X-Git-Url: http://git.claws-mail.org/?p=claws.git;a=blobdiff_plain;f=src%2Fgtkspell.c;h=94def48c1ea11def10667589a5954abf7e5d08fc;hp=eb7fa49556e8d3699d04fc364dfaa2b065a0cea2;hb=38fdd221cce9e4d99cb38cee5508452dda70c296;hpb=352a4cf61f6e0b266aed008a494e0262508d739e diff --git a/src/gtkspell.c b/src/gtkspell.c index eb7fa4955..94def48c1 100644 --- a/src/gtkspell.c +++ b/src/gtkspell.c @@ -15,19 +15,14 @@ * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ -/* - Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev - */ /* + * Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev * Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto & * The Sylpheed Claws Team. + * Adapted for pspell (c) 2001 Melvin Hadasht */ - -/* - * Adapted for pspell (c) 2001 Melvin Hadasht - * - */ + #if defined(HAVE_CONFIG_H) #include "config.h" #endif @@ -70,942 +65,1088 @@ /* number of suggestions to display on each menu. */ #define MENUCOUNT 15 +/******************************************************************************/ -/* Only one config per session */ +/* Function called from menus */ -GtkPspellConfig * gtkpspellconfig; +static void add_word_to_session (GtkWidget *w, GtkPspell *d); +static void add_word_to_personal (GtkWidget *w, GtkPspell *d); +static void set_sug_mode (GtkWidget *w, GtkPspell *gtkpspell); +static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell); +static void check_all (GtkWidget *w, GtkPspell *gtkpspell); +static void menu_change_dict (GtkWidget *w, GtkPspell *gtkpspell); +static void entry_insert_cb (GtkXText *gtktext, gchar *newtext, + guint len, guint *ppos, + GtkPspell *gtkpspell); +static gint compare_dict (Dictionary *a, Dictionary *b); +guchar *convert_to_pspell_encoding (const guchar *encoding); -/* Function called from menus */ -static void add_word_to_session(GtkWidget *w, GtkPspell * d); -static void add_word_to_personal(GtkWidget *w, GtkPspell * d); -static void set_sug_mode(GtkWidget *w, GtkPspell * gtkpspell); -static void check_all(GtkWidget *w, GtkPspell * gtkpspell); -static void menu_change_dict(GtkWidget *w, GtkPspell * gtkpspell); +/* gtkspellconfig - only one config per session */ +GtkPspellConfig * gtkpspellconfig; +/* TODO: configurable */ static GdkColor highlight = { 0, 255 * 256, 0, 0 }; -static void entry_insert_cb(GtkXText *gtktext, - gchar *newtext, guint len, guint *ppos, - GtkPspell *gtkpspell); - -/* Run the first pspell_config from which every new config is */ -/* cloned */ +/******************************************************************************/ -GtkPspellConfig * gtkpspell_init(){ - return new_pspell_config(); +/* gtkspell_init() - run the first pspell_config from which every + * new config is cloned + */ +GtkPspellConfig * gtkpspell_init() +{ + return new_pspell_config(); } -/* Finish all. No more spelling. Called when the program ends */ - -void gtkpspell_finished(GtkPspellConfig * gtkpspellconfig){ - if(gtkpspellconfig){ - delete_pspell_config( gtkpspellconfig ); - gtkpspellconfig = NULL; - } +/* gtkspell_finished() - Finish all. No more spelling. Called when the + * program ends + */ +void gtkpspell_finished(GtkPspellConfig *gtkpspellconfig) +{ + if (gtkpspellconfig) { + delete_pspell_config(gtkpspellconfig); + gtkpspellconfig = NULL; + } } - -/* Test if there is a manager running */ - +/* gtkspell_running - Test if there is a manager running + */ int gtkpspell_running(GtkPspell * gtkpspell) { return (gtkpspell->config!=NULL); } -/* Creates a new session if a gtkpspellconfig exists */ -/* The settings are defaults. If no path/dict is set afterwards, the default one is used */ - -GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig){ - GtkPspell *gtkpspell; - - if( gtkpspellconfig == NULL ){ - gtkpspellconfig=gtkpspell_init(); - if(gtkpspellconfig==NULL){ - debug_print(_("Pspell could not be started.")); - prefs_common.enable_pspell=FALSE; - return NULL; - } - } - - gtkpspell = g_new( GtkPspell ,1); - gtkpspell->config = gtkpspellconfig; - gtkpspell->possible_err = new_pspell_manager( gtkpspell->config ); - gtkpspell->checker = NULL; - - if( pspell_error_number( gtkpspell->possible_err ) != 0){ - debug_print(_("Pspell error : %s\n"), pspell_error_message( gtkpspell->possible_err )); - delete_pspell_can_have_error( gtkpspell->possible_err ); - } - else{ - gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err ); - } +/* gtkspell_new() - creates a new session if a gtkpspellconfig exists. The + * settings are defaults. If no path/dict is set afterwards, the default + * one is used + */ +GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig) +{ + GtkPspell *gtkpspell; + + if (gtkpspellconfig == NULL) { + gtkpspellconfig = gtkpspell_init(); + if (gtkpspellconfig == NULL) { + debug_print(_("Pspell could not be started.")); + prefs_common.enable_pspell=FALSE; + return NULL; + } + } + + gtkpspell = g_new(GtkPspell ,1); + gtkpspell->config = gtkpspellconfig; + gtkpspell->possible_err = new_pspell_manager(gtkpspell->config); + gtkpspell->checker = NULL; + + if (pspell_error_number(gtkpspell->possible_err) != 0) { + debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err)); + delete_pspell_can_have_error( gtkpspell->possible_err ); + } + else { + gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err); + } - gtkpspell->dictionary_list = NULL; - gtkpspell->path = NULL; - gtkpspell->dict = NULL; - gtkpspell->mode = PSPELL_FASTMODE; - gtkpspell->gtktext = NULL; - return gtkpspell; + gtkpspell->dictionary_list = NULL; + gtkpspell->path = NULL; + gtkpspell->dict = NULL; + gtkpspell->mode = PSPELL_FASTMODE; + gtkpspell->learn = TRUE; + gtkpspell->gtktext = NULL; + return gtkpspell; } -/* Creates a new session and set path/dic */ - +/* gtkspell_new_with_config() - Creates a new session and set path/dic + */ GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig, - guchar *path, - guchar *dict, - guint mode, - guchar *encoding){ - GtkPspell *gtkpspell; - - if( gtkpspellconfig == NULL) { - gtkpspellconfig=gtkpspell_init(); - if(gtkpspellconfig==NULL){ - debug_print(_("Pspell could not be started.")); - prefs_common.enable_pspell=FALSE; - return NULL; - } - } - - gtkpspell = g_new( GtkPspell ,1); - gtkpspell->path = NULL; - gtkpspell->dict = NULL; - gtkpspell->dictionary_list = NULL; - gtkpspell->gtktext = NULL; - - gtkpspell->config = pspell_config_clone(gtkpspellconfig); - gtkpspell->mode = PSPELL_FASTMODE; - if(!set_path_and_dict(gtkpspell, gtkpspell->config, path, dict)){ - debug_print(_("Pspell could not be configured.")); - gtkpspell=gtkpspell_delete(gtkpspell); - } - if(encoding) - pspell_config_replace(gtkpspell->config,"encoding",encoding); - - gtkpspell->possible_err = new_pspell_manager( gtkpspell->config ); - gtkpspell->checker = NULL; - - if( pspell_error_number( gtkpspell->possible_err ) != 0){ - debug_print(_("Pspell error : %s\n"), pspell_error_message( gtkpspell->possible_err )); - delete_pspell_can_have_error( gtkpspell->possible_err ); - gtkpspell=gtkpspell_delete(gtkpspell); - } - else{ - gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err ); - } - return gtkpspell; -} + guchar *path, guchar *dict, + guint mode, const guchar *encoding) +{ + GtkPspell *gtkpspell; + + if (gtkpspellconfig == NULL) { + gtkpspellconfig=gtkpspell_init(); + if (gtkpspellconfig == NULL) { + debug_print(_("Pspell could not be started.")); + prefs_common.enable_pspell = FALSE; + return NULL; + } + } + gtkpspell = g_new( GtkPspell ,1); + gtkpspell->path = NULL; + gtkpspell->dict = NULL; + gtkpspell->dictionary_list = NULL; + gtkpspell->gtktext = NULL; + + gtkpspell->config = pspell_config_clone(gtkpspellconfig); + gtkpspell->mode = PSPELL_FASTMODE; + gtkpspell->learn = TRUE; + + if (!set_path_and_dict(gtkpspell, gtkpspell->config, path, dict)) { + debug_print(_("Pspell could not be configured.")); + gtkpspell = gtkpspell_delete(gtkpspell); + return gtkpspell; + } + + if (encoding) { + char *pspell_encoding; + pspell_encoding = convert_to_pspell_encoding (encoding); + debug_print(_("Pspell encoding: asked: %s changed to: %s\n"), encoding, pspell_encoding); + pspell_config_replace(gtkpspell->config, "encoding", (const char *)pspell_encoding); + if (pspell_config_error_number(gtkpspell->config) !=0 ) { + debug_print(_("Pspell encoding error: %s\nSwitching to iso8859-1 (sorry)\n"), + pspell_config_error_message(gtkpspell->config)); + pspell_config_replace(gtkpspell->config, "encoding", "iso8859-1"); + } + g_free(pspell_encoding); + } -/* Finishes a session */ + gtkpspell->possible_err = new_pspell_manager(gtkpspell->config); + gtkpspell->checker = NULL; -GtkPspell * gtkpspell_delete( GtkPspell *gtkpspell ){ + if (pspell_error_number(gtkpspell->possible_err) != 0) { + debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err)); + delete_pspell_can_have_error(gtkpspell->possible_err); + gtkpspell = gtkpspell_delete(gtkpspell); + } + else { + gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err ); + } + return gtkpspell; +} - if( gtkpspell->checker ){ - delete_pspell_manager( gtkpspell->checker ); - gtkpspell->checker = NULL; - gtkpspell->possible_err = NULL; /* checker is a cast from - possible_err */ - } +/* gtkspell_delete() - Finishes a session + */ +GtkPspell *gtkpspell_delete( GtkPspell *gtkpspell ) +{ + if ( gtkpspell->checker ) { + /* First save all word lists */ + pspell_manager_save_all_word_lists(gtkpspell->checker); + delete_pspell_manager(gtkpspell->checker); + gtkpspell->checker = NULL; + gtkpspell->possible_err = NULL; /* checker is a cast from possible_err */ + } - if( gtkpspell->dictionary_list ) - gtkpspell_free_dictionary_list( gtkpspell->dictionary_list ); + if (gtkpspell->dictionary_list) + gtkpspell_free_dictionary_list(gtkpspell->dictionary_list); - g_free( gtkpspell->path ); - g_free( gtkpspell->dict ); - gtkpspell->path = NULL; - gtkpspell->dict = NULL; + g_free(gtkpspell->path); + g_free(gtkpspell->dict); + gtkpspell->path = NULL; + gtkpspell->dict = NULL; - g_free( gtkpspell ); - return NULL; + g_free(gtkpspell); + return NULL; } - -int set_path_and_dict( GtkPspell *gtkpspell, - PspellConfig *config, - guchar *path, - guchar * dict ) +int set_path_and_dict(GtkPspell *gtkpspell, PspellConfig *config, + guchar *path, guchar * dict) { - guchar *module = NULL; - guchar *language = NULL; - guchar *spelling = NULL; - guchar *jargon = NULL; - - guchar buf[BUFSIZE]; - guchar *end; - guchar *temppath; - guchar *tempdict; - - /* Change nothing if any of path/dict/config is NULL */ - if( path==NULL || dict==NULL || config==NULL) - return 0; - - /* This is done, so we can free gtkpspell->path, even if it was - given as an argument of the function */ - temppath = g_strdup( path ); - g_free( gtkpspell->path ); - - /* pspell dict name format : */ - /* [[-[-]]-.pwli */ - /* Strip off path */ - - if(!strrchr(dict,G_DIR_SEPARATOR)){ /* plain dict name */ - strncpy(buf,dict,BUFSIZE-1); - } - else{ /* strip path */ - strncpy(buf,strrchr(dict,G_DIR_SEPARATOR)+1,BUFSIZE-1); - } - g_free(gtkpspell->dict); - - /* Ensure no buffers overflows if the dict is to long */ - buf[BUFSIZE-1] = 0x00; + guchar *module = NULL; + guchar *language = NULL; + guchar *spelling = NULL; + guchar *jargon = NULL; + guchar buf[BUFSIZE]; + guchar *end; + guchar *temppath; + guchar *tempdict; + + /* Change nothing if any of path/dict/config is NULL */ + g_return_val_if_fail(path, 0); + g_return_val_if_fail(dict, 0); + g_return_val_if_fail(config, 0); + + /* This is done, so we can free gtkpspell->path, even if it was + * given as an argument of the function */ + temppath = g_strdup(path); + g_free(gtkpspell->path); - language = buf; - if(( module=strrchr(buf,'-'))!=NULL){ - module++; - if(( end=strrchr(module,'.'))!=NULL) - end[0]=0x00; - } - - /* In tempdict, we have only the dict name, without path nor - extension. Useful in the popup menus */ - - tempdict=g_strdup(buf); - - /* Probably I am too paranoied... */ - if(!( language[0]!=0x00 && language[1]!=0x00)) - language = NULL; - else{ - spelling = strchr(language,'-'); - if( spelling!=NULL ){ - spelling[0] = 0x00; - spelling++; - } - if( spelling!=module ){ - if( ( end=strchr( spelling,'-' ) )!=NULL ){ - end[0] = 0x00; - jargon = end+1; - if( jargon!=module ) - if( ( end=strchr(jargon,'-') )!=NULL ) - end[0] = 0x00; - else - jargon = NULL; - else - jargon = NULL; - } - else - spelling = NULL; - } - else - spelling = NULL; - } - - debug_print( _("Language : %s\nSpelling: %s\nJargon: %s\nModule: %s\n"),language,spelling,jargon,module); - - if(language) - pspell_config_replace(config,"language-tag",language); - if(spelling) - pspell_config_replace(config,"spelling",spelling); - if(jargon) - pspell_config_replace(config,"jargon",jargon); - if(module) - pspell_config_replace(config,"module",module); - if(temppath) - pspell_config_replace(config,"word-list-path",temppath); - - switch(gtkpspell->mode){ - case PSPELL_FASTMODE: pspell_config_replace(config,"sug_mode","fast"); - break; - case PSPELL_NORMALMODE: pspell_config_replace(config,"sug_mode","normal"); - break; - case PSPELL_BADSPELLERMODE: pspell_config_replace(config,"sug_mode","bad-spellers"); - break; - } + /* pspell dict name format : */ + /* [[-[-]]-.pwli */ + /* Strip off path */ + + if (!strrchr(dict,G_DIR_SEPARATOR)) { + /* plain dict name */ + strncpy(buf,dict,BUFSIZE-1); + } + else { + /* strip path */ + strncpy(buf, strrchr(dict, G_DIR_SEPARATOR)+1, BUFSIZE-1); + } + + g_free(gtkpspell->dict); + + /* Ensure no buffers overflows if the dict is to long */ + buf[BUFSIZE-1] = 0x00; + + language = buf; + if ((module = strrchr(buf, '-')) != NULL) { + module++; + if ((end = strrchr(module, '.')) != NULL) + end[0] = 0x00; + } + + /* In tempdict, we have only the dict name, without path nor + extension. Useful in the popup menus */ + + tempdict = g_strdup(buf); + + /* Probably I am too paranoied... */ + if (!(language[0] != 0x00 && language[1] != 0x00)) + language = NULL; + else { + spelling = strchr(language, '-'); + if (spelling != NULL) { + spelling[0] = 0x00; + spelling++; + } + if (spelling != module) { + if ((end = strchr(spelling, '-')) != NULL) { + end[0] = 0x00; + jargon = end + 1; + if (jargon != module) + if ((end = strchr(jargon, '-')) != NULL) + end[0] = 0x00; + else + jargon = NULL; + else + jargon = NULL; + } + else + spelling = NULL; + } + else + spelling = NULL; + } + + debug_print(_("Language : %s\nSpelling: %s\nJargon: %s\nModule: %s\n"), + language, spelling, jargon, module); + + if (language) + pspell_config_replace(config, "language-tag", language); + if (spelling) + pspell_config_replace(config, "spelling", spelling); + if (jargon) + pspell_config_replace(config, "jargon", jargon); + if (module) + pspell_config_replace(config, "module", module); + if (temppath) + pspell_config_replace(config, "word-list-path", temppath); + + switch(gtkpspell->mode) { + case PSPELL_FASTMODE: + pspell_config_replace(config, "sug_mode", "fast"); + break; + case PSPELL_NORMALMODE: + pspell_config_replace(config, "sug_mode", "normal"); + break; + case PSPELL_BADSPELLERMODE: + pspell_config_replace(config, "sug_mode", "bad-spellers"); + break; + } - gtkpspell->path = g_strdup(temppath); - gtkpspell->dict = g_strdup(tempdict); - g_free(temppath); - g_free(tempdict); + gtkpspell->path = g_strdup(temppath); + gtkpspell->dict = g_strdup(tempdict); + g_free(temppath); + g_free(tempdict); - return -1; + return TRUE; } -/* Set path and dict. The session is resetted. */ -/* 0 on error, -1 on success */ -int gtkpspell_set_path_and_dict(GtkPspell * gtkpspell, guchar * path, guchar * dict){ - PspellConfig * config2; +/* gtkpspell_set_path_and_dict() - Set path and dict. The session is + * resetted. + * FALSE on error, TRUE on success */ +int gtkpspell_set_path_and_dict(GtkPspell * gtkpspell, guchar * path, + guchar * dict) +{ + PspellConfig * config2; - /* It seems changing an already running config is not the way to go - */ + /* It seems changing an already running config is not the way to go + */ - config2 = pspell_config_clone( gtkpspell->config ); + config2 = pspell_config_clone(gtkpspell->config); - if(gtkpspell->checker){ - delete_pspell_manager(gtkpspell->checker); - } - gtkpspell->checker = NULL; - gtkpspell->possible_err = NULL; + if (gtkpspell->checker) { + pspell_manager_save_all_word_lists(gtkpspell->checker); + delete_pspell_manager(gtkpspell->checker); + } + + gtkpspell->checker = NULL; + gtkpspell->possible_err = NULL; - if(set_path_and_dict(gtkpspell,config2,path,dict)==0){ - debug_print("Pspell set_path_and_dict error."); - return 0; - } + if (set_path_and_dict(gtkpspell,config2,path,dict) == 0) { + debug_print(_("Pspell set_path_and_dict error.")); + return FALSE; + } - gtkpspell->possible_err = new_pspell_manager( config2 ); + gtkpspell->possible_err = new_pspell_manager(config2); - delete_pspell_config(config2); - config2 = NULL; + delete_pspell_config(config2); + config2 = NULL; - if(pspell_error_number(gtkpspell->possible_err)!=0){ - debug_print("Pspell set path&dict error %s\n", - pspell_error_message(gtkpspell->possible_err)); - delete_pspell_can_have_error(gtkpspell->possible_err); - gtkpspell->possible_err = NULL; - return 0; - } + if (pspell_error_number(gtkpspell->possible_err) != 0) { + debug_print(_("Pspell path & dict. error %s\n"), + pspell_error_message(gtkpspell->possible_err)); + delete_pspell_can_have_error(gtkpspell->possible_err); + gtkpspell->possible_err = NULL; + return FALSE; + } - gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err); + gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err); - return -1; + return TRUE; } -/* What dict are we using ? language-spelling-jargon-module format */ +/* gtkpspell_get_dict() - What dict are we using ? language-spelling-jargon-module format */ /* Actually, this function is not used and hence not tested. */ /* Returns an allocated string */ -guchar * gtkpspell_get_dict( GtkPspell *gtkpspell ){ - - guchar * dict; - guchar * language; - guchar * spelling; - guchar * jargon; - guint len; +guchar *gtkpspell_get_dict(GtkPspell *gtkpspell) +{ + guchar *dict; + guchar *language; + guchar *spelling; + guchar *jargon; + guint len; - if(gtkpspell->config==NULL) - return NULL; + g_return_val_if_fail(gtkpspell->config, NULL); - language = g_strdup(pspell_config_retrieve(gtkpspell->config,"language")); - spelling = g_strdup(pspell_config_retrieve(gtkpspell->config,"spelling")); - jargon = g_strdup(pspell_config_retrieve(gtkpspell->config,"jargon" )); - len = strlen(language) + strlen(spelling) + strlen(jargon); - - if( lenconfig, "language")); + spelling = g_strdup(pspell_config_retrieve(gtkpspell->config, "spelling")); + jargon = g_strdup(pspell_config_retrieve(gtkpspell->config, "jargon" )); + len = strlen(language) + strlen(spelling) + strlen(jargon); + + if (len < BUFSIZE) { + dict = g_new(char,len + 4); + strcpy(dict, language); + if (spelling) { + strcat(dict, "-"); + strcat(dict, spelling); + if (jargon) { + strcat(dict, "-"); + strcat(dict,jargon); + } + } + } + g_free(language); + g_free(spelling); + g_free(jargon); - return dict; + return dict; } -/* Return the dict path as an allocated string */ +/* gtkpspell_get_path() - Return the dict path as an allocated string */ /* Not used = not tested */ +guchar *gtkpspell_get_path(GtkPspell *gtkpspell) +{ + guchar * path; -guchar * gtkpspell_get_path(GtkPspell * gtkpspell){ - - guchar * path; - if( gtkpspell->config=NULL ) - return NULL; + g_return_val_if_fail(gtkpspell->config, NULL); - path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path")); + path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path")); - return path; + return path; } -/* Menu callback : change dict */ - -static void menu_change_dict(GtkWidget *w, GtkPspell * gtkpspell){ - - guchar *thedict,*thelabel; +/* menu_change_dict() - Menu callback : change dict */ +static void menu_change_dict(GtkWidget *w, GtkPspell *gtkpspell) +{ + guchar *thedict, + *thelabel; - /* Dict is simply the menu label */ + /* Dict is simply the menu label */ - gtk_label_get( GTK_LABEL(GTK_BIN(w)->child),(gchar **) &thelabel ); - thedict=g_strdup(thelabel); + gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &thelabel); + thedict = g_strdup(thelabel); - /* Set path, dict, (and sug_mode ?) */ - gtkpspell_set_path_and_dict(gtkpspell,gtkpspell->path,thedict); - g_free(thedict); + /* Set path, dict, (and sug_mode ?) */ + gtkpspell_set_path_and_dict(gtkpspell, gtkpspell->path, thedict); + g_free(thedict); } - -/* Menu callback : Set the suggestion mode */ - -static void set_sug_mode(GtkWidget *w, GtkPspell * gtkpspell){ - - unsigned char * themode; - - gtk_label_get(GTK_LABEL(GTK_BIN(w)->child),(gchar **) &themode); - - if( !strcmp(themode,_("Fast Mode")) ){ - gtkpspell_set_sug_mode( gtkpspell,"fast" ); - gtkpspell->mode = PSPELL_FASTMODE; - } - if( !strcmp(themode,_("Normal Mode")) ){ - gtkpspell_set_sug_mode( gtkpspell,"normal" ); - gtkpspell->mode = PSPELL_NORMALMODE; - } - if(!strcmp( themode,_("Bad Spellers Mode")) ){ - gtkpspell_set_sug_mode( gtkpspell,"bad-spellers" ); - gtkpspell->mode = PSPELL_BADSPELLERMODE; - } +/* set_sug_mode() - Menu callback : Set the suggestion mode */ +static void set_sug_mode(GtkWidget *w, GtkPspell *gtkpspell) +{ + unsigned char *themode; + + gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode); + + if (!strcmp(themode, _("Fast Mode"))) { + gtkpspell_set_sug_mode(gtkpspell, "fast"); + gtkpspell->mode = PSPELL_FASTMODE; + } + if (!strcmp(themode,_("Normal Mode"))) { + gtkpspell_set_sug_mode(gtkpspell, "normal"); + gtkpspell->mode = PSPELL_NORMALMODE; + } + if (!strcmp( themode,_("Bad Spellers Mode"))) { + gtkpspell_set_sug_mode(gtkpspell, "bad-spellers"); + gtkpspell->mode = PSPELL_BADSPELLERMODE; + } } -/* Set the suggestion mode */ +/* gtkpspell_set_sug_mode() - Set the suggestion mode */ /* Actually, the session is resetted and everything is reset. */ -/* We take the used path/dict pair and create a new config with them - */ - -int gtkpspell_set_sug_mode( GtkPspell * gtkpspell, gchar * themode ){ - PspellConfig *config2; - guchar *path; - guchar *dict; - - delete_pspell_manager( gtkpspell->checker ); - gtkpspell->checker = NULL; - - config2 = pspell_config_clone(gtkpspell->config); - - if(!set_path_and_dict( gtkpspell, config2, gtkpspell->path, gtkpspell->dict )){ - debug_print(_("Pspell set_sug_mod could not reset path & dict\n")); - return 0; - } - - pspell_config_replace( config2, "sug-mode", themode ); - - gtkpspell->possible_err = new_pspell_manager( config2 ); - delete_pspell_config( config2 ); - config2 = NULL; - - if( pspell_error_number( gtkpspell->possible_err )!=0 ){ - debug_print( _("Pspell set sug-mode error %s\n"), - pspell_error_message( gtkpspell->possible_err ) ); - delete_pspell_can_have_error( gtkpspell->possible_err ); - gtkpspell->possible_err = NULL; - return 0; - } - gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err ); - return -1; +/* We take the used path/dict pair and create a new config with them */ +int gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gchar *themode) +{ + PspellConfig *config2; + guchar *path; + guchar *dict; + + pspell_manager_save_all_word_lists(gtkpspell->checker); + delete_pspell_manager(gtkpspell->checker); + + gtkpspell->checker = NULL; + + config2 = pspell_config_clone(gtkpspell->config); + + if (!set_path_and_dict(gtkpspell, config2, gtkpspell->path, gtkpspell->dict)) { + debug_print(_("Pspell set_sug_mod could not reset path & dict\n")); + return FALSE; + } + + pspell_config_replace(config2, "sug-mode", themode); + + gtkpspell->possible_err = new_pspell_manager(config2); + delete_pspell_config(config2); + config2 = NULL; + + if (pspell_error_number(gtkpspell->possible_err) != 0) { + debug_print(_("Pspell set sug-mode error %s\n"), + pspell_error_message(gtkpspell->possible_err)); + delete_pspell_can_have_error(gtkpspell->possible_err); + gtkpspell->possible_err = NULL; + return FALSE; + } + gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err); + return TRUE; } - - -/* Create a suggestion list for word */ -static GList* misspelled_suggest( GtkPspell * gtkpspell, guchar *word ) +/* set_learn_mode() - menu callback to toggle learn mode */ +static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell) { - const guchar *newword; - GList *l = NULL; - int count; - const PspellWordList *suggestions ; - PspellStringEmulation *elements ; - - if( word==NULL ) return NULL; - - if( !pspell_manager_check( gtkpspell->checker,word,-1 ) ){ - suggestions = pspell_manager_suggest( gtkpspell->checker,(const char *) word,-1 ); - elements = pspell_word_list_elements( suggestions ); - /* First one must be the misspelled (why this ?) */ - l = g_list_append( l,g_strdup(word) ); - while( ( newword=pspell_string_emulation_next( elements ) )!=NULL ) - l = g_list_append( l, g_strdup( newword ) ); - return l; - } - return NULL; + gtkpspell->learn = gtkpspell->learn == FALSE ; +} + +/* misspelled_suggest() - Create a suggestion list for word */ +static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word) +{ + const guchar *newword; + GList *list = NULL; + int count; + const PspellWordList *suggestions; + PspellStringEmulation *elements; + + g_return_val_if_fail(word, NULL); + + if (!pspell_manager_check(gtkpspell->checker, word, -1)) { + suggestions = pspell_manager_suggest(gtkpspell->checker, (const char *)word, -1); + elements = pspell_word_list_elements(suggestions); + /* First one must be the misspelled (why this ?) */ + list = g_list_append(list, g_strdup(word)); + + while ((newword = pspell_string_emulation_next(elements)) != NULL) + list = g_list_append(list, g_strdup(newword)); + return list; + } + return NULL; } - -/* Just test if word is correctly spelled */ - -static int misspelled_test(GtkPspell * gtkpspell, unsigned char *word) +/* misspelled_test() - Just test if word is correctly spelled */ +static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word) { - if( pspell_manager_check( gtkpspell->checker, word, -1) ) - return 0; - return 1; + return pspell_manager_check(gtkpspell->checker, word, -1) ? 0 : 1; } static gboolean iswordsep(unsigned char c) { - return !isalpha(c) && c != '\''; + return !isalpha(c) && c != '\''; } -static guchar get_text_index_whar(GtkPspell * gtkpspell, int pos) +static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos) { - guchar a; - gchar *text; - text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1); - if (text == NULL) return 0; - a = (guchar) * text; - g_free(text); - return a; + guchar a; + gchar *text; + + text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1); + if (text == NULL) + return 0; + a = (guchar) *text; + g_free(text); + return a; } -static gboolean get_word_from_pos(GtkPspell * gtkpspell, int pos, +/* get_word_from_pos () - return the word pointed to. */ +/* Handles correctly the quotes. */ +static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos, unsigned char* buf, int *pstart, int *pend) { - gint start, end; - GtkXText * gtktext; - gtktext=gtkpspell->gtktext; - if (iswordsep(get_text_index_whar(gtkpspell, pos))) return FALSE; - - for (start = pos; start >= 0; --start) { - if (iswordsep(get_text_index_whar(gtkpspell, start))) break; - } - start++; - for (end = pos; end < gtk_xtext_get_length(gtktext); end++) { - if (iswordsep(get_text_index_whar(gtkpspell, end))) break; - } + /* TODO : when correcting a word into quotes, change the color of */ + /* the quotes too, as may be they were highlighted before. To do */ + /* so, we can use two others pointers that points to the whole */ + /* word including quotes. */ - if (buf) { - for (pos = start; pos < end; pos++) buf[pos - start] = get_text_index_whar(gtkpspell, pos); - buf[pos - start] = 0; - } + gint start, + end; + guchar c; + GtkXText *gtktext; + + gtktext = gtkpspell->gtktext; + if (iswordsep(get_text_index_whar(gtkpspell, pos))) + return FALSE; + + /* The apostrophe character is somtimes used for quotes + * So include it in the word only if it is not surrounded + * by other characters. + */ + + for (start = pos; start >= 0; --start) { + c = get_text_index_whar(gtkpspell, start); + if (c == '\'') { + if (start > 0) { + if (!isalpha(get_text_index_whar(gtkpspell, start - 1))) { + /* start_quote = TRUE; */ + break; + } + } + else { + /* start_quote = TRUE; */ + break; + } + } + else + if (!isalpha(c)) + break; + } + start++; + + for (end = pos; end < gtk_xtext_get_length(gtktext); end++) { + c = get_text_index_whar(gtkpspell, end); + if (c == '\'') { + if (end < gtk_xtext_get_length(gtktext)) { + if (!isalpha(get_text_index_whar(gtkpspell, end + 1))) { + /* end_quote = TRUE; */ + break; + } + } + else { + /* end_quote = TRUE; */ + break; + } + } + else + if(!isalpha(c)) + break; + } + + if (buf) { + for (pos = start; pos < end; pos++) + buf[pos - start] = get_text_index_whar(gtkpspell, pos); + buf[pos - start] = 0; + } - if (pstart) *pstart = start; - if (pend) *pend = end; + if (pstart) + *pstart = start; + if (pend) + *pend = end; - return TRUE; + return TRUE; } -static gboolean get_curword(GtkPspell * gtkpspell, unsigned char* buf, +static gboolean get_curword(GtkPspell *gtkpspell, unsigned char* buf, int *pstart, int *pend) { - int pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext)); - return get_word_from_pos(gtkpspell, pos, buf, pstart, pend); + int pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext)); + return get_word_from_pos(gtkpspell, pos, buf, pstart, pend); } -static void change_color(GtkPspell * gtkpspell, int start, int end, +static void change_color(GtkPspell * gtkpspell, + int start, int end, GdkColor *color) { - char *newtext; - GtkXText *gtktext; - gtktext=gtkpspell->gtktext; - if (start >= end) { - return ; - }; - gtk_xtext_freeze(gtktext); - newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end); - if(newtext){ -/* gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);*/ - gtk_xtext_set_point(gtktext, start); - gtk_xtext_forward_delete(gtktext, end - start); - - gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start); -/* gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);*/ - } - gtk_xtext_thaw(gtktext); + char *newtext; + GtkXText *gtktext; + + g_return_if_fail(start < end); + + gtktext = gtkpspell->gtktext; + + gtk_xtext_freeze(gtktext); + newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end); + if (newtext) { + gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(entry_insert_cb), + gtkpspell); + gtk_xtext_set_point(gtktext, start); + gtk_xtext_forward_delete(gtktext, end - start); + + gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start); + gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(entry_insert_cb), + gtkpspell); + } + gtk_xtext_thaw(gtktext); } -static gboolean check_at(GtkPspell * gtkpspell, int from_pos) +static gboolean check_at(GtkPspell *gtkpspell, int from_pos) { - int start, end; - unsigned char buf[BUFSIZE]; - GtkXText * gtktext; - gtktext=gtkpspell->gtktext; - - if (from_pos < 0) return FALSE; - if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end)) { - return FALSE; - }; - if (misspelled_test(gtkpspell, buf)) { - if (highlight.pixel == 0) { - /* add an entry for the highlight in the color map. */ - GdkColormap *gc = gtk_widget_get_colormap(GTK_WIDGET(gtktext)); - gdk_colormap_alloc_color(gc, &highlight, FALSE, TRUE); - ; - } - change_color(gtkpspell, start, end, &highlight); - return TRUE; - } else { - change_color(gtkpspell, start, end, - &(GTK_WIDGET(gtktext)->style->fg[0])); - return FALSE; - } + int start, end; + unsigned char buf[BUFSIZE]; + GtkXText *gtktext; + + g_return_val_if_fail(from_pos >= 0, FALSE); + + gtktext = gtkpspell->gtktext; + + if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end)) + return FALSE; + + strncpy(gtkpspell->theword, buf, BUFSIZE - 1); + gtkpspell->theword[BUFSIZE - 1] = 0; + + if (misspelled_test(gtkpspell, buf)) { + if (highlight.pixel == 0) { + /* add an entry for the highlight in the color map. */ + GdkColormap *gc = gtk_widget_get_colormap(GTK_WIDGET(gtktext)); + gdk_colormap_alloc_color(gc, &highlight, FALSE, TRUE); + } + change_color(gtkpspell, start, end, &highlight); + return TRUE; + } else { + change_color(gtkpspell, start, end, + &(GTK_WIDGET(gtktext)->style->fg[0])); + return FALSE; + } } -static void check_all(GtkWidget *w, GtkPspell * gtkpspell){ - gtkpspell_check_all(gtkpspell); +static void check_all(GtkWidget *w, GtkPspell *gtkpspell) +{ + gtkpspell_check_all(gtkpspell); } -void gtkpspell_check_all(GtkPspell * gtkpspell) +void gtkpspell_check_all(GtkPspell *gtkpspell) { - guint origpos; - guint pos = 0; - guint len; - float adj_value; - GtkXText * gtktext; - gtktext=gtkpspell->gtktext; - - if (!gtkpspell_running(gtkpspell)) return ; - - len = gtk_xtext_get_length(gtktext); - - adj_value = gtktext->vadj->value; - gtk_xtext_freeze(gtktext); - origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - while (pos < len) { - while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos))) - pos++; - while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos))) - pos++; - if (pos > 0) - check_at(gtkpspell, pos - 1); - } - gtk_xtext_thaw(gtktext); - gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); - gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); + guint origpos; + guint pos = 0; + guint len; + float adj_value; + GtkXText *gtktext; + + if (!gtkpspell_running(gtkpspell)) return ; + gtktext = gtkpspell->gtktext; + + len = gtk_xtext_get_length(gtktext); + + adj_value = gtktext->vadj->value; + gtk_xtext_freeze(gtktext); + origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); + gtk_editable_set_position(GTK_EDITABLE(gtktext),0); + while (pos < len) { + while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos))) + pos++; + while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos))) + pos++; + if (pos > 0) + check_at(gtkpspell, pos - 1); + } + gtk_xtext_thaw(gtktext); + gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); + gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); } -static void entry_insert_cb(GtkXText *gtktext, - gchar *newtext, guint len, guint *ppos, +static void entry_insert_cb(GtkXText *gtktext, gchar *newtext, + guint len, guint *ppos, GtkPspell * gtkpspell) { - int origpos; - if (!gtkpspell_running(gtkpspell)) return ; - - gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_insert_cb), - gtkpspell); - gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, - &(GTK_WIDGET(gtktext)->style->fg[0]), NULL, newtext, len); - - gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_insert_cb), - gtkpspell); - gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "insert-text"); - *ppos += len; - origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - - if (iswordsep(newtext[0])) { - /* did we just end a word? */ - if (*ppos >= 2) check_at(gtkpspell, *ppos - 2); - - /* did we just split a word? */ - if (*ppos < gtk_xtext_get_length(gtktext)) - check_at(gtkpspell, *ppos + 1); - } else { - /* check as they type, *except* if they're typing at the end (the most - * common case. - */ - if (*ppos < gtk_xtext_get_length(gtktext) && - !iswordsep(get_text_index_whar(gtkpspell, *ppos))) - check_at(gtkpspell, *ppos - 1); - } - - gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); + guint origpos; + if (!gtkpspell_running(gtkpspell)) + return; + + /* We must insert ourself the character to impose the */ + /* color of the inserted character to be default */ + /* Never mess with set_insertion when frozen */ + gtk_xtext_freeze(gtktext); + gtk_xtext_backward_delete(GTK_XTEXT(gtktext), len); + gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, + &(GTK_WIDGET(gtktext)->style->fg[0]), NULL, newtext, len); + *ppos = gtk_xtext_get_point(GTK_XTEXT(gtktext)); + + if (iswordsep(newtext[0])) { + /* did we just end a word? */ + if (*ppos >= 2) + check_at(gtkpspell, *ppos - 2); + + /* did we just split a word? */ + if (*ppos < gtk_xtext_get_length(gtktext)) + check_at(gtkpspell, *ppos + 1); + } else { + /* check as they type, *except* if they're typing at the end (the most + * common case. + */ + if (*ppos < gtk_xtext_get_length(gtktext) + && !iswordsep(get_text_index_whar(gtkpspell, *ppos))) + check_at(gtkpspell, *ppos - 1); + } + gtk_xtext_thaw(gtktext); + gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos); } -static void entry_delete_cb(GtkXText *gtktext, - gint start, gint end, GtkPspell *gtkpspell) +static void entry_delete_cb(GtkXText *gtktext, gint start, gint end, + GtkPspell *gtkpspell) { - int origpos; - if (!gtkpspell_running(gtkpspell)) return ; - - origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - check_at(gtkpspell, start - 1); - gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); - gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); - /* this is to *UNDO* the selection, in case they were holding shift - * while hitting backspace. */ + int origpos; + + if (!gtkpspell_running(gtkpspell)) + return; + + origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); + if (start) { + check_at(gtkpspell, start - 1); + check_at(gtkpspell, start); + } + + gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); + gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); + /* this is to *UNDO* the selection, in case they were holding shift + * while hitting backspace. */ } -static void replace_word(GtkWidget *w, GtkPspell * gtkpspell) +static void replace_word(GtkWidget *w, GtkPspell *gtkpspell) { - int start, end; - unsigned char *newword; - unsigned char buf[BUFSIZE]; - guint pos; - GtkXText * gtktext; - gtktext=gtkpspell->gtktext; - - gtk_xtext_freeze(GTK_XTEXT(gtktext)); - pos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - - gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword); - get_curword(gtkpspell, buf, &start, &end); - - gtk_xtext_set_point(GTK_XTEXT(gtktext), end); - gtk_xtext_backward_delete(GTK_XTEXT(gtktext), end - start); - gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newword, strlen(newword)); - - if(end-start>0){ /* Just be sure the buffer is correct... */ - buf[end-start]=0x00; - /* Learn from common misspellings */ -// pspell_manager_store_replacement(gtkpspell->checker,buf,end-start,newword,strlen(newword)); - } - /* Put the point and the position where we clicked with the mouse */ - /* It seems to be a hack, as I must thaw,freeze,thaw the widget */ - /* to let it update correctly the word insertion and then the */ - /* point & position position. If not, SEGV after the first replacement */ - /* If the new inserted word is smaller, put the point at its end*/ - if(pos-start>strlen(newword)) pos=start+strlen(newword); + int start, end,oldlen, newlen; + guint origpos; + unsigned char *newword; + unsigned char buf[BUFSIZE]; + guint pos; + GtkXText *gtktext; + + gtktext = gtkpspell->gtktext; + + gtk_xtext_freeze(GTK_XTEXT(gtktext)); + origpos = gtkpspell->orig_pos; + pos = origpos; + + gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword); + newlen = strlen(newword); + + get_curword(gtkpspell, buf, &start, &end); + oldlen = end - start; + + gtk_xtext_set_point(GTK_XTEXT(gtktext), end); + gtk_xtext_backward_delete(GTK_XTEXT(gtktext), end - start); + gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newword, strlen(newword)); + + if (end-start > 0 && gtkpspell->learn) { + /* Just be sure the buffer ends somewhere... */ + buf[end-start] = 0; + /* Learn from common misspellings */ + pspell_manager_store_replacement(gtkpspell->checker, buf, + end-start, newword, + strlen(newword)); + } + + /* Put the point and the position where we clicked with the mouse */ + /* It seems to be a hack, as I must thaw,freeze,thaw the widget */ + /* to let it update correctly the word insertion and then the */ + /* point & position position. If not, SEGV after the first replacement */ + /* If the new word ends before point, put the point at its end*/ + + if (origpos-start <= oldlen && origpos-start >= 0) { + /* Original point was in the word. */ + /* Put the insertion point in the same location */ + /* with respect to the new length */ + /* If the original position is still within the word, */ + /* then keep the original position. If not, move to the */ + /* end of the word */ + if (origpos-start > newlen) + pos = start + newlen; + } + else if (origpos > end) { + /* move the position according to the change of length */ + pos = origpos + newlen - oldlen; + } gtk_xtext_thaw(GTK_XTEXT(gtktext)); gtk_xtext_freeze(GTK_XTEXT(gtktext)); - gtk_editable_set_position(GTK_EDITABLE(gtktext),pos); - gtk_xtext_set_point(GTK_XTEXT(gtktext), gtk_editable_get_position(GTK_EDITABLE(gtktext))); + if (GTK_XTEXT(gtktext)->text_len < pos) + pos = gtk_xtext_get_length(GTK_XTEXT(gtktext)); + gtkpspell->orig_pos = pos; + gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkpspell->orig_pos); + gtk_xtext_set_point(GTK_XTEXT(gtktext), + gtk_editable_get_position(GTK_EDITABLE(gtktext))); gtk_xtext_thaw(GTK_XTEXT(gtktext)); } /* Accept this word for this session */ -static void add_word_to_session(GtkWidget *w, GtkPspell * gtkpspell){ - guint pos; - GtkXText * gtkxtext; - gtkxtext=gtkpspell->gtktext; - - gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); - pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext)); +static void add_word_to_session(GtkWidget *w, GtkPspell *gtkpspell) +{ + guint pos; + GtkXText *gtkxtext; - pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword)); + gtkxtext = gtkpspell->gtktext; + gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); + pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext)); + + pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword, strlen(gtkpspell->theword)); - check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); + check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); - gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); - gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); - gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos); - gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); - gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); + gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); + gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); + gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos); + gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); + gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); } -/* Add word to personal dict. Save the list at every addition (may be - not efficient...) */ +/* add_word_to_personal() - add word to personal dict. */ -static void add_word_to_personal(GtkWidget *w, GtkPspell * gtkpspell){ - guint pos; - GtkXText * gtkxtext; - gtkxtext=gtkpspell->gtktext; +static void add_word_to_personal(GtkWidget *w, GtkPspell *gtkpspell) +{ + guint pos; + GtkXText *gtkxtext; + + gtkxtext = gtkpspell->gtktext; - gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); - pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext)); + gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); + pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext)); - pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword)); - pspell_manager_save_all_word_lists(gtkpspell->checker); + pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword)); - check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); - gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); - gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); - gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos); - gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); + check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); + gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); + gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); + gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos); + gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); } -static GtkMenu *make_menu_config(GtkPspell *gtkpspell){ - GtkWidget *menu, *item, *submenu; +static GtkMenu *make_menu_config(GtkPspell *gtkpspell) +{ + GtkWidget *menu, *item, *submenu; - menu = gtk_menu_new(); + menu = gtk_menu_new(); item = gtk_menu_item_new_with_label(_("Spell check all")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); gtk_signal_connect(GTK_OBJECT(item),"activate", - GTK_SIGNAL_FUNC(check_all),gtkpspell); + GTK_SIGNAL_FUNC(check_all), + gtkpspell); item = gtk_menu_item_new(); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu),item); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu),item); submenu = gtk_menu_new(); - item = gtk_menu_item_new_with_label(_("Change dictionary")); - gtk_widget_show(item); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu); - gtk_menu_append(GTK_MENU(menu), item); - /* Dict list */ - if(gtkpspell->dictionary_list==NULL) - gtkpspell->dictionary_list=gtkpspell_get_dictionary_list(gtkpspell->path); + item = gtk_menu_item_new_with_label(_("Change dictionary")); + gtk_widget_show(item); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu); + gtk_menu_append(GTK_MENU(menu), item); + + /* Dict list */ + if (gtkpspell->dictionary_list==NULL) + gtkpspell->dictionary_list = gtkpspell_get_dictionary_list(gtkpspell->path); - { - GtkWidget * curmenu=submenu; - int count = 0; - Dictionary *dict; - GSList *tmp; - tmp = gtkpspell->dictionary_list; - for (tmp = gtkpspell->dictionary_list;tmp!=NULL;tmp=g_slist_next(tmp)){ - dict= (Dictionary *) tmp->data; - item = gtk_check_menu_item_new_with_label(dict->name); - if(strcmp2(dict->name,gtkpspell->dict)) - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),FALSE); - else{ - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE); - gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE); - } - gtk_menu_append(GTK_MENU(curmenu),item); - gtk_signal_connect(GTK_OBJECT(item),"activate", - GTK_SIGNAL_FUNC(menu_change_dict),gtkpspell); - gtk_widget_show(item); - count++; - if(count==MENUCOUNT){ - GtkWidget *newmenu; - newmenu=gtk_menu_new(); - item=gtk_menu_item_new_with_label(_("More...")); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),newmenu); - gtk_menu_append(GTK_MENU(curmenu),item); - gtk_widget_show(item); - curmenu=newmenu; - count=0; - } - } + GtkWidget * curmenu = submenu; + int count = 0; + Dictionary *dict; + GSList *tmp; + + tmp = gtkpspell->dictionary_list; + for (tmp = gtkpspell->dictionary_list; tmp != NULL; tmp =g_slist_next(tmp)) { + dict = (Dictionary *) tmp->data; + item = gtk_check_menu_item_new_with_label(dict->name); + if (strcmp2(dict->name, gtkpspell->dict)) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE); + else { + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); + gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE); + } + gtk_menu_append(GTK_MENU(curmenu), item); + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(menu_change_dict), + gtkpspell); + gtk_widget_show(item); + count++; + if (count == MENUCOUNT) { + GtkWidget *newmenu; + newmenu = gtk_menu_new(); + item = gtk_menu_item_new_with_label(_("More...")); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), newmenu); + gtk_menu_append(GTK_MENU(curmenu), item); + gtk_widget_show(item); + curmenu = newmenu; + count = 0; + } + } } item = gtk_menu_item_new(); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu),item); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); item = gtk_check_menu_item_new_with_label(_("Fast Mode")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu),item); - if(gtkpspell->mode==PSPELL_FASTMODE){ - gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE); - } - else - gtk_signal_connect(GTK_OBJECT(item),"activate", - GTK_SIGNAL_FUNC(set_sug_mode),gtkpspell); - - + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + if (gtkpspell->mode == PSPELL_FASTMODE) { + gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE); + } + else + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(set_sug_mode), + gtkpspell); item = gtk_check_menu_item_new_with_label(_("Normal Mode")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu),item); - if(gtkpspell->mode==PSPELL_NORMALMODE){ - gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE); - } - else - gtk_signal_connect(GTK_OBJECT(item),"activate", - GTK_SIGNAL_FUNC(set_sug_mode),gtkpspell); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu),item); + if (gtkpspell->mode == PSPELL_NORMALMODE) { + gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); + } + else + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(set_sug_mode), + gtkpspell); item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu),item); - if(gtkpspell->mode==PSPELL_BADSPELLERMODE){ - gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE); - } - else - gtk_signal_connect(GTK_OBJECT(item),"activate", - GTK_SIGNAL_FUNC(set_sug_mode),gtkpspell); - - + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + if (gtkpspell->mode==PSPELL_BADSPELLERMODE) { + gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); + } + else + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(set_sug_mode), + gtkpspell); + item = gtk_menu_item_new(); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + item = gtk_check_menu_item_new_with_label(_("Learn from mistakes")); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), + gtkpspell->learn); + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(set_learn_mode), gtkpspell); + + return GTK_MENU(menu); } -/* Add menus to accept this word for this session and to add it to personal - dictionary */ -static GtkMenu *make_menu(GList *l, GtkPspell * gtkpspell) +/* make_menu() - Add menus to accept this word for this session and to add it to + * personal dictionary */ +static GtkMenu *make_menu(GList *l, GtkPspell *gtkpspell) { - GtkWidget *menu, *item; - unsigned char *caption; - GtkXText * gtktext; - gtktext=gtkpspell->gtktext; + GtkWidget *menu, *item; + unsigned char *caption; + GtkXText * gtktext; + + gtktext = gtkpspell->gtktext; - menu = gtk_menu_new(); + menu = gtk_menu_new(); caption = g_strdup_printf(_("Accept `%s' for this session"), (unsigned char*)l->data); - item = gtk_menu_item_new_with_label(caption); - g_free(caption); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); + item = gtk_menu_item_new_with_label(caption); + g_free(caption); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(add_word_to_session), gtkpspell); + GTK_SIGNAL_FUNC(add_word_to_session), + gtkpspell); caption = g_strdup_printf(_("Add `%s' to personal dictionary"), (char*)l->data); - item = gtk_menu_item_new_with_label(caption); - g_free(caption); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); + item = gtk_menu_item_new_with_label(caption); + g_free(caption); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(add_word_to_personal), gtkpspell); + GTK_SIGNAL_FUNC(add_word_to_personal), + gtkpspell); - item = gtk_menu_item_new(); gtk_widget_show(item); gtk_menu_append(GTK_MENU(menu), item); l = l->next; if (l == NULL) { - item = gtk_menu_item_new_with_label(_("(no suggestions)")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); + item = gtk_menu_item_new_with_label(_("(no suggestions)")); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); } else { - GtkWidget *curmenu = menu; - int count = 0; - do { - if (l->data == NULL && l->next != NULL) { - count = 0; - curmenu = gtk_menu_new(); - item = gtk_menu_item_new_with_label(_("Others...")); - gtk_widget_show(item); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); - gtk_menu_append(GTK_MENU(curmenu), item); - l = l->next; - } else if (count > MENUCOUNT) { - count -= MENUCOUNT; - item = gtk_menu_item_new_with_label(_("More...")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(curmenu), item); - curmenu = gtk_menu_new(); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); - } - item = gtk_menu_item_new_with_label((unsigned char*)l->data); - gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(replace_word), gtkpspell); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(curmenu), item); - count++; - } while ((l = l->next) != NULL); - } - return GTK_MENU(menu); + GtkWidget *curmenu = menu; + int count = 0; + + do { + if (l->data == NULL && l->next != NULL) { + count = 0; + curmenu = gtk_menu_new(); + item = gtk_menu_item_new_with_label(_("Others...")); + gtk_widget_show(item); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); + gtk_menu_append(GTK_MENU(curmenu), item); + l = l->next; + } else if (count > MENUCOUNT) { + count -= MENUCOUNT; + item = gtk_menu_item_new_with_label(_("More...")); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(curmenu), item); + curmenu = gtk_menu_new(); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); + } + item = gtk_menu_item_new_with_label((unsigned char*)l->data); + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(replace_word), gtkpspell); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(curmenu), item); + count++; + } while ((l = l->next) != NULL); + } + return GTK_MENU(menu); } -static void popup_menu(GtkPspell * gtkpspell, GdkEventButton *eb) +static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb) { - unsigned char buf[BUFSIZE]; - GList *list, *l; - GtkXText * gtktext; - gtktext=gtkpspell->gtktext; - - if (get_curword(gtkpspell, buf, NULL, NULL)){ - if (buf != NULL) { - strncpy(gtkpspell->theword,buf,BUFSIZE-1); - gtkpspell->theword[BUFSIZE-1]=0x00; - list = misspelled_suggest(gtkpspell, buf); - if (list != NULL) { - gtk_menu_popup(make_menu(list, gtkpspell), NULL, NULL, NULL, NULL, - eb->button, eb->time); - for (l = list; l != NULL; l = l->next) - g_free(l->data); - g_list_free(list); - return; - } - } - } - gtk_menu_popup(make_menu_config(gtkpspell),NULL,NULL,NULL,NULL, - eb->button,eb->time); - + unsigned char buf[BUFSIZE]; + GList *list, *l; + GtkXText * gtktext; + + gtktext = gtkpspell->gtktext; + gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); + + if (!(eb->state & GDK_SHIFT_MASK)) + if (get_curword(gtkpspell, buf, NULL, NULL)) { + if (buf != NULL) { + strncpy(gtkpspell->theword, buf, BUFSIZE - 1); + gtkpspell->theword[BUFSIZE - 1] = 0; + list = misspelled_suggest(gtkpspell, buf); + if (list != NULL) { + gtk_menu_popup(make_menu(list, gtkpspell), NULL, NULL, NULL, NULL, + eb->button, eb->time); + for (l = list; l != NULL; l = l->next) + g_free(l->data); + g_list_free(list); + return; + } + } + } + gtk_menu_popup(make_menu_config(gtkpspell),NULL,NULL,NULL,NULL, + eb->button,eb->time); } /* ok, this is pretty wacky: @@ -1016,84 +1157,89 @@ static void popup_menu(GtkPspell * gtkpspell, GdkEventButton *eb) * so what do we do? forge rightclicks as leftclicks, then popup the menu. * HACK HACK HACK. */ -static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell * gtkpspell) - +static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell *gtkpspell) { - GdkEventButton *eb; - gboolean retval; + GdkEventButton *eb; + gboolean retval; - if (!gtkpspell_running(gtkpspell)) return FALSE; + if (!gtkpspell_running(gtkpspell)) + return FALSE; - if (e->type != GDK_BUTTON_PRESS) return FALSE; - eb = (GdkEventButton*) e; + if (e->type != GDK_BUTTON_PRESS) + return FALSE; + eb = (GdkEventButton*) e; - if (eb->button != 3) return FALSE; + if (eb->button != 3) + return FALSE; - /* forge the leftclick */ - eb->button = 1; + /* forge the leftclick */ + eb->button = 1; gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); - gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event", - e, &retval); - gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); - gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event"); + GTK_SIGNAL_FUNC(button_press_intercept_cb), + gtkpspell); + gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event", + e, &retval); + gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(button_press_intercept_cb), + gtkpspell); + gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event"); - /* now do the menu wackiness */ - popup_menu(gtkpspell, eb); - return TRUE; + /* now do the menu wackiness */ + popup_menu(gtkpspell, eb); + gtk_grab_remove(GTK_WIDGET(gtktext)); + return TRUE; } void gtkpspell_uncheck_all(GtkPspell * gtkpspell) { - int origpos; - unsigned char *text; - float adj_value; - GtkXText * gtktext; - gtktext=gtkpspell->gtktext; - - adj_value = gtktext->vadj->value; - gtk_xtext_freeze(gtktext); - origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1); - gtk_xtext_set_point(gtktext, 0); - gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext)); - gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text)); - gtk_xtext_thaw(gtktext); - - gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); - gtk_adjustment_set_value(gtktext->vadj, adj_value); + int origpos; + unsigned char *text; + float adj_value; + GtkXText *gtktext; + + gtktext=gtkpspell->gtktext; + + adj_value = gtktext->vadj->value; + gtk_xtext_freeze(gtktext); + origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); + text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1); + gtk_xtext_set_point(gtktext, 0); + gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext)); + gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text)); + gtk_xtext_thaw(gtktext); + + gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); + gtk_adjustment_set_value(gtktext->vadj, adj_value); } -void gtkpspell_attach(GtkPspell * gtkpspell, GtkXText *gtktext) +void gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *gtktext) { - gtkpspell->gtktext=gtktext; -// if (prefs_common.auto_makepspell) { - gtk_signal_connect(GTK_OBJECT(gtktext), "insert-text", - GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); - gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text", - GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); -// }; - gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event", - GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); + gtkpspell->gtktext=gtktext; + gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text", + GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); + gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text", + GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); + gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event", + GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); } void gtkpspell_detach(GtkPspell * gtkpspell) { - GtkXText * gtktext; - gtktext=gtkpspell->gtktext; -// if (prefs_common.auto_makepspell) { + GtkXText * gtktext; + + gtktext =gtkpspell->gtktext; +/* if (prefs_common.auto_makepspell) { */ gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); -// }; - gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); +/* }; */ + gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); - gtkpspell_uncheck_all(gtkpspell); + gtkpspell_uncheck_all(gtkpspell); } /*** Sylpheed (Claws) ***/ @@ -1141,7 +1287,7 @@ GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path) dict = g_new0(Dictionary, 1); dict->name = g_strndup(ent->d_name, tmp - ent->d_name); debug_print(_("Found dictionary %s\n"), dict->name); - list = g_slist_append(list, dict); + list = g_slist_insert_sorted(list, dict, (GCompareFunc) compare_dict); } } closedir(dir); @@ -1161,6 +1307,28 @@ GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path) return list; } +/* compare_dict () - compare 2 dict names */ + +static gint compare_dict(Dictionary *a, Dictionary *b) +{ + guchar *alanguage, *blanguage, + *aspelling, *bspelling, + *ajargon , *bjargon , + *amodule , *bmodule ; + guint aparts = 0, bparts = 0, i; + + for (i=0; i < strlen(a->name) ; i++) + if (a->name[i]=='-') + aparts++; + for (i=0; i < strlen(b->name) ; i++) + if (b->name[i]=='-') + bparts++; + + if (aparts != bparts) + return (aparts < bparts) ? -1 : +1 ; + else + return strcmp2(a->name, b->name); +} void gtkpspell_free_dictionary_list(GSList *list) { Dictionary *dict; @@ -1227,4 +1395,27 @@ gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu) return g_strdup(result); } + +/* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-* + * as needed by pspell. Returns an allocated string. + */ + +guchar *convert_to_pspell_encoding (const guchar *encoding) +{ + guchar * pspell_encoding; + /* Beware, strstr2 returns 0 if string is found -1 if not */ + if (!strstr2(encoding, "ISO-8859-")) { + pspell_encoding = g_strdup_printf("iso8859%s", encoding+8); + } + else + if (!strcmp2(encoding, "US-ASCII")) + pspell_encoding = g_strdup("iso8859-1"); + else + pspell_encoding = g_strdup(encoding); + return pspell_encoding; + +} + + + #endif