Fix InsetBox::contentAlignment()

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

diff --git a/src/insets/InsetCommandParams.cpp b/src/insets/InsetCommandParams.cpp
index 5ea28ff3fcd4090257de9ed3f977292d73fd48c8..24d1afad883008cac73637bfdf2251b5aa28b376 100644 (file)
--- a/src/insets/InsetCommandParams.cpp
+++ b/src/insets/InsetCommandParams.cpp
@@ -99,8 +99,10 @@ static ParamInfo const & findInfo(InsetCode code, string const & cmdName)
 /////////////////////////////////////////////////////////////////////
 
 ParamInfo::ParamData::ParamData(std::string const & s, ParamType t,
-                               ParamHandling h)
-       : name_(s), type_(t), handling_(h)
+                                ParamHandling h, bool ignore,
+                                docstring default_value)
+       : name_(s), type_(t), handling_(h), ignore_(ignore),
+         default_value_(default_value)
 {}
 
 
@@ -130,9 +132,10 @@ bool ParamInfo::hasParam(std::string const & name) const
 
 
 void ParamInfo::add(std::string const & name, ParamType type,
-                   ParamHandling handling)
-{ 
-       info_.push_back(ParamData(name, type, handling)); 
+                    ParamHandling handling, bool ignoreval,
+                    docstring default_value)
+{
+       info_.push_back(ParamData(name, type, handling, ignoreval, default_value));
 }
 
 
@@ -144,7 +147,7 @@ bool ParamInfo::operator==(ParamInfo const & rhs) const
 }
 
 
-ParamInfo::ParamData const & 
+ParamInfo::ParamData const &
        ParamInfo::operator[](std::string const & name) const
 {
        const_iterator it = begin();
@@ -192,7 +195,7 @@ std::string InsetCommandParams::insetType() const
 string InsetCommandParams::getDefaultCmd(InsetCode code)
 {
        switch (code) {
-               case BIBITEM_CODE: 
+               case BIBITEM_CODE:
                        return InsetBibitem::defaultCommand();
                case BIBTEX_CODE:
                        return InsetBibtex::defaultCommand();
@@ -229,7 +232,7 @@ string InsetCommandParams::getDefaultCmd(InsetCode code)
 bool InsetCommandParams::isCompatibleCommand(InsetCode code, string const & s)
 {
        switch (code) {
-               case BIBITEM_CODE: 
+               case BIBITEM_CODE:
                        return InsetBibitem::isCompatibleCommand(s);
                case BIBTEX_CODE:
                        return InsetBibtex::isCompatibleCommand(s);
@@ -266,7 +269,7 @@ bool InsetCommandParams::isCompatibleCommand(InsetCode code, string const & s)
 void InsetCommandParams::setCmdName(string const & name)
 {
        if (!isCompatibleCommand(insetCode_, name)) {
-               LYXERR0("InsetCommand: Incompatible command name " << 
+               LYXERR0("InsetCommand: Incompatible command name " <<
                                name << ".");
                throw ExceptionMessage(WarningException, _("InsetCommand Error: "),
                                       _("Incompatible command name."));
@@ -296,7 +299,12 @@ void InsetCommandParams::Read(Lexer & lex, Buffer const * buffer)
        }
 
        info_ = findInfo(insetCode_, cmdName_);
-       
+
+       for (ParamInfo::ParamData const & param : info_)
+               if (param.ignore()) {
+                       params_[param.name()] = param.defaultValue();
+               }
+
        string token;
        while (lex.isOK()) {
                lex.next();
@@ -361,6 +369,8 @@ void InsetCommandParams::Write(ostream & os, Buffer const * buffer) const
        ParamInfo::const_iterator it  = info_.begin();
        ParamInfo::const_iterator end = info_.end();
        for (; it != end; ++it) {
+               if (it->ignore())
+                       continue;
                string const & name = it->name();
                string data = to_utf8((*this)[name]);
                if (!data.empty()) {
@@ -422,12 +432,22 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
                                             docstring const & command,
                                             ParamInfo::ParamHandling handling) const
 {
-       if (handling == ParamInfo::HANDLING_LATEXIFY)
+       docstring result;
+       bool ltrimmed = false;
+       // Trimming can be done on top of any of the other handlings
+       // We check this here since handling might be changed below.
+       if (handling & ParamInfo::HANDLING_LTRIM) {
+               // this is used if no other handling is done
+               result = command;
+               ltrimmed = true;
+       }
+       if (handling & ParamInfo::HANDLING_LATEXIFY
+           || handling & ParamInfo::HANDLING_INDEX_ESCAPE)
                if ((*this)["literal"] == "true")
                        handling = ParamInfo::HANDLING_NONE;
-       docstring result;
-       switch (handling) {
-       case ParamInfo::HANDLING_LATEXIFY: {
+
+       // LATEXIFY, ESCAPE and NONE are mutually exclusive
+       if (handling & ParamInfo::HANDLING_LATEXIFY) {
                // First handle backslash
                result = subst(command, from_ascii("\\"), from_ascii("\\textbackslash{}"));
                // Then get LaTeX macros
@@ -444,14 +464,15 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
                }
                // Now escape special commands
                static docstring const backslash = from_ascii("\\");
-               static char_type const chars_escape[6] = {
-                       '&', '_', '$', '%', '#', '^'};
+               int const nchars_escape = 8;
+               static char_type const chars_escape[nchars_escape] = {
+                       '&', '_', '$', '%', '#', '^', '{', '}'};
 
                if (!result.empty()) {
                        int previous;
                        // The characters in chars_name[] need to be changed to a command when
                        // they are LaTeXified.
-                       for (int k = 0; k < 6; k++)
+                       for (int k = 0; k < nchars_escape; k++)
                                for (size_t i = 0, pos;
                                        (pos = result.find(chars_escape[k], i)) != string::npos;
                                        i = pos + 2) {
@@ -466,17 +487,30 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
                                                        result.replace(pos, 1, backslash + chars_escape[k] + term);
                                }
                }
-               break;
        }
-       case ParamInfo::HANDLING_ESCAPE:
+       else if (handling & ParamInfo::HANDLING_ESCAPE)
                result = escape(command);
-               break;
-       case ParamInfo::HANDLING_NONE:
+       else if (handling & ParamInfo::HANDLING_NONE)
                result = command;
-               break;
-       } // switch
+       // INDEX_ESCAPE is independent of the others
+       if (handling & ParamInfo::HANDLING_INDEX_ESCAPE) {
+               // Now escape special commands
+               static docstring const quote = from_ascii("\"");
+               int const nchars_escape = 4;
+               static char_type const chars_escape[nchars_escape] = { '"', '@', '|', '!' };
+
+               if (!result.empty()) {
+                       // The characters in chars_name[] need to be changed to a command when
+                       // they are LaTeXified.
+                       for (int k = 0; k < nchars_escape; k++)
+                               for (size_t i = 0, pos;
+                                       (pos = result.find(chars_escape[k], i)) != string::npos;
+                                       i = pos + 2)
+                                               result.replace(pos, 1, quote + chars_escape[k]);
+               }
+       }
 
-       return result;
+       return ltrimmed ? ltrim(result) : result;
 }
 
 
@@ -510,7 +544,7 @@ docstring InsetCommandParams::getCommand(OutputParams const & runparams) const
                                        noparam = false;
                        }
                        break;
-               } 
+               }
                } //end switch
        }
        if (noparam)
@@ -523,8 +557,8 @@ docstring InsetCommandParams::getCommand(OutputParams const & runparams) const
 
 docstring InsetCommandParams::getFirstNonOptParam() const
 {
-       ParamInfo::const_iterator it = 
-               find_if(info_.begin(), info_.end(), 
+       ParamInfo::const_iterator it =
+               find_if(info_.begin(), info_.end(),
                        not1(mem_fun_ref(&ParamInfo::ParamData::isOptional)));
        LASSERT(it != info_.end(), return docstring());
        return (*this)[it->name()];
@@ -538,6 +572,9 @@ docstring const & InsetCommandParams::operator[](string const & name) const
        ParamMap::const_iterator data = params_.find(name);
        if (data == params_.end() || data->second.empty())
                return dummy;
+       ParamInfo::ParamData const & param = info_[name];
+       if (param.ignore())
+               return param.defaultValue();
        return data->second;
 }
 
@@ -546,6 +583,9 @@ docstring & InsetCommandParams::operator[](string const & name)
 {
        LATTEST(info_.hasParam(name));
        // this will add the name in release mode
+       ParamInfo::ParamData const & param = info_[name];
+       if (param.ignore())
+               params_[name] = param.defaultValue();
        return params_[name];
 }