Merge branch 'master' of git.lyx.org:lyx

[lyx.git] / src / insets / InsetCommandParams.h

diff --git a/src/insets/InsetCommandParams.h b/src/insets/InsetCommandParams.h
index f80dcecf0ebbdb16041c5ffe90981259681b857d..7dc59fa5ee764fc0e46cf65d4d5a6008ee5fdb42 100644 (file)
--- a/src/insets/InsetCommandParams.h
+++ b/src/insets/InsetCommandParams.h
@@ -15,9 +15,11 @@
 #define INSETCOMMANDPARAMS_H
 
 #include "InsetCode.h"
+
+#include "OutputParams.h"
+
 #include "support/docstring.h"
 
-#include <iosfwd>
 #include <string>
 #include <vector>
 #include <map>
@@ -29,17 +31,33 @@ class Lexer;
 
 class ParamInfo {
 public:
+       /// Types of parameters
+       enum ParamType {
+               LATEX_OPTIONAL,    /// normal optional argument
+               LATEX_REQUIRED,    /// normal required argument
+               LYX_INTERNAL       /// a parameter used internally by LyX
+       };
+       /// Special handling on output
+       enum ParamHandling {
+               HANDLING_NONE,    /// no special handling
+               HANDLING_ESCAPE,  /// escape special characters
+               HANDLING_LATEXIFY /// transform special characters to LaTeX macros
+       };
        ///
        class ParamData {
        // No parameter may be named "preview", because that is a required
        // flag for all commands.
        public:
                ///
-               ParamData(std::string const &, bool);
+               ParamData(std::string const &, ParamType, ParamHandling = HANDLING_NONE);
                ///
                std::string name() const { return name_; }
                ///
-               bool isOptional() const { return optional_; }
+               ParamType type() const { return type_; }
+               ///
+               ParamHandling handling() const { return handling_; }
+               /// whether this is an optional LaTeX argument
+               bool isOptional() const;
                ///
                bool operator==(ParamData const &) const;
                /// 
@@ -49,11 +67,14 @@ public:
                ///
                std::string name_;
                ///
-               bool optional_;
+               ParamType type_;
+               /// do we need special handling on latex output?
+               ParamHandling handling_;
        };
 
        /// adds a new parameter
-       void add(std::string const & name, bool optional);
+       void add(std::string const & name, ParamType type,
+                ParamHandling = HANDLING_NONE);
        ///
        bool empty() const { return info_.empty(); }
        ///
@@ -61,12 +82,15 @@ public:
        ///
        typedef std::vector<ParamData>::const_iterator const_iterator;
        ///
-       const_iterator begin() const { return info_.begin(); }
-       ///
-       const_iterator end() const { return info_.end(); }
+       const_iterator const begin() const { return info_.begin(); }
        ///
+       const_iterator const end() const { return info_.end(); }
+       /// \return true if name corresponds to a parameter of some sort.
+       /// \return false if the parameter does not exist at all of it it 
        bool hasParam(std::string const & name) const;
        ///
+       ParamData const & operator[](std::string const & name) const;
+       ///
        bool operator==(ParamInfo const &) const;
 private:
        ///
@@ -83,7 +107,7 @@ public:
        explicit InsetCommandParams(InsetCode code,
                        std::string const & cmdName);
        ///
-       std::string insetType() const { return insetName(insetCode_); }
+       std::string insetType() const;
        ///
        InsetCode code() const { return insetCode_; }
        ///
@@ -92,7 +116,7 @@ public:
        ///
        void write(std::ostream &) const;
        /// Build the complete LaTeX command
-       docstring const getCommand() const;
+       docstring getCommand(OutputParams const &) const;
        /// Return the command name
        std::string const & getCmdName() const { return cmdName_; }
        /// Set the name to \p n. This must be a known name. All parameters
@@ -101,10 +125,12 @@ public:
        void setCmdName(std::string const & n);
        /// FIXME Would be better removed, but is used in BufferView.cpp in 
        /// ways that make removal hard.
-       docstring const getFirstNonOptParam() const;
+       docstring getFirstNonOptParam() const;
        /// get parameter \p name
+       /// LyX will assert if name is not a valid parameter.
        docstring const & operator[](std::string const & name) const;
        /// set parameter \p name
+       /// LyX will assert if name is not a valid parameter.
        docstring & operator[](std::string const & name);
        ///
        bool preview() const { return preview_; }
@@ -112,22 +138,19 @@ public:
        void preview(bool p) { preview_ = p; }
        /// Clear the values of all parameters
        void clear();
-
-private:
-       ///
-       /// Get information for inset type \p code.
-       /// Returns 0 if the inset is not known.
-       static ParamInfo const & findInfo(InsetCode code);
-       /// Get information for \p code and command \p cmdName.
-       /// Returns 0 if the combination is not known.
-       /// Don't call this without first making sure the command name is
-       /// acceptable to the inset.
-       static ParamInfo const & findInfo(InsetCode code,
-                                           std::string const & cmdName);
        ///
        static bool isCompatibleCommand(InsetCode code, std::string const & s);
+       /// 
+       ParamInfo const & info() const { return info_; };
        ///
-       std::string getDefaultCmd(InsetCode);
+       docstring prepareCommand(OutputParams const & runparams,
+               docstring const & command, ParamInfo::ParamHandling handling) const;
+private:
+       std::string getDefaultCmd(InsetCode code);
+       /// checks whether we need to write an empty optional parameter
+       /// \return true if a non-empty optional parameter follows ci
+       bool writeEmptyOptional(ParamInfo::const_iterator ci) const;
+
        /// Description of all command properties
        ParamInfo info_;
        /// what kind of inset we're the parameters for
@@ -135,6 +158,9 @@ private:
        /// The name of this command as it appears in .lyx and .tex files
        std::string cmdName_;
        ///
+       // if we need to allow more than one value for a parameter, this
+       // could be made a multimap. it may be that the only thing that
+       // would then need changing is operator[].
        typedef std::map<std::string, docstring> ParamMap;
        /// The parameters, by name.
        ParamMap params_;