src/lyxfont.h

   1 // -*- C++ -*-
   2 /* This file is part of
   3  * ======================================================
   4  *
   5  *           LyX, The Document Processor
   6  *
   7  *          Copyright (C) 1995 Matthias Ettrich
   8  *
   9  * ====================================================== */
  10
  11 #ifndef LYXFONT_H
  12 #define LYXFONT_H
  13
  14 #ifdef __GNUG__
  15 #pragma interface
  16 #endif
  17
  18 #include FORMS_H_LOCATION
  19 #include "LString.h"
  20 #include "debug.h"
  21
  22
  23 // It might happen that locale.h defines ON and OFF. This is not good
  24 // for us, since we use these names below. But of course this is due
  25 // to some old compilers. Than is broken when it comes to C++ scoping.
  26 #include "gettext.h" // so that we are sure tht it won't be included
  27                      // later.
  28 #ifdef ON
  29 #undef ON
  30 #endif
  31
  32 #ifdef OFF
  33 #undef OFF
  34 #endif
  35
  36 class LyXLex;
  37
  38 ///
  39 class LyXFont {
  40 public:
  41         /** The value INHERIT_* means that the font attribute is
  42           inherited from the layout. In the case of layout fonts, the
  43           attribute is inherited from the default font.
  44           The value IGNORE_* is used with LyXFont::update() when the
  45           attribute should not be changed.
  46           */
  47         enum FONT_FAMILY {
  48                 ///
  49                 ROMAN_FAMILY, // fontstruct rely on this to be 0
  50                 ///
  51                 SANS_FAMILY,
  52                 ///
  53                 TYPEWRITER_FAMILY,
  54                 ///
  55                 SYMBOL_FAMILY,
  56                 ///
  57                 INHERIT_FAMILY,
  58                 ///
  59                 IGNORE_FAMILY
  60         };
  61
  62         ///
  63         enum FONT_SERIES {
  64                 ///
  65                 MEDIUM_SERIES, // fontstruct rely on this to be 0
  66                 ///
  67                 BOLD_SERIES,
  68                 ///
  69                 INHERIT_SERIES,
  70                 ///
  71                 IGNORE_SERIES
  72         };
  73
  74         ///
  75         enum FONT_SHAPE {
  76                 ///
  77                 UP_SHAPE, // fontstruct rely on this to be 0
  78                 ///
  79                 ITALIC_SHAPE,
  80                 ///
  81                 SLANTED_SHAPE,
  82                 ///
  83                 SMALLCAPS_SHAPE,
  84                 ///
  85                 INHERIT_SHAPE,
  86                 ///
  87                 IGNORE_SHAPE
  88         };
  89
  90         ///
  91         enum FONT_SIZE {
  92                 ///
  93                 SIZE_TINY, // fontstruct rely on this to be 0
  94                 ///
  95                 SIZE_SCRIPT,
  96                 ///
  97                 SIZE_FOOTNOTE,
  98                 ///
  99                 SIZE_SMALL,
 100                 ///
 101                 SIZE_NORMAL,
 102                 ///
 103                 SIZE_LARGE,
 104                 ///
 105                 SIZE_LARGER,
 106                 ///
 107                 SIZE_LARGEST,
 108                 ///
 109                 SIZE_HUGE,
 110                 ///
 111                 SIZE_HUGER,
 112                 ///
 113                 INCREASE_SIZE,
 114                 ///
 115                 DECREASE_SIZE,
 116                 ///
 117                 INHERIT_SIZE,
 118                 ///
 119                 IGNORE_SIZE
 120         };
 121
 122         /// Used for emph, underbar, noun and latex toggles
 123         enum FONT_MISC_STATE {
 124                 ///
 125                 OFF,
 126                 ///
 127                 ON,
 128                 ///
 129                 TOGGLE,
 130                 ///
 131                 INHERIT,
 132                 ///
 133                 IGNORE
 134         };
 135
 136         ///
 137         enum FONT_COLOR {
 138                 ///
 139                 NONE,
 140                 ///
 141                 BLACK,
 142                 ///
 143                 WHITE,
 144                 ///
 145                 RED,
 146                 ///
 147                 GREEN,
 148                 ///
 149                 BLUE,
 150                 ///
 151                 CYAN,
 152                 ///
 153                 MAGENTA,
 154                 ///
 155                 YELLOW,
 156                 ///
 157                 MATH,
 158                 ///
 159                 INSET,
 160                 ///
 161                 INHERIT_COLOR,
 162                 ///
 163                 IGNORE_COLOR
 164         };
 165
 166         /// Trick to overload constructor and make it megafast
 167         enum FONT_INIT1 {
 168                 ///
 169                 ALL_INHERIT
 170         };
 171         ///
 172         enum FONT_INIT2 {
 173                 ///
 174                 ALL_IGNORE
 175         };
 176         ///
 177         enum FONT_INIT3 {
 178                 ///
 179                 ALL_SANE
 180         };
 181
 182         ///
 183         LyXFont();
 184
 185         /// LyXFont x(LyXFont ...) and LyXFont x = LyXFont ...
 186         LyXFont(LyXFont const & x);
 187
 188         /// Shortcut initialization
 189         LyXFont(LyXFont::FONT_INIT1);
 190         /// Shortcut initialization
 191         LyXFont(LyXFont::FONT_INIT2);
 192         /// Shortcut initialization
 193         LyXFont(LyXFont::FONT_INIT3);
 194
 195         /// LyXFont x, y; x = y;
 196         LyXFont& operator=(LyXFont const & x);
 197
 198         /// Decreases font size by one
 199         LyXFont & decSize();
 200
 201         /// Increases font size by one
 202         LyXFont & incSize();
 203
 204         ///
 205         FONT_FAMILY family() const;
 206
 207         ///
 208         FONT_SERIES series() const;
 209
 210         ///
 211         FONT_SHAPE shape() const;
 212
 213         ///
 214         FONT_SIZE size() const;
 215
 216         ///
 217         FONT_MISC_STATE emph() const;
 218
 219         ///
 220         FONT_MISC_STATE underbar() const;
 221
 222         ///
 223         FONT_MISC_STATE noun() const;
 224
 225         ///
 226         FONT_MISC_STATE latex() const;
 227
 228         ///
 229         FONT_COLOR color() const;
 230
 231         ///
 232         LyXFont & setFamily(LyXFont::FONT_FAMILY f);
 233         ///
 234         LyXFont & setSeries(LyXFont::FONT_SERIES s);
 235         ///
 236         LyXFont & setShape(LyXFont::FONT_SHAPE s);
 237         ///
 238         LyXFont & setSize(LyXFont::FONT_SIZE s);
 239         ///
 240         LyXFont & setEmph(LyXFont::FONT_MISC_STATE e);
 241         ///
 242         LyXFont & setUnderbar(LyXFont::FONT_MISC_STATE u);
 243         ///
 244         LyXFont & setNoun(LyXFont::FONT_MISC_STATE n);
 245         ///
 246         LyXFont & setLatex(LyXFont::FONT_MISC_STATE l);
 247         ///
 248         LyXFont & setColor(LyXFont::FONT_COLOR c);
 249
 250         /// Set family after LyX text format
 251         LyXFont & setLyXFamily(string const &);
 252
 253         /// Set series after LyX text format
 254         LyXFont & setLyXSeries(string const &);
 255
 256         /// Set shape after LyX text format
 257         LyXFont & setLyXShape(string const &);
 258
 259         /// Set size after LyX text format
 260         LyXFont & setLyXSize(string const &);
 261
 262         /// Returns misc flag after LyX text format
 263         LyXFont::FONT_MISC_STATE setLyXMisc(string const &);
 264
 265         /// Sets color after LyX text format
 266         LyXFont & setLyXColor(string const &);
 267
 268         /// Sets size after GUI name
 269         LyXFont & setGUISize(string const &);
 270
 271         /// Returns size of font in LaTeX text notation
 272         string latexSize() const;
 273
 274         /** Updates font settings according to request. If an
 275           attribute is IGNORE, the attribute is left as it is. */
 276         /*
 277          * When toggleall = true, all properties that matches the font in use
 278          * will have the effect that the properties is reset to the
 279          * default.  If we have a text that is TYPEWRITER_FAMILY, and is
 280          * update()'ed with TYPEWRITER_FAMILY, the operation will be as if
 281          * a INHERIT_FAMILY was asked for.  This is necessary for the
 282          * toggle-user-defined-style button on the toolbar.
 283          */
 284         void update(LyXFont const & newfont, bool toggleall = false);
 285
 286         /** Reduce font to fall back to template where possible.
 287           Equal fields are reduced to INHERIT */
 288         void reduce(LyXFont const & tmplt);
 289
 290         /// Realize font from a template (INHERIT are realized)
 291         LyXFont & realize(LyXFont const & tmplt);
 292
 293         /// Is a given font fully resolved?
 294         bool resolved() const;
 295
 296         /// Read a font specification from LyXLex. Used for layout files.
 297         LyXFont & lyxRead(LyXLex&);
 298
 299         /// Writes the changes from this font to orgfont in .lyx format in file
 300         void lyxWriteChanges(LyXFont const & orgfont, ostream &) const;
 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(string &, LyXFont const & base) const;
 308
 309         /** Writes tha tail of the LaTeX needed to chagne to this font.
 310           Returns number of chars written. Base is the font state we want
 311             to achieve.
 312         */
 313         int latexWriteEndChanges(string &, LyXFont const & base) const;
 314
 315         /// Build GUI description of font state
 316         string stateText() const;
 317
 318         ///
 319         int maxAscent() const;
 320
 321         ///
 322         int maxDescent() const;
 323
 324         ///
 325         int ascent(char c) const;
 326
 327         ///
 328         int descent(char c) const;
 329
 330         ///
 331         int width(char c) const;
 332
 333         ///
 334         int textWidth(char const *s, int n) const;
 335
 336         ///
 337         int stringWidth(string const & s) const;
 338
 339         ///
 340         int signedStringWidth(string const & s) const;
 341
 342         /// Draws text and returns width of text
 343         int drawText(char const*, int n, Pixmap, int baseline, int x) const;
 344
 345         ///
 346         int drawString(string const &, Pixmap pm, int baseline, int x) const;
 347
 348         ///
 349         GC getGC() const;
 350
 351         ///
 352         friend inline
 353         bool operator==(LyXFont const & font1, LyXFont const & font2) {
 354                 return font1.bits == font2.bits;
 355         }
 356
 357         ///
 358         friend inline
 359         bool operator!=(LyXFont const & font1, LyXFont const & font2) {
 360                 return font1.bits != font2.bits;
 361         }
 362
 363         /// compares two fonts, ignoring the setting of the Latex part.
 364         bool equalExceptLatex(LyXFont const &) const;
 365
 366 private:
 367         /// This have to be at least 32 bits, but 64 or more does not hurt
 368         typedef unsigned int ui32;
 369
 370         /** Representation: bit table
 371           Layout of bit table:
 372                    11 1111 111 122 222 222 2233
 373           Bit 012 34 567 8901 2345 678 901 234 567 8901
 374               FFF SS SSS SSSS CCCC EEE UUU NNN LLL
 375               aaa ee hhh iiii oooo mmm nnn ooo aaa
 376               mmm rr aaa zzzz llll ppp ddd uuu ttt
 377
 378           Some might think this is a dirty representation, but it gives
 379           us at least 25% speed-up, so why not?
 380         */
 381         ui32 bits;
 382
 383         ///
 384         enum FONT_POSITION {
 385                 ///
 386                 Fam_Pos =  0,
 387                 ///
 388                 Ser_Pos =  3,
 389                 ///
 390                 Sha_Pos =  5,
 391                 ///
 392                 Siz_Pos =  8,
 393                 ///
 394                 Col_Pos = 12,
 395                 ///
 396                 Emp_Pos = 16,
 397                 ///
 398                 Und_Pos = 19,
 399                 ///
 400                 Nou_Pos = 22,
 401                 ///
 402                 Lat_Pos = 25
 403         };
 404
 405         ///
 406         enum FONT_MASK {
 407                 ///
 408                 Fam_Mask = 0x07,
 409                 ///
 410                 Ser_Mask = 0x03,
 411                 ///
 412                 Sha_Mask = 0x07,
 413                 ///
 414                 Siz_Mask = 0x0f,
 415                 ///
 416                 Col_Mask = 0x0f,
 417                 ///
 418                 Misc_Mask = 0x07
 419         };
 420
 421         /// Sane font
 422         enum {  sane = ui32(ROMAN_FAMILY) << Fam_Pos
 423                 | ui32(MEDIUM_SERIES) << Ser_Pos
 424                 | ui32(UP_SHAPE) << Sha_Pos
 425                 | ui32(SIZE_NORMAL) << Siz_Pos
 426                 | ui32(NONE) << Col_Pos
 427                 | ui32(OFF) << Emp_Pos
 428                 | ui32(OFF) << Und_Pos
 429                 | ui32(OFF) << Nou_Pos
 430                 | ui32(OFF) << Lat_Pos};
 431
 432         /// All inherit font
 433         enum{ inherit = ui32(INHERIT_FAMILY) << Fam_Pos
 434                 | ui32(INHERIT_SERIES) << Ser_Pos
 435                 | ui32(INHERIT_SHAPE) << Sha_Pos
 436                 | ui32(INHERIT_SIZE) << Siz_Pos
 437                 | ui32(INHERIT_COLOR) << Col_Pos
 438                 | ui32(INHERIT) << Emp_Pos
 439                 | ui32(INHERIT) << Und_Pos
 440                 | ui32(INHERIT) << Nou_Pos
 441                 | ui32(INHERIT) << Lat_Pos};
 442
 443         /// All ignore font
 444         enum{ ignore = ui32(IGNORE_FAMILY) << Fam_Pos
 445                | ui32(IGNORE_SERIES) << Ser_Pos
 446                | ui32(IGNORE_SHAPE) << Sha_Pos
 447                | ui32(IGNORE_SIZE) << Siz_Pos
 448                | ui32(IGNORE_COLOR) << Col_Pos
 449                | ui32(IGNORE) << Emp_Pos
 450                | ui32(IGNORE) << Und_Pos
 451                | ui32(IGNORE) << Nou_Pos
 452                | ui32(IGNORE) << Lat_Pos};
 453
 454         /// Updates a misc setting according to request
 455         LyXFont::FONT_MISC_STATE setMisc(LyXFont::FONT_MISC_STATE newfont,
 456                                          LyXFont::FONT_MISC_STATE org);
 457
 458         /// Converts logical attributes to concrete shape attribute
 459         LyXFont::FONT_SHAPE realShape() const;
 460
 461         ///
 462         XFontStruct* getXFontstruct() const;
 463 };
 464
 465 ostream & operator<<(ostream &, LyXFont::FONT_MISC_STATE);
 466
 467 inline LyXFont::LyXFont()
 468 {
 469         bits = sane;
 470 }
 471
 472
 473 inline LyXFont::LyXFont(LyXFont const & x)
 474 {
 475         bits = x.bits;
 476 }
 477
 478
 479 inline LyXFont::LyXFont(LyXFont::FONT_INIT1)
 480 {
 481         bits = inherit;
 482 }
 483
 484
 485 inline LyXFont::LyXFont(LyXFont::FONT_INIT2)
 486 {
 487         bits = ignore;
 488 }
 489
 490
 491 inline LyXFont::LyXFont(LyXFont::FONT_INIT3)
 492 {
 493         bits = sane;
 494 }
 495
 496
 497 inline LyXFont & LyXFont::operator=(LyXFont const & x)
 498 {
 499         bits = x.bits;
 500         return *this;
 501 }
 502
 503
 504  // You don't have to understand the stuff below :-)
 505  // It works, and it's bloody fast. (Asger)
 506 inline LyXFont::FONT_FAMILY LyXFont::family() const
 507 {
 508         return LyXFont::FONT_FAMILY((bits >> Fam_Pos) & Fam_Mask);
 509 }
 510
 511
 512 inline LyXFont::FONT_SERIES LyXFont::series() const
 513 {
 514         return LyXFont::FONT_SERIES((bits >> Ser_Pos) & Ser_Mask);
 515 }
 516
 517
 518 inline LyXFont::FONT_SHAPE LyXFont::shape() const
 519 {
 520         return LyXFont::FONT_SHAPE((bits >> Sha_Pos) & Sha_Mask);
 521 }
 522
 523
 524 inline LyXFont::FONT_SIZE LyXFont::size() const
 525 {
 526         return LyXFont::FONT_SIZE((bits >> Siz_Pos) & Siz_Mask);
 527 }
 528
 529
 530 inline LyXFont::FONT_MISC_STATE LyXFont::emph() const
 531 {
 532         return LyXFont::FONT_MISC_STATE((bits >> Emp_Pos) & Misc_Mask);
 533 }
 534
 535
 536 inline LyXFont::FONT_MISC_STATE LyXFont::underbar() const
 537 {
 538         return LyXFont::FONT_MISC_STATE((bits >> Und_Pos) & Misc_Mask);
 539 }
 540
 541
 542 inline LyXFont::FONT_MISC_STATE LyXFont::noun() const
 543 {
 544         return LyXFont::FONT_MISC_STATE((bits >> Nou_Pos) & Misc_Mask);
 545 }
 546
 547
 548 inline LyXFont::FONT_MISC_STATE LyXFont::latex() const
 549 {
 550         return LyXFont::FONT_MISC_STATE((bits >> Lat_Pos) & Misc_Mask);
 551 }
 552
 553
 554 inline LyXFont::FONT_COLOR LyXFont::color() const
 555 {
 556         return LyXFont::FONT_COLOR((bits >> Col_Pos) & Col_Mask);
 557 }
 558
 559
 560 inline LyXFont & LyXFont::setFamily(LyXFont::FONT_FAMILY f)
 561 {
 562         bits &= ~(Fam_Mask << Fam_Pos);
 563         bits |= ui32(f) << Fam_Pos;
 564         return *this;
 565 }
 566
 567
 568 inline LyXFont & LyXFont::setSeries(LyXFont::FONT_SERIES s)
 569 {
 570         bits &= ~(Ser_Mask << Ser_Pos);
 571         bits |= ui32(s) << Ser_Pos;
 572         return *this;
 573 }
 574
 575
 576 inline LyXFont & LyXFont::setShape(LyXFont::FONT_SHAPE s)
 577 {
 578         bits &= ~(Sha_Mask << Sha_Pos);
 579         bits |= ui32(s) << Sha_Pos;
 580         return *this;
 581 }
 582
 583
 584 inline LyXFont & LyXFont::setSize(LyXFont::FONT_SIZE s)
 585 {
 586         bits &= ~(Siz_Mask << Siz_Pos);
 587         bits |= ui32(s) << Siz_Pos;
 588         return *this;
 589 }
 590
 591
 592 inline LyXFont & LyXFont::setEmph(LyXFont::FONT_MISC_STATE e)
 593 {
 594         bits &= ~(Misc_Mask << Emp_Pos);
 595         bits |= ui32(e) << Emp_Pos;
 596         return *this;
 597 }
 598
 599
 600 inline LyXFont & LyXFont::setUnderbar(LyXFont::FONT_MISC_STATE u)
 601 {
 602         bits &= ~(Misc_Mask << Und_Pos);
 603         bits |= ui32(u) << Und_Pos;
 604         return *this;
 605 }
 606
 607
 608 inline LyXFont & LyXFont::setNoun(LyXFont::FONT_MISC_STATE n)
 609 {
 610         bits &= ~(Misc_Mask << Nou_Pos);
 611         bits |= ui32(n) << Nou_Pos;
 612         return *this;
 613 }
 614
 615 inline LyXFont & LyXFont::setLatex(LyXFont::FONT_MISC_STATE l)
 616 {
 617         bits &= ~(Misc_Mask << Lat_Pos);
 618         bits |= ui32(l) << Lat_Pos;
 619         return *this;
 620 }
 621
 622
 623 inline LyXFont & LyXFont::setColor(LyXFont::FONT_COLOR c)
 624 {
 625         bits &= ~(Col_Mask << Col_Pos);
 626         bits |= ui32(c) << Col_Pos;
 627         return *this;
 628 }
 629 #endif