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