X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=253a617e706b6fd1adebe28155fa42f6def03c15;hb=5c3d9a254640468e40b2d30467a26222c91d856d;hp=cd53424db695b26a1f22339537e81440744b52e6;hpb=83e37d57dd3228814360a46cb5487ed4fb50ee6c;p=lyx.git diff --git a/src/paragraph.C b/src/paragraph.C index cd53424db6..253a617e70 100644 --- a/src/paragraph.C +++ b/src/paragraph.C @@ -1,12 +1,19 @@ -/* This file is part of - * ====================================================== +/** + * \file paragraph.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Asger Alstrup + * \author Lars Gullik Bjønnes + * \author Jean-Marc Lasgouttes + * \author Angus Leeming + * \author John Levon + * \author André Pönitz + * \author Dekel Tsur + * \author Jürgen Vigna * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. - * - * ====================================================== */ + * Full author contact details are available in file CREDITS. + */ #include @@ -15,89 +22,89 @@ #include "buffer.h" #include "bufferparams.h" -#include "BufferView.h" -#include "changes.h" #include "encoding.h" #include "debug.h" #include "gettext.h" #include "language.h" #include "latexrunparams.h" -#include "layout.h" +#include "lyxfont.h" #include "lyxrc.h" -#include "paragraph_funcs.h" -#include "ParameterStruct.h" +#include "lyxrow.h" #include "texrow.h" - -#include "Lsstream.h" +#include "vspace.h" #include "insets/insetbibitem.h" #include "insets/insetoptarg.h" -#include "insets/insetenv.h" -#include "support/filetools.h" #include "support/lstrings.h" -#include "support/lyxmanip.h" -#include "support/FileInfo.h" -#include "support/LAssert.h" #include "support/textutils.h" - -#include -#include -#include -#include - -using std::ostream; -using std::endl; -using std::fstream; -using std::ios; -using std::lower_bound; -using std::upper_bound; +#include "support/std_sstream.h" using lyx::pos_type; +using lyx::support::contains; +using lyx::support::subst; -// this is a minibuffer - -namespace { - -char minibuffer_char; -LyXFont minibuffer_font; -Inset * minibuffer_inset; - -} // namespace anon +using std::endl; +using std::string; +using std::ostream; +using std::ostringstream; Paragraph::Paragraph() - : pimpl_(new Paragraph::Pimpl(this)) + : y(0), height(0), pimpl_(new Paragraph::Pimpl(this)) { - enumdepth = 0; itemdepth = 0; params().clear(); } Paragraph::Paragraph(Paragraph const & lp) - : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this)) + : y(0), height(0), text_(lp.text_), 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(); - buffer_ = lp.buffer_; // 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) { - it->inset = it->inset->clone(**buffer_); - // tell the new inset who is the boss now - it->inset->parOwner(this); + // currently we hold Inset*, not InsetBase* + it->inset = static_cast(it->inset->clone().release()); } } +void Paragraph::operator=(Paragraph const & lp) +{ + // needed as we will destroy the pimpl_ before copying it + if (&lp != this) + return; + + lyxerr << "Paragraph::operator=()" << endl; + + text_ = lp.text_; + + delete pimpl_; + pimpl_ = new Pimpl(*lp.pimpl_, this); + + itemdepth = lp.itemdepth; + // this is because of the dummy layout of the paragraphs that + // follow footnotes + layout_ = lp.layout(); + + // 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) { + it->inset = static_cast(it->inset->clone().release()); + } +} + // the destructor removes the new paragraph from the list Paragraph::~Paragraph() { @@ -108,7 +115,7 @@ Paragraph::~Paragraph() } -void Paragraph::write(Buffer const * buf, ostream & os, +void Paragraph::write(Buffer const & buf, ostream & os, BufferParams const & bparams, depth_type & dth) const { @@ -128,7 +135,7 @@ void Paragraph::write(Buffer const * buf, ostream & os, } // First write the layout - os << "\n\\layout " << layout()->name() << '\n'; + os << "\n\\begin_layout " << layout()->name() << '\n'; params().write(os); @@ -160,7 +167,7 @@ void Paragraph::write(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 @@ -212,6 +219,8 @@ void Paragraph::write(Buffer const * buf, ostream & os, } Changes::lyxMarkChange(os, column, curtime, running_change, Change(Change::UNCHANGED)); + + os << "\n\\end_layout\n"; } @@ -221,68 +230,6 @@ void Paragraph::validate(LaTeXFeatures & features) const } -// First few functions needed for cut and paste and paragraph breaking. -void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const -{ - BufferParams bparams = buffer.params; - - minibuffer_char = getChar(pos); - minibuffer_font = getFontSettings(bparams, pos); - minibuffer_inset = 0; - if (minibuffer_char == Paragraph::META_INSET) { - if (getInset(pos)) { - minibuffer_inset = getInset(pos)->clone(buffer); - } else { - minibuffer_inset = 0; - minibuffer_char = ' '; - // This reflects what GetInset() does (ARRae) - } - } -} - - -void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos) -{ - minibuffer_char = getChar(pos); - minibuffer_font = getFontSettings(bparams, pos); - minibuffer_inset = 0; - if (minibuffer_char == Paragraph::META_INSET) { - if (getInset(pos)) { - // 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())) { - return false; - } - insertInset(pos, minibuffer_inset, minibuffer_font); - } else { - LyXFont f = minibuffer_font; - if (!checkInsertChar(f)) { - return false; - } - insertChar(pos, minibuffer_char, f); - } - return true; -} - -// end of minibuffer - - void Paragraph::eraseIntern(lyx::pos_type pos) { pimpl_->eraseIntern(pos); @@ -311,8 +258,7 @@ 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)); } @@ -323,20 +269,20 @@ void Paragraph::insertChar(pos_type pos, Paragraph::value_type c, } -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, Change change) +void Paragraph::insertInset(pos_type pos, InsetOld * inset, + LyXFont const & font, Change change) { 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) @@ -345,16 +291,16 @@ bool Paragraph::insetAllowed(Inset::Code code) } -Inset * Paragraph::getInset(pos_type pos) +InsetOld * Paragraph::getInset(pos_type pos) { - lyx::Assert(pos < size()); + BOOST_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()); + BOOST_ASSERT(pos < size()); return insetlist.get(pos); } @@ -363,24 +309,38 @@ Inset const * Paragraph::getInset(pos_type pos) const LyXFont const Paragraph::getFontSettings(BufferParams const & bparams, pos_type pos) const { - lyx::Assert(pos <= size()); + BOOST_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)); + return cit->font(); + + if (pos == size() && !empty()) + return getFontSettings(bparams, pos - 1); - return retfont; + return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams)); +} + + +lyx::pos_type Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const +{ + BOOST_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(); + + // This should not happen, but if so, we take no chances. + //lyxerr << "Paragraph::getEndPosOfFontSpan: This should not happen!" + // << endl; + return pos; } @@ -402,7 +362,7 @@ LyXFont const Paragraph::getFirstFontSettings() const LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos, LyXFont const & outerfont) const { - lyx::Assert(pos >= 0); + BOOST_ASSERT(pos >= 0); LyXLayout_ptr const & lout = layout(); @@ -414,44 +374,41 @@ LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos, else layoutfont = lout->font; - LyXFont tmpfont = getFontSettings(bparams, pos); - tmpfont.realize(layoutfont); - tmpfont.realize(outerfont); + LyXFont font = getFontSettings(bparams, pos); + font.realize(layoutfont); + font.realize(outerfont); + font.realize(bparams.getLyXTextClass().defaultfont()); - return realizeFont(tmpfont, bparams); + return font; } 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)); tmpfont.realize(outerfont); - - return realizeFont(tmpfont, bparams); + tmpfont.realize(bparams.getLyXTextClass().defaultfont()); + return tmpfont; } 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)); tmpfont.realize(outerfont); - - return realizeFont(tmpfont, bparams); + tmpfont.realize(bparams.getLyXTextClass().defaultfont()); + return tmpfont; } /// Returns the height of the highest font in range -LyXFont::FONT_SIZE +LyXFont_size Paragraph::highestFontInRange(pos_type startpos, pos_type endpos, - LyXFont::FONT_SIZE const def_size) const + LyXFont_size def_size) const { if (pimpl_->fontlist.empty()) return def_size; @@ -527,10 +484,10 @@ Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const void Paragraph::setFont(pos_type pos, LyXFont const & font) { - lyx::Assert(pos <= size()); + BOOST_ASSERT(pos <= size()); // First, reduce font against layout/label font - // Update: The SetCharFont() routine in text2.C already + // Update: The setCharFont() routine in text2.C already // reduces font, so we don't need to do that here. (Asger) // No need to simplify this because it will disappear // in a new kernel. (Asger) @@ -598,7 +555,7 @@ void Paragraph::makeSameLayout(Paragraph const & par) int Paragraph::stripLeadingSpaces() { - if (layout()->free_spacing || isFreeSpacing()) + if (isFreeSpacing()) return 0; int i = 0; @@ -680,7 +637,7 @@ int Paragraph::beginningOfBody() const // Unroll the first two cycles of the loop // and remember the previous character to - // remove unnecessary GetChar() calls + // remove unnecessary getChar() calls pos_type i = 0; if (i < size() && !isNewline(i)) { ++i; @@ -707,7 +664,7 @@ int Paragraph::beginningOfBody() const // returns -1 if inset not found -int Paragraph::getPositionOfInset(Inset const * inset) const +int Paragraph::getPositionOfInset(InsetOld const * inset) const { // Find the entry. InsetList::const_iterator it = insetlist.begin(); @@ -722,12 +679,53 @@ int Paragraph::getPositionOfInset(Inset const * inset) const InsetBibitem * Paragraph::bibitem() const { InsetList::const_iterator it = insetlist.begin(); - if (it != insetlist.end() && it->inset->lyxCode() == Inset::BIBTEX_CODE) + if (it != insetlist.end() && it->inset->lyxCode() == InsetOld::BIBTEX_CODE) return static_cast(it->inset); return 0; } +namespace { + +/* paragraphs inside floats need different alignment tags to avoid +unwanted space */ + +bool noTrivlistCentering(UpdatableInset const * inset) +{ + if (inset && inset->owner()) { + InsetOld::Code const code = inset->owner()->lyxCode(); + return code == InsetOld::FLOAT_CODE || + code == InsetOld::WRAP_CODE; + } + return false; +} + + +string correction(string const & orig) +{ + if (orig == "flushleft") + return "raggedright"; + if (orig == "flushright") + return "raggedleft"; + if (orig == "center") + return "centering"; + return orig; +} + + +string const corrected_env(string const & suffix, string const & env, + UpdatableInset const * inset) +{ + string output = suffix + "{"; + if (noTrivlistCentering(inset)) + output += correction(env); + else + output += env; + return output + "}"; +} + +} // namespace anon + // This could go to ParagraphParameters if we want to int Paragraph::startTeXParParams(BufferParams const & bparams, @@ -762,29 +760,34 @@ int Paragraph::startTeXParParams(BufferParams const & bparams, case LYX_ALIGN_LAYOUT: case LYX_ALIGN_SPECIAL: break; - case LYX_ALIGN_LEFT: - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\begin{flushleft}"; - column += 17; - } else { - os << "\\begin{flushright}"; - column += 18; - } + case LYX_ALIGN_LEFT: { + string output; + UpdatableInset const * const inset = pimpl_->inset_owner; + if (getParLanguage(bparams)->babel() != "hebrew") + output = corrected_env("\\begin", "flushleft", inset); + else + output = corrected_env("\\begin", "flushright", inset); + os << output; + column += output.size(); break; - case LYX_ALIGN_RIGHT: - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\begin{flushright}"; - column += 18; - } else { - os << "\\begin{flushleft}"; - column += 17; - } + } case LYX_ALIGN_RIGHT: { + string output; + UpdatableInset const * const inset = pimpl_->inset_owner; + if (getParLanguage(bparams)->babel() != "hebrew") + output = corrected_env("\\begin", "flushright", inset); + else + output = corrected_env("\\begin", "flushleft", inset); + os << output; + column += output.size(); break; - case LYX_ALIGN_CENTER: - os << "\\begin{center}"; - column += 14; + } case LYX_ALIGN_CENTER: { + string output; + output = corrected_env("\\begin", "center", pimpl_->inset_owner); + os << output; + column += output.size(); break; } + } return column; } @@ -818,35 +821,41 @@ int Paragraph::endTeXParParams(BufferParams const & bparams, case LYX_ALIGN_LAYOUT: case LYX_ALIGN_SPECIAL: break; - case LYX_ALIGN_LEFT: - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\end{flushleft}"; - column = 15; - } else { - os << "\\end{flushright}"; - column = 16; - } + case LYX_ALIGN_LEFT: { + string output; + UpdatableInset const * const inset = pimpl_->inset_owner; + if (getParLanguage(bparams)->babel() != "hebrew") + output = corrected_env("\\par\\end", "flushleft", inset); + else + output = corrected_env("\\par\\end", "flushright", inset); + os << output; + column += output.size(); break; - case LYX_ALIGN_RIGHT: - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\end{flushright}"; - column+= 16; - } else { - os << "\\end{flushleft}"; - column = 15; - } + } case LYX_ALIGN_RIGHT: { + string output; + UpdatableInset const * const inset = pimpl_->inset_owner; + if (getParLanguage(bparams)->babel() != "hebrew") + output = corrected_env("\\par\\end", "flushright", inset); + else + output = corrected_env("\\par\\end", "flushleft", inset); + os << output; + column += output.size(); break; - case LYX_ALIGN_CENTER: - os << "\\end{center}"; - column = 12; + } case LYX_ALIGN_CENTER: { + string output; + output = corrected_env("\\par\\end", "center", pimpl_->inset_owner); + os << output; + column += output.size(); break; } + } + return column; } // This one spits out the text of the paragraph -bool Paragraph::simpleTeXOnePar(Buffer const * buf, +bool Paragraph::simpleTeXOnePar(Buffer const & buf, BufferParams const & bparams, LyXFont const & outerfont, ostream & os, TexRow & texrow, @@ -859,7 +868,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, 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 + // length (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! bool asdefault = @@ -1047,12 +1056,23 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, } +namespace { + +/// return true if the char is a meta-character for an inset +inline +bool IsInsetChar(char c) +{ + return (c == Paragraph::META_INSET); +} + +} // namespace anon + bool Paragraph::isHfill(pos_type pos) const { return IsInsetChar(getChar(pos)) - && getInset(pos)->lyxCode() == Inset::HFILL_CODE; + && getInset(pos)->lyxCode() == InsetOld::HFILL_CODE; } @@ -1065,7 +1085,7 @@ bool Paragraph::isInset(pos_type pos) const bool Paragraph::isNewline(pos_type pos) const { return IsInsetChar(getChar(pos)) - && getInset(pos)->lyxCode() == Inset::NEWLINE_CODE; + && getInset(pos)->lyxCode() == InsetOld::NEWLINE_CODE; } @@ -1106,22 +1126,20 @@ bool Paragraph::isLetter(pos_type pos) const bool Paragraph::isWord(pos_type pos) const { - return IsWordChar(getChar(pos)) ; + unsigned char const c = getChar(pos); + return !(IsSeparatorChar(c) + || IsKommaChar(c) + || IsInsetChar(c)); } Language const * Paragraph::getParLanguage(BufferParams const & bparams) const { - if (!empty()) { + if (!empty()) return getFirstFontSettings().language(); #warning FIXME we should check the prev par as well (Lgb) -#if 0 - } else if (previous_) { - return previous_->getParLanguage(bparams); -#endif - }else - return bparams.language; + return bparams.language; } @@ -1130,7 +1148,7 @@ 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); } @@ -1156,7 +1174,7 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams) for (; cit != end; ++cit) if (cit->font().language() != ignore_language && cit->font().language() != latex_language && - cit->font().language() != doc_language) + cit->font().language() != doc_language) return true; return false; } @@ -1164,8 +1182,9 @@ 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) const +string const Paragraph::asString(Buffer const & buffer, bool label) const { +#if 0 string s; if (label && !params().labelString().empty()) s += params().labelString() + ' '; @@ -1175,7 +1194,7 @@ string const Paragraph::asString(Buffer const * buffer, bool label) const 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(STRCONV(ost.str()),'\n',' '); @@ -1183,10 +1202,15 @@ string const Paragraph::asString(Buffer const * buffer, bool label) const } 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, +string const Paragraph::asString(Buffer const & buffer, pos_type beg, pos_type end, bool label) const { ostringstream os; @@ -1195,42 +1219,34 @@ string const Paragraph::asString(Buffer const * buffer, os << params().labelString() << ' '; for (pos_type i = beg; i < end; ++i) { - value_type const c = getUChar(buffer->params, i); + value_type const c = getUChar(buffer.params(), i); if (IsPrintable(c)) os << c; else if (c == META_INSET) getInset(i)->ascii(buffer, os); } - return STRCONV(os.str()); + return 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->inset) - it->inset->setOwner(i); + 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 const & par) { pimpl_->setContentsFromPar(par); @@ -1257,14 +1273,14 @@ void Paragraph::cleanChanges() Change::Type Paragraph::lookupChange(lyx::pos_type pos) const { - lyx::Assert(!size() || pos < size()); + BOOST_ASSERT(!size() || pos < size()); return pimpl_->lookupChange(pos); } Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const { - lyx::Assert(!size() || pos < size()); + BOOST_ASSERT(!size() || pos < size()); return pimpl_->lookupChangeFull(pos); } @@ -1306,21 +1322,21 @@ void Paragraph::rejectChange(pos_type start, pos_type end) } -lyx::pos_type Paragraph::size() const +Paragraph::value_type Paragraph::getChar(pos_type pos) const { - return pimpl_->size(); -} - + // This is in the critical path! + pos_type const siz = text_.size(); -bool Paragraph::empty() const -{ - return pimpl_->empty(); -} + BOOST_ASSERT(pos <= siz); + if (pos == siz) { + lyxerr << "getChar() on pos " << pos << " in par id " + << id() << " of size " << siz + << " is a bit silly !" << endl; + return '\0'; + } -Paragraph::value_type Paragraph::getChar(pos_type pos) const -{ - return pimpl_->getChar(pos); + return text_[pos]; } @@ -1338,9 +1354,11 @@ void Paragraph::id(int i) LyXLayout_ptr const & Paragraph::layout() const { - Inset * inset = inInset(); - if (inset && inset->lyxCode() == Inset::ENVIRONMENT_CODE) +/* + InsetOld * inset = inInset(); + if (inset && inset->lyxCode() == InsetOld::ENVIRONMENT_CODE) return static_cast(inset)->layout(); +*/ return layout_; } @@ -1351,7 +1369,7 @@ void Paragraph::layout(LyXLayout_ptr const & new_layout) } -Inset * Paragraph::inInset() const +UpdatableInset * Paragraph::inInset() const { return pimpl_->inset_owner; } @@ -1359,12 +1377,13 @@ Inset * Paragraph::inInset() const void Paragraph::clearContents() { - pimpl_->clear(); + text_.clear(); } + void Paragraph::setChar(pos_type pos, value_type c) { - pimpl_->setChar(pos, c); + text_[pos] = c; } @@ -1382,16 +1401,22 @@ ParagraphParameters const & Paragraph::params() const bool Paragraph::isFreeSpacing() const { + 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 Inset::() too. + // 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() == Inset::ERT_CODE); + return pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE; return false; } -bool operator==(Paragraph const & lhs, Paragraph const & rhs) +bool Paragraph::allowEmpty() const { -#warning FIXME this implementatoin must be completely wrong... - return &lhs == &rhs; + if (layout()->keepempty) + return true; + if (pimpl_->inset_owner && pimpl_->inset_owner->owner()) + return pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE; + return false; }