FontList fontlist_;
///
- unsigned int id_;
- ///
- static unsigned int paragraph_id;
+ int id_;
+
///
ParagraphParameters params_;
///
TextContainer text_;
- typedef std::set<docstring> Words;
+ typedef set<docstring> Words;
///
- Words words_;
+ map<Language, Words> words_;
///
Layout const * layout_;
};
-// Initialization of the counter for the paragraph id's,
-unsigned int Paragraph::Private::paragraph_id = 0;
-
namespace {
struct special_phrase {
Paragraph::Private::Private(Paragraph * owner, Layout const & layout)
- : owner_(owner), inset_owner_(0), begin_of_body_(0), layout_(&layout)
+ : owner_(owner), inset_owner_(0), id_(-1), begin_of_body_(0), layout_(&layout)
{
- id_ = paragraph_id++;
text_.reserve(100);
}
+// Initialization of the counter for the paragraph id's,
+//
+// FIXME: There should be a more intelligent way to generate and use the
+// paragraph ids per buffer instead a global static counter for all InsetText
+// in the running program.
+static int paragraph_id = -1;
+
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_),
begin_of_body_(p.begin_of_body_), text_(p.text_), words_(p.words_),
layout_(p.layout_)
{
- id_ = paragraph_id++;
+ id_ = ++paragraph_id;
}
begin_of_body_(p.begin_of_body_), words_(p.words_),
layout_(p.layout_)
{
- id_ = paragraph_id++;
+ id_ = ++paragraph_id;
if (beg >= pos_type(p.text_.size()))
return;
text_ = p.text_.substr(beg, end - beg);
void Paragraph::Private::validate(LaTeXFeatures & features) const
{
+ if (layout_->inpreamble && inset_owner_) {
+ Buffer const & buf = inset_owner_->buffer();
+ BufferParams const & bp = buf.params();
+ Font f;
+ TexRow tr;
+ odocstringstream ods;
+ owner_->latex(bp, f, ods, tr, features.runparams());
+ docstring d = ods.str();
+ if (!d.empty())
+ features.addPreambleSnippet(to_utf8(d));
+ }
+
+ if (features.runparams().flavor == OutputParams::HTML
+ && layout_->htmltitle()) {
+ features.setHTMLTitle(owner_->asString(AS_STR_INSETS));
+ }
+
// check the params.
if (!params_.spacing().isDefault())
features.require("setspace");
}
-docstring Paragraph::expandLabel(Layout const & layout,
+docstring Paragraph::expandLabel(Layout const & layout,
+ BufferParams const & bparams) const
+{
+ return expandParagraphLabel(layout, bparams, true);
+}
+
+
+docstring Paragraph::expandDocBookLabel(Layout const & layout,
+ BufferParams const & bparams) const
+{
+ return expandParagraphLabel(layout, bparams, false);
+}
+
+
+docstring Paragraph::expandParagraphLabel(Layout const & layout,
BufferParams const & bparams, bool process_appendix) const
{
DocumentClass const & tclass = bparams.documentClass();
docstring parent(fmt, i + 1, j - i - 1);
docstring label = from_ascii("??");
if (tclass.hasLayout(parent))
- docstring label = expandLabel(tclass[parent], bparams,
+ docstring label = expandParagraphLabel(tclass[parent], bparams,
process_appendix);
fmt = docstring(fmt, 0, i) + label
+ docstring(fmt, j + 1, docstring::npos);
{
LYXERR(Debug::LATEX, "Paragraph::latex... " << this);
+ if (layout().inpreamble)
+ return true;
+
bool return_value = false;
bool const allowcust = allowParagraphCustomization();
char_type c = d->text_[i];
if (c == ' ')
break;
- xs << html::escapeChar(c);
+ xs << c;
}
}
return i;
{
docstring retval;
- // FIXME We really need to manage the tag nesting here.
- // Probably in the same sort of way as in output_xhtml.
bool emph_flag = false;
bool bold_flag = false;
- std::string closing_tag;
+ string closing_tag;
Layout const & style = *d->layout_;
+
+ if (!runparams.for_toc && runparams.html_make_pars) {
+ // generate a magic label for this paragraph
+ string const attr = "id='" + magicLabel() + "'";
+ xs << html::CompTag("a", attr);
+ }
+
FontInfo font_old =
style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
// parsing main loop
for (pos_type i = initial; i < size(); ++i) {
+ // let's not show deleted material in the output
+ if (isDeleted(i))
+ continue;
+
Font font = getFont(buf.params(), i, outerfont);
// emphasis
if (font_old.emph() != font.fontInfo().emph()) {
if (font.fontInfo().emph() == FONT_ON) {
- xs << StartTag("em");
+ xs << html::StartTag("em");
emph_flag = true;
} else if (emph_flag && i != initial) {
- xs << EndTag("em");
+ xs << html::EndTag("em");
emph_flag = false;
}
}
// bold
if (font_old.series() != font.fontInfo().series()) {
if (font.fontInfo().series() == BOLD_SERIES) {
- xs << StartTag("strong");
+ xs << html::StartTag("strong");
bold_flag = true;
} else if (bold_flag && i != initial) {
- xs << EndTag("strong");
+ xs << html::EndTag("strong");
bold_flag = false;
}
}
- // FIXME Other such tags?
+ // FIXME XHTML
+ // Other such tags? What about the other text ranges?
Inset const * inset = getInset(i);
if (inset) {
+ InsetCommand const * ic = inset->asInsetCommand();
InsetLayout const & il = inset->getLayout();
- OutputParams np = runparams;
- if (!il.htmlisblock())
- np.html_in_par = true;
- retval += inset->xhtml(xs, np);
+ InsetMath const * im = inset->asInsetMath();
+ if (!runparams.for_toc
+ || im || il.isInToc() || (ic && ic->isInToc())) {
+ OutputParams np = runparams;
+ if (!il.htmlisblock())
+ np.html_in_par = true;
+ retval += inset->xhtml(xs, np);
+ }
} else {
char_type c = d->text_[i];
}
else
str += c;
+ // We don't want to escape the entities. Note that
+ // it is safe to do this, since str can otherwise
+ // only be "-". E.g., it can't be "<".
xs << XHTMLStream::NextRaw() << str;
} else
xs << c;
}
+void Paragraph::setId(int id)
+{
+ d->id_ = id;
+}
+
+
Layout const & Paragraph::layout() const
{
return *d->layout_;
void Paragraph::deregisterWords()
{
+ map<Language, Private::Words>::const_iterator itl;
Private::Words::const_iterator it;
- WordList & wl = theWordList();
- for (it = d->words_.begin(); it != d->words_.end(); ++it)
- wl.remove(*it);
+ for (itl = d->words_.begin(); itl != d->words_.end(); ++itl) {
+ WordList * wl = theWordList(itl->first);
+ for (it = (itl->second).begin(); it != (itl->second).end(); ++it)
+ wl->remove(*it);
+ }
d->words_.clear();
}
locateWord(from, pos, WHOLE_WORD);
if (pos - from >= 6) {
docstring word = asString(from, pos, AS_STR_NONE);
- d->words_.insert(word);
+ FontList::const_iterator cit = d->fontlist_.fontIterator(pos);
+ if (cit == d->fontlist_.end())
+ return;
+ Language const * lang = cit->font().language();
+ d->words_[*lang].insert(word);
}
}
}
void Paragraph::registerWords()
{
+ map<Language, Private::Words>::const_iterator itl;
Private::Words::const_iterator it;
- WordList & wl = theWordList();
- for (it = d->words_.begin(); it != d->words_.end(); ++it)
- wl.insert(*it);
+ for (itl = d->words_.begin(); itl != d->words_.end(); ++itl) {
+ WordList * wl = theWordList(itl->first);
+ for (it = (itl->second).begin(); it != (itl->second).end(); ++it)
+ wl->insert(*it);
+ }
}
return false;
docstring word = asString(from, to, AS_STR_INSETS);
- string const lang_code = lyxrc.spellchecker_alt_lang.empty()
- ? getFontSettings(d->inset_owner_->buffer().params(), from).language()->code()
- : lyxrc.spellchecker_alt_lang;
- wl = WordLangTuple(word, lang_code);
+ string lang_code;
+ string lang_variety;
+ if (!lyxrc.spellchecker_alt_lang.empty())
+ lang_variety = split(lyxrc.spellchecker_alt_lang, lang_code, '-');
+ else {
+ lang_code = getFontSettings(
+ d->inset_owner_->buffer().params(), from).language()->code();
+ lang_variety = getFontSettings(
+ d->inset_owner_->buffer().params(), from).language()->variety();
+ }
+ wl = WordLangTuple(word, lang_code, lang_variety);
SpellChecker::Result res = speller->check(wl);
// Just ignore any error that the spellchecker reports.
// FIXME: we should through out an exception and catch it in the GUI to
}
+string Paragraph::magicLabel() const
+{
+ stringstream ss;
+ ss << "magicparlabel-" << id();
+ return ss.str();
+}
+
+
} // namespace lyx