]>
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 | ||
3570ad57 QT |
34 | #define VT_COL_WIDTH_NAME 160 |
35 | #define VT_COL_WIDTH_TYPE 20 | |
36 | #define VT_COL_WIDTH_VISIBLE 20 | |
37 | ||
50a14534 EB |
38 | #define TREEVIEW_GET(model,iter,what,dest) gtk_tree_model_get(GTK_TREE_MODEL(model),(iter),(what),(dest),-1) |
39 | ||
40 | enum { | |
41 | VT_ITEM_EDITED_SIGNAL, | |
42 | VT_ITEM_TOGGLED_SIGNAL, | |
43 | VT_LAST_SIGNAL | |
44 | }; | |
45 | ||
46 | static guint treeview_signals[VT_LAST_SIGNAL] = { 0, 0 }; | |
47 | ||
48 | static GObjectClass *parent_class; | |
49 | ||
50 | enum | |
51 | { | |
52 | NAME_COLUMN = 0, | |
53 | VISIBLE_COLUMN, | |
54 | ICON_COLUMN, | |
55 | /* invisible */ | |
56 | ||
57 | TYPE_COLUMN, | |
58 | ITEM_PARENT_COLUMN, | |
59 | ITEM_POINTER_COLUMN, | |
60 | ITEM_DATA_COLUMN, | |
61 | HAS_VISIBLE_COLUMN, | |
62 | EDITABLE_COLUMN, | |
63 | /* properties dialog, delete, rename, etc. */ | |
64 | NUM_COLUMNS | |
65 | }; | |
66 | ||
67 | struct _VikTreeview { | |
68 | GtkTreeView treeview; | |
69 | GtkTreeModel *model; | |
70 | ||
71 | GdkPixbuf *layer_type_icons[VIK_LAYER_NUM_TYPES]; | |
72 | }; | |
73 | ||
74 | /* TODO: find, make "static" and put up here all non-"a_" functions */ | |
75 | static void treeview_class_init ( VikTreeviewClass *klass ); | |
76 | static void treeview_init ( VikTreeview *vt ); | |
77 | static void treeview_finalize ( GObject *gob ); | |
78 | static void treeview_add_columns ( VikTreeview *vt ); | |
79 | ||
70a23263 AF |
80 | static gboolean treeview_drag_data_received ( GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data ); |
81 | static gboolean treeview_drag_data_delete ( GtkTreeDragSource *drag_source, GtkTreePath *path ); | |
e4afc73a | 82 | |
50a14534 EB |
83 | GType vik_treeview_get_type (void) |
84 | { | |
85 | static GType vt_type = 0; | |
86 | ||
87 | if (!vt_type) | |
88 | { | |
89 | static const GTypeInfo vt_info = | |
90 | { | |
91 | sizeof (VikTreeviewClass), | |
92 | NULL, /* base_init */ | |
93 | NULL, /* base_finalize */ | |
94 | (GClassInitFunc) treeview_class_init, | |
95 | NULL, /* class_finalize */ | |
96 | NULL, /* class_data */ | |
97 | sizeof (VikTreeview), | |
98 | 0, | |
99 | (GInstanceInitFunc) treeview_init, | |
100 | }; | |
101 | vt_type = g_type_register_static ( GTK_TYPE_TREE_VIEW, "VikTreeview", &vt_info, 0 ); | |
102 | } | |
103 | ||
104 | return vt_type; | |
105 | } | |
106 | ||
107 | static void treeview_class_init ( VikTreeviewClass *klass ) | |
108 | { | |
109 | /* Destructor */ | |
110 | GObjectClass *object_class; | |
111 | ||
112 | object_class = G_OBJECT_CLASS (klass); | |
113 | ||
114 | object_class->finalize = treeview_finalize; | |
115 | ||
116 | parent_class = g_type_class_peek_parent (klass); | |
117 | ||
118 | 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, | |
752f500c | 119 | gtk_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2, GTK_TYPE_POINTER, G_TYPE_POINTER); |
50a14534 EB |
120 | /* VOID__UINT_POINTER: kinda hack-ish, but it works. */ |
121 | ||
122 | 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, | |
752f500c | 123 | g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, GTK_TYPE_POINTER ); |
50a14534 EB |
124 | } |
125 | ||
126 | static void treeview_edited_cb (GtkCellRendererText *cell, gchar *path_str, const gchar *new_name, VikTreeview *vt) | |
127 | { | |
128 | GtkTreeIter iter; | |
129 | ||
130 | /* get type and data */ | |
131 | vik_treeview_get_iter_from_path_str ( vt, &iter, path_str ); | |
132 | ||
752f500c | 133 | g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_EDITED_SIGNAL], 0, &iter, new_name ); |
50a14534 EB |
134 | } |
135 | ||
136 | static void treeview_toggled_cb (GtkCellRendererToggle *cell, gchar *path_str, VikTreeview *vt) | |
137 | { | |
138 | GtkTreeIter iter; | |
139 | ||
140 | /* get type and data */ | |
141 | vik_treeview_get_iter_from_path_str ( vt, &iter, path_str ); | |
142 | ||
143 | g_signal_emit ( G_OBJECT(vt), | |
144 | treeview_signals[VT_ITEM_TOGGLED_SIGNAL], 0, &iter ); | |
145 | } | |
146 | ||
147 | VikTreeview *vik_treeview_new () | |
148 | { | |
149 | return VIK_TREEVIEW ( g_object_new ( VIK_TREEVIEW_TYPE, NULL ) ); | |
150 | } | |
151 | ||
152 | gint vik_treeview_item_get_type ( VikTreeview *vt, GtkTreeIter *iter ) | |
153 | { | |
154 | gint rv; | |
155 | TREEVIEW_GET ( vt->model, iter, TYPE_COLUMN, &rv ); | |
156 | return rv; | |
157 | } | |
158 | ||
159 | gint vik_treeview_item_get_data ( VikTreeview *vt, GtkTreeIter *iter ) | |
160 | { | |
161 | gint rv; | |
162 | TREEVIEW_GET ( vt->model, iter, ITEM_DATA_COLUMN, &rv ); | |
163 | return rv; | |
164 | } | |
165 | ||
166 | gpointer vik_treeview_item_get_pointer ( VikTreeview *vt, GtkTreeIter *iter ) | |
167 | { | |
168 | gpointer rv; | |
169 | TREEVIEW_GET ( vt->model, iter, ITEM_POINTER_COLUMN, &rv ); | |
170 | return rv; | |
171 | } | |
172 | ||
173 | void vik_treeview_item_set_pointer ( VikTreeview *vt, GtkTreeIter *iter, gpointer pointer ) | |
174 | { | |
175 | gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_POINTER_COLUMN, pointer, -1 ); | |
176 | } | |
177 | ||
178 | gpointer vik_treeview_item_get_parent ( VikTreeview *vt, GtkTreeIter *iter ) | |
179 | { | |
180 | gpointer rv; | |
181 | TREEVIEW_GET ( vt->model, iter, ITEM_PARENT_COLUMN, &rv ); | |
182 | return rv; | |
183 | } | |
184 | ||
e673b75f | 185 | gboolean vik_treeview_get_iter_from_path_str ( VikTreeview *vt, GtkTreeIter *iter, const gchar *path_str ) |
50a14534 | 186 | { |
e673b75f | 187 | return gtk_tree_model_get_iter_from_string ( GTK_TREE_MODEL(vt->model), iter, path_str ); |
50a14534 EB |
188 | } |
189 | ||
190 | static void treeview_add_columns ( VikTreeview *vt ) | |
191 | { | |
192 | gint col_offset; | |
193 | GtkCellRenderer *renderer; | |
194 | GtkTreeViewColumn *column; | |
195 | ||
196 | renderer = gtk_cell_renderer_text_new (); | |
197 | g_signal_connect (renderer, "edited", | |
198 | G_CALLBACK (treeview_edited_cb), vt); | |
199 | ||
200 | g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL); | |
201 | ||
202 | col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt), | |
4c77d5e0 | 203 | -1, _("Layer Name"), |
50a14534 EB |
204 | renderer, "text", |
205 | NAME_COLUMN, | |
206 | "editable", EDITABLE_COLUMN, | |
207 | NULL); | |
208 | ||
209 | column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1); | |
210 | gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), | |
211 | GTK_TREE_VIEW_COLUMN_FIXED); | |
3570ad57 QT |
212 | gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), |
213 | VT_COL_WIDTH_NAME); | |
50a14534 EB |
214 | gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); |
215 | gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), TRUE); | |
216 | ||
217 | renderer = gtk_cell_renderer_pixbuf_new (); | |
218 | ||
3570ad57 | 219 | g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL); |
50a14534 EB |
220 | |
221 | col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt), | |
3570ad57 | 222 | -1, "", |
50a14534 EB |
223 | renderer, "pixbuf", |
224 | ICON_COLUMN, | |
225 | NULL); | |
226 | ||
227 | ||
228 | column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1); | |
3570ad57 QT |
229 | gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), |
230 | VT_COL_WIDTH_TYPE); | |
50a14534 EB |
231 | gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), |
232 | GTK_TREE_VIEW_COLUMN_FIXED); | |
233 | gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); | |
234 | ||
235 | ||
236 | renderer = gtk_cell_renderer_toggle_new (); | |
3570ad57 | 237 | g_object_set (G_OBJECT (renderer), "xalign", 0.5, NULL); |
50a14534 EB |
238 | |
239 | g_signal_connect (renderer, "toggled", G_CALLBACK (treeview_toggled_cb), vt); | |
240 | ||
241 | col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt), | |
3570ad57 | 242 | -1, "", |
50a14534 EB |
243 | renderer, |
244 | "active", | |
245 | VISIBLE_COLUMN, | |
246 | "visible", | |
247 | HAS_VISIBLE_COLUMN, | |
248 | "activatable", | |
249 | HAS_VISIBLE_COLUMN, | |
250 | NULL); | |
251 | ||
252 | column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1); | |
3570ad57 QT |
253 | gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), |
254 | VT_COL_WIDTH_VISIBLE); | |
50a14534 EB |
255 | gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), |
256 | GTK_TREE_VIEW_COLUMN_FIXED); | |
257 | gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); | |
258 | ||
259 | } | |
260 | ||
79845167 QT |
261 | static void select_cb(GtkTreeSelection *selection, gpointer data) |
262 | { | |
263 | VikTreeview *vt = data; | |
264 | gint type; | |
265 | GtkTreeIter iter, parent; | |
266 | VikLayer *vl; | |
267 | VikWindow * vw; | |
268 | ||
269 | if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) return; | |
270 | type = vik_treeview_item_get_type( vt, &iter); | |
271 | ||
272 | while ( type != VIK_TREEVIEW_TYPE_LAYER ) { | |
273 | if ( ! vik_treeview_item_get_parent_iter ( vt, &iter, &parent ) ) | |
274 | return; | |
275 | iter = parent; | |
276 | type = vik_treeview_item_get_type (vt, &iter ); | |
277 | } | |
278 | ||
279 | vl = VIK_LAYER( vik_treeview_item_get_pointer ( vt, &iter ) ); | |
280 | ||
8ece78c0 | 281 | vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vl)); |
79845167 QT |
282 | vik_window_selected_layer(vw, vl); |
283 | } | |
284 | ||
50a14534 EB |
285 | void treeview_init ( VikTreeview *vt ) |
286 | { | |
287 | guint16 i; | |
288 | ||
289 | 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 )); | |
290 | ||
291 | /* create tree view */ | |
292 | gtk_tree_view_set_model ( GTK_TREE_VIEW(vt), vt->model ); | |
293 | treeview_add_columns ( vt ); | |
294 | g_object_unref (vt->model); | |
295 | ||
296 | gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (vt), TRUE); | |
297 | gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)), | |
298 | GTK_SELECTION_SINGLE); | |
299 | ||
e4afc73a EB |
300 | /* Override treestore's dnd methods only; this is easier than deriving from GtkTreeStore. |
301 | * The downside is that all treestores will have this behavior, so this needs to be | |
302 | * changed if we add more treeviews in the future. //Alex | |
303 | */ | |
304 | if (1) { | |
305 | GtkTreeDragSourceIface *isrc; | |
306 | GtkTreeDragDestIface *idest; | |
307 | ||
308 | isrc = g_type_interface_peek (g_type_class_peek(G_OBJECT_TYPE(vt->model)), GTK_TYPE_TREE_DRAG_SOURCE); | |
70a23263 | 309 | isrc->drag_data_delete = treeview_drag_data_delete; |
e4afc73a EB |
310 | |
311 | idest = g_type_interface_peek (g_type_class_peek(G_OBJECT_TYPE(vt->model)), GTK_TYPE_TREE_DRAG_DEST); | |
70a23263 | 312 | idest->drag_data_received = treeview_drag_data_received; |
e4afc73a EB |
313 | } |
314 | ||
50a14534 EB |
315 | for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ ) |
316 | 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. */ | |
317 | ||
e4afc73a | 318 | gtk_tree_view_set_reorderable (GTK_TREE_VIEW(vt), TRUE); |
79845167 QT |
319 | g_signal_connect(gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)), "changed", |
320 | G_CALLBACK(select_cb), vt); | |
e4afc73a | 321 | |
50a14534 EB |
322 | } |
323 | ||
324 | gboolean vik_treeview_item_get_parent_iter ( VikTreeview *vt, GtkTreeIter *iter, GtkTreeIter *parent ) | |
325 | { | |
326 | return gtk_tree_model_iter_parent ( GTK_TREE_MODEL(vt->model), parent, iter ); | |
327 | } | |
328 | ||
329 | gboolean vik_treeview_move_item ( VikTreeview *vt, GtkTreeIter *iter, gboolean up ) | |
330 | { | |
331 | gint t = vik_treeview_item_get_type ( vt, iter ); | |
332 | if ( t == VIK_TREEVIEW_TYPE_LAYER ) | |
333 | { | |
334 | GtkTreeIter switch_iter; | |
335 | if (up) | |
336 | { | |
337 | /* iter to path to iter */ | |
338 | GtkTreePath *path = gtk_tree_model_get_path ( vt->model, iter ); | |
339 | if ( !gtk_tree_path_prev ( path ) || !gtk_tree_model_get_iter ( vt->model, &switch_iter, path ) ) | |
340 | { | |
341 | gtk_tree_path_free ( path ); | |
342 | return FALSE; | |
343 | } | |
344 | gtk_tree_path_free ( path ); | |
345 | } | |
346 | else | |
347 | { | |
348 | switch_iter = *iter; | |
349 | if ( !gtk_tree_model_iter_next ( vt->model, &switch_iter ) ) | |
350 | return FALSE; | |
351 | } | |
352 | gtk_tree_store_swap ( GTK_TREE_STORE(vt->model), iter, &switch_iter ); | |
353 | return TRUE; | |
354 | /* now, the easy part. actually switching them, not the GUI */ | |
355 | } /* if item is map */ | |
356 | return FALSE; | |
357 | } | |
358 | ||
359 | gboolean vik_treeview_get_iter_at_pos ( VikTreeview *vt, GtkTreeIter *iter, gint x, gint y ) | |
360 | { | |
361 | GtkTreePath *path; | |
362 | gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(vt), x, y, &path, NULL, NULL, NULL ); | |
363 | if ( ! path ) | |
364 | return FALSE; | |
365 | ||
366 | gtk_tree_model_get_iter (GTK_TREE_MODEL(vt->model), iter, path); | |
367 | gtk_tree_path_free ( path ); | |
368 | return TRUE; | |
369 | } | |
370 | ||
371 | void vik_treeview_select_iter ( VikTreeview *vt, GtkTreeIter *iter ) | |
372 | { | |
373 | gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter ); | |
374 | } | |
375 | ||
376 | gboolean vik_treeview_get_selected_iter ( VikTreeview *vt, GtkTreeIter *iter ) | |
377 | { | |
378 | return gtk_tree_selection_get_selected ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), NULL, iter ); | |
379 | } | |
380 | ||
381 | void vik_treeview_item_delete ( VikTreeview *vt, GtkTreeIter *iter ) | |
382 | { | |
383 | gtk_tree_store_remove ( GTK_TREE_STORE(vt->model), iter ); | |
384 | } | |
385 | ||
386 | /* Treeview Reform Project */ | |
387 | ||
388 | void vik_treeview_item_set_name ( VikTreeview *vt, GtkTreeIter *iter, const gchar *to ) | |
389 | { | |
390 | g_return_if_fail ( iter != NULL && to != NULL ); | |
391 | gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, to, -1); | |
392 | } | |
393 | ||
394 | void vik_treeview_item_set_visible ( VikTreeview *vt, GtkTreeIter *iter, gboolean to ) | |
395 | { | |
396 | g_return_if_fail ( iter != NULL ); | |
397 | gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 ); | |
398 | } | |
399 | ||
400 | void vik_treeview_expand ( VikTreeview *vt, GtkTreeIter *iter ) | |
401 | { | |
402 | GtkTreePath *path; | |
403 | path = gtk_tree_model_get_path ( vt->model, iter ); | |
404 | gtk_tree_view_expand_row ( GTK_TREE_VIEW(vt), path, FALSE ); | |
405 | gtk_tree_path_free ( path ); | |
406 | } | |
407 | ||
408 | void vik_treeview_item_select ( VikTreeview *vt, GtkTreeIter *iter ) | |
409 | { | |
410 | gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter ); | |
411 | } | |
412 | ||
413 | void vik_treeview_add_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, | |
414 | gpointer item, gint data, gint icon_type ) | |
415 | { | |
416 | g_assert ( iter != NULL ); | |
417 | g_assert ( icon_type < VIK_LAYER_NUM_TYPES ); | |
418 | gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter ); | |
419 | gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, | |
420 | TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, | |
421 | ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE, | |
422 | ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 ); | |
423 | } | |
424 | ||
425 | void vik_treeview_insert_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, | |
426 | gpointer item, gint data, gint icon_type, GtkTreeIter *sibling ) | |
427 | { | |
428 | g_assert ( iter != NULL ); | |
429 | g_assert ( icon_type < VIK_LAYER_NUM_TYPES ); | |
e673b75f AF |
430 | if (sibling) { |
431 | gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling ); | |
432 | } else { | |
433 | gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter ); | |
434 | } | |
435 | ||
50a14534 EB |
436 | gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE, |
437 | TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item, | |
438 | ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE, | |
439 | ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 ); | |
440 | } | |
441 | ||
442 | void vik_treeview_add_sublayer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item, | |
443 | gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable ) | |
444 | { | |
445 | g_assert ( iter != NULL ); | |
446 | ||
447 | gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter ); | |
448 | 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 ); | |
449 | } | |
450 | ||
451 | ||
452 | #ifdef VIK_CONFIG_ALPHABETIZED_TRW | |
453 | ||
454 | void vik_treeview_sublayer_realphabetize ( VikTreeview *vt, GtkTreeIter *iter, const gchar *newname ) | |
455 | { | |
456 | GtkTreeIter search_iter, parent_iter; | |
457 | gchar *search_name; | |
458 | g_assert ( iter != NULL ); | |
459 | ||
460 | gtk_tree_model_iter_parent ( vt->model, &parent_iter, iter ); | |
461 | ||
462 | g_assert ( gtk_tree_model_iter_children ( vt->model, &search_iter, &parent_iter ) ); | |
463 | ||
464 | do { | |
465 | gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 ); | |
466 | if ( strcmp ( search_name, newname ) > 0 ) /* not >= or would trip on itself */ | |
467 | { | |
468 | gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, &search_iter ); | |
469 | return; | |
470 | } | |
471 | } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) ); | |
472 | ||
473 | gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, NULL ); | |
474 | } | |
475 | ||
476 | void vik_treeview_add_sublayer_alphabetized | |
477 | ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item, | |
478 | gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable ) | |
479 | { | |
480 | GtkTreeIter search_iter; | |
481 | gchar *search_name; | |
482 | g_assert ( iter != NULL ); | |
483 | ||
484 | if ( gtk_tree_model_iter_children ( vt->model, &search_iter, parent_iter ) ) | |
485 | { | |
486 | gboolean found_greater_string = FALSE; | |
487 | do { | |
488 | gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 ); | |
489 | if ( strcmp ( search_name, name ) >= 0 ) | |
490 | { | |
491 | gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, &search_iter ); | |
492 | found_greater_string = TRUE; | |
493 | break; | |
494 | } | |
495 | } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) ); | |
496 | ||
497 | if ( ! found_greater_string ) | |
498 | gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter ); | |
499 | } | |
500 | else | |
501 | gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter ); | |
502 | ||
503 | 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 ); | |
504 | } | |
505 | ||
506 | #endif | |
507 | ||
508 | static void treeview_finalize ( GObject *gob ) | |
509 | { | |
510 | VikTreeview *vt = VIK_TREEVIEW ( gob ); | |
511 | guint16 i; | |
512 | ||
513 | for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ ) | |
514 | if ( vt->layer_type_icons[i] != NULL ) | |
515 | g_object_unref ( G_OBJECT(vt->layer_type_icons[i]) ); | |
516 | ||
517 | G_OBJECT_CLASS(parent_class)->finalize(gob); | |
518 | } | |
e4afc73a | 519 | |
70a23263 | 520 | static gboolean treeview_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data) |
e4afc73a EB |
521 | { |
522 | GtkTreeModel *tree_model; | |
523 | GtkTreeStore *tree_store; | |
524 | GtkTreeModel *src_model = NULL; | |
525 | GtkTreePath *src_path = NULL, *dest_cp = NULL; | |
526 | gboolean retval = FALSE; | |
70a23263 | 527 | GtkTreeIter src_iter, root_iter, dest_iter, dest_parent; |
e0b0b9c1 | 528 | gint *i_src = NULL; |
e4afc73a EB |
529 | VikTreeview *vt; |
530 | VikLayer *vl; | |
531 | ||
532 | g_return_val_if_fail (GTK_IS_TREE_STORE (drag_dest), FALSE); | |
533 | ||
534 | tree_model = GTK_TREE_MODEL (drag_dest); | |
535 | tree_store = GTK_TREE_STORE (drag_dest); | |
536 | ||
537 | if (gtk_tree_get_row_drag_data (selection_data, &src_model, &src_path) && src_model == tree_model) { | |
538 | /* | |
539 | * Copy src_path to dest. There are two subcases here, depending on what | |
540 | * is being dragged. | |
541 | * | |
542 | * 1. src_path is a layer. In this case, interpret the drop | |
543 | * as a request to move the layer to a different aggregate layer. | |
544 | * If the destination is not an aggregate layer, use the first | |
545 | * ancestor that is. | |
546 | * | |
547 | * 2. src_path is a sublayer. In this case, find ancestors of | |
548 | * both source and destination nodes who are full layers, | |
549 | * and call the move method of that layer type. | |
550 | * | |
551 | */ | |
c390aa71 AF |
552 | if (!gtk_tree_model_get_iter (src_model, &src_iter, src_path)) { |
553 | goto out; | |
554 | } | |
555 | if (!gtk_tree_path_compare(src_path, dest)) { | |
556 | goto out; | |
557 | } | |
558 | ||
e4afc73a EB |
559 | i_src = gtk_tree_path_get_indices (src_path); |
560 | dest_cp = gtk_tree_path_copy (dest); | |
561 | ||
562 | gtk_tree_model_get_iter_first(tree_model, &root_iter); | |
563 | TREEVIEW_GET(tree_model, &root_iter, ITEM_POINTER_COLUMN, &vl); | |
564 | vt = vl->vt; | |
565 | ||
e4afc73a | 566 | |
70a23263 AF |
567 | if (gtk_tree_path_get_depth(dest_cp)>1) { /* can't be sibling of top layer */ |
568 | VikLayer *vl_src, *vl_dest; | |
e4afc73a | 569 | |
70a23263 AF |
570 | /* Find the first ancestor that is a full layer, and store in dest_parent. |
571 | * In addition, put in dest_iter where Gtk wants us to insert the dragged object. | |
572 | * (Note that this may end up being an invalid iter). | |
573 | */ | |
574 | do { | |
e4afc73a | 575 | gtk_tree_path_up(dest_cp); |
70a23263 AF |
576 | dest_iter = dest_parent; |
577 | gtk_tree_model_get_iter (src_model, &dest_parent, dest_cp); | |
578 | } while (gtk_tree_path_get_depth(dest_cp)>1 && | |
579 | vik_treeview_item_get_type(vt, &dest_parent) != VIK_TREEVIEW_TYPE_LAYER); | |
580 | ||
581 | ||
582 | g_assert ( vik_treeview_item_get_parent(vt, &src_iter) ); | |
583 | vl_src = vik_treeview_item_get_parent(vt, &src_iter); | |
584 | vl_dest = vik_treeview_item_get_pointer(vt, &dest_parent); | |
585 | ||
586 | /* TODO: might want to allow different types, and let the clients handle how they want */ | |
587 | if (vl_src->type == vl_dest->type && vik_layer_get_interface(vl_dest->type)->drag_drop_request) { | |
c390aa71 | 588 | // g_print("moving an item from layer '%s' into layer '%s'\n", vl_src->name, vl_dest->name); |
70a23263 AF |
589 | vik_layer_get_interface(vl_dest->type)->drag_drop_request(vl_src, vl_dest, &src_iter, dest); |
590 | } | |
e4afc73a EB |
591 | } |
592 | } | |
e4afc73a | 593 | |
70a23263 | 594 | out: |
e4afc73a EB |
595 | if (dest_cp) |
596 | gtk_tree_path_free(dest_cp); | |
597 | if (src_path) | |
598 | gtk_tree_path_free (src_path); | |
599 | ||
600 | return retval; | |
601 | } | |
602 | ||
603 | /* | |
604 | * This may not be necessary. | |
605 | */ | |
70a23263 | 606 | static gboolean treeview_drag_data_delete ( GtkTreeDragSource *drag_source, GtkTreePath *path ) |
e4afc73a EB |
607 | { |
608 | gchar *s_dest = gtk_tree_path_to_string(path); | |
4c77d5e0 | 609 | g_print(_("delete data from %s\n"), s_dest); |
e4afc73a EB |
610 | g_free(s_dest); |
611 | return FALSE; | |
612 | } | |
613 |