src/gtkspell.c

   1 /* gtkpspell - a spell-checking addon for GtkText
   2  * Copyright (c) 2000 Evan Martin.
   3  * Copyright (c) 2002 Melvin Hadasht.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; If not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  18  */
  19 /*
  20  * Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
  21  * Adapted for Sylpheed (Claws) (c) 2001-2002 by Hiroyuki Yamamoto &
  22  * The Sylpheed Claws Team.
  23  * Adapted for pspell (c) 2001-2002 Melvin Hadasht
  24  */
  25
  26 #if defined(HAVE_CONFIG_H)
  27 #include "config.h"
  28 #endif
  29
  30 #if USE_PSPELL
  31 #include "intl.h"
  32
  33 #include <gtk/gtk.h>
  34 #include <gdk/gdk.h>
  35 #include <sys/types.h>
  36 #include <sys/wait.h>
  37 #include <unistd.h>
  38 #include <stdio.h>
  39 #include <signal.h>
  40 #include <ctype.h>
  41 #include <string.h>
  42 #include <stdlib.h>
  43 #include <errno.h>
  44 #include <stdio.h>
  45 #include <sys/time.h>
  46 #include <fcntl.h>
  47 #include <time.h>
  48 #include <prefs_common.h>
  49 #include <utils.h>
  50
  51 #include <dirent.h>
  52
  53 #include <gtk/gtkoptionmenu.h>
  54 #include <gtk/gtkmenu.h>
  55 #include <gtk/gtkmenuitem.h>
  56 #include <gdk/gdkkeysyms.h>
  57
  58 #include "gtkstext.h"
  59
  60 #include "gtkspell.h"
  61
  62 #include <pspell/pspell.h>
  63 /* size of the text buffer used in various word-processing routines. */
  64 #define BUFSIZE 1024
  65
  66 /* number of suggestions to display on each menu. */
  67 #define MENUCOUNT 15
  68
  69 /* 'config' must be defined as a 'PspellConfig *' */
  70 #define RETURN_FALSE_IF_CONFIG_ERROR() \
  71         if (pspell_config_error_number(config) != 0) { \
  72                 gtkpspellcheckers->error_message = g_strdup(pspell_config_error_message(config)); \
  73                 return FALSE; \
  74         }
  75
  76 #define CONFIG_REPLACE_RETURN_FALSE_IF_FAIL(option, value) { \
  77         pspell_config_replace(config, option, value);       \
  78         RETURN_FALSE_IF_CONFIG_ERROR();                      \
  79         }
  80
  81 /******************************************************************************/
  82
  83 GtkPspellCheckers *gtkpspellcheckers;
  84
  85 /* Error message storage */
  86 static void             gtkpspell_checkers_error_message(gchar *message);
  87
  88 /* Callbacks */
  89 static void             entry_insert_cb                 (GtkSText *gtktext,
  90                                                          gchar *newtext,
  91                                                          guint len,
  92                                                          guint *ppos,
  93                                                          GtkPspell *gtkpspell);
  94 static void             entry_delete_cb                 (GtkSText *gtktext,
  95                                                          gint start,
  96                                                          gint end,
  97                                                          GtkPspell *gtkpspell);
  98 static gint             button_press_intercept_cb       (GtkSText *gtktext,
  99                                                          GdkEvent *e,
 100                                                          GtkPspell *gtkpspell);
 101
 102 /* Checker creation */
 103 static GtkPspeller *    gtkpspeller_new                 (Dictionary *dict);
 104 static GtkPspeller *    gtkpspeller_real_new            (Dictionary *dict);
 105 static GtkPspeller *    gtkpspeller_delete              (GtkPspeller *gtkpspeller);
 106 static GtkPspeller *    gtkpspeller_real_delete         (GtkPspeller *gtkpspeller);
 107
 108 /* Checker configuration */
 109 static gint             set_dictionary                  (PspellConfig *config,
 110                                                          Dictionary *dict);
 111 static void             set_sug_mode_cb                 (GtkWidget *w,
 112                                                          GtkPspell *gtkpspell);
 113 static void             set_real_sug_mode               (GtkPspell *gtkpspell,
 114                                                          const char *themode);
 115
 116 /* Checker actions */
 117 static gboolean         check_at                        (GtkPspell *gtkpspell,
 118                                                          int from_pos);
 119 static void             check_next_prev                 (GtkPspell *gtkpspell,
 120                                                          gboolean forward);
 121
 122 static GList*           misspelled_suggest              (GtkPspell *gtkpspell,
 123                                                          guchar *word);
 124 static void             add_word_to_session             (GtkWidget *w,
 125                                                          GtkPspell *d);
 126 static void             add_word_to_personal            (GtkWidget *w,
 127                                                          GtkPspell *d);
 128 static void             replace_word                    (GtkWidget *w,
 129                                                          GtkPspell *gtkpspell);
 130 static void             replace_real_word               (GtkPspell *gtkpspell,
 131                                                          gchar *newword);
 132 static void             check_all_cb                    (GtkWidget *w,
 133                                                          GtkPspell *gtkpspell);
 134
 135 /* Menu creation */
 136 static void             popup_menu                      (GtkPspell *gtkpspell,
 137                                                          GdkEventButton *eb);
 138 static GtkMenu*         make_sug_menu                   (GtkPspell *gtkpspell);
 139 static GtkMenu*         make_config_menu                (GtkPspell *gtkpspell);
 140 static void             set_menu_pos                    (GtkMenu *menu,
 141                                                          gint *x,
 142                                                          gint *y,
 143                                                          gpointer data);
 144 /* Other menu callbacks */
 145 static gboolean         deactivate_menu_cb              (GtkWidget *w,
 146                                                          gpointer *data);
 147 static void             change_dict_cb                  (GtkWidget *w,
 148                                                          GtkPspell *gtkpspell);
 149
 150 /* Misc. helper functions */
 151 static gboolean         iswordsep                       (unsigned char c);
 152 static guchar           get_text_index_whar             (GtkPspell *gtkpspell,
 153                                                          int pos);
 154 static gboolean         get_word_from_pos               (GtkPspell *gtkpspell,
 155                                                          int pos,
 156                                                          unsigned char* buf,
 157                                                          int *pstart, int *pend);
 158 static void             allocate_color                  (GtkPspell *gtkpspell);
 159 static void             change_color                    (GtkPspell *gtkpspell,
 160                                                          int start,
 161                                                          int end,
 162                                                          GdkColor *color);
 163 static guchar*          convert_to_pspell_encoding      (const guchar *encoding);
 164 static gint             compare_dict                    (Dictionary *a,
 165                                                          Dictionary *b);
 166 static void             dictionary_delete               (Dictionary *dict);
 167 static Dictionary *     dictionary_dup                  (const Dictionary *dict);
 168 static void             free_suggestions_list           (GtkPspell *gtkpspell);
 169 static void             reset_theword_data              (GtkPspell *gtkpspell);
 170 static void             free_checkers                   (gpointer elt,
 171                                                          gpointer data);
 172 static gint             find_gtkpspeller                (gconstpointer aa,
 173                                                          gconstpointer bb);
 174 static void             gtkpspell_alert_dialog          (gchar *message);
 175 /* gtkspellconfig - only one config per session */
 176 GtkPspellConfig * gtkpspellconfig;
 177
 178 /******************************************************************************/
 179
 180 GtkPspellCheckers * gtkpspell_checkers_new()
 181 {
 182         GtkPspellCheckers *gtkpspellcheckers;
 183
 184         gtkpspellcheckers = g_new(GtkPspellCheckers, 1);
 185
 186         gtkpspellcheckers->checkers        = NULL;
 187
 188         gtkpspellcheckers->dictionary_list = NULL;
 189
 190         gtkpspellcheckers->error_message   = NULL;
 191
 192         return gtkpspellcheckers;
 193 }
 194
 195 GtkPspellCheckers *gtkpspell_checkers_delete()
 196 {
 197         GSList *checkers;
 198         GSList *dict_list;
 199
 200         if (gtkpspellcheckers == NULL) return NULL;
 201
 202         if ((checkers  = gtkpspellcheckers->checkers)) {
 203                 debug_print(_("Pspell: number of running checkers to delete %d\n"),
 204                                 g_slist_length(checkers));
 205
 206                 g_slist_foreach(checkers, free_checkers, NULL);
 207                 g_slist_free(checkers);
 208         }
 209
 210         if ((dict_list = gtkpspellcheckers->dictionary_list)) {
 211                 debug_print(_("Pspell: number of dictionaries to delete %d\n"),
 212                                 g_slist_length(dict_list));
 213
 214                 gtkpspell_free_dictionary_list(dict_list);
 215                 gtkpspellcheckers->dictionary_list = NULL;
 216         }
 217
 218         g_free(gtkpspellcheckers->error_message);
 219
 220         return NULL;
 221 }
 222
 223 static void gtkpspell_checkers_error_message (gchar *message)
 224 {
 225         gchar *tmp;
 226         if (gtkpspellcheckers->error_message) {
 227                 tmp = g_strdup_printf("%s\n%s",
 228                                       gtkpspellcheckers->error_message, message);
 229                 g_free(message);
 230                 g_free(gtkpspellcheckers->error_message);
 231                 gtkpspellcheckers->error_message = tmp;
 232         } else gtkpspellcheckers->error_message = message;
 233 }
 234
 235 void gtkpspell_checkers_reset()
 236 {
 237         g_return_if_fail(gtkpspellcheckers);
 238
 239         g_free(gtkpspellcheckers->error_message);
 240
 241         gtkpspellcheckers->error_message = NULL;
 242 }
 243
 244 GtkPspell *gtkpspell_new(const gchar *dictionary,
 245                          const gchar *encoding,
 246                          GtkSText *gtktext)
 247 {
 248         Dictionary      *dict = g_new0(Dictionary, 1);
 249         GtkPspell       *gtkpspell;
 250         GtkPspeller     *gtkpspeller;
 251
 252         g_return_val_if_fail(gtktext, NULL);
 253
 254         dict->fullname = g_strdup(dictionary);
 255         dict->encoding = g_strdup(encoding);
 256         gtkpspeller = gtkpspeller_new(dict);
 257         dictionary_delete(dict);
 258
 259         if (!gtkpspeller)
 260                 return NULL;
 261
 262         gtkpspell = g_new(GtkPspell, 1);
 263
 264         gtkpspell->gtkpspeller = gtkpspeller;
 265         gtkpspell->theword[0]  = 0x00;
 266         gtkpspell->start_pos   = 0;
 267         gtkpspell->end_pos     = 0;
 268         gtkpspell->orig_pos    = -1;
 269
 270         gtkpspell->gtktext     = gtktext;
 271
 272         gtkpspell->default_sug_mode   = PSPELL_FASTMODE;
 273         gtkpspell->max_sug            = -1;
 274         gtkpspell->suggestions_list   = NULL;
 275
 276         gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text",
 277                                  GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
 278
 279         gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
 280                                  GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
 281
 282         gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
 283                            GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
 284
 285         allocate_color(gtkpspell);
 286
 287         return gtkpspell;
 288 }
 289
 290 void gtkpspell_delete(GtkPspell * gtkpspell)
 291 {
 292         GtkSText * gtktext;
 293
 294         gtktext = gtkpspell->gtktext;
 295
 296         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
 297                                       GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
 298         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
 299                                       GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
 300         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
 301                                       GTK_SIGNAL_FUNC(button_press_intercept_cb),
 302                                       gtkpspell);
 303
 304         gtkpspell_uncheck_all(gtkpspell);
 305
 306         gtkpspeller_delete(gtkpspell->gtkpspeller);
 307
 308         g_free(gtkpspell);
 309         gtkpspell = NULL;
 310 }
 311
 312 static void entry_insert_cb(GtkSText *gtktext, gchar *newtext,
 313                             guint len, guint *ppos,
 314                             GtkPspell * gtkpspell)
 315 {
 316         g_return_if_fail(gtkpspell->gtkpspeller->checker);
 317
 318         /* We must insert ourself the character to impose the */
 319         /* color of the inserted character to be default */
 320         /* Never mess with set_insertion when frozen */
 321         gtk_stext_freeze(gtktext);
 322         gtk_stext_backward_delete(GTK_STEXT(gtktext), len);
 323         gtk_stext_insert(GTK_STEXT(gtktext), NULL, NULL, NULL, newtext, len);
 324         *ppos = gtk_stext_get_point(GTK_STEXT(gtktext));
 325
 326         if (iswordsep(newtext[0])) {
 327                 /* did we just end a word? */
 328                 if (*ppos >= 2)
 329                         check_at(gtkpspell, *ppos - 2);
 330
 331                 /* did we just split a word? */
 332                 if (*ppos < gtk_stext_get_length(gtktext))
 333                         check_at(gtkpspell, *ppos + 1);
 334         } else {
 335                 /* check as they type, *except* if they're typing at the end (the most
 336                  * common case.
 337                  */
 338                 if (*ppos < gtk_stext_get_length(gtktext)
 339                 &&  !iswordsep(get_text_index_whar(gtkpspell, *ppos)))
 340                         check_at(gtkpspell, *ppos - 1);
 341                 }
 342         gtk_stext_thaw(gtktext);
 343         gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
 344 }
 345
 346 static void entry_delete_cb(GtkSText *gtktext, gint start, gint end,
 347                             GtkPspell *gtkpspell)
 348 {
 349         int origpos;
 350
 351         g_return_if_fail(gtkpspell->gtkpspeller->checker);
 352
 353         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 354         if (start) {
 355                 check_at(gtkpspell, start - 1);
 356                 check_at(gtkpspell, start);
 357         }
 358
 359         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
 360         gtk_stext_set_point(gtktext, origpos);
 361         gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
 362         /* this is to *UNDO* the selection, in case they were holding shift
 363          * while hitting backspace. */
 364 }
 365
 366 /* ok, this is pretty wacky:
 367  * we need to let the right-mouse-click go through, so it moves the cursor,
 368  * but we *can't* let it go through, because GtkText interprets rightclicks as
 369  * weird selection modifiers.
 370  *
 371  * so what do we do?  forge rightclicks as leftclicks, then popup the menu.
 372  * HACK HACK HACK.
 373  */
 374 static gint button_press_intercept_cb(GtkSText *gtktext, GdkEvent *e, GtkPspell *gtkpspell)
 375 {
 376         GdkEventButton *eb;
 377         gboolean retval;
 378
 379         g_return_val_if_fail(gtkpspell->gtkpspeller->checker, FALSE);
 380
 381         if (e->type != GDK_BUTTON_PRESS)
 382                 return FALSE;
 383         eb = (GdkEventButton*) e;
 384
 385         if (eb->button != 3)
 386                 return FALSE;
 387
 388         /* forge the leftclick */
 389         eb->button = 1;
 390
 391         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
 392                                          GTK_SIGNAL_FUNC(button_press_intercept_cb),
 393                                          gtkpspell);
 394         gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
 395                                 e, &retval);
 396         gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
 397                                            GTK_SIGNAL_FUNC(button_press_intercept_cb),
 398                                            gtkpspell);
 399         gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
 400
 401         /* now do the menu wackiness */
 402         popup_menu(gtkpspell, eb);
 403         gtk_grab_remove(GTK_WIDGET(gtktext));
 404         return TRUE;
 405 }
 406
 407 /*****************************************************************************/
 408 /* Checker creation */
 409 static GtkPspeller *gtkpspeller_new(Dictionary *dictionary)
 410 {
 411         GSList          *checkers, *exist;
 412         GtkPspeller     *gtkpspeller = NULL;
 413         GtkPspeller     *g           = g_new(GtkPspeller, 1);
 414         Dictionary      *dict;
 415         gint            ispell;
 416         gboolean        free_dict = TRUE;
 417
 418         g_return_val_if_fail(gtkpspellcheckers, NULL);
 419
 420         g_return_val_if_fail(dictionary, NULL);
 421
 422         if (dictionary->fullname == NULL)
 423                 gtkpspell_checkers_error_message(g_strdup(_("No dictionary selected.")));
 424
 425         g_return_val_if_fail(dictionary->fullname, NULL);
 426
 427         if (dictionary->dictname == NULL) {
 428                 gchar *tmp;
 429
 430                 tmp = strrchr(dictionary->fullname, G_DIR_SEPARATOR);
 431
 432                 if (tmp == NULL)
 433                         dictionary->dictname = dictionary->fullname;
 434                 else
 435                         dictionary->dictname = tmp + 1;
 436         }
 437
 438         dict = dictionary_dup(dictionary);
 439
 440         ispell = (strstr2(dict->dictname, "-ispell") != NULL);
 441
 442         g->dictionary = dict;
 443
 444         checkers = gtkpspellcheckers->checkers;
 445
 446         exist = g_slist_find_custom(checkers, g, find_gtkpspeller);
 447
 448         g_free(g);
 449
 450         if (exist)
 451                 gtkpspeller = (GtkPspeller *) exist->data;
 452
 453         if (exist && ispell)
 454                 debug_print(_("Pspell: Using existing ispell checker %0x\n"),
 455                             (gint) gtkpspeller);
 456         else {
 457                 if ((gtkpspeller = gtkpspeller_real_new(dict)) != NULL) {
 458                         checkers = g_slist_append(checkers, gtkpspeller);
 459
 460                         debug_print(_("Pspell: Created a new gtkpspeller %0x\n"),
 461                                     (gint) gtkpspeller);
 462
 463                         free_dict = FALSE;
 464                 } else
 465                         debug_print(_("Pspell: Could not create spell checker.\n"));
 466         }
 467
 468         debug_print(_("Pspell: number of existing checkers %d\n"),
 469                     g_slist_length(checkers));
 470
 471         if (free_dict)
 472                 dictionary_delete(dict);
 473
 474         gtkpspellcheckers->checkers = checkers;
 475
 476         return gtkpspeller;
 477 }
 478
 479 static GtkPspeller *gtkpspeller_real_new(Dictionary *dict)
 480 {
 481         GtkPspeller             *gtkpspeller;
 482         PspellConfig            *config;
 483         PspellCanHaveError      *ret;
 484
 485         g_return_val_if_fail(gtkpspellcheckers, NULL);
 486         g_return_val_if_fail(dict, NULL);
 487
 488         gtkpspeller = g_new(GtkPspeller, 1);
 489
 490         gtkpspeller->dictionary = dict;
 491         gtkpspeller->sug_mode   = PSPELL_FASTMODE;
 492
 493         config = new_pspell_config();
 494
 495         if (!set_dictionary(config, dict))
 496                 return NULL;
 497
 498         ret = new_pspell_manager(config);
 499         delete_pspell_config(config);
 500
 501         if (pspell_error_number(ret) != 0) {
 502                 gtkpspellcheckers->error_message = g_strdup(pspell_error_message(ret));
 503
 504                 delete_pspell_can_have_error(ret);
 505
 506                 return NULL;
 507         }
 508
 509         gtkpspeller->checker = to_pspell_manager(ret);
 510         gtkpspeller->config  = pspell_manager_config(gtkpspeller->checker);
 511         gtkpspeller->ispell  = (strstr2(dict->fullname, "-ispell") != NULL);
 512
 513         return gtkpspeller;
 514 }
 515
 516 static GtkPspeller *gtkpspeller_delete(GtkPspeller *gtkpspeller)
 517 {
 518         GSList *checkers;
 519
 520         g_return_val_if_fail(gtkpspellcheckers, NULL);
 521
 522         checkers = gtkpspellcheckers->checkers;
 523
 524         if (gtkpspeller->ispell)
 525                 debug_print(_("Pspell: Won't remove existing ispell checker %0x.\n"),
 526                             (gint) gtkpspeller);
 527         else {
 528                 checkers = g_slist_remove(checkers, gtkpspeller);
 529
 530                 gtkpspellcheckers->checkers = checkers;
 531
 532                 debug_print(_("Pspell: Deleting gtkpspeller %0x.\n"),
 533                             (gint) gtkpspeller);
 534
 535                 gtkpspeller_real_delete(gtkpspeller);
 536         }
 537
 538         debug_print(_("Pspell: number of existing checkers %d\n"),
 539                     g_slist_length(checkers));
 540
 541         return gtkpspeller;
 542 }
 543
 544 static GtkPspeller *gtkpspeller_real_delete(GtkPspeller *gtkpspeller)
 545 {
 546         g_return_val_if_fail(gtkpspeller,          NULL);
 547         g_return_val_if_fail(gtkpspeller->checker, NULL);
 548
 549         pspell_manager_save_all_word_lists(gtkpspeller->checker);
 550
 551         delete_pspell_manager(gtkpspeller->checker);
 552
 553         dictionary_delete(gtkpspeller->dictionary);
 554
 555         g_free(gtkpspeller);
 556
 557         return NULL;
 558 }
 559
 560 /*****************************************************************************/
 561 /* Checker configuration */
 562
 563 static gboolean set_dictionary(PspellConfig *config, Dictionary *dict)
 564 {
 565         gchar *language = NULL;
 566         gchar *spelling = NULL;
 567         gchar *jargon   = NULL;
 568         gchar *module   = NULL;
 569         gchar *end      = NULL;
 570         gchar buf[BUFSIZE];
 571
 572         g_return_val_if_fail(config, FALSE);
 573         g_return_val_if_fail(dict,   FALSE);
 574
 575         strncpy(buf, dict->fullname, BUFSIZE-1);
 576         buf[BUFSIZE-1] = 0x00;
 577
 578         buf[dict->dictname - dict->fullname] = 0x00;
 579
 580         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("rem-all-word-list-path", "");
 581         debug_print(_("Pspell: removing all paths.\n"));
 582
 583         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("add-word-list-path", buf);
 584         debug_print(_("Pspell: adding path (%s).\n"), buf);
 585
 586         strncpy(buf, dict->dictname, BUFSIZE-1);
 587         language = buf;
 588
 589         if ((module = strrchr(buf, '-')) != NULL) {
 590                 module++;
 591         }
 592         if ((spelling = strchr(language, '-')) != NULL)
 593                 *spelling++ = 0x00;
 594         if (spelling != module) {
 595                 if ((end = strchr(spelling, '-')) != NULL) {
 596                         *end++ = 0x00;
 597                         jargon = end;
 598                         if (jargon != module)
 599                                 if ((end = strchr(jargon, '-')) != NULL)
 600                                         *end = 0x00;
 601                                 else
 602                                         jargon = NULL;
 603                         else
 604                                 jargon = NULL;
 605                 }
 606                 else
 607                         spelling = NULL;
 608         }
 609         else
 610                 spelling = NULL;
 611
 612         debug_print(_("Pspell: Language: %s, spelling: %s, jargon: %s, module: %s\n"),
 613                     language, spelling, jargon, module);
 614
 615         if (language)
 616                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("language-tag", language);
 617
 618         if (spelling)
 619                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("spelling",     spelling);
 620
 621         if (jargon)
 622                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("jargon",       jargon);
 623
 624         if (module) {
 625                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("rem-all-module-search-order", "");
 626                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("add-module-search-order", module);
 627         }
 628
 629         if (dict->encoding) {
 630                 gchar *pspell_enc;
 631
 632                 pspell_enc = convert_to_pspell_encoding (dict->encoding);
 633                 pspell_config_replace(config, "encoding", (const char *) pspell_enc);
 634                 g_free(pspell_enc);
 635
 636                 RETURN_FALSE_IF_CONFIG_ERROR();
 637         }
 638
 639         return TRUE;
 640 }
 641
 642 guchar *gtkpspell_get_dict(GtkPspell *gtkpspell)
 643 {
 644
 645         g_return_val_if_fail(gtkpspell->gtkpspeller->config,     NULL);
 646         g_return_val_if_fail(gtkpspell->gtkpspeller->dictionary, NULL);
 647
 648         return g_strdup(gtkpspell->gtkpspeller->dictionary->dictname);
 649 }
 650
 651 guchar *gtkpspell_get_path(GtkPspell *gtkpspell)
 652 {
 653         guchar *path;
 654         Dictionary *dict;
 655
 656         g_return_val_if_fail(gtkpspell->gtkpspeller->config, NULL);
 657         g_return_val_if_fail(gtkpspell->gtkpspeller->dictionary, NULL);
 658
 659         dict = gtkpspell->gtkpspeller->dictionary;
 660         path = g_strndup(dict->fullname, dict->dictname - dict->fullname);
 661
 662         return path;
 663 }
 664
 665 /* set_sug_mode_cb() - Menu callback : Set the suggestion mode */
 666 static void set_sug_mode_cb(GtkWidget *w, GtkPspell *gtkpspell)
 667 {
 668         unsigned char *themode;
 669
 670         if (gtkpspell->gtkpspeller->ispell) return;
 671
 672         gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode);
 673
 674         set_real_sug_mode(gtkpspell, themode);
 675
 676 }
 677 static void set_real_sug_mode(GtkPspell *gtkpspell, const char *themode)
 678 {
 679         gint result;
 680         g_return_if_fail(gtkpspell);
 681         g_return_if_fail(gtkpspell->gtkpspeller);
 682         g_return_if_fail(themode);
 683
 684         if (!strcmp(themode, _("Fast Mode"))) {
 685                 result = gtkpspell_set_sug_mode(gtkpspell, PSPELL_FASTMODE);
 686         } else if (!strcmp(themode,_("Normal Mode"))) {
 687                 result = gtkpspell_set_sug_mode(gtkpspell, PSPELL_NORMALMODE);
 688         } else if (!strcmp( themode,_("Bad Spellers Mode"))) {
 689                 result = gtkpspell_set_sug_mode(gtkpspell, PSPELL_BADSPELLERMODE);
 690         }
 691
 692         if(!result) {
 693                 debug_print(_("Pspell: error while changing suggestion mode:%s\n"),
 694                             gtkpspellcheckers->error_message);
 695                 gtkpspell_checkers_reset();
 696         }
 697 }
 698
 699 /* gtkpspell_set_sug_mode() - Set the suggestion mode */
 700 gboolean gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gint themode)
 701 {
 702         PspellConfig *config;
 703         g_return_val_if_fail(gtkpspell, FALSE);
 704         g_return_val_if_fail(gtkpspell->gtkpspeller, FALSE);
 705         g_return_val_if_fail(gtkpspell->gtkpspeller->config, FALSE);
 706
 707         config = gtkpspell->gtkpspeller->config;
 708         switch (themode) {
 709                 case PSPELL_FASTMODE:
 710                         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "fast");
 711                         break;
 712                 case PSPELL_NORMALMODE:
 713                         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "normal");
 714                         break;
 715                 case PSPELL_BADSPELLERMODE:
 716                         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode",
 717                                                             "bad-spellers");
 718                         break;
 719                 default:
 720                         gtkpspellcheckers->error_message =
 721                                 g_strdup(_("Unknown suggestion mode."));
 722                         return FALSE;
 723                 }
 724
 725         gtkpspell->gtkpspeller->sug_mode = themode;
 726         gtkpspell->default_sug_mode      = themode;
 727
 728         return TRUE;
 729 }
 730
 731 /* misspelled_suggest() - Create a suggestion list for  word  */
 732 static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word)
 733 {
 734         const guchar          *newword;
 735         GList                 *list = NULL;
 736         const PspellWordList  *suggestions;
 737         PspellStringEmulation *elements;
 738
 739         g_return_val_if_fail(word, NULL);
 740
 741         if (!pspell_manager_check(gtkpspell->gtkpspeller->checker, word, -1)) {
 742                 free_suggestions_list(gtkpspell);
 743
 744                 suggestions = pspell_manager_suggest(gtkpspell->gtkpspeller->checker,
 745                                                      (const char *)word, -1);
 746                 elements    = pspell_word_list_elements(suggestions);
 747                 list        = g_list_append(list, g_strdup(word));
 748
 749                 while ((newword = pspell_string_emulation_next(elements)) != NULL)
 750                         list = g_list_append(list, g_strdup(newword));
 751
 752                 gtkpspell->max_sug          = g_list_length(list) - 1;
 753                 gtkpspell->suggestions_list = list;
 754
 755                 return list;
 756         }
 757
 758         free_suggestions_list(gtkpspell);
 759
 760         return NULL;
 761 }
 762
 763 /* misspelled_test() - Just test if word is correctly spelled */
 764 static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word)
 765 {
 766         return pspell_manager_check(gtkpspell->gtkpspeller->checker, word, -1) ? 0 : 1;
 767 }
 768
 769
 770 static gboolean iswordsep(unsigned char c)
 771 {
 772         return !isalpha(c) && c != '\'';
 773 }
 774
 775 static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos)
 776 {
 777         guchar a;
 778         gchar *text;
 779
 780         text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1);
 781         if (text == NULL)
 782                 return 0;
 783         a = (guchar) *text;
 784         g_free(text);
 785         return a;
 786 }
 787
 788 /* get_word_from_pos () - return the word pointed to. */
 789 /* Handles correctly the quotes. */
 790 static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos,
 791                                   unsigned char* buf,
 792                                   int *pstart, int *pend)
 793 {
 794
 795         /* TODO : when correcting a word into quotes, change the color of */
 796         /* the quotes too, as may be they were highlighted before. To do  */
 797         /* this, we can use two others pointers that points to the whole    */
 798         /* word including quotes. */
 799
 800         gint      start,
 801                   end;
 802         guchar    c;
 803         GtkSText *gtktext;
 804
 805         gtktext = gtkpspell->gtktext;
 806         if (iswordsep(get_text_index_whar(gtkpspell, pos)))
 807                 return FALSE;
 808
 809         /* The apostrophe character is somtimes used for quotes
 810          * So include it in the word only if it is not surrounded
 811          * by other characters.
 812          */
 813
 814         for (start = pos; start >= 0; --start) {
 815                 c = get_text_index_whar(gtkpspell, start);
 816                 if (c == '\'') {
 817                         if (start > 0) {
 818                                 if (!isalpha(get_text_index_whar(gtkpspell, start - 1))) {
 819                                         /* start_quote = TRUE; */
 820                                         break;
 821                                 }
 822                         }
 823                         else {
 824                                 /* start_quote = TRUE; */
 825                                 break;
 826                         }
 827                 }
 828                 else
 829                         if (!isalpha(c))
 830                                 break;
 831         }
 832         start++;
 833
 834         for (end = pos; end < gtk_stext_get_length(gtktext); end++) {
 835                 c = get_text_index_whar(gtkpspell, end);
 836                 if (c == '\'') {
 837                         if (end < gtk_stext_get_length(gtktext)) {
 838                                 if (!isalpha(get_text_index_whar(gtkpspell, end + 1))) {
 839                                         /* end_quote = TRUE; */
 840                                         break;
 841                                 }
 842                         }
 843                         else {
 844                                 /* end_quote = TRUE; */
 845                                 break;
 846                         }
 847                 }
 848                 else
 849                         if(!isalpha(c))
 850                                 break;
 851         }
 852
 853         if (buf) {
 854                 for (pos = start; pos < end; pos++)
 855                         buf[pos - start] = get_text_index_whar(gtkpspell, pos);
 856                 buf[pos - start] = 0;
 857         }
 858
 859         if (pstart)
 860                 *pstart = start;
 861         if (pend)
 862                 *pend = end;
 863
 864         return TRUE;
 865 }
 866
 867 static gboolean check_at(GtkPspell *gtkpspell, int from_pos)
 868 {
 869         int           start, end;
 870         unsigned char buf[BUFSIZE];
 871         GtkSText     *gtktext;
 872
 873         g_return_val_if_fail(from_pos >= 0, FALSE);
 874
 875         gtktext = gtkpspell->gtktext;
 876
 877         if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end))
 878                 return FALSE;
 879
 880
 881         if (misspelled_test(gtkpspell, buf)) {
 882                 strncpy(gtkpspell->theword, buf, GTKPSPELLWORDSIZE - 1);
 883                 gtkpspell->theword[GTKPSPELLWORDSIZE - 1] = 0;
 884                 gtkpspell->start_pos  = start;
 885                 gtkpspell->end_pos    = end;
 886                 gtkpspell->newword[0] = 0;
 887                 free_suggestions_list(gtkpspell);
 888
 889                 change_color(gtkpspell, start, end, &(gtkpspell->highlight));
 890
 891                 return TRUE;
 892         } else {
 893                 change_color(gtkpspell, start, end, NULL);
 894                 return FALSE;
 895         }
 896 }
 897
 898 static void check_all_cb(GtkWidget *w, GtkPspell *gtkpspell)
 899 {
 900         gtkpspell_check_all(gtkpspell);
 901 }
 902
 903 void gtkpspell_check_all(GtkPspell *gtkpspell)
 904 {
 905         guint     origpos;
 906         guint     pos = 0;
 907         guint     len;
 908         float     adj_value;
 909         GtkSText *gtktext;
 910
 911         g_return_if_fail(gtkpspell->gtkpspeller->checker);
 912
 913         gtktext = gtkpspell->gtktext;
 914
 915         len = gtk_stext_get_length(gtktext);
 916
 917         adj_value = gtktext->vadj->value;
 918         gtk_stext_freeze(gtktext);
 919         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 920         gtk_editable_set_position(GTK_EDITABLE(gtktext),0);
 921         while (pos < len) {
 922                 while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos)))
 923                         pos++;
 924                 while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos)))
 925                         pos++;
 926                 if (pos > 0)
 927                         check_at(gtkpspell, pos - 1);
 928         }
 929         gtk_stext_thaw(gtktext);
 930         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
 931         gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
 932 }
 933
 934 static void check_next_prev(GtkPspell *gtkpspell, gboolean forward)
 935 {
 936         gint pos;
 937         gint minpos;
 938         gint maxpos;
 939         gint direc = -1;
 940         gboolean misspelled;
 941         GdkEvent *event= (GdkEvent *) gtk_get_current_event();
 942
 943         minpos = 0;
 944         maxpos = gtk_stext_get_length(gtkpspell->gtktext);
 945
 946         if (forward) {
 947                 minpos = -1;
 948                 direc = -direc;
 949                 maxpos--;
 950         }
 951
 952
 953         pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
 954         gtkpspell->orig_pos = pos;
 955         while (iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
 956                 pos += direc;
 957         while (!(misspelled = check_at(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
 958         {
 959                 while (!iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
 960                         pos += direc;
 961
 962                 while (iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
 963                         pos += direc;
 964         }
 965         if (misspelled) {
 966                 misspelled_suggest(gtkpspell, gtkpspell->theword);
 967                 if (forward)
 968                         gtkpspell->orig_pos = gtkpspell->end_pos;
 969                 gtk_stext_set_point(GTK_STEXT(gtkpspell->gtktext),
 970                                 gtkpspell->end_pos);
 971                 gtk_editable_set_position(GTK_EDITABLE(gtkpspell->gtktext),
 972                                 gtkpspell->end_pos);
 973                 gtk_menu_popup(make_sug_menu(gtkpspell), NULL, NULL,
 974                                 set_menu_pos, gtkpspell, 0, gdk_event_get_time(event));
 975         } else {
 976                 reset_theword_data(gtkpspell);
 977
 978                 gtk_stext_set_point(GTK_STEXT(gtkpspell->gtktext), gtkpspell->orig_pos);
 979                 gtk_editable_set_position(GTK_EDITABLE(gtkpspell->gtktext), gtkpspell->orig_pos);
 980         }
 981 }
 982
 983 void gtkpspell_check_backwards(GtkPspell *gtkpspell)
 984 {
 985         check_next_prev(gtkpspell, FALSE);
 986 }
 987
 988 void gtkpspell_check_forwards_go(GtkPspell *gtkpspell)
 989 {
 990         check_next_prev(gtkpspell, TRUE);
 991 }
 992
 993
 994 static void replace_word(GtkWidget *w, GtkPspell *gtkpspell)
 995 {
 996         unsigned char *newword;
 997         GdkEvent *e= (GdkEvent *) gtk_get_current_event();
 998
 999         gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
1000         replace_real_word(gtkpspell, newword);
1001         if ((e->type == GDK_KEY_PRESS && ((GdkEventKey *) e)->state & GDK_MOD1_MASK) ||
1002             (e->type == GDK_BUTTON_RELEASE && ((GdkEventButton *) e)->state & GDK_MOD1_MASK)) {
1003                 pspell_manager_store_replacement(gtkpspell->gtkpspeller->checker,
1004                                                  gtkpspell->theword, -1,
1005                                                  newword, -1);
1006         }
1007         gtkpspell->newword[0] = 0x00;
1008         gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
1009 }
1010
1011 static void replace_real_word(GtkPspell *gtkpspell, gchar *newword)
1012 {
1013         int             oldlen, newlen, wordlen;
1014         gint            origpos;
1015         gint            pos;
1016         gint            start = gtkpspell->start_pos;
1017         GtkSText       *gtktext;
1018
1019         if (!newword) return;
1020
1021         gtktext = gtkpspell->gtktext;
1022
1023         gtk_stext_freeze(GTK_STEXT(gtktext));
1024         origpos = gtkpspell->orig_pos;
1025         pos     = origpos;
1026         oldlen  = gtkpspell->end_pos - gtkpspell->start_pos;
1027         wordlen = strlen(gtkpspell->theword);
1028
1029         strncpy(gtkpspell->newword, newword, GTKPSPELLWORDSIZE - 1);
1030         gtkpspell->newword[GTKPSPELLWORDSIZE-1] = 0x00;
1031         newlen = strlen(newword); /* FIXME: multybyte characters? */
1032
1033         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
1034                         GTK_SIGNAL_FUNC(entry_insert_cb),
1035                         gtkpspell);
1036         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
1037                         GTK_SIGNAL_FUNC(entry_delete_cb),
1038                         gtkpspell);
1039         gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "delete-text",
1040                                 gtkpspell->start_pos, gtkpspell->end_pos);
1041         gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "insert-text",
1042                                 newword, newlen, &start);
1043
1044         gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
1045                         GTK_SIGNAL_FUNC(entry_insert_cb),
1046                         gtkpspell);
1047         gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
1048                         GTK_SIGNAL_FUNC(entry_delete_cb),
1049                         gtkpspell);
1050
1051         /* Put the point and the position where we clicked with the mouse */
1052         /* It seems to be a hack, as I must thaw,freeze,thaw the widget   */
1053         /* to let it update correctly the word insertion and then the     */
1054         /* point & position position. If not, SEGV after the first replacement */
1055         /* If the new word ends before point, put the point at its end*/
1056
1057         if (origpos - gtkpspell->start_pos < oldlen && origpos - gtkpspell->start_pos >= 0) {
1058                 /* Original point was in the word. */
1059                 /* Let it there unless point is going to be outside of the word */
1060                 if (origpos - gtkpspell->start_pos >= newlen) {
1061                         pos = gtkpspell->start_pos + newlen;
1062                 }
1063         }
1064         else if (origpos >= gtkpspell->end_pos) {
1065                 /* move the position according to the change of length */
1066                 pos = origpos + newlen - oldlen;
1067         }
1068
1069         gtkpspell->end_pos = gtkpspell->start_pos + strlen(newword); /* FIXME: multibyte characters? */
1070
1071         gtk_stext_thaw(GTK_STEXT(gtktext));
1072         gtk_stext_freeze(GTK_STEXT(gtktext));
1073         if (GTK_STEXT(gtktext)->text_len < pos)
1074                 pos = gtk_stext_get_length(GTK_STEXT(gtktext));
1075         gtkpspell->orig_pos = pos;
1076         gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkpspell->orig_pos);
1077         gtk_stext_set_point(GTK_STEXT(gtktext),
1078                             gtk_editable_get_position(GTK_EDITABLE(gtktext)));
1079         gtk_stext_thaw(GTK_STEXT(gtktext));
1080 }
1081
1082 /* Accept this word for this session */
1083
1084 static void add_word_to_session(GtkWidget *w, GtkPspell *gtkpspell)
1085 {
1086         guint     pos;
1087         GtkSText *gtktext;
1088
1089         gtktext = gtkpspell->gtktext;
1090
1091         gtk_stext_freeze(GTK_STEXT(gtktext));
1092
1093         pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1094
1095         pspell_manager_add_to_session(gtkpspell->gtkpspeller->checker,gtkpspell->theword, strlen(gtkpspell->theword));
1096
1097         check_at(gtkpspell, gtkpspell->start_pos);
1098
1099         gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
1100 }
1101
1102 /* add_word_to_personal() - add word to personal dict. */
1103 static void add_word_to_personal(GtkWidget *w, GtkPspell *gtkpspell)
1104 {
1105         GtkSText *gtktext;
1106
1107         gtktext = gtkpspell->gtktext;
1108
1109         gtk_stext_freeze(GTK_STEXT(gtktext));
1110
1111         pspell_manager_add_to_personal(gtkpspell->gtkpspeller->checker,gtkpspell->theword, strlen(gtkpspell->theword));
1112
1113         check_at(gtkpspell, gtkpspell->start_pos);
1114
1115         gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
1116 }
1117
1118 void gtkpspell_uncheck_all(GtkPspell * gtkpspell)
1119 {
1120         int origpos;
1121         unsigned char *text;
1122         float adj_value;
1123         GtkSText *gtktext;
1124
1125         gtktext=gtkpspell->gtktext;
1126
1127         adj_value = gtktext->vadj->value;
1128         gtk_stext_freeze(gtktext);
1129         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1130         text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
1131         gtk_stext_set_point(gtktext, 0);
1132         gtk_stext_forward_delete(gtktext, gtk_stext_get_length(gtktext));
1133         gtk_stext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
1134         gtk_stext_thaw(gtktext);
1135
1136         g_free(text);
1137
1138         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
1139         gtk_adjustment_set_value(gtktext->vadj, adj_value);
1140 }
1141
1142 static GSList *create_empty_dictionary_list(void)
1143 {
1144         GSList *list = NULL;
1145         Dictionary *dict;
1146
1147         dict = g_new0(Dictionary, 1);/*printf("N %08x            dictionary\n", dict);*/
1148         dict->fullname = g_strdup(_("None"));/*printf("N %08x            fullname\n", dict->fullname);*/
1149         dict->dictname = dict->fullname;
1150         dict->encoding = NULL;
1151         return g_slist_append(list, dict);
1152 }
1153
1154 /* gtkpspell_get_dictionary_list() - returns list of dictionary names */
1155 GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path, gint refresh)
1156 {
1157         GSList *list;
1158         gchar *dict_path, *tmp, *prevdir;
1159         gchar tmpname[BUFSIZE];
1160         Dictionary *dict;
1161         DIR *dir;
1162         struct dirent *ent;
1163
1164         if (!gtkpspellcheckers)
1165                 gtkpspellcheckers = gtkpspell_checkers_new();
1166
1167         if (gtkpspellcheckers->dictionary_list && !refresh)
1168                 return gtkpspellcheckers->dictionary_list;
1169         else
1170                 gtkpspell_free_dictionary_list(gtkpspellcheckers->dictionary_list);
1171
1172         list = NULL;
1173
1174 #ifdef USE_THREADS
1175 #warning TODO: no directory change
1176 #endif
1177         dict_path = g_strdup(pspell_path);
1178         prevdir = g_get_current_dir();
1179         if (chdir(dict_path) <0) {
1180                 debug_print(_("Error when searching for dictionaries:\n%s\n"),
1181                                           g_strerror(errno));
1182                 g_free(prevdir);
1183                 g_free(dict_path);
1184                 gtkpspellcheckers->dictionary_list = create_empty_dictionary_list();
1185                 return gtkpspellcheckers->dictionary_list;
1186         }
1187
1188         debug_print(_("Checking for dictionaries in %s\n"), dict_path);
1189
1190         if (NULL != (dir = opendir("."))) {
1191                 while (NULL != (ent = readdir(dir))) {
1192                         /* search for pwli */
1193                         if ((NULL != (tmp = strstr2(ent->d_name, ".pwli"))) && (tmp[5] == 0x00)) {
1194                                 g_snprintf(tmpname, BUFSIZE, "%s%s", G_DIR_SEPARATOR_S, ent->d_name);
1195                                 tmpname[MIN(tmp - ent->d_name + 1, BUFSIZE-1)] = 0x00;
1196                                 dict = g_new0(Dictionary, 1);/*printf("N %08x            dictionary\n", dict);*/
1197                                 dict->fullname = g_strdup_printf("%s%s", dict_path, tmpname);/*printf("N %08x            fullname\n", dict->fullname);*/
1198                                 dict->dictname = strrchr(dict->fullname, G_DIR_SEPARATOR) + 1;
1199                                 dict->encoding = NULL;
1200                                 debug_print(_("Found dictionary %s %s\n"), dict->fullname, dict->dictname);
1201                                 list = g_slist_insert_sorted(list, dict, (GCompareFunc) compare_dict);
1202                         }
1203                 }
1204                 closedir(dir);
1205         }
1206         else {
1207                 debug_print(_("Error when searching for dictionaries.\nNo dictionary found.\n(%s)"),
1208                                           g_strerror(errno));
1209                 list = create_empty_dictionary_list();
1210         }
1211         if(list==NULL){
1212
1213                 debug_print(_("Error when searching for dictionaries.\nNo dictionary found."));
1214                 list = create_empty_dictionary_list();
1215         }
1216         chdir(prevdir);
1217         g_free(dict_path);
1218         g_free(prevdir);
1219         gtkpspellcheckers->dictionary_list = list;
1220         return list;
1221 }
1222
1223 void gtkpspell_free_dictionary_list(GSList *list)
1224 {
1225         Dictionary *dict;
1226         GSList *walk;
1227         for (walk = list; walk != NULL; walk = g_slist_next(walk))
1228                 if (walk->data) {
1229                         dict = (Dictionary *) walk->data;
1230                         dictionary_delete(dict);
1231                 }
1232         g_slist_free(list);
1233 }
1234
1235 #if 0
1236 static void dictionary_option_menu_item_data_destroy(gpointer data)
1237 {
1238         Dictionary *dict = (Dictionary *) data;
1239
1240         if (dict)
1241                 dictionary_delete(dict);
1242 }
1243 #endif
1244
1245 GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path)
1246 {
1247         GSList *dict_list, *tmp;
1248         GtkWidget *item;
1249         GtkWidget *menu;
1250         Dictionary *dict;
1251
1252         dict_list = gtkpspell_get_dictionary_list(pspell_path, TRUE);
1253         g_return_val_if_fail(dict_list, NULL);
1254
1255         menu = gtk_menu_new();
1256
1257         for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
1258                 dict = (Dictionary *) tmp->data;
1259                 item = gtk_menu_item_new_with_label(dict->dictname);
1260                 if (dict->dictname)
1261                         gtk_object_set_data(GTK_OBJECT(item), "dict_name",
1262                                          dict);
1263
1264                 gtk_menu_append(GTK_MENU(menu), item);
1265                 gtk_widget_show(item);
1266         }
1267
1268         gtk_widget_show(menu);
1269
1270         return menu;
1271 }
1272
1273 gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu)
1274 {
1275         GtkWidget *menuitem;
1276         Dictionary *result;
1277         gchar *label;
1278
1279         g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
1280         menuitem = gtk_menu_get_active(GTK_MENU(menu));
1281         result = (Dictionary *) gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name");
1282         g_return_val_if_fail(result->fullname, NULL);
1283         label = g_strdup(result->fullname);
1284         return label;
1285
1286 }
1287
1288 GtkWidget *gtkpspell_sugmode_option_menu_new(gint sugmode)
1289 {
1290         GtkWidget *menu;
1291         GtkWidget *item;
1292
1293
1294         menu = gtk_menu_new();
1295         gtk_widget_show(menu);
1296
1297         item = gtk_menu_item_new_with_label(_("Fast Mode"));
1298         gtk_widget_show(item);
1299         gtk_menu_append(GTK_MENU(menu), item);
1300         gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_FASTMODE));
1301
1302         item = gtk_menu_item_new_with_label(_("Normal Mode"));
1303         gtk_widget_show(item);
1304         gtk_menu_append(GTK_MENU(menu), item);
1305         gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_NORMALMODE));
1306
1307         item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
1308         gtk_widget_show(item);
1309         gtk_menu_append(GTK_MENU(menu), item);
1310         gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_BADSPELLERMODE));
1311
1312         return menu;
1313 }
1314
1315 void gtkpspell_sugmode_option_menu_set(GtkOptionMenu *optmenu, gint sugmode)
1316 {
1317         g_return_if_fail(GTK_IS_OPTION_MENU(optmenu));
1318
1319         g_return_if_fail(sugmode == PSPELL_FASTMODE ||
1320                          sugmode == PSPELL_NORMALMODE ||
1321                          sugmode == PSPELL_BADSPELLERMODE);
1322
1323         gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
1324 }
1325
1326 gint gtkpspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
1327 {
1328         gint sugmode;
1329         GtkWidget *item;
1330
1331         g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
1332
1333         item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
1334
1335         sugmode = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item), "sugmode"));
1336
1337         return sugmode;
1338
1339 }
1340
1341 void gtkpspell_set_primary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding)
1342 {
1343         g_return_if_fail(gtkpspell);
1344         if (gtkpspell->dict1)
1345                 dictionary_delete(gtkpspell->dict1);
1346         gtkpspell->dict1 = g_new(Dictionary, 1);
1347         gtkpspell->dict1->fullname = g_strdup(dict);
1348         gtkpspell->dict1->encoding = g_strdup(encoding);
1349 }
1350
1351 void gtkpspell_set_secondary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding)
1352 {
1353         g_return_if_fail(gtkpspell);
1354         if (gtkpspell->dict2)
1355                 dictionary_delete(gtkpspell->dict2);
1356         gtkpspell->dict2 = g_new(Dictionary, 1);
1357         gtkpspell->dict2->fullname = g_strdup(dict);
1358         gtkpspell->dict2->encoding = g_strdup(encoding);
1359 }
1360
1361 gboolean gtkpspell_use_dict(GtkPspell *gtkpspell, Dictionary *dict)
1362 {
1363         return TRUE;
1364 }
1365
1366 gboolean gtkpspell_use_dictionary(GtkPspell *gtkpspell, gchar *dictpath, gchar *encoding)
1367 {
1368         Dictionary *dict;
1369         gboolean retval;
1370
1371         g_return_val_if_fail(gtkpspell, FALSE);
1372         g_return_val_if_fail(dict, FALSE);
1373         g_return_val_if_fail(encoding, FALSE);
1374
1375         dict = g_new(Dictionary, 1);
1376
1377         dict->fullname = g_strdup(dictpath);
1378         dict->encoding = NULL; /* To be continued */
1379
1380         retval = gtkpspell_use_dict(gtkpspell, dict);
1381
1382         dictionary_delete(dict);
1383
1384         return retval;
1385
1386 }
1387
1388 gboolean gtkpspell_use_primary(GtkPspell *gtkpspell)
1389 {
1390         g_return_val_if_fail(gtkpspell, FALSE);
1391
1392         return gtkpspell_use_dict(gtkpspell, gtkpspell->dict1);
1393 }
1394
1395 gboolean gtkpspell_use_secondary(GtkPspell *gtkpspell)
1396 {
1397         g_return_val_if_fail(gtkpspell, FALSE);
1398
1399         return gtkpspell_use_dict(gtkpspell, gtkpspell->dict2);
1400 }
1401
1402 /*****************************************************************************/
1403
1404 static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb)
1405 {
1406         GtkSText * gtktext;
1407
1408         gtktext = gtkpspell->gtktext;
1409         gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1410
1411         if (!(eb->state & GDK_SHIFT_MASK)) {
1412                 if (check_at(gtkpspell, gtkpspell->orig_pos)) {
1413
1414                         gtk_editable_set_position(GTK_EDITABLE(gtktext),
1415                                                   gtkpspell->orig_pos);
1416                         gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
1417
1418                         if (misspelled_suggest(gtkpspell, gtkpspell->theword)) {
1419                                 gtk_menu_popup(make_sug_menu(gtkpspell),
1420                                                NULL, NULL, NULL, NULL,
1421                                                eb->button, eb->time);
1422
1423                                 return;
1424                         }
1425                 } else {
1426                         gtk_editable_set_position(GTK_EDITABLE(gtktext),
1427                                                   gtkpspell->orig_pos);
1428                         gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
1429                 }
1430         }
1431
1432         gtk_menu_popup(make_config_menu(gtkpspell),NULL,NULL,NULL,NULL,
1433                        eb->button,eb->time);
1434 }
1435
1436 /* make_sug_menu() - Add menus to accept this word for this session and to add it to
1437  * personal dictionary */
1438 static GtkMenu *make_sug_menu(GtkPspell *gtkpspell)
1439 {
1440         GtkWidget       *menu, *item;
1441         unsigned char   *caption;
1442         GtkSText        *gtktext;
1443         GList           *l = gtkpspell->suggestions_list;
1444         GtkAccelGroup   *accel;
1445
1446
1447         gtktext = gtkpspell->gtktext;
1448
1449         accel = gtk_accel_group_new();
1450         menu = gtk_menu_new();
1451
1452         gtk_signal_connect(GTK_OBJECT(menu), "deactivate",
1453                 GTK_SIGNAL_FUNC(deactivate_menu_cb), gtkpspell);
1454
1455         caption = g_strdup_printf(_("Unknown word: \"%s\""),
1456                                   (unsigned char*) l->data);
1457         item = gtk_menu_item_new_with_label(caption);
1458         gtk_widget_show(item);
1459         gtk_menu_append(GTK_MENU(menu), item);
1460         gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
1461         g_free(caption);
1462
1463         item = gtk_menu_item_new();
1464         gtk_widget_show(item);
1465         gtk_menu_append(GTK_MENU(menu), item);
1466
1467         item = gtk_menu_item_new_with_label(_("Accept in this session"));
1468         gtk_widget_show(item);
1469         gtk_menu_append(GTK_MENU(menu), item);
1470         gtk_signal_connect(GTK_OBJECT(item), "activate",
1471                            GTK_SIGNAL_FUNC(add_word_to_session),
1472                            gtkpspell);
1473         gtk_accel_group_add(accel, GDK_space, GDK_MOD1_MASK,
1474                             GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE,
1475                             GTK_OBJECT(item), "activate");
1476
1477         item = gtk_menu_item_new_with_label(_("Add to personal dictionary"));
1478         gtk_widget_show(item);
1479         gtk_menu_append(GTK_MENU(menu), item);
1480         gtk_signal_connect(GTK_OBJECT(item), "activate",
1481                            GTK_SIGNAL_FUNC(add_word_to_personal),
1482                            gtkpspell);
1483         gtk_accel_group_add(accel, GDK_Return, GDK_MOD1_MASK,
1484                             GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE,
1485                             GTK_OBJECT(item), "activate");
1486
1487         item = gtk_menu_item_new();
1488         gtk_widget_show(item);
1489         gtk_menu_append(GTK_MENU(menu), item);
1490
1491         l = l->next;
1492         if (l == NULL) {
1493                 item = gtk_menu_item_new_with_label(_("(no suggestions)"));
1494                 gtk_widget_show(item);
1495                 gtk_menu_append(GTK_MENU(menu), item);
1496         } else {
1497                 GtkWidget *curmenu = menu;
1498                 gint count = 0;
1499
1500                 do {
1501                         if (l->data == NULL && l->next != NULL) {
1502                                 count = 0;
1503                                 curmenu = gtk_menu_new();
1504                                 item = gtk_menu_item_new_with_label(_("Others..."));
1505                                 gtk_widget_show(item);
1506                                 gtk_menu_append(GTK_MENU(curmenu), item);
1507                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1508
1509                                 l = l->next;
1510                         } else if (count > MENUCOUNT) {
1511                                 count -= MENUCOUNT;
1512                                 item = gtk_menu_item_new_with_label(_("More..."));
1513                                 gtk_widget_show(item);
1514                                 gtk_menu_append(GTK_MENU(curmenu), item);
1515                                 curmenu = gtk_menu_new();
1516                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1517                         }
1518                         item = gtk_menu_item_new_with_label((unsigned char*)l->data);
1519                         gtk_widget_show(item);
1520                         gtk_menu_append(GTK_MENU(curmenu), item);
1521                         gtk_signal_connect(GTK_OBJECT(item), "activate",
1522                                            GTK_SIGNAL_FUNC(replace_word), gtkpspell);
1523                         if (count <= MENUCOUNT) {
1524                                 gtk_accel_group_add(accel, 'a' + count, 0,
1525                                         GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE,
1526                                         GTK_OBJECT(item), "activate");
1527                                 gtk_accel_group_add(accel, 'a' + count,
1528                                         GDK_MOD1_MASK, GTK_ACCEL_LOCKED,
1529                                         GTK_OBJECT(item), "activate");
1530                                 }
1531
1532
1533                         count++;
1534                 } while ((l = l->next) != NULL);
1535         }
1536
1537         gtk_accel_group_attach(accel, GTK_OBJECT(menu));
1538
1539         return GTK_MENU(menu);
1540 }
1541
1542 static GtkMenu *make_config_menu(GtkPspell *gtkpspell)
1543 {
1544         GtkWidget *menu, *item, *submenu;
1545         gint ispell = gtkpspell->gtkpspeller->ispell;
1546
1547         menu = gtk_menu_new();
1548
1549         item = gtk_menu_item_new_with_label(_("Spell check all"));
1550         gtk_signal_connect(GTK_OBJECT(item),"activate",
1551                            GTK_SIGNAL_FUNC(check_all_cb),
1552                            gtkpspell);
1553         gtk_widget_show(item);
1554         gtk_menu_append(GTK_MENU(menu), item);
1555
1556
1557         item = gtk_menu_item_new();
1558         gtk_widget_show(item);
1559         gtk_menu_append(GTK_MENU(menu),item);
1560
1561         submenu = gtk_menu_new();
1562         item = gtk_menu_item_new_with_label(_("Change dictionary"));
1563         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
1564         gtk_widget_show(item);
1565         gtk_menu_append(GTK_MENU(menu), item);
1566
1567         /* Dict list */
1568         if (gtkpspellcheckers->dictionary_list == NULL)
1569                 gtkpspell_get_dictionary_list(prefs_common.pspell_path, FALSE);
1570         {
1571                 GtkWidget * curmenu = submenu;
1572                 int count = 0;
1573                 Dictionary *dict;
1574                 GSList *tmp;
1575                 tmp = gtkpspellcheckers->dictionary_list;
1576
1577                 for (tmp = gtkpspellcheckers->dictionary_list; tmp != NULL;
1578                                 tmp = g_slist_next(tmp)) {
1579                         dict = (Dictionary *) tmp->data;
1580                         item = gtk_check_menu_item_new_with_label(dict->dictname);
1581                         gtk_object_set_data(GTK_OBJECT(item), "dict_name", dict);
1582                         if (strcmp2(dict->fullname, gtkpspell->gtkpspeller->dictionary->fullname))
1583                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
1584                         else {
1585                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1586                                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1587                         }
1588                         gtk_signal_connect(GTK_OBJECT(item), "activate",
1589                                            GTK_SIGNAL_FUNC(change_dict_cb),
1590                                            gtkpspell);
1591                         gtk_widget_show(item);
1592                         gtk_menu_append(GTK_MENU(curmenu), item);
1593
1594                         count++;
1595
1596                         if (count == MENUCOUNT) {
1597                                 GtkWidget *newmenu;
1598
1599                                 newmenu = gtk_menu_new();
1600                                 item = gtk_menu_item_new_with_label(_("More..."));
1601                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
1602                                                           newmenu);
1603
1604                                 gtk_menu_append(GTK_MENU(curmenu), item);
1605                                 gtk_widget_show(item);
1606                                 curmenu = newmenu;
1607                                 count = 0;
1608                         }
1609                 }
1610         }
1611
1612         item = gtk_menu_item_new();
1613         gtk_widget_show(item);
1614         gtk_menu_append(GTK_MENU(menu), item);
1615
1616         item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
1617         if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE)
1618                 gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
1619         if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE)
1620                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
1621         else
1622                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1623                                 GTK_SIGNAL_FUNC(set_sug_mode_cb),
1624                                 gtkpspell);
1625         gtk_widget_show(item);
1626         gtk_menu_append(GTK_MENU(menu), item);
1627
1628         item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
1629         if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE)
1630                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1631         if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE)
1632                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1633         else
1634                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1635                                 GTK_SIGNAL_FUNC(set_sug_mode_cb),
1636                                 gtkpspell);
1637         gtk_widget_show(item);
1638         gtk_menu_append(GTK_MENU(menu),item);
1639
1640         item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
1641         if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE)
1642                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1643         if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE)
1644                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1645         else
1646                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1647                                 GTK_SIGNAL_FUNC(set_sug_mode_cb),
1648                                 gtkpspell);
1649         gtk_widget_show(item);
1650         gtk_menu_append(GTK_MENU(menu), item);
1651
1652         return GTK_MENU(menu);
1653 }
1654
1655 static void set_menu_pos(GtkMenu *menu, gint *x, gint *y, gpointer data)
1656 {
1657         GtkPspell       *gtkpspell = (GtkPspell *) data;
1658         gint             xx = 0, yy = 0;
1659         gint             sx,     sy;
1660         gint             wx,     wy;
1661         GtkSText        *text = GTK_STEXT(gtkpspell->gtktext);
1662         GtkRequisition   r;
1663
1664         gdk_window_get_origin(GTK_WIDGET(gtkpspell->gtktext)->window, &xx, &yy);
1665
1666         sx = gdk_screen_width();
1667         sy = gdk_screen_height();
1668
1669         gtk_widget_get_child_requisition(GTK_WIDGET(menu), &r);
1670
1671         wx =  r.width;
1672         wy =  r.height;
1673
1674         *x = gtkpspell->gtktext->cursor_pos_x + xx +
1675              gdk_char_width(GTK_WIDGET(text)->style->font, ' ');
1676         *y = gtkpspell->gtktext->cursor_pos_y + yy;
1677
1678         if (*x + wx > sx)
1679                 *x = sx - wx;
1680         if (*y + wy > sy)
1681                 *y = *y - wy -
1682                      gdk_string_height((GTK_WIDGET(gtkpspell->gtktext))->style->font,
1683                                        gtkpspell->theword);
1684
1685 }
1686
1687 /*************************************************************************/
1688 /* Menu call backs */
1689
1690 static gboolean deactivate_menu_cb(GtkWidget *w, gpointer *data)
1691 {
1692         GtkPspell *gtkpspell = (GtkPspell *) data;
1693         GtkSText *gtktext;
1694         gtktext = gtkpspell->gtktext;
1695
1696         gtk_stext_thaw(gtktext);
1697         gtk_stext_freeze(gtktext);
1698         gtk_editable_set_position(GTK_EDITABLE(gtktext),gtkpspell->orig_pos);
1699         gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
1700         gtk_stext_thaw(gtktext);
1701
1702         return TRUE;
1703 }
1704
1705 /* change_dict_cb() - Menu callback : change dict */
1706 static void change_dict_cb(GtkWidget *w, GtkPspell *gtkpspell)
1707 {
1708         Dictionary      *dict, *dict2;
1709         GtkPspeller     *gtkpspeller;
1710         gint             sug_mode;
1711
1712         /* Dict is simply the menu label */
1713
1714         dict = (Dictionary *) gtk_object_get_data(GTK_OBJECT(w), "dict_name");
1715
1716         if (!strcmp2(dict->fullname, _("None")))
1717                         return;
1718
1719         sug_mode  = gtkpspell->default_sug_mode;
1720
1721         dict2 = dictionary_dup(dict);
1722         if (dict2->encoding)
1723                 g_free(dict2->encoding);
1724         dict2->encoding = g_strdup(gtkpspell->gtkpspeller->dictionary->encoding);
1725
1726         gtkpspeller = gtkpspeller_new(dict2);
1727
1728         if (!gtkpspeller) {
1729                 gchar *message;
1730                 message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s\n"),
1731                                           gtkpspellcheckers->error_message);
1732
1733                 gtkpspell_alert_dialog(message);
1734                 g_free(message);
1735         } else {
1736                 gtkpspeller_delete(gtkpspell->gtkpspeller);
1737                 gtkpspell->gtkpspeller = gtkpspeller;
1738                 gtkpspell_set_sug_mode(gtkpspell, sug_mode);
1739         }
1740
1741         dictionary_delete(dict2);
1742 }
1743
1744 /******************************************************************************/
1745 /* Misc. helper functions */
1746
1747 static void allocate_color(GtkPspell *gtkpspell)
1748 {
1749         GdkColormap *gc;
1750         GdkColor *color = &(gtkpspell->highlight);
1751         gint rgbvalue   = prefs_common.misspelled_col;
1752
1753         gc = gtk_widget_get_colormap(GTK_WIDGET(gtkpspell->gtktext));
1754
1755         if (gtkpspell->highlight.pixel)
1756                 gdk_colormap_free_colors(gc, &(gtkpspell->highlight), 1);
1757
1758         /* Shameless copy from Sylpheed gtkutils.c */
1759         color->pixel = 0L;
1760         color->red   = (int) (((gdouble)((rgbvalue & 0xff0000) >> 16) / 255.0) * 65535.0);
1761         color->green = (int) (((gdouble)((rgbvalue & 0x00ff00) >>  8) / 255.0) * 65535.0);
1762         color->blue  = (int) (((gdouble) (rgbvalue & 0x0000ff)        / 255.0) * 65535.0);
1763
1764         gdk_colormap_alloc_color(gc, &(gtkpspell->highlight), FALSE, TRUE);
1765 }
1766
1767 static void change_color(GtkPspell * gtkpspell,
1768                          int start, int end,
1769                          GdkColor *color)
1770 {
1771         char     *newtext;
1772         GtkSText *gtktext;
1773
1774         g_return_if_fail(start < end);
1775
1776         gtktext = gtkpspell->gtktext;
1777
1778         gtk_stext_freeze(gtktext);
1779         newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end);
1780         if (newtext) {
1781                 gtk_stext_set_point(gtktext, start);
1782                 gtk_stext_forward_delete(gtktext, end - start);
1783
1784                 gtk_stext_insert(gtktext, NULL, color, NULL, newtext, end - start);
1785                 g_free(newtext);
1786         }
1787         gtk_stext_thaw(gtktext);
1788 }
1789
1790 /* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-*
1791  * as needed by pspell. Returns an allocated string.
1792  */
1793
1794 static guchar *convert_to_pspell_encoding (const guchar *encoding)
1795 {
1796         guchar * pspell_encoding;
1797
1798         if (strstr2(encoding, "ISO-8859-")) {
1799                 pspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
1800         }
1801         else
1802                 if (!strcmp2(encoding, "US-ASCII"))
1803                         pspell_encoding = g_strdup("iso8859-1");
1804                 else
1805                         pspell_encoding = g_strdup(encoding);
1806
1807         return pspell_encoding;
1808 }
1809
1810 /* compare_dict () - compare 2 dict names */
1811 static gint compare_dict(Dictionary *a, Dictionary *b)
1812 {
1813         guint   aparts = 0,  bparts = 0;
1814         guint   i;
1815
1816         for (i=0; i < strlen(a->dictname); i++)
1817                 if (a->dictname[i] == '-')
1818                         aparts++;
1819         for (i=0; i < strlen(b->dictname); i++)
1820                 if (b->dictname[i] == '-')
1821                         bparts++;
1822
1823         if (aparts != bparts)
1824                 return (aparts < bparts) ? -1 : +1;
1825         else {
1826                 gint compare;
1827                 compare = strcmp2(a->dictname, b->dictname);
1828                 if (!compare)
1829                         compare = strcmp2(a->fullname, b->fullname);
1830                 return compare;
1831         }
1832 }
1833
1834
1835 static void dictionary_delete(Dictionary *dict)
1836 {
1837         g_free(dict->fullname);
1838         g_free(dict->encoding);
1839         g_free(dict);
1840 }
1841
1842 static Dictionary *dictionary_dup(const Dictionary *dict)
1843 {
1844         Dictionary *dict2;
1845
1846         dict2 = g_new(Dictionary, 1);
1847
1848         dict2->fullname = g_strdup(dict->fullname);
1849         dict2->dictname = dict->dictname - dict->fullname + dict2->fullname;
1850         dict2->encoding = g_strdup(dict->encoding);
1851
1852         return dict2;
1853 }
1854
1855 static void free_suggestions_list(GtkPspell *gtkpspell)
1856 {
1857         GList *list;
1858
1859         for (list = gtkpspell->suggestions_list; list != NULL; list = list->next)
1860                 g_free(list->data);
1861         g_list_free(list);
1862
1863         gtkpspell->max_sug          = -1;
1864         gtkpspell->suggestions_list = NULL;
1865
1866 }
1867
1868 static void reset_theword_data(GtkPspell *gtkpspell)
1869 {
1870         gtkpspell->start_pos     =  0;
1871         gtkpspell->end_pos       =  0;
1872         gtkpspell->theword[0]    =  0;
1873         gtkpspell->max_sug       = -1;
1874         gtkpspell->newword[0]    =  0;
1875
1876         free_suggestions_list(gtkpspell);
1877 }
1878
1879 static void free_checkers(gpointer elt, gpointer data)
1880 {
1881         GtkPspeller *gtkpspeller = elt;
1882
1883         g_return_if_fail(gtkpspeller);
1884
1885         gtkpspeller_delete(gtkpspeller);
1886 }
1887
1888 static gint find_gtkpspeller(gconstpointer aa, gconstpointer bb)
1889 {
1890         Dictionary *a = ((GtkPspeller *) aa)->dictionary;
1891         Dictionary *b = ((GtkPspeller *) bb)->dictionary;
1892
1893         if (!a || !b)
1894                 return 1;
1895
1896         if (strcmp(a->fullname, b->fullname) == 0
1897             && a->encoding && b->encoding)
1898                 return strcmp(a->encoding, b->encoding);
1899
1900         return 1;
1901 }
1902
1903 static void gtkpspell_alert_dialog(gchar *message)
1904 {
1905         GtkWidget *dialog;
1906         GtkWidget *label;
1907         GtkWidget *ok_button;
1908
1909         dialog = gtk_dialog_new();
1910         label  = gtk_label_new(message);
1911         ok_button = gtk_button_new_with_label(_("OK"));
1912
1913         gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
1914         gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_MOUSE);
1915         GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
1916         gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
1917                                    GTK_SIGNAL_FUNC(gtk_widget_destroy),
1918                                    GTK_OBJECT(dialog));
1919
1920         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), ok_button);
1921
1922         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
1923         gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), 8);
1924         gtk_widget_grab_default(ok_button);
1925         gtk_widget_grab_focus(ok_button);
1926         gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
1927         gtk_widget_show_all(dialog);
1928 }
1929 #endif