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

diff --git a/src/Text2.cpp b/src/Text2.cpp
index e893889a29..b7dc9a13d6 100644
--- a/src/Text2.cpp
+++ b/src/Text2.cpp
@@ -11,6 +11,7 @@
  * \author John Levon
  * \author André Pönitz
  * \author Allan Rae
+ * \author Stefan Schimanski
  * \author Dekel Tsur
  * \author Jürgen Vigna
  *
@@ -21,62 +22,48 @@
 
 #include "Text.h"
 
+#include "Bidi.h"
 #include "Buffer.h"
 #include "buffer_funcs.h"
 #include "BufferList.h"
 #include "BufferParams.h"
 #include "BufferView.h"
-#include "bufferview_funcs.h"
-#include "Bullet.h"
-#include "CoordCache.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 "Color.h"
+#include "Layout.h"
+#include "Lexer.h"
 #include "LyXFunc.h"
 #include "LyXRC.h"
-#include "Row.h"
 #include "Paragraph.h"
-#include "TextMetrics.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 namespace std;
 
 namespace lyx {
 
-using std::endl;
-using std::ostringstream;
-using std::string;
-using std::max;
-using std::min;
-
-
 Text::Text()
-	: current_font(Font::ALL_INHERIT),
-	  background_color_(Color::background),
-	  autoBreakRows_(false)
+	: autoBreakRows_(false)
 {}
 
 
@@ -86,195 +73,55 @@ bool Text::isMainText(Buffer const & buffer) const
 }
 
 
-//takes screen x,y coordinates
-Inset * Text::checkInsetHit(BufferView & bv, int x, int y)
-{
-	pit_type pit = getPitNearY(bv, y);
-	BOOST_ASSERT(pit != -1);
-
-	Paragraph const & par = pars_[pit];
-
-	LYXERR(Debug::DEBUG)
-		<< BOOST_CURRENT_FUNCTION
-		<< ": x: " << x
-		<< " y: " << y
-		<< "  pit: " << pit
-		<< endl;
-	InsetList::const_iterator iit = par.insetlist.begin();
-	InsetList::const_iterator iend = par.insetlist.end();
-	for (; iit != iend; ++iit) {
-		Inset * inset = iit->inset;
-#if 1
-		LYXERR(Debug::DEBUG)
-			<< BOOST_CURRENT_FUNCTION
-			<< ": examining inset " << inset << endl;
-
-		if (bv.coordCache().getInsets().has(inset))
-			LYXERR(Debug::DEBUG)
-				<< BOOST_CURRENT_FUNCTION
-				<< ": xo: " << inset->xo(bv) << "..."
-				<< inset->xo(bv) + inset->width()
-				<< " yo: " << inset->yo(bv) - inset->ascent()
-				<< "..."
-				<< inset->yo(bv) + inset->descent()
-				<< endl;
-		else
-			LYXERR(Debug::DEBUG)
-				<< BOOST_CURRENT_FUNCTION
-				<< ": inset has no cached position" << endl;
-#endif
-		if (inset->covers(bv, x, y)) {
-			LYXERR(Debug::DEBUG)
-				<< BOOST_CURRENT_FUNCTION
-				<< ": Hit inset: " << inset << endl;
-			return inset;
-		}
-	}
-	LYXERR(Debug::DEBUG)
-		<< BOOST_CURRENT_FUNCTION
-		<< ": No inset hit. " << endl;
-	return 0;
-}
-
-
-
-// Gets the fully instantiated font at a given position in a paragraph
-// Basically the same routine as Paragraph::getFont() in Paragraph.cpp.
-// The difference is that this one is used for displaying, and thus we
-// are allowed to make cosmetic improvements. For instance make footnotes
-// smaller. (Asger)
-Font Text::getFont(Buffer const & buffer, Paragraph const & par,
-		pos_type const pos) const
-{
-	BOOST_ASSERT(pos >= 0);
-
-	Layout_ptr const & layout = par.layout();
-#ifdef WITH_WARNINGS
-#warning broken?
-#endif
-	BufferParams const & params = buffer.params();
-	pos_type const body_pos = par.beginOfBody();
-
-	// We specialize the 95% common case:
-	if (!par.getDepth()) {
-		Font f = par.getFontSettings(params, pos);
-		if (!isMainText(buffer))
-			applyOuterFont(buffer, f);
-		Font lf;
-		Font rlf;
-		if (layout->labeltype == LABEL_MANUAL && pos < body_pos) {
-			lf = layout->labelfont;
-			rlf = layout->reslabelfont;
-		} else {
-			lf = layout->font;
-			rlf = layout->resfont;
-		}
-		// In case the default family has been customized
-		if (lf.family() == Font::INHERIT_FAMILY)
-			rlf.setFamily(params.getFont().family());
-		return f.realize(rlf);
-	}
-
-	// The uncommon case need not be optimized as much
-	Font layoutfont;
-	if (pos < body_pos)
-		layoutfont = layout->labelfont;
-	else
-		layoutfont = layout->font;
-
-	Font font = par.getFontSettings(params, pos);
-	font.realize(layoutfont);
-
-	if (!isMainText(buffer))
-		applyOuterFont(buffer, font);
-
-	// Find the pit value belonging to paragraph. This will not break
-	// even if pars_ would not be a vector anymore.
-	// Performance appears acceptable.
-
-	pit_type pit = pars_.size();
-	for (pit_type it = 0; it < pit; ++it)
-		if (&pars_[it] == &par) {
-			pit = it;
-			break;
-		}
-	// Realize against environment font information
-	// NOTE: the cast to pit_type should be removed when pit_type
-	// changes to a unsigned integer.
-	if (pit < pit_type(pars_.size()))
-		font.realize(outerFont(pit, pars_));
-
-	// Realize with the fonts of lesser depth.
-	font.realize(params.getFont());
-
-	return font;
-}
-
-// There are currently two font mechanisms in LyX:
-// 1. The font attributes in a lyxtext, and
-// 2. The inset-specific font properties, defined in an inset's
-// metrics() and draw() methods and handed down the inset chain through
-// the pi/mi parameters, and stored locally in a lyxtext in font_.
-// This is where the two are integrated in the final fully realized
-// font.
-void Text::applyOuterFont(Buffer const & buffer, Font & font) const {
-	Font lf(font_);
-	lf.reduce(buffer.params().getFont());
-	lf.realize(font);
-	lf.setLanguage(font.language());
-	font = lf;
-}
-
-
-Font Text::getLayoutFont(Buffer const & buffer, pit_type const pit) const
+FontInfo Text::getLayoutFont(Buffer const & buffer, pit_type const pit) const
 {
-	Layout_ptr const & layout = pars_[pit].layout();
+	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
 {
-	Layout_ptr const & layout = par.layout();
+	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;
 }
 
 
 void Text::setCharFont(Buffer const & buffer, pit_type pit,
-		pos_type pos, Font const & fnt)
+		pos_type pos, Font const & fnt, Font const & display_font)
 {
 	Font font = fnt;
-	Layout_ptr const & layout = pars_[pit].layout();
+	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;
@@ -296,17 +143,37 @@ 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(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);
 }
 
 
+void Text::setInsetFont(BufferView const & bv, pit_type pit,
+		pos_type pos, Font const & font, bool toggleall)
+{
+	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();
+		if (text) {
+			// last position of the cell
+			CursorSlice cellend = cs;
+			cellend.pit() = cellend.lastpit();
+			cellend.pos() = cellend.lastpos();
+			text->setFont(bv, cs, cellend, font, toggleall);
+		}
+	}
+}
+
+
 // return past-the-last paragraph influenced by a layout change on pit
 pit_type Text::undoSpan(pit_type pit)
 {
@@ -327,12 +194,12 @@ pit_type Text::undoSpan(pit_type pit)
 
 
 void Text::setLayout(Buffer const & buffer, pit_type start, pit_type end,
-		string const & layout)
+		docstring const & layout)
 {
 	BOOST_ASSERT(start != end);
 
 	BufferParams const & bufparams = buffer.params();
-	Layout_ptr const & lyxlayout = bufparams.getTextClass()[layout];
+	LayoutPtr const & lyxlayout = bufparams.textClass()[layout];
 
 	for (pit_type pit = start; pit != end; ++pit) {
 		Paragraph & par = pars_[pit];
@@ -345,16 +212,16 @@ void Text::setLayout(Buffer const & buffer, pit_type start, pit_type end,
 
 
 // set layout over selection and make a total rebreak of those paragraphs
-void Text::setLayout(Cursor & cur, string const & layout)
+void Text::setLayout(Cursor & cur, docstring const & layout)
 {
 	BOOST_ASSERT(this == cur.text());
 	// special handling of new environment insets
 	BufferView & bv = cur.bv();
-	BufferParams const & params = bv.buffer()->params();
-	Layout_ptr const & lyxlayout = params.getTextClass()[layout];
+	BufferParams const & params = bv.buffer().params();
+	LayoutPtr const & lyxlayout = params.textClass()[layout];
 	if (lyxlayout->is_environment) {
 		// move everything in a new environment inset
-		LYXERR(Debug::DEBUG) << "setting layout " << 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));
@@ -413,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) {
@@ -433,13 +300,12 @@ void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
 }
 
 
-// set font over selection
 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]);
@@ -447,76 +313,60 @@ void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
 		layoutfont = getLayoutFont(cur.buffer(), pit);
 
 	// Update current font
-	real_current_font.update(font,
+	cur.real_current_font.update(font,
 					cur.buffer().params().language,
 					toggleall);
 
 	// Reduce to implicit settings
-	current_font = real_current_font;
-	current_font.reduce(layoutfont);
+	cur.current_font = cur.real_current_font;
+	cur.current_font.fontInfo().reduce(layoutfont);
 	// And resolve it completely
-	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 there is no selection that's all we need to do
 	if (!cur.selection())
 		return;
 
 	// Ok, we have a selection.
-	recordUndoSelection(cur);
+	cur.recordUndoSelection();
 
-	DocIterator dit = cur.selectionBegin();
-	DocIterator ditend = cur.selectionEnd();
+	setFont(cur.bv(), cur.selectionBegin().top(), 
+		cur.selectionEnd().top(), font, toggleall);
+}
 
-	BufferParams const & params = cur.buffer().params();
+
+void Text::setFont(BufferView const & bv, CursorSlice const & begin,
+		CursorSlice const & end, Font const & font,
+		bool toggleall)
+{
+	Buffer const & buffer = bv.buffer();
 
 	// Don't use forwardChar here as ditend might have
 	// pos() == lastpos() and forwardChar would miss it.
 	// Can't use forwardPos either as this descends into
 	// nested insets.
-	for (; dit != ditend; dit.forwardPosNoDescend()) {
-		if (dit.pos() != dit.lastpos()) {
-			Font f = getFont(cur.buffer(), dit.paragraph(), dit.pos());
-			f.update(font, params.language, toggleall);
-			setCharFont(cur.buffer(), dit.pit(), dit.pos(), f);
+	Language const * language = buffer.params().language;
+	for (CursorSlice dit = begin; dit != end; dit.forwardPos()) {
+		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_);
 	}
 }
 
 
-// the cursor set functions have a special mechanism. When they
-// realize you left an empty paragraph, they will delete it.
-
-bool Text::cursorHome(Cursor & cur)
-{
-	BOOST_ASSERT(this == cur.text());
-	ParagraphMetrics const & pm = cur.bv().parMetrics(this, cur.pit());
-	Row const & row = pm.getRow(cur.pos(),cur.boundary());
-	return setCursor(cur, cur.pit(), row.pos());
-}
-
-
-bool Text::cursorEnd(Cursor & cur)
-{
-	BOOST_ASSERT(this == cur.text());
-	// if not on the last row of the par, put the cursor before
-	// the final space exept if I have a spanning inset or one string
-	// is so long that we force a break.
-	pos_type end = cur.textRow().endpos();
-	if (end == 0)
-		// empty text, end-1 is no valid position
-		return false;
-	bool boundary = false;
-	if (end != cur.lastpos()) {
-		if (!cur.paragraph().isLineSeparator(end-1)
-		    && !cur.paragraph().isNewline(end-1))
-			boundary = true;
-		else
-			--end;
-	}
-	return setCursor(cur, cur.pit(), end, true, boundary);
-}
-
-
 bool Text::cursorTop(Cursor & cur)
 {
 	BOOST_ASSERT(this == cur.text());
@@ -535,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;
@@ -547,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
@@ -567,57 +418,61 @@ 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();
 }
 
 
-void Text::setParagraph(Cursor & cur,
-			   Spacing const & spacing, LyXAlignment align,
-			   docstring const & labelwidthstring, bool noindent)
+void Text::setParagraphs(Cursor & cur, docstring arg, bool merge) 
 {
 	BOOST_ASSERT(cur.text());
 	// make sure that the depth behind the selection are restored, too
 	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.spacing(spacing);
+		ParagraphParameters params = par.params();
+		params.read(argument, merge);
+		par.params().apply(params, *par.layout());
+	}
+}
 
-		// does the layout allow the new alignment?
-		Layout_ptr const & layout = par.layout();
 
-		if (align == LYX_ALIGN_LAYOUT)
-			align = layout->align;
-		if (align & layout->alignpossible) {
-			if (align == layout->align)
-				params.align(LYX_ALIGN_LAYOUT);
-			else
-				params.align(align);
-		}
-		par.setLabelWidthString(labelwidthstring);
-		params.noindent(noindent);
-	}
+//FIXME This is a little redundant now, but it's probably worth keeping,
+//especially if we're going to go away from using serialization internally
+//quite so much.
+void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p) 
+{
+	BOOST_ASSERT(cur.text());
+	// make sure that the depth behind the selection are restored, too
+	pit_type undopit = undoSpan(cur.selEnd().pit());
+	recUndo(cur, cur.selBegin().pit(), undopit - 1);
+
+	for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
+	     pit <= end; ++pit) {
+		Paragraph & par = pars_[pit];
+		Layout const & layout = *(par.layout());
+		par.params().apply(p, layout);
+	}	
 }
 
 
@@ -626,9 +481,9 @@ void Text::insertInset(Cursor & cur, Inset * inset)
 {
 	BOOST_ASSERT(this == cur.text());
 	BOOST_ASSERT(inset);
-	cur.paragraph().insertInset(cur.pos(), inset, 
-				    Change(cur.buffer().params().trackChanges ?
-				    	   Change::INSERTED : Change::UNCHANGED));
+	cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
+		Change(cur.buffer().params().trackChanges
+		? Change::INSERTED : Change::UNCHANGED));
 }
 
 
@@ -636,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(),
-					 current_font, str, autoBreakRows_);
+		cur.current_font, str, autoBreakRows_);
 }
 
 
@@ -670,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;
 }
 
 
@@ -707,409 +564,329 @@ void Text::setCursorIntern(Cursor & cur,
 	cur.boundary(boundary);
 	setCursor(cur.top(), par, pos);
 	if (setfont)
-		setCurrentFont(cur);
-}
-
-
-void Text::setCurrentFont(Cursor & cur)
-{
-	BOOST_ASSERT(this == cur.text());
-	pos_type pos = cur.pos();
-	Paragraph & par = cur.paragraph();
-
-	if (cur.boundary() && pos > 0)
-		--pos;
-
-	if (pos > 0) {
-		if (pos == cur.lastpos())
-			--pos;
-		else // potentional bug... BUG (Lgb)
-			if (par.isSeparator(pos)) {
-				if (pos > cur.textRow().pos() &&
-				    bidi.level(pos) % 2 ==
-				    bidi.level(pos - 1) % 2)
-					--pos;
-				else if (pos + 1 < cur.lastpos())
-					++pos;
-			}
-	}
-
-	BufferParams const & bufparams = cur.buffer().params();
-	current_font = par.getFontSettings(bufparams, pos);
-	real_current_font = getFont(cur.buffer(), par, pos);
-
-	if (cur.pos() == cur.lastpos()
-	    && bidi.isBoundary(cur.buffer(), par, cur.pos())
-	    && !cur.boundary()) {
-		Language const * lang = par.getParLanguage(bufparams);
-		current_font.setLanguage(lang);
-		current_font.setNumber(Font::OFF);
-		real_current_font.setLanguage(lang);
-		real_current_font.setNumber(Font::OFF);
-	}
+		cur.setCurrentFont();
 }
 
-// y is screen coordinate
-pit_type Text::getPitNearY(BufferView & bv, int y) const
-{
-	BOOST_ASSERT(!paragraphs().empty());
-	BOOST_ASSERT(bv.coordCache().getParPos().find(this) != bv.coordCache().getParPos().end());
-	CoordCache::InnerParPosCache const & cc = bv.coordCache().getParPos().find(this)->second;
-	LYXERR(Debug::DEBUG)
-		<< BOOST_CURRENT_FUNCTION
-		<< ": y: " << y << " cache size: " << cc.size()
-		<< endl;
-
-	// look for highest numbered paragraph with y coordinate less than given y
-	pit_type pit = 0;
-	int yy = -1;
-	CoordCache::InnerParPosCache::const_iterator it = cc.begin();
-	CoordCache::InnerParPosCache::const_iterator et = cc.end();
-	CoordCache::InnerParPosCache::const_iterator last = et; last--;
-
-	TextMetrics & tm = bv.textMetrics(this);
-	ParagraphMetrics const & pm = tm.parMetrics(it->first);
-
-	// If we are off-screen (before the visible part)
-	if (y < 0
-		// and even before the first paragraph in the cache.
-		&& y < it->second.y_ - int(pm.ascent())) {
-		//  and we are not at the first paragraph in the inset.
-		if (it->first == 0)
-			return 0;
-		// then this is the paragraph we are looking for.
-		pit = it->first - 1;
-		// rebreak it and update the CoordCache.
-		tm.redoParagraph(pit);
-		bv.coordCache().parPos()[this][pit] =
-			Point(0, it->second.y_ - pm.descent());
-		return pit;
-	}
 
-	ParagraphMetrics const & pm_last = bv.parMetrics(this, last->first);
-
-	// If we are off-screen (after the visible part)
-	if (y > bv.workHeight()
-		// and even after the first paragraph in the cache.
-		&& y >= last->second.y_ + int(pm_last.descent())) {
-		pit = last->first + 1;
-		//  and we are not at the last paragraph in the inset.
-		if (pit == int(pars_.size()))
-			return last->first;
-		// then this is the paragraph we are looking for.
-		// rebreak it and update the CoordCache.
-		tm.redoParagraph(pit);
-		bv.coordCache().parPos()[this][pit] =
-			Point(0, last->second.y_ + pm_last.ascent());
-		return pit;
-	}
-
-	for (; it != et; ++it) {
-		LYXERR(Debug::DEBUG)
-			<< BOOST_CURRENT_FUNCTION
-			<< "  examining: pit: " << it->first
-			<< " y: " << it->second.y_
-			<< endl;
-
-		ParagraphMetrics const & pm = bv.parMetrics(this, it->first);
-
-		if (it->first >= pit && int(it->second.y_) - int(pm.ascent()) <= y) {
-			pit = it->first;
-			yy = it->second.y_;
-		}
-	}
-
-	LYXERR(Debug::DEBUG)
-		<< BOOST_CURRENT_FUNCTION
-		<< ": found best y: " << yy << " for pit: " << pit
-		<< endl;
-
-	return pit;
-}
-
-
-Row const & Text::getRowNearY(BufferView const & bv, int y, pit_type pit) const
-{
-	ParagraphMetrics const & pm = bv.parMetrics(this, pit);
-
-	int yy = bv.coordCache().get(this, pit).y_ - pm.ascent();
-	BOOST_ASSERT(!pm.rows().empty());
-	RowList::const_iterator rit = pm.rows().begin();
-	RowList::const_iterator const rlast = boost::prior(pm.rows().end());
-	for (; rit != rlast; yy += rit->height(), ++rit)
-		if (yy + rit->height() > y)
-			break;
-	return *rit;
-}
-
-
-// x,y are absolute screen coordinates
-// sets cursor recursively descending into nested editable insets
-Inset * Text::editXY(Cursor & cur, int x, int y)
+bool Text::checkAndActivateInset(Cursor & cur, bool front)
 {
-	if (lyxerr.debugging(Debug::WORKAREA)) {
-		lyxerr << "Text::editXY(cur, " << x << ", " << y << ")" << std::endl;
-		cur.bv().coordCache().dump();
-	}
-	pit_type pit = getPitNearY(cur.bv(), y);
-	BOOST_ASSERT(pit != -1);
-
-	Row const & row = getRowNearY(cur.bv(), y, pit);
-	bool bound = false;
-
-	TextMetrics const & tm = cur.bv().textMetrics(this);
-	int xx = x; // is modified by getColumnNearX
-	pos_type const pos = row.pos()
-		+ tm.getColumnNearX(pit, row, xx, bound);
-	cur.pit() = pit;
-	cur.pos() = pos;
-	cur.boundary(bound);
-	cur.x_target() = x;
-
-	// try to descend into nested insets
-	Inset * inset = checkInsetHit(cur.bv(), x, y);
-	//lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
-	if (!inset) {
-		// Either we deconst editXY or better we move current_font
-		// and real_current_font to Cursor
-		setCurrentFont(cur);
-		return 0;
-	}
-
-	Inset * insetBefore = pos? pars_[pit].getInset(pos - 1): 0;
-	//Inset * insetBehind = pars_[pit].getInset(pos);
-
-	// This should be just before or just behind the
-	// cursor position set above.
-	BOOST_ASSERT((pos != 0 && inset == insetBefore)
-		|| inset == pars_[pit].getInset(pos));
-
-	// Make sure the cursor points to the position before
-	// this inset.
-	if (inset == insetBefore)
+	if (cur.selection())
+		return false;
+	if (front && cur.pos() == cur.lastpos())
+		return false;
+	if (!front && cur.pos() == 0)
+		return false;
+	Inset * inset = front ? cur.nextInset() : cur.prevInset();
+	if (!inset || inset->editable() != Inset::HIGHLY_EDITABLE)
+		return false;
+	/*
+	 * Apparently, when entering an inset we are expected to be positioned
+	 * *before* it in the containing paragraph, regardless of the direction
+	 * from which we are entering. Otherwise, cursor placement goes awry,
+	 * and when we exit from the beginning, we'll be placed *after* the
+	 * inset.
+	 */
+	if (!front)
 		--cur.pos();
-
-	// Try to descend recursively inside the inset.
-	inset = inset->editXY(cur, x, y);
-
-	if (cur.top().text() == this)
-		setCurrentFont(cur);
-	return inset;
+	inset->edit(cur, front);
+	return true;
 }
 
 
-bool Text::checkAndActivateInset(Cursor & cur, bool front)
+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;
-	Inset * inset = cur.nextInset();
-	if (!isHighlyEditableInset(inset))
+	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, front);
+	inset->edit(cur, movingForward, 
+		movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
 	return true;
 }
 
 
-bool Text::cursorLeft(Cursor & cur)
+bool Text::cursorBackward(Cursor & cur)
 {
 	// Tell BufferView to test for FitCursor in any case!
 	cur.updateFlags(Update::FitCursor);
 
-	if (!cur.boundary() && cur.pos() > 0 &&
-	    cur.textRow().pos() == cur.pos() &&
-	    !cur.paragraph().isLineSeparator(cur.pos()-1) &&
-	    !cur.paragraph().isNewline(cur.pos()-1)) {
-		return setCursor(cur, cur.pit(), cur.pos(), true, true);
-	}
-	if (cur.pos() != 0) {
-		bool updateNeeded = setCursor(cur, cur.pit(), cur.pos() - 1, true, false);
-		if (!checkAndActivateInset(cur, false)) {
-			/** FIXME: What's this cause purpose???
-			bool boundary = cur.boundary();
-			if (false && !boundary &&
-			    bidi.isBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
-				updateNeeded |=
-					setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
-			*/
+	// not at paragraph start?
+	if (cur.pos() > 0) {
+		// if on right side of boundary (i.e. not at paragraph end, but line end)
+		// -> skip it, i.e. set boundary to true, i.e. go only logically left
+		// there are some exceptions to ignore this: lineseps, newlines, spaces
+#if 0
+		// some effectless debug code to see the values in the debugger
+		bool bound = cur.boundary();
+		int rowpos = cur.textRow().pos();
+		int pos = cur.pos();
+		bool sep = cur.paragraph().isSeparator(cur.pos() - 1);
+		bool newline = cur.paragraph().isNewline(cur.pos() - 1);
+		bool linesep = cur.paragraph().isLineSeparator(cur.pos() - 1);
+#endif
+		if (!cur.boundary() &&
+				cur.textRow().pos() == cur.pos() &&
+				!cur.paragraph().isLineSeparator(cur.pos() - 1) &&
+				!cur.paragraph().isNewline(cur.pos() - 1) &&
+				!cur.paragraph().isSeparator(cur.pos() - 1)) {
+			return setCursor(cur, cur.pit(), cur.pos(), true, true);
 		}
-		return updateNeeded;
+		
+		// go left and try to enter inset
+		if (checkAndActivateInset(cur, false))
+			return false;
+		
+		// normal character left
+		return setCursor(cur, cur.pit(), cur.pos() - 1, true, false);
 	}
 
-	if (cur.pit() != 0) {
-		// Steps into the paragraph above
-		return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size());
-	}
+	// move to the previous paragraph or do nothing
+	if (cur.pit() > 0)
+		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)
 {
-	// Tell BufferView to test for FitCursor in any case!
-	cur.updateFlags(Update::FitCursor);
+	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;
+	}
 
-	if (cur.pos() != cur.lastpos()) {
-		if (cur.boundary())
-			return setCursor(cur, cur.pit(), cur.pos(),
-					 true, false);
-
-		bool updateNeeded = false;
-		if (!checkAndActivateInset(cur, true)) {
-			if (cur.textRow().endpos() == cur.pos() + 1 &&
-			    cur.textRow().endpos() != cur.lastpos() &&
-			    !cur.paragraph().isLineSeparator(cur.pos()) &&
-			    !cur.paragraph().isNewline(cur.pos())) {
-				cur.boundary(true);
-			}
-			updateNeeded |= setCursor(cur, cur.pit(), cur.pos() + 1, true, cur.boundary());
-			if (false && bidi.isBoundary(cur.buffer(), cur.paragraph(),
-						     cur.pos()))
-				updateNeeded |= setCursor(cur, cur.pit(), cur.pos(), true, true);
+	// 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;
 		}
-		return updateNeeded;
+		
+		// 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;
+		}
+	
 	}
 
-	if (cur.pit() != cur.lastpit())
-		return setCursor(cur, cur.pit() + 1, 0);
-	return false;
+	LYXERR(Debug::RTL, "moving to: " << new_pos 
+		<< (new_boundary ? " (boundary)" : ""));
+
+	return setCursor(cur, new_pit, new_pos, true, new_boundary);
 }
 
 
-bool Text::cursorUp(Cursor & cur)
+bool Text::cursorVisRight(Cursor & cur, bool skip_inset)
 {
-	// Tell BufferView to test for FitCursor in any case!
-	cur.updateFlags(Update::FitCursor);
-
-	TextMetrics const & tm = cur.bv().textMetrics(this);
-	ParagraphMetrics const & pm = tm.parMetrics(cur.pit());
-
-	int row;
-	if (cur.pos() && cur.boundary())
-		row = pm.pos2row(cur.pos()-1);
-	else
-		row = pm.pos2row(cur.pos());
-
-	int x = cur.targetX();
-	cur.setTargetX();
-	// We want to keep the x-target on subsequent up movements
-	// that cross beyond the end of short lines. Thus a special
-	// handling when the cursor is at the end of line: Use the new 
-	// x-target only if the old one was before the end of line.
-	if (cur.pos() != pm.rows()[row].endpos() 
-		|| (!isWithinRtlParagraph(cur) && x < cur.targetX())
-		|| (isWithinRtlParagraph(cur) && x > cur.targetX())) {
-
-		x = cur.targetX();
+	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;
 	}
 
-	if (!cur.selection()) {
-		int const y = bv_funcs::getPos(cur.bv(), cur, cur.boundary()).y_;
-		Cursor old = cur;
-		// Go to middle of previous row. 16 found to work OK;
-		// 12 = top/bottom margin of display math
-		int const margin = 3 * InsetMathHull::displayMargin() / 2;
-		editXY(cur, x, y - pm.rows()[row].ascent() - margin);
-		cur.clearSelection();
+	// 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();
 
-		// 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 = cur;
-		if (dummy == old)
-			++dummy.pos();
+		LYXERR(Debug::RTL, "right edge, moving: " << int(new_pit) << "," 
+			<< int(new_pos) << "," << (new_boundary ? 1 : 0));
 
-		cur.bv().checkDepm(dummy, old);
-		return false;
 	}
-
-	bool updateNeeded = false;
-
-	if (row > 0) {
-		updateNeeded |= setCursor(cur, cur.pit(),
-			tm.x2pos(cur.pit(), row - 1, x));
-	} else if (cur.pit() > 0) {
-		--cur.pit();
-		//cannot use 'par' now
-		ParagraphMetrics const & pmcur = cur.bv().parMetrics(this, cur.pit());
-		updateNeeded |= setCursor(cur, cur.pit(),
-			tm.x2pos(cur.pit(), pmcur.rows().size() - 1, x));
+	// 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;
+		}
+	
 	}
 
-	cur.x_target() = x;
+	LYXERR(Debug::RTL, "moving to: " << new_pos 
+		<< (new_boundary ? " (boundary)" : ""));
 
-	return updateNeeded;
+	return setCursor(cur, new_pit, new_pos, true, new_boundary);
 }
 
 
-bool Text::cursorDown(Cursor & cur)
+bool Text::cursorForward(Cursor & cur)
 {
 	// Tell BufferView to test for FitCursor in any case!
 	cur.updateFlags(Update::FitCursor);
 
-	TextMetrics const & tm = cur.bv().textMetrics(this);
-	ParagraphMetrics const & pm = tm.parMetrics(cur.pit());
-
-	int row;
-	if (cur.pos() && cur.boundary())
-		row = pm.pos2row(cur.pos()-1);
-	else
-		row = pm.pos2row(cur.pos());
-
-	int x = cur.targetX();
-	cur.setTargetX();
-	// We want to keep the x-target on subsequent down movements
-	// that cross beyond the end of short lines. Thus a special
-	// handling when the cursor is at the end of line: Use the new 
-	// x-target only if the old one was before the end of line.
-	if (cur.pos() != pm.rows()[row].endpos() 
-		|| (!isWithinRtlParagraph(cur) && x < cur.targetX())
-		|| (isWithinRtlParagraph(cur) && x > cur.targetX())) {
-
-		x = cur.targetX();
-	}
-
-	if (!cur.selection()) {
-		int const y = bv_funcs::getPos(cur.bv(), cur, cur.boundary()).y_;
-		Cursor old = cur;
-		// To middle of next row
-		int const margin = 3 * InsetMathHull::displayMargin() / 2;
-		editXY(cur, x, y + pm.rows()[row].descent() + margin);
-		cur.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 = cur;
-		if (dummy == old)
-			++dummy.pos();
+	// not at paragraph end?
+	if (cur.pos() != cur.lastpos()) {
+		// in front of editable inset, i.e. jump into it?
+		if (checkAndActivateInset(cur, true))
+			return false;
+
+		TextMetrics const & tm = cur.bv().textMetrics(this);
+		// if left of boundary -> just jump to right side
+		// but for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi
+		if (cur.boundary() && !tm.isRTLBoundary(cur.pit(), cur.pos()))
+			return setCursor(cur, cur.pit(), cur.pos(), true, false);
+
+		// next position is left of boundary, 
+		// but go to next line for special cases like space, newline, linesep
+#if 0
+		// some effectless debug code to see the values in the debugger
+		int endpos = cur.textRow().endpos();
+		int lastpos = cur.lastpos();
+		int pos = cur.pos();
+		bool linesep = cur.paragraph().isLineSeparator(cur.pos());
+		bool newline = cur.paragraph().isNewline(cur.pos());
+		bool sep = cur.paragraph().isSeparator(cur.pos());
+		if (cur.pos() != cur.lastpos()) {
+			bool linesep2 = cur.paragraph().isLineSeparator(cur.pos()+1);
+			bool newline2 = cur.paragraph().isNewline(cur.pos()+1);
+			bool sep2 = cur.paragraph().isSeparator(cur.pos()+1);
+		}
+#endif
+		if (cur.textRow().endpos() == cur.pos() + 1 &&
+		    cur.textRow().endpos() != cur.lastpos() &&
+				!cur.paragraph().isNewline(cur.pos()) &&
+				!cur.paragraph().isLineSeparator(cur.pos()) &&
+				!cur.paragraph().isSeparator(cur.pos())) {
+			return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
+		}
 		
-		bool const changed = cur.bv().checkDepm(dummy, old);
-
-		// Make sure that cur gets back whatever happened to dummy(Lgb)
-		if (changed)
-			cur = dummy;
-
-		return false;
-	}
-
-	bool updateNeeded = false;
-
-	if (row + 1 < int(pm.rows().size())) {
-		updateNeeded |= setCursor(cur, cur.pit(),
-			tm.x2pos(cur.pit(), row + 1, x));
-	} else if (cur.pit() + 1 < int(paragraphs().size())) {
-		++cur.pit();
-		updateNeeded |= setCursor(cur, cur.pit(),
-			tm.x2pos(cur.pit(), 0, x));
+		// in front of RTL boundary? Stay on this side of the boundary because:
+		//   ab|cDDEEFFghi -> abc|DDEEFFghi
+		if (tm.isRTLBoundary(cur.pit(), cur.pos() + 1))
+			return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
+		
+		// move right
+		return setCursor(cur, cur.pit(), cur.pos() + 1, true, false);
 	}
 
-	cur.x_target() = x;
-
-	return updateNeeded;
+	// move to next paragraph
+	if (cur.pit() != cur.lastpit())
+		return setCursor(cur, cur.pit() + 1, 0, true, false);
+	return false;
 }
 
 
@@ -1158,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();
 
@@ -1194,14 +971,13 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 		    && old.pos() < oldpar.size()
 		    && oldpar.isLineSeparator(old.pos())
 		    && oldpar.isLineSeparator(old.pos() - 1)
-		    && !oldpar.isDeleted(old.pos() - 1)) {
+		    && !oldpar.isDeleted(old.pos() - 1)
+		    && !oldpar.isDeleted(old.pos())) {
 			oldpar.eraseChar(old.pos() - 1, cur.buffer().params().trackChanges);
-#ifdef WITH_WARNINGS
-#warning This will not work anymore when we have multiple views of the same buffer
+// FIXME: This will not work anymore when we have multiple views of the same buffer
 // In this case, we will have to correct also the cursors held by
 // other bufferviews. It will probably be easier to do that in a more
 // automated way in CursorSlice code. (JMarc 26/09/2001)
-#endif
 			// correct all cursor parts
 			if (same_par) {
 				fixCursorAfterDelete(cur.top(), old.top());
@@ -1225,13 +1001,17 @@ 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 && old.pit() < pit_type(plist.size()))
+			plist[old.pit()].params().startOfAppendix(true);
 
-		// see #warning above
+		// see #warning (FIXME?) above 
 		if (cur.depth() >= old.depth()) {
 			CursorSlice & curslice = cur[old.depth() - 1];
 			if (&curslice.inset() == &old.inset()
@@ -1280,7 +1060,7 @@ void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool tra
 		}
 
 		// don't delete anything if this is the only remaining paragraph within the given range
-		// note: Text::acceptOrRejectChanges() sets the cursor to 'first' after calling DEPM 
+		// note: Text::acceptOrRejectChanges() sets the cursor to 'first' after calling DEPM
 		if (first == last)
 			continue;
 
@@ -1302,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