callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
35907ff2f6c1d677f927967b4c0d09d6b51d6c6c
gimp/libgimp/gimpmenu.c
Michael Natterer ecb0b58439 Changed the semantics of GIMP_EXTENSION and (to some extent) of 
2003-06-19  Michael Natterer  <mitch@gimp.org>

	Changed the semantics of GIMP_EXTENSION and (to some extent)
	of GIMP_PLUGIN:

	The old meaning of EXTENSION was "I live in the toolbox" and
	PLUGIN meant "I take RUN-MODE,IMAGE,DRAWABLE args (but only if I
	am invoked interactively)". This is completely useless, since
	living in the toolbox means having "<Toolbox>" in the menu_path
	and taking RUN-MODE,IMAGE,DRAWABLE means just that, regardless of
	what type of procedure we are.

	The new meaning of GIMP_PLUGIN is just "I am an ordinary procedure,
	I am invoked, do my job and finish", while GIMP_EXTENSION means
	"I will install temporary procedures and I will keep running to
	keep them available".

	(A GIMP_EXTENSION *must* call gimp_extension_ack() now to tell the
	core that it's ready to run, or the core will block waiting for
	the message !!!).

	* configure.in: bumped version number to 1.3.16.

	* libgimpbase/gimpprotocol.h: increased protocol version number so
	old extensions will refuse to load.

	* app/gui/plug-in-commands.c (plug_in_run_cmd_callback): don't
	blindly pass RUN-MODE,IMAGE,DRAWABLE to GIMP_PLUGIN procedures but
	look at their parameters and pass them either RUN-MODE, or
	RUN-MODE,IMAGE, or RUN-MODE,IMAGE,DRAWABLE.

	* app/pdb/procedural_db.c: cleaned up, better error reporting,
	replaced an impossible error message by g_return_if_fail()

	* app/plug-in/plug-in-message.c (plug_in_handle_proc_install):
	better error messages.

	* app/plug-in/plug-in-params.c: allocate parameter arrays using
	g_new0() so we don't have to worry about uninitialized stuff
	later.

	* app/plug-in/plug-in-run.c (plug_in_run): wait for
	gimp_extension_ack() installation confirmation for ALL extensions,
	not just for automatically started ones.

	* app/plug-in/plug-ins.c: cleanup.

	* libgimp/gimp.[ch]: cleaned up and API-documented massively. Made
	all magic values given in the GPConfig message static and added
	accessor functions for them. Added gimp_tile_width()/height().
	Added new function gimp_extension_enable() which turns on
	asynchronous processing of temp_proc run requests without having
	to enter an endless gimp_extension_process() loop. Moved all
	private functions to the end of the file. Added tons of
	g_return_if_fail() all over the place.  Call gimp_run_procedure2()
	from gimp_run_procedure() instead of duplicating the
	code. Indentation, spacing, stuff...

	* libgimp/gimptile.[ch]: removed gimp_tile_width()/height().

	* libgimp/gimpdrawable.c
	* libgimp/gimppixelrgn.c
	* libgimp/gimptile.c: use the gimp_tile_width()/height() accessor
	functions.

	* libgimp/gimp.def: added gimp_extension_enable.

	* libgimp/gimpmenu.c: removed evil code which connected to
	_readchannel manually and use gimp_extension_enable() for watching
	temp_procs.

	* plug-ins/helpbrowser/helpbrowser.c: removed the same evil code
	here and call gimp_extension_enable(). Call gimp_extension_ack()
	to let the core know that the temp_proc is installed.

	* plug-ins/script-fu/script-fu.c: made all procedures except the
	permanently running "extension_script_fu" ordinary GIMP_PLUGIN
	procedures.

	* plug-ins/common/curve_bend.c
	* plug-ins/common/plugindetails.c
	* plug-ins/common/screenshot.c
	* plug-ins/common/uniteditor.c
	* plug-ins/common/winclipboard.c
	* plug-ins/dbbrowser/dbbrowser.c
	* plug-ins/gfli/gfli.c
	* plug-ins/twain/twain.c
	* plug-ins/webbrowser/webbrowser.c
	* plug-ins/winsnap/winsnap.c: made them all ordinary GIMP_PLUGIN
	procedures and renamed them from "extension_*" to "plug_in_*".
	Random cleanups.

	* app/widgets/gimphelp.c
	* plug-ins/maze/maze_face.c: call "plug_in_web_browser" now.
2003-06-19 17:12:00 +00:00

1224 lines
33 KiB
C
Raw Blame History

/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimpmenu.c
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <string.h>
#ifdef __GNUC__
#warning GTK_DISABLE_DEPRECATED
#endif
#undef GTK_DISABLE_DEPRECATED
#include "gimp.h"
#include "gimpui.h"
#include "libgimp-intl.h"
#define MENU_THUMBNAIL_WIDTH 24
#define MENU_THUMBNAIL_HEIGHT 24
/* Copy data from temp_PDB call */
struct _GimpBrushData
{
guint idle_id;
gchar *name;
gdouble opacity;
gint spacing;
gint paint_mode;
gint width;
gint height;
guchar *brush_mask_data;
GimpRunBrushCallback callback;
gboolean closing;
gpointer data;
};
typedef struct _GimpBrushData GimpBrushData;
/* Copy data from temp_PDB call */
struct _GimpFontData
{
guint idle_id;
gchar *name;
GimpRunFontCallback callback;
gboolean closing;
gpointer data;
};
typedef struct _GimpFontData GimpFontData;
/* Copy data from temp_PDB call */
struct _GimpGradientData
{
guint idle_id;
gchar *name;
gint width;
gdouble *gradient_data;
GimpRunGradientCallback callback;
gboolean closing;
gpointer data;
};
typedef struct _GimpGradientData GimpGradientData;
/* Copy data from temp_PDB call */
struct _GimpPatternData
{
guint idle_id;
gchar *name;
gint width;
gint height;
gint bytes;
guchar *pattern_mask_data;
GimpRunPatternCallback callback;
gboolean closing;
gpointer data;
};
typedef struct _GimpPatternData GimpPatternData;
static void gimp_menu_callback (GtkWidget *widget,
gint32 *id);
static gboolean idle_brush_callback (GimpBrushData *bdata);
static gboolean idle_font_callback (GimpFontData *fdata);
static gboolean idle_gradient_callback (GimpGradientData *gdata);
static gboolean idle_pattern_callback (GimpPatternData *pdata);
static void temp_brush_invoker (gchar *name,
gint nparams,
GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
static gchar * gen_temp_plugin_name (void);
static void fill_preview_with_thumb (GtkWidget *widget,
gint32 drawable_ID,
gint width,
gint height);
static GHashTable *gbrush_ht = NULL;
static GHashTable *gfont_ht = NULL;
static GHashTable *ggradient_ht = NULL;
static GHashTable *gpattern_ht = NULL;
GtkWidget *
gimp_image_menu_new (GimpConstraintFunc constraint,
GimpMenuCallback callback,
gpointer data,
gint32 active_image)
{
GtkWidget *menu;
GtkWidget *menuitem;
gchar *name;
gchar *label;
gint32 *images;
gint nimages;
gint i, k;
menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (menu), "gimp_callback", (gpointer) callback);
g_object_set_data (G_OBJECT (menu), "gimp_callback_data", data);
images = gimp_image_list (&nimages);
for (i = 0, k = 0; i < nimages; i++)
if (!constraint || (* constraint) (images[i], -1, data))
{
name = gimp_image_get_name (images[i]);
label = g_strdup_printf ("%s-%d", name, images[i]);
g_free (name);
menuitem = gtk_menu_item_new_with_label (label);
g_signal_connect (menuitem, "activate",
G_CALLBACK (gimp_menu_callback),
&images[i]);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
g_free (label);
if (images[i] == active_image)
gtk_menu_set_active (GTK_MENU (menu), k);
k += 1;
}
if (k == 0)
{
menuitem = gtk_menu_item_new_with_label (_("None"));
gtk_widget_set_sensitive (menuitem, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
if (images)
{
if (active_image == -1)
active_image = images[0];
(* callback) (active_image, data);
}
return menu;
}
GtkWidget *
gimp_layer_menu_new (GimpConstraintFunc constraint,
GimpMenuCallback callback,
gpointer data,
gint32 active_layer)
{
GtkWidget *menu;
GtkWidget *menuitem;
gchar *name;
gchar *image_label;
gchar *label;
gint32 *images;
gint32 *layers;
gint32 layer;
gint nimages;
gint nlayers;
gint i, j, k;
menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (menu), "gimp_callback", callback);
g_object_set_data (G_OBJECT (menu), "gimp_callback_data", data);
layer = -1;
images = gimp_image_list (&nimages);
for (i = 0, k = 0; i < nimages; i++)
if (!constraint || (* constraint) (images[i], -1, data))
{
name = gimp_image_get_name (images[i]);
image_label = g_strdup_printf ("%s-%d", name, images[i]);
g_free (name);
layers = gimp_image_get_layers (images[i], &nlayers);
for (j = 0; j < nlayers; j++)
if (!constraint || (* constraint) (images[i], layers[j], data))
{
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *wcolor_box;
GtkWidget *wlabel;
name = gimp_layer_get_name (layers[j]);
label = g_strdup_printf ("%s/%s", image_label, name);
g_free (name);
menuitem = gtk_menu_item_new();
g_signal_connect (menuitem, "activate",
G_CALLBACK (gimp_menu_callback),
&layers[j]);
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (menuitem), hbox);
gtk_widget_show (hbox);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
wcolor_box = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_set_dither (GTK_PREVIEW (wcolor_box),
GDK_RGB_DITHER_MAX);
fill_preview_with_thumb (wcolor_box,
layers[j],
MENU_THUMBNAIL_WIDTH,
MENU_THUMBNAIL_HEIGHT);
gtk_widget_set_size_request (GTK_WIDGET (wcolor_box),
MENU_THUMBNAIL_WIDTH,
MENU_THUMBNAIL_HEIGHT);
gtk_container_add (GTK_CONTAINER (vbox), wcolor_box);
gtk_widget_show (wcolor_box);
wlabel = gtk_label_new (label);
gtk_misc_set_alignment (GTK_MISC (wlabel), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), wlabel, TRUE, TRUE, 4);
gtk_widget_show (wlabel);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
g_free (label);
if (layers[j] == active_layer)
{
layer = active_layer;
gtk_menu_set_active (GTK_MENU (menu), k);
}
else if (layer == -1)
layer = layers[j];
k += 1;
}
g_free (image_label);
}
g_free (images);
if (k == 0)
{
menuitem = gtk_menu_item_new_with_label (_("None"));
gtk_widget_set_sensitive (menuitem, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
if (layer != -1)
(* callback) (layer, data);
return menu;
}
GtkWidget *
gimp_channel_menu_new (GimpConstraintFunc constraint,
GimpMenuCallback callback,
gpointer data,
gint32 active_channel)
{
GtkWidget *menu;
GtkWidget *menuitem;
gchar *name;
gchar *image_label;
gchar *label;
gint32 *images;
gint32 *channels;
gint32 channel;
gint nimages;
gint nchannels;
gint i, j, k;
menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (menu), "gimp_callback", callback);
g_object_set_data (G_OBJECT (menu), "gimp_callback_data", data);
channel = -1;
images = gimp_image_list (&nimages);
for (i = 0, k = 0; i < nimages; i++)
if (!constraint || (* constraint) (images[i], -1, data))
{
name = gimp_image_get_name (images[i]);
image_label = g_strdup_printf ("%s-%d", name, images[i]);
g_free (name);
channels = gimp_image_get_channels (images[i], &nchannels);
for (j = 0; j < nchannels; j++)
if (!constraint || (* constraint) (images[i], channels[j], data))
{
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *wcolor_box;
GtkWidget *wlabel;
name = gimp_channel_get_name (channels[j]);
label = g_strdup_printf ("%s/%s", image_label, name);
g_free (name);
menuitem = gtk_menu_item_new ();
g_signal_connect (menuitem, "activate",
G_CALLBACK (gimp_menu_callback),
&channels[j]);
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (menuitem), hbox);
gtk_widget_show (hbox);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
wcolor_box = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_set_dither (GTK_PREVIEW (wcolor_box),
GDK_RGB_DITHER_MAX);
fill_preview_with_thumb (wcolor_box,
channels[j],
MENU_THUMBNAIL_WIDTH,
MENU_THUMBNAIL_HEIGHT);
gtk_widget_set_size_request (GTK_WIDGET (wcolor_box),
MENU_THUMBNAIL_WIDTH,
MENU_THUMBNAIL_HEIGHT);
gtk_container_add (GTK_CONTAINER(vbox), wcolor_box);
gtk_widget_show (wcolor_box);
wlabel = gtk_label_new (label);
gtk_misc_set_alignment (GTK_MISC (wlabel), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), wlabel, TRUE, TRUE, 4);
gtk_widget_show (wlabel);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
g_free (label);
if (channels[j] == active_channel)
{
channel = active_channel;
gtk_menu_set_active (GTK_MENU (menu), k);
}
else if (channel == -1)
channel = channels[j];
k += 1;
}
g_free (image_label);
}
g_free (images);
if (k == 0)
{
menuitem = gtk_menu_item_new_with_label (_("None"));
gtk_widget_set_sensitive (menuitem, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
if (channel != -1)
(* callback) (channel, data);
return menu;
}
GtkWidget *
gimp_drawable_menu_new (GimpConstraintFunc constraint,
GimpMenuCallback callback,
gpointer data,
gint32 active_drawable)
{
GtkWidget *menu;
GtkWidget *menuitem;
gchar *name;
gchar *image_label;
gchar *label;
gint32 *images;
gint32 *layers;
gint32 *channels;
gint32 drawable;
gint nimages;
gint nlayers;
gint nchannels;
gint i, j, k;
menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (menu), "gimp_callback", callback);
g_object_set_data (G_OBJECT (menu), "gimp_callback_data", data);
drawable = -1;
images = gimp_image_list (&nimages);
for (i = 0, k = 0; i < nimages; i++)
if (!constraint || (* constraint) (images[i], -1, data))
{
name = gimp_image_get_name (images[i]);
image_label = g_strdup_printf ("%s-%d", name, images[i]);
g_free (name);
layers = gimp_image_get_layers (images[i], &nlayers);
for (j = 0; j < nlayers; j++)
if (!constraint || (* constraint) (images[i], layers[j], data))
{
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *wcolor_box;
GtkWidget *wlabel;
name = gimp_layer_get_name (layers[j]);
label = g_strdup_printf ("%s/%s", image_label, name);
g_free (name);
menuitem = gtk_menu_item_new ();
g_signal_connect (menuitem, "activate",
G_CALLBACK (gimp_menu_callback),
&layers[j]);
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER(menuitem), hbox);
gtk_widget_show (hbox);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
wcolor_box = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_set_dither (GTK_PREVIEW (wcolor_box), GDK_RGB_DITHER_MAX);
fill_preview_with_thumb (wcolor_box,
layers[j],
MENU_THUMBNAIL_WIDTH,
MENU_THUMBNAIL_HEIGHT);
gtk_widget_set_size_request (GTK_WIDGET (wcolor_box),
MENU_THUMBNAIL_WIDTH ,
MENU_THUMBNAIL_HEIGHT);
gtk_container_add (GTK_CONTAINER(vbox), wcolor_box);
gtk_widget_show (wcolor_box);
wlabel = gtk_label_new (label);
gtk_misc_set_alignment (GTK_MISC (wlabel), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), wlabel, TRUE, TRUE, 4);
gtk_widget_show (wlabel);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
g_free (label);
if (layers[j] == active_drawable)
{
drawable = active_drawable;
gtk_menu_set_active (GTK_MENU (menu), k);
}
else if (drawable == -1)
drawable = layers[j];
k += 1;
}
channels = gimp_image_get_channels (images[i], &nchannels);
for (j = 0; j < nchannels; j++)
if (!constraint || (* constraint) (images[i], channels[j], data))
{
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *wcolor_box;
GtkWidget *wlabel;
name = gimp_channel_get_name (channels[j]);
label = g_strdup_printf ("%s/%s", image_label, name);
g_free (name);
menuitem = gtk_menu_item_new ();
g_signal_connect (menuitem, "activate",
G_CALLBACK (gimp_menu_callback),
&channels[j]);
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (menuitem), hbox);
gtk_widget_show (hbox);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
wcolor_box = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_set_dither (GTK_PREVIEW (wcolor_box),
GDK_RGB_DITHER_MAX);
fill_preview_with_thumb (wcolor_box,
channels[j],
MENU_THUMBNAIL_WIDTH,
MENU_THUMBNAIL_HEIGHT);
gtk_widget_set_size_request (GTK_WIDGET (wcolor_box),
MENU_THUMBNAIL_WIDTH ,
MENU_THUMBNAIL_HEIGHT);
gtk_container_add (GTK_CONTAINER (vbox), wcolor_box);
gtk_widget_show (wcolor_box);
wlabel = gtk_label_new (label);
gtk_misc_set_alignment (GTK_MISC (wlabel), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), wlabel, TRUE, TRUE, 4);
gtk_widget_show (wlabel);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
g_free (label);
if (channels[j] == active_drawable)
{
drawable = active_drawable;
gtk_menu_set_active (GTK_MENU (menu), k);
}
else if (drawable == -1)
drawable = channels[j];
k += 1;
}
g_free (image_label);
}
g_free (images);
if (k == 0)
{
menuitem = gtk_menu_item_new_with_label (_("None"));
gtk_widget_set_sensitive (menuitem, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
if (drawable != -1)
(* callback) (drawable, data);
return menu;
}
static void
gimp_menu_callback (GtkWidget *widget,
gint32 *id)
{
GimpMenuCallback callback;
gpointer callback_data;
callback = (GimpMenuCallback) g_object_get_data (G_OBJECT (widget->parent),
"gimp_callback");
callback_data = g_object_get_data (G_OBJECT (widget->parent),
"gimp_callback_data");
(* callback) (*id, callback_data);
}
static void
fill_preview_with_thumb (GtkWidget *widget,
gint32 drawable_ID,
gint width,
gint height)
{
guchar *drawable_data;
gint bpp;
gint x, y;
guchar *src;
gdouble r, g, b, a;
gdouble c0, c1;
guchar *p0, *p1, *even, *odd;
bpp = 0; /* Only returned */
drawable_data =
gimp_drawable_get_thumbnail_data (drawable_ID, &width, &height, &bpp);
gtk_preview_size (GTK_PREVIEW (widget), width, height);
even = g_malloc (width * 3);
odd = g_malloc (width * 3);
src = drawable_data;
for (y = 0; y < height; y++)
{
p0 = even;
p1 = odd;
for (x = 0; x < width; x++)
{
if (bpp == 4)
{
r = ((gdouble) src[x*4+0]) / 255.0;
g = ((gdouble) src[x*4+1]) / 255.0;
b = ((gdouble) src[x*4+2]) / 255.0;
a = ((gdouble) src[x*4+3]) / 255.0;
}
else if (bpp == 3)
{
r = ((gdouble) src[x*3+0]) / 255.0;
g = ((gdouble) src[x*3+1]) / 255.0;
b = ((gdouble) src[x*3+2]) / 255.0;
a = 1.0;
}
else
{
r = ((gdouble) src[x*bpp+0]) / 255.0;
g = b = r;
if (bpp == 2)
a = ((gdouble) src[x*bpp+1]) / 255.0;
else
a = 1.0;
}
if ((x / GIMP_CHECK_SIZE_SM) & 1)
{
c0 = GIMP_CHECK_LIGHT;
c1 = GIMP_CHECK_DARK;
}
else
{
c0 = GIMP_CHECK_DARK;
c1 = GIMP_CHECK_LIGHT;
}
*p0++ = (c0 + (r - c0) * a) * 255.0;
*p0++ = (c0 + (g - c0) * a) * 255.0;
*p0++ = (c0 + (b - c0) * a) * 255.0;
*p1++ = (c1 + (r - c1) * a) * 255.0;
*p1++ = (c1 + (g - c1) * a) * 255.0;
*p1++ = (c1 + (b - c1) * a) * 255.0;
}
if ((y / GIMP_CHECK_SIZE_SM) & 1)
gtk_preview_draw_row (GTK_PREVIEW (widget), odd, 0, y, width);
else
gtk_preview_draw_row (GTK_PREVIEW (widget), even, 0, y, width);
src += width * bpp;
}
g_free (even);
g_free (odd);
}
static gboolean
idle_brush_callback (GimpBrushData *bdata)
{
if (bdata->callback)
bdata->callback (bdata->name,
bdata->opacity,
bdata->spacing,
bdata->paint_mode,
bdata->width,
bdata->height,
bdata->brush_mask_data,
bdata->closing,
bdata->data);
g_free (bdata->name);
g_free (bdata->brush_mask_data);
bdata->idle_id = 0;
bdata->name = NULL;
bdata->brush_mask_data = NULL;
return FALSE;
}
static gboolean
idle_font_callback (GimpFontData *fdata)
{
if (fdata->callback)
fdata->callback (fdata->name,
fdata->closing,
fdata->data);
g_free (fdata->name);
fdata->idle_id = 0;
fdata->name = NULL;
return FALSE;
}
static gboolean
idle_gradient_callback (GimpGradientData *gdata)
{
if (gdata->callback)
gdata->callback (gdata->name,
gdata->width,
gdata->gradient_data,
gdata->closing,
gdata->data);
g_free (gdata->name);
g_free (gdata->gradient_data);
gdata->idle_id = 0;
gdata->name = NULL;
gdata->gradient_data = NULL;
return FALSE;
}
static gboolean
idle_pattern_callback (GimpPatternData *pdata)
{
if (pdata->callback)
pdata->callback (pdata->name,
pdata->width,
pdata->height,
pdata->bytes,
pdata->pattern_mask_data,
pdata->closing,
pdata->data);
g_free (pdata->name);
g_free (pdata->pattern_mask_data);
pdata->idle_id = 0;
pdata->name = NULL;
pdata->pattern_mask_data = NULL;
return FALSE;
}
static void
temp_brush_invoker (gchar *name,
gint nparams,
GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpBrushData *bdata;
bdata = (GimpBrushData *) g_hash_table_lookup (gbrush_ht, name);
if (! bdata)
{
g_warning("Can't find internal brush data");
}
else
{
g_free (bdata->name);
g_free (bdata->brush_mask_data);
bdata->name = g_strdup (param[0].data.d_string);
bdata->opacity = (gdouble) param[1].data.d_float;
bdata->spacing = param[2].data.d_int32;
bdata->paint_mode = param[3].data.d_int32;
bdata->width = param[4].data.d_int32;
bdata->height = param[5].data.d_int32;
bdata->brush_mask_data = g_memdup (param[7].data.d_int8array,
param[6].data.d_int32);
bdata->closing = param[8].data.d_int32;
if (! bdata->idle_id)
bdata->idle_id = g_idle_add ((GSourceFunc) idle_brush_callback, bdata);
}
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void
temp_font_invoker (gchar *name,
gint nparams,
GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpFontData *fdata;
fdata = (GimpFontData *) g_hash_table_lookup (gfont_ht, name);
if (! fdata)
{
g_warning ("Can't find internal font data");
}
else
{
g_free (fdata->name);
fdata->name = g_strdup (param[0].data.d_string);
fdata->closing = param[1].data.d_int32;
if (! fdata->idle_id)
fdata->idle_id = g_idle_add ((GSourceFunc) idle_font_callback, fdata);
}
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void
temp_gradient_invoker (gchar *name,
gint nparams,
GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpGradientData *gdata;
gdata = (GimpGradientData *) g_hash_table_lookup (ggradient_ht, name);
if (! gdata)
{
g_warning("Can't find internal gradient data");
}
else
{
g_free (gdata->name);
g_free (gdata->gradient_data);
gdata->name = g_strdup (param[0].data.d_string);
gdata->width = param[1].data.d_int32;
gdata->gradient_data = g_memdup (param[2].data.d_floatarray,
param[1].data.d_int32 * sizeof (gdouble));
gdata->closing = param[3].data.d_int32;
if (! gdata->idle_id)
gdata->idle_id = g_idle_add ((GSourceFunc) idle_gradient_callback,
gdata);
}
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void
temp_pattern_invoker (gchar *name,
gint nparams,
GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpPatternData *pdata;
pdata = (GimpPatternData *) g_hash_table_lookup (gpattern_ht, name);
if (! pdata)
{
g_warning ("Can't find internal pattern data");
}
else
{
g_free (pdata->name);
g_free (pdata->pattern_mask_data);
pdata->name = g_strdup(param[0].data.d_string);
pdata->width = param[1].data.d_int32;
pdata->height = param[2].data.d_int32;
pdata->bytes = param[3].data.d_int32;
pdata->pattern_mask_data = g_memdup (param[5].data.d_int8array,
param[4].data.d_int32);
pdata->closing = param[6].data.d_int32;
if (! pdata->idle_id)
pdata->idle_id = g_idle_add ((GSourceFunc) idle_pattern_callback,
pdata);
}
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static gchar *
gen_temp_plugin_name (void)
{
GimpParam *return_vals;
gint nreturn_vals;
gchar *result;
return_vals = gimp_run_procedure ("gimp_temp_PDB_name",
&nreturn_vals,
GIMP_PDB_END);
result = "temp_name_gen_failed";
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
result = g_strdup (return_vals[1].data.d_string);
gimp_destroy_params (return_vals, nreturn_vals);
return result;
}
gchar *
gimp_interactive_selection_brush (const gchar *title,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpRunBrushCallback callback,
gpointer data)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_STRING, "str", "String" },
{ GIMP_PDB_FLOAT, "opacity", "Opacity" },
{ GIMP_PDB_INT32, "spacing", "Spacing" },
{ GIMP_PDB_INT32, "paint mode", "Paint mode" },
{ GIMP_PDB_INT32, "mask width", "Brush width" },
{ GIMP_PDB_INT32, "mask height" "Brush heigth" },
{ GIMP_PDB_INT32, "mask len", "Length of brush mask data" },
{ GIMP_PDB_INT8ARRAY, "mask data", "The brush mask data" },
{ GIMP_PDB_INT32, "dialog status", "Registers if the dialog was closing "
"[0 = No, 1 = Yes]" },
};
static GimpParamDef *return_vals = NULL;
static gint nargs = sizeof (args) / sizeof (args[0]);
static gint nreturn_vals = 0;
gint bnreturn_vals;
GimpParam *pdbreturn_vals;
gchar *pdbname = gen_temp_plugin_name ();
GimpBrushData *bdata;
bdata = g_new0 (GimpBrushData, 1);
gimp_install_temp_proc (pdbname,
"Temp PDB for interactive popups",
"More here later",
"Andy Thomas",
"Andy Thomas",
"1997",
NULL,
"RGB*, GRAY*",
GIMP_TEMPORARY,
nargs, nreturn_vals,
args, return_vals,
temp_brush_invoker);
pdbreturn_vals =
gimp_run_procedure ("gimp_brushes_popup",
&bnreturn_vals,
GIMP_PDB_STRING, pdbname,
GIMP_PDB_STRING, title,
GIMP_PDB_STRING, brush_name,
GIMP_PDB_FLOAT, opacity,
GIMP_PDB_INT32, spacing,
GIMP_PDB_INT32, paint_mode,
GIMP_PDB_END);
gimp_extension_enable (); /* Allow callbacks to be watched */
gimp_destroy_params (pdbreturn_vals,bnreturn_vals);
/* Now add to hash table so we can find it again */
if (! gbrush_ht)
gbrush_ht = g_hash_table_new (g_str_hash, g_str_equal);
bdata->callback = callback;
bdata->data = data;
g_hash_table_insert (gbrush_ht, pdbname, bdata);
return pdbname;
}
gchar *
gimp_interactive_selection_font (const gchar *title,
const gchar *font_name,
GimpRunFontCallback callback,
gpointer data)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_STRING, "str", "String" },
{ GIMP_PDB_INT32, "dialog status", "Registers if the dialog was closing "
"[0 = No, 1 = Yes]" },
};
static GimpParamDef *return_vals = NULL;
static gint nargs = sizeof (args) / sizeof (args[0]);
static gint nreturn_vals = 0;
gint fnreturn_vals;
GimpParam *pdbreturn_vals;
gchar *pdbname = gen_temp_plugin_name ();
GimpFontData *fdata;
fdata = g_new0 (GimpFontData, 1);
gimp_install_temp_proc (pdbname,
"Temp PDB for interactive popups",
"More here later",
"Andy Thomas",
"Andy Thomas",
"1997",
NULL,
"RGB*, GRAY*",
GIMP_TEMPORARY,
nargs, nreturn_vals,
args, return_vals,
temp_font_invoker);
pdbreturn_vals =
gimp_run_procedure ("gimp_fonts_popup",
&fnreturn_vals,
GIMP_PDB_STRING, pdbname,
GIMP_PDB_STRING, title,
GIMP_PDB_STRING, font_name,
GIMP_PDB_END);
gimp_extension_enable (); /* Allow callbacks to be watched */
gimp_destroy_params (pdbreturn_vals, fnreturn_vals);
/* Now add to hash table so we can find it again */
if (! gfont_ht)
gfont_ht = g_hash_table_new (g_str_hash, g_str_equal);
fdata->callback = callback;
fdata->data = data;
g_hash_table_insert (gfont_ht, pdbname, fdata);
return pdbname;
}
gchar *
gimp_interactive_selection_gradient (const gchar *title,
const gchar *gradient_name,
gint sample_size,
GimpRunGradientCallback callback,
gpointer data)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_STRING, "str", "String" },
{ GIMP_PDB_INT32, "grad width", "Gradient width" },
{ GIMP_PDB_FLOATARRAY,"grad data", "The gradient mask data" },
{ GIMP_PDB_INT32, "dialog status", "Registers if the dialog was closing "
"[0 = No, 1 = Yes]" },
};
static GimpParamDef *return_vals = NULL;
static gint nargs = sizeof (args) / sizeof (args[0]);
static gint nreturn_vals = 0;
gint bnreturn_vals;
GimpParam *pdbreturn_vals;
gchar *pdbname = gen_temp_plugin_name();
GimpGradientData *gdata;
gdata = g_new0 (GimpGradientData, 1);
gimp_install_temp_proc (pdbname,
"Temp PDB for interactive popups",
"More here later",
"Andy Thomas",
"Andy Thomas",
"1997",
NULL,
"RGB*, GRAY*",
GIMP_TEMPORARY,
nargs, nreturn_vals,
args, return_vals,
temp_gradient_invoker);
pdbreturn_vals =
gimp_run_procedure ("gimp_gradients_popup",
&bnreturn_vals,
GIMP_PDB_STRING, pdbname,
GIMP_PDB_STRING, title,
GIMP_PDB_STRING, gradient_name,
GIMP_PDB_INT32, sample_size,
GIMP_PDB_END);
gimp_extension_enable (); /* Allow callbacks to be watched */
gimp_destroy_params (pdbreturn_vals,bnreturn_vals);
/* Now add to hash table so we can find it again */
if (! ggradient_ht)
ggradient_ht = g_hash_table_new (g_str_hash, g_str_equal);
gdata->callback = callback;
gdata->data = data;
g_hash_table_insert (ggradient_ht, pdbname,gdata);
return pdbname;
}
gchar *
gimp_interactive_selection_pattern (const gchar *title,
const gchar *pattern_name,
GimpRunPatternCallback callback,
gpointer data)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_STRING, "str", "String" },
{ GIMP_PDB_INT32, "mask width", "Pattern width" },
{ GIMP_PDB_INT32, "mask height", "Pattern heigth" },
{ GIMP_PDB_INT32, "mask bpp", "Pattern bytes per pixel" },
{ GIMP_PDB_INT32, "mask len", "Length of pattern mask data" },
{ GIMP_PDB_INT8ARRAY,"mask data", "The pattern mask data" },
{ GIMP_PDB_INT32, "dialog status", "Registers if the dialog was closing "
"[0 = No, 1 = Yes]" },
};
static GimpParamDef *return_vals = NULL;
static gint nargs = sizeof (args) / sizeof (args[0]);
static gint nreturn_vals = 0;
gint bnreturn_vals;
GimpParam *pdbreturn_vals;
gchar *pdbname = gen_temp_plugin_name ();
GimpPatternData *pdata;
pdata = g_new0 (GimpPatternData, 1);
gimp_install_temp_proc (pdbname,
"Temp PDB for interactive popups",
"More here later",
"Andy Thomas",
"Andy Thomas",
"1997",
NULL,
"RGB*, GRAY*",
GIMP_TEMPORARY,
nargs, nreturn_vals,
args, return_vals,
temp_pattern_invoker);
pdbreturn_vals =
gimp_run_procedure("gimp_patterns_popup",
&bnreturn_vals,
GIMP_PDB_STRING, pdbname,
GIMP_PDB_STRING, title,
GIMP_PDB_STRING, pattern_name,
GIMP_PDB_END);
gimp_extension_enable (); /* Allow callbacks to be watched */
gimp_destroy_params (pdbreturn_vals, bnreturn_vals);
/* Now add to hash table so we can find it again */
if (! gpattern_ht)
gpattern_ht = g_hash_table_new (g_str_hash, g_str_equal);
pdata->callback = callback;
pdata->data = data;
g_hash_table_insert (gpattern_ht, pdbname,pdata);
return pdbname;
}
Reference in New Issue View Git Blame Copy Permalink