src/gui/gtk/JubGtkRosterUI.m

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