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 "FontInfo.h"
  17 #include "Language.h"
  18 #include "Lexer.h"
  19 #include "output_xhtml.h"
  20 #include "TextClass.h"
  21
  22 #include "support/debug.h"
  23 #include "support/lassert.h"
  24 #include "support/lstrings.h"
  25 #include "support/Messages.h"
  26 #include "support/textutils.h"
  27
  28
  29 using namespace std;
  30 using namespace lyx::support;
  31
  32 namespace lyx {
  33
  34 /// Special value of toclevel for layouts that to not belong in a TOC
  35 const int Layout::NOT_IN_TOC = -1000;
  36
  37 //  The order of the LayoutTags enum is no more important. [asierra300396]
  38 // Tags indexes.
  39 enum LayoutTags {
  40         LT_ALIGN = 1,
  41         LT_ALIGNPOSSIBLE,
  42         LT_ARGUMENT,
  43         LT_AUTONESTS,
  44         LT_AUTONESTEDBY,
  45         LT_MARGIN,
  46         LT_BOTTOMSEP,
  47         LT_CATEGORY,
  48         LT_COMMANDDEPTH,
  49         LT_COPYSTYLE,
  50         LT_DEPENDSON,
  51         LT_OBSOLETEDBY,
  52         LT_END,
  53         LT_FONT,
  54         LT_FREE_SPACING,
  55         LT_PASS_THRU,
  56         LT_PASS_THRU_CHARS,
  57         LT_PARBREAK_IS_NEWLINE,
  58         LT_ITEMCOMMAND,
  59         LT_ITEMSEP,
  60         LT_KEEPEMPTY,
  61         LT_LABEL_BOTTOMSEP,
  62         LT_LABELFONT,
  63         LT_TEXTFONT,
  64         LT_LABELINDENT,
  65         LT_LABELSEP,
  66         LT_LABELSTRING,
  67         LT_LABELSTRING_APPENDIX,
  68         LT_LABELCOUNTER,
  69         LT_LABELTYPE,
  70         LT_ENDLABELSTRING,
  71         LT_ENDLABELTYPE,
  72         LT_LATEXNAME,
  73         LT_LATEXPARAM,
  74         LT_LATEXTYPE,
  75         LT_LEFTDELIM,
  76         LT_LEFTMARGIN,
  77         LT_NEED_CPROTECT,
  78         LT_NEED_PROTECT,
  79         LT_NEWLINE,
  80         LT_NEXTNOINDENT,
  81         LT_PAR_GROUP,
  82         LT_PARINDENT,
  83         LT_PARSEP,
  84         LT_PARSKIP,
  85         LT_PREAMBLE,
  86         LT_LANGPREAMBLE,
  87         LT_BABELPREAMBLE,
  88         LT_REQUIRES,
  89         LT_RIGHTMARGIN,
  90         LT_SPACING,
  91         LT_TOPSEP,
  92         LT_TOCLEVEL,
  93         LT_INNERTAG,
  94         LT_LABELTAG,
  95         LT_ITEMTAG,
  96         LT_HTMLTAG,
  97         LT_HTMLATTR,
  98         LT_HTMLITEM,
  99         LT_HTMLITEMATTR,
 100         LT_HTMLLABEL,
 101         LT_HTMLLABELATTR,
 102         LT_HTMLLABELFIRST,
 103         LT_HTMLPREAMBLE,
 104         LT_HTMLSTYLE,
 105         LT_HTMLFORCECSS,
 106         LT_INPREAMBLE,
 107         LT_HTMLTITLE,
 108         LT_SPELLCHECK,
 109         LT_REFPREFIX,
 110         LT_RESETARGS,
 111         LT_RESUMECOUNTER,
 112         LT_STEPMASTERCOUNTER,
 113         LT_RIGHTDELIM,
 114         LT_FORCELOCAL,
 115         LT_TOGGLE_INDENT,
 116         LT_ADDTOTOC,
 117         LT_ISTOCCAPTION,
 118         LT_INTITLE // keep this last!
 119 };
 120
 121 /////////////////////
 122
 123 Layout::Layout()
 124         : add_to_toc_(false), is_toc_caption_(true)
 125 {
 126         unknown_ = false;
 127         margintype = MARGIN_STATIC;
 128         latextype = LATEX_PARAGRAPH;
 129         resumecounter = false;
 130         stepmastercounter = false;
 131         intitle = false;
 132         inpreamble = false;
 133         needprotect = false;
 134         needcprotect = false;
 135         keepempty = false;
 136         font = inherit_font;
 137         labelfont = inherit_font;
 138         resfont = sane_font;
 139         reslabelfont = sane_font;
 140         nextnoindent = false;
 141         parskip = 0.0;
 142         itemsep = 0;
 143         topsep = 0.0;
 144         bottomsep = 0.0;
 145         labelbottomsep = 0.0;
 146         parsep = 0;
 147         align = LYX_ALIGN_BLOCK;
 148         alignpossible = LYX_ALIGN_NONE | LYX_ALIGN_LAYOUT;
 149         labeltype = LABEL_NO_LABEL;
 150         endlabeltype = END_LABEL_NO_LABEL;
 151         // Should or should not. That is the question.
 152         // spacing.set(Spacing::OneHalf);
 153         newline_allowed = true;
 154         free_spacing = false;
 155         pass_thru = false;
 156         parbreak_is_newline = false;
 157         toclevel = NOT_IN_TOC;
 158         commanddepth = 0;
 159         htmllabelfirst_ = false;
 160         htmlforcecss_ = false;
 161         htmltitle_ = false;
 162         spellcheck = true;
 163         forcelocal = 0;
 164         itemcommand_ = "item";
 165         toggle_indent = ITOGGLE_DOCUMENT_DEFAULT;
 166         par_group_ = false;
 167 }
 168
 169
 170 bool Layout::read(Lexer & lex, TextClass const & tclass)
 171 {
 172         // If this is an empty layout, or if no force local version is set,
 173         // we know that we will not discard the stuff to read
 174         if (forcelocal == 0)
 175                 return readIgnoreForcelocal(lex, tclass);
 176         Layout tmp(*this);
 177         tmp.forcelocal = 0;
 178         bool const ret = tmp.readIgnoreForcelocal(lex, tclass);
 179         // Keep the stuff if
 180         // - the read version is higher
 181         // - both versions are infinity (arbitrary decision)
 182         // - the file did not contain any local version (needed for not
 183         //   skipping user defined local layouts)
 184         if (tmp.forcelocal <= 0 || tmp.forcelocal > forcelocal)
 185                 *this = tmp;
 186         return ret;
 187 }
 188
 189
 190 bool Layout::readIgnoreForcelocal(Lexer & lex, TextClass const & tclass)
 191 {
 192         // This table is sorted alphabetically [asierra 30March96]
 193         LexerKeyword layoutTags[] = {
 194                 { "addtotoc",       LT_ADDTOTOC },
 195                 { "align",          LT_ALIGN },
 196                 { "alignpossible",  LT_ALIGNPOSSIBLE },
 197                 { "argument",       LT_ARGUMENT },
 198                 { "autonests",      LT_AUTONESTS },
 199                 { "babelpreamble",  LT_BABELPREAMBLE },
 200                 { "bottomsep",      LT_BOTTOMSEP },
 201                 { "category",       LT_CATEGORY },
 202                 { "commanddepth",   LT_COMMANDDEPTH },
 203                 { "copystyle",      LT_COPYSTYLE },
 204                 { "dependson",      LT_DEPENDSON },
 205                 { "end",            LT_END },
 206                 { "endlabelstring", LT_ENDLABELSTRING },
 207                 { "endlabeltype",   LT_ENDLABELTYPE },
 208                 { "font",           LT_FONT },
 209                 { "forcelocal",     LT_FORCELOCAL },
 210                 { "freespacing",    LT_FREE_SPACING },
 211                 { "htmlattr",       LT_HTMLATTR },
 212                 { "htmlforcecss",   LT_HTMLFORCECSS },
 213                 { "htmlitem",       LT_HTMLITEM },
 214                 { "htmlitemattr",   LT_HTMLITEMATTR },
 215                 { "htmllabel",      LT_HTMLLABEL },
 216                 { "htmllabelattr",  LT_HTMLLABELATTR },
 217                 { "htmllabelfirst", LT_HTMLLABELFIRST },
 218                 { "htmlpreamble",   LT_HTMLPREAMBLE },
 219                 { "htmlstyle",      LT_HTMLSTYLE },
 220                 { "htmltag",        LT_HTMLTAG },
 221                 { "htmltitle",      LT_HTMLTITLE },
 222                 { "innertag",       LT_INNERTAG },
 223                 { "inpreamble",     LT_INPREAMBLE },
 224                 { "intitle",        LT_INTITLE },
 225                 { "isautonestedby", LT_AUTONESTEDBY },
 226                 { "istoccaption",   LT_ISTOCCAPTION },
 227                 { "itemcommand",    LT_ITEMCOMMAND },
 228                 { "itemsep",        LT_ITEMSEP },
 229                 { "itemtag",        LT_ITEMTAG },
 230                 { "keepempty",      LT_KEEPEMPTY },
 231                 { "labelbottomsep", LT_LABEL_BOTTOMSEP },
 232                 { "labelcounter",   LT_LABELCOUNTER },
 233                 { "labelfont",      LT_LABELFONT },
 234                 { "labelindent",    LT_LABELINDENT },
 235                 { "labelsep",       LT_LABELSEP },
 236                 { "labelstring",    LT_LABELSTRING },
 237                 { "labelstringappendix", LT_LABELSTRING_APPENDIX },
 238                 { "labeltag",       LT_LABELTAG },
 239                 { "labeltype",      LT_LABELTYPE },
 240                 { "langpreamble",   LT_LANGPREAMBLE },
 241                 { "latexname",      LT_LATEXNAME },
 242                 { "latexparam",     LT_LATEXPARAM },
 243                 { "latextype",      LT_LATEXTYPE },
 244                 { "leftdelim",      LT_LEFTDELIM },
 245                 { "leftmargin",     LT_LEFTMARGIN },
 246                 { "margin",         LT_MARGIN },
 247                 { "needcprotect",    LT_NEED_CPROTECT },
 248                 { "needprotect",    LT_NEED_PROTECT },
 249                 { "newline",        LT_NEWLINE },
 250                 { "nextnoindent",   LT_NEXTNOINDENT },
 251                 { "obsoletedby",    LT_OBSOLETEDBY },
 252                 { "paragraphgroup", LT_PAR_GROUP },
 253                 { "parbreakisnewline", LT_PARBREAK_IS_NEWLINE },
 254                 { "parindent",      LT_PARINDENT },
 255                 { "parsep",         LT_PARSEP },
 256                 { "parskip",        LT_PARSKIP },
 257                 { "passthru",       LT_PASS_THRU },
 258                 { "passthruchars",  LT_PASS_THRU_CHARS },
 259                 { "preamble",       LT_PREAMBLE },
 260                 { "refprefix",      LT_REFPREFIX },
 261                 { "requires",       LT_REQUIRES },
 262                 { "resetargs",      LT_RESETARGS },
 263                 { "resumecounter",  LT_RESUMECOUNTER },
 264                 { "rightdelim",     LT_RIGHTDELIM },
 265                 { "rightmargin",    LT_RIGHTMARGIN },
 266                 { "spacing",        LT_SPACING },
 267                 { "spellcheck",     LT_SPELLCHECK },
 268                 { "stepmastercounter",  LT_STEPMASTERCOUNTER },
 269                 { "textfont",       LT_TEXTFONT },
 270                 { "toclevel",       LT_TOCLEVEL },
 271                 { "toggleindent",   LT_TOGGLE_INDENT },
 272                 { "topsep",         LT_TOPSEP }
 273         };
 274
 275         bool error = false;
 276         bool finished = false;
 277         lex.pushTable(layoutTags);
 278
 279         // parse style section
 280         while (!finished && lex.isOK() && !error) {
 281                 int le = lex.lex();
 282                 // See comment in LyXRC.cpp.
 283                 switch (le) {
 284                 case Lexer::LEX_FEOF:
 285                         continue;
 286
 287                 case Lexer::LEX_UNDEF:
 288                         // parse error
 289                         lex.printError("Unknown layout tag `$$Token'");
 290                         error = true;
 291                         continue;
 292
 293                 default:
 294                         break;
 295                 }
 296                 switch (static_cast<LayoutTags>(le)) {
 297                 case LT_END:
 298                         finished = true;
 299                         break;
 300
 301                 case LT_CATEGORY:
 302                         lex >> category_;
 303                         break;
 304
 305                 case LT_COPYSTYLE: {
 306                         docstring style;
 307                         lex >> style;
 308                         style = subst(style, '_', ' ');
 309
 310                         if (tclass.hasLayout(style)) {
 311                                 docstring const tmpname = name_;
 312                                 this->operator=(tclass[style]);
 313                                 name_ = tmpname;
 314                         } else {
 315                                 LYXERR0("Cannot copy unknown style `"
 316                                         << style << "'\n"
 317                                         << "All layouts so far:");
 318                                 DocumentClass::const_iterator lit = tclass.begin();
 319                                 DocumentClass::const_iterator len = tclass.end();
 320                                 for (; lit != len; ++lit)
 321                                         LYXERR0(lit->name());
 322                         }
 323                         break;
 324                         }
 325
 326                 case LT_OBSOLETEDBY: {
 327                         docstring style;
 328                         lex >> style;
 329                         style = subst(style, '_', ' ');
 330
 331                         if (tclass.hasLayout(style)) {
 332                                 docstring const tmpname = name_;
 333                                 this->operator=(tclass[style]);
 334                                 name_ = tmpname;
 335                                 if (obsoleted_by().empty())
 336                                         obsoleted_by_ = style;
 337                         } else {
 338                                 LYXERR0("Cannot replace with unknown style `"
 339                                         << style << '\'');
 340
 341                                 //lex.printError("Cannot replace with"
 342                                 //               " unknown style "
 343                                 //               "`$$Token'");
 344                         }
 345                         break;
 346                 }
 347
 348                 case LT_DEPENDSON:
 349                         lex >> depends_on_;
 350                         depends_on_ = subst(depends_on_, '_', ' ');
 351                         break;
 352
 353                 case LT_MARGIN:
 354                         readMargin(lex);
 355                         break;
 356
 357                 case LT_LATEXTYPE:
 358                         readLatexType(lex);
 359                         break;
 360
 361                 case LT_INTITLE:
 362                         lex >> intitle;
 363                         break;
 364
 365                 case LT_INPREAMBLE:
 366                         lex >> inpreamble;
 367                         break;
 368
 369                 case LT_TOCLEVEL:
 370                         lex >> toclevel;
 371                         break;
 372
 373                 case LT_RESETARGS:
 374                         bool reset;
 375                         lex >> reset;
 376                         if (reset) {
 377                                 latexargs_.clear();
 378                                 itemargs_.clear();
 379                                 postcommandargs_.clear();
 380                         }
 381                         break;
 382
 383                 case LT_RESUMECOUNTER:
 384                         lex >> resumecounter;
 385                         break;
 386
 387                 case LT_STEPMASTERCOUNTER:
 388                         lex >> stepmastercounter;
 389                         break;
 390
 391                 case LT_ARGUMENT:
 392                         readArgument(lex);
 393                         break;
 394
 395                 case LT_NEED_PROTECT:
 396                         lex >> needprotect;
 397                         break;
 398
 399                 case LT_NEED_CPROTECT:
 400                         lex >> needcprotect;
 401                         break;
 402
 403                 case LT_KEEPEMPTY:
 404                         lex >> keepempty;
 405                         break;
 406
 407                 case LT_FONT:
 408                         font = lyxRead(lex, font);
 409                         labelfont = font;
 410                         break;
 411
 412                 case LT_TEXTFONT:
 413                         font = lyxRead(lex, font);
 414                         break;
 415
 416                 case LT_LABELFONT:
 417                         labelfont = lyxRead(lex, labelfont);
 418                         break;
 419
 420                 case LT_NEXTNOINDENT:
 421                         lex >> nextnoindent;
 422                         break;
 423
 424                 case LT_TOGGLE_INDENT: {
 425                         string tog;
 426                         lex >> tog;
 427                         tog = support::ascii_lowercase(tog);
 428                         if (tog == "always")
 429                                 toggle_indent = ITOGGLE_ALWAYS;
 430                         else if (tog == "never")
 431                                 toggle_indent = ITOGGLE_NEVER;
 432                         else
 433                                 toggle_indent = ITOGGLE_DOCUMENT_DEFAULT;
 434                         break;
 435                 }
 436
 437                 case LT_COMMANDDEPTH:
 438                         lex >> commanddepth;
 439                         break;
 440
 441                 case LT_LATEXNAME:
 442                         lex >> latexname_;
 443                         break;
 444
 445                 case LT_LATEXPARAM:
 446                         lex >> latexparam_;
 447                         latexparam_ = subst(latexparam_, "&quot;", "\"");
 448                         break;
 449
 450                 case LT_LEFTDELIM:
 451                         lex >> leftdelim_;
 452                         leftdelim_ = support::subst(leftdelim_, from_ascii("<br/>"),
 453                                                     from_ascii("\n"));
 454                         break;
 455
 456                 case LT_RIGHTDELIM:
 457                         lex >> rightdelim_;
 458                         rightdelim_ = support::subst(rightdelim_, from_ascii("<br/>"),
 459                                                      from_ascii("\n"));
 460                         break;
 461
 462                 case LT_INNERTAG:
 463                         lex >> innertag_;
 464                         break;
 465
 466                 case LT_LABELTAG:
 467                         lex >> labeltag_;
 468                         break;
 469
 470                 case LT_ITEMTAG:
 471                         lex >> itemtag_;
 472                         break;
 473
 474                 case LT_ITEMCOMMAND:
 475                         lex >> itemcommand_;
 476                         break;
 477
 478                 case LT_PREAMBLE:
 479                         preamble_ = lex.getLongString(from_ascii("EndPreamble"));
 480                         break;
 481
 482                 case LT_LANGPREAMBLE:
 483                         langpreamble_ = lex.getLongString(from_ascii("EndLangPreamble"));
 484                         break;
 485
 486                 case LT_BABELPREAMBLE:
 487                         babelpreamble_ = lex.getLongString(from_ascii("EndBabelPreamble"));
 488                         break;
 489
 490                 case LT_LABELTYPE:
 491                         readLabelType(lex);
 492                         break;
 493
 494                 case LT_ENDLABELTYPE:
 495                         readEndLabelType(lex);
 496                         break;
 497
 498                 case LT_LEFTMARGIN:
 499                         lex >> leftmargin;
 500                         break;
 501
 502                 case LT_RIGHTMARGIN:
 503                         lex >> rightmargin;
 504                         break;
 505
 506                 case LT_LABELINDENT:
 507                         lex >> labelindent;
 508                         break;
 509
 510                 case LT_PARINDENT:
 511                         lex >> parindent;
 512                         break;
 513
 514                 case LT_PARSKIP:
 515                         lex >> parskip;
 516                         break;
 517
 518                 case LT_ITEMSEP:
 519                         lex >> itemsep;
 520                         break;
 521
 522                 case LT_TOPSEP:
 523                         lex >> topsep;
 524                         break;
 525
 526                 case LT_BOTTOMSEP:
 527                         lex >> bottomsep;
 528                         break;
 529
 530                 case LT_LABEL_BOTTOMSEP:
 531                         lex >> labelbottomsep;
 532                         break;
 533
 534                 case LT_LABELSEP:
 535                         lex >> labelsep;
 536                         labelsep = subst(labelsep, 'x', ' ');
 537                         break;
 538
 539                 case LT_PARSEP:
 540                         lex >> parsep;
 541                         break;
 542
 543                 case LT_NEWLINE:
 544                         lex >> newline_allowed;
 545                         break;
 546
 547                 case LT_ALIGN:
 548                         readAlign(lex);
 549                         break;
 550
 551                 case LT_ALIGNPOSSIBLE:
 552                         readAlignPossible(lex);
 553                         break;
 554
 555                 case LT_LABELSTRING:
 556                         // FIXME: this means LT_LABELSTRING_APPENDIX may only
 557                         // occur after LT_LABELSTRING
 558                         lex >> labelstring_;
 559                         labelstring_appendix_ = labelstring_;
 560                         break;
 561
 562                 case LT_ENDLABELSTRING:
 563                         lex >> endlabelstring_;
 564                         break;
 565
 566                 case LT_LABELSTRING_APPENDIX:
 567                         lex >> labelstring_appendix_;
 568                         break;
 569
 570                 case LT_LABELCOUNTER:
 571                         lex >> counter;
 572                         break;
 573
 574                 case LT_PAR_GROUP:
 575                         lex >> par_group_;
 576                         break;
 577
 578                 case LT_FREE_SPACING:
 579                         lex >> free_spacing;
 580                         break;
 581
 582                 case LT_PASS_THRU:
 583                         lex >> pass_thru;
 584                         break;
 585
 586                 case LT_PASS_THRU_CHARS:
 587                         lex >> pass_thru_chars;
 588                         break;
 589
 590                 case LT_PARBREAK_IS_NEWLINE:
 591                         lex >> parbreak_is_newline;
 592                         break;
 593
 594                 case LT_SPACING:
 595                         readSpacing(lex);
 596                         break;
 597
 598                 case LT_REQUIRES: {
 599                         lex.eatLine();
 600                         vector<string> const req =
 601                                 getVectorFromString(lex.getString(true));
 602                         requires_.insert(req.begin(), req.end());
 603                         break;
 604                 }
 605
 606                 case LT_AUTONESTS: {
 607                         docstring const autonest =
 608                                 subst(subst(subst(lex.getLongString(from_ascii("EndAutoNests")),
 609                                                   from_ascii("\n"), docstring()),
 610                                             from_ascii(" "), docstring()),
 611                                       from_ascii("\t"), docstring());
 612                         vector<docstring> const autonests =
 613                                 getVectorFromString(autonest);
 614                         autonests_.insert(autonests.begin(), autonests.end());
 615                         break;
 616                 }
 617
 618                 case LT_AUTONESTEDBY: {
 619                         docstring const autonest =
 620                                 subst(subst(subst(lex.getLongString(from_ascii("EndIsAutoNestedBy")),
 621                                                   from_ascii("\n"), docstring()),
 622                                             from_ascii(" "), docstring()),
 623                                       from_ascii("\t"), docstring());
 624                         vector<docstring> const autonests =
 625                                 getVectorFromString(autonest);
 626                         autonested_by_.insert(autonests.begin(), autonests.end());
 627                         break;
 628                 }
 629
 630                 case LT_REFPREFIX: {
 631                         docstring arg;
 632                         lex >> arg;
 633                         if (arg == "OFF")
 634                                 refprefix.clear();
 635                         else
 636                                 refprefix = arg;
 637                         break;
 638                 }
 639
 640                 case LT_HTMLTAG:
 641                         lex >> htmltag_;
 642                         break;
 643
 644                 case LT_HTMLATTR:
 645                         lex >> htmlattr_;
 646                         break;
 647
 648                 case LT_HTMLITEM:
 649                         lex >> htmlitemtag_;
 650                         break;
 651
 652                 case LT_HTMLITEMATTR:
 653                         lex >> htmlitemattr_;
 654                         break;
 655
 656                 case LT_HTMLLABEL:
 657                         lex >> htmllabeltag_;
 658                         break;
 659
 660                 case LT_HTMLLABELATTR:
 661                         lex >> htmllabelattr_;
 662                         break;
 663
 664                 case LT_HTMLLABELFIRST:
 665                         lex >> htmllabelfirst_;
 666                         break;
 667
 668                 case LT_HTMLSTYLE:
 669                         htmlstyle_ = lex.getLongString(from_ascii("EndHTMLStyle"));
 670                         break;
 671
 672                 case LT_HTMLFORCECSS:
 673                         lex >> htmlforcecss_;
 674                         break;
 675
 676                 case LT_HTMLPREAMBLE:
 677                         htmlpreamble_ = lex.getLongString(from_ascii("EndPreamble"));
 678                         break;
 679
 680                 case LT_HTMLTITLE:
 681                         lex >> htmltitle_;
 682                         break;
 683
 684                 case LT_SPELLCHECK:
 685                         lex >> spellcheck;
 686                         break;
 687
 688                 case LT_FORCELOCAL:
 689                         lex >> forcelocal;
 690                         break;
 691
 692                 case LT_ADDTOTOC:
 693                         lex >> toc_type_;
 694                         add_to_toc_ = !toc_type_.empty();
 695                         break;
 696
 697                 case LT_ISTOCCAPTION:
 698                         lex >> is_toc_caption_;
 699                         break;
 700
 701                 }
 702         }
 703         lex.popTable();
 704         // make sure we only have inpreamble = true for commands
 705         if (inpreamble && latextype != LATEX_COMMAND && latextype != LATEX_PARAGRAPH) {
 706                 LYXERR0("InPreamble not permitted except with command and paragraph layouts.");
 707                 LYXERR0("Layout name: " << name());
 708                 inpreamble = false;
 709         }
 710
 711         return finished && !error;
 712 }
 713
 714
 715 enum {
 716         AT_BLOCK = 1,
 717         AT_LEFT,
 718         AT_RIGHT,
 719         AT_CENTER,
 720         AT_LAYOUT
 721 };
 722
 723
 724 LexerKeyword alignTags[] = {
 725         { "block",  AT_BLOCK },
 726         { "center", AT_CENTER },
 727         { "layout", AT_LAYOUT },
 728         { "left",   AT_LEFT },
 729         { "right",  AT_RIGHT }
 730 };
 731
 732
 733 void Layout::readAlign(Lexer & lex)
 734 {
 735         PushPopHelper pph(lex, alignTags);
 736         int le = lex.lex();
 737         switch (le) {
 738         case Lexer::LEX_UNDEF:
 739                 lex.printError("Unknown alignment `$$Token'");
 740                 return;
 741         default: break;
 742         };
 743         switch (le) {
 744         case AT_BLOCK:
 745                 align = LYX_ALIGN_BLOCK;
 746                 break;
 747         case AT_LEFT:
 748                 align = LYX_ALIGN_LEFT;
 749                 break;
 750         case AT_RIGHT:
 751                 align = LYX_ALIGN_RIGHT;
 752                 break;
 753         case AT_CENTER:
 754                 align = LYX_ALIGN_CENTER;
 755                 break;
 756         case AT_LAYOUT:
 757                 align = LYX_ALIGN_LAYOUT;
 758                 break;
 759         }
 760 }
 761
 762
 763 void Layout::readAlignPossible(Lexer & lex)
 764 {
 765         lex.pushTable(alignTags);
 766         alignpossible = LYX_ALIGN_NONE | LYX_ALIGN_LAYOUT;
 767         int lineno = lex.lineNumber();
 768         do {
 769                 int le = lex.lex();
 770                 switch (le) {
 771                 case Lexer::LEX_UNDEF:
 772                         lex.printError("Unknown alignment `$$Token'");
 773                         continue;
 774                 default: break;
 775                 };
 776                 switch (le) {
 777                 case AT_BLOCK:
 778                         alignpossible |= LYX_ALIGN_BLOCK;
 779                         break;
 780                 case AT_LEFT:
 781                         alignpossible |= LYX_ALIGN_LEFT;
 782                         break;
 783                 case AT_RIGHT:
 784                         alignpossible |= LYX_ALIGN_RIGHT;
 785                         break;
 786                 case AT_CENTER:
 787                         alignpossible |= LYX_ALIGN_CENTER;
 788                         break;
 789                 case AT_LAYOUT:
 790                         alignpossible |= LYX_ALIGN_LAYOUT;
 791                         break;
 792                 }
 793         } while (lineno == lex.lineNumber());
 794         lex.popTable();
 795 }
 796
 797
 798 void Layout::readLabelType(Lexer & lex)
 799 {
 800         enum {
 801                 LA_NO_LABEL = 1,
 802                 LA_MANUAL,
 803                 LA_ABOVE,
 804                 LA_CENTERED,
 805                 LA_STATIC,
 806                 LA_SENSITIVE,
 807                 LA_ENUMERATE,
 808                 LA_ITEMIZE,
 809                 LA_BIBLIO
 810         };
 811
 812
 813         LexerKeyword labelTypeTags[] = {
 814           { "above",        LA_ABOVE },
 815                 { "bibliography", LA_BIBLIO },
 816                 { "centered",     LA_CENTERED },
 817                 { "enumerate",    LA_ENUMERATE },
 818                 { "itemize",      LA_ITEMIZE },
 819                 { "manual",       LA_MANUAL },
 820                 { "no_label",     LA_NO_LABEL },
 821                 { "sensitive",    LA_SENSITIVE },
 822                 { "static",       LA_STATIC }
 823         };
 824
 825         PushPopHelper pph(lex, labelTypeTags);
 826         int le = lex.lex();
 827         switch (le) {
 828         case Lexer::LEX_UNDEF:
 829                 lex.printError("Unknown labeltype tag `$$Token'");
 830                 return;
 831         default: break;
 832         }
 833         switch (le) {
 834         case LA_NO_LABEL:
 835                 labeltype = LABEL_NO_LABEL;
 836                 break;
 837         case LA_MANUAL:
 838                 labeltype = LABEL_MANUAL;
 839                 break;
 840         case LA_ABOVE:
 841                 labeltype = LABEL_ABOVE;
 842                 break;
 843         case LA_CENTERED:
 844                 labeltype = LABEL_CENTERED;
 845                 break;
 846         case LA_STATIC:
 847                 labeltype = LABEL_STATIC;
 848                 break;
 849         case LA_SENSITIVE:
 850                 labeltype = LABEL_SENSITIVE;
 851                 break;
 852         case LA_ENUMERATE:
 853                 labeltype = LABEL_ENUMERATE;
 854                 break;
 855         case LA_ITEMIZE:
 856                 labeltype = LABEL_ITEMIZE;
 857                 break;
 858         case LA_BIBLIO:
 859                 labeltype = LABEL_BIBLIO;
 860                 break;
 861         }
 862 }
 863
 864
 865 void Layout::readEndLabelType(Lexer & lex)
 866 {
 867         // this should be const, but can't be because
 868         // of PushPopHelper.
 869         static LexerKeyword endlabelTypeTags[] = {
 870                 { "box",              END_LABEL_BOX },
 871                 { "filled_box", END_LABEL_FILLED_BOX },
 872                 { "no_label",     END_LABEL_NO_LABEL },
 873                 { "static",     END_LABEL_STATIC }
 874         };
 875
 876         PushPopHelper pph(lex, endlabelTypeTags);
 877         int le = lex.lex();
 878         switch (le) {
 879         case Lexer::LEX_UNDEF:
 880                 lex.printError("Unknown labeltype tag `$$Token'");
 881                 break;
 882         case END_LABEL_STATIC:
 883         case END_LABEL_BOX:
 884         case END_LABEL_FILLED_BOX:
 885         case END_LABEL_NO_LABEL:
 886                 endlabeltype = static_cast<EndLabelType>(le);
 887                 break;
 888         default:
 889                 LYXERR0("Unhandled value " << le);
 890                 break;
 891         }
 892 }
 893
 894
 895 void Layout::readMargin(Lexer & lex)
 896 {
 897         LexerKeyword marginTags[] = {
 898                 { "dynamic",           MARGIN_DYNAMIC },
 899                 { "first_dynamic",     MARGIN_FIRST_DYNAMIC },
 900                 { "manual",            MARGIN_MANUAL },
 901                 { "right_address_box", MARGIN_RIGHT_ADDRESS_BOX },
 902                 { "static",            MARGIN_STATIC }
 903         };
 904
 905         PushPopHelper pph(lex, marginTags);
 906
 907         int le = lex.lex();
 908         switch (le) {
 909         case Lexer::LEX_UNDEF:
 910                 lex.printError("Unknown margin type tag `$$Token'");
 911                 return;
 912         case MARGIN_STATIC:
 913         case MARGIN_MANUAL:
 914         case MARGIN_DYNAMIC:
 915         case MARGIN_FIRST_DYNAMIC:
 916         case MARGIN_RIGHT_ADDRESS_BOX:
 917                 margintype = static_cast<MarginType>(le);
 918                 break;
 919         default:
 920                 LYXERR0("Unhandled value " << le);
 921                 break;
 922         }
 923 }
 924
 925
 926 void Layout::readLatexType(Lexer & lex)
 927 {
 928         LexerKeyword latexTypeTags[] = {
 929                 { "bib_environment",  LATEX_BIB_ENVIRONMENT },
 930                 { "command",          LATEX_COMMAND },
 931                 { "environment",      LATEX_ENVIRONMENT },
 932                 { "item_environment", LATEX_ITEM_ENVIRONMENT },
 933                 { "list_environment", LATEX_LIST_ENVIRONMENT },
 934                 { "paragraph",        LATEX_PARAGRAPH }
 935         };
 936
 937         PushPopHelper pph(lex, latexTypeTags);
 938         int le = lex.lex();
 939         switch (le) {
 940         case Lexer::LEX_UNDEF:
 941                 lex.printError("Unknown latextype tag `$$Token'");
 942                 return;
 943         case LATEX_PARAGRAPH:
 944         case LATEX_COMMAND:
 945         case LATEX_ITEM_ENVIRONMENT:
 946         case LATEX_LIST_ENVIRONMENT:
 947                 latextype = static_cast<LatexType>(le);
 948                 break;
 949         case LATEX_ENVIRONMENT:
 950         case LATEX_BIB_ENVIRONMENT:
 951                 latextype = static_cast<LatexType>(le);
 952                 par_group_ = true;
 953                 break;
 954         default:
 955                 LYXERR0("Unhandled value " << le);
 956                 break;
 957         }
 958 }
 959
 960
 961 void Layout::readSpacing(Lexer & lex)
 962 {
 963         enum {
 964                 ST_SPACING_SINGLE = 1,
 965                 ST_SPACING_ONEHALF,
 966                 ST_SPACING_DOUBLE,
 967                 ST_OTHER
 968         };
 969
 970         LexerKeyword spacingTags[] = {
 971                 {"double",  ST_SPACING_DOUBLE },
 972                 {"onehalf", ST_SPACING_ONEHALF },
 973                 {"other",   ST_OTHER },
 974                 {"single",  ST_SPACING_SINGLE }
 975         };
 976
 977         PushPopHelper pph(lex, spacingTags);
 978         int le = lex.lex();
 979         switch (le) {
 980         case Lexer::LEX_UNDEF:
 981                 lex.printError("Unknown spacing token `$$Token'");
 982                 return;
 983         default: break;
 984         }
 985         switch (le) {
 986         case ST_SPACING_SINGLE:
 987                 spacing.set(Spacing::Single);
 988                 break;
 989         case ST_SPACING_ONEHALF:
 990                 spacing.set(Spacing::Onehalf);
 991                 break;
 992         case ST_SPACING_DOUBLE:
 993                 spacing.set(Spacing::Double);
 994                 break;
 995         case ST_OTHER:
 996                 lex.next();
 997                 spacing.set(Spacing::Other, lex.getString());
 998                 break;
 999         }
1000 }
1001
1002
1003 void Layout::readArgument(Lexer & lex)
1004 {
1005         latexarg arg;
1006         // writeArgument() makes use of these default values
1007         arg.mandatory = false;
1008         arg.autoinsert = false;
1009         arg.insertcotext = false;
1010         bool error = false;
1011         bool finished = false;
1012         arg.font = inherit_font;
1013         arg.labelfont = inherit_font;
1014         arg.is_toc_caption = false;
1015         arg.passthru = PT_INHERITED;
1016         string id;
1017         lex >> id;
1018         bool const itemarg = prefixIs(id, "item:");
1019         bool const postcmd = prefixIs(id, "post:");
1020
1021         while (!finished && lex.isOK() && !error) {
1022                 lex.next();
1023                 string const tok = ascii_lowercase(lex.getString());
1024
1025                 if (tok.empty()) {
1026                         continue;
1027                 } else if (tok == "endargument") {
1028                         finished = true;
1029                 } else if (tok == "labelstring") {
1030                         lex.next();
1031                         arg.labelstring = lex.getDocString();
1032                 } else if (tok == "menustring") {
1033                         lex.next();
1034                         arg.menustring = lex.getDocString();
1035                 } else if (tok == "mandatory") {
1036                         lex.next();
1037                         arg.mandatory = lex.getBool();
1038                 } else if (tok == "autoinsert") {
1039                         lex.next();
1040                         arg.autoinsert = lex.getBool();
1041                 } else if (tok == "insertcotext") {
1042                         lex.next();
1043                         arg.insertcotext = lex.getBool();
1044                 } else if (tok == "leftdelim") {
1045                         lex.next();
1046                         arg.ldelim = lex.getDocString();
1047                         arg.ldelim = support::subst(arg.ldelim, from_ascii("<br/>"),
1048                                                     from_ascii("\n"));
1049                 } else if (tok == "rightdelim") {
1050                         lex.next();
1051                         arg.rdelim = lex.getDocString();
1052                         arg.rdelim = support::subst(arg.rdelim, from_ascii("<br/>"),
1053                                                     from_ascii("\n"));
1054                 } else if (tok == "defaultarg") {
1055                         lex.next();
1056                         arg.defaultarg = lex.getDocString();
1057                 } else if (tok == "presetarg") {
1058                         lex.next();
1059                         arg.presetarg = lex.getDocString();
1060                 } else if (tok == "tooltip") {
1061                         lex.next();
1062                         arg.tooltip = lex.getDocString();
1063                 } else if (tok == "requires") {
1064                         lex.next();
1065                         arg.requires = lex.getString();
1066                 } else if (tok == "decoration") {
1067                         lex.next();
1068                         arg.decoration = lex.getString();
1069                 } else if (tok == "font") {
1070                         arg.font = lyxRead(lex, arg.font);
1071                 } else if (tok == "labelfont") {
1072                         arg.labelfont = lyxRead(lex, arg.labelfont);
1073                 } else if (tok == "passthruchars") {
1074                         lex.next();
1075                         arg.pass_thru_chars = lex.getDocString();
1076                 } else if (tok == "passthru") {
1077                         lex.next();
1078                         docstring value = lex.getDocString();
1079                         if (value == "true" || value == "1")
1080                                 arg.passthru = PT_TRUE;
1081                         else if (value == "false" || value == "0")
1082                                 arg.passthru = PT_FALSE;
1083                         else
1084                                 arg.passthru = PT_INHERITED;
1085                 } else if (tok == "istoccaption") {
1086                         lex.next();
1087                         arg.is_toc_caption = lex.getBool();
1088                 } else {
1089                         lex.printError("Unknown tag");
1090                         error = true;
1091                 }
1092         }
1093         if (arg.labelstring.empty())
1094                 LYXERR0("Incomplete Argument definition!");
1095         else if (itemarg)
1096                 itemargs_[id] = arg;
1097         else if (postcmd)
1098                 postcommandargs_[id] = arg;
1099         else
1100                 latexargs_[id] = arg;
1101 }
1102
1103
1104 void writeArgument(ostream & os, string const & id, Layout::latexarg const & arg)
1105 {
1106         os << "\tArgument " << id << '\n';
1107         if (!arg.labelstring.empty())
1108                 os << "\t\tLabelString \"" << to_utf8(arg.labelstring) << "\"\n";
1109         if (!arg.menustring.empty())
1110                 os << "\t\tMenuString \"" << to_utf8(arg.menustring) << "\"\n";
1111         if (arg.mandatory)
1112                 os << "\t\tMandatory " << arg.mandatory << '\n';
1113         if (arg.autoinsert)
1114                 os << "\t\tAutoinsert " << arg.autoinsert << '\n';
1115         if (arg.insertcotext)
1116                 os << "\t\tInsertCotext " << arg.insertcotext << '\n';
1117         if (!arg.ldelim.empty())
1118                 os << "\t\tLeftDelim \""
1119                    << to_utf8(subst(arg.ldelim, from_ascii("\n"), from_ascii("<br/>")))
1120                    << "\"\n";
1121         if (!arg.rdelim.empty())
1122                 os << "\t\tRightDelim \""
1123                    << to_utf8(subst(arg.rdelim, from_ascii("\n"), from_ascii("<br/>")))
1124                    << "\"\n";
1125         if (!arg.defaultarg.empty())
1126                 os << "\t\tDefaultArg \"" << to_utf8(arg.defaultarg) << "\"\n";
1127         if (!arg.presetarg.empty())
1128                 os << "\t\tPresetArg \"" << to_utf8(arg.presetarg) << "\"\n";
1129         if (!arg.tooltip.empty())
1130                 os << "\t\tToolTip \"" << to_utf8(arg.tooltip) << "\"\n";
1131         if (!arg.requires.empty())
1132                 os << "\t\tRequires \"" << arg.requires << "\"\n";
1133         if (!arg.decoration.empty())
1134                 os << "\t\tDecoration \"" << arg.decoration << "\"\n";
1135         if (arg.font != inherit_font)
1136                 lyxWrite(os, arg.font, "Font", 2);
1137         if (arg.labelfont != inherit_font)
1138                 lyxWrite(os, arg.labelfont, "LabelFont", 2);
1139         switch (arg.passthru) {
1140                 case PT_TRUE:
1141                         os << "\t\tPassThru true\n";
1142                         break;
1143                 case PT_FALSE:
1144                         os << "\t\tPassThru false\n";
1145                         break;
1146                 case PT_INHERITED:
1147                         os << "\t\tPassThru inherited\n";
1148                         break;
1149         }
1150         if (!arg.pass_thru_chars.empty())
1151                 os << "\t\tPassThruChars \"" << to_utf8(arg.pass_thru_chars) << "\"\n";
1152         os << "\tEndArgument\n";
1153 }
1154
1155
1156 void Layout::write(ostream & os) const
1157 {
1158         os << "Style \"" << to_utf8(name_) << "\"\n";
1159         if (!category_.empty() && obsoleted_by_.empty())
1160                 os << "\tCategory \"" << to_utf8(category_) << "\"\n";
1161         // Can't deduce Copystyle here :-(
1162         if (!obsoleted_by_.empty()) {
1163                 os << "\tObsoletedBy \"" << to_utf8(obsoleted_by_)
1164                    << "\"\nEnd\n";
1165                 return;
1166         }
1167         if (!depends_on_.empty())
1168                 os << "\tDependsOn " << to_utf8(depends_on_) << '\n';
1169         switch (margintype) {
1170                 case MARGIN_DYNAMIC:
1171                         os << "\tMargin Dynamic\n";
1172                         break;
1173                 case MARGIN_FIRST_DYNAMIC:
1174                         os << "\tMargin First_Dynamic\n";
1175                         break;
1176                 case MARGIN_MANUAL:
1177                         os << "\tMargin Manual\n";
1178                         break;
1179                 case MARGIN_RIGHT_ADDRESS_BOX:
1180                         os << "\tMargin Right_Address_Box\n";
1181                         break;
1182                 case MARGIN_STATIC:
1183                         os << "\tMargin Static\n";
1184                         break;
1185         }
1186         switch (latextype) {
1187                 case LATEX_BIB_ENVIRONMENT:
1188                         os << "\tLatexType Bib_Environment\n";
1189                         break;
1190                 case LATEX_COMMAND:
1191                         os << "\tLatexType Command\n";
1192                         break;
1193                 case LATEX_ENVIRONMENT:
1194                         os << "\tLatexType Environment\n";
1195                         break;
1196                 case LATEX_ITEM_ENVIRONMENT:
1197                         os << "\tLatexType Item_Environment\n";
1198                         break;
1199                 case LATEX_LIST_ENVIRONMENT:
1200                         os << "\tLatexType List_Environment\n";
1201                         break;
1202                 case LATEX_PARAGRAPH:
1203                         os << "\tLatexType Paragraph\n";
1204                         break;
1205         }
1206         os << "\tInTitle " << intitle << "\n"
1207               "\tInPreamble " << inpreamble << "\n"
1208               "\tTocLevel " << toclevel << "\n"
1209               "\tResumeCounter " << resumecounter << "\n"
1210              "\tStepMasterCounter " << stepmastercounter << '\n';
1211         // ResetArgs does not make sense here
1212         for (LaTeXArgMap::const_iterator it = latexargs_.begin();
1213              it != latexargs_.end(); ++it)
1214                 writeArgument(os, it->first, it->second);
1215         for (LaTeXArgMap::const_iterator it = itemargs_.begin();
1216              it != itemargs_.end(); ++it)
1217                 writeArgument(os, it->first, it->second);
1218         for (LaTeXArgMap::const_iterator it = postcommandargs_.begin();
1219              it != postcommandargs_.end(); ++it)
1220                 writeArgument(os, it->first, it->second);
1221         os << "\tNeedProtect " << needprotect << "\n"
1222               "\tNeedCProtect " << needcprotect << "\n"
1223               "\tKeepEmpty " << keepempty << '\n';
1224         if (labelfont == font)
1225                 lyxWrite(os, font, "Font", 1);
1226         else {
1227                 lyxWrite(os, font, "TextFont", 1);
1228                 lyxWrite(os, labelfont, "LabelFont", 1);
1229         }
1230         os << "\tNextNoIndent " << nextnoindent << "\n"
1231               "\tCommandDepth " << commanddepth << '\n';
1232         if (!latexname_.empty())
1233                 os << "\tLatexName \"" << latexname_ << "\"\n";
1234         if (!latexparam_.empty())
1235                 os << "\tLatexParam \"" << subst(latexparam_, "\"", "&quot;")
1236                    << "\"\n";
1237         if (!leftdelim_.empty())
1238                 os << "\tLeftDelim "
1239                    << to_utf8(subst(leftdelim_, from_ascii("\n"), from_ascii("<br/>")))
1240                    << '\n';
1241         if (!rightdelim_.empty())
1242                 os << "\tRightDelim "
1243                    << to_utf8(subst(rightdelim_, from_ascii("\n"), from_ascii("<br/>")))
1244                    << '\n';
1245         if (!innertag_.empty())
1246                 os << "\tInnerTag \"" << innertag_ << "\"\n";
1247         if (!labeltag_.empty())
1248                 os << "\tLabelTag \"" << labeltag_ << "\"\n";
1249         if (!itemtag_.empty())
1250                 os << "\tItemTag \"" << itemtag_ << "\"\n";
1251         if (!itemcommand_.empty())
1252                 os << "\tItemCommand " << itemcommand_ << '\n';
1253         if (!preamble_.empty())
1254                 os << "\tPreamble\n\t"
1255                    << to_utf8(subst(rtrim(preamble_, "\n"),
1256                                     from_ascii("\n"), from_ascii("\n\t")))
1257                    << "\n\tEndPreamble\n";
1258         if (!langpreamble_.empty())
1259                 os << "\tLangPreamble\n\t"
1260                    << to_utf8(subst(rtrim(langpreamble_, "\n"),
1261                                     from_ascii("\n"), from_ascii("\n\t")))
1262                    << "\n\tEndLangPreamble\n";
1263         if (!babelpreamble_.empty())
1264                 os << "\tBabelPreamble\n\t"
1265                    << to_utf8(subst(rtrim(babelpreamble_, "\n"),
1266                                     from_ascii("\n"), from_ascii("\n\t")))
1267                    << "\n\tEndBabelPreamble\n";
1268         switch (labeltype) {
1269         case LABEL_ABOVE:
1270                 os << "\tLabelType Above\n";
1271                 break;
1272         case LABEL_BIBLIO:
1273                 os << "\tLabelType Bibliography\n";
1274                 break;
1275         case LABEL_CENTERED:
1276                 os << "\tLabelType Centered\n";
1277                 break;
1278         case LABEL_ENUMERATE:
1279                 os << "\tLabelType Enumerate\n";
1280                 break;
1281         case LABEL_ITEMIZE:
1282                 os << "\tLabelType Itemize\n";
1283                 break;
1284         case LABEL_MANUAL:
1285                 os << "\tLabelType Manual\n";
1286                 break;
1287         case LABEL_NO_LABEL:
1288                 os << "\tLabelType No_Label\n";
1289                 break;
1290         case LABEL_SENSITIVE:
1291                 os << "\tLabelType Sensitive\n";
1292                 break;
1293         case LABEL_STATIC:
1294                 os << "\tLabelType Static\n";
1295                 break;
1296         }
1297         switch (endlabeltype) {
1298         case END_LABEL_BOX:
1299                 os << "\tEndLabelType Box\n";
1300                 break;
1301         case END_LABEL_FILLED_BOX:
1302                 os << "\tEndLabelType Filled_Box\n";
1303                 break;
1304         case END_LABEL_NO_LABEL:
1305                 os << "\tEndLabelType No_Label\n";
1306                 break;
1307         case END_LABEL_STATIC:
1308                 os << "\tEndLabelType Static\n";
1309                 break;
1310         }
1311         os << "\tParagraphGroup \"" << par_group_ << "\"\n";
1312         if (!leftmargin.empty())
1313                 os << "\tLeftMargin \"" << to_utf8(leftmargin) << "\"\n";
1314         if (!rightmargin.empty())
1315                 os << "\tRightMargin \"" << to_utf8(rightmargin) << "\"\n";
1316         if (!labelindent.empty())
1317                 os << "\tLabelIndent " << to_utf8(labelindent) << '\n';
1318         if (!parindent.empty())
1319                 os << "\tParIndent " << to_utf8(parindent) << '\n';
1320         os << "\tParSkip " << parskip << "\n"
1321               "\tItemSep " << itemsep << "\n"
1322               "\tTopSep " << topsep << "\n"
1323               "\tBottomSep " << bottomsep << "\n"
1324               "\tLabelBottomSep " << labelbottomsep << '\n';
1325         if (!labelsep.empty())
1326                 os << "\tLabelSep " << to_utf8(subst(labelsep, ' ', 'x'))
1327                    << '\n';
1328         os << "\tParSep " << parsep << "\n"
1329               "\tNewLine " << newline_allowed << '\n';
1330         switch (align) {
1331         case LYX_ALIGN_BLOCK:
1332                 os << "\tAlign Block\n";
1333                 break;
1334         case LYX_ALIGN_CENTER:
1335                 os << "\tAlign Center\n";
1336                 break;
1337         case LYX_ALIGN_LAYOUT:
1338                 os << "\tAlign Layout\n";
1339                 break;
1340         case LYX_ALIGN_LEFT:
1341                 os << "\tAlign Left\n";
1342                 break;
1343         case LYX_ALIGN_RIGHT:
1344                 os << "\tAlign Right\n";
1345                 break;
1346         case LYX_ALIGN_DECIMAL:
1347         case LYX_ALIGN_SPECIAL:
1348         case LYX_ALIGN_NONE:
1349                 break;
1350         }
1351         if (alignpossible & (LYX_ALIGN_BLOCK | LYX_ALIGN_CENTER |
1352                              LYX_ALIGN_LAYOUT | LYX_ALIGN_LEFT | LYX_ALIGN_RIGHT)) {
1353                 bool first = true;
1354                 os << "\tAlignPossible";
1355                 if (alignpossible & LYX_ALIGN_BLOCK) {
1356                         os << " Block";
1357                         first = false;
1358                 }
1359                 if (alignpossible & LYX_ALIGN_CENTER) {
1360                         if (!first)
1361                                 os << ',';
1362                         os << " Center";
1363                         first = false;
1364                 }
1365                 if (alignpossible & LYX_ALIGN_LAYOUT) {
1366                         if (!first)
1367                                 os << ',';
1368                         os << " Layout";
1369                         first = false;
1370                 }
1371                 if (alignpossible & LYX_ALIGN_LEFT) {
1372                         if (!first)
1373                                 os << ',';
1374                         os << " Left";
1375                         first = false;
1376                 }
1377                 if (alignpossible & LYX_ALIGN_RIGHT) {
1378                         if (!first)
1379                                 os << ',';
1380                         os << " Right";
1381                         first = false;
1382                 }
1383                 os << '\n';
1384         }
1385         // LabelString must come before LabelStringAppendix
1386         if (!labelstring_.empty())
1387                 os << "\tLabelString \"" << to_utf8(labelstring_) << "\"\n";
1388         if (!endlabelstring_.empty())
1389                 os << "\tEndLabelString \"" << to_utf8(endlabelstring_) << "\"\n";
1390         if (!labelstring_appendix_.empty() && labelstring_appendix_ != labelstring_)
1391                 os << "\tLabelStringAppendix \""
1392                    << to_utf8(labelstring_appendix_) << "\"\n";
1393         if (!counter.empty())
1394                 os << "\tLabelCounter \"" << to_utf8(counter) << "\"\n";
1395         os << "\tFreeSpacing " << free_spacing << '\n';
1396         os << "\tPassThru " << pass_thru << '\n';
1397         if (!pass_thru_chars.empty())
1398                 os << "\tPassThruChars " << to_utf8(pass_thru_chars) << '\n';
1399         os << "\tParbreakIsNewline " << parbreak_is_newline << '\n';
1400         switch (spacing.getSpace()) {
1401         case Spacing::Double:
1402                 os << "\tSpacing Double\n";
1403                 break;
1404         case Spacing::Onehalf:
1405                 os << "\tSpacing Onehalf\n";
1406                 break;
1407         case Spacing::Other:
1408                 os << "\tSpacing Other " << spacing.getValueAsString() << '\n';
1409                 break;
1410         case Spacing::Single:
1411                 os << "\tSpacing Single\n";
1412                 break;
1413         case Spacing::Default:
1414                 break;
1415         }
1416         if (!requires_.empty()) {
1417                 os << "\tRequires ";
1418                 for (set<string>::const_iterator it = requires_.begin();
1419                      it != requires_.end(); ++it) {
1420                         if (it != requires_.begin())
1421                                 os << ',';
1422                         os << *it;
1423                 }
1424                 os << '\n';
1425         }
1426         if (!autonests_.empty()) {
1427                 os << "\tAutoNests\n\t";
1428                 for (set<docstring>::const_iterator it = autonests_.begin();
1429                      it != autonests_.end(); ++it) {
1430                         if (it != autonests_.begin())
1431                                 os << ',';
1432                         os << to_utf8(*it);
1433                 }
1434                 os << "\n\tEndAutoNests\n";
1435         }
1436         if (!autonested_by_.empty()) {
1437                 os << "\tIsAutoNestedBy\n\t";
1438                 for (set<docstring>::const_iterator it = autonested_by_.begin();
1439                      it != autonested_by_.end(); ++it) {
1440                         if (it != autonested_by_.begin())
1441                                 os << ',';
1442                         os << to_utf8(*it);
1443                 }
1444                 os << "\n\tIsAutoNestedBy\n";
1445         }
1446         if (refprefix.empty())
1447                 os << "\tRefPrefix OFF\n";
1448         else
1449                 os << "\tRefPrefix " << to_utf8(refprefix) << '\n';
1450         if (!htmltag_.empty())
1451                 os << "\tHTMLTag " << htmltag_ << '\n';
1452         if (!htmlattr_.empty())
1453                 os << "\tHTMLAttr " << htmlattr_ << '\n';
1454         if (!htmlitemtag_.empty())
1455                 os << "\tHTMLItem " << htmlitemtag_ << '\n';
1456         if (!htmlitemattr_.empty())
1457                 os << "\tHTMLItemAttr " << htmlitemattr_ << '\n';
1458         if (!htmllabeltag_.empty())
1459                 os << "\tHTMLLabel " << htmllabeltag_ << '\n';
1460         if (!htmllabelattr_.empty())
1461                 os << "\tHTMLLabelAttr " << htmllabelattr_ << '\n';
1462         os << "\tHTMLLabelFirst " << htmllabelfirst_ << '\n';
1463         if (!htmlstyle_.empty())
1464                 os << "\tHTMLStyle\n"
1465                    << to_utf8(rtrim(htmlstyle_, "\n"))
1466                    << "\n\tEndHTMLStyle\n";
1467         os << "\tHTMLForceCSS " << htmlforcecss_ << '\n';
1468         if (!htmlpreamble_.empty())
1469                 os << "\tHTMLPreamble\n"
1470                    << to_utf8(rtrim(htmlpreamble_, "\n"))
1471                    << "\n\tEndPreamble\n";
1472         os << "\tHTMLTitle " << htmltitle_ << "\n"
1473               "\tSpellcheck " << spellcheck << "\n"
1474               "\tForceLocal " << forcelocal << "\n"
1475               "End\n";
1476 }
1477
1478
1479 bool Layout::hasArgs() const
1480 {
1481         return !latexargs_.empty() || !postcommandargs_.empty() ||
1482                 !itemargs_.empty();
1483 }
1484
1485
1486 Layout::LaTeXArgMap Layout::args() const
1487 {
1488         LaTeXArgMap args = latexargs_;
1489         if (!postcommandargs_.empty())
1490                 args.insert(postcommandargs_.begin(), postcommandargs_.end());
1491         if (!itemargs_.empty())
1492                 args.insert(itemargs_.begin(), itemargs_.end());
1493         return args;
1494 }
1495
1496
1497 int Layout::optArgs() const
1498 {
1499         int nr = 0;
1500         LaTeXArgMap::const_iterator it = latexargs_.begin();
1501         for (; it != latexargs_.end(); ++it) {
1502                 if (!(*it).second.mandatory)
1503                         ++nr;
1504         }
1505         LaTeXArgMap::const_iterator iit = postcommandargs_.begin();
1506         for (; iit != postcommandargs_.end(); ++iit) {
1507                 if (!(*iit).second.mandatory)
1508                         ++nr;
1509         }
1510         return nr;
1511 }
1512
1513
1514 int Layout::requiredArgs() const
1515 {
1516         int nr = 0;
1517         LaTeXArgMap::const_iterator it = latexargs_.begin();
1518         for (; it != latexargs_.end(); ++it) {
1519                 if ((*it).second.mandatory)
1520                         ++nr;
1521         }
1522         LaTeXArgMap::const_iterator iit = postcommandargs_.begin();
1523         for (; iit != postcommandargs_.end(); ++iit) {
1524                 if (!(*iit).second.mandatory)
1525                         ++nr;
1526         }
1527         return nr;
1528 }
1529
1530
1531 string const & Layout::htmltag() const
1532 {
1533         if (htmltag_.empty())
1534                 htmltag_ =  "div";
1535         return htmltag_;
1536 }
1537
1538
1539 string const & Layout::htmlattr() const
1540 {
1541         if (htmlattr_.empty())
1542                 htmlattr_ = "class=\"" + defaultCSSClass() + "\"";
1543         return htmlattr_;
1544 }
1545
1546
1547 string const & Layout::htmlitemtag() const
1548 {
1549         if (htmlitemtag_.empty())
1550                 htmlitemtag_ = "div";
1551         return htmlitemtag_;
1552 }
1553
1554
1555 string const & Layout::htmlitemattr() const
1556 {
1557         if (htmlitemattr_.empty())
1558                 htmlitemattr_ = "class=\"" + defaultCSSItemClass() + "\"";
1559         return htmlitemattr_;
1560 }
1561
1562
1563 string const & Layout::htmllabeltag() const
1564 {
1565         if (htmllabeltag_.empty())
1566                         htmllabeltag_ = "span";
1567         return htmllabeltag_;
1568 }
1569
1570
1571 string const & Layout::htmllabelattr() const
1572 {
1573         if (htmllabelattr_.empty())
1574                 htmllabelattr_ = "class=\"" + defaultCSSLabelClass() + "\"";
1575         return htmllabelattr_;
1576 }
1577
1578
1579 docstring Layout::htmlstyle() const
1580 {
1581         if (!htmlstyle_.empty() && !htmlforcecss_)
1582                 return htmlstyle_;
1583         if (htmldefaultstyle_.empty())
1584                 makeDefaultCSS();
1585         docstring retval = htmldefaultstyle_;
1586         if (!htmlstyle_.empty())
1587                 retval += '\n' + htmlstyle_;
1588         return retval;
1589 }
1590
1591
1592 string Layout::defaultCSSClass() const
1593 {
1594         if (!defaultcssclass_.empty())
1595                 return defaultcssclass_;
1596         docstring d;
1597         docstring::const_iterator it = name().begin();
1598         docstring::const_iterator en = name().end();
1599         for (; it != en; ++it) {
1600                 char_type const c = *it;
1601                 if (!isAlphaASCII(c)) {
1602                         if (d.empty())
1603                                 // make sure we don't start with an underscore,
1604                                 // as that sometimes causes problems.
1605                                 d = from_ascii("lyx_");
1606                         else
1607                                 d += '_';
1608                 } else if (isLower(c))
1609                         d += c;
1610                 else
1611                         // this is slow, so do it only if necessary
1612                         d += lowercase(c);
1613         }
1614         defaultcssclass_ = to_utf8(d);
1615         return defaultcssclass_;
1616 }
1617
1618
1619 namespace {
1620
1621 string makeMarginValue(char const * side, double d)
1622 {
1623         ostringstream os;
1624         os << "margin-" << side << ": " << d << "ex;\n";
1625         return os.str();
1626 }
1627
1628 } // namespace
1629
1630
1631 void Layout::makeDefaultCSS() const
1632 {
1633         // this never needs to be redone, since reloading layouts will
1634         // wipe out what we did before.
1635         if (!htmldefaultstyle_.empty())
1636                 return;
1637
1638         // main font
1639         htmldefaultstyle_ = font.asCSS();
1640
1641         // bottom margins
1642         string tmp;
1643         if (topsep > 0)
1644                 tmp += makeMarginValue("top", topsep);
1645         if (bottomsep > 0)
1646                 tmp += makeMarginValue("bottom", bottomsep);
1647         if (!leftmargin.empty()) {
1648                 // we can't really do what LyX does with the margin, so
1649                 // we'll just figure out how many characters it is
1650                 int const len = leftmargin.length();
1651                 tmp += makeMarginValue("left", len);
1652         }
1653         if (!rightmargin.empty()) {
1654                 int const len = rightmargin.length();
1655                 tmp += makeMarginValue("right", len);
1656         }
1657
1658         if (!tmp.empty()) {
1659                 if (!htmldefaultstyle_.empty())
1660                         htmldefaultstyle_ += from_ascii("\n");
1661                 htmldefaultstyle_ += from_ascii(tmp);
1662         }
1663
1664         // alignment
1665         string where = alignmentToCSS(align);
1666         if (!where.empty()) {
1667                 htmldefaultstyle_ += from_ascii("text-align: " + where + ";\n");
1668         }
1669
1670         // wrap up what we have, if anything
1671         if (!htmldefaultstyle_.empty())
1672                 htmldefaultstyle_ =
1673                         from_ascii(htmltag() + "." + defaultCSSClass() + " {\n") +
1674                         htmldefaultstyle_ + from_ascii("\n}\n");
1675
1676         if (labeltype == LABEL_NO_LABEL || htmllabeltag() == "NONE")
1677                 return;
1678
1679         docstring labelCSS;
1680
1681         // label font
1682         if (labelfont != font)
1683                 labelCSS = labelfont.asCSS() + from_ascii("\n");
1684         if (labeltype == LABEL_CENTERED)
1685                 labelCSS += from_ascii("text-align: center;\n");
1686
1687         if (!labelCSS.empty())
1688                 htmldefaultstyle_ +=
1689                         from_ascii(htmllabeltag() + "." + defaultCSSLabelClass() + " {\n") +
1690                         labelCSS + from_ascii("\n}\n");
1691 }
1692
1693
1694 bool Layout::operator==(Layout const & rhs) const
1695 {
1696         // This is enough for the applications we actually make,
1697         // at least at the moment. But we could check more.
1698         return name() == rhs.name()
1699                 && latexname() == rhs.latexname()
1700                 && latextype == rhs.latextype;
1701 }
1702
1703
1704 } // namespace lyx