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

only code review, no real changes 

--Sven
This commit is contained in:
Sven Neumann 2000-05-08 17:45:16 +00:00
parent 056d620c5b
commit 3b85cb5dc8
3 changed files with 577 additions and 551 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ChangeLog
View File

@ -1,3 +1,7 @@
2000-05-08 Sven Neumann <sven@gimp.org>
* libgimp/gimpmenu.[ch]: code review, no real changes
2000-05-08 Sven Neumann <neo@wintermute.ochsenblut.de>
* plug-ins/script-fu/scripts/tileblur.scm

366
libgimp/gimpmenu.c
View File

@ -16,23 +16,19 @@
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <string.h>
#include "gimp.h"
#include "gimpui.h"
#define GRAD_CHECK_SIZE_SM 4
#define GRAD_CHECK_DARK (1.0 / 3.0)
#define GRAD_CHECK_LIGHT (2.0 / 3.0)
#define MENU_THUMBNAIL_WIDTH 24
#define MENU_THUMBNAIL_HEIGHT 24
/* Copy data from temp_PDB call */
struct _GBrushData {
gint busy;
struct _GimpBrushData
{
gboolean busy;
gchar *bname;
gdouble opacity;
gint spacing;
@ -41,69 +37,71 @@ struct _GBrushData {
gint height;
gchar *brush_mask_data;
GRunBrushCallback callback;
gint closing;
gpointer udata;
gboolean closing;
gpointer data;
};
typedef struct _GBrushData GBrushData;
typedef struct _GimpBrushData GimpBrushData;
/* Copy data from temp_PDB call */
struct _GPatternData {
gint busy;
struct _GimpPatternData
{
gboolean busy;
gchar *pname;
gint width;
gint height;
gint bytes;
gchar *pattern_mask_data;
GRunPatternCallback callback;
gint closing;
gpointer udata;
gboolean closing;
gpointer data;
};
typedef struct _GPatternData GPatternData;
typedef struct _GimpPatternData GimpPatternData;
/* Copy data from temp_PDB call */
struct _GGradientData {
gint busy;
struct _GimpGradientData
{
gboolean busy;
gchar *gname;
gint width;
gdouble *gradient_data;
GRunGradientCallback callback;
gint closing;
gpointer udata;
gboolean closing;
gpointer data;
};
typedef struct _GGradientData GGradientData;
typedef struct _GimpGradientData GimpGradientData;
static void gimp_menu_callback (GtkWidget *w,
static void gimp_menu_callback (GtkWidget *widget,
gint32 *id);
static void do_brush_callback (GBrushData *bdata);
static gint idle_test_brush (GBrushData *bdata);
static gint idle_test_pattern (GPatternData *pdata);
static gint idle_test_gradient (GGradientData *gdata);
static void temp_brush_invoker (char *name,
int nparams,
static void do_brush_callback (GimpBrushData *bdata);
static gint idle_test_brush (GimpBrushData *bdata);
static gint idle_test_pattern (GimpPatternData *pdata);
static gint idle_test_gradient (GimpGradientData *gdata);
static void temp_brush_invoker (gchar *name,
gint nparams,
GParam *param,
int *nreturn_vals,
gint *nreturn_vals,
GParam **return_vals);
static gboolean input_callback (GIOChannel *channel,
GIOCondition condition,
gpointer data);
static void gimp_setup_callbacks (void);
static gchar* gen_temp_plugin_name (void);
static void fill_preview_with_thumb(GtkWidget *,
gint32,
gint,
gint);
static void fill_preview_with_thumb (GtkWidget *widget,
gint32 drawable_ID,
gint width,
gint height);
/* From gimp.c */
void gimp_run_temp (void);
static GHashTable *gbrush_ht = NULL;
static GHashTable *gpattern_ht = NULL;
static GHashTable *ggradient_ht = NULL;
static GBrushData *active_brush_pdb = NULL;
static GPatternData *active_pattern_pdb = NULL;
static GGradientData *active_gradient_pdb = NULL;
static GimpBrushData *active_brush_pdb = NULL;
static GimpPatternData *active_pattern_pdb = NULL;
static GimpGradientData *active_gradient_pdb = NULL;
GtkWidget*
gimp_image_menu_new (GimpConstraintFunc constraint,
@ -403,17 +401,17 @@ gimp_drawable_menu_new (GimpConstraintFunc constraint,
{
GtkWidget *menu;
GtkWidget *menuitem;
char *name;
char *image_label;
char *label;
gchar *name;
gchar *image_label;
gchar *label;
gint32 *images;
gint32 *layers;
gint32 *channels;
gint32 drawable;
int nimages;
int nlayers;
int nchannels;
int i, j, k;
gint nimages;
gint nlayers;
gint nchannels;
gint i, j, k;
menu = gtk_menu_new ();
gtk_object_set_user_data (GTK_OBJECT (menu), (gpointer) callback);
@ -422,6 +420,7 @@ gimp_drawable_menu_new (GimpConstraintFunc constraint,
drawable = -1;
images = gimp_query_images (&nimages);
for (i = 0, k = 0; i < nimages; i++)
if (!constraint || (* constraint) (images[i], -1, data))
{
@ -431,6 +430,7 @@ gimp_drawable_menu_new (GimpConstraintFunc constraint,
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))
{
@ -440,7 +440,7 @@ gimp_drawable_menu_new (GimpConstraintFunc constraint,
GtkWidget *wlabel;
name = gimp_layer_get_name (layers[j]);
label = g_new (char, strlen (image_label) + strlen (name) + 2);
label = g_new (gchar, strlen (image_label) + strlen (name) + 2);
sprintf (label, "%s/%s", image_label, name);
g_free (name);
@ -494,6 +494,7 @@ gimp_drawable_menu_new (GimpConstraintFunc constraint,
}
channels = gimp_image_get_channels (images[i], &nchannels);
for (j = 0; j < nchannels; j++)
if (!constraint || (* constraint) (images[i], channels[j], data))
{
@ -576,20 +577,23 @@ gimp_drawable_menu_new (GimpConstraintFunc constraint,
static void
gimp_menu_callback (GtkWidget *w,
gimp_menu_callback (GtkWidget *widget,
gint32 *id)
{
GimpMenuCallback callback;
gpointer callback_data;
callback = (GimpMenuCallback) gtk_object_get_user_data (GTK_OBJECT (w->parent));
callback_data = gtk_object_get_data (GTK_OBJECT (w->parent), "gimp_callback_data");
callback = (GimpMenuCallback) gtk_object_get_user_data (GTK_OBJECT (widget->parent));
callback_data = gtk_object_get_data (GTK_OBJECT (widget->parent), "gimp_callback_data");
(* callback) (*id, callback_data);
}
static void
fill_preview_with_thumb(GtkWidget *w,gint32 drawableId,gint width,gint height)
fill_preview_with_thumb (GtkWidget *widget,
gint32 drawable_ID,
gint width,
gint height)
{
guchar *drawable_data;
gint bpp;
@ -601,9 +605,10 @@ fill_preview_with_thumb(GtkWidget *w,gint32 drawableId,gint width,gint height)
bpp = 0; /* Only returned */
drawable_data = gimp_drawable_get_thumbnail_data(drawableId,&width,&height,&bpp);
drawable_data =
gimp_drawable_get_thumbnail_data (drawable_ID, &width, &height, &bpp);
gtk_preview_size(GTK_PREVIEW(w),width,height);
gtk_preview_size (GTK_PREVIEW (widget), width, height);
even = g_malloc (width * 3);
odd = g_malloc (width * 3);
@ -614,7 +619,8 @@ fill_preview_with_thumb(GtkWidget *w,gint32 drawableId,gint width,gint height)
p0 = even;
p1 = odd;
for (x = 0; x < width; x++) {
for (x = 0; x < width; x++)
{
if(bpp == 4)
{
r = ((gdouble)src[x*4+0])/255.0;
@ -639,13 +645,16 @@ fill_preview_with_thumb(GtkWidget *w,gint32 drawableId,gint width,gint height)
a = 1.0;
}
if ((x / GRAD_CHECK_SIZE_SM) & 1) {
c0 = GRAD_CHECK_LIGHT;
c1 = GRAD_CHECK_DARK;
} else {
c0 = GRAD_CHECK_DARK;
c1 = GRAD_CHECK_LIGHT;
} /* else */
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;
@ -654,19 +663,16 @@ fill_preview_with_thumb(GtkWidget *w,gint32 drawableId,gint width,gint height)
*p1++ = (c1 + (r - c1) * a) * 255.0;
*p1++ = (c1 + (g - c1) * a) * 255.0;
*p1++ = (c1 + (b - c1) * a) * 255.0;
} /* for */
if ((y / GRAD_CHECK_SIZE_SM) & 1)
{
gtk_preview_draw_row (GTK_PREVIEW (w), (guchar *)odd, 0, y, width);
}
if ((y / GIMP_CHECK_SIZE_SM) & 1)
gtk_preview_draw_row (GTK_PREVIEW (widget), (guchar *)odd, 0, y, width);
else
{
gtk_preview_draw_row (GTK_PREVIEW (w), (guchar *)even, 0, y, width);
}
gtk_preview_draw_row (GTK_PREVIEW (widget), (guchar *)even, 0, y, width);
src += width * bpp;
}
g_free (even);
g_free (odd);
}
@ -682,7 +688,7 @@ fill_preview_with_thumb(GtkWidget *w,gint32 drawableId,gint width,gint height)
*/
static void
do_brush_callback(GBrushData * bdata)
do_brush_callback (GimpBrushData *bdata)
{
if (!bdata->busy)
return;
@ -696,7 +702,7 @@ do_brush_callback(GBrushData * bdata)
bdata->height,
bdata->brush_mask_data,
bdata->closing,
bdata->udata);
bdata->data);
if (bdata->bname)
g_free (bdata->bname);
@ -704,12 +710,13 @@ do_brush_callback(GBrushData * bdata)
if (bdata->brush_mask_data)
g_free (bdata->brush_mask_data);
bdata->busy = 0;
bdata->bname = bdata->brush_mask_data = 0;
bdata->busy = FALSE;
bdata->bname = NULL;
bdata->brush_mask_data = NULL;
}
static void
do_pattern_callback(GPatternData * pdata)
do_pattern_callback (GimpPatternData *pdata)
{
if (!pdata->busy)
return;
@ -721,7 +728,7 @@ do_pattern_callback(GPatternData * pdata)
pdata->bytes,
pdata->pattern_mask_data,
pdata->closing,
pdata->udata);
pdata->data);
if (pdata->pname)
g_free (pdata->pname);
@ -729,12 +736,13 @@ do_pattern_callback(GPatternData * pdata)
if (pdata->pattern_mask_data)
g_free (pdata->pattern_mask_data);
pdata->busy = 0;
pdata->pname = pdata->pattern_mask_data = 0;
pdata->busy = FALSE;
pdata->pname = NULL;
pdata->pattern_mask_data = NULL;
}
static void
do_gradient_callback(GGradientData * gdata)
do_gradient_callback (GimpGradientData *gdata)
{
if (!gdata->busy)
return;
@ -744,7 +752,7 @@ do_gradient_callback(GGradientData * gdata)
gdata->width,
gdata->gradient_data,
gdata->closing,
gdata->udata);
gdata->data);
if (gdata->gname)
g_free (gdata->gname);
@ -752,63 +760,54 @@ do_gradient_callback(GGradientData * gdata)
if (gdata->gradient_data)
g_free (gdata->gradient_data);
gdata->busy = 0;
gdata->busy = FALSE;
gdata->gname = NULL;
gdata->gradient_data = NULL;
}
static gint
idle_test_brush (GBrushData * bdata)
idle_test_brush (GimpBrushData *bdata)
{
do_brush_callback (bdata);
return FALSE;
}
static gint
idle_test_pattern (GPatternData * pdata)
idle_test_pattern (GimpPatternData *pdata)
{
do_pattern_callback (pdata);
return FALSE;
}
static gint
idle_test_gradient (GGradientData * gdata)
idle_test_gradient (GimpGradientData *gdata)
{
do_gradient_callback (gdata);
return FALSE;
}
static void
temp_brush_invoker(char *name,
int nparams,
temp_brush_invoker(gchar *name,
gint nparams,
GParam *param,
int *nreturn_vals,
gint *nreturn_vals,
GParam **return_vals)
{
static GParam values[1];
GStatusType status = STATUS_SUCCESS;
GBrushData *bdata = (GBrushData *)g_hash_table_lookup(gbrush_ht,name);
GimpBrushData *bdata;
bdata = (GimpBrushData *) g_hash_table_lookup (gbrush_ht, name);
if (!bdata)
{
g_warning("Can't find internal brush data");
}
else
{
if(!bdata->busy)
{
/* printf("\nXX Here I am in the temp proc\n"); */
/* printf("String name passed is '%s'\n",param[0].data.d_string); */
/* printf("opacity is '%g'\n",(gdouble)param[1].data.d_float); */
/* printf("spacing is '%d'\n",param[2].data.d_int32); */
/* printf("paint mode is '%d'\n",param[3].data.d_int32); */
/* printf("width is '%d'\n",param[4].data.d_int32); */
/* printf("height is '%d'\n",param[5].data.d_int32); */
/* printf("String mask data length passed is '%d'\n",param[6].data.d_int32); */
/* printf("closing is '%d'\n",param[8].data.d_int32); */
bdata->bname = g_strdup (param[0].data.d_string);
bdata->opacity = (gdouble)param[1].data.d_float;
bdata->spacing = param[2].data.d_int32;
@ -816,14 +815,14 @@ temp_brush_invoker(char *name,
bdata->width = param[4].data.d_int32;
bdata->height = param[5].data.d_int32;
bdata->brush_mask_data = g_malloc(param[6].data.d_int32);
g_memmove(bdata->brush_mask_data,param[7].data.d_int8array,param[6].data.d_int32);
g_memmove (bdata->brush_mask_data,
param[7].data.d_int8array, param[6].data.d_int32);
bdata->closing = param[8].data.d_int32;
active_brush_pdb = bdata;
bdata->busy = 1;
bdata->busy = TRUE;
gtk_idle_add ((GtkFunction)idle_test_brush, active_brush_pdb);
}
}
*nreturn_vals = 1;
*return_vals = values;
@ -833,37 +832,36 @@ temp_brush_invoker(char *name,
}
static void
temp_pattern_invoker(char *name,
int nparams,
temp_pattern_invoker(gchar *name,
gint nparams,
GParam *param,
int *nreturn_vals,
gint *nreturn_vals,
GParam **return_vals)
{
static GParam values[1];
GStatusType status = STATUS_SUCCESS;
GPatternData *pdata = (GPatternData *)g_hash_table_lookup(gpattern_ht,name);
GimpPatternData *pdata;
pdata = (GimpPatternData *)g_hash_table_lookup (gpattern_ht, name);
if (!pdata)
{
g_warning ("Can't find internal pattern data");
}
else
{
if (!pdata->busy)
{
pdata->pname = 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_malloc(param[4].data.d_int32);
g_memmove(pdata->pattern_mask_data,param[5].data.d_int8array,param[4].data.d_int32);
g_memmove (pdata->pattern_mask_data,
param[5].data.d_int8array, param[4].data.d_int32);
pdata->closing = param[6].data.d_int32;
active_pattern_pdb = pdata;
pdata->busy = 1;
pdata->busy = TRUE;
gtk_idle_add ((GtkFunction)idle_test_pattern, active_pattern_pdb);
}
}
*nreturn_vals = 1;
*return_vals = values;
@ -873,29 +871,32 @@ temp_pattern_invoker(char *name,
}
static void
temp_gradient_invoker(char *name,
int nparams,
temp_gradient_invoker(gchar *name,
gint nparams,
GParam *param,
int *nreturn_vals,
gint *nreturn_vals,
GParam **return_vals)
{
static GParam values[1];
GStatusType status = STATUS_SUCCESS;
GGradientData *gdata = (GGradientData *)g_hash_table_lookup(ggradient_ht,name);
GimpGradientData *gdata;
gdata = (GimpGradientData *) g_hash_table_lookup (ggradient_ht, name);
if (!gdata)
{
g_warning("Can't find internal gradient data");
}
else
{
if (!gdata->busy)
{
int i;
gdouble *pv,*values;;
gint i;
gdouble *pv;
gdouble *values;
gdata->gname = g_strdup (param[0].data.d_string);
gdata->width = param[1].data.d_int32;
gdata->gradient_data = (gdouble *)g_malloc(param[1].data.d_int32*sizeof(gdouble));
gdata->gradient_data = g_new (gdouble, param[1].data.d_int32);
values = param[2].data.d_floatarray;
pv = gdata->gradient_data;
@ -904,7 +905,7 @@ temp_gradient_invoker(char *name,
gdata->closing = param[3].data.d_int32;
active_gradient_pdb = gdata;
gdata->busy = 1;
gdata->busy = TRUE;
gtk_idle_add ((GtkFunction)idle_test_gradient, active_gradient_pdb);
}
}
@ -931,15 +932,16 @@ input_callback (GIOChannel *channel,
static void
gimp_setup_callbacks (void)
{
static int first_time = TRUE;
static gboolean first_time = TRUE;
if (first_time)
{
/* Tie into the gdk input function */
/* only once */
/* Tie into the gdk input function only once */
g_io_add_watch (_readchannel, G_IO_IN | G_IO_PRI, input_callback, NULL);
/* This needed on Win32 */
gimp_request_wakeups ();
first_time = FALSE;
}
}
@ -948,8 +950,8 @@ static gchar *
gen_temp_plugin_name (void)
{
GParam *return_vals;
int nreturn_vals;
char *result;
gint nreturn_vals;
gchar *result;
return_vals = gimp_run_procedure ("gimp_temp_PDB_name",
&nreturn_vals,
@ -967,26 +969,27 @@ gen_temp_plugin_name (void)
/* Can only be used in conjuction with gdk since we need to tie into the input
* selection mech.
*/
void *
gpointer
gimp_interactive_selection_brush(gchar *dialogname,
gchar *brush_name,
gdouble opacity,
gint spacing,
gint paint_mode,
GRunBrushCallback callback,
gpointer udata)
gpointer data)
{
static GParamDef args[] =
{
{ PARAM_STRING, "str", "String"},
{ PARAM_FLOAT, "opacity", "Opacity"},
{ PARAM_INT32, "spacing", "spacing"},
{ PARAM_INT32, "paint mode","paint mode"},
{ PARAM_INT32, "mask width","brush width"},
{ PARAM_INT32, "mask height","brush heigth"},
{ PARAM_INT32, "spacing", "Spacing"},
{ PARAM_INT32, "paint mode", "Paint mode"},
{ PARAM_INT32, "mask width", "Brush width"},
{ PARAM_INT32, "mask height" "Brush heigth"},
{ PARAM_INT32, "mask len", "Length of brush mask data"},
{ PARAM_INT8ARRAY, "mask data", "The brush mask data"},
{ PARAM_INT32, "dialog status","Registers if the dialog was closing [0 = No, 1 = Yes]"},
{ PARAM_INT32, "dialog status", "Registers if the dialog was closing "
"[0 = No, 1 = Yes]"},
};
static GParamDef *return_vals = NULL;
static int nargs = sizeof (args) / sizeof (args[0]);
@ -994,7 +997,9 @@ gimp_interactive_selection_brush(gchar *dialogname,
gint bnreturn_vals;
GParam *pdbreturn_vals;
gchar *pdbname = gen_temp_plugin_name ();
GBrushData *bdata = g_malloc0(sizeof(struct _GBrushData));
GimpBrushData *bdata;
bdata = g_new0 (GimpBrushData, 1);
gimp_install_temp_proc (pdbname,
"Temp PDB for interactive popups",
@ -1014,10 +1019,10 @@ gimp_interactive_selection_brush(gchar *dialogname,
&bnreturn_vals,
PARAM_STRING, pdbname,
PARAM_STRING, dialogname,
PARAM_STRING,brush_name,/*name*/
PARAM_FLOAT, opacity, /*Opacity*/
PARAM_INT32, spacing, /*default spacing*/
PARAM_INT32, paint_mode, /*paint mode*/
PARAM_STRING, brush_name,
PARAM_FLOAT, opacity,
PARAM_INT32, spacing,
PARAM_INT32, paint_mode,
PARAM_END);
/* if (pdbreturn_vals[0].data.d_status != STATUS_SUCCESS) */
@ -1039,7 +1044,7 @@ gimp_interactive_selection_brush(gchar *dialogname,
g_str_equal);
bdata->callback = callback;
bdata->udata = udata;
bdata->data = data;
g_hash_table_insert (gbrush_ht, pdbname, bdata);
return pdbname;
@ -1056,7 +1061,7 @@ gimp_brushes_get_brush_data (gchar *bname,
gchar **mask_data)
{
GParam *return_vals;
int nreturn_vals;
gint nreturn_vals;
gchar *ret_name = NULL;
return_vals = gimp_run_procedure ("gimp_brushes_get_brush_data",
@ -1073,7 +1078,8 @@ gimp_brushes_get_brush_data (gchar *bname,
*width = return_vals[5].data.d_int32;
*height = return_vals[6].data.d_int32;
*mask_data = g_new (gchar, return_vals[7].data.d_int32);
g_memmove (*mask_data, return_vals[8].data.d_int32array,return_vals[7].data.d_int32);
g_memmove (*mask_data,
return_vals[8].data.d_int32array, return_vals[7].data.d_int32);
}
gimp_destroy_params (return_vals, nreturn_vals);
@ -1082,10 +1088,10 @@ gimp_brushes_get_brush_data (gchar *bname,
}
gint
gimp_brush_close_popup(void * popup_pnt)
gimp_brush_close_popup (gpointer popup_pnt)
{
GParam *return_vals;
int nreturn_vals;
gint nreturn_vals;
gint retval;
return_vals = gimp_run_procedure ("gimp_brushes_close_popup",
@ -1101,14 +1107,14 @@ gimp_brush_close_popup(void * popup_pnt)
}
gint
gimp_brush_set_popup(void * popup_pnt,
gimp_brush_set_popup(gpointer popup_pnt,
gchar *pname,
gdouble opacity,
gint spacing,
gint paint_mode)
{
GParam *return_vals;
int nreturn_vals;
gint nreturn_vals;
gint retval;
return_vals = gimp_run_procedure ("gimp_brushes_set_popup",
@ -1129,21 +1135,22 @@ gimp_brush_set_popup(void * popup_pnt,
void *
gpointer
gimp_interactive_selection_pattern (gchar *dialogname,
gchar *pattern_name,
GRunPatternCallback callback,
gpointer udata)
gpointer data)
{
static GParamDef args[] =
{
{ PARAM_STRING, "str", "String"},
{ PARAM_INT32, "mask width","pattern width"},
{ PARAM_INT32, "mask height","pattern heigth"},
{ PARAM_INT32, "mask bpp","pattern bytes per pixel"},
{ PARAM_INT32, "mask width", "Pattern width"},
{ PARAM_INT32, "mask height", "Pattern heigth"},
{ PARAM_INT32, "mask bpp", "Pattern bytes per pixel"},
{ PARAM_INT32, "mask len", "Length of pattern mask data"},
{ PARAM_INT8ARRAY,"mask data", "The pattern mask data"},
{ PARAM_INT32, "dialog status","Registers if the dialog was closing [0 = No, 1 = Yes]"},
{ PARAM_INT32, "dialog status", "Registers if the dialog was closing "
"[0 = No, 1 = Yes]"},
};
static GParamDef *return_vals = NULL;
static int nargs = sizeof (args) / sizeof (args[0]);
@ -1151,7 +1158,9 @@ gimp_interactive_selection_pattern(gchar *dialogname,
gint bnreturn_vals;
GParam *pdbreturn_vals;
gchar *pdbname = gen_temp_plugin_name ();
GPatternData *pdata = g_malloc0(sizeof(struct _GPatternData));
GimpPatternData *pdata;
pdata = g_new0 (GimpPatternData, 1);
gimp_install_temp_proc (pdbname,
"Temp PDB for interactive popups",
@ -1184,7 +1193,7 @@ gimp_interactive_selection_pattern(gchar *dialogname,
g_str_equal);
pdata->callback = callback;
pdata->udata = udata;
pdata->data = data;
g_hash_table_insert (gpattern_ht, pdbname,pdata);
return pdbname;
@ -1199,7 +1208,7 @@ gimp_pattern_get_pattern_data (gchar *pname,
gchar **mask_data)
{
GParam *return_vals;
int nreturn_vals;
gint nreturn_vals;
gchar *ret_name = NULL;
return_vals = gimp_run_procedure ("gimp_patterns_get_pattern_data",
@ -1214,7 +1223,8 @@ gimp_pattern_get_pattern_data (gchar *pname,
*height = return_vals[3].data.d_int32;
*bytes = return_vals[4].data.d_int32;
*mask_data = g_new (gchar,return_vals[5].data.d_int32);
g_memmove (*mask_data, return_vals[6].data.d_int32array,return_vals[5].data.d_int32);
g_memmove (*mask_data,
return_vals[6].data.d_int32array, return_vals[5].data.d_int32);
}
gimp_destroy_params (return_vals, nreturn_vals);
@ -1223,10 +1233,10 @@ gimp_pattern_get_pattern_data (gchar *pname,
}
gint
gimp_pattern_close_popup(void * popup_pnt)
gimp_pattern_close_popup (gpointer popup_pnt)
{
GParam *return_vals;
int nreturn_vals;
gint nreturn_vals;
gint retval;
return_vals = gimp_run_procedure ("gimp_patterns_close_popup",
@ -1242,10 +1252,11 @@ gimp_pattern_close_popup(void * popup_pnt)
}
gint
gimp_pattern_set_popup(void * popup_pnt, gchar * pname)
gimp_pattern_set_popup (gpointer popup_pnt,
gchar *pname)
{
GParam *return_vals;
int nreturn_vals;
gint nreturn_vals;
gint retval;
return_vals = gimp_run_procedure ("gimp_patterns_set_popup",
@ -1261,19 +1272,20 @@ gimp_pattern_set_popup(void * popup_pnt, gchar * pname)
return retval;
}
void *
gpointer
gimp_interactive_selection_gradient (gchar *dialogname,
gchar *gradient_name,
gint sample_sz,
GRunGradientCallback callback,
gpointer udata)
gpointer data)
{
static GParamDef args[] =
{
{ PARAM_STRING, "str", "String"},
{ PARAM_INT32, "grad width","grad width"},
{ PARAM_INT32, "grad width", "Gradient width"},
{ PARAM_FLOATARRAY,"grad data", "The gradient mask data"},
{ PARAM_INT32, "dialog status","Registers if the dialog was closing [0 = No, 1 = Yes]"},
{ PARAM_INT32, "dialog status", "Registers if the dialog was closing "
"[0 = No, 1 = Yes]"},
};
static GParamDef *return_vals = NULL;
static int nargs = sizeof (args) / sizeof (args[0]);
@ -1281,7 +1293,9 @@ gimp_interactive_selection_gradient(gchar *dialogname,
gint bnreturn_vals;
GParam *pdbreturn_vals;
gchar *pdbname = gen_temp_plugin_name();
GGradientData *gdata = g_malloc0(sizeof(struct _GGradientData));
GimpGradientData *gdata;
gdata = g_new0 (GimpGradientData, 1);
gimp_install_temp_proc (pdbname,
"Temp PDB for interactive popups",
@ -1315,7 +1329,7 @@ gimp_interactive_selection_gradient(gchar *dialogname,
g_str_equal);
gdata->callback = callback;
gdata->udata = udata;
gdata->data = data;
g_hash_table_insert (ggradient_ht, pdbname,gdata);
return pdbname;
@ -1328,7 +1342,7 @@ gimp_gradient_get_gradient_data (gchar *gname,
gdouble **grad_data)
{
GParam *return_vals;
int nreturn_vals;
gint nreturn_vals;
gchar *ret_name = NULL;
return_vals = gimp_run_procedure ("gimp_gradients_get_gradient_data",
@ -1339,10 +1353,12 @@ gimp_gradient_get_gradient_data (gchar *gname,
if (return_vals[0].data.d_status == STATUS_SUCCESS)
{
int i;
gint i;
ret_name = g_strdup (return_vals[1].data.d_string);
*width = return_vals[2].data.d_int32;
*grad_data = g_new (gdouble, *width);
for (i = 0; i < *width; i++)
(*grad_data)[i] = return_vals[3].data.d_floatarray[i];
}
@ -1354,10 +1370,10 @@ gimp_gradient_get_gradient_data (gchar *gname,
gint
gimp_gradient_close_popup(void * popup_pnt)
gimp_gradient_close_popup (gpointer popup_pnt)
{
GParam *return_vals;
int nreturn_vals;
gint nreturn_vals;
gint retval;
return_vals = gimp_run_procedure ("gimp_gradients_close_popup",
@ -1373,10 +1389,11 @@ gimp_gradient_close_popup(void * popup_pnt)
}
gint
gimp_gradient_set_popup(void * popup_pnt, gchar * gname)
gimp_gradient_set_popup (gpointer popup_pnt,
gchar *gname)
{
GParam *return_vals;
int nreturn_vals;
gint nreturn_vals;
gint retval;
return_vals = gimp_run_procedure ("gimp_gradients_set_popup",
@ -1391,3 +1408,6 @@ gimp_gradient_set_popup(void * popup_pnt, gchar * gname)
return retval;
}

38
libgimp/gimpmenu.h
View File

@ -34,6 +34,7 @@ typedef gint (*GimpConstraintFunc) (gint32 image_id,
typedef void (*GimpMenuCallback) (gint32 id,
gpointer data);
/* Popup the brush dialog interactively */
typedef void (* GRunBrushCallback) (gchar *name,
gdouble opacity,
@ -42,7 +43,7 @@ typedef void (* GRunBrushCallback) (gchar *name,
gint width,
gint height,
gchar *mask_data,
gint dialog_closing,
gboolean dialog_closing,
gpointer user_data);
/* Popup the pattern dialog */
@ -51,16 +52,17 @@ typedef void (*GRunPatternCallback) (gchar *name,
gint height,
gint bpp,
gchar *mask_data,
gint dialog_closing,
gboolean dialog_closing,
gpointer user_data);
/* Popup the gradient dialog */
typedef void (*GRunGradientCallback) (gchar *name,
gint width,
gdouble *grad_data,
gint dialog_closing,
gboolean dialog_closing,
gpointer user_data);
GtkWidget* gimp_image_menu_new (GimpConstraintFunc constraint,
GimpMenuCallback callback,
gpointer data,
@ -78,7 +80,8 @@ GtkWidget* gimp_drawable_menu_new (GimpConstraintFunc constraint,
gpointer data,
gint32 active_drawable);
void * gimp_interactive_selection_brush (gchar *dialogname,
gpointer gimp_interactive_selection_brush (gchar *dialogname,
gchar *brush_name,
gdouble opacity,
gint spacing,
@ -94,12 +97,12 @@ GtkWidget * gimp_brush_select_widget (gchar *dname,
GRunBrushCallback cback,
gpointer data);
gboolean gimp_brush_select_widget_close_popup (GtkWidget *widget);
gboolean gimp_brush_select_widget_set_popup (GtkWidget *widget,
gchar *pname,
gdouble opacity,
gint spacing,
gint paint_mode);
gboolean gimp_brush_select_widget_close_popup (GtkWidget *widget);
gchar * gimp_brushes_get_brush_data (gchar *pname,
gdouble *opacity,
@ -109,14 +112,15 @@ gchar *gimp_brushes_get_brush_data (gchar *pname,
gint *height,
gchar **mask_data);
gint gimp_brush_set_popup (gpointer popup_pnt,
gboolean gimp_brush_set_popup (gpointer popup_pnt,
gchar *pname,
gdouble opacity,
gint spacing,
gint paint_mode);
gint gimp_brush_close_popup (gpointer popup_pnt);
gboolean gimp_brush_close_popup (gpointer popup_pnt);
void * gimp_interactive_selection_pattern (gchar *dialogtitle,
gpointer gimp_interactive_selection_pattern (gchar *dialogtitle,
gchar *pattern_name,
GRunPatternCallback callback,
gpointer data);
@ -136,35 +140,33 @@ gchar *gimp_pattern_get_pattern_data (gchar *pname,
gint *bytes,
gchar **mask_data);
gint gimp_pattern_set_popup (gpointer popup_pnt,
gboolean gimp_pattern_set_popup (gpointer popup_pnt,
gchar *pname);
gboolean gimp_pattern_close_popup (gpointer popup_pnt);
gint gimp_pattern_close_popup (gpointer popup_pnt);
void * gimp_interactive_selection_gradient (gchar *dialogtitle,
gpointer gimp_interactive_selection_gradient (gchar *dialogtitle,
gchar *gradient_name,
gint sample_sz,
GRunGradientCallback callback,
gpointer udata);
gpointer data);
GtkWidget * gimp_gradient_select_widget (gchar *gname,
gchar *igradient,
GRunGradientCallback cback,
gpointer data);
gint gimp_gradient_select_widget_close_popup (GtkWidget *widget);
gint gimp_gradient_select_widget_set_popup (GtkWidget *widget,
gboolean gimp_gradient_select_widget_set_popup (GtkWidget *widget,
gchar *pname);
gboolean gimp_gradient_select_widget_close_popup (GtkWidget *widget);
gchar * gimp_gradient_get_gradient_data (gchar *pname,
gint *width,
gint sample_sz,
gdouble **mask_data);
gint gimp_gradient_set_popup (gpointer popup_pnt,
gboolean gimp_gradient_set_popup (gpointer popup_pnt,
gchar *pname);
gint gimp_gradient_close_popup (gpointer popup_pnt);
gboolean gimp_gradient_close_popup (gpointer popup_pnt);
#ifdef __cplusplus
}