src/lyxfont.h

   1 // -*- C++ -*-
   2 /**
   3  * \file src/lyxfont.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 LYXFONT_H
  16 #define LYXFONT_H
  17
  18 #include "LColor.h"
  19 #include "support/docstream.h"
  20
  21
  22 namespace lyx {
  23
  24
  25 class LyXLex;
  26 class BufferParams;
  27 class Language;
  28
  29
  30 ///
  31 class LyXFont {
  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 LyXFont::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 LColor::color value as an int to get LColor.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         LyXFont();
 188
 189         /// Shortcut initialization
 190         explicit
 191         LyXFont(LyXFont::FONT_INIT1);
 192         /// Shortcut initialization
 193         explicit
 194         LyXFont(LyXFont::FONT_INIT2);
 195         /// Shortcut initialization
 196         explicit
 197         LyXFont(LyXFont::FONT_INIT3);
 198         /// Shortcut initialization
 199         LyXFont(LyXFont::FONT_INIT1, Language const * l);
 200         /// Shortcut initialization
 201         LyXFont(LyXFont::FONT_INIT2, Language const * l);
 202         /// Shortcut initialization
 203         LyXFont(LyXFont::FONT_INIT3, Language const * l);
 204
 205         /// Decreases font size by one
 206         LyXFont & decSize();
 207         /// Increases font size by one
 208         LyXFont & incSize();
 209         ///
 210         FONT_FAMILY family() const { return bits.family; }
 211         ///
 212         FONT_SERIES series() const { return bits.series; }
 213         ///
 214         FONT_SHAPE shape() const { return bits.shape; }
 215         ///
 216         FONT_SIZE size() const { return bits.size; }
 217         ///
 218         FONT_MISC_STATE emph() const { return bits.emph; }
 219         ///
 220         FONT_MISC_STATE underbar() const { return bits.underbar; }
 221         ///
 222         FONT_MISC_STATE noun() const { return bits.noun; }
 223         ///
 224         FONT_MISC_STATE number() const { return bits.number; }
 225         ///
 226         LColor_color color() const;
 227         ///
 228         Language const * language() const { return lang; }
 229         ///
 230         bool isRightToLeft() const;
 231         ///
 232         bool isVisibleRightToLeft() const;
 233         ///
 234         bool isSymbolFont() const;
 235
 236         ///
 237         void setFamily(LyXFont::FONT_FAMILY f);
 238         void setSeries(LyXFont::FONT_SERIES s);
 239         void setShape(LyXFont::FONT_SHAPE s);
 240         void setSize(LyXFont::FONT_SIZE s);
 241         void setEmph(LyXFont::FONT_MISC_STATE e);
 242         void setUnderbar(LyXFont::FONT_MISC_STATE u);
 243         void setNoun(LyXFont::FONT_MISC_STATE n);
 244         void setNumber(LyXFont::FONT_MISC_STATE n);
 245         void setColor(LColor_color c);
 246         void setLanguage(Language const * l);
 247
 248         /// Set family after LyX text format
 249         LyXFont & setLyXFamily(std::string const &);
 250
 251         /// Set series after LyX text format
 252         LyXFont & setLyXSeries(std::string const &);
 253
 254         /// Set shape after LyX text format
 255         LyXFont & setLyXShape(std::string const &);
 256
 257         /// Set size after LyX text format
 258         LyXFont & setLyXSize(std::string const &);
 259
 260         /// Returns misc flag after LyX text format
 261         LyXFont::FONT_MISC_STATE setLyXMisc(std::string const &);
 262
 263         /// Sets color after LyX text format
 264         LyXFont & setLyXColor(std::string const &);
 265
 266         /// Returns size of font in LaTeX text notation
 267         std::string const latexSize() const;
 268
 269         /** Updates font settings according to request.
 270             If an attribute is IGNORE, the attribute is left as it is.
 271             When toggleall = true, all properties that matches the font in use
 272             will have the effect that the properties is reset to the
 273             default.  If we have a text that is TYPEWRITER_FAMILY, and is
 274             update()'ed with TYPEWRITER_FAMILY, the operation will be as if
 275             a INHERIT_FAMILY was asked for.  This is necessary for the
 276             toggle-user-defined-style button on the toolbar.
 277         */
 278         void update(LyXFont const & newfont,
 279                     Language const * default_lang,
 280                     bool toggleall = false);
 281
 282         /** Reduce font to fall back to template where possible.
 283             Equal fields are reduced to INHERIT */
 284         void reduce(LyXFont const & tmplt);
 285
 286         /// Realize font from a template (INHERIT are realized)
 287         LyXFont & realize(LyXFont const & tmplt);
 288         /// Is a given font fully resolved?
 289         bool resolved() const;
 290
 291         /// Read a font specification from LyXLex. Used for layout files.
 292         LyXFont & lyxRead(LyXLex &);
 293
 294         /// Writes the changes from this font to orgfont in .lyx format in file
 295         void lyxWriteChanges(LyXFont const & orgfont, std::ostream &) const;
 296
 297         /** Writes the head of the LaTeX needed to change to this font.
 298             Writes to string, the head of the LaTeX needed to change
 299             to this font. Returns number of chars written. Base is the
 300             font state active now.
 301         */
 302         int latexWriteStartChanges(odocstream &, LyXFont const & base,
 303                                    LyXFont const & prev) const;
 304
 305         /** Writes the tail of the LaTeX needed to change to this font.
 306             Returns number of chars written. Base is the font state we want
 307             to achieve.
 308         */
 309         int latexWriteEndChanges(odocstream &, LyXFont const & base,
 310                                  LyXFont const & next) const;
 311
 312         /// Build GUI description of font state
 313         std::string const stateText(BufferParams * params) const;
 314
 315         ///
 316         LColor_color realColor() const;
 317
 318         ///
 319         friend
 320         bool operator==(LyXFont const & font1, LyXFont const & font2);
 321         ///
 322         friend
 323         std::ostream & operator<<(std::ostream & os, LyXFont const & font);
 324
 325         /// Converts logical attributes to concrete shape attribute
 326         // Try hard to inline this as it shows up with 4.6 % in the profiler.
 327         LyXFont::FONT_SHAPE realShape() const {
 328                 if (bits.noun == ON)
 329                         return SMALLCAPS_SHAPE;
 330                 if (bits.emph == ON)
 331                         return (bits.shape == UP_SHAPE) ? ITALIC_SHAPE : UP_SHAPE;
 332                 return bits.shape;
 333         }
 334
 335
 336         /** Compaq cxx 6.5 requires that the definition be public so that
 337             it can compile operator==()
 338          */
 339 private:
 340         ///
 341         FontBits bits;
 342         ///
 343         Language const * lang;
 344         /// Sane font
 345         static FontBits sane;
 346         /// All inherit font
 347         static FontBits inherit;
 348         /// All ignore font
 349         static FontBits ignore;
 350         /// Updates a misc setting according to request
 351         LyXFont::FONT_MISC_STATE setMisc(LyXFont::FONT_MISC_STATE newfont,
 352                                          LyXFont::FONT_MISC_STATE org);
 353 };
 354
 355
 356 /** \c LyXFont_size is a wrapper for LyXFont::FONT_SIZE.
 357  *  It can be forward-declared and passed as a function argument without
 358  *  having to expose lyxfont.h.
 359  */
 360 class LyXFont_size {
 361 public:
 362         ///
 363         LyXFont_size(LyXFont::FONT_SIZE val) : val_(val) {}
 364         ///
 365         operator LyXFont::FONT_SIZE() const { return val_; }
 366 private:
 367         ///
 368         LyXFont::FONT_SIZE val_;
 369 };
 370
 371
 372
 373 inline
 374 bool LyXFont::isSymbolFont() const
 375 {
 376         switch (family()) {
 377         case LyXFont::SYMBOL_FAMILY:
 378         case LyXFont::CMSY_FAMILY:
 379         case LyXFont::CMM_FAMILY:
 380         case LyXFont::CMEX_FAMILY:
 381         case LyXFont::MSA_FAMILY:
 382         case LyXFont::MSB_FAMILY:
 383         case LyXFont::WASY_FAMILY:
 384         case LyXFont::ESINT_FAMILY:
 385                 return true;
 386         default:
 387                 return false;
 388         }
 389 }
 390
 391 ///
 392 std::ostream & operator<<(std::ostream &, LyXFont::FONT_MISC_STATE);
 393
 394 bool operator==(LyXFont::FontBits const & lhs, LyXFont::FontBits const & rhs);
 395
 396 inline
 397 bool operator!=(LyXFont::FontBits const & lhs, LyXFont::FontBits const & rhs)
 398 {
 399         return !(lhs == rhs);
 400 }
 401
 402 ///
 403 inline
 404 bool operator==(LyXFont const & font1, LyXFont const & font2)
 405 {
 406         return font1.bits == font2.bits && font1.lang == font2.lang;
 407 }
 408
 409 ///
 410 inline
 411 bool operator!=(LyXFont const & font1, LyXFont const & font2)
 412 {
 413         return !(font1 == font2);
 414 }
 415
 416
 417 } // namespace lyx
 418
 419 #endif