src/Layout.cpp

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