* 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
#include "gtkspell.h"
#include <pspell/pspell.h>
-
/* 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
-
-/* 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,
- GtkPspell *gtkpspell);
+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 void entry_delete_cb (GtkXText *gtktext, gint start, gint end,
+ GtkPspell *gtkpspell);
+static gint compare_dict (Dictionary *a, Dictionary *b);
+guchar *convert_to_pspell_encoding (const guchar *encoding);
+
+static void allocate_color(GtkPspell *gtkpspell);
+
+/* gtkspellconfig - only one config per session */
+GtkPspellConfig * gtkpspellconfig;
-/* 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;
+ 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;
- 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;
-}
+ gtkpspell->config = pspell_config_clone(gtkpspellconfig);
+ gtkpspell->mode = mode;
+ 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);
+ }
+ gtkpspell->possible_err = new_pspell_manager(gtkpspell->config);
+ gtkpspell->checker = NULL;
-/* Finishes a session */
+ 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 );
+ }
-GtkPspell * gtkpspell_delete( GtkPspell *gtkpspell ){
+ 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 : */
- /* <lang>[[-<spelling>[-<jargon>]]-<module>.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 : */
+ /* <lang>[[-<spelling>[-<jargon>]]-<module>.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 (temppath[strlen(temppath)-1] == G_DIR_SEPARATOR)
+ temppath[strlen(temppath)-1]= 0;
+ if (temppath) {
+ pspell_config_replace(config, "add-word-list-path", temppath);
+ debug_print(_("Pspell config: added path %s\n"), pspell_config_retrieve(config, "word-list-path"));
+ if (pspell_config_error_number(config))
+ debug_print(_("Pspell config: %s\n"), pspell_config_error_message(config));
+ }
+ 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);
+
+ 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 *gtkpspell_get_dict(GtkPspell *gtkpspell)
+{
+/* Number of dashes in a dictionary name + 1 (for trailing null)
+ * needed when rebuilding dictionary name
+ */
+#define DASHES_IN_DICTNAME 3+1
- guchar * dict;
- guchar * language;
- guchar * spelling;
- guchar * jargon;
- guint len;
+ 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( 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);
+ 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 (len + DASHES_IN_DICTNAME < BUFSIZE) {
+ dict = g_new(char,len + DASHES_IN_DICTNAME);
+ 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 */
+/* menu_change_dict() - Menu callback : change dict */
+static void menu_change_dict(GtkWidget *w, GtkPspell *gtkpspell)
+{
+ guchar *thedict,
+ *thelabel;
-static void menu_change_dict(GtkWidget *w, GtkPspell * gtkpspell){
+ /* Dict is simply the menu label */
- guchar *thedict,*thelabel;
-
- /* Dict is simply the menu label */
+ gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &thelabel);
+
+ if (!strcmp2(thelabel, _("None")))
+ return;
- gtk_label_get( GTK_LABEL(GTK_BIN(w)->child),(gchar **) &thelabel );
- thedict=g_strdup(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 ?) */
+ if(!gtkpspell_set_path_and_dict(gtkpspell, gtkpspell->path, thedict)) {
+ /* FIXME : try to handle this very special case */
+ debug_print("Pspell: Attempt to change to a non existant dict. I will crash after closing compose window.\n");
+ gtkpspell_detach(gtkpspell);
+ gtkpspell = gtkpspell_delete(gtkpspell);
+ }
+ 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++;
+ /* 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. */
- for (end = pos; end < gtk_xtext_get_length(gtktext); end++) {
- if (iswordsep(get_text_index_whar(gtkpspell, end))) break;
- }
-
- 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_xtext_set_point(gtktext, start);
+ gtk_xtext_forward_delete(gtktext, end - start);
+
+ gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start);
+ g_free(newtext);
+ }
+ 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)) {
+ change_color(gtkpspell, start, end, &(gtkpspell->highlight));
+ return TRUE;
+ } else {
+ change_color(gtkpspell, start, end, NULL);
+ 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));
- 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);
+ 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, NULL, 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_xtext_set_point(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_signal_handler_block_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_insert_cb),
+ gtkpspell);
+ gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_delete_cb),
+ gtkpspell);
+ gtk_xtext_set_point(gtktext, start);
+ gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "delete-text", start, end);
+ gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "insert-text", newword, strlen(newword), &start);
+
+ gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_insert_cb),
+ gtkpspell);
+ gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_delete_cb),
+ gtkpspell);
+ 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( !(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]=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:
* 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);
- gtk_grab_remove(GTK_WIDGET(gtktext));
- 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);
+
+ allocate_color(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) ***/
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);
list = create_empty_dictionary_list();
}
if(list==NULL){
- debug_print(_("No dictionary found"));
+ debug_print(_("No dictionary found\n"));
list = create_empty_dictionary_list();
}
chdir(prevdir);
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;
return g_strdup(result);
}
+
+GtkWidget *gtkpspell_sugmode_option_menu_new(gint sugmode)
+{
+ GtkWidget *menu;
+ GtkWidget *item;
+
+
+ menu = gtk_menu_new();
+ gtk_widget_show(menu);
+
+ item = gtk_menu_item_new_with_label(_("Fast Mode"));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_FASTMODE));
+
+ item = gtk_menu_item_new_with_label(_("Normal Mode"));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_NORMALMODE));
+
+ item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_BADSPELLERMODE));
+
+ return menu;
+}
+
+void gtkpspell_sugmode_option_menu_set(GtkOptionMenu *optmenu, gint sugmode)
+{
+ g_return_if_fail(GTK_IS_OPTION_MENU(optmenu));
+
+ g_return_if_fail(sugmode == PSPELL_FASTMODE ||
+ sugmode == PSPELL_NORMALMODE ||
+ sugmode == PSPELL_BADSPELLERMODE);
+
+ gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
+}
+
+gint gtkpspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
+{
+ gint sugmode;
+ GtkWidget *item;
+
+ g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
+
+ item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
+
+ sugmode = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item), "sugmode"));
+
+ return sugmode;
+
+}
+
+/* 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;
+
+ 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;
+
+}
+
+static void allocate_color(GtkPspell *gtkpspell)
+{
+
+ GdkColormap *gc;
+ /* Color allocation */
+ gc = gtk_widget_get_colormap(GTK_WIDGET(gtkpspell->gtktext));
+
+ if (gtkpspell->highlight.pixel)
+ gdk_colormap_free_colors(gc, &(gtkpspell->highlight), 1);
+
+ gtkut_convert_int_to_gdk_color(prefs_common.misspelled_col,
+ &(gtkpspell->highlight));
+
+ /* add an entry for the highlight in the color map. */
+ gdk_colormap_alloc_color(gc, &(gtkpspell->highlight), FALSE, TRUE);
+}
+
#endif
projects / claws.git / blobdiff