src/lyxlayout.C

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