]>
Commit | Line | Data |
---|---|---|
50a14534 EB |
1 | /* |
2 | * viking -- GPS Data and Topo Analyzer, Explorer, and Manager | |
3 | * | |
4 | * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net> | |
03c97bc3 | 5 | * Copyright (C) 2010-2015, Rob Norris <rw_norris@hotmail.com> |
50a14534 EB |
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 | ||
4c77d5e0 GB |
23 | #ifdef HAVE_CONFIG_H |
24 | #include "config.h" | |
25 | #endif | |
26 | ||
50a14534 | 27 | #include <gtk/gtk.h> |
4c77d5e0 GB |
28 | #include <glib/gi18n.h> |
29 | ||
50a14534 EB |
30 | #include <string.h> |
31 | ||
32 | #include "viking.h" | |
50a14534 EB |
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, | |
50a14534 | 58 | EDITABLE_COLUMN, |
03c97bc3 | 59 | ITEM_TIMESTAMP_COLUMN, // Date timestamp stored in tree model to enable sorting on this value |
50a14534 EB |
60 | NUM_COLUMNS |
61 | }; | |
62 | ||
63 | struct _VikTreeview { | |
64 | GtkTreeView treeview; | |
65 | GtkTreeModel *model; | |
66 | ||
67 | GdkPixbuf *layer_type_icons[VIK_LAYER_NUM_TYPES]; | |
e2ad36b5 QT |
68 | |
69 | gboolean was_a_toggle; | |
ee4c7107 | 70 | gboolean editing; |
50a14534 EB |
71 | }; |
72 | ||
73 | /* TODO: find, make "static" and put up here all non-"a_" functions */ | |
e747a56c GB |
74 | static void vik_treeview_finalize ( GObject *gob ); |
75 | static void vik_treeview_add_columns ( VikTreeview *vt ); | |
50a14534 | 76 | |
e747a56c GB |
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 ); | |
e4afc73a | 79 | |
e747a56c | 80 | G_DEFINE_TYPE (VikTreeview, vik_treeview, GTK_TYPE_TREE_VIEW) |
50a14534 | 81 | |
de8caa14 RN |
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 | ||
e747a56c | 115 | static void vik_treeview_class_init ( VikTreeviewClass *klass ) |
50a14534 EB |
116 | { |
117 | /* Destructor */ | |
118 | GObjectClass *object_class; | |
119 | ||
120 | object_class = G_OBJECT_CLASS (klass); | |
121 | ||
e747a56c | 122 | object_class->finalize = vik_treeview_finalize; |
50a14534 EB |
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, | |
de8caa14 | 127 | vik_cclosure_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_POINTER); |
50a14534 EB |
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, | |
d38b34f2 | 130 | g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER ); |
50a14534 EB |
131 | } |
132 | ||
e747a56c | 133 | static void vik_treeview_edited_cb (GtkCellRendererText *cell, gchar *path_str, const gchar *new_name, VikTreeview *vt) |
50a14534 | 134 | { |
ee4c7107 | 135 | vt->editing = FALSE; |
50a14534 EB |
136 | GtkTreeIter iter; |
137 | ||
138 | /* get type and data */ | |
139 | vik_treeview_get_iter_from_path_str ( vt, &iter, path_str ); | |
140 | ||
752f500c | 141 | g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_EDITED_SIGNAL], 0, &iter, new_name ); |
50a14534 EB |
142 | } |
143 | ||
ee4c7107 RN |
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 | ||
e747a56c | 154 | static void vik_treeview_toggled_cb (GtkCellRendererToggle *cell, gchar *path_str, VikTreeview *vt) |
50a14534 | 155 | { |
12fcd506 RN |
156 | GtkTreeIter iter_toggle; |
157 | GtkTreeIter iter_selected; | |
50a14534 EB |
158 | |
159 | /* get type and data */ | |
12fcd506 RN |
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; | |
7780e7ac | 170 | gtk_tree_path_free ( tp_selected ); |
12fcd506 RN |
171 | } |
172 | else | |
173 | // Toggle set on new path | |
174 | // therefore prevent subsequent auto selection | |
175 | vt->was_a_toggle = TRUE; | |
50a14534 | 176 | |
7780e7ac RN |
177 | gtk_tree_path_free ( tp_toggle ); |
178 | ||
12fcd506 | 179 | g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_TOGGLED_SIGNAL], 0, &iter_toggle ); |
50a14534 EB |
180 | } |
181 | ||
f43968ee RN |
182 | /* Inspired by GTK+ test |
183 | * http://git.gnome.org/browse/gtk+/tree/tests/testtooltips.c | |
184 | */ | |
185 | static gboolean | |
e747a56c | 186 | vik_treeview_tooltip_cb (GtkWidget *widget, |
f43968ee RN |
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); | |
f43968ee RN |
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 | } | |
7780e7ac RN |
225 | else { |
226 | gtk_tree_path_free (path); | |
f43968ee | 227 | return FALSE; |
7780e7ac | 228 | } |
f43968ee RN |
229 | |
230 | // Don't display null strings :) | |
231 | if ( strncmp (buffer, "(null)", 6) == 0 ) { | |
7780e7ac | 232 | gtk_tree_path_free (path); |
f43968ee RN |
233 | return FALSE; |
234 | } | |
235 | else { | |
ab46189a RN |
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); | |
f43968ee RN |
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 | ||
50a14534 EB |
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 | ||
c9570f86 RN |
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 | ||
50a14534 EB |
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 | ||
b3c24ce7 RN |
287 | void vik_treeview_item_set_timestamp ( VikTreeview *vt, GtkTreeIter *iter, time_t timestamp ) |
288 | { | |
26ebb26f | 289 | gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_TIMESTAMP_COLUMN, (gint64)timestamp, -1 ); |
b3c24ce7 RN |
290 | } |
291 | ||
50a14534 EB |
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 | ||
e673b75f | 299 | gboolean vik_treeview_get_iter_from_path_str ( VikTreeview *vt, GtkTreeIter *iter, const gchar *path_str ) |
50a14534 | 300 | { |
e673b75f | 301 | return gtk_tree_model_get_iter_from_string ( GTK_TREE_MODEL(vt->model), iter, path_str ); |
50a14534 EB |
302 | } |
303 | ||
b2ba4fd5 RN |
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 | ||
e747a56c | 330 | static void vik_treeview_add_columns ( VikTreeview *vt ) |
50a14534 EB |
331 | { |
332 | gint col_offset; | |
333 | GtkCellRenderer *renderer; | |
334 | GtkTreeViewColumn *column; | |
335 | ||
181f5d0c | 336 | /* Layer column */ |
50a14534 EB |
337 | renderer = gtk_cell_renderer_text_new (); |
338 | g_signal_connect (renderer, "edited", | |
e747a56c | 339 | G_CALLBACK (vik_treeview_edited_cb), vt); |
50a14534 | 340 | |
ee4c7107 RN |
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 | ||
d07cdaa1 | 344 | g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL); |
50a14534 EB |
345 | |
346 | col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt), | |
4c77d5e0 | 347 | -1, _("Layer Name"), |
50a14534 EB |
348 | renderer, "text", |
349 | NAME_COLUMN, | |
350 | "editable", EDITABLE_COLUMN, | |
351 | NULL); | |
352 | ||
d07cdaa1 RN |
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 */ | |
50a14534 EB |
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), | |
d07cdaa1 | 357 | GTK_TREE_VIEW_COLUMN_FIXED); |
181f5d0c | 358 | gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); |
50a14534 | 359 | |
181f5d0c | 360 | /* Layer type */ |
50a14534 EB |
361 | renderer = gtk_cell_renderer_pixbuf_new (); |
362 | ||
3570ad57 | 363 | g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL); |
50a14534 EB |
364 | |
365 | col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt), | |
3570ad57 | 366 | -1, "", |
50a14534 EB |
367 | renderer, "pixbuf", |
368 | ICON_COLUMN, | |
369 | NULL); | |
370 | ||
50a14534 | 371 | column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1); |
50a14534 | 372 | gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), |
181f5d0c | 373 | GTK_TREE_VIEW_COLUMN_AUTOSIZE); |
50a14534 | 374 | |
181f5d0c | 375 | /* Layer visible */ |
50a14534 | 376 | renderer = gtk_cell_renderer_toggle_new (); |
3570ad57 | 377 | g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL); |
50a14534 | 378 | |
e747a56c | 379 | g_signal_connect (renderer, "toggled", G_CALLBACK (vik_treeview_toggled_cb), vt); |
50a14534 EB |
380 | |
381 | col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt), | |
3570ad57 | 382 | -1, "", |
50a14534 EB |
383 | renderer, |
384 | "active", | |
385 | VISIBLE_COLUMN, | |
50a14534 EB |
386 | NULL); |
387 | ||
388 | column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1); | |
50a14534 | 389 | gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), |
181f5d0c | 390 | GTK_TREE_VIEW_COLUMN_AUTOSIZE); |
50a14534 | 391 | |
f43968ee RN |
392 | |
393 | g_object_set (GTK_TREE_VIEW (vt), "has-tooltip", TRUE, NULL); | |
e747a56c | 394 | g_signal_connect (GTK_TREE_VIEW (vt), "query-tooltip", G_CALLBACK (vik_treeview_tooltip_cb), vt); |
50a14534 EB |
395 | } |
396 | ||
79845167 QT |
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 | ||
a5dcfdb7 RN |
405 | gpointer tmp_layer; |
406 | VikLayer *tmp_vl = NULL; | |
407 | gint tmp_subtype = 0; | |
408 | gint tmp_type = VIK_TREEVIEW_TYPE_LAYER; | |
409 | ||
79845167 QT |
410 | if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) return; |
411 | type = vik_treeview_item_get_type( vt, &iter); | |
412 | ||
a5dcfdb7 RN |
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 */ | |
79845167 QT |
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 | ||
8ece78c0 | 437 | vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vl)); |
79845167 | 438 | vik_window_selected_layer(vw, vl); |
a5dcfdb7 RN |
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 | ||
79845167 QT |
452 | } |
453 | ||
e747a56c | 454 | static gboolean vik_treeview_selection_filter(GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer data) |
e2ad36b5 QT |
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 | ||
e747a56c | 466 | void vik_treeview_init ( VikTreeview *vt ) |
50a14534 | 467 | { |
e2ad36b5 | 468 | vt->was_a_toggle = FALSE; |
ee4c7107 | 469 | vt->editing = FALSE; |
e2ad36b5 | 470 | |
b3c24ce7 RN |
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 | |
b5f3117b | 473 | // NB implicit conversion of time_t to gint64 |
03c97bc3 RN |
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 | |
50a14534 EB |
484 | |
485 | /* create tree view */ | |
e747a56c | 486 | gtk_tree_selection_set_select_function(gtk_tree_view_get_selection (GTK_TREE_VIEW(vt)), vik_treeview_selection_filter, vt, NULL); |
e2ad36b5 | 487 | |
50a14534 | 488 | gtk_tree_view_set_model ( GTK_TREE_VIEW(vt), vt->model ); |
e747a56c | 489 | vik_treeview_add_columns ( vt ); |
0a150ac4 RN |
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 | ||
50a14534 EB |
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 | ||
e4afc73a EB |
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); | |
e747a56c | 510 | isrc->drag_data_delete = vik_treeview_drag_data_delete; |
e4afc73a EB |
511 | |
512 | idest = g_type_interface_peek (g_type_class_peek(G_OBJECT_TYPE(vt->model)), GTK_TYPE_TREE_DRAG_DEST); | |
e747a56c | 513 | idest->drag_data_received = vik_treeview_drag_data_received; |
e4afc73a EB |
514 | } |
515 | ||
b5926b35 | 516 | VikLayerTypeEnum i; |
50a14534 EB |
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 | ||
e4afc73a | 520 | gtk_tree_view_set_reorderable (GTK_TREE_VIEW(vt), TRUE); |
79845167 QT |
521 | g_signal_connect(gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)), "changed", |
522 | G_CALLBACK(select_cb), vt); | |
e4afc73a | 523 | |
50a14534 EB |
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 | 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 | ||
bdd1c412 RN |
573 | /* Option to ensure visible */ |
574 | void vik_treeview_select_iter ( VikTreeview *vt, GtkTreeIter *iter, gboolean view_all ) | |
50a14534 | 575 | { |
bdd1c412 RN |
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 ); | |
7780e7ac | 592 | gtk_tree_path_free ( path ); |
bdd1c412 | 593 | } |
50a14534 EB |
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 | ||
ee4c7107 RN |
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 | ||
50a14534 EB |
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 | ||
deedc73c RN |
616 | void vik_treeview_item_set_icon ( VikTreeview *vt, GtkTreeIter *iter, const GdkPixbuf *icon ) |
617 | { | |
c947bfef | 618 | g_return_if_fail ( iter != NULL ); |
deedc73c RN |
619 | gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ICON_COLUMN, icon, -1); |
620 | } | |
621 | ||
50a14534 EB |
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 | ||
89fdc417 RN |
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 | ||
50a14534 EB |
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 | ||
440b7a86 RN |
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 | ||
c3a02429 | 661 | void vik_treeview_add_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gboolean above, |
03c97bc3 | 662 | gpointer item, gint data, VikLayerTypeEnum layer_type, time_t timestamp ) |
50a14534 EB |
663 | { |
664 | g_assert ( iter != NULL ); | |
c3a02429 RN |
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 ); | |
03c97bc3 RN |
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, | |
26ebb26f | 678 | ITEM_TIMESTAMP_COLUMN, (gint64)timestamp, |
03c97bc3 | 679 | -1 ); |
50a14534 EB |
680 | } |
681 | ||
c3a02429 | 682 | void vik_treeview_insert_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gboolean above, |
03c97bc3 | 683 | gpointer item, gint data, VikLayerTypeEnum layer_type, GtkTreeIter *sibling, time_t timestamp ) |
50a14534 EB |
684 | { |
685 | g_assert ( iter != NULL ); | |
e673b75f | 686 | if (sibling) { |
c3a02429 RN |
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 ); | |
e673b75f | 691 | } else { |
c3a02429 RN |
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 ); | |
e673b75f | 696 | } |
c3a02429 | 697 | |
03c97bc3 RN |
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, | |
26ebb26f | 707 | ITEM_TIMESTAMP_COLUMN, (gint64)timestamp, |
03c97bc3 | 708 | -1 ); |
50a14534 EB |
709 | } |
710 | ||
711 | void vik_treeview_add_sublayer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item, | |
03c97bc3 | 712 | gint data, GdkPixbuf *icon, gboolean editable, time_t timestamp ) |
50a14534 EB |
713 | { |
714 | g_assert ( iter != NULL ); | |
715 | ||
0a150ac4 | 716 | gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter ); |
03c97bc3 RN |
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, | |
26ebb26f | 726 | ITEM_TIMESTAMP_COLUMN, (gint64)timestamp, |
03c97bc3 | 727 | -1 ); |
50a14534 EB |
728 | } |
729 | ||
0a150ac4 RN |
730 | // Inspired by the internals of GtkTreeView sorting itself |
731 | typedef struct _SortTuple | |
732 | { | |
733 | gint offset; | |
734 | gchar *name; | |
26ebb26f | 735 | gint64 timestamp; |
0a150ac4 RN |
736 | } SortTuple; |
737 | ||
738 | /** | |
03c97bc3 | 739 | * |
0a150ac4 RN |
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 | ||
9a5507a0 | 746 | gint answer = -1; |
03c97bc3 RN |
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 ); | |
0a150ac4 | 751 | // Invert sort order for descending order |
03c97bc3 RN |
752 | if ( GPOINTER_TO_INT(order) == VL_SO_ALPHABETICAL_DESCENDING ) |
753 | answer = -answer; | |
754 | } | |
755 | else { | |
756 | // Date comparison | |
9a5507a0 RN |
757 | gboolean ans = ( sa->timestamp > sb->timestamp ); |
758 | if ( ans ) | |
759 | answer = 1; | |
03c97bc3 RN |
760 | // Invert sort order for descending order |
761 | if ( GPOINTER_TO_INT(order) == VL_SO_DATE_DESCENDING ) | |
9a5507a0 | 762 | answer = -answer; |
0a150ac4 | 763 | } |
0a150ac4 RN |
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 ); | |
03c97bc3 | 808 | gtk_tree_model_get ( model, &child, ITEM_TIMESTAMP_COLUMN, &(sort_array[ii].timestamp), -1 ); |
0a150ac4 RN |
809 | ii++; |
810 | } while ( gtk_tree_model_iter_next (model, &child) ); | |
811 | ||
0a150ac4 RN |
812 | // Sort list... |
813 | g_qsort_with_data (sort_array, | |
814 | length, | |
815 | sizeof (SortTuple), | |
816 | sort_tuple_compare, | |
03c97bc3 | 817 | GINT_TO_POINTER(order)); |
0a150ac4 RN |
818 | |
819 | // As the sorted list contains the reordered position offsets, extract this and then apply to the treeview | |
cd0b7e85 | 820 | gint *positions = g_malloc ( sizeof(gint) * length ); |
0a150ac4 RN |
821 | for ( ii = 0; ii < length; ii++ ) { |
822 | positions[ii] = sort_array[ii].offset; | |
66e15e9f | 823 | g_free ( sort_array[ii].name ); |
0a150ac4 RN |
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 | } | |
50a14534 | 831 | |
e747a56c | 832 | static void vik_treeview_finalize ( GObject *gob ) |
50a14534 EB |
833 | { |
834 | VikTreeview *vt = VIK_TREEVIEW ( gob ); | |
56468b2c | 835 | VikLayerTypeEnum i; |
50a14534 EB |
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 | } | |
e4afc73a | 842 | |
e747a56c | 843 | static gboolean vik_treeview_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data) |
e4afc73a EB |
844 | { |
845 | GtkTreeModel *tree_model; | |
e4afc73a EB |
846 | GtkTreeModel *src_model = NULL; |
847 | GtkTreePath *src_path = NULL, *dest_cp = NULL; | |
848 | gboolean retval = FALSE; | |
d99453eb | 849 | GtkTreeIter src_iter, root_iter, dest_parent; |
e4afc73a EB |
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); | |
e4afc73a EB |
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 | */ | |
c390aa71 AF |
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 | ||
e4afc73a EB |
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 | ||
e4afc73a | 885 | |
70a23263 AF |
886 | if (gtk_tree_path_get_depth(dest_cp)>1) { /* can't be sibling of top layer */ |
887 | VikLayer *vl_src, *vl_dest; | |
e4afc73a | 888 | |
d99453eb | 889 | /* Find the first ancestor that is a full layer, and store in dest_parent. */ |
70a23263 | 890 | do { |
e4afc73a | 891 | gtk_tree_path_up(dest_cp); |
70a23263 AF |
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 | g_assert ( vik_treeview_item_get_parent(vt, &src_iter) ); | |
898 | vl_src = vik_treeview_item_get_parent(vt, &src_iter); | |
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) { | |
c390aa71 | 903 | // g_print("moving an item from layer '%s' into layer '%s'\n", vl_src->name, vl_dest->name); |
70a23263 AF |
904 | vik_layer_get_interface(vl_dest->type)->drag_drop_request(vl_src, vl_dest, &src_iter, dest); |
905 | } | |
e4afc73a EB |
906 | } |
907 | } | |
e4afc73a | 908 | |
70a23263 | 909 | out: |
e4afc73a EB |
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 | */ | |
e747a56c | 921 | static gboolean vik_treeview_drag_data_delete ( GtkTreeDragSource *drag_source, GtkTreePath *path ) |
e4afc73a EB |
922 | { |
923 | gchar *s_dest = gtk_tree_path_to_string(path); | |
4c77d5e0 | 924 | g_print(_("delete data from %s\n"), s_dest); |
e4afc73a EB |
925 | g_free(s_dest); |
926 | return FALSE; | |
927 | } |