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