#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;
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;
<< "\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)
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}{\\"
case PAPER_JISB6:
ods << ",b6j";
break;
- default:
- // default papersize ie PAPER_DEFAULT
- switch (lyxrc.default_papersize) {
- case PAPER_DEFAULT: // keep compiler happy
- break;
- case PAPER_USLETTER:
- ods << ",letterpaper";
- break;
- case PAPER_USLEGAL:
- ods << ",legalpaper";
- break;
- case PAPER_USEXECUTIVE:
- ods << ",executivepaper";
- break;
- case PAPER_A3:
- ods << ",a3paper";
- break;
- case PAPER_A4:
- ods << ",a4paper";
- break;
- case PAPER_A5:
- ods << ",a5paper";
- break;
- case PAPER_B5:
- ods << ",b5paper";
- break;
- case PAPER_A0:
- case PAPER_A1:
- case PAPER_A2:
- case PAPER_A6:
- case PAPER_B0:
- case PAPER_B1:
- case PAPER_B2:
- case PAPER_B3:
- case PAPER_B4:
- case PAPER_B6:
- case PAPER_C0:
- case PAPER_C1:
- case PAPER_C2:
- case PAPER_C3:
- case PAPER_C4:
- case PAPER_C5:
- case PAPER_C6:
- case PAPER_JISB0:
- case PAPER_JISB1:
- case PAPER_JISB2:
- case PAPER_JISB3:
- case PAPER_JISB4:
- case PAPER_JISB5:
- case PAPER_JISB6:
- case PAPER_CUSTOM:
- break;
- }
+ case PAPER_DEFAULT:
+ break;
}
docstring const g_options = trim(ods.str(), ",");
os << "\\usepackage";
// Now insert the LyX specific LaTeX commands...
docstring lyxpreamble;
+ features.resolveAlternatives();
if (output_sync) {
if (!output_sync_macro.empty())
}
+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")
string BufferParams::paperSizeName(PapersizePurpose purpose) const
{
- char real_papersize = papersize;
- if (real_papersize == PAPER_DEFAULT)
- real_papersize = lyxrc.default_papersize;
-
- switch (real_papersize) {
+ switch (papersize) {
case PAPER_DEFAULT:
// could be anything, so don't guess
return string();
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))) {