libempathy/empathy-chatroom.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2007 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) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), EMPATHY_TYPE_CHATROOM, EmpathyChatroomPriv))
  32
  33 struct _EmpathyChatroomPriv {
  34         McAccount *account;
  35         gchar     *room;
  36         gchar     *name;
  37         gboolean   auto_connect;
  38 };
  39
  40 static void empathy_chatroom_class_init (EmpathyChatroomClass *klass);
  41 static void empathy_chatroom_init       (EmpathyChatroom      *chatroom);
  42 static void chatroom_finalize          (GObject             *object);
  43 static void chatroom_get_property      (GObject             *object,
  44                                         guint                param_id,
  45                                         GValue              *value,
  46                                         GParamSpec          *pspec);
  47 static void chatroom_set_property      (GObject             *object,
  48                                         guint                param_id,
  49                                         const GValue        *value,
  50                                         GParamSpec          *pspec);
  51
  52 enum {
  53         PROP_0,
  54         PROP_ACCOUNT,
  55         PROP_ROOM,
  56         PROP_NAME,
  57         PROP_AUTO_CONNECT,
  58 };
  59
  60 G_DEFINE_TYPE (EmpathyChatroom, empathy_chatroom, G_TYPE_OBJECT);
  61
  62 static void
  63 empathy_chatroom_class_init (EmpathyChatroomClass *klass)
  64 {
  65         GObjectClass *object_class = G_OBJECT_CLASS (klass);
  66
  67         object_class->finalize     = chatroom_finalize;
  68         object_class->get_property = chatroom_get_property;
  69         object_class->set_property = chatroom_set_property;
  70
  71         g_object_class_install_property (object_class,
  72                                          PROP_ACCOUNT,
  73                                          g_param_spec_object ("account",
  74                                                               "Chatroom Account",
  75                                                               "The account associated with an chatroom",
  76                                                               MC_TYPE_ACCOUNT,
  77                                                               G_PARAM_READWRITE));
  78
  79         g_object_class_install_property (object_class,
  80                                          PROP_ROOM,
  81                                          g_param_spec_string ("room",
  82                                                               "Chatroom Room",
  83                                                               "Chatroom represented as 'room@server'",
  84                                                               NULL,
  85                                                               G_PARAM_READWRITE));
  86
  87         g_object_class_install_property (object_class,
  88                                          PROP_NAME,
  89                                          g_param_spec_string ("name",
  90                                                               "Chatroom Name",
  91                                                               "Chatroom name",
  92                                                               NULL,
  93                                                               G_PARAM_READWRITE));
  94
  95         g_object_class_install_property (object_class,
  96                                          PROP_AUTO_CONNECT,
  97                                          g_param_spec_boolean ("auto_connect",
  98                                                                "Chatroom Auto Connect",
  99                                                                "Connect on startup",
 100                                                                FALSE,
 101                                                                G_PARAM_READWRITE));
 102
 103
 104         g_type_class_add_private (object_class, sizeof (EmpathyChatroomPriv));
 105 }
 106
 107 static void
 108 empathy_chatroom_init (EmpathyChatroom *chatroom)
 109 {
 110 }
 111
 112 static void
 113 chatroom_finalize (GObject *object)
 114 {
 115         EmpathyChatroomPriv *priv;
 116
 117         priv = GET_PRIV (object);
 118
 119         g_object_unref (priv->account);
 120         g_free (priv->room);
 121         g_free (priv->name);
 122
 123         (G_OBJECT_CLASS (empathy_chatroom_parent_class)->finalize) (object);
 124 }
 125
 126 static void
 127 chatroom_get_property (GObject    *object,
 128                        guint       param_id,
 129                        GValue     *value,
 130                        GParamSpec *pspec)
 131 {
 132         EmpathyChatroomPriv *priv;
 133
 134         priv = GET_PRIV (object);
 135
 136         switch (param_id) {
 137         case PROP_ACCOUNT:
 138                 g_value_set_object (value, priv->account);
 139                 break;
 140         case PROP_ROOM:
 141                 g_value_set_string (value, priv->room);
 142                 break;
 143         case PROP_NAME:
 144                 g_value_set_string (value, priv->name);
 145                 break;
 146         case PROP_AUTO_CONNECT:
 147                 g_value_set_boolean (value, priv->auto_connect);
 148                 break;
 149         default:
 150                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 151                 break;
 152         };
 153 }
 154
 155 static void
 156 chatroom_set_property (GObject      *object,
 157                        guint         param_id,
 158                        const 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                 empathy_chatroom_set_account (EMPATHY_CHATROOM (object),
 168                                              g_value_get_object (value));
 169                 break;
 170         case PROP_ROOM:
 171                 empathy_chatroom_set_room (EMPATHY_CHATROOM (object),
 172                                           g_value_get_string (value));
 173                 break;
 174         case PROP_NAME:
 175                 empathy_chatroom_set_name (EMPATHY_CHATROOM (object),
 176                                           g_value_get_string (value));
 177                 break;
 178         case PROP_AUTO_CONNECT:
 179                 empathy_chatroom_set_auto_connect (EMPATHY_CHATROOM (object),
 180                                                   g_value_get_boolean (value));
 181                 break;
 182         default:
 183                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 184                 break;
 185         };
 186 }
 187
 188 EmpathyChatroom *
 189 empathy_chatroom_new (McAccount   *account,
 190                      const gchar *room)
 191 {
 192         g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 193         g_return_val_if_fail (room != NULL, NULL);
 194
 195         return g_object_new (EMPATHY_TYPE_CHATROOM,
 196                              "account", account,
 197                              "room", room,
 198                              NULL);
 199 }
 200
 201 EmpathyChatroom *
 202 empathy_chatroom_new_full (McAccount   *account,
 203                           const gchar *room,
 204                           const gchar *name,
 205                           gboolean     auto_connect)
 206 {
 207         g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 208         g_return_val_if_fail (room != NULL, NULL);
 209
 210         return g_object_new (EMPATHY_TYPE_CHATROOM,
 211                              "account", account,
 212                              "room", room,
 213                              "name", name,
 214                              "auto_connect", auto_connect,
 215                              NULL);
 216 }
 217
 218 McAccount *
 219 empathy_chatroom_get_account (EmpathyChatroom *chatroom)
 220 {
 221         EmpathyChatroomPriv *priv;
 222
 223         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 224
 225         priv = GET_PRIV (chatroom);
 226         return priv->account;
 227 }
 228
 229 void
 230 empathy_chatroom_set_account (EmpathyChatroom *chatroom,
 231                              McAccount      *account)
 232 {
 233         EmpathyChatroomPriv *priv;
 234
 235         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 236         g_return_if_fail (MC_IS_ACCOUNT (account));
 237
 238         priv = GET_PRIV (chatroom);
 239
 240         if (account == priv->account) {
 241                 return;
 242         }
 243         if (priv->account) {
 244                 g_object_unref (priv->account);
 245         }
 246         priv->account = g_object_ref (account);
 247
 248         g_object_notify (G_OBJECT (chatroom), "account");
 249 }
 250
 251 const gchar *
 252 empathy_chatroom_get_room (EmpathyChatroom *chatroom)
 253 {
 254         EmpathyChatroomPriv *priv;
 255
 256         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 257
 258         priv = GET_PRIV (chatroom);
 259         return priv->room;
 260 }
 261
 262 void
 263 empathy_chatroom_set_room (EmpathyChatroom *chatroom,
 264                           const gchar    *room)
 265 {
 266         EmpathyChatroomPriv *priv;
 267
 268         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 269         g_return_if_fail (room != NULL);
 270
 271         priv = GET_PRIV (chatroom);
 272
 273         g_free (priv->room);
 274         priv->room = g_strdup (room);
 275
 276         g_object_notify (G_OBJECT (chatroom), "room");
 277 }
 278
 279 const gchar *
 280 empathy_chatroom_get_name (EmpathyChatroom *chatroom)
 281 {
 282         EmpathyChatroomPriv *priv;
 283
 284         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 285
 286         priv = GET_PRIV (chatroom);
 287
 288         if (G_STR_EMPTY (priv->name)) {
 289                 return priv->room;
 290         }
 291
 292         return priv->name;
 293 }
 294
 295 void
 296 empathy_chatroom_set_name (EmpathyChatroom *chatroom,
 297                           const gchar    *name)
 298 {
 299         EmpathyChatroomPriv *priv;
 300
 301         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 302
 303         priv = GET_PRIV (chatroom);
 304
 305         g_free (priv->name);
 306         priv->name = NULL;
 307         if (name) {
 308                 priv->name = g_strdup (name);
 309         }
 310
 311         g_object_notify (G_OBJECT (chatroom), "name");
 312 }
 313
 314 gboolean
 315 empathy_chatroom_get_auto_connect (EmpathyChatroom *chatroom)
 316 {
 317         EmpathyChatroomPriv *priv;
 318
 319         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 320
 321         priv = GET_PRIV (chatroom);
 322         return priv->auto_connect;
 323 }
 324
 325 void
 326 empathy_chatroom_set_auto_connect (EmpathyChatroom *chatroom,
 327                                   gboolean        auto_connect)
 328 {
 329         EmpathyChatroomPriv *priv;
 330
 331         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 332
 333         priv = GET_PRIV (chatroom);
 334
 335         priv->auto_connect = auto_connect;
 336
 337         g_object_notify (G_OBJECT (chatroom), "auto-connect");
 338 }
 339
 340 gboolean
 341 empathy_chatroom_equal (gconstpointer v1,
 342                        gconstpointer v2)
 343 {
 344         McAccount   *account_a;
 345         McAccount   *account_b;
 346         const gchar *room_a;
 347         const gchar *room_b;
 348
 349         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v1), FALSE);
 350         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v2), FALSE);
 351
 352         account_a = empathy_chatroom_get_account (EMPATHY_CHATROOM (v1));
 353         account_b = empathy_chatroom_get_account (EMPATHY_CHATROOM (v2));
 354
 355         room_a = empathy_chatroom_get_room (EMPATHY_CHATROOM (v1));
 356         room_b = empathy_chatroom_get_room (EMPATHY_CHATROOM (v2));
 357
 358         return empathy_account_equal (account_a, account_b) && g_str_equal (room_a, room_b);
 359 }
 360
 361