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