dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/widgets/gimpdnd.c

1849 lines
44 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>
#include "libgimpcolor/gimpcolor.h"
#include "libgimpbase/gimpbase.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "widgets-types.h"
#include "core/gimp.h"
#include "core/gimpbrush.h"
#include "core/gimpbuffer.h"
#include "core/gimpchannel.h"
#include "core/gimpcontainer.h"
#include "core/gimpdatafactory.h"
#include "core/gimpdrawable.h"
#include "core/gimpgradient.h"
#include "core/gimpimage.h"
#include "core/gimpimagefile.h"
#include "core/gimplayer.h"
#include "core/gimplayermask.h"
#include "core/gimppalette.h"
#include "core/gimppattern.h"
#include "core/gimptemplate.h"
#include "core/gimptoolinfo.h"
#include "text/gimpfont.h"
#include "vectors/gimpvectors.h"
#include "file/file-open.h"
#include "file/file-utils.h"
#include "app_procs.h"
#include "gimpdnd.h"
#include "gimppreview.h"
#include "gimp-intl.h"
#define DRAG_PREVIEW_SIZE 32
#define DRAG_ICON_OFFSET -8
typedef GtkWidget * (* GimpDndGetIconFunc) (GtkWidget *widget,
GCallback get_data_func,
gpointer get_data_data);
typedef guchar * (* GimpDndDragDataFunc) (GtkWidget *widget,
GCallback get_data_func,
gpointer get_data_data,
gint *format,
gint *length);
typedef void (* GimpDndDropDataFunc) (GtkWidget *widget,
GCallback set_data_func,
gpointer set_data_data,
guchar *vals,
gint format,
gint length);
typedef struct _GimpDndDataDef GimpDndDataDef;
struct _GimpDndDataDef
{
GtkTargetEntry target_entry;
gchar *set_data_func_name;
gchar *set_data_data_name;
GimpDndGetIconFunc get_icon_func;
GimpDndDragDataFunc get_data_func;
GimpDndDropDataFunc set_data_func;
};
static GtkWidget * gimp_dnd_get_viewable_icon (GtkWidget *widget,
GCallback get_viewable_func,
gpointer get_viewable_data);
static GtkWidget * gimp_dnd_get_color_icon (GtkWidget *widget,
GCallback get_color_func,
gpointer get_color_data);
static void gimp_dnd_set_file_data (GtkWidget *widget,
GCallback set_color_func,
gpointer set_color_data,
guchar *vals,
gint format,
gint length);
static guchar * gimp_dnd_get_color_data (GtkWidget *widget,
GCallback get_color_func,
gpointer get_color_data,
gint *format,
gint *length);
static void gimp_dnd_set_color_data (GtkWidget *widget,
GCallback set_color_func,
gpointer set_color_data,
guchar *vals,
gint format,
gint length);
static guchar * gimp_dnd_get_image_data (GtkWidget *widget,
GCallback get_image_func,
gpointer get_image_data,
gint *format,
gint *length);
static void gimp_dnd_set_image_data (GtkWidget *widget,
GCallback set_image_func,
gpointer set_image_data,
guchar *vals,
gint format,
gint length);
static guchar * gimp_dnd_get_item_data (GtkWidget *widget,
GCallback get_item_func,
gpointer get_item_data,
gint *format,
gint *length);
static void gimp_dnd_set_item_data (GtkWidget *widget,
GCallback set_item_func,
gpointer set_item_data,
guchar *vals,
gint format,
gint length);
static guchar * gimp_dnd_get_data_data (GtkWidget *widget,
GCallback get_data_func,
gpointer get_data_data,
gint *format,
gint *length);
static void gimp_dnd_set_brush_data (GtkWidget *widget,
GCallback set_brush_func,
gpointer set_brush_data,
guchar *vals,
gint format,
gint length);
static void gimp_dnd_set_pattern_data (GtkWidget *widget,
GCallback set_pattern_func,
gpointer set_pattern_data,
guchar *vals,
gint format,
gint length);
static void gimp_dnd_set_gradient_data (GtkWidget *widget,
GCallback set_gradient_func,
gpointer set_gradient_data,
guchar *vals,
gint format,
gint length);
static void gimp_dnd_set_palette_data (GtkWidget *widget,
GCallback set_palette_func,
gpointer set_palette_data,
guchar *vals,
gint format,
gint length);
static void gimp_dnd_set_font_data (GtkWidget *widget,
GCallback set_font_func,
gpointer set_font_data,
guchar *vals,
gint format,
gint length);
static void gimp_dnd_set_buffer_data (GtkWidget *widget,
GCallback set_buffer_func,
gpointer set_buffer_data,
guchar *vals,
gint format,
gint length);
static void gimp_dnd_set_imagefile_data (GtkWidget *widget,
GCallback set_imagefile_func,
gpointer set_imagefile_data,
guchar *vals,
gint format,
gint length);
static void gimp_dnd_set_template_data (GtkWidget *widget,
GCallback set_template_func,
gpointer set_template_data,
guchar *vals,
gint format,
gint length);
static void gimp_dnd_set_tool_data (GtkWidget *widget,
GCallback set_tool_func,
gpointer set_tool_data,
guchar *vals,
gint format,
gint length);
static GimpDndDataDef dnd_data_defs[] =
{
{
{ NULL, 0, -1 },
NULL,
NULL,
NULL,
NULL,
NULL
},
{
GIMP_TARGET_URI_LIST,
"gimp_dnd_set_file_func",
"gimp_dnd_set_file_data",
NULL,
NULL,
gimp_dnd_set_file_data
},
{
GIMP_TARGET_TEXT_PLAIN,
"gimp_dnd_set_file_func",
"gimp_dnd_set_file_data",
NULL,
NULL,
gimp_dnd_set_file_data
},
{
GIMP_TARGET_NETSCAPE_URL,
"gimp_dnd_set_file_func",
"gimp_dnd_set_file_data",
NULL,
NULL,
gimp_dnd_set_file_data
},
{
GIMP_TARGET_COLOR,
"gimp_dnd_set_color_func",
"gimp_dnd_set_color_data",
gimp_dnd_get_color_icon,
gimp_dnd_get_color_data,
gimp_dnd_set_color_data
},
{
GIMP_TARGET_IMAGE,
"gimp_dnd_set_image_func",
"gimp_dnd_set_image_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_image_data,
gimp_dnd_set_image_data,
},
{
GIMP_TARGET_LAYER,
"gimp_dnd_set_layer_func",
"gimp_dnd_set_layer_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_item_data,
gimp_dnd_set_item_data,
},
{
GIMP_TARGET_CHANNEL,
"gimp_dnd_set_channel_func",
"gimp_dnd_set_channel_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_item_data,
gimp_dnd_set_item_data,
},
{
GIMP_TARGET_LAYER_MASK,
"gimp_dnd_set_layer_mask_func",
"gimp_dnd_set_layer_mask_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_item_data,
gimp_dnd_set_item_data,
},
{
GIMP_TARGET_COMPONENT,
NULL,
NULL,
NULL,
NULL,
NULL,
},
{
GIMP_TARGET_VECTORS,
"gimp_dnd_set_vectors_func",
"gimp_dnd_set_vectors_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_item_data,
gimp_dnd_set_item_data,
},
{
GIMP_TARGET_BRUSH,
"gimp_dnd_set_brush_func",
"gimp_dnd_set_brush_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_data_data,
gimp_dnd_set_brush_data
},
{
GIMP_TARGET_PATTERN,
"gimp_dnd_set_pattern_func",
"gimp_dnd_set_pattern_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_data_data,
gimp_dnd_set_pattern_data
},
{
GIMP_TARGET_GRADIENT,
"gimp_dnd_set_gradient_func",
"gimp_dnd_set_gradient_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_data_data,
gimp_dnd_set_gradient_data
},
{
GIMP_TARGET_PALETTE,
"gimp_dnd_set_palette_func",
"gimp_dnd_set_palette_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_data_data,
gimp_dnd_set_palette_data
},
{
GIMP_TARGET_FONT,
"gimp_dnd_set_font_func",
"gimp_dnd_set_font_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_data_data,
gimp_dnd_set_font_data
},
{
GIMP_TARGET_BUFFER,
"gimp_dnd_set_buffer_func",
"gimp_dnd_set_buffer_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_data_data,
gimp_dnd_set_buffer_data
},
{
GIMP_TARGET_IMAGEFILE,
"gimp_dnd_set_imagefile_func",
"gimp_dnd_set_imagefile_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_data_data,
gimp_dnd_set_imagefile_data
},
{
GIMP_TARGET_TEMPLATE,
"gimp_dnd_set_template_func",
"gimp_dnd_set_template_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_data_data,
gimp_dnd_set_template_data
},
{
GIMP_TARGET_TOOL,
"gimp_dnd_set_tool_func",
"gimp_dnd_set_tool_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_data_data,
gimp_dnd_set_tool_data
},
{
GIMP_TARGET_DIALOG,
NULL,
NULL,
NULL,
NULL,
NULL
}
};
/********************************/
/* general data dnd functions */
/********************************/
static void
gimp_dnd_data_drag_begin (GtkWidget *widget,
GdkDragContext *context,
gpointer data)
{
GimpDndType data_type;
GCallback get_data_func;
gpointer get_data_data;
GtkWidget *icon_widget;
data_type = (GimpDndType) g_object_get_data (G_OBJECT (widget),
"gimp-dnd-get-data-type");
if (! data_type)
return;
get_data_func = (GCallback) g_object_get_data (G_OBJECT (widget),
"gimp-dnd-get-data-func");
get_data_data = (gpointer) g_object_get_data (G_OBJECT (widget),
"gimp-dnd-get-data-data");
if (! get_data_func)
return;
icon_widget = (* dnd_data_defs[data_type].get_icon_func) (widget,
get_data_func,
get_data_data);
if (icon_widget)
{
GtkWidget *frame;
GtkWidget *window;
window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_realize (window);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (window), frame);
gtk_widget_show (frame);
gtk_container_add (GTK_CONTAINER (frame), icon_widget);
gtk_widget_show (icon_widget);
g_object_set_data_full (G_OBJECT (widget),
"gimp-dnd-data-widget",
window,
(GDestroyNotify) gtk_widget_destroy);
gtk_drag_set_icon_widget (context, window,
DRAG_ICON_OFFSET, DRAG_ICON_OFFSET);
}
}
static void
gimp_dnd_data_drag_end (GtkWidget *widget,
GdkDragContext *context)
{
g_object_set_data (G_OBJECT (widget), "gimp-dnd-data-widget", NULL);
}
static void
gimp_dnd_data_drag_handle (GtkWidget *widget,
GdkDragContext *context,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer data)
{
GimpDndType data_type;
GCallback get_data_func;
gpointer get_data_data;
gint format;
guchar *vals;
gint length;
data_type =
(GimpDndType) g_object_get_data (G_OBJECT (widget),
"gimp-dnd-get-data-type");
if (! data_type)
return;
get_data_func =
(GCallback) g_object_get_data (G_OBJECT (widget),
"gimp-dnd-get-data-func");
get_data_data =
(gpointer) g_object_get_data (G_OBJECT (widget),
"gimp-dnd-get-data-data");
if (! get_data_func)
return;
vals = (* dnd_data_defs[data_type].get_data_func) (widget,
get_data_func,
get_data_data,
&format,
&length);
if (vals)
{
gtk_selection_data_set
(selection_data,
gdk_atom_intern (dnd_data_defs[data_type].target_entry.target, FALSE),
format, vals, length);
g_free (vals);
}
}
static void
gimp_dnd_data_drop_handle (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint time,
gpointer data)
{
GCallback set_data_func;
gpointer set_data_data;
GimpDndType data_type;
if (selection_data->length < 0)
return;
for (data_type = GIMP_DND_TYPE_NONE + 1;
data_type <= GIMP_DND_TYPE_LAST;
data_type++)
{
if (dnd_data_defs[data_type].target_entry.info == info)
{
g_print ("gimp_dnd_data_drop_handle(%s)\n",
dnd_data_defs[data_type].target_entry.target);
set_data_func = (GCallback)
g_object_get_data (G_OBJECT (widget),
dnd_data_defs[data_type].set_data_func_name);
set_data_data =
g_object_get_data (G_OBJECT (widget),
dnd_data_defs[data_type].set_data_data_name);
if (! set_data_func)
return;
(* dnd_data_defs[data_type].set_data_func) (widget,
set_data_func,
set_data_data,
selection_data->data,
selection_data->format,
selection_data->length);
return;
}
}
}
static void
gimp_dnd_data_source_set (GimpDndType data_type,
GtkWidget *widget,
GCallback get_data_func,
gpointer get_data_data)
{
gboolean drag_connected;
drag_connected =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
"gimp-dnd-drag-connected"));
if (! drag_connected)
{
g_signal_connect (widget, "drag_begin",
G_CALLBACK (gimp_dnd_data_drag_begin),
NULL);
g_signal_connect (widget, "drag_end",
G_CALLBACK (gimp_dnd_data_drag_end),
NULL);
g_signal_connect (widget, "drag_data_get",
G_CALLBACK (gimp_dnd_data_drag_handle),
NULL);
g_object_set_data (G_OBJECT (widget), "gimp-dnd-drag-connected",
GINT_TO_POINTER (TRUE));
}
g_object_set_data (G_OBJECT (widget), "gimp-dnd-get-data-type",
(gpointer) data_type);
g_object_set_data (G_OBJECT (widget), "gimp-dnd-get-data-func",
get_data_func);
g_object_set_data (G_OBJECT (widget), "gimp-dnd-get-data-data",
get_data_data);
}
static void
gimp_dnd_data_source_unset (GtkWidget *widget)
{
gboolean drag_connected;
drag_connected =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
"gimp-dnd-drag-connected"));
if (! drag_connected)
return;
g_object_set_data (G_OBJECT (widget), "gimp-dnd-get-data-type", NULL);
g_object_set_data (G_OBJECT (widget), "gimp-dnd-get-data-func", NULL);
g_object_set_data (G_OBJECT (widget), "gimp-dnd-get-data-data", NULL);
}
static void
gimp_dnd_data_dest_add (GimpDndType data_type,
GtkWidget *widget,
gpointer set_data_func,
gpointer set_data_data)
{
GtkTargetList *target_list;
gboolean drop_connected;
/* set a default drag dest if not already done */
if (! g_object_get_data (G_OBJECT (widget), "gtk-drag-dest"))
gtk_drag_dest_set (widget, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
drop_connected =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
"gimp-dnd-drop-connected"));
if (! drop_connected)
{
g_signal_connect (widget, "drag_data_received",
G_CALLBACK (gimp_dnd_data_drop_handle),
NULL);
g_object_set_data (G_OBJECT (widget), "gimp-dnd-drop-connected",
GINT_TO_POINTER (TRUE));
}
g_object_set_data (G_OBJECT (widget),
dnd_data_defs[data_type].set_data_func_name,
set_data_func);
g_object_set_data (G_OBJECT (widget),
dnd_data_defs[data_type].set_data_data_name,
set_data_data);
target_list = gtk_drag_dest_get_target_list (widget);
if (target_list)
{
gtk_target_list_add_table (target_list,
&dnd_data_defs[data_type].target_entry, 1);
}
else
{
target_list = gtk_target_list_new (&dnd_data_defs[data_type].target_entry,
1);
gtk_drag_dest_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
}
}
static void
gimp_dnd_data_dest_remove (GimpDndType data_type,
GtkWidget *widget)
{
GtkTargetList *target_list;
gboolean drop_connected;
drop_connected =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
"gimp-dnd-drop-connected"));
if (! drop_connected)
return;
g_object_set_data (G_OBJECT (widget),
dnd_data_defs[data_type].set_data_func_name,
NULL);
g_object_set_data (G_OBJECT (widget),
dnd_data_defs[data_type].set_data_data_name,
NULL);
target_list = gtk_drag_dest_get_target_list (widget);
if (target_list)
{
GdkAtom atom;
atom = gdk_atom_intern (dnd_data_defs[data_type].target_entry.target,
TRUE);
if (atom != GDK_NONE)
gtk_target_list_remove (target_list, atom);
}
}
/************************/
/* file dnd functions */
/************************/
static void
gimp_dnd_set_file_data (GtkWidget *widget,
GCallback set_file_func,
gpointer set_file_data,
guchar *vals,
gint format,
gint length)
{
GList *files = NULL;
gchar *buffer;
if (format != 8)
{
g_warning ("Received invalid file data\n");
return;
}
buffer = (gchar *) vals;
g_print ("%s: raw buffer >>%s<<\n", G_GNUC_FUNCTION, buffer);
{
gchar name_buffer[1024];
while (*buffer && (buffer - (gchar *) vals < length))
{
gchar *name = name_buffer;
gint len = 0;
while ((*buffer != 0) && (*buffer != '\n') && len < 1024)
{
*name++ = *buffer++;
len++;
}
if (len == 0)
break;
if (*(name - 1) == 0xd) /* gmc uses RETURN+NEWLINE as delimiter */
*(name - 1) = '\0';
else
*name = '\0';
name = name_buffer;
if (name && strlen (name) > 2)
files = g_list_append (files, g_strdup (name));
if (*buffer)
buffer++;
}
}
if (files)
{
(* (GimpDndDropFileFunc) set_file_func) (widget, files,
set_file_data);
g_list_foreach (files, (GFunc) g_free, NULL);
g_list_free (files);
}
}
void
gimp_dnd_file_dest_add (GtkWidget *widget,
GimpDndDropFileFunc set_file_func,
gpointer data)
{
gimp_dnd_data_dest_add (GIMP_DND_TYPE_NETSCAPE_URL, widget,
G_CALLBACK (set_file_func),
data);
gimp_dnd_data_dest_add (GIMP_DND_TYPE_TEXT_PLAIN, widget,
G_CALLBACK (set_file_func),
data);
gimp_dnd_data_dest_add (GIMP_DND_TYPE_URI_LIST, widget,
G_CALLBACK (set_file_func),
data);
}
void
gimp_dnd_file_dest_remove (GtkWidget *widget)
{
gimp_dnd_data_dest_remove (GIMP_DND_TYPE_URI_LIST, widget);
gimp_dnd_data_dest_remove (GIMP_DND_TYPE_TEXT_PLAIN, widget);
gimp_dnd_data_dest_remove (GIMP_DND_TYPE_NETSCAPE_URL, widget);
}
/* the next two functions are straight cut'n'paste from glib/glib/gconvert.c,
* except that gimp_unescape_uri_string() does not try to UTF-8 validate
* the unescaped result.
*/
static int
unescape_character (const char *scanner)
{
int first_digit;
int second_digit;
first_digit = g_ascii_xdigit_value (scanner[0]);
if (first_digit < 0)
return -1;
second_digit = g_ascii_xdigit_value (scanner[1]);
if (second_digit < 0)
return -1;
return (first_digit << 4) | second_digit;
}
static gchar *
gimp_unescape_uri_string (const char *escaped,
int len,
const char *illegal_escaped_characters,
gboolean ascii_must_not_be_escaped)
{
const gchar *in, *in_end;
gchar *out, *result;
int c;
if (escaped == NULL)
return NULL;
if (len < 0)
len = strlen (escaped);
result = g_malloc (len + 1);
out = result;
for (in = escaped, in_end = escaped + len; in < in_end; in++)
{
c = *in;
if (c == '%')
{
/* catch partial escape sequences past the end of the substring */
if (in + 3 > in_end)
break;
c = unescape_character (in + 1);
/* catch bad escape sequences and NUL characters */
if (c <= 0)
break;
/* catch escaped ASCII */
if (ascii_must_not_be_escaped && c <= 0x7F)
break;
/* catch other illegal escaped characters */
if (strchr (illegal_escaped_characters, c) != NULL)
break;
in += 2;
}
*out++ = c;
}
g_assert (out - result <= len);
*out = '\0';
if (in != in_end)
{
g_free (result);
return NULL;
}
return result;
}
void
gimp_dnd_open_files (GtkWidget *widget,
GList *files,
gpointer data)
{
GList *list;
for (list = files; list; list = g_list_next (list))
{
const gchar *dnd_crap;
gchar *filename;
gchar *uri = NULL;
dnd_crap = (const gchar *) list->data;
g_print ("%s: trying to convert \"%s\" to an uri...\n", G_GNUC_FUNCTION,
dnd_crap);
filename = g_filename_from_uri (dnd_crap, NULL, NULL);
if (filename) /* if we got a correctly encoded "file:" uri */
{
uri = g_filename_to_uri (filename, NULL, NULL);
g_free (filename);
}
else /* else to evil things... */
{
filename = (gchar *) dnd_crap;
if (! strncmp (dnd_crap, "file://", strlen ("file://")))
{
filename += strlen ("file://");
}
else if (! strncmp (dnd_crap, "file:", strlen ("file:")))
{
filename += strlen ("file:");
}
if (filename != (gchar *) dnd_crap)
{
/* try if we got a "file:" uri in the local filename encoding */
gchar *unescaped_filename;
if (strstr (filename, "%"))
{
unescaped_filename = gimp_unescape_uri_string (filename, -1,
"/", FALSE);
}
else
{
unescaped_filename = g_strdup (filename);
}
uri = g_filename_to_uri (unescaped_filename, NULL, NULL);
g_free (unescaped_filename);
}
else
{
/* otherwise try the crap passed anyway, in case it's
* a "http:" or whatever uri a plug-in might handle
*/
uri = g_strdup (dnd_crap);
}
}
g_print ("%s: ...trying to open resulting uri \"%s\"\n",
G_GNUC_FUNCTION, uri);
{
GimpImage *gimage;
GimpPDBStatusType status;
GError *error = NULL;
gimage = file_open_with_display (the_gimp, uri,
&status, &error);
if (! gimage && status != GIMP_PDB_CANCEL)
{
gchar *filename;
filename = file_utils_uri_to_utf8_filename (uri);
g_message (_("Opening '%s' failed:\n\n%s"),
filename, error->message);
g_clear_error (&error);
g_free (filename);
}
}
g_free (uri);
}
}
/*************************/
/* color dnd functions */
/*************************/
static GtkWidget *
gimp_dnd_get_color_icon (GtkWidget *widget,
GCallback get_color_func,
gpointer get_color_data)
{
GtkWidget *color_area;
GimpRGB color;
(* (GimpDndDragColorFunc) get_color_func) (widget, &color,
get_color_data);
color_area = gimp_color_area_new (&color, TRUE, 0);
gtk_widget_set_size_request (color_area, DRAG_PREVIEW_SIZE, DRAG_PREVIEW_SIZE);
return color_area;
}
static guchar *
gimp_dnd_get_color_data (GtkWidget *widget,
GCallback get_color_func,
gpointer get_color_data,
gint *format,
gint *length)
{
guint16 *vals;
GimpRGB color;
guchar r, g, b, a;
(* (GimpDndDragColorFunc) get_color_func) (widget, &color,
get_color_data);
vals = g_new (guint16, 4);
gimp_rgba_get_uchar (&color, &r, &g, &b, &a);
vals[0] = r + (r << 8);
vals[1] = g + (g << 8);
vals[2] = b + (b << 8);
vals[3] = a + (a << 8);
*format = 16;
*length = 8;
return (guchar *) vals;
}
static void
gimp_dnd_set_color_data (GtkWidget *widget,
GCallback set_color_func,
gpointer set_color_data,
guchar *vals,
gint format,
gint length)
{
guint16 *color_vals;
GimpRGB color;
if ((format != 16) || (length != 8))
{
g_warning ("Received invalid color data\n");
return;
}
color_vals = (guint16 *) vals;
gimp_rgba_set_uchar (&color,
(guchar) (color_vals[0] >> 8),
(guchar) (color_vals[1] >> 8),
(guchar) (color_vals[2] >> 8),
(guchar) (color_vals[3] >> 8));
(* (GimpDndDropColorFunc) set_color_func) (widget, &color,
set_color_data);
}
void
gimp_dnd_color_source_set (GtkWidget *widget,
GimpDndDragColorFunc get_color_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_TYPE_COLOR, widget,
G_CALLBACK (get_color_func),
data);
}
void
gimp_dnd_color_dest_add (GtkWidget *widget,
GimpDndDropColorFunc set_color_func,
gpointer data)
{
gimp_dnd_data_dest_add (GIMP_DND_TYPE_COLOR, widget,
G_CALLBACK (set_color_func),
data);
}
void
gimp_dnd_color_dest_remove (GtkWidget *widget)
{
gimp_dnd_data_dest_remove (GIMP_DND_TYPE_COLOR, widget);
}
/*******************************************/
/* GimpViewable (by GType) dnd functions */
/*******************************************/
static GtkWidget *
gimp_dnd_get_viewable_icon (GtkWidget *widget,
GCallback get_viewable_func,
gpointer get_viewable_data)
{
GtkWidget *preview;
GimpViewable *viewable;
viewable = (* (GimpDndDragViewableFunc) get_viewable_func) (widget,
get_viewable_data);
if (! viewable)
return NULL;
preview = gimp_preview_new (viewable, DRAG_PREVIEW_SIZE, 0, TRUE);
return preview;
}
static GimpDndType
gimp_dnd_data_type_get_by_g_type (GType type)
{
GimpDndType dnd_type = GIMP_DND_TYPE_NONE;
if (g_type_is_a (type, GIMP_TYPE_IMAGE))
{
dnd_type = GIMP_DND_TYPE_IMAGE;
}
else if (g_type_is_a (type, GIMP_TYPE_LAYER))
{
dnd_type = GIMP_DND_TYPE_LAYER;
}
else if (g_type_is_a (type, GIMP_TYPE_LAYER_MASK))
{
dnd_type = GIMP_DND_TYPE_LAYER_MASK;
}
else if (g_type_is_a (type, GIMP_TYPE_CHANNEL))
{
dnd_type = GIMP_DND_TYPE_CHANNEL;
}
else if (g_type_is_a (type, GIMP_TYPE_VECTORS))
{
dnd_type = GIMP_DND_TYPE_VECTORS;
}
else if (g_type_is_a (type, GIMP_TYPE_BRUSH))
{
dnd_type = GIMP_DND_TYPE_BRUSH;
}
else if (g_type_is_a (type, GIMP_TYPE_PATTERN))
{
dnd_type = GIMP_DND_TYPE_PATTERN;
}
else if (g_type_is_a (type, GIMP_TYPE_GRADIENT))
{
dnd_type = GIMP_DND_TYPE_GRADIENT;
}
else if (g_type_is_a (type, GIMP_TYPE_PALETTE))
{
dnd_type = GIMP_DND_TYPE_PALETTE;
}
else if (g_type_is_a (type, GIMP_TYPE_FONT))
{
dnd_type = GIMP_DND_TYPE_FONT;
}
else if (g_type_is_a (type, GIMP_TYPE_BUFFER))
{
dnd_type = GIMP_DND_TYPE_BUFFER;
}
else if (g_type_is_a (type, GIMP_TYPE_IMAGEFILE))
{
dnd_type = GIMP_DND_TYPE_IMAGEFILE;
}
else if (g_type_is_a (type, GIMP_TYPE_TEMPLATE))
{
dnd_type = GIMP_DND_TYPE_TEMPLATE;
}
else if (g_type_is_a (type, GIMP_TYPE_TOOL_INFO))
{
dnd_type = GIMP_DND_TYPE_TOOL;
}
return dnd_type;
}
gboolean
gimp_dnd_drag_source_set_by_type (GtkWidget *widget,
GdkModifierType start_button_mask,
GType type,
GdkDragAction actions)
{
GimpDndType dnd_type;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
dnd_type = gimp_dnd_data_type_get_by_g_type (type);
if (dnd_type == GIMP_DND_TYPE_NONE)
return FALSE;
gtk_drag_source_set (widget, start_button_mask,
&dnd_data_defs[dnd_type].target_entry,
1,
actions);
return TRUE;
}
gboolean
gimp_dnd_drag_dest_set_by_type (GtkWidget *widget,
GtkDestDefaults flags,
GType type,
GdkDragAction actions)
{
GimpDndType dnd_type;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
dnd_type = gimp_dnd_data_type_get_by_g_type (type);
if (dnd_type == GIMP_DND_TYPE_NONE)
return FALSE;
gtk_drag_dest_set (widget, flags,
&dnd_data_defs[dnd_type].target_entry,
1,
actions);
return TRUE;
}
gboolean
gimp_dnd_viewable_source_set (GtkWidget *widget,
GType type,
GimpDndDragViewableFunc get_viewable_func,
gpointer data)
{
GimpDndType dnd_type;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (get_viewable_func != NULL, FALSE);
dnd_type = gimp_dnd_data_type_get_by_g_type (type);
if (dnd_type == GIMP_DND_TYPE_NONE)
return FALSE;
gimp_dnd_data_source_set (dnd_type, widget,
G_CALLBACK (get_viewable_func),
data);
return TRUE;
}
gboolean
gimp_dnd_viewable_source_unset (GtkWidget *widget,
GType type)
{
GimpDndType dnd_type;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
dnd_type = gimp_dnd_data_type_get_by_g_type (type);
if (dnd_type == GIMP_DND_TYPE_NONE)
return FALSE;
gimp_dnd_data_source_unset (widget);
return TRUE;
}
gboolean
gimp_dnd_viewable_dest_add (GtkWidget *widget,
GType type,
GimpDndDropViewableFunc set_viewable_func,
gpointer data)
{
GimpDndType dnd_type;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (set_viewable_func != NULL, FALSE);
dnd_type = gimp_dnd_data_type_get_by_g_type (type);
if (dnd_type == GIMP_DND_TYPE_NONE)
return FALSE;
gimp_dnd_data_dest_add (dnd_type, widget,
G_CALLBACK (set_viewable_func),
data);
return TRUE;
}
gboolean
gimp_dnd_viewable_dest_remove (GtkWidget *widget,
GType type)
{
GimpDndType dnd_type;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
dnd_type = gimp_dnd_data_type_get_by_g_type (type);
if (dnd_type == GIMP_DND_TYPE_NONE)
return FALSE;
gimp_dnd_data_dest_remove (dnd_type, widget);
return TRUE;
}
GimpViewable *
gimp_dnd_get_drag_data (GtkWidget *widget)
{
GimpDndType data_type;
GimpDndDragViewableFunc get_data_func;
gpointer get_data_data;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
data_type =
(GimpDndType) g_object_get_data (G_OBJECT (widget),
"gimp-dnd-get-data-type");
if (! data_type)
return NULL;
get_data_func =
(GimpDndDragViewableFunc) g_object_get_data (G_OBJECT (widget),
"gimp-dnd-get-data-func");
get_data_data =
(gpointer) g_object_get_data (G_OBJECT (widget),
"gimp-dnd-get-data-data");
if (! get_data_func)
return NULL;
return (GimpViewable *) (* get_data_func) (widget, get_data_data);
}
/*************************/
/* image dnd functions */
/*************************/
static guchar *
gimp_dnd_get_image_data (GtkWidget *widget,
GCallback get_image_func,
gpointer get_image_data,
gint *format,
gint *length)
{
GimpImage *gimage;
gchar *id;
gimage = (GimpImage *)
(* (GimpDndDragViewableFunc) get_image_func) (widget, get_image_data);
if (! gimage)
return NULL;
id = g_strdup_printf ("%d", gimp_image_get_ID (gimage));
*format = 8;
*length = strlen (id) + 1;
return (guchar *) id;
}
static void
gimp_dnd_set_image_data (GtkWidget *widget,
GCallback set_image_func,
gpointer set_image_data,
guchar *vals,
gint format,
gint length)
{
GimpImage *gimage;
gchar *id;
gint ID;
if ((format != 8) || (length < 1))
{
g_warning ("%s(): received invalid image ID data", G_GNUC_FUNCTION);
return;
}
id = (gchar *) vals;
ID = atoi (id);
if (! ID)
return;
gimage = gimp_image_get_by_ID (the_gimp, ID);
if (gimage)
(* (GimpDndDropViewableFunc) set_image_func) (widget,
GIMP_VIEWABLE (gimage),
set_image_data);
}
/************************/
/* item dnd functions */
/************************/
static guchar *
gimp_dnd_get_item_data (GtkWidget *widget,
GCallback get_item_func,
gpointer get_item_data,
gint *format,
gint *length)
{
GimpItem *item;
gchar *id;
item = (GimpItem *)
(* (GimpDndDragViewableFunc) get_item_func) (widget, get_item_data);
if (! item)
return NULL;
id = g_strdup_printf ("%d", gimp_item_get_ID (item));
*format = 8;
*length = strlen (id) + 1;
return (guchar *) id;
}
static void
gimp_dnd_set_item_data (GtkWidget *widget,
GCallback set_item_func,
gpointer set_item_data,
guchar *vals,
gint format,
gint length)
{
GimpItem *item;
gchar *id;
gint ID;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid item ID data");
return;
}
id = (gchar *) vals;
ID = atoi (id);
if (! ID)
return;
item = gimp_item_get_by_ID (the_gimp, ID);
if (item)
(* (GimpDndDropViewableFunc) set_item_func) (widget,
GIMP_VIEWABLE (item),
set_item_data);
}
/****************************/
/* GimpData dnd functions */
/****************************/
static guchar *
gimp_dnd_get_data_data (GtkWidget *widget,
GCallback get_data_func,
gpointer get_data_data,
gint *format,
gint *length)
{
GimpData *data;
gchar *name;
data = (GimpData *)
(* (GimpDndDragViewableFunc) get_data_func) (widget, get_data_data);
if (! data)
return NULL;
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (data)));
if (! name)
return NULL;
*format = 8;
*length = strlen (name) + 1;
return (guchar *) name;
}
/*************************/
/* brush dnd functions */
/*************************/
static void
gimp_dnd_set_brush_data (GtkWidget *widget,
GCallback set_brush_func,
gpointer set_brush_data,
guchar *vals,
gint format,
gint length)
{
GimpBrush *brush;
gchar *name;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid brush data\n");
return;
}
name = (gchar *) vals;
g_print ("gimp_dnd_set_brush_data() got >>%s<<\n", name);
if (strcmp (name, "Standard") == 0)
brush = GIMP_BRUSH (gimp_brush_get_standard ());
else
brush = (GimpBrush *)
gimp_container_get_child_by_name (the_gimp->brush_factory->container,
name);
if (brush)
(* (GimpDndDropViewableFunc) set_brush_func) (widget,
GIMP_VIEWABLE (brush),
set_brush_data);
}
/***************************/
/* pattern dnd functions */
/***************************/
static void
gimp_dnd_set_pattern_data (GtkWidget *widget,
GCallback set_pattern_func,
gpointer set_pattern_data,
guchar *vals,
gint format,
gint length)
{
GimpPattern *pattern;
gchar *name;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid pattern data\n");
return;
}
name = (gchar *) vals;
if (strcmp (name, "Standard") == 0)
pattern = GIMP_PATTERN (gimp_pattern_get_standard ());
else
pattern = (GimpPattern *)
gimp_container_get_child_by_name (the_gimp->pattern_factory->container,
name);
if (pattern)
(* (GimpDndDropViewableFunc) set_pattern_func) (widget,
GIMP_VIEWABLE (pattern),
set_pattern_data);
}
/****************************/
/* gradient dnd functions */
/****************************/
static void
gimp_dnd_set_gradient_data (GtkWidget *widget,
GCallback set_gradient_func,
gpointer set_gradient_data,
guchar *vals,
gint format,
gint length)
{
GimpGradient *gradient;
gchar *name;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid gradient data\n");
return;
}
name = (gchar *) vals;
if (strcmp (name, "Standard") == 0)
gradient = GIMP_GRADIENT (gimp_gradient_get_standard ());
else
gradient = (GimpGradient *)
gimp_container_get_child_by_name (the_gimp->gradient_factory->container,
name);
if (gradient)
(* (GimpDndDropViewableFunc) set_gradient_func) (widget,
GIMP_VIEWABLE (gradient),
set_gradient_data);
}
/***************************/
/* palette dnd functions */
/***************************/
static void
gimp_dnd_set_palette_data (GtkWidget *widget,
GCallback set_palette_func,
gpointer set_palette_data,
guchar *vals,
gint format,
gint length)
{
GimpPalette *palette;
gchar *name;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid palette data\n");
return;
}
name = (gchar *) vals;
if (strcmp (name, "Standard") == 0)
palette = GIMP_PALETTE (gimp_palette_get_standard ());
else
palette = (GimpPalette *)
gimp_container_get_child_by_name (the_gimp->palette_factory->container,
name);
if (palette)
(* (GimpDndDropViewableFunc) set_palette_func) (widget,
GIMP_VIEWABLE (palette),
set_palette_data);
}
/************************/
/* font dnd functions */
/************************/
static void
gimp_dnd_set_font_data (GtkWidget *widget,
GCallback set_font_func,
gpointer set_font_data,
guchar *vals,
gint format,
gint length)
{
GimpFont *font;
gchar *name;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid font data\n");
return;
}
name = (gchar *) vals;
if (strcmp (name, "Standard") == 0)
font = gimp_font_get_standard ();
else
font = (GimpFont *)
gimp_container_get_child_by_name (the_gimp->fonts, name);
if (font)
(* (GimpDndDropViewableFunc) set_font_func) (widget,
GIMP_VIEWABLE (font),
set_font_data);
}
/**************************/
/* buffer dnd functions */
/**************************/
static void
gimp_dnd_set_buffer_data (GtkWidget *widget,
GCallback set_buffer_func,
gpointer set_buffer_data,
guchar *vals,
gint format,
gint length)
{
GimpBuffer *buffer;
gchar *name;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid buffer data\n");
return;
}
name = (gchar *) vals;
buffer = (GimpBuffer *)
gimp_container_get_child_by_name (the_gimp->named_buffers, name);
if (buffer)
(* (GimpDndDropViewableFunc) set_buffer_func) (widget,
GIMP_VIEWABLE (buffer),
set_buffer_data);
}
/*****************************/
/* imagefile dnd functions */
/*****************************/
static void
gimp_dnd_set_imagefile_data (GtkWidget *widget,
GCallback set_imagefile_func,
gpointer set_imagefile_data,
guchar *vals,
gint format,
gint length)
{
GimpImagefile *imagefile;
gchar *name;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid buffer data\n");
return;
}
name = (gchar *) vals;
imagefile = (GimpImagefile *)
gimp_container_get_child_by_name (the_gimp->documents, name);
if (imagefile)
(* (GimpDndDropViewableFunc) set_imagefile_func) (widget,
GIMP_VIEWABLE (imagefile),
set_imagefile_data);
}
/*****************************/
/* template dnd functions */
/*****************************/
static void
gimp_dnd_set_template_data (GtkWidget *widget,
GCallback set_template_func,
gpointer set_template_data,
guchar *vals,
gint format,
gint length)
{
GimpTemplate *template;
gchar *name;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid buffer data\n");
return;
}
name = (gchar *) vals;
template = (GimpTemplate *)
gimp_container_get_child_by_name (the_gimp->templates, name);
if (template)
(* (GimpDndDropViewableFunc) set_template_func) (widget,
GIMP_VIEWABLE (template),
set_template_data);
}
/************************/
/* tool dnd functions */
/************************/
static void
gimp_dnd_set_tool_data (GtkWidget *widget,
GCallback set_tool_func,
gpointer set_tool_data,
guchar *vals,
gint format,
gint length)
{
GimpToolInfo *tool_info;
gchar *name;
if ((format != 8) || (length < 1))
{
g_warning ("Received invalid tool data\n");
return;
}
name = (gchar *) vals;
g_print ("gimp_dnd_set_tool_data() got >>%s<<\n", name);
if (strcmp (name, "gimp-standard-tool") == 0)
tool_info = gimp_tool_info_get_standard (the_gimp);
else
tool_info = (GimpToolInfo *)
gimp_container_get_child_by_name (the_gimp->tool_info_list,
name);
if (tool_info)
(* (GimpDndDropViewableFunc) set_tool_func) (widget,
GIMP_VIEWABLE (tool_info),
set_tool_data);
}
Reference in New Issue View Git Blame Copy Permalink