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