X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_funcs.C;h=4ec57ef3eed6e957a8e90b7da21ed677d4460512;hb=8765ab59cdddad67284007813ef25934ea0042ce;hp=053489e88adfb819b68e2bc03f48d98c82424994;hpb=d7bcff50a9db55b3e04b8af8be1de8a25fd93601;p=lyx.git diff --git a/src/paragraph_funcs.C b/src/paragraph_funcs.C index 053489e88a..4ec57ef3ee 100644 --- a/src/paragraph_funcs.C +++ b/src/paragraph_funcs.C @@ -12,82 +12,49 @@ #include "paragraph_funcs.h" -#include "buffer.h" #include "bufferparams.h" - -#include "debug.h" -#include "encoding.h" -#include "gettext.h" -#include "language.h" -#include "lyxrow.h" #include "lyxtext.h" -#include "outputparams.h" #include "paragraph_pimpl.h" -#include "pariterator.h" -#include "sgml.h" -#include "texrow.h" -#include "vspace.h" - -#include "support/filetools.h" -#include "support/lstrings.h" -#include "support/lyxlib.h" - -#include -#include - -using lyx::pos_type; -using lyx::pit_type; - -using lyx::support::ascii_lowercase; -using lyx::support::bformat; -using lyx::support::compare_ascii_no_case; -using lyx::support::compare_no_case; -using lyx::support::contains; -using lyx::support::split; -using lyx::support::subst; - -using std::auto_ptr; -using std::endl; -using std::string; -using std::vector; -using std::istringstream; -using std::ostream; -using std::pair; +#include "debug.h" -namespace { +namespace lyx { -bool moveItem(Paragraph & from, Paragraph & to, - BufferParams const & params, pos_type i, pos_type j, - Change change = Change(Change::INSERTED)); +using std::string; +using std::endl; -bool moveItem(Paragraph & from, Paragraph & to, - BufferParams const & params, pos_type i, pos_type j, - Change change) + +static bool moveItem(Paragraph & fromPar, pos_type fromPos, + Paragraph & toPar, pos_type toPos, BufferParams const & params) { - Paragraph::value_type const tmpchar = from.getChar(i); - LyXFont tmpfont = from.getFontSettings(params, i); - - if (tmpchar == Paragraph::META_INSET) { - InsetBase * tmpinset = 0; - if (from.getInset(i)) { - // the inset is not in a paragraph anymore - tmpinset = from.insetlist.release(i); - from.insetlist.erase(i); + // Note: moveItem() does not honour change tracking! + // Therefore, it should only be used for breaking and merging paragraphs + + Paragraph::value_type const tmpChar = fromPar.getChar(fromPos); + LyXFont const tmpFont = fromPar.getFontSettings(params, fromPos); + Change const tmpChange = fromPar.lookupChange(fromPos); + + if (tmpChar == Paragraph::META_INSET) { + InsetBase * tmpInset = 0; + if (fromPar.getInset(fromPos)) { + // the inset is not in the paragraph any more + tmpInset = fromPar.insetlist.release(fromPos); } - if (!to.insetAllowed(tmpinset->lyxCode())) { - delete tmpinset; + fromPar.eraseChar(fromPos, false); + + if (!toPar.insetAllowed(tmpInset->lyxCode())) { + delete tmpInset; return false; } - if (tmpinset) - to.insertInset(j, tmpinset, tmpfont, change); + + toPar.insertInset(toPos, tmpInset, tmpFont, tmpChange); } else { - to.insertChar(j, tmpchar, tmpfont, change); + fromPar.eraseChar(fromPos, false); + toPar.insertChar(toPos, tmpChar, tmpFont, tmpChange); } - return true; -} + return true; } @@ -101,26 +68,23 @@ void breakParagraph(BufferParams const & bparams, Paragraph & par = pars[par_offset]; - // we will invalidate the row cache - par.rows().clear(); - // without doing that we get a crash when typing at the // end of a paragraph tmp->layout(bparams.getLyXTextClass().defaultLayout()); // remember to set the inset_owner tmp->setInsetOwner(par.inInset()); - if (bparams.tracking_changes) - tmp->trackChanges(); - - // this is an idea for a more userfriendly layout handling, I will - // see what the users say - // layout stays the same with latex-environments if (flag) { tmp->layout(par.layout()); tmp->setLabelWidthString(par.params().labelWidthString()); tmp->params().depth(par.params().depth()); + } else if (par.params().depth() > 0) { + Paragraph const & hook = pars[outerHook(par_offset, pars)]; + tmp->layout(hook.layout()); + // not sure the line below is useful + tmp->setLabelWidthString(par.params().labelWidthString()); + tmp->params().depth(hook.params().depth()); } bool const isempty = (par.allowEmpty() && par.empty()); @@ -133,7 +97,7 @@ void breakParagraph(BufferParams const & bparams, tmp->params().depth(par.params().depth()); tmp->params().noindent(par.params().noindent()); - // copy everything behind the break-position + // move everything behind the break position // to the new paragraph /* Note: if !keepempty, empty() == true, then we reach @@ -143,21 +107,21 @@ 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.lookupChangeType(i); - if (moveItem(par, *tmp, bparams, i, j - pos)) { - tmp->setChange(j - pos, change); + for (pos_type i = pos, j = 0; i <= pos_end; ++i) { + if (moveItem(par, pos, *tmp, j, bparams)) { ++j; } } - - for (pos_type i = pos_end; i >= pos; --i) - par.eraseIntern(i); } + // Move over the end-of-par change information + tmp->setChange(tmp->size(), par.lookupChange(par.size())); + par.setChange(par.size(), Change(bparams.trackChanges ? + Change::INSERTED : Change::UNCHANGED)); + if (pos) { // Make sure that we keep the language when - // breaking paragrpah. + // breaking paragraph. if (tmp->empty()) { LyXFont changed = tmp->getFirstFontSettings(bparams); LyXFont old = par.getFontSettings(bparams, par.size()); @@ -179,15 +143,6 @@ void breakParagraph(BufferParams const & bparams, 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 (!par.size()) { - par.cleanChanges(); - } else if (!tmp->size()) { - tmp->cleanChanges(); - } - } } @@ -199,33 +154,23 @@ void breakParagraphConservative(BufferParams const & bparams, Paragraph()); Paragraph & par = pars[par_offset]; - if (bparams.tracking_changes) - tmp.trackChanges(); - tmp.makeSameLayout(par); - // When can pos > size()? - // I guess pos == size() is possible. - if (par.size() > pos) { - // copy everything behind the break-position to the new - // paragraph + BOOST_ASSERT(pos <= par.size()); + + if (pos < par.size()) { + // move everything behind the break position to the new paragraph pos_type pos_end = par.size() - 1; - for (pos_type i = pos, j = pos; i <= pos_end; ++i) { - Change::Type change = par.lookupChangeType(i); - if (moveItem(par, tmp, bparams, i, j - pos, change)) + for (pos_type i = pos, j = 0; i <= pos_end; ++i) { + if (moveItem(par, pos, tmp, j, bparams)) { ++j; + } } - // Move over end-of-par change attr - tmp.setChange(tmp.size(), par.lookupChangeType(par.size())); - - // 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); - } + // Move over the end-of-par change information + tmp.setChange(tmp.size(), par.lookupChange(par.size())); + par.setChange(par.size(), Change(bparams.trackChanges ? + Change::INSERTED : Change::UNCHANGED)); } } @@ -239,35 +184,32 @@ 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.lookupChangeType(next.size()); - // ok, now copy the paragraph - for (pos_type i = 0, j = 0; i <= pos_end; ++i) { - Change::Type change = next.lookupChangeType(i); - if (moveItem(next, par, bparams, i, pos_insert + j, change)) + // the imaginary end-of-paragraph character (at par.size()) has to be + // marked as unmodified. Otherwise, its change is adopted by the first + // character of the next paragraph. + if (par.lookupChange(par.size()).type != Change::UNCHANGED) { + lyxerr[Debug::CHANGES] << + "merging par with inserted/deleted end-of-par character" << endl; + par.setChange(par.size(), Change(Change::UNCHANGED)); + } + + Change change = next.lookupChange(next.size()); + + // move the content of the second paragraph to the end of the first one + for (pos_type i = 0, j = pos_insert; i <= pos_end; ++i) { + if (moveItem(next, 0, par, j, bparams)) { ++j; + } } - // Move the change status of "carriage return" over - par.setChange(par.size(), cr); + + // move the change of the end-of-paragraph character + par.setChange(par.size(), change); pars.erase(boost::next(pars.begin(), par_offset + 1)); } -pit_type depthHook(pit_type pit, - ParagraphList const & pars, Paragraph::depth_type depth) +pit_type depthHook(pit_type pit, ParagraphList const & pars, depth_type depth) { pit_type newpit = pit; @@ -290,7 +232,7 @@ pit_type outerHook(pit_type par_offset, ParagraphList const & pars) if (par.getDepth() == 0) return pars.size(); - return depthHook(par_offset, pars, Paragraph::depth_type(par.getDepth() - 1)); + return depthHook(par_offset, pars, depth_type(par.getDepth() - 1)); } @@ -300,10 +242,12 @@ bool isFirstInSequence(pit_type par_offset, ParagraphList const & pars) pit_type dhook_offset = depthHook(par_offset, pars, par.getDepth()); + if (dhook_offset == par_offset) + return true; + Paragraph const & dhook = pars[dhook_offset]; - return dhook_offset == par_offset - || dhook.layout() != par.layout() + return dhook.layout() != par.layout() || dhook.getDepth() != par.getDepth(); } @@ -311,7 +255,7 @@ bool isFirstInSequence(pit_type par_offset, ParagraphList const & pars) int getEndLabel(pit_type p, ParagraphList const & pars) { pit_type pit = p; - Paragraph::depth_type par_depth = pars[p].getDepth(); + depth_type par_depth = pars[p].getDepth(); while (pit != pit_type(pars.size())) { LyXLayout_ptr const & layout = pars[pit].layout(); int const endlabeltype = layout->endlabeltype; @@ -320,7 +264,7 @@ int getEndLabel(pit_type p, ParagraphList const & pars) if (p + 1 == pit_type(pars.size())) return endlabeltype; - Paragraph::depth_type const next_depth = + depth_type const next_depth = pars[p + 1].getDepth(); if (par_depth > next_depth || (par_depth == next_depth && layout != pars[p + 1].layout())) @@ -339,7 +283,7 @@ int getEndLabel(pit_type p, ParagraphList const & pars) LyXFont const outerFont(pit_type par_offset, ParagraphList const & pars) { - Paragraph::depth_type par_depth = pars[par_offset].getDepth(); + depth_type par_depth = pars[par_offset].getDepth(); LyXFont tmpfont(LyXFont::ALL_INHERIT); // Resolve against environment font information @@ -370,3 +314,6 @@ int numberOfOptArgs(Paragraph const & par) } return num; } + + +} // namespace lyx