X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText2.cpp;h=b7dc9a13d60373425bf835bd9eebf70d52594ef0;hb=4056f0ddb150d0e5d60bc5941d51e365eed0ac86;hp=d3025d1845a757a635f28624f01f4655e002e50f;hpb=6e974a3d42b1e14daf2cdaac65d33aad4876063a;p=lyx.git

diff --git a/src/Text2.cpp b/src/Text2.cpp
index d3025d1845..b7dc9a13d6 100644
--- a/src/Text2.cpp
+++ b/src/Text2.cpp
@@ -22,51 +22,43 @@
 
 #include "Text.h"
 
+#include "Bidi.h"
 #include "Buffer.h"
 #include "buffer_funcs.h"
 #include "BufferList.h"
 #include "BufferParams.h"
 #include "BufferView.h"
-#include "Bullet.h"
-#include "Color.h"
+#include "Changes.h"
 #include "Cursor.h"
 #include "CutAndPaste.h"
-#include "debug.h"
 #include "DispatchResult.h"
 #include "ErrorList.h"
 #include "FuncRequest.h"
-#include "gettext.h"
 #include "Language.h"
+#include "Layout.h"
 #include "Lexer.h"
 #include "LyXFunc.h"
 #include "LyXRC.h"
 #include "Paragraph.h"
 #include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
-#include "ParIterator.h"
-#include "Server.h"
-#include "ServerSocket.h"
-#include "Undo.h"
+#include "TextClass.h"
+#include "TextMetrics.h"
 #include "VSpace.h"
 
-#include "frontends/FontMetrics.h"
-
 #include "insets/InsetEnvironment.h"
 
 #include "mathed/InsetMathHull.h"
 
+#include "support/debug.h"
+#include "support/gettext.h"
 #include "support/textutils.h"
 
-#include <boost/current_function.hpp>
+#include <boost/next_prior.hpp>
 
 #include <sstream>
 
-using std::endl;
-using std::ostringstream;
-using std::string;
-using std::max;
-using std::min;
-using std::istringstream;
+using namespace std;
 
 namespace lyx {
 
@@ -81,42 +73,42 @@ bool Text::isMainText(Buffer const & buffer) const
 }
 
 
-Font Text::getLayoutFont(Buffer const & buffer, pit_type const pit) const
+FontInfo Text::getLayoutFont(Buffer const & buffer, pit_type const pit) const
 {
 	LayoutPtr const & layout = pars_[pit].layout();
 
 	if (!pars_[pit].getDepth())  {
-		Font lf = layout->resfont;
+		FontInfo lf = layout->resfont;
 		// In case the default family has been customized
-		if (layout->font.family() == Font::INHERIT_FAMILY)
-			lf.setFamily(buffer.params().getFont().family());
+		if (layout->font.family() == INHERIT_FAMILY)
+			lf.setFamily(buffer.params().getFont().fontInfo().family());
 		return lf;
 	}
 
-	Font font = layout->font;
+	FontInfo font = layout->font;
 	// Realize with the fonts of lesser depth.
 	//font.realize(outerFont(pit, paragraphs()));
-	font.realize(buffer.params().getFont());
+	font.realize(buffer.params().getFont().fontInfo());
 
 	return font;
 }
 
 
-Font Text::getLabelFont(Buffer const & buffer, Paragraph const & par) const
+FontInfo Text::getLabelFont(Buffer const & buffer, Paragraph const & par) const
 {
 	LayoutPtr const & layout = par.layout();
 
 	if (!par.getDepth()) {
-		Font lf = layout->reslabelfont;
+		FontInfo lf = layout->reslabelfont;
 		// In case the default family has been customized
-		if (layout->labelfont.family() == Font::INHERIT_FAMILY)
-			lf.setFamily(buffer.params().getFont().family());
+		if (layout->labelfont.family() == INHERIT_FAMILY)
+			lf.setFamily(buffer.params().getFont().fontInfo().family());
 		return lf;
 	}
 
-	Font font = layout->labelfont;
+	FontInfo font = layout->labelfont;
 	// Realize with the fonts of lesser depth.
-	font.realize(buffer.params().getFont());
+	font.realize(buffer.params().getFont().fontInfo());
 
 	return font;
 }
@@ -129,7 +121,7 @@ void Text::setCharFont(Buffer const & buffer, pit_type pit,
 	LayoutPtr const & layout = pars_[pit].layout();
 
 	// Get concrete layout font to reduce against
-	Font layoutfont;
+	FontInfo layoutfont;
 
 	if (pos < pars_[pit].beginOfBody())
 		layoutfont = layout->labelfont;
@@ -151,12 +143,12 @@ void Text::setCharFont(Buffer const & buffer, pit_type pit,
 	// Inside inset, apply the inset's font attributes if any
 	// (charstyle!)
 	if (!isMainText(buffer))
-		layoutfont.realize(display_font);
+		layoutfont.realize(display_font.fontInfo());
 
-	layoutfont.realize(buffer.params().getFont());
+	layoutfont.realize(buffer.params().getFont().fontInfo());
 
 	// Now, reduce font against full layout font
-	font.reduce(layoutfont);
+	font.fontInfo().reduce(layoutfont);
 
 	pars_[pit].setFont(pos, font);
 }
@@ -165,10 +157,9 @@ void Text::setCharFont(Buffer const & buffer, pit_type pit,
 void Text::setInsetFont(BufferView const & bv, pit_type pit,
 		pos_type pos, Font const & font, bool toggleall)
 {
-	BOOST_ASSERT(pars_[pit].isInset(pos) &&
-		     pars_[pit].getInset(pos)->noFontChange());
-
 	Inset * const inset = pars_[pit].getInset(pos);
+	BOOST_ASSERT(inset && inset->noFontChange());
+
 	CursorSlice::idx_type endidx = inset->nargs();
 	for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
 		Text * text = cs.text();
@@ -208,7 +199,7 @@ void Text::setLayout(Buffer const & buffer, pit_type start, pit_type end,
 	BOOST_ASSERT(start != end);
 
 	BufferParams const & bufparams = buffer.params();
-	LayoutPtr const & lyxlayout = bufparams.getTextClass()[layout];
+	LayoutPtr const & lyxlayout = bufparams.textClass()[layout];
 
 	for (pit_type pit = start; pit != end; ++pit) {
 		Paragraph & par = pars_[pit];
@@ -227,10 +218,10 @@ void Text::setLayout(Cursor & cur, docstring const & layout)
 	// special handling of new environment insets
 	BufferView & bv = cur.bv();
 	BufferParams const & params = bv.buffer().params();
-	LayoutPtr const & lyxlayout = params.getTextClass()[layout];
+	LayoutPtr const & lyxlayout = params.textClass()[layout];
 	if (lyxlayout->is_environment) {
 		// move everything in a new environment inset
-		LYXERR(Debug::DEBUG) << "setting layout " << to_utf8(layout) << endl;
+		LYXERR(Debug::DEBUG, "setting layout " << to_utf8(layout));
 		lyx::dispatch(FuncRequest(LFUN_LINE_BEGIN));
 		lyx::dispatch(FuncRequest(LFUN_LINE_END_SELECT));
 		lyx::dispatch(FuncRequest(LFUN_CUT));
@@ -289,7 +280,7 @@ void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
 	BOOST_ASSERT(this == cur.text());
 	pit_type const beg = cur.selBegin().pit();
 	pit_type const end = cur.selEnd().pit() + 1;
-	recordUndoSelection(cur);
+	cur.recordUndoSelection();
 	int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
 
 	for (pit_type pit = beg; pit != end; ++pit) {
@@ -314,7 +305,7 @@ void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
 	BOOST_ASSERT(this == cur.text());
 	// Set the current_font
 	// Determine basis font
-	Font layoutfont;
+	FontInfo layoutfont;
 	pit_type pit = cur.pit();
 	if (cur.pos() < pars_[pit].beginOfBody())
 		layoutfont = getLabelFont(cur.buffer(), pars_[pit]);
@@ -328,16 +319,16 @@ void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
 
 	// Reduce to implicit settings
 	cur.current_font = cur.real_current_font;
-	cur.current_font.reduce(layoutfont);
+	cur.current_font.fontInfo().reduce(layoutfont);
 	// And resolve it completely
-	cur.real_current_font.realize(layoutfont);
+	cur.real_current_font.fontInfo().realize(layoutfont);
 
 	// if there is no selection that's all we need to do
 	if (!cur.selection())
 		return;
 
 	// Ok, we have a selection.
-	recordUndoSelection(cur);
+	cur.recordUndoSelection();
 
 	setFont(cur.bv(), cur.selectionBegin().top(), 
 		cur.selectionEnd().top(), font, toggleall);
@@ -356,21 +347,22 @@ void Text::setFont(BufferView const & bv, CursorSlice const & begin,
 	// nested insets.
 	Language const * language = buffer.params().language;
 	for (CursorSlice dit = begin; dit != end; dit.forwardPos()) {
-		if (dit.pos() != dit.lastpos()) {
-			pit_type const pit = dit.pit();
-			pos_type const pos = dit.pos();
-			if (pars_[pit].isInset(pos) &&
-			    pars_[pit].getInset(pos)->noFontChange())
-				// We need to propagate the font change to all
-				// text cells of the inset (bug 1973).
-				// FIXME: This should change, see documentation
-				// of noFontChange in Inset.h
-				setInsetFont(bv, pit, pos, font, toggleall);
-			TextMetrics const & tm = bv.textMetrics(this);
-			Font f = tm.getDisplayFont(pit, pos);
-			f.update(font, language, toggleall);
-			setCharFont(buffer, pit, pos, f, tm.font_);
+		if (dit.pos() == dit.lastpos())
+			continue;
+		pit_type const pit = dit.pit();
+		pos_type const pos = dit.pos();
+		Inset * inset = pars_[pit].getInset(pos);
+		if (inset && inset->noFontChange()) {
+			// We need to propagate the font change to all
+			// text cells of the inset (bug 1973).
+			// FIXME: This should change, see documentation
+			// of noFontChange in Inset.h
+			setInsetFont(bv, pit, pos, font, toggleall);
 		}
+		TextMetrics const & tm = bv.textMetrics(this);
+		Font f = tm.getDisplayFont(pit, pos);
+		f.update(font, language, toggleall);
+		setCharFont(buffer, pit, pos, f, tm.font_);
 	}
 }
 
@@ -393,7 +385,8 @@ void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
 {
 	BOOST_ASSERT(this == cur.text());
 	// If the mask is completely neutral, tell user
-	if (font == Font(Font::ALL_IGNORE)) {
+	if (font.fontInfo() == ignore_font && 
+		(font.language() == 0 || font.language() == ignore_language)) {
 		// Could only happen with user style
 		cur.message(_("No font change defined."));
 		return;
@@ -405,7 +398,7 @@ void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
 	CursorSlice resetCursor = cur.top();
 	bool implicitSelection =
 		font.language() == ignore_language
-		&& font.number() == Font::IGNORE
+		&& font.fontInfo().number() == FONT_IGNORE
 		&& selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT);
 
 	// Set font
@@ -425,25 +418,23 @@ docstring Text::getStringToIndex(Cursor const & cur)
 {
 	BOOST_ASSERT(this == cur.text());
 
-	docstring idxstring;
 	if (cur.selection())
-		idxstring = cur.selectionAsString(false);
-	else {
-		// Try implicit word selection. If there is a change
-		// in the language the implicit word selection is
-		// disabled.
-		Cursor tmpcur = cur;
-		selectWord(tmpcur, PREVIOUS_WORD);
-
-		if (!tmpcur.selection())
-			cur.message(_("Nothing to index!"));
-		else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
-			cur.message(_("Cannot index more than one paragraph!"));
-		else
-			idxstring = tmpcur.selectionAsString(false);
-	}
-
-	return idxstring;
+		return cur.selectionAsString(false);
+
+	// Try implicit word selection. If there is a change
+	// in the language the implicit word selection is
+	// disabled.
+	Cursor tmpcur = cur;
+	selectWord(tmpcur, PREVIOUS_WORD);
+
+	if (!tmpcur.selection())
+		cur.message(_("Nothing to index!"));
+	else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
+		cur.message(_("Cannot index more than one paragraph!"));
+	else
+		return tmpcur.selectionAsString(false);
+	
+	return docstring();
 }
 
 
@@ -454,13 +445,14 @@ void Text::setParagraphs(Cursor & cur, docstring arg, bool merge)
 	pit_type undopit = undoSpan(cur.selEnd().pit());
 	recUndo(cur, cur.selBegin().pit(), undopit - 1);
 
+	//FIXME UNICODE
+	string const argument = to_utf8(arg);
 	for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
 	     pit <= end; ++pit) {
 		Paragraph & par = pars_[pit];
 		ParagraphParameters params = par.params();
-		params.read(to_utf8(arg), merge);
-		Layout const & layout = *(par.layout());
-		par.params().apply(params, layout);
+		params.read(argument, merge);
+		par.params().apply(params, *par.layout());
 	}
 }
 
@@ -490,8 +482,8 @@ void Text::insertInset(Cursor & cur, Inset * inset)
 	BOOST_ASSERT(this == cur.text());
 	BOOST_ASSERT(inset);
 	cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
-				    Change(cur.buffer().params().trackChanges ?
-					   Change::INSERTED : Change::UNCHANGED));
+		Change(cur.buffer().params().trackChanges
+		? Change::INSERTED : Change::UNCHANGED));
 }
 
 
@@ -499,7 +491,7 @@ void Text::insertInset(Cursor & cur, Inset * inset)
 void Text::insertStringAsLines(Cursor & cur, docstring const & str)
 {
 	cur.buffer().insertStringAsLines(pars_, cur.pit(), cur.pos(),
-					 cur.current_font, str, autoBreakRows_);
+		cur.current_font, str, autoBreakRows_);
 }
 
 
@@ -533,9 +525,11 @@ void Text::insertStringAsParagraphs(Cursor & cur, docstring const & str)
 bool Text::setCursor(Cursor & cur, pit_type par, pos_type pos,
 			bool setfont, bool boundary)
 {
+	TextMetrics const & tm = cur.bv().textMetrics(this);
+	bool const update_needed = !tm.has(par);
 	Cursor old = cur;
 	setCursorIntern(cur, par, pos, setfont, boundary);
-	return cur.bv().checkDepm(cur, old);
+	return cur.bv().checkDepm(cur, old) || update_needed;
 }
 
 
@@ -583,7 +577,7 @@ bool Text::checkAndActivateInset(Cursor & cur, bool front)
 	if (!front && cur.pos() == 0)
 		return false;
 	Inset * inset = front ? cur.nextInset() : cur.prevInset();
-	if (!isHighlyEditableInset(inset))
+	if (!inset || inset->editable() != Inset::HIGHLY_EDITABLE)
 		return false;
 	/*
 	 * Apparently, when entering an inset we are expected to be positioned
@@ -599,7 +593,25 @@ bool Text::checkAndActivateInset(Cursor & cur, bool front)
 }
 
 
-bool Text::cursorLeft(Cursor & cur)
+bool Text::checkAndActivateInsetVisual(Cursor & cur, bool movingForward, bool movingLeft)
+{
+	if (cur.selection())
+		return false;
+	if (cur.pos() == -1)
+		return false;
+	if (cur.pos() == cur.lastpos())
+		return false;
+	Paragraph & par = cur.paragraph();
+	Inset * inset = par.isInset(cur.pos()) ? par.getInset(cur.pos()) : 0;
+	if (!inset || inset->editable() != Inset::HIGHLY_EDITABLE)
+		return false;
+	inset->edit(cur, movingForward, 
+		movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
+	return true;
+}
+
+
+bool Text::cursorBackward(Cursor & cur)
 {
 	// Tell BufferView to test for FitCursor in any case!
 	cur.updateFlags(Update::FitCursor);
@@ -636,12 +648,192 @@ bool Text::cursorLeft(Cursor & cur)
 
 	// move to the previous paragraph or do nothing
 	if (cur.pit() > 0)
-		return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size());
+		return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size(), true, false);
 	return false;
 }
 
 
-bool Text::cursorRight(Cursor & cur)
+bool Text::cursorVisLeft(Cursor & cur, bool skip_inset)
+{
+	pit_type new_pit = cur.pit(); // the paragraph to which we will move
+	pos_type new_pos; // the position we will move to
+	bool new_boundary; // will we move to a boundary position?
+	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?
+
+	cur.getSurroundingPos(left_pos, right_pos);
+
+	LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<<cur.pos()<<")");
+
+	// Are we at an inset?
+	Cursor temp_cur = cur;
+	temp_cur.pos() = left_pos;
+	temp_cur.boundary(false);
+	if (!skip_inset && 
+		checkAndActivateInsetVisual(temp_cur, left_pos >= cur.pos(), true)) {
+		LYXERR(Debug::RTL, "entering inset at: " << temp_cur.pos());
+		cur = temp_cur; // set the real cursor to new position inside inset!
+		return false;
+	}
+
+	// Are we already at leftmost pos in row?
+	if (left_pos == -1) {
+		
+		Cursor new_cur = cur;
+		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...
+		new_pit = new_cur.pit();
+		new_pos = new_cur.pos();
+		new_boundary = new_cur.boundary();
+
+		LYXERR(Debug::RTL, "left edge, moving: " << int(new_pit) << "," 
+			<< int(new_pos) << "," << (new_boundary ? 1 : 0));
+
+	}
+	// normal movement to the left
+	else {
+		// 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 = cur.paragraph().getFontSettings(
+			cur.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_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_pos == cur.lastpos()
+			// 2. if the position *after* left_pos is not RTL (we want to be 
+			// *after* left_pos, not before left_pos + 1!)
+				|| !cur.paragraph().getFontSettings(cur.bv().buffer().params(),
+						new_pos).isVisibleRightToLeft()
+			)
+				new_boundary = true;
+			else // set the boundary to false
+				new_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_pos = left_pos;
+			new_boundary = false;
+		}
+	
+	}
+
+	LYXERR(Debug::RTL, "moving to: " << new_pos 
+		<< (new_boundary ? " (boundary)" : ""));
+
+	return setCursor(cur, new_pit, new_pos, true, new_boundary);
+}
+
+
+bool Text::cursorVisRight(Cursor & cur, bool skip_inset)
+{
+	pit_type new_pit = cur.pit(); // the paragraph to which we will move
+	pos_type new_pos; // the position we will move to
+	bool new_boundary; // will we move to a boundary position?
+	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?
+
+	cur.getSurroundingPos(left_pos, right_pos);
+
+	LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<<cur.pos()<<")");
+
+	// Are we at an inset?
+	Cursor temp_cur = cur;
+	temp_cur.pos() = right_pos;
+	temp_cur.boundary(false);
+	if (!skip_inset &&
+		checkAndActivateInsetVisual(temp_cur, right_pos >= cur.pos(), false)) {
+		LYXERR(Debug::RTL, "entering inset at: " << temp_cur.pos());
+		cur = temp_cur; // set the real cursor to new position inside inset!
+		return false;
+	}
+
+	// Are we already at rightmost pos in row?
+	if (right_pos == -1) {
+		
+		Cursor new_cur = cur;
+		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...
+		new_pit = new_cur.pit();
+		new_pos = new_cur.pos();
+		new_boundary = new_cur.boundary();
+
+		LYXERR(Debug::RTL, "right edge, moving: " << int(new_pit) << "," 
+			<< int(new_pos) << "," << (new_boundary ? 1 : 0));
+
+	}
+	// normal movement to the right
+	else {
+		// 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 = cur.paragraph().getFontSettings(
+			cur.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_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_pos == cur.lastpos()
+			// 2. if the position *after* right_pos is RTL (we want to be 
+			// *after* right_pos, not before right_pos + 1!)
+				|| cur.paragraph().getFontSettings(cur.bv().buffer().params(),
+						new_pos).isVisibleRightToLeft()
+			)
+				new_boundary = true;
+			else // set the boundary to false
+				new_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_pos = right_pos;
+			new_boundary = false;
+		}
+	
+	}
+
+	LYXERR(Debug::RTL, "moving to: " << new_pos 
+		<< (new_boundary ? " (boundary)" : ""));
+
+	return setCursor(cur, new_pit, new_pos, true, new_boundary);
+}
+
+
+bool Text::cursorForward(Cursor & cur)
 {
 	// Tell BufferView to test for FitCursor in any case!
 	cur.updateFlags(Update::FitCursor);
@@ -693,7 +885,7 @@ bool Text::cursorRight(Cursor & cur)
 
 	// move to next paragraph
 	if (cur.pit() != cur.lastpit())
-		return setCursor(cur, cur.pit() + 1, 0);
+		return setCursor(cur, cur.pit() + 1, 0, true, false);
 	return false;
 }
 
@@ -743,7 +935,7 @@ void Text::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
 bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 		Cursor & old, bool & need_anchor_change)
 {
-	//LYXERR(Debug::DEBUG) << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
+	//LYXERR(Debug::DEBUG, "DEPM: cur:\n" << cur << "old:\n" << old);
 
 	Paragraph & oldpar = old.paragraph();
 
@@ -809,15 +1001,15 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 
 	if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
 		// Delete old par.
-		recordUndo(old, Undo::ATOMIC,
+		old.recordUndo(ATOMIC_UNDO,
 			   max(old.pit() - 1, pit_type(0)),
 			   min(old.pit() + 1, old.lastpit()));
 		ParagraphList & plist = old.text()->paragraphs();
 		bool const soa = oldpar.params().startOfAppendix();
 		plist.erase(boost::next(plist.begin(), old.pit()));
 		// do not lose start of appendix marker (bug 4212)
-		if (soa)
-			boost::next(plist.begin(), old.pit())->params().startOfAppendix(true);
+		if (soa && old.pit() < pit_type(plist.size()))
+			plist[old.pit()].params().startOfAppendix(true);
 
 		// see #warning (FIXME?) above 
 		if (cur.depth() >= old.depth()) {
@@ -890,13 +1082,13 @@ void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool tra
 
 void Text::recUndo(Cursor & cur, pit_type first, pit_type last) const
 {
-	recordUndo(cur, Undo::ATOMIC, first, last);
+	cur.recordUndo(ATOMIC_UNDO, first, last);
 }
 
 
 void Text::recUndo(Cursor & cur, pit_type par) const
 {
-	recordUndo(cur, Undo::ATOMIC, par, par);
+	cur.recordUndo(ATOMIC_UNDO, par, par);
 }
 
 } // namespace lyx