static char const * const tex_graphics[] = {
- "default", "dvips", "dvitops", "emtex",
- "ln", "oztex", "textures", "none", ""
+ "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
+ "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
+ "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
+ "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
+ "xetex", "none", ""
};
use_bibtopic = false;
trackChanges = false;
outputChanges = false;
+ use_default_options = true;
secnumdepth = 3;
tocdepth = 3;
language = default_language;
} else if (token == "\\options") {
lex.eatLine();
options = lex.getString();
+ } else if (token == "\\use_default_options") {
+ lex >> use_default_options;
} else if (token == "\\master") {
lex.eatLine();
master = lex.getString();
os << "\\options " << options << '\n';
}
+ // use the class options defined in the layout?
+ os << "\\use_default_options "
+ << convert<string>(use_default_options) << "\n";
+
// the master document
if (!master.empty()) {
os << "\\master " << master << '\n';
// http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129417.html
size_t viet = language_options.str().find("vietnam");
// viet = string::npos when not found
+ // the same is for all other languages that are not directly supported by
+ // babel, but where LaTeX-packages add babel support.
+ // this is currently the case for Latvian, Lithuanian, and Mongolian
+ size_t latvian = language_options.str().find("latvian");
+ size_t lithu = language_options.str().find("lithuanian");
+ size_t mongo = language_options.str().find("mongolian");
// if Japanese is used, babel must directly be loaded
// with language options, not in the class options, see
// http://bugzilla.lyx.org/show_bug.cgi?id=4597#c4
size_t japan = language_options.str().find("japanese");
- // japan = string::npos when not found
- if (lyxrc.language_global_options
- && !language_options.str().empty()
- && viet == string::npos && japan == string::npos)
+ if (lyxrc.language_global_options && !language_options.str().empty()
+ && viet == string::npos && japan == string::npos
+ && latvian == string::npos && lithu == string::npos
+ && mongo == string::npos)
clsoptions << language_options.str() << ',';
}
+ // the predefined options from the layout
+ if (use_default_options && !tclass.options().empty())
+ clsoptions << tclass.options() << ',';
+
// the user-defined options
if (!options.empty()) {
clsoptions << options << ',';
// PDF support.
// * Hyperref manual: "Make sure it comes last of your loaded
// packages, to give it a fighting chance of not being over-written,
- // since its job is to redefine many LATEX commands."
+ // since its job is to redefine many LaTeX commands."
// * Email from Heiko Oberdiek: "It is usually better to load babel
// before hyperref. Then hyperref has a chance to detect babel.
// * Has to be loaded before the "LyX specific LaTeX commands" to
sides = tclass.sides();
columns = tclass.columns();
pagestyle = tclass.pagestyle();
- options = tclass.options();
+ use_default_options = true;
// Only if class has a ToC hierarchy
if (tclass.hasTocLevels()) {
secnumdepth = tclass.secnumdepth();
return sides == tclass.sides()
&& columns == tclass.columns()
&& pagestyle == tclass.pagestyle()
- && options == tclass.options()
+ && use_default_options
&& secnumdepth == tclass.secnumdepth()
&& tocdepth == tclass.tocdepth();
}
}
+void BufferParams::addDefaultModules()
+{
+ // add any default modules not already in use
+ list<string> const & mods = baseClass()->defaultModules();
+ list<string>::const_iterator mit = mods.begin();
+ list<string>::const_iterator men = mods.end();
+
+ // we want to add these to the front, but in the right order,
+ // so we collect them here first.
+ list<string> modulesToAdd;
+
+ for (; mit != men; mit++) {
+ string const & modName = *mit;
+ // make sure the user hasn't removed it
+ if (find(removedModules_.begin(), removedModules_.end(), modName) !=
+ removedModules_.end()) {
+ LYXERR(Debug::TCLASS, "Default module `" << modName <<
+ "' not added because removed by user.");
+ continue;
+ }
+
+ if (moduleCanBeAdded(modName)) {
+ LYXERR(Debug::TCLASS, "Default module `" << modName << "' added.");
+ modulesToAdd.push_back(modName);
+ } else
+ LYXERR(Debug::TCLASS,
+ "Default module `" << modName << "' could not be added.");
+ }
+
+ // OK, now we can add the default modules.
+ layoutModules_.insert(
+ layoutModules_.begin(), modulesToAdd.begin(), modulesToAdd.end());
+}
+
+
+bool BufferParams::checkModuleConsistency() {
+ bool consistent = true;
+ // Perform a consistency check on the set of modules.
+ // In particular, we need to check that modules provided by this class
+ // do not conflict with modules chosen by the user.
+ list<string> oldModules = getModules();
+ clearLayoutModules();
+ list<string>::const_iterator oit = oldModules.begin();
+ list<string>::const_iterator oen = oldModules.end();
+ list<string> const & provmods = baseClass()->providedModules();
+ list<string> const & exclmods = baseClass()->excludedModules();
+ for (; oit != oen; ++oit) {
+ string const & modname = *oit;
+ // skip modules that the class provides
+ if (find(provmods.begin(), provmods.end(), modname) != provmods.end()) {
+ consistent = false;
+ LYXERR0("Module " << modname << " dropped because provided by document class.");
+ continue;
+ }
+ // are we excluded by the document class?
+ if (find(exclmods.begin(), exclmods.end(), modname) != exclmods.end()) {
+ consistent = false;
+ LYXERR0("Module " << modname << " dropped because excluded by document class.");
+ continue;
+ }
+
+ // determine whether some provided module excludes us or we exclude it
+ list<string>::const_iterator pit = provmods.begin();
+ list<string>::const_iterator pen = provmods.end();
+ bool excluded = false;
+ for (; !excluded && pit != pen; ++pit) {
+ if (!LyXModule::areCompatible(modname, *pit)) {
+ consistent = false;
+ LYXERR0("Module " << modname <<
+ " dropped becuase it conflicts with provided module " << *pit);
+ excluded = true;
+ }
+ }
+
+ if (excluded)
+ continue;
+
+ // Determine whether some prior module excludes us, or we exclude it
+ list<string>::const_iterator lit = layoutModules_.begin();
+ list<string>::const_iterator len = layoutModules_.end();
+ for (; !excluded && lit != len; ++lit) {
+ if (!LyXModule::areCompatible(modname, *lit)) {
+ consistent = false;
+ LYXERR0("Module " << modname <<
+ " dropped because it is excluded by prior module " << *lit);
+ excluded = true;
+ }
+ }
+
+ if (excluded)
+ continue;
+
+ // determine whether some provided module or some prior module
+ // satisfies our requirements
+ LyXModule const * const oldmod = moduleList[modname];
+ if (!oldmod) {
+ LYXERR0("Default module " << modname <<
+ " added although it is unavailable and can't check requirements.");
+ continue;
+ }
+
+ vector<string> const & reqs = oldmod->getRequiredModules();
+ if (!reqs.empty()) {
+ // we now set excluded to true, meaning that we haven't
+ // yet found a required module.
+ excluded = true;
+ vector<string>::const_iterator rit = reqs.begin();
+ vector<string>::const_iterator ren = reqs.end();
+ for (; rit != ren; ++rit) {
+ string const reqmod = *rit;
+ if (find(provmods.begin(), provmods.end(), reqmod) !=
+ provmods.end()) {
+ excluded = false;
+ break;
+ }
+ if (find(layoutModules_.begin(), layoutModules_.end(), reqmod) !=
+ layoutModules_.end()) {
+ excluded = false;
+ break;
+ }
+ }
+ }
+ if (excluded) {
+ consistent = false;
+ LYXERR0("Module " << modname << " dropped because requirements not met.");
+ } else {
+ LYXERR(Debug::TCLASS, "Module " << modname << " passed consistency check.");
+ layoutModules_.push_back(modname);
+ }
+ }
+ return consistent;
+}
+
+
bool BufferParams::setBaseClass(string const & classname)
{
LYXERR(Debug::TCLASS, "setBaseClass: " << classname);
}
bool const success = bcl[classname].load();
- if (!success) {
+ if (!success) {
docstring s =
bformat(_("The document class %1$s could not be loaded."),
from_utf8(classname));
}
pimpl_->baseClass_ = classname;
+ addDefaultModules();
+ checkModuleConsistency();
- // add any required modules not already in use
- set<string> const & mods = baseClass()->defaultModules();
- set<string>::const_iterator mit = mods.begin();
- set<string>::const_iterator men = mods.end();
- for (; mit != men; mit++) {
- string const & modName = *mit;
- // see if we're already in use
- if (find(layoutModules_.begin(), layoutModules_.end(), modName) !=
- layoutModules_.end()) {
- LYXERR(Debug::TCLASS, "Default module `" << modName <<
- "' not added because already used.");
- continue;
- }
- // make sure the user hasn't removed it
- if (find(removedModules_.begin(), removedModules_.end(), modName) !=
- removedModules_.end()) {
- LYXERR(Debug::TCLASS, "Default module `" << modName <<
- "' not added because removed by user.");
- continue;
- }
- // Now we want to check the list of selected modules to see if any of them
- // exclude this one.
- bool foundit = false;
- // so iterate over the selected modules...
- LayoutModuleList::const_iterator lit = layoutModules_.begin();
- LayoutModuleList::const_iterator len = layoutModules_.end();
- for (; lit != len; lit++) {
- LyXModule * lm = moduleList[*lit];
- if (!lm)
- continue;
- vector<string> const & exc = lm->getExcludedModules();
- // ...and see if this one excludes us.
- if (find(exc.begin(), exc.end(), modName) != exc.end()) {
- foundit = true;
- LYXERR(Debug::TCLASS, "Default module `" << modName <<
- "' not added because excluded by loaded module `" <<
- *lit << "'.");
- break;
- }
- }
- if (!foundit) {
- LYXERR(Debug::TCLASS, "Default module `" << modName << "' added.");
- layoutModules_.push_back(modName);
- }
- }
return true;
}
}
-bool BufferParams::addLayoutModule(string const & modName)
+bool BufferParams::moduleCanBeAdded(string const & modName) const
+{
+ // Is the module already present?
+ LayoutModuleList::const_iterator it = layoutModules_.begin();
+ LayoutModuleList::const_iterator end = layoutModules_.end();
+ for (; it != end; it++)
+ if (*it == modName)
+ return false;
+
+ LyXModule const * const lm = moduleList[modName];
+ if (!lm)
+ return true;
+
+ // Is this module explicitly excluded by the document class?
+ list<string>::const_iterator const exclmodstart =
+ baseClass()->excludedModules().begin();
+ list<string>::const_iterator const exclmodend =
+ baseClass()->excludedModules().end();
+ if (find(exclmodstart, exclmodend, modName) != exclmodend)
+ return false;
+
+ // Is this module already provided by the document class?
+ list<string>::const_iterator const provmodstart =
+ baseClass()->providedModules().begin();
+ list<string>::const_iterator const provmodend =
+ baseClass()->providedModules().end();
+ if (find(provmodstart, provmodend, modName) != provmodend)
+ return false;
+
+ // Check for conflicts with used modules
+ // first the provided modules...
+ list<string>::const_iterator provmodit = provmodstart;
+ for (; provmodit != provmodend; ++provmodit) {
+ if (!LyXModule::areCompatible(modName, *provmodit))
+ return false;
+ }
+ // and then the selected modules
+ LayoutModuleList::const_iterator mit = getModules().begin();
+ LayoutModuleList::const_iterator const men = getModules().end();
+ for (; mit != men; ++mit)
+ if (!LyXModule::areCompatible(modName, *mit))
+ return false;
+
+ // Check whether some required module is available
+ vector<string> const reqs = lm->getRequiredModules();
+ if (reqs.empty())
+ return true;
+
+ mit = getModules().begin(); // reset
+ vector<string>::const_iterator rit = reqs.begin();
+ vector<string>::const_iterator ren = reqs.end();
+ bool foundone = false;
+ for (; rit != ren; ++rit) {
+ if (find(mit, men, *rit) != men ||
+ find(provmodstart, provmodend, *rit) != provmodend) {
+ foundone = true;
+ break;
+ }
+ }
+
+ return foundone;
+}
+
+
+bool BufferParams::addLayoutModule(string const & modName)
{
LayoutModuleList::const_iterator it = layoutModules_.begin();
LayoutModuleList::const_iterator end = layoutModules_.end();
// http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129417.html
size_t viet = lang_opts.find("vietnam");
// viet = string::npos when not found
+ // the same is for all other languages that are not directly supported by
+ // babel, but where LaTeX-packages add babel support.
+ // this is currently the case for Latvian, Lithuanian, and Mongolian
+ size_t latvian = lang_opts.find("latvian");
+ size_t lithu = lang_opts.find("lithuanian");
+ size_t mongo = lang_opts.find("mongolian");
// If Japanese is used, babel must directly be loaded with the
// language options, see
// http://bugzilla.lyx.org/show_bug.cgi?id=4597#c4
size_t japan = lang_opts.find("japanese");
- // japan = string::npos when not found
- if (!lyxrc.language_global_options || viet != string::npos || japan != string::npos)
+ if (!lyxrc.language_global_options || viet != string::npos
+ || japan != string::npos || latvian != string::npos
+ || lithu != string::npos || mongo != string::npos)
return "\\usepackage[" + lang_opts + "]{babel}";
return lang_pack;
}