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