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