X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferParams.h;h=1e8b5b00f17205ca99c3c2b100d508cab2892ef8;hb=cb6c183225a51322a3b7ee9b4b97884f38d6e5cf;hp=5e6fccd82bf709c204668c1932c0849141dc5241;hpb=f1cba8ff64b369792fd49f5ddf90e8126ab476ac;p=lyx.git diff --git a/src/BufferParams.h b/src/BufferParams.h index 5e6fccd82b..1e8b5b00f1 100644 --- a/src/BufferParams.h +++ b/src/BufferParams.h @@ -15,35 +15,38 @@ #ifndef BUFFERPARAMS_H #define BUFFERPARAMS_H -#include "Font.h" +#include "Author.h" #include "Citation.h" +#include "DocumentClassPtr.h" +#include "Format.h" +#include "LayoutModuleList.h" +#include "OutputParams.h" #include "paper.h" #include "insets/InsetQuotes.h" #include "support/copied_ptr.h" -#include -#include +#include #include namespace lyx { namespace support { class FileName; } -class AuthorList; class BranchList; class Bullet; class DocumentClass; class Encoding; +class Font; +class IndicesList; class Language; -class LatexFeatures; class LayoutFile; class LayoutFileIndex; +class Length; class Lexer; class PDFOptions; class Spacing; -class TexRow; class VSpace; /** Buffer parameters. @@ -53,8 +56,6 @@ class VSpace; */ class BufferParams { public: - /// - typedef std::list LayoutModuleList; /// enum ParagraphSeparation { /// @@ -74,85 +75,154 @@ public: support::FileName const & filepath); /// - void writeFile(std::ostream &) const; + void writeFile(std::ostream &, Buffer const *) const; /// check what features are implied by the buffer parameters. void validate(LaTeXFeatures &) const; - /** \returns true if the babel package is used (interogates - * the BufferParams and a LyXRC variable). + /** \returns true if the babel package is used (interrogates + * the BufferParams, a LyXRC variable, and the document class). * This returned value can then be passed to the insets... */ - bool writeLaTeX(odocstream &, LaTeXFeatures &, TexRow &) const; + bool writeLaTeX(otexstream &, LaTeXFeatures &, + support::FileName const &) const; /// void useClassDefaults(); /// bool hasClassDefaults() const; + /// + Length const & getParIndent() const; + /// + void setParIndent(Length const & indent); /// VSpace const & getDefSkip() const; /// void setDefSkip(VSpace const & vs); + /// + Length const & getMathIndent() const; + /// + void setMathIndent(Length const & indent); + + /// Whether formulas are indented + bool is_math_indent; + + + enum MathNumber { DEFAULT, LEFT, RIGHT }; + /// number formulas on left/right/default + MathNumber math_numbering_side; + + /// Convenience function for display: like math_number, but + /// DEFAULT is replaced by the best guess we have. + MathNumber getMathNumber() const; + /** Whether paragraphs are separated by using a indent like in * articles or by using a little skip like in letters. */ ParagraphSeparation paragraph_separation; /// - InsetQuotes::QuoteLanguage quotes_language; + InsetQuotesParams::QuoteStyle quotes_style; /// - InsetQuotes::QuoteTimes quotes_times; + bool dynamic_quotes; /// std::string fontsize; - ///Get the LayoutFile this document is using. + /// Get the LayoutFile this document is using. LayoutFile const * baseClass() const; /// LayoutFileIndex const & baseClassID() const; /// Set the LyX layout file this document is using. - /// NOTE: This does not call makeDocumentClass() to update the local + /// NOTE: This does not call makeDocumentClass() to update the local /// DocumentClass. That needs to be done manually. - /// \param filename the name of the layout file - bool setBaseClass(std::string const & classname); + /// \param classname: the name of the layout file + /// \param path: non-empty only for local layout files + bool setBaseClass(std::string const & classname, + std::string const & path = std::string()); /// Adds the module information to the baseClass information to /// create our local DocumentClass. - void makeDocumentClass(); + /// NOTE: This should NEVER be called externally unless one immediately goes + /// on to class BufferView::updateDocumentClass(). The exception, of course, + /// is in GuiDocument, where we use a BufferParams simply to hold a copy of + /// the parameters from the active Buffer. + void makeDocumentClass(bool const clone = false); /// Returns the DocumentClass currently in use: the BaseClass as modified /// by modules. DocumentClass const & documentClass() const; - /// \return A pointer to the DocumentClass currently in use: the BaseClass - /// as modified by modules. - DocumentClass const * documentClassPtr() const; + /// \return A pointer to the DocumentClass currently in use: the BaseClass + /// as modified by modules. + DocumentClassConstPtr documentClassPtr() const; /// This bypasses the baseClass and sets the textClass directly. /// Should be called with care and would be better not being here, /// but it seems to be needed by CutAndPaste::putClipboard(). - void setDocumentClass(DocumentClass const * const); + void setDocumentClass(DocumentClassConstPtr); /// List of modules in use - LayoutModuleList const & getModules() const { return layoutModules_; } + LayoutModuleList const & getModules() const { return layout_modules_; } /// List of default modules the user has removed - std::set const & getRemovedModules() const - { return removedModules_; } + std::list const & getRemovedModules() const + { return removed_modules_; } /// /// Add a module to the list of modules in use. This checks only that the - /// module is not already in the list, so use moduleIsCompatible first if - /// you want to check for compatibility. + /// module is not already in the list, so use layoutModuleCanBeAdeed first + /// if you want to check for compatibility. /// \return true if module was successfully added. bool addLayoutModule(std::string const & modName); /// checks to make sure module's requriements are satisfied, that it does /// not conflict with already-present modules, isn't already loaded, etc. - bool moduleCanBeAdded(std::string const & modName) const; + bool layoutModuleCanBeAdded(std::string const & modName) const; /// - void addRemovedModule(std::string const & modName) - { removedModules_.insert(modName); } + void addRemovedModule(std::string const & modName) + { removed_modules_.push_back(modName); } /// Clear the list - void clearLayoutModules() { layoutModules_.clear(); } + void clearLayoutModules() { layout_modules_.clear(); } /// Clear the removed module list - void clearRemovedModules() { removedModules_.clear(); } + void clearRemovedModules() { removed_modules_.clear(); } + /// Get the local layouts + docstring getLocalLayout(bool forced) const; + /// Set the local layouts + void setLocalLayout(docstring const & layout, bool forced); + + /// returns \c true if the buffer contains a LaTeX document + bool isLatex() const; + /// returns \c true if the buffer contains a DocBook document + bool isDocBook() const; + /// returns \c true if the buffer contains a Wed document + bool isLiterate() const; + + /// return the format of the buffer on a string + std::string bufferFormat() const; + /// return the default output format of the current backend + std::string getDefaultOutputFormat() const; + /// return the output flavor of \p format or the default + OutputParams::FLAVOR getOutputFlavor( + std::string const & format = std::string()) const; + /// + bool isExportable(std::string const & format, bool need_viewable) const; + /// + std::vector const & exportableFormats(bool only_viewable) const; + /// the backends appropriate for use with this document. + /// so, e.g., latex is excluded , if we're using non-TeX fonts + std::vector backends() const; + + /// List of included children (for includeonly) + std::list const & getIncludedChildren() const + { return included_children_; } + /// + void addIncludedChildren(std::string const & child) + { included_children_.push_back(child); } + /// Clear the list of included children + void clearIncludedChildren() { included_children_.clear(); } + + /// update aux files of unincluded children (with \includeonly) + bool maintain_unincluded_children; /// returns the main font for the buffer (document) Font const getFont() const; - /* this are for the PaperLayout */ + /// translate quote style string to enum value + InsetQuotesParams::QuoteStyle getQuoteStyle(std::string const & qs) const; + + /* these are for the PaperLayout */ /// the papersize PAPER_SIZE papersize; /// @@ -182,25 +252,53 @@ public: /* some LaTeX options */ /// The graphics driver - std::string graphicsDriver; + std::string graphics_driver; + /// The default output format + std::string default_output_format; + /// customized bibliography processor + std::string bibtex_command; + /// customized index processor + std::string index_command; + /// font encoding(s) requested for this document + std::string fontenc; + /// the rm font: [0] for TeX fonts, [1] for non-TeX fonts + std::string fonts_roman[2]; /// the rm font - std::string fontsRoman; + std::string const & fontsRoman() const { return fonts_roman[useNonTeXFonts]; } + /// the sf font: [0] for TeX fonts, [1] for non-TeX fonts + std::string fonts_sans[2]; /// the sf font - std::string fontsSans; + std::string const & fontsSans() const { return fonts_sans[useNonTeXFonts]; } + /// the tt font: [0] for TeX fonts, [1] for non-TeX fonts + std::string fonts_typewriter[2]; /// the tt font - std::string fontsTypewriter; + std::string const & fontsTypewriter() const { return fonts_typewriter[useNonTeXFonts]; } + /// the math font: [0] for TeX fonts, [1] for non-TeX fonts + std::string fonts_math[2]; + /// the math font + std::string const & fontsMath() const { return fonts_math[useNonTeXFonts]; } /// the default family (rm, sf, tt) - std::string fontsDefaultFamily; + std::string fonts_default_family; + /// use the fonts of the OS (OpenType, True Type) directly + bool useNonTeXFonts; /// use expert Small Caps - bool fontsSC; + bool fonts_expert_sc; /// use Old Style Figures - bool fontsOSF; + bool fonts_old_figures; + /// the scale factor of the sf font: [0] for TeX fonts, [1] for non-TeX fonts + int fonts_sans_scale[2]; /// the scale factor of the sf font - int fontsSansScale; + int fontsSansScale() const { return fonts_sans_scale[useNonTeXFonts]; } + /// the scale factor of the tt font: [0] for TeX fonts, [1] for non-TeX fonts + int fonts_typewriter_scale[2]; /// the scale factor of the tt font - int fontsTypewriterScale; + int fontsTypewriterScale() const { return fonts_typewriter_scale[useNonTeXFonts]; } /// the font used by the CJK command - std::string fontsCJK; + std::string fonts_cjk; + /// use LaTeX microtype package + bool use_microtype; + /// use font ligatures for en- and em-dashes + bool use_dash_ligatures; /// Spacing & spacing(); Spacing const & spacing() const; @@ -210,32 +308,41 @@ public: int tocdepth; /// Language const * language; + /// language package + std::string lang_package; /// BranchList: BranchList & branchlist(); BranchList const & branchlist() const; + /// IndicesList: + IndicesList & indiceslist(); + IndicesList const & indiceslist() const; /** - * The input encoding for LaTeX. This can be one of + * The LyX name of the input encoding for LaTeX. This can be one of * - \c auto: find out the input encoding from the used languages * - \c default: ditto - * - any encoding supported by the inputenc package + * - any encoding defined in the file lib/encodings * The encoding of the LyX file is always utf8 and has nothing to * do with this setting. * The difference between \c auto and \c default is that \c auto also - * causes loading of the inputenc package, while \c default does not. + * causes loading of the inputenc package and writes a \inputenc{} command + * to the file when switching to another encoding, while \c default does not. * \c default will not work unless the user takes additional measures * (such as using special environments like the CJK environment from * CJK.sty). - * \c default can be seen as an unspecified 8bit encoding, since LyX + * \c default can be seen as an unspecified mix of 8bit encodings, since LyX * does not interpret it in any way apart from display on screen. */ std::string inputenc; /// The main encoding used by this buffer for LaTeX output. - /// Individual pieces of text can use different encodings. + /// If the main encoding is \c auto or \c default, + /// individual pieces of text can use different encodings. + /// Output for XeTeX with 8-bit TeX fonts uses ASCII (set at runtime) + /// instead of the value returned by this function (cf. #10600). Encoding const & encoding() const; /// - std::string preamble; + std::string origin; /// - std::string local_layout; + docstring preamble; /// std::string options; /// use the class options defined in the layout? @@ -243,15 +350,35 @@ public: /// std::string master; /// + bool suppress_date; + /// std::string float_placement; /// + std::string float_alignment; + /// unsigned int columns; + /// + bool justification; /// parameters for the listings package std::string listings_params; /// PageSides sides; /// std::string pagestyle; + /// + std::string tablestyle; + /// + RGBColor backgroundcolor; + /// + bool isbackgroundcolor; + /// + RGBColor fontcolor; + /// + bool isfontcolor; + /// + RGBColor notefontcolor; + /// + RGBColor boxbgcolor; /// \param index should lie in the range 0 <= \c index <= 3. Bullet & temp_bullet(size_type index); Bullet const & temp_bullet(size_type index) const; @@ -270,28 +397,50 @@ public: /// some ERT that needs the package) package_on = 2 }; - /// Whether and how to load amsmath - Package use_amsmath; - /// Whether and how to load esint - Package use_esint; - /// - bool use_bibtopic; - /// revision tracking for this buffer ? - bool trackChanges; + /// Whether to load a package such as amsmath or esint. + Package use_package(std::string const & p) const; + /// Set whether to load a package such as amsmath or esint. + void use_package(std::string const & p, Package u); + /// All packages that can be switched on or off + static std::map const & auto_packages(); + /// Do we use the bibtopic package? + bool useBibtopic() const; + /// Split bibliography? + bool splitbib() const { return use_bibtopic; } + /// Set split bibliography + void splitbib(bool const b) { use_bibtopic = b; } + /// Do we have multiple bibliographies (by chapter etc.)? + std::string multibib; + /// Split the index? + bool use_indices; + /// Save transient properties? + bool save_transient_properties; + /// revision tracking for this buffer ? (this is a transient property) + bool track_changes; /** This param decides whether change tracking marks should be used * in output (irrespective of how these marks are actually defined; * for instance, they may differ for DVI and PDF generation) + * This is a transient property. */ - bool outputChanges; + bool output_changes; /// bool compressed; /// the author list for the document AuthorList & authors(); AuthorList const & authors() const; + void addAuthor(Author a); + + /// map of the file's author IDs to AuthorList indexes + typedef std::map AuthorMap; + AuthorMap author_map_; + + /// the buffer's active font encoding + std::string const main_font_encoding() const; + /// all font encodings requested by the prefs/document/main language. + /// This does NOT include font encodings required by secondary languages + std::vector const font_encodings() const; - /// map of the file's author IDs to buffer author IDs - std::vector author_map; /// std::string const dvips_options() const; /** The return value of paperSizeName() depends on the @@ -309,30 +458,118 @@ public: /// std::string paperSizeName(PapersizePurpose purpose) const; /// set up if and how babel is called - std::string babelCall(std::string const & lang_opts) const; + std::string babelCall(std::string const & lang_opts, bool const langoptions) const; + /// return supported drivers for specific packages + docstring getGraphicsDriver(std::string const & package) const; /// handle inputenc etc. - void writeEncodingPreamble(odocstream & os, LaTeXFeatures & features, - TexRow & texrow) const; + void writeEncodingPreamble(otexstream & os, LaTeXFeatures & features) const; + /// + std::string const parseFontName(std::string const & name) const; /// set up the document fonts - std::string const loadFonts(std::string const & rm, - std::string const & sf, std::string const & tt, - bool const & sc, bool const & osf, - int const & sfscale, int const & ttscale) const; + std::string const loadFonts(LaTeXFeatures & features) const; - /// get the appropriate cite engine (natbib handling) - CiteEngine citeEngine() const; - /// - void setCiteEngine(CiteEngine const); + /// the cite engine modules + std::string const & citeEngine() const { return cite_engine_; } + /// the type of cite engine (authoryear or numerical) + CiteEngineType const & citeEngineType() const + { return cite_engine_type_; } + /// add the module to the cite engine modules + void setCiteEngine(std::string const & eng) { cite_engine_ = eng; } + /// set the cite engine type + void setCiteEngineType(CiteEngineType const & engine_type) + { cite_engine_type_ = engine_type; } + + /// the available citation commands + std::vector citeCommands() const; + /// the available citation styles + std::vector citeStyles() const; + + /// Return the actual bibtex command (lyxrc or buffer param) + std::string const bibtexCommand() const; + + /// Are we using biblatex? + bool useBiblatex() const; + + /// Set the default BibTeX style file for the document + void setDefaultBiblioStyle(std::string const & s){ biblio_style = s; } + /// Get the default BibTeX style file from the TextClass + std::string const & defaultBiblioStyle() const; + /// whether the BibTeX style supports full author lists + bool const & fullAuthorList() const; + /// Check if a citation style is an alias to another style + std::string getCiteAlias(std::string const & s) const; + + /// Options of the bibiography package + std::string biblio_opts; + /// The biblatex bibliography style + std::string biblatex_bibstyle; + /// The biblatex citation style + std::string biblatex_citestyle; + /// Set the bib file encoding (for biblatex) + void setBibEncoding(std::string const & s) { bib_encoding = s; } + /// Get the bib file encoding (for biblatex) + std::string const & bibEncoding() const { return bib_encoding; } + /// Set encoding for individual bib file (for biblatex) + void setBibFileEncoding(std::string const & file, std::string const & enc); + /// + std::string const bibFileEncoding(std::string const & file) const; /// options for pdf output PDFOptions & pdfoptions(); PDFOptions const & pdfoptions() const; + // do not change these values. we rely upon them. + enum MathOutput { + MathML = 0, + HTML = 1, + Images = 2, + LaTeX = 3 + }; + /// what to use for math output. present choices are above + MathOutput html_math_output; + /// whether to attempt to be XHTML 1.1 compliant or instead be + /// a little more mellow + bool html_be_strict; + /// + double html_math_img_scale; + /// + double display_pixel_ratio; + /// + std::string html_latex_start; + /// + std::string html_latex_end; + /// + bool html_css_as_file; + /// allow the LaTeX backend to run external programs + bool shell_escape; + /// generate output usable for reverse/forward search + bool output_sync; + /// custom LaTeX macro from user instead our own + std::string output_sync_macro; + /// use refstyle? or prettyref? + bool use_refstyle; + /// use minted? or listings? + bool use_minted; + //output line numbering + bool use_lineno; + //optional params for lineno package + std::string lineno_opts; + + /// Return true if language could be set to lang, + /// otherwise return false and do not change language + bool setLanguage(std::string const & lang); + /// + void invalidateConverterCache() const; + /// Copies over some of the settings from \param bp, + /// namely the ones need by Advanced F&R. We don't want + /// to copy them all, e.g., not the default master. + void copyForAdvFR(BufferParams const & bp); + private: /// void readPreamble(Lexer &); /// - void readLocalLayout(Lexer &); + void readLocalLayout(Lexer &, bool); /// void readLanguage(Lexer &); /// @@ -345,29 +582,44 @@ private: void readModules(Lexer &); /// void readRemovedModules(Lexer &); - /// Called when the document class changes. Removes modules - /// excluded by, provided by, etc, the document class. - /// \return true if modules were consistent, false if changes had - /// to be made. - bool removeBadModules(); - /// Adds default modules, if they're addable. - void addDefaultModules(); - /// checks for consistency among modules: makes sure requirements - /// are met, no modules exclude one another, etc, and resolves any - /// such conflicts, leaving us with a consistent collection. - /// \return true if modules were consistent, false if changes had - /// to be made. - bool checkModuleConsistency(); - - /// for use with natbib - CiteEngine cite_engine_; - /// - DocumentClass * doc_class_; - /// - LayoutModuleList layoutModules_; + /// + void readIncludeonly(Lexer &); + /// A cache for the default flavors + typedef std::map DefaultFlavorCache; + /// + mutable DefaultFlavorCache default_flavors_; + /// the cite engine + std::string cite_engine_; + /// the type of cite engine (authoryear or numerical) + CiteEngineType cite_engine_type_; + /// the default BibTeX style file for the document + std::string biblio_style; + /// The main encoding of the bib files, for Biblatex + std::string bib_encoding; + /// Individual file encodings, for Biblatex + std::map bib_encodings; + /// Split bibliography? + bool use_bibtopic; + /// + DocumentClassPtr doc_class_; + /// + LayoutModuleList layout_modules_; /// this is for modules that are required by the document class but that /// the user has chosen not to use - std::set removedModules_; + std::list removed_modules_; + /// The local layouts without the forced ones + docstring local_layout_; + /// Forced local layouts only for reading (use getLocalLayout() instead) + docstring forced_local_layout_; + + /// the list of included children (for includeonly) + std::list included_children_; + + typedef std::map PackageMap; + /** Whether and how to load packages like amsmath, esint, mhchem, + * mathdots, stackrel, stmaryrd and undertilde. + */ + PackageMap use_packages; /** Use the Pimpl idiom to hide those member variables that would otherwise * drag in other header files. @@ -379,7 +631,6 @@ private: static void destroy(Impl *); }; support::copied_ptr pimpl_; - }; } // namespace lyx