#include "OutputParams.h"
#include "output_latex.h"
#include "output_xhtml.h"
+#include "output_docbook.h"
#include "ParagraphParameters.h"
#include "SpellChecker.h"
-#include "sgml.h"
+#include "xml.h"
#include "texstream.h"
#include "TextClass.h"
#include "TexRow.h"
#include "support/lassert.h"
#include "support/lstrings.h"
#include "support/textutils.h"
+#include "output_docbook.h"
#include <atomic>
#include <sstream>
Paragraph::Private::Private(Paragraph * owner, Layout const & layout)
- : owner_(owner), inset_owner_(0), id_(-1), begin_of_body_(0), layout_(&layout)
+ : owner_(owner), inset_owner_(nullptr), id_(-1), begin_of_body_(0), layout_(&layout)
{
text_.reserve(100);
}
return d->changes_.isChanged(start, end);
}
+// FIXME: Ideally the diverse isChanged() methods should account for that!
+bool Paragraph::hasChangedInsets(pos_type start, pos_type end) const
+{
+ LASSERT(start >= 0 && start <= size(), return false);
+ LASSERT(end > start && end <= size() + 1, return false);
+
+ for (auto const & icit : d->insetlist_) {
+ if (icit.pos < start)
+ continue;
+ if (icit.pos >= end)
+ break;
+ if (icit.inset && icit.inset->isChanged())
+ return true;
+ }
+ return false;
+}
bool Paragraph::isChanged() const
{
// see comment in setChange(Change const &) above
if (!change.deleted() && pos < size())
- if (Inset * inset = getInset(pos))
- inset->setChange(change);
+ if (Inset * inset = getInset(pos))
+ inset->setChange(change);
}
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);
+ 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
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());
+ open_font = (running_font.language() == basefont.language()
+ || running_font.fontInfo().size() == basefont.fontInfo().size());
if (closeLanguage)
runparams.local_font = &basefont;
}
// Optimisation: avoid a full font instantiation if there is no
// language change from previous call.
static Font previous_font;
- static Language const * previous_lang = 0;
+ static Language const * previous_lang = nullptr;
Language const * lang = getParLanguage(bparams);
if (lang != previous_lang) {
previous_lang = lang;
// Optimisation: avoid a full font instantiation if there is no
// language change from previous call.
static Font previous_font;
- static Language const * previous_lang = 0;
+ static Language const * previous_lang = nullptr;
if (bparams.language != previous_lang) {
previous_lang = bparams.language;
previous_font = Font(inherit_font, bparams.language);
}
-docstring Paragraph::expandDocBookLabel(Layout const & layout,
- BufferParams const & bparams) const
-{
- return expandParagraphLabel(layout, bparams, false);
-}
-
-
docstring Paragraph::expandParagraphLabel(Layout const & layout,
BufferParams const & bparams, bool process_appendix) const
{
// remove unnecessary getChar() calls
pos_type i = 0;
pos_type end = size();
- if (i < end && !(isNewline(i) || isEnvSeparator(i))) {
+ bool prev_char_deleted = false;
+ if (i < end && (!(isNewline(i) || isEnvSeparator(i)) || isDeleted(i))) {
++i;
if (i < end) {
char_type previous_char = d->text_[i];
if (!(isNewline(i) || isEnvSeparator(i))) {
++i;
- while (i < end && previous_char != ' ') {
+ while (i < end && (previous_char != ' ' || prev_char_deleted)) {
char_type temp = d->text_[i];
- if (isNewline(i) || isEnvSeparator(i))
+ prev_char_deleted = isDeleted(i);
+ if (!isDeleted(i) && (isNewline(i) || isEnvSeparator(i)))
break;
++i;
previous_char = temp;
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)
+ ? Font(runparams.local_font->fontInfo()) : outerfont;
+
if (body_pos > 0) {
// the optional argument is kept in curly brackets in
// case it contains a ']'
// braces when it parses \item.
os << "[{";
column += 2;
- basefont = getLabelFont(bparams, outerfont);
+ basefont = getLabelFont(bparams, real_outerfont);
} else {
- basefont = getLayoutFont(bparams, outerfont);
+ basefont = getLayoutFont(bparams, real_outerfont);
}
// Which font is currently active?
basefont, basefont, needPar);
open_font = false;
}
- basefont = getLayoutFont(bparams, outerfont);
+ basefont = getLayoutFont(bparams, real_outerfont);
running_font = basefont;
column += Changes::latexMarkChange(os, bparams,
basefont, needPar);
open_font = false;
}
- basefont = (body_pos > i) ? getLabelFont(bparams, outerfont)
- : getLayoutFont(bparams, outerfont);
+ basefont = (body_pos > i) ? getLabelFont(bparams, real_outerfont)
+ : getLayoutFont(bparams, real_outerfont);
running_font = basefont;
column += Changes::latexMarkChange(os, bparams,
Change(Change::INSERTED), change, rp);
basefont, basefont, needPar);
open_font = false;
}
- basefont = (body_pos > i) ? getLabelFont(bparams, outerfont)
- : getLayoutFont(bparams, outerfont);
+ basefont = (body_pos > i) ? getLabelFont(bparams, real_outerfont)
+ : getLayoutFont(bparams, real_outerfont);
running_font = basefont;
column += Changes::latexMarkChange(os, bparams, runningChange,
change, runparams);
Font const current_font = getFont(bparams, i, outerfont);
Font const last_font = running_font;
+ bool const in_ct_deletion = (bparams.output_changes
+ && runningChange == change
+ && change.type == Change::DELETED
+ && !os.afterParbreak());
// Do we need to close the previous font?
if (open_font &&
alien_script.clear();
}
bool needPar = false;
+ if (in_ct_deletion) {
+ // We have to close and then reopen \lyxdeleted,
+ // as strikeout needs to be on lowest level.
+ os << '}';
+ column += 1;
+ }
column += running_font.latexWriteEndChanges(
os, bparams, runparams, basefont,
(i == body_pos-1) ? basefont : current_font,
needPar);
+ 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(Change::DELETED), rp);
+ }
running_font = basefont;
open_font = false;
}
// Do we need to change font?
if ((current_font != running_font ||
- current_font.language() != running_font.language()) &&
- i != body_pos - 1)
+ current_font.language() != running_font.language())
+ && i != body_pos - 1)
{
- bool const in_ct_deletion = (bparams.output_changes
- && runningChange == change
- && change.type == Change::DELETED
- && !os.afterParbreak());
if (in_ct_deletion) {
// We have to close and then reopen \lyxdeleted,
// as strikeout needs to be on lowest level.
Inset const * inset = getInset(i);
InsetText const * textinset = inset
? inset->asInsetText()
- : 0;
+ : nullptr;
if (i + 1 == size() && textinset
&& !inset->getLayout().isDisplay()) {
ParagraphList const & pars =
pit < 0 || pars[pit].empty()
? pars[pit].getLayoutFont(
bparams,
- outerfont)
+ real_outerfont)
: pars[pit].getFont(bparams,
pars[pit].size() - 1,
- outerfont);
+ real_outerfont);
if (lastfont.fontInfo().size() !=
basefont.fontInfo().size()) {
++parInline;
}
}
d->latexInset(bparams, os, rp, running_font,
- basefont, outerfont, open_font,
+ basefont, real_outerfont, open_font,
runningChange, style, i, column);
if (incremented)
--parInline;
// command is ever executed but its opening was recorded.
runparams.inulemcmd = rp.inulemcmd;
+ // These need to be passed upstream as well
+ runparams.need_maketitle = rp.need_maketitle;
+ runparams.have_maketitle = rp.have_maketitle;
+
// And finally, pass the post_macros upstream
runparams.post_macro = rp.post_macro;
}
// since this produces unwanted whitespace.
Font const font = empty()
- ? getLayoutFont(bparams, outerfont)
- : getFont(bparams, size() - 1, outerfont);
+ ? getLayoutFont(bparams, real_outerfont)
+ : getFont(bparams, size() - 1, real_outerfont);
InsetText const * textinset = inInset().asInsetText();
}
-string Paragraph::getID(Buffer const & buf, OutputParams const & runparams)
+string Paragraph::getID(Buffer const &, OutputParams const &)
const
{
for (pos_type i = 0; i < size(); ++i) {
if (lyx_code == LABEL_CODE) {
InsetLabel const * const il = static_cast<InsetLabel const *>(inset);
docstring const & id = il->getParam("name");
- return "id='" + to_utf8(sgml::cleanID(buf, runparams, id)) + "'";
+ return "id='" + to_utf8(xml::cleanID(id)) + "'";
}
}
}
}
-pos_type Paragraph::firstWordDocBook(odocstream & os, OutputParams const & runparams)
- const
+pos_type Paragraph::firstWordDocBook(XMLStream & xs, OutputParams const & runparams) const
{
pos_type i;
for (i = 0; i < size(); ++i) {
if (Inset const * inset = getInset(i)) {
- inset->docbook(os, runparams);
+ inset->docbook(xs, runparams);
} else {
char_type c = d->text_[i];
if (c == ' ')
break;
- os << sgml::escapeChar(c);
+ xs << c;
}
}
return i;
}
-pos_type Paragraph::firstWordLyXHTML(XHTMLStream & xs, OutputParams const & runparams)
+pos_type Paragraph::firstWordLyXHTML(XMLStream & xs, OutputParams const & runparams)
const
{
pos_type i;
}
+namespace {
+
+void doFontSwitchDocBook(vector<xml::FontTag> & tagsToOpen,
+ vector<xml::EndFontTag> & tagsToClose,
+ bool & flag, FontState curstate, xml::FontTypes type)
+{
+ if (curstate == FONT_ON) {
+ tagsToOpen.push_back(docbookStartFontTag(type));
+ flag = true;
+ } else if (flag) {
+ tagsToClose.push_back(docbookEndFontTag(type));
+ flag = false;
+ }
+}
+
+class OptionalFontType {
+public:
+ bool has_value;
+ xml::FontTypes ft;
+
+ 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 fontShapeToXml(FontShape fs)
+{
+ switch (fs) {
+ case ITALIC_SHAPE:
+ return {xml::FT_ITALIC};
+ case SLANTED_SHAPE:
+ return {xml::FT_SLANTED};
+ case SMALLCAPS_SHAPE:
+ return {xml::FT_SMALLCAPS};
+ case UP_SHAPE:
+ case INHERIT_SHAPE:
+ return {};
+ default:
+ // the other tags are for internal use
+ LATTEST(false);
+ return {};
+ }
+}
+
+OptionalFontType fontFamilyToXml(FontFamily fm)
+{
+ 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:
+ // the other tags are for internal use
+ LATTEST(false);
+ return {};
+ }
+}
+
+OptionalFontType fontSizeToXml(FontSize fs)
+{
+ switch (fs) {
+ case TINY_SIZE:
+ return {xml::FT_SIZE_TINY};
+ case SCRIPT_SIZE:
+ return {xml::FT_SIZE_SCRIPT};
+ case FOOTNOTE_SIZE:
+ return {xml::FT_SIZE_FOOTNOTE};
+ case SMALL_SIZE:
+ return {xml::FT_SIZE_SMALL};
+ case LARGE_SIZE:
+ return {xml::FT_SIZE_LARGE};
+ case LARGER_SIZE:
+ return {xml::FT_SIZE_LARGER};
+ case LARGEST_SIZE:
+ return {xml::FT_SIZE_LARGEST};
+ case HUGE_SIZE:
+ return {xml::FT_SIZE_HUGE};
+ case HUGER_SIZE:
+ return {xml::FT_SIZE_HUGER};
+ case INCREASE_SIZE:
+ return {xml::FT_SIZE_INCREASE};
+ case DECREASE_SIZE:
+ return {xml::FT_SIZE_DECREASE};
+ case INHERIT_SIZE:
+ case NORMAL_SIZE:
+ return {};
+ default:
+ // the other tags are for internal use
+ LATTEST(false);
+ return {};
+ }
+}
+
+}// anonymous namespace
+
+
void Paragraph::simpleDocBookOnePar(Buffer const & buf,
- odocstream & os,
- OutputParams const & runparams,
- Font const & outerfont,
- pos_type initial) const
+ XMLStream & xs,
+ OutputParams const & runparams,
+ Font const & outerfont,
+ bool start_paragraph, bool close_paragraph,
+ pos_type initial) const
{
+ // track whether we have opened these tags
bool emph_flag = false;
+ bool bold_flag = false;
+ bool noun_flag = false;
+ bool ubar_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_;
+
+ if (start_paragraph)
+ xs.startDivision(allowEmpty());
+
FontInfo font_old =
- style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
+ 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;
- if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
- os << "]]>";
+ vector<xml::FontTag> tagsToOpen;
+ vector<xml::EndFontTag> tagsToClose;
// parsing main loop
for (pos_type i = initial; i < size(); ++i) {
- Font font = getFont(buf.params(), i, outerfont);
-
- // handle <emphasis> tag
- if (font_old.emph() != font.fontInfo().emph()) {
- if (font.fontInfo().emph() == FONT_ON) {
- os << "<emphasis>";
- emph_flag = true;
- } else if (i != initial) {
- os << "</emphasis>";
- emph_flag = false;
+ // let's not show deleted material in the output
+ if (isDeleted(i))
+ continue;
+
+ Font const font = getFont(buf.masterBuffer()->params(), i, outerfont);
+
+ if (start_paragraph) {
+ // 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);
+
+ // 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(curr_fs);
+ if (tag.has_value) {
+ tagsToOpen.push_back(docbookStartFontTag(tag.ft));
+ }
}
+
+ // 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) {
+ 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;
+ }
+ break;
+ case SANS_FAMILY:
+ if (default_family != "sfdefault") {
+ tagsToOpen.push_back(docbookStartFontTag(xml::FT_SANS));
+ faml_flag = true;
+ }
+ break;
+ case TYPEWRITER_FAMILY:
+ if (default_family != "ttdefault") {
+ tagsToOpen.push_back(docbookStartFontTag(xml::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) {
+ OptionalFontType tag = fontSizeToXml(old_size);
+ if (tag.has_value) {
+ tagsToClose.push_back(docbookEndFontTag(tag.ft));
+ }
+ size_flag = false;
+ }
+
+ OptionalFontType tag = fontSizeToXml(curr_size);
+ if (tag.has_value) {
+ tagsToOpen.push_back(docbookStartFontTag(tag.ft));
+ size_flag = true;
+ }
+ }
+
+ // 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;
+
+ 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)) {
- inset->docbook(os, runparams);
+ 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.
+ // This "special case" is defined in more details in output_docbook.cpp, makeParagraphs. The results
+ // of that brittle logic is passed to this function through open_par.
+ if (!inset->getLayout().htmlisblock() && size() != 1) // TODO: htmlisblock here too!
+ np.docbook_in_par = true;
+ inset->docbook(xs, np);
+ }
} else {
- char_type c = d->text_[i];
-
- if (style.pass_thru)
- os.put(c);
- else
- os << sgml::escapeChar(c);
+ char_type c = getUChar(buf.masterBuffer()->params(), runparams, i);
+ xs << c;
}
font_old = font.fontInfo();
}
- if (emph_flag) {
- os << "</emphasis>";
- }
-
- if (style.free_spacing)
- os << '\n';
- if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
- os << "<![CDATA[";
+ // 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();
}
namespace {
-void doFontSwitch(vector<html::FontTag> & tagsToOpen,
- vector<html::EndFontTag> & tagsToClose,
- bool & flag, FontState curstate, html::FontTypes type)
+
+void doFontSwitchXHTML(vector<xml::FontTag> & tagsToOpen,
+ vector<xml::EndFontTag> & tagsToClose,
+ bool & flag, FontState curstate, xml::FontTypes type)
{
if (curstate == FONT_ON) {
- tagsToOpen.push_back(html::FontTag(type));
+ tagsToOpen.push_back(xhtmlStartFontTag(type));
flag = true;
} else if (flag) {
- tagsToClose.push_back(html::EndFontTag(type));
+ tagsToClose.push_back(xhtmlEndFontTag(type));
flag = false;
}
}
-} // namespace
+
+} // anonymous namespace
docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
- XHTMLStream & xs,
+ XMLStream & xs,
OutputParams const & runparams,
Font const & outerfont,
bool start_paragraph, bool close_paragraph,
string const default_family =
buf.masterBuffer()->params().fonts_default_family;
- vector<html::FontTag> tagsToOpen;
- vector<html::EndFontTag> tagsToClose;
+ vector<xml::FontTag> tagsToOpen;
+ vector<xml::EndFontTag> tagsToClose;
// parsing main loop
for (pos_type i = initial; i < size(); ++i) {
// emphasis
FontState curstate = font.fontInfo().emph();
if (font_old.emph() != curstate)
- doFontSwitch(tagsToOpen, tagsToClose, emph_flag, curstate, html::FT_EMPH);
+ doFontSwitchXHTML(tagsToOpen, tagsToClose, emph_flag, curstate, xml::FT_EMPH);
// noun
curstate = font.fontInfo().noun();
if (font_old.noun() != curstate)
- doFontSwitch(tagsToOpen, tagsToClose, noun_flag, curstate, html::FT_NOUN);
+ doFontSwitchXHTML(tagsToOpen, tagsToClose, noun_flag, curstate, xml::FT_NOUN);
// underbar
curstate = font.fontInfo().underbar();
if (font_old.underbar() != curstate)
- doFontSwitch(tagsToOpen, tagsToClose, ubar_flag, curstate, html::FT_UBAR);
+ doFontSwitchXHTML(tagsToOpen, tagsToClose, ubar_flag, curstate, xml::FT_UBAR);
// strikeout
curstate = font.fontInfo().strikeout();
if (font_old.strikeout() != curstate)
- doFontSwitch(tagsToOpen, tagsToClose, sout_flag, curstate, html::FT_SOUT);
+ doFontSwitchXHTML(tagsToOpen, tagsToClose, sout_flag, curstate, xml::FT_SOUT);
// xout
curstate = font.fontInfo().xout();
if (font_old.xout() != curstate)
- doFontSwitch(tagsToOpen, tagsToClose, xout_flag, curstate, html::FT_XOUT);
+ doFontSwitchXHTML(tagsToOpen, tagsToClose, xout_flag, curstate, xml::FT_XOUT);
// double underbar
curstate = font.fontInfo().uuline();
if (font_old.uuline() != curstate)
- doFontSwitch(tagsToOpen, tagsToClose, dbar_flag, curstate, html::FT_DBAR);
+ doFontSwitchXHTML(tagsToOpen, tagsToClose, dbar_flag, curstate, xml::FT_DBAR);
// wavy line
curstate = font.fontInfo().uwave();
if (font_old.uwave() != curstate)
- doFontSwitch(tagsToOpen, tagsToClose, wave_flag, curstate, html::FT_WAVE);
+ doFontSwitchXHTML(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())
- doFontSwitch(tagsToOpen, tagsToClose, bold_flag, curstate, html::FT_BOLD);
+ doFontSwitchXHTML(tagsToOpen, tagsToClose, bold_flag, curstate, xml::FT_BOLD);
// Font shape
curr_fs = font.fontInfo().shape();
if (shap_flag) {
switch (old_fs) {
case ITALIC_SHAPE:
- tagsToClose.push_back(html::EndFontTag(html::FT_ITALIC));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_ITALIC));
break;
case SLANTED_SHAPE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SLANTED));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SLANTED));
break;
case SMALLCAPS_SHAPE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SMALLCAPS));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SMALLCAPS));
break;
case UP_SHAPE:
case INHERIT_SHAPE:
}
switch (curr_fs) {
case ITALIC_SHAPE:
- tagsToOpen.push_back(html::FontTag(html::FT_ITALIC));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_ITALIC));
shap_flag = true;
break;
case SLANTED_SHAPE:
- tagsToOpen.push_back(html::FontTag(html::FT_SLANTED));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SLANTED));
shap_flag = true;
break;
case SMALLCAPS_SHAPE:
- tagsToOpen.push_back(html::FontTag(html::FT_SMALLCAPS));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SMALLCAPS));
shap_flag = true;
break;
case UP_SHAPE:
if (faml_flag) {
switch (old_fam) {
case ROMAN_FAMILY:
- tagsToClose.push_back(html::EndFontTag(html::FT_ROMAN));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_ROMAN));
break;
case SANS_FAMILY:
- tagsToClose.push_back(html::EndFontTag(html::FT_SANS));
- break;
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SANS));
+ break;
case TYPEWRITER_FAMILY:
- tagsToClose.push_back(html::EndFontTag(html::FT_TYPE));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_TYPE));
break;
case INHERIT_FAMILY:
break;
// 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));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_ROMAN));
faml_flag = true;
}
break;
case SANS_FAMILY:
if (default_family != "sfdefault") {
- tagsToOpen.push_back(html::FontTag(html::FT_SANS));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SANS));
faml_flag = true;
}
break;
case TYPEWRITER_FAMILY:
if (default_family != "ttdefault") {
- tagsToOpen.push_back(html::FontTag(html::FT_TYPE));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_TYPE));
faml_flag = true;
}
break;
if (size_flag) {
switch (old_size) {
case TINY_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_TINY));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_TINY));
break;
case SCRIPT_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_SCRIPT));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_SCRIPT));
break;
case FOOTNOTE_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_FOOTNOTE));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_FOOTNOTE));
break;
case SMALL_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_SMALL));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_SMALL));
break;
case LARGE_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGE));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_LARGE));
break;
case LARGER_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGER));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_LARGER));
break;
case LARGEST_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGEST));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_LARGEST));
break;
case HUGE_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_HUGE));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_HUGE));
break;
case HUGER_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_HUGER));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_HUGER));
break;
case INCREASE_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_INCREASE));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_INCREASE));
break;
case DECREASE_SIZE:
- tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_DECREASE));
+ tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_DECREASE));
break;
case INHERIT_SIZE:
case NORMAL_SIZE:
}
switch (curr_size) {
case TINY_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_TINY));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_TINY));
size_flag = true;
break;
case SCRIPT_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_SCRIPT));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_SCRIPT));
size_flag = true;
break;
case FOOTNOTE_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_FOOTNOTE));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_FOOTNOTE));
size_flag = true;
break;
case SMALL_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_SMALL));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_SMALL));
size_flag = true;
break;
case LARGE_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGE));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_LARGE));
size_flag = true;
break;
case LARGER_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGER));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_LARGER));
size_flag = true;
break;
case LARGEST_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGEST));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_LARGEST));
size_flag = true;
break;
case HUGE_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_HUGE));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_HUGE));
size_flag = true;
break;
case HUGER_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_HUGER));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_HUGER));
size_flag = true;
break;
case INCREASE_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_INCREASE));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_INCREASE));
size_flag = true;
break;
case DECREASE_SIZE:
- tagsToOpen.push_back(html::FontTag(html::FT_SIZE_DECREASE));
+ tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_DECREASE));
size_flag = true;
break;
- case NORMAL_SIZE:
case INHERIT_SIZE:
+ case NORMAL_SIZE:
break;
default:
// the other tags are for internal use
// 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();
+ vector<xml::EndFontTag>::const_iterator cit = tagsToClose.begin();
+ vector<xml::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();
+ vector<xml::FontTag>::const_iterator sit = tagsToOpen.begin();
+ vector<xml::FontTag>::const_iterator sen = tagsToOpen.end();
for (; sit != sen; ++sit)
xs << *sit;
char_type c = getUChar(buf.masterBuffer()->params(),
runparams, i);
if (c == ' ' && (style.free_spacing || runparams.free_spacing))
- xs << XHTMLStream::ESCAPE_NONE << " ";
+ xs << XMLStream::ESCAPE_NONE << " ";
else
xs << c;
}
os.put(c);
else if (c == META_INSET && (options & AS_STR_INSETS)) {
if (c == META_INSET && (options & AS_STR_PLAINTEXT)) {
- LASSERT(runparams != 0, return docstring());
+ LASSERT(runparams != nullptr, return docstring());
getInset(i)->plaintext(os, *runparams);
} else {
getInset(i)->toString(os);
Inset * Paragraph::getInset(pos_type pos)
{
return (pos < pos_type(d->text_.size()) && d->text_[pos] == META_INSET)
- ? d->insetlist_.get(pos) : 0;
+ ? d->insetlist_.get(pos) : nullptr;
}
Inset const * Paragraph::getInset(pos_type pos) const
{
return (pos < pos_type(d->text_.size()) && d->text_[pos] == META_INSET)
- ? d->insetlist_.get(pos) : 0;
+ ? d->insetlist_.get(pos) : nullptr;
}
++from;
// don't check empty range
if (from >= to)
- return 0;
+ return nullptr;
// get current language
Language * lang = getSpellLanguage(from);
pos_type last = from;