#include "LyXRC.h"
#include "OutputParams.h"
#include "output_latex.h"
+#include "output_xhtml.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
+#include "SpellChecker.h"
#include "sgml.h"
#include "TextClass.h"
#include "TexRow.h"
#include "Text.h"
#include "VSpace.h"
+#include "WordLangTuple.h"
#include "WordList.h"
#include "frontends/alert.h"
#include "insets/InsetLabel.h"
#include "support/lassert.h"
-#include "support/convert.h"
#include "support/debug.h"
#include "support/ExceptionMessage.h"
#include "support/gettext.h"
}
+bool Paragraph::isFullyDeleted(pos_type start, pos_type end) const
+{
+ LASSERT(start >= 0 && start <= size(), /**/);
+ LASSERT(end > start && end <= size() + 1, /**/);
+
+ return d->changes_.isFullyDeleted(start, end);
+}
+
+
bool Paragraph::isChanged(pos_type start, pos_type end) const
{
LASSERT(start >= 0 && start <= size(), /**/);
column += 17;
break;
- case '*': case '[':
+ case '*':
+ case '[':
+ case ']':
// avoid being mistaken for optional arguments
os << '{';
os.put(c);
// the next two functions are for the manual labels
docstring const Paragraph::getLabelWidthString() const
{
- if (d->layout_->margintype == MARGIN_MANUAL)
+ if (d->layout_->margintype == MARGIN_MANUAL
+ || d->layout_->latextype == LATEX_BIB_ENVIRONMENT)
return d->params_.labelWidthString();
else
return _("Senseless with this layout!");
if (fmt.empty() && layout.labeltype == LABEL_COUNTER
&& !layout.counter.empty())
- fmt = "\\the" + layout.counter;
+ return tclass.counters().theCounter(layout.counter);
// handle 'inherited level parts' in 'fmt',
// i.e. the stuff between '@' in '@Section@.\arabic{subsection}'
}
-pos_type Paragraph::firstWord(odocstream & os, OutputParams const & runparams)
+pos_type Paragraph::firstWordDocBook(odocstream & os, OutputParams const & runparams)
const
{
pos_type i;
}
+pos_type Paragraph::firstWordLyXHTML(odocstream & os, OutputParams const & runparams)
+ const
+{
+ pos_type i;
+ for (i = 0; i < size(); ++i) {
+ if (Inset const * inset = getInset(i)) {
+ inset->xhtml(os, runparams);
+ } else {
+ char_type c = d->text_[i];
+ if (c == ' ')
+ break;
+ os << html::escapeChar(c);
+ }
+ }
+ return i;
+}
+
+
bool Paragraph::Private::onlyText(Buffer const & buf, Font const & outerfont, pos_type initial) const
{
Font font_old;
}
+void Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
+ odocstream & os,
+ OutputParams const & runparams,
+ Font const & outerfont,
+ pos_type initial) const
+{
+ // FIXME We really need to manage the tag nesting here.
+ // Probably in the same sort of way as in output_xhtml.
+ bool emph_flag = false;
+ bool bold_flag = false;
+ std::string closing_tag;
+
+ Layout const & style = *d->layout_;
+ FontInfo font_old =
+ style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
+
+ //if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
+ // os << "]]>";
+
+ // parsing main loop
+ for (pos_type i = initial; i < size(); ++i) {
+ Font font = getFont(buf.params(), i, outerfont);
+
+ // emphasis
+ if (font_old.emph() != font.fontInfo().emph()) {
+ if (font.fontInfo().emph() == FONT_ON) {
+ os << "<em>";
+ emph_flag = true;
+ } else if (emph_flag && i != initial) {
+ os << "</em>";
+ emph_flag = false;
+ }
+ }
+ // bold
+ if (font_old.series() != font.fontInfo().series()) {
+ if (font.fontInfo().series() == BOLD_SERIES) {
+ os << "<strong>";
+ bold_flag = true;
+ } else if (bold_flag && i != initial) {
+ os << "</strong>";
+ bold_flag = false;
+ }
+ }
+ // FIXME Other such tags?
+
+ if (Inset const * inset = getInset(i)) {
+ inset->xhtml(os, runparams);
+ } else {
+ char_type c = d->text_[i];
+
+ if (style.pass_thru)
+ os.put(c);
+ else if (c == '-') {
+ int j = i + 1;
+ if (j < size() && d->text_[j] == '-') {
+ j += 1;
+ if (j < size() && d->text_[j] == '-') {
+ os << from_ascii("—");
+ i += 2;
+ } else {
+ os << from_ascii("–");
+ i += 1;
+ }
+ }
+ else
+ os << c;
+ } else
+ os << html::escapeChar(c);
+ }
+ font_old = font.fontInfo();
+ }
+
+ // FIXME This could be out of order. See above.
+ if (emph_flag)
+ os << "</em>";
+ if (bold_flag)
+ os << "</strong>";
+
+// if (style.free_spacing)
+// os << '\n';
+// if (style.pass_thru && !d->onlyText(buf, outerfont, initial))
+// os << "<![CDATA[";
+}
+
+
bool Paragraph::isHfill(pos_type pos) const
{
Inset const * inset = getInset(pos);
if (Inset const * inset = getInset(pos))
return inset->isLetter();
char_type const c = d->text_[pos];
- return isLetterChar(c) || isDigit(c);
+ // We want to pass the ' and escape chars to the spellchecker
+ static docstring const quote = from_utf8(lyxrc.spellchecker_esc_chars + '\'');
+ return (isLetterChar(c) || isDigit(c) || contains(quote, c))
+ && (!d->inset_owner_ || d->inset_owner_->allowSpellCheck())
+ && pos != size()
+ && !isDeleted(pos);
}
}
+docstring Paragraph::stringify(pos_type beg, pos_type end, int options, OutputParams & runparams) const
+{
+ odocstringstream os;
+
+ if (beg == 0
+ && options & AS_STR_LABEL
+ && !d->params_.labelString().empty())
+ os << d->params_.labelString() << ' ';
+
+ for (pos_type i = beg; i < end; ++i) {
+ char_type const c = d->text_[i];
+ if (isPrintable(c) || c == '\t'
+ || (c == '\n' && options & AS_STR_NEWLINES))
+ os.put(c);
+ else if (c == META_INSET && options & AS_STR_INSETS) {
+ getInset(i)->plaintext(os, runparams);
+ }
+ }
+
+ return os.str();
+}
+
+
void Paragraph::setInsetOwner(Inset const * inset)
{
d->inset_owner_ = inset;
}
-void Paragraph::collectWords(CursorSlice const & sl)
+void Paragraph::locateWord(pos_type & from, pos_type & to,
+ word_location const loc) const
+{
+ switch (loc) {
+ case WHOLE_WORD_STRICT:
+ if (from == 0 || from == size()
+ || !isLetter(from)
+ || !isLetter(from - 1)) {
+ to = from;
+ return;
+ }
+ // no break here, we go to the next
+
+ case WHOLE_WORD:
+ // If we are already at the beginning of a word, do nothing
+ if (!from || !isLetter(from - 1))
+ break;
+ // no break here, we go to the next
+
+ case PREVIOUS_WORD:
+ // always move the cursor to the beginning of previous word
+ while (from && isLetter(from - 1))
+ --from;
+ break;
+ case NEXT_WORD:
+ LYXERR0("Paragraph::locateWord: NEXT_WORD not implemented yet");
+ break;
+ case PARTIAL_WORD:
+ // no need to move the 'from' cursor
+ break;
+ }
+ to = from;
+ while (to < size() && isLetter(to))
+ ++to;
+}
+
+
+void Paragraph::collectWords()
{
- // find new words
- bool inword = false;
+ SpellChecker * speller = theSpellChecker();
//lyxerr << "Words: ";
pos_type n = size();
- for (pos_type pos = 0; pos != n; ++pos) {
- if (isDeleted(pos))
+ for (pos_type pos = 0; pos < n; ++pos) {
+ if (!isLetter(pos))
continue;
-
- if (!isLetter(pos)) {
- inword = false;
+ pos_type from = pos;
+ locateWord(from, pos, WHOLE_WORD);
+ if (!lyxrc.spellcheck_continuously && pos - from < 6)
continue;
- }
- if (inword)
- continue;
+ docstring word = asString(from, pos, false);
+ if (pos - from >= 6)
+ d->words_.insert(word);
- inword = true;
- CursorSlice from = sl;
- CursorSlice to = sl;
- from.pos() = pos;
- to.pos() = pos;
- from.text()->getWord(from, to, WHOLE_WORD);
- if (to.pos() - from.pos() < 6)
+ if (!lyxrc.spellcheck_continuously || !speller)
continue;
- docstring word = asString(from.pos(), to.pos(), false);
- d->words_.insert(word);
+
+ string lang_code = lyxrc.spellchecker_use_alt_lang
+ ? lyxrc.spellchecker_alt_lang
+ : getFontSettings(d->inset_owner_->buffer().params(), from).language()->code();
+ WordLangTuple wl(word, lang_code);
+ SpellChecker::Result res = speller->check(wl);
+ // ... just ignore any error that the spellchecker reports.
+ if (!speller->error().empty())
+ continue;
+ bool const misspelled = res != SpellChecker::OK
+ && res != SpellChecker::IGNORED_WORD;
+ d->fontlist_.setMisspelled(from, pos, misspelled);
+
//lyxerr << word << " ";
}
//lyxerr << std::endl;
}
-void Paragraph::updateWords(CursorSlice const & sl)
+void Paragraph::updateWords()
{
- LASSERT(&sl.paragraph() == this, /**/);
deregisterWords();
- collectWords(sl);
+ collectWords();
registerWords();
}
+
+bool Paragraph::isMisspelled(pos_type pos) const
+{
+ SpellChecker * speller = theSpellChecker();
+ pos_type from = pos;
+ pos_type to = pos;
+ locateWord(from, to, WHOLE_WORD);
+ docstring word = asString(from, to, false);
+ if (!speller)
+ return false;
+
+ string lang_code = lyxrc.spellchecker_use_alt_lang
+ ? lyxrc.spellchecker_alt_lang
+ : getFontSettings(d->inset_owner_->buffer().params(), from).language()->code();
+ WordLangTuple wl(word, lang_code);
+ SpellChecker::Result res = speller->check(wl);
+ // ... just ignore any error that the spellchecker reports.
+ if (!speller->error().empty())
+ return false;
+
+ bool const misspelled = res != SpellChecker::OK
+ && res != SpellChecker::IGNORED_WORD;
+ if (lyxrc.spellcheck_continuously)
+ d->fontlist_.setMisspelled(from, pos, misspelled);
+ return misspelled;
+}
+
+
} // namespace lyx
projects / lyx.git / blobdiff