libempathy-gtk/empathy-individual-store-channel.c

   1 /*
   2  * Copyright (C) 2005-2007 Imendio AB
   3  * Copyright (C) 2007-2011 Collabora Ltd.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA  02110-1301  USA
  19  *
  20  * Authors: Mikael Hallendal <micke@imendio.com>
  21  *          Martyn Russell <martyn@imendio.com>
  22  *          Xavier Claessens <xclaesse@gmail.com>
  23  *          Travis Reitter <travis.reitter@collabora.co.uk>
  24  */
  25
  26 #include "config.h"
  27
  28 #include <string.h>
  29
  30 #include <glib.h>
  31 #include <glib/gi18n-lib.h>
  32 #include <gtk/gtk.h>
  33
  34 #include <folks/folks.h>
  35 #include <folks/folks-telepathy.h>
  36 #include <telepathy-glib/util.h>
  37
  38 #include <libempathy/empathy-utils.h>
  39 #include <libempathy/empathy-enum-types.h>
  40
  41 #include "empathy-individual-store-channel.h"
  42
  43 #include "empathy-ui-utils.h"
  44 #include "empathy-gtk-enum-types.h"
  45
  46 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
  47 #include <libempathy/empathy-debug.h>
  48
  49 struct _EmpathyIndividualStoreChannelPriv
  50 {
  51   TpChannel *channel;
  52
  53   /* TpContact => FolksIndividual
  54    * We keep the individuals we have added to the store so can easily remove
  55    * them when their TpContact leaves the channel. */
  56   GHashTable *individuals;
  57 };
  58
  59 enum
  60 {
  61   PROP_0,
  62   PROP_CHANNEL,
  63 };
  64
  65
  66 G_DEFINE_TYPE (EmpathyIndividualStoreChannel, empathy_individual_store_channel,
  67     EMPATHY_TYPE_INDIVIDUAL_STORE);
  68
  69 static void
  70 add_members (EmpathyIndividualStoreChannel *self,
  71     GPtrArray *members)
  72 {
  73   EmpathyIndividualStore *store = (EmpathyIndividualStore *) self;
  74   guint i;
  75
  76   for (i = 0; i < members->len; i++)
  77     {
  78       TpContact *contact = g_ptr_array_index (members, i);
  79       FolksIndividual *individual;
  80
  81       if (g_hash_table_lookup (self->priv->individuals, contact) != NULL)
  82         continue;
  83
  84       individual = empathy_create_individual_from_tp_contact (contact);
  85       if (individual == NULL)
  86         return;
  87
  88       DEBUG ("%s joined channel %s", tp_contact_get_identifier (contact),
  89           tp_proxy_get_object_path (self->priv->channel));
  90
  91       individual_store_add_individual_and_connect (store, individual);
  92
  93       /* Pass the individual reference to the hash table */
  94       g_hash_table_insert (self->priv->individuals, g_object_ref (contact),
  95           individual);
  96     }
  97 }
  98
  99 static void
 100 remove_members (EmpathyIndividualStoreChannel *self,
 101     GPtrArray *members)
 102 {
 103   EmpathyIndividualStore *store = (EmpathyIndividualStore *) self;
 104   guint i;
 105
 106   for (i = 0; i < members->len; i++)
 107     {
 108       TpContact *contact = g_ptr_array_index (members, i);
 109       FolksIndividual *individual;
 110
 111       individual = g_hash_table_lookup (self->priv->individuals, contact);
 112       if (individual == NULL)
 113         continue;
 114
 115       DEBUG ("%s left channel %s", tp_contact_get_identifier (contact),
 116           tp_proxy_get_object_path (self->priv->channel));
 117
 118       individual_store_remove_individual_and_disconnect (store, individual);
 119
 120       g_hash_table_remove (self->priv->individuals, contact);
 121     }
 122 }
 123
 124 static void
 125 group_contacts_changed_cb (TpChannel *channel,
 126     GPtrArray *added,
 127     GPtrArray *removed,
 128     GPtrArray *local_pending,
 129     GPtrArray *remote_pending,
 130     TpContact *actor,
 131     GHashTable *details,
 132     gpointer user_data)
 133 {
 134   EmpathyIndividualStoreChannel *self = EMPATHY_INDIVIDUAL_STORE_CHANNEL (
 135       user_data);
 136
 137   remove_members (self, removed);
 138   add_members (self, added);
 139 }
 140
 141 static void
 142 individual_store_channel_set_individual_channel (
 143     EmpathyIndividualStoreChannel *self,
 144     TpChannel *channel)
 145 {
 146   GPtrArray *members;
 147
 148   g_assert (self->priv->channel == NULL); /* construct only */
 149   self->priv->channel = g_object_ref (channel);
 150
 151   /* Add initial members */
 152   members = tp_channel_group_dup_members_contacts (channel);
 153   if (members != NULL)
 154     {
 155       add_members (self, members);
 156       g_ptr_array_unref (members);
 157     }
 158
 159   tp_g_signal_connect_object (channel, "group-contacts-changed",
 160       G_CALLBACK (group_contacts_changed_cb), self, 0);
 161 }
 162
 163 static void
 164 individual_store_channel_dispose (GObject *object)
 165 {
 166   EmpathyIndividualStoreChannel *self = EMPATHY_INDIVIDUAL_STORE_CHANNEL (
 167       object);
 168   EmpathyIndividualStore *store = EMPATHY_INDIVIDUAL_STORE (object);
 169   GHashTableIter iter;
 170   gpointer v;
 171
 172   g_hash_table_iter_init (&iter, self->priv->individuals);
 173   while (g_hash_table_iter_next (&iter, NULL, &v))
 174     {
 175       FolksIndividual *individual = v;
 176
 177       empathy_individual_store_disconnect_individual (store, individual);
 178     }
 179
 180   tp_clear_pointer (&self->priv->individuals, g_hash_table_unref);
 181   g_clear_object (&self->priv->channel);
 182
 183   G_OBJECT_CLASS (empathy_individual_store_channel_parent_class)->dispose (
 184       object);
 185 }
 186
 187 static void
 188 individual_store_channel_get_property (GObject *object,
 189     guint param_id,
 190     GValue *value,
 191     GParamSpec *pspec)
 192 {
 193   EmpathyIndividualStoreChannel *self = EMPATHY_INDIVIDUAL_STORE_CHANNEL (
 194       object);
 195
 196   switch (param_id)
 197     {
 198     case PROP_CHANNEL:
 199       g_value_set_object (value, self->priv->channel);
 200       break;
 201     default:
 202       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 203       break;
 204     };
 205 }
 206
 207 static void
 208 individual_store_channel_set_property (GObject *object,
 209     guint param_id,
 210     const GValue *value,
 211     GParamSpec *pspec)
 212 {
 213   switch (param_id)
 214     {
 215     case PROP_CHANNEL:
 216       individual_store_channel_set_individual_channel (
 217           EMPATHY_INDIVIDUAL_STORE_CHANNEL (object),
 218           g_value_get_object (value));
 219       break;
 220     default:
 221       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 222       break;
 223     };
 224 }
 225
 226 static void
 227 individual_store_channel_reload_individuals (EmpathyIndividualStore *store)
 228 {
 229   EmpathyIndividualStoreChannel *self = EMPATHY_INDIVIDUAL_STORE_CHANNEL (
 230       store);
 231   GPtrArray *members;
 232   GList *list, *l;
 233
 234   /* remove all. The list returned by g_hash_table_get_keys() is valid until
 235    * the hash table is modified so we can't remove the contact directly in the
 236    * iteration. */
 237   members = g_ptr_array_new_with_free_func (g_object_unref);
 238
 239   list = g_hash_table_get_keys (self->priv->individuals);
 240   for (l = list; l != NULL; l = g_list_next (l))
 241     {
 242       g_ptr_array_add (members, g_object_ref (l->data));
 243     }
 244
 245   remove_members (self, members);
 246
 247   g_list_free (list);
 248   g_ptr_array_unref (members);
 249
 250   /* re-add members */
 251   members = tp_channel_group_dup_members_contacts (self->priv->channel);
 252   if (members == NULL)
 253     return;
 254
 255   add_members (self, members);
 256   g_ptr_array_unref (members);
 257 }
 258
 259 static gboolean
 260 individual_store_channel_initial_loading (EmpathyIndividualStore *store)
 261 {
 262   EmpathyIndividualStoreChannel *self = EMPATHY_INDIVIDUAL_STORE_CHANNEL (
 263       store);
 264
 265   return !tp_proxy_is_prepared (self->priv->channel,
 266       TP_CHANNEL_FEATURE_CONTACTS);
 267 }
 268
 269 static void
 270 empathy_individual_store_channel_class_init (
 271     EmpathyIndividualStoreChannelClass *klass)
 272 {
 273   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 274   EmpathyIndividualStoreClass *store_class = EMPATHY_INDIVIDUAL_STORE_CLASS (
 275       klass);
 276
 277   object_class->dispose = individual_store_channel_dispose;
 278   object_class->get_property = individual_store_channel_get_property;
 279   object_class->set_property = individual_store_channel_set_property;
 280
 281   store_class->reload_individuals = individual_store_channel_reload_individuals;
 282   store_class->initial_loading = individual_store_channel_initial_loading;
 283
 284   g_object_class_install_property (object_class,
 285       PROP_CHANNEL,
 286       g_param_spec_object ("individual-channel",
 287           "Individual channel",
 288           "Individual channel",
 289           TP_TYPE_CHANNEL,
 290           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
 291
 292   g_type_class_add_private (object_class,
 293       sizeof (EmpathyIndividualStoreChannelPriv));
 294 }
 295
 296 static void
 297 empathy_individual_store_channel_init (EmpathyIndividualStoreChannel *self)
 298 {
 299   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 300       EMPATHY_TYPE_INDIVIDUAL_STORE_CHANNEL, EmpathyIndividualStoreChannelPriv);
 301
 302   self->priv->individuals = g_hash_table_new_full (NULL, NULL, g_object_unref,
 303       g_object_unref);
 304 }
 305
 306 EmpathyIndividualStoreChannel *
 307 empathy_individual_store_channel_new (TpChannel *channel)
 308 {
 309   g_return_val_if_fail (TP_IS_CHANNEL (channel), NULL);
 310
 311   return g_object_new (EMPATHY_TYPE_INDIVIDUAL_STORE_CHANNEL,
 312       "individual-channel", channel, NULL);
 313 }
 314
 315 TpChannel *
 316 empathy_individual_store_channel_get_channel (
 317     EmpathyIndividualStoreChannel *self)
 318 {
 319   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_STORE_CHANNEL (self), FALSE);
 320
 321   return self->priv->channel;
 322 }