#include "output_latex.h"
+#include "BiblioInfo.h"
#include "Buffer.h"
#include "BufferParams.h"
#include "Encoding.h"
if (data.par_language->encoding()->package() == Encoding::CJK &&
state->open_encoding_ != CJK && pit->isMultiLingual(bparams)) {
if (prev_par_language->encoding()->package() == Encoding::CJK) {
- docstring const cjkenc = (bparams.encoding().iconvName() == "UTF-8"
+ docstring const cjkenc = (bparams.encoding().name() == "utf8-cjk"
&& LaTeXFeatures::isAvailable("CJKutf8")) ?
from_ascii("UTF8")
: from_ascii(data.par_language->encoding()->latexName());
? 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);
&& (priorpar->getDepth() > par.getDepth()
|| (priorpar->getDepth() == par.getDepth()
&& priorpar->layout() != par.layout()));
+
+ // 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 =
- (priorpar && !priorpar->isPassThru())
- ? (use_prev_env_language ? state->prev_env_language_
- : priorpar->getParLanguage(bparams))
- : outer_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 ?
}
// With CJK, the CJK tag has to be closed first (see below)
if (runparams.encoding->package() != Encoding::CJK
- && (par_lang != openLanguageName(state) || localswitch)
+ && (par_lang != openLanguageName(state) || localswitch || intitle_command)
&& !par_lang.empty()) {
string bc = use_polyglossia ?
getPolyglossiaBegin(lang_begin_command, par_lang,
// context (nesting issue).
if (par_language->encoding()->package() == Encoding::CJK
&& state->open_encoding_ != CJK && state->cjk_inherited_ == 0) {
- docstring const cjkenc = (bparams.encoding().iconvName() == "UTF-8"
+ docstring const cjkenc = (bparams.encoding().name() == "utf8-cjk"
&& LaTeXFeatures::isAvailable("CJKutf8")) ?
from_ascii("UTF8")
: from_ascii(par_language->encoding()->latexName());
if (localswitch_needed
|| (intitle_command && using_begin_end)
|| closing_rtl_ltr_environment
- || ((runparams.isLastPar || close_lang_switch)
+ || (((runparams.isLastPar && !runparams.inbranch) || close_lang_switch)
&& (par_lang != outer_lang || (using_begin_end
&& style.isEnvironment()
&& par_lang != nextpar_lang)))) {
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;
}
// (but not in child documents)
OutputState * state = getOutputState();
if (maintext && !is_child && !bparams.useNonTeXFonts
- && bparams.language->encoding()->package() == Encoding::CJK) {
- docstring const cjkenc = (bparams.encoding().iconvName() == "UTF-8"
+ && 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());
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;
}
//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
bool const from_to_cjk =
((oldEnc.package() == Encoding::CJK && newEnc.package() != Encoding::CJK)
|| (oldEnc.package() != Encoding::CJK && newEnc.package() == Encoding::CJK))
- && (bparams.inputenc != "utf8" && LaTeXFeatures::isAvailable("CJKutf8"));
+ && (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;
}
- docstring const cjkenc = (bparams.encoding().iconvName() == "UTF-8"
+ docstring const cjkenc = (bparams.encoding().name() == "utf8-cjk"
&& LaTeXFeatures::isAvailable("CJKutf8")) ?
from_ascii("UTF8")
: from_ascii(bparams.encoding().latexName());