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