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  * Copyright (C) 2010-2015, Rob Norris <rw_norris@hotmail.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <gtk/gtk.h>
  28 #include <glib/gi18n.h>
  29
  30 #include <string.h>
  31
  32 #include "viking.h"
  33 #include "config.h"
  34
  35 #define TREEVIEW_GET(model,iter,what,dest) gtk_tree_model_get(GTK_TREE_MODEL(model),(iter),(what),(dest),-1)
  36
  37 enum {
  38   VT_ITEM_EDITED_SIGNAL,
  39   VT_ITEM_TOGGLED_SIGNAL,
  40   VT_LAST_SIGNAL
  41 };
  42
  43 static guint treeview_signals[VT_LAST_SIGNAL] = { 0, 0 };
  44
  45 static GObjectClass *parent_class;
  46
  47 enum
  48 {
  49   NAME_COLUMN = 0,
  50   VISIBLE_COLUMN,
  51   ICON_COLUMN,
  52   /* invisible */
  53
  54   TYPE_COLUMN,
  55   ITEM_PARENT_COLUMN,
  56   ITEM_POINTER_COLUMN,
  57   ITEM_DATA_COLUMN,
  58   EDITABLE_COLUMN,
  59   ITEM_TIMESTAMP_COLUMN, // Date timestamp stored in tree model to enable sorting on this value
  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     gtk_tree_path_free ( tp_selected );
 171   }
 172   else
 173     // Toggle set on new path
 174     // therefore prevent subsequent auto selection
 175     vt->was_a_toggle = TRUE;
 176
 177   gtk_tree_path_free ( tp_toggle );
 178
 179   g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_TOGGLED_SIGNAL], 0, &iter_toggle );
 180 }
 181
 182 /* Inspired by GTK+ test
 183  * http://git.gnome.org/browse/gtk+/tree/tests/testtooltips.c
 184  */
 185 static gboolean
 186 vik_treeview_tooltip_cb (GtkWidget  *widget,
 187                      gint        x,
 188                      gint        y,
 189                      gboolean    keyboard_tip,
 190                      GtkTooltip *tooltip,
 191                      gpointer    data)
 192 {
 193   GtkTreeIter iter;
 194   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
 195   GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
 196   GtkTreePath *path = NULL;
 197
 198   char buffer[256];
 199
 200   if (!gtk_tree_view_get_tooltip_context (tree_view, &x, &y,
 201                                           keyboard_tip,
 202                                           &model, &path, &iter))
 203     return FALSE;
 204
 205   /* ATM normally treeview doesn't call into layers - maybe another level of redirection required? */
 206   gint rv;
 207   gtk_tree_model_get (model, &iter, TYPE_COLUMN, &rv, -1);
 208   if ( rv == VIK_TREEVIEW_TYPE_SUBLAYER ) {
 209
 210     gtk_tree_model_get (model, &iter, ITEM_DATA_COLUMN, &rv, -1);
 211
 212     gpointer sublayer;
 213     gtk_tree_model_get (model, &iter, ITEM_POINTER_COLUMN, &sublayer, -1);
 214
 215     gpointer parent;
 216     gtk_tree_model_get (model, &iter, ITEM_PARENT_COLUMN, &parent, -1);
 217
 218     g_snprintf (buffer, sizeof(buffer), "%s", vik_layer_sublayer_tooltip (VIK_LAYER(parent), rv, sublayer));
 219   }
 220   else if ( rv == VIK_TREEVIEW_TYPE_LAYER ) {
 221     gpointer layer;
 222     gtk_tree_model_get (model, &iter, ITEM_POINTER_COLUMN, &layer, -1);
 223     g_snprintf (buffer, sizeof(buffer), "%s", vik_layer_layer_tooltip (VIK_LAYER(layer)));
 224   }
 225   else {
 226     gtk_tree_path_free (path);
 227     return FALSE;
 228   }
 229
 230   // Don't display null strings :)
 231   if ( strncmp (buffer, "(null)", 6) == 0 ) {
 232     gtk_tree_path_free (path);
 233     return FALSE;
 234   }
 235   else {
 236     // No point in using (Pango) markup verson - gtk_tooltip_set_markup()
 237     //  especially as waypoint comments may well contain HTML markup which confuses the pango markup parser
 238     // This plain text is probably faster too.
 239     gtk_tooltip_set_text (tooltip, buffer);
 240   }
 241
 242   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
 243
 244   gtk_tree_path_free (path);
 245
 246   return TRUE;
 247 }
 248
 249 VikTreeview *vik_treeview_new ()
 250 {
 251   return VIK_TREEVIEW ( g_object_new ( VIK_TREEVIEW_TYPE, NULL ) );
 252 }
 253
 254 gint vik_treeview_item_get_type ( VikTreeview *vt, GtkTreeIter *iter )
 255 {
 256   gint rv;
 257   TREEVIEW_GET ( vt->model, iter, TYPE_COLUMN, &rv );
 258   return rv;
 259 }
 260
 261 gchar* vik_treeview_item_get_name ( VikTreeview *vt, GtkTreeIter *iter )
 262 {
 263   gchar *rv;
 264   TREEVIEW_GET ( vt->model, iter, NAME_COLUMN, &rv );
 265   return rv;
 266 }
 267
 268 gint vik_treeview_item_get_data ( VikTreeview *vt, GtkTreeIter *iter )
 269 {
 270   gint rv;
 271   TREEVIEW_GET ( vt->model, iter, ITEM_DATA_COLUMN, &rv );
 272   return rv;
 273 }
 274
 275 gpointer vik_treeview_item_get_pointer ( VikTreeview *vt, GtkTreeIter *iter )
 276 {
 277   gpointer rv;
 278   TREEVIEW_GET ( vt->model, iter, ITEM_POINTER_COLUMN, &rv );
 279   return rv;
 280 }
 281
 282 void vik_treeview_item_set_pointer ( VikTreeview *vt, GtkTreeIter *iter, gpointer pointer )
 283 {
 284   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_POINTER_COLUMN, pointer, -1 );
 285 }
 286
 287 void vik_treeview_item_set_timestamp ( VikTreeview *vt, GtkTreeIter *iter, time_t timestamp )
 288 {
 289   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_TIMESTAMP_COLUMN, (gint64)timestamp, -1 );
 290 }
 291
 292 gpointer vik_treeview_item_get_parent ( VikTreeview *vt, GtkTreeIter *iter )
 293 {
 294   gpointer rv;
 295   TREEVIEW_GET ( vt->model, iter, ITEM_PARENT_COLUMN, &rv );
 296   return rv;
 297 }
 298
 299 gboolean vik_treeview_get_iter_from_path_str ( VikTreeview *vt, GtkTreeIter *iter, const gchar *path_str )
 300 {
 301   return gtk_tree_model_get_iter_from_string ( GTK_TREE_MODEL(vt->model), iter, path_str );
 302 }
 303
 304 /**
 305  * Get visibility of an item considering visibility of all parents
 306  *  i.e. if any parent is off then this item will also be considered off
 307  *   (even though itself may be marked as on.)
 308  */
 309 gboolean vik_treeview_item_get_visible_tree ( VikTreeview *vt, GtkTreeIter *iter )
 310 {
 311   gboolean ans;
 312   TREEVIEW_GET ( vt->model, iter, VISIBLE_COLUMN, &ans );
 313
 314   if ( !ans )
 315     return ans;
 316
 317   GtkTreeIter parent;
 318   GtkTreeIter child = *iter;
 319   while ( gtk_tree_model_iter_parent (vt->model, &parent, &child) ) {
 320     // Visibility of this parent
 321     TREEVIEW_GET ( vt->model, &parent, VISIBLE_COLUMN, &ans );
 322     // If not visible, no need to check further ancestors
 323     if ( !ans )
 324       break;
 325     child = parent;
 326   }
 327   return ans;
 328 }
 329
 330 static void vik_treeview_add_columns ( VikTreeview *vt )
 331 {
 332   gint col_offset;
 333   GtkCellRenderer *renderer;
 334   GtkTreeViewColumn *column;
 335
 336   /* Layer column */
 337   renderer = gtk_cell_renderer_text_new ();
 338   g_signal_connect (renderer, "edited",
 339                     G_CALLBACK (vik_treeview_edited_cb), vt);
 340
 341   g_signal_connect (renderer, "editing-started", G_CALLBACK (vik_treeview_edit_start_cb), vt);
 342   g_signal_connect (renderer, "editing-canceled", G_CALLBACK (vik_treeview_edit_stop_cb), vt);
 343
 344   g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 345
 346   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 347                                                             -1, _("Layer Name"),
 348                                                             renderer, "text",
 349                                                             NAME_COLUMN,
 350                                                             "editable", EDITABLE_COLUMN,
 351                                                             NULL);
 352
 353   /* ATM the minimum overall width (and starting default) of the treeview size is determined
 354      by the buttons added to the bottom of the layerspanel */
 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_FIXED);
 358   gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
 359
 360   /* Layer type */
 361   renderer = gtk_cell_renderer_pixbuf_new ();
 362
 363   g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL);
 364
 365   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 366                                                             -1, "",
 367                                                             renderer, "pixbuf",
 368                                                             ICON_COLUMN,
 369                                                             NULL);
 370
 371   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 372   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 373                                    GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 374
 375   /* Layer visible */
 376   renderer = gtk_cell_renderer_toggle_new ();
 377   g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL);
 378
 379   g_signal_connect (renderer, "toggled", G_CALLBACK (vik_treeview_toggled_cb), vt);
 380
 381   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 382                                                             -1, "",
 383                                                             renderer,
 384                                                             "active",
 385                                                             VISIBLE_COLUMN,
 386                                                             NULL);
 387
 388   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 389   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 390                                    GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 391
 392
 393   g_object_set (GTK_TREE_VIEW (vt), "has-tooltip", TRUE, NULL);
 394   g_signal_connect (GTK_TREE_VIEW (vt), "query-tooltip", G_CALLBACK (vik_treeview_tooltip_cb), vt);
 395 }
 396
 397 static void select_cb(GtkTreeSelection *selection, gpointer data)
 398 {
 399   VikTreeview *vt = data;
 400   gint type;
 401   GtkTreeIter iter, parent;
 402   VikLayer *vl;
 403   VikWindow * vw;
 404
 405   gpointer tmp_layer;
 406   VikLayer *tmp_vl = NULL;
 407   gint tmp_subtype = 0;
 408   gint tmp_type = VIK_TREEVIEW_TYPE_LAYER;
 409
 410   if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) return;
 411   type = vik_treeview_item_get_type( vt, &iter);
 412
 413   /* Find the Sublayer type if possible */
 414   tmp_layer = vik_treeview_item_get_pointer ( vt, &iter );
 415   if (tmp_layer) {
 416     if (type == VIK_TREEVIEW_TYPE_SUBLAYER) {
 417       tmp_vl = VIK_LAYER(vik_treeview_item_get_parent(vt, &iter));
 418       tmp_subtype = vik_treeview_item_get_data(vt, &iter);
 419       tmp_type = VIK_TREEVIEW_TYPE_SUBLAYER;
 420     }
 421   }
 422   else {
 423     tmp_subtype = vik_treeview_item_get_data(vt, &iter);
 424     tmp_type = VIK_TREEVIEW_TYPE_SUBLAYER;
 425   }
 426
 427   /* Go up the tree to find the Vik Layer */
 428   while ( type != VIK_TREEVIEW_TYPE_LAYER ) {
 429     if ( ! vik_treeview_item_get_parent_iter ( vt, &iter, &parent ) )
 430       return;
 431     iter = parent;
 432     type = vik_treeview_item_get_type (vt, &iter );
 433   }
 434
 435   vl = VIK_LAYER( vik_treeview_item_get_pointer ( vt, &iter ) );
 436
 437   vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vl));
 438   vik_window_selected_layer(vw, vl);
 439
 440   if (tmp_vl == NULL)
 441     tmp_vl = vl;
 442   /* Apply settings now we have the all details  */
 443   if ( vik_layer_selected ( tmp_vl,
 444                             tmp_subtype,
 445                             tmp_layer,
 446                             tmp_type,
 447                             vik_window_layers_panel(vw) ) ) {
 448     /* Redraw required */
 449     vik_layers_panel_emit_update ( vik_window_layers_panel(vw) );
 450   }
 451
 452 }
 453
 454 static gboolean vik_treeview_selection_filter(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer data)
 455 {
 456   VikTreeview *vt = data;
 457
 458   if (vt->was_a_toggle) {
 459     vt->was_a_toggle = FALSE;
 460     return FALSE;
 461   }
 462
 463   return TRUE;
 464 }
 465
 466 void vik_treeview_init ( VikTreeview *vt )
 467 {
 468   vt->was_a_toggle = FALSE;
 469   vt->editing = FALSE;
 470
 471   // ATM The dates are stored on initial creation and updated when items are deleted
 472   //  this should be good enough for most purposes, although it may get inaccurate if items are edited in a particular manner
 473   // NB implicit conversion of time_t to gint64
 474   vt->model = GTK_TREE_MODEL(gtk_tree_store_new ( NUM_COLUMNS,
 475                                                   G_TYPE_STRING,  // Name
 476                                                   G_TYPE_BOOLEAN, // Visibility
 477                                                   GDK_TYPE_PIXBUF,// The Icon
 478                                                   G_TYPE_INT,     // Layer Type
 479                                                   G_TYPE_POINTER, // pointer to TV parent
 480                                                   G_TYPE_POINTER, // pointer to the layer or sublayer
 481                                                   G_TYPE_INT,     // type of the sublayer
 482                                                   G_TYPE_BOOLEAN, // Editable
 483                                                   G_TYPE_INT64 )); // Timestamp
 484
 485   /* create tree view */
 486   gtk_tree_selection_set_select_function(gtk_tree_view_get_selection (GTK_TREE_VIEW(vt)), vik_treeview_selection_filter, vt, NULL);
 487
 488   gtk_tree_view_set_model ( GTK_TREE_VIEW(vt), vt->model );
 489   vik_treeview_add_columns ( vt );
 490
 491   // Can not specify 'auto' sort order with a 'GtkTreeSortable' on the name since we want to control the ordering of layers
 492   // Thus need to create special sort to operate on a subsection of treeview (i.e. from a specific child either a layer or sublayer)
 493   // see vik_treeview_sort_children()
 494
 495   g_object_unref (vt->model);
 496
 497   gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (vt), TRUE);
 498   gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)),
 499                                GTK_SELECTION_SINGLE);
 500
 501   /* Override treestore's dnd methods only; this is easier than deriving from GtkTreeStore.
 502    * The downside is that all treestores will have this behavior, so this needs to be
 503    * changed if we add more treeviews in the future.  //Alex
 504    */
 505   if (1) {
 506     GtkTreeDragSourceIface *isrc;
 507     GtkTreeDragDestIface *idest;
 508
 509     isrc = g_type_interface_peek (g_type_class_peek(G_OBJECT_TYPE(vt->model)), GTK_TYPE_TREE_DRAG_SOURCE);
 510     isrc->drag_data_delete = vik_treeview_drag_data_delete;
 511
 512     idest = g_type_interface_peek (g_type_class_peek(G_OBJECT_TYPE(vt->model)), GTK_TYPE_TREE_DRAG_DEST);
 513     idest->drag_data_received = vik_treeview_drag_data_received;
 514   }
 515
 516   VikLayerTypeEnum i;
 517   for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
 518     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. */
 519
 520   gtk_tree_view_set_reorderable (GTK_TREE_VIEW(vt), TRUE);
 521   g_signal_connect(gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)), "changed",
 522       G_CALLBACK(select_cb), vt);
 523
 524 }
 525
 526 gboolean vik_treeview_item_get_parent_iter ( VikTreeview *vt, GtkTreeIter *iter,  GtkTreeIter *parent )
 527 {
 528   return gtk_tree_model_iter_parent ( GTK_TREE_MODEL(vt->model), parent, iter );
 529 }
 530
 531 gboolean vik_treeview_move_item ( VikTreeview *vt, GtkTreeIter *iter, gboolean up )
 532 {
 533   gint t = vik_treeview_item_get_type ( vt, iter );
 534   if ( t == VIK_TREEVIEW_TYPE_LAYER )
 535   {
 536     GtkTreeIter switch_iter;
 537     if (up)
 538     {
 539       /* iter to path to iter */
 540       GtkTreePath *path = gtk_tree_model_get_path ( vt->model, iter );
 541       if ( !gtk_tree_path_prev ( path ) || !gtk_tree_model_get_iter ( vt->model, &switch_iter, path ) )
 542       {
 543         gtk_tree_path_free ( path );
 544         return FALSE;
 545       }
 546       gtk_tree_path_free ( path );
 547     }
 548     else
 549     {
 550       switch_iter = *iter;
 551       if ( !gtk_tree_model_iter_next ( vt->model, &switch_iter ) )
 552         return FALSE;
 553     }
 554     gtk_tree_store_swap ( GTK_TREE_STORE(vt->model), iter, &switch_iter );
 555     return TRUE;
 556     /* now, the easy part. actually switching them, not the GUI */
 557   } /* if item is map */
 558   return FALSE;
 559 }
 560
 561 gboolean vik_treeview_get_iter_at_pos ( VikTreeview *vt, GtkTreeIter *iter, gint x, gint y )
 562 {
 563   GtkTreePath *path;
 564   (void)gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(vt), x, y, &path, NULL, NULL, NULL );
 565   if ( ! path )
 566     return FALSE;
 567
 568   gtk_tree_model_get_iter (GTK_TREE_MODEL(vt->model), iter, path);
 569   gtk_tree_path_free ( path );
 570   return TRUE;
 571 }
 572
 573 /* Option to ensure visible */
 574 void vik_treeview_select_iter ( VikTreeview *vt, GtkTreeIter *iter, gboolean view_all )
 575 {
 576   GtkTreeView *tree_view = GTK_TREE_VIEW ( vt );
 577   GtkTreePath *path;
 578
 579   if ( view_all ) {
 580     path = gtk_tree_model_get_path ( gtk_tree_view_get_model (tree_view), iter );
 581     gtk_tree_view_expand_to_path ( tree_view, path );
 582   }
 583
 584   gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( tree_view ), iter );
 585
 586   if ( view_all ) {
 587     gtk_tree_view_scroll_to_cell  ( tree_view,
 588                                     path,
 589                                     gtk_tree_view_get_expander_column (tree_view),
 590                                     FALSE,
 591                                     0.0, 0.0 );
 592     gtk_tree_path_free ( path );
 593   }
 594 }
 595
 596 gboolean vik_treeview_get_selected_iter ( VikTreeview *vt, GtkTreeIter *iter )
 597 {
 598   return gtk_tree_selection_get_selected ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), NULL, iter );
 599 }
 600
 601 gboolean vik_treeview_get_editing ( VikTreeview *vt )
 602 {
 603   // Don't know how to get cell for the selected item
 604   //return GPOINTER_TO_INT(g_object_get_data ( G_OBJECT(cell), "editing" ));
 605   // Instead maintain our own value applying to the whole tree
 606   return vt->editing;
 607 }
 608
 609 void vik_treeview_item_delete ( VikTreeview *vt, GtkTreeIter *iter )
 610 {
 611   gtk_tree_store_remove ( GTK_TREE_STORE(vt->model), iter );
 612 }
 613
 614 /* Treeview Reform Project */
 615
 616 void vik_treeview_item_set_icon ( VikTreeview *vt, GtkTreeIter *iter, const GdkPixbuf *icon )
 617 {
 618   g_return_if_fail ( iter != NULL );
 619   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ICON_COLUMN, icon, -1);
 620 }
 621
 622 void vik_treeview_item_set_name ( VikTreeview *vt, GtkTreeIter *iter, const gchar *to )
 623 {
 624   g_return_if_fail ( iter != NULL && to != NULL );
 625   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, to, -1);
 626 }
 627
 628 void vik_treeview_item_set_visible ( VikTreeview *vt, GtkTreeIter *iter, gboolean to )
 629 {
 630   g_return_if_fail ( iter != NULL );
 631   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 );
 632 }
 633
 634 void vik_treeview_item_toggle_visible ( VikTreeview *vt, GtkTreeIter *iter )
 635 {
 636   g_return_if_fail ( iter != NULL );
 637   gboolean to;
 638   TREEVIEW_GET ( vt->model, iter, VISIBLE_COLUMN, &to );
 639   to = !to;
 640   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 );
 641 }
 642
 643 void vik_treeview_expand ( VikTreeview *vt, GtkTreeIter *iter )
 644 {
 645   GtkTreePath *path;
 646   path = gtk_tree_model_get_path ( vt->model, iter );
 647   gtk_tree_view_expand_row ( GTK_TREE_VIEW(vt), path, FALSE );
 648   gtk_tree_path_free ( path );
 649 }
 650
 651 void vik_treeview_item_select ( VikTreeview *vt, GtkTreeIter *iter )
 652 {
 653   gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
 654 }
 655
 656 void vik_treeview_item_unselect ( VikTreeview *vt, GtkTreeIter *iter )
 657 {
 658   gtk_tree_selection_unselect_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
 659 }
 660
 661 void vik_treeview_add_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gboolean above,
 662                               gpointer item, gint data, VikLayerTypeEnum layer_type, time_t timestamp )
 663 {
 664   g_assert ( iter != NULL );
 665   if ( above )
 666     gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 667   else
 668     gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 669   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter,
 670     NAME_COLUMN, name,
 671     VISIBLE_COLUMN, TRUE,
 672     TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER,
 673     ITEM_PARENT_COLUMN, parent,
 674     ITEM_POINTER_COLUMN, item,
 675     ITEM_DATA_COLUMN, data,
 676     EDITABLE_COLUMN, parent == NULL ? FALSE : TRUE,
 677     ICON_COLUMN, layer_type >= 0 ? vt->layer_type_icons[layer_type] : NULL,
 678     ITEM_TIMESTAMP_COLUMN, (gint64)timestamp,
 679     -1 );
 680 }
 681
 682 void vik_treeview_insert_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gboolean above,
 683                               gpointer item, gint data, VikLayerTypeEnum layer_type, GtkTreeIter *sibling, time_t timestamp )
 684 {
 685   g_assert ( iter != NULL );
 686   if (sibling) {
 687     if (above)
 688       gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling );
 689     else
 690       gtk_tree_store_insert_after ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling );
 691   } else {
 692     if (above)
 693       gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 694     else
 695       gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 696   }
 697
 698   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter,
 699                        NAME_COLUMN, name,
 700                        VISIBLE_COLUMN, TRUE,
 701                        TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER,
 702                        ITEM_PARENT_COLUMN, parent,
 703                        ITEM_POINTER_COLUMN, item,
 704                        ITEM_DATA_COLUMN, data,
 705                        EDITABLE_COLUMN, TRUE,
 706                        ICON_COLUMN, layer_type >= 0 ? vt->layer_type_icons[layer_type] : NULL,
 707                        ITEM_TIMESTAMP_COLUMN, (gint64)timestamp,
 708                        -1 );
 709 }
 710
 711 void vik_treeview_add_sublayer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item,
 712                                  gint data, GdkPixbuf *icon, gboolean editable, time_t timestamp )
 713 {
 714   g_assert ( iter != NULL );
 715
 716   gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 717   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter,
 718                        NAME_COLUMN, name,
 719                        VISIBLE_COLUMN, TRUE,
 720                        TYPE_COLUMN, VIK_TREEVIEW_TYPE_SUBLAYER,
 721                        ITEM_PARENT_COLUMN, parent,
 722                        ITEM_POINTER_COLUMN, item,
 723                        ITEM_DATA_COLUMN, data,
 724                        EDITABLE_COLUMN, editable,
 725                        ICON_COLUMN, icon,
 726                        ITEM_TIMESTAMP_COLUMN, (gint64)timestamp,
 727                        -1 );
 728 }
 729
 730 // Inspired by the internals of GtkTreeView sorting itself
 731 typedef struct _SortTuple
 732 {
 733   gint offset;
 734   gchar *name;
 735   gint64 timestamp;
 736 } SortTuple;
 737
 738 /**
 739  *
 740  */
 741 static gint sort_tuple_compare ( gconstpointer a, gconstpointer b, gpointer order )
 742 {
 743   SortTuple *sa = (SortTuple *)a;
 744   SortTuple *sb = (SortTuple *)b;
 745
 746   gint answer = -1;
 747   if ( GPOINTER_TO_INT(order) < VL_SO_DATE_ASCENDING ) {
 748     // Alphabetical comparison
 749     // Default ascending order
 750     answer = g_strcmp0 ( sa->name, sb->name );
 751     // Invert sort order for descending order
 752     if ( GPOINTER_TO_INT(order) == VL_SO_ALPHABETICAL_DESCENDING )
 753       answer = -answer;
 754   }
 755   else {
 756     // Date comparison
 757     gboolean ans = ( sa->timestamp > sb->timestamp );
 758     if ( ans )
 759       answer = 1;
 760     // Invert sort order for descending order
 761     if ( GPOINTER_TO_INT(order) == VL_SO_DATE_DESCENDING )
 762       answer = -answer;
 763   }
 764   return answer;
 765 }
 766
 767 /**
 768  * Note: I don't believe we can sensibility use built in model sort gtk_tree_model_sort_new_with_model() on the name,
 769  * since that would also sort the layers - but that needs to be user controlled for ordering, such as which maps get drawn on top.
 770  *
 771  * vik_treeview_sort_children:
 772  * @vt:     The treeview to operate on
 773  * @parent: The level within the treeview to sort
 774  * @order:  How the items should be sorted
 775  *
 776  * Use the gtk_tree_store_reorder method as it very quick
 777  *
 778  * This ordering can be performed on demand and works for any parent iterator (i.e. both sublayer and layer levels)
 779  *
 780  * It should be called whenever an individual sublayer item is added or renamed (or after a group of sublayer items have been added).
 781  *
 782  * Previously with insertion sort on every sublayer addition: adding 10,000 items would take over 30 seconds!
 783  * Now sorting after simply adding all tracks takes 1 second.
 784  * For a KML file with over 10,000 tracks (3Mb zipped) - See 'UK Hampshire Rights of Way'
 785  * http://www3.hants.gov.uk/row/row-maps.htm
 786  */
 787 void vik_treeview_sort_children ( VikTreeview *vt, GtkTreeIter *parent, vik_layer_sort_order_t order )
 788 {
 789   if ( order == VL_SO_NONE )
 790     // Nothing to do
 791     return;
 792
 793   GtkTreeModel *model = vt->model;
 794   GtkTreeIter child;
 795   if ( !gtk_tree_model_iter_children ( model, &child, parent ) )
 796     return;
 797
 798   guint length = gtk_tree_model_iter_n_children ( model, parent );
 799
 800   // Create an array to store the position offsets
 801   SortTuple *sort_array;
 802   sort_array = g_new ( SortTuple, length );
 803
 804   guint ii = 0;
 805   do {
 806     sort_array[ii].offset = ii;
 807     gtk_tree_model_get ( model, &child, NAME_COLUMN, &(sort_array[ii].name), -1 );
 808     gtk_tree_model_get ( model, &child, ITEM_TIMESTAMP_COLUMN, &(sort_array[ii].timestamp), -1 );
 809     ii++;
 810   } while ( gtk_tree_model_iter_next (model, &child) );
 811
 812   // Sort list...
 813   g_qsort_with_data (sort_array,
 814                      length,
 815                      sizeof (SortTuple),
 816                      sort_tuple_compare,
 817                      GINT_TO_POINTER(order));
 818
 819   // As the sorted list contains the reordered position offsets, extract this and then apply to the treeview
 820   gint *positions = g_malloc ( sizeof(gint) * length );
 821   for ( ii = 0; ii < length; ii++ ) {
 822     positions[ii] = sort_array[ii].offset;
 823     g_free ( sort_array[ii].name );
 824   }
 825   g_free ( sort_array );
 826
 827   // This is extremely fast compared to the old alphabetical insertion
 828   gtk_tree_store_reorder ( GTK_TREE_STORE(model), parent, positions );
 829   g_free ( positions );
 830 }
 831
 832 static void vik_treeview_finalize ( GObject *gob )
 833 {
 834   VikTreeview *vt = VIK_TREEVIEW ( gob );
 835   VikLayerTypeEnum i;
 836   for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
 837     if ( vt->layer_type_icons[i] != NULL )
 838       g_object_unref ( G_OBJECT(vt->layer_type_icons[i]) );
 839
 840   G_OBJECT_CLASS(parent_class)->finalize(gob);
 841 }
 842
 843 static gboolean vik_treeview_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data)
 844 {
 845   GtkTreeModel *tree_model;
 846   GtkTreeModel *src_model = NULL;
 847   GtkTreePath *src_path = NULL, *dest_cp = NULL;
 848   gboolean retval = FALSE;
 849   GtkTreeIter src_iter, root_iter, dest_parent;
 850   VikTreeview *vt;
 851   VikLayer *vl;
 852
 853   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_dest), FALSE);
 854
 855   tree_model = GTK_TREE_MODEL (drag_dest);
 856
 857   if (gtk_tree_get_row_drag_data (selection_data, &src_model, &src_path) && src_model == tree_model) {
 858     /*
 859      * Copy src_path to dest.  There are two subcases here, depending on what
 860      * is being dragged.
 861      *
 862      * 1. src_path is a layer. In this case, interpret the drop
 863      *    as a request to move the layer to a different aggregate layer.
 864      *    If the destination is not an aggregate layer, use the first
 865      *    ancestor that is.
 866      *
 867      * 2. src_path is a sublayer.  In this case, find ancestors of
 868      *    both source and destination nodes who are full layers,
 869      *    and call the move method of that layer type.
 870      *
 871      */
 872     if (!gtk_tree_model_get_iter (src_model, &src_iter, src_path)) {
 873       goto out;
 874     }
 875     if (!gtk_tree_path_compare(src_path, dest)) {
 876       goto out;
 877     }
 878
 879     dest_cp = gtk_tree_path_copy (dest);
 880
 881     gtk_tree_model_get_iter_first(tree_model, &root_iter);
 882     TREEVIEW_GET(tree_model, &root_iter, ITEM_POINTER_COLUMN, &vl);
 883     vt = vl->vt;
 884
 885
 886     if (gtk_tree_path_get_depth(dest_cp)>1) { /* can't be sibling of top layer */
 887       VikLayer *vl_src, *vl_dest;
 888
 889       /* Find the first ancestor that is a full layer, and store in dest_parent. */
 890       do {
 891         gtk_tree_path_up(dest_cp);
 892         gtk_tree_model_get_iter (src_model, &dest_parent, dest_cp);
 893       } while (gtk_tree_path_get_depth(dest_cp)>1 &&
 894                vik_treeview_item_get_type(vt, &dest_parent) != VIK_TREEVIEW_TYPE_LAYER);
 895
 896
 897       vl_src = vik_treeview_item_get_parent(vt, &src_iter);
 898       g_assert ( vl_src );
 899       vl_dest = vik_treeview_item_get_pointer(vt, &dest_parent);
 900
 901       /* TODO: might want to allow different types, and let the clients handle how they want */
 902       if (vl_src->type == vl_dest->type && vik_layer_get_interface(vl_dest->type)->drag_drop_request) {
 903         //      g_print("moving an item from layer '%s' into layer '%s'\n", vl_src->name, vl_dest->name);
 904         vik_layer_get_interface(vl_dest->type)->drag_drop_request(vl_src, vl_dest, &src_iter, dest);
 905       }
 906     }
 907   }
 908
 909  out:
 910   if (dest_cp)
 911     gtk_tree_path_free(dest_cp);
 912   if (src_path)
 913     gtk_tree_path_free (src_path);
 914
 915   return retval;
 916 }
 917
 918 /*
 919  * This may not be necessary.
 920  */
 921 static gboolean vik_treeview_drag_data_delete ( GtkTreeDragSource *drag_source, GtkTreePath *path )
 922 {
 923   gchar *s_dest = gtk_tree_path_to_string(path);
 924   g_print(_("delete data from %s\n"), s_dest);
 925   g_free(s_dest);
 926   return FALSE;
 927 }