pegasus/weechat
1
0
Fork 0
mirror of https://github.com/weechat/weechat.git synced 2026-06-30 14:56:39 +02:00
Code Activity
Files
935d8e930488ac196c63a58c1e613fff8e1ed37f
weechat/src/plugins/aspell/weechat-aspell.c
T
Emmanuel Bouthenot 935d8e9304 adding aspell plugin
2006-06-11 02:28:23 +00:00

1177 lines
26 KiB
C
Raw Blame History

/*
* Copyright (c) 2003-2006 by FlashCode <flashcode@flashtux.org>
* See README for License detail, AUTHORS for developers list.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/* weechat-aspell.c: Aspell plugin support for WeeChat */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <ctype.h>
#include "../weechat-plugin.h"
#include "weechat-aspell.h"
speller_t *plugin_speller = NULL;
config_t *plugin_config = NULL;
options_t plugin_options;
t_weechat_plugin *plugin = NULL;
/*
* new_speller : create a new speller cell
*/
speller_t *new_speller (void)
{
speller_t *s;
s = (speller_t *) malloc (sizeof (speller_t));
if (!s)
{
plugin->print (plugin, NULL, NULL,
"[%s] [ERROR] : unable to alloc memory.", plugin_name);
return NULL;
}
s->speller= NULL;
s->lang = NULL;
s->refs = 0;
s->prev_speller = NULL;
s->next_speller = NULL;
return s;
}
/*
* free_speller : free a speller cell
*/
void free_speller (speller_t *s)
{
if (s)
{
if (s->speller)
{
aspell_speller_save_all_word_lists (s->speller);
delete_aspell_speller (s->speller);
}
if (s->lang)
free(s->lang);
free(s);
}
}
/*
* speller_list_search : search a speller cell
*/
speller_t *speller_list_search (char *lang)
{
speller_t *p, *r = NULL;
for(p = plugin_speller; p; p = p->next_speller)
{
if (strcmp(p->lang, lang) == 0)
{
r = p;
break;
}
}
return r;
}
/*
* speller_list_add : create and add a new speller instance
*/
int speller_list_add (char *lang)
{
speller_t *s;
AspellConfig *config;
AspellCanHaveError *ret;
/* create a speller instance for the newly created cell */
config = new_aspell_config();
aspell_config_replace (config, "lang", lang);
ret = new_aspell_speller (config);
if (aspell_error (ret) != 0)
{
plugin->print (plugin, NULL, NULL,
"[%s] [ERROR] : %s",
plugin_name, aspell_error_message (ret));
delete_aspell_config (config);
delete_aspell_can_have_error (ret);
return 0;
}
/* create and add a new speller cell */
s = new_speller();
if (!s)
return 0;
s->next_speller = plugin_speller;
if (plugin_speller)
plugin_speller->prev_speller = s;
plugin_speller = s;
s->lang = strdup (lang);
s->refs = 1;
s->speller = to_aspell_speller (ret);
delete_aspell_config (config);
return 1;
}
/*
* speller_list_remove : remove a speller instance
*/
int speller_list_remove(char *lang)
{
speller_t *p;
int r = 0;
if (!plugin_speller || !lang)
return 0;
if (!plugin_speller->prev_speller
&& !plugin_speller->next_speller)
{
free_speller (plugin_speller);
plugin_speller = NULL;
return 1;
}
for(p = plugin_speller; p; p = p->next_speller)
{
if (strcmp(p->lang, lang) == 0)
{
if (p->prev_speller)
p->prev_speller->next_speller = p->next_speller;
else
plugin_speller = p->next_speller;
if (p->next_speller)
p->next_speller->prev_speller = p->prev_speller;
free_speller (p);
r = 1;
break;
}
}
return r;
}
/*
* new_config : create a new config cell
*/
config_t *new_config (void)
{
config_t *c;
c = (config_t *) malloc (sizeof (config_t));
if (!c)
{
plugin->print (plugin, NULL, NULL,
"[%s] [ERROR] : unable to alloc memory.", plugin_name);
return NULL;
}
c->server = NULL;
c->channel = NULL;
c->speller = NULL;
c->prev_config = NULL;
c->next_config = NULL;
return c;
}
/*
* free_config : free a config cell
*/
void free_config (config_t *c)
{
if (c)
{
if (c->server)
free(c->server);
if (c->channel)
free(c->channel);
free(c);
}
}
/*
* config_list_search : search a config cell
*/
config_t *config_list_search (char *server, char *channel)
{
config_t *p, *r = NULL;
if (!server || !channel)
return NULL;
for(p = plugin_config; p; p = p->next_config)
{
if (strcmp(p->server, server) == 0
&& strcmp(p->channel, channel) == 0)
{
r = p;
break;
}
}
return r;
}
/*
* config_list_add : create and add a new config
*/
int config_list_add (char *server, char *channel)
{
config_t *c;
c = new_config();
if (!c)
return 0;
c->channel = strdup (channel);
c->server = strdup (server);
c->next_config = plugin_config;
if (plugin_config)
plugin_config->prev_config = c;
plugin_config = c;
return 1;
}
/*
* config_list_remove : remove a speller config
*/
int config_list_remove(char *server, char *channel)
{
config_t *p;
int r = 0;
if (!plugin_config || !server || !channel)
return 0;
if (!plugin_config->prev_config
&& !plugin_config)
{
free_config (plugin_config);
plugin_config = NULL;
return 1;
}
for(p = plugin_config; p; p = p->next_config)
{
if (strcmp(p->server, server) == 0
&& strcmp(p->channel, channel) == 0)
{
if (p->prev_config)
p->prev_config->next_config = p->next_config;
else
plugin_config = p->next_config;
if (p->next_config)
p->next_config->prev_config = p->prev_config;
free_config (p);
r = 1;
break;
}
}
return r;
}
/*
* iso_to_lang : convert an aspell iso lang code
* in its english full name
*
*/
char *iso_to_lang (char *code)
{
iso_langs_t *p;
char *l;
l = NULL;
for(p = langs_avail; p->code; ++p)
{
if (strcmp(p->code, code) == 0)
{
l = strdup(p->name);
break;
}
}
if (!l)
l = strdup ("Unknown");
return l;
}
/*
* iso_to_country : convert an aspell iso country
* code in its english full name
*/
char *iso_to_country (char *code)
{
iso_countries_t *p;
char *c;
c = NULL;
for(p = countries_avail; p->code; ++p)
{
if (strcmp(p->code, code) == 0)
{
c = strdup(p->name);
break;
}
}
if (!c)
c = strdup ("Unknown");
return c;
}
/*
* speller_exists : return 1 if an aspell dict exists
* for a lang, 0 otherwise
*/
int speller_exists (char *lang)
{
struct AspellConfig *config;
AspellDictInfoList *l;
AspellDictInfoEnumeration *el;
const AspellDictInfo *di;
int r;
r = 0;
config = new_aspell_config();
l = get_aspell_dict_info_list (config);
el = aspell_dict_info_list_elements (l);
di = NULL;
while (( di = aspell_dict_info_enumeration_next (el)))
{
if (strcmp(di->name, lang) == 0)
{
r = 1;
break;
}
}
delete_aspell_dict_info_enumeration (el);
delete_aspell_config (config);
return r;
}
/*
* speller_list_dicts : list all aspell dict installed on system and display them
*/
void speller_list_dicts (void)
{
char *country, *lang, *p;
char buffer[192];
struct AspellConfig *config;
AspellDictInfoList *l;
AspellDictInfoEnumeration *el;
const AspellDictInfo *di;
config = new_aspell_config();
l = get_aspell_dict_info_list (config);
el = aspell_dict_info_list_elements (l);
di = NULL;
plugin->print (plugin, NULL, NULL, "[%s] *** dictionnaries list :", plugin_name);
while (( di = aspell_dict_info_enumeration_next (el)))
{
country = NULL;
p = strchr (di->code, '_');
if (p)
{
*p = '\0';
lang = iso_to_lang ((char*) di->code);
*p = '_';
country = iso_to_country (p+1);
}
else
lang = iso_to_lang ((char*) di->code);
if (strlen (di->jargon) == 0)
{
if (p)
snprintf (buffer, sizeof(buffer), "%-22s %s (%s)", di->name, lang, country);
else
snprintf (buffer, sizeof(buffer), "%-22s %s", di->name, lang);
}
else
{
if (p)
snprintf (buffer, sizeof(buffer), "%-22s %s (%s - %s)", di->name, lang, country, di->jargon);
else
snprintf (buffer, sizeof(buffer), "%-22s %s (%s)", di->name, lang, di->jargon);
}
plugin->print (plugin, NULL, NULL, "[%s] - %s", plugin_name, buffer);
if (lang)
free (lang);
if (country)
free (country);
}
delete_aspell_dict_info_enumeration (el);
delete_aspell_config (config);
}
/*
* config_show : display plugin settings
*/
void config_show (void)
{
config_t *p;
if (!plugin_config)
plugin->print (plugin, NULL, NULL,
"[%s] [SHOW] *** No buffers with spellchecking enable",
plugin_name);
else
plugin->print (plugin, NULL, NULL,
"[%s] [SHOW] *** Spellchecking is active on the following buffers :",
plugin_name);
for(p = plugin_config; p; p = p->next_config)
plugin->print (plugin, NULL, NULL,
"[%s] [SHOW] -> %s@%s with lang '%s'",
plugin_name, p->channel, p->server, p->speller->lang);
plugin->print (plugin, NULL, NULL,
"[%s] [SHOW] *** plugin options :", plugin_name);
plugin->print (plugin, NULL, NULL,
"[%s] [SHOW] -> word-size = %d",
plugin_name, plugin_options.word_size);
plugin->print (plugin, NULL, NULL,
"[%s] [SHOW] -> color = %s",
plugin_name, plugin_options.color_name);
plugin->print (plugin, NULL, NULL,
plugin_options.check_sync == 1
? "[%s] [SHOW] -> realtime spellchecking is enable"
: "[%s] [SHOW] -> asynchronous spellchecking is enable"
,
plugin_name);
}
/*
* config_addword : adding a word in personnal dictionaries
*/
int config_addword(char *word)
{
char *server, *channel;
config_t *c;
int ret;
ret = 0;
channel = plugin->get_info (plugin, "channel", NULL);
server = plugin->get_info (plugin, "server", NULL);
if (!server || !channel)
return 0;
c = config_list_search (server, channel);
if (c) {
if (aspell_speller_add_to_personal (
c->speller->speller, (const char *) word, strlen(word)) == 1)
ret = 1;
}
if (ret)
plugin->print (plugin, NULL, NULL,
"[%s] [ADD-WORD] word '%s' successfully added in your personnal dictionnary",
plugin_name, word);
else
plugin->print (plugin, NULL, NULL,
"[%s] [ADD-WORD] an error occured while adding word '%s' in your personnal dict",
plugin_name, word);
if (server)
free (server);
if (channel)
free (channel);
return ret;
}
/*
* config_dump : display debug infos
*/
void config_dump (void)
{
config_t *p;
speller_t *s;
if (!plugin_config)
plugin->print (plugin, NULL, NULL,
"[%s] [DEBUG] [CONFIG] no config",
plugin_name);
for(p = plugin_config; p; p = p->next_config)
plugin->print (plugin, NULL, NULL,
"[%s] [DEBUG] [CONFIG] @%p server='%s' channel='%s' @speller=%p lang='%s' @p=%p @n=%p",
plugin_name, p, p->server, p->channel, p->speller, p->speller->lang, p->prev_config, p->next_config);
if (!plugin_speller)
plugin->print (plugin, NULL, NULL,
"[%s] [DEBUG] [SPELLER] no speller",
plugin_name);
for(s = plugin_speller; s; s = s->next_speller)
plugin->print (plugin, NULL, NULL,
"[%s] [DEBUG] [SPELLER] @%p lang='%s' refs=%d @engine=%p @p=%p @n=%p",
plugin_name, s, s->lang, s->refs, s->speller, s->prev_speller, s->next_speller);
}
/*
* config_enable_for : internal subroutine
*/
void config_enable_for (char *server, char *channel, char *lang)
{
config_t *c;
speller_t *s;
if (!speller_exists (lang))
{
plugin->print (plugin, NULL, NULL,
"[%s] [WARN] '%s' dictionary doesn't seems to be available on your system",
plugin_name, lang);
return;
}
c = config_list_search (server, channel);
if (c)
{
c->speller->refs--;
if (c->speller->refs == 0)
speller_list_remove (c->speller->lang);
config_list_remove (server, channel);
}
if (!config_list_add (server, channel))
{
plugin->print (plugin, NULL, NULL,
"[%s] [ERROR] enabling spell checking on %s@%s failed",
plugin_name, channel, server);
return;
}
s = speller_list_search (lang);
if (!s) {
speller_list_add (lang);
s = plugin_speller;
}
else
s->refs++;
plugin_config->speller = s;
}
/*
* config_enable : enabling given lang spell checking on current server/channel
*/
void config_enable (char *lang)
{
char *channel, *server;
channel = plugin->get_info (plugin, "channel", NULL);
server = plugin->get_info (plugin, "server", NULL);
if (!server || !channel)
{
plugin->print (plugin, NULL, NULL,
"[%s] [WARN] you are not in a channel",
plugin_name);
return;
}
config_enable_for (server, channel, lang);
plugin->print (plugin, NULL, NULL,
"[%s] spell checking '%s' is now active on %s@%s",
plugin_name, lang, channel, server);
if (channel)
free (channel);
if (server)
free (server);
}
/*
* config_disable : disabling spell checking on current server/channel
*/
void config_disable (void)
{
config_t *c;
char *channel, *server;
channel = plugin->get_info (plugin, "channel", NULL);
server = plugin->get_info (plugin, "server", NULL);
if (!server || !channel)
{
plugin->print (plugin, NULL, NULL,
"[%s] [WARN] you are not in a channel",
plugin_name, NULL, NULL);
return;
}
c = config_list_search (server, channel);
if (!c)
{
plugin->print (plugin, NULL, NULL,
"[%s] [WARN] spell checking is not active on %s@%s",
plugin_name, channel, server);
if (channel)
free (channel);
if (server)
free (server);
return;
}
c->speller->refs--;
if (c->speller->refs == 0)
speller_list_remove (c->speller->lang);
config_list_remove (server, channel);
plugin->print (plugin, NULL, NULL,
"[%s] spell checking is now inactive on %s@%s",
plugin_name, channel, server);
if (channel)
free (channel);
if (server)
free (server);
}
/*
* config_set : setting options values
*/
int config_set(char *option, char *value)
{
int c;
if (strcmp (option, "word-size") == 0)
{
plugin_options.word_size = atoi ((value == NULL) ? "" : value);
plugin->print (plugin, NULL, NULL,
"[%s] [SET] setting %s = %d",
plugin_name, option, plugin_options.word_size);
}
else if (strcmp (option, "toggle-check-mode") == 0)
{
plugin_options.check_sync = plugin_options.check_sync == 1 ? 0 : 1;
plugin->print (plugin, NULL, NULL,
plugin_options.check_sync == 1
? "[%s] [SET] spellchecking is now set in realtime mode"
: "[%s] [SET] spellchecking is now set in asynchronous mode",
plugin_name, option);
}
else if (strcmp (option, "color") == 0)
{
c = plugin->get_irc_color (plugin, (value == NULL) ? "" : value);
if (c == -1)
plugin->print (plugin, NULL, NULL,
"[%s] [SET] setting %s = %s failed : color '%s' is unknown",
plugin_name, option,
(value == NULL) ? "" : value,
(value == NULL) ? "" : value);
else
{
plugin_options.color = c;
if (plugin_options.color_name)
free (plugin_options.color_name);
plugin_options.color_name = strdup (value);
plugin->print (plugin, NULL, NULL,
"[%s] [SET] setting %s = %s",
plugin_name, option, plugin_options.color_name);
}
}
else
return 0;
return 1;
}
/*
* config_save : saving plugin config
*/
int config_save (void)
{
config_t *p, *q;
char *servers, *channels, *option;
int n;
servers = NULL;
plugin->set_plugin_config (plugin, "servers", "");
for(p = plugin_config; p; p = p->next_config)
{
servers = plugin->get_plugin_config (plugin, "servers");
if (!servers)
plugin->set_plugin_config (plugin, "servers", p->server);
else if (strlen (servers) == 0)
{
plugin->set_plugin_config (plugin, "servers", p->server);
free (servers);
}
else
{
if (!strstr (servers, p->server))
{
n = strlen (servers) + strlen (p->server) + 2;
servers = (char *) realloc (servers, n * sizeof (char));
strcat (servers, " ");
strcat (servers, p->server);
plugin->set_plugin_config (plugin, "servers", servers);
}
free (servers);
}
channels = NULL;
for(q = plugin_config; q; q = q->next_config)
{
if (strcmp (p->server, q->server) == 0)
{
if (!channels)
channels = strdup (q->channel);
else
{
if (!strstr (channels, q->channel))
{
n = strlen (channels) + strlen (q->channel) + 2;
channels = (char *) realloc (channels, n * sizeof (char));
strcat (channels, " ");
strcat (channels, q->channel);
}
}
n = 7 + strlen (p->server) + strlen (q->channel);
option = (char *) malloc ( n * sizeof (char));
snprintf (option, n, "lang_%s_%s", p->server, q->channel);
plugin->set_plugin_config (plugin, option, q->speller->lang);
free (option);
}
}
if (channels)
{
n = 10 + strlen (p->server);
option = (char *) malloc ( n * sizeof (char));
snprintf (option, n, "channels_%s", p->server);
plugin->set_plugin_config (plugin, option, channels);
free (option);
free (channels);
}
}
plugin->print (plugin, NULL, NULL, "[%s] [SAVE] configuration saved", plugin_name);
return 1;
}
/*
* config_load : loading plugin config
*/
int config_load(void)
{
char *servers, *channels, *lang;
char *option_s, *option_l;
char **servers_list, **channels_list;
int i, j, s, c, n;
servers = plugin->get_plugin_config (plugin, "servers");
if (!servers)
return 0;
servers_list = plugin->explode_string (plugin, servers, " ", 0, &s);
if (servers_list)
{
for (i=0; i<s; i++)
{
n = 10 + strlen (servers_list[i]);
option_s = (char *) malloc (n * sizeof (char));
snprintf (option_s, n, "channels_%s", servers_list[i]);
channels = plugin->get_plugin_config (plugin, option_s);
if (channels)
{
channels_list = plugin->explode_string (plugin, channels, " ", 0, &c);
if (channels_list)
{
for (j=0; j<c; j++)
{
n = 7 + strlen (servers_list[i]) + strlen (channels_list[j]);
option_l = (char *) malloc (n * sizeof (char));
snprintf (option_l, n, "lang_%s_%s", servers_list[i], channels_list[j]);
lang = plugin->get_plugin_config (plugin, option_l);
if (lang)
{
config_enable_for (servers_list[i], channels_list[j], lang);
free (lang);
}
free (option_l);
}
plugin->free_exploded_string (plugin, channels_list);
}
free (channels);
}
free (option_s);
}
plugin->free_exploded_string (plugin, servers_list);
}
plugin->print (plugin, NULL, NULL, "[%s] [LOAD] configuration loaded", plugin_name);
return 1;
}
/*
* options_save : saving plugin options
*/
int options_save(void)
{
char buf[8];
snprintf (buf, sizeof(buf), "%d", plugin_options.word_size);
plugin->set_plugin_config (plugin, "word-size", buf);
snprintf (buf, sizeof(buf), "%d", plugin_options.check_sync);
plugin->set_plugin_config (plugin, "check-sync", buf);
plugin->set_plugin_config (plugin, "color", plugin_options.color_name);
plugin->print (plugin, NULL, NULL, "[%s] [SAVE] options saved", plugin_name);
return 1;
}
/*
* options_load : loading plugin options
*/
int options_load(void)
{
char *buffer;
int n;
buffer = plugin->get_plugin_config (plugin, "word-size");
if (buffer)
{
plugin_options.word_size = atoi (buffer);
free (buffer);
}
else
plugin_options.word_size = _OPTION_WORD_SIZE;
buffer = plugin->get_plugin_config (plugin, "check-sync");
if (buffer)
{
plugin_options.check_sync = atoi (buffer);
if (plugin_options.check_sync != 0 && plugin_options.check_sync != 1)
plugin_options.check_sync = _OPTION_CHECK_SYNC;
free (buffer);
}
else
plugin_options.check_sync = _OPTION_CHECK_SYNC;
buffer = plugin->get_plugin_config (plugin, "color");
if (buffer)
{
n = plugin->get_irc_color (plugin, buffer);
if (n == -1)
{
plugin_options.color = plugin->get_irc_color (plugin, _OPTION_COLOR);
plugin_options.color_name = strdup (_OPTION_COLOR);
}
else
{
plugin_options.color = n;
plugin_options.color_name = strdup (buffer);
}
free (buffer);
}
else {
plugin_options.color = plugin->get_irc_color (plugin, _OPTION_COLOR);
plugin_options.color_name = strdup (_OPTION_COLOR);
}
plugin->print (plugin, NULL, NULL, "[%s] [LOAD] options loaded", plugin_name);
return 1;
}
/*
* speller_command : manage "/aspell" uses
*/
int speller_command (t_weechat_plugin *p,
int argc, char **argv,
char *handler_args,
void *handler_pointer)
{
/* make gcc happy */
(void) p;
(void) handler_args;
(void) handler_pointer;
char helpcmd[32];
char **args;
int c, r;
snprintf(helpcmd, sizeof(helpcmd), "/help %s", plugin_command);
r = 0;
if ((argc == 3) && argv[1] && argv[2])
{
args = plugin->explode_string (plugin, argv[2], " ", 0, &c);
if (args)
{
if (c >= 1)
{
if (strcmp (args[0], "dictlist") == 0)
{
speller_list_dicts (); r = 1;
}
else if (strcmp (args[0], "show") == 0)
{
config_show (); r = 1;
}
else if (strcmp (args[0], "save") == 0)
{
config_save (); options_save(); r = 1;
}
else if (strcmp (args[0], "dump") == 0)
{
config_dump (); r = 1;
}
else if (strcmp (args[0], "enable") == 0)
{
if (c >= 2) { config_enable (args[1]); r = 1; }
}
else if (strcmp (args[0], "disable") == 0)
config_disable ();
else if (strcmp (args[0], "set") == 0)
{
if (c >= 2) { r = config_set (args[1], args[2]); }
}
else if (strcmp (args[0], "add-word") == 0)
{
if (c >= 2) { config_addword (args[1]); r = 1; }
}
}
plugin->free_exploded_string (plugin, args);
}
}
if (r == 0)
plugin->exec_command (plugin, NULL, NULL, helpcmd);
return PLUGIN_RC_OK;
}
/*
* keyb_check : handler to check spelling on input line
*/
int keyb_check (t_weechat_plugin *p, int argc, char **argv,
char *handler_args, void *handler_pointer)
{
/* make gcc happy */
(void) p;
(void) handler_args;
(void) handler_pointer;
char *server, *channel;
config_t *c;
char *input, *ptr_input, *pos_space;
int count;
channel = plugin->get_info (plugin, "channel", NULL);
server = plugin->get_info (plugin, "server", NULL);
if (!server || !channel)
return PLUGIN_RC_OK;
c = config_list_search (server, channel);
if (!c)
return PLUGIN_RC_OK;
if (plugin_options.check_sync == 0 && argv[0] && argv[0][0])
{
/* FIXME : using isalpha(), can make problem with UTF-8 encodings */
if (argv[0][0] == '*' && isalpha (argv[0][1]))
return PLUGIN_RC_OK;
}
if (!(argc == 3 && argv[1] && argv[2]))
return PLUGIN_RC_OK;
if (strcmp (argv[1], argv[2]) == 0)
return PLUGIN_RC_OK;
input = plugin->get_info (plugin, "input", NULL);
if (!input)
return PLUGIN_RC_OK;
if (!input[0])
return PLUGIN_RC_OK;
if (input[0] == '/')
return PLUGIN_RC_OK;
count = 0;
ptr_input = input;
plugin->input_color (plugin, 0, 0, 0);
while (ptr_input && ptr_input[0])
{
pos_space = strchr (ptr_input, ' ');
if (pos_space)
pos_space[0] = '\0';
if ( (int) strlen (ptr_input) >= plugin_options.word_size)
{
if (aspell_speller_check (c->speller->speller, ptr_input, -1) != 1)
{
if (count == 0)
plugin->input_color (plugin, 0, 0, 0);
plugin->input_color (plugin, plugin_options.color,
ptr_input - input, strlen (ptr_input));
count++;
}
}
if (pos_space)
{
pos_space[0] = ' ';
ptr_input = pos_space + 1;
while (ptr_input[0] == ' ')
ptr_input++;
}
else
ptr_input = NULL;
}
plugin->input_color (plugin, -1, 0, 0);
free (input);
return PLUGIN_RC_OK;
}
/*
* weechat_plugin_init : init function, called when plugin is loaded
*/
int weechat_plugin_init (t_weechat_plugin *p)
{
char help[1024];
plugin_speller = NULL;
plugin_config = NULL;
plugin = p;
snprintf (help, sizeof(help),
" show : show plugin configuration\n"
"dictlist : show installed dictionnaries\n"
" save : save plugin configuration\n"
" enable : enable aspell on current channel/server\n"
" disable : disable aspell on current channel/server\n"
"add-word : add a word in your personnal aspell dict\n"
" dump : show plugins internals (usefull for debug)\n"
" set : setting options\n"
" OPTION := { word-size SIZE | toogle-check-mode | color COLOR }\n"
" word-size : minimum size for a word to be checked (default : %d)\n"
" toggle-check-mode : switch between a realtime or an asynchronous checking\n"
" color : color of the mispelled words\n",
_OPTION_WORD_SIZE);
plugin->cmd_handler_add (plugin, "aspell",
"Aspell Plugin configuration",
"{ show | save | dictlist | set [OPTION [VALUE]] | add-word WORD | enable LANG | disable | dump }",
help,
"show|dictlist|save|enable|disable|set|add-word|dump word-size|toggle-check-mode|color",
&speller_command, NULL, NULL);
plugin->keyboard_handler_add (plugin, &keyb_check, NULL, NULL);
options_load ();
config_load ();
return PLUGIN_RC_OK;
}
/*
* weechat_plugin_end : end function, called when plugin is unloaded
*/
void weechat_plugin_end (t_weechat_plugin *p)
{
/* make gcc happy */
(void) p;
speller_t *s, *t;
config_t *c, *d;
options_save ();
config_save ();
/* freeing memory */
/* options */
if (plugin_options.color_name)
free (plugin_options.color_name);
/* spellers */
s = plugin_speller;
while ( s != NULL)
{
t = s;
s = s->next_speller;
free_speller (t);
}
/* config */
c = plugin_config;
while ( c != NULL)
{
d = c;
c = c->next_config;
free_config (c);
}
}
View Git Blame Copy Permalink