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