-/* This file is part of
- * ======================================================
- *
- * LyX, The Document Processor
- *
- * Copyright 2001 The LyX Team.
+/**
+ * \file ControlSpellchecker.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * ======================================================
+ * \author Edwin Leuven
*
- * \file ControlSpellchecker.C
- * \author Edwin Leuven <leuven@fee.uva.nl>
+ * Full author contact details are available in file CREDITS.
*/
#include <config.h>
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
-#ifdef HAVE_SYS_SELECT_H
-# ifdef HAVE_STRINGS_H
- // <strings.h> is needed at least on AIX because FD_ZERO uses bzero().
- // BUT we cannot include both string.h and strings.h on Irix 6.5 :(
-# ifdef _AIX
-# include <strings.h>
-# endif
-# endif
-#include <sys/select.h>
-#endif
+#include "ControlSpellchecker.h"
+#include "ViewBase.h"
#include "buffer.h"
-#include "lyxrc.h"
+#include "bufferparams.h"
#include "BufferView.h"
-#include "LyXView.h"
+#include "bufferview_funcs.h"
+#include "debug.h"
#include "gettext.h"
-#include "support/lstrings.h"
#include "language.h"
+#include "lyxrc.h"
-#include "ViewBase.h"
-#include "ButtonControllerBase.h"
-#include "ControlSpellchecker.h"
-#include "Dialogs.h"
-#include "Liason.h"
+#include "PosIterator.h"
+#include "paragraph.h"
-# include "sp_ispell.h"
+#include "ispell.h"
#ifdef USE_PSPELL
-# include "sp_pspell.h"
+# include "pspell.h"
+#else
+#ifdef USE_ASPELL
+# include "aspell_local.h"
+#endif
#endif
-#include "debug.h"
+#include "support/tostr.h"
+
+#include "frontends/Alert.h"
+
+
+using lyx::support::bformat;
+
+using std::endl;
+using std::string;
-using SigC::slot;
ControlSpellchecker::ControlSpellchecker(LyXView & lv, Dialogs & d)
- : ControlDialog<ControlConnectBD>(lv, d),
- rtl_(false), newval_(0.0), oldval_(0), newvalue_(0), count_(0),
- stop_(false), result_(SpellBase::ISP_OK), speller_(0)
+ : ControlDialogBD(lv, d),
+ oldval_(0), newvalue_(0), count_(0)
+{}
+
+
+ControlSpellchecker::~ControlSpellchecker()
+{}
+
+
+void ControlSpellchecker::setParams()
{
- d_.showSpellchecker.connect(SigC::slot(this, &ControlSpellchecker::show));
+ lyxerr[Debug::GUI] << "spell setParams" << endl;
+ startSession();
}
-void ControlSpellchecker::setParams()
+void ControlSpellchecker::clearParams()
{
- if (!speller_) {
- // create spell object
- string tmp;
-#ifdef USE_PSPELL
- if (lyxrc.use_pspell) {
- tmp = (lyxrc.isp_use_alt_lang) ?
- lyxrc.isp_alt_lang : lv_.buffer()->params.language->code();
-
- speller_ = new PSpell(lv_.view()->buffer()->params, tmp);
- } else {
+ lyxerr[Debug::GUI] << "spell clearParams" << endl;
+ endSession();
+}
+
+
+namespace {
+
+
+SpellBase * getSpeller(BufferParams const & bp)
+{
+ string lang = (lyxrc.isp_use_alt_lang)
+ ? lyxrc.isp_alt_lang
+ : bp.language->code();
+
+#ifdef USE_ASPELL
+ if (lyxrc.use_spell_lib)
+ return new ASpell(bp, lang);
#endif
- tmp = (lyxrc.isp_use_alt_lang) ?
- lyxrc.isp_alt_lang : lv_.buffer()->params.language->lang();
-
- speller_ = new ISpell(lv_.view()->buffer()->params, tmp);
#ifdef USE_PSPELL
- }
+ if (lyxrc.use_spell_lib)
+ return new PSpell(bp, lang);
#endif
-
- if (lyxrc.isp_use_alt_lang) {
- Language const * lang = languages.getLanguage(tmp);
- if (lang)
- rtl_ = lang->RightToLeft();
- } else {
- rtl_ = lv_.buffer()->params.language->RightToLeft();
- }
-
- if (speller_->error() != 0) {
- message_ = speller_->error();
- // show error message
- view().partialUpdate(2);
- clearParams();
- return;
- }
+
+ lang = (lyxrc.isp_use_alt_lang) ?
+ lyxrc.isp_alt_lang : bp.language->lang();
+
+ return new ISpell(bp, lang);
+}
+
+}
+
+
+void ControlSpellchecker::startSession()
+{
+ lyxerr[Debug::GUI] << "spell startSession" << endl;
+
+ if (speller_.get()) {
+ lyxerr[Debug::GUI] << "startSession: speller exists" << endl;
+ speller_.reset(0);
+ return;
}
+
+ speller_.reset(getSpeller(buffer()->params()));
+
+ // reset values to initial
+ oldval_ = 0;
+ newvalue_ = 0;
+ count_ = 0;
+ emergency_exit_ = false;
+
+ // start off the check
+ if (speller_->error().empty()) {
+ check();
+ return;
+ }
+
+ emergency_exit_ = true;
+ string message = speller_->error();
+ if (message.empty())
+ message = _("The spell-checker could not be started.\n"
+ "Maybe it is mis-configured.");
+
+ Alert::error(_("The spell-checker has failed"), message);
+ speller_.reset(0);
}
+void ControlSpellchecker::endSession()
+{
+ lyxerr[Debug::GUI] << "spell endSession" << endl;
+
+ emergency_exit_ = true;
+
+ if (!speller_.get()) {
+ lyxerr[Debug::GUI] << "endSession with no speller" << endl;
+ return;
+ }
+
+ speller_.reset(0);
+}
+
+
+namespace {
+
+
+bool isLetter(PosIterator & cur)
+{
+ return !cur.at_end()
+ && cur.pit()->isLetter(cur.pos())
+ && !isDeletedText(*cur.pit(), cur.pos())
+ && (!cur.inset() || cur.inset()->allowSpellCheck());
+}
+
+
+WordLangTuple nextWord(PosIterator & cur, PosIterator const & end,
+ int & progress, BufferParams & bp)
+{
+ // skip until we have real text (will jump paragraphs)
+ for (; cur != end && !isLetter(cur); ++cur, ++progress);
+
+ if (cur == end)
+ return WordLangTuple(string(), string());
+
+ string lang_code = cur.pit()->getFontSettings(bp, cur.pos()).language()->code();
+ string str;
+ // and find the end of the word (insets like optional hyphens
+ // and ligature break are part of a word)
+ for (; cur != end && isLetter(cur); ++cur, ++progress) {
+ if (!cur.pit()->isInset(cur.pos()))
+ str += cur.pit()->getChar(cur.pos());
+ }
+
+ return WordLangTuple(str, lang_code);
+}
+
+
+} //namespace anon
+
+
+
+
void ControlSpellchecker::check()
{
- result_ = SpellBase::ISP_OK;
- stop_ = false;
-
- while ((result_==SpellBase::ISP_OK || result_==SpellBase::ISP_IGNORE) &&
- !stop_) {
- word_ = lv_.view()->nextWord(newval_);
-
- if (word_.empty()) {
- clearParams();
+ lyxerr[Debug::GUI] << "spell check a word" << endl;
+
+ SpellBase::Result res = SpellBase::OK;
+
+ PosIterator cur(*bufferview());
+ PosIterator const beg = buffer()->pos_iterator_begin();
+ PosIterator const end = buffer()->pos_iterator_end();
+
+ int start = std::distance(beg, cur);
+ int const total = start + std::distance(cur, end);
+
+ if (cur != buffer()->pos_iterator_begin())
+ for (; cur != end && isLetter(cur); ++cur, ++start);
+
+ while (res == SpellBase::OK || res == SpellBase::IGNORE) {
+ word_ = nextWord(cur, end, start, buffer()->params());
+
+ // end of document
+ if (word_.word().empty())
break;
- }
-
+
++count_;
// Update slider if and only if value has changed
- newvalue_ = int(100.0*newval_);
+ float progress = total ? float(start)/total : 1;
+ newvalue_ = int(100.0 * progress);
if (newvalue_!= oldval_) {
+ lyxerr[Debug::GUI] << "Updating spell progress." << endl;
oldval_ = newvalue_;
// set progress bar
- view().partialUpdate(0);
+ view().partialUpdate(SPELL_PROGRESSED);
}
-
- if (!speller_->alive()) clearParams();
-
- result_ = speller_->check(word_);
+
+ // speller might be dead ...
+ if (!checkAlive())
+ return;
+
+ res = speller_->check(word_);
+
+ // ... or it might just be reporting an error
+ if (!checkAlive())
+ return;
+ }
+
+ lyxerr[Debug::GUI] << "Found word \"" << word_.word() << "\"" << endl;
+
+ if (!word_.word().empty()) {
+ int const size = word_.word().size();
+ std::advance(cur, -size);
+ bufferview()->putSelectionAt(cur, size, false);
+ std::advance(cur, size);
+ } else {
+ showSummary();
+ endSession();
+ return;
}
-
- if (!stop_ && !word_.empty())
- lv_.view()->selectLastWord();
// set suggestions
- if (result_!=SpellBase::ISP_OK && result_!=SpellBase::ISP_IGNORE) {
- view().partialUpdate(1);
+ if (res != SpellBase::OK && res != SpellBase::IGNORE) {
+ lyxerr[Debug::GUI] << "Found a word needing checking." << endl;
+ view().partialUpdate(SPELL_FOUND_WORD);
}
}
-void ControlSpellchecker::replace(string const & replacement)
+bool ControlSpellchecker::checkAlive()
{
- lv_.view()->replaceWord(replacement);
- check();
-}
+ if (speller_->alive() && speller_->error().empty())
+ return true;
+ string message = speller_->error();
+ if (message.empty())
+ message = _("The spell-checker has died for some reason.\n"
+ "Maybe it has been killed.");
-void ControlSpellchecker::replaceAll(string const & replacement)
-{
- // TODO: add to list
- replace(replacement);
-}
-
+ view().hide();
+ speller_.reset(0);
-void ControlSpellchecker::insert()
-{
- speller_->insert(word_);
- check();
+ Alert::error(_("The spell-checker has failed"), message);
+ return false;
}
-string ControlSpellchecker::getSuggestion()
+void ControlSpellchecker::showSummary()
{
- // this is needed because string tmp = nextmiss()
- // segfaults when nextMiss is 0
- string tmp;
- char const * w = speller_->nextMiss();
-
- if (w!=0) {
- tmp = w;
- if (rtl_) std::reverse(tmp.begin(), tmp.end());
+ if (!checkAlive() || count_ == 0) {
+ view().hide();
+ return;
}
-
- return tmp;
-}
+ string message;
+ if (count_ != 1)
+ message = bformat(_("%1$s words checked."), tostr(count_));
+ else
+ message = _("One word checked.");
-string ControlSpellchecker::getWord()
-{
- string tmp = word_;
- if (rtl_) std::reverse(tmp.begin(), tmp.end());
- return tmp;
+ view().hide();
+ Alert::information(_("Spell-checking is complete"), message);
}
-void ControlSpellchecker::ignoreAll()
+void ControlSpellchecker::replace(string const & replacement)
{
- speller_->accept(word_);
+ bufferview()->replaceWord(replacement);
+ // fix up the count
+ --count_;
check();
}
-void ControlSpellchecker::stop()
+void ControlSpellchecker::replaceAll(string const & replacement)
{
- stop_ = true;
- lv_.view()->endOfSpellCheck();
+ // TODO: add to list
+ replace(replacement);
}
-void ControlSpellchecker::clearParams()
+void ControlSpellchecker::insert()
{
- if (!speller_) return;
-
- if (speller_->alive()) {
- speller_->close();
- message_ = tostr(count_);
- if (count_ != 1) {
- message_ += _(" words checked.");
+ speller_->insert(word_);
+ check();
+}
- } else {
- message_ += _(" word checked.");
- }
- message_ = "\n" + message_;
- message_ = _("Spellchecking completed! ") + message_;
- } else {
- speller_->cleanUp();
- message_ = _("The spell checker has died for some reason.\n"
- "Maybe it has been killed.");
-
- // make sure that the dialog is not launched
- emergency_exit_ = true;
- }
-
- delete speller_;
-
- lv_.view()->endOfSpellCheck();
+string const ControlSpellchecker::getSuggestion() const
+{
+ return speller_->nextMiss();
+}
- // show closing message
- view().partialUpdate(2);
- // reset values to initial
- rtl_ = false;
- word_ = "";
- newval_ = 0.0;
- oldval_ = 0;
- newvalue_ = 0;
- count_ = 0;
- message_ = "";
- stop_ = false;
- result_ = SpellBase::ISP_OK;
- speller_ = 0;
+string const ControlSpellchecker::getWord() const
+{
+ return word_.word();
}
-void ControlSpellchecker::options()
+void ControlSpellchecker::ignoreAll()
{
- lv_.getDialogs()->showSpellcheckerPreferences();
+ speller_->accept(word_);
+ check();
}