#include "TextClass.h"
#include "TexRow.h"
#include "Text.h"
-#include "VSpace.h"
#include "WordLangTuple.h"
#include "WordList.h"
OutputParams const &) const;
/// This could go to ParagraphParameters if we want to.
- int endTeXParParams(BufferParams const &, otexstream &,
- OutputParams const &) const;
+ bool endTeXParParams(BufferParams const &, otexstream &,
+ OutputParams const &) const;
///
void latexInset(BufferParams const &,
}
void requestSpellCheck(pos_type pos) {
- speller_state_.needsRefresh(pos);
+ if (pos == -1)
+ speller_state_.needsCompleteRefresh(speller_state_.currentChangeNumber());
+ else
+ speller_state_.needsRefresh(pos);
}
void readySpellCheck() {
// when appending characters, no need to update tables
d->text_.push_back(c);
setFont(d->text_.size() - 1, font);
+ d->requestSpellCheck(d->text_.size() - 1);
}
for (size_t i = oldsize; i != newsize; ++i) {
// track change
d->changes_.insert(change, i);
+ d->requestSpellCheck(i);
}
d->fontlist_.set(oldsize, font);
d->fontlist_.set(newsize - 1, font);
}
-int Paragraph::Private::endTeXParParams(BufferParams const & bparams,
+bool Paragraph::Private::endTeXParParams(BufferParams const & bparams,
otexstream & os, OutputParams const & runparams) const
{
- int column = 0;
-
LyXAlignment const curAlign = params_.align();
if (curAlign == layout_->align)
- return column;
+ return false;
switch (curAlign) {
case LYX_ALIGN_NONE:
case LYX_ALIGN_LEFT:
case LYX_ALIGN_RIGHT:
case LYX_ALIGN_CENTER:
- if (runparams.moving_arg) {
+ if (runparams.moving_arg)
os << "\\protect";
- column = 8;
- }
break;
}
+ string output;
string const end_tag = "\n\\par\\end";
InsetCode code = ownerCode();
bool const lastpar = runparams.isLastPar;
case LYX_ALIGN_DECIMAL:
break;
case LYX_ALIGN_LEFT: {
- string output;
if (owner_->getParLanguage(bparams)->babel() != "hebrew")
output = corrected_env(end_tag, "flushleft", code, lastpar);
else
output = corrected_env(end_tag, "flushright", code, lastpar);
os << from_ascii(output);
- adjust_column(output, column);
break;
} case LYX_ALIGN_RIGHT: {
- string output;
if (owner_->getParLanguage(bparams)->babel() != "hebrew")
output = corrected_env(end_tag, "flushright", code, lastpar);
else
output = corrected_env(end_tag, "flushleft", code, lastpar);
os << from_ascii(output);
- adjust_column(output, column);
break;
} case LYX_ALIGN_CENTER: {
- string output;
output = corrected_env(end_tag, "center", code, lastpar);
os << from_ascii(output);
- adjust_column(output, column);
break;
}
}
- return column;
+ return !output.empty() || lastpar;
}
if (body_pos > 0) {
// the optional argument is kept in curly brackets in
// case it contains a ']'
+ // This is not strictly needed, but if this is changed it
+ // would be a file format change, and tex2lyx would need
+ // to be adjusted, since it unconditionally removes the
+ // braces when it parses \item.
os << "[{";
column += 2;
basefont = getLabelFont(bparams, outerfont);
runparams);
}
- Change const & change = runparams.inDeletedInset ? runparams.changeOfDeletedInset
- : lookupChange(i);
+ Change const & change = runparams.inDeletedInset
+ ? runparams.changeOfDeletedInset : lookupChange(i);
if (bparams.outputChanges && runningChange != change) {
if (open_font) {
bool emph_flag = false;
bool bold_flag = false;
- string closing_tag;
Layout const & style = *d->layout_;
+ xs.startParagraph(allowEmpty());
+
if (!runparams.for_toc && runparams.html_make_pars) {
// generate a magic label for this paragraph
string const attr = "id='" + magicLabel() + "'";
}
xs.closeFontTags();
+ xs.endParagraph();
return retval;
}
bool Paragraph::isWordSeparator(pos_type pos) const
{
- if (Inset const * inset = getInset(pos))
- return !inset->isLetter();
if (pos == size())
return true;
- char_type const c = d->text_[pos];
- // if we have a hard hyphen (no en- or emdash),
+ if (Inset const * inset = getInset(pos))
+ return !inset->isLetter();
+ // if we have a hard hyphen (no en- or emdash) or apostrophe
// we pass this to the spell checker
- if (c == '-') {
- int j = pos + 1;
- if ((j == size() || d->text_[j] != '-')
- && (pos == 0 || d->text_[pos - 1] != '-'))
- return false;
- }
- // 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));
+ // FIXME: this method is subject to change, visit
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=355178
+ // to get an impression how complex this is.
+ if (isHardHyphenOrApostrophe(pos))
+ return false;
+ char_type const c = d->text_[pos];
+ // We want to pass the escape chars to the spellchecker
+ docstring const escape_chars = from_utf8(lyxrc.spellchecker_esc_chars);
+ return !isLetterChar(c) && !isDigitASCII(c) && !contains(escape_chars, c);
+}
+
+
+bool Paragraph::isHardHyphenOrApostrophe(pos_type pos) const
+{
+ pos_type const psize = size();
+ if (pos >= psize)
+ return false;
+ char_type const c = d->text_[pos];
+ if (c != '-' && c != '\'')
+ return false;
+ int nextpos = pos + 1;
+ int prevpos = pos > 0 ? pos - 1 : 0;
+ if ((nextpos == psize || isSpace(nextpos))
+ && (pos == 0 || isSpace(prevpos)))
+ return false;
+ return c == '\''
+ || ((nextpos == psize || d->text_[nextpos] != '-')
+ && (pos == 0 || d->text_[prevpos] != '-'));
}
if (font.language() == from) {
font.setLanguage(to);
setFont(i, font);
+ d->requestSpellCheck(i);
}
}
- d->requestSpellCheck(size());
}
void Paragraph::requestSpellCheck(pos_type pos)
{
- d->requestSpellCheck(pos == -1 ? size() : pos);
+ d->requestSpellCheck(pos);
}
return result;
if (needsSpellCheck() || check_learned) {
+ pos_type end = to;
if (!d->ignoreWord(word)) {
bool const trailing_dot = to < size() && d->text_[to] == '.';
result = speller->check(wl);
word << "\" [" <<
from << ".." << to << "]");
} else {
- // spell check with dot appended failed
+ // spell check with dot appended failed too
// restore original word/lang value
word = asString(from, to, AS_STR_INSETS | AS_STR_SKIPDELETE);
wl = WordLangTuple(word, lang);
}
}
}
- d->setMisspelled(from, to, result);
+ if (!SpellChecker::misspelled(result)) {
+ // area up to the begin of the next word is not misspelled
+ while (end < size() && isWordSeparator(end))
+ ++end;
+ }
+ d->setMisspelled(from, end, result);
} else {
result = d->speller_state_.getState(from);
}
- bool const misspelled_ = SpellChecker::misspelled(result) ;
- if (misspelled_ && do_suggestion)
- speller->suggest(wl, suggestions);
- else if (misspelled_)
+ if (do_suggestion)
+ suggestions.clear();
+
+ if (SpellChecker::misspelled(result)) {
LYXERR(Debug::GUI, "misspelled word: \"" <<
word << "\" [" <<
from << ".." << to << "]");
- else
- suggestions.clear();
-
+ if (do_suggestion)
+ speller->suggest(wl, suggestions);
+ }
return result;
}
bool Paragraph::isMisspelled(pos_type pos, bool check_boundary) const
{
bool result = SpellChecker::misspelled(d->speller_state_.getState(pos));
- if (result || pos <= 0 || pos >= size())
+ if (result || pos <= 0 || pos > size())
return result;
- if (check_boundary && isWordSeparator(pos))
+ if (check_boundary && (pos == size() || isWordSeparator(pos)))
result = SpellChecker::misspelled(d->speller_state_.getState(pos - 1));
return result;
}
projects / lyx.git / blobdiff