src/lyxlayout.C

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