/// \return whether a surrogate pair was output.
bool simpleTeXBlanks(Encoding const &,
odocstream &, TexRow & texrow,
- pos_type & i,
+ pos_type i,
unsigned int & column,
Font const & font,
Layout const & style);
/// \return the number of characters written.
int knownLangChars(odocstream & os, value_type c, string & preamble,
Change &, Encoding const &, pos_type &);
+
+ /// This could go to ParagraphParameters if we want to.
+ int startTeXParParams(BufferParams const &, odocstream &, TexRow &,
+ bool) const;
+
+ /// This could go to ParagraphParameters if we want to.
+ int endTeXParParams(BufferParams const &, odocstream &, TexRow &,
+ bool) const;
+
///
- void simpleTeXSpecialChars(Buffer const &, BufferParams const &,
+ void latexInset(Buffer const &, BufferParams const &,
odocstream &,
TexRow & texrow, OutputParams &,
Font & running_font,
Change & running_change,
Layout const & style,
pos_type & i,
- unsigned int & column, value_type const c);
+ unsigned int & column);
///
- void simpleTeXSpecialChar(
+ void latexSpecialChar(
odocstream & os,
OutputParams & runparams,
Font & running_font,
Change & running_change,
+ Layout const & style,
pos_type & i,
- unsigned int & column,
- value_type const c);
+ unsigned int & column);
+
+ ///
+ bool latexSpecialT1(
+ char_type const c,
+ odocstream & os,
+ pos_type & i,
+ unsigned int & column);
+ ///
+ bool latexSpecialTypewriter(
+ char_type const c,
+ odocstream & os,
+ pos_type & i,
+ unsigned int & column);
+ ///
+ bool latexSpecialPhrase(
+ odocstream & os,
+ pos_type & i,
+ unsigned int & column);
///
void validate(LaTeXFeatures & features,
///
InsetList insetlist_;
+
+ ///
+ LayoutPtr layout_;
+
+ /// end of label
+ pos_type begin_of_body_;
};
Paragraph::Private::Private(Paragraph * owner)
- : owner_(owner)
+ : owner_(owner), inset_owner_(0), begin_of_body_(0)
{
- inset_owner_ = 0;
id_ = paragraph_id++;
}
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_)
+ params_(p.params_), changes_(p.changes_), insetlist_(p.insetlist_),
+ layout_(p.layout_), begin_of_body_(p.begin_of_body_)
{
id_ = paragraph_id++;
}
bool Paragraph::Private::simpleTeXBlanks(Encoding const & encoding,
odocstream & os, TexRow & texrow,
- pos_type & i,
+ pos_type i,
unsigned int & column,
Font const & font,
Layout const & style)
if (Encodings::isCombiningChar(next)) {
// This space has an accent, so we must always output it.
column += latexSurrogatePair(os, ' ', next, encoding) - 1;
- ++i;
return true;
}
}
}
-void Paragraph::Private::simpleTeXSpecialChars(Buffer const & buf,
+void Paragraph::Private::latexInset(Buffer const & buf,
BufferParams const & bparams,
odocstream & os,
TexRow & texrow,
Change & running_change,
Layout const & style,
pos_type & i,
- unsigned int & column,
- value_type const c)
+ unsigned int & column)
{
- if (style.pass_thru) {
- if (c != Paragraph::META_INSET) {
- if (c != '\0')
- // FIXME UNICODE: This can fail if c cannot
- // be encoded in the current encoding.
- os.put(c);
- } else
- owner_->getInset(i)->plaintext(buf, os, runparams);
- return;
- }
+ Inset * inset = owner_->getInset(i);
+ BOOST_ASSERT(inset);
- // 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 != Paragraph::META_INSET) {
- simpleTeXSpecialChar(os, runparams, running_font, running_change,
- i, column, c);
+ if (style.pass_thru) {
+ inset->plaintext(buf, os, runparams);
return;
}
- Inset * inset = owner_->getInset(i);
- BOOST_ASSERT(inset);
-
// FIXME: move this to InsetNewline::latex
if (inset->lyxCode() == NEWLINE_CODE) {
// newlines are handled differently here than
}
-void Paragraph::Private::simpleTeXSpecialChar(
+void Paragraph::Private::latexSpecialChar(
odocstream & os,
OutputParams & runparams,
Font & running_font,
Change & running_change,
+ Layout const & style,
pos_type & i,
- unsigned int & column,
- value_type const c)
+ unsigned int & column)
{
+ value_type const c = getChar(i);
+
+ if (style.pass_thru) {
+ if (c != '\0')
+ // FIXME UNICODE: This can fail if c cannot
+ // be encoded in the current encoding.
+ os.put(c);
+ return;
+ }
+
if (runparams.verbatim) {
os.put(c);
return;
}
+ if (lyxrc.fontenc == "T1" && latexSpecialT1(c, os, i, column))
+ return;
+
+ if (running_font.family() == Font::TYPEWRITER_FAMILY
+ && latexSpecialTypewriter(c, os, i, column))
+ return;
+
+ // Otherwise, we use what LaTeX provides us.
switch (c) {
case '\\':
os << "\\textbackslash{}";
column += 15;
break;
-
- case '|':
case '<':
+ os << "\\textless{}";
+ column += 10;
+ break;
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;
- }
+ os << "\\textgreater{}";
+ column += 13;
break;
-
- case '-': // "--" in Typewriter mode -> "-{}-"
- if (i <= size() - 2 &&
- getChar(i + 1) == '-' &&
- running_font.family() == Font::TYPEWRITER_FAMILY) {
- os << "-{}";
- column += 2;
- } else {
- os << '-';
- }
+ case '|':
+ os << "\\textbar{}";
+ column += 9;
+ break;
+ case '-':
+ os << '-';
break;
-
case '\"':
os << "\\char`\\\"{}";
column += 9;
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.
+ if (latexSpecialPhrase(os, i, column))
+ return;
- // 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;
+ if (c == '\0')
+ return;
- 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;
+ 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;
}
}
-
- 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;
- 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;
- }
+ 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;
}
}
+bool Paragraph::Private::latexSpecialT1(char_type const c, odocstream & os,
+ pos_type & i, unsigned int & column)
+{
+ switch (c) {
+ case '>':
+ case '<':
+ os.put(c);
+ // In T1 encoding, these characters exist
+ // but we should avoid ligatures
+ if (i + 1 > size() || getChar(i + 1) != c)
+ return true;
+ os << "\\,{}";
+ column += 3;
+ // Alternative code:
+ //os << "\\textcompwordmark{}";
+ //column += 19;
+ return true;
+ case '|':
+ os.put(c);
+ return true;
+ default:
+ return false;
+ }
+}
+
+
+bool Paragraph::Private::latexSpecialTypewriter(char_type const c, odocstream & os,
+ pos_type & i, unsigned int & column)
+{
+ switch (c) {
+ case '-':
+ if (i + 1 < size() && getChar(i + 1) == '-') {
+ // "--" in Typewriter mode -> "-{}-"
+ os << "-{}";
+ column += 2;
+ } else
+ os << '-';
+ return true;
+
+ // I assume this is hack treating typewriter as verbatim
+ // FIXME UNICODE: This can fail if c cannot be encoded
+ // in the current encoding.
+
+ case '\0':
+ return true;
+
+ // Those characters are not directly supported.
+ case '\\':
+ case '\"':
+ case '$': case '&':
+ case '%': case '#': case '{':
+ case '}': case '_':
+ case '~':
+ case '^':
+ case '*': case '[':
+ case ' ':
+ return false;
+
+ default:
+ // With Typewriter font, these characters exist.
+ os.put(c);
+ return true;
+ }
+}
+
+
+bool Paragraph::Private::latexSpecialPhrase(odocstream & os, pos_type & i,
+ unsigned int & column)
+{
+ // 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
+
+ for (size_t pnr = 0; pnr < phrases_nr; ++pnr) {
+ if (!isTextAt(special_phrases[pnr].phrase, i))
+ continue;
+ os << special_phrases[pnr].macro;
+ i += special_phrases[pnr].phrase.length() - 1;
+ column += special_phrases[pnr].macro.length() - 1;
+ return true;
+ }
+ return false;
+}
+
+
void Paragraph::Private::validate(LaTeXFeatures & features,
Layout const & layout) const
{
/////////////////////////////////////////////////////////////////////
Paragraph::Paragraph()
- : begin_of_body_(0), d(new Paragraph::Private(this))
+ : d(new Paragraph::Private(this))
{
itemdepth = 0;
d->params_.clear();
+ text_.reserve(100);
}
Paragraph::Paragraph(Paragraph const & par)
- : itemdepth(par.itemdepth),
- layout_(par.layout_),
- text_(par.text_), begin_of_body_(par.begin_of_body_),
+ : itemdepth(par.itemdepth), text_(par.text_),
d(new Paragraph::Private(*par.d, this))
{
}
// needed as we will destroy the private part before copying it
if (&par != this) {
itemdepth = par.itemdepth;
- layout_ = par.layout();
text_ = par.text_;
- begin_of_body_ = par.begin_of_body_;
delete d;
d = new Private(*par.d, this);
}
+void Paragraph::appendChar(value_type c, Font const & font,
+ Change const & change)
+{
+ // track change
+ d->changes_.insert(change, text_.size());
+ // when appending characters, no need to update tables
+ text_.push_back(c);
+ setFont(text_.size() - 1, font);
+}
+
+
+void Paragraph::appendString(docstring const & s, Font const & font,
+ Change const & change)
+{
+ size_t end = s.size();
+ size_t oldsize = text_.size();
+ size_t newsize = oldsize + end;
+ size_t capacity = text_.capacity();
+ if (newsize >= capacity)
+ text_.reserve(std::max(capacity + 100, newsize));
+
+ // FIXME: Optimize this!
+ for (pos_type i = 0; i != end; ++i) {
+ // track change
+ d->changes_.insert(change, i);
+ // when appending characters, no need to update tables
+ text_.push_back(s[i]);
+ }
+ d->fontlist_.setRange(oldsize, newsize, font);
+}
+
+
void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
bool trackChanges)
{
pos_type const body_pos = beginOfBody();
if (pos < body_pos)
- font.realize(layout_->labelfont);
+ font.realize(d->layout_->labelfont);
else
- font.realize(layout_->font);
+ font.realize(d->layout_->font);
font.realize(outerfont);
font.realize(bparams.getFont());
pos_type Paragraph::beginOfBody() const
{
- return begin_of_body_;
+ return d->begin_of_body_;
}
void Paragraph::setBeginOfBody()
{
if (layout()->labeltype != LABEL_MANUAL) {
- begin_of_body_ = 0;
+ d->begin_of_body_ = 0;
return;
}
}
}
- begin_of_body_ = i;
-}
-
-
-// returns -1 if inset not found
-int Paragraph::getPositionOfInset(Inset const * inset) const
-{
- // Find the entry.
- InsetList::const_iterator it = d->insetlist_.begin();
- InsetList::const_iterator end = d->insetlist_.end();
- for (; it != end; ++it)
- if (it->inset == inset)
- return it->pos;
- return -1;
+ d->begin_of_body_ = i;
}
} // namespace anon
-// This could go to ParagraphParameters if we want to
-int Paragraph::startTeXParParams(BufferParams const & bparams,
+int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
odocstream & os, TexRow & texrow,
bool moving_arg) const
{
int column = 0;
- if (params().noindent()) {
+ if (params_.noindent()) {
os << "\\noindent ";
column += 10;
}
- LyXAlignment const curAlign = params().align();
+ LyXAlignment const curAlign = params_.align();
- if (curAlign == layout()->align)
+ if (curAlign == layout_->align)
return column;
switch (curAlign) {
break;
case LYX_ALIGN_LEFT: {
string output;
- if (getParLanguage(bparams)->babel() != "hebrew")
- output = corrected_env("\\begin", "flushleft", ownerCode());
+ if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+ output = corrected_env("\\begin", "flushleft", owner_->ownerCode());
else
- output = corrected_env("\\begin", "flushright", ownerCode());
+ output = corrected_env("\\begin", "flushright", owner_->ownerCode());
os << from_ascii(output);
adjust_row_column(output, texrow, column);
break;
} case LYX_ALIGN_RIGHT: {
string output;
- if (getParLanguage(bparams)->babel() != "hebrew")
- output = corrected_env("\\begin", "flushright", ownerCode());
+ if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+ output = corrected_env("\\begin", "flushright", owner_->ownerCode());
else
- output = corrected_env("\\begin", "flushleft", ownerCode());
+ output = corrected_env("\\begin", "flushleft", owner_->ownerCode());
os << from_ascii(output);
adjust_row_column(output, texrow, column);
break;
} case LYX_ALIGN_CENTER: {
string output;
- output = corrected_env("\\begin", "center", ownerCode());
+ output = corrected_env("\\begin", "center", owner_->ownerCode());
os << from_ascii(output);
adjust_row_column(output, texrow, column);
break;
}
-// This could go to ParagraphParameters if we want to
-int Paragraph::endTeXParParams(BufferParams const & bparams,
+int Paragraph::Private::endTeXParParams(BufferParams const & bparams,
odocstream & os, TexRow & texrow,
bool moving_arg) const
{
int column = 0;
- switch (params().align()) {
+ switch (params_.align()) {
case LYX_ALIGN_NONE:
case LYX_ALIGN_BLOCK:
case LYX_ALIGN_LAYOUT:
break;
}
- switch (params().align()) {
+ switch (params_.align()) {
case LYX_ALIGN_NONE:
case LYX_ALIGN_BLOCK:
case LYX_ALIGN_LAYOUT:
break;
case LYX_ALIGN_LEFT: {
string output;
- if (getParLanguage(bparams)->babel() != "hebrew")
- output = corrected_env("\n\\par\\end", "flushleft", ownerCode());
+ if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+ output = corrected_env("\n\\par\\end", "flushleft", owner_->ownerCode());
else
- output = corrected_env("\n\\par\\end", "flushright", ownerCode());
+ output = corrected_env("\n\\par\\end", "flushright", owner_->ownerCode());
os << from_ascii(output);
adjust_row_column(output, texrow, column);
break;
} case LYX_ALIGN_RIGHT: {
string output;
- if (getParLanguage(bparams)->babel() != "hebrew")
- output = corrected_env("\n\\par\\end", "flushright", ownerCode());
+ if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+ output = corrected_env("\n\\par\\end", "flushright", owner_->ownerCode());
else
- output = corrected_env("\n\\par\\end", "flushleft", ownerCode());
+ output = corrected_env("\n\\par\\end", "flushleft", owner_->ownerCode());
os << from_ascii(output);
adjust_row_column(output, texrow, column);
break;
} case LYX_ALIGN_CENTER: {
string output;
- output = corrected_env("\n\\par\\end", "center", ownerCode());
+ output = corrected_env("\n\\par\\end", "center", owner_->ownerCode());
os << from_ascii(output);
adjust_row_column(output, texrow, column);
break;
// This one spits out the text of the paragraph
-bool Paragraph::simpleTeXOnePar(Buffer const & buf,
+bool Paragraph::latex(Buffer const & buf,
BufferParams const & bparams,
Font const & outerfont,
odocstream & os, TexRow & texrow,
++column;
}
if (!asdefault)
- column += startTeXParParams(bparams, os, texrow,
+ column += d->startTeXParParams(bparams, os, texrow,
runparams.moving_arg);
}
}
if (!asdefault)
- column += startTeXParParams(bparams, os,
+ column += d->startTeXParParams(bparams, os,
texrow,
runparams.moving_arg);
}
++column;
- value_type const c = getChar(i);
-
// Fully instantiated font
Font const font = getFont(bparams, i, outerfont);
}
}
+ value_type const c = getChar(i);
+
// Do we need to change font?
if ((font != running_font ||
font.language() != running_font.language()) &&
}
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
- // simpleTeXSpecialChars ignores spaces if
+ // latexSpecialChar ignores spaces if
// style->pass_thru is false.
if (i != body_pos - 1) {
if (d->simpleTeXBlanks(
*(runparams.encoding), os, texrow,
- i, column, font, *style))
+ i, column, font, *style)) {
// A surrogate pair was output. We
- // must not call simpleTeXSpecialChars
- // in this iteration, since
- // simpleTeXBlanks incremented i, and
- // simpleTeXSpecialChars would output
+ // must not call latexSpecialChar
+ // in this iteration, since it would output
// the combining character again.
+ ++i;
continue;
+ }
}
}
rp.free_spacing = style->free_spacing;
rp.local_font = &font;
rp.intitle = style->intitle;
- d->simpleTeXSpecialChars(buf, bparams, os,
+
+ // 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 == Paragraph::META_INSET)
+ d->latexInset(buf, bparams, os,
texrow, rp, running_font,
basefont, outerfont, open_font,
- runningChange, *style, i, column, c);
+ runningChange, *style, i, column);
+ else
+ d->latexSpecialChar(os, rp, running_font, runningChange,
+ *style, i, column);
// Set the encoding to that returned from simpleTeXSpecialChars (see
// comment for encoding member in OutputParams.h)
}
if (!asdefault) {
- column += endTeXParParams(bparams, os, texrow,
+ column += d->endTeXParParams(bparams, os, texrow,
runparams.moving_arg);
}
LayoutPtr const & Paragraph::layout() const
{
- return layout_;
+ return d->layout_;
}
void Paragraph::layout(LayoutPtr const & new_layout)
{
- layout_ = new_layout;
+ d->layout_ = new_layout;
}