Adjust bookmark position when inserting/deleting from paragraph

[lyx.git] / src / Text2.cpp

diff --git a/src/Text2.cpp b/src/Text2.cpp
index 99ec8e66c720289fee945d0b00b329862f0122c7..cc5340317a0956e688fa87537b6fdb2ec6941003 100644 (file)
--- a/src/Text2.cpp
+++ b/src/Text2.cpp
@@ -22,39 +22,23 @@
 
 #include "Text.h"
 
 
 #include "Text.h"
 

-#include "Bidi.h"

 #include "Buffer.h"
 #include "Buffer.h"

-#include "buffer_funcs.h"
-#include "BufferList.h"

 #include "BufferParams.h"
 #include "BufferView.h"
 #include "Changes.h"
 #include "Cursor.h"
 #include "BufferParams.h"
 #include "BufferView.h"
 #include "Changes.h"
 #include "Cursor.h"

-#include "CutAndPaste.h"
-#include "DispatchResult.h"
-#include "ErrorList.h"
-#include "FuncRequest.h"

 #include "Language.h"
 #include "Layout.h"
 #include "Language.h"
 #include "Layout.h"

-#include "Lexer.h"
-#include "LyXFunc.h"

 #include "LyXRC.h"
 #include "Paragraph.h"
 #include "ParagraphParameters.h"
 #include "TextClass.h"
 #include "TextMetrics.h"
 #include "LyXRC.h"
 #include "Paragraph.h"
 #include "ParagraphParameters.h"
 #include "TextClass.h"
 #include "TextMetrics.h"

-#include "VSpace.h"

 
 

-#include "insets/InsetCollapsable.h"
-
-#include "mathed/InsetMathHull.h"
+#include "insets/InsetText.h"

 
 #include "support/lassert.h"
 
 #include "support/lassert.h"

-#include "support/debug.h"

 #include "support/gettext.h"
 #include "support/gettext.h"

-#include "support/textutils.h"
-
-#include <boost/next_prior.hpp>

 
 #include <sstream>
 
 
 #include <sstream>
 


@@ -78,16 +62,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());
                // 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;
        }
                icf.realize(lf);
                return icf;
        }


@@ -165,12 +140,12 @@ void Text::setCharFont(pit_type pit,
 
 
 void Text::setInsetFont(BufferView const & bv, 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);
 {
        Inset * const inset = pars_[pit].getInset(pos);

-       LASSERT(inset && inset->noFontChange(), /**/);
+       LASSERT(inset && inset->resetFontEdit(), return);

 
 

-       CursorSlice::idx_type endidx = inset->nargs();
+       idx_type endidx = inset->nargs();

        for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
                Text * text = cs.text();
                if (text) {
        for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
                Text * text = cs.text();
                if (text) {


@@ -178,35 +153,16 @@ void Text::setInsetFont(BufferView const & bv, pit_type pit,
                        CursorSlice cellend = cs;
                        cellend.pit() = cellend.lastpit();
                        cellend.pos() = cellend.lastpos();
                        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)
 {
 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();
 
        Buffer const & buffer = owner_->buffer();
        BufferParams const & bp = buffer.params();


@@ -214,32 +170,37 @@ void Text::setLayout(pit_type start, pit_type end,
 
        for (pit_type pit = start; pit != end; ++pit) {
                Paragraph & par = pars_[pit];
 
        for (pit_type pit = start; pit != end; ++pit) {
                Paragraph & par = pars_[pit];

-               par.applyLayout(lyxlayout);
+               // Is this a separating paragraph? If so,
+               // this needs to be standard layout
+               bool const is_separator = par.size() == 1
+                               && par.isEnvSeparator(0);
+               par.applyLayout(is_separator ? bp.documentClass().defaultLayout() : lyxlayout);

                if (lyxlayout.margintype == MARGIN_MANUAL)
                        par.setLabelWidthString(par.expandLabel(lyxlayout, bp));
        }
                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)
 {
 }
 
 
 // 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 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);
        setLayout(start, end, layout);

-       cur.buffer()->updateLabels();
+       cur.fixIfBroken();
+       cur.setCurrentFont();
+       cur.forceBufferUpdate();

 }
 
 
 static bool changeDepthAllowed(Text::DEPTH_CHANGE type,
                        Paragraph const & par, int max_depth)
 {
 }
 
 
 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;
        int const depth = par.params().depth();
        if (type == Text::INC_DEPTH && depth < max_depth)
                return true;


@@ -249,9 +210,9 @@ static bool changeDepthAllowed(Text::DEPTH_CHANGE type,
 }
 
 
 }
 
 

-bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
+bool Text::changeDepthAllowed(Cursor const & 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;
        // this happens when selecting several cells in tabular (bug 2630)
        if (cur.selBegin().idx() != cur.selEnd().idx())
                return false;


@@ -269,9 +230,9 @@ bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
 }
 
 
 }
 
 

-void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
+void Text::changeDepth(Cursor const & 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();
        pit_type const beg = cur.selBegin().pit();
        pit_type const end = cur.selEnd().pit() + 1;
        cur.recordUndoSelection();


@@ -290,13 +251,18 @@ void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
        }
        // this handles the counter labels, and also fixes up
        // depth values for follow-on (child) paragraphs
        }
        // this handles the counter labels, and also fixes up
        // depth values for follow-on (child) paragraphs

-       cur.buffer()->updateLabels();
+       cur.forceBufferUpdate();

 }
 
 
 void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
 {
 }
 
 
 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;
        // Set the current_font
        // Determine basis font
        FontInfo layoutfont;


@@ -322,16 +288,71 @@ void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
                return;
 
        // Ok, we have a selection.
                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,
 }
 
 
 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();
 
 {
        Buffer const & buffer = bv.buffer();
 


@@ -346,38 +367,39 @@ 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);
                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
                        // 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);
                }
                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_);
                setCharFont(pit, pos, f, tm.font_);

+               // font change may change language...
+               // spell checker has to know that
+               pars_[pit].requestSpellCheck(pos);

        }
 }
 
 
 bool Text::cursorTop(Cursor & cur)
 {
        }
 }
 
 
 bool Text::cursorTop(Cursor & cur)
 {

-       LASSERT(this == cur.text(), /**/);
+       LBUFERR(this == cur.text());

        return setCursor(cur, 0, 0);
 }
 
 
 bool Text::cursorBottom(Cursor & cur)
 {
        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)
 {
 }
 
 
 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
        // If the mask is completely neutral, tell user
        if (font.fontInfo() == ignore_font && font.language() == ignore_language) {
                // Could only happen with user style


@@ -407,9 +429,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);
 
        if (cur.selection())
                return cur.selectionAsString(false);


@@ -417,98 +439,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.
        // 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)
 {
                docstring const & s)
 {

-       pit_type offset = par_offset;
+       Cursor c = cur;

        // Find first of same layout in sequence
        // 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
        }
 
        // 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;
                        return;

-               if (pars_[pit].layout() != layout)
+               if (c.paragraph().layout() != layout)

                        return;
                        return;

-               pars_[pit].setLabelWidthString(s);
+               c.recordUndo();
+               c.paragraph().setLabelWidthString(s);

        }
 }
 
 
        }
 }
 
 

-void Text::setParagraphs(Cursor & cur, docstring arg, bool merge) 
+void Text::setParagraphs(Cursor const & 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;
 
        //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.
                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());
                par.params().apply(params, par.layout());

+               if (par.getDepth() != priordepth || par.layout() != priorlayout)
+                       setLabelWidthStringToSequence(c, params.labelWidthString());

                priordepth = par.getDepth();
                priorlayout = par.layout();
        }
 }
 
 
                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 const & 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;
 
        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.
                // 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)
                if (par.getDepth() != priordepth || par.layout() != priorlayout)

-                       setLabelWidthStringToSequence(pit,
+                       setLabelWidthStringToSequence(c,

                                par.params().labelWidthString());
                                par.params().labelWidthString());

-               par.params().apply(p, par.layout());

                priordepth = par.getDepth();
                priorlayout = par.layout();
        }
                priordepth = par.getDepth();
                priorlayout = par.layout();
        }


@@ -518,55 +531,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)
 {
 // 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,
        cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,

-               Change(cur.buffer()->params().trackChanges
+               Change(cur.buffer()->params().track_changes

                ? Change::INSERTED : Change::UNCHANGED));
 }
 
 
                ? 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 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;
        Cursor old = cur;

-       setCursorIntern(cur, par, pos, setfont, boundary);
+       setCursorIntern(cur, pit, pos, setfont, boundary);

        return cur.bv().checkDepm(cur, old) || update_needed;
 }
 
 
        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 << "dont like -1" << endl;
-               LASSERT(false, /**/);
-       }
-
-       if (pos > para.size()) {
-               lyxerr << "dont 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);
        cur.boundary(boundary);

-       setCursor(cur.top(), par, pos);
+       cur.top().setPitPos(pit, pos);

        if (setfont)
                cur.setCurrentFont();
 }
        if (setfont)
                cur.setCurrentFont();
 }


@@ -574,8 +563,6 @@ void Text::setCursorIntern(Cursor & cur,
 
 bool Text::checkAndActivateInset(Cursor & cur, bool front)
 {
 
 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)
        if (front && cur.pos() == cur.lastpos())
                return false;
        if (!front && cur.pos() == 0)


@@ -583,6 +570,8 @@ bool Text::checkAndActivateInset(Cursor & cur, bool front)
        Inset * inset = front ? cur.nextInset() : cur.prevInset();
        if (!inset || !inset->editable())
                return false;
        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
        /*
         * Apparently, when entering an inset we are expected to be positioned
         * *before* it in the containing paragraph, regardless of the direction


@@ -593,24 +582,28 @@ bool Text::checkAndActivateInset(Cursor & cur, bool front)
        if (!front)
                --cur.pos();
        inset->edit(cur, 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)
 {
        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())
                return false;
        Paragraph & par = cur.paragraph();
        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;
+       Inset * inset = par.isInset(cur.pos()) ? par.getInset(cur.pos()) : nullptr;

        if (!inset || !inset->editable())
                return false;
        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);
                movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);

+       cur.setCurrentFont();
+       cur.boundary(false);

        return true;
 }
 
        return true;
 }
 


@@ -618,7 +611,7 @@ bool Text::checkAndActivateInsetVisual(Cursor & cur, bool movingForward, bool mo
 bool Text::cursorBackward(Cursor & cur)
 {
        // Tell BufferView to test for FitCursor in any case!
 bool Text::cursorBackward(Cursor & cur)
 {
        // Tell BufferView to test for FitCursor in any case!

-       cur.updateFlags(Update::FitCursor);
+       cur.screenUpdateFlags(Update::FitCursor);

 
        // not at paragraph start?
        if (cur.pos() > 0) {
 
        // not at paragraph start?
        if (cur.pos() > 0) {


@@ -638,21 +631,28 @@ bool Text::cursorBackward(Cursor & cur)
                                cur.textRow().pos() == cur.pos() &&
                                !cur.paragraph().isLineSeparator(cur.pos() - 1) &&
                                !cur.paragraph().isNewline(cur.pos() - 1) &&
                                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);
                }
                                !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;
                // 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
                // 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;
 }
 
        return false;
 }
 


@@ -665,7 +665,7 @@ bool Text::cursorVisLeft(Cursor & cur, bool skip_inset)
                cur = temp_cur;
                return false;
        }
                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());
 }
 
                true, temp_cur.boundary());
 }
 


@@ -686,7 +686,7 @@ bool Text::cursorVisRight(Cursor & cur, bool skip_inset)
 bool Text::cursorForward(Cursor & cur)
 {
        // Tell BufferView to test for FitCursor in any case!
 bool Text::cursorForward(Cursor & cur)
 {
        // Tell BufferView to test for FitCursor in any case!

-       cur.updateFlags(Update::FitCursor);
+       cur.screenUpdateFlags(Update::FitCursor);

 
        // not at paragraph end?
        if (cur.pos() != cur.lastpos()) {
 
        // not at paragraph end?
        if (cur.pos() != cur.lastpos()) {


@@ -700,7 +700,7 @@ bool Text::cursorForward(Cursor & cur)
                if (cur.boundary() && !tm.isRTLBoundary(cur.pit(), cur.pos()))
                        return setCursor(cur, cur.pit(), cur.pos(), true, false);
 
                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
                // 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


@@ -716,19 +716,26 @@ bool Text::cursorForward(Cursor & cur)
                        bool sep2 = cur.paragraph().isSeparator(cur.pos()+1);
                }
 #endif
                        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);
                // 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);
        }
                // move right
                return setCursor(cur, cur.pit(), cur.pos() + 1, true, false);
        }


@@ -755,30 +762,47 @@ bool Text::cursorDownParagraph(Cursor & cur)
 {
        bool updated = false;
        if (cur.pit() != cur.lastpit())
 {
        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;
 }
 
        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();

 }
 
 
 }
 
 


@@ -788,137 +812,181 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
        //LYXERR(Debug::DEBUG, "DEPM: cur:\n" << cur << "old:\n" << old);
 
        Paragraph & oldpar = old.paragraph();
        //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 allow all kinds of "mumbo-jumbo" when freespacing.
-       if (oldpar.isFreeSpacing())
+       // We do not do anything on read-only documents
+       if (cur.buffer()->isReadonly())

                return false;
 
                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 and the
+        * paragraph is not in free spacing mode, 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
           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)
        */
           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 (!oldpar.isFreeSpacing()) {
+               // 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 (same_par) {

-                               fixCursorAfterDelete(cur[depth], old.top());
+                               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;
                        }
                                need_anchor_change = true;
                        }

-                       return 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)
        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)
 
        // 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())
 
        // 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(plist.iterator_at(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.idx() == old.idx()
+                   && 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)
 {
 }
 
 
 void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool trackChanges)
 {

-       LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), /**/);
+       pos_type last_pos = static_cast<pos_type>(pars_[last].size() - 1);
+       deleteEmptyParagraphMechanism(first, last, 0, last_pos, trackChanges);
+}
+
+
+void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last,
+                                        pos_type first_pos, pos_type last_pos,
+                                        bool trackChanges)
+{
+       LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), return);

 
        for (pit_type pit = first; pit <= last; ++pit) {
                Paragraph & par = pars_[pit];
 
 
        for (pit_type pit = first; pit <= last; ++pit) {
                Paragraph & par = pars_[pit];
 

-               // We allow all kinds of "mumbo-jumbo" when freespacing.
-               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;
-                               }
+               /*
+                * (1) Delete consecutive spaces
+                */
+               if (!par.isFreeSpacing()) {
+                       pos_type from = (pit == first) ? first_pos : 0;
+                       pos_type to_pos = (pit == last) ? last_pos + 1 : par.size();
+                       while (from < to_pos) {
+                               // 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
+               /*
+                * (2) Delete empty pragraphs
+                */
+
+               // 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;
 
                if (first == last)
                        continue;
 


@@ -927,26 +995,13 @@ void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool tra
                        continue;
 
                if (par.empty() || (par.size() == 1 && par.isLineSeparator(0))) {
                        continue;
 
                if (par.empty() || (par.size() == 1 && par.isLineSeparator(0))) {

-                       pars_.erase(boost::next(pars_.begin(), pit));
+                       pars_.erase(pars_.iterator_at(pit));

                        --pit;
                        --last;
                        continue;
                }
                        --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
 } // namespace lyx