#include "Layout.h"
#include "Length.h"
#include "Font.h"
+#include "FontList.h"
#include "LyXRC.h"
#include "Messages.h"
#include "OutputParams.h"
#include "support/convert.h"
#include "support/unicode.h"
-#include <boost/bind.hpp>
-#include <boost/next_prior.hpp>
-
-#include <algorithm>
#include <sstream>
-using std::distance;
using std::endl;
using std::string;
using std::ostream;
using support::rsplit;
using support::rtrim;
-namespace {
-/** A font entry covers a range of positions. Notice that the
- entries in the list are inserted in random order.
- I don't think it's worth the effort to implement a more effective
- datastructure, because the number of different fonts in a paragraph
- is limited. (Asger)
- Nevertheless, I decided to store fontlist_ using a sorted vector:
- fontlist_ = { {pos_1,font_1} , {pos_2,font_2} , ... } where
- pos_1 < pos_2 < ..., font_{i-1} != font_i for all i,
- and font_i covers the chars in positions pos_{i-1}+1,...,pos_i
- (font_1 covers the chars 0,...,pos_1) (Dekel)
-*/
-class FontTable
-{
-public:
- ///
- FontTable(pos_type p, Font const & f)
- : pos_(p), font_(f)
- {}
- ///
- pos_type pos() const { return pos_; }
- ///
- void pos(pos_type p) { pos_ = p; }
- ///
- Font const & font() const { return font_; }
- ///
- void font(Font const & f) { font_ = f;}
-
-private:
- /// End position of paragraph this font attribute covers
- pos_type pos_;
- /** Font. Interpretation of the font values:
- If a value is Font::INHERIT_*, it means that the font
- attribute is inherited from either the layout of this
- paragraph or, in the case of nested paragraphs, from the
- layout in the environment one level up until completely
- resolved.
- The values Font::IGNORE_* and Font::TOGGLE are NOT
- allowed in these font tables.
- */
- Font font_;
-};
-
-
-class matchFT
-{
-public:
- /// used by lower_bound and upper_bound
- int operator()(FontTable const & a, FontTable const & b) const {
- return a.pos() < b.pos();
- }
-};
-
-
-typedef std::vector<FontTable> FontList;
-
-}
/////////////////////////////////////////////////////////////////////
//
//
/////////////////////////////////////////////////////////////////////
-class Encoding;
-class Layout;
-
-
class Paragraph::Private
{
public:
pos_type & i,
unsigned int & column, value_type const c);
+ ///
+ void simpleTeXSpecialChar(
+ odocstream & os,
+ OutputParams & runparams,
+ Font & running_font,
+ Change & running_change,
+ pos_type & i,
+ unsigned int & column,
+ value_type const c);
+
///
void validate(LaTeXFeatures & features,
Layout const & layout) const;
};
special_phrase const special_phrases[] = {
- { "LyX", from_ascii("\\LyX{}"), false },
- { "TeX", from_ascii("\\TeX{}"), true },
- { "LaTeX2e", from_ascii("\\LaTeXe{}"), true },
- { "LaTeX", from_ascii("\\LaTeX{}"), true },
+ { "LyX", from_ascii("\\protect\\LyX{}"), false },
+ { "TeX", from_ascii("\\protect\\TeX{}"), true },
+ { "LaTeX2e", from_ascii("\\protect\\LaTeXe{}"), true },
+ { "LaTeX", from_ascii("\\protect\\LaTeX{}"), true },
};
size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
Paragraph::Private::Private(Private const & p, Paragraph * owner)
- : owner_(owner), inset_owner_(p.inset_owner_), params_(p.params_),
- changes_(p.changes_), insetlist_(p.insetlist_), fontlist_(p.fontlist_)
+ : owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_),
+ params_(p.params_), changes_(p.changes_), insetlist_(p.insetlist_)
{
id_ = paragraph_id++;
}
owner_->text_.insert(owner_->text_.begin() + pos, c);
// Update the font table.
- FontTable search_font(pos, Font());
- for (FontList::iterator it
- = lower_bound(fontlist_.begin(), fontlist_.end(), search_font, matchFT());
- it != fontlist_.end(); ++it)
- {
- it->pos(it->pos() + 1);
- }
+ fontlist_.increasePosAfterPos(pos);
// Update the insets
insetlist_.increasePosAfterPos(pos);
BOOST_ASSERT(pos >= 0 && pos <= size());
d->insertChar(pos, META_INSET, change);
- BOOST_ASSERT(owner_->text_[pos] == META_INSET);
+ BOOST_ASSERT(text_[pos] == META_INSET);
// Add a new entry in the insetlist_.
d->insetlist_.insert(inset, pos);
text_.erase(text_.begin() + pos);
- // Erase entries in the tables.
- FontTable search_font(pos, Font());
-
- FontList::iterator it =
- lower_bound(d->fontlist_.begin(),
- d->fontlist_.end(),
- search_font, matchFT());
- FontList::iterator begin = d->fontlist_.begin();
- if (it != d->fontlist_.end() && it->pos() == pos &&
- (pos == 0 ||
- (it != begin
- && boost::prior(it)->pos() == pos - 1))) {
- // If it is a multi-character font
- // entry, we just make it smaller
- // (see update below), otherwise we
- // should delete it.
- unsigned int const i = it - begin;
- d->fontlist_.erase(begin + i);
- it = begin + i;
- if (i > 0 && i < d->fontlist_.size() &&
- d->fontlist_[i - 1].font() == d->fontlist_[i].font()) {
- d->fontlist_.erase(begin + i - 1);
- it = begin + i - 1;
- }
- }
-
- // Update all other entries
- FontList::iterator fend = d->fontlist_.end();
- for (; it != fend; ++it)
- it->pos(it->pos() - 1);
+ // Update the fontlist_
+ d->fontlist_.erase(pos);
// Update the insetlist_
d->insetlist_.decreasePosAfterPos(pos);
return false;
}
- // is there a font change in middle of the word?
- FontList::const_iterator cit = fontlist_.begin();
- FontList::const_iterator end = fontlist_.end();
- for (; cit != end; ++cit) {
- if (cit->pos() >= pos)
- break;
- }
- if (cit != end && pos + len - 1 > cit->pos())
- return false;
-
- return true;
+ return fontlist_.hasChangeInRange(pos, len);
}
// Two major modes: LaTeX or plain
// Handle here those cases common to both modes
// and then split to handle the two modes separately.
- switch (c) {
- case Paragraph::META_INSET: {
- Inset * inset = owner_->getInset(i);
-
- // FIXME: remove this check
- if (!inset)
- break;
+ if (c != Paragraph::META_INSET) {
+ simpleTeXSpecialChar(os, runparams, running_font, running_change,
+ i, column, c);
+ return;
+ }
- // FIXME: move this to InsetNewline::latex
- if (inset->lyxCode() == NEWLINE_CODE) {
- // 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, bparams, runparams,
- basefont, basefont);
- open_font = false;
- }
+ Inset * inset = owner_->getInset(i);
+ BOOST_ASSERT(inset);
- if (running_font.family() == Font::TYPEWRITER_FAMILY)
- os << '~';
+ // FIXME: move this to InsetNewline::latex
+ if (inset->lyxCode() == NEWLINE_CODE) {
+ // 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, bparams, runparams,
+ basefont, basefont);
+ open_font = false;
+ }
- basefont = owner_->getLayoutFont(bparams, outerfont);
- running_font = basefont;
+ if (running_font.family() == Font::TYPEWRITER_FAMILY)
+ os << '~';
- if (runparams.moving_arg)
- os << "\\protect ";
+ basefont = owner_->getLayoutFont(bparams, outerfont);
+ running_font = basefont;
- os << "\\\\\n";
- }
- texrow.newline();
- texrow.start(owner_->id(), i + 1);
- column = 0;
- break;
- }
+ if (runparams.moving_arg)
+ os << "\\protect ";
- if (owner_->lookupChange(i).type == Change::DELETED) {
- if( ++runparams.inDeletedInset == 1)
- runparams.changeOfDeletedInset = owner_->lookupChange(i);
+ os << "\\\\\n";
}
+ texrow.newline();
+ texrow.start(owner_->id(), i + 1);
+ column = 0;
+ }
- if (inset->canTrackChanges()) {
- column += Changes::latexMarkChange(os, bparams, running_change,
- Change(Change::UNCHANGED));
- running_change = Change(Change::UNCHANGED);
- }
+ if (owner_->lookupChange(i).type == Change::DELETED) {
+ if( ++runparams.inDeletedInset == 1)
+ runparams.changeOfDeletedInset = owner_->lookupChange(i);
+ }
- bool close = false;
- odocstream::pos_type const len = os.tellp();
+ if (inset->canTrackChanges()) {
+ column += Changes::latexMarkChange(os, bparams, running_change,
+ Change(Change::UNCHANGED));
+ running_change = Change(Change::UNCHANGED);
+ }
- if ((inset->lyxCode() == GRAPHICS_CODE
- || inset->lyxCode() == MATH_CODE
- || inset->lyxCode() == HYPERLINK_CODE)
- && running_font.isRightToLeft()) {
- if (running_font.language()->lang() == "farsi")
- os << "\\beginL{}";
- else
- os << "\\L{";
- close = true;
- }
+ bool close = false;
+ odocstream::pos_type const len = os.tellp();
-// FIXME: Bug: we can have an empty font change here!
-// if there has just been a font change, we are going to close it
-// right now, which means stupid latex code like \textsf{}. AFAIK,
-// this does not harm dvi output. A minor bug, thus (JMarc)
- // Some insets cannot be inside a font change command.
- // However, even such insets *can* be placed in \L or \R
- // or their equivalents (for RTL language switches), so we don't
- // close the language in those cases.
- // ArabTeX, though, cannot handle this special behavior, it seems.
- bool arabtex = basefont.language()->lang() == "arabic_arabtex" ||
- running_font.language()->lang() == "arabic_arabtex";
- if (open_font && inset->noFontChange()) {
- bool closeLanguage = arabtex ||
- basefont.isRightToLeft() == running_font.isRightToLeft();
- unsigned int count = running_font.latexWriteEndChanges(
- os, bparams, runparams,
- basefont, basefont, closeLanguage);
- column += count;
- // if any font properties were closed, update the running_font,
- // making sure, however, to leave the language as it was
- if (count > 0) {
- // FIXME: probably a better way to keep track of the old
- // language, than copying the entire font?
- Font const copy_font(running_font);
- basefont = owner_->getLayoutFont(bparams, outerfont);
- running_font = basefont;
- if (!closeLanguage)
- running_font.setLanguage(copy_font.language());
- // leave font open if language is still open
- open_font = (running_font.language() == basefont.language());
- if (closeLanguage)
- runparams.local_font = &basefont;
- }
+ if ((inset->lyxCode() == GRAPHICS_CODE
+ || inset->lyxCode() == MATH_CODE
+ || inset->lyxCode() == HYPERLINK_CODE)
+ && running_font.isRightToLeft()) {
+ if (running_font.language()->lang() == "farsi")
+ os << "\\beginL{}";
+ else
+ os << "\\L{";
+ close = true;
+ }
+
+ // FIXME: Bug: we can have an empty font change here!
+ // if there has just been a font change, we are going to close it
+ // right now, which means stupid latex code like \textsf{}. AFAIK,
+ // this does not harm dvi output. A minor bug, thus (JMarc)
+
+ // Some insets cannot be inside a font change command.
+ // However, even such insets *can* be placed in \L or \R
+ // or their equivalents (for RTL language switches), so we don't
+ // close the language in those cases.
+ // ArabTeX, though, cannot handle this special behavior, it seems.
+ bool arabtex = basefont.language()->lang() == "arabic_arabtex"
+ || running_font.language()->lang() == "arabic_arabtex";
+ if (open_font && inset->noFontChange()) {
+ bool closeLanguage = arabtex
+ || basefont.isRightToLeft() == running_font.isRightToLeft();
+ unsigned int count = running_font.latexWriteEndChanges(os,
+ bparams, runparams, basefont, basefont, closeLanguage);
+ column += count;
+ // if any font properties were closed, update the running_font,
+ // making sure, however, to leave the language as it was
+ if (count > 0) {
+ // FIXME: probably a better way to keep track of the old
+ // language, than copying the entire font?
+ Font const copy_font(running_font);
+ basefont = owner_->getLayoutFont(bparams, outerfont);
+ running_font = basefont;
+ if (!closeLanguage)
+ running_font.setLanguage(copy_font.language());
+ // leave font open if language is still open
+ open_font = (running_font.language() == basefont.language());
+ if (closeLanguage)
+ runparams.local_font = &basefont;
}
+ }
- int tmp = inset->latex(buf, os, runparams);
+ int tmp = inset->latex(buf, os, runparams);
- if (close) {
- if (running_font.language()->lang() == "farsi")
- os << "\\endL{}";
- else
- os << '}';
- }
+ if (close) {
+ if (running_font.language()->lang() == "farsi")
+ os << "\\endL{}";
+ else
+ os << '}';
+ }
- if (tmp) {
- for (int j = 0; j < tmp; ++j) {
- texrow.newline();
- }
- texrow.start(owner_->id(), i + 1);
- column = 0;
- } else {
- column += os.tellp() - len;
- }
+ if (tmp) {
+ for (int j = 0; j < tmp; ++j)
+ texrow.newline();
- if (owner_->lookupChange(i).type == Change::DELETED) {
- --runparams.inDeletedInset;
- }
+ texrow.start(owner_->id(), i + 1);
+ column = 0;
+ } else {
+ column += os.tellp() - len;
}
- break;
- default:
- // And now for the special cases within each mode
+ if (owner_->lookupChange(i).type == Change::DELETED)
+ --runparams.inDeletedInset;
+}
- switch (c) {
- case '\\':
- os << "\\textbackslash{}";
- column += 15;
- break;
- case '|': case '<': case '>':
- // In T1 encoding, these characters exist
- if (lyxrc.fontenc == "T1") {
- os.put(c);
- //... but we should avoid ligatures
- if ((c == '>' || c == '<')
- && i <= size() - 2
- && getChar(i + 1) == c) {
- //os << "\\textcompwordmark{}";
- //column += 19;
- // Jean-Marc, have a look at
- // this. IÂ think this works
- // equally well:
- os << "\\,{}";
- // Lgb
- column += 3;
- }
- break;
- }
- // Typewriter font also has them
- if (running_font.family() == Font::TYPEWRITER_FAMILY) {
- os.put(c);
- break;
- }
- // Otherwise, we use what LaTeX
- // provides us.
- switch (c) {
- case '<':
- os << "\\textless{}";
- column += 10;
- break;
- case '>':
- os << "\\textgreater{}";
- column += 13;
- break;
- case '|':
- os << "\\textbar{}";
- column += 9;
- break;
- }
- break;
+void Paragraph::Private::simpleTeXSpecialChar(
+ odocstream & os,
+ OutputParams & runparams,
+ Font & running_font,
+ Change & running_change,
+ pos_type & i,
+ unsigned int & column,
+ value_type const c)
+{
+ if (runparams.verbatim) {
+ os.put(c);
+ return;
+ }
- case '-': // "--" in Typewriter mode -> "-{}-"
- if (i <= size() - 2 &&
- getChar(i + 1) == '-' &&
- running_font.family() == Font::TYPEWRITER_FAMILY) {
- os << "-{}";
- column += 2;
- } else {
- os << '-';
- }
- break;
+ switch (c) {
+ case '\\':
+ os << "\\textbackslash{}";
+ column += 15;
+ break;
- case '\"':
- os << "\\char`\\\"{}";
- column += 9;
+ case '|':
+ case '<':
+ case '>':
+ // In T1 encoding, these characters exist
+ if (lyxrc.fontenc == "T1") {
+ os.put(c);
+ //... but we should avoid ligatures
+ if ((c == '>' || c == '<')
+ && i <= size() - 2
+ && getChar(i + 1) == c) {
+ //os << "\\textcompwordmark{}";
+ //column += 19;
+ // Jean-Marc, have a look at
+ // this. IÂ think this works
+ // equally well:
+ os << "\\,{}";
+ // Lgb
+ column += 3;
+ }
break;
-
- case '$': case '&':
- case '%': case '#': case '{':
- case '}': case '_':
- os << '\\';
+ }
+ // Typewriter font also has them
+ if (running_font.family() == Font::TYPEWRITER_FAMILY) {
os.put(c);
- column += 1;
break;
-
- case '~':
- os << "\\textasciitilde{}";
- column += 16;
+ }
+ // Otherwise, we use what LaTeX
+ // provides us.
+ switch (c) {
+ case '<':
+ os << "\\textless{}";
+ column += 10;
break;
-
- case '^':
- os << "\\textasciicircum{}";
- column += 17;
+ case '>':
+ os << "\\textgreater{}";
+ column += 13;
break;
+ case '|':
+ os << "\\textbar{}";
+ column += 9;
+ break;
+ }
+ break;
- case '*': case '[':
- // avoid being mistaken for optional arguments
- os << '{';
- os.put(c);
- os << '}';
+ case '-': // "--" in Typewriter mode -> "-{}-"
+ if (i <= size() - 2 &&
+ getChar(i + 1) == '-' &&
+ running_font.family() == Font::TYPEWRITER_FAMILY) {
+ os << "-{}";
column += 2;
- break;
+ } else {
+ os << '-';
+ }
+ break;
- case ' ':
- // Blanks are printed before font switching.
- // Sure? I am not! (try nice-latex)
- // I am sure it's correct. LyX might be smarter
- // in the future, but for now, nothing wrong is
- // written. (Asger)
- break;
+ case '\"':
+ os << "\\char`\\\"{}";
+ column += 9;
+ break;
- default:
+ case '$': case '&':
+ case '%': case '#': case '{':
+ case '}': case '_':
+ os << '\\';
+ os.put(c);
+ column += 1;
+ break;
- // I assume this is hack treating typewriter as verbatim
- // FIXME UNICODE: This can fail if c cannot be encoded
- // in the current encoding.
- if (running_font.family() == Font::TYPEWRITER_FAMILY) {
- if (c != '\0') {
- os.put(c);
- }
- break;
- }
+ case '~':
+ os << "\\textasciitilde{}";
+ column += 16;
+ break;
- // LyX, LaTeX etc.
+ case '^':
+ os << "\\textasciicircum{}";
+ column += 17;
+ break;
- // FIXME: if we have "LaTeX" with a font
- // change in the middle (before the 'T', then
- // the "TeX" part is still special cased.
- // Really we should only operate this on
- // "words" for some definition of word
+ case '*': case '[':
+ // avoid being mistaken for optional arguments
+ os << '{';
+ os.put(c);
+ os << '}';
+ column += 2;
+ break;
- size_t pnr = 0;
+ case ' ':
+ // Blanks are printed before font switching.
+ // Sure? I am not! (try nice-latex)
+ // I am sure it's correct. LyX might be smarter
+ // in the future, but for now, nothing wrong is
+ // written. (Asger)
+ break;
- for (; pnr < phrases_nr; ++pnr) {
- if (isTextAt(special_phrases[pnr].phrase, i)) {
- os << special_phrases[pnr].macro;
- i += special_phrases[pnr].phrase.length() - 1;
- column += special_phrases[pnr].macro.length() - 1;
- break;
- }
+ default:
+ // I assume this is hack treating typewriter as verbatim
+ // FIXME UNICODE: This can fail if c cannot be encoded
+ // in the current encoding.
+ if (running_font.family() == Font::TYPEWRITER_FAMILY) {
+ if (c != '\0')
+ os.put(c);
+ break;
+ }
+
+ // LyX, LaTeX etc.
+
+ // FIXME: if we have "LaTeX" with a font
+ // change in the middle (before the 'T', then
+ // the "TeX" part is still special cased.
+ // Really we should only operate this on
+ // "words" for some definition of word
+
+ size_t pnr = 0;
+
+ for (; pnr < phrases_nr; ++pnr) {
+ if (isTextAt(special_phrases[pnr].phrase, i)) {
+ os << special_phrases[pnr].macro;
+ i += special_phrases[pnr].phrase.length() - 1;
+ column += special_phrases[pnr].macro.length() - 1;
+ break;
}
+ }
- if (pnr == phrases_nr && c != '\0') {
- Encoding const & encoding = *(runparams.encoding);
- if (i + 1 < size()) {
- char_type next = getChar(i + 1);
- if (Encodings::isCombiningChar(next)) {
- column += latexSurrogatePair(os, c, next, encoding) - 1;
- ++i;
- break;
- }
- }
- string preamble;
- if (Encodings::isKnownLangChar(c, preamble)) {
- column +=
- knownLangChars(os, c, preamble,
- running_change,
- encoding, i) - 1;
+ if (pnr == phrases_nr && c != '\0') {
+ Encoding const & encoding = *(runparams.encoding);
+ if (i + 1 < size()) {
+ char_type next = getChar(i + 1);
+ if (Encodings::isCombiningChar(next)) {
+ column += latexSurrogatePair(os, c, next, encoding) - 1;
+ ++i;
break;
}
- docstring const latex = encoding.latexChar(c);
- if (latex.length() > 1 &&
- latex[latex.length() - 1] != '}') {
- // Prevent eating of a following
- // space or command corruption by
- // following characters
- column += latex.length() + 1;
- os << latex << "{}";
- } else {
- column += latex.length() - 1;
- os << latex;
- }
}
- break;
+ string preamble;
+ if (Encodings::isKnownLangChar(c, preamble)) {
+ column += knownLangChars(os, c, preamble, running_change,
+ encoding, i) - 1;
+ break;
+ }
+ docstring const latex = encoding.latexChar(c);
+ if (latex.length() > 1 && latex[latex.length() - 1] != '}') {
+ // Prevent eating of a following
+ // space or command corruption by
+ // following characters
+ column += latex.length() + 1;
+ os << latex << "{}";
+ } else {
+ column += latex.length() - 1;
+ os << latex;
+ }
}
+ break;
}
}
void Paragraph::Private::validate(LaTeXFeatures & features,
Layout const & layout) const
{
- BufferParams const & bparams = features.bufferParams();
-
// check the params.
if (!params_.spacing().isDefault())
features.require("setspace");
features.useLayout(layout.name());
// then the fonts
- Language const * doc_language = bparams.language;
-
- FontList::const_iterator fcit = fontlist_.begin();
- FontList::const_iterator fend = fontlist_.end();
- for (; fcit != fend; ++fcit) {
- if (fcit->font().noun() == Font::ON) {
- LYXERR(Debug::LATEX) << "font.noun: "
- << fcit->font().noun()
- << endl;
- features.require("noun");
- LYXERR(Debug::LATEX) << "Noun enabled. Font: "
- << to_utf8(fcit->font().stateText(0))
- << endl;
- }
- switch (fcit->font().color()) {
- case Color::none:
- case Color::inherit:
- case Color::ignore:
- // probably we should put here all interface colors used for
- // font displaying! For now I just add this ones I know of (Jug)
- case Color::latex:
- case Color::note:
- break;
- default:
- features.require("color");
- LYXERR(Debug::LATEX) << "Color enabled. Font: "
- << to_utf8(fcit->font().stateText(0))
- << endl;
- }
-
- Language const * language = fcit->font().language();
- if (language->babel() != doc_language->babel() &&
- language != ignore_language &&
- language != latex_language)
- {
- features.useLanguage(language);
- LYXERR(Debug::LATEX) << "Found language "
- << language->lang() << endl;
- }
- }
+ fontlist_.validate(features);
+ // then the indentation
if (!params_.leftIndent().zero())
features.require("ParagraphLeftIndent");
}
}
-
-} // namespace lyx
-
-
/////////////////////////////////////////////////////////////////////
//
// Paragraph
//
/////////////////////////////////////////////////////////////////////
-namespace lyx {
-
Paragraph::Paragraph()
: begin_of_body_(0), d(new Paragraph::Private(this))
{
BOOST_ASSERT(pos <= size());
}
- FontList::const_iterator cit = d->fontlist_.begin();
- FontList::const_iterator end = d->fontlist_.end();
- for (; cit != end; ++cit)
- if (cit->pos() >= pos)
- break;
-
- if (cit != end)
+ FontList::const_iterator cit = d->fontlist_.fontIterator(pos);
+ if (cit != d->fontlist_.end())
return cit->font();
if (pos == size() && !empty())
Font const Paragraph::getFirstFontSettings(BufferParams const & bparams) const
{
if (!empty() && !d->fontlist_.empty())
- return d->fontlist_[0].font();
+ return d->fontlist_.begin()->font();
return Font(Font::ALL_INHERIT, bparams.language);
}
Font_size Paragraph::highestFontInRange
(pos_type startpos, pos_type endpos, Font_size def_size) const
{
- if (d->fontlist_.empty())
- return def_size;
-
- FontList::const_iterator end_it = d->fontlist_.begin();
- FontList::const_iterator const end = d->fontlist_.end();
- for (; end_it != end; ++end_it) {
- if (end_it->pos() >= endpos)
- break;
- }
-
- if (end_it != end)
- ++end_it;
-
- FontList::const_iterator cit = d->fontlist_.begin();
- for (; cit != end; ++cit) {
- if (cit->pos() >= startpos)
- break;
- }
-
- Font::FONT_SIZE maxsize = Font::SIZE_TINY;
- for (; cit != end_it; ++cit) {
- Font::FONT_SIZE size = cit->font().size();
- if (size == Font::INHERIT_SIZE)
- size = def_size;
- if (size > maxsize && size <= Font::SIZE_HUGER)
- maxsize = size;
- }
- return maxsize;
+ return d->fontlist_.highestInRange(startpos, endpos, def_size);
}
// First, reduce font against layout/label font
// Update: The setCharFont() routine in text2.cpp 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)
- // Next search font table
-
- FontList::iterator beg = d->fontlist_.begin();
- FontList::iterator it = beg;
- FontList::iterator endit = d->fontlist_.end();
- for (; it != endit; ++it) {
- if (it->pos() >= pos)
- break;
- }
- size_t const i = distance(beg, it);
- bool notfound = (it == endit);
-
- if (!notfound && d->fontlist_[i].font() == font)
- return;
-
- bool begin = pos == 0 || notfound ||
- (i > 0 && d->fontlist_[i - 1].pos() == pos - 1);
- // Is position pos is a beginning of a font block?
- bool end = !notfound && d->fontlist_[i].pos() == pos;
- // Is position pos is the end of a font block?
- if (begin && end) { // A single char block
- if (i + 1 < d->fontlist_.size() &&
- d->fontlist_[i + 1].font() == font) {
- // Merge the singleton block with the next block
- d->fontlist_.erase(d->fontlist_.begin() + i);
- if (i > 0 && d->fontlist_[i - 1].font() == font)
- d->fontlist_.erase(d->fontlist_.begin() + i - 1);
- } else if (i > 0 && d->fontlist_[i - 1].font() == font) {
- // Merge the singleton block with the previous block
- d->fontlist_[i - 1].pos(pos);
- d->fontlist_.erase(d->fontlist_.begin() + i);
- } else
- d->fontlist_[i].font(font);
- } else if (begin) {
- if (i > 0 && d->fontlist_[i - 1].font() == font)
- d->fontlist_[i - 1].pos(pos);
- else
- d->fontlist_.insert(d->fontlist_.begin() + i,
- FontTable(pos, font));
- } else if (end) {
- d->fontlist_[i].pos(pos - 1);
- if (!(i + 1 < d->fontlist_.size() &&
- d->fontlist_[i + 1].font() == font))
- d->fontlist_.insert(d->fontlist_.begin() + i + 1,
- FontTable(pos, font));
- } else { // The general case. The block is splitted into 3 blocks
- d->fontlist_.insert(d->fontlist_.begin() + i,
- FontTable(pos - 1, d->fontlist_[i].font()));
- d->fontlist_.insert(d->fontlist_.begin() + i + 1,
- FontTable(pos, font));
- }
+
+ d->fontlist_.set(pos, font);
}
//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")));
+ InsetBibitem * inset(new InsetBibitem(InsetCommandParams(BIBITEM_CODE)));
// restore values of previously deleted item in this par.
if (!oldkey.empty())
inset->setParam("key", oldkey);
projects / lyx.git / blobdiff