src/gtkspell.c

   1 /* gtkpspell - a spell-checking addon for GtkText
   2  * Copyright (c) 2000 Evan Martin.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  17  */
  18 /*
  19     Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
  20  */
  21
  22 /*
  23  * Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto &
  24  * The Sylpheed Claws Team.
  25  */
  26
  27 /*
  28  *  Adapted for pspell (c) 2001 Melvin Hadasht
  29  *
  30  */
  31 #if defined(HAVE_CONFIG_H)
  32 #include "config.h"
  33 #endif
  34
  35 #if USE_PSPELL
  36 #include "intl.h"
  37
  38 #include <gtk/gtk.h>
  39 #include <sys/types.h>
  40 #include <sys/wait.h>
  41 #include <unistd.h>
  42 #include <stdio.h>
  43 #include <signal.h>
  44 #include <ctype.h>
  45 #include <string.h>
  46 #include <stdlib.h>
  47 #include <errno.h>
  48 #include <stdio.h>
  49 #include <sys/time.h>
  50 #include <fcntl.h>
  51 #include <time.h>
  52 #include <prefs_common.h>
  53 #include <utils.h>
  54
  55 #include <dirent.h>
  56
  57 #include <gtk/gtkoptionmenu.h>
  58 #include <gtk/gtkmenu.h>
  59 #include <gtk/gtkmenuitem.h>
  60
  61 #include "gtkxtext.h"
  62
  63 #include "gtkspell.h"
  64
  65 #include <pspell/pspell.h>
  66
  67 /* size of the text buffer used in various word-processing routines. */
  68 #define BUFSIZE 1024
  69
  70 /* number of suggestions to display on each menu. */
  71 #define MENUCOUNT 15
  72
  73
  74 /* Only one config per session */
  75
  76 GtkPspellConfig * gtkpspellconfig;
  77
  78 /* Function called from menus */
  79
  80 static void add_word_to_session(GtkWidget *w, GtkPspell * d);
  81 static void add_word_to_personal(GtkWidget *w, GtkPspell * d);
  82 static void set_sug_mode(GtkWidget *w, GtkPspell * gtkpspell);
  83 static void check_all(GtkWidget *w, GtkPspell * gtkpspell);
  84 static void menu_change_dict(GtkWidget *w, GtkPspell * gtkpspell);
  85
  86 static GdkColor highlight = { 0, 255 * 256, 0, 0 };
  87
  88 static void entry_insert_cb(GtkXText *gtktext,
  89                             gchar *newtext, guint len, guint *ppos,
  90                             GtkPspell *gtkpspell);
  91
  92 /*  Run the first pspell_config from which every new config is */
  93 /*    cloned  */
  94
  95 GtkPspellConfig * gtkpspell_init(){
  96   return new_pspell_config();
  97 }
  98
  99 /* Finish all. No more spelling. Called when the program ends */
 100
 101 void gtkpspell_finished(GtkPspellConfig * gtkpspellconfig){
 102   if(gtkpspellconfig){
 103     delete_pspell_config( gtkpspellconfig );
 104     gtkpspellconfig = NULL;
 105   }
 106 }
 107
 108
 109 /* Test if there is a manager running */
 110
 111 int gtkpspell_running(GtkPspell * gtkpspell)
 112 {
 113         return (gtkpspell->config!=NULL);
 114 }
 115
 116 /* Creates a new session if a gtkpspellconfig exists */
 117 /* The settings are defaults.  If no path/dict is set afterwards, the default one is used  */
 118
 119 GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig){
 120   GtkPspell *gtkpspell;
 121
 122   if( gtkpspellconfig == NULL ){
 123     gtkpspellconfig=gtkpspell_init();
 124     if(gtkpspellconfig==NULL){
 125       debug_print(_("Pspell could not be started."));
 126       prefs_common.enable_pspell=FALSE;
 127       return NULL;
 128     }
 129   }
 130
 131   gtkpspell               = g_new( GtkPspell ,1);
 132   gtkpspell->config       = gtkpspellconfig;
 133   gtkpspell->possible_err = new_pspell_manager( gtkpspell->config );
 134   gtkpspell->checker      = NULL;
 135
 136   if( pspell_error_number( gtkpspell->possible_err ) != 0){
 137     debug_print(_("Pspell error : %s\n"), pspell_error_message( gtkpspell->possible_err ));
 138     delete_pspell_can_have_error( gtkpspell->possible_err );
 139   }
 140   else{
 141     gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
 142   }
 143
 144   gtkpspell->dictionary_list = NULL;
 145   gtkpspell->path            = NULL;
 146   gtkpspell->dict            = NULL;
 147   gtkpspell->mode            = PSPELL_FASTMODE;
 148   gtkpspell->gtktext         = NULL;
 149   return gtkpspell;
 150 }
 151
 152 /* Creates a new session and set path/dic */
 153
 154 GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig,
 155                                      guchar *path,
 156                                      guchar *dict,
 157                                      guint mode,
 158                                      guchar *encoding){
 159   GtkPspell *gtkpspell;
 160
 161   if( gtkpspellconfig == NULL) {
 162     gtkpspellconfig=gtkpspell_init();
 163     if(gtkpspellconfig==NULL){
 164       debug_print(_("Pspell could not be started."));
 165       prefs_common.enable_pspell=FALSE;
 166       return NULL;
 167     }
 168   }
 169
 170   gtkpspell                  = g_new( GtkPspell ,1);
 171   gtkpspell->path            = NULL;
 172   gtkpspell->dict            = NULL;
 173   gtkpspell->dictionary_list = NULL;
 174   gtkpspell->gtktext         = NULL;
 175
 176   gtkpspell->config       = pspell_config_clone(gtkpspellconfig);
 177   gtkpspell->mode = PSPELL_FASTMODE;
 178   if(!set_path_and_dict(gtkpspell, gtkpspell->config, path, dict)){
 179     debug_print(_("Pspell could not be configured."));
 180     gtkpspell=gtkpspell_delete(gtkpspell);
 181   }
 182   if(encoding)
 183     pspell_config_replace(gtkpspell->config,"encoding",encoding);
 184
 185   gtkpspell->possible_err = new_pspell_manager( gtkpspell->config );
 186   gtkpspell->checker      = NULL;
 187
 188   if( pspell_error_number( gtkpspell->possible_err ) != 0){
 189     debug_print(_("Pspell error : %s\n"), pspell_error_message( gtkpspell->possible_err ));
 190     delete_pspell_can_have_error( gtkpspell->possible_err );
 191     gtkpspell=gtkpspell_delete(gtkpspell);
 192   }
 193   else{
 194     gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
 195   }
 196   return gtkpspell;
 197 }
 198
 199
 200 /* Finishes a session */
 201
 202 GtkPspell *  gtkpspell_delete( GtkPspell *gtkpspell ){
 203
 204   if( gtkpspell->checker ){
 205     delete_pspell_manager( gtkpspell->checker );
 206     gtkpspell->checker      = NULL;
 207     gtkpspell->possible_err = NULL; /* checker is a cast from
 208                                        possible_err */
 209   }
 210
 211   if( gtkpspell->dictionary_list )
 212     gtkpspell_free_dictionary_list( gtkpspell->dictionary_list );
 213
 214   g_free( gtkpspell->path );
 215   g_free( gtkpspell->dict );
 216   gtkpspell->path = NULL;
 217   gtkpspell->dict = NULL;
 218
 219   g_free( gtkpspell );
 220   return NULL;
 221 }
 222
 223
 224 int set_path_and_dict( GtkPspell *gtkpspell,
 225                        PspellConfig *config,
 226                        guchar *path,
 227                        guchar * dict )
 228 {
 229   guchar *module   = NULL;
 230   guchar *language = NULL;
 231   guchar *spelling = NULL;
 232   guchar *jargon   = NULL;
 233
 234   guchar buf[BUFSIZE];
 235   guchar *end;
 236   guchar *temppath;
 237   guchar *tempdict;
 238
 239   /* Change nothing if any of path/dict/config is NULL */
 240   if( path==NULL || dict==NULL || config==NULL)
 241     return 0;
 242
 243   /* This is done, so we can free gtkpspell->path, even if it was
 244      given as an argument of the function */
 245   temppath = g_strdup( path );
 246   g_free( gtkpspell->path );
 247
 248   /* pspell dict name format :                         */
 249   /*   <lang>[[-<spelling>[-<jargon>]]-<module>.pwli   */
 250   /* Strip off path                                    */
 251
 252   if(!strrchr(dict,G_DIR_SEPARATOR)){ /* plain dict name */
 253     strncpy(buf,dict,BUFSIZE-1);
 254   }
 255   else{ /* strip path */
 256     strncpy(buf,strrchr(dict,G_DIR_SEPARATOR)+1,BUFSIZE-1);
 257   }
 258   g_free(gtkpspell->dict);
 259
 260   /* Ensure no buffers overflows if the dict is to long */
 261   buf[BUFSIZE-1] = 0x00;
 262
 263   language = buf;
 264   if(( module=strrchr(buf,'-'))!=NULL){
 265     module++;
 266     if(( end=strrchr(module,'.'))!=NULL)
 267       end[0]=0x00;
 268     }
 269
 270   /* In tempdict, we have only the dict name, without path nor
 271      extension. Useful in the popup menus */
 272
 273   tempdict=g_strdup(buf);
 274
 275   /* Probably I am too paranoied... */
 276   if(!( language[0]!=0x00 && language[1]!=0x00))
 277     language = NULL;
 278   else{
 279      spelling = strchr(language,'-');
 280      if( spelling!=NULL ){
 281        spelling[0] = 0x00;
 282        spelling++;
 283      }
 284     if( spelling!=module ){
 285       if( ( end=strchr( spelling,'-' ) )!=NULL ){
 286         end[0] = 0x00;
 287         jargon = end+1;
 288         if( jargon!=module )
 289           if( ( end=strchr(jargon,'-') )!=NULL )
 290             end[0] = 0x00;
 291           else
 292             jargon = NULL;
 293         else
 294         jargon = NULL;
 295       }
 296       else
 297       spelling = NULL;
 298     }
 299     else
 300       spelling = NULL;
 301   }
 302
 303   debug_print( _("Language : %s\nSpelling: %s\nJargon: %s\nModule: %s\n"),language,spelling,jargon,module);
 304
 305   if(language)
 306     pspell_config_replace(config,"language-tag",language);
 307   if(spelling)
 308     pspell_config_replace(config,"spelling",spelling);
 309   if(jargon)
 310     pspell_config_replace(config,"jargon",jargon);
 311   if(module)
 312     pspell_config_replace(config,"module",module);
 313   if(temppath)
 314     pspell_config_replace(config,"word-list-path",temppath);
 315
 316   switch(gtkpspell->mode){
 317   case PSPELL_FASTMODE: pspell_config_replace(config,"sug_mode","fast");
 318     break;
 319   case PSPELL_NORMALMODE: pspell_config_replace(config,"sug_mode","normal");
 320     break;
 321   case PSPELL_BADSPELLERMODE: pspell_config_replace(config,"sug_mode","bad-spellers");
 322     break;
 323   }
 324
 325   gtkpspell->path = g_strdup(temppath);
 326   gtkpspell->dict = g_strdup(tempdict);
 327   g_free(temppath);
 328   g_free(tempdict);
 329
 330   return -1;
 331 }
 332
 333 /* Set path and dict. The session is resetted. */
 334 /* 0 on error, -1 on success */
 335 int gtkpspell_set_path_and_dict(GtkPspell * gtkpspell, guchar * path, guchar * dict){
 336
 337   PspellConfig * config2;
 338
 339   /* It seems changing an already running config is not the way to go
 340      */
 341
 342   config2 = pspell_config_clone( gtkpspell->config );
 343
 344   if(gtkpspell->checker){
 345     delete_pspell_manager(gtkpspell->checker);
 346   }
 347   gtkpspell->checker      = NULL;
 348   gtkpspell->possible_err = NULL;
 349
 350   if(set_path_and_dict(gtkpspell,config2,path,dict)==0){
 351     debug_print("Pspell set_path_and_dict error.");
 352     return 0;
 353   }
 354
 355   gtkpspell->possible_err = new_pspell_manager( config2 );
 356
 357   delete_pspell_config(config2);
 358   config2 = NULL;
 359
 360   if(pspell_error_number(gtkpspell->possible_err)!=0){
 361     debug_print("Pspell set path&dict error %s\n",
 362                 pspell_error_message(gtkpspell->possible_err));
 363     delete_pspell_can_have_error(gtkpspell->possible_err);
 364     gtkpspell->possible_err = NULL;
 365     return 0;
 366   }
 367
 368   gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err);
 369
 370   return -1;
 371 }
 372
 373 /* What dict are we using ? language-spelling-jargon-module format */
 374 /* Actually, this function is not used and hence not tested. */
 375 /* Returns an allocated string */
 376 guchar * gtkpspell_get_dict( GtkPspell *gtkpspell ){
 377
 378   guchar * dict;
 379   guchar * language;
 380   guchar * spelling;
 381   guchar * jargon;
 382   guint len;
 383
 384   if(gtkpspell->config==NULL)
 385     return NULL;
 386
 387   language = g_strdup(pspell_config_retrieve(gtkpspell->config,"language"));
 388   spelling = g_strdup(pspell_config_retrieve(gtkpspell->config,"spelling"));
 389   jargon   = g_strdup(pspell_config_retrieve(gtkpspell->config,"jargon"  ));
 390   len      = strlen(language) + strlen(spelling) + strlen(jargon);
 391
 392   if( len<BUFSIZE ){
 393     dict = g_new(char,len+4);
 394     strcpy(dict,language);
 395     if(spelling){
 396       strcat(dict,"-");
 397       strcat(dict,spelling);
 398       if(jargon){
 399         strcat(dict,"-");
 400         strcat(dict,jargon);
 401       }
 402     }
 403   }
 404   g_free(language);
 405   g_free(spelling);
 406   g_free(jargon);
 407
 408   return dict;
 409 }
 410
 411 /* Return the dict path as an allocated string */
 412 /* Not used = not tested */
 413
 414 guchar * gtkpspell_get_path(GtkPspell * gtkpspell){
 415
 416   guchar * path;
 417
 418   if( gtkpspell->config=NULL )
 419     return NULL;
 420
 421   path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path"));
 422
 423   return path;
 424 }
 425
 426 /* Menu callback : change dict */
 427
 428 static void menu_change_dict(GtkWidget *w, GtkPspell * gtkpspell){
 429
 430   guchar *thedict,*thelabel;
 431
 432   /* Dict is simply the menu label */
 433
 434   gtk_label_get( GTK_LABEL(GTK_BIN(w)->child),(gchar **) &thelabel );
 435   thedict=g_strdup(thelabel);
 436
 437   /* Set path, dict, (and sug_mode ?) */
 438   gtkpspell_set_path_and_dict(gtkpspell,gtkpspell->path,thedict);
 439   g_free(thedict);
 440 }
 441
 442
 443 /* Menu callback : Set the suggestion mode */
 444
 445 static void set_sug_mode(GtkWidget *w, GtkPspell * gtkpspell){
 446
 447   unsigned char * themode;
 448
 449   gtk_label_get(GTK_LABEL(GTK_BIN(w)->child),(gchar **) &themode);
 450
 451   if( !strcmp(themode,_("Fast Mode")) ){
 452       gtkpspell_set_sug_mode( gtkpspell,"fast" );
 453       gtkpspell->mode = PSPELL_FASTMODE;
 454   }
 455   if( !strcmp(themode,_("Normal Mode")) ){
 456       gtkpspell_set_sug_mode( gtkpspell,"normal" );
 457       gtkpspell->mode = PSPELL_NORMALMODE;
 458   }
 459   if(!strcmp( themode,_("Bad Spellers Mode")) ){
 460       gtkpspell_set_sug_mode( gtkpspell,"bad-spellers" );
 461       gtkpspell->mode = PSPELL_BADSPELLERMODE;
 462   }
 463 }
 464
 465 /* Set the suggestion mode */
 466 /* Actually, the session is resetted and everything is reset. */
 467 /* We take the used path/dict pair and create a new config with them
 468    */
 469
 470 int gtkpspell_set_sug_mode( GtkPspell * gtkpspell, gchar * themode ){
 471   PspellConfig *config2;
 472   guchar       *path;
 473   guchar       *dict;
 474
 475   delete_pspell_manager( gtkpspell->checker );
 476   gtkpspell->checker = NULL;
 477
 478   config2 = pspell_config_clone(gtkpspell->config);
 479
 480   if(!set_path_and_dict( gtkpspell, config2, gtkpspell->path, gtkpspell->dict )){
 481     debug_print(_("Pspell set_sug_mod could not reset path & dict\n"));
 482     return 0;
 483   }
 484
 485   pspell_config_replace( config2, "sug-mode", themode );
 486
 487   gtkpspell->possible_err = new_pspell_manager( config2 );
 488   delete_pspell_config( config2 );
 489   config2 = NULL;
 490
 491   if( pspell_error_number( gtkpspell->possible_err )!=0 ){
 492     debug_print( _("Pspell set sug-mode error %s\n"),
 493         pspell_error_message( gtkpspell->possible_err ) );
 494     delete_pspell_can_have_error( gtkpspell->possible_err );
 495     gtkpspell->possible_err = NULL;
 496     return 0;
 497   }
 498   gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
 499   return -1;
 500 }
 501
 502
 503 /* Create a suggestion list for  word  */
 504
 505 static GList* misspelled_suggest( GtkPspell * gtkpspell, guchar *word )
 506 {
 507   const guchar          *newword;
 508   GList                 *l = NULL;
 509   int                    count;
 510   const PspellWordList  *suggestions ;
 511   PspellStringEmulation *elements ;
 512
 513   if( word==NULL ) return NULL;
 514
 515   if( !pspell_manager_check( gtkpspell->checker,word,-1 ) ){
 516        suggestions =  pspell_manager_suggest( gtkpspell->checker,(const char *) word,-1 );
 517        elements    = pspell_word_list_elements( suggestions );
 518        /* First one must be the misspelled (why this ?) */
 519        l           = g_list_append( l,g_strdup(word) );
 520        while( ( newword=pspell_string_emulation_next( elements ) )!=NULL )
 521          l = g_list_append( l, g_strdup( newword ) );
 522        return l;
 523   }
 524   return NULL;
 525 }
 526
 527
 528 /* Just test if word is correctly spelled */
 529
 530 static int misspelled_test(GtkPspell * gtkpspell, unsigned char *word)
 531 {
 532     if( pspell_manager_check( gtkpspell->checker, word, -1) )
 533       return 0;
 534     return 1;
 535 }
 536
 537
 538 static gboolean iswordsep(unsigned char c)
 539 {
 540     return !isalpha(c) && c != '\'';
 541 }
 542
 543 static guchar get_text_index_whar(GtkPspell * gtkpspell, int pos)
 544 {
 545     guchar a;
 546     gchar *text;
 547     text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1);
 548     if (text == NULL) return 0;
 549     a = (guchar) * text;
 550     g_free(text);
 551     return a;
 552 }
 553
 554 static gboolean get_word_from_pos(GtkPspell * gtkpspell, int pos,
 555                                   unsigned char* buf,
 556                                   int *pstart, int *pend)
 557 {
 558     gint start, end;
 559     GtkXText * gtktext;
 560     gtktext=gtkpspell->gtktext;
 561     if (iswordsep(get_text_index_whar(gtkpspell, pos))) return FALSE;
 562
 563     for (start = pos; start >= 0; --start) {
 564         if (iswordsep(get_text_index_whar(gtkpspell, start))) break;
 565     }
 566     start++;
 567
 568     for (end = pos; end < gtk_xtext_get_length(gtktext); end++) {
 569         if (iswordsep(get_text_index_whar(gtkpspell, end))) break;
 570     }
 571
 572     if (buf) {
 573         for (pos = start; pos < end; pos++) buf[pos - start] = get_text_index_whar(gtkpspell, pos);
 574         buf[pos - start] = 0;
 575     }
 576
 577     if (pstart) *pstart = start;
 578     if (pend) *pend = end;
 579
 580     return TRUE;
 581 }
 582
 583 static gboolean get_curword(GtkPspell * gtkpspell, unsigned char* buf,
 584                             int *pstart, int *pend)
 585 {
 586     int pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
 587     return get_word_from_pos(gtkpspell, pos, buf, pstart, pend);
 588 }
 589
 590 static void change_color(GtkPspell * gtkpspell, int start, int end,
 591                          GdkColor *color)
 592 {
 593     char *newtext;
 594     GtkXText *gtktext;
 595     gtktext=gtkpspell->gtktext;
 596     if (start >= end) {
 597         return ;
 598     };
 599     gtk_xtext_freeze(gtktext);
 600     newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end);
 601     if(newtext){
 602         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
 603                                          GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
 604         gtk_xtext_set_point(gtktext, start);
 605         gtk_xtext_forward_delete(gtktext, end - start);
 606
 607         gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start);
 608         gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
 609                                            GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
 610    }
 611    gtk_xtext_thaw(gtktext);
 612 }
 613
 614 static gboolean check_at(GtkPspell * gtkpspell, int from_pos)
 615 {
 616     int start, end;
 617     unsigned char buf[BUFSIZE];
 618     GtkXText * gtktext;
 619     gtktext=gtkpspell->gtktext;
 620     if (from_pos < 0) return FALSE;
 621     if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end)) {
 622         return FALSE;
 623     };
 624     if (misspelled_test(gtkpspell, buf)) {
 625         if (highlight.pixel == 0) {
 626             /* add an entry for the highlight in the color map. */
 627             GdkColormap *gc = gtk_widget_get_colormap(GTK_WIDGET(gtktext));
 628             gdk_colormap_alloc_color(gc, &highlight, FALSE, TRUE);
 629             ;
 630         }
 631         change_color(gtkpspell, start, end, &highlight);
 632         return TRUE;
 633     } else {
 634         change_color(gtkpspell, start, end,
 635                      &(GTK_WIDGET(gtktext)->style->fg[0]));
 636         return FALSE;
 637     }
 638 }
 639
 640
 641 static void check_all(GtkWidget *w, GtkPspell * gtkpspell){
 642   gtkpspell_check_all(gtkpspell);
 643 }
 644
 645
 646 void gtkpspell_check_all(GtkPspell * gtkpspell)
 647 {
 648     guint origpos;
 649     guint pos = 0;
 650     guint len;
 651     float adj_value;
 652     GtkXText * gtktext;
 653     gtktext=gtkpspell->gtktext;
 654
 655     if (!gtkpspell_running(gtkpspell)) return ;
 656
 657     len = gtk_xtext_get_length(gtktext);
 658
 659     adj_value = gtktext->vadj->value;
 660     gtk_xtext_freeze(gtktext);
 661     origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 662     gtk_editable_set_position(GTK_EDITABLE(gtktext),0);
 663     while (pos < len) {
 664         while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos)))
 665             pos++;
 666         while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos)))
 667             pos++;
 668         if (pos > 0)
 669             check_at(gtkpspell, pos - 1);
 670     }
 671     gtk_xtext_thaw(gtktext);
 672     gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
 673     gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
 674
 675 }
 676
 677 static void entry_insert_cb(GtkXText *gtktext,
 678                             gchar *newtext, guint len, guint *ppos,
 679                             GtkPspell * gtkpspell)
 680 {
 681     int origpos;
 682     if (!gtkpspell_running(gtkpspell)) return ;
 683
 684     gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
 685                                      GTK_SIGNAL_FUNC(entry_insert_cb),
 686                                      gtkpspell);
 687     gtk_xtext_insert(GTK_XTEXT(gtktext), NULL,
 688                     &(GTK_WIDGET(gtktext)->style->fg[0]), NULL, newtext, len);
 689
 690     gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
 691                                        GTK_SIGNAL_FUNC(entry_insert_cb),
 692                                        gtkpspell);
 693     gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "insert-text");
 694     *ppos += len;
 695     origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 696
 697     if (iswordsep(newtext[0])) {
 698         /* did we just end a word? */
 699         if (*ppos >= 2) check_at(gtkpspell, *ppos - 2);
 700
 701         /* did we just split a word? */
 702         if (*ppos < gtk_xtext_get_length(gtktext))
 703             check_at(gtkpspell, *ppos + 1);
 704     } else {
 705         /* check as they type, *except* if they're typing at the end (the most
 706          * common case.
 707          */
 708         if (*ppos < gtk_xtext_get_length(gtktext) &&
 709                 !iswordsep(get_text_index_whar(gtkpspell, *ppos)))
 710             check_at(gtkpspell, *ppos - 1);
 711     }
 712
 713     gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
 714 }
 715
 716 static void entry_delete_cb(GtkXText *gtktext,
 717                             gint start, gint end, GtkPspell *gtkpspell)
 718 {
 719     int origpos;
 720     if (!gtkpspell_running(gtkpspell)) return ;
 721
 722     origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 723     check_at(gtkpspell, start - 1);
 724     gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
 725     gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
 726     /* this is to *UNDO* the selection, in case they were holding shift
 727      * while hitting backspace. */
 728 }
 729
 730 static void replace_word(GtkWidget *w, GtkPspell * gtkpspell)
 731 {
 732     int start, end;
 733     unsigned char *newword;
 734     unsigned char buf[BUFSIZE];
 735     guint pos;
 736     GtkXText * gtktext;
 737     gtktext=gtkpspell->gtktext;
 738
 739     gtk_xtext_freeze(GTK_XTEXT(gtktext));
 740         pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 741
 742     gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
 743     get_curword(gtkpspell, buf, &start, &end);
 744
 745     gtk_xtext_set_point(GTK_XTEXT(gtktext), end);
 746     gtk_xtext_backward_delete(GTK_XTEXT(gtktext), end - start);
 747     gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newword, strlen(newword));
 748
 749     if(end-start>0){ /* Just be sure the buffer is correct... */
 750             buf[end-start]=0x00;
 751             /* Learn from common misspellings */
 752 //            pspell_manager_store_replacement(gtkpspell->checker,buf,end-start,newword,strlen(newword));
 753     }
 754     /* Put the point and the position where we clicked with the mouse */
 755     /* It seems to be a hack, as I must thaw,freeze,thaw the widget   */
 756     /* to let it update correctly the word insertion and then the     */
 757     /* point & position position. If not, SEGV after the first replacement */
 758     /* If the new inserted word is smaller, put the point at its end*/
 759     if(pos-start>strlen(newword)) pos=start+strlen(newword);
 760         gtk_xtext_thaw(GTK_XTEXT(gtktext));
 761         gtk_xtext_freeze(GTK_XTEXT(gtktext));
 762     gtk_editable_set_position(GTK_EDITABLE(gtktext),pos);
 763     gtk_xtext_set_point(GTK_XTEXT(gtktext), gtk_editable_get_position(GTK_EDITABLE(gtktext)));
 764         gtk_xtext_thaw(GTK_XTEXT(gtktext));
 765 }
 766
 767 /* Accept this word for this session */
 768
 769 static void add_word_to_session(GtkWidget *w, GtkPspell * gtkpspell){
 770     guint pos;
 771     GtkXText * gtkxtext;
 772     gtkxtext=gtkpspell->gtktext;
 773
 774     gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
 775     pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
 776
 777     pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword));
 778
 779     check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
 780
 781     gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
 782     gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
 783     gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
 784     gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
 785     gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
 786 }
 787
 788 /* Add word to personal dict. Save the list at every addition (may be
 789    not efficient...) */
 790
 791 static void add_word_to_personal(GtkWidget *w, GtkPspell * gtkpspell){
 792     guint pos;
 793     GtkXText * gtkxtext;
 794     gtkxtext=gtkpspell->gtktext;
 795
 796     gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
 797     pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
 798
 799     pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword));
 800     pspell_manager_save_all_word_lists(gtkpspell->checker);
 801
 802     check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
 803     gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
 804     gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
 805     gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
 806     gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
 807         gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
 808 }
 809
 810
 811 static GtkMenu *make_menu_config(GtkPspell *gtkpspell){
 812   GtkWidget *menu, *item, *submenu;
 813
 814
 815   menu = gtk_menu_new();
 816
 817         item = gtk_menu_item_new_with_label(_("Spell check all"));
 818                 gtk_widget_show(item);
 819                 gtk_menu_append(GTK_MENU(menu), item);
 820         gtk_signal_connect(GTK_OBJECT(item),"activate",
 821                 GTK_SIGNAL_FUNC(check_all),gtkpspell);
 822
 823
 824         item = gtk_menu_item_new();
 825                 gtk_widget_show(item);
 826                 gtk_menu_append(GTK_MENU(menu),item);
 827
 828         submenu = gtk_menu_new();
 829                 item = gtk_menu_item_new_with_label(_("Change dictionary"));
 830                 gtk_widget_show(item);
 831                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
 832                 gtk_menu_append(GTK_MENU(menu), item);
 833                 /* Dict list */
 834                 if(gtkpspell->dictionary_list==NULL)
 835                   gtkpspell->dictionary_list=gtkpspell_get_dictionary_list(gtkpspell->path);
 836
 837
 838         {
 839           GtkWidget * curmenu=submenu;
 840           int count = 0;
 841           Dictionary *dict;
 842           GSList *tmp;
 843           tmp = gtkpspell->dictionary_list;
 844           for (tmp =  gtkpspell->dictionary_list;tmp!=NULL;tmp=g_slist_next(tmp)){
 845             dict= (Dictionary *) tmp->data;
 846             item = gtk_check_menu_item_new_with_label(dict->name);
 847             if(strcmp2(dict->name,gtkpspell->dict))
 848               gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),FALSE);
 849             else{
 850               gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
 851               gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
 852             }
 853             gtk_menu_append(GTK_MENU(curmenu),item);
 854             gtk_signal_connect(GTK_OBJECT(item),"activate",
 855                 GTK_SIGNAL_FUNC(menu_change_dict),gtkpspell);
 856             gtk_widget_show(item);
 857             count++;
 858             if(count==MENUCOUNT){
 859               GtkWidget *newmenu;
 860               newmenu=gtk_menu_new();
 861               item=gtk_menu_item_new_with_label(_("More..."));
 862               gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),newmenu);
 863               gtk_menu_append(GTK_MENU(curmenu),item);
 864               gtk_widget_show(item);
 865               curmenu=newmenu;
 866               count=0;
 867             }
 868           }
 869         }
 870
 871         item = gtk_menu_item_new();
 872                 gtk_widget_show(item);
 873                 gtk_menu_append(GTK_MENU(menu),item);
 874
 875         item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
 876                 gtk_widget_show(item);
 877                 gtk_menu_append(GTK_MENU(menu),item);
 878                 if(gtkpspell->mode==PSPELL_FASTMODE){
 879                   gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
 880                   gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
 881                 }
 882                 else
 883                   gtk_signal_connect(GTK_OBJECT(item),"activate",
 884                         GTK_SIGNAL_FUNC(set_sug_mode),gtkpspell);
 885
 886
 887
 888         item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
 889                 gtk_widget_show(item);
 890                 gtk_menu_append(GTK_MENU(menu),item);
 891                 if(gtkpspell->mode==PSPELL_NORMALMODE){
 892                   gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
 893                   gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
 894                 }
 895                 else
 896                   gtk_signal_connect(GTK_OBJECT(item),"activate",
 897                         GTK_SIGNAL_FUNC(set_sug_mode),gtkpspell);
 898
 899         item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
 900                 gtk_widget_show(item);
 901                 gtk_menu_append(GTK_MENU(menu),item);
 902                 if(gtkpspell->mode==PSPELL_BADSPELLERMODE){
 903                   gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
 904                   gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
 905                 }
 906                 else
 907                   gtk_signal_connect(GTK_OBJECT(item),"activate",
 908                         GTK_SIGNAL_FUNC(set_sug_mode),gtkpspell);
 909
 910
 911
 912         return GTK_MENU(menu);
 913 }
 914
 915 /* Add menus to accept this word for this session and to add it to personal
 916    dictionary */
 917 static GtkMenu *make_menu(GList *l, GtkPspell * gtkpspell)
 918 {
 919     GtkWidget *menu, *item;
 920     unsigned char *caption;
 921     GtkXText * gtktext;
 922     gtktext=gtkpspell->gtktext;
 923
 924     menu = gtk_menu_new();
 925         caption = g_strdup_printf(_("Accept `%s' for this session"), (unsigned char*)l->data);
 926                 item = gtk_menu_item_new_with_label(caption);
 927                 g_free(caption);
 928                 gtk_widget_show(item);
 929                 gtk_menu_append(GTK_MENU(menu), item);
 930
 931         gtk_signal_connect(GTK_OBJECT(item), "activate",
 932                 GTK_SIGNAL_FUNC(add_word_to_session), gtkpspell);
 933
 934         caption = g_strdup_printf(_("Add `%s' to personal dictionary"), (char*)l->data);
 935                 item = gtk_menu_item_new_with_label(caption);
 936                 g_free(caption);
 937                 gtk_widget_show(item);
 938                 gtk_menu_append(GTK_MENU(menu), item);
 939
 940         gtk_signal_connect(GTK_OBJECT(item), "activate",
 941                 GTK_SIGNAL_FUNC(add_word_to_personal), gtkpspell);
 942
 943
 944         item = gtk_menu_item_new();
 945         gtk_widget_show(item);
 946         gtk_menu_append(GTK_MENU(menu), item);
 947
 948         l = l->next;
 949         if (l == NULL) {
 950             item = gtk_menu_item_new_with_label(_("(no suggestions)"));
 951             gtk_widget_show(item);
 952             gtk_menu_append(GTK_MENU(menu), item);
 953         } else {
 954             GtkWidget *curmenu = menu;
 955             int count = 0;
 956             do {
 957                 if (l->data == NULL && l->next != NULL) {
 958                     count = 0;
 959                     curmenu = gtk_menu_new();
 960                     item = gtk_menu_item_new_with_label(_("Others..."));
 961                     gtk_widget_show(item);
 962                     gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
 963                     gtk_menu_append(GTK_MENU(curmenu), item);
 964                     l = l->next;
 965                 } else if (count > MENUCOUNT) {
 966                     count -= MENUCOUNT;
 967                     item = gtk_menu_item_new_with_label(_("More..."));
 968                     gtk_widget_show(item);
 969                     gtk_menu_append(GTK_MENU(curmenu), item);
 970                     curmenu = gtk_menu_new();
 971                     gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
 972                 }
 973                 item = gtk_menu_item_new_with_label((unsigned char*)l->data);
 974                 gtk_signal_connect(GTK_OBJECT(item), "activate",
 975                                    GTK_SIGNAL_FUNC(replace_word), gtkpspell);
 976                 gtk_widget_show(item);
 977                 gtk_menu_append(GTK_MENU(curmenu), item);
 978                 count++;
 979             } while ((l = l->next) != NULL);
 980         }
 981     return GTK_MENU(menu);
 982 }
 983
 984 static void popup_menu(GtkPspell * gtkpspell, GdkEventButton *eb)
 985 {
 986     unsigned char buf[BUFSIZE];
 987     GList *list, *l;
 988     GtkXText * gtktext;
 989     gtktext=gtkpspell->gtktext;
 990
 991     if( !(eb->state & GDK_SHIFT_MASK) )
 992       if (get_curword(gtkpspell, buf, NULL, NULL)){
 993         if (buf != NULL) {
 994           strncpy(gtkpspell->theword,buf,BUFSIZE-1);
 995           gtkpspell->theword[BUFSIZE-1]=0x00;
 996           list = misspelled_suggest(gtkpspell, buf);
 997           if (list != NULL) {
 998             gtk_menu_popup(make_menu(list, gtkpspell), NULL, NULL, NULL, NULL,
 999                            eb->button, eb->time);
1000             for (l = list; l != NULL; l = l->next)
1001               g_free(l->data);
1002             g_list_free(list);
1003             return;
1004           }
1005         }
1006       }
1007     gtk_menu_popup(make_menu_config(gtkpspell),NULL,NULL,NULL,NULL,
1008           eb->button,eb->time);
1009
1010 }
1011
1012 /* ok, this is pretty wacky:
1013  * we need to let the right-mouse-click go through, so it moves the cursor,
1014  * but we *can't* let it go through, because GtkText interprets rightclicks as
1015  * weird selection modifiers.
1016  *
1017  * so what do we do?  forge rightclicks as leftclicks, then popup the menu.
1018  * HACK HACK HACK.
1019  */
1020 static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell * gtkpspell)
1021
1022 {
1023     GdkEventButton *eb;
1024     gboolean retval;
1025
1026     if (!gtkpspell_running(gtkpspell)) return FALSE;
1027
1028     if (e->type != GDK_BUTTON_PRESS) return FALSE;
1029     eb = (GdkEventButton*) e;
1030
1031     if (eb->button != 3) return FALSE;
1032
1033     /* forge the leftclick */
1034     eb->button = 1;
1035
1036         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
1037                                      GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
1038     gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
1039                             e, &retval);
1040     gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
1041                                        GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
1042     gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
1043
1044     /* now do the menu wackiness */
1045     popup_menu(gtkpspell, eb);
1046     gtk_grab_remove(GTK_WIDGET(gtktext));
1047     return TRUE;
1048 }
1049
1050 void gtkpspell_uncheck_all(GtkPspell * gtkpspell)
1051 {
1052     int origpos;
1053     unsigned char *text;
1054     float adj_value;
1055     GtkXText * gtktext;
1056     gtktext=gtkpspell->gtktext;
1057
1058     adj_value = gtktext->vadj->value;
1059     gtk_xtext_freeze(gtktext);
1060     origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1061     text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
1062     gtk_xtext_set_point(gtktext, 0);
1063     gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext));
1064     gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
1065     gtk_xtext_thaw(gtktext);
1066
1067     gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
1068     gtk_adjustment_set_value(gtktext->vadj, adj_value);
1069 }
1070
1071 void gtkpspell_attach(GtkPspell * gtkpspell, GtkXText *gtktext)
1072 {
1073     gtkpspell->gtktext=gtktext;
1074 //    if (prefs_common.auto_makepspell) {
1075         gtk_signal_connect(GTK_OBJECT(gtktext), "insert-text",
1076                            GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
1077         gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
1078                                  GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
1079 //    };
1080     gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
1081                        GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
1082
1083 }
1084
1085 void gtkpspell_detach(GtkPspell * gtkpspell)
1086 {
1087     GtkXText * gtktext;
1088     gtktext=gtkpspell->gtktext;
1089 //    if (prefs_common.auto_makepspell) {
1090         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
1091                                       GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
1092         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
1093                                       GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
1094 //    };
1095     gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
1096                                   GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
1097
1098     gtkpspell_uncheck_all(gtkpspell);
1099 }
1100
1101 /*** Sylpheed (Claws) ***/
1102
1103 static GSList *create_empty_dictionary_list(void)
1104 {
1105         GSList *list = NULL;
1106         Dictionary *dict;
1107
1108         dict = g_new0(Dictionary, 1);
1109         dict->name = g_strdup(_("None"));
1110         return g_slist_append(list, dict);
1111 }
1112
1113 /* gtkpspell_get_dictionary_list() - returns list of dictionary names */
1114 GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path)
1115 {
1116         GSList *list;
1117         gchar *dict_path, *tmp, *prevdir;
1118         GSList *walk;
1119         Dictionary *dict;
1120         DIR *dir;
1121         struct dirent *ent;
1122
1123         list = NULL;
1124
1125 #ifdef USE_THREADS
1126 #warning TODO: no directory change
1127 #endif
1128         dict_path=g_strdup(pspell_path);
1129         prevdir = g_get_current_dir();
1130         if (chdir(dict_path) <0) {
1131                 FILE_OP_ERROR(dict_path, "chdir");
1132                 g_free(prevdir);
1133                 g_free(dict_path);
1134                 return create_empty_dictionary_list();
1135         }
1136
1137         debug_print(_("Checking for dictionaries in %s\n"), dict_path);
1138
1139         if (NULL != (dir = opendir("."))) {
1140                 while (NULL != (ent = readdir(dir))) {
1141                         /* search for pwli */
1142                         if (NULL != (tmp = strstr(ent->d_name, ".pwli"))) {
1143                                 dict = g_new0(Dictionary, 1);
1144                                 dict->name = g_strndup(ent->d_name, tmp - ent->d_name);
1145                                 debug_print(_("Found dictionary %s\n"), dict->name);
1146                                 list = g_slist_append(list, dict);
1147                         }
1148                 }
1149                 closedir(dir);
1150         }
1151         else {
1152                 FILE_OP_ERROR(dict_path, "opendir");
1153                 debug_print(_("No dictionary found\n"));
1154                 list = create_empty_dictionary_list();
1155         }
1156         if(list==NULL){
1157           debug_print(_("No dictionary found"));
1158           list = create_empty_dictionary_list();
1159         }
1160         chdir(prevdir);
1161         g_free(dict_path);
1162         g_free(prevdir);
1163         return list;
1164 }
1165
1166 void gtkpspell_free_dictionary_list(GSList *list)
1167 {
1168         Dictionary *dict;
1169         GSList *walk;
1170         for (walk = list; walk != NULL; walk = g_slist_next(walk))
1171                 if (walk->data) {
1172                         dict = (Dictionary *) walk->data;
1173                         if (dict->name)
1174                                 g_free(dict->name);
1175                         g_free(dict);
1176                 }
1177         g_slist_free(list);
1178 }
1179
1180 static void dictionary_option_menu_item_data_destroy(gpointer data)
1181 {
1182         gchar *str = (gchar *) data;
1183
1184         if (str)
1185                 g_free(str);
1186 }
1187
1188 GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path)
1189 {
1190         GSList *dict_list, *tmp;
1191         GtkWidget *item;
1192         GtkWidget *menu;
1193         Dictionary *dict;
1194
1195         dict_list = gtkpspell_get_dictionary_list(pspell_path);
1196         g_return_val_if_fail(dict_list, NULL);
1197
1198         menu = gtk_menu_new();
1199
1200         for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
1201                 dict = (Dictionary *) tmp->data;
1202                 item = gtk_menu_item_new_with_label(dict->name);
1203                 if (dict->name)
1204                         gtk_object_set_data_full(GTK_OBJECT(item), "dict_name",
1205                                          g_strdup(dict->name),
1206                                          dictionary_option_menu_item_data_destroy);
1207                 gtk_menu_append(GTK_MENU(menu), item);
1208                 gtk_widget_show(item);
1209         }
1210
1211         gtk_widget_show(menu);
1212
1213         gtkpspell_free_dictionary_list(dict_list);
1214
1215         return menu;
1216 }
1217
1218
1219
1220 gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu)
1221 {
1222         GtkWidget *menuitem;
1223         gchar *result;
1224
1225         g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
1226         menuitem = gtk_menu_get_active(GTK_MENU(menu));
1227         result = gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name");
1228         g_return_val_if_fail(result, NULL);
1229         return g_strdup(result);
1230
1231 }
1232 #endif