#include "TextClass.h"
#include "LayoutFile.h"
+#include "CiteEnginesList.h"
#include "Color.h"
#include "Counters.h"
#include "Floating.h"
// You should also run the development/tools/updatelayouts.py script,
// to update the format of all of our layout files.
//
-int const LAYOUT_FORMAT = 57; //spitz: New Layout tag ParagraphGroup
+int const LAYOUT_FORMAT = 68; //spitz: New layout tag AddToCiteEngine
+
+
+// Layout format for the current lyx file format. Controls which format is
+// targeted by Local Layout > Convert. In master, equal to LAYOUT_FORMAT.
+int const LYXFILE_LAYOUT_FORMAT = LAYOUT_FORMAT;
+
namespace {
};
-bool layout2layout(FileName const & filename, FileName const & tempfile)
+bool layout2layout(FileName const & filename, FileName const & tempfile,
+ int const format = LAYOUT_FORMAT)
{
FileName const script = libFileSearch("scripts", "layout2layout.py");
if (script.empty()) {
LYXERR0("Could not find layout conversion "
- "script layout2layout.py.");
+ "script layout2layout.py.");
return false;
}
ostringstream command;
command << os::python() << ' ' << quoteName(script.toFilesystemEncoding())
- << ' ' << quoteName(filename.toFilesystemEncoding())
- << ' ' << quoteName(tempfile.toFilesystemEncoding());
+ << " -t " << format
+ << ' ' << quoteName(filename.toFilesystemEncoding())
+ << ' ' << quoteName(tempfile.toFilesystemEncoding());
string const command_str = command.str();
LYXERR(Debug::TCLASS, "Running `" << command_str << '\'');
cmd_ret const ret = runCommand(command_str);
if (ret.first != 0) {
- LYXERR0("Could not run layout conversion script layout2layout.py.");
+ if (format == LAYOUT_FORMAT)
+ LYXERR0("Conversion of layout with layout2layout.py has failed.");
return false;
}
return true;
return "input file";
case TextClass::MODULE:
return "module file";
+ case TextClass::CITE_ENGINE:
+ return "cite engine";
case TextClass::VALIDATION:
return "validation";
}
return string();
}
-} // namespace anon
+} // namespace
// This string should not be translated here,
docstring const TextClass::plain_layout_ = from_ascii(N_("Plain Layout"));
-InsetLayout DocumentClass::plain_insetlayout_;
-
-
/////////////////////////////////////////////////////////////////////////
//
// TextClass
opt_enginetype_("authoryear|numerical"), opt_fontsize_("10|11|12"),
opt_pagestyle_("empty|plain|headings|fancy"), pagestyle_("default"),
columns_(1), sides_(OneSide), secnumdepth_(3), tocdepth_(3),
- outputType_(LATEX), outputFormat_("latex"),
+ outputType_(LATEX), outputFormat_("latex"), has_output_format_(false),
defaultfont_(sane_font),
titletype_(TITLE_COMMAND_AFTER), titlename_("maketitle"),
- min_toclevel_(0), max_toclevel_(0),
+ min_toclevel_(0), max_toclevel_(0), maxcitenames_(2),
cite_full_author_list_(true)
{
}
TC_OUTPUTFORMAT,
TC_INPUT,
TC_STYLE,
- TC_IFSTYLE,
+ TC_MODIFYSTYLE,
+ TC_PROVIDESTYLE,
TC_DEFAULTSTYLE,
TC_INSETLAYOUT,
TC_NOINSETLAYOUT,
TC_EXCLUDESMODULE,
TC_HTMLTOCSECTION,
TC_CITEENGINE,
+ TC_ADDTOCITEENGINE,
TC_CITEENGINETYPE,
TC_CITEFORMAT,
+ TC_CITEFRAMEWORK,
+ TC_MAXCITENAMES,
TC_DEFAULTBIBLIO,
- TC_FULLAUTHORLIST
+ TC_FULLAUTHORLIST,
+ TC_OUTLINERNAME
};
namespace {
LexerKeyword textClassTags[] = {
+ { "addtociteengine", TC_ADDTOCITEENGINE },
{ "addtohtmlpreamble", TC_ADDTOHTMLPREAMBLE },
{ "addtohtmlstyles", TC_ADDTOHTMLSTYLES },
{ "addtopreamble", TC_ADDTOPREAMBLE },
{ "citeengine", TC_CITEENGINE },
{ "citeenginetype", TC_CITEENGINETYPE },
{ "citeformat", TC_CITEFORMAT },
+ { "citeframework", TC_CITEFRAMEWORK },
{ "classoptions", TC_CLASSOPTIONS },
{ "columns", TC_COLUMNS },
{ "counter", TC_COUNTER },
{ "htmlstyles", TC_HTMLSTYLES },
{ "htmltocsection", TC_HTMLTOCSECTION },
{ "ifcounter", TC_IFCOUNTER },
- { "ifstyle", TC_IFSTYLE },
{ "input", TC_INPUT },
{ "insetlayout", TC_INSETLAYOUT },
{ "leftmargin", TC_LEFTMARGIN },
+ { "maxcitenames", TC_MAXCITENAMES },
+ { "modifystyle", TC_MODIFYSTYLE },
{ "nocounter", TC_NOCOUNTER },
{ "nofloat", TC_NOFLOAT },
{ "noinsetlayout", TC_NOINSETLAYOUT },
{ "nostyle", TC_NOSTYLE },
+ { "outlinername", TC_OUTLINERNAME },
{ "outputformat", TC_OUTPUTFORMAT },
{ "outputtype", TC_OUTPUTTYPE },
{ "packageoptions", TC_PKGOPTS },
{ "preamble", TC_PREAMBLE },
{ "provides", TC_PROVIDES },
{ "providesmodule", TC_PROVIDESMODULE },
+ { "providestyle", TC_PROVIDESTYLE },
{ "requires", TC_REQUIRES },
{ "rightmargin", TC_RIGHTMARGIN },
{ "secnumdepth", TC_SECNUMDEPTH },
{ "tocdepth", TC_TOCDEPTH }
};
-} //namespace anon
+} // namespace
bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType rt)
os.close();
TempFile tmp2("convert_localXXXXXX.layout");
FileName const tempfile = tmp2.name();
- bool success = layout2layout(fn, tempfile);
+ bool success = layout2layout(fn, tempfile, LYXFILE_LAYOUT_FORMAT);
if (!success)
return "";
ifstream is(tempfile.toFilesystemEncoding().c_str());
os << str;
os.close();
- // now try to convert it
- bool const worx = convertLayoutFormat(tempfile, rt);
- if (!worx) {
+ // now try to convert it to LAYOUT_FORMAT
+ if (!convertLayoutFormat(tempfile, rt)) {
LYXERR0("Unable to convert internal layout information to format "
<< LAYOUT_FORMAT);
return ERROR;
}
+
return OK_OLDFORMAT;
}
if (!lexrc.isOK())
return ERROR;
- // Format of files before the 'Format' tag was introduced
- int format = 1;
- bool error = false;
+ // The first usable line should be
+ // Format LAYOUT_FORMAT
+ if (lexrc.lex() != TC_FORMAT || !lexrc.next()
+ || lexrc.getInteger() != LAYOUT_FORMAT)
+ return FORMAT_MISMATCH;
// parsing
+ bool error = false;
while (lexrc.isOK() && !error) {
int le = lexrc.lex();
}
// used below to track whether we are in an IfStyle or IfCounter tag.
- bool ifstyle = false;
- bool ifcounter = false;
+ bool modifystyle = false;
+ bool providestyle = false;
+ bool ifcounter = false;
switch (static_cast<TextClassTags>(le)) {
case TC_FORMAT:
- if (lexrc.next())
- format = lexrc.getInteger();
+ lexrc.next();
+ lexrc.printError("Duplicate Format directive");
break;
case TC_OUTPUTFORMAT:
- if (lexrc.next())
+ if (lexrc.next()) {
outputFormat_ = lexrc.getString();
+ has_output_format_ = true;
+ }
break;
case TC_OUTPUTTYPE:
case TC_INPUT: // Include file
if (lexrc.next()) {
+ FileName tmp;
string const inc = lexrc.getString();
- FileName tmp = libFileSearch("layouts", inc,
+ if (!path().empty() && (prefixIs(inc, "./") ||
+ prefixIs(inc, "../")))
+ tmp = fileSearch(path(), inc, "layout");
+ else
+ tmp = libFileSearch("layouts", inc,
"layout");
if (tmp.empty()) {
}
break;
- case TC_IFSTYLE:
- ifstyle = true;
- // fall through
+ case TC_MODIFYSTYLE:
+ modifystyle = true;
+ // fall through
+ case TC_PROVIDESTYLE:
+ // if modifystyle is true, then we got here by falling through
+ // so we are not in an ProvideStyle block
+ if (!modifystyle)
+ providestyle = true;
+ // fall through
case TC_STYLE: {
if (!lexrc.next()) {
lexrc.printError("No name given for style: `$$Token'.");
// Since we couldn't read the name, we just scan the rest
// of the style and discard it.
error = !readStyle(lexrc, lay);
- } else if (hasLayout(name)) {
+ break;
+ }
+
+ bool const have_layout = hasLayout(name);
+
+ // If the layout already exists, then we want to add it to
+ // the existing layout, as long as we are not in an ProvideStyle
+ // block.
+ if (have_layout && !providestyle) {
Layout & lay = operator[](name);
error = !readStyle(lexrc, lay);
- } else if (!ifstyle) {
+ }
+ // If the layout does not exist, then we want to create a new
+ // one, but not if we are in a ModifyStyle block.
+ else if (!have_layout && !modifystyle) {
Layout layout;
layout.setName(name);
error = !readStyle(lexrc, layout);
defaultlayout_ = name;
}
}
+ // There are two ways to get here:
+ // (i) The layout exists but we are in an ProvideStyle block
+ // (ii) The layout doesn't exist, but we are in an ModifyStyle
+ // block.
+ // Either way, we just scan the rest and discard it
else {
- // this was an ifstyle where we didn't have the style
- // scan the rest and discard it
Layout lay;
- readStyle(lexrc, lay);
+ // signal to coverity that we do not care about the result
+ (void)readStyle(lexrc, lay);
}
break;
}
break;
case TC_PREAMBLE:
- preamble_ = from_utf8(lexrc.getLongString("EndPreamble"));
+ preamble_ = lexrc.getLongString(from_ascii("EndPreamble"));
break;
case TC_HTMLPREAMBLE:
- htmlpreamble_ = from_utf8(lexrc.getLongString("EndPreamble"));
+ htmlpreamble_ = lexrc.getLongString(from_ascii("EndPreamble"));
break;
case TC_HTMLSTYLES:
- htmlstyles_ = from_utf8(lexrc.getLongString("EndStyles"));
+ htmlstyles_ = lexrc.getLongString(from_ascii("EndStyles"));
break;
case TC_HTMLTOCSECTION:
break;
case TC_ADDTOPREAMBLE:
- preamble_ += from_utf8(lexrc.getLongString("EndPreamble"));
+ preamble_ += lexrc.getLongString(from_ascii("EndPreamble"));
break;
case TC_ADDTOHTMLPREAMBLE:
- htmlpreamble_ += from_utf8(lexrc.getLongString("EndPreamble"));
+ htmlpreamble_ += lexrc.getLongString(from_ascii("EndPreamble"));
break;
case TC_ADDTOHTMLSTYLES:
- htmlstyles_ += from_utf8(lexrc.getLongString("EndStyles"));
+ htmlstyles_ += lexrc.getLongString(from_ascii("EndStyles"));
break;
case TC_PROVIDES: {
break;
case TC_CITEENGINE:
- error = !readCiteEngine(lexrc);
+ error = !readCiteEngine(lexrc, rt);
+ break;
+
+ case TC_ADDTOCITEENGINE:
+ error = !readCiteEngine(lexrc, rt, true);
break;
case TC_CITEENGINETYPE:
break;
case TC_CITEFORMAT:
- error = !readCiteFormat(lexrc);
+ error = !readCiteFormat(lexrc, rt);
+ break;
+
+ case TC_CITEFRAMEWORK:
+ lexrc.next();
+ citeframework_ = rtrim(lexrc.getString());
+ break;
+
+ case TC_MAXCITENAMES:
+ lexrc.next();
+ maxcitenames_ = size_t(lexrc.getInteger());
break;
case TC_DEFAULTBIBLIO:
- if (lexrc.next())
- cite_default_biblio_style_ = rtrim(lexrc.getString());
+ if (lexrc.next()) {
+ vector<string> const dbs =
+ getVectorFromString(rtrim(lexrc.getString()), "|");
+ vector<string>::const_iterator it = dbs.begin();
+ vector<string>::const_iterator end = dbs.end();
+ for (; it != end; ++it) {
+ if (!contains(*it, ':')) {
+ vector<string> const enginetypes =
+ getVectorFromString(opt_enginetype_, "|");
+ for (string const &s: enginetypes)
+ cite_default_biblio_style_[s] = *it;
+ } else {
+ string eng;
+ string const db = split(*it, eng, ':');
+ cite_default_biblio_style_[eng] = db;
+ }
+ }
+ }
break;
case TC_FULLAUTHORLIST:
floatlist_.erase(nofloat);
}
break;
- } // end of switch
- // Note that this is triggered the first time through the loop unless
- // we hit a format tag.
- if (format != LAYOUT_FORMAT)
- return FORMAT_MISMATCH;
+ case TC_OUTLINERNAME:
+ error = !readOutlinerName(lexrc);
+ break;
+ } // end of switch
}
// at present, we abort if we encounter an error,
}
-bool TextClass::readCiteEngine(Lexer & lexrc)
+vector<CitationStyle> const & TextClass::getCiteStyles(
+ CiteEngineType const & type) const
+{
+ static vector<CitationStyle> empty;
+ map<CiteEngineType, vector<CitationStyle> >::const_iterator it = cite_styles_.find(type);
+ if (it == cite_styles_.end())
+ return empty;
+ return it->second;
+}
+
+
+bool TextClass::readCiteEngine(Lexer & lexrc, ReadType rt, bool const add)
{
int const type = readCiteEngineType(lexrc);
- if (type & ENGINE_TYPE_AUTHORYEAR)
- cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear();
- if (type & ENGINE_TYPE_NUMERICAL)
- cite_styles_[ENGINE_TYPE_NUMERICAL].clear();
- if (type & ENGINE_TYPE_DEFAULT)
- cite_styles_[ENGINE_TYPE_DEFAULT].clear();
+ bool authoryear = (type & ENGINE_TYPE_AUTHORYEAR);
+ bool numerical = (type & ENGINE_TYPE_NUMERICAL);
+ bool defce = (type & ENGINE_TYPE_DEFAULT);
+
+ if (rt == CITE_ENGINE) {
+ // The cite engines are not supposed to overwrite
+ // CiteStyle defined by the class or a module.
+ if (authoryear)
+ authoryear = getCiteStyles(ENGINE_TYPE_AUTHORYEAR).empty();
+ if (numerical)
+ numerical = getCiteStyles(ENGINE_TYPE_NUMERICAL).empty();
+ if (defce)
+ defce = getCiteStyles(ENGINE_TYPE_DEFAULT).empty();
+ }
+
+ if (rt != CITE_ENGINE && !add) {
+ // Reset if we defined CiteStyle
+ // from the class or a module
+ if (authoryear)
+ cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear();
+ if (numerical)
+ cite_styles_[ENGINE_TYPE_NUMERICAL].clear();
+ if (defce)
+ cite_styles_[ENGINE_TYPE_DEFAULT].clear();
+ }
+
string def;
bool getout = false;
while (!getout && lexrc.isOK()) {
getout = true;
continue;
}
- string cmd;
CitationStyle cs;
char ichar = def[0];
if (ichar == '#')
continue;
- if (ichar == 'C') {
+ if (isUpperCase(ichar)) {
cs.forceUpperCase = true;
- def[0] = 'c';
+ def[0] = lowercase(ichar);
}
+ /** For portability reasons (between different
+ * cite engines such as natbib and biblatex),
+ * we distinguish between:
+ * 1. The LyX name as output in the LyX file
+ * 2. Possible aliases that might fall back to
+ * the given LyX name in the current engine
+ * 3. The actual LaTeX command that is output
+ * (2) and (3) are optional.
+ * Also, the GUI string for the starred version can
+ * be changed
+ * The syntax is:
+ * LyXName|alias,nextalias*<!stardesc!stardesctooltip>[][]=latexcmd
+ */
+ enum ScanMode {
+ LyXName,
+ Alias,
+ LaTeXCmd,
+ StarDesc
+ };
+
+ ScanMode mode = LyXName;
+ ScanMode oldmode = LyXName;
+ string lyx_cmd;
+ string alias;
+ string latex_cmd;
+ string stardesc;
size_t const n = def.size();
for (size_t i = 0; i != n; ++i) {
ichar = def[i];
- if (ichar == '*')
- cs.fullAuthorList = true;
+ if (ichar == '|')
+ mode = Alias;
+ else if (ichar == '=')
+ mode = LaTeXCmd;
+ else if (ichar == '<') {
+ oldmode = mode;
+ mode = StarDesc;
+ } else if (ichar == '>')
+ mode = oldmode;
+ else if (mode == LaTeXCmd)
+ latex_cmd += ichar;
+ else if (mode == StarDesc)
+ stardesc += ichar;
+ else if (ichar == '$')
+ cs.hasQualifiedList = true;
+ else if (ichar == '*')
+ cs.hasStarredVersion = true;
else if (ichar == '[' && cs.textAfter)
cs.textBefore = true;
else if (ichar == '[')
cs.textAfter = true;
- else if (ichar != ']')
- cmd += ichar;
+ else if (ichar != ']') {
+ if (mode == Alias)
+ alias += ichar;
+ else
+ lyx_cmd += ichar;
+ }
}
-
- cs.cmd = cmd;
+ cs.name = lyx_cmd;
+ cs.cmd = latex_cmd.empty() ? lyx_cmd : latex_cmd;
+ if (!alias.empty()) {
+ vector<string> const aliases = getVectorFromString(alias);
+ for (string const &s: aliases)
+ cite_command_aliases_[s] = lyx_cmd;
+ }
+ vector<string> const stardescs = getVectorFromString(stardesc, "!");
+ int size = stardesc.size();
+ if (size > 0)
+ cs.stardesc = stardescs[0];
+ if (size > 1)
+ cs.startooltip = stardescs[1];
+ if (add) {
+ if (authoryear)
+ class_cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs);
+ if (numerical)
+ class_cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs);
+ if (defce)
+ class_cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs);
+ } else {
+ if (authoryear)
+ cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs);
+ if (numerical)
+ cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs);
+ if (defce)
+ cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs);
+ }
+ }
+ // If we do AddToCiteEngine, do not apply yet,
+ // except if we have already a style to add something to
+ bool apply_ay = !add;
+ bool apply_num = !add;
+ bool apply_def = !add;
+ if (add) {
if (type & ENGINE_TYPE_AUTHORYEAR)
- cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs);
+ apply_ay = !getCiteStyles(ENGINE_TYPE_AUTHORYEAR).empty();
if (type & ENGINE_TYPE_NUMERICAL)
- cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs);
+ apply_num = !getCiteStyles(ENGINE_TYPE_NUMERICAL).empty();
if (type & ENGINE_TYPE_DEFAULT)
- cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs);
+ apply_def = !getCiteStyles(ENGINE_TYPE_DEFAULT).empty();
+ }
+
+ // Add the styles from AddToCiteEngine to the class' styles
+ // (but only if they are not yet defined)
+ for (auto const cis : class_cite_styles_) {
+ // Only consider the current CiteEngineType
+ if (!(type & cis.first))
+ continue;
+ for (auto const ciss : cis.second) {
+ bool defined = false;
+ // Check if the style "name" is already def'ed
+ for (auto const av : getCiteStyles(cis.first))
+ if (av.name == ciss.name)
+ defined = true;
+ if (!defined) {
+ if (cis.first == ENGINE_TYPE_AUTHORYEAR && apply_ay)
+ cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(ciss);
+ else if (cis.first == ENGINE_TYPE_NUMERICAL && apply_num)
+ cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(ciss);
+ else if (cis.first == ENGINE_TYPE_DEFAULT && apply_def)
+ cite_styles_[ENGINE_TYPE_DEFAULT].push_back(ciss);
+ }
+ }
}
+ if (type & ENGINE_TYPE_AUTHORYEAR && apply_ay)
+ class_cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear();
+ if (type & ENGINE_TYPE_NUMERICAL && apply_num)
+ class_cite_styles_[ENGINE_TYPE_NUMERICAL].clear();
+ if (type & ENGINE_TYPE_DEFAULT && apply_def)
+ class_cite_styles_[ENGINE_TYPE_DEFAULT].clear();
return getout;
}
int TextClass::readCiteEngineType(Lexer & lexrc) const
{
- LATTEST(ENGINE_TYPE_DEFAULT ==
- (ENGINE_TYPE_AUTHORYEAR | ENGINE_TYPE_NUMERICAL));
+ static_assert(ENGINE_TYPE_DEFAULT ==
+ (ENGINE_TYPE_AUTHORYEAR | ENGINE_TYPE_NUMERICAL),
+ "Incorrect default engine type");
if (!lexrc.next()) {
lexrc.printError("No cite engine type given for token: `$$Token'.");
return ENGINE_TYPE_DEFAULT;
}
-bool TextClass::readCiteFormat(Lexer & lexrc)
+bool TextClass::readCiteFormat(Lexer & lexrc, ReadType rt)
{
int const type = readCiteEngineType(lexrc);
string etype;
string definition;
+ // Cite engine definitions do not overwrite existing
+ // definitions from the class or a module
+ bool const overwrite = rt != CITE_ENGINE;
while (lexrc.isOK()) {
lexrc.next();
etype = lexrc.getString();
char initchar = etype[0];
if (initchar == '#')
continue;
- if (initchar == '!' || initchar == '_') {
- if (type & ENGINE_TYPE_AUTHORYEAR)
- cite_macros_[ENGINE_TYPE_AUTHORYEAR][etype] = definition;
- if (type & ENGINE_TYPE_NUMERICAL)
- cite_macros_[ENGINE_TYPE_NUMERICAL][etype] = definition;
- if (type & ENGINE_TYPE_DEFAULT)
- cite_macros_[ENGINE_TYPE_DEFAULT][etype] = definition;
+ if (initchar == '!' || initchar == '_' || prefixIs(etype, "B_")) {
+ bool defined = false;
+ // Check if the macro is already def'ed
+ for (auto const cm : cite_macros_) {
+ if (!(type & cm.first))
+ continue;
+ if (cm.second.find(etype) != cm.second.end())
+ defined = true;
+ }
+ if (!defined || overwrite) {
+ if (type & ENGINE_TYPE_AUTHORYEAR)
+ cite_macros_[ENGINE_TYPE_AUTHORYEAR][etype] = definition;
+ if (type & ENGINE_TYPE_NUMERICAL)
+ cite_macros_[ENGINE_TYPE_NUMERICAL][etype] = definition;
+ if (type & ENGINE_TYPE_DEFAULT)
+ cite_macros_[ENGINE_TYPE_DEFAULT][etype] = definition;
+ }
} else {
- if (type & ENGINE_TYPE_AUTHORYEAR)
- cite_formats_[ENGINE_TYPE_AUTHORYEAR][etype] = definition;
- if (type & ENGINE_TYPE_NUMERICAL)
- cite_formats_[ENGINE_TYPE_NUMERICAL][etype] = definition;
- if (type & ENGINE_TYPE_DEFAULT)
- cite_formats_[ENGINE_TYPE_DEFAULT][etype] = definition;
+ bool defined = false;
+ // Check if the format is already def'ed
+ for (auto const cm : cite_formats_) {
+ if (!(type & cm.first))
+ continue;
+ if (cm.second.find(etype) != cm.second.end())
+ defined = true;
+ }
+ if (!defined || overwrite){
+ if (type & ENGINE_TYPE_AUTHORYEAR)
+ cite_formats_[ENGINE_TYPE_AUTHORYEAR][etype] = definition;
+ if (type & ENGINE_TYPE_NUMERICAL)
+ cite_formats_[ENGINE_TYPE_NUMERICAL][etype] = definition;
+ if (type & ENGINE_TYPE_DEFAULT)
+ cite_formats_[ENGINE_TYPE_DEFAULT][etype] = definition;
+ }
}
}
return true;
string ext;
string htmlattr;
- string htmlstyle;
+ docstring htmlstyle;
string htmltag;
string listname;
string listcommand;
break;
case FT_HTMLSTYLE:
lexrc.next();
- htmlstyle = lexrc.getLongString("EndHTMLStyle");
+ htmlstyle = lexrc.getLongString(from_ascii("EndHTMLStyle"));
break;
case FT_HTMLTAG:
lexrc.next();
}
+bool TextClass::readOutlinerName(Lexer & lexrc)
+{
+ std::string type;
+ docstring name;
+ if (lexrc.next())
+ type = lexrc.getString();
+ else {
+ lexrc.printError("No type given for OutlinerName: `$$Token'.");
+ return false;
+ }
+ if (lexrc.next())
+ name = lexrc.getDocString();
+ else {
+ lexrc.printError("No name given for OutlinerName: `$$Token'.");
+ return false;
+ }
+ outliner_names_[type] = name;
+ return true;
+}
+
+
string const & TextClass::prerequisites(string const & sep) const
{
if (contains(prerequisites_, ',')) {
n = n.substr(0, i);
}
// Layout "name" not found.
+ return plainInsetLayout();
+}
+
+
+InsetLayout const & DocumentClass::plainInsetLayout() {
+ static const InsetLayout plain_insetlayout_;
return plain_insetlayout_;
}
DocumentClassPtr getDocumentClass(
LayoutFile const & baseClass, LayoutModuleList const & modlist,
- bool const clone)
+ string const & cengine, bool const clone)
{
DocumentClassPtr doc_class =
DocumentClassPtr(new DocumentClass(baseClass));
frontend::Alert::warning(_("Read Error"), msg);
}
}
+
+ if (cengine.empty())
+ return doc_class;
+
+ LyXCiteEngine * ce = theCiteEnginesList[cengine];
+ if (!ce) {
+ docstring const msg =
+ bformat(_("The cite engine %1$s has been requested by\n"
+ "this document but has not been found in the list of\n"
+ "available engines. If you recently installed it, you\n"
+ "probably need to reconfigure LyX.\n"), from_utf8(cengine));
+ if (!clone)
+ frontend::Alert::warning(_("Cite Engine not available"), msg);
+ } else if (!ce->isAvailable() && !clone) {
+ docstring const prereqs = from_utf8(getStringFromVector(ce->prerequisites(), "\n\t"));
+ docstring const msg =
+ bformat(_("The cite engine %1$s requires a package that is not\n"
+ "available in your LaTeX installation, or a converter that\n"
+ "you have not installed. LaTeX output may not be possible.\n"
+ "Missing prerequisites:\n"
+ "\t%2$s\n"
+ "See section 3.1.2.3 (Modules) of the User's Guide for more information."),
+ from_utf8(cengine), prereqs);
+ frontend::Alert::warning(_("Package not available"), msg, true);
+ } else {
+ FileName layout_file = libFileSearch("citeengines", ce->getFilename());
+ if (!doc_class->read(layout_file, TextClass::CITE_ENGINE)) {
+ docstring const msg =
+ bformat(_("Error reading cite engine %1$s\n"), from_utf8(cengine));
+ frontend::Alert::warning(_("Read Error"), msg);
+ }
+ }
+
return doc_class;
}
for (; lit != len; ++lit) {
int const level = lit->toclevel;
// we don't want Part or unnumbered sections
- if (level == Layout::NOT_IN_TOC || level < 0
+ if (level == Layout::NOT_IN_TOC || level < 0
|| level >= minlevel || lit->counter.empty())
continue;
lay = &*lit;
}
-string const & DocumentClass::getCiteFormat(CiteEngineType const & type,
- string const & entry, string const & fallback) const
+string const DocumentClass::getCiteFormat(CiteEngineType const & type,
+ string const & entry, bool const punct, string const & fallback) const
{
- static string default_format = "{%author%[[%author%, ]][[{%editor%[[%editor%, ed., ]]}]]}\"%title%\"{%journal%[[, {!<i>!}%journal%{!</i>!}]][[{%publisher%[[, %publisher%]][[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}.";
+ string default_format = "{%fullnames:author%[[%fullnames:author%, ]][[{%fullnames:editor%[[%fullnames:editor%, ed., ]]}]]}\"%title%\"{%journal%[[, {!<i>!}%journal%{!</i>!}]][[{%publisher%[[, %publisher%]][[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}";
+ if (punct)
+ default_format += ".";
map<CiteEngineType, map<string, string> >::const_iterator itype = cite_formats_.find(type);
if (itype == cite_formats_.end())
it = itype->second.find(fallback);
if (it == itype->second.end())
return default_format;
+ if (punct)
+ return it->second + ".";
return it->second;
}
vector<string> cmds;
for (; it != end; ++it) {
CitationStyle const cite = *it;
- cmds.push_back(cite.cmd);
+ cmds.push_back(cite.name);
}
return cmds;
}
projects / lyx.git / blobdiff