minimal effort implementation of:

[lyx.git] / src / paragraph_funcs.C

diff --git a/src/paragraph_funcs.C b/src/paragraph_funcs.C
index a5d3a5e777313f0e4c6220e2a320855903ea2cd7..252c5956dedf931a615ff4215406868fce48be21 100644 (file)
--- a/src/paragraph_funcs.C
+++ b/src/paragraph_funcs.C
@@ -58,8 +58,8 @@ using std::pair;
 namespace {
 
 bool moveItem(Paragraph & from, Paragraph & to,
-       BufferParams const & params, pos_type i, pos_type j, 
-       Change change = Change(Change::INSERTED)); 
+       BufferParams const & params, pos_type i, pos_type j,
+       Change change = Change(Change::INSERTED));
 
 bool moveItem(Paragraph & from, Paragraph & to,
        BufferParams const & params, pos_type i, pos_type j,
@@ -83,8 +83,6 @@ bool moveItem(Paragraph & from, Paragraph & to,
                if (tmpinset)
                        to.insertInset(j, tmpinset, tmpfont, change);
        } else {
-               if (!to.checkInsertChar(tmpfont))
-                       return false;
                to.insertChar(j, tmpchar, tmpfont, change);
        }
        return true;
@@ -98,7 +96,8 @@ void breakParagraph(BufferParams const & bparams,
 {
        // create a new paragraph, and insert into the list
        ParagraphList::iterator tmp =
-               pars.insert(pars.begin() + par_offset + 1, Paragraph());
+               pars.insert(boost::next(pars.begin(), par_offset + 1),
+                           Paragraph());
 
        Paragraph & par = pars[par_offset];
 
@@ -121,6 +120,7 @@ void breakParagraph(BufferParams const & bparams,
        if (flag) {
                tmp->layout(par.layout());
                tmp->setLabelWidthString(par.params().labelWidthString());
+               tmp->params().depth(par.params().depth());
        }
 
        bool const isempty = (par.allowEmpty() && par.empty());
@@ -144,7 +144,7 @@ void breakParagraph(BufferParams const & bparams,
                pos_type pos_end = par.size() - 1;
 
                for (pos_type i = pos, j = pos; i <= pos_end; ++i) {
-                       Change::Type change = par.lookupChange(i);
+                       Change::Type change = par.lookupChange(i).type;
                        if (moveItem(par, *tmp, bparams, i, j - pos)) {
                                tmp->setChange(j - pos, change);
                                ++j;
@@ -159,7 +159,7 @@ void breakParagraph(BufferParams const & bparams,
                // Make sure that we keep the language when
                // breaking paragrpah.
                if (tmp->empty()) {
-                       LyXFont changed = tmp->getFirstFontSettings();
+                       LyXFont changed = tmp->getFirstFontSettings(bparams);
                        LyXFont old = par.getFontSettings(bparams, par.size());
                        changed.setLanguage(old.language());
                        tmp->setFont(0, changed);
@@ -168,9 +168,10 @@ void breakParagraph(BufferParams const & bparams,
                return;
        }
 
-       par.params().clear();
-
-       par.layout(bparams.getLyXTextClass().defaultLayout());
+       if (!isempty) {
+               par.params().clear();
+               par.layout(bparams.getLyXTextClass().defaultLayout());
+       }
 
        // layout stays the same with latex-environments
        if (flag) {
@@ -194,7 +195,8 @@ void breakParagraphConservative(BufferParams const & bparams,
        ParagraphList & pars, pit_type par_offset, pos_type pos)
 {
        // create a new paragraph
-       Paragraph & tmp = *pars.insert(pars.begin() + par_offset + 1, Paragraph());
+       Paragraph & tmp = *pars.insert(boost::next(pars.begin(), par_offset + 1),
+                                      Paragraph());
        Paragraph & par = pars[par_offset];
 
        if (bparams.tracking_changes)
@@ -210,13 +212,16 @@ void breakParagraphConservative(BufferParams const & bparams,
                pos_type pos_end = par.size() - 1;
 
                for (pos_type i = pos, j = pos; i <= pos_end; ++i) {
-                       Change::Type change = par.lookupChange(i);
+                       Change::Type change = par.lookupChange(i).type;
                        if (moveItem(par, tmp, bparams, i, j - pos, change))
                                ++j;
                }
-               // If tracking changes, set all the text that is to be  
-               // erased to Type::INSERTED.  
-               for (pos_type k = pos_end; k >= pos; --k) { 
+               // Move over end-of-par change attr
+               tmp.setChange(tmp.size(), par.lookupChange(par.size()).type);
+
+               // If tracking changes, set all the text that is to be
+               // erased to Type::INSERTED.
+               for (pos_type k = pos_end; k >= pos; --k) {
                        if (bparams.tracking_changes)
                                par.setChange(k, Change::INSERTED);
                        par.erase(k);
@@ -234,14 +239,30 @@ void mergeParagraph(BufferParams const & bparams,
        pos_type pos_end = next.size() - 1;
        pos_type pos_insert = par.size();
 
+       // What happens is the following. Later on, moveItem() will copy
+       // over characters from the next paragraph to be inserted into this
+       // position. Now, if the first char to be so copied is "red" (i.e.,
+       // marked deleted) and the paragraph break is marked "blue",
+       // insertChar will trigger (eventually, through record(), and see
+       // del() and erase() in changes.C) a "hard" character deletion.
+       // Which doesn't make sense of course at this pos, but the effect is
+       // to shorten the change range to which this para break belongs, by
+       // one. It will (should) remain "orphaned", having no CT info to it,
+       // and check() in changes.C will assert. Setting the para break
+       // forcibly to "black" prevents this scenario. -- MV 13.3.2006
+       par.setChange(par.size(), Change::UNCHANGED);
+
+       Change::Type cr = next.lookupChange(next.size()).type;
        // ok, now copy the paragraph
        for (pos_type i = 0, j = 0; i <= pos_end; ++i) {
-               Change::Type change = next.lookupChange(i);
+               Change::Type change = next.lookupChange(i).type;
                if (moveItem(next, par, bparams, i, pos_insert + j, change))
                        ++j;
        }
+       // Move the change status of "carriage return" over
+       par.setChange(par.size(), cr);
 
-       pars.erase(pars.begin() + par_offset + 1);
+       pars.erase(boost::next(pars.begin(), par_offset + 1));
 }