src/gui/gtk/JubGtkRosterUI.m

   1 #import <ObjXMPP/namespaces.h>
   2 #include <string.h>
   3 #include <gdk-pixbuf/gdk-pixbuf.h>
   4
   5 #import "JubGtkRosterUI.h"
   6 #import "JubGObjectMap.h"
   7 #import "JubGtkChatUI.h"
   8 #import "JubGtkHelper.h"
   9
  10 static void roster_row_activated(GtkTreeView *tree_view, GtkTreePath *path,
  11     GtkTreeViewColumn *column, gpointer data)
  12 {
  13         OFAutoreleasePool *pool;
  14         XMPPContact *contact;
  15         JubChatClient *client = data;
  16         GtkTreeIter row_iter;
  17         GtkTreeModel *tree_model;
  18         gchar *jid_s;
  19         OFString *jid;
  20
  21         tree_model = gtk_tree_view_get_model(tree_view);
  22         gtk_tree_model_get_iter(tree_model, &row_iter, path);
  23         gtk_tree_model_get(tree_model, &row_iter, 1, &jid_s, -1);
  24
  25         // This was a group row
  26         if (!jid_s) return;
  27
  28         pool = [OFAutoreleasePool new];
  29
  30         jid = [OFString stringWithUTF8String: jid_s];
  31         contact = [client.contactManager.contacts objectForKey: jid];
  32
  33         [client performSelectorOnMainThread: @selector(chatForContact:)
  34                                  withObject: contact
  35                               waitUntilDone: false];
  36         [pool release];
  37 }
  38
  39 static void presence_changed(GtkComboBox *combo_box, gpointer data)
  40 {
  41         JubChatClient *client = data;
  42         OFAutoreleasePool *pool = [OFAutoreleasePool new];
  43         const char *status = gtk_combo_box_get_active_id(combo_box);
  44
  45         [client sendPresenceWithStatus: @(status)];
  46
  47         [pool release];
  48 }
  49
  50 static gboolean filter_roster_by_presence(GtkTreeModel *model,
  51     GtkTreeIter *iter, gpointer data)
  52 {
  53         bool *showOffline = data;
  54         char *status;
  55         gtk_tree_model_get(model, iter, 2, &status, -1);
  56
  57         // Groups have no status
  58         if (!status)
  59                 return TRUE;
  60
  61         if (!*showOffline && !strcmp(status, "unavailable"))
  62                 return FALSE;
  63
  64         return TRUE;
  65 }
  66
  67 static void menu_show_offline(GtkCheckMenuItem *checkmenuitem, gpointer data)
  68 {
  69         JubGtkRosterUI *ui = data;
  70         ui.showOffline = gtk_check_menu_item_get_active(checkmenuitem);
  71 }
  72
  73 static void dialog_response_callback(GtkDialog *dialog, gint response_id,
  74     gpointer user_data)
  75 {
  76         void (^block)(gint) = user_data;
  77         block(response_id);
  78         [block release];
  79 }
  80
  81 @implementation JubGtkRosterUI
  82 - initWithClient: (JubChatClient*)client
  83 {
  84         self = [super init];
  85
  86         @try {
  87                 GtkCheckMenuItem *show_offline_menu_item;
  88                 GtkTreeView *roster_view;
  89                 GtkBuilder *builder;
  90
  91                 _groupMap = [[OFMapTable alloc]
  92                     initWithKeyFunctions: keyFunctions
  93                           valueFunctions: rowRefFunctions];
  94                 _subDialogMap = [[OFMapTable alloc]
  95                     initWithKeyFunctions: keyFunctions
  96                     valueFunctions: gObjectFunctions];
  97                 _contactMap = [[OFMutableDictionary alloc] init];
  98                 _client = [client retain];
  99
 100                 [_client.contactManager addDelegate: self];
 101                 [_client.avatarManager setDelegate: self];
 102
 103                 builder = gtk_builder_new();
 104                 gtk_builder_add_from_file(builder, "data/gtk/roster.ui", NULL);
 105                 gtk_builder_connect_signals(builder, NULL);
 106
 107                 _roster_window =
 108                     GTK_WIDGET(gtk_builder_get_object(builder, "RosterWindow"));
 109
 110                 gtk_widget_show(_roster_window);
 111
 112                 _roster_model = GTK_TREE_STORE(gtk_builder_get_object(builder,
 113                     "RosterTreeStore"));
 114
 115                 _roster_filter = GTK_TREE_MODEL_FILTER(
 116                     gtk_builder_get_object(builder, "RosterTreeModelFilter"));
 117
 118                 gtk_tree_model_filter_set_visible_func(_roster_filter,
 119                     filter_roster_by_presence, &_showOffline, NULL);
 120
 121                 roster_view = GTK_TREE_VIEW(gtk_builder_get_object(builder,
 122                         "RosterTreeView"));
 123
 124                 g_signal_connect(roster_view, "row_activated",
 125                     G_CALLBACK(roster_row_activated), client);
 126
 127                 _presence_combo = GTK_COMBO_BOX(gtk_builder_get_object(builder,
 128                         "PresenceComboBox"));
 129
 130                 _presence_combo_changed_handler_id =
 131                     g_signal_connect(_presence_combo, "changed",
 132                         G_CALLBACK(presence_changed), client);
 133
 134                 show_offline_menu_item =
 135                     GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder,
 136                         "showOfflineCheckMenuItem"));
 137
 138                 g_signal_connect(show_offline_menu_item, "toggled",
 139                     G_CALLBACK(menu_show_offline), self);
 140
 141                 g_object_unref(G_OBJECT(builder));
 142         } @catch (id e) {
 143                 [self release];
 144                 @throw e;
 145         }
 146
 147         return self;
 148 }
 149
 150 - (void)dealloc
 151 {
 152         [_client.avatarManager setDelegate: nil];
 153         [_client.contactManager removeDelegate: self];
 154         [_subDialogMap release];
 155         [_groupMap release];
 156         [_contactMap release];
 157         [_client release];
 158
 159         gtk_widget_destroy(_roster_window);
 160
 161         [super dealloc];
 162 }
 163
 164 - (void)Jub_closeSubscribeDialogForRosterItem: (XMPPRosterItem*)rosterItem
 165 {
 166         // Close subscripton dialogs, answered on another client
 167         GtkDialog *dialog;
 168         OFString *subscription = rosterItem.subscription;
 169         OFString *bareJID = [rosterItem.JID bareJID];
 170
 171         if (([subscription isEqual: @"from"] ||
 172              [subscription isEqual: @"both"]) &&
 173             (dialog = [_subDialogMap valueForKey: bareJID]) != NULL)
 174                 gtk_dialog_response(dialog, GTK_RESPONSE_NONE);
 175 }
 176
 177 /* Roster Delegate methods */
 178 - (void)Jub_addRosterItem: (XMPPRosterItem*)item
 179                     group: (OFString*)group
 180 {
 181         GtkTreeIter group_iter, contact_iter;
 182         GtkTreeRowReference *group_ref, *contact_ref;
 183         GtkTreePath *group_path, *contact_path;
 184         OFString *bareJID = [item.JID bareJID];
 185         OFMapTable *contactRows;
 186
 187         if (!(contactRows = [_contactMap objectForKey: bareJID])) {
 188                 contactRows = [OFMapTable
 189                     mapTableWithKeyFunctions: keyFunctions
 190                               valueFunctions: rowRefFunctions];
 191
 192                 [_contactMap setObject: contactRows
 193                                 forKey: bareJID];
 194         }
 195
 196         group_ref = [_groupMap valueForKey: group];
 197
 198         if (!group_ref) {
 199                 // Create new group row
 200                 gtk_tree_store_append(_roster_model, &group_iter, NULL);
 201                 gtk_tree_store_set(_roster_model, &group_iter,
 202                     0, [group UTF8String], -1);
 203
 204                 group_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
 205                     _roster_model), &group_iter);
 206
 207                 group_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
 208                     _roster_model), group_path);
 209
 210                 [_groupMap setValue: group_ref
 211                              forKey: group];
 212         } else {
 213                 // Get iter for existing group row
 214                 group_path = gtk_tree_row_reference_get_path(group_ref);
 215
 216                 gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model),
 217                     &group_iter, group_path);
 218         }
 219         gtk_tree_path_free(group_path);
 220
 221         // Create new contact row
 222         gtk_tree_store_append(_roster_model, &contact_iter, &group_iter);
 223         if (item.name)
 224                 gtk_tree_store_set(_roster_model, &contact_iter,
 225                     0, [item.name UTF8String],
 226                     1, [bareJID UTF8String],
 227                     2, "unavailable", -1);
 228         else if (item.JID.node)
 229                 gtk_tree_store_set(_roster_model, &contact_iter,
 230                     0, [item.JID.node UTF8String],
 231                     1, [bareJID UTF8String],
 232                     2, "unavailable", -1);
 233         else
 234                 gtk_tree_store_set(_roster_model, &contact_iter,
 235                     0, [item.JID.domain UTF8String],
 236                     1, [bareJID UTF8String],
 237                     2, "unavailable", -1);
 238
 239         contact_path = gtk_tree_model_get_path(GTK_TREE_MODEL(_roster_model),
 240             &contact_iter);
 241
 242         contact_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(_roster_model),
 243             contact_path);
 244
 245         gtk_tree_path_free(contact_path);
 246
 247         [contactRows setValue: contact_ref
 248                        forKey: group];
 249 }
 250
 251 - (void)Jub_removeRosterItem: (XMPPRosterItem*)item
 252                        group: (OFString*)group
 253 {
 254         GtkTreeIter contact_iter, group_iter;
 255         GtkTreePath *contact_path, *group_path;
 256         GtkTreeRowReference *contact_ref, *group_ref;
 257         OFString *bareJID = [item.JID bareJID];
 258         OFMapTable *contactRows = [_contactMap objectForKey: bareJID];
 259
 260         contact_ref = [contactRows valueForKey: group];
 261         contact_path = gtk_tree_row_reference_get_path(contact_ref);
 262         gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model), &contact_iter,
 263             contact_path);
 264         gtk_tree_path_free(contact_path);
 265
 266         gtk_tree_store_remove(_roster_model, &contact_iter);
 267
 268         group_ref = [_groupMap valueForKey: group];
 269         group_path = gtk_tree_row_reference_get_path(group_ref);
 270         gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model), &group_iter,
 271             group_path);
 272
 273         if (!gtk_tree_model_iter_has_child(GTK_TREE_MODEL(_roster_model),
 274             &group_iter)) {
 275                 gtk_tree_store_remove(_roster_model, &group_iter);
 276                 [_groupMap removeValueForKey: group];
 277         }
 278
 279         gtk_tree_path_free(group_path);
 280
 281         [contactRows removeValueForKey: group];
 282         if([contactRows count] == 0)
 283                 [_contactMap removeObjectForKey: bareJID];
 284 }
 285
 286 - (void)contactManager: (XMPPContactManager*)manager
 287          didAddContact: (XMPPContact*)contact
 288 {
 289         XMPPRosterItem *rosterItem = contact.rosterItem;
 290         OFArray *groups = rosterItem.groups;;
 291
 292         if (groups == nil)
 293                 groups = @[ @"General" ];
 294
 295         for (OFString *group in groups)
 296                 [self performSelectorOnGLibThread: @selector(
 297                     Jub_addRosterItem:group:)
 298                                        withObject: rosterItem
 299                                        withObject: group];
 300
 301         [self Jub_closeSubscribeDialogForRosterItem: rosterItem];
 302 }
 303
 304 - (void)contactManager: (XMPPContactManager*)manager
 305       didRemoveContact: (XMPPContact*)contact
 306 {
 307         XMPPRosterItem *rosterItem = contact.rosterItem;
 308         OFArray *groups = rosterItem.groups;
 309
 310         if (groups == nil)
 311                 groups = @[ @"General" ];
 312
 313         for (OFString *group in groups)
 314                 [self performSelectorOnGLibThread: @selector(
 315                     Jub_removeRosterItem:group:)
 316                                        withObject: rosterItem
 317                                        withObject: group];
 318 }
 319
 320 -          (void)contactManager: (XMPPContactManager*)manager
 321   didReceiveSubscriptionRequest: (XMPPPresence*)presence
 322 {
 323         XMPPJID *JID = presence.from;
 324         OFString *bareJID = [JID bareJID];
 325         OFString *message = [OFString stringWithFormat: @"<b>%@</b> would like "
 326             @"to subscribe to your presence.", bareJID];
 327         g_idle_add_block(^{
 328                 GtkWidget *dialog, *content_area, *label;
 329
 330                 if ([_subDialogMap valueForKey: JID] != NULL)
 331                         return;
 332
 333                 dialog = gtk_dialog_new_with_buttons("Subscription Request",
 334                     GTK_WINDOW(_roster_window), GTK_DIALOG_DESTROY_WITH_PARENT,
 335                     "Accept", GTK_RESPONSE_ACCEPT,
 336                     "Deny", GTK_RESPONSE_REJECT, NULL);
 337
 338                 content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
 339                 label = gtk_label_new(NULL);
 340                 gtk_label_set_markup(GTK_LABEL(label), [message UTF8String]);
 341                 gtk_container_add(GTK_CONTAINER(content_area), label);
 342
 343                 g_signal_connect(dialog, "response",
 344                     G_CALLBACK(dialog_response_callback),
 345                     [^(gint response_id) {
 346                         if (response_id == GTK_RESPONSE_ACCEPT)
 347                                 [manager sendSubscribedToJID: JID];
 348                         else if (response_id == GTK_RESPONSE_REJECT)
 349                                 [manager sendUnsubscribedToJID: JID];
 350                         [_subDialogMap removeValueForKey: bareJID];
 351                         gtk_widget_destroy(GTK_WIDGET(dialog));
 352                 } copy]);
 353
 354                 [_subDialogMap setValue: dialog
 355                                  forKey: bareJID];
 356
 357                 gtk_widget_show_all(dialog);
 358         });
 359 }
 360
 361 -            (void)contact: (XMPPContact*)contact
 362   willUpdateWithRosterItem: (XMPPRosterItem*)rosterItem;
 363 {
 364         [self Jub_closeSubscribeDialogForRosterItem: rosterItem];
 365
 366         // Remove contact from old set of groups
 367         XMPPRosterItem *oldItem = contact.rosterItem;
 368         OFArray *groups = oldItem.groups;
 369
 370         if (groups == nil)
 371                 groups = @[ @"General" ];
 372
 373         for (OFString *group in groups)
 374                 [self performSelectorOnGLibThread: @selector(
 375                     Jub_removeRosterItem:group:)
 376                                        withObject: oldItem
 377                                        withObject: group];
 378
 379         // Add contact to new set of groups
 380         groups = rosterItem.groups;
 381
 382         if (groups == nil)
 383                 groups = @[ @"General" ];
 384
 385         for (OFString *group in groups)
 386                 [self performSelectorOnGLibThread: @selector(
 387                     Jub_addRosterItem:group:)
 388                                        withObject: rosterItem
 389                                        withObject: group];
 390 }
 391
 392 -   (void)contact: (XMPPContact*)contact
 393   didSendPresence: (XMPPPresence*)presence
 394 {
 395         OFDictionary *allPresences = [contact presences];
 396         XMPPPresence *highPresence = [[[allPresences allObjects] sortedArray]
 397                                          lastObject];
 398         OFMutableString *tooltip =
 399             [OFMutableString stringWithString: @"<b>Resources:</b>"];
 400
 401         [allPresences enumerateKeysAndObjectsUsingBlock:
 402             ^(OFString *resource, XMPPPresence *pres, bool *stop) {
 403                 [tooltip appendString: @"\n"];
 404                 [tooltip appendString: resource];
 405                 if ([pres.type isEqual: @"available"]) {
 406                         if (pres.show != nil)
 407                                 [tooltip appendFormat: @" (%@)", pres.show];
 408                         else
 409                                 [tooltip appendString: @" (available)"];
 410                 } else
 411                         [tooltip appendString: @" (unavailable)"];
 412
 413                 if (pres.status)
 414                         [tooltip appendFormat: @": <i>%@</i>", pres.status];
 415         }];
 416
 417         g_idle_add_block(^{
 418                 GtkTreeIter iter;
 419                 GtkTreePath *path;
 420                 GtkTreeRowReference *ref;
 421                 OFString *bareJID = [contact.rosterItem.JID bareJID];
 422                 OFMapTable *contactRows = [_contactMap objectForKey: bareJID];
 423                 OFArray *groups = contact.rosterItem.groups;;
 424
 425                 if (groups == nil)
 426                         groups = @[ @"General" ];
 427
 428                 for (OFString *group in groups) {
 429                         ref = [contactRows valueForKey: group];
 430                         path = gtk_tree_row_reference_get_path(ref);
 431                         gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model),
 432                             &iter, path);
 433                         gtk_tree_path_free(path);
 434
 435                         if ([highPresence.type isEqual: @"available"]) {
 436                                 if (highPresence.show != nil)
 437                                         gtk_tree_store_set(_roster_model, &iter,
 438                                             2, [highPresence.show UTF8String],
 439                                             -1);
 440                                 else
 441                                         gtk_tree_store_set(_roster_model, &iter,
 442                                             2, "available", -1);
 443                         } else
 444                                 gtk_tree_store_set(_roster_model, &iter,
 445                                     2, "unavailable", -1);
 446
 447                         gtk_tree_store_set(_roster_model, &iter,
 448                             3, [tooltip UTF8String], -1);
 449                 }
 450
 451                 gtk_tree_model_filter_refilter(_roster_filter);
 452         });
 453 }
 454
 455 - (void)contact: (XMPPContact*)contact
 456    didSetAvatar: (OFString*)avatarFile
 457 {
 458         of_log(@"Got an avatar from %@", contact.rosterItem.JID);
 459         g_idle_add_block(^{
 460                 GtkTreeIter iter;
 461                 GtkTreePath *path;
 462                 GtkTreeRowReference *ref;
 463                 OFString *bareJID = [contact.rosterItem.JID bareJID];
 464                 OFMapTable *contactRows = [_contactMap objectForKey: bareJID];
 465                 OFArray *groups = contact.rosterItem.groups;;
 466
 467                 GdkPixbuf *avatar =
 468                     gdk_pixbuf_new_from_file_at_size([avatarFile UTF8String],
 469                         32, 32, NULL);
 470
 471                 if (groups == nil)
 472                         groups = @[ @"General" ];
 473
 474                 for (OFString *group in groups) {
 475                         ref = [contactRows valueForKey: group];
 476                         path = gtk_tree_row_reference_get_path(ref);
 477                         gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model),
 478                             &iter, path);
 479                         gtk_tree_path_free(path);
 480
 481                         gtk_tree_store_set(_roster_model, &iter,
 482                             4, avatar, -1);
 483                 }
 484                 g_object_unref(G_OBJECT(avatar));
 485         });
 486 }
 487
 488 -      (void)client: (JubChatClient*)client_
 489   didChangePresence: (XMPPPresence*)presence
 490 {
 491         OFString *tooltip = @"";
 492         OFString *show =
 493             [[presence elementForName: @"show"
 494                             namespace: XMPP_NS_CLIENT] stringValue];
 495         OFString *status =
 496             [[presence elementForName: @"status"
 497                             namespace: XMPP_NS_CLIENT] stringValue];
 498
 499         if (status != nil)
 500                 tooltip = [@"<b>Status:</b> " stringByAppendingString: status];
 501
 502         g_idle_add_block(^{
 503                 // Block the PresenceComboBox's changed handler, so it doesn't
 504                 // fire and resend presence
 505                 g_signal_handler_block(_presence_combo,
 506                     _presence_combo_changed_handler_id);
 507
 508                 if ([presence.type isEqual: @"unavailable"])
 509                         gtk_combo_box_set_active_id(_presence_combo,
 510                             "unavailable");
 511                 else if (show == nil)
 512                         gtk_combo_box_set_active_id(_presence_combo,
 513                             "available");
 514                 else
 515                         gtk_combo_box_set_active_id(_presence_combo,
 516                             [show UTF8String]);
 517
 518                 // Unblock the changed handler
 519                 g_signal_handler_unblock(_presence_combo,
 520                     _presence_combo_changed_handler_id);
 521
 522                 gtk_widget_set_tooltip_markup(GTK_WIDGET(_presence_combo),
 523                     [tooltip UTF8String]);
 524         });
 525 }
 526
 527 - (bool)showOffline
 528 {
 529         OF_GETTER(_showOffline, true);
 530 }
 531
 532 - (void)setShowOffline: (bool)showOffline
 533 {
 534         _showOffline = showOffline;
 535         g_idle_add_block(^{
 536                 gtk_tree_model_filter_refilter(_roster_filter);
 537         });
 538 }
 539 @end