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 TREEVIEW_GET(model,iter,what,dest) gtk_tree_model_get(GTK_TREE_MODEL(model),(iter),(what),(dest),-1)
  35
  36 enum {
  37   VT_ITEM_EDITED_SIGNAL,
  38   VT_ITEM_TOGGLED_SIGNAL,
  39   VT_LAST_SIGNAL
  40 };
  41
  42 static guint treeview_signals[VT_LAST_SIGNAL] = { 0, 0 };
  43
  44 static GObjectClass *parent_class;
  45
  46 enum
  47 {
  48   NAME_COLUMN = 0,
  49   VISIBLE_COLUMN,
  50   ICON_COLUMN,
  51   /* invisible */
  52
  53   TYPE_COLUMN,
  54   ITEM_PARENT_COLUMN,
  55   ITEM_POINTER_COLUMN,
  56   ITEM_DATA_COLUMN,
  57   HAS_VISIBLE_COLUMN,
  58   EDITABLE_COLUMN,
  59   /* properties dialog, delete, rename, etc. */
  60   NUM_COLUMNS
  61 };
  62
  63 struct _VikTreeview {
  64   GtkTreeView treeview;
  65   GtkTreeModel *model;
  66
  67   GdkPixbuf *layer_type_icons[VIK_LAYER_NUM_TYPES];
  68
  69   gboolean was_a_toggle;
  70 };
  71
  72 /* TODO: find, make "static" and put up here all non-"a_" functions */
  73 static void vik_treeview_finalize ( GObject *gob );
  74 static void vik_treeview_add_columns ( VikTreeview *vt );
  75
  76 static gboolean vik_treeview_drag_data_received ( GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data );
  77 static gboolean vik_treeview_drag_data_delete ( GtkTreeDragSource *drag_source, GtkTreePath *path );
  78
  79 G_DEFINE_TYPE (VikTreeview, vik_treeview, GTK_TYPE_TREE_VIEW)
  80
  81 static void vik_treeview_class_init ( VikTreeviewClass *klass )
  82 {
  83   /* Destructor */
  84   GObjectClass *object_class;
  85
  86   object_class = G_OBJECT_CLASS (klass);
  87
  88   object_class->finalize = vik_treeview_finalize;
  89
  90   parent_class = g_type_class_peek_parent (klass);
  91
  92   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,
  93     gtk_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2, GTK_TYPE_POINTER, G_TYPE_POINTER);
  94   /* VOID__UINT_POINTER: kinda hack-ish, but it works. */
  95
  96   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,
  97     g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, GTK_TYPE_POINTER );
  98 }
  99
 100 static void vik_treeview_edited_cb (GtkCellRendererText *cell, gchar *path_str, const gchar *new_name, VikTreeview *vt)
 101 {
 102   GtkTreeIter iter;
 103
 104   /* get type and data */
 105   vik_treeview_get_iter_from_path_str ( vt, &iter, path_str );
 106
 107   g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_EDITED_SIGNAL], 0, &iter, new_name );
 108 }
 109
 110 static void vik_treeview_toggled_cb (GtkCellRendererToggle *cell, gchar *path_str, VikTreeview *vt)
 111 {
 112   GtkTreeIter iter_toggle;
 113   GtkTreeIter iter_selected;
 114
 115   /* get type and data */
 116   vik_treeview_get_iter_from_path_str ( vt, &iter_toggle, path_str );
 117
 118   GtkTreePath *tp_toggle = gtk_tree_model_get_path ( vt->model, &iter_toggle );
 119
 120   if ( gtk_tree_selection_get_selected ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), NULL, &iter_selected ) ) {
 121     GtkTreePath *tp_selected = gtk_tree_model_get_path ( vt->model, &iter_selected );
 122     if ( gtk_tree_path_compare ( tp_toggle, tp_selected ) )
 123       // Toggle set on different path
 124       // therefore prevent subsequent auto selection (otherwise no action needed)
 125       vt->was_a_toggle = TRUE;
 126   }
 127   else
 128     // Toggle set on new path
 129     // therefore prevent subsequent auto selection
 130     vt->was_a_toggle = TRUE;
 131
 132   g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_TOGGLED_SIGNAL], 0, &iter_toggle );
 133 }
 134
 135 /* Inspired by GTK+ test
 136  * http://git.gnome.org/browse/gtk+/tree/tests/testtooltips.c
 137  */
 138 static gboolean
 139 vik_treeview_tooltip_cb (GtkWidget  *widget,
 140                      gint        x,
 141                      gint        y,
 142                      gboolean    keyboard_tip,
 143                      GtkTooltip *tooltip,
 144                      gpointer    data)
 145 {
 146   GtkTreeIter iter;
 147   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
 148   GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
 149   GtkTreePath *path = NULL;
 150
 151   char buffer[256];
 152
 153   if (!gtk_tree_view_get_tooltip_context (tree_view, &x, &y,
 154                                           keyboard_tip,
 155                                           &model, &path, &iter))
 156     return FALSE;
 157
 158   /* ATM normally treeview doesn't call into layers - maybe another level of redirection required? */
 159   gint rv;
 160   gtk_tree_model_get (model, &iter, TYPE_COLUMN, &rv, -1);
 161   if ( rv == VIK_TREEVIEW_TYPE_SUBLAYER ) {
 162
 163     gtk_tree_model_get (model, &iter, ITEM_DATA_COLUMN, &rv, -1);
 164
 165     gpointer sublayer;
 166     gtk_tree_model_get (model, &iter, ITEM_POINTER_COLUMN, &sublayer, -1);
 167
 168     gpointer parent;
 169     gtk_tree_model_get (model, &iter, ITEM_PARENT_COLUMN, &parent, -1);
 170
 171     g_snprintf (buffer, sizeof(buffer), "%s", vik_layer_sublayer_tooltip (VIK_LAYER(parent), rv, sublayer));
 172   }
 173   else if ( rv == VIK_TREEVIEW_TYPE_LAYER ) {
 174     gpointer layer;
 175     gtk_tree_model_get (model, &iter, ITEM_POINTER_COLUMN, &layer, -1);
 176     g_snprintf (buffer, sizeof(buffer), "%s", vik_layer_layer_tooltip (VIK_LAYER(layer)));
 177   }
 178   else
 179     return FALSE;
 180
 181   // Don't display null strings :)
 182   if ( strncmp (buffer, "(null)", 6) == 0 ) {
 183     return FALSE;
 184   }
 185   else {
 186     // No point in using (Pango) markup verson - gtk_tooltip_set_markup()
 187     //  especially as waypoint comments may well contain HTML markup which confuses the pango markup parser
 188     // This plain text is probably faster too.
 189     gtk_tooltip_set_text (tooltip, buffer);
 190   }
 191
 192   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
 193
 194   gtk_tree_path_free (path);
 195
 196   return TRUE;
 197 }
 198
 199 VikTreeview *vik_treeview_new ()
 200 {
 201   return VIK_TREEVIEW ( g_object_new ( VIK_TREEVIEW_TYPE, NULL ) );
 202 }
 203
 204 gint vik_treeview_item_get_type ( VikTreeview *vt, GtkTreeIter *iter )
 205 {
 206   gint rv;
 207   TREEVIEW_GET ( vt->model, iter, TYPE_COLUMN, &rv );
 208   return rv;
 209 }
 210
 211 gchar* vik_treeview_item_get_name ( VikTreeview *vt, GtkTreeIter *iter )
 212 {
 213   gchar *rv;
 214   TREEVIEW_GET ( vt->model, iter, NAME_COLUMN, &rv );
 215   return rv;
 216 }
 217
 218 gint vik_treeview_item_get_data ( VikTreeview *vt, GtkTreeIter *iter )
 219 {
 220   gint rv;
 221   TREEVIEW_GET ( vt->model, iter, ITEM_DATA_COLUMN, &rv );
 222   return rv;
 223 }
 224
 225 gpointer vik_treeview_item_get_pointer ( VikTreeview *vt, GtkTreeIter *iter )
 226 {
 227   gpointer rv;
 228   TREEVIEW_GET ( vt->model, iter, ITEM_POINTER_COLUMN, &rv );
 229   return rv;
 230 }
 231
 232 void vik_treeview_item_set_pointer ( VikTreeview *vt, GtkTreeIter *iter, gpointer pointer )
 233 {
 234   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_POINTER_COLUMN, pointer, -1 );
 235 }
 236
 237 gpointer vik_treeview_item_get_parent ( VikTreeview *vt, GtkTreeIter *iter )
 238 {
 239   gpointer rv;
 240   TREEVIEW_GET ( vt->model, iter, ITEM_PARENT_COLUMN, &rv );
 241   return rv;
 242 }
 243
 244 gboolean vik_treeview_get_iter_from_path_str ( VikTreeview *vt, GtkTreeIter *iter, const gchar *path_str )
 245 {
 246   return gtk_tree_model_get_iter_from_string ( GTK_TREE_MODEL(vt->model), iter, path_str );
 247 }
 248
 249 static void vik_treeview_add_columns ( VikTreeview *vt )
 250 {
 251   gint col_offset;
 252   GtkCellRenderer *renderer;
 253   GtkTreeViewColumn *column;
 254
 255   /* Layer column */
 256   renderer = gtk_cell_renderer_text_new ();
 257   g_signal_connect (renderer, "edited",
 258                     G_CALLBACK (vik_treeview_edited_cb), vt);
 259
 260   g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 261
 262   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 263                                                             -1, _("Layer Name"),
 264                                                             renderer, "text",
 265                                                             NAME_COLUMN,
 266                                                             "editable", EDITABLE_COLUMN,
 267                                                             NULL);
 268
 269   /* ATM the minimum overall width (and starting default) of the treeview size is determined
 270      by the buttons added to the bottom of the layerspanel */
 271   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 272   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 273                                    GTK_TREE_VIEW_COLUMN_FIXED);
 274   gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
 275
 276   /* Layer type */
 277   renderer = gtk_cell_renderer_pixbuf_new ();
 278
 279   g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL);
 280
 281   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 282                                                             -1, "",
 283                                                             renderer, "pixbuf",
 284                                                             ICON_COLUMN,
 285                                                             NULL);
 286
 287   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 288   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 289                                    GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 290
 291   /* Layer visible */
 292   renderer = gtk_cell_renderer_toggle_new ();
 293   g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL);
 294
 295   g_signal_connect (renderer, "toggled", G_CALLBACK (vik_treeview_toggled_cb), vt);
 296
 297   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 298                                                             -1, "",
 299                                                             renderer,
 300                                                             "active",
 301                                                             VISIBLE_COLUMN,
 302                                                             "visible",
 303                                                             HAS_VISIBLE_COLUMN,
 304                                                             "activatable",
 305                                                             HAS_VISIBLE_COLUMN,
 306                                                             NULL);
 307
 308   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 309   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 310                                    GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 311
 312
 313   g_object_set (GTK_TREE_VIEW (vt), "has-tooltip", TRUE, NULL);
 314   g_signal_connect (GTK_TREE_VIEW (vt), "query-tooltip", G_CALLBACK (vik_treeview_tooltip_cb), vt);
 315 }
 316
 317 static void select_cb(GtkTreeSelection *selection, gpointer data)
 318 {
 319   VikTreeview *vt = data;
 320   gint type;
 321   GtkTreeIter iter, parent;
 322   VikLayer *vl;
 323   VikWindow * vw;
 324
 325   gpointer tmp_layer;
 326   VikLayer *tmp_vl = NULL;
 327   gint tmp_subtype = 0;
 328   gint tmp_type = VIK_TREEVIEW_TYPE_LAYER;
 329
 330   if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) return;
 331   type = vik_treeview_item_get_type( vt, &iter);
 332
 333   /* Find the Sublayer type if possible */
 334   tmp_layer = vik_treeview_item_get_pointer ( vt, &iter );
 335   if (tmp_layer) {
 336     if (type == VIK_TREEVIEW_TYPE_SUBLAYER) {
 337       tmp_vl = VIK_LAYER(vik_treeview_item_get_parent(vt, &iter));
 338       tmp_subtype = vik_treeview_item_get_data(vt, &iter);
 339       tmp_type = VIK_TREEVIEW_TYPE_SUBLAYER;
 340     }
 341   }
 342   else {
 343     tmp_subtype = vik_treeview_item_get_data(vt, &iter);
 344     tmp_type = VIK_TREEVIEW_TYPE_SUBLAYER;
 345   }
 346
 347   /* Go up the tree to find the Vik Layer */
 348   while ( type != VIK_TREEVIEW_TYPE_LAYER ) {
 349     if ( ! vik_treeview_item_get_parent_iter ( vt, &iter, &parent ) )
 350       return;
 351     iter = parent;
 352     type = vik_treeview_item_get_type (vt, &iter );
 353   }
 354
 355   vl = VIK_LAYER( vik_treeview_item_get_pointer ( vt, &iter ) );
 356
 357   vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vl));
 358   vik_window_selected_layer(vw, vl);
 359
 360   if (tmp_vl == NULL)
 361     tmp_vl = vl;
 362   /* Apply settings now we have the all details  */
 363   if ( vik_layer_selected ( tmp_vl,
 364                             tmp_subtype,
 365                             tmp_layer,
 366                             tmp_type,
 367                             vik_window_layers_panel(vw) ) ) {
 368     /* Redraw required */
 369     vik_layers_panel_emit_update ( vik_window_layers_panel(vw) );
 370   }
 371
 372 }
 373
 374 static gboolean vik_treeview_selection_filter(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer data)
 375 {
 376   VikTreeview *vt = data;
 377
 378   if (vt->was_a_toggle) {
 379     vt->was_a_toggle = FALSE;
 380     return FALSE;
 381   }
 382
 383   return TRUE;
 384 }
 385
 386 void vik_treeview_init ( VikTreeview *vt )
 387 {
 388   guint16 i;
 389
 390   vt->was_a_toggle = FALSE;
 391
 392   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 ));
 393
 394   /* create tree view */
 395   gtk_tree_selection_set_select_function(gtk_tree_view_get_selection (GTK_TREE_VIEW(vt)), vik_treeview_selection_filter, vt, NULL);
 396
 397   gtk_tree_view_set_model ( GTK_TREE_VIEW(vt), vt->model );
 398   vik_treeview_add_columns ( vt );
 399   g_object_unref (vt->model);
 400
 401   gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (vt), TRUE);
 402   gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)),
 403                                GTK_SELECTION_SINGLE);
 404
 405   /* Override treestore's dnd methods only; this is easier than deriving from GtkTreeStore.
 406    * The downside is that all treestores will have this behavior, so this needs to be
 407    * changed if we add more treeviews in the future.  //Alex
 408    */
 409   if (1) {
 410     GtkTreeDragSourceIface *isrc;
 411     GtkTreeDragDestIface *idest;
 412
 413     isrc = g_type_interface_peek (g_type_class_peek(G_OBJECT_TYPE(vt->model)), GTK_TYPE_TREE_DRAG_SOURCE);
 414     isrc->drag_data_delete = vik_treeview_drag_data_delete;
 415
 416     idest = g_type_interface_peek (g_type_class_peek(G_OBJECT_TYPE(vt->model)), GTK_TYPE_TREE_DRAG_DEST);
 417     idest->drag_data_received = vik_treeview_drag_data_received;
 418   }
 419
 420   for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
 421     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. */
 422
 423   gtk_tree_view_set_reorderable (GTK_TREE_VIEW(vt), TRUE);
 424   g_signal_connect(gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)), "changed",
 425       G_CALLBACK(select_cb), vt);
 426
 427 }
 428
 429 gboolean vik_treeview_item_get_parent_iter ( VikTreeview *vt, GtkTreeIter *iter,  GtkTreeIter *parent )
 430 {
 431   return gtk_tree_model_iter_parent ( GTK_TREE_MODEL(vt->model), parent, iter );
 432 }
 433
 434 gboolean vik_treeview_move_item ( VikTreeview *vt, GtkTreeIter *iter, gboolean up )
 435 {
 436   gint t = vik_treeview_item_get_type ( vt, iter );
 437   if ( t == VIK_TREEVIEW_TYPE_LAYER )
 438   {
 439     GtkTreeIter switch_iter;
 440     if (up)
 441     {
 442       /* iter to path to iter */
 443       GtkTreePath *path = gtk_tree_model_get_path ( vt->model, iter );
 444       if ( !gtk_tree_path_prev ( path ) || !gtk_tree_model_get_iter ( vt->model, &switch_iter, path ) )
 445       {
 446         gtk_tree_path_free ( path );
 447         return FALSE;
 448       }
 449       gtk_tree_path_free ( path );
 450     }
 451     else
 452     {
 453       switch_iter = *iter;
 454       if ( !gtk_tree_model_iter_next ( vt->model, &switch_iter ) )
 455         return FALSE;
 456     }
 457     gtk_tree_store_swap ( GTK_TREE_STORE(vt->model), iter, &switch_iter );
 458     return TRUE;
 459     /* now, the easy part. actually switching them, not the GUI */
 460   } /* if item is map */
 461   return FALSE;
 462 }
 463
 464 gboolean vik_treeview_get_iter_at_pos ( VikTreeview *vt, GtkTreeIter *iter, gint x, gint y )
 465 {
 466   GtkTreePath *path;
 467   gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(vt), x, y, &path, NULL, NULL, NULL );
 468   if ( ! path )
 469     return FALSE;
 470
 471   gtk_tree_model_get_iter (GTK_TREE_MODEL(vt->model), iter, path);
 472   gtk_tree_path_free ( path );
 473   return TRUE;
 474 }
 475
 476 /* Option to ensure visible */
 477 void vik_treeview_select_iter ( VikTreeview *vt, GtkTreeIter *iter, gboolean view_all )
 478 {
 479   GtkTreeView *tree_view = GTK_TREE_VIEW ( vt );
 480   GtkTreePath *path;
 481
 482   if ( view_all ) {
 483     path = gtk_tree_model_get_path ( gtk_tree_view_get_model (tree_view), iter );
 484     gtk_tree_view_expand_to_path ( tree_view, path );
 485   }
 486
 487   gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( tree_view ), iter );
 488
 489   if ( view_all ) {
 490     gtk_tree_view_scroll_to_cell  ( tree_view,
 491                                     path,
 492                                     gtk_tree_view_get_expander_column (tree_view),
 493                                     FALSE,
 494                                     0.0, 0.0 );
 495   }
 496 }
 497
 498 gboolean vik_treeview_get_selected_iter ( VikTreeview *vt, GtkTreeIter *iter )
 499 {
 500   return gtk_tree_selection_get_selected ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), NULL, iter );
 501 }
 502
 503 void vik_treeview_item_delete ( VikTreeview *vt, GtkTreeIter *iter )
 504 {
 505   gtk_tree_store_remove ( GTK_TREE_STORE(vt->model), iter );
 506 }
 507
 508 /* Treeview Reform Project */
 509
 510 void vik_treeview_item_set_icon ( VikTreeview *vt, GtkTreeIter *iter, const GdkPixbuf *icon )
 511 {
 512   g_return_if_fail ( iter != NULL && icon != NULL );
 513   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ICON_COLUMN, icon, -1);
 514 }
 515
 516 void vik_treeview_item_set_name ( VikTreeview *vt, GtkTreeIter *iter, const gchar *to )
 517 {
 518   g_return_if_fail ( iter != NULL && to != NULL );
 519   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, to, -1);
 520 }
 521
 522 void vik_treeview_item_set_visible ( VikTreeview *vt, GtkTreeIter *iter, gboolean to )
 523 {
 524   g_return_if_fail ( iter != NULL );
 525   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 );
 526 }
 527
 528 void vik_treeview_expand ( VikTreeview *vt, GtkTreeIter *iter )
 529 {
 530   GtkTreePath *path;
 531   path = gtk_tree_model_get_path ( vt->model, iter );
 532   gtk_tree_view_expand_row ( GTK_TREE_VIEW(vt), path, FALSE );
 533   gtk_tree_path_free ( path );
 534 }
 535
 536 void vik_treeview_item_select ( VikTreeview *vt, GtkTreeIter *iter )
 537 {
 538   gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
 539 }
 540
 541 void vik_treeview_item_unselect ( VikTreeview *vt, GtkTreeIter *iter )
 542 {
 543   gtk_tree_selection_unselect_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
 544 }
 545
 546 void vik_treeview_add_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent,
 547                               gpointer item, gint data, gint icon_type )
 548 {
 549   g_assert ( iter != NULL );
 550   g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
 551   gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 552   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE,
 553     TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item,
 554     ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, parent == NULL ? FALSE : TRUE,
 555     ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
 556 }
 557
 558 void vik_treeview_insert_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent,
 559                               gpointer item, gint data, gint icon_type, GtkTreeIter *sibling )
 560 {
 561   g_assert ( iter != NULL );
 562   g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
 563   if (sibling) {
 564     gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling );
 565   } else {
 566     gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 567   }
 568
 569   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE,
 570     TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item,
 571     ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE,
 572     ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
 573 }
 574
 575 void vik_treeview_add_sublayer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item,
 576                                  gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
 577 {
 578   g_assert ( iter != NULL );
 579
 580   gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 581   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 );
 582 }
 583
 584
 585 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
 586
 587 void vik_treeview_sublayer_realphabetize ( VikTreeview *vt, GtkTreeIter *iter, const gchar *newname )
 588 {
 589   GtkTreeIter search_iter, parent_iter;
 590   gchar *search_name = NULL;
 591   g_assert ( iter != NULL );
 592
 593   gtk_tree_model_iter_parent ( vt->model, &parent_iter, iter );
 594
 595   g_assert ( gtk_tree_model_iter_children ( vt->model, &search_iter, &parent_iter ) );
 596
 597   do {
 598     gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
 599     if ( strcmp ( search_name, newname ) > 0 ) /* not >= or would trip on itself */
 600     {
 601       gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, &search_iter );
 602       g_free (search_name);
 603       search_name = NULL;
 604       return;
 605     }
 606     g_free (search_name);
 607     search_name = NULL;
 608   } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );
 609
 610   gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, NULL );
 611 }
 612
 613 void vik_treeview_add_sublayer_alphabetized
 614                  ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item,
 615                    gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
 616 {
 617   GtkTreeIter search_iter;
 618   gchar *search_name = NULL;
 619   g_assert ( iter != NULL );
 620
 621   if ( gtk_tree_model_iter_children ( vt->model, &search_iter, parent_iter ) )
 622   {
 623     gboolean found_greater_string = FALSE;
 624     do {
 625       gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
 626       if ( strcmp ( search_name, name ) >= 0 )
 627       {
 628         gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, &search_iter );
 629         found_greater_string = TRUE;
 630         g_free (search_name);
 631         search_name = NULL;
 632         break;
 633       }
 634       g_free (search_name);
 635       search_name = NULL;
 636     } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );
 637
 638     if ( ! found_greater_string )
 639       gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 640   }
 641   else
 642     gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 643
 644   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 );
 645 }
 646
 647 #endif
 648
 649 static void vik_treeview_finalize ( GObject *gob )
 650 {
 651   VikTreeview *vt = VIK_TREEVIEW ( gob );
 652   guint16 i;
 653
 654   for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
 655     if ( vt->layer_type_icons[i] != NULL )
 656       g_object_unref ( G_OBJECT(vt->layer_type_icons[i]) );
 657
 658   G_OBJECT_CLASS(parent_class)->finalize(gob);
 659 }
 660
 661 static gboolean vik_treeview_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data)
 662 {
 663   GtkTreeModel *tree_model;
 664   GtkTreeModel *src_model = NULL;
 665   GtkTreePath *src_path = NULL, *dest_cp = NULL;
 666   gboolean retval = FALSE;
 667   GtkTreeIter src_iter, root_iter, dest_parent;
 668   VikTreeview *vt;
 669   VikLayer *vl;
 670
 671   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_dest), FALSE);
 672
 673   tree_model = GTK_TREE_MODEL (drag_dest);
 674
 675   if (gtk_tree_get_row_drag_data (selection_data, &src_model, &src_path) && src_model == tree_model) {
 676     /*
 677      * Copy src_path to dest.  There are two subcases here, depending on what
 678      * is being dragged.
 679      *
 680      * 1. src_path is a layer. In this case, interpret the drop
 681      *    as a request to move the layer to a different aggregate layer.
 682      *    If the destination is not an aggregate layer, use the first
 683      *    ancestor that is.
 684      *
 685      * 2. src_path is a sublayer.  In this case, find ancestors of
 686      *    both source and destination nodes who are full layers,
 687      *    and call the move method of that layer type.
 688      *
 689      */
 690     if (!gtk_tree_model_get_iter (src_model, &src_iter, src_path)) {
 691       goto out;
 692     }
 693     if (!gtk_tree_path_compare(src_path, dest)) {
 694       goto out;
 695     }
 696
 697     dest_cp = gtk_tree_path_copy (dest);
 698
 699     gtk_tree_model_get_iter_first(tree_model, &root_iter);
 700     TREEVIEW_GET(tree_model, &root_iter, ITEM_POINTER_COLUMN, &vl);
 701     vt = vl->vt;
 702
 703
 704     if (gtk_tree_path_get_depth(dest_cp)>1) { /* can't be sibling of top layer */
 705       VikLayer *vl_src, *vl_dest;
 706
 707       /* Find the first ancestor that is a full layer, and store in dest_parent. */
 708       do {
 709         gtk_tree_path_up(dest_cp);
 710         gtk_tree_model_get_iter (src_model, &dest_parent, dest_cp);
 711       } while (gtk_tree_path_get_depth(dest_cp)>1 &&
 712                vik_treeview_item_get_type(vt, &dest_parent) != VIK_TREEVIEW_TYPE_LAYER);
 713
 714
 715       g_assert ( vik_treeview_item_get_parent(vt, &src_iter) );
 716       vl_src = vik_treeview_item_get_parent(vt, &src_iter);
 717       vl_dest = vik_treeview_item_get_pointer(vt, &dest_parent);
 718
 719       /* TODO: might want to allow different types, and let the clients handle how they want */
 720       if (vl_src->type == vl_dest->type && vik_layer_get_interface(vl_dest->type)->drag_drop_request) {
 721         //      g_print("moving an item from layer '%s' into layer '%s'\n", vl_src->name, vl_dest->name);
 722         vik_layer_get_interface(vl_dest->type)->drag_drop_request(vl_src, vl_dest, &src_iter, dest);
 723       }
 724     }
 725   }
 726
 727  out:
 728   if (dest_cp)
 729     gtk_tree_path_free(dest_cp);
 730   if (src_path)
 731     gtk_tree_path_free (src_path);
 732
 733   return retval;
 734 }
 735
 736 /*
 737  * This may not be necessary.
 738  */
 739 static gboolean vik_treeview_drag_data_delete ( GtkTreeDragSource *drag_source, GtkTreePath *path )
 740 {
 741   gchar *s_dest = gtk_tree_path_to_string(path);
 742   g_print(_("delete data from %s\n"), s_dest);
 743   g_free(s_dest);
 744   return FALSE;
 745 }