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 "Lexer.h"
  17 #include "output_xhtml.h"
  18 #include "TextClass.h"
  19
  20 #include "support/debug.h"
  21 #include "support/docstream.h"
  22 #include "support/lassert.h"
  23 #include "support/lstrings.h"
  24 #include "support/textutils.h"
  25
  26
  27 using namespace std;
  28 using namespace lyx::support;
  29
  30 namespace lyx {
  31
  32 /// Special value of toclevel for layouts that do not belong to a TOC
  33 const int Layout::NOT_IN_TOC = -1000;
  34
  35 //  The order of the LayoutTags enum is no more important. [asierra300396]
  36 // Tags indexes.
  37 enum LayoutTags {
  38         LT_ALIGN = 1,
  39         LT_ALIGNPOSSIBLE,
  40         LT_ARGUMENT,
  41         LT_AUTONESTS,
  42         LT_AUTONESTEDBY,
  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_CPROTECT,
  76         LT_NEED_MBOXPROTECT,
  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_DOCBOOKTAG,
 106         LT_DOCBOOKATTR,
 107         LT_DOCBOOKTAGTYPE,
 108         LT_DOCBOOKINNERATTR,
 109         LT_DOCBOOKINNERTAG,
 110         LT_DOCBOOKINNERTAGTYPE,
 111         LT_DOCBOOKININFO,
 112         LT_DOCBOOKABSTRACT,
 113         LT_DOCBOOKWRAPPERTAG,
 114         LT_DOCBOOKWRAPPERATTR,
 115         LT_DOCBOOKWRAPPERTAGTYPE,
 116         LT_DOCBOOKWRAPPERMERGEWITHPREVIOUS,
 117         LT_DOCBOOKSECTION,
 118         LT_DOCBOOKSECTIONTAG,
 119         LT_DOCBOOKITEMWRAPPERTAG,
 120         LT_DOCBOOKITEMWRAPPERATTR,
 121         LT_DOCBOOKITEMWRAPPERTAGTYPE,
 122         LT_DOCBOOKITEMTAG,
 123         LT_DOCBOOKITEMATTR,
 124         LT_DOCBOOKITEMTAGTYPE,
 125         LT_DOCBOOKITEMLABELTAG,
 126         LT_DOCBOOKITEMLABELATTR,
 127         LT_DOCBOOKITEMLABELTAGTYPE,
 128         LT_DOCBOOKITEMINNERTAG,
 129         LT_DOCBOOKITEMINNERATTR,
 130         LT_DOCBOOKITEMINNERTAGTYPE,
 131         LT_DOCBOOKFORCEABSTRACTTAG,
 132         LT_DOCBOOKNOFONTINSIDE,
 133         LT_INPREAMBLE,
 134         LT_HTMLTITLE,
 135         LT_SPELLCHECK,
 136         LT_REFPREFIX,
 137         LT_RESETARGS,
 138         LT_RESUMECOUNTER,
 139         LT_STEPPARENTCOUNTER,
 140         LT_RIGHTDELIM,
 141         LT_FORCELOCAL,
 142         LT_TOGGLE_INDENT,
 143         LT_ADDTOTOC,
 144         LT_ISTOCCAPTION,
 145         LT_INTITLE // keep this last!
 146 };
 147
 148 /////////////////////
 149
 150 Layout::Layout()
 151         : add_to_toc_(false), is_toc_caption_(true)
 152 {
 153         unknown_ = false;
 154         margintype = MARGIN_STATIC;
 155         latextype = LATEX_PARAGRAPH;
 156         resumecounter = false;
 157         stepparentcounter = false;
 158         intitle = false;
 159         inpreamble = false;
 160         needprotect = false;
 161         needcprotect = false;
 162         needmboxprotect = false;
 163         keepempty = false;
 164         font = inherit_font;
 165         labelfont = inherit_font;
 166         resfont = sane_font;
 167         reslabelfont = sane_font;
 168         nextnoindent = false;
 169         parskip = 0.0;
 170         itemsep = 0;
 171         topsep = 0.0;
 172         bottomsep = 0.0;
 173         labelbottomsep = 0.0;
 174         parsep = 0;
 175         align = LYX_ALIGN_BLOCK;
 176         alignpossible = LYX_ALIGN_NONE | LYX_ALIGN_LAYOUT;
 177         labeltype = LABEL_NO_LABEL;
 178         endlabeltype = END_LABEL_NO_LABEL;
 179         // Should or should not. That is the question.
 180         // spacing.set(Spacing::OneHalf);
 181         newline_allowed = true;
 182         free_spacing = false;
 183         pass_thru = false;
 184         parbreak_is_newline = false;
 185         toclevel = NOT_IN_TOC;
 186         commanddepth = 0;
 187         htmllabelfirst_ = false;
 188         htmlforcecss_ = false;
 189         htmltitle_ = false;
 190         docbookabstract_ = false;
 191         docbookwrappermergewithprevious_ = false;
 192         docbooksection_ = false;
 193         spellcheck = true;
 194         forcelocal = 0;
 195         itemcommand_ = "item";
 196         toggle_indent = ITOGGLE_DOCUMENT_DEFAULT;
 197         par_group_ = false;
 198 }
 199
 200
 201 bool Layout::read(Lexer & lex, TextClass const & tclass, bool validating)
 202 {
 203         // If this is an empty layout, or if no force local version is set,
 204         // we know that we will not discard the stuff to read
 205         if (forcelocal == 0)
 206                 return readIgnoreForcelocal(lex, tclass, validating);
 207         Layout tmp(*this);
 208         tmp.forcelocal = 0;
 209         bool const ret = tmp.readIgnoreForcelocal(lex, tclass, validating);
 210         // Keep the stuff if
 211         // - the read version is higher
 212         // - both versions are infinity (arbitrary decision)
 213         // - the file did not contain any local version (needed for not
 214         //   skipping user defined local layouts)
 215         if (tmp.forcelocal <= 0 || tmp.forcelocal > forcelocal)
 216                 *this = tmp;
 217         return ret;
 218 }
 219
 220
 221 bool Layout::readIgnoreForcelocal(Lexer & lex, TextClass const & tclass,
 222                                                                   bool validating)
 223 {
 224         // This table is sorted alphabetically [asierra 30March96]
 225         LexerKeyword layoutTags[] = {
 226                 { "addtotoc",       LT_ADDTOTOC },
 227                 { "align",          LT_ALIGN },
 228                 { "alignpossible",  LT_ALIGNPOSSIBLE },
 229                 { "argument",       LT_ARGUMENT },
 230                 { "autonests",      LT_AUTONESTS },
 231                 { "babelpreamble",  LT_BABELPREAMBLE },
 232                 { "bottomsep",      LT_BOTTOMSEP },
 233                 { "category",       LT_CATEGORY },
 234                 { "commanddepth",   LT_COMMANDDEPTH },
 235                 { "copystyle",      LT_COPYSTYLE },
 236                 { "dependson",      LT_DEPENDSON },
 237                 { "docbookabstract",           LT_DOCBOOKABSTRACT },
 238                 { "docbookattr",               LT_DOCBOOKATTR },
 239                 { "docbookforceabstracttag",   LT_DOCBOOKFORCEABSTRACTTAG },
 240                 { "docbookininfo",             LT_DOCBOOKININFO },
 241                 { "docbookinnerattr",          LT_DOCBOOKINNERATTR },
 242                 { "docbookinnertag",           LT_DOCBOOKINNERTAG },
 243                 { "docbookinnertagtype",       LT_DOCBOOKINNERTAGTYPE },
 244                 { "docbookitemattr",           LT_DOCBOOKITEMATTR },
 245                 { "docbookiteminnerattr",      LT_DOCBOOKITEMINNERATTR },
 246                 { "docbookiteminnertag",       LT_DOCBOOKITEMINNERTAG },
 247                 { "docbookiteminnertagtype",   LT_DOCBOOKITEMINNERTAGTYPE },
 248                 { "docbookitemlabelattr",      LT_DOCBOOKITEMLABELATTR },
 249                 { "docbookitemlabeltag",       LT_DOCBOOKITEMLABELTAG },
 250                 { "docbookitemlabeltagtype",   LT_DOCBOOKITEMLABELTAGTYPE },
 251                 { "docbookitemtag",            LT_DOCBOOKITEMTAG },
 252                 { "docbookitemtagtype",        LT_DOCBOOKITEMTAGTYPE },
 253                 { "docbookitemwrapperattr",    LT_DOCBOOKITEMWRAPPERATTR },
 254                 { "docbookitemwrappertag",     LT_DOCBOOKITEMWRAPPERTAG },
 255                 { "docbookitemwrappertagtype", LT_DOCBOOKITEMWRAPPERTAGTYPE },
 256                 { "docbooknofontinside",       LT_DOCBOOKNOFONTINSIDE, },
 257                 { "docbooksection",            LT_DOCBOOKSECTION },
 258                 { "docbooksectiontag",         LT_DOCBOOKSECTIONTAG },
 259                 { "docbooktag",                LT_DOCBOOKTAG },
 260                 { "docbooktagtype",            LT_DOCBOOKTAGTYPE },
 261                 { "docbookwrapperattr",        LT_DOCBOOKWRAPPERATTR },
 262                 { "docbookwrappermergewithprevious", LT_DOCBOOKWRAPPERMERGEWITHPREVIOUS },
 263                 { "docbookwrappertag",         LT_DOCBOOKWRAPPERTAG },
 264                 { "docbookwrappertagtype",     LT_DOCBOOKWRAPPERTAGTYPE },
 265                 { "end",            LT_END },
 266                 { "endlabelstring", LT_ENDLABELSTRING },
 267                 { "endlabeltype",   LT_ENDLABELTYPE },
 268                 { "font",           LT_FONT },
 269                 { "forcelocal",     LT_FORCELOCAL },
 270                 { "freespacing",    LT_FREE_SPACING },
 271                 { "htmlattr",       LT_HTMLATTR },
 272                 { "htmlforcecss",   LT_HTMLFORCECSS },
 273                 { "htmlitem",       LT_HTMLITEM },
 274                 { "htmlitemattr",   LT_HTMLITEMATTR },
 275                 { "htmllabel",      LT_HTMLLABEL },
 276                 { "htmllabelattr",  LT_HTMLLABELATTR },
 277                 { "htmllabelfirst", LT_HTMLLABELFIRST },
 278                 { "htmlpreamble",   LT_HTMLPREAMBLE },
 279                 { "htmlstyle",      LT_HTMLSTYLE },
 280                 { "htmltag",        LT_HTMLTAG },
 281                 { "htmltitle",      LT_HTMLTITLE },
 282                 { "innertag",       LT_INNERTAG },
 283                 { "inpreamble",     LT_INPREAMBLE },
 284                 { "intitle",        LT_INTITLE },
 285                 { "isautonestedby", LT_AUTONESTEDBY },
 286                 { "istoccaption",   LT_ISTOCCAPTION },
 287                 { "itemcommand",    LT_ITEMCOMMAND },
 288                 { "itemsep",        LT_ITEMSEP },
 289                 { "itemtag",        LT_ITEMTAG },
 290                 { "keepempty",      LT_KEEPEMPTY },
 291                 { "labelbottomsep", LT_LABEL_BOTTOMSEP },
 292                 { "labelcounter",   LT_LABELCOUNTER },
 293                 { "labelfont",      LT_LABELFONT },
 294                 { "labelindent",    LT_LABELINDENT },
 295                 { "labelsep",       LT_LABELSEP },
 296                 { "labelstring",    LT_LABELSTRING },
 297                 { "labelstringappendix", LT_LABELSTRING_APPENDIX },
 298                 { "labeltag",       LT_LABELTAG },
 299                 { "labeltype",      LT_LABELTYPE },
 300                 { "langpreamble",   LT_LANGPREAMBLE },
 301                 { "latexname",      LT_LATEXNAME },
 302                 { "latexparam",     LT_LATEXPARAM },
 303                 { "latextype",      LT_LATEXTYPE },
 304                 { "leftdelim",      LT_LEFTDELIM },
 305                 { "leftmargin",     LT_LEFTMARGIN },
 306                 { "margin",         LT_MARGIN },
 307                 { "needcprotect",    LT_NEED_CPROTECT },
 308                 { "needmboxprotect", LT_NEED_MBOXPROTECT },
 309                 { "needprotect",    LT_NEED_PROTECT },
 310                 { "newline",        LT_NEWLINE },
 311                 { "nextnoindent",   LT_NEXTNOINDENT },
 312                 { "obsoletedby",    LT_OBSOLETEDBY },
 313                 { "paragraphgroup", LT_PAR_GROUP },
 314                 { "parbreakisnewline", LT_PARBREAK_IS_NEWLINE },
 315                 { "parindent",      LT_PARINDENT },
 316                 { "parsep",         LT_PARSEP },
 317                 { "parskip",        LT_PARSKIP },
 318                 { "passthru",       LT_PASS_THRU },
 319                 { "passthruchars",  LT_PASS_THRU_CHARS },
 320                 { "preamble",       LT_PREAMBLE },
 321                 { "refprefix",      LT_REFPREFIX },
 322                 { "requires",       LT_REQUIRES },
 323                 { "resetargs",      LT_RESETARGS },
 324                 { "resumecounter",  LT_RESUMECOUNTER },
 325                 { "rightdelim",     LT_RIGHTDELIM },
 326                 { "rightmargin",    LT_RIGHTMARGIN },
 327                 { "spacing",        LT_SPACING },
 328                 { "spellcheck",     LT_SPELLCHECK },
 329                 { "stepparentcounter",  LT_STEPPARENTCOUNTER },
 330                 { "textfont",       LT_TEXTFONT },
 331                 { "toclevel",       LT_TOCLEVEL },
 332                 { "toggleindent",   LT_TOGGLE_INDENT },
 333                 { "topsep",         LT_TOPSEP }
 334         };
 335
 336         bool error = false;
 337         bool finished = false;
 338         lex.pushTable(layoutTags);
 339
 340         // parse style section
 341         while (!finished && lex.isOK() && !error) {
 342                 int le = lex.lex();
 343                 // See comment in LyXRC.cpp.
 344                 switch (le) {
 345                 case Lexer::LEX_FEOF:
 346                         continue;
 347
 348                 case Lexer::LEX_UNDEF:
 349                         // parse error
 350                         lex.printError("Unknown layout tag `$$Token'");
 351                         error = true;
 352                         continue;
 353
 354                 default:
 355                         break;
 356                 }
 357                 switch (static_cast<LayoutTags>(le)) {
 358                 case LT_END:
 359                         finished = true;
 360                         break;
 361
 362                 case LT_CATEGORY:
 363                         lex >> category_;
 364                         break;
 365
 366                 case LT_COPYSTYLE: {
 367                         docstring style;
 368                         lex >> style;
 369                         style = subst(style, '_', ' ');
 370
 371                         if (tclass.hasLayout(style)) {
 372                                 docstring const tmpname = name_;
 373                                 this->operator=(tclass[style]);
 374                                 name_ = tmpname;
 375                         } else {
 376                                 LYXERR0("Cannot copy unknown style `"
 377                                         << style << "'\n"
 378                                         << "All layouts so far:");
 379                                 DocumentClass::const_iterator lit = tclass.begin();
 380                                 DocumentClass::const_iterator len = tclass.end();
 381                                 for (; lit != len; ++lit)
 382                                         LYXERR0(lit->name());
 383                         }
 384                         break;
 385                         }
 386
 387                 case LT_OBSOLETEDBY: {
 388                         docstring style;
 389                         lex >> style;
 390                         style = subst(style, '_', ' ');
 391
 392                         if (tclass.hasLayout(style)) {
 393                                 docstring const tmpname = name_;
 394                                 this->operator=(tclass[style]);
 395                                 name_ = tmpname;
 396                                 if (obsoleted_by().empty())
 397                                         obsoleted_by_ = style;
 398                         } else {
 399                                 LYXERR0("Cannot replace with unknown style `"
 400                                         << style << '\'');
 401
 402                                 //lex.printError("Cannot replace with"
 403                                 //               " unknown style "
 404                                 //               "`$$Token'");
 405                         }
 406                         break;
 407                 }
 408
 409                 case LT_DEPENDSON:
 410                         lex >> depends_on_;
 411                         depends_on_ = subst(depends_on_, '_', ' ');
 412                         break;
 413
 414                 case LT_MARGIN:
 415                         readMargin(lex);
 416                         break;
 417
 418                 case LT_LATEXTYPE:
 419                         readLatexType(lex);
 420                         break;
 421
 422                 case LT_INTITLE:
 423                         lex >> intitle;
 424                         break;
 425
 426                 case LT_INPREAMBLE:
 427                         lex >> inpreamble;
 428                         break;
 429
 430                 case LT_TOCLEVEL:
 431                         lex >> toclevel;
 432                         break;
 433
 434                 case LT_RESETARGS:
 435                         bool reset;
 436                         lex >> reset;
 437                         if (reset) {
 438                                 latexargs_.clear();
 439                                 itemargs_.clear();
 440                                 postcommandargs_.clear();
 441                                 listpreamble_.clear();
 442                         }
 443                         break;
 444
 445                 case LT_RESUMECOUNTER:
 446                         lex >> resumecounter;
 447                         break;
 448
 449                 case LT_STEPPARENTCOUNTER:
 450                         lex >> stepparentcounter;
 451                         break;
 452
 453                 case LT_ARGUMENT:
 454                         readArgument(lex, validating);
 455                         break;
 456
 457                 case LT_NEED_PROTECT:
 458                         lex >> needprotect;
 459                         break;
 460
 461                 case LT_NEED_CPROTECT:
 462                         lex >> needcprotect;
 463                         break;
 464
 465                 case LT_NEED_MBOXPROTECT:
 466                         lex >> needmboxprotect;
 467                         break;
 468
 469                 case LT_KEEPEMPTY:
 470                         lex >> keepempty;
 471                         break;
 472
 473                 case LT_FONT:
 474                         font = lyxRead(lex, font);
 475                         labelfont = font;
 476                         break;
 477
 478                 case LT_TEXTFONT:
 479                         font = lyxRead(lex, font);
 480                         break;
 481
 482                 case LT_LABELFONT:
 483                         labelfont = lyxRead(lex, labelfont);
 484                         break;
 485
 486                 case LT_NEXTNOINDENT:
 487                         lex >> nextnoindent;
 488                         break;
 489
 490                 case LT_TOGGLE_INDENT: {
 491                         string tog;
 492                         lex >> tog;
 493                         tog = support::ascii_lowercase(tog);
 494                         if (tog == "always")
 495                                 toggle_indent = ITOGGLE_ALWAYS;
 496                         else if (tog == "never")
 497                                 toggle_indent = ITOGGLE_NEVER;
 498                         else
 499                                 toggle_indent = ITOGGLE_DOCUMENT_DEFAULT;
 500                         break;
 501                 }
 502
 503                 case LT_COMMANDDEPTH:
 504                         lex >> commanddepth;
 505                         break;
 506
 507                 case LT_LATEXNAME:
 508                         lex >> latexname_;
 509                         break;
 510
 511                 case LT_LATEXPARAM:
 512                         lex >> latexparam_;
 513                         latexparam_ = subst(latexparam_, "&quot;", "\"");
 514                         break;
 515
 516                 case LT_LEFTDELIM:
 517                         lex >> leftdelim_;
 518                         leftdelim_ = support::subst(leftdelim_, from_ascii("<br/>"),
 519                                                     from_ascii("\n"));
 520                         break;
 521
 522                 case LT_RIGHTDELIM:
 523                         lex >> rightdelim_;
 524                         rightdelim_ = support::subst(rightdelim_, from_ascii("<br/>"),
 525                                                      from_ascii("\n"));
 526                         break;
 527
 528                 case LT_INNERTAG:
 529                         lex >> innertag_;
 530                         break;
 531
 532                 case LT_LABELTAG:
 533                         lex >> labeltag_;
 534                         break;
 535
 536                 case LT_ITEMTAG:
 537                         lex >> itemtag_;
 538                         break;
 539
 540                 case LT_ITEMCOMMAND:
 541                         lex >> itemcommand_;
 542                         break;
 543
 544                 case LT_PREAMBLE:
 545                         preamble_ = lex.getLongString(from_ascii("EndPreamble"));
 546                         break;
 547
 548                 case LT_LANGPREAMBLE:
 549                         langpreamble_ = lex.getLongString(from_ascii("EndLangPreamble"));
 550                         break;
 551
 552                 case LT_BABELPREAMBLE:
 553                         babelpreamble_ = lex.getLongString(from_ascii("EndBabelPreamble"));
 554                         break;
 555
 556                 case LT_LABELTYPE:
 557                         readLabelType(lex);
 558                         break;
 559
 560                 case LT_ENDLABELTYPE:
 561                         readEndLabelType(lex);
 562                         break;
 563
 564                 case LT_LEFTMARGIN:
 565                         lex >> leftmargin;
 566                         break;
 567
 568                 case LT_RIGHTMARGIN:
 569                         lex >> rightmargin;
 570                         break;
 571
 572                 case LT_LABELINDENT:
 573                         lex >> labelindent;
 574                         break;
 575
 576                 case LT_PARINDENT:
 577                         lex >> parindent;
 578                         break;
 579
 580                 case LT_PARSKIP:
 581                         lex >> parskip;
 582                         break;
 583
 584                 case LT_ITEMSEP:
 585                         lex >> itemsep;
 586                         break;
 587
 588                 case LT_TOPSEP:
 589                         lex >> topsep;
 590                         break;
 591
 592                 case LT_BOTTOMSEP:
 593                         lex >> bottomsep;
 594                         break;
 595
 596                 case LT_LABEL_BOTTOMSEP:
 597                         lex >> labelbottomsep;
 598                         break;
 599
 600                 case LT_LABELSEP:
 601                         lex >> labelsep;
 602                         labelsep = subst(labelsep, 'x', ' ');
 603                         break;
 604
 605                 case LT_PARSEP:
 606                         lex >> parsep;
 607                         break;
 608
 609                 case LT_NEWLINE:
 610                         lex >> newline_allowed;
 611                         break;
 612
 613                 case LT_ALIGN:
 614                         readAlign(lex);
 615                         break;
 616
 617                 case LT_ALIGNPOSSIBLE:
 618                         readAlignPossible(lex);
 619                         break;
 620
 621                 case LT_LABELSTRING:
 622                         // FIXME: this means LT_LABELSTRING_APPENDIX may only
 623                         // occur after LT_LABELSTRING
 624                         lex >> labelstring_;
 625                         labelstring_appendix_ = labelstring_;
 626                         break;
 627
 628                 case LT_ENDLABELSTRING:
 629                         lex >> endlabelstring_;
 630                         break;
 631
 632                 case LT_LABELSTRING_APPENDIX:
 633                         lex >> labelstring_appendix_;
 634                         break;
 635
 636                 case LT_LABELCOUNTER:
 637                         lex >> counter;
 638                         break;
 639
 640                 case LT_PAR_GROUP:
 641                         lex >> par_group_;
 642                         break;
 643
 644                 case LT_FREE_SPACING:
 645                         lex >> free_spacing;
 646                         break;
 647
 648                 case LT_PASS_THRU:
 649                         lex >> pass_thru;
 650                         break;
 651
 652                 case LT_PASS_THRU_CHARS:
 653                         lex >> pass_thru_chars;
 654                         break;
 655
 656                 case LT_PARBREAK_IS_NEWLINE:
 657                         lex >> parbreak_is_newline;
 658                         break;
 659
 660                 case LT_SPACING:
 661                         readSpacing(lex);
 662                         break;
 663
 664                 case LT_REQUIRES: {
 665                         lex.eatLine();
 666                         vector<string> const req =
 667                                 getVectorFromString(lex.getString(true));
 668                         required_.insert(req.begin(), req.end());
 669                         break;
 670                 }
 671
 672                 case LT_AUTONESTS: {
 673                         docstring autonest = lex.getLongString(from_ascii("EndAutoNests"));
 674                         autonest = subst(autonest, from_ascii("\n"), docstring());
 675                         autonest = subst(autonest, from_ascii("\t"), docstring());
 676                         autonest = subst(autonest, from_ascii("\""), docstring());
 677                         autonest = subst(autonest, '_', ' ');
 678                         vector<docstring> const autonests =
 679                                 getVectorFromString(autonest, from_ascii(","), false, true);
 680                         autonests_.insert(autonests.begin(), autonests.end());
 681                         break;
 682                 }
 683
 684                 case LT_AUTONESTEDBY: {
 685                         docstring autonest = lex.getLongString(from_ascii("EndIsAutoNestedBy"));
 686                         autonest = subst(autonest, from_ascii("\n"), docstring());
 687                         autonest = subst(autonest, from_ascii("\t"), docstring());
 688                         autonest = subst(autonest, from_ascii("\""), docstring());
 689                         autonest = subst(autonest, '_', ' ');
 690                         vector<docstring> const autonests =
 691                                 getVectorFromString(autonest, from_ascii(","), false, true);
 692                         autonested_by_.insert(autonests.begin(), autonests.end());
 693                         break;
 694                 }
 695
 696                 case LT_REFPREFIX: {
 697                         docstring arg;
 698                         lex >> arg;
 699                         if (arg == "OFF")
 700                                 refprefix.clear();
 701                         else
 702                                 refprefix = arg;
 703                         break;
 704                 }
 705
 706                 case LT_HTMLTAG:
 707                         lex >> htmltag_;
 708                         break;
 709
 710                 case LT_HTMLATTR:
 711                         lex >> htmlattr_;
 712                         break;
 713
 714                 case LT_HTMLITEM:
 715                         lex >> htmlitemtag_;
 716                         break;
 717
 718                 case LT_HTMLITEMATTR:
 719                         lex >> htmlitemattr_;
 720                         break;
 721
 722                 case LT_HTMLLABEL:
 723                         lex >> htmllabeltag_;
 724                         break;
 725
 726                 case LT_HTMLLABELATTR:
 727                         lex >> htmllabelattr_;
 728                         break;
 729
 730                 case LT_HTMLLABELFIRST:
 731                         lex >> htmllabelfirst_;
 732                         break;
 733
 734                 case LT_HTMLSTYLE:
 735                         htmlstyle_ = lex.getLongString(from_ascii("EndHTMLStyle"));
 736                         break;
 737
 738                 case LT_HTMLFORCECSS:
 739                         lex >> htmlforcecss_;
 740                         break;
 741
 742                 case LT_HTMLPREAMBLE:
 743                         htmlpreamble_ = lex.getLongString(from_ascii("EndPreamble"));
 744                         break;
 745
 746                 case LT_HTMLTITLE:
 747                         lex >> htmltitle_;
 748                         break;
 749
 750                 case LT_DOCBOOKTAG:
 751                         lex >> docbooktag_;
 752                         break;
 753
 754                 case LT_DOCBOOKATTR:
 755                         lex >> docbookattr_;
 756                         break;
 757
 758                 case LT_DOCBOOKTAGTYPE:
 759                         lex >> docbooktagtype_;
 760                         break;
 761
 762                 case LT_DOCBOOKINNERTAG:
 763                         lex >> docbookinnertag_;
 764                         break;
 765
 766                 case LT_DOCBOOKINNERATTR:
 767                         lex >> docbookinnerattr_;
 768                         break;
 769
 770                 case LT_DOCBOOKINNERTAGTYPE:
 771                         lex >> docbookinnertagtype_;
 772                         break;
 773
 774                 case LT_DOCBOOKFORCEABSTRACTTAG:
 775                         lex >> docbookforceabstracttag_;
 776                         break;
 777
 778                 case LT_DOCBOOKININFO:
 779                         lex >> docbookininfo_;
 780                         break;
 781
 782                 case LT_DOCBOOKABSTRACT:
 783                         lex >> docbookabstract_;
 784                         break;
 785
 786                 case LT_DOCBOOKWRAPPERTAG:
 787                         lex >> docbookwrappertag_;
 788                         break;
 789
 790                 case LT_DOCBOOKWRAPPERATTR:
 791                         lex >> docbookwrapperattr_;
 792                         break;
 793
 794                 case LT_DOCBOOKWRAPPERTAGTYPE:
 795                         lex >> docbookwrappertagtype_;
 796                         break;
 797
 798                 case LT_DOCBOOKWRAPPERMERGEWITHPREVIOUS:
 799                         lex >> docbookwrappermergewithprevious_;
 800                         break;
 801
 802                 case LT_DOCBOOKSECTION:
 803                         lex >> docbooksection_;
 804                         break;
 805
 806                 case LT_DOCBOOKSECTIONTAG:
 807                         lex >> docbooksectiontag_;
 808                         break;
 809
 810                 case LT_DOCBOOKITEMWRAPPERTAG:
 811                         lex >> docbookitemwrappertag_;
 812                         break;
 813
 814                 case LT_DOCBOOKITEMWRAPPERATTR:
 815                         lex >> docbookitemwrapperattr_;
 816                         break;
 817
 818                 case LT_DOCBOOKITEMWRAPPERTAGTYPE:
 819                         lex >> docbookitemwrappertagtype_;
 820                         break;
 821
 822                 case LT_DOCBOOKITEMTAG:
 823                         lex >> docbookitemtag_;
 824                         break;
 825
 826                 case LT_DOCBOOKITEMATTR:
 827                         lex >> docbookitemattr_;
 828                         break;
 829
 830                 case LT_DOCBOOKITEMTAGTYPE:
 831                         lex >> docbookitemtagtype_;
 832                         break;
 833
 834                 case LT_DOCBOOKITEMLABELTAG:
 835                         lex >> docbookitemlabeltag_;
 836                         break;
 837
 838                 case LT_DOCBOOKITEMLABELATTR:
 839                         lex >> docbookitemlabelattr_;
 840                         break;
 841
 842                 case LT_DOCBOOKITEMLABELTAGTYPE:
 843                         lex >> docbookitemlabeltagtype_;
 844                         break;
 845
 846                 case LT_DOCBOOKITEMINNERTAG:
 847                         lex >> docbookiteminnertag_;
 848                         break;
 849
 850                 case LT_DOCBOOKITEMINNERATTR:
 851                         lex >> docbookiteminnerattr_;
 852                         break;
 853
 854                 case LT_DOCBOOKITEMINNERTAGTYPE:
 855                         lex >> docbookiteminnertagtype_;
 856                         break;
 857
 858         case LT_DOCBOOKNOFONTINSIDE:
 859             lex >> docbooknofontinside_;
 860             break;
 861
 862                 case LT_SPELLCHECK:
 863                         lex >> spellcheck;
 864                         break;
 865
 866                 case LT_FORCELOCAL:
 867                         lex >> forcelocal;
 868                         break;
 869
 870                 case LT_ADDTOTOC:
 871                         lex >> toc_type_;
 872                         add_to_toc_ = !toc_type_.empty();
 873                         break;
 874
 875                 case LT_ISTOCCAPTION:
 876                         lex >> is_toc_caption_;
 877                         break;
 878
 879                 }
 880         }
 881         lex.popTable();
 882         // make sure we only have inpreamble = true for commands
 883         if (inpreamble && latextype != LATEX_COMMAND && latextype != LATEX_PARAGRAPH) {
 884                 LYXERR0("InPreamble not permitted except with command and paragraph layouts.");
 885                 LYXERR0("Layout name: " << name());
 886                 inpreamble = false;
 887         }
 888
 889         return finished && !error;
 890 }
 891
 892
 893 enum {
 894         AT_BLOCK = 1,
 895         AT_LEFT,
 896         AT_RIGHT,
 897         AT_CENTER,
 898         AT_LAYOUT
 899 };
 900
 901
 902 LexerKeyword alignTags[] = {
 903         { "block",  AT_BLOCK },
 904         { "center", AT_CENTER },
 905         { "layout", AT_LAYOUT },
 906         { "left",   AT_LEFT },
 907         { "right",  AT_RIGHT }
 908 };
 909
 910
 911 void Layout::readAlign(Lexer & lex)
 912 {
 913         PushPopHelper pph(lex, alignTags);
 914         int le = lex.lex();
 915         switch (le) {
 916         case Lexer::LEX_UNDEF:
 917                 lex.printError("Unknown alignment `$$Token'");
 918                 return;
 919         default: break;
 920         };
 921         switch (le) {
 922         case AT_BLOCK:
 923                 align = LYX_ALIGN_BLOCK;
 924                 break;
 925         case AT_LEFT:
 926                 align = LYX_ALIGN_LEFT;
 927                 break;
 928         case AT_RIGHT:
 929                 align = LYX_ALIGN_RIGHT;
 930                 break;
 931         case AT_CENTER:
 932                 align = LYX_ALIGN_CENTER;
 933                 break;
 934         case AT_LAYOUT:
 935                 align = LYX_ALIGN_LAYOUT;
 936                 break;
 937         }
 938 }
 939
 940
 941 void Layout::readAlignPossible(Lexer & lex)
 942 {
 943         lex.pushTable(alignTags);
 944         alignpossible = LYX_ALIGN_NONE | LYX_ALIGN_LAYOUT;
 945         int lineno = lex.lineNumber();
 946         do {
 947                 int le = lex.lex();
 948                 switch (le) {
 949                 case Lexer::LEX_UNDEF:
 950                         lex.printError("Unknown alignment `$$Token'");
 951                         continue;
 952                 default: break;
 953                 };
 954                 switch (le) {
 955                 case AT_BLOCK:
 956                         alignpossible |= LYX_ALIGN_BLOCK;
 957                         break;
 958                 case AT_LEFT:
 959                         alignpossible |= LYX_ALIGN_LEFT;
 960                         break;
 961                 case AT_RIGHT:
 962                         alignpossible |= LYX_ALIGN_RIGHT;
 963                         break;
 964                 case AT_CENTER:
 965                         alignpossible |= LYX_ALIGN_CENTER;
 966                         break;
 967                 case AT_LAYOUT:
 968                         alignpossible |= LYX_ALIGN_LAYOUT;
 969                         break;
 970                 }
 971         } while (lineno == lex.lineNumber());
 972         lex.popTable();
 973 }
 974
 975
 976 void Layout::readLabelType(Lexer & lex)
 977 {
 978         enum {
 979                 LA_NO_LABEL = 1,
 980                 LA_MANUAL,
 981                 LA_ABOVE,
 982                 LA_CENTERED,
 983                 LA_STATIC,
 984                 LA_SENSITIVE,
 985                 LA_ENUMERATE,
 986                 LA_ITEMIZE,
 987                 LA_BIBLIO
 988         };
 989
 990
 991         LexerKeyword labelTypeTags[] = {
 992           { "above",        LA_ABOVE },
 993                 { "bibliography", LA_BIBLIO },
 994                 { "centered",     LA_CENTERED },
 995                 { "enumerate",    LA_ENUMERATE },
 996                 { "itemize",      LA_ITEMIZE },
 997                 { "manual",       LA_MANUAL },
 998                 { "no_label",     LA_NO_LABEL },
 999                 { "sensitive",    LA_SENSITIVE },
1000                 { "static",       LA_STATIC }
1001         };
1002
1003         PushPopHelper pph(lex, labelTypeTags);
1004         int le = lex.lex();
1005         switch (le) {
1006         case Lexer::LEX_UNDEF:
1007                 lex.printError("Unknown labeltype tag `$$Token'");
1008                 return;
1009         default: break;
1010         }
1011         switch (le) {
1012         case LA_NO_LABEL:
1013                 labeltype = LABEL_NO_LABEL;
1014                 break;
1015         case LA_MANUAL:
1016                 labeltype = LABEL_MANUAL;
1017                 break;
1018         case LA_ABOVE:
1019                 labeltype = LABEL_ABOVE;
1020                 break;
1021         case LA_CENTERED:
1022                 labeltype = LABEL_CENTERED;
1023                 break;
1024         case LA_STATIC:
1025                 labeltype = LABEL_STATIC;
1026                 break;
1027         case LA_SENSITIVE:
1028                 labeltype = LABEL_SENSITIVE;
1029                 break;
1030         case LA_ENUMERATE:
1031                 labeltype = LABEL_ENUMERATE;
1032                 break;
1033         case LA_ITEMIZE:
1034                 labeltype = LABEL_ITEMIZE;
1035                 break;
1036         case LA_BIBLIO:
1037                 labeltype = LABEL_BIBLIO;
1038                 break;
1039         }
1040 }
1041
1042
1043 void Layout::readEndLabelType(Lexer & lex)
1044 {
1045         // this should be const, but can't be because
1046         // of PushPopHelper.
1047         static LexerKeyword endlabelTypeTags[] = {
1048                 { "box",              END_LABEL_BOX },
1049                 { "filled_box", END_LABEL_FILLED_BOX },
1050                 { "no_label",     END_LABEL_NO_LABEL },
1051                 { "static",     END_LABEL_STATIC }
1052         };
1053
1054         PushPopHelper pph(lex, endlabelTypeTags);
1055         int le = lex.lex();
1056         switch (le) {
1057         case Lexer::LEX_UNDEF:
1058                 lex.printError("Unknown labeltype tag `$$Token'");
1059                 break;
1060         case END_LABEL_STATIC:
1061         case END_LABEL_BOX:
1062         case END_LABEL_FILLED_BOX:
1063         case END_LABEL_NO_LABEL:
1064                 endlabeltype = static_cast<EndLabelType>(le);
1065                 break;
1066         default:
1067                 LYXERR0("Unhandled value " << le);
1068                 break;
1069         }
1070 }
1071
1072
1073 void Layout::readMargin(Lexer & lex)
1074 {
1075         LexerKeyword marginTags[] = {
1076                 { "dynamic",           MARGIN_DYNAMIC },
1077                 { "first_dynamic",     MARGIN_FIRST_DYNAMIC },
1078                 { "manual",            MARGIN_MANUAL },
1079                 { "right_address_box", MARGIN_RIGHT_ADDRESS_BOX },
1080                 { "static",            MARGIN_STATIC }
1081         };
1082
1083         PushPopHelper pph(lex, marginTags);
1084
1085         int le = lex.lex();
1086         switch (le) {
1087         case Lexer::LEX_UNDEF:
1088                 lex.printError("Unknown margin type tag `$$Token'");
1089                 return;
1090         case MARGIN_STATIC:
1091         case MARGIN_MANUAL:
1092         case MARGIN_DYNAMIC:
1093         case MARGIN_FIRST_DYNAMIC:
1094         case MARGIN_RIGHT_ADDRESS_BOX:
1095                 margintype = static_cast<MarginType>(le);
1096                 break;
1097         default:
1098                 LYXERR0("Unhandled value " << le);
1099                 break;
1100         }
1101 }
1102
1103
1104 void Layout::readLatexType(Lexer & lex)
1105 {
1106         LexerKeyword latexTypeTags[] = {
1107                 { "bib_environment",  LATEX_BIB_ENVIRONMENT },
1108                 { "command",          LATEX_COMMAND },
1109                 { "environment",      LATEX_ENVIRONMENT },
1110                 { "item_environment", LATEX_ITEM_ENVIRONMENT },
1111                 { "list_environment", LATEX_LIST_ENVIRONMENT },
1112                 { "paragraph",        LATEX_PARAGRAPH }
1113         };
1114
1115         PushPopHelper pph(lex, latexTypeTags);
1116         int le = lex.lex();
1117         switch (le) {
1118         case Lexer::LEX_UNDEF:
1119                 lex.printError("Unknown latextype tag `$$Token'");
1120                 return;
1121         case LATEX_PARAGRAPH:
1122         case LATEX_COMMAND:
1123         case LATEX_ITEM_ENVIRONMENT:
1124         case LATEX_LIST_ENVIRONMENT:
1125                 latextype = static_cast<LatexType>(le);
1126                 break;
1127         case LATEX_ENVIRONMENT:
1128         case LATEX_BIB_ENVIRONMENT:
1129                 latextype = static_cast<LatexType>(le);
1130                 par_group_ = true;
1131                 break;
1132         default:
1133                 LYXERR0("Unhandled value " << le);
1134                 break;
1135         }
1136 }
1137
1138
1139 void Layout::readSpacing(Lexer & lex)
1140 {
1141         enum {
1142                 ST_SPACING_SINGLE = 1,
1143                 ST_SPACING_ONEHALF,
1144                 ST_SPACING_DOUBLE,
1145                 ST_OTHER
1146         };
1147
1148         LexerKeyword spacingTags[] = {
1149                 {"double",  ST_SPACING_DOUBLE },
1150                 {"onehalf", ST_SPACING_ONEHALF },
1151                 {"other",   ST_OTHER },
1152                 {"single",  ST_SPACING_SINGLE }
1153         };
1154
1155         PushPopHelper pph(lex, spacingTags);
1156         int le = lex.lex();
1157         switch (le) {
1158         case Lexer::LEX_UNDEF:
1159                 lex.printError("Unknown spacing token `$$Token'");
1160                 return;
1161         default: break;
1162         }
1163         switch (le) {
1164         case ST_SPACING_SINGLE:
1165                 spacing.set(Spacing::Single);
1166                 break;
1167         case ST_SPACING_ONEHALF:
1168                 spacing.set(Spacing::Onehalf);
1169                 break;
1170         case ST_SPACING_DOUBLE:
1171                 spacing.set(Spacing::Double);
1172                 break;
1173         case ST_OTHER:
1174                 lex.next();
1175                 spacing.set(Spacing::Other, lex.getString());
1176                 break;
1177         }
1178 }
1179
1180
1181 void Layout::readArgument(Lexer & lex, bool validating)
1182 {
1183         if (!lex.next()) {
1184                 LYXERR0("Unable to read argument ID!");
1185                 return;
1186         }
1187         string const id = lex.getString();
1188
1189         bool const itemarg = prefixIs(id, "item:");
1190         bool const postcmd = prefixIs(id, "post:");
1191         bool const listpreamble = prefixIs(id, "listpreamble:");
1192
1193         LaTeXArgMap & lam = itemarg ? itemargs_ :
1194                         (postcmd ? postcommandargs_ :
1195                         (listpreamble ? listpreamble_ :
1196                         latexargs_));
1197         latexarg & arg = lam[id];
1198
1199         if (listpreamble)
1200                 // list preamble has no delimiters by default
1201                 arg.nodelims = true;
1202
1203         bool error = false;
1204         bool finished = false;
1205         while (!finished && lex.isOK() && !error) {
1206                 lex.next();
1207                 string const tok = ascii_lowercase(lex.getString());
1208
1209                 if (tok.empty()) {
1210                         continue;
1211                 } else if (tok == "endargument") {
1212                         finished = true;
1213                 } else if (tok == "labelstring") {
1214                         lex.next();
1215                         arg.labelstring = lex.getDocString();
1216                 } else if (tok == "menustring") {
1217                         lex.next();
1218                         arg.menustring = lex.getDocString();
1219                 } else if (tok == "mandatory") {
1220                         lex.next();
1221                         arg.mandatory = lex.getBool();
1222                 } else if (tok == "autoinsert") {
1223                         lex.next();
1224                         arg.autoinsert = lex.getBool();
1225                 } else if (tok == "insertcotext") {
1226                         lex.next();
1227                         arg.insertcotext = lex.getBool();
1228                 } else if (tok == "leftdelim") {
1229                         lex.next();
1230                         arg.ldelim = lex.getDocString();
1231                         arg.ldelim = support::subst(arg.ldelim, from_ascii("<br/>"),
1232                                                     from_ascii("\n"));
1233                 } else if (tok == "rightdelim") {
1234                         lex.next();
1235                         arg.rdelim = lex.getDocString();
1236                         arg.rdelim = support::subst(arg.rdelim, from_ascii("<br/>"),
1237                                                     from_ascii("\n"));
1238                 } else if (tok == "defaultarg") {
1239                         lex.next();
1240                         arg.defaultarg = lex.getDocString();
1241                 } else if (tok == "presetarg") {
1242                         lex.next();
1243                         arg.presetarg = lex.getDocString();
1244                 } else if (tok == "tooltip") {
1245                         lex.next();
1246                         arg.tooltip = lex.getDocString();
1247                 } else if (tok == "requires") {
1248                         lex.next();
1249                         arg.required = lex.getString();
1250                 } else if (tok == "decoration") {
1251                         lex.next();
1252                         arg.decoration = lex.getString();
1253                 } else if (tok == "newlinecmd") {
1254                         lex.next();
1255                         arg.newlinecmd = lex.getString();
1256                 } else if (tok == "font") {
1257                         arg.font = lyxRead(lex, arg.font);
1258                 } else if (tok == "labelfont") {
1259                         arg.labelfont = lyxRead(lex, arg.labelfont);
1260                 } else if (tok == "passthruchars") {
1261                         lex.next();
1262                         arg.pass_thru_chars = lex.getDocString();
1263                 } else if (tok == "passthru") {
1264                         lex.next();
1265                         docstring value = lex.getDocString();
1266                         if (value == "true" || value == "1")
1267                                 arg.passthru = PT_TRUE;
1268                         else if (value == "false" || value == "0")
1269                                 arg.passthru = PT_FALSE;
1270                         else
1271                                 arg.passthru = PT_INHERITED;
1272                 } else if (tok == "istoccaption") {
1273                         lex.next();
1274                         arg.is_toc_caption = lex.getBool();
1275                 } else if (tok == "freespacing") {
1276                         lex.next();
1277                         arg.free_spacing = lex.getBool();
1278                 } else if (tok == "docbooktag") {
1279                         lex.next();
1280                         arg.docbooktag = lex.getDocString();
1281                 } else if (tok == "docbookattr") {
1282                         lex.next();
1283                         arg.docbookattr = lex.getDocString();
1284                 } else if (tok == "docbooktagtype") {
1285                         lex.next();
1286                         arg.docbooktagtype = lex.getDocString();
1287                 } else if (tok == "docbookargumentaftermaintag") {
1288                         lex.next();
1289                         arg.docbookargumentaftermaintag = lex.getBool();
1290                 } else if (tok == "docbookargumentbeforemaintag") {
1291                         lex.next();
1292                         arg.docbookargumentbeforemaintag = lex.getBool();
1293                 } else {
1294                         lex.printError("Unknown tag");
1295                         error = true;
1296                 }
1297         }
1298         if (!validating && arg.labelstring.empty()) {
1299                 LYXERR0("Incomplete Argument definition!");
1300                 // remove invalid definition
1301                 lam.erase(id);
1302         }
1303 }
1304
1305
1306 void writeArgument(ostream & os, string const & id, Layout::latexarg const & arg)
1307 {
1308         os << "\tArgument " << id << '\n';
1309         if (!arg.labelstring.empty())
1310                 os << "\t\tLabelString \"" << to_utf8(arg.labelstring) << "\"\n";
1311         if (!arg.menustring.empty())
1312                 os << "\t\tMenuString \"" << to_utf8(arg.menustring) << "\"\n";
1313         if (arg.mandatory)
1314                 os << "\t\tMandatory " << arg.mandatory << '\n';
1315         if (arg.autoinsert)
1316                 os << "\t\tAutoinsert " << arg.autoinsert << '\n';
1317         if (arg.insertcotext)
1318                 os << "\t\tInsertCotext " << arg.insertcotext << '\n';
1319         if (!arg.ldelim.empty())
1320                 os << "\t\tLeftDelim \""
1321                    << to_utf8(subst(arg.ldelim, from_ascii("\n"), from_ascii("<br/>")))
1322                    << "\"\n";
1323         if (!arg.rdelim.empty())
1324                 os << "\t\tRightDelim \""
1325                    << to_utf8(subst(arg.rdelim, from_ascii("\n"), from_ascii("<br/>")))
1326                    << "\"\n";
1327         if (!arg.defaultarg.empty())
1328                 os << "\t\tDefaultArg \"" << to_utf8(arg.defaultarg) << "\"\n";
1329         if (!arg.presetarg.empty())
1330                 os << "\t\tPresetArg \"" << to_utf8(arg.presetarg) << "\"\n";
1331         if (!arg.tooltip.empty())
1332                 os << "\t\tToolTip \"" << to_utf8(arg.tooltip) << "\"\n";
1333         if (!arg.required.empty())
1334                 os << "\t\tRequires \"" << arg.required << "\"\n";
1335         if (!arg.decoration.empty())
1336                 os << "\t\tDecoration \"" << arg.decoration << "\"\n";
1337         if (!arg.newlinecmd.empty())
1338                 os << "\t\tNewlineCmd \"" << arg.newlinecmd << "\"\n";
1339         if (arg.font != inherit_font)
1340                 lyxWrite(os, arg.font, "Font", 2);
1341         if (arg.labelfont != inherit_font)
1342                 lyxWrite(os, arg.labelfont, "LabelFont", 2);
1343         switch (arg.passthru) {
1344                 case PT_TRUE:
1345                         os << "\t\tPassThru true\n";
1346                         break;
1347                 case PT_FALSE:
1348                         os << "\t\tPassThru false\n";
1349                         break;
1350                 case PT_INHERITED:
1351                         os << "\t\tPassThru inherited\n";
1352                         break;
1353         }
1354         if (!arg.pass_thru_chars.empty())
1355                 os << "\t\tPassThruChars \"" << to_utf8(arg.pass_thru_chars) << "\"\n";
1356         if (arg.free_spacing)
1357                 os << "\t\tFreeSpacing " << arg.free_spacing << "\n";
1358         os << "\tEndArgument\n";
1359 }
1360
1361
1362 void Layout::write(ostream & os) const
1363 {
1364         os << "Style \"" << to_utf8(name_) << "\"\n";
1365         if (!category_.empty() && obsoleted_by_.empty())
1366                 os << "\tCategory \"" << to_utf8(category_) << "\"\n";
1367         // Can't deduce Copystyle here :-(
1368         if (!obsoleted_by_.empty()) {
1369                 os << "\tObsoletedBy \"" << to_utf8(obsoleted_by_)
1370                    << "\"\nEnd\n";
1371                 return;
1372         }
1373         if (!depends_on_.empty())
1374                 os << "\tDependsOn " << to_utf8(depends_on_) << '\n';
1375         switch (margintype) {
1376                 case MARGIN_DYNAMIC:
1377                         os << "\tMargin Dynamic\n";
1378                         break;
1379                 case MARGIN_FIRST_DYNAMIC:
1380                         os << "\tMargin First_Dynamic\n";
1381                         break;
1382                 case MARGIN_MANUAL:
1383                         os << "\tMargin Manual\n";
1384                         break;
1385                 case MARGIN_RIGHT_ADDRESS_BOX:
1386                         os << "\tMargin Right_Address_Box\n";
1387                         break;
1388                 case MARGIN_STATIC:
1389                         os << "\tMargin Static\n";
1390                         break;
1391         }
1392         switch (latextype) {
1393                 case LATEX_BIB_ENVIRONMENT:
1394                         os << "\tLatexType Bib_Environment\n";
1395                         break;
1396                 case LATEX_COMMAND:
1397                         os << "\tLatexType Command\n";
1398                         break;
1399                 case LATEX_ENVIRONMENT:
1400                         os << "\tLatexType Environment\n";
1401                         break;
1402                 case LATEX_ITEM_ENVIRONMENT:
1403                         os << "\tLatexType Item_Environment\n";
1404                         break;
1405                 case LATEX_LIST_ENVIRONMENT:
1406                         os << "\tLatexType List_Environment\n";
1407                         break;
1408                 case LATEX_PARAGRAPH:
1409                         os << "\tLatexType Paragraph\n";
1410                         break;
1411         }
1412         os << "\tInTitle " << intitle << "\n"
1413               "\tInPreamble " << inpreamble << "\n"
1414               "\tTocLevel " << toclevel << "\n"
1415               "\tResumeCounter " << resumecounter << "\n"
1416               "\tStepParentCounter " << stepparentcounter << '\n';
1417         // ResetArgs does not make sense here
1418         for (LaTeXArgMap::const_iterator it = latexargs_.begin();
1419              it != latexargs_.end(); ++it)
1420                 writeArgument(os, it->first, it->second);
1421         for (LaTeXArgMap::const_iterator it = itemargs_.begin();
1422              it != itemargs_.end(); ++it)
1423                 writeArgument(os, it->first, it->second);
1424         for (LaTeXArgMap::const_iterator it = postcommandargs_.begin();
1425              it != postcommandargs_.end(); ++it)
1426                 writeArgument(os, it->first, it->second);
1427         for (LaTeXArgMap::const_iterator it = listpreamble_.begin();
1428              it != listpreamble_.end(); ++it)
1429                 writeArgument(os, it->first, it->second);
1430         os << "\tNeedProtect " << needprotect << "\n"
1431               "\tNeedCProtect " << needcprotect << "\n"
1432               "\tNeedMBoxProtect " << needmboxprotect << "\n"
1433               "\tKeepEmpty " << keepempty << '\n';
1434         if (labelfont == font)
1435                 lyxWrite(os, font, "Font", 1);
1436         else {
1437                 lyxWrite(os, font, "TextFont", 1);
1438                 lyxWrite(os, labelfont, "LabelFont", 1);
1439         }
1440         os << "\tNextNoIndent " << nextnoindent << "\n"
1441               "\tCommandDepth " << commanddepth << '\n';
1442         if (!latexname_.empty())
1443                 os << "\tLatexName \"" << latexname_ << "\"\n";
1444         if (!latexparam_.empty())
1445                 os << "\tLatexParam \"" << subst(latexparam_, "\"", "&quot;")
1446                    << "\"\n";
1447         if (!leftdelim_.empty())
1448                 os << "\tLeftDelim "
1449                    << to_utf8(subst(leftdelim_, from_ascii("\n"), from_ascii("<br/>")))
1450                    << '\n';
1451         if (!rightdelim_.empty())
1452                 os << "\tRightDelim "
1453                    << to_utf8(subst(rightdelim_, from_ascii("\n"), from_ascii("<br/>")))
1454                    << '\n';
1455         if (!innertag_.empty())
1456                 os << "\tInnerTag \"" << innertag_ << "\"\n";
1457         if (!labeltag_.empty())
1458                 os << "\tLabelTag \"" << labeltag_ << "\"\n";
1459         if (!itemtag_.empty())
1460                 os << "\tItemTag \"" << itemtag_ << "\"\n";
1461         if (!itemcommand_.empty())
1462                 os << "\tItemCommand " << itemcommand_ << '\n';
1463         if (!preamble_.empty())
1464                 os << "\tPreamble\n\t"
1465                    << to_utf8(subst(rtrim(preamble_, "\n"),
1466                                     from_ascii("\n"), from_ascii("\n\t")))
1467                    << "\n\tEndPreamble\n";
1468         if (!langpreamble_.empty())
1469                 os << "\tLangPreamble\n\t"
1470                    << to_utf8(subst(rtrim(langpreamble_, "\n"),
1471                                     from_ascii("\n"), from_ascii("\n\t")))
1472                    << "\n\tEndLangPreamble\n";
1473         if (!babelpreamble_.empty())
1474                 os << "\tBabelPreamble\n\t"
1475                    << to_utf8(subst(rtrim(babelpreamble_, "\n"),
1476                                     from_ascii("\n"), from_ascii("\n\t")))
1477                    << "\n\tEndBabelPreamble\n";
1478         switch (labeltype) {
1479         case LABEL_ABOVE:
1480                 os << "\tLabelType Above\n";
1481                 break;
1482         case LABEL_BIBLIO:
1483                 os << "\tLabelType Bibliography\n";
1484                 break;
1485         case LABEL_CENTERED:
1486                 os << "\tLabelType Centered\n";
1487                 break;
1488         case LABEL_ENUMERATE:
1489                 os << "\tLabelType Enumerate\n";
1490                 break;
1491         case LABEL_ITEMIZE:
1492                 os << "\tLabelType Itemize\n";
1493                 break;
1494         case LABEL_MANUAL:
1495                 os << "\tLabelType Manual\n";
1496                 break;
1497         case LABEL_NO_LABEL:
1498                 os << "\tLabelType No_Label\n";
1499                 break;
1500         case LABEL_SENSITIVE:
1501                 os << "\tLabelType Sensitive\n";
1502                 break;
1503         case LABEL_STATIC:
1504                 os << "\tLabelType Static\n";
1505                 break;
1506         }
1507         switch (endlabeltype) {
1508         case END_LABEL_BOX:
1509                 os << "\tEndLabelType Box\n";
1510                 break;
1511         case END_LABEL_FILLED_BOX:
1512                 os << "\tEndLabelType Filled_Box\n";
1513                 break;
1514         case END_LABEL_NO_LABEL:
1515                 os << "\tEndLabelType No_Label\n";
1516                 break;
1517         case END_LABEL_STATIC:
1518                 os << "\tEndLabelType Static\n";
1519                 break;
1520         }
1521         os << "\tParagraphGroup \"" << par_group_ << "\"\n";
1522         if (!leftmargin.empty())
1523                 os << "\tLeftMargin \"" << to_utf8(leftmargin) << "\"\n";
1524         if (!rightmargin.empty())
1525                 os << "\tRightMargin \"" << to_utf8(rightmargin) << "\"\n";
1526         if (!labelindent.empty())
1527                 os << "\tLabelIndent " << to_utf8(labelindent) << '\n';
1528         if (!parindent.empty())
1529                 os << "\tParIndent " << to_utf8(parindent) << '\n';
1530         os << "\tParSkip " << parskip << "\n"
1531               "\tItemSep " << itemsep << "\n"
1532               "\tTopSep " << topsep << "\n"
1533               "\tBottomSep " << bottomsep << "\n"
1534               "\tLabelBottomSep " << labelbottomsep << '\n';
1535         if (!labelsep.empty())
1536                 os << "\tLabelSep " << to_utf8(subst(labelsep, ' ', 'x'))
1537                    << '\n';
1538         os << "\tParSep " << parsep << "\n"
1539               "\tNewLine " << newline_allowed << '\n';
1540         switch (align) {
1541         case LYX_ALIGN_BLOCK:
1542                 os << "\tAlign Block\n";
1543                 break;
1544         case LYX_ALIGN_CENTER:
1545                 os << "\tAlign Center\n";
1546                 break;
1547         case LYX_ALIGN_LAYOUT:
1548                 os << "\tAlign Layout\n";
1549                 break;
1550         case LYX_ALIGN_LEFT:
1551                 os << "\tAlign Left\n";
1552                 break;
1553         case LYX_ALIGN_RIGHT:
1554                 os << "\tAlign Right\n";
1555                 break;
1556         case LYX_ALIGN_DECIMAL:
1557         case LYX_ALIGN_SPECIAL:
1558         case LYX_ALIGN_NONE:
1559                 break;
1560         }
1561         if (alignpossible & (LYX_ALIGN_BLOCK | LYX_ALIGN_CENTER |
1562                              LYX_ALIGN_LAYOUT | LYX_ALIGN_LEFT | LYX_ALIGN_RIGHT)) {
1563                 bool first = true;
1564                 os << "\tAlignPossible";
1565                 if (alignpossible & LYX_ALIGN_BLOCK) {
1566                         os << " Block";
1567                         first = false;
1568                 }
1569                 if (alignpossible & LYX_ALIGN_CENTER) {
1570                         if (!first)
1571                                 os << ',';
1572                         os << " Center";
1573                         first = false;
1574                 }
1575                 if (alignpossible & LYX_ALIGN_LAYOUT) {
1576                         if (!first)
1577                                 os << ',';
1578                         os << " Layout";
1579                         first = false;
1580                 }
1581                 if (alignpossible & LYX_ALIGN_LEFT) {
1582                         if (!first)
1583                                 os << ',';
1584                         os << " Left";
1585                         first = false;
1586                 }
1587                 if (alignpossible & LYX_ALIGN_RIGHT) {
1588                         if (!first)
1589                                 os << ',';
1590                         os << " Right";
1591                         first = false;
1592                 }
1593                 os << '\n';
1594         }
1595         // LabelString must come before LabelStringAppendix
1596         if (!labelstring_.empty())
1597                 os << "\tLabelString \"" << to_utf8(labelstring_) << "\"\n";
1598         if (!endlabelstring_.empty())
1599                 os << "\tEndLabelString \"" << to_utf8(endlabelstring_) << "\"\n";
1600         if (!labelstring_appendix_.empty() && labelstring_appendix_ != labelstring_)
1601                 os << "\tLabelStringAppendix \""
1602                    << to_utf8(labelstring_appendix_) << "\"\n";
1603         if (!counter.empty())
1604                 os << "\tLabelCounter \"" << to_utf8(counter) << "\"\n";
1605         os << "\tFreeSpacing " << free_spacing << '\n';
1606         os << "\tPassThru " << pass_thru << '\n';
1607         if (!pass_thru_chars.empty())
1608                 os << "\tPassThruChars " << to_utf8(pass_thru_chars) << '\n';
1609         os << "\tParbreakIsNewline " << parbreak_is_newline << '\n';
1610         switch (spacing.getSpace()) {
1611         case Spacing::Double:
1612                 os << "\tSpacing Double\n";
1613                 break;
1614         case Spacing::Onehalf:
1615                 os << "\tSpacing Onehalf\n";
1616                 break;
1617         case Spacing::Other:
1618                 os << "\tSpacing Other " << spacing.getValueAsString() << '\n';
1619                 break;
1620         case Spacing::Single:
1621                 os << "\tSpacing Single\n";
1622                 break;
1623         case Spacing::Default:
1624                 break;
1625         }
1626         if (!required_.empty()) {
1627                 os << "\tRequires ";
1628                 for (set<string>::const_iterator it = required_.begin();
1629                      it != required_.end(); ++it) {
1630                         if (it != required_.begin())
1631                                 os << ',';
1632                         os << *it;
1633                 }
1634                 os << '\n';
1635         }
1636         if (!autonests_.empty()) {
1637                 os << "\tAutoNests\n\t";
1638                 for (set<docstring>::const_iterator it = autonests_.begin();
1639                      it != autonests_.end(); ++it) {
1640                         if (it != autonests_.begin())
1641                                 os << ',';
1642                         os << to_utf8(*it);
1643                 }
1644                 os << "\n\tEndAutoNests\n";
1645         }
1646         if (!autonested_by_.empty()) {
1647                 os << "\tIsAutoNestedBy\n\t\t";
1648                 for (set<docstring>::const_iterator it = autonested_by_.begin();
1649                      it != autonested_by_.end(); ++it) {
1650                         if (it != autonested_by_.begin())
1651                                 os << ',';
1652                         os << to_utf8(*it);
1653                 }
1654                 os << "\n\tEndIsAutoNestedBy\n";
1655         }
1656         if (refprefix.empty())
1657                 os << "\tRefPrefix OFF\n";
1658         else
1659                 os << "\tRefPrefix " << to_utf8(refprefix) << '\n';
1660         if (!htmltag_.empty())
1661                 os << "\tHTMLTag " << htmltag_ << '\n';
1662         if (!htmlattr_.empty())
1663                 os << "\tHTMLAttr " << htmlattr_ << '\n';
1664         if (!htmlitemtag_.empty())
1665                 os << "\tHTMLItem " << htmlitemtag_ << '\n';
1666         if (!htmlitemattr_.empty())
1667                 os << "\tHTMLItemAttr " << htmlitemattr_ << '\n';
1668         if (!htmllabeltag_.empty())
1669                 os << "\tHTMLLabel " << htmllabeltag_ << '\n';
1670         if (!htmllabelattr_.empty())
1671                 os << "\tHTMLLabelAttr " << htmllabelattr_ << '\n';
1672         os << "\tHTMLLabelFirst " << htmllabelfirst_ << '\n';
1673         if (!htmlstyle_.empty())
1674                 os << "\tHTMLStyle\n"
1675                    << to_utf8(rtrim(htmlstyle_, "\n"))
1676                    << "\n\tEndHTMLStyle\n";
1677         os << "\tHTMLForceCSS " << htmlforcecss_ << '\n';
1678         if (!htmlpreamble_.empty())
1679                 os << "\tHTMLPreamble\n"
1680                    << to_utf8(rtrim(htmlpreamble_, "\n"))
1681                    << "\n\tEndPreamble\n";
1682         os << "\tHTMLTitle " << htmltitle_ << "\n";
1683         if(!docbooktag_.empty())
1684                 os << "\tDocBookTag " << docbooktag_ << '\n';
1685         if(!docbookattr_.empty())
1686                 os << "\tDocBookAttr \"" << docbookattr_ << "\"\n";
1687         if(!docbooktagtype_.empty())
1688                 os << "\tDocBookTagType " << docbooktagtype_ << '\n';
1689         if(!docbookinnertag_.empty())
1690                 os << "\tDocBookInnerTag " << docbookinnertag_ << '\n';
1691         if(!docbookinnerattr_.empty())
1692                 os << "\tDocBookInnerAttr \"" << docbookinnerattr_ << "\"\n";
1693         if(!docbookinnertagtype_.empty())
1694                 os << "\tDocBookInnerTagType " << docbookinnertagtype_ << '\n';
1695         if(!docbookininfo_.empty())
1696                 os << "\tDocBookInInfo " << docbookininfo_ << '\n';
1697         os << "\tDocBookAbstract " << docbookabstract_ << '\n';
1698         if(!docbookwrappertag_.empty())
1699                 os << "\tDocBookWrapperTag " << docbookwrappertag_ << '\n';
1700         if(!docbookwrapperattr_.empty())
1701                 os << "\tDocBookWrapperAttr " << docbookwrapperattr_ << '\n';
1702         if(!docbookwrappertagtype_.empty())
1703                 os << "\tDocBookWrapperTagType " << docbookwrappertagtype_ << '\n';
1704         os << "\tDocBookSection " << docbooksection_ << '\n';
1705         if(!docbooksectiontag_.empty())
1706                 os << "\tDocBookSectionTag " << docbooksectiontag_ << '\n';
1707         if(!docbookitemtag_.empty())
1708                 os << "\tDocBookItemTag " << docbookitemtag_ << '\n';
1709         if(!docbookitemattr_.empty())
1710                 os << "\tDocBookItemAttr " << docbookitemattr_ << '\n';
1711         if(!docbookitemtagtype_.empty())
1712                 os << "\tDocBookItemTagType " << docbookitemtagtype_ << '\n';
1713         if(!docbookitemwrappertag_.empty())
1714                 os << "\tDocBookItemWrapperTag " << docbookitemwrappertag_ << '\n';
1715         if(!docbookitemwrapperattr_.empty())
1716                 os << "\tDocBookItemWrapperAttr " << docbookitemwrapperattr_ << '\n';
1717         if(!docbookitemwrappertagtype_.empty())
1718                 os << "\tDocBookItemWrapperTagType " << docbookitemwrappertagtype_ << '\n';
1719         os << "\tDocBookWrapperMergeWithPrevious " << docbookwrappermergewithprevious_ << '\n';
1720         if(!docbookitemlabeltag_.empty())
1721                 os << "\tDocBookItemLabelTag " << docbookitemlabeltag_ << '\n';
1722         if(!docbookitemlabelattr_.empty())
1723                 os << "\tDocBookItemLabelAttr " << docbookitemlabelattr_ << '\n';
1724         if(!docbookitemlabeltagtype_.empty())
1725                 os << "\tDocBookItemLabelTagType " << docbookitemlabeltagtype_ << '\n';
1726         if(!docbookiteminnertag_.empty())
1727                 os << "\tDocBookItemInnerTag " << docbookiteminnertag_ << '\n';
1728         if(!docbookiteminnerattr_.empty())
1729                 os << "\tDocBookItemInnerAttr " << docbookiteminnerattr_ << '\n';
1730         if(!docbookiteminnertagtype_.empty())
1731                 os << "\tDocBookItemInnerTagType " << docbookiteminnertagtype_ << '\n';
1732         if(!docbookforceabstracttag_.empty())
1733                 os << "\tDocBookForceAbstractTag " << docbookforceabstracttag_ << '\n';
1734     os << "\tDocBookNoFontInside " << docbooknofontinside_ << "\n"
1735               "\tSpellcheck " << spellcheck << "\n"
1736               "\tForceLocal " << forcelocal << "\n"
1737               "End\n";
1738 }
1739
1740
1741 bool Layout::hasArgs() const
1742 {
1743         return !latexargs_.empty() || !postcommandargs_.empty() ||
1744                 !itemargs_.empty() || !listpreamble_.empty();
1745 }
1746
1747
1748 Layout::LaTeXArgMap Layout::args() const
1749 {
1750         LaTeXArgMap args = latexargs_;
1751         if (!postcommandargs_.empty())
1752                 args.insert(postcommandargs_.begin(), postcommandargs_.end());
1753         if (!listpreamble_.empty())
1754                 args.insert(listpreamble_.begin(), listpreamble_.end());
1755         if (!itemargs_.empty())
1756                 args.insert(itemargs_.begin(), itemargs_.end());
1757         return args;
1758 }
1759
1760
1761 int Layout::optArgs() const
1762 {
1763         int nr = 0;
1764         LaTeXArgMap::const_iterator it = latexargs_.begin();
1765         for (; it != latexargs_.end(); ++it) {
1766                 if (!(*it).second.mandatory)
1767                         ++nr;
1768         }
1769         LaTeXArgMap::const_iterator iit = postcommandargs_.begin();
1770         for (; iit != postcommandargs_.end(); ++iit) {
1771                 if (!(*iit).second.mandatory)
1772                         ++nr;
1773         }
1774         return nr;
1775 }
1776
1777
1778 int Layout::requiredArgs() const
1779 {
1780         int nr = 0;
1781         LaTeXArgMap::const_iterator it = latexargs_.begin();
1782         for (; it != latexargs_.end(); ++it) {
1783                 if ((*it).second.mandatory)
1784                         ++nr;
1785         }
1786         LaTeXArgMap::const_iterator iit = postcommandargs_.begin();
1787         for (; iit != postcommandargs_.end(); ++iit) {
1788                 if (!(*iit).second.mandatory)
1789                         ++nr;
1790         }
1791         return nr;
1792 }
1793
1794
1795 string const & Layout::htmltag() const
1796 {
1797         if (htmltag_.empty())
1798                 htmltag_ =  "div";
1799         return htmltag_;
1800 }
1801
1802
1803 string const & Layout::htmlattr() const
1804 {
1805         if (htmlattr_.empty())
1806                 htmlattr_ = "class=\"" + defaultCSSClass() + "\"";
1807         return htmlattr_;
1808 }
1809
1810
1811 string const & Layout::htmlitemtag() const
1812 {
1813         if (htmlitemtag_.empty())
1814                 htmlitemtag_ = "div";
1815         return htmlitemtag_;
1816 }
1817
1818
1819 string const & Layout::htmlitemattr() const
1820 {
1821         if (htmlitemattr_.empty())
1822                 htmlitemattr_ = "class=\"" + defaultCSSItemClass() + "\"";
1823         return htmlitemattr_;
1824 }
1825
1826
1827 string const & Layout::htmllabeltag() const
1828 {
1829         if (htmllabeltag_.empty())
1830                         htmllabeltag_ = "span";
1831         return htmllabeltag_;
1832 }
1833
1834
1835 string const & Layout::htmllabelattr() const
1836 {
1837         if (htmllabelattr_.empty())
1838                 htmllabelattr_ = "class=\"" + defaultCSSLabelClass() + "\"";
1839         return htmllabelattr_;
1840 }
1841
1842
1843 docstring Layout::htmlstyle() const
1844 {
1845         if (!htmlstyle_.empty() && !htmlforcecss_)
1846                 return htmlstyle_;
1847         if (htmldefaultstyle_.empty())
1848                 makeDefaultCSS();
1849         docstring retval = htmldefaultstyle_;
1850         if (!htmlstyle_.empty())
1851                 retval += '\n' + htmlstyle_;
1852         return retval;
1853 }
1854
1855
1856 string Layout::defaultCSSClass() const
1857 {
1858         if (!defaultcssclass_.empty())
1859                 return defaultcssclass_;
1860         docstring d;
1861         docstring::const_iterator it = name().begin();
1862         docstring::const_iterator en = name().end();
1863         for (; it != en; ++it) {
1864                 char_type const c = *it;
1865                 if (!isAlphaASCII(c)) {
1866                         if (d.empty())
1867                                 // make sure we don't start with an underscore,
1868                                 // as that sometimes causes problems.
1869                                 d = from_ascii("lyx_");
1870                         else
1871                                 d += '_';
1872                 } else if (isLower(c))
1873                         d += c;
1874                 else
1875                         // this is slow, so do it only if necessary
1876                         d += lowercase(c);
1877         }
1878         defaultcssclass_ = to_utf8(d);
1879         return defaultcssclass_;
1880 }
1881
1882
1883 string const & Layout::docbooktag() const
1884 {
1885         if (docbooktag_.empty()) {
1886                 if (to_ascii(name_) == "Plain Layout")
1887                         docbooktag_ = "para";
1888                 else // No sensible default value, unhappily...
1889                         docbooktag_ = to_utf8(name_);
1890         }
1891         return docbooktag_;
1892 }
1893
1894
1895 string const & Layout::docbookattr() const
1896 {
1897         // Perfectly OK to return no attributes, so docbookattr_ does not need to be filled.
1898         return docbookattr_;
1899 }
1900
1901
1902 bool isValidTagType(std::string const & type)
1903 {
1904         return !(type.empty() || (type != "block" && type != "paragraph" && type != "inline"));
1905 }
1906
1907
1908 string const & Layout::docbooktagtype() const
1909 {
1910         if (!isValidTagType(docbooktagtype_))
1911                 docbooktagtype_ = "block";
1912         return docbooktagtype_;
1913 }
1914
1915
1916 string const & Layout::docbookinnertag() const
1917 {
1918         if (docbookinnertag_.empty())
1919                 docbookinnertag_ = "NONE";
1920         return docbookinnertag_;
1921 }
1922
1923
1924 string const & Layout::docbookinnerattr() const
1925 {
1926         return docbookinnerattr_;
1927 }
1928
1929
1930 string const & Layout::docbookinnertagtype() const
1931 {
1932         if (!isValidTagType(docbookinnertagtype_))
1933                 docbookinnertagtype_ = "block";
1934         return docbookinnertagtype_;
1935 }
1936
1937
1938 string const & Layout::docbookininfo() const
1939 {
1940         // Indeed, a trilean. Only titles should be "maybe": otherwise, metadata is "always", content is "never".
1941         if (docbookininfo_.empty() || (docbookininfo_ != "never" && docbookininfo_ != "always" && docbookininfo_ != "maybe"))
1942                 docbookininfo_ = "never";
1943         return docbookininfo_;
1944 }
1945
1946
1947 string const & Layout::docbookwrappertag() const
1948 {
1949     if (docbookwrappertag_.empty())
1950         docbookwrappertag_ = "NONE";
1951     return docbookwrappertag_;
1952 }
1953
1954
1955 string const & Layout::docbookwrapperattr() const
1956 {
1957     return docbookwrapperattr_;
1958 }
1959
1960
1961 string const & Layout::docbookwrappertagtype() const
1962 {
1963         if (!isValidTagType(docbookwrappertagtype_))
1964                 docbookwrappertagtype_ = "block";
1965         return docbookwrappertagtype_;
1966 }
1967
1968
1969 string const & Layout::docbooksectiontag() const
1970 {
1971         if (docbooksectiontag_.empty())
1972                 docbooksectiontag_ = "section";
1973         return docbooksectiontag_;
1974 }
1975
1976
1977 string const & Layout::docbookitemwrappertag() const
1978 {
1979     if (docbookitemwrappertag_.empty())
1980         docbookitemwrappertag_ = "NONE";
1981     return docbookitemwrappertag_;
1982 }
1983
1984
1985 string const & Layout::docbookitemwrapperattr() const
1986 {
1987     return docbookitemwrapperattr_;
1988 }
1989
1990
1991 string const & Layout::docbookitemwrappertagtype() const
1992 {
1993         if (!isValidTagType(docbookitemwrappertagtype_))
1994                 docbookitemwrappertagtype_ = "block";
1995         return docbookitemwrappertagtype_;
1996 }
1997
1998
1999 string const & Layout::docbookitemtag() const
2000 {
2001         if (docbookitemtag_.empty())
2002                 docbookitemtag_ = "NONE";
2003         return docbookitemtag_;
2004 }
2005
2006
2007 string const & Layout::docbookitemattr() const
2008 {
2009     return docbookitemattr_;
2010 }
2011
2012
2013 string const & Layout::docbookitemtagtype() const
2014 {
2015         if (!isValidTagType(docbookitemtagtype_))
2016                 docbookitemtagtype_ = "block";
2017         return docbookitemtagtype_;
2018 }
2019
2020
2021 string const & Layout::docbookitemlabeltag() const
2022 {
2023         if (docbookitemlabeltag_.empty())
2024                 docbookitemlabeltag_ = "NONE";
2025         return docbookitemlabeltag_;
2026 }
2027
2028
2029 string const & Layout::docbookitemlabelattr() const
2030 {
2031         return docbookitemlabelattr_;
2032 }
2033
2034
2035 string const & Layout::docbookitemlabeltagtype() const
2036 {
2037         if (!isValidTagType(docbookitemlabeltagtype_))
2038                 docbookitemlabeltagtype_ = "block";
2039         return docbookitemlabeltagtype_;
2040 }
2041
2042
2043 string const & Layout::docbookiteminnertag() const
2044 {
2045         if (docbookiteminnertag_.empty())
2046                 docbookiteminnertag_ = "NONE";
2047         return docbookiteminnertag_;
2048 }
2049
2050
2051 string const & Layout::docbookiteminnerattr() const
2052 {
2053         return docbookiteminnerattr_;
2054 }
2055
2056
2057 string const & Layout::docbookiteminnertagtype() const
2058 {
2059         if (!isValidTagType(docbookiteminnertagtype_))
2060                 docbookiteminnertagtype_ = "block";
2061         return docbookiteminnertagtype_;
2062 }
2063
2064
2065 std::string const & Layout::docbookforceabstracttag() const
2066 {
2067         if (docbookforceabstracttag_.empty())
2068                 docbookforceabstracttag_ = "NONE";
2069         return docbookforceabstracttag_;
2070 }
2071
2072
2073
2074 namespace {
2075
2076 string makeMarginValue(char const * side, double d)
2077 {
2078         ostringstream os;
2079         os << "margin-" << side << ": " << d << "ex;\n";
2080         return os.str();
2081 }
2082
2083 } // namespace
2084
2085
2086 void Layout::makeDefaultCSS() const
2087 {
2088         // this never needs to be redone, since reloading layouts will
2089         // wipe out what we did before.
2090         if (!htmldefaultstyle_.empty())
2091                 return;
2092
2093         // main font
2094         htmldefaultstyle_ = font.asCSS();
2095
2096         // bottom margins
2097         string tmp;
2098         if (topsep > 0)
2099                 tmp += makeMarginValue("top", topsep);
2100         if (bottomsep > 0)
2101                 tmp += makeMarginValue("bottom", bottomsep);
2102         if (!leftmargin.empty()) {
2103                 // we can't really do what LyX does with the margin, so
2104                 // we'll just figure out how many characters it is
2105                 int const len = leftmargin.length();
2106                 tmp += makeMarginValue("left", len);
2107         }
2108         if (!rightmargin.empty()) {
2109                 int const len = rightmargin.length();
2110                 tmp += makeMarginValue("right", len);
2111         }
2112
2113         if (!tmp.empty()) {
2114                 if (!htmldefaultstyle_.empty())
2115                         htmldefaultstyle_ += from_ascii("\n");
2116                 htmldefaultstyle_ += from_ascii(tmp);
2117         }
2118
2119         // alignment
2120         string where = alignmentToCSS(align);
2121         if (!where.empty()) {
2122                 htmldefaultstyle_ += from_ascii("text-align: " + where + ";\n");
2123         }
2124
2125         // wrap up what we have, if anything
2126         if (!htmldefaultstyle_.empty())
2127                 htmldefaultstyle_ =
2128                         from_ascii(htmltag() + "." + defaultCSSClass() + " {\n") +
2129                         htmldefaultstyle_ + from_ascii("\n}\n");
2130
2131         if (labeltype == LABEL_NO_LABEL || htmllabeltag() == "NONE")
2132                 return;
2133
2134         docstring labelCSS;
2135
2136         // label font
2137         if (labelfont != font)
2138                 labelCSS = labelfont.asCSS() + from_ascii("\n");
2139         if (labeltype == LABEL_CENTERED)
2140                 labelCSS += from_ascii("text-align: center;\n");
2141
2142         if (!labelCSS.empty())
2143                 htmldefaultstyle_ +=
2144                         from_ascii(htmllabeltag() + "." + defaultCSSLabelClass() + " {\n") +
2145                         labelCSS + from_ascii("\n}\n");
2146 }
2147
2148
2149 bool Layout::operator==(Layout const & rhs) const
2150 {
2151         // This is enough for the applications we actually make,
2152         // at least at the moment. But we could check more.
2153         return name() == rhs.name()
2154                 && latexname() == rhs.latexname()
2155                 && latextype == rhs.latextype;
2156 }
2157
2158
2159 } // namespace lyx