#include "BufferParams.h"
#include "Changes.h"
#include "Counters.h"
-#include "Encoding.h"
+#include "BufferEncodings.h"
#include "InsetList.h"
#include "Language.h"
#include "LaTeXFeatures.h"
///
void result(SpellChecker::Result r) { result_ = r; }
///
- bool inside(pos_type pos) const { return range_.inside(pos); }
+ bool contains(pos_type pos) const { return range_.contains(pos); }
///
bool covered(FontSpan const & r) const
{
// 2. last of new range inside current range or
// 3. first of current range inside new range or
// 4. last of current range inside new range
- return range_.inside(r.first) || range_.inside(r.last) ||
- r.inside(range_.first) || r.inside(range_.last);
+ //FIXME: is this the same as !range_.intersect(r).empty() ?
+ return range_.contains(r.first) || range_.contains(r.last) ||
+ r.contains(range_.first) || r.contains(range_.last);
}
///
void shift(pos_type pos, int offset)
RangesIterator et = ranges_.end();
RangesIterator it = ranges_.begin();
for (; it != et; ++it) {
- if(it->inside(pos)) {
+ if(it->contains(pos)) {
return it->result();
}
}
RangesIterator et = ranges_.end();
RangesIterator it = ranges_.begin();
for (; it != et; ++it) {
- if(it->inside(pos)) {
+ if(it->contains(pos)) {
return it->range();
}
}
class Paragraph::Private
{
+ // Enforce our own "copy" constructor by declaring the standard one and
+ // the assignment operator private without implementing them.
+ Private(Private const &);
+ Private & operator=(Private const &);
public:
///
Private(Paragraph * owner, Layout const & layout);
otexstream & os,
pos_type i,
unsigned int & column);
- ///
- bool latexSpecialTypewriter(
- char_type const c,
- otexstream & os,
- pos_type i,
- unsigned int & column);
- ///
- bool latexSpecialPhrase(
- otexstream & os,
- pos_type & i,
- pos_type end_pos,
- unsigned int & column,
- OutputParams const & runparams);
///
void validate(LaTeXFeatures & features) const;
bool onlyText(Buffer const & buf, Font const & outerfont,
pos_type initial) const;
- /// match a string against a particular point in the paragraph
- bool isTextAt(string const & str, pos_type pos) const;
-
/// a vector of speller skip positions
typedef vector<FontSpan> SkipPositions;
typedef SkipPositions::const_iterator SkipPositionsIterator;
TextContainer text_;
typedef set<docstring> Words;
- typedef map<Language, Words> LangWordsMap;
+ typedef map<string, Words> LangWordsMap;
///
LangWordsMap words_;
///
};
-namespace {
-
-struct special_phrase {
- string phrase;
- docstring macro;
- bool builtin;
-};
-
-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 },
-};
-
-size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase);
-
-} // namespace anon
-
-
Paragraph::Private::Private(Paragraph * owner, Layout const & layout)
: owner_(owner), inset_owner_(0), id_(-1), begin_of_body_(0), layout_(&layout)
{
// 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.
+// However, this per-session id is used in LFUN_PARAGRAPH_GOTO to
+// switch to a different buffer, as used in the outliner for instance.
static int paragraph_id = -1;
Paragraph::Private::Private(Private const & p, Paragraph * owner)
}
+void Paragraph::addChangesToBuffer(Buffer const & buf) const
+{
+ d->changes_.updateBuffer(buf);
+}
+
+
+bool Paragraph::isChangeUpdateRequired() const
+{
+ return d->changes_.isUpdateRequired();
+}
+
+
bool Paragraph::isDeleted(pos_type start, pos_type end) const
{
LASSERT(start >= 0 && start <= size(), return false);
if (!trackChanges)
return true;
- Change const change = d->changes_.lookup(size());
+ Change const & change = d->changes_.lookup(size());
return change.inserted() && change.currentAuthor();
}
Change const & Paragraph::lookupChange(pos_type pos) const
{
- LBUFERR(pos >= 0 && pos <= size(),
- _("Invalid position given to lookupChange()"));
+ LBUFERR(pos >= 0 && pos <= size());
return d->changes_.lookup(pos);
}
bool Paragraph::insertInset(pos_type pos, Inset * inset,
- Change const & change)
+ Font const & font, Change const & change)
{
LASSERT(inset, return false);
LASSERT(pos >= 0 && pos <= size(), return false);
// Some insets require run of spell checker
requestSpellCheck(pos);
+ setFont(pos, font);
return true;
}
{
// FIXME: modifying i here is not very nice...
- // We only arrive here when a proper language for character text_[i] has
- // not been specified (i.e., it could not be translated in the current
- // latex encoding) or its latex translation has been forced, and it
- // belongs to a known script.
+ // We only arrive here when character text_[i] could not be translated
+ // into the current latex encoding (or its latex translation has been forced,)
+ // and it belongs to a known script.
+ // TODO: We need \textcyr and \textgreek wrappers also for characters
+ // that can be encoded in the "LaTeX encoding" but not in the
+ // current *font encoding*.
+ // (See #9681 for details and test)
// Parameter ltx contains the latex translation of text_[i] as specified
// in the unicodesymbols file and is something like "\textXXX{<spec>}".
// The latex macro name "textXXX" specifies the script to which text_[i]
bool closing_brace = true;
if (script == "textgreek" && encoding.latexName() == "iso-8859-7") {
// Correct encoding is being used, so we can avoid \textgreek.
+ // TODO: wrong test: we need to check the *font encoding*
+ // (i.e. the active language and its FontEncoding tag)
+ // instead of the LaTeX *input encoding*!
+ // See #9637 for details and test-cases.
pos = brace1 + 1;
length -= pos;
closing_brace = false;
}
-bool Paragraph::Private::isTextAt(string const & str, pos_type pos) const
-{
- pos_type const len = str.length();
-
- // is the paragraph large enough?
- if (pos + len > int(text_.size()))
- return false;
-
- // does the wanted text start at point?
- for (string::size_type i = 0; i < str.length(); ++i) {
- // Caution: direct comparison of characters works only
- // because str is pure ASCII.
- if (str[i] != text_[pos + i])
- return false;
- }
-
- return fontlist_.hasChangeInRange(pos, len);
-}
-
-
void Paragraph::Private::latexInset(BufferParams const & bparams,
otexstream & os,
OutputParams & runparams,
unsigned int & column)
{
Inset * inset = owner_->getInset(i);
- LBUFERR(inset, from_ascii(""));
+ LBUFERR(inset);
if (style.pass_thru) {
odocstringstream ods;
}
// FIXME: move this to InsetNewline::latex
- if (inset->lyxCode() == NEWLINE_CODE) {
+ if (inset->lyxCode() == NEWLINE_CODE || inset->lyxCode() == SEPARATOR_CODE) {
// newlines are handled differently here than
// the default in simpleTeXSpecialChars().
if (!style.newline_allowed) {
char_type const c = (runparams.use_polyglossia) ?
owner_->getUChar(bparams, i) : text_[i];
- if (style.pass_thru || runparams.pass_thru) {
+ if (style.pass_thru || runparams.pass_thru
+ || contains(style.pass_thru_chars, c)
+ || contains(runparams.pass_thru_chars, c)) {
if (c != '\0') {
Encoding const * const enc = runparams.encoding;
if (enc && !enc->encodable(c))
return;
// If T1 font encoding is used, use the special
// characters it provides.
- // NOTE: some languages reset the font encoding
- // internally
+ // NOTE: Some languages reset the font encoding internally to a
+ // non-standard font encoding. If we are using such a language,
+ // we do not output special T1 chars.
if (!runparams.inIPA && !running_font.language()->internalFontEncoding()
- && lyxrc.fontenc == "T1" && latexSpecialT1(c, os, i, column))
- return;
-
- // \tt font needs special treatment
- if (!runparams.inIPA
- && running_font.fontInfo().family() == TYPEWRITER_FAMILY
- && latexSpecialTypewriter(c, os, i, column))
+ && bparams.font_encoding() == "T1" && latexSpecialT1(c, os, i, column))
return;
// Otherwise, we use what LaTeX provides us.
break;
case '-':
os << '-';
+ if (i + 1 < static_cast<pos_type>(text_.size()) &&
+ (end_pos == -1 || i + 1 < end_pos) &&
+ text_[i+1] == '-') {
+ // Prevent "--" becoming an endash and "---" becoming
+ // an emdash.
+ // Within \ttfamily, "--" is merged to "-" (no endash)
+ // so we avoid this rather irritating ligature as well
+ os << "{}";
+ column += 2;
+ }
break;
case '\"':
os << "\\char`\\\"{}";
break;
default:
- // LyX, LaTeX etc.
- if (latexSpecialPhrase(os, i, end_pos, column, runparams))
- return;
-
if (c == '\0')
return;
docstring nextlatex;
bool nexttipas = false;
string nexttipashortcut;
- if (next != '\0' && next != META_INSET) {
+ if (next != '\0' && next != META_INSET && encoding.encodable(next)) {
nextlatex = encoding.latexChar(next).first;
if (runparams.inIPA) {
nexttipashortcut = Encodings::TIPAShortcut(next);
}
-bool Paragraph::Private::latexSpecialTypewriter(char_type const c, otexstream & os,
- pos_type i, unsigned int & column)
-{
- switch (c) {
- case '-':
- // within \ttfamily, "--" is merged to "-" (no endash)
- // so we avoid this rather irritating ligature
- if (i + 1 < int(text_.size()) && text_[i + 1] == '-') {
- os << "-{}";
- column += 2;
- } else
- os << '-';
- return true;
-
- // everything else has to be checked separately
- // (depending on the encoding)
- default:
- return false;
- }
-}
-
-
-/// \param end_pos
-/// If [start_pos, end_pos) does not include entirely the special phrase, then
-/// do not apply the macro transformation.
-bool Paragraph::Private::latexSpecialPhrase(otexstream & os, pos_type & i, pos_type end_pos,
- unsigned int & column, OutputParams const & runparams)
-{
- // 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)
- || (end_pos != -1 && i + int(special_phrases[pnr].phrase.size()) > end_pos))
- continue;
- if (runparams.moving_arg)
- os << "\\protect";
- 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) const
{
if (layout_->inpreamble && inset_owner_) {
bool const is_command = layout_->latextype == LATEX_COMMAND;
Buffer const & buf = inset_owner_->buffer();
- BufferParams const & bp = buf.params();
+ BufferParams const & bp = features.runparams().is_child
+ ? buf.masterParams() : buf.params();
Font f;
TexRow texrow;
// Using a string stream here circumvents the encoding
}
}
string const snippet = to_utf8(ods.str());
- features.addPreambleSnippet(snippet);
+ features.addPreambleSnippet(snippet, true);
}
}
// then the contents
for (pos_type i = 0; i < int(text_.size()) ; ++i) {
- for (size_t pnr = 0; pnr < phrases_nr; ++pnr) {
- if (!special_phrases[pnr].builtin
- && isTextAt(special_phrases[pnr].phrase, i)) {
- features.require(special_phrases[pnr].phrase);
- break;
- }
- }
- Encodings::validate(text_[i], features);
+ BufferEncodings::validate(text_[i], features);
}
}
int column = 0;
for (pos_type i = 0; i <= size(); ++i) {
- Change const change = lookupChange(i);
+ Change const & change = lookupChange(i);
if (change != running_change)
flushString(os, write_buffer);
Changes::lyxMarkChange(os, bparams, column, running_change, change);
os << "\n\\end_inset\n\n";
column = 0;
}
+ // FIXME This can be removed again once the mystery
+ // crash has been resolved.
+ os << flush;
}
break;
case '\\':
flushString(os, write_buffer);
os << "\n\\end_layout\n";
+ // FIXME This can be removed again once the mystery
+ // crash has been resolved.
+ os << flush;
}
}
-bool Paragraph::insertInset(pos_type pos, Inset * inset,
- Font const & font, Change const & change)
-{
- bool const success = insertInset(pos, inset, change);
- // Set the font/language of the inset...
- setFont(pos, font);
- return success;
-}
-
-
void Paragraph::resetFonts(Font const & font)
{
d->fontlist_.clear();
{
if (pos > size()) {
LYXERR0("pos: " << pos << " size: " << size());
- LBUFERR(false, _("Invalid position."));
+ LBUFERR(false);
}
FontList::const_iterator cit = d->fontlist_.fontIterator(pos);
FontSpan Paragraph::fontSpan(pos_type pos) const
{
- LBUFERR(pos <= size(), _("Invalid position"));
+ LBUFERR(pos <= size());
- // Last position is a special case. I suspect that it would
- // actually make sense to extend the last font span to cover
- // the last character (JMarc)
if (pos == size())
return FontSpan(pos, pos);
Font const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
Font const & outerfont) const
{
- LBUFERR(pos >= 0, _("Invalid position."));
+ LBUFERR(pos >= 0);
Font font = getFontSettings(bparams, pos);
char_type Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
{
char_type c = d->text_[pos];
- if (!lyxrc.rtl_support || !getFontSettings(bparams, pos).isRightToLeft())
+ if (!getFontSettings(bparams, pos).isRightToLeft())
return c;
// FIXME: The arabic special casing is due to the difference of arabic
docstring parent(fmt, i + 1, j - i - 1);
docstring label = from_ascii("??");
if (tclass.hasLayout(parent))
- docstring label = expandParagraphLabel(tclass[parent], bparams,
+ label = expandParagraphLabel(tclass[parent], bparams,
process_appendix);
fmt = docstring(fmt, 0, i) + label
+ docstring(fmt, j + 1, docstring::npos);
// remove unnecessary getChar() calls
pos_type i = 0;
pos_type end = size();
- if (i < end && !isNewline(i)) {
+ if (i < end && !(isNewline(i) || isEnvSeparator(i))) {
++i;
- char_type previous_char = 0;
- char_type temp = 0;
if (i < end) {
- previous_char = d->text_[i];
- if (!isNewline(i)) {
+ char_type previous_char = d->text_[i];
+ if (!(isNewline(i) || isEnvSeparator(i))) {
++i;
while (i < end && previous_char != ' ') {
- temp = d->text_[i];
- if (isNewline(i))
+ char_type temp = d->text_[i];
+ if (isNewline(i) || isEnvSeparator(i))
break;
++i;
previous_char = temp;
}
-string const corrected_env(string const & suffix, string const & env,
- InsetCode code, bool const lastpar)
+bool corrected_env(otexstream & os, string const & suffix, string const & env,
+ InsetCode code, bool const lastpar, int & col)
{
- string output = suffix + "{";
+ string macro = suffix + "{";
if (noTrivlistCentering(code)) {
if (lastpar) {
// the last paragraph in non-trivlist-aligned
// context is special (to avoid unwanted whitespace)
- if (suffix == "\\begin")
- return "\\" + correction(env) + "{}";
- return string();
+ if (suffix == "\\begin") {
+ macro = "\\" + correction(env) + "{}";
+ os << from_ascii(macro);
+ col += macro.size();
+ return true;
+ }
+ return false;
}
- output += correction(env);
+ macro += correction(env);
} else
- output += env;
- output += "}";
- if (suffix == "\\begin")
- output += "\n";
- return output;
-}
-
-
-void adjust_column(string const & str, int & column)
-{
- if (!contains(str, "\n"))
- column += str.size();
- else {
- string tmp;
- column = rsplit(str, tmp, '\n').size();
+ macro += env;
+ macro += "}";
+ if (suffix == "\\par\\end") {
+ os << breakln;
+ col = 0;
+ }
+ os << from_ascii(macro);
+ col += macro.size();
+ if (suffix == "\\begin") {
+ os << breakln;
+ col = 0;
}
+ return true;
}
} // namespace anon
{
int column = 0;
- if (params_.noindent() && !layout_->pass_thru) {
+ bool canindent =
+ (bparams.paragraph_separation == BufferParams::ParagraphIndentSeparation) ?
+ (layout_->toggle_indent != ITOGGLE_NEVER) :
+ (layout_->toggle_indent == ITOGGLE_ALWAYS);
+
+ if (canindent && params_.noindent() && !layout_->pass_thru) {
os << "\\noindent ";
column += 10;
}
case LYX_ALIGN_DECIMAL:
break;
case LYX_ALIGN_LEFT: {
- string output;
if (owner_->getParLanguage(bparams)->babel() != "hebrew")
- output = corrected_env(begin_tag, "flushleft", code, lastpar);
+ corrected_env(os, begin_tag, "flushleft", code, lastpar, column);
else
- output = corrected_env(begin_tag, "flushright", code, lastpar);
- os << from_ascii(output);
- adjust_column(output, column);
+ corrected_env(os, begin_tag, "flushright", code, lastpar, column);
break;
} case LYX_ALIGN_RIGHT: {
- string output;
if (owner_->getParLanguage(bparams)->babel() != "hebrew")
- output = corrected_env(begin_tag, "flushright", code, lastpar);
+ corrected_env(os, begin_tag, "flushright", code, lastpar, column);
else
- output = corrected_env(begin_tag, "flushleft", code, lastpar);
- os << from_ascii(output);
- adjust_column(output, column);
+ corrected_env(os, begin_tag, "flushleft", code, lastpar, column);
break;
} case LYX_ALIGN_CENTER: {
- string output;
- output = corrected_env(begin_tag, "center", code, lastpar);
- os << from_ascii(output);
- adjust_column(output, column);
+ corrected_env(os, begin_tag, "center", code, lastpar, column);
break;
}
}
break;
}
- string output;
- string const end_tag = "\n\\par\\end";
+ bool output = false;
+ int col = 0;
+ string const end_tag = "\\par\\end";
InsetCode code = ownerCode();
bool const lastpar = runparams.isLastPar;
break;
case LYX_ALIGN_LEFT: {
if (owner_->getParLanguage(bparams)->babel() != "hebrew")
- output = corrected_env(end_tag, "flushleft", code, lastpar);
+ output = corrected_env(os, end_tag, "flushleft", code, lastpar, col);
else
- output = corrected_env(end_tag, "flushright", code, lastpar);
- os << from_ascii(output);
+ output = corrected_env(os, end_tag, "flushright", code, lastpar, col);
break;
} case LYX_ALIGN_RIGHT: {
if (owner_->getParLanguage(bparams)->babel() != "hebrew")
- output = corrected_env(end_tag, "flushright", code, lastpar);
+ output = corrected_env(os, end_tag, "flushright", code, lastpar, col);
else
- output = corrected_env(end_tag, "flushleft", code, lastpar);
- os << from_ascii(output);
+ output = corrected_env(os, end_tag, "flushleft", code, lastpar, col);
break;
} case LYX_ALIGN_CENTER: {
- output = corrected_env(end_tag, "center", code, lastpar);
- os << from_ascii(output);
+ corrected_env(os, end_tag, "center", code, lastpar, col);
break;
}
}
- return !output.empty() || lastpar;
+ return output || lastpar;
}
Change const & change = runparams.inDeletedInset
? runparams.changeOfDeletedInset : lookupChange(i);
- if (bparams.outputChanges && runningChange != change) {
+ if (bparams.output_changes && runningChange != change) {
if (open_font) {
column += running_font.latexWriteEndChanges(
os, bparams, runparams, basefont, basefont);
// do not output text which is marked deleted
// if change tracking output is disabled
- if (!bparams.outputChanges && change.deleted()) {
+ if (!bparams.output_changes && change.deleted()) {
continue;
}
if (allowcust && d->endTeXParParams(bparams, os, runparams)
&& runparams.encoding != prev_encoding) {
runparams.encoding = prev_encoding;
- if (!runparams.isFullUnicode())
- os << setEncoding(prev_encoding->iconvName());
+ os << setEncoding(prev_encoding->iconvName());
}
LYXERR(Debug::LATEX, "Paragraph::latex... done " << this);
}
-void doFontSwitch(XHTMLStream & xs, bool startrange,
- bool & flag, FontState curstate, std::string tag, std::string attr = "")
+namespace {
+void doFontSwitch(vector<html::FontTag> & tagsToOpen,
+ vector<html::EndFontTag> & tagsToClose,
+ bool & flag, FontState curstate, html::FontTypes type)
{
if (curstate == FONT_ON) {
- xs << html::StartTag(tag, attr);
+ tagsToOpen.push_back(html::FontTag(type));
flag = true;
- } else if (flag && !startrange) {
- xs << html::EndTag(tag);
+ } else if (flag) {
+ tagsToClose.push_back(html::EndFontTag(type));
flag = false;
}
}
+}
docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
{
docstring retval;
+ // track whether we have opened these tags
bool emph_flag = false;
bool bold_flag = false;
bool noun_flag = false;
bool dbar_flag = false;
bool sout_flag = false;
bool wave_flag = false;
+ // shape tags
+ bool shap_flag = false;
+ // family tags
+ bool faml_flag = false;
+ // size tags
+ bool size_flag = false;
Layout const & style = *d->layout_;
xs.startParagraph(allowEmpty());
- 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;
+ FontShape curr_fs = INHERIT_SHAPE;
+ FontFamily curr_fam = INHERIT_FAMILY;
+ FontSize curr_size = FONT_SIZE_INHERIT;
+
+ string const default_family =
+ buf.masterBuffer()->params().fonts_default_family;
+
+ vector<html::FontTag> tagsToOpen;
+ vector<html::EndFontTag> tagsToClose;
+
// 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.masterBuffer()->params(), i, outerfont);
- bool const at_start = (i == initial);
+ Font const font = getFont(buf.masterBuffer()->params(), i, outerfont);
// emphasis
FontState curstate = font.fontInfo().emph();
if (font_old.emph() != curstate)
- doFontSwitch(xs, at_start, emph_flag, curstate, "em");
+ doFontSwitch(tagsToOpen, tagsToClose, emph_flag, curstate, html::FT_EMPH);
// noun
curstate = font.fontInfo().noun();
if (font_old.noun() != curstate)
- doFontSwitch(xs, at_start, noun_flag, curstate, "dfn", "class='lyxnoun'");
+ doFontSwitch(tagsToOpen, tagsToClose, noun_flag, curstate, html::FT_NOUN);
// underbar
curstate = font.fontInfo().underbar();
if (font_old.underbar() != curstate)
- doFontSwitch(xs, at_start, ubar_flag, curstate, "u");
+ doFontSwitch(tagsToOpen, tagsToClose, ubar_flag, curstate, html::FT_UBAR);
// strikeout
curstate = font.fontInfo().strikeout();
if (font_old.strikeout() != curstate)
- doFontSwitch(xs, at_start, sout_flag, curstate, "del", "class='strikeout'");
-
- // HTML does not really have an equivalent of the next two, so we will just
- // output a single underscore with a class, and people can style it if they
- // wish to do so
+ doFontSwitch(tagsToOpen, tagsToClose, sout_flag, curstate, html::FT_SOUT);
// double underbar
curstate = font.fontInfo().uuline();
if (font_old.uuline() != curstate)
- doFontSwitch(xs, at_start, dbar_flag, curstate, "u", "class='dline'");
+ doFontSwitch(tagsToOpen, tagsToClose, dbar_flag, curstate, html::FT_DBAR);
// wavy line
curstate = font.fontInfo().uwave();
if (font_old.uwave() != curstate)
- doFontSwitch(xs, at_start, wave_flag, curstate, "u", "class='wavyline'");
+ doFontSwitch(tagsToOpen, tagsToClose, wave_flag, curstate, html::FT_WAVE);
// bold
- if (font_old.series() != font.fontInfo().series()) {
- if (font.fontInfo().series() == BOLD_SERIES) {
- xs << html::StartTag("b");
- bold_flag = true;
- } else if (bold_flag && i != initial) {
- xs << html::EndTag("b");
- bold_flag = false;
+ // a little hackish, but allows us to reuse what we have.
+ curstate = (font.fontInfo().series() == BOLD_SERIES ? FONT_ON : FONT_OFF);
+ if (font_old.series() != font.fontInfo().series())
+ doFontSwitch(tagsToOpen, tagsToClose, bold_flag, curstate, html::FT_BOLD);
+
+ // Font shape
+ curr_fs = font.fontInfo().shape();
+ FontShape old_fs = font_old.shape();
+ if (old_fs != curr_fs) {
+ if (shap_flag) {
+ switch (old_fs) {
+ case ITALIC_SHAPE:
+ tagsToClose.push_back(html::EndFontTag(html::FT_ITALIC));
+ break;
+ case SLANTED_SHAPE:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SLANTED));
+ break;
+ case SMALLCAPS_SHAPE:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SMALLCAPS));
+ break;
+ case UP_SHAPE:
+ case INHERIT_SHAPE:
+ break;
+ default:
+ // the other tags are for internal use
+ LATTEST(false);
+ break;
+ }
+ shap_flag = false;
+ }
+ switch (curr_fs) {
+ case ITALIC_SHAPE:
+ tagsToOpen.push_back(html::FontTag(html::FT_ITALIC));
+ shap_flag = true;
+ break;
+ case SLANTED_SHAPE:
+ tagsToOpen.push_back(html::FontTag(html::FT_SLANTED));
+ shap_flag = true;
+ break;
+ case SMALLCAPS_SHAPE:
+ tagsToOpen.push_back(html::FontTag(html::FT_SMALLCAPS));
+ shap_flag = true;
+ break;
+ case UP_SHAPE:
+ case INHERIT_SHAPE:
+ break;
+ default:
+ // the other tags are for internal use
+ LATTEST(false);
+ break;
+ }
+ }
+
+ // Font family
+ curr_fam = font.fontInfo().family();
+ FontFamily old_fam = font_old.family();
+ if (old_fam != curr_fam) {
+ if (faml_flag) {
+ switch (old_fam) {
+ case ROMAN_FAMILY:
+ tagsToClose.push_back(html::EndFontTag(html::FT_ROMAN));
+ break;
+ case SANS_FAMILY:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SANS));
+ break;
+ case TYPEWRITER_FAMILY:
+ tagsToClose.push_back(html::EndFontTag(html::FT_TYPE));
+ break;
+ case INHERIT_FAMILY:
+ break;
+ default:
+ // the other tags are for internal use
+ LATTEST(false);
+ break;
+ }
+ faml_flag = false;
+ }
+ switch (curr_fam) {
+ case ROMAN_FAMILY:
+ // we will treat a "default" font family as roman, since we have
+ // no other idea what to do.
+ if (default_family != "rmdefault" && default_family != "default") {
+ tagsToOpen.push_back(html::FontTag(html::FT_ROMAN));
+ faml_flag = true;
+ }
+ break;
+ case SANS_FAMILY:
+ if (default_family != "sfdefault") {
+ tagsToOpen.push_back(html::FontTag(html::FT_SANS));
+ faml_flag = true;
+ }
+ break;
+ case TYPEWRITER_FAMILY:
+ if (default_family != "ttdefault") {
+ tagsToOpen.push_back(html::FontTag(html::FT_TYPE));
+ faml_flag = true;
+ }
+ break;
+ case INHERIT_FAMILY:
+ break;
+ default:
+ // the other tags are for internal use
+ LATTEST(false);
+ break;
+ }
+ }
+
+ // Font size
+ curr_size = font.fontInfo().size();
+ FontSize old_size = font_old.size();
+ if (old_size != curr_size) {
+ if (size_flag) {
+ switch (old_size) {
+ case FONT_SIZE_TINY:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_TINY));
+ break;
+ case FONT_SIZE_SCRIPT:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_SCRIPT));
+ break;
+ case FONT_SIZE_FOOTNOTE:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_FOOTNOTE));
+ break;
+ case FONT_SIZE_SMALL:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_SMALL));
+ break;
+ case FONT_SIZE_LARGE:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGE));
+ break;
+ case FONT_SIZE_LARGER:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGER));
+ break;
+ case FONT_SIZE_LARGEST:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGEST));
+ break;
+ case FONT_SIZE_HUGE:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_HUGE));
+ break;
+ case FONT_SIZE_HUGER:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_HUGER));
+ break;
+ case FONT_SIZE_INCREASE:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_INCREASE));
+ break;
+ case FONT_SIZE_DECREASE:
+ tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_DECREASE));
+ break;
+ case FONT_SIZE_INHERIT:
+ case FONT_SIZE_NORMAL:
+ break;
+ default:
+ // the other tags are for internal use
+ LATTEST(false);
+ break;
+ }
+ size_flag = false;
+ }
+ switch (curr_size) {
+ case FONT_SIZE_TINY:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_TINY));
+ size_flag = true;
+ break;
+ case FONT_SIZE_SCRIPT:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_SCRIPT));
+ size_flag = true;
+ break;
+ case FONT_SIZE_FOOTNOTE:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_FOOTNOTE));
+ size_flag = true;
+ break;
+ case FONT_SIZE_SMALL:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_SMALL));
+ size_flag = true;
+ break;
+ case FONT_SIZE_LARGE:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGE));
+ size_flag = true;
+ break;
+ case FONT_SIZE_LARGER:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGER));
+ size_flag = true;
+ break;
+ case FONT_SIZE_LARGEST:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGEST));
+ size_flag = true;
+ break;
+ case FONT_SIZE_HUGE:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_HUGE));
+ size_flag = true;
+ break;
+ case FONT_SIZE_HUGER:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_HUGER));
+ size_flag = true;
+ break;
+ case FONT_SIZE_INCREASE:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_INCREASE));
+ size_flag = true;
+ break;
+ case FONT_SIZE_DECREASE:
+ tagsToOpen.push_back(html::FontTag(html::FT_SIZE_DECREASE));
+ size_flag = true;
+ break;
+ case FONT_SIZE_NORMAL:
+ case FONT_SIZE_INHERIT:
+ break;
+ default:
+ // the other tags are for internal use
+ LATTEST(false);
+ break;
}
}
+
// FIXME XHTML
// Other such tags? What about the other text ranges?
+ vector<html::EndFontTag>::const_iterator cit = tagsToClose.begin();
+ vector<html::EndFontTag>::const_iterator cen = tagsToClose.end();
+ for (; cit != cen; ++cit)
+ xs << *cit;
+
+ vector<html::FontTag>::const_iterator sit = tagsToOpen.begin();
+ vector<html::FontTag>::const_iterator sen = tagsToOpen.end();
+ for (; sit != sen; ++sit)
+ xs << *sit;
+
+ tagsToClose.clear();
+ tagsToOpen.clear();
+
Inset const * inset = getInset(i);
if (inset) {
if (!runparams.for_toc || inset->isInToc()) {
}
} else {
char_type c = getUChar(buf.masterBuffer()->params(), i);
-
- if (style.pass_thru || runparams.pass_thru)
- xs << c;
- else if (c == '-') {
- docstring str;
- int j = i + 1;
- if (j < size() && d->text_[j] == '-') {
- j += 1;
- if (j < size() && d->text_[j] == '-') {
- str += from_ascii("—");
- i += 2;
- } else {
- str += from_ascii("–");
- i += 1;
- }
- }
- 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::ESCAPE_NONE << str;
- } else
- xs << c;
+ xs << c;
}
font_old = font.fontInfo();
}
bool Paragraph::isHfill(pos_type pos) const
{
Inset const * inset = getInset(pos);
- return inset && (inset->lyxCode() == SPACE_CODE &&
- inset->isStretchableSpace());
+ return inset && inset->isHfill();
}
}
+bool Paragraph::isEnvSeparator(pos_type pos) const
+{
+ Inset const * inset = getInset(pos);
+ return inset && inset->lyxCode() == SEPARATOR_CODE;
+}
+
+
bool Paragraph::isLineSeparator(pos_type pos) const
{
char_type const c = d->text_[pos];
if ((nextpos == psize || isSpace(nextpos))
&& (pos == 0 || isSpace(prevpos)))
return false;
- return c == '\''
- || ((nextpos == psize || d->text_[nextpos] != '-')
- && (pos == 0 || d->text_[prevpos] != '-'));
+ return true;
}
-bool Paragraph::isSameSpellRange(pos_type pos1, pos_type pos2) const
+FontSpan const & Paragraph::getSpellRange(pos_type pos) const
{
- return pos1 == pos2
- || d->speller_state_.getRange(pos1) == d->speller_state_.getRange(pos2);
+ return d->speller_state_.getRange(pos);
}
bool Paragraph::isRTL(BufferParams const & bparams) const
{
- return lyxrc.rtl_support
- && getParLanguage(bparams)->rightToLeft()
+ return getParLanguage(bparams)->rightToLeft()
&& !inInset().getLayout().forceLTR();
}
}
-docstring Paragraph::asString(pos_type beg, pos_type end, int options) const
+docstring Paragraph::asString(pos_type beg, pos_type end, int options, const OutputParams *runparams) const
{
odocstringstream os;
|| (c == '\n' && (options & AS_STR_NEWLINES)))
os.put(c);
else if (c == META_INSET && (options & AS_STR_INSETS)) {
- getInset(i)->toString(os);
- if (getInset(i)->asInsetMath())
- os << " ";
+ if (c == META_INSET && (options & AS_STR_PLAINTEXT)) {
+ LASSERT(runparams != 0, return docstring());
+ getInset(i)->plaintext(os, *runparams);
+ } else {
+ getInset(i)->toString(os);
+ }
}
}
}
-void Paragraph::forToc(docstring & os, size_t maxlen) const
+void Paragraph::forOutliner(docstring & os, size_t const maxlen,
+ bool const shorten) const
{
+ size_t tmplen = shorten ? maxlen + 1 : maxlen;
if (!d->params_.labelString().empty())
os += d->params_.labelString() + ' ';
- for (pos_type i = 0; i < size() && os.length() < maxlen; ++i) {
+ for (pos_type i = 0; i < size() && os.length() < tmplen; ++i) {
if (isDeleted(i))
continue;
char_type const c = d->text_[i];
if (isPrintable(c))
os += c;
- else if (c == '\t' || c == '\n')
- os += ' ';
else if (c == META_INSET)
- getInset(i)->forToc(os, maxlen);
+ getInset(i)->forOutliner(os, tmplen, false);
}
-}
-
-
-docstring Paragraph::stringify(pos_type beg, pos_type end, int options,
- OutputParams const & runparams) const
-{
- odocstringstream os;
-
- if (beg == 0
- && options & AS_STR_LABEL
- && !d->params_.labelString().empty())
- os << d->params_.labelString() << ' ';
-
- OutputParams op = runparams;
- op.for_search = true;
-
- for (pos_type i = beg; i < end; ++i) {
- char_type const c = d->text_[i];
- if (isPrintable(c) || c == '\t'
- || (c == '\n' && (options & AS_STR_NEWLINES)))
- os.put(c);
- else if (c == META_INSET && (options & AS_STR_INSETS)) {
- getInset(i)->plaintext(os, op);
- }
- }
-
- return os.str();
+ if (shorten)
+ Text::shortenForOutliner(os, maxlen);
}
Inset const & Paragraph::inInset() const
{
- LBUFERR(d->inset_owner_, _("Paragraph not properly initialized"));
+ LBUFERR(d->inset_owner_);
return *d->inset_owner_;
}
}
-char_type Paragraph::transformChar(char_type c, pos_type pos) const
-{
- if (!Encodings::isArabicChar(c))
- return c;
-
- char_type prev_char = ' ';
- char_type next_char = ' ';
-
- for (pos_type i = pos - 1; i >= 0; --i) {
- char_type const par_char = d->text_[i];
- if (!Encodings::isArabicComposeChar(par_char)) {
- prev_char = par_char;
- break;
- }
- }
-
- for (pos_type i = pos + 1, end = size(); i < end; ++i) {
- char_type const par_char = d->text_[i];
- if (!Encodings::isArabicComposeChar(par_char)) {
- next_char = par_char;
- break;
- }
- }
-
- if (Encodings::isArabicChar(next_char)) {
- if (Encodings::isArabicChar(prev_char) &&
- !Encodings::isArabicSpecialChar(prev_char))
- return Encodings::transformChar(c, Encodings::FORM_MEDIAL);
- else
- return Encodings::transformChar(c, Encodings::FORM_INITIAL);
- } else {
- if (Encodings::isArabicChar(prev_char) &&
- !Encodings::isArabicSpecialChar(prev_char))
- return Encodings::transformChar(c, Encodings::FORM_FINAL);
- else
- return Encodings::transformChar(c, Encodings::FORM_ISOLATED);
- }
-}
-
-
bool Paragraph::brokenBiblio() const
{
// there is a problem if there is no bibitem at position 0 or
if (d->layout_->labeltype != LABEL_BIBLIO)
return 0;
- bool const track_changes = buffer.params().trackChanges;
+ bool const track_changes = buffer.params().track_changes;
int bibitem_pos = d->insetlist_.find(BIBITEM_CODE);
bool const hasbibitem0 = bibitem_pos == 0;
// these, which there should be.
// FIXME: why does it make sense to do that rather
// than keep the first? (JMarc)
- Inset * inset = d->insetlist_.release(bibitem_pos);
- eraseChar(bibitem_pos, track_changes);
+ Inset * inset = releaseInset(bibitem_pos);
d->insetlist_.begin()->inset = inset;
return -bibitem_pos;
}
inset = new InsetBibitem(const_cast<Buffer *>(&buffer),
InsetCommandParams(BIBITEM_CODE));
- insertInset(0, inset, Change(track_changes ? Change::INSERTED
+ Font font(inherit_font, buffer.params().language);
+ insertInset(0, inset, font, Change(track_changes ? Change::INSERTED
: Change::UNCHANGED));
return 1;
// process sequences of modified characters; in change
// tracking mode, this approach results in much better
// usability than changing case on a char-by-char basis
- docstring changes;
+ // We also need to track the current font, since font
+ // changes within sequences can occur.
+ vector<pair<char_type, Font> > changes;
- bool const trackChanges = bparams.trackChanges;
+ bool const trackChanges = bparams.track_changes;
bool capitalize = true;
}
if (oldChar != newChar) {
- changes += newChar;
+ changes.push_back(make_pair(newChar, getFontSettings(bparams, pos)));
if (pos != right - 1)
continue;
// step behind the changing area
int erasePos = pos - changes.size();
for (size_t i = 0; i < changes.size(); i++) {
- insertChar(pos, changes[i],
- getFontSettings(bparams,
- erasePos),
+ insertChar(pos, changes[i].first,
+ changes[i].second,
trackChanges);
if (!eraseChar(erasePos, trackChanges)) {
++erasePos;
void Paragraph::collectWords()
{
- pos_type n = size();
- for (pos_type pos = 0; pos < n; ++pos) {
+ for (pos_type pos = 0; pos < size(); ++pos) {
if (isWordSeparator(pos))
continue;
pos_type from = pos;
locateWord(from, pos, WHOLE_WORD);
- if ((pos - from) >= (int)lyxrc.completion_minlength) {
- docstring word = asString(from, pos, AS_STR_NONE);
- 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);
- }
+ // Work around MSVC warning: The statement
+ // if (pos < from + lyxrc.completion_minlength)
+ // triggers a signed vs. unsigned warning.
+ // I don't know why this happens, it could be a MSVC bug, or
+ // related to LLP64 (windows) vs. LP64 (unix) programming
+ // model, or the C++ standard might be ambigous in the section
+ // defining the "usual arithmetic conversions". However, using
+ // a temporary variable is safe and works on all compilers.
+ pos_type const endpos = from + lyxrc.completion_minlength;
+ if (pos < endpos)
+ continue;
+ FontList::const_iterator cit = d->fontlist_.fontIterator(from);
+ if (cit == d->fontlist_.end())
+ return;
+ Language const * lang = cit->font().language();
+ docstring const word = asString(from, pos, AS_STR_NONE);
+ d->words_[lang->lang()].insert(word);
}
}