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