#include "Buffer.h"
#include "BufferParams.h"
-#include "debug.h"
+#include "support/debug.h"
#include "Encoding.h"
+#include "InsetList.h"
#include "Language.h"
#include "Layout.h"
#include "LyXRC.h"
#include "Paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
+#include "TextClass.h"
#include "TexRow.h"
#include "VSpace.h"
#include "support/lstrings.h"
+#include <boost/next_prior.hpp>
+
+using namespace std;
+using namespace lyx::support;
namespace lyx {
-using support::subst;
+namespace {
-using std::endl;
-using std::string;
-using std::pair;
-using std::make_pair;
+enum OpenEncoding {
+ none,
+ inputenc,
+ CJK
+ };
+
+static int open_encoding_ = none;
+static bool cjk_inherited_ = false;
-namespace {
ParagraphList::const_iterator
TeXEnvironment(Buffer const & buf,
odocstream & os, TexRow & texrow,
OutputParams const & runparams)
{
- LYXERR(Debug::LATEX) << "TeXDeeper... " << &*pit << endl;
+ LYXERR(Debug::LATEX, "TeXDeeper... " << &*pit);
ParagraphList::const_iterator par = pit;
while (par != paragraphs.end() &&
os, texrow, runparams);
}
}
- LYXERR(Debug::LATEX) << "TeXDeeper...done " << endl;
+ LYXERR(Debug::LATEX, "TeXDeeper...done ");
return par;
}
odocstream & os, TexRow & texrow,
OutputParams const & runparams)
{
- LYXERR(Debug::LATEX) << "TeXEnvironment... " << &*pit << endl;
+ LYXERR(Debug::LATEX, "TeXEnvironment... " << &*pit);
BufferParams const & bparams = buf.params();
lyxrc.language_command_end,
"$$lang",
prev_par_language->babel()))
- << '\n';
+ // the '%' is necessary to prevent unwanted whitespace
+ << "%\n";
texrow.newline();
}
lyxrc.language_command_begin,
"$$lang",
par_language->babel()))
- << '\n';
+ // the '%' is necessary to prevent unwanted whitespace
+ << "%\n";
texrow.newline();
}
}
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();
texrow.newline();
}
- if (par != paragraphs.end()) {
- LYXERR(Debug::LATEX) << "TeXEnvironment...done " << &*par << endl;
- }
+ if (par != paragraphs.end())
+ LYXERR(Debug::LATEX, "TeXEnvironment...done " << &*par);
+
return par;
}
{
int lines = 0;
- InsetList::const_iterator it = par.insetlist.begin();
- InsetList::const_iterator end = par.insetlist.end();
+ InsetList::const_iterator it = par.insetList().begin();
+ InsetList::const_iterator end = par.insetList().end();
for (; it != end && number > 0 ; ++it) {
- if (it->inset->lyxCode() == Inset::OPTARG_CODE) {
+ if (it->inset->lyxCode() == OPTARG_CODE) {
InsetOptArg * ins =
static_cast<InsetOptArg *>(it->inset);
lines += ins->latexOptional(buf, os, runparams);
OutputParams const & runparams_in,
string const & everypar)
{
- LYXERR(Debug::LATEX) << "TeXOnePar... " << &*pit << " '"
- << everypar << "'" << endl;
+ LYXERR(Debug::LATEX, "TeXOnePar... " << &*pit << " '"
+ << everypar << "'");
BufferParams const & bparams = buf.params();
LayoutPtr style;
+ if (runparams_in.verbatim) {
+ int const dist = distance(paragraphs.begin(), pit);
+ Font const outerfont = outerFont(dist, paragraphs);
+
+ // No newline if only one paragraph in this lyxtext
+ if (dist > 0) {
+ os << '\n';
+ texrow.newline();
+ }
+
+ /*bool need_par = */ pit->latex(buf, bparams, outerfont,
+ os, texrow, runparams_in);
+
+ return ++pit;
+ }
+
// In an inset with unlimited length (all in one row),
// force layout to default
if (!pit->forceDefaultParagraphs())
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
Language const * const doc_language = bparams.language;
- // The language that was in effect when the environemnt this paragraph is
+ // 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) ?
os << from_ascii(subst(lyxrc.language_command_end,
"$$lang",
prev_language->babel()))
- << '\n';
+ // the '%' is necessary to prevent unwanted whitespace
+ << "%\n";
texrow.newline();
}
else
os << "\\L{";
}
- os << from_ascii(subst(
- lyxrc.language_command_begin,
- "$$lang",
- par_language->babel()))
- << '\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,
- *(runparams.encoding), *encoding);
- if (encoding->package() == Encoding::inputenc && enc_switch.first) {
- runparams.encoding = encoding;
- if (enc_switch.second > 0) {
- os << '\n';
+
+ // 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,
+ *encoding);
+ 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;
}
}
// In an inset with unlimited length (all in one row),
// don't allow any special options in the paragraph
+ bool const useSetSpace = bparams.getTextClass().provides("SetSpace");
if (!pit->forceDefaultParagraphs()) {
if (pit->params().startOfAppendix()) {
os << "\\appendix\n";
&& (pit == paragraphs.begin()
|| !boost::prior(pit)->hasSameLayout(*pit)))
{
- os << from_ascii(pit->params().spacing().writeEnvirBegin())
+ os << from_ascii(pit->params().spacing().writeEnvirBegin(useSetSpace))
<< '\n';
texrow.newline();
}
}
Font const outerfont =
- outerFont(std::distance(paragraphs.begin(), pit),
+ outerFont(distance(paragraphs.begin(), pit),
paragraphs);
// FIXME UNICODE
os << from_utf8(everypar);
- bool need_par = pit->simpleTeXOnePar(buf, bparams, outerfont,
+ bool need_par = pit->latex(buf, bparams, outerfont,
os, texrow, runparams);
// Make sure that \\par is done with the font of the last
bool is_command = style->isCommand();
- if (style->resfont.size() != font.size()
+ if (style->resfont.size() != font.fontInfo().size()
&& boost::next(pit) != paragraphs.end()
&& !is_command) {
if (!need_par)
os << '\n';
texrow.newline();
}
- os << from_ascii(pit->params().spacing().writeEnvirEnd());
+ os << from_ascii(pit->params().spacing().writeEnvirEnd(useSetSpace));
pending_newline = true;
}
}
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 (boost::next(pit) != paragraphs.end()) {
- LYXERR(Debug::LATEX) << "TeXOnePar...done " << &*boost::next(pit) << endl;
- }
+ if (boost::next(pit) != paragraphs.end())
+ LYXERR(Debug::LATEX, "TeXOnePar...done " << &*boost::next(pit));
return ++pit;
}
par = TeXOnePar(buf, paragraphs, par, os, texrow,
runparams, everypar);
}
- if (std::distance(lastpar, par) >= std::distance(lastpar, endpar))
+ if (distance(lastpar, par) >= distance(lastpar, endpar))
break;
}
// It might be that we only have a title in this document
}
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,
- Encoding const & newEnc)
+ OutputParams const & runparams, Encoding const & newEnc)
{
+ Encoding const oldEnc = *runparams.encoding;
+ bool moving_arg = runparams.moving_arg;
if ((bparams.inputenc != "auto" && bparams.inputenc != "default")
|| moving_arg)
return make_pair(false, 0);
|| newEnc.package() == Encoding::none)
return make_pair(false, 0);
- LYXERR(Debug::LATEX) << "Changing LaTeX encoding from "
- << oldEnc.name() << " to "
- << newEnc.name() << endl;
+ LYXERR(Debug::LATEX, "Changing LaTeX encoding from "
+ << oldEnc.name() << " to " << newEnc.name());
os << setEncoding(newEnc.iconvName());
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