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