void setRange(FontSpan const fp, SpellChecker::Result state)
{
- eraseCoveredRanges(fp);
+ Ranges result;
+ RangesIterator et = ranges_.end();
+ RangesIterator it = ranges_.begin();
+ for (; it != et; ++it) {
+ if (!it->covered(fp))
+ result.push_back(SpellResultRange(it->range(), it->result()));
+ else if (state == SpellChecker::WORD_OK) {
+ // trim or split the current misspelled range
+ // store misspelled ranges only
+ FontSpan range = it->range();
+ if (fp.first > range.first) {
+ // misspelled area in front of WORD_OK
+ range.last = fp.first - 1;
+ result.push_back(SpellResultRange(range, it->result()));
+ range = it->range();
+ }
+ if (fp.last < range.last) {
+ // misspelled area after WORD_OK range
+ range.first = fp.last + 1;
+ result.push_back(SpellResultRange(range, it->result()));
+ }
+ }
+ }
+ ranges_ = result;
if (state != SpellChecker::WORD_OK)
ranges_.push_back(SpellResultRange(fp, state));
}
if (pos > refresh_.last)
refresh_.last = pos;
} else if (pos != -1) {
- refresh_.first = pos;
- refresh_.last = pos;
+ // init request check for neighbour positions too
+ refresh_.first = pos > 0 ? pos - 1 : 0;
+ // no need for special end of paragraph check
+ refresh_.last = pos + 1;
}
needs_refresh_ = pos != -1;
}
SpellChecker::ChangeNumber current_change_number_;
- void eraseCoveredRanges(FontSpan const fp)
- {
- Ranges result;
- RangesIterator et = ranges_.end();
- RangesIterator it = ranges_.begin();
- for (; it != et; ++it) {
- if (!it->covered(fp))
- result.push_back(SpellResultRange(it->range(), it->result()));
- }
- ranges_ = result;
- }
-
void correctRangesAfterPos(pos_type pos, int offset)
{
RangesIterator et = ranges_.end();
/// Output the surrogate pair formed by \p c and \p next to \p os.
/// \return the number of characters written.
- int latexSurrogatePair(odocstream & os, char_type c, char_type next,
+ int latexSurrogatePair(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 &,
- odocstream &, TexRow & texrow,
+ otexstream &,
pos_type i,
unsigned int & column,
Font const & font,
/// 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(odocstream & os, docstring const & ltx,
+ int writeScriptChars(otexstream & os, docstring const & ltx,
Change const &, Encoding const &, pos_type & i);
/// This could go to ParagraphParameters if we want to.
- int startTeXParParams(BufferParams const &, odocstream &, TexRow &,
+ int startTeXParParams(BufferParams const &, otexstream &,
OutputParams const &) const;
/// This could go to ParagraphParameters if we want to.
- int endTeXParParams(BufferParams const &, odocstream &, TexRow &,
+ int endTeXParParams(BufferParams const &, otexstream &,
OutputParams const &) const;
///
void latexInset(BufferParams const &,
- odocstream &,
- TexRow & texrow, OutputParams &,
+ otexstream &,
+ OutputParams &,
Font & running_font,
Font & basefont,
Font const & outerfont,
///
void latexSpecialChar(
- odocstream & os,
+ otexstream & os,
OutputParams const & runparams,
Font const & running_font,
Change const & running_change,
Layout const & style,
pos_type & i,
+ pos_type end_pos,
unsigned int & column);
///
bool latexSpecialT1(
char_type const c,
- odocstream & os,
+ otexstream & os,
pos_type i,
unsigned int & column);
///
bool latexSpecialTypewriter(
char_type const c,
- odocstream & os,
+ otexstream & os,
pos_type i,
unsigned int & column);
///
bool latexSpecialPhrase(
- odocstream & os,
+ otexstream & os,
pos_type & i,
+ pos_type end_pos,
unsigned int & column,
OutputParams const & runparams);
{
pos_type textsize = owner_->size();
// check for sane arguments
- if (to < from || from >= textsize)
+ if (to <= from || from >= textsize)
return;
- FontSpan fp = FontSpan(from, to);
- // don't mark end of paragraph
- if (fp.last >= textsize)
- fp.last = textsize - 1;
+ FontSpan fp = FontSpan(from, to - 1);
speller_state_.setRange(fp, state);
}
}
-int Paragraph::Private::latexSurrogatePair(odocstream & os, char_type c,
+int Paragraph::Private::latexSurrogatePair(otexstream & os, char_type c,
char_type next, OutputParams const & runparams)
{
// Writing next here may circumvent a possible font change between
bool Paragraph::Private::simpleTeXBlanks(OutputParams const & runparams,
- odocstream & os, TexRow & texrow,
+ otexstream & os,
pos_type i,
unsigned int & column,
Font const & font,
|| text_[i - 1] == ':'
|| text_[i - 1] == '!'))) {
os << '\n';
- texrow.newline();
- texrow.start(owner_->id(), i + 1);
+ os.texrow().start(owner_->id(), i + 1);
column = 0;
} else if (style.free_spacing) {
os << '~';
}
-int Paragraph::Private::writeScriptChars(odocstream & os,
+int Paragraph::Private::writeScriptChars(otexstream & os,
docstring const & ltx,
Change const & runningChange,
Encoding const & encoding,
void Paragraph::Private::latexInset(BufferParams const & bparams,
- odocstream & os,
- TexRow & texrow,
+ otexstream & os,
OutputParams & runparams,
Font & running_font,
Font & basefont,
LASSERT(inset, /**/);
if (style.pass_thru) {
- inset->plaintext(os, runparams);
+ inset->plaintext(os.os(), runparams);
return;
}
os << "\\protect ";
}
- texrow.newline();
- texrow.start(owner_->id(), i + 1);
+ os.texrow().start(owner_->id(), i + 1);
column = 0;
}
}
bool close = false;
- odocstream::pos_type const len = os.tellp();
+ odocstream::pos_type const len = os.os().tellp();
if (inset->forceLTR()
&& running_font.isRightToLeft()
}
}
- int tmp;
+ int prev_rows = os.texrow().rows();
try {
- tmp = inset->latex(os, runparams);
+ inset->latex(os, runparams);
} catch (EncodingException & e) {
// add location information and throw again.
e.par_id = id_;
os << '}';
}
- if (tmp) {
- texrow.newlines(tmp);
- texrow.start(owner_->id(), i + 1);
+ if (os.texrow().rows() > prev_rows) {
+ os.texrow().start(owner_->id(), i + 1);
column = 0;
} else {
- column += (unsigned int)(os.tellp() - len);
+ column += (unsigned int)(os.os().tellp() - len);
}
if (owner_->isDeleted(i))
}
-void Paragraph::Private::latexSpecialChar(
- odocstream & os,
- OutputParams const & runparams,
- Font const & running_font,
- Change const & running_change,
- Layout const & style,
- pos_type & i,
- unsigned int & column)
+void Paragraph::Private::latexSpecialChar(otexstream & os,
+ OutputParams const & runparams,
+ Font const & running_font,
+ Change const & running_change,
+ Layout const & style,
+ pos_type & i,
+ pos_type end_pos,
+ unsigned int & column)
{
char_type const c = text_[i];
default:
// LyX, LaTeX etc.
- if (latexSpecialPhrase(os, i, column, runparams))
+ if (latexSpecialPhrase(os, i, end_pos, column, runparams))
return;
if (c == '\0')
}
-bool Paragraph::Private::latexSpecialT1(char_type const c, odocstream & os,
+bool Paragraph::Private::latexSpecialT1(char_type const c, otexstream & os,
pos_type i, unsigned int & column)
{
switch (c) {
}
-bool Paragraph::Private::latexSpecialTypewriter(char_type const c, odocstream & os,
+bool Paragraph::Private::latexSpecialTypewriter(char_type const c, otexstream & os,
pos_type i, unsigned int & column)
{
switch (c) {
}
-bool Paragraph::Private::latexSpecialPhrase(odocstream & os, pos_type & i,
+/// \param end_pos
+/// If [start_pos, end_pos) does not include entirely the special phrase, then
+/// do not apply the macro transformation.
+bool Paragraph::Private::latexSpecialPhrase(otexstream & os, pos_type & i, pos_type end_pos,
unsigned int & column, OutputParams const & runparams)
{
// FIXME: if we have "LaTeX" with a font
// "words" for some definition of word
for (size_t pnr = 0; pnr < phrases_nr; ++pnr) {
- if (!isTextAt(special_phrases[pnr].phrase, i))
+ if (!isTextAt(special_phrases[pnr].phrase, i)
+ || (end_pos != -1 && i + int(special_phrases[pnr].phrase.size()) > end_pos))
continue;
if (runparams.moving_arg)
os << "\\protect";
Buffer const & buf = inset_owner_->buffer();
BufferParams const & bp = buf.params();
Font f;
- TexRow tr;
+ TexRow texrow;
// 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.
odocstringstream ods;
+ otexstream os(ods, texrow);
if (is_command) {
- ods << '\\' << from_ascii(layout_->latexname());
+ 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_->optargs != 0 || layout_->reqargs != 0)
- latexArgInsets(*owner_, ods, features.runparams(),
- layout_->reqargs, layout_->optargs);
+ latexArgInsets(*owner_, os, features.runparams(),
+ layout_->reqargs, layout_->optargs);
else
- ods << from_ascii(layout_->latexparam());
+ os << from_ascii(layout_->latexparam());
}
docstring::size_type const length = ods.str().length();
// this will output "{" at the beginning, but not at the end
- owner_->latex(bp, f, ods, tr, features.runparams(), 0, -1, true);
+ owner_->latex(bp, f, os, features.runparams(), 0, -1, true);
if (ods.str().length() > length) {
if (is_command)
ods << '}';
}
+bool Paragraph::isPassThru() const
+{
+ return inInset().getLayout().isPassThru() || d->layout_->pass_thru;
+}
+
namespace {
// paragraphs inside floats need different alignment tags to avoid
}
-void adjust_row_column(string const & str, TexRow & texrow, int & column)
+void adjust_column(string const & str, int & column)
{
if (!contains(str, "\n"))
column += str.size();
else {
string tmp;
- texrow.newline();
column = rsplit(str, tmp, '\n').size();
}
}
int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
- odocstream & os, TexRow & texrow,
- OutputParams const & runparams) const
+ otexstream & os, OutputParams const & runparams) const
{
int column = 0;
- if (params_.noindent()) {
+ if (params_.noindent() && !layout_->pass_thru) {
os << "\\noindent ";
column += 10;
}
else
output = corrected_env(begin_tag, "flushright", code, lastpar);
os << from_ascii(output);
- adjust_row_column(output, texrow, column);
+ adjust_column(output, column);
break;
} case LYX_ALIGN_RIGHT: {
string output;
else
output = corrected_env(begin_tag, "flushleft", code, lastpar);
os << from_ascii(output);
- adjust_row_column(output, texrow, column);
+ adjust_column(output, column);
break;
} case LYX_ALIGN_CENTER: {
string output;
output = corrected_env(begin_tag, "center", code, lastpar);
os << from_ascii(output);
- adjust_row_column(output, texrow, column);
+ adjust_column(output, column);
break;
}
}
int Paragraph::Private::endTeXParParams(BufferParams const & bparams,
- odocstream & os, TexRow & texrow,
- OutputParams const & runparams) const
+ otexstream & os, OutputParams const & runparams) const
{
int column = 0;
else
output = corrected_env(end_tag, "flushright", code, lastpar);
os << from_ascii(output);
- adjust_row_column(output, texrow, column);
+ adjust_column(output, column);
break;
} case LYX_ALIGN_RIGHT: {
string output;
else
output = corrected_env(end_tag, "flushleft", code, lastpar);
os << from_ascii(output);
- adjust_row_column(output, texrow, column);
+ adjust_column(output, column);
break;
} case LYX_ALIGN_CENTER: {
string output;
output = corrected_env(end_tag, "center", code, lastpar);
os << from_ascii(output);
- adjust_row_column(output, texrow, column);
+ adjust_column(output, column);
break;
}
}
// This one spits out the text of the paragraph
void Paragraph::latex(BufferParams const & bparams,
Font const & outerfont,
- odocstream & os, TexRow & texrow,
+ otexstream & os,
OutputParams const & runparams,
int start_pos, int end_pos, bool force) const
{
Encoding const * const prev_encoding = runparams.encoding;
- texrow.start(id(), 0);
+ os.texrow().start(id(), 0);
// if the paragraph is empty, the loop will not be entered at all
if (empty()) {
++column;
}
if (allowcust)
- column += d->startTeXParParams(bparams, os, texrow,
- runparams);
+ column += d->startTeXParParams(bparams, os, runparams);
}
for (pos_type i = 0; i < size(); ++i) {
if (allowcust)
column += d->startTeXParParams(bparams, os,
- texrow,
runparams);
}
if (!runparams.pass_thru && !style.pass_thru &&
runparams.encoding->package() != Encoding::none &&
font.language()->encoding()->package() != Encoding::none) {
- pair<bool, int> const enc_switch = switchEncoding(os, bparams,
- runparams, *(font.language()->encoding()));
+ pair<bool, int> const enc_switch =
+ switchEncoding(os.os(), bparams, runparams,
+ *(font.language()->encoding()));
if (enc_switch.first) {
column += enc_switch.second;
runparams.encoding = font.language()->encoding();
// latexSpecialChar ignores spaces if
// style.pass_thru is false.
if (i != body_pos - 1) {
- if (d->simpleTeXBlanks(
- runparams, os, texrow,
+ if (d->simpleTeXBlanks(runparams, os,
i, column, 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)) {
- d->latexInset(bparams, os,
- texrow, rp, running_font,
+ d->latexInset(bparams, os, rp, running_font,
basefont, outerfont, open_font,
runningChange, style, i, column);
}
if (i >= start_pos && (end_pos == -1 || i < end_pos)) {
try {
d->latexSpecialChar(os, rp, running_font, runningChange,
- style, i, column);
+ style, i, end_pos, column);
} catch (EncodingException & e) {
if (runparams.dryrun) {
os << "<" << _("LyX Warning: ")
os << "}]~";
}
- if (allowcust && d->endTeXParParams(bparams, os, texrow, runparams)
+ if (allowcust && d->endTeXParParams(bparams, os, runparams)
&& runparams.encoding != prev_encoding) {
runparams.encoding = prev_encoding;
if (!runparams.isFullUnicode())
{
if (Inset const * inset = getInset(pos))
return !inset->isLetter();
+ if (pos == size())
+ return true;
char_type const c = d->text_[pos];
// We want to pass the ' and escape chars to the spellchecker
static docstring const quote = from_utf8(lyxrc.spellchecker_esc_chars + '\'');
- return (!isLetterChar(c) && !isDigitASCII(c) && !contains(quote, c))
- || pos == size();
+ return (!isLetterChar(c) && !isDigitASCII(c) && !contains(quote, c));
}
void Paragraph::forToc(docstring & os, size_t maxlen) const
{
+ if (!d->params_.labelString().empty())
+ os += d->params_.labelString() + ' ';
for (pos_type i = 0; i < size() && os.length() < maxlen; ++i) {
if (isDeleted(i))
continue;
}
-bool Paragraph::isMisspelled(pos_type pos) const
+bool Paragraph::isMisspelled(pos_type pos, bool check_boundary) const
{
- return SpellChecker::misspelled(d->speller_state_.getState(pos));
+ bool result = SpellChecker::misspelled(d->speller_state_.getState(pos));
+ if (result || pos <= 0 || pos >= size())
+ return result;
+ if (check_boundary && isWordSeparator(pos))
+ result = SpellChecker::misspelled(d->speller_state_.getState(pos - 1));
+ return result;
}