fonts_roman = "default";
fonts_sans = "default";
fonts_typewriter = "default";
+ fonts_math = "auto";
fonts_default_family = "default";
useNonTeXFonts = false;
fonts_expert_sc = false;
} else if (token == "\\font_typewriter") {
lex.eatLine();
fonts_typewriter = lex.getString();
+ } else if (token == "\\font_math") {
+ lex.eatLine();
+ fonts_math = lex.getString();
} else if (token == "\\font_default_family") {
lex >> fonts_default_family;
} else if (token == "\\use_non_tex_fonts") {
<< "\n\\font_roman " << fonts_roman
<< "\n\\font_sans " << fonts_sans
<< "\n\\font_typewriter " << fonts_typewriter
+ << "\n\\font_math " << fonts_math
<< "\n\\font_default_family " << fonts_default_family
<< "\n\\use_non_tex_fonts " << convert<string>(useNonTeXFonts)
<< "\n\\font_sc " << convert<string>(fonts_expert_sc)
{
features.require(documentClass().requires());
+ if (columns > 1 && language->rightToLeft())
+ features.require("rtloutputdblcol");
+
if (outputChanges) {
bool dvipost = LaTeXFeatures::isAvailable("dvipost");
bool xcolorulem = LaTeXFeatures::isAvailable("ulem") &&
if (it->first == "amsmath") {
// AMS Style is at document level
if (it->second == package_on ||
- documentClass().provides("amsmath"))
+ features.isProvided("amsmath"))
features.require(it->first);
} else if (it->second == package_on)
features.require(it->first);
|| useNonTeXFonts))
features.require("polyglossia");
+ if (useNonTeXFonts && fonts_math != "auto")
+ features.require("unicode-math");
+
if (!language->requires().empty())
features.require(language->requires());
}
features.useLanguage(default_language);
ostringstream language_options;
- bool const use_babel = features.useBabel() && !tclass.provides("babel");
+ bool const use_babel = features.useBabel() && !features.isProvided("babel");
bool const use_polyglossia = features.usePolyglossia();
bool const global = lyxrc.language_global_options;
if (use_babel || (use_polyglossia && global)) {
if (useNonTeXFonts && !ams.empty())
os << from_ascii(ams);
- if (useNonTeXFonts)
+ if (useNonTeXFonts) {
os << "\\usepackage{fontspec}\n";
+ if (features.mustProvide("unicode-math")
+ && features.isAvailable("unicode-math"))
+ os << "\\usepackage{unicode-math}\n";
+ }
// font selection must be done before loading fontenc.sty
- string const fonts =
- loadFonts(fonts_roman, fonts_sans, fonts_typewriter,
- fonts_expert_sc, fonts_old_figures,
- fonts_sans_scale, fonts_typewriter_scale,
- useNonTeXFonts, features);
+ string const fonts = loadFonts(features);
if (!fonts.empty())
os << from_utf8(fonts);
// LFE encoding
// XeTeX and LuaTeX (with OS fonts) work without fontenc
if (font_encoding() != "default" && language->lang() != "japanese"
- && !useNonTeXFonts && !tclass.provides("fontenc")) {
+ && !useNonTeXFonts && !features.isProvided("fontenc")) {
size_t fars = language_options.str().find("farsi");
size_t arab = language_options.str().find("arabic");
if (language->lang() == "arabic_arabi"
os << from_utf8(par)
<< "}\n";
}
- if (!tclass.provides("geometry")
+ if (!features.isProvided("geometry")
&& (use_geometry || nonstandard_papersize)) {
odocstringstream ods;
if (!getGraphicsDriver("geometry").empty())
}
// Line spacing
- lyxpreamble += from_utf8(spacing().writePreamble(tclass.provides("SetSpace")));
+ lyxpreamble += from_utf8(spacing().writePreamble(features.isProvided("SetSpace")));
// PDF support.
// * Hyperref manual: "Make sure it comes last of your loaded
OutputParams tmp_params = features.runparams();
pdfoptions().writeLaTeX(tmp_params, os,
- documentClass().provides("hyperref"));
+ features.isProvided("hyperref"));
// set back for the rest
lyxpreamble.clear();
// correctly break URLs with hyperref and dvi output
namespace {
-bool formatSorter(Format const * lhs, Format const * rhs) {
+
+bool formatSorter(Format const * lhs, Format const * rhs)
+{
return _(lhs->prettyname()) < _(rhs->prettyname());
}
+
}
}
-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,
- bool const & use_systemfonts,
- LaTeXFeatures & features) const
-{
- /* The LaTeX font world is in a flux. In the PSNFSS font interface,
- several packages have been replaced by others, that might not
- be installed on every system. We have to take care for that
- (see psnfss.pdf). We try to support all psnfss fonts as well
- as the fonts that have become de facto standard in the LaTeX
- world (e.g. Latin Modern). We do not support obsolete fonts
- (like PSLatex). In general, it should be possible to mix any
- rm font with any sf or tt font, respectively. (JSpitzm)
- TODO:
- -- separate math fonts.
- */
-
- if (rm == "default" && sf == "default" && tt == "default")
+string const BufferParams::loadFonts(LaTeXFeatures & features) const
+{
+ if (fonts_roman == "default" && fonts_sans == "default"
+ && fonts_typewriter == "default"
+ && (fonts_math == "default" || fonts_math == "auto"))
//nothing to do
return string();
* -- if there's a way to find out if a font really supports
* OldStyle, enable/disable the widget accordingly.
*/
- if (use_systemfonts && features.isAvailable("fontspec")) {
+ if (useNonTeXFonts && features.isAvailable("fontspec")) {
// "Mapping=tex-text" and "Ligatures=TeX" are equivalent.
// However, until v.2 (2010/07/11) fontspec only knew
// Mapping=tex-text (for XeTeX only); then "Ligatures=TeX"
string const texmapping =
(features.runparams().flavor == OutputParams::XETEX) ?
"Mapping=tex-text" : "Ligatures=TeX";
- if (rm != "default") {
+ if (fonts_roman != "default") {
os << "\\setmainfont[" << texmapping;
- if (osf)
+ if (fonts_old_figures)
os << ",Numbers=OldStyle";
- os << "]{" << parseFontName(rm) << "}\n";
+ os << "]{" << parseFontName(fonts_roman) << "}\n";
}
- if (sf != "default") {
- string const sans = parseFontName(sf);
- if (sfscale != 100)
+ if (fonts_sans != "default") {
+ string const sans = parseFontName(fonts_sans);
+ if (fonts_sans_scale != 100)
os << "\\setsansfont[Scale="
- << float(sfscale) / 100
+ << float(fonts_sans_scale) / 100
<< "," << texmapping << "]{"
<< sans << "}\n";
else
os << "\\setsansfont[" << texmapping << "]{"
<< sans << "}\n";
}
- if (tt != "default") {
- string const mono = parseFontName(tt);
- if (ttscale != 100)
+ if (fonts_typewriter != "default") {
+ string const mono = parseFontName(fonts_typewriter);
+ if (fonts_typewriter_scale != 100)
os << "\\setmonofont[Scale="
- << float(ttscale) / 100
+ << float(fonts_typewriter_scale) / 100
<< "]{"
<< mono << "}\n";
else
// Tex Fonts
bool const ot1 = (font_encoding() == "default" || font_encoding() == "OT1");
bool const dryrun = features.runparams().dryrun;
+ bool const complete = (fonts_sans == "default" && fonts_typewriter == "default");
+ bool const nomath = (fonts_math == "default");
// ROMAN FONTS
- LaTeXFont roman = theLaTeXFonts().getLaTeXFont(from_ascii(rm));
- if (roman.switchdefault()) {
- if (roman.available(ot1) || dryrun)
- os << "\\renewcommand{\\rmdefault}{" << to_ascii(roman.name()) << "}\n";
- else
- frontend::Alert::warning(_("Font not available"),
- bformat(_("The LaTeX package `%1$s' needed for the font `%2$s'\n"
- "is not available on your system. LyX will fall back to the default font."),
- roman.requires(), roman.guiname()), true);
- } else {
- bool const complete = (sf == "default" && tt == "default");
- string const package =
- roman.getAvailablePackage(dryrun, ot1, complete);
- string const packageopts = roman.getPackageOptions(ot1, sc, osf);
- if (packageopts.empty() && !package.empty())
- os << "\\usepackage{" << package << "}\n";
- else if (!packageopts.empty() && !package.empty())
- os << "\\usepackage[" << packageopts << "]{" << package << "}\n";
- }
- if (osf && roman.providesOSF(ot1) && !roman.osfpackage().empty())
- os << "\\usepackage{" << to_ascii(roman.osfpackage()) << "}\n";
+ os << theLaTeXFonts().getLaTeXFont(from_ascii(fonts_roman)).getLaTeXCode(
+ dryrun, ot1, complete, fonts_expert_sc, fonts_old_figures,
+ nomath);
// SANS SERIF
- LaTeXFont sans = theLaTeXFonts().getLaTeXFont(from_ascii(sf));
- if (sans.switchdefault()) {
- if (sans.available(ot1) || dryrun)
- os << "\\renewcommand{\\sfdefault}{" << to_ascii(sans.name()) << "}\n";
- else
- frontend::Alert::warning(_("Font not available"),
- bformat(_("The LaTeX package `%1$s' needed for the font `%2$s'\n"
- "is not available on your system. LyX will fall back to the default font."),
- sans.requires(), sans.guiname()), true);
- } else {
- string const package = sans.getAvailablePackage(dryrun, ot1);
- string const packageopts = sans.getPackageOptions(ot1, sc, osf, sfscale);
- if (packageopts.empty() && !package.empty())
- os << "\\usepackage{" << package << "}\n";
- else if (!packageopts.empty() && !package.empty())
- os << "\\usepackage[" << packageopts << "]{" << package << "}\n";
- }
+ os << theLaTeXFonts().getLaTeXFont(from_ascii(fonts_sans)).getLaTeXCode(
+ dryrun, ot1, complete, fonts_expert_sc, fonts_old_figures,
+ nomath, fonts_sans_scale);
// MONOSPACED/TYPEWRITER
- LaTeXFont mono = theLaTeXFonts().getLaTeXFont(from_ascii(tt));
- if (mono.switchdefault()) {
- if (mono.available(ot1) || dryrun)
- os << "\\renewcommand{\\ttdefault}{" << to_ascii(mono.name()) << "}\n";
- else
- frontend::Alert::warning(_("Font not available"),
- bformat(_("The LaTeX package `%1$s' needed for the font `%2$s'\n"
- "is not available on your system. LyX will fall back to the default font."),
- mono.requires(), mono.guiname()), true);
- } else {
- string const package = mono.getAvailablePackage(dryrun, ot1);
- string const packageopts = mono.getPackageOptions(ot1, sc, osf, ttscale);
- if (packageopts.empty() && !package.empty())
- os << "\\usepackage{" << package << "}\n";
- else if (!packageopts.empty() && !package.empty())
- os << "\\usepackage[" << packageopts << "]{" << package << "}\n";
- }
+ os << theLaTeXFonts().getLaTeXFont(from_ascii(fonts_typewriter)).getLaTeXCode(
+ dryrun, ot1, complete, fonts_expert_sc, fonts_old_figures,
+ nomath, fonts_typewriter_scale);
+
+ // MATH
+ os << theLaTeXFonts().getLaTeXFont(from_ascii(fonts_math)).getLaTeXCode(
+ dryrun, ot1, complete, fonts_expert_sc, fonts_old_figures,
+ nomath);
return os.str();
}
projects / lyx.git / blobdiff