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