/// Output the surrogate pair formed by \p c and \p next to \p os.
/// \return the number of characters written.
- int latexSurrogatePair(otexstream & os, char_type c, char_type next,
+ int latexSurrogatePair(BufferParams const &, otexstream & os,
+ char_type c, char_type next,
OutputParams const &);
/// Output a space in appropriate formatting (or a surrogate pair
/// if the next character is a combining character).
/// \return whether a surrogate pair was output.
- bool simpleTeXBlanks(OutputParams const &,
+ bool simpleTeXBlanks(BufferParams const &,
+ OutputParams const &,
otexstream &,
pos_type i,
unsigned int & column,
/// Output consecutive unicode chars, belonging to the same script as
/// specified by the latex macro \p ltx, to \p os starting from \p i.
/// \return the number of characters written.
- int writeScriptChars(OutputParams const &, otexstream & os,
+ int writeScriptChars(BufferParams const &, OutputParams const &,
+ otexstream & os,
docstring const & ltx,
Change const &, Encoding const &,
std::string const, pos_type & i);
}
-int Paragraph::Private::latexSurrogatePair(otexstream & os, char_type c,
- char_type next, OutputParams const & runparams)
+int Paragraph::Private::latexSurrogatePair(BufferParams const & bparams,
+ otexstream & os, char_type c, char_type next,
+ OutputParams const & runparams)
{
// Writing next here may circumvent a possible font change between
// c and next. Since next is only output if it forms a surrogate pair
int length = brace2;
string fontenc;
if (runparams.local_font)
- fontenc = runparams.local_font->language()->fontenc();
+ fontenc = runparams.local_font->language()->fontenc(bparams);
else
- fontenc = runparams.main_fontenc;
+ fontenc = bparams.language->fontenc(bparams);
docstring scriptmacro;
docstring cb;
if (script == "textgreek" || script == "textcyrillic") {
}
-bool Paragraph::Private::simpleTeXBlanks(OutputParams const & runparams,
+bool Paragraph::Private::simpleTeXBlanks(BufferParams const & bparams,
+ OutputParams const & runparams,
otexstream & os,
pos_type i,
unsigned int & column,
char_type next = text_[i + 1];
if (Encodings::isCombiningChar(next)) {
// This space has an accent, so we must always output it.
- column += latexSurrogatePair(os, ' ', next, runparams) - 1;
+ column += latexSurrogatePair(bparams, os, ' ', next, runparams) - 1;
return true;
}
}
}
-int Paragraph::Private::writeScriptChars(OutputParams const & runparams,
+int Paragraph::Private::writeScriptChars(BufferParams const & bparams,
+ OutputParams const & runparams,
otexstream & os,
docstring const & ltx,
Change const & runningChange,
if (i + 2 < size) {
next_next = text_[i + 2];
if (Encodings::isCombiningChar(next_next)) {
- length += latexSurrogatePair(os, next, next_next, runparams) - 1;
+ length += latexSurrogatePair(bparams, os, next, next_next, runparams) - 1;
i += 2;
continue;
}
pos_type end_pos,
unsigned int & column)
{
- // With polyglossia, brackets and stuff need not be reversed
- // in RTL scripts (see bug #8251)
- char_type const c = (runparams.use_polyglossia) ?
- owner_->getUChar(bparams, i) : text_[i];
+ char_type const c = owner_->getUChar(bparams, runparams, i);
if (style.pass_thru || runparams.pass_thru
|| contains(style.pass_thru_chars, c)
if (i + 1 < int(text_.size())) {
next = text_[i + 1];
if (Encodings::isCombiningChar(next)) {
- column += latexSurrogatePair(os, c, next, runparams) - 1;
+ column += latexSurrogatePair(bparams, os, c, next, runparams) - 1;
++i;
break;
}
}
}
string fontenc;
- if (running_font.language()->lang() == bparams.language->lang())
- fontenc = runparams.main_fontenc;
- else
- fontenc = running_font.language()->fontenc();
+ fontenc = running_font.language()->fontenc(bparams);
// "Script chars" need to embraced in \textcyrillic and \textgreek notwithstanding
// whether they are encodable or not (it only depends on the font encoding)
if (!runparams.isFullUnicode() && Encodings::isKnownScriptChar(c, script)) {
docstring ltx = latex.first;
if (!prefixIs(ltx, wrapper))
ltx = wrapper + latex.first + from_ascii("}");
- column += writeScriptChars(runparams, os, ltx, running_change,
+ column += writeScriptChars(bparams, runparams, os, ltx, running_change,
encoding, fontenc, i) - 1;
} else if (latex.second
&& ((!prefixIs(nextlatex, '\\')
// then the contents
BufferParams const bp = features.runparams().is_child
? features.buffer().masterParams() : features.buffer().params();
- string bscript = "textbaltic";
for (pos_type i = 0; i < int(text_.size()) ; ++i) {
char_type c = text_[i];
+ CharInfo const & ci = Encodings::unicodeCharInfo(c);
if (c == 0x0022) {
if (features.runparams().isFullUnicode() && bp.useNonTeXFonts)
features.require("textquotedblp");
else if (bp.main_font_encoding() != "T1"
|| ((&owner_->getFontSettings(bp, i))->language()->internalFontEncoding()))
features.require("textquotedbl");
- } else if (Encodings::isKnownScriptChar(c, bscript)){
- string fontenc = (&owner_->getFontSettings(bp, i))->language()->fontenc();
+ } else if (ci.textfeature() && contains(ci.textpreamble(), '=')) {
+ // features that depend on the font or input encoding
+ string feats = ci.textpreamble();
+ string fontenc = (&owner_->getFontSettings(bp, i))->language()->fontenc(bp);
if (fontenc.empty())
fontenc = features.runparams().main_fontenc;
- if (Encodings::needsScriptWrapper("textbaltic", fontenc))
- features.require("textbalticdefs");
+ while (!feats.empty()) {
+ string feat;
+ feats = split(feats, feat, ',');
+ if (contains(feat, "!=")) {
+ // a feature that is required except for the spcified
+ // font or input encodings
+ string realfeature;
+ string const contexts = ltrim(split(feat, realfeature, '!'), "=");
+ // multiple encodings are separated by semicolon
+ vector<string> context = getVectorFromString(contexts, ";");
+ // require feature if the context matches neither current font
+ // nor input encoding
+ if (std::find(context.begin(), context.end(), fontenc) == context.end()
+ && std::find(context.begin(), context.end(),
+ features.runparams().encoding->name()) == context.end())
+ features.require(realfeature);
+ } else if (contains(feat, '=')) {
+ // a feature that is required only for the spcified
+ // font or input encodings
+ string realfeature;
+ string const contexts = split(feat, realfeature, '=');
+ // multiple encodings are separated by semicolon
+ vector<string> context = getVectorFromString(contexts, ";");
+ // require feature if the context matches either current font
+ // or input encoding
+ if (std::find(context.begin(), context.end(), fontenc) != context.end()
+ || std::find(context.begin(), context.end(),
+ features.runparams().encoding->name()) != context.end())
+ features.require(realfeature);
+ }
+ }
} else if (!bp.use_dash_ligatures
&& (c == 0x2013 || c == 0x2014)
&& bp.useNonTeXFonts
void Paragraph::validate(LaTeXFeatures & features) const
{
d->validate(features);
- if (needsCProtection())
+ bool fragile = features.runparams().moving_arg;
+ fragile |= layout().needprotect;
+ if (needsCProtection(fragile))
features.require("cprotect");
}
}
-char_type Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
+char_type Paragraph::getUChar(BufferParams const & bparams,
+ OutputParams const & rp,
+ pos_type pos) const
{
char_type c = d->text_[pos];
+
+ // Return unchanged character in LTR languages.
if (!getFontSettings(bparams, pos).isRightToLeft())
return c;
- // FIXME: The arabic special casing is due to the difference of arabic
- // round brackets input introduced in r18599. Check if this should be
- // unified with Hebrew or at least if all bracket types should be
- // handled the same (file format change in either case).
+ // FIXME This is a complete mess due to all the language-specific
+ // special cases. We need to unify this eventually, but this
+ // requires a file format change and some thought.
+ // We also need to unify the input of parentheses in different RTL
+ // languages. Currently, some have their own methods (Arabic:
+ // 18599/lyxsvn, Hebrew: e5f42f67d/lyxgit), some don't (Urdu, Syriac).
+ // Also note that the representation in the LyX file is probably wrong
+ // (see FIXME in TextMetrics::breakRow).
+ // Most likely, we should simply rely on Qt's unicode handling here.
string const & lang = getFontSettings(bparams, pos).language()->lang();
- bool const arabic = lang == "arabic_arabtex" || lang == "arabic_arabi"
- || lang == "farsi";
+
+ // With polyglossia, brackets and stuff need not be reversed in RTL scripts
+ // FIXME: The special casing for Hebrew parens is due to the special
+ // handling on input (for Hebrew in e5f42f67d/lyxgit); see #8251.
char_type uc = c;
+ if (rp.use_polyglossia) {
+ switch (c) {
+ case '(':
+ if (lang == "hebrew")
+ uc = ')';
+ break;
+ case ')':
+ if (lang == "hebrew")
+ uc = '(';
+ break;
+ }
+ return uc;
+ }
+
+ // In the following languages, brackets don't need to be reversed.
+ // Furthermore, in arabic_arabi, they are transformed to Arabic
+ // Ornate Parentheses (dunno if this is really wanted)
+ bool const reversebrackets = lang != "arabic_arabtex"
+ && lang != "arabic_arabi"
+ && lang != "farsi";
+
switch (c) {
- case '(':
- uc = arabic ? c : ')';
- break;
- case ')':
- uc = arabic ? c : '(';
- break;
case '[':
- uc = ']';
+ if (reversebrackets)
+ uc = ']';
break;
case ']':
- uc = '[';
+ if (reversebrackets)
+ uc = '[';
break;
case '{':
uc = '}';
case LYX_ALIGN_DECIMAL:
break;
case LYX_ALIGN_LEFT: {
- if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+ if (!owner_->getParLanguage(bparams)->rightToLeft())
corrected_env(os, begin_tag, "flushleft", code, lastpar, column);
else
corrected_env(os, begin_tag, "flushright", code, lastpar, column);
break;
} case LYX_ALIGN_RIGHT: {
- if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+ if (!owner_->getParLanguage(bparams)->rightToLeft())
corrected_env(os, begin_tag, "flushright", code, lastpar, column);
else
corrected_env(os, begin_tag, "flushleft", code, lastpar, column);
case LYX_ALIGN_DECIMAL:
break;
case LYX_ALIGN_LEFT: {
- if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+ if (!owner_->getParLanguage(bparams)->rightToLeft())
output = corrected_env(os, end_tag, "flushleft", code, lastpar, col);
else
output = corrected_env(os, end_tag, "flushright", code, lastpar, col);
break;
} case LYX_ALIGN_RIGHT: {
- if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+ if (!owner_->getParLanguage(bparams)->rightToLeft())
output = corrected_env(os, end_tag, "flushright", code, lastpar, col);
else
output = corrected_env(os, end_tag, "flushleft", code, lastpar, col);
// latexSpecialChar ignores spaces if
// style.pass_thru is false.
if (i != body_pos - 1) {
- if (d->simpleTeXBlanks(runparams, os,
+ if (d->simpleTeXBlanks(bparams, runparams, os,
i, column, current_font, style)) {
// A surrogate pair was output. We
// must not call latexSpecialChar
retval += inset->xhtml(xs, np);
}
} else {
- char_type c = getUChar(buf.masterBuffer()->params(), i);
+ char_type c = getUChar(buf.masterBuffer()->params(),
+ runparams, i);
xs << c;
}
font_old = font.fontInfo();
}
-bool Paragraph::needsCProtection() const
+bool Paragraph::needsCProtection(bool const fragile) const
{
- // first check the layout of the paragraph
- if (layout().needcprotect) {
+ // first check the layout of the paragraph, but only in insets
+ InsetText const * textinset = inInset().asInsetText();
+ bool const maintext = textinset
+ ? textinset->text().isMainText()
+ : false;
+
+ if (!maintext && layout().needcprotect) {
// Environments need cprotection regardless the content
if (layout().latextype == LATEX_ENVIRONMENT)
return true;
// now check whether we have insets that need cprotection
pos_type size = d->text_.size();
for (pos_type i = 0; i < size; ++i)
- if (isInset(i) && getInset(i)->needsCProtection())
+ if (isInset(i) && getInset(i)->needsCProtection(maintext, fragile))
return true;
return false;
docstring word = asString(from, to, AS_STR_INSETS | AS_STR_SKIPDELETE);
Language * lang = d->getSpellLanguage(from);
+ if (getFontSettings(d->inset_owner_->buffer().params(), from).fontInfo().nospellcheck() == FONT_ON)
+ return result;
+
wl = WordLangTuple(word, lang);
if (word.empty())
projects / lyx.git / blobdiff