/* gtkpspell - a spell-checking addon for GtkText
* Copyright (c) 2000 Evan Martin.
+ * Copyright (c) 2002 Melvin Hadasht.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
+ * License along with this library; If not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-
/*
* Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
- * Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto &
+ * Adapted for Sylpheed (Claws) (c) 2001-2002 by Hiroyuki Yamamoto &
* The Sylpheed Claws Team.
- * Adapted for pspell (c) 2001 Melvin Hadasht
+ * Adapted for pspell (c) 2001-2002 Melvin Hadasht
*/
#if defined(HAVE_CONFIG_H)
#include "intl.h"
#include <gtk/gtk.h>
+#include <gdk/gdk.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <gtk/gtkoptionmenu.h>
#include <gtk/gtkmenu.h>
#include <gtk/gtkmenuitem.h>
+#include <gdk/gdkkeysyms.h>
-#include "gtkxtext.h"
+#include "gtkstext.h"
#include "gtkspell.h"
/* number of suggestions to display on each menu. */
#define MENUCOUNT 15
-/******************************************************************************/
-
-/* Function called from menus */
+/* 'config' must be defined as a 'PspellConfig *' */
+#define RETURN_FALSE_IF_CONFIG_ERROR() \
+ if (pspell_config_error_number(config) != 0) { \
+ gtkpspellcheckers->error_message = g_strdup(pspell_config_error_message(config)); \
+ return FALSE; \
+ }
-static void add_word_to_session (GtkWidget *w, GtkPspell *d);
-static void add_word_to_personal (GtkWidget *w, GtkPspell *d);
-static void set_sug_mode (GtkWidget *w, GtkPspell *gtkpspell);
-static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell);
-static void check_all (GtkWidget *w, GtkPspell *gtkpspell);
-static void menu_change_dict (GtkWidget *w, GtkPspell *gtkpspell);
-static void entry_insert_cb (GtkXText *gtktext, gchar *newtext,
- guint len, guint *ppos,
- GtkPspell *gtkpspell);
-static gint compare_dict (Dictionary *a, Dictionary *b);
-guchar *convert_to_pspell_encoding (const guchar *encoding);
+#define CONFIG_REPLACE_RETURN_FALSE_IF_FAIL(option, value) { \
+ pspell_config_replace(config, option, value); \
+ RETURN_FALSE_IF_CONFIG_ERROR(); \
+ }
-static void allocate_color(GtkPspell *gtkpspell);
+/******************************************************************************/
+GtkPspellCheckers *gtkpspellcheckers;
+
+/* Error message storage */
+static void gtkpspell_checkers_error_message(gchar *message);
+
+/* Callbacks */
+static void entry_insert_cb (GtkSText *gtktext,
+ gchar *newtext,
+ guint len,
+ guint *ppos,
+ GtkPspell *gtkpspell);
+static void entry_delete_cb (GtkSText *gtktext,
+ gint start,
+ gint end,
+ GtkPspell *gtkpspell);
+static gint button_press_intercept_cb (GtkSText *gtktext,
+ GdkEvent *e,
+ GtkPspell *gtkpspell);
+
+/* Checker creation */
+static GtkPspeller * gtkpspeller_new (Dictionary *dict);
+static GtkPspeller * gtkpspeller_real_new (Dictionary *dict);
+static GtkPspeller * gtkpspeller_delete (GtkPspeller *gtkpspeller);
+static GtkPspeller * gtkpspeller_real_delete (GtkPspeller *gtkpspeller);
+
+/* Checker configuration */
+static gint set_dictionary (PspellConfig *config,
+ Dictionary *dict);
+static void set_sug_mode_cb (GtkMenuItem *w,
+ GtkPspell *gtkpspell);
+static void set_real_sug_mode (GtkPspell *gtkpspell,
+ const char *themode);
+
+/* Checker actions */
+static gboolean check_at (GtkPspell *gtkpspell,
+ int from_pos);
+static gboolean check_next_prev (GtkPspell *gtkpspell,
+ gboolean forward);
+static GList* misspelled_suggest (GtkPspell *gtkpspell,
+ guchar *word);
+static void add_word_to_session_cb (GtkWidget *w,
+ gpointer data);
+static void add_word_to_personal_cb (GtkWidget *w,
+ gpointer data);
+static void replace_with_create_dialog_cb (GtkWidget *w,
+ gpointer data);
+static void replace_with_supplied_word_cb (GtkWidget *w,
+ GtkPspell *gtkpspell);
+static void replace_word_cb (GtkWidget *w,
+ gpointer data);
+static void replace_real_word (GtkPspell *gtkpspell,
+ gchar *newword);
+static void toggle_check_while_typing_cb (GtkWidget *w,
+ gpointer data);
+
+/* Menu creation */
+static void popup_menu (GtkPspell *gtkpspell,
+ GdkEventButton *eb);
+static GtkMenu* make_sug_menu (GtkPspell *gtkpspell);
+static void populate_submenu (GtkPspell *gtkpspell,
+ GtkWidget *menu);
+static GtkMenu* make_config_menu (GtkPspell *gtkpspell);
+static void set_menu_pos (GtkMenu *menu,
+ gint *x,
+ gint *y,
+ gpointer data);
+/* Other menu callbacks */
+static gboolean cancel_menu_cb (GtkMenuShell *w,
+ gpointer data);
+static void change_dict_cb (GtkWidget *w,
+ GtkPspell *gtkpspell);
+
+/* Misc. helper functions */
+static void set_point_continue (GtkPspell *gtkpspell);
+static void continue_check (gpointer *gtkpspell);
+static gboolean iswordsep (unsigned char c);
+static guchar get_text_index_whar (GtkPspell *gtkpspell,
+ int pos);
+static gboolean get_word_from_pos (GtkPspell *gtkpspell,
+ gint pos,
+ unsigned char* buf,
+ gint buflen,
+ gint *pstart,
+ gint *pend);
+static void allocate_color (GtkPspell *gtkpspell,
+ gint rgbvalue);
+static void change_color (GtkPspell *gtkpspell,
+ gint start,
+ gint end,
+ gchar *newtext,
+ GdkColor *color);
+static guchar* convert_to_pspell_encoding (const guchar *encoding);
+static gint compare_dict (Dictionary *a,
+ Dictionary *b);
+static void dictionary_delete (Dictionary *dict);
+static Dictionary * dictionary_dup (const Dictionary *dict);
+static void free_suggestions_list (GtkPspell *gtkpspell);
+static void reset_theword_data (GtkPspell *gtkpspell);
+static void free_checkers (gpointer elt,
+ gpointer data);
+static gint find_gtkpspeller (gconstpointer aa,
+ gconstpointer bb);
+static void gtkpspell_alert_dialog (gchar *message);
/* gtkspellconfig - only one config per session */
GtkPspellConfig * gtkpspellconfig;
/******************************************************************************/
-/* gtkspell_init() - run the first pspell_config from which every
- * new config is cloned
- */
-GtkPspellConfig * gtkpspell_init()
+GtkPspellCheckers * gtkpspell_checkers_new()
{
- return new_pspell_config();
-}
+ GtkPspellCheckers *gtkpspellcheckers;
+
+ gtkpspellcheckers = g_new(GtkPspellCheckers, 1);
+
+ gtkpspellcheckers->checkers = NULL;
-/* gtkspell_finished() - Finish all. No more spelling. Called when the
- * program ends
- */
-void gtkpspell_finished(GtkPspellConfig *gtkpspellconfig)
-{
- if (gtkpspellconfig) {
- delete_pspell_config(gtkpspellconfig);
- gtkpspellconfig = NULL;
- }
-}
+ gtkpspellcheckers->dictionary_list = NULL;
-/* gtkspell_running - Test if there is a manager running
- */
-int gtkpspell_running(GtkPspell * gtkpspell)
-{
- return (gtkpspell->config!=NULL);
+ gtkpspellcheckers->error_message = NULL;
+
+ return gtkpspellcheckers;
}
-
-/* gtkspell_new() - creates a new session if a gtkpspellconfig exists. The
- * settings are defaults. If no path/dict is set afterwards, the default
- * one is used
- */
-GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig)
+
+GtkPspellCheckers *gtkpspell_checkers_delete()
{
- GtkPspell *gtkpspell;
+ GSList *checkers;
+ GSList *dict_list;
- if (gtkpspellconfig == NULL) {
- gtkpspellconfig = gtkpspell_init();
- if (gtkpspellconfig == NULL) {
- debug_print(_("Pspell could not be started."));
- prefs_common.enable_pspell=FALSE;
- return NULL;
- }
- }
+ if (gtkpspellcheckers == NULL) return NULL;
- gtkpspell = g_new(GtkPspell ,1);
- gtkpspell->config = gtkpspellconfig;
- gtkpspell->possible_err = new_pspell_manager(gtkpspell->config);
- gtkpspell->checker = NULL;
+ if ((checkers = gtkpspellcheckers->checkers)) {
+ debug_print(_("Pspell: number of running checkers to delete %d\n"),
+ g_slist_length(checkers));
- if (pspell_error_number(gtkpspell->possible_err) != 0) {
- debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err));
- delete_pspell_can_have_error( gtkpspell->possible_err );
+ g_slist_foreach(checkers, free_checkers, NULL);
+ g_slist_free(checkers);
}
- else {
- gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err);
+
+ if ((dict_list = gtkpspellcheckers->dictionary_list)) {
+ debug_print(_("Pspell: number of dictionaries to delete %d\n"),
+ g_slist_length(dict_list));
+
+ gtkpspell_free_dictionary_list(dict_list);
+ gtkpspellcheckers->dictionary_list = NULL;
}
-
- gtkpspell->dictionary_list = NULL;
- gtkpspell->path = NULL;
- gtkpspell->dict = NULL;
- gtkpspell->mode = PSPELL_FASTMODE;
- gtkpspell->learn = TRUE;
- gtkpspell->gtktext = NULL;
- return gtkpspell;
+ g_free(gtkpspellcheckers->error_message);
+
+ return NULL;
}
-/* gtkspell_new_with_config() - Creates a new session and set path/dic
- */
-GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig,
- guchar *path, guchar *dict,
- guint mode, const guchar *encoding)
-{
- GtkPspell *gtkpspell;
-
- if (gtkpspellconfig == NULL) {
- gtkpspellconfig=gtkpspell_init();
- if (gtkpspellconfig == NULL) {
- debug_print(_("Pspell could not be started."));
- prefs_common.enable_pspell = FALSE;
- return NULL;
- }
- }
+static void gtkpspell_checkers_error_message (gchar *message)
+{
+ gchar *tmp;
+ if (gtkpspellcheckers->error_message) {
+ tmp = g_strdup_printf("%s\n%s",
+ gtkpspellcheckers->error_message, message);
+ g_free(message);
+ g_free(gtkpspellcheckers->error_message);
+ gtkpspellcheckers->error_message = tmp;
+ } else gtkpspellcheckers->error_message = message;
+}
- gtkpspell = g_new( GtkPspell ,1);
- gtkpspell->path = NULL;
- gtkpspell->dict = NULL;
- gtkpspell->dictionary_list = NULL;
- gtkpspell->gtktext = NULL;
-
- gtkpspell->config = pspell_config_clone(gtkpspellconfig);
- gtkpspell->mode = PSPELL_FASTMODE;
- gtkpspell->learn = TRUE;
-
- if (!set_path_and_dict(gtkpspell, gtkpspell->config, path, dict)) {
- debug_print(_("Pspell could not be configured."));
- gtkpspell = gtkpspell_delete(gtkpspell);
- return gtkpspell;
- }
+void gtkpspell_checkers_reset_error()
+{
+ g_return_if_fail(gtkpspellcheckers);
- if (encoding) {
- char *pspell_encoding;
- pspell_encoding = convert_to_pspell_encoding (encoding);
- debug_print(_("Pspell encoding: asked: %s changed to: %s\n"), encoding, pspell_encoding);
- pspell_config_replace(gtkpspell->config, "encoding", (const char *)pspell_encoding);
- if (pspell_config_error_number(gtkpspell->config) !=0 ) {
- debug_print(_("Pspell encoding error: %s\nSwitching to iso8859-1 (sorry)\n"),
- pspell_config_error_message(gtkpspell->config));
- pspell_config_replace(gtkpspell->config, "encoding", "iso8859-1");
- }
- g_free(pspell_encoding);
- }
+ g_free(gtkpspellcheckers->error_message);
+
+ gtkpspellcheckers->error_message = NULL;
+}
- gtkpspell->possible_err = new_pspell_manager(gtkpspell->config);
- gtkpspell->checker = NULL;
+GtkPspell *gtkpspell_new(const gchar *dictionary,
+ const gchar *encoding,
+ gint misspelled_color,
+ gboolean check_while_typing,
+ GtkSText *gtktext)
+{
+ Dictionary *dict = g_new0(Dictionary, 1);
+ GtkPspell *gtkpspell;
+ GtkPspeller *gtkpspeller;
- if (pspell_error_number(gtkpspell->possible_err) != 0) {
- debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err));
- delete_pspell_can_have_error(gtkpspell->possible_err);
- gtkpspell = gtkpspell_delete(gtkpspell);
- }
- else {
- gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
- }
+ g_return_val_if_fail(gtktext, NULL);
+
+ dict->fullname = g_strdup(dictionary);
+ dict->encoding = g_strdup(encoding);
+ gtkpspeller = gtkpspeller_new(dict);
+ dictionary_delete(dict);
+
+ if (!gtkpspeller)
+ return NULL;
+
+ gtkpspell = g_new(GtkPspell, 1);
+
+ gtkpspell->gtkpspeller = gtkpspeller;
+ gtkpspell->theword[0] = 0x00;
+ gtkpspell->start_pos = 0;
+ gtkpspell->end_pos = 0;
+ gtkpspell->orig_pos = -1;
+ gtkpspell->end_check_pos = -1;
+ gtkpspell->misspelled = -1;
+ gtkpspell->check_while_typing = check_while_typing;
+ gtkpspell->continue_check = NULL;
+ gtkpspell->config_menu = NULL;
+ gtkpspell->popup_config_menu = NULL;
+ gtkpspell->sug_menu = NULL;
+ gtkpspell->replace_entry = NULL;
+ gtkpspell->gtktext = gtktext;
+ gtkpspell->default_sug_mode = PSPELL_FASTMODE;
+ gtkpspell->max_sug = -1;
+ gtkpspell->suggestions_list = NULL;
+
+ allocate_color(gtkpspell, misspelled_color);
+
+ gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text",
+ GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
+ gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
+ GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
+ gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
+ GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
+
+ debug_print("Pspell: created gtkpspell %0x\n", gtkpspell);
return gtkpspell;
}
-/* gtkspell_delete() - Finishes a session
- */
-GtkPspell *gtkpspell_delete( GtkPspell *gtkpspell )
-{
- if ( gtkpspell->checker ) {
- /* First save all word lists */
- pspell_manager_save_all_word_lists(gtkpspell->checker);
- delete_pspell_manager(gtkpspell->checker);
- gtkpspell->checker = NULL;
- gtkpspell->possible_err = NULL; /* checker is a cast from possible_err */
- }
-
- if (gtkpspell->dictionary_list)
- gtkpspell_free_dictionary_list(gtkpspell->dictionary_list);
+void gtkpspell_delete(GtkPspell * gtkpspell)
+{
+ GtkSText * gtktext;
+
+ gtktext = gtkpspell->gtktext;
- g_free(gtkpspell->path);
- g_free(gtkpspell->dict);
- gtkpspell->path = NULL;
- gtkpspell->dict = NULL;
+ gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
+ gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
+ gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(button_press_intercept_cb),
+ gtkpspell);
- g_free(gtkpspell);
- return NULL;
-}
-
-int set_path_and_dict(GtkPspell *gtkpspell, PspellConfig *config,
- guchar *path, guchar * dict)
-{
- guchar *module = NULL;
- guchar *language = NULL;
- guchar *spelling = NULL;
- guchar *jargon = NULL;
- guchar buf[BUFSIZE];
- guchar *end;
- guchar *temppath;
- guchar *tempdict;
-
- /* Change nothing if any of path/dict/config is NULL */
- g_return_val_if_fail(path, 0);
- g_return_val_if_fail(dict, 0);
- g_return_val_if_fail(config, 0);
-
- /* This is done, so we can free gtkpspell->path, even if it was
- * given as an argument of the function */
- temppath = g_strdup(path);
- g_free(gtkpspell->path);
-
- /* pspell dict name format : */
- /* <lang>[[-<spelling>[-<jargon>]]-<module>.pwli */
- /* Strip off path */
+ gtkpspell_uncheck_all(gtkpspell);
- if (!strrchr(dict,G_DIR_SEPARATOR)) {
- /* plain dict name */
- strncpy(buf,dict,BUFSIZE-1);
- }
- else {
- /* strip path */
- strncpy(buf, strrchr(dict, G_DIR_SEPARATOR)+1, BUFSIZE-1);
- }
+ gtkpspeller_delete(gtkpspell->gtkpspeller);
+
+ if (gtkpspell->sug_menu)
+ gtk_widget_destroy(gtkpspell->sug_menu);
+ if (gtkpspell->popup_config_menu)
+ gtk_widget_destroy(gtkpspell->popup_config_menu);
+ if (gtkpspell->config_menu)
+ gtk_widget_destroy(gtkpspell->config_menu);
+ if (gtkpspell->suggestions_list)
+ free_suggestions_list(gtkpspell);
- g_free(gtkpspell->dict);
+ debug_print("Pspell: deleting gtkpspell %0x\n", gtkpspell);
- /* Ensure no buffers overflows if the dict is to long */
- buf[BUFSIZE-1] = 0x00;
+ g_free(gtkpspell);
- language = buf;
- if ((module = strrchr(buf, '-')) != NULL) {
- module++;
- if ((end = strrchr(module, '.')) != NULL)
- end[0] = 0x00;
- }
+ gtkpspell = NULL;
+}
- /* In tempdict, we have only the dict name, without path nor
- extension. Useful in the popup menus */
+static void entry_insert_cb(GtkSText *gtktext, gchar *newtext,
+ guint len, guint *ppos,
+ GtkPspell * gtkpspell)
+{
+ g_return_if_fail(gtkpspell->gtkpspeller->checker);
- tempdict = g_strdup(buf);
+ if (!gtkpspell->check_while_typing)
+ return;
+
+ /* We must insert ourself the character to impose the */
+ /* color of the inserted character to be default */
+ /* Never mess with set_insertion when frozen */
+ gtk_stext_freeze(gtktext);
+ gtk_stext_backward_delete(GTK_STEXT(gtktext), len);
+ gtk_stext_insert(GTK_STEXT(gtktext), NULL, NULL, NULL, newtext, len);
+ *ppos = gtk_stext_get_point(GTK_STEXT(gtktext));
+
+ if (iswordsep(newtext[0])) {
+ /* did we just end a word? */
+ if (*ppos >= 2)
+ check_at(gtkpspell, *ppos - 2);
- /* Probably I am too paranoied... */
- if (!(language[0] != 0x00 && language[1] != 0x00))
- language = NULL;
- else {
- spelling = strchr(language, '-');
- if (spelling != NULL) {
- spelling[0] = 0x00;
- spelling++;
- }
- if (spelling != module) {
- if ((end = strchr(spelling, '-')) != NULL) {
- end[0] = 0x00;
- jargon = end + 1;
- if (jargon != module)
- if ((end = strchr(jargon, '-')) != NULL)
- end[0] = 0x00;
- else
- jargon = NULL;
- else
- jargon = NULL;
- }
- else
- spelling = NULL;
+ /* did we just split a word? */
+ if (*ppos < gtk_stext_get_length(gtktext))
+ check_at(gtkpspell, *ppos + 1);
+ } else {
+ /* check as they type, *except* if they're typing at the end (the most
+ * common case.
+ */
+ if (*ppos < gtk_stext_get_length(gtktext)
+ && !iswordsep(get_text_index_whar(gtkpspell, *ppos)))
+ check_at(gtkpspell, *ppos - 1);
}
- else
- spelling = NULL;
- }
+ gtk_stext_thaw(gtktext);
+ gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
+}
- debug_print(_("Language : %s\nSpelling: %s\nJargon: %s\nModule: %s\n"),
- language, spelling, jargon, module);
-
- if (temppath[strlen(temppath)-1] == G_DIR_SEPARATOR)
- temppath[strlen(temppath)-1]= 0;
- if (temppath) {
- pspell_config_replace(config, "add-word-list-path", temppath);
- debug_print(_("Pspell config: added path %s\n"), pspell_config_retrieve(config, "word-list-path"));
- if (pspell_config_error_number(config))
- debug_print(_("Pspell config: %s\n"), pspell_config_error_message(config));
- }
- if (language)
- pspell_config_replace(config, "language-tag", language);
- if (spelling)
- pspell_config_replace(config, "spelling", spelling);
- if (jargon)
- pspell_config_replace(config, "jargon", jargon);
- if (module)
- pspell_config_replace(config, "module", module);
-
- switch(gtkpspell->mode) {
- case PSPELL_FASTMODE:
- pspell_config_replace(config, "sug-mode", "fast");
- break;
- case PSPELL_NORMALMODE:
- pspell_config_replace(config, "sug-mode", "normal");
- break;
- case PSPELL_BADSPELLERMODE:
- pspell_config_replace(config, "sug-mode", "bad-spellers");
- break;
+static void entry_delete_cb(GtkSText *gtktext, gint start, gint end,
+ GtkPspell *gtkpspell)
+{
+ int origpos;
+
+ g_return_if_fail(gtkpspell->gtkpspeller->checker);
+
+ if (!gtkpspell->check_while_typing)
+ return;
+
+ origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
+ if (start) {
+ check_at(gtkpspell, start - 1);
+ check_at(gtkpspell, start);
}
-
- gtkpspell->path = g_strdup(temppath);
- gtkpspell->dict = g_strdup(tempdict);
- g_free(temppath);
- g_free(tempdict);
- return TRUE;
+ gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
+ gtk_stext_set_point(gtktext, origpos);
+ gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
+ /* this is to *UNDO* the selection, in case they were holding shift
+ * while hitting backspace. */
}
-
-/* gtkpspell_set_path_and_dict() - Set path and dict. The session is
- * resetted.
- * FALSE on error, TRUE on success */
-int gtkpspell_set_path_and_dict(GtkPspell * gtkpspell, guchar * path,
- guchar * dict)
+/* ok, this is pretty wacky:
+ * we need to let the right-mouse-click go through, so it moves the cursor,
+ * but we *can't* let it go through, because GtkText interprets rightclicks as
+ * weird selection modifiers.
+ *
+ * so what do we do? forge rightclicks as leftclicks, then popup the menu.
+ * HACK HACK HACK.
+ */
+static gint button_press_intercept_cb(GtkSText *gtktext, GdkEvent *e, GtkPspell *gtkpspell)
{
- PspellConfig * config2;
-
- /* It seems changing an already running config is not the way to go
- */
-
- config2 = pspell_config_clone(gtkpspell->config);
+ GdkEventButton *eb;
+ gboolean retval;
- if (gtkpspell->checker) {
- pspell_manager_save_all_word_lists(gtkpspell->checker);
- delete_pspell_manager(gtkpspell->checker);
- }
-
- gtkpspell->checker = NULL;
- gtkpspell->possible_err = NULL;
+ g_return_val_if_fail(gtkpspell->gtkpspeller->checker, FALSE);
- if (set_path_and_dict(gtkpspell,config2,path,dict) == 0) {
- debug_print(_("Pspell set_path_and_dict error."));
+ if (e->type != GDK_BUTTON_PRESS)
return FALSE;
- }
-
- gtkpspell->possible_err = new_pspell_manager(config2);
-
- delete_pspell_config(config2);
- config2 = NULL;
+ eb = (GdkEventButton*) e;
- if (pspell_error_number(gtkpspell->possible_err) != 0) {
- debug_print(_("Pspell path & dict. error %s\n"),
- pspell_error_message(gtkpspell->possible_err));
- delete_pspell_can_have_error(gtkpspell->possible_err);
- gtkpspell->possible_err = NULL;
+ if (eb->button != 3)
return FALSE;
- }
- gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err);
+ /* forge the leftclick */
+ eb->button = 1;
+ gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(button_press_intercept_cb),
+ gtkpspell);
+ gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
+ e, &retval);
+ gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(button_press_intercept_cb),
+ gtkpspell);
+ gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
+
+ /* now do the menu wackiness */
+ popup_menu(gtkpspell, eb);
+ gtk_grab_remove(GTK_WIDGET(gtktext));
return TRUE;
}
-
-/* gtkpspell_get_dict() - What dict are we using ? language-spelling-jargon-module format */
-/* Actually, this function is not used and hence not tested. */
-/* Returns an allocated string */
-guchar *gtkpspell_get_dict(GtkPspell *gtkpspell)
-{
-/* Number of dashes in a dictionary name + 1 (for trailing null)
- * needed when rebuilding dictionary name
- */
-#define DASHES_IN_DICTNAME 3+1
- guchar *dict;
- guchar *language;
- guchar *spelling;
- guchar *jargon;
- guint len;
-
- g_return_val_if_fail(gtkpspell->config, NULL);
-
- language = g_strdup(pspell_config_retrieve(gtkpspell->config, "language"));
- spelling = g_strdup(pspell_config_retrieve(gtkpspell->config, "spelling"));
- jargon = g_strdup(pspell_config_retrieve(gtkpspell->config, "jargon" ));
- len = strlen(language) + strlen(spelling) + strlen(jargon);
-
- if (len + DASHES_IN_DICTNAME < BUFSIZE) {
- dict = g_new(char,len + DASHES_IN_DICTNAME);
- strcpy(dict, language);
- if (spelling) {
- strcat(dict, "-");
- strcat(dict, spelling);
- if (jargon) {
- strcat(dict, "-");
- strcat(dict,jargon);
- }
- }
- }
- g_free(language);
- g_free(spelling);
- g_free(jargon);
-
- return dict;
-}
-
-/* gtkpspell_get_path() - Return the dict path as an allocated string */
-/* Not used = not tested */
-guchar *gtkpspell_get_path(GtkPspell *gtkpspell)
+/*****************************************************************************/
+/* Checker creation */
+static GtkPspeller *gtkpspeller_new(Dictionary *dictionary)
{
- guchar * path;
+ GSList *exist;
+ GtkPspeller *gtkpspeller = NULL;
+ GtkPspeller *g = g_new0(GtkPspeller, 1);
+ Dictionary *dict;
+ gint ispell;
+
+ g_return_val_if_fail(gtkpspellcheckers, NULL);
+ g_return_val_if_fail(dictionary, NULL);
- g_return_val_if_fail(gtkpspell->config, NULL);
+ if (dictionary->fullname == NULL)
+ gtkpspell_checkers_error_message(g_strdup(_("No dictionary selected.")));
+
+ g_return_val_if_fail(dictionary->fullname, NULL);
+
+ if (dictionary->dictname == NULL) {
+ gchar *tmp;
- path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path"));
+ tmp = strrchr(dictionary->fullname, G_DIR_SEPARATOR);
- return path;
-}
+ if (tmp == NULL)
+ dictionary->dictname = dictionary->fullname;
+ else
+ dictionary->dictname = tmp + 1;
+ }
-/* menu_change_dict() - Menu callback : change dict */
-static void menu_change_dict(GtkWidget *w, GtkPspell *gtkpspell)
-{
- guchar *thedict,
- *thelabel;
-
- /* Dict is simply the menu label */
+ dict = dictionary_dup(dictionary);
- gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &thelabel);
+ ispell = (strstr2(dict->dictname, "-ispell") != NULL);
- if (!strcmp2(thelabel, _("None")))
- return;
+ g->dictionary = dict;
- thedict = g_strdup(thelabel);
+ exist = g_slist_find_custom(gtkpspellcheckers->checkers, g,
+ find_gtkpspeller);
+
+ g_free(g);
- /* Set path, dict, (and sug_mode ?) */
- if(!gtkpspell_set_path_and_dict(gtkpspell, gtkpspell->path, thedict)) {
- /* FIXME : try to handle this very special case */
- debug_print("Pspell: Attempt to change to a non existant dict. I will crash after closing compose window.\n");
- gtkpspell_detach(gtkpspell);
- gtkpspell = gtkpspell_delete(gtkpspell);
- }
- g_free(thedict);
-}
+ if (exist && ispell) {
+ gtkpspeller = (GtkPspeller *) exist->data;
+ dictionary_delete(dict);
-/* set_sug_mode() - Menu callback : Set the suggestion mode */
-static void set_sug_mode(GtkWidget *w, GtkPspell *gtkpspell)
-{
- unsigned char *themode;
+ debug_print(_("Pspell: Using existing ispell checker %0x\n"),
+ (gint) gtkpspeller);
+ } else {
+ if ((gtkpspeller = gtkpspeller_real_new(dict)) != NULL) {
+ gtkpspellcheckers->checkers = g_slist_append(
+ gtkpspellcheckers->checkers,
+ gtkpspeller);
- gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode);
+ debug_print(_("Pspell: Created a new gtkpspeller %0x\n"),
+ (gint) gtkpspeller);
+ } else {
+ dictionary_delete(dict);
- if (!strcmp(themode, _("Fast Mode"))) {
- gtkpspell_set_sug_mode(gtkpspell, "fast");
- gtkpspell->mode = PSPELL_FASTMODE;
- }
- if (!strcmp(themode,_("Normal Mode"))) {
- gtkpspell_set_sug_mode(gtkpspell, "normal");
- gtkpspell->mode = PSPELL_NORMALMODE;
- }
- if (!strcmp( themode,_("Bad Spellers Mode"))) {
- gtkpspell_set_sug_mode(gtkpspell, "bad-spellers");
- gtkpspell->mode = PSPELL_BADSPELLERMODE;
+ debug_print(_("Pspell: Could not create spell checker.\n"));
+ }
}
+
+ debug_print(_("Pspell: number of existing checkers %d\n"),
+ g_slist_length(gtkpspellcheckers->checkers));
+
+ return gtkpspeller;
}
-
-/* gtkpspell_set_sug_mode() - Set the suggestion mode */
-/* Actually, the session is resetted and everything is reset. */
-/* We take the used path/dict pair and create a new config with them */
-int gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gchar *themode)
+
+static GtkPspeller *gtkpspeller_real_new(Dictionary *dict)
{
- PspellConfig *config2;
- guchar *path;
- guchar *dict;
+ GtkPspeller *gtkpspeller;
+ PspellConfig *config;
+ PspellCanHaveError *ret;
+
+ g_return_val_if_fail(gtkpspellcheckers, NULL);
+ g_return_val_if_fail(dict, NULL);
- pspell_manager_save_all_word_lists(gtkpspell->checker);
- delete_pspell_manager(gtkpspell->checker);
+ gtkpspeller = g_new(GtkPspeller, 1);
+
+ gtkpspeller->dictionary = dict;
+ gtkpspeller->sug_mode = PSPELL_FASTMODE;
- gtkpspell->checker = NULL;
+ config = new_pspell_config();
- config2 = pspell_config_clone(gtkpspell->config);
+ if (!set_dictionary(config, dict))
+ return NULL;
+
+ ret = new_pspell_manager(config);
+ delete_pspell_config(config);
- if (!set_path_and_dict(gtkpspell, config2, gtkpspell->path, gtkpspell->dict)) {
- debug_print(_("Pspell set_sug_mod could not reset path & dict\n"));
- return FALSE;
+ if (pspell_error_number(ret) != 0) {
+ gtkpspellcheckers->error_message = g_strdup(pspell_error_message(ret));
+
+ delete_pspell_can_have_error(ret);
+
+ return NULL;
}
- pspell_config_replace(config2, "sug-mode", themode);
-
- gtkpspell->possible_err = new_pspell_manager(config2);
- delete_pspell_config(config2);
- config2 = NULL;
+ gtkpspeller->checker = to_pspell_manager(ret);
+ gtkpspeller->config = pspell_manager_config(gtkpspeller->checker);
+ gtkpspeller->ispell = (strstr2(dict->fullname, "-ispell") != NULL);
- if (pspell_error_number(gtkpspell->possible_err) != 0) {
- debug_print(_("Pspell set sug-mode error %s\n"),
- pspell_error_message(gtkpspell->possible_err));
- delete_pspell_can_have_error(gtkpspell->possible_err);
- gtkpspell->possible_err = NULL;
- return FALSE;
- }
- gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err);
- return TRUE;
+ return gtkpspeller;
}
-/* set_learn_mode() - menu callback to toggle learn mode */
-static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell)
-{
- gtkpspell->learn = gtkpspell->learn == FALSE ;
-}
-
-/* misspelled_suggest() - Create a suggestion list for word */
-static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word)
+static GtkPspeller *gtkpspeller_delete(GtkPspeller *gtkpspeller)
{
- const guchar *newword;
- GList *list = NULL;
- int count;
- const PspellWordList *suggestions;
- PspellStringEmulation *elements;
-
- g_return_val_if_fail(word, NULL);
+ g_return_val_if_fail(gtkpspellcheckers, NULL);
+
+ if (gtkpspeller->ispell)
+ debug_print(_("Pspell: Won't remove existing ispell checker %0x.\n"),
+ (gint) gtkpspeller);
+ else {
+ gtkpspellcheckers->checkers = g_slist_remove(gtkpspellcheckers->checkers,
+ gtkpspeller);
- if (!pspell_manager_check(gtkpspell->checker, word, -1)) {
- suggestions = pspell_manager_suggest(gtkpspell->checker, (const char *)word, -1);
- elements = pspell_word_list_elements(suggestions);
- /* First one must be the misspelled (why this ?) */
- list = g_list_append(list, g_strdup(word));
+ debug_print(_("Pspell: Deleting gtkpspeller %0x.\n"),
+ (gint) gtkpspeller);
- while ((newword = pspell_string_emulation_next(elements)) != NULL)
- list = g_list_append(list, g_strdup(newword));
- return list;
+ gtkpspeller_real_delete(gtkpspeller);
}
- return NULL;
+
+ debug_print(_("Pspell: number of existing checkers %d\n"),
+ g_slist_length(gtkpspellcheckers->checkers));
+
+ return gtkpspeller;
}
-/* misspelled_test() - Just test if word is correctly spelled */
-static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word)
+static GtkPspeller *gtkpspeller_real_delete(GtkPspeller *gtkpspeller)
{
- return pspell_manager_check(gtkpspell->checker, word, -1) ? 0 : 1;
-}
+ g_return_val_if_fail(gtkpspeller, NULL);
+ g_return_val_if_fail(gtkpspeller->checker, NULL);
+ pspell_manager_save_all_word_lists(gtkpspeller->checker);
-static gboolean iswordsep(unsigned char c)
-{
- return !isalpha(c) && c != '\'';
+ delete_pspell_manager(gtkpspeller->checker);
+
+ dictionary_delete(gtkpspeller->dictionary);
+
+ g_free(gtkpspeller);
+
+ return NULL;
}
-static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos)
+/*****************************************************************************/
+/* Checker configuration */
+
+static gboolean set_dictionary(PspellConfig *config, Dictionary *dict)
{
- guchar a;
- gchar *text;
+ gchar *language = NULL;
+ gchar *spelling = NULL;
+ gchar *jargon = NULL;
+ gchar *module = NULL;
+ gchar *end = NULL;
+ gchar buf[BUFSIZE];
- text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1);
- if (text == NULL)
- return 0;
- a = (guchar) *text;
+ g_return_val_if_fail(config, FALSE);
+ g_return_val_if_fail(dict, FALSE);
+
+ strncpy(buf, dict->fullname, BUFSIZE-1);
+ buf[BUFSIZE-1] = 0x00;
+
+ buf[dict->dictname - dict->fullname] = 0x00;
+
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("rem-all-word-list-path", "");
+ debug_print(_("Pspell: removed all paths.\n"));
+
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("add-word-list-path", buf);
+ debug_print(_("Pspell: added path %s.\n"), buf);
+
+ strncpy(buf, dict->dictname, BUFSIZE-1);
+ language = buf;
+
+ if ((module = strrchr(buf, '-')) != NULL) {
+ module++;
+ }
+ if ((spelling = strchr(language, '-')) != NULL)
+ *spelling++ = 0x00;
+ if (spelling != module) {
+ if ((end = strchr(spelling, '-')) != NULL) {
+ *end++ = 0x00;
+ jargon = end;
+ if (jargon != module)
+ if ((end = strchr(jargon, '-')) != NULL)
+ *end = 0x00;
+ else
+ jargon = NULL;
+ else
+ jargon = NULL;
+ }
+ else
+ spelling = NULL;
+ }
+ else
+ spelling = NULL;
+
+ debug_print(_("Pspell: Language: %s, spelling: %s, jargon: %s, module: %s\n"),
+ language, spelling, jargon, module);
+
+ if (language)
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("language-tag", language);
+
+ if (spelling)
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("spelling", spelling);
+
+ if (jargon)
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("jargon", jargon);
+
+ if (module) {
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("rem-all-module-search-order", "");
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("add-module-search-order", module);
+ }
+
+ if (dict->encoding) {
+ gchar *pspell_enc;
+
+ pspell_enc = convert_to_pspell_encoding (dict->encoding);
+ pspell_config_replace(config, "encoding", (const char *) pspell_enc);
+ g_free(pspell_enc);
+
+ RETURN_FALSE_IF_CONFIG_ERROR();
+ }
+
+ return TRUE;
+}
+
+guchar *gtkpspell_get_dict(GtkPspell *gtkpspell)
+{
+
+ g_return_val_if_fail(gtkpspell->gtkpspeller->config, NULL);
+ g_return_val_if_fail(gtkpspell->gtkpspeller->dictionary, NULL);
+
+ return g_strdup(gtkpspell->gtkpspeller->dictionary->dictname);
+}
+
+guchar *gtkpspell_get_path(GtkPspell *gtkpspell)
+{
+ guchar *path;
+ Dictionary *dict;
+
+ g_return_val_if_fail(gtkpspell->gtkpspeller->config, NULL);
+ g_return_val_if_fail(gtkpspell->gtkpspeller->dictionary, NULL);
+
+ dict = gtkpspell->gtkpspeller->dictionary;
+ path = g_strndup(dict->fullname, dict->dictname - dict->fullname);
+
+ return path;
+}
+
+/* set_sug_mode_cb() - Menu callback : Set the suggestion mode */
+static void set_sug_mode_cb(GtkMenuItem *w, GtkPspell *gtkpspell)
+{
+ char *themode;
+
+ if (gtkpspell->gtkpspeller->ispell) return;
+
+ gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode);
+
+ set_real_sug_mode(gtkpspell, themode);
+
+ if (gtkpspell->config_menu)
+ populate_submenu(gtkpspell, gtkpspell->config_menu);
+}
+static void set_real_sug_mode(GtkPspell *gtkpspell, const char *themode)
+{
+ gint result;
+ gint mode = PSPELL_FASTMODE;
+ g_return_if_fail(gtkpspell);
+ g_return_if_fail(gtkpspell->gtkpspeller);
+ g_return_if_fail(themode);
+
+ if (!strcmp(themode,_("Normal Mode")))
+ mode = PSPELL_NORMALMODE;
+ else if (!strcmp( themode,_("Bad Spellers Mode")))
+ mode = PSPELL_BADSPELLERMODE;
+
+ result = gtkpspell_set_sug_mode(gtkpspell, mode);
+
+ if(!result) {
+ debug_print(_("Pspell: error while changing suggestion mode:%s\n"),
+ gtkpspellcheckers->error_message);
+ gtkpspell_checkers_reset_error();
+ }
+}
+
+/* gtkpspell_set_sug_mode() - Set the suggestion mode */
+gboolean gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gint themode)
+{
+ PspellConfig *config;
+
+ g_return_val_if_fail(gtkpspell, FALSE);
+ g_return_val_if_fail(gtkpspell->gtkpspeller, FALSE);
+ g_return_val_if_fail(gtkpspell->gtkpspeller->config, FALSE);
+
+ debug_print("Pspell: setting sug mode of gtkpspeller %0x to %d\n",
+ gtkpspell->gtkpspeller, themode);
+ config = gtkpspell->gtkpspeller->config;
+ switch (themode) {
+ case PSPELL_FASTMODE:
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "fast");
+ break;
+ case PSPELL_NORMALMODE:
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "normal");
+ break;
+ case PSPELL_BADSPELLERMODE:
+ CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode",
+ "bad-spellers");
+ break;
+ default:
+ gtkpspellcheckers->error_message =
+ g_strdup(_("Unknown suggestion mode."));
+ return FALSE;
+ }
+
+ gtkpspell->gtkpspeller->sug_mode = themode;
+ gtkpspell->default_sug_mode = themode;
+
+ return TRUE;
+}
+
+/* misspelled_suggest() - Create a suggestion list for word */
+static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word)
+{
+ const guchar *newword;
+ GList *list = NULL;
+ const PspellWordList *suggestions;
+ PspellStringEmulation *elements;
+
+ g_return_val_if_fail(word, NULL);
+
+ if (!pspell_manager_check(gtkpspell->gtkpspeller->checker, word, -1)) {
+ free_suggestions_list(gtkpspell);
+
+ suggestions = pspell_manager_suggest(gtkpspell->gtkpspeller->checker,
+ (const char *)word, -1);
+ elements = pspell_word_list_elements(suggestions);
+ list = g_list_append(list, g_strdup(word));
+
+ while ((newword = pspell_string_emulation_next(elements)) != NULL)
+ list = g_list_append(list, g_strdup(newword));
+
+ gtkpspell->max_sug = g_list_length(list) - 1;
+ gtkpspell->suggestions_list = list;
+
+ return list;
+ }
+
+ free_suggestions_list(gtkpspell);
+
+ return NULL;
+}
+
+/* misspelled_test() - Just test if word is correctly spelled */
+static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word)
+{
+ return pspell_manager_check(gtkpspell->gtkpspeller->checker, word, -1) ? 0 : 1;
+}
+
+
+static gboolean iswordsep(unsigned char c)
+{
+ return !isalpha(c) && c != '\'';
+}
+
+static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos)
+{
+ guchar a;
+ gchar *text;
+
+ text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1);
+ if (text == NULL)
+ return 0;
+ a = (guchar) *text;
g_free(text);
return a;
}
/* get_word_from_pos () - return the word pointed to. */
/* Handles correctly the quotes. */
-static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos,
- unsigned char* buf,
- int *pstart, int *pend)
+static gboolean get_word_from_pos(GtkPspell *gtkpspell, gint pos,
+ unsigned char* buf, gint buflen,
+ gint *pstart, gint *pend)
{
/* TODO : when correcting a word into quotes, change the color of */
/* the quotes too, as may be they were highlighted before. To do */
- /* so, we can use two others pointers that points to the whole */
+ /* this, we can use two others pointers that points to the whole */
/* word including quotes. */
gint start,
end;
guchar c;
- GtkXText *gtktext;
+ GtkSText *gtktext;
gtktext = gtkpspell->gtktext;
if (iswordsep(get_text_index_whar(gtkpspell, pos)))
}
start++;
- for (end = pos; end < gtk_xtext_get_length(gtktext); end++) {
+ for (end = pos; end < gtk_stext_get_length(gtktext); end++) {
c = get_text_index_whar(gtkpspell, end);
if (c == '\'') {
- if (end < gtk_xtext_get_length(gtktext)) {
+ if (end < gtk_stext_get_length(gtktext)) {
if (!isalpha(get_text_index_whar(gtkpspell, end + 1))) {
/* end_quote = TRUE; */
break;
break;
}
- if (buf) {
- for (pos = start; pos < end; pos++)
- buf[pos - start] = get_text_index_whar(gtkpspell, pos);
- buf[pos - start] = 0;
- }
-
if (pstart)
*pstart = start;
if (pend)
*pend = end;
- return TRUE;
-}
-
-static gboolean get_curword(GtkPspell *gtkpspell, unsigned char* buf,
- int *pstart, int *pend)
-{
- int pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
- return get_word_from_pos(gtkpspell, pos, buf, pstart, pend);
-}
-
-static void change_color(GtkPspell * gtkpspell,
- int start, int end,
- GdkColor *color)
-{
- char *newtext;
- GtkXText *gtktext;
-
- g_return_if_fail(start < end);
-
- gtktext = gtkpspell->gtktext;
-
- gtk_xtext_freeze(gtktext);
- newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end);
- if (newtext) {
- gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_insert_cb),
- gtkpspell);
- gtk_xtext_set_point(gtktext, start);
- gtk_xtext_forward_delete(gtktext, end - start);
-
- gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start);
- gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_insert_cb),
- gtkpspell);
- g_free(newtext);
+ if (buf) {
+ if (end - start < buflen) {
+ for (pos = start; pos < end; pos++)
+ buf[pos - start] = get_text_index_whar(gtkpspell, pos);
+ buf[pos - start] = 0;
+ } else return FALSE;
}
- gtk_xtext_thaw(gtktext);
+
+ return TRUE;
}
-static gboolean check_at(GtkPspell *gtkpspell, int from_pos)
+static gboolean check_at(GtkPspell *gtkpspell, gint from_pos)
{
- int start, end;
- unsigned char buf[BUFSIZE];
- GtkXText *gtktext;
+ gint start, end;
+ unsigned char buf[GTKPSPELLWORDSIZE];
+ GtkSText *gtktext;
g_return_val_if_fail(from_pos >= 0, FALSE);
gtktext = gtkpspell->gtktext;
- if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end))
+ if (!get_word_from_pos(gtkpspell, from_pos, buf, sizeof(buf),
+ &start, &end))
return FALSE;
- strncpy(gtkpspell->theword, buf, BUFSIZE - 1);
- gtkpspell->theword[BUFSIZE - 1] = 0;
-
if (misspelled_test(gtkpspell, buf)) {
- change_color(gtkpspell, start, end, &(gtkpspell->highlight));
+ strncpy(gtkpspell->theword, buf, GTKPSPELLWORDSIZE - 1);
+ gtkpspell->theword[GTKPSPELLWORDSIZE - 1] = 0;
+ gtkpspell->start_pos = start;
+ gtkpspell->end_pos = end;
+ free_suggestions_list(gtkpspell);
+
+ change_color(gtkpspell, start, end, buf, &(gtkpspell->highlight));
return TRUE;
} else {
- change_color(gtkpspell, start, end, NULL);
+ change_color(gtkpspell, start, end, buf, NULL);
return FALSE;
}
}
+static gboolean check_next_prev(GtkPspell *gtkpspell, gboolean forward)
+{
+ gint pos;
+ gint minpos;
+ gint maxpos;
+ gint direc = -1;
+ gboolean misspelled;
+
+ minpos = 0;
+ maxpos = gtkpspell->end_check_pos;
+
+ if (forward) {
+ minpos = -1;
+ direc = 1;
+ maxpos--;
+ }
+
+ pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
+ gtkpspell->orig_pos = pos;
+ while (iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
+ pos += direc;
+ while (!(misspelled = check_at(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
+ {
+ while (!iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
+ pos += direc;
+
+ while (iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
+ pos += direc;
+ }
+ if (misspelled) {
+ misspelled_suggest(gtkpspell, gtkpspell->theword);
+ if (forward)
+ gtkpspell->orig_pos = gtkpspell->end_pos;
+ gtk_stext_set_point(GTK_STEXT(gtkpspell->gtktext),
+ gtkpspell->end_pos);
+ gtk_editable_set_position(GTK_EDITABLE(gtkpspell->gtktext),
+ gtkpspell->end_pos);
+ gtk_menu_popup(make_sug_menu(gtkpspell), NULL, NULL,
+ set_menu_pos, gtkpspell, 0, GDK_CURRENT_TIME);
+ } else {
+ reset_theword_data(gtkpspell);
+
+ gtkpspell_alert_dialog(_("No misspelled word found."));
+ gtk_stext_set_point(GTK_STEXT(gtkpspell->gtktext), gtkpspell->orig_pos);
+ gtk_editable_set_position(GTK_EDITABLE(gtkpspell->gtktext), gtkpspell->orig_pos);
+ }
+ return misspelled;
+}
+
+void gtkpspell_check_backwards(GtkPspell *gtkpspell)
+{
+ gtkpspell->continue_check = NULL;
+ gtkpspell->end_check_pos = gtk_stext_get_length(GTK_STEXT(gtkpspell->gtktext));
+ check_next_prev(gtkpspell, FALSE);
+}
-static void check_all(GtkWidget *w, GtkPspell *gtkpspell)
+void gtkpspell_check_forwards_go(GtkPspell *gtkpspell)
{
- gtkpspell_check_all(gtkpspell);
+
+ gtkpspell->continue_check = NULL;
+ gtkpspell->end_check_pos = gtk_stext_get_length(GTK_STEXT(gtkpspell->gtktext));
+ check_next_prev(gtkpspell, TRUE);
}
+void gtkpspell_check_all(GtkPspell *gtkpspell)
+{
+ GtkWidget *gtktext;
+
+ gint start, end;
+
+ g_return_if_fail(gtkpspell);
+ g_return_if_fail(gtkpspell->gtktext);
+
+ gtktext = (GtkWidget *) gtkpspell->gtktext;
+
+ start = 0;
+ end = gtk_stext_get_length(GTK_STEXT(gtktext));
+
+ if (GTK_EDITABLE(gtktext)->has_selection) {
+ start = GTK_EDITABLE(gtktext)->selection_start_pos;
+ end = GTK_EDITABLE(gtktext)->selection_end_pos;
+ }
+
+ if (start > end) {
+ gint tmp;
+ tmp = start;
+ start = end;
+ end = tmp;
+ }
+
+
+ gtk_editable_set_position(GTK_EDITABLE(gtktext), start);
+ gtk_stext_set_point(GTK_STEXT(gtktext), start);
+
+ gtkpspell->continue_check = continue_check;
+ gtkpspell->end_check_pos = end;
+
+ gtkpspell->misspelled = check_next_prev(gtkpspell, TRUE);
+
+}
+
+static void continue_check(gpointer *data)
+{
+ GtkPspell *gtkpspell = (GtkPspell *) data;
+ gint pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
+
+ if (pos < gtkpspell->end_check_pos && gtkpspell->misspelled)
+ gtkpspell->misspelled = check_next_prev(gtkpspell, TRUE);
+ else
+ gtkpspell->continue_check = NULL;
+
+}
-void gtkpspell_check_all(GtkPspell *gtkpspell)
+void gtkpspell_highlight_all(GtkPspell *gtkpspell)
{
guint origpos;
guint pos = 0;
guint len;
- float adj_value;
- GtkXText *gtktext;
+ GtkSText *gtktext;
+ gfloat adj_value;
-
- if (!gtkpspell_running(gtkpspell)) return ;
- gtktext = gtkpspell->gtktext;
+ g_return_if_fail(gtkpspell->gtkpspeller->checker);
- len = gtk_xtext_get_length(gtktext);
+ gtktext = gtkpspell->gtktext;
adj_value = gtktext->vadj->value;
- gtk_xtext_freeze(gtktext);
+
+ len = gtk_stext_get_length(gtktext);
+
+ gtk_stext_freeze(gtktext);
+
origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
- gtk_editable_set_position(GTK_EDITABLE(gtktext),0);
+
+/* gtk_editable_set_position(GTK_EDITABLE(gtktext), 0);*/
+
while (pos < len) {
- while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos)))
+ while (pos < len &&
+ iswordsep(get_text_index_whar(gtkpspell, pos)))
pos++;
- while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos)))
+ while (pos < len &&
+ !iswordsep(get_text_index_whar(gtkpspell, pos)))
pos++;
if (pos > 0)
check_at(gtkpspell, pos - 1);
}
- gtk_xtext_thaw(gtktext);
+ gtk_stext_thaw(gtktext);
gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
- gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
+ gtk_stext_set_point(GTK_STEXT(gtktext), origpos);
+ gtk_adjustment_set_value(gtktext->vadj, adj_value);
+ /*gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);*/
}
-static void entry_insert_cb(GtkXText *gtktext, gchar *newtext,
- guint len, guint *ppos,
- GtkPspell * gtkpspell)
+static void replace_with_supplied_word_cb(GtkWidget *w, GtkPspell *gtkpspell)
{
- guint origpos;
- if (!gtkpspell_running(gtkpspell))
- return;
+ unsigned char *newword;
+ GdkEvent *e= (GdkEvent *) gtk_get_current_event();
+
+ newword = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->replace_entry), 0, -1);
+
+ if (strcmp(newword, gtkpspell->theword)) {
+ replace_real_word(gtkpspell, newword);
+
+ if ((e->type == GDK_KEY_PRESS &&
+ ((GdkEventKey *) e)->state & GDK_MOD1_MASK)) {
+ pspell_manager_store_replacement(gtkpspell->gtkpspeller->checker,
+ gtkpspell->theword, -1,
+ newword, -1);
+ }
+ gtkpspell->replace_entry = NULL;
+ }
- /* We must insert ourself the character to impose the */
- /* color of the inserted character to be default */
- /* Never mess with set_insertion when frozen */
- gtk_xtext_freeze(gtktext);
- gtk_xtext_backward_delete(GTK_XTEXT(gtktext), len);
- gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newtext, len);
- *ppos = gtk_xtext_get_point(GTK_XTEXT(gtktext));
-
- if (iswordsep(newtext[0])) {
- /* did we just end a word? */
- if (*ppos >= 2)
- check_at(gtkpspell, *ppos - 2);
+ g_free(newword);
- /* did we just split a word? */
- if (*ppos < gtk_xtext_get_length(gtktext))
- check_at(gtkpspell, *ppos + 1);
- } else {
- /* check as they type, *except* if they're typing at the end (the most
- * common case.
- */
- if (*ppos < gtk_xtext_get_length(gtktext)
- && !iswordsep(get_text_index_whar(gtkpspell, *ppos)))
- check_at(gtkpspell, *ppos - 1);
- }
- gtk_xtext_thaw(gtktext);
- gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
+ set_point_continue(gtkpspell);
}
-static void entry_delete_cb(GtkXText *gtktext, gint start, gint end,
- GtkPspell *gtkpspell)
+
+static void replace_word_cb(GtkWidget *w, gpointer data)
{
- int origpos;
-
- if (!gtkpspell_running(gtkpspell))
- return;
+ unsigned char *newword;
+ GtkPspell *gtkpspell = (GtkPspell *) data;
+ GdkEvent *e= (GdkEvent *) gtk_get_current_event();
- origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
- if (start) {
- check_at(gtkpspell, start - 1);
- check_at(gtkpspell, start);
+
+ gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
+
+ replace_real_word(gtkpspell, newword);
+
+ if ((e->type == GDK_KEY_PRESS &&
+ ((GdkEventKey *) e)->state & GDK_MOD1_MASK) ||
+ (e->type == GDK_BUTTON_RELEASE &&
+ ((GdkEventButton *) e)->state & GDK_MOD1_MASK)) {
+ pspell_manager_store_replacement(gtkpspell->gtkpspeller->checker,
+ gtkpspell->theword, -1,
+ newword, -1);
}
- gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
- gtk_xtext_set_point(gtktext, origpos);
- gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
- /* this is to *UNDO* the selection, in case they were holding shift
- * while hitting backspace. */
+ gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
+
+ set_point_continue(gtkpspell);
}
-static void replace_word(GtkWidget *w, GtkPspell *gtkpspell)
+static void replace_real_word(GtkPspell *gtkpspell, gchar *newword)
{
- int start, end,oldlen, newlen;
- guint origpos;
- unsigned char *newword;
- unsigned char buf[BUFSIZE];
- guint pos;
- GtkXText *gtktext;
+ int oldlen, newlen, wordlen;
+ gint origpos;
+ gint pos;
+ gint start = gtkpspell->start_pos;
+ GtkSText *gtktext;
+ if (!newword) return;
+
gtktext = gtkpspell->gtktext;
- gtk_xtext_freeze(GTK_XTEXT(gtktext));
+ gtk_stext_freeze(GTK_STEXT(gtktext));
origpos = gtkpspell->orig_pos;
pos = origpos;
+ oldlen = gtkpspell->end_pos - gtkpspell->start_pos;
+ wordlen = strlen(gtkpspell->theword);
- gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
- newlen = strlen(newword);
-
- get_curword(gtkpspell, buf, &start, &end);
- oldlen = end - start;
+ newlen = strlen(newword); /* FIXME: multybyte characters? */
- gtk_xtext_set_point(GTK_XTEXT(gtktext), end);
- gtk_xtext_backward_delete(GTK_XTEXT(gtktext), end - start);
- gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newword, strlen(newword));
-
- if (end-start > 0 && gtkpspell->learn) {
- /* Just be sure the buffer ends somewhere... */
- buf[end-start] = 0;
- /* Learn from common misspellings */
- pspell_manager_store_replacement(gtkpspell->checker, buf,
- end-start, newword,
- strlen(newword));
- }
+ gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_insert_cb),
+ gtkpspell);
+ gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_delete_cb),
+ gtkpspell);
+ gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "delete-text",
+ gtkpspell->start_pos, gtkpspell->end_pos);
+ gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "insert-text",
+ newword, newlen, &start);
+
+ gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_insert_cb),
+ gtkpspell);
+ gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
+ GTK_SIGNAL_FUNC(entry_delete_cb),
+ gtkpspell);
+
/* Put the point and the position where we clicked with the mouse */
/* It seems to be a hack, as I must thaw,freeze,thaw the widget */
/* to let it update correctly the word insertion and then the */
/* point & position position. If not, SEGV after the first replacement */
/* If the new word ends before point, put the point at its end*/
- if (origpos-start <= oldlen && origpos-start >= 0) {
+ if (origpos - gtkpspell->start_pos < oldlen &&
+ origpos - gtkpspell->start_pos >= 0) {
/* Original point was in the word. */
- /* Put the insertion point in the same location */
- /* with respect to the new length */
- /* If the original position is still within the word, */
- /* then keep the original position. If not, move to the */
- /* end of the word */
- if (origpos-start > newlen)
- pos = start + newlen;
+ /* Let it there unless point is going to be outside of the word */
+ if (origpos - gtkpspell->start_pos >= newlen) {
+ pos = gtkpspell->start_pos + newlen;
+ }
}
- else if (origpos > end) {
+ else if (origpos >= gtkpspell->end_pos) {
/* move the position according to the change of length */
pos = origpos + newlen - oldlen;
}
- gtk_xtext_thaw(GTK_XTEXT(gtktext));
- gtk_xtext_freeze(GTK_XTEXT(gtktext));
- if (GTK_XTEXT(gtktext)->text_len < pos)
- pos = gtk_xtext_get_length(GTK_XTEXT(gtktext));
+
+ gtkpspell->end_pos = gtkpspell->start_pos + strlen(newword); /* FIXME: multibyte characters? */
+
+ gtk_stext_thaw(GTK_STEXT(gtktext));
+ gtk_stext_freeze(GTK_STEXT(gtktext));
+
+ if (GTK_STEXT(gtktext)->text_len < pos)
+ pos = gtk_stext_get_length(GTK_STEXT(gtktext));
+
gtkpspell->orig_pos = pos;
+
gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkpspell->orig_pos);
- gtk_xtext_set_point(GTK_XTEXT(gtktext),
+ gtk_stext_set_point(GTK_STEXT(gtktext),
gtk_editable_get_position(GTK_EDITABLE(gtktext)));
- gtk_xtext_thaw(GTK_XTEXT(gtktext));
+
+ gtk_stext_thaw(GTK_STEXT(gtktext));
}
/* Accept this word for this session */
-
-static void add_word_to_session(GtkWidget *w, GtkPspell *gtkpspell)
+static void add_word_to_session_cb(GtkWidget *w, gpointer data)
{
guint pos;
- GtkXText *gtkxtext;
-
- gtkxtext = gtkpspell->gtktext;
- gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
- pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
+ GtkSText *gtktext;
+ GtkPspell *gtkpspell = (GtkPspell *) data;
+ gtktext = gtkpspell->gtktext;
+
+ gtk_stext_freeze(GTK_STEXT(gtktext));
+
+ pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
- pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword, strlen(gtkpspell->theword));
+ pspell_manager_add_to_session(gtkpspell->gtkpspeller->checker,
+ gtkpspell->theword,
+ strlen(gtkpspell->theword));
- check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
+ check_at(gtkpspell, gtkpspell->start_pos);
- gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
- gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
- gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
- gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
- gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
-}
+ gtk_stext_thaw(gtkpspell->gtktext);
-/* add_word_to_personal() - add word to personal dict. */
+ gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
-static void add_word_to_personal(GtkWidget *w, GtkPspell *gtkpspell)
+ set_point_continue(gtkpspell);
+}
+
+/* add_word_to_personal_cb() - add word to personal dict. */
+static void add_word_to_personal_cb(GtkWidget *w, gpointer data)
{
- guint pos;
- GtkXText *gtkxtext;
-
- gtkxtext = gtkpspell->gtktext;
+ GtkSText *gtktext;
+ GtkPspell *gtkpspell = (GtkPspell *) data;
+ gtktext = gtkpspell->gtktext;
- gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
- pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
+ gtk_stext_freeze(GTK_STEXT(gtktext));
- pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword));
+ pspell_manager_add_to_personal(gtkpspell->gtkpspeller->checker,
+ gtkpspell->theword,
+ strlen(gtkpspell->theword));
- check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
- gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
- gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
- gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
- gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
- gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
+ check_at(gtkpspell, gtkpspell->start_pos);
+
+ gtk_stext_thaw(gtkpspell->gtktext);
+
+ gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
+ set_point_continue(gtkpspell);
}
-
-static GtkMenu *make_menu_config(GtkPspell *gtkpspell)
+static void deactivate_sug_menu_cb(GtkObject *w, gpointer data)
{
- GtkWidget *menu, *item, *submenu;
+ GtkMenuShell *menu_shell = GTK_MENU_SHELL(data);
+ debug_print("Destroying %0x\n", w);
+ gtk_menu_shell_deactivate(menu_shell);
+}
-
- menu = gtk_menu_new();
-
- item = gtk_menu_item_new_with_label(_("Spell check all"));
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
- gtk_signal_connect(GTK_OBJECT(item),"activate",
- GTK_SIGNAL_FUNC(check_all),
+static void replace_with_create_dialog_cb(GtkWidget *w, gpointer data)
+{
+ GtkWidget *dialog;
+ GtkWidget *label;
+ GtkWidget *hbox;
+ GtkWidget *entry;
+ GtkWidget *ok_button;
+ GtkWidget *cancel_button;
+ gchar *thelabel;
+ gint xx, yy;
+ GtkPspell *gtkpspell = (GtkPspell *) data;
+
+ gdk_window_get_origin((GTK_WIDGET(w)->parent)->window, &xx, &yy);
+
+ gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
+
+ dialog = gtk_dialog_new();
+ gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
+ gtk_window_set_title(GTK_WINDOW(dialog),_("Replace unknown word"));
+ gtk_widget_set_uposition(dialog, xx, yy);
+
+ gtk_signal_connect_object(GTK_OBJECT(dialog), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT(dialog));
+
+ hbox = gtk_hbox_new(FALSE, 0);
+ gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
+
+ thelabel = g_strdup_printf(_("Replace \"%s\" with: "),
+ gtkpspell->theword);
+ label = gtk_label_new(thelabel);
+ g_free(thelabel);
+ gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+
+ entry = gtk_entry_new();
+ gtkpspell->replace_entry = entry;
+ gtk_entry_set_text(GTK_ENTRY(entry), gtkpspell->theword);
+ gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
+ gtk_signal_connect(GTK_OBJECT(entry), "activate",
+ GTK_SIGNAL_FUNC(replace_with_supplied_word_cb),
gtkpspell);
-
-
- item = gtk_menu_item_new();
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu),item);
-
- submenu = gtk_menu_new();
- item = gtk_menu_item_new_with_label(_("Change dictionary"));
- gtk_widget_show(item);
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
- gtk_menu_append(GTK_MENU(menu), item);
-
- /* Dict list */
- if (gtkpspell->dictionary_list==NULL)
- gtkpspell->dictionary_list = gtkpspell_get_dictionary_list(gtkpspell->path);
-
- {
- GtkWidget * curmenu = submenu;
- int count = 0;
- Dictionary *dict;
- GSList *tmp;
-
- tmp = gtkpspell->dictionary_list;
- for (tmp = gtkpspell->dictionary_list; tmp != NULL; tmp =g_slist_next(tmp)) {
- dict = (Dictionary *) tmp->data;
- item = gtk_check_menu_item_new_with_label(dict->name);
- if (strcmp2(dict->name, gtkpspell->dict))
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
- else {
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
- gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
- }
- gtk_menu_append(GTK_MENU(curmenu), item);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(menu_change_dict),
- gtkpspell);
- gtk_widget_show(item);
- count++;
- if (count == MENUCOUNT) {
- GtkWidget *newmenu;
- newmenu = gtk_menu_new();
- item = gtk_menu_item_new_with_label(_("More..."));
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), newmenu);
- gtk_menu_append(GTK_MENU(curmenu), item);
- gtk_widget_show(item);
- curmenu = newmenu;
- count = 0;
- }
- }
- }
-
- item = gtk_menu_item_new();
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
-
- item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
- if (gtkpspell->mode == PSPELL_FASTMODE) {
- gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
+ gtk_signal_connect_object(GTK_OBJECT(entry), "activate",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT(dialog));
+ gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
+
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE,
+ TRUE, 0);
+ if (!gtkpspell->gtkpspeller->ispell) {
+ label = gtk_label_new(_("Holding down MOD1 key while pressing Enter\nwill learn from mistake.\n"));
+ gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
+ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
+ gtk_misc_set_padding(GTK_MISC(label), 8, 0);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label,
+ TRUE, TRUE, 0);
}
- else
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(set_sug_mode),
- gtkpspell);
- item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu),item);
- if (gtkpspell->mode == PSPELL_NORMALMODE) {
- gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
- }
- else
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(set_sug_mode),
- gtkpspell);
-
- item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
- if (gtkpspell->mode==PSPELL_BADSPELLERMODE) {
- gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
- }
- else
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(set_sug_mode),
- gtkpspell);
- item = gtk_menu_item_new();
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ hbox = gtk_hbox_new(TRUE, 0);
- item = gtk_check_menu_item_new_with_label(_("Learn from mistakes"));
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),
- gtkpspell->learn);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(set_learn_mode), gtkpspell);
-
-
- return GTK_MENU(menu);
-}
-
-/* make_menu() - Add menus to accept this word for this session and to add it to
- * personal dictionary */
-static GtkMenu *make_menu(GList *l, GtkPspell *gtkpspell)
-{
- GtkWidget *menu, *item;
- unsigned char *caption;
- GtkXText * gtktext;
-
- gtktext = gtkpspell->gtktext;
+ ok_button = gtk_button_new_with_label(_("OK"));
+ gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 8);
+ gtk_signal_connect(GTK_OBJECT(ok_button), "clicked",
+ GTK_SIGNAL_FUNC(replace_with_supplied_word_cb),
+ gtkpspell);
+ gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT(dialog));
- menu = gtk_menu_new();
- caption = g_strdup_printf(_("Accept `%s' for this session"), (unsigned char*)l->data);
- item = gtk_menu_item_new_with_label(caption);
- g_free(caption);
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ cancel_button = gtk_button_new_with_label(_("Cancel"));
+ gtk_box_pack_start(GTK_BOX(hbox), cancel_button, TRUE, TRUE, 8);
+ gtk_signal_connect_object(GTK_OBJECT(cancel_button), "clicked",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT(dialog));
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(add_word_to_session),
- gtkpspell);
+ gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), hbox);
- caption = g_strdup_printf(_("Add `%s' to personal dictionary"), (char*)l->data);
- item = gtk_menu_item_new_with_label(caption);
- g_free(caption);
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ gtk_widget_grab_focus(entry);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(add_word_to_personal),
- gtkpspell);
-
- item = gtk_menu_item_new();
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
- l = l->next;
- if (l == NULL) {
- item = gtk_menu_item_new_with_label(_("(no suggestions)"));
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
- } else {
- GtkWidget *curmenu = menu;
- int count = 0;
-
- do {
- if (l->data == NULL && l->next != NULL) {
- count = 0;
- curmenu = gtk_menu_new();
- item = gtk_menu_item_new_with_label(_("Others..."));
- gtk_widget_show(item);
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
- gtk_menu_append(GTK_MENU(curmenu), item);
- l = l->next;
- } else if (count > MENUCOUNT) {
- count -= MENUCOUNT;
- item = gtk_menu_item_new_with_label(_("More..."));
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(curmenu), item);
- curmenu = gtk_menu_new();
- gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
- }
- item = gtk_menu_item_new_with_label((unsigned char*)l->data);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(replace_word), gtkpspell);
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(curmenu), item);
- count++;
- } while ((l = l->next) != NULL);
- }
- return GTK_MENU(menu);
+ gtk_widget_show_all(dialog);
}
-static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb)
+void gtkpspell_uncheck_all(GtkPspell * gtkpspell)
{
- unsigned char buf[BUFSIZE];
- GList *list, *l;
- GtkXText * gtktext;
+ gint origpos;
+ gchar *text;
+ gfloat adj_value;
+ GtkSText *gtktext;
gtktext = gtkpspell->gtktext;
- gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
-
- if (!(eb->state & GDK_SHIFT_MASK))
- if (get_curword(gtkpspell, buf, NULL, NULL)) {
- if (buf != NULL) {
- strncpy(gtkpspell->theword, buf, BUFSIZE - 1);
- gtkpspell->theword[BUFSIZE - 1] = 0;
- list = misspelled_suggest(gtkpspell, buf);
- if (list != NULL) {
- gtk_menu_popup(make_menu(list, gtkpspell), NULL, NULL, NULL, NULL,
- eb->button, eb->time);
- for (l = list; l != NULL; l = l->next)
- g_free(l->data);
- g_list_free(list);
- return;
- }
- }
- }
- gtk_menu_popup(make_menu_config(gtkpspell),NULL,NULL,NULL,NULL,
- eb->button,eb->time);
-}
-
-/* ok, this is pretty wacky:
- * we need to let the right-mouse-click go through, so it moves the cursor,
- * but we *can't* let it go through, because GtkText interprets rightclicks as
- * weird selection modifiers.
- *
- * so what do we do? forge rightclicks as leftclicks, then popup the menu.
- * HACK HACK HACK.
- */
-static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell *gtkpspell)
-{
- GdkEventButton *eb;
- gboolean retval;
-
- if (!gtkpspell_running(gtkpspell))
- return FALSE;
- if (e->type != GDK_BUTTON_PRESS)
- return FALSE;
- eb = (GdkEventButton*) e;
+ adj_value = gtktext->vadj->value;
- if (eb->button != 3)
- return FALSE;
+ gtk_stext_freeze(gtktext);
- /* forge the leftclick */
- eb->button = 1;
+ origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
- gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(button_press_intercept_cb),
- gtkpspell);
- gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
- e, &retval);
- gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(button_press_intercept_cb),
- gtkpspell);
- gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
-
- /* now do the menu wackiness */
- popup_menu(gtkpspell, eb);
- gtk_grab_remove(GTK_WIDGET(gtktext));
- return TRUE;
-}
+ text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
-void gtkpspell_uncheck_all(GtkPspell * gtkpspell)
-{
- int origpos;
- unsigned char *text;
- float adj_value;
- GtkXText *gtktext;
-
- gtktext=gtkpspell->gtktext;
+ gtk_stext_set_point(gtktext, 0);
+ gtk_stext_forward_delete(gtktext, gtk_stext_get_length(gtktext));
+ gtk_stext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
- adj_value = gtktext->vadj->value;
- gtk_xtext_freeze(gtktext);
- origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
- text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
- gtk_xtext_set_point(gtktext, 0);
- gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext));
- gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
- gtk_xtext_thaw(gtktext);
+ gtk_stext_thaw(gtktext);
gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
+ gtk_stext_set_point(gtktext, origpos);
gtk_adjustment_set_value(gtktext->vadj, adj_value);
-}
-void gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *gtktext)
-{
- gtkpspell->gtktext = gtktext;
- gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text",
- GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
- gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
- GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
- gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
- GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
+ g_free(text);
- allocate_color(gtkpspell);
-
}
-void gtkpspell_detach(GtkPspell * gtkpspell)
+static void toggle_check_while_typing_cb(GtkWidget *w, gpointer data)
{
- GtkXText * gtktext;
-
- gtktext =gtkpspell->gtktext;
-/* if (prefs_common.auto_makepspell) { */
- gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
- gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
-/* }; */
- gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
+ GtkPspell *gtkpspell = (GtkPspell *) data;
- gtkpspell_uncheck_all(gtkpspell);
-}
+ gtkpspell->check_while_typing = gtkpspell->check_while_typing == FALSE;
+ if (!gtkpspell->check_while_typing)
+ gtkpspell_uncheck_all(gtkpspell);
-/*** Sylpheed (Claws) ***/
+ if (gtkpspell->config_menu)
+ populate_submenu(gtkpspell, gtkpspell->config_menu);
+}
static GSList *create_empty_dictionary_list(void)
{
GSList *list = NULL;
Dictionary *dict;
-
+
dict = g_new0(Dictionary, 1);
- dict->name = g_strdup(_("None"));
+ dict->fullname = g_strdup(_("None"));
+ dict->dictname = dict->fullname;
+ dict->encoding = NULL;
return g_slist_append(list, dict);
}
/* gtkpspell_get_dictionary_list() - returns list of dictionary names */
-GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path)
+GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path, gint refresh)
{
GSList *list;
gchar *dict_path, *tmp, *prevdir;
- GSList *walk;
+ gchar tmpname[BUFSIZE];
Dictionary *dict;
DIR *dir;
struct dirent *ent;
+ if (!gtkpspellcheckers)
+ gtkpspellcheckers = gtkpspell_checkers_new();
+
+ if (gtkpspellcheckers->dictionary_list && !refresh)
+ return gtkpspellcheckers->dictionary_list;
+ else
+ gtkpspell_free_dictionary_list(gtkpspellcheckers->dictionary_list);
+
list = NULL;
#ifdef USE_THREADS
#warning TODO: no directory change
#endif
- dict_path=g_strdup(pspell_path);
- prevdir = g_get_current_dir();
+ dict_path = g_strdup(pspell_path);
+ prevdir = g_get_current_dir();
if (chdir(dict_path) <0) {
- FILE_OP_ERROR(dict_path, "chdir");
+ debug_print(_("Pspell: error when searching for dictionaries:\n%s\n"),
+ g_strerror(errno));
g_free(prevdir);
g_free(dict_path);
- return create_empty_dictionary_list();
+ gtkpspellcheckers->dictionary_list = create_empty_dictionary_list();
+ return gtkpspellcheckers->dictionary_list;
}
- debug_print(_("Checking for dictionaries in %s\n"), dict_path);
+ debug_print(_("Pspell: checking for dictionaries in %s\n"), dict_path);
if (NULL != (dir = opendir("."))) {
while (NULL != (ent = readdir(dir))) {
/* search for pwli */
- if (NULL != (tmp = strstr(ent->d_name, ".pwli"))) {
+ if ((NULL != (tmp = strstr2(ent->d_name, ".pwli"))) &&
+ (tmp[5] == 0x00)) {
+ g_snprintf(tmpname, BUFSIZE, "%s%s",
+ G_DIR_SEPARATOR_S, ent->d_name);
+ tmpname[MIN(tmp - ent->d_name + 1, BUFSIZE-1)] = 0x00;
dict = g_new0(Dictionary, 1);
- dict->name = g_strndup(ent->d_name, tmp - ent->d_name);
- debug_print(_("Found dictionary %s\n"), dict->name);
- list = g_slist_insert_sorted(list, dict, (GCompareFunc) compare_dict);
+ dict->fullname = g_strdup_printf("%s%s",
+ dict_path,
+ tmpname);
+ dict->dictname = strrchr(dict->fullname,
+ G_DIR_SEPARATOR) + 1;
+ dict->encoding = NULL;
+ debug_print(_("Pspell: found dictionary %s %s\n"),
+ dict->fullname, dict->dictname);
+ list = g_slist_insert_sorted(list, dict,
+ (GCompareFunc) compare_dict);
}
}
closedir(dir);
}
else {
- FILE_OP_ERROR(dict_path, "opendir");
- debug_print(_("No dictionary found\n"));
+ debug_print(_("Pspell: error when searching for dictionaries.\nNo dictionary found.\n(%s)"),
+ g_strerror(errno));
list = create_empty_dictionary_list();
}
if(list==NULL){
- debug_print(_("No dictionary found\n"));
- list = create_empty_dictionary_list();
- }
+
+ debug_print(_("Pspell: error when searching for dictionaries.\nNo dictionary found."));
+ list = create_empty_dictionary_list();
+ }
chdir(prevdir);
g_free(dict_path);
g_free(prevdir);
+ gtkpspellcheckers->dictionary_list = list;
return list;
}
-/* compare_dict () - compare 2 dict names */
-
-static gint compare_dict(Dictionary *a, Dictionary *b)
-{
- guchar *alanguage, *blanguage,
- *aspelling, *bspelling,
- *ajargon , *bjargon ,
- *amodule , *bmodule ;
- guint aparts = 0, bparts = 0, i;
-
- for (i=0; i < strlen(a->name) ; i++)
- if (a->name[i]=='-')
- aparts++;
- for (i=0; i < strlen(b->name) ; i++)
- if (b->name[i]=='-')
- bparts++;
-
- if (aparts != bparts)
- return (aparts < bparts) ? -1 : +1 ;
- else
- return strcmp2(a->name, b->name);
-}
void gtkpspell_free_dictionary_list(GSList *list)
{
Dictionary *dict;
for (walk = list; walk != NULL; walk = g_slist_next(walk))
if (walk->data) {
dict = (Dictionary *) walk->data;
- if (dict->name)
- g_free(dict->name);
- g_free(dict);
+ dictionary_delete(dict);
}
g_slist_free(list);
}
+#if 0
static void dictionary_option_menu_item_data_destroy(gpointer data)
{
- gchar *str = (gchar *) data;
+ Dictionary *dict = (Dictionary *) data;
- if (str)
- g_free(str);
+ if (dict)
+ dictionary_delete(dict);
}
+#endif
GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path)
{
GtkWidget *menu;
Dictionary *dict;
- dict_list = gtkpspell_get_dictionary_list(pspell_path);
+ dict_list = gtkpspell_get_dictionary_list(pspell_path, TRUE);
g_return_val_if_fail(dict_list, NULL);
menu = gtk_menu_new();
for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
dict = (Dictionary *) tmp->data;
- item = gtk_menu_item_new_with_label(dict->name);
- if (dict->name)
- gtk_object_set_data_full(GTK_OBJECT(item), "dict_name",
- g_strdup(dict->name),
- dictionary_option_menu_item_data_destroy);
+ item = gtk_menu_item_new_with_label(dict->dictname);
+ gtk_object_set_data(GTK_OBJECT(item), "dict_name",
+ dict->fullname);
+
gtk_menu_append(GTK_MENU(menu), item);
gtk_widget_show(item);
}
gtk_widget_show(menu);
- gtkpspell_free_dictionary_list(dict_list);
-
return menu;
}
-
-
gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu)
{
GtkWidget *menuitem;
- gchar *result;
+ gchar *dict_fullname;
+ gchar *label;
g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
menuitem = gtk_menu_get_active(GTK_MENU(menu));
- result = gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name");
- g_return_val_if_fail(result, NULL);
- return g_strdup(result);
+ dict_fullname = (gchar *) gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name");
+ g_return_val_if_fail(dict_fullname, NULL);
+ label = g_strdup(dict_fullname);
+ return label;
}
-/* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-*
- * as needed by pspell. Returns an allocated string.
- */
-
-guchar *convert_to_pspell_encoding (const guchar *encoding)
+GtkWidget *gtkpspell_sugmode_option_menu_new(gint sugmode)
{
- guchar * pspell_encoding;
+ GtkWidget *menu;
+ GtkWidget *item;
- if (strstr2(encoding, "ISO-8859-")) {
- pspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
- }
- else
- if (!strcmp2(encoding, "US-ASCII"))
- pspell_encoding = g_strdup("iso8859-1");
- else
- pspell_encoding = g_strdup(encoding);
- return pspell_encoding;
-
-}
-static void allocate_color(GtkPspell *gtkpspell)
-{
+ menu = gtk_menu_new();
+ gtk_widget_show(menu);
- GdkColormap *gc;
- /* Color allocation */
- gc = gtk_widget_get_colormap(GTK_WIDGET(gtkpspell->gtktext));
+ item = gtk_menu_item_new_with_label(_("Fast Mode"));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_FASTMODE));
- if (gtkpspell->highlight.pixel)
- gdk_colormap_free_colors(gc, &(gtkpspell->highlight), 1);
+ item = gtk_menu_item_new_with_label(_("Normal Mode"));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_NORMALMODE));
+
+ item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_BADSPELLERMODE));
- gtkut_convert_int_to_gdk_color(prefs_common.misspelled_col,
- &(gtkpspell->highlight));
+ return menu;
+}
+
+void gtkpspell_sugmode_option_menu_set(GtkOptionMenu *optmenu, gint sugmode)
+{
+ g_return_if_fail(GTK_IS_OPTION_MENU(optmenu));
+
+ g_return_if_fail(sugmode == PSPELL_FASTMODE ||
+ sugmode == PSPELL_NORMALMODE ||
+ sugmode == PSPELL_BADSPELLERMODE);
+
+ gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
+}
+
+gint gtkpspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
+{
+ gint sugmode;
+ GtkWidget *item;
+
+ g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
+
+ item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
+
+ sugmode = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item), "sugmode"));
+
+ return sugmode;
+
+}
+#if 0 /* Experimenal */
+void gtkpspell_set_primary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding)
+{
+ g_return_if_fail(gtkpspell);
+ if (gtkpspell->dict1)
+ dictionary_delete(gtkpspell->dict1);
+ gtkpspell->dict1 = g_new(Dictionary, 1);
+ gtkpspell->dict1->fullname = g_strdup(dict);
+ gtkpspell->dict1->encoding = g_strdup(encoding);
+}
+
+void gtkpspell_set_secondary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding)
+{
+ g_return_if_fail(gtkpspell);
+ if (gtkpspell->dict2)
+ dictionary_delete(gtkpspell->dict2);
+ gtkpspell->dict2 = g_new(Dictionary, 1);
+ gtkpspell->dict2->fullname = g_strdup(dict);
+ gtkpspell->dict2->encoding = g_strdup(encoding);
+}
+
+gboolean gtkpspell_use_dict(GtkPspell *gtkpspell, Dictionary *dict)
+{
+ return TRUE;
+}
+
+gboolean gtkpspell_use_dictionary(GtkPspell *gtkpspell, gchar *dictpath, gchar *encoding)
+{
+ Dictionary *dict;
+ gboolean retval;
+
+ g_return_val_if_fail(gtkpspell, FALSE);
+ g_return_val_if_fail(dict, FALSE);
+ g_return_val_if_fail(encoding, FALSE);
+
+ dict = g_new(Dictionary, 1);
+
+ dict->fullname = g_strdup(dictpath);
+ dict->encoding = NULL; /* To be continued */
+
+ retval = gtkpspell_use_dict(gtkpspell, dict);
+
+ dictionary_delete(dict);
+
+ return retval;
+
+}
+
+gboolean gtkpspell_use_primary(GtkPspell *gtkpspell)
+{
+ g_return_val_if_fail(gtkpspell, FALSE);
+
+ return gtkpspell_use_dict(gtkpspell, gtkpspell->dict1);
+}
+
+gboolean gtkpspell_use_secondary(GtkPspell *gtkpspell)
+{
+ g_return_val_if_fail(gtkpspell, FALSE);
+
+ return gtkpspell_use_dict(gtkpspell, gtkpspell->dict2);
+}
+#endif
+
+/*****************************************************************************/
+
+static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb)
+{
+ GtkSText * gtktext;
+
+ gtktext = gtkpspell->gtktext;
+ gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
+
+ if (!(eb->state & GDK_SHIFT_MASK)) {
+ if (check_at(gtkpspell, gtkpspell->orig_pos)) {
+
+ gtk_editable_set_position(GTK_EDITABLE(gtktext),
+ gtkpspell->orig_pos);
+ gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
+
+ if (misspelled_suggest(gtkpspell, gtkpspell->theword)) {
+ gtk_menu_popup(make_sug_menu(gtkpspell),
+ NULL, NULL, NULL, NULL,
+ eb->button, GDK_CURRENT_TIME);
+
+ return;
+ }
+ } else {
+ gtk_editable_set_position(GTK_EDITABLE(gtktext),
+ gtkpspell->orig_pos);
+ gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
+ }
+ }
+
+ gtk_menu_popup(make_config_menu(gtkpspell),NULL,NULL,NULL,NULL,
+ eb->button, GDK_CURRENT_TIME);
+}
+
+/* make_sug_menu() - Add menus to accept this word for this session and to add it to
+ * personal dictionary */
+static GtkMenu *make_sug_menu(GtkPspell *gtkpspell)
+{
+ GtkWidget *menu, *item;
+ unsigned char *caption;
+ GtkSText *gtktext;
+ GList *l = gtkpspell->suggestions_list;
+ GtkAccelGroup *accel;
+
+
+ gtktext = gtkpspell->gtktext;
+
+ accel = gtk_accel_group_new();
+ menu = gtk_menu_new();
+
+ if (gtkpspell->sug_menu)
+ gtk_widget_destroy(gtkpspell->sug_menu);
+
+ gtkpspell->sug_menu = menu;
+
+ gtk_signal_connect(GTK_OBJECT(menu), "cancel",
+ GTK_SIGNAL_FUNC(cancel_menu_cb), gtkpspell);
+
+ caption = g_strdup_printf(_("Unknown word: \"%s\""),
+ (unsigned char*) l->data);
+ item = gtk_menu_item_new_with_label(caption);
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
+ g_free(caption);
+
+ item = gtk_menu_item_new();
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ item = gtk_menu_item_new_with_label(_("Accept in this session"));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_signal_connect(GTK_OBJECT(item), "activate",
+ GTK_SIGNAL_FUNC(add_word_to_session_cb),
+ gtkpspell);
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_space, GDK_MOD1_MASK,
+ GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
+
+ item = gtk_menu_item_new_with_label(_("Add to personal dictionary"));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_signal_connect(GTK_OBJECT(item), "activate",
+ GTK_SIGNAL_FUNC(add_word_to_personal_cb),
+ gtkpspell);
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_Return, GDK_MOD1_MASK,
+ GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
+
+ item = gtk_menu_item_new_with_label(_("Replace with..."));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ gtk_signal_connect(GTK_OBJECT(item), "activate",
+ GTK_SIGNAL_FUNC(replace_with_create_dialog_cb),
+ gtkpspell);
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_R, 0,
+ GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
+
+ item = gtk_menu_item_new();
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ l = l->next;
+ if (l == NULL) {
+ item = gtk_menu_item_new_with_label(_("(no suggestions)"));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+ } else {
+ GtkWidget *curmenu = menu;
+ gint count = 0;
+
+ do {
+ if (l->data == NULL && l->next != NULL) {
+ count = 0;
+ curmenu = gtk_menu_new();
+ item = gtk_menu_item_new_with_label(_("Others..."));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(curmenu), item);
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
+
+ l = l->next;
+ } else if (count > MENUCOUNT) {
+ count -= MENUCOUNT;
+
+ item = gtk_menu_item_new_with_label(_("More..."));
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(curmenu), item);
+
+ curmenu = gtk_menu_new();
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
+ }
+
+ item = gtk_menu_item_new_with_label((unsigned char*)l->data);
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(curmenu), item);
+ gtk_signal_connect(GTK_OBJECT(item), "activate",
+ GTK_SIGNAL_FUNC(replace_word_cb), gtkpspell);
+
+ if (curmenu == menu && count < MENUCOUNT) {
+ gtk_widget_add_accelerator(item, "activate",
+ accel,
+ GDK_A + count, 0,
+ GTK_ACCEL_LOCKED |
+ GTK_ACCEL_VISIBLE);
+ gtk_widget_add_accelerator(item, "activate",
+ accel,
+ GDK_A + count,
+ GDK_MOD1_MASK,
+ GTK_ACCEL_LOCKED);
+ }
+
+ count++;
+
+ } while ((l = l->next) != NULL);
+ }
+
+ gtk_accel_group_attach(accel, GTK_OBJECT(menu));
+ gtk_accel_group_unref(accel);
+
+ return GTK_MENU(menu);
+}
+
+static void populate_submenu(GtkPspell *gtkpspell, GtkWidget *menu)
+{
+ GtkWidget *item, *submenu;
+ GtkPspeller *gtkpspeller = gtkpspell->gtkpspeller;
+ gchar *dictname;
+ gint ispell = gtkpspeller->ispell;
+
+ if (GTK_MENU_SHELL(menu)->children) {
+ GList *amenu, *alist;
+ for (amenu = (GTK_MENU_SHELL(menu)->children); amenu; ) {
+ alist = amenu->next;
+ gtk_widget_destroy(GTK_WIDGET(amenu->data));
+ amenu = alist;
+ }
+ }
+
+ dictname = g_strdup_printf(_("Dictionary: %s"), gtkpspeller->dictionary->dictname);
+ item = gtk_menu_item_new_with_label(dictname);
+ gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
+ g_free(dictname);
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ item = gtk_menu_item_new();
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
+ if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE)
+ gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
+ if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE)
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
+ else
+ gtk_signal_connect(GTK_OBJECT(item), "activate",
+ GTK_SIGNAL_FUNC(set_sug_mode_cb),
+ gtkpspell);
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
+ if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE)
+ gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
+ if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE)
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+ else
+ gtk_signal_connect(GTK_OBJECT(item), "activate",
+ GTK_SIGNAL_FUNC(set_sug_mode_cb),
+ gtkpspell);
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu),item);
+
+ item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
+ if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE)
+ gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
+ if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE)
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+ else
+ gtk_signal_connect(GTK_OBJECT(item), "activate",
+ GTK_SIGNAL_FUNC(set_sug_mode_cb),
+ gtkpspell);
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ item = gtk_menu_item_new();
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ item = gtk_check_menu_item_new_with_label(_("Check while typing"));
+ if (gtkpspell->check_while_typing)
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+ else
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
+ gtk_signal_connect(GTK_OBJECT(item), "activate",
+ GTK_SIGNAL_FUNC(toggle_check_while_typing_cb),
+ gtkpspell);
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ item = gtk_menu_item_new();
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ submenu = gtk_menu_new();
+ item = gtk_menu_item_new_with_label(_("Change dictionary"));
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(menu), item);
+
+ /* Dict list */
+ if (gtkpspellcheckers->dictionary_list == NULL)
+ gtkpspell_get_dictionary_list(prefs_common.pspell_path, FALSE);
+ {
+ GtkWidget * curmenu = submenu;
+ int count = 0;
+ Dictionary *dict;
+ GSList *tmp;
+ tmp = gtkpspellcheckers->dictionary_list;
+
+ for (tmp = gtkpspellcheckers->dictionary_list; tmp != NULL;
+ tmp = g_slist_next(tmp)) {
+ dict = (Dictionary *) tmp->data;
+ item = gtk_check_menu_item_new_with_label(dict->dictname);
+ gtk_object_set_data(GTK_OBJECT(item), "dict_name", dict->fullname);
+ if (strcmp2(dict->fullname, gtkpspell->gtkpspeller->dictionary->fullname))
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
+ else {
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+ gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
+ }
+ gtk_signal_connect(GTK_OBJECT(item), "activate",
+ GTK_SIGNAL_FUNC(change_dict_cb),
+ gtkpspell);
+ gtk_widget_show(item);
+ gtk_menu_append(GTK_MENU(curmenu), item);
+
+ count++;
+
+ if (count == MENUCOUNT) {
+ GtkWidget *newmenu;
+
+ newmenu = gtk_menu_new();
+ item = gtk_menu_item_new_with_label(_("More..."));
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
+ newmenu);
+
+ gtk_menu_append(GTK_MENU(curmenu), item);
+ gtk_widget_show(item);
+ curmenu = newmenu;
+ count = 0;
+ }
+ }
+ }
+
+
+
+
+}
+
+static GtkMenu *make_config_menu(GtkPspell *gtkpspell)
+{
+ if (!gtkpspell->popup_config_menu)
+ gtkpspell->popup_config_menu = gtk_menu_new();
+
+ debug_print("Pspell: creating/using popup_config_menu %0x\n",
+ gtkpspell->popup_config_menu);
+ populate_submenu(gtkpspell, gtkpspell->popup_config_menu);
+
+ return GTK_MENU(gtkpspell->popup_config_menu);
+}
+
+void gtkpspell_populate_submenu(GtkPspell *gtkpspell, GtkWidget *menuitem)
+{
+ GtkWidget *menu;
+
+ menu = GTK_WIDGET(GTK_MENU_ITEM(menuitem)->submenu);
+
+ debug_print("Pspell: using config menu %0x\n",
+ gtkpspell->popup_config_menu);
+ populate_submenu(gtkpspell, menu);
+
+ gtkpspell->config_menu = menu;
+
+}
+
+static void set_menu_pos(GtkMenu *menu, gint *x, gint *y, gpointer data)
+{
+ GtkPspell *gtkpspell = (GtkPspell *) data;
+ gint xx = 0, yy = 0;
+ gint sx, sy;
+ gint wx, wy;
+ GtkSText *text = GTK_STEXT(gtkpspell->gtktext);
+ GtkRequisition r;
+
+ gdk_window_get_origin(GTK_WIDGET(gtkpspell->gtktext)->window, &xx, &yy);
+
+ sx = gdk_screen_width();
+ sy = gdk_screen_height();
+
+ gtk_widget_get_child_requisition(GTK_WIDGET(menu), &r);
+
+ wx = r.width;
+ wy = r.height;
+
+ *x = gtkpspell->gtktext->cursor_pos_x + xx +
+ gdk_char_width(GTK_WIDGET(text)->style->font, ' ');
+ *y = gtkpspell->gtktext->cursor_pos_y + yy;
+
+ if (*x + wx > sx)
+ *x = sx - wx;
+ if (*y + wy > sy)
+ *y = *y - wy -
+ gdk_string_height((GTK_WIDGET(gtkpspell->gtktext))->style->font,
+ gtkpspell->theword);
+
+}
+
+/*************************************************************************/
+/* Menu call backs */
+
+static gboolean cancel_menu_cb(GtkMenuShell *w, gpointer data)
+{
+ GtkPspell *gtkpspell = (GtkPspell *) data;
+ gtkpspell->continue_check = NULL;
+ set_point_continue(gtkpspell);
+ return FALSE;
+
+}
+/* change_dict_cb() - Menu callback : change dict */
+static void change_dict_cb(GtkWidget *w, GtkPspell *gtkpspell)
+{
+ Dictionary *dict;
+ gchar *fullname;
+ GtkPspeller *gtkpspeller;
+ gint sug_mode;
+
+ fullname = (gchar *) gtk_object_get_data(GTK_OBJECT(w), "dict_name");
+
+ if (!strcmp2(fullname, _("None")))
+ return;
+
+ sug_mode = gtkpspell->default_sug_mode;
+
+ dict = g_new0(Dictionary, 1);
+ dict->fullname = g_strdup(fullname);
+ dict->encoding = g_strdup(gtkpspell->gtkpspeller->dictionary->encoding);
+
+ gtkpspeller = gtkpspeller_new(dict);
+
+ if (!gtkpspeller) {
+ gchar *message;
+ message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s"),
+ gtkpspellcheckers->error_message);
+
+ gtkpspell_alert_dialog(message);
+ g_free(message);
+ } else {
+ gtkpspeller_delete(gtkpspell->gtkpspeller);
+ gtkpspell->gtkpspeller = gtkpspeller;
+ gtkpspell_set_sug_mode(gtkpspell, sug_mode);
+ }
+
+ dictionary_delete(dict);
+
+ if (gtkpspell->config_menu)
+ populate_submenu(gtkpspell, gtkpspell->config_menu);
+
+}
+
+/******************************************************************************/
+/* Misc. helper functions */
+
+static void set_point_continue(GtkPspell *gtkpspell)
+{
+ GtkSText *gtktext;
+
+ gtktext = gtkpspell->gtktext;
+
+ gtk_stext_freeze(gtktext);
+ gtk_editable_set_position(GTK_EDITABLE(gtktext),gtkpspell->orig_pos);
+ gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
+ gtk_stext_thaw(gtktext);
+
+ if (gtkpspell->continue_check)
+ gtkpspell->continue_check((gpointer *) gtkpspell);
+}
+
+static void allocate_color(GtkPspell *gtkpspell, gint rgbvalue)
+{
+ GdkColormap *gc;
+ GdkColor *color = &(gtkpspell->highlight);
+
+ gc = gtk_widget_get_colormap(GTK_WIDGET(gtkpspell->gtktext));
+
+ if (gtkpspell->highlight.pixel)
+ gdk_colormap_free_colors(gc, &(gtkpspell->highlight), 1);
+
+ /* Shameless copy from Sylpheed's gtkutils.c */
+ color->pixel = 0L;
+ color->red = (int) (((gdouble)((rgbvalue & 0xff0000) >> 16) / 255.0) * 65535.0);
+ color->green = (int) (((gdouble)((rgbvalue & 0x00ff00) >> 8) / 255.0) * 65535.0);
+ color->blue = (int) (((gdouble) (rgbvalue & 0x0000ff) / 255.0) * 65535.0);
- /* add an entry for the highlight in the color map. */
gdk_colormap_alloc_color(gc, &(gtkpspell->highlight), FALSE, TRUE);
}
+static void change_color(GtkPspell * gtkpspell,
+ gint start, gint end,
+ gchar *newtext,
+ GdkColor *color)
+{
+ GtkSText *gtktext;
+
+ g_return_if_fail(start < end);
+
+ gtktext = gtkpspell->gtktext;
+
+ gtk_stext_freeze(gtktext);
+ if (newtext) {
+ gtk_stext_set_point(gtktext, start);
+ gtk_stext_forward_delete(gtktext, end - start);
+ gtk_stext_insert(gtktext, NULL, color, NULL, newtext, end - start);
+ }
+ gtk_stext_thaw(gtktext);
+}
+
+/* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-*
+ * as needed by pspell. Returns an allocated string.
+ */
+
+static guchar *convert_to_pspell_encoding (const guchar *encoding)
+{
+ guchar * pspell_encoding;
+
+ if (strstr2(encoding, "ISO-8859-")) {
+ pspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
+ }
+ else
+ if (!strcmp2(encoding, "US-ASCII"))
+ pspell_encoding = g_strdup("iso8859-1");
+ else
+ pspell_encoding = g_strdup(encoding);
+
+ return pspell_encoding;
+}
+
+/* compare_dict () - compare 2 dict names */
+static gint compare_dict(Dictionary *a, Dictionary *b)
+{
+ guint aparts = 0, bparts = 0;
+ guint i;
+
+ for (i=0; i < strlen(a->dictname); i++)
+ if (a->dictname[i] == '-')
+ aparts++;
+ for (i=0; i < strlen(b->dictname); i++)
+ if (b->dictname[i] == '-')
+ bparts++;
+
+ if (aparts != bparts)
+ return (aparts < bparts) ? -1 : +1;
+ else {
+ gint compare;
+ compare = strcmp2(a->dictname, b->dictname);
+ if (!compare)
+ compare = strcmp2(a->fullname, b->fullname);
+ return compare;
+ }
+}
+
+
+static void dictionary_delete(Dictionary *dict)
+{
+ g_free(dict->fullname);
+ g_free(dict->encoding);
+ g_free(dict);
+}
+
+static Dictionary *dictionary_dup(const Dictionary *dict)
+{
+ Dictionary *dict2;
+
+ dict2 = g_new(Dictionary, 1);
+
+ dict2->fullname = g_strdup(dict->fullname);
+ dict2->dictname = dict->dictname - dict->fullname + dict2->fullname;
+ dict2->encoding = g_strdup(dict->encoding);
+
+ return dict2;
+}
+
+static void free_suggestions_list(GtkPspell *gtkpspell)
+{
+ GList *list;
+
+ for (list = gtkpspell->suggestions_list; list != NULL; list = list->next)
+ g_free(list->data);
+ g_list_free(list);
+
+ gtkpspell->max_sug = -1;
+ gtkpspell->suggestions_list = NULL;
+
+}
+
+static void reset_theword_data(GtkPspell *gtkpspell)
+{
+ gtkpspell->start_pos = 0;
+ gtkpspell->end_pos = 0;
+ gtkpspell->theword[0] = 0;
+ gtkpspell->max_sug = -1;
+
+ free_suggestions_list(gtkpspell);
+}
+
+static void free_checkers(gpointer elt, gpointer data)
+{
+ GtkPspeller *gtkpspeller = elt;
+
+ g_return_if_fail(gtkpspeller);
+
+ gtkpspeller_real_delete(gtkpspeller);
+}
+
+static gint find_gtkpspeller(gconstpointer aa, gconstpointer bb)
+{
+ Dictionary *a = ((GtkPspeller *) aa)->dictionary;
+ Dictionary *b = ((GtkPspeller *) bb)->dictionary;
+
+ if (a && b && a->fullname && b->fullname &&
+ strcmp(a->fullname, b->fullname) == 0 &&
+ a->encoding && b->encoding)
+ return strcmp(a->encoding, b->encoding);
+
+ return 1;
+}
+
+static void gtkpspell_alert_dialog(gchar *message)
+{
+ GtkWidget *dialog;
+ GtkWidget *hbox;
+ GtkWidget *label;
+ GtkWidget *ok_button;
+
+ dialog = gtk_dialog_new();
+ gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
+ gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_MOUSE);
+ gtk_signal_connect_object(GTK_OBJECT(dialog), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT(dialog));
+
+ label = gtk_label_new(message);
+ gtk_misc_set_padding(GTK_MISC(label), 8, 8);
+
+ gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
+
+ hbox = gtk_hbox_new(FALSE, 0);
+
+ ok_button = gtk_button_new_with_label(_("OK"));
+ GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
+ gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 8);
+
+ gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT(dialog));
+ gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), hbox);
+
+ gtk_widget_grab_default(ok_button);
+ gtk_widget_grab_focus(ok_button);
+ gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
+
+ gtk_widget_show_all(dialog);
+}
#endif
projects / claws.git / blobdiff