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