* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
* \author Jean-Marc Lasgouttes
* \author Angus Leeming
- * \author André Pönitz
+ * \author André Pönitz
* \author Dekel Tsur
*
* Full author contact details are available in file CREDITS.
#include "FontInfo.h"
+#include "ColorSet.h"
+#include "Lexer.h"
+#include "LyXRC.h"
+
+#include "support/convert.h"
#include "support/debug.h"
+#include "support/docstring.h"
+#include "support/gettext.h"
+#include "support/lstrings.h"
+
+#include <algorithm>
+#include <ostream>
+#include <sstream>
using namespace std;
+using namespace lyx::support;
namespace lyx {
+//
+// Names for the GUI
+//
+
+char const * GUIFamilyNames[NUM_FAMILIES + 2 /* default & error */] =
+{ N_("Roman"), N_("Sans Serif"), N_("Typewriter"), N_("Symbol"),
+ "cmr", "cmsy", "cmm", "cmex", "msa", "msb", "ds", "eufrak", "rsfs", "stmry",
+ "wasy", "esint", N_("Inherit"), N_("Ignore") };
+
+char const * GUISeriesNames[NUM_SERIES + 2 /* default & error */] =
+{ N_("Medium"), N_("Bold"), N_("Inherit"), N_("Ignore") };
+
+char const * GUIShapeNames[NUM_SHAPE + 2 /* default & error */] =
+{ N_("Upright"), N_("Italic"), N_("Slanted"), N_("Smallcaps"), N_("Inherit"),
+ N_("Ignore") };
+
+char const * GUISizeNames[NUM_SIZE + 4 /* increase, decrease, default & error */] =
+{ N_("Tiny"), N_("Smallest"), N_("Smaller"), N_("Small"), N_("Normal"), N_("Large"),
+ N_("Larger"), N_("Largest"), N_("Huge"), N_("Huger"), N_("Increase"), N_("Decrease"),
+ N_("Inherit"), N_("Ignore") };
+
+char const * GUIMiscNames[5] =
+{ N_("Off"), N_("On"), N_("Toggle"), N_("Inherit"), N_("Ignore") };
+
+
+//
+// Strings used to read and write .lyx format files
+//
+char const * LyXFamilyNames[NUM_FAMILIES + 2 /* default & error */] =
+{ "roman", "sans", "typewriter", "symbol",
+ "cmr", "cmsy", "cmm", "cmex", "msa", "msb", "ds", "eufrak", "rsfs", "stmry",
+ "wasy", "esint", "default", "error" };
+
+char const * LyXSeriesNames[NUM_SERIES + 2 /* default & error */] =
+{ "medium", "bold", "default", "error" };
+
+char const * LyXShapeNames[NUM_SHAPE + 2 /* default & error */] =
+{ "up", "italic", "slanted", "smallcaps", "default", "error" };
+
+char const * LyXSizeNames[NUM_SIZE + 4 /* increase, decrease, default & error */] =
+{ "tiny", "scriptsize", "footnotesize", "small", "normal", "large",
+ "larger", "largest", "huge", "giant",
+ "increase", "decrease", "default", "error" };
+
+char const * LyXMiscNames[5] =
+{ "off", "on", "toggle", "default", "error" };
+
+
FontInfo const sane_font(
ROMAN_FAMILY,
MEDIUM_SERIES,
UP_SHAPE,
- FONT_SIZE_NORMAL,
+ NORMAL_SIZE,
+ TEXT_STYLE,
Color_none,
Color_background,
FONT_OFF,
FONT_OFF,
FONT_OFF,
+ FONT_OFF,
+ FONT_OFF,
+ FONT_OFF,
+ FONT_OFF,
+ FONT_OFF,
FONT_OFF);
FontInfo const inherit_font(
INHERIT_FAMILY,
INHERIT_SERIES,
INHERIT_SHAPE,
- FONT_SIZE_INHERIT,
+ INHERIT_SIZE,
+ INHERIT_STYLE,
Color_inherit,
Color_inherit,
FONT_INHERIT,
FONT_INHERIT,
FONT_INHERIT,
- FONT_OFF);
+ FONT_INHERIT,
+ FONT_INHERIT,
+ FONT_INHERIT,
+ FONT_INHERIT,
+ FONT_OFF,
+ FONT_INHERIT);
FontInfo const ignore_font(
IGNORE_FAMILY,
IGNORE_SERIES,
IGNORE_SHAPE,
- FONT_SIZE_IGNORE,
+ IGNORE_SIZE,
+ IGNORE_STYLE,
Color_ignore,
Color_ignore,
FONT_IGNORE,
FONT_IGNORE,
FONT_IGNORE,
+ FONT_IGNORE,
+ FONT_IGNORE,
+ FONT_IGNORE,
+ FONT_IGNORE,
+ FONT_IGNORE,
FONT_IGNORE);
*this = sane_font;
}
+
/// Decreases font size_ by one
FontInfo & FontInfo::decSize()
{
switch (size_) {
- case FONT_SIZE_HUGER: size_ = FONT_SIZE_HUGE; break;
- case FONT_SIZE_HUGE: size_ = FONT_SIZE_LARGEST; break;
- case FONT_SIZE_LARGEST: size_ = FONT_SIZE_LARGER; break;
- case FONT_SIZE_LARGER: size_ = FONT_SIZE_LARGE; break;
- case FONT_SIZE_LARGE: size_ = FONT_SIZE_NORMAL; break;
- case FONT_SIZE_NORMAL: size_ = FONT_SIZE_SMALL; break;
- case FONT_SIZE_SMALL: size_ = FONT_SIZE_FOOTNOTE; break;
- case FONT_SIZE_FOOTNOTE: size_ = FONT_SIZE_SCRIPT; break;
- case FONT_SIZE_SCRIPT: size_ = FONT_SIZE_TINY; break;
- case FONT_SIZE_TINY: break;
- case FONT_SIZE_INCREASE:
- LYXERR0("Can't FontInfo::decSize on FONT_SIZE_INCREASE");
+ case HUGER_SIZE: size_ = HUGE_SIZE; break;
+ case HUGE_SIZE: size_ = LARGEST_SIZE; break;
+ case LARGEST_SIZE: size_ = LARGER_SIZE; break;
+ case LARGER_SIZE: size_ = LARGE_SIZE; break;
+ case LARGE_SIZE: size_ = NORMAL_SIZE; break;
+ case NORMAL_SIZE: size_ = SMALL_SIZE; break;
+ case SMALL_SIZE: size_ = FOOTNOTE_SIZE; break;
+ case FOOTNOTE_SIZE: size_ = SCRIPT_SIZE; break;
+ case SCRIPT_SIZE: size_ = TINY_SIZE; break;
+ case TINY_SIZE: break;
+ case INCREASE_SIZE:
+ LYXERR0("Can't FontInfo::decSize on INCREASE_SIZE");
break;
- case FONT_SIZE_DECREASE:
- LYXERR0("Can't FontInfo::decSize on FONT_SIZE_DECREASE");
+ case DECREASE_SIZE:
+ LYXERR0("Can't FontInfo::decSize on DECREASE_SIZE");
break;
- case FONT_SIZE_INHERIT:
- LYXERR0("Can't FontInfo::decSize on FONT_SIZE_INHERIT");
+ case INHERIT_SIZE:
+ LYXERR0("Can't FontInfo::decSize on INHERIT_SIZE");
break;
- case FONT_SIZE_IGNORE:
- LYXERR0("Can't FontInfo::decSize on FONT_SIZE_IGNORE");
+ case IGNORE_SIZE:
+ LYXERR0("Can't FontInfo::decSize on IGNORE_SIZE");
break;
}
return *this;
FontInfo & FontInfo::incSize()
{
switch (size_) {
- case FONT_SIZE_HUGER: break;
- case FONT_SIZE_HUGE: size_ = FONT_SIZE_HUGER; break;
- case FONT_SIZE_LARGEST: size_ = FONT_SIZE_HUGE; break;
- case FONT_SIZE_LARGER: size_ = FONT_SIZE_LARGEST; break;
- case FONT_SIZE_LARGE: size_ = FONT_SIZE_LARGER; break;
- case FONT_SIZE_NORMAL: size_ = FONT_SIZE_LARGE; break;
- case FONT_SIZE_SMALL: size_ = FONT_SIZE_NORMAL; break;
- case FONT_SIZE_FOOTNOTE: size_ = FONT_SIZE_SMALL; break;
- case FONT_SIZE_SCRIPT: size_ = FONT_SIZE_FOOTNOTE; break;
- case FONT_SIZE_TINY: size_ = FONT_SIZE_SCRIPT; break;
- case FONT_SIZE_INCREASE:
- LYXERR0("Can't FontInfo::incSize on FONT_SIZE_INCREASE");
+ case HUGER_SIZE: break;
+ case HUGE_SIZE: size_ = HUGER_SIZE; break;
+ case LARGEST_SIZE: size_ = HUGE_SIZE; break;
+ case LARGER_SIZE: size_ = LARGEST_SIZE; break;
+ case LARGE_SIZE: size_ = LARGER_SIZE; break;
+ case NORMAL_SIZE: size_ = LARGE_SIZE; break;
+ case SMALL_SIZE: size_ = NORMAL_SIZE; break;
+ case FOOTNOTE_SIZE: size_ = SMALL_SIZE; break;
+ case SCRIPT_SIZE: size_ = FOOTNOTE_SIZE; break;
+ case TINY_SIZE: size_ = SCRIPT_SIZE; break;
+ case INCREASE_SIZE:
+ LYXERR0("Can't FontInfo::incSize on INCREASE_SIZE");
break;
- case FONT_SIZE_DECREASE:
- LYXERR0("Can't FontInfo::incSize on FONT_SIZE_DECREASE");
+ case DECREASE_SIZE:
+ LYXERR0("Can't FontInfo::incSize on DECREASE_SIZE");
break;
- case FONT_SIZE_INHERIT:
- LYXERR0("Can't FontInfo::incSize on FONT_SIZE_INHERIT");
+ case INHERIT_SIZE:
+ LYXERR0("Can't FontInfo::incSize on INHERIT_SIZE");
break;
- case FONT_SIZE_IGNORE:
- LYXERR0("Can't FontInfo::incSize on FONT_SIZE_IGNORE");
+ case IGNORE_SIZE:
+ LYXERR0("Can't FontInfo::incSize on IGNORE_SIZE");
break;
}
return *this;
}
+double FontInfo::realSize() const
+{
+ double d = convert<double>(lyxrc.font_sizes[size()]);
+ // The following is according to the average of the values in the
+ // definitions of \defaultscriptratio and \defaultscriptscriptratio in LaTeX
+ // font packages. No attempt is made to implement the actual values from
+ // \DefineMathSizes.
+ switch (style()) {
+ case DISPLAY_STYLE:
+ case TEXT_STYLE:
+ case INHERIT_STYLE:
+ case IGNORE_STYLE:
+ break;
+ case SCRIPT_STYLE:
+ d *= .73;
+ break;
+ case SCRIPTSCRIPT_STYLE:
+ d *= .55;
+ break;
+ }
+ // Never go below the smallest size
+ return max(d, convert<double>(lyxrc.font_sizes[TINY_SIZE]));
+}
+
+
/// Reduce font to fall back to template where possible
void FontInfo::reduce(FontInfo const & tmplt)
{
if (shape_ == tmplt.shape_)
shape_ = INHERIT_SHAPE;
if (size_ == tmplt.size_)
- size_ = FONT_SIZE_INHERIT;
+ size_ = INHERIT_SIZE;
+ if (style_ == tmplt.style_)
+ style_ = INHERIT_STYLE;
if (emph_ == tmplt.emph_)
emph_ = FONT_INHERIT;
if (underbar_ == tmplt.underbar_)
underbar_ = FONT_INHERIT;
+ if (strikeout_ == tmplt.strikeout_)
+ strikeout_ = FONT_INHERIT;
+ if (xout_ == tmplt.xout_)
+ xout_ = FONT_INHERIT;
+ if (uuline_ == tmplt.uuline_)
+ uuline_ = FONT_INHERIT;
+ if (uwave_ == tmplt.uwave_)
+ uwave_ = FONT_INHERIT;
if (noun_ == tmplt.noun_)
noun_ = FONT_INHERIT;
if (color_ == tmplt.color_)
color_ = Color_inherit;
if (background_ == tmplt.background_)
background_ = Color_inherit;
+ if (nospellcheck_ == tmplt.nospellcheck_)
+ nospellcheck_ = FONT_INHERIT;
}
if (shape_ == INHERIT_SHAPE)
shape_ = tmplt.shape_;
- if (size_ == FONT_SIZE_INHERIT)
+ if (size_ == INHERIT_SIZE)
size_ = tmplt.size_;
+ if (style_ == INHERIT_STYLE)
+ style_ = tmplt.style_;
+
if (emph_ == FONT_INHERIT)
emph_ = tmplt.emph_;
if (underbar_ == FONT_INHERIT)
underbar_ = tmplt.underbar_;
+ if (strikeout_ == FONT_INHERIT)
+ strikeout_ = tmplt.strikeout_;
+
+ if (xout_ == FONT_INHERIT)
+ xout_ = tmplt.xout_;
+
+ if (uuline_ == FONT_INHERIT)
+ uuline_ = tmplt.uuline_;
+
+ if (uwave_ == FONT_INHERIT)
+ uwave_ = tmplt.uwave_;
+
if (noun_ == FONT_INHERIT)
noun_ = tmplt.noun_;
if (background_ == Color_inherit)
background_ = tmplt.background_;
+ if (nospellcheck_ == FONT_INHERIT)
+ nospellcheck_ = tmplt.nospellcheck_;
+
return *this;
}
+Changer FontInfo::changeColor(ColorCode const color)
+{
+ return changeVar(color_, color);
+}
+
+
+Changer FontInfo::changeShape(FontShape const shape)
+{
+ return changeVar(shape_, shape);
+}
+
+
+Changer FontInfo::changeStyle(MathStyle const new_style)
+{
+ return changeVar(style_, new_style);
+}
+
+
+Changer FontInfo::change(FontInfo font, bool realize)
+{
+ if (realize)
+ font.realize(*this);
+ return changeVar(*this, font);
+}
+
+
/// Updates a misc setting according to request
static FontState setMisc(FontState newfont,
FontState org)
shape_ = newfont.shape_;
// else it's IGNORE_SHAPE
- if (newfont.size_ != FONT_SIZE_IGNORE) {
- if (newfont.size_ == FONT_SIZE_INCREASE)
+ if (newfont.size_ != IGNORE_SIZE) {
+ if (newfont.size_ == INCREASE_SIZE)
incSize();
- else if (newfont.size_ == FONT_SIZE_DECREASE)
+ else if (newfont.size_ == DECREASE_SIZE)
decSize();
else
size_ = newfont.size_;
}
+ if (newfont.style_ != IGNORE_STYLE) {
+ style_ = newfont.style_;
+ }
+
setEmph(setMisc(newfont.emph_, emph_));
setUnderbar(setMisc(newfont.underbar_, underbar_));
+ setStrikeout(setMisc(newfont.strikeout_, strikeout_));
+ setXout(setMisc(newfont.xout_, xout_));
+ setUuline(setMisc(newfont.uuline_, uuline_));
+ setUwave(setMisc(newfont.uwave_, uwave_));
setNoun(setMisc(newfont.noun_, noun_));
setNumber(setMisc(newfont.number_, number_));
+ setNoSpellcheck(setMisc(newfont.nospellcheck_, nospellcheck_));
if (newfont.color_ == color_ && toggleall)
setColor(Color_inherit); // toggle 'back'
bool FontInfo::resolved() const
{
return (family_ != INHERIT_FAMILY && series_ != INHERIT_SERIES
- && shape_ != INHERIT_SHAPE && size_ != FONT_SIZE_INHERIT
+ && shape_ != INHERIT_SHAPE && size_ != INHERIT_SIZE
+ && style_ != INHERIT_STYLE
&& emph_ != FONT_INHERIT && underbar_ != FONT_INHERIT
- && noun_ != FONT_INHERIT
- && color_ != Color_inherit
- && background_ != Color_inherit);
+ && uuline_ != FONT_INHERIT && uwave_ != FONT_INHERIT
+ && strikeout_ != FONT_INHERIT && xout_ != FONT_INHERIT
+ && noun_ != FONT_INHERIT && color_ != Color_inherit
+ && background_ != Color_inherit && nospellcheck_ != FONT_INHERIT);
}
-ColorCode FontInfo::realColor() const
+Color FontInfo::realColor() const
{
+ if (paint_color_ != Color_none)
+ return paint_color_;
if (color_ == Color_none)
return Color_foreground;
return color_;
}
+
+namespace {
+
+void appendSep(string & s1, string const & s2)
+{
+ if (s2.empty())
+ return;
+ s1 += s1.empty() ? "" : "\n";
+ s1 += s2;
+}
+
+
+string makeCSSTag(string const & key, string const & val)
+{
+ return key + ": " + val + ";";
+}
+
+
+string getFamilyCSS(FontFamily const & f)
+{
+ switch (f) {
+ case ROMAN_FAMILY:
+ return "serif";
+ case SANS_FAMILY:
+ return "sans-serif";
+ case TYPEWRITER_FAMILY:
+ return "monospace";
+ case SYMBOL_FAMILY:
+ case CMR_FAMILY:
+ case CMSY_FAMILY:
+ case CMM_FAMILY:
+ case CMEX_FAMILY:
+ case MSA_FAMILY:
+ case MSB_FAMILY:
+ case DS_FAMILY:
+ case EUFRAK_FAMILY:
+ case RSFS_FAMILY:
+ case STMARY_FAMILY:
+ case WASY_FAMILY:
+ case ESINT_FAMILY:
+ case INHERIT_FAMILY:
+ case IGNORE_FAMILY:
+ break;
+ }
+ return "";
+}
+
+
+string getSeriesCSS(FontSeries const & s)
+{
+ switch (s) {
+ case MEDIUM_SERIES:
+ return "normal";
+ case BOLD_SERIES:
+ return "bold";
+ case INHERIT_SERIES:
+ case IGNORE_SERIES:
+ break;
+ }
+ return "";
+}
+
+
+string getShapeCSS(FontShape const & s)
+{
+ string fs = "normal";
+ string fv = "normal";
+ switch (s) {
+ case UP_SHAPE: break;
+ case ITALIC_SHAPE: fs = "italic"; break;
+ case SLANTED_SHAPE: fs = "oblique"; break;
+ case SMALLCAPS_SHAPE: fv = "small-caps"; break;
+ case IGNORE_SHAPE:
+ case INHERIT_SHAPE:
+ fs = ""; fv = ""; break;
+ }
+ string retval;
+ if (!fs.empty())
+ appendSep(retval, makeCSSTag("font-style", fs));
+ if (!fv.empty())
+ appendSep(retval, makeCSSTag("font-variant", fv));
+ return retval;
+}
+
+
+string getSizeCSS(FontSize const & s)
+{
+ switch (s) {
+ case TINY_SIZE:
+ return "xx-small";
+ case SCRIPT_SIZE:
+ return "x-small";
+ case FOOTNOTE_SIZE:
+ case SMALL_SIZE:
+ return "small";
+ case NORMAL_SIZE:
+ return "medium";
+ case LARGE_SIZE:
+ return "large";
+ case LARGER_SIZE:
+ case LARGEST_SIZE:
+ return "x-large";
+ case HUGE_SIZE:
+ case HUGER_SIZE:
+ return "xx-large";
+ case INCREASE_SIZE:
+ return "larger";
+ case DECREASE_SIZE:
+ return "smaller";
+ case IGNORE_SIZE:
+ case INHERIT_SIZE:
+ break;
+ }
+ return "";
+}
+
+} // namespace
+
+
+// FIXME This does not yet handle color
+docstring FontInfo::asCSS() const
+{
+ string retval;
+ string tmp = getFamilyCSS(family_);
+ if (!tmp.empty())
+ appendSep(retval, makeCSSTag("font-family", tmp));
+ tmp = getSeriesCSS(series_);
+ if (!tmp.empty())
+ appendSep(retval, makeCSSTag("font-weight", tmp));
+ appendSep(retval, getShapeCSS(shape_));
+ tmp = getSizeCSS(size_);
+ if (!tmp.empty())
+ appendSep(retval, makeCSSTag("font-size", tmp));
+ return from_ascii(retval);
+}
+
+
+docstring const FontInfo::stateText(bool const terse) const
+{
+ odocstringstream os;
+ if (family() != INHERIT_FAMILY && (!terse || family() != IGNORE_FAMILY))
+ os << _(GUIFamilyNames[family()]) << ", ";
+ if (series() != INHERIT_SERIES && (!terse || series() != IGNORE_SERIES))
+ os << _(GUISeriesNames[series()]) << ", ";
+ if (shape() != INHERIT_SHAPE && (!terse || shape() != IGNORE_SHAPE))
+ os << _(GUIShapeNames[shape()]) << ", ";
+ if (size() != INHERIT_SIZE && (!terse || size() != IGNORE_SIZE))
+ os << _(GUISizeNames[size()]) << ", ";
+ // FIXME: shall style be handled there? Probably not.
+ if (color() != Color_inherit && (!terse || color() != Color_ignore))
+ os << lcolor.getGUIName(color()) << ", ";
+ // FIXME: uncomment this when we support background.
+ //if (background() != Color_inherit)
+ // os << lcolor.getGUIName(background()) << ", ";
+ if (emph() != FONT_INHERIT && (!terse || emph() != FONT_IGNORE))
+ os << bformat(_("Emphasis %1$s, "),
+ _(GUIMiscNames[emph()]));
+ if (underbar() != FONT_INHERIT && (!terse || underbar() == FONT_ON))
+ os << bformat(_("Underline %1$s, "),
+ _(GUIMiscNames[underbar()]));
+ if (uuline() != FONT_INHERIT && (!terse || uuline() == FONT_ON))
+ os << bformat(_("Double underline %1$s, "),
+ _(GUIMiscNames[uuline()]));
+ if (uwave() != FONT_INHERIT && (!terse || uwave() == FONT_ON))
+ os << bformat(_("Wavy underline %1$s, "),
+ _(GUIMiscNames[uwave()]));
+ if (strikeout() != FONT_INHERIT && (!terse || strikeout() == FONT_ON))
+ os << bformat(_("Strike out %1$s, "),
+ _(GUIMiscNames[strikeout()]));
+ if (xout() != FONT_INHERIT && (!terse || xout() == FONT_ON))
+ os << bformat(_("Cross out %1$s, "),
+ _(GUIMiscNames[xout()]));
+ if (noun() != FONT_INHERIT && (!terse || noun() != FONT_IGNORE))
+ os << bformat(_("Noun %1$s, "),
+ _(GUIMiscNames[noun()]));
+ if (*this == inherit_font)
+ os << _("Default") << ", ";
+
+ return os.str();
+}
+
+
+// Set family according to lyx format string
+void setLyXFamily(string const & fam, FontInfo & f)
+{
+ string const s = ascii_lowercase(fam);
+
+ int i = 0;
+ while (LyXFamilyNames[i] != s &&
+ LyXFamilyNames[i] != string("error"))
+ ++i;
+ if (s == LyXFamilyNames[i])
+ f.setFamily(FontFamily(i));
+ else
+ LYXERR0("Unknown family `" << s << '\'');
+}
+
+
+// Set series according to lyx format string
+void setLyXSeries(string const & ser, FontInfo & f)
+{
+ string const s = ascii_lowercase(ser);
+
+ int i = 0;
+ while (LyXSeriesNames[i] != s &&
+ LyXSeriesNames[i] != string("error")) ++i;
+ if (s == LyXSeriesNames[i]) {
+ f.setSeries(FontSeries(i));
+ } else
+ LYXERR0("Unknown series `" << s << '\'');
+}
+
+
+// Set shape according to lyx format string
+void setLyXShape(string const & sha, FontInfo & f)
+{
+ string const s = ascii_lowercase(sha);
+
+ int i = 0;
+ while (LyXShapeNames[i] != s && LyXShapeNames[i] != string("error"))
+ ++i;
+ if (s == LyXShapeNames[i])
+ f.setShape(FontShape(i));
+ else
+ LYXERR0("Unknown shape `" << s << '\'');
+}
+
+
+// Set size according to lyx format string
+void setLyXSize(string const & siz, FontInfo & f)
+{
+ string const s = ascii_lowercase(siz);
+ int i = 0;
+ while (LyXSizeNames[i] != s && LyXSizeNames[i] != string("error"))
+ ++i;
+ if (s == LyXSizeNames[i]) {
+ f.setSize(FontSize(i));
+ } else
+ LYXERR0("Unknown size `" << s << '\'');
+}
+
+
+// Set size according to lyx format string
+FontState setLyXMisc(string const & siz)
+{
+ string const s = ascii_lowercase(siz);
+ int i = 0;
+ while (LyXMiscNames[i] != s &&
+ LyXMiscNames[i] != string("error")) ++i;
+ if (s == LyXMiscNames[i])
+ return FontState(i);
+ LYXERR0("Unknown misc flag `" << s << '\'');
+ return FONT_OFF;
+}
+
+
+/// Sets color after LyX text format
+void setLyXColor(string const & col, FontInfo & f)
+{
+ f.setColor(lcolor.getFromLyXName(col));
+}
+
+
+// Read a font definition from given file in lyx format
+// Used for layouts
+FontInfo lyxRead(Lexer & lex, FontInfo const & fi)
+{
+ FontInfo f = fi;
+ bool error = false;
+ bool finished = false;
+ while (!finished && lex.isOK() && !error) {
+ lex.next();
+ string const tok = ascii_lowercase(lex.getString());
+
+ if (tok.empty()) {
+ continue;
+ } else if (tok == "endfont") {
+ finished = true;
+ } else if (tok == "family") {
+ lex.next();
+ string const ttok = lex.getString();
+ setLyXFamily(ttok, f);
+ } else if (tok == "series") {
+ lex.next();
+ string const ttok = lex.getString();
+ setLyXSeries(ttok, f);
+ } else if (tok == "shape") {
+ lex.next();
+ string const ttok = lex.getString();
+ setLyXShape(ttok, f);
+ } else if (tok == "size") {
+ lex.next();
+ string const ttok = lex.getString();
+ setLyXSize(ttok, f);
+ } else if (tok == "misc") {
+ lex.next();
+ string const ttok = ascii_lowercase(lex.getString());
+
+ if (ttok == "no_bar") {
+ f.setUnderbar(FONT_OFF);
+ } else if (ttok == "no_strikeout") {
+ f.setStrikeout(FONT_OFF);
+ } else if (ttok == "no_xout") {
+ f.setXout(FONT_OFF);
+ } else if (ttok == "no_uuline") {
+ f.setUuline(FONT_OFF);
+ } else if (ttok == "no_uwave") {
+ f.setUwave(FONT_OFF);
+ } else if (ttok == "no_emph") {
+ f.setEmph(FONT_OFF);
+ } else if (ttok == "no_noun") {
+ f.setNoun(FONT_OFF);
+ } else if (ttok == "emph") {
+ f.setEmph(FONT_ON);
+ } else if (ttok == "underbar") {
+ f.setUnderbar(FONT_ON);
+ } else if (ttok == "strikeout") {
+ f.setStrikeout(FONT_ON);
+ } else if (ttok == "xout") {
+ f.setXout(FONT_ON);
+ } else if (ttok == "uuline") {
+ f.setUuline(FONT_ON);
+ } else if (ttok == "uwave") {
+ f.setUwave(FONT_ON);
+ } else if (ttok == "noun") {
+ f.setNoun(FONT_ON);
+ } else if (ttok == "nospellcheck") {
+ f.setNoSpellcheck(FONT_ON);
+ } else if (ttok == "no_nospellcheck") {
+ f.setNoSpellcheck(FONT_OFF);
+ } else {
+ lex.printError("Illegal misc type");
+ }
+ } else if (tok == "color") {
+ lex.next();
+ string const ttok = lex.getString();
+ setLyXColor(ttok, f);
+ } else {
+ lex.printError("Unknown tag");
+ error = true;
+ }
+ }
+ return f;
+}
+
+
+void lyxWrite(ostream & os, FontInfo const & f, string const & start, int level)
+{
+ string indent;
+ for (int i = 0; i < level; ++i)
+ indent += '\t';
+ ostringstream oss;
+ if (f.family() != INHERIT_FAMILY)
+ oss << indent << "\tFamily " << LyXFamilyNames[f.family()]
+ << '\n';
+ if (f.series() != INHERIT_SERIES)
+ oss << indent << "\tSeries " << LyXSeriesNames[f.series()]
+ << '\n';
+ if (f.shape() != INHERIT_SHAPE)
+ oss << indent << "\tShape " << LyXShapeNames[f.shape()]
+ << '\n';
+ if (f.size() != INHERIT_SIZE)
+ oss << indent << "\tSize " << LyXSizeNames[f.size()]
+ << '\n';
+ //FIXME: shall style be handled here? Probably not.
+ if (f.underbar() == FONT_ON)
+ oss << indent << "\tMisc Underbar\n";
+ else if (f.underbar() == FONT_OFF)
+ oss << indent << "\tMisc No_Bar\n";
+ if (f.strikeout() == FONT_ON)
+ oss << indent << "\tMisc Strikeout\n";
+ else if (f.strikeout() == FONT_OFF)
+ oss << indent << "\tMisc No_Strikeout\n";
+ if (f.xout() == FONT_ON)
+ oss << indent << "\tMisc Xout\n";
+ else if (f.xout() == FONT_OFF)
+ oss << indent << "\tMisc No_Xout\n";
+ if (f.uuline() == FONT_ON)
+ oss << indent << "\tMisc Uuline\n";
+ else if (f.uuline() == FONT_OFF)
+ oss << indent << "\tMisc No_Uuline\n";
+ if (f.uwave() == FONT_ON)
+ oss << indent << "\tMisc Uwave\n";
+ else if (f.uwave() == FONT_OFF)
+ oss << indent << "\tMisc No_Uwave\n";
+ if (f.emph() == FONT_ON)
+ oss << indent << "\tMisc Emph\n";
+ else if (f.emph() == FONT_OFF)
+ oss << indent << "\tMisc No_Emph\n";
+ if (f.noun() == FONT_ON)
+ oss << indent << "\tMisc Noun\n";
+ else if (f.noun() == FONT_OFF)
+ oss << indent << "\tMisc No_Noun\n";
+ if (f.nospellcheck() == FONT_ON)
+ oss << indent << "\tMisc NoSpellcheck\n";
+ else if (f.nospellcheck() == FONT_OFF)
+ oss << indent << "\tMisc No_NoSpellcheck\n";
+ if (f.color() != Color_inherit && f.color() != Color_none)
+ oss << indent << "\tColor " << lcolor.getLyXName(f.color())
+ << '\n';
+ if (!oss.str().empty()) {
+ os << indent << start << '\n'
+ << oss.str()
+ << indent << "EndFont\n";
+ }
+}
+
+
} // namespace lyx
projects / lyx.git / blobdiff