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