X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FLayout.h;h=0c0b4ae0ef89f29a88c3ffafa16b6474077ecb9d;hb=a4d9315bc49445e4419b3b59fd238a13c5f7be31;hp=1db9a23a386896ac0248fb08df98c33a34506154;hpb=07b2898afe28f64f4f6f16e16351d90408927ec5;p=lyx.git diff --git a/src/Layout.h b/src/Layout.h index 1db9a23a38..0c0b4ae0ef 100644 --- a/src/Layout.h +++ b/src/Layout.h @@ -14,19 +14,20 @@ #ifndef LAYOUT_H #define LAYOUT_H -#include "Encoding.h" #include "FontInfo.h" #include "LayoutEnums.h" #include "Spacing.h" +#include "support/debug.h" #include "support/docstring.h" +#include #include #include namespace lyx { -class Language; -class Lexer; +namespace support { class Lexer; } + class TextClass; /* Fixed labels are printed flushright, manual labels flushleft. @@ -58,21 +59,25 @@ public: void setUnknown(bool unknown) { unknown_ = unknown; } /// Reads a layout definition from file /// \return true on success. - bool read(Lexer &, TextClass const &); + bool read(support::Lexer &, TextClass const &, bool validating = false); + /// + void readAlign(support::Lexer &); /// - void readAlign(Lexer &); + void readAlignPossible(support::Lexer &); /// - void readAlignPossible(Lexer &); + void readLabelType(support::Lexer &); /// - void readLabelType(Lexer &); + void readEndLabelType(support::Lexer &); /// - void readEndLabelType(Lexer &); + void readMargin(support::Lexer &); /// - void readMargin(Lexer &); + void readLatexType(support::Lexer &); /// - void readLatexType(Lexer &); + void readSpacing(support::Lexer &); /// - void readSpacing(Lexer &); + void readArgument(support::Lexer &, bool); + /// Write a layout definition in utf8 encoding + void write(std::ostream &) const; /// docstring const & name() const { return name_; } /// @@ -84,9 +89,67 @@ public: /// std::string const & latexname() const { return latexname_; } /// - void setLatexName(std::string const & n) { latexname_ = n; } - /// - docstring const & labelstring(bool in_appendix) const + std::string const & itemcommand() const { return itemcommand_; } + /// One argument of this layout + struct latexarg { + docstring labelstring; + docstring menustring; + bool mandatory = false; + bool nodelims = false; + docstring ldelim; + docstring rdelim; + docstring defaultarg; + docstring presetarg; + docstring tooltip; + std::string required; + std::string decoration; + FontInfo font = inherit_font; + FontInfo labelfont = inherit_font; + bool autoinsert = false; + bool insertcotext = false; + bool insertonnewline = false; + ArgPassThru passthru = PT_INHERITED; + docstring pass_thru_chars; + bool is_toc_caption = false; + bool free_spacing = false; + std::string newlinecmd; + /// The DocBook tag corresponding to this argument. + docstring docbooktag; + docstring docbooktagtype; + docstring docbookattr; + /// Whether this argument should be output after the main tag (default: inside). The result if the argument + /// should be output both before and after the main tag is undefined. + bool docbookargumentbeforemaintag = false; + /// Whether this argument should be output before the main tag (default: inside). The result if the argument + /// should be output both before and after the main tag is undefined. + bool docbookargumentaftermaintag = false; + }; + /// + typedef std::map LaTeXArgMap; + /// + LaTeXArgMap const & latexargs() const { return latexargs_; } + /// + LaTeXArgMap const & postcommandargs() const { return postcommandargs_; } + /// + LaTeXArgMap const & listpreamble() const { return listpreamble_; } + /// + LaTeXArgMap const & itemargs() const { return itemargs_; } + /// Returns true is the layout has arguments. If false, then an + /// InsetArgument in this layout stands for the parent InsetText. + bool hasArgs() const; + /// Returns latexargs() + postcommandargs() + itemargs(). + /// But note that it returns a *copy*, not a reference, so do not do + /// anything like: + /// Layout::LaTeXArgMap::iterator it = args().begin(); + /// Layout::LaTeXArgMap::iterator en = args().end(); + /// Those are iterators for different containers. + LaTeXArgMap args() const; + /// + int optArgs() const; + /// + int requiredArgs() const; + /// + docstring const & labelstring(bool in_appendix) const { return in_appendix ? labelstring_appendix_ : labelstring_; } /// docstring const & endlabelstring() const { return endlabelstring_; } @@ -96,43 +159,115 @@ public: docstring const & preamble() const { return preamble_; } /// Get language dependent macro definitions needed for this layout /// for language \p lang - docstring const langpreamble(Language const * lang, Encoding const & enc, bool const polyglossia) const; + docstring const langpreamble() const { return langpreamble_; } /// Get language and babel dependent macro definitions needed for /// this layout for language \p lang - docstring const babelpreamble(Language const * lang, Encoding const & enc, bool const polyglossia) const; + docstring const babelpreamble() const { return babelpreamble_; } + /// + std::set const & required() const { return required_; } + /// + std::set const & autonests() const { return autonests_; } /// - std::set const & requires() const { return requires_; } + std::set const & isAutonestedBy() const { return autonested_by_; } /// std::string const & latexparam() const { return latexparam_; } /// + docstring leftdelim() const { return leftdelim_; } + /// + docstring rightdelim() const { return rightdelim_; } + /// std::string const & innertag() const { return innertag_; } /// std::string const & labeltag() const { return labeltag_; } /// std::string const & itemtag() const { return itemtag_; } - /// + /// std::string const & htmltag() const; - /// - std::string const & htmlattr() const; - /// + /// + std::string const & htmlattr() const { return htmlattr_; } + /// + std::string const & htmlclass() const; + /// Returns a complete attribute string, including class, etc. + std::string const & htmlGetAttrString() const; + /// std::string const & htmlitemtag() const; - /// + /// std::string const & htmlitemattr() const; - /// + /// std::string const & htmllabeltag() const; - /// + /// std::string const & htmllabelattr() const; /// + bool htmlintoc() const { return htmlintoc_; } + /// std::string defaultCSSClass() const; /// bool htmllabelfirst() const { return htmllabelfirst_; } - /// + /// docstring htmlstyle() const; - /// + /// docstring const & htmlpreamble() const { return htmlpreamble_; } /// bool htmltitle() const { return htmltitle_; } /// + std::string const & docbooktag() const; + /// + std::string const & docbookattr() const; + /// + std::string const & docbooktagtype() const; + /// + std::string const & docbookinnertag() const; + /// + std::string const & docbookinnerattr() const; + /// + std::string const & docbookinnertagtype() const; + /// + std::string const & docbookininfo() const; + /// + bool docbookabstract() const { return docbookabstract_; } + /// + std::string const & docbookwrappertag() const; + /// + std::string const & docbookwrapperattr() const; + /// + std::string const & docbookwrappertagtype() const; + /// + bool docbookwrappermergewithprevious() const { return docbookwrappermergewithprevious_; } + /// + std::string const & docbooksectiontag() const; + /// + bool docbooksection() const { return docbooksection_; } + /// + std::string const & docbookitemwrappertag() const; + /// + std::string const & docbookitemwrapperattr() const; + /// + std::string const & docbookitemwrappertagtype() const; + /// + std::string const & docbookitemlabeltag() const; + /// + std::string const & docbookitemlabelattr() const; + /// + std::string const & docbookitemlabeltagtype() const; + /// + std::string const & docbookiteminnertag() const; + /// + std::string const & docbookiteminnerattr() const; + /// + std::string const & docbookiteminnertagtype() const; + /// + std::string const & docbookitemtag() const; + /// + std::string const & docbookitemattr() const; + /// + std::string const & docbookitemtagtype() const; + /// + std::string const & docbookforceabstracttag() const; + /// + bool docbooknofontinside() const { return docbooknofontinside_; } + /// + bool docbookgeneratetitle() const { return docbookgeneratetitle_; } + /// bool isParagraph() const { return latextype == LATEX_PARAGRAPH; } /// bool isCommand() const { return latextype == LATEX_COMMAND; } @@ -143,11 +278,37 @@ public: || latextype == LATEX_ITEM_ENVIRONMENT || latextype == LATEX_LIST_ENVIRONMENT; } + /// Is this the kind of layout in which adjacent paragraphs + /// are handled as one group? + bool isParagraphGroup() const { return par_group_; } + /// + bool labelIsInline() const { + return labeltype == LABEL_STATIC + || labeltype == LABEL_SENSITIVE + || labeltype == LABEL_ENUMERATE + || labeltype == LABEL_ITEMIZE; + } + bool labelIsAbove() const { + return labeltype == LABEL_ABOVE + || labeltype == LABEL_CENTERED + || labeltype == LABEL_BIBLIO; + } + bool isNumHeadingLabelType() const { + return labeltype == LABEL_ABOVE + || labeltype == LABEL_CENTERED + || labeltype == LABEL_STATIC; + } + /// + bool addToToc() const { return add_to_toc_; } + /// + std::string tocType() const { return toc_type_; } + /// + bool isTocCaption() const { return is_toc_caption_; } /// bool operator==(Layout const &) const; /// - bool operator!=(Layout const & rhs) const + bool operator!=(Layout const & rhs) const { return !(*this == rhs); } //////////////////////////////////////////////////////////////// @@ -219,9 +380,13 @@ public: /// bool nextnoindent; /// + ToggleIndentation toggle_indent; + /// bool free_spacing; /// bool pass_thru; + /// Individual chars to be passed verbatim + docstring pass_thru_chars; /// bool parbreak_is_newline; /// show this in toc @@ -232,6 +397,12 @@ public: /** true when the fragile commands in the paragraph need to be \protect'ed. */ bool needprotect; + /** true when the verbatim stuff of this layout needs to be + \cprotect'ed. */ + bool needcprotect; + /** true when specific commands in this paragraph need to be + protected in an \mbox. */ + bool needmboxprotect; /// true when empty paragraphs should be kept. bool keepempty; /// Type of LaTeX object @@ -240,39 +411,43 @@ public: bool intitle; /// Is the content to go in the preamble rather than the body? bool inpreamble; - /// Number of requried arguments for this command or environment - unsigned int reqargs; - /// Number of optional arguments for this command or environment - /// These MUST come at the beginning, so: - /// \cmd[opt1][opt2]{req1}{here is the text from LyX} - /// is fine. But: - /// \cmd[opt1]{req1}[opt2]{here is the text from LyX} - /// is not. - unsigned int optargs; /// Which counter to step docstring counter; + /// Resume counter? + bool resumecounter; + /// Step parent counter? + bool stepparentcounter; /// Prefix to use when creating labels docstring refprefix; /// Depth of XML command int commanddepth; - /// Return a pointer on a new layout suitable to describe a caption. - /// FIXME: remove this eventually. This is only for tex2lyx - /// until it has proper support for the caption inset (JMarc) - static Layout * forCaption(); - /// Is this spellchecked? bool spellcheck; + /** + * Should this layout definition always be written to the document preamble? + * Possible values are: + * 0: Do not enforce local layout + * >=1: Enforce local layout with version forcelocal + * -1: Enforce local layout with infinite version + * On reading, the forced local layout is only used if its version + * number is greater than the version number of the same layout in the + * document class. Otherwise, it is ignored. + */ + int forcelocal; private: + /// Reads a layout definition from file + /// \return true on success. + bool readIgnoreForcelocal(support::Lexer &, TextClass const &, bool validating); /// generates the default CSS for this layout void makeDefaultCSS() const; /// std::string defaultCSSItemClass() const { return defaultCSSClass() + "_item"; } /// std::string defaultCSSLabelClass() const { return defaultCSSClass() + "_label"; } - + /// Name of the layout/paragraph environment docstring name_; @@ -304,6 +479,12 @@ private: docstring labelstring_appendix_; /// LaTeX parameter for environment std::string latexparam_; + /// Item command in lists + std::string itemcommand_; + /// Left delimiter of the content + docstring leftdelim_; + /// Right delimiter of the content + docstring rightdelim_; /// Internal tag to use (e.g., for sect header) std::string innertag_; /// Internal tag to use (e.g. to surround varentrylist label) @@ -311,23 +492,27 @@ private: /// Internal tag to surround the item text in a list. std::string itemtag_; /// The interpretation of this tag varies depending upon the latextype. - /// In an environment, it is the tag enclosing all content for this set of - /// paragraphs. So for quote, e.g,. it would be: blockquote. For itemize, + /// In an environment, it is the tag enclosing all content for this set of + /// paragraphs. So for quote, e.g,. it would be: blockquote. For itemize, /// it would be: ul. (You get the idea.) /// /// For a command, it is the tag enclosing the content of the command. /// So, for section, it might be: h2. - /// + /// /// For the paragraph type, it is the tag that will enclose each paragraph. /// /// Defaults to "div". mutable std::string htmltag_; - /// Additional attributes for inclusion with the start tag. Defaults - /// to: class="layoutname". - mutable std::string htmlattr_; + /// Additional attributes for inclusion with the start tag. + /// Note that the CSS class is handled separately. + std::string htmlattr_; + /// The CSS class to use. Calculated from the layout name if not given. + mutable std::string htmlclass_; + /// cached + mutable std::string htmlfullattrs_; /// Tag for individual paragraphs in an environment. In lists, this /// would be something like "li". But it also needs to be set for - /// quotation, e.g., since the paragraphs in a quote need to be + /// quotation, e.g., since the paragraphs in a quote need to be /// in "p" tags. Default is "div". /// Note that when I said "environment", I meant it: This has no /// effect for LATEX_PARAGRAPH type layouts. @@ -336,7 +521,7 @@ private: mutable std::string htmlitemattr_; /// Tag for labels, of whatever sort. One use for this is in setting /// descriptions, in which case it would be: dt. Another use is to - /// customize the display of, say, the auto-generated label for + /// customize the display of, say, the auto-generated label for /// sections. Defaults to "span". /// If set to "NONE", this suppresses the printing of the label. mutable std::string htmllabeltag_; @@ -349,8 +534,75 @@ private: /// ... /// The latter is the default. bool htmllabelfirst_; + /// Is this to be output with the toc? + bool htmlintoc_; /// CSS information needed by this layout. docstring htmlstyle_; + /// DocBook tag corresponding to this layout. + mutable std::string docbooktag_; + /// Roles to add to docbooktag_, if any (default: none). + mutable std::string docbookattr_; + /// DocBook tag type corresponding to this layout (block, paragraph, or inline; default: block). + mutable std::string docbooktagtype_; + /// DocBook inner tag corresponding to this layout. + mutable std::string docbookinnertag_; + /// Roles to add to docbookinnertag_, if any (default: none). + mutable std::string docbookinnerattr_; + /// DocBook inner-tag type corresponding to this layout (block, paragraph, or inline; default: block). + mutable std::string docbookinnertagtype_; + /// DocBook tag corresponding to this item (mainly for lists). + mutable std::string docbookitemtag_; + /// Roles to add to docbookitemtag_, if any (default: none). + mutable std::string docbookitemattr_; + /// DocBook tag type corresponding to this item (block, paragraph, or inline; default: block). + mutable std::string docbookitemtagtype_; + /// DocBook tag corresponding to the wrapper around an item (mainly for lists). + mutable std::string docbookitemwrappertag_; + /// Roles to add to docbookitemwrappertag_, if any (default: none). + mutable std::string docbookitemwrapperattr_; + /// DocBook tag type corresponding to the wrapper around an item (block, paragraph, or inline; default: block). + mutable std::string docbookitemwrappertagtype_; + /// DocBook tag corresponding to this label (mostly for description lists; + /// labels in the common sense do not exist with DocBook). + mutable std::string docbookitemlabeltag_; + /// Roles to add to docbooklabeltag_, if any (default: none). + mutable std::string docbookitemlabelattr_; + /// DocBook tag corresponding to this label (block, paragraph, or inline; default: block). + mutable std::string docbookitemlabeltagtype_; + /// DocBook tag to add within the item, around its direct content (mainly for lists). + mutable std::string docbookiteminnertag_; + /// Roles to add to docbookiteminnertag_, if any (default: none). + mutable std::string docbookiteminnerattr_; + /// DocBook tag to add within the item, around its direct content (block, paragraph, or inline; default: block). + mutable std::string docbookiteminnertagtype_; + /// DocBook tag corresponding to this wrapper around the main tag. + mutable std::string docbookwrappertag_; + /// Roles to add to docbookwrappertag_, if any (default: none). + mutable std::string docbookwrapperattr_; + /// DocBook tag corresponding to this wrapper around the main tag (block, paragraph, or inline; default: block). + mutable std::string docbookwrappertagtype_; + /// Whether this wrapper tag may be merged with the previously opened wrapper tag. + bool docbookwrappermergewithprevious_; + /// Outer tag for this section, only if this layout represent a sectionning item, including chapters + /// (default: section). + mutable std::string docbooksectiontag_; + /// Whether this element should be considered as a section-level element in DocBook. + bool docbooksection_; + /// Whether this tag must/can/can't go into an tag (default: never, as it only makes sense for metadata). + mutable std::string docbookininfo_; + /// Whether this paragraph should be considered as abstract. Such paragraphs are output as a part of the document + /// abstract element (corresponding to the root tag). + bool docbookabstract_; + /// Whether this element (root or not) does not accept text without a section (i.e. the first text that is met + /// in LyX must be considered as the abstract if this is true); this text must be output with the specific tag + /// held by this attribute. + mutable std::string docbookforceabstracttag_; + /// Whether font tags are allowed inside this tag. + bool docbooknofontinside_ = false; + /// Whether LyX should create a title on its own, just after the wrapper tag. Typically, this parameter is required + /// because the wrapper tag requires a title (like a figure). The generated title will be similar to a LyXHTML label + /// (environment type and a number). + bool docbookgeneratetitle_ = false; /// Should we generate the default CSS for this layout, even if HTMLStyle /// has been given? Default is false. /// Note that the default CSS is output first, then the user CSS, so it is @@ -366,7 +618,7 @@ private: mutable std::string defaultcssclass_; /// This is the `category' for this layout. The following are /// recommended basic categories: FrontMatter, BackMatter, MainText, - /// Section, Starred, List, Theorem. + /// Sectioning, Starred, List, Reasoning. docstring category_; /// Macro definitions needed for this layout docstring preamble_; @@ -374,10 +626,31 @@ private: docstring langpreamble_; /// Language and babel dependent macro definitions needed for this layout docstring babelpreamble_; + /// Are adjacent paragraphs handled as one group? + bool par_group_; /// Packages needed for this layout - std::set requires_; + std::set required_; + /// Layouts that are by default nested after this one + std::set autonests_; + /// Layouts that by auto-nest this one + std::set autonested_by_; + /// + LaTeXArgMap latexargs_; + /// + LaTeXArgMap postcommandargs_; + /// + LaTeXArgMap listpreamble_; + /// + LaTeXArgMap itemargs_; + /// + bool add_to_toc_; + /// + std::string toc_type_; + /// + bool is_toc_caption_; }; + } // namespace lyx #endif