update to reflect text widget changes.

2000-07-25  Havoc Pennington  <hp@redhat.com>

* gtk/testtext.c, gtk/testtextbuffer.c: update to reflect text
widget changes.

* gtk/gtktextview.h: To be consistent with usage of "line"
throughout the API to mean "newline-terminated thingy", change
MOVEMENT_LINE to be MOVEMENT_WRAPPED_LINE, and MOVEMENT_PARAGRAPH
to MOVEMENT_LINE.

(GtkTextView): Add flags for default editability, and whether to
show the cursor. Add functions to get/set that. Add

(gtk_text_view_get_iter_location): new function

* gtk/gtktexttypes.h: Move GtkTextLine typedef from here to
gtktextlayout.h
(g_convert): Add g_convert temporarily, will go in glib in a bit

* gtk/gtktexttagtable.h: include gtktexttag.h, and define
GtkTextTagTableForeach instead of brokenly using GHFunc.
Change gtk_text_tag_table_foreach() so it doesn't use GHFunc.

* gtk/gtktexttagprivate.h: Remove GtkTextStyleValues from here,
moved to public header.

* gtk/gtktexttag.h: Rename the "elide" attribute of tags to
"invisible", since "elide" was a bad name.
(gtk_text_tag_get_priority): Added

(GtkTextStyleValues): put this in public header, along with
functions to use it.

* gtk/gtktextmarkprivate.h: Include more headers, since we no
longer include gtktextbtree.h.

* gtk/gtktextmark.h: Add gtk_text_mark_ref, gtk_text_mark_unref,
gtk_text_mark_deleted

* gtk/gtktextlayout.h: Don't include the "really private" headers,
only buffer/iter. Forward declare GtkTextLIne and GtkTextLineData
to make this possible. Now we only need to install
gtktextlayout.h, not gtktextbtree.h and gtktext*private.h.
(However the Makefile.am isn't changed yet because of the
logistics of merging gtk-hp-patches piecemeal)

* gtk/gtktextiterprivate.h: include btree header, so it compiles;
rename gtk_text_iter_get_line to gtk_text_iter_get_text_line since
gtk_text_iter_get_line is now used in the public API for a
different purpose.

* gtk/gtktextiter.h: Clean up function names to be more
consistent. Always call char offset "offset" and byte index
"index". A "line" is always a line number.

(gtk_text_iter_is_last): new function, more efficient than
the existing way to check
(gtk_text_iter_is_first): new function, also more efficient

(gtk_text_iter_up_lines, gtk_text_iter_down_lines): Remove these

(gtk_text_iter_next_char, gtk_text_iter_prev_char): Renamed from
gtk_text_iter_forward_char, etc.

(gtk_text_iter_forward_to_tag_toggle): Renamed from
forward_find_tag_toggle, since this isn't a linear search

(GtkTextCharPredicate): rename from GtkTextViewCharPredicate

(gtk_text_iter_forward_search, gtk_text_iter_backward_search):
New functions, search for a buffer substring.

* gtk/gtktextbuffer.h: Add fields to store whether a paste is
interactive and default editable (since we need to store that info
until we receive the selection data).

Remove all the _at_char and at_line etc. versions of functions;
only have iterator versions.

Add _interactive() versions of functions, that consider the
editability of text. (FIXME add interactive flag to the
insert/delete signals per Darin's suggestion)

(gtk_text_buffer_get_tag_table): new function, demand-creates the
tag table if necessary

Remove declaration of gtk_text_buffer_get_iter_from_string

(_gtk_text_buffer_get_btree): private/internal function, added.


* gtk/gtktextbtree.h: Remove forward decl of GtkTextLineData.
(gtk_text_line_is_last): new function

2 files changed, 413 insertions, 213 deletions

diff --git a/tests/testtext.c b/tests/testtext.c
index fad48f0399..bbff4d00ae 100644
--- a/tests/testtext.c
+++ b/tests/testtext.c
@@ -20,6 +20,8 @@ struct _Buffer
   GtkTextBuffer *buffer;
   char *filename;
   gint untitled_serial;
+  GtkTextTag *not_editable_tag;
+  GtkTextTag *found_text_tag;
 };
 
 struct _View
@@ -41,6 +43,9 @@ static gboolean save_buffer        (Buffer *buffer);
 static gboolean save_as_buffer     (Buffer *buffer);
 static char *   buffer_pretty_name (Buffer *buffer);
 static void     buffer_filename_set (Buffer *buffer);
+static void     buffer_search_forward (Buffer *buffer,
+                                       const char *str,
+                                       View *view);
 
 static View *view_from_widget (GtkWidget *widget);
 
@@ -290,14 +295,14 @@ msgbox_run (GtkWindow  *parent,
  * Example buffer filling code
  */
 static gint
-blink_timeout(gpointer data)
+blink_timeout (gpointer data)
 {
   GtkTextTag *tag;
   static gboolean flip = FALSE;
   
-  tag = GTK_TEXT_TAG(data);
+  tag = GTK_TEXT_TAG (data);
 
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
                  "foreground", flip ? "blue" : "purple",
                  NULL);
 
@@ -307,42 +312,46 @@ blink_timeout(gpointer data)
 }
 
 static gint
-tag_event_handler(GtkTextTag *tag, GtkWidget *widget, GdkEvent *event,
+tag_event_handler (GtkTextTag *tag, GtkWidget *widget, GdkEvent *event,
                   const GtkTextIter *iter, gpointer user_data)
 {
   gint char_index;
 
-  char_index = gtk_text_iter_get_char_index(iter);
+  char_index = gtk_text_iter_get_offset (iter);
   
   switch (event->type)
     {
     case GDK_MOTION_NOTIFY:
-      printf("Motion event at char %d tag `%s'\n",
+      printf ("Motion event at char %d tag `%s'\n",
              char_index, tag->name);
       break;
         
     case GDK_BUTTON_PRESS:
-      printf("Button press at char %d tag `%s'\n",
+      printf ("Button press at char %d tag `%s'\n",
              char_index, tag->name);
       break;
         
     case GDK_2BUTTON_PRESS:
-      printf("Double click at char %d tag `%s'\n",
+      printf ("Double click at char %d tag `%s'\n",
              char_index, tag->name);
       break;
         
     case GDK_3BUTTON_PRESS:
-      printf("Triple click at char %d tag `%s'\n",
+      printf ("Triple click at char %d tag `%s'\n",
              char_index, tag->name);
       break;
         
     case GDK_BUTTON_RELEASE:
-      printf("Button release at char %d tag `%s'\n",
+      printf ("Button release at char %d tag `%s'\n",
              char_index, tag->name);
       break;
         
     case GDK_KEY_PRESS:
     case GDK_KEY_RELEASE:
+      printf ("Key event at char %d tag `%s'\n",
+              char_index, tag->name);
+      break;
+      
     case GDK_ENTER_NOTIFY:
     case GDK_LEAVE_NOTIFY:
     case GDK_PROPERTY_NOTIFY:
@@ -365,12 +374,12 @@ tag_event_handler(GtkTextTag *tag, GtkWidget *widget, GdkEvent *event,
 }
 
 static void
-setup_tag(GtkTextTag *tag)
+setup_tag (GtkTextTag *tag)
 {
 
-  gtk_signal_connect(GTK_OBJECT(tag),
+  gtk_signal_connect (GTK_OBJECT (tag),
                      "event",
-                     GTK_SIGNAL_FUNC(tag_event_handler),
+                     GTK_SIGNAL_FUNC (tag_event_handler),
                      NULL);
 }
 
@@ -413,77 +422,77 @@ fill_example_buffer (GtkTextBuffer *buffer)
   int i;
   char *str;
   
-  tag = gtk_text_buffer_create_tag(buffer, "fg_blue");
+  tag = gtk_text_buffer_create_tag (buffer, "fg_blue");
 
-  /*       gtk_timeout_add(1000, blink_timeout, tag); */
+  /*       gtk_timeout_add (1000, blink_timeout, tag); */
       
-  setup_tag(tag);
+  setup_tag (tag);
   
   color.red = color.green = 0;
   color.blue = 0xffff;
   color2.red = 0xfff;
   color2.blue = 0x0;
   color2.green = 0;
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
 		 "foreground_gdk", &color,
 		 "background_gdk", &color2,
 		 "font", "Sans 24",
 		 NULL);
 
-  tag = gtk_text_buffer_create_tag(buffer, "fg_red");
+  tag = gtk_text_buffer_create_tag (buffer, "fg_red");
 
-  setup_tag(tag);
+  setup_tag (tag);
       
   color.blue = color.green = 0;
   color.red = 0xffff;
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
 		 "offset", -4,
 		 "foreground_gdk", &color,
 		 NULL);
 
-  tag = gtk_text_buffer_create_tag(buffer, "bg_green");
+  tag = gtk_text_buffer_create_tag (buffer, "bg_green");
 
-  setup_tag(tag);
+  setup_tag (tag);
       
   color.blue = color.red = 0;
   color.green = 0xffff;
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
 		 "background_gdk", &color,
 		 "font", "Sans 10",
 		 NULL);
 
-  tag = gtk_text_buffer_create_tag(buffer, "overstrike");
+  tag = gtk_text_buffer_create_tag (buffer, "overstrike");
 
-  setup_tag(tag);
+  setup_tag (tag);
       
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
 		 "overstrike", TRUE,
 		 NULL);
 
 
-  tag = gtk_text_buffer_create_tag(buffer, "underline");
+  tag = gtk_text_buffer_create_tag (buffer, "underline");
 
-  setup_tag(tag);
+  setup_tag (tag);
       
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
 		 "underline", PANGO_UNDERLINE_SINGLE,
 		 NULL);
 
-  setup_tag(tag);
+  setup_tag (tag);
       
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
 		 "underline", PANGO_UNDERLINE_SINGLE,
 		 NULL);
 
-  tag = gtk_text_buffer_create_tag(buffer, "centered");
+  tag = gtk_text_buffer_create_tag (buffer, "centered");
       
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
 		 "justify", GTK_JUSTIFY_CENTER,
 		 NULL);
 
-  tag = gtk_text_buffer_create_tag(buffer, "rtl_quote");
+  tag = gtk_text_buffer_create_tag (buffer, "rtl_quote");
       
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
 		 "wrap_mode", GTK_WRAPMODE_WORD,
 		 "direction", GTK_TEXT_DIR_RTL,
 		 "left_wrapped_line_margin", 20,
@@ -492,31 +501,31 @@ fill_example_buffer (GtkTextBuffer *buffer)
 		 NULL);
   
   pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
-						  gtk_widget_get_default_colormap(),
+						  gtk_widget_get_default_colormap (),
 						  &mask,
 						  NULL, book_closed_xpm);
   
-  g_assert(pixmap != NULL);
+  g_assert (pixmap != NULL);
   
   i = 0;
   while (i < 100)
     {
       GtkTextMark * temp_mark;
       
-      gtk_text_buffer_get_iter_at_char(buffer, &iter, 0);
+      gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
           
       gtk_text_buffer_insert_pixmap (buffer, &iter, pixmap, mask);
           
-      str = g_strdup_printf("%d Hello World! blah blah blah blah blah blah blah blah blah blah blah blah\nwoo woo woo woo woo woo woo woo woo woo woo woo woo woo woo\n",
+      str = g_strdup_printf ("%d Hello World! blah blah blah blah blah blah blah blah blah blah blah blah\nwoo woo woo woo woo woo woo woo woo woo woo woo woo woo woo\n",
 			    i);
       
-      gtk_text_buffer_insert(buffer, &iter, str, -1);
+      gtk_text_buffer_insert (buffer, &iter, str, -1);
 
-      g_free(str);
+      g_free (str);
       
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter, 0, 5);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 5);
           
-      gtk_text_buffer_insert(buffer, &iter,
+      gtk_text_buffer_insert (buffer, &iter,
 			     "(Hello World!)\nfoo foo Hello this is some text we are using to text word wrap. It has punctuation! gee; blah - hmm, great.\nnew line with a significant quantity of text on it. This line really does contain some text. More text! More text! More text!\n"
 			     /* This is UTF8 stuff, Emacs doesn't
 				really know how to display it */
@@ -526,59 +535,59 @@ fill_example_buffer (GtkTextBuffer *buffer)
         gtk_text_buffer_create_mark (buffer, "tmp_mark", &iter, TRUE);
 
 #if 1
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter, 0, 6);
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter2, 0, 13);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 6);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 0, 13);
 
-      gtk_text_buffer_apply_tag(buffer, "fg_blue", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
 
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter, 1, 10);
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter2, 1, 16);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 1, 10);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 1, 16);
 
-      gtk_text_buffer_apply_tag(buffer, "underline", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "underline", &iter, &iter2);
 
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter, 1, 14);
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter2, 1, 24);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 1, 14);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 1, 24);
 
-      gtk_text_buffer_apply_tag(buffer, "overstrike", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "overstrike", &iter, &iter2);
           
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter, 0, 9);
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter2, 0, 16);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 9);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 0, 16);
 
-      gtk_text_buffer_apply_tag(buffer, "bg_green", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);
   
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter, 4, 2);
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter2, 4, 10);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 4, 2);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 4, 10);
 
-      gtk_text_buffer_apply_tag(buffer, "bg_green", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);
 
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter, 4, 8);
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter2, 4, 15);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 4, 8);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter2, 4, 15);
 
-      gtk_text_buffer_apply_tag(buffer, "fg_red", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
 #endif
 
       gtk_text_buffer_get_iter_at_mark (buffer, &iter, temp_mark);
       gtk_text_buffer_insert (buffer, &iter, "Centered text!\n", -1);
 	  
       gtk_text_buffer_get_iter_at_mark (buffer, &iter2, temp_mark);
-      gtk_text_buffer_apply_tag (buffer, "centered", &iter2, &iter);
+      gtk_text_buffer_apply_tag_by_name (buffer, "centered", &iter2, &iter);
 
       gtk_text_buffer_move_mark (buffer, temp_mark, &iter);
       gtk_text_buffer_insert (buffer, &iter, "Word wrapped, Right-to-left Quote\n", -1);
       gtk_text_buffer_insert (buffer, &iter, "وقد بدأ ثلاث من أكثر المؤسسات تقدما في شبكة اكسيون برامجها كمنظمات لا تسعى للربح، ثم تحولت في السنوات الخمس الماضية إلى مؤسسات مالية منظمة، وباتت جزءا من النظام المالي في بلدانها، ولكنها تتخصص في خدمة قطاع المشروعات الصغيرة. وأحد أكثر هذه المؤسسات نجاحا هو »بانكوسول« في بوليفيا.\n", -1);
       gtk_text_buffer_get_iter_at_mark (buffer, &iter2, temp_mark);
-      gtk_text_buffer_apply_tag (buffer, "rtl_quote", &iter2, &iter);
+      gtk_text_buffer_apply_tag_by_name (buffer, "rtl_quote", &iter2, &iter);
 	  
       ++i;
     }
 
-  gdk_pixmap_unref(pixmap);
+  gdk_pixmap_unref (pixmap);
   if (mask)
-    gdk_bitmap_unref(mask);
+    gdk_bitmap_unref (mask);
   
-  printf("%d lines %d chars\n",
-	 gtk_text_buffer_get_line_count(buffer),
-	 gtk_text_buffer_get_char_count(buffer));
+  printf ("%d lines %d chars\n",
+	 gtk_text_buffer_get_line_count (buffer),
+	 gtk_text_buffer_get_char_count (buffer));
 
   gtk_text_buffer_set_modified (buffer, FALSE);
 }
@@ -591,7 +600,7 @@ fill_file_buffer (GtkTextBuffer *buffer, const char *filename)
   gint remaining = 0;
   GtkTextIter iter, end;
 
-  f = fopen(filename, "r");
+  f = fopen (filename, "r");
   
   if (f == NULL)
     {
@@ -602,7 +611,7 @@ fill_file_buffer (GtkTextBuffer *buffer, const char *filename)
       return FALSE;
     }
   
-  gtk_text_buffer_get_iter_at_char(buffer, &iter, 0);
+  gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
   while (!feof (f))
     {
       gint count;
@@ -650,7 +659,7 @@ fill_file_buffer (GtkTextBuffer *buffer, const char *filename)
 }
 
 static gint
-delete_event_cb(GtkWidget *window, GdkEventAny *event, gpointer data)
+delete_event_cb (GtkWidget *window, GdkEventAny *event, gpointer data)
 {
   View *view = view_from_widget (window);
 
@@ -801,7 +810,7 @@ do_exit    (gpointer             callback_data,
       tmp_list = tmp_list->next;
     }
 
-  gtk_main_quit();
+  gtk_main_quit ();
   pop_active_window ();
 }
 
@@ -840,6 +849,118 @@ do_direction_changed (gpointer             callback_data,
 }
 
 static void
+do_editable_changed (gpointer callback_data,
+                     guint callback_action,
+                     GtkWidget *widget)
+{
+  View *view = view_from_widget (widget);
+
+  gtk_text_view_set_editable (GTK_TEXT_VIEW (view->text_view), callback_action);
+}
+
+static void
+do_cursor_visible_changed (gpointer callback_data,
+                           guint callback_action,
+                           GtkWidget *widget)
+{
+  View *view = view_from_widget (widget);
+
+  gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view->text_view), callback_action);
+}
+
+static void
+do_apply_editable (gpointer callback_data,
+                   guint callback_action,
+                   GtkWidget *widget)
+{
+  View *view = view_from_widget (widget);
+  GtkTextIter start;
+  GtkTextIter end;
+  
+  if (gtk_text_buffer_get_selection_bounds (view->buffer->buffer,
+                                            &start, &end))
+    {
+      if (callback_action)
+        {
+          gtk_text_buffer_remove_tag (view->buffer->buffer,
+                                      view->buffer->not_editable_tag,
+                                      &start, &end);
+        }
+      else
+        {
+          gtk_text_buffer_apply_tag (view->buffer->buffer,
+                                     view->buffer->not_editable_tag,
+                                     &start, &end);
+        }
+    }
+}
+
+static void
+dialog_response_callback (GtkWidget *dialog, gint response_id, gpointer data)
+{
+  GtkTextBuffer *buffer;
+  View *view = data;
+  GtkTextIter start, end;
+  gchar *search_string;
+  
+  buffer = gtk_object_get_data (GTK_OBJECT (dialog), "buffer");
+
+  gtk_text_buffer_get_bounds (buffer, &start, &end);
+
+  /* Remove trailing newline */
+  gtk_text_iter_prev_char (&end);
+  
+  search_string = gtk_text_iter_get_text (&start, &end);
+
+  printf ("Searching for `%s'\n", search_string);
+  
+  buffer_search_forward (view->buffer, search_string, view);
+
+  g_free (search_string);
+  
+  gtk_widget_destroy (dialog);
+}
+
+static void
+do_search (gpointer callback_data,
+           guint callback_action,
+           GtkWidget *widget)
+{
+  View *view = view_from_widget (widget);
+  GtkWidget *dialog;
+  GtkWidget *search_text;
+  GtkTextBuffer *buffer;
+  
+  dialog = gtk_dialog_new_with_buttons ("Search",
+                                        GTK_WINDOW (view->window),
+                                        GTK_DIALOG_DESTROY_WITH_PARENT,
+                                        GTK_STOCK_BUTTON_CLOSE,
+                                        GTK_RESPONSE_NONE, NULL);
+
+  buffer = gtk_text_buffer_new (NULL);
+
+  /* FIXME memory leak once buffer is a GObject */
+  search_text = gtk_text_view_new_with_buffer (buffer);
+
+  gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->vbox),
+                    search_text,
+                    TRUE, TRUE, 0);
+
+  gtk_object_set_data (GTK_OBJECT (dialog), "buffer", buffer);
+  
+  gtk_signal_connect (GTK_OBJECT (dialog),
+                      "response",
+                      GTK_SIGNAL_FUNC (dialog_response_callback),
+                      view);
+
+  gtk_widget_show (search_text);
+
+  gtk_widget_grab_focus (search_text);
+  
+  gtk_widget_show_all (dialog);
+}
+
+static void
 view_init_menus (View *view)
 {
   GtkTextDirection direction = gtk_widget_get_direction (view->text_view);
@@ -889,13 +1010,26 @@ static GtkItemFactoryEntry menu_items[] =
   { "/File/_Close",     "<control>W" , do_close,    0, NULL },
   { "/File/E_xit",      "<control>Q" , do_exit,     0, NULL },
 
+  { "/_Edit", NULL, 0, 0, "<Branch>" },
+  { "/Edit/Find...", NULL, do_search, 0, NULL },
+
   { "/_Settings",   	  NULL,         0,                0, "<Branch>" },
   { "/Settings/Wrap _Off",   NULL,      do_wrap_changed,  GTK_WRAPMODE_NONE, "<RadioItem>" },
   { "/Settings/Wrap _Words", NULL,      do_wrap_changed,  GTK_WRAPMODE_WORD, "/Settings/Wrap Off" },
   { "/Settings/sep1",        NULL,      0,                0, "<Separator>" },
+  { "/Settings/Editable", NULL,      do_editable_changed,  TRUE, "<RadioItem>" },
+  { "/Settings/Not editable",    NULL,      do_editable_changed,  FALSE, "/Settings/Editable" },
+  { "/Settings/sep1",        NULL,      0,                0, "<Separator>" },
+
+  { "/Settings/Cursor visible",    NULL,      do_cursor_visible_changed,  TRUE, "<RadioItem>" },
+  { "/Settings/Cursor not visible", NULL,      do_cursor_visible_changed,  FALSE, "/Settings/Cursor visible" },
+  { "/Settings/sep1",        NULL,      0,                0, "<Separator>" },
+  
   { "/Settings/Left-to-Right", NULL,    do_direction_changed,  GTK_TEXT_DIR_LTR, "<RadioItem>" },
   { "/Settings/Right-to-Left", NULL,    do_direction_changed,  GTK_TEXT_DIR_RTL, "/Settings/Left-to-Right" },
-  
+  { "/_Attributes",   	  NULL,         0,                0, "<Branch>" },
+  { "/Attributes/Editable",   	  NULL,         do_apply_editable, TRUE, NULL },
+  { "/Attributes/Not editable",   	  NULL,         do_apply_editable, FALSE, NULL },
   { "/_Test",   	 NULL,         0,           0, "<Branch>" },
   { "/Test/_Example",  	 NULL,         do_example,  0, NULL },
 };
@@ -938,7 +1072,7 @@ save_buffer (Buffer *buffer)
     }
   else
     {
-      gtk_text_buffer_get_iter_at_char (buffer->buffer, &start, 0);
+      gtk_text_buffer_get_iter_at_offset (buffer->buffer, &start, 0);
       gtk_text_buffer_get_last_iter (buffer->buffer, &end);
   
       chars = gtk_text_buffer_get_slice (buffer->buffer, &start, &end, FALSE);
@@ -988,7 +1122,7 @@ save_as_ok_func (const char *filename, gpointer data)
     {
       struct stat statbuf;
 
-      if (stat(filename, &statbuf) == 0)
+      if (stat (filename, &statbuf) == 0)
 	{
 	  gchar *err = g_strdup_printf ("Ovewrite existing file '%s'?", filename);
 	  gint result = msgbox_run (NULL, err, "Yes", "No", NULL, 1);
@@ -1061,6 +1195,15 @@ create_buffer (void)
   buffer->filename = NULL;
   buffer->untitled_serial = -1;
 
+  buffer->not_editable_tag = gtk_text_buffer_create_tag (buffer->buffer, NULL);
+  gtk_object_set (GTK_OBJECT (buffer->not_editable_tag),
+                  "editable", FALSE,
+                  "foreground", "purple", NULL);
+
+  buffer->found_text_tag = gtk_text_buffer_create_tag (buffer->buffer, NULL);
+  gtk_object_set (GTK_OBJECT (buffer->found_text_tag),
+                  "foreground", "red", NULL);
+  
   buffers = g_slist_prepend (buffers, buffer);
   
   return buffer;
@@ -1108,6 +1251,60 @@ buffer_filename_set (Buffer *buffer)
 }
 
 static void
+buffer_search_forward (Buffer *buffer, const char *str,
+                       View *view)
+{
+  GtkTextIter iter;
+  GtkTextIter start, end;
+  gint char_len;
+  int i = 0;
+  GtkWidget *dialog;
+  
+  /* remove tag from whole buffer */
+  gtk_text_buffer_get_bounds (buffer->buffer, &start, &end);
+  gtk_text_buffer_remove_tag (buffer->buffer,  buffer->found_text_tag,
+                              &start, &end );
+  
+  gtk_text_buffer_get_iter_at_mark (buffer->buffer, &iter,
+                                    gtk_text_buffer_get_mark (buffer->buffer,
+                                                              "insert"));
+
+
+  char_len = g_utf8_strlen (str, -1);
+
+  if (char_len > 0)
+    {
+      while (gtk_text_iter_forward_search (&iter, str, TRUE, FALSE))
+        {
+          GtkTextIter end = iter;
+          
+          gtk_text_iter_forward_chars (&end, char_len);
+          
+          gtk_text_buffer_apply_tag (buffer->buffer, buffer->found_text_tag,
+                                     &iter, &end);
+
+          iter = end;
+          
+          ++i;
+        }
+    }
+  
+  dialog = gtk_message_dialog_new (GTK_WINDOW (view->window),
+                                   GTK_MESSAGE_INFO,
+                                   GTK_BUTTONS_OK,
+                                   GTK_DIALOG_DESTROY_WITH_PARENT,
+                                   "%d strings found and marked in red",
+                                   i);
+
+  gtk_signal_connect_object (GTK_OBJECT (dialog),
+                             "response",
+                             GTK_SIGNAL_FUNC (gtk_widget_destroy),
+                             GTK_OBJECT (dialog));
+  
+  gtk_widget_show (dialog);
+}
+
+static void
 buffer_ref (Buffer *buffer)
 {
   buffer->refcount++;
@@ -1137,7 +1334,7 @@ close_view (View *view)
   g_free (view);
   
   if (!views)
-    gtk_main_quit();
+    gtk_main_quit ();
 }
 
 static void
@@ -1178,7 +1375,7 @@ create_view (Buffer *buffer)
   gtk_object_set_data (GTK_OBJECT (view->window), "view", view);
   
   gtk_signal_connect (GTK_OBJECT (view->window), "delete_event",
-		      GTK_SIGNAL_FUNC(delete_event_cb), NULL);
+		      GTK_SIGNAL_FUNC (delete_event_cb), NULL);
 
   view->accel_group = gtk_accel_group_new ();
   view->item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", view->accel_group);
@@ -1195,8 +1392,8 @@ create_view (Buffer *buffer)
 		      gtk_item_factory_get_widget (view->item_factory, "<main>"),
 		      FALSE, FALSE, 0);
   
-  sw = gtk_scrolled_window_new(NULL, NULL);
-  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
+  sw = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                  GTK_POLICY_AUTOMATIC,
                                  GTK_POLICY_AUTOMATIC);
 
@@ -1204,11 +1401,11 @@ create_view (Buffer *buffer)
   gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view->text_view), GTK_WRAPMODE_WORD);
 
   gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
-  gtk_container_add(GTK_CONTAINER(sw), view->text_view);
+  gtk_container_add (GTK_CONTAINER (sw), view->text_view);
 
   gtk_window_set_default_size (GTK_WINDOW (view->window), 500, 500);
 
-  gtk_widget_grab_focus(view->text_view);
+  gtk_widget_grab_focus (view->text_view);
 
   view_set_title (view);
   view_init_menus (view);
@@ -1218,14 +1415,15 @@ create_view (Buffer *buffer)
 }
 
 int
-main(int argc, char** argv)
+main (int argc, char** argv)
 {
   Buffer *buffer;
   View *view;
   int i;
   
-  gtk_init(&argc, &argv);
-
+  gtk_init (&argc, &argv);
+  gdk_rgb_init (); /* FIXME remove this */
+  
   buffer = create_buffer ();
   view = create_view (buffer);
   buffer_unref (buffer);
@@ -1254,7 +1452,7 @@ main(int argc, char** argv)
     }
   pop_active_window ();
   
-  gtk_main();
+  gtk_main ();
 
   return 0;
 }
diff --git a/tests/testtextbuffer.c b/tests/testtextbuffer.c
index 884ed0f887..8047dc62df 100644
--- a/tests/testtextbuffer.c
+++ b/tests/testtextbuffer.c
@@ -5,72 +5,72 @@
 #include <gtk/gtk.h>
 #include "gtktextbtree.h"
 
-static void fill_buffer(GtkTextBuffer *buffer);
+static void fill_buffer (GtkTextBuffer *buffer);
 
-static void run_tests(GtkTextBuffer *buffer);
+static void run_tests (GtkTextBuffer *buffer);
 
 int
-main(int argc, char** argv)
+main (int argc, char** argv)
 {
   GtkTextBuffer *buffer;
   int n;
   gunichar ch;
   GtkTextIter start, end;
   
-  gtk_init(&argc, &argv);
+  gtk_init (&argc, &argv);
 
   /* Check UTF8 unknown char thing */
-  g_assert(g_utf8_strlen (gtk_text_unknown_char_utf8, 3) == 1);
+  g_assert (g_utf8_strlen (gtk_text_unknown_char_utf8, 3) == 1);
   ch = g_utf8_get_char (gtk_text_unknown_char_utf8);
-  g_assert(ch == gtk_text_unknown_char);
+  g_assert (ch == gtk_text_unknown_char);
   
   /* First, we turn on btree debugging. */
   gtk_debug_flags |= GTK_DEBUG_TEXT;
 
   /* Create a buffer */
-  buffer = gtk_text_buffer_new(NULL);
+  buffer = gtk_text_buffer_new (NULL);
 
   /* Check that buffer starts with one empty line and zero chars */
   
-  n = gtk_text_buffer_get_line_count(buffer);
+  n = gtk_text_buffer_get_line_count (buffer);
   if (n != 1)
-    g_error("%d lines, expected 1", n);
+    g_error ("%d lines, expected 1", n);
   
-  n = gtk_text_buffer_get_char_count(buffer);
+  n = gtk_text_buffer_get_char_count (buffer);
   if (n != 1)
-    g_error("%d chars, expected 1", n);
+    g_error ("%d chars, expected 1", n);
   
   /* Run gruesome alien test suite on buffer */
-  run_tests(buffer);
+  run_tests (buffer);
   
   /* Put stuff in the buffer */
 
-  fill_buffer(buffer);
+  fill_buffer (buffer);
 
   /* Subject stuff-bloated buffer to further torment */
-  run_tests(buffer);
+  run_tests (buffer);
 
   /* Delete all stuff from the buffer */
-  gtk_text_buffer_get_bounds(buffer, &start, &end);
-  gtk_text_buffer_delete(buffer, &start, &end);
+  gtk_text_buffer_get_bounds (buffer, &start, &end);
+  gtk_text_buffer_delete (buffer, &start, &end);
 
   /* Check buffer for emptiness (note that a single
      empty line always remains in the buffer) */
-  n = gtk_text_buffer_get_line_count(buffer);
+  n = gtk_text_buffer_get_line_count (buffer);
   if (n != 1)
-    g_error("%d lines, expected 1", n);
+    g_error ("%d lines, expected 1", n);
   
-  n = gtk_text_buffer_get_char_count(buffer);
+  n = gtk_text_buffer_get_char_count (buffer);
   if (n != 1)
-    g_error("%d chars, expected 1", n);
+    g_error ("%d chars, expected 1", n);
 
-  run_tests(buffer);
+  run_tests (buffer);
   
   return 0;
 }
 
 static void
-run_tests(GtkTextBuffer *buffer)
+run_tests (GtkTextBuffer *buffer)
 {
   GtkTextIter iter;
   GtkTextIter start;
@@ -80,149 +80,151 @@ run_tests(GtkTextBuffer *buffer)
   gint num_chars;
   GtkTextMark *bar_mark;
   
-  gtk_text_buffer_get_bounds(buffer, &start, &end);
+  gtk_text_buffer_get_bounds (buffer, &start, &end);
   
   /* Check that walking the tree via chars and via indexes produces
    * the same number of indexable locations.
    */
-  num_chars = gtk_text_buffer_get_char_count(buffer);
+  num_chars = gtk_text_buffer_get_char_count (buffer);
   iter = start;
-  bar_mark = gtk_text_buffer_create_mark(buffer, "bar", &iter, FALSE);
+  bar_mark = gtk_text_buffer_create_mark (buffer, "bar", &iter, FALSE);
   i = 0;
   while (i < num_chars)
     {
       GtkTextIter current;
       GtkTextMark *foo_mark;
       
-      gtk_text_buffer_get_iter_at_char(buffer, &current, i);
+      gtk_text_buffer_get_iter_at_offset (buffer, &current, i);
 
-      if (!gtk_text_iter_equal(&iter, &current))
+      if (!gtk_text_iter_equal (&iter, &current))
         {
-          g_error("get_char_index didn't return current iter");
+          g_error ("get_char_index didn't return current iter");
         }
 
-      j = gtk_text_iter_get_char_index(&iter);
+      j = gtk_text_iter_get_offset (&iter);
 
       if (i != j)
         {
-          g_error("iter converted to %d not %d", j, i);
+          g_error ("iter converted to %d not %d", j, i);
         }
 
       /* get/set mark */
-      gtk_text_buffer_get_iter_at_mark(buffer, &mark, bar_mark);
+      gtk_text_buffer_get_iter_at_mark (buffer, &mark, bar_mark);
 
-      if (!gtk_text_iter_equal(&iter, &mark))
+      if (!gtk_text_iter_equal (&iter, &mark))
         {
-          gtk_text_iter_spew(&iter, "iter");
-          gtk_text_iter_spew(&mark, "mark");
-          g_error("Mark not moved to the right place.");
+          gtk_text_iter_spew (&iter, "iter");
+          gtk_text_iter_spew (&mark, "mark");
+          g_error ("Mark not moved to the right place.");
         }
       
-      foo_mark = gtk_text_buffer_create_mark(buffer, "foo", &iter, FALSE);
-      gtk_text_buffer_get_iter_at_mark(buffer, &mark, foo_mark);
-      gtk_text_buffer_delete_mark(buffer, foo_mark);
+      foo_mark = gtk_text_buffer_create_mark (buffer, "foo", &iter, FALSE);
+      gtk_text_buffer_get_iter_at_mark (buffer, &mark, foo_mark);
+      gtk_text_buffer_delete_mark (buffer, foo_mark);
       
-      if (!gtk_text_iter_equal(&iter, &mark))
+      if (!gtk_text_iter_equal (&iter, &mark))
         {
-          gtk_text_iter_spew(&iter, "iter");
-          gtk_text_iter_spew(&mark, "mark");
-          g_error("Mark not created in the right place.");
+          gtk_text_iter_spew (&iter, "iter");
+          gtk_text_iter_spew (&mark, "mark");
+          g_error ("Mark not created in the right place.");
         }
+
+      if (gtk_text_iter_is_last (&iter))
+        g_error ("iterators ran out before chars (offset %d of %d)",
+                 i, num_chars);
       
-      if (!gtk_text_iter_forward_char(&iter))
-        g_error("iterators ran out before chars");      
+      gtk_text_iter_next_char (&iter);
 
-      gtk_text_buffer_move_mark(buffer, bar_mark, &iter);
+      gtk_text_buffer_move_mark (buffer, bar_mark, &iter);
       
       ++i;
     }
 
-  if (!gtk_text_iter_equal(&iter, &end))
-    g_error("Iterating over all chars didn't end with the end iter");
+  if (!gtk_text_iter_equal (&iter, &end))
+    g_error ("Iterating over all chars didn't end with the end iter");
 
   /* Do the tree-walk backward 
    */
-  num_chars = gtk_text_buffer_get_char_count(buffer);
-  gtk_text_buffer_get_iter_at_char(buffer, &iter, -1);
+  num_chars = gtk_text_buffer_get_char_count (buffer);
+  gtk_text_buffer_get_iter_at_offset (buffer, &iter, -1);
 
-  gtk_text_buffer_move_mark(buffer, bar_mark, &iter);
+  gtk_text_buffer_move_mark (buffer, bar_mark, &iter);
   
   i = num_chars;
 
-  if (!gtk_text_iter_equal(&iter, &end))
-    g_error("iter at char -1 is not equal to the end iterator");
+  if (!gtk_text_iter_equal (&iter, &end))
+    g_error ("iter at char -1 is not equal to the end iterator");
   
   while (i >= 0)
     {
       GtkTextIter current;
       GtkTextMark *foo_mark;
       
-      gtk_text_buffer_get_iter_at_char(buffer, &current, i);
+      gtk_text_buffer_get_iter_at_offset (buffer, &current, i);
 
-      if (!gtk_text_iter_equal(&iter, &current))
+      if (!gtk_text_iter_equal (&iter, &current))
         {
-          g_error("get_char_index didn't return current iter while going backward");
+          g_error ("get_char_index didn't return current iter while going backward");
         }
-      j = gtk_text_iter_get_char_index(&iter);
+      j = gtk_text_iter_get_offset (&iter);
 
       if (i != j)
         {
-          g_error("going backward, iter converted to %d not %d", j, i);
+          g_error ("going backward, iter converted to %d not %d", j, i);
         }
 
       /* get/set mark */
-      gtk_text_buffer_get_iter_at_mark(buffer, &mark, bar_mark);
+      gtk_text_buffer_get_iter_at_mark (buffer, &mark, bar_mark);
 
-      if (!gtk_text_iter_equal(&iter, &mark))
+      if (!gtk_text_iter_equal (&iter, &mark))
         {
-          gtk_text_iter_spew(&iter, "iter");
-          gtk_text_iter_spew(&mark, "mark");
-          g_error("Mark not moved to the right place.");
+          gtk_text_iter_spew (&iter, "iter");
+          gtk_text_iter_spew (&mark, "mark");
+          g_error ("Mark not moved to the right place.");
         }
       
-      foo_mark = gtk_text_buffer_create_mark(buffer, "foo", &iter, FALSE);
-      gtk_text_buffer_get_iter_at_mark(buffer, &mark, foo_mark);
-      gtk_text_buffer_delete_mark(buffer, foo_mark);
+      foo_mark = gtk_text_buffer_create_mark (buffer, "foo", &iter, FALSE);
+      gtk_text_buffer_get_iter_at_mark (buffer, &mark, foo_mark);
+      gtk_text_buffer_delete_mark (buffer, foo_mark);
       
-      if (!gtk_text_iter_equal(&iter, &mark))
+      if (!gtk_text_iter_equal (&iter, &mark))
         {
-          gtk_text_iter_spew(&iter, "iter");
-          gtk_text_iter_spew(&mark, "mark");
-          g_error("Mark not created in the right place.");
+          gtk_text_iter_spew (&iter, "iter");
+          gtk_text_iter_spew (&mark, "mark");
+          g_error ("Mark not created in the right place.");
         }
       
       if (i > 0)
         {
-          if (!gtk_text_iter_backward_char(&iter))
-            g_error("iterators ran out before char indexes");
+          if (!gtk_text_iter_prev_char (&iter))
+            g_error ("iterators ran out before char indexes");
 
-          gtk_text_buffer_move_mark(buffer, bar_mark, &iter);
+          gtk_text_buffer_move_mark (buffer, bar_mark, &iter);
         }
       else
         {
-          if (gtk_text_iter_backward_char(&iter))
-            g_error("went backward from 0?");
+          if (gtk_text_iter_prev_char (&iter))
+            g_error ("went backward from 0?");
         }
       
       --i;
     }
   
-  if (!gtk_text_iter_equal(&iter, &start))
-    g_error("Iterating backward over all chars didn't end with the start iter");
+  if (!gtk_text_iter_equal (&iter, &start))
+    g_error ("Iterating backward over all chars didn't end with the start iter");
 
   /*
    * Check that get_line_count returns the same number of lines
    * as walking the tree by line
    */
   i = 1; /* include current (first) line */
-  gtk_text_buffer_get_iter_at_line(buffer, &iter, 0);
-  while (gtk_text_iter_forward_line(&iter))
+  gtk_text_buffer_get_iter_at_line (buffer, &iter, 0);
+  while (gtk_text_iter_forward_line (&iter))
     ++i;
-
-  /* Add 1 to the line count, because 'i' counts the end-iterator line */
-  if (i != gtk_text_buffer_get_line_count(buffer) + 1)
-    g_error("Counted %d lines, buffer has %d", i,
-            gtk_text_buffer_get_line_count(buffer) + 1);
+  
+  if (i != gtk_text_buffer_get_line_count (buffer))
+    g_error ("Counted %d lines, buffer has %d", i,
+            gtk_text_buffer_get_line_count (buffer));
 }
 
 
@@ -252,7 +254,7 @@ static char  *book_closed_xpm[] = {
 "                "};
 
 static void
-fill_buffer(GtkTextBuffer *buffer)
+fill_buffer (GtkTextBuffer *buffer)
 {
   GtkTextTag *tag;
   GdkColor color, color2;
@@ -262,65 +264,65 @@ fill_buffer(GtkTextBuffer *buffer)
   GdkBitmap *mask;
   int i;
   
-  tag = gtk_text_buffer_create_tag(buffer, "fg_blue");
+  tag = gtk_text_buffer_create_tag (buffer, "fg_blue");
 
   color.red = color.green = 0;
   color.blue = 0xffff;
   color2.red = 0xfff;
   color2.blue = 0x0;
   color2.green = 0;
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
                  "foreground_gdk", &color,
                  "background_gdk", &color2,
                  "font", "-*-courier-bold-r-*-*-30-*-*-*-*-*-*-*",
                  NULL);
 
-  tag = gtk_text_buffer_create_tag(buffer, "fg_red");
+  tag = gtk_text_buffer_create_tag (buffer, "fg_red");
 
   color.blue = color.green = 0;
   color.red = 0xffff;
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
                  "offset", -4,
                  "foreground_gdk", &color,
                  NULL);
 
-  tag = gtk_text_buffer_create_tag(buffer, "bg_green");
+  tag = gtk_text_buffer_create_tag (buffer, "bg_green");
 
   color.blue = color.red = 0;
   color.green = 0xffff;
-  gtk_object_set(GTK_OBJECT(tag),
+  gtk_object_set (GTK_OBJECT (tag),
                  "background_gdk", &color,
                  "font", "-*-courier-bold-r-*-*-10-*-*-*-*-*-*-*",
                  NULL);
 
   pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
-                                                  gtk_widget_get_default_colormap(),
+                                                  gtk_widget_get_default_colormap (),
                                                   &mask,
                                                   NULL, book_closed_xpm);
   
-  g_assert(pixmap != NULL);
+  g_assert (pixmap != NULL);
   
   i = 0;
   while (i < 10)
     {
       gchar *str;
 
-      gtk_text_buffer_get_iter_at_char(buffer, &iter, 0);
+      gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
       
       gtk_text_buffer_insert_pixmap (buffer, &iter, pixmap, mask);
 
-      gtk_text_buffer_get_iter_at_char(buffer, &iter, 1);
+      gtk_text_buffer_get_iter_at_offset (buffer, &iter, 1);
       
       gtk_text_buffer_insert_pixmap (buffer, &iter, pixmap, mask);
       
-      str = g_strdup_printf("%d Hello World!\nwoo woo woo woo woo woo woo woo\n",
+      str = g_strdup_printf ("%d Hello World!\nwoo woo woo woo woo woo woo woo\n",
                             i);
       
-      gtk_text_buffer_insert(buffer, &iter, str, -1);
+      gtk_text_buffer_insert (buffer, &iter, str, -1);
 
-      g_free(str);
+      g_free (str);
       
-      gtk_text_buffer_insert(buffer, &iter,
+      gtk_text_buffer_insert (buffer, &iter,
                               "(Hello World!)\nfoo foo Hello this is some text we are using to text word wrap. It has punctuation! gee; blah - hmm, great.\nnew line\n\n"
                               /* This is UTF8 stuff, Emacs doesn't
                                  really know how to display it */
@@ -330,64 +332,64 @@ fill_buffer(GtkTextBuffer *buffer)
       gtk_text_buffer_insert_pixmap (buffer, &iter, pixmap, mask);
       gtk_text_buffer_insert_pixmap (buffer, &iter, pixmap, mask);
       
-      gtk_text_buffer_get_iter_at_char(buffer, &iter, 4);
+      gtk_text_buffer_get_iter_at_offset (buffer, &iter, 4);
       
       gtk_text_buffer_insert_pixmap (buffer, &iter, pixmap, mask);
 
-      gtk_text_buffer_get_iter_at_char(buffer, &iter, 7);
+      gtk_text_buffer_get_iter_at_offset (buffer, &iter, 7);
       
       gtk_text_buffer_insert_pixmap (buffer, &iter, pixmap, mask);
 
-      gtk_text_buffer_get_iter_at_char(buffer, &iter, 8);
+      gtk_text_buffer_get_iter_at_offset (buffer, &iter, 8);
       
       gtk_text_buffer_insert_pixmap (buffer, &iter, pixmap, mask);
 
-      gtk_text_buffer_get_iter_at_line_char(buffer, &iter, 0, 8);
+      gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 8);
       iter2 = iter;
-      gtk_text_iter_forward_chars(&iter2, 10);
+      gtk_text_iter_forward_chars (&iter2, 10);
 
-      gtk_text_buffer_apply_tag(buffer, "fg_blue", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
 
-      gtk_text_iter_forward_chars(&iter, 7);
-      gtk_text_iter_forward_chars(&iter2, 10);
+      gtk_text_iter_forward_chars (&iter, 7);
+      gtk_text_iter_forward_chars (&iter2, 10);
       
-      gtk_text_buffer_apply_tag(buffer, "bg_green", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);
 
-      gtk_text_iter_forward_chars(&iter, 12);
-      gtk_text_iter_forward_chars(&iter2, 10);
+      gtk_text_iter_forward_chars (&iter, 12);
+      gtk_text_iter_forward_chars (&iter2, 10);
       
-      gtk_text_buffer_apply_tag(buffer, "bg_green", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);
 
-      gtk_text_iter_forward_chars(&iter, 10);
-      gtk_text_iter_forward_chars(&iter2, 15);
+      gtk_text_iter_forward_chars (&iter, 10);
+      gtk_text_iter_forward_chars (&iter2, 15);
       
-      gtk_text_buffer_apply_tag(buffer, "fg_red", &iter, &iter2);
-      gtk_text_buffer_apply_tag(buffer, "fg_blue", &iter, &iter2);      
+      gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);      
 
-      gtk_text_iter_forward_chars(&iter, 20);
-      gtk_text_iter_forward_chars(&iter2, 20);
+      gtk_text_iter_forward_chars (&iter, 20);
+      gtk_text_iter_forward_chars (&iter2, 20);
       
-      gtk_text_buffer_apply_tag(buffer, "fg_red", &iter, &iter2);
-      gtk_text_buffer_apply_tag(buffer, "fg_blue", &iter, &iter2);      
+      gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);      
 
-      gtk_text_iter_backward_chars(&iter, 25);
-      gtk_text_iter_forward_chars(&iter2, 5);
+      gtk_text_iter_backward_chars (&iter, 25);
+      gtk_text_iter_forward_chars (&iter2, 5);
       
-      gtk_text_buffer_apply_tag(buffer, "fg_red", &iter, &iter2);
-      gtk_text_buffer_apply_tag(buffer, "fg_blue", &iter, &iter2);      
+      gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
+      gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);      
 
-      gtk_text_iter_forward_chars(&iter, 15);
-      gtk_text_iter_backward_chars(&iter2, 10);
+      gtk_text_iter_forward_chars (&iter, 15);
+      gtk_text_iter_backward_chars (&iter2, 10);
 
-      gtk_text_buffer_remove_tag(buffer, "fg_red", &iter, &iter2);
-      gtk_text_buffer_remove_tag(buffer, "fg_blue", &iter, &iter2);      
+      gtk_text_buffer_remove_tag_by_name (buffer, "fg_red", &iter, &iter2);
+      gtk_text_buffer_remove_tag_by_name (buffer, "fg_blue", &iter, &iter2);      
       
       ++i;
     }
 
-  gdk_pixmap_unref(pixmap);
+  gdk_pixmap_unref (pixmap);
   if (mask)
-    gdk_bitmap_unref(mask);
+    gdk_bitmap_unref (mask);
 }