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