libempathy-gtk/empathy-individual-store-manager.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 "empathy-individual-store-manager.h"
  29
  30 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
  31 #include "empathy-debug.h"
  32
  33 struct _EmpathyIndividualStoreManagerPriv
  34 {
  35   EmpathyIndividualManager *manager;
  36   gboolean setup_idle_id;
  37 };
  38
  39 enum
  40 {
  41   PROP_0,
  42   PROP_INDIVIDUAL_MANAGER,
  43 };
  44
  45
  46 G_DEFINE_TYPE (EmpathyIndividualStoreManager, empathy_individual_store_manager,
  47     EMPATHY_TYPE_INDIVIDUAL_STORE);
  48
  49 static void
  50 individual_store_manager_members_changed_cb (EmpathyIndividualManager *manager,
  51     const gchar *message,
  52     GList *added,
  53     GList *removed,
  54     guint reason,
  55     EmpathyIndividualStoreManager *self)
  56 {
  57   GList *l;
  58   EmpathyIndividualStore *store = EMPATHY_INDIVIDUAL_STORE (self);
  59
  60   for (l = removed; l; l = l->next)
  61     {
  62       DEBUG ("Individual %s (%s) %s",
  63           folks_individual_get_id (l->data),
  64           folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (l->data)),
  65           "removed");
  66
  67       individual_store_remove_individual_and_disconnect (store, l->data);
  68     }
  69
  70   for (l = added; l; l = l->next)
  71     {
  72       DEBUG ("Individual %s (%s) %s", folks_individual_get_id (l->data),
  73           folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (l->data)),
  74           "added");
  75
  76       individual_store_add_individual_and_connect (store, l->data);
  77     }
  78 }
  79
  80 static void
  81 individual_store_manager_groups_changed_cb (EmpathyIndividualManager *manager,
  82     FolksIndividual *individual,
  83     gchar *group,
  84     gboolean is_member,
  85     EmpathyIndividualStoreManager *self)
  86 {
  87   EmpathyIndividualStore *store = EMPATHY_INDIVIDUAL_STORE (self);
  88
  89   DEBUG ("Updating groups for individual %s (%s)",
  90       folks_individual_get_id (individual),
  91       folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual)));
  92
  93   /* We do this to make sure the groups are correct, if not, we
  94    * would have to check the groups already set up for each
  95    * contact and then see what has been updated.
  96    */
  97   empathy_individual_store_refresh_individual (store, individual);
  98 }
  99
 100 static gboolean
 101 individual_store_manager_manager_setup (gpointer user_data)
 102 {
 103   EmpathyIndividualStoreManager *self = user_data;
 104   GList *individuals;
 105
 106   /* Signal connection. */
 107
 108   DEBUG ("handling individual renames unimplemented");
 109
 110   g_signal_connect (self->priv->manager,
 111       "members-changed",
 112       G_CALLBACK (individual_store_manager_members_changed_cb), self);
 113
 114   g_signal_connect (self->priv->manager,
 115       "groups-changed",
 116       G_CALLBACK (individual_store_manager_groups_changed_cb), self);
 117
 118   /* Add contacts already created. */
 119   individuals = empathy_individual_manager_get_members (self->priv->manager);
 120   if (individuals != NULL)
 121     {
 122       individual_store_manager_members_changed_cb (self->priv->manager, "initial add",
 123           individuals, NULL, 0, self);
 124       g_list_free (individuals);
 125     }
 126
 127   self->priv->setup_idle_id = 0;
 128   return FALSE;
 129 }
 130
 131 static void
 132 individual_store_manager_set_individual_manager (
 133     EmpathyIndividualStoreManager *self,
 134     EmpathyIndividualManager *manager)
 135 {
 136   g_assert (self->priv->manager == NULL); /* construct only */
 137   self->priv->manager = g_object_ref (manager);
 138
 139   /* Let a chance to have all properties set before populating */
 140   self->priv->setup_idle_id = g_idle_add (
 141       individual_store_manager_manager_setup, self);
 142 }
 143
 144 static void
 145 individual_store_manager_member_renamed_cb (EmpathyIndividualManager *manager,
 146     FolksIndividual *old_individual,
 147     FolksIndividual *new_individual,
 148     guint reason,
 149     const gchar *message,
 150     EmpathyIndividualStoreManager *self)
 151 {
 152   EmpathyIndividualStore *store = EMPATHY_INDIVIDUAL_STORE (self);
 153
 154   DEBUG ("Individual %s (%s) renamed to %s",
 155       folks_individual_get_id (old_individual),
 156       folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (old_individual)),
 157       folks_individual_get_id (new_individual));
 158
 159   /* remove old contact */
 160   individual_store_remove_individual_and_disconnect (store, old_individual);
 161
 162   /* add the new contact */
 163   individual_store_add_individual_and_connect (store, new_individual);
 164 }
 165
 166 static void
 167 individual_store_manager_dispose (GObject *object)
 168 {
 169   EmpathyIndividualStoreManager *self = EMPATHY_INDIVIDUAL_STORE_MANAGER (
 170       object);
 171   EmpathyIndividualStore *store = EMPATHY_INDIVIDUAL_STORE (object);
 172   GList *individuals, *l;
 173
 174   individuals = empathy_individual_manager_get_members (self->priv->manager);
 175   for (l = individuals; l; l = l->next)
 176     {
 177       empathy_individual_store_disconnect_individual (store,
 178           FOLKS_INDIVIDUAL (l->data));
 179     }
 180   tp_clear_pointer (&individuals, g_list_free);
 181
 182   if (self->priv->manager != NULL)
 183     {
 184       g_signal_handlers_disconnect_by_func (self->priv->manager,
 185           G_CALLBACK (individual_store_manager_member_renamed_cb), object);
 186       g_signal_handlers_disconnect_by_func (self->priv->manager,
 187           G_CALLBACK (individual_store_manager_members_changed_cb), object);
 188       g_signal_handlers_disconnect_by_func (self->priv->manager,
 189           G_CALLBACK (individual_store_manager_groups_changed_cb), object);
 190       g_clear_object (&self->priv->manager);
 191     }
 192
 193   if (self->priv->setup_idle_id != 0)
 194     {
 195       g_source_remove (self->priv->setup_idle_id);
 196       self->priv->setup_idle_id = 0;
 197     }
 198
 199   G_OBJECT_CLASS (empathy_individual_store_manager_parent_class)->dispose (
 200       object);
 201 }
 202
 203 static void
 204 individual_store_manager_get_property (GObject *object,
 205     guint param_id,
 206     GValue *value,
 207     GParamSpec *pspec)
 208 {
 209   EmpathyIndividualStoreManager *self = EMPATHY_INDIVIDUAL_STORE_MANAGER (
 210       object);
 211
 212   switch (param_id)
 213     {
 214     case PROP_INDIVIDUAL_MANAGER:
 215       g_value_set_object (value, self->priv->manager);
 216       break;
 217     default:
 218       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 219       break;
 220     };
 221 }
 222
 223 static void
 224 individual_store_manager_set_property (GObject *object,
 225     guint param_id,
 226     const GValue *value,
 227     GParamSpec *pspec)
 228 {
 229   switch (param_id)
 230     {
 231     case PROP_INDIVIDUAL_MANAGER:
 232       individual_store_manager_set_individual_manager (
 233           EMPATHY_INDIVIDUAL_STORE_MANAGER (object),
 234           g_value_get_object (value));
 235       break;
 236     default:
 237       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 238       break;
 239     };
 240 }
 241
 242 static void
 243 individual_store_manager_reload_individuals (EmpathyIndividualStore *store)
 244 {
 245   EmpathyIndividualStoreManager *self = EMPATHY_INDIVIDUAL_STORE_MANAGER (
 246       store);
 247   GList *contacts;
 248
 249   contacts = empathy_individual_manager_get_members (self->priv->manager);
 250
 251   individual_store_manager_members_changed_cb (self->priv->manager,
 252       "re-adding members: toggled group visibility",
 253       contacts, NULL, 0, self);
 254
 255   g_list_free (contacts);
 256 }
 257
 258 static gboolean
 259 individual_store_manager_initial_loading (EmpathyIndividualStore *store)
 260 {
 261   EmpathyIndividualStoreManager *self = EMPATHY_INDIVIDUAL_STORE_MANAGER (
 262       store);
 263
 264   return self->priv->setup_idle_id != 0;
 265 }
 266
 267 static void
 268 empathy_individual_store_manager_class_init (
 269     EmpathyIndividualStoreManagerClass *klass)
 270 {
 271   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 272   EmpathyIndividualStoreClass *store_class = EMPATHY_INDIVIDUAL_STORE_CLASS (
 273       klass);
 274
 275   object_class->dispose = individual_store_manager_dispose;
 276   object_class->get_property = individual_store_manager_get_property;
 277   object_class->set_property = individual_store_manager_set_property;
 278
 279   store_class->reload_individuals = individual_store_manager_reload_individuals;
 280   store_class->initial_loading = individual_store_manager_initial_loading;
 281
 282   g_object_class_install_property (object_class,
 283       PROP_INDIVIDUAL_MANAGER,
 284       g_param_spec_object ("individual-manager",
 285           "Individual manager",
 286           "Individual manager",
 287           EMPATHY_TYPE_INDIVIDUAL_MANAGER,
 288           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
 289
 290   g_type_class_add_private (object_class,
 291       sizeof (EmpathyIndividualStoreManagerPriv));
 292 }
 293
 294 static void
 295 empathy_individual_store_manager_init (EmpathyIndividualStoreManager *self)
 296 {
 297   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 298       EMPATHY_TYPE_INDIVIDUAL_STORE_MANAGER, EmpathyIndividualStoreManagerPriv);
 299 }
 300
 301 EmpathyIndividualStoreManager *
 302 empathy_individual_store_manager_new (EmpathyIndividualManager *manager)
 303 {
 304   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (manager), NULL);
 305
 306   return g_object_new (EMPATHY_TYPE_INDIVIDUAL_STORE_MANAGER,
 307       "individual-manager", manager, NULL);
 308 }
 309
 310 EmpathyIndividualManager *
 311 empathy_individual_store_manager_get_manager (
 312     EmpathyIndividualStoreManager *self)
 313 {
 314   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_STORE_MANAGER (self), FALSE);
 315
 316   return self->priv->manager;
 317 }