src/gui/gtk/JubGtkRosterUI.m

   1 #import <ObjXMPP/namespaces.h>
   2 #include <string.h>
   3
   4 #import "JubGtkRosterUI.h"
   5 #import "JubGObjectMap.h"
   6 #import "JubGtkChatUI.h"
   7 #import "JubGtkHelper.h"
   8
   9 static void roster_row_activated(GtkTreeView *tree_view, GtkTreePath *path,
  10     GtkTreeViewColumn *column, gpointer data)
  11 {
  12         OFAutoreleasePool *pool;
  13         XMPPContact *contact;
  14         JubChatClient *client = data;
  15         GtkTreeIter row_iter;
  16         GtkTreeModel *tree_model;
  17         gchar *jid_s;
  18         OFString *jid;
  19
  20         tree_model = gtk_tree_view_get_model(tree_view);
  21         gtk_tree_model_get_iter(tree_model, &row_iter, path);
  22         gtk_tree_model_get(tree_model, &row_iter, 1, &jid_s, -1);
  23
  24         // This was a group row
  25         if (!jid_s) return;
  26
  27         pool = [OFAutoreleasePool new];
  28
  29         jid = [OFString stringWithUTF8String: jid_s];
  30         contact = [client.contactManager.contacts objectForKey: jid];
  31
  32         [client performSelectorOnMainThread: @selector(chatForContact:)
  33                                  withObject: contact
  34                               waitUntilDone: NO];
  35         [pool release];
  36 }
  37
  38 static void presence_changed(GtkComboBox *combo_box, gpointer data)
  39 {
  40         JubChatClient *client = data;
  41         OFAutoreleasePool *pool = [OFAutoreleasePool new];
  42         const char *status = gtk_combo_box_get_active_id(combo_box);
  43
  44         [client sendPresenceWithStatus: @(status)];
  45
  46         [pool release];
  47 }
  48
  49 static gboolean filter_roster_by_presence(GtkTreeModel *model,
  50     GtkTreeIter *iter, gpointer data)
  51 {
  52         char *status;
  53         gtk_tree_model_get(model, iter, 2, &status, -1);
  54
  55         // Groups have no status
  56         if (!status)
  57                 return TRUE;
  58
  59         if (!strcmp(status, "unavailable"))
  60                 return FALSE;
  61
  62         return TRUE;
  63 }
  64
  65 @implementation JubGtkRosterUI
  66 - initWithClient: (JubChatClient*)client
  67 {
  68         self = [super init];
  69
  70         @try {
  71                 GtkTreeView *roster_view;
  72                 GtkBuilder *builder;
  73
  74                 _groupMap = [[OFMapTable alloc]
  75                     initWithKeyFunctions: keyFunctions
  76                           valueFunctions: rowRefFunctions];
  77                 _contactMap = [[OFMutableDictionary alloc] init];
  78                 _client = [client retain];
  79
  80                 [_client.contactManager addDelegate: self];
  81
  82                 builder = gtk_builder_new();
  83                 gtk_builder_add_from_file(builder, "data/gtk/roster.ui", NULL);
  84                 gtk_builder_connect_signals(builder, NULL);
  85
  86                 _roster_window =
  87                     GTK_WIDGET(gtk_builder_get_object(builder, "RosterWindow"));
  88
  89                 gtk_widget_show(_roster_window);
  90
  91                 _roster_model = GTK_TREE_STORE(gtk_builder_get_object(builder,
  92                     "RosterTreeStore"));
  93
  94                 _roster_filter = GTK_TREE_MODEL_FILTER(
  95                     gtk_builder_get_object(builder, "RosterTreeModelFilter"));
  96
  97                 gtk_tree_model_filter_set_visible_func(_roster_filter,
  98                     filter_roster_by_presence, NULL, NULL);
  99
 100                 roster_view = GTK_TREE_VIEW(gtk_builder_get_object(builder,
 101                         "RosterTreeView"));
 102
 103                 g_signal_connect(roster_view, "row_activated",
 104                     G_CALLBACK(roster_row_activated), client);
 105
 106                 _presence_combo = GTK_COMBO_BOX(gtk_builder_get_object(builder,
 107                         "PresenceComboBox"));
 108
 109                 _presence_combo_changed_handler_id =
 110                     g_signal_connect(_presence_combo, "changed",
 111                         G_CALLBACK(presence_changed), client);
 112
 113                 g_object_unref(G_OBJECT(builder));
 114         } @catch (id e) {
 115                 [self release];
 116                 @throw e;
 117         }
 118
 119         return self;
 120 }
 121
 122 - (void)dealloc
 123 {
 124         [_client.contactManager removeDelegate: self];
 125         [_groupMap release];
 126         [_contactMap release];
 127         [_client release];
 128
 129         gtk_widget_destroy(_roster_window);
 130
 131         [super dealloc];
 132 }
 133
 134 /* Roster Delegate methods */
 135 - (void)Jub_addRosterItem: (XMPPRosterItem*)item
 136                     group: (OFString*)group
 137 {
 138         GtkTreeIter group_iter, contact_iter;
 139         GtkTreeRowReference *group_ref, *contact_ref;
 140         GtkTreePath *group_path, *contact_path;
 141         OFString *bareJID = [item.JID bareJID];
 142         OFMapTable *contactRows;
 143
 144         if (!(contactRows = [_contactMap objectForKey: bareJID])) {
 145                 contactRows = [OFMapTable
 146                     mapTableWithKeyFunctions: keyFunctions
 147                               valueFunctions: rowRefFunctions];
 148
 149                 [_contactMap setObject: contactRows
 150                                 forKey: bareJID];
 151         }
 152
 153         group_ref = [_groupMap valueForKey: group];
 154
 155         if (!group_ref) {
 156                 // Create new group row
 157                 gtk_tree_store_append(_roster_model, &group_iter, NULL);
 158                 gtk_tree_store_set(_roster_model, &group_iter,
 159                     0, [group UTF8String], -1);
 160
 161                 group_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
 162                     _roster_model), &group_iter);
 163
 164                 group_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
 165                     _roster_model), group_path);
 166
 167                 [_groupMap setValue: group_ref
 168                              forKey: group];
 169         } else {
 170                 // Get iter for existing group row
 171                 group_path = gtk_tree_row_reference_get_path(group_ref);
 172
 173                 gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model),
 174                     &group_iter, group_path);
 175         }
 176         gtk_tree_path_free(group_path);
 177
 178         // Create new contact row
 179         gtk_tree_store_append(_roster_model, &contact_iter, &group_iter);
 180         if (item.name)
 181                 gtk_tree_store_set(_roster_model, &contact_iter,
 182                     0, [item.name UTF8String],
 183                     1, [bareJID UTF8String],
 184                     2, "unavailable", -1);
 185         else if (item.JID.node)
 186                 gtk_tree_store_set(_roster_model, &contact_iter,
 187                     0, [item.JID.node UTF8String],
 188                     1, [bareJID UTF8String],
 189                     2, "unavailable", -1);
 190         else
 191                 gtk_tree_store_set(_roster_model, &contact_iter,
 192                     0, [item.JID.domain UTF8String],
 193                     1, [bareJID UTF8String],
 194                     2, "unavailable", -1);
 195
 196         contact_path = gtk_tree_model_get_path(GTK_TREE_MODEL(_roster_model),
 197             &contact_iter);
 198
 199         contact_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(_roster_model),
 200             contact_path);
 201
 202         gtk_tree_path_free(contact_path);
 203
 204         [contactRows setValue: contact_ref
 205                        forKey: group];
 206 }
 207
 208 - (void)Jub_removeRosterItem: (XMPPRosterItem*)item
 209                        group: (OFString*)group
 210 {
 211         GtkTreeIter contact_iter, group_iter;
 212         GtkTreePath *contact_path, *group_path;
 213         GtkTreeRowReference *contact_ref, *group_ref;
 214         OFString *bareJID = [item.JID bareJID];
 215         OFMapTable *contactRows = [_contactMap objectForKey: bareJID];
 216
 217         contact_ref = [contactRows valueForKey: group];
 218         contact_path = gtk_tree_row_reference_get_path(contact_ref);
 219         gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model), &contact_iter,
 220             contact_path);
 221         gtk_tree_path_free(contact_path);
 222
 223         gtk_tree_store_remove(_roster_model, &contact_iter);
 224
 225         group_ref = [_groupMap valueForKey: group];
 226         group_path = gtk_tree_row_reference_get_path(group_ref);
 227         gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model), &group_iter,
 228             group_path);
 229
 230         if (!gtk_tree_model_iter_has_child(GTK_TREE_MODEL(_roster_model),
 231             &group_iter)) {
 232                 gtk_tree_store_remove(_roster_model, &group_iter);
 233                 [_groupMap removeValueForKey: group];
 234         }
 235
 236         gtk_tree_path_free(group_path);
 237
 238         [contactRows removeValueForKey: group];
 239         if([contactRows count] == 0)
 240                 [_contactMap removeObjectForKey: bareJID];
 241 }
 242
 243 - (void)contactManager: (XMPPContactManager*)manager
 244          didAddContact: (XMPPContact*)contact
 245 {
 246         XMPPRosterItem *rosterItem = contact.rosterItem;
 247         OFArray *groups = rosterItem.groups;;
 248
 249         if (groups == nil)
 250                 groups = @[ @"General" ];
 251
 252         for (OFString *group in groups)
 253                 [self performSelectorOnGLibThread: @selector(
 254                     Jub_addRosterItem:group:)
 255                                        withObject: rosterItem
 256                                        withObject: group];
 257 }
 258
 259 - (void)contactManager: (XMPPContactManager*)manager
 260       didRemoveContact: (XMPPContact*)contact
 261 {
 262         XMPPRosterItem *rosterItem = contact.rosterItem;
 263         OFArray *groups = rosterItem.groups;
 264
 265         if (groups == nil)
 266                 groups = @[ @"General" ];
 267
 268         for (OFString *group in groups)
 269                 [self performSelectorOnGLibThread: @selector(
 270                     Jub_removeRosterItem:group:)
 271                                        withObject: rosterItem
 272                                        withObject: group];
 273 }
 274
 275 -            (void)contact: (XMPPContact*)contact
 276   willUpdateWithRosterItem: (XMPPRosterItem*)rosterItem;
 277 {
 278         // Remove contact from old set of groups
 279         XMPPRosterItem *oldItem = contact.rosterItem;
 280         OFArray *groups = oldItem.groups;
 281
 282         if (groups == nil)
 283                 groups = @[ @"General" ];
 284
 285         for (OFString *group in groups)
 286                 [self performSelectorOnGLibThread: @selector(
 287                     Jub_removeRosterItem:group:)
 288                                        withObject: oldItem
 289                                        withObject: group];
 290
 291         // Add contact to new set of groups
 292         groups = rosterItem.groups;
 293
 294         if (groups == nil)
 295                 groups = @[ @"General" ];
 296
 297         for (OFString *group in groups)
 298                 [self performSelectorOnGLibThread: @selector(
 299                     Jub_addRosterItem:group:)
 300                                        withObject: rosterItem
 301                                        withObject: group];
 302 }
 303
 304 -   (void)contact: (XMPPContact*)contact
 305   didSendPresence: (XMPPPresence*)presence
 306 {
 307         OFDictionary *allPresences = [contact presences];
 308         XMPPPresence *highPresence = [[[allPresences allObjects] sortedArray]
 309                                          lastObject];
 310         OFMutableString *tooltip =
 311             [OFMutableString stringWithString: @"<b>Resources:</b>"];
 312
 313         [allPresences enumerateKeysAndObjectsUsingBlock:
 314             ^(OFString *resource, XMPPPresence *pres, BOOL *stop) {
 315                 [tooltip appendString: @"\n"];
 316                 [tooltip appendString: resource];
 317                 if ([pres.type isEqual: @"available"]) {
 318                         if (pres.show != nil)
 319                                 [tooltip appendFormat: @" (%@)", pres.show];
 320                         else
 321                                 [tooltip appendString: @" (available)"];
 322                 } else
 323                         [tooltip appendString: @" (unavailable)"];
 324
 325                 if (pres.status)
 326                         [tooltip appendFormat: @": <i>%@</i>", pres.status];
 327         }];
 328
 329         g_idle_add_block(^{
 330                 GtkTreeIter iter;
 331                 GtkTreePath *path;
 332                 GtkTreeRowReference *ref;
 333                 OFString *bareJID = [contact.rosterItem.JID bareJID];
 334                 OFMapTable *contactRows = [_contactMap objectForKey: bareJID];
 335                 OFArray *groups = contact.rosterItem.groups;;
 336
 337                 if (groups == nil)
 338                         groups = @[ @"General" ];
 339
 340                 for (OFString *group in groups) {
 341                         ref = [contactRows valueForKey: group];
 342                         path = gtk_tree_row_reference_get_path(ref);
 343                         gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model),
 344                             &iter, path);
 345                         gtk_tree_path_free(path);
 346
 347                         if ([highPresence.type isEqual: @"available"]) {
 348                                 if (highPresence.show != nil)
 349                                         gtk_tree_store_set(_roster_model, &iter,
 350                                             2, [highPresence.show UTF8String],
 351                                             -1);
 352                                 else
 353                                         gtk_tree_store_set(_roster_model, &iter,
 354                                             2, "available", -1);
 355                         } else
 356                                 gtk_tree_store_set(_roster_model, &iter,
 357                                     2, "unavailable", -1);
 358
 359                         gtk_tree_store_set(_roster_model, &iter,
 360                             3, [tooltip UTF8String], -1);
 361                 }
 362
 363                 gtk_tree_model_filter_refilter(_roster_filter);
 364         });
 365 }
 366
 367 -      (void)client: (JubChatClient*)client_
 368   didChangePresence: (XMPPPresence*)presence
 369 {
 370         OFString *tooltip = @"";
 371         OFString *show =
 372             [[presence elementForName: @"show"
 373                             namespace: XMPP_NS_CLIENT] stringValue];
 374         OFString *status =
 375             [[presence elementForName: @"status"
 376                             namespace: XMPP_NS_CLIENT] stringValue];
 377
 378         if (status != nil)
 379                 tooltip = [@"<b>Status:</b> " stringByAppendingString: status];
 380
 381         g_idle_add_block(^{
 382                 // Block the PresenceComboBox's changed handler, so it doesn't
 383                 // fire and resend presence
 384                 g_signal_handler_block(_presence_combo,
 385                     _presence_combo_changed_handler_id);
 386
 387                 if ([presence.type isEqual: @"unavailable"])
 388                         gtk_combo_box_set_active_id(_presence_combo,
 389                             "unavailable");
 390                 else if (show == nil)
 391                         gtk_combo_box_set_active_id(_presence_combo,
 392                             "available");
 393                 else
 394                         gtk_combo_box_set_active_id(_presence_combo,
 395                             [show UTF8String]);
 396
 397                 // Unblock the changed handler
 398                 g_signal_handler_unblock(_presence_combo,
 399                     _presence_combo_changed_handler_id);
 400
 401                 gtk_widget_set_tooltip_markup(GTK_WIDGET(_presence_combo),
 402                     [tooltip UTF8String]);
 403         });
 404 }
 405 @end