bug 1305

Make sure that we keep the language over a rebreak.

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@8911 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/src/ChangeLog b/src/ChangeLog
index 22ec2ee7a8d7a0d6fc6b9acb6bbbf149e5daf97e..64aab4179c6ade307b17a47da2a227d2b2f940aa 100644 (file)
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,6 +1,25 @@
+2004-08-13  Lars Gullik Bjonnes  <larsbj@lyx.org>
+
+       bug 1305
+       * paragraph_funcs.C (moveItem): use Paragraph::value_type instead
+       of char
+       (breakParagraph): rename par to par_offset and use a local
+       reference. Add code to keep the language over a rebreak.
+       (breakParagraphConservative): rename par to par_offset, use a
+       local reference
+       (mergeParagraph): ditto
+       (outerHook): ditto
+       (isFirstInSequence): ditto
+       (outerFont): rename pit to par_offset
+
+       * paragraph.C: ws change
+       * paragraph.h: ditto
+       * text3.C: ditto
+       * text.C: ditto
+
 2004-08-13  Jean-Marc Lasgouttes  <lasgouttes@lyx.org>
 
-       * text2.C (editXY): 
+       * text2.C (editXY):
        * text3.C (checkInsetHit): constify
 
 2004-08-13  Jean-Marc Lasgouttes  <lasgouttes@lyx.org>
@@ -11,7 +30,7 @@
 2004-08-13  Jean-Marc Lasgouttes  <lasgouttes@lyx.org>
 
        Fix toggling of collapsable insets with the mouse (bug 1558)
-       
+
        * lyxfunc.C (dispatch): adapt to LCursor changes
 
        * BufferView_pimpl.C (workAreaDispatch): adapt to LCursor changes;
@@ -31,7 +50,7 @@
 
        * CutAndPaste.C (eraseSelection): fix cursor position after erasing
          multiple cells
-   
+
 2004-08-12  André Pönitz  <poenitz@gmx.net>
 
        * text3.C: take out the 'cursor right' form insertInset and only
@@ -55,7 +74,7 @@
 
        * paragraph.C (insertInset, insertChar): the version that takes a
        LyXFont argument is now a wrapper around the other one (the
-       opposite used to be true). 
+       opposite used to be true).
 
        * paragraph_pimpl.C (insertInset, insertChar): remove the LyXFont
        argument. Font setting is done in Paragraph now.

diff --git a/src/paragraph.C b/src/paragraph.C
index 18bcfb9a275bd0155cf9f0d7562d9d9f5f462af2..7073f641ed2e325df6eb3506b262217732b733e6 100644 (file)
--- a/src/paragraph.C
+++ b/src/paragraph.C
@@ -278,7 +278,7 @@ bool Paragraph::checkInsertChar(LyXFont &)
 }
 
 
-void Paragraph::insertChar(pos_type pos, Paragraph::value_type c, 
+void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
                           Change change)
 {
        pimpl_->insertChar(pos, c, change);

diff --git a/src/paragraph.h b/src/paragraph.h
index 155ee497f0edf8359777f15501a505616c00c4de..aa4e24156d48ef3f81a9cafbb601a859a8a555f4 100644 (file)
--- a/src/paragraph.h
+++ b/src/paragraph.h
@@ -292,7 +292,7 @@ public:
        ///
        bool checkInsertChar(LyXFont &);
        ///
-       void insertInset(lyx::pos_type pos, InsetBase * inset, 
+       void insertInset(lyx::pos_type pos, InsetBase * inset,
                         Change change = Change(Change::INSERTED));
        ///
        void insertInset(lyx::pos_type pos, InsetBase * inset,

diff --git a/src/paragraph_funcs.C b/src/paragraph_funcs.C
index b2794d996adbd7bd655db5053a041450d99551f4..cb8aad1ba2035694a2c4a079570d197df6085180 100644 (file)
--- a/src/paragraph_funcs.C
+++ b/src/paragraph_funcs.C
@@ -60,7 +60,7 @@ namespace {
 bool moveItem(Paragraph & from, Paragraph & to,
        BufferParams const & params, pos_type i, pos_type j)
 {
-       char const tmpchar = from.getChar(i);
+       Paragraph::value_type const tmpchar = from.getChar(i);
        LyXFont tmpfont = from.getFontSettings(params, i);
 
        if (tmpchar == Paragraph::META_INSET) {
@@ -89,17 +89,19 @@ bool moveItem(Paragraph & from, Paragraph & to,
 
 
 void breakParagraph(BufferParams const & bparams,
-       ParagraphList & pars, par_type par, pos_type pos, int flag)
+       ParagraphList & pars, par_type par_offset, pos_type pos, int flag)
 {
        // create a new paragraph, and insert into the list
        ParagraphList::iterator tmp =
-               pars.insert(pars.begin() + par + 1, Paragraph());
+               pars.insert(pars.begin() + par_offset + 1, Paragraph());
+
+       Paragraph & par = pars[par_offset];
 
        // without doing that we get a crash when typing <Return> at the
        // end of a paragraph
        tmp->layout(bparams.getLyXTextClass().defaultLayout());
        // remember to set the inset_owner
-       tmp->setInsetOwner(pars[par].inInset());
+       tmp->setInsetOwner(par.inInset());
 
        if (bparams.tracking_changes)
                tmp->trackChanges();
@@ -109,19 +111,19 @@ void breakParagraph(BufferParams const & bparams,
 
        // layout stays the same with latex-environments
        if (flag) {
-               tmp->layout(pars[par].layout());
-               tmp->setLabelWidthString(pars[par].params().labelWidthString());
+               tmp->layout(par.layout());
+               tmp->setLabelWidthString(par.params().labelWidthString());
        }
 
-       bool const isempty = (pars[par].allowEmpty() && pars[par].empty());
+       bool const isempty = (par.allowEmpty() && par.empty());
 
-       if (!isempty && (pars[par].size() > pos || pars[par].empty() || flag == 2)) {
-               tmp->layout(pars[par].layout());
-               tmp->params().align(pars[par].params().align());
-               tmp->setLabelWidthString(pars[par].params().labelWidthString());
+       if (!isempty && (par.size() > pos || par.empty() || flag == 2)) {
+               tmp->layout(par.layout());
+               tmp->params().align(par.params().align());
+               tmp->setLabelWidthString(par.params().labelWidthString());
 
-               tmp->params().depth(pars[par].params().depth());
-               tmp->params().noindent(pars[par].params().noindent());
+               tmp->params().depth(par.params().depth());
+               tmp->params().noindent(par.params().noindent());
 
                // copy everything behind the break-position
                // to the new paragraph
@@ -131,38 +133,48 @@ void breakParagraph(BufferParams const & bparams,
                 * doesn't cause problems because both loops below
                 * enforce pos <= pos_end and 0 <= pos
                 */
-               pos_type pos_end = pars[par].size() - 1;
+               pos_type pos_end = par.size() - 1;
 
                for (pos_type i = pos, j = pos; i <= pos_end; ++i) {
-                       Change::Type change = pars[par].lookupChange(i);
-                       if (moveItem(pars[par], *tmp, bparams, i, j - pos)) {
+                       Change::Type change = par.lookupChange(i);
+                       if (moveItem(par, *tmp, bparams, i, j - pos)) {
                                tmp->setChange(j - pos, change);
                                ++j;
                        }
                }
 
                for (pos_type i = pos_end; i >= pos; --i)
-                       pars[par].eraseIntern(i);
+                       par.eraseIntern(i);
        }
 
-       if (pos)
+       if (pos) {
+               // Make sure that we keep the language when
+               // breaking paragrpah.
+               if (tmp->empty()) {
+                       LyXFont changed = tmp->getFirstFontSettings();
+                       LyXFont old = par.getFontSettings(bparams, par.size());
+                       changed.setLanguage(old.language());
+                       tmp->setFont(0, changed);
+               }
+
                return;
+       }
 
-       pars[par].params().clear();
+       par.params().clear();
 
-       pars[par].layout(bparams.getLyXTextClass().defaultLayout());
+       par.layout(bparams.getLyXTextClass().defaultLayout());
 
        // layout stays the same with latex-environments
        if (flag) {
-               pars[par].layout(tmp->layout());
-               pars[par].setLabelWidthString(tmp->params().labelWidthString());
-               pars[par].params().depth(tmp->params().depth());
+               par.layout(tmp->layout());
+               par.setLabelWidthString(tmp->params().labelWidthString());
+               par.params().depth(tmp->params().depth());
        }
 
        // subtle, but needed to get empty pars working right
        if (bparams.tracking_changes) {
-               if (!pars[par].size()) {
-                       pars[par].cleanChanges();
+               if (!par.size()) {
+                       par.cleanChanges();
                } else if (!tmp->size()) {
                        tmp->cleanChanges();
                }
@@ -171,43 +183,46 @@ void breakParagraph(BufferParams const & bparams,
 
 
 void breakParagraphConservative(BufferParams const & bparams,
-       ParagraphList & pars, par_type par, pos_type pos)
+       ParagraphList & pars, par_type par_offset, pos_type pos)
 {
        // create a new paragraph
-       Paragraph & tmp = *pars.insert(pars.begin() + par + 1, Paragraph());
-       tmp.makeSameLayout(pars[par]);
+       Paragraph & tmp = *pars.insert(pars.begin() + par_offset + 1, Paragraph());
+       Paragraph & par = pars[par_offset];
+
+       tmp.makeSameLayout(par);
 
        // When can pos > size()?
        // I guess pos == size() is possible.
-       if (pars[par].size() > pos) {
+       if (par.size() > pos) {
                // copy everything behind the break-position to the new
                // paragraph
-               pos_type pos_end = pars[par].size() - 1;
+               pos_type pos_end = par.size() - 1;
 
                for (pos_type i = pos, j = pos; i <= pos_end; ++i)
-                       if (moveItem(pars[par], tmp, bparams, i, j - pos))
+                       if (moveItem(par, tmp, bparams, i, j - pos))
                                ++j;
 
                for (pos_type k = pos_end; k >= pos; --k)
-                       pars[par].erase(k);
+                       par.erase(k);
        }
 }
 
 
 void mergeParagraph(BufferParams const & bparams,
-       ParagraphList & pars, par_type par)
+       ParagraphList & pars, par_type par_offset)
 {
-       Paragraph & next = pars[par + 1];
+       Paragraph & next = pars[par_offset + 1];
+       Paragraph & par = pars[par_offset];
 
        pos_type pos_end = next.size() - 1;
-       pos_type pos_insert = pars[par].size();
+       pos_type pos_insert = par.size();
 
        // ok, now copy the paragraph
        for (pos_type i = 0, j = 0; i <= pos_end; ++i)
-               if (moveItem(next, pars[par], bparams, i, pos_insert + j))
+               if (moveItem(next, par, bparams, i, pos_insert + j))
                        ++j;
 
-       pars.erase(pars.begin() + par + 1);
+       pars.erase(pars.begin() + par_offset + 1);
 }
 
 
@@ -229,20 +244,27 @@ par_type depthHook(par_type pit,
 }
 
 
-par_type outerHook(par_type par, ParagraphList const & pars)
+par_type outerHook(par_type par_offset, ParagraphList const & pars)
 {
-       if (pars[par].getDepth() == 0)
+       Paragraph const & par = pars[par_offset];
+
+       if (par.getDepth() == 0)
                return pars.size();
-       return depthHook(par, pars, Paragraph::depth_type(pars[par].getDepth() - 1));
+       return depthHook(par_offset, pars, Paragraph::depth_type(par.getDepth() - 1));
 }
 
 
-bool isFirstInSequence(par_type pit, ParagraphList const & pars)
+bool isFirstInSequence(par_type par_offset, ParagraphList const & pars)
 {
-       par_type dhook = depthHook(pit, pars, pars[pit].getDepth());
-       return dhook == pit
-               || pars[dhook].layout() != pars[pit].layout()
-               || pars[dhook].getDepth() != pars[pit].getDepth();
+       Paragraph const & par = pars[par_offset];
+
+       par_type dhook_offset = depthHook(par_offset, pars, par.getDepth());
+
+       Paragraph const & dhook = pars[dhook_offset];
+
+       return dhook_offset == par_offset
+               || dhook.layout() != par.layout()
+               || dhook.getDepth() != par.getDepth();
 }
 
 
@@ -275,19 +297,19 @@ int getEndLabel(par_type p, ParagraphList const & pars)
 }
 
 
-LyXFont const outerFont(par_type pit, ParagraphList const & pars)
+LyXFont const outerFont(par_type par_offset, ParagraphList const & pars)
 {
-       Paragraph::depth_type par_depth = pars[pit].getDepth();
+       Paragraph::depth_type par_depth = pars[par_offset].getDepth();
        LyXFont tmpfont(LyXFont::ALL_INHERIT);
 
        // Resolve against environment font information
-       while (pit != par_type(pars.size())
+       while (par_offset != par_type(pars.size())
               && par_depth
               && !tmpfont.resolved()) {
-               pit = outerHook(pit, pars);
-               if (pit != par_type(pars.size())) {
-                       tmpfont.realize(pars[pit].layout()->font);
-                       par_depth = pars[pit].getDepth();
+               par_offset = outerHook(par_offset, pars);
+               if (par_offset != par_type(pars.size())) {
+                       tmpfont.realize(pars[par_offset].layout()->font);
+                       par_depth = pars[par_offset].getDepth();
                }
        }
 

diff --git a/src/text.C b/src/text.C
index fda8d9a1d6b4c9d56ec4cfbf88f7f379dbcb38bd..d5bbf53c3afb79bdcaede0026d138c84f0ef74d8 100644 (file)
--- a/src/text.C
+++ b/src/text.C
@@ -2092,6 +2092,7 @@ string LyXText::currentState(LCursor & cur)
                        break;
                }
        }
+
 #ifdef DEVEL_VERSION
        os << _(", Inset: ") << &cur.inset();
        os << _(", Paragraph: ") << cur.par();

diff --git a/src/text3.C b/src/text3.C
index 6b9213a9dae673772feb1a4023d45389df7d9312..fd6d9b298e7e0f97c6b4c8c10ad72cb7f8be56b9 100644 (file)
--- a/src/text3.C
+++ b/src/text3.C
@@ -185,7 +185,7 @@ string const freefont2string()
 
 
 //takes absolute x,y coordinates
-InsetBase * LyXText::checkInsetHit(int x, int y) const 
+InsetBase * LyXText::checkInsetHit(int x, int y) const
 {
        par_type pit;
        par_type end;
@@ -454,7 +454,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd)
                finishChange(cur, false);
                break;
 
-       case LFUN_BEGINNINGBUF: 
+       case LFUN_BEGINNINGBUF:
                if (cur.size() == 1) {
                        if (!cur.mark())
                                cur.clearSelection();
@@ -1045,7 +1045,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd)
                                cur.insert(new InsetQuotes(c,
                                    bufparams.quotes_language,
                                    InsetQuotes::DoubleQ));
-                       else 
+                       else
                                cur.insert(new InsetQuotes(c, bufparams));
                        cur.posRight();
                }