initial

1 files changed, 1015 insertions, 0 deletions

diff --git a/plugins/spell/gedit-automatic-spell-checker.c b/plugins/spell/gedit-automatic-spell-checker.c
new file mode 100755
index 00000000..96b2fae9
--- /dev/null
+++ b/plugins/spell/gedit-automatic-spell-checker.c
@@ -0,0 +1,1015 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * gedit-automatic-spell-checker.c
+ * This file is part of gedit
+ *
+ * Copyright (C) 2002 Paolo Maggi 
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, 
+ * Boston, MA 02111-1307, USA. 
+ */
+
+/*
+ * Modified by the gedit Team, 2002. See the AUTHORS file for a 
+ * list of people on the gedit Team.  
+ * See the ChangeLog files for a list of changes. 
+ */
+
+/* This is a modified version of gtkspell 2.0.5  (gtkspell.sf.net) */
+/* gtkspell - a spell-checking addon for GTK's TextView widget
+ * Copyright (c) 2002 Evan Martin.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+
+#include <glib/gi18n.h>
+
+#include "gedit-automatic-spell-checker.h"
+#include "gedit-spell-utils.h"
+
+struct _GeditAutomaticSpellChecker {
+	GeditDocument		*doc;
+	GSList 			*views;
+	
+	GtkTextMark 		*mark_insert_start;
+	GtkTextMark		*mark_insert_end;
+	gboolean 		 deferred_check;
+
+	GtkTextTag 		*tag_highlight;
+	GtkTextMark		*mark_click;
+
+       	GeditSpellChecker	*spell_checker;
+};
+
+static GQuark automatic_spell_checker_id = 0;
+static GQuark suggestion_id = 0;
+
+static void gedit_automatic_spell_checker_free_internal (GeditAutomaticSpellChecker *spell);
+
+static void
+view_destroy (GeditView *view, GeditAutomaticSpellChecker *spell)
+{
+	gedit_automatic_spell_checker_detach_view (spell, view);
+}
+
+static void
+check_word (GeditAutomaticSpellChecker *spell, GtkTextIter *start, GtkTextIter *end) 
+{
+	gchar *word;
+
+	word = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (spell->doc), start, end, FALSE);
+
+	/*
+	g_print ("Check word: %s [%d - %d]\n", word, gtk_text_iter_get_offset (start),
+						gtk_text_iter_get_offset (end));
+	*/
+
+	if (!gedit_spell_checker_check_word (spell->spell_checker, word, -1)) 
+	{
+		/*
+		g_print ("Apply tag: [%d - %d]\n", gtk_text_iter_get_offset (start),
+						gtk_text_iter_get_offset (end));
+		*/
+		gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (spell->doc), 
+					   spell->tag_highlight, 
+					   start, 
+					   end);
+	}
+	
+	g_free (word);
+}
+
+static void
+check_range (GeditAutomaticSpellChecker *spell, 
+	     GtkTextIter                 start, 
+	     GtkTextIter                 end,
+	     gboolean                    force_all) 
+{
+	/* we need to "split" on word boundaries.
+	 * luckily, Pango knows what "words" are 
+	 * so we don't have to figure it out. */
+
+	GtkTextIter wstart;
+	GtkTextIter wend;
+	GtkTextIter cursor; 
+	GtkTextIter precursor;
+  	gboolean    highlight;
+
+	/*
+	g_print ("Check range: [%d - %d]\n", gtk_text_iter_get_offset (&start),
+						gtk_text_iter_get_offset (&end));
+	*/
+
+	if (gtk_text_iter_inside_word (&end))
+		gtk_text_iter_forward_word_end (&end);
+	
+	if (!gtk_text_iter_starts_word (&start)) 
+	{
+		if (gtk_text_iter_inside_word (&start) || 
+		    gtk_text_iter_ends_word (&start)) 
+		{
+			gtk_text_iter_backward_word_start (&start);
+		} 
+		else 
+		{
+			/* if we're neither at the beginning nor inside a word,
+			 * me must be in some spaces.
+			 * skip forward to the beginning of the next word. */
+			
+			if (gtk_text_iter_forward_word_end (&start))
+				gtk_text_iter_backward_word_start (&start);
+		}
+	}
+
+	gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (spell->doc), 
+					  &cursor,
+					  gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (spell->doc)));
+  	 
+	precursor = cursor;
+	gtk_text_iter_backward_char (&precursor);
+	
+  	highlight = gtk_text_iter_has_tag (&cursor, spell->tag_highlight) ||
+  	            gtk_text_iter_has_tag (&precursor, spell->tag_highlight);
+	
+	gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER (spell->doc), 
+				    spell->tag_highlight, 
+				    &start, 
+				    &end);
+
+	/* Fix a corner case when replacement occurs at beginning of buffer:
+	 * An iter at offset 0 seems to always be inside a word,
+  	 * even if it's not.  Possibly a pango bug.
+	 */
+  	if (gtk_text_iter_get_offset (&start) == 0) 
+	{
+		gtk_text_iter_forward_word_end(&start);
+		gtk_text_iter_backward_word_start(&start);
+	}
+
+	wstart = start;
+	
+	while (gedit_spell_utils_skip_no_spell_check (&wstart, &end) &&
+	       gtk_text_iter_compare (&wstart, &end) < 0) 
+	{
+		gboolean inword; 
+
+		/* move wend to the end of the current word. */
+		wend = wstart;
+		
+		gtk_text_iter_forward_word_end (&wend);
+
+		inword = (gtk_text_iter_compare (&wstart, &cursor) < 0) &&
+			 (gtk_text_iter_compare (&cursor, &wend) <= 0);
+  	 
+		if (inword && !force_all)
+		{
+			/* this word is being actively edited,
+			 * only check if it's already highligted,
+			 * otherwise defer this check until later. */
+			if (highlight)
+				check_word (spell, &wstart, &wend);
+			else
+				spell->deferred_check = TRUE;
+		} 
+		else 
+		{
+			check_word (spell, &wstart, &wend);
+			spell->deferred_check = FALSE;
+		}
+
+		/* now move wend to the beginning of the next word, */
+		gtk_text_iter_forward_word_end (&wend);
+		gtk_text_iter_backward_word_start (&wend);
+		
+		/* make sure we've actually advanced
+		 * (we don't advance in some corner cases), */
+		if (gtk_text_iter_equal (&wstart, &wend))
+			break; /* we're done in these cases.. */
+
+		/* and then pick this as the new next word beginning. */
+		wstart = wend;
+	}
+}
+
+static void
+check_deferred_range (GeditAutomaticSpellChecker *spell, 
+		      gboolean                    force_all) 
+{
+	GtkTextIter start, end;
+
+	gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (spell->doc), 
+					  &start, 
+					  spell->mark_insert_start);
+	gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (spell->doc),
+					  &end, 
+					  spell->mark_insert_end);
+
+	check_range (spell, start, end, force_all);
+}
+
+/* insertion works like this:
+ *  - before the text is inserted, we mark the position in the buffer.
+ *  - after the text is inserted, we see where our mark is and use that and
+ *    the current position to check the entire range of inserted text.
+ *
+ * this may be overkill for the common case (inserting one character). */
+
+static void
+insert_text_before (GtkTextBuffer *buffer, GtkTextIter *iter,
+		gchar *text, gint len, GeditAutomaticSpellChecker *spell) 
+{
+	gtk_text_buffer_move_mark (buffer, spell->mark_insert_start, iter);
+}
+
+static void
+insert_text_after (GtkTextBuffer *buffer, GtkTextIter *iter,
+                  gchar *text, gint len, GeditAutomaticSpellChecker *spell) 
+{
+	GtkTextIter start;
+
+	/* we need to check a range of text. */
+	gtk_text_buffer_get_iter_at_mark (buffer, &start, spell->mark_insert_start);
+	
+	check_range (spell, start, *iter, FALSE);
+
+	gtk_text_buffer_move_mark (buffer, spell->mark_insert_end, iter);
+}
+
+/* deleting is more simple:  we're given the range of deleted text.
+ * after deletion, the start and end iters should be at the same position
+ * (because all of the text between them was deleted!).
+ * this means we only really check the words immediately bounding the
+ * deletion.
+ */
+
+static void
+delete_range_after (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end, 
+		GeditAutomaticSpellChecker *spell) 
+{
+	check_range (spell, *start, *end, FALSE);
+}
+
+static void
+mark_set (GtkTextBuffer              *buffer, 
+	  GtkTextIter                *iter,
+	  GtkTextMark                *mark, 
+	  GeditAutomaticSpellChecker *spell) 
+{
+	/* if the cursor has moved and there is a deferred check so handle it now */
+	if ((mark == gtk_text_buffer_get_insert (buffer)) && spell->deferred_check)
+		check_deferred_range (spell, FALSE);
+}
+
+static void
+get_word_extents_from_mark (GtkTextBuffer *buffer, 
+			    GtkTextIter   *start, 
+			    GtkTextIter   *end,
+			    GtkTextMark   *mark)
+{
+	gtk_text_buffer_get_iter_at_mark(buffer, start, mark);
+	
+	if (!gtk_text_iter_starts_word (start)) 
+		gtk_text_iter_backward_word_start (start);
+	
+	*end = *start;
+	
+	if (gtk_text_iter_inside_word (end))
+		gtk_text_iter_forward_word_end (end);
+}
+
+static void
+remove_tag_to_word (GeditAutomaticSpellChecker *spell, const gchar *word)
+{
+	GtkTextIter iter;
+	GtkTextIter match_start, match_end;
+
+	gboolean found;
+
+	gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (spell->doc), &iter, 0);
+	
+	found = TRUE;
+
+	while (found)
+	{
+		found = gtk_text_iter_forward_search (&iter, 
+				word, 
+				GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY,
+				&match_start, 
+				&match_end,
+				NULL);	
+
+		if (found)
+		{
+			if (gtk_text_iter_starts_word (&match_start) &&
+			    gtk_text_iter_ends_word (&match_end))
+			{
+				gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER (spell->doc),
+						spell->tag_highlight,
+						&match_start, 
+						&match_end);
+			}
+
+			iter = match_end;
+		}
+	}
+}
+
+static void
+add_to_dictionary (GtkWidget *menuitem, GeditAutomaticSpellChecker *spell) 
+{
+	gchar *word;
+	
+	GtkTextIter start, end;
+	
+	get_word_extents_from_mark (GTK_TEXT_BUFFER (spell->doc), &start, &end, spell->mark_click);	
+
+	word = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (spell->doc), 
+					 &start, 
+					 &end, 
+					 FALSE);
+	
+	gedit_spell_checker_add_word_to_personal (spell->spell_checker, word, -1);
+
+	g_free (word);
+}
+
+static void
+ignore_all (GtkWidget *menuitem, GeditAutomaticSpellChecker *spell) 
+{
+	gchar *word;
+	
+	GtkTextIter start, end;
+	
+	get_word_extents_from_mark (GTK_TEXT_BUFFER (spell->doc), &start, &end, spell->mark_click);	
+
+	word = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (spell->doc), 
+					 &start, 
+					 &end, 
+					 FALSE);
+	
+	gedit_spell_checker_add_word_to_session (spell->spell_checker, word, -1);
+
+	g_free (word);
+}
+
+static void
+replace_word (GtkWidget *menuitem, GeditAutomaticSpellChecker *spell) 
+{
+	gchar *oldword;
+	const gchar *newword;
+	
+	GtkTextIter start, end;
+
+	get_word_extents_from_mark (GTK_TEXT_BUFFER (spell->doc), &start, &end, spell->mark_click);	
+
+	oldword = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (spell->doc), &start, &end, FALSE);
+	
+	newword =  g_object_get_qdata (G_OBJECT (menuitem), suggestion_id);
+	g_return_if_fail (newword != NULL);
+
+	gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (spell->doc));
+
+	gtk_text_buffer_delete (GTK_TEXT_BUFFER (spell->doc), &start, &end);
+	gtk_text_buffer_insert (GTK_TEXT_BUFFER (spell->doc), &start, newword, -1);
+
+	gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (spell->doc));
+
+	gedit_spell_checker_set_correction (spell->spell_checker, 
+				oldword, strlen (oldword),
+				newword, strlen (newword));
+
+	g_free (oldword);
+}
+
+static GtkWidget *
+build_suggestion_menu (GeditAutomaticSpellChecker *spell, const gchar *word) 
+{
+	GtkWidget *topmenu, *menu;
+	GtkWidget *mi;
+	GSList *suggestions;
+	GSList *list;
+	gchar *label_text;
+	
+	topmenu = menu = gtk_menu_new();
+
+	suggestions = gedit_spell_checker_get_suggestions (spell->spell_checker, word, -1);
+
+	list = suggestions;
+
+	if (suggestions == NULL) 
+	{		
+		/* no suggestions.  put something in the menu anyway... */
+		GtkWidget *label;
+		/* Translators: Displayed in the "Check Spelling" dialog if there are no suggestions for the current misspelled word */
+		label = gtk_label_new (_("(no suggested words)"));
+		
+		mi = gtk_menu_item_new ();
+		gtk_widget_set_sensitive (mi, FALSE);
+		gtk_container_add (GTK_CONTAINER(mi), label);
+		gtk_widget_show_all (mi);
+		gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi);
+	} 
+	else 
+	{
+		gint count = 0;
+		
+		/* build a set of menus with suggestions. */
+		while (suggestions != NULL) 
+		{
+			GtkWidget *label;
+
+			if (count == 10) 
+			{
+				/* Separator */
+				mi = gtk_menu_item_new ();
+				gtk_widget_show (mi);
+				gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+	
+				mi = gtk_menu_item_new_with_mnemonic (_("_More..."));
+				gtk_widget_show (mi);
+				gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+				menu = gtk_menu_new ();
+				gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), menu);
+				count = 0;
+			}
+			
+			label_text = g_strdup_printf ("<b>%s</b>", (gchar*) suggestions->data);
+			
+			label = gtk_label_new (label_text);
+			gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
+			gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+
+			mi = gtk_menu_item_new ();
+			gtk_container_add (GTK_CONTAINER(mi), label);
+			
+			gtk_widget_show_all (mi);
+			gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+			g_object_set_qdata_full (G_OBJECT (mi), 
+				 suggestion_id, 
+				 g_strdup (suggestions->data), 
+				 (GDestroyNotify)g_free);
+
+			g_free (label_text);
+			g_signal_connect (mi,
+					  "activate",
+					  G_CALLBACK (replace_word),
+					  spell);
+
+			count++;
+
+			suggestions = g_slist_next (suggestions);
+		}
+	}
+
+	/* free the suggestion list */
+	suggestions = list;
+
+	while (list)
+	{
+		g_free (list->data);
+		list = g_slist_next (list);
+	}
+
+	g_slist_free (suggestions);
+
+	/* Separator */
+	mi = gtk_menu_item_new ();
+	gtk_widget_show (mi);
+	gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi);
+
+	/* Ignore all */
+	mi = gtk_image_menu_item_new_with_mnemonic (_("_Ignore All"));
+	gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi),
+				       gtk_image_new_from_stock (GTK_STOCK_GOTO_BOTTOM, 
+					       			 GTK_ICON_SIZE_MENU));
+	
+	g_signal_connect (mi,
+			  "activate",
+			  G_CALLBACK(ignore_all),
+			  spell);
+
+	gtk_widget_show_all (mi);
+
+	gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi);
+
+	/* + Add to Dictionary */
+	mi = gtk_image_menu_item_new_with_mnemonic (_("_Add"));
+	gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi),
+				       gtk_image_new_from_stock (GTK_STOCK_ADD, 
+					       			 GTK_ICON_SIZE_MENU));
+
+	g_signal_connect (mi,
+			  "activate",
+			  G_CALLBACK (add_to_dictionary),
+			  spell);
+
+	gtk_widget_show_all (mi);
+	
+	gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi);
+
+	return topmenu;
+}
+
+static void
+populate_popup (GtkTextView *textview, GtkMenu *menu, GeditAutomaticSpellChecker *spell) 
+{
+	GtkWidget *img, *mi;
+	GtkTextIter start, end;
+	char *word;
+
+	/* we need to figure out if they picked a misspelled word. */
+	get_word_extents_from_mark (GTK_TEXT_BUFFER (spell->doc), &start, &end, spell->mark_click);	
+
+	/* if our highlight algorithm ever messes up, 
+	 * this isn't correct, either. */
+	if (!gtk_text_iter_has_tag (&start, spell->tag_highlight))
+		return; /* word wasn't misspelled. */
+
+	/* menu separator comes first. */
+	mi = gtk_menu_item_new ();
+	gtk_widget_show (mi);
+	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi);
+
+	/* then, on top of it, the suggestions menu. */
+	img = gtk_image_new_from_stock (GTK_STOCK_SPELL_CHECK, GTK_ICON_SIZE_MENU);
+	mi = gtk_image_menu_item_new_with_mnemonic (_("_Spelling Suggestions..."));
+	gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
+
+	word = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (spell->doc), &start, &end, FALSE);
+	gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi),
+				   build_suggestion_menu (spell, word));
+	g_free(word);
+
+	gtk_widget_show_all (mi);
+	gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi);
+}
+
+void
+gedit_automatic_spell_checker_recheck_all (GeditAutomaticSpellChecker *spell)
+{
+	GtkTextIter start, end;
+
+	g_return_if_fail (spell != NULL);
+
+	gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (spell->doc), &start, &end);
+
+	check_range (spell, start, end, TRUE);
+}
+
+static void 
+add_word_signal_cb (GeditSpellChecker          *checker, 
+		    const gchar                *word, 
+		    gint                        len,
+		    GeditAutomaticSpellChecker *spell)
+{
+	gchar *w;
+
+	if (len < 0)
+		w = g_strdup (word);
+	else
+		w = g_strndup (word, len);
+
+	remove_tag_to_word (spell, w);
+
+	g_free (w);
+}
+
+static void 
+set_language_cb (GeditSpellChecker               *checker,
+		 const GeditSpellCheckerLanguage *lang,
+		 GeditAutomaticSpellChecker      *spell)
+{
+	gedit_automatic_spell_checker_recheck_all (spell);
+}
+
+static void 
+clear_session_cb (GeditSpellChecker          *checker,
+		  GeditAutomaticSpellChecker *spell)
+{
+	gedit_automatic_spell_checker_recheck_all (spell);
+}
+
+/* When the user right-clicks on a word, they want to check that word.
+ * Here, we do NOT  move the cursor to the location of the clicked-upon word
+ * since that prevents the use of edit functions on the context menu. 
+ */
+static gboolean
+button_press_event (GtkTextView *view,
+		    GdkEventButton *event,
+		    GeditAutomaticSpellChecker *spell) 
+{
+	if (event->button == 3) 
+	{
+		gint x, y;
+		GtkTextIter iter;
+
+		GtkTextBuffer *buffer = gtk_text_view_get_buffer (view);
+
+		/* handle deferred check if it exists */
+  	        if (spell->deferred_check)
+			check_deferred_range (spell, TRUE);
+
+		gtk_text_view_window_to_buffer_coords (view, 
+				GTK_TEXT_WINDOW_TEXT, 
+				event->x, event->y,
+				&x, &y);
+		
+		gtk_text_view_get_iter_at_location (view, &iter, x, y);
+
+		gtk_text_buffer_move_mark (buffer, spell->mark_click, &iter);
+	}
+
+	return FALSE; /* false: let gtk process this event, too.
+			 we don't want to eat any events. */
+}
+
+/* Move the insert mark before popping up the menu, otherwise it
+ * will contain the wrong set of suggestions.
+ */
+static gboolean
+popup_menu_event (GtkTextView *view, GeditAutomaticSpellChecker *spell) 
+{
+	GtkTextIter iter;
+	GtkTextBuffer *buffer;
+
+	buffer = gtk_text_view_get_buffer (view);
+
+	/* handle deferred check if it exists */
+	if (spell->deferred_check)
+		check_deferred_range (spell, TRUE);
+
+	gtk_text_buffer_get_iter_at_mark (buffer, &iter,
+					  gtk_text_buffer_get_insert (buffer));
+	gtk_text_buffer_move_mark (buffer, spell->mark_click, &iter);
+
+	return FALSE;
+}
+
+static void
+tag_table_changed (GtkTextTagTable            *table,
+		   GeditAutomaticSpellChecker *spell)
+{
+	g_return_if_fail (spell->tag_highlight !=  NULL);
+
+	gtk_text_tag_set_priority (spell->tag_highlight,
+				   gtk_text_tag_table_get_size (table) - 1);
+}
+
+static void 
+tag_added_or_removed (GtkTextTagTable            *table,
+		      GtkTextTag                 *tag,
+		      GeditAutomaticSpellChecker *spell)
+{
+	tag_table_changed (table, spell);
+}
+
+static void 
+tag_changed (GtkTextTagTable            *table,
+	     GtkTextTag                 *tag,
+	     gboolean                    size_changed,
+	     GeditAutomaticSpellChecker *spell)
+{
+	tag_table_changed (table, spell);
+}
+
+static void
+highlight_updated (GtkSourceBuffer            *buffer,
+                   GtkTextIter                *start,
+                   GtkTextIter                *end,
+                   GeditAutomaticSpellChecker *spell)
+{
+	check_range (spell, *start, *end, FALSE);
+}
+
+static void
+spell_tag_destroyed (GeditAutomaticSpellChecker *spell,
+                     GObject                    *where_the_object_was)
+{
+	spell->tag_highlight = NULL;
+}
+
+GeditAutomaticSpellChecker *
+gedit_automatic_spell_checker_new (GeditDocument     *doc,
+				   GeditSpellChecker *checker)
+{
+	GeditAutomaticSpellChecker *spell;
+	GtkTextTagTable *tag_table;
+	GtkTextIter start, end;
+
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+	g_return_val_if_fail (GEDIT_IS_SPELL_CHECKER (checker), NULL);
+	g_return_val_if_fail ((spell = gedit_automatic_spell_checker_get_from_document (doc)) == NULL,
+			      spell);
+	
+	/* attach to the widget */
+	spell = g_new0 (GeditAutomaticSpellChecker, 1);
+
+	spell->doc = doc;
+	spell->spell_checker = g_object_ref (checker);
+
+	if (automatic_spell_checker_id == 0)
+	{
+		automatic_spell_checker_id = 
+			g_quark_from_string ("GeditAutomaticSpellCheckerID");
+	}
+	if (suggestion_id == 0)
+	{
+		suggestion_id = g_quark_from_string ("GeditAutoSuggestionID");
+	}
+
+	g_object_set_qdata_full (G_OBJECT (doc), 
+				 automatic_spell_checker_id, 
+				 spell, 
+				 (GDestroyNotify)gedit_automatic_spell_checker_free_internal);
+
+	g_signal_connect (doc,
+			  "insert-text",
+			  G_CALLBACK (insert_text_before), 
+			  spell);
+	g_signal_connect_after (doc,
+			  "insert-text",
+			  G_CALLBACK (insert_text_after), 
+			  spell);
+	g_signal_connect_after (doc,
+			  "delete-range",
+			  G_CALLBACK (delete_range_after), 
+			  spell);
+	g_signal_connect (doc,
+			  "mark-set",
+			  G_CALLBACK (mark_set), 
+			  spell);
+
+	g_signal_connect (doc,
+	                  "highlight-updated",
+	                  G_CALLBACK (highlight_updated),
+	                  spell);
+
+	g_signal_connect (spell->spell_checker,
+			  "add_word_to_session",
+			  G_CALLBACK (add_word_signal_cb),
+			  spell);
+	g_signal_connect (spell->spell_checker,
+			  "add_word_to_personal",
+			  G_CALLBACK (add_word_signal_cb),
+			  spell);
+	g_signal_connect (spell->spell_checker,
+			  "clear_session",
+			  G_CALLBACK (clear_session_cb),
+			  spell);
+	g_signal_connect (spell->spell_checker,
+			  "set_language",
+			  G_CALLBACK (set_language_cb),
+			  spell);
+
+	spell->tag_highlight = gtk_text_buffer_create_tag (
+				GTK_TEXT_BUFFER (doc),
+				"gtkspell-misspelled",
+				"underline", PANGO_UNDERLINE_ERROR,
+				NULL);
+
+	g_object_weak_ref (G_OBJECT (spell->tag_highlight),
+	                   (GWeakNotify)spell_tag_destroyed,
+	                   spell);
+
+	tag_table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (doc));
+
+	gtk_text_tag_set_priority (spell->tag_highlight, 
+				   gtk_text_tag_table_get_size (tag_table) - 1);
+
+	g_signal_connect (tag_table,
+			  "tag-added",
+			  G_CALLBACK (tag_added_or_removed),
+			  spell);
+	g_signal_connect (tag_table,
+			  "tag-removed",
+			  G_CALLBACK (tag_added_or_removed),
+			  spell);
+	g_signal_connect (tag_table,
+			  "tag-changed",
+			  G_CALLBACK (tag_changed),
+			  spell);
+
+	/* we create the mark here, but we don't use it until text is
+	 * inserted, so we don't really care where iter points.  */
+	gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc), &start, &end);
+	
+	spell->mark_insert_start = gtk_text_buffer_get_mark (GTK_TEXT_BUFFER (doc),
+					"gedit-automatic-spell-checker-insert-start");
+
+	if (spell->mark_insert_start == NULL)
+	{
+		spell->mark_insert_start = 
+			gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (doc),
+						     "gedit-automatic-spell-checker-insert-start",
+						     &start, 
+						     TRUE);
+	}
+	else
+	{
+		gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
+					   spell->mark_insert_start,
+					   &start);
+	}
+
+	spell->mark_insert_end = gtk_text_buffer_get_mark (GTK_TEXT_BUFFER (doc),
+					"gedit-automatic-spell-checker-insert-end");
+
+	if (spell->mark_insert_end == NULL)
+	{
+		spell->mark_insert_end = 
+			gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (doc),
+						     "gedit-automatic-spell-checker-insert-end",
+						     &start, 
+						     TRUE);
+	}
+	else
+	{
+		gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
+					   spell->mark_insert_end,
+					   &start);
+	}
+
+	spell->mark_click = gtk_text_buffer_get_mark (GTK_TEXT_BUFFER (doc),
+					"gedit-automatic-spell-checker-click");
+
+	if (spell->mark_click == NULL)
+	{
+		spell->mark_click = 
+			gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (doc),
+						     "gedit-automatic-spell-checker-click",
+						     &start, 
+						     TRUE);
+	}
+	else
+	{
+		gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
+					   spell->mark_click,
+					   &start);
+	}
+
+	spell->deferred_check = FALSE;
+
+	return spell;
+}
+
+GeditAutomaticSpellChecker *
+gedit_automatic_spell_checker_get_from_document (const GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+
+	if (automatic_spell_checker_id == 0)
+		return NULL;
+
+	return g_object_get_qdata (G_OBJECT (doc), automatic_spell_checker_id);
+}	
+
+void
+gedit_automatic_spell_checker_free (GeditAutomaticSpellChecker *spell)
+{
+	g_return_if_fail (spell != NULL);
+	g_return_if_fail (gedit_automatic_spell_checker_get_from_document (spell->doc) == spell);
+	
+	if (automatic_spell_checker_id == 0)
+		return;
+
+	g_object_set_qdata (G_OBJECT (spell->doc), automatic_spell_checker_id, NULL);	
+}
+
+static void
+gedit_automatic_spell_checker_free_internal (GeditAutomaticSpellChecker *spell)
+{
+	GtkTextTagTable *table;
+	GtkTextIter start, end;
+	GSList *list;
+	
+	g_return_if_fail (spell != NULL);
+
+	table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (spell->doc));
+
+	if (table != NULL && spell->tag_highlight != NULL)
+	{
+		gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (spell->doc), 
+					    &start, 
+					    &end);
+		gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER (spell->doc), 
+					    spell->tag_highlight, 
+					    &start, 
+					    &end);
+
+		g_signal_handlers_disconnect_matched (G_OBJECT (table),
+					G_SIGNAL_MATCH_DATA,
+					0, 0, NULL, NULL,
+					spell);
+
+		gtk_text_tag_table_remove (table, spell->tag_highlight);
+	}
+		
+	g_signal_handlers_disconnect_matched (G_OBJECT (spell->doc),
+			G_SIGNAL_MATCH_DATA,
+			0, 0, NULL, NULL,
+			spell);
+
+	g_signal_handlers_disconnect_matched (G_OBJECT (spell->spell_checker),
+			G_SIGNAL_MATCH_DATA,
+			0, 0, NULL, NULL,
+			spell);
+
+	g_object_unref (spell->spell_checker);
+
+	list = spell->views;
+	while (list != NULL)
+	{
+		GeditView *view = GEDIT_VIEW (list->data);
+		
+		g_signal_handlers_disconnect_matched (G_OBJECT (view),
+				G_SIGNAL_MATCH_DATA,
+				0, 0, NULL, NULL,
+				spell);
+
+		g_signal_handlers_disconnect_matched (G_OBJECT (view),
+			G_SIGNAL_MATCH_DATA,
+			0, 0, NULL, NULL,
+			spell);
+
+		list = g_slist_next (list);
+	}
+
+	g_slist_free (spell->views);
+	
+	g_free (spell);
+}
+
+void
+gedit_automatic_spell_checker_attach_view (
+		GeditAutomaticSpellChecker *spell, 
+		GeditView *view)
+{
+	g_return_if_fail (spell != NULL);
+	g_return_if_fail (GEDIT_IS_VIEW (view));
+
+	g_return_if_fail (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)) ==
+			  GTK_TEXT_BUFFER (spell->doc));
+
+	g_signal_connect (view,
+			  "button-press-event",
+			  G_CALLBACK (button_press_event), 
+			  spell);
+	g_signal_connect (view,
+			  "popup-menu",
+			  G_CALLBACK (popup_menu_event), 
+			  spell);
+	g_signal_connect (view,
+			  "populate-popup",
+			  G_CALLBACK (populate_popup), 
+			  spell);
+	g_signal_connect (view,
+			  "destroy",
+			  G_CALLBACK (view_destroy), 
+			  spell);
+
+	spell->views = g_slist_prepend (spell->views, view);
+}
+
+void 
+gedit_automatic_spell_checker_detach_view (
+		GeditAutomaticSpellChecker *spell,
+		GeditView *view)
+{
+	g_return_if_fail (spell != NULL);
+	g_return_if_fail (GEDIT_IS_VIEW (view));
+
+	g_return_if_fail (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)) ==
+			  GTK_TEXT_BUFFER (spell->doc));
+	g_return_if_fail (spell->views != NULL);
+
+	g_signal_handlers_disconnect_matched (G_OBJECT (view),
+			G_SIGNAL_MATCH_DATA,
+			0, 0, NULL, NULL,
+			spell);
+
+	g_signal_handlers_disconnect_matched (G_OBJECT (view),
+			G_SIGNAL_MATCH_DATA,
+			0, 0, NULL, NULL,
+			spell);
+
+	spell->views = g_slist_remove (spell->views, view);
+}
+