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