#include "insets/InsetBibitem.h"
#include "insets/InsetLabel.h"
#include "insets/InsetSpecialChar.h"
+#include "insets/InsetText.h"
#include "mathed/InsetMathHull.h"
using namespace std;
using namespace lyx::support;
+// OSX clang, gcc < 4.8.0, and msvc < 2015 do not support C++11 thread_local
+#if defined(__APPLE__) || (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ < 8)
+#define THREAD_LOCAL_STATIC static __thread
+#elif defined(_MSC_VER) && (_MSC_VER < 1900)
+#define THREAD_LOCAL_STATIC static __declspec(thread)
+#else
+#define THREAD_LOCAL_STATIC thread_local static
+#endif
+
namespace lyx {
namespace {
/// Inset identifier (above 0x10ffff, for ucs-4)
char_type const META_INSET = 0x200001;
-}
+} // namespace
/////////////////////////////////////////////////////////////////////
/// 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 &,
typedef SkipPositions::const_iterator SkipPositionsIterator;
void appendSkipPosition(SkipPositions & skips, pos_type const pos) const;
-
+
Language * getSpellLanguage(pos_type const from) const;
Language * locateSpellRange(pos_type & from, pos_type & to,
}
bool ignoreWord(docstring const & word) const ;
-
+
void setMisspelled(pos_type from, pos_type to, SpellChecker::Result state)
{
pos_type textsize = owner_->size();
}
-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("{"));
os << '\n';
} else {
if (open_font) {
+ bool needPar = false;
column += running_font.latexWriteEndChanges(
os, bparams, runparams,
- basefont, basefont);
+ basefont, basefont, needPar);
open_font = false;
}
bool arabtex = basefont.language()->lang() == "arabic_arabtex"
|| running_font.language()->lang() == "arabic_arabtex";
if (open_font && !inset->inheritFont()) {
+ bool needPar = false;
bool closeLanguage = arabtex
|| basefont.isRightToLeft() == running_font.isRightToLeft();
unsigned int count = running_font.latexWriteEndChanges(os,
- bparams, runparams, basefont, basefont, closeLanguage);
+ bparams, runparams, basefont, basefont,
+ needPar, closeLanguage);
column += count;
// if any font properties were closed, update the running_font,
// making sure, however, to leave the language as it was
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;
}
break;
case '\"':
- os << "\\char34" << termcmd;
- column += 9;
+ os << "\\textquotedbl" << termcmd;
+ column += 14;
break;
case '$': case '&':
case 0x2013:
case 0x2014:
- if (bparams.use_dash_ligatures && !bparams.useNonTeXFonts) {
+ // 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
os << "--";
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, '}'))
void Paragraph::Private::validate(LaTeXFeatures & features) const
{
if (layout_->inpreamble && inset_owner_) {
- bool const is_command = layout_->latextype == LATEX_COMMAND;
- Buffer const & buf = inset_owner_->buffer();
- BufferParams const & bp = features.runparams().is_child
- ? buf.masterParams() : buf.params();
- 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
for (; icit != iend; ++icit) {
if (icit->inset) {
features.inDeletedInset(owner_->isDeleted(icit->pos));
+ if (icit->inset->lyxCode() == FOOT_CODE) {
+ // FIXME: an item inset would make things much easier.
+ if ((layout_->latextype == LATEX_LIST_ENVIRONMENT
+ || (layout_->latextype == LATEX_ITEM_ENVIRONMENT
+ && layout_->margintype == MARGIN_FIRST_DYNAMIC))
+ && (icit->pos < begin_of_body_
+ || (icit->pos == begin_of_body_
+ && (icit->pos == 0 || text_[icit->pos - 1] != ' '))))
+ features.saveNoteEnv("description");
+ }
icit->inset->validate(features);
features.inDeletedInset(false);
if (layout_->needprotect &&
}
// 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) {
- BufferEncodings::validate(text_[i], features);
+ 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 (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);
}
}
s.erase();
}
-}
+} // namespace
void Paragraph::write(ostream & os, BufferParams const & bparams,
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];
+
+ // 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 = '}';
return true;
}
-} // namespace anon
+} // namespace
int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
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;
}
column += d->startTeXParParams(bparams, os, runparams);
}
+ // Whether a \par can be issued for insets typeset inline with text.
+ // Yes if greater than 0. This has to be static.
+ THREAD_LOCAL_STATIC int parInline = 0;
+
for (pos_type i = 0; i < size(); ++i) {
// First char in paragraph or after label?
if (i == body_pos) {
if (body_pos > 0) {
if (open_font) {
+ bool needPar = false;
column += running_font.latexWriteEndChanges(
os, bparams, runparams,
- basefont, basefont);
+ basefont, basefont, needPar);
open_font = false;
}
basefont = getLayoutFont(bparams, outerfont);
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;
}
runparams.wasDisplayMath = runparams.inDisplayMath;
runparams.inDisplayMath = false;
bool deleted_display_math = false;
+ Change const & change = runparams.inDeletedInset
+ ? runparams.changeOfDeletedInset : lookupChange(i);
// Check whether a display math inset follows
if (d->text_[i] == META_INSET
// cannot set it here because it is a counter.
deleted_display_math = isDeleted(i);
}
+ if (bparams.output_changes && deleted_display_math
+ && runningChange == change
+ && change.type == Change::DELETED
+ && !os.afterParbreak()) {
+ // A display math in the same paragraph follows.
+ // We have to close and then reopen \lyxdeleted,
+ // otherwise the math will be shifted up.
+ OutputParams rp = runparams;
+ if (open_font) {
+ bool needPar = false;
+ column += running_font.latexWriteEndChanges(
+ os, bparams, rp, basefont,
+ basefont, needPar);
+ open_font = false;
+ }
+ basefont = getLayoutFont(bparams, outerfont);
+ running_font = basefont;
+ column += Changes::latexMarkChange(os, bparams,
+ Change(Change::INSERTED), change, rp);
+ }
}
- Change const & change = runparams.inDeletedInset
- ? runparams.changeOfDeletedInset : lookupChange(i);
-
if (bparams.output_changes && runningChange != change) {
if (open_font) {
+ bool needPar = false;
column += running_font.latexWriteEndChanges(
- os, bparams, runparams, basefont, basefont);
+ os, bparams, runparams,
+ basefont, basefont, needPar);
open_font = false;
}
basefont = getLayoutFont(bparams, outerfont);
(current_font != running_font ||
current_font.language() != running_font.language()))
{
+ bool needPar = false;
column += running_font.latexWriteEndChanges(
- os, bparams, runparams, basefont,
- (i == body_pos-1) ? basefont : current_font);
+ os, bparams, runparams, basefont,
+ (i == body_pos-1) ? basefont : current_font,
+ needPar);
running_font = basefont;
open_font = false;
}
bool const using_begin_end = runparams.use_polyglossia ||
!lang_end_command.empty();
if (!running_lang.empty() &&
+ (!using_begin_end || running_lang == openLanguageName()) &&
current_font.language()->encoding()->package() == Encoding::CJK) {
string end_tag = subst(lang_end_command,
"$$lang",
char_type const c = d->text_[i];
// A display math inset inside an ulem command will be output
- // as a box of width \columnwidth, so we have to either disable
+ // as a box of width \linewidth, so we have to either disable
// indentation if the inset starts a paragraph, or start a new
// line to accommodate such box. This has to be done before
// writing any font changing commands.
// 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
// and then split to handle the two modes separately.
if (c == META_INSET) {
if (i >= start_pos && (end_pos == -1 || i < end_pos)) {
+ // Greyedout notes and, in general, all insets
+ // with InsetLayout::isDisplay() == false,
+ // are typeset inline with the text. So, we
+ // can add a \par to the last paragraph of
+ // such insets only if nothing else follows.
+ bool incremented = false;
+ Inset const * inset = getInset(i);
+ InsetText const * textinset = inset
+ ? inset->asInsetText()
+ : 0;
+ if (i + 1 == size() && textinset
+ && !inset->getLayout().isDisplay()) {
+ ParagraphList const & pars =
+ textinset->text().paragraphs();
+ pit_type const pit = pars.size() - 1;
+ Font const lastfont =
+ pit < 0 || pars[pit].empty()
+ ? pars[pit].getLayoutFont(
+ bparams,
+ outerfont)
+ : pars[pit].getFont(bparams,
+ pars[pit].size() - 1,
+ outerfont);
+ if (lastfont.fontInfo().size() !=
+ basefont.fontInfo().size()) {
+ ++parInline;
+ incremented = true;
+ }
+ }
d->latexInset(bparams, os, rp, running_font,
basefont, outerfont, open_font,
runningChange, style, i, column);
+ if (incremented)
+ --parInline;
}
} else if (i >= start_pos && (end_pos == -1 || i < end_pos)) {
try {
// If we have an open font definition, we have to close it
if (open_font) {
+ // Make sure that \\par is done with the font of the last
+ // character if this has another size as the default.
+ // This is necessary because LaTeX (and LyX on the screen)
+ // calculates the space between the baselines according
+ // to this font. (Matthias)
+ //
+ // We must not change the font for the last paragraph
+ // of non-multipar insets, tabular cells or commands,
+ // since this produces unwanted whitespace.
+
+ Font const font = empty()
+ ? getLayoutFont(bparams, outerfont)
+ : getFont(bparams, size() - 1, outerfont);
+
+ InsetText const * textinset = inInset().asInsetText();
+
+ bool const maintext = textinset
+ ? textinset->text().isMainText()
+ : false;
+
+ size_t const numpars = textinset
+ ? textinset->text().paragraphs().size()
+ : 0;
+
+ bool needPar = false;
+
+ if (style.resfont.size() != font.fontInfo().size()
+ && (!runparams.isLastPar || maintext
+ || (numpars > 1 && d->ownerCode() != CELL_CODE
+ && (inInset().getLayout().isDisplay()
+ || parInline)))
+ && !style.isCommand()) {
+ needPar = true;
+ }
#ifdef FIXED_LANGUAGE_END_DETECTION
if (next_) {
running_font.latexWriteEndChanges(os, bparams,
runparams, basefont,
- next_->getFont(bparams, 0, outerfont));
+ next_->getFont(bparams, 0, outerfont),
+ needPar);
} else {
running_font.latexWriteEndChanges(os, bparams,
- runparams, basefont, basefont);
+ runparams, basefont, basefont, needPar);
}
#else
//FIXME: For now we ALWAYS have to close the foreign font settings if they are
//FIXME: there as we start another \selectlanguage with the next paragraph if
//FIXME: we are in need of this. This should be fixed sometime (Jug)
running_font.latexWriteEndChanges(os, bparams, runparams,
- basefont, basefont);
+ basefont, basefont, needPar);
#endif
+ if (needPar) {
+ // The \par could not be inserted at the same nesting
+ // level of the font size change, so do it now.
+ os << "{\\" << font.latexSize() << "\\par}";
+ }
}
column += Changes::latexMarkChange(os, bparams, runningChange,
flag = false;
}
}
-}
+} // namespace
docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
FontShape curr_fs = INHERIT_SHAPE;
FontFamily curr_fam = INHERIT_FAMILY;
FontSize curr_size = FONT_SIZE_INHERIT;
-
- string const default_family =
- buf.masterBuffer()->params().fonts_default_family;
+
+ string const default_family =
+ buf.masterBuffer()->params().fonts_default_family;
vector<html::FontTag> tagsToOpen;
vector<html::EndFontTag> tagsToClose;
-
+
// parsing main loop
for (pos_type i = initial; i < size(); ++i) {
// let's not show deleted material in the output
curstate = font.fontInfo().underbar();
if (font_old.underbar() != curstate)
doFontSwitch(tagsToOpen, tagsToClose, ubar_flag, curstate, html::FT_UBAR);
-
+
// strikeout
curstate = font.fontInfo().strikeout();
if (font_old.strikeout() != curstate)
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;
InsetCommandParams(BIBITEM_CODE));
Font font(inherit_font, buffer.params().language);
- insertInset(0, inset, font, Change(track_changes ? Change::INSERTED
+ insertInset(0, inset, font, Change(track_changes ? Change::INSERTED
: Change::UNCHANGED));
return 1;
}
-void Paragraph::setBuffer(Buffer & b)
+void Paragraph::setInsetBuffers(Buffer & b)
{
d->insetlist_.setBuffer(b);
}
to = from;
return;
}
- // no break here, we go to the next
+ // fall through
case WHOLE_WORD:
// If we are already at the beginning of a word, do nothing
if (!from || isWordSeparator(from - 1))
break;
- // no break here, we go to the next
+ // fall through
case PREVIOUS_WORD:
// always move the cursor to the beginning of previous word
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,