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