libempathy-gtk/empathy-groups-widget.c

   1 /*
   2  * Copyright (C) 2007-2010 Collabora Ltd.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library 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  * Lesser 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 Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  * Authors: Xavier Claessens <xclaesse@gmail.com>
  19  *          Philip Withnall <philip.withnall@collabora.co.uk>
  20  */
  21
  22 #include <config.h>
  23
  24 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #include <gtk/gtk.h>
  28 #include <glib/gi18n-lib.h>
  29
  30 #include <telepathy-glib/telepathy-glib.h>
  31
  32 #include <folks/folks.h>
  33
  34 #include <libempathy/empathy-utils.h>
  35 #include <libempathy/empathy-connection-aggregator.h>
  36
  37 #include "empathy-groups-widget.h"
  38 #include "empathy-ui-utils.h"
  39
  40 /**
  41  * SECTION:empathy-groups-widget
  42  * @title:EmpathyGroupsWidget
  43  * @short_description: A widget used to edit the groups of a #FolksGroupDetails
  44  * @include: libempathy-gtk/empathy-groups-widget.h
  45  *
  46  * #EmpathyGroupsWidget is a widget which lists the groups of a
  47  * #FolksGroupDetails (i.e. a #FolksPersona or a #FolksIndividual) and allows
  48  * them to be added and removed.
  49  */
  50
  51 /**
  52  * EmpathyGroupsWidget:
  53  * @parent: parent object
  54  *
  55  * Widget which displays and allows editing of the groups of a
  56  * #FolksGroupDetails (i.e. a #FolksPersona or #FolksIndividual).
  57  */
  58
  59 /* Delay before updating the widget when the id entry changed (seconds) */
  60 #define ID_CHANGED_TIMEOUT 1
  61
  62 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyGroupsWidget)
  63
  64 typedef struct
  65 {
  66   /* The object we're actually changing the groups of */
  67   FolksGroupDetails *group_details; /* owned */
  68   GtkListStore *group_store; /* owned */
  69
  70   GtkWidget *add_group_entry; /* child widget */
  71   GtkWidget *add_group_button; /* child widget */
  72 } EmpathyGroupsWidgetPriv;
  73
  74 enum {
  75   PROP_GROUP_DETAILS = 1,
  76 };
  77
  78 enum {
  79   COL_NAME,
  80   COL_ENABLED,
  81   COL_EDITABLE
  82 };
  83 #define NUM_COLUMNS COL_EDITABLE + 1
  84
  85 G_DEFINE_TYPE (EmpathyGroupsWidget, empathy_groups_widget, GTK_TYPE_BOX);
  86
  87 typedef struct
  88 {
  89   EmpathyGroupsWidget *widget;
  90   const gchar *name;
  91   gboolean found;
  92   GtkTreeIter found_iter;
  93 } FindNameData;
  94
  95 static gboolean
  96 model_find_name_foreach (GtkTreeModel *model,
  97     GtkTreePath *path,
  98     GtkTreeIter *iter,
  99     FindNameData *data)
 100 {
 101   gchar *name;
 102
 103   gtk_tree_model_get (model, iter,
 104       COL_NAME, &name,
 105       -1);
 106
 107   if (name != NULL && strcmp (data->name, name) == 0)
 108     {
 109       data->found = TRUE;
 110       data->found_iter = *iter;
 111
 112       g_free (name);
 113
 114       return TRUE;
 115     }
 116
 117   g_free (name);
 118
 119   return FALSE;
 120 }
 121
 122 static gboolean
 123 model_find_name (EmpathyGroupsWidget *self,
 124     const gchar *name,
 125     GtkTreeIter *iter)
 126 {
 127   EmpathyGroupsWidgetPriv *priv = GET_PRIV (self);
 128   FindNameData data;
 129
 130   if (EMP_STR_EMPTY (name))
 131     return FALSE;
 132
 133   data.widget = self;
 134   data.name = name;
 135   data.found = FALSE;
 136
 137   gtk_tree_model_foreach (GTK_TREE_MODEL (priv->group_store),
 138       (GtkTreeModelForeachFunc) model_find_name_foreach, &data);
 139
 140   if (data.found == TRUE)
 141     {
 142       *iter = data.found_iter;
 143       return TRUE;
 144     }
 145
 146   return FALSE;
 147 }
 148
 149 static void
 150 populate_data (EmpathyGroupsWidget *self)
 151 {
 152   EmpathyGroupsWidgetPriv *priv = GET_PRIV (self);
 153   EmpathyConnectionAggregator *aggregator;
 154   GeeSet *member_groups;
 155   GList *all_groups, *l;
 156
 157   /* Remove the old groups */
 158   gtk_list_store_clear (priv->group_store);
 159
 160   /* FIXME: We have to get the whole group list from
 161    * EmpathyConnectionAggregator, as libfolks hasn't grown API to get the whole
 162    * group list yet. (bgo#627398) */
 163   aggregator = empathy_connection_aggregator_dup_singleton ();
 164   all_groups = empathy_connection_aggregator_get_all_groups (aggregator);
 165   g_object_unref (aggregator);
 166
 167   /* Get the list of groups that this #FolksGroupDetails is currently in */
 168   member_groups = folks_group_details_get_groups (priv->group_details);
 169
 170   for (l = all_groups; l != NULL; l = l->next)
 171     {
 172       const gchar *group_str = l->data;
 173       gboolean enabled;
 174
 175       enabled = gee_collection_contains (GEE_COLLECTION (member_groups),
 176           group_str);
 177
 178       gtk_list_store_insert_with_values (priv->group_store, NULL, -1,
 179           COL_NAME, group_str,
 180           COL_EDITABLE, TRUE,
 181           COL_ENABLED, enabled,
 182           -1);
 183     }
 184
 185   g_list_free (all_groups);
 186 }
 187
 188 static void
 189 add_group_entry_changed_cb (GtkEditable *editable,
 190     EmpathyGroupsWidget *self)
 191 {
 192   EmpathyGroupsWidgetPriv *priv = GET_PRIV (self);
 193   GtkTreeIter iter;
 194   const gchar *group;
 195
 196   group = gtk_entry_get_text (GTK_ENTRY (priv->add_group_entry));
 197
 198   if (model_find_name (self, group, &iter))
 199     {
 200       gtk_widget_set_sensitive (GTK_WIDGET (priv->add_group_button), FALSE);
 201     }
 202   else
 203     {
 204       gtk_widget_set_sensitive (GTK_WIDGET (priv->add_group_button),
 205           !EMP_STR_EMPTY (group));
 206     }
 207 }
 208
 209 static void
 210 add_group_entry_activate_cb (GtkEntry *entry,
 211     EmpathyGroupsWidget  *self)
 212 {
 213   gtk_widget_activate (GTK_WIDGET (GET_PRIV (self)->add_group_button));
 214 }
 215
 216 static void
 217 change_group_cb (FolksGroupDetails *group_details,
 218     GAsyncResult *async_result,
 219     EmpathyGroupsWidget *self)
 220 {
 221   GError *error = NULL;
 222
 223   folks_group_details_change_group_finish (group_details, async_result, &error);
 224
 225   if (error != NULL)
 226     {
 227       g_warning ("Failed to change group: %s", error->message);
 228       g_clear_error (&error);
 229     }
 230 }
 231
 232 static void
 233 add_group_button_clicked_cb (GtkButton *button,
 234    EmpathyGroupsWidget *self)
 235 {
 236   EmpathyGroupsWidgetPriv *priv = GET_PRIV (self);
 237   const gchar *group;
 238
 239   group = gtk_entry_get_text (GTK_ENTRY (priv->add_group_entry));
 240
 241   gtk_list_store_insert_with_values (priv->group_store, NULL, -1,
 242       COL_NAME, group,
 243       COL_ENABLED, TRUE,
 244       -1);
 245
 246   folks_group_details_change_group (priv->group_details, group, TRUE,
 247       (GAsyncReadyCallback) change_group_cb, self);
 248 }
 249
 250 static void
 251 cell_toggled_cb (GtkCellRendererToggle *cell,
 252     const gchar *path_string,
 253     EmpathyGroupsWidget *self)
 254 {
 255   EmpathyGroupsWidgetPriv *priv = GET_PRIV (self);
 256   GtkTreePath *path;
 257   GtkTreeIter iter;
 258   gboolean was_enabled;
 259   gchar *group;
 260
 261   path = gtk_tree_path_new_from_string (path_string);
 262
 263   gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->group_store), &iter,
 264       path);
 265   gtk_tree_model_get (GTK_TREE_MODEL (priv->group_store), &iter,
 266       COL_ENABLED, &was_enabled,
 267       COL_NAME, &group,
 268       -1);
 269
 270   gtk_list_store_set (priv->group_store, &iter,
 271       COL_ENABLED, !was_enabled,
 272       -1);
 273
 274   gtk_tree_path_free (path);
 275
 276   if (group != NULL)
 277     {
 278       folks_group_details_change_group (priv->group_details, group,
 279           !was_enabled, (GAsyncReadyCallback) change_group_cb, self);
 280       g_free (group);
 281     }
 282 }
 283
 284
 285 static void
 286 group_details_group_changed_cb (FolksGroupDetails *groups,
 287     const gchar *group,
 288     gboolean is_member,
 289     EmpathyGroupsWidget *self)
 290 {
 291   EmpathyGroupsWidgetPriv *priv = GET_PRIV (self);
 292   GtkTreeIter iter;
 293
 294   if (model_find_name (self, group, &iter) == TRUE)
 295     {
 296       gtk_list_store_set (priv->group_store, &iter,
 297           COL_ENABLED, is_member,
 298           -1);
 299     }
 300 }
 301
 302 static void
 303 set_up (EmpathyGroupsWidget *self)
 304 {
 305   EmpathyGroupsWidgetPriv *priv;
 306   GtkWidget *label, *alignment;
 307   GtkBox *vbox, *hbox;
 308   GtkTreeView *tree_view;
 309   GtkTreeSelection *selection;
 310   GtkTreeViewColumn *column;
 311   GtkCellRenderer *renderer;
 312   guint col_offset;
 313   GtkScrolledWindow *scrolled_window;
 314   gchar *markup;
 315
 316   priv = GET_PRIV (self);
 317
 318   /* Set up ourself */
 319   gtk_orientable_set_orientation (GTK_ORIENTABLE (self),
 320       GTK_ORIENTATION_VERTICAL);
 321   gtk_box_set_spacing (GTK_BOX (self), 6);
 322
 323   /* Create our child widgets */
 324   label = gtk_label_new (NULL);
 325   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 326
 327   markup = g_strdup_printf ("<b>%s</b>", _("Groups"));
 328   gtk_label_set_markup (GTK_LABEL (label), markup);
 329   g_free (markup);
 330
 331   gtk_box_pack_start (GTK_BOX (self), label, FALSE, FALSE, 0);
 332   gtk_widget_show (label);
 333
 334   alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
 335   gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
 336
 337   vbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 6));
 338
 339   label = gtk_label_new (_("Select the groups you want this contact to appear "
 340       "in.  Note that you can select more than one group or no groups."));
 341   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 342   gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
 343
 344   gtk_box_pack_start (vbox, label, FALSE, FALSE, 0);
 345   gtk_widget_show (label);
 346
 347   hbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12));
 348
 349   priv->add_group_entry = gtk_entry_new ();
 350   g_signal_connect (priv->add_group_entry, "changed",
 351       (GCallback) add_group_entry_changed_cb, self);
 352   g_signal_connect (priv->add_group_entry, "activate",
 353       (GCallback) add_group_entry_activate_cb, self);
 354
 355   gtk_box_pack_start (hbox, priv->add_group_entry, TRUE, TRUE, 0);
 356   gtk_widget_show (priv->add_group_entry);
 357
 358   priv->add_group_button = gtk_button_new_with_mnemonic (_("_Add Group"));
 359   gtk_widget_set_sensitive (priv->add_group_button, FALSE);
 360   gtk_widget_set_receives_default (priv->add_group_button, TRUE);
 361   g_signal_connect (priv->add_group_button, "clicked",
 362       (GCallback) add_group_button_clicked_cb, self);
 363
 364   gtk_box_pack_start (hbox, priv->add_group_button, FALSE, FALSE, 0);
 365   gtk_widget_show (priv->add_group_button);
 366
 367   gtk_box_pack_start (vbox, GTK_WIDGET (hbox), FALSE, FALSE, 0);
 368   gtk_widget_show (GTK_WIDGET (hbox));
 369
 370   scrolled_window = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL));
 371   gtk_scrolled_window_set_policy (scrolled_window, GTK_POLICY_NEVER,
 372       GTK_POLICY_AUTOMATIC);
 373   gtk_scrolled_window_set_shadow_type (scrolled_window, GTK_SHADOW_IN);
 374   gtk_widget_set_size_request (GTK_WIDGET (scrolled_window), -1, 100);
 375
 376   priv->group_store = gtk_list_store_new (NUM_COLUMNS,
 377       G_TYPE_STRING,   /* name */
 378       G_TYPE_BOOLEAN,  /* enabled */
 379       G_TYPE_BOOLEAN); /* editable */
 380
 381   tree_view = GTK_TREE_VIEW (gtk_tree_view_new_with_model (
 382       GTK_TREE_MODEL (priv->group_store)));
 383   gtk_tree_view_set_headers_visible (tree_view, FALSE);
 384   gtk_tree_view_set_enable_search (tree_view, FALSE);
 385
 386   selection = gtk_tree_view_get_selection (tree_view);
 387   gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
 388
 389   renderer = gtk_cell_renderer_toggle_new ();
 390   g_signal_connect (renderer, "toggled", (GCallback) cell_toggled_cb, self);
 391
 392   column = gtk_tree_view_column_new_with_attributes (
 393       C_("verb in a column header displaying group names", "Select"), renderer,
 394       "active", COL_ENABLED,
 395       NULL);
 396
 397   gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
 398   gtk_tree_view_column_set_fixed_width (column, 50);
 399   gtk_tree_view_append_column (tree_view, column);
 400
 401   renderer = gtk_cell_renderer_text_new ();
 402   col_offset = gtk_tree_view_insert_column_with_attributes (tree_view,
 403       -1, _("Group"),
 404       renderer,
 405       "text", COL_NAME,
 406       /* "editable", COL_EDITABLE, */
 407       NULL);
 408
 409   column = gtk_tree_view_get_column (tree_view, col_offset - 1);
 410   gtk_tree_view_column_set_sort_column_id (column, COL_NAME);
 411   gtk_tree_view_column_set_resizable (column, FALSE);
 412   gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
 413
 414   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->group_store),
 415       COL_NAME, GTK_SORT_ASCENDING);
 416
 417   gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (tree_view));
 418   gtk_widget_show (GTK_WIDGET (tree_view));
 419
 420   gtk_box_pack_start (vbox, GTK_WIDGET (scrolled_window), TRUE, TRUE, 0);
 421   gtk_widget_show (GTK_WIDGET (scrolled_window));
 422
 423   gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox));
 424   gtk_widget_show (GTK_WIDGET (vbox));
 425
 426   gtk_box_pack_start (GTK_BOX (self), alignment, TRUE, TRUE, 0);
 427   gtk_widget_show (alignment);
 428 }
 429
 430 static void
 431 empathy_groups_widget_init (EmpathyGroupsWidget *self)
 432 {
 433   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 434       EMPATHY_TYPE_GROUPS_WIDGET, EmpathyGroupsWidgetPriv);
 435
 436   set_up (self);
 437 }
 438
 439 static void
 440 get_property (GObject *object,
 441     guint param_id,
 442     GValue *value,
 443     GParamSpec *pspec)
 444 {
 445   EmpathyGroupsWidgetPriv *priv;
 446
 447   priv = GET_PRIV (object);
 448
 449   switch (param_id)
 450     {
 451       case PROP_GROUP_DETAILS:
 452         g_value_set_object (value, priv->group_details);
 453         break;
 454       default:
 455         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 456         break;
 457     }
 458 }
 459
 460 static void
 461 set_property (GObject *object,
 462     guint param_id,
 463     const GValue *value,
 464     GParamSpec *pspec)
 465 {
 466   switch (param_id)
 467     {
 468       case PROP_GROUP_DETAILS:
 469         empathy_groups_widget_set_group_details (EMPATHY_GROUPS_WIDGET (object),
 470             g_value_get_object (value));
 471         break;
 472       default:
 473         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 474         break;
 475     }
 476 }
 477
 478 static void
 479 dispose (GObject *object)
 480 {
 481   EmpathyGroupsWidgetPriv *priv = GET_PRIV (object);
 482
 483   empathy_groups_widget_set_group_details (EMPATHY_GROUPS_WIDGET (object),
 484       NULL);
 485   tp_clear_object (&priv->group_store);
 486
 487   G_OBJECT_CLASS (empathy_groups_widget_parent_class)->dispose (object);
 488 }
 489
 490 static void
 491 empathy_groups_widget_class_init (EmpathyGroupsWidgetClass *klass)
 492 {
 493   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 494
 495   object_class->get_property = get_property;
 496   object_class->set_property = set_property;
 497   object_class->dispose = dispose;
 498
 499   /**
 500    * EmpathyGroupsWidget:group_details:
 501    *
 502    * The #FolksGroupDetails whose group membership is to be edited by the
 503    * #EmpathyGroupsWidget.
 504    */
 505   g_object_class_install_property (object_class, PROP_GROUP_DETAILS,
 506       g_param_spec_object ("group-details",
 507           "Group Details",
 508           "The #FolksGroupDetails whose groups are being edited.",
 509           FOLKS_TYPE_GROUP_DETAILS,
 510           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 511
 512   g_type_class_add_private (object_class, sizeof (EmpathyGroupsWidgetPriv));
 513 }
 514
 515 /**
 516  * empathy_groups_widget_new:
 517  * @group_details: a #FolksGroupDetails, or %NULL
 518  *
 519  * Creates a new #EmpathyGroupsWidget to edit the groups of the given
 520  * @group_details.
 521  *
 522  * Return value: a new #EmpathyGroupsWidget
 523  */
 524 GtkWidget *
 525 empathy_groups_widget_new (FolksGroupDetails *group_details)
 526 {
 527   g_return_val_if_fail (
 528       group_details == NULL || FOLKS_IS_GROUP_DETAILS (group_details),
 529       NULL);
 530
 531   return GTK_WIDGET (g_object_new (EMPATHY_TYPE_GROUPS_WIDGET,
 532       "group-details", group_details,
 533       NULL));
 534 }
 535
 536 /**
 537  * empathy_groups_widget_get_group_details:
 538  * @self: an #EmpathyGroupsWidget
 539  *
 540  * Get the #FolksGroupDetails whose group membership is being edited by the
 541  * #EmpathyGroupsWidget.
 542  *
 543  * Returns: the #FolksGroupDetails associated with @widget, or %NULL
 544  */
 545 FolksGroupDetails *
 546 empathy_groups_widget_get_group_details (EmpathyGroupsWidget *self)
 547 {
 548   g_return_val_if_fail (EMPATHY_IS_GROUPS_WIDGET (self), NULL);
 549
 550   return GET_PRIV (self)->group_details;
 551 }
 552
 553 /**
 554  * empathy_groups_widget_set_group_details:
 555  * @self: an #EmpathyGroupsWidget
 556  * @group_details: the #FolksGroupDetails whose membership is to be edited, or
 557  * %NULL
 558  *
 559  * Change the #FolksGroupDetails whose group membership is to be edited by the
 560  * #EmpathyGroupsWidget.
 561  */
 562 void
 563 empathy_groups_widget_set_group_details (EmpathyGroupsWidget *self,
 564     FolksGroupDetails *group_details)
 565 {
 566   EmpathyGroupsWidgetPriv *priv;
 567
 568   g_return_if_fail (EMPATHY_IS_GROUPS_WIDGET (self));
 569   g_return_if_fail (
 570       group_details == NULL || FOLKS_IS_GROUP_DETAILS (group_details));
 571
 572   priv = GET_PRIV (self);
 573
 574   if (group_details == priv->group_details)
 575     return;
 576
 577   if (priv->group_details != NULL)
 578     {
 579       g_signal_handlers_disconnect_by_func (priv->group_details,
 580           group_details_group_changed_cb, self);
 581     }
 582
 583   tp_clear_object (&priv->group_details);
 584
 585   if (group_details != NULL)
 586     {
 587       priv->group_details = g_object_ref (group_details);
 588
 589       g_signal_connect (priv->group_details, "group-changed",
 590           (GCallback) group_details_group_changed_cb, self);
 591
 592       populate_data (self);
 593     }
 594
 595   g_object_notify (G_OBJECT (self), "group-details");
 596 }