ParSepTranslator const & parseptranslator()
{
- static ParSepTranslator translator = init_parseptranslator();
+ static ParSepTranslator const translator =
+ init_parseptranslator();
return translator;
}
QuotesLangTranslator const & quoteslangtranslator()
{
- static QuotesLangTranslator translator = init_quoteslangtranslator();
+ static QuotesLangTranslator const translator =
+ init_quoteslangtranslator();
return translator;
}
PaperSizeTranslator const & papersizetranslator()
{
- static PaperSizeTranslator translator = initPaperSizeTranslator();
+ static PaperSizeTranslator const translator =
+ initPaperSizeTranslator();
return translator;
}
PaperOrientationTranslator const & paperorientationtranslator()
{
- static PaperOrientationTranslator translator = init_paperorientationtranslator();
+ static PaperOrientationTranslator const translator =
+ init_paperorientationtranslator();
return translator;
}
SidesTranslator const & sidestranslator()
{
- static SidesTranslator translator = init_sidestranslator();
+ static SidesTranslator const translator = init_sidestranslator();
return translator;
}
PackageTranslator const & packagetranslator()
{
- static PackageTranslator translator = init_packagetranslator();
+ static PackageTranslator const translator =
+ init_packagetranslator();
return translator;
}
{
CiteEngineTypeTranslator translator("authoryear", ENGINE_TYPE_AUTHORYEAR);
translator.addPair("numerical", ENGINE_TYPE_NUMERICAL);
+ translator.addPair("default", ENGINE_TYPE_DEFAULT);
return translator;
}
CiteEngineTypeTranslator const & citeenginetypetranslator()
{
- static CiteEngineTypeTranslator translator = init_citeenginetypetranslator();
+ static CiteEngineTypeTranslator const translator =
+ init_citeenginetypetranslator();
return translator;
}
SpaceTranslator const & spacetranslator()
{
- static SpaceTranslator translator = init_spacetranslator();
+ static SpaceTranslator const translator = init_spacetranslator();
return translator;
}
BufferParams::Impl *
BufferParams::MemoryTraits::clone(BufferParams::Impl const * ptr)
{
- LASSERT(ptr, /**/);
-
+ LBUFERR(ptr);
return new BufferParams::Impl(*ptr);
}
orientation = ORIENTATION_PORTRAIT;
use_geometry = false;
cite_engine_.push_back("basic");
- cite_engine_type_ = ENGINE_TYPE_NUMERICAL;
+ cite_engine_type_ = ENGINE_TYPE_DEFAULT;
biblio_style = "plain";
use_bibtopic = false;
use_indices = false;
docstring BufferParams::B_(string const & l10n) const
{
- LASSERT(language, /**/);
+ LASSERT(language, return from_utf8(l10n));
return getMessages(language->code()).get(l10n);
}
}
-vector<string> const & BufferParams::auto_packages()
+map<string, string> const & BufferParams::auto_packages()
{
- static vector<string> packages;
+ // FIXME THREAD
+ // It is extremely unlikely that there could be a problem here, but...
+ static map<string, string> packages;
if (packages.empty()) {
// adding a package here implies a file format change!
- packages.push_back("amsmath");
- packages.push_back("amssymb");
- packages.push_back("esint");
- packages.push_back("mathdots");
- packages.push_back("mathtools");
- packages.push_back("mhchem");
- packages.push_back("undertilde");
+ packages["amsmath"] =
+ N_("The LaTeX package amsmath is only used if AMS formula types or symbols from the AMS math toolbars are inserted into formulas");
+ packages["amssymb"] =
+ N_("The LaTeX package amssymb is only used if symbols from the AMS math toolbars are inserted into formulas");
+ packages["cancel"] =
+ N_("The LaTeX package cancel is only used if \\cancel commands are used in formulas");
+ packages["esint"] =
+ N_("The LaTeX package esint is only used if special integral symbols are inserted into formulas");
+ packages["mathdots"] =
+ N_("The LaTeX package mathdots is only used if the command \\iddots is inserted into formulas");
+ packages["mathtools"] =
+ N_("The LaTeX package mathtools is only used if some mathematical relations are inserted into formulas");
+ packages["mhchem"] =
+ N_("The LaTeX package mhchem is only used if either the command \\ce or \\cf is inserted into formulas");
+ packages["stackrel"] =
+ N_("The LaTeX package stackrel is only used if the command \\stackrel with subscript is inserted into formulas");
+ packages["stmaryrd"] =
+ N_("The LaTeX package stmaryrd is only used if symbols from the St Mary's Road symbol font for theoretical computer science are inserted into formulas");
+ packages["undertilde"] =
+ N_("The LaTeX package undertilde is only used if you use the math frame decoration 'utilde'");
}
return packages;
}
Bullet & BufferParams::temp_bullet(lyx::size_type const index)
{
- LASSERT(index < 4, /**/);
+ LASSERT(index < 4, return pimpl_->temp_bullets[0]);
return pimpl_->temp_bullets[index];
}
Bullet const & BufferParams::temp_bullet(lyx::size_type const index) const
{
- LASSERT(index < 4, /**/);
+ LASSERT(index < 4, return pimpl_->temp_bullets[0]);
return pimpl_->temp_bullets[index];
}
Bullet & BufferParams::user_defined_bullet(lyx::size_type const index)
{
- LASSERT(index < 4, /**/);
+ LASSERT(index < 4, return pimpl_->temp_bullets[0]);
return pimpl_->user_defined_bullets[index];
}
Bullet const & BufferParams::user_defined_bullet(lyx::size_type const index) const
{
- LASSERT(index < 4, /**/);
+ LASSERT(index < 4, return pimpl_->temp_bullets[0]);
return pimpl_->user_defined_bullets[index];
}
// be available.
string tcp;
LayoutFileList & bcl = LayoutFileList::get();
- if (tcp.empty() && !filepath.empty())
+ if (!filepath.empty())
tcp = bcl.addLocalLayout(classname, filepath.absFileName());
+ // that returns non-empty if a "local" layout file is found.
if (!tcp.empty())
setBaseClass(tcp);
else
} else if (token == "\\begin_preamble") {
readPreamble(lex);
} else if (token == "\\begin_local_layout") {
- readLocalLayout(lex);
+ readLocalLayout(lex, false);
+ } else if (token == "\\begin_forced_local_layout") {
+ readLocalLayout(lex, true);
} else if (token == "\\begin_modules") {
readModules(lex);
} else if (token == "\\begin_removed_modules") {
<< convert<string>(maintain_unincluded_children) << '\n';
// local layout information
+ string const local_layout = getLocalLayout(false);
if (!local_layout.empty()) {
// remove '\n' from the end
string const tmplocal = rtrim(local_layout, "\n");
<< tmplocal
<< "\n\\end_local_layout\n";
}
+ string const forced_local_layout = getLocalLayout(true);
+ if (!forced_local_layout.empty()) {
+ // remove '\n' from the end
+ string const tmplocal = rtrim(forced_local_layout, "\n");
+ os << "\\begin_forced_local_layout\n"
+ << tmplocal
+ << "\n\\end_forced_local_layout\n";
+ }
// then the text parameters
if (language != ignore_language)
os << "\\papersize " << string_papersize[papersize]
<< "\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]);
+ map<string, string> const & packages = auto_packages();
+ for (map<string, string>::const_iterator it = packages.begin();
+ it != packages.end(); ++it)
+ os << "\n\\use_package " << it->first << ' '
+ << use_package(it->first);
os << "\n\\cite_engine ";
if (pdfoptions().colorlinks)
features.require("color");
}
+ if (!listings_params.empty()) {
+ // do not test validity because listings_params is
+ // supposed to be valid
+ string par =
+ InsetListingsParams(listings_params).separatedParams(true);
+ // we can't support all packages, but we should load the color package
+ if (par.find("\\color", 0) != string::npos)
+ features.require("color");
+ }
// some languages are only available via polyglossia
if (features.runparams().flavor == OutputParams::XETEX
os << '{' << from_ascii(tclass.latexname()) << "}\n";
// end of \documentclass defs
- // if we use fontspec, we have to load the AMS packages here
+ // if we use fontspec or newtxmath, we have to load the AMS packages here
string const ams = features.loadAMSPackages();
- if (useNonTeXFonts && !ams.empty())
+ bool const ot1 = (font_encoding() == "default" || font_encoding() == "OT1");
+ bool const use_newtxmath =
+ theLaTeXFonts().getLaTeXFont(from_ascii(fonts_math)).getUsedPackage(
+ ot1, false, false) == "newtxmath";
+ if ((useNonTeXFonts || use_newtxmath) && !ams.empty())
os << from_ascii(ams);
if (useNonTeXFonts) {
// XeTeX and LuaTeX (with OS fonts) work without fontenc
if (font_encoding() != "default" && language->lang() != "japanese"
&& !useNonTeXFonts && !features.isProvided("fontenc")) {
+ docstring extra_encoding;
+ if (features.mustProvide("textgreek"))
+ extra_encoding += from_ascii("LGR");
+ if (features.mustProvide("textcyr")) {
+ if (!extra_encoding.empty())
+ extra_encoding.push_back(',');
+ extra_encoding += from_ascii("T2A");
+ }
+ if (!extra_encoding.empty() && !font_encoding().empty())
+ extra_encoding.push_back(',');
size_t fars = language_options.str().find("farsi");
size_t arab = language_options.str().find("arabic");
if (language->lang() == "arabic_arabi"
|| language->lang() == "farsi" || fars != string::npos
|| arab != string::npos) {
- os << "\\usepackage[" << from_ascii(font_encoding())
+ os << "\\usepackage[" << extra_encoding
+ << from_ascii(font_encoding())
<< ",LFE,LAE]{fontenc}\n";
} else {
- os << "\\usepackage[" << from_ascii(font_encoding())
+ os << "\\usepackage[" << extra_encoding
+ << from_ascii(font_encoding())
<< "]{fontenc}\n";
}
}
os << "}\n";
}
- if (!listings_params.empty() || features.isRequired("listings"))
- os << "\\usepackage{listings}\n";
-
- if (!listings_params.empty()) {
- os << "\\lstset{";
- // do not test validity because listings_params is
- // supposed to be valid
- string par =
- InsetListingsParams(listings_params).separatedParams(true);
- // we can't support all packages, but we should load the color package
- if (par.find("\\color", 0) != string::npos)
- features.require("color");
- os << from_utf8(par)
- << "}\n";
- }
if (!features.isProvided("geometry")
&& (use_geometry || nonstandard_papersize)) {
odocstringstream ods;
// http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg144349.html
lyxpreamble += from_ascii(features.getColorOptions());
- // If we use hyperref, jurabib, japanese, or vietnamese, we have to call babel before them.
+ // If we use hyperref, jurabib, japanese, varioref or vietnamese,
+ // we have to call babel before
if (use_babel
&& (features.isRequired("jurabib")
|| features.isRequired("hyperref")
+ || features.isRequired("varioref")
|| features.isRequired("vietnamese")
|| features.isRequired("japanese"))) {
// FIXME UNICODE
+ atlyxpreamble + "\\makeatother\n\n";
// We try to load babel late, in case it interferes with other packages.
- // Jurabib and Hyperref have to be called after babel, though.
+ // Jurabib, hyperref, varioref and listings (bug 8995) have to be
+ // called after babel, though.
if (use_babel && !features.isRequired("jurabib")
&& !features.isRequired("hyperref")
+ && !features.isRequired("varioref")
&& !features.isRequired("vietnamese")
&& !features.isRequired("japanese")) {
// FIXME UNICODE
features.needBabelLangOptions())) + '\n';
lyxpreamble += from_utf8(features.getBabelPostsettings());
}
+ if (!listings_params.empty() || features.isRequired("listings"))
+ lyxpreamble += "\\usepackage{listings}\n";
+ if (!listings_params.empty()) {
+ lyxpreamble += "\\lstset{";
+ // do not test validity because listings_params is
+ // supposed to be valid
+ string par =
+ InsetListingsParams(listings_params).separatedParams(true);
+ lyxpreamble += from_utf8(par);
+ lyxpreamble += "}\n";
+ }
// xunicode needs to be loaded at least after amsmath, amssymb,
// esint and the other packages that provide special glyphs
- if (features.runparams().flavor == OutputParams::XETEX)
+ if (features.runparams().flavor == OutputParams::XETEX
+ && useNonTeXFonts)
lyxpreamble += "\\usepackage{xunicode}\n";
// Polyglossia must be loaded last
}
-void BufferParams::makeDocumentClass()
+void BufferParams::makeDocumentClass(bool const clone)
{
if (!baseClass())
return;
for (; it != en; ++it)
mods.push_back(*it);
- doc_class_ = getDocumentClass(*baseClass(), mods);
+ doc_class_ = getDocumentClass(*baseClass(), mods, clone);
- if (!local_layout.empty()) {
- TextClass::ReturnValues success =
- doc_class_->read(local_layout, TextClass::MODULE);
- if (success != TextClass::OK && success != TextClass::OK_OLDFORMAT) {
- docstring const msg = _("Error reading internal layout information");
- frontend::Alert::warning(_("Read Error"), msg);
- }
+ TextClass::ReturnValues success = TextClass::OK;
+ if (!forced_local_layout_.empty())
+ success = doc_class_->read(forced_local_layout_, TextClass::MODULE);
+ if (!local_layout_.empty() &&
+ (success == TextClass::OK || success == TextClass::OK_OLDFORMAT))
+ success = doc_class_->read(local_layout_, TextClass::MODULE);
+ if (success != TextClass::OK && success != TextClass::OK_OLDFORMAT) {
+ docstring const msg = _("Error reading internal layout information");
+ frontend::Alert::warning(_("Read Error"), msg);
}
}
-bool BufferParams::moduleCanBeAdded(string const & modName) const
+bool BufferParams::layoutModuleCanBeAdded(string const & modName) const
{
- return cite_engine_.moduleCanBeAdded(modName, baseClass()) &&
- layout_modules_.moduleCanBeAdded(modName, baseClass());
+ return layout_modules_.moduleCanBeAdded(modName, baseClass());
+}
+
+
+bool BufferParams::citationModuleCanBeAdded(string const & modName) const
+{
+ return cite_engine_.moduleCanBeAdded(modName, baseClass());
+}
+
+
+std::string BufferParams::getLocalLayout(bool forced) const
+{
+ if (forced)
+ return doc_class_->forcedLayouts();
+ else
+ return local_layout_;
+}
+
+
+void BufferParams::setLocalLayout(string const & layout, bool forced)
+{
+ if (forced)
+ forced_local_layout_ = layout;
+ else
+ local_layout_ = layout;
}
}
-namespace {
-
-bool formatSorter(Format const * lhs, Format const * rhs)
-{
- return _(lhs->prettyname()) < _(rhs->prettyname());
-}
-
-}
-
-
vector<Format const *> BufferParams::exportableFormats(bool only_viewable) const
{
vector<string> const backs = backends();
theConverters().getReachable(*it, only_viewable, false, excludes);
result.insert(result.end(), r.begin(), r.end());
}
- sort(result.begin(), result.end(), formatSorter);
return result;
}
v.push_back("xetex");
} else if (buffmt == "xetex") {
v.push_back("xetex");
- v.push_back("luatex");
- v.push_back("dviluatex");
+ // FIXME: need to test all languages (bug 8205)
+ if (!language || !language->isPolyglossiaExclusive()) {
+ v.push_back("luatex");
+ v.push_back("dviluatex");
+ }
} else
v.push_back(buffmt);
&& default_output_format != "default")
return default_output_format;
if (isDocBook()
- || useNonTeXFonts
|| encoding().package() == Encoding::japanese) {
vector<Format const *> const formats = exportableFormats(true);
if (formats.empty())
// return the first we find
return formats.front()->name();
}
+ if (useNonTeXFonts)
+ return lyxrc.default_otf_view_format;
return lyxrc.default_view_format;
}
}
-void BufferParams::readLocalLayout(Lexer & lex)
+void BufferParams::readLocalLayout(Lexer & lex, bool forced)
{
- if (lex.getString() != "\\begin_local_layout")
+ string const expected = forced ? "\\begin_forced_local_layout" :
+ "\\begin_local_layout";
+ if (lex.getString() != expected)
lyxerr << "Error (BufferParams::readLocalLayout):"
"consistency check failed." << endl;
- local_layout = lex.getLongString("\\end_local_layout");
+ if (forced)
+ forced_local_layout_ =
+ lex.getLongString("\\end_forced_local_layout");
+ else
+ local_layout_ = lex.getLongString("\\end_local_layout");
}
// do not load inputenc if japanese is used
if (features.isRequired("japanese"))
break;
- os << "\\usepackage[" << from_ascii(inputenc)
+ os << "\\usepackage[" << from_ascii(encoding().latexName())
<< "]{inputenc}\n";
break;
case Encoding::CJK:
os << "\\usepackage{CJK}\n";
break;
}
+ // Load the CJK package if needed by a secondary language.
+ // If the main encoding is some variant of UTF8, use CJKutf8.
+ if (encoding().package() != Encoding::CJK && features.mustProvide("CJK")) {
+ if (encoding().iconvName() == "UTF-8"
+ && LaTeXFeatures::isAvailable("CJKutf8"))
+ os << "\\usepackage{CJKutf8}\n";
+ else
+ os << "\\usepackage{CJK}\n";
+ }
}
}
// This check will not work with XeTeX/LuaTeX and tex fonts.
// Thus we have to reset the encoding in Buffer::makeLaTeXFile.
if (useNonTeXFonts)
- return *(encodings.fromLaTeXName("utf8-plain"));
+ return *(encodings.fromLyXName("utf8-plain"));
if (inputenc == "auto" || inputenc == "default")
return *language->encoding();
- Encoding const * const enc = encodings.fromLaTeXName(inputenc);
+ Encoding const * const enc = encodings.fromLyXName(inputenc);
if (enc)
return *enc;
LYXERR0("Unknown inputenc value `" << inputenc