anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-11-25 19:07:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename-XHTMLStream-to-XMLStream #2.

Browse Source 
Refactor font-related stuff to come closer to the previous xHTML output.
Patch from Thibaut Cuvelier.
This commit is contained in:
Pavel Sanda 2020-06-15 23:28:27 +02:00
parent 8e2b18ada9
commit 86387120bc
5 changed files with 221 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

386
src/Paragraph.cpp
View File

@ -3074,11 +3074,11 @@ void doFontSwitchXHTML(vector<xml::FontTag> & tagsToOpen,
docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
XMLStream & xs,
OutputParams const & runparams,
Font const & outerfont,
bool start_paragraph, bool close_paragraph,
pos_type initial) const
XMLStream & xs,
OutputParams const & runparams,
Font const & outerfont,
bool start_paragraph, bool close_paragraph,
pos_type initial) const
{
docstring retval;
@ -3169,206 +3169,206 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
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(xml::EndFontTag(fontToHtmlTag(xml::FT_ITALIC), xml::FT_ITALIC));
break;
case SLANTED_SHAPE:
tagsToClose.push_back(xml::EndFontTag(fontToHtmlTag(xml::FT_SLANTED), xml::FT_SLANTED));
break;
case SMALLCAPS_SHAPE:
tagsToClose.push_back(xml::EndFontTag(fontToHtmlTag(xml::FT_SMALLCAPS), xml::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(xml::FontTag(fontToHtmlTag(xml::FT_ITALIC), xml::FT_ITALIC));
shap_flag = true;
break;
case SLANTED_SHAPE:
tagsToOpen.push_back(xml::FontTag(fontToHtmlTag(xml::FT_SLANTED), xml::FT_SLANTED));
shap_flag = true;
break;
case SMALLCAPS_SHAPE:
tagsToOpen.push_back(xml::FontTag(fontToHtmlTag(xml::FT_SMALLCAPS), xml::FT_SMALLCAPS));
shap_flag = true;
break;
case UP_SHAPE:
case INHERIT_SHAPE:
break;
default:
// the other tags are for internal use
LATTEST(false);
break;
}
if (shap_flag) {
switch (old_fs) {
case ITALIC_SHAPE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_ITALIC));
break;
case SLANTED_SHAPE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SLANTED));
break;
case SMALLCAPS_SHAPE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::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.emplace_back(xhtmlStartFontTag(xml::FT_ITALIC));
shap_flag = true;
break;
case SLANTED_SHAPE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SLANTED));
shap_flag = true;
break;
case SMALLCAPS_SHAPE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::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(xml::EndFontTag(fontToHtmlTag(xml::FT_ROMAN), xml::FT_ROMAN));
break;
case SANS_FAMILY:
tagsToClose.push_back(xml::EndFontTag(fontToHtmlTag(xml::FT_SANS), xml::FT_SANS));
break;
case TYPEWRITER_FAMILY:
tagsToClose.push_back(xml::EndFontTag(fontToHtmlTag(xml::FT_TYPE), xml::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(xml::FontTag(fontToHtmlTag(xml::FT_ROMAN), xml::FT_ROMAN));
faml_flag = true;
}
break;
case SANS_FAMILY:
if (default_family != "sfdefault") {
tagsToOpen.push_back(xml::FontTag(fontToHtmlTag(xml::FT_SANS), xml::FT_SANS));
faml_flag = true;
}
break;
case TYPEWRITER_FAMILY:
if (default_family != "ttdefault") {
tagsToOpen.push_back(xml::FontTag(fontToHtmlTag(xml::FT_TYPE), xml::FT_TYPE));
faml_flag = true;
}
break;
case INHERIT_FAMILY:
break;
default:
// the other tags are for internal use
LATTEST(false);
break;
}
if (faml_flag) {
switch (old_fam) {
case ROMAN_FAMILY:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_ROMAN));
break;
case SANS_FAMILY:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SANS));
break;
case TYPEWRITER_FAMILY:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::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.emplace_back(xhtmlStartFontTag(xml::FT_ROMAN));
faml_flag = true;
}
break;
case SANS_FAMILY:
if (default_family != "sfdefault") {
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SANS));
faml_flag = true;
}
break;
case TYPEWRITER_FAMILY:
if (default_family != "ttdefault") {
tagsToOpen.emplace_back(xhtmlStartFontTag(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) {
switch (old_size) {
case TINY_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_TINY), xml::FT_SIZE_TINY);
break;
case SCRIPT_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_SCRIPT), xml::FT_SIZE_SCRIPT);
break;
case FOOTNOTE_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_FOOTNOTE), xml::FT_SIZE_FOOTNOTE);
break;
case SMALL_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_SMALL), xml::FT_SIZE_SMALL);
break;
case LARGE_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_LARGE), xml::FT_SIZE_LARGE);
break;
case LARGER_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_LARGER), xml::FT_SIZE_LARGER);
break;
case LARGEST_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_LARGEST), xml::FT_SIZE_LARGEST);
break;
case HUGE_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_HUGE), xml::FT_SIZE_HUGE);
break;
case HUGER_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_HUGER), xml::FT_SIZE_HUGER);
break;
case INCREASE_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_INCREASE), xml::FT_SIZE_INCREASE);
break;
case DECREASE_SIZE:
tagsToClose.emplace_back(fontToHtmlTag(xml::FT_SIZE_DECREASE), xml::FT_SIZE_DECREASE);
break;
case INHERIT_SIZE:
case NORMAL_SIZE:
break;
default:
// the other tags are for internal use
LATTEST(false);
break;
}
size_flag = false;
}
switch (curr_size) {
case TINY_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_TINY), xml::FT_SIZE_TINY);
size_flag = true;
break;
case SCRIPT_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_SCRIPT), xml::FT_SIZE_SCRIPT);
size_flag = true;
break;
case FOOTNOTE_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_FOOTNOTE), xml::FT_SIZE_FOOTNOTE);
size_flag = true;
break;
case SMALL_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_SMALL), xml::FT_SIZE_SMALL);
size_flag = true;
break;
case LARGE_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_LARGE), xml::FT_SIZE_LARGE);
size_flag = true;
break;
case LARGER_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_LARGER), xml::FT_SIZE_LARGER);
size_flag = true;
break;
case LARGEST_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_LARGEST), xml::FT_SIZE_LARGEST);
size_flag = true;
break;
case HUGE_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_HUGE), xml::FT_SIZE_HUGE);
size_flag = true;
break;
case HUGER_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_HUGER), xml::FT_SIZE_HUGER);
size_flag = true;
break;
case INCREASE_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_INCREASE), xml::FT_SIZE_INCREASE);
size_flag = true;
break;
case DECREASE_SIZE:
tagsToOpen.emplace_back(fontToHtmlTag(xml::FT_SIZE_DECREASE), xml::FT_SIZE_DECREASE);
size_flag = true;
break;
case INHERIT_SIZE:
case NORMAL_SIZE:
break;
default:
// the other tags are for internal use
LATTEST(false);
break;
}
if (size_flag) {
switch (old_size) {
case TINY_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_TINY));
break;
case SCRIPT_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_SCRIPT));
break;
case FOOTNOTE_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_FOOTNOTE));
break;
case SMALL_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_SMALL));
break;
case LARGE_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_LARGE));
break;
case LARGER_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_LARGER));
break;
case LARGEST_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_LARGEST));
break;
case HUGE_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_HUGE));
break;
case HUGER_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_HUGER));
break;
case INCREASE_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_INCREASE));
break;
case DECREASE_SIZE:
tagsToClose.emplace_back(xhtmlEndFontTag(xml::FT_SIZE_DECREASE));
break;
case INHERIT_SIZE:
case NORMAL_SIZE:
break;
default:
// the other tags are for internal use
LATTEST(false);
break;
}
size_flag = false;
}
switch (curr_size) {
case TINY_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_TINY));
size_flag = true;
break;
case SCRIPT_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_SCRIPT));
size_flag = true;
break;
case FOOTNOTE_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_FOOTNOTE));
size_flag = true;
break;
case SMALL_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_SMALL));
size_flag = true;
break;
case LARGE_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_LARGE));
size_flag = true;
break;
case LARGER_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_LARGER));
size_flag = true;
break;
case LARGEST_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_LARGEST));
size_flag = true;
break;
case HUGE_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_HUGE));
size_flag = true;
break;
case HUGER_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_HUGER));
size_flag = true;
break;
case INCREASE_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_INCREASE));
size_flag = true;
break;
case DECREASE_SIZE:
tagsToOpen.emplace_back(xhtmlStartFontTag(xml::FT_SIZE_DECREASE));
size_flag = true;
break;
case INHERIT_SIZE:
case NORMAL_SIZE:
break;
default:
// the other tags are for internal use
LATTEST(false);
break;
}
}
// FIXME XHTML

2
src/insets/InsetBibtex.h
View File

@ -66,8 +66,6 @@ public:
///
docstring xhtml(XMLStream &, OutputParams const &) const;
///
docstring docbook(XMLStream &, OutputParams const &) const;
///
std::string contextMenuName() const;
//@}

2
src/insets/InsetInclude.h
View File

@ -159,7 +159,7 @@ private:
/// get the text displayed on the button
docstring screenLabel() const;
//@}
/// holds the entity name that defines the file location (XML)
docstring const include_label;

54
src/output_xhtml.cpp
View File

@ -45,7 +45,7 @@ using namespace lyx::support;
namespace lyx {
docstring const fontToHtmlTag(xml::FontTypes type)
docstring fontToHtmlTag(xml::FontTypes type)
{
switch(type) {
case xml::FontTypes::FT_EMPH:
@ -88,70 +88,66 @@ docstring const fontToHtmlTag(xml::FontTypes type)
}
namespace {
string fontToAttribute(xml::FontTypes type)
docstring fontToHtmlAttribute(xml::FontTypes type)
{
switch(type) {
case xml::FontTypes::FT_EMPH:
case xml::FontTypes::FT_BOLD:
return "";
return from_ascii("");
case xml::FontTypes::FT_NOUN:
return "class='lyxnoun'";
return from_ascii("class='lyxnoun'");
case xml::FontTypes::FT_UBAR:
return "";
return from_ascii("");
case xml::FontTypes::FT_DBAR:
return "class='dline'";
return from_ascii("class='dline'");
case xml::FontTypes::FT_XOUT:
case xml::FontTypes::FT_SOUT:
return "class='strikeout'";
return from_ascii("class='strikeout'");
case xml::FontTypes::FT_WAVE:
return "class='wline'";
return from_ascii("class='wline'");
case xml::FontTypes::FT_ITALIC:
return "";
return from_ascii("");
case xml::FontTypes::FT_UPRIGHT:
return "style='font-style:normal;'";
return from_ascii("style='font-style:normal;'");
case xml::FontTypes::FT_SLANTED:
return "style='font-style:oblique;'";
return from_ascii("style='font-style:oblique;'");
case xml::FontTypes::FT_SMALLCAPS:
return "style='font-variant:small-caps;'";
return from_ascii("style='font-variant:small-caps;'");
case xml::FontTypes::FT_ROMAN:
return "style='font-family:serif;'";
return from_ascii("style='font-family:serif;'");
case xml::FontTypes::FT_SANS:
return "style='font-family:sans-serif;'";
return from_ascii("style='font-family:sans-serif;'");
case xml::FontTypes::FT_TYPE:
return "style='font-family:monospace;'";
return from_ascii("style='font-family:monospace;'");
case xml::FontTypes::FT_SIZE_TINY:
case xml::FontTypes::FT_SIZE_SCRIPT:
case xml::FontTypes::FT_SIZE_FOOTNOTE:
return "style='font-size:x-small;'";
return from_ascii("style='font-size:x-small;'");
case xml::FontTypes::FT_SIZE_SMALL:
return "style='font-size:small;'";
return from_ascii("style='font-size:small;'");
case xml::FontTypes::FT_SIZE_NORMAL:
return "style='font-size:normal;'";
return from_ascii("style='font-size:normal;'");
case xml::FontTypes::FT_SIZE_LARGE:
return "style='font-size:large;'";
return from_ascii("style='font-size:large;'");
case xml::FontTypes::FT_SIZE_LARGER:
case xml::FontTypes::FT_SIZE_LARGEST:
return "style='font-size:x-large;'";
return from_ascii("style='font-size:x-large;'");
case xml::FontTypes::FT_SIZE_HUGE:
case xml::FontTypes::FT_SIZE_HUGER:
return "style='font-size:xx-large;'";
return from_ascii("style='font-size:xx-large;'");
case xml::FontTypes::FT_SIZE_INCREASE:
return "style='font-size:larger;'";
return from_ascii("style='font-size:larger;'");
case xml::FontTypes::FT_SIZE_DECREASE:
return "style='font-size:smaller;'";
return from_ascii("style='font-size:smaller;'");
}
// kill warning
return "";
return from_ascii("");
}
} // end anonymous namespace
xml::FontTag xhtmlStartFontTag(xml::FontTypes type)
{
return xml::FontTag(fontToHtmlTag(type), from_utf8(fontToAttribute(type)), type);
return xml::FontTag(fontToHtmlTag(type), fontToHtmlAttribute(type), type);
}

3
src/output_xhtml.h
View File

@ -24,7 +24,8 @@
namespace lyx {
docstring const fontToHtmlTag(xml::FontTypes type);
docstring fontToHtmlTag(xml::FontTypes type);
docstring fontToHtmlAttribute(xml::FontTypes type);
class Buffer;
class OutputParams;