Pileus Git - ~andy/gtk/blob - gtk/gtktreemodelmapping.c

   1 /* gtktreemodelmapping.c
   2  * Copyright (C) 2000  Red Hat, Inc.,  Alexander Larsson <alexl@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "gtktreemodelmapping.h"
  21 #include "gtksignal.h"
  22
  23 enum {
  24   CHANGED,
  25   INSERTED,
  26   CHILD_TOGGLED,
  27   DELETED,
  28   LAST_SIGNAL
  29 };
  30
  31 static guint tree_model_mapping_signals[LAST_SIGNAL] = { 0 };
  32
  33 static void         gtk_tree_model_mapping_init            (GtkTreeModelMapping      *tree_model_mapping);
  34 static void         gtk_tree_model_mapping_class_init      (GtkTreeModelMappingClass *tree_model_mapping_class);
  35 static void         gtk_tree_model_mapping_tree_model_init (GtkTreeModelIface        *iface);
  36 static void         gtk_tree_model_mapping_finalize        (GObject                  *object);
  37 /* signals */
  38 static void         gtk_tree_model_mapping_changed         (GtkTreeModel             *model,
  39                                                             GtkTreePath              *path,
  40                                                             GtkTreeIter              *iter,
  41                                                             gpointer                  data);
  42 static void         gtk_tree_model_mapping_inserted        (GtkTreeModel             *model,
  43                                                             GtkTreePath              *path,
  44                                                             GtkTreeIter              *iter,
  45                                                             gpointer                  data);
  46 static void         gtk_tree_model_mapping_child_toggled   (GtkTreeModel             *model,
  47                                                             GtkTreePath              *path,
  48                                                             GtkTreeIter              *iter,
  49                                                             gpointer                  data);
  50 static void         gtk_tree_model_mapping_deleted         (GtkTreeModel             *model,
  51                                                             GtkTreePath              *path,
  52                                                             gpointer                  data);
  53 static void         gtk_tree_model_mapping_reordered       (GtkTreeModel             *model,
  54                                                             GtkTreePath              *path,
  55                                                             gint                     *new_order);
  56 /* vtable */
  57 static GtkTreeModelFlags gtk_tree_model_mapping_get_flags  (GtkTreeModel             *tree_model);
  58 static gint         gtk_tree_model_mapping_get_n_columns   (GtkTreeModel             *tree_model);
  59 static GType        gtk_tree_model_mapping_get_column_type (GtkTreeModel             *tree_model,
  60                                                             gint                      index);
  61 static gboolean     gtk_tree_model_mapping_get_iter        (GtkTreeModel             *tree_model,
  62                                                             GtkTreeIter              *iter,
  63                                                             GtkTreePath              *path);
  64 static GtkTreePath *gtk_tree_model_mapping_get_path        (GtkTreeModel             *tree_model,
  65                                                             GtkTreeIter              *iter);
  66 static void         gtk_tree_model_mapping_get_value       (GtkTreeModel             *tree_model,
  67                                                             GtkTreeIter              *iter,
  68                                                             gint                      column,
  69                                                             GValue                   *value);
  70 static gboolean     gtk_tree_model_mapping_iter_next       (GtkTreeModel             *tree_model,
  71                                                             GtkTreeIter              *iter);
  72 static gboolean     gtk_tree_model_mapping_iter_children   (GtkTreeModel             *tree_model,
  73                                                             GtkTreeIter              *iter,
  74                                                             GtkTreeIter              *parent);
  75 static gboolean     gtk_tree_model_mapping_iter_has_child  (GtkTreeModel             *tree_model,
  76                                                             GtkTreeIter              *iter);
  77 static gint         gtk_tree_model_mapping_iter_n_children (GtkTreeModel             *tree_model,
  78                                                             GtkTreeIter              *iter);
  79 static gboolean     gtk_tree_model_mapping_iter_nth_child  (GtkTreeModel             *tree_model,
  80                                                             GtkTreeIter              *iter,
  81                                                             GtkTreeIter              *parent,
  82                                                             gint                      n);
  83 static gboolean     gtk_tree_model_mapping_iter_parent     (GtkTreeModel             *tree_model,
  84                                                             GtkTreeIter              *iter,
  85                                                             GtkTreeIter              *child);
  86 static void         gtk_tree_model_mapping_ref_iter        (GtkTreeModel             *tree_model,
  87                                                             GtkTreeIter              *iter);
  88 static void         gtk_tree_model_mapping_unref_iter      (GtkTreeModel          *tree_model,
  89                                                             GtkTreeIter              *iter);
  90
  91
  92 GtkType
  93 gtk_tree_model_mapping_get_type (void)
  94 {
  95   static GtkType tree_model_mapping_type = 0;
  96
  97   if (!tree_model_mapping_type)
  98     {
  99       static const GTypeInfo tree_model_mapping_info =
 100       {
 101         sizeof (GtkTreeModelMappingClass),
 102         NULL,           /* base_init */
 103         NULL,           /* base_finalize */
 104         (GClassInitFunc) gtk_tree_model_mapping_class_init,
 105         NULL,           /* class_finalize */
 106         NULL,           /* class_data */
 107         sizeof (GtkTreeModelMapping),
 108         0,              /* n_preallocs */
 109         (GInstanceInitFunc) gtk_tree_model_mapping_init
 110       };
 111
 112       static const GInterfaceInfo tree_model_info =
 113       {
 114         (GInterfaceInitFunc) gtk_tree_model_mapping_tree_model_init,
 115         NULL,
 116         NULL
 117       };
 118
 119       tree_model_mapping_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkTreeModelMapping", &tree_model_mapping_info, 0);
 120       g_type_add_interface_static (tree_model_mapping_type,
 121                                    GTK_TYPE_TREE_MODEL,
 122                                    &tree_model_info);
 123     }
 124
 125   return tree_model_mapping_type;
 126 }
 127
 128 static void
 129 gtk_tree_model_mapping_class_init (GtkTreeModelMappingClass *tree_model_mapping_class)
 130 {
 131   GObjectClass *object_class;
 132
 133   object_class = (GObjectClass *) tree_model_mapping_class;
 134
 135   object_class->finalize = gtk_tree_model_mapping_finalize;
 136
 137   tree_model_mapping_signals[CHANGED] =
 138     gtk_signal_new ("changed",
 139                     GTK_RUN_FIRST,
 140                     GTK_CLASS_TYPE (object_class),
 141                     GTK_SIGNAL_OFFSET (GtkTreeModelMappingClass, changed),
 142                     gtk_marshal_VOID__POINTER_POINTER,
 143                     GTK_TYPE_NONE, 2,
 144                     GTK_TYPE_POINTER,
 145                     GTK_TYPE_POINTER);
 146   tree_model_mapping_signals[INSERTED] =
 147     gtk_signal_new ("inserted",
 148                     GTK_RUN_FIRST,
 149                     GTK_CLASS_TYPE (object_class),
 150                     GTK_SIGNAL_OFFSET (GtkTreeModelMappingClass, inserted),
 151                     gtk_marshal_VOID__POINTER_POINTER,
 152                     GTK_TYPE_NONE, 2,
 153                     GTK_TYPE_POINTER,
 154                     GTK_TYPE_POINTER);
 155   tree_model_mapping_signals[CHILD_TOGGLED] =
 156     gtk_signal_new ("child_toggled",
 157                     GTK_RUN_FIRST,
 158                     GTK_CLASS_TYPE (object_class),
 159                     GTK_SIGNAL_OFFSET (GtkTreeModelMappingClass, child_toggled),
 160                     gtk_marshal_VOID__POINTER_POINTER,
 161                     GTK_TYPE_NONE, 2,
 162                     GTK_TYPE_POINTER,
 163                     GTK_TYPE_POINTER);
 164   tree_model_mapping_signals[DELETED] =
 165     gtk_signal_new ("deleted",
 166                     GTK_RUN_FIRST,
 167                     GTK_CLASS_TYPE (object_class),
 168                     GTK_SIGNAL_OFFSET (GtkTreeModelMappingClass, deleted),
 169                     gtk_marshal_VOID__POINTER,
 170                     GTK_TYPE_NONE, 1,
 171                     GTK_TYPE_POINTER);
 172 }
 173
 174 static void
 175 gtk_tree_model_mapping_tree_model_init (GtkTreeModelIface *iface)
 176 {
 177   iface->get_flags = gtk_tree_model_mapping_get_flags;
 178   iface->get_n_columns = gtk_tree_model_mapping_get_n_columns;
 179   iface->get_column_type = gtk_tree_model_mapping_get_column_type;
 180   iface->get_iter = gtk_tree_model_mapping_get_iter;
 181   iface->get_path = gtk_tree_model_mapping_get_path;
 182   iface->get_value = gtk_tree_model_mapping_get_value;
 183   iface->iter_next = gtk_tree_model_mapping_iter_next;
 184   iface->iter_children = gtk_tree_model_mapping_iter_children;
 185   iface->iter_has_child = gtk_tree_model_mapping_iter_has_child;
 186   iface->iter_n_children = gtk_tree_model_mapping_iter_n_children;
 187   iface->iter_nth_child = gtk_tree_model_mapping_iter_nth_child;
 188   iface->iter_parent = gtk_tree_model_mapping_iter_parent;
 189   iface->ref_iter = gtk_tree_model_mapping_ref_iter;
 190   iface->unref_iter = gtk_tree_model_mapping_unref_iter;
 191 }
 192
 193 static void
 194 gtk_tree_model_mapping_init (GtkTreeModelMapping *tree_model_mapping)
 195 {
 196 }
 197
 198 GtkTreeModel *
 199 gtk_tree_model_mapping_new (void)
 200 {
 201   return GTK_TREE_MODEL (gtk_type_new (gtk_tree_model_mapping_get_type ()));
 202 }
 203
 204 GtkTreeModel *
 205 gtk_tree_model_mapping_new_with_model (GtkTreeModel      *child_model)
 206 {
 207   GtkTreeModel *retval;
 208
 209   retval = gtk_tree_model_mapping_new ();
 210   gtk_tree_model_mapping_set_model (GTK_TREE_MODEL_MAPPING (retval), child_model);
 211   return retval;
 212 }
 213
 214 void
 215 gtk_tree_model_mapping_set_n_columns (GtkTreeModelMapping *tree_model_mapping,
 216                                       gint                 n_columns)
 217 {
 218   g_return_if_fail (tree_model_mapping != NULL);
 219   g_return_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model_mapping));
 220
 221   tree_model_mapping->n_columns = n_columns;
 222   tree_model_mapping->column_maps = g_realloc (tree_model_mapping->column_maps, sizeof (GtkTreeModelMapping)*n_columns);
 223 }
 224
 225 void
 226 gtk_tree_model_mapping_set_column_mapping (GtkTreeModelMapping *tree_model_mapping,
 227                                            gint                 column,
 228                                            gint                 src_column,
 229                                            GType                col_type,
 230                                            GValueMapFunc        map_func,
 231                                            gpointer             user_data)
 232 {
 233   GtkTreeModelMappingMap *map;
 234
 235   g_return_if_fail (tree_model_mapping != NULL);
 236   g_return_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model_mapping));
 237   g_return_if_fail (column < tree_model_mapping->n_columns);
 238
 239   map = &tree_model_mapping->column_maps[column];
 240   map->src_column = src_column;
 241   map->col_type = col_type;
 242   map->map_func = map_func;
 243   map->user_data = user_data;
 244 }
 245
 246 /**
 247  * gtk_tree_model_mapping_set_model:
 248  * @tree_model_mapping: The #GtkTreeModelMapping.
 249  * @child_model: A #GtkTreeModel, or NULL.
 250  *
 251  * Sets the model of @tree_model_mapping to be @model.  If @model is NULL, then the
 252  * old model is unset.
 253  **/
 254 void
 255 gtk_tree_model_mapping_set_model (GtkTreeModelMapping *tree_model_mapping,
 256                                   GtkTreeModel     *child_model)
 257 {
 258   g_return_if_fail (tree_model_mapping != NULL);
 259   g_return_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model_mapping));
 260
 261   if (child_model)
 262     g_object_ref (G_OBJECT (child_model));
 263
 264   if (tree_model_mapping->child_model)
 265     {
 266       gtk_signal_disconnect_by_func (GTK_OBJECT (tree_model_mapping->child_model),
 267                                      gtk_tree_model_mapping_changed,
 268                                      tree_model_mapping);
 269       gtk_signal_disconnect_by_func (GTK_OBJECT (tree_model_mapping->child_model),
 270                                      gtk_tree_model_mapping_inserted,
 271                                      tree_model_mapping);
 272       gtk_signal_disconnect_by_func (GTK_OBJECT (tree_model_mapping->child_model),
 273                                      gtk_tree_model_mapping_child_toggled,
 274                                      tree_model_mapping);
 275       gtk_signal_disconnect_by_func (GTK_OBJECT (tree_model_mapping->child_model),
 276                                      gtk_tree_model_mapping_deleted,
 277                                      tree_model_mapping);
 278
 279       g_object_unref (G_OBJECT (tree_model_mapping->child_model));
 280     }
 281
 282   tree_model_mapping->child_model = child_model;
 283
 284   if (child_model)
 285     {
 286       gtk_signal_connect (GTK_OBJECT (child_model),
 287                           "changed",
 288                           gtk_tree_model_mapping_changed,
 289                           tree_model_mapping);
 290       gtk_signal_connect (GTK_OBJECT (child_model),
 291                           "inserted",
 292                           gtk_tree_model_mapping_inserted,
 293                           tree_model_mapping);
 294       gtk_signal_connect (GTK_OBJECT (child_model),
 295                           "child_toggled",
 296                           gtk_tree_model_mapping_child_toggled,
 297                           tree_model_mapping);
 298       gtk_signal_connect (GTK_OBJECT (child_model),
 299                           "deleted",
 300                           gtk_tree_model_mapping_deleted,
 301                           tree_model_mapping);
 302     }
 303 }
 304
 305 /**
 306  * gtk_tree_model_mapping_get_model:
 307  * @tree_model: a #GtkTreeModelMapping
 308  *
 309  * Returns the model the #GtkTreeModelMapping is mappinging.
 310  *
 311  * Return value: the "child model" being mappinged
 312  **/
 313 GtkTreeModel*
 314 gtk_tree_model_mapping_get_model (GtkTreeModelMapping  *tree_model)
 315 {
 316   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), NULL);
 317
 318   return tree_model->child_model;
 319 }
 320
 321 static void
 322 gtk_tree_model_mapping_finalize (GObject *object)
 323 {
 324   GtkTreeModelMapping *tree_model_mapping = (GtkTreeModelMapping *) object;
 325
 326   g_free (tree_model_mapping->column_maps);
 327   tree_model_mapping->column_maps = NULL;
 328
 329   if (tree_model_mapping->child_model)
 330     {
 331       g_object_unref (G_OBJECT (tree_model_mapping->child_model));
 332       tree_model_mapping->child_model = NULL;
 333     }
 334 }
 335
 336 static void
 337 gtk_tree_model_mapping_changed (GtkTreeModel             *model,
 338                                 GtkTreePath              *path,
 339                                 GtkTreeIter              *iter,
 340                                 gpointer                  data)
 341 {
 342   gtk_signal_emit_by_name (GTK_OBJECT (data), "changed", path, iter);
 343 }
 344
 345 static void
 346 gtk_tree_model_mapping_inserted (GtkTreeModel             *model,
 347                                  GtkTreePath              *path,
 348                                  GtkTreeIter              *iter,
 349                                  gpointer                  data)
 350 {
 351   gtk_signal_emit_by_name (GTK_OBJECT (data), "inserted", path, iter);
 352 }
 353
 354 static void
 355 gtk_tree_model_mapping_child_toggled (GtkTreeModel             *model,
 356                                       GtkTreePath              *path,
 357                                       GtkTreeIter              *iter,
 358                                       gpointer                  data)
 359 {
 360   gtk_signal_emit_by_name (GTK_OBJECT (data), "child_toggled", path, iter);
 361 }
 362
 363 static void
 364 gtk_tree_model_mapping_deleted (GtkTreeModel             *model,
 365                                 GtkTreePath              *path,
 366                                 gpointer                  data)
 367 {
 368   gtk_signal_emit_by_name (GTK_OBJECT (data), "deleted", path);
 369 }
 370
 371
 372 static GtkTreeModelFlags
 373 gtk_tree_model_mapping_get_flags (GtkTreeModel *tree_model)
 374 {
 375   GtkTreeModel *child_model;
 376
 377   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 378   g_return_val_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL, 0);
 379
 380   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 381
 382   return gtk_tree_model_get_flags (child_model);
 383 }
 384
 385 static gint
 386 gtk_tree_model_mapping_get_n_columns (GtkTreeModel *tree_model)
 387 {
 388   GtkTreeModelMapping *tree_model_mapping;
 389
 390   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 391
 392   tree_model_mapping = GTK_TREE_MODEL_MAPPING (tree_model);
 393
 394   return tree_model_mapping->n_columns;
 395 }
 396
 397 static GType
 398 gtk_tree_model_mapping_get_column_type (GtkTreeModel  *tree_model,
 399                                         gint           index)
 400 {
 401   GtkTreeModelMapping *tree_model_mapping;
 402
 403   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 404
 405   tree_model_mapping = GTK_TREE_MODEL_MAPPING (tree_model);
 406
 407   return tree_model_mapping->column_maps[index].col_type;
 408 }
 409
 410 static gboolean
 411 gtk_tree_model_mapping_get_iter (GtkTreeModel *tree_model,
 412                                  GtkTreeIter  *iter,
 413                                  GtkTreePath  *path)
 414 {
 415   GtkTreeModel *child_model;
 416
 417   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 418   g_return_val_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL, 0);
 419
 420   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 421
 422   return gtk_tree_model_get_iter (child_model, iter, path);
 423 }
 424
 425 static GtkTreePath *
 426 gtk_tree_model_mapping_get_path (GtkTreeModel *tree_model,
 427                                  GtkTreeIter  *iter)
 428 {
 429   GtkTreeModel *child_model;
 430
 431   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 432   g_return_val_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL, 0);
 433
 434   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 435
 436   return gtk_tree_model_get_path (child_model, iter);
 437 }
 438
 439 static void
 440 gtk_tree_model_mapping_get_value (GtkTreeModel  *tree_model,
 441                                   GtkTreeIter   *iter,
 442                                   gint           column,
 443                                   GValue        *value)
 444 {
 445   GValue src_val = { 0, };
 446   GtkTreeModel *child_model;
 447   GtkTreeModelMapping *tree_model_mapping;
 448   GtkTreeModelMappingMap *map;
 449
 450   g_return_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model));
 451   g_return_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL);
 452
 453   tree_model_mapping = GTK_TREE_MODEL_MAPPING (tree_model);
 454   child_model = tree_model_mapping->child_model;
 455
 456   map = &tree_model_mapping->column_maps[column];
 457
 458   gtk_tree_model_get_value (child_model, iter, map->src_column, &src_val);
 459   (* map->map_func) (&src_val, value, map->user_data);
 460   g_value_unset (&src_val);
 461 }
 462
 463 static gboolean
 464 gtk_tree_model_mapping_iter_next (GtkTreeModel *tree_model,
 465                                   GtkTreeIter  *iter)
 466 {
 467   GtkTreeModel *child_model;
 468
 469   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 470   g_return_val_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL, 0);
 471
 472   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 473
 474   return gtk_tree_model_iter_next (child_model, iter);
 475 }
 476
 477 static gboolean
 478 gtk_tree_model_mapping_iter_children (GtkTreeModel *tree_model,
 479                                       GtkTreeIter  *iter,
 480                                       GtkTreeIter  *parent)
 481 {
 482   GtkTreeModel *child_model;
 483
 484   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 485   g_return_val_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL, 0);
 486
 487   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 488   return gtk_tree_model_iter_children (child_model, iter, parent);
 489 }
 490
 491 static gboolean
 492 gtk_tree_model_mapping_iter_has_child (GtkTreeModel *tree_model,
 493                                        GtkTreeIter  *iter)
 494
 495 {
 496   GtkTreeModel *child_model;
 497
 498   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 499   g_return_val_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL, 0);
 500
 501   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 502   return gtk_tree_model_iter_has_child (child_model, iter);
 503 }
 504
 505 static gint
 506 gtk_tree_model_mapping_iter_n_children (GtkTreeModel *tree_model,
 507                                         GtkTreeIter  *iter)
 508 {
 509   GtkTreeModel *child_model;
 510
 511   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 512   g_return_val_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL, 0);
 513
 514   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 515   return gtk_tree_model_iter_n_children (child_model, iter);
 516 }
 517
 518 static gboolean
 519 gtk_tree_model_mapping_iter_nth_child (GtkTreeModel *tree_model,
 520                                        GtkTreeIter  *iter,
 521                                        GtkTreeIter  *parent,
 522                                        gint         n)
 523 {
 524   GtkTreeModel *child_model;
 525
 526   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 527   g_return_val_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL, 0);
 528
 529   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 530   return gtk_tree_model_iter_nth_child (child_model, iter, parent, n);
 531 }
 532
 533 static gboolean
 534 gtk_tree_model_mapping_iter_parent (GtkTreeModel             *tree_model,
 535                                     GtkTreeIter              *iter,
 536                                     GtkTreeIter              *child)
 537 {
 538   GtkTreeModel *child_model;
 539
 540   g_return_val_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model), 0);
 541   g_return_val_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL, 0);
 542
 543   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 544   return gtk_tree_model_iter_parent (child_model, iter, child);
 545 }
 546
 547 static void
 548 gtk_tree_model_mapping_ref_iter (GtkTreeModel *tree_model,
 549                                  GtkTreeIter  *iter)
 550 {
 551   GtkTreeModel *child_model;
 552
 553   g_return_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model));
 554   g_return_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL);
 555
 556   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 557   gtk_tree_model_ref_iter (child_model, iter);
 558 }
 559
 560 static void
 561 gtk_tree_model_mapping_unref_iter (GtkTreeModel *tree_model,
 562                                    GtkTreeIter  *iter)
 563 {
 564   GtkTreeModel *child_model;
 565
 566   g_return_if_fail (GTK_IS_TREE_MODEL_MAPPING (tree_model));
 567   g_return_if_fail (GTK_TREE_MODEL_MAPPING (tree_model)->child_model != NULL);
 568
 569   child_model = GTK_TREE_MODEL_MAPPING (tree_model)->child_model;
 570   gtk_tree_model_unref_iter (child_model, iter);
 571 }