]> git.lyx.org Git - lyx.git/blobdiff - src/Paragraph.cpp
Routines to retrieve HTML style information.
[lyx.git] / src / Paragraph.cpp
index 177e20263388f18897d5cb1ec02df741e43b076a..37d2957f8d8cfa8336a3b20738edc493a688052f 100644 (file)
 #include "output_latex.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"
@@ -50,7 +52,6 @@
 #include "insets/InsetLabel.h"
 
 #include "support/lassert.h"
-#include "support/convert.h"
 #include "support/debug.h"
 #include "support/ExceptionMessage.h"
 #include "support/gettext.h"
@@ -286,6 +287,15 @@ void Paragraph::addChangesToToc(DocIterator const & cdit,
 }
 
 
+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(), /**/);
@@ -817,10 +827,10 @@ void Paragraph::Private::latexInset(
        }
 
        if (close) {
-       if (running_font.language()->lang() == "farsi")
-                       os << "\\endL{}";
-               else
-                       os << '}';
+               if (running_font.language()->lang() == "farsi")
+                               os << "\\endL{}";
+                       else
+                               os << '}';
        }
 
        if (tmp) {
@@ -864,9 +874,15 @@ void Paragraph::Private::latexSpecialChar(
                return;
        }
 
-       if (lyxrc.fontenc == "T1" && latexSpecialT1(c, os, i, column))
+       // If T1 font encoding is used, use the special
+       // characters it provides.
+       // NOTE: some languages reset the font encoding
+       // internally
+       if (!running_font.language()->internalFontEncoding()
+           && lyxrc.fontenc == "T1" && latexSpecialT1(c, os, i, column))
                return;
 
+       // \tt font needs special treatment
        if (running_font.fontInfo().family() == TYPEWRITER_FAMILY
                && latexSpecialTypewriter(c, os, i, column))
                return;
@@ -915,7 +931,9 @@ void Paragraph::Private::latexSpecialChar(
                column += 17;
                break;
 
-       case '*': case '[':
+       case '*':
+       case '[':
+       case ']':
                // avoid being mistaken for optional arguments
                os << '{';
                os.put(c);
@@ -1571,7 +1589,8 @@ docstring const & Paragraph::labelString() const
 // 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!");
@@ -1612,7 +1631,7 @@ docstring Paragraph::expandLabel(Layout const & 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}'
@@ -2342,7 +2361,12 @@ bool Paragraph::isLetter(pos_type pos) const
        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);
 }
 
 
@@ -2440,6 +2464,29 @@ docstring Paragraph::asString(pos_type beg, pos_type end, int options) const
 }
 
 
+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;
@@ -2835,35 +2882,76 @@ void Paragraph::deregisterWords()
 }
 
 
-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;
@@ -2879,12 +2967,39 @@ void Paragraph::registerWords()
 }
 
 
-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