src/lyxlayout.C

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