X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCursor.cpp;h=b91322fe49c73ff1de00c6a4426a4ff600b3c49d;hb=2455bc258f3b62c29ec4a41cb88070ff8518e842;hp=397331f7a686c46fc21067ed47c965035a6b1fe4;hpb=770b230704ca129329f300f2d276ff24ff677ced;p=lyx.git

diff --git a/src/Cursor.cpp b/src/Cursor.cpp
index 397331f7a6..b91322fe49 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"
 
@@ -49,7 +50,6 @@
 #include "mathed/MathData.h"
 #include "mathed/MathMacro.h"
 
-#include <boost/assert.hpp>
 #include <boost/bind.hpp>
 
 #include <sstream>
@@ -134,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();
 
@@ -304,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.
@@ -341,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();
 }
 
@@ -369,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);
@@ -378,7 +378,7 @@ void Cursor::pushBackward(Inset & p)
 
 bool Cursor::popBackward()
 {
-	BOOST_ASSERT(!empty());
+	LASSERT(!empty(), /**/);
 	if (depth() == 1)
 		return false;
 	pop();
@@ -388,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)
@@ -401,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)
@@ -423,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());
 }
 
@@ -453,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
@@ -567,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
@@ -724,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
@@ -1003,7 +1193,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));
@@ -1024,7 +1214,7 @@ void Cursor::insert(MathAtom const & t)
 
 void Cursor::insert(Inset * inset0)
 {
-	BOOST_ASSERT(inset0);
+	LASSERT(inset0, /**/);
 	if (inMathed())
 		insert(MathAtom(inset0));
 	else {
@@ -1369,7 +1559,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();
@@ -1495,7 +1685,7 @@ bool Cursor::upDownInMath(bool up)
 
 bool Cursor::upDownInText(bool up, bool & updateNeeded)
 {
-	BOOST_ASSERT(text());
+	LASSERT(text(), /**/);
 
 	// where are we?
 	int xo = 0;
@@ -1554,7 +1744,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()) {
@@ -1587,7 +1777,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 {
@@ -1595,6 +1788,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());
 			}
 		}
@@ -1654,11 +1850,14 @@ 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()) {
 		ParagraphList const & pars = text()->paragraphs();
 
@@ -1943,14 +2142,20 @@ void Cursor::recordUndoFullDocument()
 
 void Cursor::recordUndoSelection()
 {
-	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));