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 {
1288                         lex.printError("Unknown tag");
1289                         error = true;
1290                 }
1291         }
1292         if (!validating && arg.labelstring.empty()) {
1293                 LYXERR0("Incomplete Argument definition!");
1294                 // remove invalid definition
1295                 lam.erase(id);
1296         }
1297 }
1298
1299
1300 void writeArgument(ostream & os, string const & id, Layout::latexarg const & arg)
1301 {
1302         os << "\tArgument " << id << '\n';
1303         if (!arg.labelstring.empty())
1304                 os << "\t\tLabelString \"" << to_utf8(arg.labelstring) << "\"\n";
1305         if (!arg.menustring.empty())
1306                 os << "\t\tMenuString \"" << to_utf8(arg.menustring) << "\"\n";
1307         if (arg.mandatory)
1308                 os << "\t\tMandatory " << arg.mandatory << '\n';
1309         if (arg.autoinsert)
1310                 os << "\t\tAutoinsert " << arg.autoinsert << '\n';
1311         if (arg.insertcotext)
1312                 os << "\t\tInsertCotext " << arg.insertcotext << '\n';
1313         if (!arg.ldelim.empty())
1314                 os << "\t\tLeftDelim \""
1315                    << to_utf8(subst(arg.ldelim, from_ascii("\n"), from_ascii("<br/>")))
1316                    << "\"\n";
1317         if (!arg.rdelim.empty())
1318                 os << "\t\tRightDelim \""
1319                    << to_utf8(subst(arg.rdelim, from_ascii("\n"), from_ascii("<br/>")))
1320                    << "\"\n";
1321         if (!arg.defaultarg.empty())
1322                 os << "\t\tDefaultArg \"" << to_utf8(arg.defaultarg) << "\"\n";
1323         if (!arg.presetarg.empty())
1324                 os << "\t\tPresetArg \"" << to_utf8(arg.presetarg) << "\"\n";
1325         if (!arg.tooltip.empty())
1326                 os << "\t\tToolTip \"" << to_utf8(arg.tooltip) << "\"\n";
1327         if (!arg.required.empty())
1328                 os << "\t\tRequires \"" << arg.required << "\"\n";
1329         if (!arg.decoration.empty())
1330                 os << "\t\tDecoration \"" << arg.decoration << "\"\n";
1331         if (!arg.newlinecmd.empty())
1332                 os << "\t\tNewlineCmd \"" << arg.newlinecmd << "\"\n";
1333         if (arg.font != inherit_font)
1334                 lyxWrite(os, arg.font, "Font", 2);
1335         if (arg.labelfont != inherit_font)
1336                 lyxWrite(os, arg.labelfont, "LabelFont", 2);
1337         switch (arg.passthru) {
1338                 case PT_TRUE:
1339                         os << "\t\tPassThru true\n";
1340                         break;
1341                 case PT_FALSE:
1342                         os << "\t\tPassThru false\n";
1343                         break;
1344                 case PT_INHERITED:
1345                         os << "\t\tPassThru inherited\n";
1346                         break;
1347         }
1348         if (!arg.pass_thru_chars.empty())
1349                 os << "\t\tPassThruChars \"" << to_utf8(arg.pass_thru_chars) << "\"\n";
1350         if (arg.free_spacing)
1351                 os << "\t\tFreeSpacing " << arg.free_spacing << "\n";
1352         os << "\tEndArgument\n";
1353 }
1354
1355
1356 void Layout::write(ostream & os) const
1357 {
1358         os << "Style \"" << to_utf8(name_) << "\"\n";
1359         if (!category_.empty() && obsoleted_by_.empty())
1360                 os << "\tCategory \"" << to_utf8(category_) << "\"\n";
1361         // Can't deduce Copystyle here :-(
1362         if (!obsoleted_by_.empty()) {
1363                 os << "\tObsoletedBy \"" << to_utf8(obsoleted_by_)
1364                    << "\"\nEnd\n";
1365                 return;
1366         }
1367         if (!depends_on_.empty())
1368                 os << "\tDependsOn " << to_utf8(depends_on_) << '\n';
1369         switch (margintype) {
1370                 case MARGIN_DYNAMIC:
1371                         os << "\tMargin Dynamic\n";
1372                         break;
1373                 case MARGIN_FIRST_DYNAMIC:
1374                         os << "\tMargin First_Dynamic\n";
1375                         break;
1376                 case MARGIN_MANUAL:
1377                         os << "\tMargin Manual\n";
1378                         break;
1379                 case MARGIN_RIGHT_ADDRESS_BOX:
1380                         os << "\tMargin Right_Address_Box\n";
1381                         break;
1382                 case MARGIN_STATIC:
1383                         os << "\tMargin Static\n";
1384                         break;
1385         }
1386         switch (latextype) {
1387                 case LATEX_BIB_ENVIRONMENT:
1388                         os << "\tLatexType Bib_Environment\n";
1389                         break;
1390                 case LATEX_COMMAND:
1391                         os << "\tLatexType Command\n";
1392                         break;
1393                 case LATEX_ENVIRONMENT:
1394                         os << "\tLatexType Environment\n";
1395                         break;
1396                 case LATEX_ITEM_ENVIRONMENT:
1397                         os << "\tLatexType Item_Environment\n";
1398                         break;
1399                 case LATEX_LIST_ENVIRONMENT:
1400                         os << "\tLatexType List_Environment\n";
1401                         break;
1402                 case LATEX_PARAGRAPH:
1403                         os << "\tLatexType Paragraph\n";
1404                         break;
1405         }
1406         os << "\tInTitle " << intitle << "\n"
1407               "\tInPreamble " << inpreamble << "\n"
1408               "\tTocLevel " << toclevel << "\n"
1409               "\tResumeCounter " << resumecounter << "\n"
1410               "\tStepParentCounter " << stepparentcounter << '\n';
1411         // ResetArgs does not make sense here
1412         for (LaTeXArgMap::const_iterator it = latexargs_.begin();
1413              it != latexargs_.end(); ++it)
1414                 writeArgument(os, it->first, it->second);
1415         for (LaTeXArgMap::const_iterator it = itemargs_.begin();
1416              it != itemargs_.end(); ++it)
1417                 writeArgument(os, it->first, it->second);
1418         for (LaTeXArgMap::const_iterator it = postcommandargs_.begin();
1419              it != postcommandargs_.end(); ++it)
1420                 writeArgument(os, it->first, it->second);
1421         for (LaTeXArgMap::const_iterator it = listpreamble_.begin();
1422              it != listpreamble_.end(); ++it)
1423                 writeArgument(os, it->first, it->second);
1424         os << "\tNeedProtect " << needprotect << "\n"
1425               "\tNeedCProtect " << needcprotect << "\n"
1426               "\tNeedMBoxProtect " << needmboxprotect << "\n"
1427               "\tKeepEmpty " << keepempty << '\n';
1428         if (labelfont == font)
1429                 lyxWrite(os, font, "Font", 1);
1430         else {
1431                 lyxWrite(os, font, "TextFont", 1);
1432                 lyxWrite(os, labelfont, "LabelFont", 1);
1433         }
1434         os << "\tNextNoIndent " << nextnoindent << "\n"
1435               "\tCommandDepth " << commanddepth << '\n';
1436         if (!latexname_.empty())
1437                 os << "\tLatexName \"" << latexname_ << "\"\n";
1438         if (!latexparam_.empty())
1439                 os << "\tLatexParam \"" << subst(latexparam_, "\"", "&quot;")
1440                    << "\"\n";
1441         if (!leftdelim_.empty())
1442                 os << "\tLeftDelim "
1443                    << to_utf8(subst(leftdelim_, from_ascii("\n"), from_ascii("<br/>")))
1444                    << '\n';
1445         if (!rightdelim_.empty())
1446                 os << "\tRightDelim "
1447                    << to_utf8(subst(rightdelim_, from_ascii("\n"), from_ascii("<br/>")))
1448                    << '\n';
1449         if (!innertag_.empty())
1450                 os << "\tInnerTag \"" << innertag_ << "\"\n";
1451         if (!labeltag_.empty())
1452                 os << "\tLabelTag \"" << labeltag_ << "\"\n";
1453         if (!itemtag_.empty())
1454                 os << "\tItemTag \"" << itemtag_ << "\"\n";
1455         if (!itemcommand_.empty())
1456                 os << "\tItemCommand " << itemcommand_ << '\n';
1457         if (!preamble_.empty())
1458                 os << "\tPreamble\n\t"
1459                    << to_utf8(subst(rtrim(preamble_, "\n"),
1460                                     from_ascii("\n"), from_ascii("\n\t")))
1461                    << "\n\tEndPreamble\n";
1462         if (!langpreamble_.empty())
1463                 os << "\tLangPreamble\n\t"
1464                    << to_utf8(subst(rtrim(langpreamble_, "\n"),
1465                                     from_ascii("\n"), from_ascii("\n\t")))
1466                    << "\n\tEndLangPreamble\n";
1467         if (!babelpreamble_.empty())
1468                 os << "\tBabelPreamble\n\t"
1469                    << to_utf8(subst(rtrim(babelpreamble_, "\n"),
1470                                     from_ascii("\n"), from_ascii("\n\t")))
1471                    << "\n\tEndBabelPreamble\n";
1472         switch (labeltype) {
1473         case LABEL_ABOVE:
1474                 os << "\tLabelType Above\n";
1475                 break;
1476         case LABEL_BIBLIO:
1477                 os << "\tLabelType Bibliography\n";
1478                 break;
1479         case LABEL_CENTERED:
1480                 os << "\tLabelType Centered\n";
1481                 break;
1482         case LABEL_ENUMERATE:
1483                 os << "\tLabelType Enumerate\n";
1484                 break;
1485         case LABEL_ITEMIZE:
1486                 os << "\tLabelType Itemize\n";
1487                 break;
1488         case LABEL_MANUAL:
1489                 os << "\tLabelType Manual\n";
1490                 break;
1491         case LABEL_NO_LABEL:
1492                 os << "\tLabelType No_Label\n";
1493                 break;
1494         case LABEL_SENSITIVE:
1495                 os << "\tLabelType Sensitive\n";
1496                 break;
1497         case LABEL_STATIC:
1498                 os << "\tLabelType Static\n";
1499                 break;
1500         }
1501         switch (endlabeltype) {
1502         case END_LABEL_BOX:
1503                 os << "\tEndLabelType Box\n";
1504                 break;
1505         case END_LABEL_FILLED_BOX:
1506                 os << "\tEndLabelType Filled_Box\n";
1507                 break;
1508         case END_LABEL_NO_LABEL:
1509                 os << "\tEndLabelType No_Label\n";
1510                 break;
1511         case END_LABEL_STATIC:
1512                 os << "\tEndLabelType Static\n";
1513                 break;
1514         }
1515         os << "\tParagraphGroup \"" << par_group_ << "\"\n";
1516         if (!leftmargin.empty())
1517                 os << "\tLeftMargin \"" << to_utf8(leftmargin) << "\"\n";
1518         if (!rightmargin.empty())
1519                 os << "\tRightMargin \"" << to_utf8(rightmargin) << "\"\n";
1520         if (!labelindent.empty())
1521                 os << "\tLabelIndent " << to_utf8(labelindent) << '\n';
1522         if (!parindent.empty())
1523                 os << "\tParIndent " << to_utf8(parindent) << '\n';
1524         os << "\tParSkip " << parskip << "\n"
1525               "\tItemSep " << itemsep << "\n"
1526               "\tTopSep " << topsep << "\n"
1527               "\tBottomSep " << bottomsep << "\n"
1528               "\tLabelBottomSep " << labelbottomsep << '\n';
1529         if (!labelsep.empty())
1530                 os << "\tLabelSep " << to_utf8(subst(labelsep, ' ', 'x'))
1531                    << '\n';
1532         os << "\tParSep " << parsep << "\n"
1533               "\tNewLine " << newline_allowed << '\n';
1534         switch (align) {
1535         case LYX_ALIGN_BLOCK:
1536                 os << "\tAlign Block\n";
1537                 break;
1538         case LYX_ALIGN_CENTER:
1539                 os << "\tAlign Center\n";
1540                 break;
1541         case LYX_ALIGN_LAYOUT:
1542                 os << "\tAlign Layout\n";
1543                 break;
1544         case LYX_ALIGN_LEFT:
1545                 os << "\tAlign Left\n";
1546                 break;
1547         case LYX_ALIGN_RIGHT:
1548                 os << "\tAlign Right\n";
1549                 break;
1550         case LYX_ALIGN_DECIMAL:
1551         case LYX_ALIGN_SPECIAL:
1552         case LYX_ALIGN_NONE:
1553                 break;
1554         }
1555         if (alignpossible & (LYX_ALIGN_BLOCK | LYX_ALIGN_CENTER |
1556                              LYX_ALIGN_LAYOUT | LYX_ALIGN_LEFT | LYX_ALIGN_RIGHT)) {
1557                 bool first = true;
1558                 os << "\tAlignPossible";
1559                 if (alignpossible & LYX_ALIGN_BLOCK) {
1560                         os << " Block";
1561                         first = false;
1562                 }
1563                 if (alignpossible & LYX_ALIGN_CENTER) {
1564                         if (!first)
1565                                 os << ',';
1566                         os << " Center";
1567                         first = false;
1568                 }
1569                 if (alignpossible & LYX_ALIGN_LAYOUT) {
1570                         if (!first)
1571                                 os << ',';
1572                         os << " Layout";
1573                         first = false;
1574                 }
1575                 if (alignpossible & LYX_ALIGN_LEFT) {
1576                         if (!first)
1577                                 os << ',';
1578                         os << " Left";
1579                         first = false;
1580                 }
1581                 if (alignpossible & LYX_ALIGN_RIGHT) {
1582                         if (!first)
1583                                 os << ',';
1584                         os << " Right";
1585                         first = false;
1586                 }
1587                 os << '\n';
1588         }
1589         // LabelString must come before LabelStringAppendix
1590         if (!labelstring_.empty())
1591                 os << "\tLabelString \"" << to_utf8(labelstring_) << "\"\n";
1592         if (!endlabelstring_.empty())
1593                 os << "\tEndLabelString \"" << to_utf8(endlabelstring_) << "\"\n";
1594         if (!labelstring_appendix_.empty() && labelstring_appendix_ != labelstring_)
1595                 os << "\tLabelStringAppendix \""
1596                    << to_utf8(labelstring_appendix_) << "\"\n";
1597         if (!counter.empty())
1598                 os << "\tLabelCounter \"" << to_utf8(counter) << "\"\n";
1599         os << "\tFreeSpacing " << free_spacing << '\n';
1600         os << "\tPassThru " << pass_thru << '\n';
1601         if (!pass_thru_chars.empty())
1602                 os << "\tPassThruChars " << to_utf8(pass_thru_chars) << '\n';
1603         os << "\tParbreakIsNewline " << parbreak_is_newline << '\n';
1604         switch (spacing.getSpace()) {
1605         case Spacing::Double:
1606                 os << "\tSpacing Double\n";
1607                 break;
1608         case Spacing::Onehalf:
1609                 os << "\tSpacing Onehalf\n";
1610                 break;
1611         case Spacing::Other:
1612                 os << "\tSpacing Other " << spacing.getValueAsString() << '\n';
1613                 break;
1614         case Spacing::Single:
1615                 os << "\tSpacing Single\n";
1616                 break;
1617         case Spacing::Default:
1618                 break;
1619         }
1620         if (!required_.empty()) {
1621                 os << "\tRequires ";
1622                 for (set<string>::const_iterator it = required_.begin();
1623                      it != required_.end(); ++it) {
1624                         if (it != required_.begin())
1625                                 os << ',';
1626                         os << *it;
1627                 }
1628                 os << '\n';
1629         }
1630         if (!autonests_.empty()) {
1631                 os << "\tAutoNests\n\t";
1632                 for (set<docstring>::const_iterator it = autonests_.begin();
1633                      it != autonests_.end(); ++it) {
1634                         if (it != autonests_.begin())
1635                                 os << ',';
1636                         os << to_utf8(*it);
1637                 }
1638                 os << "\n\tEndAutoNests\n";
1639         }
1640         if (!autonested_by_.empty()) {
1641                 os << "\tIsAutoNestedBy\n\t\t";
1642                 for (set<docstring>::const_iterator it = autonested_by_.begin();
1643                      it != autonested_by_.end(); ++it) {
1644                         if (it != autonested_by_.begin())
1645                                 os << ',';
1646                         os << to_utf8(*it);
1647                 }
1648                 os << "\n\tEndIsAutoNestedBy\n";
1649         }
1650         if (refprefix.empty())
1651                 os << "\tRefPrefix OFF\n";
1652         else
1653                 os << "\tRefPrefix " << to_utf8(refprefix) << '\n';
1654         if (!htmltag_.empty())
1655                 os << "\tHTMLTag " << htmltag_ << '\n';
1656         if (!htmlattr_.empty())
1657                 os << "\tHTMLAttr " << htmlattr_ << '\n';
1658         if (!htmlitemtag_.empty())
1659                 os << "\tHTMLItem " << htmlitemtag_ << '\n';
1660         if (!htmlitemattr_.empty())
1661                 os << "\tHTMLItemAttr " << htmlitemattr_ << '\n';
1662         if (!htmllabeltag_.empty())
1663                 os << "\tHTMLLabel " << htmllabeltag_ << '\n';
1664         if (!htmllabelattr_.empty())
1665                 os << "\tHTMLLabelAttr " << htmllabelattr_ << '\n';
1666         os << "\tHTMLLabelFirst " << htmllabelfirst_ << '\n';
1667         if (!htmlstyle_.empty())
1668                 os << "\tHTMLStyle\n"
1669                    << to_utf8(rtrim(htmlstyle_, "\n"))
1670                    << "\n\tEndHTMLStyle\n";
1671         os << "\tHTMLForceCSS " << htmlforcecss_ << '\n';
1672         if (!htmlpreamble_.empty())
1673                 os << "\tHTMLPreamble\n"
1674                    << to_utf8(rtrim(htmlpreamble_, "\n"))
1675                    << "\n\tEndPreamble\n";
1676         os << "\tHTMLTitle " << htmltitle_ << "\n";
1677         if(!docbooktag_.empty())
1678                 os << "\tDocBookTag " << docbooktag_ << '\n';
1679         if(!docbookattr_.empty())
1680                 os << "\tDocBookAttr \"" << docbookattr_ << "\"\n";
1681         if(!docbooktagtype_.empty())
1682                 os << "\tDocBookTagType " << docbooktagtype_ << '\n';
1683         if(!docbookinnertag_.empty())
1684                 os << "\tDocBookInnerTag " << docbookinnertag_ << '\n';
1685         if(!docbookinnerattr_.empty())
1686                 os << "\tDocBookInnerAttr \"" << docbookinnerattr_ << "\"\n";
1687         if(!docbookinnertagtype_.empty())
1688                 os << "\tDocBookInnerTagType " << docbookinnertagtype_ << '\n';
1689         if(!docbookininfo_.empty())
1690                 os << "\tDocBookInInfo " << docbookininfo_ << '\n';
1691         os << "\tDocBookAbstract " << docbookabstract_ << '\n';
1692         if(!docbookwrappertag_.empty())
1693                 os << "\tDocBookWrapperTag " << docbookwrappertag_ << '\n';
1694         if(!docbookwrapperattr_.empty())
1695                 os << "\tDocBookWrapperAttr " << docbookwrapperattr_ << '\n';
1696         if(!docbookwrappertagtype_.empty())
1697                 os << "\tDocBookWrapperTagType " << docbookwrappertagtype_ << '\n';
1698         os << "\tDocBookSection " << docbooksection_ << '\n';
1699         if(!docbooksectiontag_.empty())
1700                 os << "\tDocBookSectionTag " << docbooksectiontag_ << '\n';
1701         if(!docbookitemtag_.empty())
1702                 os << "\tDocBookItemTag " << docbookitemtag_ << '\n';
1703         if(!docbookitemattr_.empty())
1704                 os << "\tDocBookItemAttr " << docbookitemattr_ << '\n';
1705         if(!docbookitemtagtype_.empty())
1706                 os << "\tDocBookItemTagType " << docbookitemtagtype_ << '\n';
1707         if(!docbookitemwrappertag_.empty())
1708                 os << "\tDocBookItemWrapperTag " << docbookitemwrappertag_ << '\n';
1709         if(!docbookitemwrapperattr_.empty())
1710                 os << "\tDocBookItemWrapperAttr " << docbookitemwrapperattr_ << '\n';
1711         if(!docbookitemwrappertagtype_.empty())
1712                 os << "\tDocBookItemWrapperTagType " << docbookitemwrappertagtype_ << '\n';
1713         os << "\tDocBookWrapperMergeWithPrevious " << docbookwrappermergewithprevious_ << '\n';
1714         if(!docbookitemlabeltag_.empty())
1715                 os << "\tDocBookItemLabelTag " << docbookitemlabeltag_ << '\n';
1716         if(!docbookitemlabelattr_.empty())
1717                 os << "\tDocBookItemLabelAttr " << docbookitemlabelattr_ << '\n';
1718         if(!docbookitemlabeltagtype_.empty())
1719                 os << "\tDocBookItemLabelTagType " << docbookitemlabeltagtype_ << '\n';
1720         if(!docbookiteminnertag_.empty())
1721                 os << "\tDocBookItemInnerTag " << docbookiteminnertag_ << '\n';
1722         if(!docbookiteminnerattr_.empty())
1723                 os << "\tDocBookItemInnerAttr " << docbookiteminnerattr_ << '\n';
1724         if(!docbookiteminnertagtype_.empty())
1725                 os << "\tDocBookItemInnerTagType " << docbookiteminnertagtype_ << '\n';
1726         if(!docbookforceabstracttag_.empty())
1727                 os << "\tDocBookForceAbstractTag " << docbookforceabstracttag_ << '\n';
1728     os << "\tDocBookNoFontInside " << docbooknofontinside_ << "\n"
1729               "\tSpellcheck " << spellcheck << "\n"
1730               "\tForceLocal " << forcelocal << "\n"
1731               "End\n";
1732 }
1733
1734
1735 bool Layout::hasArgs() const
1736 {
1737         return !latexargs_.empty() || !postcommandargs_.empty() ||
1738                 !itemargs_.empty() || !listpreamble_.empty();
1739 }
1740
1741
1742 Layout::LaTeXArgMap Layout::args() const
1743 {
1744         LaTeXArgMap args = latexargs_;
1745         if (!postcommandargs_.empty())
1746                 args.insert(postcommandargs_.begin(), postcommandargs_.end());
1747         if (!listpreamble_.empty())
1748                 args.insert(listpreamble_.begin(), listpreamble_.end());
1749         if (!itemargs_.empty())
1750                 args.insert(itemargs_.begin(), itemargs_.end());
1751         return args;
1752 }
1753
1754
1755 int Layout::optArgs() const
1756 {
1757         int nr = 0;
1758         LaTeXArgMap::const_iterator it = latexargs_.begin();
1759         for (; it != latexargs_.end(); ++it) {
1760                 if (!(*it).second.mandatory)
1761                         ++nr;
1762         }
1763         LaTeXArgMap::const_iterator iit = postcommandargs_.begin();
1764         for (; iit != postcommandargs_.end(); ++iit) {
1765                 if (!(*iit).second.mandatory)
1766                         ++nr;
1767         }
1768         return nr;
1769 }
1770
1771
1772 int Layout::requiredArgs() const
1773 {
1774         int nr = 0;
1775         LaTeXArgMap::const_iterator it = latexargs_.begin();
1776         for (; it != latexargs_.end(); ++it) {
1777                 if ((*it).second.mandatory)
1778                         ++nr;
1779         }
1780         LaTeXArgMap::const_iterator iit = postcommandargs_.begin();
1781         for (; iit != postcommandargs_.end(); ++iit) {
1782                 if (!(*iit).second.mandatory)
1783                         ++nr;
1784         }
1785         return nr;
1786 }
1787
1788
1789 string const & Layout::htmltag() const
1790 {
1791         if (htmltag_.empty())
1792                 htmltag_ =  "div";
1793         return htmltag_;
1794 }
1795
1796
1797 string const & Layout::htmlattr() const
1798 {
1799         if (htmlattr_.empty())
1800                 htmlattr_ = "class=\"" + defaultCSSClass() + "\"";
1801         return htmlattr_;
1802 }
1803
1804
1805 string const & Layout::htmlitemtag() const
1806 {
1807         if (htmlitemtag_.empty())
1808                 htmlitemtag_ = "div";
1809         return htmlitemtag_;
1810 }
1811
1812
1813 string const & Layout::htmlitemattr() const
1814 {
1815         if (htmlitemattr_.empty())
1816                 htmlitemattr_ = "class=\"" + defaultCSSItemClass() + "\"";
1817         return htmlitemattr_;
1818 }
1819
1820
1821 string const & Layout::htmllabeltag() const
1822 {
1823         if (htmllabeltag_.empty())
1824                         htmllabeltag_ = "span";
1825         return htmllabeltag_;
1826 }
1827
1828
1829 string const & Layout::htmllabelattr() const
1830 {
1831         if (htmllabelattr_.empty())
1832                 htmllabelattr_ = "class=\"" + defaultCSSLabelClass() + "\"";
1833         return htmllabelattr_;
1834 }
1835
1836
1837 docstring Layout::htmlstyle() const
1838 {
1839         if (!htmlstyle_.empty() && !htmlforcecss_)
1840                 return htmlstyle_;
1841         if (htmldefaultstyle_.empty())
1842                 makeDefaultCSS();
1843         docstring retval = htmldefaultstyle_;
1844         if (!htmlstyle_.empty())
1845                 retval += '\n' + htmlstyle_;
1846         return retval;
1847 }
1848
1849
1850 string Layout::defaultCSSClass() const
1851 {
1852         if (!defaultcssclass_.empty())
1853                 return defaultcssclass_;
1854         docstring d;
1855         docstring::const_iterator it = name().begin();
1856         docstring::const_iterator en = name().end();
1857         for (; it != en; ++it) {
1858                 char_type const c = *it;
1859                 if (!isAlphaASCII(c)) {
1860                         if (d.empty())
1861                                 // make sure we don't start with an underscore,
1862                                 // as that sometimes causes problems.
1863                                 d = from_ascii("lyx_");
1864                         else
1865                                 d += '_';
1866                 } else if (isLower(c))
1867                         d += c;
1868                 else
1869                         // this is slow, so do it only if necessary
1870                         d += lowercase(c);
1871         }
1872         defaultcssclass_ = to_utf8(d);
1873         return defaultcssclass_;
1874 }
1875
1876
1877 string const & Layout::docbooktag() const
1878 {
1879         if (docbooktag_.empty()) {
1880                 if (to_ascii(name_) == "Plain Layout")
1881                         docbooktag_ = "para";
1882                 else // No sensible default value, unhappily...
1883                         docbooktag_ = to_utf8(name_);
1884         }
1885         return docbooktag_;
1886 }
1887
1888
1889 string const & Layout::docbookattr() const
1890 {
1891         // Perfectly OK to return no attributes, so docbookattr_ does not need to be filled.
1892         return docbookattr_;
1893 }
1894
1895
1896 bool isValidTagType(std::string const & type)
1897 {
1898         return !(type.empty() || (type != "block" && type != "paragraph" && type != "inline"));
1899 }
1900
1901
1902 string const & Layout::docbooktagtype() const
1903 {
1904         if (!isValidTagType(docbooktagtype_))
1905                 docbooktagtype_ = "block";
1906         return docbooktagtype_;
1907 }
1908
1909
1910 string const & Layout::docbookinnertag() const
1911 {
1912         if (docbookinnertag_.empty())
1913                 docbookinnertag_ = "NONE";
1914         return docbookinnertag_;
1915 }
1916
1917
1918 string const & Layout::docbookinnerattr() const
1919 {
1920         return docbookinnerattr_;
1921 }
1922
1923
1924 string const & Layout::docbookinnertagtype() const
1925 {
1926         if (!isValidTagType(docbookinnertagtype_))
1927                 docbookinnertagtype_ = "block";
1928         return docbookinnertagtype_;
1929 }
1930
1931
1932 string const & Layout::docbookininfo() const
1933 {
1934         // Indeed, a trilean. Only titles should be "maybe": otherwise, metadata is "always", content is "never".
1935         if (docbookininfo_.empty() || (docbookininfo_ != "never" && docbookininfo_ != "always" && docbookininfo_ != "maybe"))
1936                 docbookininfo_ = "never";
1937         return docbookininfo_;
1938 }
1939
1940
1941 string const & Layout::docbookwrappertag() const
1942 {
1943     if (docbookwrappertag_.empty())
1944         docbookwrappertag_ = "NONE";
1945     return docbookwrappertag_;
1946 }
1947
1948
1949 string const & Layout::docbookwrapperattr() const
1950 {
1951     return docbookwrapperattr_;
1952 }
1953
1954
1955 string const & Layout::docbookwrappertagtype() const
1956 {
1957         if (!isValidTagType(docbookwrappertagtype_))
1958                 docbookwrappertagtype_ = "block";
1959         return docbookwrappertagtype_;
1960 }
1961
1962
1963 string const & Layout::docbooksectiontag() const
1964 {
1965         if (docbooksectiontag_.empty())
1966                 docbooksectiontag_ = "section";
1967         return docbooksectiontag_;
1968 }
1969
1970
1971 string const & Layout::docbookitemwrappertag() const
1972 {
1973     if (docbookitemwrappertag_.empty())
1974         docbookitemwrappertag_ = "NONE";
1975     return docbookitemwrappertag_;
1976 }
1977
1978
1979 string const & Layout::docbookitemwrapperattr() const
1980 {
1981     return docbookitemwrapperattr_;
1982 }
1983
1984
1985 string const & Layout::docbookitemwrappertagtype() const
1986 {
1987         if (!isValidTagType(docbookitemwrappertagtype_))
1988                 docbookitemwrappertagtype_ = "block";
1989         return docbookitemwrappertagtype_;
1990 }
1991
1992
1993 string const & Layout::docbookitemtag() const
1994 {
1995         if (docbookitemtag_.empty())
1996                 docbookitemtag_ = "NONE";
1997         return docbookitemtag_;
1998 }
1999
2000
2001 string const & Layout::docbookitemattr() const
2002 {
2003     return docbookitemattr_;
2004 }
2005
2006
2007 string const & Layout::docbookitemtagtype() const
2008 {
2009         if (!isValidTagType(docbookitemtagtype_))
2010                 docbookitemtagtype_ = "block";
2011         return docbookitemtagtype_;
2012 }
2013
2014
2015 string const & Layout::docbookitemlabeltag() const
2016 {
2017         if (docbookitemlabeltag_.empty())
2018                 docbookitemlabeltag_ = "NONE";
2019         return docbookitemlabeltag_;
2020 }
2021
2022
2023 string const & Layout::docbookitemlabelattr() const
2024 {
2025         return docbookitemlabelattr_;
2026 }
2027
2028
2029 string const & Layout::docbookitemlabeltagtype() const
2030 {
2031         if (!isValidTagType(docbookitemlabeltagtype_))
2032                 docbookitemlabeltagtype_ = "block";
2033         return docbookitemlabeltagtype_;
2034 }
2035
2036
2037 string const & Layout::docbookiteminnertag() const
2038 {
2039         if (docbookiteminnertag_.empty())
2040                 docbookiteminnertag_ = "NONE";
2041         return docbookiteminnertag_;
2042 }
2043
2044
2045 string const & Layout::docbookiteminnerattr() const
2046 {
2047         return docbookiteminnerattr_;
2048 }
2049
2050
2051 string const & Layout::docbookiteminnertagtype() const
2052 {
2053         if (!isValidTagType(docbookiteminnertagtype_))
2054                 docbookiteminnertagtype_ = "block";
2055         return docbookiteminnertagtype_;
2056 }
2057
2058
2059 std::string const & Layout::docbookforceabstracttag() const
2060 {
2061         if (docbookforceabstracttag_.empty())
2062                 docbookforceabstracttag_ = "NONE";
2063         return docbookforceabstracttag_;
2064 }
2065
2066
2067
2068 namespace {
2069
2070 string makeMarginValue(char const * side, double d)
2071 {
2072         ostringstream os;
2073         os << "margin-" << side << ": " << d << "ex;\n";
2074         return os.str();
2075 }
2076
2077 } // namespace
2078
2079
2080 void Layout::makeDefaultCSS() const
2081 {
2082         // this never needs to be redone, since reloading layouts will
2083         // wipe out what we did before.
2084         if (!htmldefaultstyle_.empty())
2085                 return;
2086
2087         // main font
2088         htmldefaultstyle_ = font.asCSS();
2089
2090         // bottom margins
2091         string tmp;
2092         if (topsep > 0)
2093                 tmp += makeMarginValue("top", topsep);
2094         if (bottomsep > 0)
2095                 tmp += makeMarginValue("bottom", bottomsep);
2096         if (!leftmargin.empty()) {
2097                 // we can't really do what LyX does with the margin, so
2098                 // we'll just figure out how many characters it is
2099                 int const len = leftmargin.length();
2100                 tmp += makeMarginValue("left", len);
2101         }
2102         if (!rightmargin.empty()) {
2103                 int const len = rightmargin.length();
2104                 tmp += makeMarginValue("right", len);
2105         }
2106
2107         if (!tmp.empty()) {
2108                 if (!htmldefaultstyle_.empty())
2109                         htmldefaultstyle_ += from_ascii("\n");
2110                 htmldefaultstyle_ += from_ascii(tmp);
2111         }
2112
2113         // alignment
2114         string where = alignmentToCSS(align);
2115         if (!where.empty()) {
2116                 htmldefaultstyle_ += from_ascii("text-align: " + where + ";\n");
2117         }
2118
2119         // wrap up what we have, if anything
2120         if (!htmldefaultstyle_.empty())
2121                 htmldefaultstyle_ =
2122                         from_ascii(htmltag() + "." + defaultCSSClass() + " {\n") +
2123                         htmldefaultstyle_ + from_ascii("\n}\n");
2124
2125         if (labeltype == LABEL_NO_LABEL || htmllabeltag() == "NONE")
2126                 return;
2127
2128         docstring labelCSS;
2129
2130         // label font
2131         if (labelfont != font)
2132                 labelCSS = labelfont.asCSS() + from_ascii("\n");
2133         if (labeltype == LABEL_CENTERED)
2134                 labelCSS += from_ascii("text-align: center;\n");
2135
2136         if (!labelCSS.empty())
2137                 htmldefaultstyle_ +=
2138                         from_ascii(htmllabeltag() + "." + defaultCSSLabelClass() + " {\n") +
2139                         labelCSS + from_ascii("\n}\n");
2140 }
2141
2142
2143 bool Layout::operator==(Layout const & rhs) const
2144 {
2145         // This is enough for the applications we actually make,
2146         // at least at the moment. But we could check more.
2147         return name() == rhs.name()
2148                 && latexname() == rhs.latexname()
2149                 && latextype == rhs.latextype;
2150 }
2151
2152
2153 } // namespace lyx