#include "Bullet.h"
#include "Color.h"
#include "ColorSet.h"
+#include "Converter.h"
#include "Encoding.h"
#include "HSpace.h"
#include "IndicesList.h"
use_esint = package_auto;
use_mhchem = package_auto;
use_mathdots = package_auto;
+ use_undertilde = package_auto;
cite_engine_ = ENGINE_BASIC;
use_bibtopic = false;
use_indices = false;
html_be_strict = false;
html_math_output = MathML;
html_math_img_scale = 1.0;
+ html_css_as_file = false;
output_sync = false;
use_refstyle = true;
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 == "\\cite_engine") {
string engine;
lex >> engine;
html_math_output = static_cast<MathOutput>(temp);
} else if (token == "\\html_be_strict") {
lex >> html_be_strict;
+ } else if (token == "\\html_css_as_file") {
+ lex >> html_css_as_file;
} else if (token == "\\html_math_img_scale") {
lex >> html_math_img_scale;
} else if (token == "\\html_latex_start") {
<< "\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_bibtopic " << convert<string>(use_bibtopic)
<< "\n\\use_indices " << convert<string>(use_indices)
}
os << "\\tracking_changes " << convert<string>(trackChanges) << '\n'
- << "\\output_changes " << convert<string>(outputChanges) << '\n'
- << "\\html_math_output " << html_math_output << '\n'
- << "\\html_be_strict " << convert<string>(html_be_strict) << '\n';
+ << "\\output_changes " << convert<string>(outputChanges) << '\n'
+ << "\\html_math_output " << html_math_output << '\n'
+ << "\\html_css_as_file " << html_css_as_file << '\n'
+ << "\\html_be_strict " << convert<string>(html_be_strict) << '\n';
if (html_math_img_scale != 1.0)
os << "\\html_math_img_scale " << convert<string>(html_math_img_scale) << '\n';
switch (features.runparams().flavor) {
case OutputParams::LATEX:
+ case OutputParams::DVILUATEX:
if (dvipost) {
features.require("ct-dvipost");
features.require("dvipost");
features.require("mhchem");
if (use_mathdots == package_on)
features.require("mathdots");
+ if (use_undertilde == package_on)
+ features.require("undertilde");
// Document-level line spacing
if (spacing().getSpace() != Spacing::Single && !spacing().isDefault())
// http://www.tug.org/texmf-dist/doc/latex/base/fixltx2e.pdf
// !! To use the Fix-cm package, load it before \documentclass, and use the command
// \RequirePackage to do so, rather than the normal \usepackage
- // Do not to load any other package before the document class, unless you
+ // Do not try to load any other package before the document class, unless you
// have a thorough understanding of the LATEX internals and know exactly what you
// are doing!
if (features.mustProvide("fix-cm"))
fonts_sans_scale, fonts_typewriter_scale,
useNonTeXFonts, features);
if (!fonts.empty())
- os << from_ascii(fonts);
+ os << from_utf8(fonts);
if (fonts_default_family != "default")
os << "\\renewcommand{\\familydefault}{\\"
// Now insert the LyX specific LaTeX commands...
docstring lyxpreamble;
+ features.resolveAlternatives();
if (output_sync) {
if (!output_sync_macro.empty())
doc_class_ = &(DocumentClassBundle::get().makeDocumentClass(*baseClass(), layout_modules_));
if (!local_layout.empty()) {
- if (!doc_class_->read(local_layout, TextClass::MODULE)) {
+ 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);
}
}
+string BufferParams::bufferFormat() const
+{
+ string format = documentClass().outputFormat();
+ if (format == "latex") {
+ if (useNonTeXFonts)
+ return "xetex";
+ if (encoding().package() == Encoding::japanese)
+ return "platex";
+ }
+ return format;
+}
+
+
+bool BufferParams::isExportable(string const & format) const
+{
+ vector<string> backs = backends();
+ for (vector<string>::const_iterator it = backs.begin();
+ it != backs.end(); ++it)
+ if (theConverters().isReachable(*it, format))
+ return true;
+ return false;
+}
+
+
+vector<Format const *> BufferParams::exportableFormats(bool only_viewable) const
+{
+ vector<string> const backs = backends();
+ set<string> excludes;
+ if (useNonTeXFonts) {
+ excludes.insert("latex");
+ excludes.insert("pdflatex");
+ }
+ vector<Format const *> result =
+ theConverters().getReachable(backs[0], only_viewable, true, excludes);
+ for (vector<string>::const_iterator it = backs.begin() + 1;
+ it != backs.end(); ++it) {
+ vector<Format const *> r =
+ theConverters().getReachable(*it, only_viewable, false, excludes);
+ result.insert(result.end(), r.begin(), r.end());
+ }
+ return result;
+}
+
+
+bool BufferParams::isExportableFormat(string const & format) const
+{
+ typedef vector<Format const *> Formats;
+ Formats formats;
+ formats = exportableFormats(true);
+ Formats::const_iterator fit = formats.begin();
+ Formats::const_iterator end = formats.end();
+ for (; fit != end ; ++fit) {
+ if ((*fit)->name() == format)
+ return true;
+ }
+ return false;
+}
+
+
+vector<string> BufferParams::backends() const
+{
+ vector<string> v;
+ v.push_back(bufferFormat());
+ // FIXME: Don't hardcode format names here, but use a flag
+ if (v.back() == "latex") {
+ v.push_back("pdflatex");
+ v.push_back("luatex");
+ v.push_back("dviluatex");
+ v.push_back("xetex");
+ } else if (v.back() == "xetex") {
+ v.push_back("luatex");
+ v.push_back("dviluatex");
+ }
+ v.push_back("xhtml");
+ v.push_back("text");
+ v.push_back("lyx");
+ return v;
+}
+
+
+OutputParams::FLAVOR BufferParams::getOutputFlavor(string const format) const
+{
+ string const dformat = (format.empty() || format == "default") ?
+ getDefaultOutputFormat() : format;
+ DefaultFlavorCache::const_iterator it =
+ default_flavors_.find(dformat);
+
+ if (it != default_flavors_.end())
+ return it->second;
+
+ OutputParams::FLAVOR result = OutputParams::LATEX;
+
+ if (dformat == "xhtml")
+ result = OutputParams::HTML;
+ else {
+ // Try to determine flavor of default output format
+ vector<string> backs = backends();
+ if (find(backs.begin(), backs.end(), dformat) == backs.end()) {
+ // Get shortest path to format
+ Graph::EdgePath path;
+ for (vector<string>::const_iterator it = backs.begin();
+ it != backs.end(); ++it) {
+ Graph::EdgePath p = theConverters().getPath(*it, dformat);
+ if (!p.empty() && (path.empty() || p.size() < path.size())) {
+ path = p;
+ }
+ }
+ if (!path.empty())
+ result = theConverters().getFlavor(path);
+ }
+ }
+ // cache this flavor
+ default_flavors_[dformat] = result;
+ return result;
+}
+
+
+string BufferParams::getDefaultOutputFormat() const
+{
+ if (!default_output_format.empty()
+ && 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 string();
+ // return the first we find
+ return formats.front()->name();
+ }
+ return lyxrc.default_view_format;
+}
+
Font const BufferParams::getFont() const
{
FontInfo f = documentClass().defaultfont();
}
+bool BufferParams::isLatex() const
+{
+ return documentClass().outputType() == LATEX;
+}
+
+
+bool BufferParams::isLiterate() const
+{
+ return documentClass().outputType() == LITERATE;
+}
+
+
+bool BufferParams::isDocBook() const
+{
+ return documentClass().outputType() == DOCBOOK;
+}
+
+
void BufferParams::readPreamble(Lexer & lex)
{
if (lex.getString() != "\\begin_preamble")
}
+bool BufferParams::setLanguage(string const & lang)
+{
+ Language const *new_language = languages.getLanguage(lang);
+ if (!new_language) {
+ // Language lang was not found
+ return false;
+ }
+ language = new_language;
+ return true;
+}
+
+
void BufferParams::readLanguage(Lexer & lex)
{
if (!lex.next()) return;
string const tmptok = lex.getString();
// check if tmptok is part of tex_babel in tex-defs.h
- language = languages.getLanguage(tmptok);
- if (!language) {
+ if (!setLanguage(tmptok)) {
// Language tmptok was not found
language = default_language;
lyxerr << "Warning: Setting language `"
return;
// LuaTeX neither, but with tex fonts, we need to load
// the luainputenc package.
- if (features.runparams().flavor == OutputParams::LUATEX) {
+ if (features.runparams().flavor == OutputParams::LUATEX
+ || features.runparams().flavor == OutputParams::DVILUATEX) {
if (!useNonTeXFonts && inputenc != "default"
&& ((inputenc == "auto" && language->encoding()->package() == Encoding::inputenc)
|| (inputenc != "auto" && encoding().package() == Encoding::inputenc))) {
// didn't understand "Mapping=tex-text", while XeTeX
// understood both. With most recent versions, both
// variants are understood by both engines. However,
- // we want to provide support for at least TeXLive 2009.
+ // we want to provide support for at least TeXLive 2009
+ // (for XeTeX; LuaTeX is only supported as of v.2)
string const texmapping =
(features.runparams().flavor == OutputParams::XETEX) ?
"Mapping=tex-text" : "Ligatures=TeX";
projects / lyx.git / blobdiff