#include "Color.h"
#include "ColorSet.h"
#include "Encoding.h"
+#include "IndicesList.h"
#include "Language.h"
#include "LaTeXFeatures.h"
#include "ModuleList.h"
};
+
namespace lyx {
// Local translators
return translator;
}
-
} // anon namespace
BranchList branchlist;
Bullet temp_bullets[4];
Bullet user_defined_bullets[4];
+ IndicesList indiceslist;
Spacing spacing;
/** This is the amount of space used for paragraph_separation "skip",
* and for detached paragraphs in "indented" documents.
use_esint = package_auto;
cite_engine_ = ENGINE_BASIC;
use_bibtopic = false;
+ use_indices = false;
trackChanges = false;
outputChanges = false;
use_default_options = true;
fontsSans = "default";
fontsTypewriter = "default";
fontsDefaultFamily = "default";
+ useXetex = false;
fontsSC = false;
fontsOSF = false;
fontsSansScale = 100;
fontsTypewriterScale = 100;
inputenc = "auto";
graphicsDriver = "default";
+ defaultOutputFormat = "default";
+ bibtex_command = "default";
+ index_command = "default";
sides = OneSide;
columns = 1;
listings_params = string();
pagestyle = "default";
+ // white is equal to no background color
+ backgroundcolor = lyx::rgbFromHexName("#ffffff");
compressed = false;
for (int iter = 0; iter < 4; ++iter) {
user_defined_bullet(iter) = ITEMIZE_DEFAULTS[iter];
temp_bullet(iter) = ITEMIZE_DEFAULTS[iter];
}
+ // default index
+ indiceslist().addDefault(B_("Index"));
}
}
+IndicesList & BufferParams::indiceslist()
+{
+ return pimpl_->indiceslist;
+}
+
+
+IndicesList const & BufferParams::indiceslist() const
+{
+ return pimpl_->indiceslist;
+}
+
+
Bullet & BufferParams::temp_bullet(lyx::size_type const index)
{
LASSERT(index < 4, /**/);
lex >> inputenc;
} else if (token == "\\graphics") {
readGraphicsDriver(lex);
+ } else if (token == "\\default_output_format") {
+ lex >> defaultOutputFormat;
+ } else if (token == "\\bibtex_command") {
+ lex.eatLine();
+ bibtex_command = lex.getString();
+ } else if (token == "\\index_command") {
+ lex.eatLine();
+ index_command = lex.getString();
} else if (token == "\\font_roman") {
- lex >> fontsRoman;
+ lex.eatLine();
+ fontsRoman = lex.getString();
} else if (token == "\\font_sans") {
- lex >> fontsSans;
+ lex.eatLine();
+ fontsSans = lex.getString();
} else if (token == "\\font_typewriter") {
- lex >> fontsTypewriter;
+ lex.eatLine();
+ fontsTypewriter = lex.getString();
} else if (token == "\\font_default_family") {
lex >> fontsDefaultFamily;
+ } else if (token == "\\use_xetex") {
+ lex >> useXetex;
} else if (token == "\\font_sc") {
lex >> fontsSC;
} else if (token == "\\font_osf") {
cite_engine_ = citeenginetranslator().find(engine);
} else if (token == "\\use_bibtopic") {
lex >> use_bibtopic;
+ } else if (token == "\\use_indices") {
+ lex >> use_indices;
} else if (token == "\\tracking_changes") {
lex >> trackChanges;
} else if (token == "\\output_changes") {
color = lcolor.getX11Name(Color_background);
// FIXME UNICODE
lcolor.setColor(to_utf8(branch), color);
-
+ }
+ }
+ } else if (token == "\\index") {
+ lex.eatLine();
+ docstring index = lex.getDocString();
+ indiceslist().add(index);
+ while (true) {
+ lex.next();
+ string const tok = lex.getString();
+ if (tok == "\\end_index")
+ break;
+ Index * index_ptr = indiceslist().find(index);
+ if (tok == "\\shortcut") {
+ lex.next();
+ if (index_ptr)
+ index_ptr->setShortcut(lex.getDocString());
+ }
+ // not yet operational
+ if (tok == "\\color") {
+ lex.eatLine();
+ string color = lex.getString();
+ if (index_ptr)
+ index_ptr->setColor(color);
+ // Update also the Color table:
+ if (color == "none")
+ color = lcolor.getX11Name(Color_background);
+ // FIXME UNICODE
+ lcolor.setColor(to_utf8(index), color);
}
}
} else if (token == "\\author") {
string orient;
lex >> orient;
orientation = paperorientationtranslator().find(orient);
+ } else if (token == "\\backgroundcolor") {
+ lex.eatLine();
+ backgroundcolor = lyx::rgbFromHexName(lex.getString());
} else if (token == "\\paperwidth") {
lex >> paperwidth;
} else if (token == "\\paperheight") {
<< "\n\\font_sans " << fontsSans
<< "\n\\font_typewriter " << fontsTypewriter
<< "\n\\font_default_family " << fontsDefaultFamily
+ << "\n\\use_xetex " << convert<string>(useXetex)
<< "\n\\font_sc " << convert<string>(fontsSC)
<< "\n\\font_osf " << convert<string>(fontsOSF)
<< "\n\\font_sf_scale " << fontsSansScale
os << "\\font_cjk " << fontsCJK << '\n';
}
os << "\n\\graphics " << graphicsDriver << '\n';
+ os << "\\default_output_format " << defaultOutputFormat << '\n';
+ os << "\\bibtex_command " << bibtex_command << '\n';
+ os << "\\index_command " << index_command << '\n';
if (!float_placement.empty()) {
os << "\\float_placement " << float_placement << '\n';
<< "\n\\use_esint " << use_esint
<< "\n\\cite_engine " << citeenginetranslator().find(cite_engine_)
<< "\n\\use_bibtopic " << convert<string>(use_bibtopic)
+ << "\n\\use_indices " << convert<string>(use_indices)
<< "\n\\paperorientation " << string_orientation[orientation]
<< '\n';
+ if (backgroundcolor != lyx::rgbFromHexName("#ffffff"))
+ os << "\\backgroundcolor " << lyx::X11hexname(backgroundcolor) << '\n';
BranchList::const_iterator it = branchlist().begin();
BranchList::const_iterator end = branchlist().end();
<< "\n";
}
+ IndicesList::const_iterator iit = indiceslist().begin();
+ IndicesList::const_iterator iend = indiceslist().end();
+ for (; iit != iend; ++iit) {
+ os << "\\index " << to_utf8(iit->index())
+ << "\n\\shortcut " << to_utf8(iit->shortcut())
+ << "\n\\color " << lyx::X11hexname(iit->color())
+ << "\n\\end_index"
+ << "\n";
+ }
+
if (!paperwidth.empty())
os << "\\paperwidth "
<< VSpace(paperwidth).asLyXCommand() << '\n';
}
break;
case OutputParams::PDFLATEX:
+ case OutputParams::XETEX:
if (xcolorulem) {
features.require("ct-xcolor-ulem");
features.require("ulem");
features.require("color");
}
+ if (useXetex)
+ features.require("xetex");
+
if (language->lang() == "vietnamese")
features.require("vietnamese");
else if (language->lang() == "japanese")
texrow.newline();
// end of \documentclass defs
+ if (useXetex) {
+ os << "\\usepackage{fontspec}\n";
+ texrow.newline();
+ }
+
// font selection must be done before loading fontenc.sty
string const fonts =
loadFonts(fontsRoman, fontsSans,
fontsTypewriter, fontsSC, fontsOSF,
- fontsSansScale, fontsTypewriterScale);
+ fontsSansScale, fontsTypewriterScale, useXetex);
if (!fonts.empty()) {
os << from_ascii(fonts);
texrow.newline();
// this one is not per buffer
// for arabic_arabi and farsi we also need to load the LAE and
// LFE encoding
- if (lyxrc.fontenc != "default" && language->lang() != "japanese") {
+ // XeTeX works without fontenc
+ if (lyxrc.fontenc != "default" && language->lang() != "japanese"
+ && !useXetex) {
if (language->lang() == "arabic_arabi"
|| language->lang() == "farsi") {
os << "\\usepackage[" << from_ascii(lyxrc.fontenc)
texrow.newline();
}
+ // only output when the background color is not white
+ if (backgroundcolor != lyx::rgbFromHexName("#ffffff")) {
+ // only require color here, the background color will be defined
+ // in LaTeXFeatures.cpp to avoid interferences with the LaTeX
+ // package pdfpages
+ features.require("color");
+ features.require("pagecolor");
+ }
+
// Only if class has a ToC hierarchy
if (tclass.hasTocLevels()) {
if (secnumdepth != tclass.secnumdepth()) {
// The optional packages;
lyxpreamble += from_ascii(features.getPackages());
+ // Additional Indices
+ if (features.isRequired("splitidx")) {
+ IndicesList::const_iterator iit = indiceslist().begin();
+ IndicesList::const_iterator iend = indiceslist().end();
+ for (; iit != iend; ++iit) {
+ lyxpreamble += "\\newindex[";
+ lyxpreamble += iit->index();
+ lyxpreamble += "]{";
+ lyxpreamble += iit->shortcut();
+ lyxpreamble += "}\n";
+ }
+ }
+
// Line spacing
lyxpreamble += from_utf8(spacing().writePreamble(tclass.provides("SetSpace")));
lyxpreamble += oss.str();
}
- // Will be surrounded by \makeatletter and \makeatother when needed
+ // Will be surrounded by \makeatletter and \makeatother when not empty
docstring atlyxpreamble;
// Some macros LyX will need
+ tmppreamble + '\n';
/* the user-defined preamble */
- if (!preamble.empty())
+ if (!containsOnly(preamble, " \n\t"))
// FIXME UNICODE
atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
"User specified LaTeX commands.\n"
if (!bullets_def.empty())
atlyxpreamble += bullets_def + "}\n\n";
- if (atlyxpreamble.find(from_ascii("@")) != docstring::npos)
+ if (!atlyxpreamble.empty())
lyxpreamble += "\n\\makeatletter\n"
+ atlyxpreamble + "\\makeatother\n\n";
- else
- lyxpreamble += '\n' + atlyxpreamble;
// We try to load babel late, in case it interferes with other packages.
// Jurabib and Hyperref have to be called after babel, though.
}
os << lyxpreamble;
+
+ // these packages (xunicode, for that matter) need to be loaded at least
+ // after amsmath, amssymb, esint and the other packages that provide
+ // special glyphs
+ if (useXetex) {
+ os << "\\usepackage{xunicode}\n";
+ texrow.newline();
+ os << "\\usepackage{xltxtra}\n";
+ texrow.newline();
+ }
return use_babel;
}
void BufferParams::writeEncodingPreamble(odocstream & os,
LaTeXFeatures & features, TexRow & texrow) const
{
+ if (useXetex)
+ return;
if (inputenc == "auto") {
string const doc_encoding =
language->encoding()->latexName();
}
+string const BufferParams::parseFontName(string const & name) const
+{
+ string mangled = name;
+ size_t const idx = mangled.find('[');
+ if (idx == string::npos || idx == 0)
+ return mangled;
+ else
+ return mangled.substr(0, idx - 1);
+}
+
+
string const BufferParams::loadFonts(string const & rm,
string const & sf, string const & tt,
bool const & sc, bool const & osf,
- int const & sfscale, int const & ttscale) const
+ int const & sfscale, int const & ttscale,
+ bool const & xetex) const
{
/* The LaTeX font world is in a flux. In the PSNFSS font interface,
several packages have been replaced by others, that might not
ostringstream os;
+ if (xetex) {
+ if (rm != "default")
+ os << "\\setmainfont[Mapping=tex-text]{"
+ << parseFontName(rm) << "}\n";
+ if (sf != "default") {
+ string const sans = parseFontName(sf);
+ if (sfscale != 100)
+ os << "\\setsansfont[Scale="
+ << float(sfscale) / 100
+ << ",Mapping=tex-text]{"
+ << sans << "}\n";
+ else
+ os << "\\setsansfont[Mapping=tex-text]{"
+ << sans << "}\n";
+ }
+ if (tt != "default") {
+ string const mono = parseFontName(tt);
+ if (ttscale != 100)
+ os << "\\setmonofont[Scale="
+ << float(sfscale) / 100
+ << "]{"
+ << mono << "}\n";
+ else
+ os << "\\setmonofont[Mapping=tex-text]{"
+ << mono << "}\n";
+ }
+ if (osf)
+ os << "\\defaultfontfeatures{Numbers=OldStyle}\n";
+ return os.str();
+ }
+
// ROMAN FONTS
// Computer Modern (must be explicitely selectable -- there might be classes
// that define a different default font!
Encoding const & BufferParams::encoding() const
{
+ if (useXetex)
+ return *(encodings.fromLaTeXName("utf8-plain"));
if (inputenc == "auto" || inputenc == "default")
return *language->encoding();
Encoding const * const enc = encodings.fromLaTeXName(inputenc);
projects / lyx.git / blobdiff