libegg/eggtreemodelunion.c

   1 /**
   2  * eggtreemodelunion.c: Union treemodel implementation
   3  *
   4  * Copyright (C) 2003, Kristian Rietveld
   5  */
   6
   7
   8 /* Notes/ToDo:
   9  *  - there is a nasty bug in here which I can't easily repro. Need to
  10  *    investigate
  11  *  - need to implement_set_child
  12  *  - fix bugs
  13  */
  14
  15 #include "eggtreemodelunion.h"
  16
  17 #include <glib/gprintf.h>
  18 #include <string.h> /* for memcpy */
  19
  20
  21 typedef struct _ModelMap ModelMap;
  22
  23 struct _ModelMap
  24 {
  25   GtkTreeModel *model;
  26   gint nodes;
  27   gint offset;
  28
  29   gint *column_mapping;
  30 };
  31
  32 #define MODEL_MAP(map) ((ModelMap *)map)
  33
  34 /* iter format:
  35  * iter->stamp = umodel->stamp
  36  * iter->user_data = ModelMap
  37  * iter->user_data2 = offset relative to child_model
  38  * iter->user_data3 = index in the child hash.
  39  *
  40  * Iters will be invalidated on insertion/deletion of rows.
  41  */
  42
  43
  44 /* object construction/deconstruction */
  45 static void          egg_tree_model_union_init                      (EggTreeModelUnion *umodel);
  46 static void          egg_tree_model_union_class_init                (EggTreeModelUnionClass *u_class);
  47 static void          egg_tree_model_union_model_init                (GtkTreeModelIface *iface);
  48
  49 static void          egg_tree_model_union_finalize                  (GObject *object);
  50
  51 /* helpers */
  52 static void          egg_tree_model_union_set_n_columns             (EggTreeModelUnion *umodel,
  53                                                                      gint               n_columns);
  54 static void          egg_tree_model_union_set_column_type           (EggTreeModelUnion *umodel,
  55                                                                      gint               column,
  56                                                                      GType              type);
  57 static void          model_map_free                                 (ModelMap          *map);
  58 static GtkTreePath  *get_path_from_hash                             (EggTreeModelUnion *umodel,
  59                                                                      gchar             *str);
  60 static gchar        *path_to_string_without_first                   (GtkTreePath       *path);
  61 static void          egg_tree_model_union_update_stamp              (EggTreeModelUnion *umodel);
  62 static ModelMap     *egg_tree_model_union_get_map_from_offset       (EggTreeModelUnion *umodel,
  63                                                                      gint               offset);
  64 static ModelMap     *egg_tree_model_union_get_map_from_iter          (GtkTreeIter      *iter);
  65 static void          egg_tree_model_union_convert_iter_to_child_iter(EggTreeModelUnion *umodel,
  66                                                                      GtkTreeIter       *child_iter,
  67                                                                      GtkTreeIter       *union_iter);
  68 static gint         egg_tree_model_union_convert_to_child_column    (EggTreeModelUnion *umodel,
  69                                                                      GtkTreeIter       *iter,
  70                                                                      gint               column);
  71 static gboolean     egg_tree_model_union_column_check               (EggTreeModelUnion *umodel,
  72                                                                      GtkTreeModel      *model,
  73                                                                      gint              *column_mapping);
  74 static void         egg_tree_model_union_emit_inserted              (EggTreeModelUnion *umodel,
  75                                                                      gint               start,
  76                                                                      gint               length);
  77 static void         egg_tree_model_union_emit_deleted               (EggTreeModelUnion *umodel,
  78                                                                      gint               start,
  79                                                                      gint               length);
  80
  81 /* TreeModel signals */
  82 static void         egg_tree_model_union_row_changed           (GtkTreeModel *c_model,
  83                                                                 GtkTreePath  *c_path,
  84                                                                 GtkTreeIter  *c_iter,
  85                                                                 gpointer       data);
  86 static void         egg_tree_model_union_row_inserted          (GtkTreeModel *c_model,
  87                                                                 GtkTreePath  *c_path,
  88                                                                 GtkTreeIter  *c_iter,
  89                                                                 gpointer      data);
  90 static void         egg_tree_model_union_row_deleted           (GtkTreeModel *c_model,
  91                                                                 GtkTreePath  *c_path,
  92                                                                 gpointer      data);
  93 static void         egg_tree_model_union_row_has_child_toggled (GtkTreeModel *c_model,
  94                                                                 GtkTreePath  *c_path,
  95                                                                 GtkTreeIter  *c_iter,
  96                                                                 gpointer      data);
  97 static void         egg_tree_model_union_rows_reordered        (GtkTreeModel *c_model,
  98                                                                 GtkTreePath  *c_path,
  99                                                                 GtkTreeIter  *c_iter,
 100                                                                 gint         *new_order,
 101                                                                 gpointer      data);
 102 /* TreeModelIface impl */
 103 static guint        egg_tree_model_union_get_flags       (GtkTreeModel *model);
 104 static gint         egg_tree_model_union_get_n_columns   (GtkTreeModel *model);
 105 static GType        egg_tree_model_union_get_column_type (GtkTreeModel *model,
 106                                                           gint          index);
 107 static gboolean     egg_tree_model_union_get_iter        (GtkTreeModel *model,
 108                                                           GtkTreeIter  *iter,
 109                                                           GtkTreePath  *path);
 110 static GtkTreePath *egg_tree_model_union_get_path        (GtkTreeModel *model,
 111                                                           GtkTreeIter  *iter);
 112 static void         egg_tree_model_union_get_value       (GtkTreeModel *model,
 113                                                           GtkTreeIter  *iter,
 114                                                           gint          column,
 115                                                           GValue       *value);
 116 static gboolean     egg_tree_model_union_iter_next       (GtkTreeModel *model,
 117                                                           GtkTreeIter  *iter);
 118 static gboolean     egg_tree_model_union_iter_children   (GtkTreeModel *model,
 119                                                           GtkTreeIter  *iter,
 120                                                           GtkTreeIter  *parent);
 121 static gboolean     egg_tree_model_union_iter_has_child  (GtkTreeModel *model,
 122                                                           GtkTreeIter  *iter);
 123 static gint         egg_tree_model_union_iter_n_children (GtkTreeModel *model,
 124                                                           GtkTreeIter  *iter);
 125 static gboolean     egg_tree_model_union_iter_nth_child  (GtkTreeModel *model,
 126                                                           GtkTreeIter  *iter,
 127                                                           GtkTreeIter  *parent,
 128                                                           gint          n);
 129 static gboolean     egg_tree_model_union_iter_parent     (GtkTreeModel *model,
 130                                                           GtkTreeIter  *iter,
 131                                                           GtkTreeIter  *child);
 132 static void         egg_tree_model_union_ref_node        (GtkTreeModel *model,
 133                                                           GtkTreeIter  *iter);
 134 static void         egg_tree_model_union_unref_node      (GtkTreeModel *model,
 135                                                           GtkTreeIter  *iter);
 136
 137
 138 static GObjectClass *parent_class = NULL;
 139
 140 GType
 141 egg_tree_model_union_get_type (void)
 142 {
 143   static GType tree_model_union_type = 0;
 144
 145   if (!tree_model_union_type)
 146     {
 147       static const GTypeInfo tree_model_union_info =
 148         {
 149           sizeof (EggTreeModelUnionClass),
 150           NULL,
 151           NULL,
 152           (GClassInitFunc) egg_tree_model_union_class_init,
 153           NULL,
 154           NULL,
 155           sizeof (EggTreeModelUnion),
 156           0,
 157           (GInstanceInitFunc) egg_tree_model_union_init
 158         };
 159
 160       static const GInterfaceInfo tree_model_info =
 161         {
 162           (GInterfaceInitFunc) egg_tree_model_union_model_init,
 163           NULL,
 164           NULL
 165         };
 166
 167       tree_model_union_type = g_type_register_static (G_TYPE_OBJECT,
 168                                                       "EggTreeModelUnion",
 169                                                       &tree_model_union_info, 0);
 170
 171       g_type_add_interface_static (tree_model_union_type,
 172                                    GTK_TYPE_TREE_MODEL,
 173                                    &tree_model_info);
 174     }
 175
 176   return tree_model_union_type;
 177 }
 178
 179 static void
 180 egg_tree_model_union_init (EggTreeModelUnion *umodel)
 181 {
 182   umodel->root = NULL;
 183   umodel->childs = NULL;
 184
 185   umodel->child_paths = g_hash_table_new_full (g_str_hash, g_str_equal,
 186                                                g_free, (GDestroyNotify)gtk_tree_path_free);
 187
 188   umodel->n_columns = 0;
 189   umodel->column_headers = NULL;
 190
 191   umodel->stamp = g_random_int ();
 192 }
 193
 194 static void
 195 egg_tree_model_union_class_init (EggTreeModelUnionClass *u_class)
 196 {
 197   GObjectClass *object_class;
 198
 199   object_class = G_OBJECT_CLASS (u_class);
 200   parent_class = g_type_class_peek_parent (u_class);
 201
 202   object_class->finalize = egg_tree_model_union_finalize;
 203 }
 204
 205 static void
 206 egg_tree_model_union_model_init (GtkTreeModelIface *iface)
 207 {
 208   iface->get_flags = egg_tree_model_union_get_flags;
 209   iface->get_n_columns = egg_tree_model_union_get_n_columns;
 210   iface->get_column_type = egg_tree_model_union_get_column_type;
 211   iface->get_iter = egg_tree_model_union_get_iter;
 212   iface->get_path = egg_tree_model_union_get_path;
 213   iface->get_value = egg_tree_model_union_get_value;
 214   iface->iter_next = egg_tree_model_union_iter_next;
 215   iface->iter_children = egg_tree_model_union_iter_children;
 216   iface->iter_has_child = egg_tree_model_union_iter_has_child;
 217   iface->iter_n_children = egg_tree_model_union_iter_n_children;
 218   iface->iter_nth_child = egg_tree_model_union_iter_nth_child;
 219   iface->iter_parent = egg_tree_model_union_iter_parent;
 220   iface->ref_node = egg_tree_model_union_ref_node;
 221   iface->unref_node = egg_tree_model_union_unref_node;
 222 }
 223
 224
 225 static void
 226 egg_tree_model_union_finalize (GObject *object)
 227 {
 228   EggTreeModelUnion *umodel = (EggTreeModelUnion *) object;
 229
 230   egg_tree_model_union_clear (umodel);
 231
 232   if (umodel->column_headers)
 233     g_free (umodel->column_headers);
 234
 235   if (umodel->child_paths)
 236     g_hash_table_destroy (umodel->child_paths);
 237
 238   /* chain */
 239   parent_class->finalize (object);
 240 }
 241
 242 /* Helpers */
 243 static void
 244 egg_tree_model_union_set_n_columns (EggTreeModelUnion *umodel,
 245                                     gint               n_columns)
 246 {
 247   GType *new_columns;
 248
 249   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
 250
 251   if (umodel->n_columns == n_columns)
 252     return;
 253
 254   new_columns = g_new0 (GType, n_columns);
 255   if (umodel->column_headers)
 256     {
 257       /* copy the old header orders over */
 258       if (n_columns >= umodel->n_columns)
 259         memcpy (new_columns, umodel->column_headers, umodel->n_columns * sizeof (gchar *));
 260       else
 261         memcpy (new_columns, umodel->column_headers, n_columns * sizeof (GType));
 262
 263       g_free (umodel->column_headers);
 264     }
 265
 266   umodel->column_headers = new_columns;
 267   umodel->n_columns = n_columns;
 268 }
 269
 270 static void
 271 egg_tree_model_union_set_column_type (EggTreeModelUnion *umodel,
 272                                       gint               column,
 273                                       GType              type)
 274 {
 275   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
 276   g_return_if_fail (column >= 0 && column < umodel->n_columns);
 277
 278   umodel->column_headers[column] = type;
 279 }
 280
 281 static void
 282 model_map_free (ModelMap *map)
 283 {
 284   if (map->column_mapping)
 285     g_free (map->column_mapping);
 286
 287   g_free (map);
 288 }
 289
 290 static GtkTreePath *
 291 get_path_from_hash (EggTreeModelUnion *umodel,
 292                     gchar *str)
 293 {
 294   gpointer ret;
 295
 296   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (umodel), NULL);
 297
 298   ret = g_hash_table_lookup (umodel->child_paths, str);
 299
 300   if (ret)
 301     return ret;
 302
 303   ret = gtk_tree_path_new_from_string (str);
 304   g_hash_table_insert (umodel->child_paths, g_strdup (str), ret);
 305
 306   return ret;
 307 }
 308
 309 static gchar *
 310 path_to_string_without_first (GtkTreePath *path)
 311 {
 312   gint i;
 313   gchar *str, *ptr;
 314
 315   gint depth = gtk_tree_path_get_depth (path);
 316   gint *indices = gtk_tree_path_get_indices (path);
 317
 318   /* NOTE: we skip the first index here */
 319   str = ptr = (gchar *)g_new0 (gchar, depth * 8);
 320   g_sprintf (str, "%d", indices[1]);
 321   while (*ptr != '\0')
 322     ptr++;
 323
 324   for (i = 2; i < depth; i++)
 325     {
 326       g_sprintf (ptr, ":%d", indices[i]);
 327       while (*ptr != '\0')
 328         ptr++;
 329     }
 330
 331   return str;
 332 }
 333
 334 static void
 335 egg_tree_model_union_update_stamp (EggTreeModelUnion *umodel)
 336 {
 337   do
 338     {
 339       umodel->stamp++;
 340     }
 341   while (!umodel->stamp);
 342 }
 343
 344 static ModelMap *
 345 egg_tree_model_union_get_map_from_offset (EggTreeModelUnion *umodel,
 346                                           gint               offset)
 347 {
 348   GList *i;
 349
 350   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (umodel), NULL);
 351
 352   if (offset < 0 || offset >= umodel->length)
 353     return NULL;
 354
 355   for (i = umodel->root; i; i = i->next)
 356     {
 357       ModelMap *map = MODEL_MAP (i->data);
 358
 359       if (map->offset <= offset
 360           && offset < map->offset + map->nodes)
 361         return map;
 362     }
 363
 364   return NULL;
 365 }
 366
 367 static ModelMap *
 368 egg_tree_model_union_get_map_from_iter (GtkTreeIter *iter)
 369 {
 370   return MODEL_MAP (iter->user_data);
 371 }
 372
 373 static ModelMap *
 374 egg_tree_model_union_get_map_from_model (EggTreeModelUnion *umodel,
 375                                          GtkTreeModel      *model)
 376 {
 377   GList *i;
 378
 379   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (umodel), NULL);
 380
 381   for (i = umodel->root; i; i = i->next)
 382     if (MODEL_MAP (i->data)->model == model)
 383       return MODEL_MAP (i->data);
 384
 385   return NULL;
 386 }
 387
 388 static void
 389 egg_tree_model_union_convert_iter_to_union_iter (EggTreeModelUnion *umodel,
 390                                                  GtkTreeModel      *model,
 391                                                  GtkTreeIter       *child_iter,
 392                                                  GtkTreeIter       *union_iter)
 393 {
 394   ModelMap *map;
 395   GtkTreePath *path;
 396
 397   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
 398   g_return_if_fail (GTK_IS_TREE_MODEL (model));
 399
 400   map = egg_tree_model_union_get_map_from_model (umodel, model);
 401
 402   if (!map)
 403     {
 404       union_iter->stamp = 0;
 405       return;
 406     }
 407
 408   path = gtk_tree_model_get_path (model, child_iter);
 409   if (!path)
 410     {
 411       union_iter->stamp = 0;
 412       return;
 413     }
 414
 415   union_iter->stamp = umodel->stamp;
 416   union_iter->user_data = map;
 417   union_iter->user_data2 = GINT_TO_POINTER (gtk_tree_path_get_indices (path)[0]);
 418
 419   if (gtk_tree_path_get_depth (path) > 1)
 420     {
 421       gchar *str = path_to_string_without_first (path);
 422
 423       union_iter->user_data3 = get_path_from_hash (umodel, str);
 424       g_free (str);
 425     }
 426   else
 427     union_iter->user_data3 = NULL;
 428
 429   gtk_tree_path_free (path);
 430 }
 431
 432 static void
 433 egg_tree_model_union_convert_iter_to_child_iter (EggTreeModelUnion *umodel,
 434                                                  GtkTreeIter       *child_iter,
 435                                                  GtkTreeIter       *union_iter)
 436 {
 437   ModelMap *map;
 438   GtkTreePath *path;
 439
 440   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
 441   g_return_if_fail (umodel->stamp == union_iter->stamp);
 442
 443   map = egg_tree_model_union_get_map_from_iter (union_iter);
 444
 445   if (union_iter->user_data3)
 446     path = gtk_tree_path_copy (union_iter->user_data3);
 447   else
 448     path = gtk_tree_path_new ();
 449
 450   gtk_tree_path_prepend_index (path, GPOINTER_TO_INT (union_iter->user_data2));
 451   gtk_tree_model_get_iter (map->model, child_iter, path);
 452
 453   gtk_tree_path_free (path);
 454 }
 455
 456 static gint
 457 egg_tree_model_union_convert_to_child_column (EggTreeModelUnion *umodel,
 458                                               GtkTreeIter       *iter,
 459                                               gint               column)
 460 {
 461   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (umodel), 0);
 462   g_return_val_if_fail (umodel->stamp == iter->stamp, 0);
 463   g_return_val_if_fail (column >= 0 && column < umodel->n_columns, 0);
 464
 465   if (!MODEL_MAP (iter->user_data)->column_mapping)
 466     return column;
 467
 468   return (MODEL_MAP (iter->user_data))->column_mapping[column];
 469 }
 470
 471 static gboolean
 472 egg_tree_model_union_column_check (EggTreeModelUnion *umodel,
 473                                    GtkTreeModel      *model,
 474                                    gint              *column_mapping)
 475 {
 476   gint i;
 477
 478   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (umodel), FALSE);
 479   g_return_val_if_fail (GTK_IS_TREE_MODEL (model), FALSE);
 480
 481   for (i = 0; i < umodel->n_columns; i++)
 482     {
 483       GType type;
 484
 485       if (column_mapping)
 486         type = gtk_tree_model_get_column_type (model, column_mapping[i]);
 487       else
 488         type = gtk_tree_model_get_column_type (model, i);
 489
 490       if (type != umodel->column_headers[i])
 491         return FALSE;
 492     }
 493
 494   return TRUE;
 495 }
 496
 497 static void
 498 egg_tree_model_union_emit_inserted (EggTreeModelUnion *umodel,
 499                                     gint               start,
 500                                     gint               length)
 501 {
 502   gint i;
 503   GtkTreeIter iter;
 504   GtkTreePath *path;
 505
 506   if (!length)
 507     return;
 508
 509   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
 510
 511   path = gtk_tree_path_new_from_indices (start, -1);
 512   egg_tree_model_union_get_iter (GTK_TREE_MODEL (umodel), &iter, path);
 513
 514   /* FIXME: do we need to emit inserted for child nodes? */
 515
 516   for (i = 0; i < length; i++)
 517     {
 518       gtk_tree_model_row_inserted (GTK_TREE_MODEL (umodel), path, &iter);
 519       gtk_tree_path_next (path);
 520       egg_tree_model_union_iter_next (GTK_TREE_MODEL (umodel), &iter);
 521     }
 522
 523   gtk_tree_path_free (path);
 524 }
 525
 526 static void
 527 egg_tree_model_union_emit_deleted (EggTreeModelUnion *umodel,
 528                                    gint               start,
 529                                    gint               length)
 530 {
 531   gint i;
 532   GtkTreePath *path;
 533
 534   if (!length)
 535     return;
 536
 537   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
 538
 539   path = gtk_tree_path_new_from_indices (start, -1);
 540
 541   /* FIXME: do we need to emit deleted for child nodes? */
 542
 543   for (i = 0; i < length; i++)
 544     {
 545       gtk_tree_model_row_deleted (GTK_TREE_MODEL (umodel), path);
 546       gtk_tree_path_next (path);
 547     }
 548
 549   gtk_tree_path_free (path);
 550 }
 551
 552 /* TreeModel signals */
 553 static void
 554 egg_tree_model_union_row_changed (GtkTreeModel *c_model,
 555                                   GtkTreePath  *c_path,
 556                                   GtkTreeIter  *c_iter,
 557                                   gpointer      data)
 558 {
 559   EggTreeModelUnion *umodel = EGG_TREE_MODEL_UNION (data);
 560   GtkTreeIter uiter;
 561   GtkTreePath *path;
 562
 563   g_return_if_fail (GTK_IS_TREE_MODEL (c_model));
 564   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (data));
 565
 566   /* translate the iter to a union iter and pass the event on */
 567   egg_tree_model_union_convert_iter_to_union_iter (umodel, c_model,
 568                                                    c_iter, &uiter);
 569
 570   path = egg_tree_model_union_get_path (GTK_TREE_MODEL (data), &uiter);
 571   gtk_tree_model_row_changed (GTK_TREE_MODEL (data), path, &uiter);
 572   gtk_tree_path_free (path);
 573 }
 574
 575 static void
 576 egg_tree_model_union_row_inserted (GtkTreeModel *c_model,
 577                                    GtkTreePath  *c_path,
 578                                    GtkTreeIter  *c_iter,
 579                                    gpointer      data)
 580 {
 581   gint position;
 582   GList *i;
 583   EggTreeModelUnion *umodel = EGG_TREE_MODEL_UNION (data);
 584
 585   g_return_if_fail (GTK_IS_TREE_MODEL (c_model));
 586   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (data));
 587
 588   if (gtk_tree_path_get_depth (c_path) > 1)
 589     {
 590       GtkTreeIter uiter;
 591       GtkTreePath *path;
 592
 593       /* translate and propagate */
 594       egg_tree_model_union_convert_iter_to_union_iter (umodel,
 595                                                        c_model,
 596                                                        c_iter,
 597                                                        &uiter);
 598       path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &uiter);
 599       gtk_tree_model_row_inserted (GTK_TREE_MODEL (data), path, &uiter);
 600       gtk_tree_path_free (path);
 601
 602       return;
 603     }
 604
 605   for (i = umodel->root; i; i = i->next)
 606     if (MODEL_MAP (i->data)->model == c_model)
 607       break;
 608
 609   if (!i)
 610     return;
 611
 612   MODEL_MAP (i->data)->nodes++;
 613   position = MODEL_MAP (i->data)->offset;
 614
 615   for (i = i->next; i; i = i->next)
 616     MODEL_MAP (i->data)->offset++;
 617
 618   position += gtk_tree_path_get_indices (c_path)[0];
 619
 620   umodel->length++;
 621
 622   egg_tree_model_union_update_stamp (umodel);
 623   egg_tree_model_union_emit_inserted (umodel, position, 1);
 624 }
 625
 626 static void
 627 egg_tree_model_union_row_deleted (GtkTreeModel *c_model,
 628                                   GtkTreePath  *c_path,
 629                                   gpointer      data)
 630 {
 631   GList *i;
 632   gint position;
 633   EggTreeModelUnion *umodel = EGG_TREE_MODEL_UNION (data);
 634
 635   g_return_if_fail (GTK_IS_TREE_MODEL (c_model));
 636   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (data));
 637
 638   for (i = umodel->root; i; i = i->next)
 639     if (MODEL_MAP (i->data)->model == c_model)
 640       break;
 641
 642   if (!i)
 643     return;
 644
 645   if (gtk_tree_path_get_depth (c_path) > 1)
 646     {
 647       GtkTreePath *path = gtk_tree_path_copy (c_path);
 648
 649       gtk_tree_path_get_indices (path)[0] += MODEL_MAP (i->data)->offset;
 650       gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
 651       gtk_tree_path_free (path);
 652
 653       return;
 654     }
 655
 656   MODEL_MAP (i->data)->nodes--;
 657   position = MODEL_MAP (i->data)->offset;
 658
 659   for (i = i->next; i; i = i->next)
 660     MODEL_MAP (i->data)->offset--;
 661
 662   position += gtk_tree_path_get_indices (c_path)[0];
 663
 664   umodel->length--;
 665
 666   egg_tree_model_union_update_stamp (umodel);
 667   egg_tree_model_union_emit_deleted (umodel, position, 1);
 668 }
 669
 670 static void
 671 egg_tree_model_union_row_has_child_toggled (GtkTreeModel *c_model,
 672                                             GtkTreePath  *c_path,
 673                                             GtkTreeIter  *c_iter,
 674                                             gpointer      data)
 675 {
 676   GtkTreeIter uiter;
 677   GtkTreePath *path;
 678   EggTreeModelUnion *umodel = EGG_TREE_MODEL_UNION (data);
 679
 680   g_return_if_fail (GTK_IS_TREE_MODEL (c_model));
 681   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (data));
 682
 683   /* translate the iter to a union iter and pass the event on */
 684   egg_tree_model_union_convert_iter_to_union_iter (umodel, c_model,
 685                                                    c_iter, &uiter);
 686
 687   path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &uiter);
 688   gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data), path, &uiter);
 689   gtk_tree_path_free (path);
 690 }
 691
 692 typedef struct
 693 {
 694   GtkTreePath *root;
 695   gint level;
 696   gint *order;
 697 } ReorderInfo;
 698
 699 static void
 700 reorder_func (GtkTreePath *path,
 701               ReorderInfo *ri)
 702 {
 703   gtk_tree_path_get_indices (path)[0] = gtk_tree_path_get_indices (ri->root)[0];
 704
 705   if (!gtk_tree_path_is_descendant (path, ri->root))
 706     return;
 707
 708   gtk_tree_path_get_indices (path)[ri->level] = ri->order[gtk_tree_path_get_indices (path)[ri->level]];
 709 }
 710
 711 static void
 712 egg_tree_model_union_rows_reordered (GtkTreeModel *c_model,
 713                                      GtkTreePath  *c_path,
 714                                      GtkTreeIter  *c_iter,
 715                                      gint         *new_order,
 716                                      gpointer      data)
 717 {
 718   gint i;
 719   gint *order;
 720   ModelMap *map;
 721   EggTreeModelUnion *umodel = EGG_TREE_MODEL_UNION (data);
 722
 723   g_return_if_fail (GTK_IS_TREE_MODEL (c_model));
 724   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (data));
 725
 726   map = egg_tree_model_union_get_map_from_model (umodel, c_model);
 727   if (!map)
 728     return;
 729
 730   if (gtk_tree_path_get_depth (c_path) > 0)
 731     {
 732       GtkTreePath *path;
 733       GtkTreeIter uiter;
 734       ReorderInfo ri;
 735
 736       ri.root = c_path;
 737       ri.level = gtk_tree_path_get_depth (c_path);
 738       ri.order = new_order;
 739
 740       g_hash_table_foreach (umodel->child_paths, (GHFunc)reorder_func, &ri);
 741
 742       /* convert the iter and emit the signal */
 743       egg_tree_model_union_convert_iter_to_union_iter (umodel, c_model,
 744                                                        c_iter, &uiter);
 745
 746       path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &uiter);
 747       gtk_tree_model_rows_reordered (GTK_TREE_MODEL (data), path,
 748                                      &uiter, new_order);
 749       gtk_tree_path_free (path);
 750
 751       return;
 752     }
 753
 754   order = g_new (gint, umodel->length);
 755   for (i = 0; i < umodel->length; i++)
 756     if (i < map->offset || i >= map->offset + map->nodes)
 757       order[i] = i;
 758     else
 759       order[i] = new_order[i] + map->offset;
 760
 761   gtk_tree_model_rows_reordered (GTK_TREE_MODEL (data), NULL, NULL, order);
 762   g_free (order);
 763 }
 764
 765 /* TreeModelIface implementation */
 766 static guint
 767 egg_tree_model_union_get_flags (GtkTreeModel *model)
 768 {
 769   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), 0);
 770
 771   return 0;
 772 }
 773
 774 static gint
 775 egg_tree_model_union_get_n_columns (GtkTreeModel *model)
 776 {
 777   EggTreeModelUnion *umodel = (EggTreeModelUnion *)model;
 778
 779   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), 0);
 780
 781   return umodel->n_columns;
 782 }
 783
 784 static GType
 785 egg_tree_model_union_get_column_type (GtkTreeModel *model,
 786                                       gint          index)
 787 {
 788   EggTreeModelUnion *umodel = (EggTreeModelUnion *)model;
 789
 790   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), G_TYPE_INVALID);
 791   g_return_val_if_fail (index >= 0 && index < umodel->n_columns, G_TYPE_INVALID);
 792
 793   return umodel->column_headers[index];
 794 }
 795
 796 static gboolean
 797 egg_tree_model_union_get_iter (GtkTreeModel *model,
 798                                GtkTreeIter  *iter,
 799                                GtkTreePath  *path)
 800 {
 801   ModelMap *map;
 802   GtkTreeIter c_iter;
 803   GtkTreePath *c_path;
 804   EggTreeModelUnion *umodel = (EggTreeModelUnion *)model;
 805
 806   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), FALSE);
 807   g_return_val_if_fail (iter, FALSE);
 808
 809   /* we don't want a warning on the screen if this fails */
 810   if (!umodel->root)
 811     {
 812       iter->stamp = 0;
 813       return FALSE;
 814     }
 815
 816   map = egg_tree_model_union_get_map_from_offset (umodel, gtk_tree_path_get_indices (path)[0]);
 817
 818   if (!map)
 819     {
 820       iter->stamp = 0;
 821       return FALSE;
 822     }
 823
 824   /* check if the iter actually exists in the child model */
 825   c_path = gtk_tree_path_copy (path);
 826   gtk_tree_path_get_indices (c_path)[0] -= map->offset;
 827
 828   if (!gtk_tree_model_get_iter (map->model, &c_iter, c_path))
 829     {
 830       gtk_tree_path_free (c_path);
 831       return FALSE;
 832     }
 833
 834   gtk_tree_path_free (c_path);
 835
 836   iter->stamp = umodel->stamp;
 837   iter->user_data = map;
 838   iter->user_data2 = GINT_TO_POINTER (gtk_tree_path_get_indices (path)[0] - map->offset);
 839
 840   if (gtk_tree_path_get_depth (path) > 1)
 841     {
 842       gchar *str = path_to_string_without_first (path);
 843
 844       iter->user_data3 = get_path_from_hash (umodel, str);
 845       g_free (str);
 846     }
 847   else
 848     iter->user_data3 = NULL;
 849
 850   return TRUE;
 851 }
 852
 853 static GtkTreePath *
 854 egg_tree_model_union_get_path (GtkTreeModel *model,
 855                                GtkTreeIter  *iter)
 856 {
 857   EggTreeModelUnion *umodel = (EggTreeModelUnion *)model;
 858   GtkTreePath *path;
 859   ModelMap *map;
 860
 861   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), NULL);
 862   g_return_val_if_fail (umodel->stamp == iter->stamp, NULL);
 863   g_return_val_if_fail (umodel->root, NULL);
 864
 865   map = egg_tree_model_union_get_map_from_iter (iter);
 866
 867   if (iter->user_data3)
 868     {
 869       path = gtk_tree_path_copy (iter->user_data3);
 870     }
 871   else
 872     path = gtk_tree_path_new ();
 873
 874   gtk_tree_path_prepend_index (path, map->offset + GPOINTER_TO_INT (iter->user_data2));
 875
 876   return path;
 877 }
 878
 879 static void
 880 egg_tree_model_union_get_value (GtkTreeModel *model,
 881                                 GtkTreeIter  *iter,
 882                                 gint          column,
 883                                 GValue       *value)
 884 {
 885   EggTreeModelUnion *umodel = (EggTreeModelUnion *)model;
 886   GtkTreeIter child_iter;
 887   gint col;
 888
 889   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (model));
 890   g_return_if_fail (umodel->stamp == iter->stamp);
 891   g_return_if_fail (umodel->root);
 892
 893   egg_tree_model_union_convert_iter_to_child_iter (umodel, &child_iter, iter);
 894   col = egg_tree_model_union_convert_to_child_column (umodel, iter, column);
 895   gtk_tree_model_get_value (MODEL_MAP (iter->user_data)->model,
 896                             &child_iter, col, value);
 897 }
 898
 899 static gboolean
 900 egg_tree_model_union_iter_next (GtkTreeModel *model,
 901                                 GtkTreeIter  *iter)
 902 {
 903   EggTreeModelUnion *umodel = (EggTreeModelUnion *)model;
 904   GtkTreePath *path;
 905   gboolean ret;
 906
 907   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), FALSE);
 908   g_return_val_if_fail (umodel->stamp == iter->stamp, FALSE);
 909   g_return_val_if_fail (umodel->root, FALSE);
 910
 911   /* let's do it the lazy and easy way */
 912   path = egg_tree_model_union_get_path (model, iter);
 913   gtk_tree_path_next (path);
 914
 915   ret = egg_tree_model_union_get_iter (model, iter, path);
 916   gtk_tree_path_free (path);
 917
 918   return ret;
 919 }
 920
 921 static gboolean
 922 egg_tree_model_union_iter_children (GtkTreeModel *model,
 923                                     GtkTreeIter  *iter,
 924                                     GtkTreeIter  *parent)
 925 {
 926   ModelMap *map;
 927   GtkTreeIter child_iter;
 928   GtkTreeIter child_iter2;
 929   EggTreeModelUnion *umodel = EGG_TREE_MODEL_UNION (model);
 930
 931   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), FALSE);
 932
 933   if (!parent)
 934     {
 935       gtk_tree_model_get_iter_first (model, iter);
 936       return TRUE;
 937     }
 938
 939   g_return_val_if_fail (umodel->stamp == parent->stamp, FALSE);
 940
 941   map = egg_tree_model_union_get_map_from_iter (parent);
 942
 943   egg_tree_model_union_convert_iter_to_child_iter (umodel, &child_iter,
 944                                                    parent);
 945
 946   if (!gtk_tree_model_iter_children (map->model, &child_iter2, &child_iter))
 947     {
 948       iter->stamp = 0;
 949       return FALSE;
 950     }
 951
 952   egg_tree_model_union_convert_iter_to_union_iter (umodel, map->model,
 953                                                    &child_iter2, iter);
 954
 955   return TRUE;
 956 }
 957
 958 static gboolean
 959 egg_tree_model_union_iter_has_child (GtkTreeModel *model,
 960                                      GtkTreeIter  *iter)
 961 {
 962   ModelMap *map;
 963   GtkTreeIter child_iter;
 964   EggTreeModelUnion *umodel = EGG_TREE_MODEL_UNION (model);
 965
 966   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), FALSE);
 967
 968   if (!iter)
 969     return TRUE;
 970
 971   g_return_val_if_fail (umodel->stamp == iter->stamp, FALSE);
 972
 973   map = egg_tree_model_union_get_map_from_iter (iter);
 974
 975   egg_tree_model_union_convert_iter_to_child_iter (umodel, &child_iter,
 976                                                    iter);
 977
 978   return gtk_tree_model_iter_has_child (map->model, &child_iter);
 979 }
 980
 981 static gint
 982 egg_tree_model_union_iter_n_children (GtkTreeModel *model,
 983                                       GtkTreeIter  *iter)
 984 {
 985   ModelMap *map;
 986   GtkTreeIter child_iter;
 987   EggTreeModelUnion *umodel = (EggTreeModelUnion *)model;
 988
 989   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), 0);
 990
 991   if (!iter)
 992     return umodel->length;
 993
 994   g_return_val_if_fail (umodel->stamp == iter->stamp, FALSE);
 995
 996   map = egg_tree_model_union_get_map_from_iter (iter);
 997
 998   egg_tree_model_union_convert_iter_to_child_iter (umodel, &child_iter,
 999                                                    iter);
1000
1001   return gtk_tree_model_iter_n_children (map->model, &child_iter);
1002 }
1003
1004 static gboolean
1005 egg_tree_model_union_iter_nth_child (GtkTreeModel *model,
1006                                      GtkTreeIter  *iter,
1007                                      GtkTreeIter  *parent,
1008                                      gint          n)
1009 {
1010   EggTreeModelUnion *umodel = (EggTreeModelUnion *)model;
1011   GtkTreePath *path;
1012   gboolean ret;
1013
1014   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), FALSE);
1015
1016   if (!parent)
1017     {
1018       path = gtk_tree_path_new_from_indices (n, -1);
1019       ret = egg_tree_model_union_get_iter (model, iter, path);
1020       gtk_tree_path_free (path);
1021
1022       return TRUE;
1023     }
1024
1025   g_return_val_if_fail (umodel->stamp == parent->stamp, FALSE);
1026
1027   path = gtk_tree_model_get_path (model, parent);
1028   gtk_tree_path_append_index (path, n);
1029
1030   ret = gtk_tree_model_get_iter (model, iter, path);
1031
1032   gtk_tree_path_free (path);
1033
1034   return ret;
1035 }
1036
1037 static gboolean
1038 egg_tree_model_union_iter_parent (GtkTreeModel *model,
1039                                   GtkTreeIter  *iter,
1040                                   GtkTreeIter  *child)
1041 {
1042   EggTreeModelUnion *umodel = (EggTreeModelUnion *)model;
1043   GtkTreePath *path;
1044   gboolean ret;
1045
1046   g_return_val_if_fail (EGG_IS_TREE_MODEL_UNION (model), FALSE);
1047
1048   if (!child)
1049     {
1050       iter->stamp = 0;
1051       return FALSE;
1052     }
1053
1054   g_return_val_if_fail (umodel->stamp == child->stamp, FALSE);
1055
1056   path = gtk_tree_model_get_path (model, child);
1057
1058   if (gtk_tree_path_get_depth (path) <= 1)
1059     {
1060       gtk_tree_path_free (path);
1061
1062       iter->stamp = 0;
1063       return FALSE;
1064     }
1065
1066   gtk_tree_path_up (path);
1067
1068   ret = gtk_tree_model_get_iter (model, iter, path);
1069   gtk_tree_path_free (path);
1070
1071   return ret;
1072 }
1073
1074 static void
1075 egg_tree_model_union_ref_node (GtkTreeModel *model,
1076                                GtkTreeIter  *iter)
1077 {
1078 }
1079
1080 static void
1081 egg_tree_model_union_unref_node (GtkTreeModel *model,
1082                                  GtkTreeIter  *iter)
1083 {
1084 }
1085
1086 /* public API */
1087 GtkTreeModel *
1088 egg_tree_model_union_new (gint n_columns,
1089                           ...)
1090 {
1091   EggTreeModelUnion *retval;
1092   va_list args;
1093   gint i;
1094
1095   g_return_val_if_fail (n_columns > 0, NULL);
1096
1097   retval = g_object_new (EGG_TYPE_TREE_MODEL_UNION, NULL);
1098   egg_tree_model_union_set_n_columns (retval, n_columns);
1099
1100   va_start (args, n_columns);
1101
1102   for (i = 0; i < n_columns; i++)
1103     {
1104       GType type = va_arg (args, GType);
1105       egg_tree_model_union_set_column_type (retval, i, type);
1106     }
1107
1108   va_end (args);
1109
1110   return GTK_TREE_MODEL (retval);
1111 }
1112
1113 GtkTreeModel *
1114 egg_tree_model_union_newv (gint   n_columns,
1115                            GType *types)
1116 {
1117   EggTreeModelUnion *retval;
1118   gint i;
1119
1120   g_return_val_if_fail (n_columns > 0, NULL);
1121
1122   retval = g_object_new (EGG_TYPE_TREE_MODEL_UNION, NULL);
1123   egg_tree_model_union_set_n_columns (retval, n_columns);
1124
1125   for (i = 0; i < n_columns; i++)
1126     egg_tree_model_union_set_column_type (retval, i, types[i]);
1127
1128   return GTK_TREE_MODEL (retval);
1129 }
1130
1131 void
1132 egg_tree_model_union_set_column_types (EggTreeModelUnion *umodel,
1133                                        gint               n_types,
1134                                        GType             *types)
1135 {
1136   /* FIXME */
1137 }
1138
1139
1140 void
1141 egg_tree_model_union_append (EggTreeModelUnion *umodel,
1142                              GtkTreeModel      *model)
1143 {
1144   egg_tree_model_union_insert (umodel, model, -1);
1145 }
1146
1147 void
1148 egg_tree_model_union_prepend (EggTreeModelUnion *umodel,
1149                               GtkTreeModel      *model)
1150 {
1151   egg_tree_model_union_insert (umodel, model, 0);
1152 }
1153
1154 void
1155 egg_tree_model_union_insert (EggTreeModelUnion *umodel,
1156                              GtkTreeModel      *model,
1157                              gint               position)
1158 {
1159   egg_tree_model_union_insert_with_mappingv (umodel, model, position, NULL);
1160 }
1161
1162 void
1163 egg_tree_model_union_append_with_mapping (EggTreeModelUnion *umodel,
1164                                           GtkTreeModel      *model,
1165                                           ...)
1166 {
1167   gint *column_mapping;
1168   va_list args;
1169   gint i;
1170
1171   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
1172
1173   column_mapping = g_new0 (gint, umodel->n_columns);
1174
1175   va_start (args, model);
1176   for (i = 0; i < umodel->n_columns; i++)
1177     column_mapping[i] = va_arg (args, gint);
1178   va_end (args);
1179
1180   egg_tree_model_union_insert_with_mappingv (umodel, model, -1, column_mapping);
1181
1182   g_free (column_mapping);
1183
1184 }
1185
1186 void
1187 egg_tree_model_union_prepend_with_mapping (EggTreeModelUnion *umodel,
1188                                            GtkTreeModel      *model,
1189                                            ...)
1190 {
1191   gint *column_mapping;
1192   va_list args;
1193   gint i;
1194
1195   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
1196
1197   column_mapping = g_new0 (gint, umodel->n_columns);
1198
1199   va_start (args, model);
1200   for (i = 0; i < umodel->n_columns; i++)
1201     column_mapping[i] = va_arg (args, gint);
1202   va_end (args);
1203
1204   egg_tree_model_union_insert_with_mappingv (umodel, model, 0, column_mapping);
1205
1206   g_free (column_mapping);
1207 }
1208
1209 void
1210 egg_tree_model_union_insert_with_mapping (EggTreeModelUnion *umodel,
1211                                           GtkTreeModel      *model,
1212                                           gint               position,
1213                                           ...)
1214 {
1215   gint *column_mapping;
1216   va_list args;
1217   gint i;
1218
1219   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
1220
1221   column_mapping = g_new0 (gint, umodel->n_columns);
1222
1223   va_start (args, position);
1224   for (i = 0; i < umodel->n_columns; i++)
1225     column_mapping[i] = va_arg (args, gint);
1226   va_end (args);
1227
1228   egg_tree_model_union_insert_with_mappingv (umodel, model, position, column_mapping);
1229
1230   g_free (column_mapping);
1231 }
1232
1233 void
1234 egg_tree_model_union_insert_with_mappingv (EggTreeModelUnion *umodel,
1235                                            GtkTreeModel      *model,
1236                                            gint               position,
1237                                            gint              *column_mapping)
1238 {
1239   ModelMap *map;
1240
1241   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
1242   g_return_if_fail (GTK_IS_TREE_MODEL (model));
1243
1244   /* leaks ... */
1245   if (column_mapping)
1246     g_return_if_fail (egg_tree_model_union_column_check (umodel, model, column_mapping));
1247   else
1248     g_return_if_fail (egg_tree_model_union_column_check (umodel, model, NULL));
1249
1250   g_object_ref (G_OBJECT (model));
1251
1252   map = g_new0 (ModelMap, 1);
1253   map->model = model;
1254   map->nodes = gtk_tree_model_iter_n_children (model, NULL);
1255   if (column_mapping)
1256     {
1257       map->column_mapping = g_new0 (gint, umodel->n_columns);
1258       memcpy (map->column_mapping, column_mapping, sizeof (gint) * umodel->n_columns);
1259     }
1260
1261   umodel->length += map->nodes;
1262
1263   g_signal_connect (model, "row_inserted",
1264                     G_CALLBACK (egg_tree_model_union_row_inserted), umodel);
1265   g_signal_connect (model, "row_changed",
1266                     G_CALLBACK (egg_tree_model_union_row_changed), umodel);
1267   g_signal_connect (model, "row_deleted",
1268                     G_CALLBACK (egg_tree_model_union_row_deleted), umodel);
1269   g_signal_connect (model, "row_has_child_toggled",
1270                     G_CALLBACK (egg_tree_model_union_row_has_child_toggled),
1271                     umodel);
1272   g_signal_connect (model, "rows_reordered",
1273                     G_CALLBACK (egg_tree_model_union_rows_reordered), umodel);
1274
1275   if (position == 0)
1276     {
1277       GList *j;
1278
1279       umodel->root = g_list_prepend (umodel->root, map);
1280       map->offset = 0;
1281
1282       /* fix up offsets */
1283       for (j = umodel->root->next; j; j = j->next)
1284         MODEL_MAP (j->data)->offset += map->nodes;
1285
1286       /* update stamp */
1287       egg_tree_model_union_update_stamp (umodel);
1288
1289       /* emit signals */
1290       egg_tree_model_union_emit_inserted (umodel, 0, map->nodes);
1291     }
1292   else if (position == -1)
1293     {
1294       GList *j;
1295
1296       map->offset = 0;
1297
1298       for (j = umodel->root; j; j = j->next)
1299         map->offset += MODEL_MAP (j->data)->nodes;
1300
1301       umodel->root = g_list_append (umodel->root, map);
1302
1303       /* update stamp */
1304       egg_tree_model_union_update_stamp (umodel);
1305
1306       /* emit signals */
1307       egg_tree_model_union_emit_inserted (umodel, map->offset, map->nodes);
1308     }
1309   else
1310     {
1311       GList *j;
1312
1313       umodel->root = g_list_insert (umodel->root, map, position);
1314
1315       map->offset = 0;
1316
1317       for (j = umodel->root; j->data != map; j = j->next)
1318         map->offset += MODEL_MAP (j->data)->nodes;
1319
1320       for (j = j->next; j; j = j->next)
1321         MODEL_MAP (j->data)->offset += map->nodes;
1322
1323       /* update stamp */
1324       egg_tree_model_union_update_stamp (umodel);
1325
1326       /* emit signals */
1327       egg_tree_model_union_emit_inserted (umodel, map->offset, map->nodes);
1328     }
1329 }
1330
1331 void
1332 egg_tree_model_union_clear (EggTreeModelUnion *umodel)
1333 {
1334   gint length;
1335
1336   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
1337
1338   g_list_foreach (umodel->root, (GFunc)model_map_free, NULL);
1339   g_list_free (umodel->root);
1340   umodel->root = NULL;
1341
1342   length = umodel->length;
1343   umodel->length = 0;
1344
1345   egg_tree_model_union_update_stamp (umodel);
1346
1347   egg_tree_model_union_emit_deleted (umodel, 0, length);
1348 }
1349
1350 void
1351 egg_tree_model_union_remove (EggTreeModelUnion *umodel,
1352                              GtkTreeModel      *model)
1353 {
1354   GList *i;
1355   GList *next;
1356   ModelMap *map;
1357
1358   g_return_if_fail (EGG_IS_TREE_MODEL_UNION (umodel));
1359   g_return_if_fail (GTK_IS_TREE_MODEL (model));
1360   g_return_if_fail (umodel->root);
1361
1362   for (i = umodel->root; i; i = i->next)
1363     if (MODEL_MAP (i->data)->model == model)
1364       break;
1365
1366   g_return_if_fail (i);
1367
1368   next = i->next;
1369
1370   map = MODEL_MAP (i->data);
1371
1372   umodel->root = g_list_remove_link (umodel->root, i);
1373   umodel->length -= map->nodes;
1374
1375   for (i = next; i; i = i->next)
1376     MODEL_MAP (i->data)->offset -= map->nodes;
1377
1378   g_signal_handlers_disconnect_by_func (map->model,
1379                                         egg_tree_model_union_row_inserted,
1380                                         umodel);
1381   g_signal_handlers_disconnect_by_func (map->model,
1382                                         egg_tree_model_union_row_deleted,
1383                                         umodel);
1384   g_signal_handlers_disconnect_by_func (map->model,
1385                                         egg_tree_model_union_row_changed,
1386                                         umodel);
1387   g_signal_handlers_disconnect_by_func (map->model,
1388                                         egg_tree_model_union_row_has_child_toggled,
1389                                         umodel);
1390   g_signal_handlers_disconnect_by_func (map->model,
1391                                         egg_tree_model_union_rows_reordered,
1392                                         umodel);
1393
1394   g_object_unref (G_OBJECT (map->model));
1395
1396   egg_tree_model_union_update_stamp (umodel);
1397
1398   egg_tree_model_union_emit_deleted (umodel, map->offset, map->nodes);
1399
1400   model_map_free (map);
1401 }