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_stext_thaw(gtkpspell->gtktext);
1100         gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
1101 }
1102
1103 /* add_word_to_personal() - add word to personal dict. */
1104 static void add_word_to_personal(GtkWidget *w, GtkPspell *gtkpspell)
1105 {
1106         GtkSText *gtktext;
1107
1108         gtktext = gtkpspell->gtktext;
1109
1110         gtk_stext_freeze(GTK_STEXT(gtktext));
1111
1112         pspell_manager_add_to_personal(gtkpspell->gtkpspeller->checker,gtkpspell->theword, strlen(gtkpspell->theword));
1113
1114         check_at(gtkpspell, gtkpspell->start_pos);
1115
1116         gtk_stext_thaw(gtkpspell->gtktext);
1117         gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
1118 }
1119
1120 void gtkpspell_uncheck_all(GtkPspell * gtkpspell)
1121 {
1122         int origpos;
1123         unsigned char *text;
1124         float adj_value;
1125         GtkSText *gtktext;
1126
1127         gtktext=gtkpspell->gtktext;
1128
1129         adj_value = gtktext->vadj->value;
1130         gtk_stext_freeze(gtktext);
1131         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1132         text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
1133         gtk_stext_set_point(gtktext, 0);
1134         gtk_stext_forward_delete(gtktext, gtk_stext_get_length(gtktext));
1135         gtk_stext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
1136         gtk_stext_thaw(gtktext);
1137
1138         g_free(text);
1139
1140         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
1141         gtk_adjustment_set_value(gtktext->vadj, adj_value);
1142 }
1143
1144 static GSList *create_empty_dictionary_list(void)
1145 {
1146         GSList *list = NULL;
1147         Dictionary *dict;
1148
1149         dict = g_new0(Dictionary, 1);/*printf("N %08x            dictionary\n", dict);*/
1150         dict->fullname = g_strdup(_("None"));/*printf("N %08x            fullname\n", dict->fullname);*/
1151         dict->dictname = dict->fullname;
1152         dict->encoding = NULL;
1153         return g_slist_append(list, dict);
1154 }
1155
1156 /* gtkpspell_get_dictionary_list() - returns list of dictionary names */
1157 GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path, gint refresh)
1158 {
1159         GSList *list;
1160         gchar *dict_path, *tmp, *prevdir;
1161         gchar tmpname[BUFSIZE];
1162         Dictionary *dict;
1163         DIR *dir;
1164         struct dirent *ent;
1165
1166         if (!gtkpspellcheckers)
1167                 gtkpspellcheckers = gtkpspell_checkers_new();
1168
1169         if (gtkpspellcheckers->dictionary_list && !refresh)
1170                 return gtkpspellcheckers->dictionary_list;
1171         else
1172                 gtkpspell_free_dictionary_list(gtkpspellcheckers->dictionary_list);
1173
1174         list = NULL;
1175
1176 #ifdef USE_THREADS
1177 #warning TODO: no directory change
1178 #endif
1179         dict_path = g_strdup(pspell_path);
1180         prevdir = g_get_current_dir();
1181         if (chdir(dict_path) <0) {
1182                 debug_print(_("Error when searching for dictionaries:\n%s\n"),
1183                                           g_strerror(errno));
1184                 g_free(prevdir);
1185                 g_free(dict_path);
1186                 gtkpspellcheckers->dictionary_list = create_empty_dictionary_list();
1187                 return gtkpspellcheckers->dictionary_list;
1188         }
1189
1190         debug_print(_("Checking for dictionaries in %s\n"), dict_path);
1191
1192         if (NULL != (dir = opendir("."))) {
1193                 while (NULL != (ent = readdir(dir))) {
1194                         /* search for pwli */
1195                         if ((NULL != (tmp = strstr2(ent->d_name, ".pwli"))) && (tmp[5] == 0x00)) {
1196                                 g_snprintf(tmpname, BUFSIZE, "%s%s", G_DIR_SEPARATOR_S, ent->d_name);
1197                                 tmpname[MIN(tmp - ent->d_name + 1, BUFSIZE-1)] = 0x00;
1198                                 dict = g_new0(Dictionary, 1);/*printf("N %08x            dictionary\n", dict);*/
1199                                 dict->fullname = g_strdup_printf("%s%s", dict_path, tmpname);/*printf("N %08x            fullname\n", dict->fullname);*/
1200                                 dict->dictname = strrchr(dict->fullname, G_DIR_SEPARATOR) + 1;
1201                                 dict->encoding = NULL;
1202                                 debug_print(_("Found dictionary %s %s\n"), dict->fullname, dict->dictname);
1203                                 list = g_slist_insert_sorted(list, dict, (GCompareFunc) compare_dict);
1204                         }
1205                 }
1206                 closedir(dir);
1207         }
1208         else {
1209                 debug_print(_("Error when searching for dictionaries.\nNo dictionary found.\n(%s)"),
1210                                           g_strerror(errno));
1211                 list = create_empty_dictionary_list();
1212         }
1213         if(list==NULL){
1214
1215                 debug_print(_("Error when searching for dictionaries.\nNo dictionary found."));
1216                 list = create_empty_dictionary_list();
1217         }
1218         chdir(prevdir);
1219         g_free(dict_path);
1220         g_free(prevdir);
1221         gtkpspellcheckers->dictionary_list = list;
1222         return list;
1223 }
1224
1225 void gtkpspell_free_dictionary_list(GSList *list)
1226 {
1227         Dictionary *dict;
1228         GSList *walk;
1229         for (walk = list; walk != NULL; walk = g_slist_next(walk))
1230                 if (walk->data) {
1231                         dict = (Dictionary *) walk->data;
1232                         dictionary_delete(dict);
1233                 }
1234         g_slist_free(list);
1235 }
1236
1237 #if 0
1238 static void dictionary_option_menu_item_data_destroy(gpointer data)
1239 {
1240         Dictionary *dict = (Dictionary *) data;
1241
1242         if (dict)
1243                 dictionary_delete(dict);
1244 }
1245 #endif
1246
1247 GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path)
1248 {
1249         GSList *dict_list, *tmp;
1250         GtkWidget *item;
1251         GtkWidget *menu;
1252         Dictionary *dict;
1253
1254         dict_list = gtkpspell_get_dictionary_list(pspell_path, TRUE);
1255         g_return_val_if_fail(dict_list, NULL);
1256
1257         menu = gtk_menu_new();
1258
1259         for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
1260                 dict = (Dictionary *) tmp->data;
1261                 item = gtk_menu_item_new_with_label(dict->dictname);
1262                 if (dict->dictname)
1263                         gtk_object_set_data(GTK_OBJECT(item), "dict_name",
1264                                          dict);
1265
1266                 gtk_menu_append(GTK_MENU(menu), item);
1267                 gtk_widget_show(item);
1268         }
1269
1270         gtk_widget_show(menu);
1271
1272         return menu;
1273 }
1274
1275 gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu)
1276 {
1277         GtkWidget *menuitem;
1278         Dictionary *result;
1279         gchar *label;
1280
1281         g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
1282         menuitem = gtk_menu_get_active(GTK_MENU(menu));
1283         result = (Dictionary *) gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name");
1284         g_return_val_if_fail(result->fullname, NULL);
1285         label = g_strdup(result->fullname);
1286         return label;
1287
1288 }
1289
1290 GtkWidget *gtkpspell_sugmode_option_menu_new(gint sugmode)
1291 {
1292         GtkWidget *menu;
1293         GtkWidget *item;
1294
1295
1296         menu = gtk_menu_new();
1297         gtk_widget_show(menu);
1298
1299         item = gtk_menu_item_new_with_label(_("Fast Mode"));
1300         gtk_widget_show(item);
1301         gtk_menu_append(GTK_MENU(menu), item);
1302         gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_FASTMODE));
1303
1304         item = gtk_menu_item_new_with_label(_("Normal Mode"));
1305         gtk_widget_show(item);
1306         gtk_menu_append(GTK_MENU(menu), item);
1307         gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_NORMALMODE));
1308
1309         item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
1310         gtk_widget_show(item);
1311         gtk_menu_append(GTK_MENU(menu), item);
1312         gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_BADSPELLERMODE));
1313
1314         return menu;
1315 }
1316
1317 void gtkpspell_sugmode_option_menu_set(GtkOptionMenu *optmenu, gint sugmode)
1318 {
1319         g_return_if_fail(GTK_IS_OPTION_MENU(optmenu));
1320
1321         g_return_if_fail(sugmode == PSPELL_FASTMODE ||
1322                          sugmode == PSPELL_NORMALMODE ||
1323                          sugmode == PSPELL_BADSPELLERMODE);
1324
1325         gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
1326 }
1327
1328 gint gtkpspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
1329 {
1330         gint sugmode;
1331         GtkWidget *item;
1332
1333         g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
1334
1335         item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
1336
1337         sugmode = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item), "sugmode"));
1338
1339         return sugmode;
1340
1341 }
1342
1343 void gtkpspell_set_primary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding)
1344 {
1345         g_return_if_fail(gtkpspell);
1346         if (gtkpspell->dict1)
1347                 dictionary_delete(gtkpspell->dict1);
1348         gtkpspell->dict1 = g_new(Dictionary, 1);
1349         gtkpspell->dict1->fullname = g_strdup(dict);
1350         gtkpspell->dict1->encoding = g_strdup(encoding);
1351 }
1352
1353 void gtkpspell_set_secondary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding)
1354 {
1355         g_return_if_fail(gtkpspell);
1356         if (gtkpspell->dict2)
1357                 dictionary_delete(gtkpspell->dict2);
1358         gtkpspell->dict2 = g_new(Dictionary, 1);
1359         gtkpspell->dict2->fullname = g_strdup(dict);
1360         gtkpspell->dict2->encoding = g_strdup(encoding);
1361 }
1362
1363 gboolean gtkpspell_use_dict(GtkPspell *gtkpspell, Dictionary *dict)
1364 {
1365         return TRUE;
1366 }
1367
1368 gboolean gtkpspell_use_dictionary(GtkPspell *gtkpspell, gchar *dictpath, gchar *encoding)
1369 {
1370         Dictionary *dict;
1371         gboolean retval;
1372
1373         g_return_val_if_fail(gtkpspell, FALSE);
1374         g_return_val_if_fail(dict, FALSE);
1375         g_return_val_if_fail(encoding, FALSE);
1376
1377         dict = g_new(Dictionary, 1);
1378
1379         dict->fullname = g_strdup(dictpath);
1380         dict->encoding = NULL; /* To be continued */
1381
1382         retval = gtkpspell_use_dict(gtkpspell, dict);
1383
1384         dictionary_delete(dict);
1385
1386         return retval;
1387
1388 }
1389
1390 gboolean gtkpspell_use_primary(GtkPspell *gtkpspell)
1391 {
1392         g_return_val_if_fail(gtkpspell, FALSE);
1393
1394         return gtkpspell_use_dict(gtkpspell, gtkpspell->dict1);
1395 }
1396
1397 gboolean gtkpspell_use_secondary(GtkPspell *gtkpspell)
1398 {
1399         g_return_val_if_fail(gtkpspell, FALSE);
1400
1401         return gtkpspell_use_dict(gtkpspell, gtkpspell->dict2);
1402 }
1403
1404 /*****************************************************************************/
1405
1406 static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb)
1407 {
1408         GtkSText * gtktext;
1409
1410         gtktext = gtkpspell->gtktext;
1411         gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1412
1413         if (!(eb->state & GDK_SHIFT_MASK)) {
1414                 if (check_at(gtkpspell, gtkpspell->orig_pos)) {
1415
1416                         gtk_editable_set_position(GTK_EDITABLE(gtktext),
1417                                                   gtkpspell->orig_pos);
1418                         gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
1419
1420                         if (misspelled_suggest(gtkpspell, gtkpspell->theword)) {
1421                                 gtk_menu_popup(make_sug_menu(gtkpspell),
1422                                                NULL, NULL, NULL, NULL,
1423                                                eb->button, eb->time);
1424
1425                                 return;
1426                         }
1427                 } else {
1428                         gtk_editable_set_position(GTK_EDITABLE(gtktext),
1429                                                   gtkpspell->orig_pos);
1430                         gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
1431                 }
1432         }
1433
1434         gtk_menu_popup(make_config_menu(gtkpspell),NULL,NULL,NULL,NULL,
1435                        eb->button,eb->time);
1436 }
1437
1438 /* make_sug_menu() - Add menus to accept this word for this session and to add it to
1439  * personal dictionary */
1440 static GtkMenu *make_sug_menu(GtkPspell *gtkpspell)
1441 {
1442         GtkWidget       *menu, *item;
1443         unsigned char   *caption;
1444         GtkSText        *gtktext;
1445         GList           *l = gtkpspell->suggestions_list;
1446         GtkAccelGroup   *accel;
1447
1448
1449         gtktext = gtkpspell->gtktext;
1450
1451         accel = gtk_accel_group_new();
1452         menu = gtk_menu_new();
1453
1454         gtk_signal_connect(GTK_OBJECT(menu), "deactivate",
1455                 GTK_SIGNAL_FUNC(deactivate_menu_cb), gtkpspell);
1456
1457         caption = g_strdup_printf(_("Unknown word: \"%s\""),
1458                                   (unsigned char*) l->data);
1459         item = gtk_menu_item_new_with_label(caption);
1460         gtk_widget_show(item);
1461         gtk_menu_append(GTK_MENU(menu), item);
1462         gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
1463         g_free(caption);
1464
1465         item = gtk_menu_item_new();
1466         gtk_widget_show(item);
1467         gtk_menu_append(GTK_MENU(menu), item);
1468
1469         item = gtk_menu_item_new_with_label(_("Accept in this session"));
1470         gtk_widget_show(item);
1471         gtk_menu_append(GTK_MENU(menu), item);
1472         gtk_signal_connect(GTK_OBJECT(item), "activate",
1473                            GTK_SIGNAL_FUNC(add_word_to_session),
1474                            gtkpspell);
1475         gtk_accel_group_add(accel, GDK_space, GDK_MOD1_MASK,
1476                             GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE,
1477                             GTK_OBJECT(item), "activate");
1478
1479         item = gtk_menu_item_new_with_label(_("Add to personal dictionary"));
1480         gtk_widget_show(item);
1481         gtk_menu_append(GTK_MENU(menu), item);
1482         gtk_signal_connect(GTK_OBJECT(item), "activate",
1483                            GTK_SIGNAL_FUNC(add_word_to_personal),
1484                            gtkpspell);
1485         gtk_accel_group_add(accel, GDK_Return, GDK_MOD1_MASK,
1486                             GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE,
1487                             GTK_OBJECT(item), "activate");
1488
1489         item = gtk_menu_item_new();
1490         gtk_widget_show(item);
1491         gtk_menu_append(GTK_MENU(menu), item);
1492
1493         l = l->next;
1494         if (l == NULL) {
1495                 item = gtk_menu_item_new_with_label(_("(no suggestions)"));
1496                 gtk_widget_show(item);
1497                 gtk_menu_append(GTK_MENU(menu), item);
1498         } else {
1499                 GtkWidget *curmenu = menu;
1500                 gint count = 0;
1501
1502                 do {
1503                         if (l->data == NULL && l->next != NULL) {
1504                                 count = 0;
1505                                 curmenu = gtk_menu_new();
1506                                 item = gtk_menu_item_new_with_label(_("Others..."));
1507                                 gtk_widget_show(item);
1508                                 gtk_menu_append(GTK_MENU(curmenu), item);
1509                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1510
1511                                 l = l->next;
1512                         } else if (count > MENUCOUNT) {
1513                                 count -= MENUCOUNT;
1514                                 item = gtk_menu_item_new_with_label(_("More..."));
1515                                 gtk_widget_show(item);
1516                                 gtk_menu_append(GTK_MENU(curmenu), item);
1517                                 curmenu = gtk_menu_new();
1518                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1519                         }
1520                         item = gtk_menu_item_new_with_label((unsigned char*)l->data);
1521                         gtk_widget_show(item);
1522                         gtk_menu_append(GTK_MENU(curmenu), item);
1523                         gtk_signal_connect(GTK_OBJECT(item), "activate",
1524                                            GTK_SIGNAL_FUNC(replace_word), gtkpspell);
1525                         if (count <= MENUCOUNT) {
1526                                 gtk_accel_group_add(accel, 'a' + count, 0,
1527                                         GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE,
1528                                         GTK_OBJECT(item), "activate");
1529                                 gtk_accel_group_add(accel, 'a' + count,
1530                                         GDK_MOD1_MASK, GTK_ACCEL_LOCKED,
1531                                         GTK_OBJECT(item), "activate");
1532                                 }
1533
1534
1535                         count++;
1536                 } while ((l = l->next) != NULL);
1537         }
1538
1539         gtk_accel_group_attach(accel, GTK_OBJECT(menu));
1540
1541         return GTK_MENU(menu);
1542 }
1543
1544 static GtkMenu *make_config_menu(GtkPspell *gtkpspell)
1545 {
1546         GtkWidget *menu, *item, *submenu;
1547         gint ispell = gtkpspell->gtkpspeller->ispell;
1548
1549         menu = gtk_menu_new();
1550
1551         item = gtk_menu_item_new_with_label(_("Spell check all"));
1552         gtk_signal_connect(GTK_OBJECT(item),"activate",
1553                            GTK_SIGNAL_FUNC(check_all_cb),
1554                            gtkpspell);
1555         gtk_widget_show(item);
1556         gtk_menu_append(GTK_MENU(menu), item);
1557
1558
1559         item = gtk_menu_item_new();
1560         gtk_widget_show(item);
1561         gtk_menu_append(GTK_MENU(menu),item);
1562
1563         submenu = gtk_menu_new();
1564         item = gtk_menu_item_new_with_label(_("Change dictionary"));
1565         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
1566         gtk_widget_show(item);
1567         gtk_menu_append(GTK_MENU(menu), item);
1568
1569         /* Dict list */
1570         if (gtkpspellcheckers->dictionary_list == NULL)
1571                 gtkpspell_get_dictionary_list(prefs_common.pspell_path, FALSE);
1572         {
1573                 GtkWidget * curmenu = submenu;
1574                 int count = 0;
1575                 Dictionary *dict;
1576                 GSList *tmp;
1577                 tmp = gtkpspellcheckers->dictionary_list;
1578
1579                 for (tmp = gtkpspellcheckers->dictionary_list; tmp != NULL;
1580                                 tmp = g_slist_next(tmp)) {
1581                         dict = (Dictionary *) tmp->data;
1582                         item = gtk_check_menu_item_new_with_label(dict->dictname);
1583                         gtk_object_set_data(GTK_OBJECT(item), "dict_name", dict);
1584                         if (strcmp2(dict->fullname, gtkpspell->gtkpspeller->dictionary->fullname))
1585                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
1586                         else {
1587                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1588                                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1589                         }
1590                         gtk_signal_connect(GTK_OBJECT(item), "activate",
1591                                            GTK_SIGNAL_FUNC(change_dict_cb),
1592                                            gtkpspell);
1593                         gtk_widget_show(item);
1594                         gtk_menu_append(GTK_MENU(curmenu), item);
1595
1596                         count++;
1597
1598                         if (count == MENUCOUNT) {
1599                                 GtkWidget *newmenu;
1600
1601                                 newmenu = gtk_menu_new();
1602                                 item = gtk_menu_item_new_with_label(_("More..."));
1603                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
1604                                                           newmenu);
1605
1606                                 gtk_menu_append(GTK_MENU(curmenu), item);
1607                                 gtk_widget_show(item);
1608                                 curmenu = newmenu;
1609                                 count = 0;
1610                         }
1611                 }
1612         }
1613
1614         item = gtk_menu_item_new();
1615         gtk_widget_show(item);
1616         gtk_menu_append(GTK_MENU(menu), item);
1617
1618         item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
1619         if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE)
1620                 gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
1621         if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE)
1622                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
1623         else
1624                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1625                                 GTK_SIGNAL_FUNC(set_sug_mode_cb),
1626                                 gtkpspell);
1627         gtk_widget_show(item);
1628         gtk_menu_append(GTK_MENU(menu), item);
1629
1630         item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
1631         if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE)
1632                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1633         if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE)
1634                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1635         else
1636                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1637                                 GTK_SIGNAL_FUNC(set_sug_mode_cb),
1638                                 gtkpspell);
1639         gtk_widget_show(item);
1640         gtk_menu_append(GTK_MENU(menu),item);
1641
1642         item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
1643         if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE)
1644                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1645         if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE)
1646                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1647         else
1648                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1649                                 GTK_SIGNAL_FUNC(set_sug_mode_cb),
1650                                 gtkpspell);
1651         gtk_widget_show(item);
1652         gtk_menu_append(GTK_MENU(menu), item);
1653
1654         return GTK_MENU(menu);
1655 }
1656
1657 static void set_menu_pos(GtkMenu *menu, gint *x, gint *y, gpointer data)
1658 {
1659         GtkPspell       *gtkpspell = (GtkPspell *) data;
1660         gint             xx = 0, yy = 0;
1661         gint             sx,     sy;
1662         gint             wx,     wy;
1663         GtkSText        *text = GTK_STEXT(gtkpspell->gtktext);
1664         GtkRequisition   r;
1665
1666         gdk_window_get_origin(GTK_WIDGET(gtkpspell->gtktext)->window, &xx, &yy);
1667
1668         sx = gdk_screen_width();
1669         sy = gdk_screen_height();
1670
1671         gtk_widget_get_child_requisition(GTK_WIDGET(menu), &r);
1672
1673         wx =  r.width;
1674         wy =  r.height;
1675
1676         *x = gtkpspell->gtktext->cursor_pos_x + xx +
1677              gdk_char_width(GTK_WIDGET(text)->style->font, ' ');
1678         *y = gtkpspell->gtktext->cursor_pos_y + yy;
1679
1680         if (*x + wx > sx)
1681                 *x = sx - wx;
1682         if (*y + wy > sy)
1683                 *y = *y - wy -
1684                      gdk_string_height((GTK_WIDGET(gtkpspell->gtktext))->style->font,
1685                                        gtkpspell->theword);
1686
1687 }
1688
1689 /*************************************************************************/
1690 /* Menu call backs */
1691
1692 static gboolean deactivate_menu_cb(GtkWidget *w, gpointer *data)
1693 {
1694         GtkPspell *gtkpspell = (GtkPspell *) data;
1695         GtkSText *gtktext;
1696         gtktext = gtkpspell->gtktext;
1697
1698         gtk_stext_freeze(gtktext);
1699         gtk_editable_set_position(GTK_EDITABLE(gtktext),gtkpspell->orig_pos);
1700         gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
1701         gtk_stext_thaw(gtktext);
1702
1703         return FALSE;
1704 }
1705
1706 /* change_dict_cb() - Menu callback : change dict */
1707 static void change_dict_cb(GtkWidget *w, GtkPspell *gtkpspell)
1708 {
1709         Dictionary      *dict, *dict2;
1710         GtkPspeller     *gtkpspeller;
1711         gint             sug_mode;
1712
1713         /* Dict is simply the menu label */
1714
1715         dict = (Dictionary *) gtk_object_get_data(GTK_OBJECT(w), "dict_name");
1716
1717         if (!strcmp2(dict->fullname, _("None")))
1718                         return;
1719
1720         sug_mode  = gtkpspell->default_sug_mode;
1721
1722         dict2 = dictionary_dup(dict);
1723         if (dict2->encoding)
1724                 g_free(dict2->encoding);
1725         dict2->encoding = g_strdup(gtkpspell->gtkpspeller->dictionary->encoding);
1726
1727         gtkpspeller = gtkpspeller_new(dict2);
1728
1729         if (!gtkpspeller) {
1730                 gchar *message;
1731                 message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s\n"),
1732                                           gtkpspellcheckers->error_message);
1733
1734                 gtkpspell_alert_dialog(message);
1735                 g_free(message);
1736         } else {
1737                 gtkpspeller_delete(gtkpspell->gtkpspeller);
1738                 gtkpspell->gtkpspeller = gtkpspeller;
1739                 gtkpspell_set_sug_mode(gtkpspell, sug_mode);
1740         }
1741
1742         dictionary_delete(dict2);
1743 }
1744
1745 /******************************************************************************/
1746 /* Misc. helper functions */
1747
1748 static void allocate_color(GtkPspell *gtkpspell)
1749 {
1750         GdkColormap *gc;
1751         GdkColor *color = &(gtkpspell->highlight);
1752         gint rgbvalue   = prefs_common.misspelled_col;
1753
1754         gc = gtk_widget_get_colormap(GTK_WIDGET(gtkpspell->gtktext));
1755
1756         if (gtkpspell->highlight.pixel)
1757                 gdk_colormap_free_colors(gc, &(gtkpspell->highlight), 1);
1758
1759         /* Shameless copy from Sylpheed gtkutils.c */
1760         color->pixel = 0L;
1761         color->red   = (int) (((gdouble)((rgbvalue & 0xff0000) >> 16) / 255.0) * 65535.0);
1762         color->green = (int) (((gdouble)((rgbvalue & 0x00ff00) >>  8) / 255.0) * 65535.0);
1763         color->blue  = (int) (((gdouble) (rgbvalue & 0x0000ff)        / 255.0) * 65535.0);
1764
1765         gdk_colormap_alloc_color(gc, &(gtkpspell->highlight), FALSE, TRUE);
1766 }
1767
1768 static void change_color(GtkPspell * gtkpspell,
1769                          int start, int end,
1770                          GdkColor *color)
1771 {
1772         char     *newtext;
1773         GtkSText *gtktext;
1774
1775         g_return_if_fail(start < end);
1776
1777         gtktext = gtkpspell->gtktext;
1778
1779         gtk_stext_freeze(gtktext);
1780         newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end);
1781         if (newtext) {
1782                 gtk_stext_set_point(gtktext, start);
1783                 gtk_stext_forward_delete(gtktext, end - start);
1784
1785                 gtk_stext_insert(gtktext, NULL, color, NULL, newtext, end - start);
1786                 g_free(newtext);
1787         }
1788         gtk_stext_thaw(gtktext);
1789 }
1790
1791 /* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-*
1792  * as needed by pspell. Returns an allocated string.
1793  */
1794
1795 static guchar *convert_to_pspell_encoding (const guchar *encoding)
1796 {
1797         guchar * pspell_encoding;
1798
1799         if (strstr2(encoding, "ISO-8859-")) {
1800                 pspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
1801         }
1802         else
1803                 if (!strcmp2(encoding, "US-ASCII"))
1804                         pspell_encoding = g_strdup("iso8859-1");
1805                 else
1806                         pspell_encoding = g_strdup(encoding);
1807
1808         return pspell_encoding;
1809 }
1810
1811 /* compare_dict () - compare 2 dict names */
1812 static gint compare_dict(Dictionary *a, Dictionary *b)
1813 {
1814         guint   aparts = 0,  bparts = 0;
1815         guint   i;
1816
1817         for (i=0; i < strlen(a->dictname); i++)
1818                 if (a->dictname[i] == '-')
1819                         aparts++;
1820         for (i=0; i < strlen(b->dictname); i++)
1821                 if (b->dictname[i] == '-')
1822                         bparts++;
1823
1824         if (aparts != bparts)
1825                 return (aparts < bparts) ? -1 : +1;
1826         else {
1827                 gint compare;
1828                 compare = strcmp2(a->dictname, b->dictname);
1829                 if (!compare)
1830                         compare = strcmp2(a->fullname, b->fullname);
1831                 return compare;
1832         }
1833 }
1834
1835
1836 static void dictionary_delete(Dictionary *dict)
1837 {
1838         g_free(dict->fullname);
1839         g_free(dict->encoding);
1840         g_free(dict);
1841 }
1842
1843 static Dictionary *dictionary_dup(const Dictionary *dict)
1844 {
1845         Dictionary *dict2;
1846
1847         dict2 = g_new(Dictionary, 1);
1848
1849         dict2->fullname = g_strdup(dict->fullname);
1850         dict2->dictname = dict->dictname - dict->fullname + dict2->fullname;
1851         dict2->encoding = g_strdup(dict->encoding);
1852
1853         return dict2;
1854 }
1855
1856 static void free_suggestions_list(GtkPspell *gtkpspell)
1857 {
1858         GList *list;
1859
1860         for (list = gtkpspell->suggestions_list; list != NULL; list = list->next)
1861                 g_free(list->data);
1862         g_list_free(list);
1863
1864         gtkpspell->max_sug          = -1;
1865         gtkpspell->suggestions_list = NULL;
1866
1867 }
1868
1869 static void reset_theword_data(GtkPspell *gtkpspell)
1870 {
1871         gtkpspell->start_pos     =  0;
1872         gtkpspell->end_pos       =  0;
1873         gtkpspell->theword[0]    =  0;
1874         gtkpspell->max_sug       = -1;
1875         gtkpspell->newword[0]    =  0;
1876
1877         free_suggestions_list(gtkpspell);
1878 }
1879
1880 static void free_checkers(gpointer elt, gpointer data)
1881 {
1882         GtkPspeller *gtkpspeller = elt;
1883
1884         g_return_if_fail(gtkpspeller);
1885
1886         gtkpspeller_delete(gtkpspeller);
1887 }
1888
1889 static gint find_gtkpspeller(gconstpointer aa, gconstpointer bb)
1890 {
1891         Dictionary *a = ((GtkPspeller *) aa)->dictionary;
1892         Dictionary *b = ((GtkPspeller *) bb)->dictionary;
1893
1894         if (!a || !b)
1895                 return 1;
1896
1897         if (strcmp(a->fullname, b->fullname) == 0
1898             && a->encoding && b->encoding)
1899                 return strcmp(a->encoding, b->encoding);
1900
1901         return 1;
1902 }
1903
1904 static void gtkpspell_alert_dialog(gchar *message)
1905 {
1906         GtkWidget *dialog;
1907         GtkWidget *label;
1908         GtkWidget *ok_button;
1909
1910         dialog = gtk_dialog_new();
1911         label  = gtk_label_new(message);
1912         ok_button = gtk_button_new_with_label(_("OK"));
1913
1914         gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
1915         gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_MOUSE);
1916         GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
1917         gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
1918                                    GTK_SIGNAL_FUNC(gtk_widget_destroy),
1919                                    GTK_OBJECT(dialog));
1920
1921         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), ok_button);
1922
1923         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
1924         gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), 8);
1925         gtk_widget_grab_default(ok_button);
1926         gtk_widget_grab_focus(ok_button);
1927         gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
1928         gtk_widget_show_all(dialog);
1929 }
1930 #endif