SpellCheck::SpellCheck(QObject *parent) : QObject(parent), config(NULL), spell_checker(NULL) { config = new_aspell_config(); aspell_config_replace(config, "encoding", "utf-8"); aspell_config_replace(config, "personal", (dcpp::Util::getPath(dcpp::Util::PATH_USER_CONFIG)+"dict").c_str()); #if defined(Q_WS_WIN) aspell_config_replace(config, "data-dir", "./aspell/data"); aspell_config_replace(config, "dict-dir", "./aspell/dict"); #endif if (config) { AspellCanHaveError *error = new_aspell_speller(config); if (aspell_error(error)) { delete_aspell_config(config); printf("%s\n", aspell_error_message(error)); config = NULL; } else spell_checker = to_aspell_speller(error); } }
void AspellAdapterImpl::passOptionsToAspellConfig( const boost::program_options::variables_map& options) { if (options.count("limit")) { limitCandidates_ = options["limit"].as<unsigned int>(); } else { limitCandidates_ = 0; } std::list<std::string> stringOptions = boost::assign::list_of (std::string("size")) (std::string("personal")) (std::string("repl")) (std::string("keyboard")) (std::string("sug-mode")) ; BOOST_FOREACH (std::string & optionName, stringOptions) { if (options.count(optionName.c_str())) { std::string optionValue = options[optionName.c_str()].as<std::string>(); aspell_config_replace(aspellConfig_, optionName.c_str(), optionValue.c_str()); } } if (options.count("ignore-case")) { aspell_config_replace(aspellConfig_, "ignore-case", "true"); } if (options.count("ignore")) { int ignoreLength = options["ignore"].as<int>(); std::string ignoreLengthString = boost::lexical_cast<std::string>( ignoreLength); aspell_config_replace(aspellConfig_, "ignore", ignoreLengthString.c_str()); } }
struct spelling * spelling_init(char *lang) { AspellConfig *config; AspellCanHaveError *ret; struct spelling *spelling = malloc(sizeof(struct spelling)); if (spelling == NULL) { warn("malloc(spelling)"); return NULL; } config = new_aspell_config(); aspell_config_replace(config, "lang", spelling_lookup_lang(lang)); aspell_config_replace(config, "dict-dir", bfile("data/dict/")); aspell_config_replace(config, "encoding", "iso-8859-1"); ret = new_aspell_speller(config); delete_aspell_config(config); spelling->speller = to_aspell_speller(ret); if (aspell_error(ret) != 0) { printf("Error: %s\n", aspell_speller_error_message(spelling->speller)); delete_aspell_can_have_error(ret); return NULL; } spelling->conv = iconv_open("iso-8859-1", "utf-8"); spelling->conv_out = iconv_open("utf-8", "iso-8859-1"); return spelling; }
SpellChecker::SpellChecker(QTextEdit *textEdit): m_textEdit(textEdit) { m_regExp = new QRegExp("[^\\s]*"); //m_cursor= new QTextCursor(m_textEdit->document()); spell_config1 = new_aspell_config(); spell_config2 = new_aspell_config(); aspell_config_replace(spell_config1, "lang", m_lang1.toAscii()); aspell_config_replace(spell_config2, "lang", m_lang2.toAscii()); aspell_config_replace(spell_config1, "encoding", "utf-8"); aspell_config_replace(spell_config2, "encoding", "utf-8"); m_map = new StringMap(); m_map->insert("ara", "ar"); m_map->insert("ruseng", "ru"); m_map->insert("rus", "ru"); m_map->insert("bul", "bg"); m_map->insert("cze", "cs"); m_map->insert("dan", "da"); m_map->insert("dut", "nl"); m_map->insert("nld", "nl"); m_map->insert("ell", "el"); m_map->insert("eng", "en"); m_map->insert("est", "et"); m_map->insert("fin", "fi"); m_map->insert("fra", "fr"); m_map->insert("ger", "de"); m_map->insert("deu", "de"); m_map->insert("deu-frak", "de-alt"); m_map->insert("heb", "he"); m_map->insert("hin", "hi"); m_map->insert("hrv", "hr"); m_map->insert("hun", "hu"); m_map->insert("ind", "in"); m_map->insert("isl", "is"); m_map->insert("ita", "it"); m_map->insert("lav", "lv"); m_map->insert("lit", "lt"); m_map->insert("mkd", "mk"); m_map->insert("msa", "ms"); m_map->insert("nor", "no"); m_map->insert("pol", "pl"); m_map->insert("por", "pt_PT"); m_map->insert("rum", "ro"); //m_map->insert("rus", "ru"); m_map->insert("ron", "ro"); m_map->insert("slo", "sl"); m_map->insert("slk", "sk"); m_map->insert("spa", "es"); m_map->insert("srp", "sr"); m_map->insert("swa", "sw"); m_map->insert("swe", "sv"); m_map->insert("swef", "sv"); m_map->insert("tur", "tr"); m_map->insert("ukr", "uk"); m_map->insert("vie", "vi"); spell_checker1 = 0; spell_checker2 = 0; setLanguage("ruseng"); dictList = new QStringList(); }
AspellSpeller * weechat_aspell_speller_new (const char *lang) { AspellConfig *config; AspellCanHaveError *ret; AspellSpeller *new_speller; struct t_infolist *infolist; if (!lang) return NULL; if (weechat_aspell_plugin->debug) { weechat_printf (NULL, "%s: creating new speller for lang \"%s\"", ASPELL_PLUGIN_NAME, lang); } /* create a speller instance for the newly created cell */ config = new_aspell_config(); aspell_config_replace (config, "lang", lang); /* apply all options on speller */ infolist = weechat_infolist_get ("option", NULL, "aspell.option.*"); if (infolist) { while (weechat_infolist_next (infolist)) { aspell_config_replace (config, weechat_infolist_string (infolist, "option_name"), weechat_infolist_string (infolist, "value")); } weechat_infolist_free (infolist); } ret = new_aspell_speller (config); if (aspell_error (ret) != 0) { weechat_printf (NULL, "%s%s: error: %s", weechat_prefix ("error"), ASPELL_PLUGIN_NAME, aspell_error_message (ret)); delete_aspell_config (config); delete_aspell_can_have_error (ret); return NULL; } new_speller = to_aspell_speller (ret); weechat_hashtable_set (weechat_aspell_spellers, lang, new_speller); /* free configuration */ delete_aspell_config (config); return new_speller; }
ASpellChecker::ASpellChecker() : config_(new_aspell_config()) { aspell_config_replace(config_, "encoding", "utf-8"); #ifdef Q_OS_WIN aspell_config_replace(config_, "conf-dir", QDir::homePath().toLocal8Bit().data()); aspell_config_replace(config_, "data-dir", QString("%1/aspell").arg(QCoreApplication::applicationDirPath()).toLocal8Bit().data()); aspell_config_replace(config_, "dict-dir", QString("%1/aspell").arg(QCoreApplication::applicationDirPath()).toLocal8Bit().data()); #endif setActiveLanguages(getAllLanguages()); }
bool SpellChecker::addCheckedLang(QString &name) { if (checkers.find(name) != checkers.end()) return true; aspell_config_replace(spellConfig, "lang", name.toAscii()); // create spell checker using prepared configuration AspellCanHaveError* possibleErr = new_aspell_speller(spellConfig); if (aspell_error_number(possibleErr) != 0) { MessageBox::msg(aspell_error_message(possibleErr)); return false; } else checkers[name] = to_aspell_speller(possibleErr); if (checkers.size() == 1) { foreach(ChatWidget *chat, ChatWidgetManager::instance()->chats()) chatCreated(chat); } return true; }
bool KAspellChecker::init() { QString locale = QString(QLocale::system().name()).left(2); if (locale.length() < 2) locale = "en"; AspellConfig * config = new_aspell_config(); aspell_config_replace(config, "lang", locale.toLocal8Bit().data()); AspellCanHaveError * ret = new_aspell_speller(config); delete_aspell_config(config); if (aspell_error(ret) != 0) { qDebug("Error: %s\n",aspell_error_message(ret)); delete_aspell_can_have_error(ret); return false; } m_speller = to_aspell_speller(ret); config = aspell_speller_config(m_speller); qDebug() << "USING LANG= " << aspell_config_retrieve(config, "lang"); return true; }
SpellCheck::SpellCheck(QObject *parent) : QObject(parent), config(NULL), spell_checker(NULL) { config = new_aspell_config(); aspell_config_replace(config, "encoding", "utf-8"); aspell_config_replace(config, "personal", (QDir::homePath()+QDir::separator()+".eiskaltdc++"+QDir::separator()+"dict").toAscii().constData()); if (config){ /*const AspellDictInfoList *dicts = get_aspell_dict_info_list(config); AspellDictInfoEnumeration *enumer = aspell_dict_info_list_elements(dicts); const AspellDictInfo *info = NULL; QStringList all; while ((info = aspell_dict_info_enumeration_next(enumer)) != NULL) all.append(QString::fromUtf8(info->code, strlen(info->code))); if (WSGET(WS_APP_ASPELL_LANG).isEmpty()){ QString lc_prefix = QLocale::system().name(); if (all.contains(lc_prefix))//Loading dictionary from system locale aspell_config_replace(config, "lang", lc_prefix.toAscii().constData()); else if (all.contains(lc_prefix.left(lc_prefix.indexOf("_")))) { aspell_config_replace(config, "lang", lc_prefix.left(lc_prefix.indexOf("_")).toAscii().constData()); } } else aspell_config_replace(config, "lang", WSGET(WS_APP_ASPELL_LANG).toAscii().constData());*/ AspellCanHaveError *error = new_aspell_speller(config); if (aspell_error(error) != 0){ delete_aspell_config(config); printf("%s\n", aspell_error_message(error)); config = NULL; } else spell_checker = to_aspell_speller(error); } }
ASpellChecker::ASpellChecker() { config_ = NULL; speller_ = NULL; config_ = new_aspell_config(); aspell_config_replace(config_, "encoding", "utf-8"); #ifdef Q_WS_WIN aspell_config_replace(config_, "conf-dir", QDir::homeDirPath()); aspell_config_replace(config_, "data-dir", QString("%1/aspell/data").arg(QCoreApplication::applicationDirPath())); aspell_config_replace(config_, "dict-dir", QString("%1/aspell/dict").arg(QCoreApplication::applicationDirPath())); #endif AspellCanHaveError* ret = new_aspell_speller(config_); if (aspell_error_number(ret) == 0) { speller_ = to_aspell_speller(ret); } else { qWarning(QString("Aspell error: %1").arg(aspell_error_message(ret)).toAscii()); } }
/** * Set a specific option, that is known by aspell. * @param config the config object of a specific spellchecker. * @param key the option to set (eg: lang). * @param value the value of the option to set (eg: "us_US"). * @exception Exception if key not known, or value undefined. */ static void set_option(AspellConfig *config, char *key, char *value) { //printf("set option: %s = %s\n", key, value); if (aspell_config_replace(config, key, value) == 0) { rb_raise(cAspellError, "%s", aspell_config_error_message(config)); } //check config: if (aspell_config_error(config) != 0) { rb_raise(cAspellError, "%s", aspell_config_error_message(config)); } }
SpellChecker::SpellChecker() { connect(ChatWidgetManager::instance(), SIGNAL(chatWidgetCreated(ChatWidget *)), this, SLOT(chatCreated(ChatWidget *))); // prepare configuration of spellchecker spellConfig = new_aspell_config(); aspell_config_replace(spellConfig, "encoding", "utf-8"); createDefaultConfiguration(); // load mark settings buildMarkTag(); }
SpellChecker::SpellChecker( QObject * parent ) : QObject(parent) { m_spell_config_ru = new_aspell_config(); aspell_config_replace(m_spell_config_ru, "dict-dir", "./dict"); aspell_config_replace(m_spell_config_ru, "encoding", "utf-8"); aspell_config_replace(m_spell_config_ru, "lang", "ru"); AspellCanHaveError * possible_err = new_aspell_speller(m_spell_config_ru); m_spell_checker_ru = 0; if (aspell_error_number(possible_err) != 0){ puts(aspell_error_message(possible_err)); } else{ m_spell_checker_ru = to_aspell_speller(possible_err); } m_spell_config_en = new_aspell_config(); aspell_config_replace(m_spell_config_en, "dict-dir", "./dict"); aspell_config_replace(m_spell_config_en, "encoding", "utf-8"); aspell_config_replace(m_spell_config_en, "lang", "en"); possible_err = new_aspell_speller(m_spell_config_en); m_spell_checker_en = 0; if (aspell_error_number(possible_err) != 0){ puts(aspell_error_message(possible_err)); } else{ m_spell_checker_en = to_aspell_speller(possible_err); } m_codec = QTextCodec::codecForName("UTF-8"); }
static gboolean gtkspell_set_language_internal(GtkSpell *spell, const gchar *lang, GError **error) { AspellConfig *config; AspellCanHaveError *err; if (lang == NULL) { lang = g_getenv("LANG"); if (lang) { if (g_strncasecmp(lang, "C", 1) == 0) lang = NULL; else if (lang[0] == 0) lang = NULL; } } config = new_aspell_config(); if (lang) aspell_config_replace(config, "language-tag", lang); aspell_config_replace(config, "encoding", "utf-8"); err = new_aspell_speller(config); delete_aspell_config(config); if (aspell_error_number(err) != 0) { #ifdef USING_ASPELL g_set_error(error, GTKSPELL_ERROR, GTKSPELL_ERROR_BACKEND, "aspell: %s", aspell_error_message(err)); #elif defined USING_PSPELL g_set_error(error, GTKSPELL_ERROR, GTKSPELL_ERROR_BACKEND, "pspell: %s", aspell_error_message(err)); #endif return FALSE; } if (spell->speller) delete_aspell_speller(spell->speller); spell->speller = to_aspell_speller(err); return TRUE; }
//__________________________________________________________________________ void Speller::Aspell::Suggest::setConfigOpt(const std::string& opt, const std::string& val) throw( std::invalid_argument ) { aspell_config_replace( fconfig, opt.c_str(), val.c_str() ); try { checkConfigError(); } catch( const std::invalid_argument& err ) { throw err; } }
bool SpellChecker::buildCheckers() { foreach(AspellSpeller *speller, checkers.values()) delete_aspell_speller(speller); checkers.clear(); // load languages to check from configuration QString checkedStr = config_file.readEntry("ASpell", "Checked", "pl"); QStringList checkedList = checkedStr.split(',', QString::SkipEmptyParts); if (config_file.readBoolEntry("ASpell", "Accents", false)) aspell_config_replace(spellConfig, "ignore-accents", "true"); else aspell_config_replace(spellConfig, "ignore-accents", "false"); if (config_file.readBoolEntry( "ASpell", "Case", false)) aspell_config_replace(spellConfig, "ignore-case", "true"); else aspell_config_replace(spellConfig, "ignore-case", "false"); // create aspell checkers for each language for (unsigned int i = 0; i < checkedList.count(); i++) { addCheckedLang(checkedList[i]); /* if ( !addCheckedLang( checkedList[i] ) ) { delete_aspell_config( spellConfig ); delete config; return false; } */ } return true; }
void initAspell() { spell_config = new_aspell_config(); aspell_config_replace(spell_config, "lang", "en_US"); //set language possible_err = new_aspell_speller(spell_config); spell_checker = 0; if (aspell_error_number(possible_err) != 0) { printf("%s ", aspell_error_message(possible_err)); } else { printf("Unscrambled words:\n"); spell_checker = to_aspell_speller(possible_err); } }
void ASpellChecker::setActiveLanguages(const QList<QString>& langs) { clearSpellers(); foreach(const QString& lang, langs) { AspellConfig* conf = aspell_config_clone(config_); aspell_config_replace(conf, "lang", lang.toUtf8().constData()); AspellCanHaveError* ret = new_aspell_speller(conf); if (aspell_error_number(ret) == 0) { spellers_.append(to_aspell_speller(ret)); } else { qDebug() << QString("Aspell error: %1").arg(aspell_error_message(ret)); } delete_aspell_config(conf); }
bool AspellAdapterImpl::isDictionaryAvailable(const std::string & langCode) { AspellConfig * tempAspellConfig = new_aspell_config(); aspell_config_replace(tempAspellConfig, "lang", langCode.c_str()); AspellCanHaveError * possibleError = new_aspell_speller(tempAspellConfig); bool result = true; if (aspell_error_number(possibleError) != 0) { result = false; } else { AspellSpeller * tempSpeller = to_aspell_speller(possibleError); delete_aspell_speller(tempSpeller); } delete_aspell_config(tempAspellConfig); return result; }
void ASpellChecker::setActiveLanguages(const QSet<LanguageManager::LangId>& langs) { clearSpellers(); for(auto const &lang: langs) { AspellConfig* conf = aspell_config_clone(config_); aspell_config_replace(conf, "lang", LanguageManager::toString(lang) .replace(QLatin1Char('-'),QLatin1Char('_')).toUtf8().constData()); AspellCanHaveError* ret = new_aspell_speller(conf); if (aspell_error_number(ret) == 0) { spellers_.append(to_aspell_speller(ret)); } else { qDebug() << QString("Aspell error: %1").arg(aspell_error_message(ret)); } delete_aspell_config(conf); } }
/** * Create a spell checker for a language * @param language the language code e.g. en_GB or it * @return a checker or NULL */ static checker *checker_create( const char *language ) { int err = 0; checker *c = calloc( 1, sizeof(checker) ); if ( c != NULL ) { strncpy(c->lang,language,24); c->spell_config = new_aspell_config(); if ( c->spell_config != NULL ) { aspell_config_replace( c->spell_config, "lang", language ); AspellCanHaveError *possible_err = new_aspell_speller(c->spell_config); c->spell_checker = 0; if (aspell_error_number(possible_err) != 0) { fprintf(stderr,"%s\n",aspell_error_message(possible_err)); err = 1; } else { c->spell_checker = to_aspell_speller(possible_err); if ( c->spell_checker == NULL ) { fprintf(stderr,"checker: failed to initialise speller\n"); err = 1; } } if ( err ) { checker_dispose( c ); c = NULL; } } else fprintf(stderr,"checker: failed to create speller\n"); } else fprintf(stderr,"checker: failed to create object\n"); return c; }
/** * create a neew spell-checker for the language 'lang' */ void * spellcheck_create(const char * lang) { struct linkgrammar_aspell *aspell = NULL; size_t i = 0; AspellCanHaveError *spell_err = NULL; for (i = 0; i < sizeof(spellcheck_lang_mapping)/sizeof(char *); i += 2) { if (0 != strcmp(lang, spellcheck_lang_mapping[i])) continue; aspell = (struct linkgrammar_aspell *)malloc(sizeof(struct linkgrammar_aspell)); if (!aspell) { prt_error("Error: out of memory. Aspell not used.\n"); aspell = NULL; break; } aspell->config = NULL; aspell->speller = NULL; aspell->config = new_aspell_config(); if (aspell_config_replace(aspell->config, ASPELL_LANG_KEY, spellcheck_lang_mapping[i]) == 0) { prt_error("Error: failed to set language in aspell: %s\n", lang); delete_aspell_config(aspell->config); free(aspell); aspell = NULL; break; } spell_err = new_aspell_speller(aspell->config); if (aspell_error_number(spell_err) != 0) { prt_error("Error: Aspell: %s\n", aspell_error_message(spell_err)); delete_aspell_can_have_error(spell_err); delete_aspell_config(aspell->config); free(aspell); aspell = NULL; break; } aspell->speller = to_aspell_speller(spell_err); break; } return aspell; }
int SpellerConfig::setKey(const char *key, const char *val) { if (cfg == NULL) return -1; return aspell_config_replace(cfg, key, val); }
static int get_aspell_hits(const char *word, int len) { if (len < 2) { log_message(DEBUG, " [-]Skip aspell checking (word is very short)"); return NO_LANGUAGE; } AspellConfig *spell_config = new_aspell_config(); for (int lang = 0; lang < xconfig->total_languages; lang++) { char *lang_word = (char *) malloc(1 * sizeof(char)); if (lang_word == NULL) continue; lang_word[0] = NULLSYM; for (int i = 0; i < len; i++) { KeyCode kc; int modifier; main_window->xkeymap->char_to_keycode(main_window->xkeymap, word[i], &kc, &modifier); char *symbol = keycode_to_symbol(kc, lang, modifier); if ((symbol == NULL) || (lang_word == NULL)) continue; lang_word = (char *) realloc(lang_word, (strlen(lang_word) + strlen(symbol) + 1) * sizeof(char)); if (lang_word != NULL) strcat(lang_word, symbol); free(symbol); } if (lang_word == NULL) continue; aspell_config_replace(spell_config, "lang", xconfig->languages[lang].dir); AspellCanHaveError *possible_err = new_aspell_speller(spell_config); AspellSpeller *spell_checker = 0; if (aspell_error_number(possible_err) == 0) { spell_checker = to_aspell_speller(possible_err); int correct = aspell_speller_check(spell_checker, lang_word, strlen(lang_word)); if (correct) { log_message(DEBUG, " [+]Found this word in %s aspell dictionary", xconfig->get_lang_name(xconfig, lang)); delete_aspell_speller(spell_checker); free(lang_word); return lang; } } else { log_message(DEBUG, " [!]Error aspell checking for %s aspell dictionary", xconfig->get_lang_name(xconfig, lang)); } delete_aspell_speller(spell_checker); free(lang_word); } log_message(DEBUG, " [-]This word has no hits for all aspell dictionaries"); return NO_LANGUAGE; }
/* Create a new speller *******************************************************/ static PyObject* new_speller(PyObject* self, PyObject* args) { aspell_AspellObject* newobj; AspellSpeller* speller = 0; AspellConfig* config; AspellCanHaveError* possible_error; int i; int n; /* arg count */ char *key, *value; config = new_aspell_config(); if (config == NULL) { PyErr_SetString(_AspellModuleException, "can't create config"); return NULL; } /* check constructor arguments */ n = PyTuple_Size(args); switch (n) { case 0: /* no arguments passed */ break; case 2: /* constructor is called with single pair: key & value */ if (PyArg_ParseTuple(args, "ss", &key, &value)) { if (!aspell_config_replace(config, key, value)) { PyErr_SetString(_AspellConfigException, aspell_config_error_message(config)); goto arg_error; } break; } PyErr_Clear(); default: /* list of tuples key&value */ for (i=0; i<n; i++) { if (!PyArg_ParseTuple(PyTuple_GetItem(args, i), "ss", &key, &value)) { PyErr_Format(PyExc_TypeError, "argument %d: tuple of two strings (key, value) expeced", i); goto arg_error; } if (!aspell_config_replace(config, key, value)) { PyErr_SetString(_AspellConfigException, aspell_config_error_message(config)); goto arg_error; } } Py_DECREF(args); break; } /* try to create a new speller */ possible_error = new_aspell_speller(config); delete_aspell_config(config); if (aspell_error_number(possible_error) == 0) /* save a speller */ speller = to_aspell_speller(possible_error); else { /* or raise an exception */ PyErr_SetString(_AspellSpellerException, aspell_error_message(possible_error)); delete_aspell_can_have_error(possible_error); return NULL; } /* create a new py-object */ newobj = (aspell_AspellObject*)PyObject_New(aspell_AspellObject, &aspell_AspellType); newobj->speller = speller; return (PyObject*)newobj; /* argument error: before return NULL we need to delete speller's config we've created */ arg_error: delete_aspell_config(config); return NULL; }
AspellSpeller * #endif /* USE_ENCHANT */ weechat_aspell_speller_new (const char *lang) { #ifdef USE_ENCHANT EnchantDict *new_speller; #else AspellConfig *config; AspellCanHaveError *ret; AspellSpeller *new_speller; #endif /* USE_ENCHANT */ struct t_infolist *infolist; if (!lang) return NULL; if (weechat_aspell_plugin->debug) { weechat_printf (NULL, "%s: creating new speller for lang \"%s\"", ASPELL_PLUGIN_NAME, lang); } #ifdef USE_ENCHANT new_speller = enchant_broker_request_dict (broker, lang); if (!new_speller) { weechat_printf (NULL, _("%s%s: error: unable to create speller for lang \"%s\""), weechat_prefix ("error"), ASPELL_PLUGIN_NAME, lang); return NULL; } #else /* create a speller instance for the newly created cell */ config = new_aspell_config (); aspell_config_replace (config, "lang", lang); #endif /* USE_ENCHANT */ /* apply all options */ infolist = weechat_infolist_get ("option", NULL, "aspell.option.*"); if (infolist) { while (weechat_infolist_next (infolist)) { #ifdef USE_ENCHANT /* TODO: set option with enchant */ #else aspell_config_replace (config, weechat_infolist_string (infolist, "option_name"), weechat_infolist_string (infolist, "value")); #endif /* USE_ENCHANT */ } weechat_infolist_free (infolist); } #ifndef USE_ENCHANT ret = new_aspell_speller (config); if (aspell_error (ret) != 0) { weechat_printf (NULL, "%s%s: error: %s", weechat_prefix ("error"), ASPELL_PLUGIN_NAME, aspell_error_message (ret)); delete_aspell_config (config); delete_aspell_can_have_error (ret); return NULL; } new_speller = to_aspell_speller (ret); #endif /* USE_ENCHANT */ weechat_hashtable_set (weechat_aspell_spellers, lang, new_speller); #ifndef USE_ENCHANT /* free configuration */ delete_aspell_config (config); #endif /* USE_ENCHANT */ return new_speller; }
void SpellChecker::setLanguage(const QString &lang) { if (lang.isEmpty()) return; delete_aspell_speller(spell_checker1); delete_aspell_speller(spell_checker2); bad_language.clear(); m_lang2 = "en"; m_lang1 = m_map->value(lang, QString("en")); if (lang.contains("+")) { QStringList sl = lang.split("+"); m_lang1 = m_map->value(sl[0], QString("en")); m_lang2 = m_map->value(sl[1], QString("en")); if ((m_lang1 == "deu")||(lang == "ger")) { m_lang1 = "de_DE"; } if ((m_lang2 == "deu")||(lang == "ger")) { m_lang2 = "de_DE"; } } if (lang == "rus_fra") { m_lang1 = "ru"; m_lang2 = "fr"; } else if (lang == "rus_ger") { m_lang1 = "ru"; m_lang2 = "de"; } else if (lang == "rus_spa") { m_lang1 = "ru"; m_lang2 = "es"; } if ((lang == "deu")||(lang == "ger")) { m_lang1 = "de_DE"; m_lang2 = "de_AT"; } if (lang == "ruseng") { m_lang1 = "ru"; m_lang2 = "en"; } aspell_config_replace(spell_config1, "lang", m_lang1.toAscii()); aspell_config_replace(spell_config2, "lang", m_lang2.toAscii()); AspellCanHaveError *possible_err = new_aspell_speller(spell_config1); spell_checker1 = 0; if (aspell_error_number(possible_err) == 0) spell_checker1 = to_aspell_speller(possible_err); else delete_aspell_can_have_error(possible_err); possible_err = new_aspell_speller(spell_config2); spell_checker2 = 0; if (aspell_error_number(possible_err) == 0) spell_checker2 = to_aspell_speller(possible_err); else delete_aspell_can_have_error(possible_err); // Check absent dictionary if (spell_checker1 == 0) bad_language = m_lang1; if (spell_checker2 == 0) bad_language = m_lang2; }
/** * Create a userdata object * @param language the language e.g. "en_GB" * @param rules recipe file path to recipe file * @param fmt the format object containing function pointers * @return a complete userdata object or NULL */ userdata *userdata_create( const char *language, char *barefile, recipe *rules, format *fmt, hh_exceptions *hhe ) { int err = 0; userdata *u = calloc( 1, sizeof(userdata) ); if ( u != NULL ) { u->rules = rules; if ( hhe != NULL ) u->hhe = hhe; u->spell_config = new_aspell_config(); if ( u->spell_config != NULL ) { aspell_config_replace( u->spell_config, "lang", language ); AspellCanHaveError *possible_err = new_aspell_speller(u->spell_config); u->spell_checker = 0; if (aspell_error_number(possible_err) != 0) { fprintf(stderr,"%s\n",aspell_error_message(possible_err)); err = 1; } else { u->spell_checker = to_aspell_speller(possible_err); if ( u->spell_checker == NULL ) { fprintf(stderr,"userdata: failed to initialise speller\n"); err = 1; } } u->range_stack = stack_create(); if ( u->range_stack == NULL ) { err = 1; fprintf(stderr, "stripper: failed to allocate store for range stack" ); } u->ignoring = stack_create(); if ( u->ignoring == NULL ) { err = 1; fprintf(stderr, "stripper: failed to allocate store for ignore stack" ); } if ( !open_dest_files(u,barefile,fmt) ) { err = 1; fprintf(stderr,"stripper: couldn't open dest files\n"); } } else { fprintf(stderr, "userdata: failed to initialise speller\n"); err = 1; } } else fprintf(stderr, "userdata:failed to allocate object\n"); if ( err ) { userdata_dispose( u ); u = NULL; } return u; }
StyleDialog::StyleDialog ( wxWindow *parent, wxIcon icon, const std::string& bufferParameterUtf8, const wxString& fileNameParameter, const wxString& ruleSetDirectoryParameter, const wxString& filterDirectoryParameter, const wxString& ruleSetPresetParameter, const wxString& filterPresetParameter, #if !defined(USE_ENCHANT) && defined(__WXMSW__) const wxString& aspellDataPathParameter, const wxString& aspellDictPathParameter, #endif int typeParameter, bool readOnlyParameter, wxPoint position, wxSize size ) : wxDialog ( parent, wxID_ANY, wxString ( ( typeParameter == ID_TYPE_STYLE) ? _ ( "Style" ) : _ ( "Spelling" ) ), position, size, wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxMAXIMIZE_BOX ), indexForContextMenu ( -1 ), bufferUtf8 ( bufferParameterUtf8 ), #if !defined(USE_ENCHANT) && defined(__WXMSW__) aspellDataPath ( aspellDataPathParameter ), aspellDictPath ( aspellDictPathParameter ), #endif fileName ( fileNameParameter ), ruleSetDirectory ( ruleSetDirectoryParameter ), filterDirectory ( filterDirectoryParameter ), ruleSetPreset ( ruleSetPresetParameter ), filterPreset ( filterPresetParameter ), type(typeParameter), readOnly ( readOnlyParameter ) { SetIcon ( icon ); // top box ruleSetCombo = new wxComboBox ( this, ID_STYLE_COMBO_RULESET, _T ( "" ), wxDefaultPosition, wxSize ( 200, -1 ) ); int width, height; ruleSetCombo->GetSize ( &width, &height ); wxSize buttonSize ( 100, height ); filterCombo = new wxComboBox ( this, ID_STYLE_COMBO_FILTER, _T ( "" ), wxDefaultPosition, wxSize ( 200, -1 ) ); //if (type != ID_TYPE_STYLE) // from v. 1.1.0.7: never show filterCombo->Show ( false ); wxButton *createReportButton = new wxButton ( this, ID_STYLE_REPORT, _ ( "&Check" ), wxDefaultPosition, buttonSize, 0 ); wxBoxSizer *comboSizer = new wxBoxSizer ( wxHORIZONTAL ); comboSizer->Add ( ruleSetCombo, 0, wxRIGHT, 10 ); comboSizer->Add ( filterCombo, 0, wxRIGHT, 10 ); comboSizer->Add ( createReportButton, 0, wxRIGHT, 10 ); // middle box wxListCtrl *myTable = new wxListCtrl ( this, ID_STYLE_TABLE, wxPoint ( 0, 0 ), wxSize ( -1, -1 ), wxLC_REPORT ); int widthUnit = 35; myTable->InsertColumn ( 0, _ ( "No." ), wxLIST_FORMAT_LEFT, widthUnit * 1 ); myTable->InsertColumn ( 1, _ ( "Context" ), wxLIST_FORMAT_RIGHT, widthUnit * 3 ); myTable->InsertColumn ( 2, _ ( "Error" ), wxLIST_FORMAT_CENTER, widthUnit * 3 ); myTable->InsertColumn ( 3, _ ( "Context" ), wxLIST_FORMAT_LEFT, widthUnit * 3 ); myTable->InsertColumn ( 4, _ ( "Suggestion" ), wxLIST_FORMAT_LEFT, widthUnit * 3 ); myTable->InsertColumn ( 5, _ ( "Rule" ), wxLIST_FORMAT_LEFT, widthUnit * 3 ); myTable->InsertColumn ( 6, _ ( "Action" ), wxLIST_FORMAT_LEFT, widthUnit * 3 ); table = myTable; // lower box wxButton *editItemsButton = new wxButton ( this, ID_STYLE_EDIT, _ ( "&Apply changes" ), wxDefaultPosition, wxSize ( -1, buttonSize.GetHeight() ), 0 ); wxButton *webReportButton = new wxButton ( this, ID_STYLE_WEB_REPORT, _ ( "&Printable report" ), wxDefaultPosition, wxSize ( -1, buttonSize.GetHeight() ), 0 ); wxButton *webSummaryButton = new wxButton ( this, ID_STYLE_WEB_SUMMARY, _ ( "Pr&intable summary" ), wxDefaultPosition, wxSize ( -1, buttonSize.GetHeight() ), 0 ); wxButton *selectAllButton = new wxButton ( this, ID_STYLE_CHANGE_ALL, _ ( "C&hange all" ), wxDefaultPosition, wxSize ( -1, buttonSize.GetHeight() ), 0 ); wxButton *deselectAllButton = new wxButton ( this, ID_STYLE_IGNORE_ALL, _ ( "I&gnore all" ), wxDefaultPosition, wxSize ( -1, buttonSize.GetHeight() ), 0 ); wxButton *cancelButton = new wxButton ( this, wxID_CANCEL, _ ( "Ca&ncel" ), wxDefaultPosition, wxSize ( -1, buttonSize.GetHeight() ), 0 ); wxBoxSizer *reportButtonSizer = new wxBoxSizer ( wxHORIZONTAL ); reportButtonSizer->Add ( editItemsButton, 0, wxRIGHT, 10 ); reportButtonSizer->Add ( webReportButton, 0, wxLEFT | wxRIGHT, 10 ); reportButtonSizer->Add ( webSummaryButton, 0, wxRIGHT, 10 ); reportButtonSizer->Add ( selectAllButton, 0, wxLEFT | wxRIGHT, 10 ); reportButtonSizer->Add ( deselectAllButton, 0, wxRIGHT, 10 ); reportButtonSizer->Add ( cancelButton, 0, wxLEFT, 10 ); // status bar status = new wxStatusBar ( this, wxID_ANY ); // overall sizer wxBoxSizer *reportTopSizer = new wxBoxSizer ( wxVERTICAL ); reportTopSizer->Add ( comboSizer, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5 ); reportTopSizer->Add ( table, 1, wxEXPAND | wxALL, 5 ); reportTopSizer->Add ( reportButtonSizer, 0, wxALL, 5 ); reportTopSizer->Add ( status, 0, wxEXPAND | wxALL ); this->SetSizer ( reportTopSizer ); createReportButton->SetFocus(); if ( readOnly ) filterCombo->Enable ( false ); // keyboard shortcuts wxAcceleratorEntry entries[7]; entries[0].Set ( wxACCEL_ALT, ( int ) 'C', ID_STYLE_REPORT ); entries[1].Set ( wxACCEL_ALT, ( int ) 'A', ID_STYLE_EDIT ); entries[2].Set ( wxACCEL_ALT, ( int ) 'W', ID_STYLE_WEB_REPORT ); entries[3].Set ( wxACCEL_ALT, ( int ) 'B', ID_STYLE_WEB_SUMMARY ); entries[4].Set ( wxACCEL_ALT, ( int ) 'H', ID_STYLE_CHANGE_ALL ); entries[5].Set ( wxACCEL_ALT, ( int ) 'I', ID_STYLE_IGNORE_ALL ); entries[6].Set ( wxACCEL_ALT, ( int ) 'N', wxID_CANCEL ); wxAcceleratorTable accel ( 7, entries ); this->SetAcceleratorTable ( accel ); // update combo lists // special case spellcheck if (type == ID_TYPE_SPELL) { #ifdef USE_ENCHANT EnchantBroker *broker = enchant_broker_init(); dictdetect adetected(ruleSetCombo); enchant_broker_list_dicts(broker, EnchantDictDescribe, &adetected); bool anyFound = !adetected.empty(); #else AspellConfig *config; AspellDictInfoList *dlist; AspellDictInfoEnumeration *dels; const AspellDictInfo *entry; config = new_aspell_config(); #ifdef __WXMSW__ aspell_config_replace ( config, "data-dir", aspellDataPath.mb_str() ); //ASPELL_DATA_PATH ); aspell_config_replace ( config, "dict-dir", aspellDictPath.mb_str() ); //ASPELL_DICT_PATH ); #endif dlist = get_aspell_dict_info_list( config ); delete_aspell_config ( config ); dels = aspell_dict_info_list_elements ( dlist ); bool anyFound = false; while ( ( entry = aspell_dict_info_enumeration_next ( dels ) ) != 0 ) { anyFound = true; std::string stdEntry = entry->name; wxString entry = wxString ( stdEntry.c_str(), wxConvUTF8, stdEntry.size() ); ruleSetCombo->Append ( entry ); } #endif if ( anyFound ) { if ( ruleSetPreset.empty() ) ruleSetPreset = _ ( "en_US" ); ruleSetCombo->SetValue ( ruleSetPreset ); } else { ruleSetCombo->Append ( _ ( "(No dictionaries found)" ) ); ruleSetCombo->Select ( 0 ); createReportButton->Enable ( false ); } return; } // all other branches if ( wxDirExists ( ruleSetDirectory ) ) { wxString ruleMask, ruleFile; ruleMask = ruleSetDirectory + wxFileName::GetPathSeparator() + _T ( "*.xml" ); ruleFile = wxFindFirstFile ( ruleMask, wxFILE ); if ( !ruleFile.empty() ) { ruleFile.Replace ( _T ( ".xml" ), _T ( "" ) ); ruleFile.Replace ( _T ( "_" ), _T ( " " ) ); ruleSetCombo->Append ( wxFileNameFromPath ( ruleFile ) ); for ( ;; ) { ruleFile = wxFindNextFile(); if ( ruleFile.empty() ) break; ruleFile.Replace ( _T ( ".xml" ), _T ( "" ) ); ruleFile.Replace ( _T ( "_" ), _T ( " " ) ); ruleSetCombo->Append ( wxFileNameFromPath ( ruleFile ) ); } } if ( ruleSetPreset.empty() ) ruleSetPreset = _ ( "Default" ); ruleSetCombo->SetValue ( ruleSetPreset ); } else { ruleSetCombo->Append ( _ ( "(No rule sets found)" ) ); ruleSetCombo->Select ( 0 ); } if ( wxDirExists ( filterDirectory ) ) { filterCombo->Append ( _ ( "(No filter)" ) ); wxString filterMask, filterFile; filterMask = filterDirectory + wxFileName::GetPathSeparator() + _T ( "*.xml" ); filterFile = wxFindFirstFile ( filterMask, wxFILE ); if ( !filterFile.empty() ) { filterFile.Replace ( _T ( ".xml" ), _T ( "" ) ); filterCombo->Append ( wxFileNameFromPath ( filterFile ) ); for ( ;; ) { filterFile = wxFindNextFile(); if ( filterFile.empty() ) break; filterFile.Replace ( _T ( ".xml" ), _T ( "" ) ); filterCombo->Append ( wxFileNameFromPath ( filterFile ) ); } } filterCombo->SetValue ( filterPreset ); } else { filterCombo->Append ( _ ( "(No filters found)" ) ); filterCombo->Select ( 0 ); } }
void AspellAdapterImpl::initAspell(const std::string & langCode) { langCode_ = langCode; aspell_config_replace(aspellConfig_, "lang", langCode.c_str()); aspell_config_replace(aspellConfig_, "encoding", "utf-8"); }