← Back to branch summary

~bcurtiswx/ubuntu/precise/empathy/3.4.2.1-0ubuntu1

« back to all changes in this revision

Viewing changes to libempathy/gossip-contact.c

  • Committer: Bazaar Package Importer
  • Author(s): Sjoerd Simons
  • Date: 2007-05-20 15:31:42 UTC
  • Revision ID: james.westby@ubuntu.com-20070520153142-r3auwguxdgxhktqb
Tags: upstream-0.4
Import upstream version 0.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
libempathy/gossip-contact.c
 
1
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
 
2
/*
 
3
 * Copyright (C) 2004-2007 Imendio AB
 
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., 59 Temple Place - Suite 330,
 
18
 * Boston, MA 02111-1307, USA.
 
19
 *
 
20
 * Authors: Mikael Hallendal <micke@imendio.com>
 
21
 *          Martyn Russell <martyn@imendio.com>
 
22
 */
 
23
 
 
24
#include "config.h"
 
25
 
 
26
#include <string.h>
 
27
 
 
28
#include <glib/gi18n.h>
 
29
 
 
30
#include "gossip-contact.h"
 
31
#include "gossip-utils.h"
 
32
#include "gossip-debug.h"
 
33
#include "empathy-contact-manager.h"
 
34
 
 
35
#define DEBUG_DOMAIN "Contact"
 
36
 
 
37
#define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GOSSIP_TYPE_CONTACT, GossipContactPriv))
 
38
 
 
39
typedef struct _GossipContactPriv GossipContactPriv;
 
40
 
 
41
struct _GossipContactPriv {
 
42
        gchar              *id;
 
43
        gchar              *name;
 
44
        GossipAvatar       *avatar;
 
45
        McAccount          *account;
 
46
        GossipPresence     *presence;
 
47
        GList              *groups;
 
48
        GossipSubscription  subscription;
 
49
        guint               handle;
 
50
};
 
51
 
 
52
static void contact_class_init    (GossipContactClass *class);
 
53
static void contact_init          (GossipContact      *contact);
 
54
static void contact_finalize      (GObject            *object);
 
55
static void contact_get_property  (GObject            *object,
 
56
                                   guint               param_id,
 
57
                                   GValue             *value,
 
58
                                   GParamSpec         *pspec);
 
59
static void contact_set_property  (GObject            *object,
 
60
                                   guint               param_id,
 
61
                                   const GValue       *value,
 
62
                                   GParamSpec         *pspec);
 
63
 
 
64
enum {
 
65
        PROP_0,
 
66
        PROP_ID,
 
67
        PROP_NAME,
 
68
        PROP_AVATAR,
 
69
        PROP_ACCOUNT,
 
70
        PROP_PRESENCE,
 
71
        PROP_GROUPS,
 
72
        PROP_SUBSCRIPTION,
 
73
        PROP_HANDLE
 
74
};
 
75
 
 
76
static gpointer parent_class = NULL;
 
77
 
 
78
GType
 
79
gossip_contact_get_gtype (void)
 
80
{
 
81
        static GType type = 0;
 
82
 
 
83
        if (!type) {
 
84
                static const GTypeInfo info = {
 
85
                        sizeof (GossipContactClass),
 
86
                        NULL, /* base_init */
 
87
                        NULL, /* base_finalize */
 
88
                        (GClassInitFunc) contact_class_init,
 
89
                        NULL, /* class_finalize */
 
90
                        NULL, /* class_data */
 
91
                        sizeof (GossipContact),
 
92
                        0,    /* n_preallocs */
 
93
                        (GInstanceInitFunc) contact_init
 
94
                };
 
95
 
 
96
                type = g_type_register_static (G_TYPE_OBJECT,
 
97
                                               "GossipContact",
 
98
                                               &info, 0);
 
99
        }
 
100
 
 
101
        return type;
 
102
}
 
103
 
 
104
static void
 
105
contact_class_init (GossipContactClass *class)
 
106
{
 
107
        GObjectClass *object_class;
 
108
 
 
109
        object_class = G_OBJECT_CLASS (class);
 
110
        parent_class = g_type_class_peek_parent (class);
 
111
 
 
112
        object_class->finalize     = contact_finalize;
 
113
        object_class->get_property = contact_get_property;
 
114
        object_class->set_property = contact_set_property;
 
115
 
 
116
        g_object_class_install_property (object_class,
 
117
                                         PROP_ID,
 
118
                                         g_param_spec_string ("id",
 
119
                                                              "Contact id",
 
120
                                                              "String identifying contact",
 
121
                                                              NULL,
 
122
                                                              G_PARAM_READWRITE));
 
123
 
 
124
        g_object_class_install_property (object_class,
 
125
                                         PROP_NAME,
 
126
                                         g_param_spec_string ("name",
 
127
                                                              "Contact Name",
 
128
                                                              "The name of the contact",
 
129
                                                              NULL,
 
130
                                                              G_PARAM_READWRITE));
 
131
 
 
132
        g_object_class_install_property (object_class,
 
133
                                         PROP_AVATAR,
 
134
                                         g_param_spec_boxed ("avatar",
 
135
                                                             "Avatar image",
 
136
                                                             "The avatar image",
 
137
                                                             GOSSIP_TYPE_AVATAR,
 
138
                                                             G_PARAM_READWRITE));
 
139
 
 
140
        g_object_class_install_property (object_class,
 
141
                                         PROP_ACCOUNT,
 
142
                                         g_param_spec_object ("account",
 
143
                                                              "Contact Account",
 
144
                                                              "The account associated with the contact",
 
145
                                                              MC_TYPE_ACCOUNT,
 
146
                                                              G_PARAM_READWRITE));
 
147
 
 
148
        g_object_class_install_property (object_class,
 
149
                                         PROP_PRESENCE,
 
150
                                         g_param_spec_object ("presence",
 
151
                                                              "Contact presence",
 
152
                                                              "Presence of contact",
 
153
                                                              GOSSIP_TYPE_PRESENCE,
 
154
                                                              G_PARAM_READWRITE));
 
155
 
 
156
        g_object_class_install_property (object_class,
 
157
                                         PROP_GROUPS,
 
158
                                         g_param_spec_pointer ("groups",
 
159
                                                               "Contact groups",
 
160
                                                               "Groups of contact",
 
161
                                                               G_PARAM_READWRITE));
 
162
 
 
163
        g_object_class_install_property (object_class,
 
164
                                         PROP_SUBSCRIPTION,
 
165
                                         g_param_spec_int ("subscription",
 
166
                                                           "Contact Subscription",
 
167
                                                           "The subscription status of the contact",
 
168
                                                           GOSSIP_SUBSCRIPTION_NONE,
 
169
                                                           GOSSIP_SUBSCRIPTION_BOTH,
 
170
                                                           GOSSIP_SUBSCRIPTION_NONE,
 
171
                                                           G_PARAM_READWRITE));
 
172
 
 
173
 
 
174
        g_object_class_install_property (object_class,
 
175
                                         PROP_HANDLE,
 
176
                                         g_param_spec_uint ("handle",
 
177
                                                            "Contact Handle",
 
178
                                                            "The handle of the contact",
 
179
                                                            0,
 
180
                                                            G_MAXUINT,
 
181
                                                            0,
 
182
                                                            G_PARAM_READWRITE));
 
183
 
 
184
        g_type_class_add_private (object_class, sizeof (GossipContactPriv));
 
185
}
 
186
 
 
187
static void
 
188
contact_init (GossipContact *contact)
 
189
{
 
190
        GossipContactPriv *priv;
 
191
 
 
192
        priv = GET_PRIV (contact);
 
193
 
 
194
        priv->id       = NULL;
 
195
        priv->name     = NULL;
 
196
        priv->avatar   = NULL;
 
197
        priv->account  = NULL;
 
198
        priv->presence = NULL;
 
199
        priv->groups   = NULL;
 
200
        priv->handle   = 0;
 
201
}
 
202
 
 
203
static void
 
204
contact_finalize (GObject *object)
 
205
{
 
206
        GossipContactPriv *priv;
 
207
 
 
208
        priv = GET_PRIV (object);
 
209
 
 
210
        gossip_debug (DEBUG_DOMAIN, "finalize: %p", object);
 
211
 
 
212
        g_free (priv->name);
 
213
        g_free (priv->id);
 
214
 
 
215
        if (priv->avatar) {
 
216
                gossip_avatar_unref (priv->avatar);
 
217
        }
 
218
 
 
219
        if (priv->presence) {
 
220
                g_object_unref (priv->presence);
 
221
        }
 
222
 
 
223
        if (priv->groups) {
 
224
                g_list_foreach (priv->groups, (GFunc) g_free, NULL);
 
225
                g_list_free (priv->groups);
 
226
        }
 
227
 
 
228
        if (priv->account) {
 
229
                g_object_unref (priv->account);
 
230
        }
 
231
 
 
232
        (G_OBJECT_CLASS (parent_class)->finalize) (object);
 
233
}
 
234
 
 
235
static void
 
236
contact_get_property (GObject    *object,
 
237
                      guint       param_id,
 
238
                      GValue     *value,
 
239
                      GParamSpec *pspec)
 
240
{
 
241
        GossipContactPriv *priv;
 
242
 
 
243
        priv = GET_PRIV (object);
 
244
 
 
245
        switch (param_id) {
 
246
        case PROP_ID:
 
247
                g_value_set_string (value,
 
248
                                    gossip_contact_get_id (GOSSIP_CONTACT (object)));
 
249
                break;
 
250
        case PROP_NAME:
 
251
                g_value_set_string (value,
 
252
                                    gossip_contact_get_name (GOSSIP_CONTACT (object)));
 
253
                break;
 
254
        case PROP_AVATAR:
 
255
                g_value_set_boxed (value, priv->avatar);
 
256
                break;
 
257
        case PROP_ACCOUNT:
 
258
                g_value_set_object (value, priv->account);
 
259
                break;
 
260
        case PROP_PRESENCE:
 
261
                g_value_set_object (value, priv->presence);
 
262
                break;
 
263
        case PROP_GROUPS:
 
264
                g_value_set_pointer (value, priv->groups);
 
265
                break;
 
266
        case PROP_SUBSCRIPTION:
 
267
                g_value_set_int (value, priv->subscription);
 
268
                break;
 
269
        case PROP_HANDLE:
 
270
                g_value_set_uint (value, priv->handle);
 
271
                break;
 
272
        default:
 
273
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 
274
                break;
 
275
        };
 
276
}
 
277
 
 
278
static void
 
279
contact_set_property (GObject      *object,
 
280
                      guint         param_id,
 
281
                      const GValue *value,
 
282
                      GParamSpec   *pspec)
 
283
{
 
284
        GossipContactPriv *priv;
 
285
 
 
286
        priv = GET_PRIV (object);
 
287
 
 
288
        switch (param_id) {
 
289
        case PROP_ID:
 
290
                gossip_contact_set_id (GOSSIP_CONTACT (object),
 
291
                                       g_value_get_string (value));
 
292
                break;
 
293
        case PROP_NAME:
 
294
                gossip_contact_set_name (GOSSIP_CONTACT (object),
 
295
                                         g_value_get_string (value));
 
296
                break;
 
297
        case PROP_AVATAR:
 
298
                gossip_contact_set_avatar (GOSSIP_CONTACT (object),
 
299
                                           g_value_get_boxed (value));
 
300
                break;
 
301
        case PROP_ACCOUNT:
 
302
                gossip_contact_set_account (GOSSIP_CONTACT (object),
 
303
                                            MC_ACCOUNT (g_value_get_object (value)));
 
304
                break;
 
305
        case PROP_PRESENCE:
 
306
                gossip_contact_set_presence (GOSSIP_CONTACT (object),
 
307
                                             GOSSIP_PRESENCE (g_value_get_object (value)));
 
308
                break;
 
309
        case PROP_GROUPS:
 
310
                gossip_contact_set_groups (GOSSIP_CONTACT (object),
 
311
                                           g_value_get_pointer (value));
 
312
                break;
 
313
        case PROP_SUBSCRIPTION:
 
314
                gossip_contact_set_subscription (GOSSIP_CONTACT (object),
 
315
                                                 g_value_get_int (value));
 
316
                break;
 
317
        case PROP_HANDLE:
 
318
                gossip_contact_set_handle (GOSSIP_CONTACT (object),
 
319
                                           g_value_get_uint (value));
 
320
                break;
 
321
        default:
 
322
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 
323
                break;
 
324
        };
 
325
}
 
326
 
 
327
GossipContact *
 
328
gossip_contact_new (McAccount *account)
 
329
{
 
330
        return g_object_new (GOSSIP_TYPE_CONTACT,
 
331
                             "account", account,
 
332
                             NULL);
 
333
}
 
334
 
 
335
GossipContact *
 
336
gossip_contact_new_full (McAccount *account,
 
337
                         const gchar   *id,
 
338
                         const gchar   *name)
 
339
{
 
340
        return g_object_new (GOSSIP_TYPE_CONTACT,
 
341
                             "account", account,
 
342
                             "name", name,
 
343
                             "id", id,
 
344
                             NULL);
 
345
}
 
346
 
 
347
const gchar *
 
348
gossip_contact_get_id (GossipContact *contact)
 
349
{
 
350
        GossipContactPriv *priv;
 
351
 
 
352
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), "");
 
353
 
 
354
        priv = GET_PRIV (contact);
 
355
 
 
356
        if (priv->id) {
 
357
                return priv->id;
 
358
        }
 
359
 
 
360
        return "";
 
361
}
 
362
 
 
363
const gchar *
 
364
gossip_contact_get_name (GossipContact *contact)
 
365
{
 
366
        GossipContactPriv *priv;
 
367
 
 
368
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), "");
 
369
 
 
370
        priv = GET_PRIV (contact);
 
371
 
 
372
        if (priv->name == NULL) {
 
373
                return gossip_contact_get_id (contact);
 
374
        }
 
375
 
 
376
        return priv->name;
 
377
}
 
378
 
 
379
GossipAvatar *
 
380
gossip_contact_get_avatar (GossipContact *contact)
 
381
{
 
382
        GossipContactPriv *priv;
 
383
 
 
384
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), NULL);
 
385
 
 
386
        priv = GET_PRIV (contact);
 
387
 
 
388
        return priv->avatar;
 
389
}
 
390
 
 
391
McAccount *
 
392
gossip_contact_get_account (GossipContact *contact)
 
393
{
 
394
        GossipContactPriv *priv;
 
395
 
 
396
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), NULL);
 
397
 
 
398
        priv = GET_PRIV (contact);
 
399
 
 
400
        return priv->account;
 
401
}
 
402
 
 
403
GossipPresence *
 
404
gossip_contact_get_presence (GossipContact *contact)
 
405
{
 
406
        GossipContactPriv *priv;
 
407
 
 
408
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), NULL);
 
409
 
 
410
        priv = GET_PRIV (contact);
 
411
 
 
412
        return priv->presence;
 
413
}
 
414
 
 
415
GList *
 
416
gossip_contact_get_groups (GossipContact *contact)
 
417
{
 
418
        GossipContactPriv *priv;
 
419
 
 
420
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), NULL);
 
421
 
 
422
        priv = GET_PRIV (contact);
 
423
 
 
424
        return priv->groups;
 
425
}
 
426
 
 
427
GossipSubscription
 
428
gossip_contact_get_subscription (GossipContact *contact)
 
429
{
 
430
        GossipContactPriv *priv;
 
431
 
 
432
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact),
 
433
                              GOSSIP_SUBSCRIPTION_NONE);
 
434
 
 
435
        priv = GET_PRIV (contact);
 
436
 
 
437
        return priv->subscription;
 
438
}
 
439
 
 
440
guint
 
441
gossip_contact_get_handle (GossipContact *contact)
 
442
{
 
443
        GossipContactPriv *priv;
 
444
 
 
445
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), 0);
 
446
 
 
447
        priv = GET_PRIV (contact);
 
448
 
 
449
        return priv->handle;
 
450
}
 
451
 
 
452
void
 
453
gossip_contact_set_id (GossipContact *contact,
 
454
                       const gchar   *id)
 
455
{
 
456
        GossipContactPriv *priv;
 
457
 
 
458
        g_return_if_fail (GOSSIP_IS_CONTACT (contact));
 
459
        g_return_if_fail (id != NULL);
 
460
 
 
461
        priv = GET_PRIV (contact);
 
462
 
 
463
        g_free (priv->id);
 
464
        priv->id = g_strdup (id);
 
465
 
 
466
        g_object_notify (G_OBJECT (contact), "id");
 
467
}
 
468
 
 
469
void
 
470
gossip_contact_set_name (GossipContact *contact,
 
471
                         const gchar   *name)
 
472
{
 
473
        GossipContactPriv *priv;
 
474
 
 
475
        g_return_if_fail (GOSSIP_IS_CONTACT (contact));
 
476
        g_return_if_fail (name != NULL);
 
477
 
 
478
        priv = GET_PRIV (contact);
 
479
 
 
480
        g_free (priv->name);
 
481
        priv->name = g_strdup (name);
 
482
 
 
483
        g_object_notify (G_OBJECT (contact), "name");
 
484
}
 
485
 
 
486
void
 
487
gossip_contact_set_avatar (GossipContact *contact,
 
488
                           GossipAvatar  *avatar)
 
489
{
 
490
        GossipContactPriv *priv;
 
491
 
 
492
        g_return_if_fail (GOSSIP_IS_CONTACT (contact));
 
493
 
 
494
        priv = GET_PRIV (contact);
 
495
 
 
496
        if (priv->avatar) {
 
497
                gossip_avatar_unref (priv->avatar);
 
498
                priv->avatar = NULL;
 
499
        }
 
500
 
 
501
        if (avatar) {
 
502
                priv->avatar = gossip_avatar_ref (avatar);
 
503
        }
 
504
 
 
505
        g_object_notify (G_OBJECT (contact), "avatar");
 
506
}
 
507
 
 
508
void
 
509
gossip_contact_set_account (GossipContact *contact,
 
510
                            McAccount     *account)
 
511
{
 
512
        GossipContactPriv *priv;
 
513
 
 
514
        g_return_if_fail (GOSSIP_IS_CONTACT (contact));
 
515
        g_return_if_fail (MC_IS_ACCOUNT (account));
 
516
 
 
517
        priv = GET_PRIV (contact);
 
518
 
 
519
        if (priv->account) {
 
520
                g_object_unref (priv->account);
 
521
        }
 
522
        priv->account = g_object_ref (account);
 
523
 
 
524
        g_object_notify (G_OBJECT (contact), "account");
 
525
}
 
526
 
 
527
void
 
528
gossip_contact_set_presence (GossipContact  *contact,
 
529
                             GossipPresence *presence)
 
530
{
 
531
        GossipContactPriv *priv;
 
532
 
 
533
        g_return_if_fail (GOSSIP_IS_CONTACT (contact));
 
534
 
 
535
        priv = GET_PRIV (contact);
 
536
 
 
537
        if (priv->presence) {
 
538
                g_object_unref (priv->presence);
 
539
                priv->presence = NULL;
 
540
        }
 
541
 
 
542
        if (presence) {
 
543
                priv->presence = g_object_ref (presence);
 
544
        }
 
545
 
 
546
        g_object_notify (G_OBJECT (contact), "presence");
 
547
}
 
548
 
 
549
void
 
550
gossip_contact_set_groups (GossipContact *contact,
 
551
                           GList         *groups)
 
552
{
 
553
        GossipContactPriv *priv;
 
554
        GList             *old_groups, *l;
 
555
 
 
556
        g_return_if_fail (GOSSIP_IS_CONTACT (contact));
 
557
 
 
558
        priv = GET_PRIV (contact);
 
559
 
 
560
        old_groups = priv->groups;
 
561
        priv->groups = NULL;
 
562
 
 
563
        for (l = groups; l; l = l->next) {
 
564
                priv->groups = g_list_append (priv->groups,
 
565
                                              g_strdup (l->data));
 
566
        }
 
567
 
 
568
        g_list_foreach (old_groups, (GFunc) g_free, NULL);
 
569
        g_list_free (old_groups);
 
570
 
 
571
        g_object_notify (G_OBJECT (contact), "groups");
 
572
}
 
573
 
 
574
void
 
575
gossip_contact_set_subscription (GossipContact      *contact,
 
576
                                 GossipSubscription  subscription)
 
577
{
 
578
        GossipContactPriv *priv;
 
579
 
 
580
        g_return_if_fail (GOSSIP_IS_CONTACT (contact));
 
581
 
 
582
        priv = GET_PRIV (contact);
 
583
 
 
584
        priv->subscription = subscription;
 
585
 
 
586
        g_object_notify (G_OBJECT (contact), "subscription");
 
587
}
 
588
 
 
589
void
 
590
gossip_contact_set_handle (GossipContact *contact,
 
591
                           guint          handle)
 
592
{
 
593
        GossipContactPriv *priv;
 
594
 
 
595
        priv = GET_PRIV (contact);
 
596
 
 
597
        priv->handle = handle;
 
598
 
 
599
        g_object_notify (G_OBJECT (contact), "handle");
 
600
}
 
601
 
 
602
gboolean
 
603
gossip_contact_is_online (GossipContact *contact)
 
604
{
 
605
        GossipContactPriv *priv;
 
606
 
 
607
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), FALSE);
 
608
 
 
609
        priv = GET_PRIV (contact);
 
610
 
 
611
        return (priv->presence != NULL);
 
612
}
 
613
 
 
614
gboolean
 
615
gossip_contact_is_in_group (GossipContact *contact,
 
616
                            const gchar   *group)
 
617
{
 
618
        GossipContactPriv *priv;
 
619
 
 
620
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), FALSE);
 
621
        g_return_val_if_fail (!G_STR_EMPTY (group), FALSE);
 
622
 
 
623
        priv = GET_PRIV (contact);
 
624
 
 
625
        if (g_list_find_custom (priv->groups, group, (GCompareFunc) strcmp)) {
 
626
                return TRUE;
 
627
        }
 
628
 
 
629
        return FALSE;
 
630
}
 
631
 
 
632
const gchar *
 
633
gossip_contact_get_status (GossipContact *contact)
 
634
{
 
635
        GossipContactPriv *priv;
 
636
 
 
637
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), "");
 
638
 
 
639
        priv = GET_PRIV (contact);
 
640
 
 
641
        if (priv->presence) {
 
642
                const gchar *status;
 
643
 
 
644
                status = gossip_presence_get_status (priv->presence);
 
645
                if (!status) {
 
646
                        McPresence state;
 
647
 
 
648
                        state = gossip_presence_get_state (priv->presence);
 
649
                        status = gossip_presence_state_get_default_status (state);
 
650
                }
 
651
 
 
652
                return status;
 
653
        }
 
654
 
 
655
        return _("Offline");
 
656
}
 
657
 
 
658
GossipContact *
 
659
gossip_contact_get_user (GossipContact *contact)
 
660
{
 
661
        GossipContactPriv     *priv;
 
662
        EmpathyContactManager *manager;
 
663
        GossipContact         *user_contact;
 
664
 
 
665
        g_return_val_if_fail (GOSSIP_IS_CONTACT (contact), NULL);
 
666
 
 
667
        priv = GET_PRIV (contact);
 
668
 
 
669
        manager = empathy_contact_manager_new ();
 
670
        user_contact = empathy_contact_manager_get_user (manager, priv->account);
 
671
        g_object_unref (manager);
 
672
 
 
673
        return user_contact;
 
674
}
 
675
 
 
676
gboolean
 
677
gossip_contact_equal (gconstpointer v1,
 
678
                      gconstpointer v2)
 
679
{
 
680
        McAccount   *account_a;
 
681
        McAccount   *account_b;
 
682
        const gchar *id_a;
 
683
        const gchar *id_b;
 
684
 
 
685
        g_return_val_if_fail (GOSSIP_IS_CONTACT (v1), FALSE);
 
686
        g_return_val_if_fail (GOSSIP_IS_CONTACT (v2), FALSE);
 
687
 
 
688
        account_a = gossip_contact_get_account (GOSSIP_CONTACT (v1));
 
689
        account_b = gossip_contact_get_account (GOSSIP_CONTACT (v2));
 
690
 
 
691
        id_a = gossip_contact_get_id (GOSSIP_CONTACT (v1));
 
692
        id_b = gossip_contact_get_id (GOSSIP_CONTACT (v2));
 
693
 
 
694
        return gossip_account_equal (account_a, account_b) && g_str_equal (id_a, id_b);
 
695
}
 
696
 
 
697
guint
 
698
gossip_contact_hash (gconstpointer key)
 
699
{
 
700
        GossipContactPriv *priv;
 
701
        guint              hash;
 
702
 
 
703
        g_return_val_if_fail (GOSSIP_IS_CONTACT (key), +1);
 
704
 
 
705
        priv = GET_PRIV (GOSSIP_CONTACT (key));
 
706
 
 
707
        hash = gossip_account_hash (gossip_contact_get_account (GOSSIP_CONTACT (key)));
 
708
        hash += g_str_hash (gossip_contact_get_id (GOSSIP_CONTACT (key)));
 
709
 
 
710
        return hash;
 
711
}
 
712