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