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 #include <gtk/gtk.h>
  23 #include <string.h>
  24
  25 #include "viking.h"
  26
  27 #include "config.h"
  28
  29 #define TREEVIEW_GET(model,iter,what,dest) gtk_tree_model_get(GTK_TREE_MODEL(model),(iter),(what),(dest),-1)
  30
  31 enum {
  32   VT_ITEM_EDITED_SIGNAL,
  33   VT_ITEM_TOGGLED_SIGNAL,
  34   VT_LAST_SIGNAL
  35 };
  36
  37 static guint treeview_signals[VT_LAST_SIGNAL] = { 0, 0 };
  38
  39 static GObjectClass *parent_class;
  40
  41 enum
  42 {
  43   NAME_COLUMN = 0,
  44   VISIBLE_COLUMN,
  45   ICON_COLUMN,
  46   /* invisible */
  47
  48   TYPE_COLUMN,
  49   ITEM_PARENT_COLUMN,
  50   ITEM_POINTER_COLUMN,
  51   ITEM_DATA_COLUMN,
  52   HAS_VISIBLE_COLUMN,
  53   EDITABLE_COLUMN,
  54   /* properties dialog, delete, rename, etc. */
  55   NUM_COLUMNS
  56 };
  57
  58 struct _VikTreeview {
  59   GtkTreeView treeview;
  60   GtkTreeModel *model;
  61
  62   GdkPixbuf *layer_type_icons[VIK_LAYER_NUM_TYPES];
  63 };
  64
  65 /* TODO: find, make "static" and put up here all non-"a_" functions */
  66 static void treeview_class_init ( VikTreeviewClass *klass );
  67 static void treeview_init ( VikTreeview *vt );
  68 static void treeview_finalize ( GObject *gob );
  69 static void treeview_add_columns ( VikTreeview *vt );
  70
  71 GType vik_treeview_get_type (void)
  72 {
  73   static GType vt_type = 0;
  74
  75   if (!vt_type)
  76   {
  77     static const GTypeInfo vt_info =
  78     {
  79       sizeof (VikTreeviewClass),
  80       NULL, /* base_init */
  81       NULL, /* base_finalize */
  82       (GClassInitFunc) treeview_class_init,
  83       NULL, /* class_finalize */
  84       NULL, /* class_data */
  85       sizeof (VikTreeview),
  86       0,
  87       (GInstanceInitFunc) treeview_init,
  88     };
  89     vt_type = g_type_register_static ( GTK_TYPE_TREE_VIEW, "VikTreeview", &vt_info, 0 );
  90   }
  91
  92   return vt_type;
  93 }
  94
  95 static void treeview_class_init ( VikTreeviewClass *klass )
  96 {
  97   /* Destructor */
  98   GObjectClass *object_class;
  99
 100   object_class = G_OBJECT_CLASS (klass);
 101
 102   object_class->finalize =  treeview_finalize;
 103
 104   parent_class = g_type_class_peek_parent (klass);
 105
 106   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,
 107     g_cclosure_marshal_VOID__UINT_POINTER, G_TYPE_NONE, 2, GTK_TYPE_TREE_ITER, G_TYPE_STRING);
 108   /* VOID__UINT_POINTER: kinda hack-ish, but it works. */
 109
 110   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,
 111     g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, GTK_TYPE_TREE_ITER );
 112 }
 113
 114 static void treeview_edited_cb (GtkCellRendererText *cell, gchar *path_str, const gchar *new_name, VikTreeview *vt)
 115 {
 116   GtkTreeIter iter;
 117
 118   /* get type and data */
 119   vik_treeview_get_iter_from_path_str ( vt, &iter, path_str );
 120
 121   g_signal_emit ( G_OBJECT(vt), treeview_signals[VT_ITEM_EDITED_SIGNAL], 0, &iter, new_name, 0 );
 122 }
 123
 124 static void treeview_toggled_cb (GtkCellRendererToggle *cell, gchar *path_str, 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),
 132 treeview_signals[VT_ITEM_TOGGLED_SIGNAL], 0, &iter );
 133 }
 134
 135 VikTreeview *vik_treeview_new ()
 136 {
 137   return VIK_TREEVIEW ( g_object_new ( VIK_TREEVIEW_TYPE, NULL ) );
 138 }
 139
 140 gint vik_treeview_item_get_type ( VikTreeview *vt, GtkTreeIter *iter )
 141 {
 142   gint rv;
 143   TREEVIEW_GET ( vt->model, iter, TYPE_COLUMN, &rv );
 144   return rv;
 145 }
 146
 147 gint vik_treeview_item_get_data ( VikTreeview *vt, GtkTreeIter *iter )
 148 {
 149   gint rv;
 150   TREEVIEW_GET ( vt->model, iter, ITEM_DATA_COLUMN, &rv );
 151   return rv;
 152 }
 153
 154 gpointer vik_treeview_item_get_pointer ( VikTreeview *vt, GtkTreeIter *iter )
 155 {
 156   gpointer rv;
 157   TREEVIEW_GET ( vt->model, iter, ITEM_POINTER_COLUMN, &rv );
 158   return rv;
 159 }
 160
 161 void vik_treeview_item_set_pointer ( VikTreeview *vt, GtkTreeIter *iter, gpointer pointer )
 162 {
 163   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, ITEM_POINTER_COLUMN, pointer, -1 );
 164 }
 165
 166 gpointer vik_treeview_item_get_parent ( VikTreeview *vt, GtkTreeIter *iter )
 167 {
 168   gpointer rv;
 169   TREEVIEW_GET ( vt->model, iter, ITEM_PARENT_COLUMN, &rv );
 170   return rv;
 171 }
 172
 173 void vik_treeview_get_iter_from_path_str ( VikTreeview *vt, GtkTreeIter *iter, const gchar *path_str )
 174 {
 175   gtk_tree_model_get_iter_from_string ( GTK_TREE_MODEL(vt->model), iter, path_str );
 176 }
 177
 178 static void treeview_add_columns ( VikTreeview *vt )
 179 {
 180   gint col_offset;
 181   GtkCellRenderer *renderer;
 182   GtkTreeViewColumn *column;
 183
 184   renderer = gtk_cell_renderer_text_new ();
 185   g_signal_connect (renderer, "edited",
 186                     G_CALLBACK (treeview_edited_cb), vt);
 187
 188   g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
 189
 190   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 191                                                             -1, "Layer Name",
 192                                                             renderer, "text",
 193                                                             NAME_COLUMN,
 194                                                             "editable", EDITABLE_COLUMN,
 195                                                             NULL);
 196
 197   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 198   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 199                                    GTK_TREE_VIEW_COLUMN_FIXED);
 200   gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 100);
 201   gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 202   gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 203
 204   renderer = gtk_cell_renderer_pixbuf_new ();
 205
 206   g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
 207
 208   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 209                                                             -1, "Type",
 210                                                             renderer, "pixbuf",
 211                                                             ICON_COLUMN,
 212                                                             NULL);
 213
 214
 215   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 216   gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 33);
 217   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 218                                    GTK_TREE_VIEW_COLUMN_FIXED);
 219   gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 220
 221
 222   renderer = gtk_cell_renderer_toggle_new ();
 223   g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
 224
 225   g_signal_connect (renderer, "toggled", G_CALLBACK (treeview_toggled_cb), vt);
 226
 227   col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (vt),
 228                                                             -1, "Visible",
 229                                                             renderer,
 230                                                             "active",
 231                                                             VISIBLE_COLUMN,
 232                                                             "visible",
 233                                                             HAS_VISIBLE_COLUMN,
 234                                                             "activatable",
 235                                                             HAS_VISIBLE_COLUMN,
 236                                                             NULL);
 237
 238   column = gtk_tree_view_get_column (GTK_TREE_VIEW (vt), col_offset - 1);
 239   gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 40);
 240   gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
 241                                    GTK_TREE_VIEW_COLUMN_FIXED);
 242   gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 243
 244 }
 245
 246 void treeview_init ( VikTreeview *vt )
 247 {
 248   guint16 i;
 249
 250   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 ));
 251
 252   /* create tree view */
 253   gtk_tree_view_set_model ( GTK_TREE_VIEW(vt), vt->model );
 254   treeview_add_columns ( vt );
 255   g_object_unref (vt->model);
 256
 257   gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (vt), TRUE);
 258   gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (vt)),
 259                                GTK_SELECTION_SINGLE);
 260
 261   for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
 262     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. */
 263
 264 }
 265
 266 gboolean vik_treeview_item_get_parent_iter ( VikTreeview *vt, GtkTreeIter *iter,  GtkTreeIter *parent )
 267 {
 268   return gtk_tree_model_iter_parent ( GTK_TREE_MODEL(vt->model), parent, iter );
 269 }
 270
 271 gboolean vik_treeview_move_item ( VikTreeview *vt, GtkTreeIter *iter, gboolean up )
 272 {
 273   gint t = vik_treeview_item_get_type ( vt, iter );
 274   if ( t == VIK_TREEVIEW_TYPE_LAYER )
 275   {
 276     GtkTreeIter switch_iter;
 277     if (up)
 278     {
 279       /* iter to path to iter */
 280       GtkTreePath *path = gtk_tree_model_get_path ( vt->model, iter );
 281       if ( !gtk_tree_path_prev ( path ) || !gtk_tree_model_get_iter ( vt->model, &switch_iter, path ) )
 282       {
 283         gtk_tree_path_free ( path );
 284         return FALSE;
 285       }
 286       gtk_tree_path_free ( path );
 287     }
 288     else
 289     {
 290       switch_iter = *iter;
 291       if ( !gtk_tree_model_iter_next ( vt->model, &switch_iter ) )
 292         return FALSE;
 293     }
 294     gtk_tree_store_swap ( GTK_TREE_STORE(vt->model), iter, &switch_iter );
 295     return TRUE;
 296     /* now, the easy part. actually switching them, not the GUI */
 297   } /* if item is map */
 298   return FALSE;
 299 }
 300
 301 gboolean vik_treeview_get_iter_at_pos ( VikTreeview *vt, GtkTreeIter *iter, gint x, gint y )
 302 {
 303   GtkTreePath *path;
 304   gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(vt), x, y, &path, NULL, NULL, NULL );
 305   if ( ! path )
 306     return FALSE;
 307
 308   gtk_tree_model_get_iter (GTK_TREE_MODEL(vt->model), iter, path);
 309   gtk_tree_path_free ( path );
 310   return TRUE;
 311 }
 312
 313 void vik_treeview_select_iter ( VikTreeview *vt, GtkTreeIter *iter )
 314 {
 315   gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
 316 }
 317
 318 gboolean vik_treeview_get_selected_iter ( VikTreeview *vt, GtkTreeIter *iter )
 319 {
 320   return gtk_tree_selection_get_selected ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), NULL, iter );
 321 }
 322
 323 void vik_treeview_item_delete ( VikTreeview *vt, GtkTreeIter *iter )
 324 {
 325   gtk_tree_store_remove ( GTK_TREE_STORE(vt->model), iter );
 326 }
 327
 328 /* Treeview Reform Project */
 329
 330 void vik_treeview_item_set_name ( VikTreeview *vt, GtkTreeIter *iter, const gchar *to )
 331 {
 332   g_return_if_fail ( iter != NULL && to != NULL );
 333   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, to, -1);
 334 }
 335
 336 void vik_treeview_item_set_visible ( VikTreeview *vt, GtkTreeIter *iter, gboolean to )
 337 {
 338   g_return_if_fail ( iter != NULL );
 339   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, VISIBLE_COLUMN, to, -1 );
 340 }
 341
 342 void vik_treeview_expand ( VikTreeview *vt, GtkTreeIter *iter )
 343 {
 344   GtkTreePath *path;
 345   path = gtk_tree_model_get_path ( vt->model, iter );
 346   gtk_tree_view_expand_row ( GTK_TREE_VIEW(vt), path, FALSE );
 347   gtk_tree_path_free ( path );
 348 }
 349
 350 void vik_treeview_item_select ( VikTreeview *vt, GtkTreeIter *iter )
 351 {
 352   gtk_tree_selection_select_iter ( gtk_tree_view_get_selection ( GTK_TREE_VIEW ( vt ) ), iter );
 353 }
 354
 355 void vik_treeview_add_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent,
 356                               gpointer item, gint data, gint icon_type )
 357 {
 358   g_assert ( iter != NULL );
 359   g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
 360   gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 361   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE,
 362     TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item,
 363     ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE,
 364     ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
 365 }
 366
 367 void vik_treeview_insert_layer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent,
 368                               gpointer item, gint data, gint icon_type, GtkTreeIter *sibling )
 369 {
 370   g_assert ( iter != NULL );
 371   g_assert ( icon_type < VIK_LAYER_NUM_TYPES );
 372   gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, sibling );
 373   gtk_tree_store_set ( GTK_TREE_STORE(vt->model), iter, NAME_COLUMN, name, VISIBLE_COLUMN, TRUE,
 374     TYPE_COLUMN, VIK_TREEVIEW_TYPE_LAYER, ITEM_PARENT_COLUMN, parent, ITEM_POINTER_COLUMN, item,
 375     ITEM_DATA_COLUMN, data, HAS_VISIBLE_COLUMN, TRUE, EDITABLE_COLUMN, TRUE,
 376     ICON_COLUMN, icon_type >= 0 ? vt->layer_type_icons[icon_type] : NULL, -1 );
 377 }
 378
 379 void vik_treeview_add_sublayer ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item,
 380                                  gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
 381 {
 382   g_assert ( iter != NULL );
 383
 384   gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 385   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 );
 386 }
 387
 388
 389 #ifdef VIK_CONFIG_ALPHABETIZED_TRW
 390
 391 void vik_treeview_sublayer_realphabetize ( VikTreeview *vt, GtkTreeIter *iter, const gchar *newname )
 392 {
 393   GtkTreeIter search_iter, parent_iter;
 394   gchar *search_name;
 395   g_assert ( iter != NULL );
 396
 397   gtk_tree_model_iter_parent ( vt->model, &parent_iter, iter );
 398
 399   g_assert ( gtk_tree_model_iter_children ( vt->model, &search_iter, &parent_iter ) );
 400
 401   do {
 402     gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
 403     if ( strcmp ( search_name, newname ) > 0 ) /* not >= or would trip on itself */
 404     {
 405       gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, &search_iter );
 406       return;
 407     }
 408   } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );
 409
 410   gtk_tree_store_move_before ( GTK_TREE_STORE(vt->model), iter, NULL );
 411 }
 412
 413 void vik_treeview_add_sublayer_alphabetized
 414                  ( VikTreeview *vt, GtkTreeIter *parent_iter, GtkTreeIter *iter, const gchar *name, gpointer parent, gpointer item,
 415                    gint data, GdkPixbuf *icon, gboolean has_visible, gboolean editable )
 416 {
 417   GtkTreeIter search_iter;
 418   gchar *search_name;
 419   g_assert ( iter != NULL );
 420
 421   if ( gtk_tree_model_iter_children ( vt->model, &search_iter, parent_iter ) )
 422   {
 423     gboolean found_greater_string = FALSE;
 424     do {
 425       gtk_tree_model_get ( vt->model, &search_iter, NAME_COLUMN, &search_name, -1 );
 426       if ( strcmp ( search_name, name ) >= 0 )
 427       {
 428         gtk_tree_store_insert_before ( GTK_TREE_STORE(vt->model), iter, parent_iter, &search_iter );
 429         found_greater_string = TRUE;
 430         break;
 431       }
 432     } while ( gtk_tree_model_iter_next ( vt->model, &search_iter ) );
 433
 434     if ( ! found_greater_string )
 435       gtk_tree_store_append ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 436   }
 437   else
 438     gtk_tree_store_prepend ( GTK_TREE_STORE(vt->model), iter, parent_iter );
 439
 440   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 );
 441 }
 442
 443 #endif
 444
 445 static void treeview_finalize ( GObject *gob )
 446 {
 447   VikTreeview *vt = VIK_TREEVIEW ( gob );
 448   guint16 i;
 449
 450   for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
 451     if ( vt->layer_type_icons[i] != NULL )
 452       g_object_unref ( G_OBJECT(vt->layer_type_icons[i]) );
 453
 454   G_OBJECT_CLASS(parent_class)->finalize(gob);
 455 }