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