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