Add support for invalid nodes. (_gtk_rbnode_rotate_right): Ditto.

Thu Oct 25 16:27:29 2001  Jonathan Blandford  <jrb@redhat.com>

	* gtk/gtkrbtree.c (_gtk_rbnode_rotate_left): Add support for
	invalid nodes.
	 (_gtk_rbnode_rotate_right): Ditto.
	 (_gtk_rbtree_node_mark_invalid): New function.
	 (_gtk_rbtree_node_mark_valid): New function.

	* gtk/gtktreemodelsort.c (gtk_tree_model_sort_class_init): We're a
	GObject, not a GtkObject.
	(gtk_tree_model_sort_row_has_child_toggled): Rewrote to be more
	correct.
	(gtk_tree_model_sort_row_deleted): ditto.
	(gtk_tree_model_sort_{un,}ref_node): Fix.

	* gtk/gtktreeview.c: Protean incremental reflow support (commented
	out)

	* gtk/gtktreeview.h (GtkTreeViewSearchEqualFunc): change char *key
	to const char *key.

	* gtk/gtktreemodel.c (gtk_tree_row_reference_unref_path_helper):
	Important 1 line fix to fix a lot of refcounting woes.

ChangeLog

@@ -1,3 +1,27 @@
+Thu Oct 25 16:27:29 2001  Jonathan Blandford  <jrb@redhat.com>
+
+	* gtk/gtkrbtree.c (_gtk_rbnode_rotate_left): Add support for
+	invalid nodes.
+	 (_gtk_rbnode_rotate_right): Ditto.
+	 (_gtk_rbtree_node_mark_invalid): New function.
+	 (_gtk_rbtree_node_mark_valid): New function.
+
+	* gtk/gtktreemodelsort.c (gtk_tree_model_sort_class_init): We're a
+	GObject, not a GtkObject.
+	(gtk_tree_model_sort_row_has_child_toggled): Rewrote to be more
+	correct.
+	(gtk_tree_model_sort_row_deleted): ditto.
+	(gtk_tree_model_sort_{un,}ref_node): Fix.
+
+	* gtk/gtktreeview.c: Protean incremental reflow support (commented
+	out)
+
+	* gtk/gtktreeview.h (GtkTreeViewSearchEqualFunc): change char *key
+	to const char *key.
+
+	* gtk/gtktreemodel.c (gtk_tree_row_reference_unref_path_helper):
+	Important 1 line fix to fix a lot of refcounting woes.
+
 2001-10-25  Matt Wilson  <msw@redhat.com>
 
 	* gtk/gtktextview.c (gtk_text_view_destroy): call

ChangeLog.pre-2-0

@@ -1,3 +1,27 @@
+Thu Oct 25 16:27:29 2001  Jonathan Blandford  <jrb@redhat.com>
+
+	* gtk/gtkrbtree.c (_gtk_rbnode_rotate_left): Add support for
+	invalid nodes.
+	 (_gtk_rbnode_rotate_right): Ditto.
+	 (_gtk_rbtree_node_mark_invalid): New function.
+	 (_gtk_rbtree_node_mark_valid): New function.
+
+	* gtk/gtktreemodelsort.c (gtk_tree_model_sort_class_init): We're a
+	GObject, not a GtkObject.
+	(gtk_tree_model_sort_row_has_child_toggled): Rewrote to be more
+	correct.
+	(gtk_tree_model_sort_row_deleted): ditto.
+	(gtk_tree_model_sort_{un,}ref_node): Fix.
+
+	* gtk/gtktreeview.c: Protean incremental reflow support (commented
+	out)
+
+	* gtk/gtktreeview.h (GtkTreeViewSearchEqualFunc): change char *key
+	to const char *key.
+
+	* gtk/gtktreemodel.c (gtk_tree_row_reference_unref_path_helper):
+	Important 1 line fix to fix a lot of refcounting woes.
+
 2001-10-25  Matt Wilson  <msw@redhat.com>
 
 	* gtk/gtktextview.c (gtk_text_view_destroy): call

ChangeLog.pre-2-10

@@ -1,3 +1,27 @@
+Thu Oct 25 16:27:29 2001  Jonathan Blandford  <jrb@redhat.com>
+
+	* gtk/gtkrbtree.c (_gtk_rbnode_rotate_left): Add support for
+	invalid nodes.
+	 (_gtk_rbnode_rotate_right): Ditto.
+	 (_gtk_rbtree_node_mark_invalid): New function.
+	 (_gtk_rbtree_node_mark_valid): New function.
+
+	* gtk/gtktreemodelsort.c (gtk_tree_model_sort_class_init): We're a
+	GObject, not a GtkObject.
+	(gtk_tree_model_sort_row_has_child_toggled): Rewrote to be more
+	correct.
+	(gtk_tree_model_sort_row_deleted): ditto.
+	(gtk_tree_model_sort_{un,}ref_node): Fix.
+
+	* gtk/gtktreeview.c: Protean incremental reflow support (commented
+	out)
+
+	* gtk/gtktreeview.h (GtkTreeViewSearchEqualFunc): change char *key
+	to const char *key.
+
+	* gtk/gtktreemodel.c (gtk_tree_row_reference_unref_path_helper):
+	Important 1 line fix to fix a lot of refcounting woes.
+
 2001-10-25  Matt Wilson  <msw@redhat.com>
 
 	* gtk/gtktextview.c (gtk_text_view_destroy): call

ChangeLog.pre-2-2

@@ -1,3 +1,27 @@
+Thu Oct 25 16:27:29 2001  Jonathan Blandford  <jrb@redhat.com>
+
+	* gtk/gtkrbtree.c (_gtk_rbnode_rotate_left): Add support for
+	invalid nodes.
+	 (_gtk_rbnode_rotate_right): Ditto.
+	 (_gtk_rbtree_node_mark_invalid): New function.
+	 (_gtk_rbtree_node_mark_valid): New function.
+
+	* gtk/gtktreemodelsort.c (gtk_tree_model_sort_class_init): We're a
+	GObject, not a GtkObject.
+	(gtk_tree_model_sort_row_has_child_toggled): Rewrote to be more
+	correct.
+	(gtk_tree_model_sort_row_deleted): ditto.
+	(gtk_tree_model_sort_{un,}ref_node): Fix.
+
+	* gtk/gtktreeview.c: Protean incremental reflow support (commented
+	out)
+
+	* gtk/gtktreeview.h (GtkTreeViewSearchEqualFunc): change char *key
+	to const char *key.
+
+	* gtk/gtktreemodel.c (gtk_tree_row_reference_unref_path_helper):
+	Important 1 line fix to fix a lot of refcounting woes.
+
 2001-10-25  Matt Wilson  <msw@redhat.com>
 
 	* gtk/gtktextview.c (gtk_text_view_destroy): call

ChangeLog.pre-2-4

@@ -1,3 +1,27 @@
+Thu Oct 25 16:27:29 2001  Jonathan Blandford  <jrb@redhat.com>
+
+	* gtk/gtkrbtree.c (_gtk_rbnode_rotate_left): Add support for
+	invalid nodes.
+	 (_gtk_rbnode_rotate_right): Ditto.
+	 (_gtk_rbtree_node_mark_invalid): New function.
+	 (_gtk_rbtree_node_mark_valid): New function.
+
+	* gtk/gtktreemodelsort.c (gtk_tree_model_sort_class_init): We're a
+	GObject, not a GtkObject.
+	(gtk_tree_model_sort_row_has_child_toggled): Rewrote to be more
+	correct.
+	(gtk_tree_model_sort_row_deleted): ditto.
+	(gtk_tree_model_sort_{un,}ref_node): Fix.
+
+	* gtk/gtktreeview.c: Protean incremental reflow support (commented
+	out)
+
+	* gtk/gtktreeview.h (GtkTreeViewSearchEqualFunc): change char *key
+	to const char *key.
+
+	* gtk/gtktreemodel.c (gtk_tree_row_reference_unref_path_helper):
+	Important 1 line fix to fix a lot of refcounting woes.
+
 2001-10-25  Matt Wilson  <msw@redhat.com>
 
 	* gtk/gtktextview.c (gtk_text_view_destroy): call

ChangeLog.pre-2-6

@@ -1,3 +1,27 @@
+Thu Oct 25 16:27:29 2001  Jonathan Blandford  <jrb@redhat.com>
+
+	* gtk/gtkrbtree.c (_gtk_rbnode_rotate_left): Add support for
+	invalid nodes.
+	 (_gtk_rbnode_rotate_right): Ditto.
+	 (_gtk_rbtree_node_mark_invalid): New function.
+	 (_gtk_rbtree_node_mark_valid): New function.
+
+	* gtk/gtktreemodelsort.c (gtk_tree_model_sort_class_init): We're a
+	GObject, not a GtkObject.
+	(gtk_tree_model_sort_row_has_child_toggled): Rewrote to be more
+	correct.
+	(gtk_tree_model_sort_row_deleted): ditto.
+	(gtk_tree_model_sort_{un,}ref_node): Fix.
+
+	* gtk/gtktreeview.c: Protean incremental reflow support (commented
+	out)
+
+	* gtk/gtktreeview.h (GtkTreeViewSearchEqualFunc): change char *key
+	to const char *key.
+
+	* gtk/gtktreemodel.c (gtk_tree_row_reference_unref_path_helper):
+	Important 1 line fix to fix a lot of refcounting woes.
+
 2001-10-25  Matt Wilson  <msw@redhat.com>
 
 	* gtk/gtktextview.c (gtk_text_view_destroy): call

ChangeLog.pre-2-8

@@ -1,3 +1,27 @@
+Thu Oct 25 16:27:29 2001  Jonathan Blandford  <jrb@redhat.com>
+
+	* gtk/gtkrbtree.c (_gtk_rbnode_rotate_left): Add support for
+	invalid nodes.
+	 (_gtk_rbnode_rotate_right): Ditto.
+	 (_gtk_rbtree_node_mark_invalid): New function.
+	 (_gtk_rbtree_node_mark_valid): New function.
+
+	* gtk/gtktreemodelsort.c (gtk_tree_model_sort_class_init): We're a
+	GObject, not a GtkObject.
+	(gtk_tree_model_sort_row_has_child_toggled): Rewrote to be more
+	correct.
+	(gtk_tree_model_sort_row_deleted): ditto.
+	(gtk_tree_model_sort_{un,}ref_node): Fix.
+
+	* gtk/gtktreeview.c: Protean incremental reflow support (commented
+	out)
+
+	* gtk/gtktreeview.h (GtkTreeViewSearchEqualFunc): change char *key
+	to const char *key.
+
+	* gtk/gtktreemodel.c (gtk_tree_row_reference_unref_path_helper):
+	Important 1 line fix to fix a lot of refcounting woes.
+
 2001-10-25  Matt Wilson  <msw@redhat.com>
 
 	* gtk/gtktextview.c (gtk_text_view_destroy): call

gtk/gtkrbtree.c

@@ -26,7 +26,7 @@ static GtkRBNode *_gtk_rbnode_new                (GtkRBTree  *tree,
 static void       _gtk_rbnode_free               (GtkRBNode  *node);
 static void       _gtk_rbnode_rotate_left        (GtkRBTree  *tree,
 						  GtkRBNode  *node);
-static void       _gtk_rbnode_rotate_left        (GtkRBTree  *tree,
+static void       _gtk_rbnode_rotate_right       (GtkRBTree  *tree,
 						  GtkRBNode  *node);
 static void       _gtk_rbtree_insert_fixup       (GtkRBTree  *tree,
 						  GtkRBNode  *node);
@@ -207,6 +207,23 @@ _gtk_rbnode_rotate_left (GtkRBTree *tree,
     (right->left?right->left->parity:0) +
     (right->right?right->right->parity:0) +
     (right->children?right->children->root->parity:0);
+
+  if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID))
+    {
+      if ((! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)) &&
+	  (node->right != tree->nil && ! GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+	  (node->left != tree->nil && ! GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+	  (node->children && GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID)))
+	GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID);
+    }
+  if (GTK_RBNODE_FLAG_SET (right, GTK_RBNODE_DESCENDANTS_INVALID))
+    {
+      if ((! GTK_RBNODE_FLAG_SET (right, GTK_RBNODE_INVALID)) &&
+	  (right->right != tree->nil && ! GTK_RBNODE_FLAG_SET (right->right, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+	  (right->left != tree->nil && ! GTK_RBNODE_FLAG_SET (right->left, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+	  (right->children && GTK_RBNODE_FLAG_SET (right->children->root, GTK_RBNODE_DESCENDANTS_INVALID)))
+	GTK_RBNODE_UNSET_FLAG (right, GTK_RBNODE_DESCENDANTS_INVALID);
+    }
 }
 
 static void
@@ -282,6 +299,23 @@ _gtk_rbnode_rotate_right (GtkRBTree *tree,
     (left->left?left->left->parity:0) +
     (left->right?left->right->parity:0) +
     (left->children?left->children->root->parity:0);
+
+  if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID))
+    {
+      if ((! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)) &&
+	  (node->right != tree->nil && ! GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+	  (node->left != tree->nil && ! GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+	  (node->children && GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID)))
+	GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID);
+    }
+  if (GTK_RBNODE_FLAG_SET (left, GTK_RBNODE_DESCENDANTS_INVALID))
+    {
+      if ((! GTK_RBNODE_FLAG_SET (left, GTK_RBNODE_INVALID)) &&
+	  (left->right != tree->nil && ! GTK_RBNODE_FLAG_SET (left->right, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+	  (left->left != tree->nil && ! GTK_RBNODE_FLAG_SET (left->left, GTK_RBNODE_DESCENDANTS_INVALID)) &&
+	  (left->children && GTK_RBNODE_FLAG_SET (left->children->root, GTK_RBNODE_DESCENDANTS_INVALID)))
+	GTK_RBNODE_UNSET_FLAG (left, GTK_RBNODE_DESCENDANTS_INVALID);
+    }
 }
 
 static void
@@ -714,6 +748,56 @@ _gtk_rbtree_node_set_height (GtkRBTree *tree,
     }
 }
 
+void
+_gtk_rbtree_node_mark_invalid (GtkRBTree *tree,
+			       GtkRBNode *node)
+{
+  if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID))
+    return;
+
+  GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_INVALID);
+  do
+    {
+      if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID))
+	return;
+      GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID);
+      node = node->parent;
+      if (node == NULL)
+	{
+	  node = tree->parent_node;
+	  tree = tree->parent_tree;
+	}
+    }
+  while (node);
+}
+
+void
+_gtk_rbtree_node_mark_valid (GtkRBTree *tree,
+			     GtkRBNode *node)
+{
+  if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID))
+    return;
+
+  GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_INVALID);
+  do
+    {
+      if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
+	  (node->children && GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID)) ||
+	  (node->left && GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)) ||
+	  (node->right && GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID)))
+	return;
+	  
+      GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID);
+      node = node->parent;
+      if (node == NULL)
+	{
+	  node = tree->parent_node;
+	  tree = tree->parent_tree;
+	}
+    }
+  while (node);
+}
+
 typedef struct _GtkRBReorder
 {
   GtkRBTree *children;

gtk/gtkrbtree.h

@@ -36,7 +36,9 @@ typedef enum
   GTK_RBNODE_IS_PRELIT = 1 << 4,
   GTK_RBNODE_IS_SEMI_COLLAPSED = 1 << 5,
   GTK_RBNODE_IS_SEMI_EXPANDED = 1 << 6,
-  GTK_RBNODE_NON_COLORS = GTK_RBNODE_IS_PARENT | GTK_RBNODE_IS_SELECTED | GTK_RBNODE_IS_PRELIT | GTK_RBNODE_IS_SEMI_COLLAPSED | GTK_RBNODE_IS_SEMI_EXPANDED
+  GTK_RBNODE_INVALID = 1 << 7,
+  GTK_RBNODE_DESCENDANTS_INVALID = 1 << 8,
+  GTK_RBNODE_NON_COLORS = GTK_RBNODE_IS_PARENT | GTK_RBNODE_IS_SELECTED | GTK_RBNODE_IS_PRELIT | GTK_RBNODE_IS_SEMI_COLLAPSED | GTK_RBNODE_IS_SEMI_EXPANDED | GTK_RBNODE_INVALID | GTK_RBNODE_DESCENDANTS_INVALID
 } GtkRBNodeColor;
 
 typedef struct _GtkRBTree GtkRBTree;
@@ -121,6 +123,10 @@ GtkRBNode *_gtk_rbtree_find_count       (GtkRBTree              *tree,
 void       _gtk_rbtree_node_set_height  (GtkRBTree              *tree,
 					 GtkRBNode              *node,
 					 gint                    height);
+void       _gtk_rbtree_node_mark_invalid(GtkRBTree              *tree,
+					 GtkRBNode              *node);
+void       _gtk_rbtree_node_mark_valid  (GtkRBTree              *tree,
+					 GtkRBNode              *node);
 gint       _gtk_rbtree_node_find_offset (GtkRBTree              *tree,
 					 GtkRBNode              *node);
 gint       _gtk_rbtree_node_find_parity (GtkRBTree              *tree,

gtk/gtktreemodel.c

@@ -1403,7 +1403,7 @@ gtk_tree_row_reference_unref_path_helper (GtkTreePath  *path,
   if (path->depth == depth)
     return;
 
-  gtk_tree_model_iter_nth_child (model, &iter, NULL, path->indices[depth]);
+  gtk_tree_model_iter_nth_child (model, &iter, parent_iter, path->indices[depth]);
   gtk_tree_row_reference_unref_path_helper (path, model, &iter, depth + 1, free_last);
   gtk_tree_model_unref_node (model, &iter);
 }

gtk/gtktreemodelsort.c

@@ -106,7 +106,6 @@ static void gtk_tree_model_sort_rows_reordered        (GtkTreeModel          *s_
 						       GtkTreeIter           *s_iter,
 						       gint                  *new_order,
 						       gpointer               data);
-static void gtk_tree_model_sort_destroy               (GtkObject             *gobject);
 
 static void gtk_tree_model_sort_row_changed           (GtkTreeModel          *model,
 						       GtkTreePath           *start_path,
@@ -214,6 +213,9 @@ static void         get_child_iter_from_elt               (GtkTreeModelSort *tre
 							   SortElt          *elt);
 static void         gtk_tree_model_sort_set_model         (GtkTreeModelSort *tree_model_sort,
 							   GtkTreeModel     *child_model);
+static GtkTreePath *gtk_real_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort,
+									 GtkTreePath      *child_path,
+									 gboolean          build_levels);
 
 
 GType
@@ -279,13 +281,10 @@ static void
 gtk_tree_model_sort_class_init (GtkTreeModelSortClass *class)
 {
   GObjectClass *object_class;
-  GtkObjectClass *gobject_class;
 
   object_class = (GObjectClass *) class;
-  gobject_class = (GtkObjectClass *) class;
 
   object_class->finalize = gtk_tree_model_sort_finalize;
-  gobject_class->destroy = gtk_tree_model_sort_destroy;
 }
 
 static void
@@ -345,6 +344,8 @@ gtk_tree_model_sort_finalize (GObject *object)
 {
   GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) object;
 
+  gtk_tree_model_sort_set_model (tree_model_sort, NULL);
+
   if (tree_model_sort->root)
     gtk_tree_model_sort_free_level (tree_model_sort, tree_model_sort->root);
 
@@ -355,16 +356,6 @@ gtk_tree_model_sort_finalize (GObject *object)
     }
 }
 
-/* GtkObject callbacks */
-static void
-gtk_tree_model_sort_destroy (GtkObject *gobject)
-{
-  GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) gobject;
-
-  if (tree_model_sort->child_model)
-    gtk_tree_model_sort_set_model (tree_model_sort, NULL);
-}
-
 static void
 gtk_tree_model_sort_row_changed (GtkTreeModel *s_model,
 				 GtkTreePath  *start_s_path,
@@ -604,39 +595,17 @@ gtk_tree_model_sort_row_has_child_toggled (GtkTreeModel *s_model,
   GtkTreeModelSort *tree_model_sort = GTK_TREE_MODEL_SORT (data);
   GtkTreePath *path;
   GtkTreeIter iter;
-  gboolean free_s_path = FALSE;
 
-  g_return_if_fail (s_path != NULL || s_iter != NULL);
+  g_return_if_fail (s_path != NULL && s_iter != NULL);
 
-  /* we don't handle signals which we don't cover */
+  path = gtk_real_tree_model_sort_convert_child_path_to_path (tree_model_sort, s_path, FALSE);
-  if (!tree_model_sort->root)
+  if (path == NULL)
-    return;
-
-  if (!s_path)
-    {
-      s_path = gtk_tree_model_get_path (s_model, s_iter);
-      free_s_path = TRUE;
-    }
-
-  path = gtk_tree_model_sort_convert_child_path_to_path (tree_model_sort,
-							 s_path);
-  if (!path)
     return;
   
   gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
-  gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data), path,
+  gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data), path, &iter);
-					&iter);
-  gtk_tree_path_free (path);
 
-  if (!GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort))
+  gtk_tree_path_free (path);
-    {
-      gtk_tree_model_sort_free_level (tree_model_sort,
-				      SORT_LEVEL (tree_model_sort->root));
-      tree_model_sort->root = NULL;
-    }
-  
-  if (free_s_path)
-    gtk_tree_path_free (s_path);
 }
 
 static void
@@ -646,63 +615,58 @@ gtk_tree_model_sort_row_deleted (GtkTreeModel *s_model,
 {
   GtkTreeModelSort *tree_model_sort = GTK_TREE_MODEL_SORT (data);
   GtkTreePath *path = NULL;
+  SortElt *elt;
+  SortLevel *level;
+  GtkTreeIter iter;
+  gint offset;
+  gint i;
+  
+  g_return_if_fail (s_path != NULL);
 
-  /* we don't handle signals which we don't cover */
+  path = gtk_real_tree_model_sort_convert_child_path_to_path (tree_model_sort, s_path, FALSE);
-  if (!tree_model_sort->root)
+  if (path == NULL)
     return;
 
-  g_return_if_fail (s_path != NULL);
+  g_print ("path to be deleted: %s\n", gtk_tree_path_to_string (path));
-  path = gtk_tree_model_sort_convert_child_path_to_path (tree_model_sort,
+  gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
-							 s_path);
 
-  if (!path)
+  level = SORT_LEVEL (iter.user_data);
+  elt = SORT_ELT (iter.user_data2);
+  offset = elt->offset;
+
+  while (elt->ref_count > 0)
+    gtk_tree_model_sort_unref_node (GTK_TREE_MODEL (data), &iter);
+
+  if (level->ref_count == 0)
     {
-      /* we don't cover this signal */
+      /* This will prune the level, so I can just emit the signal and not worry
+       * about cleaning this level up. */
+      gtk_tree_model_sort_increment_stamp (tree_model_sort);
+      gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
+
+      gtk_tree_path_free (path);
       return;
     }
-  
-  if (!GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort))
-    {
-      gtk_tree_model_sort_free_level (tree_model_sort,
-				      SORT_LEVEL (tree_model_sort->root));
-      tree_model_sort->root = NULL;
-    }
-  else
-    {
-      SortElt *elt;
-      SortLevel *level;
-      GtkTreeIter iter;
-      gint offset;
-      gint i;
-      
-      gtk_tree_model_get_iter (GTK_TREE_MODEL (data),
-			       &iter, path);
-      g_return_if_fail (tree_model_sort->stamp == iter.stamp);
-      level = SORT_LEVEL (iter.user_data);
-      elt = SORT_ELT (iter.user_data2);
-      offset = elt->offset;
 
-      for (i = 0; i < level->array->len; i++)
+  /* Remove the row */
-	if (elt->offset == g_array_index (level->array, SortElt, i).offset)
+  for (i = 0; i < level->array->len; i++)
-	  break;
+    if (elt->offset == g_array_index (level->array, SortElt, i).offset)
+      break;
+
+  g_array_remove_index (level->array, i);
       
-      g_array_remove_index (level->array, i);
+  /* update all offsets */
-      level->ref_count--;
+  for (i = 0; i < level->array->len; i++)
-      
+    {
-      /* update all offsets */
+      elt = & (g_array_index (level->array, SortElt, i));
-      for (i = 0; i < level->array->len; i++)
+      if (elt->offset > offset)
-	    {
+	elt->offset--;
-	      elt = & (g_array_index (level->array, SortElt, i));
-	      if (elt->offset > offset)
-		elt->offset--;
-	    }
     }
-  
+
   gtk_tree_model_sort_increment_stamp (tree_model_sort);
   gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
 
-  if (path)
+  gtk_tree_path_free (path);
-    gtk_tree_path_free (path);
 }
 
 static void
@@ -716,22 +680,15 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model,
   int len;
   SortElt *elt;
   SortLevel *level;
-  gboolean free_s_path = FALSE;
   
   GtkTreeIter  iter;
   GtkTreePath *path;
 
   GtkTreeModelSort *tree_model_sort = GTK_TREE_MODEL_SORT (data);
   
-  g_return_if_fail (s_path != NULL || s_iter != NULL);
+  g_return_if_fail (s_path != NULL && s_iter != NULL);
   g_return_if_fail (new_order != NULL);
 
-  if (!s_path)
-    {
-      s_path = gtk_tree_model_get_path (s_model, s_iter);
-      free_s_path = TRUE;
-    }
-
   if (!gtk_tree_path_get_indices (s_path))
     len = gtk_tree_model_iter_n_children (s_model, NULL);
   else
@@ -739,8 +696,6 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model,
 
   if (len < 2)
     {
-      if (free_s_path)
-	gtk_tree_path_free (s_path);
       return;
     }
 
@@ -755,16 +710,12 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model,
       
       if (!path)
 	{
-	  if (free_s_path)
-	    gtk_tree_path_free (s_path);
 	  return;
 	}
 
       if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path))
 	{
 	  /* no iter for me */
-	  if (free_s_path)
-	    gtk_tree_path_free (s_path);
 	  gtk_tree_path_free (path);
 	  return;
 	}
@@ -785,18 +736,12 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model,
 
   if (!level)
     {
-      if (free_s_path)
-	gtk_tree_path_free (s_path);
-
       /* ignore signal */
       return;
     }
 
   if (len != level->array->len)
     {
-      if (free_s_path)
-	gtk_tree_path_free (s_path);
-
       /* length mismatch, pretty bad, shouldn't happen */
       
       return;
@@ -810,9 +755,6 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model,
 
       if (!path)
 	{
-	  if (free_s_path)
-	    gtk_tree_path_free (s_path);
-	  
 	  return;
 	}
       
@@ -849,9 +791,6 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model,
       
       gtk_tree_path_free (path);
       
-      if (free_s_path)
-	gtk_tree_path_free (s_path);
-
       return;
     }
 
@@ -862,8 +801,6 @@ gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model,
 
   gtk_tree_model_sort_increment_stamp (tree_model_sort);
 
-  if (free_s_path)
-    gtk_tree_path_free (s_path);
 }
 
 /* Fulfill our model requirements */
@@ -885,7 +822,7 @@ gtk_tree_model_sort_get_n_columns (GtkTreeModel *tree_model)
   if (tree_model_sort->child_model == 0)
     return 0;
 
-  return gtk_tree_model_get_n_columns (GTK_TREE_MODEL_SORT (tree_model)->child_model);
+  return gtk_tree_model_get_n_columns (tree_model_sort->child_model);
 }
 
 static GType
@@ -1017,13 +954,13 @@ gtk_tree_model_sort_iter_children (GtkTreeModel *tree_model,
   GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model;
   SortLevel *level;
 
+  iter->stamp = 0;
   g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model), FALSE);
   g_return_val_if_fail (tree_model_sort->child_model != NULL, FALSE);
   if (parent) g_return_val_if_fail (tree_model_sort->stamp == parent->stamp, FALSE);
 
   if (parent == NULL)
     {
-
       if (tree_model_sort->root == NULL)
 	gtk_tree_model_sort_build_level (tree_model_sort, NULL, NULL);
       if (tree_model_sort->root == NULL)
@@ -1090,21 +1027,30 @@ gtk_tree_model_sort_iter_nth_child (GtkTreeModel *tree_model,
 				    gint          n)
 {
   SortLevel *level;
+  /* We have this for the iter == parent case */
+  GtkTreeIter children;
 
   g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model), FALSE);
-  g_return_val_if_fail (GTK_TREE_MODEL_SORT (tree_model)->child_model != NULL, FALSE);
+  if (parent) g_return_val_if_fail (GTK_TREE_MODEL_SORT (tree_model)->stamp == parent->stamp, FALSE);
 
-  if (gtk_tree_model_sort_iter_children (tree_model, iter, parent) == FALSE)
+  /* Use this instead of has_child to force us to build the level, if needed */
-    return FALSE;
+  if (gtk_tree_model_sort_iter_children (tree_model, &children, parent) == FALSE)
+    {
+      iter->stamp = 0;
+      return FALSE;
+    }
 
-  level = iter->user_data;
+  level = children.user_data;
   if (n >= level->array->len)
     {
       iter->stamp = 0;
       return FALSE;
     }
 
+  iter->stamp = GTK_TREE_MODEL_SORT (tree_model)->stamp;
+  iter->user_data = level;
   iter->user_data2 = &g_array_index (level->array, SortElt, n);
+
   return TRUE;
 }
 
@@ -1115,6 +1061,7 @@ gtk_tree_model_sort_iter_parent (GtkTreeModel *tree_model,
 {
   SortLevel *level;
 
+  iter->stamp = 0;
   g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model), FALSE);
   g_return_val_if_fail (GTK_TREE_MODEL_SORT (tree_model)->child_model != NULL, FALSE);
   g_return_val_if_fail (GTK_TREE_MODEL_SORT (tree_model)->stamp == child->stamp, FALSE);
@@ -1186,27 +1133,24 @@ gtk_tree_model_sort_unref_node (GtkTreeModel *tree_model,
   level = iter->user_data;
   elt = iter->user_data2;
 
+  g_return_if_fail (elt->ref_count > 0);
+
   elt->ref_count--;
   level->ref_count--;
   if (level->ref_count == 0)
     {
       SortLevel *parent_level = level->parent_level;
       SortElt *parent_elt = level->parent_elt;
+
       /* We were at zero -- time to decrement the zero_ref_count val */
-      do
+      while (parent_level)
 	{
-	  if (parent_elt)
+	  parent_elt->zero_ref_count++;
-	    parent_elt->zero_ref_count++;
-	  else
-	    tree_model_sort->zero_ref_count++;
 	  
-	  if (parent_level)
+	  parent_elt = parent_level->parent_elt;
-	    {
+	  parent_level = parent_level->parent_level;
-	      parent_elt = parent_level->parent_elt;
-	      parent_level = parent_level->parent_level;
-	    }
 	}
-      while (parent_level);
+      tree_model_sort->zero_ref_count++;
     }
 }
 
@@ -1856,6 +1800,7 @@ gtk_tree_model_sort_set_model (GtkTreeModelSort *tree_model_sort,
       GType *types;
       gint i, n_columns;
 
+      g_object_ref (tree_model_sort->child_model);
       tree_model_sort->changed_id =
         g_signal_connect (child_model, "row_changed",
                           G_CALLBACK (gtk_tree_model_sort_row_changed),
@@ -1909,21 +1854,10 @@ gtk_tree_model_sort_get_model (GtkTreeModelSort  *tree_model)
 }
 
 
-/**
+static GtkTreePath *
- * gtk_tree_model_sort_convert_child_path_to_path:
+gtk_real_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort,
- * @tree_model_sort: A #GtkTreeModelSort
+						     GtkTreePath      *child_path,
- * @child_path: A #GtkTreePath to convert
+						     gboolean          build_levels)
- * 
- * Converts @child_path to a path relative to @tree_model_sort.  That is,
- * @child_path points to a path in the child model.  The returned path will
- * point to the same row in the sorted model.  If @child_path isn't a valid path
- * on the child model, then %NULL is returned.
- * 
- * Return value: A newly allocated #GtkTreePath, or %NULL
- **/
-GtkTreePath *
-gtk_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort,
-						GtkTreePath      *child_path)
 {
   gint *child_indices;
   GtkTreePath *retval;
@@ -1937,7 +1871,10 @@ gtk_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sor
   retval = gtk_tree_path_new ();
   child_indices = gtk_tree_path_get_indices (child_path);
 
+  if (tree_model_sort->root == NULL && build_levels)
+    gtk_tree_model_sort_build_level (tree_model_sort, NULL, NULL);
   level = SORT_LEVEL (tree_model_sort->root);
+    
   for (i = 0; i < gtk_tree_path_get_depth (child_path); i++)
     {
       gint j;
@@ -1959,6 +1896,8 @@ gtk_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sor
 	  if ((g_array_index (level->array, SortElt, j)).offset == child_indices[i])
 	    {
 	      gtk_tree_path_append_index (retval, j);
+	      if (g_array_index (level->array, SortElt, j).children == NULL && build_levels)
+		gtk_tree_model_sort_build_level (tree_model_sort, level, &g_array_index (level->array, SortElt, j));
 	      level = g_array_index (level->array, SortElt, j).children;
 	      found_child = TRUE;
 	      break;
@@ -1974,6 +1913,30 @@ gtk_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sor
   return retval;
 }
 
+
+/**
+ * gtk_tree_model_sort_convert_child_path_to_path:
+ * @tree_model_sort: A #GtkTreeModelSort
+ * @child_path: A #GtkTreePath to convert
+ * 
+ * Converts @child_path to a path relative to @tree_model_sort.  That is,
+ * @child_path points to a path in the child model.  The returned path will
+ * point to the same row in the sorted model.  If @child_path isn't a valid path
+ * on the child model, then %NULL is returned.
+ * 
+ * Return value: A newly allocated #GtkTreePath, or %NULL
+ **/
+GtkTreePath *
+gtk_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort,
+						GtkTreePath      *child_path)
+{
+  g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model_sort), NULL);
+  g_return_val_if_fail (tree_model_sort->child_model != NULL, NULL);
+  g_return_val_if_fail (child_path != NULL, NULL);
+
+  return gtk_real_tree_model_sort_convert_child_path_to_path (tree_model_sort, child_path, TRUE);
+}
+
 /**
  * gtk_tree_model_sort_convert_child_iter_to_iter:
  * @tree_model_sort: A #GtkTreeModelSort
@@ -2202,6 +2165,7 @@ gtk_tree_model_sort_free_level (GtkTreeModelSort *tree_model_sort,
 
   g_assert (sort_level);
 
+  g_print ("freeing a level\n");
   if (sort_level->ref_count == 0)
     {
       SortLevel *parent_level = sort_level->parent_level;
@@ -2245,7 +2209,8 @@ gtk_tree_model_sort_free_level (GtkTreeModelSort *tree_model_sort,
 static void
 gtk_tree_model_sort_increment_stamp (GtkTreeModelSort *tree_model_sort)
 {
-  tree_model_sort->stamp++;
+  while (tree_model_sort->stamp == 0) tree_model_sort->stamp++;
+
   gtk_tree_model_sort_clear_cache (tree_model_sort);
 }
 

gtk/gtktreeview.c

@@ -360,13 +360,13 @@ static void     gtk_tree_view_search_move               (GtkWidget        *windo
 							 gboolean          up);
 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 							 gint              column,
-							 gchar            *key,
+							 const gchar      *key,
 							 GtkTreeIter      *iter,
 							 gpointer          search_data);
 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 							 GtkTreeSelection *selection,
 							 GtkTreeIter      *iter,
-							 gchar            *text,
+							 const gchar      *text,
 							 gint             *count,
 							 gint              n);
 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
@@ -2978,7 +2978,41 @@ gtk_tree_view_focus_out (GtkWidget     *widget,
   return FALSE;
 }
 
+/* Incremental Reflow */
+#if 0
+static void
+validate_visible_area (GtkTreeView *tree_view)
+{
 
+}
+
+static gboolean
+validate_rows_handler (GtkTreeView *tree_view)
+{
+  g_assert (tree_view);
+
+  g_return_val_if_fail (tree_view->priv->tree != NULL, TRUE);
+
+  if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
+    return TRUE;
+
+
+  return TRUE;
+}
+
+static gboolean
+presize_handler_callback (gpointer data)
+{
+
+  return TRUE;
+}
+
+static void
+install_presize_handler (GtkTreeView *tree_view)
+{
+
+}
+#endif
 /* Drag-and-drop */
 
 static void
@@ -4480,7 +4514,7 @@ gtk_tree_view_row_inserted (GtkTreeModel *model,
   if (free_path)
     gtk_tree_path_free (path);
 }
-
+#include "gtktreemodelsort.h"
 static void
 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
 				     GtkTreePath  *path,
@@ -9042,7 +9076,7 @@ gtk_tree_view_search_move (GtkWidget   *window,
 static gboolean
 gtk_tree_view_search_equal_func (GtkTreeModel *model,
 				 gint          column,
-				 gchar        *key,
+				 const gchar  *key,
 				 GtkTreeIter  *iter,
 				 gpointer      search_data)
 {
@@ -9078,7 +9112,7 @@ static gboolean
 gtk_tree_view_search_iter (GtkTreeModel     *model,
 			   GtkTreeSelection *selection,
 			   GtkTreeIter      *iter,
-			   gchar            *text,
+			   const gchar      *text,
 			   gint             *count,
 			   gint              n)
 {
@@ -9195,7 +9229,7 @@ gtk_tree_view_search_init (GtkWidget   *entry,
   gint *selected_iter;
   gint len;
   gint count = 0;
-  gchar *text;
+  const gchar *text;
   GtkWidget *window;
   GtkTreeIter iter;
   GtkTreeModel *model;

gtk/gtktreeview.h

@@ -121,7 +121,7 @@ typedef gboolean (* GtkTreeViewDroppableFunc)  (GtkTreeView             *tree_vi
 						gpointer                 user_data);
 typedef gboolean (*GtkTreeViewSearchEqualFunc) (GtkTreeModel            *model,
 						gint                     column,
-						gchar                   *key,
+						const gchar             *key,
 						GtkTreeIter             *iter,
 						gpointer                 search_data);