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