2 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
4 * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
5 * Copyright (C) 2010-2015, Rob Norris <rw_norris@hotmail.com>
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.
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.
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
28 #include <glib/gi18n.h>
35 #define TREEVIEW_GET(model,iter,what,dest) gtk_tree_model_get(GTK_TREE_MODEL(model),(iter),(what),(dest),-1)
38 VT_ITEM_EDITED_SIGNAL,
39 VT_ITEM_TOGGLED_SIGNAL,
43 static guint treeview_signals[VT_LAST_SIGNAL] = { 0, 0 };
45 static GObjectClass *parent_class;
59 ITEM_TIMESTAMP_COLUMN, // Date timestamp stored in tree model to enable sorting on this value
67 GdkPixbuf *layer_type_icons[VIK_LAYER_NUM_TYPES];
69 gboolean was_a_toggle;
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 );
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 );
80 G_DEFINE_TYPE (VikTreeview, vik_treeview, GTK_TYPE_TREE_VIEW)
82 static void vik_cclosure_marshal_VOID__POINTER_POINTER ( GClosure *closure,
85 const GValue *param_values,
86 gpointer invocation_hint,
87 gpointer marshal_data )
89 typedef gboolean (*VikMarshalFunc_VOID__POINTER_POINTER) ( gpointer data1,
94 register VikMarshalFunc_VOID__POINTER_POINTER callback;
95 register GCClosure* cc = (GCClosure*) closure;
96 register gpointer data1, data2;
98 g_return_if_fail (n_param_vals == 3);
100 if (G_CCLOSURE_SWAP_DATA(closure)) {
101 data1 = closure->data;
102 data2 = g_value_peek_pointer (param_values + 0);
105 data1 = g_value_peek_pointer (param_values + 0);
106 data2 = closure->data;
108 callback = (VikMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
110 g_value_get_pointer(param_values + 1),
111 g_value_get_pointer(param_values + 2),
115 static void vik_treeview_class_init ( VikTreeviewClass *klass )
118 GObjectClass *object_class;
120 object_class = G_OBJECT_CLASS (klass);
122 object_class->finalize = vik_treeview_finalize;
124 parent_class = g_type_class_peek_parent (klass);
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);
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 );
133 static void vik_treeview_edited_cb (GtkCellRendererText *cell, gchar *path_str, const gchar *new_name, VikTreeview *vt)
138 /* get type and data */
139 vik_treeview_get_iter_from_path_str ( vt, &iter, path_str );
141 g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_EDITED_SIGNAL], 0, &iter, new_name );
144 static void vik_treeview_edit_start_cb (GtkCellRenderer *cell, GtkCellEditable *editable, gchar *path, VikTreeview *vt)
149 static void vik_treeview_edit_stop_cb (GtkCellRenderer *cell, VikTreeview *vt)
154 static void vik_treeview_toggled_cb (GtkCellRendererToggle *cell, gchar *path_str, VikTreeview *vt)
156 GtkTreeIter iter_toggle;
157 GtkTreeIter iter_selected;
159 /* get type and data */
160 vik_treeview_get_iter_from_path_str ( vt, &iter_toggle, path_str );
162 GtkTreePath *tp_toggle = gtk_tree_model_get_path ( vt->model, &iter_toggle );
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 );
173 // Toggle set on new path
174 // therefore prevent subsequent auto selection
175 vt->was_a_toggle = TRUE;
177 gtk_tree_path_free ( tp_toggle );
179 g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_TOGGLED_SIGNAL], 0, &iter_toggle );
182 /* Inspired by GTK+ test
183 * http://git.gnome.org/browse/gtk+/tree/tests/testtooltips.c
186 vik_treeview_tooltip_cb (GtkWidget *widget,
189 gboolean keyboard_tip,
194 GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
195 GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
196 GtkTreePath *path = NULL;
200 if (!gtk_tree_view_get_tooltip_context (tree_view, &x, &y,
202 &model, &path, &iter))
205 /* ATM normally treeview doesn't call into layers - maybe another level of redirection required? */
207 gtk_tree_model_get (model, &iter, TYPE_COLUMN, &rv, -1);
208 if ( rv == VIK_TREEVIEW_TYPE_SUBLAYER ) {
210 gtk_tree_model_get (model, &iter, ITEM_DATA_COLUMN, &rv, -1);
213 gtk_tree_model_get (model, &iter, ITEM_POINTER_COLUMN, &sublayer, -1);
216 gtk_tree_model_get (model, &iter, ITEM_PARENT_COLUMN, &parent, -1);
218 g_snprintf (buffer, sizeof(buffer), "%s", vik_layer_sublayer_tooltip (VIK_LAYER(parent), rv, sublayer));
220 else if ( rv == VIK_TREEVIEW_TYPE_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)));
226 gtk_tree_path_free (path);
230 // Don't display null strings :)
231 if ( strncmp (buffer, "(null)", 6) == 0 ) {
232 gtk_tree_path_free (path);
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);
242 gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
244 gtk_tree_path_free (path);
249 VikTreeview *vik_treeview_new ()
251 return VIK_TREEVIEW ( g_object_new ( VIK_TREEVIEW_TYPE, NULL ) );
254 gint vik_treeview_item_get_type ( VikTreeview *vt, GtkTreeIter *iter )
257 TREEVIEW_GET ( vt->model, iter, TYPE_COLUMN, &rv );
261 gchar* vik_treeview_item_get_name ( VikTreeview *vt, GtkTreeIter *iter )
264 TREEVIEW_GET ( vt->model, iter, NAME_COLUMN, &rv );
268 gint vik_treeview_item_get_data ( VikTreeview *vt, GtkTreeIter *iter )
271 TREEVIEW_GET ( vt->model, iter, ITEM_DATA_COLUMN, &rv );
275 gpointer vik_treeview_item_get_pointer ( VikTreeview *vt, GtkTreeIter *iter )
278 TREEVIEW_GET ( vt->model, iter, ITEM_POINTER_COLUMN, &rv );
282 void vik_treeview_item_set_pointer ( VikTreeview *vt, GtkTreeIter *iter, gpointer pointer )
284 gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_POINTER_COLUMN, pointer, -1 );
287 void vik_treeview_item_set_timestamp ( VikTreeview *vt, GtkTreeIter *iter, time_t timestamp )
289 gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_TIMESTAMP_COLUMN, (gint64)timestamp, -1 );
292 gpointer vik_treeview_item_get_parent ( VikTreeview *vt, GtkTreeIter *iter )
295 TREEVIEW_GET ( vt->model, iter, ITEM_PARENT_COLUMN, &rv );
299 gboolean vik_treeview_get_iter_from_path_str ( VikTreeview *vt, GtkTreeIter *iter, const gchar *path_str )
301 return gtk_tree_model_get_iter_from_string ( GTK_TREE_MODEL(vt->model), iter, path_str );
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.)
309 gboolean vik_treeview_item_get_visible_tree ( VikTreeview *vt, GtkTreeIter *iter )
312 TREEVIEW_GET ( vt->model, iter, VISIBLE_COLUMN, &ans );
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
330 static void vik_treeview_add_columns ( VikTreeview *vt )
333 GtkCellRenderer *renderer;
334 GtkTreeViewColumn *column;
337 renderer = gtk_cell_renderer_text_new ();
338 g_signal_connect (renderer, "edited",
339 G_CALLBACK (vik_treeview_edited_cb), vt);
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);
344 g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
346 col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
350 "editable", EDITABLE_COLUMN,
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);
361 renderer = gtk_cell_renderer_pixbuf_new ();
363 g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL);
365 col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
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);
376 renderer = gtk_cell_renderer_toggle_new ();
377 g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL);
379 g_signal_connect (renderer, "toggled", G_CALLBACK (vik_treeview_toggled_cb), vt);
381 col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
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);
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);
397 static void select_cb(GtkTreeSelection *selection, gpointer data)
399 VikTreeview *vt = data;
401 GtkTreeIter iter, parent;
406 VikLayer *tmp_vl = NULL;
407 gint tmp_subtype = 0;
408 gint tmp_type = VIK_TREEVIEW_TYPE_LAYER;
410 if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) return;
411 type = vik_treeview_item_get_type( vt, &iter);
413 /* Find the Sublayer type if possible */
414 tmp_layer = vik_treeview_item_get_pointer ( vt, &iter );
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;
423 tmp_subtype = vik_treeview_item_get_data(vt, &iter);
424 tmp_type = VIK_TREEVIEW_TYPE_SUBLAYER;
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 ) )
432 type = vik_treeview_item_get_type (vt, &iter );
435 vl = VIK_LAYER( vik_treeview_item_get_pointer ( vt, &iter ) );
437 vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vl));
438 vik_window_selected_layer(vw, vl);
442 /* Apply settings now we have the all details */
443 if ( vik_layer_selected ( tmp_vl,
447 vik_window_layers_panel(vw) ) ) {
448 /* Redraw required */
449 vik_layers_panel_emit_update ( vik_window_layers_panel(vw) );
454 static gboolean vik_treeview_selection_filter(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer data)
456 VikTreeview *vt = data;
458 if (vt->was_a_toggle) {
459 vt->was_a_toggle = FALSE;
466 void vik_treeview_init ( VikTreeview *vt )
468 vt->was_a_toggle = FALSE;
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
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);
488 gtk_tree_view_set_model ( GTK_TREE_VIEW(vt), vt->model );
489 vik_treeview_add_columns ( vt );
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()
495 g_object_unref (vt->model);
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);
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
506 GtkTreeDragSourceIface *isrc;
507 GtkTreeDragDestIface *idest;
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;
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;
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. */
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);
526 gboolean vik_treeview_item_get_parent_iter ( VikTreeview *vt, GtkTreeIter *iter, GtkTreeIter *parent )
528 return gtk_tree_model_iter_parent ( GTK_TREE_MODEL(vt->model), parent, iter );
531 gboolean vik_treeview_move_item ( VikTreeview *vt, GtkTreeIter *iter, gboolean up )
533 gint t = vik_treeview_item_get_type ( vt, iter );
534 if ( t == VIK_TREEVIEW_TYPE_LAYER )
536 GtkTreeIter switch_iter;
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 ) )
543 gtk_tree_path_free ( path );
546 gtk_tree_path_free ( path );
551 if ( !gtk_tree_model_iter_next ( vt->model, &switch_iter ) )
554 gtk_tree_store_swap ( GTK_TREE_STORE(vt->model), iter, &switch_iter );
556 /* now, the easy part. actually switching them, not the GUI */
557 } /* if item is map */
561 gboolean vik_treeview_get_iter_at_pos ( VikTreeview *vt, GtkTreeIter *iter, gint x, gint y )
564 (void)gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(vt), x, y, &path, NULL, NULL, NULL );
568 gtk_tree_model_get_iter (GTK_TREE_MODEL(vt->model), iter, path);
569 gtk_tree_path_free ( path );
573 /* Option to ensure visible */
574 void vik_treeview_select_iter ( VikTreeview *vt, GtkTreeIter *iter, gboolean view_all )
576 GtkTreeView *tree_view = GTK_TREE_VIEW ( vt );
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 );
584 gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( tree_view ), iter );
587 gtk_tree_view_scroll_to_cell ( tree_view,
589 gtk_tree_view_get_expander_column (tree_view),
592 gtk_tree_path_free ( path );
596 gboolean vik_treeview_get_selected_iter ( VikTreeview *vt, GtkTreeIter *iter )
598 return gtk_tree_selection_get_selected ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), NULL, iter );
601 gboolean vik_treeview_get_editing ( VikTreeview *vt )
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
609 void vik_treeview_item_delete ( VikTreeview *vt, GtkTreeIter *iter )
611 gtk_tree_store_remove ( GTK_TREE_STORE(vt->model), iter );
614 /* Treeview Reform Project */
616 void vik_treeview_item_set_icon ( VikTreeview *vt, GtkTreeIter *iter, const GdkPixbuf *icon )
618 g_return_if_fail ( iter != NULL );
619 gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ICON_COLUMN, icon, -1);
622 void vik_treeview_item_set_name ( VikTreeview *vt, GtkTreeIter *iter, const gchar *to )
624 g_return_if_fail ( iter != NULL && to != NULL );
625 gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, to, -1);
628 void vik_treeview_item_set_visible ( VikTreeview *vt, GtkTreeIter *iter, gboolean to )
630 g_return_if_fail ( iter != NULL );
631 gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 );
634 void vik_treeview_item_toggle_visible ( VikTreeview *vt, GtkTreeIter *iter )
636 g_return_if_fail ( iter != NULL );
638 TREEVIEW_GET ( vt->model, iter, VISIBLE_COLUMN, &to );
640 gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 );
643 void vik_treeview_expand ( VikTreeview *vt, GtkTreeIter *iter )
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 );
651 void vik_treeview_item_select ( VikTreeview *vt, GtkTreeIter *iter )
653 gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
656 void vik_treeview_item_unselect ( VikTreeview *vt, GtkTreeIter *iter )
658 gtk_tree_selection_unselect_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
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 )
664 g_assert ( iter != NULL );
666 gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
668 gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
669 gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter,
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,
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 )
685 g_assert ( iter != NULL );
688 gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling );
690 gtk_tree_store_insert_after ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling );
693 gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
695 gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
698 gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter,
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,
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 )
714 g_assert ( iter != NULL );
716 gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
717 gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter,
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,
726 ITEM_TIMESTAMP_COLUMN, (gint64)timestamp,
730 // Inspired by the internals of GtkTreeView sorting itself
731 typedef struct _SortTuple
741 static gint sort_tuple_compare ( gconstpointer a, gconstpointer b, gpointer order )
743 SortTuple *sa = (SortTuple *)a;
744 SortTuple *sb = (SortTuple *)b;
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 )
757 gboolean ans = ( sa->timestamp > sb->timestamp );
760 // Invert sort order for descending order
761 if ( GPOINTER_TO_INT(order) == VL_SO_DATE_DESCENDING )
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.
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
776 * Use the gtk_tree_store_reorder method as it very quick
778 * This ordering can be performed on demand and works for any parent iterator (i.e. both sublayer and layer levels)
780 * It should be called whenever an individual sublayer item is added or renamed (or after a group of sublayer items have been added).
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
787 void vik_treeview_sort_children ( VikTreeview *vt, GtkTreeIter *parent, vik_layer_sort_order_t order )
789 if ( order == VL_SO_NONE )
793 GtkTreeModel *model = vt->model;
795 if ( !gtk_tree_model_iter_children ( model, &child, parent ) )
798 guint length = gtk_tree_model_iter_n_children ( model, parent );
800 // Create an array to store the position offsets
801 SortTuple *sort_array;
802 sort_array = g_new ( SortTuple, length );
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 );
810 } while ( gtk_tree_model_iter_next (model, &child) );
813 g_qsort_with_data (sort_array,
817 GINT_TO_POINTER(order));
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 );
825 g_free ( sort_array );
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 );
832 static void vik_treeview_finalize ( GObject *gob )
834 VikTreeview *vt = VIK_TREEVIEW ( gob );
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]) );
840 G_OBJECT_CLASS(parent_class)->finalize(gob);
843 static gboolean vik_treeview_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data)
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;
853 g_return_val_if_fail (GTK_IS_TREE_STORE (drag_dest), FALSE);
855 tree_model = GTK_TREE_MODEL (drag_dest);
857 if (gtk_tree_get_row_drag_data (selection_data, &src_model, &src_path) && src_model == tree_model) {
859 * Copy src_path to dest. There are two subcases here, depending on what
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
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.
872 if (!gtk_tree_model_get_iter (src_model, &src_iter, src_path)) {
875 if (!gtk_tree_path_compare(src_path, dest)) {
879 dest_cp = gtk_tree_path_copy (dest);
881 gtk_tree_model_get_iter_first(tree_model, &root_iter);
882 TREEVIEW_GET(tree_model, &root_iter, ITEM_POINTER_COLUMN, &vl);
886 if (gtk_tree_path_get_depth(dest_cp)>1) { /* can't be sibling of top layer */
887 VikLayer *vl_src, *vl_dest;
889 /* Find the first ancestor that is a full layer, and store in dest_parent. */
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);
897 vl_src = vik_treeview_item_get_parent(vt, &src_iter);
899 vl_dest = vik_treeview_item_get_pointer(vt, &dest_parent);
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);
911 gtk_tree_path_free(dest_cp);
913 gtk_tree_path_free (src_path);
919 * This may not be necessary.
921 static gboolean vik_treeview_drag_data_delete ( GtkTreeDragSource *drag_source, GtkTreePath *path )
923 gchar *s_dest = gtk_tree_path_to_string(path);
924 g_print(_("delete data from %s\n"), s_dest);