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