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