#include "TextClass.h"
-#include "LayoutFile.h"
#include "CiteEnginesList.h"
-#include "Color.h"
#include "Counters.h"
#include "Floating.h"
#include "FloatList.h"
#include "Layout.h"
+#include "LayoutFile.h"
#include "Lexer.h"
-#include "Font.h"
#include "ModuleList.h"
#include "frontends/alert.h"
#include "support/lassert.h"
#include "support/debug.h"
-#include "support/ExceptionMessage.h"
#include "support/FileName.h"
#include "support/filetools.h"
#include "support/gettext.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 = 80; // spitz: Requires for floats
+int const LAYOUT_FORMAT = 104; // rkh: RefFormat for counters
// Layout format for the current lyx file format. Controls which format is
namespace {
-class LayoutNamesEqual : public unary_function<Layout, bool> {
-public:
- LayoutNamesEqual(docstring const & name)
- : name_(name)
- {}
- bool operator()(Layout const & c) const
- {
- return c.name() == name_;
- }
-private:
- docstring name_;
-};
-
-
bool layout2layout(FileName const & filename, FileName const & tempfile,
int const format = LAYOUT_FORMAT)
{
LYXERR(Debug::TCLASS, "Running `" << command_str << '\'');
cmd_ret const ret = runCommand(command_str);
- if (ret.first != 0) {
+ if (!ret.valid) {
if (format == LAYOUT_FORMAT)
LYXERR0("Conversion of layout with layout2layout.py has failed.");
return false;
opt_pagesize_("default|a4|a5|b5|letter|legal|executive"),
opt_pagestyle_("empty|plain|headings|fancy"), fontsize_format_("$$spt"), pagesize_("default"),
pagesize_format_("$$spaper"), pagestyle_("default"), tablestyle_("default"),
+ docbookroot_("article"), docbookforceabstract_(false),
columns_(1), sides_(OneSide), secnumdepth_(3), tocdepth_(3), outputType_(LATEX),
outputFormat_("latex"), has_output_format_(false), defaultfont_(sane_font),
titletype_(TITLE_COMMAND_AFTER), titlename_("maketitle"),
min_toclevel_(0), max_toclevel_(0), maxcitenames_(2),
- cite_full_author_list_(true), bibintoc_(false)
-{
+ cite_full_author_list_(true), bibintoc_(false) {
}
-bool TextClass::readStyle(Lexer & lexrc, Layout & lay) const
+bool TextClass::readStyle(Lexer & lexrc, Layout & lay, ReadType rt) const
{
LYXERR(Debug::TCLASS, "Reading style " << to_utf8(lay.name()));
- if (!lay.read(lexrc, *this)) {
+ if (!lay.read(lexrc, *this, rt == VALIDATION)) {
LYXERR0("Error parsing style `" << to_utf8(lay.name()) << '\'');
return false;
}
TC_OUTPUTTYPE = 1,
TC_OUTPUTFORMAT,
TC_INPUT,
+ TC_INPUT_GLOBAL,
TC_STYLE,
TC_MODIFYSTYLE,
TC_PROVIDESTYLE,
TC_DEFAULTSTYLE,
TC_INSETLAYOUT,
+ TC_MODIFYINSETLAYOUT,
+ TC_PROVIDEINSETLAYOUT,
TC_NOINSETLAYOUT,
TC_NOSTYLE,
TC_COLUMNS,
TC_FULLAUTHORLIST,
TC_OUTLINERNAME,
TC_TABLESTYLE,
- TC_BIBINTOC
+ TC_BIBINTOC,
+ TC_DOCBOOKROOT,
+ TC_DOCBOOKFORCEABSTRACT
};
{ "defaultfont", TC_DEFAULTFONT },
{ "defaultmodule", TC_DEFAULTMODULE },
{ "defaultstyle", TC_DEFAULTSTYLE },
+ { "docbookforceabstract", TC_DOCBOOKFORCEABSTRACT },
+ { "docbookroot", TC_DOCBOOKROOT },
{ "excludesmodule", TC_EXCLUDESMODULE },
{ "float", TC_FLOAT },
{ "format", TC_FORMAT },
{ "htmltocsection", TC_HTMLTOCSECTION },
{ "ifcounter", TC_IFCOUNTER },
{ "input", TC_INPUT },
+ { "inputglobal", TC_INPUT_GLOBAL },
{ "insetlayout", TC_INSETLAYOUT },
{ "leftmargin", TC_LEFTMARGIN },
{ "maxcitenames", TC_MAXCITENAMES },
+ { "modifyinsetlayout", TC_MODIFYINSETLAYOUT },
{ "modifystyle", TC_MODIFYSTYLE },
{ "nocounter", TC_NOCOUNTER },
{ "nofloat", TC_NOFLOAT },
{ "pagesize", TC_PAGESIZE },
{ "pagestyle", TC_PAGESTYLE },
{ "preamble", TC_PREAMBLE },
+ { "provideinsetlayout", TC_PROVIDEINSETLAYOUT },
{ "provides", TC_PROVIDES },
{ "providesmodule", TC_PROVIDESMODULE },
{ "providestyle", TC_PROVIDESTYLE },
}
// used below to track whether we are in an IfStyle or IfCounter tag.
- bool modifystyle = false;
- bool providestyle = false;
+ bool modify = false;
+ bool provide = false;
bool ifcounter = false;
+ bool only_global = false;
switch (static_cast<TextClassTags>(le)) {
case LATEX:
outputFormat_ = "latex";
break;
- case DOCBOOK:
- outputFormat_ = "docbook";
- break;
case LITERATE:
outputFormat_ = "literate";
break;
}
break;
+ case TC_INPUT_GLOBAL:
+ only_global = true;
+ // fall through
case TC_INPUT: // Include file
if (lexrc.next()) {
FileName tmp;
if (!path().empty() && (prefixIs(inc, "./") ||
prefixIs(inc, "../")))
tmp = fileSearch(path(), inc, "layout");
- else
+ else {
+ // InputGlobal only searches in the system and
+ // build directories. This allows to reuse and
+ // modify files in the user directory.
tmp = libFileSearch("layouts", inc,
- "layout");
+ "layout", must_exist, only_global);
+ }
if (tmp.empty()) {
lexrc.printError("Could not find input file: " + inc);
break;
case TC_MODIFYSTYLE:
- modifystyle = true;
+ modify = 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;
+ if (!modify)
+ provide = true;
// fall through
case TC_STYLE: {
if (!lexrc.next()) {
Layout lay;
// Since we couldn't read the name, we just scan the rest
// of the style and discard it.
- error = !readStyle(lexrc, lay);
+ error = !readStyle(lexrc, lay, rt);
break;
}
// 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) {
+ if (have_layout && !provide) {
Layout & lay = operator[](name);
- error = !readStyle(lexrc, lay);
+ error = !readStyle(lexrc, lay, rt);
}
// 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) {
+ else if (!have_layout && !modify) {
Layout layout;
layout.setName(name);
- error = !readStyle(lexrc, layout);
+ error = !readStyle(lexrc, layout, rt);
if (!error)
layoutlist_.push_back(layout);
else {
Layout lay;
// signal to coverity that we do not care about the result
- (void)readStyle(lexrc, lay);
+ (void)readStyle(lexrc, lay, rt);
}
break;
}
lexrc.eatLine();
vector<string> const req
= getVectorFromString(lexrc.getString());
- requires_.insert(req.begin(), req.end());
+ required_.insert(req.begin(), req.end());
break;
}
case TC_PKGOPTS : {
lexrc.next();
string const pkg = lexrc.getString();
- lexrc.next();
+ lexrc.eatLine();
string const options = lexrc.getString();
package_options_[pkg] = options;
break;
rightmargin_ = lexrc.getDocString();
break;
+ case TC_MODIFYINSETLAYOUT:
+ modify = true;
+ // fall through
+ case TC_PROVIDEINSETLAYOUT:
+ // if modifyinsetlayout is true, then we got here by falling through
+ // so we are not in an ProvideInsetLayout block
+ if (!modify)
+ provide = true;
+ // fall through
case TC_INSETLAYOUT: {
if (!lexrc.next()) {
lexrc.printError("No name given for InsetLayout: `$$Token'.");
break;
}
docstring const name = subst(lexrc.getDocString(), '_', ' ');
+ bool const validating = (rt == VALIDATION);
+ bool const have_layout = name.empty() ? false : hasInsetLayout(name);
if (name.empty()) {
string s = "Could not read name for InsetLayout: `$$Token' "
+ lexrc.getString() + " is probably not valid UTF-8!";
// Since we couldn't read the name, we just scan the rest
// of the style and discard it.
il.read(lexrc, *this);
- // Let's try to continue rather than abort.
- // error = true;
- } else if (hasInsetLayout(name)) {
+ // Let's try to continue rather than abort, unless we're validating
+ // in which case we want to report the error
+ if (validating)
+ error = true;
+ } else if (have_layout && !provide) {
InsetLayout & il = insetlayoutlist_[name];
- error = !il.read(lexrc, *this);
- } else {
+ error = !il.read(lexrc, *this, validating);
+ } else if (!modify && !have_layout) {
InsetLayout il;
il.setName(name);
- error = !il.read(lexrc, *this);
+ error = !il.read(lexrc, *this, validating);
if (!error)
insetlayoutlist_[name] = il;
+ } else {
+ InsetLayout il;
+ // We just scan the rest of the style and discard it.
+ il.read(lexrc, *this);
}
break;
}
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, ':')) {
+ for (auto const & dbase : dbs) {
+ if (!contains(dbase, ':')) {
vector<string> const enginetypes =
getVectorFromString(opt_enginetype_, "|");
- for (string const &s: enginetypes)
- cite_default_biblio_style_[s] = *it;
+ for (string const & s: enginetypes)
+ cite_default_biblio_style_[s] = dbase;
} else {
string eng;
- string const db = split(*it, eng, ':');
+ string const db = split(dbase, eng, ':');
cite_default_biblio_style_[eng] = db;
}
}
lexrc.next();
tablestyle_ = rtrim(lexrc.getString());
break;
+
+ case TC_DOCBOOKROOT:
+ if (lexrc.next())
+ docbookroot_ = lexrc.getString();
+ break;
+
+ case TC_DOCBOOKFORCEABSTRACT:
+ if (lexrc.next())
+ docbookforceabstract_ = lexrc.getBool();
+ break;
} // end of switch
}
// If we do not succeed, then it was not there, which means that
// the textclass did not provide the definitions of the standard
// insets. So we need to try to load them.
- int erased = provides_.erase("stdinsets");
+ size_type const erased = provides_.erase("stdinsets");
if (!erased) {
FileName tmp = libFileSearch("layouts", "stdinsets.inc");
min_toclevel_ = Layout::NOT_IN_TOC;
max_toclevel_ = Layout::NOT_IN_TOC;
- const_iterator lit = begin();
- const_iterator len = end();
- for (; lit != len; ++lit) {
- int const toclevel = lit->toclevel;
+ for (auto const & lay : *this) {
+ int const toclevel = lay.toclevel;
if (toclevel != Layout::NOT_IN_TOC) {
if (min_toclevel_ == Layout::NOT_IN_TOC)
min_toclevel_ = toclevel;
void TextClass::readOutputType(Lexer & lexrc)
{
LexerKeyword outputTypeTags[] = {
- { "docbook", DOCBOOK },
{ "latex", LATEX },
{ "literate", LITERATE }
};
lexrc.printError("Unknown output type `$$Token'");
return;
case LATEX:
- case DOCBOOK:
case LITERATE:
outputType_ = static_cast<OutputType>(le);
break;
CO_PAGESIZE_FORMAT,
CO_PAGESTYLE,
CO_OTHER,
- CO_HEADER,
CO_END
};
{"end", CO_END },
{"fontsize", CO_FONTSIZE },
{"fontsizeformat", CO_FONTSIZE_FORMAT },
- {"header", CO_HEADER },
{"other", CO_OTHER },
{"pagesize", CO_PAGESIZE },
{"pagesizeformat", CO_PAGESIZE_FORMAT },
else
options_ += ',' + lexrc.getString();
break;
- case CO_HEADER:
- lexrc.next();
- class_header_ = subst(lexrc.getString(), """, "\"");
- break;
case CO_END:
getout = true;
break;
cs.cmd = latex_cmd.empty() ? lyx_cmd : latex_cmd;
if (!alias.empty()) {
vector<string> const aliases = getVectorFromString(alias);
- for (string const &s: aliases)
+ for (string const & s: aliases)
cite_command_aliases_[s] = lyx_cmd;
}
vector<string> const stardescs = getVectorFromString(stardesc, "!");
FT_HTMLSTYLE,
FT_HTMLATTR,
FT_HTMLTAG,
+ FT_DOCBOOKATTR,
+ FT_DOCBOOKFLOATTYPE,
+ FT_DOCBOOKTAG,
+ FT_DOCBOOKTAGTYPE,
+ FT_DOCBOOKCAPTION,
FT_LISTCOMMAND,
FT_REFPREFIX,
FT_ALLOWED_PLACEMENT,
FT_ALLOWS_SIDEWAYS,
FT_ALLOWS_WIDE,
FT_REQUIRES,
+ FT_PRETTYFORMAT,
FT_END
};
{ "allowedplacement", FT_ALLOWED_PLACEMENT },
{ "allowssideways", FT_ALLOWS_SIDEWAYS },
{ "allowswide", FT_ALLOWS_WIDE },
+ { "docbookattr", FT_DOCBOOKATTR },
+ { "docbookcaption", FT_DOCBOOKCAPTION },
+ { "docbookfloattype", FT_DOCBOOKFLOATTYPE },
+ { "docbooktag", FT_DOCBOOKTAG },
+ { "docbooktagtype", FT_DOCBOOKTAGTYPE },
{ "end", FT_END },
{ "extension", FT_EXT },
{ "guiname", FT_NAME },
{ "listname", FT_LISTNAME },
{ "numberwithin", FT_WITHIN },
{ "placement", FT_PLACEMENT },
+ { "prettyformat", FT_PRETTYFORMAT },
{ "refprefix", FT_REFPREFIX },
{ "requires", FT_REQUIRES },
{ "style", FT_STYLE },
string htmlattr;
docstring htmlstyle;
string htmltag;
+ string docbookattr;
+ string docbookcaption;
+ string docbooktag;
+ string docbooktagtype;
+ string docbookfloattype;
string listname;
string listcommand;
string name;
string style;
string type;
string within;
- string requires;
+ string required;
+ docstring prettyformat;
bool usesfloat = true;
bool ispredefined = false;
bool allowswide = true;
break;
case FT_REQUIRES:
lexrc.next();
- requires = lexrc.getString();
+ required = lexrc.getString();
break;
case FT_PREDEFINED:
lexrc.next();
lexrc.next();
htmltag = lexrc.getString();
break;
+ case FT_PRETTYFORMAT:
+ lexrc.next();
+ prettyformat = lexrc.getDocString();
+ break;
+ case FT_DOCBOOKATTR:
+ lexrc.next();
+ docbookattr = lexrc.getString();
+ break;
+ case FT_DOCBOOKCAPTION:
+ lexrc.next();
+ docbookcaption = lexrc.getString();
+ break;
+ case FT_DOCBOOKTAG:
+ lexrc.next();
+ docbooktag = lexrc.getString();
+ break;
+ case FT_DOCBOOKTAGTYPE:
+ lexrc.next();
+ docbooktagtype = lexrc.getString();
+ break;
+ case FT_DOCBOOKFLOATTYPE:
+ lexrc.next();
+ docbookfloattype = lexrc.getString();
+ break;
case FT_END:
getout = true;
break;
+ default:
+ LYXERR0("Unhandled value " << le << " in TextClass::readFloat.");
+ break;
}
}
if (!usesfloat && listcommand.empty()) {
// if this float uses the same auxfile as an existing one,
// there is no need for it to provide a list command.
- FloatList::const_iterator it = floatlist_.begin();
- FloatList::const_iterator en = floatlist_.end();
bool found_ext = false;
- for (; it != en; ++it) {
- if (it->second.ext() == ext) {
+ for (auto const & f : floatlist_) {
+ if (f.second.ext() == ext) {
found_ext = true;
break;
}
"not be able to produce a float list.");
}
Floating fl(type, placement, ext, within, style, name,
- listname, listcommand, refprefix, allowed_placement,
- htmltag, htmlattr, htmlstyle, requires, usesfloat,
- ispredefined, allowswide, allowssideways);
+ listname, listcommand, refprefix, allowed_placement,
+ htmltag, htmlattr, htmlstyle, docbooktag, docbookattr,
+ docbooktagtype, docbookfloattype, docbookcaption,
+ required, usesfloat, ispredefined,
+ allowswide, allowssideways);
floatlist_.newFloat(fl);
// each float has its own counter
counters_.newCounter(from_ascii(type), from_ascii(within),
- docstring(), docstring());
+ docstring(), docstring(),
+ prettyformat.empty() ? bformat(_("%1$s ##"), _(name)) : prettyformat,
+ bformat(_("%1$s (Float)"), _(name)));
// also define sub-float counters
docstring const subtype = "sub-" + from_ascii(type);
counters_.newCounter(subtype, from_ascii(type),
- "\\alph{" + subtype + "}", docstring());
+ "\\alph{" + subtype + "}", docstring(),
+ prettyformat.empty() ? bformat(_("Sub-%1$s ##"), _(name)) : prettyformat,
+ bformat(_("Sub-%1$s (Float)"), _(name)));
}
return getout;
}
bool TextClass::hasLayout(docstring const & n) const
{
docstring const name = n.empty() ? defaultLayoutName() : n;
-
- return find_if(layoutlist_.begin(), layoutlist_.end(),
- LayoutNamesEqual(name))
- != layoutlist_.end();
+ return getLayout(name) != nullptr;
}
{
LATTEST(!name.empty());
- const_iterator it =
- find_if(begin(), end(), LayoutNamesEqual(name));
-
- if (it == end()) {
+ Layout const * c = getLayout(name);
+ if (!c) {
LYXERR0("We failed to find the layout '" << name
<< "' in the layout list. You MUST investigate!");
- for (const_iterator cit = begin(); cit != end(); ++cit)
- lyxerr << " " << to_utf8(cit->name()) << endl;
+ for (auto const & lay : *this)
+ lyxerr << " " << to_utf8(lay.name()) << endl;
// We require the name to exist
static const Layout dummy;
LASSERT(false, return dummy);
}
- return *it;
+ return *c;
}
LATTEST(!name.empty());
// Safe to continue, given what we do below.
- iterator it = find_if(begin(), end(), LayoutNamesEqual(name));
-
- if (it == end()) {
+ Layout * c = getLayout(name);
+ if (!c) {
LYXERR0("We failed to find the layout '" << to_utf8(name)
<< "' in the layout list. You MUST investigate!");
- for (const_iterator cit = begin(); cit != end(); ++cit)
- LYXERR0(" " << to_utf8(cit->name()));
+ for (auto const & lay : *this)
+ LYXERR0(" " << to_utf8(lay.name()));
// we require the name to exist
LATTEST(false);
// we are here only in release mode
layoutlist_.push_back(createBasicLayout(name, true));
- it = find_if(begin(), end(), LayoutNamesEqual(name));
+ c = getLayout(name);
}
- return *it;
+ return *c;
}
LayoutList::iterator it =
remove_if(layoutlist_.begin(), layoutlist_.end(),
- LayoutNamesEqual(name));
+ [name](const Layout &c) { return c.name() == name; });
- LayoutList::iterator end = layoutlist_.end();
+ LayoutList::iterator const end = layoutlist_.end();
bool const ret = (it != end);
layoutlist_.erase(it, end);
return ret;
<< to_utf8(makeDisplayPath(layout_file.absFileName()))
<< "'\n(Check `" << name_
<< "')\nCheck your installation and "
- "try Options/Reconfigure..."
+ "try Tools/Reconfigure..."
<< endl;
}
}
+Layout const * TextClass::getLayout(docstring const & name) const
+{
+ LayoutList::const_iterator cit =
+ find_if(begin(), end(),
+ [name](const Layout &c) { return c.name() == name; });
+ if (cit == layoutlist_.end())
+ return nullptr;
+
+ return &(*cit);
+}
+
+
+Layout * TextClass::getLayout(docstring const & name)
+{
+ LayoutList::iterator it =
+ find_if(layoutlist_.begin(), layoutlist_.end(),
+ [name](const Layout &c) { return c.name() == name; });
+ if (it == layoutlist_.end())
+ return nullptr;
+
+ return &(*it);
+}
+
+
bool DocumentClass::addLayoutIfNeeded(docstring const & n) const
{
if (hasLayout(n))
{
ostringstream os;
bool first = true;
- const_iterator const e = end();
- for (const_iterator i = begin(); i != e; ++i) {
- if (i->forcelocal > 0) {
+ for (auto const & lay : *this) {
+ if (lay.forcelocal > 0) {
if (first) {
os << "Format " << LAYOUT_FORMAT << '\n';
first = false;
}
- i->write(os);
+ lay.write(os);
}
}
return os.str();
Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const
{
- static Layout * defaultLayout = NULL;
+ static Layout * defaultLayout = nullptr;
if (defaultLayout) {
defaultLayout->setUnknown(unknown);
defaultLayout = new Layout;
defaultLayout->setUnknown(unknown);
defaultLayout->setName(name);
- if (!readStyle(lex, *defaultLayout)) {
+ if (!readStyle(lex, *defaultLayout, BASECLASS)) {
// The only way this happens is because the hardcoded layout above
// is wrong.
LATTEST(false);
}
-DocumentClassPtr getDocumentClass(
- LayoutFile const & baseClass, LayoutModuleList const & modlist,
- string const & cengine, bool const clone)
+DocumentClassPtr getDocumentClass(LayoutFile const & baseClass, LayoutModuleList const & modlist,
+ string const & cengine, bool clone, bool internal)
{
+ bool const show_warnings = !clone && !internal;
DocumentClassPtr doc_class =
DocumentClassPtr(new DocumentClass(baseClass));
- LayoutModuleList::const_iterator it = modlist.begin();
- LayoutModuleList::const_iterator en = modlist.end();
- for (; it != en; ++it) {
- string const modName = *it;
- LyXModule * lm = theModuleList[modName];
+ for (auto const & mod : modlist) {
+ LyXModule * lm = theModuleList[mod];
if (!lm) {
- docstring const msg =
- bformat(_("The module %1$s has been requested by\n"
- "this document but has not been found in the list of\n"
- "available modules. If you recently installed it, you\n"
- "probably need to reconfigure LyX.\n"), from_utf8(modName));
- if (!clone)
+ if (show_warnings) {
+ docstring const msg =
+ bformat(_("The module %1$s has been requested by\n"
+ "this document but has not been found in the list of\n"
+ "available modules. If you recently installed it, you\n"
+ "probably need to reconfigure LyX.\n"), from_utf8(mod));
frontend::Alert::warning(_("Module not available"), msg);
+ }
continue;
}
- if (!lm->isAvailable() && !clone) {
+ if (!lm->isAvailable() && show_warnings) {
docstring const prereqs = from_utf8(getStringFromVector(lm->prerequisites(), "\n\t"));
docstring const msg =
bformat(_("The module %1$s requires a package that is not\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(modName), prereqs);
+ from_utf8(mod), prereqs);
frontend::Alert::warning(_("Package not available"), msg, true);
}
FileName layout_file = libFileSearch("layouts", lm->getFilename());
if (!doc_class->read(layout_file, TextClass::MODULE)) {
docstring const msg =
- bformat(_("Error reading module %1$s\n"), from_utf8(modName));
+ bformat(_("Error reading module %1$s\n"), from_utf8(mod));
frontend::Alert::warning(_("Read Error"), msg);
}
}
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)
+ if (show_warnings) {
+ 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));
frontend::Alert::warning(_("Cite Engine not available"), msg);
- } else if (!ce->isAvailable() && !clone) {
+ }
+ } else if (!ce->isAvailable() && show_warnings) {
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"
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));
+ bformat(_("Error reading cite engine %1$s\n"), from_utf8(cengine));
frontend::Alert::warning(_("Read Error"), msg);
}
}
bool DocumentClass::hasLaTeXLayout(std::string const & lay) const
{
- LayoutList::const_iterator it = layoutlist_.begin();
- LayoutList::const_iterator end = layoutlist_.end();
- for (; it != end; ++it)
- if (it->latexname() == lay)
+ for (auto const & l : layoutlist_)
+ if (l.latexname() == lay)
return true;
return false;
}
Layout const & DocumentClass::getTOCLayout() const
{
// we're going to look for the layout with the minimum toclevel
- TextClass::LayoutList::const_iterator lit = begin();
- TextClass::LayoutList::const_iterator const len = end();
int minlevel = 1000;
- Layout const * lay = NULL;
- for (; lit != len; ++lit) {
- int const level = lit->toclevel;
+ Layout const * lay = nullptr;
+ for (auto const & l : *this) {
+ int const level = l.toclevel;
// we don't want Part or unnumbered sections
if (level == Layout::NOT_IN_TOC || level < 0
- || level >= minlevel || lit->counter.empty())
+ || level >= minlevel || l.counter.empty())
continue;
- lay = &*lit;
+ lay = &l;
minlevel = level;
}
if (lay)
CiteEngineType const & type) const
{
vector<CitationStyle> const styles = citeStyles(type);
- vector<CitationStyle>::const_iterator it = styles.begin();
- vector<CitationStyle>::const_iterator end = styles.end();
vector<string> cmds;
- for (; it != end; ++it) {
- CitationStyle const cite = *it;
- cmds.push_back(cite.name);
- }
+ cmds.reserve(styles.size());
+ for (auto const & cs : styles)
+ cmds.push_back(cs.name);
+
return cmds;
}
projects / lyx.git / blobdiff