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

removed all brush, pattern, gradient and palette DND functions because 

2001-02-20  Michael Natterer  <mitch@gimp.org>

	* app/gimpdnd.[ch]: removed all brush, pattern, gradient and palette
	DND functions because there are generic GimpViewable DND functions
	now.

	* app/disp_callbacks.[ch]
	* app/interface.c: changed accordingly.
This commit is contained in:
Michael Natterer 2001-02-19 23:37:49 +00:00 committed by Michael Natterer
parent 8710fa8941
commit 1edef6d18f
14 changed files with 239 additions and 917 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@ -1,3 +1,12 @@
2001-02-20 Michael Natterer <mitch@gimp.org>
* app/gimpdnd.[ch]: removed all brush, pattern, gradient and palette
DND functions because there are generic GimpViewable DND functions
now.
* app/disp_callbacks.[ch]
* app/interface.c: changed accordingly.
2001-02-19 Michael Natterer <mitch@gimp.org>
* app/commands.[ch]

12
app/disp_callbacks.c
View File

@ -1024,9 +1024,13 @@ gdisplay_drop_color (GtkWidget *widget,
}
void
gdisplay_drop_pattern (GtkWidget *widget,
GimpPattern *pattern,
gpointer data)
gdisplay_drop_viewable (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
gdisplay_bucket_fill (widget, PATTERN_BUCKET_FILL, NULL, pattern->mask, data);
if (GIMP_IS_PATTERN (viewable))
{
gdisplay_bucket_fill (widget, PATTERN_BUCKET_FILL, NULL,
GIMP_PATTERN (viewable)->mask, data);
}
}

4
app/disp_callbacks.h
View File

@ -58,8 +58,8 @@ gboolean gdisplay_drag_drop (GtkWidget *widget,
void gdisplay_drop_color (GtkWidget *widget,
const GimpRGB *color,
gpointer data);
void gdisplay_drop_pattern (GtkWidget *widget,
GimpPattern *pattern,
void gdisplay_drop_viewable (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);

12
app/display/gimpdisplay-callbacks.c
View File

@ -1024,9 +1024,13 @@ gdisplay_drop_color (GtkWidget *widget,
}
void
gdisplay_drop_pattern (GtkWidget *widget,
GimpPattern *pattern,
gpointer data)
gdisplay_drop_viewable (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
gdisplay_bucket_fill (widget, PATTERN_BUCKET_FILL, NULL, pattern->mask, data);
if (GIMP_IS_PATTERN (viewable))
{
gdisplay_bucket_fill (widget, PATTERN_BUCKET_FILL, NULL,
GIMP_PATTERN (viewable)->mask, data);
}
}

4
app/display/gimpdisplay-callbacks.h
View File

@ -58,8 +58,8 @@ gboolean gdisplay_drag_drop (GtkWidget *widget,
void gdisplay_drop_color (GtkWidget *widget,
const GimpRGB *color,
gpointer data);
void gdisplay_drop_pattern (GtkWidget *widget,
GimpPattern *pattern,
void gdisplay_drop_viewable (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);

12
app/display/gimpdisplayshell-callbacks.c
View File

@ -1024,9 +1024,13 @@ gdisplay_drop_color (GtkWidget *widget,
}
void
gdisplay_drop_pattern (GtkWidget *widget,
GimpPattern *pattern,
gpointer data)
gdisplay_drop_viewable (GtkWidget *widget,
GimpViewable *viewable,
gpointer data)
{
gdisplay_bucket_fill (widget, PATTERN_BUCKET_FILL, NULL, pattern->mask, data);
if (GIMP_IS_PATTERN (viewable))
{
gdisplay_bucket_fill (widget, PATTERN_BUCKET_FILL, NULL,
GIMP_PATTERN (viewable)->mask, data);
}
}

4
app/display/gimpdisplayshell-callbacks.h
View File

@ -58,8 +58,8 @@ gboolean gdisplay_drag_drop (GtkWidget *widget,
void gdisplay_drop_color (GtkWidget *widget,
const GimpRGB *color,
gpointer data);
void gdisplay_drop_pattern (GtkWidget *widget,
GimpPattern *pattern,
void gdisplay_drop_viewable (GtkWidget *widget,
GimpViewable *viewable,
gpointer data);

5
app/display/gimpdisplayshell-draw.c
View File

@ -29,6 +29,7 @@
#include "gimpdnd.h"
#include "gimphelp.h"
#include "gimpimage.h"
#include "gimppattern.h"
#include "gimprc.h"
#include "interface.h"
#include "menus.h"
@ -178,7 +179,9 @@ create_display_shell (GDisplay *gdisp,
GTK_SIGNAL_FUNC (gdisplay_drag_drop),
gdisp);
gimp_dnd_color_dest_set (gdisp->shell, gdisplay_drop_color, gdisp);
gimp_dnd_pattern_dest_set (gdisp->shell, gdisplay_drop_pattern, gdisp);
gimp_dnd_viewable_dest_set (gdisp->shell,
GIMP_TYPE_PATTERN,
gdisplay_drop_viewable, gdisp);
if (! image_popup_menu)
menus_get_image_menu (&image_popup_menu, &image_accel_group);

5
app/display/gimpdisplayshell.c
View File

@ -29,6 +29,7 @@
#include "gimpdnd.h"
#include "gimphelp.h"
#include "gimpimage.h"
#include "gimppattern.h"
#include "gimprc.h"
#include "interface.h"
#include "menus.h"
@ -178,7 +179,9 @@ create_display_shell (GDisplay *gdisp,
GTK_SIGNAL_FUNC (gdisplay_drag_drop),
gdisp);
gimp_dnd_color_dest_set (gdisp->shell, gdisplay_drop_color, gdisp);
gimp_dnd_pattern_dest_set (gdisp->shell, gdisplay_drop_pattern, gdisp);
gimp_dnd_viewable_dest_set (gdisp->shell,
GIMP_TYPE_PATTERN,
gdisplay_drop_viewable, gdisp);
if (! image_popup_menu)
menus_get_image_menu (&image_popup_menu, &image_accel_group);

439
app/gimpdnd.c
View File

@ -121,24 +121,9 @@ static guchar * gimp_dnd_get_drawable_data (GtkWidget *widget,
gpointer get_drawable_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_brush_data (GtkWidget *widget,
GtkSignalFunc get_brush_func,
gpointer get_brush_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_pattern_data (GtkWidget *widget,
GtkSignalFunc get_pattern_func,
gpointer get_pattern_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_gradient_data (GtkWidget *widget,
GtkSignalFunc get_gradient_func,
gpointer get_gradient_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_palette_data (GtkWidget *widget,
GtkSignalFunc get_palette_func,
gpointer get_palette_data,
static guchar * gimp_dnd_get_data_data (GtkWidget *widget,
GtkSignalFunc get_data_func,
gpointer get_data_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_tool_data (GtkWidget *widget,
@ -255,7 +240,7 @@ static GimpDndDataDef dnd_data_defs[] =
"gimp_dnd_set_brush_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_brush_data,
gimp_dnd_get_data_data,
gimp_dnd_set_brush_data
},
@ -266,7 +251,7 @@ static GimpDndDataDef dnd_data_defs[] =
"gimp_dnd_set_pattern_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_pattern_data,
gimp_dnd_get_data_data,
gimp_dnd_set_pattern_data
},
@ -277,7 +262,7 @@ static GimpDndDataDef dnd_data_defs[] =
"gimp_dnd_set_gradient_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_gradient_data,
gimp_dnd_get_data_data,
gimp_dnd_set_gradient_data
},
@ -288,7 +273,7 @@ static GimpDndDataDef dnd_data_defs[] =
"gimp_dnd_set_palette_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_palette_data,
gimp_dnd_get_data_data,
gimp_dnd_set_palette_data
},
@ -744,6 +729,9 @@ gimp_gtk_drag_source_set_by_type (GtkWidget *widget,
const GtkTargetEntry *target_table = NULL;
guint n_targets = 0;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (type == GIMP_TYPE_LAYER)
{
target_table = layer_target_table;
@ -803,6 +791,9 @@ gimp_gtk_drag_dest_set_by_type (GtkWidget *widget,
const GtkTargetEntry *target_table = NULL;
guint n_targets = 0;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (type == GIMP_TYPE_LAYER)
{
target_table = layer_target_table;
@ -858,52 +849,49 @@ gimp_dnd_viewable_source_set (GtkWidget *widget,
GimpDndDragViewableFunc get_viewable_func,
gpointer data)
{
GimpDndDataType dnd_type;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (get_viewable_func != NULL);
if (type == GIMP_TYPE_LAYER)
{
gimp_dnd_layer_source_set (widget,
(GimpDndDragDrawableFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_LAYER;
}
else if (type == GIMP_TYPE_CHANNEL)
{
gimp_dnd_channel_source_set (widget,
(GimpDndDragDrawableFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_CHANNEL;
}
else if (type == GIMP_TYPE_LAYER_MASK)
{
gimp_dnd_layer_mask_source_set (widget,
(GimpDndDragDrawableFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_LAYER_MASK;
}
else if (type == GIMP_TYPE_BRUSH)
{
gimp_dnd_brush_source_set (widget,
(GimpDndDragBrushFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_BRUSH;
}
else if (type == GIMP_TYPE_PATTERN)
{
gimp_dnd_pattern_source_set (widget,
(GimpDndDragPatternFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_PATTERN;
}
else if (type == GIMP_TYPE_GRADIENT)
{
gimp_dnd_gradient_source_set (widget,
(GimpDndDragGradientFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_GRADIENT;
}
else if (type == GIMP_TYPE_PALETTE)
{
gimp_dnd_palette_source_set (widget,
(GimpDndDragPaletteFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_PALETTE;
}
else
{
g_warning ("%s(): unsupported GtkType", G_GNUC_FUNCTION);
return;
}
gimp_dnd_data_source_set (dnd_type, widget,
GTK_SIGNAL_FUNC (get_viewable_func),
data);
}
void
@ -912,90 +900,92 @@ gimp_dnd_viewable_dest_set (GtkWidget *widget,
GimpDndDropViewableFunc set_viewable_func,
gpointer data)
{
GimpDndDataType dnd_type;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (set_viewable_func != NULL);
if (type == GIMP_TYPE_LAYER)
{
gimp_dnd_layer_dest_set (widget,
(GimpDndDropDrawableFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_LAYER;
}
else if (type == GIMP_TYPE_CHANNEL)
{
gimp_dnd_channel_dest_set (widget,
(GimpDndDropDrawableFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_CHANNEL;
}
else if (type == GIMP_TYPE_LAYER_MASK)
{
gimp_dnd_layer_mask_dest_set (widget,
(GimpDndDropDrawableFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_LAYER_MASK;
}
else if (type == GIMP_TYPE_BRUSH)
{
gimp_dnd_brush_dest_set (widget,
(GimpDndDropBrushFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_BRUSH;
}
else if (type == GIMP_TYPE_PATTERN)
{
gimp_dnd_pattern_dest_set (widget,
(GimpDndDropPatternFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_PATTERN;
}
else if (type == GIMP_TYPE_GRADIENT)
{
gimp_dnd_gradient_dest_set (widget,
(GimpDndDropGradientFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_GRADIENT;
}
else if (type == GIMP_TYPE_PALETTE)
{
gimp_dnd_palette_dest_set (widget,
(GimpDndDropPaletteFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_PALETTE;
}
else
{
g_warning ("%s(): unsupported GtkType", G_GNUC_FUNCTION);
return;
}
gimp_dnd_data_dest_set (dnd_type, widget,
GTK_SIGNAL_FUNC (set_viewable_func),
data);
}
void
gimp_dnd_viewable_dest_unset (GtkWidget *widget,
GtkType type)
{
GimpDndDataType dnd_type;
if (type == GIMP_TYPE_LAYER)
{
gimp_dnd_layer_dest_unset (widget);
dnd_type = GIMP_DND_DATA_LAYER;
}
else if (type == GIMP_TYPE_CHANNEL)
{
gimp_dnd_channel_dest_unset (widget);
dnd_type = GIMP_DND_DATA_CHANNEL;
}
else if (type == GIMP_TYPE_LAYER_MASK)
{
gimp_dnd_layer_mask_dest_unset (widget);
dnd_type = GIMP_DND_DATA_LAYER_MASK;
}
else if (type == GIMP_TYPE_BRUSH)
{
gimp_dnd_brush_dest_unset (widget);
dnd_type = GIMP_DND_DATA_BRUSH;
}
else if (type == GIMP_TYPE_PATTERN)
{
gimp_dnd_pattern_dest_unset (widget);
dnd_type = GIMP_DND_DATA_PATTERN;
}
else if (type == GIMP_TYPE_GRADIENT)
{
gimp_dnd_gradient_dest_unset (widget);
dnd_type = GIMP_DND_DATA_GRADIENT;
}
else if (type == GIMP_TYPE_PALETTE)
{
gimp_dnd_palette_dest_unset (widget);
dnd_type = GIMP_DND_DATA_PALETTE;
}
else
{
g_warning ("%s(): unsupported GtkType", G_GNUC_FUNCTION);
return;
}
gimp_dnd_data_dest_unset (dnd_type, widget);
}
@ -1014,7 +1004,7 @@ gimp_dnd_get_drawable_data (GtkWidget *widget,
gchar *id;
drawable =
(* (GimpDndDragDrawableFunc) get_drawable_func) (widget, get_drawable_data);
(* (GimpDndDragViewableFunc) get_drawable_func) (widget, get_drawable_data);
if (! drawable)
return NULL;
@ -1055,109 +1045,32 @@ gimp_dnd_set_drawable_data (GtkWidget *widget,
drawable = gimp_drawable_get_by_ID (ID);
if (drawable)
(* (GimpDndDropDrawableFunc) set_drawable_func) (widget, drawable,
(* (GimpDndDropViewableFunc) set_drawable_func) (widget, drawable,
set_drawable_data);
}
void
gimp_dnd_layer_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_LAYER, widget,
GTK_SIGNAL_FUNC (get_drawable_func),
data);
}
void
gimp_dnd_layer_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_LAYER, widget,
GTK_SIGNAL_FUNC (set_drawable_func),
data);
}
void
gimp_dnd_layer_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_LAYER, widget);
}
void
gimp_dnd_channel_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_CHANNEL, widget,
GTK_SIGNAL_FUNC (get_drawable_func),
data);
}
void
gimp_dnd_channel_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_CHANNEL, widget,
GTK_SIGNAL_FUNC (set_drawable_func),
data);
}
void
gimp_dnd_channel_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_CHANNEL, widget);
}
void
gimp_dnd_layer_mask_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_LAYER_MASK, widget,
GTK_SIGNAL_FUNC (get_drawable_func),
data);
}
void
gimp_dnd_layer_mask_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_LAYER_MASK, widget,
GTK_SIGNAL_FUNC (set_drawable_func),
data);
}
void
gimp_dnd_layer_mask_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_LAYER_MASK, widget);
}
/*************************/
/* brush dnd functions */
/*************************/
/****************************/
/* GimpData dnd functions */
/****************************/
static guchar *
gimp_dnd_get_brush_data (GtkWidget *widget,
GtkSignalFunc get_brush_func,
gpointer get_brush_data,
gint *format,
gint *length)
gimp_dnd_get_data_data (GtkWidget *widget,
GtkSignalFunc get_data_func,
gpointer get_data_data,
gint *format,
gint *length)
{
GimpBrush *brush;
gchar *name;
GimpData *data;
gchar *name;
brush = (* (GimpDndDragBrushFunc) get_brush_func) (widget, get_brush_data);
data = (GimpData *)
(* (GimpDndDragViewableFunc) get_data_func) (widget, get_data_data);
if (! brush)
if (! data)
return NULL;
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (brush)));
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (data)));
if (! name)
return NULL;
@ -1168,6 +1081,11 @@ gimp_dnd_get_brush_data (GtkWidget *widget,
return (guchar *) name;
}
/*************************/
/* brush dnd functions */
/*************************/
static void
gimp_dnd_set_brush_data (GtkWidget *widget,
GtkSignalFunc set_brush_func,
@ -1195,33 +1113,9 @@ gimp_dnd_set_brush_data (GtkWidget *widget,
name);
if (brush)
(* (GimpDndDropBrushFunc) set_brush_func) (widget, brush, set_brush_data);
}
void
gimp_dnd_brush_source_set (GtkWidget *widget,
GimpDndDragBrushFunc get_brush_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_BRUSH, widget,
GTK_SIGNAL_FUNC (get_brush_func),
data);
}
void
gimp_dnd_brush_dest_set (GtkWidget *widget,
GimpDndDropBrushFunc set_brush_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_BRUSH, widget,
GTK_SIGNAL_FUNC (set_brush_func),
data);
}
void
gimp_dnd_brush_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_BRUSH, widget);
(* (GimpDndDropViewableFunc) set_brush_func) (widget,
GIMP_VIEWABLE (brush),
set_brush_data);
}
@ -1229,30 +1123,6 @@ gimp_dnd_brush_dest_unset (GtkWidget *widget)
/* pattern dnd functions */
/***************************/
static guchar *
gimp_dnd_get_pattern_data (GtkWidget *widget,
GtkSignalFunc get_pattern_func,
gpointer get_pattern_data,
gint *format,
gint *length)
{
GimpPattern *pattern;
gchar *name;
pattern = (* (GimpDndDragPatternFunc) get_pattern_func) (widget,
get_pattern_data);
if (! pattern)
return NULL;
name = g_strdup (GIMP_OBJECT (pattern)->name);
*format = 8;
*length = strlen (name) + 1;
return (guchar *) name;
}
static void
gimp_dnd_set_pattern_data (GtkWidget *widget,
GtkSignalFunc set_pattern_func,
@ -1280,34 +1150,9 @@ gimp_dnd_set_pattern_data (GtkWidget *widget,
name);
if (pattern)
(* (GimpDndDropPatternFunc) set_pattern_func) (widget, pattern,
set_pattern_data);
}
void
gimp_dnd_pattern_source_set (GtkWidget *widget,
GimpDndDragPatternFunc get_pattern_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_PATTERN, widget,
GTK_SIGNAL_FUNC (get_pattern_func),
data);
}
void
gimp_dnd_pattern_dest_set (GtkWidget *widget,
GimpDndDropPatternFunc set_pattern_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_PATTERN, widget,
GTK_SIGNAL_FUNC (set_pattern_func),
data);
}
void
gimp_dnd_pattern_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_PATTERN, widget);
(* (GimpDndDropViewableFunc) set_pattern_func) (widget,
GIMP_VIEWABLE (pattern),
set_pattern_data);
}
@ -1315,30 +1160,6 @@ gimp_dnd_pattern_dest_unset (GtkWidget *widget)
/* gradient dnd functions */
/****************************/
static guchar *
gimp_dnd_get_gradient_data (GtkWidget *widget,
GtkSignalFunc get_gradient_func,
gpointer get_gradient_data,
gint *format,
gint *length)
{
GimpGradient *gradient;
gchar *name;
gradient =
(* (GimpDndDragGradientFunc) get_gradient_func) (widget, get_gradient_data);
if (! gradient)
return NULL;
name = g_strdup (GIMP_OBJECT (gradient)->name);
*format = 8;
*length = strlen (name) + 1;
return (guchar *) name;
}
static void
gimp_dnd_set_gradient_data (GtkWidget *widget,
GtkSignalFunc set_gradient_func,
@ -1366,65 +1187,16 @@ gimp_dnd_set_gradient_data (GtkWidget *widget,
name);
if (gradient)
(* (GimpDndDropGradientFunc) set_gradient_func) (widget, gradient,
(* (GimpDndDropViewableFunc) set_gradient_func) (widget,
GIMP_VIEWABLE (gradient),
set_gradient_data);
}
void
gimp_dnd_gradient_source_set (GtkWidget *widget,
GimpDndDragGradientFunc get_gradient_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_GRADIENT, widget,
GTK_SIGNAL_FUNC (get_gradient_func),
data);
}
void
gimp_dnd_gradient_dest_set (GtkWidget *widget,
GimpDndDropGradientFunc set_gradient_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_GRADIENT, widget,
GTK_SIGNAL_FUNC (set_gradient_func),
data);
}
void
gimp_dnd_gradient_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_GRADIENT, widget);
}
/***************************/
/* palette dnd functions */
/***************************/
static guchar *
gimp_dnd_get_palette_data (GtkWidget *widget,
GtkSignalFunc get_palette_func,
gpointer get_palette_data,
gint *format,
gint *length)
{
GimpPalette *palette;
gchar *name;
palette = (* (GimpDndDragPaletteFunc) get_palette_func) (widget,
get_palette_data);
if (! palette)
return NULL;
name = g_strdup (GIMP_OBJECT (palette)->name);
*format = 8;
*length = strlen (name) + 1;
return (guchar *) name;
}
static void
gimp_dnd_set_palette_data (GtkWidget *widget,
GtkSignalFunc set_palette_func,
@ -1452,34 +1224,9 @@ gimp_dnd_set_palette_data (GtkWidget *widget,
name);
if (palette)
(* (GimpDndDropPaletteFunc) set_palette_func) (widget, palette,
set_palette_data);
}
void
gimp_dnd_palette_source_set (GtkWidget *widget,
GimpDndDragPaletteFunc get_palette_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_PALETTE, widget,
GTK_SIGNAL_FUNC (get_palette_func),
data);
}
void
gimp_dnd_palette_dest_set (GtkWidget *widget,
GimpDndDropPaletteFunc set_palette_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_PALETTE, widget,
GTK_SIGNAL_FUNC (set_palette_func),
data);
}
void
gimp_dnd_palette_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_PALETTE, widget);
(* (GimpDndDropViewableFunc) set_palette_func) (widget,
GIMP_VIEWABLE (palette),
set_palette_data);
}

103
app/gimpdnd.h
View File

@ -140,107 +140,6 @@ void gimp_dnd_viewable_dest_unset (GtkWidget *widget,
GtkType type);
/* drawable dnd functions */
typedef void (* GimpDndDropDrawableFunc) (GtkWidget *widget,
GimpDrawable *drawable,
gpointer data);
typedef GimpDrawable * (* GimpDndDragDrawableFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_layer_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data);
void gimp_dnd_layer_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data);
void gimp_dnd_layer_dest_unset (GtkWidget *widget);
void gimp_dnd_channel_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data);
void gimp_dnd_channel_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data);
void gimp_dnd_channel_dest_unset (GtkWidget *widget);
void gimp_dnd_layer_mask_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data);
void gimp_dnd_layer_mask_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data);
void gimp_dnd_layer_mask_dest_unset (GtkWidget *widget);
/* brush dnd functions */
typedef void (* GimpDndDropBrushFunc) (GtkWidget *widget,
GimpBrush *brush,
gpointer data);
typedef GimpBrush * (* GimpDndDragBrushFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_brush_source_set (GtkWidget *widget,
GimpDndDragBrushFunc get_brush_func,
gpointer data);
void gimp_dnd_brush_dest_set (GtkWidget *widget,
GimpDndDropBrushFunc set_brush_func,
gpointer data);
void gimp_dnd_brush_dest_unset (GtkWidget *widget);
/* pattern dnd functions */
typedef void (* GimpDndDropPatternFunc) (GtkWidget *widget,
GimpPattern *pattern,
gpointer data);
typedef GimpPattern * (* GimpDndDragPatternFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_pattern_source_set (GtkWidget *widget,
GimpDndDragPatternFunc get_pattern_func,
gpointer data);
void gimp_dnd_pattern_dest_set (GtkWidget *widget,
GimpDndDropPatternFunc set_pattern_func,
gpointer data);
void gimp_dnd_pattern_dest_unset (GtkWidget *widget);
/* gradient dnd functions */
typedef void (* GimpDndDropGradientFunc) (GtkWidget *widget,
GimpGradient *gradient,
gpointer data);
typedef GimpGradient * (* GimpDndDragGradientFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_gradient_source_set (GtkWidget *widget,
GimpDndDragGradientFunc get_gradient_func,
gpointer data);
void gimp_dnd_gradient_dest_set (GtkWidget *widget,
GimpDndDropGradientFunc set_gradient_func,
gpointer data);
void gimp_dnd_gradient_dest_unset (GtkWidget *widget);
/* palette dnd functions */
typedef void (* GimpDndDropPaletteFunc) (GtkWidget *widget,
GimpPalette *palette,
gpointer data);
typedef GimpPalette * (* GimpDndDragPaletteFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_palette_source_set (GtkWidget *widget,
GimpDndDragPaletteFunc get_palette_func,
gpointer data);
void gimp_dnd_palette_dest_set (GtkWidget *widget,
GimpDndDropPaletteFunc set_palette_func,
gpointer data);
void gimp_dnd_palette_dest_unset (GtkWidget *widget);
/* tool dnd functions */
typedef void (* GimpDndDropToolFunc) (GtkWidget *widget,
@ -258,7 +157,7 @@ void gimp_dnd_tool_dest_set (GtkWidget *widget,
void gimp_dnd_tool_dest_unset (GtkWidget *widget);
/* drawable dnd functions */
/* OLD drawable dnd functions */
void gimp_dnd_set_drawable_preview_icon (GtkWidget *widget,
GdkDragContext *context,

5
app/interface.c
View File

@ -29,6 +29,7 @@
#include "gimpdnd.h"
#include "gimphelp.h"
#include "gimpimage.h"
#include "gimppattern.h"
#include "gimprc.h"
#include "interface.h"
#include "menus.h"
@ -178,7 +179,9 @@ create_display_shell (GDisplay *gdisp,
GTK_SIGNAL_FUNC (gdisplay_drag_drop),
gdisp);
gimp_dnd_color_dest_set (gdisp->shell, gdisplay_drop_color, gdisp);
gimp_dnd_pattern_dest_set (gdisp->shell, gdisplay_drop_pattern, gdisp);
gimp_dnd_viewable_dest_set (gdisp->shell,
GIMP_TYPE_PATTERN,
gdisplay_drop_viewable, gdisp);
if (! image_popup_menu)
menus_get_image_menu (&image_popup_menu, &image_accel_group);

439
app/widgets/gimpdnd.c
View File

@ -121,24 +121,9 @@ static guchar * gimp_dnd_get_drawable_data (GtkWidget *widget,
gpointer get_drawable_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_brush_data (GtkWidget *widget,
GtkSignalFunc get_brush_func,
gpointer get_brush_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_pattern_data (GtkWidget *widget,
GtkSignalFunc get_pattern_func,
gpointer get_pattern_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_gradient_data (GtkWidget *widget,
GtkSignalFunc get_gradient_func,
gpointer get_gradient_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_palette_data (GtkWidget *widget,
GtkSignalFunc get_palette_func,
gpointer get_palette_data,
static guchar * gimp_dnd_get_data_data (GtkWidget *widget,
GtkSignalFunc get_data_func,
gpointer get_data_data,
gint *format,
gint *length);
static guchar * gimp_dnd_get_tool_data (GtkWidget *widget,
@ -255,7 +240,7 @@ static GimpDndDataDef dnd_data_defs[] =
"gimp_dnd_set_brush_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_brush_data,
gimp_dnd_get_data_data,
gimp_dnd_set_brush_data
},
@ -266,7 +251,7 @@ static GimpDndDataDef dnd_data_defs[] =
"gimp_dnd_set_pattern_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_pattern_data,
gimp_dnd_get_data_data,
gimp_dnd_set_pattern_data
},
@ -277,7 +262,7 @@ static GimpDndDataDef dnd_data_defs[] =
"gimp_dnd_set_gradient_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_gradient_data,
gimp_dnd_get_data_data,
gimp_dnd_set_gradient_data
},
@ -288,7 +273,7 @@ static GimpDndDataDef dnd_data_defs[] =
"gimp_dnd_set_palette_data",
gimp_dnd_get_viewable_icon,
gimp_dnd_get_palette_data,
gimp_dnd_get_data_data,
gimp_dnd_set_palette_data
},
@ -744,6 +729,9 @@ gimp_gtk_drag_source_set_by_type (GtkWidget *widget,
const GtkTargetEntry *target_table = NULL;
guint n_targets = 0;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (type == GIMP_TYPE_LAYER)
{
target_table = layer_target_table;
@ -803,6 +791,9 @@ gimp_gtk_drag_dest_set_by_type (GtkWidget *widget,
const GtkTargetEntry *target_table = NULL;
guint n_targets = 0;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
if (type == GIMP_TYPE_LAYER)
{
target_table = layer_target_table;
@ -858,52 +849,49 @@ gimp_dnd_viewable_source_set (GtkWidget *widget,
GimpDndDragViewableFunc get_viewable_func,
gpointer data)
{
GimpDndDataType dnd_type;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (get_viewable_func != NULL);
if (type == GIMP_TYPE_LAYER)
{
gimp_dnd_layer_source_set (widget,
(GimpDndDragDrawableFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_LAYER;
}
else if (type == GIMP_TYPE_CHANNEL)
{
gimp_dnd_channel_source_set (widget,
(GimpDndDragDrawableFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_CHANNEL;
}
else if (type == GIMP_TYPE_LAYER_MASK)
{
gimp_dnd_layer_mask_source_set (widget,
(GimpDndDragDrawableFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_LAYER_MASK;
}
else if (type == GIMP_TYPE_BRUSH)
{
gimp_dnd_brush_source_set (widget,
(GimpDndDragBrushFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_BRUSH;
}
else if (type == GIMP_TYPE_PATTERN)
{
gimp_dnd_pattern_source_set (widget,
(GimpDndDragPatternFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_PATTERN;
}
else if (type == GIMP_TYPE_GRADIENT)
{
gimp_dnd_gradient_source_set (widget,
(GimpDndDragGradientFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_GRADIENT;
}
else if (type == GIMP_TYPE_PALETTE)
{
gimp_dnd_palette_source_set (widget,
(GimpDndDragPaletteFunc) get_viewable_func,
data);
dnd_type = GIMP_DND_DATA_PALETTE;
}
else
{
g_warning ("%s(): unsupported GtkType", G_GNUC_FUNCTION);
return;
}
gimp_dnd_data_source_set (dnd_type, widget,
GTK_SIGNAL_FUNC (get_viewable_func),
data);
}
void
@ -912,90 +900,92 @@ gimp_dnd_viewable_dest_set (GtkWidget *widget,
GimpDndDropViewableFunc set_viewable_func,
gpointer data)
{
GimpDndDataType dnd_type;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (set_viewable_func != NULL);
if (type == GIMP_TYPE_LAYER)
{
gimp_dnd_layer_dest_set (widget,
(GimpDndDropDrawableFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_LAYER;
}
else if (type == GIMP_TYPE_CHANNEL)
{
gimp_dnd_channel_dest_set (widget,
(GimpDndDropDrawableFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_CHANNEL;
}
else if (type == GIMP_TYPE_LAYER_MASK)
{
gimp_dnd_layer_mask_dest_set (widget,
(GimpDndDropDrawableFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_LAYER_MASK;
}
else if (type == GIMP_TYPE_BRUSH)
{
gimp_dnd_brush_dest_set (widget,
(GimpDndDropBrushFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_BRUSH;
}
else if (type == GIMP_TYPE_PATTERN)
{
gimp_dnd_pattern_dest_set (widget,
(GimpDndDropPatternFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_PATTERN;
}
else if (type == GIMP_TYPE_GRADIENT)
{
gimp_dnd_gradient_dest_set (widget,
(GimpDndDropGradientFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_GRADIENT;
}
else if (type == GIMP_TYPE_PALETTE)
{
gimp_dnd_palette_dest_set (widget,
(GimpDndDropPaletteFunc) set_viewable_func,
data);
dnd_type = GIMP_DND_DATA_PALETTE;
}
else
{
g_warning ("%s(): unsupported GtkType", G_GNUC_FUNCTION);
return;
}
gimp_dnd_data_dest_set (dnd_type, widget,
GTK_SIGNAL_FUNC (set_viewable_func),
data);
}
void
gimp_dnd_viewable_dest_unset (GtkWidget *widget,
GtkType type)
{
GimpDndDataType dnd_type;
if (type == GIMP_TYPE_LAYER)
{
gimp_dnd_layer_dest_unset (widget);
dnd_type = GIMP_DND_DATA_LAYER;
}
else if (type == GIMP_TYPE_CHANNEL)
{
gimp_dnd_channel_dest_unset (widget);
dnd_type = GIMP_DND_DATA_CHANNEL;
}
else if (type == GIMP_TYPE_LAYER_MASK)
{
gimp_dnd_layer_mask_dest_unset (widget);
dnd_type = GIMP_DND_DATA_LAYER_MASK;
}
else if (type == GIMP_TYPE_BRUSH)
{
gimp_dnd_brush_dest_unset (widget);
dnd_type = GIMP_DND_DATA_BRUSH;
}
else if (type == GIMP_TYPE_PATTERN)
{
gimp_dnd_pattern_dest_unset (widget);
dnd_type = GIMP_DND_DATA_PATTERN;
}
else if (type == GIMP_TYPE_GRADIENT)
{
gimp_dnd_gradient_dest_unset (widget);
dnd_type = GIMP_DND_DATA_GRADIENT;
}
else if (type == GIMP_TYPE_PALETTE)
{
gimp_dnd_palette_dest_unset (widget);
dnd_type = GIMP_DND_DATA_PALETTE;
}
else
{
g_warning ("%s(): unsupported GtkType", G_GNUC_FUNCTION);
return;
}
gimp_dnd_data_dest_unset (dnd_type, widget);
}
@ -1014,7 +1004,7 @@ gimp_dnd_get_drawable_data (GtkWidget *widget,
gchar *id;
drawable =
(* (GimpDndDragDrawableFunc) get_drawable_func) (widget, get_drawable_data);
(* (GimpDndDragViewableFunc) get_drawable_func) (widget, get_drawable_data);
if (! drawable)
return NULL;
@ -1055,109 +1045,32 @@ gimp_dnd_set_drawable_data (GtkWidget *widget,
drawable = gimp_drawable_get_by_ID (ID);
if (drawable)
(* (GimpDndDropDrawableFunc) set_drawable_func) (widget, drawable,
(* (GimpDndDropViewableFunc) set_drawable_func) (widget, drawable,
set_drawable_data);
}
void
gimp_dnd_layer_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_LAYER, widget,
GTK_SIGNAL_FUNC (get_drawable_func),
data);
}
void
gimp_dnd_layer_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_LAYER, widget,
GTK_SIGNAL_FUNC (set_drawable_func),
data);
}
void
gimp_dnd_layer_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_LAYER, widget);
}
void
gimp_dnd_channel_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_CHANNEL, widget,
GTK_SIGNAL_FUNC (get_drawable_func),
data);
}
void
gimp_dnd_channel_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_CHANNEL, widget,
GTK_SIGNAL_FUNC (set_drawable_func),
data);
}
void
gimp_dnd_channel_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_CHANNEL, widget);
}
void
gimp_dnd_layer_mask_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_LAYER_MASK, widget,
GTK_SIGNAL_FUNC (get_drawable_func),
data);
}
void
gimp_dnd_layer_mask_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_LAYER_MASK, widget,
GTK_SIGNAL_FUNC (set_drawable_func),
data);
}
void
gimp_dnd_layer_mask_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_LAYER_MASK, widget);
}
/*************************/
/* brush dnd functions */
/*************************/
/****************************/
/* GimpData dnd functions */
/****************************/
static guchar *
gimp_dnd_get_brush_data (GtkWidget *widget,
GtkSignalFunc get_brush_func,
gpointer get_brush_data,
gint *format,
gint *length)
gimp_dnd_get_data_data (GtkWidget *widget,
GtkSignalFunc get_data_func,
gpointer get_data_data,
gint *format,
gint *length)
{
GimpBrush *brush;
gchar *name;
GimpData *data;
gchar *name;
brush = (* (GimpDndDragBrushFunc) get_brush_func) (widget, get_brush_data);
data = (GimpData *)
(* (GimpDndDragViewableFunc) get_data_func) (widget, get_data_data);
if (! brush)
if (! data)
return NULL;
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (brush)));
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (data)));
if (! name)
return NULL;
@ -1168,6 +1081,11 @@ gimp_dnd_get_brush_data (GtkWidget *widget,
return (guchar *) name;
}
/*************************/
/* brush dnd functions */
/*************************/
static void
gimp_dnd_set_brush_data (GtkWidget *widget,
GtkSignalFunc set_brush_func,
@ -1195,33 +1113,9 @@ gimp_dnd_set_brush_data (GtkWidget *widget,
name);
if (brush)
(* (GimpDndDropBrushFunc) set_brush_func) (widget, brush, set_brush_data);
}
void
gimp_dnd_brush_source_set (GtkWidget *widget,
GimpDndDragBrushFunc get_brush_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_BRUSH, widget,
GTK_SIGNAL_FUNC (get_brush_func),
data);
}
void
gimp_dnd_brush_dest_set (GtkWidget *widget,
GimpDndDropBrushFunc set_brush_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_BRUSH, widget,
GTK_SIGNAL_FUNC (set_brush_func),
data);
}
void
gimp_dnd_brush_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_BRUSH, widget);
(* (GimpDndDropViewableFunc) set_brush_func) (widget,
GIMP_VIEWABLE (brush),
set_brush_data);
}
@ -1229,30 +1123,6 @@ gimp_dnd_brush_dest_unset (GtkWidget *widget)
/* pattern dnd functions */
/***************************/
static guchar *
gimp_dnd_get_pattern_data (GtkWidget *widget,
GtkSignalFunc get_pattern_func,
gpointer get_pattern_data,
gint *format,
gint *length)
{
GimpPattern *pattern;
gchar *name;
pattern = (* (GimpDndDragPatternFunc) get_pattern_func) (widget,
get_pattern_data);
if (! pattern)
return NULL;
name = g_strdup (GIMP_OBJECT (pattern)->name);
*format = 8;
*length = strlen (name) + 1;
return (guchar *) name;
}
static void
gimp_dnd_set_pattern_data (GtkWidget *widget,
GtkSignalFunc set_pattern_func,
@ -1280,34 +1150,9 @@ gimp_dnd_set_pattern_data (GtkWidget *widget,
name);
if (pattern)
(* (GimpDndDropPatternFunc) set_pattern_func) (widget, pattern,
set_pattern_data);
}
void
gimp_dnd_pattern_source_set (GtkWidget *widget,
GimpDndDragPatternFunc get_pattern_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_PATTERN, widget,
GTK_SIGNAL_FUNC (get_pattern_func),
data);
}
void
gimp_dnd_pattern_dest_set (GtkWidget *widget,
GimpDndDropPatternFunc set_pattern_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_PATTERN, widget,
GTK_SIGNAL_FUNC (set_pattern_func),
data);
}
void
gimp_dnd_pattern_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_PATTERN, widget);
(* (GimpDndDropViewableFunc) set_pattern_func) (widget,
GIMP_VIEWABLE (pattern),
set_pattern_data);
}
@ -1315,30 +1160,6 @@ gimp_dnd_pattern_dest_unset (GtkWidget *widget)
/* gradient dnd functions */
/****************************/
static guchar *
gimp_dnd_get_gradient_data (GtkWidget *widget,
GtkSignalFunc get_gradient_func,
gpointer get_gradient_data,
gint *format,
gint *length)
{
GimpGradient *gradient;
gchar *name;
gradient =
(* (GimpDndDragGradientFunc) get_gradient_func) (widget, get_gradient_data);
if (! gradient)
return NULL;
name = g_strdup (GIMP_OBJECT (gradient)->name);
*format = 8;
*length = strlen (name) + 1;
return (guchar *) name;
}
static void
gimp_dnd_set_gradient_data (GtkWidget *widget,
GtkSignalFunc set_gradient_func,
@ -1366,65 +1187,16 @@ gimp_dnd_set_gradient_data (GtkWidget *widget,
name);
if (gradient)
(* (GimpDndDropGradientFunc) set_gradient_func) (widget, gradient,
(* (GimpDndDropViewableFunc) set_gradient_func) (widget,
GIMP_VIEWABLE (gradient),
set_gradient_data);
}
void
gimp_dnd_gradient_source_set (GtkWidget *widget,
GimpDndDragGradientFunc get_gradient_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_GRADIENT, widget,
GTK_SIGNAL_FUNC (get_gradient_func),
data);
}
void
gimp_dnd_gradient_dest_set (GtkWidget *widget,
GimpDndDropGradientFunc set_gradient_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_GRADIENT, widget,
GTK_SIGNAL_FUNC (set_gradient_func),
data);
}
void
gimp_dnd_gradient_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_GRADIENT, widget);
}
/***************************/
/* palette dnd functions */
/***************************/
static guchar *
gimp_dnd_get_palette_data (GtkWidget *widget,
GtkSignalFunc get_palette_func,
gpointer get_palette_data,
gint *format,
gint *length)
{
GimpPalette *palette;
gchar *name;
palette = (* (GimpDndDragPaletteFunc) get_palette_func) (widget,
get_palette_data);
if (! palette)
return NULL;
name = g_strdup (GIMP_OBJECT (palette)->name);
*format = 8;
*length = strlen (name) + 1;
return (guchar *) name;
}
static void
gimp_dnd_set_palette_data (GtkWidget *widget,
GtkSignalFunc set_palette_func,
@ -1452,34 +1224,9 @@ gimp_dnd_set_palette_data (GtkWidget *widget,
name);
if (palette)
(* (GimpDndDropPaletteFunc) set_palette_func) (widget, palette,
set_palette_data);
}
void
gimp_dnd_palette_source_set (GtkWidget *widget,
GimpDndDragPaletteFunc get_palette_func,
gpointer data)
{
gimp_dnd_data_source_set (GIMP_DND_DATA_PALETTE, widget,
GTK_SIGNAL_FUNC (get_palette_func),
data);
}
void
gimp_dnd_palette_dest_set (GtkWidget *widget,
GimpDndDropPaletteFunc set_palette_func,
gpointer data)
{
gimp_dnd_data_dest_set (GIMP_DND_DATA_PALETTE, widget,
GTK_SIGNAL_FUNC (set_palette_func),
data);
}
void
gimp_dnd_palette_dest_unset (GtkWidget *widget)
{
gimp_dnd_data_dest_unset (GIMP_DND_DATA_PALETTE, widget);
(* (GimpDndDropViewableFunc) set_palette_func) (widget,
GIMP_VIEWABLE (palette),
set_palette_data);
}

103
app/widgets/gimpdnd.h
View File

@ -140,107 +140,6 @@ void gimp_dnd_viewable_dest_unset (GtkWidget *widget,
GtkType type);
/* drawable dnd functions */
typedef void (* GimpDndDropDrawableFunc) (GtkWidget *widget,
GimpDrawable *drawable,
gpointer data);
typedef GimpDrawable * (* GimpDndDragDrawableFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_layer_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data);
void gimp_dnd_layer_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data);
void gimp_dnd_layer_dest_unset (GtkWidget *widget);
void gimp_dnd_channel_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data);
void gimp_dnd_channel_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data);
void gimp_dnd_channel_dest_unset (GtkWidget *widget);
void gimp_dnd_layer_mask_source_set (GtkWidget *widget,
GimpDndDragDrawableFunc get_drawable_func,
gpointer data);
void gimp_dnd_layer_mask_dest_set (GtkWidget *widget,
GimpDndDropDrawableFunc set_drawable_func,
gpointer data);
void gimp_dnd_layer_mask_dest_unset (GtkWidget *widget);
/* brush dnd functions */
typedef void (* GimpDndDropBrushFunc) (GtkWidget *widget,
GimpBrush *brush,
gpointer data);
typedef GimpBrush * (* GimpDndDragBrushFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_brush_source_set (GtkWidget *widget,
GimpDndDragBrushFunc get_brush_func,
gpointer data);
void gimp_dnd_brush_dest_set (GtkWidget *widget,
GimpDndDropBrushFunc set_brush_func,
gpointer data);
void gimp_dnd_brush_dest_unset (GtkWidget *widget);
/* pattern dnd functions */
typedef void (* GimpDndDropPatternFunc) (GtkWidget *widget,
GimpPattern *pattern,
gpointer data);
typedef GimpPattern * (* GimpDndDragPatternFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_pattern_source_set (GtkWidget *widget,
GimpDndDragPatternFunc get_pattern_func,
gpointer data);
void gimp_dnd_pattern_dest_set (GtkWidget *widget,
GimpDndDropPatternFunc set_pattern_func,
gpointer data);
void gimp_dnd_pattern_dest_unset (GtkWidget *widget);
/* gradient dnd functions */
typedef void (* GimpDndDropGradientFunc) (GtkWidget *widget,
GimpGradient *gradient,
gpointer data);
typedef GimpGradient * (* GimpDndDragGradientFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_gradient_source_set (GtkWidget *widget,
GimpDndDragGradientFunc get_gradient_func,
gpointer data);
void gimp_dnd_gradient_dest_set (GtkWidget *widget,
GimpDndDropGradientFunc set_gradient_func,
gpointer data);
void gimp_dnd_gradient_dest_unset (GtkWidget *widget);
/* palette dnd functions */
typedef void (* GimpDndDropPaletteFunc) (GtkWidget *widget,
GimpPalette *palette,
gpointer data);
typedef GimpPalette * (* GimpDndDragPaletteFunc) (GtkWidget *widget,
gpointer data);
void gimp_dnd_palette_source_set (GtkWidget *widget,
GimpDndDragPaletteFunc get_palette_func,
gpointer data);
void gimp_dnd_palette_dest_set (GtkWidget *widget,
GimpDndDropPaletteFunc set_palette_func,
gpointer data);
void gimp_dnd_palette_dest_unset (GtkWidget *widget);
/* tool dnd functions */
typedef void (* GimpDndDropToolFunc) (GtkWidget *widget,
@ -258,7 +157,7 @@ void gimp_dnd_tool_dest_set (GtkWidget *widget,
void gimp_dnd_tool_dest_unset (GtkWidget *widget);
/* drawable dnd functions */
/* OLD drawable dnd functions */
void gimp_dnd_set_drawable_preview_icon (GtkWidget *widget,
GdkDragContext *context,