X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FParagraph.cpp;h=e26f70f4bce4ca04754af67565dd6263acd09e30;hb=3f7d2a66f522a45583e0a8b0ba734bb71f0ddde0;hp=b5f31281f4da9ee0dff6d11b8825bdb8a68a63f1;hpb=b546fff555bf15f01f7ab2eb9a8f7338f7d6b1a8;p=lyx.git diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp index b5f31281f4..e26f70f4bc 100644 --- a/src/Paragraph.cpp +++ b/src/Paragraph.cpp @@ -19,6 +19,7 @@ #include "Paragraph.h" +#include "LayoutFile.h" #include "Buffer.h" #include "BufferParams.h" #include "Changes.h" @@ -39,10 +40,11 @@ #include "sgml.h" #include "TextClass.h" #include "TexRow.h" +#include "Text.h" #include "VSpace.h" +#include "WordList.h" #include "frontends/alert.h" -#include "frontends/FontMetrics.h" #include "insets/InsetBibitem.h" #include "insets/InsetLabel.h" @@ -77,7 +79,7 @@ class Paragraph::Private { public: /// - Private(Paragraph * owner); + Private(Paragraph * owner, Layout const & layout); /// "Copy constructor" Private(Private const &, Paragraph * owner); @@ -114,7 +116,7 @@ public: bool) const; /// - void latexInset(Buffer const &, BufferParams const &, + void latexInset(BufferParams const &, odocstream &, TexRow & texrow, OutputParams &, Font & running_font, @@ -188,15 +190,18 @@ public: /// InsetList insetlist_; - /// - LayoutPtr layout_; - /// end of label pos_type begin_of_body_; typedef docstring TextContainer; /// TextContainer text_; + + typedef std::set Words; + /// + Words words_; + /// + Layout const * layout_; }; @@ -223,8 +228,8 @@ size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase); } // namespace anon -Paragraph::Private::Private(Paragraph * owner) - : owner_(owner), inset_owner_(0), begin_of_body_(0) +Paragraph::Private::Private(Paragraph * owner, Layout const & layout) + : owner_(owner), inset_owner_(0), begin_of_body_(0), layout_(&layout) { id_ = paragraph_id++; text_.reserve(100); @@ -234,7 +239,8 @@ Paragraph::Private::Private(Paragraph * owner) Paragraph::Private::Private(Private const & p, Paragraph * owner) : owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_), params_(p.params_), changes_(p.changes_), insetlist_(p.insetlist_), - layout_(p.layout_), begin_of_body_(p.begin_of_body_), text_(p.text_) + begin_of_body_(p.begin_of_body_), text_(p.text_), words_(p.words_), + layout_(p.layout_) { id_ = paragraph_id++; } @@ -626,7 +632,7 @@ bool Paragraph::Private::isTextAt(string const & str, pos_type pos) const } -void Paragraph::Private::latexInset(Buffer const & buf, +void Paragraph::Private::latexInset( BufferParams const & bparams, odocstream & os, TexRow & texrow, @@ -644,7 +650,7 @@ void Paragraph::Private::latexInset(Buffer const & buf, BOOST_ASSERT(inset); if (style.pass_thru) { - inset->plaintext(buf, os, runparams); + inset->plaintext(os, runparams); return; } @@ -737,7 +743,7 @@ void Paragraph::Private::latexInset(Buffer const & buf, } } - int tmp = inset->latex(buf, os, runparams); + int tmp = inset->latex(os, runparams); if (close) { if (running_font.language()->lang() == "farsi") @@ -1028,8 +1034,12 @@ void Paragraph::Private::validate(LaTeXFeatures & features, // ///////////////////////////////////////////////////////////////////// -Paragraph::Paragraph() - : d(new Paragraph::Private(this)) +namespace { + Layout const emptyParagraphLayout; +} + +Paragraph::Paragraph() + : d(new Paragraph::Private(this, emptyParagraphLayout)) { itemdepth = 0; d->params_.clear(); @@ -1040,6 +1050,7 @@ Paragraph::Paragraph(Paragraph const & par) : itemdepth(par.itemdepth), d(new Paragraph::Private(*par.d, this)) { + registerWords(); } @@ -1049,8 +1060,10 @@ Paragraph & Paragraph::operator=(Paragraph const & par) if (&par != this) { itemdepth = par.itemdepth; + deregisterWords(); delete d; d = new Private(*par.d, this); + registerWords(); } return *this; } @@ -1058,23 +1071,23 @@ Paragraph & Paragraph::operator=(Paragraph const & par) Paragraph::~Paragraph() { + deregisterWords(); delete d; } -void Paragraph::write(Buffer const & buf, ostream & os, - BufferParams const & bparams, - depth_type & dth) const +void Paragraph::write(ostream & os, BufferParams const & bparams, + depth_type & dth) const { // The beginning or end of a deeper (i.e. nested) area? - if (dth != params().depth()) { - if (params().depth() > dth) { - while (params().depth() > dth) { + if (dth != d->params_.depth()) { + if (d->params_.depth() > dth) { + while (d->params_.depth() > dth) { os << "\n\\begin_deeper"; ++dth; } } else { - while (params().depth() < dth) { + while (d->params_.depth() < dth) { os << "\n\\end_deeper"; --dth; } @@ -1082,9 +1095,9 @@ void Paragraph::write(Buffer const & buf, ostream & os, } // First write the layout - os << "\n\\begin_layout " << to_utf8(layout()->name()) << '\n'; + os << "\n\\begin_layout " << to_utf8(d->layout_->name()) << '\n'; - params().write(os); + d->params_.write(os); Font font1(inherit_font, bparams.language); @@ -1116,12 +1129,12 @@ void Paragraph::write(Buffer const & buf, ostream & os, // international char, let it write // code directly so it's shorter in // the file - inset->write(buf, os); + inset->write(os); } else { if (i) os << '\n'; os << "\\begin_inset "; - inset->write(buf, os); + inset->write(os); os << "\n\\end_inset\n\n"; column = 0; } @@ -1162,7 +1175,7 @@ void Paragraph::write(Buffer const & buf, ostream & os, void Paragraph::validate(LaTeXFeatures & features) const { - d->validate(features, *layout()); + d->validate(features, *d->layout_); } @@ -1340,7 +1353,7 @@ Font const Paragraph::getFont(BufferParams const & bparams, pos_type pos, Font const Paragraph::getLabelFont (BufferParams const & bparams, Font const & outerfont) const { - FontInfo tmpfont = layout()->labelfont; + FontInfo tmpfont = d->layout_->labelfont; tmpfont.realize(outerfont.fontInfo()); tmpfont.realize(bparams.getFont().fontInfo()); return Font(tmpfont, getParLanguage(bparams)); @@ -1350,7 +1363,7 @@ Font const Paragraph::getLabelFont Font const Paragraph::getLayoutFont (BufferParams const & bparams, Font const & outerfont) const { - FontInfo tmpfont = layout()->font; + FontInfo tmpfont = d->layout_->font; tmpfont.realize(outerfont.fontInfo()); tmpfont.realize(bparams.getFont().fontInfo()); return Font(tmpfont, getParLanguage(bparams)); @@ -1420,9 +1433,8 @@ void Paragraph::setFont(pos_type pos, Font const & font) void Paragraph::makeSameLayout(Paragraph const & par) { - layout(par.layout()); - // move to pimpl? - d->params_ = par.params(); + d->layout_ = par.d->layout_; + d->params_ = par.d->params_; } @@ -1447,45 +1459,46 @@ bool Paragraph::stripLeadingSpaces(bool trackChanges) bool Paragraph::hasSameLayout(Paragraph const & par) const { - return par.layout() == layout() && d->params_.sameLayout(par.params()); + return par.d->layout_ == d->layout_ + && d->params_.sameLayout(par.d->params_); } depth_type Paragraph::getDepth() const { - return params().depth(); + return d->params_.depth(); } depth_type Paragraph::getMaxDepthAfter() const { - if (layout()->isEnvironment()) - return params().depth() + 1; + if (d->layout_->isEnvironment()) + return d->params_.depth() + 1; else - return params().depth(); + return d->params_.depth(); } char Paragraph::getAlign() const { - if (params().align() == LYX_ALIGN_LAYOUT) - return layout()->align; + if (d->params_.align() == LYX_ALIGN_LAYOUT) + return d->layout_->align; else - return params().align(); + return d->params_.align(); } -docstring const & Paragraph::getLabelstring() const +docstring const & Paragraph::labelString() const { - return params().labelString(); + return d->params_.labelString(); } // the next two functions are for the manual labels docstring const Paragraph::getLabelWidthString() const { - if (layout()->margintype == MARGIN_MANUAL) - return params().labelWidthString(); + if (d->layout_->margintype == MARGIN_MANUAL) + return d->params_.labelWidthString(); else return _("Senseless with this layout!"); } @@ -1493,7 +1506,7 @@ docstring const Paragraph::getLabelWidthString() const void Paragraph::setLabelWidthString(docstring const & s) { - params().labelWidthString(s); + d->params_.labelWidthString(s); } @@ -1511,21 +1524,21 @@ docstring const Paragraph::translateIfPossible(docstring const & s, } -docstring Paragraph::expandLabel(LayoutPtr const & layout, +docstring Paragraph::expandLabel(Layout const & layout, BufferParams const & bparams, bool process_appendix) const { - TextClass const & tclass = bparams.getTextClass(); + DocumentClass const & tclass = bparams.documentClass(); docstring fmt; - if (process_appendix && params().appendix()) - fmt = translateIfPossible(layout->labelstring_appendix(), + if (process_appendix && d->params_.appendix()) + fmt = translateIfPossible(layout.labelstring_appendix(), bparams); else - fmt = translateIfPossible(layout->labelstring(), bparams); + fmt = translateIfPossible(layout.labelstring(), bparams); - if (fmt.empty() && layout->labeltype == LABEL_COUNTER - && !layout->counter.empty()) - fmt = "\\the" + layout->counter; + if (fmt.empty() && layout.labeltype == LABEL_COUNTER + && !layout.counter.empty()) + fmt = "\\the" + layout.counter; // handle 'inherited level parts' in 'fmt', // i.e. the stuff between '@' in '@Section@.\arabic{subsection}' @@ -1547,15 +1560,15 @@ docstring Paragraph::expandLabel(LayoutPtr const & layout, } -void Paragraph::applyLayout(LayoutPtr const & new_layout) +void Paragraph::applyLayout(Layout const & new_layout) { - layout(new_layout); - LyXAlignment const oldAlign = params().align(); + d->layout_ = &new_layout; + LyXAlignment const oldAlign = d->params_.align(); - if (!(oldAlign & layout()->alignpossible)) { + if (!(oldAlign & d->layout_->alignpossible)) { frontend::Alert::warning(_("Alignment not permitted"), _("The new layout does not permit the alignment previously used.\nSetting to default.")); - params().align(LYX_ALIGN_LAYOUT); + d->params_.align(LYX_ALIGN_LAYOUT); } } @@ -1568,7 +1581,7 @@ pos_type Paragraph::beginOfBody() const void Paragraph::setBeginOfBody() { - if (layout()->labeltype != LABEL_MANUAL) { + if (d->layout_->labeltype != LABEL_MANUAL) { d->begin_of_body_ = 0; return; } @@ -1601,9 +1614,21 @@ void Paragraph::setBeginOfBody() } -bool Paragraph::forceDefaultParagraphs() const +bool Paragraph::forceEmptyLayout() const +{ + return inInset() && inInset()->forceEmptyLayout(); +} + + +bool Paragraph::allowParagraphCustomization() const { - return inInset() && inInset()->forceDefaultParagraphs(0); + return inInset() && inInset()->allowParagraphCustomization(0); +} + + +bool Paragraph::useEmptyLayout() const +{ + return inInset() && inInset()->useEmptyLayout(); } @@ -1788,8 +1813,7 @@ int Paragraph::Private::endTeXParParams(BufferParams const & bparams, // This one spits out the text of the paragraph -bool Paragraph::latex(Buffer const & buf, - BufferParams const & bparams, +bool Paragraph::latex(BufferParams const & bparams, Font const & outerfont, odocstream & os, TexRow & texrow, OutputParams const & runparams) const @@ -1798,20 +1822,11 @@ bool Paragraph::latex(Buffer const & buf, bool return_value = false; - LayoutPtr style; + bool asdefault = forceEmptyLayout(); - // well we have to check if we are in an inset with unlimited - // 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 than the default layout of the text class - // to be valid! - bool asdefault = forceDefaultParagraphs(); - - if (asdefault) { - style = bparams.getTextClass().defaultLayout(); - } else { - style = layout(); - } + Layout const & style = asdefault ? + bparams.documentClass().emptyLayout() : + *d->layout_; // Current base font for all inherited font changes, without any // change caused by an individual character, except for the language: @@ -1846,7 +1861,7 @@ bool Paragraph::latex(Buffer const & buf, // if the paragraph is empty, the loop will not be entered at all if (empty()) { - if (style->isCommand()) { + if (style.isCommand()) { os << '{'; ++column; } @@ -1875,7 +1890,7 @@ bool Paragraph::latex(Buffer const & buf, os << "}] "; column +=3; } - if (style->isCommand()) { + if (style.isCommand()) { os << '{'; ++column; } @@ -1975,13 +1990,13 @@ bool Paragraph::latex(Buffer const & buf, if (c == ' ') { // FIXME: integrate this case in latexSpecialChar // Do not print the separation of the optional argument - // if style->pass_thru is false. This works because + // if style.pass_thru is false. This works because // latexSpecialChar ignores spaces if - // style->pass_thru is false. + // style.pass_thru is false. if (i != body_pos - 1) { if (d->simpleTeXBlanks( runparams, os, texrow, - i, column, font, *style)) { + i, column, font, style)) { // A surrogate pair was output. We // must not call latexSpecialChar // in this iteration, since it would output @@ -1993,22 +2008,22 @@ bool Paragraph::latex(Buffer const & buf, } OutputParams rp = runparams; - rp.free_spacing = style->free_spacing; + rp.free_spacing = style.free_spacing; rp.local_font = &font; - rp.intitle = style->intitle; + rp.intitle = style.intitle; // Two major modes: LaTeX or plain // Handle here those cases common to both modes // and then split to handle the two modes separately. if (c == META_INSET) - d->latexInset(buf, bparams, os, + d->latexInset(bparams, os, texrow, rp, running_font, basefont, outerfont, open_font, - runningChange, *style, i, column); + runningChange, style, i, column); else { try { d->latexSpecialChar(os, rp, running_font, runningChange, - *style, i, column); + style, i, column); } catch (EncodingException & e) { if (runparams.dryrun) { os << "<" << _("LyX Warning: ") @@ -2092,7 +2107,8 @@ bool Paragraph::emptyTag() const } -string Paragraph::getID(Buffer const & buf, OutputParams const & runparams) const +string Paragraph::getID(Buffer const & buf, OutputParams const & runparams) + const { for (pos_type i = 0; i < size(); ++i) { if (Inset const * inset = getInset(i)) { @@ -2108,12 +2124,13 @@ string Paragraph::getID(Buffer const & buf, OutputParams const & runparams) cons } -pos_type Paragraph::getFirstWord(Buffer const & buf, odocstream & os, OutputParams const & runparams) const +pos_type Paragraph::firstWord(odocstream & os, OutputParams const & runparams) + const { pos_type i; for (i = 0; i < size(); ++i) { if (Inset const * inset = getInset(i)) { - inset->docbook(buf, os, runparams); + inset->docbook(os, runparams); } else { char_type c = d->text_[i]; if (c == ' ') @@ -2150,11 +2167,11 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf, { bool emph_flag = false; - LayoutPtr const & style = layout(); + Layout const & style = *d->layout_; FontInfo font_old = - style->labeltype == LABEL_MANUAL ? style->labelfont : style->font; + style.labeltype == LABEL_MANUAL ? style.labelfont : style.font; - if (style->pass_thru && !d->onlyText(buf, outerfont, initial)) + if (style.pass_thru && !d->onlyText(buf, outerfont, initial)) os << "]]>"; // parsing main loop @@ -2173,11 +2190,11 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf, } if (Inset const * inset = getInset(i)) { - inset->docbook(buf, os, runparams); + inset->docbook(os, runparams); } else { char_type c = d->text_[i]; - if (style->pass_thru) + if (style.pass_thru) os.put(c); else os << sgml::escapeChar(c); @@ -2189,9 +2206,9 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf, os << ""; } - if (style->free_spacing) + if (style.free_spacing) os << '\n'; - if (style->pass_thru && !d->onlyText(buf, outerfont, initial)) + if (style.pass_thru && !d->onlyText(buf, outerfont, initial)) os << "params_.labelString().empty()) + os << d->params_.labelString() << ' '; for (pos_type i = beg; i < end; ++i) { char_type const c = d->text_[i]; if (isPrintable(c)) os.put(c); else if (c == META_INSET) - getInset(i)->textString(buffer, os); + getInset(i)->textString(os); } return os.str(); @@ -2319,15 +2333,24 @@ int Paragraph::id() const } -LayoutPtr const & Paragraph::layout() const +Layout const & Paragraph::layout() const { - return d->layout_; + return *d->layout_; } -void Paragraph::layout(LayoutPtr const & new_layout) +void Paragraph::setLayout(Layout const & layout) { - d->layout_ = new_layout; + d->layout_ = &layout; +} + + +void Paragraph::setEmptyOrDefaultLayout(DocumentClass const & tclass) +{ + if (useEmptyLayout()) + setLayout(tclass.emptyLayout()); + else + setLayout(tclass.defaultLayout()); } @@ -2357,7 +2380,7 @@ ParagraphParameters const & Paragraph::params() const bool Paragraph::isFreeSpacing() const { - if (layout()->free_spacing) + if (d->layout_->free_spacing) return true; return d->inset_owner_ && d->inset_owner_->isFreeSpacing(); } @@ -2365,7 +2388,7 @@ bool Paragraph::isFreeSpacing() const bool Paragraph::allowEmpty() const { - if (layout()->keepempty) + if (d->layout_->keepempty) return true; return d->inset_owner_ && d->inset_owner_->allowEmpty(); } @@ -2411,14 +2434,14 @@ char_type Paragraph::transformChar(char_type c, pos_type pos) const } -int Paragraph::checkBiblio(bool track_changes) +int Paragraph::checkBiblio(Buffer const & buffer) { - //FIXME From JS: - //This is getting more and more a mess. ...We really should clean - //up this bibitem issue for 1.6. See also bug 2743. + // FIXME From JS: + // This is getting more and more a mess. ...We really should clean + // up this bibitem issue for 1.6. See also bug 2743. // Add bibitem insets if necessary - if (layout()->labeltype != LABEL_BIBLIO) + if (d->layout_->labeltype != LABEL_BIBLIO) return 0; bool hasbibitem = !d->insetlist_.empty() @@ -2426,6 +2449,8 @@ int Paragraph::checkBiblio(bool track_changes) && d->text_[0] == META_INSET && d->insetlist_.begin()->inset->lyxCode() == BIBITEM_CODE; + bool track_changes = buffer.params().trackChanges; + docstring oldkey; docstring oldlabel; @@ -2448,13 +2473,13 @@ int Paragraph::checkBiblio(bool track_changes) break; } - //There was an InsetBibitem at the beginning, and we didn't - //have to erase one. + // There was an InsetBibitem at the beginning, and we didn't + // have to erase one. if (hasbibitem && erasedInsetPosition < 0) return 0; - //There was an InsetBibitem at the beginning and we did have to - //erase one. So we give its properties to the beginning inset. + // There was an InsetBibitem at the beginning and we did have to + // erase one. So we give its properties to the beginning inset. if (hasbibitem) { InsetBibitem * inset = static_cast(d->insetlist_.begin()->inset); @@ -2464,9 +2489,10 @@ int Paragraph::checkBiblio(bool track_changes) return -erasedInsetPosition; } - //There was no inset at the beginning, so we need to create one with - //the key and label of the one we erased. - InsetBibitem * inset(new InsetBibitem(InsetCommandParams(BIBITEM_CODE))); + // There was no inset at the beginning, so we need to create one with + // the key and label of the one we erased. + InsetBibitem * inset = new InsetBibitem(InsetCommandParams(BIBITEM_CODE)); + inset->setBuffer(const_cast(buffer)); // restore values of previously deleted item in this par. if (!oldkey.empty()) inset->setParam("key", oldkey); @@ -2660,4 +2686,66 @@ bool Paragraph::isSeparator(pos_type pos) const } +void Paragraph::deregisterWords() +{ + Private::Words::const_iterator it; + WordList & wl = theWordList(); + for (it = d->words_.begin(); it != d->words_.end(); ++it) + wl.remove(*it); + d->words_.clear(); +} + + +void Paragraph::collectWords(CursorSlice const & sl) +{ + // find new words + bool inword = false; + + //lyxerr << "Words: "; + pos_type n = size(); + for (pos_type pos = 0; pos != n; ++pos) { + if (isDeleted(pos)) + continue; + + if (!isLetter(pos)) { + inword = false; + continue; + } + + if (inword) + continue; + + inword = true; + CursorSlice from = sl; + CursorSlice to = sl; + from.pos() = pos; + to.pos() = pos; + from.text()->getWord(from, to, WHOLE_WORD); + if (to.pos() - from.pos() < 6) + continue; + docstring word = asString(from.pos(), to.pos(), false); + d->words_.insert(word); + //lyxerr << word << " "; + } + //lyxerr << std::endl; +} + + +void Paragraph::registerWords() +{ + Private::Words::const_iterator it; + WordList & wl = theWordList(); + for (it = d->words_.begin(); it != d->words_.end(); ++it) + wl.insert(*it); +} + + +void Paragraph::updateWords(CursorSlice const & sl) +{ + BOOST_ASSERT(&sl.paragraph() == this); + deregisterWords(); + collectWords(sl); + registerWords(); +} + } // namespace lyx