#ifdef HAVE_CONFIG_H
# include "config.h"
+#include "claws-features.h"
#endif
-#ifdef USE_ASPELL
+#ifdef USE_ENCHANT
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
-#include <sys/wait.h>
+#if HAVE_SYS_WAIT_H
+# include <sys/wait.h>
+#endif
#include <signal.h>
#include <ctype.h>
#include <string.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
-#include <gtk/gtkoptionmenu.h>
-#include <gtk/gtkmenu.h>
-#include <gtk/gtkmenuitem.h>
#include <gdk/gdkkeysyms.h>
-#include <aspell.h>
-
#include "utils.h"
-#include "codeconv.h"
#include "alertpanel.h"
#include "gtkaspell.h"
#include "gtk/gtkutils.h"
+#include "gtk/combobox.h"
#define ASPELL_FASTMODE 1
#define ASPELL_NORMALMODE 2
#define ASPELL_BADSPELLERMODE 3
-#define GTKASPELLWORDSIZE 1024
-
/* 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 'AspellConfig *' */
-#define RETURN_FALSE_IF_CONFIG_ERROR() \
-{ \
- if (aspell_config_error_number(config) != 0) { \
- gtkaspellcheckers->error_message = g_strdup(aspell_config_error_message(config)); \
- return FALSE; \
- } \
-}
-
-#define CONFIG_REPLACE_RETURN_FALSE_IF_FAIL(option, value) { \
- aspell_config_replace(config, option, value); \
- RETURN_FALSE_IF_CONFIG_ERROR(); \
- }
+enum {
+ SET_GTKASPELL_NAME = 0,
+ SET_GTKASPELL_FULLNAME = 1,
+ SET_GTKASPELL_SIZE
+};
typedef struct _GtkAspellCheckers {
GSList *checkers;
gchar *error_message;
} GtkAspellCheckers;
-typedef struct _Dictionary {
- gchar *fullname;
- gchar *dictname;
- gchar *encoding;
-} Dictionary;
-
-typedef struct _GtkAspeller {
- Dictionary *dictionary;
- gint sug_mode;
- AspellConfig *config;
- AspellSpeller *checker;
-} GtkAspeller;
-
-typedef void (*ContCheckFunc) (gpointer *gtkaspell);
-
-struct _GtkAspell
-{
- GtkAspeller *gtkaspeller;
- GtkAspeller *alternate_speller;
- gchar *dictionary_path;
- gchar theword[GTKASPELLWORDSIZE];
- gint start_pos;
- gint end_pos;
- gint orig_pos;
- gint end_check_pos;
- gboolean misspelled;
- gboolean check_while_typing;
- gboolean recheck_when_changing_dict;
- gboolean use_alternate;
- gboolean use_both_dicts;
-
- ContCheckFunc continue_check;
-
- GtkWidget *replace_entry;
- GtkWidget *parent_window;
-
- gint default_sug_mode;
- gint max_sug;
- GList *suggestions_list;
-
- GtkTextView *gtktext;
- GdkColor highlight;
- GtkAccelGroup *accel_group;
- void (*menu_changed_cb)(void *data);
- void *menu_changed_data;
-};
-
-typedef AspellConfig GtkAspellConfig;
-
/******************************************************************************/
static GtkAspellCheckers *gtkaspellcheckers;
/* Error message storage */
-static void gtkaspell_checkers_error_message (gchar *message);
+static void gtkaspell_checkers_error_message (gchar *message);
/* Callbacks */
+static gboolean key_press_cb (GtkWidget *text_view,
+ GdkEventKey *event,
+ GtkAspell *gtkaspell);
static void entry_insert_cb (GtkTextBuffer *textbuf,
GtkTextIter *iter,
gchar *newtext,
static GtkAspeller* gtkaspeller_real_delete (GtkAspeller *gtkaspeller);
/* Checker configuration */
-static gint set_dictionary (AspellConfig *config,
+static EnchantDict *set_dictionary (EnchantBroker *broker,
Dictionary *dict);
-static void set_sug_mode_cb (GtkMenuItem *w,
- GtkAspell *gtkaspell);
static void set_use_both_cb (GtkMenuItem *w,
GtkAspell *gtkaspell);
-static void set_real_sug_mode (GtkAspell *gtkaspell,
- const char *themode);
/* Checker actions */
static gboolean check_at (GtkAspell *gtkaspell,
int from_pos);
-static gboolean check_next_prev (GtkAspell *gtkaspell,
- gboolean forward);
+static gboolean check_at_cb (gpointer data);
static GList* misspelled_suggest (GtkAspell *gtkaspell,
gchar *word);
+static gboolean find_misspelled_cb (gpointer data,
+ gboolean forward);
static void add_word_to_session_cb (GtkWidget *w,
gpointer data);
static void add_word_to_personal_cb (GtkWidget *w,
static void replace_word_cb (GtkWidget *w,
gpointer data);
static void replace_real_word (GtkAspell *gtkaspell,
- gchar *newword);
+ const gchar *newword);
+static void replace_real_word_cb (gpointer data,
+ const gchar *newword);
static void check_with_alternate_cb (GtkWidget *w,
gpointer data);
-static void use_alternate_dict (GtkAspell *gtkaspell);
static void toggle_check_while_typing_cb (GtkWidget *w,
gpointer data);
int pos);
static gboolean get_word_from_pos (GtkAspell *gtkaspell,
gint pos,
- unsigned char* buf,
+ char* buf,
gint buflen,
gint *pstart,
gint *pend);
gint end,
gchar *newtext,
GdkColor *color);
-static gchar* convert_to_aspell_encoding (const gchar *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 (GtkAspell *gtkaspell);
static void reset_theword_data (GtkAspell *gtkaspell);
static void free_checkers (gpointer elt,
gpointer data);
-static gint find_gtkaspeller (gconstpointer aa,
- gconstpointer bb);
-/* gtkspellconfig - only one config per session */
-GtkAspellConfig * gtkaspellconfig;
+
static void destroy_menu(GtkWidget *widget, gpointer user_data);
/******************************************************************************/
static gint get_textview_buffer_charcount(GtkTextView *view);
static void gtkaspell_free_dictionary_list (GSList *list);
-static GSList* gtkaspell_get_dictionary_list (const char *aspell_path,
- gint refresh);
+static GSList* gtkaspell_get_dictionary_list (gint refresh);
static void gtkaspell_uncheck_all (GtkAspell *gtkaspell);
{
GtkTextBuffer *buffer;
- g_return_val_if_fail(view, 0);
+ cm_return_val_if_fail(view, 0);
buffer = gtk_text_view_get_buffer(view);
- g_return_val_if_fail(buffer, 0);
+ cm_return_val_if_fail(buffer, 0);
return gtk_text_buffer_get_char_count(buffer);
}
GtkTextMark * mark;
GtkTextIter iter;
- g_return_val_if_fail(view, 0);
+ cm_return_val_if_fail(view, 0);
buffer = gtk_text_view_get_buffer(view);
- g_return_val_if_fail(buffer, 0);
+ cm_return_val_if_fail(buffer, 0);
mark = gtk_text_buffer_get_insert(buffer);
- g_return_val_if_fail(mark, 0);
+ cm_return_val_if_fail(mark, 0);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
GtkTextBuffer *buffer;
GtkTextIter iter;
- g_return_if_fail(view);
+ cm_return_if_fail(view);
buffer = gtk_text_view_get_buffer(view);
- g_return_if_fail(buffer);
+ cm_return_if_fail(buffer);
gtk_text_buffer_get_iter_at_offset(buffer, &iter, offset);
gtk_text_buffer_place_cursor(buffer, &iter);
gtkaspellcheckers->error_message = tmp;
} else
gtkaspellcheckers->error_message = message;
+
+
}
const char *gtkaspell_checkers_strerror(void)
{
- g_return_val_if_fail(gtkaspellcheckers, "");
+ cm_return_val_if_fail(gtkaspellcheckers, "");
return gtkaspellcheckers->error_message;
}
void gtkaspell_checkers_reset_error(void)
{
- g_return_if_fail(gtkaspellcheckers);
+ cm_return_if_fail(gtkaspellcheckers);
g_free(gtkaspellcheckers->error_message);
gtkaspellcheckers->error_message = NULL;
}
-GtkAspell *gtkaspell_new(const gchar *dictionary_path,
- const gchar *dictionary,
+GtkAspell *gtkaspell_new(const gchar *dictionary,
const gchar *alt_dictionary,
- const gchar *encoding,
+ const gchar *encoding, /* unused */
gint misspelled_color,
gboolean check_while_typing,
gboolean recheck_when_changing_dict,
gboolean use_both_dicts,
GtkTextView *gtktext,
GtkWindow *parent_win,
+ void (dict_changed_cb)(void *data),
void (*spell_menu_cb)(void *data),
void *data)
{
GtkAspeller *gtkaspeller;
GtkTextBuffer *buffer;
- g_return_val_if_fail(gtktext, NULL);
- g_return_val_if_fail(dictionary && strlen(dictionary) > 0,
- NULL);
-
- g_return_val_if_fail(dictionary_path && strlen(dictionary_path) > 0,
- NULL);
+ cm_return_val_if_fail(gtktext, NULL);
+ if (!dictionary || !*dictionary) {
+ gtkaspell_checkers_error_message(
+ g_strdup(_("No dictionary selected.")));
+ return NULL;
+ }
buffer = gtk_text_view_get_buffer(gtktext);
dict = g_new0(Dictionary, 1);
- dict->fullname = g_strdup(dictionary);
- dict->encoding = g_strdup(encoding);
+ if (strrchr(dictionary, '/')) {
+ dict->fullname = g_strdup(strrchr(dictionary, '/')+1);
+ dict->dictname = g_strdup(strrchr(dictionary, '/')+1);
+ } else {
+ dict->fullname = g_strdup(dictionary);
+ dict->dictname = g_strdup(dictionary);
+ }
+ if (strchr(dict->fullname, '-')) {
+ *(strchr(dict->fullname, '-')) = '\0';
+ *(strchr(dict->dictname, '-')) = '\0';
+ }
gtkaspeller = gtkaspeller_new(dict);
dictionary_delete(dict);
- if (!gtkaspeller)
+ if (!gtkaspeller) {
+ gtkaspell_checkers_error_message(
+ g_strdup_printf(_("Couldn't initialize %s speller."), dictionary));
return NULL;
+ }
gtkaspell = g_new0(GtkAspell, 1);
- gtkaspell->dictionary_path = g_strdup(dictionary_path);
-
gtkaspell->gtkaspeller = gtkaspeller;
if (use_alternate && alt_dictionary && *alt_dictionary) {
GtkAspeller *alt_gtkaspeller;
alt_dict = g_new0(Dictionary, 1);
- alt_dict->fullname = g_strdup(alt_dictionary);
- alt_dict->encoding = g_strdup(encoding);
+ if (strrchr(alt_dictionary, '/')) {
+ alt_dict->fullname = g_strdup(strrchr(alt_dictionary, '/')+1);
+ alt_dict->dictname = g_strdup(strrchr(alt_dictionary, '/')+1);
+ } else {
+ alt_dict->fullname = g_strdup(alt_dictionary);
+ alt_dict->dictname = g_strdup(alt_dictionary);
+ }
+ if (strchr(alt_dict->fullname, '-')) {
+ *(strchr(alt_dict->fullname, '-')) = '\0';
+ *(strchr(alt_dict->dictname, '-')) = '\0';
+ }
alt_gtkaspeller = gtkaspeller_new(alt_dict);
dictionary_delete(alt_dict);
- if (!alt_gtkaspeller)
+ if (!alt_gtkaspeller) {
+ gtkaspell_checkers_error_message(
+ g_strdup_printf(_("Couldn't initialize %s speller."), dictionary));
+ gtkaspeller_delete(gtkaspeller);
+ g_free(gtkaspell);
return NULL;
+ }
gtkaspell->alternate_speller = alt_gtkaspeller;
} else {
gtkaspell->continue_check = NULL;
gtkaspell->replace_entry = NULL;
gtkaspell->gtktext = gtktext;
- gtkaspell->default_sug_mode = ASPELL_FASTMODE;
gtkaspell->max_sug = -1;
gtkaspell->suggestions_list = NULL;
gtkaspell->use_alternate = use_alternate;
gtkaspell->use_both_dicts = use_both_dicts;
gtkaspell->parent_window = GTK_WIDGET(parent_win);
+ gtkaspell->dict_changed_cb = dict_changed_cb;
gtkaspell->menu_changed_cb = spell_menu_cb;
gtkaspell->menu_changed_data = data;
allocate_color(gtkaspell, misspelled_color);
+ g_signal_connect(G_OBJECT(gtktext), "key_press_event",
+ G_CALLBACK(key_press_cb), gtkaspell);
g_signal_connect_after(G_OBJECT(buffer), "insert-text",
G_CALLBACK(entry_insert_cb), gtkaspell);
g_signal_connect_after(G_OBJECT(buffer), "delete-range",
{
GtkTextView *gtktext = gtkaspell->gtktext;
+ g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(key_press_cb),
+ gtkaspell);
g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
G_CALLBACK(entry_insert_cb),
gtkaspell);
gtkaspeller_delete(gtkaspell->alternate_speller);
if (gtkaspell->suggestions_list)
- free_suggestions_list(gtkaspell);
-
- g_free((gchar *)gtkaspell->dictionary_path);
- gtkaspell->dictionary_path = NULL;
+ gtkaspell_free_suggestions_list(gtkaspell);
debug_print("Aspell: deleting gtkaspell %p\n", gtkaspell);
gtkaspell = NULL;
}
+void gtkaspell_dict_changed(GtkAspell *gtkaspell)
+{
+ if(!gtkaspell || !gtkaspell->dict_changed_cb ||
+ !gtkaspell->menu_changed_data)
+ return;
+
+ gtkaspell->dict_changed_cb(gtkaspell->menu_changed_data);
+}
+
+static gboolean key_press_cb (GtkWidget *text_view,
+ GdkEventKey *event,
+ GtkAspell *gtkaspell)
+{
+ gint pos;
+
+ cm_return_val_if_fail(gtkaspell->gtkaspeller->speller, FALSE);
+
+ if (!gtkaspell->check_while_typing)
+ return FALSE;
+
+ switch (event->keyval) {
+ case GDK_KEY_Home:
+ case GDK_KEY_Left:
+ case GDK_KEY_Up:
+ case GDK_KEY_Right:
+ case GDK_KEY_Down:
+ case GDK_KEY_Page_Up:
+ case GDK_KEY_Page_Down:
+ case GDK_KEY_End:
+ case GDK_KEY_Begin:
+ pos = get_textview_buffer_offset(GTK_TEXT_VIEW(text_view));
+ if (pos > 0)
+ check_at(gtkaspell, pos - 1);
+ else
+ check_at(gtkaspell, pos);
+ break;
+ default:
+ break;
+ }
+
+ return FALSE;
+}
+
static void entry_insert_cb(GtkTextBuffer *textbuf,
GtkTextIter *iter,
gchar *newtext,
{
guint pos;
- g_return_if_fail(gtkaspell->gtkaspeller->checker);
+ cm_return_if_fail(gtkaspell->gtkaspeller->speller);
if (!gtkaspell->check_while_typing)
return;
GtkAspell *gtkaspell)
{
int origpos;
- gint start, end;
+ gint start;
- g_return_if_fail(gtkaspell->gtkaspeller->checker);
+ cm_return_if_fail(gtkaspell->gtkaspeller->speller);
if (!gtkaspell->check_while_typing)
return;
start = gtk_text_iter_get_offset(startiter);
- end = gtk_text_iter_get_offset(enditer);
origpos = get_textview_buffer_offset(gtkaspell->gtktext);
if (start) {
check_at(gtkaspell, start - 1);
/* gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); */
}
-static void button_press_intercept_cb(GtkTextView *gtktext,
- GtkMenu *menu, GtkAspell *gtkaspell)
+void gtkaspell_make_context_menu(GtkMenu *menu, GtkAspell *gtkaspell)
{
GtkMenuItem *menuitem;
GSList *spell_menu = NULL;
GSList *items;
gboolean suggest = FALSE;
- menuitem = GTK_MENU_ITEM(gtk_separator_menu_item_new());
- gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), GTK_WIDGET(menuitem));
- gtk_widget_show(GTK_WIDGET(menuitem));
-
- gtktext = gtkaspell->gtktext;
-
- gtkaspell->orig_pos = get_textview_buffer_offset(gtktext);
-
- if (check_at(gtkaspell, gtkaspell->orig_pos)) {
-
- if (misspelled_suggest(gtkaspell, gtkaspell->theword)) {
- spell_menu = make_sug_menu(gtkaspell);
- suggest = TRUE;
- }
+ if (gtkaspell->misspelled &&
+ misspelled_suggest(gtkaspell, gtkaspell->theword)) {
+ spell_menu = make_sug_menu(gtkaspell);
+ suggest = TRUE;
}
if (!spell_menu)
spell_menu = gtkaspell_make_config_menu(gtkaspell);
+ menuitem = GTK_MENU_ITEM(gtk_separator_menu_item_new());
+ gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), GTK_WIDGET(menuitem));
+ gtk_widget_show(GTK_WIDGET(menuitem));
+
spell_menu = g_slist_reverse(spell_menu);
for (items = spell_menu;
items; items = items->next) {
g_slist_free(spell_menu);
g_signal_connect(G_OBJECT(menu), "deactivate",
- G_CALLBACK(destroy_menu),
+ G_CALLBACK(destroy_menu),
gtkaspell);
if (suggest)
g_signal_connect(G_OBJECT(menu),
"key_press_event",
- G_CALLBACK(aspell_key_pressed), gtkaspell);
+ G_CALLBACK(aspell_key_pressed),
+ gtkaspell);
+}
+
+static void set_position_cb(gpointer data, gint pos)
+{
+ GtkAspell *gtkaspell = (GtkAspell *) data;
+ set_textview_buffer_offset(gtkaspell->gtktext, pos);
+}
+
+void gtkaspell_context_set(GtkAspell *gtkaspell)
+{
+ gtkaspell->ctx.set_position = set_position_cb;
+ gtkaspell->ctx.set_menu_pos = set_menu_pos;
+ gtkaspell->ctx.find_misspelled = find_misspelled_cb;
+ gtkaspell->ctx.check_word = check_at_cb;
+ gtkaspell->ctx.replace_word = replace_real_word_cb;
+ gtkaspell->ctx.data = (gpointer) gtkaspell;
+}
+static void button_press_intercept_cb(GtkTextView *gtktext,
+ GtkMenu *menu, GtkAspell *gtkaspell)
+{
+ gtktext = gtkaspell->gtktext;
+ gtkaspell->orig_pos = get_textview_buffer_offset(gtktext);
+ gtkaspell->misspelled = check_at(gtkaspell, gtkaspell->orig_pos);
+ gtkaspell_context_set(gtkaspell);
+ gtkaspell_make_context_menu(menu, gtkaspell);
}
/* Checker creation */
static GtkAspeller *gtkaspeller_new(Dictionary *dictionary)
{
- GSList *exist;
GtkAspeller *gtkaspeller = NULL;
GtkAspeller *tmp;
Dictionary *dict;
- g_return_val_if_fail(gtkaspellcheckers, NULL);
+ cm_return_val_if_fail(gtkaspellcheckers, NULL);
- g_return_val_if_fail(dictionary, NULL);
+ cm_return_val_if_fail(dictionary, NULL);
- if (dictionary->fullname == NULL)
+ if (dictionary->dictname == NULL)
gtkaspell_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;
- }
+ cm_return_val_if_fail(dictionary->fullname, NULL);
dict = dictionary_dup(dictionary);
tmp = g_new0(GtkAspeller, 1);
tmp->dictionary = dict;
- exist = g_slist_find_custom(gtkaspellcheckers->checkers, tmp,
- find_gtkaspeller);
-
g_free(tmp);
if ((gtkaspeller = gtkaspeller_real_new(dict)) != NULL) {
static GtkAspeller *gtkaspeller_real_new(Dictionary *dict)
{
GtkAspeller *gtkaspeller;
- AspellConfig *config;
- AspellCanHaveError *ret;
+ EnchantBroker *broker;
+ EnchantDict *speller;
- g_return_val_if_fail(gtkaspellcheckers, NULL);
- g_return_val_if_fail(dict, NULL);
+ cm_return_val_if_fail(gtkaspellcheckers, NULL);
+ cm_return_val_if_fail(dict, NULL);
gtkaspeller = g_new(GtkAspeller, 1);
gtkaspeller->dictionary = dict;
- gtkaspeller->sug_mode = ASPELL_FASTMODE;
- config = new_aspell_config();
+ broker = enchant_broker_init();
- if (!set_dictionary(config, dict))
+ if (!broker) {
+ gtkaspell_checkers_error_message(
+ g_strdup(_("Couldn't initialize Enchant broker.")));
+ g_free(gtkaspeller);
return NULL;
-
- ret = new_aspell_speller(config);
- delete_aspell_config(config);
-
- if (aspell_error_number(ret) != 0) {
- gtkaspellcheckers->error_message
- = g_strdup(aspell_error_message(ret));
-
- delete_aspell_can_have_error(ret);
-
+ }
+ if ((speller = set_dictionary(broker, dict)) == NULL) {
+ gtkaspell_checkers_error_message(
+ g_strdup_printf(_("Couldn't initialize %s dictionary:"), dict->fullname));
+ gtkaspell_checkers_error_message(
+ g_strdup(enchant_broker_get_error(broker)));
+ g_free(gtkaspeller);
return NULL;
}
-
- gtkaspeller->checker = to_aspell_speller(ret);
- gtkaspeller->config = aspell_speller_config(gtkaspeller->checker);
+ gtkaspeller->speller = speller;
+ gtkaspeller->broker = broker;
return gtkaspeller;
}
static GtkAspeller *gtkaspeller_delete(GtkAspeller *gtkaspeller)
{
- g_return_val_if_fail(gtkaspellcheckers, NULL);
+ cm_return_val_if_fail(gtkaspellcheckers, NULL);
gtkaspellcheckers->checkers =
g_slist_remove(gtkaspellcheckers->checkers,
static GtkAspeller *gtkaspeller_real_delete(GtkAspeller *gtkaspeller)
{
- g_return_val_if_fail(gtkaspeller, NULL);
- g_return_val_if_fail(gtkaspeller->checker, NULL);
-
- aspell_speller_save_all_word_lists(gtkaspeller->checker);
+ cm_return_val_if_fail(gtkaspeller, NULL);
+ cm_return_val_if_fail(gtkaspeller->speller, NULL);
- delete_aspell_speller(gtkaspeller->checker);
+ enchant_broker_free_dict(gtkaspeller->broker, gtkaspeller->speller);
+ enchant_broker_free(gtkaspeller->broker);
dictionary_delete(gtkaspeller->dictionary);
/*****************************************************************************/
/* Checker configuration */
-static gboolean set_dictionary(AspellConfig *config, Dictionary *dict)
+static EnchantDict *set_dictionary(EnchantBroker *broker, Dictionary *dict)
{
- gchar *language = NULL;
- gchar *jargon = NULL;
- gchar *size = 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("dict-dir", buf);
- debug_print("Aspell: looking for dictionaries in path %s.\n", buf);
+ cm_return_val_if_fail(broker, FALSE);
+ cm_return_val_if_fail(dict, FALSE);
- strncpy(buf, dict->dictname, BUFSIZE-1);
- language = buf;
-
- if ((size = strrchr(buf, '-')) && isdigit((int) size[1]))
- *size++ = 0x00;
- else
- size = NULL;
-
- if ((jargon = strchr(language, '-')) != NULL)
- *jargon++ = 0x00;
-
- if (size != NULL && jargon == size)
- jargon = NULL;
-
- debug_print("Aspell: language: %s, jargon: %s, size: %s\n",
- language, jargon ? jargon : "",
- size ? size : "");
-
- if (language)
- CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("lang", language);
- if (jargon)
- CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("jargon", jargon);
- if (size)
- CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("size", size);
- if (dict->encoding) {
- gchar *aspell_enc;
-
- aspell_enc = convert_to_aspell_encoding (dict->encoding);
- aspell_config_replace(config, "encoding",
- (const char *) aspell_enc);
- g_free(aspell_enc);
-
- RETURN_FALSE_IF_CONFIG_ERROR();
- }
-
- return TRUE;
-}
-
-/* set_sug_mode_cb() - Menu callback: Set the suggestion mode */
-static void set_sug_mode_cb(GtkMenuItem *w, GtkAspell *gtkaspell)
-{
- char *themode;
-
- themode = (char *) gtk_label_get_text(GTK_LABEL(GTK_BIN(w)->child));
- themode = g_strdup(themode);
-
- set_real_sug_mode(gtkaspell, themode);
- g_free(themode);
- if (gtkaspell->menu_changed_cb)
- gtkaspell->menu_changed_cb(gtkaspell->menu_changed_data);
+ return enchant_broker_request_dict(broker, dict->dictname );
}
-/* set_sug_mode_cb() - Menu callback: Set the suggestion mode */
static void set_use_both_cb(GtkMenuItem *w, GtkAspell *gtkaspell)
{
gtkaspell->use_both_dicts = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w));
-
- if (gtkaspell->recheck_when_changing_dict) {
- gtkaspell_highlight_all(gtkaspell);
- }
+ gtkaspell_dict_changed(gtkaspell);
if (gtkaspell->menu_changed_cb)
gtkaspell->menu_changed_cb(gtkaspell->menu_changed_data);
}
-
-static void set_real_sug_mode(GtkAspell *gtkaspell, const char *themode)
-{
- gint result;
- gint mode = ASPELL_FASTMODE;
- g_return_if_fail(gtkaspell);
- g_return_if_fail(gtkaspell->gtkaspeller);
- g_return_if_fail(themode);
-
- if (!strcmp(themode,_("Normal Mode")))
- mode = ASPELL_NORMALMODE;
- else if (!strcmp( themode,_("Bad Spellers Mode")))
- mode = ASPELL_BADSPELLERMODE;
-
- result = gtkaspell_set_sug_mode(gtkaspell, mode);
-
- if(!result) {
- debug_print("Aspell: error while changing suggestion mode:%s\n",
- gtkaspellcheckers->error_message);
- gtkaspell_checkers_reset_error();
- }
-}
-/* gtkaspell_set_sug_mode() - Set the suggestion mode */
-gboolean gtkaspell_set_sug_mode(GtkAspell *gtkaspell, gint themode)
-{
- AspellConfig *config;
-
- g_return_val_if_fail(gtkaspell, FALSE);
- g_return_val_if_fail(gtkaspell->gtkaspeller, FALSE);
- g_return_val_if_fail(gtkaspell->gtkaspeller->config, FALSE);
-
- debug_print("Aspell: setting sug mode of gtkaspeller %p to %d\n",
- gtkaspell->gtkaspeller, themode);
-
- config = gtkaspell->gtkaspeller->config;
-
- switch (themode) {
- case ASPELL_FASTMODE:
- CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "fast");
- break;
- case ASPELL_NORMALMODE:
- CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "normal");
- break;
- case ASPELL_BADSPELLERMODE:
- CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode",
- "bad-spellers");
- break;
- default:
- gtkaspellcheckers->error_message =
- g_strdup(_("Unknown suggestion mode."));
- return FALSE;
- }
-
- gtkaspell->gtkaspeller->sug_mode = themode;
- gtkaspell->default_sug_mode = themode;
-
- return TRUE;
-}
-
/* misspelled_suggest() - Create a suggestion list for word */
static GList *misspelled_suggest(GtkAspell *gtkaspell, gchar *word)
{
- const guchar *newword;
GList *list = NULL;
- const AspellWordList *suggestions;
- AspellStringEnumeration *elements;
+ char **suggestions;
+ size_t num_sug, i;
+ cm_return_val_if_fail(word, NULL);
- g_return_val_if_fail(word, NULL);
+ if (*word == 0)
+ return NULL;
- if (!aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1)) {
- free_suggestions_list(gtkaspell);
+ gtkaspell_free_suggestions_list(gtkaspell);
- suggestions = aspell_speller_suggest(
- gtkaspell->gtkaspeller->checker,
- (const char *)word, -1);
- elements = aspell_word_list_elements(suggestions);
- list = g_list_append(list, g_strdup(word));
-
- while ((newword = (guchar *)aspell_string_enumeration_next(elements)) != NULL)
- list = g_list_append(list, g_strdup((gchar *)newword));
-
- gtkaspell->max_sug = g_list_length(list) - 1;
+ suggestions = enchant_dict_suggest(gtkaspell->gtkaspeller->speller, word, strlen(word), &num_sug);
+ list = g_list_append(list, g_strdup(word));
+ if (suggestions == NULL || num_sug == 0) {
+ gtkaspell->max_sug = -1;
gtkaspell->suggestions_list = list;
-
return list;
}
+ for (i = 0; i < num_sug; i++)
+ list = g_list_append(list, g_strdup((gchar *)suggestions[i]));
- free_suggestions_list(gtkaspell);
-
- return NULL;
+ gtkaspell->max_sug = num_sug - 1;
+ gtkaspell->suggestions_list = list;
+ enchant_dict_free_string_list(gtkaspell->gtkaspeller->speller, suggestions);
+ return list;
}
/* misspelled_test() - Just test if word is correctly spelled */
-static int misspelled_test(GtkAspell *gtkaspell, unsigned char *word)
+int gtkaspell_misspelled_test(GtkAspell *gtkaspell, char *word)
{
- gint result = aspell_speller_check(gtkaspell->gtkaspeller->checker, (char *)word, -1)
- ? 0 : 1;
+ gint result = 0;
+ cm_return_val_if_fail(word, 0);
+
+ if (*word == 0)
+ return 0;
+
+ result = enchant_dict_check(gtkaspell->gtkaspeller->speller, word, strlen(word));
+
if (result && gtkaspell->use_both_dicts && gtkaspell->alternate_speller) {
- use_alternate_dict(gtkaspell);
- result = aspell_speller_check(gtkaspell->gtkaspeller->checker, (char *)word, -1)
- ? 0 : 1;
- use_alternate_dict(gtkaspell);
+ gtkaspell_use_alternate_dict(gtkaspell);
+ result = enchant_dict_check(gtkaspell->gtkaspeller->speller, word, strlen(word));
+ gtkaspell_use_alternate_dict(gtkaspell);
}
- return result;
+ return (result && strcasecmp(word, "sylpheed") &&
+ strcasecmp(word, "claws-mail"));
}
gtk_text_buffer_get_iter_at_offset(buffer, &end, pos+1);
utf8chars = gtk_text_iter_get_text(&start, &end);
- if (is_ascii_str(utf8chars)) {
- a = utf8chars ? (gunichar)utf8chars[0] : '\0' ;
- } else {
- gchar *tr = conv_iconv_strdup(utf8chars, CS_UTF_8,
- gtkaspell->gtkaspeller->dictionary->encoding);
- if (tr) {
- a = g_utf8_get_char(tr);
- g_free(tr);
- }
- }
+ a = g_utf8_get_char(utf8chars);
g_free(utf8chars);
return a;
/* get_word_from_pos () - return the word pointed to. */
/* Handles correctly the quotes. */
static gboolean get_word_from_pos(GtkAspell *gtkaspell, gint pos,
- unsigned char* buf, gint buflen,
+ char* buf, gint buflen,
gint *pstart, gint *pend)
{
if (buf) {
if (end - start < buflen) {
GtkTextIter iterstart, iterend;
- gchar *tmp, *conv;
+ gchar *tmp;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(gtktext);
gtk_text_buffer_get_iter_at_offset(buffer, &iterstart, start);
gtk_text_buffer_get_iter_at_offset(buffer, &iterend, end);
tmp = gtk_text_buffer_get_text(buffer, &iterstart, &iterend, FALSE);
- conv = conv_iconv_strdup(tmp, CS_UTF_8,
- gtkaspell->gtkaspeller->dictionary->encoding);
- g_free(tmp);
- strncpy((char *)buf, conv, buflen-1);
+ strncpy(buf, tmp, buflen-1);
buf[buflen-1]='\0';
- g_free(conv);
+ g_free(tmp);
} else
return FALSE;
}
static gboolean check_at(GtkAspell *gtkaspell, gint from_pos)
{
gint start, end;
- unsigned char buf[GTKASPELLWORDSIZE];
- GtkTextView *gtktext;
+ char buf[GTKASPELLWORDSIZE];
- g_return_val_if_fail(from_pos >= 0, FALSE);
+ cm_return_val_if_fail(from_pos >= 0, FALSE);
- gtktext = gtkaspell->gtktext;
-
if (!get_word_from_pos(gtkaspell, from_pos, buf, sizeof(buf),
&start, &end))
return FALSE;
- if (misspelled_test(gtkaspell, buf)
- && strcasecmp((char *)buf, "sylpheed") && strcasecmp((char *)buf, "claws-mail")) {
+ if (gtkaspell_misspelled_test(gtkaspell, buf)) {
strncpy(gtkaspell->theword, (gchar *)buf, GTKASPELLWORDSIZE - 1);
gtkaspell->theword[GTKASPELLWORDSIZE - 1] = 0;
gtkaspell->start_pos = start;
gtkaspell->end_pos = end;
- free_suggestions_list(gtkaspell);
+ gtkaspell_free_suggestions_list(gtkaspell);
change_color(gtkaspell, start, end, (gchar *)buf, &(gtkaspell->highlight));
return TRUE;
}
}
-static gboolean check_next_prev(GtkAspell *gtkaspell, gboolean forward)
+static gboolean check_at_cb(gpointer data)
{
+ GtkAspell *gtkaspell = (GtkAspell *)data;
+ return check_at(gtkaspell, gtkaspell->start_pos);
+}
+
+static gboolean find_misspelled_cb(gpointer data, gboolean forward)
+{
+ GtkAspell *gtkaspell = (GtkAspell *)data;
+ gboolean misspelled;
gint pos;
gint minpos;
gint maxpos;
gint direc = -1;
- gboolean misspelled;
minpos = 0;
maxpos = gtkaspell->end_check_pos;
pos > minpos && pos <= maxpos)
pos += direc;
}
+
+ return misspelled;
+}
+
+gboolean gtkaspell_check_next_prev(GtkAspell *gtkaspell, gboolean forward)
+{
+ gboolean misspelled = gtkaspell->ctx.find_misspelled(gtkaspell->ctx.data,
+ forward);
if (misspelled) {
GSList *list, *cur;
GtkWidget *menu;
if (forward)
gtkaspell->orig_pos = gtkaspell->end_pos;
- set_textview_buffer_offset(gtkaspell->gtktext,
- gtkaspell->end_pos);
- /* scroll line to window center */
- gtk_text_view_scroll_to_mark(gtkaspell->gtktext,
- gtk_text_buffer_get_insert(
- gtk_text_view_get_buffer(gtkaspell->gtktext)),
- 0.0, TRUE, 0.0, 0.5);
- /* let textview recalculate coordinates (set_menu_pos) */
- while (gtk_events_pending ())
- gtk_main_iteration ();
+ gtkaspell->ctx.set_position(gtkaspell->ctx.data, gtkaspell->end_pos);
+
+ /* only execute when in textview context */
+ if (gtkaspell == (GtkAspell *)gtkaspell->ctx.data) {
+ /* scroll line to window center */
+ gtk_text_view_scroll_to_mark(gtkaspell->gtktext,
+ gtk_text_buffer_get_insert(
+ gtk_text_view_get_buffer(gtkaspell->gtktext)),
+ 0.0, TRUE, 0.0, 0.5);
+ /* let textview recalculate coordinates (set_menu_pos) */
+ while (gtk_events_pending ())
+ gtk_main_iteration ();
+ }
list = make_sug_menu(gtkaspell);
menu = gtk_menu_new();
for (cur = list; cur; cur = cur->next)
- gtk_menu_append(menu, GTK_WIDGET(cur->data));
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), GTK_WIDGET(cur->data));
g_slist_free(list);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
- set_menu_pos, gtkaspell, 0, GDK_CURRENT_TIME);
+ gtkaspell->ctx.set_menu_pos,
+ gtkaspell->ctx.data,
+ 0, GDK_CURRENT_TIME);
g_signal_connect(G_OBJECT(menu), "deactivate",
- G_CALLBACK(destroy_menu),
+ G_CALLBACK(destroy_menu),
gtkaspell);
g_signal_connect(G_OBJECT(menu),
"key_press_event",
- G_CALLBACK(aspell_key_pressed), gtkaspell);
+ G_CALLBACK(aspell_key_pressed),
+ gtkaspell);
} else {
reset_theword_data(gtkaspell);
alertpanel_notice(_("No misspelled word found."));
- set_textview_buffer_offset(gtkaspell->gtktext,
- gtkaspell->orig_pos);
+ gtkaspell->ctx.set_position(gtkaspell->ctx.data,
+ gtkaspell->orig_pos);
}
return misspelled;
gtkaspell->continue_check = NULL;
gtkaspell->end_check_pos =
get_textview_buffer_charcount(gtkaspell->gtktext);
- check_next_prev(gtkaspell, FALSE);
+ gtkaspell_context_set(gtkaspell);
+ gtkaspell_check_next_prev(gtkaspell, FALSE);
}
void gtkaspell_check_forwards_go(GtkAspell *gtkaspell)
gtkaspell->continue_check = NULL;
gtkaspell->end_check_pos =
get_textview_buffer_charcount(gtkaspell->gtktext);
- check_next_prev(gtkaspell, TRUE);
+ gtkaspell_context_set(gtkaspell);
+ gtkaspell_check_next_prev(gtkaspell, TRUE);
}
void gtkaspell_check_all(GtkAspell *gtkaspell)
GtkTextBuffer *buffer;
GtkTextIter startiter, enditer;
- g_return_if_fail(gtkaspell);
- g_return_if_fail(gtkaspell->gtktext);
+ cm_return_if_fail(gtkaspell);
+ cm_return_if_fail(gtkaspell->gtktext);
gtktext = gtkaspell->gtktext;
buffer = gtk_text_view_get_buffer(gtktext);
gtkaspell->continue_check = continue_check;
gtkaspell->end_check_pos = end;
- gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
+ gtkaspell_context_set(gtkaspell);
+ gtkaspell->misspelled = gtkaspell_check_next_prev(gtkaspell, TRUE);
}
static void continue_check(gpointer *data)
GtkAspell *gtkaspell = (GtkAspell *) data;
gint pos = get_textview_buffer_offset(gtkaspell->gtktext);
if (pos < gtkaspell->end_check_pos && gtkaspell->misspelled)
- gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
+ gtkaspell->misspelled = gtkaspell_check_next_prev(gtkaspell, TRUE);
else
gtkaspell->continue_check = NULL;
}
guint len;
GtkTextView *gtktext;
- g_return_if_fail(gtkaspell->gtkaspeller->checker);
+ cm_return_if_fail(gtkaspell->gtkaspeller->speller);
gtktext = gtkaspell->gtktext;
static void replace_with_supplied_word_cb(GtkWidget *w, GtkAspell *gtkaspell)
{
- unsigned char *newword;
+ char *newword;
GdkEvent *e= (GdkEvent *) gtk_get_current_event();
- newword = (unsigned char *)gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->replace_entry),
+ newword = gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->replace_entry),
0, -1);
- if (strcmp((char *)newword, gtkaspell->theword)) {
- replace_real_word(gtkaspell, (char *)newword);
+ if (strcmp(newword, gtkaspell->theword)) {
+ gtkaspell->ctx.replace_word(gtkaspell->ctx.data, newword);
if ((e->type == GDK_KEY_PRESS &&
((GdkEventKey *) e)->state & GDK_CONTROL_MASK)) {
- aspell_speller_store_replacement(
- gtkaspell->gtkaspeller->checker,
- gtkaspell->theword, -1,
- (char *)newword, -1);
+ enchant_dict_store_replacement(gtkaspell->gtkaspeller->speller,
+ gtkaspell->theword, strlen(gtkaspell->theword),
+ newword, strlen(newword));
}
gtkaspell->replace_entry = NULL;
}
static void replace_word_cb(GtkWidget *w, gpointer data)
{
- unsigned char *newword;
+ const char *newword;
GtkAspell *gtkaspell = (GtkAspell *) data;
GdkEvent *e= (GdkEvent *) gtk_get_current_event();
- newword = (unsigned char *) gtk_label_get_text(GTK_LABEL(GTK_BIN(w)->child));
- newword = (unsigned char *)g_strdup((char *)newword);
+ newword = gtk_label_get_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN((w)))));
- replace_real_word(gtkaspell, (char *)newword);
+ gtkaspell->ctx.replace_word(gtkaspell->ctx.data, newword);
if ((e->type == GDK_KEY_PRESS &&
((GdkEventKey *) e)->state & GDK_CONTROL_MASK) ||
(e->type == GDK_BUTTON_RELEASE &&
((GdkEventButton *) e)->state & GDK_CONTROL_MASK)) {
- aspell_speller_store_replacement(
- gtkaspell->gtkaspeller->checker,
- gtkaspell->theword, -1,
- (char *)newword, -1);
+ enchant_dict_store_replacement(gtkaspell->gtkaspeller->speller,
+ gtkaspell->theword, strlen(gtkaspell->theword),
+ newword, strlen(newword));
}
gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
set_point_continue(gtkaspell);
- g_free(newword);
}
-static void replace_real_word(GtkAspell *gtkaspell, gchar *newword)
+void gtkaspell_block_check(GtkAspell *gtkaspell)
+{
+ GtkTextView *gtktext;
+
+ if (gtkaspell == NULL)
+ return;
+
+ gtktext = gtkaspell->gtktext;
+ g_signal_handlers_block_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(key_press_cb),
+ gtkaspell);
+ g_signal_handlers_block_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(entry_insert_cb),
+ gtkaspell);
+ g_signal_handlers_block_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(entry_delete_cb),
+ gtkaspell);
+}
+
+void gtkaspell_unblock_check(GtkAspell *gtkaspell)
+{
+ GtkTextView *gtktext;
+
+ if (gtkaspell == NULL)
+ return;
+
+ gtktext = gtkaspell->gtktext;
+ g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(key_press_cb),
+ gtkaspell);
+ g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(entry_insert_cb),
+ gtkaspell);
+ g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(entry_delete_cb),
+ gtkaspell);
+}
+
+static void replace_real_word(GtkAspell *gtkaspell, const gchar *newword)
{
- int oldlen, newlen, wordlen;
+ int oldlen, newlen;
gint origpos;
gint pos;
GtkTextView *gtktext;
origpos = gtkaspell->orig_pos;
pos = origpos;
oldlen = gtkaspell->end_pos - gtkaspell->start_pos;
- wordlen = strlen(gtkaspell->theword);
newlen = strlen(newword); /* FIXME: multybyte characters? */
- g_signal_handlers_block_by_func(G_OBJECT(gtktext),
- G_CALLBACK(entry_insert_cb),
- gtkaspell);
- g_signal_handlers_block_by_func(G_OBJECT(gtktext),
- G_CALLBACK(entry_delete_cb),
- gtkaspell);
+ gtkaspell_block_check(gtkaspell);
gtk_text_buffer_get_iter_at_offset(textbuf, &startiter,
gtkaspell->start_pos);
g_signal_emit_by_name(G_OBJECT(textbuf), "insert-text",
&startiter, newword, newlen, gtkaspell);
- g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
- G_CALLBACK(entry_insert_cb),
- gtkaspell);
- g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
- G_CALLBACK(entry_delete_cb),
- gtkaspell);
+ gtkaspell_unblock_check(gtkaspell);
/* 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
set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
}
+static void replace_real_word_cb(gpointer data, const gchar *newword)
+{
+ replace_real_word((GtkAspell *)data, newword);
+}
+
/* Accept this word for this session */
static void add_word_to_session_cb(GtkWidget *w, gpointer data)
{
- guint pos;
- GtkTextView *gtktext;
GtkAspell *gtkaspell = (GtkAspell *) data;
- gtktext = gtkaspell->gtktext;
- pos = get_textview_buffer_offset(gtktext);
+ enchant_dict_add_to_session(gtkaspell->gtkaspeller->speller, gtkaspell->theword, strlen(gtkaspell->theword));
- aspell_speller_add_to_session(gtkaspell->gtkaspeller->checker,
- gtkaspell->theword,
- strlen(gtkaspell->theword));
-
- check_at(gtkaspell, gtkaspell->start_pos);
+ gtkaspell->ctx.check_word(gtkaspell->ctx.data);
+ gtkaspell_dict_changed(gtkaspell);
gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
{
GtkAspell *gtkaspell = (GtkAspell *) data;
- aspell_speller_add_to_personal(gtkaspell->gtkaspeller->checker,
- gtkaspell->theword,
- strlen(gtkaspell->theword));
-
- check_at(gtkaspell, gtkaspell->start_pos);
+ enchant_dict_add_to_pwl(gtkaspell->gtkaspeller->speller, gtkaspell->theword, strlen(gtkaspell->theword));
+ gtkaspell->ctx.check_word(gtkaspell->ctx.data);
+ gtkaspell_dict_changed(gtkaspell);
+
gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
set_point_continue(gtkaspell);
}
static void check_with_alternate_cb(GtkWidget *w, gpointer data)
{
- GtkAspell *gtkaspell = (GtkAspell *) data;
+ GtkAspell *gtkaspell = (GtkAspell *)data;
gint misspelled;
gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
- use_alternate_dict(gtkaspell);
- misspelled = check_at(gtkaspell, gtkaspell->start_pos);
+ gtkaspell_use_alternate_dict(gtkaspell);
+ misspelled = gtkaspell->ctx.check_word(gtkaspell->ctx.data);
if (!gtkaspell->continue_check) {
GSList *list, *cur;
misspelled_suggest(gtkaspell, gtkaspell->theword);
- set_textview_buffer_offset(gtkaspell->gtktext,
+ gtkaspell->ctx.set_position(gtkaspell->ctx.data,
gtkaspell->end_pos);
list = make_sug_menu(gtkaspell);
menu = gtk_menu_new();
for (cur = list; cur; cur = cur->next)
- gtk_menu_append(menu, GTK_WIDGET(cur->data));
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), GTK_WIDGET(cur->data));
g_slist_free(list);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
- set_menu_pos, gtkaspell, 0,
+ gtkaspell->ctx.set_menu_pos,
+ gtkaspell->ctx.data, 0,
GDK_CURRENT_TIME);
g_signal_connect(G_OBJECT(menu), "deactivate",
- G_CALLBACK(destroy_menu),
+ G_CALLBACK(destroy_menu),
gtkaspell);
g_signal_connect(G_OBJECT(menu),
"key_press_event",
- G_CALLBACK(aspell_key_pressed), gtkaspell);
+ G_CALLBACK(aspell_key_pressed),
+ gtkaspell);
return;
}
} else
GdkEventKey *event,
GtkAspell *gtkaspell)
{
- if (event && event->keyval == GDK_Escape) {
+ if (event && event->keyval == GDK_KEY_Escape) {
gtk_widget_destroy(widget);
return TRUE;
- } else if (event && event->keyval == GDK_Return) {
+ } else if (event && event->keyval == GDK_KEY_Return) {
replace_with_supplied_word_cb(widget, gtkaspell);
return TRUE;
}
static PangoFontDescription *font_desc;
GtkWidget *dialog;
GtkWidget *label;
- GtkWidget *w_hbox;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *entry;
GtkWidget *cancel_button;
GtkWidget *confirm_area;
GtkWidget *icon;
- gchar *thelabel;
+ gchar *utf8buf, *thelabel;
gint xx, yy;
GtkAspell *gtkaspell = (GtkAspell *) data;
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_window_set_title(GTK_WINDOW(dialog),_("Replace unknown word"));
- gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
- gtk_widget_set_uposition(dialog, xx, yy);
+ gtk_window_move(GTK_WINDOW(dialog), xx, yy);
g_signal_connect_swapped(G_OBJECT(dialog), "destroy",
G_CALLBACK(gtk_widget_destroy),
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
FALSE, FALSE, 0);
+ utf8buf = g_strdup(gtkaspell->theword);
+
thelabel = g_strdup_printf(_("<span weight=\"bold\" "
"size=\"larger\">Replace \"%s\" with: </span>"),
- gtkaspell->theword);
- /* for title label */
- w_hbox = gtk_hbox_new(FALSE, 0);
+ utf8buf);
icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION,
GTK_ICON_SIZE_DIALOG);
entry = gtk_entry_new();
gtkaspell->replace_entry = entry;
- gtk_entry_set_text(GTK_ENTRY(entry), gtkaspell->theword);
+ gtk_entry_set_text(GTK_ENTRY(entry), utf8buf);
gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
g_signal_connect(G_OBJECT(dialog),
"key_press_event",
G_CALLBACK(replace_key_pressed), gtkaspell);
gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
+ g_free(utf8buf);
label = gtk_label_new(_("Holding down Control key while pressing "
"Enter\nwill learn from mistake.\n"));
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
- hbox = gtk_hbox_new(TRUE, 0);
-
gtkut_stock_button_set_create(&confirm_area,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK,
dict = g_new0(Dictionary, 1);
dict->fullname = g_strdup(_("None"));
- dict->dictname = dict->fullname;
- dict->encoding = NULL;
+ dict->dictname = NULL;
return g_slist_append(list, dict);
}
+static void list_dict_cb(const char * const lang_tag,
+ const char * const provider_name,
+ const char * const provider_desc,
+ const char * const provider_file,
+ void * data)
+{
+ GSList **list = (GSList **)data;
+ Dictionary *dict = g_new0(Dictionary, 1);
+ dict->fullname = g_strdup(lang_tag);
+ dict->dictname = g_strdup(lang_tag);
+
+ if (g_slist_find_custom(*list, dict,
+ (GCompareFunc) compare_dict) == NULL) {
+ debug_print("Aspell: found dictionary %s %s\n", dict->fullname,
+ dict->dictname);
+ *list = g_slist_insert_sorted(*list, dict,
+ (GCompareFunc) compare_dict);
+ } else {
+ dictionary_delete(dict);
+ }
+}
+
/* gtkaspell_get_dictionary_list() - returns list of dictionary names */
-static GSList *gtkaspell_get_dictionary_list(const gchar *aspell_path, gint refresh)
+static GSList *gtkaspell_get_dictionary_list(gint refresh)
{
GSList *list;
- Dictionary *dict;
- AspellConfig *config;
- AspellDictInfoList *dlist;
- AspellDictInfoEnumeration *dels;
- const AspellDictInfo *entry;
+ EnchantBroker *broker;
if (!gtkaspellcheckers)
gtkaspell_checkers_init();
gtkaspellcheckers->dictionary_list);
list = NULL;
- config = new_aspell_config();
+ broker = enchant_broker_init();
- aspell_config_replace(config, "dict-dir", aspell_path);
- if (aspell_config_error_number(config) != 0) {
- gtkaspellcheckers->error_message = g_strdup(
- aspell_config_error_message(config));
- gtkaspellcheckers->dictionary_list =
- create_empty_dictionary_list();
+ enchant_broker_list_dicts(broker, list_dict_cb, &list);
- return gtkaspellcheckers->dictionary_list;
- }
+ enchant_broker_free(broker);
- dlist = get_aspell_dict_info_list(config);
- delete_aspell_config(config);
-
- debug_print("Aspell: checking for dictionaries in %s\n", aspell_path);
- dels = aspell_dict_info_list_elements(dlist);
- while ( (entry = aspell_dict_info_enumeration_next(dels)) != 0)
- {
- dict = g_new0(Dictionary, 1);
- dict->fullname = g_strdup_printf("%s%s", aspell_path,
- entry->name);
- dict->dictname = dict->fullname + strlen(aspell_path);
- dict->encoding = g_strdup(entry->code);
-
- if (g_slist_find_custom(list, dict,
- (GCompareFunc) compare_dict) != NULL) {
- dictionary_delete(dict);
- continue;
- }
-
- debug_print("Aspell: found dictionary %s %s %s\n", dict->fullname,
- dict->dictname, dict->encoding);
- list = g_slist_insert_sorted(list, dict,
- (GCompareFunc) compare_dict);
- }
-
- delete_aspell_dict_info_enumeration(dels);
-
- if(list==NULL){
+ if (list == NULL){
debug_print("Aspell: error when searching for dictionaries: "
"No dictionary found.\n");
g_slist_free(list);
}
-/* FIXME */
-GtkWidget *gtkaspell_dictionary_option_menu_new_with_refresh(const gchar *aspell_path,
- gboolean refresh)
+GtkTreeModel *gtkaspell_dictionary_store_new_with_refresh(gboolean refresh)
{
GSList *dict_list, *tmp;
- GtkWidget *item;
- GtkWidget *menu;
+ GtkListStore *store;
+ GtkTreeIter iter;
Dictionary *dict;
- dict_list = gtkaspell_get_dictionary_list(aspell_path, refresh);
- g_return_val_if_fail(dict_list, NULL);
+ dict_list = gtkaspell_get_dictionary_list(refresh);
+ cm_return_val_if_fail(dict_list, NULL);
- menu = gtk_menu_new();
+ store = gtk_list_store_new(SET_GTKASPELL_SIZE,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ -1);
for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
dict = (Dictionary *) tmp->data;
- item = gtk_menu_item_new_with_label(dict->dictname);
- g_object_set_data(G_OBJECT(item), "dict_name",
- dict->fullname);
-
- gtk_menu_append(GTK_MENU(menu), item);
- gtk_widget_show(item);
+
+ gtk_list_store_append(store, &iter);
+ gtk_list_store_set(store, &iter,
+ SET_GTKASPELL_NAME, dict->dictname,
+ SET_GTKASPELL_FULLNAME, dict->fullname,
+ -1);
}
- gtk_widget_show(menu);
-
- return menu;
+ return GTK_TREE_MODEL(store);
}
-GtkWidget *gtkaspell_dictionary_option_menu_new(const gchar *aspell_path)
+GtkTreeModel *gtkaspell_dictionary_store_new(void)
{
- return gtkaspell_dictionary_option_menu_new_with_refresh
- (aspell_path, TRUE);
-
-}
-
-gchar *gtkaspell_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 *) g_object_get_data(G_OBJECT(menuitem),
- "dict_name");
- g_return_val_if_fail(dict_fullname, NULL);
-
- label = g_strdup(dict_fullname);
-
- return label;
-
+ return gtkaspell_dictionary_store_new_with_refresh
+ (TRUE);
}
-gint gtkaspell_set_dictionary_menu_active_item(GtkWidget *menu,
- const gchar *dictionary)
+GtkWidget *gtkaspell_dictionary_combo_new(const gboolean refresh)
{
- GList *cur;
- gint n;
-
- g_return_val_if_fail(menu != NULL, 0);
- g_return_val_if_fail(dictionary != NULL, 0);
- g_return_val_if_fail(GTK_IS_OPTION_MENU(menu), 0);
+ GtkWidget *combo;
+ GtkCellRenderer *renderer;
- n = 0;
- for (cur = GTK_MENU_SHELL(gtk_option_menu_get_menu(
- GTK_OPTION_MENU(menu)))->children;
- cur != NULL; cur = cur->next) {
- GtkWidget *menuitem;
- gchar *dict_name;
-
- menuitem = GTK_WIDGET(cur->data);
- dict_name = g_object_get_data(G_OBJECT(menuitem),
- "dict_name");
- if ((dict_name != NULL) && !strcmp2(dict_name, dictionary)) {
- gtk_option_menu_set_history(GTK_OPTION_MENU(menu), n);
-
- return 1;
- }
- n++;
- }
-
- return 0;
-}
+ combo = gtk_combo_box_new_with_model(
+ gtkaspell_dictionary_store_new_with_refresh(refresh));
+ gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
+ gtk_widget_show(combo);
+
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE);
+ gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo),renderer,
+ "text", SET_GTKASPELL_NAME, NULL);
+
+ return combo;
+}
-/* FIXME */
-GtkWidget *gtkaspell_sugmode_option_menu_new(gint sugmode)
+gchar *gtkaspell_get_dictionary_menu_active_item(GtkComboBox *combo)
{
- 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);
- g_object_set_data(G_OBJECT(item), "sugmode",
- GINT_TO_POINTER(ASPELL_FASTMODE));
-
- item = gtk_menu_item_new_with_label(_("Normal Mode"));
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
- g_object_set_data(G_OBJECT(item), "sugmode",
- GINT_TO_POINTER(ASPELL_NORMALMODE));
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ gchar *dict_fullname = NULL;
- item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
- g_object_set_data(G_OBJECT(item), "sugmode",
- GINT_TO_POINTER(ASPELL_BADSPELLERMODE));
-
- return menu;
-}
+ cm_return_val_if_fail(GTK_IS_COMBO_BOX(combo), NULL);
+ cm_return_val_if_fail(gtk_combo_box_get_active_iter(combo, &iter), NULL);
-void gtkaspell_sugmode_option_menu_set(GtkOptionMenu *optmenu, gint sugmode)
-{
- g_return_if_fail(GTK_IS_OPTION_MENU(optmenu));
-
- g_return_if_fail(sugmode == ASPELL_FASTMODE ||
- sugmode == ASPELL_NORMALMODE ||
- sugmode == ASPELL_BADSPELLERMODE);
+ model = gtk_combo_box_get_model(combo);
+ if(model == NULL)
+ return NULL;
+
+ gtk_tree_model_get(model, &iter,
+ SET_GTKASPELL_FULLNAME, &dict_fullname,
+ -1);
- gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
+ return dict_fullname;
}
-gint gtkaspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
+gint gtkaspell_set_dictionary_menu_active_item(GtkComboBox *combo,
+ const gchar *dictionary)
{
- gint sugmode;
- GtkWidget *item;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gchar *dict_name = NULL;
- g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
-
- item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
+ cm_return_val_if_fail(combo != NULL, 0);
+ cm_return_val_if_fail(dictionary != NULL, 0);
+ cm_return_val_if_fail(GTK_IS_COMBO_BOX(combo), 0);
+
+ if((model = gtk_combo_box_get_model(combo)) == NULL)
+ return 0;
+ if((gtk_tree_model_get_iter_first(model, &iter)) == FALSE)
+ return 0;
- sugmode = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item),
- "sugmode"));
-
- return sugmode;
+ do {
+ gtk_tree_model_get(model, &iter,
+ SET_GTKASPELL_FULLNAME, &dict_name,
+ -1);
+
+ if ((dict_name != NULL) && !strcmp2(dict_name, dictionary)) {
+ gtk_combo_box_set_active_iter(combo, &iter);
+ g_free(dict_name);
+ return 1;
+ }
+
+ g_free(dict_name);
+
+ } while ((gtk_tree_model_iter_next(model, &iter)) == TRUE);
+
+ return 0;
}
-static void use_alternate_dict(GtkAspell *gtkaspell)
+void gtkaspell_use_alternate_dict(GtkAspell *gtkaspell)
{
GtkAspeller *tmp;
static void destroy_menu(GtkWidget *widget,
gpointer user_data) {
-
GtkAspell *gtkaspell = (GtkAspell *)user_data;
if (gtkaspell->accel_group) {
GdkEventKey *event,
GtkAspell *gtkaspell)
{
- if (event && (isascii(event->keyval) || event->keyval == GDK_Return)) {
+ if (event && (isascii(event->keyval) || event->keyval == GDK_KEY_Return)) {
gtk_accel_groups_activate(
G_OBJECT(gtkaspell->parent_window),
event->keyval, event->state);
- } else if (event && event->keyval == GDK_Escape) {
+ } else if (event && event->keyval == GDK_KEY_Escape) {
destroy_menu(NULL, gtkaspell);
}
return FALSE;
}
+/* Create a paged submenu with choice of available dictionaries */
+static GtkWidget *make_dictionary_list_submenu(GtkAspell *gtkaspell)
+{
+ GtkWidget *menu, *curmenu, *moremenu, *item;
+ int count = 2;
+ Dictionary *dict;
+ GSList *tmp;
+
+ /* Dict list */
+ if (gtkaspellcheckers->dictionary_list == NULL)
+ gtkaspell_get_dictionary_list(FALSE);
+
+ menu = gtk_menu_new();
+ curmenu = menu;
+
+ item = gtk_menu_item_new_with_label(_("Change to..."));
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+
+ item = gtk_separator_menu_item_new();
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+
+ for (tmp = gtkaspellcheckers->dictionary_list; tmp != NULL;
+ tmp = g_slist_next(tmp)) {
+ if (count == MENUCOUNT) {
+
+ moremenu = gtk_menu_new();
+ item = gtk_menu_item_new_with_label(_("More..."));
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
+ moremenu);
+
+ gtk_menu_shell_append(GTK_MENU_SHELL(curmenu), item);
+ curmenu = moremenu;
+ count = 0;
+ }
+ dict = (Dictionary *) tmp->data;
+ item = gtk_check_menu_item_new_with_label(dict->fullname);
+ g_object_set_data(G_OBJECT(item), "dict_name",
+ dict->dictname);
+ if (strcmp2(dict->fullname,
+ gtkaspell->gtkaspeller->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);
+ }
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(change_dict_cb),
+ gtkaspell);
+ gtk_menu_shell_append(GTK_MENU_SHELL(curmenu), item);
+
+ count++;
+ }
+
+ gtk_widget_show_all(menu);
+ return menu;
+}
+
/* make_sug_menu() - Add menus to accept this word for this session
* and to add it to personal dictionary
*/
static GSList *make_sug_menu(GtkAspell *gtkaspell)
{
- GtkWidget *item;
+ GtkWidget *item, *submenu;
char *caption;
- GtkTextView *gtktext;
GtkAccelGroup *accel;
GList *l = gtkaspell->suggestions_list;
gchar *utf8buf;
GSList *list = NULL;
- gtktext = gtkaspell->gtktext;
+
+ if (l == NULL)
+ return NULL;
accel = gtk_accel_group_new();
gtkaspell->accel_group = NULL;
}
- utf8buf = conv_codeset_strdup((char*)l->data,
- conv_get_locale_charset_str(),
- CS_UTF_8);
- caption = g_strdup_printf(_("\"%s\" unknown in %s"),
+ utf8buf = g_strdup(l->data);
+ caption = g_strdup_printf(_("\"%s\" unknown in dictionary '%s'"),
utf8buf,
gtkaspell->gtkaspeller->dictionary->dictname);
item = gtk_menu_item_new_with_label(caption);
+ submenu = make_dictionary_list_submenu(gtkaspell);
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
g_free(utf8buf);
gtk_widget_show(item);
list = g_slist_append(list, item);
- gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
+ gtk_misc_set_alignment(GTK_MISC(gtk_bin_get_child(GTK_BIN((item)))), 0.5, 0.5);
g_free(caption);
item = gtk_menu_item_new();
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(add_word_to_session_cb),
gtkaspell);
- gtk_widget_add_accelerator(item, "activate", accel, GDK_space,
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_KEY_space,
GDK_CONTROL_MASK,
GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(add_word_to_personal_cb),
gtkaspell);
- gtk_widget_add_accelerator(item, "activate", accel, GDK_Return,
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_KEY_Return,
GDK_CONTROL_MASK,
GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(replace_with_create_dialog_cb),
gtkaspell);
- gtk_widget_add_accelerator(item, "activate", accel, GDK_R, 0,
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_KEY_R, 0,
GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
- gtk_widget_add_accelerator(item, "activate", accel, GDK_R,
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_KEY_R,
GDK_CONTROL_MASK,
GTK_ACCEL_LOCKED);
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(check_with_alternate_cb),
gtkaspell);
- gtk_widget_add_accelerator(item, "activate", accel, GDK_X, 0,
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_KEY_X, 0,
GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
- gtk_widget_add_accelerator(item, "activate", accel, GDK_X,
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_KEY_X,
GDK_CONTROL_MASK,
GTK_ACCEL_LOCKED);
}
item = gtk_menu_item_new_with_label(_("More..."));
gtk_widget_show(item);
if (curmenu)
- gtk_menu_append(GTK_MENU(curmenu), item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(curmenu), item);
else
list = g_slist_append(list, item);
curmenu);
}
- utf8buf = conv_codeset_strdup((char*)l->data,
- conv_get_locale_charset_str(),
- CS_UTF_8);
+ utf8buf = g_strdup(l->data);
+
item = gtk_menu_item_new_with_label(utf8buf);
g_free(utf8buf);
gtk_widget_show(item);
if (curmenu == NULL) {
list = g_slist_append(list, item);
} else {
- gtk_menu_append(GTK_MENU(curmenu), item);
+ gtk_menu_shell_append(GTK_MENU_SHELL(curmenu), item);
}
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(replace_word_cb),
if (curmenu == NULL && count < MENUCOUNT) {
gtk_widget_add_accelerator(item, "activate",
accel,
- GDK_A + count, 0,
+ GDK_KEY_A + count, 0,
GTK_ACCEL_LOCKED |
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(item, "activate",
accel,
- GDK_A + count,
+ GDK_KEY_A + count,
GDK_CONTROL_MASK,
GTK_ACCEL_LOCKED);
}
dictname = g_strdup_printf(_("Dictionary: %s"),
gtkaspeller->dictionary->dictname);
item = gtk_menu_item_new_with_label(dictname);
- gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
+ gtk_misc_set_alignment(GTK_MISC(gtk_bin_get_child(GTK_BIN((item)))), 0.5, 0.5);
g_free(dictname);
+ submenu = make_dictionary_list_submenu(gtkaspell);
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
gtk_widget_show(item);
list = g_slist_append(list, item);
gtk_widget_show(item);
list = g_slist_append(list, item);
- item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
- gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), TRUE);
- if (gtkaspell->gtkaspeller->sug_mode == ASPELL_FASTMODE) {
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
- gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
- } else
- g_signal_connect(G_OBJECT(item), "activate",
- G_CALLBACK(set_sug_mode_cb),
- gtkaspell);
- gtk_widget_show(item);
- list = g_slist_append(list, item);
-
- item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
- gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), TRUE);
- if (gtkaspell->gtkaspeller->sug_mode == ASPELL_NORMALMODE) {
- gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
- } else
- g_signal_connect(G_OBJECT(item), "activate",
- G_CALLBACK(set_sug_mode_cb),
- gtkaspell);
- gtk_widget_show(item);
- list = g_slist_append(list, item);
-
- item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
- gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), TRUE);
- if (gtkaspell->gtkaspeller->sug_mode == ASPELL_BADSPELLERMODE) {
- gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
- } else
- g_signal_connect(G_OBJECT(item), "activate",
- G_CALLBACK(set_sug_mode_cb),
- gtkaspell);
- gtk_widget_show(item);
- list = g_slist_append(list, item);
-
- item = gtk_menu_item_new();
- gtk_widget_show(item);
- list = g_slist_append(list, item);
-
item = gtk_check_menu_item_new_with_label(_("Check while typing"));
if (gtkaspell->check_while_typing)
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
gtk_widget_show(item);
list = g_slist_append(list, item);
- item = gtk_menu_item_new();
- gtk_widget_show(item);
- list = g_slist_append(list, 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);
- list = g_slist_append(list, item);
-
- /* Dict list */
- if (gtkaspellcheckers->dictionary_list == NULL)
- gtkaspell_get_dictionary_list(gtkaspell->dictionary_path, FALSE);
- {
- GtkWidget * curmenu = submenu;
- int count = 0;
- Dictionary *dict;
- GSList *tmp;
- tmp = gtkaspellcheckers->dictionary_list;
-
- for (tmp = gtkaspellcheckers->dictionary_list; tmp != NULL;
- tmp = g_slist_next(tmp)) {
- 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;
- }
- dict = (Dictionary *) tmp->data;
- item = gtk_check_menu_item_new_with_label(dict->dictname);
- g_object_set_data(G_OBJECT(item), "dict_name",
- dict->fullname);
- if (strcmp2(dict->fullname,
- gtkaspell->gtkaspeller->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);
- }
- g_signal_connect(G_OBJECT(item), "activate",
- G_CALLBACK(change_dict_cb),
- gtkaspell);
- gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(curmenu), item);
-
- count++;
- }
- }
return list;
}
wx = r.width;
wy = r.height;
- *x = rect.x + xx +
- gdk_char_width(gtk_style_get_font(GTK_WIDGET(text)->style), ' ');
+ *x = rect.x + xx + 8;
*y = rect.y + rect.height + yy;
if (*x + wx > sx)
*x = sx - wx;
if (*y + wy > sy)
- *y = *y - wy -
- gdk_string_height(gtk_style_get_font(
- GTK_WIDGET(text)->style),
- gtkaspell->theword);
+ *y = *y - wy - 10;
}
/* change the current dictionary of gtkaspell
{
Dictionary *dict;
GtkAspeller *gtkaspeller;
- gint sug_mode;
- g_return_val_if_fail(gtkaspell, FALSE);
- g_return_val_if_fail(dictionary, FALSE);
+ cm_return_val_if_fail(gtkaspell, FALSE);
+ cm_return_val_if_fail(dictionary, FALSE);
- sug_mode = gtkaspell->default_sug_mode;
-
dict = g_new0(Dictionary, 1);
- dict->fullname = g_strdup(dictionary);
- dict->encoding = g_strdup(gtkaspell->gtkaspeller->dictionary->encoding);
+
+ if (strrchr(dictionary, '/')) {
+ dict->fullname = g_strdup(strrchr(dictionary, '/')+1);
+ dict->dictname = g_strdup(strrchr(dictionary, '/')+1);
+ } else {
+ dict->fullname = g_strdup(dictionary);
+ dict->dictname = g_strdup(dictionary);
+ }
+
+ if (dict->fullname && strchr(dict->fullname, '-')) {
+ *(strchr(dict->fullname, '-')) = '\0';
+ *(strchr(dict->dictname, '-')) = '\0';
+ }
+ if (!dict->fullname || !(*dict->fullname)) {
+ dictionary_delete(dict);
+ return FALSE;
+ }
gtkaspeller = gtkaspeller_new(dict);
if (!gtkaspeller) {
- gchar *message;
- message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s"),
+ alertpanel_warning(_("The spell checker could not change dictionary.\n%s"),
gtkaspellcheckers->error_message);
-
- alertpanel_warning(message);
- g_free(message);
} else {
if (gtkaspell->use_alternate) {
if (gtkaspell->alternate_speller) {
gtkaspeller_delete(gtkaspell->gtkaspeller);
gtkaspell->gtkaspeller = gtkaspeller;
- gtkaspell_set_sug_mode(gtkaspell, sug_mode);
}
dictionary_delete(dict);
Dictionary *dict;
GtkAspeller *gtkaspeller;
- g_return_val_if_fail(gtkaspell, FALSE);
- g_return_val_if_fail(alt_dictionary, FALSE);
+ cm_return_val_if_fail(gtkaspell, FALSE);
+ cm_return_val_if_fail(alt_dictionary, FALSE);
dict = g_new0(Dictionary, 1);
- dict->fullname = g_strdup(alt_dictionary);
- dict->encoding = g_strdup(gtkaspell->gtkaspeller->dictionary->encoding);
+ if (strrchr(alt_dictionary, '/')) {
+ dict->fullname = g_strdup(strrchr(alt_dictionary, '/')+1);
+ dict->dictname = g_strdup(strrchr(alt_dictionary, '/')+1);
+ } else {
+ dict->fullname = g_strdup(alt_dictionary);
+ dict->dictname = g_strdup(alt_dictionary);
+ }
+
+ if (dict->fullname && strchr(dict->fullname, '-')) {
+ *(strchr(dict->fullname, '-')) = '\0';
+ *(strchr(dict->dictname, '-')) = '\0';
+ }
+
+ if (!dict->fullname || !(*dict->fullname)) {
+ dictionary_delete(dict);
+ return FALSE;
+ }
gtkaspeller = gtkaspeller_new(dict);
if (!gtkaspeller) {
- gchar *message;
- message = g_strdup_printf(_("The spell checker could not change the alternate dictionary.\n%s"),
+ alertpanel_warning(_("The spell checker could not change the alternate dictionary.\n%s"),
gtkaspellcheckers->error_message);
-
- alertpanel_warning(message);
- g_free(message);
} else {
if (gtkaspell->alternate_speller)
gtkaspeller_delete(gtkaspell->alternate_speller);
return;
gtkaspell_change_dict(gtkaspell, fullname, TRUE);
- if (gtkaspell->recheck_when_changing_dict) {
- gtkaspell_highlight_all(gtkaspell);
- }
+ gtkaspell_dict_changed(gtkaspell);
+
if (gtkaspell->menu_changed_cb)
gtkaspell->menu_changed_cb(gtkaspell->menu_changed_data);
}
gpointer data)
{
GtkAspell *gtkaspell = (GtkAspell *) data;
- use_alternate_dict(gtkaspell);
- if (gtkaspell->recheck_when_changing_dict) {
- gtkaspell_highlight_all(gtkaspell);
- }
+ gtkaspell_use_alternate_dict(gtkaspell);
+ gtkaspell_dict_changed(gtkaspell);
+
if (gtkaspell->menu_changed_cb)
gtkaspell->menu_changed_cb(gtkaspell->menu_changed_data);
}
static void set_point_continue(GtkAspell *gtkaspell)
{
- GtkTextView *gtktext;
-
- gtktext = gtkaspell->gtktext;
-
- set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
+ gtkaspell->ctx.set_position(gtkaspell->ctx.data, gtkaspell->orig_pos);
if (gtkaspell->continue_check)
- gtkaspell->continue_check((gpointer *) gtkaspell);
+ gtkaspell->continue_check((gpointer *) gtkaspell->ctx.data);
}
static void allocate_color(GtkAspell *gtkaspell, gint rgbvalue)
}
}
-/* convert_to_aspell_encoding () - converts ISO-8859-* strings to iso8859-*
- * as needed by aspell. Returns an allocated string.
- */
-
-static gchar *convert_to_aspell_encoding (const gchar *encoding)
-{
- gchar * aspell_encoding;
-
- if (strstr2(encoding, "ISO-8859-")) {
- aspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
- }
- else {
- if (!strcmp2(encoding, "US-ASCII"))
- aspell_encoding = g_strdup("iso8859-1");
- else
- aspell_encoding = g_strdup(encoding);
- }
-
- return aspell_encoding;
-}
-
/* compare_dict () - compare 2 dict names */
static gint compare_dict(Dictionary *a, Dictionary *b)
{
static void dictionary_delete(Dictionary *dict)
{
g_free(dict->fullname);
- g_free(dict->encoding);
+ g_free(dict->dictname);
g_free(dict);
}
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);
+ dict2->dictname = g_strdup(dict->dictname);
return dict2;
}
-static void free_suggestions_list(GtkAspell *gtkaspell)
+void gtkaspell_free_suggestions_list(GtkAspell *gtkaspell)
{
GList *list;
gtkaspell->theword[0] = 0;
gtkaspell->max_sug = -1;
- free_suggestions_list(gtkaspell);
+ gtkaspell_free_suggestions_list(gtkaspell);
}
static void free_checkers(gpointer elt, gpointer data)
{
GtkAspeller *gtkaspeller = elt;
- g_return_if_fail(gtkaspeller);
+ cm_return_if_fail(gtkaspeller);
gtkaspeller_real_delete(gtkaspeller);
}
-static gint find_gtkaspeller(gconstpointer aa, gconstpointer bb)
-{
- Dictionary *a = ((GtkAspeller *) aa)->dictionary;
- Dictionary *b = ((GtkAspeller *) 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;
-}
-
gchar *gtkaspell_get_default_dictionary(GtkAspell *gtkaspell)
{
if (gtkaspell && gtkaspell->gtkaspeller &&
projects / claws.git / blobdiff