X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtktreestore.c;h=21e7a205d95a941ab9e429cd1b9a649da6cf2b1e;hb=190dcfe050814e979c364bf74ae83530aba4c686;hp=4570007018d9b3481074d0ee71140f1d2a621726;hpb=0a07e9733bb259598a09515a3e4cdbcda5feef57;p=~andy%2Fgtk

diff --git a/gtk/gtktreestore.c b/gtk/gtktreestore.c
index 457000701..21e7a205d 100644
--- a/gtk/gtktreestore.c
+++ b/gtk/gtktreestore.c
@@ -12,9 +12,7 @@
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "config.h"
@@ -25,12 +23,64 @@
 #include "gtktreedatalist.h"
 #include "gtktreednd.h"
 #include "gtkbuildable.h"
+#include "gtkdebug.h"
 #include "gtkintl.h"
 
 
+/**
+ * SECTION:gtktreestore
+ * @Short_description: A tree-like data structure that can be used with the GtkTreeView
+ * @Title: GtkTreeStore
+ * @See_also: #GtkTreeModel
+ *
+ * The #GtkTreeStore object is a list model for use with a #GtkTreeView
+ * widget.  It implements the #GtkTreeModel interface, and consequentialy,
+ * can use all of the methods available there.  It also implements the
+ * #GtkTreeSortable interface so it can be sorted by the view.  Finally,
+ * it also implements the tree <link linkend="gtktreednd">drag and
+ * drop</link> interfaces.
+ *
+ * <refsect2 id="GtkTreeStore-BUILDER-UI">
+ * <title>GtkTreeStore as GtkBuildable</title>
+ * The GtkTreeStore implementation of the #GtkBuildable interface allows
+ * to specify the model columns with a &lt;columns&gt; element that may
+ * contain multiple &lt;column&gt; elements, each specifying one model
+ * column. The "type" attribute specifies the data type for the column.
+ * <example>
+ * <title>A UI Definition fragment for a tree store</title>
+ * <programlisting><![CDATA[
+ * <object class="GtkTreeStore">
+ *   <columns>
+ *     <column type="gchararray"/>
+ *     <column type="gchararray"/>
+ *     <column type="gint"/>
+ *   </columns>
+ * </object>
+ * ]]></programlisting>
+ * </example>
+ * </refsect2>
+ */
+
+struct _GtkTreeStorePrivate
+{
+  gint stamp;
+  gpointer root;
+  gpointer last;
+  gint n_columns;
+  gint sort_column_id;
+  GList *sort_list;
+  GtkSortType order;
+  GType *column_headers;
+  GtkTreeIterCompareFunc default_sort_func;
+  gpointer default_sort_data;
+  GDestroyNotify default_sort_destroy;
+  guint columns_dirty : 1;
+};
+
+
 #define G_NODE(node) ((GNode *)node)
-#define GTK_TREE_STORE_IS_SORTED(tree) (((GtkTreeStore*)(tree))->sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
-#define VALID_ITER(iter, tree_store) ((iter)!= NULL && (iter)->user_data != NULL && ((GtkTreeStore*)(tree_store))->stamp == (iter)->stamp)
+#define GTK_TREE_STORE_IS_SORTED(tree) (((GtkTreeStore*)(tree))->priv->sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
+#define VALID_ITER(iter, tree_store) ((iter)!= NULL && (iter)->user_data != NULL && ((GtkTreeStore*)(tree_store))->priv->stamp == (iter)->stamp)
 
 static void         gtk_tree_store_tree_model_init (GtkTreeModelIface *iface);
 static void         gtk_tree_store_drag_source_init(GtkTreeDragSourceIface *iface);
@@ -53,6 +103,8 @@ static void         gtk_tree_store_get_value       (GtkTreeModel      *tree_mode
 						    GValue            *value);
 static gboolean     gtk_tree_store_iter_next       (GtkTreeModel      *tree_model,
 						    GtkTreeIter       *iter);
+static gboolean     gtk_tree_store_iter_previous   (GtkTreeModel      *tree_model,
+						    GtkTreeIter       *iter);
 static gboolean     gtk_tree_store_iter_children   (GtkTreeModel      *tree_model,
 						    GtkTreeIter       *iter,
 						    GtkTreeIter       *parent);
@@ -143,11 +195,11 @@ static void     gtk_tree_store_move                    (GtkTreeStore           *
 static inline void
 validate_tree (GtkTreeStore *tree_store)
 {
-  if (gtk_debug_flags & GTK_DEBUG_TREE)
+  if (gtk_get_debug_flags () & GTK_DEBUG_TREE)
     {
-      g_assert (G_NODE (tree_store->root)->parent == NULL);
+      g_assert (G_NODE (tree_store->priv->root)->parent == NULL);
 
-      validate_gnode (G_NODE (tree_store->root));
+      validate_gnode (G_NODE (tree_store->priv->root));
     }
 }
 
@@ -171,6 +223,8 @@ gtk_tree_store_class_init (GtkTreeStoreClass *class)
   object_class = (GObjectClass *) class;
 
   object_class->finalize = gtk_tree_store_finalize;
+
+  g_type_class_add_private (class, sizeof (GtkTreeStorePrivate));
 }
 
 static void
@@ -183,6 +237,7 @@ gtk_tree_store_tree_model_init (GtkTreeModelIface *iface)
   iface->get_path = gtk_tree_store_get_path;
   iface->get_value = gtk_tree_store_get_value;
   iface->iter_next = gtk_tree_store_iter_next;
+  iface->iter_previous = gtk_tree_store_iter_previous;
   iface->iter_children = gtk_tree_store_iter_children;
   iface->iter_has_child = gtk_tree_store_iter_has_child;
   iface->iter_n_children = gtk_tree_store_iter_n_children;
@@ -225,28 +280,33 @@ gtk_tree_store_buildable_init (GtkBuildableIface *iface)
 static void
 gtk_tree_store_init (GtkTreeStore *tree_store)
 {
-  tree_store->root = g_node_new (NULL);
-  /* While the odds are against us getting 0...
-   */
+  GtkTreeStorePrivate *priv;
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_store,
+                                      GTK_TYPE_TREE_STORE,
+                                      GtkTreeStorePrivate);
+  tree_store->priv = priv;
+  priv->root = g_node_new (NULL);
+  /* While the odds are against us getting 0...  */
   do
     {
-      tree_store->stamp = g_random_int ();
+      priv->stamp = g_random_int ();
     }
-  while (tree_store->stamp == 0);
+  while (priv->stamp == 0);
 
-  tree_store->sort_list = NULL;
-  tree_store->sort_column_id = GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID;
-  tree_store->columns_dirty = FALSE;
+  priv->sort_list = NULL;
+  priv->sort_column_id = GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID;
+  priv->columns_dirty = FALSE;
 }
 
 /**
  * gtk_tree_store_new:
  * @n_columns: number of columns in the tree store
- * @Varargs: all #GType types for the columns, from first to last
+ * @...: all #GType types for the columns, from first to last
  *
  * Creates a new tree store as with @n_columns columns each of the types passed
- * in.  Note that only types derived from standard GObject fundamental types 
- * are supported. 
+ * in.  Note that only types derived from standard GObject fundamental types
+ * are supported.
  *
  * As an example, <literal>gtk_tree_store_new (3, G_TYPE_INT, G_TYPE_STRING,
  * GDK_TYPE_PIXBUF);</literal> will create a new #GtkTreeStore with three columns, of type
@@ -292,7 +352,8 @@ gtk_tree_store_new (gint n_columns,
  *
  * Non vararg creation function.  Used primarily by language bindings.
  *
- * Return value: a new #GtkTreeStore
+ * Return value: (transfer full): a new #GtkTreeStore
+ * Rename to: gtk_tree_store_new
  **/
 GtkTreeStore *
 gtk_tree_store_newv (gint   n_columns,
@@ -340,7 +401,7 @@ gtk_tree_store_set_column_types (GtkTreeStore *tree_store,
   gint i;
 
   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
-  g_return_if_fail (tree_store->columns_dirty == 0);
+  g_return_if_fail (tree_store->priv->columns_dirty == 0);
 
   gtk_tree_store_set_n_columns (tree_store, n_columns);
    for (i = 0; i < n_columns; i++)
@@ -358,20 +419,21 @@ static void
 gtk_tree_store_set_n_columns (GtkTreeStore *tree_store,
 			      gint          n_columns)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   int i;
 
-  if (tree_store->n_columns == n_columns)
+  if (priv->n_columns == n_columns)
     return;
 
-  tree_store->column_headers = g_renew (GType, tree_store->column_headers, n_columns);
-  for (i = tree_store->n_columns; i < n_columns; i++)
-    tree_store->column_headers[i] = G_TYPE_INVALID;
-  tree_store->n_columns = n_columns;
+  priv->column_headers = g_renew (GType, priv->column_headers, n_columns);
+  for (i = priv->n_columns; i < n_columns; i++)
+    priv->column_headers[i] = G_TYPE_INVALID;
+  priv->n_columns = n_columns;
 
-  if (tree_store->sort_list)
-    _gtk_tree_data_list_header_free (tree_store->sort_list);
+  if (priv->sort_list)
+    _gtk_tree_data_list_header_free (priv->sort_list);
 
-  tree_store->sort_list = _gtk_tree_data_list_header_new (n_columns, tree_store->column_headers);
+  priv->sort_list = _gtk_tree_data_list_header_new (n_columns, priv->column_headers);
 }
 
 /**
@@ -391,12 +453,14 @@ gtk_tree_store_set_column_type (GtkTreeStore *tree_store,
 				gint          column,
 				GType         type)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
+
   if (!_gtk_tree_data_list_check_type (type))
     {
       g_warning ("%s: Invalid type %s\n", G_STRLOC, g_type_name (type));
       return;
     }
-  tree_store->column_headers[column] = type;
+  priv->column_headers[column] = type;
 }
 
 static gboolean
@@ -413,20 +477,21 @@ static void
 gtk_tree_store_finalize (GObject *object)
 {
   GtkTreeStore *tree_store = GTK_TREE_STORE (object);
+  GtkTreeStorePrivate *priv = tree_store->priv;
 
-  g_node_traverse (tree_store->root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
-		   node_free, tree_store->column_headers);
-  g_node_destroy (tree_store->root);
-  _gtk_tree_data_list_header_free (tree_store->sort_list);
-  g_free (tree_store->column_headers);
+  g_node_traverse (priv->root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
+		   node_free, priv->column_headers);
+  g_node_destroy (priv->root);
+  _gtk_tree_data_list_header_free (priv->sort_list);
+  g_free (priv->column_headers);
 
-  if (tree_store->default_sort_destroy)
+  if (priv->default_sort_destroy)
     {
-      GDestroyNotify d = tree_store->default_sort_destroy;
+      GDestroyNotify d = priv->default_sort_destroy;
 
-      tree_store->default_sort_destroy = NULL;
-      d (tree_store->default_sort_data);
-      tree_store->default_sort_data = NULL;
+      priv->default_sort_destroy = NULL;
+      d (priv->default_sort_data);
+      priv->default_sort_data = NULL;
     }
 
   /* must chain up */
@@ -450,10 +515,11 @@ static gint
 gtk_tree_store_get_n_columns (GtkTreeModel *tree_model)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
+  GtkTreeStorePrivate *priv = tree_store->priv;
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
-  return tree_store->n_columns;
+  return priv->n_columns;
 }
 
 static GType
@@ -461,12 +527,13 @@ gtk_tree_store_get_column_type (GtkTreeModel *tree_model,
 				gint          index)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
+  GtkTreeStorePrivate *priv = tree_store->priv;
 
-  g_return_val_if_fail (index < tree_store->n_columns, G_TYPE_INVALID);
+  g_return_val_if_fail (index < priv->n_columns, G_TYPE_INVALID);
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
-  return tree_store->column_headers[index];
+  return priv->column_headers[index];
 }
 
 static gboolean
@@ -475,28 +542,35 @@ gtk_tree_store_get_iter (GtkTreeModel *tree_model,
 			 GtkTreePath  *path)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreeIter parent;
   gint *indices;
   gint depth, i;
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
   indices = gtk_tree_path_get_indices (path);
   depth = gtk_tree_path_get_depth (path);
 
   g_return_val_if_fail (depth > 0, FALSE);
 
-  parent.stamp = tree_store->stamp;
-  parent.user_data = tree_store->root;
+  parent.stamp = priv->stamp;
+  parent.user_data = priv->root;
 
   if (!gtk_tree_store_iter_nth_child (tree_model, iter, &parent, indices[0]))
-    return FALSE;
+    {
+      iter->stamp = 0;
+      return FALSE;
+    }
 
   for (i = 1; i < depth; i++)
     {
       parent = *iter;
       if (!gtk_tree_store_iter_nth_child (tree_model, iter, &parent, indices[i]))
-	return FALSE;
+        {
+          iter->stamp = 0;
+          return FALSE;
+        }
     }
 
   return TRUE;
@@ -507,24 +581,25 @@ gtk_tree_store_get_path (GtkTreeModel *tree_model,
 			 GtkTreeIter  *iter)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreePath *retval;
   GNode *tmp_node;
   gint i = 0;
 
   g_return_val_if_fail (iter->user_data != NULL, NULL);
-  g_return_val_if_fail (iter->stamp == tree_store->stamp, NULL);
+  g_return_val_if_fail (iter->stamp == priv->stamp, NULL);
 
   validate_tree (tree_store);
 
   if (G_NODE (iter->user_data)->parent == NULL &&
-      G_NODE (iter->user_data) == tree_store->root)
+      G_NODE (iter->user_data) == priv->root)
     return gtk_tree_path_new ();
   g_assert (G_NODE (iter->user_data)->parent != NULL);
 
-  if (G_NODE (iter->user_data)->parent == G_NODE (tree_store->root))
+  if (G_NODE (iter->user_data)->parent == G_NODE (priv->root))
     {
       retval = gtk_tree_path_new ();
-      tmp_node = G_NODE (tree_store->root)->children;
+      tmp_node = G_NODE (priv->root)->children;
     }
   else
     {
@@ -573,10 +648,11 @@ gtk_tree_store_get_value (GtkTreeModel *tree_model,
 			  GValue       *value)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreeDataList *list;
   gint tmp_column = column;
 
-  g_return_if_fail (column < tree_store->n_columns);
+  g_return_if_fail (column < priv->n_columns);
   g_return_if_fail (VALID_ITER (iter, tree_store));
 
   list = G_NODE (iter->user_data)->data;
@@ -587,13 +663,13 @@ gtk_tree_store_get_value (GtkTreeModel *tree_model,
   if (list)
     {
       _gtk_tree_data_list_node_to_value (list,
-					 tree_store->column_headers[column],
+					 priv->column_headers[column],
 					 value);
     }
   else
     {
       /* We want to return an initialized but empty (default) value */
-      g_value_init (value, tree_store->column_headers[column]);
+      g_value_init (value, priv->column_headers[column]);
     }
 }
 
@@ -602,18 +678,35 @@ gtk_tree_store_iter_next (GtkTreeModel  *tree_model,
 			  GtkTreeIter   *iter)
 {
   g_return_val_if_fail (iter->user_data != NULL, FALSE);
-  g_return_val_if_fail (iter->stamp == GTK_TREE_STORE (tree_model)->stamp, FALSE);
+  g_return_val_if_fail (iter->stamp == GTK_TREE_STORE (tree_model)->priv->stamp, FALSE);
 
-  if (G_NODE (iter->user_data)->next)
+  if (G_NODE (iter->user_data)->next == NULL)
     {
-      iter->user_data = G_NODE (iter->user_data)->next;
-      return TRUE;
+      iter->stamp = 0;
+      return FALSE;
     }
-  else
+
+  iter->user_data = G_NODE (iter->user_data)->next;
+
+  return TRUE;
+}
+
+static gboolean
+gtk_tree_store_iter_previous (GtkTreeModel *tree_model,
+                              GtkTreeIter  *iter)
+{
+  g_return_val_if_fail (iter->user_data != NULL, FALSE);
+  g_return_val_if_fail (iter->stamp == GTK_TREE_STORE (tree_model)->priv->stamp, FALSE);
+
+  if (G_NODE (iter->user_data)->prev == NULL)
     {
       iter->stamp = 0;
       return FALSE;
     }
+
+  iter->user_data = G_NODE (iter->user_data)->prev;
+
+  return TRUE;
 }
 
 static gboolean
@@ -622,6 +715,7 @@ gtk_tree_store_iter_children (GtkTreeModel *tree_model,
 			      GtkTreeIter  *parent)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GNode *children;
 
   if (parent)
@@ -630,11 +724,11 @@ gtk_tree_store_iter_children (GtkTreeModel *tree_model,
   if (parent)
     children = G_NODE (parent->user_data)->children;
   else
-    children = G_NODE (tree_store->root)->children;
+    children = G_NODE (priv->root)->children;
 
   if (children)
     {
-      iter->stamp = tree_store->stamp;
+      iter->stamp = priv->stamp;
       iter->user_data = children;
       return TRUE;
     }
@@ -665,7 +759,7 @@ gtk_tree_store_iter_n_children (GtkTreeModel *tree_model,
   g_return_val_if_fail (iter == NULL || iter->user_data != NULL, 0);
 
   if (iter == NULL)
-    node = G_NODE (GTK_TREE_STORE (tree_model)->root)->children;
+    node = G_NODE (GTK_TREE_STORE (tree_model)->priv->root)->children;
   else
     node = G_NODE (iter->user_data)->children;
 
@@ -685,13 +779,14 @@ gtk_tree_store_iter_nth_child (GtkTreeModel *tree_model,
 			       gint          n)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GNode *parent_node;
   GNode *child;
 
   g_return_val_if_fail (parent == NULL || parent->user_data != NULL, FALSE);
 
   if (parent == NULL)
-    parent_node = tree_store->root;
+    parent_node = priv->root;
   else
     parent_node = parent->user_data;
 
@@ -700,7 +795,7 @@ gtk_tree_store_iter_nth_child (GtkTreeModel *tree_model,
   if (child)
     {
       iter->user_data = child;
-      iter->stamp = tree_store->stamp;
+      iter->stamp = priv->stamp;
       return TRUE;
     }
   else
@@ -716,6 +811,7 @@ gtk_tree_store_iter_parent (GtkTreeModel *tree_model,
 			    GtkTreeIter  *child)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GNode *parent;
 
   g_return_val_if_fail (iter != NULL, FALSE);
@@ -725,10 +821,10 @@ gtk_tree_store_iter_parent (GtkTreeModel *tree_model,
 
   g_assert (parent != NULL);
 
-  if (parent != tree_store->root)
+  if (parent != priv->root)
     {
       iter->user_data = parent;
-      iter->stamp = tree_store->stamp;
+      iter->stamp = priv->stamp;
       return TRUE;
     }
   else
@@ -747,30 +843,32 @@ gtk_tree_store_real_set_value (GtkTreeStore *tree_store,
 			       GValue       *value,
 			       gboolean      sort)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreeDataList *list;
   GtkTreeDataList *prev;
   gint old_column = column;
-  GValue real_value = {0, };
+  GValue real_value = G_VALUE_INIT;
   gboolean converted = FALSE;
   gboolean retval = FALSE;
 
-  if (! g_type_is_a (G_VALUE_TYPE (value), tree_store->column_headers[column]))
+  if (! g_type_is_a (G_VALUE_TYPE (value), priv->column_headers[column]))
     {
-      if (! (g_value_type_compatible (G_VALUE_TYPE (value), tree_store->column_headers[column]) &&
-	     g_value_type_compatible (tree_store->column_headers[column], G_VALUE_TYPE (value))))
+      if (! (g_value_type_transformable (G_VALUE_TYPE (value), priv->column_headers[column])))
 	{
 	  g_warning ("%s: Unable to convert from %s to %s\n",
 		     G_STRLOC,
 		     g_type_name (G_VALUE_TYPE (value)),
-		     g_type_name (tree_store->column_headers[column]));
+		     g_type_name (priv->column_headers[column]));
 	  return retval;
 	}
+
+      g_value_init (&real_value, priv->column_headers[column]);
       if (!g_value_transform (value, &real_value))
 	{
 	  g_warning ("%s: Unable to make conversion from %s to %s\n",
 		     G_STRLOC,
 		     g_type_name (G_VALUE_TYPE (value)),
-		     g_type_name (tree_store->column_headers[column]));
+		     g_type_name (priv->column_headers[column]));
 	  g_value_unset (&real_value);
 	  return retval;
 	}
@@ -854,7 +952,7 @@ gtk_tree_store_set_value (GtkTreeStore *tree_store,
 {
   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
   g_return_if_fail (VALID_ITER (iter, tree_store));
-  g_return_if_fail (column >= 0 && column < tree_store->n_columns);
+  g_return_if_fail (column >= 0 && column < tree_store->priv->n_columns);
   g_return_if_fail (G_IS_VALUE (value));
 
   if (gtk_tree_store_real_set_value (tree_store, iter, column, value, TRUE))
@@ -870,22 +968,23 @@ gtk_tree_store_set_value (GtkTreeStore *tree_store,
 static GtkTreeIterCompareFunc
 gtk_tree_store_get_compare_func (GtkTreeStore *tree_store)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreeIterCompareFunc func = NULL;
 
   if (GTK_TREE_STORE_IS_SORTED (tree_store))
     {
-      if (tree_store->sort_column_id != -1)
+      if (priv->sort_column_id != -1)
 	{
 	  GtkTreeDataSortHeader *header;
-	  header = _gtk_tree_data_list_get_header (tree_store->sort_list,
-						   tree_store->sort_column_id);
+	  header = _gtk_tree_data_list_get_header (priv->sort_list,
+						   priv->sort_column_id);
 	  g_return_val_if_fail (header != NULL, NULL);
 	  g_return_val_if_fail (header->func != NULL, NULL);
 	  func = header->func;
 	}
       else
 	{
-	  func = tree_store->default_sort_func;
+	  func = priv->default_sort_func;
 	}
     }
 
@@ -901,6 +1000,7 @@ gtk_tree_store_set_vector_internal (GtkTreeStore *tree_store,
 				    GValue       *values,
 				    gint          n_values)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   gint i;
   GtkTreeIterCompareFunc func = NULL;
 
@@ -915,7 +1015,7 @@ gtk_tree_store_set_vector_internal (GtkTreeStore *tree_store,
 						    FALSE) || *emit_signal;
 
       if (func == _gtk_tree_data_list_compare_func &&
-	  columns[i] == tree_store->sort_column_id)
+	  columns[i] == priv->sort_column_id)
 	*maybe_need_sort = TRUE;
     }
 }
@@ -927,6 +1027,7 @@ gtk_tree_store_set_valist_internal (GtkTreeStore *tree_store,
                                     gboolean     *maybe_need_sort,
                                     va_list       var_args)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   gint column;
   GtkTreeIterCompareFunc func = NULL;
 
@@ -938,17 +1039,17 @@ gtk_tree_store_set_valist_internal (GtkTreeStore *tree_store,
 
   while (column != -1)
     {
-      GValue value = { 0, };
+      GValue value = G_VALUE_INIT;
       gchar *error = NULL;
 
-      if (column < 0 || column >= tree_store->n_columns)
+      if (column < 0 || column >= priv->n_columns)
 	{
 	  g_warning ("%s: Invalid column number %d added to iter (remember to end your list of columns with a -1)", G_STRLOC, column);
 	  break;
 	}
-      g_value_init (&value, tree_store->column_headers[column]);
 
-      G_VALUE_COLLECT (&value, var_args, 0, &error);
+      G_VALUE_COLLECT_INIT (&value, priv->column_headers[column],
+                            var_args, 0, &error);
       if (error)
 	{
 	  g_warning ("%s: %s", G_STRLOC, error);
@@ -967,7 +1068,7 @@ gtk_tree_store_set_valist_internal (GtkTreeStore *tree_store,
 						    FALSE) || *emit_signal;
 
       if (func == _gtk_tree_data_list_compare_func &&
-	  column == tree_store->sort_column_id)
+	  column == priv->sort_column_id)
 	*maybe_need_sort = TRUE;
 
       g_value_unset (&value);
@@ -990,6 +1091,7 @@ gtk_tree_store_set_valist_internal (GtkTreeStore *tree_store,
  * the number of columns to change is not known until run-time.
  *
  * Since: 2.12
+ * Rename to: gtk_tree_store_set
  **/
 void
 gtk_tree_store_set_valuesv (GtkTreeStore *tree_store,
@@ -998,6 +1100,7 @@ gtk_tree_store_set_valuesv (GtkTreeStore *tree_store,
 			    GValue       *values,
 			    gint          n_values)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   gboolean emit_signal = FALSE;
   gboolean maybe_need_sort = FALSE;
 
@@ -1010,7 +1113,7 @@ gtk_tree_store_set_valuesv (GtkTreeStore *tree_store,
 				      columns, values, n_values);
 
   if (maybe_need_sort && GTK_TREE_STORE_IS_SORTED (tree_store))
-    gtk_tree_store_sort_iter_changed (tree_store, iter, tree_store->sort_column_id, TRUE);
+    gtk_tree_store_sort_iter_changed (tree_store, iter, priv->sort_column_id, TRUE);
 
   if (emit_signal)
     {
@@ -1037,6 +1140,7 @@ gtk_tree_store_set_valist (GtkTreeStore *tree_store,
                            GtkTreeIter  *iter,
                            va_list       var_args)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   gboolean emit_signal = FALSE;
   gboolean maybe_need_sort = FALSE;
 
@@ -1049,7 +1153,7 @@ gtk_tree_store_set_valist (GtkTreeStore *tree_store,
 				      var_args);
 
   if (maybe_need_sort && GTK_TREE_STORE_IS_SORTED (tree_store))
-    gtk_tree_store_sort_iter_changed (tree_store, iter, tree_store->sort_column_id, TRUE);
+    gtk_tree_store_sort_iter_changed (tree_store, iter, priv->sort_column_id, TRUE);
 
   if (emit_signal)
     {
@@ -1065,15 +1169,17 @@ gtk_tree_store_set_valist (GtkTreeStore *tree_store,
  * gtk_tree_store_set:
  * @tree_store: A #GtkTreeStore
  * @iter: A valid #GtkTreeIter for the row being modified
- * @Varargs: pairs of column number and value, terminated with -1
+ * @...: pairs of column number and value, terminated with -1
  *
  * Sets the value of one or more cells in the row referenced by @iter.
  * The variable argument list should contain integer column numbers,
- * each column number followed by the value to be set. 
+ * each column number followed by the value to be set.
  * The list is terminated by a -1. For example, to set column 0 with type
- * %G_TYPE_STRING to "Foo", you would write 
+ * %G_TYPE_STRING to "Foo", you would write
  * <literal>gtk_tree_store_set (store, iter, 0, "Foo", -1)</literal>.
- * The value will be copied or referenced by the store if appropriate.
+ *
+ * The value will be referenced by the store if it is a %G_TYPE_OBJECT, and it
+ * will be copied if it is a %G_TYPE_STRING or %G_TYPE_BOXED.
  **/
 void
 gtk_tree_store_set (GtkTreeStore *tree_store,
@@ -1102,6 +1208,7 @@ gboolean
 gtk_tree_store_remove (GtkTreeStore *tree_store,
 		       GtkTreeIter  *iter)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreePath *path;
   GtkTreeIter new_iter = {0,};
   GNode *parent;
@@ -1117,21 +1224,21 @@ gtk_tree_store_remove (GtkTreeStore *tree_store,
 
   if (G_NODE (iter->user_data)->data)
     g_node_traverse (G_NODE (iter->user_data), G_POST_ORDER, G_TRAVERSE_ALL,
-		     -1, node_free, tree_store->column_headers);
+		     -1, node_free, priv->column_headers);
 
   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
   g_node_destroy (G_NODE (iter->user_data));
 
   gtk_tree_model_row_deleted (GTK_TREE_MODEL (tree_store), path);
 
-  if (parent != G_NODE (tree_store->root))
+  if (parent != G_NODE (priv->root))
     {
       /* child_toggled */
       if (parent->children == NULL)
 	{
 	  gtk_tree_path_up (path);
 
-	  new_iter.stamp = tree_store->stamp;
+	  new_iter.stamp = priv->stamp;
 	  new_iter.user_data = parent;
 	  gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (tree_store), path, &new_iter);
 	}
@@ -1141,7 +1248,7 @@ gtk_tree_store_remove (GtkTreeStore *tree_store,
   /* revalidate iter */
   if (next_node != NULL)
     {
-      iter->stamp = tree_store->stamp;
+      iter->stamp = priv->stamp;
       iter->user_data = next_node;
       return TRUE;
     }
@@ -1159,14 +1266,14 @@ gtk_tree_store_remove (GtkTreeStore *tree_store,
  * @tree_store: A #GtkTreeStore
  * @iter: (out): An unset #GtkTreeIter to set to the new row
  * @parent: (allow-none): A valid #GtkTreeIter, or %NULL
- * @position: position to insert the new row
+ * @position: position to insert the new row, or -1 for last
  *
  * Creates a new row at @position.  If parent is non-%NULL, then the row will be
  * made a child of @parent.  Otherwise, the row will be created at the toplevel.
- * If @position is larger than the number of rows at that level, then the new
- * row will be inserted to the end of the list.  @iter will be changed to point
- * to this new row.  The row will be empty after this function is called.  To
- * fill in values, you need to call gtk_tree_store_set() or
+ * If @position is -1 or is larger than the number of rows at that level, then
+ * the new row will be inserted to the end of the list.  @iter will be changed
+ * to point to this new row.  The row will be empty after this function is
+ * called.  To fill in values, you need to call gtk_tree_store_set() or
  * gtk_tree_store_set_value().
  *
  **/
@@ -1176,6 +1283,7 @@ gtk_tree_store_insert (GtkTreeStore *tree_store,
 		       GtkTreeIter  *parent,
 		       gint          position)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreePath *path;
   GNode *parent_node;
   GNode *new_node;
@@ -1188,20 +1296,20 @@ gtk_tree_store_insert (GtkTreeStore *tree_store,
   if (parent)
     parent_node = parent->user_data;
   else
-    parent_node = tree_store->root;
+    parent_node = priv->root;
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
   new_node = g_node_new (NULL);
 
-  iter->stamp = tree_store->stamp;
+  iter->stamp = priv->stamp;
   iter->user_data = new_node;
   g_node_insert (parent_node, position, new_node);
 
   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
   gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
 
-  if (parent_node != tree_store->root)
+  if (parent_node != priv->root)
     {
       if (new_node->prev == NULL && new_node->next == NULL)
         {
@@ -1239,6 +1347,7 @@ gtk_tree_store_insert_before (GtkTreeStore *tree_store,
 			      GtkTreeIter  *parent,
 			      GtkTreeIter  *sibling)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreePath *path;
   GNode *parent_node = NULL;
   GNode *new_node;
@@ -1251,7 +1360,7 @@ gtk_tree_store_insert_before (GtkTreeStore *tree_store,
     g_return_if_fail (VALID_ITER (sibling, tree_store));
 
   if (parent == NULL && sibling == NULL)
-    parent_node = tree_store->root;
+    parent_node = priv->root;
   else if (parent == NULL)
     parent_node = G_NODE (sibling->user_data)->parent;
   else if (sibling == NULL)
@@ -1262,7 +1371,7 @@ gtk_tree_store_insert_before (GtkTreeStore *tree_store,
       parent_node = G_NODE (parent->user_data);
     }
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
   new_node = g_node_new (NULL);
 
@@ -1270,19 +1379,19 @@ gtk_tree_store_insert_before (GtkTreeStore *tree_store,
 			sibling ? G_NODE (sibling->user_data) : NULL,
                         new_node);
 
-  iter->stamp = tree_store->stamp;
+  iter->stamp = priv->stamp;
   iter->user_data = new_node;
 
   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
   gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
 
-  if (parent_node != tree_store->root)
+  if (parent_node != priv->root)
     {
       if (new_node->prev == NULL && new_node->next == NULL)
         {
           GtkTreeIter parent_iter;
 
-          parent_iter.stamp = tree_store->stamp;
+          parent_iter.stamp = priv->stamp;
           parent_iter.user_data = parent_node;
 
           gtk_tree_path_up (path);
@@ -1319,6 +1428,7 @@ gtk_tree_store_insert_after (GtkTreeStore *tree_store,
 			     GtkTreeIter  *parent,
 			     GtkTreeIter  *sibling)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreePath *path;
   GNode *parent_node;
   GNode *new_node;
@@ -1331,7 +1441,7 @@ gtk_tree_store_insert_after (GtkTreeStore *tree_store,
     g_return_if_fail (VALID_ITER (sibling, tree_store));
 
   if (parent == NULL && sibling == NULL)
-    parent_node = tree_store->root;
+    parent_node = priv->root;
   else if (parent == NULL)
     parent_node = G_NODE (sibling->user_data)->parent;
   else if (sibling == NULL)
@@ -1343,7 +1453,7 @@ gtk_tree_store_insert_after (GtkTreeStore *tree_store,
       parent_node = G_NODE (parent->user_data);
     }
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
   new_node = g_node_new (NULL);
 
@@ -1351,19 +1461,19 @@ gtk_tree_store_insert_after (GtkTreeStore *tree_store,
 		       sibling ? G_NODE (sibling->user_data) : NULL,
                        new_node);
 
-  iter->stamp = tree_store->stamp;
+  iter->stamp = priv->stamp;
   iter->user_data = new_node;
 
   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
   gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
 
-  if (parent_node != tree_store->root)
+  if (parent_node != priv->root)
     {
       if (new_node->prev == NULL && new_node->next == NULL)
         {
           GtkTreeIter parent_iter;
 
-          parent_iter.stamp = tree_store->stamp;
+          parent_iter.stamp = priv->stamp;
           parent_iter.user_data = parent_node;
 
           gtk_tree_path_up (path);
@@ -1381,12 +1491,12 @@ gtk_tree_store_insert_after (GtkTreeStore *tree_store,
  * @tree_store: A #GtkTreeStore
  * @iter: (out) (allow-none): An unset #GtkTreeIter to set the new row, or %NULL.
  * @parent: (allow-none): A valid #GtkTreeIter, or %NULL
- * @position: position to insert the new row
- * @Varargs: pairs of column number and value, terminated with -1
+ * @position: position to insert the new row, or -1 to append after existing rows
+ * @...: pairs of column number and value, terminated with -1
  *
- * Creates a new row at @position.  @iter will be changed to point to this
- * new row.  If @position is larger than the number of rows on the list, then
- * the new row will be appended to the list.  The row will be filled with
+ * Creates a new row at @position. @iter will be changed to point to this
+ * new row. If @position is -1, or larger than the number of rows on the list, then
+ * the new row will be appended to the list. The row will be filled with
  * the values given to this function.
  *
  * Calling
@@ -1412,6 +1522,7 @@ gtk_tree_store_insert_with_values (GtkTreeStore *tree_store,
 				   gint          position,
 				   ...)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreePath *path;
   GNode *parent_node;
   GNode *new_node;
@@ -1431,13 +1542,13 @@ gtk_tree_store_insert_with_values (GtkTreeStore *tree_store,
   if (parent)
     parent_node = parent->user_data;
   else
-    parent_node = tree_store->root;
+    parent_node = priv->root;
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
   new_node = g_node_new (NULL);
 
-  iter->stamp = tree_store->stamp;
+  iter->stamp = priv->stamp;
   iter->user_data = new_node;
   g_node_insert (parent_node, position, new_node);
 
@@ -1448,12 +1559,12 @@ gtk_tree_store_insert_with_values (GtkTreeStore *tree_store,
   va_end (var_args);
 
   if (maybe_need_sort && GTK_TREE_STORE_IS_SORTED (tree_store))
-    gtk_tree_store_sort_iter_changed (tree_store, iter, tree_store->sort_column_id, FALSE);
+    gtk_tree_store_sort_iter_changed (tree_store, iter, priv->sort_column_id, FALSE);
 
   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
   gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
 
-  if (parent_node != tree_store->root)
+  if (parent_node != priv->root)
     {
       if (new_node->prev == NULL && new_node->next == NULL)
         {
@@ -1472,9 +1583,9 @@ gtk_tree_store_insert_with_values (GtkTreeStore *tree_store,
  * @tree_store: A #GtkTreeStore
  * @iter: (out) (allow-none): An unset #GtkTreeIter to set the new row, or %NULL.
  * @parent: (allow-none): A valid #GtkTreeIter, or %NULL
- * @position: position to insert the new row
- * @columns: an array of column numbers
- * @values: an array of GValues
+ * @position: position to insert the new row, or -1 for last
+ * @columns: (array length=n_values): an array of column numbers
+ * @values: (array length=n_values): an array of GValues
  * @n_values: the length of the @columns and @values arrays
  *
  * A variant of gtk_tree_store_insert_with_values() which takes
@@ -1482,6 +1593,7 @@ gtk_tree_store_insert_with_values (GtkTreeStore *tree_store,
  * function is mainly intended for language bindings.
  *
  * Since: 2.10
+ * Rename to: gtk_tree_store_insert_with_values
  */
 void
 gtk_tree_store_insert_with_valuesv (GtkTreeStore *tree_store,
@@ -1492,6 +1604,7 @@ gtk_tree_store_insert_with_valuesv (GtkTreeStore *tree_store,
 				    GValue       *values,
 				    gint          n_values)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GtkTreePath *path;
   GNode *parent_node;
   GNode *new_node;
@@ -1510,13 +1623,13 @@ gtk_tree_store_insert_with_valuesv (GtkTreeStore *tree_store,
   if (parent)
     parent_node = parent->user_data;
   else
-    parent_node = tree_store->root;
+    parent_node = priv->root;
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
   new_node = g_node_new (NULL);
 
-  iter->stamp = tree_store->stamp;
+  iter->stamp = priv->stamp;
   iter->user_data = new_node;
   g_node_insert (parent_node, position, new_node);
 
@@ -1525,12 +1638,12 @@ gtk_tree_store_insert_with_valuesv (GtkTreeStore *tree_store,
 				      columns, values, n_values);
 
   if (maybe_need_sort && GTK_TREE_STORE_IS_SORTED (tree_store))
-    gtk_tree_store_sort_iter_changed (tree_store, iter, tree_store->sort_column_id, FALSE);
+    gtk_tree_store_sort_iter_changed (tree_store, iter, priv->sort_column_id, FALSE);
 
   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
   gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
 
-  if (parent_node != tree_store->root)
+  if (parent_node != priv->root)
     {
       if (new_node->prev == NULL && new_node->next == NULL)
         {
@@ -1561,6 +1674,7 @@ gtk_tree_store_prepend (GtkTreeStore *tree_store,
 			GtkTreeIter  *iter,
 			GtkTreeIter  *parent)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GNode *parent_node;
 
   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
@@ -1568,10 +1682,10 @@ gtk_tree_store_prepend (GtkTreeStore *tree_store,
   if (parent != NULL)
     g_return_if_fail (VALID_ITER (parent, tree_store));
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
   if (parent == NULL)
-    parent_node = tree_store->root;
+    parent_node = priv->root;
   else
     parent_node = parent->user_data;
 
@@ -1579,7 +1693,7 @@ gtk_tree_store_prepend (GtkTreeStore *tree_store,
     {
       GtkTreePath *path;
       
-      iter->stamp = tree_store->stamp;
+      iter->stamp = priv->stamp;
       iter->user_data = g_node_new (NULL);
 
       g_node_prepend (parent_node, G_NODE (iter->user_data));
@@ -1587,7 +1701,7 @@ gtk_tree_store_prepend (GtkTreeStore *tree_store,
       path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
       gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
 
-      if (parent_node != tree_store->root)
+      if (parent_node != priv->root)
 	{
 	  gtk_tree_path_up (path);
 	  gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (tree_store), path, parent);
@@ -1619,6 +1733,7 @@ gtk_tree_store_append (GtkTreeStore *tree_store,
 		       GtkTreeIter  *iter,
 		       GtkTreeIter  *parent)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GNode *parent_node;
 
   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
@@ -1627,17 +1742,17 @@ gtk_tree_store_append (GtkTreeStore *tree_store,
     g_return_if_fail (VALID_ITER (parent, tree_store));
 
   if (parent == NULL)
-    parent_node = tree_store->root;
+    parent_node = priv->root;
   else
     parent_node = parent->user_data;
 
-  tree_store->columns_dirty = TRUE;
+  priv->columns_dirty = TRUE;
 
   if (parent_node->children == NULL)
     {
       GtkTreePath *path;
 
-      iter->stamp = tree_store->stamp;
+      iter->stamp = priv->stamp;
       iter->user_data = g_node_new (NULL);
 
       g_node_append (parent_node, G_NODE (iter->user_data));
@@ -1645,7 +1760,7 @@ gtk_tree_store_append (GtkTreeStore *tree_store,
       path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
       gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
 
-      if (parent_node != tree_store->root)
+      if (parent_node != priv->root)
 	{
 	  gtk_tree_path_up (path);
 	  gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (tree_store), path, parent);
@@ -1729,7 +1844,7 @@ gtk_tree_store_clear_traverse (GNode        *node,
 
       if (node->parent)
         {
-	  iter.stamp = store->stamp;
+	  iter.stamp = store->priv->stamp;
 	  iter.user_data = node;
 
 	  gtk_tree_store_remove (store, &iter);
@@ -1737,7 +1852,7 @@ gtk_tree_store_clear_traverse (GNode        *node,
     }
   else if (node->parent)
     {
-      iter.stamp = store->stamp;
+      iter.stamp = store->priv->stamp;
       iter.user_data = node;
 
       gtk_tree_store_remove (store, &iter);
@@ -1749,11 +1864,12 @@ gtk_tree_store_clear_traverse (GNode        *node,
 static void
 gtk_tree_store_increment_stamp (GtkTreeStore *tree_store)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   do
     {
-      tree_store->stamp++;
+      priv->stamp++;
     }
-  while (tree_store->stamp == 0);
+  while (priv->stamp == 0);
 }
 
 /**
@@ -1767,7 +1883,7 @@ gtk_tree_store_clear (GtkTreeStore *tree_store)
 {
   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 
-  gtk_tree_store_clear_traverse (tree_store->root, tree_store);
+  gtk_tree_store_clear_traverse (tree_store->priv->root, tree_store);
   gtk_tree_store_increment_stamp (tree_store);
 }
 
@@ -1819,7 +1935,7 @@ gtk_tree_store_iter_is_valid (GtkTreeStore *tree_store,
   if (!VALID_ITER (iter, tree_store))
     return FALSE;
 
-  return gtk_tree_store_iter_is_valid_helper (iter, tree_store->root);
+  return gtk_tree_store_iter_is_valid_helper (iter, tree_store->priv->root);
 }
 
 /* DND */
@@ -1891,7 +2007,7 @@ copy_node_data (GtkTreeStore *tree_store,
   col = 0;
   while (dl)
     {
-      copy_iter = _gtk_tree_data_list_node_copy (dl, tree_store->column_headers[col]);
+      copy_iter = _gtk_tree_data_list_node_copy (dl, tree_store->priv->column_headers[col]);
 
       if (copy_head == NULL)
         copy_head = copy_iter;
@@ -2138,10 +2254,10 @@ gtk_tree_store_reorder_func (gconstpointer a,
 }
 
 /**
- * gtk_tree_store_reorder:
+ * gtk_tree_store_reorder: (skip)
  * @tree_store: A #GtkTreeStore.
  * @parent: A #GtkTreeIter.
- * @new_order: an array of integers mapping the new position of each child
+ * @new_order: (array): an array of integers mapping the new position of each child
  *      to its old position before the re-ordering,
  *      i.e. @new_order<literal>[newpos] = oldpos</literal>.
  *
@@ -2167,7 +2283,7 @@ gtk_tree_store_reorder (GtkTreeStore *tree_store,
   g_return_if_fail (new_order != NULL);
 
   if (!parent)
-    level = G_NODE (tree_store->root)->children;
+    level = G_NODE (tree_store->priv->root)->children;
   else
     level = G_NODE (parent->user_data)->children;
 
@@ -2209,7 +2325,7 @@ gtk_tree_store_reorder (GtkTreeStore *tree_store,
   if (parent)
     G_NODE (parent->user_data)->children = sort_array[0].node;
   else
-    G_NODE (tree_store->root)->children = sort_array[0].node;
+    G_NODE (tree_store->priv->root)->children = sort_array[0].node;
 
   /* emit signal */
   if (parent)
@@ -2270,11 +2386,11 @@ gtk_tree_store_swap (GtkTreeStore *tree_store,
         {
           gtk_tree_path_free (path_a);
           gtk_tree_path_free (path_b);
-                                                                                
+
           g_warning ("Given children are not in the same level\n");
           return;
         }
-      parent_node = G_NODE (tree_store->root);
+      parent_node = G_NODE (tree_store->priv->root);
     }
   else
     {
@@ -2282,7 +2398,7 @@ gtk_tree_store_swap (GtkTreeStore *tree_store,
         {
           gtk_tree_path_free (path_a);
           gtk_tree_path_free (path_b);
-                                                                                
+
           g_warning ("Given children don't have a common parent\n");
           return;
         }
@@ -2359,7 +2475,7 @@ gtk_tree_store_swap (GtkTreeStore *tree_store,
       order[i] = i;
 
   gtk_tree_model_rows_reordered (GTK_TREE_MODEL (tree_store), path_a,
-				 parent_node == tree_store->root 
+				 parent_node == tree_store->priv->root
 				 ? NULL : &parent, order);
   gtk_tree_path_free (path_a);
   g_free (order);
@@ -2457,7 +2573,7 @@ gtk_tree_store_move (GtkTreeStore *tree_store,
       parent = G_NODE (parent_iter.user_data);
     }
   else
-    parent = G_NODE (tree_store->root);
+    parent = G_NODE (tree_store->priv->root);
 
   /* yes, I know that this can be done shorter, but I'm doing it this way
    * so the code is also maintainable
@@ -2735,6 +2851,7 @@ gtk_tree_store_compare_func (gconstpointer a,
 			     gpointer      user_data)
 {
   GtkTreeStore *tree_store = user_data;
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GNode *node_a;
   GNode *node_b;
   GtkTreeIterCompareFunc func;
@@ -2744,12 +2861,12 @@ gtk_tree_store_compare_func (gconstpointer a,
   GtkTreeIter iter_b;
   gint retval;
 
-  if (tree_store->sort_column_id != -1)
+  if (priv->sort_column_id != -1)
     {
       GtkTreeDataSortHeader *header;
 
-      header = _gtk_tree_data_list_get_header (tree_store->sort_list,
-					       tree_store->sort_column_id);
+      header = _gtk_tree_data_list_get_header (priv->sort_list,
+					       priv->sort_column_id);
       g_return_val_if_fail (header != NULL, 0);
       g_return_val_if_fail (header->func != NULL, 0);
 
@@ -2758,22 +2875,22 @@ gtk_tree_store_compare_func (gconstpointer a,
     }
   else
     {
-      g_return_val_if_fail (tree_store->default_sort_func != NULL, 0);
-      func = tree_store->default_sort_func;
-      data = tree_store->default_sort_data;
+      g_return_val_if_fail (priv->default_sort_func != NULL, 0);
+      func = priv->default_sort_func;
+      data = priv->default_sort_data;
     }
 
   node_a = ((SortTuple *) a)->node;
   node_b = ((SortTuple *) b)->node;
 
-  iter_a.stamp = tree_store->stamp;
+  iter_a.stamp = priv->stamp;
   iter_a.user_data = node_a;
-  iter_b.stamp = tree_store->stamp;
+  iter_b.stamp = priv->stamp;
   iter_b.user_data = node_b;
 
   retval = (* func) (GTK_TREE_MODEL (user_data), &iter_a, &iter_b, data);
 
-  if (tree_store->order == GTK_SORT_DESCENDING)
+  if (priv->order == GTK_SORT_DESCENDING)
     {
       if (retval > 0)
 	retval = -1;
@@ -2842,7 +2959,7 @@ gtk_tree_store_sort_helper (GtkTreeStore *tree_store,
   for (i = 0; i < list_length; i++)
     new_order[i] = g_array_index (sort_array, SortTuple, i).offset;
 
-  iter.stamp = tree_store->stamp;
+  iter.stamp = tree_store->priv->stamp;
   iter.user_data = parent;
   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), &iter);
   gtk_tree_model_rows_reordered (GTK_TREE_MODEL (tree_store),
@@ -2864,15 +2981,17 @@ gtk_tree_store_sort_helper (GtkTreeStore *tree_store,
 static void
 gtk_tree_store_sort (GtkTreeStore *tree_store)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
+
   if (!GTK_TREE_STORE_IS_SORTED (tree_store))
     return;
 
-  if (tree_store->sort_column_id != -1)
+  if (priv->sort_column_id != -1)
     {
       GtkTreeDataSortHeader *header = NULL;
 
-      header = _gtk_tree_data_list_get_header (tree_store->sort_list, 
-					       tree_store->sort_column_id);
+      header = _gtk_tree_data_list_get_header (priv->sort_list,
+					       priv->sort_column_id);
 
       /* We want to make sure that we have a function */
       g_return_if_fail (header != NULL);
@@ -2880,10 +2999,10 @@ gtk_tree_store_sort (GtkTreeStore *tree_store)
     }
   else
     {
-      g_return_if_fail (tree_store->default_sort_func != NULL);
+      g_return_if_fail (priv->default_sort_func != NULL);
     }
 
-  gtk_tree_store_sort_helper (tree_store, G_NODE (tree_store->root), TRUE);
+  gtk_tree_store_sort_helper (tree_store, G_NODE (priv->root), TRUE);
 }
 
 static void
@@ -2892,6 +3011,7 @@ gtk_tree_store_sort_iter_changed (GtkTreeStore *tree_store,
 				  gint          column,
 				  gboolean      emit_signal)
 {
+  GtkTreeStorePrivate *priv = tree_store->priv;
   GNode *prev = NULL;
   GNode *next = NULL;
   GNode *node;
@@ -2909,12 +3029,12 @@ gtk_tree_store_sort_iter_changed (GtkTreeStore *tree_store,
 
   g_return_if_fail (G_NODE (iter->user_data)->parent != NULL);
 
-  tmp_iter.stamp = tree_store->stamp;
-  if (tree_store->sort_column_id != -1)
+  tmp_iter.stamp = priv->stamp;
+  if (priv->sort_column_id != -1)
     {
       GtkTreeDataSortHeader *header;
-      header = _gtk_tree_data_list_get_header (tree_store->sort_list,
-					       tree_store->sort_column_id);
+      header = _gtk_tree_data_list_get_header (priv->sort_list,
+					       priv->sort_column_id);
       g_return_if_fail (header != NULL);
       g_return_if_fail (header->func != NULL);
       func = header->func;
@@ -2922,14 +3042,14 @@ gtk_tree_store_sort_iter_changed (GtkTreeStore *tree_store,
     }
   else
     {
-      g_return_if_fail (tree_store->default_sort_func != NULL);
-      func = tree_store->default_sort_func;
-      data = tree_store->default_sort_data;
+      g_return_if_fail (priv->default_sort_func != NULL);
+      func = priv->default_sort_func;
+      data = priv->default_sort_data;
     }
 
   /* If it's the built in function, we don't sort. */
   if (func == _gtk_tree_data_list_compare_func &&
-      tree_store->sort_column_id != column)
+      priv->sort_column_id != column)
     return;
 
   old_location = 0;
@@ -2960,7 +3080,7 @@ gtk_tree_store_sort_iter_changed (GtkTreeStore *tree_store,
       cmp_b = (* func) (GTK_TREE_MODEL (tree_store), iter, &tmp_iter, data);
     }
 
-  if (tree_store->order == GTK_SORT_DESCENDING)
+  if (priv->order == GTK_SORT_DESCENDING)
     {
       if (cmp_a < 0)
 	cmp_a = 1;
@@ -3000,7 +3120,7 @@ gtk_tree_store_sort_iter_changed (GtkTreeStore *tree_store,
   node = node->parent->children;
   new_location = 0;
   tmp_iter.user_data = node;
-  if (tree_store->order == GTK_SORT_DESCENDING)
+  if (priv->order == GTK_SORT_DESCENDING)
     cmp_a = (* func) (GTK_TREE_MODEL (tree_store), &tmp_iter, iter, data);
   else
     cmp_a = (* func) (GTK_TREE_MODEL (tree_store), iter, &tmp_iter, data);
@@ -3011,7 +3131,7 @@ gtk_tree_store_sort_iter_changed (GtkTreeStore *tree_store,
       node = node->next;
       new_location++;
       tmp_iter.user_data = node;
-      if (tree_store->order == GTK_SORT_DESCENDING)
+      if (priv->order == GTK_SORT_DESCENDING)
 	cmp_a = (* func) (GTK_TREE_MODEL (tree_store), &tmp_iter, iter, data);
       else
 	cmp_a = (* func) (GTK_TREE_MODEL (tree_store), iter, &tmp_iter, data);
@@ -3086,14 +3206,15 @@ gtk_tree_store_get_sort_column_id (GtkTreeSortable  *sortable,
 				   GtkSortType      *order)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
+  GtkTreeStorePrivate *priv = tree_store->priv;
 
   if (sort_column_id)
-    * sort_column_id = tree_store->sort_column_id;
+    * sort_column_id = priv->sort_column_id;
   if (order)
-    * order = tree_store->order;
+    * order = priv->order;
 
-  if (tree_store->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID ||
-      tree_store->sort_column_id == GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
+  if (priv->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID ||
+      priv->sort_column_id == GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
     return FALSE;
 
   return TRUE;
@@ -3105,10 +3226,10 @@ gtk_tree_store_set_sort_column_id (GtkTreeSortable  *sortable,
 				   GtkSortType       order)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
+  GtkTreeStorePrivate *priv = tree_store->priv;
 
-  
-  if ((tree_store->sort_column_id == sort_column_id) &&
-      (tree_store->order == order))
+  if ((priv->sort_column_id == sort_column_id) &&
+      (priv->order == order))
     return;
 
   if (sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
@@ -3117,7 +3238,7 @@ gtk_tree_store_set_sort_column_id (GtkTreeSortable  *sortable,
 	{
 	  GtkTreeDataSortHeader *header = NULL;
 
-	  header = _gtk_tree_data_list_get_header (tree_store->sort_list, 
+	  header = _gtk_tree_data_list_get_header (priv->sort_list,
 						   sort_column_id);
 
 	  /* We want to make sure that we have a function */
@@ -3126,12 +3247,12 @@ gtk_tree_store_set_sort_column_id (GtkTreeSortable  *sortable,
 	}
       else
 	{
-	  g_return_if_fail (tree_store->default_sort_func != NULL);
+	  g_return_if_fail (priv->default_sort_func != NULL);
 	}
     }
 
-  tree_store->sort_column_id = sort_column_id;
-  tree_store->order = order;
+  priv->sort_column_id = sort_column_id;
+  priv->order = order;
 
   gtk_tree_sortable_sort_column_changed (sortable);
 
@@ -3146,12 +3267,13 @@ gtk_tree_store_set_sort_func (GtkTreeSortable        *sortable,
 			      GDestroyNotify          destroy)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
+  GtkTreeStorePrivate *priv = tree_store->priv;
 
-  tree_store->sort_list = _gtk_tree_data_list_set_header (tree_store->sort_list, 
-							  sort_column_id, 
-							  func, data, destroy);
+  priv->sort_list = _gtk_tree_data_list_set_header (priv->sort_list,
+						    sort_column_id,
+						    func, data, destroy);
 
-  if (tree_store->sort_column_id == sort_column_id)
+  if (priv->sort_column_id == sort_column_id)
     gtk_tree_store_sort (tree_store);
 }
 
@@ -3162,20 +3284,21 @@ gtk_tree_store_set_default_sort_func (GtkTreeSortable        *sortable,
 				      GDestroyNotify          destroy)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
+  GtkTreeStorePrivate *priv = tree_store->priv;
 
-  if (tree_store->default_sort_destroy)
+  if (priv->default_sort_destroy)
     {
-      GDestroyNotify d = tree_store->default_sort_destroy;
+      GDestroyNotify d = priv->default_sort_destroy;
 
-      tree_store->default_sort_destroy = NULL;
-      d (tree_store->default_sort_data);
+      priv->default_sort_destroy = NULL;
+      d (priv->default_sort_data);
     }
 
-  tree_store->default_sort_func = func;
-  tree_store->default_sort_data = data;
-  tree_store->default_sort_destroy = destroy;
+  priv->default_sort_func = func;
+  priv->default_sort_data = data;
+  priv->default_sort_destroy = destroy;
 
-  if (tree_store->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID)
+  if (priv->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID)
     gtk_tree_store_sort (tree_store);
 }
 
@@ -3184,7 +3307,7 @@ gtk_tree_store_has_default_sort_func (GtkTreeSortable *sortable)
 {
   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
 
-  return (tree_store->default_sort_func != NULL);
+  return (tree_store->priv->default_sort_func != NULL);
 }
 
 static void