# include "config.h"
#endif
-#if USE_ASPELL
+#ifdef USE_ASPELL
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <dirent.h>
+#include <glib.h>
+#include <glib/gi18n.h>
+
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gtk/gtkoptionmenu.h>
#include <gtk/gtkmenuitem.h>
#include <gdk/gdkkeysyms.h>
-#include "intl.h"
-#include "gtkstext.h"
+#include <aspell.h>
+
#include "utils.h"
+#include "codeconv.h"
+#include "alertpanel.h"
#include "gtkaspell.h"
+#include "gtk/gtkutils.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
RETURN_FALSE_IF_CONFIG_ERROR(); \
}
+typedef struct _GtkAspellCheckers {
+ GSList *checkers;
+ GSList *dictionary_list;
+ 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 use_alternate;
+
+ ContCheckFunc continue_check;
+
+ GtkWidget *config_menu;
+ GtkWidget *popup_config_menu;
+ GtkWidget *sug_menu;
+ GtkWidget *replace_entry;
+ GtkWidget *parent_window;
+
+ gint default_sug_mode;
+ gint max_sug;
+ GList *suggestions_list;
+
+ GtkTextView *gtktext;
+ GdkColor highlight;
+ GtkAccelGroup *accel_group;
+};
+
+typedef AspellConfig GtkAspellConfig;
+
/******************************************************************************/
-GtkAspellCheckers *gtkaspellcheckers;
+static GtkAspellCheckers *gtkaspellcheckers;
/* Error message storage */
static void gtkaspell_checkers_error_message (gchar *message);
/* Callbacks */
-static void entry_insert_cb (GtkSText *gtktext,
+static void entry_insert_cb (GtkTextBuffer *textbuf,
+ GtkTextIter *iter,
gchar *newtext,
- guint len,
- guint *ppos,
+ gint len,
GtkAspell *gtkaspell);
-static void entry_delete_cb (GtkSText *gtktext,
- gint start,
- gint end,
+static void entry_delete_cb (GtkTextBuffer *textbuf,
+ GtkTextIter *startiter,
+ GtkTextIter *enditer,
GtkAspell *gtkaspell);
-static gint button_press_intercept_cb (GtkSText *gtktext,
+static gint button_press_intercept_cb (GtkTextView *gtktext,
GdkEvent *e,
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 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);
-GtkAspellCheckers *gtkaspell_checkers_new(void)
+static gint get_textview_buffer_charcount(GtkTextView *view)
+{
+ GtkTextBuffer *buffer;
+
+ g_return_val_if_fail(view, 0);
+
+ buffer = gtk_text_view_get_buffer(view);
+ g_return_val_if_fail(buffer, 0);
+
+ return gtk_text_buffer_get_char_count(buffer);
+}
+static gint get_textview_buffer_offset(GtkTextView *view)
+{
+ GtkTextBuffer * buffer;
+ GtkTextMark * mark;
+ GtkTextIter iter;
+
+ g_return_val_if_fail(view, 0);
+
+ buffer = gtk_text_view_get_buffer(view);
+ g_return_val_if_fail(buffer, 0);
+
+ mark = gtk_text_buffer_get_insert(buffer);
+ g_return_val_if_fail(mark, 0);
+
+ gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
+
+ return gtk_text_iter_get_offset(&iter);
+}
+static void set_textview_buffer_offset(GtkTextView *view, gint offset)
+{
+ GtkTextBuffer *buffer;
+ GtkTextIter iter;
+
+ g_return_if_fail(view);
+
+ buffer = gtk_text_view_get_buffer(view);
+ g_return_if_fail(buffer);
+
+ gtk_text_buffer_get_iter_at_offset(buffer, &iter, offset);
+ gtk_text_buffer_place_cursor(buffer, &iter);
+}
+/******************************************************************************/
+
+void gtkaspell_checkers_init(void)
{
- GtkAspellCheckers *gtkaspellcheckers;
-
gtkaspellcheckers = g_new(GtkAspellCheckers, 1);
gtkaspellcheckers->checkers = NULL;
gtkaspellcheckers->dictionary_list = NULL;
gtkaspellcheckers->error_message = NULL;
-
- return gtkaspellcheckers;
}
-GtkAspellCheckers *gtkaspell_checkers_delete(void)
+void gtkaspell_checkers_quit(void)
{
GSList *checkers;
GSList *dict_list;
if (gtkaspellcheckers == NULL)
- return NULL;
+ return;
if ((checkers = gtkaspellcheckers->checkers)) {
debug_print("Aspell: number of running checkers to delete %d\n",
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);
-
- return NULL;
+ gtkaspellcheckers->error_message = NULL;
+ return;
}
static void gtkaspell_checkers_error_message (gchar *message)
gchar *tmp;
if (gtkaspellcheckers->error_message) {
tmp = g_strdup_printf("%s\n%s",
- gtkaspellcheckers->error_message, message);
+ gtkaspellcheckers->error_message,
+ message);
g_free(message);
g_free(gtkaspellcheckers->error_message);
gtkaspellcheckers->error_message = tmp;
gtkaspellcheckers->error_message = message;
}
+const char *gtkaspell_checkers_strerror(void)
+{
+ g_return_val_if_fail(gtkaspellcheckers, "");
+ return gtkaspellcheckers->error_message;
+}
+
void gtkaspell_checkers_reset_error(void)
{
g_return_if_fail(gtkaspellcheckers);
gint misspelled_color,
gboolean check_while_typing,
gboolean use_alternate,
- GtkSText *gtktext)
+ GtkTextView *gtktext,
+ GtkWindow *parent_win)
{
Dictionary *dict;
GtkAspell *gtkaspell;
GtkAspeller *gtkaspeller;
+ GtkTextBuffer *buffer;
g_return_val_if_fail(gtktext, NULL);
+ buffer = gtk_text_view_get_buffer(gtktext);
dict = g_new0(Dictionary, 1);
dict->fullname = g_strdup(dictionary);
gtkaspell = g_new0(GtkAspell, 1);
- gtkaspell->dictionary_path = dictionary_path;
+ gtkaspell->dictionary_path = g_strdup(dictionary_path);
gtkaspell->gtkaspeller = gtkaspeller;
gtkaspell->alternate_speller = NULL;
gtkaspell->max_sug = -1;
gtkaspell->suggestions_list = NULL;
gtkaspell->use_alternate = use_alternate;
-
+ gtkaspell->parent_window = GTK_WIDGET(parent_win);
+
allocate_color(gtkaspell, misspelled_color);
- gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text",
- GTK_SIGNAL_FUNC(entry_insert_cb), gtkaspell);
- gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
- GTK_SIGNAL_FUNC(entry_delete_cb), gtkaspell);
- gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
- GTK_SIGNAL_FUNC(button_press_intercept_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",
+ G_CALLBACK(entry_delete_cb), gtkaspell);
+ g_signal_connect(G_OBJECT(gtktext), "button-press-event",
+ G_CALLBACK(button_press_intercept_cb),
+ gtkaspell);
debug_print("Aspell: created gtkaspell %0x\n", (guint) gtkaspell);
return gtkaspell;
}
-void gtkaspell_delete(GtkAspell * gtkaspell)
+void gtkaspell_delete(GtkAspell *gtkaspell)
{
- GtkSText *gtktext = gtkaspell->gtktext;
+ GtkTextView *gtktext = gtkaspell->gtktext;
- gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_insert_cb),
- gtkaspell);
- gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_delete_cb),
- gtkaspell);
- gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(button_press_intercept_cb),
- gtkaspell);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(entry_insert_cb),
+ gtkaspell);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(entry_delete_cb),
+ gtkaspell);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(button_press_intercept_cb),
+ gtkaspell);
gtkaspell_uncheck_all(gtkaspell);
free_suggestions_list(gtkaspell);
g_free((gchar *)gtkaspell->dictionary_path);
-
+ gtkaspell->dictionary_path = NULL;
+
debug_print("Aspell: deleting gtkaspell %0x\n", (guint) gtkaspell);
g_free(gtkaspell);
gtkaspell = NULL;
}
-static void entry_insert_cb(GtkSText *gtktext,
- gchar *newtext,
- guint len,
- guint *ppos,
- GtkAspell *gtkaspell)
+static void entry_insert_cb(GtkTextBuffer *textbuf,
+ GtkTextIter *iter,
+ gchar *newtext,
+ gint len,
+ GtkAspell *gtkaspell)
{
+ guint pos;
+
g_return_if_fail(gtkaspell->gtkaspeller->checker);
if (!gtkaspell->check_while_typing)
return;
-
- /* We must insert ourselves the character so the
- * color of the inserted character is the default color.
- * Never mess with set_insertion when frozen.
- */
- gtk_stext_freeze(gtktext);
- gtk_stext_backward_delete(GTK_STEXT(gtktext), len);
- gtk_stext_insert(GTK_STEXT(gtktext), NULL, NULL, NULL, newtext, len);
- *ppos = gtk_stext_get_point(GTK_STEXT(gtktext));
-
+ pos = gtk_text_iter_get_offset(iter);
+
if (iswordsep(newtext[0])) {
/* did we just end a word? */
- if (*ppos >= 2)
- check_at(gtkaspell, *ppos - 2);
+ if (pos >= 2)
+ check_at(gtkaspell, pos - 2);
/* did we just split a word? */
- if (*ppos < gtk_stext_get_length(gtktext))
- check_at(gtkaspell, *ppos + 1);
+ if (pos < gtk_text_buffer_get_char_count(textbuf))
+ check_at(gtkaspell, pos + 1);
} else {
/* check as they type, *except* if they're typing at the end (the most
* common case).
*/
- if (*ppos < gtk_stext_get_length(gtktext) &&
- !iswordsep(get_text_index_whar(gtkaspell, *ppos))) {
- check_at(gtkaspell, *ppos - 1);
+ if (pos < gtk_text_buffer_get_char_count(textbuf) &&
+ !iswordsep(get_text_index_whar(gtkaspell, pos))) {
+ check_at(gtkaspell, pos - 1);
}
}
-
- gtk_stext_thaw(gtktext);
- gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
}
-static void entry_delete_cb(GtkSText *gtktext,
- gint start,
- gint end,
- GtkAspell *gtkaspell)
+static void entry_delete_cb(GtkTextBuffer *textbuf,
+ GtkTextIter *startiter,
+ GtkTextIter *enditer,
+ GtkAspell *gtkaspell)
{
int origpos;
+ gint start, end;
g_return_if_fail(gtkaspell->gtkaspeller->checker);
if (!gtkaspell->check_while_typing)
return;
- origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
+ 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);
check_at(gtkaspell, start);
}
- gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
- gtk_stext_set_point(gtktext, origpos);
+ set_textview_buffer_offset(gtkaspell->gtktext, origpos);
/* this is to *UNDO* the selection, in case they were holding shift
* while hitting backspace. */
- gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
+ /* needed with textview ??? */
+ /* gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); */
}
/* ok, this is pretty wacky:
* so what do we do? forge rightclicks as leftclicks, then popup the menu.
* HACK HACK HACK.
*/
-static gint button_press_intercept_cb(GtkSText *gtktext, GdkEvent *e, GtkAspell *gtkaspell)
+static gint button_press_intercept_cb(GtkTextView *gtktext,
+ GdkEvent *e,
+ GtkAspell *gtkaspell)
{
GdkEventButton *eb;
gboolean retval;
if (eb->button != 3)
return FALSE;
+ 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);
+
/* forge the leftclick */
eb->button = 1;
-
- gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(button_press_intercept_cb),
- gtkaspell);
- gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
- e, &retval);
- gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(button_press_intercept_cb),
+
+ 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);
- gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
+ 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 TRUE;
+ return FALSE;
}
/* Checker creation */
g_return_val_if_fail(dictionary, NULL);
if (dictionary->fullname == NULL)
- gtkaspell_checkers_error_message(g_strdup(_("No dictionary selected.")));
+ gtkaspell_checkers_error_message(
+ g_strdup(_("No dictionary selected.")));
g_return_val_if_fail(dictionary->fullname, NULL);
delete_aspell_config(config);
if (aspell_error_number(ret) != 0) {
- gtkaspellcheckers->error_message = g_strdup(aspell_error_message(ret));
+ gtkaspellcheckers->error_message
+ = g_strdup(aspell_error_message(ret));
delete_aspell_can_have_error(ret);
jargon = NULL;
debug_print("Aspell: language: %s, jargon: %s, size: %s\n",
- language, jargon, size);
+ language, jargon ? jargon : "",
+ size ? size : "");
if (language)
CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("lang", language);
gchar *aspell_enc;
aspell_enc = convert_to_aspell_encoding (dict->encoding);
- aspell_config_replace(config, "encoding", (const char *) aspell_enc);
+ aspell_config_replace(config, "encoding",
+ (const char *) aspell_enc);
g_free(aspell_enc);
RETURN_FALSE_IF_CONFIG_ERROR();
{
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->config_menu)
populate_submenu(gtkaspell, gtkaspell->config_menu);
if (!aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1)) {
free_suggestions_list(gtkaspell);
- suggestions = aspell_speller_suggest(gtkaspell->gtkaspeller->checker,
+ 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));
/* 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) ? 0 : 1;
+ return aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1)
+ ? 0 : 1;
}
static gboolean iswordsep(unsigned char c)
{
- return !isalpha(c) && c != '\'';
+ return (isspace(c) || ispunct(c)) && c != '\'';
}
static guchar get_text_index_whar(GtkAspell *gtkaspell, int pos)
{
- guchar a;
- gchar *text;
-
- text = gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->gtktext), pos,
- pos + 1);
- if (text == NULL)
- return 0;
+ GtkTextView *view = gtkaspell->gtktext;
+ GtkTextBuffer *buffer = gtk_text_view_get_buffer(view);
+ GtkTextIter start, end;
+ const gchar *utf8chars;
+ guchar a = '\0';
- a = (guchar) *text;
+ gtk_text_buffer_get_iter_at_offset(buffer, &start, pos);
+ gtk_text_buffer_get_iter_at_offset(buffer, &end, pos+1);
- g_free(text);
+ utf8chars = gtk_text_iter_get_text(&start, &end);
+ if (is_ascii_str(utf8chars)) {
+ a = utf8chars ? utf8chars[0] : '\0' ;
+ } else {
+ gchar *tr = conv_iconv_strdup(utf8chars, CS_UTF_8,
+ gtkaspell->gtkaspeller->dictionary->encoding);
+ if (tr) {
+ a = tr[0];
+ g_free(tr);
+ }
+ }
return a;
}
gint end;
guchar c;
- GtkSText *gtktext;
+ GtkTextView *gtktext;
gtktext = gtkaspell->gtktext;
if (iswordsep(get_text_index_whar(gtkaspell, pos)))
c = get_text_index_whar(gtkaspell, start);
if (c == '\'') {
if (start > 0) {
- if (!isalpha(get_text_index_whar(gtkaspell,
+ if (isspace(get_text_index_whar(gtkaspell,
+ start - 1))
+ || ispunct(get_text_index_whar(gtkaspell,
+ start - 1))
+ || isdigit(get_text_index_whar(gtkaspell,
start - 1))) {
/* start_quote = TRUE; */
break;
break;
}
}
- else if (!isalpha(c))
+ else if (isspace(c) || ispunct(c) || isdigit(c))
break;
}
start++;
- for (end = pos; end < gtk_stext_get_length(gtktext); end++) {
+ for (end = pos; end < get_textview_buffer_charcount(gtktext); end++) {
c = get_text_index_whar(gtkaspell, end);
if (c == '\'') {
- if (end < gtk_stext_get_length(gtktext)) {
- if (!isalpha(get_text_index_whar(gtkaspell,
+ if (end < get_textview_buffer_charcount(gtktext)) {
+ if (isspace(get_text_index_whar(gtkaspell,
+ end + 1))
+ || ispunct(get_text_index_whar(gtkaspell,
+ end + 1))
+ || isdigit(get_text_index_whar(gtkaspell,
end + 1))) {
/* end_quote = TRUE; */
break;
break;
}
}
- else if(!isalpha(c))
+ else if (isspace(c) || ispunct(c) || 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(buf, conv, buflen-1);
+ buf[buflen]='\0';
+ g_free(conv);
} else
return FALSE;
}
{
gint start, end;
unsigned char buf[GTKASPELLWORDSIZE];
- GtkSText *gtktext;
+ GtkTextView *gtktext;
g_return_val_if_fail(from_pos >= 0, FALSE);
if (!get_word_from_pos(gtkaspell, from_pos, buf, sizeof(buf),
&start, &end))
return FALSE;
-
if (misspelled_test(gtkaspell, buf)) {
strncpy(gtkaspell->theword, buf, GTKASPELLWORDSIZE - 1);
gtkaspell->theword[GTKASPELLWORDSIZE - 1] = 0;
maxpos--;
}
- pos = gtk_editable_get_position(GTK_EDITABLE(gtkaspell->gtktext));
+ pos = get_textview_buffer_offset(gtkaspell->gtktext);
gtkaspell->orig_pos = pos;
while (iswordsep(get_text_index_whar(gtkaspell, pos)) &&
- pos > minpos && pos <= maxpos)
+ pos > minpos && pos <= maxpos)
pos += direc;
while (!(misspelled = check_at(gtkaspell, pos)) &&
pos > minpos && pos <= maxpos) {
pos > minpos && pos <= maxpos)
pos += direc;
- while (iswordsep(get_text_index_whar(gtkaspell, pos)) &&
- pos > minpos && pos <= maxpos)
+ while (iswordsep(get_text_index_whar(gtkaspell, pos)) &&
+ pos > minpos && pos <= maxpos)
pos += direc;
}
if (misspelled) {
+ GtkMenu *menu = NULL;
misspelled_suggest(gtkaspell, gtkaspell->theword);
if (forward)
gtkaspell->orig_pos = gtkaspell->end_pos;
- gtk_stext_set_point(GTK_STEXT(gtkaspell->gtktext),
- gtkaspell->end_pos);
- gtk_editable_set_position(GTK_EDITABLE(gtkaspell->gtktext),
+ set_textview_buffer_offset(gtkaspell->gtktext,
gtkaspell->end_pos);
- gtk_menu_popup(make_sug_menu(gtkaspell), NULL, NULL,
+ /* 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 ();
+
+ menu = make_sug_menu(gtkaspell);
+ gtk_menu_popup(menu, NULL, NULL,
set_menu_pos, gtkaspell, 0, GDK_CURRENT_TIME);
+ g_signal_connect(G_OBJECT(menu), "deactivate",
+ G_CALLBACK(destroy_menu),
+ gtkaspell);
+
} else {
reset_theword_data(gtkaspell);
- gtkaspell_alert_dialog(_("No misspelled word found."));
- gtk_stext_set_point(GTK_STEXT(gtkaspell->gtktext),
- gtkaspell->orig_pos);
- gtk_editable_set_position(GTK_EDITABLE(gtkaspell->gtktext),
+ alertpanel_notice(_("No misspelled word found."));
+ set_textview_buffer_offset(gtkaspell->gtktext,
gtkaspell->orig_pos);
-
-
}
+
return misspelled;
}
{
gtkaspell->continue_check = NULL;
gtkaspell->end_check_pos =
- gtk_stext_get_length(GTK_STEXT(gtkaspell->gtktext));
+ get_textview_buffer_charcount(gtkaspell->gtktext);
check_next_prev(gtkaspell, FALSE);
}
{
gtkaspell->continue_check = NULL;
- gtkaspell->end_check_pos
- = gtk_stext_get_length(GTK_STEXT(gtkaspell->gtktext));
+ gtkaspell->end_check_pos =
+ get_textview_buffer_charcount(gtkaspell->gtktext);
check_next_prev(gtkaspell, TRUE);
}
void gtkaspell_check_all(GtkAspell *gtkaspell)
{
- GtkWidget *gtktext;
+ GtkTextView *gtktext;
gint start, end;
+ GtkTextBuffer *buffer;
+ GtkTextIter startiter, enditer;
g_return_if_fail(gtkaspell);
g_return_if_fail(gtkaspell->gtktext);
- gtktext = (GtkWidget *) gtkaspell->gtktext;
-
- start = 0;
- end = gtk_stext_get_length(GTK_STEXT(gtktext));
-
- if (GTK_EDITABLE(gtktext)->has_selection) {
- start = GTK_EDITABLE(gtktext)->selection_start_pos;
- end = GTK_EDITABLE(gtktext)->selection_end_pos;
- }
-
- if (start > end) {
+ gtktext = gtkaspell->gtktext;
+ buffer = gtk_text_view_get_buffer(gtktext);
+ gtk_text_buffer_get_selection_bounds(buffer, &startiter, &enditer);
+ start = gtk_text_iter_get_offset(&startiter);
+ end = gtk_text_iter_get_offset(&enditer);
+
+ if (start == end) {
+ start = 0;
+ end = gtk_text_buffer_get_char_count(buffer);
+ } else if (start > end) {
gint tmp;
tmp = start;
start = end;
end = tmp;
}
-
-
- gtk_editable_set_position(GTK_EDITABLE(gtktext), start);
- gtk_stext_set_point(GTK_STEXT(gtktext), start);
+
+ set_textview_buffer_offset(gtktext, start);
gtkaspell->continue_check = continue_check;
gtkaspell->end_check_pos = end;
gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
-
}
static void continue_check(gpointer *data)
{
GtkAspell *gtkaspell = (GtkAspell *) data;
- gint pos = gtk_editable_get_position(GTK_EDITABLE(gtkaspell->gtktext));
+ gint pos = get_textview_buffer_offset(gtkaspell->gtktext);
if (pos < gtkaspell->end_check_pos && gtkaspell->misspelled)
gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
else
gtkaspell->continue_check = NULL;
-
}
void gtkaspell_highlight_all(GtkAspell *gtkaspell)
guint origpos;
guint pos = 0;
guint len;
- GtkSText *gtktext;
- gfloat adj_value;
+ GtkTextView *gtktext;
g_return_if_fail(gtkaspell->gtkaspeller->checker);
gtktext = gtkaspell->gtktext;
- adj_value = gtktext->vadj->value;
-
- len = gtk_stext_get_length(gtktext);
+ len = get_textview_buffer_charcount(gtktext);
- origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
+ origpos = get_textview_buffer_offset(gtktext);
while (pos < len) {
- while (pos < len &&
+ while (pos < len &&
iswordsep(get_text_index_whar(gtkaspell, pos)))
pos++;
while (pos < len &&
if (pos > 0)
check_at(gtkaspell, pos - 1);
}
- gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
- gtk_stext_set_point(GTK_STEXT(gtktext), origpos);
- gtk_adjustment_set_value(gtktext->vadj, adj_value);
+ set_textview_buffer_offset(gtktext, origpos);
}
static void replace_with_supplied_word_cb(GtkWidget *w, GtkAspell *gtkaspell)
{
unsigned char *newword;
GdkEvent *e= (GdkEvent *) gtk_get_current_event();
-
+
newword = gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->replace_entry),
0, -1);
-
+
if (strcmp(newword, gtkaspell->theword)) {
replace_real_word(gtkaspell, newword);
- if ((e->type == GDK_KEY_PRESS &&
- ((GdkEventKey *) e)->state & GDK_MOD1_MASK)) {
- aspell_speller_store_replacement(gtkaspell->gtkaspeller->checker,
- gtkaspell->theword, -1,
- newword, -1);
+ if ((e->type == GDK_KEY_PRESS &&
+ ((GdkEventKey *) e)->state & GDK_CONTROL_MASK)) {
+ aspell_speller_store_replacement(
+ gtkaspell->gtkaspeller->checker,
+ gtkaspell->theword, -1,
+ 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 = g_strdup(newword);
replace_real_word(gtkaspell, newword);
if ((e->type == GDK_KEY_PRESS &&
- ((GdkEventKey *) e)->state & GDK_MOD1_MASK) ||
+ ((GdkEventKey *) e)->state & GDK_CONTROL_MASK) ||
(e->type == GDK_BUTTON_RELEASE &&
- ((GdkEventButton *) e)->state & GDK_MOD1_MASK)) {
- aspell_speller_store_replacement(gtkaspell->gtkaspeller->checker,
+ ((GdkEventButton *) e)->state & GDK_CONTROL_MASK)) {
+ aspell_speller_store_replacement(
+ gtkaspell->gtkaspeller->checker,
gtkaspell->theword, -1,
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;
- GtkSText *gtktext;
+ GtkTextView *gtktext;
+ GtkTextBuffer *textbuf;
+ GtkTextIter startiter, enditer;
if (!newword) return;
gtktext = gtkaspell->gtktext;
+ textbuf = gtk_text_view_get_buffer(gtktext);
- gtk_stext_freeze(GTK_STEXT(gtktext));
origpos = gtkaspell->orig_pos;
pos = origpos;
oldlen = gtkaspell->end_pos - gtkaspell->start_pos;
newlen = strlen(newword); /* FIXME: multybyte characters? */
- gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_insert_cb),
+ g_signal_handlers_block_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(entry_insert_cb),
gtkaspell);
- gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_delete_cb),
+ g_signal_handlers_block_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(entry_delete_cb),
gtkaspell);
- gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "delete-text",
- gtkaspell->start_pos, gtkaspell->end_pos);
- gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "insert-text",
- newword, newlen, &start);
-
- gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_insert_cb),
+ gtk_text_buffer_get_iter_at_offset(textbuf, &startiter,
+ gtkaspell->start_pos);
+ gtk_text_buffer_get_iter_at_offset(textbuf, &enditer,
+ gtkaspell->end_pos);
+ g_signal_emit_by_name(G_OBJECT(textbuf), "delete-range",
+ &startiter, &enditer, gtkaspell);
+ 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);
- gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
- GTK_SIGNAL_FUNC(entry_delete_cb),
+ g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
+ G_CALLBACK(entry_delete_cb),
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
* to let it update correctly the word insertion and then the
* point & position position. If not, SEGV after the first replacement
* If the new word ends before point, put the point at its end.
*/
-
- if (origpos - gtkaspell->start_pos < oldlen &&
+
+ if (origpos - gtkaspell->start_pos < oldlen &&
origpos - gtkaspell->start_pos >= 0) {
/* Original point was in the word.
* Let it there unless point is going to be outside of the word
/* move the position according to the change of length */
pos = origpos + newlen - oldlen;
}
-
- gtkaspell->end_pos = gtkaspell->start_pos + strlen(newword); /* FIXME: multibyte characters? */
-
- gtk_stext_thaw(GTK_STEXT(gtktext));
- gtk_stext_freeze(GTK_STEXT(gtktext));
- if (GTK_STEXT(gtktext)->text_len < pos)
- pos = gtk_stext_get_length(GTK_STEXT(gtktext));
+ gtkaspell->end_pos = gtkaspell->start_pos + strlen(newword); /* FIXME: multibyte characters? */
+ if (get_textview_buffer_charcount(gtktext) < pos)
+ pos = get_textview_buffer_charcount(gtktext);
gtkaspell->orig_pos = pos;
- gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkaspell->orig_pos);
- gtk_stext_set_point(GTK_STEXT(gtktext),
- gtk_editable_get_position(GTK_EDITABLE(gtktext)));
-
- gtk_stext_thaw(GTK_STEXT(gtktext));
+ set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
}
/* Accept this word for this session */
static void add_word_to_session_cb(GtkWidget *w, gpointer data)
{
guint pos;
- GtkSText *gtktext;
+ GtkTextView *gtktext;
GtkAspell *gtkaspell = (GtkAspell *) data;
gtktext = gtkaspell->gtktext;
- gtk_stext_freeze(GTK_STEXT(gtktext));
+ pos = get_textview_buffer_offset(gtktext);
- pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
-
aspell_speller_add_to_session(gtkaspell->gtkaspeller->checker,
- gtkaspell->theword,
+ gtkaspell->theword,
strlen(gtkaspell->theword));
check_at(gtkaspell, gtkaspell->start_pos);
- gtk_stext_thaw(gtkaspell->gtktext);
-
gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
set_point_continue(gtkaspell);
static void add_word_to_personal_cb(GtkWidget *w, gpointer data)
{
GtkAspell *gtkaspell = (GtkAspell *) data;
- GtkSText *gtktext = gtkaspell->gtktext;
- gtk_stext_freeze(GTK_STEXT(gtktext));
-
aspell_speller_add_to_personal(gtkaspell->gtkaspeller->checker,
gtkaspell->theword,
strlen(gtkaspell->theword));
-
- check_at(gtkaspell, gtkaspell->start_pos);
- gtk_stext_thaw(gtkaspell->gtktext);
+ check_at(gtkaspell, gtkaspell->start_pos);
gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
set_point_continue(gtkaspell);
gtkaspell->misspelled = misspelled;
if (gtkaspell->misspelled) {
-
+ GtkMenu *menu;
misspelled_suggest(gtkaspell, gtkaspell->theword);
- gtk_stext_set_point(GTK_STEXT(gtkaspell->gtktext),
+ set_textview_buffer_offset(gtkaspell->gtktext,
gtkaspell->end_pos);
- gtk_editable_set_position(GTK_EDITABLE(gtkaspell->gtktext),
- gtkaspell->end_pos);
- gtk_menu_popup(make_sug_menu(gtkaspell), NULL, NULL,
- set_menu_pos, gtkaspell, 0,
+ menu = make_sug_menu(gtkaspell);
+ gtk_menu_popup(menu, NULL, NULL,
+ set_menu_pos, gtkaspell, 0,
GDK_CURRENT_TIME);
+ g_signal_connect(G_OBJECT(menu), "deactivate",
+ G_CALLBACK(destroy_menu),
+ 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;
dialog = gtk_dialog_new();
- gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
+ 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_signal_connect_object(GTK_OBJECT(dialog), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT(dialog));
+ 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);
- gtk_signal_connect(GTK_OBJECT(entry), "activate",
- GTK_SIGNAL_FUNC(replace_with_supplied_word_cb),
- gtkaspell);
- gtk_signal_connect_object(GTK_OBJECT(entry), "activate",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT(dialog));
- gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
-
- gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE,
- TRUE, 0);
- label = gtk_label_new(_("Holding down MOD1 key while pressing "
+ 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);
+
+ 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);
- gtk_signal_connect(GTK_OBJECT(ok_button), "clicked",
- GTK_SIGNAL_FUNC(replace_with_supplied_word_cb),
- gtkaspell);
- gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT(dialog));
+ gtkut_stock_button_set_create(&confirm_area,
+ &ok_button, GTK_STOCK_OK,
+ &cancel_button, GTK_STOCK_CANCEL,
+ 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);
- cancel_button = gtk_button_new_with_label(_("Cancel"));
- gtk_box_pack_start(GTK_BOX(hbox), cancel_button, TRUE, TRUE, 8);
- gtk_signal_connect_object(GTK_OBJECT(cancel_button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT(dialog));
+ g_signal_connect(G_OBJECT(ok_button), "clicked",
+ G_CALLBACK(replace_with_supplied_word_cb),
+ gtkaspell);
+ 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);
+ g_signal_connect_swapped(G_OBJECT(cancel_button), "clicked",
+ G_CALLBACK(gtk_widget_destroy),
+ G_OBJECT(dialog));
gtk_widget_grab_focus(entry);
void gtkaspell_uncheck_all(GtkAspell * gtkaspell)
{
- gint origpos;
- gchar *text;
- gfloat adj_value;
- GtkSText *gtktext;
+ GtkTextView *gtktext;
+ GtkTextBuffer *buffer;
+ GtkTextIter startiter, enditer;
gtktext = gtkaspell->gtktext;
- adj_value = gtktext->vadj->value;
-
- gtk_stext_freeze(gtktext);
-
- origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
-
- text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
-
- gtk_stext_set_point(gtktext, 0);
- gtk_stext_forward_delete(gtktext, gtk_stext_get_length(gtktext));
- gtk_stext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
-
- gtk_stext_thaw(gtktext);
-
- gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
- gtk_stext_set_point(gtktext, origpos);
- gtk_adjustment_set_value(gtktext->vadj, adj_value);
-
- g_free(text);
-
+ buffer = gtk_text_view_get_buffer(gtktext);
+ gtk_text_buffer_get_iter_at_offset(buffer, &startiter, 0);
+ gtk_text_buffer_get_iter_at_offset(buffer, &enditer,
+ get_textview_buffer_charcount(gtktext)-1);
+ gtk_text_buffer_remove_tag_by_name(buffer, "misspelled",
+ &startiter, &enditer);
}
static void toggle_check_while_typing_cb(GtkWidget *w, gpointer data)
const AspellDictInfo *entry;
if (!gtkaspellcheckers)
- gtkaspellcheckers = gtkaspell_checkers_new();
+ gtkaspell_checkers_init();
if (gtkaspellcheckers->dictionary_list && !refresh)
return gtkaspellcheckers->dictionary_list;
else
- gtkaspell_free_dictionary_list(gtkaspellcheckers->dictionary_list);
+ gtkaspell_free_dictionary_list(
+ gtkaspellcheckers->dictionary_list);
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(
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);
}
for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
dict = (Dictionary *) tmp->data;
item = gtk_menu_item_new_with_label(dict->dictname);
- gtk_object_set_data(GTK_OBJECT(item), "dict_name",
- dict->fullname);
+ g_object_set_data(G_OBJECT(item), "dict_name",
+ dict->fullname);
gtk_menu_append(GTK_MENU(menu), item);
gtk_widget_show(item);
g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
menuitem = gtk_menu_get_active(GTK_MENU(menu));
- dict_fullname = (gchar *) gtk_object_get_data(GTK_OBJECT(menuitem),
- "dict_name");
+ 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);
}
+gint gtkaspell_set_dictionary_menu_active_item(GtkWidget *menu,
+ const gchar *dictionary)
+{
+ 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);
+
+ 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;
+}
+
GtkWidget *gtkaspell_sugmode_option_menu_new(gint sugmode)
{
GtkWidget *menu;
item = gtk_menu_item_new_with_label(_("Fast Mode"));
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
- gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(ASPELL_FASTMODE));
+ 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);
- gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(ASPELL_NORMALMODE));
+ g_object_set_data(G_OBJECT(item), "sugmode",
+ GINT_TO_POINTER(ASPELL_NORMALMODE));
item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
- gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(ASPELL_BADSPELLERMODE));
+ g_object_set_data(G_OBJECT(item), "sugmode",
+ GINT_TO_POINTER(ASPELL_BADSPELLERMODE));
return menu;
}
item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
- sugmode = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item),
- "sugmode"));
+ sugmode = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item),
+ "sugmode"));
return sugmode;
}
populate_submenu(gtkaspell, gtkaspell->config_menu);
}
+static void destroy_menu(GtkWidget *widget,
+ gpointer user_data) {
+
+ GtkAspell *gtkaspell = (GtkAspell *)user_data;
+
+ if (gtkaspell->accel_group) {
+ gtk_window_remove_accel_group(GTK_WINDOW(gtkaspell->parent_window),
+ gtkaspell->accel_group);
+ gtkaspell->accel_group = NULL;
+ }
+}
+
static void popup_menu(GtkAspell *gtkaspell, GdkEventButton *eb)
{
- GtkSText * gtktext;
+ GtkTextView * gtktext;
+ GtkMenu *menu = NULL;
gtktext = gtkaspell->gtktext;
- gtkaspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
+
+ gtkaspell->orig_pos = get_textview_buffer_offset(gtktext);
if (!(eb->state & GDK_SHIFT_MASK)) {
if (check_at(gtkaspell, gtkaspell->orig_pos)) {
- gtk_editable_set_position(GTK_EDITABLE(gtktext),
- gtkaspell->orig_pos);
- gtk_stext_set_point(gtktext, gtkaspell->orig_pos);
+ set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
if (misspelled_suggest(gtkaspell, gtkaspell->theword)) {
- gtk_menu_popup(make_sug_menu(gtkaspell),
+ menu = make_sug_menu(gtkaspell);
+ gtk_menu_popup(menu,
NULL, NULL, NULL, NULL,
- eb->button, GDK_CURRENT_TIME);
-
+ eb->button, eb->time);
+
+ g_signal_connect(G_OBJECT(menu), "deactivate",
+ G_CALLBACK(destroy_menu),
+ gtkaspell);
return;
}
- } else {
- gtk_editable_set_position(GTK_EDITABLE(gtktext),
- gtkaspell->orig_pos);
- gtk_stext_set_point(gtktext, gtkaspell->orig_pos);
- }
+ } 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);
- gtk_menu_popup(make_config_menu(gtkaspell), NULL, NULL, NULL, NULL,
- eb->button, GDK_CURRENT_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) || event->keyval == GDK_Return)) {
+ gtk_accel_groups_activate(
+ G_OBJECT(gtkaspell->parent_window),
+ event->keyval, event->state);
+ } else if (event && event->keyval == GDK_Escape) {
+ destroy_menu(NULL, gtkaspell);
+ }
+ return FALSE;
}
/* make_sug_menu() - Add menus to accept this word for this session
{
GtkWidget *menu, *item;
unsigned char *caption;
- GtkSText *gtktext;
+ GtkTextView *gtktext;
GtkAccelGroup *accel;
GList *l = gtkaspell->suggestions_list;
+ gchar *utf8buf;
gtktext = gtkaspell->gtktext;
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);
+ gtkaspell->accel_group = NULL;
+ }
+
gtkaspell->sug_menu = menu;
- gtk_signal_connect(GTK_OBJECT(menu), "cancel",
- GTK_SIGNAL_FUNC(cancel_menu_cb), gtkaspell);
+ g_signal_connect(G_OBJECT(menu), "cancel",
+ G_CALLBACK(cancel_menu_cb), gtkaspell);
+ utf8buf = conv_codeset_strdup((unsigned 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);
gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
item = gtk_menu_item_new_with_label(_("Accept in this session"));
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(add_word_to_session_cb),
- gtkaspell);
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(add_word_to_session_cb),
+ gtkaspell);
gtk_widget_add_accelerator(item, "activate", accel, GDK_space,
- GDK_MOD1_MASK,
+ GDK_CONTROL_MASK,
GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
item = gtk_menu_item_new_with_label(_("Add to personal dictionary"));
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(add_word_to_personal_cb),
- gtkaspell);
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(add_word_to_personal_cb),
+ gtkaspell);
gtk_widget_add_accelerator(item, "activate", accel, GDK_Return,
- GDK_MOD1_MASK,
+ GDK_CONTROL_MASK,
GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
item = gtk_menu_item_new_with_label(_("Replace with..."));
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(replace_with_create_dialog_cb),
- gtkaspell);
+ 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"),
g_free(caption);
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(check_with_alternate_cb),
- gtkaspell);
+ 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();
curmenu);
}
- item = gtk_menu_item_new_with_label((unsigned char*)l->data);
+ utf8buf = conv_codeset_strdup((unsigned 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);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(replace_word_cb),
- gtkaspell);
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(replace_word_cb),
+ gtkaspell);
if (curmenu == menu && count < MENUCOUNT) {
gtk_widget_add_accelerator(item, "activate",
gtk_widget_add_accelerator(item, "activate",
accel,
GDK_A + count,
- GDK_MOD1_MASK,
+ GDK_CONTROL_MASK,
GTK_ACCEL_LOCKED);
}
} while ((l = l->next) != NULL);
}
- gtk_accel_group_attach(accel, GTK_OBJECT(menu));
- gtk_accel_group_unref(accel);
+ gtk_window_add_accel_group
+ (GTK_WINDOW(gtkaspell->parent_window),
+ accel);
+ gtkaspell->accel_group = accel;
+
+ g_signal_connect(G_OBJECT(menu),
+ "key_press_event",
+ G_CALLBACK(aspell_key_pressed), gtkaspell);
return GTK_MENU(menu);
}
gtkaspell->alternate_speller->dictionary->dictname);
item = gtk_menu_item_new_with_label(dictname);
g_free(dictname);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(switch_to_alternate_cb),
- gtkaspell);
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(switch_to_alternate_cb),
+ gtkaspell);
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
} else
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(set_sug_mode_cb),
- gtkaspell);
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(set_sug_mode_cb),
+ gtkaspell);
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
} else
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(set_sug_mode_cb),
- gtkaspell);
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(set_sug_mode_cb),
+ gtkaspell);
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu),item);
gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
} else
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(set_sug_mode_cb),
- gtkaspell);
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(set_sug_mode_cb),
+ gtkaspell);
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
else
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(toggle_check_while_typing_cb),
- gtkaspell);
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(toggle_check_while_typing_cb),
+ gtkaspell);
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
}
dict = (Dictionary *) tmp->data;
item = gtk_check_menu_item_new_with_label(dict->dictname);
- gtk_object_set_data(GTK_OBJECT(item), "dict_name",
- dict->fullname);
+ 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);
gtk_widget_set_sensitive(GTK_WIDGET(item),
FALSE);
}
- gtk_signal_connect(GTK_OBJECT(item), "activate",
- GTK_SIGNAL_FUNC(change_dict_cb),
- gtkaspell);
+ g_signal_connect(G_OBJECT(item), "activate",
+ G_CALLBACK(change_dict_cb),
+ gtkaspell);
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(curmenu), item);
}
-static void set_menu_pos(GtkMenu *menu, gint *x, gint *y, gpointer data)
+static void set_menu_pos(GtkMenu *menu, gint *x, gint *y,
+ gboolean *push_in, gpointer data)
{
GtkAspell *gtkaspell = (GtkAspell *) data;
gint xx = 0, yy = 0;
gint sx, sy;
gint wx, wy;
- GtkSText *text = GTK_STEXT(gtkaspell->gtktext);
+ GtkTextView *text = GTK_TEXT_VIEW(gtkaspell->gtktext);
+ GtkTextBuffer *textbuf;
+ GtkTextIter iter;
+ GdkRectangle rect;
GtkRequisition r;
+ textbuf = gtk_text_view_get_buffer(gtkaspell->gtktext);
+ gtk_text_buffer_get_iter_at_mark(textbuf, &iter,
+ gtk_text_buffer_get_insert(textbuf));
+ gtk_text_view_get_iter_location(gtkaspell->gtktext, &iter, &rect);
+ gtk_text_view_buffer_to_window_coords(text, GTK_TEXT_WINDOW_TEXT,
+ rect.x, rect.y,
+ &rect.x, &rect.y);
+
gdk_window_get_origin(GTK_WIDGET(gtkaspell->gtktext)->window, &xx, &yy);
-
+
sx = gdk_screen_width();
sy = gdk_screen_height();
-
+
gtk_widget_get_child_requisition(GTK_WIDGET(menu), &r);
-
+
wx = r.width;
wy = r.height;
-
- *x = gtkaspell->gtktext->cursor_pos_x + xx +
- gdk_char_width(GTK_WIDGET(text)->style->font, ' ');
- *y = gtkaspell->gtktext->cursor_pos_y + yy;
+
+ *x = rect.x + xx +
+ gdk_char_width(gtk_style_get_font(GTK_WIDGET(text)->style), ' ');
+
+ *y = rect.y + rect.height + yy;
if (*x + wx > sx)
*x = sx - wx;
if (*y + wy > sy)
- *y = *y - wy -
- gdk_string_height((GTK_WIDGET(gtkaspell->gtktext))->style->font,
+ *y = *y - wy -
+ gdk_string_height(gtk_style_get_font(
+ GTK_WIDGET(text)->style),
gtkaspell->theword);
-
}
/* Menu call backs */
set_point_continue(gtkaspell);
return FALSE;
-
}
-/* change_dict_cb() - Menu callback : change dict */
-static void change_dict_cb(GtkWidget *w, GtkAspell *gtkaspell)
+gboolean gtkaspell_change_dict(GtkAspell *gtkaspell, const gchar *dictionary)
{
Dictionary *dict;
- gchar *fullname;
GtkAspeller *gtkaspeller;
gint sug_mode;
-
- fullname = (gchar *) gtk_object_get_data(GTK_OBJECT(w), "dict_name");
-
- if (!strcmp2(fullname, _("None")))
- return;
+ g_return_val_if_fail(gtkaspell, FALSE);
+ g_return_val_if_fail(dictionary, FALSE);
+
sug_mode = gtkaspell->default_sug_mode;
dict = g_new0(Dictionary, 1);
- dict->fullname = g_strdup(fullname);
+ 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;
+ gtkaspell->alternate_speller->dictionary = NULL;
+ return TRUE;
}
gtkaspeller = gtkaspeller_new(dict);
message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s"),
gtkaspellcheckers->error_message);
- gtkaspell_alert_dialog(message);
+ alertpanel_warning(message);
g_free(message);
} else {
if (gtkaspell->use_alternate) {
if (gtkaspell->config_menu)
populate_submenu(gtkaspell, gtkaspell->config_menu);
+
+ return TRUE;
+}
+
+/* change_dict_cb() - Menu callback : change dict */
+static void change_dict_cb(GtkWidget *w, GtkAspell *gtkaspell)
+{
+ gchar *fullname;
+
+ fullname = (gchar *) g_object_get_data(G_OBJECT(w), "dict_name");
+
+ if (!strcmp2(fullname, _("None")))
+ return;
+
+ gtkaspell_change_dict(gtkaspell, fullname);
}
static void switch_to_alternate_cb(GtkWidget *w,
static void set_point_continue(GtkAspell *gtkaspell)
{
- GtkSText *gtktext;
+ GtkTextView *gtktext;
gtktext = gtkaspell->gtktext;
- gtk_stext_freeze(gtktext);
- gtk_editable_set_position(GTK_EDITABLE(gtktext),gtkaspell->orig_pos);
- gtk_stext_set_point(gtktext, gtkaspell->orig_pos);
- gtk_stext_thaw(gtktext);
+ set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
if (gtkaspell->continue_check)
gtkaspell->continue_check((gpointer *) gtkaspell);
static void allocate_color(GtkAspell *gtkaspell, gint rgbvalue)
{
- GdkColormap *gc;
+ GtkTextBuffer *buffer = gtk_text_view_get_buffer(gtkaspell->gtktext);
GdkColor *color = &(gtkaspell->highlight);
- gc = gtk_widget_get_colormap(GTK_WIDGET(gtkaspell->gtktext));
-
- if (gtkaspell->highlight.pixel)
- gdk_colormap_free_colors(gc, &(gtkaspell->highlight), 1);
-
/* Shameless copy from Sylpheed's gtkutils.c */
color->pixel = 0L;
color->red = (int) (((gdouble)((rgbvalue & 0xff0000) >> 16) / 255.0)
color->blue = (int) (((gdouble) (rgbvalue & 0x0000ff) / 255.0)
* 65535.0);
- gdk_colormap_alloc_color(gc, &(gtkaspell->highlight), FALSE, TRUE);
+ gtk_text_buffer_create_tag(buffer, "misspelled",
+ "foreground-gdk", color, NULL);
}
static void change_color(GtkAspell * gtkaspell,
gchar *newtext,
GdkColor *color)
{
- GtkSText *gtktext;
+ GtkTextView *gtktext;
+ GtkTextBuffer *buffer;
+ GtkTextIter startiter, enditer;
- g_return_if_fail(start < end);
+ if (start > end)
+ return;
gtktext = gtkaspell->gtktext;
- gtk_stext_freeze(gtktext);
- if (newtext) {
- gtk_stext_set_point(gtktext, start);
- gtk_stext_forward_delete(gtktext, end - start);
- gtk_stext_insert(gtktext, NULL, color, NULL, newtext,
- end - start);
- }
- gtk_stext_thaw(gtktext);
+ buffer = gtk_text_view_get_buffer(gtktext);
+ gtk_text_buffer_get_iter_at_offset(buffer, &startiter, start);
+ gtk_text_buffer_get_iter_at_offset(buffer, &enditer, end);
+ if (color)
+ gtk_text_buffer_apply_tag_by_name(buffer, "misspelled",
+ &startiter, &enditer);
+ else
+ gtk_text_buffer_remove_tag_by_name(buffer, "misspelled",
+ &startiter, &enditer);
}
/* convert_to_aspell_encoding () - converts ISO-8859-* strings to iso8859-*
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)
-{
- GtkWidget *dialog;
- GtkWidget *hbox;
- GtkWidget *label;
- GtkWidget *ok_button;
-
- dialog = gtk_dialog_new();
- gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
- gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_MOUSE);
- gtk_signal_connect_object(GTK_OBJECT(dialog), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT(dialog));
-
- label = gtk_label_new(message);
- gtk_misc_set_padding(GTK_MISC(label), 8, 8);
-
- gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
-
- hbox = gtk_hbox_new(FALSE, 0);
-
- ok_button = gtk_button_new_with_label(_("OK"));
- GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
- gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 8);
-
- gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT(dialog));
- gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), hbox);
-
- gtk_widget_grab_default(ok_button);
- gtk_widget_grab_focus(ok_button);
- gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
-
- gtk_widget_show_all(dialog);
-}
#endif
projects / claws.git / blobdiff