/// 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(otexstream & os, docstring const & ltx,
- Change const &, Encoding const &, pos_type & i);
+ int writeScriptChars(BufferParams const &, OutputParams const &,
+ otexstream & os,
+ docstring const & ltx,
+ Change const &, Encoding const &,
+ std::string const, pos_type & i);
/// This could go to ParagraphParameters if we want to.
int startTeXParParams(BufferParams const &, otexstream &,
}
-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
latex1 = from_ascii(tipashortcut);
}
}
- docstring const latex2 = encoding.latexChar(c).first;
+ docstring latex2 = encoding.latexChar(c).first;
+
if (docstring(1, next) == latex1) {
- // the encoding supports the combination
+ // The encoding supports the combination:
+ // output as is (combining char after base char).
os << latex2 << latex1;
return latex1.length() + latex2.length();
- } else if (runparams.local_font &&
- runparams.local_font->language()->lang() == "polutonikogreek") {
- // polutonikogreek only works without the brackets
- os << latex1 << latex2;
- return latex1.length() + latex2.length();
- } else
- os << latex1 << '{' << latex2 << '}';
- return latex1.length() + latex2.length() + 2;
+ }
+
+ // Handle combining characters in "script" context (i.e., \textgreek and \textcyrillic)
+ docstring::size_type const brace1 = latex2.find_first_of(from_ascii("{"));
+ docstring::size_type const brace2 = latex2.find_last_of(from_ascii("}"));
+ string script = to_ascii(latex2.substr(1, brace1 - 1));
+ // "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())
+ // This will get us a script value to deal with below
+ Encodings::isKnownScriptChar(c, script);
+ int pos = 0;
+ int length = brace2;
+ string fontenc;
+ if (runparams.local_font)
+ fontenc = runparams.local_font->language()->fontenc(bparams);
+ else
+ fontenc = bparams.language->fontenc(bparams);
+ docstring scriptmacro;
+ docstring cb;
+ if (script == "textgreek" || script == "textcyrillic") {
+ // We separate the script macro (\text[greek|cyr]) from the rest,
+ // since we need to include the combining char in it (#6463).
+ // This is "the rest":
+ pos = brace1 + 1;
+ length -= pos;
+ latex2 = latex2.substr(pos, length);
+ // We only need the script macro with non-native font encodings
+ if (Encodings::needsScriptWrapper(script, fontenc)) {
+ scriptmacro = from_ascii("\\" + script + "{");
+ cb = from_ascii("}");
+ }
+ }
+
+ docstring lb;
+ docstring rb;
+ // polutonikogreek does not play nice with brackets
+ if (!runparams.local_font
+ || runparams.local_font->language()->lang() != "polutonikogreek") {
+ lb = from_ascii("{");
+ rb = from_ascii("}");
+ }
+
+ os << scriptmacro << latex1 << lb << latex2 << rb << cb;
+ return latex1.length() + latex2.length() + lb.length() + rb.length() + cb.length();
}
-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(otexstream & os,
+int Paragraph::Private::writeScriptChars(BufferParams const & bparams,
+ OutputParams const & runparams,
+ otexstream & os,
docstring const & ltx,
Change const & runningChange,
Encoding const & encoding,
+ string const fontenc,
pos_type & i)
{
// FIXME: modifying i here is not very nice...
// We only arrive here when character text_[i] could not be translated
// into the current latex encoding (or its latex translation has been forced,)
// and it belongs to a known script.
- // TODO: We need \textcyr and \textgreek wrappers also for characters
- // that can be encoded in the "LaTeX encoding" but not in the
- // current *font encoding*.
- // (See #9681 for details and test)
// Parameter ltx contains the latex translation of text_[i] as specified
// in the unicodesymbols file and is something like "\textXXX{<spec>}".
// The latex macro name "textXXX" specifies the script to which text_[i]
int pos = 0;
int length = brace2;
bool closing_brace = true;
- if (script == "textgreek" && encoding.latexName() == "iso-8859-7") {
- // Correct encoding is being used, so we can avoid \textgreek.
- // TODO: wrong test: we need to check the *font encoding*
- // (i.e. the active language and its FontEncoding tag)
- // instead of the LaTeX *input encoding*!
- // See #9637 for details and test-cases.
+ if (!Encodings::needsScriptWrapper(script, fontenc)) {
+ // Correct font encoding is being used, so we can avoid \text[greek|cyr].
pos = brace1 + 1;
length -= pos;
closing_brace = false;
// Stop here if there is a font attribute or encoding change.
if (found && cit != end && prev_font != cit->font())
break;
+
+ // Check whether we have a combining pair
+ char_type next_next = '\0';
+ if (i + 2 < size) {
+ next_next = text_[i + 2];
+ if (Encodings::isCombiningChar(next_next)) {
+ length += latexSurrogatePair(bparams, os, next, next_next, runparams) - 1;
+ i += 2;
+ continue;
+ }
+ }
+
docstring const latex = encoding.latexChar(next).first;
docstring::size_type const b1 =
latex.find_first_of(from_ascii("{"));
odocstream::pos_type const len = os.os().tellp();
if (inset->forceLTR()
- && !runparams.use_polyglossia
&& running_font.isRightToLeft()
// ERT is an exception, it should be output with no
// decorations at all
&& inset->lyxCode() != ERT_CODE) {
- if (running_font.language()->lang() == "farsi")
- os << "\\beginL" << termcmd;
+ if (runparams.use_polyglossia) {
+ os << "\\LRE{";
+ } else if (running_font.language()->lang() == "farsi"
+ || running_font.language()->lang() == "arabic_arabi")
+ os << "\\textLR{" << termcmd;
else
os << "\\L{";
close = true;
throw(e);
}
- if (close) {
- if (running_font.language()->lang() == "farsi")
- os << "\\endL" << termcmd;
- else
- os << '}';
- }
+ if (close)
+ os << '}';
if (os.texrow().rows() > previous_row_count) {
os.texrow().start(owner_->id(), i + 1);
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 < static_cast<pos_type>(text_.size()) &&
(end_pos == -1 || i + 1 < end_pos) &&
text_[i+1] == '-') {
- // Prevent "--" becoming an endash and "---" becoming
- // an emdash.
- // Within \ttfamily, "--" is merged to "-" (no endash)
- // so we avoid this rather irritating ligature as well
+ // Prevent "--" becoming an en dash and "---" an em dash.
+ // (Within \ttfamily, "---" is merged to en dash + hyphen.)
os << "{}";
column += 2;
}
// XeTeX's dash behaviour is determined via a global setting
if (bparams.use_dash_ligatures
&& owner_->getFontSettings(bparams, i).fontInfo().family() != TYPEWRITER_FAMILY
+ && !runparams.inIPA
+ // TODO #10961: && not in inset Flex Code
+ // TODO #10961: && not in layout LyXCode
&& (!bparams.useNonTeXFonts || runparams.flavor != OutputParams::XETEX)) {
if (c == 0x2013) {
// en-dash
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;
}
tipas = true;
}
}
- if (Encodings::isKnownScriptChar(c, script)
- && prefixIs(latex.first, from_ascii("\\" + script)))
- column += writeScriptChars(os, latex.first,
- running_change, encoding, i) - 1;
- else if (latex.second
+ string 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 const wrapper = from_ascii("\\" + script + "{");
+ docstring ltx = latex.first;
+ if (!prefixIs(ltx, wrapper))
+ ltx = wrapper + latex.first + from_ascii("}");
+ column += writeScriptChars(bparams, runparams, os, ltx, running_change,
+ encoding, fontenc, i) - 1;
+ } else if (latex.second
&& ((!prefixIs(nextlatex, '\\')
&& !prefixIs(nextlatex, '{')
&& !prefixIs(nextlatex, '}'))
os << "\\textvertline" << termcmd;
column += 14;
return true;
- case 0x2013:
- os << "\\textendash" << termcmd;
- column += 12;
- return true;
- case 0x2014:
- os << "\\textemdash" << termcmd;
- column += 12;
- return true;
default:
return false;
}
void Paragraph::Private::validate(LaTeXFeatures & features) const
{
- Buffer const & buf = inset_owner_->buffer();
- BufferParams const & bp = features.runparams().is_child
- ? buf.masterParams() : buf.params();
if (layout_->inpreamble && inset_owner_) {
- bool const is_command = layout_->latextype == LATEX_COMMAND;
- Font f;
- // Using a string stream here circumvents the encoding
+ // FIXME: Using a string stream here circumvents the encoding
// switching machinery of odocstream. Therefore the
// output is wrong if this paragraph contains content
// that needs to switch encoding.
+ Buffer const & buf = inset_owner_->buffer();
otexstringstream os;
os << layout_->preamble();
- if (is_command) {
- os << '\\' << from_ascii(layout_->latexname());
- // we have to provide all the optional arguments here, even though
- // the last one is the only one we care about.
- // Separate handling of optional argument inset.
- if (!layout_->latexargs().empty()) {
- OutputParams rp = features.runparams();
- rp.local_font = &owner_->getFirstFontSettings(bp);
- latexArgInsets(*owner_, os, rp, layout_->latexargs());
- }
- os << from_ascii(layout_->latexparam());
- }
size_t const length = os.length();
- // this will output "{" at the beginning, but not at the end
- owner_->latex(bp, f, os, features.runparams(), 0, -1, true);
- if (os.length() > length) {
- if (is_command) {
- os << '}';
- if (!layout_->postcommandargs().empty()) {
- OutputParams rp = features.runparams();
- rp.local_font = &owner_->getFirstFontSettings(bp);
- latexArgInsets(*owner_, os, rp, layout_->postcommandargs(), "post:");
- }
- }
+ TeXOnePar(buf, buf.text(), buf.getParFromID(owner_->id()).pit(), os,
+ features.runparams(), string(), 0, -1, true);
+ if (os.length() > length)
features.addPreambleSnippet(os.release(), true);
- }
}
if (features.runparams().flavor == OutputParams::HTML
}
// then the contents
+ BufferParams const bp = features.runparams().is_child
+ ? features.buffer().masterParams() : features.buffer().params();
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");
- }
- if (!bp.use_dash_ligatures
- && (c == 0x2013 || c == 0x2014)
- && bp.useNonTeXFonts
- && features.runparams().flavor == OutputParams::XETEX)
+ } 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;
+ 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
+ && features.runparams().flavor == OutputParams::XETEX)
// XeTeX's dash behaviour is determined via a global setting
features.require("xetexdashbreakstate");
BufferEncodings::validate(c, features);
void Paragraph::validate(LaTeXFeatures & features) const
{
d->validate(features);
+ 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];
- if (!getFontSettings(bparams, pos).isRightToLeft())
+
+ // Return unchanged character in LTR languages
+ // or if we use poylglossia/bidi.
+ if (rp.use_polyglossia || !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).
+ // Without polyglossia/bidi, we need to account for some special cases.
+ // FIXME This needs to be audited!
+ // Check if:
+ // * The input is as expected for all delimiters
+ // => checked for Hebrew!
+ // * The output matches the display in the LyX workarea
+ // => checked for Hebrew!
+ // * The special cases below are really necessary
+ // => checked for Hebrew!
+ // * In arabic_arabi, brackets are transformed to Arabic
+ // Ornate Parentheses. Is this is really wanted?
+
string const & lang = getFontSettings(bparams, pos).language()->lang();
- bool const arabic = lang == "arabic_arabtex" || lang == "arabic_arabi"
- || lang == "farsi";
char_type uc = c;
+
+ // 1. In the following languages, parentheses need to be reversed.
+ bool const reverseparens = lang == "hebrew";
+
+ // 2. In the following languages, brackets don't need to be reversed.
+ bool const reversebrackets = lang != "arabic_arabtex"
+ && lang != "arabic_arabi"
+ && lang != "farsi";
+
+ // Now swap delimiters if needed.
switch (c) {
case '(':
- uc = arabic ? c : ')';
+ if (reverseparens)
+ uc = ')';
break;
case ')':
- uc = arabic ? c : '(';
+ if (reverseparens)
+ uc = '(';
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);
// if the paragraph is empty, the loop will not be entered at all
if (empty()) {
- if (style.isCommand()) {
+ // For InTitle commands, we have already opened a group
+ // in output_latex::TeXOnePar.
+ if (style.isCommand() && !style.intitle) {
os << '{';
++column;
}
os << "}] ";
column +=3;
}
- if (style.isCommand()) {
+ // For InTitle commands, we have already opened a group
+ // in output_latex::TeXOnePar.
+ if (style.isCommand() && !style.intitle) {
os << '{';
++column;
}
// 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
ParagraphList const & pars =
textinset->text().paragraphs();
pit_type const pit = pars.size() - 1;
- Font const last_font =
+ Font const lastfont =
pit < 0 || pars[pit].empty()
? pars[pit].getLayoutFont(
bparams,
: pars[pit].getFont(bparams,
pars[pit].size() - 1,
outerfont);
- if (last_font.fontInfo().size() !=
+ if (lastfont.fontInfo().size() !=
basefont.fontInfo().size()) {
++parInline;
incremented = true;
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(bool const fragile) const
+{
+ // 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;
+
+ // Commands need cprotection if they contain specific chars
+ int const nchars_escape = 9;
+ static char_type const chars_escape[nchars_escape] = {
+ '&', '_', '$', '%', '#', '^', '{', '}', '\\'};
+
+ docstring const pars = asString();
+ for (int k = 0; k < nchars_escape; k++) {
+ if (contains(pars, chars_escape[k]))
+ 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(maintext, fragile))
+ return true;
+
+ return false;
+}
+
+
FontSpan const & Paragraph::getSpellRange(pos_type pos) const
{
return d->speller_state_.getRange(pos);
bool Paragraph::isMultiLingual(BufferParams const & bparams) const
{
Language const * doc_language = bparams.language;
- FontList::const_iterator cit = d->fontlist_.begin();
- FontList::const_iterator end = d->fontlist_.end();
-
- for (; cit != end; ++cit)
- if (cit->font().language() != ignore_language &&
- cit->font().language() != latex_language &&
- cit->font().language() != doc_language)
+ for (auto const & f : d->fontlist_)
+ if (f.font().language() != ignore_language &&
+ f.font().language() != latex_language &&
+ f.font().language() != doc_language)
return true;
return false;
}
-void Paragraph::getLanguages(std::set<Language const *> & languages) const
+void Paragraph::getLanguages(std::set<Language const *> & langs) const
{
- FontList::const_iterator cit = d->fontlist_.begin();
- FontList::const_iterator end = d->fontlist_.end();
-
- for (; cit != end; ++cit) {
- Language const * lang = cit->font().language();
+ for (auto const & f : d->fontlist_) {
+ Language const * lang = f.font().language();
if (lang != ignore_language &&
lang != latex_language)
- languages.insert(lang);
+ langs.insert(lang);
}
}
size_t tmplen = shorten ? maxlen + 1 : maxlen;
if (label && !labelString().empty())
os += labelString() + ' ';
+ if (!layout().isTocCaption())
+ return;
for (pos_type i = 0; i < size() && os.length() < tmplen; ++i) {
if (isDeleted(i))
continue;
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())
}
+void Paragraph::anonymize()
+{
+ // This is a very crude anonymization for now
+ for (char_type & c : d->text_)
+ if (isLetterChar(c) || isNumber(c))
+ c = 'a';
+}
+
+
void Paragraph::Private::markMisspelledWords(
pos_type const & first, pos_type const & last,
SpellChecker::Result result,
projects / lyx.git / blobdiff