src/lyxlayout.C

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