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