X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FLayout.h;h=ba4d26fb37c76a475a280f1bf2a91c5bde7615a0;hb=28be7d552f62cc02fa86d7f79201d089bfb2d7b5;hp=ee5905f141490de89a2050e5f765dfce626a3005;hpb=82309f0c2df9a10a119e3f3d5ce97c81b3113d69;p=lyx.git diff --git a/src/Layout.h b/src/Layout.h index ee5905f141..ba4d26fb37 100644 --- a/src/Layout.h +++ b/src/Layout.h @@ -4,162 +4,37 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author Jean-Marc Lasgouttes - * \author André Pönitz + * \author André Pönitz * * Full author contact details are available in file CREDITS. */ -#ifndef LYX_LAYOUT_H -#define LYX_LAYOUT_H +#ifndef LAYOUT_H +#define LAYOUT_H -#include "Font.h" +#include "FontInfo.h" +#include "LayoutEnums.h" #include "Spacing.h" +#include "support/debug.h" #include "support/docstring.h" +#include +#include #include - namespace lyx { class Lexer; class TextClass; - -/// The different output types -enum OutputType { - /// - LATEX = 1, - /// - DOCBOOK, - /// - LITERATE -}; - - -/// The different margin types -enum LYX_MARGIN_TYPE { - /// - MARGIN_MANUAL = 1, - /// - MARGIN_FIRST_DYNAMIC, - /// - MARGIN_DYNAMIC, - /// - MARGIN_STATIC, - /// - MARGIN_RIGHT_ADDRESS_BOX -}; - - -/// -enum LyXAlignment { - /// - LYX_ALIGN_NONE = 0, - /// - LYX_ALIGN_BLOCK = 1, - /// - LYX_ALIGN_LEFT = 2, - /// - LYX_ALIGN_RIGHT = 4, - /// - LYX_ALIGN_CENTER = 8, - /// - LYX_ALIGN_LAYOUT = 16, - /// - LYX_ALIGN_SPECIAL = 32 -}; - -/// -inline -void operator|=(LyXAlignment & la1, LyXAlignment la2) { - la1 = static_cast(la1 | la2); -} - - -/// -inline -LyXAlignment operator|(LyXAlignment la1, LyXAlignment la2) { - return static_cast(static_cast(la1) | static_cast(la2)); -} - - -/// The different LaTeX-Types -enum LYX_LATEX_TYPES { - /// - LATEX_PARAGRAPH = 1, - /// - LATEX_COMMAND, - /// - LATEX_ENVIRONMENT, - /// - LATEX_ITEM_ENVIRONMENT, - /// - LATEX_BIB_ENVIRONMENT, - /// - LATEX_LIST_ENVIRONMENT -}; - - -/// The different title types -enum LYX_TITLE_LATEX_TYPES { - /// - TITLE_COMMAND_AFTER = 1, - /// - TITLE_ENVIRONMENT -}; - - -/// The different label types -enum LYX_LABEL_TYPES { - /// - LABEL_NO_LABEL, - /// - LABEL_MANUAL, - /// - LABEL_BIBLIO, - /// - LABEL_TOP_ENVIRONMENT, - /// - LABEL_CENTERED_TOP_ENVIRONMENT, - - // the flushright labels following now must start with LABEL_STATIC - /// - LABEL_STATIC, - /// - LABEL_SENSITIVE, - /// - LABEL_COUNTER, - /// - LABEL_ENUMERATE, - /// - LABEL_ITEMIZE -}; - - -/// -enum LYX_END_LABEL_TYPES { - /// - END_LABEL_NO_LABEL, - /// - END_LABEL_BOX, - /// - END_LABEL_FILLED_BOX, - /// - END_LABEL_STATIC, - /// - END_LABEL_ENUM_FIRST = END_LABEL_NO_LABEL, - /// - END_LABEL_ENUM_LAST = END_LABEL_STATIC -}; - -/* Fix labels are printed flushright, manual labels flushleft. +/* Fixed labels are printed flushright, manual labels flushleft. * MARGIN_MANUAL and MARGIN_FIRST_DYNAMIC are *only* for LABEL_MANUAL, * MARGIN_DYNAMIC and MARGIN_STATIC are *not* for LABEL_MANUAL. * This seems a funny restriction, but I think other combinations are * not needed, so I will not change it yet. - * Correction: MARGIN_FIRST_DYNAMIC also usable with LABEL_STATIC + * Correction: MARGIN_FIRST_DYNAMIC also usable with LABEL_STATIC. */ @@ -178,7 +53,11 @@ class Layout { public: /// Layout(); - /// + /// is this layout a default layout created for an unknown layout + bool isUnknown() const { return unknown_; } + void setUnknown(bool unknown) { unknown_ = unknown; } + /// Reads a layout definition from file + /// \return true on success. bool read(Lexer &, TextClass const &); /// void readAlign(Lexer &); @@ -195,59 +74,182 @@ public: /// void readSpacing(Lexer &); /// - docstring const & name() const; + void readArgument(Lexer &); + /// Write a layout definition in utf8 encoding + void write(std::ostream &) const; + /// + docstring const & name() const { return name_; } /// - void setName(docstring const & n); + void setName(docstring const & n) { name_ = n; } /// - docstring const & obsoleted_by() const; + docstring const & obsoleted_by() const { return obsoleted_by_; } /// - docstring const & depends_on() const; + docstring const & depends_on() const { return depends_on_; } /// std::string const & latexname() const { return latexname_; } /// - docstring const & labelstring() const { return labelstring_; } + std::string const & itemcommand() const { return itemcommand_; } + /// The arguments of this layout + struct latexarg { + docstring labelstring; + docstring menustring; + bool mandatory; + docstring ldelim; + docstring rdelim; + docstring defaultarg; + docstring presetarg; + docstring tooltip; + std::string requires; + std::string decoration; + FontInfo font; + FontInfo labelfont; + bool autoinsert; + bool insertcotext; + ArgPassThru passthru; + docstring pass_thru_chars; + bool is_toc_caption; + }; + /// + typedef std::map LaTeXArgMap; + /// + LaTeXArgMap const & latexargs() const { return latexargs_; } + /// + LaTeXArgMap const & postcommandargs() const { return postcommandargs_; } + /// + 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_; } /// + docstring const & category() const { return category_; } + /// docstring const & preamble() const { return preamble_; } + /// Get language dependent macro definitions needed for this layout + /// for language \p lang + docstring const langpreamble() const { return langpreamble_; } + /// Get language and babel dependent macro definitions needed for + /// this layout for language \p lang + docstring const babelpreamble() const { return babelpreamble_; } + /// + std::set const & requires() const { return requires_; } /// 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_; } + /// + bool isParagraph() const { return latextype == LATEX_PARAGRAPH; } /// - docstring const & labelstring_appendix() const { - return labelstring_appendix_; + bool isCommand() const { return latextype == LATEX_COMMAND; } + /// + bool isEnvironment() const { + return latextype == LATEX_ENVIRONMENT + || latextype == LATEX_BIB_ENVIRONMENT + || 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 + { return !(*this == rhs); } + + //////////////////////////////////////////////////////////////// + // members + //////////////////////////////////////////////////////////////// /** Default font for this layout/environment. The main font for this kind of environment. If an attribute has - Font::INHERITED_*, it means that the value is specified by + INHERITED_*, it means that the value is specified by the defaultfont for the entire layout. If we are nested, the font is inherited from the font in the environment one level - up until the font is resolved. The values Font::IGNORE_* - and Font::TOGGLE are illegal here. + up until the font is resolved. The values :IGNORE_* + and FONT_TOGGLE are illegal here. */ - Font font; + FontInfo font; /** Default font for labels. Interpretation the same as for font above */ - Font labelfont; + FontInfo labelfont; /** Resolved version of the font for this layout/environment. This is a resolved version the default font. The font is resolved against the defaultfont of the entire layout. */ - Font resfont; + FontInfo resfont; /** Resolved version of the font used for labels. This is a resolved version the label font. The font is resolved against the defaultfont of the entire layout. */ - Font reslabelfont; + FontInfo reslabelfont; /// Text that dictates how wide the left margin is on the screen docstring leftmargin; @@ -278,70 +280,49 @@ public: /// LyXAlignment alignpossible; /// - LYX_LABEL_TYPES labeltype; - /// - LYX_END_LABEL_TYPES endlabeltype; + LabelType labeltype; /// - LYX_MARGIN_TYPE margintype; + EndLabelType endlabeltype; /// - bool fill_top; - /// - bool fill_bottom; + MarginType margintype; /// bool newline_allowed; /// bool nextnoindent; /// + ToggleIndentation toggle_indent; + /// bool free_spacing; /// bool pass_thru; - /** - * Whether this layout was declared with "Environment xxx" as opposed - * to "Style xxx". This is part of some unfinished generic environment - * handling (see also InsetEnvironment) started by Andre. No layout - * that is shipped with LyX has this flag set. - * Don't confuse this with isEnvironment()! - */ - bool is_environment; + /// Individual chars to be passed verbatim + docstring pass_thru_chars; + /// + bool parbreak_is_newline; /// show this in toc int toclevel; /// special value of toclevel for non-section layouts static const int NOT_IN_TOC; - /// for new environment insets - std::string latexheader; - /// for new environment insets - std::string latexfooter; - /// for new environment insets - std::string latexparagraph; /** true when the fragile commands in the paragraph need to be \protect'ed. */ bool needprotect; /// true when empty paragraphs should be kept. bool keepempty; - /// - bool isParagraph() const { - return latextype == LATEX_PARAGRAPH; - } - /// - bool isCommand() const { - return latextype == LATEX_COMMAND; - } - /// - bool isEnvironment() const { - return (latextype == LATEX_ENVIRONMENT - || latextype == LATEX_BIB_ENVIRONMENT - || latextype == LATEX_ITEM_ENVIRONMENT - || latextype == LATEX_LIST_ENVIRONMENT); - } /// Type of LaTeX object - LYX_LATEX_TYPES latextype; + LatexType latextype; /// Does this object belong in the title part of the document? bool intitle; - /// Does this layout allow for an optional parameter? - int optionalargs; + /// Is the content to go in the preamble rather than the body? + 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 int commanddepth; @@ -350,10 +331,43 @@ public: /// 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(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_; + /// LaTeX name for environment + std::string latexname_; + + /** Is this layout the default layout for an unknown layout? If + * so, its name will be displayed as xxx (unknown). + */ + bool unknown_; + /** Name of an layout that has replaced this layout. This is used to rename a layout, while keeping backward compatibility @@ -366,8 +380,6 @@ private: */ docstring depends_on_; - /// LaTeX name for environment - std::string latexname_; /// Label string. "Abstract", "Reference", "Caption"... docstring labelstring_; /// @@ -376,14 +388,98 @@ 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 varlistentry label) + /// Internal tag to use (e.g. to surround varentrylist label) std::string labeltag_; - /// Internal tag to surround the item text in a list) + /// 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, + /// 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_; + /// 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 + /// 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 htmlitemtag_; + /// Attributes for htmlitemtag_. Default is: class="layoutname_item". + 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 + /// sections. Defaults to "span". + /// If set to "NONE", this suppresses the printing of the label. + mutable std::string htmllabeltag_; + /// Attributes for the label. Defaults to: class="layoutname_label". + mutable std::string htmllabelattr_; + /// Whether to put the label before the item, or within the item. + /// I.e., do we have (true): + /// ... + /// or instead (false): + /// ... + /// The latter is the default. + bool htmllabelfirst_; + /// CSS information needed by this layout. + docstring htmlstyle_; + /// 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 + /// possible to override what one does not want. + bool htmlforcecss_; + /// A cache for the default style info so generated. + mutable docstring htmldefaultstyle_; + /// Any other info for the HTML header. + docstring htmlpreamble_; + /// Whether this is the paragraph. + bool htmltitle_; + /// calculating this is expensive, so we cache it. + mutable std::string defaultcssclass_; + /// This is the `category' for this layout. The following are + /// recommended basic categories: FrontMatter, BackMatter, MainText, + /// Sectioning, Starred, List, Reasoning. + docstring category_; /// Macro definitions needed for this layout docstring preamble_; + /// Language dependent macro definitions needed for this layout + 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_; + /// + LaTeXArgMap latexargs_; + /// + LaTeXArgMap postcommandargs_; + /// + LaTeXArgMap itemargs_; + /// + bool add_to_toc_; + /// + std::string toc_type_; + /// + bool is_toc_caption_; };