// Cite engine
-typedef Translator<string, CiteEngine> CiteEngineTranslator;
+typedef Translator<string, CiteEngineType> CiteEngineTypeTranslator;
-CiteEngineTranslator const init_citeenginetranslator()
+CiteEngineTypeTranslator const init_citeenginetypetranslator()
{
- CiteEngineTranslator translator("basic", ENGINE_BASIC);
- translator.addPair("natbib_numerical", ENGINE_NATBIB_NUMERICAL);
- translator.addPair("natbib_authoryear", ENGINE_NATBIB_AUTHORYEAR);
- translator.addPair("jurabib", ENGINE_JURABIB);
+ CiteEngineTypeTranslator translator("authoryear", ENGINE_TYPE_AUTHORYEAR);
+ translator.addPair("numerical", ENGINE_TYPE_NUMERICAL);
return translator;
}
-CiteEngineTranslator const & citeenginetranslator()
+CiteEngineTypeTranslator const & citeenginetypetranslator()
{
- static CiteEngineTranslator translator = init_citeenginetranslator();
+ static CiteEngineTypeTranslator translator = init_citeenginetypetranslator();
return translator;
}
papersize = PAPER_DEFAULT;
orientation = ORIENTATION_PORTRAIT;
use_geometry = false;
- use_amsmath = package_auto;
- use_esint = package_auto;
- use_mhchem = package_auto;
- use_mathdots = package_auto;
- use_undertilde = package_auto;
- cite_engine_ = ENGINE_BASIC;
+ cite_engine_.push_back("basic");
+ cite_engine_type_ = ENGINE_TYPE_NUMERICAL;
+ biblio_style = "plain";
use_bibtopic = false;
use_indices = false;
trackChanges = false;
}
+BufferParams::Package BufferParams::use_package(std::string const & p) const
+{
+ PackageMap::const_iterator it = use_packages.find(p);
+ if (it == use_packages.end())
+ return package_auto;
+ return it->second;
+}
+
+
+void BufferParams::use_package(std::string const & p, BufferParams::Package u)
+{
+ use_packages[p] = u;
+}
+
+
+vector<string> const & BufferParams::auto_packages()
+{
+ static vector<string> packages;
+ if (packages.empty()) {
+ // adding a package here implies a file format change!
+ packages.push_back("amsmath");
+ packages.push_back("esint");
+ packages.push_back("mathdots");
+ packages.push_back("mathtools");
+ packages.push_back("mhchem");
+ packages.push_back("undertilde");
+ }
+ return packages;
+}
+
+
AuthorList & BufferParams::authors()
{
return pimpl_->authorlist;
papersize = papersizetranslator().find(ppsize);
} else if (token == "\\use_geometry") {
lex >> use_geometry;
- } else if (token == "\\use_amsmath") {
- int use_ams;
- lex >> use_ams;
- use_amsmath = packagetranslator().find(use_ams);
- } else if (token == "\\use_esint") {
- int useesint;
- lex >> useesint;
- use_esint = packagetranslator().find(useesint);
- } else if (token == "\\use_mhchem") {
- int usemhchem;
- lex >> usemhchem;
- use_mhchem = packagetranslator().find(usemhchem);
- } else if (token == "\\use_mathdots") {
- int usemathdots;
- lex >> usemathdots;
- use_mathdots = packagetranslator().find(usemathdots);
- } else if (token == "\\use_undertilde") {
- int useundertilde;
- lex >> useundertilde;
- use_undertilde = packagetranslator().find(useundertilde);
+ } else if (token == "\\use_package") {
+ string package;
+ int use;
+ lex >> package;
+ lex >> use;
+ use_package(package, packagetranslator().find(use));
} else if (token == "\\cite_engine") {
- string engine;
- lex >> engine;
- cite_engine_ = citeenginetranslator().find(engine);
+ lex.eatLine();
+ vector<string> engine = getVectorFromString(lex.getString());
+ setCiteEngine(engine);
+ } else if (token == "\\cite_engine_type") {
+ string engine_type;
+ lex >> engine_type;
+ cite_engine_type_ = citeenginetypetranslator().find(engine_type);
+ } else if (token == "\\biblio_style") {
+ lex.eatLine();
+ biblio_style = lex.getString();
} else if (token == "\\use_bibtopic") {
lex >> use_bibtopic;
} else if (token == "\\use_indices") {
pdfoptions().writeFile(os);
os << "\\papersize " << string_papersize[papersize]
- << "\n\\use_geometry " << convert<string>(use_geometry)
- << "\n\\use_amsmath " << use_amsmath
- << "\n\\use_esint " << use_esint
- << "\n\\use_mhchem " << use_mhchem
- << "\n\\use_mathdots " << use_mathdots
- << "\n\\use_undertilde " << use_undertilde
- << "\n\\cite_engine " << citeenginetranslator().find(cite_engine_)
+ << "\n\\use_geometry " << convert<string>(use_geometry);
+ vector<string> const & packages = auto_packages();
+ for (size_t i = 0; i < packages.size(); ++i)
+ os << "\n\\use_package " << packages[i] << ' '
+ << use_package(packages[i]);
+
+ os << "\n\\cite_engine ";
+
+ if (!cite_engine_.empty()) {
+ LayoutModuleList::const_iterator be = cite_engine_.begin();
+ LayoutModuleList::const_iterator en = cite_engine_.end();
+ for (LayoutModuleList::const_iterator it = be; it != en; ++it) {
+ if (it != be)
+ os << ',';
+ os << *it;
+ }
+ } else {
+ os << "basic";
+ }
+
+ os << "\n\\cite_engine_type " << citeenginetypetranslator().find(cite_engine_type_)
+ << "\n\\biblio_style " << biblio_style
<< "\n\\use_bibtopic " << convert<string>(use_bibtopic)
<< "\n\\use_indices " << convert<string>(use_indices)
<< "\n\\paperorientation " << string_orientation[orientation]
if (float_placement.find('H') != string::npos)
features.require("float");
- // AMS Style is at document level
- if (use_amsmath == package_on
- || documentClass().provides("amsmath"))
- features.require("amsmath");
- if (use_esint == package_on)
- features.require("esint");
- if (use_mhchem == package_on)
- features.require("mhchem");
- if (use_mathdots == package_on)
- features.require("mathdots");
- if (use_undertilde == package_on)
- features.require("undertilde");
+ for (PackageMap::const_iterator it = use_packages.begin();
+ it != use_packages.end(); ++it) {
+ if (it->first == "amsmath") {
+ // AMS Style is at document level
+ if (it->second == package_on ||
+ documentClass().provides("amsmath"))
+ features.require(it->first);
+ } else if (it->second == package_on)
+ features.require(it->first);
+ }
// Document-level line spacing
if (spacing().getSpace() != Spacing::Single && !spacing().isDefault())
if (!baseClass())
return;
- doc_class_ = &(DocumentClassBundle::get().makeDocumentClass(*baseClass(), layout_modules_));
+ LayoutModuleList mods;
+ LayoutModuleList::iterator it;
+ LayoutModuleList::iterator en;
+
+ it = layout_modules_.begin();
+ en = layout_modules_.end();
+ for (; it != en; it++)
+ mods.push_back(*it);
+ it = cite_engine_.begin();
+ en = cite_engine_.end();
+ for (; it != en; it++)
+ mods.push_back(*it);
+ doc_class_ = &(DocumentClassBundle::get().makeDocumentClass(*baseClass(), mods));
if (!local_layout.empty()) {
TextClass::ReturnValues success =
bool BufferParams::moduleCanBeAdded(string const & modName) const
{
- return layout_modules_.moduleCanBeAdded(modName, baseClass());
+ return cite_engine_.moduleCanBeAdded(modName, baseClass()) &&
+ layout_modules_.moduleCanBeAdded(modName, baseClass());
}
vector<string> BufferParams::backends() const
{
vector<string> v;
- v.push_back(bufferFormat());
+ string const buffmt = bufferFormat();
+
// FIXME: Don't hardcode format names here, but use a flag
- if (v.back() == "latex") {
- v.push_back("pdflatex");
+ if (buffmt == "latex") {
+ if (!useNonTeXFonts) {
+ v.push_back("pdflatex");
+ v.push_back("latex");
+ }
v.push_back("luatex");
v.push_back("dviluatex");
v.push_back("xetex");
- } else if (v.back() == "xetex") {
+ } else if (buffmt == "xetex") {
+ v.push_back("xetex");
v.push_back("luatex");
v.push_back("dviluatex");
- }
+ } else
+ v.push_back(buffmt);
+
v.push_back("xhtml");
v.push_back("text");
v.push_back("lyx");
if (dformat == "xhtml")
result = OutputParams::HTML;
+ else if (dformat == "text")
+ result = OutputParams::TEXT;
else {
// Try to determine flavor of default output format
vector<string> backs = backends();
{
string result;
+ // If the class loads the geometry package, we do not know which
+ // paper size is used, since we do not set it (bug 7013).
+ // Therefore we must not specify any argument here.
+ // dvips gets the correct paper size via DVI specials in this case
+ // (if the class uses the geometry package correctly).
+ if (documentClass().provides("geometry"))
+ return result;
+
if (use_geometry
&& papersize == PAPER_CUSTOM
&& !lyxrc.print_paper_dimension_flag.empty()
}
-CiteEngine BufferParams::citeEngine() const
+bool BufferParams::addCiteEngine(string const & engine)
+{
+ LayoutModuleList::const_iterator it = cite_engine_.begin();
+ LayoutModuleList::const_iterator en = cite_engine_.end();
+ for (; it != en; ++it)
+ if (*it == engine)
+ return false;
+ cite_engine_.push_back(engine);
+ return true;
+}
+
+
+bool BufferParams::addCiteEngine(vector<string> const & engine)
+{
+ vector<string>::const_iterator it = engine.begin();
+ vector<string>::const_iterator en = engine.end();
+ bool ret = true;
+ for (; it != en; ++it)
+ if (!addCiteEngine(*it))
+ ret = false;
+ return ret;
+}
+
+
+string const & BufferParams::defaultBiblioStyle() const
+{
+ return documentClass().defaultBiblioStyle();
+}
+
+
+bool const & BufferParams::fullAuthorList() const
+{
+ return documentClass().fullAuthorList();
+}
+
+
+void BufferParams::setCiteEngine(string const & engine)
+{
+ clearCiteEngine();
+ addCiteEngine(engine);
+}
+
+
+void BufferParams::setCiteEngine(vector<string> const & engine)
+{
+ clearCiteEngine();
+ addCiteEngine(engine);
+}
+
+
+vector<string> BufferParams::citeCommands() const
{
- // FIXME the class should provide the numerical/
- // authoryear choice
- if (documentClass().provides("natbib")
- && cite_engine_ != ENGINE_NATBIB_NUMERICAL)
- return ENGINE_NATBIB_AUTHORYEAR;
- return cite_engine_;
+ static CitationStyle const default_style;
+ vector<string> commands =
+ documentClass().citeCommands(citeEngineType());
+ if (commands.empty())
+ commands.push_back(default_style.cmd);
+ return commands;
}
-void BufferParams::setCiteEngine(CiteEngine cite_engine)
+vector<CitationStyle> BufferParams::citeStyles() const
{
- cite_engine_ = cite_engine;
+ static CitationStyle const default_style;
+ vector<CitationStyle> styles =
+ documentClass().citeStyles(citeEngineType());
+ if (styles.empty())
+ styles.push_back(default_style);
+ return styles;
}
} // namespace lyx
projects / lyx.git / blobdiff