2360 lines
65 KiB
C
2360 lines
65 KiB
C
/* 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
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* 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
|
|
* 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-2002 by Hiroyuki Yamamoto &
|
|
* The Sylpheed Claws Team.
|
|
* Adapted for pspell (c) 2001-2002 Melvin Hadasht
|
|
*/
|
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#if USE_PSPELL
|
|
#include "intl.h"
|
|
|
|
#include <gtk/gtk.h>
|
|
#include <gdk/gdk.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <signal.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <sys/time.h>
|
|
#include <fcntl.h>
|
|
#include <time.h>
|
|
#include <prefs_common.h>
|
|
#include <utils.h>
|
|
|
|
#include <dirent.h>
|
|
|
|
#include <gtk/gtkoptionmenu.h>
|
|
#include <gtk/gtkmenu.h>
|
|
#include <gtk/gtkmenuitem.h>
|
|
#include <gdk/gdkkeysyms.h>
|
|
|
|
#include "gtkstext.h"
|
|
|
|
#include "gtkspell.h"
|
|
|
|
#include <pspell/pspell.h>
|
|
/* size of the text buffer used in various word-processing routines. */
|
|
#define BUFSIZE 1024
|
|
|
|
/* number of suggestions to display on each menu. */
|
|
#define MENUCOUNT 15
|
|
|
|
/* '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; \
|
|
}
|
|
|
|
#define CONFIG_REPLACE_RETURN_FALSE_IF_FAIL(option, value) { \
|
|
pspell_config_replace(config, option, value); \
|
|
RETURN_FALSE_IF_CONFIG_ERROR(); \
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
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 check_with_alternate_cb (GtkWidget *w,
|
|
gpointer data);
|
|
static void use_alternate_dict (GtkPspell *gtkpspell);
|
|
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);
|
|
static void switch_to_alternate_cb (GtkWidget *w,
|
|
gpointer data);
|
|
|
|
/* 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;
|
|
|
|
/******************************************************************************/
|
|
|
|
GtkPspellCheckers * gtkpspell_checkers_new()
|
|
{
|
|
GtkPspellCheckers *gtkpspellcheckers;
|
|
|
|
gtkpspellcheckers = g_new(GtkPspellCheckers, 1);
|
|
|
|
gtkpspellcheckers->checkers = NULL;
|
|
|
|
gtkpspellcheckers->dictionary_list = NULL;
|
|
|
|
gtkpspellcheckers->error_message = NULL;
|
|
|
|
return gtkpspellcheckers;
|
|
}
|
|
|
|
GtkPspellCheckers *gtkpspell_checkers_delete()
|
|
{
|
|
GSList *checkers;
|
|
GSList *dict_list;
|
|
|
|
if (gtkpspellcheckers == NULL) return NULL;
|
|
|
|
if ((checkers = gtkpspellcheckers->checkers)) {
|
|
debug_print(_("Pspell: number of running checkers to delete %d\n"),
|
|
g_slist_length(checkers));
|
|
|
|
g_slist_foreach(checkers, free_checkers, NULL);
|
|
g_slist_free(checkers);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
g_free(gtkpspellcheckers->error_message);
|
|
|
|
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;
|
|
}
|
|
|
|
void gtkpspell_checkers_reset_error()
|
|
{
|
|
g_return_if_fail(gtkpspellcheckers);
|
|
|
|
g_free(gtkpspellcheckers->error_message);
|
|
|
|
gtkpspellcheckers->error_message = NULL;
|
|
}
|
|
|
|
GtkPspell *gtkpspell_new(const gchar *dictionary,
|
|
const gchar *encoding,
|
|
gint misspelled_color,
|
|
gboolean check_while_typing,
|
|
gboolean use_alternate,
|
|
GtkSText *gtktext)
|
|
{
|
|
Dictionary *dict = g_new0(Dictionary, 1);
|
|
GtkPspell *gtkpspell;
|
|
GtkPspeller *gtkpspeller;
|
|
|
|
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->alternate_speller = NULL;
|
|
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;
|
|
gtkpspell->use_alternate = use_alternate;
|
|
|
|
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", (guint) gtkpspell);
|
|
|
|
return gtkpspell;
|
|
}
|
|
|
|
void gtkpspell_delete(GtkPspell * gtkpspell)
|
|
{
|
|
GtkSText * gtktext;
|
|
|
|
gtktext = gtkpspell->gtktext;
|
|
|
|
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_uncheck_all(gtkpspell);
|
|
|
|
gtkpspeller_delete(gtkpspell->gtkpspeller);
|
|
|
|
if (gtkpspell->use_alternate && gtkpspell->alternate_speller)
|
|
gtkpspeller_delete(gtkpspell->alternate_speller);
|
|
|
|
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);
|
|
|
|
debug_print("Pspell: deleting gtkpspell %0x\n", (guint) gtkpspell);
|
|
|
|
g_free(gtkpspell);
|
|
|
|
gtkpspell = NULL;
|
|
}
|
|
|
|
static void entry_insert_cb(GtkSText *gtktext, gchar *newtext,
|
|
guint len, guint *ppos,
|
|
GtkPspell * gtkpspell)
|
|
{
|
|
g_return_if_fail(gtkpspell->gtkpspeller->checker);
|
|
|
|
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);
|
|
|
|
/* 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);
|
|
}
|
|
gtk_stext_thaw(gtktext);
|
|
gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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. */
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
GdkEventButton *eb;
|
|
gboolean retval;
|
|
|
|
g_return_val_if_fail(gtkpspell->gtkpspeller->checker, FALSE);
|
|
|
|
if (e->type != GDK_BUTTON_PRESS)
|
|
return FALSE;
|
|
eb = (GdkEventButton*) e;
|
|
|
|
if (eb->button != 3)
|
|
return FALSE;
|
|
|
|
/* 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;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Checker creation */
|
|
static GtkPspeller *gtkpspeller_new(Dictionary *dictionary)
|
|
{
|
|
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);
|
|
|
|
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;
|
|
|
|
tmp = strrchr(dictionary->fullname, G_DIR_SEPARATOR);
|
|
|
|
if (tmp == NULL)
|
|
dictionary->dictname = dictionary->fullname;
|
|
else
|
|
dictionary->dictname = tmp + 1;
|
|
}
|
|
|
|
dict = dictionary_dup(dictionary);
|
|
|
|
ispell = (strstr2(dict->dictname, "-ispell") != NULL);
|
|
|
|
g->dictionary = dict;
|
|
|
|
exist = g_slist_find_custom(gtkpspellcheckers->checkers, g,
|
|
find_gtkpspeller);
|
|
|
|
g_free(g);
|
|
|
|
if (exist && ispell) {
|
|
gtkpspeller = (GtkPspeller *) exist->data;
|
|
dictionary_delete(dict);
|
|
|
|
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);
|
|
|
|
debug_print(_("Pspell: Created a new gtkpspeller %0x\n"),
|
|
(gint) gtkpspeller);
|
|
} else {
|
|
dictionary_delete(dict);
|
|
|
|
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;
|
|
}
|
|
|
|
static GtkPspeller *gtkpspeller_real_new(Dictionary *dict)
|
|
{
|
|
GtkPspeller *gtkpspeller;
|
|
PspellConfig *config;
|
|
PspellCanHaveError *ret;
|
|
|
|
g_return_val_if_fail(gtkpspellcheckers, NULL);
|
|
g_return_val_if_fail(dict, NULL);
|
|
|
|
gtkpspeller = g_new(GtkPspeller, 1);
|
|
|
|
gtkpspeller->dictionary = dict;
|
|
gtkpspeller->sug_mode = PSPELL_FASTMODE;
|
|
|
|
config = new_pspell_config();
|
|
|
|
if (!set_dictionary(config, dict))
|
|
return NULL;
|
|
|
|
ret = new_pspell_manager(config);
|
|
delete_pspell_config(config);
|
|
|
|
if (pspell_error_number(ret) != 0) {
|
|
gtkpspellcheckers->error_message = g_strdup(pspell_error_message(ret));
|
|
|
|
delete_pspell_can_have_error(ret);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
gtkpspeller->checker = to_pspell_manager(ret);
|
|
gtkpspeller->config = pspell_manager_config(gtkpspeller->checker);
|
|
gtkpspeller->ispell = (strstr2(dict->fullname, "-ispell") != NULL);
|
|
|
|
return gtkpspeller;
|
|
}
|
|
|
|
static GtkPspeller *gtkpspeller_delete(GtkPspeller *gtkpspeller)
|
|
{
|
|
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);
|
|
|
|
debug_print(_("Pspell: Deleting gtkpspeller %0x.\n"),
|
|
(gint) gtkpspeller);
|
|
|
|
gtkpspeller_real_delete(gtkpspeller);
|
|
}
|
|
|
|
debug_print(_("Pspell: number of existing checkers %d\n"),
|
|
g_slist_length(gtkpspellcheckers->checkers));
|
|
|
|
return gtkpspeller;
|
|
}
|
|
|
|
static GtkPspeller *gtkpspeller_real_delete(GtkPspeller *gtkpspeller)
|
|
{
|
|
g_return_val_if_fail(gtkpspeller, NULL);
|
|
g_return_val_if_fail(gtkpspeller->checker, NULL);
|
|
|
|
pspell_manager_save_all_word_lists(gtkpspeller->checker);
|
|
|
|
delete_pspell_manager(gtkpspeller->checker);
|
|
|
|
dictionary_delete(gtkpspeller->dictionary);
|
|
|
|
debug_print(_("Pspell: gtkpspeller %0x deleted.\n"),
|
|
(gint) gtkpspeller);
|
|
g_free(gtkpspeller);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/* Checker configuration */
|
|
|
|
static gboolean set_dictionary(PspellConfig *config, Dictionary *dict)
|
|
{
|
|
gchar *language = NULL;
|
|
gchar *spelling = NULL;
|
|
gchar *jargon = NULL;
|
|
gchar *module = NULL;
|
|
gchar *end = NULL;
|
|
gchar buf[BUFSIZE];
|
|
|
|
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",
|
|
(guint) 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, 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 */
|
|
/* this, we can use two others pointers that points to the whole */
|
|
/* word including quotes. */
|
|
|
|
gint start,
|
|
end;
|
|
guchar c;
|
|
GtkSText *gtktext;
|
|
|
|
gtktext = gtkpspell->gtktext;
|
|
if (iswordsep(get_text_index_whar(gtkpspell, pos)))
|
|
return FALSE;
|
|
|
|
/* The apostrophe character is somtimes used for quotes
|
|
* So include it in the word only if it is not surrounded
|
|
* by other characters.
|
|
*/
|
|
|
|
for (start = pos; start >= 0; --start) {
|
|
c = get_text_index_whar(gtkpspell, start);
|
|
if (c == '\'') {
|
|
if (start > 0) {
|
|
if (!isalpha(get_text_index_whar(gtkpspell, start - 1))) {
|
|
/* start_quote = TRUE; */
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
/* start_quote = TRUE; */
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
if (!isalpha(c))
|
|
break;
|
|
}
|
|
start++;
|
|
|
|
for (end = pos; end < gtk_stext_get_length(gtktext); end++) {
|
|
c = get_text_index_whar(gtkpspell, end);
|
|
if (c == '\'') {
|
|
if (end < gtk_stext_get_length(gtktext)) {
|
|
if (!isalpha(get_text_index_whar(gtkpspell, end + 1))) {
|
|
/* end_quote = TRUE; */
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
/* end_quote = TRUE; */
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
if(!isalpha(c))
|
|
break;
|
|
}
|
|
|
|
if (pstart)
|
|
*pstart = start;
|
|
if (pend)
|
|
*pend = end;
|
|
|
|
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;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean check_at(GtkPspell *gtkpspell, gint from_pos)
|
|
{
|
|
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, sizeof(buf),
|
|
&start, &end))
|
|
return FALSE;
|
|
|
|
if (misspelled_test(gtkpspell, buf)) {
|
|
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, 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);
|
|
}
|
|
|
|
void gtkpspell_check_forwards_go(GtkPspell *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_highlight_all(GtkPspell *gtkpspell)
|
|
{
|
|
guint origpos;
|
|
guint pos = 0;
|
|
guint len;
|
|
GtkSText *gtktext;
|
|
gfloat adj_value;
|
|
|
|
g_return_if_fail(gtkpspell->gtkpspeller->checker);
|
|
|
|
gtktext = gtkpspell->gtktext;
|
|
|
|
adj_value = gtktext->vadj->value;
|
|
|
|
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);*/
|
|
|
|
while (pos < len) {
|
|
while (pos < len &&
|
|
iswordsep(get_text_index_whar(gtkpspell, pos)))
|
|
pos++;
|
|
while (pos < len &&
|
|
!iswordsep(get_text_index_whar(gtkpspell, pos)))
|
|
pos++;
|
|
if (pos > 0)
|
|
check_at(gtkpspell, pos - 1);
|
|
}
|
|
gtk_stext_thaw(gtktext);
|
|
gtk_editable_set_position(GTK_EDITABLE(gtktext), 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 replace_with_supplied_word_cb(GtkWidget *w, GtkPspell *gtkpspell)
|
|
{
|
|
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;
|
|
}
|
|
|
|
g_free(newword);
|
|
|
|
set_point_continue(gtkpspell);
|
|
}
|
|
|
|
|
|
static void replace_word_cb(GtkWidget *w, gpointer data)
|
|
{
|
|
unsigned char *newword;
|
|
GtkPspell *gtkpspell = (GtkPspell *) data;
|
|
GdkEvent *e= (GdkEvent *) gtk_get_current_event();
|
|
|
|
|
|
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_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
|
|
|
|
set_point_continue(gtkpspell);
|
|
}
|
|
|
|
static void replace_real_word(GtkPspell *gtkpspell, gchar *newword)
|
|
{
|
|
int oldlen, newlen, wordlen;
|
|
gint origpos;
|
|
gint pos;
|
|
gint start = gtkpspell->start_pos;
|
|
GtkSText *gtktext;
|
|
|
|
if (!newword) return;
|
|
|
|
gtktext = gtkpspell->gtktext;
|
|
|
|
gtk_stext_freeze(GTK_STEXT(gtktext));
|
|
origpos = gtkpspell->orig_pos;
|
|
pos = origpos;
|
|
oldlen = gtkpspell->end_pos - gtkpspell->start_pos;
|
|
wordlen = strlen(gtkpspell->theword);
|
|
|
|
newlen = strlen(newword); /* FIXME: multybyte characters? */
|
|
|
|
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 - gtkpspell->start_pos < oldlen &&
|
|
origpos - gtkpspell->start_pos >= 0) {
|
|
/* Original point was in the word. */
|
|
/* 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 >= gtkpspell->end_pos) {
|
|
/* move the position according to the change of length */
|
|
pos = origpos + newlen - oldlen;
|
|
}
|
|
|
|
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_stext_set_point(GTK_STEXT(gtktext),
|
|
gtk_editable_get_position(GTK_EDITABLE(gtktext)));
|
|
|
|
gtk_stext_thaw(GTK_STEXT(gtktext));
|
|
}
|
|
|
|
/* Accept this word for this session */
|
|
static void add_word_to_session_cb(GtkWidget *w, gpointer data)
|
|
{
|
|
guint pos;
|
|
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->gtkpspeller->checker,
|
|
gtkpspell->theword,
|
|
strlen(gtkpspell->theword));
|
|
|
|
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);
|
|
}
|
|
|
|
/* add_word_to_personal_cb() - add word to personal dict. */
|
|
static void add_word_to_personal_cb(GtkWidget *w, gpointer data)
|
|
{
|
|
GtkSText *gtktext;
|
|
GtkPspell *gtkpspell = (GtkPspell *) data;
|
|
gtktext = gtkpspell->gtktext;
|
|
|
|
gtk_stext_freeze(GTK_STEXT(gtktext));
|
|
|
|
pspell_manager_add_to_personal(gtkpspell->gtkpspeller->checker,
|
|
gtkpspell->theword,
|
|
strlen(gtkpspell->theword));
|
|
|
|
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 void check_with_alternate_cb(GtkWidget *w,
|
|
gpointer data)
|
|
{
|
|
GtkPspell *gtkpspell = (GtkPspell *) data;
|
|
gint misspelled;
|
|
gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
|
|
|
|
use_alternate_dict(gtkpspell);
|
|
misspelled = check_at(gtkpspell, gtkpspell->start_pos);
|
|
|
|
if (!gtkpspell->continue_check) {
|
|
gtkpspell->misspelled = misspelled;
|
|
if (gtkpspell->misspelled) {
|
|
misspelled_suggest(gtkpspell, gtkpspell->theword);
|
|
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);
|
|
return;
|
|
}
|
|
} else
|
|
gtkpspell->orig_pos = gtkpspell->start_pos;
|
|
|
|
set_point_continue(gtkpspell);
|
|
}
|
|
|
|
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);
|
|
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);
|
|
}
|
|
|
|
hbox = gtk_hbox_new(TRUE, 0);
|
|
|
|
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));
|
|
|
|
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_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), hbox);
|
|
|
|
gtk_widget_grab_focus(entry);
|
|
|
|
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
|
|
|
|
gtk_widget_show_all(dialog);
|
|
}
|
|
|
|
void gtkpspell_uncheck_all(GtkPspell * gtkpspell)
|
|
{
|
|
gint origpos;
|
|
gchar *text;
|
|
gfloat adj_value;
|
|
GtkSText *gtktext;
|
|
|
|
gtktext = gtkpspell->gtktext;
|
|
|
|
adj_value = gtktext->vadj->value;
|
|
|
|
gtk_stext_freeze(gtktext);
|
|
|
|
origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
|
|
|
|
text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
|
|
|
|
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));
|
|
|
|
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);
|
|
|
|
g_free(text);
|
|
|
|
}
|
|
|
|
static void toggle_check_while_typing_cb(GtkWidget *w, gpointer data)
|
|
{
|
|
GtkPspell *gtkpspell = (GtkPspell *) data;
|
|
|
|
gtkpspell->check_while_typing = gtkpspell->check_while_typing == FALSE;
|
|
if (!gtkpspell->check_while_typing)
|
|
gtkpspell_uncheck_all(gtkpspell);
|
|
|
|
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->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, gint refresh)
|
|
{
|
|
GSList *list;
|
|
gchar *dict_path, *tmp, *prevdir;
|
|
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();
|
|
if (chdir(dict_path) <0) {
|
|
debug_print(_("Pspell: error when searching for dictionaries:\n%s\n"),
|
|
g_strerror(errno));
|
|
g_free(prevdir);
|
|
g_free(dict_path);
|
|
gtkpspellcheckers->dictionary_list = create_empty_dictionary_list();
|
|
return gtkpspellcheckers->dictionary_list;
|
|
}
|
|
|
|
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 = 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->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 {
|
|
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(_("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;
|
|
}
|
|
|
|
void gtkpspell_free_dictionary_list(GSList *list)
|
|
{
|
|
Dictionary *dict;
|
|
GSList *walk;
|
|
for (walk = list; walk != NULL; walk = g_slist_next(walk))
|
|
if (walk->data) {
|
|
dict = (Dictionary *) walk->data;
|
|
dictionary_delete(dict);
|
|
}
|
|
g_slist_free(list);
|
|
}
|
|
|
|
#if 0
|
|
static void dictionary_option_menu_item_data_destroy(gpointer data)
|
|
{
|
|
Dictionary *dict = (Dictionary *) data;
|
|
|
|
if (dict)
|
|
dictionary_delete(dict);
|
|
}
|
|
#endif
|
|
|
|
GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path)
|
|
{
|
|
GSList *dict_list, *tmp;
|
|
GtkWidget *item;
|
|
GtkWidget *menu;
|
|
Dictionary *dict;
|
|
|
|
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->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);
|
|
|
|
return menu;
|
|
}
|
|
|
|
gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu)
|
|
{
|
|
GtkWidget *menuitem;
|
|
gchar *dict_fullname;
|
|
gchar *label;
|
|
|
|
g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
|
|
menuitem = gtk_menu_get_active(GTK_MENU(menu));
|
|
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;
|
|
|
|
}
|
|
|
|
GtkWidget *gtkpspell_sugmode_option_menu_new(gint sugmode)
|
|
{
|
|
GtkWidget *menu;
|
|
GtkWidget *item;
|
|
|
|
|
|
menu = gtk_menu_new();
|
|
gtk_widget_show(menu);
|
|
|
|
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));
|
|
|
|
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));
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
static void use_alternate_dict(GtkPspell *gtkpspell)
|
|
{
|
|
GtkPspeller *tmp;
|
|
|
|
tmp = gtkpspell->gtkpspeller;
|
|
gtkpspell->gtkpspeller = gtkpspell->alternate_speller;
|
|
gtkpspell->alternate_speller = tmp;
|
|
|
|
if (gtkpspell->config_menu)
|
|
populate_submenu(gtkpspell, gtkpspell->config_menu);
|
|
}
|
|
|
|
|
|
#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(_("\"%s\" unknown in %s"),
|
|
(unsigned char*) l->data,
|
|
gtkpspell->gtkpspeller->dictionary->dictname);
|
|
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);
|
|
|
|
if (gtkpspell->use_alternate && gtkpspell->alternate_speller) {
|
|
caption = g_strdup_printf(_("Check with %s"),
|
|
gtkpspell->alternate_speller->dictionary->dictname);
|
|
item = gtk_menu_item_new_with_label(caption);
|
|
g_free(caption);
|
|
gtk_widget_show(item);
|
|
gtk_menu_append(GTK_MENU(menu), item);
|
|
gtk_signal_connect(GTK_OBJECT(item), "activate",
|
|
GTK_SIGNAL_FUNC(check_with_alternate_cb),
|
|
gtkpspell);
|
|
gtk_widget_add_accelerator(item, "activate", accel, GDK_X, 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);
|
|
|
|
if (gtkpspell->use_alternate && gtkpspell->alternate_speller) {
|
|
dictname = g_strdup_printf(_("Use alternate (%s)"),
|
|
gtkpspell->alternate_speller->dictionary->dictname);
|
|
item = gtk_menu_item_new_with_label(dictname);
|
|
g_free(dictname);
|
|
gtk_signal_connect(GTK_OBJECT(item), "activate",
|
|
GTK_SIGNAL_FUNC(switch_to_alternate_cb),
|
|
gtkpspell);
|
|
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",
|
|
(guint) 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",
|
|
(guint) 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);
|
|
|
|
if (gtkpspell->use_alternate && gtkpspell->alternate_speller &&
|
|
dict == gtkpspell->alternate_speller->dictionary) {
|
|
use_alternate_dict(gtkpspell);
|
|
dictionary_delete(dict);
|
|
return;
|
|
}
|
|
|
|
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 {
|
|
if (gtkpspell->use_alternate) {
|
|
if (gtkpspell->alternate_speller)
|
|
gtkpspeller_delete(gtkpspell->alternate_speller);
|
|
gtkpspell->alternate_speller = gtkpspell->gtkpspeller;
|
|
} 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);
|
|
|
|
}
|
|
|
|
static void switch_to_alternate_cb(GtkWidget *w,
|
|
gpointer data)
|
|
{
|
|
GtkPspell *gtkpspell = (GtkPspell *) data;
|
|
use_alternate_dict(gtkpspell);
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* 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);
|
|
|
|
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
|