src/Layout.cpp

   1 /**
   2  * \file Layout.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author Jean-Marc Lasgouttes
   8  * \author André Pönitz
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #include <config.h>
  14
  15 #include "Layout.h"
  16 #include "TextClass.h"
  17 #include "Lexer.h"
  18 #include "Font.h"
  19
  20 #include "support/debug.h"
  21 #include "support/lstrings.h"
  22
  23 using namespace std;
  24 using namespace lyx::support;
  25
  26 namespace lyx {
  27
  28 /// Special value of toclevel for layouts that to not belong in a TOC
  29 const int Layout::NOT_IN_TOC = -1000;
  30
  31 //  The order of the LayoutTags enum is no more important. [asierra300396]
  32 // Tags indexes.
  33 enum LayoutTags {
  34         LT_ALIGN = 1,
  35         LT_ALIGNPOSSIBLE,
  36         LT_MARGIN,
  37         LT_BOTTOMSEP,
  38         LT_CATEGORY,
  39         LT_COMMANDDEPTH,
  40         LT_COPYSTYLE,
  41         LT_DEPENDSON,
  42         LT_OBSOLETEDBY,
  43         //LT_EMPTY,
  44         LT_END,
  45         //LT_ENVIRONMENT_DEFAULT,
  46         //LT_FANCYHDR,
  47         LT_FILL_BOTTOM,
  48         LT_FILL_TOP,
  49         //LT_FIRST_COUNTER,
  50         LT_FONT,
  51         LT_FREE_SPACING,
  52         LT_PASS_THRU,
  53         //LT_HEADINGS,
  54         LT_ITEMSEP,
  55         LT_KEEPEMPTY,
  56         LT_LABEL_BOTTOMSEP,
  57         LT_LABELFONT,
  58         LT_TEXTFONT,
  59         LT_LABELINDENT,
  60         LT_LABELSEP,
  61         LT_LABELSTRING,
  62         LT_LABELSTRING_APPENDIX,
  63         LT_LABELCOUNTER,
  64         LT_LABELTYPE,
  65         LT_ENDLABELSTRING,
  66         LT_ENDLABELTYPE,
  67         LT_LATEXNAME,
  68         LT_LATEXPARAM,
  69         LT_OPTARGS,
  70         LT_LATEXTYPE,
  71         LT_LEFTMARGIN,
  72         LT_NEED_PROTECT,
  73         LT_NEWLINE,
  74         LT_NEXTNOINDENT,
  75         LT_PARINDENT,
  76         LT_PARSEP,
  77         LT_PARSKIP,
  78         //LT_PLAIN,
  79         LT_PREAMBLE,
  80         LT_REQUIRES,
  81         LT_RIGHTMARGIN,
  82         LT_SPACING,
  83         LT_TOPSEP,
  84         LT_TOCLEVEL,
  85         LT_INNERTAG,
  86         LT_LABELTAG,
  87         LT_ITEMTAG,
  88         LT_INTITLE // keep this last!
  89 };
  90
  91 /////////////////////
  92
  93 Layout::Layout()
  94 {
  95         unknown_ = false;
  96         margintype = MARGIN_STATIC;
  97         latextype = LATEX_PARAGRAPH;
  98         intitle = false;
  99         optionalargs = 0;
 100         needprotect = false;
 101         keepempty = false;
 102         font = inherit_font;
 103         labelfont = inherit_font;
 104         resfont = sane_font;
 105         reslabelfont = sane_font;
 106         nextnoindent = false;
 107         parskip = 0.0;
 108         itemsep = 0;
 109         topsep = 0.0;
 110         bottomsep = 0.0;
 111         labelbottomsep = 0.0;
 112         parsep = 0;
 113         align = LYX_ALIGN_BLOCK;
 114         alignpossible = LYX_ALIGN_NONE | LYX_ALIGN_LAYOUT;
 115         labeltype = LABEL_NO_LABEL;
 116         endlabeltype = END_LABEL_NO_LABEL;
 117         // Should or should not. That is the question.
 118         // spacing.set(Spacing::OneHalf);
 119         fill_top = false;
 120         fill_bottom = false;
 121         newline_allowed = true;
 122         free_spacing = false;
 123         pass_thru = false;
 124         toclevel = NOT_IN_TOC;
 125         commanddepth = 0;
 126 }
 127
 128
 129 bool Layout::read(Lexer & lex, TextClass const & tclass)
 130 {
 131         // This table is sorted alphabetically [asierra 30March96]
 132         LexerKeyword layoutTags[] = {
 133                 { "align",          LT_ALIGN },
 134                 { "alignpossible",  LT_ALIGNPOSSIBLE },
 135                 { "bottomsep",      LT_BOTTOMSEP },
 136                 { "category",       LT_CATEGORY },
 137                 { "commanddepth",   LT_COMMANDDEPTH },
 138                 { "copystyle",      LT_COPYSTYLE },
 139                 { "dependson",      LT_DEPENDSON },
 140                 { "end",            LT_END },
 141                 { "endlabelstring", LT_ENDLABELSTRING },
 142                 { "endlabeltype",   LT_ENDLABELTYPE },
 143                 { "fill_bottom",    LT_FILL_BOTTOM },
 144                 { "fill_top",       LT_FILL_TOP },
 145                 { "font",           LT_FONT },
 146                 { "freespacing",    LT_FREE_SPACING },
 147                 { "innertag",       LT_INNERTAG },
 148                 { "intitle",        LT_INTITLE },
 149                 { "itemsep",        LT_ITEMSEP },
 150                 { "itemtag",        LT_ITEMTAG },
 151                 { "keepempty",      LT_KEEPEMPTY },
 152                 { "labelbottomsep", LT_LABEL_BOTTOMSEP },
 153                 { "labelcounter",   LT_LABELCOUNTER },
 154                 { "labelfont",      LT_LABELFONT },
 155                 { "labelindent",    LT_LABELINDENT },
 156                 { "labelsep",       LT_LABELSEP },
 157                 { "labelstring",    LT_LABELSTRING },
 158                 { "labelstringappendix", LT_LABELSTRING_APPENDIX },
 159                 { "labeltag",       LT_LABELTAG },
 160                 { "labeltype",      LT_LABELTYPE },
 161                 { "latexname",      LT_LATEXNAME },
 162                 { "latexparam",     LT_LATEXPARAM },
 163                 { "latextype",      LT_LATEXTYPE },
 164                 { "leftmargin",     LT_LEFTMARGIN },
 165                 { "margin",         LT_MARGIN },
 166                 { "needprotect",    LT_NEED_PROTECT },
 167                 { "newline",        LT_NEWLINE },
 168                 { "nextnoindent",   LT_NEXTNOINDENT },
 169                 { "obsoletedby",    LT_OBSOLETEDBY },
 170                 { "optionalargs",   LT_OPTARGS },
 171                 { "parindent",      LT_PARINDENT },
 172                 { "parsep",         LT_PARSEP },
 173                 { "parskip",        LT_PARSKIP },
 174                 { "passthru",       LT_PASS_THRU },
 175                 { "preamble",       LT_PREAMBLE },
 176                 { "requires",       LT_REQUIRES },
 177                 { "rightmargin",    LT_RIGHTMARGIN },
 178                 { "spacing",        LT_SPACING },
 179                 { "textfont",       LT_TEXTFONT },
 180                 { "toclevel",       LT_TOCLEVEL },
 181                 { "topsep",         LT_TOPSEP }
 182         };
 183
 184         bool error = false;
 185         bool finished = false;
 186         lex.pushTable(layoutTags);
 187         // parse style section
 188         while (!finished && lex.isOK() && !error) {
 189                 int le = lex.lex();
 190                 // See comment in LyXRC.cpp.
 191                 switch (le) {
 192                 case Lexer::LEX_FEOF:
 193                         continue;
 194
 195                 case Lexer::LEX_UNDEF:          // parse error
 196                         lex.printError("Unknown layout tag `$$Token'");
 197                         error = true;
 198                         continue;
 199                 default: break;
 200                 }
 201                 switch (static_cast<LayoutTags>(le)) {
 202                 case LT_END:            // end of structure
 203                         finished = true;
 204                         break;
 205
 206                 case LT_CATEGORY:
 207                         lex >> category_;
 208                         break;
 209
 210                 case LT_COPYSTYLE: {     // initialize with a known style
 211                         docstring style;
 212                         lex >> style;
 213                         style = subst(style, '_', ' ');
 214
 215                         if (tclass.hasLayout(style)) {
 216                                 docstring const tmpname = name_;
 217                                 this->operator=(tclass[style]);
 218                                 name_ = tmpname;
 219                         } else {
 220                                 LYXERR0("Cannot copy unknown style `"
 221                                         << style << "'\n"
 222                                         << "All layouts so far:");
 223                                 DocumentClass::const_iterator lit = tclass.begin();
 224                                 DocumentClass::const_iterator len = tclass.end();
 225                                 for (; lit != len; ++lit)
 226                                         LYXERR0(lit->name());
 227                         }
 228                         break;
 229                         }
 230
 231                 case LT_OBSOLETEDBY: {   // replace with a known style
 232                         docstring style;
 233                         lex >> style;
 234                         style = subst(style, '_', ' ');
 235
 236                         if (tclass.hasLayout(style)) {
 237                                 docstring const tmpname = name_;
 238                                 this->operator=(tclass[style]);
 239                                 name_ = tmpname;
 240                                 if (obsoleted_by().empty())
 241                                         obsoleted_by_ = style;
 242                         } else {
 243                                 LYXERR0("Cannot replace with unknown style `"
 244                                         << style << '\'');
 245
 246                                 //lex.printError("Cannot replace with"
 247                                 //               " unknown style "
 248                                 //               "`$$Token'");
 249                         }
 250                         break;
 251                 }
 252
 253                 case LT_DEPENDSON:
 254                         lex >> depends_on_;
 255                         depends_on_ = subst(depends_on_, '_', ' ');
 256                         break;
 257
 258                 case LT_MARGIN:         // margin style definition.
 259                         readMargin(lex);
 260                         break;
 261
 262                 case LT_LATEXTYPE:      // LaTeX style definition.
 263                         readLatexType(lex);
 264                         break;
 265
 266                 case LT_INTITLE:
 267                         lex >> intitle;
 268                         break;
 269
 270                 case LT_TOCLEVEL:
 271                         lex >> toclevel;
 272                         break;
 273
 274                 case LT_OPTARGS:
 275                         lex >> optionalargs ;
 276                         break;
 277
 278                 case LT_NEED_PROTECT:
 279                         lex >> needprotect;
 280                         break;
 281
 282                 case LT_KEEPEMPTY:
 283                         lex >> keepempty;
 284                         break;
 285
 286                 case LT_FONT:
 287                         font = lyxRead(lex, font);
 288                         labelfont = font;
 289                         break;
 290
 291                 case LT_TEXTFONT:
 292                         font = lyxRead(lex, font);
 293                         break;
 294
 295                 case LT_LABELFONT:
 296                         labelfont = lyxRead(lex, labelfont);
 297                         break;
 298
 299                 case LT_NEXTNOINDENT:   // Indent next paragraph?
 300                         lex >> nextnoindent;
 301                         break;
 302
 303                 case LT_COMMANDDEPTH:
 304                         lex >> commanddepth;
 305                         break;
 306
 307                 case LT_LATEXNAME:
 308                         lex >> latexname_;
 309                         break;
 310
 311                 case LT_LATEXPARAM:
 312                         lex >> latexparam_;
 313                         latexparam_ = subst(latexparam_, "&quot;", "\"");
 314                         break;
 315
 316                 case LT_INNERTAG:
 317                         lex >> innertag_;
 318                         break;
 319
 320                 case LT_LABELTAG:
 321                         lex >> labeltag_;
 322                         break;
 323
 324                 case LT_ITEMTAG:
 325                         lex >> itemtag_;
 326                         break;
 327
 328                 case LT_PREAMBLE:
 329                         preamble_ = from_utf8(lex.getLongString("EndPreamble"));
 330                         break;
 331
 332                 case LT_LABELTYPE:
 333                         readLabelType(lex);
 334                         break;
 335
 336                 case LT_ENDLABELTYPE:
 337                         readEndLabelType(lex);
 338                         break;
 339
 340                 case LT_LEFTMARGIN:     // left margin type
 341                         lex >> leftmargin;
 342                         break;
 343
 344                 case LT_RIGHTMARGIN:    // right margin type
 345                         lex >> rightmargin;
 346                         break;
 347
 348                 case LT_LABELINDENT:    // label indenting flag
 349                         lex >> labelindent;
 350                         break;
 351
 352                 case LT_PARINDENT:      // paragraph indent. flag
 353                         lex >> parindent;
 354                         break;
 355
 356                 case LT_PARSKIP:        // paragraph skip size
 357                         lex >> parskip;
 358                         break;
 359
 360                 case LT_ITEMSEP:        // item separation size
 361                         lex >> itemsep;
 362                         break;
 363
 364                 case LT_TOPSEP:         // top separation size
 365                         lex >> topsep;
 366                         break;
 367
 368                 case LT_BOTTOMSEP:      // bottom separation size
 369                         lex >> bottomsep;
 370                         break;
 371
 372                 case LT_LABEL_BOTTOMSEP: // label bottom separation size
 373                         lex >> labelbottomsep;
 374                         break;
 375
 376                 case LT_LABELSEP:       // label separator
 377                         lex >> labelsep;
 378                         labelsep = subst(labelsep, 'x', ' ');
 379                         break;
 380
 381                 case LT_PARSEP:         // par. separation size
 382                         lex >> parsep;
 383                         break;
 384
 385                 case LT_FILL_TOP:       // fill top flag
 386                         lex >> fill_top;
 387                         break;
 388
 389                 case LT_FILL_BOTTOM:    // fill bottom flag
 390                         lex >> fill_bottom;
 391                         break;
 392
 393                 case LT_NEWLINE:        // newlines allowed?
 394                         lex >> newline_allowed;
 395                         break;
 396
 397                 case LT_ALIGN:          // paragraph align
 398                         readAlign(lex);
 399                         break;
 400                 case LT_ALIGNPOSSIBLE:  // paragraph allowed align
 401                         readAlignPossible(lex);
 402                         break;
 403
 404                 case LT_LABELSTRING:    // label string definition
 405                         // FIXME: this means LT_ENDLABELSTRING may only
 406                         // occur after LT_LABELSTRING
 407                         lex >> labelstring_;
 408                         labelstring_ = trim(labelstring_);
 409                         labelstring_appendix_ = labelstring_;
 410                         break;
 411
 412                 case LT_ENDLABELSTRING: // endlabel string definition
 413                         lex >> endlabelstring_;
 414                         endlabelstring_ = trim(endlabelstring_);
 415                         break;
 416
 417                 case LT_LABELSTRING_APPENDIX: // label string appendix definition
 418                         lex >> labelstring_appendix_;
 419                         labelstring_appendix_ = trim(labelstring_appendix_);
 420                         break;
 421
 422                 case LT_LABELCOUNTER: // name of counter to use
 423                         lex >> counter;
 424                         counter = trim(counter);
 425                         break;
 426
 427                 case LT_FREE_SPACING:   // Allow for free spacing.
 428                         lex >> free_spacing;
 429                         break;
 430
 431                 case LT_PASS_THRU:      // Allow for pass thru.
 432                         lex >> pass_thru;
 433                         break;
 434
 435                 case LT_SPACING: // setspace.sty
 436                         readSpacing(lex);
 437                         break;
 438
 439                 case LT_REQUIRES:
 440                         lex.eatLine();
 441                         vector<string> const req =
 442                                 getVectorFromString(lex.getString());
 443                         requires_.insert(req.begin(), req.end());
 444                         break;
 445
 446                 }
 447         }
 448         lex.popTable();
 449
 450         return !error;
 451 }
 452
 453
 454 enum {
 455         AT_BLOCK = 1,
 456         AT_LEFT,
 457         AT_RIGHT,
 458         AT_CENTER,
 459         AT_LAYOUT
 460 };
 461
 462
 463 LexerKeyword alignTags[] = {
 464         { "block",  AT_BLOCK },
 465         { "center", AT_CENTER },
 466         { "layout", AT_LAYOUT },
 467         { "left",   AT_LEFT },
 468         { "right",  AT_RIGHT }
 469 };
 470
 471
 472 void Layout::readAlign(Lexer & lex)
 473 {
 474         PushPopHelper pph(lex, alignTags);
 475         int le = lex.lex();
 476         switch (le) {
 477         case Lexer::LEX_UNDEF:
 478                 lex.printError("Unknown alignment `$$Token'");
 479                 return;
 480         default: break;
 481         };
 482         switch (le) {
 483         case AT_BLOCK:
 484                 align = LYX_ALIGN_BLOCK;
 485                 break;
 486         case AT_LEFT:
 487                 align = LYX_ALIGN_LEFT;
 488                 break;
 489         case AT_RIGHT:
 490                 align = LYX_ALIGN_RIGHT;
 491                 break;
 492         case AT_CENTER:
 493                 align = LYX_ALIGN_CENTER;
 494                 break;
 495         case AT_LAYOUT:
 496                 align = LYX_ALIGN_LAYOUT;
 497                 break;
 498         }
 499 }
 500
 501
 502 void Layout::readAlignPossible(Lexer & lex)
 503 {
 504         lex.pushTable(alignTags);
 505         alignpossible = LYX_ALIGN_NONE | LYX_ALIGN_LAYOUT;
 506         int lineno = lex.lineNumber();
 507         do {
 508                 int le = lex.lex();
 509                 switch (le) {
 510                 case Lexer::LEX_UNDEF:
 511                         lex.printError("Unknown alignment `$$Token'");
 512                         continue;
 513                 default: break;
 514                 };
 515                 switch (le) {
 516                 case AT_BLOCK:
 517                         alignpossible |= LYX_ALIGN_BLOCK;
 518                         break;
 519                 case AT_LEFT:
 520                         alignpossible |= LYX_ALIGN_LEFT;
 521                         break;
 522                 case AT_RIGHT:
 523                         alignpossible |= LYX_ALIGN_RIGHT;
 524                         break;
 525                 case AT_CENTER:
 526                         alignpossible |= LYX_ALIGN_CENTER;
 527                         break;
 528                 case AT_LAYOUT:
 529                         alignpossible |= LYX_ALIGN_LAYOUT;
 530                         break;
 531                 }
 532         } while (lineno == lex.lineNumber());
 533         lex.popTable();
 534 }
 535
 536
 537 void Layout::readLabelType(Lexer & lex)
 538 {
 539         enum {
 540                 LA_NO_LABEL = 1,
 541                 LA_MANUAL,
 542                 LA_TOP_ENVIRONMENT,
 543                 LA_CENTERED_TOP_ENVIRONMENT,
 544                 LA_STATIC,
 545                 LA_SENSITIVE,
 546                 LA_COUNTER,
 547                 LA_ENUMERATE,
 548                 LA_ITEMIZE,
 549                 LA_BIBLIO
 550         };
 551
 552
 553         LexerKeyword labelTypeTags[] = {
 554                 { "bibliography",             LA_BIBLIO },
 555                 { "centered_top_environment", LA_CENTERED_TOP_ENVIRONMENT },
 556                 { "counter",                  LA_COUNTER },
 557                 { "enumerate",                LA_ENUMERATE },
 558                 { "itemize",                  LA_ITEMIZE },
 559                 { "manual",                   LA_MANUAL },
 560                 { "no_label",                 LA_NO_LABEL },
 561                 { "sensitive",                LA_SENSITIVE },
 562                 { "static",                   LA_STATIC },
 563                 { "top_environment",          LA_TOP_ENVIRONMENT }
 564         };
 565
 566         PushPopHelper pph(lex, labelTypeTags);
 567         int le = lex.lex();
 568         switch (le) {
 569         case Lexer::LEX_UNDEF:
 570                 lex.printError("Unknown labeltype tag `$$Token'");
 571                 return;
 572         default: break;
 573         }
 574         switch (le) {
 575         case LA_NO_LABEL:
 576                 labeltype = LABEL_NO_LABEL;
 577                 break;
 578         case LA_MANUAL:
 579                 labeltype = LABEL_MANUAL;
 580                 break;
 581         case LA_TOP_ENVIRONMENT:
 582                 labeltype = LABEL_TOP_ENVIRONMENT;
 583                 break;
 584         case LA_CENTERED_TOP_ENVIRONMENT:
 585                 labeltype = LABEL_CENTERED_TOP_ENVIRONMENT;
 586                 break;
 587         case LA_STATIC:
 588                 labeltype = LABEL_STATIC;
 589                 break;
 590         case LA_SENSITIVE:
 591                 labeltype = LABEL_SENSITIVE;
 592                 break;
 593         case LA_COUNTER:
 594                 labeltype = LABEL_COUNTER;
 595                 break;
 596         case LA_ENUMERATE:
 597                 labeltype = LABEL_ENUMERATE;
 598                 break;
 599         case LA_ITEMIZE:
 600                 labeltype = LABEL_ITEMIZE;
 601                 break;
 602         case LA_BIBLIO:
 603                 labeltype = LABEL_BIBLIO;
 604                 break;
 605         }
 606 }
 607
 608
 609 void Layout::readEndLabelType(Lexer & lex)
 610 {
 611         static LexerKeyword endlabelTypeTags[] = {
 612                 { "box",              END_LABEL_BOX },
 613                 { "filled_box", END_LABEL_FILLED_BOX },
 614                 { "no_label",     END_LABEL_NO_LABEL },
 615                 { "static",     END_LABEL_STATIC }
 616         };
 617
 618         PushPopHelper pph(lex, endlabelTypeTags);
 619         int le = lex.lex();
 620         switch (le) {
 621         case Lexer::LEX_UNDEF:
 622                 lex.printError("Unknown labeltype tag `$$Token'");
 623                 break;
 624         case END_LABEL_STATIC:
 625         case END_LABEL_BOX:
 626         case END_LABEL_FILLED_BOX:
 627         case END_LABEL_NO_LABEL:
 628                 endlabeltype = static_cast<EndLabelType>(le);
 629                 break;
 630         default:
 631                 LYXERR0("Unhandled value " << le);
 632                 break;
 633         }
 634 }
 635
 636
 637 void Layout::readMargin(Lexer & lex)
 638 {
 639         LexerKeyword marginTags[] = {
 640                 { "dynamic",           MARGIN_DYNAMIC },
 641                 { "first_dynamic",     MARGIN_FIRST_DYNAMIC },
 642                 { "manual",            MARGIN_MANUAL },
 643                 { "right_address_box", MARGIN_RIGHT_ADDRESS_BOX },
 644                 { "static",            MARGIN_STATIC }
 645         };
 646
 647         PushPopHelper pph(lex, marginTags);
 648
 649         int le = lex.lex();
 650         switch (le) {
 651         case Lexer::LEX_UNDEF:
 652                 lex.printError("Unknown margin type tag `$$Token'");
 653                 return;
 654         case MARGIN_STATIC:
 655         case MARGIN_MANUAL:
 656         case MARGIN_DYNAMIC:
 657         case MARGIN_FIRST_DYNAMIC:
 658         case MARGIN_RIGHT_ADDRESS_BOX:
 659                 margintype = static_cast<MarginType>(le);
 660                 break;
 661         default:
 662                 LYXERR0("Unhandled value " << le);
 663                 break;
 664         }
 665 }
 666
 667
 668 void Layout::readLatexType(Lexer & lex)
 669 {
 670         LexerKeyword latexTypeTags[] = {
 671                 { "bib_environment",  LATEX_BIB_ENVIRONMENT },
 672                 { "command",          LATEX_COMMAND },
 673                 { "environment",      LATEX_ENVIRONMENT },
 674                 { "item_environment", LATEX_ITEM_ENVIRONMENT },
 675                 { "list_environment", LATEX_LIST_ENVIRONMENT },
 676                 { "paragraph",        LATEX_PARAGRAPH }
 677         };
 678
 679         PushPopHelper pph(lex, latexTypeTags);
 680         int le = lex.lex();
 681         switch (le) {
 682         case Lexer::LEX_UNDEF:
 683                 lex.printError("Unknown latextype tag `$$Token'");
 684                 return;
 685         case LATEX_PARAGRAPH:
 686         case LATEX_COMMAND:
 687         case LATEX_ENVIRONMENT:
 688         case LATEX_ITEM_ENVIRONMENT:
 689         case LATEX_BIB_ENVIRONMENT:
 690         case LATEX_LIST_ENVIRONMENT:
 691                 latextype = static_cast<LatexType>(le);
 692                 break;
 693         default:
 694                 LYXERR0("Unhandled value " << le);
 695                 break;
 696         }
 697 }
 698
 699
 700 void Layout::readSpacing(Lexer & lex)
 701 {
 702         enum {
 703                 ST_SPACING_SINGLE = 1,
 704                 ST_SPACING_ONEHALF,
 705                 ST_SPACING_DOUBLE,
 706                 ST_OTHER
 707         };
 708
 709         LexerKeyword spacingTags[] = {
 710                 {"double",  ST_SPACING_DOUBLE },
 711                 {"onehalf", ST_SPACING_ONEHALF },
 712                 {"other",   ST_OTHER },
 713                 {"single",  ST_SPACING_SINGLE }
 714         };
 715
 716         PushPopHelper pph(lex, spacingTags);
 717         int le = lex.lex();
 718         switch (le) {
 719         case Lexer::LEX_UNDEF:
 720                 lex.printError("Unknown spacing token `$$Token'");
 721                 return;
 722         default: break;
 723         }
 724         switch (le) {
 725         case ST_SPACING_SINGLE:
 726                 spacing.set(Spacing::Single);
 727                 break;
 728         case ST_SPACING_ONEHALF:
 729                 spacing.set(Spacing::Onehalf);
 730                 break;
 731         case ST_SPACING_DOUBLE:
 732                 spacing.set(Spacing::Double);
 733                 break;
 734         case ST_OTHER:
 735                 lex.next();
 736                 spacing.set(Spacing::Other, lex.getString());
 737                 break;
 738         }
 739 }
 740
 741
 742 docstring const & Layout::name() const
 743 {
 744         return name_;
 745 }
 746
 747
 748 void Layout::setName(docstring const & name)
 749 {
 750         name_ = name;
 751 }
 752
 753
 754 docstring const & Layout::obsoleted_by() const
 755 {
 756         return obsoleted_by_;
 757 }
 758
 759
 760 docstring const & Layout::depends_on() const
 761 {
 762         return depends_on_;
 763 }
 764
 765
 766 bool Layout::operator==(Layout const & rhs) const
 767 {
 768         // This is enough for the applications we actually make,
 769         // at least at the moment. But we could check more.
 770         return name() == rhs.name()
 771                 && latexname() == rhs.latexname()
 772                 && latextype == rhs.latextype;
 773 }
 774
 775
 776 } // namespace lyx