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