From 352a4cf61f6e0b266aed008a494e0262508d739e Mon Sep 17 00:00:00 2001 From: Melvin Hadasht Date: Tue, 18 Sep 2001 16:41:01 +0000 Subject: [PATCH] switched to pspell and dropped ispell support --- src/gtkspell.c | 1105 +++++++++++++++++++++++++++++++++--------------- src/gtkspell.h | 97 ++++- 2 files changed, 846 insertions(+), 356 deletions(-) diff --git a/src/gtkspell.c b/src/gtkspell.c index 3b9517ebc..eb7fa4955 100644 --- a/src/gtkspell.c +++ b/src/gtkspell.c @@ -1,4 +1,4 @@ -/* gtkspell - a spell-checking addon for GtkText +/* gtkpspell - a spell-checking addon for GtkText * Copyright (c) 2000 Evan Martin. * * This library is free software; you can redistribute it and/or @@ -24,10 +24,15 @@ * The Sylpheed Claws Team. */ +/* + * Adapted for pspell (c) 2001 Melvin Hadasht + * + */ #if defined(HAVE_CONFIG_H) #include "config.h" #endif +#if USE_PSPELL #include "intl.h" #include @@ -57,279 +62,515 @@ #include "gtkspell.h" +#include + /* size of the text buffer used in various word-processing routines. */ #define BUFSIZE 1024 /* number of suggestions to display on each menu. */ #define MENUCOUNT 15 -/* because we keep only one copy of the spell program running, - * all ispell-related variables can be static. - */ -volatile pid_t spell_pid = -1; -static int sp_fd_write[2], sp_fd_read[2]; -static int signal_set_up = 0; + +/* Only one config per session */ + +GtkPspellConfig * gtkpspellconfig; + +/* 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); static GdkColor highlight = { 0, 255 * 256, 0, 0 }; static void entry_insert_cb(GtkXText *gtktext, - gchar *newtext, guint len, guint *ppos, gpointer d); -static void set_up_signal(); + gchar *newtext, guint len, guint *ppos, + GtkPspell *gtkpspell); -int gtkspell_running() -{ - return (spell_pid > 0); -} +/* Run the first pspell_config from which every new config is */ +/* cloned */ -/* functions to interface with pipe */ -static void writetext(unsigned char *text_ccc) -{ - write(sp_fd_write[1], text_ccc, strlen(text_ccc)); +GtkPspellConfig * gtkpspell_init(){ + return new_pspell_config(); } -static int readpipe(unsigned char *buf, int bufsize) -{ - int len; - len = read(sp_fd_read[0], buf, bufsize - 1); - if (len < 0) { - debug_print(_("*** readpipe: read: %s\n"), strerror(errno)); - return -1; - } else if (len == 0) { - debug_print(_("*** readpipe: pipe closed.\n")); - return -1; - } else if (len == bufsize - 1) { - debug_print(_("*** readpipe: buffer overflowed?\n")); - } +/* Finish all. No more spelling. Called when the program ends */ - buf[len] = 0; - return len; +void gtkpspell_finished(GtkPspellConfig * gtkpspellconfig){ + if(gtkpspellconfig){ + delete_pspell_config( gtkpspellconfig ); + gtkpspellconfig = NULL; + } } -static int readline(unsigned char *buf) + +/* Test if there is a manager running */ + +int gtkpspell_running(GtkPspell * gtkpspell) { - return readpipe(buf, BUFSIZE); + return (gtkpspell->config!=NULL); } -static int readresponse(unsigned char *buf) -{ - int len; - len = readpipe(buf, BUFSIZE); - - /* all ispell responses of any reasonable length should end in \n\n. - * depending on the speed of the spell checker, this may require more - * reading. */ - if (len >= 2 && (buf[len - 1] != '\n' || buf[len - 2] != '\n')) { - len += readpipe(buf + len, BUFSIZE - len); - } +/* Creates a new session if a gtkpspellconfig exists */ +/* The settings are defaults. If no path/dict is set afterwards, the default one is used */ - /* now we can remove all of the the trailing newlines. */ - while (len > 0 && buf[len - 1] == '\n') - buf[--len] = 0; +GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig){ + GtkPspell *gtkpspell; - return len; + 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; } -void gtkspell_stop() -{ - if (gtkspell_running()) { - kill(spell_pid, SIGTERM); - debug_print(_("*** Kill pid[%i] returned: %s\n"), spell_pid, strerror(errno)); - while (spell_pid != -1); +/* 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; } -static int poller(int buffer) -{ - int len; - fd_set rfds; - struct timeval tv; - int retval; - FD_ZERO(&rfds); - FD_SET(buffer, &rfds); - memset(&tv, 0, sizeof(tv)); - tv.tv_sec = 2; - tv.tv_usec = 0; - return select(buffer + 1, &rfds, NULL, NULL, &tv); -} +/* Finishes a session */ + +GtkPspell * gtkpspell_delete( GtkPspell *gtkpspell ){ + + if( gtkpspell->checker ){ + delete_pspell_manager( gtkpspell->checker ); + gtkpspell->checker = NULL; + gtkpspell->possible_err = NULL; /* checker is a cast from + possible_err */ + } -int gtkspell_start(unsigned char *path, char * args[]) + 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 ); + return NULL; +} + + +int set_path_and_dict( GtkPspell *gtkpspell, + PspellConfig *config, + guchar *path, + guchar * dict ) { - int fd_error[2]; - FILE *sav_stdin, *sav_stdout, *sav_stderr; - char buf[BUFSIZE]; - int retncode; - - if (gtkspell_running()) { - debug_print(_("*** gtkspell_start called while already running.\n")); - gtkspell_stop(); + 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; + + language = buf; + if(( module=strrchr(buf,'-'))!=NULL){ + module++; + if(( end=strrchr(module,'.'))!=NULL) + end[0]=0x00; } - if (!signal_set_up) { - set_up_signal(); - signal_set_up = 1; + /* 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); + + return -1; +} - pipe(sp_fd_write); - pipe(sp_fd_read); - pipe(fd_error); - - spell_pid = fork(); - if (spell_pid < 0) { - debug_print(_("*** fork: %s\n"), strerror(errno)); - return -1; - } else if (spell_pid == 0) { - sav_stdin = fdopen(dup(fileno(stdin)), "r"); - sav_stdout = fdopen(dup(fileno(stdout)), "w"); - sav_stderr = fdopen(dup(fileno(stderr)), "w"); - dup2(sp_fd_write[0], 0); - dup2(sp_fd_read[1], 1); - dup2(fd_error[1], 2); - close(sp_fd_read[0]); - close(fd_error[0]); - close(sp_fd_write[1]); - - if (path == NULL) { - if (execvp(args[0], args) < 0) - //DONT call debug_print here, because stdout is closed at this moment - fprintf(sav_stderr, _("*** execvp('%s'): %s\n"), args[0], strerror(errno)); - } else { - if (execv(path, args) < 0) - //DONT call debug_print here, because stdout is closed at this moment - fprintf(sav_stderr, _("*** execv('%s'): %s\n"), path, strerror(errno)); - } - /* if we get here, we failed. - * send some text on the pipe to indicate status. - */ - write(sp_fd_read[1], "!", 1); +/* 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){ - _exit(0); - } else { - retncode = poller(sp_fd_read[1]); - if (retncode < 0) { - debug_print(_("*** Spell comand failed: %s.\n"), strerror(errno)); - gtkspell_stop(); - return -1; - } - readline(buf); - /* ispell should print something like this: - * @(#) International Ispell Version 3.1.20 10/10/95 - * if it doesn't, it's an error. */ - if (buf[0] != '@') { - debug_print(_("*** ispell didnt print '@'\n")); - gtkspell_stop(); - return -1; - } - } + PspellConfig * config2; - /* put ispell into terse mode. - * this makes it not respond on correctly spelled words. */ - sprintf(buf, "!\n"); - writetext(buf); + /* It seems changing an already running config is not the way to go + */ + + config2 = pspell_config_clone( gtkpspell->config ); + + if(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; -} + } + + 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 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; + } -static GList* misspelled_suggest(unsigned char *word) -{ - unsigned char buf[BUFSIZE]; - unsigned char *newword; - GList *l = NULL; - int count; - sprintf(buf, "^%s\n", word); /* guard against ispell control chars */ - writetext(buf); - readresponse(buf); - switch (buf[0]) { /* first char is ispell command. */ - case 0: /* no response: word is ok. */ - return NULL; - case 10: /* just enter word is ok. */ - return NULL; - case '&': /* misspelled, with suggestions */ - /* & : , , , ... */ - strtok(buf, " "); /* & */ - newword = strtok(NULL, " "); /* orig */ - l = g_list_append(l, g_strdup(newword)); - newword = strtok(NULL, " "); /* count */ - count = atoi(newword); - strtok(NULL, " "); /* ofs: */ - - while ((newword = strtok(NULL, ",")) != NULL) { - int len = strlen(newword); - if (newword[len - 1] == ' ' || newword[len - 1] == '\n') - newword[len - 1] = 0; - if (count == 0) { - g_list_append(l, NULL); /* signal the "suggestions" */ - } - /* add it to the list, skipping the initial space. */ - l = g_list_append(l, - g_strdup(newword[0] == ' ' ? newword + 1 : newword)); + gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err); - count--; - } - return l; - case '?': /* ispell is guessing. */ - case '#': /* misspelled, no suggestions */ - /* # */ - strtok(buf, " "); /* & */ - newword = strtok(NULL, " "); /* orig */ - l = g_list_append(l, g_strdup(newword)); - return l; - default: - debug_print(_("*** Unsupported spell command '%c'.\n"), buf[0]); + return -1; +} + +/* 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; + + if(gtkpspell->config==NULL) + return 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=NULL ) return NULL; + + path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path")); + + return path; +} + +/* Menu callback : change dict */ + +static void menu_change_dict(GtkWidget *w, GtkPspell * gtkpspell){ + + guchar *thedict,*thelabel; + + /* Dict is simply the menu label */ + + 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); +} + + +/* 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 */ +/* 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); -static int misspelled_test(unsigned char *word) + 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; +} + + +/* Create a suggestion list for word */ + +static GList* misspelled_suggest( GtkPspell * gtkpspell, guchar *word ) { - unsigned char buf[BUFSIZE]; - sprintf(buf, "^%s\n", word); /* guard against ispell control chars */ - writetext(buf); - readresponse(buf); - - if (buf[0] == 0) { - return 0; - } else if (buf[0] == '&' || buf[0] == '#' || buf[0] == '?') { - return 1; - } + 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; +} - debug_print(_("*** Unsupported spell command '%c'.\n"), buf[0]); - return -1; +/* 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; } + static gboolean iswordsep(unsigned char c) { return !isalpha(c) && c != '\''; } -static guchar get_text_index_whar(GtkXText *gtktext, int pos) +static guchar get_text_index_whar(GtkPspell * gtkpspell, int pos) { guchar a; gchar *text; - text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), pos, pos + 1); + 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(GtkXText *gtktext, int pos, unsigned char* buf, +static gboolean get_word_from_pos(GtkPspell * gtkpspell, int pos, + unsigned char* buf, int *pstart, int *pend) { gint start, end; - if (iswordsep(get_text_index_whar(gtktext, pos))) return FALSE; + 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(gtktext, start))) break; + 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(gtktext, end))) break; + if (iswordsep(get_text_index_whar(gtkpspell, end))) break; } if (buf) { - for (pos = start; pos < end; pos++) buf[pos - start] = get_text_index_whar(gtktext, pos); + for (pos = start; pos < end; pos++) buf[pos - start] = get_text_index_whar(gtkpspell, pos); buf[pos - start] = 0; } @@ -339,69 +580,80 @@ static gboolean get_word_from_pos(GtkXText *gtktext, int pos, unsigned char* buf return TRUE; } -static gboolean get_curword(GtkXText *gtktext, unsigned char* buf, +static gboolean get_curword(GtkPspell * gtkpspell, unsigned char* buf, int *pstart, int *pend) { - int pos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - return get_word_from_pos(gtktext, 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(GtkXText *gtktext, int start, int end, GdkColor *color) +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 (prefs_common.auto_makeispell) { - gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_insert_cb), NULL); -// } - gtk_xtext_set_point(gtktext, start); - gtk_xtext_forward_delete(gtktext, end - start); + 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); - if (newtext && end - start > 0) gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start); - // if (prefs_common.auto_makeispell) { - gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_insert_cb), NULL); - // } - gtk_xtext_thaw(gtktext); +/* gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);*/ + } + gtk_xtext_thaw(gtktext); } -static gboolean check_at(GtkXText *gtktext, 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(gtktext, from_pos, buf, &start, &end)) { + if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end)) { return FALSE; }; - if (misspelled_test(buf)) { + 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(gtktext, start, end, &highlight); + change_color(gtkpspell, start, end, &highlight); return TRUE; } else { - change_color(gtktext, start, end, + change_color(gtkpspell, start, end, &(GTK_WIDGET(gtktext)->style->fg[0])); return FALSE; } } -void gtkspell_check_all(GtkXText *gtktext) + +static void check_all(GtkWidget *w, GtkPspell * gtkpspell){ + gtkpspell_check_all(gtkpspell); +} + + +void gtkpspell_check_all(GtkPspell * gtkpspell) { guint origpos; guint pos = 0; guint len; float adj_value; + GtkXText * gtktext; + gtktext=gtkpspell->gtktext; - if (!gtkspell_running()) return ; + if (!gtkpspell_running(gtkpspell)) return ; len = gtk_xtext_get_length(gtktext); @@ -409,12 +661,12 @@ void gtkspell_check_all(GtkXText *gtktext) gtk_xtext_freeze(gtktext); origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); while (pos < len) { - while (pos < len && iswordsep(get_text_index_whar(gtktext, pos))) + while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos))) pos++; - while (pos < len && !iswordsep(get_text_index_whar(gtktext, pos))) + while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos))) pos++; if (pos > 0) - check_at(gtktext, pos - 1); + check_at(gtkpspell, pos - 1); } gtk_xtext_thaw(gtktext); gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); @@ -422,88 +674,272 @@ void gtkspell_check_all(GtkXText *gtktext) } -static void entry_insert_cb(GtkXText *gtktext, - gchar *newtext, guint len, guint *ppos, gpointer d) +static void entry_insert_cb(GtkXText *gtktext, + gchar *newtext, guint len, guint *ppos, + GtkPspell * gtkpspell) { int origpos; - if (!gtkspell_running()) return ; + if (!gtkpspell_running(gtkpspell)) return ; gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), - NULL); + 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), - NULL); + 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(gtktext, *ppos - 2); + if (*ppos >= 2) check_at(gtkpspell, *ppos - 2); /* did we just split a word? */ if (*ppos < gtk_xtext_get_length(gtktext)) - check_at(gtktext, *ppos + 1); + 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(gtktext, *ppos))) - check_at(gtktext, *ppos - 1); + !iswordsep(get_text_index_whar(gtkpspell, *ppos))) + check_at(gtkpspell, *ppos - 1); } gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); } static void entry_delete_cb(GtkXText *gtktext, - gint start, gint end, gpointer d) + gint start, gint end, GtkPspell *gtkpspell) { int origpos; - if (!gtkspell_running()) return ; + if (!gtkpspell_running(gtkpspell)) return ; origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - check_at(gtktext, start - 1); + 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. */ } -static void replace_word(GtkWidget *w, gpointer d) +static void replace_word(GtkWidget *w, GtkPspell * gtkpspell) { int start, end; unsigned char *newword; unsigned char buf[BUFSIZE]; - gtk_xtext_freeze(GTK_XTEXT(d)); + 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(GTK_XTEXT(d), buf, &start, &end); + 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); + 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))); + gtk_xtext_thaw(GTK_XTEXT(gtktext)); +} - gtk_xtext_set_point(GTK_XTEXT(d), end); - gtk_xtext_backward_delete(GTK_XTEXT(d), end - start); - gtk_xtext_insert(GTK_XTEXT(d), NULL, NULL, NULL, newword, strlen(newword)); +/* Accept this word for this session */ - gtk_xtext_thaw(GTK_XTEXT(d)); +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)); + + pspell_manager_add_to_session(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))); + gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); +} + +/* Add word to personal dict. Save the list at every addition (may be + not efficient...) */ + +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)); + + pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword)); + pspell_manager_save_all_word_lists(gtkpspell->checker); + + 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(GList *l, GtkXText *gtktext) + +static GtkMenu *make_menu_config(GtkPspell *gtkpspell){ + GtkWidget *menu, *item, *submenu; + + + 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_signal_connect(GTK_OBJECT(item),"activate", + GTK_SIGNAL_FUNC(check_all),gtkpspell); + + + item = gtk_menu_item_new(); + 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); + + + { + 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); + + 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); + + + + 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); + + 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); + + + + 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) { GtkWidget *menu, *item; unsigned char *caption; + GtkXText * gtktext; + gtktext=gtkpspell->gtktext; + menu = gtk_menu_new(); - - caption = g_strdup_printf(_("Not in dictionary: %s"), (unsigned char*)l->data); - item = gtk_menu_item_new_with_label(caption); - /* I'd like to make it so this item is never selectable, like - * the menu titles in the GNOME panel... unfortunately, the GNOME - * panel creates their own custom widget to do this! */ - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); + 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); + + gtk_signal_connect(GTK_OBJECT(item), "activate", + 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); + + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(add_word_to_personal), gtkpspell); + item = gtk_menu_item_new(); gtk_widget_show(item); @@ -536,7 +972,7 @@ static GtkMenu *make_menu(GList *l, GtkXText *gtktext) } item = gtk_menu_item_new_with_label((unsigned char*)l->data); gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(replace_word), gtktext); + GTK_SIGNAL_FUNC(replace_word), gtkpspell); gtk_widget_show(item); gtk_menu_append(GTK_MENU(curmenu), item); count++; @@ -545,20 +981,31 @@ static GtkMenu *make_menu(GList *l, GtkXText *gtktext) return GTK_MENU(menu); } -static void popup_menu(GtkXText *gtktext, GdkEventButton *eb) +static void popup_menu(GtkPspell * gtkpspell, GdkEventButton *eb) { unsigned char buf[BUFSIZE]; GList *list, *l; - if (!get_curword(gtktext, buf, NULL, NULL)) return ; - if (buf == NULL) return ; - list = misspelled_suggest(buf); - if (list != NULL) { - gtk_menu_popup(make_menu(list, gtktext), NULL, NULL, NULL, NULL, - eb->button, eb->time); - for (l = list; l != NULL; l = l->next) - g_free(l->data); - g_list_free(list); + 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); + } /* ok, this is pretty wacky: @@ -569,12 +1016,13 @@ static void popup_menu(GtkXText *gtktext, 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, gpointer d) +static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell * gtkpspell) + { GdkEventButton *eb; gboolean retval; - if (!gtkspell_running()) return FALSE; + if (!gtkpspell_running(gtkpspell)) return FALSE; if (e->type != GDK_BUTTON_PRESS) return FALSE; eb = (GdkEventButton*) e; @@ -584,24 +1032,27 @@ static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, gpointer d /* forge the leftclick */ eb->button = 1; - gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(button_press_intercept_cb), d); + 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), d); + 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(gtktext, eb); + popup_menu(gtkpspell, eb); return TRUE; } -void gtkspell_uncheck_all(GtkXText *gtktext) +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)); @@ -615,56 +1066,34 @@ void gtkspell_uncheck_all(GtkXText *gtktext) gtk_adjustment_set_value(gtktext->vadj, adj_value); } -void gtkspell_attach(GtkXText *gtktext) +void gtkpspell_attach(GtkPspell * gtkpspell, GtkXText *gtktext) { -// if (prefs_common.auto_makeispell) { + gtkpspell->gtktext=gtktext; +// if (prefs_common.auto_makepspell) { gtk_signal_connect(GTK_OBJECT(gtktext), "insert-text", - GTK_SIGNAL_FUNC(entry_insert_cb), NULL); + GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text", - GTK_SIGNAL_FUNC(entry_delete_cb), NULL); + GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); // }; gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event", - GTK_SIGNAL_FUNC(button_press_intercept_cb), NULL); + GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); } -void gtkspell_detach(GtkXText *gtktext) +void gtkpspell_detach(GtkPspell * gtkpspell) { -// if (prefs_common.auto_makeispell) { + GtkXText * gtktext; + gtktext=gtkpspell->gtktext; +// if (prefs_common.auto_makepspell) { gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_insert_cb), NULL); + GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_delete_cb), NULL); + GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); // }; gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(button_press_intercept_cb), NULL); + GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); - gtkspell_uncheck_all(gtktext); -} - -static void sigchld(int param) -{ - int retstat, retval; - - debug_print(_("*** SIGCHLD called. (ispell pid: %i)\n"), spell_pid); - while ((retval = waitpid( -1, &retstat, WNOHANG)) > 0) { - if (retval == spell_pid) { - debug_print(_("*** SIGCHLD called for ispell. (pid: %i)\n"), spell_pid); - spell_pid = -1; - } - } -} - -static void set_up_signal() -{ - /* RETSIGTYPE is found in autoconf's config.h */ -#ifdef RETSIGTYPE - typedef RETSIGTYPE (*sighandler)(int); - signal(SIGCHLD, (sighandler)sigchld); -#else - /* otherwise, just hope it works */ - signal(SIGCHLD, sigchld); -#endif + gtkpspell_uncheck_all(gtkpspell); } /*** Sylpheed (Claws) ***/ @@ -676,13 +1105,11 @@ static GSList *create_empty_dictionary_list(void) dict = g_new0(Dictionary, 1); dict->name = g_strdup(_("None")); - dict->path = NULL; return g_slist_append(list, dict); } -/* gtkspell_get_dictionary_list() - returns list of dictionary names and the full - * path of file names. */ -GSList *gtkspell_get_dictionary_list(const gchar *ispell_path) +/* gtkpspell_get_dictionary_list() - returns list of dictionary names */ +GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path) { GSList *list; gchar *dict_path, *tmp, *prevdir; @@ -693,18 +1120,10 @@ GSList *gtkspell_get_dictionary_list(const gchar *ispell_path) list = NULL; - /* ASSUME: ispell_path is full path */ - dict_path = strstr(ispell_path + 1, G_DIR_SEPARATOR_S); - tmp = g_strndup(ispell_path, dict_path - ispell_path); - - /* ASSUME: ispell dictionaries in PREFIX/lib/ispell */ - dict_path = g_strconcat(tmp, G_DIR_SEPARATOR_S, "lib", G_DIR_SEPARATOR_S, "ispell", NULL); - g_free(tmp); - #ifdef USE_THREADS #warning TODO: no directory change #endif - + dict_path=g_strdup(pspell_path); prevdir = g_get_current_dir(); if (chdir(dict_path) <0) { FILE_OP_ERROR(dict_path, "chdir"); @@ -717,12 +1136,11 @@ GSList *gtkspell_get_dictionary_list(const gchar *ispell_path) if (NULL != (dir = opendir("."))) { while (NULL != (ent = readdir(dir))) { - /* search for hash table */ - if (NULL != (tmp = strstr(ent->d_name, ".hash"))) { + /* search for pwli */ + if (NULL != (tmp = strstr(ent->d_name, ".pwli"))) { dict = g_new0(Dictionary, 1); dict->name = g_strndup(ent->d_name, tmp - ent->d_name); - dict->path = g_strconcat(dict_path, G_DIR_SEPARATOR_S, ent->d_name, NULL); - debug_print(_("Found dictionary %s\n"), dict->path); + debug_print(_("Found dictionary %s\n"), dict->name); list = g_slist_append(list, dict); } } @@ -733,13 +1151,17 @@ GSList *gtkspell_get_dictionary_list(const gchar *ispell_path) debug_print(_("No dictionary found\n")); list = create_empty_dictionary_list(); } + if(list==NULL){ + debug_print(_("No dictionary found")); + list = create_empty_dictionary_list(); + } chdir(prevdir); g_free(dict_path); g_free(prevdir); return list; } -void gtkspell_free_dictionary_list(GSList *list) +void gtkpspell_free_dictionary_list(GSList *list) { Dictionary *dict; GSList *walk; @@ -748,8 +1170,6 @@ void gtkspell_free_dictionary_list(GSList *list) dict = (Dictionary *) walk->data; if (dict->name) g_free(dict->name); - if (dict->path) - g_free(dict->path); g_free(dict); } g_slist_free(list); @@ -763,14 +1183,14 @@ static void dictionary_option_menu_item_data_destroy(gpointer data) g_free(str); } -GtkWidget *gtkspell_dictionary_option_menu_new(const gchar *ispell_path) +GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path) { GSList *dict_list, *tmp; GtkWidget *item; GtkWidget *menu; Dictionary *dict; - dict_list = gtkspell_get_dictionary_list(ispell_path); + dict_list = gtkpspell_get_dictionary_list(pspell_path); g_return_val_if_fail(dict_list, NULL); menu = gtk_menu_new(); @@ -778,9 +1198,9 @@ GtkWidget *gtkspell_dictionary_option_menu_new(const gchar *ispell_path) for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) { dict = (Dictionary *) tmp->data; item = gtk_menu_item_new_with_label(dict->name); - if (dict->path) - gtk_object_set_data_full(GTK_OBJECT(item), "full_path", - g_strdup(dict->path), + if (dict->name) + gtk_object_set_data_full(GTK_OBJECT(item), "dict_name", + g_strdup(dict->name), dictionary_option_menu_item_data_destroy); gtk_menu_append(GTK_MENU(menu), item); gtk_widget_show(item); @@ -788,22 +1208,23 @@ GtkWidget *gtkspell_dictionary_option_menu_new(const gchar *ispell_path) gtk_widget_show(menu); - gtkspell_free_dictionary_list(dict_list); + gtkpspell_free_dictionary_list(dict_list); return menu; } -gchar *gtkspell_get_dictionary_menu_active_item(GtkWidget *menu) + + +gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu) { GtkWidget *menuitem; gchar *result; g_return_val_if_fail(GTK_IS_MENU(menu), NULL); menuitem = gtk_menu_get_active(GTK_MENU(menu)); - - result = gtk_object_get_data(GTK_OBJECT(menuitem), "full_path"); - g_return_val_if_fail(result, NULL); - - return g_strdup(result); + result = gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name"); + g_return_val_if_fail(result, NULL); + return g_strdup(result); + } - +#endif diff --git a/src/gtkspell.h b/src/gtkspell.h index 03214187a..abf03e4e1 100644 --- a/src/gtkspell.h +++ b/src/gtkspell.h @@ -1,7 +1,7 @@ /* Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev */ -/* gtkspell - a spell-checking addon for GtkText +/* gtkpspell - a spell-checking addon for GtkText * Copyright (c) 2000 Evan Martin. * * This library is free software; you can redistribute it and/or @@ -23,31 +23,100 @@ * Adapted by the Sylpheed Claws Team. */ -#ifndef __gtkspell_h__ -#define __gtkspell_h__ +/* + * Adapted for pspell (c) 2001 Melvin Hadasht + * + */ + + /* first a pspell config must be created (at the beginning of the app) + with + GtkPspellConfig gtkpspellconfig = gtkpspell_init(); + then for each document use this to create a manager + GtkPspell = gtkpspell_new(GtkPspellConfig *gtkpspellconfig); + Now, path and dict can be set + gtkpspell_set_path_and_dict(GtkPspell *gtkpspell, guchar * path, guchar * dict); + then attach this to a gtktext widget : + gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *gtkxtext); + and we can also detach : + gtkpspell_deattach(GtkPspell *gtkpspell, GtkXText *gtkxtext); + When finished, GtkPspell can be deleted with + gtkpspell_delete(GtkPspell * gtkpspell); + At the end of the app, GtkPspellConfig should be deleted with : + gtkpspell_finished(GtkPspellConfig * gtkpspellconfig); +*/ + +#ifndef __gtkpspell_h__ +#define __gtkpspell_h__ #include "gtkxtext.h" +#include + +#define PSPELL_FASTMODE 1 +#define PSPELL_NORMALMODE 2 +#define PSPELL_BADSPELLERMODE 3 typedef struct _Dictionary { gchar *name; - gchar *path; } Dictionary; -int gtkspell_start(unsigned char *path, char * args[]); +typedef struct _GtkPspell +{ + PspellConfig * config; + PspellCanHaveError * possible_err ; + PspellManager * checker; + gchar theword[1111]; + gchar *path; + gchar *dict; + guint mode; + + GSList * dictionary_list; + GtkXText * gtktext; + +} GtkPspell; + +typedef PspellConfig GtkPspellConfig; +/* Create a new gtkspell instance to manage one text widget */ + +/* These one create and delete a pspell config */ +GtkPspellConfig * gtkpspell_init(); +void gtkpspell_finished(GtkPspellConfig * gtkpspellconfig); + +/* These ones create and delete a manager*/ +GtkPspell * gtkpspell_new(GtkPspellConfig * config); + +GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig, + guchar *path, + guchar *dict, + guint mode, + guchar *encoding); +GtkPspell * gtkpspell_delete(GtkPspell *gtkpspell); + +int gtkpspell_set_path_and_dict(GtkPspell *gtkpspell, guchar * path, + guchar * dict); +guchar * gtkpspell_get_dict(GtkPspell *gtkpspell); + +guchar * gtkpspell_get_path(GtkPspell *gtkpspell); + +/* This sets suggestion mode "fast" "normal" "bad-spellers" */ +/* and resets the dict & path (which should be set first) */ +/* return 0 on failure and -1 on success */ +int gtkpspell_set_sug_mode(GtkPspell * gtkpspell, gchar * themode); + +void gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *text_ccc); -void gtkspell_attach(GtkXText *text_ccc); +void gtkpspell_detach(GtkPspell *gtkpspell); -void gtkspell_detach(GtkXText *gtktext); +void gtkpspell_check_all(GtkPspell *gtkpspell); -void gtkspell_check_all(GtkXText *gtktext); +void gtkpspell_uncheck_all(GtkPspell *gtkpspell); -void gtkspell_uncheck_all(GtkXText *gtktext); +GSList *gtkpspell_get_dictionary_list(const char *pspell_path); -GSList *gtkspell_get_dictionary_list(const char *ispell_path); +void gtkpspell_free_dictionary_list(GSList *list); -void gtkspell_free_dictionary_list(GSList *list); +GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path); +gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu); -GtkWidget *gtkspell_dictionary_option_menu_new(const gchar *ispell_path); -gchar *gtkspell_get_dictionary_menu_active_item(GtkWidget *menu); +extern GtkPspellConfig * gtkpspellconfig; -#endif /* __gtkspell_h__ */ +#endif /* __gtkpspell_h__ */ -- 2.25.1