remove unused call to get_last_line()

2000-12-14  Havoc Pennington  <hp@redhat.com>

	* gtk/gtktextbtree.c (_gtk_text_btree_validate_line): remove
	unused call to get_last_line()

	* gtk/gtkobject.c (gtk_object_add_arg_type): add G_TYPE_POINTER
	here until boxed is working (and maybe after that - we should
	really not gratuitously break old code)

	* gtk/gtktexttag.c (gtk_text_tag_class_init): add commented-out
	specific types for font_desc and tabs args, move them to
	GTK_TYPE_POINTER for now, waiting on g_param_spec_boxed() to get
	fixed. Move GdkColor args to GTK_TYPE_POINTER also.

	* gtk/gtktextbuffer.c (gtk_text_buffer_class_init): temporarily
	use GTK_TYPE_POINTER for signal signatures as a hack-around

	* gtk/gtk-boxed.defs: Add boxed types for PangoFontDescription and
	PangoTabArray

	* gtk/gtktextlayout.c (line_display_iter_to_index):
	make static
	(line_display_index_to_iter): make static

	* gtk/gtktextbuffer.c (gtk_text_buffer_class_init): fix marshaller
	to marshal a string not a boxed

	* gtk/gtkmarshal.list: add marshaller for GtkTextBuffer:insert_text

	* gtk/testtext.c (fill_file_buffer): don't use g_utf8_next_char
	since the UTF-8 isn't validated yet

	* gtk/gtktextsegment.c (char_segment_check_func): don't require
	lines to end in '\n'

	* gtk/gtktextview.c (gtk_text_view_move_cursor): update to use
	forward_to_delimiters, and grapheme boundaries
	(gtk_text_view_delete_from_cursor): properly handle non-newline
	delimiters, and grapheme boundaries

	* gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): rename
	to gtk_text_iter_forward_to_delimiters, and make it work properly
	if empty lines end with a character other than '\n'

	* gtk/gtktextiter.h, gtk/gtktextiter.c: Add movement by cursor
	position

13 files changed, 218 insertions, 79 deletions

diff --git a/gtk/gtk-boxed.defs b/gtk/gtk-boxed.defs
index b21c10498d..83fc8d8d46 100644
--- a/gtk/gtk-boxed.defs
+++ b/gtk/gtk-boxed.defs
@@ -1286,6 +1286,14 @@
   gtk_text_iter_copy
   gtk_text_iter_free)
 
+(define-boxed PangoTabArray
+  pango_tab_array_copy
+  pango_tab_array_free)
+
+(define-boxed PangoFontDescription
+  pango_font_description_copy
+  pango_font_description_free)
+
 ;; TreeView
 (define-boxed GtkTreeIter
   gtk_tree_iter_copy
diff --git a/gtk/gtkmarshal.list b/gtk/gtkmarshal.list
index f011f28b73..9afc449ccf 100644
--- a/gtk/gtkmarshal.list
+++ b/gtk/gtkmarshal.list
@@ -47,7 +47,7 @@ VOID:BOOLEAN
 VOID:BOXED
 VOID:BOXED,BOXED
 VOID:BOXED,BOXED,BOOLEAN
-VOID:BOXED,BOXED,INT,BOOLEAN
+VOID:BOXED,STRING,INT,BOOLEAN
 VOID:BOXED,INT,POINTER
 VOID:BOXED,OBJECT
 VOID:BOXED,UINT,FLAGS
diff --git a/gtk/gtkmarshalers.list b/gtk/gtkmarshalers.list
index f011f28b73..9afc449ccf 100644
--- a/gtk/gtkmarshalers.list
+++ b/gtk/gtkmarshalers.list
@@ -47,7 +47,7 @@ VOID:BOOLEAN
 VOID:BOXED
 VOID:BOXED,BOXED
 VOID:BOXED,BOXED,BOOLEAN
-VOID:BOXED,BOXED,INT,BOOLEAN
+VOID:BOXED,STRING,INT,BOOLEAN
 VOID:BOXED,INT,POINTER
 VOID:BOXED,OBJECT
 VOID:BOXED,UINT,FLAGS
diff --git a/gtk/gtkobject.c b/gtk/gtkobject.c
index ff9c081738..a6678899ba 100644
--- a/gtk/gtkobject.c
+++ b/gtk/gtkobject.c
@@ -290,6 +290,9 @@ gtk_object_add_arg_type (const gchar *arg_name,
     case G_TYPE_STRING:
       pspec = g_param_spec_string (pname, NULL, NULL, NULL, arg_flags);
       break;
+    case G_TYPE_POINTER:
+      pspec = g_param_spec_pointer (pname, NULL, NULL, arg_flags);
+      break;
     case G_TYPE_OBJECT:
       pspec = g_param_spec_object (pname, NULL, NULL, arg_type, arg_flags);
       break;
diff --git a/gtk/gtktextbtree.c b/gtk/gtktextbtree.c
index 9fe5277136..f456ff644d 100644
--- a/gtk/gtktextbtree.c
+++ b/gtk/gtktextbtree.c
@@ -959,6 +959,8 @@ _gtk_text_btree_insert (GtkTextIter *iter,
   chars_changed (tree);
   segments_changed (tree);
 
+  g_assert (g_utf8_validate (text, len, NULL));
+  
   /*
    * Chop the text up into lines and create a new segment for
    * each line, plus a new line for the leftovers from the
@@ -971,6 +973,8 @@ _gtk_text_btree_insert (GtkTextIter *iter,
   char_count_delta = 0;
   while (eol < len)
     {
+      sol = eol;
+      
       pango_find_paragraph_boundary (text + sol,
                                      len - sol,
                                      &delim,
@@ -979,9 +983,16 @@ _gtk_text_btree_insert (GtkTextIter *iter,
       /* make these relative to the start of the text */
       delim += sol;
       eol += sol;
+
+      g_assert (eol >= sol);
+      g_assert (delim >= sol);
+      g_assert (eol >= delim);
+      g_assert (sol >= 0);
+      g_assert (eol <= len);
       
       chunk_len = eol - sol;
-      
+
+      g_assert (g_utf8_validate (&text[sol], chunk_len, NULL));
       seg = _gtk_char_segment_new (&text[sol], chunk_len);
 
       char_count_delta += seg->char_count;
@@ -998,8 +1009,11 @@ _gtk_text_btree_insert (GtkTextIter *iter,
         }
 
       if (delim == eol)
-        /* chunk didn't end with a paragraph separator */
-        break;
+        {
+          /* chunk didn't end with a paragraph separator */
+          g_assert (eol == len);
+          break;
+        }
 
       /*
        * The chunk ended with a newline, so create a new GtkTextLine
@@ -1015,8 +1029,6 @@ _gtk_text_btree_insert (GtkTextIter *iter,
       line = newline;
       cur_seg = NULL;
       line_count_delta++;
-
-      sol = eol;
     }
 
   /*
@@ -1215,9 +1227,9 @@ find_line_by_y (GtkTextBTree *tree, BTreeView *view,
 
 GtkTextLine *
 _gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
-                               gpointer      view_id,
-                               gint          ypixel,
-                               gint         *line_top_out)
+                                gpointer      view_id,
+                                gint          ypixel,
+                                gint         *line_top_out)
 {
   GtkTextLine *line;
   BTreeView *view;
@@ -3240,7 +3252,7 @@ _gtk_text_line_get_data (GtkTextLine *line,
 
 void
 _gtk_text_line_invalidate_wrap (GtkTextLine *line,
-                               GtkTextLineData *ld)
+                                GtkTextLineData *ld)
 {
   /* For now this is totally unoptimized. FIXME?
 
@@ -3248,9 +3260,9 @@ _gtk_text_line_invalidate_wrap (GtkTextLine *line,
      is less than the max width for the parent node,
      and the case where the height is unchanged when we re-wrap.
   */
-
+  
   g_return_if_fail (ld != NULL);
-
+  
   ld->valid = FALSE;
   gtk_text_btree_node_invalidate_upward (line->parent, ld->view_id);
 }
@@ -4997,11 +5009,10 @@ gtk_text_btree_node_check_valid_downward (GtkTextBTreeNode *node,
  **/
 void
 _gtk_text_btree_validate_line (GtkTextBTree     *tree,
-                              GtkTextLine      *line,
-                              gpointer          view_id)
+                               GtkTextLine      *line,
+                               gpointer          view_id)
 {
   GtkTextLineData *ld;
-  GtkTextLine *last_line;
   BTreeView *view;
 
   g_return_if_fail (tree != NULL);
@@ -5009,13 +5020,12 @@ _gtk_text_btree_validate_line (GtkTextBTree     *tree,
 
   view = gtk_text_btree_get_view (tree, view_id);
   g_return_if_fail (view != NULL);
-
+  
   ld = _gtk_text_line_get_data (line, view_id);
   if (!ld || !ld->valid)
     {
       ld = gtk_text_layout_wrap (view->layout, line, ld);
-      last_line = get_last_line (tree);
-
+      
       gtk_text_btree_node_check_valid_upward (line->parent, view_id);
     }
 }
diff --git a/gtk/gtktextbuffer.c b/gtk/gtktextbuffer.c
index e501b3776a..276d77f81a 100644
--- a/gtk/gtktextbuffer.c
+++ b/gtk/gtktextbuffer.c
@@ -148,11 +148,16 @@ gtk_text_buffer_class_init (GtkTextBufferClass *klass)
                     GTK_RUN_LAST,
                     GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkTextBufferClass, insert_text),
-                    gtk_marshal_VOID__BOXED_BOXED_INT_BOOLEAN,
+                    gtk_marshal_VOID__BOXED_STRING_INT_BOOLEAN,
                     GTK_TYPE_NONE,
                     4,
+#if 0
+                    /* FIXME */
                     GTK_TYPE_TEXT_ITER,
-                    GTK_TYPE_TEXT_ITER,
+                    GTK_TYPE_STRING,
+#endif
+                    GTK_TYPE_POINTER,
+                    GTK_TYPE_POINTER,
                     GTK_TYPE_INT,
                     GTK_TYPE_BOOL);
 
@@ -164,8 +169,13 @@ gtk_text_buffer_class_init (GtkTextBufferClass *klass)
                     gtk_marshal_VOID__BOXED_BOXED_BOOLEAN,
                     GTK_TYPE_NONE,
                     3,
+#if 0
+                    /* FIXME */
                     GTK_TYPE_TEXT_ITER,
                     GTK_TYPE_TEXT_ITER,
+#endif
+                    GTK_TYPE_POINTER,
+                    GTK_TYPE_POINTER,
                     GTK_TYPE_BOOL);
 
   signals[CHANGED] =
@@ -410,10 +420,10 @@ gtk_text_buffer_real_insert_text (GtkTextBuffer *buffer,
 
 static void
 gtk_text_buffer_emit_insert (GtkTextBuffer *buffer,
-                             GtkTextIter *iter,
-                             const gchar *text,
-                             gint len,
-                             gboolean interactive)
+                             GtkTextIter   *iter,
+                             const gchar   *text,
+                             gint           len,
+                             gboolean       interactive)
 {
   g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
   g_return_if_fail (iter != NULL);
@@ -422,6 +432,8 @@ gtk_text_buffer_emit_insert (GtkTextBuffer *buffer,
   if (len < 0)
     len = strlen (text);
 
+  g_assert (g_utf8_validate (text, len, NULL));
+  
   if (len > 0)
     {
       gtk_signal_emit (GTK_OBJECT (buffer), signals[INSERT_TEXT],
diff --git a/gtk/gtktextiter.c b/gtk/gtktextiter.c
index 2e181f37e7..226604d821 100644
--- a/gtk/gtktextiter.c
+++ b/gtk/gtktextiter.c
@@ -2606,6 +2606,94 @@ gtk_text_iter_inside_word (const GtkTextIter *iter)
   return test_log_attrs (iter, inside_word_func, NULL);
 }
 
+static gboolean
+find_cursor_pos_func (const PangoLogAttr *attrs,
+                      gint          offset,
+                      gint          min_offset,
+                      gint          len,
+                      gint         *found_offset)
+{
+  ++offset; /* We always go to the NEXT position */
+
+  /* Find end of next word */
+  while (offset < min_offset + len &&
+         !attrs[offset].is_cursor_position)
+    ++offset;
+
+  *found_offset = offset;
+
+  return offset < min_offset + len;
+}
+
+static gboolean
+is_cursor_pos_func (const PangoLogAttr *attrs,
+                    gint          offset,
+                    gint          min_offset,
+                    gint          len,
+                    gint         *found_offset)
+{
+  return attrs[offset].is_cursor_position;
+}
+
+gboolean
+gtk_text_iter_forward_cursor_position (GtkTextIter *iter)
+{
+  return find_by_log_attrs (iter, find_cursor_pos_func, TRUE);  
+
+}
+
+gboolean
+gtk_text_iter_backward_cursor_position (GtkTextIter *iter)
+{
+  return find_by_log_attrs (iter, find_cursor_pos_func, FALSE);
+}
+
+gboolean
+gtk_text_iter_forward_cursor_positions (GtkTextIter *iter,
+                                        gint         count)
+{
+  g_return_val_if_fail (iter != NULL, FALSE);
+  g_return_val_if_fail (count > 0, FALSE);
+
+  if (!gtk_text_iter_forward_cursor_position (iter))
+    return FALSE;
+  --count;
+
+  while (count > 0)
+    {
+      if (!gtk_text_iter_forward_cursor_position (iter))
+        break;
+      --count;
+    }
+  return TRUE;
+}
+
+gboolean
+gtk_text_iter_backward_cursor_positions (GtkTextIter *iter,
+                                         gint         count)
+{
+  g_return_val_if_fail (iter != NULL, FALSE);
+  g_return_val_if_fail (count > 0, FALSE);
+
+  if (!gtk_text_iter_backward_cursor_position (iter))
+    return FALSE;
+  --count;
+
+  while (count > 0)
+    {
+      if (!gtk_text_iter_backward_cursor_position (iter))
+        break;
+      --count;
+    }
+  return TRUE;
+}
+
+gboolean
+gtk_text_iter_is_cursor_position (const GtkTextIter *iter)
+{
+  return test_log_attrs (iter, is_cursor_pos_func, NULL);
+}
+
 void
 gtk_text_iter_set_line_offset (GtkTextIter *iter,
                                gint char_on_line)
@@ -2732,8 +2820,19 @@ gtk_text_iter_forward_to_end  (GtkTextIter       *iter)
   gtk_text_buffer_get_last_iter (buffer, iter);
 }
 
+/**
+ * gtk_text_iter_forward_to_delimiters:
+ * @iter: a #GtkTextIter
+ * 
+ * Moves the iterator to point to the paragraph delimiter characters,
+ * which will be either a newline, a carriage return, a carriage
+ * return/newline in sequence, or the Unicode paragraph separator
+ * character.
+ * 
+ * Return value: %TRUE if we moved and the new location is not the end iterator
+ **/
 gboolean
-gtk_text_iter_forward_to_newline (GtkTextIter *iter)
+gtk_text_iter_forward_to_delimiters (GtkTextIter *iter)
 {
   gint current_offset;
   gint new_offset;
@@ -2757,8 +2856,8 @@ gtk_text_iter_forward_to_newline (GtkTextIter *iter)
           /* We don't want to move past all
            * empty lines.
            */
-          if (gtk_text_iter_get_char (iter) != '\n')
-            gtk_text_iter_forward_to_newline (iter);
+          if (!gtk_text_iter_ends_line (iter))
+            gtk_text_iter_forward_to_delimiters (iter);
           return TRUE;
         }
       else
diff --git a/gtk/gtktextiter.h b/gtk/gtktextiter.h
index da5e761d4e..0f46d625a1 100644
--- a/gtk/gtktextiter.h
+++ b/gtk/gtktextiter.h
@@ -125,11 +125,12 @@ GSList  *gtk_text_iter_get_tags          (const GtkTextIter   *iter);
 gboolean gtk_text_iter_editable          (const GtkTextIter   *iter,
                                           gboolean             default_setting);
 
-gboolean gtk_text_iter_starts_word       (const GtkTextIter   *iter);
-gboolean gtk_text_iter_ends_word         (const GtkTextIter   *iter);
-gboolean gtk_text_iter_inside_word       (const GtkTextIter   *iter);
-gboolean gtk_text_iter_starts_line       (const GtkTextIter   *iter);
-gboolean gtk_text_iter_ends_line         (const GtkTextIter   *iter);
+gboolean gtk_text_iter_starts_word        (const GtkTextIter   *iter);
+gboolean gtk_text_iter_ends_word          (const GtkTextIter   *iter);
+gboolean gtk_text_iter_inside_word        (const GtkTextIter   *iter);
+gboolean gtk_text_iter_starts_line        (const GtkTextIter   *iter);
+gboolean gtk_text_iter_ends_line          (const GtkTextIter   *iter);
+gboolean gtk_text_iter_is_cursor_position (const GtkTextIter   *iter);
 
 gint     gtk_text_iter_get_chars_in_line (const GtkTextIter   *iter);
 
@@ -143,8 +144,8 @@ gboolean gtk_text_iter_is_first          (const GtkTextIter    *iter);
  * Moving around the buffer
  */
 
-gboolean gtk_text_iter_forward_char            (GtkTextIter *iter);
-gboolean gtk_text_iter_backward_char            (GtkTextIter *iter);
+gboolean gtk_text_iter_forward_char         (GtkTextIter *iter);
+gboolean gtk_text_iter_backward_char        (GtkTextIter *iter);
 gboolean gtk_text_iter_forward_chars        (GtkTextIter *iter,
                                              gint         count);
 gboolean gtk_text_iter_backward_chars       (GtkTextIter *iter,
@@ -155,12 +156,24 @@ gboolean gtk_text_iter_forward_lines        (GtkTextIter *iter,
                                              gint         count);
 gboolean gtk_text_iter_backward_lines       (GtkTextIter *iter,
                                              gint         count);
+gboolean gtk_text_iter_forward_word_end     (GtkTextIter *iter);
+gboolean gtk_text_iter_backward_word_start  (GtkTextIter *iter);
 gboolean gtk_text_iter_forward_word_ends    (GtkTextIter *iter,
                                              gint         count);
 gboolean gtk_text_iter_backward_word_starts (GtkTextIter *iter,
                                              gint         count);
-gboolean gtk_text_iter_forward_word_end     (GtkTextIter *iter);
-gboolean gtk_text_iter_backward_word_start  (GtkTextIter *iter);
+/* cursor positions are almost equivalent to chars, but not quite;
+ * in some languages, you can't put the cursor between certain
+ * chars. Also, you can't put the cursor between \r\n at the end
+ * of a line.
+ */
+gboolean gtk_text_iter_forward_cursor_position   (GtkTextIter *iter);
+gboolean gtk_text_iter_backward_cursor_position  (GtkTextIter *iter);
+gboolean gtk_text_iter_forward_cursor_positions  (GtkTextIter *iter,
+                                                  gint         count);
+gboolean gtk_text_iter_backward_cursor_positions (GtkTextIter *iter,
+                                                  gint         count);
+
 
 void     gtk_text_iter_set_offset         (GtkTextIter *iter,
                                            gint         char_offset);
@@ -171,7 +184,7 @@ void     gtk_text_iter_set_line_offset    (GtkTextIter *iter,
 void     gtk_text_iter_set_line_index     (GtkTextIter *iter,
                                            gint         byte_on_line);
 void     gtk_text_iter_forward_to_end     (GtkTextIter *iter);
-gboolean gtk_text_iter_forward_to_newline (GtkTextIter *iter);
+gboolean gtk_text_iter_forward_to_delimiters (GtkTextIter *iter);
 
 
 /* returns TRUE if a toggle was found; NULL for the tag pointer
diff --git a/gtk/gtktextlayout.c b/gtk/gtktextlayout.c
index 6e6819403b..e27732be7d 100644
--- a/gtk/gtktextlayout.c
+++ b/gtk/gtktextlayout.c
@@ -785,7 +785,7 @@ gtk_text_layout_validate_yrange (GtkTextLayout *layout,
           gint old_height = line_data ? line_data->height : 0;
 
           _gtk_text_btree_validate_line (_gtk_text_buffer_get_btree (layout->buffer),
-                                        line, layout);
+                                         line, layout);
           line_data = _gtk_text_line_get_data (line, layout);
 
           delta_height += line_data->height - old_height;
@@ -814,7 +814,7 @@ gtk_text_layout_validate_yrange (GtkTextLayout *layout,
           gint old_height = line_data ? line_data->height : 0;
 
           _gtk_text_btree_validate_line (_gtk_text_buffer_get_btree (layout->buffer),
-                                        line, layout);
+                                         line, layout);
           line_data = _gtk_text_line_get_data (line, layout);
 
           delta_height += line_data->height - old_height;
@@ -842,7 +842,7 @@ gtk_text_layout_validate_yrange (GtkTextLayout *layout,
       update_layout_size (layout);
 
       line_top = _gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
-					       first_line, layout);
+                                                first_line, layout);
 
       gtk_text_layout_changed (layout,
                                line_top,
@@ -871,8 +871,8 @@ gtk_text_layout_validate (GtkTextLayout *layout,
 
   while (max_pixels > 0 &&
          _gtk_text_btree_validate (_gtk_text_buffer_get_btree (layout->buffer),
-                                  layout,  max_pixels,
-                                  &y, &old_height, &new_height))
+                                   layout,  max_pixels,
+                                   &y, &old_height, &new_height))
     {
       max_pixels -= new_height;
 
@@ -1623,7 +1623,7 @@ gtk_text_layout_get_line_display (GtkTextLayout *layout,
   display->insert_index = -1;
 
   _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
-                                   &iter, line, 0);
+                                    &iter, line, 0);
 
   /* Special-case optimization for completely
    * invisible lines; makes it faster to deal
@@ -1872,7 +1872,7 @@ gtk_text_layout_get_line_display (GtkTextLayout *layout,
 
   display->width = PANGO_PIXELS (extents.width) + display->left_margin + display->right_margin;
   display->height += PANGO_PIXELS (extents.height);
-
+  
   /* Free this if we aren't in a loop */
   if (layout->wrap_loop_count == 0)
     invalidate_cached_style (layout);
@@ -1910,7 +1910,7 @@ gtk_text_layout_free_line_display (GtkTextLayout      *layout,
 /* Functions to convert iter <=> index for the line of a GtkTextLineDisplay
  * taking into account the preedit string, if necessary.
  */
-gint
+static gint
 line_display_iter_to_index (GtkTextLayout      *layout,
 			    GtkTextLineDisplay *display,
 			    const GtkTextIter  *iter)
@@ -1927,7 +1927,7 @@ line_display_iter_to_index (GtkTextLayout      *layout,
   return index;
 }
 
-void
+static void
 line_display_index_to_iter (GtkTextLayout      *layout,
 			    GtkTextLineDisplay *display,
 			    GtkTextIter        *iter,
diff --git a/gtk/gtktextsegment.c b/gtk/gtktextsegment.c
index 2a4bce96fa..e37e78ac9c 100644
--- a/gtk/gtktextsegment.c
+++ b/gtk/gtktextsegment.c
@@ -392,14 +392,7 @@ char_segment_check_func (segPtr, line)
 {
   char_segment_self_check (segPtr);
 
-  if (segPtr->next == NULL)
-    {
-      if (segPtr->body.chars[segPtr->byte_count-1] != '\n')
-        {
-          g_error ("char_segment_check_func: line doesn't end with newline");
-        }
-    }
-  else
+  if (segPtr->next != NULL)
     {
       if (segPtr->next->type == &gtk_text_char_type)
         {
diff --git a/gtk/gtktexttag.c b/gtk/gtktexttag.c
index f0a54326ca..25f48f42cb 100644
--- a/gtk/gtktexttag.c
+++ b/gtk/gtktexttag.c
@@ -195,7 +195,8 @@ gtk_text_tag_class_init (GtkTextTagClass *klass)
   /* Style args */
   gtk_object_add_arg_type ("GtkTextTag::background", GTK_TYPE_STRING,
                            GTK_ARG_WRITABLE, ARG_BACKGROUND);
-  gtk_object_add_arg_type ("GtkTextTag::background_gdk", GTK_TYPE_GDK_COLOR,
+  /* FIXME GTK_TYPE_GDK_COLOR */
+  gtk_object_add_arg_type ("GtkTextTag::background_gdk", GTK_TYPE_POINTER,
                            GTK_ARG_READWRITE, ARG_BACKGROUND_GDK);
   gtk_object_add_arg_type ("GtkTextTag::background_full_height", GTK_TYPE_BOOL,
                            GTK_ARG_READWRITE, ARG_BG_FULL_HEIGHT);
@@ -208,7 +209,8 @@ gtk_text_tag_class_init (GtkTextTagClass *klass)
                            GTK_ARG_READWRITE, ARG_EDITABLE);
   gtk_object_add_arg_type ("GtkTextTag::font", GTK_TYPE_STRING,
                            GTK_ARG_READWRITE, ARG_FONT);
-  gtk_object_add_arg_type ("GtkTextTag::font_desc", GTK_TYPE_BOXED,
+  /* FIXME GTK_TYPE_PANGO_FONT_DESCRIPTION */
+  gtk_object_add_arg_type ("GtkTextTag::font_desc", GTK_TYPE_POINTER,
                            GTK_ARG_READWRITE, ARG_FONT_DESC);      
   gtk_object_add_arg_type ("GtkTextTag::family", GTK_TYPE_STRING,
                            GTK_ARG_READWRITE, ARG_FAMILY);
@@ -226,7 +228,8 @@ gtk_text_tag_class_init (GtkTextTagClass *klass)
                            GTK_ARG_READWRITE, ARG_SIZE_POINTS);
   gtk_object_add_arg_type ("GtkTextTag::foreground", GTK_TYPE_STRING,
                            GTK_ARG_WRITABLE, ARG_FOREGROUND);
-  gtk_object_add_arg_type ("GtkTextTag::foreground_gdk", GTK_TYPE_GDK_COLOR,
+  /* FIXME GTK_TYPE_GDK_COLOR */
+  gtk_object_add_arg_type ("GtkTextTag::foreground_gdk", GTK_TYPE_POINTER,
                            GTK_ARG_READWRITE, ARG_FOREGROUND_GDK);
   gtk_object_add_arg_type ("GtkTextTag::foreground_stipple",
                            GDK_TYPE_PIXMAP,
@@ -255,7 +258,8 @@ gtk_text_tag_class_init (GtkTextTagClass *klass)
                            GTK_ARG_READWRITE, ARG_UNDERLINE);
   gtk_object_add_arg_type ("GtkTextTag::wrap_mode", GTK_TYPE_ENUM,
                            GTK_ARG_READWRITE, ARG_WRAP_MODE);
-  gtk_object_add_arg_type ("GtkTextTag::tabs", GTK_TYPE_POINTER, /* FIXME */
+  /* FIXME GTK_TYPE_PANGO_TAB_ARRAY */
+  gtk_object_add_arg_type ("GtkTextTag::tabs", GTK_TYPE_POINTER,
                            GTK_ARG_READWRITE, ARG_TABS);
   gtk_object_add_arg_type ("GtkTextTag::invisible", GTK_TYPE_BOOL,
                            GTK_ARG_READWRITE, ARG_INVISIBLE);
@@ -337,7 +341,8 @@ gtk_text_tag_init (GtkTextTag *text_tag)
 {
   /* 0 is basically a fine way to initialize everything in the
      entire struct */
-
+  
+  text_tag->values = gtk_text_attributes_new ();
 }
 
 /**
@@ -354,11 +359,9 @@ gtk_text_tag_new (const gchar *name)
 {
   GtkTextTag *tag;
 
-  tag = GTK_TEXT_TAG (gtk_type_new (gtk_text_tag_get_type ()));
-
-  tag->name = g_strdup (name);
-
-  tag->values = gtk_text_attributes_new ();
+  tag = GTK_TEXT_TAG (g_object_new (gtk_text_tag_get_type (),
+                                    "name", name,
+                                    NULL));
 
   return tag;
 }
@@ -717,6 +720,7 @@ gtk_text_tag_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
       if (text_tag->values->tabs)
         pango_tab_array_free (text_tag->values->tabs);
 
+      /* FIXME I'm not sure if this is a memleak or not */
       text_tag->values->tabs =
         pango_tab_array_copy (GTK_VALUE_POINTER (*arg));
 
diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c
index 35a4747bb3..1a97e93d35 100644
--- a/gtk/gtktextview.c
+++ b/gtk/gtktextview.c
@@ -3123,7 +3123,7 @@ gtk_text_view_move_cursor (GtkTextView     *text_view,
   switch (step)
     {
     case GTK_MOVEMENT_CHARS:
-      gtk_text_iter_forward_chars (&newplace, count);
+      gtk_text_iter_forward_cursor_positions (&newplace, count);
       break;
 
     case GTK_MOVEMENT_POSITIONS:
@@ -3161,7 +3161,7 @@ gtk_text_view_move_cursor (GtkTextView     *text_view,
 
     case GTK_MOVEMENT_PARAGRAPH_ENDS:
       if (count > 0)
-        gtk_text_iter_forward_to_newline (&newplace);
+        gtk_text_iter_forward_to_delimiters (&newplace);
       else if (count < 0)
         gtk_text_iter_set_line_offset (&newplace, 0);
       break;
@@ -3334,7 +3334,7 @@ gtk_text_view_delete_from_cursor (GtkTextView   *text_view,
   switch (type)
     {
     case GTK_DELETE_CHARS:
-      gtk_text_iter_forward_chars (&end, count);
+      gtk_text_iter_forward_cursor_positions (&end, count);
       break;
 
     case GTK_DELETE_WORD_ENDS:
@@ -3358,15 +3358,15 @@ gtk_text_view_delete_from_cursor (GtkTextView   *text_view,
        * simply delete that newline, instead of
        * moving to the next one.
        */
-      if (gtk_text_iter_get_char (&end) == '\n')
+      if (gtk_text_iter_ends_line (&end))
         {
-          gtk_text_iter_forward_char (&end);
+          gtk_text_iter_forward_line (&end);
           --count;
         }
 
       while (count > 0)
         {
-          if (!gtk_text_iter_forward_to_newline (&end))
+          if (!gtk_text_iter_forward_to_delimiters (&end))
             break;
 
           --count;
@@ -3380,12 +3380,12 @@ gtk_text_view_delete_from_cursor (GtkTextView   *text_view,
       if (count > 0)
         {
           gtk_text_iter_set_line_offset (&start, 0);
-          gtk_text_iter_forward_to_newline (&end);
+          gtk_text_iter_forward_to_delimiters (&end);
 
           /* Do the lines beyond the first. */
           while (count > 1)
             {
-              gtk_text_iter_forward_to_newline (&end);
+              gtk_text_iter_forward_to_delimiters (&end);
 
               --count;
             }
diff --git a/gtk/testtext.c b/gtk/testtext.c
index 6daeebae2c..4eaf62b75c 100644
--- a/gtk/testtext.c
+++ b/gtk/testtext.c
@@ -651,16 +651,13 @@ fill_file_buffer (GtkTextBuffer *buffer, const char *filename)
 	  if (!*leftover)
 	    break;
 	  
-	  next = g_utf8_next_char (next);
-	  if (next > buf+count+remaining) {
-	    next = NULL;
-	    break;
-	  }
+	  next = g_utf8_find_next_char (next, buf + count + remaining);
 	}
 
+      g_assert (g_utf8_validate (buf, leftover - buf, NULL));
       gtk_text_buffer_insert (buffer, &iter, buf, leftover - buf);
 
-      remaining = buf + remaining + count - leftover;
+      remaining = (buf + remaining + count) - leftover;
       g_memmove (buf, leftover, remaining);
 
       if (remaining > 6 || count < to_read)