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., 51 Franklin St, Fifth Floor,
  23  * Boston, MA  02110-1301  USA
  24  *
  25  * Authors: Danielle Madeley <danielle.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 <libempathy/empathy-utils.h>
  43 #include <libempathy/empathy-status-presets.h>
  44
  45 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  46 #include <libempathy/empathy-debug.h>
  47
  48 #include "empathy-ui-utils.h"
  49 #include "empathy-status-preset-dialog.h"
  50
  51 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyStatusPresetDialog)
  52
  53 G_DEFINE_TYPE (EmpathyStatusPresetDialog, empathy_status_preset_dialog, GTK_TYPE_DIALOG);
  54
  55 static TpConnectionPresenceType states[] = {
  56         TP_CONNECTION_PRESENCE_TYPE_AVAILABLE,
  57         TP_CONNECTION_PRESENCE_TYPE_BUSY,
  58         TP_CONNECTION_PRESENCE_TYPE_AWAY,
  59 };
  60
  61 typedef struct _EmpathyStatusPresetDialogPriv EmpathyStatusPresetDialogPriv;
  62 struct _EmpathyStatusPresetDialogPriv
  63 {
  64         /* block status_preset_dialog_add_combo_changed () when > 0 */
  65         int block_add_combo_changed;
  66
  67         GtkWidget *presets_treeview;
  68         GtkTreeViewColumn *column;
  69         GtkCellRenderer *text_cell;
  70
  71         GtkWidget *add_combobox;
  72         GtkWidget *add_button;
  73
  74         GtkTreeIter selected_iter;
  75         gboolean add_combo_changed;
  76         char *saved_status;
  77 };
  78
  79 enum
  80 {
  81         PRESETS_STORE_STATE,
  82         PRESETS_STORE_ICON_NAME,
  83         PRESETS_STORE_STATUS,
  84         PRESETS_STORE_N_COLS
  85 };
  86
  87 enum
  88 {
  89         ADD_COMBO_STATE,
  90         ADD_COMBO_ICON_NAME,
  91         ADD_COMBO_STATUS,
  92         ADD_COMBO_DEFAULT_TEXT,
  93         ADD_COMBO_N_COLS
  94 };
  95
  96 static void
  97 empathy_status_preset_dialog_finalize (GObject *self)
  98 {
  99         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 100
 101         g_free (priv->saved_status);
 102
 103         G_OBJECT_CLASS (empathy_status_preset_dialog_parent_class)->finalize (self);
 104 }
 105
 106 static void
 107 empathy_status_preset_dialog_class_init (EmpathyStatusPresetDialogClass *class)
 108 {
 109         GObjectClass *gobject_class;
 110
 111         gobject_class = G_OBJECT_CLASS (class);
 112         gobject_class->finalize = empathy_status_preset_dialog_finalize;
 113
 114         g_type_class_add_private (gobject_class,
 115                         sizeof (EmpathyStatusPresetDialogPriv));
 116 }
 117
 118 static void
 119 status_preset_dialog_presets_update (EmpathyStatusPresetDialog *self)
 120 {
 121         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 122         GtkListStore *store;
 123         guint i;
 124
 125         store = GTK_LIST_STORE (gtk_tree_view_get_model (
 126                                 GTK_TREE_VIEW (priv->presets_treeview)));
 127
 128         gtk_list_store_clear (store);
 129
 130         for (i = 0; i < G_N_ELEMENTS (states); i++) {
 131                 GList *presets, *l;
 132                 const char *icon_name;
 133
 134                 icon_name = empathy_icon_name_for_presence (states[i]);
 135                 presets = empathy_status_presets_get (states[i], -1);
 136                 presets = g_list_sort (presets, (GCompareFunc) g_utf8_collate);
 137
 138                 for (l = presets; l; l = l->next) {
 139                         char *preset = (char *) l->data;
 140
 141                         gtk_list_store_insert_with_values (store,
 142                                         NULL, -1,
 143                                         PRESETS_STORE_STATE, states[i],
 144                                         PRESETS_STORE_ICON_NAME, icon_name,
 145                                         PRESETS_STORE_STATUS, preset,
 146                                         -1);
 147                 }
 148
 149                 g_list_free (presets);
 150         }
 151 }
 152
 153 static void
 154 status_preset_add_combo_reset (EmpathyStatusPresetDialog *self)
 155 {
 156         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 157         GtkWidget *entry;
 158
 159         entry = gtk_bin_get_child (GTK_BIN (priv->add_combobox));
 160         gtk_entry_set_text (GTK_ENTRY (entry), "");
 161
 162         gtk_combo_box_set_active_iter (GTK_COMBO_BOX (priv->add_combobox),
 163                         &priv->selected_iter);
 164 }
 165
 166 static void
 167 status_preset_dialog_setup_add_combobox (EmpathyStatusPresetDialog *self)
 168 {
 169         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 170         GtkWidget *combobox = priv->add_combobox;
 171         GtkListStore *store;
 172         GtkCellRenderer *renderer;
 173         guint i;
 174
 175         store = gtk_list_store_new (ADD_COMBO_N_COLS,
 176                         G_TYPE_UINT,            /* ADD_COMBO_STATE */
 177                         G_TYPE_STRING,          /* ADD_COMBO_ICON_NAME */
 178                         G_TYPE_STRING,          /* ADD_COMBO_STATUS */
 179                         G_TYPE_STRING);         /* ADD_COMBO_DEFAULT_TEXT */
 180
 181         gtk_combo_box_set_model (GTK_COMBO_BOX (combobox),
 182                                  GTK_TREE_MODEL (store));
 183         g_object_unref (store);
 184
 185         gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (combobox),
 186                         ADD_COMBO_DEFAULT_TEXT);
 187
 188         for (i = 0; i < G_N_ELEMENTS (states); i++) {
 189                 gtk_list_store_insert_with_values (store, NULL, -1,
 190                                 ADD_COMBO_STATE, states[i],
 191                                 ADD_COMBO_ICON_NAME, empathy_icon_name_for_presence (states[i]),
 192                                 ADD_COMBO_STATUS, empathy_presence_get_default_message (states[i]),
 193                                 ADD_COMBO_DEFAULT_TEXT, "",
 194                                 -1);
 195         }
 196
 197         gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
 198
 199         renderer = gtk_cell_renderer_pixbuf_new ();
 200         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE);
 201         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox), renderer,
 202                         "icon-name", ADD_COMBO_ICON_NAME);
 203
 204         renderer = gtk_cell_renderer_text_new ();
 205         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
 206         gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox), renderer,
 207                         "text", ADD_COMBO_STATUS);
 208         g_object_set (renderer,
 209                         "style", PANGO_STYLE_ITALIC,
 210                         "foreground", "Gray", /* FIXME - theme */
 211                         NULL);
 212
 213         gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
 214 }
 215
 216 static void
 217 status_preset_dialog_status_edited (GtkCellRendererText *renderer,
 218                                     char *path_str,
 219                                     char *new_status,
 220                                     EmpathyStatusPresetDialog *self)
 221 {
 222         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 223         GtkTreeModel *model;
 224         GtkTreePath *path;
 225         GtkTreeIter iter;
 226         TpConnectionPresenceType state;
 227         char *old_status;
 228         gboolean valid;
 229
 230         if (strlen (new_status) == 0) {
 231                 /* status is empty, ignore */
 232                 return;
 233         }
 234
 235         model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->presets_treeview));
 236         path = gtk_tree_path_new_from_string (path_str);
 237         valid = gtk_tree_model_get_iter (model, &iter, path);
 238         gtk_tree_path_free (path);
 239
 240         if (!valid) return;
 241
 242         gtk_tree_model_get (model, &iter,
 243                         PRESETS_STORE_STATE, &state,
 244                         PRESETS_STORE_STATUS, &old_status,
 245                         -1);
 246
 247         if (!strcmp (old_status, new_status)) {
 248                 /* statuses are the same */
 249                 g_free (old_status);
 250                 return;
 251         }
 252
 253         DEBUG ("EDITED STATUS (%s) -> (%s)\n", old_status, new_status);
 254
 255         empathy_status_presets_remove (state, old_status);
 256         empathy_status_presets_set_last (state, new_status);
 257
 258         g_free (old_status);
 259
 260         status_preset_dialog_presets_update (self);
 261 }
 262
 263 static void
 264 status_preset_dialog_setup_presets_treeview (EmpathyStatusPresetDialog *self)
 265 {
 266         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 267         GtkWidget *treeview = priv->presets_treeview;
 268         GtkListStore *store;
 269         GtkTreeViewColumn *column;
 270         GtkCellRenderer *renderer;
 271
 272         store = gtk_list_store_new (PRESETS_STORE_N_COLS,
 273                         G_TYPE_UINT,            /* PRESETS_STORE_STATE */
 274                         G_TYPE_STRING,          /* PRESETS_STORE_ICON_NAME */
 275                         G_TYPE_STRING);         /* PRESETS_STORE_STATUS */
 276
 277         gtk_tree_view_set_model (GTK_TREE_VIEW (treeview),
 278                                  GTK_TREE_MODEL (store));
 279         g_object_unref (store);
 280
 281         status_preset_dialog_presets_update (self);
 282
 283         column = gtk_tree_view_column_new ();
 284         priv->column = column;
 285         gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
 286
 287         renderer = gtk_cell_renderer_pixbuf_new ();
 288         gtk_tree_view_column_pack_start (column, renderer, FALSE);
 289         gtk_tree_view_column_add_attribute (column, renderer,
 290                         "icon-name", PRESETS_STORE_ICON_NAME);
 291
 292         renderer = gtk_cell_renderer_text_new ();
 293         priv->text_cell = renderer;
 294         gtk_tree_view_column_pack_start (column, renderer, TRUE);
 295         gtk_tree_view_column_add_attribute (column, renderer,
 296                         "text", PRESETS_STORE_STATUS);
 297         g_object_set (renderer,
 298                         "editable", TRUE,
 299                         NULL);
 300         g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 301
 302         g_signal_connect (renderer, "edited",
 303                         G_CALLBACK (status_preset_dialog_status_edited), self);
 304 }
 305
 306 static void
 307 status_preset_dialog_preset_selection_changed (GtkTreeSelection *selection,
 308                                                GtkWidget *remove_button)
 309 {
 310         /* update the sensitivity of the Remove button */
 311         gtk_widget_set_sensitive (remove_button,
 312                         gtk_tree_selection_count_selected_rows (selection) != 0);
 313 }
 314
 315 static void
 316 foreach_removed_status (GtkTreeModel *model,
 317                         GtkTreePath *path,
 318                         GtkTreeIter *iter,
 319                         gpointer data)
 320 {
 321         TpConnectionPresenceType state;
 322         char *status;
 323
 324         gtk_tree_model_get (model, iter,
 325                         PRESETS_STORE_STATE, &state,
 326                         PRESETS_STORE_STATUS, &status,
 327                         -1);
 328
 329         DEBUG ("REMOVE PRESET (%i, %s)\n", state, status);
 330         empathy_status_presets_remove (state, status);
 331
 332         g_free (status);
 333 }
 334
 335 static void
 336 status_preset_dialog_preset_remove (GtkButton *button,
 337                                     EmpathyStatusPresetDialog *self)
 338 {
 339         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 340         GtkTreeSelection *selection;
 341
 342         selection = gtk_tree_view_get_selection (
 343                         GTK_TREE_VIEW (priv->presets_treeview));
 344         gtk_tree_selection_selected_foreach (selection, foreach_removed_status, NULL);
 345         status_preset_dialog_presets_update (self);
 346 }
 347
 348 static void
 349 status_preset_dialog_set_add_combo_changed (EmpathyStatusPresetDialog *self,
 350                                             gboolean state,
 351                                             gboolean reset_text)
 352 {
 353         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 354         GtkWidget *entry;
 355
 356         entry = gtk_bin_get_child (GTK_BIN (priv->add_combobox));
 357
 358         priv->add_combo_changed = state;
 359         gtk_widget_set_sensitive (priv->add_button, state);
 360
 361         if (state) {
 362                 gtk_widget_override_color (entry, 0, NULL);
 363         } else {
 364                 GdkRGBA color;
 365
 366                 if (gdk_rgba_parse (&color, "Gray")) /* FIXME - theme */
 367                         gtk_widget_override_color (entry, 0, &color);
 368
 369                 if (reset_text) {
 370                         priv->block_add_combo_changed++;
 371                         gtk_entry_set_text (GTK_ENTRY (entry),
 372                                         _("Enter Custom Message"));
 373                         priv->block_add_combo_changed--;
 374                 }
 375         }
 376 }
 377
 378 static void
 379 status_preset_dialog_add_combo_changed (GtkComboBox *combo,
 380                                         EmpathyStatusPresetDialog *self)
 381 {
 382         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 383         GtkWidget *entry;
 384         GtkTreeModel *model;
 385         GtkTreeIter iter;
 386
 387         if (priv->block_add_combo_changed) return;
 388
 389         model = gtk_combo_box_get_model (combo);
 390         entry = gtk_bin_get_child (GTK_BIN (combo));
 391
 392         if (gtk_combo_box_get_active_iter (combo, &iter)) {
 393                 char *icon_name;
 394
 395                 priv->selected_iter = iter;
 396                 gtk_tree_model_get (model, &iter,
 397                                 PRESETS_STORE_ICON_NAME, &icon_name,
 398                                 -1);
 399
 400                 gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
 401                                 GTK_ENTRY_ICON_PRIMARY,
 402                                 icon_name);
 403
 404                 g_free (icon_name);
 405
 406                 status_preset_dialog_set_add_combo_changed (self, FALSE, TRUE);
 407                 if (priv->saved_status && strlen (priv->saved_status) > 0) {
 408                         gtk_entry_set_text (GTK_ENTRY (entry),
 409                                         priv->saved_status);
 410                 }
 411         } else {
 412                 g_free (priv->saved_status);
 413                 priv->saved_status = g_strdup (
 414                                 gtk_entry_get_text (GTK_ENTRY (entry)));
 415
 416                 status_preset_dialog_set_add_combo_changed (self,
 417                                 strlen (priv->saved_status) > 0, FALSE);
 418         }
 419 }
 420
 421 static void
 422 status_preset_dialog_add_preset (GtkWidget *widget,
 423                                  EmpathyStatusPresetDialog *self)
 424 {
 425         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 426         GtkTreeModel *model;
 427         GtkTreeIter iter;
 428         GtkWidget *entry;
 429         TpConnectionPresenceType state, cstate;
 430         const char *status;
 431         char *cstatus;
 432         gboolean valid, match = FALSE;
 433
 434         g_return_if_fail (priv->add_combo_changed);
 435
 436         model = gtk_combo_box_get_model (GTK_COMBO_BOX (priv->add_combobox));
 437         entry = gtk_bin_get_child (GTK_BIN (priv->add_combobox));
 438
 439         status = gtk_entry_get_text (GTK_ENTRY (entry));
 440         gtk_tree_model_get (model, &priv->selected_iter,
 441                         PRESETS_STORE_STATE, &state,
 442                         -1);
 443
 444         DEBUG ("ADD PRESET (%i, %s)\n", state, status);
 445         empathy_status_presets_set_last (state, status);
 446
 447         status_preset_dialog_presets_update (self);
 448
 449         /* select the added status*/
 450         model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->presets_treeview));
 451         for (valid = gtk_tree_model_get_iter_first (model, &iter);
 452              valid;
 453              valid = gtk_tree_model_iter_next (model, &iter)) {
 454
 455                 gtk_tree_model_get (model, &iter,
 456                                 PRESETS_STORE_STATE, &cstate,
 457                                 PRESETS_STORE_STATUS, &cstatus,
 458                                 -1);
 459
 460                 match = (cstate == state) && (strcmp (cstatus, status) == 0);
 461
 462                 g_free (cstatus);
 463
 464                 if (match) {
 465                         GtkTreePath *path;
 466
 467                         path = gtk_tree_model_get_path (model, &iter);
 468                         gtk_tree_view_set_cursor_on_cell (
 469                                 GTK_TREE_VIEW (priv->presets_treeview),
 470                                 path,
 471                                 priv->column,
 472                                 priv->text_cell,
 473                                 FALSE);
 474                         gtk_widget_grab_focus (priv->presets_treeview);
 475                         gtk_tree_path_free (path);
 476                         break;
 477                 }
 478         }
 479
 480         if (!match) g_warning ("No match");
 481
 482         status_preset_add_combo_reset (self);
 483 }
 484
 485 static gboolean
 486 status_preset_dialog_add_combo_press_event (GtkWidget *widget,
 487                                             GdkEventButton *event,
 488                                             EmpathyStatusPresetDialog *self)
 489 {
 490         if (!gtk_widget_has_focus (widget)) {
 491                 /* if the widget isn't focused, focus it and select the text */
 492                 gtk_widget_grab_focus (widget);
 493                 gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1);
 494
 495                 return TRUE;
 496         }
 497
 498         return FALSE;
 499 }
 500
 501 static gboolean
 502 status_preset_dialog_add_combo_focus_out (GtkWidget *widget,
 503                                           GdkEventFocus *event,
 504                                           EmpathyStatusPresetDialog *self)
 505 {
 506         EmpathyStatusPresetDialogPriv *priv = GET_PRIV (self);
 507         const char *status;
 508
 509         gtk_editable_set_position (GTK_EDITABLE (widget), 0);
 510
 511         status = gtk_entry_get_text (GTK_ENTRY (widget));
 512         status_preset_dialog_set_add_combo_changed (self,
 513                         priv->add_combo_changed && strlen (status) > 0,
 514                         TRUE);
 515
 516         return FALSE;
 517 }
 518
 519 static void
 520 empathy_status_preset_dialog_init (EmpathyStatusPresetDialog *self)
 521 {
 522         EmpathyStatusPresetDialogPriv *priv = self->priv =
 523                 G_TYPE_INSTANCE_GET_PRIVATE (self,
 524                         EMPATHY_TYPE_STATUS_PRESET_DIALOG,
 525                         EmpathyStatusPresetDialogPriv);
 526         GtkBuilder *gui;
 527         GtkWidget *toplevel_vbox, *remove_button, *entry;
 528         GtkTreeSelection *selection;
 529         char *filename;
 530
 531         gtk_window_set_title (GTK_WINDOW (self),
 532                         _("Edit Custom Messages"));
 533         gtk_dialog_add_button (GTK_DIALOG (self),
 534                         GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
 535         gtk_window_set_resizable (GTK_WINDOW (self), FALSE);
 536
 537         filename = empathy_file_lookup ("empathy-status-preset-dialog.ui",
 538                         "libempathy-gtk");
 539         gui = empathy_builder_get_file (filename,
 540                         "toplevel-vbox", &toplevel_vbox,
 541                         "presets-treeview", &priv->presets_treeview,
 542                         "remove-button", &remove_button,
 543                         "add-combobox", &priv->add_combobox,
 544                         "add-button", &priv->add_button,
 545                         NULL);
 546         g_free (filename);
 547
 548         selection = gtk_tree_view_get_selection (
 549                 GTK_TREE_VIEW (priv->presets_treeview));
 550         g_signal_connect (selection,
 551                         "changed",
 552                         G_CALLBACK (status_preset_dialog_preset_selection_changed),
 553                         remove_button);
 554         gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
 555
 556         entry = gtk_bin_get_child (GTK_BIN (priv->add_combobox));
 557         g_signal_connect (entry, "activate",
 558                         G_CALLBACK (status_preset_dialog_add_preset), self);
 559         g_signal_connect (entry, "button-press-event",
 560                         G_CALLBACK (status_preset_dialog_add_combo_press_event),
 561                         self);
 562         g_signal_connect (entry, "focus-out-event",
 563                         G_CALLBACK (status_preset_dialog_add_combo_focus_out),
 564                         self);
 565
 566         empathy_builder_connect (gui, self,
 567                         "remove-button", "clicked", status_preset_dialog_preset_remove,
 568                         "add-combobox", "changed", status_preset_dialog_add_combo_changed,
 569                         "add-button", "clicked", status_preset_dialog_add_preset,
 570                         NULL);
 571
 572         status_preset_dialog_setup_presets_treeview (self);
 573         status_preset_dialog_setup_add_combobox (self);
 574
 575         gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))),
 576             toplevel_vbox, TRUE, TRUE, 0);
 577
 578         g_object_unref (gui);
 579 }
 580
 581 /**
 582  * empathy_status_preset_dialog_new:
 583  * @parent: the parent window of this dialog (or NULL)
 584  *
 585  * Creates a new #EmpathyStatusPresetDialog that allows the user to
 586  * add/remove/edit their saved status messages.
 587  *
 588  * Returns: the newly constructed dialog.
 589  */
 590 GtkWidget *
 591 empathy_status_preset_dialog_new (GtkWindow *parent)
 592 {
 593         GtkWidget *self = g_object_new (EMPATHY_TYPE_STATUS_PRESET_DIALOG,
 594                         NULL);
 595
 596         if (parent) {
 597                 gtk_window_set_transient_for (GTK_WINDOW (self), parent);
 598         }
 599
 600         return self;
 601 }