src/lyxfont.h

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