#include "BufferParams.h"
#include "debug.h"
#include "Encoding.h"
+#include "InsetList.h"
#include "Language.h"
+#include "Layout.h"
#include "LyXRC.h"
#include "OutputParams.h"
#include "Paragraph.h"
#include "support/lstrings.h"
+#include <boost/next_prior.hpp>
namespace lyx {
using std::endl;
using std::string;
+using std::pair;
+using std::make_pair;
namespace {
BufferParams const & bparams = buf.params();
- Layout_ptr const & style = pit->layout();
+ LayoutPtr const & style = pit->layout();
Language const * const par_language = pit->getParLanguage(bparams);
Language const * const doc_language = bparams.language;
texrow.newline();
}
- if (lyxrc.language_command_end.empty() ||
- par_language->babel() != doc_language->babel() &&
+ if ((lyxrc.language_command_end.empty() ||
+ par_language->babel() != doc_language->babel()) &&
!par_language->babel().empty()) {
os << from_ascii(subst(
lyxrc.language_command_begin,
os << '\n';
texrow.newline();
} else if (par->params().depth() > pit->params().depth()) {
- if (par->layout()->isParagraph()) {
+ if (par->layout()->isParagraph()) {
+ // Thinko!
+ // How to handle this? (Lgb)
+ //&& !suffixIs(os, "\n\n")
+ //) {
- // Thinko!
- // How to handle this? (Lgb)
- //&& !suffixIs(os, "\n\n")
- //) {
// There should be at least one '\n' already
// but we need there to be two for Standard
// paragraphs that are depth-increment'ed to be
texrow.newline();
}
- if (par != paragraphs.end())
+ if (par != paragraphs.end()) {
LYXERR(Debug::LATEX) << "TeXEnvironment...done " << &*par << endl;
+ }
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);
LYXERR(Debug::LATEX) << "TeXOnePar... " << &*pit << " '"
<< everypar << "'" << endl;
BufferParams const & bparams = buf.params();
- Layout_ptr style;
+ LayoutPtr style;
// In an inset with unlimited length (all in one row),
// force layout to default
OutputParams runparams = runparams_in;
runparams.moving_arg |= style->needprotect;
+ // This paragraph's language
Language const * const par_language = pit->getParLanguage(bparams);
+ // The document's language
Language const * const doc_language = bparams.language;
- Language const * const prev_par_language =
- (pit != paragraphs.begin())
- ? boost::prior(pit)->getParLanguage(bparams)
- : doc_language;
-
- if (par_language->babel() != prev_par_language->babel()
+ // The language that was in effect when the environemnt this paragraph is
+ // inside of was opened
+ Language const * const outer_language =
+ (runparams.local_font != 0) ?
+ runparams.local_font->language() : doc_language;
+ // The previous language that was in effect is either the language of
+ // the previous paragraph, if there is one, or else the outer language
+ // if there is no previous paragraph
+ Language const * const prev_language =
+ (pit != paragraphs.begin()) ?
+ boost::prior(pit)->getParLanguage(bparams) : outer_language;
+
+ if (par_language->babel() != prev_language->babel()
// check if we already put language command in TeXEnvironment()
&& !(style->isEnvironment()
&& (pit == paragraphs.begin() ||
|| boost::prior(pit)->getDepth() < pit->getDepth())))
{
if (!lyxrc.language_command_end.empty() &&
- prev_par_language->babel() != doc_language->babel() &&
- !prev_par_language->babel().empty())
+ prev_language->babel() != outer_language->babel() &&
+ !prev_language->babel().empty())
{
os << from_ascii(subst(lyxrc.language_command_end,
"$$lang",
- prev_par_language->babel()))
+ prev_language->babel()))
<< '\n';
texrow.newline();
}
- if (lyxrc.language_command_end.empty() ||
- par_language->babel() != doc_language->babel() &&
- !par_language->babel().empty())
- {
+ // We need to open a new language if we couldn't close the previous
+ // one (because there's no language_command_end); and even if we closed
+ // the previous one, if the current language is different than the
+ // outer_language (which is currently in effect once the previous one
+ // is closed).
+ if ((lyxrc.language_command_end.empty() ||
+ par_language->babel() != outer_language->babel()) &&
+ !par_language->babel().empty()) {
+ // If we're inside an inset, and that inset is within an \L or \R
+ // (or equivalents), then within the inset, too, any opposite
+ // language paragraph should appear within an \L or \R (in addition
+ // to, outside of, the normal language switch commands).
+ // This behavior is not correct for ArabTeX, though.
+ if ( // not for ArabTeX
+ (par_language->lang() != "arabic_arabtex" &&
+ outer_language->lang() != "arabic_arabtex") &&
+ // are we in an inset?
+ runparams.local_font != 0 &&
+ // is the inset within an \L or \R?
+ //
+ // FIXME: currently, we don't check this; this means that
+ // we'll have unnnecessary \L and \R commands, but that
+ // doesn't seem to hurt (though latex will complain)
+ //
+ // is this paragraph in the opposite direction?
+ runparams.local_font->isRightToLeft() !=
+ par_language->rightToLeft()
+ ) {
+ // FIXME: I don't have a working copy of the Arabi package, so
+ // I'm not sure if the farsi and arabic_arabi stuff is correct
+ // or not...
+ if (par_language->lang() == "farsi")
+ os << "\\textFR{";
+ else if (outer_language->lang() == "farsi")
+ os << "\\textLR{";
+ else if (par_language->lang() == "arabic_arabi")
+ os << "\\textAR{";
+ else if (outer_language->lang() == "arabic_arabi")
+ os << "\\textLR{";
+ // remaining RTL languages currently is hebrew
+ else if (par_language->rightToLeft())
+ os << "\\R{";
+ else
+ os << "\\L{";
+ }
os << from_ascii(subst(
lyxrc.language_command_begin,
"$$lang",
}
}
- // Switch file encoding if necessary
+ // Switch file encoding if necessary; no need to do this for "default"
+ // 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) {
// Look ahead for future encoding changes.
// encoding to that required by the language of c.
Encoding const * const encoding =
pit->getFontSettings(bparams, i).language()->encoding();
- if (encoding->package() == Encoding::inputenc &&
- switchEncoding(os, bparams, false,
- *(runparams.encoding), *encoding) > 0) {
+ pair<bool, int> enc_switch = switchEncoding(os, bparams, false,
+ *(runparams.encoding), *encoding);
+ if (encoding->package() == Encoding::inputenc && enc_switch.first) {
runparams.encoding = encoding;
- os << '\n';
- texrow.newline();
+ if (enc_switch.second > 0) {
+ os << '\n';
+ texrow.newline();
+ }
}
break;
}
}
}
- if (boost::next(pit) == paragraphs.end()
- && par_language->babel() != doc_language->babel()) {
+ // Closing the language is needed for the last paragraph; it is also
+ // needed if we're within an \L or \R that we may have opened above (not
+ // necessarily in this paragraph) and are about to close.
+ bool closing_rtl_ltr_environment =
+ // not for ArabTeX
+ (par_language->lang() != "arabic_arabtex" &&
+ outer_language->lang() != "arabic_arabtex") &&
+ // have we opened and \L or \R environment?
+ runparams.local_font != 0 &&
+ runparams.local_font->isRightToLeft() != par_language->rightToLeft() &&
+ // are we about to close the language?
+ ((boost::next(pit) != paragraphs.end() &&
+ par_language->babel() !=
+ (boost::next(pit)->getParLanguage(bparams))->babel()) ||
+ (boost::next(pit) == paragraphs.end() &&
+ par_language->babel() != outer_language->babel()));
+
+ if (closing_rtl_ltr_environment || (boost::next(pit) == paragraphs.end()
+ && par_language->babel() != outer_language->babel())) {
// Since \selectlanguage write the language to the aux file,
// we need to reset the language at the end of footnote or
// float.
texrow.newline();
}
if (lyxrc.language_command_end.empty()) {
- if (!doc_language->babel().empty()) {
+ if (!prev_language->babel().empty()) {
os << from_ascii(subst(
lyxrc.language_command_begin,
"$$lang",
- doc_language->babel()));
+ prev_language->babel()));
pending_newline = true;
}
} else if (!par_language->babel().empty()) {
pending_newline = true;
}
}
+ if (closing_rtl_ltr_environment)
+ os << "}";
if (pending_newline) {
os << '\n';
texrow.newline();
}
- runparams_in.encoding = runparams.encoding;
+
+ // 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
+ // switch command is needed, since latex will automatically revert to it
+ // when this inset closes.
+ // This switch is only necessary if we're using "auto" or "default"
+ // encoding.
+ if (boost::next(pit) == paragraphs.end() && runparams_in.local_font != 0) {
+ runparams_in.encoding = runparams_in.local_font->language()->encoding();
+ if (bparams.inputenc == "auto" || bparams.inputenc == "default")
+ os << setEncoding(runparams_in.encoding->iconvName());
+
+ }
+ // Otherwise, the current encoding should be set for the next paragraph.
+ else
+ runparams_in.encoding = runparams.encoding;
+
// we don't need it for the last paragraph!!!
// Note from JMarc: we will re-add a \n explicitely in
texrow.newline();
}
- if (boost::next(pit) != paragraphs.end())
+ if (boost::next(pit) != paragraphs.end()) {
LYXERR(Debug::LATEX) << "TeXOnePar...done " << &*boost::next(pit) << endl;
+ }
return ++pit;
}
// any environment other than the default layout of the
// text class to be valid!
if (!par->forceDefaultParagraphs()) {
- Layout_ptr const & layout = par->layout();
+ LayoutPtr const & layout = par->layout();
if (layout->intitle) {
if (already_title) {
par = TeXOnePar(buf, paragraphs, par, os, texrow,
runparams, everypar);
} else if (layout->isEnvironment() ||
- !par->params().leftIndent().zero()) {
+ !par->params().leftIndent().zero()) {
par = TeXEnvironment(buf, paragraphs, par, os,
texrow, runparams);
} else {
}
-int switchEncoding(odocstream & os, BufferParams const & bparams,
- bool moving_arg, Encoding const & oldEnc,
- Encoding const & newEnc)
+pair<bool, int> switchEncoding(odocstream & os, BufferParams const & bparams,
+ bool moving_arg, Encoding const & oldEnc,
+ Encoding const & newEnc)
{
+ if ((bparams.inputenc != "auto" && bparams.inputenc != "default")
+ || moving_arg)
+ return make_pair(false, 0);
+
+ // Do nothing if the encoding is unchanged.
+ if (oldEnc.name() == newEnc.name())
+ 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.
// This does of course only work in special cases (e.g. switch from
- // tis620-0 to latin1, but the text in latin1 contains ASCII only,
+ // tis620-0 to latin1, but the text in latin1 contains ASCII only),
// but it is the best we can do
- if (((bparams.inputenc == "auto" && !moving_arg) ||
- bparams.inputenc == "default") &&
- oldEnc.name() != newEnc.name() &&
- oldEnc.package() != Encoding::none &&
- newEnc.package() != Encoding::none) {
- LYXERR(Debug::LATEX) << "Changing LaTeX encoding from "
- << oldEnc.name() << " to "
- << newEnc.name() << endl;
- os << setEncoding(newEnc.iconvName());
- if (bparams.inputenc != "default") {
- docstring const inputenc(from_ascii(newEnc.latexName()));
- switch (newEnc.package()) {
- case Encoding::none:
- break;
- case Encoding::inputenc: {
- int count = inputenc.length();
- if (oldEnc.package() == Encoding::CJK) {
- os << "\\end{CJK}";
- count += 9;
- }
- os << "\\inputencoding{" << inputenc << '}';
- return count + 16;
- }
- case Encoding::CJK: {
- int count = inputenc.length();
- if (oldEnc.package() == Encoding::CJK) {
- os << "\\end{CJK}";
- count += 9;
- }
- os << "\\begin{CJK}{" << inputenc << "}{}";
- return count + 15;
- }
+ if (oldEnc.package() == Encoding::none
+ || newEnc.package() == Encoding::none)
+ return make_pair(false, 0);
+
+ LYXERR(Debug::LATEX) << "Changing LaTeX encoding from "
+ << oldEnc.name() << " to "
+ << newEnc.name() << endl;
+ os << setEncoding(newEnc.iconvName());
+ if (bparams.inputenc == "default")
+ return make_pair(true, 0);
+
+ docstring const inputenc(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) {
+ os << "\\end{CJK}";
+ count += 9;
+ }
+ os << "\\inputencoding{" << inputenc << '}';
+ return make_pair(true, count + 16);
+ }
+ case Encoding::CJK: {
+ int count = inputenc.length();
+ if (oldEnc.package() == Encoding::CJK) {
+ os << "\\end{CJK}";
+ count += 9;
}
+ os << "\\begin{CJK}{" << inputenc << "}{}";
+ return make_pair(true, count + 15);
}
}
- return 0;
+ // Dead code to avoid a warning:
+ return make_pair(true, 0);
}
} // namespace lyx