libempathy/empathy-chatroom.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007-2008 Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library 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  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  * Authors: Xavier Claessens <xclaesse@gmail.com>
  20  */
  21
  22 #include "config.h"
  23
  24 #include <string.h>
  25
  26 #include <glib.h>
  27 #include <telepathy-glib/util.h>
  28
  29 #include "empathy-chatroom.h"
  30 #include "empathy-utils.h"
  31
  32 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyChatroom)
  33 typedef struct {
  34         McAccount *account;
  35         gchar     *room;
  36         gchar     *name;
  37         gboolean   auto_connect;
  38         gboolean favorite;
  39         EmpathyTpChat *tp_chat;
  40 } EmpathyChatroomPriv;
  41
  42
  43 static void chatroom_finalize          (GObject             *object);
  44 static void chatroom_get_property      (GObject             *object,
  45                                         guint                param_id,
  46                                         GValue              *value,
  47                                         GParamSpec          *pspec);
  48 static void chatroom_set_property      (GObject             *object,
  49                                         guint                param_id,
  50                                         const GValue        *value,
  51                                         GParamSpec          *pspec);
  52
  53 enum {
  54         PROP_0,
  55         PROP_ACCOUNT,
  56         PROP_ROOM,
  57         PROP_NAME,
  58         PROP_AUTO_CONNECT,
  59         PROP_FAVORITE,
  60         PROP_TP_CHAT,
  61 };
  62
  63 G_DEFINE_TYPE (EmpathyChatroom, empathy_chatroom, G_TYPE_OBJECT);
  64
  65 static void
  66 empathy_chatroom_class_init (EmpathyChatroomClass *klass)
  67 {
  68         GObjectClass *object_class = G_OBJECT_CLASS (klass);
  69
  70         object_class->finalize     = chatroom_finalize;
  71         object_class->get_property = chatroom_get_property;
  72         object_class->set_property = chatroom_set_property;
  73
  74         g_object_class_install_property (object_class,
  75                                          PROP_ACCOUNT,
  76                                          g_param_spec_object ("account",
  77                                                               "Chatroom Account",
  78                                                               "The account associated with an chatroom",
  79                                                               MC_TYPE_ACCOUNT,
  80                                                               G_PARAM_READWRITE));
  81
  82         g_object_class_install_property (object_class,
  83                                          PROP_ROOM,
  84                                          g_param_spec_string ("room",
  85                                                               "Chatroom Room",
  86                                                               "Chatroom represented as 'room@server'",
  87                                                               NULL,
  88                                                               G_PARAM_READWRITE));
  89
  90         g_object_class_install_property (object_class,
  91                                          PROP_NAME,
  92                                          g_param_spec_string ("name",
  93                                                               "Chatroom Name",
  94                                                               "Chatroom name",
  95                                                               NULL,
  96                                                               G_PARAM_READWRITE));
  97
  98         g_object_class_install_property (object_class,
  99                                          PROP_AUTO_CONNECT,
 100                                          g_param_spec_boolean ("auto_connect",
 101                                                                "Chatroom Auto Connect",
 102                                                                "Connect on startup",
 103                                                                FALSE,
 104                                                                G_PARAM_READWRITE));
 105
 106   g_object_class_install_property (object_class,
 107       PROP_FAVORITE,
 108       g_param_spec_boolean ("favorite",
 109         "Favorite",
 110         "TRUE if the chatroom is in user's favorite list",
 111         FALSE,
 112         G_PARAM_READWRITE |
 113         G_PARAM_CONSTRUCT |
 114         G_PARAM_STATIC_NAME |
 115         G_PARAM_STATIC_NICK |
 116         G_PARAM_STATIC_BLURB));
 117
 118         g_object_class_install_property (object_class,
 119                                          PROP_TP_CHAT,
 120                                          g_param_spec_object ("tp-chat",
 121                                                               "Chatroom channel wrapper",
 122                                                               "The wrapper for the chatroom channel if there is one",
 123                                                               EMPATHY_TYPE_TP_CHAT,
 124                                                               G_PARAM_READWRITE));
 125
 126         g_type_class_add_private (object_class, sizeof (EmpathyChatroomPriv));
 127 }
 128
 129 static void
 130 empathy_chatroom_init (EmpathyChatroom *chatroom)
 131 {
 132         EmpathyChatroomPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chatroom,
 133                 EMPATHY_TYPE_CHATROOM, EmpathyChatroomPriv);
 134
 135         chatroom->priv = priv;
 136 }
 137
 138 static void
 139 chatroom_finalize (GObject *object)
 140 {
 141         EmpathyChatroomPriv *priv;
 142
 143         priv = GET_PRIV (object);
 144
 145         if (priv->tp_chat != NULL)
 146                 g_object_unref (priv->tp_chat);
 147
 148         g_object_unref (priv->account);
 149         g_free (priv->room);
 150         g_free (priv->name);
 151
 152         (G_OBJECT_CLASS (empathy_chatroom_parent_class)->finalize) (object);
 153 }
 154
 155 static void
 156 chatroom_get_property (GObject    *object,
 157                        guint       param_id,
 158                        GValue     *value,
 159                        GParamSpec *pspec)
 160 {
 161         EmpathyChatroomPriv *priv;
 162
 163         priv = GET_PRIV (object);
 164
 165         switch (param_id) {
 166         case PROP_ACCOUNT:
 167                 g_value_set_object (value, priv->account);
 168                 break;
 169         case PROP_ROOM:
 170                 g_value_set_string (value, priv->room);
 171                 break;
 172         case PROP_NAME:
 173                 g_value_set_string (value, priv->name);
 174                 break;
 175         case PROP_AUTO_CONNECT:
 176                 g_value_set_boolean (value, priv->auto_connect);
 177                 break;
 178   case PROP_FAVORITE:
 179     g_value_set_boolean (value, priv->favorite);
 180     break;
 181         case PROP_TP_CHAT:
 182                 g_value_set_object (value, priv->tp_chat);
 183                 break;
 184         default:
 185                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 186                 break;
 187         };
 188 }
 189
 190 static void
 191 chatroom_set_property (GObject      *object,
 192                        guint         param_id,
 193                        const GValue *value,
 194                        GParamSpec   *pspec)
 195 {
 196         EmpathyChatroomPriv *priv;
 197
 198         priv = GET_PRIV (object);
 199
 200         switch (param_id) {
 201         case PROP_ACCOUNT:
 202                 empathy_chatroom_set_account (EMPATHY_CHATROOM (object),
 203                                              g_value_get_object (value));
 204                 break;
 205         case PROP_ROOM:
 206                 empathy_chatroom_set_room (EMPATHY_CHATROOM (object),
 207                                           g_value_get_string (value));
 208                 break;
 209         case PROP_NAME:
 210                 empathy_chatroom_set_name (EMPATHY_CHATROOM (object),
 211                                           g_value_get_string (value));
 212                 break;
 213         case PROP_AUTO_CONNECT:
 214                 empathy_chatroom_set_auto_connect (EMPATHY_CHATROOM (object),
 215                                                   g_value_get_boolean (value));
 216                 break;
 217   case PROP_FAVORITE:
 218     priv->favorite = g_value_get_boolean (value);
 219     if (!priv->favorite)
 220       {
 221         empathy_chatroom_set_auto_connect (EMPATHY_CHATROOM (object),
 222             FALSE);
 223       }
 224     break;
 225         case PROP_TP_CHAT: {
 226                 GObject *chat = g_value_dup_object (value);
 227
 228                 if (chat == (GObject *) priv->tp_chat)
 229                         break;
 230
 231                 g_assert (chat == NULL || priv->tp_chat == NULL);
 232
 233                 if (priv->tp_chat != NULL) {
 234                         g_object_unref (priv->tp_chat);
 235                         priv->tp_chat = NULL;
 236                 } else {
 237                         priv->tp_chat = EMPATHY_TP_CHAT (chat);
 238                 }
 239                 break;
 240         }
 241         default:
 242                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 243                 break;
 244         };
 245 }
 246
 247 EmpathyChatroom *
 248 empathy_chatroom_new (McAccount *account)
 249 {
 250         g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 251
 252         return g_object_new (EMPATHY_TYPE_CHATROOM,
 253                              "account", account,
 254                              NULL);
 255 }
 256
 257 EmpathyChatroom *
 258 empathy_chatroom_new_full (McAccount   *account,
 259                           const gchar *room,
 260                           const gchar *name,
 261                           gboolean     auto_connect)
 262 {
 263         g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 264         g_return_val_if_fail (room != NULL, NULL);
 265
 266         return g_object_new (EMPATHY_TYPE_CHATROOM,
 267                              "account", account,
 268                              "room", room,
 269                              "name", name,
 270                              "auto_connect", auto_connect,
 271                              NULL);
 272 }
 273
 274 McAccount *
 275 empathy_chatroom_get_account (EmpathyChatroom *chatroom)
 276 {
 277         EmpathyChatroomPriv *priv;
 278
 279         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 280
 281         priv = GET_PRIV (chatroom);
 282         return priv->account;
 283 }
 284
 285 void
 286 empathy_chatroom_set_account (EmpathyChatroom *chatroom,
 287                              McAccount      *account)
 288 {
 289         EmpathyChatroomPriv *priv;
 290
 291         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 292         g_return_if_fail (MC_IS_ACCOUNT (account));
 293
 294         priv = GET_PRIV (chatroom);
 295
 296         if (account == priv->account) {
 297                 return;
 298         }
 299         if (priv->account) {
 300                 g_object_unref (priv->account);
 301         }
 302         priv->account = g_object_ref (account);
 303
 304         g_object_notify (G_OBJECT (chatroom), "account");
 305 }
 306
 307 const gchar *
 308 empathy_chatroom_get_room (EmpathyChatroom *chatroom)
 309 {
 310         EmpathyChatroomPriv *priv;
 311
 312         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 313
 314         priv = GET_PRIV (chatroom);
 315         return priv->room;
 316 }
 317
 318 void
 319 empathy_chatroom_set_room (EmpathyChatroom *chatroom,
 320                           const gchar    *room)
 321 {
 322         EmpathyChatroomPriv *priv;
 323
 324         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 325         g_return_if_fail (room != NULL);
 326
 327         priv = GET_PRIV (chatroom);
 328
 329         g_free (priv->room);
 330         priv->room = g_strdup (room);
 331
 332         g_object_notify (G_OBJECT (chatroom), "room");
 333 }
 334
 335 const gchar *
 336 empathy_chatroom_get_name (EmpathyChatroom *chatroom)
 337 {
 338         EmpathyChatroomPriv *priv;
 339
 340         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 341
 342         priv = GET_PRIV (chatroom);
 343
 344         if (EMP_STR_EMPTY (priv->name)) {
 345                 return priv->room;
 346         }
 347
 348         return priv->name;
 349 }
 350
 351 void
 352 empathy_chatroom_set_name (EmpathyChatroom *chatroom,
 353                           const gchar    *name)
 354 {
 355         EmpathyChatroomPriv *priv;
 356
 357         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 358
 359         priv = GET_PRIV (chatroom);
 360
 361         g_free (priv->name);
 362         priv->name = NULL;
 363         if (name) {
 364                 priv->name = g_strdup (name);
 365         }
 366
 367         g_object_notify (G_OBJECT (chatroom), "name");
 368 }
 369
 370 gboolean
 371 empathy_chatroom_get_auto_connect (EmpathyChatroom *chatroom)
 372 {
 373         EmpathyChatroomPriv *priv;
 374
 375         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 376
 377         priv = GET_PRIV (chatroom);
 378         return priv->auto_connect;
 379 }
 380
 381 void
 382 empathy_chatroom_set_auto_connect (EmpathyChatroom *chatroom,
 383                                   gboolean        auto_connect)
 384 {
 385         EmpathyChatroomPriv *priv;
 386
 387         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 388
 389         priv = GET_PRIV (chatroom);
 390
 391         priv->auto_connect = auto_connect;
 392
 393   if (priv->auto_connect)
 394     {
 395       /* auto_connect implies favorite */
 396       priv->favorite = TRUE;
 397       g_object_notify (G_OBJECT (chatroom), "favorite");
 398     }
 399
 400         g_object_notify (G_OBJECT (chatroom), "auto-connect");
 401 }
 402
 403 gboolean
 404 empathy_chatroom_equal (gconstpointer v1,
 405                        gconstpointer v2)
 406 {
 407         McAccount   *account_a;
 408         McAccount   *account_b;
 409         const gchar *room_a;
 410         const gchar *room_b;
 411
 412         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v1), FALSE);
 413         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v2), FALSE);
 414
 415         account_a = empathy_chatroom_get_account (EMPATHY_CHATROOM (v1));
 416         account_b = empathy_chatroom_get_account (EMPATHY_CHATROOM (v2));
 417
 418         room_a = empathy_chatroom_get_room (EMPATHY_CHATROOM (v1));
 419         room_b = empathy_chatroom_get_room (EMPATHY_CHATROOM (v2));
 420
 421         return empathy_account_equal (account_a, account_b) && !tp_strdiff (room_a,
 422       room_b);
 423 }
 424
 425 EmpathyTpChat *
 426 empathy_chatroom_get_tp_chat (EmpathyChatroom *chatroom) {
 427         EmpathyChatroomPriv *priv;
 428
 429         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 430
 431         priv = GET_PRIV (chatroom);
 432
 433         return priv->tp_chat;
 434 }