#include "support/lstrings.h"
#include "support/textutils.h"
+#include <QThreadStorage>
+
#include <algorithm>
#include <boost/next_prior.hpp>
#include <list>
CJK
};
-// FIXME THREAD
-// There could easily be a conflict here, with the export process
-// setting this one way, and a View>Source process (possbily for
-// another Buffer) resetting it.
-static int open_encoding_ = none;
-static int cjk_inherited_ = 0;
-Language const * prev_env_language_ = 0;
+
+struct OutputState
+{
+ OutputState() : open_encoding_(none), cjk_inherited_(0),
+ prev_env_language_(0)
+ {
+ }
+ int open_encoding_;
+ int cjk_inherited_;
+ Language const * prev_env_language_;
+};
+
+
+OutputState * getOutputState()
+{
+ // FIXME An instance of OutputState should be kept around for each export
+ // instead of using local thread storage
+ static QThreadStorage<OutputState *> outputstate;
+ if (!outputstate.hasLocalData())
+ outputstate.setLocalData(new OutputState);
+ return outputstate.localData();
+}
string const getPolyglossiaEnvName(Language const * lang)
ParagraphList::const_iterator const priorpit =
pit == paragraphs.begin() ? pit : boost::prior(pit);
- bool const use_prev_env_language = prev_env_language_ != 0
+ OutputState * state = getOutputState();
+ bool const use_prev_env_language = state->prev_env_language_ != 0
&& priorpit->layout().isEnvironment()
&& (priorpit->getDepth() > pit->getDepth()
|| (priorpit->getDepth() == pit->getDepth()
Language const * const doc_language = bparams.language;
Language const * const prev_par_language =
(pit != paragraphs.begin())
- ? (use_prev_env_language ? prev_env_language_
+ ? (use_prev_env_language ? state->prev_env_language_
: priorpit->getParLanguage(bparams))
: doc_language;
// in multilingual environments, the CJK tags have to be nested properly
data.cjk_nested = false;
if (data.par_language->encoding()->package() == Encoding::CJK &&
- open_encoding_ != CJK && pit->isMultiLingual(bparams)) {
+ 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())
<< "}{" << from_ascii(bparams.fonts_cjk) << "}%\n";
- open_encoding_ = CJK;
+ state->open_encoding_ = CJK;
data.cjk_nested = true;
}
return data;
}
-static void finishEnvironment(Buffer const & buf, Text const & text,
- pit_type nextpit, otexstream & os,
- OutputParams const & runparams,
+static void finishEnvironment(otexstream & os, OutputParams const & runparams,
TeXEnvironmentData const & data)
{
- if (open_encoding_ == CJK && data.cjk_nested) {
+ OutputState * state = getOutputState();
+ 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
os << "\\end{CJK}\n";
- open_encoding_ = none;
+ state->open_encoding_ = none;
}
if (data.style->isEnvironment()) {
os << breakln
<< "\\end{" << from_ascii(data.style->latexname()) << "}\n";
- prev_env_language_ = data.par_language;
+ state->prev_env_language_ = data.par_language;
if (runparams.encoding != data.prev_encoding) {
runparams.encoding = data.prev_encoding;
if (!runparams.isFullUnicode())
if (data.leftindent_open) {
os << breakln << "\\end{LyXParagraphLeftIndent}\n";
- prev_env_language_ = data.par_language;
+ state->prev_env_language_ = data.par_language;
if (runparams.encoding != data.prev_encoding) {
runparams.encoding = data.prev_encoding;
if (!runparams.isFullUnicode())
}
// Check whether we should output a blank line after the environment
- DocumentClass const & tclass = buf.params().documentClass();
- ParagraphList const & pars = text.paragraphs();
- bool next_style_is_default = (nextpit >= runparams.par_end) ? false
- : tclass.isDefaultLayout(pars.constIterator(nextpit)->layout());
- if (!data.style->nextnoindent && next_style_is_default)
+ if (!data.style->nextnoindent)
os << '\n';
}
prepareEnvironment(buf, text, par, os, runparams);
// Recursive call to TeXEnvironment!
TeXEnvironment(buf, text, runparams, pit, os);
- finishEnvironment(buf, text, pit + 1, os, runparams, data);
+ finishEnvironment(os, runparams, data);
}
if (pit != runparams.par_end)
if (argnr == 0)
return;
+ // Default and preset args are always output, so if they require
+ // other arguments, consider this.
+ Layout::LaTeXArgMap::const_iterator lit = latexargs.begin();
+ Layout::LaTeXArgMap::const_iterator const lend = latexargs.end();
+ for (; lit != lend; ++lit) {
+ Layout::latexarg arg = (*lit).second;
+ if ((!arg.presetarg.empty() || !arg.defaultarg.empty()) && !arg.requires.empty()) {
+ vector<string> req = getVectorFromString(arg.requires);
+ 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);
bool inserted = false;
bool const maintext = text.isMainText();
// we are at the beginning of an inset and CJK is already open;
// we count inheritation levels to get the inset nesting right.
+ OutputState * state = getOutputState();
if (pit == 0 && !maintext
- && (cjk_inherited_ > 0 || open_encoding_ == CJK)) {
- cjk_inherited_ += 1;
- open_encoding_ = none;
+ && (state->cjk_inherited_ > 0 || state->open_encoding_ == CJK)) {
+ state->cjk_inherited_ += 1;
+ state->open_encoding_ = none;
}
if (text.inset().isPassThru()) {
// environment with nesting depth greater than (or equal to, but with
// a different layout) the current one. If there is no previous
// paragraph, the previous language is the outer language.
- bool const use_prev_env_language = prev_env_language_ != 0
+ bool const use_prev_env_language = state->prev_env_language_ != 0
&& priorpar
&& priorpar->layout().isEnvironment()
&& (priorpar->getDepth() > par.getDepth()
&& priorpar->layout() != par.layout()));
Language const * const prev_language =
(pit != 0)
- ? (use_prev_env_language ? prev_env_language_
+ ? (use_prev_env_language ? state->prev_env_language_
: priorpar->getParLanguage(bparams))
: outer_language;
// the following is necessary after a CJK environment in a multilingual
// context (nesting issue).
if (par_language->encoding()->package() == Encoding::CJK
- && open_encoding_ != CJK && cjk_inherited_ == 0) {
+ && state->open_encoding_ != CJK && state->cjk_inherited_ == 0) {
os << "\\begin{CJK}{" << from_ascii(par_language->encoding()->latexName())
<< "}{" << from_ascii(bparams.fonts_cjk) << "}%\n";
- open_encoding_ = CJK;
+ state->open_encoding_ = CJK;
}
if (encoding->package() != Encoding::none && enc_switch.first) {
if (enc_switch.second > 0) {
switch (style.latextype) {
case LATEX_ITEM_ENVIRONMENT:
case LATEX_LIST_ENVIRONMENT:
- if (nextpar
- && (par.params().depth() < nextpar->params().depth())
- && !par.isEnvSeparator(par.size() - 1))
+ if (nextpar && par.params().depth() < nextpar->params().depth())
pending_newline = true;
break;
case LATEX_ENVIRONMENT: {
// fall through possible
default:
// we don't need it for the last paragraph!!!
- // or if the last thing is an environment separator
- if (nextpar && par.size() > 0 && !par.isEnvSeparator(par.size() - 1))
+ if (nextpar)
pending_newline = true;
}
if (closing_rtl_ltr_environment)
os << "}";
+ bool const last_was_separator =
+ par.size() > 0 && par.isEnvSeparator(par.size() - 1);
+
if (pending_newline) {
if (unskip_newline)
// prevent unwanted whitespace
os << '%';
- os << '\n';
+ if (!os.afterParbreak() && !last_was_separator)
+ os << '\n';
}
// 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
- && open_encoding_ == CJK
+ && state->open_encoding_ == CJK
&& (nextpar->getParLanguage(bparams)->encoding()->package() != Encoding::CJK
|| (nextpar->layout().isEnvironment() && nextpar->isMultiLingual(bparams)))
// inbetween environments, CJK has to be closed later (nesting!)
&& (!style.isEnvironment() || !nextpar->layout().isEnvironment())) {
os << "\\end{CJK}\n";
- open_encoding_ = none;
+ state->open_encoding_ = none;
}
// If this is the last paragraph, close the CJK environment
// if necessary. If it's an environment, we'll have to \end that first.
if (runparams.isLastPar && !style.isEnvironment()) {
- switch (open_encoding_) {
+ switch (state->open_encoding_) {
case CJK: {
// do nothing at the end of child documents
if (maintext && buf.masterBuffer() != &buf)
// end of an inset
} else
os << "\\end{CJK}";
- open_encoding_ = none;
+ state->open_encoding_ = none;
break;
}
case inputenc: {
os << "\\egroup";
- open_encoding_ = none;
+ state->open_encoding_ = none;
break;
}
case none:
// 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 && par.size() > 0 && !par.isEnvSeparator(par.size() - 1)) {
+ if (nextpar && !os.afterParbreak() && !last_was_separator) {
// Make sure to start a new line
os << breakln;
Layout const & next_layout = nextpar->layout();
// 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 4) the current alignment is
+ // is unchanged, or (case 5) the current alignment is
// changed and a standard paragraph follows.
DocumentClass const & tclass = bparams.documentClass();
if ((style == next_layout
|| (!next_layout.isEnvironment()
&& nextpar->getDepth() > par.getDepth()
&& nextpar->getAlign() == par.getAlign())
+ || (!style.isEnvironment()
+ && next_layout.latextype == LATEX_ENVIRONMENT
+ && nextpar->getDepth() < par.getDepth())
|| (style.isCommand()
&& !next_layout.isEnvironment()
&& style.align == par.getAlign()
// Open a CJK environment at the beginning of the main buffer
// if the document's language is a CJK language
// (but not in child documents)
+ OutputState * state = getOutputState();
if (maintext && !is_child
&& bparams.encoding().package() == Encoding::CJK) {
os << "\\begin{CJK}{" << from_ascii(bparams.encoding().latexName())
<< "}{" << from_ascii(bparams.fonts_cjk) << "}%\n";
- open_encoding_ = CJK;
+ state->open_encoding_ = CJK;
}
// if "auto begin" is switched off, explicitly switch the
// language on at start
prepareEnvironment(buf, text, par, os, runparams);
// pit can be changed in TeXEnvironment.
TeXEnvironment(buf, text, runparams, pit, os);
- finishEnvironment(buf, text, pit + 1, os, runparams, data);
+ finishEnvironment(os, runparams, data);
}
if (pit == runparams.par_end) {
// If the last paragraph is an environment, we'll have to close
// CJK at the very end to do proper nesting.
- if (maintext && !is_child && open_encoding_ == CJK) {
+ if (maintext && !is_child && state->open_encoding_ == CJK) {
os << "\\end{CJK}\n";
- open_encoding_ = none;
+ state->open_encoding_ = none;
}
// reset inherited encoding
- if (cjk_inherited_ > 0) {
- cjk_inherited_ -= 1;
- if (cjk_inherited_ == 0)
- open_encoding_ = CJK;
+ if (state->cjk_inherited_ > 0) {
+ state->cjk_inherited_ -= 1;
+ if (state->cjk_inherited_ == 0)
+ state->open_encoding_ = CJK;
}
}
return make_pair(true, 0);
docstring const inputenc_arg(from_ascii(newEnc.latexName()));
+ OutputState * state = getOutputState();
switch (newEnc.package()) {
case Encoding::none:
case Encoding::japanese:
case Encoding::inputenc: {
int count = inputenc_arg.length();
if (oldEnc.package() == Encoding::CJK &&
- open_encoding_ == CJK) {
+ state->open_encoding_ == CJK) {
os << "\\end{CJK}";
- open_encoding_ = none;
+ state->open_encoding_ = none;
count += 9;
}
else if (oldEnc.package() == Encoding::inputenc &&
- open_encoding_ == inputenc) {
+ state->open_encoding_ == inputenc) {
os << "\\egroup";
- open_encoding_ = none;
+ state->open_encoding_ = none;
count += 7;
}
if (runparams.local_font != 0
// else CJK fails.
os << "\\bgroup";
count += 7;
- open_encoding_ = inputenc;
+ state->open_encoding_ = inputenc;
}
// with the japanese option, inputenc is omitted.
if (runparams.use_japanese)
case Encoding::CJK: {
int count = inputenc_arg.length();
if (oldEnc.package() == Encoding::CJK &&
- open_encoding_ == CJK) {
+ state->open_encoding_ == CJK) {
os << "\\end{CJK}";
count += 9;
}
if (oldEnc.package() == Encoding::inputenc &&
- open_encoding_ == inputenc) {
+ state->open_encoding_ == inputenc) {
os << "\\egroup";
count += 7;
}
os << "\\begin{CJK}{" << inputenc_arg << "}{"
<< from_ascii(bparams.fonts_cjk) << "}";
- open_encoding_ = CJK;
+ state->open_encoding_ = CJK;
return make_pair(true, count + 15);
}
}