libempathy-gtk/empathy-presence-chooser.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2005-2007 Imendio AB
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Authors: Richard Hult <richard@imendio.com>
  21  *          Martyn Russell <martyn@imendio.com>
  22  */
  23
  24 #include "config.h"
  25
  26 #include <string.h>
  27 #include <stdlib.h>
  28
  29 #include <glib/gi18n.h>
  30 #include <gtk/gtk.h>
  31 #include <glade/glade.h>
  32
  33 #include <libempathy/empathy-idle.h>
  34 #include <libempathy/empathy-utils.h>
  35 #include <libempathy/empathy-debug.h>
  36 #include <libempathy/empathy-marshal.h>
  37
  38 #include "empathy-ui-utils.h"
  39 #include "empathy-images.h"
  40 #include "empathy-presence-chooser.h"
  41 #include "empathy-status-presets.h"
  42
  43 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), EMPATHY_TYPE_PRESENCE_CHOOSER, EmpathyPresenceChooserPriv))
  44
  45 #define DEBUG_DOMAIN "PresenceChooser"
  46
  47 /* Flashing delay for icons (milliseconds). */
  48 #define FLASH_TIMEOUT 500
  49
  50 typedef struct {
  51         EmpathyIdle *idle;
  52
  53         GtkWidget   *hbox;
  54         GtkWidget   *image;
  55         GtkWidget   *label;
  56         GtkWidget   *menu;
  57
  58         McPresence   last_state;
  59
  60         McPresence   flash_state_1;
  61         McPresence   flash_state_2;
  62         guint        flash_timeout_id;
  63
  64         /* The handle the kind of unnessecary scroll support. */
  65         guint        scroll_timeout_id;
  66         McPresence   scroll_state;
  67         gchar       *scroll_status;
  68 } EmpathyPresenceChooserPriv;
  69
  70 typedef struct {
  71         McPresence   state;
  72         const gchar *status;
  73 } StateAndStatus;
  74
  75 /* States to be listed in the menu */
  76 static McPresence states[] = {MC_PRESENCE_AVAILABLE,
  77                               MC_PRESENCE_DO_NOT_DISTURB,
  78                               MC_PRESENCE_AWAY};
  79
  80 static void            empathy_presence_chooser_class_init      (EmpathyPresenceChooserClass *klass);
  81 static void            empathy_presence_chooser_init            (EmpathyPresenceChooser      *chooser);
  82 static void            presence_chooser_finalize               (GObject                    *object);
  83 static void            presence_chooser_presence_changed_cb    (EmpathyPresenceChooser      *chooser);
  84 static void            presence_chooser_reset_scroll_timeout   (EmpathyPresenceChooser      *chooser);
  85 static gboolean        presence_chooser_scroll_timeout_cb      (EmpathyPresenceChooser      *chooser);
  86 static gboolean        presence_chooser_scroll_event_cb        (EmpathyPresenceChooser      *chooser,
  87                                                                 GdkEventScroll             *event,
  88                                                                 gpointer                    user_data);
  89 static GList *         presence_chooser_get_presets            (EmpathyPresenceChooser      *chooser);
  90 static StateAndStatus *presence_chooser_state_and_status_new   (McPresence                  state,
  91                                                                 const gchar                *status);
  92 static gboolean        presence_chooser_flash_timeout_cb       (EmpathyPresenceChooser      *chooser);
  93 static void            presence_chooser_flash_start            (EmpathyPresenceChooser      *chooser,
  94                                                                 McPresence                  state_1,
  95                                                                 McPresence                  state_2);
  96 static void            presence_chooser_flash_stop             (EmpathyPresenceChooser      *chooser,
  97                                                                 McPresence                  state);
  98 static gboolean        presence_chooser_button_press_event_cb  (GtkWidget                  *chooser,
  99                                                                 GdkEventButton             *event,
 100                                                                 gpointer                    user_data);
 101 static void            presence_chooser_toggled_cb             (GtkWidget                  *chooser,
 102                                                                 gpointer                    user_data);
 103 static void            presence_chooser_menu_popup             (EmpathyPresenceChooser      *chooser);
 104 static void            presence_chooser_menu_popdown           (EmpathyPresenceChooser      *chooser);
 105 static void            presence_chooser_menu_selection_done_cb (GtkMenuShell               *menushell,
 106                                                                 EmpathyPresenceChooser      *chooser);
 107 static void            presence_chooser_menu_destroy_cb        (GtkWidget                  *menu,
 108                                                                 EmpathyPresenceChooser      *chooser);
 109 static void            presence_chooser_menu_detach            (GtkWidget                  *attach_widget,
 110                                                                 GtkMenu                    *menu);
 111 static void            presence_chooser_menu_align_func        (GtkMenu                    *menu,
 112                                                                 gint                       *x,
 113                                                                 gint                       *y,
 114                                                                 gboolean                   *push_in,
 115                                                                 GtkWidget                  *widget);
 116 static void            presence_chooser_menu_add_item          (GtkWidget                  *menu,
 117                                                                 const gchar                *str,
 118                                                                 McPresence                  state,
 119                                                                 gboolean                    custom);
 120 static void            presence_chooser_clear_activate_cb      (GtkWidget                  *item,
 121                                                                 gpointer                    user_data);
 122 static void            presence_chooser_clear_response_cb      (GtkWidget                  *widget,
 123                                                                 gint                        response,
 124                                                                 gpointer                    user_data);
 125 static void            presence_chooser_noncustom_activate_cb  (GtkWidget                  *item,
 126                                                                 gpointer                    user_data);
 127 static void            presence_chooser_set_state              (McPresence                  state,
 128                                                                 const gchar                *status,
 129                                                                 gboolean                    save);
 130 static void            presence_chooser_custom_activate_cb     (GtkWidget                  *item,
 131                                                                 gpointer                    user_data);
 132 static void            presence_chooser_show_dialog            (McPresence                  state);
 133 static void            presence_chooser_dialog_response_cb     (GtkWidget                  *dialog,
 134                                                                 gint                        response,
 135                                                                 gpointer                    user_data);
 136
 137 G_DEFINE_TYPE (EmpathyPresenceChooser, empathy_presence_chooser, GTK_TYPE_TOGGLE_BUTTON);
 138
 139 static void
 140 empathy_presence_chooser_class_init (EmpathyPresenceChooserClass *klass)
 141 {
 142         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 143
 144         object_class->finalize = presence_chooser_finalize;
 145
 146         g_type_class_add_private (object_class, sizeof (EmpathyPresenceChooserPriv));
 147 }
 148
 149 static void
 150 empathy_presence_chooser_init (EmpathyPresenceChooser *chooser)
 151 {
 152         EmpathyPresenceChooserPriv *priv;
 153         GtkWidget                 *arrow;
 154         GtkWidget                 *alignment;
 155
 156         priv = GET_PRIV (chooser);
 157
 158         gtk_button_set_relief (GTK_BUTTON (chooser), GTK_RELIEF_NONE);
 159         gtk_button_set_focus_on_click (GTK_BUTTON (chooser), FALSE);
 160
 161         alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
 162         gtk_widget_show (alignment);
 163         gtk_container_add (GTK_CONTAINER (chooser), alignment);
 164         gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 1, 0);
 165
 166         priv->hbox = gtk_hbox_new (FALSE, 1);
 167         gtk_widget_show (priv->hbox);
 168         gtk_container_add (GTK_CONTAINER (alignment), priv->hbox);
 169
 170         priv->image = gtk_image_new ();
 171         gtk_widget_show (priv->image);
 172         gtk_box_pack_start (GTK_BOX (priv->hbox), priv->image, FALSE, TRUE, 0);
 173
 174         priv->label = gtk_label_new (NULL);
 175         gtk_widget_show (priv->label);
 176         gtk_box_pack_start (GTK_BOX (priv->hbox), priv->label, TRUE, TRUE, 0);
 177         gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END);
 178         gtk_misc_set_alignment (GTK_MISC (priv->label), 0, 0.5);
 179         gtk_misc_set_padding (GTK_MISC (priv->label), 4, 1);
 180
 181         alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
 182         gtk_widget_show (alignment);
 183         gtk_box_pack_start (GTK_BOX (priv->hbox), alignment, FALSE, FALSE, 0);
 184
 185         arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
 186         gtk_widget_show (arrow);
 187         gtk_container_add (GTK_CONTAINER (alignment), arrow);
 188
 189         g_signal_connect (chooser, "toggled",
 190                           G_CALLBACK (presence_chooser_toggled_cb),
 191                           NULL);
 192         g_signal_connect (chooser, "button-press-event",
 193                           G_CALLBACK (presence_chooser_button_press_event_cb),
 194                           NULL);
 195         g_signal_connect (chooser, "scroll-event",
 196                           G_CALLBACK (presence_chooser_scroll_event_cb),
 197                           NULL);
 198
 199         priv->idle = empathy_idle_new ();
 200         presence_chooser_presence_changed_cb (chooser);
 201         g_signal_connect_swapped (priv->idle, "notify",
 202                                   G_CALLBACK (presence_chooser_presence_changed_cb),
 203                                   chooser);
 204 }
 205
 206 static void
 207 presence_chooser_finalize (GObject *object)
 208 {
 209         EmpathyPresenceChooserPriv *priv;
 210
 211         priv = GET_PRIV (object);
 212
 213         if (priv->flash_timeout_id) {
 214                 g_source_remove (priv->flash_timeout_id);
 215         }
 216
 217         if (priv->scroll_timeout_id) {
 218                 g_source_remove (priv->scroll_timeout_id);
 219         }
 220
 221         g_signal_handlers_disconnect_by_func (priv->idle,
 222                                               presence_chooser_presence_changed_cb,
 223                                               object);
 224         g_object_unref (priv->idle);
 225
 226         G_OBJECT_CLASS (empathy_presence_chooser_parent_class)->finalize (object);
 227 }
 228
 229 GtkWidget *
 230 empathy_presence_chooser_new (void)
 231 {
 232         GtkWidget *chooser;
 233
 234         chooser = g_object_new (EMPATHY_TYPE_PRESENCE_CHOOSER, NULL);
 235
 236         return chooser;
 237 }
 238
 239 static void
 240 presence_chooser_presence_changed_cb (EmpathyPresenceChooser *chooser)
 241 {
 242         EmpathyPresenceChooserPriv *priv;
 243         McPresence                 state;
 244         McPresence                 flash_state;
 245         const gchar               *status;
 246
 247         priv = GET_PRIV (chooser);
 248
 249         state = empathy_idle_get_state (priv->idle);
 250         status = empathy_idle_get_status (priv->idle);
 251         flash_state = empathy_idle_get_flash_state (priv->idle);
 252
 253         presence_chooser_reset_scroll_timeout (chooser);
 254         gtk_label_set_text (GTK_LABEL (priv->label), status);
 255
 256         if (flash_state != MC_PRESENCE_UNSET) {
 257                 presence_chooser_flash_start (chooser, state, flash_state);
 258         } else {
 259                 presence_chooser_flash_stop (chooser, state);
 260         }
 261 }
 262
 263 static void
 264 presence_chooser_reset_scroll_timeout (EmpathyPresenceChooser *chooser)
 265 {
 266         EmpathyPresenceChooserPriv *priv;
 267
 268         priv = GET_PRIV (chooser);
 269
 270         if (priv->scroll_timeout_id) {
 271                 g_source_remove (priv->scroll_timeout_id);
 272                 priv->scroll_timeout_id = 0;
 273         }
 274
 275         g_free (priv->scroll_status);
 276         priv->scroll_status = NULL;
 277 }
 278
 279 static gboolean
 280 presence_chooser_scroll_timeout_cb (EmpathyPresenceChooser *chooser)
 281 {
 282         EmpathyPresenceChooserPriv *priv;
 283
 284         priv = GET_PRIV (chooser);
 285
 286         priv->scroll_timeout_id = 0;
 287
 288         empathy_idle_set_presence (priv->idle,
 289                                    priv->scroll_state,
 290                                    priv->scroll_status);
 291
 292         g_free (priv->scroll_status);
 293         priv->scroll_status = NULL;
 294
 295         return FALSE;
 296 }
 297
 298 static gboolean
 299 presence_chooser_scroll_event_cb (EmpathyPresenceChooser *chooser,
 300                                   GdkEventScroll        *event,
 301                                   gpointer               user_data)
 302 {
 303         EmpathyPresenceChooserPriv *priv;
 304         GList                     *list, *l;
 305         const gchar               *current_status;
 306         StateAndStatus            *sas;
 307         gboolean                   match;
 308
 309         priv = GET_PRIV (chooser);
 310
 311         switch (event->direction) {
 312         case GDK_SCROLL_UP:
 313                 break;
 314         case GDK_SCROLL_DOWN:
 315                 break;
 316         default:
 317                 return FALSE;
 318         }
 319
 320         current_status = gtk_label_get_text (GTK_LABEL (priv->label));
 321
 322         /* Get the list of presets, which in this context means all the items
 323          * without a trailing "...".
 324          */
 325         list = presence_chooser_get_presets (chooser);
 326         sas = NULL;
 327         match = FALSE;
 328         for (l = list; l; l = l->next) {
 329                 sas = l->data;
 330
 331                 if (sas->state == priv->last_state &&
 332                     strcmp (sas->status, current_status) == 0) {
 333                         sas = NULL;
 334                         match = TRUE;
 335                         if (event->direction == GDK_SCROLL_UP) {
 336                                 if (l->prev) {
 337                                         sas = l->prev->data;
 338                                 }
 339                         }
 340                         else if (event->direction == GDK_SCROLL_DOWN) {
 341                                 if (l->next) {
 342                                         sas = l->next->data;
 343                                 }
 344                         }
 345                         break;
 346                 }
 347
 348                 sas = NULL;
 349         }
 350
 351         if (sas) {
 352                 presence_chooser_reset_scroll_timeout (chooser);
 353
 354                 priv->scroll_status = g_strdup (sas->status);
 355                 priv->scroll_state = sas->state;
 356
 357                 priv->scroll_timeout_id =
 358                         g_timeout_add (500,
 359                                        (GSourceFunc) presence_chooser_scroll_timeout_cb,
 360                                        chooser);
 361
 362                 presence_chooser_flash_stop (chooser, sas->state);
 363                 gtk_label_set_text (GTK_LABEL (priv->label), sas->status);
 364         }
 365         else if (!match) {
 366                 const gchar *status;
 367                 /* If we didn't get any match at all, it means the last state
 368                  * was a custom one. Just switch to the first one.
 369                  */
 370                 status = empathy_presence_state_get_default_status (states[0]);
 371
 372                 presence_chooser_reset_scroll_timeout (chooser);
 373                 empathy_idle_set_presence (priv->idle, states[0], status);
 374         }
 375
 376         g_list_foreach (list, (GFunc) g_free, NULL);
 377         g_list_free (list);
 378
 379         return TRUE;
 380 }
 381
 382 static GList *
 383 presence_chooser_get_presets (EmpathyPresenceChooser *chooser)
 384 {
 385         GList      *list = NULL;
 386         guint       i;
 387
 388         for (i = 0; i < G_N_ELEMENTS (states); i++) {
 389                 GList          *presets, *p;
 390                 StateAndStatus *sas;
 391                 const gchar    *status;
 392
 393                 status = empathy_presence_state_get_default_status (states[i]);
 394                 sas = presence_chooser_state_and_status_new (states[i], status);
 395                 list = g_list_append (list, sas);
 396
 397                 presets = empathy_status_presets_get (states[i], 5);
 398                 for (p = presets; p; p = p->next) {
 399                         sas = presence_chooser_state_and_status_new (states[i], p->data);
 400                         list = g_list_append (list, sas);
 401                 }
 402                 g_list_free (presets);
 403         }
 404
 405         return list;
 406 }
 407
 408 static StateAndStatus *
 409 presence_chooser_state_and_status_new (McPresence   state,
 410                                        const gchar *status)
 411 {
 412         StateAndStatus *sas;
 413
 414         sas = g_new0 (StateAndStatus, 1);
 415
 416         sas->state = state;
 417         sas->status = status;
 418
 419         return sas;
 420 }
 421
 422 static gboolean
 423 presence_chooser_flash_timeout_cb (EmpathyPresenceChooser *chooser)
 424 {
 425         EmpathyPresenceChooserPriv *priv;
 426         McPresence                 state;
 427         static gboolean            on = FALSE;
 428
 429         priv = GET_PRIV (chooser);
 430
 431         if (on) {
 432                 state = priv->flash_state_1;
 433         } else {
 434                 state = priv->flash_state_2;
 435         }
 436
 437         gtk_image_set_from_icon_name (GTK_IMAGE (priv->image),
 438                                       empathy_icon_name_for_presence_state (state),
 439                                       GTK_ICON_SIZE_MENU);
 440
 441         on = !on;
 442
 443         return TRUE;
 444 }
 445
 446 static void
 447 presence_chooser_flash_start (EmpathyPresenceChooser *chooser,
 448                               McPresence             state_1,
 449                               McPresence             state_2)
 450 {
 451         EmpathyPresenceChooserPriv *priv;
 452
 453         g_return_if_fail (EMPATHY_IS_PRESENCE_CHOOSER (chooser));
 454
 455         priv = GET_PRIV (chooser);
 456
 457         priv->flash_state_1 = state_1;
 458         priv->flash_state_2 = state_2;
 459
 460         if (!priv->flash_timeout_id) {
 461                 priv->flash_timeout_id = g_timeout_add (FLASH_TIMEOUT,
 462                                                         (GSourceFunc) presence_chooser_flash_timeout_cb,
 463                                                         chooser);
 464         }
 465 }
 466
 467 static void
 468 presence_chooser_flash_stop (EmpathyPresenceChooser *chooser,
 469                              McPresence             state)
 470 {
 471         EmpathyPresenceChooserPriv *priv;
 472
 473         g_return_if_fail (EMPATHY_IS_PRESENCE_CHOOSER (chooser));
 474
 475         priv = GET_PRIV (chooser);
 476
 477         if (priv->flash_timeout_id) {
 478                 g_source_remove (priv->flash_timeout_id);
 479                 priv->flash_timeout_id = 0;
 480         }
 481
 482         gtk_image_set_from_icon_name (GTK_IMAGE (priv->image),
 483                                       empathy_icon_name_for_presence_state (state),
 484                                       GTK_ICON_SIZE_MENU);
 485
 486         priv->last_state = state;
 487 }
 488
 489 static gboolean
 490 presence_chooser_button_press_event_cb (GtkWidget      *chooser,
 491                                         GdkEventButton *event,
 492                                         gpointer        user_data)
 493 {
 494         if (event->button != 1 || event->type != GDK_BUTTON_PRESS) {
 495                 return FALSE;
 496         }
 497
 498         if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (chooser))) {
 499                         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chooser), TRUE);
 500                         return TRUE;
 501                 }
 502
 503         return FALSE;
 504 }
 505
 506 static void
 507 presence_chooser_toggled_cb (GtkWidget *chooser,
 508                              gpointer   user_data)
 509 {
 510         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (chooser))) {
 511                 presence_chooser_menu_popup (EMPATHY_PRESENCE_CHOOSER (chooser));
 512         } else {
 513                 presence_chooser_menu_popdown (EMPATHY_PRESENCE_CHOOSER (chooser));
 514         }
 515 }
 516
 517 static void
 518 presence_chooser_menu_popup (EmpathyPresenceChooser *chooser)
 519 {
 520         EmpathyPresenceChooserPriv *priv;
 521         GtkWidget                 *menu;
 522
 523         priv = GET_PRIV (chooser);
 524
 525         if (priv->menu) {
 526                 return;
 527         }
 528
 529         menu = empathy_presence_chooser_create_menu ();
 530
 531         g_signal_connect_after (menu, "selection-done",
 532                                 G_CALLBACK (presence_chooser_menu_selection_done_cb),
 533                                 chooser);
 534
 535         g_signal_connect (menu, "destroy",
 536                           G_CALLBACK (presence_chooser_menu_destroy_cb),
 537                           chooser);
 538
 539         gtk_menu_attach_to_widget (GTK_MENU (menu),
 540                                    GTK_WIDGET (chooser),
 541                                    presence_chooser_menu_detach);
 542
 543         gtk_menu_popup (GTK_MENU (menu),
 544                         NULL, NULL,
 545                         (GtkMenuPositionFunc) presence_chooser_menu_align_func,
 546                         chooser,
 547                         1,
 548                         gtk_get_current_event_time ());
 549
 550         priv->menu = menu;
 551 }
 552
 553 static void
 554 presence_chooser_menu_popdown (EmpathyPresenceChooser *chooser)
 555 {
 556         EmpathyPresenceChooserPriv *priv;
 557
 558         priv = GET_PRIV (chooser);
 559
 560         if (priv->menu) {
 561                 gtk_widget_destroy (priv->menu);
 562         }
 563 }
 564
 565 static void
 566 presence_chooser_menu_selection_done_cb (GtkMenuShell          *menushell,
 567                                          EmpathyPresenceChooser *chooser)
 568 {
 569         gtk_widget_destroy (GTK_WIDGET (menushell));
 570
 571         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chooser), FALSE);
 572 }
 573
 574 static void
 575 presence_chooser_menu_destroy_cb (GtkWidget             *menu,
 576                                   EmpathyPresenceChooser *chooser)
 577 {
 578         EmpathyPresenceChooserPriv *priv;
 579
 580         priv = GET_PRIV (chooser);
 581
 582         priv->menu = NULL;
 583 }
 584
 585 static void
 586 presence_chooser_menu_detach (GtkWidget *attach_widget,
 587                               GtkMenu   *menu)
 588 {
 589         /* We don't need to do anything, but attaching the menu means
 590          * we don't own the ref count and it is cleaned up properly.
 591          */
 592 }
 593
 594 static void
 595 presence_chooser_menu_align_func (GtkMenu   *menu,
 596                                   gint      *x,
 597                                   gint      *y,
 598                                   gboolean  *push_in,
 599                                   GtkWidget *widget)
 600 {
 601         GtkRequisition  req;
 602         GdkScreen      *screen;
 603         gint            screen_height;
 604
 605         gtk_widget_size_request (GTK_WIDGET (menu), &req);
 606
 607         gdk_window_get_origin (widget->window, x, y);
 608
 609         *x += widget->allocation.x + 1;
 610         *y += widget->allocation.y;
 611
 612         screen = gtk_widget_get_screen (GTK_WIDGET (menu));
 613         screen_height = gdk_screen_get_height (screen);
 614
 615         if (req.height > screen_height) {
 616                 /* Too big for screen height anyway. */
 617                 *y = 0;
 618                 return;
 619         }
 620
 621         if ((*y + req.height + widget->allocation.height) > screen_height) {
 622                 /* Can't put it below the button. */
 623                 *y -= req.height;
 624                 *y += 1;
 625         } else {
 626                 /* Put menu below button. */
 627                 *y += widget->allocation.height;
 628                 *y -= 1;
 629         }
 630
 631         *push_in = FALSE;
 632 }
 633
 634 GtkWidget *
 635 empathy_presence_chooser_create_menu (void)
 636 {
 637         const gchar *status;
 638         GtkWidget   *menu;
 639         GtkWidget   *item;
 640         GtkWidget   *image;
 641         guint        i;
 642
 643         menu = gtk_menu_new ();
 644
 645         for (i = 0; i < G_N_ELEMENTS (states); i++) {
 646                 GList       *list, *l;
 647
 648                 status = empathy_presence_state_get_default_status (states[i]);
 649                 presence_chooser_menu_add_item (menu,
 650                                                 status,
 651                                                 states[i],
 652                                                 FALSE);
 653
 654                 list = empathy_status_presets_get (states[i], 5);
 655                 for (l = list; l; l = l->next) {
 656                         presence_chooser_menu_add_item (menu,
 657                                                         l->data,
 658                                                         states[i],
 659                                                         FALSE);
 660                 }
 661                 g_list_free (list);
 662
 663                 presence_chooser_menu_add_item (menu,
 664                                                 _("Custom message..."),
 665                                                 states[i],
 666                                                 TRUE);
 667
 668                 /* Separator. */
 669                 item = gtk_menu_item_new ();
 670                 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 671                 gtk_widget_show (item);
 672         }
 673
 674         /* Offline to disconnect */
 675         status = empathy_presence_state_get_default_status (MC_PRESENCE_OFFLINE);
 676         presence_chooser_menu_add_item (menu,
 677                                         status,
 678                                         MC_PRESENCE_OFFLINE,
 679                                         FALSE);
 680         /* Separator. */
 681         item = gtk_menu_item_new ();
 682         gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 683         gtk_widget_show (item);
 684
 685         /* Clear list */
 686         item = gtk_image_menu_item_new_with_label (_("Clear List..."));
 687         image = gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU);
 688         gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 689         gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 690         gtk_widget_show (image);
 691         gtk_widget_show (item);
 692
 693         g_signal_connect (item,
 694                           "activate",
 695                           G_CALLBACK (presence_chooser_clear_activate_cb),
 696                           NULL);
 697
 698         return menu;
 699 }
 700
 701 static void
 702 presence_chooser_menu_add_item (GtkWidget   *menu,
 703                                 const gchar *str,
 704                                 McPresence   state,
 705                                 gboolean     custom)
 706 {
 707         GtkWidget   *item;
 708         GtkWidget   *image;
 709         const gchar *icon_name;
 710
 711         item = gtk_image_menu_item_new_with_label (str);
 712         icon_name = empathy_icon_name_for_presence_state (state);
 713
 714         if (custom) {
 715                 g_signal_connect (item, "activate",
 716                                   G_CALLBACK (presence_chooser_custom_activate_cb),
 717                                   NULL);
 718         } else {
 719                 g_signal_connect (item, "activate",
 720                                   G_CALLBACK (presence_chooser_noncustom_activate_cb),
 721                                   NULL);
 722         }
 723
 724         image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
 725         gtk_widget_show (image);
 726
 727         gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 728         gtk_widget_show (item);
 729
 730         g_object_set_data_full (G_OBJECT (item),
 731                                 "status", g_strdup (str),
 732                                 (GDestroyNotify) g_free);
 733
 734         g_object_set_data (G_OBJECT (item), "state", GINT_TO_POINTER (state));
 735
 736         gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 737 }
 738
 739 static void
 740 presence_chooser_clear_activate_cb (GtkWidget *item,
 741                                     gpointer   user_data)
 742 {
 743         GtkWidget *dialog;
 744         GtkWidget *toplevel;
 745         GtkWindow *parent = NULL;
 746
 747         toplevel = gtk_widget_get_toplevel (item);
 748         if (GTK_WIDGET_TOPLEVEL (toplevel) &&
 749             GTK_IS_WINDOW (toplevel)) {
 750                 GtkWindow *window;
 751                 gboolean   visible;
 752
 753                 window = GTK_WINDOW (toplevel);
 754                 visible = empathy_window_get_is_visible (window);
 755
 756                 if (visible) {
 757                         parent = window;
 758                 }
 759         }
 760
 761         dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
 762                                          0,
 763                                          GTK_MESSAGE_QUESTION,
 764                                          GTK_BUTTONS_NONE,
 765                                          _("Are you sure you want to clear the list?"));
 766
 767         gtk_message_dialog_format_secondary_text (
 768                 GTK_MESSAGE_DIALOG (dialog),
 769                 _("This will remove any custom messages you have "
 770                   "added to the list of preset status messages."));
 771
 772         gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 773                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 774                                 _("Clear List"), GTK_RESPONSE_OK,
 775                                 NULL);
 776
 777         gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dialog), FALSE);
 778
 779         g_signal_connect (dialog, "response",
 780                           G_CALLBACK (presence_chooser_clear_response_cb),
 781                           NULL);
 782
 783         gtk_widget_show (dialog);
 784 }
 785
 786 static void
 787 presence_chooser_clear_response_cb (GtkWidget *widget,
 788                                     gint       response,
 789                                     gpointer   user_data)
 790 {
 791         if (response == GTK_RESPONSE_OK) {
 792                 empathy_status_presets_reset ();
 793         }
 794
 795         gtk_widget_destroy (widget);
 796 }
 797
 798 static void
 799 presence_chooser_noncustom_activate_cb (GtkWidget *item,
 800                                         gpointer   user_data)
 801 {
 802         McPresence   state;
 803         const gchar *status;
 804
 805         status = g_object_get_data (G_OBJECT (item), "status");
 806         state = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "state"));
 807
 808         presence_chooser_set_state (state, status, FALSE);
 809 }
 810
 811 static void
 812 presence_chooser_set_state (McPresence   state,
 813                             const gchar *status,
 814                             gboolean     save)
 815 {
 816         EmpathyIdle *idle;
 817
 818         if (!G_STR_EMPTY (status)) {
 819                 const gchar *default_status;
 820
 821                 /* Only store the value if it differs from the default ones. */
 822                 default_status = empathy_presence_state_get_default_status (state);
 823                 if (save && strcmp (status, default_status) != 0) {
 824                         empathy_status_presets_set_last (state, status);
 825                 }
 826         }
 827
 828         idle = empathy_idle_new ();
 829         empathy_idle_set_presence (idle, state, status);
 830         g_object_unref (idle);
 831 }
 832
 833 static void
 834 presence_chooser_custom_activate_cb (GtkWidget *item,
 835                                      gpointer   user_data)
 836 {
 837         McPresence state;
 838
 839         state = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "state"));
 840
 841         presence_chooser_show_dialog (state);
 842 }
 843
 844 static void
 845 presence_chooser_show_dialog (McPresence state)
 846 {
 847         static GtkWidget    *dialog = NULL;
 848         static GtkListStore *store[LAST_MC_PRESENCE];
 849         GladeXML            *glade;
 850         GtkWidget           *image;
 851         GtkWidget           *combo;
 852         GtkWidget           *entry;
 853         GtkWidget           *checkbutton;
 854         const gchar         *default_status;
 855
 856         if (dialog) {
 857                 gtk_widget_destroy (dialog);
 858                 dialog = NULL;
 859         } else {
 860                 guint i;
 861
 862                 for (i = 0; i < LAST_MC_PRESENCE; i++) {
 863                         store[i] = NULL;
 864                 }
 865         }
 866
 867         glade = empathy_glade_get_file ("empathy-presence-chooser.glade",
 868                                        "status_message_dialog",
 869                                        NULL,
 870                                        "status_message_dialog", &dialog,
 871                                        "comboentry_status", &combo,
 872                                        "image_status", &image,
 873                                        "checkbutton_add", &checkbutton,
 874                                        NULL);
 875
 876         g_object_unref (glade);
 877
 878         g_signal_connect (dialog, "destroy",
 879                           G_CALLBACK (gtk_widget_destroyed),
 880                           &dialog);
 881         g_signal_connect (dialog, "response",
 882                           G_CALLBACK (presence_chooser_dialog_response_cb),
 883                           NULL);
 884
 885         gtk_image_set_from_icon_name (GTK_IMAGE (image),
 886                                       empathy_icon_name_for_presence_state (state),
 887                                       GTK_ICON_SIZE_MENU);
 888
 889         if (!store[state]) {
 890                 GList       *presets, *l;
 891                 GtkTreeIter  iter;
 892
 893                 store[state] = gtk_list_store_new (1, G_TYPE_STRING);
 894
 895                 presets = empathy_status_presets_get (state, -1);
 896                 for (l = presets; l; l = l->next) {
 897                         gtk_list_store_append (store[state], &iter);
 898                         gtk_list_store_set (store[state], &iter, 0, l->data, -1);
 899                 }
 900
 901                 g_list_free (presets);
 902         }
 903
 904         default_status = empathy_presence_state_get_default_status (state);
 905
 906         entry = GTK_BIN (combo)->child;
 907         gtk_entry_set_text (GTK_ENTRY (entry), default_status);
 908         gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
 909         gtk_entry_set_width_chars (GTK_ENTRY (entry), 25);
 910
 911         gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (store[state]));
 912         gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (combo), 0);
 913
 914         /* FIXME: Set transian for a window ? */
 915
 916         g_object_set_data (G_OBJECT (dialog), "store", store[state]);
 917         g_object_set_data (G_OBJECT (dialog), "entry", entry);
 918         g_object_set_data (G_OBJECT (dialog), "checkbutton", checkbutton);
 919         g_object_set_data (G_OBJECT (dialog), "state", GINT_TO_POINTER (state));
 920
 921         gtk_widget_show_all (dialog);
 922 }
 923
 924 static void
 925 presence_chooser_dialog_response_cb (GtkWidget *dialog,
 926                                      gint       response,
 927                                      gpointer   user_data)
 928 {
 929         if (response == GTK_RESPONSE_OK) {
 930                 GtkWidget           *entry;
 931                 GtkWidget           *checkbutton;
 932                 GtkListStore        *store;
 933                 GtkTreeModel        *model;
 934                 GtkTreeIter          iter;
 935                 McPresence           state;
 936                 const gchar         *status;
 937                 gboolean             save;
 938                 gboolean             duplicate = FALSE;
 939                 gboolean             has_next;
 940
 941                 entry = g_object_get_data (G_OBJECT (dialog), "entry");
 942                 status = gtk_entry_get_text (GTK_ENTRY (entry));
 943                 store = g_object_get_data (G_OBJECT (dialog), "store");
 944                 model = GTK_TREE_MODEL (store);
 945
 946                 has_next = gtk_tree_model_get_iter_first (model, &iter);
 947                 while (has_next) {
 948                         gchar *str;
 949
 950                         gtk_tree_model_get (model, &iter,
 951                                             0, &str,
 952                                             -1);
 953
 954                         if (strcmp (status, str) == 0) {
 955                                 g_free (str);
 956                                 duplicate = TRUE;
 957                                 break;
 958                         }
 959
 960                         g_free (str);
 961
 962                         has_next = gtk_tree_model_iter_next (model, &iter);
 963                 }
 964
 965                 if (!duplicate) {
 966                         gtk_list_store_append (store, &iter);
 967                         gtk_list_store_set (store, &iter, 0, status, -1);
 968                 }
 969
 970                 checkbutton = g_object_get_data (G_OBJECT (dialog), "checkbutton");
 971                 save = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton));
 972                 state = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog), "state"));
 973
 974                 presence_chooser_set_state (state, status, save);
 975         }
 976
 977         gtk_widget_destroy (dialog);
 978 }
 979