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