src/viktreeview.c

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