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