X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetCommandParams.cpp;h=94b9a2c8a2e7897be9fce2d393e36be3ea1db3b0;hb=8124e6c02ea1fd6779bb6c47ffe2bca2c8bd2d97;hp=9d34808d415c668f81ef81e32b60d1f46dfb69d3;hpb=75bfed55079cab6b73fbea6ce4ae3f10d1af3b91;p=lyx.git

diff --git a/src/insets/InsetCommandParams.cpp b/src/insets/InsetCommandParams.cpp
index 9d34808d41..94b9a2c8a2 100644
--- 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:
@@ -132,10 +134,10 @@ bool ParamInfo::hasParam(std::string const & name) const
 
 
 void ParamInfo::add(std::string const & name, ParamType type,
-                    ParamHandling handling, bool ignore,
+                    ParamHandling handling, bool ignoreval,
                     docstring default_value)
 {
-	info_.push_back(ParamData(name, type, handling, ignore, default_value));
+	info_.push_back(ParamData(name, type, handling, ignoreval, default_value));
 }
 
 
@@ -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);
 }
 
 
@@ -432,12 +438,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
@@ -454,14 +470,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) {
@@ -476,23 +493,71 @@ 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:
-		result = command;
-		break;
-	} // switch
+	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
+		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;
 }
 
 
-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();
@@ -535,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;
@@ -557,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())
@@ -569,6 +648,7 @@ docstring & InsetCommandParams::operator[](string const & name)
 void InsetCommandParams::clear()
 {
 	params_.clear();
+	preview(false);
 }