X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCursor.cpp;h=70d31860f662fde0fb094a809f60eabbf2d5a24b;hb=ac3f391b46d25784f3129e24658b73c4bc15febf;hp=405d72b4f0af6bc4ea460e155b1506da528329bb;hpb=1bf7b59d60a30aed7d418cb63e9f12610635f7e6;p=lyx.git

diff --git a/src/Cursor.cpp b/src/Cursor.cpp
index 405d72b4f0..70d31860f6 100644
--- a/src/Cursor.cpp
+++ b/src/Cursor.cpp
@@ -23,9 +23,9 @@
 #include "DispatchResult.h"
 #include "Encoding.h"
 #include "Font.h"
+#include "FuncCode.h"
 #include "FuncRequest.h"
 #include "Language.h"
-#include "lfuns.h"
 #include "LyXFunc.h" // only for setMessage()
 #include "LyXRC.h"
 #include "paragraph_funcs.h"
@@ -36,6 +36,7 @@
 #include "TextMetrics.h"
 #include "TocBackend.h"
 
+#include "support/lassert.h"
 #include "support/debug.h"
 #include "support/docstream.h"
 
@@ -43,12 +44,12 @@
 #include "insets/InsetText.h"
 
 #include "mathed/InsetMath.h"
+#include "mathed/InsetMathBrace.h"
 #include "mathed/InsetMathScript.h"
 #include "mathed/MacroTable.h"
 #include "mathed/MathData.h"
 #include "mathed/MathMacro.h"
 
-#include <boost/assert.hpp>
 #include <boost/bind.hpp>
 
 #include <sstream>
@@ -133,7 +134,7 @@ DocIterator bruteFind2(Cursor const & c, int x, int y)
 bool bruteFind(Cursor & cursor,
 	int x, int y, int xlow, int xhigh, int ylow, int yhigh)
 {
-	BOOST_ASSERT(!cursor.empty());
+	LASSERT(!cursor.empty(), return false);
 	Inset & inset = cursor[0].inset();
 	BufferView & bv = cursor.bv();
 
@@ -300,12 +301,12 @@ void Cursor::dispatch(FuncRequest const & cmd0)
 	
 	// store some values to be used inside of the handlers
 	beforeDispatchCursor_ = *this;
-	for (; depth(); pop()) {
+	for (; depth(); pop(), boundary(false)) {
 		LYXERR(Debug::DEBUG, "Cursor::dispatch: cmd: "
 			<< cmd0 << endl << *this);
-		BOOST_ASSERT(pos() <= lastpos());
-		BOOST_ASSERT(idx() <= lastidx());
-		BOOST_ASSERT(pit() <= lastpit());
+		LASSERT(pos() <= lastpos(), /**/);
+		LASSERT(idx() <= lastidx(), /**/);
+		LASSERT(pit() <= lastpit(), /**/);
 
 		// The common case is 'LFUN handled, need update', so make the
 		// LFUN handler's life easier by assuming this as default value.
@@ -340,21 +341,21 @@ DispatchResult Cursor::result() const
 
 BufferView & Cursor::bv() const
 {
-	BOOST_ASSERT(bv_);
+	LASSERT(bv_, /**/);
 	return *bv_;
 }
 
 
 Buffer & Cursor::buffer() const
 {
-	BOOST_ASSERT(bv_);
+	LASSERT(bv_, /**/);
 	return bv_->buffer();
 }
 
 
 void Cursor::pop()
 {
-	BOOST_ASSERT(depth() >= 1);
+	LASSERT(depth() >= 1, /**/);
 	pop_back();
 }
 
@@ -362,12 +363,13 @@ void Cursor::pop()
 void Cursor::push(Inset & p)
 {
 	push_back(CursorSlice(p));
+	p.setBuffer(bv_->buffer());
 }
 
 
 void Cursor::pushBackward(Inset & p)
 {
-	BOOST_ASSERT(!empty());
+	LASSERT(!empty(), /**/);
 	//lyxerr << "Entering inset " << t << " front" << endl;
 	push(p);
 	p.idxFirst(*this);
@@ -376,9 +378,7 @@ void Cursor::pushBackward(Inset & p)
 
 bool Cursor::popBackward()
 {
-	BOOST_ASSERT(!empty());
-	//lyxerr << "Leaving inset from in front" << endl;
-	inset().notifyCursorLeaves(*this);
+	LASSERT(!empty(), /**/);
 	if (depth() == 1)
 		return false;
 	pop();
@@ -388,10 +388,9 @@ bool Cursor::popBackward()
 
 bool Cursor::popForward()
 {
-	BOOST_ASSERT(!empty());
+	LASSERT(!empty(), /**/);
 	//lyxerr << "Leaving inset from in back" << endl;
 	const pos_type lp = (depth() > 1) ? (*this)[depth() - 2].lastpos() : 0;
-	inset().notifyCursorLeaves(*this);
 	if (depth() == 1)
 		return false;
 	pop();
@@ -402,7 +401,7 @@ bool Cursor::popForward()
 
 int Cursor::currentMode()
 {
-	BOOST_ASSERT(!empty());
+	LASSERT(!empty(), /**/);
 	for (int i = depth() - 1; i >= 0; --i) {
 		int res = operator[](i).inset().currentMode();
 		if (res != Inset::UNDECIDED_MODE)
@@ -424,7 +423,7 @@ Row const & Cursor::textRow() const
 {
 	CursorSlice const & cs = innerTextSlice();
 	ParagraphMetrics const & pm = bv().parMetrics(cs.text(), cs.pit());
-	BOOST_ASSERT(!pm.rows().empty());
+	LASSERT(!pm.rows().empty(), /**/);
 	return pm.getRow(pos(), boundary());
 }
 
@@ -454,6 +453,188 @@ bool Cursor::posForward()
 }
 
 
+bool Cursor::posVisRight(bool skip_inset)
+{
+	Cursor new_cur = *this; // where we will move to
+	pos_type left_pos; // position visually left of current cursor
+	pos_type right_pos; // position visually right of current cursor
+	bool new_pos_is_RTL; // is new position we're moving to RTL?
+
+	getSurroundingPos(left_pos, right_pos);
+
+	LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<< pos() <<")");
+
+	// Are we at an inset?
+	new_cur.pos() = right_pos;
+	new_cur.boundary(false);
+	if (!skip_inset &&
+		text()->checkAndActivateInsetVisual(new_cur, right_pos >= pos(), false)) {
+		// we actually move the cursor at the end of this function, for now
+		// we just keep track of the new position in new_cur...
+		LYXERR(Debug::RTL, "entering inset at: " << new_cur.pos());
+	}
+
+	// Are we already at rightmost pos in row?
+	else if (text()->empty() || right_pos == -1) {
+		
+		new_cur = *this;
+		if (!new_cur.posVisToNewRow(false)) {
+			LYXERR(Debug::RTL, "not moving!");
+			return false;
+		}
+		
+		// we actually move the cursor at the end of this function, for now 
+		// just keep track of the new position in new_cur...
+		LYXERR(Debug::RTL, "right edge, moving: " << int(new_cur.pit()) << "," 
+			<< int(new_cur.pos()) << "," << (new_cur.boundary() ? 1 : 0));
+
+	}
+	// normal movement to the right
+	else {
+		new_cur = *this;
+		// Recall, if the cursor is at position 'x', that means *before* 
+		// the character at position 'x'. In RTL, "before" means "to the 
+		// right of", in LTR, "to the left of". So currently our situation
+		// is this: the position to our right is 'right_pos' (i.e., we're 
+		// currently to the left of 'right_pos'). In order to move to the 
+		// right, it depends whether or not the character at 'right_pos' is RTL.
+		new_pos_is_RTL = paragraph().getFontSettings(
+			bv().buffer().params(), right_pos).isVisibleRightToLeft();
+		// If the character at 'right_pos' *is* LTR, then in order to move to
+		// the right of it, we need to be *after* 'right_pos', i.e., move to
+		// position 'right_pos' + 1.
+		if (!new_pos_is_RTL) {
+			new_cur.pos() = right_pos + 1;
+			// set the boundary to true in two situations:
+			if (
+			// 1. if new_pos is now lastpos (which means that we're moving 
+			// right to the end of an LTR chunk which is at the end of an
+			// RTL paragraph);
+				new_cur.pos() == lastpos()
+			// 2. if the position *after* right_pos is RTL (we want to be 
+			// *after* right_pos, not before right_pos + 1!)
+				|| paragraph().getFontSettings(bv().buffer().params(),
+						new_cur.pos()).isVisibleRightToLeft()
+			)
+				new_cur.boundary(true);
+			else // set the boundary to false
+				new_cur.boundary(false);
+		}
+		// Otherwise (if the character at position 'right_pos' is RTL), then
+		// moving to the right of it is as easy as setting the new position
+		// to 'right_pos'.
+		else {
+			new_cur.pos() = right_pos;
+			new_cur.boundary(false);
+		}
+	
+	}
+
+	bool moved = (new_cur.pos() != pos()
+				  || new_cur.pit() != pit()
+				  || new_cur.boundary() != boundary());
+	
+	if (moved) {
+		LYXERR(Debug::RTL, "moving to: " << new_cur.pos() 
+			<< (new_cur.boundary() ? " (boundary)" : ""));
+		*this = new_cur;
+	}
+
+	return moved;
+}
+
+
+bool Cursor::posVisLeft(bool skip_inset)
+{
+	Cursor new_cur = *this; // where we will move to
+	pos_type left_pos; // position visually left of current cursor
+	pos_type right_pos; // position visually right of current cursor
+	bool new_pos_is_RTL; // is new position we're moving to RTL?
+
+	getSurroundingPos(left_pos, right_pos);
+
+	LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<< pos() <<")");
+
+	// Are we at an inset?
+	new_cur.pos() = left_pos;
+	new_cur.boundary(false);
+	if (!skip_inset && 
+		text()->checkAndActivateInsetVisual(new_cur, left_pos >= pos(), true)) {
+		// we actually move the cursor at the end of this function, for now 
+		// we just keep track of the new position in new_cur...
+		LYXERR(Debug::RTL, "entering inset at: " << new_cur.pos());
+	}
+
+	// Are we already at leftmost pos in row?
+	else if (text()->empty() || left_pos == -1) {
+		
+		new_cur = *this;
+		if (!new_cur.posVisToNewRow(true)) {
+			LYXERR(Debug::RTL, "not moving!");
+			return false;
+		}
+		
+		// we actually move the cursor at the end of this function, for now 
+		// just keep track of the new position in new_cur...
+		LYXERR(Debug::RTL, "left edge, moving: " << int(new_cur.pit()) << "," 
+			<< int(new_cur.pos()) << "," << (new_cur.boundary() ? 1 : 0));
+
+	}
+	// normal movement to the left
+	else {
+		new_cur = *this;
+		// Recall, if the cursor is at position 'x', that means *before* 
+		// the character at position 'x'. In RTL, "before" means "to the 
+		// right of", in LTR, "to the left of". So currently our situation
+		// is this: the position to our left is 'left_pos' (i.e., we're 
+		// currently to the right of 'left_pos'). In order to move to the 
+		// left, it depends whether or not the character at 'left_pos' is RTL.
+		new_pos_is_RTL = paragraph().getFontSettings(
+			bv().buffer().params(), left_pos).isVisibleRightToLeft();
+		// If the character at 'left_pos' *is* RTL, then in order to move to
+		// the left of it, we need to be *after* 'left_pos', i.e., move to
+		// position 'left_pos' + 1.
+		if (new_pos_is_RTL) {
+			new_cur.pos() = left_pos + 1;
+			// set the boundary to true in two situations:
+			if (
+			// 1. if new_pos is now lastpos (which means that we're moving left
+			// to the end of an RTL chunk which is at the end of an LTR 
+			// paragraph);
+				new_cur.pos() == lastpos()
+			// 2. if the position *after* left_pos is not RTL (we want to be 
+			// *after* left_pos, not before left_pos + 1!)
+				|| !paragraph().getFontSettings(bv().buffer().params(),
+						new_cur.pos()).isVisibleRightToLeft()
+			)
+				new_cur.boundary(true);
+			else // set the boundary to false
+				new_cur.boundary(false);
+		}
+		// Otherwise (if the character at position 'left_pos' is LTR), then
+		// moving to the left of it is as easy as setting the new position
+		// to 'left_pos'.
+		else {
+			new_cur.pos() = left_pos;
+			new_cur.boundary(false);
+		}
+	
+	}
+
+	bool moved = (new_cur.pos() != pos() 
+				  || new_cur.pit() != pit()
+				  || new_cur.boundary() != boundary());
+
+	if (moved) {
+		LYXERR(Debug::RTL, "moving to: " << new_cur.pos() 
+			<< (new_cur.boundary() ? " (boundary)" : ""));
+		*this = new_cur;
+	}
+		
+	return moved;
+}
+
+
 void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 {
 	// preparing bidi tables
@@ -470,6 +651,21 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 	// known position around the cursor:
 	pos_type known_pos = boundary() ? pos() - 1 : pos();
 	
+	// edge case: if we're at the end of the paragraph, things are a little 
+	// different (because lastpos is a position which does not really "exist" 
+	// --- there's no character there yet).
+	if (known_pos == lastpos()) {
+		if (par.isRTL(buf.params())) {
+			left_pos = -1;
+			right_pos = bidi.vis2log(row.pos());
+		}
+		else { // LTR paragraph
+			right_pos = -1;
+			left_pos = bidi.vis2log(row.endpos() - 1);
+		}
+		return;
+	}
+	
 	// Whether 'known_pos' is to the left or to the right of the cursor depends
 	// on whether it is an RTL or LTR character...
 	bool const cur_is_RTL = 
@@ -484,14 +680,6 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 	// determine the other one:
 	
 	if (known_pos_on_right) {
-		// edge-case: we're at the end of the paragraph, there isn't really any
-		// position any further to the right 
-		if (known_pos == lastpos()) {
-			right_pos = -1;
-			left_pos = row.endpos() - 1;
-			return;
-		}
-		// the normal case
 		right_pos = known_pos;
 		// *visual* position of 'left_pos':
 		pos_type v_left_pos = bidi.log2vis(right_pos) - 1;
@@ -524,14 +712,6 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 		}
 	} 
 	else { // known_pos is on the left
-		// edge-case: we're at the end of the paragraph, there isn't really any
-		// position any further to the left
-		if (known_pos == lastpos()) {
-			left_pos = -1;
-			right_pos = row.endpos() - 1;
-			return;
-		}
-		// the normal case
 		left_pos = known_pos;
 		// *visual* position of 'right_pos'
 		pos_type v_right_pos = bidi.log2vis(left_pos) + 1;
@@ -569,6 +749,14 @@ bool Cursor::posVisToNewRow(bool movingLeft)
 	Buffer const & buf = buffer();
 	Row const & row = textRow();
 	bool par_is_LTR = !par.isRTL(buf.params());
+
+	// Inside a table, determining whether to move to the next or previous row
+	// should be done based on the table's direction. 
+	int s = depth() - 1;
+	if (s >= 1 && (*this)[s].inset().asInsetTabular()) {
+		par_is_LTR = !(*this)[s].inset().asInsetTabular()->isRightToLeft(*this);
+		LYXERR(Debug::RTL, "Inside table! par_is_LTR=" << (par_is_LTR ? 1 : 0));
+	}
 	
 	// if moving left in an LTR paragraph or moving right in an RTL one, 
 	// move to previous row
@@ -726,7 +914,7 @@ void Cursor::posVisToRowExtremity(bool left)
 
 CursorSlice Cursor::anchor() const
 {
-	BOOST_ASSERT(anchor_.depth() >= depth());
+	LASSERT(anchor_.depth() >= depth(), /**/);
 	CursorSlice normal = anchor_[depth() - 1];
 	if (depth() < anchor_.depth() && top() <= normal) {
 		// anchor is behind cursor -> move anchor behind the inset
@@ -780,7 +968,9 @@ void Cursor::setSelection()
 	selection() = true;
 	// A selection with no contents is not a selection
 	// FIXME: doesnt look ok
-	if (pit() == anchor().pit() && pos() == anchor().pos())
+	if (idx() == anchor().idx() && 
+	    pit() == anchor().pit() && 
+	    pos() == anchor().pos())
 		selection() = false;
 }
 
@@ -989,6 +1179,8 @@ void Cursor::plainInsert(MathAtom const & t)
 {
 	cell().insert(pos(), t);
 	++pos();
+	inset().setBuffer(bv_->buffer());
+	inset().initView();
 }
 
 
@@ -1003,7 +1195,7 @@ void Cursor::insert(docstring const & str)
 void Cursor::insert(char_type c)
 {
 	//lyxerr << "Cursor::insert char '" << c << "'" << endl;
-	BOOST_ASSERT(!empty());
+	LASSERT(!empty(), /**/);
 	if (inMathed()) {
 		cap::selClearOrDel(*this);
 		insert(new InsetMathChar(c));
@@ -1022,12 +1214,16 @@ void Cursor::insert(MathAtom const & t)
 }
 
 
-void Cursor::insert(Inset * inset)
+void Cursor::insert(Inset * inset0)
 {
+	LASSERT(inset0, /**/);
 	if (inMathed())
-		insert(MathAtom(inset));
-	else
-		text()->insertInset(*this, inset);
+		insert(MathAtom(inset0));
+	else {
+		text()->insertInset(*this, inset0);
+		inset0->setBuffer(bv_->buffer());
+		inset0->initView();
+	}
 }
 
 
@@ -1205,6 +1401,8 @@ bool Cursor::macroModeClose()
 		return false;
 	InsetMathUnknown * p = activeMacro();
 	p->finalize();
+	MathData selection;
+	asArray(p->selection(), selection);
 	docstring const s = p->name();
 	--pos();
 	cell().erase(pos());
@@ -1222,12 +1420,37 @@ bool Cursor::macroModeClose()
 	if (in && in->interpretString(*this, s))
 		return true;
 	MathAtom atom = createInsetMath(name);
+
+	// try to put argument into macro, if we just inserted a macro
+	bool macroArg = false;
 	MathMacro * atomAsMacro = atom.nucleus()->asMacro();
 	if (atomAsMacro) {
-		// make non-greedy, i.e. don't eat parameters from the right
-		atomAsMacro->setDisplayMode(MathMacro::DISPLAY_INTERACTIVE_INIT);
+		// macros here are still unfolded (in init mode in fact). So
+		// we have to resolve the macro here manually and check its arity
+		// to put the selection behind it if arity > 0.
+		MacroData const * data = buffer().getMacro(atomAsMacro->name());
+		if (selection.size() > 0 && data && data->numargs() - data->optionals() > 0) {
+			macroArg = true;
+			atomAsMacro->setDisplayMode(MathMacro::DISPLAY_INTERACTIVE_INIT, 1);
+		} else
+			// non-greedy case. Do not touch the arguments behind
+			atomAsMacro->setDisplayMode(MathMacro::DISPLAY_INTERACTIVE_INIT, 0);
 	}
+
+	// insert remembered selection into first argument of a non-macro
+	else if (atom.nucleus()->nargs() > 0)
+		atom.nucleus()->cell(0).append(selection);
+	
 	plainInsert(atom);
+
+	// finally put the macro argument behind, if needed
+	if (macroArg) {
+		if (selection.size() > 1)
+			plainInsert(MathAtom(new InsetMathBrace(selection)));
+		else
+			insert(selection);
+	}
+	
 	return true;
 }
 
@@ -1338,7 +1561,7 @@ void Cursor::normalize()
 			<< pos() << ' ' << lastpos() <<  " in idx: " << idx()
 		       << " in atom: '";
 		odocstringstream os;
-		WriteStream wi(os, false, true);
+		WriteStream wi(os, false, true, false);
 		inset().asInsetMath()->write(wi);
 		lyxerr << to_utf8(os.str()) << endl;
 		pos() = lastpos();
@@ -1464,7 +1687,7 @@ bool Cursor::upDownInMath(bool up)
 
 bool Cursor::upDownInText(bool up, bool & updateNeeded)
 {
-	BOOST_ASSERT(text());
+	LASSERT(text(), /**/);
 
 	// where are we?
 	int xo = 0;
@@ -1523,7 +1746,7 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded)
 		if (pit() + 1 >= int(text()->paragraphs().size()) &&
 				row + 1 >= int(pm.rows().size()))
 			return false;
-	}	
+	}
 
 	// with and without selection are handled differently
 	if (!selection()) {
@@ -1556,7 +1779,10 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded)
 				top().pos() = min(tm.x2pos(pit(), row - 1, xo), top().lastpos());
 			} else if (pit() > 0) {
 				--pit();
-				ParagraphMetrics const & pmcur = bv_->parMetrics(text(), pit());
+				TextMetrics & tm = bv_->textMetrics(text());
+				if (!tm.contains(pit()))
+					tm.newParMetricsUp();
+				ParagraphMetrics const & pmcur = tm.parMetrics(pit());
 				top().pos() = min(tm.x2pos(pit(), pmcur.rows().size() - 1, xo), top().lastpos());
 			}
 		} else {
@@ -1564,6 +1790,9 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded)
 				top().pos() = min(tm.x2pos(pit(), row + 1, xo), top().lastpos());
 			} else if (pit() + 1 < int(text()->paragraphs().size())) {
 				++pit();
+				TextMetrics & tm = bv_->textMetrics(text());
+				if (!tm.contains(pit()))
+					tm.newParMetricsDown();
 				top().pos() = min(tm.x2pos(pit(), 0, xo), top().lastpos());
 			}
 		}
@@ -1623,38 +1852,48 @@ void Cursor::errorMessage(docstring const & msg) const
 }
 
 
-docstring Cursor::selectionAsString(bool label) const
+docstring Cursor::selectionAsString(bool with_label) const
 {
 	if (!selection())
 		return docstring();
 
+	int const label = with_label
+		? AS_STR_LABEL | AS_STR_INSETS : AS_STR_INSETS;
+
 	if (inTexted()) {
-		Buffer const & buffer = bv().buffer();
+		idx_type const startidx = selBegin().idx();
+		idx_type const endidx = selEnd().idx();
+		if (startidx != endidx) {
+			// multicell selection
+			InsetTabular * table = inset().asInsetTabular();
+			LASSERT(table, return docstring());
+			return table->asString(startidx, endidx);
+		}
+		
 		ParagraphList const & pars = text()->paragraphs();
 
-		// should be const ...
-		pit_type startpit = selBegin().pit();
-		pit_type endpit = selEnd().pit();
+		pit_type const startpit = selBegin().pit();
+		pit_type const endpit = selEnd().pit();
 		size_t const startpos = selBegin().pos();
 		size_t const endpos = selEnd().pos();
 
 		if (startpit == endpit)
-			return pars[startpit].asString(buffer, startpos, endpos, label);
+			return pars[startpit].asString(startpos, endpos, label);
 
 		// First paragraph in selection
 		docstring result = pars[startpit].
-			asString(buffer, startpos, pars[startpit].size(), label)
+			asString(startpos, pars[startpit].size(), label)
 				 + parbreak(pars[startpit]);
 
 		// The paragraphs in between (if any)
 		for (pit_type pit = startpit + 1; pit != endpit; ++pit) {
 			Paragraph const & par = pars[pit];
-			result += par.asString(buffer, 0, par.size(), label)
+			result += par.asString(0, par.size(), label)
 				  + parbreak(pars[pit]);
 		}
 
 		// Last paragraph in selection
-		result += pars[endpit].asString(buffer, 0, endpos, label);
+		result += pars[endpit].asString(0, endpos, label);
 
 		return result;
 	}
@@ -1666,7 +1905,7 @@ docstring Cursor::selectionAsString(bool label) const
 }
 
 
-docstring Cursor::currentState()
+docstring Cursor::currentState() const
 {
 	if (inMathed()) {
 		odocstringstream os;
@@ -1681,7 +1920,7 @@ docstring Cursor::currentState()
 }
 
 
-docstring Cursor::getPossibleLabel()
+docstring Cursor::getPossibleLabel() const
 {
 	return inMathed() ? from_ascii("eq:") : text()->getPossibleLabel(*this);
 }
@@ -1761,14 +2000,13 @@ bool Cursor::fixIfBroken()
 {
 	if (DocIterator::fixIfBroken()) {
 			clearSelection();
-			resetAnchor();
 			return true;
 	}
 	return false;
 }
 
 
-bool notifyCursorLeaves(DocIterator const & old, Cursor & cur)
+bool notifyCursorLeaves(Cursor const & old, Cursor & cur)
 {
 	// find inset in common
 	size_type i;
@@ -1776,11 +2014,22 @@ bool notifyCursorLeaves(DocIterator const & old, Cursor & cur)
 		if (&old[i].inset() != &cur[i].inset())
 			break;
 	}
+
+	// update words if we just moved to another paragraph
+	if (i == old.depth() && i == cur.depth()
+	    && !cur.buffer().isClean()
+	    && cur.inTexted() && old.inTexted()
+	    && cur.pit() != old.pit()) {
+		old.paragraph().updateWords(old.top());
+		return false;
+	}
 	
 	// notify everything on top of the common part in old cursor,
 	// but stop if the inset claims the cursor to be invalid now
 	for (; i < old.depth(); ++i) {
-		if (old[i].inset().notifyCursorLeaves(cur))
+		Cursor insetPos = old;
+		insetPos.cutOff(i);
+		if (old[i].inset().notifyCursorLeaves(insetPos, cur))
 			return true;
 	}
 	
@@ -1819,7 +2068,7 @@ void Cursor::setCurrentFont()
 	// get font
 	BufferParams const & bufparams = buffer().params();
 	current_font = par.getFontSettings(bufparams, cpos);
-	real_current_font = tm.getDisplayFont(cpit, cpos);
+	real_current_font = tm.displayFont(cpit, cpos);
 
 	// special case for paragraph end
 	if (cs.pos() == lastpos()
@@ -1842,8 +2091,7 @@ bool Cursor::textUndo()
 		return false;
 	// Set cursor
 	setCursor(dit);
-	selection() = false;
-	resetAnchor();
+	clearSelection();
 	fixIfBroken();
 	return true;
 }
@@ -1857,59 +2105,76 @@ bool Cursor::textRedo()
 		return false;
 	// Set cursor
 	setCursor(dit);
-	selection() = false;
-	resetAnchor();
+	clearSelection();
 	fixIfBroken();
 	return true;
 }
 
 
-void Cursor::finishUndo()
+void Cursor::finishUndo() const
 {
 	bv_->buffer().undo().finishUndo();
 }
 
 
-void Cursor::recordUndo(UndoKind kind, pit_type from, pit_type to)
+void Cursor::beginUndoGroup() const
+{
+	bv_->buffer().undo().beginUndoGroup();
+}
+
+
+void Cursor::endUndoGroup() const
+{
+	bv_->buffer().undo().endUndoGroup();
+}
+
+
+void Cursor::recordUndo(UndoKind kind, pit_type from, pit_type to) const
 {
 	bv_->buffer().undo().recordUndo(*this, kind, from, to);
 }
 
 
-void Cursor::recordUndo(UndoKind kind, pit_type from)
+void Cursor::recordUndo(UndoKind kind, pit_type from) const
 {
 	bv_->buffer().undo().recordUndo(*this, kind, from);
 }
 
 
-void Cursor::recordUndo(UndoKind kind)
+void Cursor::recordUndo(UndoKind kind) const
 {
 	bv_->buffer().undo().recordUndo(*this, kind);
 }
 
 
-void Cursor::recordUndoInset(UndoKind kind)
+void Cursor::recordUndoInset(UndoKind kind) const
 {
 	bv_->buffer().undo().recordUndoInset(*this, kind);
 }
 
 
-void Cursor::recordUndoFullDocument()
+void Cursor::recordUndoFullDocument() const
 {
 	bv_->buffer().undo().recordUndoFullDocument(*this);
 }
 
 
-void Cursor::recordUndoSelection()
+void Cursor::recordUndoSelection() const
 {
-	bv_->buffer().undo().recordUndo(*this, ATOMIC_UNDO,
-		selBegin().pit(), selEnd().pit());
+	if (inMathed()) {
+		if (cap::multipleCellsSelected(*this))
+			recordUndoInset();
+		else
+			recordUndo();
+	} else
+		bv_->buffer().undo().recordUndo(*this, ATOMIC_UNDO,
+			selBegin().pit(), selEnd().pit());
 }
 
 
 void Cursor::checkBufferStructure()
 {
-	if (paragraph().layout()->toclevel == Layout::NOT_IN_TOC)
+	if (paragraph().layout().toclevel == Layout::NOT_IN_TOC)
 		return;
 	Buffer const * master = buffer().masterBuffer();
 	master->tocBackend().updateItem(ParConstIterator(*this));