#include "InsetCode.h"
+#include "OutputParams.h"
+
#include "support/docstring.h"
#include <string>
namespace lyx {
class Lexer;
+class Buffer;
class ParamInfo {
public:
+ ///
+ ParamInfo() {}
/// Types of parameters
- /// WARNING: LATEX_KV_* `parameters' aren't really parameters at all
- /// but merely markers for where the keyval-type parameters should
- /// appear in the LaTeX output. ParamInfo::hasParam(name) therefore
- /// returns FALSE if the corresponding `parameter' is of type
- /// LATEX_KV_*.
- /// It is assumed here that there is exactly one argument that accepts
- /// the key=value pairs.
enum ParamType {
LATEX_OPTIONAL, /// normal optional argument
LATEX_REQUIRED, /// normal required argument
- LATEX_KV_OPTIONAL, /// optional argument that uses keyval
- LATEX_KV_REQUIRED, /// required argument that uses keyval
- LATEX_KEY, /// a key to be used with keyval argument
LYX_INTERNAL /// a parameter used internally by LyX
};
+ /// Special handling on output
+ enum ParamHandling {
+ HANDLING_NONE = 1, /// no special handling
+ HANDLING_ESCAPE = 2, /// escape special characters
+ HANDLING_LATEXIFY = 4, /// transform special characters to LaTeX macros
+ HANDLING_LTRIM = 8, /// trim blanks on the left
+ HANDLING_INDEX_ESCAPE = 16, /// escape makeindex special chars
+ };
///
class ParamData {
// No parameter may be named "preview", because that is a required
// flag for all commands.
public:
///
- ParamData(std::string const &, ParamType);
+ ParamData(std::string const &, ParamType, ParamHandling = HANDLING_NONE,
+ bool ignore = false,
+ docstring default_value = docstring());
///
std::string name() const { return name_; }
///
ParamType type() const { return type_; }
- /// whether this is a key for use with keyval
- bool isKey() const
- { return type_ == LATEX_KEY; }
+ ///
+ ParamHandling handling() const { return handling_; }
/// whether this is an optional LaTeX argument
- inline bool isOptional() const;
- /// whether this is a keyval argument
- inline bool isKeyValArg() const;
-#if 0
- //presently unused but perhaps useful at some point
- /// whether this is a required LaTeX argument
- bool isRequired() const
- { return type_ == ParamInfo::LATEX_REQUIRED ||
- type_ == ParamInfo::LATEX_KV_REQUIRED; }
- /// whether this is a LaTeX argument
- inline bool isLaTeXArgument() const
- { return isOptional() || isRequired(); }
-#endif
+ bool isOptional() const;
+ ///
+ bool ignore() const { return ignore_; }
+ ///
+ docstring const & defaultValue() const { return default_value_; }
///
bool operator==(ParamData const &) const;
- ///
+ ///
bool operator!=(ParamData const & rhs) const
{ return !(*this == rhs); }
private:
std::string name_;
///
ParamType type_;
+ /// do we need special handling on latex output?
+ ParamHandling handling_;
+ ///
+ bool ignore_;
+ ///
+ docstring default_value_;
};
/// adds a new parameter
- void add(std::string const & name, ParamType type);
+ /// If ignore is true, then the parameter is never saved, and is always
+ /// given the default value.
+ void add(std::string const & name, ParamType type,
+ ParamHandling = HANDLING_NONE, bool ignore = false,
+ docstring default_value = docstring());
///
bool empty() const { return info_.empty(); }
///
///
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
- /// corresponds to a `parameter' of type LATEX_KV_*; these do not
- /// really represent parameters but just argument places.
+ /// \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;
std::string insetType() const;
///
InsetCode code() const { return insetCode_; }
- ///
- void read(Lexer &);
/// Parse the command
+ void read(Lexer &);
+ ///
+ void Read(Lexer &, Buffer const *);
///
void write(std::ostream &) const;
+ ///
+ void Write(std::ostream & os, Buffer const * buf) 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
/// are cleared except those that exist also in the new command.
/// What matters here is the parameter name, not position.
void setCmdName(std::string const & n);
- /// FIXME Would be better removed, but is used in BufferView.cpp in
+ /// 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
- /// WARNING: You cannot access LATEX_KV_* arguments in this way.
- /// LyX will assert if you attempt to do so.
+ /// LyX will assert if name is not a valid parameter.
docstring const & operator[](std::string const & name) const;
/// set parameter \p name
- /// WARNING: You cannot access LATEX_KV_* arguments in this way.
- /// LyX will assert if you attempt to do so.
+ /// LyX will assert if name is not a valid parameter.
docstring & operator[](std::string const & name);
///
bool preview() const { return preview_; }
void clear();
///
static bool isCompatibleCommand(InsetCode code, std::string const & s);
-
-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);
///
- std::string getDefaultCmd(InsetCode);
+ ParamInfo const & info() const { return info_; }
///
- docstring makeKeyValArgument() const;
+ 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
projects / lyx.git / blobdiff