pidgin/gtksmiley-manager.c

   1 /*
   2  * pidgin
   3  *
   4  * Pidgin is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
  21  */
  22
  23 #include "internal.h"
  24
  25 #include "debug.h"
  26 #include "http.h"
  27 #include "notify.h"
  28 #include "smiley.h"
  29 #include "smiley-custom.h"
  30 #include "smiley-list.h"
  31
  32 #include "gtksmiley-manager.h"
  33 #include "gtkutils.h"
  34 #include "pidginstock.h"
  35
  36 #include "gtk3compat.h"
  37
  38 typedef struct
  39 {
  40         PurpleSmiley *smiley;
  41
  42         gchar *filename;
  43         PurpleImage *new_image;
  44
  45         GtkDialog *window;
  46         GtkImage *thumbnail;
  47         GtkEntry *shortcut;
  48 } SmileyEditDialog;
  49
  50 typedef struct
  51 {
  52         GtkDialog *window;
  53         GtkListStore *model;
  54         GtkTreeView *tree;
  55
  56         PurpleHttpConnection *running_request;
  57 } SmileyManager;
  58
  59 enum
  60 {
  61         SMILEY_LIST_MODEL_ICON,
  62         SMILEY_LIST_MODEL_SHORTCUT,
  63         SMILEY_LIST_MODEL_PURPLESMILEY,
  64         SMILEY_LIST_MODEL_N_COL
  65 };
  66
  67 enum
  68 {
  69         PIDGIN_RESPONSE_MODIFY
  70 };
  71
  72 static SmileyManager *smiley_manager = NULL;
  73
  74 static void
  75 edit_dialog_update_buttons(SmileyEditDialog *edit_dialog);
  76
  77 static void
  78 manager_list_fill(SmileyManager *manager);
  79
  80
  81 /*******************************************************************************
  82  * Custom smiley edit dialog image.
  83  ******************************************************************************/
  84
  85 static void
  86 edit_dialog_image_update_thumb(SmileyEditDialog *edit_dialog)
  87 {
  88         GdkPixbuf *pixbuf = NULL;
  89
  90         if (edit_dialog->new_image) {
  91                 pixbuf = pidgin_pixbuf_from_image(edit_dialog->new_image);
  92         } else if (edit_dialog->filename) {
  93                 pixbuf = pidgin_pixbuf_new_from_file(edit_dialog->filename);
  94                 if (!pixbuf) {
  95                         g_free(edit_dialog->filename);
  96                         edit_dialog->filename = NULL;
  97                 }
  98         }
  99
 100         if (pixbuf) {
 101                 pixbuf = pidgin_pixbuf_scale_down(pixbuf, 64, 64,
 102                         GDK_INTERP_HYPER, TRUE);
 103         }
 104
 105         if (!pixbuf) {
 106                 GtkIconSize icon_size =
 107                         gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL);
 108                 pixbuf = gtk_widget_render_icon(GTK_WIDGET(edit_dialog->window),
 109                         PIDGIN_STOCK_TOOLBAR_SELECT_AVATAR, icon_size,
 110                         "PidginSmileyManager");
 111         }
 112         g_return_if_fail(pixbuf != NULL);
 113
 114         gtk_image_set_from_pixbuf(GTK_IMAGE(edit_dialog->thumbnail), pixbuf);
 115
 116         g_object_unref(G_OBJECT(pixbuf));
 117 }
 118
 119 static gboolean
 120 edit_dialog_set_image(SmileyEditDialog *edit_dialog, PurpleImage *image)
 121 {
 122         GdkPixbuf *tmp = NULL;
 123
 124         if (edit_dialog->new_image)
 125                 g_object_unref(edit_dialog->new_image);
 126
 127         if (edit_dialog->smiley) {
 128                 g_object_set_data(G_OBJECT(edit_dialog->smiley),
 129                         "pidgin-smiley-manager-list-thumb", NULL);
 130         }
 131
 132         /* check, if image is valid */
 133         if (image)
 134                 tmp = pidgin_pixbuf_from_image(image);
 135         if (tmp)
 136                 g_object_unref(tmp);
 137         else {
 138                 g_object_unref(image);
 139                 image = NULL;
 140         }
 141
 142         edit_dialog->new_image = image;
 143
 144         edit_dialog_image_update_thumb(edit_dialog);
 145         edit_dialog_update_buttons(edit_dialog);
 146
 147         return (image != NULL);
 148 }
 149
 150 static void
 151 edit_dialog_set_shortcut(SmileyEditDialog *edit_dialog,
 152         const gchar *shortcut)
 153 {
 154         gtk_entry_set_text(edit_dialog->shortcut, shortcut ? shortcut : "");
 155 }
 156
 157 static void
 158 edit_dialog_image_choosen(const char *filename, gpointer _edit_dialog)
 159 {
 160         PurpleImage *image;
 161         SmileyEditDialog *edit_dialog = _edit_dialog;
 162
 163         if (!filename)
 164                 return;
 165
 166         image = purple_image_new_from_file(filename, NULL);
 167         if (!image)
 168                 return;
 169
 170         g_free(edit_dialog->filename);
 171         edit_dialog->filename = NULL;
 172
 173         if (!edit_dialog_set_image(edit_dialog, image))
 174                 return;
 175         edit_dialog->filename = g_strdup(filename);
 176
 177         gtk_widget_grab_focus(GTK_WIDGET(edit_dialog->shortcut));
 178 }
 179
 180 static void
 181 edit_dialog_image_choose(GtkWidget *widget, gpointer _edit_dialog)
 182 {
 183         GtkFileChooserNative *file_chooser;
 184         file_chooser = pidgin_buddy_icon_chooser_new(
 185                 GTK_WINDOW(gtk_widget_get_toplevel(widget)),
 186                 edit_dialog_image_choosen, _edit_dialog);
 187         gtk_window_set_title(GTK_WINDOW(file_chooser), _("Custom Smiley"));
 188         gtk_window_set_role(GTK_WINDOW(file_chooser),
 189                 "file-selector-custom-smiley");
 190         gtk_native_dialog_run(GTK_NATIVE_DIALOG(file_chooser));
 191         g_object_unref(file_chooser);
 192 }
 193
 194
 195 /*******************************************************************************
 196  * Custom smiley edit dialog.
 197  ******************************************************************************/
 198
 199 static void
 200 edit_dialog_destroy(GtkWidget *window, gpointer _edit_dialog)
 201 {
 202         SmileyEditDialog *edit_dialog = _edit_dialog;
 203
 204         if (edit_dialog->smiley) {
 205                 g_object_set_data(G_OBJECT(edit_dialog->smiley),
 206                         "pidgin-smiley-manager-edit-dialog", NULL);
 207                 g_object_unref(edit_dialog->smiley);
 208         }
 209
 210         if (edit_dialog->new_image)
 211                 g_object_unref(edit_dialog->new_image);
 212
 213         g_free(edit_dialog->filename);
 214         g_free(edit_dialog);
 215 }
 216
 217 static void
 218 edit_dialog_save(SmileyEditDialog *edit_dialog)
 219 {
 220         const gchar *shortcut;
 221         PurpleSmiley *existing_smiley;
 222         gboolean shortcut_changed, image_changed;
 223
 224         shortcut = gtk_entry_get_text(edit_dialog->shortcut);
 225
 226         existing_smiley = purple_smiley_list_get_by_shortcut(
 227                 purple_smiley_custom_get_list(), shortcut);
 228
 229         if (existing_smiley && existing_smiley != edit_dialog->smiley) {
 230                 gchar *msg = g_strdup_printf(
 231                         _("A custom smiley for '%s' already exists.  "
 232                         "Please use a different shortcut."), shortcut);
 233                 purple_notify_error(edit_dialog, _("Custom Smiley"),
 234                         _("Duplicate Shortcut"), msg, NULL);
 235                 g_free(msg);
 236                 return;
 237         }
 238
 239         if (edit_dialog->smiley == NULL)
 240                 shortcut_changed = image_changed = TRUE;
 241         else {
 242                 shortcut_changed = purple_strequal(purple_smiley_get_shortcut(
 243                         edit_dialog->smiley), shortcut);
 244                 image_changed = (edit_dialog->new_image != NULL);
 245         }
 246
 247         if (!shortcut_changed && !image_changed) {
 248                 gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 249                 return;
 250         }
 251
 252         if (edit_dialog->new_image == NULL) {
 253                 edit_dialog->new_image = PURPLE_IMAGE(edit_dialog->smiley);
 254                 g_return_if_fail(edit_dialog->new_image);
 255         }
 256
 257         if (edit_dialog->smiley)
 258                 purple_smiley_custom_remove(edit_dialog->smiley);
 259         purple_smiley_custom_add(edit_dialog->new_image, shortcut);
 260
 261         if (smiley_manager)
 262                 manager_list_fill(smiley_manager);
 263
 264         gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 265 }
 266
 267 static void
 268 edit_dialog_update_buttons(SmileyEditDialog *edit_dialog)
 269 {
 270         gboolean shortcut_ok, image_ok;
 271
 272         shortcut_ok = (gtk_entry_get_text_length(edit_dialog->shortcut) > 0);
 273         image_ok = (edit_dialog->filename || edit_dialog->new_image);
 274
 275         gtk_dialog_set_response_sensitive(edit_dialog->window,
 276                 GTK_RESPONSE_ACCEPT, shortcut_ok && image_ok);
 277 }
 278
 279 static void
 280 edit_dialog_shortcut_changed(GtkEditable *shortcut, gpointer _edit_dialog)
 281 {
 282         SmileyEditDialog *edit_dialog = _edit_dialog;
 283
 284         edit_dialog_update_buttons(edit_dialog);
 285 }
 286
 287 static void
 288 edit_dialog_response(GtkDialog *window, gint response_id,
 289         gpointer _edit_dialog)
 290 {
 291         SmileyEditDialog *edit_dialog = _edit_dialog;
 292
 293         switch (response_id) {
 294                 case GTK_RESPONSE_ACCEPT:
 295                         edit_dialog_save(edit_dialog);
 296                         break;
 297                 case GTK_RESPONSE_DELETE_EVENT:
 298                 case GTK_RESPONSE_CANCEL:
 299                         gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 300                         break;
 301                 default:
 302                         g_warn_if_reached();
 303         }
 304 }
 305
 306 static SmileyEditDialog *
 307 edit_dialog_show(SmileyManager *manager, PurpleSmiley *smiley)
 308 {
 309         SmileyEditDialog *edit_dialog;
 310         GtkWidget *vbox, *hbox;
 311         GtkLabel *label;
 312         GtkButton *filech;
 313
 314         if (smiley) {
 315                 edit_dialog = g_object_get_data(G_OBJECT(smiley),
 316                         "pidgin-smiley-manager-edit-dialog");
 317                 if (edit_dialog) {
 318                         gtk_window_present(GTK_WINDOW(edit_dialog->window));
 319                         return edit_dialog;
 320                 }
 321         }
 322
 323         edit_dialog = g_new0(SmileyEditDialog, 1);
 324
 325         edit_dialog->window = GTK_DIALOG(gtk_dialog_new_with_buttons(
 326                 smiley ? _("Edit Smiley") : _("Add Smiley"),
 327                 manager ? GTK_WINDOW(manager->window) : NULL,
 328                 GTK_DIALOG_DESTROY_WITH_PARENT,
 329                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 330                 smiley ? GTK_STOCK_SAVE : GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT,
 331                 NULL));
 332         gtk_dialog_set_default_response(
 333                 edit_dialog->window, GTK_RESPONSE_ACCEPT);
 334
 335         if (smiley) {
 336                 edit_dialog->smiley = smiley;
 337                 g_object_set_data(G_OBJECT(smiley),
 338                         "pidgin-smiley-manager-edit-dialog", edit_dialog);
 339                 g_object_ref(smiley);
 340         }
 341
 342
 343         /* The vbox */
 344         vbox = gtk_grid_new();
 345         gtk_grid_set_row_spacing(GTK_GRID(vbox), PIDGIN_HIG_BORDER);
 346         gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(
 347                 edit_dialog->window)), vbox);
 348         gtk_widget_show(vbox);
 349
 350         /* The hbox */
 351         hbox = gtk_grid_new();
 352         gtk_grid_set_column_spacing(GTK_GRID(hbox), PIDGIN_HIG_BORDER);
 353         gtk_grid_attach(GTK_GRID(vbox), hbox, 0, 0, 1, 1);
 354
 355         label = GTK_LABEL(gtk_label_new_with_mnemonic(_("_Image:")));
 356         gtk_grid_attach(GTK_GRID(hbox), GTK_WIDGET(label), 0, 0, 1, 1);
 357         gtk_widget_show(GTK_WIDGET(label));
 358
 359         filech = GTK_BUTTON(gtk_button_new());
 360         gtk_grid_attach_next_to(GTK_GRID(hbox), GTK_WIDGET(filech), NULL,
 361                 GTK_POS_RIGHT, 1, 1);
 362         pidgin_set_accessible_label(GTK_WIDGET(filech), label);
 363
 364         edit_dialog->thumbnail = GTK_IMAGE(gtk_image_new());
 365         gtk_container_add(GTK_CONTAINER(filech),
 366                 GTK_WIDGET(edit_dialog->thumbnail));
 367
 368         gtk_widget_show_all(hbox);
 369
 370         /* info */
 371         hbox = gtk_grid_new();
 372         gtk_grid_set_column_spacing(GTK_GRID(hbox), PIDGIN_HIG_BORDER);
 373
 374         gtk_grid_attach_next_to(GTK_GRID(vbox), hbox, NULL,
 375                 GTK_POS_BOTTOM, 1, 1);
 376
 377         /* Shortcut text */
 378         label = GTK_LABEL(gtk_label_new_with_mnemonic(_("S_hortcut text:")));
 379         gtk_grid_attach(GTK_GRID(hbox), GTK_WIDGET(label), 0, 0, 1, 1);
 380         gtk_widget_show(GTK_WIDGET(label));
 381
 382         edit_dialog->shortcut = GTK_ENTRY(gtk_entry_new());
 383         gtk_entry_set_activates_default(edit_dialog->shortcut, TRUE);
 384         pidgin_set_accessible_label(GTK_WIDGET(edit_dialog->shortcut), label);
 385
 386         gtk_grid_attach_next_to(GTK_GRID(hbox),
 387                 GTK_WIDGET(edit_dialog->shortcut), NULL, GTK_POS_RIGHT, 1, 1);
 388
 389         gtk_widget_show(GTK_WIDGET(edit_dialog->shortcut));
 390         gtk_widget_show(hbox);
 391         gtk_widget_show(GTK_WIDGET(edit_dialog->window));
 392
 393         if (smiley) {
 394                 edit_dialog->filename = g_strdup(purple_image_get_path(
 395                         PURPLE_IMAGE(smiley)));
 396                 gtk_entry_set_text(edit_dialog->shortcut,
 397                         purple_smiley_get_shortcut(smiley));
 398         }
 399
 400         edit_dialog_image_update_thumb(edit_dialog);
 401         edit_dialog_update_buttons(edit_dialog);
 402
 403         g_signal_connect(edit_dialog->window, "response",
 404                 G_CALLBACK(edit_dialog_response), edit_dialog);
 405         g_signal_connect(filech, "clicked",
 406                 G_CALLBACK(edit_dialog_image_choose), edit_dialog);
 407         g_signal_connect(edit_dialog->shortcut, "changed",
 408                 G_CALLBACK(edit_dialog_shortcut_changed), edit_dialog);
 409
 410         g_signal_connect(edit_dialog->window, "destroy",
 411                 G_CALLBACK(edit_dialog_destroy), edit_dialog);
 412         g_signal_connect(edit_dialog->window, "destroy",
 413                 G_CALLBACK(purple_notify_close_with_handle), edit_dialog);
 414
 415         return edit_dialog;
 416 }
 417
 418 void
 419 pidgin_smiley_manager_add(PurpleImage *image, const gchar *shortcut)
 420 {
 421         SmileyEditDialog *edit_dialog;
 422
 423         g_return_if_fail(image != NULL);
 424
 425         g_object_ref(image);
 426
 427         edit_dialog = edit_dialog_show(NULL, NULL);
 428         edit_dialog_set_shortcut(edit_dialog, shortcut);
 429         if (!edit_dialog_set_image(edit_dialog, image))
 430                 gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 431 }
 432
 433
 434 /*******************************************************************************
 435  * Custom smiley list Drag-and-drop support.
 436  ******************************************************************************/
 437
 438 static void
 439 smiley_list_dnd_url_got(PurpleHttpConnection *http_conn,
 440         PurpleHttpResponse *response, gpointer _manager)
 441 {
 442         SmileyManager *manager = _manager;
 443         SmileyEditDialog *edit_dialog;
 444         PurpleImage *image;
 445         const gchar *image_data;
 446         size_t image_size;
 447
 448         g_return_if_fail(manager == smiley_manager);
 449         g_return_if_fail(manager->running_request == http_conn);
 450         manager->running_request = NULL;
 451
 452         if (!purple_http_response_is_successful(response))
 453                 return;
 454
 455         image_data = purple_http_response_get_data(response, &image_size);
 456         image = purple_image_new_from_data((const guint8 *)image_data, image_size);
 457         if (!image)
 458                 return;
 459
 460         edit_dialog = edit_dialog_show(manager, NULL);
 461         if (!edit_dialog_set_image(edit_dialog, image))
 462                 gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 463 }
 464
 465 static void
 466 smiley_list_dnd_recv(GtkWidget *widget, GdkDragContext *dc, gint x, gint y,
 467         GtkSelectionData *sd, guint info, guint time, gpointer _manager)
 468 {
 469         SmileyManager *manager = _manager;
 470         gchar content[1024];
 471
 472         /* We don't need anything, that is not 8-bit per element (char). */
 473         if (gtk_selection_data_get_format(sd) != 8) {
 474                 gtk_drag_finish(dc, FALSE, FALSE, time);
 475                 return;
 476         }
 477
 478         if (gtk_selection_data_get_length(sd) <= 0) {
 479                 gtk_drag_finish(dc, FALSE, FALSE, time);
 480                 return;
 481         }
 482
 483         memset(&content, 0, sizeof(content));
 484         memcpy(&content, gtk_selection_data_get_data(sd),
 485                 MIN((guint)gtk_selection_data_get_length(sd), sizeof(content)));
 486         g_strstrip(content);
 487         if (content[0] == '\0') {
 488                 gtk_drag_finish(dc, FALSE, FALSE, time);
 489                 return;
 490         }
 491
 492         /* Well, it looks like the drag event was cool.
 493          * Let's do something with it */
 494
 495         if (purple_str_has_caseprefix(content, "file://")) {
 496                 SmileyEditDialog *edit_dialog;
 497                 PurpleImage *image;
 498                 gchar *filename;
 499
 500                 filename = g_filename_from_uri(content, NULL, NULL);
 501                 if (!filename || !g_file_test(filename, G_FILE_TEST_EXISTS)) {
 502                         purple_debug_warning("gtksmiley-manager",
 503                                 "dropped file does not exists");
 504                         gtk_drag_finish(dc, FALSE, FALSE, time);
 505                         return;
 506                 }
 507
 508                 image = purple_image_new_from_file(filename, NULL);
 509                 if (!image) {
 510                         purple_debug_warning("gtksmiley-manager",
 511                                 "dropped file is not a valid image");
 512                         gtk_drag_finish(dc, FALSE, FALSE, time);
 513                         return;
 514                 }
 515                 edit_dialog = edit_dialog_show(manager, NULL);
 516                 if (!edit_dialog_set_image(edit_dialog, image)) {
 517                         gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 518                         gtk_drag_finish(dc, FALSE, FALSE, time);
 519                         return;
 520                 }
 521
 522                 gtk_drag_finish(dc, TRUE, FALSE, time);
 523                 return;
 524         }
 525
 526         if (purple_str_has_caseprefix(content, "http://") ||
 527                 purple_str_has_caseprefix(content, "https://"))
 528         {
 529                 purple_http_conn_cancel(smiley_manager->
 530                         running_request);
 531                 smiley_manager->running_request = purple_http_get(NULL,
 532                         smiley_list_dnd_url_got, manager, content);
 533
 534                 gtk_drag_finish(dc, TRUE, FALSE, time);
 535                 return;
 536         }
 537
 538         gtk_drag_finish(dc, FALSE, FALSE, time);
 539 }
 540
 541 /*******************************************************************************
 542  * Custom smiley list.
 543  ******************************************************************************/
 544
 545 static void
 546 smiley_list_selected(GtkTreeSelection *sel, gpointer _manager)
 547 {
 548         SmileyManager *manager = _manager;
 549         gboolean sens;
 550
 551         sens = (gtk_tree_selection_count_selected_rows(sel) > 0);
 552
 553         gtk_dialog_set_response_sensitive(manager->window,
 554                 GTK_RESPONSE_NO, sens);
 555         gtk_dialog_set_response_sensitive(manager->window,
 556                 PIDGIN_RESPONSE_MODIFY, sens);
 557 }
 558
 559 static void
 560 smiley_list_activated(GtkTreeView *tree, GtkTreePath *path,
 561         GtkTreeViewColumn *col, gpointer _manager)
 562 {
 563         SmileyManager *manager = _manager;
 564         GtkTreeIter iter;
 565         PurpleSmiley *smiley = NULL;
 566
 567         if (!gtk_tree_model_get_iter(
 568                 GTK_TREE_MODEL(manager->model), &iter, path))
 569         {
 570                 return;
 571         }
 572
 573         gtk_tree_model_get(GTK_TREE_MODEL(manager->model), &iter,
 574                 SMILEY_LIST_MODEL_PURPLESMILEY, &smiley, -1);
 575         g_return_if_fail(PURPLE_IS_SMILEY(smiley));
 576
 577         edit_dialog_show(manager, smiley);
 578 }
 579
 580 static void
 581 manager_list_add(SmileyManager *manager, PurpleSmiley *smiley)
 582 {
 583         GdkPixbuf *smiley_image;
 584         GtkTreeIter iter;
 585
 586         smiley_image = g_object_get_data(G_OBJECT(smiley),
 587                 "pidgin-smiley-manager-list-thumb");
 588         if (smiley_image == NULL) {
 589                 smiley_image = pidgin_pixbuf_from_image(PURPLE_IMAGE(smiley));
 590                 smiley_image = pidgin_pixbuf_scale_down(smiley_image,
 591                         22, 22, GDK_INTERP_BILINEAR, TRUE);
 592                 g_object_set_data_full(G_OBJECT(smiley),
 593                         "pidgin-smiley-manager-list-thumb",
 594                         smiley_image, g_object_unref);
 595         }
 596
 597         gtk_list_store_append(manager->model, &iter);
 598         gtk_list_store_set(manager->model, &iter,
 599                 SMILEY_LIST_MODEL_ICON, smiley_image,
 600                 SMILEY_LIST_MODEL_SHORTCUT, purple_smiley_get_shortcut(smiley),
 601                 SMILEY_LIST_MODEL_PURPLESMILEY, smiley,
 602                 -1);
 603 }
 604
 605 static void
 606 manager_list_fill(SmileyManager *manager)
 607 {
 608         GList *custom_smileys, *it;
 609         gtk_list_store_clear(manager->model);
 610
 611         custom_smileys = purple_smiley_list_get_all(
 612                 purple_smiley_custom_get_list());
 613
 614         for (it = custom_smileys; it; it = g_list_next(it)) {
 615                 PurpleSmiley *smiley = it->data;
 616
 617                 manager_list_add(manager, smiley);
 618         }
 619         g_list_free(custom_smileys);
 620 }
 621
 622 static GtkWidget *
 623 manager_list_create(SmileyManager *manager)
 624 {
 625         GtkTreeView *tree;
 626         GtkTreeSelection *sel;
 627         GtkCellRenderer *cellrend;
 628         GtkTreeViewColumn *column;
 629         GtkTargetEntry targets[3] = {
 630                 {"text/plain", 0, 0},
 631                 {"text/uri-list", 0, 1},
 632                 {"STRING", 0, 2}
 633         };
 634
 635         manager->model = gtk_list_store_new(SMILEY_LIST_MODEL_N_COL,
 636                 GDK_TYPE_PIXBUF, /* icon */
 637                 G_TYPE_STRING, /* shortcut */
 638                 G_TYPE_OBJECT /* PurpleSmiley */
 639                 );
 640
 641         manager->tree = tree = GTK_TREE_VIEW(gtk_tree_view_new_with_model(
 642                 GTK_TREE_MODEL(manager->model)));
 643
 644         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(manager->model),
 645                 SMILEY_LIST_MODEL_SHORTCUT, GTK_SORT_ASCENDING);
 646
 647         g_object_unref(manager->model);
 648
 649         sel = gtk_tree_view_get_selection(tree);
 650         gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
 651
 652         g_signal_connect(sel, "changed",
 653                 G_CALLBACK(smiley_list_selected), manager);
 654         g_signal_connect(tree, "row-activated",
 655                 G_CALLBACK(smiley_list_activated), manager);
 656
 657         gtk_drag_dest_set(GTK_WIDGET(tree), GTK_DEST_DEFAULT_MOTION |
 658                 GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
 659                 targets, G_N_ELEMENTS(targets),
 660                 GDK_ACTION_COPY | GDK_ACTION_MOVE);
 661         g_signal_connect(tree, "drag-data-received",
 662                 G_CALLBACK(smiley_list_dnd_recv), manager);
 663
 664         gtk_widget_show(GTK_WIDGET(tree));
 665
 666         /* setting up columns */
 667
 668         column = gtk_tree_view_column_new();
 669         gtk_tree_view_column_set_title(column, _("Smiley"));
 670         gtk_tree_view_column_set_resizable(column, TRUE);
 671         gtk_tree_view_append_column(tree, column);
 672         cellrend = gtk_cell_renderer_pixbuf_new();
 673         gtk_tree_view_column_pack_start(column, cellrend, FALSE);
 674         gtk_tree_view_column_add_attribute(column, cellrend,
 675                 "pixbuf", SMILEY_LIST_MODEL_ICON);
 676
 677         column = gtk_tree_view_column_new();
 678         gtk_tree_view_column_set_title(column, _("Shortcut Text"));
 679         gtk_tree_view_column_set_resizable(column, TRUE);
 680         gtk_tree_view_append_column(tree, column);
 681         cellrend = gtk_cell_renderer_text_new();
 682         gtk_tree_view_column_pack_start(column, cellrend, TRUE);
 683         gtk_tree_view_column_add_attribute(column, cellrend,
 684                 "text", SMILEY_LIST_MODEL_SHORTCUT);
 685
 686         manager_list_fill(manager);
 687
 688         return pidgin_make_scrollable(GTK_WIDGET(tree), GTK_POLICY_AUTOMATIC,
 689                 GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, -1);
 690 }
 691
 692 /*******************************************************************************
 693  * Custom smiley manager window.
 694  ******************************************************************************/
 695
 696 static void
 697 manager_select_cb(GtkWidget *widget, gint resp, SmileyManager *manager)
 698 {
 699         GtkTreeSelection *selection = NULL;
 700         GList *selected_rows, *selected_smileys = NULL, *it;
 701         GtkTreeModel *model = GTK_TREE_MODEL(manager->model);
 702
 703         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(manager->tree));
 704         selected_rows = gtk_tree_selection_get_selected_rows(selection, NULL);
 705         for (it = selected_rows; it; it = g_list_next(it)) {
 706                 GtkTreePath *path = it->data;
 707                 GtkTreeIter iter;
 708                 PurpleSmiley *smiley = NULL;
 709
 710                 if (!gtk_tree_model_get_iter(model, &iter, path))
 711                         continue;
 712
 713                 gtk_tree_model_get(model, &iter,
 714                         SMILEY_LIST_MODEL_PURPLESMILEY, &smiley, -1);
 715                 if (!smiley)
 716                         continue;
 717
 718                 selected_smileys = g_list_prepend(selected_smileys, smiley);
 719         }
 720         g_list_free_full(selected_rows, (GDestroyNotify)gtk_tree_path_free);
 721
 722         switch (resp) {
 723                 case GTK_RESPONSE_YES:
 724                         edit_dialog_show(manager, NULL);
 725                         break;
 726                 case GTK_RESPONSE_NO:
 727                         for (it = selected_smileys; it; it = g_list_next(it))
 728                                 purple_smiley_custom_remove(it->data);
 729                         manager_list_fill(manager);
 730                         break;
 731                 case GTK_RESPONSE_DELETE_EVENT:
 732                 case GTK_RESPONSE_CLOSE:
 733                         gtk_widget_destroy(GTK_WIDGET(manager->window));
 734                         purple_http_conn_cancel(manager->running_request);
 735                         g_free(manager);
 736                         smiley_manager = NULL;
 737                         break;
 738                 case PIDGIN_RESPONSE_MODIFY:
 739                         for (it = selected_smileys; it; it = g_list_next(it))
 740                                 edit_dialog_show(manager, it->data);
 741                         break;
 742                 default:
 743                         g_warn_if_reached();
 744         }
 745
 746         g_list_free(selected_smileys);
 747 }
 748
 749 void
 750 pidgin_smiley_manager_show(void)
 751 {
 752         SmileyManager *manager;
 753         GtkDialog *win;
 754         GtkWidget *sw, *vbox;
 755
 756         if (smiley_manager) {
 757                 gtk_window_present(GTK_WINDOW(smiley_manager->window));
 758                 return;
 759         }
 760
 761         manager = g_new0(SmileyManager, 1);
 762         smiley_manager = manager;
 763
 764         manager->window = win = GTK_DIALOG(gtk_dialog_new_with_buttons(
 765                 _("Custom Smiley Manager"), NULL,
 766                 GTK_DIALOG_DESTROY_WITH_PARENT,
 767                 PIDGIN_STOCK_ADD, GTK_RESPONSE_YES,
 768                 PIDGIN_STOCK_MODIFY, PIDGIN_RESPONSE_MODIFY,
 769                 GTK_STOCK_DELETE, GTK_RESPONSE_NO,
 770                 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
 771                 NULL));
 772
 773         gtk_window_set_default_size(GTK_WINDOW(win), 50, 400);
 774         gtk_window_set_role(GTK_WINDOW(win), "custom_smiley_manager");
 775         gtk_dialog_set_response_sensitive(win, GTK_RESPONSE_NO, FALSE);
 776         gtk_dialog_set_response_sensitive(win, PIDGIN_RESPONSE_MODIFY, FALSE);
 777
 778         g_signal_connect(win, "response",
 779                 G_CALLBACK(manager_select_cb), manager);
 780
 781         /* The vbox */
 782         vbox = gtk_dialog_get_content_area(win);
 783
 784         /* get the scrolled window with all stuff */
 785         sw = manager_list_create(manager);
 786         gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
 787         gtk_widget_show(sw);
 788
 789         gtk_widget_show(GTK_WIDGET(win));
 790 }