#include "sgml.h"
#include "TextClass.h"
#include "TexRow.h"
+#include "Text.h"
#include "VSpace.h"
+#include "WordList.h"
#include "frontends/alert.h"
bool) const;
///
- void latexInset(Buffer const &, BufferParams const &,
+ void latexInset(BufferParams const &,
odocstream &,
TexRow & texrow, OutputParams &,
Font & running_font,
typedef docstring TextContainer;
///
TextContainer text_;
+
+ typedef std::set<docstring> Words;
+ ///
+ Words words_;
};
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_)
+ layout_(p.layout_), begin_of_body_(p.begin_of_body_), text_(p.text_),
+ words_(p.words_)
{
id_ = paragraph_id++;
}
}
-void Paragraph::Private::latexInset(Buffer const & buf,
+void Paragraph::Private::latexInset(
BufferParams const & bparams,
odocstream & os,
TexRow & texrow,
BOOST_ASSERT(inset);
if (style.pass_thru) {
- inset->plaintext(buf, os, runparams);
+ inset->plaintext(os, runparams);
return;
}
}
}
- int tmp = inset->latex(buf, os, runparams);
+ int tmp = inset->latex(os, runparams);
if (close) {
if (running_font.language()->lang() == "farsi")
: itemdepth(par.itemdepth),
d(new Paragraph::Private(*par.d, this))
{
+ registerWords();
}
if (&par != this) {
itemdepth = par.itemdepth;
+ deregisterWords();
delete d;
d = new Private(*par.d, this);
+ registerWords();
}
return *this;
}
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;
}
}
// 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);
// 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;
}
void Paragraph::validate(LaTeXFeatures & features) const
{
- d->validate(features, *layout());
+ d->validate(features, *d->layout_);
}
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));
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));
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_;
}
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!");
}
void Paragraph::setLabelWidthString(docstring const & s)
{
- params().labelWidthString(s);
+ d->params_.labelWidthString(s);
}
docstring Paragraph::expandLabel(LayoutPtr 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())
+ if (process_appendix && d->params_.appendix())
fmt = translateIfPossible(layout->labelstring_appendix(),
bparams);
else
void Paragraph::applyLayout(LayoutPtr 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);
}
}
void Paragraph::setBeginOfBody()
{
- if (layout()->labeltype != LABEL_MANUAL) {
+ if (d->layout_->labeltype != LABEL_MANUAL) {
d->begin_of_body_ = 0;
return;
}
// 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
// to be valid!
bool asdefault = forceEmptyLayout();
- if (asdefault) {
- style = bparams.getTextClass().defaultLayout();
- } else {
- style = layout();
- }
+ if (asdefault)
+ style = bparams.documentClass().emptyLayout();
+ else
+ style = d->layout_;
// Current base font for all inherited font changes, without any
// change caused by an individual character, except for the language:
// 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);
}
-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)) {
}
-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 == ' ')
{
bool emph_flag = false;
- LayoutPtr const & style = layout();
+ LayoutPtr const & style = d->layout_;
FontInfo font_old =
style->labeltype == LABEL_MANUAL ? style->labelfont : style->font;
}
if (Inset const * inset = getInset(i)) {
- inset->docbook(buf, os, runparams);
+ inset->docbook(os, runparams);
} else {
char_type c = d->text_[i];
}
-// Convert the paragraph to a string.
-// Used for building the table of contents
-docstring const Paragraph::asString(Buffer const & buffer, bool label) const
+docstring Paragraph::asString(bool label) const
{
- return asString(buffer, 0, size(), label);
+ return asString(0, size(), label);
}
-docstring const Paragraph::asString(Buffer const & buffer,
- pos_type beg, pos_type end, bool label) const
+docstring Paragraph::asString(pos_type beg, pos_type end, bool label) const
{
odocstringstream os;
- if (beg == 0 && label && !params().labelString().empty())
- os << params().labelString() << ' ';
+ if (beg == 0 && label && !d->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();
}
-void Paragraph::layout(LayoutPtr const & new_layout)
+void Paragraph::setLayout(LayoutPtr const & layout)
{
- d->layout_ = new_layout;
+ d->layout_ = layout;
+}
+
+
+void Paragraph::setEmptyOrDefaultLayout(DocumentClass const & tclass)
+{
+ if (useEmptyLayout())
+ setLayout(tclass.emptyLayout());
+ else
+ setLayout(tclass.defaultLayout());
}
bool Paragraph::isFreeSpacing() const
{
- if (layout()->free_spacing)
+ if (d->layout_->free_spacing)
return true;
return d->inset_owner_ && d->inset_owner_->isFreeSpacing();
}
bool Paragraph::allowEmpty() const
{
- if (layout()->keepempty)
+ if (d->layout_->keepempty)
return true;
return d->inset_owner_ && d->inset_owner_->allowEmpty();
}
}
-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()
&& d->text_[0] == META_INSET
&& d->insetlist_.begin()->inset->lyxCode() == BIBITEM_CODE;
+ bool track_changes = buffer.params().trackChanges;
+
docstring oldkey;
docstring oldlabel;
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<InsetBibitem *>(d->insetlist_.begin()->inset);
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 &>(buffer));
// restore values of previously deleted item in this par.
if (!oldkey.empty())
inset->setParam("key", oldkey);
}
+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
projects / lyx.git / blobdiff