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