libedataserverui/e-categories-selector.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of version 2 of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #include <config.h>
  21 #include <glib/gi18n-lib.h>
  22
  23 #include <libedataserver/libedataserver.h>
  24
  25 #include "e-categories-selector.h"
  26 #include "e-data-server-ui-marshal.h"
  27
  28 #define E_CATEGORIES_SELECTOR_GET_PRIVATE(obj) \
  29         (G_TYPE_INSTANCE_GET_PRIVATE \
  30         ((obj), E_TYPE_CATEGORIES_SELECTOR, ECategoriesSelectorPrivate))
  31
  32 struct _ECategoriesSelectorPrivate {
  33         gboolean checkable;
  34         GHashTable *selected_categories;
  35
  36         gboolean ignore_category_changes;
  37 };
  38
  39 enum {
  40         PROP_0,
  41         PROP_ITEMS_CHECKABLE
  42 };
  43
  44 enum {
  45         CATEGORY_CHECKED,
  46         SELECTION_CHANGED,
  47         LAST_SIGNAL
  48 };
  49
  50 enum {
  51         COLUMN_ACTIVE,
  52         COLUMN_ICON,
  53         COLUMN_CATEGORY,
  54         N_COLUMNS
  55 };
  56
  57 static gint signals[LAST_SIGNAL] = {0};
  58
  59 G_DEFINE_TYPE (
  60         ECategoriesSelector,
  61         e_categories_selector,
  62         GTK_TYPE_TREE_VIEW)
  63
  64 static void
  65 categories_selector_build_model (ECategoriesSelector *selector)
  66 {
  67         GtkListStore *store;
  68         GList *list, *iter;
  69
  70         store = gtk_list_store_new (
  71                 N_COLUMNS, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING);
  72
  73         gtk_tree_sortable_set_sort_column_id (
  74                 GTK_TREE_SORTABLE (store),
  75                 COLUMN_CATEGORY, GTK_SORT_ASCENDING);
  76
  77         list = e_categories_get_list ();
  78         for (iter = list; iter != NULL; iter = iter->next) {
  79                 const gchar *category_name = iter->data;
  80                 const gchar *filename;
  81                 GdkPixbuf *pixbuf = NULL;
  82                 GtkTreeIter iter;
  83                 gboolean active;
  84
  85                 /* Only add user-visible categories. */
  86                 if (!e_categories_is_searchable (category_name))
  87                         continue;
  88
  89                 active = (g_hash_table_lookup (
  90                                 selector->priv->selected_categories,
  91                                 category_name) != NULL);
  92
  93                 filename = e_categories_get_icon_file_for (category_name);
  94                 if (filename != NULL)
  95                         pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
  96
  97                 gtk_list_store_append (store, &iter);
  98
  99                 gtk_list_store_set (
 100                         store, &iter,
 101                         COLUMN_ACTIVE, active,
 102                         COLUMN_ICON, pixbuf,
 103                         COLUMN_CATEGORY, category_name,
 104                         -1);
 105
 106                 if (pixbuf != NULL)
 107                         g_object_unref (pixbuf);
 108         }
 109
 110         gtk_tree_view_set_model (
 111                 GTK_TREE_VIEW (selector), GTK_TREE_MODEL (store));
 112
 113         /* This has to be reset everytime we install a new model */
 114         gtk_tree_view_set_search_column (
 115                 GTK_TREE_VIEW (selector), COLUMN_CATEGORY);
 116
 117         g_list_free (list);
 118         g_object_unref (store);
 119 }
 120
 121 static void
 122 category_toggled_cb (GtkCellRenderer *renderer,
 123                      const gchar *path,
 124                      ECategoriesSelector *selector)
 125 {
 126         GtkTreeModel *model;
 127         GtkTreePath *tree_path;
 128         GtkTreeIter iter;
 129
 130         model = gtk_tree_view_get_model (GTK_TREE_VIEW (selector));
 131         g_return_if_fail (model);
 132
 133         tree_path = gtk_tree_path_new_from_string (path);
 134         g_return_if_fail (tree_path);
 135
 136         if (gtk_tree_model_get_iter (model, &iter, tree_path)) {
 137                 gchar *category;
 138                 gboolean active;
 139
 140                 gtk_tree_model_get (model, &iter,
 141                         COLUMN_ACTIVE, &active,
 142                         COLUMN_CATEGORY, &category, -1);
 143
 144                 gtk_list_store_set (
 145                         GTK_LIST_STORE (model), &iter,
 146                         COLUMN_ACTIVE, !active, -1);
 147
 148                 if (active)
 149                         g_hash_table_remove (
 150                                 selector->priv->selected_categories, category);
 151                 else
 152                         g_hash_table_insert (
 153                                 selector->priv->selected_categories,
 154                                 g_strdup (category), g_strdup (category));
 155
 156                 g_signal_emit (
 157                         selector, signals[CATEGORY_CHECKED], 0,
 158                         category, !active);
 159
 160                 g_free (category);
 161         }
 162
 163         gtk_tree_path_free (tree_path);
 164 }
 165
 166 static void
 167 categories_selector_listener_cb (gpointer useless_pointer,
 168                                  ECategoriesSelector *selector)
 169 {
 170         if (!selector->priv->ignore_category_changes)
 171                 categories_selector_build_model (selector);
 172 }
 173
 174 static gboolean
 175 categories_selector_key_press_event (ECategoriesSelector *selector,
 176                                      GdkEventKey *event)
 177 {
 178         if (event->keyval == GDK_KEY_Delete) {
 179                 e_categories_selector_delete_selection (selector);
 180                 return TRUE;
 181         }
 182
 183         return FALSE;
 184 }
 185
 186 static void
 187 categories_selector_selection_changed (GtkTreeSelection *selection,
 188                                        ECategoriesSelector *selector)
 189 {
 190         g_signal_emit (selector, signals[SELECTION_CHANGED], 0, selection);
 191 }
 192
 193 static void
 194 categories_selector_get_property (GObject *object,
 195                                   guint property_id,
 196                                   GValue *value,
 197                                   GParamSpec *pspec)
 198 {
 199         switch (property_id) {
 200                 case PROP_ITEMS_CHECKABLE:
 201                         g_value_set_boolean (
 202                                 value,
 203                                 e_categories_selector_get_items_checkable (
 204                                 E_CATEGORIES_SELECTOR (object)));
 205                         return;
 206         }
 207
 208         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 209 }
 210
 211 static void
 212 categories_selector_set_property (GObject *object,
 213                                   guint property_id,
 214                                   const GValue *value,
 215                                   GParamSpec *pspec)
 216 {
 217         switch (property_id) {
 218                 case PROP_ITEMS_CHECKABLE:
 219                         e_categories_selector_set_items_checkable (
 220                                 E_CATEGORIES_SELECTOR (object),
 221                                 g_value_get_boolean (value));
 222                         return;
 223         }
 224
 225         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 226 }
 227
 228 static void
 229 categories_selector_dispose (GObject *object)
 230 {
 231         ECategoriesSelectorPrivate *priv;
 232
 233         priv = E_CATEGORIES_SELECTOR_GET_PRIVATE (object);
 234
 235         if (priv->selected_categories != NULL) {
 236                 g_hash_table_destroy (priv->selected_categories);
 237                 priv->selected_categories = NULL;
 238         }
 239
 240         /* Chain up to parent's dispose() method.*/
 241         G_OBJECT_CLASS (e_categories_selector_parent_class)->dispose (object);
 242 }
 243
 244 static void
 245 categories_selector_finalize (GObject *object)
 246 {
 247         e_categories_unregister_change_listener (
 248                 G_CALLBACK (categories_selector_listener_cb), object);
 249 }
 250
 251 static void
 252 e_categories_selector_class_init (ECategoriesSelectorClass *class)
 253 {
 254         GObjectClass *object_class;
 255
 256         g_type_class_add_private (class, sizeof (ECategoriesSelectorPrivate));
 257
 258         object_class = G_OBJECT_CLASS (class);
 259         object_class->set_property = categories_selector_set_property;
 260         object_class->get_property = categories_selector_get_property;
 261         object_class->dispose = categories_selector_dispose;
 262         object_class->finalize = categories_selector_finalize;
 263
 264         g_object_class_install_property (
 265                 object_class,
 266                 PROP_ITEMS_CHECKABLE,
 267                 g_param_spec_boolean (
 268                         "items-checkable",
 269                         NULL,
 270                         NULL,
 271                         TRUE,
 272                         G_PARAM_READWRITE));
 273
 274         signals[CATEGORY_CHECKED] = g_signal_new (
 275                 "category-checked",
 276                 G_TYPE_FROM_CLASS (class),
 277                 G_SIGNAL_RUN_FIRST,
 278                 G_STRUCT_OFFSET (ECategoriesSelectorClass, category_checked),
 279                 NULL, NULL,
 280                 e_data_server_ui_marshal_VOID__STRING_BOOLEAN,
 281                 G_TYPE_NONE, 2,
 282                 G_TYPE_STRING,
 283                 G_TYPE_BOOLEAN);
 284
 285         signals[SELECTION_CHANGED] = g_signal_new (
 286                 "selection-changed",
 287                 G_TYPE_FROM_CLASS (class),
 288                 G_SIGNAL_RUN_FIRST,
 289                 G_STRUCT_OFFSET (ECategoriesSelectorClass, selection_changed),
 290                 NULL, NULL,
 291                 g_cclosure_marshal_VOID__OBJECT,
 292                 G_TYPE_NONE, 1,
 293                 GTK_TYPE_TREE_SELECTION);
 294 }
 295
 296 static void
 297 e_categories_selector_init (ECategoriesSelector *selector)
 298 {
 299         GtkCellRenderer *renderer;
 300         GtkTreeViewColumn *column;
 301         GtkTreeSelection *selection;
 302
 303         selector->priv = E_CATEGORIES_SELECTOR_GET_PRIVATE (selector);
 304
 305         selector->priv->checkable = TRUE;
 306         selector->priv->selected_categories = g_hash_table_new_full (
 307                 (GHashFunc) g_str_hash,
 308                 (GEqualFunc) g_str_equal,
 309                 (GDestroyNotify) g_free,
 310                 (GDestroyNotify) g_free);
 311         selector->priv->ignore_category_changes = FALSE;
 312
 313         renderer = gtk_cell_renderer_toggle_new ();
 314         column = gtk_tree_view_column_new_with_attributes (
 315                 "?", renderer, "active", COLUMN_ACTIVE, NULL);
 316         gtk_tree_view_append_column (GTK_TREE_VIEW (selector), column);
 317
 318         g_signal_connect (
 319                 renderer, "toggled",
 320                 G_CALLBACK (category_toggled_cb), selector);
 321
 322         renderer = gtk_cell_renderer_pixbuf_new ();
 323         column = gtk_tree_view_column_new_with_attributes (
 324                 _("Icon"), renderer, "pixbuf", COLUMN_ICON, NULL);
 325         gtk_tree_view_append_column (GTK_TREE_VIEW (selector), column);
 326
 327         renderer = gtk_cell_renderer_text_new ();
 328         column = gtk_tree_view_column_new_with_attributes (
 329                 _("Category"), renderer, "text", COLUMN_CATEGORY, NULL);
 330         gtk_tree_view_append_column (GTK_TREE_VIEW (selector), column);
 331
 332         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (selector));
 333         g_signal_connect (
 334                 selection, "changed",
 335                 G_CALLBACK (categories_selector_selection_changed), selector);
 336
 337         g_signal_connect (
 338                 selector, "key-press-event",
 339                 G_CALLBACK (categories_selector_key_press_event), NULL);
 340
 341         e_categories_register_change_listener (
 342                 G_CALLBACK (categories_selector_listener_cb), selector);
 343
 344         categories_selector_build_model (selector);
 345 }
 346
 347 /**
 348  * e_categories_selector_new:
 349  *
 350  * Since: 3.2
 351  **/
 352 GtkWidget *
 353 e_categories_selector_new (void)
 354 {
 355         return g_object_new (
 356                 E_TYPE_CATEGORIES_SELECTOR,
 357                 "items-checkable", TRUE, NULL);
 358 }
 359
 360 /**
 361  * e_categories_selector_get_items_checkable:
 362  *
 363  * Since: 3.2
 364  **/
 365 gboolean
 366 e_categories_selector_get_items_checkable (ECategoriesSelector *selector)
 367 {
 368         g_return_val_if_fail (E_IS_CATEGORIES_SELECTOR (selector), TRUE);
 369
 370         return selector->priv->checkable;
 371 }
 372
 373 /**
 374  * e_categories_selector_set_items_checkable:
 375  *
 376  * Since: 3.2
 377  **/
 378 void
 379 e_categories_selector_set_items_checkable (ECategoriesSelector *selector,
 380                                            gboolean checkable)
 381 {
 382         GtkTreeViewColumn *column;
 383
 384         g_return_if_fail (E_IS_CATEGORIES_SELECTOR (selector));
 385
 386         selector->priv->checkable = checkable;
 387
 388         column = gtk_tree_view_get_column (
 389                 GTK_TREE_VIEW (selector), COLUMN_ACTIVE);
 390         gtk_tree_view_column_set_visible (column, checkable);
 391
 392         g_object_notify (G_OBJECT (selector), "items-checkable");
 393 }
 394
 395 /**
 396  * e_categories_selector_get_checked:
 397  *
 398  * Free returned pointer with g_free().
 399  *
 400  * Since: 3.2
 401  **/
 402 gchar *
 403 e_categories_selector_get_checked (ECategoriesSelector *selector)
 404 {
 405         GString *str;
 406         GList *list, *category;
 407
 408         g_return_val_if_fail (E_IS_CATEGORIES_SELECTOR (selector), NULL);
 409
 410         str = g_string_new ("");
 411         list = g_hash_table_get_values (selector->priv->selected_categories);
 412
 413         /* to get them always in the same order */
 414         list = g_list_sort (list, (GCompareFunc) g_utf8_collate);
 415
 416         for (category = list; category != NULL; category = category->next) {
 417                 if (str->len > 0)
 418                         g_string_append_printf (
 419                                 str, ",%s", (gchar *) category->data);
 420                 else
 421                         g_string_append (str, (gchar *) category->data);
 422         }
 423
 424         g_list_free (list);
 425
 426         return g_string_free (str, FALSE);
 427 }
 428
 429 /**
 430  * e_categories_selector_set_checked:
 431  *
 432  * Since: 3.2
 433  **/
 434 void
 435 e_categories_selector_set_checked (ECategoriesSelector *selector,
 436                                    const gchar *categories)
 437 {
 438         GtkTreeModel *model;
 439         GtkTreeIter iter;
 440         gchar **arr;
 441         gint i;
 442
 443         g_return_if_fail (E_IS_CATEGORIES_SELECTOR (selector));
 444
 445         /* Clean up table of selected categories. */
 446         g_hash_table_remove_all (selector->priv->selected_categories);
 447
 448         arr = g_strsplit (categories, ",", 0);
 449         if (arr) {
 450                 for (i = 0; arr[i] != NULL; i++) {
 451                         g_strstrip (arr[i]);
 452                         g_hash_table_insert (
 453                                 selector->priv->selected_categories,
 454                                 g_strdup (arr[i]), g_strdup (arr[i]));
 455                 }
 456                 g_strfreev (arr);
 457         }
 458
 459         model = gtk_tree_view_get_model (GTK_TREE_VIEW (selector));
 460         if (gtk_tree_model_get_iter_first (model, &iter)) {
 461                 do {
 462                         gchar *category_name;
 463                         gboolean found;
 464
 465                         gtk_tree_model_get (model, &iter,
 466                                 COLUMN_CATEGORY, &category_name,
 467                                 -1);
 468                         found = (g_hash_table_lookup (
 469                                 selector->priv->selected_categories,
 470                                 category_name) != NULL);
 471                         gtk_list_store_set (
 472                                 GTK_LIST_STORE (model), &iter,
 473                                 COLUMN_ACTIVE, found, -1);
 474
 475                         g_free (category_name);
 476                 } while (gtk_tree_model_iter_next (model, &iter));
 477         }
 478 }
 479
 480 /**
 481  * e_categories_selector_delete_selection:
 482  *
 483  * Since: 3.2
 484  **/
 485 void
 486 e_categories_selector_delete_selection (ECategoriesSelector *selector)
 487 {
 488         GtkTreeModel *model;
 489         GtkTreeSelection *selection;
 490         GList *selected, *item;
 491
 492         g_return_if_fail (E_IS_CATEGORIES_SELECTOR (selector));
 493
 494         model = gtk_tree_view_get_model (GTK_TREE_VIEW (selector));
 495         g_return_if_fail (model != NULL);
 496
 497         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (selector));
 498         selected = gtk_tree_selection_get_selected_rows (selection, &model);
 499
 500         /* Remove categories in reverse order to avoid invalidating
 501          * tree paths as we iterate over the list. Note, the list is
 502          * probably already sorted but we sort again just to be safe. */
 503         selected = g_list_reverse (g_list_sort (
 504                 selected, (GCompareFunc) gtk_tree_path_compare));
 505
 506         /* Prevent the model from being rebuilt every time we
 507          * remove a category, since we're already modifying it. */
 508         selector->priv->ignore_category_changes = TRUE;
 509
 510         for (item = selected; item != NULL; item = item->next) {
 511                 GtkTreePath *path = item->data;
 512                 GtkTreeIter iter;
 513                 gchar *category;
 514
 515                 gtk_tree_model_get_iter (model, &iter, path);
 516                 gtk_tree_model_get (model, &iter,
 517                         COLUMN_CATEGORY, &category, -1);
 518                 gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
 519                 e_categories_remove (category);
 520                 g_free (category);
 521         }
 522
 523         selector->priv->ignore_category_changes = FALSE;
 524
 525         /* If we only remove one category, try to select another */
 526         if (g_list_length (selected) == 1) {
 527                 GtkTreePath *path = selected->data;
 528
 529                 gtk_tree_selection_select_path (selection, path);
 530                 if (!gtk_tree_selection_path_is_selected (selection, path))
 531                         if (gtk_tree_path_prev (path))
 532                                 gtk_tree_selection_select_path (selection, path);
 533         }
 534
 535         g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
 536         g_list_free (selected);
 537 }
 538
 539 /**
 540  * e_categories_selector_get_selected:
 541  *
 542  * Free returned pointer with g_free().
 543  *
 544  * Since: 3.2
 545  **/
 546 gchar *
 547 e_categories_selector_get_selected (ECategoriesSelector *selector)
 548 {
 549         GtkTreeModel *model;
 550         GtkTreeSelection *selection;
 551         GList *selected, *item;
 552         GString *str = g_string_new ("");
 553
 554         g_return_val_if_fail (E_IS_CATEGORIES_SELECTOR (selector), NULL);
 555
 556         model = gtk_tree_view_get_model (GTK_TREE_VIEW (selector));
 557         g_return_val_if_fail (model != NULL, NULL);
 558
 559         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (selector));
 560         selected = gtk_tree_selection_get_selected_rows (selection, &model);
 561
 562         for (item = selected; item != NULL; item = item->next) {
 563                 GtkTreePath *path = item->data;
 564                 GtkTreeIter iter;
 565                 gchar *category;
 566
 567                 gtk_tree_model_get_iter (model, &iter, path);
 568                 gtk_tree_model_get (model, &iter,
 569                         COLUMN_CATEGORY, &category, -1);
 570                 if (str->len == 0)
 571                         g_string_assign (str, category);
 572                 else
 573                         g_string_append_printf (str, ",%s", category);
 574
 575                 g_free (category);
 576         }
 577
 578         g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
 579         g_list_free (selected);
 580
 581         return g_string_free (str, FALSE);
 582 }