#include "Preamble.h"
#include "tex2lyx.h"
+#include "Encoding.h"
#include "LayoutFile.h"
#include "Layout.h"
#include "Lexer.h"
#include "TextClass.h"
+#include "version.h"
#include "support/convert.h"
#include "support/FileName.h"
"greek", "hebrew", "hungarian", "icelandic", "indon", "indonesian", "interlingua",
"irish", "italian", "japanese", "kazakh", "kurmanji", "latin", "latvian", "lithuanian",
"lowersorbian", "lsorbian", "magyar", "malay", "meyalu", "mongolian", "naustrian",
-"newzealand", "ngerman", "ngermanb", "norsk", "nynorsk", "polutonikogreek", "polish",
-"portuges", "portuguese", "romanian", "russian", "russianb", "samin",
-"scottish", "serbian", "serbian-latin", "slovak", "slovene", "spanish",
-"swedish", "thai", "turkish", "turkmen", "ukraineb", "ukrainian",
-"uppersorbian", "UKenglish", "USenglish", "usorbian", "vietnam", "welsh",
+"newzealand", "ngerman", "ngermanb", "norsk", "nswissgerman", "nynorsk",
+"polutonikogreek", "polish", "portuges", "portuguese", "romanian", "russian",
+"russianb", "samin", "scottish", "serbian", "serbian-latin", "slovak",
+"slovene", "spanish", "swedish", "swissgerman", "thai", "turkish", "turkmen",
+"ukraineb", "ukrainian", "uppersorbian", "UKenglish", "USenglish", "usorbian",
+"vietnam", "welsh",
0};
/**
"greek", "hebrew", "magyar", "icelandic", "bahasa", "bahasa", "interlingua",
"irish", "italian", "japanese", "kazakh", "kurmanji", "latin", "latvian", "lithuanian",
"lowersorbian", "lowersorbian", "magyar", "bahasam", "bahasam", "mongolian", "naustrian",
-"newzealand", "ngerman", "ngerman", "norsk", "nynorsk", "polutonikogreek", "polish",
-"portuguese", "portuguese", "romanian", "russian", "russian", "samin",
-"scottish", "serbian", "serbian-latin", "slovak", "slovene", "spanish",
-"swedish", "thai", "turkish", "turkmen", "ukrainian", "ukrainian",
-"uppersorbian", "uppersorbian", "english", "english", "vietnamese", "welsh",
+"newzealand", "ngerman", "ngerman", "norsk", "german-ch", "nynorsk",
+"polutonikogreek", "polish", "portuguese", "portuguese", "romanian", "russian",
+"russian", "samin", "scottish", "serbian", "serbian-latin", "slovak",
+"slovene", "spanish", "swedish", "german-ch-old", "thai", "turkish", "turkmen",
+"ukrainian", "ukrainian", "uppersorbian", "english", "english", "uppersorbian",
+"vietnamese", "welsh",
0};
/// languages with danish quotes (.lyx names)
char const * const known_fontsizes[] = { "10pt", "11pt", "12pt", 0 };
const char * const known_roman_fonts[] = { "ae", "beraserif", "bookman",
-"ccfonts", "chancery", "charter", "cmr", "fourier", "lmodern", "mathpazo",
-"mathptmx", "newcent", "utopia", 0};
+"ccfonts", "chancery", "charter", "cmr", "fourier", "garamondx", "libertine",
+"libertine-type1", "lmodern", "mathdesign", "mathpazo", "mathptmx", "newcent",
+"tgbonum", "tgchorus", "tgpagella", "tgschola", "tgtermes", "utopia", 0};
-const char * const known_sans_fonts[] = { "avant", "berasans", "cmbr", "cmss",
-"helvet", "lmss", 0};
+const char * const known_sans_fonts[] = { "avant", "berasans", "biolinum-type1",
+"cmbr", "cmss", "helvet", "iwona", "iwonac", "iwonal", "iwonalc", "kurier",
+"kurierc", "kurierl", "kurierlc", "lmss", "tgadventor", "tgheros", 0};
const char * const known_typewriter_fonts[] = { "beramono", "cmtl", "cmtt",
-"courier", "lmtt", "luximono", "fourier", "lmodern", "mathpazo", "mathptmx",
-"newcent", 0};
+"courier", "lmtt", "luximono", "fourier", "libertineMono-type1", "lmodern",
+"mathpazo", "mathptmx", "newcent", "tgcursor", "txtt", 0};
+
+const char * const known_math_fonts[] = { "eulervm", "newtxmath", 0};
const char * const known_paper_sizes[] = { "a0paper", "b0paper", "c0paper",
"a1paper", "b1paper", "c1paper", "a2paper", "b2paper", "c2paper", "a3paper",
const char * const known_basic_colors[] = {"blue", "black", "cyan", "green",
"magenta", "red", "white", "yellow", 0};
-const char * const known_basic_color_codes[] = {"#0000ff", "#000000", "#00ffff", "#00ff00",
-"#ff00ff", "#ff0000", "#ffffff", "#ffff00", 0};
+const char * const known_basic_color_codes[] = {"#0000ff", "#000000", "#00ffff",
+"#00ff00", "#ff00ff", "#ff0000", "#ffffff", "#ffff00", 0};
/// conditional commands with three arguments like \@ifundefined{}{}{}
const char * const known_if_3arg_commands[] = {"@ifundefined", "IfFileExists",
/// packages that are automatically skipped if loaded by LyX
const char * const known_lyx_packages[] = {"amsbsy", "amsmath", "amssymb",
-"amstext", "amsthm", "array", "babel", "booktabs", "calc", "CJK", "color", "float",
-"fontspec", "graphicx", "hhline", "ifthen", "longtable", "makeidx", "multirow",
-"nomencl", "pdfpages", "rotating", "rotfloat", "splitidx", "setspace",
-"subscript", "textcomp", "ulem", "url", "varioref", "verbatim", "wrapfig",
-"xunicode", 0};
+"amstext", "amsthm", "array", "babel", "booktabs", "calc", "CJK", "color",
+"float", "fontspec", "graphicx", "hhline", "ifthen", "longtable", "makeidx",
+"multirow", "nomencl", "pdfpages", "prettyref", "refstyle", "rotating",
+"rotfloat", "splitidx", "setspace", "subscript", "textcomp", "tipa", "tipx",
+"tone", "ulem", "url", "varioref", "verbatim", "wrapfig", "xunicode", 0};
+
+// used for the handling of \newindex
+int index_number = 0;
// codes used to remove packages that are loaded automatically by LyX.
// Syntax: package_beg_sep<name>package_mid_sep<package loading code>package_end_sep
/**
* known polyglossia language names (including variants)
+ * FIXME: support spelling=old for german variants (german vs. ngerman LyX names etc)
*/
const char * const Preamble::polyglossia_languages[] = {
"albanian", "croatian", "hebrew", "norsk", "swedish", "amharic", "czech", "hindi",
"armenian", "divehi", "interlingua", "polish", "telugu", "asturian", "dutch",
"irish", "portuges", "thai", "bahasai", "english", "italian", "romanian", "turkish",
"bahasam", "esperanto", "lao", "russian", "turkmen", "basque", "estonian", "latin",
-"samin", "ukrainian", "bengali", "farsi", "latvian", "sanskrit", "urdu", "brazil",
-"brazilian", "finnish", "lithuanian", "scottish", "usorbian", "breton", "french",
-"lsorbian", "serbian", "vietnamese", "bulgarian", "galician", "magyar", "slovak",
-"welsh", "catalan", "german", "malayalam", "slovenian", "coptic", "greek",
-"marathi", "spanish",
+"samin", "ukrainian", "bengali", "farsi", "latvian", "sanskrit", "tibetan", "urdu",
+"brazil", "brazilian", "finnish", "lithuanian", "scottish", "usorbian", "breton",
+"french", "lsorbian", "serbian", "vietnamese", "bulgarian", "galician", "magyar",
+"slovak", "welsh", "catalan", "german", "malayalam", "slovenian", "coptic", "greek",
+"marathi", "spanish", "austrian",
"american", "ancient", "australian", "british", "monotonic", "newzealand",
"polytonic", 0};
"armenian", "divehi", "interlingua", "polish", "telugu", "asturian", "dutch",
"irish", "portuges", "thai", "bahasa", "english", "italian", "romanian", "turkish",
"bahasam", "esperanto", "lao", "russian", "turkmen", "basque", "estonian", "latin",
-"samin", "ukrainian", "bengali", "farsi", "latvian", "sanskrit", "urdu", "brazilian",
-"brazilian", "finnish", "lithuanian", "scottish", "uppersorbian", "breton", "french",
-"lowersorbian", "serbian", "vietnamese", "bulgarian", "galician", "magyar", "slovak",
-"welsh", "catalan", "ngerman", "malayalam", "slovene", "coptic", "greek",
-"marathi", "spanish",
+"samin", "ukrainian", "bengali", "farsi", "latvian", "sanskrit", "tibetan", "urdu",
+"brazilian", "brazilian", "finnish", "lithuanian", "scottish", "uppersorbian", "breton",
+"french", "lowersorbian", "serbian", "vietnamese", "bulgarian", "galician", "magyar",
+"slovak", "welsh", "catalan", "ngerman", "malayalam", "slovene", "coptic", "greek",
+"marathi", "spanish", "naustrian",
"american", "ancientgreek", "australian", "british", "greek", "newzealand",
"polutonikogreek", 0};
namespace {
-// Given is a string like "scaled=0.9", return 0.9 * 100
-string const scale_as_percentage(string const & scale)
+// Given is a string like "scaled=0.9" or "Scale=0.9", return 0.9 * 100
+bool scale_as_percentage(string const & scale, string & percentage)
{
string::size_type pos = scale.find('=');
if (pos != string::npos) {
string value = scale.substr(pos + 1);
- if (isStrDbl(value))
- return convert<string>(100 * convert<double>(value));
+ if (isStrDbl(value)) {
+ percentage = convert<string>(
+ static_cast<int>(100 * convert<double>(value)));
+ return true;
+ }
}
- // If the input string didn't match our expectations.
- // return the default value "100"
- return "100";
+ return false;
}
} // anonymous namespace
-Preamble::Preamble() : one_language(true), title_layout_found(false)
+Preamble::Preamble() : one_language(true), explicit_babel(false),
+ title_layout_found(false), h_font_cjk_set(false)
{
//h_backgroundcolor;
//h_boxbgcolor;
h_biblio_style = "plain";
h_bibtex_command = "default";
h_cite_engine = "basic";
- h_cite_engine_type = "numerical";
+ h_cite_engine_type = "default";
h_color = "#008000";
h_defskip = "medskip";
//h_float_placement;
h_font_osf = "false";
h_font_sf_scale = "100";
h_font_tt_scale = "100";
+ //h_font_cjk
h_graphics = "default";
h_default_output_format = "default";
h_html_be_strict = "false";
h_html_css_as_file = "0";
h_html_math_output = "0";
- h_index = "Index";
+ h_index[0] = "Index";
h_index_command = "default";
h_inputencoding = "auto";
h_justification = "true";
//h_pdf_author;
//h_pdf_subject;
//h_pdf_keywords;
- h_pdf_bookmarks = "1";
+ h_pdf_bookmarks = "0";
h_pdf_bookmarksnumbered = "0";
h_pdf_bookmarksopen = "0";
h_pdf_bookmarksopenlevel = "1";
h_pdf_pdfborder = "0";
h_pdf_colorlinks = "0";
h_pdf_backref = "section";
- h_pdf_pdfusetitle = "1";
+ h_pdf_pdfusetitle = "0";
//h_pdf_pagemode;
//h_pdf_quoted_options;
h_quotes_language = "english";
h_secnumdepth = "3";
- h_shortcut = "idx";
+ h_shortcut[0] = "idx";
h_spacing = "single";
h_suppress_date = "false";
h_textclass = "article";
h_use_geometry = "false";
h_use_default_options = "false";
h_use_hyperref = "false";
- h_use_refstyle = "0";
+ h_use_refstyle = false;
h_use_packages["amsmath"] = "1";
h_use_packages["amssymb"] = "0";
+ h_use_packages["cancel"] = "0";
h_use_packages["esint"] = "1";
h_use_packages["mhchem"] = "0";
h_use_packages["mathdots"] = "0";
h_use_packages["mathtools"] = "0";
+ h_use_packages["stackrel"] = "0";
+ h_use_packages["stmaryrd"] = "0";
h_use_packages["undertilde"] = "0";
}
{
vector<string> options = split_options(opts);
add_package(name, options);
- string scale;
char const * const * where = 0;
if (is_known(name, known_xetex_packages)) {
h_use_non_tex_fonts = "true";
registerAutomaticallyLoadedPackage("fontspec");
if (h_inputencoding == "auto")
- p.setEncoding("utf8");
+ p.setEncoding("UTF-8");
}
// roman fonts
h_font_sc = "true";
}
+ if (name == "garamondx") {
+ h_font_roman = "garamondx";
+ if (opts == "osfI")
+ h_font_osf = "true";
+ }
+
+ if (name == "libertine") {
+ h_font_roman = "libertine";
+ // this automatically invokes biolinum
+ h_font_sans = "biolinum";
+ if (opts == "osf")
+ h_font_osf = "true";
+ else if (opts == "lining")
+ h_font_osf = "false";
+ }
+
+ if (name == "libertine-type1") {
+ h_font_roman = "libertine";
+ // NOTE: contrary to libertine.sty, libertine-type1
+ // does not automatically invoke biolinum
+ if (opts == "lining")
+ h_font_osf = "false";
+ else if (opts == "osf")
+ h_font_osf = "true";
+ }
+
+ if (name == "mathdesign") {
+ if (opts.find("charter") != string::npos)
+ h_font_roman = "md-charter";
+ if (opts.find("garamond") != string::npos)
+ h_font_roman = "md-garamond";
+ if (opts.find("utopia") != string::npos)
+ h_font_roman = "md-utopia";
+ if (opts.find("expert") != string::npos) {
+ h_font_sc = "true";
+ h_font_osf = "true";
+ }
+ }
+
else if (name == "mathpazo")
h_font_roman = "palatino";
// sansserif fonts
if (is_known(name, known_sans_fonts)) {
h_font_sans = name;
- if (!opts.empty()) {
- scale = opts;
- h_font_sf_scale = scale_as_percentage(scale);
+ if (options.size() >= 1) {
+ if (scale_as_percentage(opts, h_font_sf_scale))
+ options.clear();
}
}
+ if (name == "biolinum-type1") {
+ h_font_sans = "biolinum";
+ // biolinum can have several options, e.g. [osf,scaled=0.97]
+ string::size_type pos = opts.find("osf");
+ if (pos != string::npos)
+ h_font_osf = "true";
+ }
+
// typewriter fonts
if (is_known(name, known_typewriter_fonts)) {
// fourier can be set as roman font _only_
// fourier as typewriter is handled in handling of \ttdefault
if (name != "fourier") {
h_font_typewriter = name;
- if (!opts.empty()) {
- scale = opts;
- h_font_tt_scale = scale_as_percentage(scale);
+ if (options.size() >= 1) {
+ if (scale_as_percentage(opts, h_font_tt_scale))
+ options.clear();
}
}
}
+ if (name == "libertineMono-type1") {
+ h_font_typewriter = "libertine-mono";
+ }
+
// font uses old-style figure
if (name == "eco")
h_font_osf = "true";
+ // math fonts
+ if (is_known(name, known_math_fonts))
+ h_font_math = name;
+
+ if (name == "newtxmath") {
+ if (opts.empty())
+ h_font_math = "newtxmath";
+ else if (opts == "garamondx")
+ h_font_math = "garamondx-ntxm";
+ else if (opts == "libertine")
+ h_font_math = "libertine-ntxm";
+ else if (opts == "minion")
+ h_font_math = "minion-ntxm";
+ }
+
+ if (name == "iwona")
+ if (opts == "math")
+ h_font_math = "iwona-math";
+
+ if (name == "kurier")
+ if (opts == "math")
+ h_font_math = "kurier-math";
+
// after the detection and handling of special cases, we can remove the
// fonts, otherwise they would appear in the preamble, see bug #7856
if (is_known(name, known_roman_fonts) || is_known(name, known_sans_fonts)
- || is_known(name, known_typewriter_fonts))
+ || is_known(name, known_typewriter_fonts) || is_known(name, known_math_fonts))
;
- else if (name == "amsmath" || name == "amssymb" ||
+ else if (name == "amsmath" || name == "amssymb" || name == "cancel" ||
name == "esint" || name == "mhchem" || name == "mathdots" ||
- name == "mathtools" || name == "undertilde")
+ name == "mathtools" || name == "stackrel" ||
+ name == "stmaryrd" || name == "undertilde")
h_use_packages[name] = "2";
else if (name == "babel") {
handle_opt(options, known_languages, h_language);
// translate the babel name to a LyX name
h_language = babel2lyx(h_language);
- // for Japanese we assume EUC-JP as encoding
- // but we cannot determine the exact encoding and thus output also a note
if (h_language == "japanese") {
- h_inputencoding = "euc";
- p.setEncoding("EUC-JP");
+ // For Japanese, the encoding isn't indicated in the source
+ // file, and there's really not much we can do. We could
+ // 1) offer a list of possible encodings to choose from, or
+ // 2) determine the encoding of the file by inspecting it.
+ // For the time being, we leave the encoding alone so that
+ // we don't get iconv errors when making a wrong guess, and
+ // we will output a note at the top of the document
+ // explaining what to do.
+ Encoding const * const enc = encodings.fromIconvName(
+ p.getEncoding(), Encoding::japanese, false);
+ if (enc)
+ h_inputencoding = enc->name();
is_nonCJKJapanese = true;
// in this case babel can be removed from the preamble
registerAutomaticallyLoadedPackage("babel");
h_preamble << "\\usepackage[" << opts << "]{babel}\n";
}
delete_opt(options, known_languages);
- }
- else
+ } else {
h_preamble << "\\usepackage{babel}\n";
+ explicit_babel = true;
+ }
}
else if (name == "polyglossia") {
xetex = true;
registerAutomaticallyLoadedPackage("xunicode");
if (h_inputencoding == "auto")
- p.setEncoding("utf8");
+ p.setEncoding("UTF-8");
}
else if (name == "CJK") {
registerAutomaticallyLoadedPackage("CJK");
}
+ else if (name == "CJKutf8") {
+ h_inputencoding = "utf8-cjk";
+ p.setEncoding("UTF-8");
+ registerAutomaticallyLoadedPackage("CJKutf8");
+ }
+
else if (name == "fontenc") {
h_fontencoding = getStringFromVector(options, ",");
/* We could do the following for better round trip support,
// h_inputencoding is only set when there is not more than one
// inputenc option because otherwise h_inputencoding must be
// set to "auto" (the default encoding of the document language)
- // Therefore check for the "," character.
+ // Therefore check that exactly one option is passed to inputenc.
// It is also only set when there is not more than one babel
// language option.
- if (opts.find(",") == string::npos && one_language == true)
- h_inputencoding = opts;
- if (!options.empty())
- p.setEncoding(options.back());
- options.clear();
+ if (!options.empty()) {
+ string const encoding = options.back();
+ Encoding const * const enc = encodings.fromLaTeXName(
+ encoding, Encoding::inputenc, true);
+ if (!enc)
+ cerr << "Unknown encoding " << encoding << ". Ignoring." << std::endl;
+ else {
+ if (!enc->unsafe() && options.size() == 1 && one_language == true)
+ h_inputencoding = enc->name();
+ p.setEncoding(enc->iconvName());
+ }
+ options.clear();
+ }
}
else if (name == "srcltx") {
h_language_package = "\\usepackage{" + name + "}";
}
- else if (name == "prettyref")
- ; // ignore this FIXME: Use the package separator mechanism instead
-
else if (name == "lyxskak") {
// ignore this and its options
const char * const o[] = {"ps", "mover", 0};
else if (is_known(name, known_lyx_packages) && options.empty()) {
if (name == "splitidx")
h_use_indices = "true";
+ if (name == "refstyle")
+ h_use_refstyle = true;
+ else if (name == "prettyref")
+ h_use_refstyle = false;
if (!in_lyx_preamble) {
h_preamble << package_beg_sep << name
<< package_mid_sep << "\\usepackage{"
h_cite_engine_type = "authoryear";
}
+ else if (name == "bibtopic")
+ h_use_bibtopic = "true";
+
else if (name == "hyperref")
handle_hyperref(options);
+ else if (name == "algorithm2e") {
+ // Load "algorithm2e" module
+ addModule("algorithm2e");
+ // Add the package options to the global document options
+ if (!options.empty()) {
+ if (h_options.empty())
+ h_options = join(options, ",");
+ else
+ h_options += ',' + join(options, ",");
+ }
+ }
+
else if (!in_lyx_preamble) {
if (options.empty())
h_preamble << "\\usepackage{" << name << '}';
}
// output the LyX file settings
- os << "#LyX file created by tex2lyx " << PACKAGE_VERSION << "\n"
+ // Important: Keep the version formatting in sync with LyX and
+ // lyx2lyx (bug 7951)
+ os << "#LyX file created by tex2lyx " << lyx_version_major << '.'
+ << lyx_version_minor << '\n'
<< "\\lyxformat " << LYX_FORMAT << '\n'
<< "\\begin_document\n"
<< "\\begin_header\n"
<< "\\font_sc " << h_font_sc << "\n"
<< "\\font_osf " << h_font_osf << "\n"
<< "\\font_sf_scale " << h_font_sf_scale << "\n"
- << "\\font_tt_scale " << h_font_tt_scale << "\n"
- << "\\graphics " << h_graphics << "\n"
+ << "\\font_tt_scale " << h_font_tt_scale << '\n';
+ if (!h_font_cjk.empty())
+ os << "\\font_cjk " << h_font_cjk << '\n';
+ os << "\\graphics " << h_graphics << '\n'
<< "\\default_output_format " << h_default_output_format << "\n"
<< "\\output_sync " << h_output_sync << "\n";
if (h_output_sync == "1")
os << "\\backgroundcolor " << h_backgroundcolor << '\n';
if (!h_boxbgcolor.empty())
os << "\\boxbgcolor " << h_boxbgcolor << '\n';
- os << "\\index " << h_index << '\n'
- << "\\shortcut " << h_shortcut << '\n'
- << "\\color " << h_color << '\n'
- << "\\end_index\n";
+ if (index_number != 0)
+ for (int i = 0; i < index_number; i++) {
+ os << "\\index " << h_index[i] << '\n'
+ << "\\shortcut " << h_shortcut[i] << '\n'
+ << "\\color " << h_color << '\n'
+ << "\\end_index\n";
+ }
+ else {
+ os << "\\index " << h_index[0] << '\n'
+ << "\\shortcut " << h_shortcut[0] << '\n'
+ << "\\color " << h_color << '\n'
+ << "\\end_index\n";
+ }
os << h_margins
<< "\\secnumdepth " << h_secnumdepth << "\n"
<< "\\tocdepth " << h_tocdepth << "\n"
if (pos != string::npos) {
string::size_type i = fontopts.find(',', pos);
if (i == string::npos)
- scale = scale_as_percentage(fontopts.substr(pos + 1));
+ scale_as_percentage(fontopts.substr(pos + 1), scale);
else
- scale = scale_as_percentage(fontopts.substr(pos, i - pos));
+ scale_as_percentage(fontopts.substr(pos, i - pos), scale);
}
}
if (t.cs() == "setsansfont") {
else if (t.cs() == "makeatletter") {
// LyX takes care of this
- p.setCatCode('@', catLetter);
+ p.setCatcode('@', catLetter);
}
else if (t.cs() == "makeatother") {
// LyX takes care of this
- p.setCatCode('@', catOther);
+ p.setCatcode('@', catOther);
+ }
+
+ else if (t.cs() == "makeindex") {
+ // LyX will re-add this if a print index command is found
+ p.skip_spaces();
+ }
+
+ else if (t.cs() == "newindex") {
+ string const indexname = p.getArg('[', ']');
+ string const shortcut = p.verbatim_item();
+ if (!indexname.empty())
+ h_index[index_number] = indexname;
+ else
+ h_index[index_number] = shortcut;
+ h_shortcut[index_number] = shortcut;
+ index_number += 1;
+ p.skip_spaces();
+ }
+
+ else if (t.cs() == "RS@ifundefined") {
+ string const name = p.verbatim_item();
+ string const body1 = p.verbatim_item();
+ string const body2 = p.verbatim_item();
+ // only non-lyxspecific stuff
+ if (in_lyx_preamble &&
+ (name == "subref" || name == "thmref" || name == "lemref"))
+ p.skip_spaces();
+ else {
+ ostringstream ss;
+ ss << '\\' << t.cs();
+ ss << '{' << name << '}'
+ << '{' << body1 << '}'
+ << '{' << body2 << '}';
+ h_preamble << ss.str();
+ }
+ }
+
+ else if (t.cs() == "AtBeginDocument") {
+ string const name = p.verbatim_item();
+ // only non-lyxspecific stuff
+ if (in_lyx_preamble &&
+ (name == "\\providecommand\\partref[1]{\\ref{part:#1}}"
+ || name == "\\providecommand\\chapref[1]{\\ref{chap:#1}}"
+ || name == "\\providecommand\\secref[1]{\\ref{sec:#1}}"
+ || name == "\\providecommand\\subref[1]{\\ref{sub:#1}}"
+ || name == "\\providecommand\\parref[1]{\\ref{par:#1}}"
+ || name == "\\providecommand\\figref[1]{\\ref{fig:#1}}"
+ || name == "\\providecommand\\tabref[1]{\\ref{tab:#1}}"
+ || name == "\\providecommand\\algref[1]{\\ref{alg:#1}}"
+ || name == "\\providecommand\\fnref[1]{\\ref{fn:#1}}"
+ || name == "\\providecommand\\enuref[1]{\\ref{enu:#1}}"
+ || name == "\\providecommand\\eqref[1]{\\ref{eq:#1}}"
+ || name == "\\providecommand\\lemref[1]{\\ref{lem:#1}}"
+ || name == "\\providecommand\\thmref[1]{\\ref{thm:#1}}"
+ || name == "\\providecommand\\corref[1]{\\ref{cor:#1}}"
+ || name == "\\providecommand\\propref[1]{\\ref{prop:#1}}"))
+ p.skip_spaces();
+ else {
+ ostringstream ss;
+ ss << '\\' << t.cs();
+ ss << '{' << name << '}';
+ h_preamble << ss.str();
+ }
}
else if (t.cs() == "newcommand" || t.cs() == "newcommandx"
string const opt1 = p.getFullOpt();
string const opt2 = p.getFullOpt();
string const body = p.verbatim_item();
+ // store the in_lyx_preamble setting
+ bool const was_in_lyx_preamble = in_lyx_preamble;
// font settings
if (name == "\\rmdefault")
- if (is_known(body, known_roman_fonts))
+ if (is_known(body, known_roman_fonts)) {
h_font_roman = body;
+ p.skip_spaces();
+ in_lyx_preamble = true;
+ }
if (name == "\\sfdefault")
- if (is_known(body, known_sans_fonts))
+ if (is_known(body, known_sans_fonts)) {
h_font_sans = body;
+ p.skip_spaces();
+ in_lyx_preamble = true;
+ }
if (name == "\\ttdefault")
- if (is_known(body, known_typewriter_fonts))
+ if (is_known(body, known_typewriter_fonts)) {
h_font_typewriter = body;
+ p.skip_spaces();
+ in_lyx_preamble = true;
+ }
if (name == "\\familydefault") {
string family = body;
// remove leading "\"
h_font_default_family = family.erase(0,1);
+ p.skip_spaces();
+ in_lyx_preamble = true;
}
// remove the lyxdot definition that is re-added by LyX
// if necessary
- if (name == "\\lyxdot")
+ if (name == "\\lyxdot") {
+ p.skip_spaces();
in_lyx_preamble = true;
+ }
// Add the command to the known commands
add_known_command(name, opt1, !opt2.empty(), from_utf8(body));
<< opts << "{" << body << "}";
*/
}
+ // restore the in_lyx_preamble setting
+ in_lyx_preamble = was_in_lyx_preamble;
}
else if (t.cs() == "documentclass") {
// FIXME This does not work for classes that have a
// different name in LyX than in LaTeX
h_textclass = p.getArg('{', '}');
+ p.skip_spaces();
}
else if (t.cs() == "usepackage") {
else if (t.cs() == "inputencoding") {
string const encoding = p.getArg('{','}');
- h_inputencoding = encoding;
- p.setEncoding(encoding);
+ Encoding const * const enc = encodings.fromLaTeXName(
+ encoding, Encoding::inputenc, true);
+ if (!enc)
+ cerr << "Unknown encoding " << encoding << ". Ignoring." << std::endl;
+ else {
+ if (!enc->unsafe())
+ h_inputencoding = enc->name();
+ p.setEncoding(enc->iconvName());
+ }
}
else if (t.cs() == "newenvironment") {
}
+ else if (t.cs() == "newtheorem") {
+ string const name = p.getArg('{', '}');
+ string const opt1 = p.getFullOpt();
+ string const opt2 = p.getFullOpt();
+ string const body = p.verbatim_item();
+ string const opt3 = p.getFullOpt();
+
+ add_known_theorem(name, opt1, !opt2.empty(),
+ from_utf8("\\newtheorem{" + name + '}' +
+ opt1 + opt2 + '{' + body + '}' + opt3));
+
+ if (!in_lyx_preamble)
+ h_preamble << "\\newtheorem{" << name << '}'
+ << opt1 << opt2 << '{' << '}' << opt3;
+ }
+
else if (t.cs() == "def") {
string name = p.get_token().cs();
// In fact, name may be more than the name:
// Force textclass if the user wanted it
if (!forceclass.empty())
h_textclass = forceclass;
- if (noweb_mode && !prefixIs(h_textclass, "literate-"))
- h_textclass.insert(0, "literate-");
tc.setName(h_textclass);
if (!tc.load()) {
cerr << "Error: Could not read layout file for textclass \"" << h_textclass << "\"." << endl;
// the babel options. Instead, we guess which language is used most
// and set this one.
default_language = h_language;
- if (is_full_document && auto_packages.find("CJK") != auto_packages.end()) {
+ if (is_full_document &&
+ (auto_packages.find("CJK") != auto_packages.end() ||
+ auto_packages.find("CJKutf8") != auto_packages.end())) {
p.pushPosition();
h_language = guessLanguage(p, default_language);
p.popPosition();
+ if (explicit_babel && h_language != default_language) {
+ // We set the document language to a CJK language,
+ // but babel is explicitly called in the user preamble
+ // without options. LyX will not add the default
+ // language to the document options if it is either
+ // english, or no text is set as default language.
+ // Therefore we need to add a language option explicitly.
+ // FIXME: It would be better to remove all babel calls
+ // from the user preamble, but this is difficult
+ // without re-introducing bug 7861.
+ if (h_options.empty())
+ h_options = lyx2babel(default_language);
+ else
+ h_options += ',' + lyx2babel(default_language);
+ }
}
}
}
+string lyx2babel(string const & language)
+{
+ char const * const * where = is_known(language, known_coded_languages);
+ if (where)
+ return known_languages[where - known_coded_languages];
+ return language;
+}
+
+
string Preamble::polyglossia2lyx(string const & language)
{
char const * const * where = is_known(language, polyglossia_languages);
projects / lyx.git / blobdiff