#include "Language.h"
#include "LaTeXFeatures.h"
#include "Layout.h"
-#include "Length.h"
#include "Font.h"
#include "FontList.h"
#include "LyXRC.h"
#include "support/ExceptionMessage.h"
#include "support/gettext.h"
#include "support/lassert.h"
+#include "support/Length.h"
#include "support/lstrings.h"
#include "support/textutils.h"
#include "output_docbook.h"
+#include <algorithm>
#include <atomic>
#include <sstream>
#include <vector>
namespace lyx {
-namespace {
-
-/// Inset identifier (above 0x10ffff, for ucs-4)
-char_type const META_INSET = 0x200001;
-
-} // namespace
-
-
/////////////////////////////////////////////////////////////////////
//
// SpellResultRange
Ranges ranges_;
/// the area of the paragraph with pending spell check
FontSpan refresh_;
- bool needs_refresh_;
/// spell state cache version number
SpellChecker::ChangeNumber current_change_number_;
+ bool needs_refresh_;
void correctRangesAfterPos(pos_type pos, int offset)
Change & running_change,
Layout const & style,
pos_type & i,
- unsigned int & column);
+ unsigned int & column,
+ bool const fontswitch_inset,
+ bool const closeLanguage,
+ bool const lang_switched_at_inset);
///
void latexSpecialChar(
{
int numskips = 0;
while (it != et && it->first < start) {
- int skip = it->last - it->first + 1;
+ long skip = it->last - it->first + 1;
start += skip;
numskips += skip;
++it;
///
FontList fontlist_;
- ///
- int id_;
-
///
ParagraphParameters params_;
Layout const * layout_;
///
SpellCheckerState speller_state_;
+ ///
+ int id_;
};
Paragraph::Private::Private(Paragraph * owner, Layout const & layout)
- : owner_(owner), inset_owner_(nullptr), id_(-1), begin_of_body_(0), layout_(&layout)
+ : owner_(owner), inset_owner_(nullptr), begin_of_body_(0), layout_(&layout), id_(-1)
{
text_.reserve(100);
}
// LFUN_PARAGRAPH_GOTO to switch to a different buffer, for instance in the
// outliner.
// (thread-safe)
- static atomic_uint next_id(0);
+ static int next_id(0);
return next_id++;
}
Paragraph::Private::Private(Private const & p, Paragraph * owner)
: owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_),
- id_(make_id()),
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_)
+ layout_(p.layout_), id_(make_id())
{
requestSpellCheck(p.text_.size());
}
Paragraph::Private::Private(Private const & p, Paragraph * owner,
pos_type beg, pos_type end)
- : owner_(owner), inset_owner_(p.inset_owner_), id_(make_id()),
+ : owner_(owner), inset_owner_(p.inset_owner_),
params_(p.params_), changes_(p.changes_),
insetlist_(p.insetlist_, beg, end),
begin_of_body_(p.begin_of_body_), words_(p.words_),
- layout_(p.layout_)
+ layout_(p.layout_), id_(make_id())
{
if (beg >= pos_type(p.text_.size()))
return;
Change & running_change,
Layout const & style,
pos_type & i,
- unsigned int & column)
+ unsigned int & column,
+ bool const fontswitch_inset,
+ bool const closeLanguage,
+ bool const lang_switched_at_inset)
{
Inset * inset = owner_->getInset(i);
LBUFERR(inset);
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->inheritFont()) {
- bool needPar = false;
- bool closeLanguage = arabtex
- || basefont.isRightToLeft() == running_font.isRightToLeft();
- // We pass non_inherit_inset = true here since size switches
- // ought not to be terminated here (#8384).
- unsigned int count = running_font.latexWriteEndChanges(os,
- bparams, runparams, basefont, basefont,
- needPar, closeLanguage, true);
- 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());
- basefont.fontInfo().setSize(copy_font.fontInfo().size());
- // leave font open if language is still open
- open_font = (running_font.language() == basefont.language()
- || running_font.fontInfo().size() == basefont.fontInfo().size());
- if (closeLanguage)
- runparams.local_font = &basefont;
+ if (open_font && fontswitch_inset) {
+ bool lang_closed = false;
+ // Close language if needed
+ if (closeLanguage && !lang_switched_at_inset) {
+ // We need prev_font here as language changes directly at inset
+ // will only be started inside the inset.
+ Font const prev_font = (i > 0) ?
+ owner_->getFont(bparams, i - 1, outerfont)
+ : running_font;
+ Font tmpfont(basefont);
+ tmpfont.setLanguage(prev_font.language());
+ bool needPar = false;
+ unsigned int count = tmpfont.latexWriteEndChanges(os, bparams, runparams,
+ basefont, basefont,
+ needPar, closeLanguage);
+ column += count;
+ lang_closed = count > 0;
}
+ // Update the running_font, making sure, however,
+ // to leave the language as it was.
+ // 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());
+ OutputParams rp = runparams;
+ rp.encoding = basefont.language()->encoding();
+ // For these, we use switches, so they should be taken as
+ // base inside the inset.
+ basefont.fontInfo().setSize(copy_font.fontInfo().size());
+ basefont.fontInfo().setFamily(copy_font.fontInfo().family());
+ basefont.fontInfo().setSeries(copy_font.fontInfo().series());
+ // Now re-do font changes in a way needed here
+ // (using switches with multi-par insets)
+ InsetText const * textinset = inset->asInsetText();
+ bool const cprotect = textinset
+ ? textinset->hasCProtectContent(runparams.moving_arg)
+ && !textinset->text().isMainText()
+ : false;
+ unsigned int count2 = basefont.latexWriteStartChanges(os, bparams,
+ rp, running_font,
+ basefont, true,
+ cprotect);
+ open_font = true;
+ column += count2;
+ if (count2 == 0 && (lang_closed || lang_switched_at_inset))
+ // All fonts closed
+ open_font = false;
+ if (closeLanguage)
+ runparams.local_font = &basefont;
+ }
+
+ if (fontswitch_inset && !closeLanguage) {
+ // The directionality has been switched at inset.
+ // Force markup inside.
+ runparams.local_font = &basefont;
}
size_t const previous_row_count = os.texrow().rows();
// add location information and throw again.
e.par_id = id_;
e.pos = i;
- throw(e);
+ throw;
}
if (close)
pos_type body_pos = beginOfBody();
unsigned int column = 0;
- // If we are inside an inset, the real outerfont is local_font
- Font const real_outerfont = (runparams.local_font != nullptr)
+ // If we are inside an non inheritFont() inset, the real outerfont is local_font
+ Font const real_outerfont = (!inInset().inheritFont()
+ && runparams.local_font != nullptr)
? Font(runparams.local_font->fontInfo()) : outerfont;
if (body_pos > 0) {
++column;
// Fully instantiated font
- Font const current_font = getFont(bparams, i, outerfont);
+ Font current_font = getFont(bparams, i, outerfont);
+ // Previous font
+ Font const prev_font = (i > 0) ?
+ getFont(bparams, i - 1, outerfont)
+ : current_font;
Font const last_font = running_font;
bool const in_ct_deletion = (bparams.output_changes
&& runningChange == change
&& change.type == Change::DELETED
&& !os.afterParbreak());
+ // Insets where font switches are used (rather than font commands)
+ bool const fontswitch_inset =
+ c == META_INSET
+ && getInset(i)
+ && getInset(i)->allowMultiPar()
+ && getInset(i)->lyxCode() != ERT_CODE;
+
+ bool closeLanguage = false;
+ bool lang_switched_at_inset = false;
+ if (fontswitch_inset) {
+ // 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
+ // (= differing isRightToLeft()).
+ // ArabTeX, though, doesn't seem to handle this special behavior.
+ closeLanguage = basefont.isRightToLeft() == current_font.isRightToLeft()
+ || basefont.language()->lang() == "arabic_arabtex"
+ || current_font.language()->lang() == "arabic_arabtex";
+ // We need to check prev_font as language changes directly at inset
+ // will only be started inside the inset.
+ lang_switched_at_inset = prev_font.language() != current_font.language();
+ }
// Do we need to close the previous font?
+ bool langClosed = false;
if (open_font &&
- (current_font != running_font ||
- current_font.language() != running_font.language()))
+ ((current_font != running_font
+ || current_font.language() != running_font.language())
+ || (fontswitch_inset
+ && (current_font == prev_font))))
{
// ensure there is no open script-wrapper
if (!alien_script.empty()) {
os << '}';
column += 1;
}
+ if (closeLanguage)
+ // Force language closing
+ current_font.setLanguage(basefont.language());
+ Font const nextfont = (i == body_pos-1) ? basefont : current_font;
column += running_font.latexWriteEndChanges(
os, bparams, runparams, basefont,
- (i == body_pos-1) ? basefont : current_font,
- needPar);
+ nextfont, needPar);
if (in_ct_deletion) {
// We have to close and then reopen \lyxdeleted,
// as strikeout needs to be on lowest level.
column += Changes::latexMarkChange(os, bparams,
Change(Change::UNCHANGED), Change(Change::DELETED), rp);
}
- running_font = basefont;
open_font = false;
+ // Has the language been closed in the latexWriteEndChanges() call above?
+ langClosed = running_font.language() != basefont.language()
+ && running_font.language() != nextfont.language()
+ && (running_font.language()->encoding()->package() != Encoding::CJK);
+ running_font = basefont;
}
// if necessary, close language environment before opening CJK
}
// Switch file encoding if necessary (and allowed)
- if (!runparams.pass_thru && !style.pass_thru &&
+ if ((!fontswitch_inset || closeLanguage)
+ && !runparams.pass_thru && !style.pass_thru &&
runparams.encoding->package() != Encoding::none &&
current_font.language()->encoding()->package() != Encoding::none) {
pair<bool, int> const enc_switch =
current_font.language() != running_font.language())
&& i != body_pos - 1)
{
- if (in_ct_deletion) {
- // We have to close and then reopen \lyxdeleted,
- // as strikeout needs to be on lowest level.
- bool needPar = false;
- OutputParams rp = runparams;
- column += running_font.latexWriteEndChanges(
- os, bparams, rp, basefont,
- basefont, needPar);
- os << '}';
- column += 1;
- }
- odocstringstream ods;
- column += current_font.latexWriteStartChanges(ods, bparams,
- runparams, basefont,
- last_font);
- // Check again for display math in ulem commands as a
- // font change may also occur just before a math inset.
- if (runparams.inDisplayMath && !deleted_display_math
- && runparams.inulemcmd) {
- if (os.afterParbreak())
- os << "\\noindent";
- else
- os << "\\\\\n";
- }
- running_font = current_font;
- open_font = true;
- docstring fontchange = ods.str();
- // check whether the fontchange ends with a \\textcolor
- // modifier and the text starts with a space (bug 4473)
- docstring const last_modifier = rsplit(fontchange, '\\');
- if (prefixIs(last_modifier, from_ascii("textcolor")) && c == ' ')
- os << fontchange << from_ascii("{}");
- // check if the fontchange ends with a trailing blank
- // (like "\small " (see bug 3382)
- else if (suffixIs(fontchange, ' ') && c == ' ')
- os << fontchange.substr(0, fontchange.size() - 1)
- << from_ascii("{}");
- else
+ if (!fontswitch_inset) {
+ if (in_ct_deletion) {
+ // We have to close and then reopen \lyxdeleted,
+ // as strikeout needs to be on lowest level.
+ bool needPar = false;
+ OutputParams rp = runparams;
+ column += running_font.latexWriteEndChanges(
+ os, bparams, rp, basefont,
+ basefont, needPar);
+ os << '}';
+ column += 1;
+ }
+ otexstringstream ots;
+ InsetText const * textinset = inInset().asInsetText();
+ bool const cprotect = textinset
+ ? textinset->hasCProtectContent(runparams.moving_arg)
+ && !textinset->text().isMainText()
+ : false;
+ column += current_font.latexWriteStartChanges(ots, bparams,
+ runparams, basefont, last_font, false,
+ cprotect);
+ // Check again for display math in ulem commands as a
+ // font change may also occur just before a math inset.
+ if (runparams.inDisplayMath && !deleted_display_math
+ && runparams.inulemcmd) {
+ if (os.afterParbreak())
+ os << "\\noindent";
+ else
+ os << "\\\\\n";
+ }
+ running_font = current_font;
+ open_font = true;
+ docstring fontchange = ots.str();
os << fontchange;
- if (in_ct_deletion) {
- // We have to close and then reopen \lyxdeleted,
- // as strikeout needs to be on lowest level.
- OutputParams rp = runparams;
- column += Changes::latexMarkChange(os, bparams,
- Change(Change::UNCHANGED), change, rp);
+ // check whether the fontchange ends with a \\textcolor
+ // modifier and the text starts with a space. If so we
+ // need to add } in order to prevent \\textcolor from gobbling
+ // the space (bug 4473).
+ docstring const last_modifier = rsplit(fontchange, '\\');
+ if (prefixIs(last_modifier, from_ascii("textcolor")) && c == ' ')
+ os << from_ascii("{}");
+ else if (ots.terminateCommand())
+ os << termcmd;
+ if (in_ct_deletion) {
+ // We have to close and then reopen \lyxdeleted,
+ // as strikeout needs to be on lowest level.
+ OutputParams rp = runparams;
+ column += Changes::latexMarkChange(os, bparams,
+ Change(Change::UNCHANGED), change, rp);
+ }
+ } else {
+ running_font = current_font;
+ open_font = !langClosed;
}
}
incremented = true;
}
}
+ // We need to restore parts of this after insets with
+ // allowMultiPar() true
+ Font const save_basefont = basefont;
d->latexInset(bparams, os, rp, running_font,
basefont, real_outerfont, open_font,
- runningChange, style, i, column);
+ runningChange, style, i, column, fontswitch_inset,
+ closeLanguage, lang_switched_at_inset);
+ if (fontswitch_inset) {
+ if (open_font) {
+ bool needPar = false;
+ column += running_font.latexWriteEndChanges(
+ os, bparams, runparams,
+ basefont, basefont, needPar);
+ open_font = false;
+ }
+ basefont.fontInfo().setSize(save_basefont.fontInfo().size());
+ basefont.fontInfo().setFamily(save_basefont.fontInfo().family());
+ basefont.fontInfo().setSeries(save_basefont.fontInfo().series());
+ }
if (incremented)
--parInline;
// add location information and throw again.
e.par_id = id();
e.pos = i;
- throw(e);
+ throw;
}
}
}
class OptionalFontType {
public:
- bool has_value;
xml::FontTypes ft;
+ bool has_value;
- OptionalFontType(): has_value(false), ft(xml::FT_EMPH) {} // A possible value at random for ft.
- OptionalFontType(xml::FontTypes ft): has_value(true), ft(ft) {}
+ OptionalFontType(): ft(xml::FT_EMPH), has_value(false) {} // A possible value at random for ft.
+ OptionalFontType(xml::FontTypes ft): ft(ft), has_value(true) {}
};
OptionalFontType fontShapeToXml(FontShape fs)
switch (fm) {
case ROMAN_FAMILY:
return {xml::FT_ROMAN};
- break;
case SANS_FAMILY:
return {xml::FT_SANS};
- break;
case TYPEWRITER_FAMILY:
return {xml::FT_TYPE};
- break;
case INHERIT_FAMILY:
return {};
default:
}
}
-}// anonymous namespace
-
-
-void Paragraph::simpleDocBookOnePar(Buffer const & buf,
- XMLStream & xs,
- OutputParams const & runparams,
- Font const & outerfont,
- bool start_paragraph, bool close_paragraph,
- pos_type initial) const
+struct DocBookFontState
{
+ FontShape curr_fs = INHERIT_SHAPE;
+ FontFamily curr_fam = INHERIT_FAMILY;
+ FontSize curr_size = INHERIT_SIZE;
+
// track whether we have opened these tags
bool emph_flag = false;
bool bold_flag = false;
bool ubar_flag = false;
bool dbar_flag = false;
bool sout_flag = false;
+ bool xout_flag = false;
bool wave_flag = false;
// shape tags
bool shap_flag = false;
bool faml_flag = false;
// size tags
bool size_flag = false;
+};
- Layout const & style = *d->layout_;
-
- if (start_paragraph)
- xs.startDivision(allowEmpty());
-
- FontInfo font_old =
- style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
-
- FontShape curr_fs = INHERIT_SHAPE;
- FontFamily curr_fam = INHERIT_FAMILY;
- FontSize curr_size = INHERIT_SIZE;
-
- string const default_family =
- buf.masterBuffer()->params().fonts_default_family;
-
+std::tuple<vector<xml::FontTag>, vector<xml::EndFontTag>> computeDocBookFontSwitch(FontInfo const & font_old,
+ Font const & font,
+ std::string const & default_family,
+ DocBookFontState & fs)
+{
vector<xml::FontTag> tagsToOpen;
vector<xml::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 const font = getFont(buf.masterBuffer()->params(), i, outerfont);
-
- // emphasis
- FontState curstate = font.fontInfo().emph();
- if (font_old.emph() != curstate)
- doFontSwitchDocBook(tagsToOpen, tagsToClose, emph_flag, curstate, xml::FT_EMPH);
-
- // noun
- curstate = font.fontInfo().noun();
- if (font_old.noun() != curstate)
- doFontSwitchDocBook(tagsToOpen, tagsToClose, noun_flag, curstate, xml::FT_NOUN);
-
- // underbar
- curstate = font.fontInfo().underbar();
- if (font_old.underbar() != curstate)
- doFontSwitchDocBook(tagsToOpen, tagsToClose, ubar_flag, curstate, xml::FT_UBAR);
-
- // strikeout
- curstate = font.fontInfo().strikeout();
- if (font_old.strikeout() != curstate)
- doFontSwitchDocBook(tagsToOpen, tagsToClose, sout_flag, curstate, xml::FT_SOUT);
-
- // double underbar
- curstate = font.fontInfo().uuline();
- if (font_old.uuline() != curstate)
- doFontSwitchDocBook(tagsToOpen, tagsToClose, dbar_flag, curstate, xml::FT_DBAR);
-
- // wavy line
- curstate = font.fontInfo().uwave();
- if (font_old.uwave() != curstate)
- doFontSwitchDocBook(tagsToOpen, tagsToClose, wave_flag, curstate, xml::FT_WAVE);
-
- // bold
- // 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())
- doFontSwitchDocBook(tagsToOpen, tagsToClose, bold_flag, curstate, xml::FT_BOLD);
+ // emphasis
+ FontState curstate = font.fontInfo().emph();
+ if (font_old.emph() != curstate)
+ doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.emph_flag, curstate, xml::FT_EMPH);
+
+ // noun
+ curstate = font.fontInfo().noun();
+ if (font_old.noun() != curstate)
+ doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.noun_flag, curstate, xml::FT_NOUN);
+
+ // underbar
+ curstate = font.fontInfo().underbar();
+ if (font_old.underbar() != curstate)
+ doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.ubar_flag, curstate, xml::FT_UBAR);
+
+ // strikeout
+ curstate = font.fontInfo().strikeout();
+ if (font_old.strikeout() != curstate)
+ doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.sout_flag, curstate, xml::FT_SOUT);
+
+ // xout
+ curstate = font.fontInfo().xout();
+ if (font_old.xout() != curstate)
+ doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.xout_flag, curstate, xml::FT_XOUT);
+
+ // double underbar
+ curstate = font.fontInfo().uuline();
+ if (font_old.uuline() != curstate)
+ doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.dbar_flag, curstate, xml::FT_DBAR);
+
+ // wavy line
+ curstate = font.fontInfo().uwave();
+ if (font_old.uwave() != curstate)
+ doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.wave_flag, curstate, xml::FT_WAVE);
+
+ // bold
+ // 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())
+ doFontSwitchDocBook(tagsToOpen, tagsToClose, fs.bold_flag, curstate, xml::FT_BOLD);
+
+ // Font shape
+ fs.curr_fs = font.fontInfo().shape();
+ FontShape old_fs = font_old.shape();
+ if (old_fs != fs.curr_fs) {
+ if (fs.shap_flag) {
+ OptionalFontType tag = fontShapeToXml(old_fs);
+ if (tag.has_value)
+ tagsToClose.push_back(docbookEndFontTag(tag.ft));
+ fs.shap_flag = false;
+ }
- // Font shape
- curr_fs = font.fontInfo().shape();
- FontShape old_fs = font_old.shape();
- if (old_fs != curr_fs) {
- if (shap_flag) {
- OptionalFontType tag = fontShapeToXml(old_fs);
- if (tag.has_value) {
- tagsToClose.push_back(docbookEndFontTag(tag.ft));
- }
- shap_flag = false;
- }
+ OptionalFontType tag = fontShapeToXml(fs.curr_fs);
+ if (tag.has_value)
+ tagsToOpen.push_back(docbookStartFontTag(tag.ft));
+ }
- OptionalFontType tag = fontShapeToXml(curr_fs);
- if (tag.has_value) {
- tagsToOpen.push_back(docbookStartFontTag(tag.ft));
- }
+ // Font family
+ fs.curr_fam = font.fontInfo().family();
+ FontFamily old_fam = font_old.family();
+ if (old_fam != fs.curr_fam) {
+ if (fs.faml_flag) {
+ OptionalFontType tag = fontFamilyToXml(old_fam);
+ if (tag.has_value)
+ tagsToClose.push_back(docbookEndFontTag(tag.ft));
+ fs.faml_flag = false;
}
-
- // Font family
- curr_fam = font.fontInfo().family();
- FontFamily old_fam = font_old.family();
- if (old_fam != curr_fam) {
- if (faml_flag) {
- OptionalFontType tag = fontFamilyToXml(old_fam);
- if (tag.has_value) {
- tagsToClose.push_back(docbookEndFontTag(tag.ft));
- }
- faml_flag = false;
- }
- switch (curr_fam) {
+ switch (fs.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(docbookStartFontTag(xml::FT_ROMAN));
- faml_flag = true;
+ fs.faml_flag = true;
}
break;
case SANS_FAMILY:
if (default_family != "sfdefault") {
tagsToOpen.push_back(docbookStartFontTag(xml::FT_SANS));
- faml_flag = true;
+ fs.faml_flag = true;
}
break;
case TYPEWRITER_FAMILY:
if (default_family != "ttdefault") {
tagsToOpen.push_back(docbookStartFontTag(xml::FT_TYPE));
- faml_flag = true;
+ fs.faml_flag = true;
}
break;
case INHERIT_FAMILY:
// 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) {
- OptionalFontType tag = fontSizeToXml(old_size);
- if (tag.has_value) {
- tagsToClose.push_back(docbookEndFontTag(tag.ft));
- }
- size_flag = false;
- }
+ // Font size
+ fs.curr_size = font.fontInfo().size();
+ FontSize old_size = font_old.size();
+ if (old_size != fs.curr_size) {
+ if (fs.size_flag) {
+ OptionalFontType tag = fontSizeToXml(old_size);
+ if (tag.has_value)
+ tagsToClose.push_back(docbookEndFontTag(tag.ft));
+ fs.size_flag = false;
+ }
- OptionalFontType tag = fontSizeToXml(curr_size);
- if (tag.has_value) {
- tagsToOpen.push_back(docbookStartFontTag(tag.ft));
- size_flag = true;
- }
+ OptionalFontType tag = fontSizeToXml(fs.curr_size);
+ if (tag.has_value) {
+ tagsToOpen.push_back(docbookStartFontTag(tag.ft));
+ fs.size_flag = true;
}
+ }
- // FIXME XHTML
- // Other such tags? What about the other text ranges?
+ return std::tuple<vector<xml::FontTag>, vector<xml::EndFontTag>>(tagsToOpen, tagsToClose);
+}
- vector<xml::EndFontTag>::const_iterator cit = tagsToClose.begin();
- vector<xml::EndFontTag>::const_iterator cen = tagsToClose.end();
- for (; cit != cen; ++cit)
- xs << *cit;
+} // anonymous namespace
- vector<xml::FontTag>::const_iterator sit = tagsToOpen.begin();
- vector<xml::FontTag>::const_iterator sen = tagsToOpen.end();
- for (; sit != sen; ++sit)
- xs << *sit;
- tagsToClose.clear();
- tagsToOpen.clear();
+std::vector<docstring> Paragraph::simpleDocBookOnePar(Buffer const & buf,
+ OutputParams const & runparams,
+ Font const & outerfont,
+ pos_type initial,
+ bool is_last_par,
+ bool ignore_fonts) const
+{
+ // Track whether we have opened these tags
+ DocBookFontState fs;
+
+ Layout const & style = *d->layout_;
+ FontInfo font_old =
+ style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
+
+ string const default_family =
+ buf.masterBuffer()->params().fonts_default_family;
+
+ vector<xml::FontTag> tagsToOpen;
+ vector<xml::EndFontTag> tagsToClose;
+
+ std::vector<docstring> generatedParagraphs;
+ DocBookFontState old_fs = fs;
+ odocstringstream os;
+ auto * xs = new XMLStream(os); // XMLStream has no copy constructor: to create a new object, the only solution
+ // is to hold a pointer to the XMLStream (xs = XMLStream(os) is not allowed once the first object is built).
+
+ // When a font tag ends with a space, output it after the closing font tag. This requires to store delayed
+ // characters at some point.
+ std::vector<char_type> delayedChars;
+
+ // Parsing main loop.
+ for (pos_type i = initial; i < size(); ++i) {
+ // Don't show deleted material in the output.
+ if (isDeleted(i))
+ continue;
+
+ // If this is an InsetNewline, generate a new paragraph. Also reset the fonts, so that tags are closed in
+ // this paragraph.
+ if (getInset(i) != nullptr && getInset(i)->lyxCode() == NEWLINE_CODE) {
+ if (!ignore_fonts)
+ xs->closeFontTags();
+
+ // Output one paragraph (i.e. one string entry in generatedParagraphs).
+ generatedParagraphs.push_back(os.str());
+
+ // Create a new XMLStream for the new paragraph, completely independent from the previous one. This implies
+ // that the string stream must be reset.
+ os.str(from_ascii(""));
+ delete xs;
+ xs = new XMLStream(os);
+
+ // Restore the fonts for the new paragraph, so that the right tags are opened for the new entry.
+ if (!ignore_fonts) {
+ font_old = outerfont.fontInfo();
+ fs = old_fs;
+ }
+ }
+
+ // Determine which tags should be opened or closed regarding fonts.
+ Font const font = getFont(buf.masterBuffer()->params(), i, outerfont);
+ if (!ignore_fonts) {
+ tie(tagsToOpen, tagsToClose) = computeDocBookFontSwitch(font_old, font, default_family, fs);
+
+ // FIXME XHTML
+ // Other such tags? What about the other text ranges?
+
+ vector<xml::EndFontTag>::const_iterator cit = tagsToClose.begin();
+ vector<xml::EndFontTag>::const_iterator cen = tagsToClose.end();
+ for (; cit != cen; ++cit)
+ *xs << *cit;
+
+ // Deal with the delayed characters *after* closing font tags.
+ if (!delayedChars.empty()) {
+ for (char_type c: delayedChars)
+ *xs << c;
+ delayedChars.clear();
+ }
+
+ vector<xml::FontTag>::const_iterator sit = tagsToOpen.begin();
+ vector<xml::FontTag>::const_iterator sen = tagsToOpen.end();
+ for (; sit != sen; ++sit)
+ *xs << *sit;
+
+ tagsToClose.clear();
+ tagsToOpen.clear();
+ }
if (Inset const * inset = getInset(i)) {
if (!runparams.for_toc || inset->isInToc()) {
OutputParams np = runparams;
np.local_font = &font;
- // If the paragraph has size 1, then we are in the "special
- // case" where we do not output the containing paragraph info.
- if (!inset->getLayout().htmlisblock() && size() != 1) // TODO: htmlisblock here too!
- np.docbook_in_par = true;
- inset->docbook(xs, np);
+
+ // TODO: special case will bite here.
+ np.docbook_in_par = true;
+ inset->docbook(*xs, np);
}
} else {
char_type c = getUChar(buf.masterBuffer()->params(), runparams, i);
- xs << c;
+ if (lyx::isSpace(c) && !ignore_fonts)
+ delayedChars.push_back(c);
+ else
+ *xs << c;
}
font_old = font.fontInfo();
}
// FIXME, this code is just imported from XHTML
// I'm worried about what happens if a branch, say, is itself
// wrapped in some font stuff. I think that will not work.
- xs.closeFontTags();
- if (runparams.docbook_in_listing)
- xs << xml::CR();
- if (close_paragraph)
- xs.endDivision();
+ if (!ignore_fonts)
+ xs->closeFontTags();
+
+ // Deal with the delayed characters *after* closing font tags.
+ if (!delayedChars.empty())
+ for (char_type c: delayedChars)
+ *xs << c;
+
+ // In listings, new lines (i.e. \n characters in the output) are very important. Avoid generating one for the
+ // last line to get a clean output.
+ if (runparams.docbook_in_listing && !is_last_par)
+ *xs << xml::CR();
+
+ // Finalise the last (and most likely only) paragraph.
+ generatedParagraphs.push_back(os.str());
+ delete xs;
+
+ return generatedParagraphs;
}
char_type const c = d->text_[pos];
if (c != '-' && c != '\'')
return false;
- int nextpos = pos + 1;
- int prevpos = pos > 0 ? pos - 1 : 0;
+ pos_type nextpos = pos + 1;
+ pos_type prevpos = pos > 0 ? pos - 1 : 0;
if ((nextpos == psize || isSpace(nextpos))
&& (pos == 0 || isSpace(prevpos)))
return false;
Inset const * ins = getInset(i);
if (ins->needsCProtection(maintext, fragile))
return true;
- if (ins->getLayout().latextype() == InsetLayout::ENVIRONMENT)
- // Environments need cprotection regardless the content
- return true;
// Now check math environments
InsetMath const * im = getInset(i)->asInsetMath();
if (!im || im->cell(0).empty())
int Paragraph::fixBiblio(Buffer const & buffer)
{
// FIXME: when there was already an inset at 0, the return value is 1,
- // which does not tell whether another inset has been remove; the
+ // which does not tell whether another inset has been removed; the
// cursor cannot be correctly updated.
bool const track_changes = buffer.params().track_changes;
// than keep the first? (JMarc)
Inset * inset = releaseInset(bibitem_pos);
d->insetlist_.begin()->inset = inset;
+ // This needs to be done to update the counter (#8499)
+ buffer.updateBuffer();
return -bibitem_pos;
}
}
int erasePos = pos - changes.size();
- for (size_t i = 0; i < changes.size(); i++) {
- insertChar(pos, changes[i].first,
- changes[i].second,
- trackChanges);
+ for (auto const & change : changes) {
+ insertChar(pos, change.first, change.second, trackChanges);
if (!eraseChar(erasePos, trackChanges)) {
++erasePos;
++pos; // advance
// Ignore "invisible" letters such as ligature breaks
// and hyphenation chars while searching
while (pos < parsize - 1 && isInset(pos)) {
+ Inset const * inset = getInset(pos);
+ if (!inset->isLetter())
+ break;
odocstringstream os;
- getInset(pos)->toString(os);
- if (!getInset(pos)->isLetter() || !os.str().empty())
+ inset->toString(os);
+ if (!os.str().empty())
break;
pos++;
}
while (last < to && samelang && sameinset) {
// hop to end of word
while (last < to && !owner_->isWordSeparator(last)) {
- if (owner_->getInset(last)) {
+ Inset const * inset = owner_->getInset(last);
+ if (inset && dynamic_cast<const InsetSpecialChar *>(inset)) {
+ // check for "invisible" letters such as ligature breaks
+ odocstringstream os;
+ inset->toString(os);
+ if (os.str().length() != 0) {
+ // avoid spell check of visible special char insets
+ // stop the loop in front of the special char inset
+ sameinset = false;
+ break;
+ }
+ } else if (inset) {
appendSkipPosition(skips, last);
} else if (owner_->isDeleted(last)) {
appendSkipPosition(skips, last);
// start the spell checker on the unit of meaning
docstring word = asString(first, last, AS_STR_INSETS + AS_STR_SKIPDELETE);
WordLangTuple wl = WordLangTuple(word, lang);
- SpellChecker::Result result = word.size() ?
+ SpellChecker::Result result = !word.empty() ?
speller->check(wl) : SpellChecker::WORD_OK;
d->markMisspelledWords(first, last, result, word, skips);
first = ++last;
projects / lyx.git / blobdiff