#include "output_latex.h"
+#include "BiblioInfo.h"
#include "Buffer.h"
#include "BufferParams.h"
#include "Encoding.h"
#include "Font.h"
#include "InsetList.h"
#include "Language.h"
+#include "LaTeXFeatures.h"
#include "Layout.h"
#include "LyXRC.h"
#include "OutputParams.h"
string const getPolyglossiaBegin(string const & lang_begin_command,
- string const & lang, string const & opts)
+ string const & lang, string const & opts,
+ bool const localswitch = false)
{
string result;
- if (!lang.empty())
- result = subst(lang_begin_command, "$$lang", lang);
+ if (!lang.empty()) {
+ // we need to revert the upcasing done in getPolyglossiaEnvName()
+ // in case we have a local polyglossia command (\textarabic).
+ string language = localswitch ? ascii_lowercase(lang) : lang;
+ result = subst(lang_begin_command, "$$lang", language);
+ }
string options = opts.empty() ?
string() : "[" + opts + "]";
result = subst(result, "$$opts", options);
data.cjk_nested = false;
if (data.par_language->encoding()->package() == Encoding::CJK &&
state->open_encoding_ != CJK && pit->isMultiLingual(bparams)) {
- if (prev_par_language->encoding()->package() == Encoding::CJK)
- os << "\\begin{CJK}{" << from_ascii(data.par_language->encoding()->latexName())
+ if (prev_par_language->encoding()->package() == Encoding::CJK) {
+ docstring const cjkenc = (bparams.encoding().name() == "utf8-cjk"
+ && LaTeXFeatures::isAvailable("CJKutf8")) ?
+ from_ascii("UTF8")
+ : from_ascii(data.par_language->encoding()->latexName());
+ os << "\\begin{CJK}{" << cjkenc
<< "}{" << from_ascii(bparams.fonts_cjk) << "}%\n";
+ }
state->open_encoding_ = CJK;
data.cjk_nested = true;
}
}
-} // namespace anon
+} // namespace
void pushLanguageName(string const & lang_name, bool localswitch)
}
+string const & openLanguageName()
+{
+ OutputState * state = getOutputState();
+
+ return openLanguageName(state);
+}
+
+
namespace {
void addArgInsets(Paragraph const & par, string const & prefix,
}
}
-} // anon namespace
+} // namespace
void latexArgInsets(Paragraph const & par, otexstream & os,
// output the proper paragraph start according to latextype.
void parStartCommand(Paragraph const & par, otexstream & os,
- OutputParams const & runparams, Layout const & style)
+ OutputParams const & runparams, Layout const & style)
{
switch (style.latextype) {
case LATEX_COMMAND:
}
}
-} // namespace anon
+} // namespace
// FIXME: this should be anonymous
void TeXOnePar(Buffer const & buf,
otexstream & os,
OutputParams const & runparams_in,
string const & everypar,
- int start_pos, int end_pos)
+ int start_pos, int end_pos,
+ bool const force)
{
BufferParams const & bparams = runparams_in.is_child
? buf.masterParams() : buf.params();
Layout const & style = text.inset().forcePlainLayout() ?
bparams.documentClass().plainLayout() : par.layout();
- if (style.inpreamble)
+ if (style.inpreamble && !force)
return;
LYXERR(Debug::LATEX, "TeXOnePar for paragraph " << pit << " ptr " << &par << " '"
os << '\n';
}
- par.latex(bparams, outerfont, os, runparams, start_pos, end_pos);
+ par.latex(bparams, outerfont, os, runparams, start_pos, end_pos, force);
return;
}
Paragraph const * nextpar = runparams.isLastPar
? 0 : ¶graphs.at(pit + 1);
+ bool const intitle_command = style.intitle && style.latextype == LATEX_COMMAND;
+ // Intitle commands switch languages locally, thus increase
+ // language nesting level
+ if (intitle_command)
+ state->nest_level_ += 1;
+
if (style.pass_thru) {
Font const outerfont = text.outerFont(pit);
parStartCommand(par, os, runparams, style);
+ if (intitle_command)
+ os << '{';
- par.latex(bparams, outerfont, os, runparams, start_pos, end_pos);
+ par.latex(bparams, outerfont, os, runparams, start_pos, end_pos, force);
// I did not create a parEndCommand for this minuscule
// task because in the other user of parStartCommand
// environment with nesting depth greater than (or equal to, but with
// a different layout) the current one. If there is no previous
// paragraph, the previous language is the outer language.
+ // Note further that we take the outer language also if the prior par
+ // is PassThru, since in that case it has latex_language, and all secondary
+ // languages have been closed (#10793).
bool const use_prev_env_language = state->prev_env_language_ != 0
&& priorpar
&& priorpar->layout().isEnvironment()
&& (priorpar->getDepth() > par.getDepth()
|| (priorpar->getDepth() == par.getDepth()
&& priorpar->layout() != par.layout()));
- Language const * const prev_language =
- (pit != 0)
- ? (use_prev_env_language ? state->prev_env_language_
- : priorpar->getParLanguage(bparams))
- : outer_language;
+ // We need to ignore previous intitle commands since languages
+ // are switched locally there (# 11514)
+ // There might be paragraphs before the title, so we check this.
+ Paragraph * prior_nontitle_par = nullptr;
+ if (!intitle_command) {
+ pit_type ppit = pit;
+ while (ppit > 0) {
+ --ppit;
+ Paragraph const * tmppar = ¶graphs.at(ppit);
+ if (tmppar->layout().intitle && tmppar->layout().isCommand())
+ continue;
+ prior_nontitle_par = const_cast<Paragraph*>(tmppar);
+ break;
+ }
+ }
+ Language const * const prev_language =
+ runparams_in.for_search
+ ? languages.getLanguage("ignore")
+ : (prior_nontitle_par && !prior_nontitle_par->isPassThru())
+ ? (use_prev_env_language
+ ? state->prev_env_language_
+ : prior_nontitle_par->getParLanguage(bparams))
+ : outer_language;
bool const use_polyglossia = runparams.use_polyglossia;
string const par_lang = use_polyglossia ?
bool const using_begin_end = use_polyglossia ||
!lang_end_command.empty();
- // In some insets (such as Arguments), we cannot use \selectlanguage
+ // For InTitle commands, we need to switch the language inside the command
+ // (see #10849); thus open the command here.
+ if (intitle_command) {
+ parStartCommand(par, os, runparams, style);
+ os << '{';
+ }
+
+ // In some insets (such as Arguments), we cannot use \selectlanguage.
+ // Also, if an RTL language is set via environment in polyglossia,
+ // only a nested \\text<lang> command will reset the direction for LTR
+ // languages (see # 10111).
+ bool const in_polyglossia_rtl_env =
+ use_polyglossia
+ && runparams.local_font != 0
+ && outer_language->rightToLeft()
+ && !par_language->rightToLeft();
bool const localswitch = text.inset().forceLocalFontSwitch()
- || (using_begin_end && text.inset().forcePlainLayout());
+ || (using_begin_end && text.inset().forcePlainLayout())
+ || in_polyglossia_rtl_env;
if (localswitch) {
lang_begin_command = use_polyglossia ?
"\\text$$lang$$opts{" : lyxrc.language_command_local;
lang_end_command = "}";
lang_command_termination.clear();
}
-
- if (par_lang != prev_lang
- // check if we already put language command in TeXEnvironment()
- && !(style.isEnvironment()
- && (pit == 0 || (priorpar->layout() != par.layout()
- && priorpar->getDepth() <= par.getDepth())
- || priorpar->getDepth() < par.getDepth())))
- {
- if ((!using_begin_end || langOpenedAtThisLevel(state)) &&
- !lang_end_command.empty() &&
- prev_lang != outer_lang &&
- !prev_lang.empty() &&
- (!using_begin_end || !style.isEnvironment()))
- {
+
+ bool const localswitch_needed = localswitch && par_lang != outer_lang;
+
+ // localswitches need to be closed and reopened at each par
+ if ((par_lang != prev_lang || localswitch_needed)
+ // check if we already put language command in TeXEnvironment()
+ && !(style.isEnvironment()
+ && (pit == 0 || (priorpar->layout() != par.layout()
+ && priorpar->getDepth() <= par.getDepth())
+ || priorpar->getDepth() < par.getDepth()))) {
+ if (!localswitch
+ && (!using_begin_end || langOpenedAtThisLevel(state))
+ && !lang_end_command.empty()
+ && prev_lang != outer_lang
+ && !prev_lang.empty()
+ && (!using_begin_end || !style.isEnvironment())) {
os << from_ascii(subst(lang_end_command,
- "$$lang",
- prev_lang))
+ "$$lang",
+ prev_lang))
<< lang_command_termination;
if (using_begin_end)
popLanguageName();
}
// With CJK, the CJK tag has to be closed first (see below)
if (runparams.encoding->package() != Encoding::CJK
- && par_lang != openLanguageName(state)
+ && (par_lang != openLanguageName(state) || localswitch || intitle_command)
&& !par_lang.empty()) {
string bc = use_polyglossia ?
- getPolyglossiaBegin(lang_begin_command, par_lang, par_language->polyglossiaOpts())
+ getPolyglossiaBegin(lang_begin_command, par_lang,
+ par_language->polyglossiaOpts(),
+ localswitch)
: subst(lang_begin_command, "$$lang", par_lang);
os << bc;
os << lang_command_termination;
// context (nesting issue).
if (par_language->encoding()->package() == Encoding::CJK
&& state->open_encoding_ != CJK && state->cjk_inherited_ == 0) {
- os << "\\begin{CJK}{" << from_ascii(par_language->encoding()->latexName())
+ docstring const cjkenc = (bparams.encoding().name() == "utf8-cjk"
+ && LaTeXFeatures::isAvailable("CJKutf8")) ?
+ from_ascii("UTF8")
+ : from_ascii(par_language->encoding()->latexName());
+ os << "\\begin{CJK}{" << cjkenc
<< "}{" << from_ascii(bparams.fonts_cjk) << "}%\n";
state->open_encoding_ = CJK;
}
if (runparams.encoding->package() == Encoding::CJK
&& par_lang != openLanguageName(state)
&& !par_lang.empty()) {
- os << from_ascii(subst(
- lang_begin_command,
- "$$lang",
- par_lang))
- << lang_command_termination;
+ string bc = use_polyglossia ?
+ getPolyglossiaBegin(lang_begin_command, par_lang,
+ par_language->polyglossiaOpts(),
+ localswitch)
+ : subst(lang_begin_command, "$$lang", par_lang);
+ os << bc
+ << lang_command_termination;
if (using_begin_end)
pushLanguageName(par_lang, localswitch);
}
os << "\n\\appendix\n";
}
- if (!par.params().spacing().isDefault()
- && (pit == 0 || !priorpar->hasSameLayout(par)))
- {
- os << from_ascii(par.params().spacing().writeEnvirBegin(useSetSpace))
- << '\n';
- }
+ // InTitle commands must use switches (not environments)
+ // inside the commands (see #9332)
+ if (style.intitle) {
+ if (!par.params().spacing().isDefault())
+ {
+ if (runparams.moving_arg)
+ os << "\\protect";
+ os << from_ascii(par.params().spacing().writeCmd(useSetSpace));
+ }
+ } else {
+ if (!par.params().spacing().isDefault()
+ && (pit == 0 || !priorpar->hasSameLayout(par)))
+ {
+ os << from_ascii(par.params().spacing().writeEnvirBegin(useSetSpace))
+ << '\n';
+ }
- if (style.isCommand()) {
- os << '\n';
+ if (style.isCommand()) {
+ os << '\n';
+ }
}
}
- parStartCommand(par, os, runparams, style);
+ // For InTitle commands, we already started the command before
+ // the language switch
+ if (!intitle_command)
+ parStartCommand(par, os, runparams, style);
+
Font const outerfont = text.outerFont(pit);
// FIXME UNICODE
os << from_utf8(everypar);
- par.latex(bparams, outerfont, os, runparams, start_pos, end_pos);
-
- // Make sure that \\par is done with the font of the last
- // character if this has another size as the default.
- // This is necessary because LaTeX (and LyX on the screen)
- // calculates the space between the baselines according
- // to this font. (Matthias)
- //
- // We must not change the font for the last paragraph
- // of non-multipar insets, tabular cells or commands,
- // since this produces unwanted whitespace.
+ par.latex(bparams, outerfont, os, runparams, start_pos, end_pos, force);
Font const font = par.empty()
? par.getLayoutFont(bparams, outerfont)
bool const is_command = style.isCommand();
- if (style.resfont.size() != font.fontInfo().size()
- && (nextpar || maintext
- || (text.inset().paragraphs().size() > 1
- && text.inset().lyxCode() != CELL_CODE))
- && !is_command) {
- os << '{';
- os << "\\" << from_ascii(font.latexSize()) << " \\par}";
- } else if (is_command) {
- os << '}';
- if (!style.postcommandargs().empty())
- latexArgInsets(par, os, runparams, style.postcommandargs(), "post:");
- if (runparams.encoding != prev_encoding) {
- runparams.encoding = prev_encoding;
- os << setEncoding(prev_encoding->iconvName());
+ // InTitle commands need to be closed after the language has been closed.
+ if (!intitle_command) {
+ if (is_command) {
+ os << '}';
+ if (!style.postcommandargs().empty())
+ latexArgInsets(par, os, runparams, style.postcommandargs(), "post:");
+ if (runparams.encoding != prev_encoding) {
+ runparams.encoding = prev_encoding;
+ os << setEncoding(prev_encoding->iconvName());
+ }
}
}
break;
}
}
-
- // fall through possible
+ // possible
+ // fall through
default:
- // we don't need it for the last paragraph!!!
- if (nextpar)
+ // we don't need it for the last paragraph and in InTitle commands!!!
+ if (nextpar && !intitle_command)
pending_newline = true;
}
- if (par.allowParagraphCustomization()) {
+ // InTitle commands use switches (not environments) for space settings
+ if (par.allowParagraphCustomization() && !style.intitle) {
if (!par.params().spacing().isDefault()
&& (runparams.isLastPar || !nextpar->hasSameLayout(par))) {
if (pending_newline)
}
}
- // Closing the language is needed for the last paragraph; it is also
- // needed if we're within an \L or \R that we may have opened above (not
- // necessarily in this paragraph) and are about to close.
+ // Closing the language is needed for the last paragraph in a given language
+ // as well as for any InTitleCommand (since these set the language locally);
+ // it is also needed if we're within an \L or \R that we may have opened above
+ // (not necessarily in this paragraph) and are about to close.
bool closing_rtl_ltr_environment = !using_begin_end
// not for ArabTeX
&& (par_language->lang() != "arabic_arabtex"
&&((nextpar && par_lang != nextpar_lang)
|| (runparams.isLastPar && par_lang != outer_lang));
- if (closing_rtl_ltr_environment
- || ((runparams.isLastPar || close_lang_switch)
+ if (localswitch_needed
+ || (intitle_command && using_begin_end)
+ || closing_rtl_ltr_environment
+ || (((runparams.isLastPar && !runparams.inbranch) || close_lang_switch)
&& (par_lang != outer_lang || (using_begin_end
&& style.isEnvironment()
&& par_lang != nextpar_lang)))) {
// we need to reset the language at the end of footnote or
// float.
- if (pending_newline || close_lang_switch)
+ if (!localswitch && (pending_newline || close_lang_switch))
os << '\n';
// when the paragraph uses CJK, the language has to be closed earlier
&& current_lang != openLanguageName(state)) {
string bc = use_polyglossia ?
getPolyglossiaBegin(lang_begin_command, current_lang,
- current_language->polyglossiaOpts())
+ current_language->polyglossiaOpts(),
+ localswitch)
: subst(lang_begin_command, "$$lang", current_lang);
os << bc;
pending_newline = !localswitch;
&& style != nextpar->layout())))
|| (atSameLastLangSwitchDepth(state)
&& state->lang_switch_depth_.size()
- && cur_lang != par_lang))
+ && cur_lang != par_lang)
+ || in_polyglossia_rtl_env)
{
if (using_begin_end && !localswitch)
os << breakln;
if (closing_rtl_ltr_environment)
os << "}";
+ // InTitle commands need to be closed after the language has been closed.
+ if (intitle_command) {
+ if (is_command) {
+ os << '}';
+ if (!style.postcommandargs().empty())
+ latexArgInsets(par, os, runparams, style.postcommandargs(), "post:");
+ if (runparams.encoding != prev_encoding) {
+ runparams.encoding = prev_encoding;
+ os << setEncoding(prev_encoding->iconvName());
+ }
+ }
+ }
+
bool const last_was_separator =
par.size() > 0 && par.isEnvSeparator(par.size() - 1);
else
runparams_in.encoding = runparams.encoding;
+ // These need to be passed upstream as well
+ runparams_in.need_maketitle = runparams.need_maketitle;
+ runparams_in.have_maketitle = runparams.have_maketitle;
// we don't need a newline for the last paragraph!!!
// Note from JMarc: we will re-add a \n explicitly in
&& !text.inset().getLayout().parbreakIsNewline()
&& style.latextype != LATEX_ITEM_ENVIRONMENT
&& style.latextype != LATEX_LIST_ENVIRONMENT
- && style.align == par.getAlign()
+ && style.align == par.getAlign(bparams)
&& nextpar->getDepth() == par.getDepth()
- && nextpar->getAlign() == par.getAlign())
+ && nextpar->getAlign(bparams) == par.getAlign(bparams))
|| (!next_layout.isEnvironment()
&& nextpar->getDepth() > par.getDepth()
- && nextpar->getAlign() == par.getAlign())
+ && nextpar->getAlign(bparams) == next_layout.align)
|| (!style.isEnvironment()
&& next_layout.latextype == LATEX_ENVIRONMENT
&& nextpar->getDepth() < par.getDepth())
|| (style.isCommand()
&& !next_layout.isEnvironment()
- && style.align == par.getAlign()
- && next_layout.align == nextpar->getAlign())
- || (style.align != par.getAlign()
+ && style.align == par.getAlign(bparams)
+ && next_layout.align == nextpar->getAlign(bparams))
+ || (style.align != par.getAlign(bparams)
&& tclass.isDefaultLayout(next_layout))) {
os << '\n';
}
}
}
+ // Reset language nesting level after intitle command
+ if (intitle_command)
+ state->nest_level_ -= 1;
+
LYXERR(Debug::LATEX, "TeXOnePar for paragraph " << pit << " done; ptr "
<< &par << " next " << nextpar);
if (multibib_child && mparams.useBiblatex())
os << "\\newrefsection";
- else if (multibib_child && mparams.useBibtopic()) {
+ else if (multibib_child && mparams.useBibtopic()
+ && !buf.masterBibInfo().empty()) {
os << "\\begin{btUnit}\n";
runparams.openbtUnit = true;
}
// if the document's language is a CJK language
// (but not in child documents)
OutputState * state = getOutputState();
- if (maintext && !is_child
- && bparams.encoding().package() == Encoding::CJK) {
- os << "\\begin{CJK}{" << from_ascii(bparams.encoding().latexName())
- << "}{" << from_ascii(bparams.fonts_cjk) << "}%\n";
+ if (maintext && !is_child && !bparams.useNonTeXFonts
+ && bparams.language->encoding()->package() == Encoding::CJK
+ && (bparams.encoding().name() == "utf8-cjk"
+ || bparams.encoding().iconvName() != "UTF-8")) {
+ docstring const cjkenc = (bparams.encoding().name() == "utf8-cjk"
+ && LaTeXFeatures::isAvailable("CJKutf8")) ?
+ from_ascii("UTF8")
+ : from_ascii(bparams.encoding().latexName());
+ os << "\\begin{CJK}{" << cjkenc
+ << "}{" << from_ascii(bparams.fonts_cjk) << "}%\n";
state->open_encoding_ = CJK;
}
// if "auto begin" is switched off, explicitly switch the
pit_type pit = runparams.par_begin;
// lastpit is for the language check after the loop.
pit_type lastpit = pit;
- // variables used in the loop:
- bool was_title = false;
- bool already_title = false;
DocumentClass const & tclass = bparams.documentClass();
// Did we already warn about inTitle layout mixing? (we only warn once)
tclass.plainLayout() : par->layout();
if (layout.intitle) {
- if (already_title) {
+ if (runparams.have_maketitle) {
if (!gave_layout_warning && !runparams.dryrun) {
gave_layout_warning = true;
frontend::Alert::warning(_("Error in latexParagraphs"),
"could lead to missing or incorrect output."
), layout.name()));
}
- } else if (!was_title) {
- was_title = true;
+ } else if (!runparams.need_maketitle) {
+ runparams.need_maketitle = true;
if (tclass.titletype() == TITLE_ENVIRONMENT) {
os << "\\begin{"
<< from_ascii(tclass.titlename())
<< "}\n";
}
}
- } else if (was_title && !already_title && !layout.inpreamble) {
+ } else if (runparams.need_maketitle && !runparams.have_maketitle
+ && !layout.inpreamble && !text.inset().isInTitle()) {
if (tclass.titletype() == TITLE_ENVIRONMENT) {
os << "\\end{" << from_ascii(tclass.titlename())
<< "}\n";
os << "\\" << from_ascii(tclass.titlename())
<< "\n";
}
- already_title = true;
- was_title = false;
+ runparams.have_maketitle = true;
+ runparams.need_maketitle = false;
}
if (layout.isCommand() && !layout.latexname().empty()
&& layout.latexname() == bparams.multibib) {
if (runparams.openbtUnit)
os << "\\end{btUnit}\n";
- if (!bparams.useBiblatex()) {
+ if (!bparams.useBiblatex()
+ && !buf.masterBibInfo().empty()) {
os << '\n' << "\\begin{btUnit}\n";
runparams.openbtUnit = true;
}
TeXOnePar(buf, text, pit, os, runparams, everypar);
continue;
}
-
+
TeXEnvironmentData const data =
prepareEnvironment(buf, text, par, os, runparams);
// pit can be changed in TeXEnvironment.
//os << '\n';
}
- // It might be that we only have a title in this document
- if (was_title && !already_title) {
+ // It might be that we only have a title in this document.
+ // But if we're in an inset, this is not the end of
+ // the document. (There may be some other checks of this
+ // kind that are needed.)
+ if (runparams.need_maketitle && !runparams.have_maketitle && maintext) {
if (tclass.titletype() == TITLE_ENVIRONMENT) {
os << "\\end{" << from_ascii(tclass.titlename())
<< "}\n";
// if "auto end" is switched off, explicitly close the language at the end
// but only if the last par is in a babel or polyglossia language
+ Language const * const lastpar_language =
+ paragraphs.at(lastpit).getParLanguage(bparams);
if (maintext && !lyxrc.language_auto_end && !mainlang.empty() &&
- paragraphs.at(lastpit).getParLanguage(bparams)->encoding()->package() != Encoding::CJK) {
+ lastpar_language->encoding()->package() != Encoding::CJK) {
os << from_utf8(subst(lang_end_command,
"$$lang",
mainlang))
<< '\n';
- if (using_begin_end)
+ // If we have language_auto_begin, the stack will
+ // already be empty, nothing to pop()
+ if (using_begin_end && !lyxrc.language_auto_begin)
popLanguageName();
}
state->open_encoding_ = none;
}
// Likewise for polyglossia or when using begin/end commands
+ // or at the very end of an active branch inset with a language switch
+ Language const * const outer_language = (runparams.local_font != 0)
+ ? runparams.local_font->language() : bparams.language;
+ string const & prev_lang = runparams.use_polyglossia
+ ? getPolyglossiaEnvName(outer_language)
+ : outer_language->babel();
+ string const lastpar_lang = runparams.use_polyglossia ?
+ getPolyglossiaEnvName(lastpar_language): lastpar_language->babel();
string const & cur_lang = openLanguageName(state);
- if (maintext && !is_child && !cur_lang.empty()) {
+ if (((runparams.inbranch && langOpenedAtThisLevel(state) && prev_lang != cur_lang)
+ || (maintext && !is_child)) && !cur_lang.empty()) {
os << from_utf8(subst(lang_end_command,
"$$lang",
cur_lang))
<< '\n';
if (using_begin_end)
popLanguageName();
+ } else if (runparams.inbranch && !using_begin_end
+ && prev_lang != lastpar_lang && !lastpar_lang.empty()) {
+ // with !using_begin_end, cur_lang is empty, so we need to
+ // compare against the paragraph language (and we are in the
+ // last paragraph at this point)
+ os << subst(lang_begin_command, "$$lang", prev_lang) << '\n';
}
// reset inherited encoding
// * with useNonTeXFonts: "utf8plain",
// * with XeTeX and TeX fonts: "ascii" (inputenc fails),
// * with LuaTeX and TeX fonts: only one encoding accepted by luainputenc.
- if (runparams.isFullUnicode())
+ if (runparams.isFullUnicode() || newEnc.name() == "inherit")
return make_pair(false, 0);
Encoding const & oldEnc = *runparams.encoding;
bool moving_arg = runparams.moving_arg;
- // If we switch from/to CJK, we need to switch anyway, despite custom inputenc
- bool const from_to_cjk =
- (oldEnc.package() == Encoding::CJK && newEnc.package() != Encoding::CJK)
- || (oldEnc.package() != Encoding::CJK && newEnc.package() == Encoding::CJK);
+ // If we switch from/to CJK, we need to switch anyway, despite custom inputenc,
+ // except if we use CJKutf8
+ bool const from_to_cjk =
+ ((oldEnc.package() == Encoding::CJK && newEnc.package() != Encoding::CJK)
+ || (oldEnc.package() != Encoding::CJK && newEnc.package() == Encoding::CJK))
+ && (bparams.encoding().name() != "utf8-cjk" || !LaTeXFeatures::isAvailable("CJKutf8"));
if (!force && !from_to_cjk
&& ((bparams.inputenc != "auto" && bparams.inputenc != "default") || moving_arg))
return make_pair(false, 0);
os << "\\egroup";
count += 7;
}
- os << "\\begin{CJK}{" << inputenc_arg << "}{"
+ docstring const cjkenc = (bparams.encoding().name() == "utf8-cjk"
+ && LaTeXFeatures::isAvailable("CJKutf8")) ?
+ from_ascii("UTF8")
+ : from_ascii(bparams.encoding().latexName());
+ os << "\\begin{CJK}{" << cjkenc << "}{"
<< from_ascii(bparams.fonts_cjk) << "}";
state->open_encoding_ = CJK;
return make_pair(true, count + 15);
projects / lyx.git / blobdiff