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         g_idle_add_block(^{
 160                 GtkTreeIter group_iter, contact_iter;
 161                 GtkTreeRowReference *group_ref, *contact_ref;
 162                 GtkTreePath *group_path, *contact_path;
 163                 OFString *bareJID = [item.JID bareJID];
 164                 OFMapTable *contactRows;
 165
 166                 if (!(contactRows = [_contactMap objectForKey: bareJID])) {
 167                         contactRows = [OFMapTable
 168                             mapTableWithKeyFunctions: keyFunctions
 169                                       valueFunctions: rowRefFunctions];
 170
 171                         [_contactMap setObject: contactRows
 172                                         forKey: bareJID];
 173                 }
 174
 175                 group_ref = [_groupMap valueForKey: group];
 176
 177                 if (!group_ref) {
 178                         // Create new group row
 179                         gtk_tree_store_append(_roster_model, &group_iter, NULL);
 180                         gtk_tree_store_set(_roster_model, &group_iter,
 181                             0, [group UTF8String], -1);
 182
 183                         group_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
 184                                 _roster_model), &group_iter);
 185
 186                         group_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
 187                                 _roster_model), group_path);
 188
 189                         [_groupMap setValue: group_ref
 190                                      forKey: group];
 191                 } else {
 192                         // Get iter for existing group row
 193                         group_path = gtk_tree_row_reference_get_path(group_ref);
 194
 195                         gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model),
 196                             &group_iter, group_path);
 197                 }
 198                 gtk_tree_path_free(group_path);
 199
 200                 // Create new contact row
 201                 gtk_tree_store_append(_roster_model, &contact_iter,
 202                     &group_iter);
 203                 if (item.name)
 204                         gtk_tree_store_set(_roster_model, &contact_iter,
 205                             0, [item.name UTF8String],
 206                             1, [bareJID UTF8String],
 207                             2, "unavailable", -1);
 208                 else if (item.JID.node)
 209                         gtk_tree_store_set(_roster_model, &contact_iter,
 210                             0, [item.JID.node UTF8String],
 211                             1, [bareJID UTF8String],
 212                             2, "unavailable", -1);
 213                 else
 214                         gtk_tree_store_set(_roster_model, &contact_iter,
 215                             0, [item.JID.domain UTF8String],
 216                             1, [bareJID UTF8String],
 217                             2, "unavailable", -1);
 218
 219                 contact_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
 220                         _roster_model), &contact_iter);
 221
 222                 contact_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
 223                         _roster_model), contact_path);
 224
 225                 gtk_tree_path_free(contact_path);
 226
 227                 [contactRows setValue: contact_ref
 228                                forKey: group];
 229         });
 230 }
 231
 232 - (void)Jub_removeRosterItem: (XMPPRosterItem*)item
 233                        group: (OFString*)group
 234 {
 235         g_idle_add_block(^{
 236                 GtkTreeIter contact_iter, group_iter;
 237                 GtkTreePath *contact_path, *group_path;
 238                 GtkTreeRowReference *contact_ref, *group_ref;
 239                 OFString *bareJID = [item.JID bareJID];
 240                 OFMapTable *contactRows = [_contactMap objectForKey: bareJID];
 241
 242                 contact_ref = [contactRows valueForKey: group];
 243                 contact_path = gtk_tree_row_reference_get_path(contact_ref);
 244                 gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model),
 245                     &contact_iter, contact_path);
 246                 gtk_tree_path_free(contact_path);
 247
 248                 gtk_tree_store_remove(_roster_model, &contact_iter);
 249
 250                 group_ref = [_groupMap valueForKey: group];
 251                 group_path = gtk_tree_row_reference_get_path(group_ref);
 252                 gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model),
 253                     &group_iter, group_path);
 254
 255                 if (!gtk_tree_model_iter_has_child(GTK_TREE_MODEL(
 256                     _roster_model), &group_iter)) {
 257                         gtk_tree_store_remove(_roster_model, &group_iter);
 258                         [_groupMap removeValueForKey: group];
 259                 }
 260
 261                 gtk_tree_path_free(group_path);
 262
 263                 [contactRows removeValueForKey: group];
 264                 if([contactRows count] == 0)
 265                         [_contactMap removeObjectForKey: bareJID];
 266         });
 267 }
 268
 269 - (void)contactManager: (XMPPContactManager*)manager
 270          didAddContact: (XMPPContact*)contact
 271 {
 272         XMPPRosterItem *rosterItem = contact.rosterItem;
 273         OFArray *groups = rosterItem.groups;;
 274
 275         if (groups == nil)
 276                 groups = @[ @"General" ];
 277
 278         for (OFString *group in groups)
 279                 [self Jub_addRosterItem: rosterItem
 280                                   group: group];
 281 }
 282
 283 - (void)contactManager: (XMPPContactManager*)manager
 284       didRemoveContact: (XMPPContact*)contact
 285 {
 286         XMPPRosterItem *rosterItem = contact.rosterItem;
 287         OFArray *groups = rosterItem.groups;
 288
 289         if (groups == nil)
 290                 groups = @[ @"General" ];
 291
 292         for (OFString *group in groups)
 293                 [self Jub_removeRosterItem: rosterItem
 294                                      group: group];
 295 }
 296
 297 -            (void)contact: (XMPPContact*)contact
 298   willUpdateWithRosterItem: (XMPPRosterItem*)rosterItem;
 299 {
 300         // Remove contact from old set of groups
 301         XMPPRosterItem *oldItem = contact.rosterItem;
 302         OFArray *groups = oldItem.groups;
 303
 304         if (groups == nil)
 305                 groups = @[ @"General" ];
 306
 307         for (OFString *group in groups)
 308                 [self Jub_removeRosterItem: oldItem
 309                                      group: group];
 310
 311         // Add contact to new set of groups
 312         groups = rosterItem.groups;
 313
 314         if (groups == nil)
 315                 groups = @[ @"General" ];
 316
 317         for (OFString *group in groups)
 318                 [self Jub_addRosterItem: rosterItem
 319                                   group: group];
 320 }
 321
 322 -   (void)contact: (XMPPContact*)contact
 323   didSendPresence: (XMPPPresence*)presence
 324 {
 325         OFDictionary *allPresences = [contact presences];
 326         XMPPPresence *highPresence = [[[allPresences allObjects] sortedArray]
 327                                          lastObject];
 328         OFMutableString *tooltip =
 329             [OFMutableString stringWithString: @"<b>Resources:</b>"];
 330
 331         [allPresences enumerateKeysAndObjectsUsingBlock:
 332             ^(OFString *resource, XMPPPresence *pres, BOOL *stop) {
 333                 [tooltip appendString: @"\n"];
 334                 [tooltip appendString: resource];
 335                 if ([pres.type isEqual: @"available"]) {
 336                         if (pres.show != nil)
 337                                 [tooltip appendFormat: @" (%@)", pres.show];
 338                         else
 339                                 [tooltip appendString: @" (available)"];
 340                 } else
 341                         [tooltip appendString: @" (unavailable)"];
 342
 343                 if (pres.status)
 344                         [tooltip appendFormat: @": <i>%@</i>", pres.status];
 345         }];
 346
 347         g_idle_add_block(^{
 348                 GtkTreeIter iter;
 349                 GtkTreePath *path;
 350                 GtkTreeRowReference *ref;
 351                 OFString *bareJID = [contact.rosterItem.JID bareJID];
 352                 OFMapTable *contactRows = [_contactMap objectForKey: bareJID];
 353
 354                 for (OFString *group in contact.rosterItem.groups) {
 355                         ref = [contactRows valueForKey: group];
 356                         path = gtk_tree_row_reference_get_path(ref);
 357                         gtk_tree_model_get_iter(GTK_TREE_MODEL(_roster_model),
 358                             &iter, path);
 359                         gtk_tree_path_free(path);
 360
 361                         if ([highPresence.type isEqual: @"available"]) {
 362                                 if (highPresence.show != nil)
 363                                         gtk_tree_store_set(_roster_model, &iter,
 364                                             2, [highPresence.show UTF8String],
 365                                             -1);
 366                                 else
 367                                         gtk_tree_store_set(_roster_model, &iter,
 368                                             2, "available", -1);
 369                         } else
 370                                 gtk_tree_store_set(_roster_model, &iter,
 371                                     2, "unavailable", -1);
 372
 373                         gtk_tree_store_set(_roster_model, &iter,
 374                             3, [tooltip UTF8String], -1);
 375                 }
 376
 377                 gtk_tree_model_filter_refilter(_roster_filter);
 378         });
 379 }
 380
 381 -      (void)client: (JubChatClient*)client_
 382   didChangePresence: (XMPPPresence*)presence
 383 {
 384         OFString *tooltip = @"";
 385         OFString *show =
 386             [[presence elementForName: @"show"
 387                             namespace: XMPP_NS_CLIENT] stringValue];
 388         OFString *status =
 389             [[presence elementForName: @"status"
 390                             namespace: XMPP_NS_CLIENT] stringValue];
 391
 392         if (status != nil)
 393                 tooltip = [@"<b>Status:</b> " stringByAppendingString: status];
 394
 395         g_idle_add_block(^{
 396                 // Block the PresenceComboBox's changed handler, so it doesn't
 397                 // fire and resend presence
 398                 g_signal_handler_block(_presence_combo,
 399                     _presence_combo_changed_handler_id);
 400
 401                 if ([presence.type isEqual: @"unavailable"])
 402                         gtk_combo_box_set_active_id(_presence_combo,
 403                             "unavailable");
 404                 else if (show == nil)
 405                         gtk_combo_box_set_active_id(_presence_combo,
 406                             "available");
 407                 else
 408                         gtk_combo_box_set_active_id(_presence_combo,
 409                             [show UTF8String]);
 410
 411                 // Unblock the changed handler
 412                 g_signal_handler_unblock(_presence_combo,
 413                     _presence_combo_changed_handler_id);
 414
 415                 gtk_widget_set_tooltip_markup(GTK_WIDGET(_presence_combo),
 416                     [tooltip UTF8String]);
 417         });
 418 }
 419 @end