src/FontInfo.cpp

   1 /**
   2  * \file src/FontInfo.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author Jean-Marc Lasgouttes
   8  * \author Angus Leeming
   9  * \author André Pönitz
  10  * \author Dekel Tsur
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 #include <config.h>
  16
  17 #include "FontInfo.h"
  18
  19 #include "ColorSet.h"
  20 #include "Lexer.h"
  21 #include "LyXRC.h"
  22
  23 #include "support/convert.h"
  24 #include "support/debug.h"
  25 #include "support/docstring.h"
  26 #include "support/gettext.h"
  27 #include "support/lstrings.h"
  28 #include "support/RefChanger.h"
  29
  30 #include <algorithm>
  31 #include <ostream>
  32 #include <sstream>
  33
  34 using namespace std;
  35 using namespace lyx::support;
  36
  37 namespace lyx {
  38
  39 //
  40 // Names for the GUI
  41 //
  42
  43 char const * GUIFamilyNames[NUM_FAMILIES + 2 /* default & error */] =
  44 { N_("Roman"), N_("Sans Serif"), N_("Typewriter"), N_("Symbol"),
  45   "cmr", "cmsy", "cmm", "cmex", "msa", "msb", "ds", "eufrak", "rsfs", "stmry",
  46   "wasy", "esint", N_("Inherit"), N_("Ignore") };
  47
  48 char const * GUISeriesNames[NUM_SERIES + 2 /* default & error */] =
  49 { N_("Medium"), N_("Bold"), N_("Inherit"), N_("Ignore") };
  50
  51 char const * GUIShapeNames[NUM_SHAPE + 2 /* default & error */] =
  52 { N_("Upright"), N_("Italic"), N_("Slanted"), N_("Smallcaps"), N_("Inherit"),
  53   N_("Ignore") };
  54
  55 char const * GUISizeNames[NUM_SIZE + 4 /* increase, decrease, default & error */] =
  56 { N_("Tiny"), N_("Smallest"), N_("Smaller"), N_("Small"), N_("Normal"), N_("Large"),
  57   N_("Larger"), N_("Largest"), N_("Huge"), N_("Huger"), N_("Increase"), N_("Decrease"),
  58   N_("Inherit"), N_("Ignore") };
  59
  60 char const * GUIMiscNames[5] =
  61 { N_("Off"), N_("On"), N_("Toggle"), N_("Inherit"), N_("Ignore") };
  62
  63
  64 //
  65 // Strings used to read and write .lyx format files
  66 //
  67 char const * LyXFamilyNames[NUM_FAMILIES + 2 /* default & error */] =
  68 { "roman", "sans", "typewriter", "symbol",
  69   "cmr", "cmsy", "cmm", "cmex", "msa", "msb", "ds", "eufrak", "rsfs", "stmry",
  70   "wasy", "esint", "default", "error" };
  71
  72 char const * LyXSeriesNames[NUM_SERIES + 2 /* default & error */] =
  73 { "medium", "bold", "default", "error" };
  74
  75 char const * LyXShapeNames[NUM_SHAPE + 2 /* default & error */] =
  76 { "up", "italic", "slanted", "smallcaps", "default", "error" };
  77
  78 char const * LyXSizeNames[NUM_SIZE + 4 /* increase, decrease, default & error */] =
  79 { "tiny", "scriptsize", "footnotesize", "small", "normal", "large",
  80   "larger", "largest", "huge", "giant",
  81   "increase", "decrease", "default", "error" };
  82
  83 char const * LyXMiscNames[5] =
  84 { "off", "on", "toggle", "default", "error" };
  85
  86
  87 FontInfo const sane_font(
  88         ROMAN_FAMILY,
  89         MEDIUM_SERIES,
  90         UP_SHAPE,
  91         NORMAL_SIZE,
  92         TEXT_STYLE,
  93         Color_none,
  94         Color_background,
  95         FONT_OFF,
  96         FONT_OFF,
  97         FONT_OFF,
  98         FONT_OFF,
  99         FONT_OFF,
 100         FONT_OFF,
 101         FONT_OFF,
 102         FONT_OFF,
 103         FONT_OFF);
 104
 105 FontInfo const inherit_font(
 106         INHERIT_FAMILY,
 107         INHERIT_SERIES,
 108         INHERIT_SHAPE,
 109         INHERIT_SIZE,
 110         INHERIT_STYLE,
 111         Color_inherit,
 112         Color_inherit,
 113         FONT_INHERIT,
 114         FONT_INHERIT,
 115         FONT_INHERIT,
 116         FONT_INHERIT,
 117         FONT_INHERIT,
 118         FONT_INHERIT,
 119         FONT_INHERIT,
 120         FONT_OFF,
 121         FONT_INHERIT);
 122
 123 FontInfo const ignore_font(
 124         IGNORE_FAMILY,
 125         IGNORE_SERIES,
 126         IGNORE_SHAPE,
 127         IGNORE_SIZE,
 128         IGNORE_STYLE,
 129         Color_ignore,
 130         Color_ignore,
 131         FONT_IGNORE,
 132         FONT_IGNORE,
 133         FONT_IGNORE,
 134         FONT_IGNORE,
 135         FONT_IGNORE,
 136         FONT_IGNORE,
 137         FONT_IGNORE,
 138         FONT_IGNORE,
 139         FONT_IGNORE);
 140
 141
 142 FontInfo::FontInfo()
 143 {
 144         *this = sane_font;
 145 }
 146
 147
 148 /// Decreases font size_ by one
 149 FontInfo & FontInfo::decSize()
 150 {
 151         switch (size_) {
 152         case HUGER_SIZE:        size_ = HUGE_SIZE;     break;
 153         case HUGE_SIZE:         size_ = LARGEST_SIZE;  break;
 154         case LARGEST_SIZE:      size_ = LARGER_SIZE;   break;
 155         case LARGER_SIZE:       size_ = LARGE_SIZE;    break;
 156         case LARGE_SIZE:        size_ = NORMAL_SIZE;   break;
 157         case NORMAL_SIZE:       size_ = SMALL_SIZE;    break;
 158         case SMALL_SIZE:        size_ = FOOTNOTE_SIZE; break;
 159         case FOOTNOTE_SIZE:     size_ = SCRIPT_SIZE;   break;
 160         case SCRIPT_SIZE:       size_ = TINY_SIZE;     break;
 161         case TINY_SIZE:         break;
 162         case INCREASE_SIZE:
 163                 LYXERR0("Can't FontInfo::decSize on INCREASE_SIZE");
 164                 break;
 165         case DECREASE_SIZE:
 166                 LYXERR0("Can't FontInfo::decSize on DECREASE_SIZE");
 167                 break;
 168         case INHERIT_SIZE:
 169                 LYXERR0("Can't FontInfo::decSize on INHERIT_SIZE");
 170                 break;
 171         case IGNORE_SIZE:
 172                 LYXERR0("Can't FontInfo::decSize on IGNORE_SIZE");
 173                 break;
 174         }
 175         return *this;
 176 }
 177
 178
 179 /// Increases font size_ by one
 180 FontInfo & FontInfo::incSize()
 181 {
 182         switch (size_) {
 183         case HUGER_SIZE:        break;
 184         case HUGE_SIZE:         size_ = HUGER_SIZE;    break;
 185         case LARGEST_SIZE:      size_ = HUGE_SIZE;     break;
 186         case LARGER_SIZE:       size_ = LARGEST_SIZE;  break;
 187         case LARGE_SIZE:        size_ = LARGER_SIZE;   break;
 188         case NORMAL_SIZE:       size_ = LARGE_SIZE;    break;
 189         case SMALL_SIZE:        size_ = NORMAL_SIZE;   break;
 190         case FOOTNOTE_SIZE:     size_ = SMALL_SIZE;    break;
 191         case SCRIPT_SIZE:       size_ = FOOTNOTE_SIZE; break;
 192         case TINY_SIZE:         size_ = SCRIPT_SIZE;   break;
 193         case INCREASE_SIZE:
 194                 LYXERR0("Can't FontInfo::incSize on INCREASE_SIZE");
 195                 break;
 196         case DECREASE_SIZE:
 197                 LYXERR0("Can't FontInfo::incSize on DECREASE_SIZE");
 198                 break;
 199         case INHERIT_SIZE:
 200                 LYXERR0("Can't FontInfo::incSize on INHERIT_SIZE");
 201                 break;
 202         case IGNORE_SIZE:
 203                 LYXERR0("Can't FontInfo::incSize on IGNORE_SIZE");
 204                 break;
 205         }
 206         return *this;
 207 }
 208
 209
 210 double FontInfo::realSize() const
 211 {
 212         double d = convert<double>(lyxrc.font_sizes[size()]);
 213         // The following is according to the average of the values in the
 214         // definitions of \defaultscriptratio and \defaultscriptscriptratio in LaTeX
 215         // font packages. No attempt is made to implement the actual values from
 216         // \DefineMathSizes.
 217         switch (style()) {
 218         case DISPLAY_STYLE:
 219         case TEXT_STYLE:
 220         case INHERIT_STYLE:
 221         case IGNORE_STYLE:
 222                 break;
 223         case SCRIPT_STYLE:
 224                 d *= .73;
 225                 break;
 226         case SCRIPTSCRIPT_STYLE:
 227                 d *= .55;
 228                 break;
 229         }
 230         // Never go below the smallest size
 231         return max(d, convert<double>(lyxrc.font_sizes[TINY_SIZE]));
 232 }
 233
 234
 235 /// Reduce font to fall back to template where possible
 236 void FontInfo::reduce(FontInfo const & tmplt)
 237 {
 238         if (family_ == tmplt.family_)
 239                 family_ = INHERIT_FAMILY;
 240         if (series_ == tmplt.series_)
 241                 series_ = INHERIT_SERIES;
 242         if (shape_ == tmplt.shape_)
 243                 shape_ = INHERIT_SHAPE;
 244         if (size_ == tmplt.size_)
 245                 size_ = INHERIT_SIZE;
 246         if (style_ == tmplt.style_)
 247                 style_ = INHERIT_STYLE;
 248         if (emph_ == tmplt.emph_)
 249                 emph_ = FONT_INHERIT;
 250         if (underbar_ == tmplt.underbar_)
 251                 underbar_ = FONT_INHERIT;
 252         if (strikeout_ == tmplt.strikeout_)
 253                 strikeout_ = FONT_INHERIT;
 254         if (xout_ == tmplt.xout_)
 255                 xout_ = FONT_INHERIT;
 256         if (uuline_ == tmplt.uuline_)
 257                 uuline_ = FONT_INHERIT;
 258         if (uwave_ == tmplt.uwave_)
 259                 uwave_ = FONT_INHERIT;
 260         if (noun_ == tmplt.noun_)
 261                 noun_ = FONT_INHERIT;
 262         if (color_ == tmplt.color_)
 263                 color_ = Color_inherit;
 264         if (background_ == tmplt.background_)
 265                 background_ = Color_inherit;
 266         if (nospellcheck_ == tmplt.nospellcheck_)
 267                 nospellcheck_ = FONT_INHERIT;
 268 }
 269
 270
 271 /// Realize font from a template
 272 FontInfo & FontInfo::realize(FontInfo const & tmplt)
 273 {
 274         if ((*this) == inherit_font) {
 275                 operator=(tmplt);
 276                 return *this;
 277         }
 278
 279         if (family_ == INHERIT_FAMILY)
 280                 family_ = tmplt.family_;
 281
 282         if (series_ == INHERIT_SERIES)
 283                 series_ = tmplt.series_;
 284
 285         if (shape_ == INHERIT_SHAPE)
 286                 shape_ = tmplt.shape_;
 287
 288         if (size_ == INHERIT_SIZE)
 289                 size_ = tmplt.size_;
 290
 291         if (style_ == INHERIT_STYLE)
 292                 style_ = tmplt.style_;
 293
 294         if (emph_ == FONT_INHERIT)
 295                 emph_ = tmplt.emph_;
 296
 297         if (underbar_ == FONT_INHERIT)
 298                 underbar_ = tmplt.underbar_;
 299
 300         if (strikeout_ == FONT_INHERIT)
 301                 strikeout_ = tmplt.strikeout_;
 302
 303         if (xout_ == FONT_INHERIT)
 304                 xout_ = tmplt.xout_;
 305
 306         if (uuline_ == FONT_INHERIT)
 307                 uuline_ = tmplt.uuline_;
 308
 309         if (uwave_ == FONT_INHERIT)
 310                 uwave_ = tmplt.uwave_;
 311
 312         if (noun_ == FONT_INHERIT)
 313                 noun_ = tmplt.noun_;
 314
 315         if (color_ == Color_inherit)
 316                 color_ = tmplt.color_;
 317
 318         if (background_ == Color_inherit)
 319                 background_ = tmplt.background_;
 320
 321         if (nospellcheck_ == FONT_INHERIT)
 322                 nospellcheck_ = tmplt.nospellcheck_;
 323
 324         return *this;
 325 }
 326
 327
 328 Changer FontInfo::changeColor(ColorCode const color)
 329 {
 330         return make_change(color_, color);
 331 }
 332
 333
 334 Changer FontInfo::changeShape(FontShape const shape)
 335 {
 336         return make_change(shape_, shape);
 337 }
 338
 339
 340 Changer FontInfo::changeStyle(MathStyle const new_style)
 341 {
 342         return make_change(style_, new_style);
 343 }
 344
 345
 346 Changer FontInfo::change(FontInfo font, bool realiz)
 347 {
 348         if (realiz)
 349                 font.realize(*this);
 350         return make_change(*this, font);
 351 }
 352
 353
 354 /// Updates a misc setting according to request
 355 static FontState setMisc(FontState newfont,
 356         FontState org)
 357 {
 358         if (newfont == FONT_TOGGLE) {
 359                 if (org == FONT_ON)
 360                         return FONT_OFF;
 361                 else if (org == FONT_OFF)
 362                         return FONT_ON;
 363                 else {
 364                         LYXERR0("Font::setMisc: Need state"
 365                                 " FONT_ON or FONT_OFF to toggle. Setting to FONT_ON");
 366                         return FONT_ON;
 367                 }
 368         } else if (newfont == FONT_IGNORE)
 369                 return org;
 370         else
 371                 return newfont;
 372 }
 373
 374 /// Updates font settings according to request
 375 void FontInfo::update(FontInfo const & newfont, bool toggleall)
 376 {
 377         if (newfont.family_ == family_ && toggleall)
 378                 setFamily(INHERIT_FAMILY); // toggle 'back'
 379         else if (newfont.family_ != IGNORE_FAMILY)
 380                 setFamily(newfont.family_);
 381         // else it's IGNORE_SHAPE
 382
 383         // "Old" behaviour: "Setting" bold will toggle bold on/off.
 384         switch (newfont.series_) {
 385         case BOLD_SERIES:
 386                 // We toggle...
 387                 if (series_ == BOLD_SERIES && toggleall)
 388                         setSeries(MEDIUM_SERIES);
 389                 else
 390                         setSeries(BOLD_SERIES);
 391                 break;
 392         case MEDIUM_SERIES:
 393         case INHERIT_SERIES:
 394                 setSeries(newfont.series_);
 395                 break;
 396         case IGNORE_SERIES:
 397                 break;
 398         }
 399
 400         if (newfont.shape_ == shape_ && toggleall)
 401                 shape_ = INHERIT_SHAPE; // toggle 'back'
 402         else if (newfont.shape_ != IGNORE_SHAPE)
 403                 shape_ = newfont.shape_;
 404         // else it's IGNORE_SHAPE
 405
 406         if (newfont.size_ != IGNORE_SIZE) {
 407                 if (newfont.size_ == INCREASE_SIZE)
 408                         incSize();
 409                 else if (newfont.size_ == DECREASE_SIZE)
 410                         decSize();
 411                 else
 412                         size_ = newfont.size_;
 413         }
 414
 415         if (newfont.style_ != IGNORE_STYLE) {
 416                         style_ = newfont.style_;
 417         }
 418
 419         setEmph(setMisc(newfont.emph_, emph_));
 420         setUnderbar(setMisc(newfont.underbar_, underbar_));
 421         setStrikeout(setMisc(newfont.strikeout_, strikeout_));
 422         setXout(setMisc(newfont.xout_, xout_));
 423         setUuline(setMisc(newfont.uuline_, uuline_));
 424         setUwave(setMisc(newfont.uwave_, uwave_));
 425         setNoun(setMisc(newfont.noun_, noun_));
 426         setNumber(setMisc(newfont.number_, number_));
 427         setNoSpellcheck(setMisc(newfont.nospellcheck_, nospellcheck_));
 428
 429         if (newfont.color_ == color_ && toggleall)
 430                 setColor(Color_inherit); // toggle 'back'
 431         else if (newfont.color_ != Color_ignore)
 432                 setColor(newfont.color_);
 433
 434         if (newfont.background_ == background_ && toggleall)
 435                 setBackground(Color_inherit); // toggle 'back'
 436         else if (newfont.background_ != Color_ignore)
 437                 setBackground(newfont.background_);
 438 }
 439
 440 /// Is font resolved?
 441 bool FontInfo::resolved() const
 442 {
 443         return (family_ != INHERIT_FAMILY && series_ != INHERIT_SERIES
 444                 && shape_ != INHERIT_SHAPE && size_ != INHERIT_SIZE
 445                 && style_ != INHERIT_STYLE
 446                 && emph_ != FONT_INHERIT && underbar_ != FONT_INHERIT
 447                 && uuline_ != FONT_INHERIT && uwave_ != FONT_INHERIT
 448                 && strikeout_ != FONT_INHERIT && xout_ != FONT_INHERIT
 449                 && noun_ != FONT_INHERIT && color_ != Color_inherit
 450                 && background_ != Color_inherit && nospellcheck_ != FONT_INHERIT);
 451 }
 452
 453
 454 Color FontInfo::realColor() const
 455 {
 456         if (paint_color_ != Color_none)
 457                 return paint_color_;
 458         if (color_ == Color_none)
 459                 return Color_foreground;
 460         return color_;
 461 }
 462
 463
 464 namespace {
 465
 466 void appendSep(string & s1, string const & s2)
 467 {
 468         if (s2.empty())
 469                 return;
 470         s1 += s1.empty() ? "" : "\n";
 471         s1 += s2;
 472 }
 473
 474
 475 string makeCSSTag(string const & key, string const & val)
 476 {
 477         return key + ": " + val + ";";
 478 }
 479
 480
 481 string getFamilyCSS(FontFamily const & f)
 482 {
 483         switch (f) {
 484         case ROMAN_FAMILY:
 485                 return "serif";
 486         case SANS_FAMILY:
 487                 return "sans-serif";
 488         case TYPEWRITER_FAMILY:
 489                 return "monospace";
 490         case SYMBOL_FAMILY:
 491         case CMR_FAMILY:
 492         case CMSY_FAMILY:
 493         case CMM_FAMILY:
 494         case CMEX_FAMILY:
 495         case MSA_FAMILY:
 496         case MSB_FAMILY:
 497         case DS_FAMILY:
 498         case EUFRAK_FAMILY:
 499         case RSFS_FAMILY:
 500         case STMARY_FAMILY:
 501         case WASY_FAMILY:
 502         case ESINT_FAMILY:
 503         case INHERIT_FAMILY:
 504         case IGNORE_FAMILY:
 505                 break;
 506         }
 507         return "";
 508 }
 509
 510
 511 string getSeriesCSS(FontSeries const & s)
 512 {
 513         switch (s) {
 514         case MEDIUM_SERIES:
 515                 return "normal";
 516         case BOLD_SERIES:
 517                 return "bold";
 518         case INHERIT_SERIES:
 519         case IGNORE_SERIES:
 520                 break;
 521         }
 522         return "";
 523 }
 524
 525
 526 string getShapeCSS(FontShape const & s)
 527 {
 528         string fs = "normal";
 529         string fv = "normal";
 530         switch (s) {
 531         case UP_SHAPE: break;
 532         case ITALIC_SHAPE: fs = "italic"; break;
 533         case SLANTED_SHAPE: fs = "oblique"; break;
 534         case SMALLCAPS_SHAPE: fv = "small-caps"; break;
 535         case IGNORE_SHAPE:
 536         case INHERIT_SHAPE:
 537                 fs = ""; fv = ""; break;
 538         }
 539         string retval;
 540         if (!fs.empty())
 541                 appendSep(retval, makeCSSTag("font-style", fs));
 542         if (!fv.empty())
 543                 appendSep(retval, makeCSSTag("font-variant", fv));
 544         return retval;
 545 }
 546
 547
 548 string getSizeCSS(FontSize const & s)
 549 {
 550         switch (s) {
 551         case TINY_SIZE:
 552                 return "xx-small";
 553         case SCRIPT_SIZE:
 554                 return "x-small";
 555         case FOOTNOTE_SIZE:
 556         case SMALL_SIZE:
 557                 return "small";
 558         case NORMAL_SIZE:
 559                 return "medium";
 560         case LARGE_SIZE:
 561                 return "large";
 562         case LARGER_SIZE:
 563         case LARGEST_SIZE:
 564                 return "x-large";
 565         case HUGE_SIZE:
 566         case HUGER_SIZE:
 567                 return "xx-large";
 568         case INCREASE_SIZE:
 569                 return "larger";
 570         case DECREASE_SIZE:
 571                 return "smaller";
 572         case IGNORE_SIZE:
 573         case INHERIT_SIZE:
 574                 break;
 575         }
 576         return "";
 577 }
 578
 579 } // namespace
 580
 581
 582 // FIXME This does not yet handle color
 583 docstring FontInfo::asCSS() const
 584 {
 585         string retval;
 586         string tmp = getFamilyCSS(family_);
 587         if (!tmp.empty())
 588                 appendSep(retval, makeCSSTag("font-family", tmp));
 589         tmp = getSeriesCSS(series_);
 590         if (!tmp.empty())
 591                 appendSep(retval, makeCSSTag("font-weight", tmp));
 592         appendSep(retval, getShapeCSS(shape_));
 593         tmp = getSizeCSS(size_);
 594         if (!tmp.empty())
 595                 appendSep(retval, makeCSSTag("font-size", tmp));
 596         return from_ascii(retval);
 597 }
 598
 599
 600 docstring const FontInfo::stateText(bool const terse) const
 601 {
 602         odocstringstream os;
 603         if (family() != INHERIT_FAMILY && (!terse || family() != IGNORE_FAMILY))
 604                 os << _(GUIFamilyNames[family()]) << ", ";
 605         if (series() != INHERIT_SERIES && (!terse || series() != IGNORE_SERIES))
 606                 os << _(GUISeriesNames[series()]) << ", ";
 607         if (shape() != INHERIT_SHAPE && (!terse || shape() != IGNORE_SHAPE))
 608                 os << _(GUIShapeNames[shape()]) << ", ";
 609         if (size() != INHERIT_SIZE && (!terse || size() != IGNORE_SIZE))
 610                 os << _(GUISizeNames[size()]) << ", ";
 611         // FIXME: shall style be handled there? Probably not.
 612         if (color() != Color_inherit && (!terse || color() != Color_ignore))
 613                 os << lcolor.getGUIName(color()) << ", ";
 614         // FIXME: uncomment this when we support background.
 615         //if (background() != Color_inherit)
 616         //      os << lcolor.getGUIName(background()) << ", ";
 617         if (emph() != FONT_INHERIT && (!terse || emph() != FONT_IGNORE))
 618                 os << bformat(_("Emphasis %1$s, "),
 619                               _(GUIMiscNames[emph()]));
 620         if (underbar() != FONT_INHERIT && (!terse || underbar() == FONT_ON))
 621                 os << bformat(_("Underline %1$s, "),
 622                               _(GUIMiscNames[underbar()]));
 623         if (uuline() != FONT_INHERIT && (!terse || uuline() == FONT_ON))
 624                 os << bformat(_("Double underline %1$s, "),
 625                               _(GUIMiscNames[uuline()]));
 626         if (uwave() != FONT_INHERIT && (!terse || uwave() == FONT_ON))
 627                 os << bformat(_("Wavy underline %1$s, "),
 628                               _(GUIMiscNames[uwave()]));
 629         if (strikeout() != FONT_INHERIT && (!terse || strikeout() == FONT_ON))
 630                 os << bformat(_("Strike out %1$s, "),
 631                               _(GUIMiscNames[strikeout()]));
 632         if (xout() != FONT_INHERIT && (!terse || xout() == FONT_ON))
 633                 os << bformat(_("Cross out %1$s, "),
 634                               _(GUIMiscNames[xout()]));
 635         if (noun() != FONT_INHERIT && (!terse || noun() != FONT_IGNORE))
 636                 os << bformat(_("Noun %1$s, "),
 637                               _(GUIMiscNames[noun()]));
 638         if (*this == inherit_font)
 639                 os << _("Default") << ", ";
 640
 641         return os.str();
 642 }
 643
 644
 645 // Set family according to lyx format string
 646 void setLyXFamily(string const & fam, FontInfo & f)
 647 {
 648         string const s = ascii_lowercase(fam);
 649
 650         int i = 0;
 651         while (LyXFamilyNames[i] != s &&
 652                LyXFamilyNames[i] != string("error"))
 653                 ++i;
 654         if (s == LyXFamilyNames[i])
 655                 f.setFamily(FontFamily(i));
 656         else
 657                 LYXERR0("Unknown family `" << s << '\'');
 658 }
 659
 660
 661 // Set series according to lyx format string
 662 void setLyXSeries(string const & ser, FontInfo & f)
 663 {
 664         string const s = ascii_lowercase(ser);
 665
 666         int i = 0;
 667         while (LyXSeriesNames[i] != s &&
 668                LyXSeriesNames[i] != string("error")) ++i;
 669         if (s == LyXSeriesNames[i]) {
 670                 f.setSeries(FontSeries(i));
 671         } else
 672                 LYXERR0("Unknown series `" << s << '\'');
 673 }
 674
 675
 676 // Set shape according to lyx format string
 677 void setLyXShape(string const & sha, FontInfo & f)
 678 {
 679         string const s = ascii_lowercase(sha);
 680
 681         int i = 0;
 682         while (LyXShapeNames[i] != s && LyXShapeNames[i] != string("error"))
 683                         ++i;
 684         if (s == LyXShapeNames[i])
 685                 f.setShape(FontShape(i));
 686         else
 687                 LYXERR0("Unknown shape `" << s << '\'');
 688 }
 689
 690
 691 // Set size according to lyx format string
 692 void setLyXSize(string const & siz, FontInfo & f)
 693 {
 694         string const s = ascii_lowercase(siz);
 695         int i = 0;
 696         while (LyXSizeNames[i] != s && LyXSizeNames[i] != string("error"))
 697                 ++i;
 698         if (s == LyXSizeNames[i]) {
 699                 f.setSize(FontSize(i));
 700         } else
 701                 LYXERR0("Unknown size `" << s << '\'');
 702 }
 703
 704
 705 // Set size according to lyx format string
 706 FontState setLyXMisc(string const & siz)
 707 {
 708         string const s = ascii_lowercase(siz);
 709         int i = 0;
 710         while (LyXMiscNames[i] != s &&
 711                LyXMiscNames[i] != string("error")) ++i;
 712         if (s == LyXMiscNames[i])
 713                 return FontState(i);
 714         LYXERR0("Unknown misc flag `" << s << '\'');
 715         return FONT_OFF;
 716 }
 717
 718
 719 /// Sets color after LyX text format
 720 void setLyXColor(string const & col, FontInfo & f)
 721 {
 722         f.setColor(lcolor.getFromLyXName(col));
 723 }
 724
 725
 726 // Read a font definition from given file in lyx format
 727 // Used for layouts
 728 FontInfo lyxRead(Lexer & lex, FontInfo const & fi)
 729 {
 730         FontInfo f = fi;
 731         bool error = false;
 732         bool finished = false;
 733         while (!finished && lex.isOK() && !error) {
 734                 lex.next();
 735                 string const tok = ascii_lowercase(lex.getString());
 736
 737                 if (tok.empty()) {
 738                         continue;
 739                 } else if (tok == "endfont") {
 740                         finished = true;
 741                 } else if (tok == "family") {
 742                         lex.next();
 743                         string const ttok = lex.getString();
 744                         setLyXFamily(ttok, f);
 745                 } else if (tok == "series") {
 746                         lex.next();
 747                         string const ttok = lex.getString();
 748                         setLyXSeries(ttok, f);
 749                 } else if (tok == "shape") {
 750                         lex.next();
 751                         string const ttok = lex.getString();
 752                         setLyXShape(ttok, f);
 753                 } else if (tok == "size") {
 754                         lex.next();
 755                         string const ttok = lex.getString();
 756                         setLyXSize(ttok, f);
 757                 } else if (tok == "misc") {
 758                         lex.next();
 759                         string const ttok = ascii_lowercase(lex.getString());
 760
 761                         if (ttok == "no_bar") {
 762                                 f.setUnderbar(FONT_OFF);
 763                         } else if (ttok == "no_strikeout") {
 764                                 f.setStrikeout(FONT_OFF);
 765                         } else if (ttok == "no_xout") {
 766                                 f.setXout(FONT_OFF);
 767                         } else if (ttok == "no_uuline") {
 768                                 f.setUuline(FONT_OFF);
 769                         } else if (ttok == "no_uwave") {
 770                                 f.setUwave(FONT_OFF);
 771                         } else if (ttok == "no_emph") {
 772                                 f.setEmph(FONT_OFF);
 773                         } else if (ttok == "no_noun") {
 774                                 f.setNoun(FONT_OFF);
 775                         } else if (ttok == "emph") {
 776                                 f.setEmph(FONT_ON);
 777                         } else if (ttok == "underbar") {
 778                                 f.setUnderbar(FONT_ON);
 779                         } else if (ttok == "strikeout") {
 780                                 f.setStrikeout(FONT_ON);
 781                         } else if (ttok == "xout") {
 782                                 f.setXout(FONT_ON);
 783                         } else if (ttok == "uuline") {
 784                                 f.setUuline(FONT_ON);
 785                         } else if (ttok == "uwave") {
 786                                 f.setUwave(FONT_ON);
 787                         } else if (ttok == "noun") {
 788                                 f.setNoun(FONT_ON);
 789                         } else if (ttok == "nospellcheck") {
 790                                 f.setNoSpellcheck(FONT_ON);
 791                         } else if (ttok == "no_nospellcheck") {
 792                                 f.setNoSpellcheck(FONT_OFF);
 793                         } else {
 794                                 lex.printError("Illegal misc type");
 795                         }
 796                 } else if (tok == "color") {
 797                         lex.next();
 798                         string const ttok = lex.getString();
 799                         setLyXColor(ttok, f);
 800                 } else {
 801                         lex.printError("Unknown tag");
 802                         error = true;
 803                 }
 804         }
 805         return f;
 806 }
 807
 808
 809 void lyxWrite(ostream & os, FontInfo const & f, string const & start, int level)
 810 {
 811         string indent;
 812         for (int i = 0; i < level; ++i)
 813                 indent += '\t';
 814         ostringstream oss;
 815         if (f.family() != INHERIT_FAMILY)
 816                 oss << indent << "\tFamily " << LyXFamilyNames[f.family()]
 817                     << '\n';
 818         if (f.series() != INHERIT_SERIES)
 819                 oss << indent << "\tSeries " << LyXSeriesNames[f.series()]
 820                     << '\n';
 821         if (f.shape() != INHERIT_SHAPE)
 822                 oss << indent << "\tShape " << LyXShapeNames[f.shape()]
 823                     << '\n';
 824         if (f.size() != INHERIT_SIZE)
 825                 oss << indent << "\tSize " << LyXSizeNames[f.size()]
 826                     << '\n';
 827         //FIXME: shall style be handled here? Probably not.
 828         if (f.underbar() == FONT_ON)
 829                 oss << indent << "\tMisc Underbar\n";
 830         else if (f.underbar() == FONT_OFF)
 831                 oss << indent << "\tMisc No_Bar\n";
 832         if (f.strikeout() == FONT_ON)
 833                 oss << indent << "\tMisc Strikeout\n";
 834         else if (f.strikeout() == FONT_OFF)
 835                 oss << indent << "\tMisc No_Strikeout\n";
 836         if (f.xout() == FONT_ON)
 837                 oss << indent << "\tMisc Xout\n";
 838         else if (f.xout() == FONT_OFF)
 839                 oss << indent << "\tMisc No_Xout\n";
 840         if (f.uuline() == FONT_ON)
 841                 oss << indent << "\tMisc Uuline\n";
 842         else if (f.uuline() == FONT_OFF)
 843                 oss << indent << "\tMisc No_Uuline\n";
 844         if (f.uwave() == FONT_ON)
 845                 oss << indent << "\tMisc Uwave\n";
 846         else if (f.uwave() == FONT_OFF)
 847                 oss << indent << "\tMisc No_Uwave\n";
 848         if (f.emph() == FONT_ON)
 849                 oss << indent << "\tMisc Emph\n";
 850         else if (f.emph() == FONT_OFF)
 851                 oss << indent << "\tMisc No_Emph\n";
 852         if (f.noun() == FONT_ON)
 853                 oss << indent << "\tMisc Noun\n";
 854         else if (f.noun() == FONT_OFF)
 855                 oss << indent << "\tMisc No_Noun\n";
 856         if (f.nospellcheck() == FONT_ON)
 857                 oss << indent << "\tMisc NoSpellcheck\n";
 858         else if (f.nospellcheck() == FONT_OFF)
 859                 oss << indent << "\tMisc No_NoSpellcheck\n";
 860         if (f.color() != Color_inherit && f.color() != Color_none)
 861                 oss << indent << "\tColor " << lcolor.getLyXName(f.color())
 862                     << '\n';
 863         if (!oss.str().empty()) {
 864                 os << indent << start << '\n'
 865                    << oss.str()
 866                    << indent << "EndFont\n";
 867         }
 868 }
 869
 870
 871 } // namespace lyx