src/gtkspell.c

   1 /* gtkspell - a spell-checking addon for GtkText
   2  * Copyright (c) 2000 Evan Martin.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  17  */
  18 /*
  19     Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
  20  */
  21
  22 /*
  23  * Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto &
  24  * The Sylpheed Claws Team.
  25  */
  26
  27 #if defined(HAVE_CONFIG_H)
  28 #include "config.h"
  29 #endif
  30
  31 #include "intl.h"
  32
  33 #include <gtk/gtk.h>
  34 #include <sys/types.h>
  35 #include <sys/wait.h>
  36 #include <unistd.h>
  37 #include <stdio.h>
  38 #include <signal.h>
  39 #include <ctype.h>
  40 #include <string.h>
  41 #include <stdlib.h>
  42 #include <errno.h>
  43 #include <stdio.h>
  44 #include <sys/time.h>
  45 #include <fcntl.h>
  46 #include <time.h>
  47 #include <prefs_common.h>
  48 #include <utils.h>
  49
  50 #include "gtkxtext.h"
  51
  52 /* size of the text buffer used in various word-processing routines. */
  53 #define BUFSIZE 1024
  54
  55 /* number of suggestions to display on each menu. */
  56 #define MENUCOUNT 15
  57
  58 /* because we keep only one copy of the spell program running,
  59  * all ispell-related variables can be static.
  60  */
  61 volatile pid_t spell_pid = -1;
  62 static int sp_fd_write[2], sp_fd_read[2];
  63 static int signal_set_up = 0;
  64
  65 static GdkColor highlight = { 0, 255 * 256, 0, 0 };
  66
  67 static void entry_insert_cb(GtkXText *gtktext,
  68                             gchar *newtext, guint len, guint *ppos, gpointer d);
  69 static void set_up_signal();
  70
  71 int gtkspell_running()
  72 {
  73     return (spell_pid > 0);
  74 }
  75
  76 /* functions to interface with pipe */
  77 static void writetext(unsigned char *text_ccc)
  78 {
  79     write(sp_fd_write[1], text_ccc, strlen(text_ccc));
  80 }
  81
  82 static int readpipe(unsigned char *buf, int bufsize)
  83 {
  84     int len;
  85     len = read(sp_fd_read[0], buf, bufsize - 1);
  86     if (len < 0) {
  87         debug_print(_("*** readpipe: read: %s\n"), strerror(errno));
  88         return -1;
  89     } else if (len == 0) {
  90         debug_print(_("*** readpipe: pipe closed.\n"));
  91         return -1;
  92     } else if (len == bufsize - 1) {
  93         debug_print(_("*** readpipe: buffer overflowed?\n"));
  94     }
  95
  96     buf[len] = 0;
  97     return len;
  98 }
  99
 100 static int readline(unsigned char *buf)
 101 {
 102     return readpipe(buf, BUFSIZE);
 103 }
 104
 105 static int readresponse(unsigned char *buf)
 106 {
 107     int len;
 108     len = readpipe(buf, BUFSIZE);
 109
 110     /* all ispell responses of any reasonable length should end in \n\n.
 111      * depending on the speed of the spell checker, this may require more
 112      * reading. */
 113     if (len >= 2 && (buf[len - 1] != '\n' || buf[len - 2] != '\n')) {
 114         len += readpipe(buf + len, BUFSIZE - len);
 115     }
 116
 117     /* now we can remove all of the the trailing newlines. */
 118     while (len > 0 && buf[len - 1] == '\n')
 119         buf[--len] = 0;
 120
 121     return len;
 122 }
 123
 124 void gtkspell_stop()
 125 {
 126     if (gtkspell_running()) {
 127         kill(spell_pid, SIGTERM);
 128         debug_print(_("*** Kill pid[%i] returned: %s\n"), spell_pid, strerror(errno));
 129         while (spell_pid != -1);
 130     }
 131 }
 132
 133 static int poller(int buffer)
 134 {
 135     int len;
 136     fd_set rfds;
 137     struct timeval tv;
 138     int retval;
 139
 140     FD_ZERO(&rfds);
 141     FD_SET(buffer, &rfds);
 142     memset(&tv, 0, sizeof(tv));
 143     tv.tv_sec = 2;
 144     tv.tv_usec = 0;
 145     return select(buffer + 1, &rfds, NULL, NULL, &tv);
 146 }
 147
 148 int gtkspell_start(unsigned char *path, char * args[])
 149 {
 150     int fd_error[2];
 151     FILE *sav_stdin, *sav_stdout, *sav_stderr;
 152     char buf[BUFSIZE];
 153     int retncode;
 154
 155     if (gtkspell_running()) {
 156         debug_print(_("*** gtkspell_start called while already running.\n"));
 157         gtkspell_stop();
 158     }
 159
 160     if (!signal_set_up) {
 161         set_up_signal();
 162         signal_set_up = 1;
 163     }
 164
 165     pipe(sp_fd_write);
 166     pipe(sp_fd_read);
 167     pipe(fd_error);
 168
 169     spell_pid = fork();
 170     if (spell_pid < 0) {
 171         debug_print(_("*** fork: %s\n"), strerror(errno));
 172         return -1;
 173     } else if (spell_pid == 0) {
 174         sav_stdin = fdopen(dup(fileno(stdin)), "r");
 175         sav_stdout = fdopen(dup(fileno(stdout)), "w");
 176         sav_stderr = fdopen(dup(fileno(stderr)), "w");
 177         dup2(sp_fd_write[0], 0);
 178         dup2(sp_fd_read[1], 1);
 179         dup2(fd_error[1], 2);
 180         close(sp_fd_read[0]);
 181         close(fd_error[0]);
 182         close(sp_fd_write[1]);
 183
 184         if (path == NULL) {
 185             if (execvp(args[0], args) < 0)
 186                 //DONT call debug_print here, because stdout is closed at this moment
 187                 fprintf(sav_stderr, _("*** execvp('%s'): %s\n"), args[0], strerror(errno));
 188         } else {
 189             if (execv(path, args) < 0)
 190                 //DONT call debug_print here, because stdout is closed at this moment
 191                 fprintf(sav_stderr, _("*** execv('%s'): %s\n"), path, strerror(errno));
 192         }
 193         /* if we get here, we failed.
 194          * send some text on the pipe to indicate status.
 195          */
 196         write(sp_fd_read[1], "!", 1);
 197
 198         _exit(0);
 199     } else {
 200         retncode = poller(sp_fd_read[1]);
 201         if (retncode < 0) {
 202             debug_print(_("*** Spell comand failed: %s.\n"), strerror(errno));
 203             gtkspell_stop();
 204             return -1;
 205         }
 206         readline(buf);
 207         /* ispell should print something like this:
 208          * @(#) International Ispell Version 3.1.20 10/10/95
 209          * if it doesn't, it's an error. */
 210         if (buf[0] != '@') {
 211             debug_print(_("*** ispell didnt print '@'\n"));
 212             gtkspell_stop();
 213             return -1;
 214         }
 215     }
 216
 217     /* put ispell into terse mode.
 218      * this makes it not respond on correctly spelled words. */
 219     sprintf(buf, "!\n");
 220     writetext(buf);
 221     return 0;
 222 }
 223
 224 static GList* misspelled_suggest(unsigned char *word)
 225 {
 226     unsigned char buf[BUFSIZE];
 227     unsigned char *newword;
 228     GList *l = NULL;
 229     int count;
 230     sprintf(buf, "^%s\n", word);  /* guard against ispell control chars */
 231     writetext(buf);
 232     readresponse(buf);
 233     switch (buf[0]) { /* first char is ispell command. */
 234     case 0:  /* no response: word is ok. */
 235         return NULL;
 236     case 10:  /* just enter word is ok.  */
 237         return NULL;
 238     case '&':  /* misspelled, with suggestions */
 239         /* & <orig> <count> <ofs>: <miss>, <miss>, <guess>, ... */
 240         strtok(buf, " ");  /* & */
 241         newword = strtok(NULL, " ");  /* orig */
 242         l = g_list_append(l, g_strdup(newword));
 243         newword = strtok(NULL, " ");  /* count */
 244         count = atoi(newword);
 245         strtok(NULL, " ");  /* ofs: */
 246
 247         while ((newword = strtok(NULL, ",")) != NULL) {
 248             int len = strlen(newword);
 249             if (newword[len - 1] == ' ' || newword[len - 1] == '\n')
 250                 newword[len - 1] = 0;
 251             if (count == 0) {
 252                 g_list_append(l, NULL);  /* signal the "suggestions" */
 253             }
 254             /* add it to the list, skipping the initial space. */
 255             l = g_list_append(l,
 256                               g_strdup(newword[0] == ' ' ? newword + 1 : newword));
 257
 258             count--;
 259         }
 260         return l;
 261     case '?':  /* ispell is guessing. */
 262     case '#':  /* misspelled, no suggestions */
 263         /* # <orig> <ofs> */
 264         strtok(buf, " ");  /* & */
 265         newword = strtok(NULL, " ");  /* orig */
 266         l = g_list_append(l, g_strdup(newword));
 267         return l;
 268     default:
 269         debug_print(_("*** Unsupported spell command '%c'.\n"), buf[0]);
 270     }
 271     return NULL;
 272 }
 273
 274 static int misspelled_test(unsigned char *word)
 275 {
 276     unsigned char buf[BUFSIZE];
 277     sprintf(buf, "^%s\n", word);  /* guard against ispell control chars */
 278     writetext(buf);
 279     readresponse(buf);
 280
 281     if (buf[0] == 0) {
 282         return 0;
 283     } else if (buf[0] == '&' || buf[0] == '#' || buf[0] == '?') {
 284         return 1;
 285     }
 286
 287     debug_print(_("*** Unsupported spell command '%c'.\n"), buf[0]);
 288
 289     return -1;
 290 }
 291
 292 static gboolean iswordsep(unsigned char c)
 293 {
 294     return !isalpha(c) && c != '\'';
 295 }
 296
 297 static guchar get_text_index_whar(GtkXText *gtktext, int pos)
 298 {
 299     guchar a;
 300     gchar *text;
 301     text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), pos, pos + 1);
 302     if (text == NULL) return 0;
 303     a = (guchar) * text;
 304     g_free(text);
 305     return a;
 306 }
 307
 308 static gboolean get_word_from_pos(GtkXText *gtktext, int pos, unsigned char* buf,
 309                                   int *pstart, int *pend)
 310 {
 311     gint start, end;
 312     if (iswordsep(get_text_index_whar(gtktext, pos))) return FALSE;
 313
 314     for (start = pos; start >= 0; --start) {
 315         if (iswordsep(get_text_index_whar(gtktext, start))) break;
 316     }
 317     start++;
 318
 319     for (end = pos; end < gtk_xtext_get_length(gtktext); end++) {
 320         if (iswordsep(get_text_index_whar(gtktext, end))) break;
 321     }
 322
 323     if (buf) {
 324         for (pos = start; pos < end; pos++) buf[pos - start] = get_text_index_whar(gtktext, pos);
 325         buf[pos - start] = 0;
 326     }
 327
 328     if (pstart) *pstart = start;
 329     if (pend) *pend = end;
 330
 331     return TRUE;
 332 }
 333
 334 static gboolean get_curword(GtkXText *gtktext, unsigned char* buf,
 335                             int *pstart, int *pend)
 336 {
 337     int pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 338     return get_word_from_pos(gtktext, pos, buf, pstart, pend);
 339 }
 340
 341 static void change_color(GtkXText *gtktext, int start, int end, GdkColor *color)
 342 {
 343     char *newtext;
 344     if (start >= end) {
 345         return ;
 346     };
 347     gtk_xtext_freeze(gtktext);
 348     newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end);
 349 //    if (prefs_common.auto_makeispell) {
 350         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
 351                                          GTK_SIGNAL_FUNC(entry_insert_cb), NULL);
 352 //    }
 353     gtk_xtext_set_point(gtktext, start);
 354     gtk_xtext_forward_delete(gtktext, end - start);
 355
 356     if (newtext && end - start > 0)
 357         gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start);
 358   //  if (prefs_common.auto_makeispell) {
 359         gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
 360                                            GTK_SIGNAL_FUNC(entry_insert_cb), NULL);
 361    // }
 362     gtk_xtext_thaw(gtktext);
 363 }
 364
 365 static gboolean check_at(GtkXText *gtktext, int from_pos)
 366 {
 367     int start, end;
 368     unsigned char buf[BUFSIZE];
 369     if (from_pos < 0) return FALSE;
 370     if (!get_word_from_pos(gtktext, from_pos, buf, &start, &end)) {
 371         return FALSE;
 372     };
 373     if (misspelled_test(buf)) {
 374         if (highlight.pixel == 0) {
 375             /* add an entry for the highlight in the color map. */
 376             GdkColormap *gc = gtk_widget_get_colormap(GTK_WIDGET(gtktext));
 377             gdk_colormap_alloc_color(gc, &highlight, FALSE, TRUE);
 378             ;
 379         }
 380         change_color(gtktext, start, end, &highlight);
 381         return TRUE;
 382     } else {
 383         change_color(gtktext, start, end,
 384                      &(GTK_WIDGET(gtktext)->style->fg[0]));
 385         return FALSE;
 386     }
 387 }
 388
 389 void gtkspell_check_all(GtkXText *gtktext)
 390 {
 391     guint origpos;
 392     guint pos = 0;
 393     guint len;
 394     float adj_value;
 395
 396     if (!gtkspell_running()) return ;
 397
 398     len = gtk_xtext_get_length(gtktext);
 399
 400     adj_value = gtktext->vadj->value;
 401     gtk_xtext_freeze(gtktext);
 402     origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 403     while (pos < len) {
 404         while (pos < len && iswordsep(get_text_index_whar(gtktext, pos)))
 405             pos++;
 406         while (pos < len && !iswordsep(get_text_index_whar(gtktext, pos)))
 407             pos++;
 408         if (pos > 0)
 409             check_at(gtktext, pos - 1);
 410     }
 411     gtk_xtext_thaw(gtktext);
 412     gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
 413     gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
 414
 415 }
 416
 417 static void entry_insert_cb(GtkXText *gtktext,
 418                             gchar *newtext, guint len, guint *ppos, gpointer d)
 419 {
 420     int origpos;
 421     if (!gtkspell_running()) return ;
 422
 423     gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
 424                                      GTK_SIGNAL_FUNC(entry_insert_cb),
 425                                      NULL);
 426     gtk_xtext_insert(GTK_XTEXT(gtktext), NULL,
 427                     &(GTK_WIDGET(gtktext)->style->fg[0]), NULL, newtext, len);
 428
 429     gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
 430                                        GTK_SIGNAL_FUNC(entry_insert_cb),
 431                                        NULL);
 432     gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "insert-text");
 433     *ppos += len;
 434     origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 435
 436     if (iswordsep(newtext[0])) {
 437         /* did we just end a word? */
 438         if (*ppos >= 2) check_at(gtktext, *ppos - 2);
 439
 440         /* did we just split a word? */
 441         if (*ppos < gtk_xtext_get_length(gtktext))
 442             check_at(gtktext, *ppos + 1);
 443     } else {
 444         /* check as they type, *except* if they're typing at the end (the most
 445          * common case.
 446          */
 447         if (*ppos < gtk_xtext_get_length(gtktext) &&
 448                 !iswordsep(get_text_index_whar(gtktext, *ppos)))
 449             check_at(gtktext, *ppos - 1);
 450     }
 451
 452     gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
 453 }
 454
 455 static void entry_delete_cb(GtkXText *gtktext,
 456                             gint start, gint end, gpointer d)
 457 {
 458     int origpos;
 459     if (!gtkspell_running()) return ;
 460
 461     origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 462     check_at(gtktext, start - 1);
 463     gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
 464     gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
 465     /* this is to *UNDO* the selection, in case they were holding shift
 466      * while hitting backspace. */
 467 }
 468
 469 static void replace_word(GtkWidget *w, gpointer d)
 470 {
 471     int start, end;
 472     unsigned char *newword;
 473     unsigned char buf[BUFSIZE];
 474     gtk_xtext_freeze(GTK_XTEXT(d));
 475
 476     gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
 477     get_curword(GTK_XTEXT(d), buf, &start, &end);
 478
 479     gtk_xtext_set_point(GTK_XTEXT(d), end);
 480     gtk_xtext_backward_delete(GTK_XTEXT(d), end - start);
 481     gtk_xtext_insert(GTK_XTEXT(d), NULL, NULL, NULL, newword, strlen(newword));
 482
 483     gtk_xtext_thaw(GTK_XTEXT(d));
 484 }
 485
 486 static GtkMenu *make_menu(GList *l, GtkXText *gtktext)
 487 {
 488     GtkWidget *menu, *item;
 489     unsigned char *caption;
 490     menu = gtk_menu_new();
 491
 492         caption = g_strdup_printf(_("Not in dictionary: %s"), (unsigned char*)l->data);
 493         item = gtk_menu_item_new_with_label(caption);
 494         /* I'd like to make it so this item is never selectable, like
 495          * the menu titles in the GNOME panel... unfortunately, the GNOME
 496          * panel creates their own custom widget to do this! */
 497         gtk_widget_show(item);
 498         gtk_menu_append(GTK_MENU(menu), item);
 499
 500         item = gtk_menu_item_new();
 501         gtk_widget_show(item);
 502         gtk_menu_append(GTK_MENU(menu), item);
 503
 504         l = l->next;
 505         if (l == NULL) {
 506             item = gtk_menu_item_new_with_label(_("(no suggestions)"));
 507             gtk_widget_show(item);
 508             gtk_menu_append(GTK_MENU(menu), item);
 509         } else {
 510             GtkWidget *curmenu = menu;
 511             int count = 0;
 512             do {
 513                 if (l->data == NULL && l->next != NULL) {
 514                     count = 0;
 515                     curmenu = gtk_menu_new();
 516                     item = gtk_menu_item_new_with_label(_("Others..."));
 517                     gtk_widget_show(item);
 518                     gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
 519                     gtk_menu_append(GTK_MENU(curmenu), item);
 520                     l = l->next;
 521                 } else if (count > MENUCOUNT) {
 522                     count -= MENUCOUNT;
 523                     item = gtk_menu_item_new_with_label(_("More..."));
 524                     gtk_widget_show(item);
 525                     gtk_menu_append(GTK_MENU(curmenu), item);
 526                     curmenu = gtk_menu_new();
 527                     gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
 528                 }
 529                 item = gtk_menu_item_new_with_label((unsigned char*)l->data);
 530                 gtk_signal_connect(GTK_OBJECT(item), "activate",
 531                                    GTK_SIGNAL_FUNC(replace_word), gtktext);
 532                 gtk_widget_show(item);
 533                 gtk_menu_append(GTK_MENU(curmenu), item);
 534                 count++;
 535             } while ((l = l->next) != NULL);
 536         }
 537     return GTK_MENU(menu);
 538 }
 539
 540 static void popup_menu(GtkXText *gtktext, GdkEventButton *eb)
 541 {
 542     unsigned char buf[BUFSIZE];
 543     GList *list, *l;
 544     if (!get_curword(gtktext, buf, NULL, NULL)) return ;
 545     if (buf == NULL) return ;
 546     list = misspelled_suggest(buf);
 547     if (list != NULL) {
 548         gtk_menu_popup(make_menu(list, gtktext), NULL, NULL, NULL, NULL,
 549                        eb->button, eb->time);
 550         for (l = list; l != NULL; l = l->next)
 551             g_free(l->data);
 552         g_list_free(list);
 553     }
 554 }
 555
 556 /* ok, this is pretty wacky:
 557  * we need to let the right-mouse-click go through, so it moves the cursor,
 558  * but we *can't* let it go through, because GtkText interprets rightclicks as
 559  * weird selection modifiers.
 560  *
 561  * so what do we do?  forge rightclicks as leftclicks, then popup the menu.
 562  * HACK HACK HACK.
 563  */
 564 static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, gpointer d)
 565 {
 566     GdkEventButton *eb;
 567     gboolean retval;
 568
 569     if (!gtkspell_running()) return FALSE;
 570
 571     if (e->type != GDK_BUTTON_PRESS) return FALSE;
 572     eb = (GdkEventButton*) e;
 573
 574     if (eb->button != 3) return FALSE;
 575
 576     /* forge the leftclick */
 577     eb->button = 1;
 578
 579     gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
 580                                      GTK_SIGNAL_FUNC(button_press_intercept_cb), d);
 581     gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
 582                             e, &retval);
 583     gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
 584                                        GTK_SIGNAL_FUNC(button_press_intercept_cb), d);
 585     gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
 586
 587     /* now do the menu wackiness */
 588     popup_menu(gtktext, eb);
 589     return TRUE;
 590 }
 591
 592 void gtkspell_uncheck_all(GtkXText *gtktext)
 593 {
 594     int origpos;
 595     unsigned char *text;
 596     float adj_value;
 597     adj_value = gtktext->vadj->value;
 598     gtk_xtext_freeze(gtktext);
 599     origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
 600     text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
 601     gtk_xtext_set_point(gtktext, 0);
 602     gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext));
 603     gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
 604     gtk_xtext_thaw(gtktext);
 605
 606     gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
 607     gtk_adjustment_set_value(gtktext->vadj, adj_value);
 608 }
 609
 610 void gtkspell_attach(GtkXText *gtktext)
 611 {
 612 //    if (prefs_common.auto_makeispell) {
 613         gtk_signal_connect(GTK_OBJECT(gtktext), "insert-text",
 614                            GTK_SIGNAL_FUNC(entry_insert_cb), NULL);
 615         gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
 616                                  GTK_SIGNAL_FUNC(entry_delete_cb), NULL);
 617 //    };
 618     gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
 619                        GTK_SIGNAL_FUNC(button_press_intercept_cb), NULL);
 620
 621 }
 622
 623 void gtkspell_detach(GtkXText *gtktext)
 624 {
 625 //    if (prefs_common.auto_makeispell) {
 626         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
 627                                       GTK_SIGNAL_FUNC(entry_insert_cb), NULL);
 628         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
 629                                       GTK_SIGNAL_FUNC(entry_delete_cb), NULL);
 630 //    };
 631     gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
 632                                   GTK_SIGNAL_FUNC(button_press_intercept_cb), NULL);
 633
 634     gtkspell_uncheck_all(gtktext);
 635 }
 636
 637 static void sigchld(int param)
 638 {
 639     int retstat, retval;
 640
 641     debug_print(_("*** SIGCHLD called. (ispell pid: %i)\n"), spell_pid);
 642     while ((retval = waitpid( -1, &retstat, WNOHANG)) > 0) {
 643         if (retval == spell_pid) {
 644             debug_print(_("*** SIGCHLD called for ispell. (pid: %i)\n"), spell_pid);
 645             spell_pid = -1;
 646         }
 647     }
 648 }
 649
 650 static void set_up_signal()
 651 {
 652     /* RETSIGTYPE is found in autoconf's config.h */
 653 #ifdef RETSIGTYPE
 654     typedef RETSIGTYPE (*sighandler)(int);
 655     signal(SIGCHLD, (sighandler)sigchld);
 656 #else
 657     /* otherwise, just hope it works */
 658     signal(SIGCHLD, sigchld);
 659 #endif
 660 }