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         JubGtkRosterUI *roster = data;
  13         GtkTreeIter row_iter;
  14         GtkTreeModel *tree_model;
  15         gchar *jid_s;
  16         XMPPJID *jid;
  17         OFAutoreleasePool *pool;
  18
  19         tree_model = gtk_tree_view_get_model(tree_view);
  20         gtk_tree_model_get_iter(tree_model, &row_iter, path);
  21         gtk_tree_model_get(tree_model, &row_iter, 1, &jid_s, -1);
  22
  23         // This was a group row
  24         if (!jid_s) return;
  25
  26         pool = [OFAutoreleasePool new];
  27         jid = [XMPPJID JIDWithString: [OFString stringWithUTF8String: jid_s]];
  28
  29         [roster performSelectorOnMainThread: @selector(chatForJID:)
  30                                  withObject: jid
  31                               waitUntilDone: NO];
  32         [pool release];
  33 }
  34
  35 static void presence_changed(GtkComboBox *combo_box, gpointer data)
  36 {
  37         XMPPPresence *pres;
  38         XMPPConnection *connection = data;
  39         OFAutoreleasePool *pool = [OFAutoreleasePool new];
  40
  41         const char *status = gtk_combo_box_get_active_id(combo_box);
  42
  43         if (!strcmp(status, "unavailable"))
  44                 pres = [XMPPPresence presenceWithType: @"unavailable"];
  45         else {
  46                 pres = [XMPPPresence presence];
  47                 if (strcmp(status, "available"))
  48                         [pres addShow: @(status)];
  49         }
  50
  51         [connection sendStanza: pres];
  52
  53         [pool release];
  54 }
  55
  56 static gboolean filter_roster_by_presence(GtkTreeModel *model,
  57     GtkTreeIter *iter, gpointer data)
  58 {
  59         char *jid_s;
  60         OFString *jid;
  61         OFCountedSet *presences = data;
  62
  63         gtk_tree_model_get(model, iter, 1, &jid_s, -1);
  64
  65         // Groups have no JID
  66         if (!jid_s)
  67                 return TRUE;
  68
  69         jid = [[OFString alloc] initWithUTF8String: jid_s];
  70
  71         g_free(jid_s);
  72
  73         int num = [presences countForObject: jid];
  74         if (num) {
  75                 [jid release];
  76                 return TRUE;
  77         } else {
  78                 [jid release];
  79                 return FALSE;
  80         }
  81 }
  82
  83 @implementation JubGtkRosterUI
  84 - initWithClient: (JubChatClient*)client;
  85 {
  86         self = [super init];
  87
  88         @try {
  89                 GtkTreeView *roster_view;
  90                 GtkBuilder *builder;
  91
  92                 groupMap = [[OFMapTable alloc]
  93                     initWithKeyFunctions: keyFunctions
  94                           valueFunctions: rowRefFunctions];
  95                 contactMap = [[OFMutableDictionary alloc] init];
  96                 chatMap = [[OFMutableDictionary alloc] init];
  97                 presences = [[OFCountedSet alloc] init];
  98                 connection = [client.connection retain];
  99
 100                 [connection addDelegate: self];
 101                 [client.roster addDelegate: self];
 102
 103                 builder = gtk_builder_new();
 104                 gtk_builder_add_from_file(builder, "data/gtk/roster.ui", NULL);
 105                 gtk_builder_connect_signals(builder, NULL);
 106
 107                 roster_window =
 108                     GTK_WIDGET(gtk_builder_get_object(builder, "RosterWindow"));
 109
 110                 gtk_widget_show(roster_window);
 111
 112                 roster_model = GTK_TREE_STORE(gtk_builder_get_object(builder,
 113                     "RosterTreeStore"));
 114
 115                 roster_filter = GTK_TREE_MODEL_FILTER(
 116                     gtk_builder_get_object(builder, "RosterTreeModelFilter"));
 117
 118                 gtk_tree_model_filter_set_visible_func(roster_filter,
 119                     filter_roster_by_presence, presences, NULL);
 120
 121                 roster_view = GTK_TREE_VIEW(gtk_builder_get_object(builder,
 122                         "RosterTreeView"));
 123
 124                 g_signal_connect(roster_view, "row_activated",
 125                     G_CALLBACK(roster_row_activated), self);
 126
 127                 presence_combo = GTK_COMBO_BOX(gtk_builder_get_object(builder,
 128                         "PresenceComboBox"));
 129
 130                 g_signal_connect(presence_combo, "changed",
 131                     G_CALLBACK(presence_changed), connection);
 132
 133                 g_object_unref(G_OBJECT(builder));
 134         } @catch (id e) {
 135                 [self release];
 136                 @throw e;
 137         }
 138
 139         return self;
 140 }
 141
 142 - (void)dealloc
 143 {
 144         [groupMap release];
 145         [contactMap release];
 146         [chatMap release];
 147         [presences release];
 148         [connection release];
 149
 150         gtk_widget_destroy(roster_window);
 151
 152         [super dealloc];
 153 }
 154
 155 /* Presence handling */
 156 -   (void)connection: (XMPPConnection*)connection
 157   didReceivePresence: (XMPPPresence*)presence
 158 {
 159         if ([presence.type isEqual: @"available"])
 160                 [presences addObject: [presence.from bareJID]];
 161         else if ([presence.type isEqual: @"unavailable"])
 162                 [presences removeObject: [presence.from bareJID]];
 163
 164         g_idle_add_block(^{
 165                 gtk_tree_model_filter_refilter(roster_filter);
 166         });
 167 }
 168
 169 // FIXME: This needs to move somewhere else
 170 - (JubGtkChatUI*)chatForJID: (XMPPJID*)jid
 171 {
 172         OFAutoreleasePool *pool = [OFAutoreleasePool new];
 173         JubGtkChatUI *chat =
 174             [chatMap objectForKey: [jid bareJID]];
 175         if (chat == nil) {
 176                 OFString * title = [@"Chat with " stringByAppendingString:
 177                     [jid bareJID]];
 178
 179                 chat = [[[JubGtkChatUI alloc]
 180                     initWithTitle: title
 181                        closeBlock: ^{
 182                                 [chatMap removeObjectForKey: [jid bareJID]];
 183                         }
 184                         sendBlock: ^(OFString *text) {
 185                                 XMPPMessage *msg =
 186                                     [XMPPMessage messageWithType: @"chat"];
 187                                 msg.to = jid;
 188                                 msg.body = text;
 189                                 [connection sendStanza: msg];
 190                         }
 191                 ] autorelease];
 192
 193                 [chatMap setObject: chat
 194                             forKey: [jid bareJID]];
 195         }
 196
 197         [pool release];
 198
 199         return chat;
 200 }
 201
 202 -  (void)connection: (XMPPConnection*)connection
 203   didReceiveMessage: (XMPPMessage*)message
 204 {
 205         JubGtkChatUI *chat = [self chatForJID: message.from];
 206         [chat addMessage: message.body
 207                   sender: [message.from bareJID]];
 208 }
 209
 210 /* Roster Delegate methods */
 211 - (void)Jub_addRosterItem: (XMPPRosterItem*)item
 212                     group: (OFString*)group
 213 {
 214         g_idle_add_block(^{
 215                 GtkTreeIter group_iter, contact_iter;
 216                 GtkTreeRowReference *group_ref, *contact_ref;
 217                 GtkTreePath *group_path, *contact_path;
 218                 OFMapTable *contactRows =
 219                     [contactMap objectForKey: [item.JID bareJID]];
 220
 221                 group_ref = [groupMap valueForKey: group];
 222
 223                 if (!group_ref) {
 224                         // Create new group row
 225                         gtk_tree_store_append(roster_model, &group_iter, NULL);
 226                         gtk_tree_store_set(roster_model, &group_iter,
 227                             0, [group UTF8String], -1);
 228
 229                         group_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
 230                                 roster_model), &group_iter);
 231
 232                         group_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
 233                                 roster_model), group_path);
 234
 235                         [groupMap setValue: group_ref
 236                                     forKey: group];
 237                 } else {
 238                         // Get iter for existing group row
 239                         group_path = gtk_tree_row_reference_get_path(group_ref);
 240
 241                         gtk_tree_model_get_iter(GTK_TREE_MODEL(roster_model),
 242                             &group_iter, group_path);
 243                 }
 244                 gtk_tree_path_free(group_path);
 245
 246                 // Create new contact row
 247                 gtk_tree_store_append(roster_model, &contact_iter, &group_iter);
 248                 if (item.name)
 249                         gtk_tree_store_set(roster_model, &contact_iter,
 250                             0, [item.name UTF8String],
 251                             1, [[item.JID bareJID] UTF8String], -1);
 252                 else
 253                         gtk_tree_store_set(roster_model, &contact_iter,
 254                             0, [item.JID.node UTF8String],
 255                             1, [[item.JID bareJID] UTF8String], -1);
 256
 257                 contact_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
 258                         roster_model), &contact_iter);
 259
 260                 contact_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
 261                         roster_model), contact_path);
 262
 263                 gtk_tree_path_free(contact_path);
 264
 265                 [contactRows setValue: contact_ref
 266                                forKey: group];
 267         });
 268 }
 269
 270 - (void)Jub_removeRosterItem: (XMPPRosterItem*)item
 271                        group: (OFString*)group
 272 {
 273         g_idle_add_block(^{
 274                 GtkTreeIter contact_iter, group_iter;
 275                 GtkTreePath *contact_path, *group_path;
 276                 GtkTreeRowReference *contact_ref, *group_ref;
 277                 OFMapTable *contactRows =
 278                     [contactMap objectForKey: [item.JID bareJID]];
 279
 280                 contact_ref = [contactRows valueForKey: group];
 281                 contact_path = gtk_tree_row_reference_get_path(contact_ref);
 282                 gtk_tree_model_get_iter(GTK_TREE_MODEL(roster_model),
 283                     &contact_iter, contact_path);
 284
 285                 gtk_tree_store_remove(roster_model, &contact_iter);
 286
 287                 group_ref = [groupMap valueForKey: group];
 288                 group_path = gtk_tree_row_reference_get_path(group_ref);
 289                 gtk_tree_model_get_iter(GTK_TREE_MODEL(roster_model),
 290                     &group_iter, group_path);
 291
 292                 if (!gtk_tree_model_iter_has_child(GTK_TREE_MODEL(roster_model),
 293                     &group_iter)) {
 294                         gtk_tree_store_remove(roster_model, &group_iter);
 295                         [groupMap removeValueForKey: group];
 296                 }
 297
 298                 gtk_tree_path_free(group_path);
 299         });
 300 }
 301
 302 - (void)rosterWasReceived: (XMPPRoster*)roster_
 303 {
 304         of_log(@"Handling roster");
 305         [[roster_ rosterItems] enumerateKeysAndObjectsUsingBlock:
 306             ^(OFString *bareJID, XMPPRosterItem *item, BOOL *stop) {
 307                 OFArray *groups;
 308                 OFMapTable *contactRows = [OFMapTable
 309                     mapTableWithKeyFunctions: keyFunctions
 310                               valueFunctions: rowRefFunctions];
 311
 312                 [contactMap setObject: contactRows
 313                                forKey: bareJID];
 314
 315                 if (item.groups != nil)
 316                         groups = item.groups;
 317                 else
 318                         groups = @[@"General"];
 319
 320                 for (OFString *group in groups)
 321                         [self Jub_addRosterItem: item
 322                                           group: group];
 323         }];
 324 }
 325
 326 -         (void)roster: (XMPPRoster*)roster_
 327   didReceiveRosterItem: (XMPPRosterItem*)item
 328 {
 329         OFArray *groups;
 330         XMPPRosterItem *oldItem =
 331             [roster_.rosterItems objectForKey: [item.JID bareJID]];
 332
 333         if (oldItem) {
 334                 if (oldItem.groups != nil)
 335                         groups = oldItem.groups;
 336                 else
 337                         groups = @[@"General"];
 338
 339                 for (OFString *group in groups)
 340                         [self Jub_removeRosterItem: oldItem
 341                                              group: group];
 342
 343                 [contactMap removeObjectForKey: [item.JID bareJID]];
 344         }
 345
 346         if (![item.subscription isEqual: @"remove"]) {
 347                 OFMapTable *contactRows = [OFMapTable
 348                     mapTableWithKeyFunctions: keyFunctions
 349                               valueFunctions: rowRefFunctions];
 350
 351                 [contactMap setObject: contactRows
 352                                forKey: [item.JID bareJID]];
 353
 354                 if (item.groups != nil)
 355                         groups = item.groups;
 356                 else
 357                         groups = @[@"General"];
 358
 359                 for (OFString *group in groups)
 360                         [self Jub_addRosterItem: item
 361                                           group: group];
 362         }
 363 }
 364
 365 -      (void)client: (JubChatClient*)client
 366   didChangePresence: (XMPPPresence*)presence
 367 {
 368         OFString *tooltip = @"";
 369         OFString *show =
 370             [[presence elementForName: @"show"
 371                             namespace: XMPP_NS_CLIENT] stringValue];
 372         OFString *status =
 373             [[presence elementForName: @"status"
 374                             namespace: XMPP_NS_CLIENT] stringValue];
 375
 376         if (status != nil)
 377                 tooltip = [@"<b>Status:</b> " stringByAppendingString: status];
 378
 379         // FIXME: Changing the active id will send another presence
 380         g_idle_add_block(^{
 381                 if ([presence.type isEqual: @"unavailable"])
 382                         gtk_combo_box_set_active_id(presence_combo,
 383                             "unavailable");
 384                 else if (show == nil)
 385                         gtk_combo_box_set_active_id(presence_combo,
 386                             "available");
 387                 else
 388                         gtk_combo_box_set_active_id(presence_combo,
 389                             [show UTF8String]);
 390
 391
 392                 gtk_widget_set_tooltip_markup(GTK_WIDGET(presence_combo),
 393                     [tooltip UTF8String]);
 394         });
 395 }
 396 @end