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