* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- *
+ *
* Authors: Xavier Claessens <xclaesse@gmail.com>
*/
#include <string.h>
+#include <telepathy-glib/account-manager.h>
#include <telepathy-glib/enums.h>
+#include <telepathy-glib/proxy-subclass.h>
+#include <telepathy-glib/util.h>
+
+#include <extensions/extensions.h>
#include "empathy-contact-manager.h"
#include "empathy-contact-list.h"
#include "empathy-utils.h"
-#include "empathy-debug.h"
-#define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
- EMPATHY_TYPE_CONTACT_MANAGER, EmpathyContactManagerPriv))
-
-#define DEBUG_DOMAIN "ContactManager"
+#define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
+#include "empathy-debug.h"
-struct _EmpathyContactManagerPriv {
+#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyContactManager)
+typedef struct {
+ /* Owned (TpConnection *) => Owned (TpContactList *)
+ The contact list associated with each connected connection */
GHashTable *lists;
- MissionControl *mc;
-};
+ TpAccountManager *account_manager;
+ TpProxy *logger;
+ /* account object path (gchar *) => GHashTable containing favorite contacts
+ * (contact ID (gchar *) => TRUE) */
+ GHashTable *favourites;
+ TpProxySignalConnection *favourite_contacts_changed_signal;
+} EmpathyContactManagerPriv;
-static void empathy_contact_manager_class_init (EmpathyContactManagerClass *klass);
-static void empathy_contact_manager_init (EmpathyContactManager *manager);
static void contact_manager_iface_init (EmpathyContactListIface *iface);
G_DEFINE_TYPE_WITH_CODE (EmpathyContactManager, empathy_contact_manager, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (EMPATHY_TYPE_CONTACT_LIST,
contact_manager_iface_init));
+static EmpathyContactManager *manager_singleton = NULL;
+
static void
contact_manager_members_changed_cb (EmpathyTpContactList *list,
EmpathyContact *contact,
contact, group, is_member);
}
-static void contact_manager_destroy_cb (EmpathyTpContactList *list,
- EmpathyContactManager *manager);
+static void
+contact_manager_invalidated_cb (TpProxy *connection,
+ guint domain,
+ gint code,
+ gchar *message,
+ EmpathyContactManager *manager)
+{
+ EmpathyContactManagerPriv *priv = GET_PRIV (manager);
+ EmpathyTpContactList *list;
+
+ DEBUG ("Removing connection: %s (%s)",
+ tp_proxy_get_object_path (TP_PROXY (connection)),
+ message);
+
+ list = g_hash_table_lookup (priv->lists, connection);
+ if (list) {
+ empathy_tp_contact_list_remove_all (list);
+ g_hash_table_remove (priv->lists, connection);
+ }
+}
static void
contact_manager_disconnect_foreach (gpointer key,
gpointer value,
gpointer user_data)
{
+ TpConnection *connection = key;
EmpathyTpContactList *list = value;
EmpathyContactManager *manager = user_data;
g_signal_handlers_disconnect_by_func (list,
contact_manager_groups_changed_cb,
manager);
- g_signal_handlers_disconnect_by_func (list,
- contact_manager_destroy_cb,
+ g_signal_handlers_disconnect_by_func (connection,
+ contact_manager_invalidated_cb,
manager);
}
static void
-contact_manager_destroy_cb (EmpathyTpContactList *list,
- EmpathyContactManager *manager)
+contact_manager_status_changed_cb (TpAccount *account,
+ guint old_status,
+ guint new_status,
+ guint reason,
+ gchar *dbus_error_name,
+ GHashTable *details,
+ EmpathyContactManager *self)
{
- EmpathyContactManagerPriv *priv = GET_PRIV (manager);
- McAccount *account;
-
- account = empathy_tp_contact_list_get_account (list);
-
- empathy_debug (DEBUG_DOMAIN, "Removing account: %s",
- mc_account_get_display_name (account));
-
- contact_manager_disconnect_foreach (account, list, manager);
- g_hash_table_remove (priv->lists, account);
-}
-
-static void
-contact_manager_add_account (EmpathyContactManager *manager,
- McAccount *account)
-{
- EmpathyContactManagerPriv *priv = GET_PRIV (manager);
+ EmpathyContactManagerPriv *priv = GET_PRIV (self);
EmpathyTpContactList *list;
+ TpConnection *connection;
- if (g_hash_table_lookup (priv->lists, account)) {
+ if (new_status == TP_CONNECTION_STATUS_DISCONNECTED)
+ /* No point to start tracking a connection which is about to die */
return;
- }
- empathy_debug (DEBUG_DOMAIN, "Adding new account: %s",
- mc_account_get_display_name (account));
+ connection = tp_account_get_connection (account);
- list = empathy_tp_contact_list_new (account);
- if (!list) {
+ if (connection == NULL || g_hash_table_lookup (priv->lists, connection)) {
return;
}
- g_hash_table_insert (priv->lists, g_object_ref (account), list);
+ DEBUG ("Adding new connection: %s",
+ tp_proxy_get_object_path (TP_PROXY (connection)));
+
+ list = empathy_tp_contact_list_new (connection);
+ g_hash_table_insert (priv->lists, g_object_ref (connection), list);
+ g_signal_connect (connection, "invalidated",
+ G_CALLBACK (contact_manager_invalidated_cb),
+ self);
/* Connect signals */
g_signal_connect (list, "members-changed",
G_CALLBACK (contact_manager_members_changed_cb),
- manager);
+ self);
g_signal_connect (list, "pendings-changed",
G_CALLBACK (contact_manager_pendings_changed_cb),
- manager);
+ self);
g_signal_connect (list, "groups-changed",
G_CALLBACK (contact_manager_groups_changed_cb),
- manager);
- g_signal_connect (list, "destroy",
- G_CALLBACK (contact_manager_destroy_cb),
- manager);
+ self);
}
static void
-contact_manager_status_changed_cb (MissionControl *mc,
- TpConnectionStatus status,
- McPresence presence,
- TpConnectionStatusReason reason,
- const gchar *unique_name,
- EmpathyContactManager *manager)
+contact_manager_validity_changed_cb (TpAccountManager *account_manager,
+ TpAccount *account,
+ gboolean valid,
+ EmpathyContactManager *manager)
{
- McAccount *account;
+ if (valid) {
+ tp_g_signal_connect_object (account, "status-changed",
+ G_CALLBACK (contact_manager_status_changed_cb),
+ manager, 0);
+ }
+}
- if (status != TP_CONNECTION_STATUS_CONNECTED) {
- /* We only care about newly connected accounts */
- return;
+static gboolean
+contact_manager_is_favourite (EmpathyContactList *manager,
+ EmpathyContact *contact)
+{
+ EmpathyContactManagerPriv *priv;
+ TpAccount *account;
+ const gchar *account_name;
+ GHashTable *contact_hash;
+
+ g_return_val_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager), FALSE);
+ g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), FALSE);
+
+ priv = GET_PRIV (manager);
+
+ account = empathy_contact_get_account (contact);
+ account_name = tp_proxy_get_object_path (TP_PROXY (account));
+ contact_hash = g_hash_table_lookup (priv->favourites, account_name);
+
+ if (contact_hash != NULL) {
+ const gchar *contact_id = empathy_contact_get_id (contact);
+
+ if (g_hash_table_lookup (contact_hash, contact_id) != NULL)
+ return TRUE;
}
- account = mc_account_lookup (unique_name);
- contact_manager_add_account (manager, account);
- g_object_unref (account);
+ return FALSE;
+}
+
+static void
+add_favourite_contact_cb (TpProxy *proxy,
+ const GError *error,
+ gpointer user_data,
+ GObject *weak_object)
+{
+ if (error != NULL)
+ DEBUG ("AddFavouriteContact failed: %s", error->message);
+}
+
+static void
+contact_manager_add_favourite (EmpathyContactList *manager,
+ EmpathyContact *contact)
+{
+ EmpathyContactManagerPriv *priv;
+ TpAccount *account;
+ const gchar *account_name;
+
+ g_return_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager));
+ g_return_if_fail (EMPATHY_IS_CONTACT (contact));
+
+ priv = GET_PRIV (manager);
+
+ account = empathy_contact_get_account (contact);
+ account_name = tp_proxy_get_object_path (TP_PROXY (account));
+
+ emp_cli_logger_call_add_favourite_contact (priv->logger, -1,
+ account_name,
+ empathy_contact_get_id (contact),
+ add_favourite_contact_cb, NULL, NULL, G_OBJECT (manager));
+}
+
+static void
+remove_favourite_contact_cb (TpProxy *proxy,
+ const GError *error,
+ gpointer user_data,
+ GObject *weak_object)
+{
+ if (error != NULL)
+ DEBUG ("RemoveFavouriteContact failed: %s", error->message);
+}
+
+static void
+contact_manager_remove_favourite (EmpathyContactList *manager,
+ EmpathyContact *contact)
+{
+ EmpathyContactManagerPriv *priv;
+ TpAccount *account;
+ const gchar *account_name;
+
+ g_return_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager));
+ g_return_if_fail (EMPATHY_IS_CONTACT (contact));
+
+ priv = GET_PRIV (manager);
+
+ account = empathy_contact_get_account (contact);
+ account_name = tp_proxy_get_object_path (TP_PROXY (account));
+
+ emp_cli_logger_call_remove_favourite_contact (priv->logger, -1,
+ account_name,
+ empathy_contact_get_id (contact),
+ remove_favourite_contact_cb, NULL, NULL, G_OBJECT (manager));
+}
+
+static void
+add_contacts_to_favourites (EmpathyContactManager *self,
+ const gchar *account,
+ const gchar **contacts)
+{
+ EmpathyContactManagerPriv *priv = GET_PRIV (self);
+ guint j;
+ GHashTable *contact_hash;
+
+ contact_hash = g_hash_table_lookup (priv->favourites, account);
+ if (contact_hash == NULL) {
+ contact_hash = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ g_free, NULL);
+
+ g_hash_table_insert (priv->favourites,
+ g_strdup (account),
+ contact_hash);
+ }
+
+ for (j = 0; contacts && contacts[j] != NULL; j++) {
+ g_hash_table_insert (contact_hash,
+ g_strdup (contacts[j]),
+ GINT_TO_POINTER (1));
+ }
+}
+
+static void
+logger_favourite_contacts_add_from_value_array (GValueArray *va,
+ EmpathyContactManager *manager)
+{
+ const gchar *account;
+ const gchar **contacts;
+
+ account = g_value_get_boxed (g_value_array_get_nth (va, 0));
+ contacts = g_value_get_boxed (g_value_array_get_nth (va, 1));
+
+ add_contacts_to_favourites (manager, account, contacts);
+}
+
+static void
+logger_favourite_contacts_get_cb (TpProxy *proxy,
+ const GPtrArray *result,
+ const GError *error,
+ gpointer user_data,
+ GObject *weak_object)
+{
+ EmpathyContactManager *manager = EMPATHY_CONTACT_MANAGER (weak_object);
+
+ if (error == NULL) {
+ g_ptr_array_foreach ((GPtrArray *) result,
+ (GFunc)
+ logger_favourite_contacts_add_from_value_array,
+ manager);
+ } else {
+ DEBUG ("Failed to get the FavouriteContacts property: %s",
+ error->message);
+ }
+}
+
+static void
+logger_favourite_contacts_setup (EmpathyContactManager *manager)
+{
+ EmpathyContactManagerPriv *priv = GET_PRIV (manager);
+
+ emp_cli_logger_call_get_favourite_contacts (priv->logger, -1,
+ logger_favourite_contacts_get_cb, NULL, NULL,
+ G_OBJECT (manager));
}
static void
{
EmpathyContactManagerPriv *priv = GET_PRIV (object);
- dbus_g_proxy_disconnect_signal (DBUS_G_PROXY (priv->mc),
- "AccountStatusChanged",
- G_CALLBACK (contact_manager_status_changed_cb),
- object);
+ tp_proxy_signal_connection_disconnect (priv->favourite_contacts_changed_signal);
+
+ if (priv->logger != NULL)
+ g_object_unref (priv->logger);
g_hash_table_foreach (priv->lists,
contact_manager_disconnect_foreach,
object);
g_hash_table_destroy (priv->lists);
- g_object_unref (priv->mc);
+ g_hash_table_destroy (priv->favourites);
+
+ g_object_unref (priv->account_manager);
+}
+
+static GObject *
+contact_manager_constructor (GType type,
+ guint n_props,
+ GObjectConstructParam *props)
+{
+ GObject *retval;
+
+ if (manager_singleton) {
+ retval = g_object_ref (manager_singleton);
+ } else {
+ retval = G_OBJECT_CLASS (empathy_contact_manager_parent_class)->constructor
+ (type, n_props, props);
+
+ manager_singleton = EMPATHY_CONTACT_MANAGER (retval);
+ g_object_add_weak_pointer (retval, (gpointer) &manager_singleton);
+ }
+
+ return retval;
+}
+
+/**
+ * empathy_contact_manager_initialized:
+ *
+ * Reports whether or not the singleton has already been created.
+ *
+ * There can be instances where you want to access the #EmpathyContactManager
+ * only if it has been set up for this process.
+ *
+ * Returns: %TRUE if the #EmpathyContactManager singleton has previously
+ * been initialized.
+ */
+gboolean
+empathy_contact_manager_initialized (void)
+{
+ return (manager_singleton != NULL);
}
static void
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = contact_manager_finalize;
+ object_class->constructor = contact_manager_constructor;
g_type_class_add_private (object_class, sizeof (EmpathyContactManagerPriv));
}
static void
-empathy_contact_manager_init (EmpathyContactManager *manager)
+account_manager_prepared_cb (GObject *source_object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GList *accounts, *l;
+ EmpathyContactManager *manager = user_data;
+ TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
+ GError *error = NULL;
+
+ if (!tp_account_manager_prepare_finish (account_manager, result, &error)) {
+ DEBUG ("Failed to prepare account manager: %s", error->message);
+ g_error_free (error);
+ return;
+ }
+
+ accounts = tp_account_manager_get_valid_accounts (account_manager);
+
+ for (l = accounts; l != NULL; l = l->next) {
+ TpAccount *account = l->data;
+ TpConnection *conn = tp_account_get_connection (account);
+
+ if (conn != NULL) {
+ contact_manager_status_changed_cb (account, 0, 0, 0,
+ NULL, NULL, manager);
+ }
+
+ tp_g_signal_connect_object (account, "status-changed",
+ G_CALLBACK (contact_manager_status_changed_cb),
+ manager, 0);
+ }
+ g_list_free (accounts);
+
+ tp_g_signal_connect_object (account_manager, "account-validity-changed",
+ G_CALLBACK (contact_manager_validity_changed_cb),
+ manager, 0);
+}
+
+static EmpathyContact *
+contact_manager_lookup_contact (EmpathyContactManager *manager,
+ const gchar *account_name,
+ const gchar *contact_id)
+{
+ EmpathyContact *retval = NULL;
+ GList *members, *l;
+
+ /* XXX: any more efficient way to do this (other than having to build
+ * and maintain a hash)? */
+ members = empathy_contact_list_get_members (
+ EMPATHY_CONTACT_LIST (manager));
+ for (l = members; l; l = l->next) {
+ EmpathyContact *contact = l->data;
+ TpAccount *account = empathy_contact_get_account (contact);
+ const gchar *id_cur;
+ const gchar *name_cur;
+
+ id_cur = empathy_contact_get_id (contact);
+ name_cur = tp_proxy_get_object_path (TP_PROXY (account));
+
+ if (!tp_strdiff (contact_id, id_cur) &&
+ !tp_strdiff (account_name, name_cur)) {
+ retval = contact;
+ }
+
+ g_object_unref (contact);
+ }
+
+ g_list_free (members);
+
+ return retval;
+}
+
+static void
+logger_favourite_contacts_changed_cb (TpProxy *proxy,
+ const gchar *account_name,
+ const gchar **added,
+ const gchar **removed,
+ gpointer user_data,
+ GObject *weak_object)
{
EmpathyContactManagerPriv *priv;
- GSList *accounts, *l;
+ EmpathyContactManager *manager = EMPATHY_CONTACT_MANAGER (weak_object);
+ GHashTable *contact_hash;
+ EmpathyContact *contact;
+ gint i;
priv = GET_PRIV (manager);
- priv->lists = g_hash_table_new_full (empathy_account_hash,
- empathy_account_equal,
- (GDestroyNotify) g_object_unref,
- (GDestroyNotify) g_object_unref);
+ contact_hash = g_hash_table_lookup (priv->favourites, account_name);
+
+ /* XXX: note that, at the time of this comment, there will always be
+ * exactly one contact amongst added and removed, so the linear lookup
+ * of each contact isn't as painful as it appears */
+
+ add_contacts_to_favourites (manager, account_name, added);
+
+ for (i = 0; added && added[i]; i++) {
+ contact = contact_manager_lookup_contact (manager, account_name,
+ added[i]);
+ if (contact != NULL)
+ g_signal_emit_by_name (manager, "favourites-changed",
+ contact, TRUE);
+ else
+ DEBUG ("failed to find contact for account %s, contact "
+ "id %s", account_name, added[i]);
+ }
+
+ for (i = 0; removed && removed[i]; i++) {
+ contact_hash = g_hash_table_lookup (priv->favourites,
+ account_name);
- priv->mc = empathy_mission_control_new ();
+ if (contact_hash != NULL) {
+ g_hash_table_remove (contact_hash, removed[i]);
- empathy_connect_to_account_status_changed (priv->mc,
- G_CALLBACK (contact_manager_status_changed_cb),
- manager, NULL);
+ if (g_hash_table_size (contact_hash) < 1) {
+ g_hash_table_remove (priv->favourites,
+ account_name);
+ }
+ }
- /* Get ContactList for existing connections */
- accounts = mission_control_get_online_connections (priv->mc, NULL);
- for (l = accounts; l; l = l->next) {
- contact_manager_add_account (manager, l->data);
- g_object_unref (l->data);
+ contact = contact_manager_lookup_contact (manager, account_name,
+ removed[i]);
+ if (contact != NULL)
+ g_signal_emit_by_name (manager, "favourites-changed",
+ contact, FALSE);
+ else
+ DEBUG ("failed to find contact for account %s, contact "
+ "id %s", account_name, removed[i]);
}
- g_slist_free (accounts);
}
-EmpathyContactManager *
-empathy_contact_manager_new (void)
+static void
+empathy_contact_manager_init (EmpathyContactManager *manager)
{
- static EmpathyContactManager *manager = NULL;
+ EmpathyContactManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
+ EMPATHY_TYPE_CONTACT_MANAGER, EmpathyContactManagerPriv);
+ TpDBusDaemon *bus;
+ GError *error = NULL;
+
+ manager->priv = priv;
+ priv->lists = g_hash_table_new_full (empathy_proxy_hash,
+ empathy_proxy_equal,
+ (GDestroyNotify) g_object_unref,
+ (GDestroyNotify) g_object_unref);
+
+ priv->favourites = g_hash_table_new_full (g_str_hash, g_str_equal,
+ (GDestroyNotify) g_free,
+ (GDestroyNotify)
+ g_hash_table_unref);
+
+ priv->account_manager = tp_account_manager_dup ();
+
+ tp_account_manager_prepare_async (priv->account_manager, NULL,
+ account_manager_prepared_cb, manager);
- if (!manager) {
- manager = g_object_new (EMPATHY_TYPE_CONTACT_MANAGER, NULL);
- g_object_add_weak_pointer (G_OBJECT (manager), (gpointer) &manager);
+ bus = tp_dbus_daemon_dup (&error);
+
+ if (error == NULL) {
+ priv->logger = g_object_new (TP_TYPE_PROXY,
+ "bus-name", "org.freedesktop.Telepathy.Logger",
+ "object-path",
+ "/org/freedesktop/Telepathy/Logger",
+ "dbus-daemon", bus,
+ NULL);
+ g_object_unref (bus);
+
+ tp_proxy_add_interface_by_id (priv->logger,
+ EMP_IFACE_QUARK_LOGGER);
+
+ logger_favourite_contacts_setup (manager);
+
+ priv->favourite_contacts_changed_signal =
+ emp_cli_logger_connect_to_favourite_contacts_changed (
+ priv->logger,
+ logger_favourite_contacts_changed_cb, NULL,
+ NULL, G_OBJECT (manager), NULL);
} else {
- g_object_ref (manager);
+ DEBUG ("Failed to get telepathy-logger proxy: %s",
+ error->message);
+ g_clear_error (&error);
}
+}
- return manager;
+EmpathyContactManager *
+empathy_contact_manager_dup_singleton (void)
+{
+ return g_object_new (EMPATHY_TYPE_CONTACT_MANAGER, NULL);
}
EmpathyTpContactList *
empathy_contact_manager_get_list (EmpathyContactManager *manager,
- McAccount *account)
+ TpConnection *connection)
{
EmpathyContactManagerPriv *priv = GET_PRIV (manager);
g_return_val_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager), NULL);
- g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
+ g_return_val_if_fail (TP_IS_CONNECTION (connection), NULL);
- return g_hash_table_lookup (priv->lists, account);
+ return g_hash_table_lookup (priv->lists, connection);
}
static void
{
EmpathyContactManagerPriv *priv = GET_PRIV (manager);
EmpathyContactList *list;
- McAccount *account;
+ TpConnection *connection;
g_return_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager));
- account = empathy_contact_get_account (contact);
- list = g_hash_table_lookup (priv->lists, account);
+ connection = empathy_contact_get_connection (contact);
+ list = g_hash_table_lookup (priv->lists, connection);
if (list) {
empathy_contact_list_add (list, contact, message);
static void
contact_manager_remove (EmpathyContactList *manager,
- EmpathyContact *contact,
+ EmpathyContact *contact,
const gchar *message)
{
EmpathyContactManagerPriv *priv = GET_PRIV (manager);
EmpathyContactList *list;
- McAccount *account;
+ TpConnection *connection;
g_return_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager));
- account = empathy_contact_get_account (contact);
- list = g_hash_table_lookup (priv->lists, account);
+ connection = empathy_contact_get_connection (contact);
+ list = g_hash_table_lookup (priv->lists, connection);
if (list) {
empathy_contact_list_remove (list, contact, message);
}
static void
-contact_manager_get_members_foreach (McAccount *account,
+contact_manager_get_members_foreach (TpConnection *connection,
EmpathyTpContactList *list,
GList **contacts)
{
}
static void
-contact_manager_get_pendings_foreach (McAccount *account,
+contact_manager_get_pendings_foreach (TpConnection *connection,
EmpathyTpContactList *list,
GList **contacts)
{
}
static void
-contact_manager_get_all_groups_foreach (McAccount *account,
+contact_manager_get_all_groups_foreach (TpConnection *connection,
EmpathyTpContactList *list,
GList **all_groups)
{
{
EmpathyContactManagerPriv *priv = GET_PRIV (manager);
EmpathyContactList *list;
- McAccount *account;
+ TpConnection *connection;
g_return_val_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager), NULL);
- account = empathy_contact_get_account (contact);
- list = g_hash_table_lookup (priv->lists, account);
+ connection = empathy_contact_get_connection (contact);
+ list = g_hash_table_lookup (priv->lists, connection);
if (list) {
return empathy_contact_list_get_groups (list, contact);
{
EmpathyContactManagerPriv *priv = GET_PRIV (manager);
EmpathyContactList *list;
- McAccount *account;
+ TpConnection *connection;
g_return_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager));
- account = empathy_contact_get_account (contact);
- list = g_hash_table_lookup (priv->lists, account);
+ connection = empathy_contact_get_connection (contact);
+ list = g_hash_table_lookup (priv->lists, connection);
if (list) {
empathy_contact_list_add_to_group (list, contact, group);
{
EmpathyContactManagerPriv *priv = GET_PRIV (manager);
EmpathyContactList *list;
- McAccount *account;
+ TpConnection *connection;
g_return_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager));
- account = empathy_contact_get_account (contact);
- list = g_hash_table_lookup (priv->lists, account);
+ connection = empathy_contact_get_connection (contact);
+ list = g_hash_table_lookup (priv->lists, connection);
if (list) {
empathy_contact_list_remove_from_group (list, contact, group);
} RenameGroupData;
static void
-contact_manager_rename_group_foreach (McAccount *account,
+contact_manager_rename_group_foreach (TpConnection *connection,
EmpathyTpContactList *list,
RenameGroupData *data)
{
&data);
}
-static void contact_manager_remove_group_foreach (McAccount *account,
+static void contact_manager_remove_group_foreach (TpConnection *connection,
EmpathyTpContactList *list,
const gchar *group)
{
const gchar *group)
{
EmpathyContactManagerPriv *priv = GET_PRIV (manager);
-
+
g_return_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager));
g_hash_table_foreach (priv->lists,
iface->remove_from_group = contact_manager_remove_from_group;
iface->rename_group = contact_manager_rename_group;
iface->remove_group = contact_manager_remove_group;
+ iface->is_favourite = contact_manager_is_favourite;
+ iface->remove_favourite = contact_manager_remove_favourite;
+ iface->add_favourite = contact_manager_add_favourite;
+}
+
+EmpathyContactListFlags
+empathy_contact_manager_get_flags_for_connection (
+ EmpathyContactManager *manager,
+ TpConnection *connection)
+{
+ EmpathyContactManagerPriv *priv = GET_PRIV (manager);
+ EmpathyContactList *list;
+ EmpathyContactListFlags flags;
+
+ g_return_val_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager), FALSE);
+ g_return_val_if_fail (connection != NULL, FALSE);
+
+ list = g_hash_table_lookup (priv->lists, connection);
+ if (list == NULL) {
+ return FALSE;
+ }
+ flags = empathy_contact_list_get_flags (list);
+
+ return flags;
}
projects / empathy.git / blobdiff