X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText2.cpp;h=07839a748d016e4d6609a9354bd41e014aecd424;hb=62af7ee772f16f154225d2d0b65d77f4376b6001;hp=9ce5d98fa9330ebf94c12a5b03a9444719effd55;hpb=dec437fbac739fb4d8e78842b9f9286bbaaf0971;p=lyx.git

diff --git a/src/Text2.cpp b/src/Text2.cpp
index 9ce5d98fa9..07839a748d 100644
--- a/src/Text2.cpp
+++ b/src/Text2.cpp
@@ -22,7 +22,6 @@
 
 #include "Text.h"
 
-#include "Bidi.h"
 #include "Buffer.h"
 #include "buffer_funcs.h"
 #include "BufferList.h"
@@ -42,19 +41,17 @@
 #include "ParagraphParameters.h"
 #include "TextClass.h"
 #include "TextMetrics.h"
-#include "VSpace.h"
 
-#include "insets/InsetCollapsable.h"
+#include "insets/InsetCollapsible.h"
 
 #include "mathed/InsetMathHull.h"
 
 #include "support/lassert.h"
 #include "support/debug.h"
 #include "support/gettext.h"
+#include "support/lyxalgo.h"
 #include "support/textutils.h"
 
-#include <boost/next_prior.hpp>
-
 #include <sstream>
 
 using namespace std;
@@ -77,16 +74,7 @@ FontInfo Text::layoutFont(pit_type const pit) const
 		// In case the default family has been customized
 		if (layout.font.family() == INHERIT_FAMILY)
 			lf.setFamily(owner_->buffer().params().getFont().fontInfo().family());
-		// FIXME
-		// It ought to be possible here just to use Inset::getLayout() and skip
-		// the asInsetCollapsable() bit. Unfortunatley, that doesn't work right
-		// now, because Inset::getLayout() will return a default-constructed
-		// InsetLayout, and that e.g. sets the foreground color to red. So we
-		// need to do some work to make that possible.
-		InsetCollapsable const * icp = owner_->asInsetCollapsable();
-		if (!icp)
-			return lf;
-		FontInfo icf = icp->getLayout().font();
+		FontInfo icf = owner_->getLayout().font();
 		icf.realize(lf);
 		return icf;
 	}
@@ -164,10 +152,10 @@ void Text::setCharFont(pit_type pit,
 
 
 void Text::setInsetFont(BufferView const & bv, pit_type pit,
-		pos_type pos, Font const & font, bool toggleall)
+		pos_type pos, Font const & font)
 {
 	Inset * const inset = pars_[pit].getInset(pos);
-	LASSERT(inset && inset->noFontChange(), /**/);
+	LASSERT(inset && inset->resetFontEdit(), return);
 
 	CursorSlice::idx_type endidx = inset->nargs();
 	for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
@@ -177,35 +165,16 @@ void Text::setInsetFont(BufferView const & bv, pit_type pit,
 			CursorSlice cellend = cs;
 			cellend.pit() = cellend.lastpit();
 			cellend.pos() = cellend.lastpos();
-			text->setFont(bv, cs, cellend, font, toggleall);
+			text->setFont(bv, cs, cellend, font);
 		}
 	}
 }
 
 
-// return past-the-last paragraph influenced by a layout change on pit
-pit_type Text::undoSpan(pit_type pit)
-{
-	pit_type const end = paragraphs().size();
-	pit_type nextpit = pit + 1;
-	if (nextpit == end)
-		return nextpit;
-	//because of parindents
-	if (!pars_[pit].getDepth())
-		return boost::next(nextpit);
-	//because of depth constrains
-	for (; nextpit != end; ++pit, ++nextpit) {
-		if (!pars_[pit].getDepth())
-			break;
-	}
-	return nextpit;
-}
-
-
 void Text::setLayout(pit_type start, pit_type end,
 		     docstring const & layout)
 {
-	LASSERT(start != end, /**/);
+	LASSERT(start != end, return);
 
 	Buffer const & buffer = owner_->buffer();
 	BufferParams const & bp = buffer.params();
@@ -217,19 +186,22 @@ void Text::setLayout(pit_type start, pit_type end,
 		if (lyxlayout.margintype == MARGIN_MANUAL)
 			par.setLabelWidthString(par.expandLabel(lyxlayout, bp));
 	}
+
+	deleteEmptyParagraphMechanism(start, end - 1, bp.track_changes);
 }
 
 
 // set layout over selection and make a total rebreak of those paragraphs
 void Text::setLayout(Cursor & cur, docstring const & layout)
 {
-	LASSERT(this == cur.text(), /**/);
+	LBUFERR(this == cur.text());
 
 	pit_type start = cur.selBegin().pit();
 	pit_type end = cur.selEnd().pit() + 1;
-	pit_type undopit = undoSpan(end - 1);
-	recUndo(cur, start, undopit - 1);
+	cur.recordUndoSelection();
 	setLayout(start, end, layout);
+	cur.fixIfBroken();
+	cur.setCurrentFont();
 	cur.forceBufferUpdate();
 }
 
@@ -237,8 +209,6 @@ void Text::setLayout(Cursor & cur, docstring const & layout)
 static bool changeDepthAllowed(Text::DEPTH_CHANGE type,
 			Paragraph const & par, int max_depth)
 {
-	if (par.layout().labeltype == LABEL_BIBLIO)
-		return false;
 	int const depth = par.params().depth();
 	if (type == Text::INC_DEPTH && depth < max_depth)
 		return true;
@@ -250,7 +220,7 @@ static bool changeDepthAllowed(Text::DEPTH_CHANGE type,
 
 bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
 {
-	LASSERT(this == cur.text(), /**/);
+	LBUFERR(this == cur.text());
 	// this happens when selecting several cells in tabular (bug 2630)
 	if (cur.selBegin().idx() != cur.selEnd().idx())
 		return false;
@@ -270,7 +240,7 @@ bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
 
 void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
 {
-	LASSERT(this == cur.text(), /**/);
+	LBUFERR(this == cur.text());
 	pit_type const beg = cur.selBegin().pit();
 	pit_type const end = cur.selEnd().pit() + 1;
 	cur.recordUndoSelection();
@@ -295,7 +265,12 @@ void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
 
 void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
 {
-	LASSERT(this == cur.text(), /**/);
+	LASSERT(this == cur.text(), return);
+
+	// If there is a selection, record undo before the cursor font is changed.
+	if (cur.selection())
+		cur.recordUndoSelection();
+
 	// Set the current_font
 	// Determine basis font
 	FontInfo layoutfont;
@@ -321,16 +296,71 @@ void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
 		return;
 
 	// Ok, we have a selection.
-	cur.recordUndoSelection();
+	Font newfont = font;
+
+	if (toggleall) {
+		// Toggling behaves as follows: We check the first character of the
+		// selection. If it's (say) got EMPH on, then we set to off; if off,
+		// then to on. With families and the like, we set it to INHERIT, if
+		// we already have it.
+		CursorSlice const & sl = cur.selBegin();
+		Text const & text = *sl.text();
+		Paragraph const & par = text.getPar(sl.pit());
+
+		// get font at the position
+		Font oldfont = par.getFont(cur.bv().buffer().params(), sl.pos(),
+			text.outerFont(sl.pit()));
+		FontInfo const & oldfi = oldfont.fontInfo();
+
+		FontInfo & newfi = newfont.fontInfo();
+
+		FontFamily newfam = newfi.family();
+		if (newfam !=	INHERIT_FAMILY && newfam != IGNORE_FAMILY &&
+				newfam == oldfi.family())
+			newfi.setFamily(INHERIT_FAMILY);
+
+		FontSeries newser = newfi.series();
+		if (newser == BOLD_SERIES && oldfi.series() == BOLD_SERIES)
+			newfi.setSeries(INHERIT_SERIES);
+
+		FontShape newshp = newfi.shape();
+		if (newshp != INHERIT_SHAPE && newshp != IGNORE_SHAPE &&
+				newshp == oldfi.shape())
+			newfi.setShape(INHERIT_SHAPE);
+
+		ColorCode newcol = newfi.color();
+		if (newcol != Color_none && newcol != Color_inherit
+		    && newcol != Color_ignore && newcol == oldfi.color())
+			newfi.setColor(Color_none);
+
+		// ON/OFF ones
+		if (newfi.emph() == FONT_TOGGLE)
+			newfi.setEmph(oldfi.emph() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.underbar() == FONT_TOGGLE)
+			newfi.setUnderbar(oldfi.underbar() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.strikeout() == FONT_TOGGLE)
+			newfi.setStrikeout(oldfi.strikeout() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.xout() == FONT_TOGGLE)
+			newfi.setXout(oldfi.xout() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.uuline() == FONT_TOGGLE)
+			newfi.setUuline(oldfi.uuline() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.uwave() == FONT_TOGGLE)
+			newfi.setUwave(oldfi.uwave() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.noun() == FONT_TOGGLE)
+			newfi.setNoun(oldfi.noun() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.number() == FONT_TOGGLE)
+			newfi.setNumber(oldfi.number() == FONT_OFF ? FONT_ON : FONT_OFF);
+		if (newfi.nospellcheck() == FONT_TOGGLE)
+			newfi.setNoSpellcheck(oldfi.nospellcheck() == FONT_OFF ? FONT_ON : FONT_OFF);
+	}
 
-	setFont(cur.bv(), cur.selectionBegin().top(), 
-		cur.selectionEnd().top(), font, toggleall);
+	setFont(cur.bv(), cur.selectionBegin().top(),
+		cur.selectionEnd().top(), newfont);
 }
 
 
 void Text::setFont(BufferView const & bv, CursorSlice const & begin,
-		CursorSlice const & end, Font const & font,
-		bool toggleall)
+		CursorSlice const & end, Font const & font)
 {
 	Buffer const & buffer = bv.buffer();
 
@@ -345,18 +375,16 @@ void Text::setFont(BufferView const & bv, CursorSlice const & begin,
 		pit_type const pit = dit.pit();
 		pos_type const pos = dit.pos();
 		Inset * inset = pars_[pit].getInset(pos);
-		if (inset && inset->noFontChange()) {
+		if (inset && inset->resetFontEdit()) {
 			// 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);
+			// text cells of the inset (bugs 1973, 6919).
+			setInsetFont(bv, pit, pos, font);
 		}
 		TextMetrics const & tm = bv.textMetrics(this);
 		Font f = tm.displayFont(pit, pos);
-		f.update(font, language, toggleall);
+		f.update(font, language);
 		setCharFont(pit, pos, f, tm.font_);
-		// font change may change language... 
+		// font change may change language...
 		// spell checker has to know that
 		pars_[pit].requestSpellCheck(pos);
 	}
@@ -365,21 +393,21 @@ void Text::setFont(BufferView const & bv, CursorSlice const & begin,
 
 bool Text::cursorTop(Cursor & cur)
 {
-	LASSERT(this == cur.text(), /**/);
+	LBUFERR(this == cur.text());
 	return setCursor(cur, 0, 0);
 }
 
 
 bool Text::cursorBottom(Cursor & cur)
 {
-	LASSERT(this == cur.text(), /**/);
-	return setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
+	LBUFERR(this == cur.text());
+	return setCursor(cur, cur.lastpit(), prev(paragraphs().end(), 1)->size());
 }
 
 
 void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
 {
-	LASSERT(this == cur.text(), /**/);
+	LBUFERR(this == cur.text());
 	// If the mask is completely neutral, tell user
 	if (font.fontInfo() == ignore_font && font.language() == ignore_language) {
 		// Could only happen with user style
@@ -409,9 +437,9 @@ void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
 }
 
 
-docstring Text::getStringToIndex(Cursor const & cur)
+docstring Text::getStringForDialog(Cursor & cur)
 {
-	LASSERT(this == cur.text(), /**/);
+	LBUFERR(this == cur.text());
 
 	if (cur.selection())
 		return cur.selectionAsString(false);
@@ -419,98 +447,89 @@ docstring Text::getStringToIndex(Cursor const & cur)
 	// 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();
+	selectWordWhenUnderCursor(cur, WHOLE_WORD);
+	docstring const & retval = cur.selectionAsString(false);
+	cur.clearSelection();
+	return retval;
 }
 
 
-void Text::setLabelWidthStringToSequence(pit_type const par_offset,
+void Text::setLabelWidthStringToSequence(Cursor const & cur,
 		docstring const & s)
 {
-	pit_type offset = par_offset;
+	Cursor c = cur;
 	// Find first of same layout in sequence
-	while (!isFirstInSequence(offset)) {
-		offset = depthHook(offset, pars_[offset].getDepth());
+	while (!isFirstInSequence(c.pit())) {
+		c.pit() = depthHook(c.pit(), c.paragraph().getDepth());
 	}
 
 	// now apply label width string to every par
 	// in sequence
-	pit_type const end = pars_.size();
-	depth_type const depth = pars_[offset].getDepth();
-	Layout const & layout = pars_[offset].layout();
-	for (pit_type pit = offset; pit != end; ++pit) {
-		while (pars_[pit].getDepth() > depth)
-			++pit;
-		if (pars_[pit].getDepth() < depth)
+	depth_type const depth = c.paragraph().getDepth();
+	Layout const & layout = c.paragraph().layout();
+	for ( ; c.pit() <= c.lastpit() ; ++c.pit()) {
+		while (c.paragraph().getDepth() > depth) {
+			++c.pit();
+			if (c.pit() > c.lastpit())
+				return;
+		}
+		if (c.paragraph().getDepth() < depth)
 			return;
-		if (pars_[pit].layout() != layout)
+		if (c.paragraph().layout() != layout)
 			return;
-		pars_[pit].setLabelWidthString(s);
+		c.recordUndo();
+		c.paragraph().setLabelWidthString(s);
 	}
 }
 
 
-void Text::setParagraphs(Cursor & cur, docstring arg, bool merge) 
+void Text::setParagraphs(Cursor & cur, docstring const & arg, bool merge)
 {
-	LASSERT(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);
+	LBUFERR(cur.text());
 
 	//FIXME UNICODE
 	string const argument = to_utf8(arg);
 	depth_type priordepth = -1;
 	Layout priorlayout;
-	for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
-	     pit <= end; ++pit) {
-		Paragraph & par = pars_[pit];
+	Cursor c(cur.bv());
+	c.setCursor(cur.selectionBegin());
+	for ( ; c <= cur.selectionEnd() ; ++c.pit()) {
+		Paragraph & par = c.paragraph();
 		ParagraphParameters params = par.params();
 		params.read(argument, merge);
 		// Changes to label width string apply to all paragraphs
 		// with same layout in a sequence.
 		// Do this only once for a selected range of paragraphs
 		// of the same layout and depth.
-		if (par.getDepth() != priordepth || par.layout() != priorlayout)
-			setLabelWidthStringToSequence(pit, params.labelWidthString());
+		c.recordUndo();
 		par.params().apply(params, par.layout());
+		if (par.getDepth() != priordepth || par.layout() != priorlayout)
+			setLabelWidthStringToSequence(c, params.labelWidthString());
 		priordepth = par.getDepth();
 		priorlayout = par.layout();
 	}
 }
 
 
-//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) 
+void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p)
 {
-	LASSERT(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);
+	LBUFERR(cur.text());
 
 	depth_type priordepth = -1;
 	Layout priorlayout;
-	for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
-	     pit <= end; ++pit) {
-		Paragraph & par = pars_[pit];
+	Cursor c(cur.bv());
+	c.setCursor(cur.selectionBegin());
+	for ( ; c < cur.selectionEnd() ; ++c.pit()) {
+		Paragraph & par = c.paragraph();
 		// Changes to label width string apply to all paragraphs
 		// with same layout in a sequence.
 		// Do this only once for a selected range of paragraphs
 		// of the same layout and depth.
+		cur.recordUndo();
+		par.params().apply(p, par.layout());
 		if (par.getDepth() != priordepth || par.layout() != priorlayout)
-			setLabelWidthStringToSequence(pit,
+			setLabelWidthStringToSequence(c,
 				par.params().labelWidthString());
-		par.params().apply(p, par.layout());
 		priordepth = par.getDepth();
 		priorlayout = par.layout();
 	}
@@ -520,55 +539,31 @@ void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p)
 // this really should just insert the inset and not move the cursor.
 void Text::insertInset(Cursor & cur, Inset * inset)
 {
-	LASSERT(this == cur.text(), /**/);
-	LASSERT(inset, /**/);
+	LBUFERR(this == cur.text());
+	LBUFERR(inset);
 	cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
-		Change(cur.buffer()->params().trackChanges
+		Change(cur.buffer()->params().track_changes
 		? Change::INSERTED : Change::UNCHANGED));
 }
 
 
-bool Text::setCursor(Cursor & cur, pit_type par, pos_type pos,
+bool Text::setCursor(Cursor & cur, pit_type pit, pos_type pos,
 			bool setfont, bool boundary)
 {
 	TextMetrics const & tm = cur.bv().textMetrics(this);
-	bool const update_needed = !tm.contains(par);
+	bool const update_needed = !tm.contains(pit);
 	Cursor old = cur;
-	setCursorIntern(cur, par, pos, setfont, boundary);
+	setCursorIntern(cur, pit, pos, setfont, boundary);
 	return cur.bv().checkDepm(cur, old) || update_needed;
 }
 
 
-void Text::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
+void Text::setCursorIntern(Cursor & cur, pit_type pit, pos_type pos,
+                           bool setfont, bool boundary)
 {
-	LASSERT(par != int(paragraphs().size()), /**/);
-	cur.pit() = par;
-	cur.pos() = pos;
-
-	// now some strict checking
-	Paragraph & para = getPar(par);
-
-	// None of these should happen, but we're scaredy-cats
-	if (pos < 0) {
-		lyxerr << "don't like -1" << endl;
-		LASSERT(false, /**/);
-	}
-
-	if (pos > para.size()) {
-		lyxerr << "don't like 1, pos: " << pos
-		       << " size: " << para.size()
-		       << " par: " << par << endl;
-		LASSERT(false, /**/);
-	}
-}
-
-
-void Text::setCursorIntern(Cursor & cur,
-			      pit_type par, pos_type pos, bool setfont, bool boundary)
-{
-	LASSERT(this == cur.text(), /**/);
+	LBUFERR(this == cur.text());
 	cur.boundary(boundary);
-	setCursor(cur.top(), par, pos);
+	cur.top().setPitPos(pit, pos);
 	if (setfont)
 		cur.setCurrentFont();
 }
@@ -576,8 +571,6 @@ void Text::setCursorIntern(Cursor & cur,
 
 bool Text::checkAndActivateInset(Cursor & cur, bool front)
 {
-	if (cur.selection())
-		return false;
 	if (front && cur.pos() == cur.lastpos())
 		return false;
 	if (!front && cur.pos() == 0)
@@ -585,6 +578,8 @@ bool Text::checkAndActivateInset(Cursor & cur, bool front)
 	Inset * inset = front ? cur.nextInset() : cur.prevInset();
 	if (!inset || !inset->editable())
 		return false;
+	if (cur.selection() && cur.realAnchor().find(inset) == -1)
+		return false;
 	/*
 	 * Apparently, when entering an inset we are expected to be positioned
 	 * *before* it in the containing paragraph, regardless of the direction
@@ -595,14 +590,14 @@ bool Text::checkAndActivateInset(Cursor & cur, bool front)
 	if (!front)
 		--cur.pos();
 	inset->edit(cur, front);
+	cur.setCurrentFont();
+	cur.boundary(false);
 	return true;
 }
 
 
 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())
@@ -611,8 +606,12 @@ bool Text::checkAndActivateInsetVisual(Cursor & cur, bool movingForward, bool mo
 	Inset * inset = par.isInset(cur.pos()) ? par.getInset(cur.pos()) : 0;
 	if (!inset || !inset->editable())
 		return false;
-	inset->edit(cur, movingForward, 
+	if (cur.selection() && cur.realAnchor().find(inset) == -1)
+		return false;
+	inset->edit(cur, movingForward,
 		movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
+	cur.setCurrentFont();
+	cur.boundary(false);
 	return true;
 }
 
@@ -640,21 +639,28 @@ bool Text::cursorBackward(Cursor & cur)
 				cur.textRow().pos() == cur.pos() &&
 				!cur.paragraph().isLineSeparator(cur.pos() - 1) &&
 				!cur.paragraph().isNewline(cur.pos() - 1) &&
+				!cur.paragraph().isEnvSeparator(cur.pos() - 1) &&
 				!cur.paragraph().isSeparator(cur.pos() - 1)) {
 			return setCursor(cur, cur.pit(), cur.pos(), true, true);
 		}
-		
+
 		// 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);
 	}
 
 	// 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);
+	if (cur.pit() > 0) {
+		Paragraph & par = getPar(cur.pit() - 1);
+		pos_type lastpos = par.size();
+		if (lastpos > 0 && par.isEnvSeparator(lastpos - 1))
+			return setCursor(cur, cur.pit() - 1, lastpos - 1, true, false);
+		else
+			return setCursor(cur, cur.pit() - 1, lastpos, true, false);
+	}
 	return false;
 }
 
@@ -667,7 +673,7 @@ bool Text::cursorVisLeft(Cursor & cur, bool skip_inset)
 		cur = temp_cur;
 		return false;
 	}
-	return setCursor(cur, temp_cur.pit(), temp_cur.pos(), 
+	return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
 		true, temp_cur.boundary());
 }
 
@@ -702,7 +708,7 @@ bool Text::cursorForward(Cursor & cur)
 		if (cur.boundary() && !tm.isRTLBoundary(cur.pit(), cur.pos()))
 			return setCursor(cur, cur.pit(), cur.pos(), true, false);
 
-		// next position is left of boundary, 
+		// 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
@@ -718,19 +724,26 @@ bool Text::cursorForward(Cursor & cur)
 			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);
+		if (cur.textRow().endpos() == cur.pos() + 1) {
+			if (cur.paragraph().isEnvSeparator(cur.pos()) &&
+			    cur.pos() + 1 == cur.lastpos() &&
+			    cur.pit() != cur.lastpit()) {
+				// move to next paragraph
+				return setCursor(cur, cur.pit() + 1, 0, true, false);
+			} else if (cur.textRow().endpos() != cur.lastpos() &&
+				   !cur.paragraph().isNewline(cur.pos()) &&
+				   !cur.paragraph().isEnvSeparator(cur.pos()) &&
+				   !cur.paragraph().isLineSeparator(cur.pos()) &&
+				   !cur.paragraph().isSeparator(cur.pos())) {
+				return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
+			}
 		}
-		
+
 		// 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);
 	}
@@ -757,30 +770,47 @@ bool Text::cursorDownParagraph(Cursor & cur)
 {
 	bool updated = false;
 	if (cur.pit() != cur.lastpit())
-		updated = setCursor(cur, cur.pit() + 1, 0);
+		if (lyxrc.mac_like_cursor_movement)
+			if (cur.pos() == cur.lastpos())
+				updated = setCursor(cur, cur.pit() + 1, getPar(cur.pit() + 1).size());
+			else
+				updated = setCursor(cur, cur.pit(), cur.lastpos());
+		else
+			updated = setCursor(cur, cur.pit() + 1, 0);
 	else
 		updated = setCursor(cur, cur.pit(), cur.lastpos());
 	return updated;
 }
 
+namespace {
 
-// fix the cursor `cur' after a characters has been deleted at `where'
-// position. Called by deleteEmptyParagraphMechanism
-void Text::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
+/** delete num_spaces characters between from and to. Return the
+ * number of spaces that got physically deleted (not marked as
+ * deleted) */
+int deleteSpaces(Paragraph & par, pos_type const from, pos_type to,
+				  int num_spaces, bool const trackChanges)
 {
-	// Do nothing if cursor is not in the paragraph where the
-	// deletion occured,
-	if (cur.pit() != where.pit())
-		return;
+	if (num_spaces <= 0)
+		return 0;
 
-	// If cursor position is after the deletion place update it
-	if (cur.pos() > where.pos())
-		--cur.pos();
+	// First, delete spaces marked as inserted
+	int pos = from;
+	while (pos < to && num_spaces > 0) {
+		Change const & change = par.lookupChange(pos);
+		if (change.inserted() && change.currentAuthor()) {
+			par.eraseChar(pos, trackChanges);
+			--num_spaces;
+			--to;
+		} else
+			++pos;
+	}
+
+	// Then remove remaining spaces
+	int const psize = par.size();
+	par.eraseChars(from, from + num_spaces, trackChanges);
+	return psize - par.size();
+}
 
-	// Check also if we don't want to set the cursor on a spot behind the
-	// pagragraph because we erased the last character.
-	if (cur.pos() > cur.lastpos())
-		cur.pos() = cur.lastpos();
 }
 
 
@@ -790,118 +820,130 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
 	//LYXERR(Debug::DEBUG, "DEPM: cur:\n" << cur << "old:\n" << old);
 
 	Paragraph & oldpar = old.paragraph();
+	bool const trackChanges = cur.buffer()->params().track_changes;
+	bool result = false;
+
+	// We do nothing if cursor did not move
+	if (cur.top() == old.top())
+		return false;
+
+	// We do not do anything on read-only documents
+	if (cur.buffer()->isReadonly())
+		return false;
 
 	// We allow all kinds of "mumbo-jumbo" when freespacing.
 	if (oldpar.isFreeSpacing())
 		return false;
 
-	/* Ok I'll put some comments here about what is missing.
-	   There are still some small problems that can lead to
+	// Whether a common inset is found and whether the cursor is still in
+	// the same paragraph (possibly nested).
+	int const depth = cur.find(&old.inset());
+	bool const same_par = depth != -1 && old.idx() == cur[depth].idx()
+		&& old.pit() == cur[depth].pit();
+
+	/*
+	 * (1) If the chars around the old cursor were spaces, delete some of
+	 * them, but only if the cursor has really moved.
+	 */
+
+	/* There are still some small problems that can lead to
 	   double spaces stored in the document file or space at
 	   the beginning of paragraphs(). This happens if you have
-	   the cursor between to spaces and then save. Or if you
-	   cut and paste and the selection have a space at the
+	   the cursor between two spaces and then save. Or if you
+	   cut and paste and the selection has a space at the
 	   beginning and then save right after the paste. (Lgb)
 	*/
 
-	// If old.pos() == 0 and old.pos()(1) == LineSeparator
-	// delete the LineSeparator.
-	// MISSING
-
-	// If old.pos() == 1 and old.pos()(0) == LineSeparator
-	// delete the LineSeparator.
-	// MISSING
-
-	// Find a common inset and the corresponding depth.
-	size_t depth = 0;
-	for (; depth < cur.depth(); ++depth)
-		if (&old.inset() == &cur[depth].inset())
-			break;
-
-	// Whether a common inset is found and whether the cursor is still in 
-	// the same paragraph (possibly nested).
-	bool const same_par = depth < cur.depth() && old.pit() == cur[depth].pit();
-	bool const same_par_pos = depth == cur.depth() - 1 && same_par 
-		&& old.pos() == cur[depth].pos();
-	
-	// If the chars around the old cursor were spaces, delete one of them.
-	if (!same_par_pos) {
-		// Only if the cursor has really moved.
-		if (old.pos() > 0
-		    && old.pos() < oldpar.size()
-		    && oldpar.isLineSeparator(old.pos())
-		    && oldpar.isLineSeparator(old.pos() - 1)
-		    && !oldpar.isDeleted(old.pos() - 1)
-		    && !oldpar.isDeleted(old.pos())) {
-			oldpar.eraseChar(old.pos() - 1, cur.buffer()->params().trackChanges);
-// 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)
-			// correct all cursor parts
-			if (same_par) {
-				fixCursorAfterDelete(cur[depth], old.top());
-				need_anchor_change = true;
-			}
-			return true;
+	// find range of spaces around cursors
+	pos_type from = old.pos();
+	while (from > 0
+		   && oldpar.isLineSeparator(from - 1)
+		   && !oldpar.isDeleted(from - 1))
+		--from;
+	pos_type to = old.pos();
+	while (to < old.lastpos()
+		   && oldpar.isLineSeparator(to)
+		   && !oldpar.isDeleted(to))
+		++to;
+
+	int num_spaces = to - from;
+	// If we are not at the start of the paragraph, keep one space
+	if (from != to && from > 0)
+		--num_spaces;
+
+	// If cursor is inside range, keep one additional space
+	if (same_par && cur.pos() > from && cur.pos() < to)
+		--num_spaces;
+
+	// Remove spaces and adapt cursor.
+	if (num_spaces > 0) {
+		old.recordUndo();
+		int const deleted =
+			deleteSpaces(oldpar, from, to, num_spaces, trackChanges);
+		// correct cur position
+		// FIXME: there can be other cursors pointing there, we should update them
+		if (same_par) {
+			if (cur[depth].pos() >= to)
+				cur[depth].pos() -= deleted;
+			else if (cur[depth].pos() > from)
+				cur[depth].pos() = min(from + 1, old.lastpos());
+			need_anchor_change = true;
 		}
+		result = true;
 	}
 
-	// only do our magic if we changed paragraph
+	/*
+	 * (2) If the paragraph where the cursor was is empty, delete it
+	 */
+
+	// only do our other magic if we changed paragraph
 	if (same_par)
-		return false;
+		return result;
+
+	// only do our magic if the paragraph is empty
+	if (!oldpar.empty())
+		return result;
 
 	// don't delete anything if this is the ONLY paragraph!
 	if (old.lastpit() == 0)
-		return false;
+		return result;
 
 	// Do not delete empty paragraphs with keepempty set.
 	if (oldpar.allowEmpty())
-		return false;
-
-	if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
-		// Delete old par.
-		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 (FIXME?) above 
-		if (cur.depth() >= old.depth()) {
-			CursorSlice & curslice = cur[old.depth() - 1];
-			if (&curslice.inset() == &old.inset()
-			    && curslice.pit() > old.pit()) {
-				--curslice.pit();
-				// since a paragraph has been deleted, all the
-				// insets after `old' have been copied and
-				// their address has changed. Therefore we
-				// need to `regenerate' cur. (JMarc)
-				cur.updateInsets(&(cur.bottom().inset()));
-				need_anchor_change = true;
-			}
+		return result;
+
+	// Delete old par.
+	old.recordUndo(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(lyx::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 (FIXME?) above
+	if (cur.depth() >= old.depth()) {
+		CursorSlice & curslice = cur[old.depth() - 1];
+		if (&curslice.inset() == &old.inset()
+		    && curslice.pit() > old.pit()) {
+			--curslice.pit();
+			// since a paragraph has been deleted, all the
+			// insets after `old' have been copied and
+			// their address has changed. Therefore we
+			// need to `regenerate' cur. (JMarc)
+			cur.updateInsets(&(cur.bottom().inset()));
+			need_anchor_change = true;
 		}
-		return true;
-	}
-
-	if (oldpar.stripLeadingSpaces(cur.buffer()->params().trackChanges)) {
-		need_anchor_change = true;
-		// We return true here because the Paragraph contents changed and
-		// we need a redraw before further action is processed.
-		return true;
 	}
 
-	return false;
+	return true;
 }
 
 
 void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool trackChanges)
 {
-	LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), /**/);
+	LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), return);
 
 	for (pit_type pit = first; pit <= last; ++pit) {
 		Paragraph & par = pars_[pit];
@@ -910,17 +952,35 @@ void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool tra
 		if (par.isFreeSpacing())
 			continue;
 
-		for (pos_type pos = 1; pos < par.size(); ++pos) {
-			if (par.isLineSeparator(pos) && par.isLineSeparator(pos - 1)
-			    && !par.isDeleted(pos - 1)) {
-				if (par.eraseChar(pos - 1, trackChanges)) {
-					--pos;
-				}
-			}
+		pos_type from = 0;
+		while (from < par.size()) {
+			// skip non-spaces
+			while (from < par.size()
+			       && (!par.isLineSeparator(from) || par.isDeleted(from)))
+				++from;
+			// find string of spaces
+			pos_type to = from;
+			while (to < par.size()
+			       && par.isLineSeparator(to) && !par.isDeleted(to))
+				++to;
+			// empty? We are done
+			if (from == to)
+				break;
+
+			int num_spaces = to - from;
+
+			// If we are not at the extremity of the paragraph, keep one space
+			if (from != to && from > 0 && to < par.size())
+				--num_spaces;
+
+			// Remove spaces if needed
+			int const deleted = deleteSpaces(par, from , to, num_spaces, trackChanges);
+			from = to - deleted;
 		}
 
-		// 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
+		// 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
 		if (first == last)
 			continue;
 
@@ -929,26 +989,13 @@ void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool tra
 			continue;
 
 		if (par.empty() || (par.size() == 1 && par.isLineSeparator(0))) {
-			pars_.erase(boost::next(pars_.begin(), pit));
+			pars_.erase(lyx::next(pars_.begin(), pit));
 			--pit;
 			--last;
 			continue;
 		}
-
-		par.stripLeadingSpaces(trackChanges);
 	}
 }
 
 
-void Text::recUndo(Cursor & cur, pit_type first, pit_type last) const
-{
-	cur.recordUndo(ATOMIC_UNDO, first, last);
-}
-
-
-void Text::recUndo(Cursor & cur, pit_type par) const
-{
-	cur.recordUndo(ATOMIC_UNDO, par, par);
-}
-
 } // namespace lyx