X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FFontInfo.cpp;h=983499db68a41f3c13ddfeea98aa581e24772eb1;hb=79cf3f5ec1088e7de988e889247ec300d42fb70b;hp=b6918efebfaae8e5e68aaed2f56caa0aea0b9b07;hpb=150cf11651ad92090a452bb9e6cb72d7eea886d5;p=lyx.git diff --git a/src/FontInfo.cpp b/src/FontInfo.cpp index b6918efebf..983499db68 100644 --- a/src/FontInfo.cpp +++ b/src/FontInfo.cpp @@ -3,10 +3,10 @@ * 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. @@ -14,17 +14,49 @@ #include +#include "ColorSet.h" #include "FontInfo.h" +#include "Lexer.h" +#include "LyXRC.h" -#include "debug.h" +#include "support/convert.h" +#include "support/debug.h" +#include "support/docstring.h" +#include "support/lstrings.h" +#include "support/RefChanger.h" +#include #include +#include -using std::endl; - +using namespace std; +using namespace lyx::support; namespace lyx { +// +// 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", "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, @@ -35,6 +67,11 @@ FontInfo const sane_font( FONT_OFF, FONT_OFF, FONT_OFF, + FONT_OFF, + FONT_OFF, + FONT_OFF, + FONT_OFF, + FONT_OFF, FONT_OFF); FontInfo const inherit_font( @@ -47,7 +84,12 @@ FontInfo const inherit_font( 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, @@ -59,6 +101,11 @@ FontInfo const ignore_font( FONT_IGNORE, FONT_IGNORE, FONT_IGNORE, + FONT_IGNORE, + FONT_IGNORE, + FONT_IGNORE, + FONT_IGNORE, + FONT_IGNORE, FONT_IGNORE); @@ -67,6 +114,7 @@ FontInfo::FontInfo() *this = sane_font; } + /// Decreases font size_ by one FontInfo & FontInfo::decSize() { @@ -82,16 +130,16 @@ FontInfo & FontInfo::decSize() case FONT_SIZE_SCRIPT: size_ = FONT_SIZE_TINY; break; case FONT_SIZE_TINY: break; case FONT_SIZE_INCREASE: - lyxerr << "Can't FontInfo::decSize on FONT_SIZE_INCREASE" << endl; + LYXERR0("Can't FontInfo::decSize on FONT_SIZE_INCREASE"); break; case FONT_SIZE_DECREASE: - lyxerr <<"Can't FontInfo::decSize on FONT_SIZE_DECREASE" << endl; + LYXERR0("Can't FontInfo::decSize on FONT_SIZE_DECREASE"); break; case FONT_SIZE_INHERIT: - lyxerr <<"Can't FontInfo::decSize on FONT_SIZE_INHERIT" << endl; + LYXERR0("Can't FontInfo::decSize on FONT_SIZE_INHERIT"); break; case FONT_SIZE_IGNORE: - lyxerr <<"Can't FontInfo::decSize on FONT_SIZE_IGNORE" << endl; + LYXERR0("Can't FontInfo::decSize on FONT_SIZE_IGNORE"); break; } return *this; @@ -113,22 +161,45 @@ FontInfo & FontInfo::incSize() case FONT_SIZE_SCRIPT: size_ = FONT_SIZE_FOOTNOTE; break; case FONT_SIZE_TINY: size_ = FONT_SIZE_SCRIPT; break; case FONT_SIZE_INCREASE: - lyxerr <<"Can't FontInfo::incSize on FONT_SIZE_INCREASE" << endl; + LYXERR0("Can't FontInfo::incSize on FONT_SIZE_INCREASE"); break; case FONT_SIZE_DECREASE: - lyxerr <<"Can't FontInfo::incSize on FONT_SIZE_DECREASE" << endl; + LYXERR0("Can't FontInfo::incSize on FONT_SIZE_DECREASE"); break; case FONT_SIZE_INHERIT: - lyxerr <<"Can't FontInfo::incSize on FONT_SIZE_INHERIT" << endl; + LYXERR0("Can't FontInfo::incSize on FONT_SIZE_INHERIT"); break; case FONT_SIZE_IGNORE: - lyxerr <<"Can't FontInfo::incSize on FONT_SIZE_IGNORE" << endl; + LYXERR0("Can't FontInfo::incSize on FONT_SIZE_IGNORE"); break; } return *this; } +double FontInfo::realSize() const +{ + double d = convert(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 LM_ST_DISPLAY: + case LM_ST_TEXT: + break; + case LM_ST_SCRIPT: + d *= .73; + break; + case LM_ST_SCRIPTSCRIPT: + d *= .55; + break; + } + // Never go below the smallest size + return max(d, convert(lyxrc.font_sizes[FONT_SIZE_TINY])); +} + + /// Reduce font to fall back to template where possible void FontInfo::reduce(FontInfo const & tmplt) { @@ -144,12 +215,22 @@ void FontInfo::reduce(FontInfo const & tmplt) 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; } @@ -179,6 +260,18 @@ FontInfo & FontInfo::realize(FontInfo const & tmplt) 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_; @@ -188,10 +281,39 @@ FontInfo & FontInfo::realize(FontInfo const & tmplt) if (background_ == Color_inherit) background_ = tmplt.background_; + if (nospellcheck_ == FONT_INHERIT) + nospellcheck_ = tmplt.nospellcheck_; + return *this; } +Changer FontInfo::changeColor(ColorCode const color) +{ + return make_change(color_, color); +} + + +Changer FontInfo::changeShape(FontShape const shape) +{ + return make_change(shape_, shape); +} + + +Changer FontInfo::changeStyle(MathStyle const new_style) +{ + return make_change(style_, new_style); +} + + +Changer FontInfo::change(FontInfo font, bool realiz) +{ + if (realiz) + font.realize(*this); + return make_change(*this, font); +} + + /// Updates a misc setting according to request static FontState setMisc(FontState newfont, FontState org) @@ -202,8 +324,8 @@ static FontState setMisc(FontState newfont, else if (org == FONT_OFF) return FONT_ON; else { - lyxerr <<"Font::setMisc: Need state" - " FONT_ON or FONT_OFF to toggle. Setting to FONT_ON" << endl; + LYXERR0("Font::setMisc: Need state" + " FONT_ON or FONT_OFF to toggle. Setting to FONT_ON"); return FONT_ON; } } else if (newfont == FONT_IGNORE) @@ -255,8 +377,13 @@ void FontInfo::update(FontInfo const & newfont, bool toggleall) 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' @@ -275,17 +402,381 @@ bool FontInfo::resolved() const return (family_ != INHERIT_FAMILY && series_ != INHERIT_SERIES && shape_ != INHERIT_SHAPE && size_ != FONT_SIZE_INHERIT && 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 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 FONT_SIZE_TINY: + return "xx-small"; + case FONT_SIZE_SCRIPT: + return "x-small"; + case FONT_SIZE_FOOTNOTE: + case FONT_SIZE_SMALL: + return "small"; + case FONT_SIZE_NORMAL: + return "medium"; + case FONT_SIZE_LARGE: + return "large"; + case FONT_SIZE_LARGER: + case FONT_SIZE_LARGEST: + return "x-large"; + case FONT_SIZE_HUGE: + case FONT_SIZE_HUGER: + return "xx-large"; + case FONT_SIZE_INCREASE: + return "larger"; + case FONT_SIZE_DECREASE: + return "smaller"; + case FONT_SIZE_IGNORE: + case FONT_SIZE_INHERIT: + 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); +} + + +// 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() != FONT_SIZE_INHERIT) + oss << indent << "\tSize " << LyXSizeNames[f.size()] + << '\n'; + 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