Fix bug #12795

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

diff --git a/src/insets/InsetCommandParams.cpp b/src/insets/InsetCommandParams.cpp
index 24d1afad883008cac73637bfdf2251b5aa28b376..94b9a2c8a2e7897be9fce2d393e36be3ea1db3b0 100644 (file)
--- a/src/insets/InsetCommandParams.cpp
+++ b/src/insets/InsetCommandParams.cpp
@@ -5,21 +5,19 @@
  *
  * \author Angus Leeming
  * \author Georg Baum
- * \author Richard Heck
+ * \author Richard Kimberly Heck
  *
  * Full author contact details are available in file CREDITS.
  */
 
 #include <config.h>
-#include <algorithm>
-#include <functional>
-
 
 #include "InsetCommandParams.h"
 
 #include "InsetBibitem.h"
 #include "InsetBibtex.h"
 #include "InsetCitation.h"
+#include "InsetCounter.h"
 #include "InsetFloatList.h"
 #include "InsetHyperlink.h"
 #include "InsetInclude.h"
@@ -33,7 +31,6 @@
 #include "Buffer.h"
 #include "Encoding.h"
 #include "Lexer.h"
-#include "OutputParams.h"
 
 #include "frontends/alert.h"
 
@@ -45,6 +42,9 @@
 
 #include "support/lassert.h"
 
+#include <algorithm>
+#include <functional>
+
 using namespace std;
 using namespace lyx::support;
 
@@ -63,6 +63,8 @@ static ParamInfo const & findInfo(InsetCode code, string const & cmdName)
                return InsetBibtex::findInfo(cmdName);
        case CITE_CODE:
                return InsetCitation::findInfo(cmdName);
+       case COUNTER_CODE:
+               return InsetCounter::findInfo(cmdName);
        case FLOAT_LIST_CODE:
                return InsetFloatList::findInfo(cmdName);
        case HYPERLINK_CODE:
@@ -201,6 +203,8 @@ string InsetCommandParams::getDefaultCmd(InsetCode code)
                        return InsetBibtex::defaultCommand();
                case CITE_CODE:
                        return InsetCitation::defaultCommand();
+               case COUNTER_CODE:
+                       return InsetCounter::defaultCommand();
                case FLOAT_LIST_CODE:
                        return InsetFloatList::defaultCommand();
                case HYPERLINK_CODE:
@@ -238,6 +242,8 @@ bool InsetCommandParams::isCompatibleCommand(InsetCode code, string const & s)
                        return InsetBibtex::isCompatibleCommand(s);
                case CITE_CODE:
                        return InsetCitation::isCompatibleCommand(s);
+               case COUNTER_CODE:
+                       return InsetCounter::isCompatibleCommand(s);
                case FLOAT_LIST_CODE:
                        return InsetFloatList::isCompatibleCommand(s);
                case HYPERLINK_CODE:
@@ -282,7 +288,7 @@ void InsetCommandParams::setCmdName(string const & name)
 
 void InsetCommandParams::read(Lexer & lex)
 {
-       Read(lex, 0);
+       Read(lex, nullptr);
 }
 
 
@@ -316,7 +322,7 @@ void InsetCommandParams::Read(Lexer & lex, Buffer const * buffer)
                        preview_ = lex.getBool();
                        continue;
                }
-               if (info_.hasParam(token)) {
+               if (hasParam(token)) {
                        lex.next(true);
                        docstring data = lex.getDocString();
                        if (buffer && token == "filename") {
@@ -356,7 +362,7 @@ void InsetCommandParams::Read(Lexer & lex, Buffer const * buffer)
 
 void InsetCommandParams::write(ostream & os) const
 {
-       Write(os, 0);
+       Write(os, nullptr);
 }
 
 
@@ -490,8 +496,41 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
        }
        else if (handling & ParamInfo::HANDLING_ESCAPE)
                result = escape(command);
-       else if (handling & ParamInfo::HANDLING_NONE)
-               result = command;
+       else if (handling & ParamInfo::HANDLING_NONE) {
+               // we can only output characters covered by the current
+               // encoding!
+               docstring uncodable;
+               for (char_type c : command) {
+                       try {
+                               if (runparams.encoding->encodable(c))
+                                       result += c;
+                               else if (runparams.dryrun) {
+                                       result += "<" + _("LyX Warning: ")
+                                          + _("uncodable character") + " '";
+                                       result += docstring(1, c);
+                                       result += "'>";
+                               } else
+                                       uncodable += c;
+                       } catch (EncodingException & /* e */) {
+                               if (runparams.dryrun) {
+                                       result += "<" + _("LyX Warning: ")
+                                          + _("uncodable character") + " '";
+                                       result += docstring(1, c);
+                                       result += "'>";
+                               } else
+                                       uncodable += c;
+                       }
+               }
+               if (!uncodable.empty() && !runparams.silent) {
+                       // issue a warning about omitted characters
+                       // FIXME: should be passed to the error dialog
+                       frontend::Alert::warning(_("Uncodable characters in inset"),
+                               bformat(_("The following characters in one of the insets are\n"
+                                         "not representable in the current encoding and have been omitted: %1$s.\n"
+                                         "Unchecking 'Literal' in the respective inset dialog might help."),
+                               uncodable));
+               }
+       }
        // INDEX_ESCAPE is independent of the others
        if (handling & ParamInfo::HANDLING_INDEX_ESCAPE) {
                // Now escape special commands
@@ -514,9 +553,11 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
 }
 
 
-docstring InsetCommandParams::getCommand(OutputParams const & runparams) const
+docstring InsetCommandParams::getCommand(OutputParams const & runparams, bool starred) const
 {
        docstring s = '\\' + from_ascii(cmdName_);
+       if (starred)
+               s += from_utf8("*");
        bool noparam = true;
        ParamInfo::const_iterator it  = info_.begin();
        ParamInfo::const_iterator end = info_.end();
@@ -559,16 +600,30 @@ docstring InsetCommandParams::getFirstNonOptParam() const
 {
        ParamInfo::const_iterator it =
                find_if(info_.begin(), info_.end(),
-                       not1(mem_fun_ref(&ParamInfo::ParamData::isOptional)));
+                       [](ParamInfo::ParamData const & d) { return !d.isOptional(); });
        LASSERT(it != info_.end(), return docstring());
        return (*this)[it->name()];
 }
 
 
+bool InsetCommandParams::hasParam(std::string const & name) const
+{
+       return info_.hasParam(name);
+}
+
+
+docstring const & InsetCommandParams::getParamOr(std::string const & name, docstring const & defaultValue) const
+{
+       if (hasParam(name))
+               return (*this)[name];
+       return defaultValue;
+}
+
+
 docstring const & InsetCommandParams::operator[](string const & name) const
 {
        static const docstring dummy;
-       LASSERT(info_.hasParam(name), return dummy);
+       LASSERT(hasParam(name), return dummy);
        ParamMap::const_iterator data = params_.find(name);
        if (data == params_.end() || data->second.empty())
                return dummy;
@@ -581,7 +636,7 @@ docstring const & InsetCommandParams::operator[](string const & name) const
 
 docstring & InsetCommandParams::operator[](string const & name)
 {
-       LATTEST(info_.hasParam(name));
+       LATTEST(hasParam(name));
        // this will add the name in release mode
        ParamInfo::ParamData const & param = info_[name];
        if (param.ignore())
@@ -593,6 +648,7 @@ docstring & InsetCommandParams::operator[](string const & name)
 void InsetCommandParams::clear()
 {
        params_.clear();
+       preview(false);
 }