X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_latex.cpp;h=4589b3795b1368a10c90d8f92e4b8abf0e90fcae;hb=33b7088719c3c72e81483e3a82a321971403f505;hp=b26fb1b6305364146ab81c60318ca921d9b514a7;hpb=c7efb677f8550a44b1262944c15515097723fa31;p=lyx.git diff --git a/src/output_latex.cpp b/src/output_latex.cpp index b26fb1b630..4589b3795b 100644 --- a/src/output_latex.cpp +++ b/src/output_latex.cpp @@ -19,8 +19,6 @@ #include "Font.h" #include "InsetList.h" #include "Language.h" -#include "LaTeXFeatures.h" -#include "Layout.h" #include "LyXRC.h" #include "OutputParams.h" #include "Paragraph.h" @@ -37,7 +35,6 @@ #include "support/convert.h" #include "support/debug.h" #include "support/lstrings.h" -#include "support/lyxalgo.h" #include "support/textutils.h" #include "support/gettext.h" @@ -63,16 +60,16 @@ enum OpenEncoding { struct OutputState { - OutputState() : open_encoding_(none), cjk_inherited_(0), - prev_env_language_(0), nest_level_(0) + OutputState() : prev_env_language_(nullptr), open_encoding_(none), + cjk_inherited_(0), nest_level_(0) { } - OpenEncoding open_encoding_; - int cjk_inherited_; Language const * prev_env_language_; - int nest_level_; stack lang_switch_depth_; // Both are always empty when stack open_polyglossia_lang_; // not using polyglossia + OpenEncoding open_encoding_; + int cjk_inherited_; + int nest_level_; }; @@ -109,7 +106,7 @@ bool atSameLastLangSwitchDepth(OutputState const * state) // commands. Instead, return always true when using babel with // only a begin command. - return state->lang_switch_depth_.size() == 0 + return state->lang_switch_depth_.empty() ? true : abs(state->lang_switch_depth_.top()) == state->nest_level_; } @@ -119,7 +116,7 @@ bool isLocalSwitch(OutputState const * state) { // Return true if the language was opened by a local command switch. - return state->lang_switch_depth_.size() + return !state->lang_switch_depth_.empty() && state->lang_switch_depth_.top() < 0; } @@ -128,7 +125,7 @@ bool langOpenedAtThisLevel(OutputState const * state) { // Return true if the language was opened at the current nesting level. - return state->lang_switch_depth_.size() + return !state->lang_switch_depth_.empty() && abs(state->lang_switch_depth_.top()) == state->nest_level_; } @@ -164,10 +161,10 @@ string const getPolyglossiaBegin(string const & lang_begin_command, struct TeXEnvironmentData { - bool cjk_nested; Layout const * style; Language const * par_language; Encoding const * prev_encoding; + bool cjk_nested; bool leftindent_open; }; @@ -192,7 +189,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() @@ -241,7 +238,7 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf, // polyglossia or begin/end commands, then the current // language is the document language. string const & cur_lang = using_begin_end - && state->lang_switch_depth_.size() + && !state->lang_switch_depth_.empty() ? openLanguageName(state) : doc_lang; @@ -352,6 +349,11 @@ static void finishEnvironment(otexstream & os, OutputParams const & runparams, popLanguageName(); } } + if (data.style->latextype == LATEX_BIB_ENVIRONMENT) + // bibliography needs a blank line after + // each item for backref to function properly + // (see #12041) + os << '\n'; state->nest_level_ -= 1; string const & name = data.style->latexname(); if (!name.empty()) @@ -383,7 +385,7 @@ void TeXEnvironment(Buffer const & buf, Text const & text, pit_type & pit, otexstream & os) { ParagraphList const & paragraphs = text.paragraphs(); - ParagraphList::const_iterator ipar = paragraphs.constIterator(pit); + ParagraphList::const_iterator ipar = paragraphs.iterator_at(pit); LYXERR(Debug::LATEX, "TeXEnvironment for paragraph " << pit); Layout const & current_layout = ipar->layout(); @@ -393,7 +395,7 @@ void TeXEnvironment(Buffer const & buf, Text const & text, // This is for debugging purpose at the end. pit_type const par_begin = pit; for (; pit < runparams.par_end; ++pit) { - ParagraphList::const_iterator par = paragraphs.constIterator(pit); + ParagraphList::const_iterator par = paragraphs.iterator_at(pit); // check first if this is an higher depth paragraph. bool go_out = (par->params().depth() < current_depth); @@ -434,6 +436,27 @@ void TeXEnvironment(Buffer const & buf, Text const & text, continue; } + // Do not output empty environments if the whole paragraph has + // been deleted with ct and changes are not output. + bool output_changes; + if (runparams.for_searchAdv == OutputParams::NoSearch) + output_changes = buf.params().output_changes; + else + output_changes = (runparams.for_searchAdv == OutputParams::SearchWithDeleted); + if (size_t(pit + 1) < paragraphs.size()) { + ParagraphList::const_iterator nextpar = paragraphs.iterator_at(pit + 1); + Paragraph const & cpar = paragraphs.at(pit); + if ((par->layout() != nextpar->layout() + || par->params().depth() == nextpar->params().depth() + || par->params().leftIndent() == nextpar->params().leftIndent()) + && !cpar.empty() + && cpar.isDeleted(0, cpar.size()) && !output_changes) { + if (!output_changes && !cpar.parEndChange().deleted()) + os << '\n' << '\n'; + continue; + } + } + // This is a new environment. TeXEnvironmentData const data = prepareEnvironment(buf, text, par, os, runparams); @@ -448,9 +471,9 @@ void TeXEnvironment(Buffer const & buf, Text const & text, void getArgInsets(otexstream & os, OutputParams const & runparams, Layout::LaTeXArgMap const & latexargs, - map ilist, vector required, string const & prefix) + map ilist, vector required, string const & prefix) { - unsigned int const argnr = latexargs.size(); + size_t const argnr = latexargs.size(); if (argnr == 0) return; @@ -458,22 +481,22 @@ void getArgInsets(otexstream & os, OutputParams const & runparams, Layout::LaTeX // other arguments, consider this. for (auto const & larg : latexargs) { Layout::latexarg const & arg = larg.second; - if ((!arg.presetarg.empty() || !arg.defaultarg.empty()) && !arg.requires.empty()) { - vector req = getVectorFromString(arg.requires); + if ((!arg.presetarg.empty() || !arg.defaultarg.empty()) && !arg.required.empty()) { + vector req = getVectorFromString(arg.required); required.insert(required.end(), req.begin(), req.end()); } } - for (unsigned int i = 1; i <= argnr; ++i) { - map::const_iterator lit = ilist.find(i); + for (size_t i = 1; i <= argnr; ++i) { + map::const_iterator lit = ilist.find(i); bool inserted = false; if (lit != ilist.end()) { - InsetArgument const * ins = (*lit).second; + InsetArgument const * ins = lit->second; if (ins) { Layout::LaTeXArgMap::const_iterator const lait = latexargs.find(ins->name()); if (lait != latexargs.end()) { - Layout::latexarg arg = (*lait).second; + Layout::latexarg arg = lait->second; docstring ldelim; docstring rdelim; if (!arg.nodelims) { @@ -531,7 +554,7 @@ void getArgInsets(otexstream & os, OutputParams const & runparams, Layout::LaTeX } } } - if (runparams.for_search) { + if ((runparams.for_searchAdv != OutputParams::NoSearch) && argnr > 1) { // Mark end of arguments for findadv() only os << "\\endarguments{}"; } @@ -572,7 +595,7 @@ namespace { void addArgInsets(Paragraph const & par, string const & prefix, Layout::LaTeXArgMap const & latexargs, - map & ilist, + map & ilist, vector & required) { for (auto const & table : par.insetList()) { @@ -585,15 +608,13 @@ void addArgInsets(Paragraph const & par, string const & prefix, } string const name = prefix.empty() ? arg->name() : split(arg->name(), ':'); - // why converting into an integer? - unsigned int const nr = convert(name); - if (ilist.find(nr) == ilist.end()) - ilist[nr] = arg; + size_t const nr = convert(name); + ilist.insert({nr, arg}); Layout::LaTeXArgMap::const_iterator const lit = latexargs.find(arg->name()); if (lit != latexargs.end()) { Layout::latexarg const & larg = lit->second; - vector req = getVectorFromString(larg.requires); + vector req = getVectorFromString(larg.required); move(req.begin(), req.end(), back_inserter(required)); } } @@ -607,7 +628,7 @@ void latexArgInsets(Paragraph const & par, otexstream & os, Layout::LaTeXArgMap const & latexargs, string const & prefix) { - map ilist; + map ilist; vector required; addArgInsets(par, prefix, latexargs, ilist, required); getArgInsets(os, runparams, latexargs, ilist, required, prefix); @@ -620,18 +641,18 @@ void latexArgInsets(ParagraphList const & pars, Layout::LaTeXArgMap const & latexargs, string const & prefix) { - map ilist; + map ilist; vector required; depth_type const current_depth = pit->params().depth(); Layout const current_layout = pit->layout(); // get the first paragraph in sequence with this layout and depth - pit_type offset = 0; + ptrdiff_t offset = 0; while (true) { - if (lyx::prev(pit, offset) == pars.begin()) + if (prev(pit, offset) == pars.begin()) break; - ParagraphList::const_iterator priorpit = lyx::prev(pit, offset + 1); + ParagraphList::const_iterator priorpit = prev(pit, offset + 1); if (priorpit->layout() == current_layout && priorpit->params().depth() == current_depth) ++offset; @@ -639,8 +660,7 @@ void latexArgInsets(ParagraphList const & pars, break; } - ParagraphList::const_iterator spit = lyx::prev(pit, offset); - + ParagraphList::const_iterator spit = prev(pit, offset); for (; spit != pars.end(); ++spit) { if (spit->layout() != current_layout || spit->params().depth() < current_depth) @@ -658,7 +678,7 @@ void latexArgInsetsForParent(ParagraphList const & pars, otexstream & os, Layout::LaTeXArgMap const & latexargs, string const & prefix) { - map ilist; + map ilist; vector required; for (Paragraph const & par : pars) { @@ -679,8 +699,12 @@ void parStartCommand(Paragraph const & par, otexstream & os, { switch (style.latextype) { case LATEX_COMMAND: - if (par.needsCProtection(runparams.moving_arg)) + if (par.needsCProtection(runparams.moving_arg)) { + if (contains(runparams.active_chars, '^')) + // cprotect relies on ^ being on catcode 7 + os << "\\begingroup\\catcode`\\^=7"; os << "\\cprotect"; + } os << '\\' << from_ascii(style.latexname()); // Command arguments @@ -690,7 +714,7 @@ void parStartCommand(Paragraph const & par, otexstream & os, break; case LATEX_ITEM_ENVIRONMENT: case LATEX_LIST_ENVIRONMENT: - if (runparams.for_search) { + if (runparams.for_searchAdv != OutputParams::NoSearch) { os << "\\" + style.itemcommand() << "{" << style.latexname() << "}"; } else { @@ -702,7 +726,7 @@ void parStartCommand(Paragraph const & par, otexstream & os, } break; case LATEX_ENVIRONMENT: - if (runparams.for_search) { + if (runparams.for_searchAdv != OutputParams::NoSearch) { os << "\\latexenvironment{" << style.latexname() << "}{"; } break; @@ -738,6 +762,12 @@ void TeXOnePar(Buffer const & buf, if (style.inpreamble && !force) return; + // Do not output empty commands if the whole paragraph has + // been deleted with ct and changes are not output. + if ((runparams_in.for_searchAdv != OutputParams::SearchWithDeleted) && style.latextype != LATEX_ENVIRONMENT + && !par.empty() && par.isDeleted(0, par.size()) && !bparams.output_changes) + return; + LYXERR(Debug::LATEX, "TeXOnePar for paragraph " << pit << " ptr " << &par << " '" << everypar << "'"); @@ -759,11 +789,14 @@ void TeXOnePar(Buffer const & buf, state->open_encoding_ = none; } + // This paragraph is merged and we do not show changes in the output + bool const merged_par = !bparams.output_changes && par.parEndChange().deleted(); + if (text.inset().isPassThru()) { Font const outerfont = text.outerFont(pit); // No newline before first paragraph in this lyxtext - if (pit > 0 && !text.inset().getLayout().parbreakIgnored()) { + if (pit > 0 && !text.inset().getLayout().parbreakIgnored() && !merged_par) { os << '\n'; if (!text.inset().getLayout().parbreakIsNewline()) os << '\n'; @@ -774,9 +807,13 @@ 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; + bool const intitle_command = style.intitle && style.isCommand(); + // 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); @@ -785,7 +822,8 @@ void TeXOnePar(Buffer const & buf, // Due to the moving argument, some fragile // commands (labels, index entries) // are output after this command (#2154) - runparams.postpone_fragile_stuff = true; + runparams.postpone_fragile_stuff = + bparams.postpone_fragile_content; if (intitle_command) os << '{'; @@ -794,17 +832,25 @@ void TeXOnePar(Buffer const & buf, // I did not create a parEndCommand for this minuscule // task because in the other user of parStartCommand // the code is different (JMarc) - if (style.isCommand()) - os << "}\n"; - else + if (style.isCommand()) { + os << "}"; + if (par.needsCProtection(runparams.moving_arg) + && contains(runparams.active_chars, '^')) + os << "\\endgroup"; + if (merged_par) + os << "{}"; + else + os << "\n"; + } + else if (!merged_par) os << '\n'; - if (!style.parbreak_is_newline) { + if (!style.parbreak_is_newline && !merged_par) { os << '\n'; } else if (nextpar && !style.isEnvironment()) { Layout const nextstyle = text.inset().forcePlainLayout() ? bparams.documentClass().plainLayout() : nextpar->layout(); - if (nextstyle.name() != style.name()) + if (nextstyle.name() != style.name() && !merged_par) os << '\n'; } @@ -814,16 +860,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 @@ -833,19 +879,36 @@ 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() || (priorpar->getDepth() == par.getDepth() - && priorpar->layout() != par.layout())); + && 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(tmppar); + break; + } + } Language const * const prev_language = - runparams_in.for_search ? - languages.getLanguage("ignore") - :(priorpar && !priorpar->isPassThru()) - ? (use_prev_env_language ? state->prev_env_language_ - : priorpar->getParLanguage(bparams)) - : outer_language; + runparams_in.for_searchAdv != OutputParams::NoSearch + ? 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 ? @@ -874,7 +937,8 @@ void TeXOnePar(Buffer const & buf, // Due to the moving argument, some fragile // commands (labels, index entries) // are output after this command (#2154) - runparams.postpone_fragile_stuff = true; + runparams.postpone_fragile_stuff = + bparams.postpone_fragile_content; os << '{'; } @@ -884,13 +948,15 @@ 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 + bool const localswitch = + (runparams_in.for_searchAdv != OutputParams::NoSearch || text.inset().forceLocalFontSwitch() || (using_begin_end && text.inset().forcePlainLayout()) - || in_polyglossia_rtl_env; + || in_polyglossia_rtl_env) + && !text.inset().forceParDirectionSwitch(); if (localswitch) { lang_begin_command = use_polyglossia ? "\\text$$lang$$opts{" : lyxrc.language_command_local; @@ -901,7 +967,7 @@ void TeXOnePar(Buffer const & buf, bool const localswitch_needed = localswitch && par_lang != outer_lang; // localswitches need to be closed and reopened at each par - if (runparams_in.for_search || ((par_lang != prev_lang || localswitch_needed) + if ((runparams_in.for_searchAdv != OutputParams::NoSearch) || ((par_lang != prev_lang || localswitch_needed) // check if we already put language command in TeXEnvironment() && !(style.isEnvironment() && (pit == 0 || (priorpar->layout() != par.layout() @@ -940,7 +1006,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 @@ -969,8 +1035,8 @@ void TeXOnePar(Buffer const & buf, // With CJK, the CJK tag has to be closed first (see below) if ((runparams.encoding->package() != Encoding::CJK || bparams.useNonTeXFonts - || runparams.for_search) - && (par_lang != openLanguageName(state) || localswitch) + || (runparams.for_searchAdv != OutputParams::NoSearch)) + && (par_lang != openLanguageName(state) || localswitch || intitle_command) && !par_lang.empty()) { string bc = use_polyglossia ? getPolyglossiaBegin(lang_begin_command, par_lang, @@ -1089,7 +1155,8 @@ void TeXOnePar(Buffer const & buf, // Due to the moving argument, some fragile // commands (labels, index entries) // are output after this command (#2154) - runparams.postpone_fragile_stuff = true; + runparams.postpone_fragile_stuff = + bparams.postpone_fragile_content; } Font const outerfont = text.outerFont(pit); @@ -1116,6 +1183,9 @@ void TeXOnePar(Buffer const & buf, os << runparams.post_macro; runparams.post_macro.clear(); } + if (par.needsCProtection(runparams.moving_arg) + && contains(runparams.active_chars, '^')) + os << "\\endgroup"; if (runparams.encoding != prev_encoding) { runparams.encoding = prev_encoding; os << setEncoding(prev_encoding->iconvName()); @@ -1135,7 +1205,7 @@ 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 = !text.inset().getLayout().parbreakIgnored(); + pending_newline = !text.inset().getLayout().parbreakIgnored() && !merged_par; break; case LATEX_ENVIRONMENT: { // if it's the last paragraph of the current environment @@ -1154,7 +1224,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 = !text.inset().getLayout().parbreakIgnored(); + pending_newline = !text.inset().getLayout().parbreakIgnored() && !merged_par; } // InTitle commands use switches (not environments) for space settings @@ -1183,7 +1253,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) @@ -1206,7 +1276,7 @@ void TeXOnePar(Buffer const & buf, // when the paragraph uses CJK, the language has to be closed earlier if ((font.language()->encoding()->package() != Encoding::CJK) || bparams.useNonTeXFonts - || runparams_in.for_search) { + || (runparams_in.for_searchAdv != OutputParams::NoSearch)) { if (lang_end_command.empty()) { // If this is a child, we should restore the // master language after the last paragraph. @@ -1246,7 +1316,7 @@ void TeXOnePar(Buffer const & buf, && nextpar && style != nextpar->layout()))) || (atSameLastLangSwitchDepth(state) - && state->lang_switch_depth_.size() + && !state->lang_switch_depth_.empty() && cur_lang != par_lang) || in_polyglossia_rtl_env) { @@ -1270,25 +1340,34 @@ void TeXOnePar(Buffer const & buf, // 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.post_macro.empty()) { - // Output the stored fragile commands (labels, indices etc.) - // that need to be output after the command with moving argument. - os << runparams.post_macro; - runparams.post_macro.clear(); - } - if (runparams.encoding != prev_encoding) { - runparams.encoding = prev_encoding; - os << setEncoding(prev_encoding->iconvName()); - } + os << '}'; + if (!style.postcommandargs().empty()) + latexArgInsets(par, os, runparams, style.postcommandargs(), "post:"); + if (!runparams.post_macro.empty()) { + // Output the stored fragile commands (labels, indices etc.) + // that need to be output after the command with moving argument. + os << runparams.post_macro; + runparams.post_macro.clear(); + } + if (par.needsCProtection(runparams.moving_arg) + && contains(runparams.active_chars, '^')) + os << "\\endgroup"; + 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); + !par.empty() && par.isEnvSeparator(par.size() - 1); + + // Signify added/deleted par break in output if show changes in output + if (nextpar && !os.afterParbreak() && !last_was_separator + && bparams.output_changes && par.parEndChange().changed()) { + Changes::latexMarkChange(os, bparams, Change(Change::UNCHANGED), + par.parEndChange(), runparams); + os << bparams.encoding().latexString(docstring(1, 0x00b6)).first << "}"; + } if (pending_newline) { if (unskip_newline) @@ -1303,7 +1382,8 @@ void TeXOnePar(Buffer const & buf, if (nextpar && state->open_encoding_ == CJK && bparams.encoding().iconvName() != "UTF-8" && bparams.encoding().package() != Encoding::CJK - && (nextpar_language->encoding()->package() != Encoding::CJK + && ((nextpar_language && + nextpar_language->encoding()->package() != Encoding::CJK) || (nextpar->layout().isEnvironment() && nextpar->isMultiLingual(bparams))) // inbetween environments, CJK has to be closed later (nesting!) && (!style.isEnvironment() || !nextpar->layout().isEnvironment())) { @@ -1352,7 +1432,7 @@ void TeXOnePar(Buffer const & buf, // 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 != 0 + if (runparams.isLastPar && runparams_in.local_font != nullptr && runparams_in.encoding != runparams_in.local_font->language()->encoding() && (bparams.inputenc == "auto-legacy" || bparams.inputenc == "auto-legacy-plain") && !runparams.isFullUnicode() @@ -1366,18 +1446,21 @@ void TeXOnePar(Buffer const & buf, // Also pass the post_macros upstream runparams_in.post_macro = runparams.post_macro; + // 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 // TeXEnvironment, because it is needed in this case if (nextpar && !os.afterParbreak() && !last_was_separator) { - Layout const & next_layout = nextpar->layout(); - if (!text.inset().getLayout().parbreakIgnored()) + if (!text.inset().getLayout().parbreakIgnored() && !merged_par) // Make sure to start a new line os << breakln; // A newline '\n' is always output before a command, // so avoid doubling it. + Layout const & next_layout = nextpar->layout(); if (!next_layout.isCommand()) { // Here we now try to avoid spurious empty lines by // outputting a paragraph break only if: (case 1) the @@ -1402,26 +1485,40 @@ void TeXOnePar(Buffer const & buf, && !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'; + // and omit paragraph break if it has been deleted with ct + // and changes are not shown in output + if (!merged_par) { + if (runparams.isNonLong) + // This is to allow parbreak in multirow + // It could also be used for other non-long + // contexts + os << "\\endgraf\n"; + else + 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); @@ -1466,7 +1563,8 @@ void latexParagraphs(Buffer const & buf, && runparams.use_CJK)) ) { docstring const cjkenc = bparams.encoding().iconvName() == "UTF-8" - ? from_ascii("UTF8") : from_ascii(bparams.encoding().latexName()); + ? from_ascii("UTF8") + : from_ascii(bparams.encoding().latexName()); os << "\\begin{CJK}{" << cjkenc << "}{" << from_ascii(bparams.fonts_cjk) << "}%\n"; state->open_encoding_ = CJK; @@ -1502,22 +1600,19 @@ void latexParagraphs(Buffer const & buf, // The full doc will be exported but it is easier to just rely on // runparams range parameters that will be passed TeXEnvironment. runparams.par_begin = 0; - runparams.par_end = paragraphs.size(); + runparams.par_end = static_cast(paragraphs.size()); } 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) bool gave_layout_warning = false; for (; pit < runparams.par_end; ++pit) { lastpit = pit; - ParagraphList::const_iterator par = paragraphs.constIterator(pit); + ParagraphList::const_iterator par = paragraphs.iterator_at(pit); // FIXME This check should not be needed. We should // perhaps issue an error if it is. @@ -1525,7 +1620,7 @@ void latexParagraphs(Buffer const & buf, 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"), @@ -1535,15 +1630,16 @@ void latexParagraphs(Buffer const & buf, "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"; @@ -1552,8 +1648,8 @@ void latexParagraphs(Buffer const & buf, 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() @@ -1573,6 +1669,36 @@ void latexParagraphs(Buffer const & buf, continue; } + // Do not output empty environments if the whole paragraph has + // been deleted with ct and changes are not output. + bool output_changes; + if (runparams.for_searchAdv == OutputParams::NoSearch) + output_changes = bparams.output_changes; + else + output_changes = (runparams.for_searchAdv == OutputParams::SearchWithDeleted); + if (size_t(pit + 1) < paragraphs.size()) { + ParagraphList::const_iterator nextpar = paragraphs.iterator_at(pit + 1); + Paragraph const & cpar = paragraphs.at(pit); + if ((par->layout() != nextpar->layout() + || par->params().depth() == nextpar->params().depth() + || par->params().leftIndent() == nextpar->params().leftIndent()) + && !cpar.empty() + && cpar.isDeleted(0, cpar.size()) && !output_changes) { + if (!cpar.parEndChange().deleted()) + os << '\n' << '\n'; + continue; + } + } else { + // This is the last par + Paragraph const & cpar = paragraphs.at(pit); + if ( !cpar.empty() + && cpar.isDeleted(0, cpar.size()) && !output_changes) { + if (!cpar.parEndChange().deleted()) + os << '\n' << '\n'; + continue; + } + } + TeXEnvironmentData const data = prepareEnvironment(buf, text, par, os, runparams); // pit can be changed in TeXEnvironment. @@ -1588,8 +1714,11 @@ void latexParagraphs(Buffer const & buf, //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"; @@ -1604,13 +1733,17 @@ void latexParagraphs(Buffer const & buf, // 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(); } @@ -1621,12 +1754,14 @@ 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 != 0) + // or at the very end of 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 lastpar_lang = runparams.use_polyglossia ? + getPolyglossiaEnvName(lastpar_language): lastpar_language->babel(); string const & cur_lang = openLanguageName(state); if (((runparams.inbranch && langOpenedAtThisLevel(state) && prev_lang != cur_lang) || (maintext && !is_child)) && !cur_lang.empty()) { @@ -1636,7 +1771,11 @@ void latexParagraphs(Buffer const & buf, << '\n'; if (using_begin_end) popLanguageName(); - } else if (runparams.inbranch && !using_begin_end && prev_lang != cur_lang) { + } 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'; } @@ -1658,14 +1797,10 @@ 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"), - // with LuaTeX and TeX fonts (only one encoding accepted by luainputenc), + // Never switch encoding with XeTeX/LuaTeX // or if we're in a moving argument or inherit the outer encoding. - if (bparams.useNonTeXFonts - || runparams.flavor == OutputParams::LUATEX - || runparams.flavor == OutputParams::DVILUATEX - || newEnc.name() == "inherit") - return make_pair(false, 0); + 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"). @@ -1682,7 +1817,7 @@ pair switchEncoding(odocstream & os, BufferParams const & bparams, || oldEnc.package() == Encoding::japanese || oldEnc.package() == Encoding::none || newEnc.package() == Encoding::none - || runparams.for_search) + || (runparams.for_searchAdv != OutputParams::NoSearch)) 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. @@ -1705,7 +1840,7 @@ pair switchEncoding(odocstream & os, BufferParams const & bparams, // shouldn't ever reach here (see above) but avoids warning. return make_pair(true, 0); case Encoding::inputenc: { - int count = inputenc_arg.length(); + size_t count = inputenc_arg.length(); if (oldEnc.package() == Encoding::CJK && state->open_encoding_ == CJK) { os << "\\end{CJK}"; @@ -1718,7 +1853,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; @@ -1733,7 +1868,7 @@ pair switchEncoding(odocstream & os, BufferParams const & bparams, return make_pair(true, count + 16); } case Encoding::CJK: { - int count = inputenc_arg.length(); + size_t count = inputenc_arg.length(); if (oldEnc.package() == Encoding::CJK && state->open_encoding_ == CJK) { os << "\\end{CJK}";