libempathy-gtk/empathy-status-preset-dialog.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * empathy-status-preset-dialog.c
   4  *
   5  * EmpathyStatusPresetDialog - a dialog for adding and removing preset status
   6  * messages.
   7  *
   8  * Copyright (C) 2009 Collabora Ltd.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation; either version 2 of the
  13  * License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public
  21  * License along with this program; if not, write to the
  22  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23  * Boston, MA 02111-1307, USA.
  24  *
  25  * Authors: Davyd Madeley <davyd.madeley@collabora.co.uk>
  26  */
  27 /**
  28  * SECTION:empathy-status-preset-dialog
  29  * @title: EmpathyStatusPresetDialog
  30  * @short_description: a dialog for editing the saved status messages
  31  * @include: libempathy-gtk/empathy-status-preset-dialog.h
  32  *
  33  * #EmpathyStatusPresetDialog is a dialog allowing the user to add/remove/edit
  34  * their saved status messages.
  35  */
  36
  37 #include "config.h"
  38
  39 #include <glib/gi18n-lib.h>
  40 #include <gtk/gtk.h>
  41
  42 #include <libmissioncontrol/mc-enum-types.h>
  43
  44 #include <libempathy/empathy-utils.h>
  45 #include <libempathy/empathy-status-presets.h>
  46
  47 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  48 #include <libempathy/empathy-debug.h>
  49
  50 #include "empathy-ui-utils.h"
  51 #include "empathy-status-preset-dialog.h"
  52
  53 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyStatusPresetDialog)
  54
  55 G_DEFINE_TYPE (EmpathyStatusPresetDialog, empathy_status_preset_dialog, GTK_TYPE_DIALOG);
  56
  57 static McPresence states[] = {
  58         MC_PRESENCE_AVAILABLE,
  59         MC_PRESENCE_DO_NOT_DISTURB,
  60         MC_PRESENCE_AWAY
  61 };
  62
  63 typedef struct _EmpathyStatusPresetDialogPriv EmpathyStatusPresetDialogPriv;
  64 struct _EmpathyStatusPresetDialogPriv
  65 {
  66         /* block status_preset_dialog_add_combo_changed() when > 0 */
  67         int block_add_combo_changed;
  68
  69         GtkWidget *presets_treeview;
  70         GtkWidget *add_combobox;
  71         GtkWidget *add_button;
  72
  73         GtkTreeIter selected_iter;
  74         gboolean add_combo_changed;
  75         char *saved_status;
  76 };
  77
  78 enum
  79 {
  80         PRESETS_STORE_STATE,
  81         PRESETS_STORE_ICON_NAME,
  82         PRESETS_STORE_STATUS,
  83         PRESETS_STORE_N_COLS
  84 };
  85
  86 enum
  87 {
  88         ADD_COMBO_STATE,
  89         ADD_COMBO_ICON_NAME,
  90         ADD_COMBO_STATUS,
  91         ADD_COMBO_DEFAULT_TEXT,
  92         ADD_COMBO_N_COLS
  93 };
  94
  95 static void
  96 empathy_status_preset_dialog_finalize (GObject *self)
  97 {
  98         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
  99
 100         g_free (priv->saved_status);
 101
 102         G_OBJECT_CLASS (empathy_status_preset_dialog_parent_class)->finalize (self);
 103 }
 104
 105 static void
 106 empathy_status_preset_dialog_class_init (EmpathyStatusPresetDialogClass *class)
 107 {
 108         GObjectClass *gobject_class;
 109
 110         gobject_class = G_OBJECT_CLASS (class);
 111         gobject_class->finalize = empathy_status_preset_dialog_finalize;
 112
 113         g_type_class_add_private (gobject_class,
 114                         sizeof (EmpathyStatusPresetDialogPriv));
 115 }
 116
 117 static void
 118 status_preset_dialog_presets_update (EmpathyStatusPresetDialog *self)
 119 {
 120         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 121         GtkListStore *store;
 122         int i;
 123
 124         store = GTK_LIST_STORE (gtk_tree_view_get_model (
 125                                 GTK_TREE_VIEW (priv->presets_treeview)));
 126
 127         gtk_list_store_clear (store);
 128
 129         for (i = 0; i < G_N_ELEMENTS (states); i++) {
 130                 GList *presets, *l;
 131                 const char *icon_name;
 132
 133                 icon_name = empathy_icon_name_for_presence (states[i]);
 134                 presets = empathy_status_presets_get (states[i], -1);
 135                 presets = g_list_sort (presets, (GCompareFunc) g_utf8_collate);
 136
 137                 for (l = presets; l; l = l->next) {
 138                         char *preset = (char *) l->data;
 139
 140                         gtk_list_store_insert_with_values (store,
 141                                         NULL, -1,
 142                                         PRESETS_STORE_STATE, states[i],
 143                                         PRESETS_STORE_ICON_NAME, icon_name,
 144                                         PRESETS_STORE_STATUS, preset,
 145                                         -1);
 146                 }
 147
 148                 g_list_free (presets);
 149         }
 150 }
 151
 152 static void
 153 status_preset_add_combo_reset (EmpathyStatusPresetDialog *self)
 154 {
 155         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 156
 157         gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->add_combobox),
 158                         &priv->selected_iter);
 159 }
 160
 161 static void
 162 status_preset_dialog_setup_add_combobox (EmpathyStatusPresetDialog *self)
 163 {
 164         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 165         GtkWidget *combobox = priv->add_combobox;
 166         GtkListStore *store;
 167         GtkCellRenderer *renderer;
 168         int i;
 169
 170         store = gtk_list_store_new (ADD_COMBO_N_COLS,
 171                         MC_TYPE_PRESENCE,       /* ADD_COMBO_STATE */
 172                         G_TYPE_STRING,          /* ADD_COMBO_ICON_NAME */
 173                         G_TYPE_STRING,          /* ADD_COMBO_STATUS */
 174                         G_TYPE_STRING);         /* ADD_COMBO_DEFAULT_TEXT */
 175
 176         gtk_combo_box_set_model (GTK_COMBO_BOX (combobox),
 177                                  GTK_TREE_MODEL (store));
 178         g_object_unref (store);
 179
 180         gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (combobox),
 181                         ADD_COMBO_DEFAULT_TEXT);
 182
 183         for (i = 0; i < G_N_ELEMENTS (states); i++) {
 184                 gtk_list_store_insert_with_values (store, NULL, -1,
 185                                 ADD_COMBO_STATE, states[i],
 186                                 ADD_COMBO_ICON_NAME, empathy_icon_name_for_presence (states[i]),
 187                                 ADD_COMBO_STATUS, empathy_presence_get_default_message (states[i]),
 188                                 ADD_COMBO_DEFAULT_TEXT, "",
 189                                 -1);
 190         }
 191
 192         gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
 193
 194         renderer = gtk_cell_renderer_pixbuf_new ();
 195         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE);
 196         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox), renderer,
 197                         "icon-name", ADD_COMBO_ICON_NAME);
 198
 199         renderer = gtk_cell_renderer_text_new ();
 200         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
 201         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox), renderer,
 202                         "text", ADD_COMBO_STATUS);
 203         g_object_set (renderer,
 204                         "style", PANGO_STYLE_ITALIC,
 205                         "foreground", "Gray", /* FIXME - theme */
 206                         NULL);
 207
 208         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
 209 }
 210
 211 static void
 212 status_preset_dialog_status_edited (GtkCellRendererText *renderer,
 213                                     char *path_str,
 214                                     char *new_status,
 215                                     EmpathyStatusPresetDialog *self)
 216 {
 217         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 218         GtkTreeModel *model;
 219         GtkTreePath *path;
 220         GtkTreeIter iter;
 221         McPresence state;
 222         char *old_status;
 223         gboolean valid;
 224
 225         if (strlen (new_status) == 0) {
 226                 /* status is empty, ignore */
 227                 return;
 228         }
 229
 230         model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->presets_treeview));
 231         path = gtk_tree_path_new_from_string (path_str);
 232         valid = gtk_tree_model_get_iter (model, &iter, path);
 233         gtk_tree_path_free (path);
 234
 235         if (!valid) return;
 236
 237         gtk_tree_model_get (model, &iter,
 238                         PRESETS_STORE_STATE, &state,
 239                         PRESETS_STORE_STATUS, &old_status,
 240                         -1);
 241
 242         if (!strcmp (old_status, new_status)) {
 243                 /* statuses are the same */
 244                 g_free (old_status);
 245                 return;
 246         }
 247
 248         DEBUG ("EDITED STATUS (%s) -> (%s)\n", old_status, new_status);
 249
 250         empathy_status_presets_remove (state, old_status);
 251         empathy_status_presets_set_last (state, new_status);
 252
 253         g_free (old_status);
 254
 255         status_preset_dialog_presets_update (self);
 256 }
 257
 258 static void
 259 status_preset_dialog_setup_presets_treeview (EmpathyStatusPresetDialog *self)
 260 {
 261         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 262         GtkWidget *treeview = priv->presets_treeview;
 263         GtkListStore *store;
 264         GtkTreeViewColumn *column;
 265         GtkCellRenderer *renderer;
 266
 267         store = gtk_list_store_new (PRESETS_STORE_N_COLS,
 268                         MC_TYPE_PRESENCE,       /* PRESETS_STORE_STATE */
 269                         G_TYPE_STRING,          /* PRESETS_STORE_ICON_NAME */
 270                         G_TYPE_STRING);         /* PRESETS_STORE_STATUS */
 271
 272         gtk_tree_view_set_model (GTK_TREE_VIEW (treeview),
 273                                  GTK_TREE_MODEL (store));
 274         g_object_unref (store);
 275
 276         status_preset_dialog_presets_update (self);
 277
 278         column = gtk_tree_view_column_new ();
 279         gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
 280
 281         renderer = gtk_cell_renderer_pixbuf_new ();
 282         gtk_tree_view_column_pack_start (column, renderer, FALSE);
 283         gtk_tree_view_column_add_attribute (column, renderer,
 284                         "icon-name", PRESETS_STORE_ICON_NAME);
 285
 286         renderer = gtk_cell_renderer_text_new ();
 287         gtk_tree_view_column_pack_start (column, renderer, TRUE);
 288         gtk_tree_view_column_add_attribute (column, renderer,
 289                         "text", PRESETS_STORE_STATUS);
 290         g_object_set (renderer,
 291                         "editable", TRUE,
 292                         NULL);
 293         g_signal_connect (renderer, "edited",
 294                         G_CALLBACK (status_preset_dialog_status_edited), self);
 295 }
 296
 297 static void
 298 status_preset_dialog_preset_selection_changed (GtkTreeSelection *selection,
 299                                                GtkWidget *remove_button)
 300 {
 301         /* update the sensitivity of the Remove button */
 302         gtk_widget_set_sensitive (remove_button,
 303                         gtk_tree_selection_get_selected (selection, NULL, NULL));
 304 }
 305
 306 static void
 307 status_preset_dialog_preset_remove (GtkButton *button,
 308                                     EmpathyStatusPresetDialog *self)
 309 {
 310         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 311         GtkTreeSelection *selection;
 312         GtkTreeModel *model;
 313         GtkTreeIter iter;
 314         McPresence state;
 315         char *status;
 316
 317         selection = gtk_tree_view_get_selection (
 318                         GTK_TREE_VIEW (priv->presets_treeview));
 319
 320         g_return_if_fail (gtk_tree_selection_get_selected (selection,
 321                                 &model, &iter));
 322
 323         gtk_tree_model_get (model, &iter,
 324                         PRESETS_STORE_STATE, &state,
 325                         PRESETS_STORE_STATUS, &status,
 326                         -1);
 327
 328         DEBUG ("REMOVE PRESET (%i, %s)\n", state, status);
 329         empathy_status_presets_remove (state, status);
 330
 331         g_free (status);
 332
 333         status_preset_dialog_presets_update (self);
 334 }
 335
 336 static void
 337 status_preset_dialog_set_add_combo_changed (EmpathyStatusPresetDialog *self,
 338                                             gboolean state,
 339                                             gboolean reset_text)
 340 {
 341         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 342         GtkWidget *entry;
 343
 344         entry = gtk_bin_get_child (GTK_BIN (priv->add_combobox));
 345
 346         priv->add_combo_changed = state;
 347         gtk_widget_set_sensitive (priv->add_button, state);
 348
 349         if (state) {
 350                 gtk_widget_modify_text (entry, GTK_STATE_NORMAL, NULL);
 351         } else {
 352                 GdkColor colour;
 353
 354                 gdk_color_parse ("Gray", &colour); /* FIXME - theme */
 355                 gtk_widget_modify_text (entry, GTK_STATE_NORMAL, &colour);
 356
 357                 if (reset_text) {
 358                         priv->block_add_combo_changed++;
 359                         gtk_entry_set_text (GTK_ENTRY (entry),
 360                                         _("Enter Custom Message"));
 361                         priv->block_add_combo_changed--;
 362                 }
 363         }
 364 }
 365
 366 static void
 367 status_preset_dialog_add_combo_changed (GtkComboBox *combo,
 368                                         EmpathyStatusPresetDialog *self)
 369 {
 370         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 371         GtkWidget *entry;
 372         GtkTreeModel *model;
 373         GtkTreeIter iter;
 374
 375         if (priv->block_add_combo_changed) return;
 376
 377         model = gtk_combo_box_get_model (combo);
 378         entry = gtk_bin_get_child (GTK_BIN (combo));
 379
 380         if (gtk_combo_box_get_active_iter (combo, &iter)) {
 381                 char *icon_name;
 382
 383                 priv->selected_iter = iter;
 384                 gtk_tree_model_get (model, &iter,
 385                                 PRESETS_STORE_ICON_NAME, &icon_name,
 386                                 -1);
 387
 388                 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
 389                                 GTK_ENTRY_ICON_PRIMARY,
 390                                 icon_name);
 391
 392                 g_free (icon_name);
 393
 394                 status_preset_dialog_set_add_combo_changed (self, FALSE, TRUE);
 395                 if (priv->saved_status && strlen (priv->saved_status) > 0) {
 396                         gtk_entry_set_text (GTK_ENTRY (entry),
 397                                         priv->saved_status);
 398                 }
 399         } else {
 400                 g_free (priv->saved_status);
 401                 priv->saved_status = g_strdup (
 402                                 gtk_entry_get_text (GTK_ENTRY (entry)));
 403
 404                 status_preset_dialog_set_add_combo_changed (self,
 405                                 strlen (priv->saved_status) > 0, FALSE);
 406         }
 407 }
 408
 409 static void
 410 status_preset_dialog_add_preset (GtkWidget *widget,
 411                                  EmpathyStatusPresetDialog *self)
 412 {
 413         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 414         GtkTreeModel *model;
 415         GtkWidget *entry;
 416         McPresence state;
 417         const char *status;
 418
 419         g_return_if_fail (priv->add_combo_changed);
 420
 421         model = gtk_combo_box_get_model (GTK_COMBO_BOX (priv->add_combobox));
 422         entry = gtk_bin_get_child (GTK_BIN (priv->add_combobox));
 423
 424         status = gtk_entry_get_text (GTK_ENTRY (entry));
 425         gtk_tree_model_get (model, &priv->selected_iter,
 426                         PRESETS_STORE_STATE, &state,
 427                         -1);
 428
 429         DEBUG ("ADD PRESET (%i, %s)\n", state, status);
 430         empathy_status_presets_set_last (state, status);
 431
 432         status_preset_dialog_presets_update (self);
 433         status_preset_add_combo_reset (self);
 434 }
 435
 436 static gboolean
 437 status_preset_dialog_add_combo_press_event (GtkWidget *widget,
 438                                             GdkEventButton *event,
 439                                             EmpathyStatusPresetDialog *self)
 440 {
 441         if (!GTK_WIDGET_HAS_FOCUS (widget)) {
 442                 /* if the widget isn't focused, focus it and select the text */
 443                 gtk_widget_grab_focus (widget);
 444                 gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1);
 445
 446                 return TRUE;
 447         }
 448
 449         return FALSE;
 450 }
 451
 452 static gboolean
 453 status_preset_dialog_add_combo_focus_out (GtkWidget *widget,
 454                                           GdkEventFocus *event,
 455                                           EmpathyStatusPresetDialog *self)
 456 {
 457         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 458         const char *status;
 459
 460         gtk_editable_set_position (GTK_EDITABLE (widget), 0);
 461
 462         status = gtk_entry_get_text (GTK_ENTRY (widget));
 463         status_preset_dialog_set_add_combo_changed (self,
 464                         priv->add_combo_changed && strlen (status) > 0,
 465                         TRUE);
 466
 467         return FALSE;
 468 }
 469
 470 static void
 471 empathy_status_preset_dialog_init (EmpathyStatusPresetDialog *self)
 472 {
 473         EmpathyStatusPresetDialogPriv *priv = self->priv =
 474                 G_TYPE_INSTANCE_GET_PRIVATE (self,
 475                         EMPATHY_TYPE_STATUS_PRESET_DIALOG,
 476                         EmpathyStatusPresetDialogPriv);
 477         GtkBuilder *gui;
 478         GtkWidget *toplevel_vbox, *remove_button, *entry;
 479         char *filename;
 480
 481         gtk_window_set_title (GTK_WINDOW (self),
 482                         _("Edit Custom Messages"));
 483         gtk_dialog_set_has_separator (GTK_DIALOG (self), FALSE);
 484         gtk_dialog_add_button (GTK_DIALOG (self),
 485                         GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
 486
 487         filename = empathy_file_lookup ("empathy-status-preset-dialog.ui",
 488                         "libempathy-gtk");
 489         gui = empathy_builder_get_file (filename,
 490                         "toplevel-vbox", &toplevel_vbox,
 491                         "presets-treeview", &priv->presets_treeview,
 492                         "remove-button", &remove_button,
 493                         "add-combobox", &priv->add_combobox,
 494                         "add-button", &priv->add_button,
 495                         NULL);
 496         g_free (filename);
 497
 498         g_signal_connect (gtk_tree_view_get_selection (
 499                                 GTK_TREE_VIEW (priv->presets_treeview)),
 500                         "changed",
 501                         G_CALLBACK (status_preset_dialog_preset_selection_changed),
 502                         remove_button);
 503
 504         entry = gtk_bin_get_child (GTK_BIN (priv->add_combobox));
 505         g_signal_connect (entry, "activate",
 506                         G_CALLBACK (status_preset_dialog_add_preset), self);
 507         g_signal_connect (entry, "button-press-event",
 508                         G_CALLBACK (status_preset_dialog_add_combo_press_event),
 509                         self);
 510         g_signal_connect (entry, "focus-out-event",
 511                         G_CALLBACK (status_preset_dialog_add_combo_focus_out),
 512                         self);
 513
 514         empathy_builder_connect (gui, self,
 515                         "remove-button", "clicked", status_preset_dialog_preset_remove,
 516                         "add-combobox", "changed", status_preset_dialog_add_combo_changed,
 517                         "add-button", "clicked", status_preset_dialog_add_preset,
 518                         NULL);
 519
 520         status_preset_dialog_setup_presets_treeview (self);
 521         status_preset_dialog_setup_add_combobox (self);
 522
 523         gtk_box_pack_start(GTK_BOX (GTK_DIALOG (self)->vbox), toplevel_vbox,
 524                         TRUE, TRUE, 0);
 525
 526         g_object_unref (gui);
 527 }
 528
 529 /**
 530  * empathy_status_preset_dialog_new:
 531  * @parent: the parent window of this dialog (or NULL)
 532  *
 533  * Creates a new #EmpathyStatusPresetDialog that allows the user to
 534  * add/remove/edit their saved status messages.
 535  *
 536  * Returns: the newly constructed dialog.
 537  */
 538 GtkWidget *
 539 empathy_status_preset_dialog_new (GtkWindow *parent)
 540 {
 541         GtkWidget *self = g_object_new (EMPATHY_TYPE_STATUS_PRESET_DIALOG,
 542                         NULL);
 543
 544         if (parent) {
 545                 gtk_window_set_transient_for (GTK_WINDOW (self), parent);
 546         }
 547
 548         return self;
 549 }