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
 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         EmpathyChatroomPriv *priv;
 277
 278         priv = GET_PRIV (object);
 279
 280         switch (param_id) {
 281         case PROP_ACCOUNT:
 282                 empathy_chatroom_set_account (EMPATHY_CHATROOM (object),
 283                                              g_value_get_object (value));
 284                 break;
 285         case PROP_ROOM:
 286                 empathy_chatroom_set_room (EMPATHY_CHATROOM (object),
 287                                           g_value_get_string (value));
 288                 break;
 289         case PROP_NAME:
 290                 empathy_chatroom_set_name (EMPATHY_CHATROOM (object),
 291                                           g_value_get_string (value));
 292                 break;
 293         case PROP_AUTO_CONNECT:
 294                 empathy_chatroom_set_auto_connect (EMPATHY_CHATROOM (object),
 295                                                   g_value_get_boolean (value));
 296                 break;
 297         case PROP_FAVORITE:
 298                 empathy_chatroom_set_favorite (EMPATHY_CHATROOM (object),
 299                                                g_value_get_boolean (value));
 300                 break;
 301         case PROP_ALWAYS_URGENT:
 302                 empathy_chatroom_set_always_urgent (EMPATHY_CHATROOM (object),
 303                                                g_value_get_boolean (value));
 304                 break;
 305         case PROP_TP_CHAT:
 306                 empathy_chatroom_set_tp_chat (EMPATHY_CHATROOM (object),
 307                                               g_value_get_object (value));
 308                 break;
 309   case PROP_SUBJECT:
 310     empathy_chatroom_set_subject (EMPATHY_CHATROOM (object),
 311         g_value_get_string (value));
 312     break;
 313   case PROP_MEMBERS_COUNT:
 314     empathy_chatroom_set_members_count (EMPATHY_CHATROOM (object),
 315         g_value_get_uint (value));
 316     break;
 317   case PROP_NEED_PASSWORD:
 318     empathy_chatroom_set_need_password (EMPATHY_CHATROOM (object),
 319         g_value_get_boolean (value));
 320     break;
 321   case PROP_INVITE_ONLY:
 322     empathy_chatroom_set_invite_only (EMPATHY_CHATROOM (object),
 323         g_value_get_boolean (value));
 324     break;
 325         default:
 326                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 327                 break;
 328         };
 329 }
 330
 331 EmpathyChatroom *
 332 empathy_chatroom_new (TpAccount *account)
 333 {
 334         return g_object_new (EMPATHY_TYPE_CHATROOM,
 335                              "account", account,
 336                              NULL);
 337 }
 338
 339 EmpathyChatroom *
 340 empathy_chatroom_new_full (TpAccount *account,
 341                           const gchar *room,
 342                           const gchar *name,
 343                           gboolean     auto_connect)
 344 {
 345         g_return_val_if_fail (room != NULL, NULL);
 346
 347         return g_object_new (EMPATHY_TYPE_CHATROOM,
 348                              "account", account,
 349                              "room", room,
 350                              "name", name,
 351                              "auto_connect", auto_connect,
 352                              NULL);
 353 }
 354
 355 TpAccount *
 356 empathy_chatroom_get_account (EmpathyChatroom *chatroom)
 357 {
 358         EmpathyChatroomPriv *priv;
 359
 360         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 361
 362         priv = GET_PRIV (chatroom);
 363         return priv->account;
 364 }
 365
 366 void
 367 empathy_chatroom_set_account (EmpathyChatroom *chatroom,
 368                              TpAccount *account)
 369 {
 370         EmpathyChatroomPriv *priv;
 371
 372         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 373
 374         priv = GET_PRIV (chatroom);
 375
 376         if (account == priv->account) {
 377                 return;
 378         }
 379         if (priv->account) {
 380                 g_object_unref (priv->account);
 381         }
 382         priv->account = g_object_ref (account);
 383
 384         g_object_notify (G_OBJECT (chatroom), "account");
 385 }
 386
 387 const gchar *
 388 empathy_chatroom_get_room (EmpathyChatroom *chatroom)
 389 {
 390         EmpathyChatroomPriv *priv;
 391
 392         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 393
 394         priv = GET_PRIV (chatroom);
 395         return priv->room;
 396 }
 397
 398 void
 399 empathy_chatroom_set_room (EmpathyChatroom *chatroom,
 400                           const gchar    *room)
 401 {
 402         EmpathyChatroomPriv *priv;
 403
 404         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 405         g_return_if_fail (room != NULL);
 406
 407         priv = GET_PRIV (chatroom);
 408
 409         g_free (priv->room);
 410         priv->room = g_strdup (room);
 411
 412         g_object_notify (G_OBJECT (chatroom), "room");
 413 }
 414
 415 const gchar *
 416 empathy_chatroom_get_name (EmpathyChatroom *chatroom)
 417 {
 418         EmpathyChatroomPriv *priv;
 419
 420         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 421
 422         priv = GET_PRIV (chatroom);
 423
 424         if (EMP_STR_EMPTY (priv->name)) {
 425                 return priv->room;
 426         }
 427
 428         return priv->name;
 429 }
 430
 431 void
 432 empathy_chatroom_set_name (EmpathyChatroom *chatroom,
 433                           const gchar    *name)
 434 {
 435         EmpathyChatroomPriv *priv;
 436
 437         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 438
 439         priv = GET_PRIV (chatroom);
 440
 441         g_free (priv->name);
 442         priv->name = NULL;
 443         if (name) {
 444                 priv->name = g_strdup (name);
 445         }
 446
 447         g_object_notify (G_OBJECT (chatroom), "name");
 448 }
 449
 450 gboolean
 451 empathy_chatroom_get_auto_connect (EmpathyChatroom *chatroom)
 452 {
 453         EmpathyChatroomPriv *priv;
 454
 455         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 456
 457         priv = GET_PRIV (chatroom);
 458         return priv->auto_connect;
 459 }
 460
 461 void
 462 empathy_chatroom_set_auto_connect (EmpathyChatroom *chatroom,
 463                                   gboolean        auto_connect)
 464 {
 465         EmpathyChatroomPriv *priv;
 466
 467         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 468
 469         priv = GET_PRIV (chatroom);
 470
 471         priv->auto_connect = auto_connect;
 472
 473         if (priv->auto_connect) {
 474                 /* auto_connect implies favorite */
 475                 priv->favorite = TRUE;
 476                 g_object_notify (G_OBJECT (chatroom), "favorite");
 477         }
 478
 479         g_object_notify (G_OBJECT (chatroom), "auto-connect");
 480 }
 481
 482 gboolean
 483 empathy_chatroom_equal (gconstpointer v1,
 484                        gconstpointer v2)
 485 {
 486         TpAccount *account_a;
 487         TpAccount *account_b;
 488         const gchar *room_a;
 489         const gchar *room_b;
 490
 491         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v1), FALSE);
 492         g_return_val_if_fail (EMPATHY_IS_CHATROOM (v2), FALSE);
 493
 494         account_a = empathy_chatroom_get_account (EMPATHY_CHATROOM (v1));
 495         account_b = empathy_chatroom_get_account (EMPATHY_CHATROOM (v2));
 496
 497         room_a = empathy_chatroom_get_room (EMPATHY_CHATROOM (v1));
 498         room_b = empathy_chatroom_get_room (EMPATHY_CHATROOM (v2));
 499
 500         return account_a == account_b && !tp_strdiff (room_a, room_b);
 501 }
 502
 503 EmpathyTpChat *
 504 empathy_chatroom_get_tp_chat (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->tp_chat;
 513 }
 514
 515 const gchar *
 516 empathy_chatroom_get_subject (EmpathyChatroom *chatroom)
 517 {
 518   EmpathyChatroomPriv *priv;
 519
 520   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), NULL);
 521
 522   priv = GET_PRIV (chatroom);
 523
 524   return priv->subject;
 525 }
 526
 527 void
 528 empathy_chatroom_set_subject (EmpathyChatroom *chatroom,
 529                               const gchar *subject)
 530 {
 531   EmpathyChatroomPriv *priv;
 532
 533   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 534
 535   priv = GET_PRIV (chatroom);
 536
 537   g_free (priv->subject);
 538   priv->subject = NULL;
 539
 540   if (subject)
 541     priv->subject = g_strdup (subject);
 542
 543   g_object_notify (G_OBJECT (chatroom), "subject");
 544 }
 545
 546 guint
 547 empathy_chatroom_get_members_count (EmpathyChatroom *chatroom)
 548 {
 549   EmpathyChatroomPriv *priv;
 550
 551   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), 0);
 552
 553   priv = GET_PRIV (chatroom);
 554
 555   return priv->members_count;
 556 }
 557
 558 void
 559 empathy_chatroom_set_members_count (EmpathyChatroom *chatroom,
 560                                     guint count)
 561 {
 562   EmpathyChatroomPriv *priv;
 563
 564   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 565
 566   priv = GET_PRIV (chatroom);
 567
 568   priv->members_count = count;
 569
 570   g_object_notify (G_OBJECT (chatroom), "members-count");
 571 }
 572
 573 gboolean
 574 empathy_chatroom_get_need_password (EmpathyChatroom *chatroom)
 575 {
 576   EmpathyChatroomPriv *priv;
 577
 578   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 579
 580   priv = GET_PRIV (chatroom);
 581
 582   return priv->need_password;
 583 }
 584
 585 void
 586 empathy_chatroom_set_need_password (EmpathyChatroom *chatroom,
 587                                     gboolean need_password)
 588 {
 589   EmpathyChatroomPriv *priv;
 590
 591   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 592
 593   priv = GET_PRIV (chatroom);
 594
 595   priv->need_password = need_password;
 596
 597   g_object_notify (G_OBJECT (chatroom), "need-password");
 598 }
 599
 600 gboolean
 601 empathy_chatroom_get_invite_only (EmpathyChatroom *chatroom)
 602 {
 603   EmpathyChatroomPriv *priv;
 604
 605   g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 606
 607   priv = GET_PRIV (chatroom);
 608
 609   return priv->invite_only;
 610 }
 611
 612 void
 613 empathy_chatroom_set_invite_only (EmpathyChatroom *chatroom,
 614                                   gboolean invite_only)
 615 {
 616   EmpathyChatroomPriv *priv;
 617
 618   g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 619
 620   priv = GET_PRIV (chatroom);
 621
 622   priv->invite_only = invite_only;
 623
 624   g_object_notify (G_OBJECT (chatroom), "invite-only");
 625 }
 626
 627 void
 628 empathy_chatroom_set_tp_chat (EmpathyChatroom *chatroom,
 629                               EmpathyTpChat   *tp_chat)
 630 {
 631         EmpathyChatroomPriv *priv;
 632
 633         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 634         g_return_if_fail (tp_chat == NULL || EMPATHY_IS_TP_CHAT (tp_chat));
 635
 636         priv = GET_PRIV (chatroom);
 637
 638         if (priv->tp_chat == tp_chat) {
 639                 return;
 640         }
 641
 642         if (priv->tp_chat != NULL) {
 643                 g_object_unref (priv->tp_chat);
 644         }
 645
 646         priv->tp_chat = tp_chat ? g_object_ref (tp_chat) : NULL;
 647         g_object_notify (G_OBJECT (chatroom), "tp-chat");
 648 }
 649
 650 gboolean
 651 empathy_chatroom_is_favorite (EmpathyChatroom *chatroom)
 652 {
 653         EmpathyChatroomPriv *priv;
 654
 655         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 656
 657         priv = GET_PRIV (chatroom);
 658
 659         return priv->favorite;
 660 }
 661
 662 void
 663 empathy_chatroom_set_favorite (EmpathyChatroom *chatroom,
 664                                gboolean         favorite)
 665 {
 666         EmpathyChatroomPriv *priv;
 667
 668         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 669
 670         priv = GET_PRIV (chatroom);
 671
 672         if (priv->favorite == favorite) {
 673                 return;
 674         }
 675
 676         priv->favorite = favorite;
 677         if (!priv->favorite) {
 678                 empathy_chatroom_set_auto_connect (chatroom, FALSE);
 679         }
 680         g_object_notify (G_OBJECT (chatroom), "favorite");
 681 }
 682
 683 gboolean
 684 empathy_chatroom_is_always_urgent (EmpathyChatroom *chatroom)
 685 {
 686         EmpathyChatroomPriv *priv;
 687
 688         g_return_val_if_fail (EMPATHY_IS_CHATROOM (chatroom), FALSE);
 689
 690         priv = GET_PRIV (chatroom);
 691
 692         return priv->always_urgent;
 693 }
 694
 695 void
 696 empathy_chatroom_set_always_urgent (EmpathyChatroom *chatroom,
 697                                gboolean         always_urgent)
 698 {
 699         EmpathyChatroomPriv *priv;
 700
 701         g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
 702
 703         priv = GET_PRIV (chatroom);
 704
 705         if (priv->always_urgent == always_urgent)
 706                 return;
 707
 708         priv->always_urgent = always_urgent;
 709         g_object_notify (G_OBJECT (chatroom), "always_urgent");
 710 }
 711