src/viktreeview.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include <gtk/gtk.h>
  23 #include <string.h>
  24
  25 #include "viking.h"
  26 #include "config.h"
  27
  28 #define VT_COL_WIDTH_NAME     160
  29 #define VT_COL_WIDTH_TYPE     20
  30 #define VT_COL_WIDTH_VISIBLE  20
  31
  32 #define TREEVIEW_GET(model,iter,what,dest) gtk_tree_model_get(GTK_TREE_MODEL(model),(iter),(what),(dest),-1)
  33
  34 enum {
  35   VT_ITEM_EDITED_SIGNAL,
  36   VT_ITEM_TOGGLED_SIGNAL,
  37   VT_LAST_SIGNAL
  38 };
  39
  40 static guint treeview_signals[VT_LAST_SIGNAL] = { 0, 0 };
  41
  42 static GObjectClass *parent_class;
  43
  44 enum
  45 {
  46   NAME_COLUMN = 0,
  47   VISIBLE_COLUMN,
  48   ICON_COLUMN,
  49   /* invisible */
  50
  51   TYPE_COLUMN,
  52   ITEM_PARENT_COLUMN,
  53   ITEM_POINTER_COLUMN,
  54   ITEM_DATA_COLUMN,
  55   HAS_VISIBLE_COLUMN,
  56   EDITABLE_COLUMN,
  57   /* properties dialog, delete, rename, etc. */
  58   NUM_COLUMNS
  59 };
  60
  61 struct _VikTreeview {
  62   GtkTreeView treeview;
  63   GtkTreeModel *model;
  64
  65   GdkPixbuf *layer_type_icons[VIK_LAYER_NUM_TYPES];
  66 };
  67
  68 /* TODO: find, make "static" and put up here all non-"a_" functions */
  69 static void treeview_class_init ( VikTreeviewClass *klass );
  70 static void treeview_init ( VikTreeview *vt );
  71 static void treeview_finalize ( GObject *gob );
  72 static void treeview_add_columns ( VikTreeview *vt );
  73
  74 static gboolean treeview_drag_data_received ( GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data );
  75 static gboolean treeview_drag_data_delete ( GtkTreeDragSource *drag_source, GtkTreePath *path );
  76
  77 GType vik_treeview_get_type (void)
  78 {
  79   static GType vt_type = 0;
  80
  81   if (!vt_type)
  82   {
  83     static const GTypeInfo vt_info =
  84     {
  85       sizeof (VikTreeviewClass),
  86       NULL, /* base_init */
  87       NULL, /* base_finalize */
  88       (GClassInitFunc) treeview_class_init,
  89       NULL, /* class_finalize */
  90       NULL, /* class_data */
  91       sizeof (VikTreeview),
  92       0,
  93       (GInstanceInitFunc) treeview_init,
  94     };
  95     vt_type = g_type_register_static ( GTK_TYPE_TREE_VIEW, "VikTreeview", &vt_info, 0 );
  96   }
  97
  98   return vt_type;
  99 }
 100
 101 static void treeview_class_init ( VikTreeviewClass *klass )
 102 {
 103   /* Destructor */
 104   GObjectClass *object_class;
 105
 106   object_class = G_OBJECT_CLASS (klass);
 107
 108   object_class->finalize =  treeview_finalize;
 109
 110   parent_class = g_type_class_peek_parent (klass);
 111
 112   treeview_signals[VT_ITEM_EDITED_SIGNAL] = g_signal_new ( "item_edited", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikTreeviewClass, item_edited), NULL, NULL,
 113     gtk_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2, GTK_TYPE_POINTER, G_TYPE_POINTER);
 114   /* VOID__UINT_POINTER: kinda hack-ish, but it works. */
 115
 116   treeview_signals[VT_ITEM_TOGGLED_SIGNAL] = g_signal_new ( "item_toggled", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikTreeviewClass, item_toggled), NULL, NULL,
 117     g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, GTK_TYPE_POINTER );
 118 }
 119
 120 static void treeview_edited_cb (GtkCellRendererText *cell, gchar *path_str, const gchar *new_name, VikTreeview *vt)
 121 {
 122   GtkTreeIter iter;
 123
 124   /* get type and data */
 125   vik_treeview_get_iter_from_path_str ( vt, &iter, path_str );
 126
 127   g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_EDITED_SIGNAL], 0, &iter, new_name );
 128 }
 129
 130 static void treeview_toggled_cb (GtkCellRendererToggle *cell, gchar *path_str, VikTreeview *vt)
 131 {
 132   GtkTreeIter iter;
 133
 134   /* get type and data */
 135   vik_treeview_get_iter_from_path_str ( vt, &iter, path_str );
 136
 137   g_signal_emit ( G_OBJECT(vt),
 138 treeview_signals[VT_ITEM_TOGGLED_SIGNAL], 0, &iter );
 139 }
 140
 141 VikTreeview *vik_treeview_new ()
 142 {
 143   return VIK_TREEVIEW ( g_object_new ( VIK_TREEVIEW_TYPE, NULL ) );
 144 }
 145
 146 gint vik_treeview_item_get_type ( VikTreeview *vt, GtkTreeIter *iter )
 147 {
 148   gint rv;
 149   TREEVIEW_GET ( vt->model, iter, TYPE_COLUMN, &rv );
 150   return rv;
 151 }
 152
 153 gint vik_treeview_item_get_data ( VikTreeview *vt, GtkTreeIter *iter )
 154 {
 155   gint rv;
 156   TREEVIEW_GET ( vt->model, iter, ITEM_DATA_COLUMN, &rv );
 157   return rv;
 158 }
 159
 160 gpointer vik_treeview_item_get_pointer ( VikTreeview *vt, GtkTreeIter *iter )
 161 {
 162   gpointer rv;
 163   TREEVIEW_GET ( vt->model, iter, ITEM_POINTER_COLUMN, &rv );
 164   return rv;
 165 }
 166
 167 void vik_treeview_item_set_pointer ( VikTreeview *vt, GtkTreeIter *iter, gpointer pointer )
 168 {
 169   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_POINTER_COLUMN, pointer, -1 );
 170 }
 171
 172 gpointer vik_treeview_item_get_parent ( VikTreeview *vt, GtkTreeIter *iter )
 173 {
 174   gpointer rv;
 175   TREEVIEW_GET ( vt->model, iter, ITEM_PARENT_COLUMN, &rv );
 176   return rv;
 177 }
 178
 179 gboolean vik_treeview_get_iter_from_path_str ( VikTreeview *vt, GtkTreeIter *iter, const gchar *path_str )
 180 {
 181   return gtk_tree_model_get_iter_from_string ( GTK_TREE_MODEL(vt->model), iter, path_str );
 182 }
 183
 184 static void treeview_add_columns ( VikTreeview *vt )
 185 {
 186   gint col_offset;
 187   GtkCellRenderer *renderer;
 188   GtkTreeViewColumn *column;
 189
 190   renderer = gtk_cell_renderer_text_new ();
 191   g_signal_connect (renderer, "edited",
 192                     G_CALLBACK (treeview_edited_cb), vt);
 193
 194   g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
 195
 196   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 197                                                             -1, "Layer Name",
 198                                                             renderer, "text",
 199                                                             NAME_COLUMN,
 200                                                             "editable", EDITABLE_COLUMN,
 201                                                             NULL);
 202
 203   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 204   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 205                                    GTK_TREE_VIEW_COLUMN_FIXED);
 206   gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column),
 207                                    VT_COL_WIDTH_NAME);
 208   gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 209   gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 210
 211   renderer = gtk_cell_renderer_pixbuf_new ();
 212
 213   g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL);
 214
 215   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 216                                                             -1, "",
 217                                                             renderer, "pixbuf",
 218                                                             ICON_COLUMN,
 219                                                             NULL);
 220
 221
 222   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 223   gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column),
 224                                         VT_COL_WIDTH_TYPE);
 225   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 226                                    GTK_TREE_VIEW_COLUMN_FIXED);
 227   gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 228
 229
 230   renderer = gtk_cell_renderer_toggle_new ();
 231   g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL);
 232
 233   g_signal_connect (renderer, "toggled", G_CALLBACK (treeview_toggled_cb), vt);
 234
 235   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 236                                                             -1, "",
 237                                                             renderer,
 238                                                             "active",
 239                                                             VISIBLE_COLUMN,
 240                                                             "visible",
 241                                                             HAS_VISIBLE_COLUMN,
 242                                                             "activatable",
 243                                                             HAS_VISIBLE_COLUMN,
 244                                                             NULL);
 245
 246   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 247   gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column),
 248                                         VT_COL_WIDTH_VISIBLE);
 249   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 250                                    GTK_TREE_VIEW_COLUMN_FIXED);
 251   gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 252
 253 }
 254
 255 static void select_cb(GtkTreeSelection *selection, gpointer data)
 256 {
 257   VikTreeview *vt = data;
 258   gint type;
 259   GtkTreeIter iter, parent;
 260   VikLayer *vl;
 261   VikWindow * vw;
 262
 263   if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) return;
 264   type = vik_treeview_item_get_type( vt, &iter);
 265
 266   while ( type != VIK_TREEVIEW_TYPE_LAYER ) {
 267     if ( ! vik_treeview_item_get_parent_iter ( vt, &iter, &parent ) )
 268       return;
 269     iter = parent;
 270     type = vik_treeview_item_get_type (vt, &iter );
 271   }
 272
 273   vl = VIK_LAYER( vik_treeview_item_get_pointer ( vt, &iter ) );
 274
 275   vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vl));
 276   vik_window_selected_layer(vw, vl);
 277 }
 278
 279 void treeview_init ( VikTreeview *vt )
 280 {
 281   guint16 i;
 282
 283   vt->model = GTK_TREE_MODEL(gtk_tree_store_new ( NUM_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN ));
 284
 285   /* create tree view */
 286   gtk_tree_view_set_model ( GTK_TREE_VIEW(vt), vt->model );
 287   treeview_add_columns ( vt );
 288   g_object_unref (vt->model);
 289
 290   gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (vt), TRUE);
 291   gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)),
 292                                GTK_SELECTION_SINGLE);
 293
 294   /* Override treestore's dnd methods only; this is easier than deriving from GtkTreeStore.
 295    * The downside is that all treestores will have this behavior, so this needs to be
 296    * changed if we add more treeviews in the future.  //Alex
 297    */
 298   if (1) {
 299     GtkTreeDragSourceIface *isrc;
 300     GtkTreeDragDestIface *idest;
 301
 302     isrc = g_type_interface_peek (g_type_class_peek(G_OBJECT_TYPE(vt->model)), GTK_TYPE_TREE_DRAG_SOURCE);
 303     isrc->drag_data_delete = treeview_drag_data_delete;
 304
 305     idest = g_type_interface_peek (g_type_class_peek(G_OBJECT_TYPE(vt->model)), GTK_TYPE_TREE_DRAG_DEST);
 306     idest->drag_data_received = treeview_drag_data_received;
 307   }
 308
 309   for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
 310     vt->layer_type_icons[i] = vik_layer_load_icon ( i ); /* if icon can't be loaded, it will be null and simply not be shown. */
 311
 312   gtk_tree_view_set_reorderable (GTK_TREE_VIEW(vt), TRUE);
 313   g_signal_connect(gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)), "changed",
 314       G_CALLBACK(select_cb), vt);
 315
 316 }
 317
 318 gboolean vik_treeview_item_get_parent_iter ( VikTreeview *vt, GtkTreeIter *iter,  GtkTreeIter *parent )
 319 {
 320   return gtk_tree_model_iter_parent ( GTK_TREE_MODEL(vt->model), parent, iter );
 321 }
 322
 323 gboolean vik_treeview_move_item ( VikTreeview *vt, GtkTreeIter *iter, gboolean up )
 324 {
 325   gint t = vik_treeview_item_get_type ( vt, iter );
 326   if ( t == VIK_TREEVIEW_TYPE_LAYER )
 327   {
 328     GtkTreeIter switch_iter;
 329     if (up)
 330     {
 331       /* iter to path to iter */
 332       GtkTreePath *path = gtk_tree_model_get_path ( vt->model, iter );
 333       if ( !gtk_tree_path_prev ( path ) || !gtk_tree_model_get_iter ( vt->model, &switch_iter, path ) )
 334       {
 335         gtk_tree_path_free ( path );
 336         return FALSE;
 337       }
 338       gtk_tree_path_free ( path );
 339     }
 340     else
 341     {
 342       switch_iter = *iter;
 343       if ( !gtk_tree_model_iter_next ( vt->model, &switch_iter ) )
 344         return FALSE;
 345     }
 346     gtk_tree_store_swap ( GTK_TREE_STORE(vt->model), iter, &switch_iter );
 347     return TRUE;
 348     /* now, the easy part. actually switching them, not the GUI */
 349   } /* if item is map */
 350   return FALSE;
 351 }
 352
 353 gboolean vik_treeview_get_iter_at_pos ( VikTreeview *vt, GtkTreeIter *iter, gint x, gint y )
 354 {
 355   GtkTreePath *path;
 356   gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(vt), x, y, &path, NULL, NULL, NULL );
 357   if ( ! path )
 358     return FALSE;
 359
 360   gtk_tree_model_get_iter (GTK_TREE_MODEL(vt->model), iter, path);
 361   gtk_tree_path_free ( path );
 362   return TRUE;
 363 }
 364
 365 void vik_treeview_select_iter ( VikTreeview *vt, GtkTreeIter *iter )
 366 {
 367   gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
 368 }
 369
 370 gboolean vik_treeview_get_selected_iter ( VikTreeview *vt, GtkTreeIter *iter )
 371 {
 372   return gtk_tree_selection_get_selected ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), NULL, iter );
 373 }
 374
 375 void vik_treeview_item_delete ( VikTreeview *vt, GtkTreeIter *iter )
 376 {
 377   gtk_tree_store_remove ( GTK_TREE_STORE(vt->model), iter );
 378 }
 379
 380 /* Treeview Reform Project */
 381
 382 void vik_treeview_item_set_name ( VikTreeview *vt, GtkTreeIter *iter, const gchar *to )
 383 {
 384   g_return_if_fail ( iter != NULL && to != NULL );
 385   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, to, -1);
 386 }
 387
 388 void vik_treeview_item_set_visible ( VikTreeview *vt, GtkTreeIter *iter, gboolean to )
 389 {
 390   g_return_if_fail ( iter != NULL );
 391   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 );
 392 }
 393
 394 void vik_treeview_expand ( VikTreeview *vt, GtkTreeIter *iter )
 395 {
 396   GtkTreePath *path;
 397   path = gtk_tree_model_get_path ( vt->model, iter );
 398   gtk_tree_view_expand_row ( GTK_TREE_VIEW(vt), path, FALSE );
 399   gtk_tree_path_free ( path );
 400 }
 401
 402 void vik_treeview_item_select ( VikTreeview *vt, GtkTreeIter *iter )
 403 {
 404   gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
 405 }
 406
 407 void vik_treeview_add_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent,
 408                               gpointer item, gint data, gint icon_type )
 409 {
 410   g_assert ( iter != NULL );
 411   g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
 412   gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 413   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE,
 414     TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item,
 415     ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE,
 416     ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
 417 }
 418
 419 void vik_treeview_insert_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent,
 420                               gpointer item, gint data, gint icon_type, GtkTreeIter *sibling )
 421 {
 422   g_assert ( iter != NULL );
 423   g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
 424   if (sibling) {
 425     gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling );
 426   } else {
 427     gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 428   }
 429
 430   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE,
 431     TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item,
 432     ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE,
 433     ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
 434 }
 435
 436 void vik_treeview_add_sublayer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item,
 437                                  gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
 438 {
 439   g_assert ( iter != NULL );
 440
 441   gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 442   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, TYPE_COLUMN, VIK_TREEVIEW_TYPE_SUBLAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, has_visible, EDITABLE_COLUMN, editable, ICON_COLUMN, icon, -1 );
 443 }
 444
 445
 446 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
 447
 448 void vik_treeview_sublayer_realphabetize ( VikTreeview *vt, GtkTreeIter *iter, const gchar *newname )
 449 {
 450   GtkTreeIter search_iter, parent_iter;
 451   gchar *search_name;
 452   g_assert ( iter != NULL );
 453
 454   gtk_tree_model_iter_parent ( vt->model, &parent_iter, iter );
 455
 456   g_assert ( gtk_tree_model_iter_children ( vt->model, &search_iter, &parent_iter ) );
 457
 458   do {
 459     gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
 460     if ( strcmp ( search_name, newname ) > 0 ) /* not >= or would trip on itself */
 461     {
 462       gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, &search_iter );
 463       return;
 464     }
 465   } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );
 466
 467   gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, NULL );
 468 }
 469
 470 void vik_treeview_add_sublayer_alphabetized
 471                  ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item,
 472                    gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
 473 {
 474   GtkTreeIter search_iter;
 475   gchar *search_name;
 476   g_assert ( iter != NULL );
 477
 478   if ( gtk_tree_model_iter_children ( vt->model, &search_iter, parent_iter ) )
 479   {
 480     gboolean found_greater_string = FALSE;
 481     do {
 482       gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
 483       if ( strcmp ( search_name, name ) >= 0 )
 484       {
 485         gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, &search_iter );
 486         found_greater_string = TRUE;
 487         break;
 488       }
 489     } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );
 490
 491     if ( ! found_greater_string )
 492       gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 493   }
 494   else
 495     gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 496
 497   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, TYPE_COLUMN, VIK_TREEVIEW_TYPE_SUBLAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, has_visible, EDITABLE_COLUMN, editable, ICON_COLUMN, icon, -1 );
 498 }
 499
 500 #endif
 501
 502 static void treeview_finalize ( GObject *gob )
 503 {
 504   VikTreeview *vt = VIK_TREEVIEW ( gob );
 505   guint16 i;
 506
 507   for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
 508     if ( vt->layer_type_icons[i] != NULL )
 509       g_object_unref ( G_OBJECT(vt->layer_type_icons[i]) );
 510
 511   G_OBJECT_CLASS(parent_class)->finalize(gob);
 512 }
 513
 514 static gboolean treeview_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data)
 515 {
 516   GtkTreeModel *tree_model;
 517   GtkTreeStore *tree_store;
 518   GtkTreeModel *src_model = NULL;
 519   GtkTreePath *src_path = NULL, *dest_cp = NULL;
 520   gboolean retval = FALSE;
 521   GtkTreeIter src_iter, root_iter, dest_iter, dest_parent;
 522   gint *i_src = NULL;
 523   VikTreeview *vt;
 524   VikLayer *vl;
 525
 526   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_dest), FALSE);
 527
 528   tree_model = GTK_TREE_MODEL (drag_dest);
 529   tree_store = GTK_TREE_STORE (drag_dest);
 530
 531   if (gtk_tree_get_row_drag_data (selection_data, &src_model, &src_path) && src_model == tree_model) {
 532     /*
 533      * Copy src_path to dest.  There are two subcases here, depending on what
 534      * is being dragged.
 535      *
 536      * 1. src_path is a layer. In this case, interpret the drop
 537      *    as a request to move the layer to a different aggregate layer.
 538      *    If the destination is not an aggregate layer, use the first
 539      *    ancestor that is.
 540      *
 541      * 2. src_path is a sublayer.  In this case, find ancestors of
 542      *    both source and destination nodes who are full layers,
 543      *    and call the move method of that layer type.
 544      *
 545      */
 546     if (!gtk_tree_model_get_iter (src_model, &src_iter, src_path)) {
 547       goto out;
 548     }
 549     if (!gtk_tree_path_compare(src_path, dest)) {
 550       goto out;
 551     }
 552
 553     i_src = gtk_tree_path_get_indices (src_path);
 554     dest_cp = gtk_tree_path_copy (dest);
 555
 556     gtk_tree_model_get_iter_first(tree_model, &root_iter);
 557     TREEVIEW_GET(tree_model, &root_iter, ITEM_POINTER_COLUMN, &vl);
 558     vt = vl->vt;
 559
 560
 561     if (gtk_tree_path_get_depth(dest_cp)>1) { /* can't be sibling of top layer */
 562       VikLayer *vl_src, *vl_dest;
 563
 564       /* Find the first ancestor that is a full layer, and store in dest_parent.
 565        * In addition, put in dest_iter where Gtk wants us to insert the dragged object.
 566        * (Note that this may end up being an invalid iter).
 567        */
 568       do {
 569         gtk_tree_path_up(dest_cp);
 570         dest_iter = dest_parent;
 571         gtk_tree_model_get_iter (src_model, &dest_parent, dest_cp);
 572       } while (gtk_tree_path_get_depth(dest_cp)>1 &&
 573                vik_treeview_item_get_type(vt, &dest_parent) != VIK_TREEVIEW_TYPE_LAYER);
 574
 575
 576       g_assert ( vik_treeview_item_get_parent(vt, &src_iter) );
 577       vl_src = vik_treeview_item_get_parent(vt, &src_iter);
 578       vl_dest = vik_treeview_item_get_pointer(vt, &dest_parent);
 579
 580       /* TODO: might want to allow different types, and let the clients handle how they want */
 581       if (vl_src->type == vl_dest->type && vik_layer_get_interface(vl_dest->type)->drag_drop_request) {
 582         //      g_print("moving an item from layer '%s' into layer '%s'\n", vl_src->name, vl_dest->name);
 583         vik_layer_get_interface(vl_dest->type)->drag_drop_request(vl_src, vl_dest, &src_iter, dest);
 584       }
 585     }
 586   }
 587
 588  out:
 589   if (dest_cp)
 590     gtk_tree_path_free(dest_cp);
 591   if (src_path)
 592     gtk_tree_path_free (src_path);
 593
 594   return retval;
 595 }
 596
 597 /*
 598  * This may not be necessary.
 599  */
 600 static gboolean treeview_drag_data_delete ( GtkTreeDragSource *drag_source, GtkTreePath *path )
 601 {
 602   gchar *s_dest = gtk_tree_path_to_string(path);
 603   g_print("delete data from %s\n", s_dest);
 604   g_free(s_dest);
 605   return FALSE;
 606 }
 607