HGKeeper

/**

* @file gtksmiley.c GTK+ Smiley Manager API

* @ingroup pidgin

* pidgin

* Pidgin is the legal property of its developers, whose names are too numerous

* to list here. Please refer to the COPYRIGHT file distributed with this

* source distribution.

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA

#include "internal.h"

#include "pidgin.h"

#include "debug.h"

#include "glibcompat.h"

#include "notify.h"

#include "smiley.h"

#include "gtkimhtml.h"

#include "gtksmiley.h"

#include "gtkutils.h"

#include "pidginstock.h"

#define PIDGIN_RESPONSE_MODIFY 1000

struct _PidginSmiley

{

PurpleSmiley *smiley;

GtkWidget *parent;

GtkWidget *smile;

GtkWidget *smiley_image;

gchar *filename;

GdkPixbuf *custom_pixbuf;

gpointer data; /** @since 2.6.0 */

gsize datasize; /** @since 2.6.0 */

gint entry_len; /** @since 2.6.0 */

};

typedef struct

{

GtkWidget *window;

GtkWidget *treeview;

GtkListStore *model;

} SmileyManager;

enum

{

ICON,

SHORTCUT,

SMILEY,

N_COL

};

static SmileyManager *smiley_manager = NULL;

static GSList *gtk_smileys = NULL;

static void

pidgin_smiley_destroy(PidginSmiley *smiley)

{

if (smiley->smiley)

g_object_set_data(G_OBJECT(smiley->smiley), "edit-dialog", NULL);

gtk_widget_destroy(smiley->parent);

g_free(smiley->filename);

if (smiley->custom_pixbuf)

g_object_unref(G_OBJECT(smiley->custom_pixbuf));

g_free(smiley);

}

/******************************************************************************

* GtkIMHtmlSmileys stuff

*****************************************************************************/

/* Perhaps these should be in gtkimhtml.c instead. -- sadrul */

static void add_gtkimhtml_to_list(GtkIMHtmlSmiley *gtksmiley)

{

gtk_smileys = g_slist_prepend(gtk_smileys, gtksmiley);

purple_debug_info("gtksmiley", "adding %s to gtk_smileys\n", gtksmiley->smile);

}

static void

shortcut_changed_cb(PurpleSmiley *smiley, gpointer dontcare, GtkIMHtmlSmiley *gtksmiley)

{

g_free(gtksmiley->smile);

gtksmiley->smile = g_strdup(purple_smiley_get_shortcut(smiley));

}

static void

image_changed_cb(PurpleSmiley *smiley, gpointer dontcare, GtkIMHtmlSmiley *gtksmiley)

{

const char *file;

g_free(gtksmiley->file);

file = purple_imgstore_get_filename(purple_smiley_get_stored_image(smiley));

gtksmiley->file = g_build_filename(purple_smileys_get_storing_dir(), file, NULL);

gtk_imhtml_smiley_reload(gtksmiley);

}

static GtkIMHtmlSmiley *smiley_purple_to_gtkimhtml(PurpleSmiley *smiley)

{

GtkIMHtmlSmiley *gtksmiley;

gchar *filename;

const gchar *file;

file = purple_imgstore_get_filename(purple_smiley_get_stored_image(smiley));

filename = g_build_filename(purple_smileys_get_storing_dir(), file, NULL);

gtksmiley = gtk_imhtml_smiley_create(filename, purple_smiley_get_shortcut(smiley),

FALSE, GTK_IMHTML_SMILEY_CUSTOM);

g_free(filename);

/* Make sure the shortcut for the GtkIMHtmlSmiley is updated with the PurpleSmiley */

g_signal_connect(G_OBJECT(smiley), "notify::shortcut",

G_CALLBACK(shortcut_changed_cb), gtksmiley);

/* And update the pixbuf too when the image is changed */

g_signal_connect(G_OBJECT(smiley), "notify::image",

G_CALLBACK(image_changed_cb), gtksmiley);

return gtksmiley;

}

void pidgin_smiley_del_from_list(PurpleSmiley *smiley)

{

GSList *list = NULL;

GtkIMHtmlSmiley *gtksmiley;

if (gtk_smileys == NULL)

return;

list = gtk_smileys;

for (; list; list = list->next) {

gtksmiley = (GtkIMHtmlSmiley*)list->data;

if (!purple_strequal(gtksmiley->smile, purple_smiley_get_shortcut(smiley)))

continue;

gtk_imhtml_smiley_destroy(gtksmiley);

g_signal_handlers_disconnect_matched(G_OBJECT(smiley), G_SIGNAL_MATCH_DATA,

0, 0, NULL, NULL, gtksmiley);

break;

}

if (list)

gtk_smileys = g_slist_delete_link(gtk_smileys, list);

}

void pidgin_smiley_add_to_list(PurpleSmiley *smiley)

{

GtkIMHtmlSmiley *gtksmiley;

gtksmiley = smiley_purple_to_gtkimhtml(smiley);

add_gtkimhtml_to_list(gtksmiley);

g_signal_connect(G_OBJECT(smiley), "destroy", G_CALLBACK(pidgin_smiley_del_from_list), NULL);

}

void pidgin_smileys_init(void)

{

GList *smileys;

PurpleSmiley *smiley;

if (gtk_smileys != NULL)

return;

smileys = purple_smileys_get_all();

for (; smileys; smileys = g_list_delete_link(smileys, smileys)) {

smiley = (PurpleSmiley*)smileys->data;

pidgin_smiley_add_to_list(smiley);

}

void pidgin_smileys_uninit(void)

{

GSList *list;

GtkIMHtmlSmiley *gtksmiley;

list = gtk_smileys;

if (list == NULL)

return;

for (; list; list = g_slist_delete_link(list, list)) {

gtksmiley = (GtkIMHtmlSmiley*)list->data;

gtk_imhtml_smiley_destroy(gtksmiley);

}

gtk_smileys = NULL;

}

GSList *pidgin_smileys_get_all(void)

{

return gtk_smileys;

}

/******************************************************************************

* Manager stuff

*****************************************************************************/

static void refresh_list(void);

/******************************************************************************

* The Add dialog

******************************************************************************/

static void do_add(GtkWidget *widget, PidginSmiley *s)

{

const gchar *entry;

PurpleSmiley *emoticon;

entry = gtk_entry_get_text(GTK_ENTRY(s->smile));

emoticon = purple_smileys_find_by_shortcut(entry);

if (emoticon && emoticon != s->smiley) {

gchar *msg;

msg = g_strdup_printf(_("A custom smiley for '%s' already exists. "

"Please use a different shortcut."), entry);

purple_notify_error(s->parent, _("Custom Smiley"),

_("Duplicate Shortcut"), msg);

g_free(msg);

return;

}

if (s->smiley) {

if (s->filename) {

gchar *data = NULL;

size_t len;

GError *err = NULL;

if (!g_file_get_contents(s->filename, &data, &len, &err)) {

purple_debug_error("gtksmiley", "Error reading %s: %s\n",

s->filename, err->message);

g_error_free(err);

return;

}

purple_smiley_set_data(s->smiley, (guchar*)data, len);

}

purple_smiley_set_shortcut(s->smiley, entry);

} else {

purple_debug_info("gtksmiley", "adding a new smiley\n");

if (s->filename == NULL) {

gchar *buffer = NULL;

gsize size = 0;

gchar *filename;

const gchar *dirname = purple_smileys_get_storing_dir();

/* since this may be called before purple_smiley_new_* has ever been

called, we create the storing dir, if it doesn't exist yet, to be

able to save the pixbuf before adding the smiley */

if (!g_file_test(dirname, G_FILE_TEST_IS_DIR)) {

purple_debug_info("gtksmiley", "Creating smileys directory.\n");

if (g_mkdir(dirname, S_IRUSR | S_IWUSR | S_IXUSR) < 0) {

purple_debug_error("gtksmiley",

"Unable to create directory %s: %s\n",

dirname, g_strerror(errno));

}

if (s->data && s->datasize) {

/* Cached data & size in memory */

buffer = s->data;

size = s->datasize;

}

else {

/* Get the smiley from the custom pixbuf */

gdk_pixbuf_save_to_buffer(s->custom_pixbuf, &buffer, &size,

"png", NULL, "compression", "9", NULL, NULL);

}

filename = purple_util_get_image_filename(buffer, size);

s->filename = g_build_filename(dirname, filename, NULL);

purple_util_write_data_to_file_absolute(s->filename, buffer, size);

g_free(filename);

g_free(buffer);

}

emoticon = purple_smiley_new_from_file(entry, s->filename);

if (emoticon)

pidgin_smiley_add_to_list(emoticon);

}

if (smiley_manager != NULL)

refresh_list();

gtk_widget_destroy(s->parent);

}

static void do_add_select_cb(GtkWidget *widget, gint resp, PidginSmiley *s)

{

switch (resp) {

case GTK_RESPONSE_ACCEPT:

do_add(widget, s);

break;

case GTK_RESPONSE_DELETE_EVENT:

case GTK_RESPONSE_CANCEL:

gtk_widget_destroy(s->parent);

break;

default:

purple_debug_error("gtksmiley", "no valid response\n");

break;

}

static void do_add_file_cb(const char *filename, gpointer data)

{

PidginSmiley *s = data;

GdkPixbuf *pixbuf;

if (!filename)

return;

g_free(s->filename);

s->filename = g_strdup(filename);

pixbuf = pidgin_pixbuf_new_from_file_at_scale(filename, 64, 64, FALSE);

gtk_image_set_from_pixbuf(GTK_IMAGE(s->smiley_image), pixbuf);

if (pixbuf)

g_object_unref(G_OBJECT(pixbuf));

gtk_widget_grab_focus(s->smile);

if (s->entry_len > 0)

gtk_dialog_set_response_sensitive(GTK_DIALOG(s->parent), GTK_RESPONSE_ACCEPT, TRUE);

}

static void

open_image_selector(GtkWidget *widget, PidginSmiley *psmiley)

{

GtkWidget *file_chooser;

file_chooser = pidgin_buddy_icon_chooser_new(GTK_WINDOW(gtk_widget_get_toplevel(widget)),

do_add_file_cb, psmiley);

gtk_window_set_title(GTK_WINDOW(file_chooser), _("Custom Smiley"));

gtk_window_set_role(GTK_WINDOW(file_chooser), "file-selector-custom-smiley");

gtk_widget_show_all(file_chooser);

}

static void

smiley_name_insert_cb(GtkEditable *editable,

gchar *new_text,

gint new_text_length,

gint *position,

gpointer user_data)

{

PidginSmiley *s = user_data;

if (new_text_length != -1)

s->entry_len += new_text_length;

else

s->entry_len += strlen(new_text);

if (s->filename != NULL || s->custom_pixbuf != NULL || s->smiley != NULL)

gtk_dialog_set_response_sensitive(GTK_DIALOG(s->parent), GTK_RESPONSE_ACCEPT, TRUE);

}

static void

smiley_name_delete_cb(GtkEditable *editable,

gint start_pos,

gint end_pos,

gpointer user_data)

{

PidginSmiley *s = user_data;

s->entry_len -= end_pos - start_pos;

if (s->entry_len <= 0)

gtk_dialog_set_response_sensitive(GTK_DIALOG(s->parent), GTK_RESPONSE_ACCEPT, FALSE);

}

PidginSmiley *

pidgin_smiley_edit(GtkWidget *widget, PurpleSmiley *smiley)

{

GtkWidget *vbox;

GtkWidget *hbox;

GtkWidget *label;

GtkWidget *filech;

GtkWidget *window;

GdkPixbuf *pixbuf = NULL;

PurpleStoredImage *stored_img;

PidginSmiley *s = g_new0(PidginSmiley, 1);

s->smiley = smiley;

window = gtk_dialog_new_with_buttons(smiley ? _("Edit Smiley") : _("Add Smiley"),

widget ? GTK_WINDOW(widget) : NULL,

GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,

GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,

smiley ? GTK_STOCK_SAVE : GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT,

NULL);

s->parent = window;

if (smiley)

g_object_set_data(G_OBJECT(smiley), "edit-dialog", window);

gtk_container_set_border_width(GTK_CONTAINER(window), PIDGIN_HIG_BORDER);

gtk_dialog_set_default_response(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT);

g_signal_connect(window, "response", G_CALLBACK(do_add_select_cb), s);

/* The vbox */

vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);

gtk_container_add(GTK_CONTAINER(GTK_DIALOG(window)->vbox), vbox);

gtk_widget_show(vbox);

/* The hbox */

hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);

gtk_container_add(GTK_CONTAINER(GTK_VBOX(vbox)), hbox);

label = gtk_label_new_with_mnemonic(_("_Image:"));

gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

gtk_widget_show(label);

filech = gtk_button_new();

gtk_box_pack_end(GTK_BOX(hbox), filech, FALSE, FALSE, 0);

pidgin_set_accessible_label(filech, label);

s->smiley_image = gtk_image_new();

gtk_container_add(GTK_CONTAINER(filech), s->smiley_image);

if (smiley && (stored_img = purple_smiley_get_stored_image(smiley))) {

pixbuf = pidgin_pixbuf_from_imgstore(stored_img);

purple_imgstore_unref(stored_img);

} else {

GtkIconSize icon_size = gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL);

pixbuf = gtk_widget_render_icon(window, PIDGIN_STOCK_TOOLBAR_SELECT_AVATAR,

icon_size, "PidginSmiley");

}

gtk_image_set_from_pixbuf(GTK_IMAGE(s->smiley_image), pixbuf);

if (pixbuf != NULL)

g_object_unref(G_OBJECT(pixbuf));

g_signal_connect(G_OBJECT(filech), "clicked", G_CALLBACK(open_image_selector), s);

gtk_widget_show_all(hbox);

/* info */

hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER);

gtk_container_add(GTK_CONTAINER(GTK_VBOX(vbox)),hbox);

/* Shortcut text */

label = gtk_label_new_with_mnemonic(_("S_hortcut text:"));

gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

gtk_widget_show(label);

s->smile = gtk_entry_new();

gtk_entry_set_activates_default(GTK_ENTRY(s->smile), TRUE);

pidgin_set_accessible_label(s->smile, label);

if (smiley) {

const char *shortcut = purple_smiley_get_shortcut(smiley);

gtk_entry_set_text(GTK_ENTRY(s->smile), shortcut);

s->entry_len = strlen(shortcut);

}

else

gtk_dialog_set_response_sensitive(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT, FALSE);

/* gtk_entry_get_text_length is 2.14+, so we'll just keep track ourselves */

g_signal_connect(G_OBJECT(s->smile), "insert-text", G_CALLBACK(smiley_name_insert_cb), s);

g_signal_connect(G_OBJECT(s->smile), "delete-text", G_CALLBACK(smiley_name_delete_cb), s);

gtk_box_pack_end(GTK_BOX(hbox), s->smile, FALSE, FALSE, 0);

gtk_widget_show(s->smile);

gtk_widget_show(hbox);

gtk_widget_show(GTK_WIDGET(window));

g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(pidgin_smiley_destroy), s);

g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(purple_notify_close_with_handle), s);

return s;

}

void

pidgin_smiley_editor_set_shortcut(PidginSmiley *editor, const gchar *shortcut)

{

gtk_entry_set_text(GTK_ENTRY(editor->smile), shortcut ? shortcut : "");

}

void

pidgin_smiley_editor_set_image(PidginSmiley *editor, GdkPixbuf *image)

{

if (editor->custom_pixbuf)

g_object_unref(G_OBJECT(editor->custom_pixbuf));

editor->custom_pixbuf = image ? g_object_ref(G_OBJECT(image)) : NULL;

if (image) {

gtk_image_set_from_pixbuf(GTK_IMAGE(editor->smiley_image), image);

if (editor->entry_len > 0)

gtk_dialog_set_response_sensitive(GTK_DIALOG(editor->parent),

GTK_RESPONSE_ACCEPT, TRUE);

}

else

gtk_dialog_set_response_sensitive(GTK_DIALOG(editor->parent),

GTK_RESPONSE_ACCEPT, FALSE);

}

void

pidgin_smiley_editor_set_data(PidginSmiley *editor, gpointer data, gsize datasize)

{

editor->data = data;

editor->datasize = datasize;

}

/******************************************************************************

* Delete smiley

*****************************************************************************/

static void delete_foreach(GtkTreeModel *model, GtkTreePath *path,

GtkTreeIter *iter, gpointer data)

{

PurpleSmiley *smiley = NULL;

gtk_tree_model_get(model, iter,

SMILEY, &smiley,

-1);

if(smiley != NULL) {

g_object_unref(G_OBJECT(smiley));

pidgin_smiley_del_from_list(smiley);

purple_smiley_delete(smiley);

}

static void append_to_list(GtkTreeModel *model, GtkTreePath *path,

GtkTreeIter *iter, gpointer data)

{

GList **list = data;

*list = g_list_prepend(*list, gtk_tree_path_copy(path));

}

static void smiley_delete(SmileyManager *dialog)

{

GtkTreeSelection *selection;

GList *list = NULL;

selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview));

gtk_tree_selection_selected_foreach(selection, delete_foreach, dialog);

gtk_tree_selection_selected_foreach(selection, append_to_list, &list);

while (list) {

GtkTreeIter iter;

if (gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, list->data))

gtk_list_store_remove(GTK_LIST_STORE(dialog->model), &iter);

gtk_tree_path_free(list->data);

list = g_list_delete_link(list, list);

}

/******************************************************************************

* The Smiley Manager

*****************************************************************************/

static void add_columns(GtkWidget *treeview, SmileyManager *dialog)

{

GtkCellRenderer *rend;

GtkTreeViewColumn *column;

/* Icon */

column = gtk_tree_view_column_new();

gtk_tree_view_column_set_title(column, _("Smiley"));

gtk_tree_view_column_set_resizable(column, TRUE);

gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);

rend = gtk_cell_renderer_pixbuf_new();

gtk_tree_view_column_pack_start(column, rend, FALSE);

gtk_tree_view_column_add_attribute(column, rend, "pixbuf", ICON);

/* Shortcut Text */

column = gtk_tree_view_column_new();

gtk_tree_view_column_set_title(column, _("Shortcut Text"));

gtk_tree_view_column_set_resizable(column, TRUE);

gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);

rend = gtk_cell_renderer_text_new();

gtk_tree_view_column_pack_start(column, rend, TRUE);

gtk_tree_view_column_add_attribute(column, rend, "text", SHORTCUT);

}

static void store_smiley_add(PurpleSmiley *smiley)

{

GtkTreeIter iter;

PurpleStoredImage *img;

GdkPixbuf *sized_smiley = NULL;

if (smiley_manager == NULL)

return;

img = purple_smiley_get_stored_image(smiley);

if (img != NULL) {

GdkPixbuf *smiley_image = pidgin_pixbuf_from_imgstore(img);

purple_imgstore_unref(img);

if (smiley_image != NULL) {

if (gdk_pixbuf_get_width(smiley_image) > 22 ||

gdk_pixbuf_get_height(smiley_image) > 22) {

sized_smiley = gdk_pixbuf_scale_simple(smiley_image,

22, 22, GDK_INTERP_HYPER);

g_object_unref(G_OBJECT(smiley_image));

} else {

/* don't scale up smaller smileys, avoid blurryness */

sized_smiley = smiley_image;

}

gtk_list_store_append(smiley_manager->model, &iter);

gtk_list_store_set(smiley_manager->model, &iter,

ICON, sized_smiley,

SHORTCUT, purple_smiley_get_shortcut(smiley),

SMILEY, smiley,

-1);

if (sized_smiley != NULL)

g_object_unref(G_OBJECT(sized_smiley));

}

static void populate_smiley_list(SmileyManager *dialog)

{

GList *list;

PurpleSmiley *emoticon;

gtk_list_store_clear(dialog->model);

for(list = purple_smileys_get_all(); list != NULL;

list = g_list_delete_link(list, list)) {

emoticon = (PurpleSmiley*)list->data;

store_smiley_add(emoticon);

}

static void smile_selected_cb(GtkTreeSelection *sel, SmileyManager *dialog)

{

gint selected;

selected = gtk_tree_selection_count_selected_rows(sel);

gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog->window),

GTK_RESPONSE_NO, selected > 0);

gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog->window),

PIDGIN_RESPONSE_MODIFY, selected > 0);

}

static void

smiley_edit_iter(SmileyManager *dialog, GtkTreeIter *iter)

{

PurpleSmiley *smiley = NULL;

GtkWidget *window = NULL;

gtk_tree_model_get(GTK_TREE_MODEL(dialog->model), iter, SMILEY, &smiley, -1);

if ((window = g_object_get_data(G_OBJECT(smiley), "edit-dialog")) != NULL)

gtk_window_present(GTK_WINDOW(window));

else

pidgin_smiley_edit(gtk_widget_get_toplevel(GTK_WIDGET(dialog->treeview)), smiley);

g_object_unref(G_OBJECT(smiley));

}

static void smiley_edit_cb(GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)

{

GtkTreeIter iter;

SmileyManager *dialog = data;

gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, path);

smiley_edit_iter(dialog, &iter);

}

static void

edit_selected_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)

{

smiley_edit_iter(data, iter);

}

static void

smiley_got_url(PurpleUtilFetchUrlData *url_data, gpointer user_data,

const gchar *smileydata, size_t len, const gchar *error_message)

{

SmileyManager *dialog = user_data;

FILE *f;

gchar *path;

size_t wc;

PidginSmiley *ps;

GdkPixbuf *image;

if ((error_message != NULL) || (len == 0)) {

return;

}

f = purple_mkstemp(&path, TRUE);

wc = fwrite(smileydata, len, 1, f);

if (wc != 1) {

purple_debug_warning("smiley_got_url", "Unable to write smiley data.\n");

fclose(f);

g_unlink(path);

g_free(path);

return;

}

fclose(f);

image = pidgin_pixbuf_new_from_file(path);

g_unlink(path);

g_free(path);

if (!image)

return;

ps = pidgin_smiley_edit(dialog->window, NULL);

pidgin_smiley_editor_set_image(ps, image);

pidgin_smiley_editor_set_data(ps, g_memdup2(smileydata, len), len);

}

static void

smiley_dnd_recv(GtkWidget *widget, GdkDragContext *dc, guint x, guint y,

GtkSelectionData *sd, guint info, guint t, gpointer user_data)

{

SmileyManager *dialog = user_data;

gchar *name = g_strchomp((gchar *)sd->data);

if ((sd->length >= 0) && (sd->format == 8)) {

/* Well, it looks like the drag event was cool.

* Let's do something with it */

if (!g_ascii_strncasecmp(name, "file://", 7)) {

GError *converr = NULL;

gchar *tmp;

PidginSmiley *ps;

/* It looks like we're dealing with a local file. Let's

* just try and read it */

if(!(tmp = g_filename_from_uri(name, NULL, &converr))) {

purple_debug_error("smiley dnd", "%s\n",

(converr ? converr->message :

"g_filename_from_uri error"));

return;

}

ps = pidgin_smiley_edit(dialog->window, NULL);

do_add_file_cb(tmp, ps);

if (gtk_image_get_pixbuf(GTK_IMAGE(ps->smiley_image)) == NULL)

gtk_dialog_response(GTK_DIALOG(ps->parent), GTK_RESPONSE_CANCEL);

g_free(tmp);

} else if (!g_ascii_strncasecmp(name, "http://", 7)) {

/* Oo, a web drag and drop. This is where things

* will start to get interesting */

purple_util_fetch_url(name, TRUE, NULL, FALSE, smiley_got_url, dialog);

} else if (!g_ascii_strncasecmp(name, "https://", 8)) {

/* purple_util_fetch_url() doesn't support HTTPS */

char *tmp = g_strdup(name + 1);

tmp[0] = 'h';

tmp[1] = 't';

tmp[2] = 't';

tmp[3] = 'p';

purple_util_fetch_url(tmp, TRUE, NULL, FALSE, smiley_got_url, dialog);

g_free(tmp);

}

gtk_drag_finish(dc, TRUE, FALSE, t);

}

gtk_drag_finish(dc, FALSE, FALSE, t);

}

static GtkWidget *smiley_list_create(SmileyManager *dialog)

{

GtkWidget *treeview;

GtkTreeSelection *sel;

GtkTargetEntry te[3] = {

{"text/plain", 0, 0},

{"text/uri-list", 0, 1},

{"STRING", 0, 2}

};

/* Create the list model */

dialog->model = gtk_list_store_new(N_COL,

GDK_TYPE_PIXBUF, /* ICON */

G_TYPE_STRING, /* SHORTCUT */

G_TYPE_OBJECT /* SMILEY */

);

/* the actual treeview */

treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dialog->model));

dialog->treeview = treeview;

gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);

gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(dialog->model), SHORTCUT, GTK_SORT_ASCENDING);

g_object_unref(G_OBJECT(dialog->model));

sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);

g_signal_connect(G_OBJECT(sel), "changed", G_CALLBACK(smile_selected_cb), dialog);

g_signal_connect(G_OBJECT(treeview), "row_activated", G_CALLBACK(smiley_edit_cb), dialog);

gtk_drag_dest_set(treeview,

GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,

te, G_N_ELEMENTS(te), GDK_ACTION_COPY | GDK_ACTION_MOVE);

g_signal_connect(G_OBJECT(treeview), "drag_data_received", G_CALLBACK(smiley_dnd_recv), dialog);

gtk_widget_show(treeview);

add_columns(treeview, dialog);

populate_smiley_list(dialog);

return pidgin_make_scrollable(treeview, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, -1);

}

static void refresh_list()

{

populate_smiley_list(smiley_manager);

}

static void smiley_manager_select_cb(GtkWidget *widget, gint resp, SmileyManager *dialog)

{

GtkTreeSelection *selection = NULL;

switch (resp) {

case GTK_RESPONSE_YES:

pidgin_smiley_edit(dialog->window, NULL);

break;

case GTK_RESPONSE_NO:

smiley_delete(dialog);

break;

case GTK_RESPONSE_DELETE_EVENT:

case GTK_RESPONSE_CLOSE:

gtk_widget_destroy(dialog->window);

g_free(smiley_manager);

smiley_manager = NULL;

break;

case PIDGIN_RESPONSE_MODIFY:

/* Find smiley of selection... */

selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview));

gtk_tree_selection_selected_foreach(selection, edit_selected_cb, dialog);

break;

default:

purple_debug_info("gtksmiley", "No valid selection\n");

break;

}

void pidgin_smiley_manager_show(void)

{

SmileyManager *dialog;

GtkWidget *win;

GtkWidget *sw;

GtkWidget *vbox;

if (smiley_manager) {

gtk_window_present(GTK_WINDOW(smiley_manager->window));

return;

}

dialog = g_new0(SmileyManager, 1);

smiley_manager = dialog;

dialog->window = win = gtk_dialog_new_with_buttons(

_("Custom Smiley Manager"),

NULL,

GTK_DIALOG_DESTROY_WITH_PARENT,

PIDGIN_STOCK_ADD, GTK_RESPONSE_YES,

PIDGIN_STOCK_MODIFY, PIDGIN_RESPONSE_MODIFY,

GTK_STOCK_DELETE, GTK_RESPONSE_NO,

GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,

NULL);

gtk_window_set_default_size(GTK_WINDOW(win), 50, 400);

gtk_window_set_role(GTK_WINDOW(win), "custom_smiley_manager");

gtk_container_set_border_width(GTK_CONTAINER(win),PIDGIN_HIG_BORDER);

gtk_dialog_set_response_sensitive(GTK_DIALOG(win), GTK_RESPONSE_NO, FALSE);

gtk_dialog_set_response_sensitive(GTK_DIALOG(win),

PIDGIN_RESPONSE_MODIFY, FALSE);

g_signal_connect(win, "response", G_CALLBACK(smiley_manager_select_cb),

dialog);

/* The vbox */

vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);

gtk_container_add(GTK_CONTAINER(GTK_DIALOG(win)->vbox), vbox);

gtk_widget_show(vbox);

/* get the scrolled window with all stuff */

sw = smiley_list_create(dialog);

gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);

gtk_widget_show(sw);

gtk_widget_show(win);

}

pidgin/pidgin