void readSpacing(Lexer &);
///
void readArgument(Lexer &);
+ /// Write a layout definition in utf8 encoding
+ void write(std::ostream &) const;
///
docstring const & name() const { return name_; }
///
///
std::string const & latexname() const { return latexname_; }
///
- void setLatexName(std::string const & n) { latexname_ = n; }
+ std::string const & itemcommand() const { return itemcommand_; }
/// The arguments of this layout
struct latexarg {
docstring labelstring;
+ docstring menustring;
bool mandatory;
+ bool nodelims;
docstring ldelim;
docstring rdelim;
+ docstring defaultarg;
+ docstring presetarg;
docstring tooltip;
- std::string shortcut;
- std::string requires;
+ std::string required;
+ std::string decoration;
+ FontInfo font;
+ FontInfo labelfont;
+ bool autoinsert;
+ bool insertcotext;
+ bool insertonnewline;
+ ArgPassThru passthru;
+ docstring pass_thru_chars;
+ bool is_toc_caption;
+ bool free_spacing;
+ std::string newlinecmd;
};
///
- typedef std::map<unsigned int, latexarg> LaTeXArgMap;
+ typedef std::map<std::string, latexarg> 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
+ docstring const & labelstring(bool in_appendix) const
{ return in_appendix ? labelstring_appendix_ : labelstring_; }
///
docstring const & endlabelstring() const { return endlabelstring_; }
/// this layout for language \p lang
docstring const babelpreamble() const { return babelpreamble_; }
///
- std::set<std::string> const & requires() const { return requires_; }
+ std::set<std::string> const & required() const { return required_; }
+ ///
+ std::set<docstring> const & autonests() const { return autonests_; }
+ ///
+ std::set<docstring> 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 & htmlitemtag() const;
- ///
+ ///
std::string const & htmlitemattr() const;
- ///
+ ///
std::string const & htmllabeltag() const;
- ///
+ ///
std::string const & htmllabelattr() const;
///
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 & docbookininfo() const;
+ ///
+ std::string const & docbookwrappertag() const;
+ ///
+ std::string const & docbookwrapperattr() const;
+ ///
+ bool docbookwrappermergewithprevious() const { return docbookwrappermergewithprevious_; }
+ ///
+ std::string const & docbooksectiontag() const;
+ ///
+ std::string const & docbookitemwrappertag() const;
+ ///
+ std::string const & docbookitemwrapperattr() const;
+ ///
+ std::string const & docbookitemlabeltag() const;
+ ///
+ std::string const & docbookitemlabelattr() const;
+ ///
+ std::string const & docbookiteminnertag() const;
+ ///
+ std::string const & docbookiteminnerattr() const;
+ ///
+ std::string const & docbookitemtag() const;
+ ///
+ std::string const & docbookitemattr() const;
+ ///
+ std::string const & docbookforceabstracttag() const;
+ ///
bool isParagraph() const { return latextype == LATEX_PARAGRAPH; }
///
bool isCommand() const { return latextype == LATEX_COMMAND; }
|| 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 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); }
////////////////////////////////////////////////////////////////
///
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
/** 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
bool inpreamble;
/// Which counter to step
docstring counter;
+ /// Resume counter?
+ bool resumecounter;
+ /// Step master counter?
+ bool stepmastercounter;
/// Prefix to use when creating labels
docstring refprefix;
/// Depth of XML command
/// 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(Lexer &, TextClass const &);
/// 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_;
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., <title></title> for sect header)
std::string innertag_;
/// Internal tag to use (e.g. to surround varentrylist label)
/// 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 htmlattr_;
/// 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.
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_;
bool htmllabelfirst_;
/// 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 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 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 corresponding to this label (only 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 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 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_;
+ /// 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 tag must/can/can't go into an <info> tag (default: never, as it only makes sense for metadata).
+ mutable std::string docbookininfo_;
+ /// 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_;
/// 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
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_;
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<std::string> requires_;
+ std::set<std::string> required_;
+ /// Layouts that are by default nested after this one
+ std::set<docstring> autonests_;
+ /// Layouts that by auto-nest this one
+ std::set<docstring> 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
projects / lyx.git / blobdiff