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