namespace {
+
+enum OpenEncoding {
+ none,
+ inputenc,
+ CJK
+ };
+
+static int open_encoding_ = none;
+static bool cjk_inherited_ = false;
+
+
ParagraphList::const_iterator
TeXEnvironment(Buffer const & buf,
ParagraphList const & paragraphs,
os << from_ascii(style->latexparam()) << '\n';
texrow.newline();
}
+
+ // in multilingual environments, the CJK tags have to be nested properly
+ bool cjk_nested = false;
+ if (par_language->encoding()->package() == Encoding::CJK &&
+ open_encoding_ != CJK && pit->isMultiLingual(bparams)) {
+ os << "\\begin{CJK}{" << from_ascii(par_language->encoding()->latexName())
+ << "}{}%\n";
+ open_encoding_ = CJK;
+ cjk_nested = true;
+ texrow.newline();
+ }
+
ParagraphList::const_iterator par = pit;
do {
par = TeXOnePar(buf, paragraphs, par, os, texrow, runparams);
&& par->params().depth() == pit->params().depth()
&& par->params().leftIndent() == pit->params().leftIndent());
+ if (open_encoding_ == CJK && cjk_nested) {
+ // We need to close the encoding even if it does not change
+ // to do correct environment nesting
+ os << "\\end{CJK}\n";
+ texrow.newline();
+ open_encoding_ = none;
+ }
+
if (style->isEnvironment()) {
os << "\\end{" << from_ascii(style->latexname()) << "}\n";
texrow.newline();
OutputParams runparams = runparams_in;
runparams.moving_arg |= style->needprotect;
+ // we are at the beginning of an inset and CJK is already open.
+ if (pit == paragraphs.begin() && runparams.local_font != 0 &&
+ open_encoding_ == CJK) {
+ cjk_inherited_ = true;
+ open_encoding_ = none;
+ }
+
+ if (pit == paragraphs.begin() && runparams.local_font == 0) {
+ // Open a CJK environment at the beginning of the main buffer
+ // if the document's language is a CJK language
+ if (bparams.encoding().package() == Encoding::CJK) {
+ os << "\\begin{CJK}{" << from_ascii(bparams.encoding().latexName())
+ << "}{}%\n";
+ texrow.newline();
+ open_encoding_ = CJK;
+ }
+ if (!lyxrc.language_auto_begin && !bparams.language->babel().empty()) {
+ // FIXME UNICODE
+ os << from_utf8(subst(lyxrc.language_command_begin,
+ "$$lang",
+ bparams.language->babel()))
+ << '\n';
+ texrow.newline();
+ }
+ }
+
// This paragraph's language
Language const * const par_language = pit->getParLanguage(bparams);
// The document's language
else
os << "\\L{";
}
- os << from_ascii(subst(
- lyxrc.language_command_begin,
- "$$lang",
- par_language->babel()))
- // the '%' is necessary to prevent unwanted whitespace
- << "%\n";
- texrow.newline();
+ // With CJK, the CJK tag has to be closed first (see below)
+ if (runparams.encoding->package() != Encoding::CJK) {
+ os << from_ascii(subst(
+ lyxrc.language_command_begin,
+ "$$lang",
+ par_language->babel()))
+ // the '%' is necessary to prevent unwanted whitespace
+ << "%\n";
+ texrow.newline();
+ }
}
}
// encoding, since this only affects the position of the outputted
// \inputencoding command; the encoding switch will occur when necessary
if (bparams.inputenc == "auto" &&
- runparams.encoding->package() == Encoding::inputenc) {
+ runparams.encoding->package() != Encoding::none) {
// Look ahead for future encoding changes.
// We try to output them at the beginning of the paragraph,
// since the \inputencoding command is not allowed e.g. in
// sections.
for (pos_type i = 0; i < pit->size(); ++i) {
char_type const c = pit->getChar(i);
- if (c < 0x80)
+ if (runparams.encoding->package() == Encoding::inputenc && c < 0x80)
continue;
if (pit->isInset(i))
break;
// encoding to that required by the language of c.
Encoding const * const encoding =
pit->getFontSettings(bparams, i).language()->encoding();
- pair<bool, int> enc_switch = switchEncoding(os, bparams, false,
+
+ // with CJK, only add switch if we have CJK content at the beginning
+ // of the paragraph
+ if (encoding->package() != Encoding::CJK || i == 0) {
+ OutputParams tmp_rp = runparams;
+ runparams.moving_arg = false;
+ pair<bool, int> enc_switch = switchEncoding(os, bparams, runparams,
*(runparams.encoding), *encoding);
- if (encoding->package() == Encoding::inputenc && enc_switch.first) {
- runparams.encoding = encoding;
- if (enc_switch.second > 0) {
- // the '%' is necessary to prevent unwanted whitespace
- os << "%\n";
+ runparams = tmp_rp;
+ // 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_) {
+ os << "\\begin{CJK}{" << from_ascii(par_language->encoding()->latexName())
+ << "}{}%\n";
+ open_encoding_ = CJK;
texrow.newline();
}
+ if (encoding->package() != Encoding::none && enc_switch.first) {
+ if (enc_switch.second > 0) {
+ // the '%' is necessary to prevent unwanted whitespace
+ os << "%\n";
+ texrow.newline();
+ }
+ // With CJK, the CJK tag had to be closed first (see above)
+ if (runparams.encoding->package() == Encoding::CJK) {
+ os << from_ascii(subst(
+ lyxrc.language_command_begin,
+ "$$lang",
+ par_language->babel()))
+ // the '%' is necessary to prevent unwanted whitespace
+ << "%\n";
+ texrow.newline();
+ }
+ runparams.encoding = encoding;
+ }
+ break;
}
- break;
}
}
os << '\n';
texrow.newline();
}
- if (lyxrc.language_command_end.empty()) {
- if (!prev_language->babel().empty()) {
+ // when the paragraph uses CJK, the language has to be closed earlier
+ if (font.language()->encoding()->package() != Encoding::CJK) {
+ if (lyxrc.language_command_end.empty()) {
+ if (!prev_language->babel().empty()) {
+ os << from_ascii(subst(
+ lyxrc.language_command_begin,
+ "$$lang",
+ prev_language->babel()));
+ pending_newline = true;
+ }
+ } else if (!par_language->babel().empty()) {
os << from_ascii(subst(
- lyxrc.language_command_begin,
+ lyxrc.language_command_end,
"$$lang",
- prev_language->babel()));
+ par_language->babel()));
pending_newline = true;
}
- } else if (!par_language->babel().empty()) {
- os << from_ascii(subst(
- lyxrc.language_command_end,
- "$$lang",
- par_language->babel()));
- pending_newline = true;
}
}
if (closing_rtl_ltr_environment)
texrow.newline();
}
+ // 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 (boost::next(pit) != paragraphs.end() && open_encoding_ == CJK &&
+ (boost::next(pit)->getParLanguage(bparams)->encoding()->package() != Encoding::CJK ||
+ boost::next(pit)->layout()->isEnvironment() && boost::next(pit)->isMultiLingual(bparams))
+ // in environments, CJK has to be closed later (nesting!)
+ && !style->isEnvironment()) {
+ os << "\\end{CJK}\n";
+ 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 (boost::next(pit) == paragraphs.end() && !style->isEnvironment()) {
+ switch (open_encoding_) {
+ case CJK: {
+ // end of main text
+ if (runparams.local_font == 0) {
+ os << '\n';
+ texrow.newline();
+ os << "\\end{CJK}\n";
+ texrow.newline();
+ // end of an inset
+ } else
+ os << "\\end{CJK}";
+ open_encoding_ = none;
+ break;
+ }
+ case inputenc: {
+ os << "\\egroup";
+ open_encoding_ = none;
+ break;
+ }
+ case none:
+ default:
+ // do nothing
+ break;
+ }
+ // auto_end tag only if the last par is in a babel language
+ if (runparams.local_font == 0 && !lyxrc.language_auto_end &&
+ !bparams.language->babel().empty() &&
+ font.language()->encoding()->package() != Encoding::CJK) {
+ os << from_utf8(subst(lyxrc.language_command_end,
+ "$$lang",
+ bparams.language->babel()))
+ << '\n';
+ texrow.newline();
+ }
+ }
+
// If this is the last paragraph, and a local_font was set upon entering
// the inset, the encoding should be set back to that local_font's
// encoding. We don't use switchEncoding(), because no explicit encoding
}
texrow.newline();
}
+ // If the last paragraph is an environment, we'll have to close
+ // CJK at the very end to do proper nesting.
+ if (open_encoding_ == CJK) {
+ os << "\\end{CJK}\n";
+ texrow.newline();
+ open_encoding_ = none;
+ }
+ // reset inherited encoding
+ if (cjk_inherited_) {
+ open_encoding_ = CJK;
+ cjk_inherited_ = false;
+ }
}
pair<bool, int> switchEncoding(odocstream & os, BufferParams const & bparams,
- bool moving_arg, Encoding const & oldEnc,
+ OutputParams const & runparams, Encoding const & oldEnc,
Encoding const & newEnc)
{
+ bool moving_arg = runparams.moving_arg;
if ((bparams.inputenc != "auto" && bparams.inputenc != "default")
|| moving_arg)
return make_pair(false, 0);
if (bparams.inputenc == "default")
return make_pair(true, 0);
- docstring const inputenc = from_ascii(newEnc.latexName());
+ docstring const inputenc_arg(from_ascii(newEnc.latexName()));
switch (newEnc.package()) {
case Encoding::none:
// shouldn't ever reach here, see above
return make_pair(true, 0);
case Encoding::inputenc: {
- int count = inputenc.length();
- if (oldEnc.package() == Encoding::CJK) {
+ int count = inputenc_arg.length();
+ if (oldEnc.package() == Encoding::CJK &&
+ open_encoding_ == CJK) {
os << "\\end{CJK}";
+ open_encoding_ = none;
count += 9;
}
- os << "\\inputencoding{" << inputenc << '}';
+ else if (oldEnc.package() == Encoding::inputenc &&
+ open_encoding_ == inputenc) {
+ os << "\\egroup";
+ open_encoding_ = none;
+ count += 7;
+ }
+ if (runparams.local_font != 0 && oldEnc.package() == Encoding::CJK) {
+ // within insets, \inputenc switches need to be
+ // embraced within \bgroup ... \egroup; else CJK fails.
+ os << "\\bgroup";
+ count += 7;
+ open_encoding_ = inputenc;
+ }
+ os << "\\inputencoding{" << inputenc_arg << '}';
return make_pair(true, count + 16);
}
case Encoding::CJK: {
- int count = inputenc.length();
- if (oldEnc.package() == Encoding::CJK) {
+ int count = inputenc_arg.length();
+ if (oldEnc.package() == Encoding::CJK &&
+ open_encoding_ == CJK) {
os << "\\end{CJK}";
count += 9;
}
- os << "\\begin{CJK}{" << inputenc << "}{}";
+ if (oldEnc.package() == Encoding::inputenc &&
+ open_encoding_ == inputenc) {
+ os << "\\egroup";
+ count += 7;
+ }
+ os << "\\begin{CJK}{" << inputenc_arg << "}{}";
+ open_encoding_ = CJK;
return make_pair(true, count + 15);
}
}
// Dead code to avoid a warning:
return make_pair(true, 0);
+
}
} // namespace lyx
projects / features.git / commitdiff