src/lyxlayout.C

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