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