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