src/Layout.cpp

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