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
 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 (McAccount *account)
 316 {
 317         g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 318
 319         return g_object_new (EMPATHY_TYPE_CHATROOM,
 320                              "account", account,
 321                              NULL);
 322 }
 323
 324 EmpathyChatroom *
 325 empathy_chatroom_new_full (McAccount   *account,
 326                           const gchar *room,
 327                           const gchar *name,
 328                           gboolean     auto_connect)
 329 {
 330         g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 331         g_return_val_if_fail (room != NULL, NULL);
 332
 333         return g_object_new (EMPATHY_TYPE_CHATROOM,
 334                              "account", account,
 335                              "room", room,
 336                              "name", name,
 337                              "auto_connect", auto_connect,
 338                              NULL);
 339 }
 340
 341 McAccount *
 342 empathy_chatroom_get_account (EmpathyChatroom *chatroom)
 343 {
 344         EmpathyChatroomPriv *priv;
 345
 346         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 347
 348         priv = GET_PRIV (chatroom);
 349         return priv->account;
 350 }
 351
 352 void
 353 empathy_chatroom_set_account (EmpathyChatroom *chatroom,
 354                              McAccount      *account)
 355 {
 356         EmpathyChatroomPriv *priv;
 357
 358         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 359         g_return_if_fail (MC_IS_ACCOUNT (account));
 360
 361         priv = GET_PRIV (chatroom);
 362
 363         if (account == priv->account) {
 364                 return;
 365         }
 366         if (priv->account) {
 367                 g_object_unref (priv->account);
 368         }
 369         priv->account = g_object_ref (account);
 370
 371         g_object_notify (G_OBJECT (chatroom), "account");
 372 }
 373
 374 const gchar *
 375 empathy_chatroom_get_room (EmpathyChatroom *chatroom)
 376 {
 377         EmpathyChatroomPriv *priv;
 378
 379         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 380
 381         priv = GET_PRIV (chatroom);
 382         return priv->room;
 383 }
 384
 385 void
 386 empathy_chatroom_set_room (EmpathyChatroom *chatroom,
 387                           const gchar    *room)
 388 {
 389         EmpathyChatroomPriv *priv;
 390
 391         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 392         g_return_if_fail (room != NULL);
 393
 394         priv = GET_PRIV (chatroom);
 395
 396         g_free (priv->room);
 397         priv->room = g_strdup (room);
 398
 399         g_object_notify (G_OBJECT (chatroom), "room");
 400 }
 401
 402 const gchar *
 403 empathy_chatroom_get_name (EmpathyChatroom *chatroom)
 404 {
 405         EmpathyChatroomPriv *priv;
 406
 407         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 408
 409         priv = GET_PRIV (chatroom);
 410
 411         if (EMP_STR_EMPTY (priv->name)) {
 412                 return priv->room;
 413         }
 414
 415         return priv->name;
 416 }
 417
 418 void
 419 empathy_chatroom_set_name (EmpathyChatroom *chatroom,
 420                           const gchar    *name)
 421 {
 422         EmpathyChatroomPriv *priv;
 423
 424         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 425
 426         priv = GET_PRIV (chatroom);
 427
 428         g_free (priv->name);
 429         priv->name = NULL;
 430         if (name) {
 431                 priv->name = g_strdup (name);
 432         }
 433
 434         g_object_notify (G_OBJECT (chatroom), "name");
 435 }
 436
 437 gboolean
 438 empathy_chatroom_get_auto_connect (EmpathyChatroom *chatroom)
 439 {
 440         EmpathyChatroomPriv *priv;
 441
 442         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 443
 444         priv = GET_PRIV (chatroom);
 445         return priv->auto_connect;
 446 }
 447
 448 void
 449 empathy_chatroom_set_auto_connect (EmpathyChatroom *chatroom,
 450                                   gboolean        auto_connect)
 451 {
 452         EmpathyChatroomPriv *priv;
 453
 454         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 455
 456         priv = GET_PRIV (chatroom);
 457
 458         priv->auto_connect = auto_connect;
 459
 460         if (priv->auto_connect) {
 461                 /* auto_connect implies favorite */
 462                 priv->favorite = TRUE;
 463                 g_object_notify (G_OBJECT (chatroom), "favorite");
 464         }
 465
 466         g_object_notify (G_OBJECT (chatroom), "auto-connect");
 467 }
 468
 469 gboolean
 470 empathy_chatroom_equal (gconstpointer v1,
 471                        gconstpointer v2)
 472 {
 473         McAccount   *account_a;
 474         McAccount   *account_b;
 475         const gchar *room_a;
 476         const gchar *room_b;
 477
 478         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v1), FALSE);
 479         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v2), FALSE);
 480
 481         account_a = empathy_chatroom_get_account (EMPATHY_CHATROOM (v1));
 482         account_b = empathy_chatroom_get_account (EMPATHY_CHATROOM (v2));
 483
 484         room_a = empathy_chatroom_get_room (EMPATHY_CHATROOM (v1));
 485         room_b = empathy_chatroom_get_room (EMPATHY_CHATROOM (v2));
 486
 487         return empathy_account_equal (account_a, account_b) &&
 488                !tp_strdiff (room_a, room_b);
 489 }
 490
 491 EmpathyTpChat *
 492 empathy_chatroom_get_tp_chat (EmpathyChatroom *chatroom)
 493 {
 494         EmpathyChatroomPriv *priv;
 495
 496         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 497
 498         priv = GET_PRIV (chatroom);
 499
 500         return priv->tp_chat;
 501 }
 502
 503 const gchar *
 504 empathy_chatroom_get_subject (EmpathyChatroom *chatroom)
 505 {
 506   EmpathyChatroomPriv *priv;
 507
 508   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 509
 510   priv = GET_PRIV (chatroom);
 511
 512   return priv->subject;
 513 }
 514
 515 void
 516 empathy_chatroom_set_subject (EmpathyChatroom *chatroom,
 517                               const gchar *subject)
 518 {
 519   EmpathyChatroomPriv *priv;
 520
 521   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 522
 523   priv = GET_PRIV (chatroom);
 524
 525   g_free (priv->subject);
 526   priv->subject = NULL;
 527
 528   if (subject)
 529     priv->subject = g_strdup (subject);
 530
 531   g_object_notify (G_OBJECT (chatroom), "subject");
 532 }
 533
 534 guint
 535 empathy_chatroom_get_members_count (EmpathyChatroom *chatroom)
 536 {
 537   EmpathyChatroomPriv *priv;
 538
 539   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), 0);
 540
 541   priv = GET_PRIV (chatroom);
 542
 543   return priv->members_count;
 544 }
 545
 546 void
 547 empathy_chatroom_set_members_count (EmpathyChatroom *chatroom,
 548                                     guint count)
 549 {
 550   EmpathyChatroomPriv *priv;
 551
 552   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 553
 554   priv = GET_PRIV (chatroom);
 555
 556   priv->members_count = count;
 557
 558   g_object_notify (G_OBJECT (chatroom), "members-count");
 559 }
 560
 561 gboolean
 562 empathy_chatroom_get_need_password (EmpathyChatroom *chatroom)
 563 {
 564   EmpathyChatroomPriv *priv;
 565
 566   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 567
 568   priv = GET_PRIV (chatroom);
 569
 570   return priv->need_password;
 571 }
 572
 573 void
 574 empathy_chatroom_set_need_password (EmpathyChatroom *chatroom,
 575                                     gboolean need_password)
 576 {
 577   EmpathyChatroomPriv *priv;
 578
 579   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 580
 581   priv = GET_PRIV (chatroom);
 582
 583   priv->need_password = need_password;
 584
 585   g_object_notify (G_OBJECT (chatroom), "need-password");
 586 }
 587
 588 gboolean
 589 empathy_chatroom_get_invite_only (EmpathyChatroom *chatroom)
 590 {
 591   EmpathyChatroomPriv *priv;
 592
 593   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 594
 595   priv = GET_PRIV (chatroom);
 596
 597   return priv->invite_only;
 598 }
 599
 600 void
 601 empathy_chatroom_set_invite_only (EmpathyChatroom *chatroom,
 602                                   gboolean invite_only)
 603 {
 604   EmpathyChatroomPriv *priv;
 605
 606   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 607
 608   priv = GET_PRIV (chatroom);
 609
 610   priv->invite_only = invite_only;
 611
 612   g_object_notify (G_OBJECT (chatroom), "invite-only");
 613 }
 614
 615 void
 616 empathy_chatroom_set_tp_chat (EmpathyChatroom *chatroom,
 617                               EmpathyTpChat   *tp_chat)
 618 {
 619         EmpathyChatroomPriv *priv;
 620
 621         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 622         g_return_if_fail (tp_chat == NULL || EMPATHY_IS_TP_CHAT (tp_chat));
 623
 624         priv = GET_PRIV (chatroom);
 625
 626         if (priv->tp_chat == tp_chat) {
 627                 return;
 628         }
 629
 630         if (priv->tp_chat != NULL) {
 631                 g_object_unref (priv->tp_chat);
 632         }
 633
 634         priv->tp_chat = tp_chat ? g_object_ref (tp_chat) : NULL;
 635         g_object_notify (G_OBJECT (chatroom), "tp-chat");
 636 }
 637
 638 gboolean
 639 empathy_chatroom_is_favorite (EmpathyChatroom *chatroom)
 640 {
 641         EmpathyChatroomPriv *priv;
 642
 643         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 644
 645         priv = GET_PRIV (chatroom);
 646
 647         return priv->favorite;
 648 }
 649
 650 void
 651 empathy_chatroom_set_favorite (EmpathyChatroom *chatroom,
 652                                gboolean         favorite)
 653 {
 654         EmpathyChatroomPriv *priv;
 655
 656         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 657
 658         priv = GET_PRIV (chatroom);
 659
 660         if (priv->favorite == favorite) {
 661                 return;
 662         }
 663
 664         priv->favorite = favorite;
 665         if (!priv->favorite) {
 666                 empathy_chatroom_set_auto_connect (chatroom, FALSE);
 667         }
 668         g_object_notify (G_OBJECT (chatroom), "favorite");
 669 }
 670