X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=5579d6deeea234e75227382628a16d643d69cfa7;hb=131eabe56c437ebb740950a17b6226914153f2df;hp=50723296514d60d7e68812d0cfb0807da9611d1e;hpb=8e5e95247280998287554937870c44a20fc493c7;p=lyx.git diff --git a/src/paragraph.C b/src/paragraph.C index 5072329651..5579d6deee 100644 --- a/src/paragraph.C +++ b/src/paragraph.C @@ -10,28 +10,29 @@ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "paragraph.h" #include "paragraph_pimpl.h" -#include "lyxrc.h" -#include "layout.h" -#include "language.h" -#include "tex-strings.h" + #include "buffer.h" #include "bufferparams.h" -#include "debug.h" -#include "texrow.h" #include "BufferView.h" +#include "changes.h" #include "encoding.h" -#include "ParameterStruct.h" +#include "debug.h" #include "gettext.h" +#include "language.h" +#include "latexrunparams.h" +#include "layout.h" +#include "lyxrc.h" +#include "paragraph_funcs.h" +#include "ParameterStruct.h" +#include "texrow.h" + +#include "Lsstream.h" -#include "insets/insetinclude.h" -#include "insets/insetbib.h" -#include "insets/insettext.h" +#include "insets/insetbibitem.h" +#include "insets/insetoptarg.h" +#include "insets/insetenv.h" #include "support/filetools.h" #include "support/lstrings.h" @@ -43,6 +44,9 @@ #include #include #include +#include + +using namespace lyx::support; using std::ostream; using std::endl; @@ -50,14 +54,9 @@ using std::fstream; using std::ios; using std::lower_bound; using std::upper_bound; -using std::reverse; using lyx::pos_type; -// this is a bad idea, but how can Paragraph find its buffer to get -// parameters? (JMarc) - -extern string bibitemWidest(Buffer const *); // this is a minibuffer @@ -65,89 +64,71 @@ namespace { char minibuffer_char; LyXFont minibuffer_font; -Inset * minibuffer_inset; +InsetOld * minibuffer_inset; } // namespace anon -extern BufferView * current_view; - - Paragraph::Paragraph() : pimpl_(new Paragraph::Pimpl(this)) { - next_ = 0; - previous_ = 0; enumdepth = 0; itemdepth = 0; - bibkey = 0; // ale970302 params().clear(); } -// This constructor inserts the new paragraph in a list. -Paragraph::Paragraph(Paragraph * par) - : pimpl_(new Paragraph::Pimpl(this)) +Paragraph::Paragraph(Paragraph const & lp) + : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this)) { enumdepth = 0; itemdepth = 0; + // this is because of the dummy layout of the paragraphs that + // follow footnotes + layout_ = lp.layout(); - // double linked list begin - next_ = par->next_; - if (next_) - next_->previous_ = this; - previous_ = par; - previous_->next_ = this; - // end - - bibkey = 0; // ale970302 - params().clear(); + // copy everything behind the break-position to the new paragraph + insetlist = lp.insetlist; + InsetList::iterator it = insetlist.begin(); + InsetList::iterator end = insetlist.end(); + for (; it != end; ++it) { + // currently we hold Inset*, not InsetBase* + it->inset = static_cast(it->inset->clone().release()); + // tell the new inset who is the boss now + it->inset->parOwner(this); + } } -Paragraph::Paragraph(Paragraph const & lp, bool same_ids) - : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids)) +void Paragraph::operator=(Paragraph const & lp) { - enumdepth = 0; - itemdepth = 0; - next_ = 0; - previous_ = 0; + // needed as we will destroy the pimpl_ before copying it + if (&lp != this) + return; + lyxerr << "Paragraph::operator=()\n"; + delete pimpl_; + pimpl_ = new Pimpl(*lp.pimpl_, this); + enumdepth = lp.enumdepth; + itemdepth = lp.itemdepth; // this is because of the dummy layout of the paragraphs that // follow footnotes layout_ = lp.layout(); - // ale970302 - if (lp.bibkey) { - bibkey = static_cast - (lp.bibkey->clone(*current_view->buffer())); - } else { - bibkey = 0; - } - // copy everything behind the break-position to the new paragraph insetlist = lp.insetlist; - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) - { - it.setInset(it.getInset()->clone(*current_view->buffer(), same_ids)); + InsetList::iterator it = insetlist.begin(); + InsetList::iterator end = insetlist.end(); + for (; it != end; ++it) { + it->inset = static_cast(it->inset->clone().release()); // tell the new inset who is the boss now - it.getInset()->parOwner(this); + it->inset->parOwner(this); } } - // the destructor removes the new paragraph from the list Paragraph::~Paragraph() { - if (previous_) - previous_->next_ = next_; - if (next_) - next_->previous_ = previous_; - - // ale970302 - delete bibkey; - delete pimpl_; // //lyxerr << "Paragraph::paragraph_id = " @@ -155,9 +136,9 @@ Paragraph::~Paragraph() } -void Paragraph::writeFile(Buffer const * buf, ostream & os, +void Paragraph::write(Buffer const * buf, ostream & os, BufferParams const & bparams, - depth_type dth) const + depth_type & dth) const { // The beginning or end of a deeper (i.e. nested) area? if (dth != params().depth()) { @@ -175,81 +156,30 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, } // First write the layout - os << "\n\\layout " << layout()->name() << "\n"; - - // Maybe some vertical spaces. - if (params().spaceTop().kind() != VSpace::NONE) - os << "\\added_space_top " - << params().spaceTop().asLyXCommand() << " "; - if (params().spaceBottom().kind() != VSpace::NONE) - os << "\\added_space_bottom " - << params().spaceBottom().asLyXCommand() << " "; + os << "\n\\begin_layout " << layout()->name() << '\n'; - // Maybe the paragraph has special spacing - params().spacing().writeFile(os, true); - - // The labelwidth string used in lists. - if (!params().labelWidthString().empty()) - os << "\\labelwidthstring " - << params().labelWidthString() << '\n'; - - // Lines above or below? - if (params().lineTop()) - os << "\\line_top "; - if (params().lineBottom()) - os << "\\line_bottom "; - - // Pagebreaks above or below? - if (params().pagebreakTop()) - os << "\\pagebreak_top "; - if (params().pagebreakBottom()) - os << "\\pagebreak_bottom "; - - // Start of appendix? - if (params().startOfAppendix()) - os << "\\start_of_appendix "; - - // Noindent? - if (params().noindent()) - os << "\\noindent "; - - // Do we have a manual left indent? - if (!params().leftIndent().zero()) - os << "\\leftindent " << params().leftIndent().asString() << " "; - - // Alignment? - if (params().align() != LYX_ALIGN_LAYOUT) { - int h = 0; - switch (params().align()) { - case LYX_ALIGN_LEFT: h = 1; break; - case LYX_ALIGN_RIGHT: h = 2; break; - case LYX_ALIGN_CENTER: h = 3; break; - default: h = 0; break; - } - os << "\\align " << string_align[h] << " "; - } - - // bibitem ale970302 - if (bibkey) - bibkey->write(buf, os); + params().write(os); LyXFont font1(LyXFont::ALL_INHERIT, bparams.language); + Change running_change = Change(Change::UNCHANGED); + lyx::time_type const curtime(lyx::current_time()); + int column = 0; for (pos_type i = 0; i < size(); ++i) { if (!i) { - os << "\n"; + os << '\n'; column = 0; } + Change change = pimpl_->lookupChangeFull(i); + Changes::lyxMarkChange(os, column, curtime, running_change, change); + running_change = change; + // Write font changes LyXFont font2 = getFontSettings(bparams, i); if (font2 != font1) { -#ifndef INHERIT_LANGUAGE font2.lyxWriteChanges(font1, os); -#else - font2.lyxWriteChanges(font1, bparams.language, os); -#endif column = 0; font1 = font2; } @@ -258,7 +188,7 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, switch (c) { case META_INSET: { - Inset const * inset = getInset(i); + InsetOld const * inset = getInset(i); if (inset) if (inset->directWrite()) { // international char, let it write @@ -273,14 +203,6 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, } } break; - case META_NEWLINE: - os << "\n\\newline \n"; - column = 0; - break; - case META_HFILL: - os << "\n\\hfill \n"; - column = 0; - break; case '\\': os << "\n\\backslash \n"; column = 0; @@ -290,12 +212,12 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, os << ".\n"; column = 0; } else - os << "."; + os << '.'; break; default: if ((column > 70 && c == ' ') || column > 79) { - os << "\n"; + os << '\n'; column = 0; } // this check is to amend a bug. LyX sometimes @@ -310,9 +232,16 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, } } - // now write the next paragraph - if (next_) - next_->writeFile(buf, os, bparams, dth); + // to make reading work properly + if (!size()) { + running_change = pimpl_->lookupChange(0); + Changes::lyxMarkChange(os, column, curtime, + Change(Change::UNCHANGED), running_change); + } + Changes::lyxMarkChange(os, column, curtime, + running_change, Change(Change::UNCHANGED)); + + os << "\n\\end_layout\n"; } @@ -332,7 +261,7 @@ void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const minibuffer_inset = 0; if (minibuffer_char == Paragraph::META_INSET) { if (getInset(pos)) { - minibuffer_inset = getInset(pos)->clone(buffer); + minibuffer_inset = static_cast(getInset(pos)->clone().release()); } else { minibuffer_inset = 0; minibuffer_char = ' '; @@ -349,46 +278,28 @@ void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos) minibuffer_inset = 0; if (minibuffer_char == Paragraph::META_INSET) { if (getInset(pos)) { - minibuffer_inset = getInset(pos); - // This is a little hack since I want exactly - // the inset, not just a clone. Otherwise - // the inset would be deleted when calling Erase(pos) - // find the entry - InsetList::iterator it = insetlist.begin(); - InsetList::iterator end = insetlist.end(); - for (; it != end; ++it) { - if (it.getPos() == pos) - break; - } - - if (it != end && it.getPos() == pos) - it.setInset(0); // the inset is not in a paragraph anymore + minibuffer_inset = insetlist.release(pos); minibuffer_inset->parOwner(0); } else { minibuffer_inset = 0; minibuffer_char = ' '; // This reflects what GetInset() does (ARRae) } - } - - // Erase(pos); now the caller is responsible for that. } bool Paragraph::insertFromMinibuffer(pos_type pos) { if (minibuffer_char == Paragraph::META_INSET) { - if (!insetAllowed(minibuffer_inset->lyxCode())) { + if (!insetAllowed(minibuffer_inset->lyxCode())) return false; - } insertInset(pos, minibuffer_inset, minibuffer_font); } else { LyXFont f = minibuffer_font; - if (!checkInsertChar(f)) { + if (!checkInsertChar(f)) return false; - } insertChar(pos, minibuffer_char, f); } return true; @@ -397,9 +308,21 @@ bool Paragraph::insertFromMinibuffer(pos_type pos) // end of minibuffer -void Paragraph::erase(pos_type pos) +void Paragraph::eraseIntern(lyx::pos_type pos) +{ + pimpl_->eraseIntern(pos); +} + + +bool Paragraph::erase(pos_type pos) +{ + return pimpl_->erase(pos); +} + + +int Paragraph::erase(pos_type start, pos_type end) { - pimpl_->erase(pos); + return pimpl_->erase(start, end); } @@ -413,73 +336,48 @@ bool Paragraph::checkInsertChar(LyXFont & font) void Paragraph::insertChar(pos_type pos, Paragraph::value_type c) { - LyXFont const f(LyXFont::ALL_INHERIT); - insertChar(pos, c, f); + insertChar(pos, c, LyXFont(LyXFont::ALL_INHERIT)); } void Paragraph::insertChar(pos_type pos, Paragraph::value_type c, - LyXFont const & font) + LyXFont const & font, Change change) { - pimpl_->insertChar(pos, c, font); + pimpl_->insertChar(pos, c, font, change); } -void Paragraph::insertInset(pos_type pos, Inset * inset) +void Paragraph::insertInset(pos_type pos, InsetOld * inset) { - LyXFont const f(LyXFont::ALL_INHERIT); - insertInset(pos, inset, f); + insertInset(pos, inset, LyXFont(LyXFont::ALL_INHERIT)); } -void Paragraph::insertInset(pos_type pos, Inset * inset, LyXFont const & font) +void Paragraph::insertInset(pos_type pos, InsetOld * inset, LyXFont const & font, Change change) { - pimpl_->insertInset(pos, inset, font); + pimpl_->insertInset(pos, inset, font, change); } -bool Paragraph::insetAllowed(Inset::Code code) +bool Paragraph::insetAllowed(InsetOld::Code code) { //lyxerr << "Paragraph::InsertInsetAllowed" << endl; - if (pimpl_->inset_owner) return pimpl_->inset_owner->insetAllowed(code); return true; } -Inset * Paragraph::getInset(pos_type pos) +InsetOld * Paragraph::getInset(pos_type pos) { - lyx::Assert(pos < size()); - - // Find the inset. - InsetList::iterator it = insetlist.begin(); - InsetList::iterator end = insetlist.end(); - for (; it != end; ++it) { - if (it.getPos() == pos) - break; - } - - if (it != end && it.getPos() == pos) - return it.getInset(); - - lyxerr << "ERROR (Paragraph::getInset): " - << "Inset does not exist: " << pos << endl; - //::raise(SIGSTOP); - - // text[pos] = ' '; // WHY!!! does this set the pos to ' '???? - // Did this commenting out introduce a bug? So far I have not - // see any, please enlighten me. (Lgb) - // My guess is that since the inset does not exist, we might - // as well replace it with a space to prevent craches. (Asger) - return 0; + Assert(pos < size()); + return insetlist.get(pos); } -Inset const * Paragraph::getInset(pos_type pos) const +InsetOld const * Paragraph::getInset(pos_type pos) const { - lyx::Assert(pos < size()); - + Assert(pos < size()); return insetlist.get(pos); } @@ -488,28 +386,38 @@ Inset const * Paragraph::getInset(pos_type pos) const LyXFont const Paragraph::getFontSettings(BufferParams const & bparams, pos_type pos) const { - lyx::Assert(pos <= size()); + Assert(pos <= size()); Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin(); Pimpl::FontList::const_iterator end = pimpl_->fontlist.end(); - for (; cit != end; ++cit) { + for (; cit != end; ++cit) if (cit->pos() >= pos) break; - } - LyXFont retfont; - if (cit != end) { - retfont = cit->font(); - } else if (pos == size() && !empty()) { - retfont = getFontSettings(bparams, pos - 1); - } else - retfont = LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams)); -#ifdef INHERIT_LANGUAGE - if (retfont.language() == inherit_language) - retfont.setLanguage(bparams.language); -#endif + if (cit != end) + return cit->font(); + + if (pos == size() && !empty()) + return getFontSettings(bparams, pos - 1); + + return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams)); +} + + +lyx::pos_type +Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const +{ + Assert(pos <= size()); + + Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin(); + Pimpl::FontList::const_iterator end = pimpl_->fontlist.end(); + for (; cit != end; ++cit) + if (cit->pos() >= pos) + return cit->pos(); - return retfont; + // This should not happen, but if so, we take no chances. + lyxerr << "Pararaph::getEndPosOfFontSpan: This should not happen!\n"; + return pos; } @@ -528,55 +436,49 @@ LyXFont const Paragraph::getFirstFontSettings() const // The difference is that this one is used for generating the LaTeX file, // and thus cosmetic "improvements" are disallowed: This has to deliver // the true picture of the buffer. (Asger) -// If position is -1, we get the layout font of the paragraph. -// If position is -2, we get the font of the manual label of the paragraph. -LyXFont const Paragraph::getFont(BufferParams const & bparams, - pos_type pos) const +LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos, + LyXFont const & outerfont) const { - lyx::Assert(pos >= 0); + Assert(pos >= 0); LyXLayout_ptr const & lout = layout(); - pos_type main_body = 0; - if (lout->labeltype == LABEL_MANUAL) - main_body = beginningOfMainBody(); + pos_type const body_pos = beginningOfBody(); LyXFont layoutfont; - if (pos < main_body) + if (pos < body_pos) layoutfont = lout->labelfont; else layoutfont = lout->font; LyXFont tmpfont = getFontSettings(bparams, pos); -#ifndef INHERIT_LANGUAGE tmpfont.realize(layoutfont); -#else - tmpfont.realize(layoutfont, bparams.language); -#endif + tmpfont.realize(outerfont); + tmpfont.realize(bparams.getLyXTextClass().defaultfont()); - return pimpl_->realizeFont(tmpfont, bparams); + return tmpfont; } -LyXFont const Paragraph::getLabelFont(BufferParams const & bparams) const +LyXFont const Paragraph::getLabelFont(BufferParams const & bparams, + LyXFont const & outerfont) const { - LyXLayout_ptr const & lout = layout(); - - LyXFont tmpfont = lout->labelfont; + LyXFont tmpfont = layout()->labelfont; tmpfont.setLanguage(getParLanguage(bparams)); - - return pimpl_->realizeFont(tmpfont, bparams); + tmpfont.realize(outerfont); + tmpfont.realize(bparams.getLyXTextClass().defaultfont()); + return tmpfont; } -LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams) const +LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams, + LyXFont const & outerfont) const { - LyXLayout_ptr const & lout = layout(); - - LyXFont tmpfont = lout->font; + LyXFont tmpfont = layout()->font; tmpfont.setLanguage(getParLanguage(bparams)); - - return pimpl_->realizeFont(tmpfont, bparams); + tmpfont.realize(outerfont); + tmpfont.realize(bparams.getLyXTextClass().defaultfont()); + return tmpfont; } @@ -659,7 +561,7 @@ Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const void Paragraph::setFont(pos_type pos, LyXFont const & font) { - lyx::Assert(pos <= size()); + Assert(pos <= size()); // First, reduce font against layout/label font // Update: The SetCharFont() routine in text2.C already @@ -720,137 +622,22 @@ void Paragraph::setFont(pos_type pos, LyXFont const & font) } - -void Paragraph::next(Paragraph * p) -{ - next_ = p; -} - - -// This function is able to hide closed footnotes. -Paragraph * Paragraph::next() -{ - return next_; -} - - -Paragraph const * Paragraph::next() const -{ - return next_; -} - - -void Paragraph::previous(Paragraph * p) -{ - previous_ = p; -} - - -// This function is able to hide closed footnotes. -Paragraph * Paragraph::previous() -{ - return previous_; -} - - -// This function is able to hide closed footnotes. -Paragraph const * Paragraph::previous() const -{ - return previous_; -} - - -void Paragraph::breakParagraph(BufferParams const & bparams, - pos_type pos, - int flag) -{ - // create a new paragraph - Paragraph * tmp = new Paragraph(this); - tmp->layout(bparams.getLyXTextClass().defaultLayout()); - // remember to set the inset_owner - tmp->setInsetOwner(inInset()); - - // 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(layout()); - tmp->setLabelWidthString(params().labelWidthString()); - } - - bool isempty = (layout()->keepempty && empty()); - - if (!isempty && (size() > pos || empty() || flag == 2)) { - tmp->layout(layout()); - tmp->params().align(params().align()); - tmp->setLabelWidthString(params().labelWidthString()); - - tmp->params().lineBottom(params().lineBottom()); - params().lineBottom(false); - tmp->params().pagebreakBottom(params().pagebreakBottom()); - params().pagebreakBottom(false); - tmp->params().spaceBottom(params().spaceBottom()); - params().spaceBottom(VSpace(VSpace::NONE)); - - tmp->params().depth(params().depth()); - tmp->params().noindent(params().noindent()); - - // copy everything behind the break-position - // to the new paragraph - pos_type pos_end = size() - 1; - pos_type i = pos; - pos_type j = pos; - for (; i <= pos_end; ++i) { - cutIntoMinibuffer(bparams, i); - if (tmp->insertFromMinibuffer(j - pos)) - ++j; - } - for (i = pos_end; i >= pos; --i) { - erase(i); - } - } - - // just an idea of me - if (!isempty && !pos) { - tmp->params().lineTop(params().lineTop()); - tmp->params().pagebreakTop(params().pagebreakTop()); - tmp->params().spaceTop(params().spaceTop()); - tmp->bibkey = bibkey; - - bibkey = 0; - params().clear(); - - layout(bparams.getLyXTextClass().defaultLayout()); - - // layout stays the same with latex-environments - if (flag) { - layout(tmp->layout()); - setLabelWidthString(tmp->params().labelWidthString()); - params().depth(tmp->params().depth()); - } - } -} - - -void Paragraph::makeSameLayout(Paragraph const * par) +void Paragraph::makeSameLayout(Paragraph const & par) { - layout(par->layout()); + layout(par.layout()); // move to pimpl? - params() = par->params(); + params() = par.params(); } int Paragraph::stripLeadingSpaces() { - if (layout()->free_spacing || - isFreeSpacing()) { + if (isFreeSpacing()) return 0; - } int i = 0; while (!empty() && (isNewline(0) || isLineSeparator(0))) { - erase(0); + pimpl_->eraseIntern(0); ++i; } @@ -858,100 +645,11 @@ int Paragraph::stripLeadingSpaces() } -bool Paragraph::hasSameLayout(Paragraph const * par) const +bool Paragraph::hasSameLayout(Paragraph const & par) const { return - par->layout() == layout() && - params().sameLayout(par->params()); -} - - -void Paragraph::breakParagraphConservative(BufferParams const & bparams, - pos_type pos) -{ - // create a new paragraph - Paragraph * tmp = new Paragraph(this); - tmp->makeSameLayout(this); - - // When can pos > Last()? - // I guess pos == Last() is possible. - if (size() > pos) { - // copy everything behind the break-position to the new - // paragraph - pos_type pos_end = size() - 1; - - //pos_type i = pos; - //pos_type j = pos; - for (pos_type i = pos, j = pos; i <= pos_end; ++i) { - cutIntoMinibuffer(bparams, i); - if (tmp->insertFromMinibuffer(j - pos)) - ++j; - } - - for (pos_type k = pos_end; k >= pos; --k) { - erase(k); - } - } -} - - -// Be carefull, this does not make any check at all. -// This method has wrong name, it combined this par with the next par. -// In that sense it is the reverse of break paragraph. (Lgb) -void Paragraph::pasteParagraph(BufferParams const & bparams) -{ - // copy the next paragraph to this one - Paragraph * the_next = next(); - - // first the DTP-stuff - params().lineBottom(the_next->params().lineBottom()); - params().spaceBottom(the_next->params().spaceBottom()); - params().pagebreakBottom(the_next->params().pagebreakBottom()); - - pos_type pos_end = the_next->pimpl_->size() - 1; - pos_type pos_insert = size(); - - // ok, now copy the paragraph - for (pos_type i = 0, j = 0; i <= pos_end; ++i) { - the_next->cutIntoMinibuffer(bparams, i); - if (insertFromMinibuffer(pos_insert + j)) - ++j; - } - - // delete the next paragraph - Paragraph * ppar = the_next->previous_; - Paragraph * npar = the_next->next_; - delete the_next; - ppar->next(npar); -} - - -int Paragraph::getEndLabel() const -{ - Paragraph const * par = this; - depth_type par_depth = getDepth(); - while (par) { - LyXLayout_ptr const & layout = par->layout(); - int const endlabeltype = layout->endlabeltype; - - if (endlabeltype != END_LABEL_NO_LABEL) { - if (!next_) - return endlabeltype; - - depth_type const next_depth = next_->getDepth(); - if (par_depth > next_depth || - (par_depth == next_depth - && layout != next_->layout())) - return endlabeltype; - break; - } - if (par_depth == 0) - break; - par = par->outerHook(); - if (par) - par_depth = par->getDepth(); - } - return END_LABEL_NO_LABEL; + par.layout() == layout() && + params().sameLayout(par.params()); } @@ -963,15 +661,13 @@ Paragraph::depth_type Paragraph::getDepth() const Paragraph::depth_type Paragraph::getMaxDepthAfter() const { - bool const isenv = layout()->isEnvironment(); - - if (isenv) + if (layout()->isEnvironment()) return params().depth() + 1; else return params().depth(); - } + char Paragraph::getAlign() const { return params().align(); @@ -984,12 +680,6 @@ string const & Paragraph::getLabelstring() const } -int Paragraph::getFirstCounter(int i) const -{ - return pimpl_->counter_[i]; -} - - // the next two functions are for the manual labels string const Paragraph::getLabelWidthString() const { @@ -1017,32 +707,31 @@ void Paragraph::applyLayout(LyXLayout_ptr const & new_layout) } -// if the layout of a paragraph contains a manual label, the beginning of the -// main body is the beginning of the second word. This is what the par- -// function returns. If the layout does not contain a label, the main -// body always starts with position 0. This differentiation is necessary, -// because there cannot be a newline or a blank <= the beginning of the -// main body in TeX. - -int Paragraph::beginningOfMainBody() const +int Paragraph::beginningOfBody() const { + if (layout()->labeltype != LABEL_MANUAL) + return 0; + // Unroll the first two cycles of the loop // and remember the previous character to // remove unnecessary GetChar() calls pos_type i = 0; - if (i < size() && getChar(i) != Paragraph::META_NEWLINE) { + if (i < size() && !isNewline(i)) { ++i; char previous_char = 0; char temp = 0; - if (i < size() - && (previous_char = getChar(i)) != Paragraph::META_NEWLINE) { - // Yes, this ^ is supposed to be "= " not "==" - ++i; - while (i < size() - && previous_char != ' ' - && (temp = getChar(i)) != Paragraph::META_NEWLINE) { + if (i < size()) { + previous_char = getChar(i); + if (!isNewline(i)) { ++i; - previous_char = temp; + while (i < size() && previous_char != ' ') { + temp = getChar(i); + if (isNewline(i)) + break; + + ++i; + previous_char = temp; + } } } } @@ -1051,295 +740,28 @@ int Paragraph::beginningOfMainBody() const } -Paragraph * Paragraph::depthHook(depth_type depth) -{ - Paragraph * newpar = this; - - do { - newpar = newpar->previous(); - } while (newpar && newpar->getDepth() > depth); - - if (!newpar) { - if (previous() || getDepth()) - lyxerr << "ERROR (Paragraph::DepthHook): " - "no hook." << endl; - newpar = this; - } - - return newpar; -} - - -Paragraph const * Paragraph::depthHook(depth_type depth) const -{ - Paragraph const * newpar = this; - - do { - newpar = newpar->previous(); - } while (newpar && newpar->getDepth() > depth); - - if (!newpar) { - if (previous() || getDepth()) - lyxerr << "ERROR (Paragraph::DepthHook): " - "no hook." << endl; - newpar = this; - } - - return newpar; -} - -Paragraph * Paragraph::outerHook() -{ - if (!getDepth()) - return 0; - return depthHook(depth_type(getDepth() - 1)); -} - -Paragraph const * Paragraph::outerHook() const -{ - if (!getDepth()) - return 0; - return depthHook(depth_type(getDepth() - 1)); -} - - // returns -1 if inset not found -int Paragraph::getPositionOfInset(Inset const * inset) const +int Paragraph::getPositionOfInset(InsetOld const * inset) const { // Find the entry. - InsetList::iterator it = insetlist.begin(); - InsetList::iterator end = insetlist.end(); - for (; it != end; ++it) { - if (it.getInset() == inset) { - return it.getPos(); - } - } - if (inset == bibkey) - return 0; - + InsetList::const_iterator it = insetlist.begin(); + InsetList::const_iterator end = insetlist.end(); + for (; it != end; ++it) + if (it->inset == inset) + return it->pos; return -1; } -Paragraph * Paragraph::TeXOnePar(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow, - bool moving_arg) +InsetBibitem * Paragraph::bibitem() const { - lyxerr[Debug::LATEX] << "TeXOnePar... " << this << endl; - Inset const * in = inInset(); - bool further_blank_line = false; - LyXLayout_ptr style; - - // well we have to check if we are in an inset with unlimited - // lenght (all in one row) if that is true then we don't allow - // any special options in the paragraph and also we don't allow - // any environment other then "Standard" to be valid! - if ((in == 0) || !in->forceDefaultParagraphs(in)) { - style = layout(); - - if (params().startOfAppendix()) { - os << "\\appendix\n"; - texrow.newline(); - } - - if (!params().spacing().isDefault() - && (!previous() || !previous()->hasSameLayout(this))) { - os << params().spacing().writeEnvirBegin() << "\n"; - texrow.newline(); - } - - if (style->isCommand()) { - os << '\n'; - texrow.newline(); - } - - if (params().pagebreakTop()) { - os << "\\newpage"; - further_blank_line = true; - } - if (params().spaceTop().kind() != VSpace::NONE) { - os << params().spaceTop().asLatexCommand(bparams); - further_blank_line = true; - } - - if (params().lineTop()) { - os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}' - << "\\vspace{-1\\parskip}"; - further_blank_line = true; - } - - if (further_blank_line) { - os << '\n'; - texrow.newline(); - } - } else { - style = bparams.getLyXTextClass().defaultLayout(); - } - - Language const * language = getParLanguage(bparams); - Language const * doc_language = bparams.language; - Language const * previous_language = previous() - ? previous()->getParLanguage(bparams) : doc_language; - - if (language->babel() != previous_language->babel() - // check if we already put language command in TeXEnvironment() - && !(style->isEnvironment() - && (!previous() || previous()->layout() != layout() || - previous()->params().depth() != params().depth()))) - { - if (!lyxrc.language_command_end.empty() && - previous_language->babel() != doc_language->babel()) - { - os << subst(lyxrc.language_command_end, "$$lang", - previous_language->babel()) - << endl; - texrow.newline(); - } - - if (lyxrc.language_command_end.empty() || - language->babel() != doc_language->babel()) - { - os << subst(lyxrc.language_command_begin, "$$lang", - language->babel()) - << endl; - texrow.newline(); - } - } - - if (bparams.inputenc == "auto" && - language->encoding() != previous_language->encoding()) { - os << "\\inputencoding{" - << language->encoding()->LatexName() - << "}" << endl; - texrow.newline(); - } - - switch (style->latextype) { - case LATEX_COMMAND: - os << '\\' - << style->latexname() - << style->latexparam(); - break; - case LATEX_ITEM_ENVIRONMENT: - if (bibkey) { - bibkey->latex(buf, os, false, false); - } else - os << "\\item "; - break; - case LATEX_LIST_ENVIRONMENT: - os << "\\item "; - break; - default: - break; - } - - bool need_par = simpleTeXOnePar(buf, bparams, os, texrow, moving_arg); - - // Make sure that \\par is done with the font of the last - // character if this has another size as the default. - // This is necessary because LaTeX (and LyX on the screen) - // calculates the space between the baselines according - // to this font. (Matthias) - // - // Is this really needed ? (Dekel) - // We do not need to use to change the font for the last paragraph - // or for a command. - LyXFont const font = - (empty() - ? getLayoutFont(bparams) : getFont(bparams, size() - 1)); - - bool is_command = style->isCommand(); - - if (style->resfont.size() != font.size() && next_ && !is_command) { - if (!need_par) - os << "{"; - os << "\\" << font.latexSize() << " \\par}"; - } else if (need_par) { - os << "\\par}"; - } else if (is_command) - os << "}"; - - switch (style->latextype) { - case LATEX_ITEM_ENVIRONMENT: - case LATEX_LIST_ENVIRONMENT: - if (next_ && (params().depth() < next_->params().depth())) { - os << '\n'; - texrow.newline(); - } - break; - case LATEX_ENVIRONMENT: - // if its the last paragraph of the current environment - // skip it otherwise fall through - if (next_ - && (next_->layout() != layout() - || next_->params().depth() != params().depth())) - break; - // fall through possible - default: - // we don't need it for the last paragraph!!! - if (next_) { - os << '\n'; - texrow.newline(); - } - } - - if ((in == 0) || !in->forceDefaultParagraphs(in)) { - further_blank_line = false; - if (params().lineBottom()) { - os << "\\lyxline{\\" << font.latexSize() << '}'; - further_blank_line = true; - } - - if (params().spaceBottom().kind() != VSpace::NONE) { - os << params().spaceBottom().asLatexCommand(bparams); - further_blank_line = true; - } - - if (params().pagebreakBottom()) { - os << "\\newpage"; - further_blank_line = true; - } - - if (further_blank_line) { - os << '\n'; - texrow.newline(); - } - - if (!params().spacing().isDefault() - && (!next_ || !next_->hasSameLayout(this))) { - os << params().spacing().writeEnvirEnd() << "\n"; - texrow.newline(); - } - } + InsetList::const_iterator it = insetlist.begin(); + if (it != insetlist.end() && it->inset->lyxCode() == InsetOld::BIBTEX_CODE) + return static_cast(it->inset); + return 0; +} - // we don't need it for the last paragraph!!! - if (next_) { - os << '\n'; - texrow.newline(); - } else { - // Since \selectlanguage write the language to the aux file, - // we need to reset the language at the end of footnote or - // float. - - if (language->babel() != doc_language->babel()) { - if (lyxrc.language_command_end.empty()) - os << subst(lyxrc.language_command_begin, - "$$lang", - doc_language->babel()) - << endl; - else - os << subst(lyxrc.language_command_end, - "$$lang", - language->babel()) - << endl; - texrow.newline(); - } - } - lyxerr[Debug::LATEX] << "TeXOnePar...done " << next_ << endl; - return next_; -} // This could go to ParagraphParameters if we want to int Paragraph::startTeXParParams(BufferParams const & bparams, @@ -1401,6 +823,7 @@ int Paragraph::startTeXParParams(BufferParams const & bparams, return column; } + // This could go to ParagraphParameters if we want to int Paragraph::endTeXParParams(BufferParams const & bparams, ostream & os, bool moving_arg) const @@ -1459,8 +882,9 @@ int Paragraph::endTeXParParams(BufferParams const & bparams, // This one spits out the text of the paragraph bool Paragraph::simpleTeXOnePar(Buffer const * buf, BufferParams const & bparams, + LyXFont const & outerfont, ostream & os, TexRow & texrow, - bool moving_arg) + LatexRunParams const & runparams) { lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl; @@ -1484,22 +908,27 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, LyXFont basefont; // Maybe we have to create a optional argument. - pos_type main_body; - if (style->labeltype != LABEL_MANUAL) - main_body = 0; - else - main_body = beginningOfMainBody(); + pos_type body_pos; - int column = 0; + // FIXME: can we actually skip this check and just call + // beginningOfBody() ?? + if (style->labeltype != LABEL_MANUAL) { + body_pos = 0; + } else { + body_pos = beginningOfBody(); + } + + unsigned int column = 0; - if (main_body > 0) { + if (body_pos > 0) { os << '['; ++column; - basefont = getLabelFont(bparams); + basefont = getLabelFont(bparams, outerfont); } else { - basefont = getLayoutFont(bparams); + basefont = getLayoutFont(bparams, outerfont); } + bool moving_arg = runparams.moving_arg; moving_arg |= style->needprotect; // Which font is currently active? @@ -1507,7 +936,9 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, // Do we have an open font change? bool open_font = false; - texrow.start(this, 0); + Change::Type running_change = Change::UNCHANGED; + + texrow.start(id(), 0); // if the paragraph is empty, the loop will not be entered at all if (empty()) { @@ -1523,13 +954,13 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, for (pos_type i = 0; i < size(); ++i) { ++column; // First char in paragraph or after label? - if (i == main_body) { - if (main_body > 0) { + if (i == body_pos) { + if (body_pos > 0) { if (open_font) { column += running_font.latexWriteEndChanges(os, basefont, basefont); open_font = false; } - basefont = getLayoutFont(bparams); + basefont = getLayoutFont(bparams, outerfont); running_font = basefont; os << ']'; ++column; @@ -1547,7 +978,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, value_type c = getChar(i); // Fully instantiated font - LyXFont font = getFont(bparams, i); + LyXFont font = getFont(bparams, i, outerfont); LyXFont const last_font = running_font; @@ -1555,7 +986,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, // outside font change, i.e. we write "\textXX{text} " // rather than "\textXX{text }". (Asger) if (open_font && c == ' ' && i <= size() - 2) { - LyXFont const & next_font = getFont(bparams, i + 1); + LyXFont const & next_font = getFont(bparams, i + 1, outerfont); if (next_font != running_font && next_font != font) { font = next_font; @@ -1569,7 +1000,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, { column += running_font.latexWriteEndChanges(os, basefont, - (i == main_body-1) ? basefont : font); + (i == body_pos-1) ? basefont : font); running_font = basefont; open_font = false; } @@ -1577,7 +1008,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, // Blanks are printed before start of fontswitch if (c == ' ') { // Do not print the separation of the optional argument - if (i != main_body - 1) { + if (i != body_pos - 1) { pimpl_->simpleTeXBlanks(os, texrow, i, column, font, *style); } @@ -1586,7 +1017,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, // Do we need to change font? if ((font != running_font || font.language() != running_font.language()) && - i != main_body - 1) + i != body_pos - 1) { column += font.latexWriteStartChanges(os, basefont, last_font); @@ -1594,39 +1025,25 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, open_font = true; } - if (c == Paragraph::META_NEWLINE) { - // newlines are handled differently here than - // the default in SimpleTeXSpecialChars(). - if (!style->newline_allowed) { - os << '\n'; - } else { - if (open_font) { - column += running_font.latexWriteEndChanges(os, basefont, basefont); - open_font = false; - } - basefont = getLayoutFont(bparams); - running_font = basefont; - if (font.family() == - LyXFont::TYPEWRITER_FAMILY) { - os << "~"; - } - if (moving_arg) - os << "\\protect "; + Change::Type change = pimpl_->lookupChange(i); - os << "\\\\\n"; - } - texrow.newline(); - texrow.start(this, i + 1); - column = 0; - } else { - pimpl_->simpleTeXSpecialChars(buf, bparams, - os, texrow, moving_arg, - font, running_font, - basefont, open_font, - *style, i, column, c); - } + column += Changes::latexMarkChange(os, running_change, change); + running_change = change; + + LatexRunParams rp = runparams; + rp.moving_arg = moving_arg; + rp.free_spacing = style->free_spacing; + pimpl_->simpleTeXSpecialChars(buf, bparams, + os, texrow, runparams, + font, running_font, + basefont, outerfont, open_font, + running_change, + *style, i, column, c); } + column += Changes::latexMarkChange(os, + running_change, Change::UNCHANGED); + // If we have an open font definition, we have to close it if (open_font) { #ifdef FIXED_LANGUAGE_END_DETECTION @@ -1634,7 +1051,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, running_font .latexWriteEndChanges(os, basefont, next_->getFont(bparams, - 0)); + 0, outerfont)); } else { running_font.latexWriteEndChanges(os, basefont, basefont); @@ -1650,7 +1067,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, } // Needed if there is an optional argument but no contents. - if (main_body > 0 && main_body == size()) { + if (body_pos > 0 && body_pos == size()) { os << "]~"; return_value = false; } @@ -1664,111 +1081,12 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, } -Paragraph * Paragraph::TeXEnvironment(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow) -{ - lyxerr[Debug::LATEX] << "TeXEnvironment... " << this << endl; - - LyXLayout_ptr const & style = layout(); - - Language const * language = getParLanguage(bparams); - Language const * doc_language = bparams.language; - Language const * previous_language = previous_ - ? previous_->getParLanguage(bparams) : doc_language; - if (language->babel() != previous_language->babel()) { - - if (!lyxrc.language_command_end.empty() && - previous_language->babel() != doc_language->babel()) { - os << subst(lyxrc.language_command_end, "$$lang", - previous_language->babel()) - << endl; - texrow.newline(); - } - - if (lyxrc.language_command_end.empty() || - language->babel() != doc_language->babel()) { - os << subst(lyxrc.language_command_begin, "$$lang", - language->babel()) - << endl; - texrow.newline(); - } - } - - bool leftindent_open = false; - if (!params().leftIndent().zero()) { - os << "\\begin{LyXParagraphLeftIndent}{" << - params().leftIndent().asLatexString() << "}\n"; - texrow.newline(); - leftindent_open = true; - } - - if (style->isEnvironment()) { - if (style->latextype == LATEX_LIST_ENVIRONMENT) { - os << "\\begin{" << style->latexname() << "}{" - << params().labelWidthString() << "}\n"; - } else if (style->labeltype == LABEL_BIBLIO) { - // ale970405 - os << "\\begin{" << style->latexname() << "}{" - << bibitemWidest(buf) - << "}\n"; - } else if (style->latextype == LATEX_ITEM_ENVIRONMENT) { - os << "\\begin{" << style->latexname() << '}' - << style->latexparam() << '\n'; - } else - os << "\\begin{" << style->latexname() << '}' - << style->latexparam() << '\n'; - texrow.newline(); - } - Paragraph * par = this; - do { - par = par->TeXOnePar(buf, bparams, os, texrow, false); - - if (par && par->params().depth() > params().depth()) { - if (par->layout()->isParagraph()) { - - // Thinko! - // How to handle this? (Lgb) - //&& !suffixIs(os, "\n\n") - //) { - // There should be at least one '\n' already - // but we need there to be two for Standard - // paragraphs that are depth-increment'ed to be - // output correctly. However, tables can - // also be paragraphs so don't adjust them. - // ARRae - // Thinkee: - // Will it ever harm to have one '\n' too - // many? i.e. that we sometimes will have - // three in a row. (Lgb) - os << '\n'; - texrow.newline(); - } - par = par->pimpl_->TeXDeeper(buf, bparams, os, texrow); - } - } while (par - && par->layout() == layout() - && par->params().depth() == params().depth() - && par->params().leftIndent() == params().leftIndent()); - - if (style->isEnvironment()) { - os << "\\end{" << style->latexname() << "}\n"; - texrow.newline(); - } - - if (leftindent_open) { - os << "\\end{LyXParagraphLeftIndent}\n"; - texrow.newline(); - } - - lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl; - return par; // ale970302 -} bool Paragraph::isHfill(pos_type pos) const { - return IsHfillChar(getChar(pos)); + return IsInsetChar(getChar(pos)) + && getInset(pos)->lyxCode() == InsetOld::HFILL_CODE; } @@ -1780,7 +1098,8 @@ bool Paragraph::isInset(pos_type pos) const bool Paragraph::isNewline(pos_type pos) const { - return pos >= 0 && IsNewlineChar(getChar(pos)); + return IsInsetChar(getChar(pos)) + && getInset(pos)->lyxCode() == InsetOld::NEWLINE_CODE; } @@ -1828,22 +1147,10 @@ bool Paragraph::isWord(pos_type pos) const Language const * Paragraph::getParLanguage(BufferParams const & bparams) const { - if (!empty()) { -#ifndef INHERIT_LANGUAGE + if (!empty()) return getFirstFontSettings().language(); -#else - Language const * lang = getFirstFontSettings().language(); -#ifdef WITH_WARNINGS -#warning We should make this somewhat better, any ideas? (Jug) -#endif - if (lang == inherit_language || lang == ignore_language) - lang = bparams.language; - return lang; -#endif - } else if (previous_) - return previous_->getParLanguage(bparams); - else - return bparams.language; +#warning FIXME we should check the prev par as well (Lgb) + return bparams.language; } @@ -1852,12 +1159,12 @@ bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const return lyxrc.rtl_support && getParLanguage(bparams)->RightToLeft() && !(inInset() && inInset()->owner() && - inInset()->owner()->lyxCode() == Inset::ERT_CODE); + inInset()->owner()->lyxCode() == InsetOld::ERT_CODE); } void Paragraph::changeLanguage(BufferParams const & bparams, - Language const * from, Language const * to) + Language const * from, Language const * to) { for (pos_type i = 0; i < size(); ++i) { LyXFont font = getFontSettings(bparams, i); @@ -1878,9 +1185,6 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams) for (; cit != end; ++cit) if (cit->font().language() != ignore_language && cit->font().language() != latex_language && -#ifdef INHERIT_LANGUAGE - cit->font().language() != inherit_language && -#endif cit->font().language() != doc_language) return true; return false; @@ -1889,90 +1193,152 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams) // Convert the paragraph to a string. // Used for building the table of contents -string const Paragraph::asString(Buffer const * buffer, bool label) +string const Paragraph::asString(Buffer const * buffer, bool label) const { - BufferParams const & bparams = buffer->params; +#if 0 string s; if (label && !params().labelString().empty()) s += params().labelString() + ' '; - string::size_type const len = s.size(); for (pos_type i = 0; i < size(); ++i) { value_type c = getChar(i); if (IsPrintable(c)) s += c; else if (c == META_INSET && - getInset(i)->lyxCode() == Inset::MATH_CODE) { + getInset(i)->lyxCode() == InsetOld::MATH_CODE) { ostringstream ost; getInset(i)->ascii(buffer, ost); - s += subst(ost.str().c_str(),'\n',' '); + s += subst(STRCONV(ost.str()),'\n',' '); } } - if (isRightToLeftPar(bparams)) - reverse(s.begin() + len,s.end()); - return s; +#else + // This should really be done by the caller and not here. + string ret(asString(buffer, 0, size(), label)); + return subst(ret, '\n', ' '); +#endif } string const Paragraph::asString(Buffer const * buffer, - pos_type beg, pos_type end, bool label) + pos_type beg, pos_type end, bool label) const { - ostringstream ost; + ostringstream os; if (beg == 0 && label && !params().labelString().empty()) - ost << params().labelString() << ' '; + os << params().labelString() << ' '; for (pos_type i = beg; i < end; ++i) { value_type const c = getUChar(buffer->params, i); if (IsPrintable(c)) - ost << c; - else if (c == META_NEWLINE) - ost << '\n'; - else if (c == META_HFILL) - ost << '\t'; - else if (c == META_INSET) { - getInset(i)->ascii(buffer, ost); - } + os << c; + else if (c == META_INSET) + getInset(i)->ascii(buffer, os); } - return ost.str().c_str(); + return STRCONV(os.str()); } -void Paragraph::setInsetOwner(Inset * i) +void Paragraph::setInsetOwner(UpdatableInset * inset) { - pimpl_->inset_owner = i; + pimpl_->inset_owner = inset; InsetList::iterator it = insetlist.begin(); InsetList::iterator end = insetlist.end(); - for (; it != end; ++it) { - if (it.getInset()) - it.getInset()->setOwner(i); - } + for (; it != end; ++it) + if (it->inset) + it->inset->setOwner(inset); } void Paragraph::deleteInsetsLyXText(BufferView * bv) { - // then the insets insetlist.deleteInsetsLyXText(bv); } void Paragraph::resizeInsetsLyXText(BufferView * bv) { - // then the insets insetlist.resizeInsetsLyXText(bv); } -void Paragraph::setContentsFromPar(Paragraph * par) +void Paragraph::setContentsFromPar(Paragraph const & par) { pimpl_->setContentsFromPar(par); } +void Paragraph::trackChanges(Change::Type type) +{ + pimpl_->trackChanges(type); +} + + +void Paragraph::untrackChanges() +{ + pimpl_->untrackChanges(); +} + + +void Paragraph::cleanChanges() +{ + pimpl_->cleanChanges(); +} + + +Change::Type Paragraph::lookupChange(lyx::pos_type pos) const +{ + Assert(!size() || pos < size()); + return pimpl_->lookupChange(pos); +} + + +Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const +{ + Assert(!size() || pos < size()); + return pimpl_->lookupChangeFull(pos); +} + + +bool Paragraph::isChanged(pos_type start, pos_type end) const +{ + return pimpl_->isChanged(start, end); +} + + +bool Paragraph::isChangeEdited(pos_type start, pos_type end) const +{ + return pimpl_->isChangeEdited(start, end); +} + + +void Paragraph::setChange(lyx::pos_type pos, Change::Type type) +{ + pimpl_->setChange(pos, type); + +} + + +void Paragraph::markErased() +{ + pimpl_->markErased(); +} + + +void Paragraph::acceptChange(pos_type start, pos_type end) +{ + return pimpl_->acceptChange(start, end); +} + + +void Paragraph::rejectChange(pos_type start, pos_type end) +{ + return pimpl_->rejectChange(start, end); +} + + lyx::pos_type Paragraph::size() const { return pimpl_->size(); @@ -1997,28 +1363,30 @@ int Paragraph::id() const } -LyXLayout_ptr const & Paragraph::layout() const +void Paragraph::id(int i) { - return layout_; + pimpl_->id_ = i; } -void Paragraph::layout(LyXLayout_ptr const & new_layout) +LyXLayout_ptr const & Paragraph::layout() const { - layout_ = new_layout; +/* + InsetOld * inset = inInset(); + if (inset && inset->lyxCode() == InsetOld::ENVIRONMENT_CODE) + return static_cast(inset)->layout(); +*/ + return layout_; } -bool Paragraph::isFirstInSequence() const +void Paragraph::layout(LyXLayout_ptr const & new_layout) { - Paragraph const * dhook = depthHook(getDepth()); - return (dhook == this - || dhook->layout() != layout() - || dhook->getDepth() != getDepth()); + layout_ = new_layout; } -Inset * Paragraph::inInset() const +UpdatableInset * Paragraph::inInset() const { return pimpl_->inset_owner; } @@ -2047,23 +1415,31 @@ ParagraphParameters const & Paragraph::params() const } -Paragraph * Paragraph::getParFromID(int id) const +bool Paragraph::isFreeSpacing() const { - return pimpl_->getParFromID(id); + if (layout()->free_spacing) + return true; + + // for now we just need this, later should we need this in some + // other way we can always add a function to InsetOld::() too. + if (pimpl_->inset_owner && pimpl_->inset_owner->owner()) + return (pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE); + return false; } -bool Paragraph::isFreeSpacing() const +bool Paragraph::allowEmpty() const { - // for now we just need this, later should we need this in some - // other way we can always add a function to Inset::() too. + if (layout()->keepempty) + return true; if (pimpl_->inset_owner && pimpl_->inset_owner->owner()) - return (pimpl_->inset_owner->owner()->lyxCode() == Inset::ERT_CODE); + return (pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE); return false; } -Counters & Paragraph::counters() +bool operator==(Paragraph const & lhs, Paragraph const & rhs) { - return pimpl_->ctrs; +#warning FIXME this implementatoin must be completely wrong... + return &lhs == &rhs; }