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