X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCursor.cpp;h=572e062876d461d8680adb218b857e59c51eddc2;hb=4df7d8ab1ae443119057562fb76c2e438c053eef;hp=81357ccc2161735fca39c5ce6a73652338a8ed15;hpb=7f461f4392a19cf488dec005d2f12cfea83655d9;p=lyx.git

diff --git a/src/Cursor.cpp b/src/Cursor.cpp
index 81357ccc21..572e062876 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.
@@ -36,7 +36,7 @@
 #include "TextMetrics.h"
 #include "TocBackend.h"
 
-#include "support/assert.h"
+#include "support/lassert.h"
 #include "support/debug.h"
 #include "support/docstream.h"
 
@@ -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;
@@ -322,6 +321,15 @@ void Cursor::dispatch(FuncRequest const & cmd0)
 	// object will be used again.
 	if (!disp_.dispatched()) {
 		LYXERR(Debug::DEBUG, "RESTORING OLD CURSOR!");
+		// We might have invalidated the cursor when removing an empty
+		// paragraph while the cursor could not be moved out the inset
+		// while we initially thought we could. This might happen when
+		// a multiline inset becomes an inline inset when the second 
+		// paragraph is removed.
+		if (safe.pit() > safe.lastpit()) {
+			safe.pit() = safe.lastpit();
+			safe.pos() = safe.lastpos();
+		}
 		operator=(safe);
 		disp_.update(Update::None);
 		disp_.dispatched(false);
@@ -346,13 +354,6 @@ BufferView & Cursor::bv() const
 }
 
 
-Buffer & Cursor::buffer() const
-{
-	LASSERT(bv_, /**/);
-	return bv_->buffer();
-}
-
-
 void Cursor::pop()
 {
 	LASSERT(depth() >= 1, /**/);
@@ -363,13 +364,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 +379,7 @@ void Cursor::pushBackward(Inset & p)
 
 bool Cursor::popBackward()
 {
-	LASSERT(!empty(), /**/);
+	LASSERT(!empty(), return false);
 	if (depth() == 1)
 		return false;
 	pop();
@@ -388,7 +389,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 +435,12 @@ void Cursor::resetAnchor()
 }
 
 
+void Cursor::setCursorToAnchor()
+{
+	if (selection())
+		setCursor(anchor_);
+}
+
 
 bool Cursor::posBackward()
 {
@@ -453,11 +460,196 @@ 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(
+			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(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()
+				  || &new_cur.inset() != &inset());
+	
+	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(
+			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(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
 	Paragraph const & par = paragraph();
-	Buffer const & buf = buffer();
+	Buffer const & buf = *buffer();
 	Row const & row = textRow();
 	Bidi bidi;
 	bidi.computeTables(par, buf, row);
@@ -467,7 +659,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" 
@@ -476,8 +668,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);
 		}
@@ -492,11 +684,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':
@@ -510,9 +701,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;
@@ -522,14 +713,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;
@@ -538,9 +729,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;
@@ -550,7 +741,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
@@ -564,9 +755,17 @@ 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());
+
+	// 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
@@ -610,7 +809,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);
@@ -649,32 +848,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.
@@ -699,16 +897,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) {
@@ -754,7 +953,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;
 }
@@ -764,7 +970,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();
@@ -775,18 +989,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;
 }
@@ -794,8 +1010,8 @@ void Cursor::setSelection(DocIterator const & where, int n)
 
 void Cursor::clearSelection()
 {
-	selection() = false;
-	mark() = false;
+	setSelection(false);
+	setMark(false);
 	resetAnchor();
 }
 
@@ -858,7 +1074,7 @@ bool Cursor::selHandle(bool sel)
 		cap::saveSelection(*this);
 
 	resetAnchor();
-	selection() = sel;
+	setSelection(sel);
 	return true;
 }
 
@@ -1035,10 +1251,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
@@ -1117,7 +1333,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();
@@ -1165,7 +1381,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();
@@ -1236,7 +1452,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);
@@ -1369,7 +1585,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();
@@ -1493,6 +1709,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(), /**/);
@@ -1546,14 +1784,33 @@ 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)) {
+		// Is there a place for the cursor to go ? If yes, we
+		// can execute the DEPM, otherwise we should keep the
+		// paragraph to host the cursor.
+		Cursor dummy = *this;
+		bool valid_destination = false;
+		for(; dummy.depth(); dummy.pop())
+			if (!dummy.atFirstOrLastRow(up)) {
+				valid_destination = true;
+				break;
+			}
+
+		// will a next dispatch follow and if there is a new 
+		// dispatch will it move the cursor out ?
+		if (depth() > 1 && valid_destination) {
+			// 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 = *this;
+			dummy.pos() = dummy.pos() == 0 ? dummy.lastpos() : 0;
+			dummy.pit() = dummy.pit() == 0 ? dummy.lastpit() : 0;
+
+			updateNeeded |= bv().checkDepm(dummy, *this);
+			updateTextTargetOffset();
+		}
+		return false;
 	}
 
 	// with and without selection are handled differently
@@ -1567,16 +1824,16 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded)
 			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)
+		// 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)
+			// Make sure that cur gets back whatever happened to dummy(Lgb) 
 			operator=(dummy);
 		}
 	} else {
@@ -1622,6 +1879,8 @@ void Cursor::handleFont(string const & font)
 		safe = cap::grabAndEraseSelection(*this);
 	}
 
+	recordUndoInset();
+
 	if (lastpos() != 0) {
 		// something left in the cell
 		if (pos() == 0) {
@@ -1641,8 +1900,9 @@ void Cursor::handleFont(string const & font)
 		}
 	} else {
 		// nothing left in the cell
-		pullArg();
+		popBackward();
 		plainErase();
+		resetAnchor();
 	}
 	insert(safe);
 }
@@ -1660,17 +1920,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();
 
@@ -1702,7 +1973,7 @@ docstring Cursor::selectionAsString(bool label) const
 }
 
 
-docstring Cursor::currentState()
+docstring Cursor::currentState() const
 {
 	if (inMathed()) {
 		odocstringstream os;
@@ -1717,7 +1988,7 @@ docstring Cursor::currentState()
 }
 
 
-docstring Cursor::getPossibleLabel()
+docstring Cursor::getPossibleLabel() const
 {
 	return inMathed() ? from_ascii("eq:") : text()->getPossibleLabel(*this);
 }
@@ -1786,7 +2057,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;
@@ -1797,14 +2068,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;
@@ -1815,19 +2085,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;
+		old.paragraph().updateWords();
 	}
-	
+
 	// 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;
 	}
 	
@@ -1864,7 +2140,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);
 
@@ -1885,12 +2161,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;
 }
@@ -1900,73 +2175,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
+{
+	buffer()->undo().finishUndo();
+}
+
+
+void Cursor::beginUndoGroup() const
 {
-	bv_->buffer().undo().finishUndo();
+	buffer()->undo().beginUndoGroup();
 }
 
 
-void Cursor::recordUndo(UndoKind kind, pit_type from, pit_type to)
+void Cursor::endUndoGroup() const
 {
-	bv_->buffer().undo().recordUndo(*this, kind, from, to);
+	buffer()->undo().endUndoGroup();
 }
 
 
-void Cursor::recordUndo(UndoKind kind, pit_type from)
+void Cursor::recordUndo(UndoKind kind, pit_type from, pit_type to) const
 {
-	bv_->buffer().undo().recordUndo(*this, kind, from);
+	buffer()->undo().recordUndo(*this, kind, from, to);
 }
 
 
-void Cursor::recordUndo(UndoKind kind)
+void Cursor::recordUndo(UndoKind kind, pit_type from) const
 {
-	bv_->buffer().undo().recordUndo(*this, kind);
+	buffer()->undo().recordUndo(*this, kind, from);
 }
 
 
-void Cursor::recordUndoInset(UndoKind kind)
+void Cursor::recordUndo(UndoKind kind) const
 {
-	bv_->buffer().undo().recordUndoInset(*this, kind);
+	buffer()->undo().recordUndo(*this, kind);
 }
 
 
-void Cursor::recordUndoFullDocument()
+void Cursor::recordUndoInset(UndoKind kind) const
 {
-	bv_->buffer().undo().recordUndoFullDocument(*this);
+	buffer()->undo().recordUndoInset(*this, kind);
 }
 
 
-void Cursor::recordUndoSelection()
+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);
 }