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