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         gchar *subject;
  41         guint members_count;
  42         gboolean invite_only;
  43         gboolean need_password;
  44 } EmpathyChatroomPriv;
  45
  46
  47 static void chatroom_finalize          (GObject             *object);
  48 static void chatroom_get_property      (GObject             *object,
  49                                         guint                param_id,
  50                                         GValue              *value,
  51                                         GParamSpec          *pspec);
  52 static void chatroom_set_property      (GObject             *object,
  53                                         guint                param_id,
  54                                         const GValue        *value,
  55                                         GParamSpec          *pspec);
  56
  57 enum {
  58         PROP_0,
  59         PROP_ACCOUNT,
  60         PROP_ROOM,
  61         PROP_NAME,
  62         PROP_AUTO_CONNECT,
  63         PROP_FAVORITE,
  64         PROP_TP_CHAT,
  65         PROP_SUBJECT,
  66         PROP_MEMBERS_COUNT,
  67         PROP_NEED_PASSWORD,
  68         PROP_INVITE_ONLY
  69 };
  70
  71 G_DEFINE_TYPE (EmpathyChatroom, empathy_chatroom, G_TYPE_OBJECT);
  72
  73 static void
  74 empathy_chatroom_class_init (EmpathyChatroomClass *klass)
  75 {
  76         GObjectClass *object_class = G_OBJECT_CLASS (klass);
  77
  78         object_class->finalize     = chatroom_finalize;
  79         object_class->get_property = chatroom_get_property;
  80         object_class->set_property = chatroom_set_property;
  81
  82         g_object_class_install_property (object_class,
  83                                          PROP_ACCOUNT,
  84                                          g_param_spec_object ("account",
  85                                                               "Chatroom Account",
  86                                                               "The account associated with an chatroom",
  87                                                               MC_TYPE_ACCOUNT,
  88                                                               G_PARAM_READWRITE));
  89
  90         g_object_class_install_property (object_class,
  91                                          PROP_ROOM,
  92                                          g_param_spec_string ("room",
  93                                                               "Chatroom Room",
  94                                                               "Chatroom represented as 'room@server'",
  95                                                               NULL,
  96                                                               G_PARAM_READWRITE));
  97
  98         g_object_class_install_property (object_class,
  99                                          PROP_NAME,
 100                                          g_param_spec_string ("name",
 101                                                               "Chatroom Name",
 102                                                               "Chatroom name",
 103                                                               NULL,
 104                                                               G_PARAM_READWRITE));
 105
 106         g_object_class_install_property (object_class,
 107                                          PROP_AUTO_CONNECT,
 108                                          g_param_spec_boolean ("auto_connect",
 109                                                                "Chatroom Auto Connect",
 110                                                                "Connect on startup",
 111                                                                FALSE,
 112                                                                G_PARAM_READWRITE));
 113
 114   g_object_class_install_property (object_class,
 115       PROP_FAVORITE,
 116       g_param_spec_boolean ("favorite",
 117         "Favorite",
 118         "TRUE if the chatroom is in user's favorite list",
 119         FALSE,
 120         G_PARAM_READWRITE |
 121         G_PARAM_CONSTRUCT |
 122         G_PARAM_STATIC_NAME |
 123         G_PARAM_STATIC_NICK |
 124         G_PARAM_STATIC_BLURB));
 125
 126         g_object_class_install_property (object_class,
 127                                          PROP_TP_CHAT,
 128                                          g_param_spec_object ("tp-chat",
 129                                                               "Chatroom channel wrapper",
 130                                                               "The wrapper for the chatroom channel if there is one",
 131                                                               EMPATHY_TYPE_TP_CHAT,
 132                                                               G_PARAM_READWRITE));
 133
 134   g_object_class_install_property (object_class,
 135       PROP_SUBJECT,
 136       g_param_spec_string ("subject",
 137         "Subject",
 138         "The chatroom's subject",
 139         "",
 140         G_PARAM_READWRITE |
 141         G_PARAM_CONSTRUCT |
 142         G_PARAM_STATIC_NAME |
 143         G_PARAM_STATIC_NICK |
 144         G_PARAM_STATIC_BLURB));
 145
 146   g_object_class_install_property (object_class,
 147       PROP_MEMBERS_COUNT,
 148       g_param_spec_uint ("members-count",
 149         "Members count",
 150         "The chatroom's members count",
 151         0,
 152         G_MAXUINT,
 153         0,
 154         G_PARAM_READWRITE |
 155         G_PARAM_CONSTRUCT |
 156         G_PARAM_STATIC_NAME |
 157         G_PARAM_STATIC_NICK |
 158         G_PARAM_STATIC_BLURB));
 159
 160   g_object_class_install_property (object_class,
 161       PROP_INVITE_ONLY,
 162       g_param_spec_boolean ("invite-only",
 163         "Invite Only",
 164         "The chatroom is invite only",
 165         FALSE,
 166         G_PARAM_READWRITE |
 167         G_PARAM_CONSTRUCT |
 168         G_PARAM_STATIC_NAME |
 169         G_PARAM_STATIC_NICK |
 170         G_PARAM_STATIC_BLURB));
 171
 172   g_object_class_install_property (object_class,
 173       PROP_NEED_PASSWORD,
 174       g_param_spec_boolean ("need-password",
 175         "Password Needed",
 176         "The chatroom is password protected",
 177         FALSE,
 178         G_PARAM_READWRITE |
 179         G_PARAM_CONSTRUCT |
 180         G_PARAM_STATIC_NAME |
 181         G_PARAM_STATIC_NICK |
 182         G_PARAM_STATIC_BLURB));
 183
 184         g_type_class_add_private (object_class, sizeof (EmpathyChatroomPriv));
 185 }
 186
 187 static void
 188 empathy_chatroom_init (EmpathyChatroom *chatroom)
 189 {
 190         EmpathyChatroomPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chatroom,
 191                 EMPATHY_TYPE_CHATROOM, EmpathyChatroomPriv);
 192
 193         chatroom->priv = priv;
 194 }
 195
 196 static void
 197 chatroom_finalize (GObject *object)
 198 {
 199         EmpathyChatroomPriv *priv;
 200
 201         priv = GET_PRIV (object);
 202
 203         if (priv->tp_chat != NULL)
 204                 g_object_unref (priv->tp_chat);
 205
 206         g_object_unref (priv->account);
 207         g_free (priv->room);
 208         g_free (priv->name);
 209
 210         (G_OBJECT_CLASS (empathy_chatroom_parent_class)->finalize) (object);
 211 }
 212
 213 static void
 214 chatroom_get_property (GObject    *object,
 215                        guint       param_id,
 216                        GValue     *value,
 217                        GParamSpec *pspec)
 218 {
 219         EmpathyChatroomPriv *priv;
 220
 221         priv = GET_PRIV (object);
 222
 223         switch (param_id) {
 224         case PROP_ACCOUNT:
 225                 g_value_set_object (value, priv->account);
 226                 break;
 227         case PROP_ROOM:
 228                 g_value_set_string (value, priv->room);
 229                 break;
 230         case PROP_NAME:
 231                 g_value_set_string (value, priv->name);
 232                 break;
 233         case PROP_AUTO_CONNECT:
 234                 g_value_set_boolean (value, priv->auto_connect);
 235                 break;
 236         case PROP_FAVORITE:
 237                 g_value_set_boolean (value, priv->favorite);
 238                 break;
 239         case PROP_TP_CHAT:
 240                 g_value_set_object (value, priv->tp_chat);
 241                 break;
 242   case PROP_SUBJECT:
 243     g_value_set_string (value, priv->subject);
 244     break;
 245   case PROP_MEMBERS_COUNT:
 246     g_value_set_uint (value, priv->members_count);
 247     break;
 248   case PROP_INVITE_ONLY:
 249     g_value_set_boolean (value, priv->invite_only);
 250     break;
 251   case PROP_NEED_PASSWORD:
 252     g_value_set_boolean (value, priv->need_password);
 253     break;
 254         default:
 255                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 256                 break;
 257         };
 258 }
 259
 260 static void
 261 chatroom_set_property (GObject      *object,
 262                        guint         param_id,
 263                        const GValue *value,
 264                        GParamSpec   *pspec)
 265 {
 266         EmpathyChatroomPriv *priv;
 267
 268         priv = GET_PRIV (object);
 269
 270         switch (param_id) {
 271         case PROP_ACCOUNT:
 272                 empathy_chatroom_set_account (EMPATHY_CHATROOM (object),
 273                                              g_value_get_object (value));
 274                 break;
 275         case PROP_ROOM:
 276                 empathy_chatroom_set_room (EMPATHY_CHATROOM (object),
 277                                           g_value_get_string (value));
 278                 break;
 279         case PROP_NAME:
 280                 empathy_chatroom_set_name (EMPATHY_CHATROOM (object),
 281                                           g_value_get_string (value));
 282                 break;
 283         case PROP_AUTO_CONNECT:
 284                 empathy_chatroom_set_auto_connect (EMPATHY_CHATROOM (object),
 285                                                   g_value_get_boolean (value));
 286                 break;
 287   case PROP_FAVORITE:
 288     priv->favorite = g_value_get_boolean (value);
 289     if (!priv->favorite)
 290       {
 291         empathy_chatroom_set_auto_connect (EMPATHY_CHATROOM (object),
 292             FALSE);
 293       }
 294     break;
 295         case PROP_TP_CHAT: {
 296                 GObject *chat = g_value_dup_object (value);
 297
 298                 if (chat == (GObject *) priv->tp_chat)
 299                         break;
 300
 301                 g_assert (chat == NULL || priv->tp_chat == NULL);
 302
 303                 if (priv->tp_chat != NULL) {
 304                         g_object_unref (priv->tp_chat);
 305                         priv->tp_chat = NULL;
 306                 } else {
 307                         priv->tp_chat = EMPATHY_TP_CHAT (chat);
 308                 }
 309                 break;
 310         }
 311   case PROP_SUBJECT:
 312     empathy_chatroom_set_subject (EMPATHY_CHATROOM (object),
 313         g_value_get_string (value));
 314     break;
 315   case PROP_MEMBERS_COUNT:
 316     empathy_chatroom_set_members_count (EMPATHY_CHATROOM (object),
 317         g_value_get_uint (value));
 318     break;
 319   case PROP_NEED_PASSWORD:
 320     empathy_chatroom_set_need_password (EMPATHY_CHATROOM (object),
 321         g_value_get_boolean (value));
 322     break;
 323   case PROP_INVITE_ONLY:
 324     empathy_chatroom_set_invite_only (EMPATHY_CHATROOM (object),
 325         g_value_get_boolean (value));
 326     break;
 327         default:
 328                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 329                 break;
 330         };
 331 }
 332
 333 EmpathyChatroom *
 334 empathy_chatroom_new (McAccount *account)
 335 {
 336         g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 337
 338         return g_object_new (EMPATHY_TYPE_CHATROOM,
 339                              "account", account,
 340                              NULL);
 341 }
 342
 343 EmpathyChatroom *
 344 empathy_chatroom_new_full (McAccount   *account,
 345                           const gchar *room,
 346                           const gchar *name,
 347                           gboolean     auto_connect)
 348 {
 349         g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 350         g_return_val_if_fail (room != NULL, NULL);
 351
 352         return g_object_new (EMPATHY_TYPE_CHATROOM,
 353                              "account", account,
 354                              "room", room,
 355                              "name", name,
 356                              "auto_connect", auto_connect,
 357                              NULL);
 358 }
 359
 360 McAccount *
 361 empathy_chatroom_get_account (EmpathyChatroom *chatroom)
 362 {
 363         EmpathyChatroomPriv *priv;
 364
 365         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 366
 367         priv = GET_PRIV (chatroom);
 368         return priv->account;
 369 }
 370
 371 void
 372 empathy_chatroom_set_account (EmpathyChatroom *chatroom,
 373                              McAccount      *account)
 374 {
 375         EmpathyChatroomPriv *priv;
 376
 377         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 378         g_return_if_fail (MC_IS_ACCOUNT (account));
 379
 380         priv = GET_PRIV (chatroom);
 381
 382         if (account == priv->account) {
 383                 return;
 384         }
 385         if (priv->account) {
 386                 g_object_unref (priv->account);
 387         }
 388         priv->account = g_object_ref (account);
 389
 390         g_object_notify (G_OBJECT (chatroom), "account");
 391 }
 392
 393 const gchar *
 394 empathy_chatroom_get_room (EmpathyChatroom *chatroom)
 395 {
 396         EmpathyChatroomPriv *priv;
 397
 398         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 399
 400         priv = GET_PRIV (chatroom);
 401         return priv->room;
 402 }
 403
 404 void
 405 empathy_chatroom_set_room (EmpathyChatroom *chatroom,
 406                           const gchar    *room)
 407 {
 408         EmpathyChatroomPriv *priv;
 409
 410         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 411         g_return_if_fail (room != NULL);
 412
 413         priv = GET_PRIV (chatroom);
 414
 415         g_free (priv->room);
 416         priv->room = g_strdup (room);
 417
 418         g_object_notify (G_OBJECT (chatroom), "room");
 419 }
 420
 421 const gchar *
 422 empathy_chatroom_get_name (EmpathyChatroom *chatroom)
 423 {
 424         EmpathyChatroomPriv *priv;
 425
 426         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 427
 428         priv = GET_PRIV (chatroom);
 429
 430         if (EMP_STR_EMPTY (priv->name)) {
 431                 return priv->room;
 432         }
 433
 434         return priv->name;
 435 }
 436
 437 void
 438 empathy_chatroom_set_name (EmpathyChatroom *chatroom,
 439                           const gchar    *name)
 440 {
 441         EmpathyChatroomPriv *priv;
 442
 443         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 444
 445         priv = GET_PRIV (chatroom);
 446
 447         g_free (priv->name);
 448         priv->name = NULL;
 449         if (name) {
 450                 priv->name = g_strdup (name);
 451         }
 452
 453         g_object_notify (G_OBJECT (chatroom), "name");
 454 }
 455
 456 gboolean
 457 empathy_chatroom_get_auto_connect (EmpathyChatroom *chatroom)
 458 {
 459         EmpathyChatroomPriv *priv;
 460
 461         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 462
 463         priv = GET_PRIV (chatroom);
 464         return priv->auto_connect;
 465 }
 466
 467 void
 468 empathy_chatroom_set_auto_connect (EmpathyChatroom *chatroom,
 469                                   gboolean        auto_connect)
 470 {
 471         EmpathyChatroomPriv *priv;
 472
 473         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 474
 475         priv = GET_PRIV (chatroom);
 476
 477         priv->auto_connect = auto_connect;
 478
 479   if (priv->auto_connect)
 480     {
 481       /* auto_connect implies favorite */
 482       priv->favorite = TRUE;
 483       g_object_notify (G_OBJECT (chatroom), "favorite");
 484     }
 485
 486         g_object_notify (G_OBJECT (chatroom), "auto-connect");
 487 }
 488
 489 gboolean
 490 empathy_chatroom_equal (gconstpointer v1,
 491                        gconstpointer v2)
 492 {
 493         McAccount   *account_a;
 494         McAccount   *account_b;
 495         const gchar *room_a;
 496         const gchar *room_b;
 497
 498         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v1), FALSE);
 499         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v2), FALSE);
 500
 501         account_a = empathy_chatroom_get_account (EMPATHY_CHATROOM (v1));
 502         account_b = empathy_chatroom_get_account (EMPATHY_CHATROOM (v2));
 503
 504         room_a = empathy_chatroom_get_room (EMPATHY_CHATROOM (v1));
 505         room_b = empathy_chatroom_get_room (EMPATHY_CHATROOM (v2));
 506
 507         return empathy_account_equal (account_a, account_b) && !tp_strdiff (room_a,
 508       room_b);
 509 }
 510
 511 EmpathyTpChat *
 512 empathy_chatroom_get_tp_chat (EmpathyChatroom *chatroom) {
 513         EmpathyChatroomPriv *priv;
 514
 515         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 516
 517         priv = GET_PRIV (chatroom);
 518
 519         return priv->tp_chat;
 520 }
 521
 522 const gchar *
 523 empathy_chatroom_get_subject (EmpathyChatroom *chatroom)
 524 {
 525   EmpathyChatroomPriv *priv;
 526
 527   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 528
 529   priv = GET_PRIV (chatroom);
 530
 531   return priv->subject;
 532 }
 533
 534 void
 535 empathy_chatroom_set_subject (EmpathyChatroom *chatroom,
 536                               const gchar *subject)
 537 {
 538   EmpathyChatroomPriv *priv;
 539
 540   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 541
 542   priv = GET_PRIV (chatroom);
 543
 544   g_free (priv->subject);
 545   priv->subject = NULL;
 546
 547   if (subject)
 548     priv->subject = g_strdup (subject);
 549
 550   g_object_notify (G_OBJECT (chatroom), "subject");
 551 }
 552
 553 guint
 554 empathy_chatroom_get_members_count (EmpathyChatroom *chatroom)
 555 {
 556   EmpathyChatroomPriv *priv;
 557
 558   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), 0);
 559
 560   priv = GET_PRIV (chatroom);
 561
 562   return priv->members_count;
 563 }
 564
 565 void
 566 empathy_chatroom_set_members_count (EmpathyChatroom *chatroom,
 567                                     guint count)
 568 {
 569   EmpathyChatroomPriv *priv;
 570
 571   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 572
 573   priv = GET_PRIV (chatroom);
 574
 575   priv->members_count = count;
 576
 577   g_object_notify (G_OBJECT (chatroom), "members-count");
 578 }
 579
 580 gboolean
 581 empathy_chatroom_get_need_password (EmpathyChatroom *chatroom)
 582 {
 583   EmpathyChatroomPriv *priv;
 584
 585   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 586
 587   priv = GET_PRIV (chatroom);
 588
 589   return priv->need_password;
 590 }
 591
 592 void
 593 empathy_chatroom_set_need_password (EmpathyChatroom *chatroom,
 594                                     gboolean need_password)
 595 {
 596   EmpathyChatroomPriv *priv;
 597
 598   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 599
 600   priv = GET_PRIV (chatroom);
 601
 602   priv->need_password = need_password;
 603
 604   g_object_notify (G_OBJECT (chatroom), "need-password");
 605 }
 606
 607 gboolean
 608 empathy_chatroom_get_invite_only (EmpathyChatroom *chatroom)
 609 {
 610   EmpathyChatroomPriv *priv;
 611
 612   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 613
 614   priv = GET_PRIV (chatroom);
 615
 616   return priv->invite_only;
 617 }
 618
 619 void
 620 empathy_chatroom_set_invite_only (EmpathyChatroom *chatroom,
 621                                   gboolean invite_only)
 622 {
 623   EmpathyChatroomPriv *priv;
 624
 625   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 626
 627   priv = GET_PRIV (chatroom);
 628
 629   priv->invite_only = invite_only;
 630
 631   g_object_notify (G_OBJECT (chatroom), "invite-only");
 632 }
 633