src/Layout.h

   1 // -*- C++ -*-
   2 /**
   3  * \file Layout.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Lars Gullik Bjønnes
   8  * \author Jean-Marc Lasgouttes
   9  * \author André Pönitz
  10  *
  11  * Full author contact details are available in file CREDITS.
  12  */
  13
  14 #ifndef LAYOUT_H
  15 #define LAYOUT_H
  16
  17 #include "FontInfo.h"
  18 #include "LayoutEnums.h"
  19 #include "Spacing.h"
  20 #include "support/debug.h"
  21 #include "support/docstring.h"
  22
  23 #include <map>
  24 #include <set>
  25 #include <string>
  26
  27 namespace lyx {
  28
  29 class Lexer;
  30 class TextClass;
  31
  32 /* Fixed labels are printed flushright, manual labels flushleft.
  33  * MARGIN_MANUAL and MARGIN_FIRST_DYNAMIC are *only* for LABEL_MANUAL,
  34  * MARGIN_DYNAMIC and MARGIN_STATIC are *not* for LABEL_MANUAL.
  35  * This seems a funny restriction, but I think other combinations are
  36  * not needed, so I will not change it yet.
  37  * Correction: MARGIN_FIRST_DYNAMIC also usable with LABEL_STATIC.
  38  */
  39
  40
  41 /* There is a parindent and a parskip. Which one is used depends on the
  42  * paragraph_separation-flag of the text-object.
  43  * BUT: parindent is only thrown away, if a parskip is defined! So if you
  44  * want a space between the paragraphs and a parindent at the same time,
  45  * you should set parskip to zero and use topsep, parsep and bottomsep.
  46  *
  47  * The standard layout is an exception: its parindent is only set, if the
  48  * previous paragraph is standard too. Well, this is LateX and it is good!
  49  */
  50
  51 ///
  52 class Layout {
  53 public:
  54         ///
  55         Layout();
  56         /// is this layout a default layout created for an unknown layout
  57         bool isUnknown() const { return unknown_; }
  58         void setUnknown(bool unknown) { unknown_ = unknown; }
  59         /// Reads a layout definition from file
  60         /// \return true on success.
  61         bool read(Lexer &, TextClass const &);
  62         ///
  63         void readAlign(Lexer &);
  64         ///
  65         void readAlignPossible(Lexer &);
  66         ///
  67         void readLabelType(Lexer &);
  68         ///
  69         void readEndLabelType(Lexer &);
  70         ///
  71         void readMargin(Lexer &);
  72         ///
  73         void readLatexType(Lexer &);
  74         ///
  75         void readSpacing(Lexer &);
  76         ///
  77         void readArgument(Lexer &);
  78         /// Write a layout definition in utf8 encoding
  79         void write(std::ostream &) const;
  80         ///
  81         docstring const & name() const { return name_; }
  82         ///
  83         void setName(docstring const & n) { name_ = n; }
  84         ///
  85         docstring const & obsoleted_by() const { return obsoleted_by_; }
  86         ///
  87         docstring const & depends_on() const { return depends_on_; }
  88         ///
  89         std::string const & latexname() const { return latexname_; }
  90         ///
  91         std::string const & itemcommand() const { return itemcommand_; }
  92         /// The arguments of this layout
  93         struct latexarg {
  94                 docstring labelstring;
  95                 docstring menustring;
  96                 bool mandatory;
  97                 bool nodelims;
  98                 docstring ldelim;
  99                 docstring rdelim;
 100                 docstring defaultarg;
 101                 docstring presetarg;
 102                 docstring tooltip;
 103                 std::string requires;
 104                 std::string decoration;
 105                 FontInfo font;
 106                 FontInfo labelfont;
 107                 bool autoinsert;
 108                 bool insertcotext;
 109                 ArgPassThru passthru;
 110                 docstring pass_thru_chars;
 111                 bool is_toc_caption;
 112                 bool free_spacing;
 113                 std::string newlinecmd;
 114         };
 115         ///
 116         typedef std::map<std::string, latexarg> LaTeXArgMap;
 117         ///
 118         LaTeXArgMap const & latexargs() const { return latexargs_; }
 119         ///
 120         LaTeXArgMap const & postcommandargs() const { return postcommandargs_; }
 121         ///
 122         LaTeXArgMap const & listpreamble() const { return listpreamble_; }
 123         ///
 124         LaTeXArgMap const & itemargs() const { return itemargs_; }
 125         /// Returns true is the layout has arguments. If false, then an
 126         /// InsetArgument in this layout stands for the parent InsetText.
 127         bool hasArgs() const;
 128         /// Returns latexargs() + postcommandargs() + itemargs().
 129         /// But note that it returns a *copy*, not a reference, so do not do
 130         /// anything like:
 131         ///   Layout::LaTeXArgMap::iterator it = args().begin();
 132         ///   Layout::LaTeXArgMap::iterator en = args().end();
 133         /// Those are iterators for different containers.
 134         LaTeXArgMap args() const;
 135         ///
 136         int optArgs() const;
 137         ///
 138         int requiredArgs() const;
 139         ///
 140         docstring const & labelstring(bool in_appendix) const
 141         { return in_appendix ? labelstring_appendix_ : labelstring_; }
 142         ///
 143         docstring const & endlabelstring() const { return endlabelstring_; }
 144         ///
 145         docstring const & category() const { return category_; }
 146         ///
 147         docstring const & preamble() const { return preamble_; }
 148         /// Get language dependent macro definitions needed for this layout
 149         /// for language \p lang
 150         docstring const langpreamble() const { return langpreamble_; }
 151         /// Get language and babel dependent macro definitions needed for
 152         /// this layout for language \p lang
 153         docstring const babelpreamble() const { return babelpreamble_; }
 154         ///
 155         std::set<std::string> const & requires() const { return requires_; }
 156         ///
 157         std::set<docstring> const & autonests() const { return autonests_; }
 158         ///
 159         std::set<docstring> const & isAutonestedBy() const { return autonested_by_; }
 160         ///
 161         std::string const & latexparam() const { return latexparam_; }
 162         ///
 163         docstring leftdelim() const { return leftdelim_; }
 164         ///
 165         docstring rightdelim() const { return rightdelim_; }
 166         ///
 167         std::string const & innertag() const { return innertag_; }
 168         ///
 169         std::string const & labeltag() const { return labeltag_; }
 170         ///
 171         std::string const & itemtag() const { return itemtag_; }
 172         ///
 173         std::string const & htmltag() const;
 174         ///
 175         std::string const & htmlattr() const;
 176         ///
 177         std::string const & htmlitemtag() const;
 178         ///
 179         std::string const & htmlitemattr() const;
 180         ///
 181         std::string const & htmllabeltag() const;
 182         ///
 183         std::string const & htmllabelattr() const;
 184         ///
 185         std::string defaultCSSClass() const;
 186         ///
 187         bool htmllabelfirst() const { return htmllabelfirst_; }
 188         ///
 189         docstring htmlstyle() const;
 190         ///
 191         docstring const & htmlpreamble() const { return htmlpreamble_; }
 192         ///
 193         bool htmltitle() const { return htmltitle_; }
 194         ///
 195         bool isParagraph() const { return latextype == LATEX_PARAGRAPH; }
 196         ///
 197         bool isCommand() const { return latextype == LATEX_COMMAND; }
 198         ///
 199         bool isEnvironment() const {
 200                 return latextype == LATEX_ENVIRONMENT
 201                         || latextype == LATEX_BIB_ENVIRONMENT
 202                         || latextype == LATEX_ITEM_ENVIRONMENT
 203                         || latextype == LATEX_LIST_ENVIRONMENT;
 204         }
 205         /// Is this the kind of layout in which adjacent paragraphs
 206         /// are handled as one group?
 207         bool isParagraphGroup() const { return par_group_; }
 208         ///
 209         bool labelIsInline() const {
 210                 return labeltype == LABEL_STATIC
 211                         || labeltype == LABEL_SENSITIVE
 212                   || labeltype == LABEL_ENUMERATE
 213                         || labeltype == LABEL_ITEMIZE;
 214         }
 215         bool labelIsAbove() const {
 216                 return labeltype == LABEL_ABOVE
 217                         || labeltype == LABEL_CENTERED
 218                   || labeltype == LABEL_BIBLIO;
 219         }
 220         ///
 221         bool addToToc() const { return add_to_toc_; }
 222         ///
 223         std::string tocType() const { return toc_type_; }
 224         ///
 225         bool isTocCaption() const { return is_toc_caption_; }
 226
 227         ///
 228         bool operator==(Layout const &) const;
 229         ///
 230         bool operator!=(Layout const & rhs) const
 231                 { return !(*this == rhs); }
 232
 233         ////////////////////////////////////////////////////////////////
 234         // members
 235         ////////////////////////////////////////////////////////////////
 236         /** Default font for this layout/environment.
 237             The main font for this kind of environment. If an attribute has
 238             INHERITED_*, it means that the value is specified by
 239             the defaultfont for the entire layout. If we are nested, the
 240             font is inherited from the font in the environment one level
 241             up until the font is resolved. The values :IGNORE_*
 242             and FONT_TOGGLE are illegal here.
 243         */
 244         FontInfo font;
 245
 246         /** Default font for labels.
 247             Interpretation the same as for font above
 248         */
 249         FontInfo labelfont;
 250
 251         /** Resolved version of the font for this layout/environment.
 252             This is a resolved version the default font. The font is resolved
 253             against the defaultfont of the entire layout.
 254         */
 255         FontInfo resfont;
 256
 257         /** Resolved version of the font used for labels.
 258             This is a resolved version the label font. The font is resolved
 259             against the defaultfont of the entire layout.
 260         */
 261         FontInfo reslabelfont;
 262
 263         /// Text that dictates how wide the left margin is on the screen
 264         docstring leftmargin;
 265         /// Text that dictates how wide the right margin is on the screen
 266         docstring rightmargin;
 267         /// Text that dictates how much space to leave after a potential label
 268         docstring labelsep;
 269         /// Text that dictates how much space to leave before a potential label
 270         docstring labelindent;
 271         /// Text that dictates the width of the indentation of indented pars
 272         docstring parindent;
 273         ///
 274         double parskip;
 275         ///
 276         double itemsep;
 277         ///
 278         double topsep;
 279         ///
 280         double bottomsep;
 281         ///
 282         double labelbottomsep;
 283         ///
 284         double parsep;
 285         ///
 286         Spacing spacing;
 287         ///
 288         LyXAlignment align;
 289         ///
 290         LyXAlignment alignpossible;
 291         ///
 292         LabelType labeltype;
 293         ///
 294         EndLabelType endlabeltype;
 295         ///
 296         MarginType margintype;
 297         ///
 298         bool newline_allowed;
 299         ///
 300         bool nextnoindent;
 301         ///
 302         ToggleIndentation toggle_indent;
 303         ///
 304         bool free_spacing;
 305         ///
 306         bool pass_thru;
 307         /// Individual chars to be passed verbatim
 308         docstring pass_thru_chars;
 309         ///
 310         bool parbreak_is_newline;
 311         /// show this in toc
 312         int toclevel;
 313         /// special value of toclevel for non-section layouts
 314         static const int NOT_IN_TOC;
 315
 316         /** true when the fragile commands in the paragraph need to be
 317             \protect'ed. */
 318         bool needprotect;
 319         /** true when the verbatim stuff of this layout needs to be
 320             \cprotect'ed. */
 321         bool needcprotect;
 322         /** true when specific commands in this paragraph need to be
 323             protected in an \mbox. */
 324         bool needmboxprotect;
 325         /// true when empty paragraphs should be kept.
 326         bool keepempty;
 327         /// Type of LaTeX object
 328         LatexType latextype;
 329         /// Does this object belong in the title part of the document?
 330         bool intitle;
 331         /// Is the content to go in the preamble rather than the body?
 332         bool inpreamble;
 333         /// Which counter to step
 334         docstring counter;
 335         /// Resume counter?
 336         bool resumecounter;
 337         /// Step master counter?
 338         bool stepmastercounter;
 339         /// Prefix to use when creating labels
 340         docstring refprefix;
 341         /// Depth of XML command
 342         int commanddepth;
 343
 344         /// Return a pointer on a new layout suitable to describe a caption.
 345         /// FIXME: remove this eventually. This is only for tex2lyx
 346         /// until it has proper support for the caption inset (JMarc)
 347         static Layout * forCaption();
 348
 349         /// Is this spellchecked?
 350         bool spellcheck;
 351         /**
 352          * Should this layout definition always be written to the document preamble?
 353          * Possible values are:
 354          *   0: Do not enforce local layout
 355          * >=1: Enforce local layout with version forcelocal
 356          *  -1: Enforce local layout with infinite version
 357          * On reading, the forced local layout is only used if its version
 358          * number is greater than the version number of the same layout in the
 359          * document class. Otherwise, it is ignored.
 360          */
 361         int forcelocal;
 362
 363
 364 private:
 365         /// Reads a layout definition from file
 366         /// \return true on success.
 367         bool readIgnoreForcelocal(Lexer &, TextClass const &);
 368         /// generates the default CSS for this layout
 369         void makeDefaultCSS() const;
 370         ///
 371         std::string defaultCSSItemClass() const { return defaultCSSClass() + "_item"; }
 372         ///
 373         std::string defaultCSSLabelClass() const { return defaultCSSClass() + "_label"; }
 374
 375         /// Name of the layout/paragraph environment
 376         docstring name_;
 377
 378         /// LaTeX name for environment
 379         std::string latexname_;
 380
 381         /** Is this layout the default layout for an unknown layout? If
 382          * so, its name will be displayed as xxx (unknown).
 383          */
 384         bool unknown_;
 385
 386         /** Name of an layout that has replaced this layout.
 387             This is used to rename a layout, while keeping backward
 388             compatibility
 389         */
 390         docstring obsoleted_by_;
 391
 392         /** Name of an layout which preamble must come before this one
 393             This is used when the preamble snippet uses macros defined in
 394             another preamble
 395          */
 396         docstring depends_on_;
 397
 398         /// Label string. "Abstract", "Reference", "Caption"...
 399         docstring labelstring_;
 400         ///
 401         docstring endlabelstring_;
 402         /// Label string inside appendix. "Appendix", ...
 403         docstring labelstring_appendix_;
 404         /// LaTeX parameter for environment
 405         std::string latexparam_;
 406         /// Item command in lists
 407         std::string itemcommand_;
 408         /// Left delimiter of the content
 409         docstring leftdelim_;
 410         /// Right delimiter of the content
 411         docstring rightdelim_;
 412         /// Internal tag to use (e.g., <title></title> for sect header)
 413         std::string innertag_;
 414         /// Internal tag to use (e.g. to surround varentrylist label)
 415         std::string labeltag_;
 416         /// Internal tag to surround the item text in a list.
 417         std::string itemtag_;
 418         /// The interpretation of this tag varies depending upon the latextype.
 419         /// In an environment, it is the tag enclosing all content for this set of
 420         /// paragraphs. So for quote, e.g,. it would be: blockquote. For itemize,
 421         /// it would be: ul. (You get the idea.)
 422         ///
 423         /// For a command, it is the tag enclosing the content of the command.
 424         /// So, for section, it might be: h2.
 425         ///
 426         /// For the paragraph type, it is the tag that will enclose each paragraph.
 427         ///
 428         /// Defaults to "div".
 429         mutable std::string htmltag_;
 430         /// Additional attributes for inclusion with the start tag. Defaults
 431         /// to: class="layoutname".
 432         mutable std::string htmlattr_;
 433         /// Tag for individual paragraphs in an environment. In lists, this
 434         /// would be something like "li". But it also needs to be set for
 435         /// quotation, e.g., since the paragraphs in a quote need to be
 436         /// in "p" tags. Default is "div".
 437         /// Note that when I said "environment", I meant it: This has no
 438         /// effect for LATEX_PARAGRAPH type layouts.
 439         mutable std::string htmlitemtag_;
 440         /// Attributes for htmlitemtag_. Default is: class="layoutname_item".
 441         mutable std::string htmlitemattr_;
 442         /// Tag for labels, of whatever sort. One use for this is in setting
 443         /// descriptions, in which case it would be: dt. Another use is to
 444         /// customize the display of, say, the auto-generated label for
 445         /// sections. Defaults to "span".
 446         /// If set to "NONE", this suppresses the printing of the label.
 447         mutable std::string htmllabeltag_;
 448         /// Attributes for the label. Defaults to: class="layoutname_label".
 449         mutable std::string htmllabelattr_;
 450         /// Whether to put the label before the item, or within the item.
 451         /// I.e., do we have (true):
 452         ///    <label>...</label><item>...</item>
 453         /// or instead (false):
 454         ///    <item><label>...</label>...</item>
 455         /// The latter is the default.
 456         bool htmllabelfirst_;
 457         /// CSS information needed by this layout.
 458         docstring htmlstyle_;
 459         /// Should we generate the default CSS for this layout, even if HTMLStyle
 460         /// has been given? Default is false.
 461         /// Note that the default CSS is output first, then the user CSS, so it is
 462         /// possible to override what one does not want.
 463         bool htmlforcecss_;
 464         /// A cache for the default style info so generated.
 465         mutable docstring htmldefaultstyle_;
 466         /// Any other info for the HTML header.
 467         docstring htmlpreamble_;
 468         /// Whether this is the <title> paragraph.
 469         bool htmltitle_;
 470         /// calculating this is expensive, so we cache it.
 471         mutable std::string defaultcssclass_;
 472         /// This is the `category' for this layout. The following are
 473         /// recommended basic categories: FrontMatter, BackMatter, MainText,
 474         /// Sectioning, Starred, List, Reasoning.
 475         docstring category_;
 476         /// Macro definitions needed for this layout
 477         docstring preamble_;
 478         /// Language dependent macro definitions needed for this layout
 479         docstring langpreamble_;
 480         /// Language and babel dependent macro definitions needed for this layout
 481         docstring babelpreamble_;
 482         /// Are adjacent paragraphs handled as one group?
 483         bool par_group_;
 484         /// Packages needed for this layout
 485         std::set<std::string> requires_;
 486         /// Layouts that are by default nested after this one
 487         std::set<docstring> autonests_;
 488         /// Layouts that by auto-nest this one
 489         std::set<docstring> autonested_by_;
 490         ///
 491         LaTeXArgMap latexargs_;
 492         ///
 493         LaTeXArgMap postcommandargs_;
 494         ///
 495         LaTeXArgMap listpreamble_;
 496         ///
 497         LaTeXArgMap itemargs_;
 498         ///
 499         bool add_to_toc_;
 500         ///
 501         std::string toc_type_;
 502         ///
 503         bool is_toc_caption_;
 504 };
 505
 506
 507 } // namespace lyx
 508
 509 #endif