bparams.documentClass().plainLayout() : pit->layout();
ParagraphList const & paragraphs = text.paragraphs();
+ bool const firstpar = pit == paragraphs.begin();
ParagraphList::const_iterator const priorpit =
- pit == paragraphs.begin() ? pit : prev(pit, 1);
+ firstpar ? pit : prev(pit, 1);
OutputState * state = getOutputState();
bool const use_prev_env_language = state->prev_env_language_ != nullptr
data.par_language = pit->getParLanguage(bparams);
Language const * const doc_language = bparams.language;
Language const * const prev_par_language =
- (pit != paragraphs.begin())
- ? (use_prev_env_language ? state->prev_env_language_
- : priorpit->getParLanguage(bparams))
- : doc_language;
+ // use font at inset or document language in first paragraph
+ firstpar ? (runparams.local_font ?
+ runparams.local_font->language()
+ : doc_language)
+ : (use_prev_env_language ?
+ state->prev_env_language_
+ : priorpit->getParLanguage(bparams));
bool const use_polyglossia = runparams.use_polyglossia;
string const par_lang = use_polyglossia ?
!lang_end_command.empty();
// For polyglossia, switch language outside of environment, if possible.
+ // However, if we are at the start of an inset, do not close languages
+ // opened outside.
if (par_lang != prev_par_lang) {
- if ((!using_begin_end || langOpenedAtThisLevel(state)) &&
- !lang_end_command.empty() &&
- prev_par_lang != doc_lang &&
- !prev_par_lang.empty()) {
+ if (!firstpar
+ && (!using_begin_end || langOpenedAtThisLevel(state))
+ && !lang_end_command.empty()
+ && prev_par_lang != doc_lang
+ && !prev_par_lang.empty()) {
os << from_ascii(subst(
lang_end_command,
"$$lang",
static void finishEnvironment(otexstream & os, OutputParams const & runparams,
- TeXEnvironmentData const & data)
+ TeXEnvironmentData const & data, bool const maintext,
+ bool const lastpar)
{
OutputState * state = getOutputState();
- // BufferParams const & bparams = buf.params(); // FIXME: for speedup shortcut below, would require passing of "buf" as argument
+ // BufferParams const & bparams = buf.params();
+ // FIXME: for speedup shortcut below, would require passing of "buf" as argument
if (state->open_encoding_ == CJK && data.cjk_nested) {
// We need to close the encoding even if it does not change
// to do correct environment nesting
runparams.encoding = data.prev_encoding;
os << setEncoding(data.prev_encoding->iconvName());
}
+ // If this is the last par of an inset, the language needs
+ // to be closed after the environment
+ if (lastpar && !maintext) {
+ if (using_begin_end && langOpenedAtThisLevel(state)) {
+ if (isLocalSwitch(state)) {
+ os << "}";
+ } else {
+ os << "\\end{"
+ << openLanguageName(state)
+ << "}%\n";
+ }
+ popLanguageName();
+ }
+ }
}
if (data.leftindent_open) {
void TeXEnvironment(Buffer const & buf, Text const & text,
- OutputParams const & runparams,
+ OutputParams const & runparams_in,
pit_type & pit, otexstream & os)
{
ParagraphList const & paragraphs = text.paragraphs();
ParagraphList::const_iterator ipar = paragraphs.iterator_at(pit);
- LYXERR(Debug::LATEX, "TeXEnvironment for paragraph " << pit);
+ LYXERR(Debug::OUTFILE, "TeXEnvironment for paragraph " << pit);
Layout const & current_layout = ipar->layout();
depth_type const current_depth = ipar->params().depth();
Length const & current_left_indent = ipar->params().leftIndent();
+ OutputParams runparams = runparams_in;
+ runparams.no_cprotect = current_layout.nocprotect;
+ runparams.no_pass_thru_chars = current_layout.no_pass_thru_chars;
+
// This is for debugging purpose at the end.
pit_type const par_begin = pit;
for (; pit < runparams.par_end; ++pit) {
// 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)
+ if (!runparams.find_effective())
output_changes = buf.params().output_changes;
else
- output_changes = (runparams.for_searchAdv == OutputParams::SearchWithDeleted);
+ output_changes = runparams.find_with_deleted();
if (size_t(pit + 1) < paragraphs.size()) {
ParagraphList::const_iterator nextpar = paragraphs.iterator_at(pit + 1);
Paragraph const & cpar = paragraphs.at(pit);
prepareEnvironment(buf, text, par, os, runparams);
// Recursive call to TeXEnvironment!
TeXEnvironment(buf, text, runparams, pit, os);
- finishEnvironment(os, runparams, data);
+ bool const lastpar = size_t(pit + 1) >= paragraphs.size();
+ finishEnvironment(os, runparams, data, text.isMainText(), lastpar);
}
if (pit != runparams.par_end)
- LYXERR(Debug::LATEX, "TeXEnvironment for paragraph " << par_begin << " done.");
+ LYXERR(Debug::OUTFILE, "TeXEnvironment for paragraph " << par_begin << " done.");
+
+ // set upstream encoding
+ runparams_in.encoding = runparams.encoding;
}
-void getArgInsets(otexstream & os, OutputParams const & runparams, Layout::LaTeXArgMap const & latexargs,
- map<size_t, lyx::InsetArgument const *> ilist, vector<string> required, string const & prefix)
+// FIXME: pass the \c required vector by reference and add the stuff
+// from \c latexargs to a different vector. This avoids a copy and
+// (more importantly?) a coverity defect.
+void getArgInsets(otexstream & os, OutputParams const & runparams,
+ Layout::LaTeXArgMap const & latexargs,
+ map<size_t, lyx::InsetArgument const *> const & ilist,
+ vector<string> required, string const & prefix)
{
size_t const argnr = latexargs.size();
if (argnr == 0)
}
}
}
- if ((runparams.for_searchAdv != OutputParams::NoSearch) && argnr > 1) {
+ if (runparams.find_effective() && argnr > 1) {
// Mark end of arguments for findadv() only
os << "\\endarguments{}";
}
}
+bool languageStackEmpty()
+{
+ OutputState * state = getOutputState();
+
+ return state->lang_switch_depth_.empty();
+}
+
+
string const & openLanguageName()
{
OutputState * state = getOutputState();
{
switch (style.latextype) {
case LATEX_COMMAND:
- if (par.needsCProtection(runparams.moving_arg)) {
+ if (!runparams.no_cprotect && par.needsCProtection(runparams.moving_arg)) {
if (contains(runparams.active_chars, '^'))
// cprotect relies on ^ being on catcode 7
os << "\\begingroup\\catcode`\\^=7";
break;
case LATEX_ITEM_ENVIRONMENT:
case LATEX_LIST_ENVIRONMENT:
- if (runparams.for_searchAdv != OutputParams::NoSearch) {
+ if (runparams.find_effective()) {
os << "\\" + style.itemcommand() << "{" << style.latexname() << "}";
}
else {
}
break;
case LATEX_ENVIRONMENT:
- if (runparams.for_searchAdv != OutputParams::NoSearch) {
+ if (runparams.find_effective()) {
os << "\\latexenvironment{" << style.latexname() << "}{";
}
break;
// 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
+ if (!runparams_in.find_with_deleted() && 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 << "'");
+ LYXERR(Debug::OUTFILE, "TeXOnePar for paragraph " << pit << " ptr " << &par << " '"
+ << everypar << "'");
OutputParams runparams = runparams_in;
runparams.isLastPar = (pit == pit_type(paragraphs.size() - 1));
// the code is different (JMarc)
if (style.isCommand()) {
os << "}";
- if (par.needsCProtection(runparams.moving_arg)
+ if (!runparams.no_cprotect && par.needsCProtection(runparams.moving_arg)
&& contains(runparams.active_chars, '^'))
os << "\\endgroup";
if (merged_par)
break;
}
}
+ bool const have_prior_nptpar =
+ prior_nontitle_par && !prior_nontitle_par->isPassThru();
Language const * const prev_language =
- runparams_in.for_searchAdv != OutputParams::NoSearch
+ runparams_in.find_effective()
? languages.getLanguage("ignore")
- : (prior_nontitle_par && !prior_nontitle_par->isPassThru())
+ : (have_prior_nptpar)
? (use_prev_env_language
? state->prev_env_language_
: prior_nontitle_par->getParLanguage(bparams))
use_polyglossia
&& runparams.local_font != nullptr
&& outer_language->rightToLeft()
- && !par_language->rightToLeft();
+ && !par_language->rightToLeft()
+ && !(have_prior_nptpar
+ && (prev_language->rightToLeft() != par_language->rightToLeft()));
bool const localswitch =
- (runparams_in.for_searchAdv != OutputParams::NoSearch
+ (runparams_in.find_effective()
|| text.inset().forceLocalFontSwitch()
|| (using_begin_end && text.inset().forcePlainLayout())
|| in_polyglossia_rtl_env)
bool const localswitch_needed = localswitch && par_lang != outer_lang;
// localswitches need to be closed and reopened at each par
- if ((runparams_in.for_searchAdv != OutputParams::NoSearch) || ((par_lang != prev_lang || localswitch_needed)
+ if (runparams_in.find_effective() || ((par_lang != prev_lang || localswitch_needed)
// check if we already put language command in TeXEnvironment()
&& !(style.isEnvironment()
&& (pit == 0 || (priorpar->layout() != par.layout()
else if (outer_language->lang() == "arabic_arabi")
os << "\\textLR{";
// remaining RTL languages currently is hebrew
- else if (par_language->rightToLeft())
+ else if (par_language->rightToLeft() && !runparams.isFullUnicode())
os << "\\R{";
else
os << "\\L{";
// With CJK, the CJK tag has to be closed first (see below)
if ((runparams.encoding->package() != Encoding::CJK
|| bparams.useNonTeXFonts
- || (runparams.for_searchAdv != OutputParams::NoSearch))
+ || runparams.find_effective())
&& (par_lang != openLanguageName(state) || localswitch || intitle_command)
&& !par_lang.empty()) {
string bc = use_polyglossia ?
&& (pit == 0 || !priorpar->hasSameLayout(par)))
{
os << from_ascii(par.params().spacing().writeEnvirBegin(useSetSpace))
- << '\n';
+ << '\n';
}
if (style.isCommand()) {
bool const is_command = style.isCommand();
+ bool const last_was_separator =
+ !par.empty() && par.isEnvSeparator(par.size() - 1);
+
// InTitle commands need to be closed after the language has been closed.
if (!intitle_command) {
if (is_command) {
+ // 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 << "}";
+ }
os << '}';
if (!style.postcommandargs().empty())
latexArgInsets(par, os, runparams, style.postcommandargs(), "post:");
os << runparams.post_macro;
runparams.post_macro.clear();
}
- if (par.needsCProtection(runparams.moving_arg)
+ if (!runparams.no_cprotect && par.needsCProtection(runparams.moving_arg)
&& contains(runparams.active_chars, '^'))
os << "\\endgroup";
if (runparams.encoding != prev_encoding) {
if (localswitch_needed
|| (intitle_command && using_begin_end)
|| closing_rtl_ltr_environment
- || (((runparams.isLastPar && !runparams.inbranch) || close_lang_switch)
+ || (((runparams.isLastPar
+ && (using_begin_end
+ // Since \selectlanguage write the language to the aux file,
+ // we need to reset the language at the end of footnote or
+ // float.
+ || runparams.inFloat != OutputParams::NONFLOAT || runparams.inFootnote
+ // Same for maintext in children (see below)
+ || maintext))
+ || close_lang_switch)
&& (par_lang != outer_lang || (using_begin_end
&& style.isEnvironment()
&& par_lang != nextpar_lang)))) {
- // Since \selectlanguage write the language to the aux file,
- // we need to reset the language at the end of footnote or
- // float.
if (!localswitch && (pending_newline || close_lang_switch))
os << '\n';
// when the paragraph uses CJK, the language has to be closed earlier
if ((font.language()->encoding()->package() != Encoding::CJK)
|| bparams.useNonTeXFonts
- || (runparams_in.for_searchAdv != OutputParams::NoSearch)) {
+ || runparams_in.find_effective()) {
if (lang_end_command.empty()) {
// If this is a child, we should restore the
// master language after the last paragraph.
os << runparams.post_macro;
runparams.post_macro.clear();
}
- if (par.needsCProtection(runparams.moving_arg)
+ if (!runparams.no_cprotect && par.needsCProtection(runparams.moving_arg)
&& contains(runparams.active_chars, '^'))
os << "\\endgroup";
if (runparams.encoding != prev_encoding) {
}
}
- bool const last_was_separator =
- !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
+ if ((intitle_command || !is_command) && nextpar && !os.afterParbreak() && !last_was_separator
&& bparams.output_changes && par.parEndChange().changed()) {
Changes::latexMarkChange(os, bparams, Change(Change::UNCHANGED),
par.parEndChange(), runparams);
// 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) {
- if (runparams.isNonLong)
- // This is to allow parbreak in multirow
- // It could also be used for other non-long
- // contexts
- os << "\\endgraf";
- else if (!text.inset().getLayout().parbreakIgnored() && !merged_par)
+ 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,
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
- // paragraph style allows parbreaks and no \begin, \end
- // or \item tags are going to follow (i.e., if the next
- // isn't the first or the current isn't the last
- // paragraph of an environment or itemize) and the
- // depth and alignment of the following paragraph is
- // unchanged, or (case 2) the following is a
- // non-environment paragraph whose depth is increased
- // but whose alignment is unchanged, or (case 3) the
- // paragraph is not an environment and the next one is a
- // non-itemize-like env at lower depth, or (case 4) the
- // paragraph is a command not followed by an environment
- // and the alignment of the current and next paragraph
- // is unchanged, or (case 5) the current alignment is
- // changed and a standard paragraph follows.
+ // outputting a paragraph break only if:
+ // (case 1) the paragraph style allows parbreaks and
+ // no \begin, \end or \item tags are going to follow
+ // (i.e., if the next isn't the first or the current
+ // isn't the last paragraph of an environment or itemize)
+ // and the depth and alignment of the following paragraph is
+ // unchanged, or
+ // (case 2) the following is a non-environment paragraph
+ // whose depth is increased but whose alignment is unchanged, or
+ // (case 3) the paragraph is not an environment and the next one
+ // is a non-itemize-like env at lower depth, or
+ // (case 4) the paragraph is a command not followed by an
+ // environment and the alignment of the current and next
+ // paragraph is unchanged, or
+ // (case 5) the current alignment is changed and a
+ // standard paragraph follows.
DocumentClass const & tclass = bparams.documentClass();
if ((style == next_layout
&& !style.parbreak_is_newline
&& style.latextype != LATEX_LIST_ENVIRONMENT
&& style.align == par.getAlign(bparams)
&& nextpar->getDepth() == par.getDepth()
- && nextpar->getAlign(bparams) == par.getAlign(bparams))
+ && (nextpar->getAlign(bparams) == par.getAlign(bparams)
+ || par.params().spacing() != nextpar->params().spacing()))
|| (!next_layout.isEnvironment()
&& nextpar->getDepth() > par.getDepth()
&& nextpar->getAlign(bparams) == next_layout.align)
&& tclass.isDefaultLayout(next_layout))) {
// and omit paragraph break if it has been deleted with ct
// and changes are not shown in output
- if (!merged_par)
- os << '\n';
+ 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';
+ }
}
}
}
if (intitle_command)
state->nest_level_ -= 1;
- LYXERR(Debug::LATEX, "TeXOnePar for paragraph " << pit << " done; ptr "
- << &par << " next " << nextpar);
+ LYXERR(Debug::OUTFILE, "TeXOnePar for paragraph " << pit << " done; ptr "
+ << &par << " next " << nextpar);
return;
}
// 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)
+ if (!runparams.find_effective())
output_changes = bparams.output_changes;
else
- output_changes = (runparams.for_searchAdv == OutputParams::SearchWithDeleted);
- if (size_t(pit + 1) < paragraphs.size()) {
+ output_changes = runparams.find_with_deleted();
+ bool const lastpar = size_t(pit + 1) >= paragraphs.size();
+ if (!lastpar) {
ParagraphList::const_iterator nextpar = paragraphs.iterator_at(pit + 1);
Paragraph const & cpar = paragraphs.at(pit);
if ((par->layout() != nextpar->layout()
prepareEnvironment(buf, text, par, os, runparams);
// pit can be changed in TeXEnvironment.
TeXEnvironment(buf, text, runparams, pit, os);
- finishEnvironment(os, runparams, data);
+ finishEnvironment(os, runparams, data, maintext, lastpar);
}
// FIXME: uncomment the content or remove this block
<< '\n';
// If we have language_auto_begin, the stack will
// already be empty, nothing to pop()
- if (using_begin_end && !lyxrc.language_auto_begin)
+ if (using_begin_end && langOpenedAtThisLevel(state))
popLanguageName();
}
|| oldEnc.package() == Encoding::japanese
|| oldEnc.package() == Encoding::none
|| newEnc.package() == Encoding::none
- || (runparams.for_searchAdv != OutputParams::NoSearch))
+ || runparams.find_effective())
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.
// but it is the best we can do.
// change encoding
- LYXERR(Debug::LATEX, "Changing LaTeX encoding from "
+ LYXERR(Debug::OUTFILE, "Changing LaTeX encoding from "
<< oldEnc.name() << " to " << newEnc.name());
os << setEncoding(newEnc.iconvName());
if (bparams.inputenc == "auto-legacy-plain")
projects / lyx.git / blobdiff