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