void SpellCheck::addToDict(const QString &word){
if (!spell_checker || word.isEmpty())
return;
aspell_speller_add_to_personal(spell_checker, word.toUtf8().constData(), -1);
aspell_speller_add_to_session(spell_checker, word.toUtf8().constData(), -1);
}
bool ASpellChecker::add(const QString& word)
{
bool result = false;
if (config_ && !spellers_.empty()) {
QString trimmed_word = word.trimmed();
if(!word.isEmpty()) {
aspell_speller_add_to_personal(spellers_.first(), trimmed_word.toUtf8(), trimmed_word.toUtf8().length());
aspell_speller_save_all_word_lists(spellers_.first());
result = true;
}
}
return result;
}
void doAddIgnoreWord(GtkWidget* widget,gpointer data)
{
if((long)data==1)
aspell_speller_add_to_session(spellChecker,badWord,-1);
else
{
aspell_speller_add_to_personal(spellChecker,badWord,-1);
aspell_speller_save_all_word_lists(spellChecker);
}
gtk_dialog_response((GtkDialog*)spellCheckWord,0);
if(badWord!=NULL)
g_free(badWord);
}
/* method:addtoPersonal *******************************************************/
static PyObject* m_addtoPersonal(PyObject* self, PyObject* args) {
char *word;
int length;
if (!PyArg_ParseTuple(args, "s#", &word, &length)) {
PyErr_SetString(PyExc_TypeError, "a string is required");
return NULL;
}
aspell_speller_add_to_personal(Speller(self), word, length);
if (aspell_speller_error(Speller(self)) != 0) {
PyErr_SetString(_AspellSpellerException, aspell_speller_error_message(Speller(self)));
return NULL;
}
return_None;
}
//__________________________________________________________________________
void Speller::Aspell::Suggest::addPersonalList(const std::string& word)
throw( std::runtime_error )
{
// A std::runtime_error exception is thrown if
// an error occcurs.
// FIXME: Return value should be something meaningful from
// aspell_speller_add_to_personal.
aspell_speller_add_to_personal( fspeller, word.c_str(), -1 );
try
{
checkError();
}
catch( const std::runtime_error& err )
{
throw err;
}
}
void
weechat_aspell_add_word (const char *lang, const char *word)
{
struct t_aspell_speller *new_speller, *ptr_speller;
new_speller = NULL;
ptr_speller = weechat_aspell_speller_search (lang);
if (!ptr_speller)
{
if (!weechat_aspell_speller_exists (lang))
{
weechat_printf (NULL,
_("%s: error: dictionary \"%s\" is not "
"available on your system"),
ASPELL_PLUGIN_NAME, lang);
return;
}
new_speller = weechat_aspell_speller_new (lang);
if (!new_speller)
return;
ptr_speller = new_speller;
}
if (aspell_speller_add_to_personal (ptr_speller->speller,
word,
strlen (word)) == 1)
{
weechat_printf (NULL,
_("%s: word \"%s\" added to personal dictionary"),
ASPELL_PLUGIN_NAME, word);
}
else
{
weechat_printf (NULL,
_("%s%s: failed to add word to personal "
"dictionary"),
weechat_prefix ("error"), ASPELL_PLUGIN_NAME);
}
if (new_speller)
weechat_aspell_speller_free (new_speller);
}
/**
* Add a given word to the list of known words inside my private dictionary.
* You have to call aspell_save_all_wordlists to make sure the list gets persistent.
* @param word the word to add.
*/
static VALUE aspell_add_to_personal(VALUE self, VALUE word) {
AspellSpeller *speller = get_speller(self);
aspell_speller_add_to_personal(speller, STR2CSTR(word), -1);
check_for_error(speller);
return self;
}
void
weechat_aspell_command_add_word (struct t_gui_buffer *buffer, const char *dict,
const char *word)
{
struct t_aspell_speller_buffer *ptr_speller_buffer;
#ifdef USE_ENCHANT
EnchantDict *new_speller, *ptr_speller;
#else
AspellSpeller *new_speller, *ptr_speller;
#endif
new_speller = NULL;
if (dict)
{
ptr_speller = weechat_hashtable_get (weechat_aspell_spellers, dict);
if (!ptr_speller)
{
if (!weechat_aspell_speller_dict_supported (dict))
{
weechat_printf (NULL,
_("%s: error: dictionary \"%s\" is not "
"available on your system"),
ASPELL_PLUGIN_NAME, dict);
return;
}
new_speller = weechat_aspell_speller_new (dict);
if (!new_speller)
return;
ptr_speller = new_speller;
}
}
else
{
ptr_speller_buffer = weechat_hashtable_get (weechat_aspell_speller_buffer,
buffer);
if (!ptr_speller_buffer)
ptr_speller_buffer = weechat_aspell_speller_buffer_new (buffer);
if (!ptr_speller_buffer)
goto error;
if (!ptr_speller_buffer->spellers || !ptr_speller_buffer->spellers[0])
{
weechat_printf (NULL,
_("%s%s: no dictionary on this buffer for "
"adding word"),
weechat_prefix ("error"),
ASPELL_PLUGIN_NAME);
return;
}
else if (ptr_speller_buffer->spellers[1])
{
weechat_printf (NULL,
_("%s%s: many dictionaries are defined for "
"this buffer, please specify dictionary"),
weechat_prefix ("error"),
ASPELL_PLUGIN_NAME);
return;
}
ptr_speller = ptr_speller_buffer->spellers[0];
}
#ifdef USE_ENCHANT
enchant_dict_add (ptr_speller, word, strlen (word));
#else
if (aspell_speller_add_to_personal (ptr_speller,
word,
strlen (word)) == 1)
{
weechat_printf (NULL,
_("%s: word \"%s\" added to personal dictionary"),
ASPELL_PLUGIN_NAME, word);
}
else
goto error;
#endif
goto end;
error:
weechat_printf (NULL,
_("%s%s: failed to add word to personal "
"dictionary"),
weechat_prefix ("error"), ASPELL_PLUGIN_NAME);
end:
if (new_speller)
weechat_hashtable_remove (weechat_aspell_spellers, dict);
}
int main(int argc, const char *argv[])
{
AspellCanHaveError * ret;
AspellSpeller * speller;
int have;
char word[81];
char * p;
char * word_end;
AspellConfig * config;
if (argc < 2) {
printf("Usage: %s <language> [<size>|- [[<jargon>|- [<encoding>]]]\n", argv[0]);
return 1;
}
config = new_aspell_config();
aspell_config_replace(config, "lang", argv[1]);
if (argc >= 3 && argv[2][0] != '-' && argv[2][1] != '\0')
aspell_config_replace(config, "size", argv[2]);
if (argc >= 4 && argv[3][0] != '-')
aspell_config_replace(config, "jargon", argv[3]);
if (argc >= 5 && argv[4][0] != '-')
aspell_config_replace(config, "encoding", argv[4]);
ret = new_aspell_speller(config);
delete_aspell_config(config);
if (aspell_error(ret) != 0) {
printf("Error: %s\n",aspell_error_message(ret));
delete_aspell_can_have_error(ret);
return 2;
}
speller = to_aspell_speller(ret);
config = aspell_speller_config(speller);
fputs("Using: ", stdout);
fputs(aspell_config_retrieve(config, "lang"), stdout);
fputs("-", stdout);
fputs(aspell_config_retrieve(config, "jargon"), stdout);
fputs("-", stdout);
fputs(aspell_config_retrieve(config, "size"), stdout);
fputs("-", stdout);
fputs(aspell_config_retrieve(config, "module"), stdout);
fputs("\n\n", stdout);
puts("Type \"h\" for help.\n");
while (fgets(word, 80, stdin) != 0) {
/* remove trailing spaces */
word_end = strchr(word, '\0') - 1;
while (word_end != word && (*word_end == '\n' || *word_end == ' '))
--word_end;
++word_end;
*word_end = '\0';
putchar('\n');
switch (word[0]) {
case '\0':
break;
case 'h':
puts(
"Usage: \n"
" h(elp) help\n"
" c <word> check if a word is the correct spelling\n"
" s <word> print out a list of suggestions for a word\n"
" a <word> add a word to the personal word list\n"
" i <word> ignore a word for the rest of the session\n"
" d <file> spell checks a document\n"
" p dumps the personal word list\n"
" P dumps the session word list\n"
" m dumps the main word list\n"
" o <option> <value> sets a config option\n"
" r <option> retrieves a config option\n"
" l <option> retrieves a config option as a list\n"
" S saves all word lists\n"
" C clear the curent sesstion word list\n"
" x quite\n" );
break;
case 'p':
print_word_list(speller,
aspell_speller_personal_word_list(speller), '\n');
break;
case 'P':
print_word_list(speller,
aspell_speller_session_word_list(speller), '\n');
break;
case 'm':
print_word_list(speller,
aspell_speller_main_word_list(speller), '\n');
break;
case 'S':
aspell_speller_save_all_word_lists(speller);
check_for_error(speller);
break;
case 'C':
aspell_speller_clear_session(speller);
check_for_error(speller);
break;
case 'x':
goto END;
case 'c':
if (strlen(word) < 3) {
printf("Usage: %c <word>\n", word[0]);
} else {
have = aspell_speller_check(speller, word + 2, -1);
if (have == 1)
puts("correct");
else if (have == 0)
puts("incorrect");
else
printf("Error: %s\n", aspell_speller_error_message(speller));
}
break;
case 's':
if (strlen(word) < 3) {
printf("Usage: %c <word>\n", word[0]);
} else {
print_word_list(speller,
aspell_speller_suggest(speller, word + 2, -1), '\n');
}
break;
case 'a':
if (strlen(word) < 3) {
printf("Usage: %c <word>\n", word[0]);
} else {
aspell_speller_add_to_personal(speller, word + 2, -1);
check_for_error(speller);
}
break;
case 'i':
if (strlen(word) < 3) {
printf("Usage: %c <word>\n", word[0]);
} else {
aspell_speller_add_to_session(speller, word + 2, -1);
check_for_error(speller);
}
break;
case 'o':
word[80] = '\0'; /* to make sure strchr doesn't run off end of string */
p = strchr(word + 3, ' ');
if (strlen(word) < 3 || p == 0) {
printf("Usage: %c <option> <value>\n", word[0]);
} else {
*p = '\0';
++p;
aspell_config_replace(config, word + 2, p);
check_for_config_error(config);
}
break;
case 'r':
if (strlen(word) < 3) {
printf("Usage: %c <option>\n", word[0]);
} else {
const char * val = aspell_config_retrieve(config, word + 2);
check_for_config_error(config);
if (val)
printf("%s = \"%s\"\n", word + 2, val);
}
break;
case 'l':
if (strlen(word) < 3) {
printf("Usage: %c <option>\n", word[0]);
} else {
AspellStringList * lst = new_aspell_string_list();
AspellMutableContainer * lst0
= aspell_string_list_to_mutable_container(lst);
AspellStringEnumeration * els;
const char * val;
aspell_config_retrieve_list(config, word + 2, lst0);
check_for_config_error(config);
els = aspell_string_list_elements(lst);
printf("%s:\n", word + 2);
while ( (val = aspell_string_enumeration_next(els)) != 0)
printf(" %s\n", val);
delete_aspell_string_enumeration(els);
delete_aspell_string_list(lst);
}
break;
case 'd':
if (strlen(word) < 3) {
printf("Usage: %c <file>\n", word[0]);
} else {
check_document(speller, word + 2);
printf("\n");
}
break;
default:
printf("Unknown Command: %s\n", word);
}
putchar('\n');
}
END:
delete_aspell_speller(speller);
return 0;
}