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 setShow: @(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                 client = [client_ retain];
  99
 100                 [client.contactManager addDelegate: self];
 101
 102                 builder = gtk_builder_new();
 103                 gtk_builder_add_from_file(builder, "data/gtk/roster.ui", NULL);
 104                 gtk_builder_connect_signals(builder, NULL);
 105
 106                 roster_window =
 107                     GTK_WIDGET(gtk_builder_get_object(builder, "RosterWindow"));
 108
 109                 gtk_widget_show(roster_window);
 110
 111                 roster_model = GTK_TREE_STORE(gtk_builder_get_object(builder,
 112                     "RosterTreeStore"));
 113
 114                 roster_filter = GTK_TREE_MODEL_FILTER(
 115                     gtk_builder_get_object(builder, "RosterTreeModelFilter"));
 116
 117                 gtk_tree_model_filter_set_visible_func(roster_filter,
 118                     filter_roster_by_presence, presences, NULL);
 119
 120                 roster_view = GTK_TREE_VIEW(gtk_builder_get_object(builder,
 121                         "RosterTreeView"));
 122
 123                 g_signal_connect(roster_view, "row_activated",
 124                     G_CALLBACK(roster_row_activated), self);
 125
 126                 presence_combo = GTK_COMBO_BOX(gtk_builder_get_object(builder,
 127                         "PresenceComboBox"));
 128
 129                 presence_combo_changed_handler_id =
 130                     g_signal_connect(presence_combo, "changed",
 131                         G_CALLBACK(presence_changed), client.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         [client.contactManager removeDelegate: self];
 145         [groupMap release];
 146         [contactMap release];
 147         [chatMap release];
 148         [presences release];
 149         [client release];
 150
 151         gtk_widget_destroy(roster_window);
 152
 153         [super dealloc];
 154 }
 155
 156 // FIXME: This needs to move somewhere else
 157 - (JubGtkChatUI*)chatForJID: (XMPPJID*)jid
 158 {
 159         OFAutoreleasePool *pool = [OFAutoreleasePool new];
 160         JubGtkChatUI *chat =
 161             [chatMap objectForKey: [jid bareJID]];
 162         if (chat == nil) {
 163                 OFString * title = [@"Chat with " stringByAppendingString:
 164                     [jid bareJID]];
 165
 166                 chat = [[[JubGtkChatUI alloc]
 167                     initWithTitle: title
 168                        closeBlock: ^{
 169                                 [chatMap removeObjectForKey: [jid bareJID]];
 170                         }
 171                         sendBlock: ^(OFString *text) {
 172                                 XMPPMessage *msg =
 173                                     [XMPPMessage messageWithType: @"chat"];
 174                                 msg.to = jid;
 175                                 msg.body = text;
 176                                 [client.connection sendStanza: msg];
 177                         }
 178                 ] autorelease];
 179
 180                 [chatMap setObject: chat
 181                             forKey: [jid bareJID]];
 182         }
 183
 184         [pool release];
 185
 186         return chat;
 187 }
 188
 189 -  (void)contact: (XMPPContact*)contact
 190   didSendMessage: (XMPPMessage*)message
 191 {
 192         if (message.body == nil || ![message.type isEqual: @"chat"])
 193                 return;
 194
 195         JubGtkChatUI *chat = [self chatForJID: message.from];
 196         [chat addMessage: message.body
 197                   sender: [message.from bareJID]];
 198 }
 199
 200 /* Roster Delegate methods */
 201 - (void)Jub_addRosterItem: (XMPPRosterItem*)item
 202                     group: (OFString*)group
 203 {
 204         g_idle_add_block(^{
 205                 GtkTreeIter group_iter, contact_iter;
 206                 GtkTreeRowReference *group_ref, *contact_ref;
 207                 GtkTreePath *group_path, *contact_path;
 208                 OFString *bareJID = [item.JID bareJID];
 209                 OFMapTable *contactRows;
 210
 211                 if (!(contactRows = [contactMap objectForKey: bareJID])) {
 212                         contactRows = [OFMapTable
 213                             mapTableWithKeyFunctions: keyFunctions
 214                                       valueFunctions: rowRefFunctions];
 215
 216                         [contactMap setObject: contactRows
 217                                        forKey: bareJID];
 218                 }
 219
 220                 group_ref = [groupMap valueForKey: group];
 221
 222                 if (!group_ref) {
 223                         // Create new group row
 224                         gtk_tree_store_append(roster_model, &group_iter, NULL);
 225                         gtk_tree_store_set(roster_model, &group_iter,
 226                             0, [group UTF8String], -1);
 227
 228                         group_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
 229                                 roster_model), &group_iter);
 230
 231                         group_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
 232                                 roster_model), group_path);
 233
 234                         [groupMap setValue: group_ref
 235                                     forKey: group];
 236                 } else {
 237                         // Get iter for existing group row
 238                         group_path = gtk_tree_row_reference_get_path(group_ref);
 239
 240                         gtk_tree_model_get_iter(GTK_TREE_MODEL(roster_model),
 241                             &group_iter, group_path);
 242                 }
 243                 gtk_tree_path_free(group_path);
 244
 245                 // Create new contact row
 246                 gtk_tree_store_append(roster_model, &contact_iter, &group_iter);
 247                 if (item.name)
 248                         gtk_tree_store_set(roster_model, &contact_iter,
 249                             0, [item.name UTF8String],
 250                             1, [bareJID UTF8String], -1);
 251                 else
 252                         gtk_tree_store_set(roster_model, &contact_iter,
 253                             0, [item.JID.node UTF8String],
 254                             1, [bareJID UTF8String], -1);
 255
 256                 contact_path = gtk_tree_model_get_path(GTK_TREE_MODEL(
 257                         roster_model), &contact_iter);
 258
 259                 contact_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(
 260                         roster_model), contact_path);
 261
 262                 gtk_tree_path_free(contact_path);
 263
 264                 [contactRows setValue: contact_ref
 265                                forKey: group];
 266         });
 267 }
 268
 269 - (void)Jub_removeRosterItem: (XMPPRosterItem*)item
 270                        group: (OFString*)group
 271 {
 272         g_idle_add_block(^{
 273                 GtkTreeIter contact_iter, group_iter;
 274                 GtkTreePath *contact_path, *group_path;
 275                 GtkTreeRowReference *contact_ref, *group_ref;
 276                 OFString *bareJID = [item.JID bareJID];
 277                 OFMapTable *contactRows = [contactMap objectForKey: bareJID];
 278
 279                 contact_ref = [contactRows valueForKey: group];
 280                 contact_path = gtk_tree_row_reference_get_path(contact_ref);
 281                 gtk_tree_model_get_iter(GTK_TREE_MODEL(roster_model),
 282                     &contact_iter, contact_path);
 283
 284                 gtk_tree_store_remove(roster_model, &contact_iter);
 285
 286                 group_ref = [groupMap valueForKey: group];
 287                 group_path = gtk_tree_row_reference_get_path(group_ref);
 288                 gtk_tree_model_get_iter(GTK_TREE_MODEL(roster_model),
 289                     &group_iter, group_path);
 290
 291                 if (!gtk_tree_model_iter_has_child(GTK_TREE_MODEL(roster_model),
 292                     &group_iter)) {
 293                         gtk_tree_store_remove(roster_model, &group_iter);
 294                         [groupMap removeValueForKey: group];
 295                 }
 296
 297                 gtk_tree_path_free(group_path);
 298
 299                 [contactRows removeValueForKey: group];
 300                 if([contactRows count] == 0)
 301                         [contactMap removeObjectForKey: bareJID];
 302         });
 303 }
 304
 305 - (void)contactManager: (XMPPContactManager*)manager
 306          didAddContact: (XMPPContact*)contact
 307 {
 308         XMPPRosterItem *rosterItem = contact.rosterItem;
 309         OFArray *groups = rosterItem.groups;;
 310
 311         if (groups == nil)
 312                 groups = @[ @"General" ];
 313
 314         for (OFString *group in groups)
 315                 [self Jub_addRosterItem: rosterItem
 316                                   group: group];
 317 }
 318
 319 - (void)contactManager: (XMPPContactManager*)manager
 320       didRemoveContact: (XMPPContact*)contact
 321 {
 322         XMPPRosterItem *rosterItem = contact.rosterItem;
 323         OFArray *groups = rosterItem.groups;
 324
 325         if (groups == nil)
 326                 groups = @[ @"General" ];
 327
 328         for (OFString *group in groups)
 329                 [self Jub_removeRosterItem: rosterItem
 330                                      group: group];
 331 }
 332
 333 -            (void)contact: (XMPPContact*)contact
 334   willUpdateWithRosterItem: (XMPPRosterItem*)rosterItem;
 335 {
 336         // Remove contact from old set of groups
 337         XMPPRosterItem *oldItem = contact.rosterItem;
 338         OFArray *groups = oldItem.groups;
 339
 340         if (groups == nil)
 341                 groups = @[ @"General" ];
 342
 343         for (OFString *group in groups)
 344                 [self Jub_removeRosterItem: oldItem
 345                                      group: group];
 346
 347         // Add contact to new set of groups
 348         groups = rosterItem.groups;
 349
 350         if (groups == nil)
 351                 groups = @[ @"General" ];
 352
 353         for (OFString *group in groups)
 354                 [self Jub_addRosterItem: rosterItem
 355                                   group: group];
 356 }
 357
 358 -   (void)contact: (XMPPContact*)contact
 359   didSendPresence: (XMPPPresence*)presence
 360 {
 361         if ([presence.type isEqual: @"available"])
 362                 [presences addObject: [presence.from bareJID]];
 363         else if ([presence.type isEqual: @"unavailable"])
 364                 [presences removeObject: [presence.from bareJID]];
 365
 366         g_idle_add_block(^{
 367                 gtk_tree_model_filter_refilter(roster_filter);
 368         });
 369 }
 370
 371 -      (void)client: (JubChatClient*)client_
 372   didChangePresence: (XMPPPresence*)presence
 373 {
 374         OFString *tooltip = @"";
 375         OFString *show =
 376             [[presence elementForName: @"show"
 377                             namespace: XMPP_NS_CLIENT] stringValue];
 378         OFString *status =
 379             [[presence elementForName: @"status"
 380                             namespace: XMPP_NS_CLIENT] stringValue];
 381
 382         if (status != nil)
 383                 tooltip = [@"<b>Status:</b> " stringByAppendingString: status];
 384
 385         g_idle_add_block(^{
 386                 // Block the PresenceComboBox's changed handler, so it doesn't
 387                 // fire and resend presence
 388                 g_signal_handler_block(presence_combo,
 389                     presence_combo_changed_handler_id);
 390
 391                 if ([presence.type isEqual: @"unavailable"])
 392                         gtk_combo_box_set_active_id(presence_combo,
 393                             "unavailable");
 394                 else if (show == nil)
 395                         gtk_combo_box_set_active_id(presence_combo,
 396                             "available");
 397                 else
 398                         gtk_combo_box_set_active_id(presence_combo,
 399                             [show UTF8String]);
 400
 401                 // Unblock the changed handler
 402                 g_signal_handler_unblock(presence_combo,
 403                     presence_combo_changed_handler_id);
 404
 405                 gtk_widget_set_tooltip_markup(GTK_WIDGET(presence_combo),
 406                     [tooltip UTF8String]);
 407         });
 408 }
 409 @end