* 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.
+ * version 3 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
* 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
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
* Adapted for Sylpheed (Claws) (c) 2001-2002 by Hiroyuki Yamamoto &
- * The Sylpheed Claws Team.
+ * The Claws Mail Team.
* Adapted for pspell (c) 2001-2002 Melvin Hadasht
* Adapted for GNU/aspell (c) 2002 Melvin Hadasht
*/
#include <aspell.h>
-#include "gtk/gtktext.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
RETURN_FALSE_IF_CONFIG_ERROR(); \
}
+enum {
+ SET_GTKASPELL_NAME = 0,
+ SET_GTKASPELL_FULLNAME = 1,
+ SET_GTKASPELL_SIZE
+};
+
typedef struct _GtkAspellCheckers {
GSList *checkers;
GSList *dictionary_list;
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 *config_menu;
- GtkWidget *popup_config_menu;
- GtkWidget *sug_menu;
GtkWidget *replace_entry;
GtkWidget *parent_window;
GtkTextView *gtktext;
GdkColor highlight;
GtkAccelGroup *accel_group;
+ void (*menu_changed_cb)(void *data);
+ void *menu_changed_data;
};
typedef AspellConfig GtkAspellConfig;
GtkTextIter *startiter,
GtkTextIter *enditer,
GtkAspell *gtkaspell);
-static gint button_press_intercept_cb (GtkTextView *gtktext,
+/*static gint button_press_intercept_cb (GtkTextView *gtktext,
GdkEvent *e,
GtkAspell *gtkaspell);
-
+*/
+static void button_press_intercept_cb(GtkTextView *gtktext,
+ GtkMenu *menu, GtkAspell *gtkaspell);
+
/* Checker creation */
static GtkAspeller* gtkaspeller_new (Dictionary *dict);
static GtkAspeller* gtkaspeller_real_new (Dictionary *dict);
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);
static gboolean check_next_prev (GtkAspell *gtkaspell,
gboolean forward);
static GList* misspelled_suggest (GtkAspell *gtkaspell,
- guchar *word);
+ gchar *word);
static void add_word_to_session_cb (GtkWidget *w,
gpointer data);
static void add_word_to_personal_cb (GtkWidget *w,
gpointer data);
/* Menu creation */
-static void popup_menu (GtkAspell *gtkaspell,
- GdkEventButton *eb);
-static GtkMenu* make_sug_menu (GtkAspell *gtkaspell);
-static void populate_submenu (GtkAspell *gtkaspell,
- GtkWidget *menu);
-static GtkMenu* make_config_menu (GtkAspell *gtkaspell);
+static GSList* make_sug_menu (GtkAspell *gtkaspell);
+static GSList * populate_submenu (GtkAspell *gtkaspell);
+GSList* gtkaspell_make_config_menu (GtkAspell *gtkaspell);
static void set_menu_pos (GtkMenu *menu,
gint *x,
gint *y,
gboolean *push_in,
gpointer data);
/* Other menu callbacks */
-static gboolean cancel_menu_cb (GtkMenuShell *w,
- gpointer data);
+static gboolean aspell_key_pressed (GtkWidget *widget,
+ GdkEventKey *event,
+ GtkAspell *gtkaspell);
static void change_dict_cb (GtkWidget *w,
GtkAspell *gtkaspell);
static void switch_to_alternate_cb (GtkWidget *w,
/* Misc. helper functions */
static void set_point_continue (GtkAspell *gtkaspell);
static void continue_check (gpointer *gtkaspell);
-static gboolean iswordsep (unsigned char c);
-static guchar get_text_index_whar (GtkAspell *gtkaspell,
+static gboolean iswordsep (gunichar c);
+static gunichar get_text_index_whar (GtkAspell *gtkaspell,
int pos);
static gboolean get_word_from_pos (GtkAspell *gtkaspell,
gint pos,
gint end,
gchar *newtext,
GdkColor *color);
-static guchar* convert_to_aspell_encoding (const guchar *encoding);
+static gchar* convert_to_aspell_encoding (const gchar *encoding);
static gint compare_dict (Dictionary *a,
Dictionary *b);
static void dictionary_delete (Dictionary *dict);
gpointer data);
static gint find_gtkaspeller (gconstpointer aa,
gconstpointer bb);
-static void gtkaspell_alert_dialog (gchar *message);
/* 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 gint get_textview_buffer_position(GtkTextView *view);
+
+static void gtkaspell_free_dictionary_list (GSList *list);
+static GSList* gtkaspell_get_dictionary_list (const char *aspell_path,
+ gint refresh);
+
+static void gtkaspell_uncheck_all (GtkAspell *gtkaspell);
static gint get_textview_buffer_charcount(GtkTextView *view)
{
g_slist_foreach(checkers, free_checkers, NULL);
g_slist_free(checkers);
+ gtkaspellcheckers->checkers = NULL;
}
if ((dict_list = gtkaspellcheckers->dictionary_list)) {
}
g_free(gtkaspellcheckers->error_message);
-
+ gtkaspellcheckers->error_message = NULL;
return;
}
GtkAspell *gtkaspell_new(const gchar *dictionary_path,
const gchar *dictionary,
+ const gchar *alt_dictionary,
const gchar *encoding,
gint misspelled_color,
gboolean check_while_typing,
+ gboolean recheck_when_changing_dict,
gboolean use_alternate,
+ gboolean use_both_dicts,
GtkTextView *gtktext,
- GtkWindow *parent_win)
+ GtkWindow *parent_win,
+ void (*spell_menu_cb)(void *data),
+ void *data)
{
Dictionary *dict;
GtkAspell *gtkaspell;
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);
+
buffer = gtk_text_view_get_buffer(gtktext);
dict = g_new0(Dictionary, 1);
gtkaspell->dictionary_path = g_strdup(dictionary_path);
gtkaspell->gtkaspeller = gtkaspeller;
- gtkaspell->alternate_speller = NULL;
+
+ if (use_alternate && alt_dictionary && *alt_dictionary) {
+ Dictionary *alt_dict;
+ GtkAspeller *alt_gtkaspeller;
+
+ alt_dict = g_new0(Dictionary, 1);
+ alt_dict->fullname = g_strdup(alt_dictionary);
+ alt_dict->encoding = g_strdup(encoding);
+
+ alt_gtkaspeller = gtkaspeller_new(alt_dict);
+ dictionary_delete(alt_dict);
+
+ if (!alt_gtkaspeller)
+ return NULL;
+
+ gtkaspell->alternate_speller = alt_gtkaspeller;
+ } else {
+ gtkaspell->alternate_speller = NULL;
+ }
+
gtkaspell->theword[0] = 0x00;
gtkaspell->start_pos = 0;
gtkaspell->end_pos = 0;
gtkaspell->end_check_pos = -1;
gtkaspell->misspelled = -1;
gtkaspell->check_while_typing = check_while_typing;
+ gtkaspell->recheck_when_changing_dict = recheck_when_changing_dict;
gtkaspell->continue_check = NULL;
- gtkaspell->config_menu = NULL;
- gtkaspell->popup_config_menu = NULL;
- gtkaspell->sug_menu = 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->menu_changed_cb = spell_menu_cb;
+ gtkaspell->menu_changed_data = data;
+
allocate_color(gtkaspell, misspelled_color);
g_signal_connect_after(G_OBJECT(buffer), "insert-text",
G_CALLBACK(entry_insert_cb), gtkaspell);
g_signal_connect_after(G_OBJECT(buffer), "delete-range",
G_CALLBACK(entry_delete_cb), gtkaspell);
- g_signal_connect(G_OBJECT(gtktext), "button-press-event",
+ /*g_signal_connect(G_OBJECT(gtktext), "button-press-event",
G_CALLBACK(button_press_intercept_cb),
- gtkaspell);
+ gtkaspell);*/
+ g_signal_connect(G_OBJECT(gtktext), "populate-popup",
+ G_CALLBACK(button_press_intercept_cb), gtkaspell);
- debug_print("Aspell: created gtkaspell %0x\n", (guint) gtkaspell);
+ debug_print("Aspell: created gtkaspell %p\n", gtkaspell);
return gtkaspell;
}
-void gtkaspell_delete(GtkAspell * gtkaspell)
+void gtkaspell_delete(GtkAspell *gtkaspell)
{
GtkTextView *gtktext = gtkaspell->gtktext;
g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
G_CALLBACK(entry_insert_cb),
- gtkaspell);
+ gtkaspell);
g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
G_CALLBACK(entry_delete_cb),
- gtkaspell);
+ gtkaspell);
g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
- G_CALLBACK(button_press_intercept_cb),
- gtkaspell);
+ G_CALLBACK(button_press_intercept_cb),
+ gtkaspell);
gtkaspell_uncheck_all(gtkaspell);
gtkaspeller_delete(gtkaspell->gtkaspeller);
- if (gtkaspell->use_alternate && gtkaspell->alternate_speller)
+ if (gtkaspell->alternate_speller)
gtkaspeller_delete(gtkaspell->alternate_speller);
- if (gtkaspell->sug_menu)
- gtk_widget_destroy(gtkaspell->sug_menu);
-
- if (gtkaspell->popup_config_menu)
- gtk_widget_destroy(gtkaspell->popup_config_menu);
-
- if (gtkaspell->config_menu)
- gtk_widget_destroy(gtkaspell->config_menu);
-
if (gtkaspell->suggestions_list)
free_suggestions_list(gtkaspell);
g_free((gchar *)gtkaspell->dictionary_path);
+ gtkaspell->dictionary_path = NULL;
- debug_print("Aspell: deleting gtkaspell %0x\n", (guint) gtkaspell);
+ debug_print("Aspell: deleting gtkaspell %p\n", gtkaspell);
g_free(gtkaspell);
gint len,
GtkAspell *gtkaspell)
{
- size_t wlen;
guint pos;
g_return_if_fail(gtkaspell->gtkaspeller->checker);
pos = gtk_text_iter_get_offset(iter);
- if (iswordsep(newtext[0])) {
+ if (iswordsep(g_utf8_get_char(newtext))) {
/* did we just end a word? */
if (pos >= 2)
check_at(gtkaspell, pos - 2);
/* gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); */
}
-/* 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(GtkTextView *gtktext,
- GdkEvent *e,
- GtkAspell *gtkaspell)
+static void button_press_intercept_cb(GtkTextView *gtktext,
+ GtkMenu *menu, GtkAspell *gtkaspell)
{
- GdkEventButton *eb;
- gboolean retval;
+ GtkMenuItem *menuitem;
+ GSList *spell_menu = NULL;
+ GSList *items;
+ gboolean suggest = FALSE;
- g_return_val_if_fail(gtkaspell->gtkaspeller->checker, 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));
- if (e->type != GDK_BUTTON_PRESS)
- return FALSE;
- eb = (GdkEventButton*) e;
+ gtktext = gtkaspell->gtktext;
- if (eb->button != 3)
- return FALSE;
+ gtkaspell->orig_pos = get_textview_buffer_offset(gtktext);
- g_signal_handlers_block_by_func(G_OBJECT(gtktext),
- G_CALLBACK(button_press_intercept_cb),
- gtkaspell);
- g_signal_emit_by_name(G_OBJECT(gtktext), "button-release-event",
- e, &retval);
+ if (check_at(gtkaspell, gtkaspell->orig_pos)) {
- /* forge the leftclick */
- eb->button = 1;
+ if (misspelled_suggest(gtkaspell, gtkaspell->theword)) {
+ spell_menu = make_sug_menu(gtkaspell);
+ suggest = TRUE;
+ }
+ }
+ if (!spell_menu)
+ spell_menu = gtkaspell_make_config_menu(gtkaspell);
- g_signal_emit_by_name(G_OBJECT(gtktext), "button-press-event",
- e, &retval);
- g_signal_emit_by_name(G_OBJECT(gtktext), "button-release-event",
- e, &retval);
- g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
- G_CALLBACK(button_press_intercept_cb),
- gtkaspell);
- g_signal_stop_emission_by_name(G_OBJECT(gtktext), "button-press-event");
-
- /* now do the menu wackiness */
- popup_menu(gtkaspell, eb);
- gtk_grab_remove(GTK_WIDGET(gtktext));
- return FALSE;
-}
+ spell_menu = g_slist_reverse(spell_menu);
+ for (items = spell_menu;
+ items; items = items->next) {
+ menuitem = GTK_MENU_ITEM(items->data);
+ gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), GTK_WIDGET(menuitem));
+ gtk_widget_show(GTK_WIDGET(menuitem));
+ }
+ g_slist_free(spell_menu);
+
+ g_signal_connect(G_OBJECT(menu), "deactivate",
+ G_CALLBACK(destroy_menu),
+ gtkaspell);
+ if (suggest)
+ g_signal_connect(G_OBJECT(menu),
+ "key_press_event",
+ G_CALLBACK(aspell_key_pressed), gtkaspell);
+
+}
/* Checker creation */
static GtkAspeller *gtkaspeller_new(Dictionary *dictionary)
{
gtkaspellcheckers->checkers,
gtkaspeller);
- debug_print("Aspell: Created a new gtkaspeller %0x\n",
- (gint) gtkaspeller);
+ debug_print("Aspell: Created a new gtkaspeller %p\n",
+ gtkaspeller);
} else {
dictionary_delete(dict);
g_slist_remove(gtkaspellcheckers->checkers,
gtkaspeller);
- debug_print("Aspell: Deleting gtkaspeller %0x.\n",
- (gint) gtkaspeller);
+ debug_print("Aspell: Deleting gtkaspeller %p.\n",
+ gtkaspeller);
gtkaspeller_real_delete(gtkaspeller);
dictionary_delete(gtkaspeller->dictionary);
- debug_print("Aspell: gtkaspeller %0x deleted.\n",
- (gint) gtkaspeller);
+ debug_print("Aspell: gtkaspeller %p deleted.\n",
+ gtkaspeller);
g_free(gtkaspeller);
return TRUE;
}
-guchar *gtkaspell_get_dict(GtkAspell *gtkaspell)
-{
-
- g_return_val_if_fail(gtkaspell->gtkaspeller->config, NULL);
- g_return_val_if_fail(gtkaspell->gtkaspeller->dictionary, NULL);
-
- return g_strdup(gtkaspell->gtkaspeller->dictionary->dictname);
-}
-
-guchar *gtkaspell_get_path(GtkAspell *gtkaspell)
-{
- guchar *path;
- Dictionary *dict;
-
- g_return_val_if_fail(gtkaspell->gtkaspeller->config, NULL);
- g_return_val_if_fail(gtkaspell->gtkaspeller->dictionary, NULL);
-
- dict = gtkaspell->gtkaspeller->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, GtkAspell *gtkaspell)
{
char *themode;
- gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &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);
+}
- if (gtkaspell->config_menu)
- populate_submenu(gtkaspell, gtkaspell->config_menu);
+/* 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);
+ }
+
+ if (gtkaspell->menu_changed_cb)
+ gtkaspell->menu_changed_cb(gtkaspell->menu_changed_data);
}
static void set_real_sug_mode(GtkAspell *gtkaspell, const char *themode)
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 %0x to %d\n",
- (guint) gtkaspell->gtkaspeller, themode);
+ debug_print("Aspell: setting sug mode of gtkaspeller %p to %d\n",
+ gtkaspell->gtkaspeller, themode);
config = gtkaspell->gtkaspeller->config;
}
/* misspelled_suggest() - Create a suggestion list for word */
-static GList *misspelled_suggest(GtkAspell *gtkaspell, guchar *word)
+static GList *misspelled_suggest(GtkAspell *gtkaspell, gchar *word)
{
const guchar *newword;
GList *list = NULL;
elements = aspell_word_list_elements(suggestions);
list = g_list_append(list, g_strdup(word));
- while (newword = aspell_string_enumeration_next(elements))
- list = g_list_append(list, g_strdup(newword));
+ 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;
gtkaspell->suggestions_list = list;
/* misspelled_test() - Just test if word is correctly spelled */
static int misspelled_test(GtkAspell *gtkaspell, unsigned char *word)
{
- return aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1)
+ gint result = aspell_speller_check(gtkaspell->gtkaspeller->checker, (char *)word, -1)
? 0 : 1;
+ 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);
+ }
+ return result;
}
-static gboolean iswordsep(unsigned char c)
+static gboolean iswordsep(gunichar c)
{
- return !isalpha(c) && c != '\'';
+ return (g_unichar_isspace(c) || g_unichar_ispunct(c)) && c != (gunichar)'\'';
}
-static guchar get_text_index_whar(GtkAspell *gtkaspell, int pos)
+static gunichar get_text_index_whar(GtkAspell *gtkaspell, int pos)
{
GtkTextView *view = gtkaspell->gtktext;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(view);
GtkTextIter start, end;
- const gchar *utf8chars;
- guchar a = '\0';
+ gchar *utf8chars;
+ gunichar a = '\0';
gtk_text_buffer_get_iter_at_offset(buffer, &start, pos);
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 ? utf8chars[0] : '\0' ;
+ a = utf8chars ? (gunichar)utf8chars[0] : '\0' ;
} else {
gchar *tr = conv_iconv_strdup(utf8chars, CS_UTF_8,
gtkaspell->gtkaspeller->dictionary->encoding);
if (tr) {
- a = tr[0];
+ a = g_utf8_get_char(tr);
g_free(tr);
}
}
+ g_free(utf8chars);
return a;
}
gint start;
gint end;
- guchar c;
+ gunichar c;
GtkTextView *gtktext;
gtktext = gtkaspell->gtktext;
for (start = pos; start >= 0; --start) {
c = get_text_index_whar(gtkaspell, start);
- if (c == '\'') {
+ if (c == (gunichar)'\'') {
if (start > 0) {
- if (!isalpha(get_text_index_whar(gtkaspell,
+ if (g_unichar_isspace(get_text_index_whar(gtkaspell,
+ start - 1))
+ || g_unichar_ispunct(get_text_index_whar(gtkaspell,
+ start - 1))
+ || g_unichar_isdigit(get_text_index_whar(gtkaspell,
start - 1))) {
/* start_quote = TRUE; */
break;
break;
}
}
- else if (!isalpha(c))
+ else if (g_unichar_isspace(c) || g_unichar_ispunct(c) || g_unichar_isdigit(c))
break;
}
for (end = pos; end < get_textview_buffer_charcount(gtktext); end++) {
c = get_text_index_whar(gtkaspell, end);
- if (c == '\'') {
+ if (c == (gunichar)'\'') {
if (end < get_textview_buffer_charcount(gtktext)) {
- if (!isalpha(get_text_index_whar(gtkaspell,
+ if (g_unichar_isspace(get_text_index_whar(gtkaspell,
+ end + 1))
+ || g_unichar_ispunct(get_text_index_whar(gtkaspell,
+ end + 1))
+ || g_unichar_isdigit(get_text_index_whar(gtkaspell,
end + 1))) {
/* end_quote = TRUE; */
break;
break;
}
}
- else if(!isalpha(c))
+ else if (g_unichar_isspace(c) || g_unichar_ispunct(c) || g_unichar_isdigit(c))
break;
}
if (buf) {
if (end - start < buflen) {
- for (pos = start; pos < end; pos++) {
- buf[pos - start] =
- get_text_index_whar(gtkaspell, pos);
- }
- buf[pos - start] = 0;
+ GtkTextIter iterstart, iterend;
+ gchar *tmp, *conv;
+ 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);
+ buf[buflen-1]='\0';
+ g_free(conv);
} else
return FALSE;
}
&start, &end))
return FALSE;
- if (misspelled_test(gtkaspell, buf)) {
- strncpy(gtkaspell->theword, buf, GTKASPELLWORDSIZE - 1);
+ if (misspelled_test(gtkaspell, buf)
+ && strcasecmp((char *)buf, "sylpheed") && strcasecmp((char *)buf, "claws-mail")) {
+ strncpy(gtkaspell->theword, (gchar *)buf, GTKASPELLWORDSIZE - 1);
gtkaspell->theword[GTKASPELLWORDSIZE - 1] = 0;
gtkaspell->start_pos = start;
gtkaspell->end_pos = end;
free_suggestions_list(gtkaspell);
- change_color(gtkaspell, start, end, buf, &(gtkaspell->highlight));
+ change_color(gtkaspell, start, end, (gchar *)buf, &(gtkaspell->highlight));
return TRUE;
} else {
- change_color(gtkaspell, start, end, buf, NULL);
+ change_color(gtkaspell, start, end, (gchar *)buf, NULL);
return FALSE;
}
}
pos += direc;
}
if (misspelled) {
- GtkMenu *menu = NULL;
+ GSList *list, *cur;
+ GtkWidget *menu;
misspelled_suggest(gtkaspell, gtkaspell->theword);
if (forward)
while (gtk_events_pending ())
gtk_main_iteration ();
- menu = make_sug_menu(gtkaspell);
- gtk_menu_popup(menu, NULL, NULL,
+ list = make_sug_menu(gtkaspell);
+ menu = gtk_menu_new();
+ for (cur = list; cur; cur = cur->next)
+ gtk_menu_append(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);
g_signal_connect(G_OBJECT(menu), "deactivate",
G_CALLBACK(destroy_menu),
gtkaspell);
+ g_signal_connect(G_OBJECT(menu),
+ "key_press_event",
+ G_CALLBACK(aspell_key_pressed), gtkaspell);
+
} else {
reset_theword_data(gtkaspell);
- gtkaspell_alert_dialog(_("No misspelled word found."));
+ alertpanel_notice(_("No misspelled word found."));
set_textview_buffer_offset(gtkaspell->gtktext,
gtkaspell->orig_pos);
}
{
unsigned char *newword;
GdkEvent *e= (GdkEvent *) gtk_get_current_event();
-
- newword = gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->replace_entry),
+
+ newword = (unsigned char *)gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->replace_entry),
0, -1);
- if (strcmp(newword, gtkaspell->theword)) {
- replace_real_word(gtkaspell, newword);
+ if (strcmp((char *)newword, gtkaspell->theword)) {
+ replace_real_word(gtkaspell, (char *)newword);
if ((e->type == GDK_KEY_PRESS &&
((GdkEventKey *) e)->state & GDK_CONTROL_MASK)) {
aspell_speller_store_replacement(
gtkaspell->gtkaspeller->checker,
gtkaspell->theword, -1,
- newword, -1);
+ (char *)newword, -1);
}
gtkaspell->replace_entry = NULL;
}
g_free(newword);
+ if (w && GTK_IS_DIALOG(w)) {
+ gtk_widget_destroy(w);
+ }
+
set_point_continue(gtkaspell);
}
GtkAspell *gtkaspell = (GtkAspell *) data;
GdkEvent *e= (GdkEvent *) gtk_get_current_event();
- gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
+ newword = (unsigned char *) gtk_label_get_text(GTK_LABEL(GTK_BIN(w)->child));
+ newword = (unsigned char *)g_strdup((char *)newword);
- replace_real_word(gtkaspell, newword);
+ replace_real_word(gtkaspell, (char *)newword);
if ((e->type == GDK_KEY_PRESS &&
((GdkEventKey *) e)->state & GDK_CONTROL_MASK) ||
aspell_speller_store_replacement(
gtkaspell->gtkaspeller->checker,
gtkaspell->theword, -1,
- newword, -1);
+ (char *)newword, -1);
}
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)
int oldlen, newlen, wordlen;
gint origpos;
gint pos;
- gint start = gtkaspell->start_pos;
GtkTextView *gtktext;
GtkTextBuffer *textbuf;
GtkTextIter startiter, enditer;
static void add_word_to_personal_cb(GtkWidget *w, gpointer data)
{
GtkAspell *gtkaspell = (GtkAspell *) data;
- GtkTextView *gtktext = gtkaspell->gtktext;
aspell_speller_add_to_personal(gtkaspell->gtkaspeller->checker,
gtkaspell->theword,
gtkaspell->misspelled = misspelled;
if (gtkaspell->misspelled) {
- GtkMenu *menu;
+ GtkWidget *menu;
+ GSList *list, *cur;
misspelled_suggest(gtkaspell, gtkaspell->theword);
set_textview_buffer_offset(gtkaspell->gtktext,
gtkaspell->end_pos);
- menu = make_sug_menu(gtkaspell);
- gtk_menu_popup(menu, NULL, NULL,
+ list = make_sug_menu(gtkaspell);
+ menu = gtk_menu_new();
+ for (cur = list; cur; cur = cur->next)
+ gtk_menu_append(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);
g_signal_connect(G_OBJECT(menu), "deactivate",
G_CALLBACK(destroy_menu),
gtkaspell);
+ g_signal_connect(G_OBJECT(menu),
+ "key_press_event",
+ G_CALLBACK(aspell_key_pressed), gtkaspell);
return;
}
} else
set_point_continue(gtkaspell);
}
+static gboolean replace_key_pressed(GtkWidget *widget,
+ GdkEventKey *event,
+ GtkAspell *gtkaspell)
+{
+ if (event && event->keyval == GDK_Escape) {
+ gtk_widget_destroy(widget);
+ return TRUE;
+ } else if (event && event->keyval == GDK_Return) {
+ replace_with_supplied_word_cb(widget, gtkaspell);
+ return TRUE;
+ }
+ return FALSE;
+}
+
static void replace_with_create_dialog_cb(GtkWidget *w, gpointer data)
{
+ static PangoFontDescription *font_desc;
GtkWidget *dialog;
GtkWidget *label;
+ GtkWidget *w_hbox;
GtkWidget *hbox;
+ GtkWidget *vbox;
GtkWidget *entry;
GtkWidget *ok_button;
GtkWidget *cancel_button;
+ GtkWidget *confirm_area;
+ GtkWidget *icon;
gchar *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);
g_signal_connect_swapped(G_OBJECT(dialog), "destroy",
G_CALLBACK(gtk_widget_destroy),
G_OBJECT(dialog));
- hbox = gtk_hbox_new(FALSE, 0);
- gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
+ gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 14);
+ hbox = gtk_hbox_new (FALSE, 12);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_widget_show (hbox);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
+ FALSE, FALSE, 0);
- thelabel = g_strdup_printf(_("Replace \"%s\" with: "),
+ 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);
+
+ icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION,
+ GTK_ICON_SIZE_DIALOG);
+ gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0.0);
+ gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
+
+ vbox = gtk_vbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
+ gtk_widget_show (vbox);
+
label = gtk_label_new(thelabel);
+ gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
+ gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
+ gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
+ gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
+ gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
+ if (!font_desc) {
+ gint size;
+
+ size = pango_font_description_get_size
+ (label->style->font_desc);
+ font_desc = pango_font_description_new();
+ pango_font_description_set_weight
+ (font_desc, PANGO_WEIGHT_BOLD);
+ pango_font_description_set_size
+ (font_desc, size * PANGO_SCALE_LARGE);
+ }
+ if (font_desc)
+ gtk_widget_modify_font(label, font_desc);
g_free(thelabel);
- gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
-
+
entry = gtk_entry_new();
gtkaspell->replace_entry = entry;
gtk_entry_set_text(GTK_ENTRY(entry), gtkaspell->theword);
gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
- g_signal_connect(G_OBJECT(entry), "activate",
- G_CALLBACK(replace_with_supplied_word_cb),
- gtkaspell);
- g_signal_connect_swapped(G_OBJECT(entry), "activate",
- G_CALLBACK(gtk_widget_destroy),
- G_OBJECT(dialog));
- gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
+ 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);
- gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE,
- TRUE, 0);
label = gtk_label_new(_("Holding down Control key while pressing "
"Enter\nwill learn from mistake.\n"));
+ gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
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);
+ gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
+ gtk_widget_show(label);
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);
+ gtkut_stock_button_set_create(&confirm_area,
+ &cancel_button, GTK_STOCK_CANCEL,
+ &ok_button, GTK_STOCK_OK,
+ NULL, NULL);
+
+ gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area),
+ confirm_area, FALSE, FALSE, 0);
+ gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5);
+
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(replace_with_supplied_word_cb),
gtkaspell);
G_CALLBACK(gtk_widget_destroy),
G_OBJECT(dialog));
- cancel_button = gtk_button_new_with_label(_("Cancel"));
- gtk_box_pack_start(GTK_BOX(hbox), cancel_button, TRUE, TRUE, 8);
g_signal_connect_swapped(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(gtk_widget_destroy),
G_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 gtkaspell_uncheck_all(GtkAspell * gtkaspell)
+static void gtkaspell_uncheck_all(GtkAspell * gtkaspell)
{
- gint origpos;
- gchar *text;
- gfloat adj_value;
GtkTextView *gtktext;
GtkTextBuffer *buffer;
GtkTextIter startiter, enditer;
if (!gtkaspell->check_while_typing)
gtkaspell_uncheck_all(gtkaspell);
-
- if (gtkaspell->config_menu)
- populate_submenu(gtkaspell, gtkaspell->config_menu);
+ if (gtkaspell->menu_changed_cb)
+ gtkaspell->menu_changed_cb(gtkaspell->menu_changed_data);
}
static GSList *create_empty_dictionary_list(void)
}
/* gtkaspell_get_dictionary_list() - returns list of dictionary names */
-GSList *gtkaspell_get_dictionary_list(const gchar *aspell_path, gint refresh)
+static GSList *gtkaspell_get_dictionary_list(const gchar *aspell_path, gint refresh)
{
GSList *list;
Dictionary *dict;
list = NULL;
config = new_aspell_config();
-#if 0
- aspell_config_replace(config, "rem-all-word-list-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();
- return gtkaspellcheckers->dictionary_list;
- }
-#endif
aspell_config_replace(config, "dict-dir", aspell_path);
if (aspell_config_error_number(config) != 0) {
gtkaspellcheckers->error_message = g_strdup(
dlist = get_aspell_dict_info_list(config);
delete_aspell_config(config);
- debug_print("Aspell: checking for dictionaries in %s\n", aspell_path);
+ debug_print("Aspell: checking for dictionaries in %s\n", aspell_path?aspell_path:"(null)");
dels = aspell_dict_info_list_elements(dlist);
while ( (entry = aspell_dict_info_enumeration_next(dels)) != 0)
{
entry->name);
dict->dictname = dict->fullname + strlen(aspell_path);
dict->encoding = g_strdup(entry->code);
- debug_print("Aspell: found dictionary %s %s\n", dict->fullname,
- dict->dictname);
+
+ 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);
}
return list;
}
-void gtkaspell_free_dictionary_list(GSList *list)
+static void gtkaspell_free_dictionary_list(GSList *list)
{
Dictionary *dict;
GSList *walk;
g_slist_free(list);
}
-GtkWidget *gtkaspell_dictionary_option_menu_new(const gchar *aspell_path)
+GtkTreeModel *gtkaspell_dictionary_store_new_with_refresh(const gchar *aspell_path,
+ gboolean refresh)
{
GSList *dict_list, *tmp;
- GtkWidget *item;
- GtkWidget *menu;
+ GtkListStore *store;
+ GtkTreeIter iter;
Dictionary *dict;
- dict_list = gtkaspell_get_dictionary_list(aspell_path, TRUE);
+ dict_list = gtkaspell_get_dictionary_list(aspell_path, refresh);
g_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);
}
-gchar *gtkaspell_get_dictionary_menu_active_item(GtkWidget *menu)
+GtkTreeModel *gtkaspell_dictionary_store_new(const gchar *aspell_path)
{
- GtkWidget *menuitem;
- gchar *dict_fullname;
- gchar *label;
+ return gtkaspell_dictionary_store_new_with_refresh
+ (aspell_path, TRUE);
+}
- g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
+GtkWidget *gtkaspell_dictionary_combo_new(const gchar *aspell_path,
+ const gboolean refresh)
+{
+ GtkWidget *combo;
+ GtkCellRenderer *renderer;
- 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);
+ combo = gtk_combo_box_new_with_model(
+ gtkaspell_dictionary_store_new_with_refresh(aspell_path, 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;
+}
- label = g_strdup(dict_fullname);
+gchar *gtkaspell_get_dictionary_menu_active_item(GtkComboBox *combo)
+{
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ gchar *dict_fullname = NULL;
+
+ g_return_val_if_fail(GTK_IS_COMBO_BOX(combo), NULL);
+ g_return_val_if_fail(gtk_combo_box_get_active_iter(combo, &iter), NULL);
+
+ model = gtk_combo_box_get_model(combo);
+ if(model == NULL)
+ return NULL;
+
+ gtk_tree_model_get(model, &iter,
+ SET_GTKASPELL_FULLNAME, &dict_fullname,
+ -1);
- return label;
-
+ return dict_fullname;
}
-gint gtkaspell_set_dictionary_menu_active_item(GtkWidget *menu,
+gint gtkaspell_set_dictionary_menu_active_item(GtkComboBox *combo,
const gchar *dictionary)
{
- GList *cur;
- gint n;
-
- g_return_val_if_fail(menu != NULL, 0);
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gchar *dict_name = NULL;
+
+ g_return_val_if_fail(combo != NULL, 0);
g_return_val_if_fail(dictionary != NULL, 0);
- g_return_val_if_fail(GTK_IS_OPTION_MENU(menu), 0);
-
- 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);
+ g_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;
+
+ 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;
}
- n++;
- }
-
+
+ g_free(dict_name);
+
+ } while ((gtk_tree_model_iter_next(model, &iter)) == TRUE);
+
return 0;
}
-GtkWidget *gtkaspell_sugmode_option_menu_new(gint sugmode)
+GtkWidget *gtkaspell_sugmode_combo_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);
- 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));
+ GtkWidget *combo = gtkut_sc_combobox_create(NULL, FALSE);
+ GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(
+ GTK_COMBO_BOX(combo)));
+ GtkTreeIter iter;
- 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;
-}
-
-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);
-
- gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
-}
-
-gint gtkaspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
-{
- gint sugmode;
- GtkWidget *item;
+ g_return_val_if_fail(store != NULL, NULL);
- g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
+ COMBOBOX_ADD(store, _("Fast Mode"), ASPELL_FASTMODE);
+ COMBOBOX_ADD(store, _("Normal Mode"), ASPELL_NORMALMODE);
+ COMBOBOX_ADD(store, _("Bad Spellers Mode"), ASPELL_BADSPELLERMODE);
- item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
+ gtk_combo_box_set_active(GTK_COMBO_BOX(combo), sugmode - 1);
+ gtk_widget_show(combo);
- sugmode = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item),
- "sugmode"));
-
- return sugmode;
+ return combo;
}
static void use_alternate_dict(GtkAspell *gtkaspell)
tmp = gtkaspell->gtkaspeller;
gtkaspell->gtkaspeller = gtkaspell->alternate_speller;
gtkaspell->alternate_speller = tmp;
-
- if (gtkaspell->config_menu)
- populate_submenu(gtkaspell, gtkaspell->config_menu);
}
static void destroy_menu(GtkWidget *widget,
}
}
-static void popup_menu(GtkAspell *gtkaspell, GdkEventButton *eb)
-{
- GtkTextView * gtktext;
- GtkMenu *menu = NULL;
-
- gtktext = gtkaspell->gtktext;
-
- gtkaspell->orig_pos = get_textview_buffer_offset(gtktext);
-
- if (!(eb->state & GDK_SHIFT_MASK)) {
- if (check_at(gtkaspell, gtkaspell->orig_pos)) {
-
- set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
-
- if (misspelled_suggest(gtkaspell, gtkaspell->theword)) {
- menu = make_sug_menu(gtkaspell);
- gtk_menu_popup(menu,
- NULL, NULL, NULL, NULL,
- eb->button, eb->time);
-
- g_signal_connect(G_OBJECT(menu), "deactivate",
- G_CALLBACK(destroy_menu),
- gtkaspell);
- return;
- }
- } else
- set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
- }
- menu = make_config_menu(gtkaspell);
- gtk_menu_popup(menu, NULL, NULL, NULL, NULL,
- eb->button, eb->time);
-
- g_signal_connect(G_OBJECT(menu), "deactivate",
- G_CALLBACK(destroy_menu),
- gtkaspell);
-}
-
static gboolean aspell_key_pressed(GtkWidget *widget,
GdkEventKey *event,
GtkAspell *gtkaspell)
{
- if (event && isascii(event->keyval)) {
+ if (event && (isascii(event->keyval) || event->keyval == GDK_Return)) {
gtk_accel_groups_activate(
G_OBJECT(gtkaspell->parent_window),
event->keyval, event->state);
/* make_sug_menu() - Add menus to accept this word for this session
* and to add it to personal dictionary
*/
-static GtkMenu *make_sug_menu(GtkAspell *gtkaspell)
+static GSList *make_sug_menu(GtkAspell *gtkaspell)
{
- GtkWidget *menu, *item;
- unsigned char *caption;
+ GtkWidget *item;
+ char *caption;
GtkTextView *gtktext;
GtkAccelGroup *accel;
GList *l = gtkaspell->suggestions_list;
gchar *utf8buf;
-
+ GSList *list = NULL;
gtktext = gtkaspell->gtktext;
accel = gtk_accel_group_new();
- menu = gtk_menu_new();
-
- if (gtkaspell->sug_menu)
- gtk_widget_destroy(gtkaspell->sug_menu);
if (gtkaspell->accel_group) {
gtk_window_remove_accel_group(GTK_WINDOW(gtkaspell->parent_window),
gtkaspell->accel_group = NULL;
}
- gtkaspell->sug_menu = menu;
-
- g_signal_connect(G_OBJECT(menu), "cancel",
- G_CALLBACK(cancel_menu_cb), gtkaspell);
-
+ utf8buf = conv_codeset_strdup((char*)l->data,
+ conv_get_locale_charset_str(),
+ CS_UTF_8);
caption = g_strdup_printf(_("\"%s\" unknown in %s"),
- (unsigned char*) l->data,
+ utf8buf,
gtkaspell->gtkaspeller->dictionary->dictname);
item = gtk_menu_item_new_with_label(caption);
+ g_free(utf8buf);
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, 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);
+ list = g_slist_append(list, item);
item = gtk_menu_item_new_with_label(_("Accept in this session"));
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(add_word_to_session_cb),
gtkaspell);
item = gtk_menu_item_new_with_label(_("Add to personal dictionary"));
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(add_word_to_personal_cb),
gtkaspell);
item = gtk_menu_item_new_with_label(_("Replace with..."));
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
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_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_R,
+ GDK_CONTROL_MASK,
+ GTK_ACCEL_LOCKED);
if (gtkaspell->use_alternate && gtkaspell->alternate_speller) {
caption = g_strdup_printf(_("Check with %s"),
item = gtk_menu_item_new_with_label(caption);
g_free(caption);
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
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_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
+ gtk_widget_add_accelerator(item, "activate", accel, GDK_X,
+ GDK_CONTROL_MASK,
+ GTK_ACCEL_LOCKED);
}
item = gtk_menu_item_new();
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, 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);
+ list = g_slist_append(list, item);
} else {
- GtkWidget *curmenu = menu;
+ GtkWidget *curmenu = NULL;
gint count = 0;
do {
item = gtk_menu_item_new_with_label(_("More..."));
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(curmenu), item);
+ if (curmenu)
+ gtk_menu_append(GTK_MENU(curmenu), item);
+ else
+ list = g_slist_append(list, item);
curmenu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
curmenu);
}
- utf8buf = conv_codeset_strdup((unsigned char*)l->data,
+ utf8buf = conv_codeset_strdup((char*)l->data,
conv_get_locale_charset_str(),
CS_UTF_8);
item = gtk_menu_item_new_with_label(utf8buf);
+ g_free(utf8buf);
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(curmenu), item);
+ if (curmenu == NULL) {
+ list = g_slist_append(list, item);
+ } else {
+ gtk_menu_append(GTK_MENU(curmenu), item);
+ }
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(replace_word_cb),
gtkaspell);
- if (curmenu == menu && count < MENUCOUNT) {
+ if (curmenu == NULL && count < MENUCOUNT) {
gtk_widget_add_accelerator(item, "activate",
accel,
GDK_A + count, 0,
accel);
gtkaspell->accel_group = accel;
- g_signal_connect(G_OBJECT(menu),
- "key_press_event",
- G_CALLBACK(aspell_key_pressed), gtkaspell);
-
- return GTK_MENU(menu);
+ return list;
}
-static void populate_submenu(GtkAspell *gtkaspell, GtkWidget *menu)
+static GSList *populate_submenu(GtkAspell *gtkaspell)
{
GtkWidget *item, *submenu;
gchar *dictname;
- GtkAspeller *gtkaspeller = gtkaspell->gtkaspeller;
-
- 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;
- }
- }
-
+ GtkAspeller *gtkaspeller = NULL;
+ GSList *list = NULL;
+
+ if (!gtkaspell)
+ return NULL;
+
+ gtkaspeller = gtkaspell->gtkaspeller;
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);
g_free(dictname);
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
item = gtk_menu_item_new();
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
if (gtkaspell->use_alternate && gtkaspell->alternate_speller) {
dictname = g_strdup_printf(_("Use alternate (%s)"),
G_CALLBACK(switch_to_alternate_cb),
gtkaspell);
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
}
+ item = gtk_check_menu_item_new_with_label(_("Use both dictionaries"));
+ if (gtkaspell->use_both_dicts) {
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+ }
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(set_use_both_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(_("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);
G_CALLBACK(set_sug_mode_cb),
gtkaspell);
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), 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);
G_CALLBACK(set_sug_mode_cb),
gtkaspell);
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu),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);
G_CALLBACK(set_sug_mode_cb),
gtkaspell);
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
item = gtk_menu_item_new();
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
item = gtk_check_menu_item_new_with_label(_("Check while typing"));
if (gtkaspell->check_while_typing)
G_CALLBACK(toggle_check_while_typing_cb),
gtkaspell);
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
item = gtk_menu_item_new();
gtk_widget_show(item);
- gtk_menu_append(GTK_MENU(menu), 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);
- gtk_menu_append(GTK_MENU(menu), item);
+ list = g_slist_append(list, item);
/* Dict list */
if (gtkaspellcheckers->dictionary_list == NULL)
count++;
}
}
+ return list;
}
-static GtkMenu *make_config_menu(GtkAspell *gtkaspell)
-{
- if (!gtkaspell->popup_config_menu)
- gtkaspell->popup_config_menu = gtk_menu_new();
-
- debug_print("Aspell: creating/using popup_config_menu %0x\n",
- (guint) gtkaspell->popup_config_menu);
- populate_submenu(gtkaspell, gtkaspell->popup_config_menu);
-
- return GTK_MENU(gtkaspell->popup_config_menu);
-}
-
-void gtkaspell_populate_submenu(GtkAspell *gtkaspell, GtkWidget *menuitem)
+GSList *gtkaspell_make_config_menu(GtkAspell *gtkaspell)
{
- GtkWidget *menu;
-
- menu = GTK_WIDGET(GTK_MENU_ITEM(menuitem)->submenu);
-
- debug_print("Aspell: using config menu %0x\n",
- (guint) gtkaspell->popup_config_menu);
- populate_submenu(gtkaspell, menu);
-
- gtkaspell->config_menu = menu;
-
+ return populate_submenu(gtkaspell);
}
static void set_menu_pos(GtkMenu *menu, gint *x, gint *y,
gtkaspell->theword);
}
-/* Menu call backs */
-
-static gboolean cancel_menu_cb(GtkMenuShell *w, gpointer data)
-{
- GtkAspell *gtkaspell = (GtkAspell *) data;
-
- gtkaspell->continue_check = NULL;
- set_point_continue(gtkaspell);
-
- return FALSE;
-}
-
-gboolean gtkaspell_change_dict(GtkAspell *gtkaspell, const gchar *dictionary)
+/* change the current dictionary of gtkaspell
+ - if always_set_alt_dict is set, the alternate dict is unconditionally set to the former
+ current dictionary (common use: from menu callbacks)
+ - if always_set_alt_dict is NOT set, the alternate dict will be set to the former
+ current dictionary only if there is no alternate dictionary already set
+ (this is when we need to set the current dictionary then the alternate one
+ when creating a compose window, from the account and folder settings)
+*/
+gboolean gtkaspell_change_dict(GtkAspell *gtkaspell, const gchar *dictionary,
+ gboolean always_set_alt_dict)
{
Dictionary *dict;
GtkAspeller *gtkaspeller;
dict->fullname = g_strdup(dictionary);
dict->encoding = g_strdup(gtkaspell->gtkaspeller->dictionary->encoding);
- if (gtkaspell->use_alternate && gtkaspell->alternate_speller &&
- dict == gtkaspell->alternate_speller->dictionary) {
- use_alternate_dict(gtkaspell);
- dictionary_delete(dict);
- return TRUE;
- }
-
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);
-
- gtkaspell_alert_dialog(message);
- g_free(message);
} else {
if (gtkaspell->use_alternate) {
- if (gtkaspell->alternate_speller)
- gtkaspeller_delete(gtkaspell->alternate_speller);
- gtkaspell->alternate_speller = gtkaspell->gtkaspeller;
+ if (gtkaspell->alternate_speller) {
+ if (always_set_alt_dict) {
+ gtkaspeller_delete(gtkaspell->alternate_speller);
+ gtkaspell->alternate_speller = gtkaspell->gtkaspeller;
+ } else
+ gtkaspeller_delete(gtkaspell->gtkaspeller);
+ } else
+ /* should never be reached as the dicts are always set
+ to a default value */
+ gtkaspell->alternate_speller = gtkaspell->gtkaspeller;
} else
gtkaspeller_delete(gtkaspell->gtkaspeller);
dictionary_delete(dict);
- if (gtkaspell->config_menu)
- populate_submenu(gtkaspell, gtkaspell->config_menu);
+ return TRUE;
+}
+
+/* change the alternate dictionary of gtkaspell (doesn't affect the default dictionary) */
+gboolean gtkaspell_change_alt_dict(GtkAspell *gtkaspell, const gchar *alt_dictionary)
+{
+ Dictionary *dict;
+ GtkAspeller *gtkaspeller;
+
+ g_return_val_if_fail(gtkaspell, FALSE);
+ g_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);
+
+ gtkaspeller = gtkaspeller_new(dict);
+
+ if (!gtkaspeller) {
+ alertpanel_warning(_("The spell checker could not change the alternate dictionary.\n%s"),
+ gtkaspellcheckers->error_message);
+ } else {
+ if (gtkaspell->alternate_speller)
+ gtkaspeller_delete(gtkaspell->alternate_speller);
+ gtkaspell->alternate_speller = gtkaspeller;
+ }
+
+ dictionary_delete(dict);
return TRUE;
}
+/* Menu call backs */
+
/* change_dict_cb() - Menu callback : change dict */
static void change_dict_cb(GtkWidget *w, GtkAspell *gtkaspell)
{
if (!strcmp2(fullname, _("None")))
return;
- gtkaspell_change_dict(gtkaspell, fullname);
+ gtkaspell_change_dict(gtkaspell, fullname, TRUE);
+ if (gtkaspell->recheck_when_changing_dict) {
+ gtkaspell_highlight_all(gtkaspell);
+ }
+ if (gtkaspell->menu_changed_cb)
+ gtkaspell->menu_changed_cb(gtkaspell->menu_changed_data);
}
static void switch_to_alternate_cb(GtkWidget *w,
{
GtkAspell *gtkaspell = (GtkAspell *) data;
use_alternate_dict(gtkaspell);
+ if (gtkaspell->recheck_when_changing_dict) {
+ gtkaspell_highlight_all(gtkaspell);
+ }
+ if (gtkaspell->menu_changed_cb)
+ gtkaspell->menu_changed_cb(gtkaspell->menu_changed_data);
}
/* Misc. helper functions */
color->blue = (int) (((gdouble) (rgbvalue & 0x0000ff) / 255.0)
* 65535.0);
- gtk_text_buffer_create_tag(buffer, "misspelled",
+ if (rgbvalue != 0)
+ gtk_text_buffer_create_tag(buffer, "misspelled",
"foreground-gdk", color, NULL);
+ else
+ gtk_text_buffer_create_tag(buffer, "misspelled",
+ "underline", PANGO_UNDERLINE_ERROR, NULL);
+
}
static void change_color(GtkAspell * gtkaspell,
GtkTextBuffer *buffer;
GtkTextIter startiter, enditer;
- g_return_if_fail(start < end);
+ if (start > end)
+ return;
gtktext = gtkaspell->gtktext;
if (color)
gtk_text_buffer_apply_tag_by_name(buffer, "misspelled",
&startiter, &enditer);
- else
+ else {
+ gtk_text_iter_forward_char(&enditer);
gtk_text_buffer_remove_tag_by_name(buffer, "misspelled",
&startiter, &enditer);
+ }
}
/* convert_to_aspell_encoding () - converts ISO-8859-* strings to iso8859-*
* as needed by aspell. Returns an allocated string.
*/
-static guchar *convert_to_aspell_encoding (const guchar *encoding)
+static gchar *convert_to_aspell_encoding (const gchar *encoding)
{
- guchar * aspell_encoding;
+ gchar * aspell_encoding;
if (strstr2(encoding, "ISO-8859-")) {
aspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
list = list->next)
g_free(list->data);
- g_list_free(list);
+ g_list_free(gtkaspell->suggestions_list);
gtkaspell->max_sug = -1;
gtkaspell->suggestions_list = NULL;
return 1;
}
-static void gtkaspell_alert_dialog(gchar *message)
+gchar *gtkaspell_get_default_dictionary(GtkAspell *gtkaspell)
{
- GtkWidget *dialog;
- GtkWidget *hbox;
- GtkWidget *label;
- GtkWidget *ok_button;
-
- dialog = gtk_dialog_new();
- gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
- gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
- g_signal_connect_swapped(G_OBJECT(dialog), "destroy",
- G_CALLBACK(gtk_widget_destroy),
- G_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);
-
- g_signal_connect_swapped(G_OBJECT(ok_button), "clicked",
- G_CALLBACK(gtk_widget_destroy),
- G_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);
+ if (gtkaspell && gtkaspell->gtkaspeller &&
+ gtkaspell->gtkaspeller->dictionary)
+ return gtkaspell->gtkaspeller->dictionary->dictname;
+ else
+ return NULL;
}
#endif
projects / claws.git / blobdiff