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         GtkWidget *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_widget_show_all(file_chooser);
 191 }
 192
 193
 194 /*******************************************************************************
 195  * Custom smiley edit dialog.
 196  ******************************************************************************/
 197
 198 static void
 199 edit_dialog_destroy(GtkWidget *window, gpointer _edit_dialog)
 200 {
 201         SmileyEditDialog *edit_dialog = _edit_dialog;
 202
 203         if (edit_dialog->smiley) {
 204                 g_object_set_data(G_OBJECT(edit_dialog->smiley),
 205                         "pidgin-smiley-manager-edit-dialog", NULL);
 206                 g_object_unref(edit_dialog->smiley);
 207         }
 208
 209         if (edit_dialog->new_image)
 210                 g_object_unref(edit_dialog->new_image);
 211
 212         g_free(edit_dialog->filename);
 213         g_free(edit_dialog);
 214 }
 215
 216 static void
 217 edit_dialog_save(SmileyEditDialog *edit_dialog)
 218 {
 219         const gchar *shortcut;
 220         PurpleSmiley *existing_smiley;
 221         gboolean shortcut_changed, image_changed;
 222
 223         shortcut = gtk_entry_get_text(edit_dialog->shortcut);
 224
 225         existing_smiley = purple_smiley_list_get_by_shortcut(
 226                 purple_smiley_custom_get_list(), shortcut);
 227
 228         if (existing_smiley && existing_smiley != edit_dialog->smiley) {
 229                 gchar *msg = g_strdup_printf(
 230                         _("A custom smiley for '%s' already exists.  "
 231                         "Please use a different shortcut."), shortcut);
 232                 purple_notify_error(edit_dialog, _("Custom Smiley"),
 233                         _("Duplicate Shortcut"), msg, NULL);
 234                 g_free(msg);
 235                 return;
 236         }
 237
 238         if (edit_dialog->smiley == NULL)
 239                 shortcut_changed = image_changed = TRUE;
 240         else {
 241                 shortcut_changed = purple_strequal(purple_smiley_get_shortcut(
 242                         edit_dialog->smiley), shortcut);
 243                 image_changed = (edit_dialog->new_image != NULL);
 244         }
 245
 246         if (!shortcut_changed && !image_changed) {
 247                 gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 248                 return;
 249         }
 250
 251         if (edit_dialog->new_image == NULL) {
 252                 edit_dialog->new_image = PURPLE_IMAGE(edit_dialog->smiley);
 253                 g_return_if_fail(edit_dialog->new_image);
 254         }
 255
 256         if (edit_dialog->smiley)
 257                 purple_smiley_custom_remove(edit_dialog->smiley);
 258         purple_smiley_custom_add(edit_dialog->new_image, shortcut);
 259
 260         if (smiley_manager)
 261                 manager_list_fill(smiley_manager);
 262
 263         gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 264 }
 265
 266 static void
 267 edit_dialog_update_buttons(SmileyEditDialog *edit_dialog)
 268 {
 269         gboolean shortcut_ok, image_ok;
 270
 271         shortcut_ok = (gtk_entry_get_text_length(edit_dialog->shortcut) > 0);
 272         image_ok = (edit_dialog->filename || edit_dialog->new_image);
 273
 274         gtk_dialog_set_response_sensitive(edit_dialog->window,
 275                 GTK_RESPONSE_ACCEPT, shortcut_ok && image_ok);
 276 }
 277
 278 static void
 279 edit_dialog_shortcut_changed(GtkEditable *shortcut, gpointer _edit_dialog)
 280 {
 281         SmileyEditDialog *edit_dialog = _edit_dialog;
 282
 283         edit_dialog_update_buttons(edit_dialog);
 284 }
 285
 286 static void
 287 edit_dialog_response(GtkDialog *window, gint response_id,
 288         gpointer _edit_dialog)
 289 {
 290         SmileyEditDialog *edit_dialog = _edit_dialog;
 291
 292         switch (response_id) {
 293                 case GTK_RESPONSE_ACCEPT:
 294                         edit_dialog_save(edit_dialog);
 295                         break;
 296                 case GTK_RESPONSE_DELETE_EVENT:
 297                 case GTK_RESPONSE_CANCEL:
 298                         gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 299                         break;
 300                 default:
 301                         g_warn_if_reached();
 302         }
 303 }
 304
 305 static SmileyEditDialog *
 306 edit_dialog_show(SmileyManager *manager, PurpleSmiley *smiley)
 307 {
 308         SmileyEditDialog *edit_dialog;
 309         GtkWidget *vbox, *hbox;
 310         GtkLabel *label;
 311         GtkButton *filech;
 312
 313         if (smiley) {
 314                 edit_dialog = g_object_get_data(G_OBJECT(smiley),
 315                         "pidgin-smiley-manager-edit-dialog");
 316                 if (edit_dialog) {
 317                         gtk_window_present(GTK_WINDOW(edit_dialog->window));
 318                         return edit_dialog;
 319                 }
 320         }
 321
 322         edit_dialog = g_new0(SmileyEditDialog, 1);
 323
 324         edit_dialog->window = GTK_DIALOG(gtk_dialog_new_with_buttons(
 325                 smiley ? _("Edit Smiley") : _("Add Smiley"),
 326                 manager ? GTK_WINDOW(manager->window) : NULL,
 327                 GTK_DIALOG_DESTROY_WITH_PARENT,
 328                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 329                 smiley ? GTK_STOCK_SAVE : GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT,
 330                 NULL));
 331         gtk_dialog_set_default_response(
 332                 edit_dialog->window, GTK_RESPONSE_ACCEPT);
 333
 334         if (smiley) {
 335                 edit_dialog->smiley = smiley;
 336                 g_object_set_data(G_OBJECT(smiley),
 337                         "pidgin-smiley-manager-edit-dialog", edit_dialog);
 338                 g_object_ref(smiley);
 339         }
 340
 341
 342         /* The vbox */
 343         vbox = gtk_grid_new();
 344         gtk_grid_set_row_spacing(GTK_GRID(vbox), PIDGIN_HIG_BORDER);
 345         gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(
 346                 edit_dialog->window)), vbox);
 347         gtk_widget_show(vbox);
 348
 349         /* The hbox */
 350         hbox = gtk_grid_new();
 351         gtk_grid_set_column_spacing(GTK_GRID(hbox), PIDGIN_HIG_BORDER);
 352         gtk_grid_attach(GTK_GRID(vbox), hbox, 0, 0, 1, 1);
 353
 354         label = GTK_LABEL(gtk_label_new_with_mnemonic(_("_Image:")));
 355         gtk_grid_attach(GTK_GRID(hbox), GTK_WIDGET(label), 0, 0, 1, 1);
 356         gtk_widget_show(GTK_WIDGET(label));
 357
 358         filech = GTK_BUTTON(gtk_button_new());
 359         gtk_grid_attach_next_to(GTK_GRID(hbox), GTK_WIDGET(filech), NULL,
 360                 GTK_POS_RIGHT, 1, 1);
 361         pidgin_set_accessible_label(GTK_WIDGET(filech), label);
 362
 363         edit_dialog->thumbnail = GTK_IMAGE(gtk_image_new());
 364         gtk_container_add(GTK_CONTAINER(filech),
 365                 GTK_WIDGET(edit_dialog->thumbnail));
 366
 367         gtk_widget_show_all(hbox);
 368
 369         /* info */
 370         hbox = gtk_grid_new();
 371         gtk_grid_set_column_spacing(GTK_GRID(hbox), PIDGIN_HIG_BORDER);
 372
 373         gtk_grid_attach_next_to(GTK_GRID(vbox), hbox, NULL,
 374                 GTK_POS_BOTTOM, 1, 1);
 375
 376         /* Shortcut text */
 377         label = GTK_LABEL(gtk_label_new_with_mnemonic(_("S_hortcut text:")));
 378         gtk_grid_attach(GTK_GRID(hbox), GTK_WIDGET(label), 0, 0, 1, 1);
 379         gtk_widget_show(GTK_WIDGET(label));
 380
 381         edit_dialog->shortcut = GTK_ENTRY(gtk_entry_new());
 382         gtk_entry_set_activates_default(edit_dialog->shortcut, TRUE);
 383         pidgin_set_accessible_label(GTK_WIDGET(edit_dialog->shortcut), label);
 384
 385         gtk_grid_attach_next_to(GTK_GRID(hbox),
 386                 GTK_WIDGET(edit_dialog->shortcut), NULL, GTK_POS_RIGHT, 1, 1);
 387
 388         gtk_widget_show(GTK_WIDGET(edit_dialog->shortcut));
 389         gtk_widget_show(hbox);
 390         gtk_widget_show(GTK_WIDGET(edit_dialog->window));
 391
 392         if (smiley) {
 393                 edit_dialog->filename = g_strdup(purple_image_get_path(
 394                         PURPLE_IMAGE(smiley)));
 395                 gtk_entry_set_text(edit_dialog->shortcut,
 396                         purple_smiley_get_shortcut(smiley));
 397         }
 398
 399         edit_dialog_image_update_thumb(edit_dialog);
 400         edit_dialog_update_buttons(edit_dialog);
 401
 402         g_signal_connect(edit_dialog->window, "response",
 403                 G_CALLBACK(edit_dialog_response), edit_dialog);
 404         g_signal_connect(filech, "clicked",
 405                 G_CALLBACK(edit_dialog_image_choose), edit_dialog);
 406         g_signal_connect(edit_dialog->shortcut, "changed",
 407                 G_CALLBACK(edit_dialog_shortcut_changed), edit_dialog);
 408
 409         g_signal_connect(edit_dialog->window, "destroy",
 410                 G_CALLBACK(edit_dialog_destroy), edit_dialog);
 411         g_signal_connect(edit_dialog->window, "destroy",
 412                 G_CALLBACK(purple_notify_close_with_handle), edit_dialog);
 413
 414         return edit_dialog;
 415 }
 416
 417 void
 418 pidgin_smiley_manager_add(PurpleImage *image, const gchar *shortcut)
 419 {
 420         SmileyEditDialog *edit_dialog;
 421
 422         g_return_if_fail(image != NULL);
 423
 424         g_object_ref(image);
 425
 426         edit_dialog = edit_dialog_show(NULL, NULL);
 427         edit_dialog_set_shortcut(edit_dialog, shortcut);
 428         if (!edit_dialog_set_image(edit_dialog, image))
 429                 gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 430 }
 431
 432
 433 /*******************************************************************************
 434  * Custom smiley list Drag-and-drop support.
 435  ******************************************************************************/
 436
 437 static void
 438 smiley_list_dnd_url_got(PurpleHttpConnection *http_conn,
 439         PurpleHttpResponse *response, gpointer _manager)
 440 {
 441         SmileyManager *manager = _manager;
 442         SmileyEditDialog *edit_dialog;
 443         PurpleImage *image;
 444         const gchar *image_data;
 445         size_t image_size;
 446
 447         g_return_if_fail(manager == smiley_manager);
 448         g_return_if_fail(manager->running_request == http_conn);
 449         manager->running_request = NULL;
 450
 451         if (!purple_http_response_is_successful(response))
 452                 return;
 453
 454         image_data = purple_http_response_get_data(response, &image_size);
 455         image = purple_image_new_from_data((const guint8 *)image_data, image_size);
 456         if (!image)
 457                 return;
 458
 459         edit_dialog = edit_dialog_show(manager, NULL);
 460         if (!edit_dialog_set_image(edit_dialog, image))
 461                 gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 462 }
 463
 464 static void
 465 smiley_list_dnd_recv(GtkWidget *widget, GdkDragContext *dc, gint x, gint y,
 466         GtkSelectionData *sd, guint info, guint time, gpointer _manager)
 467 {
 468         SmileyManager *manager = _manager;
 469         gchar content[1024];
 470
 471         /* We don't need anything, that is not 8-bit per element (char). */
 472         if (gtk_selection_data_get_format(sd) != 8) {
 473                 gtk_drag_finish(dc, FALSE, FALSE, time);
 474                 return;
 475         }
 476
 477         if (gtk_selection_data_get_length(sd) <= 0) {
 478                 gtk_drag_finish(dc, FALSE, FALSE, time);
 479                 return;
 480         }
 481
 482         memset(&content, 0, sizeof(content));
 483         memcpy(&content, gtk_selection_data_get_data(sd),
 484                 MIN((guint)gtk_selection_data_get_length(sd), sizeof(content)));
 485         g_strstrip(content);
 486         if (content[0] == '\0') {
 487                 gtk_drag_finish(dc, FALSE, FALSE, time);
 488                 return;
 489         }
 490
 491         /* Well, it looks like the drag event was cool.
 492          * Let's do something with it */
 493
 494         if (purple_str_has_caseprefix(content, "file://")) {
 495                 SmileyEditDialog *edit_dialog;
 496                 PurpleImage *image;
 497                 gchar *filename;
 498
 499                 filename = g_filename_from_uri(content, NULL, NULL);
 500                 if (!filename || !g_file_test(filename, G_FILE_TEST_EXISTS)) {
 501                         purple_debug_warning("gtksmiley-manager",
 502                                 "dropped file does not exists");
 503                         gtk_drag_finish(dc, FALSE, FALSE, time);
 504                         return;
 505                 }
 506
 507                 image = purple_image_new_from_file(filename, NULL);
 508                 if (!image) {
 509                         purple_debug_warning("gtksmiley-manager",
 510                                 "dropped file is not a valid image");
 511                         gtk_drag_finish(dc, FALSE, FALSE, time);
 512                         return;
 513                 }
 514                 edit_dialog = edit_dialog_show(manager, NULL);
 515                 if (!edit_dialog_set_image(edit_dialog, image)) {
 516                         gtk_widget_destroy(GTK_WIDGET(edit_dialog->window));
 517                         gtk_drag_finish(dc, FALSE, FALSE, time);
 518                         return;
 519                 }
 520
 521                 gtk_drag_finish(dc, TRUE, FALSE, time);
 522                 return;
 523         }
 524
 525         if (purple_str_has_caseprefix(content, "http://") ||
 526                 purple_str_has_caseprefix(content, "https://"))
 527         {
 528                 purple_http_conn_cancel(smiley_manager->
 529                         running_request);
 530                 smiley_manager->running_request = purple_http_get(NULL,
 531                         smiley_list_dnd_url_got, manager, content);
 532
 533                 gtk_drag_finish(dc, TRUE, FALSE, time);
 534                 return;
 535         }
 536
 537         gtk_drag_finish(dc, FALSE, FALSE, time);
 538 }
 539
 540 /*******************************************************************************
 541  * Custom smiley list.
 542  ******************************************************************************/
 543
 544 static void
 545 smiley_list_selected(GtkTreeSelection *sel, gpointer _manager)
 546 {
 547         SmileyManager *manager = _manager;
 548         gboolean sens;
 549
 550         sens = (gtk_tree_selection_count_selected_rows(sel) > 0);
 551
 552         gtk_dialog_set_response_sensitive(manager->window,
 553                 GTK_RESPONSE_NO, sens);
 554         gtk_dialog_set_response_sensitive(manager->window,
 555                 PIDGIN_RESPONSE_MODIFY, sens);
 556 }
 557
 558 static void
 559 smiley_list_activated(GtkTreeView *tree, GtkTreePath *path,
 560         GtkTreeViewColumn *col, gpointer _manager)
 561 {
 562         SmileyManager *manager = _manager;
 563         GtkTreeIter iter;
 564         PurpleSmiley *smiley = NULL;
 565
 566         if (!gtk_tree_model_get_iter(
 567                 GTK_TREE_MODEL(manager->model), &iter, path))
 568         {
 569                 return;
 570         }
 571
 572         gtk_tree_model_get(GTK_TREE_MODEL(manager->model), &iter,
 573                 SMILEY_LIST_MODEL_PURPLESMILEY, &smiley, -1);
 574         g_return_if_fail(PURPLE_IS_SMILEY(smiley));
 575
 576         edit_dialog_show(manager, smiley);
 577 }
 578
 579 static void
 580 manager_list_add(SmileyManager *manager, PurpleSmiley *smiley)
 581 {
 582         GdkPixbuf *smiley_image;
 583         GtkTreeIter iter;
 584
 585         smiley_image = g_object_get_data(G_OBJECT(smiley),
 586                 "pidgin-smiley-manager-list-thumb");
 587         if (smiley_image == NULL) {
 588                 smiley_image = pidgin_pixbuf_from_image(PURPLE_IMAGE(smiley));
 589                 smiley_image = pidgin_pixbuf_scale_down(smiley_image,
 590                         22, 22, GDK_INTERP_BILINEAR, TRUE);
 591                 g_object_set_data_full(G_OBJECT(smiley),
 592                         "pidgin-smiley-manager-list-thumb",
 593                         smiley_image, g_object_unref);
 594         }
 595
 596         gtk_list_store_append(manager->model, &iter);
 597         gtk_list_store_set(manager->model, &iter,
 598                 SMILEY_LIST_MODEL_ICON, smiley_image,
 599                 SMILEY_LIST_MODEL_SHORTCUT, purple_smiley_get_shortcut(smiley),
 600                 SMILEY_LIST_MODEL_PURPLESMILEY, smiley,
 601                 -1);
 602 }
 603
 604 static void
 605 manager_list_fill(SmileyManager *manager)
 606 {
 607         GList *custom_smileys, *it;
 608         gtk_list_store_clear(manager->model);
 609
 610         custom_smileys = purple_smiley_list_get_all(
 611                 purple_smiley_custom_get_list());
 612
 613         for (it = custom_smileys; it; it = g_list_next(it)) {
 614                 PurpleSmiley *smiley = it->data;
 615
 616                 manager_list_add(manager, smiley);
 617         }
 618         g_list_free(custom_smileys);
 619 }
 620
 621 static GtkWidget *
 622 manager_list_create(SmileyManager *manager)
 623 {
 624         GtkTreeView *tree;
 625         GtkTreeSelection *sel;
 626         GtkCellRenderer *cellrend;
 627         GtkTreeViewColumn *column;
 628         GtkTargetEntry targets[3] = {
 629                 {"text/plain", 0, 0},
 630                 {"text/uri-list", 0, 1},
 631                 {"STRING", 0, 2}
 632         };
 633
 634         manager->model = gtk_list_store_new(SMILEY_LIST_MODEL_N_COL,
 635                 GDK_TYPE_PIXBUF, /* icon */
 636                 G_TYPE_STRING, /* shortcut */
 637                 G_TYPE_OBJECT /* PurpleSmiley */
 638                 );
 639
 640         manager->tree = tree = GTK_TREE_VIEW(gtk_tree_view_new_with_model(
 641                 GTK_TREE_MODEL(manager->model)));
 642
 643         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(manager->model),
 644                 SMILEY_LIST_MODEL_SHORTCUT, GTK_SORT_ASCENDING);
 645
 646         g_object_unref(manager->model);
 647
 648         sel = gtk_tree_view_get_selection(tree);
 649         gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
 650
 651         g_signal_connect(sel, "changed",
 652                 G_CALLBACK(smiley_list_selected), manager);
 653         g_signal_connect(tree, "row-activated",
 654                 G_CALLBACK(smiley_list_activated), manager);
 655
 656         gtk_drag_dest_set(GTK_WIDGET(tree), GTK_DEST_DEFAULT_MOTION |
 657                 GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
 658                 targets, G_N_ELEMENTS(targets),
 659                 GDK_ACTION_COPY | GDK_ACTION_MOVE);
 660         g_signal_connect(tree, "drag-data-received",
 661                 G_CALLBACK(smiley_list_dnd_recv), manager);
 662
 663         gtk_widget_show(GTK_WIDGET(tree));
 664
 665         /* setting up columns */
 666
 667         column = gtk_tree_view_column_new();
 668         gtk_tree_view_column_set_title(column, _("Smiley"));
 669         gtk_tree_view_column_set_resizable(column, TRUE);
 670         gtk_tree_view_append_column(tree, column);
 671         cellrend = gtk_cell_renderer_pixbuf_new();
 672         gtk_tree_view_column_pack_start(column, cellrend, FALSE);
 673         gtk_tree_view_column_add_attribute(column, cellrend,
 674                 "pixbuf", SMILEY_LIST_MODEL_ICON);
 675
 676         column = gtk_tree_view_column_new();
 677         gtk_tree_view_column_set_title(column, _("Shortcut Text"));
 678         gtk_tree_view_column_set_resizable(column, TRUE);
 679         gtk_tree_view_append_column(tree, column);
 680         cellrend = gtk_cell_renderer_text_new();
 681         gtk_tree_view_column_pack_start(column, cellrend, TRUE);
 682         gtk_tree_view_column_add_attribute(column, cellrend,
 683                 "text", SMILEY_LIST_MODEL_SHORTCUT);
 684
 685         manager_list_fill(manager);
 686
 687         return pidgin_make_scrollable(GTK_WIDGET(tree), GTK_POLICY_AUTOMATIC,
 688                 GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, -1);
 689 }
 690
 691 /*******************************************************************************
 692  * Custom smiley manager window.
 693  ******************************************************************************/
 694
 695 static void
 696 manager_select_cb(GtkWidget *widget, gint resp, SmileyManager *manager)
 697 {
 698         GtkTreeSelection *selection = NULL;
 699         GList *selected_rows, *selected_smileys = NULL, *it;
 700         GtkTreeModel *model = GTK_TREE_MODEL(manager->model);
 701
 702         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(manager->tree));
 703         selected_rows = gtk_tree_selection_get_selected_rows(selection, NULL);
 704         for (it = selected_rows; it; it = g_list_next(it)) {
 705                 GtkTreePath *path = it->data;
 706                 GtkTreeIter iter;
 707                 PurpleSmiley *smiley = NULL;
 708
 709                 if (!gtk_tree_model_get_iter(model, &iter, path))
 710                         continue;
 711
 712                 gtk_tree_model_get(model, &iter,
 713                         SMILEY_LIST_MODEL_PURPLESMILEY, &smiley, -1);
 714                 if (!smiley)
 715                         continue;
 716
 717                 selected_smileys = g_list_prepend(selected_smileys, smiley);
 718         }
 719         g_list_free_full(selected_rows, (GDestroyNotify)gtk_tree_path_free);
 720
 721         switch (resp) {
 722                 case GTK_RESPONSE_YES:
 723                         edit_dialog_show(manager, NULL);
 724                         break;
 725                 case GTK_RESPONSE_NO:
 726                         for (it = selected_smileys; it; it = g_list_next(it))
 727                                 purple_smiley_custom_remove(it->data);
 728                         manager_list_fill(manager);
 729                         break;
 730                 case GTK_RESPONSE_DELETE_EVENT:
 731                 case GTK_RESPONSE_CLOSE:
 732                         gtk_widget_destroy(GTK_WIDGET(manager->window));
 733                         purple_http_conn_cancel(manager->running_request);
 734                         g_free(manager);
 735                         smiley_manager = NULL;
 736                         break;
 737                 case PIDGIN_RESPONSE_MODIFY:
 738                         for (it = selected_smileys; it; it = g_list_next(it))
 739                                 edit_dialog_show(manager, it->data);
 740                         break;
 741                 default:
 742                         g_warn_if_reached();
 743         }
 744
 745         g_list_free(selected_smileys);
 746 }
 747
 748 void
 749 pidgin_smiley_manager_show(void)
 750 {
 751         SmileyManager *manager;
 752         GtkDialog *win;
 753         GtkWidget *sw, *vbox;
 754
 755         if (smiley_manager) {
 756                 gtk_window_present(GTK_WINDOW(smiley_manager->window));
 757                 return;
 758         }
 759
 760         manager = g_new0(SmileyManager, 1);
 761         smiley_manager = manager;
 762
 763         manager->window = win = GTK_DIALOG(gtk_dialog_new_with_buttons(
 764                 _("Custom Smiley Manager"), NULL,
 765                 GTK_DIALOG_DESTROY_WITH_PARENT,
 766                 PIDGIN_STOCK_ADD, GTK_RESPONSE_YES,
 767                 PIDGIN_STOCK_MODIFY, PIDGIN_RESPONSE_MODIFY,
 768                 GTK_STOCK_DELETE, GTK_RESPONSE_NO,
 769                 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
 770                 NULL));
 771
 772         gtk_window_set_default_size(GTK_WINDOW(win), 50, 400);
 773         gtk_window_set_role(GTK_WINDOW(win), "custom_smiley_manager");
 774         gtk_dialog_set_response_sensitive(win, GTK_RESPONSE_NO, FALSE);
 775         gtk_dialog_set_response_sensitive(win, PIDGIN_RESPONSE_MODIFY, FALSE);
 776
 777         g_signal_connect(win, "response",
 778                 G_CALLBACK(manager_select_cb), manager);
 779
 780         /* The vbox */
 781         vbox = gtk_dialog_get_content_area(win);
 782
 783         /* get the scrolled window with all stuff */
 784         sw = manager_list_create(manager);
 785         gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
 786         gtk_widget_show(sw);
 787
 788         gtk_widget_show(GTK_WIDGET(win));
 789 }