*
* \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"
#include "Buffer.h"
#include "Encoding.h"
-#include "Lexer.h"
-#include "OutputParams.h"
#include "frontends/alert.h"
#include "support/docstream.h"
#include "support/ExceptionMessage.h"
#include "support/gettext.h"
+#include "support/lassert.h"
+#include "support/Lexer.h"
#include "support/lstrings.h"
-#include "support/lassert.h"
+#include <algorithm>
+#include <functional>
using namespace std;
using namespace lyx::support;
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:
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:
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:
void InsetCommandParams::read(Lexer & lex)
{
- Read(lex, 0);
+ Read(lex, nullptr);
}
preview_ = lex.getBool();
continue;
}
- if (info_.hasParam(token)) {
+ if (hasParam(token)) {
lex.next(true);
docstring data = lex.getDocString();
if (buffer && token == "filename") {
void InsetCommandParams::write(ostream & os) const
{
- Write(os, 0);
+ Write(os, nullptr);
}
// LATEXIFY, ESCAPE and NONE are mutually exclusive
if (handling & ParamInfo::HANDLING_LATEXIFY) {
// First handle backslash
- result = subst(command, from_ascii("\\"), from_ascii("\\textbackslash{}"));
+ // we cannot replace yet with \textbackslash{}
+ // as the braces would be erroneously escaped
+ // in the following routines ("\textbackslash\{\}").
+ // So create a unique placeholder which is replaced
+ // in the end.
+ docstring bs = from_ascii("@LyXBackslash@");
+ // We are super-careful and assure the placeholder
+ // does not exist in the string
+ for (int i = 0; ; ++i) {
+ if (!contains(command, bs)) {
+ result = subst(command, from_ascii("\\"), bs);
+ break;
+ }
+ bs = from_ascii("@LyXBackslash") + i + '@';
+ }
// Then get LaTeX macros
pair<docstring, docstring> command_latexed =
runparams.encoding->latexString(result, runparams.dryrun);
result.replace(pos, 1, backslash + chars_escape[k] + term);
}
}
+ // set in real backslash now
+ result = subst(result, bs, from_ascii("\\textbackslash{}"));
}
else if (handling & ParamInfo::HANDLING_ESCAPE)
result = escape(command);
// we can only output characters covered by the current
// encoding!
docstring uncodable;
- for (size_type i = 0 ; i < command.size() ; ++i) {
- char_type c = command[i];
+ for (char_type c : command) {
try {
if (runparams.encoding->encodable(c))
result += c;
}
-docstring InsetCommandParams::getCommand(OutputParams const & runparams) const
+docstring InsetCommandParams::getCommand(OutputParams const & runparams, bool starred, bool unhandled) 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();
for (; it != end; ++it) {
std::string const & name = it->name();
+ ParamInfo::ParamHandling handling = unhandled ?
+ ParamInfo::HANDLING_NONE
+ : it->handling();
switch (it->type()) {
case ParamInfo::LYX_INTERNAL:
break;
case ParamInfo::LATEX_REQUIRED: {
docstring const data =
- prepareCommand(runparams, (*this)[name], it->handling());
+ prepareCommand(runparams, (*this)[name], handling);
s += '{' + data + '}';
noparam = false;
break;
}
case ParamInfo::LATEX_OPTIONAL: {
docstring data =
- prepareCommand(runparams, (*this)[name], it->handling());
+ prepareCommand(runparams, (*this)[name], handling);
if (!data.empty()) {
s += '[' + protectArgument(data) + ']';
noparam = false;
{
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;
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())
projects / lyx.git / blobdiff