#include "LyXRC.h"
#include "OutputParams.h"
#include "Paragraph.h"
-#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
#include "TextClass.h"
#include "TexRow.h"
static int open_encoding_ = none;
static int cjk_inherited_ = 0;
+Language const * prev_env_language_ = 0;
ParagraphList::const_iterator
ParagraphList const & paragraphs = text.paragraphs();
+ bool const force_plain_layout = text.inset().forcePlainLayout();
while (par != paragraphs.end() &&
par->params().depth() == pit->params().depth()) {
// FIXME This test should not be necessary.
// We should perhaps issue an error if it is.
- Layout const & style = par->forcePlainLayout() ?
- buf.params().documentClass().plainLayout() : par->layout();
+ Layout const & style = force_plain_layout
+ ? buf.params().documentClass().plainLayout() : par->layout();
if (style.isEnvironment()) {
par = TeXEnvironment(buf, text, par,
os, texrow, runparams);
}
-Language const *
-priorLanguage(ParagraphList::const_iterator const pit,
- ParagraphList::const_iterator const priorpit,
- ParagraphList::const_iterator const pars_begin,
- BufferParams const & bparams)
-{
- ParagraphList::const_iterator outpit = priorpit;
- ParagraphList::const_iterator refpit = priorpit;
-
- // We go back until the depth kept increasing or the current layout
- // matches the reference one. When the depth decreases, we should stop
- // only if we started from inside the enclosing environment, otherwise
- // we should continue to go back.
-
- bool topped = false;
- depth_type const refdepth =
- priorpit->getDepth() ? priorpit->getDepth() - 1 : 0;
- while (outpit != pars_begin
- && (outpit->hasSameLayout(*refpit)
- || outpit->getDepth() > pit->getDepth())) {
- outpit = boost::prior(outpit);
- if (outpit->getDepth() == pit->getDepth()
- && outpit->layout() == pit->layout()
- && (priorpit->getAlign() != priorpit->layout().align
- || priorpit->getDepth() > pit->getDepth())) {
- // After skipping either a nested or non-default
- // aligned environment, we ended at an environment with
- // same layout and nesting depth as the current one.
- break;
- }
- if (outpit->getDepth() == refdepth) {
- if (outpit->getDepth() >= pit->getDepth()
- && (priorpit->getDepth() > pit->getDepth()
- || outpit->layout() == refpit->layout())) {
- // The prior environment was nested in
- // another one, or was enclosing some other
- // one, or we are still in it. In any case,
- // we still have to go back.
- refpit = outpit;
- } else {
- topped = true;
- break;
- }
- }
- }
- ParagraphList::const_iterator const inpit =
- topped ? refpit : boost::next(outpit);
- // Check if we stopped at the first paragraph,
- // but we should still go back.
- topped = !topped && (outpit == pars_begin
- && (outpit->hasSameLayout(*refpit)
- || outpit->getDepth() > pit->getDepth())
- && !(outpit->getDepth() == pit->getDepth()
- && outpit->layout() == pit->layout()
- && (priorpit->getAlign() != priorpit->layout().align
- || priorpit->getDepth() > pit->getDepth())));
- Language const * const outenv_language =
- topped ? bparams.language
- : outpit->getParLanguage(bparams);
- Language const * const inenv_language =
- topped ? outpit->getParLanguage(bparams)
- : inpit->getParLanguage(bparams);
- if (outenv_language->babel() != inenv_language->babel())
- return inenv_language;
- return outenv_language;
-}
-
-
ParagraphList::const_iterator
TeXEnvironment(Buffer const & buf,
Text const & text,
// FIXME This test should not be necessary.
// We should perhaps issue an error if it is.
- Layout const & style = pit->forcePlainLayout() ?
+ Layout const & style = text.inset().forcePlainLayout() ?
bparams.documentClass().plainLayout() : pit->layout();
ParagraphList const & paragraphs = text.paragraphs();
- ParagraphList::const_iterator const priorpit =
+ ParagraphList::const_iterator const priorpit =
pit == paragraphs.begin() ? pit : boost::prior(pit);
+ bool const use_prev_env_language = prev_env_language_ != 0
+ && priorpit->layout().isEnvironment()
+ && (priorpit->getDepth() > pit->getDepth()
+ || (priorpit->getDepth() == pit->getDepth()
+ && priorpit->layout() != pit->layout()));
+
+ Encoding const * const prev_encoding = runparams.encoding;
Language const * const par_language = pit->getParLanguage(bparams);
Language const * const doc_language = bparams.language;
- Language const * const prior_language =
- (pit != paragraphs.begin() && priorpit != paragraphs.begin()
- && priorpit->getDepth() >= pit->getDepth()
- && !priorpit->hasSameLayout(*pit)
- && !priorpit->layout().isParagraph())
- ? priorLanguage(pit, priorpit, paragraphs.begin(), bparams)
- : priorpit->getParLanguage(bparams);
Language const * const prev_par_language =
- (pit != paragraphs.begin()) ? prior_language : doc_language;
-
+ (pit != paragraphs.begin())
+ ? (use_prev_env_language ? prev_env_language_
+ : priorpit->getParLanguage(bparams))
+ : doc_language;
if (par_language->babel() != prev_par_language->babel()) {
if (!lyxrc.language_command_end.empty() &&
if (style.isEnvironment()) {
os << "\\end{" << from_ascii(style.latexname()) << "}\n";
texrow.newline();
+ prev_env_language_ = par_language;
+ if (runparams.encoding != prev_encoding) {
+ runparams.encoding = prev_encoding;
+ if (!bparams.useXetex)
+ os << setEncoding(prev_encoding->iconvName());
+ }
}
if (leftindent_open) {
os << "\\end{LyXParagraphLeftIndent}\n";
texrow.newline();
+ prev_env_language_ = par_language;
+ if (runparams.encoding != prev_encoding) {
+ runparams.encoding = prev_encoding;
+ if (!bparams.useXetex)
+ os << setEncoding(prev_encoding->iconvName());
+ }
}
if (par != paragraphs.end())
if (runparams.verbatim) {
int const dist = distance(paragraphs.begin(), pit);
- Font const outerfont = outerFont(dist, paragraphs);
+ Font const outerfont = text.outerFont(dist);
// No newline if only one paragraph in this lyxtext
if (dist > 0) {
// FIXME This check should not really be needed.
// Perhaps we should issue an error if it is.
- Layout const style = pit->forcePlainLayout() ?
+ Layout const style = text.inset().forcePlainLayout() ?
bparams.documentClass().plainLayout() : pit->layout();
runparams.moving_arg |= style.needprotect;
- bool const maintext = text.isMainText(buf);
+ 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.
if (pit == paragraphs.begin() && !maintext
(runparams.local_font != 0) ?
runparams.local_font->language() : doc_language;
- // The language that was in effect before the current paragraph.
- Language const * const prior_language =
- (pit != paragraphs.begin() && priorpit != paragraphs.begin()
- && priorpit->getDepth() >= pit->getDepth()
- && !priorpit->hasSameLayout(*pit)
- && !priorpit->layout().isParagraph())
- ? priorLanguage(pit, priorpit, paragraphs.begin(), bparams)
- : priorpit->getParLanguage(bparams);
-
// The previous language that was in effect is the language of the
// previous paragraph, unless the previous paragraph is inside an
- // environment and the current one is nested in it but with a lower
- // depth. If there is no previous paragraph, the previous language
- // is the outer language.
+ // 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
+ && priorpit->layout().isEnvironment()
+ && (priorpit->getDepth() > pit->getDepth()
+ || (priorpit->getDepth() == pit->getDepth()
+ && priorpit->layout() != pit->layout()));
Language const * const prev_language =
- (pit != paragraphs.begin()) ? prior_language : outer_language;
+ (pit != paragraphs.begin())
+ ? (use_prev_env_language ? prev_env_language_
+ : priorpit->getParLanguage(bparams))
+ : outer_language;
if (par_language->babel() != prev_language->babel()
// check if we already put language command in TeXEnvironment()
}
}
+ Encoding const * const prev_encoding = runparams.encoding;
+
bool const useSetSpace = bparams.documentClass().provides("SetSpace");
if (pit->allowParagraphCustomization()) {
if (pit->params().startOfAppendix()) {
break;
}
- Font const outerfont = outerFont(distance(paragraphs.begin(), pit),
- paragraphs);
+ Font const outerfont = text.outerFont(distance(paragraphs.begin(), pit));
// FIXME UNICODE
os << from_utf8(everypar);
os << "\\" << from_ascii(font.latexSize()) << " \\par}";
} else if (need_par) {
os << "\\par}";
- } else if (is_command)
+ } else if (is_command) {
os << '}';
+ if (runparams.encoding != prev_encoding) {
+ runparams.encoding = prev_encoding;
+ if (!bparams.useXetex)
+ os << setEncoding(prev_encoding->iconvName());
+ }
+ }
bool pending_newline = false;
switch (style.latextype) {
// 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()) {
+ // If this is a child, we should restore the
+ // master language after the last paragraph.
+ Language const * const current_language =
+ (nextpit == paragraphs.end()
+ && runparams.master_language)
+ ? runparams.master_language
+ : outer_language;
+ if (!current_language->babel().empty()) {
os << from_ascii(subst(
lyxrc.language_command_begin,
"$$lang",
- prev_language->babel()));
+ current_language->babel()));
pending_newline = true;
}
} else if (!par_language->babel().empty()) {
const_cast<OutputParams&>(runparams).par_end = 0;
}
- bool const maintext = text.isMainText(buf);
+ bool const maintext = text.isMainText();
bool const is_child = buf.masterBuffer() != &buf;
// Open a CJK environment at the beginning of the main buffer
lastpar = par;
// FIXME This check should not be needed. We should
// perhaps issue an error if it is.
- Layout const & layout = par->forcePlainLayout() ?
+ Layout const & layout = text.inset().forcePlainLayout() ?
tclass.plainLayout() : par->layout();
if (layout.intitle) {
projects / lyx.git / blobdiff