X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCursor.cpp;h=7232e88e0f14f0a2837a90d8d9ad13d760c8d5bd;hb=24fe5b08c0e1dfb739738acb6fc995da7315d35f;hp=05dfc5b9d3c45d22a2612d2e9cd0197c66459574;hpb=00d6906d04a9f5738adbf21e1a1ae6d747b7ddb7;p=lyx.git

diff --git a/src/Cursor.cpp b/src/Cursor.cpp
index 05dfc5b9d3..7232e88e0f 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();
 
@@ -248,13 +249,13 @@ bool bruteFind3(Cursor & cur, int x, int y, bool up)
 
 docstring parbreak(Paragraph const & par)
 {
-	odocstringstream ods;
-	ods << '\n';
+	odocstringstream os;
+	os << '\n';
 	// only add blank line if we're not in an ERT or Listings inset
 	if (par.ownerCode() != ERT_CODE
 			&& par.ownerCode() != LISTINGS_CODE)
-		ods << '\n';
-	return ods.str();
+		os << '\n';
+	return os.str();
 }
 
 } // namespace anon
@@ -303,9 +304,9 @@ void Cursor::dispatch(FuncRequest const & cmd0)
 	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();
 }
 
@@ -368,7 +369,7 @@ void Cursor::push(Inset & p)
 
 void Cursor::pushBackward(Inset & p)
 {
-	BOOST_ASSERT(!empty());
+	LASSERT(!empty(), /**/);
 	//lyxerr << "Entering inset " << t << " front" << endl;
 	push(p);
 	p.idxFirst(*this);
@@ -377,7 +378,7 @@ void Cursor::pushBackward(Inset & p)
 
 bool Cursor::popBackward()
 {
-	BOOST_ASSERT(!empty());
+	LASSERT(!empty(), /**/);
 	if (depth() == 1)
 		return false;
 	pop();
@@ -387,7 +388,7 @@ 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;
 	if (depth() == 1)
@@ -400,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)
@@ -422,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());
 }
 
@@ -452,6 +453,190 @@ 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, and we're in an RTL paragraph
+			// (this 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()
+				 && paragraph().isRTL(buffer().params()))
+			// 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 and we're in an LTR paragraph
+			// (this 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()
+				 && !paragraph().isRTL(buffer().params()))
+			// 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
@@ -566,6 +751,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
@@ -723,7 +916,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
@@ -753,7 +946,14 @@ DocIterator Cursor::selectionBegin() const
 {
 	if (!selection())
 		return *this;
-	DocIterator di = (anchor() < top() ? anchor_ : *this);
+
+	DocIterator di;
+	// FIXME: This is a work-around for the problem that
+	// CursorSlice doesn't keep track of the boundary.
+	if (anchor() == top())
+		di = anchor_.boundary() > boundary() ? anchor_ : *this;
+	else
+		di = anchor() < top() ? anchor_ : *this;
 	di.resize(depth());
 	return di;
 }
@@ -763,7 +963,15 @@ DocIterator Cursor::selectionEnd() const
 {
 	if (!selection())
 		return *this;
-	DocIterator di = (anchor() > top() ? anchor_ : *this);
+
+	DocIterator di;
+	// FIXME: This is a work-around for the problem that
+	// CursorSlice doesn't keep track of the boundary.
+	if (anchor() == top())
+		di = anchor_.boundary() < boundary() ? anchor_ : *this;
+	else
+		di = anchor() > top() ? anchor_ : *this;
+
 	if (di.depth() > depth()) {
 		di.resize(depth());
 		++di.pos();
@@ -774,18 +982,20 @@ DocIterator Cursor::selectionEnd() const
 
 void Cursor::setSelection()
 {
-	selection() = true;
+	setSelection(true);
 	// A selection with no contents is not a selection
 	// FIXME: doesnt look ok
-	if (pit() == anchor().pit() && pos() == anchor().pos())
-		selection() = false;
+	if (idx() == anchor().idx() && 
+	    pit() == anchor().pit() && 
+	    pos() == anchor().pos())
+		setSelection(false);
 }
 
 
 void Cursor::setSelection(DocIterator const & where, int n)
 {
 	setCursor(where);
-	selection() = true;
+	setSelection(true);
 	anchor_ = where;
 	pos() += n;
 }
@@ -793,8 +1003,8 @@ void Cursor::setSelection(DocIterator const & where, int n)
 
 void Cursor::clearSelection()
 {
-	selection() = false;
-	mark() = false;
+	setSelection(false);
+	setMark(false);
 	resetAnchor();
 }
 
@@ -857,7 +1067,7 @@ bool Cursor::selHandle(bool sel)
 		cap::saveSelection(*this);
 
 	resetAnchor();
-	selection() = sel;
+	setSelection(sel);
 	return true;
 }
 
@@ -986,6 +1196,8 @@ void Cursor::plainInsert(MathAtom const & t)
 {
 	cell().insert(pos(), t);
 	++pos();
+	inset().setBuffer(bv_->buffer());
+	inset().initView();
 }
 
 
@@ -1000,7 +1212,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));
@@ -1021,20 +1233,21 @@ void Cursor::insert(MathAtom const & t)
 
 void Cursor::insert(Inset * inset0)
 {
-	BOOST_ASSERT(inset0);
+	LASSERT(inset0, /**/);
 	if (inMathed())
 		insert(MathAtom(inset0));
-	else
+	else {
 		text()->insertInset(*this, inset0);
-	inset().setBuffer(bv_->buffer());
-	inset().validate();
+		inset0->setBuffer(bv_->buffer());
+		inset0->initView();
+	}
 }
 
 
-void Cursor::niceInsert(docstring const & t)
+void Cursor::niceInsert(docstring const & t, Parse::flags f)
 {
 	MathData ar;
-	asArray(t, ar);
+	asArray(t, ar, f);
 	if (ar.size() == 1)
 		niceInsert(ar[0]);
 	else
@@ -1113,7 +1326,7 @@ bool Cursor::backspace()
 		// let's require two backspaces for 'big stuff' and
 		// highlight on the first
 		resetAnchor();
-		selection() = true;
+		setSelection(true);
 		--pos();
 	} else {
 		--pos();
@@ -1161,7 +1374,7 @@ bool Cursor::erase()
 	// 'clever' UI hack: only erase large items if previously slected
 	if (pos() != lastpos() && nextAtom()->nargs() > 0) {
 		resetAnchor();
-		selection() = true;
+		setSelection(true);
 		++pos();
 	} else {
 		plainErase();
@@ -1205,6 +1418,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 +1437,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 +1578,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 +1704,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 +1763,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 +1796,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 +1807,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());
 			}
 		}
@@ -1585,6 +1831,8 @@ void Cursor::handleFont(string const & font)
 		safe = cap::grabAndEraseSelection(*this);
 	}
 
+	recordUndoInset();
+
 	if (lastpos() != 0) {
 		// something left in the cell
 		if (pos() == 0) {
@@ -1604,8 +1852,9 @@ void Cursor::handleFont(string const & font)
 		}
 	} else {
 		// nothing left in the cell
-		pullArg();
+		popBackward();
 		plainErase();
+		resetAnchor();
 	}
 	insert(safe);
 }
@@ -1623,17 +1872,28 @@ 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()) {
+		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();
 
@@ -1665,7 +1925,7 @@ docstring Cursor::selectionAsString(bool label) const
 }
 
 
-docstring Cursor::currentState()
+docstring Cursor::currentState() const
 {
 	if (inMathed()) {
 		odocstringstream os;
@@ -1680,7 +1940,7 @@ docstring Cursor::currentState()
 }
 
 
-docstring Cursor::getPossibleLabel()
+docstring Cursor::getPossibleLabel() const
 {
 	return inMathed() ? from_ascii("eq:") : text()->getPossibleLabel(*this);
 }
@@ -1760,7 +2020,6 @@ bool Cursor::fixIfBroken()
 {
 	if (DocIterator::fixIfBroken()) {
 			clearSelection();
-			resetAnchor();
 			return true;
 	}
 	return false;
@@ -1781,7 +2040,7 @@ bool notifyCursorLeaves(Cursor const & old, Cursor & cur)
 	    && !cur.buffer().isClean()
 	    && cur.inTexted() && old.inTexted()
 	    && cur.pit() != old.pit()) {
-		old.paragraph().updateWords(old.buffer(), old.top());
+		old.paragraph().updateWords(old.top());
 		return false;
 	}
 	
@@ -1852,8 +2111,7 @@ bool Cursor::textUndo()
 		return false;
 	// Set cursor
 	setCursor(dit);
-	selection() = false;
-	resetAnchor();
+	clearSelection();
 	fixIfBroken();
 	return true;
 }
@@ -1867,63 +2125,77 @@ 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)
-		return;
 	Buffer const * master = buffer().masterBuffer();
-	master->tocBackend().updateItem(ParConstIterator(*this));
-	master->structureChanged();
+	master->tocBackend().updateItem(*this);
 }