X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCursor.cpp;h=afa8a9b30ffaa5ad36db6cccd198fe5405b51645;hb=823e44822e6638824900eee2f7e2e7165af97f8d;hp=b385f025a128175f7cd2942231ec629d29b9ad60;hpb=ffda0d89b444a6f7814df8db3f311e2a42edda9d;p=lyx.git

diff --git a/src/Cursor.cpp b/src/Cursor.cpp
index b385f025a1..afa8a9b30f 100644
--- a/src/Cursor.cpp
+++ b/src/Cursor.cpp
@@ -6,7 +6,7 @@
  * \author Alejandro Aguilar Sierra
  * \author Alfredo Braunstein
  * \author Dov Feldstern
- * \author André Pönitz
+ * \author André Pönitz
  * \author Stefan Schimanski
  *
  * Full author contact details are available in file CREDITS.
@@ -205,10 +205,9 @@ bool bruteFind3(Cursor & cur, int x, int y, bool up)
 	//	<< " xlow: " << xlow << " xhigh: " << xhigh
 	//	<< " ylow: " << ylow << " yhigh: " << yhigh
 	//	<< endl;
-	Inset & inset = bv.buffer().inset();
-	DocIterator it = doc_iterator_begin(inset);
+	DocIterator it = doc_iterator_begin(cur.buffer());
 	it.pit() = from;
-	DocIterator et = doc_iterator_end(inset);
+	DocIterator et = doc_iterator_end(cur.buffer());
 
 	double best_dist = numeric_limits<double>::max();
 	DocIterator best_cursor = et;
@@ -249,13 +248,12 @@ 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();
+	if (par.ownerCode() != ERT_CODE && par.ownerCode() != LISTINGS_CODE)
+		os << '\n';
+	return os.str();
 }
 
 } // namespace anon
@@ -264,7 +262,8 @@ docstring parbreak(Paragraph const & par)
 // be careful: this is called from the bv's constructor, too, so
 // bv functions are not yet available!
 Cursor::Cursor(BufferView & bv)
-	: DocIterator(), bv_(&bv), anchor_(), x_target_(-1), textTargetOffset_(0),
+	: DocIterator(&bv.buffer()), bv_(&bv), anchor_(),
+	  x_target_(-1), textTargetOffset_(0),
 	  selection_(false), mark_(false), logicalpos_(false),
 	  current_font(inherit_font)
 {}
@@ -274,7 +273,7 @@ void Cursor::reset(Inset & inset)
 {
 	clear();
 	push_back(CursorSlice(inset));
-	anchor_ = doc_iterator_begin(inset);
+	anchor_ = doc_iterator_begin(&inset.buffer(), &inset);
 	anchor_.clear();
 	clearTargetX();
 	selection_ = false;
@@ -346,13 +345,6 @@ BufferView & Cursor::bv() const
 }
 
 
-Buffer & Cursor::buffer() const
-{
-	LASSERT(bv_, /**/);
-	return bv_->buffer();
-}
-
-
 void Cursor::pop()
 {
 	LASSERT(depth() >= 1, /**/);
@@ -363,13 +355,13 @@ void Cursor::pop()
 void Cursor::push(Inset & p)
 {
 	push_back(CursorSlice(p));
-	p.setBuffer(bv_->buffer());
+	p.setBuffer(*buffer());
 }
 
 
 void Cursor::pushBackward(Inset & p)
 {
-	LASSERT(!empty(), /**/);
+	LASSERT(!empty(), return);
 	//lyxerr << "Entering inset " << t << " front" << endl;
 	push(p);
 	p.idxFirst(*this);
@@ -378,7 +370,7 @@ void Cursor::pushBackward(Inset & p)
 
 bool Cursor::popBackward()
 {
-	LASSERT(!empty(), /**/);
+	LASSERT(!empty(), return false);
 	if (depth() == 1)
 		return false;
 	pop();
@@ -388,7 +380,7 @@ bool Cursor::popBackward()
 
 bool Cursor::popForward()
 {
-	LASSERT(!empty(), /**/);
+	LASSERT(!empty(), return false);
 	//lyxerr << "Leaving inset from in back" << endl;
 	const pos_type lp = (depth() > 1) ? (*this)[depth() - 2].lastpos() : 0;
 	if (depth() == 1)
@@ -434,6 +426,12 @@ void Cursor::resetAnchor()
 }
 
 
+void Cursor::setCursorToAnchor()
+{
+	if (selection())
+		setCursor(anchor_);
+}
+
 
 bool Cursor::posBackward()
 {
@@ -468,7 +466,7 @@ bool Cursor::posVisRight(bool skip_inset)
 	new_cur.pos() = right_pos;
 	new_cur.boundary(false);
 	if (!skip_inset &&
-		text()->checkAndActivateInsetVisual(new_cur, right_pos>=pos(), false)) {
+		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());
@@ -499,7 +497,7 @@ bool Cursor::posVisRight(bool skip_inset)
 		// 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();
+			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.
@@ -507,13 +505,14 @@ bool Cursor::posVisRight(bool skip_inset)
 			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()
+			// 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(),
+				|| paragraph().getFontSettings(buffer()->params(),
 						new_cur.pos()).isVisibleRightToLeft()
 			)
 				new_cur.boundary(true);
@@ -532,7 +531,8 @@ bool Cursor::posVisRight(bool skip_inset)
 
 	bool moved = (new_cur.pos() != pos()
 				  || new_cur.pit() != pit()
-				  || new_cur.boundary() != boundary());
+				  || new_cur.boundary() != boundary()
+				  || &new_cur.inset() != &inset());
 	
 	if (moved) {
 		LYXERR(Debug::RTL, "moving to: " << new_cur.pos() 
@@ -590,7 +590,7 @@ bool Cursor::posVisLeft(bool skip_inset)
 		// 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();
+			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.
@@ -598,13 +598,14 @@ bool Cursor::posVisLeft(bool skip_inset)
 			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()
+			// 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(),
+				|| !paragraph().getFontSettings(buffer()->params(),
 						new_cur.pos()).isVisibleRightToLeft()
 			)
 				new_cur.boundary(true);
@@ -639,7 +640,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 {
 	// preparing bidi tables
 	Paragraph const & par = paragraph();
-	Buffer const & buf = buffer();
+	Buffer const & buf = *buffer();
 	Row const & row = textRow();
 	Bidi bidi;
 	bidi.computeTables(par, buf, row);
@@ -649,7 +650,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 	// The cursor is painted *before* the character at pos(), or, if 'boundary'
 	// is true, *after* the character at (pos() - 1). So we already have one
 	// known position around the cursor:
-	pos_type known_pos = boundary() ? pos() - 1 : pos();
+	pos_type const known_pos = boundary() && pos() > 0 ? 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" 
@@ -658,8 +659,8 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 		if (par.isRTL(buf.params())) {
 			left_pos = -1;
 			right_pos = bidi.vis2log(row.pos());
-		}
-		else { // LTR paragraph
+		} else { 
+			// LTR paragraph
 			right_pos = -1;
 			left_pos = bidi.vis2log(row.endpos() - 1);
 		}
@@ -674,11 +675,10 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 	// For an RTL character, "before" means "to the right" and "after" means
 	// "to the left"; and for LTR, it's the reverse. So, 'known_pos' is to the
 	// right of the cursor if (RTL && boundary) or (!RTL && !boundary):
-	bool known_pos_on_right = (cur_is_RTL == boundary());
+	bool const known_pos_on_right = cur_is_RTL == boundary();
 
 	// So we now know one of the positions surrounding the cursor. Let's 
-	// determine the other one:
-	
+	// determine the other one:	
 	if (known_pos_on_right) {
 		right_pos = known_pos;
 		// *visual* position of 'left_pos':
@@ -692,9 +692,9 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 		if (bidi.inRange(v_left_pos) 
 				&& bidi.vis2log(v_left_pos) + 1 == row.endpos() 
 				&& row.endpos() < lastpos()
-				&& par.isSeparator(bidi.vis2log(v_left_pos))) {
+				&& par.isSeparator(bidi.vis2log(v_left_pos)))
 			--v_left_pos;
-		}
+
 		// calculate the logical position of 'left_pos', if in row
 		if (!bidi.inRange(v_left_pos))
 			left_pos = -1;
@@ -704,14 +704,14 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 		// separator", set 'right_pos' to the *next* position to the right.
 		if (right_pos + 1 == row.endpos() && row.endpos() < lastpos() 
 				&& par.isSeparator(right_pos)) {
-			pos_type v_right_pos = bidi.log2vis(right_pos) + 1;
+			pos_type const v_right_pos = bidi.log2vis(right_pos) + 1;
 			if (!bidi.inRange(v_right_pos))
 				right_pos = -1;
 			else
 				right_pos = bidi.vis2log(v_right_pos);
 		}
-	} 
-	else { // known_pos is on the left
+	} else { 
+		// known_pos is on the left
 		left_pos = known_pos;
 		// *visual* position of 'right_pos'
 		pos_type v_right_pos = bidi.log2vis(left_pos) + 1;
@@ -720,9 +720,9 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 		if (bidi.inRange(v_right_pos) 
 				&& bidi.vis2log(v_right_pos) + 1 == row.endpos() 
 				&& row.endpos() < lastpos()
-				&& par.isSeparator(bidi.vis2log(v_right_pos))) {
+				&& par.isSeparator(bidi.vis2log(v_right_pos)))
 			++v_right_pos;
-		}
+
 		// calculate the logical position of 'right_pos', if in row
 		if (!bidi.inRange(v_right_pos)) 
 			right_pos = -1;
@@ -732,7 +732,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 		// separator", set 'left_pos' to the *next* position to the left.
 		if (left_pos + 1 == row.endpos() && row.endpos() < lastpos() 
 				&& par.isSeparator(left_pos)) {
-			pos_type v_left_pos = bidi.log2vis(left_pos) - 1;
+			pos_type const v_left_pos = bidi.log2vis(left_pos) - 1;
 			if (!bidi.inRange(v_left_pos))
 				left_pos = -1;
 			else
@@ -746,7 +746,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos)
 bool Cursor::posVisToNewRow(bool movingLeft)
 {
 	Paragraph const & par = paragraph();
-	Buffer const & buf = buffer();
+	Buffer const & buf = *buffer();
 	Row const & row = textRow();
 	bool par_is_LTR = !par.isRTL(buf.params());
 
@@ -800,7 +800,7 @@ void Cursor::posVisToRowExtremity(bool left)
 {
 	// prepare bidi tables
 	Paragraph const & par = paragraph();
-	Buffer const & buf = buffer();
+	Buffer const & buf = *buffer();
 	Row const & row = textRow();
 	Bidi bidi;
 	bidi.computeTables(par, buf, row);
@@ -839,32 +839,31 @@ void Cursor::posVisToRowExtremity(bool left)
 			// this non-separator-but-last-position-in-row is an inset, then
 			// we *do* want to stay to the left of it anyway: this is the 
 			// "boundary" which we simulate at insets.
+			// Another exception is when row.endpos() is 0.
 			
-			bool right_of_pos = false; // do we want to be to the right of pos?
-
+			// do we want to be to the right of pos?
 			// as explained above, if at last pos in row, stay to the right
-			if ((pos() == row.endpos() - 1) && !par.isInset(pos()))
-				right_of_pos = true;
+			bool const right_of_pos = row.endpos() > 0
+				&& pos() == row.endpos() - 1 && !par.isInset(pos());
 
 			// Now we know if we want to be to the left or to the right of pos,
 			// let's make sure we are where we want to be.
-			bool new_pos_is_RTL = 
+			bool const new_pos_is_RTL = 
 				par.getFontSettings(buf.params(), pos()).isVisibleRightToLeft();
 
-			if (new_pos_is_RTL == !right_of_pos) {
+			if (new_pos_is_RTL != right_of_pos) {
 				++pos();
 				boundary(true);
 			}
-			
 		}
-	}
-	else { // move to rightmost position
+	} else { 
+		// move to rightmost position
 		// if this is an LTR paragraph, and we're at the last row in the
 		// paragraph, move to lastpos
 		if (!par.isRTL(buf.params()) && row.endpos() == lastpos())
 			pos() = lastpos();
 		else {
-			pos() = bidi.vis2log(row.endpos() - 1);
+			pos() = row.endpos() > 0 ? bidi.vis2log(row.endpos() - 1) : 0;
 
 			// Moving to the rightmost position in the row, the cursor should
 			// normally be placed to the *right* of the rightmost position.
@@ -889,16 +888,17 @@ void Cursor::posVisToRowExtremity(bool left)
 			// this non-separator-but-last-position-in-row is an inset, then
 			// we *do* want to stay to the right of it anyway: this is the 
 			// "boundary" which we simulate at insets.
+			// Another exception is when row.endpos() is 0.
 			
-			bool left_of_pos = false; // do we want to be to the left of pos?
-
-			// as explained above, if at last pos in row, stay to the left
-			if ((pos() == row.endpos() - 1) && !par.isInset(pos()))
-				left_of_pos = true;
+			// do we want to be to the left of pos?
+			// as explained above, if at last pos in row, stay to the left,
+			// unless the last position is the same as the first.
+			bool const left_of_pos = row.endpos() > 0
+				&& pos() == row.endpos() - 1 && !par.isInset(pos());
 
 			// Now we know if we want to be to the left or to the right of pos,
 			// let's make sure we are where we want to be.
-			bool new_pos_is_RTL = 
+			bool const new_pos_is_RTL = 
 				par.getFontSettings(buf.params(), pos()).isVisibleRightToLeft();
 
 			if (new_pos_is_RTL == left_of_pos) {
@@ -944,7 +944,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;
 }
@@ -954,7 +961,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();
@@ -965,18 +980,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;
 }
@@ -984,8 +1001,8 @@ void Cursor::setSelection(DocIterator const & where, int n)
 
 void Cursor::clearSelection()
 {
-	selection() = false;
-	mark() = false;
+	setSelection(false);
+	setMark(false);
 	resetAnchor();
 }
 
@@ -1048,7 +1065,7 @@ bool Cursor::selHandle(bool sel)
 		cap::saveSelection(*this);
 
 	resetAnchor();
-	selection() = sel;
+	setSelection(sel);
 	return true;
 }
 
@@ -1225,10 +1242,10 @@ void Cursor::insert(Inset * inset0)
 }
 
 
-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
@@ -1307,7 +1324,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();
@@ -1355,7 +1372,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();
@@ -1426,7 +1443,7 @@ bool Cursor::macroModeClose()
 		// 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());
+		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);
@@ -1559,7 +1576,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();
@@ -1683,6 +1700,28 @@ bool Cursor::upDownInMath(bool up)
 }
 
 
+bool Cursor::atFirstOrLastRow(bool up)
+{
+	TextMetrics const & tm = bv_->textMetrics(text());
+	ParagraphMetrics const & pm = tm.parMetrics(pit());
+	
+	int row;
+	if (pos() && boundary())
+		row = pm.pos2row(pos() - 1);
+	else
+		row = pm.pos2row(pos());
+	
+	if (up) {
+		if (pit() == 0 && row == 0)
+			return true;
+	} else {
+		if (pit() + 1 >= int(text()->paragraphs().size()) &&
+				row + 1 >= int(pm.rows().size()))
+			return true;
+	}
+	return false;
+}
+
 bool Cursor::upDownInText(bool up, bool & updateNeeded)
 {
 	LASSERT(text(), /**/);
@@ -1736,14 +1775,16 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded)
 	else
 		row = pm.pos2row(pos());
 		
-	// are we not at the start or end?
-	if (up) {
-		if (pit() == 0 && row == 0)
-			return false;
-	} else {
-		if (pit() + 1 >= int(text()->paragraphs().size()) &&
-				row + 1 >= int(pm.rows().size()))
-			return false;
+	if (atFirstOrLastRow(up)) {
+		Cursor dummy = *this;
+		// The cursor hasn't changed yet. This happens when
+		// you e.g. move out of an inset. And to give the 
+		// DEPM the possibility of doing something we must
+		// provide it with two different cursors. (Lgb, vfr)
+		dummy.pos() = dummy.pos() == 0 ? dummy.lastpos() : 0;
+		dummy.pit() = dummy.pit() == 0 ? dummy.lastpit() : 0;
+		updateNeeded |= bv().checkDepm(dummy, *this);
+		return false;
 	}
 
 	// with and without selection are handled differently
@@ -1756,19 +1797,6 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded)
 		else
 			tm.editXY(*this, xo, yo + textRow().descent() + 1);
 		clearSelection();
-		
-		// This happens when you move out of an inset.
-		// And to give the DEPM the possibility of doing
-		// something we must provide it with two different
-		// cursors. (Lgb)
-		Cursor dummy = *this;
-		if (dummy == old)
-			++dummy.pos();
-		if (bv().checkDepm(dummy, old)) {
-			updateNeeded = true;
-			// Make sure that cur gets back whatever happened to dummy(Lgb)
-			operator=(dummy);
-		}
 	} else {
 		// if there is a selection, we stay out of any inset, and just jump to the right position:
 		Cursor old = *this;
@@ -1812,6 +1840,8 @@ void Cursor::handleFont(string const & font)
 		safe = cap::grabAndEraseSelection(*this);
 	}
 
+	recordUndoInset();
+
 	if (lastpos() != 0) {
 		// something left in the cell
 		if (pos() == 0) {
@@ -1831,8 +1861,9 @@ void Cursor::handleFont(string const & font)
 		}
 	} else {
 		// nothing left in the cell
-		pullArg();
+		popBackward();
 		plainErase();
+		resetAnchor();
 	}
 	insert(safe);
 }
@@ -1850,17 +1881,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();
 
@@ -1892,7 +1934,7 @@ docstring Cursor::selectionAsString(bool label) const
 }
 
 
-docstring Cursor::currentState()
+docstring Cursor::currentState() const
 {
 	if (inMathed()) {
 		odocstringstream os;
@@ -1907,7 +1949,7 @@ docstring Cursor::currentState()
 }
 
 
-docstring Cursor::getPossibleLabel()
+docstring Cursor::getPossibleLabel() const
 {
 	return inMathed() ? from_ascii("eq:") : text()->getPossibleLabel(*this);
 }
@@ -1976,7 +2018,7 @@ Font Cursor::getFont() const
 	}
 	
 	// get font at the position
-	Font font = par.getFont(bv().buffer().params(), pos,
+	Font font = par.getFont(buffer()->params(), pos,
 		outerFont(sl.pit(), text.paragraphs()));
 
 	return font;
@@ -1987,14 +2029,13 @@ bool Cursor::fixIfBroken()
 {
 	if (DocIterator::fixIfBroken()) {
 			clearSelection();
-			resetAnchor();
 			return true;
 	}
 	return false;
 }
 
 
-bool notifyCursorLeaves(Cursor const & old, Cursor & cur)
+bool notifyCursorLeavesOrEnters(Cursor const & old, Cursor & cur)
 {
 	// find inset in common
 	size_type i;
@@ -2005,19 +2046,25 @@ bool notifyCursorLeaves(Cursor const & old, Cursor & cur)
 
 	// update words if we just moved to another paragraph
 	if (i == old.depth() && i == cur.depth()
-	    && !cur.buffer().isClean()
+	    && !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) {
+	for (size_type j = i; j < old.depth(); ++j) {
 		Cursor insetPos = old;
-		insetPos.cutOff(i);
-		if (old[i].inset().notifyCursorLeaves(insetPos, cur))
+		insetPos.cutOff(j);
+		if (old[j].inset().notifyCursorLeaves(insetPos, cur))
+			return true;
+	}
+
+	// notify everything on top of the common part in new cursor,
+	// but stop if the inset claims the cursor to be invalid now
+	for (; i < cur.depth(); ++i) {
+		if (cur[i].inset().notifyCursorEnters(cur))
 			return true;
 	}
 	
@@ -2054,7 +2101,7 @@ void Cursor::setCurrentFont()
 	}
 
 	// get font
-	BufferParams const & bufparams = buffer().params();
+	BufferParams const & bufparams = buffer()->params();
 	current_font = par.getFontSettings(bufparams, cpos);
 	real_current_font = tm.displayFont(cpit, cpos);
 
@@ -2075,12 +2122,11 @@ bool Cursor::textUndo()
 {
 	DocIterator dit = *this;
 	// Undo::textUndo() will modify dit.
-	if (!bv_->buffer().undo().textUndo(dit))
+	if (!buffer()->undo().textUndo(dit))
 		return false;
 	// Set cursor
 	setCursor(dit);
-	selection() = false;
-	resetAnchor();
+	clearSelection();
 	fixIfBroken();
 	return true;
 }
@@ -2090,73 +2136,86 @@ bool Cursor::textRedo()
 {
 	DocIterator dit = *this;
 	// Undo::textRedo() will modify dit.
-	if (!bv_->buffer().undo().textRedo(dit))
+	if (!buffer()->undo().textRedo(dit))
 		return false;
 	// Set cursor
 	setCursor(dit);
-	selection() = false;
-	resetAnchor();
+	clearSelection();
 	fixIfBroken();
 	return true;
 }
 
 
-void Cursor::finishUndo()
+void Cursor::finishUndo() const
 {
-	bv_->buffer().undo().finishUndo();
+	buffer()->undo().finishUndo();
 }
 
 
-void Cursor::recordUndo(UndoKind kind, pit_type from, pit_type to)
+void Cursor::beginUndoGroup() const
 {
-	bv_->buffer().undo().recordUndo(*this, kind, from, to);
+	buffer()->undo().beginUndoGroup();
 }
 
 
-void Cursor::recordUndo(UndoKind kind, pit_type from)
+void Cursor::endUndoGroup() const
 {
-	bv_->buffer().undo().recordUndo(*this, kind, from);
+	buffer()->undo().endUndoGroup();
 }
 
 
-void Cursor::recordUndo(UndoKind kind)
+void Cursor::recordUndo(UndoKind kind, pit_type from, pit_type to) const
 {
-	bv_->buffer().undo().recordUndo(*this, kind);
+	buffer()->undo().recordUndo(*this, kind, from, to);
 }
 
 
-void Cursor::recordUndoInset(UndoKind kind)
+void Cursor::recordUndo(UndoKind kind, pit_type from) const
 {
-	bv_->buffer().undo().recordUndoInset(*this, kind);
+	buffer()->undo().recordUndo(*this, kind, from);
 }
 
 
-void Cursor::recordUndoFullDocument()
+void Cursor::recordUndo(UndoKind kind) const
 {
-	bv_->buffer().undo().recordUndoFullDocument(*this);
+	buffer()->undo().recordUndo(*this, kind);
 }
 
 
-void Cursor::recordUndoSelection()
+void Cursor::recordUndoInset(UndoKind kind) const
+{
+	buffer()->undo().recordUndoInset(*this, kind);
+}
+
+
+void Cursor::recordUndoFullDocument() const
+{
+	buffer()->undo().recordUndoFullDocument(*this);
+}
+
+
+void Cursor::recordUndoSelection() const
 {
 	if (inMathed()) {
 		if (cap::multipleCellsSelected(*this))
 			recordUndoInset();
 		else
 			recordUndo();
-	} else
-		bv_->buffer().undo().recordUndo(*this, ATOMIC_UNDO,
+	} else {
+		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();
+	Buffer const * master = buffer()->masterBuffer();
+	master->tocBackend().updateItem(*this);
+	if (master != buffer() && !master->hasGuiDelegate())
+		// In case the master has no gui associated with it, 
+		// the TocItem is not updated (part of bug 5699).
+		buffer()->tocBackend().updateItem(*this);
 }