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         LColor::color color() const;
 212
 213         ///
 214         Language const * language() const;
 215
 216         ///
 217         bool isRightToLeft() const;
 218
 219         ///
 220         bool isVisibleRightToLeft() const;
 221
 222         ///
 223         LyXFont & setFamily(LyXFont::FONT_FAMILY f);
 224         ///
 225         LyXFont & setSeries(LyXFont::FONT_SERIES s);
 226         ///
 227         LyXFont & setShape(LyXFont::FONT_SHAPE s);
 228         ///
 229         LyXFont & setSize(LyXFont::FONT_SIZE s);
 230         ///
 231         LyXFont & setEmph(LyXFont::FONT_MISC_STATE e);
 232         ///
 233         LyXFont & setUnderbar(LyXFont::FONT_MISC_STATE u);
 234         ///
 235         LyXFont & setNoun(LyXFont::FONT_MISC_STATE n);
 236         ///
 237         LyXFont & setLatex(LyXFont::FONT_MISC_STATE l);
 238         ///
 239         LyXFont & setColor(LColor::color c);
 240         ///
 241         LyXFont & setLanguage(Language const * l);
 242
 243         /// Set family after LyX text format
 244         LyXFont & setLyXFamily(string const &);
 245
 246         /// Set series after LyX text format
 247         LyXFont & setLyXSeries(string const &);
 248
 249         /// Set shape after LyX text format
 250         LyXFont & setLyXShape(string const &);
 251
 252         /// Set size after LyX text format
 253         LyXFont & setLyXSize(string const &);
 254
 255         /// Returns misc flag after LyX text format
 256         LyXFont::FONT_MISC_STATE setLyXMisc(string const &);
 257
 258         /// Sets color after LyX text format
 259         LyXFont & setLyXColor(string const &);
 260
 261         /// Sets size after GUI name
 262         LyXFont & setGUISize(string const &);
 263
 264         /// Returns size of font in LaTeX text notation
 265         string latexSize() const;
 266
 267         /** Updates font settings according to request. If an
 268             attribute is IGNORE, the attribute is left as it is. */
 269         /*
 270          * When toggleall = true, all properties that matches the font in use
 271          * will have the effect that the properties is reset to the
 272          * default.  If we have a text that is TYPEWRITER_FAMILY, and is
 273          * update()'ed with TYPEWRITER_FAMILY, the operation will be as if
 274          * a INHERIT_FAMILY was asked for.  This is necessary for the
 275          * toggle-user-defined-style button on the toolbar.
 276          */
 277         void update(LyXFont const & newfont,
 278                     Language const * default_lang,
 279                     bool toggleall = false);
 280
 281         /** Reduce font to fall back to template where possible.
 282             Equal fields are reduced to INHERIT */
 283         void reduce(LyXFont const & tmplt);
 284
 285         /// Realize font from a template (INHERIT are realized)
 286         LyXFont & realize(LyXFont const & tmplt);
 287
 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(std::ostream &, LyXFont const & base,
 303                                    LyXFont const & prev) const;
 304
 305         /** Writes tha tail of the LaTeX needed to chagne to this font.
 306             Returns number of chars written. Base is the font state we want
 307             to achieve.
 308         */
 309         int latexWriteEndChanges(std::ostream &, LyXFont const & base,
 310                                  LyXFont const & next) const;
 311
 312         /// Build GUI description of font state
 313         string 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                 return font1.bits == font2.bits &&
 322                         font1.lang == font2.lang;
 323         }
 324
 325         ///
 326         friend
 327         bool operator!=(LyXFont const & font1, LyXFont const & font2) {
 328                 return !(font1 == font2);
 329         }
 330
 331         /// compares two fonts, ignoring the setting of the Latex part.
 332         bool equalExceptLatex(LyXFont const &) const;
 333
 334         /// Converts logical attributes to concrete shape attribute
 335         LyXFont::FONT_SHAPE realShape() const;
 336 private:
 337         ///
 338         struct FontBits {
 339                 ///
 340                 bool operator==(FontBits const & fb1) const;
 341                 ///
 342                 bool operator!=(FontBits const & fb1) const;
 343                 ///
 344                 FONT_FAMILY family;
 345                 ///
 346                 FONT_SERIES series;
 347                 ///
 348                 FONT_SHAPE shape;
 349                 ///
 350                 FONT_SIZE size;
 351                 ///
 352                 LColor::color color;
 353                 ///
 354                 FONT_MISC_STATE emph;
 355                 ///
 356                 FONT_MISC_STATE underbar;
 357                 ///
 358                 FONT_MISC_STATE noun;
 359                 ///
 360                 FONT_MISC_STATE latex;
 361         };
 362         ///
 363         FontBits bits;
 364         ///
 365         Language const * lang;
 366
 367         /// Sane font
 368         static FontBits sane;
 369
 370         /// All inherit font
 371         static FontBits inherit;
 372
 373         /// All ignore font
 374         static FontBits ignore;
 375
 376         /// Updates a misc setting according to request
 377         LyXFont::FONT_MISC_STATE setMisc(LyXFont::FONT_MISC_STATE newfont,
 378                                          LyXFont::FONT_MISC_STATE org);
 379 };
 380
 381
 382 std::ostream & operator<<(std::ostream &, LyXFont::FONT_MISC_STATE);
 383
 384
 385 inline
 386 LyXFont::LyXFont()
 387 {
 388         bits = sane;
 389         lang = default_language;
 390 }
 391
 392
 393 inline
 394 LyXFont::LyXFont(LyXFont const & x)
 395 {
 396         bits = x.bits;
 397         lang = x.lang;
 398 }
 399
 400
 401 inline
 402 LyXFont::LyXFont(LyXFont::FONT_INIT1)
 403 {
 404         bits = inherit;
 405         lang = default_language;
 406 }
 407
 408
 409 inline
 410 LyXFont::LyXFont(LyXFont::FONT_INIT2)
 411 {
 412         bits = ignore;
 413         lang = ignore_language;
 414 }
 415
 416
 417 inline
 418 LyXFont::LyXFont(LyXFont::FONT_INIT3)
 419 {
 420         bits = sane;
 421         lang = default_language;
 422 }
 423 inline
 424 LyXFont::LyXFont(LyXFont::FONT_INIT1, Language const * l)
 425 {
 426         bits = inherit;
 427         lang = l;
 428 }
 429
 430
 431 inline
 432 LyXFont::LyXFont(LyXFont::FONT_INIT2, Language const * l)
 433 {
 434         bits = ignore;
 435         lang = l;
 436 }
 437
 438
 439 inline
 440 LyXFont::LyXFont(LyXFont::FONT_INIT3, Language const * l)
 441 {
 442         bits = sane;
 443         lang = l;
 444 }
 445
 446
 447 inline
 448 LyXFont & LyXFont::operator=(LyXFont const & x)
 449 {
 450         bits = x.bits;
 451         lang = x.lang;
 452         return *this;
 453 }
 454
 455
 456 inline
 457 LyXFont::FONT_FAMILY LyXFont::family() const
 458 {
 459         return bits.family;
 460 }
 461
 462
 463 inline
 464 LyXFont::FONT_SERIES LyXFont::series() const
 465 {
 466         return bits.series;
 467 }
 468
 469
 470 inline
 471 LyXFont::FONT_SHAPE LyXFont::shape() const
 472 {
 473         return bits.shape;
 474 }
 475
 476
 477 inline
 478 LyXFont::FONT_SIZE LyXFont::size() const
 479 {
 480         return bits.size;
 481 }
 482
 483
 484 inline
 485 LyXFont::FONT_MISC_STATE LyXFont::emph() const
 486 {
 487         return bits.emph;
 488 }
 489
 490
 491 inline
 492 LyXFont::FONT_MISC_STATE LyXFont::underbar() const
 493 {
 494         return bits.underbar;
 495 }
 496
 497
 498 inline
 499 LyXFont::FONT_MISC_STATE LyXFont::noun() const
 500 {
 501         return bits.noun;
 502 }
 503
 504
 505 inline
 506 LyXFont::FONT_MISC_STATE LyXFont::latex() const
 507 {
 508         return bits.latex;
 509 }
 510
 511
 512 inline
 513 LColor::color LyXFont::color() const
 514 {
 515         return bits.color;
 516 }
 517
 518
 519 inline
 520 Language const * LyXFont::language() const
 521 {
 522         return lang;
 523 }
 524
 525
 526 inline
 527 bool LyXFont::isRightToLeft() const
 528 {
 529         return lang->RightToLeft();
 530 }
 531
 532
 533 inline
 534 bool LyXFont::isVisibleRightToLeft() const
 535 {
 536         return (lang->RightToLeft() && latex() != ON);
 537 }
 538
 539
 540 inline
 541 LyXFont & LyXFont::setFamily(LyXFont::FONT_FAMILY f)
 542 {
 543         bits.family = f;
 544         return *this;
 545 }
 546
 547
 548 inline
 549 LyXFont & LyXFont::setSeries(LyXFont::FONT_SERIES s)
 550 {
 551         bits.series = s;
 552         return *this;
 553 }
 554
 555
 556 inline
 557 LyXFont & LyXFont::setShape(LyXFont::FONT_SHAPE s)
 558 {
 559         bits.shape = s;
 560         return *this;
 561 }
 562
 563
 564 inline
 565 LyXFont & LyXFont::setSize(LyXFont::FONT_SIZE s)
 566 {
 567         bits.size = s;
 568         return *this;
 569 }
 570
 571
 572 inline
 573 LyXFont & LyXFont::setEmph(LyXFont::FONT_MISC_STATE e)
 574 {
 575         bits.emph = e;
 576         return *this;
 577 }
 578
 579
 580 inline
 581 LyXFont & LyXFont::setUnderbar(LyXFont::FONT_MISC_STATE u)
 582 {
 583         bits.underbar = u;
 584         return *this;
 585 }
 586
 587
 588 inline
 589 LyXFont & LyXFont::setNoun(LyXFont::FONT_MISC_STATE n)
 590 {
 591         bits.noun = n;
 592         return *this;
 593 }
 594
 595 inline
 596 LyXFont & LyXFont::setLatex(LyXFont::FONT_MISC_STATE l)
 597 {
 598         bits.latex = l;
 599         return *this;
 600 }
 601
 602
 603 inline
 604 LyXFont & LyXFont::setColor(LColor::color c)
 605 {
 606         bits.color = c;
 607         return *this;
 608 }
 609
 610
 611 inline
 612 LyXFont & LyXFont::setLanguage(Language const * l)
 613 {
 614         lang = l;
 615         return *this;
 616 }
 617
 618 #endif