Since LyX uses "INHERIT" as a default, we do not want it for HTML.

[features.git] / src / FontInfo.cpp

diff --git a/src/FontInfo.cpp b/src/FontInfo.cpp
index b2ee8d7d27d2fc2c311141972c3a3da7fcc06453..491ebf3885c6e653924a46c37024227bd3104a84 100644 (file)
--- a/src/FontInfo.cpp
+++ b/src/FontInfo.cpp
@@ -17,6 +17,7 @@
 #include "FontInfo.h"
 
 #include "support/debug.h"
+#include "support/docstring.h"
 
 using namespace std;
 
@@ -32,6 +33,9 @@ FontInfo const sane_font(
        FONT_OFF,
        FONT_OFF,
        FONT_OFF,
+       FONT_OFF,
+       FONT_OFF,
+       FONT_OFF,
        FONT_OFF);
 
 FontInfo const inherit_font(
@@ -44,6 +48,9 @@ FontInfo const inherit_font(
        FONT_INHERIT,
        FONT_INHERIT,
        FONT_INHERIT,
+       FONT_INHERIT,
+       FONT_INHERIT,
+       FONT_INHERIT,
        FONT_OFF);
 
 FontInfo const ignore_font(
@@ -56,6 +63,9 @@ FontInfo const ignore_font(
        FONT_IGNORE,
        FONT_IGNORE,
        FONT_IGNORE,
+       FONT_IGNORE,
+       FONT_IGNORE,
+       FONT_IGNORE,
        FONT_IGNORE);
 
 
@@ -141,6 +151,12 @@ void FontInfo::reduce(FontInfo const & tmplt)
                emph_ = FONT_INHERIT;
        if (underbar_ == tmplt.underbar_)
                underbar_ = FONT_INHERIT;
+       if (strikeout_ == tmplt.strikeout_)
+               strikeout_ = 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_)
@@ -176,6 +192,15 @@ FontInfo & FontInfo::realize(FontInfo const & tmplt)
        if (underbar_ == FONT_INHERIT)
                underbar_ = tmplt.underbar_;
 
+       if (strikeout_ == FONT_INHERIT)
+               strikeout_ = tmplt.strikeout_;
+
+       if (uuline_ == FONT_INHERIT)
+               uuline_ = tmplt.uuline_;
+
+       if (uwave_ == FONT_INHERIT)
+               uwave_ = tmplt.uwave_;
+
        if (noun_ == FONT_INHERIT)
                noun_ = tmplt.noun_;
 
@@ -252,6 +277,9 @@ void FontInfo::update(FontInfo const & newfont, bool toggleall)
 
        setEmph(setMisc(newfont.emph_, emph_));
        setUnderbar(setMisc(newfont.underbar_, underbar_));
+       setStrikeout(setMisc(newfont.strikeout_, strikeout_));
+       setUuline(setMisc(newfont.uuline_, uuline_));
+       setUwave(setMisc(newfont.uwave_, uwave_));
        setNoun(setMisc(newfont.noun_, noun_));
        setNumber(setMisc(newfont.number_, number_));
 
@@ -272,7 +300,8 @@ 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
+               && uuline_ != FONT_INHERIT && uwave_ != FONT_INHERIT
+               && strikeout_ != FONT_INHERIT && noun_ != FONT_INHERIT
                && color_ != Color_inherit
                && background_ != Color_inherit);
 }
@@ -280,11 +309,143 @@ bool FontInfo::resolved() const
 
 Color FontInfo::realColor() const
 {
-       if (draw_color_ != Color_none)
-               return draw_color_;
+       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 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 anonymous
+
+
+// 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);      
+}
+
 } // namespace lyx