X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_latex.cpp;h=7a8bf24c665c4370edcf9e0c8ea05aa74d37389e;hb=ed44aed58cd48eb744cb50a546859297f9e67e58;hp=784a9e58bb1adf24cac8d52118dc633ea4a332aa;hpb=6def81f30ff4f73a9c222651f602221c67535503;p=lyx.git diff --git a/src/output_latex.cpp b/src/output_latex.cpp index 784a9e58bb..7a8bf24c66 100644 --- a/src/output_latex.cpp +++ b/src/output_latex.cpp @@ -12,6 +12,7 @@ #include "output_latex.h" +#include "BiblioInfo.h" #include "Buffer.h" #include "BufferParams.h" #include "Encoding.h" @@ -63,7 +64,7 @@ enum OpenEncoding { struct OutputState { OutputState() : open_encoding_(none), cjk_inherited_(0), - prev_env_language_(0), nest_level_(0) + prev_env_language_(nullptr), nest_level_(0) { } OpenEncoding open_encoding_; @@ -191,7 +192,7 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf, pit == paragraphs.begin() ? pit : prev(pit, 1); OutputState * state = getOutputState(); - bool const use_prev_env_language = state->prev_env_language_ != 0 + bool const use_prev_env_language = state->prev_env_language_ != nullptr && priorpit->layout().isEnvironment() && (priorpit->getDepth() > pit->getDepth() || (priorpit->getDepth() == pit->getDepth() @@ -304,8 +305,11 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf, // in multilingual environments, the CJK tags have to be nested properly data.cjk_nested = false; - if (data.par_language->encoding()->package() == Encoding::CJK && - state->open_encoding_ != CJK && pit->isMultiLingual(bparams)) { + if (!bparams.useNonTeXFonts + && (bparams.inputenc == "auto-legacy" + || bparams.inputenc == "auto-legacy-plain") + && 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()) @@ -739,7 +743,7 @@ void TeXOnePar(Buffer const & buf, OutputParams runparams = runparams_in; runparams.isLastPar = (pit == pit_type(paragraphs.size() - 1)); - // We reinitialze par begin and end to be on the safe side + // We reinitialize par begin and end to be on the safe side // with embedded inset as we don't know if they set those // value correctly. runparams.par_begin = 0; @@ -759,7 +763,7 @@ void TeXOnePar(Buffer const & buf, Font const outerfont = text.outerFont(pit); // No newline before first paragraph in this lyxtext - if (pit > 0) { + if (pit > 0 && !text.inset().getLayout().parbreakIgnored()) { os << '\n'; if (!text.inset().getLayout().parbreakIsNewline()) os << '\n'; @@ -770,7 +774,7 @@ void TeXOnePar(Buffer const & buf, } Paragraph const * nextpar = runparams.isLastPar - ? 0 : ¶graphs.at(pit + 1); + ? nullptr : ¶graphs.at(pit + 1); bool const intitle_command = style.intitle && style.latextype == LATEX_COMMAND; @@ -810,16 +814,16 @@ void TeXOnePar(Buffer const & buf, // This paragraph's language Language const * const par_language = par.getParLanguage(bparams); Language const * const nextpar_language = nextpar ? - nextpar->getParLanguage(bparams) : 0; + nextpar->getParLanguage(bparams) : nullptr; // The document's language Language const * const doc_language = bparams.language; // The language that was in effect when the environment this paragraph is // inside of was opened Language const * const outer_language = - (runparams.local_font != 0) ? + (runparams.local_font != nullptr) ? runparams.local_font->language() : doc_language; - Paragraph const * priorpar = (pit == 0) ? 0 : ¶graphs.at(pit - 1); + Paragraph const * priorpar = (pit == 0) ? nullptr : ¶graphs.at(pit - 1); // The previous language that was in effect is the language of the // previous paragraph, unless the previous paragraph is inside an @@ -829,7 +833,7 @@ void TeXOnePar(Buffer const & buf, // 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 + bool const use_prev_env_language = state->prev_env_language_ != nullptr && priorpar && priorpar->layout().isEnvironment() && (priorpar->getDepth() > par.getDepth() @@ -880,7 +884,7 @@ void TeXOnePar(Buffer const & buf, // languages (see # 10111). bool const in_polyglossia_rtl_env = use_polyglossia - && runparams.local_font != 0 + && runparams.local_font != nullptr && outer_language->rightToLeft() && !par_language->rightToLeft(); bool const localswitch = runparams_in.for_search @@ -936,7 +940,7 @@ void TeXOnePar(Buffer const & buf, && par_language->lang() != "arabic_arabtex" && outer_language->lang() != "arabic_arabtex" // are we in an inset? - && runparams.local_font != 0 + && runparams.local_font != nullptr // is the inset within an \L or \R? // // FIXME: currently, we don't check this; this means that @@ -963,7 +967,9 @@ void TeXOnePar(Buffer const & buf, os << "\\L{"; } // With CJK, the CJK tag has to be closed first (see below) - if ((runparams.encoding->package() != Encoding::CJK || runparams.for_search) + if ((runparams.encoding->package() != Encoding::CJK + || bparams.useNonTeXFonts + || runparams.for_search) && (par_lang != openLanguageName(state) || localswitch) && !par_lang.empty()) { string bc = use_polyglossia ? @@ -979,11 +985,12 @@ void TeXOnePar(Buffer const & buf, } } - // Switch file encoding if necessary; no need to do this for "default" + // Switch file encoding if necessary; no need to do this for "auto-legacy-plain" // encoding, since this only affects the position of the outputted // \inputencoding command; the encoding switch will occur when necessary - if (bparams.inputenc == "auto" + if (bparams.inputenc == "auto-legacy" && !runparams.isFullUnicode() // Xe/LuaTeX use one document-wide encoding (see also switchEncoding()) + && runparams.encoding->package() != Encoding::japanese && runparams.encoding->package() != Encoding::none) { // Look ahead for future encoding changes. // We try to output them at the beginning of the paragraph, @@ -1029,12 +1036,7 @@ void TeXOnePar(Buffer const & buf, if (runparams.encoding->package() == Encoding::CJK && par_lang != openLanguageName(state) && !par_lang.empty()) { - string bc = use_polyglossia ? - getPolyglossiaBegin(lang_begin_command, par_lang, - par_language->polyglossiaOpts(), - localswitch) - : subst(lang_begin_command, "$$lang", par_lang); - os << bc + os << subst(lang_begin_command, "$$lang", par_lang) << lang_command_termination; if (using_begin_end) pushLanguageName(par_lang, localswitch); @@ -1133,10 +1135,10 @@ void TeXOnePar(Buffer const & buf, && nextpar->getDepth() < par.getDepth())) close_lang_switch = using_begin_end; if (nextpar && par.params().depth() < nextpar->params().depth()) - pending_newline = true; + pending_newline = !text.inset().getLayout().parbreakIgnored(); break; case LATEX_ENVIRONMENT: { - // if its the last paragraph of the current environment + // if it's the last paragraph of the current environment // skip it otherwise fall through if (nextpar && ((nextpar->layout() != par.layout() @@ -1152,7 +1154,7 @@ void TeXOnePar(Buffer const & buf, default: // we don't need it for the last paragraph and in InTitle commands!!! if (nextpar && !intitle_command) - pending_newline = true; + pending_newline = !text.inset().getLayout().parbreakIgnored(); } // InTitle commands use switches (not environments) for space settings @@ -1181,7 +1183,7 @@ void TeXOnePar(Buffer const & buf, && (par_language->lang() != "arabic_arabtex" && outer_language->lang() != "arabic_arabtex") // have we opened an \L or \R environment? - && runparams.local_font != 0 + && runparams.local_font != nullptr && runparams.local_font->isRightToLeft() != par_language->rightToLeft() // are we about to close the language? &&((nextpar && par_lang != nextpar_lang) @@ -1190,7 +1192,7 @@ void TeXOnePar(Buffer const & buf, 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)))) { @@ -1202,7 +1204,9 @@ void TeXOnePar(Buffer const & buf, os << '\n'; // when the paragraph uses CJK, the language has to be closed earlier - if ((font.language()->encoding()->package() != Encoding::CJK) || runparams_in.for_search) { + if ((font.language()->encoding()->package() != Encoding::CJK) + || bparams.useNonTeXFonts + || runparams_in.for_search) { if (lang_end_command.empty()) { // If this is a child, we should restore the // master language after the last paragraph. @@ -1221,7 +1225,8 @@ void TeXOnePar(Buffer const & buf, localswitch) : subst(lang_begin_command, "$$lang", current_lang); os << bc; - pending_newline = !localswitch; + pending_newline = !localswitch + && !text.inset().getLayout().parbreakIgnored(); unskip_newline = !localswitch; if (using_begin_end) pushLanguageName(current_lang, localswitch); @@ -1251,7 +1256,8 @@ void TeXOnePar(Buffer const & buf, lang_end_command, "$$lang", par_lang)); - pending_newline = !localswitch; + pending_newline = !localswitch + && !text.inset().getLayout().parbreakIgnored(); unskip_newline = !localswitch; if (using_begin_end) popLanguageName(); @@ -1294,11 +1300,11 @@ void TeXOnePar(Buffer const & buf, // if this is a CJK-paragraph and the next isn't, close CJK // also if the next paragraph is a multilingual environment (because of nesting) - if (nextpar - && (state->open_encoding_ == CJK && bparams.encoding().iconvName() != "UTF-8" - && bparams.encoding().package() != Encoding::CJK ) + if (nextpar && state->open_encoding_ == CJK + && bparams.encoding().iconvName() != "UTF-8" + && bparams.encoding().package() != Encoding::CJK && (nextpar_language->encoding()->package() != Encoding::CJK - || (nextpar->layout().isEnvironment() && nextpar->isMultiLingual(bparams))) + || (nextpar->layout().isEnvironment() && nextpar->isMultiLingual(bparams))) // inbetween environments, CJK has to be closed later (nesting!) && (!style.isEnvironment() || !nextpar->layout().isEnvironment())) { os << "\\end{CJK}\n"; @@ -1325,6 +1331,12 @@ void TeXOnePar(Buffer const & buf, break; } case inputenc: { + // FIXME: If we are in an inset and the switch happened outside this inset, + // do not switch back at the end of the inset (bug #8479) + // The following attempt does not help with listings-caption in a CJK document: + // if (runparams_in.local_font != 0 + // && runparams_in.encoding == runparams_in.local_font->language()->encoding()) + // break; os << "\\egroup"; state->open_encoding_ = none; break; @@ -1337,15 +1349,13 @@ void TeXOnePar(Buffer const & buf, } // Information about local language is stored as a font feature. - // If this is the last paragraph, and a local_font was set upon entering - // the inset and we're using "auto" or "default" encoding (and not - // compiling with LuaTeX), ensure the encoding is set back to the default - // encoding of the local language. - if (runparams.isLastPar && runparams_in.local_font != 0 + // If this is the last paragraph of the inset and a local_font was set upon entering + // and we are mixing encodings ("auto-legacy" or "auto-legacy-plain" and no XeTeX or LuaTeX), + // ensure the encoding is set back to the default encoding of the local language. + if (runparams.isLastPar && runparams_in.local_font != nullptr && runparams_in.encoding != runparams_in.local_font->language()->encoding() - && (bparams.inputenc == "auto" || bparams.inputenc == "default") - && runparams.flavor != OutputParams::LUATEX - && runparams.flavor != OutputParams::DVILUATEX + && (bparams.inputenc == "auto-legacy" || bparams.inputenc == "auto-legacy-plain") + && !runparams.isFullUnicode() ) { runparams_in.encoding = runparams_in.local_font->language()->encoding(); os << setEncoding(runparams_in.encoding->iconvName()); @@ -1362,9 +1372,10 @@ void TeXOnePar(Buffer const & buf, // Note from JMarc: we will re-add a \n explicitly in // TeXEnvironment, because it is needed in this case if (nextpar && !os.afterParbreak() && !last_was_separator) { - // Make sure to start a new line - os << breakln; Layout const & next_layout = nextpar->layout(); + if (!text.inset().getLayout().parbreakIgnored()) + // Make sure to start a new line + os << breakln; // A newline '\n' is always output before a command, // so avoid doubling it. if (!next_layout.isCommand()) { @@ -1388,22 +1399,23 @@ void TeXOnePar(Buffer const & buf, if ((style == next_layout && !style.parbreak_is_newline && !text.inset().getLayout().parbreakIsNewline() + && !text.inset().getLayout().parbreakIgnored() && 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() == next_layout.align) + && 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'; } @@ -1437,7 +1449,8 @@ void latexParagraphs(Buffer const & buf, 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; } @@ -1547,7 +1560,8 @@ void latexParagraphs(Buffer const & buf, && 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; } @@ -1566,6 +1580,7 @@ void latexParagraphs(Buffer const & buf, finishEnvironment(os, runparams, data); } + // FIXME: uncomment the content or remove this block if (pit == runparams.par_end) { // Make sure that the last paragraph is // correctly terminated (because TeXOnePar does @@ -1606,14 +1621,23 @@ void latexParagraphs(Buffer const & buf, state->open_encoding_ = none; } // Likewise for polyglossia or when using begin/end commands + // or after an active branch inset with a language switch + Language const * const outer_language = (runparams.local_font != nullptr) + ? runparams.local_font->language() : bparams.language; + string const & prev_lang = runparams.use_polyglossia + ? getPolyglossiaEnvName(outer_language) + : outer_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 != cur_lang) { + os << subst(lang_begin_command, "$$lang", prev_lang) << '\n'; } // reset inherited encoding @@ -1629,45 +1653,44 @@ void latexParagraphs(Buffer const & buf, } } - +// Switch the input encoding for some part(s) of the document. pair switchEncoding(odocstream & os, BufferParams const & bparams, OutputParams const & runparams, Encoding const & newEnc, bool force, bool noswitchmacro) { - // Never switch encoding with non-TeX fonts (always "utf8plain") or - // with LuaTeX and TeX fonts (only one encoding accepted by luainputenc). - if (bparams.useNonTeXFonts - || runparams.flavor == OutputParams::LUATEX - || runparams.flavor == OutputParams::DVILUATEX - || newEnc.name() == "inherit") - return make_pair(false, 0); - - Encoding const & oldEnc = *runparams.encoding; - bool moving_arg = runparams.moving_arg; - if (!force - && ((bparams.inputenc != "auto" && bparams.inputenc != "default") || moving_arg)) + // Never switch encoding with XeTeX/LuaTeX + // or if we're in a moving argument or inherit the outer encoding. + if (runparams.isFullUnicode() || newEnc.name() == "inherit") + return make_pair(false, 0); + + // Only switch for auto-selected legacy encodings (inputenc setting + // "auto-legacy" or "auto-legacy-plain"). + // The "listings" environment can force a switch also with other + // encoding settings (it does not support variable width encodings + // (utf8, jis, ...) under 8-bit latex engines). + if (!force && ((bparams.inputenc != "auto-legacy" && bparams.inputenc != "auto-legacy-plain") + || runparams.moving_arg)) return make_pair(false, 0); - // Do nothing if the encoding is unchanged. - if (oldEnc.name() == newEnc.name()) + Encoding const & oldEnc = *runparams.encoding; + // Do not switch, if the encoding is unchanged or switching is not supported. + if (oldEnc.name() == newEnc.name() + || oldEnc.package() == Encoding::japanese + || oldEnc.package() == Encoding::none + || newEnc.package() == Encoding::none + || runparams.for_search) return make_pair(false, 0); - // FIXME We ignore encoding switches from/to encodings that do // neither support the inputenc package nor the CJK package here. - // This does of course only work in special cases (e.g. switch from - // tis620-0 to latin1, but the text in latin1 contains ASCII only), - // but it is the best we can do - // - // 2019-01-08 Possibly no longer required since tis620-0 is supported - // by inputenc (but check special encodings "utf8-plain" and "default"). - if (oldEnc.package() == Encoding::none || newEnc.package() == Encoding::none) - return make_pair(false, 0); + // This may fail for characters not supported by "unicodesymbols" + // or for non-ASCII characters in "listings" + // but it is the best we can do. // change encoding LYXERR(Debug::LATEX, "Changing LaTeX encoding from " << oldEnc.name() << " to " << newEnc.name()); os << setEncoding(newEnc.iconvName()); - if (bparams.inputenc == "default") + if (bparams.inputenc == "auto-legacy-plain") return make_pair(true, 0); docstring const inputenc_arg(from_ascii(newEnc.latexName())); @@ -1675,7 +1698,7 @@ pair switchEncoding(odocstream & os, BufferParams const & bparams, switch (newEnc.package()) { case Encoding::none: case Encoding::japanese: - // shouldn't ever reach here, see above + // shouldn't ever reach here (see above) but avoids warning. return make_pair(true, 0); case Encoding::inputenc: { int count = inputenc_arg.length(); @@ -1691,7 +1714,7 @@ pair switchEncoding(odocstream & os, BufferParams const & bparams, state->open_encoding_ = none; count += 7; } - if (runparams.local_font != 0 + if (runparams.local_font != nullptr && oldEnc.package() == Encoding::CJK) { // within insets, \inputenc switches need // to be embraced within \bgroup...\egroup; @@ -1700,8 +1723,7 @@ pair switchEncoding(odocstream & os, BufferParams const & bparams, count += 7; state->open_encoding_ = inputenc; } - // with the japanese option, inputenc is omitted. - if (runparams.use_japanese || noswitchmacro) + if (noswitchmacro) return make_pair(true, count); os << "\\inputencoding{" << inputenc_arg << '}'; return make_pair(true, count + 16);