src/Font.h

   1 // -*- C++ -*-
   2 /**
   3  * \file src/Font.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Lars Gullik Bjønnes
   8  * \author Jean-Marc Lasgouttes
   9  * \author Angus Leeming
  10  * \author Dekel Tsur
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 #ifndef FONT_H
  16 #define FONT_H
  17
  18 #include "Color.h"
  19 #include "support/docstream.h"
  20
  21
  22 namespace lyx {
  23
  24
  25 class Lexer;
  26 class BufferParams;
  27 class Language;
  28
  29
  30 ///
  31 class Font {
  32 public:
  33         /** The value INHERIT_* means that the font attribute is
  34             inherited from the layout. In the case of layout fonts, the
  35             attribute is inherited from the default font.
  36             The value IGNORE_* is used with Font::update() when the
  37             attribute should not be changed.
  38         */
  39         enum FONT_FAMILY {
  40                 ///
  41                 ROMAN_FAMILY, // fontstruct rely on this to be 0
  42                 ///
  43                 SANS_FAMILY,
  44                 ///
  45                 TYPEWRITER_FAMILY,
  46                 ///
  47                 SYMBOL_FAMILY,
  48                 ///
  49                 CMR_FAMILY,
  50                 ///
  51                 CMSY_FAMILY,
  52                 ///
  53                 CMM_FAMILY,
  54                 ///
  55                 CMEX_FAMILY,
  56                 ///
  57                 MSA_FAMILY,
  58                 ///
  59                 MSB_FAMILY,
  60                 ///
  61                 EUFRAK_FAMILY,
  62                 ///
  63                 WASY_FAMILY,
  64                 ///
  65                 ESINT_FAMILY,
  66                 ///
  67                 INHERIT_FAMILY,
  68                 ///
  69                 IGNORE_FAMILY,
  70                 ///
  71                 NUM_FAMILIES = INHERIT_FAMILY
  72         };
  73
  74         ///
  75         enum FONT_SERIES {
  76                 ///
  77                 MEDIUM_SERIES, // fontstruct rely on this to be 0
  78                 ///
  79                 BOLD_SERIES,
  80                 ///
  81                 INHERIT_SERIES,
  82                 ///
  83                 IGNORE_SERIES
  84         };
  85
  86         ///
  87         enum FONT_SHAPE {
  88                 ///
  89                 UP_SHAPE, // fontstruct rely on this to be 0
  90                 ///
  91                 ITALIC_SHAPE,
  92                 ///
  93                 SLANTED_SHAPE,
  94                 ///
  95                 SMALLCAPS_SHAPE,
  96                 ///
  97                 INHERIT_SHAPE,
  98                 ///
  99                 IGNORE_SHAPE
 100         };
 101
 102         ///
 103         enum FONT_SIZE {
 104                 ///
 105                 SIZE_TINY, // fontstruct rely on this to be 0
 106                 ///
 107                 SIZE_SCRIPT,
 108                 ///
 109                 SIZE_FOOTNOTE,
 110                 ///
 111                 SIZE_SMALL,
 112                 ///
 113                 SIZE_NORMAL,
 114                 ///
 115                 SIZE_LARGE,
 116                 ///
 117                 SIZE_LARGER,
 118                 ///
 119                 SIZE_LARGEST,
 120                 ///
 121                 SIZE_HUGE,
 122                 ///
 123                 SIZE_HUGER,
 124                 ///
 125                 INCREASE_SIZE,
 126                 ///
 127                 DECREASE_SIZE,
 128                 ///
 129                 INHERIT_SIZE,
 130                 ///
 131                 IGNORE_SIZE
 132         };
 133
 134         /// Used for emph, underbar, noun and latex toggles
 135         enum FONT_MISC_STATE {
 136                 ///
 137                 OFF,
 138                 ///
 139                 ON,
 140                 ///
 141                 TOGGLE,
 142                 ///
 143                 INHERIT,
 144                 ///
 145                 IGNORE
 146         };
 147
 148         /// Trick to overload constructor and make it megafast
 149         enum FONT_INIT1 {
 150                 ///
 151                 ALL_INHERIT
 152         };
 153         ///
 154         enum FONT_INIT2 {
 155                 ///
 156                 ALL_IGNORE
 157         };
 158         ///
 159         enum FONT_INIT3 {
 160                 ///
 161                 ALL_SANE
 162         };
 163
 164         struct FontBits {
 165                 ///
 166                 FONT_FAMILY family;
 167                 ///
 168                 FONT_SERIES series;
 169                 ///
 170                 FONT_SHAPE shape;
 171                 ///
 172                 FONT_SIZE size;
 173                 /** We store the Color::color value as an int to get Color.h out
 174                  *  of the header file.
 175                  */
 176                 int color;
 177                 ///
 178                 FONT_MISC_STATE emph;
 179                 ///
 180                 FONT_MISC_STATE underbar;
 181                 ///
 182                 FONT_MISC_STATE noun;
 183                 ///
 184                 FONT_MISC_STATE number;
 185         };
 186         ///
 187         Font();
 188
 189         /// Shortcut initialization
 190         explicit Font(Font::FONT_INIT1);
 191         /// Shortcut initialization
 192         explicit Font(Font::FONT_INIT2);
 193         /// Shortcut initialization
 194         explicit Font(Font::FONT_INIT3);
 195         /// Shortcut initialization
 196         Font(Font::FONT_INIT1, Language const * l);
 197         /// Shortcut initialization
 198         Font(Font::FONT_INIT2, Language const * l);
 199         /// Shortcut initialization
 200         Font(Font::FONT_INIT3, Language const * l);
 201
 202         /// Decreases font size by one
 203         Font & decSize();
 204         /// Increases font size by one
 205         Font & incSize();
 206         ///
 207         FONT_FAMILY family() const { return bits.family; }
 208         ///
 209         FONT_SERIES series() const { return bits.series; }
 210         ///
 211         FONT_SHAPE shape() const { return bits.shape; }
 212         ///
 213         FONT_SIZE size() const { return bits.size; }
 214         ///
 215         FONT_MISC_STATE emph() const { return bits.emph; }
 216         ///
 217         FONT_MISC_STATE underbar() const { return bits.underbar; }
 218         ///
 219         FONT_MISC_STATE noun() const { return bits.noun; }
 220         ///
 221         FONT_MISC_STATE number() const { return bits.number; }
 222         ///
 223         Color_color color() const;
 224         ///
 225         Language const * language() const { return lang; }
 226         ///
 227         bool isRightToLeft() const;
 228         ///
 229         bool isVisibleRightToLeft() const;
 230         ///
 231         bool isSymbolFont() const;
 232
 233         ///
 234         void setFamily(Font::FONT_FAMILY f);
 235         void setSeries(Font::FONT_SERIES s);
 236         void setShape(Font::FONT_SHAPE s);
 237         void setSize(Font::FONT_SIZE s);
 238         void setEmph(Font::FONT_MISC_STATE e);
 239         void setUnderbar(Font::FONT_MISC_STATE u);
 240         void setNoun(Font::FONT_MISC_STATE n);
 241         void setNumber(Font::FONT_MISC_STATE n);
 242         void setColor(Color_color c);
 243         void setLanguage(Language const * l);
 244
 245         /// Set family after LyX text format
 246         Font & setLyXFamily(std::string const &);
 247
 248         /// Set series after LyX text format
 249         Font & setLyXSeries(std::string const &);
 250
 251         /// Set shape after LyX text format
 252         Font & setLyXShape(std::string const &);
 253
 254         /// Set size after LyX text format
 255         Font & setLyXSize(std::string const &);
 256
 257         /// Returns misc flag after LyX text format
 258         Font::FONT_MISC_STATE setLyXMisc(std::string const &);
 259
 260         /// Sets color after LyX text format
 261         Font & setLyXColor(std::string const &);
 262
 263         /// Returns size of font in LaTeX text notation
 264         std::string const latexSize() const;
 265
 266         /** Updates font settings according to request.
 267             If an attribute is IGNORE, the attribute is left as it is.
 268             When toggleall = true, all properties that matches the font in use
 269             will have the effect that the properties is reset to the
 270             default.  If we have a text that is TYPEWRITER_FAMILY, and is
 271             update()'ed with TYPEWRITER_FAMILY, the operation will be as if
 272             a INHERIT_FAMILY was asked for.  This is necessary for the
 273             toggle-user-defined-style button on the toolbar.
 274         */
 275         void update(Font const & newfont,
 276                     Language const * default_lang,
 277                     bool toggleall = false);
 278
 279         /** Reduce font to fall back to template where possible.
 280             Equal fields are reduced to INHERIT */
 281         void reduce(Font const & tmplt);
 282
 283         /// Realize font from a template (INHERIT are realized)
 284         Font & realize(Font const & tmplt);
 285         /// Is a given font fully resolved?
 286         bool resolved() const;
 287
 288         /// Read a font specification from Lexer. Used for layout files.
 289         Font & lyxRead(Lexer &);
 290
 291         /// Writes the changes from this font to orgfont in .lyx format in file
 292         void lyxWriteChanges(Font const & orgfont, std::ostream &) const;
 293
 294         /** Writes the head of the LaTeX needed to change to this font.
 295             Writes to string, the head of the LaTeX needed to change
 296             to this font. Returns number of chars written. Base is the
 297             font state active now.
 298         */
 299         int latexWriteStartChanges(odocstream &, Font const & base,
 300                                    Font const & prev) const;
 301
 302         /** Writes the tail of the LaTeX needed to change to this font.
 303             Returns number of chars written. Base is the font state we want
 304             to achieve.
 305         */
 306         int latexWriteEndChanges(odocstream &, Font const & base,
 307                                  Font const & next) const;
 308
 309
 310         /// Build GUI description of font state
 311         docstring const stateText(BufferParams * params) const;
 312
 313         ///
 314         Color_color realColor() const;
 315
 316         ///
 317         friend
 318         bool operator==(Font const & font1, Font const & font2);
 319         ///
 320         friend
 321         std::ostream & operator<<(std::ostream & os, Font const & font);
 322
 323         /// Converts logical attributes to concrete shape attribute
 324         // Try hard to inline this as it shows up with 4.6 % in the profiler.
 325         inline Font::FONT_SHAPE realShape() const {
 326                 if (bits.noun == ON)
 327                         return SMALLCAPS_SHAPE;
 328                 if (bits.emph == ON)
 329                         return (bits.shape == UP_SHAPE) ? ITALIC_SHAPE : UP_SHAPE;
 330                 return bits.shape;
 331         }
 332
 333
 334         /** Compaq cxx 6.5 requires that the definition be public so that
 335             it can compile operator==()
 336          */
 337 private:
 338         ///
 339         FontBits bits;
 340         ///
 341         Language const * lang;
 342         /// Sane font
 343         static FontBits sane;
 344         /// All inherit font
 345         static FontBits inherit;
 346         /// All ignore font
 347         static FontBits ignore;
 348         /// Updates a misc setting according to request
 349         Font::FONT_MISC_STATE setMisc(Font::FONT_MISC_STATE newfont,
 350                                          Font::FONT_MISC_STATE org);
 351 };
 352
 353
 354 /** \c Font_size is a wrapper for Font::FONT_SIZE.
 355  *  It can be forward-declared and passed as a function argument without
 356  *  having to expose Font.h.
 357  */
 358 class Font_size {
 359 public:
 360         ///
 361         Font_size(Font::FONT_SIZE val) : val_(val) {}
 362         ///
 363         operator Font::FONT_SIZE() const { return val_; }
 364 private:
 365         ///
 366         Font::FONT_SIZE val_;
 367 };
 368
 369
 370
 371 inline
 372 bool Font::isSymbolFont() const
 373 {
 374         switch (family()) {
 375         case Font::SYMBOL_FAMILY:
 376         case Font::CMSY_FAMILY:
 377         case Font::CMM_FAMILY:
 378         case Font::CMEX_FAMILY:
 379         case Font::MSA_FAMILY:
 380         case Font::MSB_FAMILY:
 381         case Font::WASY_FAMILY:
 382         case Font::ESINT_FAMILY:
 383                 return true;
 384         default:
 385                 return false;
 386         }
 387 }
 388
 389 ///
 390 std::ostream & operator<<(std::ostream &, Font::FONT_MISC_STATE);
 391
 392 bool operator==(Font::FontBits const & lhs, Font::FontBits const & rhs);
 393
 394 inline
 395 bool operator!=(Font::FontBits const & lhs, Font::FontBits const & rhs)
 396 {
 397         return !(lhs == rhs);
 398 }
 399
 400 ///
 401 inline
 402 bool operator==(Font const & font1, Font const & font2)
 403 {
 404         return font1.bits == font2.bits && font1.lang == font2.lang;
 405 }
 406
 407 ///
 408 inline
 409 bool operator!=(Font const & font1, Font const & font2)
 410 {
 411         return !(font1 == font2);
 412 }
 413
 414
 415 } // namespace lyx
 416
 417 #endif