#include "insets/InsetBibitem.h"
#include "insets/InsetArgument.h"
+#include "frontends/alert.h"
+
#include "support/lassert.h"
#include "support/convert.h"
#include "support/debug.h"
#include "support/lstrings.h"
#include "support/lyxalgo.h"
#include "support/textutils.h"
+#include "support/gettext.h"
#include <QThreadStorage>
#include <list>
+#include <stack>
using namespace std;
using namespace lyx::support;
struct OutputState
{
OutputState() : open_encoding_(none), cjk_inherited_(0),
- prev_env_language_(0), open_polyglossia_lang_("")
+ prev_env_language_(0), nest_level_(0)
{
}
OpenEncoding open_encoding_;
int cjk_inherited_;
Language const * prev_env_language_;
- string open_polyglossia_lang_;
+ int nest_level_;
+ stack<int> lang_switch_depth_; // Both are always empty when
+ stack<string> open_polyglossia_lang_; // not using polyglossia
};
}
+string const & openPolyglossiaLang(OutputState const * state)
+{
+ // Return a reference to the last active language opened with
+ // polyglossia. If none or when using babel, return a reference
+ // to an empty string.
+
+ static string const empty;
+
+ return state->open_polyglossia_lang_.empty()
+ ? empty
+ : state->open_polyglossia_lang_.top();
+}
+
+
+bool atSameLastLangSwitchDepth(OutputState const * state)
+{
+ // Return true if the actual nest level is the same at which the
+ // language was switched when using polyglossia. Instead, return
+ // always true when using babel.
+
+ return state->lang_switch_depth_.size() == 0
+ ? true
+ : abs(state->lang_switch_depth_.top()) == state->nest_level_;
+}
+
+
+bool isLocalSwitch(OutputState const * state)
+{
+ // Return true if the language was opened by the \text<lang> command.
+
+ return state->lang_switch_depth_.size()
+ && state->lang_switch_depth_.top() < 0;
+}
+
+
+bool langOpenedAtThisLevel(OutputState const * state)
+{
+ // Return true if the language was opened at the current nesting level.
+
+ return state->lang_switch_depth_.size()
+ && abs(state->lang_switch_depth_.top()) == state->nest_level_;
+}
+
+
string const getPolyglossiaEnvName(Language const * lang)
{
string result = lang->polyglossia();
string const lang_end_command = use_polyglossia ?
"\\end{$$lang}" : lyxrc.language_command_end;
+ // For polyglossia, switch language outside of environment, if possible.
if (par_lang != prev_par_lang) {
if (!lang_end_command.empty() &&
prev_par_lang != doc_lang &&
+ atSameLastLangSwitchDepth(state) &&
!prev_par_lang.empty()) {
os << from_ascii(subst(
lang_end_command,
prev_par_lang))
// the '%' is necessary to prevent unwanted whitespace
<< "%\n";
+ if (use_polyglossia)
+ popPolyglossiaLang();
}
+ // If no language was explicitly opened and we are using
+ // polyglossia, then the current polyglossia language is
+ // the document language.
+ string const & pol_lang = use_polyglossia
+ && state->lang_switch_depth_.size()
+ ? openPolyglossiaLang(state)
+ : doc_lang;
+
if ((lang_end_command.empty() ||
- par_lang != doc_lang) &&
+ par_lang != doc_lang ||
+ par_lang != pol_lang) &&
!par_lang.empty()) {
string bc = use_polyglossia ?
getPolyglossiaBegin(lang_begin_command, par_lang,
os << bc;
// the '%' is necessary to prevent unwanted whitespace
os << "%\n";
+ if (use_polyglossia)
+ pushPolyglossiaLang(par_lang);
}
}
}
if (style.isEnvironment()) {
- if (par_lang != doc_lang)
- state->open_polyglossia_lang_ = par_lang;
+ state->nest_level_ += 1;
os << "\\begin{" << from_ascii(style.latexname()) << '}';
if (!style.latexargs().empty()) {
OutputParams rp = runparams;
}
if (data.style->isEnvironment()) {
- os << breakln
- << "\\end{" << from_ascii(data.style->latexname()) << "}\n";
+ os << breakln;
+ // Close any polyglossia language opened at this nest level
+ if (runparams.use_polyglossia) {
+ while (langOpenedAtThisLevel(state)) {
+ if (isLocalSwitch(state)) {
+ os << "}";
+ } else {
+ os << "\\end{"
+ << openPolyglossiaLang(state)
+ << "}%\n";
+ }
+ popPolyglossiaLang();
+ }
+ }
+ state->nest_level_ -= 1;
+ os << "\\end{" << from_ascii(data.style->latexname()) << "}\n";
state->prev_env_language_ = data.par_language;
if (runparams.encoding != data.prev_encoding) {
runparams.encoding = data.prev_encoding;
} // namespace anon
+void pushPolyglossiaLang(string const & lang_name, bool localswitch)
+{
+ OutputState * state = getOutputState();
+
+ int nest_level = localswitch ? -state->nest_level_ : state->nest_level_;
+ state->lang_switch_depth_.push(nest_level);
+ state->open_polyglossia_lang_.push(lang_name);
+}
+
+
+void popPolyglossiaLang()
+{
+ OutputState * state = getOutputState();
+
+ state->lang_switch_depth_.pop();
+ state->open_polyglossia_lang_.pop();
+}
+
+
void latexArgInsets(Paragraph const & par, otexstream & os,
OutputParams const & runparams, Layout::LaTeXArgMap const & latexargs, string const & prefix)
{
string lang_command_termination = "%\n";
// In some insets (such as Arguments), we cannot use \selectlanguage
- bool const localswitch = text.inset().forceLocalFontSwitch();
+ bool const localswitch = text.inset().forceLocalFontSwitch()
+ || (use_polyglossia && text.inset().forcePlainLayout());
if (localswitch) {
lang_begin_command = use_polyglossia ?
"\\text$$lang$$opts{" : lyxrc.language_command_local;
{
if (!lang_end_command.empty() &&
prev_lang != outer_lang &&
- !prev_lang.empty())
+ !prev_lang.empty() &&
+ (!use_polyglossia || !style.isEnvironment()))
{
os << from_ascii(subst(lang_end_command,
"$$lang",
prev_lang))
<< lang_command_termination;
- if (prev_lang == state->open_polyglossia_lang_)
- state->open_polyglossia_lang_ = "";
+ if (use_polyglossia)
+ popPolyglossiaLang();
}
// We need to open a new language if we couldn't close the previous
// 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 ((lang_end_command.empty() || par_lang != outer_lang)
+ if ((lang_end_command.empty() || par_lang != outer_lang
+ || (!use_polyglossia
+ || (style.isEnvironment() && par_lang != prev_lang)))
&& !par_lang.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
}
// With CJK, the CJK tag has to be closed first (see below)
if (runparams.encoding->package() != Encoding::CJK
+ && par_lang != openPolyglossiaLang(state)
&& !par_lang.empty()) {
string bc = use_polyglossia ?
getPolyglossiaBegin(lang_begin_command, par_lang, par_language->polyglossiaOpts())
: subst(lang_begin_command, "$$lang", par_lang);
os << bc;
os << lang_command_termination;
+ if (use_polyglossia)
+ pushPolyglossiaLang(par_lang, localswitch);
}
}
}
}
// With CJK, the CJK tag had to be closed first (see above)
if (runparams.encoding->package() == Encoding::CJK
+ && par_lang != openPolyglossiaLang(state)
&& !par_lang.empty()) {
os << from_ascii(subst(
lang_begin_command,
"$$lang",
par_lang))
<< lang_command_termination;
+ if (use_polyglossia)
+ pushPolyglossiaLang(par_lang, localswitch);
}
runparams.encoding = encoding;
}
bool pending_newline = false;
bool unskip_newline = false;
+ bool close_lang_switch = false;
switch (style.latextype) {
case LATEX_ITEM_ENVIRONMENT:
case LATEX_LIST_ENVIRONMENT:
+ if ((nextpar && par_lang != nextpar_lang
+ && nextpar->getDepth() == par.getDepth())
+ || (atSameLastLangSwitchDepth(state) && nextpar
+ && nextpar->getDepth() < par.getDepth()))
+ close_lang_switch = use_polyglossia;
if (nextpar && par.params().depth() < nextpar->params().depth())
pending_newline = true;
break;
// if its the last paragraph of the current environment
// skip it otherwise fall through
if (nextpar
- && (nextpar->layout() != par.layout()
- || nextpar->params().depth() != par.params().depth()))
+ && ((nextpar->layout() != par.layout()
+ || nextpar->params().depth() != par.params().depth())
+ || (!use_polyglossia || par_lang != nextpar_lang)))
+ {
+ close_lang_switch = use_polyglossia;
break;
+ }
}
// fall through possible
|| (runparams.isLastPar && par_lang != outer_lang));
if (closing_rtl_ltr_environment
- || (runparams.isLastPar
- && par_lang != outer_lang)) {
+ || ((runparams.isLastPar || close_lang_switch)
+ && (par_lang != outer_lang || (use_polyglossia
+ && style.isEnvironment()
+ && par_lang != nextpar_lang)))) {
// Since \selectlanguage write the language to the aux file,
// we need to reset the language at the end of footnote or
// float.
- if (pending_newline)
+ if (pending_newline || close_lang_switch)
os << '\n';
// when the paragraph uses CJK, the language has to be closed earlier
string const current_lang = use_polyglossia
? getPolyglossiaEnvName(current_language)
: current_language->babel();
- if (!current_lang.empty()) {
+ if (!current_lang.empty()
+ && current_lang != openPolyglossiaLang(state)) {
string bc = use_polyglossia ?
getPolyglossiaBegin(lang_begin_command, current_lang,
current_language->polyglossiaOpts())
os << bc;
pending_newline = !localswitch;
unskip_newline = !localswitch;
+ if (use_polyglossia)
+ pushPolyglossiaLang(current_lang, localswitch);
}
} else if (!par_lang.empty()) {
// If we are in an environment, we have to close the "outer" language afterwards
- if (!style.isEnvironment() || state->open_polyglossia_lang_ != par_lang) {
+ string const & pol_lang = openPolyglossiaLang(state);
+ if (!style.isEnvironment()
+ || (close_lang_switch
+ && atSameLastLangSwitchDepth(state)
+ && par_lang != outer_lang
+ && (par_lang != pol_lang
+ || (pol_lang != outer_lang
+ && nextpar
+ && style != nextpar->layout())))
+ || (atSameLastLangSwitchDepth(state)
+ && state->lang_switch_depth_.size()
+ && pol_lang != par_lang))
+ {
+ if (use_polyglossia && !localswitch)
+ os << breakln;
os << from_ascii(subst(
lang_end_command,
"$$lang",
par_lang));
pending_newline = !localswitch;
unskip_newline = !localswitch;
+ if (use_polyglossia)
+ popPolyglossiaLang();
}
}
}
// prevent unwanted whitespace
os << '%';
if (!os.afterParbreak() && !last_was_separator)
- os << '\n';
+ os << breakln;
}
// if this is a CJK-paragraph and the next isn't, close CJK
{ os << "% LaTeX Output Error\n"; return; } );
BufferParams const & bparams = buf.params();
+ BufferParams const & mparams = buf.masterParams();
bool const maintext = text.isMainText();
bool const is_child = buf.masterBuffer() != &buf;
+ bool const multibib_child = maintext && is_child
+ && mparams.multibib == "child";
+
+ if (multibib_child && mparams.useBiblatex())
+ os << "\\newrefsection";
+ else if (multibib_child && mparams.useBibtopic()) {
+ os << "\\begin{btUnit}\n";
+ runparams.openbtUnit = true;
+ }
// Open a CJK environment at the beginning of the main buffer
// if the document's language is a CJK language
: subst(lang_begin_command, "$$lang", mainlang);
os << bc;
os << '\n';
+ if (runparams.use_polyglossia)
+ pushPolyglossiaLang(mainlang);
}
ParagraphList const & paragraphs = text.paragraphs();
bool already_title = false;
DocumentClass const & tclass = bparams.documentClass();
+ // Did we already warn about inTitle layout mixing? (we only warn once)
+ bool gave_layout_warning = false;
for (; pit < runparams.par_end; ++pit) {
lastpit = pit;
ParagraphList::const_iterator par = paragraphs.constIterator(pit);
if (layout.intitle) {
if (already_title) {
- LYXERR0("Error in latexParagraphs: You"
- " are using a layout (\"" << layout.name() << "\")"
- " intended for the title, after using"
- " non-title layouts.");
+ if (!gave_layout_warning) {
+ gave_layout_warning = true;
+ frontend::Alert::warning(_("Error in latexParagraphs"),
+ bformat(_("You are using at least one "
+ "layout (%1$s) intended for the title, "
+ "after using non-title layouts. This "
+ "could lead to missing or incorrect output."
+ ), layout.name()));
+ }
} else if (!was_title) {
was_title = true;
if (tclass.titletype() == TITLE_ENVIRONMENT) {
was_title = false;
}
+ if (layout.isCommand() && !layout.latexname().empty()
+ && layout.latexname() == bparams.multibib) {
+ if (runparams.openbtUnit)
+ os << "\\end{btUnit}\n";
+ if (!bparams.useBiblatex()) {
+ os << '\n' << "\\begin{btUnit}\n";
+ runparams.openbtUnit = true;
+ }
+ }
if (!layout.isEnvironment() && par->params().leftIndent().zero()) {
// This is a standard top level paragraph, TeX it and continue.
}
}
+ if (maintext && !is_child && runparams.openbtUnit)
+ os << "\\end{btUnit}\n";
+
// if "auto end" is switched off, explicitly close the language at the end
// but only if the last par is in a babel or polyglossia language
string const lang_end_command = runparams.use_polyglossia ?
"$$lang",
mainlang))
<< '\n';
- if (state->open_polyglossia_lang_ == mainlang)
- state->open_polyglossia_lang_ = "";
+ if (runparams.use_polyglossia)
+ popPolyglossiaLang();
}
// If the last paragraph is an environment, we'll have to close
state->open_encoding_ = none;
}
// Likewise for polyglossia
- if (maintext && !is_child && state->open_polyglossia_lang_ != "") {
+ string const & pol_lang = openPolyglossiaLang(state);
+ if (maintext && !is_child && !pol_lang.empty()) {
os << from_utf8(subst(lang_end_command,
"$$lang",
- state->open_polyglossia_lang_))
+ pol_lang))
<< '\n';
- state->open_polyglossia_lang_ = "";
+ if (runparams.use_polyglossia)
+ popPolyglossiaLang();
}
// reset inherited encoding
if (state->cjk_inherited_ == 0)
state->open_encoding_ = CJK;
}
+
+ if (multibib_child && mparams.useBibtopic()) {
+ os << "\\end{btUnit}\n";
+ runparams.openbtUnit = false;
+ }
}
projects / lyx.git / blobdiff