#include "Font.h"
#include "InsetList.h"
#include "Language.h"
-#include "LaTeXFeatures.h"
-#include "Layout.h"
#include "LyXRC.h"
#include "OutputParams.h"
#include "Paragraph.h"
struct OutputState
{
- OutputState() : open_encoding_(none), cjk_inherited_(0),
- prev_env_language_(nullptr), 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<int> lang_switch_depth_; // Both are always empty when
stack<string> open_polyglossia_lang_; // not using polyglossia
+ OpenEncoding open_encoding_;
+ int cjk_inherited_;
+ int nest_level_;
};
// 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_;
}
{
// 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;
}
{
// 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_;
}
struct TeXEnvironmentData
{
- bool cjk_nested;
Layout const * style;
Language const * par_language;
Encoding const * prev_encoding;
+ bool cjk_nested;
bool leftindent_open;
};
// 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;
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();
// 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);
continue;
}
+ // Do not output empty environments if the whole paragraph has
+ // been deleted with ct and changes are not output.
+ 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())
+ && !runparams.for_search && !cpar.empty()
+ && cpar.isDeleted(0, cpar.size()) && !buf.params().output_changes) {
+ if (!buf.params().output_changes && !cpar.parEndChange().deleted())
+ os << '\n' << '\n';
+ continue;
+ }
+ }
+
// This is a new environment.
TeXEnvironmentData const data =
prepareEnvironment(buf, text, par, os, runparams);
void getArgInsets(otexstream & os, OutputParams const & runparams, Layout::LaTeXArgMap const & latexargs,
- map<int, lyx::InsetArgument const *> ilist, vector<string> required, string const & prefix)
+ map<size_t, lyx::InsetArgument const *> ilist, vector<string> required, string const & prefix)
{
- unsigned int const argnr = latexargs.size();
+ size_t const argnr = latexargs.size();
if (argnr == 0)
return;
// 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<string> req = getVectorFromString(arg.requires);
+ if ((!arg.presetarg.empty() || !arg.defaultarg.empty()) && !arg.required.empty()) {
+ vector<string> req = getVectorFromString(arg.required);
required.insert(required.end(), req.begin(), req.end());
}
}
- for (unsigned int i = 1; i <= argnr; ++i) {
- map<int, InsetArgument const *>::const_iterator lit = ilist.find(i);
+ for (size_t i = 1; i <= argnr; ++i) {
+ map<size_t, InsetArgument const *>::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) {
void addArgInsets(Paragraph const & par, string const & prefix,
Layout::LaTeXArgMap const & latexargs,
- map<int, InsetArgument const *> & ilist,
+ map<size_t, InsetArgument const *> & ilist,
vector<string> & required)
{
for (auto const & table : par.insetList()) {
}
string const name = prefix.empty() ?
arg->name() : split(arg->name(), ':');
- // why converting into an integer?
- unsigned int const nr = convert<unsigned int>(name);
- if (ilist.find(nr) == ilist.end())
- ilist[nr] = arg;
+ size_t const nr = convert<size_t>(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<string> req = getVectorFromString(larg.requires);
+ vector<string> req = getVectorFromString(larg.required);
move(req.begin(), req.end(), back_inserter(required));
}
}
Layout::LaTeXArgMap const & latexargs,
string const & prefix)
{
- map<int, InsetArgument const *> ilist;
+ map<size_t, InsetArgument const *> ilist;
vector<string> required;
addArgInsets(par, prefix, latexargs, ilist, required);
getArgInsets(os, runparams, latexargs, ilist, required, prefix);
Layout::LaTeXArgMap const & latexargs,
string const & prefix)
{
- map<int, InsetArgument const *> ilist;
+ map<size_t, InsetArgument const *> ilist;
vector<string> 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;
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)
Layout::LaTeXArgMap const & latexargs,
string const & prefix)
{
- map<int, InsetArgument const *> ilist;
+ map<size_t, InsetArgument const *> ilist;
vector<string> required;
for (Paragraph const & par : pars) {
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_search && 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 << "'");
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';
? nullptr : ¶graphs.at(pit + 1);
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);
// 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 << '{';
if (par.needsCProtection(runparams.moving_arg)
&& contains(runparams.active_chars, '^'))
os << "\\endgroup";
- os << "\n";
+ if (merged_par)
+ os << "{}";
+ else
+ os << "\n";
}
- else
+ 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';
}
// 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 << '{';
}
&& runparams.local_font != nullptr
&& outer_language->rightToLeft()
&& !par_language->rightToLeft();
- bool const localswitch = runparams_in.for_search
+ bool const localswitch =
+ (runparams_in.for_search
|| 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;
// 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);
&& 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
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
&& nextpar
&& style != nextpar->layout())))
|| (atSameLastLangSwitchDepth(state)
- && state->lang_switch_depth_.size()
+ && !state->lang_switch_depth_.empty()
&& cur_lang != par_lang)
|| in_polyglossia_rtl_env)
{
}
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)
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())) {
// 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!!!
// 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,
&& nextpar->getDepth() > par.getDepth()
&& nextpar->getAlign(bparams) == next_layout.align)
|| (!style.isEnvironment()
- && !tclass.isDefaultLayout(style)
&& next_layout.latextype == LATEX_ENVIRONMENT
&& nextpar->getDepth() < par.getDepth())
|| (style.isCommand()
&& 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)
+ 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);
// 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<int>(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.
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()
continue;
}
+ // Do not output empty environments if the whole paragraph has
+ // been deleted with ct and changes are not output.
+ 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())
+ && !runparams.for_search && !cpar.empty()
+ && cpar.isDeleted(0, cpar.size()) && !bparams.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.
//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";
"$$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();
}
// 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}";
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}";