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

plug-ins/FractalExplorer/*.[ch] plug-ins/Lighting/*.[ch] 

2000-08-22  Sven Neumann  <sven@gimp.org>

* plug-ins/FractalExplorer/*.[ch]
* plug-ins/Lighting/*.[ch]
* plug-ins/MapObject/*.[ch]
* plug-ins/bmp/*.[ch]
* plug-ins/faxg3/faxg3.c
* plug-ins/fits/fits.c
* plug-ins/flame/flame.c
* plug-ins/fp/*.[ch]
* plug-ins/gap/*.[ch]
* plug-ins/gdyntext/*.[ch]
* plug-ins/gfig/gfig.c
* plug-ins/gflare/gflare.c
* plug-ins/gfli/gfli.c
* plug-ins/gimpressionist/*.c
* plug-ins/script-fu/*.[ch]: removed COMPAT_CRUFT.
This commit is contained in:
Sven Neumann 2000-08-22 03:27:14 +00:00 committed by Sven Neumann
parent fdd6acd82f
commit 72403e73d3
78 changed files with 1829 additions and 1808 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ChangeLog
View File

@ -1,3 +1,21 @@
2000-08-22 Sven Neumann <sven@gimp.org>
* plug-ins/FractalExplorer/*.[ch]
* plug-ins/Lighting/*.[ch]
* plug-ins/MapObject/*.[ch]
* plug-ins/bmp/*.[ch]
* plug-ins/faxg3/faxg3.c
* plug-ins/fits/fits.c
* plug-ins/flame/flame.c
* plug-ins/fp/*.[ch]
* plug-ins/gap/*.[ch]
* plug-ins/gdyntext/*.[ch]
* plug-ins/gfig/gfig.c
* plug-ins/gflare/gflare.c
* plug-ins/gfli/gfli.c
* plug-ins/gimpressionist/*.c
* plug-ins/script-fu/*.[ch]: removed COMPAT_CRUFT.
Tue Aug 22 03:35:46 CEST 2000 Daniel Egger <egger@suse.de> Tue Aug 22 03:35:46 CEST 2000 Daniel Egger <egger@suse.de>
* plug-ins/common/AlienMap.c: Cleaned up AlienMap * plug-ins/common/AlienMap.c: Cleaned up AlienMap

4
plug-ins/FractalExplorer/Dialogs.c
View File

@ -205,7 +205,7 @@ explorer_number_of_colors_callback (GtkAdjustment *adjustment,
if (gradient_name == NULL) if (gradient_name == NULL)
gradient_name = gimp_gradients_get_active (); gradient_name = gimp_gradients_get_active ();
gimp_gradient_get_gradient_data (gradient_name, &dummy, wvals.ncolors, gimp_gradients_get_gradient_data (gradient_name, &dummy, wvals.ncolors,
&gradient_samples); &gradient_samples);
set_cmap_preview (); set_cmap_preview ();
@ -226,7 +226,7 @@ explorer_gradient_select_callback (gchar *name,
gradient_name = g_strdup (name); gradient_name = g_strdup (name);
gimp_gradient_get_gradient_data (gradient_name, &dummy, wvals.ncolors, gimp_gradients_get_gradient_data (gradient_name, &dummy, wvals.ncolors,
&gradient_samples); &gradient_samples);
if (wvals.colormode == 1) if (wvals.colormode == 1)

88
plug-ins/FractalExplorer/FractalExplorer.c
View File

@ -96,11 +96,11 @@
static void query (void); static void query (void);
static void run (gchar *name, static void run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
static void explorer (GDrawable *drawable); static void explorer (GimpDrawable *drawable);
static void explorer_render_row (const guchar *src_row, static void explorer_render_row (const guchar *src_row,
guchar *dest_row, guchar *dest_row,
gint row, gint row,
@ -158,7 +158,7 @@ static void fractalexplorer_rescan_ok_callback (GtkWidget *widget,
static void fractalexplorer_rescan_list (void); static void fractalexplorer_rescan_list (void);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -179,29 +179,29 @@ MAIN()
static void static void
query (void) query (void)
{ {
static GParamDef args[] = static GimpParamDef args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" }, { GIMP_PDB_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_INT8, "fractaltype", "0: Mandelbrot; 1: Julia; 2: Barnsley 1; 3: Barnsley 2; 4: Barnsley 3; 5: Spider; 6: ManOWar; 7: Lambda; 8: Sierpinski" }, { GIMP_PDB_INT8, "fractaltype", "0: Mandelbrot; 1: Julia; 2: Barnsley 1; 3: Barnsley 2; 4: Barnsley 3; 5: Spider; 6: ManOWar; 7: Lambda; 8: Sierpinski" },
{ PARAM_FLOAT, "xmin", "xmin fractal image delimiter" }, { GIMP_PDB_FLOAT, "xmin", "xmin fractal image delimiter" },
{ PARAM_FLOAT, "xmax", "xmax fractal image delimiter" }, { GIMP_PDB_FLOAT, "xmax", "xmax fractal image delimiter" },
{ PARAM_FLOAT, "ymin", "ymin fractal image delimiter" }, { GIMP_PDB_FLOAT, "ymin", "ymin fractal image delimiter" },
{ PARAM_FLOAT, "ymax", "ymax fractal image delimiter" }, { GIMP_PDB_FLOAT, "ymax", "ymax fractal image delimiter" },
{ PARAM_FLOAT, "iter", "Iteration value" }, { GIMP_PDB_FLOAT, "iter", "Iteration value" },
{ PARAM_FLOAT, "cx", "cx value ( only Julia)" }, { GIMP_PDB_FLOAT, "cx", "cx value ( only Julia)" },
{ PARAM_FLOAT, "cy", "cy value ( only Julia)" }, { GIMP_PDB_FLOAT, "cy", "cy value ( only Julia)" },
{ PARAM_INT8, "colormode", "0: Apply colormap as specified by the parameters below; 1: Apply active gradient to final image" }, { GIMP_PDB_INT8, "colormode", "0: Apply colormap as specified by the parameters below; 1: Apply active gradient to final image" },
{ PARAM_FLOAT, "redstretch", "Red stretching factor" }, { GIMP_PDB_FLOAT, "redstretch", "Red stretching factor" },
{ PARAM_FLOAT, "greenstretch", "Green stretching factor" }, { GIMP_PDB_FLOAT, "greenstretch", "Green stretching factor" },
{ PARAM_FLOAT, "bluestretch", "Blue stretching factor" }, { GIMP_PDB_FLOAT, "bluestretch", "Blue stretching factor" },
{ PARAM_INT8, "redmode", "Red application mode (0:SIN;1:COS;2:NONE)" }, { GIMP_PDB_INT8, "redmode", "Red application mode (0:SIN;1:COS;2:NONE)" },
{ PARAM_INT8, "greenmode", "Green application mode (0:SIN;1:COS;2:NONE)" }, { GIMP_PDB_INT8, "greenmode", "Green application mode (0:SIN;1:COS;2:NONE)" },
{ PARAM_INT8, "bluemode", "Blue application mode (0:SIN;1:COS;2:NONE)" }, { GIMP_PDB_INT8, "bluemode", "Blue application mode (0:SIN;1:COS;2:NONE)" },
{ PARAM_INT8, "redinvert", "Red inversion mode (1: enabled; 0: disabled)" }, { GIMP_PDB_INT8, "redinvert", "Red inversion mode (1: enabled; 0: disabled)" },
{ PARAM_INT8, "greeninvert", "Green inversion mode (1: enabled; 0: disabled)" }, { GIMP_PDB_INT8, "greeninvert", "Green inversion mode (1: enabled; 0: disabled)" },
{ PARAM_INT8, "blueinvert", "Green inversion mode (1: enabled; 0: disabled)" }, { GIMP_PDB_INT8, "blueinvert", "Green inversion mode (1: enabled; 0: disabled)" },
}; };
static gint nargs = sizeof(args) / sizeof(args[0]); static gint nargs = sizeof(args) / sizeof(args[0]);
@ -215,7 +215,7 @@ query (void)
"December, 1998", "December, 1998",
N_("<Image>/Filters/Render/Pattern/Fractal Explorer..."), N_("<Image>/Filters/Render/Pattern/Fractal Explorer..."),
"RGB*", "RGB*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs, 0, nargs, 0,
args, NULL); args, NULL);
} }
@ -227,22 +227,22 @@ query (void)
static void static void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[1]; static GimpParam values[1];
gint32 image_ID; gint32 image_ID;
GRunModeType run_mode; GimpRunModeType run_mode;
gdouble xhsiz; gdouble xhsiz;
gdouble yhsiz; gdouble yhsiz;
gint pwidth; gint pwidth;
gint pheight; gint pheight;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32; run_mode = param[0].data.d_int32;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
*nreturn_vals = 1; *nreturn_vals = 1;
@ -289,7 +289,7 @@ run (gchar *name,
/* See how we will run */ /* See how we will run */
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */ /* Possibly retrieve data */
gimp_get_data ("plug_in_fractalexplorer", &wvals); gimp_get_data ("plug_in_fractalexplorer", &wvals);
@ -299,11 +299,11 @@ run (gchar *name,
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are present */ /* Make sure all the arguments are present */
if (nparams != 22) if (nparams != 22)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
else else
{ {
@ -330,7 +330,7 @@ run (gchar *name,
make_color_map(); make_color_map();
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */ /* Possibly retrieve data */
gimp_get_data ("plug_in_fractalexplorer", &wvals); gimp_get_data ("plug_in_fractalexplorer", &wvals);
make_color_map (); make_color_map ();
@ -347,7 +347,7 @@ run (gchar *name,
cx = wvals.cx; cx = wvals.cx;
cy = wvals.cy; cy = wvals.cy;
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
/* Make sure that the drawable is indexed or RGB color */ /* Make sure that the drawable is indexed or RGB color */
if (gimp_drawable_is_rgb(drawable->id)) if (gimp_drawable_is_rgb(drawable->id))
@ -359,17 +359,17 @@ run (gchar *name,
/* Run! */ /* Run! */
explorer (drawable); explorer (drawable);
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush (); gimp_displays_flush ();
/* Store data */ /* Store data */
if (run_mode == RUN_INTERACTIVE) if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data ("plug_in_fractalexplorer", gimp_set_data ("plug_in_fractalexplorer",
&wvals, sizeof (explorer_vals_t)); &wvals, sizeof (explorer_vals_t));
} }
else else
{ {
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
} }
values[0].data.d_status = status; values[0].data.d_status = status;
@ -382,10 +382,10 @@ run (gchar *name,
*********************************************************************/ *********************************************************************/
static void static void
explorer (GDrawable * drawable) explorer (GimpDrawable * drawable)
{ {
GPixelRgn srcPR; GimpPixelRgn srcPR;
GPixelRgn destPR; GimpPixelRgn destPR;
gint width; gint width;
gint height; gint height;
gint bytes; gint bytes;

4
plug-ins/FractalExplorer/FractalExplorer.h
View File

@ -189,7 +189,7 @@ extern double x_release,
y_release; y_release;
extern float cx; extern float cx;
extern float cy; extern float cy;
extern GDrawable *drawable; extern GimpDrawable *drawable;
extern gint tile_width, extern gint tile_width,
tile_height; tile_height;
extern gint img_width, extern gint img_width,
@ -203,7 +203,7 @@ extern gint sel_width,
sel_height; sel_height;
extern gint preview_width, extern gint preview_width,
preview_height; preview_height;
extern GTile *the_tile; extern GimpTile *the_tile;
extern double cen_x, extern double cen_x,
cen_y; cen_y;
extern double xpos, extern double xpos,

4
plug-ins/FractalExplorer/Globals.c
View File

@ -18,7 +18,7 @@ double x_release = -1.0,
y_release = -1.0; y_release = -1.0;
float cx = -0.75; float cx = -0.75;
float cy = -0.2; float cy = -0.2;
GDrawable *drawable; GimpDrawable *drawable;
gint tile_width, gint tile_width,
tile_height; tile_height;
gint img_width, gint img_width,
@ -32,7 +32,7 @@ gint sel_width,
sel_height; sel_height;
gint preview_width, gint preview_width,
preview_height; preview_height;
GTile *the_tile = NULL; GimpTile *the_tile = NULL;
double cen_x, double cen_x,
cen_y; cen_y;
double xpos, double xpos,

6
plug-ins/Lighting/lighting_apply.c
View File

@ -67,7 +67,7 @@ compute_image (void)
/* Create a new image */ /* Create a new image */
/* ================== */ /* ================== */
new_image_id=gimp_image_new(width,height,RGB); new_image_id=gimp_image_new(width,height,GIMP_RGB);
if (mapvals.transparent_background==TRUE) if (mapvals.transparent_background==TRUE)
{ {
@ -75,7 +75,7 @@ compute_image (void)
/* ================================= */ /* ================================= */
new_layer_id=gimp_layer_new(new_image_id,"Background", new_layer_id=gimp_layer_new(new_image_id,"Background",
width,height,RGBA_IMAGE,100.0,NORMAL_MODE); width,height,GIMP_RGBA_IMAGE,100.0,GIMP_NORMAL_MODE);
} }
else else
{ {
@ -83,7 +83,7 @@ compute_image (void)
/* ======================= */ /* ======================= */
new_layer_id=gimp_layer_new(new_image_id,"Background", new_layer_id=gimp_layer_new(new_image_id,"Background",
width,height,RGB_IMAGE,100.0,NORMAL_MODE); width,height,GIMP_RGB_IMAGE,100.0,GIMP_NORMAL_MODE);
} }
gimp_image_add_layer(new_image_id,new_layer_id,0); gimp_image_add_layer(new_image_id,new_layer_id,0);

18
plug-ins/Lighting/lighting_image.c
View File

@ -13,14 +13,14 @@
#include "lighting_preview.h" #include "lighting_preview.h"
#include "lighting_ui.h" #include "lighting_ui.h"
GDrawable *input_drawable,*output_drawable; GimpDrawable *input_drawable,*output_drawable;
GPixelRgn source_region, dest_region; GimpPixelRgn source_region, dest_region;
GDrawable *bump_drawable = NULL; GimpDrawable *bump_drawable = NULL;
GPixelRgn bump_region; GimpPixelRgn bump_region;
GDrawable *env_drawable = NULL; GimpDrawable *env_drawable = NULL;
GPixelRgn env_region; GimpPixelRgn env_region;
guchar *preview_rgb_data = NULL; guchar *preview_rgb_data = NULL;
GdkImage *image = NULL; GdkImage *image = NULL;
@ -38,7 +38,7 @@ guchar sinemap[256], spheremap[256], logmap[256];
/******************/ /******************/
guchar guchar
peek_map (GPixelRgn *region, peek_map (GimpPixelRgn *region,
gint x, gint x,
gint y) gint y)
{ {
@ -269,7 +269,7 @@ get_image_color (gdouble u,
} }
gdouble gdouble
get_map_value (GPixelRgn *region, get_map_value (GimpPixelRgn *region,
gdouble u, gdouble u,
gdouble v, gdouble v,
gint *inside) gint *inside)
@ -330,7 +330,7 @@ compute_maps (void)
/****************************************/ /****************************************/
gint gint
image_setup (GDrawable *drawable, image_setup (GimpDrawable *drawable,
gint interactive) gint interactive)
{ {
glong numbytes; glong numbytes;

18
plug-ins/Lighting/lighting_image.h
View File

@ -1,14 +1,14 @@
#ifndef __LIGHTING_IMAGE_H__ #ifndef __LIGHTING_IMAGE_H__
#define __LIGHTING_IMAGE_H__ #define __LIGHTING_IMAGE_H__
extern GDrawable *input_drawable,*output_drawable; extern GimpDrawable *input_drawable,*output_drawable;
extern GPixelRgn source_region, dest_region; extern GimpPixelRgn source_region, dest_region;
extern GDrawable *bump_drawable; extern GimpDrawable *bump_drawable;
extern GPixelRgn bump_region; extern GimpPixelRgn bump_region;
extern GDrawable *env_drawable; extern GimpDrawable *env_drawable;
extern GPixelRgn env_region; extern GimpPixelRgn env_region;
extern guchar *preview_rgb_data; extern guchar *preview_rgb_data;
extern GdkImage *image; extern GdkImage *image;
@ -21,7 +21,7 @@ extern gint border_x1,border_y1,border_x2,border_y2;
extern guchar sinemap[256], spheremap[256], logmap[256]; extern guchar sinemap[256], spheremap[256], logmap[256];
guchar peek_map (GPixelRgn *region, guchar peek_map (GimpPixelRgn *region,
gint x, gint x,
gint y); gint y);
GckRGB peek (gint x, GckRGB peek (gint x,
@ -48,11 +48,11 @@ void pos_to_float (gdouble x,
GckRGB get_image_color (gdouble u, GckRGB get_image_color (gdouble u,
gdouble v, gdouble v,
gint *inside); gint *inside);
gdouble get_map_value (GPixelRgn *region, gdouble get_map_value (GimpPixelRgn *region,
gdouble u, gdouble u,
gdouble v, gdouble v,
gint *inside); gint *inside);
gint image_setup (GDrawable *drawable, gint image_setup (GimpDrawable *drawable,
gint interactive); gint interactive);
#endif /* __LIGHTING_IMAGE_H__ */ #endif /* __LIGHTING_IMAGE_H__ */

84
plug-ins/Lighting/lighting_main.c
View File

@ -130,32 +130,32 @@ check_drawables (void)
static void static void
query (void) query (void)
{ {
static GParamDef args[] = static GimpParamDef args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive (0), non-interactive (1)" }, { GIMP_PDB_INT32, "run_mode", "Interactive (0), non-interactive (1)" },
{ PARAM_IMAGE, "image", "Input image" }, { GIMP_PDB_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_DRAWABLE, "bumpdrawable", "Bumpmap drawable (set to 0 if disabled)" }, { GIMP_PDB_DRAWABLE, "bumpdrawable", "Bumpmap drawable (set to 0 if disabled)" },
{ PARAM_DRAWABLE, "envdrawable", "Environmentmap drawable (set to 0 if disabled)" }, { GIMP_PDB_DRAWABLE, "envdrawable", "Environmentmap drawable (set to 0 if disabled)" },
{ PARAM_INT32, "dobumpmap", "Enable bumpmapping (TRUE/FALSE)" }, { GIMP_PDB_INT32, "dobumpmap", "Enable bumpmapping (TRUE/FALSE)" },
{ PARAM_INT32, "doenvmap", "Enable envmapping (TRUE/FALSE)" }, { GIMP_PDB_INT32, "doenvmap", "Enable envmapping (TRUE/FALSE)" },
{ PARAM_INT32, "bumpmaptype", "Type of mapping (0=linear,1=log, 2=sinusoidal, 3=spherical)" }, { GIMP_PDB_INT32, "bumpmaptype", "Type of mapping (0=linear,1=log, 2=sinusoidal, 3=spherical)" },
{ PARAM_INT32, "lighttype", "Type of lightsource (0=point,1=directional,3=spot,4=none)" }, { GIMP_PDB_INT32, "lighttype", "Type of lightsource (0=point,1=directional,3=spot,4=none)" },
{ PARAM_COLOR, "lightcolor", "Lightsource color (r,g,b)" }, { GIMP_PDB_COLOR, "lightcolor", "Lightsource color (r,g,b)" },
{ PARAM_FLOAT, "lightposition_x", "Lightsource position (x,y,z)" }, { GIMP_PDB_FLOAT, "lightposition_x", "Lightsource position (x,y,z)" },
{ PARAM_FLOAT, "lightposition_y", "Lightsource position (x,y,z)" }, { GIMP_PDB_FLOAT, "lightposition_y", "Lightsource position (x,y,z)" },
{ PARAM_FLOAT, "lightposition_z", "Lightsource position (x,y,z)" }, { GIMP_PDB_FLOAT, "lightposition_z", "Lightsource position (x,y,z)" },
{ PARAM_FLOAT, "lightdirection_x", "Lightsource direction [x,y,z]" }, { GIMP_PDB_FLOAT, "lightdirection_x", "Lightsource direction [x,y,z]" },
{ PARAM_FLOAT, "lightdirection_y", "Lightsource direction [x,y,z]" }, { GIMP_PDB_FLOAT, "lightdirection_y", "Lightsource direction [x,y,z]" },
{ PARAM_FLOAT, "lightdirection_z", "Lightsource direction [x,y,z]" }, { GIMP_PDB_FLOAT, "lightdirection_z", "Lightsource direction [x,y,z]" },
{ PARAM_FLOAT, "ambient_intensity", "Material ambient intensity (0..1)" }, { GIMP_PDB_FLOAT, "ambient_intensity", "Material ambient intensity (0..1)" },
{ PARAM_FLOAT, "diffuse_intensity", "Material diffuse intensity (0..1)" }, { GIMP_PDB_FLOAT, "diffuse_intensity", "Material diffuse intensity (0..1)" },
{ PARAM_FLOAT, "diffuse_reflectivity", "Material diffuse reflectivity (0..1)" }, { GIMP_PDB_FLOAT, "diffuse_reflectivity", "Material diffuse reflectivity (0..1)" },
{ PARAM_FLOAT, "specular_reflectivity", "Material specular reflectivity (0..1)" }, { GIMP_PDB_FLOAT, "specular_reflectivity", "Material specular reflectivity (0..1)" },
{ PARAM_FLOAT, "highlight", "Material highlight (0..->), note: it's expotential" }, { GIMP_PDB_FLOAT, "highlight", "Material highlight (0..->), note: it's expotential" },
{ PARAM_INT32, "antialiasing", "Apply antialiasing (TRUE/FALSE)" }, { GIMP_PDB_INT32, "antialiasing", "Apply antialiasing (TRUE/FALSE)" },
{ PARAM_INT32, "newimage", "Create a new image (TRUE/FALSE)" }, { GIMP_PDB_INT32, "newimage", "Create a new image (TRUE/FALSE)" },
{ PARAM_INT32, "transparentbackground", "Make background transparent (TRUE/FALSE)" } { GIMP_PDB_INT32, "transparentbackground", "Make background transparent (TRUE/FALSE)" }
}; };
static gint nargs = sizeof (args) / sizeof (args[0]); static gint nargs = sizeof (args) / sizeof (args[0]);
@ -169,7 +169,7 @@ query (void)
"Version 0.2.0, March 15 1998", "Version 0.2.0, March 15 1998",
N_("<Image>/Filters/Light Effects/Lighting Effects..."), N_("<Image>/Filters/Light Effects/Lighting Effects..."),
"RGB*", "RGB*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs, 0, nargs, 0,
args, NULL); args, NULL);
} }
@ -177,18 +177,18 @@ query (void)
static void static void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[1]; static GimpParam values[1];
GDrawable *drawable; GimpDrawable *drawable;
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32; run_mode = param[0].data.d_int32;
if (run_mode == RUN_INTERACTIVE) if (run_mode == GIMP_RUN_INTERACTIVE)
{ {
INIT_I18N_UI(); INIT_I18N_UI();
} }
@ -200,7 +200,7 @@ run (gchar *name,
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
/* Set default values */ /* Set default values */
@ -222,7 +222,7 @@ run (gchar *name,
check_drawables (); check_drawables ();
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
/* Make sure that the drawable is RGBA or RGB color */ /* Make sure that the drawable is RGBA or RGB color */
/* ================================================ */ /* ================================================ */
@ -236,7 +236,7 @@ run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
if (main_dialog (drawable)) if (main_dialog (drawable))
{ {
compute_image (); compute_image ();
@ -246,15 +246,15 @@ run (gchar *name,
} }
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
image_setup (drawable, FALSE); image_setup (drawable, FALSE);
compute_image (); compute_image ();
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
if (nparams != 24) if (nparams != 24)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
else else
{ {
@ -291,10 +291,10 @@ run (gchar *name,
} }
} }
else else
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush (); gimp_displays_flush ();
values[0].data.d_status = status; values[0].data.d_status = status;
@ -306,7 +306,7 @@ run (gchar *name,
g_free (ypostab); g_free (ypostab);
} }
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */

2
plug-ins/Lighting/lighting_ui.c
View File

@ -1045,7 +1045,7 @@ create_main_notebook (GtkWidget *container)
/********************************/ /********************************/
gboolean gboolean
main_dialog (GDrawable *drawable) main_dialog (GimpDrawable *drawable)
{ {
GtkWidget *main_hbox; GtkWidget *main_hbox;
GtkWidget *vbox; GtkWidget *vbox;

2
plug-ins/Lighting/lighting_ui.h
View File

@ -12,6 +12,6 @@ extern GtkWidget *previewarea;
/* Externally visible functions */ /* Externally visible functions */
/* ============================ */ /* ============================ */
gboolean main_dialog (GDrawable *drawable); gboolean main_dialog (GimpDrawable *drawable);
#endif /* __LIGHTING_UI_H__ */ #endif /* __LIGHTING_UI_H__ */

6
plug-ins/MapObject/mapobject_apply.c
View File

@ -204,21 +204,21 @@ void compute_image(void)
/* Create a new image */ /* Create a new image */
/* ================== */ /* ================== */
new_image_id=gimp_image_new(width,height,RGB); new_image_id=gimp_image_new(width,height,GIMP_RGB);
if (mapvals.transparent_background==TRUE) if (mapvals.transparent_background==TRUE)
{ {
/* Add a layer with an alpha channel */ /* Add a layer with an alpha channel */
/* ================================= */ /* ================================= */
new_layer_id=gimp_layer_new(new_image_id,"Background",width,height,RGBA_IMAGE,100.0,NORMAL_MODE); new_layer_id=gimp_layer_new(new_image_id,"Background",width,height,GIMP_RGBA_IMAGE,100.0,GIMP_NORMAL_MODE);
} }
else else
{ {
/* Create a "normal" layer */ /* Create a "normal" layer */
/* ======================= */ /* ======================= */
new_layer_id=gimp_layer_new(new_image_id,"Background",width,height,RGB_IMAGE,100.0,NORMAL_MODE); new_layer_id=gimp_layer_new(new_image_id,"Background",width,height,GIMP_RGB_IMAGE,100.0,GIMP_NORMAL_MODE);
} }
gimp_image_add_layer(new_image_id,new_layer_id,0); gimp_image_add_layer(new_image_id,new_layer_id,0);

14
plug-ins/MapObject/mapobject_image.c
View File

@ -19,14 +19,14 @@
#include "mapobject_ui.h" #include "mapobject_ui.h"
#include "mapobject_image.h" #include "mapobject_image.h"
GDrawable *input_drawable,*output_drawable; GimpDrawable *input_drawable,*output_drawable;
GPixelRgn source_region,dest_region; GimpPixelRgn source_region,dest_region;
GDrawable *box_drawables[6]; GimpDrawable *box_drawables[6];
GPixelRgn box_regions[6]; GimpPixelRgn box_regions[6];
GDrawable *cylinder_drawables[2]; GimpDrawable *cylinder_drawables[2];
GPixelRgn cylinder_regions[2]; GimpPixelRgn cylinder_regions[2];
guchar *preview_rgb_data = NULL; guchar *preview_rgb_data = NULL;
GdkImage *image = NULL; GdkImage *image = NULL;
@ -326,7 +326,7 @@ get_cylinder_image_color (gint image,
/****************************************/ /****************************************/
gint gint
image_setup (GDrawable *drawable, image_setup (GimpDrawable *drawable,
gint interactive) gint interactive)
{ {
glong numbytes; glong numbytes;

16
plug-ins/MapObject/mapobject_image.h
View File

@ -4,14 +4,14 @@
/* Externally visible variables */ /* Externally visible variables */
/* ============================ */ /* ============================ */
extern GDrawable *input_drawable,*output_drawable; extern GimpDrawable *input_drawable,*output_drawable;
extern GPixelRgn source_region,dest_region; extern GimpPixelRgn source_region,dest_region;
extern GDrawable *box_drawables[6]; extern GimpDrawable *box_drawables[6];
extern GPixelRgn box_regions[6]; extern GimpPixelRgn box_regions[6];
extern GDrawable *cylinder_drawables[2]; extern GimpDrawable *cylinder_drawables[2];
extern GPixelRgn cylinder_regions[2]; extern GimpPixelRgn cylinder_regions[2];
extern guchar *preview_rgb_data; extern guchar *preview_rgb_data;
extern GdkImage *image; extern GdkImage *image;
@ -23,12 +23,12 @@ extern gdouble oldtreshold;
extern gint border_x1, border_y1, border_x2, border_y2; extern gint border_x1, border_y1, border_x2, border_y2;
extern GTile *current_in_tile, *current_out_tile; extern GimpTile *current_in_tile, *current_out_tile;
/* Externally visible functions */ /* Externally visible functions */
/* ============================ */ /* ============================ */
extern gint image_setup (GDrawable *drawable, extern gint image_setup (GimpDrawable *drawable,
gint interactive); gint interactive);
extern glong in_xy_to_index (gint x, extern glong in_xy_to_index (gint x,
gint y); gint y);

132
plug-ins/MapObject/mapobject_main.c
View File

@ -104,7 +104,7 @@ set_default_settings (void)
} }
static void static void
check_drawables (GDrawable *drawable) check_drawables (GimpDrawable *drawable)
{ {
gint i; gint i;
@ -140,57 +140,57 @@ check_drawables (GDrawable *drawable)
static void static void
query (void) query (void)
{ {
static GParamDef args[] = static GimpParamDef args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive (0), non-interactive (1)" }, { GIMP_PDB_INT32, "run_mode", "Interactive (0), non-interactive (1)" },
{ PARAM_IMAGE, "image", "Input image" }, { GIMP_PDB_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_INT32, "maptype", "Type of mapping (0=plane,1=sphere,2=box,3=cylinder)" }, { GIMP_PDB_INT32, "maptype", "Type of mapping (0=plane,1=sphere,2=box,3=cylinder)" },
{ PARAM_FLOAT, "viewpoint_x", "Position of viewpoint (x,y,z)" }, { GIMP_PDB_FLOAT, "viewpoint_x", "Position of viewpoint (x,y,z)" },
{ PARAM_FLOAT, "viewpoint_y", "Position of viewpoint (x,y,z)" }, { GIMP_PDB_FLOAT, "viewpoint_y", "Position of viewpoint (x,y,z)" },
{ PARAM_FLOAT, "viewpoint_z", "Position of viewpoint (x,y,z)" }, { GIMP_PDB_FLOAT, "viewpoint_z", "Position of viewpoint (x,y,z)" },
{ PARAM_FLOAT, "position_x", "Object position (x,y,z)" }, { GIMP_PDB_FLOAT, "position_x", "Object position (x,y,z)" },
{ PARAM_FLOAT, "position_y", "Object position (x,y,z)" }, { GIMP_PDB_FLOAT, "position_y", "Object position (x,y,z)" },
{ PARAM_FLOAT, "position_z", "Object position (x,y,z)" }, { GIMP_PDB_FLOAT, "position_z", "Object position (x,y,z)" },
{ PARAM_FLOAT, "firstaxis_x", "First axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "firstaxis_x", "First axis of object [x,y,z]" },
{ PARAM_FLOAT, "firstaxis_y", "First axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "firstaxis_y", "First axis of object [x,y,z]" },
{ PARAM_FLOAT, "firstaxis_z", "First axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "firstaxis_z", "First axis of object [x,y,z]" },
{ PARAM_FLOAT, "secondaxis_x", "Second axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "secondaxis_x", "Second axis of object [x,y,z]" },
{ PARAM_FLOAT, "secondaxis_y", "Second axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "secondaxis_y", "Second axis of object [x,y,z]" },
{ PARAM_FLOAT, "secondaxis_z", "Second axis of object [x,y,z]" }, { GIMP_PDB_FLOAT, "secondaxis_z", "Second axis of object [x,y,z]" },
{ PARAM_FLOAT, "rotationangle_x", "Rotation about X axis in degrees" }, { GIMP_PDB_FLOAT, "rotationangle_x", "Rotation about X axis in degrees" },
{ PARAM_FLOAT, "rotationangle_y", "Rotation about Y axis in degrees" }, { GIMP_PDB_FLOAT, "rotationangle_y", "Rotation about Y axis in degrees" },
{ PARAM_FLOAT, "rotationangle_z", "Rotation about Z axis in degrees" }, { GIMP_PDB_FLOAT, "rotationangle_z", "Rotation about Z axis in degrees" },
{ PARAM_INT32, "lighttype", "Type of lightsource (0=point,1=directional,3=none)" }, { GIMP_PDB_INT32, "lighttype", "Type of lightsource (0=point,1=directional,3=none)" },
{ PARAM_COLOR, "lightcolor", "Lightsource color (r,g,b)" }, { GIMP_PDB_COLOR, "lightcolor", "Lightsource color (r,g,b)" },
{ PARAM_FLOAT, "lightposition_x", "Lightsource position (x,y,z)" }, { GIMP_PDB_FLOAT, "lightposition_x", "Lightsource position (x,y,z)" },
{ PARAM_FLOAT, "lightposition_y", "Lightsource position (x,y,z)" }, { GIMP_PDB_FLOAT, "lightposition_y", "Lightsource position (x,y,z)" },
{ PARAM_FLOAT, "lightposition_z", "Lightsource position (x,y,z)" }, { GIMP_PDB_FLOAT, "lightposition_z", "Lightsource position (x,y,z)" },
{ PARAM_FLOAT, "lightdirection_x", "Lightsource direction [x,y,z]" }, { GIMP_PDB_FLOAT, "lightdirection_x", "Lightsource direction [x,y,z]" },
{ PARAM_FLOAT, "lightdirection_y", "Lightsource direction [x,y,z]" }, { GIMP_PDB_FLOAT, "lightdirection_y", "Lightsource direction [x,y,z]" },
{ PARAM_FLOAT, "lightdirection_z", "Lightsource direction [x,y,z]" }, { GIMP_PDB_FLOAT, "lightdirection_z", "Lightsource direction [x,y,z]" },
{ PARAM_FLOAT, "ambient_intensity", "Material ambient intensity (0..1)" }, { GIMP_PDB_FLOAT, "ambient_intensity", "Material ambient intensity (0..1)" },
{ PARAM_FLOAT, "diffuse_intensity", "Material diffuse intensity (0..1)" }, { GIMP_PDB_FLOAT, "diffuse_intensity", "Material diffuse intensity (0..1)" },
{ PARAM_FLOAT, "diffuse_reflectivity", "Material diffuse reflectivity (0..1)" }, { GIMP_PDB_FLOAT, "diffuse_reflectivity", "Material diffuse reflectivity (0..1)" },
{ PARAM_FLOAT, "specular_reflectivity", "Material specular reflectivity (0..1)" }, { GIMP_PDB_FLOAT, "specular_reflectivity", "Material specular reflectivity (0..1)" },
{ PARAM_FLOAT, "highlight", "Material highlight (0..->), note: it's expotential" }, { GIMP_PDB_FLOAT, "highlight", "Material highlight (0..->), note: it's expotential" },
{ PARAM_INT32, "antialiasing", "Apply antialiasing (TRUE/FALSE)" }, { GIMP_PDB_INT32, "antialiasing", "Apply antialiasing (TRUE/FALSE)" },
{ PARAM_INT32, "tiled", "Tile source image (TRUE/FALSE)" }, { GIMP_PDB_INT32, "tiled", "Tile source image (TRUE/FALSE)" },
{ PARAM_INT32, "newimage", "Create a new image (TRUE/FALSE)" }, { GIMP_PDB_INT32, "newimage", "Create a new image (TRUE/FALSE)" },
{ PARAM_INT32, "transparentbackground", "Make background transparent (TRUE/FALSE)" }, { GIMP_PDB_INT32, "transparentbackground", "Make background transparent (TRUE/FALSE)" },
{ PARAM_FLOAT, "radius", "Sphere/cylinder radius (only used when maptype=1 or 3)" }, { GIMP_PDB_FLOAT, "radius", "Sphere/cylinder radius (only used when maptype=1 or 3)" },
{ PARAM_FLOAT, "x_scale", "Box x size (0..->)" }, { GIMP_PDB_FLOAT, "x_scale", "Box x size (0..->)" },
{ PARAM_FLOAT, "y_scale", "Box y size (0..->)" }, { GIMP_PDB_FLOAT, "y_scale", "Box y size (0..->)" },
{ PARAM_FLOAT, "z_scale", "Box z size (0..->)"}, { GIMP_PDB_FLOAT, "z_scale", "Box z size (0..->)"},
{ PARAM_FLOAT, "cylinder_length", "Cylinder length (0..->)"}, { GIMP_PDB_FLOAT, "cylinder_length", "Cylinder length (0..->)"},
{ PARAM_DRAWABLE, "box_front_drawable", "Box front face (set these to -1 if not used)" }, { GIMP_PDB_DRAWABLE, "box_front_drawable", "Box front face (set these to -1 if not used)" },
{ PARAM_DRAWABLE, "box_back_drawable", "Box back face" }, { GIMP_PDB_DRAWABLE, "box_back_drawable", "Box back face" },
{ PARAM_DRAWABLE, "box_top_drawable", "Box top face" }, { GIMP_PDB_DRAWABLE, "box_top_drawable", "Box top face" },
{ PARAM_DRAWABLE, "box_bottom_drawable", "Box bottom face" }, { GIMP_PDB_DRAWABLE, "box_bottom_drawable", "Box bottom face" },
{ PARAM_DRAWABLE, "box_left_drawable", "Box left face" }, { GIMP_PDB_DRAWABLE, "box_left_drawable", "Box left face" },
{ PARAM_DRAWABLE, "box_right_drawable", "Box right face" }, { GIMP_PDB_DRAWABLE, "box_right_drawable", "Box right face" },
{ PARAM_DRAWABLE, "cyl_top_drawable", "Cylinder top face (set these to -1 if not used)" }, { GIMP_PDB_DRAWABLE, "cyl_top_drawable", "Cylinder top face (set these to -1 if not used)" },
{ PARAM_DRAWABLE, "cyl_bottom_drawable", "Cylinder bottom face" } { GIMP_PDB_DRAWABLE, "cyl_bottom_drawable", "Cylinder bottom face" }
}; };
static gint nargs = sizeof (args) / sizeof (args[0]); static gint nargs = sizeof (args) / sizeof (args[0]);
@ -204,7 +204,7 @@ query (void)
"Version 1.2.0, July 16 1998", "Version 1.2.0, July 16 1998",
N_("<Image>/Filters/Map/Map Object..."), N_("<Image>/Filters/Map/Map Object..."),
"RGB*", "RGB*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs, 0, nargs, 0,
args, NULL); args, NULL);
} }
@ -212,19 +212,19 @@ query (void)
static void static void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[1]; static GimpParam values[1];
GDrawable *drawable; GimpDrawable *drawable;
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint i; gint i;
run_mode = param[0].data.d_int32; run_mode = param[0].data.d_int32;
if (run_mode == RUN_INTERACTIVE) if (run_mode == GIMP_RUN_INTERACTIVE)
{ {
INIT_I18N_UI(); INIT_I18N_UI();
} }
@ -233,7 +233,7 @@ run (gchar *name,
INIT_I18N(); INIT_I18N();
} }
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
*nreturn_vals = 1; *nreturn_vals = 1;
@ -251,7 +251,7 @@ run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */ /* Possibly retrieve data */
/* ====================== */ /* ====================== */
@ -267,17 +267,17 @@ run (gchar *name,
} }
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data ("plug_in_map_object", &mapvals); gimp_get_data ("plug_in_map_object", &mapvals);
check_drawables (drawable); check_drawables (drawable);
image_setup (drawable, FALSE); image_setup (drawable, FALSE);
compute_image (); compute_image ();
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
if (nparams != 49) if (nparams != 49)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
else else
{ {
@ -340,13 +340,13 @@ run (gchar *name,
values[0].data.d_status = status; values[0].data.d_status = status;
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush (); gimp_displays_flush ();
gimp_drawable_detach (drawable); gimp_drawable_detach (drawable);
} }
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */

2
plug-ins/MapObject/mapobject_ui.c
View File

@ -1346,7 +1346,7 @@ create_main_notebook (GtkWidget *container)
/********************************/ /********************************/
gboolean gboolean
main_dialog (GDrawable *drawable) main_dialog (GimpDrawable *drawable)
{ {
GtkWidget *main_hbox; GtkWidget *main_hbox;
GtkWidget *vbox; GtkWidget *vbox;

2
plug-ins/MapObject/mapobject_ui.h
View File

@ -12,6 +12,6 @@ extern GtkWidget *previewarea;
/* Externally visible functions */ /* Externally visible functions */
/* ============================ */ /* ============================ */
gboolean main_dialog (GDrawable *drawable); gboolean main_dialog (GimpDrawable *drawable);
#endif /* __MAPOBJECT_UI_H__ */ #endif /* __MAPOBJECT_UI_H__ */

78
plug-ins/bmp/bmp.c
View File

@ -76,11 +76,11 @@ struct Bitmap_Head_Struct Bitmap_Head;
static void query (void); static void query (void);
static void run (gchar *name, static void run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -93,27 +93,27 @@ MAIN ()
static void static void
query (void) query (void)
{ {
static GParamDef load_args[] = static GimpParamDef load_args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_STRING, "filename", "The name of the file to load" }, { GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name entered" }, { GIMP_PDB_STRING, "raw_filename", "The name entered" },
}; };
static GParamDef load_return_vals[] = static GimpParamDef load_return_vals[] =
{ {
{ PARAM_IMAGE, "image", "Output image" }, { GIMP_PDB_IMAGE, "image", "Output image" },
}; };
static gint nload_args = sizeof (load_args) / sizeof (load_args[0]); static gint nload_args = sizeof (load_args) / sizeof (load_args[0]);
static gint nload_return_vals = (sizeof (load_return_vals) / static gint nload_return_vals = (sizeof (load_return_vals) /
sizeof (load_return_vals[0])); sizeof (load_return_vals[0]));
static GParamDef save_args[] = static GimpParamDef save_args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" }, { GIMP_PDB_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Drawable to save" }, { GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
{ PARAM_STRING, "filename", "The name of the file to save the image in" }, { GIMP_PDB_STRING, "filename", "The name of the file to save the image in" },
{ PARAM_STRING, "raw_filename", "The name entered" }, { GIMP_PDB_STRING, "raw_filename", "The name entered" },
}; };
static gint nsave_args = sizeof (save_args) / sizeof (save_args[0]); static gint nsave_args = sizeof (save_args) / sizeof (save_args[0]);
@ -127,7 +127,7 @@ query (void)
"1997", "1997",
"<Load>/BMP", "<Load>/BMP",
NULL, NULL,
PROC_PLUG_IN, GIMP_PLUGIN,
nload_args, nload_return_vals, nload_args, nload_return_vals,
load_args, load_return_vals); load_args, load_return_vals);
@ -139,7 +139,7 @@ query (void)
"1997", "1997",
"<Save>/BMP", "<Save>/BMP",
"INDEXED, GRAY, RGB", "INDEXED, GRAY, RGB",
PROC_PLUG_IN, GIMP_PLUGIN,
nsave_args, 0, nsave_args, 0,
save_args, NULL); save_args, NULL);
@ -155,13 +155,13 @@ query (void)
static void static void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[2]; static GimpParam values[2];
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_ID; gint32 image_ID;
gint32 drawable_ID; gint32 drawable_ID;
GimpExportReturnType export = EXPORT_CANCEL; GimpExportReturnType export = EXPORT_CANCEL;
@ -170,8 +170,8 @@ run (gchar *name,
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = STATUS_EXECUTION_ERROR; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, "file_bmp_load") == 0) if (strcmp (name, "file_bmp_load") == 0)
{ {
@ -179,34 +179,34 @@ run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
interactive_bmp = TRUE; interactive_bmp = TRUE;
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */ /* Make sure all the arguments are there! */
interactive_bmp = FALSE; interactive_bmp = FALSE;
if (nparams != 3) if (nparams != 3)
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
default: default:
break; break;
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
image_ID = ReadBMP (param[1].data.d_string); image_ID = ReadBMP (param[1].data.d_string);
if (image_ID != -1) if (image_ID != -1)
{ {
*nreturn_vals = 2; *nreturn_vals = 2;
values[1].type = PARAM_IMAGE; values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID; values[1].data.d_image = image_ID;
} }
else else
{ {
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
} }
} }
@ -220,8 +220,8 @@ run (gchar *name,
/* eventually export the image */ /* eventually export the image */
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init ("bmp", FALSE); gimp_ui_init ("bmp", FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, "BMP", export = gimp_export_image (&image_ID, &drawable_ID, "BMP",
(CAN_HANDLE_RGB | (CAN_HANDLE_RGB |
@ -229,7 +229,7 @@ run (gchar *name,
CAN_HANDLE_INDEXED)); CAN_HANDLE_INDEXED));
if (export == EXPORT_CANCEL) if (export == EXPORT_CANCEL)
{ {
values[0].data.d_status = STATUS_CANCEL; values[0].data.d_status = GIMP_PDB_CANCEL;
return; return;
} }
break; break;
@ -239,18 +239,18 @@ run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
interactive_bmp = TRUE; interactive_bmp = TRUE;
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */ /* Make sure all the arguments are there! */
interactive_bmp = FALSE; interactive_bmp = FALSE;
if (nparams != 5) if (nparams != 5)
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
interactive_bmp = FALSE; interactive_bmp = FALSE;
break; break;
@ -258,7 +258,7 @@ run (gchar *name,
break; break;
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
status = WriteBMP (param[3].data.d_string, image_ID, drawable_ID); status = WriteBMP (param[3].data.d_string, image_ID, drawable_ID);
} }
@ -268,7 +268,7 @@ run (gchar *name,
} }
else else
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
values[0].data.d_status = status; values[0].data.d_status = status;

2
plug-ins/bmp/bmp.h
View File

@ -16,7 +16,7 @@ extern gint16 ToS (guchar *);
extern void FromS (gint16, extern void FromS (gint16,
guchar *); guchar *);
extern gint32 ReadBMP (gchar *); extern gint32 ReadBMP (gchar *);
extern GStatusType WriteBMP (gchar *, extern GimpPDBStatusType WriteBMP (gchar *,
gint32, gint32,
gint32); gint32);
extern gint ReadColorMap (FILE *, extern gint ReadColorMap (FILE *,

16
plug-ins/bmp/bmpread.c
View File

@ -269,11 +269,11 @@ ReadImage (FILE *fd,
gint grey) gint grey)
{ {
guchar v,wieviel; guchar v,wieviel;
GPixelRgn pixel_rgn; GimpPixelRgn pixel_rgn;
gint xpos = 0, ypos = 0; gint xpos = 0, ypos = 0;
Image image; Image image;
gint32 layer; gint32 layer;
GDrawable *drawable; GimpDrawable *drawable;
guchar *dest, *temp, *buffer; guchar *dest, *temp, *buffer;
guchar gimp_cmap[768]; guchar gimp_cmap[768];
gushort rgb; gushort rgb;
@ -284,23 +284,23 @@ ReadImage (FILE *fd,
if (bpp >= 16) if (bpp >= 16)
{ {
image = gimp_image_new (width, height, RGB); image = gimp_image_new (width, height, GIMP_RGB);
layer = gimp_layer_new (image, _("Background"), layer = gimp_layer_new (image, _("Background"),
width, height, RGB_IMAGE, 100, NORMAL_MODE); width, height, GIMP_RGB_IMAGE, 100, GIMP_NORMAL_MODE);
channels = 3; channels = 3;
} }
else if (grey) else if (grey)
{ {
image = gimp_image_new (width, height, GRAY); image = gimp_image_new (width, height, GIMP_GRAY);
layer = gimp_layer_new (image, _("Background"), layer = gimp_layer_new (image, _("Background"),
width, height, GRAY_IMAGE, 100, NORMAL_MODE); width, height, GIMP_GRAY_IMAGE, 100, GIMP_NORMAL_MODE);
channels = 1; channels = 1;
} }
else else
{ {
image = gimp_image_new (width, height, INDEXED); image = gimp_image_new (width, height, GIMP_INDEXED);
layer = gimp_layer_new (image, _("Background"), layer = gimp_layer_new (image, _("Background"),
width, height, INDEXED_IMAGE, 100, NORMAL_MODE); width, height, GIMP_INDEXED_IMAGE, 100, GIMP_NORMAL_MODE);
channels = 1; channels = 1;
} }

30
plug-ins/bmp/bmpwrite.c
View File

@ -67,7 +67,7 @@ static gint save_dialog (void);
static void save_ok_callback (GtkWidget *widget, static void save_ok_callback (GtkWidget *widget,
gpointer data); gpointer data);
GStatusType GimpPDBStatusType
WriteBMP (gchar *filename, WriteBMP (gchar *filename,
gint32 image, gint32 image,
gint32 drawable_ID) gint32 drawable_ID)
@ -82,9 +82,9 @@ WriteBMP (gchar *filename,
gint colors; gint colors;
gchar *temp_buf; gchar *temp_buf;
guchar *pixels; guchar *pixels;
GPixelRgn pixel_rgn; GimpPixelRgn pixel_rgn;
GDrawable *drawable; GimpDrawable *drawable;
GDrawableType drawable_type; GimpImageType drawable_type;
guchar puffer[50]; guchar puffer[50];
gint i; gint i;
@ -96,13 +96,13 @@ WriteBMP (gchar *filename,
0, 0, drawable->width, drawable->height, FALSE, FALSE); 0, 0, drawable->width, drawable->height, FALSE, FALSE);
switch (drawable_type) switch (drawable_type)
{ {
case RGB_IMAGE: case GIMP_RGB_IMAGE:
case GRAY_IMAGE: case GIMP_GRAY_IMAGE:
case INDEXED_IMAGE: case GIMP_INDEXED_IMAGE:
break; break;
default: default:
g_message(_("BMP: cannot operate on unknown image types or alpha images")); g_message(_("BMP: cannot operate on unknown image types or alpha images"));
return STATUS_EXECUTION_ERROR; return GIMP_PDB_EXECUTION_ERROR;
break; break;
} }
@ -110,13 +110,13 @@ WriteBMP (gchar *filename,
switch (drawable_type) switch (drawable_type)
{ {
case RGB_IMAGE: case GIMP_RGB_IMAGE:
colors = 0; colors = 0;
BitsPerPixel = 24; BitsPerPixel = 24;
MapSize = 0; MapSize = 0;
channels = 3; channels = 3;
break; break;
case GRAY_IMAGE: case GIMP_GRAY_IMAGE:
colors = 256; colors = 256;
BitsPerPixel = 8; BitsPerPixel = 8;
MapSize = 1024; MapSize = 1024;
@ -128,7 +128,7 @@ WriteBMP (gchar *filename,
Blue[i] = i; Blue[i] = i;
} }
break; break;
case INDEXED_IMAGE: case GIMP_INDEXED_IMAGE:
cmap = gimp_image_get_cmap (image, &colors); cmap = gimp_image_get_cmap (image, &colors);
MapSize = 4 * colors; MapSize = 4 * colors;
channels = 1; channels = 1;
@ -149,7 +149,7 @@ WriteBMP (gchar *filename,
break; break;
default: default:
fprintf (stderr, "%s: This should not happen\n", prog_name); fprintf (stderr, "%s: This should not happen\n", prog_name);
return STATUS_EXECUTION_ERROR; return GIMP_PDB_EXECUTION_ERROR;
} }
/* Perhaps someone wants RLE encoded Bitmaps */ /* Perhaps someone wants RLE encoded Bitmaps */
@ -157,7 +157,7 @@ WriteBMP (gchar *filename,
if ((BitsPerPixel == 8 || BitsPerPixel == 4) && interactive_bmp) if ((BitsPerPixel == 8 || BitsPerPixel == 4) && interactive_bmp)
{ {
if (! save_dialog ()) if (! save_dialog ())
return STATUS_CANCEL; return GIMP_PDB_CANCEL;
} }
/* Let's take some file */ /* Let's take some file */
@ -165,7 +165,7 @@ WriteBMP (gchar *filename,
if (!outfile) if (!outfile)
{ {
g_message (_("Can't open %s"), filename); g_message (_("Can't open %s"), filename);
return STATUS_EXECUTION_ERROR; return GIMP_PDB_EXECUTION_ERROR;
} }
/* fetch the image */ /* fetch the image */
@ -298,7 +298,7 @@ WriteBMP (gchar *filename,
gimp_drawable_detach (drawable); gimp_drawable_detach (drawable);
g_free (pixels); g_free (pixels);
return STATUS_SUCCESS; return GIMP_PDB_SUCCESS;
} }
void void

38
plug-ins/common/fp.c
View File

@ -54,16 +54,16 @@ FP_Params Current =
{0,0,0} {0,0,0}
}; };
GDrawable *drawable, *mask; GimpDrawable *drawable, *mask;
void query (void); void query (void);
void run (gchar *name, void run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -76,11 +76,11 @@ MAIN()
void void
query (void) query (void)
{ {
GParamDef args[] = GimpParamDef args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (used for indexed images)" }, { GIMP_PDB_IMAGE, "image", "Input image (used for indexed images)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
}; };
gint nargs = sizeof (args) / sizeof (args[0]); gint nargs = sizeof (args) / sizeof (args[0]);
@ -92,7 +92,7 @@ query (void)
"27th March 1997", "27th March 1997",
N_("<Image>/Image/Colors/Filter Pack..."), N_("<Image>/Image/Colors/Filter Pack..."),
"RGB*", "RGB*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs, 0, nargs, 0,
args, NULL); args, NULL);
} }
@ -102,19 +102,19 @@ query (void)
void void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
GParam values[1]; GimpParam values[1];
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
INIT_I18N_UI(); INIT_I18N_UI();
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
initializeFilterPacks(); initializeFilterPacks();
@ -126,7 +126,7 @@ run (gchar *name,
gimp_drawable_is_gray (drawable->id) ) gimp_drawable_is_gray (drawable->id) )
{ {
gimp_message (_("Convert the image to RGB first!")); gimp_message (_("Convert the image to RGB first!"));
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
else if (gimp_drawable_is_rgb (drawable->id) && fp_dialog()) else if (gimp_drawable_is_rgb (drawable->id) && fp_dialog())
{ {
@ -135,11 +135,11 @@ run (gchar *name,
fp (drawable); fp (drawable);
gimp_displays_flush (); gimp_displays_flush ();
} }
else status = STATUS_EXECUTION_ERROR; else status = GIMP_PDB_EXECUTION_ERROR;
values[0].data.d_status = status; values[0].data.d_status = status;
if (status==STATUS_SUCCESS) if (status==GIMP_PDB_SUCCESS)
gimp_drawable_detach (drawable); gimp_drawable_detach (drawable);
} }
@ -221,9 +221,9 @@ fp_row (const guchar *src_row,
} }
void fp (GDrawable *drawable) void fp (GimpDrawable *drawable)
{ {
GPixelRgn srcPR, destPR; GimpPixelRgn srcPR, destPR;
gint width, height; gint width, height;
gint bytes; gint bytes;
guchar *src_row, *dest_row; guchar *src_row, *dest_row;

46
plug-ins/faxg3/faxg3.c
View File

@ -54,15 +54,15 @@
static void query (void); static void query (void);
static void run (gchar *name, static void run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
static gint32 load_image (gchar *); static gint32 load_image (gchar *);
gint32 emitgimp (gint, gint, gchar *, gint, gchar *); gint32 emitgimp (gint, gint, gchar *, gint, gchar *);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -74,15 +74,15 @@ MAIN ()
void query (void) void query (void)
{ {
static GParamDef load_args[] = static GimpParamDef load_args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_STRING, "filename", "The name of the file to load" }, { GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name of the file to load" }, { GIMP_PDB_STRING, "raw_filename", "The name of the file to load" },
}; };
static GParamDef load_return_vals[] = static GimpParamDef load_return_vals[] =
{ {
{ PARAM_IMAGE, "image", "Output image" }, { GIMP_PDB_IMAGE, "image", "Output image" },
}; };
static int nload_args = sizeof (load_args) / sizeof (load_args[0]); static int nload_args = sizeof (load_args) / sizeof (load_args[0]);
static int nload_return_vals = sizeof (load_return_vals) / sizeof (load_return_vals[0]); static int nload_return_vals = sizeof (load_return_vals) / sizeof (load_return_vals[0]);
@ -95,7 +95,7 @@ void query (void)
VERSION, VERSION,
"<Load>/Fax G3", "<Load>/Fax G3",
NULL, NULL,
PROC_PLUG_IN, GIMP_PLUGIN,
nload_args, nload_return_vals, nload_args, nload_return_vals,
load_args, load_return_vals); load_args, load_return_vals);
@ -108,20 +108,20 @@ void query (void)
static void static void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[2]; static GimpParam values[2];
GRunModeType run_mode; GimpRunModeType run_mode;
gint32 image_ID; gint32 image_ID;
run_mode = param[0].data.d_int32; run_mode = param[0].data.d_int32;
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = STATUS_CALLING_ERROR; values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
if (strcmp (name, "file_faxg3_load") == 0) if (strcmp (name, "file_faxg3_load") == 0)
{ {
@ -129,16 +129,16 @@ run (gchar *name,
*nreturn_vals = 2; *nreturn_vals = 2;
image_ID = load_image (param[1].data.d_string); image_ID = load_image (param[1].data.d_string);
values[1].type = PARAM_IMAGE; values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID; values[1].data.d_image = image_ID;
if (image_ID != -1) if (image_ID != -1)
{ {
values[0].data.d_status = STATUS_SUCCESS; values[0].data.d_status = GIMP_PDB_SUCCESS;
} }
else else
{ {
values[0].data.d_status = STATUS_EXECUTION_ERROR; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
} }
} }
} }
@ -426,8 +426,8 @@ do_write: /* write pbm (or whatever) file */
gint32 emitgimp ( int hcol, int row, char *bitmap, int bperrow, char *filename ) gint32 emitgimp ( int hcol, int row, char *bitmap, int bperrow, char *filename )
{ {
GPixelRgn pixel_rgn; GimpPixelRgn pixel_rgn;
GDrawable *drawable; GimpDrawable *drawable;
gint32 image_ID; gint32 image_ID;
gint32 layer_ID; gint32 layer_ID;
guchar *buf; guchar *buf;
@ -442,13 +442,13 @@ gint32 emitgimp ( int hcol, int row, char *bitmap, int bperrow, char *filename )
fprintf( stderr, "emit gimp: %d x %d\n", hcol, row); fprintf( stderr, "emit gimp: %d x %d\n", hcol, row);
#endif #endif
image_ID = gimp_image_new (hcol, row, GRAY); image_ID = gimp_image_new (hcol, row, GIMP_GRAY);
gimp_image_set_filename (image_ID, filename); gimp_image_set_filename (image_ID, filename);
layer_ID = gimp_layer_new (image_ID, _("Background"), layer_ID = gimp_layer_new (image_ID, _("Background"),
hcol, hcol,
row, row,
GRAY_IMAGE, 100, NORMAL_MODE); GIMP_GRAY_IMAGE, 100, GIMP_NORMAL_MODE);
gimp_image_add_layer (image_ID, layer_ID, 0); gimp_image_add_layer (image_ID, layer_ID, 0);
drawable = gimp_drawable_get (layer_ID); drawable = gimp_drawable_get (layer_ID);

168
plug-ins/fits/fits.c
View File

@ -68,9 +68,9 @@ typedef struct
static void query (void); static void query (void);
static void run (gchar *name, static void run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
static gint32 load_image (gchar *filename); static gint32 load_image (gchar *filename);
static gint save_image (gchar *filename, static gint save_image (gchar *filename,
@ -90,11 +90,11 @@ static gint32 create_new_image (gchar *filename,
guint pagenum, guint pagenum,
guint width, guint width,
guint height, guint height,
GImageType itype, GimpImageBaseType itype,
GDrawableType dtype, GimpImageType dtype,
gint32 *layer_ID, gint32 *layer_ID,
GDrawable **drawable, GimpDrawable **drawable,
GPixelRgn *pixel_rgn); GimpPixelRgn *pixel_rgn);
static void check_load_vals (void); static void check_load_vals (void);
@ -122,7 +122,7 @@ static FITSLoadInterface plint =
FALSE FALSE
}; };
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -131,7 +131,7 @@ GPlugInInfo PLUG_IN_INFO =
}; };
/* The run mode */ /* The run mode */
static GRunModeType l_run_mode; static GimpRunModeType l_run_mode;
MAIN () MAIN ()
@ -140,27 +140,27 @@ static void
query (void) query (void)
{ {
static GParamDef load_args[] = static GimpParamDef load_args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_STRING, "filename", "The name of the file to load" }, { GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name of the file to load" }, { GIMP_PDB_STRING, "raw_filename", "The name of the file to load" },
}; };
static GParamDef load_return_vals[] = static GimpParamDef load_return_vals[] =
{ {
{ PARAM_IMAGE, "image", "Output image" }, { GIMP_PDB_IMAGE, "image", "Output image" },
}; };
static gint nload_args = sizeof (load_args) / sizeof (load_args[0]); static gint nload_args = sizeof (load_args) / sizeof (load_args[0]);
static gint nload_return_vals = (sizeof (load_return_vals) / static gint nload_return_vals = (sizeof (load_return_vals) /
sizeof (load_return_vals[0])); sizeof (load_return_vals[0]));
static GParamDef save_args[] = static GimpParamDef save_args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" }, { GIMP_PDB_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Drawable to save" }, { GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
{ PARAM_STRING, "filename", "The name of the file to save the image in" }, { GIMP_PDB_STRING, "filename", "The name of the file to save the image in" },
{ PARAM_STRING, "raw_filename", "The name of the file to save the image in" }, { GIMP_PDB_STRING, "raw_filename", "The name of the file to save the image in" },
}; };
static gint nsave_args = sizeof (save_args) / sizeof (save_args[0]); static gint nsave_args = sizeof (save_args) / sizeof (save_args[0]);
@ -174,7 +174,7 @@ query (void)
"1997", "1997",
"<Load>/FITS", "<Load>/FITS",
NULL, NULL,
PROC_PLUG_IN, GIMP_PLUGIN,
nload_args, nload_return_vals, nload_args, nload_return_vals,
load_args, load_return_vals); load_args, load_return_vals);
@ -186,7 +186,7 @@ query (void)
"1997", "1997",
"<Save>/FITS", "<Save>/FITS",
"RGB, GRAY, INDEXED", "RGB, GRAY, INDEXED",
PROC_PLUG_IN, GIMP_PLUGIN,
nsave_args, 0, nsave_args, 0,
save_args, NULL); save_args, NULL);
@ -204,23 +204,23 @@ query (void)
static void static void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[2]; static GimpParam values[2];
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_ID; gint32 image_ID;
gint32 drawable_ID; gint32 drawable_ID;
GimpExportReturnType export = EXPORT_CANCEL; GimpExportReturnType export = EXPORT_CANCEL;
l_run_mode = run_mode = (GRunModeType)param[0].data.d_int32; l_run_mode = run_mode = (GimpRunModeType)param[0].data.d_int32;
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = STATUS_EXECUTION_ERROR; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, "file_fits_load") == 0) if (strcmp (name, "file_fits_load") == 0)
{ {
@ -228,20 +228,20 @@ run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */ /* Possibly retrieve data */
gimp_get_data ("file_fits_load", &plvals); gimp_get_data ("file_fits_load", &plvals);
if (!load_dialog ()) if (!load_dialog ())
status = STATUS_CANCEL; status = GIMP_PDB_CANCEL;
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
if (nparams != 3) if (nparams != 3)
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */ /* Possibly retrieve data */
gimp_get_data ("file_fits_load", &plvals); gimp_get_data ("file_fits_load", &plvals);
break; break;
@ -250,7 +250,7 @@ run (gchar *name,
break; break;
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
check_load_vals (); check_load_vals ();
image_ID = load_image (param[1].data.d_string); image_ID = load_image (param[1].data.d_string);
@ -261,16 +261,16 @@ run (gchar *name,
if (image_ID != -1) if (image_ID != -1)
{ {
*nreturn_vals = 2; *nreturn_vals = 2;
values[1].type = PARAM_IMAGE; values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID; values[1].data.d_image = image_ID;
} }
else else
{ {
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
/* Store plvals data */ /* Store plvals data */
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
gimp_set_data ("file_fits_load", &plvals, sizeof (FITSLoadVals)); gimp_set_data ("file_fits_load", &plvals, sizeof (FITSLoadVals));
} }
} }
@ -284,8 +284,8 @@ run (gchar *name,
/* eventually export the image */ /* eventually export the image */
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init ("fits", FALSE); gimp_ui_init ("fits", FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, "FITS", export = gimp_export_image (&image_ID, &drawable_ID, "FITS",
(CAN_HANDLE_RGB | (CAN_HANDLE_RGB |
@ -293,7 +293,7 @@ run (gchar *name,
CAN_HANDLE_INDEXED)); CAN_HANDLE_INDEXED));
if (export == EXPORT_CANCEL) if (export == EXPORT_CANCEL)
{ {
values[0].data.d_status = STATUS_CANCEL; values[0].data.d_status = GIMP_PDB_CANCEL;
return; return;
} }
break; break;
@ -303,26 +303,26 @@ run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */ /* Make sure all the arguments are there! */
if (nparams != 5) if (nparams != 5)
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
break; break;
default: default:
break; break;
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
if (! save_image (param[3].data.d_string, image_ID, drawable_ID)) if (! save_image (param[3].data.d_string, image_ID, drawable_ID))
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
if (export == EXPORT_EXPORT) if (export == EXPORT_EXPORT)
@ -330,7 +330,7 @@ run (gchar *name,
} }
else else
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
values[0].data.d_status = status; values[0].data.d_status = status;
@ -411,7 +411,7 @@ load_image (gchar *filename)
fits_close (ifp); fits_close (ifp);
/* Display images in reverse order. The last will be displayed by GIMP itself*/ /* Display images in reverse order. The last will be displayed by GIMP itself*/
if (l_run_mode != RUN_NONINTERACTIVE) if (l_run_mode != GIMP_RUN_NONINTERACTIVE)
{ {
for (k = n_images-1; k >= 1; k--) for (k = n_images-1; k >= 1; k--)
{ {
@ -434,7 +434,7 @@ save_image (gchar *filename,
gint32 drawable_ID) gint32 drawable_ID)
{ {
FITS_FILE* ofp; FITS_FILE* ofp;
GDrawableType drawable_type; GimpImageType drawable_type;
gint retval; gint retval;
char *temp = ident; /* Just to satisfy lint/gcc */ char *temp = ident; /* Just to satisfy lint/gcc */
@ -449,9 +449,9 @@ save_image (gchar *filename,
switch (drawable_type) switch (drawable_type)
{ {
case INDEXED_IMAGE: case INDEXEDA_IMAGE: case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
case GRAY_IMAGE: case GRAYA_IMAGE: case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
case RGB_IMAGE: case RGBA_IMAGE: case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
break; break;
default: default:
g_message (_("Cannot operate on unknown image types")); g_message (_("Cannot operate on unknown image types"));
@ -467,14 +467,14 @@ save_image (gchar *filename,
return (FALSE); return (FALSE);
} }
if (l_run_mode != RUN_NONINTERACTIVE) if (l_run_mode != GIMP_RUN_NONINTERACTIVE)
{ {
temp = g_strdup_printf (_("Saving %s:"), filename); temp = g_strdup_printf (_("Saving %s:"), filename);
gimp_progress_init (temp); gimp_progress_init (temp);
g_free (temp); g_free (temp);
} }
if ((drawable_type == INDEXED_IMAGE) || (drawable_type == INDEXEDA_IMAGE)) if ((drawable_type == GIMP_INDEXED_IMAGE) || (drawable_type == GIMP_INDEXEDA_IMAGE))
retval = save_index (ofp,image_ID, drawable_ID); retval = save_index (ofp,image_ID, drawable_ID);
else else
retval = save_direct (ofp,image_ID, drawable_ID); retval = save_direct (ofp,image_ID, drawable_ID);
@ -499,11 +499,11 @@ create_new_image (gchar *filename,
guint pagenum, guint pagenum,
guint width, guint width,
guint height, guint height,
GImageType itype, GimpImageBaseType itype,
GDrawableType dtype, GimpImageType dtype,
gint32 *layer_ID, gint32 *layer_ID,
GDrawable **drawable, GimpDrawable **drawable,
GPixelRgn *pixel_rgn) GimpPixelRgn *pixel_rgn)
{ {
gint32 image_ID; gint32 image_ID;
char *tmp; char *tmp;
@ -519,7 +519,7 @@ create_new_image (gchar *filename,
gimp_image_set_filename (image_ID, filename); gimp_image_set_filename (image_ID, filename);
*layer_ID = gimp_layer_new (image_ID, _("Background"), width, height, *layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
dtype, 100, NORMAL_MODE); dtype, 100, GIMP_NORMAL_MODE);
gimp_image_add_layer (image_ID, *layer_ID, 0); gimp_image_add_layer (image_ID, *layer_ID, 0);
*drawable = gimp_drawable_get (*layer_ID); *drawable = gimp_drawable_get (*layer_ID);
@ -545,10 +545,10 @@ load_fits (gchar *filename,
int i, j, channel, max_scan; int i, j, channel, max_scan;
double a, b; double a, b;
gint32 layer_ID, image_ID; gint32 layer_ID, image_ID;
GPixelRgn pixel_rgn; GimpPixelRgn pixel_rgn;
GDrawable *drawable; GimpDrawable *drawable;
GImageType itype; GimpImageBaseType itype;
GDrawableType dtype; GimpImageType dtype;
gint err = 0; gint err = 0;
FITS_HDU_LIST *hdulist; FITS_HDU_LIST *hdulist;
FITS_PIX_TRANSFORM trans; FITS_PIX_TRANSFORM trans;
@ -559,10 +559,10 @@ load_fits (gchar *filename,
width = hdulist->naxisn[0]; /* Set the size of the FITS image */ width = hdulist->naxisn[0]; /* Set the size of the FITS image */
height = hdulist->naxisn[1]; height = hdulist->naxisn[1];
if (ncompose == 2) { itype = GRAY; dtype = GRAYA_IMAGE; } if (ncompose == 2) { itype = GIMP_GRAY; dtype = GIMP_GRAYA_IMAGE; }
else if (ncompose == 3) { itype = RGB; dtype = RGB_IMAGE; } else if (ncompose == 3) { itype = GIMP_RGB; dtype = GIMP_RGB_IMAGE; }
else if (ncompose == 4) { itype = RGB; dtype = RGBA_IMAGE; } else if (ncompose == 4) { itype = GIMP_RGB; dtype = GIMP_RGBA_IMAGE; }
else { ncompose = 1; itype = GRAY; dtype = GRAY_IMAGE;} else { ncompose = 1; itype = GIMP_GRAY; dtype = GIMP_GRAY_IMAGE;}
image_ID = create_new_image (filename, picnum, width, height, itype, dtype, image_ID = create_new_image (filename, picnum, width, height, itype, dtype,
&layer_ID, &drawable, &pixel_rgn); &layer_ID, &drawable, &pixel_rgn);
@ -613,7 +613,7 @@ load_fits (gchar *filename,
scan_lines++; scan_lines++;
if ((l_run_mode != RUN_NONINTERACTIVE) && ((i % 20) == 0)) if ((l_run_mode != GIMP_RUN_NONINTERACTIVE) && ((i % 20) == 0))
gimp_progress_update ((double)(i+1) / (double)height); gimp_progress_update ((double)(i+1) / (double)height);
if ((scan_lines == tile_height) || ((i+1) == height)) if ((scan_lines == tile_height) || ((i+1) == height))
@ -665,7 +665,7 @@ load_fits (gchar *filename,
dest -= width*ncompose; dest -= width*ncompose;
scan_lines++; scan_lines++;
if ((l_run_mode != RUN_NONINTERACTIVE) && ((i % 20) == 0)) if ((l_run_mode != GIMP_RUN_NONINTERACTIVE) && ((i % 20) == 0))
gimp_progress_update ( (double)(channel*height+i+1) gimp_progress_update ( (double)(channel*height+i+1)
/ (double)(height*ncompose)); / (double)(height*ncompose));
@ -704,16 +704,16 @@ create_fits_header (FITS_FILE *ofp,
static char *ctype3_card[] = static char *ctype3_card[] =
{ {
NULL, NULL, NULL, /* bpp = 0: no additional card */ NULL, NULL, NULL, /* bpp = 0: no additional card */
"COMMENT Image type within GIMP: GRAY_IMAGE", "COMMENT Image type within GIMP: GIMP_GRAY_IMAGE",
NULL, NULL,
NULL, NULL,
"COMMENT Image type within GIMP: GRAYA_IMAGE (gray with alpha channel)", "COMMENT Image type within GIMP: GIMP_GRAYA_IMAGE (gray with alpha channel)",
"COMMENT Sequence for NAXIS3 : GRAY, ALPHA", "COMMENT Sequence for NAXIS3 : GRAY, ALPHA",
"CTYPE3 = 'GRAYA ' / GRAY IMAGE WITH ALPHA CHANNEL", "CTYPE3 = 'GRAYA ' / GRAY IMAGE WITH ALPHA CHANNEL",
"COMMENT Image type within GIMP: RGB_IMAGE", "COMMENT Image type within GIMP: GIMP_RGB_IMAGE",
"COMMENT Sequence for NAXIS3 : RED, GREEN, BLUE", "COMMENT Sequence for NAXIS3 : RED, GREEN, BLUE",
"CTYPE3 = 'RGB ' / RGB IMAGE", "CTYPE3 = 'RGB ' / RGB IMAGE",
"COMMENT Image type within GIMP: RGBA_IMAGE (rgb with alpha channel)", "COMMENT Image type within GIMP: GIMP_RGBA_IMAGE (rgb with alpha channel)",
"COMMENT Sequence for NAXIS3 : RED, GREEN, BLUE, ALPHA", "COMMENT Sequence for NAXIS3 : RED, GREEN, BLUE, ALPHA",
"CTYPE3 = 'RGBA ' / RGB IMAGE WITH ALPHA CHANNEL" "CTYPE3 = 'RGBA ' / RGB IMAGE WITH ALPHA CHANNEL"
}; };
@ -768,9 +768,9 @@ save_direct (FITS_FILE *ofp,
int tile_height, bpp, bpsl; int tile_height, bpp, bpsl;
long nbytes; long nbytes;
guchar *data, *src; guchar *data, *src;
GPixelRgn pixel_rgn; GimpPixelRgn pixel_rgn;
GDrawable *drawable; GimpDrawable *drawable;
GDrawableType drawable_type; GimpImageType drawable_type;
FITS_HDU_LIST *hdu; FITS_HDU_LIST *hdu;
drawable = gimp_drawable_get (drawable_ID); drawable = gimp_drawable_get (drawable_ID);
@ -819,7 +819,7 @@ save_direct (FITS_FILE *ofp,
nbytes += bpsl; nbytes += bpsl;
src -= 2*bpsl; src -= 2*bpsl;
if ((l_run_mode != RUN_NONINTERACTIVE) && ((i % 20) == 0)) if ((l_run_mode != GIMP_RUN_NONINTERACTIVE) && ((i % 20) == 0))
gimp_progress_update ((double)(i+channel*height)/(double)(height*bpp)); gimp_progress_update ((double)(i+channel*height)/(double)(height*bpp));
} }
} }
@ -857,9 +857,9 @@ save_index (FITS_FILE *ofp,
guchar *data, *src, *cmap, *cmapptr; guchar *data, *src, *cmap, *cmapptr;
guchar red[256], green[256], blue[256]; guchar red[256], green[256], blue[256];
guchar *channels[3]; guchar *channels[3];
GPixelRgn pixel_rgn; GimpPixelRgn pixel_rgn;
GDrawable *drawable; GimpDrawable *drawable;
GDrawableType drawable_type; GimpImageType drawable_type;
FITS_HDU_LIST *hdu; FITS_HDU_LIST *hdu;
channels[0] = red; channels[1] = green; channels[2] = blue; channels[0] = red; channels[1] = green; channels[2] = blue;
@ -918,7 +918,7 @@ save_index (FITS_FILE *ofp,
src -= 2*bpsl; src -= 2*bpsl;
} }
if ((l_run_mode != RUN_NONINTERACTIVE) && ((i % 20) == 0)) if ((l_run_mode != GIMP_RUN_NONINTERACTIVE) && ((i % 20) == 0))
gimp_progress_update ((double) (i+channel*height) / gimp_progress_update ((double) (i+channel*height) /
(double) (height*(bpp+2))); (double) (height*(bpp+2)));
} }
@ -943,7 +943,7 @@ save_index (FITS_FILE *ofp,
src -= 2*bpsl; src -= 2*bpsl;
} }
if ((l_run_mode != RUN_NONINTERACTIVE) && ((i % 20) == 0)) if ((l_run_mode != GIMP_RUN_NONINTERACTIVE) && ((i % 20) == 0))
gimp_progress_update ((double) (i+channel*height) / gimp_progress_update ((double) (i+channel*height) /
(double) (height*(bpp+2))); (double) (height*(bpp+2)));
} }

56
plug-ins/flame/flame.c
View File

@ -54,10 +54,10 @@
static void query (void); static void query (void);
static void run (gchar *name, static void run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
static void doit (GDrawable *drawable); static void doit (GimpDrawable *drawable);
static gint dialog (void); static gint dialog (void);
static void set_flame_preview (void); static void set_flame_preview (void);
@ -95,7 +95,7 @@ static GtkWidget *edit_previews[NMUTANTS];
static gdouble pick_speed = 0.2; static gdouble pick_speed = 0.2;
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -127,11 +127,11 @@ MAIN ()
static void static void
query (void) query (void)
{ {
static GParamDef args[] = static GimpParamDef args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (unused)" }, { GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
}; };
static gint nargs = sizeof(args) / sizeof(args[0]); static gint nargs = sizeof(args) / sizeof(args[0]);
@ -143,7 +143,7 @@ query (void)
"1997", "1997",
N_("<Image>/Filters/Render/Nature/Flame..."), N_("<Image>/Filters/Render/Nature/Flame..."),
"RGB*", "RGB*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs, 0, nargs, 0,
args, NULL); args, NULL);
} }
@ -179,14 +179,14 @@ maybe_init_cp (void)
static void static void
run (gchar *name, run (gchar *name,
gint n_params, gint n_params,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[1]; static GimpParam values[1];
GDrawable *drawable = NULL; GimpDrawable *drawable = NULL;
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
@ -195,9 +195,9 @@ run (gchar *name,
run_mode = param[0].data.d_int32; run_mode = param[0].data.d_int32;
if (run_mode == RUN_NONINTERACTIVE) if (run_mode == GIMP_RUN_NONINTERACTIVE)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
else else
{ {
@ -209,16 +209,16 @@ run (gchar *name,
config.cp.width = drawable->width; config.cp.width = drawable->width;
config.cp.height = drawable->height; config.cp.height = drawable->height;
if (run_mode == RUN_INTERACTIVE) if (run_mode == GIMP_RUN_INTERACTIVE)
{ {
if (!dialog ()) if (!dialog ())
{ {
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
} }
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
if (gimp_drawable_is_rgb (drawable->id)) if (gimp_drawable_is_rgb (drawable->id))
{ {
@ -228,18 +228,18 @@ run (gchar *name,
doit (drawable); doit (drawable);
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush (); gimp_displays_flush ();
gimp_set_data ("plug_in_flame", &config, sizeof (config)); gimp_set_data ("plug_in_flame", &config, sizeof (config));
} }
else else
{ {
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
gimp_drawable_detach (drawable); gimp_drawable_detach (drawable);
} }
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
} }
@ -247,8 +247,8 @@ static void
drawable_to_cmap (control_point *cp) drawable_to_cmap (control_point *cp)
{ {
gint i, j; gint i, j;
GPixelRgn pr; GimpPixelRgn pr;
GDrawable *d; GimpDrawable *d;
guchar *p; guchar *p;
gint indexed; gint indexed;
@ -291,7 +291,7 @@ drawable_to_cmap (control_point *cp)
} }
static void static void
doit (GDrawable *drawable) doit (GimpDrawable *drawable)
{ {
gint width, height; gint width, height;
guchar *tmp; guchar *tmp;
@ -321,7 +321,7 @@ doit (GDrawable *drawable)
/* update destination */ /* update destination */
if (4 == bytes) if (4 == bytes)
{ {
GPixelRgn pr; GimpPixelRgn pr;
gimp_pixel_rgn_init (&pr, drawable, 0, 0, width, height, gimp_pixel_rgn_init (&pr, drawable, 0, 0, width, height,
TRUE, TRUE); TRUE, TRUE);
gimp_pixel_rgn_set_rect (&pr, tmp, 0, 0, width, height); gimp_pixel_rgn_set_rect (&pr, tmp, 0, 0, width, height);
@ -329,7 +329,7 @@ doit (GDrawable *drawable)
else if (3 == bytes) else if (3 == bytes)
{ {
gint i, j; gint i, j;
GPixelRgn src_pr, dst_pr; GimpPixelRgn src_pr, dst_pr;
guchar *sl; guchar *sl;
sl = g_new (guchar, 3 * width); sl = g_new (guchar, 3 * width);

38
plug-ins/fp/fp.c
View File

@ -54,16 +54,16 @@ FP_Params Current =
{0,0,0} {0,0,0}
}; };
GDrawable *drawable, *mask; GimpDrawable *drawable, *mask;
void query (void); void query (void);
void run (gchar *name, void run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -76,11 +76,11 @@ MAIN()
void void
query (void) query (void)
{ {
GParamDef args[] = GimpParamDef args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (used for indexed images)" }, { GIMP_PDB_IMAGE, "image", "Input image (used for indexed images)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
}; };
gint nargs = sizeof (args) / sizeof (args[0]); gint nargs = sizeof (args) / sizeof (args[0]);
@ -92,7 +92,7 @@ query (void)
"27th March 1997", "27th March 1997",
N_("<Image>/Image/Colors/Filter Pack..."), N_("<Image>/Image/Colors/Filter Pack..."),
"RGB*", "RGB*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs, 0, nargs, 0,
args, NULL); args, NULL);
} }
@ -102,19 +102,19 @@ query (void)
void void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
GParam values[1]; GimpParam values[1];
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
INIT_I18N_UI(); INIT_I18N_UI();
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
initializeFilterPacks(); initializeFilterPacks();
@ -126,7 +126,7 @@ run (gchar *name,
gimp_drawable_is_gray (drawable->id) ) gimp_drawable_is_gray (drawable->id) )
{ {
gimp_message (_("Convert the image to RGB first!")); gimp_message (_("Convert the image to RGB first!"));
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
else if (gimp_drawable_is_rgb (drawable->id) && fp_dialog()) else if (gimp_drawable_is_rgb (drawable->id) && fp_dialog())
{ {
@ -135,11 +135,11 @@ run (gchar *name,
fp (drawable); fp (drawable);
gimp_displays_flush (); gimp_displays_flush ();
} }
else status = STATUS_EXECUTION_ERROR; else status = GIMP_PDB_EXECUTION_ERROR;
values[0].data.d_status = status; values[0].data.d_status = status;
if (status==STATUS_SUCCESS) if (status==GIMP_PDB_SUCCESS)
gimp_drawable_detach (drawable); gimp_drawable_detach (drawable);
} }
@ -221,9 +221,9 @@ fp_row (const guchar *src_row,
} }
void fp (GDrawable *drawable) void fp (GimpDrawable *drawable)
{ {
GPixelRgn srcPR, destPR; GimpPixelRgn srcPR, destPR;
gint width, height; gint width, height;
gint bytes; gint bytes;
guchar *src_row, *dest_row; guchar *src_row, *dest_row;

6
plug-ins/fp/fp.h
View File

@ -113,8 +113,8 @@ GtkWidget *fp_create_pixels_select_by();
void fp_show_hide_frame(GtkWidget *button, void fp_show_hide_frame(GtkWidget *button,
GtkWidget *frame); GtkWidget *frame);
ReducedImage *Reduce_The_Image (GDrawable *, ReducedImage *Reduce_The_Image (GimpDrawable *,
GDrawable *, GimpDrawable *,
gint, gint,
gint); gint);
@ -194,7 +194,7 @@ void Adjust_Preview_Sizes (int width,
void refreshPreviews (int); void refreshPreviews (int);
void initializeFilterPacks (void); void initializeFilterPacks (void);
void fp (GDrawable *drawable); void fp (GimpDrawable *drawable);
void fp_row (const guchar *src_row, void fp_row (const guchar *src_row,
guchar *dest_row, guchar *dest_row,
gint row, gint row,

2
plug-ins/fp/fp_gtk.c
View File

@ -36,7 +36,7 @@ AdvancedWindow AW = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
extern FP_Params Current; extern FP_Params Current;
extern GDrawable *drawable, *mask; extern GimpDrawable *drawable, *mask;
FP_Intensity ShMidHi[] = { SHADOWS, MIDTONES, HIGHLIGHTS }; FP_Intensity ShMidHi[] = { SHADOWS, MIDTONES, HIGHLIGHTS };
int HueSatVal[] = { BY_HUE, BY_SAT, BY_VAL }; int HueSatVal[] = { BY_HUE, BY_SAT, BY_VAL };

8
plug-ins/fp/fp_misc.c
View File

@ -9,7 +9,7 @@
extern FP_Params Current; extern FP_Params Current;
extern GDrawable *drawable, *mask; extern GimpDrawable *drawable, *mask;
extern ReducedImage *reduced; extern ReducedImage *reduced;
extern gint nudgeArray[256]; extern gint nudgeArray[256];
@ -36,8 +36,8 @@ void resetFilterPacks()
refreshPreviews(Current.VisibleFrames); refreshPreviews(Current.VisibleFrames);
} }
ReducedImage *Reduce_The_Image(GDrawable *drawable, ReducedImage *Reduce_The_Image(GimpDrawable *drawable,
GDrawable *mask, GimpDrawable *mask,
gint LongerSize, gint LongerSize,
gint Slctn) gint Slctn)
{ {
@ -45,7 +45,7 @@ ReducedImage *Reduce_The_Image(GDrawable *drawable,
ReducedImage *temp=(ReducedImage *)malloc(sizeof(ReducedImage)); ReducedImage *temp=(ReducedImage *)malloc(sizeof(ReducedImage));
guchar *tempRGB, *src_row, *tempmask, *src_mask_row,R,G,B; guchar *tempRGB, *src_row, *tempmask, *src_mask_row,R,G,B;
gint i, j, whichcol, whichrow, x1, x2, y1, y2; gint i, j, whichcol, whichrow, x1, x2, y1, y2;
GPixelRgn srcPR, srcMask; GimpPixelRgn srcPR, srcMask;
gint NoSelectionMade=TRUE; gint NoSelectionMade=TRUE;
hsv *tempHSV, H, S, V; hsv *tempHSV, H, S, V;

54
plug-ins/gap/gap_dbbrowser_utils.c
View File

@ -678,7 +678,7 @@ dialog_search_callback (GtkWidget *widget,
query_text++; query_text++;
} }
gimp_query_database (query->str, gimp_procedural_db_query (query->str,
".*", ".*", ".*", ".*", ".*", ".*", ".*", ".*", ".*", ".*", ".*", ".*",
&num_procs, &proc_list); &num_procs, &proc_list);
@ -688,7 +688,7 @@ dialog_search_callback (GtkWidget *widget,
{ {
gtk_window_set_title (GTK_WINDOW (dbbrowser->dlg), gtk_window_set_title (GTK_WINDOW (dbbrowser->dlg),
_("Animated Filter apply (by blurb - please wait)")); _("Animated Filter apply (by blurb - please wait)"));
gimp_query_database (".*", gimp_procedural_db_query (".*",
gtk_entry_get_text( GTK_ENTRY(dbbrowser->search_entry) ), gtk_entry_get_text( GTK_ENTRY(dbbrowser->search_entry) ),
".*", ".*", ".*", ".*", ".*", ".*", ".*", ".*", ".*", ".*",
&num_procs, &proc_list); &num_procs, &proc_list);
@ -696,7 +696,7 @@ dialog_search_callback (GtkWidget *widget,
else { else {
gtk_window_set_title (GTK_WINDOW (dbbrowser->dlg), gtk_window_set_title (GTK_WINDOW (dbbrowser->dlg),
_("Animated Filter apply (please wait)")); _("Animated Filter apply (please wait)"));
gimp_query_database (".*", ".*", ".*", ".*", ".*", ".*", ".*", gimp_procedural_db_query (".*", ".*", ".*", ".*", ".*", ".*", ".*",
&num_procs, &proc_list); &num_procs, &proc_list);
} }
@ -762,32 +762,32 @@ convert_string (char *str)
} }
static char* static char*
GParamType2char(GParamType t) GParamType2char(GimpPDBArgType t)
{ {
switch (t) { switch (t) {
case PARAM_INT32: return "INT32"; case GIMP_PDB_INT32: return "INT32";
case PARAM_INT16: return "INT16"; case GIMP_PDB_INT16: return "INT16";
case PARAM_INT8: return "INT8"; case GIMP_PDB_INT8: return "INT8";
case PARAM_FLOAT: return "FLOAT"; case GIMP_PDB_FLOAT: return "FLOAT";
case PARAM_STRING: return "STRING"; case GIMP_PDB_STRING: return "STRING";
case PARAM_INT32ARRAY: return "INT32ARRAY"; case GIMP_PDB_INT32ARRAY: return "INT32ARRAY";
case PARAM_INT16ARRAY: return "INT16ARRAY"; case GIMP_PDB_INT16ARRAY: return "INT16ARRAY";
case PARAM_INT8ARRAY: return "INT8ARRAY"; case GIMP_PDB_INT8ARRAY: return "INT8ARRAY";
case PARAM_FLOATARRAY: return "FLOATARRAY"; case GIMP_PDB_FLOATARRAY: return "FLOATARRAY";
case PARAM_STRINGARRAY: return "STRINGARRAY"; case GIMP_PDB_STRINGARRAY: return "STRINGARRAY";
case PARAM_COLOR: return "COLOR"; case GIMP_PDB_COLOR: return "COLOR";
case PARAM_REGION: return "REGION"; case GIMP_PDB_REGION: return "REGION";
case PARAM_DISPLAY: return "DISPLAY"; case GIMP_PDB_DISPLAY: return "DISPLAY";
case PARAM_IMAGE: return "IMAGE"; case GIMP_PDB_IMAGE: return "IMAGE";
case PARAM_LAYER: return "LAYER"; case GIMP_PDB_LAYER: return "LAYER";
case PARAM_CHANNEL: return "CHANNEL"; case GIMP_PDB_CHANNEL: return "CHANNEL";
case PARAM_DRAWABLE: return "DRAWABLE"; case GIMP_PDB_DRAWABLE: return "DRAWABLE";
case PARAM_SELECTION: return "SELECTION"; case GIMP_PDB_SELECTION: return "SELECTION";
case PARAM_BOUNDARY: return "BOUNDARY"; case GIMP_PDB_BOUNDARY: return "BOUNDARY";
case PARAM_PATH: return "PATH"; case GIMP_PDB_PATH: return "PATH";
case PARAM_PARASITE: return "PARASITE"; case GIMP_PDB_PARASITE: return "PARASITE";
case PARAM_STATUS: return "STATUS"; case GIMP_PDB_STATUS: return "STATUS";
case PARAM_END: return "END"; case GIMP_PDB_END: return "END";
default: return "UNKNOWN?"; default: return "UNKNOWN?";
} }
} }

2
plug-ins/gap/gap_dbbrowser_utils.h
View File

@ -123,6 +123,6 @@ static void
convert_string (gchar *str); convert_string (gchar *str);
static gchar* static gchar*
GParamType2char(GParamType t); GParamType2char(GimpPDBArgType t);
#endif #endif

90
plug-ins/gap/gap_decode_mpeg_main.c
View File

@ -105,9 +105,9 @@ static gchar G_GNUC_UNUSED *dummy_entries[] =
static void query (void); static void query (void);
static void run (char *name, static void run (char *name,
int nparams, int nparams,
GParam *param, GimpParam *param,
int *nreturn_vals, int *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
static gint32 load_image (char *filename, static gint32 load_image (char *filename,
gint32 first_frame, gint32 first_frame,
gint32 last_frame, gint32 last_frame,
@ -122,7 +122,7 @@ static gint32 load_range_dialog(gint32 *first_frame,
gint32 *autoload); gint32 *autoload);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -136,34 +136,34 @@ MAIN ()
static void static void
query () query ()
{ {
static GParamDef load_args[] = static GimpParamDef load_args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "(unused)"}, { GIMP_PDB_IMAGE, "image", "(unused)"},
{ PARAM_DRAWABLE, "drawable", "(unused)"}, { GIMP_PDB_DRAWABLE, "drawable", "(unused)"},
{ PARAM_STRING, "filename", "The name of the file to load" }, { GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name entered" }, { GIMP_PDB_STRING, "raw_filename", "The name entered" },
{ PARAM_INT32, "first_frame", "1st frame to extract (starting at number 1)" }, { GIMP_PDB_INT32, "first_frame", "1st frame to extract (starting at number 1)" },
{ PARAM_INT32, "last_frame", "last frame to extract (use 0 to load all remaining frames)" }, { GIMP_PDB_INT32, "last_frame", "last frame to extract (use 0 to load all remaining frames)" },
{ PARAM_STRING, "animframe_basename", "The name for the single frames _0001.xcf is added" }, { GIMP_PDB_STRING, "animframe_basename", "The name for the single frames _0001.xcf is added" },
{ PARAM_INT32, "autoload", "TRUE: load 1.st extracted frame on success" }, { GIMP_PDB_INT32, "autoload", "TRUE: load 1.st extracted frame on success" },
}; };
static GParamDef load_return_vals[] = static GimpParamDef load_return_vals[] =
{ {
{ PARAM_IMAGE, "image", "Output image" }, { GIMP_PDB_IMAGE, "image", "Output image" },
}; };
static int nload_args = sizeof (load_args) / sizeof (load_args[0]); static int nload_args = sizeof (load_args) / sizeof (load_args[0]);
static int nload_return_vals = sizeof (load_return_vals) / sizeof (load_return_vals[0]); static int nload_return_vals = sizeof (load_return_vals) / sizeof (load_return_vals[0]);
static GParamDef ext_args[] = static GimpParamDef ext_args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_STRING, "filename", "The name of the file to load" }, { GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name entered" }, { GIMP_PDB_STRING, "raw_filename", "The name entered" },
{ PARAM_INT32, "first_frame", "1st frame to extract (starting at number 1)" }, { GIMP_PDB_INT32, "first_frame", "1st frame to extract (starting at number 1)" },
{ PARAM_INT32, "last_frame", "last frame to extract (use 0 to load all remaining frames)" }, { GIMP_PDB_INT32, "last_frame", "last frame to extract (use 0 to load all remaining frames)" },
{ PARAM_STRING, "animframe_basename", "The name for the single frames _0001.xcf is added" }, { GIMP_PDB_STRING, "animframe_basename", "The name for the single frames _0001.xcf is added" },
{ PARAM_INT32, "autoload", "TRUE: load 1.st extracted frame on success" }, { GIMP_PDB_INT32, "autoload", "TRUE: load 1.st extracted frame on success" },
}; };
static int next_args = sizeof (ext_args) / sizeof (ext_args[0]); static int next_args = sizeof (ext_args) / sizeof (ext_args[0]);
@ -177,7 +177,7 @@ query ()
"2000/01/01", "2000/01/01",
N_("<Image>/Video/Split Video to Frames/MPEG1"), N_("<Image>/Video/Split Video to Frames/MPEG1"),
NULL, NULL,
PROC_PLUG_IN, GIMP_PLUGIN,
nload_args, nload_return_vals, nload_args, nload_return_vals,
load_args, load_return_vals); load_args, load_return_vals);
@ -189,7 +189,7 @@ query ()
"2000/01/01", "2000/01/01",
N_("<Toolbox>/Xtns/Split Video to Frames/MPEG1"), N_("<Toolbox>/Xtns/Split Video to Frames/MPEG1"),
NULL, NULL,
PROC_EXTENSION, GIMP_EXTENSION,
next_args, nload_return_vals, next_args, nload_return_vals,
ext_args, load_return_vals); ext_args, load_return_vals);
} }
@ -197,12 +197,12 @@ query ()
static void static void
run (char *name, run (char *name,
int nparams, int nparams,
GParam *param, GimpParam *param,
int *nreturn_vals, int *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[2]; static GimpParam values[2];
GRunModeType run_mode; GimpRunModeType run_mode;
gint32 image_ID; gint32 image_ID;
gint32 first_frame, last_frame; gint32 first_frame, last_frame;
gint32 autoload; gint32 autoload;
@ -216,8 +216,8 @@ run (char *name,
*return_vals = values; *return_vals = values;
autoload = FALSE; autoload = FALSE;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = STATUS_CALLING_ERROR; values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
run_mode = param[0].data.d_int32; run_mode = param[0].data.d_int32;
@ -243,7 +243,7 @@ run (char *name,
} }
l_rc = 0; l_rc = 0;
if (run_mode == RUN_NONINTERACTIVE) if (run_mode == GIMP_RUN_NONINTERACTIVE)
{ {
l_filename[0] = '\0'; l_filename[0] = '\0';
@ -293,13 +293,13 @@ run (char *name,
if (image_ID != -1) if (image_ID != -1)
{ {
*nreturn_vals = 2; *nreturn_vals = 2;
values[0].data.d_status = STATUS_SUCCESS; values[0].data.d_status = GIMP_PDB_SUCCESS;
values[1].type = PARAM_IMAGE; values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID; values[1].data.d_image = image_ID;
} }
else else
{ {
values[0].data.d_status = STATUS_EXECUTION_ERROR; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
} }
} }
@ -398,8 +398,8 @@ load_image (char *filename,
char *basename, char *basename,
gint32 autoload) gint32 autoload)
{ {
GPixelRgn pixel_rgn; GimpPixelRgn pixel_rgn;
GDrawable *drawable; GimpDrawable *drawable;
gint32 first_image_ID; gint32 first_image_ID;
gint32 image_ID; gint32 image_ID;
gint32 layer_ID; gint32 layer_ID;
@ -538,7 +538,7 @@ load_image (char *filename,
layer_ID = gimp_layer_new (image_ID, layername, layer_ID = gimp_layer_new (image_ID, layername,
wwidth, wwidth,
wheight, wheight,
RGBA_IMAGE, 100, NORMAL_MODE); GIMP_RGBA_IMAGE, 100, GIMP_NORMAL_MODE);
g_free(layername); g_free(layername);
gimp_image_add_layer (image_ID, layer_ID, 0); gimp_image_add_layer (image_ID, layer_ID, 0);
gimp_layer_set_visible(layer_ID, l_visible); gimp_layer_set_visible(layer_ID, l_visible);
@ -573,7 +573,7 @@ load_image (char *filename,
/* save each image as frame to disk */ /* save each image as frame to disk */
{ {
GParam* l_params; GimpParam* l_params;
gint l_retvals; gint l_retvals;
l_overwrite_mode = p_overwrite_dialog(framename, l_overwrite_mode); l_overwrite_mode = p_overwrite_dialog(framename, l_overwrite_mode);
@ -588,12 +588,12 @@ load_image (char *filename,
{ {
l_params = gimp_run_procedure ("gimp_xcf_save", l_params = gimp_run_procedure ("gimp_xcf_save",
&l_retvals, &l_retvals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, image_ID, GIMP_PDB_IMAGE, image_ID,
PARAM_DRAWABLE, 0, GIMP_PDB_DRAWABLE, 0,
PARAM_STRING, framename, GIMP_PDB_STRING, framename,
PARAM_STRING, framename, /* raw name ? */ GIMP_PDB_STRING, framename, /* raw name ? */
PARAM_END); GIMP_PDB_END);
p_gimp_file_save_thumbnail(image_ID, framename); p_gimp_file_save_thumbnail(image_ID, framename);
} }

38
plug-ins/gap/gap_decode_xanim.c
View File

@ -426,7 +426,7 @@ p_init_xanim_global_name()
static int static int
p_convert_frames(gint32 frame_from, gint32 frame_to, char *basename, char *ext, char *ext2) p_convert_frames(gint32 frame_from, gint32 frame_to, char *basename, char *ext, char *ext2)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
gint32 l_tmp_image_id; gint32 l_tmp_image_id;
char l_first_xa_frame[200]; char l_first_xa_frame[200];
@ -441,27 +441,27 @@ p_convert_frames(gint32 frame_from, gint32 frame_to, char *basename, char *ext,
*/ */
return_vals = gimp_run_procedure ("plug_in_gap_range_convert2", return_vals = gimp_run_procedure ("plug_in_gap_range_convert2",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, /* runmode */ GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE, /* runmode */
PARAM_IMAGE, l_tmp_image_id, GIMP_PDB_IMAGE, l_tmp_image_id,
PARAM_DRAWABLE, 0, /* (unused) */ GIMP_PDB_DRAWABLE, 0, /* (unused) */
PARAM_INT32, frame_from, GIMP_PDB_INT32, frame_from,
PARAM_INT32, frame_to, GIMP_PDB_INT32, frame_to,
PARAM_INT32, 0, /* dont flatten */ GIMP_PDB_INT32, 0, /* dont flatten */
PARAM_INT32, 4444, /* dest type (keep type) */ GIMP_PDB_INT32, 4444, /* dest type (keep type) */
PARAM_INT32, 256, /* colors (unused) */ GIMP_PDB_INT32, 256, /* colors (unused) */
PARAM_INT32, 0, /* no dither (unused) */ GIMP_PDB_INT32, 0, /* no dither (unused) */
PARAM_STRING, ext2, /* extension for dest. filetype */ GIMP_PDB_STRING, ext2, /* extension for dest. filetype */
PARAM_STRING, basename, /* basename for dest. filetype */ GIMP_PDB_STRING, basename, /* basename for dest. filetype */
PARAM_INT32, 0, /* (unused) */ GIMP_PDB_INT32, 0, /* (unused) */
PARAM_INT32, 0, /* (unused) */ GIMP_PDB_INT32, 0, /* (unused) */
PARAM_INT32, 0, /* (unused) */ GIMP_PDB_INT32, 0, /* (unused) */
PARAM_STRING, "none", /* (unused) palettename */ GIMP_PDB_STRING, "none", /* (unused) palettename */
PARAM_END); GIMP_PDB_END);
/* destroy the tmp image */ /* destroy the tmp image */
gimp_image_delete(l_tmp_image_id); gimp_image_delete(l_tmp_image_id);
if (return_vals[0].data.d_status != STATUS_SUCCESS) if (return_vals[0].data.d_status != GIMP_PDB_SUCCESS)
{ {
return(-1); return(-1);
} }
@ -971,7 +971,7 @@ p_start_xanim_process_exec(gint32 first_frame, gint32 last_frame,
*/ */
gint32 gint32
gap_xanim_decode(GRunModeType run_mode) gap_xanim_decode(GimpRunModeType run_mode)
{ {
gint32 l_rc; gint32 l_rc;
gint32 first_frame; gint32 first_frame;

2
plug-ins/gap/gap_decode_xanim.h
View File

@ -45,7 +45,7 @@ typedef enum
} t_gap_xa_formats; } t_gap_xa_formats;
int gap_xanim_decode(GRunModeType run_mode int gap_xanim_decode(GimpRunModeType run_mode
); );
#endif #endif

2
plug-ins/gap/gap_exchange_image.c
View File

@ -122,7 +122,7 @@ p_steal_content(gint32 dst_image_id, gint32 src_image_id)
/* gimp_image_undo_disable (src_image_id); */ /* does not work !! if active we can not steal layers */ /* gimp_image_undo_disable (src_image_id); */ /* does not work !! if active we can not steal layers */
/* Copy the colormap if necessary */ /* Copy the colormap if necessary */
if(gimp_image_base_type(src_image_id) == INDEXED) if(gimp_image_base_type(src_image_id) == GIMP_INDEXED)
{ {
l_cmap = gimp_image_get_cmap (src_image_id, &l_ncolors); l_cmap = gimp_image_get_cmap (src_image_id, &l_ncolors);

4
plug-ins/gap/gap_filter.h
View File

@ -35,7 +35,7 @@
* ------------------------ * ------------------------
*/ */
gint gap_proc_anim_apply(GRunModeType run_mode, gint32 image_id, char *l_plugin_name); gint gap_proc_anim_apply(GimpRunModeType run_mode, gint32 image_id, char *l_plugin_name);
/* ------------------------ /* ------------------------
@ -45,7 +45,7 @@ gint gap_proc_anim_apply(GRunModeType run_mode, gint32 image_id, char *l_plugin_
/* Hacked Iterators for some existing Plugins */ /* Hacked Iterators for some existing Plugins */
gint gap_run_iterators_ALT(char *name, GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct); gint gap_run_iterators_ALT(char *name, GimpRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct);
void gap_query_iterators_ALT(); void gap_query_iterators_ALT();
/* ------------------------ /* ------------------------

128
plug-ins/gap/gap_filter_codegen.c
View File

@ -54,31 +54,31 @@ void p_remove_codegen_files()
static char* static char*
p_type_to_string(GParamType t) p_type_to_string(GimpPDBArgType t)
{ {
switch (t) { switch (t) {
case PARAM_INT32: return "long "; case GIMP_PDB_INT32: return "long ";
case PARAM_INT16: return "short "; case GIMP_PDB_INT16: return "short ";
case PARAM_INT8: return "char "; case GIMP_PDB_INT8: return "char ";
case PARAM_FLOAT: return "gdouble "; case GIMP_PDB_FLOAT: return "gdouble ";
case PARAM_STRING: return "char *"; case GIMP_PDB_STRING: return "char *";
case PARAM_INT32ARRAY: return "INT32ARRAY"; case GIMP_PDB_INT32ARRAY: return "INT32ARRAY";
case PARAM_INT16ARRAY: return "INT16ARRAY"; case GIMP_PDB_INT16ARRAY: return "INT16ARRAY";
case PARAM_INT8ARRAY: return "INT8ARRAY"; case GIMP_PDB_INT8ARRAY: return "INT8ARRAY";
case PARAM_FLOATARRAY: return "FLOATARRAY"; case GIMP_PDB_FLOATARRAY: return "FLOATARRAY";
case PARAM_STRINGARRAY: return "STRINGARRAY"; case GIMP_PDB_STRINGARRAY: return "STRINGARRAY";
case PARAM_COLOR: return "t_color "; case GIMP_PDB_COLOR: return "t_color ";
case PARAM_REGION: return "REGION"; case GIMP_PDB_REGION: return "REGION";
case PARAM_DISPLAY: return "gint32 "; case GIMP_PDB_DISPLAY: return "gint32 ";
case PARAM_IMAGE: return "gint32 "; case GIMP_PDB_IMAGE: return "gint32 ";
case PARAM_LAYER: return "gint32 "; case GIMP_PDB_LAYER: return "gint32 ";
case PARAM_CHANNEL: return "gint32 "; case GIMP_PDB_CHANNEL: return "gint32 ";
case PARAM_DRAWABLE: return "gint32 "; case GIMP_PDB_DRAWABLE: return "gint32 ";
case PARAM_SELECTION: return "SELECTION"; case GIMP_PDB_SELECTION: return "SELECTION";
case PARAM_BOUNDARY: return "BOUNDARY"; case GIMP_PDB_BOUNDARY: return "BOUNDARY";
case PARAM_PATH: return "PATH"; case GIMP_PDB_PATH: return "PATH";
case PARAM_STATUS: return "STATUS"; case GIMP_PDB_STATUS: return "STATUS";
case PARAM_END: return "END"; case GIMP_PDB_END: return "END";
default: return "UNKNOWN?"; default: return "UNKNOWN?";
} }
} }
@ -193,11 +193,11 @@ gint p_gen_code_iter_ALT(char *proc_name)
proc_name, l_proc_author, l_proc_copyright); proc_name, l_proc_author, l_proc_copyright);
/* check if plugin can be a typical one, that works on one drawable */ /* check if plugin can be a typical one, that works on one drawable */
if (l_proc_type != PROC_PLUG_IN) { l_rc = -1; } if (l_proc_type != GIMP_PLUGIN) { l_rc = -1; }
if (l_nparams < 3) { l_rc = -1; } if (l_nparams < 3) { l_rc = -1; }
if (l_params[0].type != PARAM_INT32) { l_rc = -1; } if (l_params[0].type != GIMP_PDB_INT32) { l_rc = -1; }
if (l_params[1].type != PARAM_IMAGE) { l_rc = -1; } if (l_params[1].type != GIMP_PDB_IMAGE) { l_rc = -1; }
if (l_params[2].type != PARAM_DRAWABLE) { l_rc = -1; } if (l_params[2].type != GIMP_PDB_DRAWABLE) { l_rc = -1; }
sprintf(l_filename, "%s_iter_ALT.inc", l_clean_proc_name); sprintf(l_filename, "%s_iter_ALT.inc", l_clean_proc_name);
l_fp = fopen(l_filename, "w"); l_fp = fopen(l_filename, "w");
@ -207,7 +207,7 @@ gint p_gen_code_iter_ALT(char *proc_name)
fprintf(l_fp, " * p_%s_iter_ALT \n", l_clean_proc_name); fprintf(l_fp, " * p_%s_iter_ALT \n", l_clean_proc_name);
fprintf(l_fp, " * ----------------------------------------------------------------------\n"); fprintf(l_fp, " * ----------------------------------------------------------------------\n");
fprintf(l_fp, " */\n"); fprintf(l_fp, " */\n");
fprintf(l_fp, "gint p_%s_iter_ALT(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct) \n", l_clean_proc_name); fprintf(l_fp, "gint p_%s_iter_ALT(GimpRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct) \n", l_clean_proc_name);
fprintf(l_fp, "{\n"); fprintf(l_fp, "{\n");
fprintf(l_fp, " typedef struct t_%s_Vals \n", l_clean_proc_name); fprintf(l_fp, " typedef struct t_%s_Vals \n", l_clean_proc_name);
fprintf(l_fp, " {\n"); fprintf(l_fp, " {\n");
@ -244,27 +244,27 @@ gint p_gen_code_iter_ALT(char *proc_name)
switch(l_params[l_idx].type) switch(l_params[l_idx].type)
{ {
case PARAM_INT32: case GIMP_PDB_INT32:
fprintf(l_fp, " p_delta_long(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_long(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_INT16: case GIMP_PDB_INT16:
fprintf(l_fp, " p_delta_short(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_short(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_INT8: case GIMP_PDB_INT8:
fprintf(l_fp, " p_delta_char(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_char(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_FLOAT: case GIMP_PDB_FLOAT:
fprintf(l_fp, " p_delta_gdouble(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_gdouble(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_COLOR: case GIMP_PDB_COLOR:
fprintf(l_fp, " p_delta_color(&buf.%s, &buf_from->%s, &buf_to->%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_color(&buf.%s, &buf_from->%s, &buf_to->%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_DRAWABLE: case GIMP_PDB_DRAWABLE:
fprintf(l_fp, " p_delta_drawable(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_drawable(&buf.%s, buf_from->%s, buf_to->%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
@ -311,7 +311,7 @@ gint p_gen_forward_iter_ALT(char *proc_name)
l_fp = fopen(GEN_FORWARDFILE_NAME, "a"); l_fp = fopen(GEN_FORWARDFILE_NAME, "a");
if(l_fp != NULL) if(l_fp != NULL)
{ {
fprintf(l_fp, "static gint p_%s_iter_ALT (GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct);\n", fprintf(l_fp, "static gint p_%s_iter_ALT (GimpRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct);\n",
l_clean_proc_name); l_clean_proc_name);
fclose(l_fp); fclose(l_fp);
} }
@ -384,11 +384,11 @@ gint p_gen_code_iter(char *proc_name)
if(gap_debug) fprintf(stderr, "DEBUG: found in PDB %s\n", proc_name); if(gap_debug) fprintf(stderr, "DEBUG: found in PDB %s\n", proc_name);
/* check if plugin can be a typical one, that works on one drawable */ /* check if plugin can be a typical one, that works on one drawable */
if (l_proc_type != PROC_PLUG_IN) { l_rc = -1; } if (l_proc_type != GIMP_PLUGIN) { l_rc = -1; }
if (l_nparams < 3) { l_rc = -1; } if (l_nparams < 3) { l_rc = -1; }
if (l_params[0].type != PARAM_INT32) { l_rc = -1; } if (l_params[0].type != GIMP_PDB_INT32) { l_rc = -1; }
if (l_params[1].type != PARAM_IMAGE) { l_rc = -1; } if (l_params[1].type != GIMP_PDB_IMAGE) { l_rc = -1; }
if (l_params[2].type != PARAM_DRAWABLE) { l_rc = -1; } if (l_params[2].type != GIMP_PDB_DRAWABLE) { l_rc = -1; }
sprintf(l_filename, "%s_iter.c", l_clean_proc_name); sprintf(l_filename, "%s_iter.c", l_clean_proc_name);
@ -431,9 +431,9 @@ gint p_gen_code_iter(char *proc_name)
fprintf(l_fp, "typedef struct { gint color[3]; } t_gint_color; \n"); fprintf(l_fp, "typedef struct { gint color[3]; } t_gint_color; \n");
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
fprintf(l_fp, "static void query(void); \n"); fprintf(l_fp, "static void query(void); \n");
fprintf(l_fp, "static void run(char *name, int nparam, GParam *param, int *nretvals, GParam **retvals); \n"); fprintf(l_fp, "static void run(char *name, int nparam, GimpParam *param, int *nretvals, GimpParam **retvals); \n");
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
fprintf(l_fp, "GPlugInInfo PLUG_IN_INFO = \n"); fprintf(l_fp, "GimpPlugInInfo PLUG_IN_INFO = \n");
fprintf(l_fp, "{\n"); fprintf(l_fp, "{\n");
fprintf(l_fp, " NULL, /* init_proc */ \n"); fprintf(l_fp, " NULL, /* init_proc */ \n");
fprintf(l_fp, " NULL, /* quit_proc */ \n"); fprintf(l_fp, " NULL, /* quit_proc */ \n");
@ -568,7 +568,7 @@ gint p_gen_code_iter(char *proc_name)
fprintf(l_fp, " * p_%s_iter \n", l_clean_proc_name); fprintf(l_fp, " * p_%s_iter \n", l_clean_proc_name);
fprintf(l_fp, " * ----------------------------------------------------------------------\n"); fprintf(l_fp, " * ----------------------------------------------------------------------\n");
fprintf(l_fp, " */\n"); fprintf(l_fp, " */\n");
fprintf(l_fp, "gint p_%s_iter(GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct) \n", l_clean_proc_name); fprintf(l_fp, "gint p_%s_iter(GimpRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct) \n", l_clean_proc_name);
fprintf(l_fp, "{\n"); fprintf(l_fp, "{\n");
fprintf(l_fp, " typedef struct t_%s_Vals \n", l_clean_proc_name); fprintf(l_fp, " typedef struct t_%s_Vals \n", l_clean_proc_name);
fprintf(l_fp, " {\n"); fprintf(l_fp, " {\n");
@ -602,27 +602,27 @@ gint p_gen_code_iter(char *proc_name)
switch(l_params[l_idx].type) switch(l_params[l_idx].type)
{ {
case PARAM_INT32: case GIMP_PDB_INT32:
fprintf(l_fp, " p_delta_long(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_long(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_INT16: case GIMP_PDB_INT16:
fprintf(l_fp, " p_delta_short(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_short(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_INT8: case GIMP_PDB_INT8:
fprintf(l_fp, " p_delta_char(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_char(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_FLOAT: case GIMP_PDB_FLOAT:
fprintf(l_fp, " p_delta_gdouble(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_gdouble(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_COLOR: case GIMP_PDB_COLOR:
fprintf(l_fp, " p_delta_color(&buf.%s, &buf_from.%s, &buf_to.%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_color(&buf.%s, &buf_from.%s, &buf_to.%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
case PARAM_DRAWABLE: case GIMP_PDB_DRAWABLE:
fprintf(l_fp, " p_delta_drawable(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n", fprintf(l_fp, " p_delta_drawable(&buf.%s, buf_from.%s, buf_to.%s, total_steps, current_step);\n",
l_clean_par_name, l_clean_par_name, l_clean_par_name); l_clean_par_name, l_clean_par_name, l_clean_par_name);
break; break;
@ -647,16 +647,16 @@ gint p_gen_code_iter(char *proc_name)
fprintf(l_fp, "{\n"); fprintf(l_fp, "{\n");
fprintf(l_fp, " char l_blurb_text[300];\n"); fprintf(l_fp, " char l_blurb_text[300];\n");
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
fprintf(l_fp, " static GParamDef args_iter[] =\n"); fprintf(l_fp, " static GimpParamDef args_iter[] =\n");
fprintf(l_fp, " {\n"); fprintf(l_fp, " {\n");
fprintf(l_fp, " {PARAM_INT32, \"run_mode\", \"non-interactive\"},\n"); fprintf(l_fp, " {GIMP_PDB_INT32, \"run_mode\", \"non-interactive\"},\n");
fprintf(l_fp, " {PARAM_INT32, \"total_steps\", \"total number of steps (# of layers-1 to apply the related plug-in)\"},\n"); fprintf(l_fp, " {GIMP_PDB_INT32, \"total_steps\", \"total number of steps (# of layers-1 to apply the related plug-in)\"},\n");
fprintf(l_fp, " {PARAM_FLOAT, \"current_step\", \"current (for linear iterations this is the layerstack position, otherwise some value inbetween)\"},\n"); fprintf(l_fp, " {GIMP_PDB_FLOAT, \"current_step\", \"current (for linear iterations this is the layerstack position, otherwise some value inbetween)\"},\n");
fprintf(l_fp, " {PARAM_INT32, \"len_struct\", \"length of stored data structure with id is equal to the plug_in proc_name\"},\n"); fprintf(l_fp, " {GIMP_PDB_INT32, \"len_struct\", \"length of stored data structure with id is equal to the plug_in proc_name\"},\n");
fprintf(l_fp, " };\n"); fprintf(l_fp, " };\n");
fprintf(l_fp, " static int nargs_iter = sizeof(args_iter) / sizeof(args_iter[0]);\n"); fprintf(l_fp, " static int nargs_iter = sizeof(args_iter) / sizeof(args_iter[0]);\n");
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
fprintf(l_fp, " static GParamDef *return_vals = NULL;\n"); fprintf(l_fp, " static GimpParamDef *return_vals = NULL;\n");
fprintf(l_fp, " static int nreturn_vals = 0;\n"); fprintf(l_fp, " static int nreturn_vals = 0;\n");
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
fprintf(l_fp, " sprintf(l_blurb_text, \"This extension calculates the modified values for one iterationstep for the call of %s\");\n", l_clean_proc_name); fprintf(l_fp, " sprintf(l_blurb_text, \"This extension calculates the modified values for one iterationstep for the call of %s\");\n", l_clean_proc_name);
@ -669,7 +669,7 @@ gint p_gen_code_iter(char *proc_name)
fprintf(l_fp, " \"%s\",\n", l_gendate); /* generation date */ fprintf(l_fp, " \"%s\",\n", l_gendate); /* generation date */
fprintf(l_fp, " NULL, /* do not appear in menus */\n"); fprintf(l_fp, " NULL, /* do not appear in menus */\n");
fprintf(l_fp, " NULL,\n"); fprintf(l_fp, " NULL,\n");
fprintf(l_fp, " PROC_EXTENSION,\n"); fprintf(l_fp, " GIMP_EXTENSION,\n");
fprintf(l_fp, " nargs_iter, nreturn_vals,\n"); fprintf(l_fp, " nargs_iter, nreturn_vals,\n");
fprintf(l_fp, " args_iter, return_vals);\n"); fprintf(l_fp, " args_iter, return_vals);\n");
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
@ -685,13 +685,13 @@ gint p_gen_code_iter(char *proc_name)
fprintf(l_fp, "static void\n"); fprintf(l_fp, "static void\n");
fprintf(l_fp, "run (char *name,\n"); fprintf(l_fp, "run (char *name,\n");
fprintf(l_fp, " int n_params,\n"); fprintf(l_fp, " int n_params,\n");
fprintf(l_fp, " GParam *param,\n"); fprintf(l_fp, " GimpParam *param,\n");
fprintf(l_fp, " int *nreturn_vals,\n"); fprintf(l_fp, " int *nreturn_vals,\n");
fprintf(l_fp, " GParam **return_vals)\n"); fprintf(l_fp, " GimpParam **return_vals)\n");
fprintf(l_fp, "{\n"); fprintf(l_fp, "{\n");
fprintf(l_fp, " static GParam values[1];\n"); fprintf(l_fp, " static GimpParam values[1];\n");
fprintf(l_fp, " GRunModeType run_mode;\n"); fprintf(l_fp, " GimpRunModeType run_mode;\n");
fprintf(l_fp, " GStatusType status = STATUS_SUCCESS;\n"); fprintf(l_fp, " GimpPDBStatusType status = GIMP_PDB_SUCCESS;\n");
fprintf(l_fp, " gint32 image_id;\n"); fprintf(l_fp, " gint32 image_id;\n");
fprintf(l_fp, " gint32 len_struct;\n"); fprintf(l_fp, " gint32 len_struct;\n");
fprintf(l_fp, " gint32 total_steps;\n"); fprintf(l_fp, " gint32 total_steps;\n");
@ -705,7 +705,7 @@ gint p_gen_code_iter(char *proc_name)
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
fprintf(l_fp, " run_mode = param[0].data.d_int32;\n"); fprintf(l_fp, " run_mode = param[0].data.d_int32;\n");
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
fprintf(l_fp, " if ((run_mode == RUN_NONINTERACTIVE) && (n_params == 4))\n"); fprintf(l_fp, " if ((run_mode == GIMP_RUN_NONINTERACTIVE) && (n_params == 4))\n");
fprintf(l_fp, " {\n"); fprintf(l_fp, " {\n");
fprintf(l_fp, " total_steps = param[1].data.d_int32;\n"); fprintf(l_fp, " total_steps = param[1].data.d_int32;\n");
fprintf(l_fp, " current_step = param[2].data.d_float;\n"); fprintf(l_fp, " current_step = param[2].data.d_float;\n");
@ -713,12 +713,12 @@ gint p_gen_code_iter(char *proc_name)
fprintf(l_fp, " l_rc = p_%s_iter(run_mode, total_steps, current_step, len_struct);\n", l_clean_proc_name); fprintf(l_fp, " l_rc = p_%s_iter(run_mode, total_steps, current_step, len_struct);\n", l_clean_proc_name);
fprintf(l_fp, " if(l_rc < 0)\n"); fprintf(l_fp, " if(l_rc < 0)\n");
fprintf(l_fp, " {\n"); fprintf(l_fp, " {\n");
fprintf(l_fp, " status = STATUS_EXECUTION_ERROR;\n"); fprintf(l_fp, " status = GIMP_PDB_EXECUTION_ERROR;\n");
fprintf(l_fp, " }\n"); fprintf(l_fp, " }\n");
fprintf(l_fp, " }\n"); fprintf(l_fp, " }\n");
fprintf(l_fp, " else status = STATUS_CALLING_ERROR;\n"); fprintf(l_fp, " else status = GIMP_PDB_CALLING_ERROR;\n");
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
fprintf(l_fp, " values[0].type = PARAM_STATUS;\n"); fprintf(l_fp, " values[0].type = GIMP_PDB_STATUS;\n");
fprintf(l_fp, " values[0].data.d_status = status;\n"); fprintf(l_fp, " values[0].data.d_status = status;\n");
fprintf(l_fp, "\n"); fprintf(l_fp, "\n");
fprintf(l_fp, "}\n"); fprintf(l_fp, "}\n");

48
plug-ins/gap/gap_filter_foreach.c
View File

@ -78,7 +78,7 @@ static gint32 g_current_image_id;
void p_gdisplays_update_full(gint32 image_id) void p_gdisplays_update_full(gint32 image_id)
{ {
GParam* l_params; GimpParam* l_params;
gint l_retvals; gint l_retvals;
if(p_procedure_available("gimp_image_update_full", PTYP_ANY) >= 0) if(p_procedure_available("gimp_image_update_full", PTYP_ANY) >= 0)
@ -86,8 +86,8 @@ void p_gdisplays_update_full(gint32 image_id)
l_params = gimp_run_procedure ("gimp_image_update_full", l_params = gimp_run_procedure ("gimp_image_update_full",
&l_retvals, &l_retvals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
/* Note: gimp_displays_update_full is not available in the official release gimp 0.99.16 /* Note: gimp_displays_update_full is not available in the official release gimp 0.99.16
* (dont care if procedure is not there, * (dont care if procedure is not there,
@ -105,7 +105,7 @@ void p_gdisplays_update_full(gint32 image_id)
/* pitstop dialog /* pitstop dialog
* return -1 on cancel, 0 .. on continue, 1 .. on skip * return -1 on cancel, 0 .. on continue, 1 .. on skip
*/ */
static gint p_pitstop(GRunModeType run_mode, char *plugin_name, gint text_flag, static gint p_pitstop(GimpRunModeType run_mode, char *plugin_name, gint text_flag,
char *step_backup_file, gint len_step_backup_file, char *step_backup_file, gint len_step_backup_file,
gint32 layer_idx) gint32 layer_idx)
{ {
@ -138,7 +138,7 @@ static gint p_pitstop(GRunModeType run_mode, char *plugin_name, gint text_flag,
l_but_argc = 2; l_but_argc = 2;
l_argc = 0; l_argc = 0;
/* optional dialog between both calls (to see the effect of 1.call) */ /* optional dialog between both calls (to see the effect of 1.call) */
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_env = g_getenv("GAP_FILTER_PITSTOP"); l_env = g_getenv("GAP_FILTER_PITSTOP");
if(l_env != NULL) if(l_env != NULL)
@ -230,7 +230,7 @@ static gint32 p_get_indexed_layerid(gint32 image_id, gint *nlayers, gint32 idx,
* ============================================================================ * ============================================================================
*/ */
int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id, int p_foreach_multilayer(GimpRunModeType run_mode, gint32 image_id,
char *plugin_name, t_apply_mode apply_mode) char *plugin_name, t_apply_mode apply_mode)
{ {
static char l_key_from[512]; static char l_key_from[512];
@ -241,7 +241,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
gint32 l_idx; gint32 l_idx;
gint l_nlayers; gint l_nlayers;
gdouble l_percentage, l_percentage_step; gdouble l_percentage, l_percentage_step;
GParam *l_params; GimpParam *l_params;
gint l_retvals; gint l_retvals;
int l_rc; int l_rc;
gint l_plugin_data_len; gint l_plugin_data_len;
@ -271,7 +271,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
l_plugin_iterator = p_get_iterator_proc(plugin_name); l_plugin_iterator = p_get_iterator_proc(plugin_name);
l_percentage = 0.0; l_percentage = 0.0;
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
gimp_progress_init( _("Applying Filter to all Layers...")); gimp_progress_init( _("Applying Filter to all Layers..."));
} }
@ -330,7 +330,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
else else
{ {
if(gap_debug) fprintf(stderr, "DEBUG: apllying %s on Layerstack %d id=%d\n", plugin_name, (int)l_idx, (int)l_layer_id); if(gap_debug) fprintf(stderr, "DEBUG: apllying %s on Layerstack %d id=%d\n", plugin_name, (int)l_idx, (int)l_layer_id);
l_rc = p_call_plugin(plugin_name, image_id, l_layer_id, RUN_INTERACTIVE); l_rc = p_call_plugin(plugin_name, image_id, l_layer_id, GIMP_RUN_INTERACTIVE);
/* get values, then store with suffix "_ITER_FROM" */ /* get values, then store with suffix "_ITER_FROM" */
l_plugin_data_len = p_get_data(plugin_name); l_plugin_data_len = p_get_data(plugin_name);
@ -341,7 +341,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
} }
else l_rc = -1; else l_rc = -1;
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -380,7 +380,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
p_gdisplays_update_full(image_id); p_gdisplays_update_full(image_id);
if(gap_debug) fprintf(stderr, "DEBUG: apllying %s on Layerstack 0 id=%d\n", plugin_name, (int)l_layer_id); if(gap_debug) fprintf(stderr, "DEBUG: apllying %s on Layerstack 0 id=%d\n", plugin_name, (int)l_layer_id);
l_rc = p_call_plugin(plugin_name, image_id, l_layer_id, RUN_INTERACTIVE); l_rc = p_call_plugin(plugin_name, image_id, l_layer_id, GIMP_RUN_INTERACTIVE);
/* get values, then store with suffix "_ITER_TO" */ /* get values, then store with suffix "_ITER_TO" */
l_plugin_data_len = p_get_data(plugin_name); l_plugin_data_len = p_get_data(plugin_name);
@ -391,7 +391,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
} }
else l_rc = -1; else l_rc = -1;
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -423,9 +423,9 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
else else
{ {
if(gap_debug) fprintf(stderr, "DEBUG: NO Varying, apllying %s on Layer id=%d\n", plugin_name, (int)l_layer_id); if(gap_debug) fprintf(stderr, "DEBUG: NO Varying, apllying %s on Layer id=%d\n", plugin_name, (int)l_layer_id);
l_rc = p_call_plugin(plugin_name, image_id, l_layer_id, RUN_INTERACTIVE); l_rc = p_call_plugin(plugin_name, image_id, l_layer_id, GIMP_RUN_INTERACTIVE);
l_top_layer = 0; l_top_layer = 0;
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -437,7 +437,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
{ {
/* call plugin foreach layer inbetween /* call plugin foreach layer inbetween
* with runmode RUN_WITH_LAST_VALS * with runmode GIMP_RUN_WITH_LAST_VALS
* and modify the last values * and modify the last values
*/ */
l_pit_rc = 1; l_pit_rc = 1;
@ -476,11 +476,11 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
l_plugin_iterator, (int)l_idx); l_plugin_iterator, (int)l_idx);
l_params = gimp_run_procedure (l_plugin_iterator, l_params = gimp_run_procedure (l_plugin_iterator,
&l_retvals, &l_retvals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_INT32, l_nlayers -1, /* total steps */ GIMP_PDB_INT32, l_nlayers -1, /* total steps */
PARAM_FLOAT, (gdouble)l_idx, /* current step */ GIMP_PDB_FLOAT, (gdouble)l_idx, /* current step */
PARAM_INT32, l_plugin_data_len, /* length of stored data struct */ GIMP_PDB_INT32, l_plugin_data_len, /* length of stored data struct */
PARAM_END); GIMP_PDB_END);
if (l_params[0].data.d_status == FALSE) if (l_params[0].data.d_status == FALSE)
{ {
fprintf(stderr, "ERROR: iterator %s failed\n", l_plugin_iterator); fprintf(stderr, "ERROR: iterator %s failed\n", l_plugin_iterator);
@ -495,7 +495,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
if(l_pit_rc == 0) /* 0 == continue without further dialogs */ if(l_pit_rc == 0) /* 0 == continue without further dialogs */
{ {
/* call the plugin itself with runmode RUN_WITH_LAST_VALUES */ /* call the plugin itself with runmode RUN_WITH_LAST_VALUES */
l_rc = p_call_plugin(plugin_name, image_id, l_layer_id, RUN_WITH_LAST_VALS); l_rc = p_call_plugin(plugin_name, image_id, l_layer_id, GIMP_RUN_WITH_LAST_VALS);
/* check if to save each step to backup file */ /* check if to save each step to backup file */
if((l_step_backup_file[0] != '\0') && (l_step_backup_file[0] != ' ')) if((l_step_backup_file[0] != '\0') && (l_step_backup_file[0] != ' '))
{ {
@ -505,7 +505,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
} }
} }
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -536,7 +536,7 @@ int p_foreach_multilayer(GRunModeType run_mode, gint32 image_id,
* ============================================================================ * ============================================================================
*/ */
gint gap_proc_anim_apply(GRunModeType run_mode, gint32 image_id, char *plugin_name) gint gap_proc_anim_apply(GimpRunModeType run_mode, gint32 image_id, char *plugin_name)
{ {
t_gap_db_browse_result l_browser_result; t_gap_db_browse_result l_browser_result;
t_apply_mode l_apply_mode; t_apply_mode l_apply_mode;
@ -544,7 +544,7 @@ gint gap_proc_anim_apply(GRunModeType run_mode, gint32 image_id, char *plugin_na
l_apply_mode = PAPP_CONSTANT; l_apply_mode = PAPP_CONSTANT;
g_current_image_id = image_id; g_current_image_id = image_id;
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
if(gap_db_browser_dialog( _("Select Filter for Animated apply"), if(gap_db_browser_dialog( _("Select Filter for Animated apply"),

18
plug-ins/gap/gap_filter_iterators.c
View File

@ -28,7 +28,7 @@
* plugins internal settings. * plugins internal settings.
* *
* Common things to all Iteratur Plugins: * Common things to all Iteratur Plugins:
* Interface: run_mode # is always RUN_NONINTERACTIVE * Interface: run_mode # is always GIMP_RUN_NONINTERACTIVE
* total_steps # total number of handled layers (drawables) * total_steps # total number of handled layers (drawables)
* current_step # current layer (beginning wit 0) * current_step # current layer (beginning wit 0)
* has type gdouble for later extensions * has type gdouble for later extensions
@ -658,16 +658,16 @@ static void p_install_proc_iter_ALT(char *name)
gchar *l_iter_proc_name; gchar *l_iter_proc_name;
gchar *l_blurb_text; gchar *l_blurb_text;
static GParamDef args_iter[] = static GimpParamDef args_iter[] =
{ {
{PARAM_INT32, "run_mode", "non-interactive"}, {GIMP_PDB_INT32, "run_mode", "non-interactive"},
{PARAM_INT32, "total_steps", "total number of steps (# of layers-1 to apply the related plug-in)"}, {GIMP_PDB_INT32, "total_steps", "total number of steps (# of layers-1 to apply the related plug-in)"},
{PARAM_FLOAT, "current_step", "current (for linear iterations this is the layerstack position, otherwise some value inbetween)"}, {GIMP_PDB_FLOAT, "current_step", "current (for linear iterations this is the layerstack position, otherwise some value inbetween)"},
{PARAM_INT32, "len_struct", "length of stored data structure with id is equal to the plug_in proc_name"}, {GIMP_PDB_INT32, "len_struct", "length of stored data structure with id is equal to the plug_in proc_name"},
}; };
static int nargs_iter = sizeof(args_iter) / sizeof(args_iter[0]); static int nargs_iter = sizeof(args_iter) / sizeof(args_iter[0]);
static GParamDef *return_vals = NULL; static GimpParamDef *return_vals = NULL;
static int nreturn_vals = 0; static int nreturn_vals = 0;
l_iter_proc_name = g_strdup_printf("%s_Iterator_ALT", name); l_iter_proc_name = g_strdup_printf("%s_Iterator_ALT", name);
@ -681,7 +681,7 @@ static void p_install_proc_iter_ALT(char *name)
"Feb. 2000", "Feb. 2000",
NULL, /* do not appear in menus */ NULL, /* do not appear in menus */
NULL, NULL,
PROC_EXTENSION, GIMP_EXTENSION,
nargs_iter, nreturn_vals, nargs_iter, nreturn_vals,
args_iter, return_vals); args_iter, return_vals);
@ -703,7 +703,7 @@ void gap_query_iterators_ALT()
* ---------------------------------------------------------------------- * ----------------------------------------------------------------------
*/ */
gint gap_run_iterators_ALT(char *name, GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct) gint gap_run_iterators_ALT(char *name, GimpRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct)
{ {
gint l_rc; gint l_rc;
int l_idx; int l_idx;

2
plug-ins/gap/gap_filter_iterators.h
View File

@ -38,7 +38,7 @@
#ifndef _GAP_FILTER_ITERATORS_H #ifndef _GAP_FILTER_ITERATORS_H
#define _GAP_FILTER_ITERATORS_H #define _GAP_FILTER_ITERATORS_H
typedef gint (*t_iter_ALT_func) (GRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct); typedef gint (*t_iter_ALT_func) (GimpRunModeType run_mode, gint32 total_steps, gdouble current_step, gint32 len_struct);
typedef struct t_iter_ALT_tab typedef struct t_iter_ALT_tab

50
plug-ins/gap/gap_filter_main.c
View File

@ -66,10 +66,10 @@ int gap_debug = 0;
static void query(void); static void query(void);
static void run(char *name, int nparam, GParam *param, static void run(char *name, int nparam, GimpParam *param,
int *nretvals, GParam **retvals); int *nretvals, GimpParam **retvals);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -82,29 +82,29 @@ MAIN ()
static void static void
query () query ()
{ {
static GParamDef args_foreach[] = static GimpParamDef args_foreach[] =
{ {
{PARAM_INT32, "run_mode", "Interactive, non-interactive"}, {GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive"},
{PARAM_IMAGE, "image", "Input image"}, {GIMP_PDB_IMAGE, "image", "Input image"},
{PARAM_DRAWABLE, "drawable", "Input drawable (unused)"}, {GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)"},
{PARAM_STRING, "proc_name", "name of plugin procedure to run for each layer)"}, {GIMP_PDB_STRING, "proc_name", "name of plugin procedure to run for each layer)"},
}; };
static int nargs_foreach = sizeof(args_foreach) / sizeof(args_foreach[0]); static int nargs_foreach = sizeof(args_foreach) / sizeof(args_foreach[0]);
static GParamDef *return_vals = NULL; static GimpParamDef *return_vals = NULL;
static int nreturn_vals = 0; static int nreturn_vals = 0;
INIT_I18N(); INIT_I18N();
gimp_install_procedure("plug_in_gap_layers_run_animfilter", gimp_install_procedure("plug_in_gap_layers_run_animfilter",
"This plugin calls another plugin for each layer of an image, varying its settings (to produce animated effects). The called plugin must work on a single drawable and must be able to RUN_WITH_LAST_VALS", "This plugin calls another plugin for each layer of an image, varying its settings (to produce animated effects). The called plugin must work on a single drawable and must be able to GIMP_RUN_WITH_LAST_VALS",
"", "",
"Wolfgang Hofer (hof@hotbot.com)", "Wolfgang Hofer (hof@hotbot.com)",
"Wolfgang Hofer", "Wolfgang Hofer",
gap_filter_version, gap_filter_version,
N_("<Image>/Filters/Filter all Layers..."), N_("<Image>/Filters/Filter all Layers..."),
"RGB*, INDEXED*, GRAY*", "RGB*, INDEXED*, GRAY*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs_foreach, nreturn_vals, nargs_foreach, nreturn_vals,
args_foreach, return_vals); args_foreach, return_vals);
@ -119,16 +119,16 @@ query ()
static void static void
run (char *name, run (char *name,
int n_params, int n_params,
GParam *param, GimpParam *param,
int *nreturn_vals, int *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
#define MAX_PLUGIN_NAME_LEN 256 #define MAX_PLUGIN_NAME_LEN 256
char l_plugin_name[MAX_PLUGIN_NAME_LEN]; char l_plugin_name[MAX_PLUGIN_NAME_LEN];
static GParam values[1]; static GimpParam values[1];
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_id; gint32 image_id;
gint32 len_struct; gint32 len_struct;
gint32 total_steps; gint32 total_steps;
@ -155,11 +155,11 @@ run (char *name,
if (strcmp (name, "plug_in_gap_layers_run_animfilter") == 0) if (strcmp (name, "plug_in_gap_layers_run_animfilter") == 0)
{ {
if (run_mode == RUN_NONINTERACTIVE) if (run_mode == GIMP_RUN_NONINTERACTIVE)
{ {
if (n_params != 4) if (n_params != 4)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
else else
{ {
@ -168,7 +168,7 @@ run (char *name,
} }
INIT_I18N(); INIT_I18N();
} }
else if(run_mode == RUN_WITH_LAST_VALS) else if(run_mode == GIMP_RUN_WITH_LAST_VALS)
{ {
/* probably get last values (name of last plugin) */ /* probably get last values (name of last plugin) */
gimp_get_data("plug_in_gap_layers_run_animfilter", l_plugin_name); gimp_get_data("plug_in_gap_layers_run_animfilter", l_plugin_name);
@ -176,7 +176,7 @@ run (char *name,
INIT_I18N_UI(); INIT_I18N_UI();
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
image_id = param[1].data.d_image; image_id = param[1].data.d_image;
@ -187,26 +187,26 @@ run (char *name,
} }
else else
{ {
if ((run_mode == RUN_NONINTERACTIVE) && (n_params == 4)) if ((run_mode == GIMP_RUN_NONINTERACTIVE) && (n_params == 4))
{ {
total_steps = param[1].data.d_int32; total_steps = param[1].data.d_int32;
current_step = param[2].data.d_float; current_step = param[2].data.d_float;
len_struct = param[3].data.d_int32; len_struct = param[3].data.d_int32;
l_rc = gap_run_iterators_ALT(name, run_mode, total_steps, current_step, len_struct); l_rc = gap_run_iterators_ALT(name, run_mode, total_steps, current_step, len_struct);
} }
else status = STATUS_CALLING_ERROR; else status = GIMP_PDB_CALLING_ERROR;
} }
if(l_rc < 0) if(l_rc < 0)
{ {
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush(); gimp_displays_flush();
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
} }

66
plug-ins/gap/gap_filter_pdb.c
View File

@ -71,7 +71,7 @@ static gint32 g_current_image_id;
gint p_call_plugin(char *plugin_name, gint32 image_id, gint32 layer_id, GRunModeType run_mode) gint p_call_plugin(char *plugin_name, gint32 image_id, gint32 layer_id, GimpRunModeType run_mode)
{ {
GimpDrawable *l_drawable; GimpDrawable *l_drawable;
GimpParam *l_ret_params; GimpParam *l_ret_params;
@ -109,8 +109,8 @@ gint p_call_plugin(char *plugin_name, gint32 image_id, gint32 layer_id, GRunMode
} }
/* construct the procedures arguments */ /* construct the procedures arguments */
l_argv = g_new (GParam, l_nparams); l_argv = g_new (GimpParam, l_nparams);
memset (l_argv, 0, (sizeof (GParam) * l_nparams)); memset (l_argv, 0, (sizeof (GimpParam) * l_nparams));
/* initialize the argument types */ /* initialize the argument types */
for (l_idx = 0; l_idx < l_nparams; l_idx++) for (l_idx = 0; l_idx < l_nparams; l_idx++)
@ -118,26 +118,26 @@ gint p_call_plugin(char *plugin_name, gint32 image_id, gint32 layer_id, GRunMode
l_argv[l_idx].type = l_params[l_idx].type; l_argv[l_idx].type = l_params[l_idx].type;
switch(l_params[l_idx].type) switch(l_params[l_idx].type)
{ {
case PARAM_DISPLAY: case GIMP_PDB_DISPLAY:
l_argv[l_idx].data.d_display = -1; l_argv[l_idx].data.d_display = -1;
break; break;
case PARAM_DRAWABLE: case GIMP_PDB_DRAWABLE:
case PARAM_LAYER: case GIMP_PDB_LAYER:
case PARAM_CHANNEL: case GIMP_PDB_CHANNEL:
l_argv[l_idx].data.d_drawable = -1; l_argv[l_idx].data.d_drawable = -1;
break; break;
case PARAM_IMAGE: case GIMP_PDB_IMAGE:
l_argv[l_idx].data.d_image = -1; l_argv[l_idx].data.d_image = -1;
break; break;
case PARAM_INT32: case GIMP_PDB_INT32:
case PARAM_INT16: case GIMP_PDB_INT16:
case PARAM_INT8: case GIMP_PDB_INT8:
l_argv[l_idx].data.d_int32 = 0; l_argv[l_idx].data.d_int32 = 0;
break; break;
case PARAM_FLOAT: case GIMP_PDB_FLOAT:
l_argv[l_idx].data.d_float = 0.0; l_argv[l_idx].data.d_float = 0.0;
break; break;
case PARAM_STRING: case GIMP_PDB_STRING:
l_argv[l_idx].data.d_string = NULL; l_argv[l_idx].data.d_string = NULL;
break; break;
default: default:
@ -187,7 +187,7 @@ gint p_call_plugin(char *plugin_name, gint32 image_id, gint32 layer_id, GRunMode
int int
p_save_xcf(gint32 image_id, char *sav_name) p_save_xcf(gint32 image_id, char *sav_name)
{ {
GParam* l_params; GimpParam* l_params;
gint l_retvals; gint l_retvals;
/* save current image as xcf file /* save current image as xcf file
@ -196,12 +196,12 @@ p_save_xcf(gint32 image_id, char *sav_name)
*/ */
l_params = gimp_run_procedure ("gimp_xcf_save", l_params = gimp_run_procedure ("gimp_xcf_save",
&l_retvals, &l_retvals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_DRAWABLE, 0, GIMP_PDB_DRAWABLE, 0,
PARAM_STRING, sav_name, GIMP_PDB_STRING, sav_name,
PARAM_STRING, sav_name, /* raw name ? */ GIMP_PDB_STRING, sav_name, /* raw name ? */
PARAM_END); GIMP_PDB_END);
if (l_params[0].data.d_status == FALSE) return(-1); if (l_params[0].data.d_status == FALSE) return(-1);
@ -296,20 +296,20 @@ gint p_procedure_available(char *proc_name, t_proc_type ptype)
{ {
case PTYP_ITERATOR: case PTYP_ITERATOR:
/* check exactly for Input Parametertypes (common to all Iterators) */ /* check exactly for Input Parametertypes (common to all Iterators) */
if (l_proc_type != PROC_EXTENSION ) { l_rc = -1; break; } if (l_proc_type != GIMP_EXTENSION ) { l_rc = -1; break; }
if (l_nparams != 4) { l_rc = -1; break; } if (l_nparams != 4) { l_rc = -1; break; }
if (l_params[0].type != PARAM_INT32) { l_rc = -1; break; } if (l_params[0].type != GIMP_PDB_INT32) { l_rc = -1; break; }
if (l_params[1].type != PARAM_INT32) { l_rc = -1; break; } if (l_params[1].type != GIMP_PDB_INT32) { l_rc = -1; break; }
if (l_params[2].type != PARAM_FLOAT) { l_rc = -1; break; } if (l_params[2].type != GIMP_PDB_FLOAT) { l_rc = -1; break; }
if (l_params[3].type != PARAM_INT32) { l_rc = -1; break; } if (l_params[3].type != GIMP_PDB_INT32) { l_rc = -1; break; }
break; break;
case PTYP_CAN_OPERATE_ON_DRAWABLE: case PTYP_CAN_OPERATE_ON_DRAWABLE:
/* check if plugin can be a typical one, that works on one drawable */ /* check if plugin can be a typical one, that works on one drawable */
if (l_proc_type != PROC_PLUG_IN) { l_rc = -1; break; } if (l_proc_type != GIMP_PLUGIN) { l_rc = -1; break; }
if (l_nparams < 3) { l_rc = -1; break; } if (l_nparams < 3) { l_rc = -1; break; }
if (l_params[0].type != PARAM_INT32) { l_rc = -1; break; } if (l_params[0].type != GIMP_PDB_INT32) { l_rc = -1; break; }
if (l_params[1].type != PARAM_IMAGE) { l_rc = -1; break; } if (l_params[1].type != GIMP_PDB_IMAGE) { l_rc = -1; break; }
if (l_params[2].type != PARAM_DRAWABLE) { l_rc = -1; break; } if (l_params[2].type != GIMP_PDB_DRAWABLE) { l_rc = -1; break; }
break; break;
default: default:
break; break;
@ -384,7 +384,7 @@ char * p_get_iterator_proc(char *plugin_name)
int p_constraint_proc_sel1(gchar *proc_name) int p_constraint_proc_sel1(gchar *proc_name)
{ {
int l_rc; int l_rc;
GImageType l_base_type; GimpImageBaseType l_base_type;
/* here we should check, if proc_name /* here we should check, if proc_name
* can operate on the current Imagetype (RGB, INDEXED, GRAY) * can operate on the current Imagetype (RGB, INDEXED, GRAY)
@ -399,9 +399,9 @@ int p_constraint_proc_sel1(gchar *proc_name)
l_base_type =gimp_image_base_type(g_current_image_id); l_base_type =gimp_image_base_type(g_current_image_id);
switch(l_base_type) switch(l_base_type)
{ {
case RGB: case GIMP_RGB:
case GRAY: case GIMP_GRAY:
case INDEXED: case GIMP_INDEXED:
l_rc = 1; l_rc = 1;
break; break;
} }

2
plug-ins/gap/gap_filter_pdb.h
View File

@ -44,7 +44,7 @@ typedef enum
* ------------------------ * ------------------------
*/ */
gint p_call_plugin(char *plugin_name, gint32 image_id, gint32 layer_id, GRunModeType run_mode); gint p_call_plugin(char *plugin_name, gint32 image_id, gint32 layer_id, GimpRunModeType run_mode);
int p_save_xcf(gint32 image_id, char *sav_name); int p_save_xcf(gint32 image_id, char *sav_name);
gint p_get_data(char *key); gint p_get_data(char *key);
void p_set_data(char *key, gint plugin_data_len); void p_set_data(char *key, gint plugin_data_len);

76
plug-ins/gap/gap_frontends_main.c
View File

@ -76,10 +76,10 @@ static char *gap_main_version = "1.1.11b; 1999/11/20";
int gap_debug = 0; int gap_debug = 0;
static void query(void); static void query(void);
static void run(char *name, int nparam, GParam *param, static void run(char *name, int nparam, GimpParam *param,
int *nretvals, GParam **retvals); int *nretvals, GimpParam **retvals);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -92,29 +92,29 @@ MAIN ()
static void static void
query () query ()
{ {
static GParamDef args_xanim[] = static GimpParamDef args_xanim[] =
{ {
{PARAM_INT32, "run_mode", "Interactive"}, {GIMP_PDB_INT32, "run_mode", "Interactive"},
{PARAM_IMAGE, "image", "(unused)"}, {GIMP_PDB_IMAGE, "image", "(unused)"},
{PARAM_DRAWABLE, "drawable", "(unused)"}, {GIMP_PDB_DRAWABLE, "drawable", "(unused)"},
}; };
static int nargs_xanim = sizeof(args_xanim) / sizeof(args_xanim[0]); static int nargs_xanim = sizeof(args_xanim) / sizeof(args_xanim[0]);
static GParamDef args_xanim_ext[] = static GimpParamDef args_xanim_ext[] =
{ {
{PARAM_INT32, "run_mode", "Interactive"}, {GIMP_PDB_INT32, "run_mode", "Interactive"},
}; };
static int nargs_xanim_ext = sizeof(args_xanim_ext) / sizeof(args_xanim_ext[0]); static int nargs_xanim_ext = sizeof(args_xanim_ext) / sizeof(args_xanim_ext[0]);
static GParamDef args_mpege[] = static GimpParamDef args_mpege[] =
{ {
{PARAM_INT32, "run_mode", "Interactive, non-interactive"}, {GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive"},
{PARAM_IMAGE, "image", "Input image (one of the Anim Frames)"}, {GIMP_PDB_IMAGE, "image", "Input image (one of the Anim Frames)"},
{PARAM_DRAWABLE, "drawable", "Input drawable (unused)"}, {GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)"},
}; };
static int nargs_mpege = sizeof(args_mpege) / sizeof(args_mpege[0]); static int nargs_mpege = sizeof(args_mpege) / sizeof(args_mpege[0]);
static GParamDef *return_vals = NULL; static GimpParamDef *return_vals = NULL;
static int nreturn_vals = 0; static int nreturn_vals = 0;
@ -126,7 +126,7 @@ query ()
gap_main_version, gap_main_version,
N_("<Image>/Video/Split Video to Frames/Any XANIM readable..."), N_("<Image>/Video/Split Video to Frames/Any XANIM readable..."),
NULL, NULL,
PROC_PLUG_IN, GIMP_PLUGIN,
nargs_xanim, nreturn_vals, nargs_xanim, nreturn_vals,
args_xanim, return_vals); args_xanim, return_vals);
@ -138,7 +138,7 @@ query ()
gap_main_version, gap_main_version,
N_("<Toolbox>/Xtns/Split Video to Frames/Any XANIM readable..."), N_("<Toolbox>/Xtns/Split Video to Frames/Any XANIM readable..."),
NULL, NULL,
PROC_EXTENSION, GIMP_EXTENSION,
nargs_xanim_ext, nreturn_vals, nargs_xanim_ext, nreturn_vals,
args_xanim_ext, return_vals); args_xanim_ext, return_vals);
@ -150,7 +150,7 @@ query ()
gap_main_version, gap_main_version,
N_("<Image>/Video/Encode/MPEG1..."), N_("<Image>/Video/Encode/MPEG1..."),
"*", "*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs_mpege, nreturn_vals, nargs_mpege, nreturn_vals,
args_mpege, return_vals); args_mpege, return_vals);
@ -163,7 +163,7 @@ query ()
gap_main_version, gap_main_version,
N_("<Image>/Video/Encode/MPEG2..."), N_("<Image>/Video/Encode/MPEG2..."),
"*", "*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs_mpege, nreturn_vals, nargs_mpege, nreturn_vals,
args_mpege, return_vals); args_mpege, return_vals);
@ -175,9 +175,9 @@ query ()
static void static void
run (char *name, run (char *name,
int n_params, int n_params,
GParam *param, GimpParam *param,
int *nreturn_vals, int *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
typedef struct typedef struct
{ {
@ -191,9 +191,9 @@ run (char *name,
char *l_env; char *l_env;
char l_extension[32]; char l_extension[32];
static GParam values[2]; static GimpParam values[2];
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_id; gint32 image_id;
gint32 nr; gint32 nr;
@ -229,8 +229,8 @@ run (char *name,
{ {
fprintf(stderr, "gap_plugin is LOCKED for Image ID=%s\n", l_lockname); fprintf(stderr, "gap_plugin is LOCKED for Image ID=%s\n", l_lockname);
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
return ; return ;
} }
@ -242,7 +242,7 @@ run (char *name,
gimp_set_data (l_lockname, &l_lock, sizeof(l_lock)); gimp_set_data (l_lockname, &l_lock, sizeof(l_lock));
} }
if (run_mode == RUN_NONINTERACTIVE) { if (run_mode == GIMP_RUN_NONINTERACTIVE) {
INIT_I18N(); INIT_I18N();
} else { } else {
INIT_I18N_UI(); INIT_I18N_UI();
@ -251,13 +251,13 @@ run (char *name,
if ((strcmp (name, "plug_in_gap_xanim_decode") == 0) if ((strcmp (name, "plug_in_gap_xanim_decode") == 0)
|| (strcmp (name, "extension_gap_xanim_decode") == 0)) || (strcmp (name, "extension_gap_xanim_decode") == 0))
{ {
if (run_mode == RUN_NONINTERACTIVE) if (run_mode == GIMP_RUN_NONINTERACTIVE)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
/* planed: define non interactive PARAMS */ /* planed: define non interactive PARAMS */
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
/* planed: define non interactive PARAMS */ /* planed: define non interactive PARAMS */
@ -267,11 +267,11 @@ run (char *name,
} }
else if (strcmp (name, "plug_in_gap_mpeg_encode") == 0) else if (strcmp (name, "plug_in_gap_mpeg_encode") == 0)
{ {
if (run_mode == RUN_NONINTERACTIVE) if (run_mode == GIMP_RUN_NONINTERACTIVE)
{ {
if (n_params != 3) if (n_params != 3)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
else else
{ {
@ -280,7 +280,7 @@ run (char *name,
} }
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
image_id = param[1].data.d_image; image_id = param[1].data.d_image;
@ -292,11 +292,11 @@ run (char *name,
} }
else if (strcmp (name, "plug_in_gap_mpeg2encode") == 0) else if (strcmp (name, "plug_in_gap_mpeg2encode") == 0)
{ {
if (run_mode == RUN_NONINTERACTIVE) if (run_mode == GIMP_RUN_NONINTERACTIVE)
{ {
if (n_params != 3) if (n_params != 3)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
else else
{ {
@ -305,7 +305,7 @@ run (char *name,
} }
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
image_id = param[1].data.d_image; image_id = param[1].data.d_image;
@ -320,14 +320,14 @@ run (char *name,
if(l_rc < 0) if(l_rc < 0)
{ {
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush(); gimp_displays_flush();
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
if (strcmp (name, "extension_gap_xanim_decode") != 0) if (strcmp (name, "extension_gap_xanim_decode") != 0)

24
plug-ins/gap/gap_layer_copy.c
View File

@ -51,14 +51,14 @@ extern int gap_debug; /* ==0 ... dont print debug infos */
gint32 p_my_layer_copy (gint32 dst_image_id, gint32 p_my_layer_copy (gint32 dst_image_id,
gint32 src_layer_id, gint32 src_layer_id,
gdouble opacity, /* 0.0 upto 100.0 */ gdouble opacity, /* 0.0 upto 100.0 */
GLayerMode mode, GimpLayerModeEffects mode,
gint *src_offset_x, gint *src_offset_x,
gint *src_offset_y ) gint *src_offset_y )
{ {
gint32 l_new_layer_id; gint32 l_new_layer_id;
gint32 l_ret_id; gint32 l_ret_id;
char *l_name; char *l_name;
GDrawableType l_src_type; GimpImageType l_src_type;
if(gap_debug) printf("GAP p_my_layer_copy: START\n"); if(gap_debug) printf("GAP p_my_layer_copy: START\n");
@ -69,21 +69,21 @@ gint32 p_my_layer_copy (gint32 dst_image_id,
if(opacity < 0.0) opacity = 0.0; if(opacity < 0.0) opacity = 0.0;
l_name = gimp_layer_get_name(src_layer_id); l_name = gimp_layer_get_name(src_layer_id);
l_src_type = gimp_layer_type(src_layer_id); l_src_type = gimp_drawable_type(src_layer_id);
switch(l_src_type) switch(l_src_type)
{ {
case RGB_IMAGE: /* 0 */ case GIMP_RGB_IMAGE: /* 0 */
case RGBA_IMAGE: /* 1 */ case GIMP_RGBA_IMAGE: /* 1 */
if(gimp_image_base_type(dst_image_id) != RGB) { return -1; } if(gimp_image_base_type(dst_image_id) != GIMP_RGB) { return -1; }
break; break;
case GRAY_IMAGE: /* 2 */ case GIMP_GRAY_IMAGE: /* 2 */
case GRAYA_IMAGE: /* 3 */ case GIMP_GRAYA_IMAGE: /* 3 */
if(gimp_image_base_type(dst_image_id) != GRAY) { return -1; } if(gimp_image_base_type(dst_image_id) != GIMP_GRAY) { return -1; }
break; break;
case INDEXED_IMAGE: /* 4 */ case GIMP_INDEXED_IMAGE: /* 4 */
case INDEXEDA_IMAGE: /* 5 */ case GIMP_INDEXEDA_IMAGE: /* 5 */
if(gimp_image_base_type(dst_image_id) != INDEXED) { return -1; } if(gimp_image_base_type(dst_image_id) != GIMP_INDEXED) { return -1; }
break; break;
} }

2
plug-ins/gap/gap_layer_copy.h
View File

@ -48,7 +48,7 @@
gint32 p_my_layer_copy (gint32 dst_image_id, gint32 p_my_layer_copy (gint32 dst_image_id,
gint32 src_layer_id, gint32 src_layer_id,
gdouble opacity, /* 0.0 upto 100.0 */ gdouble opacity, /* 0.0 upto 100.0 */
GLayerMode mode, GimpLayerModeEffects mode,
gint *src_offset_x, gint *src_offset_x,
gint *src_offset_y ); gint *src_offset_y );

163
plug-ins/gap/gap_lib.c
View File

@ -36,7 +36,7 @@
* that are not the 4digit style. (like frame1.xcf) * that are not the 4digit style. (like frame1.xcf)
* 1.1.8a; 1999/08/31 hof: for AnimFrame Filtypes != XCF: * 1.1.8a; 1999/08/31 hof: for AnimFrame Filtypes != XCF:
* p_decide_save_as does save INTERACTIVE at 1.st time * p_decide_save_as does save INTERACTIVE at 1.st time
* and uses RUN_WITH_LAST_VALS for subsequent calls * and uses GIMP_RUN_WITH_LAST_VALS for subsequent calls
* (this enables to set Fileformat specific save-Parameters * (this enables to set Fileformat specific save-Parameters
* at least at the 1.st call, using the save dialog * at least at the 1.st call, using the save dialog
* of the selected (by gimp_file_save) file_save procedure. * of the selected (by gimp_file_save) file_save procedure.
@ -213,7 +213,7 @@ p_strdup_del_underscore(char *name)
* ============================================================================ * ============================================================================
*/ */
void p_msg_win(GRunModeType run_mode, char *msg) void p_msg_win(GimpRunModeType run_mode, char *msg)
{ {
static t_but_arg l_argv[1]; static t_but_arg l_argv[1];
int l_argc; int l_argc;
@ -229,7 +229,7 @@ void p_msg_win(GRunModeType run_mode, char *msg)
fwrite(msg, 1, strlen(msg), stderr); fwrite(msg, 1, strlen(msg), stderr);
fputc('\n', stderr); fputc('\n', stderr);
if(run_mode == RUN_INTERACTIVE) p_buttons_dialog (_("GAP Message"), msg, l_argc, l_argv, -1); if(run_mode == GIMP_RUN_INTERACTIVE) p_buttons_dialog (_("GAP Message"), msg, l_argc, l_argv, -1);
} }
} }
} /* end p_msg_win */ } /* end p_msg_win */
@ -609,7 +609,7 @@ char* p_alloc_fname(char *basename, long nr, char *extension)
* allocate and init an ainfo structure from the given image. * allocate and init an ainfo structure from the given image.
* ============================================================================ * ============================================================================
*/ */
t_anim_info *p_alloc_ainfo(gint32 image_id, GRunModeType run_mode) t_anim_info *p_alloc_ainfo(gint32 image_id, GimpRunModeType run_mode)
{ {
t_anim_info *l_ainfo_ptr; t_anim_info *l_ainfo_ptr;
@ -999,7 +999,7 @@ int p_decide_save_as(gint32 image_id, char *sav_name)
static t_but_arg l_argv[3]; static t_but_arg l_argv[3];
int l_argc; int l_argc;
int l_save_as_mode; int l_save_as_mode;
GRunModeType l_run_mode; GimpRunModeType l_run_mode;
l_msg = _("You are using a file format != xcf\n" l_msg = _("You are using a file format != xcf\n"
"Save Operations may result\n" "Save Operations may result\n"
@ -1028,11 +1028,11 @@ int p_decide_save_as(gint32 image_id, char *sav_name)
if(gap_debug) fprintf(stderr, "DEBUG: decide SAVE_AS_MODE %d\n", (int)l_save_as_mode); if(gap_debug) fprintf(stderr, "DEBUG: decide SAVE_AS_MODE %d\n", (int)l_save_as_mode);
if(l_save_as_mode < 0) return -1; if(l_save_as_mode < 0) return -1;
l_run_mode = RUN_INTERACTIVE; l_run_mode = GIMP_RUN_INTERACTIVE;
} }
else else
{ {
l_run_mode = RUN_WITH_LAST_VALS; l_run_mode = GIMP_RUN_WITH_LAST_VALS;
} }
gimp_set_data (l_save_as_name, &l_save_as_mode, sizeof(l_save_as_mode)); gimp_set_data (l_save_as_name, &l_save_as_mode, sizeof(l_save_as_mode));
@ -1052,12 +1052,12 @@ int p_decide_save_as(gint32 image_id, char *sav_name)
* p_save_named_image * p_save_named_image
* ============================================================================ * ============================================================================
*/ */
gint32 p_save_named_image(gint32 image_id, char *sav_name, GRunModeType run_mode) gint32 p_save_named_image(gint32 image_id, char *sav_name, GimpRunModeType run_mode)
{ {
GDrawable *l_drawable; GimpDrawable *l_drawable;
gint l_nlayers; gint l_nlayers;
gint32 *l_layers_list; gint32 *l_layers_list;
GParam *l_params; GimpParam *l_params;
gint l_retvals; gint l_retvals;
if(gap_debug) fprintf(stderr, "DEBUG: before p_save_named_image: '%s'\n", sav_name); if(gap_debug) fprintf(stderr, "DEBUG: before p_save_named_image: '%s'\n", sav_name);
@ -1077,12 +1077,12 @@ gint32 p_save_named_image(gint32 image_id, char *sav_name, GRunModeType run_mode
l_params = gimp_run_procedure ("gimp_file_save", l_params = gimp_run_procedure ("gimp_file_save",
&l_retvals, &l_retvals,
PARAM_INT32, run_mode, GIMP_PDB_INT32, run_mode,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_DRAWABLE, l_drawable->id, GIMP_PDB_DRAWABLE, l_drawable->id,
PARAM_STRING, sav_name, GIMP_PDB_STRING, sav_name,
PARAM_STRING, sav_name, /* raw name ? */ GIMP_PDB_STRING, sav_name, /* raw name ? */
PARAM_END); GIMP_PDB_END);
if(gap_debug) fprintf(stderr, "DEBUG: after p_save_named_image: '%s' nlayers=%d image=%d drw=%d run_mode=%d\n", sav_name, (int)l_nlayers, (int)image_id, (int)l_drawable->id, (int)run_mode); if(gap_debug) fprintf(stderr, "DEBUG: after p_save_named_image: '%s' nlayers=%d image=%d drw=%d run_mode=%d\n", sav_name, (int)l_nlayers, (int)image_id, (int)l_drawable->id, (int)run_mode);
@ -1118,7 +1118,7 @@ gint32 p_save_named_image(gint32 image_id, char *sav_name, GRunModeType run_mode
*/ */
int p_save_named_frame(gint32 image_id, char *sav_name) int p_save_named_frame(gint32 image_id, char *sav_name)
{ {
GParam* l_params; GimpParam* l_params;
char *l_ext; char *l_ext;
char *l_tmpname; char *l_tmpname;
gint l_retvals; gint l_retvals;
@ -1159,9 +1159,9 @@ int p_save_named_frame(gint32 image_id, char *sav_name)
/* FILE exists: let gimp find another temp name */ /* FILE exists: let gimp find another temp name */
l_params = gimp_run_procedure ("gimp_temp_name", l_params = gimp_run_procedure ("gimp_temp_name",
&l_retvals, &l_retvals,
PARAM_STRING, GIMP_PDB_STRING,
&l_ext[1], &l_ext[1],
PARAM_END); GIMP_PDB_END);
if(l_params[1].data.d_string != NULL) if(l_params[1].data.d_string != NULL)
{ {
@ -1194,12 +1194,12 @@ int p_save_named_frame(gint32 image_id, char *sav_name)
*/ */
l_params = gimp_run_procedure ("gimp_xcf_save", l_params = gimp_run_procedure ("gimp_xcf_save",
&l_retvals, &l_retvals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_DRAWABLE, 0, GIMP_PDB_DRAWABLE, 0,
PARAM_STRING, l_tmpname, GIMP_PDB_STRING, l_tmpname,
PARAM_STRING, l_tmpname, /* raw name ? */ GIMP_PDB_STRING, l_tmpname, /* raw name ? */
PARAM_END); GIMP_PDB_END);
if(gap_debug) fprintf(stderr, "DEBUG: after xcf p_save_named_frame: '%s'\n", l_tmpname); if(gap_debug) fprintf(stderr, "DEBUG: after xcf p_save_named_frame: '%s'\n", l_tmpname);
if (l_params[0].data.d_status != FALSE) if (l_params[0].data.d_status != FALSE)
@ -1301,7 +1301,7 @@ int p_save_old_frame(t_anim_info *ainfo_ptr)
*/ */
gint32 p_load_image (char *lod_name) gint32 p_load_image (char *lod_name)
{ {
GParam* l_params; GimpParam* l_params;
char *l_ext; char *l_ext;
char *l_tmpname; char *l_tmpname;
gint l_retvals; gint l_retvals;
@ -1320,9 +1320,9 @@ gint32 p_load_image (char *lod_name)
/* find a temp name */ /* find a temp name */
l_params = gimp_run_procedure ("gimp_temp_name", l_params = gimp_run_procedure ("gimp_temp_name",
&l_retvals, &l_retvals,
PARAM_STRING, GIMP_PDB_STRING,
&l_ext[1], /* extension */ &l_ext[1], /* extension */
PARAM_END); GIMP_PDB_END);
if(l_params[1].data.d_string != NULL) if(l_params[1].data.d_string != NULL)
{ {
@ -1346,10 +1346,10 @@ gint32 p_load_image (char *lod_name)
l_params = gimp_run_procedure ("gimp_file_load", /* "gimp_xcf_load" */ l_params = gimp_run_procedure ("gimp_file_load", /* "gimp_xcf_load" */
&l_retvals, &l_retvals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_STRING, l_tmpname, GIMP_PDB_STRING, l_tmpname,
PARAM_STRING, l_tmpname, /* raw name ? */ GIMP_PDB_STRING, l_tmpname, /* raw name ? */
PARAM_END); GIMP_PDB_END);
l_tmp_image_id = l_params[1].data.d_int32; l_tmp_image_id = l_params[1].data.d_int32;
@ -1597,7 +1597,7 @@ int p_dup(t_anim_info *ainfo_ptr, long cnt, long range_from, long range_to)
l_percentage = 0.0; l_percentage = 0.0;
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
gimp_progress_init( _("Duplicating frames...")); gimp_progress_init( _("Duplicating frames..."));
} }
@ -1622,7 +1622,7 @@ int p_dup(t_anim_info *ainfo_ptr, long cnt, long range_from, long range_to)
l_percentage_step = 1.0 / ((1.0 + l_hi) - l_src_nr_max); l_percentage_step = 1.0 / ((1.0 + l_hi) - l_src_nr_max);
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -1640,7 +1640,7 @@ int p_dup(t_anim_info *ainfo_ptr, long cnt, long range_from, long range_to)
g_free(l_dup_name); g_free(l_dup_name);
g_free(l_curr_name); g_free(l_curr_name);
} }
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -1773,7 +1773,7 @@ p_shift(t_anim_info *ainfo_ptr, long cnt, long range_from, long range_to)
g_free(l_curr_name); g_free(l_curr_name);
l_percentage = 0.0; l_percentage = 0.0;
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
gimp_progress_init( _("Renumber Framesequence...")); gimp_progress_init( _("Renumber Framesequence..."));
} }
@ -1792,7 +1792,7 @@ p_shift(t_anim_info *ainfo_ptr, long cnt, long range_from, long range_to)
g_free(tmp_errtxt); g_free(tmp_errtxt);
return -1; return -1;
} }
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -1814,7 +1814,7 @@ p_shift(t_anim_info *ainfo_ptr, long cnt, long range_from, long range_to)
g_free(tmp_errtxt); g_free(tmp_errtxt);
return -1; return -1;
} }
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -1848,7 +1848,7 @@ p_shift(t_anim_info *ainfo_ptr, long cnt, long range_from, long range_to)
* and load it from the next/prev anim Frame on disk. * and load it from the next/prev anim Frame on disk.
* ============================================================================ * ============================================================================
*/ */
int gap_next(GRunModeType run_mode, gint32 image_id) int gap_next(GimpRunModeType run_mode, gint32 image_id)
{ {
int rc; int rc;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
@ -1866,7 +1866,7 @@ int gap_next(GRunModeType run_mode, gint32 image_id)
return(rc); return(rc);
} /* end gap_next */ } /* end gap_next */
int gap_prev(GRunModeType run_mode, gint32 image_id) int gap_prev(GimpRunModeType run_mode, gint32 image_id)
{ {
int rc; int rc;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
@ -1892,7 +1892,7 @@ int gap_prev(GRunModeType run_mode, gint32 image_id)
* ============================================================================ * ============================================================================
*/ */
int gap_first(GRunModeType run_mode, gint32 image_id) int gap_first(GimpRunModeType run_mode, gint32 image_id)
{ {
int rc; int rc;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
@ -1912,7 +1912,7 @@ int gap_first(GRunModeType run_mode, gint32 image_id)
return(rc); return(rc);
} /* end gap_first */ } /* end gap_first */
int gap_last(GRunModeType run_mode, gint32 image_id) int gap_last(GimpRunModeType run_mode, gint32 image_id)
{ {
int rc; int rc;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
@ -1937,12 +1937,12 @@ int gap_last(GRunModeType run_mode, gint32 image_id)
* *
* store the current Gimp Image to disk * store the current Gimp Image to disk
* and load it from the anim Frame on disk that has the specified frame Nr. * and load it from the anim Frame on disk that has the specified frame Nr.
* RUN_INTERACTIVE: * GIMP_RUN_INTERACTIVE:
* show dialogwindow where user can enter the destination frame Nr. * show dialogwindow where user can enter the destination frame Nr.
* ============================================================================ * ============================================================================
*/ */
int gap_goto(GRunModeType run_mode, gint32 image_id, int nr) int gap_goto(GimpRunModeType run_mode, gint32 image_id, int nr)
{ {
int rc; int rc;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
@ -1959,7 +1959,7 @@ int gap_goto(GRunModeType run_mode, gint32 image_id, int nr)
{ {
if(0 != p_chk_framerange(ainfo_ptr)) return -1; if(0 != p_chk_framerange(ainfo_ptr)) return -1;
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_title = g_strdup_printf (_("Goto Frame (%ld/%ld)") l_title = g_strdup_printf (_("Goto Frame (%ld/%ld)")
, ainfo_ptr->curr_frame_nr , ainfo_ptr->curr_frame_nr
@ -2009,7 +2009,7 @@ int gap_goto(GRunModeType run_mode, gint32 image_id, int nr)
* gap_del * gap_del
* ============================================================================ * ============================================================================
*/ */
int gap_del(GRunModeType run_mode, gint32 image_id, int nr) int gap_del(GimpRunModeType run_mode, gint32 image_id, int nr)
{ {
int rc; int rc;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
@ -2027,7 +2027,7 @@ int gap_del(GRunModeType run_mode, gint32 image_id, int nr)
{ {
if(0 != p_chk_framerange(ainfo_ptr)) return -1; if(0 != p_chk_framerange(ainfo_ptr)) return -1;
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_title = g_strdup_printf (_("Delete Frames (%ld/%ld)") l_title = g_strdup_printf (_("Delete Frames (%ld/%ld)")
, ainfo_ptr->curr_frame_nr , ainfo_ptr->curr_frame_nr
@ -2146,7 +2146,7 @@ int p_dup_dialog(t_anim_info *ainfo_ptr, long *range_from, long *range_to)
* gap_dup * gap_dup
* ============================================================================ * ============================================================================
*/ */
int gap_dup(GRunModeType run_mode, gint32 image_id, int nr, int gap_dup(GimpRunModeType run_mode, gint32 image_id, int nr,
long range_from, long range_to) long range_from, long range_to)
{ {
int rc; int rc;
@ -2160,7 +2160,7 @@ int gap_dup(GRunModeType run_mode, gint32 image_id, int nr,
{ {
if (0 == p_dir_ainfo(ainfo_ptr)) if (0 == p_dir_ainfo(ainfo_ptr))
{ {
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
if(0 != p_chk_framechange(ainfo_ptr)) { l_cnt = -1; } if(0 != p_chk_framechange(ainfo_ptr)) { l_cnt = -1; }
else { l_cnt = p_dup_dialog(ainfo_ptr, &l_from, &l_to); } else { l_cnt = p_dup_dialog(ainfo_ptr, &l_from, &l_to); }
@ -2200,7 +2200,7 @@ int gap_dup(GRunModeType run_mode, gint32 image_id, int nr,
* ============================================================================ * ============================================================================
*/ */
int gap_exchg(GRunModeType run_mode, gint32 image_id, int nr) int gap_exchg(GimpRunModeType run_mode, gint32 image_id, int nr)
{ {
int rc; int rc;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
@ -2218,7 +2218,7 @@ int gap_exchg(GRunModeType run_mode, gint32 image_id, int nr)
{ {
if(0 != p_chk_framerange(ainfo_ptr)) return -1; if(0 != p_chk_framerange(ainfo_ptr)) return -1;
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
if(ainfo_ptr->curr_frame_nr < ainfo_ptr->last_frame_nr) if(ainfo_ptr->curr_frame_nr < ainfo_ptr->last_frame_nr)
{ {
@ -2323,7 +2323,7 @@ int p_shift_dialog(t_anim_info *ainfo_ptr, long *range_from, long *range_to)
* gap_shift * gap_shift
* ============================================================================ * ============================================================================
*/ */
int gap_shift(GRunModeType run_mode, gint32 image_id, int nr, int gap_shift(GimpRunModeType run_mode, gint32 image_id, int nr,
long range_from, long range_to) long range_from, long range_to)
{ {
int rc; int rc;
@ -2337,7 +2337,7 @@ int gap_shift(GRunModeType run_mode, gint32 image_id, int nr,
{ {
if (0 == p_dir_ainfo(ainfo_ptr)) if (0 == p_dir_ainfo(ainfo_ptr))
{ {
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_cnt = 1; l_cnt = 1;
if(0 != p_chk_framechange(ainfo_ptr)) { l_cnt = 0; } if(0 != p_chk_framechange(ainfo_ptr)) { l_cnt = 0; }
@ -2515,7 +2515,7 @@ p_vid_edit_framecount()
* ============================================================================ * ============================================================================
*/ */
gint gint
gap_vid_edit_copy(GRunModeType run_mode, gint32 image_id, long range_from, long range_to) gap_vid_edit_copy(GimpRunModeType run_mode, gint32 image_id, long range_from, long range_to)
{ {
int rc; int rc;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
@ -2620,7 +2620,7 @@ static gint p_custom_palette_file(char *filename, guchar *rgb, gint count)
* ============================================================================ * ============================================================================
*/ */
gint gint
gap_vid_edit_paste(GRunModeType run_mode, gint32 image_id, long paste_mode) gap_vid_edit_paste(GimpRunModeType run_mode, gint32 image_id, long paste_mode)
{ {
#define CUSTOM_PALETTE_NAME "gap_cmap" #define CUSTOM_PALETTE_NAME "gap_cmap"
int rc; int rc;
@ -2637,9 +2637,9 @@ gap_vid_edit_paste(GRunModeType run_mode, gint32 image_id, long paste_mode)
gint32 l_insert_frame_nr; gint32 l_insert_frame_nr;
gint32 l_tmp_image_id; gint32 l_tmp_image_id;
gint l_rc; gint l_rc;
GParam *l_params; GimpParam *l_params;
gint l_retvals; gint l_retvals;
GImageType l_orig_basetype; GimpImageBaseType l_orig_basetype;
l_cnt2 = p_vid_edit_framecount(); l_cnt2 = p_vid_edit_framecount();
if(gap_debug) if(gap_debug)
@ -2723,7 +2723,7 @@ gap_vid_edit_paste(GRunModeType run_mode, gint32 image_id, long paste_mode)
if((gimp_image_width(l_tmp_image_id) != gimp_image_width(image_id)) if((gimp_image_width(l_tmp_image_id) != gimp_image_width(image_id))
|| (gimp_image_height(l_tmp_image_id) != gimp_image_height(image_id))) || (gimp_image_height(l_tmp_image_id) != gimp_image_height(image_id)))
{ {
GParam *l_params; GimpParam *l_params;
gint l_retvals; gint l_retvals;
gint32 l_size_x, l_size_y; gint32 l_size_x, l_size_y;
@ -2733,10 +2733,10 @@ gap_vid_edit_paste(GRunModeType run_mode, gint32 image_id, long paste_mode)
l_params = gimp_run_procedure ("gimp_image_scale", l_params = gimp_run_procedure ("gimp_image_scale",
&l_retvals, &l_retvals,
PARAM_IMAGE, l_tmp_image_id, GIMP_PDB_IMAGE, l_tmp_image_id,
PARAM_INT32, l_size_x, GIMP_PDB_INT32, l_size_x,
PARAM_INT32, l_size_y, GIMP_PDB_INT32, l_size_y,
PARAM_END); GIMP_PDB_END);
} }
@ -2753,14 +2753,14 @@ gap_vid_edit_paste(GRunModeType run_mode, gint32 image_id, long paste_mode)
gint l_ncolors; gint l_ncolors;
/* convert tmp image to dest type */ /* convert tmp image to dest type */
case INDEXED: case GIMP_INDEXED:
l_cmap = gimp_image_get_cmap(image_id, &l_ncolors); l_cmap = gimp_image_get_cmap(image_id, &l_ncolors);
if(gap_debug) printf("DEBUG: convert to INDEXED %d colors\n", (int)l_ncolors); if(gap_debug) printf("DEBUG: convert to INDEXED %d colors\n", (int)l_ncolors);
l_params = gimp_run_procedure ("gimp_gimprc_query", l_params = gimp_run_procedure ("gimp_gimprc_query",
&l_retvals, &l_retvals,
PARAM_STRING, "gimp_dir", GIMP_PDB_STRING, "gimp_dir",
PARAM_END); GIMP_PDB_END);
l_gimp_dir = g_strdup(l_params[1].data.d_string); l_gimp_dir = g_strdup(l_params[1].data.d_string);
gimp_destroy_params(l_params, l_retvals); gimp_destroy_params(l_params, l_retvals);
@ -2776,19 +2776,19 @@ gap_vid_edit_paste(GRunModeType run_mode, gint32 image_id, long paste_mode)
{ {
l_params = gimp_run_procedure ("gimp_palette_refresh", l_params = gimp_run_procedure ("gimp_palette_refresh",
&l_retvals, &l_retvals,
PARAM_END); GIMP_PDB_END);
gimp_destroy_params(l_params, l_retvals); gimp_destroy_params(l_params, l_retvals);
l_params = gimp_run_procedure ("gimp_convert_indexed", l_params = gimp_run_procedure ("gimp_convert_indexed",
&l_retvals, &l_retvals,
PARAM_IMAGE, l_tmp_image_id, GIMP_PDB_IMAGE, l_tmp_image_id,
PARAM_INT32, 1, /* dither value 1== floyd-steinberg */ GIMP_PDB_INT32, 1, /* dither value 1== floyd-steinberg */
PARAM_INT32, 4, /* palette_type 4 == CUSTOM_PALETTE */ GIMP_PDB_INT32, 4, /* palette_type 4 == CUSTOM_PALETTE */
PARAM_INT32, l_ncolors, /* number of colors */ GIMP_PDB_INT32, l_ncolors, /* number of colors */
PARAM_INT32, 0, /* alpha_dither */ GIMP_PDB_INT32, 0, /* alpha_dither */
PARAM_INT32, 0, /* remove_unused */ GIMP_PDB_INT32, 0, /* remove_unused */
PARAM_STRING, CUSTOM_PALETTE_NAME, /* name of the custom palette */ GIMP_PDB_STRING, CUSTOM_PALETTE_NAME, /* name of the custom palette */
PARAM_END); GIMP_PDB_END);
gimp_destroy_params(l_params, l_retvals); gimp_destroy_params(l_params, l_retvals);
} }
else else
@ -2799,22 +2799,25 @@ gap_vid_edit_paste(GRunModeType run_mode, gint32 image_id, long paste_mode)
g_free(l_palette_filename); g_free(l_palette_filename);
g_free(l_gimp_dir); g_free(l_gimp_dir);
break; break;
case GRAY:
case GIMP_GRAY:
if(gap_debug) printf("DEBUG: convert to GRAY'\n"); if(gap_debug) printf("DEBUG: convert to GRAY'\n");
l_params = gimp_run_procedure ("gimp_convert_grayscale", l_params = gimp_run_procedure ("gimp_convert_grayscale",
&l_retvals, &l_retvals,
PARAM_IMAGE, l_tmp_image_id, GIMP_PDB_IMAGE, l_tmp_image_id,
PARAM_END); GIMP_PDB_END);
gimp_destroy_params(l_params, l_retvals); gimp_destroy_params(l_params, l_retvals);
break; break;
case RGB:
case GIMP_RGB:
if(gap_debug) printf("DEBUG: convert to RGB'\n"); if(gap_debug) printf("DEBUG: convert to RGB'\n");
l_params = gimp_run_procedure ("gimp_convert_rgb", l_params = gimp_run_procedure ("gimp_convert_rgb",
&l_retvals, &l_retvals,
PARAM_IMAGE, l_tmp_image_id, GIMP_PDB_IMAGE, l_tmp_image_id,
PARAM_END); GIMP_PDB_END);
gimp_destroy_params(l_params, l_retvals); gimp_destroy_params(l_params, l_retvals);
break; break;
default: default:
printf( "DEBUG: unknown image type\n"); printf( "DEBUG: unknown image type\n");
return -1; return -1;

30
plug-ins/gap/gap_lib.h
View File

@ -69,7 +69,7 @@ typedef struct t_anim_info {
char *extension; char *extension;
char *new_filename; char *new_filename;
char *old_filename; char *old_filename;
GRunModeType run_mode; GimpRunModeType run_mode;
long width; long width;
long height; long height;
long type; long type;
@ -85,7 +85,7 @@ int p_file_copy(char *fname, char *fname_copy);
void p_free_ainfo(t_anim_info **ainfo); void p_free_ainfo(t_anim_info **ainfo);
char* p_alloc_basename(char *imagename, long *number); char* p_alloc_basename(char *imagename, long *number);
char* p_alloc_extension(char *imagename); char* p_alloc_extension(char *imagename);
t_anim_info* p_alloc_ainfo(gint32 image_id, GRunModeType run_mode); t_anim_info* p_alloc_ainfo(gint32 image_id, GimpRunModeType run_mode);
int p_dir_ainfo(t_anim_info *ainfo_ptr); int p_dir_ainfo(t_anim_info *ainfo_ptr);
int p_chk_framerange(t_anim_info *ainfo_ptr); int p_chk_framerange(t_anim_info *ainfo_ptr);
int p_chk_framechange(t_anim_info *ainfo_ptr); int p_chk_framechange(t_anim_info *ainfo_ptr);
@ -93,7 +93,7 @@ int p_chk_framechange(t_anim_info *ainfo_ptr);
int p_save_named_frame (gint32 image_id, char *sav_name); int p_save_named_frame (gint32 image_id, char *sav_name);
int p_load_named_frame (gint32 image_id, char *lod_name); int p_load_named_frame (gint32 image_id, char *lod_name);
gint32 p_load_image (char *lod_name); gint32 p_load_image (char *lod_name);
gint32 p_save_named_image(gint32 image_id, char *sav_name, GRunModeType run_mode); gint32 p_save_named_image(gint32 image_id, char *sav_name, GimpRunModeType run_mode);
char* p_alloc_fname(char *basename, long nr, char *extension); char* p_alloc_fname(char *basename, long nr, char *extension);
char* p_gzip (char *orig_name, char *new_name, char *zip); char* p_gzip (char *orig_name, char *new_name, char *zip);
char* p_strdup_add_underscore(char *name); char* p_strdup_add_underscore(char *name);
@ -106,23 +106,23 @@ int p_image_file_copy(char *fname, char *fname_copy);
/* animation menu fuctions provided by gap_lib.c */ /* animation menu fuctions provided by gap_lib.c */
int gap_next(GRunModeType run_mode, gint32 image_id); int gap_next(GimpRunModeType run_mode, gint32 image_id);
int gap_prev(GRunModeType run_mode, gint32 image_id); int gap_prev(GimpRunModeType run_mode, gint32 image_id);
int gap_first(GRunModeType run_mode, gint32 image_id); int gap_first(GimpRunModeType run_mode, gint32 image_id);
int gap_last(GRunModeType run_mode, gint32 image_id); int gap_last(GimpRunModeType run_mode, gint32 image_id);
int gap_goto(GRunModeType run_mode, gint32 image_id, int nr); int gap_goto(GimpRunModeType run_mode, gint32 image_id, int nr);
int gap_dup(GRunModeType run_mode, gint32 image_id, int nr, long range_from, long range_to); int gap_dup(GimpRunModeType run_mode, gint32 image_id, int nr, long range_from, long range_to);
int gap_del(GRunModeType run_mode, gint32 image_id, int nr); int gap_del(GimpRunModeType run_mode, gint32 image_id, int nr);
int gap_exchg(GRunModeType run_mode, gint32 image_id, int nr); int gap_exchg(GimpRunModeType run_mode, gint32 image_id, int nr);
int gap_shift(GRunModeType run_mode, gint32 image_id, int nr, long range_from, long range_to); int gap_shift(GimpRunModeType run_mode, gint32 image_id, int nr, long range_from, long range_to);
void p_msg_win(GRunModeType run_mode, char *msg); void p_msg_win(GimpRunModeType run_mode, char *msg);
gchar *p_get_video_paste_name(void); gchar *p_get_video_paste_name(void);
gint32 p_vid_edit_clear(void); gint32 p_vid_edit_clear(void);
gint32 p_vid_edit_framecount(void); gint32 p_vid_edit_framecount(void);
gint gap_vid_edit_copy(GRunModeType run_mode, gint32 image_id, long range_from, long range_to); gint gap_vid_edit_copy(GimpRunModeType run_mode, gint32 image_id, long range_from, long range_to);
gint gap_vid_edit_paste(GRunModeType run_mode, gint32 image_id, long paste_mode); gint gap_vid_edit_paste(GimpRunModeType run_mode, gint32 image_id, long paste_mode);
#define VID_PASTE_REPLACE 0 #define VID_PASTE_REPLACE 0
#define VID_PASTE_INSERT_BEFORE 1 #define VID_PASTE_INSERT_BEFORE 1

494
plug-ins/gap/gap_main.c
View File

File diff suppressed because it is too large Load Diff

38
plug-ins/gap/gap_mod_layer.c
View File

@ -29,7 +29,7 @@
/* revision history: /* revision history:
* gimp 1.1.6; 1999/06/21 hof: bugix: wrong iterator total_steps and direction * gimp 1.1.6; 1999/06/21 hof: bugix: wrong iterator total_steps and direction
* gimp 1.1.15.1; 1999/05/08 hof: bugix (dont mix GDrawableType with GImageType) * gimp 1.1.15.1; 1999/05/08 hof: bugix (dont mix GimpImageType with GimpImageBaseType)
* version 0.98.00 1998.11.27 hof: - use new module gap_pdb_calls.h * version 0.98.00 1998.11.27 hof: - use new module gap_pdb_calls.h
* version 0.97.00 1998.10.19 hof: - created module * version 0.97.00 1998.10.19 hof: - created module
*/ */
@ -385,7 +385,7 @@ p_alloc_layli(gint32 image_id, gint32 *l_sel_cnt, gint *nlayers,
void p_prevent_empty_image(gint32 image_id) void p_prevent_empty_image(gint32 image_id)
{ {
GImageType l_type; GimpImageBaseType l_type;
guint l_width, l_height; guint l_width, l_height;
gint32 l_layer_id; gint32 l_layer_id;
gint l_nlayers; gint l_nlayers;
@ -407,7 +407,7 @@ void p_prevent_empty_image(gint32 image_id)
l_height = gimp_image_height(image_id); l_height = gimp_image_height(image_id);
l_type = gimp_image_base_type(image_id); l_type = gimp_image_base_type(image_id);
l_type = (l_type * 2); /* convert from GImageType to GDrawableType */ l_type = (l_type * 2); /* convert from GimpImageBaseType to GimpImageType */
/* add a transparent dummy layer */ /* add a transparent dummy layer */
l_layer_id = gimp_layer_new(image_id, "dummy", l_layer_id = gimp_layer_new(image_id, "dummy",
@ -593,7 +593,7 @@ p_apply_action(gint32 image_id,
l_rc = p_call_plugin(filter_procname, l_rc = p_call_plugin(filter_procname,
image_id, image_id,
l_layer_id, l_layer_id,
RUN_WITH_LAST_VALS); GIMP_RUN_WITH_LAST_VALS);
if(gap_debug) fprintf(stderr, "gap: p_apply_action FILTER:%s rc =%d\n", if(gap_debug) fprintf(stderr, "gap: p_apply_action FILTER:%s rc =%d\n",
filter_procname, (int)l_rc); filter_procname, (int)l_rc);
break; break;
@ -649,7 +649,7 @@ p_do_filter_dialogs(t_anim_info *ainfo_ptr,
static char l_key_from[512]; static char l_key_from[512];
static gint l_gtk_init = TRUE; /* gkt_init at 1.st call */ static gint l_gtk_init = TRUE; /* gkt_init at 1.st call */
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_gtk_init = FALSE; /* gtk_init was done in 1.st modify dialog before */ l_gtk_init = FALSE; /* gtk_init was done in 1.st modify dialog before */
} }
@ -704,7 +704,7 @@ p_do_filter_dialogs(t_anim_info *ainfo_ptr,
/* open a view for the 1.st handled frame */ /* open a view for the 1.st handled frame */
*dpy_id = gimp_display_new (image_id); *dpy_id = gimp_display_new (image_id);
l_rc = p_call_plugin(filter_procname, image_id, l_layer_id, RUN_INTERACTIVE); l_rc = p_call_plugin(filter_procname, image_id, l_layer_id, GIMP_RUN_INTERACTIVE);
/* OOPS: cant delete the display here, because /* OOPS: cant delete the display here, because
* closing the last display seems to free up * closing the last display seems to free up
@ -799,7 +799,7 @@ p_do_2nd_filter_dialogs(char *filter_procname,
l_idx = p_get_1st_selected(l_layli_ptr, l_nlayers); l_idx = p_get_1st_selected(l_layli_ptr, l_nlayers);
if(l_idx < 0) if(l_idx < 0)
{ {
p_msg_win (RUN_INTERACTIVE, _("GAP Modify: No layer selected in last handled frame")); p_msg_win (GIMP_RUN_INTERACTIVE, _("GAP Modify: No layer selected in last handled frame"));
goto cleanup; goto cleanup;
} }
l_layer_id = l_layli_ptr[l_idx].layer_id; l_layer_id = l_layli_ptr[l_idx].layer_id;
@ -809,7 +809,7 @@ p_do_2nd_filter_dialogs(char *filter_procname,
/* 2.nd INTERACTIV Filtercall dialog */ /* 2.nd INTERACTIV Filtercall dialog */
/* --------------------------------- */ /* --------------------------------- */
l_rc = p_call_plugin(filter_procname, l_last_image_id, l_layer_id, RUN_INTERACTIVE); l_rc = p_call_plugin(filter_procname, l_last_image_id, l_layer_id, GIMP_RUN_INTERACTIVE);
/* get values, then store with suffix "_ITER_TO" */ /* get values, then store with suffix "_ITER_TO" */
l_plugin_data_len = p_get_data(filter_procname); l_plugin_data_len = p_get_data(filter_procname);
@ -866,7 +866,7 @@ p_frames_modify(t_anim_info *ainfo_ptr,
gint32 l_sel_cnt; gint32 l_sel_cnt;
t_LayliElem *l_layli_ptr; t_LayliElem *l_layli_ptr;
GParam *l_params; GimpParam *l_params;
gint l_retvals; gint l_retvals;
gint l_plugin_data_len; gint l_plugin_data_len;
char l_filter_procname[256]; char l_filter_procname[256];
@ -883,7 +883,7 @@ p_frames_modify(t_anim_info *ainfo_ptr,
(int)action_mode, (int)sel_mode, (int)sel_case, (int)sel_invert, sel_pattern); (int)action_mode, (int)sel_mode, (int)sel_case, (int)sel_invert, sel_pattern);
l_percentage = 0.0; l_percentage = 0.0;
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
gimp_progress_init( _("Modifying Frames/Layer(s)...")); gimp_progress_init( _("Modifying Frames/Layer(s)..."));
} }
@ -966,7 +966,7 @@ p_frames_modify(t_anim_info *ainfo_ptr,
if(l_sel_cnt < 1) if(l_sel_cnt < 1)
{ {
p_msg_win(RUN_INTERACTIVE, _("No selected Layer in start frame")); p_msg_win(GIMP_RUN_INTERACTIVE, _("No selected Layer in start frame"));
goto error; goto error;
} }
@ -1076,11 +1076,11 @@ p_frames_modify(t_anim_info *ainfo_ptr,
l_plugin_iterator, (int)l_cur_frame_nr); l_plugin_iterator, (int)l_cur_frame_nr);
l_params = gimp_run_procedure (l_plugin_iterator, l_params = gimp_run_procedure (l_plugin_iterator,
&l_retvals, &l_retvals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_INT32, l_total_steps, /* total steps */ GIMP_PDB_INT32, l_total_steps, /* total steps */
PARAM_FLOAT, (gdouble)l_cur_step, /* current step */ GIMP_PDB_FLOAT, (gdouble)l_cur_step, /* current step */
PARAM_INT32, l_plugin_data_len, /* length of stored data struct */ GIMP_PDB_INT32, l_plugin_data_len, /* length of stored data struct */
PARAM_END); GIMP_PDB_END);
if (l_params[0].data.d_status == FALSE) if (l_params[0].data.d_status == FALSE)
{ {
fprintf(stderr, "ERROR: iterator %s failed\n", l_plugin_iterator); fprintf(stderr, "ERROR: iterator %s failed\n", l_plugin_iterator);
@ -1106,7 +1106,7 @@ p_frames_modify(t_anim_info *ainfo_ptr,
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -1144,7 +1144,7 @@ error:
* ============================================================================ * ============================================================================
*/ */
gint gap_mod_layer(GRunModeType run_mode, gint32 image_id, gint gap_mod_layer(GimpRunModeType run_mode, gint32 image_id,
gint32 range_from, gint32 range_to, gint32 range_from, gint32 range_to,
gint32 action_mode, gint32 sel_mode, gint32 action_mode, gint32 sel_mode,
gint32 sel_case, gint32 sel_invert, gint32 sel_case, gint32 sel_invert,
@ -1171,7 +1171,7 @@ gint gap_mod_layer(GRunModeType run_mode, gint32 image_id,
if (0 == p_dir_ainfo(ainfo_ptr)) if (0 == p_dir_ainfo(ainfo_ptr))
{ {
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_rc = p_layer_modify_dialog (ainfo_ptr, &l_from, &l_to, l_rc = p_layer_modify_dialog (ainfo_ptr, &l_from, &l_to,
&l_action_mode, &l_action_mode,

2
plug-ins/gap/gap_mod_layer.h
View File

@ -67,7 +67,7 @@ t_LayliElem *p_alloc_layli(gint32 image_id, gint32 *l_sel_cnt, gint *nlayers,
int p_get_1st_selected (t_LayliElem * layli_ptr, gint nlayers); int p_get_1st_selected (t_LayliElem * layli_ptr, gint nlayers);
void p_prevent_empty_image(gint32 image_id); void p_prevent_empty_image(gint32 image_id);
gint gap_mod_layer(GRunModeType run_mode, gint32 image_id, gint gap_mod_layer(GimpRunModeType run_mode, gint32 image_id,
gint32 range_from, gint32 range_to, gint32 range_from, gint32 range_to,
gint32 action_mode, gint32 sel_mode, gint32 action_mode, gint32 sel_mode,
gint32 sel_case, gint32 sel_invert, gint32 sel_case, gint32 sel_invert,

84
plug-ins/gap/gap_mov_dialog.c
View File

@ -114,11 +114,11 @@ typedef struct {
typedef struct typedef struct
{ {
GDrawable *drawable; GimpDrawable *drawable;
gint dwidth, dheight; gint dwidth, dheight;
gint bpp; gint bpp;
GtkWidget *preview; GtkWidget *preview;
GPixelRgn src_rgn; GimpPixelRgn src_rgn;
gint PixelRgnIsInitialized; gint PixelRgnIsInitialized;
gint show_path; gint show_path;
gint startup; gint startup;
@ -206,12 +206,12 @@ static void p_clear_point ();
static void p_load_points (char *filename); static void p_load_points (char *filename);
static void p_save_points (char *filename); static void p_save_points (char *filename);
static GDrawable * p_get_flattened_drawable (gint32 image_id); static GimpDrawable * p_get_flattened_drawable (gint32 image_id);
static GDrawable * p_get_prevw_drawable (t_mov_path_preview *path_ptr); static GimpDrawable * p_get_prevw_drawable (t_mov_path_preview *path_ptr);
static gint mov_dialog ( GDrawable *drawable, t_mov_path_preview *path_ptr, static gint mov_dialog ( GimpDrawable *drawable, t_mov_path_preview *path_ptr,
gint min, gint max); gint min, gint max);
static GtkWidget * mov_path_prevw_create ( GDrawable *drawable, static GtkWidget * mov_path_prevw_create ( GimpDrawable *drawable,
t_mov_path_preview *path_ptr); t_mov_path_preview *path_ptr);
static GtkWidget * mov_src_sel_create (); static GtkWidget * mov_src_sel_create ();
@ -261,20 +261,20 @@ static void mov_show_path_callback (GtkWidget *, gpointer);
/* the option menu items -- the paint modes */ /* the option menu items -- the paint modes */
static MenuItem option_paint_items[] = static MenuItem option_paint_items[] =
{ {
{ N_("Normal"), 0, 0, mov_paintmode_menu_callback, (gpointer) NORMAL_MODE, NULL, NULL }, { N_("Normal"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_NORMAL_MODE, NULL, NULL },
{ N_("Dissolve"), 0, 0, mov_paintmode_menu_callback, (gpointer) DISSOLVE_MODE, NULL, NULL }, { N_("Dissolve"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_DISSOLVE_MODE, NULL, NULL },
{ N_("Multiply"), 0, 0, mov_paintmode_menu_callback, (gpointer) MULTIPLY_MODE, NULL, NULL }, { N_("Multiply"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_MULTIPLY_MODE, NULL, NULL },
{ N_("Screen"), 0, 0, mov_paintmode_menu_callback, (gpointer) SCREEN_MODE, NULL, NULL }, { N_("Screen"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_SCREEN_MODE, NULL, NULL },
{ N_("Overlay"), 0, 0, mov_paintmode_menu_callback, (gpointer) OVERLAY_MODE, NULL, NULL }, { N_("Overlay"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_OVERLAY_MODE, NULL, NULL },
{ N_("Difference"), 0, 0, mov_paintmode_menu_callback, (gpointer) DIFFERENCE_MODE, NULL, NULL }, { N_("Difference"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_DIFFERENCE_MODE, NULL, NULL },
{ N_("Addition"), 0, 0, mov_paintmode_menu_callback, (gpointer) ADDITION_MODE, NULL, NULL }, { N_("Addition"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_ADDITION_MODE, NULL, NULL },
{ N_("Subtract"), 0, 0, mov_paintmode_menu_callback, (gpointer) SUBTRACT_MODE, NULL, NULL }, { N_("Subtract"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_SUBTRACT_MODE, NULL, NULL },
{ N_("Darken Only"), 0, 0, mov_paintmode_menu_callback, (gpointer) DARKEN_ONLY_MODE, NULL, NULL }, { N_("Darken Only"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_DARKEN_ONLY_MODE, NULL, NULL },
{ N_("Lighten Only"), 0, 0, mov_paintmode_menu_callback, (gpointer) LIGHTEN_ONLY_MODE, NULL, NULL }, { N_("Lighten Only"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_LIGHTEN_ONLY_MODE, NULL, NULL },
{ N_("Hue"), 0, 0, mov_paintmode_menu_callback, (gpointer) HUE_MODE, NULL, NULL }, { N_("Hue"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_HUE_MODE, NULL, NULL },
{ N_("Saturation"), 0, 0, mov_paintmode_menu_callback, (gpointer) SATURATION_MODE, NULL, NULL }, { N_("Saturation"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_SATURATION_MODE, NULL, NULL },
{ N_("Color"), 0, 0, mov_paintmode_menu_callback, (gpointer) COLOR_MODE, NULL, NULL }, { N_("Color"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_COLOR_MODE, NULL, NULL },
{ N_("Value"), 0, 0, mov_paintmode_menu_callback, (gpointer) VALUE_MODE, NULL, NULL }, { N_("Value"), 0, 0, mov_paintmode_menu_callback, (gpointer) GIMP_VALUE_MODE, NULL, NULL },
{ NULL, 0, 0, NULL, NULL, NULL, NULL } { NULL, 0, 0, NULL, NULL, NULL, NULL }
}; };
@ -324,7 +324,7 @@ OpsButtonModifier global_key_modifier = OPS_BUTTON_MODIFIER_NONE;
long p_move_dialog (t_mov_data *mov_ptr) long p_move_dialog (t_mov_data *mov_ptr)
{ {
GDrawable *l_drawable_ptr; GimpDrawable *l_drawable_ptr;
gint l_first, l_last; gint l_first, l_last;
char *l_str; char *l_str;
t_mov_path_preview *path_ptr; t_mov_path_preview *path_ptr;
@ -358,7 +358,7 @@ long p_move_dialog (t_mov_data *mov_ptr)
pvals->tmp_image_id = -1; pvals->tmp_image_id = -1;
pvals->src_image_id = -1; pvals->src_image_id = -1;
pvals->src_layer_id = -1; pvals->src_layer_id = -1;
pvals->src_paintmode = NORMAL_MODE; pvals->src_paintmode = GIMP_NORMAL_MODE;
pvals->src_handle = GAP_HANDLE_LEFT_TOP; pvals->src_handle = GAP_HANDLE_LEFT_TOP;
pvals->src_stepmode = GAP_STEP_LOOP; pvals->src_stepmode = GAP_STEP_LOOP;
pvals->src_force_visible = 0; pvals->src_force_visible = 0;
@ -421,7 +421,7 @@ long p_move_dialog (t_mov_data *mov_ptr)
*/ */
static gint static gint
mov_dialog ( GDrawable *drawable, t_mov_path_preview *path_ptr, mov_dialog ( GimpDrawable *drawable, t_mov_path_preview *path_ptr,
gint first_nr, gint last_nr ) gint first_nr, gint last_nr )
{ {
GtkWidget *vbox; GtkWidget *vbox;
@ -688,7 +688,7 @@ mov_ok_callback (GtkWidget *widget,
if(pvals->src_layer_id < 0) if(pvals->src_layer_id < 0)
{ {
p_msg_win(RUN_INTERACTIVE, p_msg_win(GIMP_RUN_INTERACTIVE,
_("No Source Image was selected\n" _("No Source Image was selected\n"
"(Please open a 2nd Image of the same type before opening Move Path)")); "(Please open a 2nd Image of the same type before opening Move Path)"));
return; return;
@ -781,7 +781,7 @@ mov_apv_callback (GtkWidget *widget,
t_video_info *vin_ptr; t_video_info *vin_ptr;
static gint apv_locked = FALSE; static gint apv_locked = FALSE;
gint32 l_new_image_id; gint32 l_new_image_id;
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
static t_arr_arg argv[ARGC_APV]; static t_arr_arg argv[ARGC_APV];
@ -900,17 +900,17 @@ mov_apv_callback (GtkWidget *widget,
l_new_image_id = p_mov_anim_preview(pvals, path_ptr->ainfo_ptr, path_ptr->preview_frame_nr); l_new_image_id = p_mov_anim_preview(pvals, path_ptr->ainfo_ptr, path_ptr->preview_frame_nr);
if(l_new_image_id < 0) if(l_new_image_id < 0)
{ {
p_msg_win(RUN_INTERACTIVE, p_msg_win(GIMP_RUN_INTERACTIVE,
_("Generate Animated Preview failed\n")); _("Generate Animated Preview failed\n"));
} }
else else
{ {
return_vals = gimp_run_procedure ("plug_in_animationplay", return_vals = gimp_run_procedure ("plug_in_animationplay",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, l_new_image_id, GIMP_PDB_IMAGE, l_new_image_id,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_END); GIMP_PDB_END);
} }
} }
@ -2044,7 +2044,7 @@ mov_src_sel_create()
*/ */
static GtkWidget * static GtkWidget *
mov_path_prevw_create ( GDrawable *drawable, t_mov_path_preview *path_ptr) mov_path_prevw_create ( GimpDrawable *drawable, t_mov_path_preview *path_ptr)
{ {
GtkWidget *frame; GtkWidget *frame;
GtkWidget *vbox; GtkWidget *vbox;
@ -2503,7 +2503,7 @@ mov_path_prevw_destroy ( GtkWidget *widget,
g_free( path_ptr ); g_free( path_ptr );
} }
static void render_preview ( GtkWidget *preview, GPixelRgn *srcrgn ); static void render_preview ( GtkWidget *preview, GimpPixelRgn *srcrgn );
/* ============================================================================ /* ============================================================================
* mov_path_prevw_preview_init * mov_path_prevw_preview_init
@ -2536,7 +2536,7 @@ mov_path_prevw_preview_init ( t_mov_path_preview *path_ptr )
#endif #endif
static void static void
render_preview ( GtkWidget *preview, GPixelRgn *srcrgn ) render_preview ( GtkWidget *preview, GimpPixelRgn *srcrgn )
{ {
guchar *src_row, *dest_row, *src, *dest; guchar *src_row, *dest_row, *src, *dest;
gint row, col; gint row, col;
@ -3050,11 +3050,11 @@ p_chk_keyframes(t_mov_path_preview *path_ptr)
* (only) remaining drawable. * (only) remaining drawable.
* ============================================================================ * ============================================================================
*/ */
GDrawable * GimpDrawable *
p_get_flattened_drawable(gint32 image_id) p_get_flattened_drawable(gint32 image_id)
{ {
GDrawable *l_drawable_ptr ; GimpDrawable *l_drawable_ptr ;
GImageType l_type; GimpImageBaseType l_type;
guint l_width, l_height; guint l_width, l_height;
gint32 l_layer_id; gint32 l_layer_id;
@ -3063,7 +3063,7 @@ p_get_flattened_drawable(gint32 image_id)
l_height = gimp_image_height(image_id); l_height = gimp_image_height(image_id);
l_type = gimp_image_base_type(image_id); l_type = gimp_image_base_type(image_id);
l_type = (l_type * 2); /* convert from GImageType to GDrawableType */ l_type = (l_type * 2); /* convert from GimpImageBaseType to GimpImageType */
/* add 2 full transparent dummy layers at top /* add 2 full transparent dummy layers at top
* (because gimp_image_merge_visible_layers complains * (because gimp_image_merge_visible_layers complains
@ -3095,7 +3095,7 @@ p_get_flattened_drawable(gint32 image_id)
* ============================================================================ * ============================================================================
*/ */
GDrawable * GimpDrawable *
p_get_prevw_drawable (t_mov_path_preview *path_ptr) p_get_prevw_drawable (t_mov_path_preview *path_ptr)
{ {
t_mov_current l_curr; t_mov_current l_curr;
@ -3287,8 +3287,8 @@ p_mov_render(gint32 image_id, t_mov_values *val_ptr, t_mov_current *cur_ptr)
} }
l_resized_flag = 0; l_resized_flag = 0;
l_orig_width = gimp_layer_width(l_cp_layer_id); l_orig_width = gimp_drawable_width(l_cp_layer_id);
l_orig_height = gimp_layer_height(l_cp_layer_id); l_orig_height = gimp_drawable_height(l_cp_layer_id);
l_new_width = l_orig_width; l_new_width = l_orig_width;
l_new_height = l_orig_height; l_new_height = l_orig_height;
@ -3313,8 +3313,8 @@ p_mov_render(gint32 image_id, t_mov_values *val_ptr, t_mov_current *cur_ptr)
p_gimp_rotate(l_cp_layer_id, l_interpolation, cur_ptr->currRotation); p_gimp_rotate(l_cp_layer_id, l_interpolation, cur_ptr->currRotation);
l_new_width = gimp_layer_width(l_cp_layer_id); l_new_width = gimp_drawable_width(l_cp_layer_id);
l_new_height = gimp_layer_height(l_cp_layer_id); l_new_height = gimp_drawable_height(l_cp_layer_id);
} }
if(l_resized_flag == 1) if(l_resized_flag == 1)

2
plug-ins/gap/gap_mov_dialog.h
View File

@ -117,7 +117,7 @@ typedef struct {
gint dst_range_start; /* use current frame as default */ gint dst_range_start; /* use current frame as default */
gint dst_range_end; gint dst_range_end;
gint dst_layerstack; gint dst_layerstack;
gint dst_combination_mode; /* GLayerMode */ gint dst_combination_mode; /* GimpLayerModeEffects */
/* for dialog only */ /* for dialog only */
gint32 dst_image_id; /* frame image */ gint32 dst_image_id; /* frame image */

38
plug-ins/gap/gap_mov_exec.c
View File

@ -129,7 +129,7 @@ p_mov_call_render(t_mov_data *mov_ptr, t_mov_current *cur_ptr, gint apv_layersta
if((mov_ptr->val_ptr->apv_scalex != 100.0) || (mov_ptr->val_ptr->apv_scaley != 100.0)) if((mov_ptr->val_ptr->apv_scalex != 100.0) || (mov_ptr->val_ptr->apv_scaley != 100.0))
{ {
GParam *l_params; GimpParam *l_params;
gint l_retvals; gint l_retvals;
gint32 l_size_x, l_size_y; gint32 l_size_x, l_size_y;
@ -138,10 +138,10 @@ p_mov_call_render(t_mov_data *mov_ptr, t_mov_current *cur_ptr, gint apv_layersta
l_params = gimp_run_procedure ("gimp_image_scale", l_params = gimp_run_procedure ("gimp_image_scale",
&l_retvals, &l_retvals,
PARAM_IMAGE, l_tmp_image_id, GIMP_PDB_IMAGE, l_tmp_image_id,
PARAM_INT32, l_size_x, GIMP_PDB_INT32, l_size_x,
PARAM_INT32, l_size_y, GIMP_PDB_INT32, l_size_y,
PARAM_END); GIMP_PDB_END);
} }
} }
@ -343,7 +343,7 @@ p_mov_execute(t_mov_data *mov_ptr)
l_apv_layerstack = 0; l_apv_layerstack = 0;
l_percentage = 0.0; l_percentage = 0.0;
if(mov_ptr->dst_ainfo_ptr->run_mode == RUN_INTERACTIVE) if(mov_ptr->dst_ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
if(mov_ptr->val_ptr->apv_mlayer_image < 0) if(mov_ptr->val_ptr->apv_mlayer_image < 0)
{ {
@ -568,7 +568,7 @@ p_mov_execute(t_mov_data *mov_ptr)
l_rc = p_mov_call_render(mov_ptr, cur_ptr, l_apv_layerstack); l_rc = p_mov_call_render(mov_ptr, cur_ptr, l_apv_layerstack);
/* show progress */ /* show progress */
if(mov_ptr->dst_ainfo_ptr->run_mode == RUN_INTERACTIVE) if(mov_ptr->dst_ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage = (gdouble)l_fridx / (gdouble)(l_cnt -1); l_percentage = (gdouble)l_fridx / (gdouble)(l_cnt -1);
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -599,9 +599,9 @@ p_mov_anim_preview(t_mov_values *pvals_orig, t_anim_info *ainfo_ptr, gint previe
gint32 l_tmp_image_id; gint32 l_tmp_image_id;
gint32 l_tmp_frame_id; gint32 l_tmp_frame_id;
gint32 l_mlayer_image_id; gint32 l_mlayer_image_id;
GParam *l_params; GimpParam *l_params;
gint l_retvals; gint l_retvals;
GImageType l_type; GimpImageBaseType l_type;
guint l_width, l_height; guint l_width, l_height;
gint32 l_stackpos; gint32 l_stackpos;
gint l_nlayers; gint l_nlayers;
@ -638,10 +638,10 @@ p_mov_anim_preview(t_mov_values *pvals_orig, t_anim_info *ainfo_ptr, gint previe
l_size_y = MAX(1, (gimp_image_height(l_tmp_image_id) * l_pvals->apv_scaley) / 100); l_size_y = MAX(1, (gimp_image_height(l_tmp_image_id) * l_pvals->apv_scaley) / 100);
l_params = gimp_run_procedure ("gimp_image_scale", l_params = gimp_run_procedure ("gimp_image_scale",
&l_retvals, &l_retvals,
PARAM_IMAGE, l_tmp_image_id, GIMP_PDB_IMAGE, l_tmp_image_id,
PARAM_INT32, l_size_x, GIMP_PDB_INT32, l_size_x,
PARAM_INT32, l_size_y, GIMP_PDB_INT32, l_size_y,
PARAM_END); GIMP_PDB_END);
/* findout the src_layer id in the scaled copy by stackpos index */ /* findout the src_layer id in the scaled copy by stackpos index */
l_pvals->src_layer_id = -1; l_pvals->src_layer_id = -1;
@ -732,10 +732,10 @@ p_mov_anim_preview(t_mov_values *pvals_orig, t_anim_info *ainfo_ptr, gint previe
l_size_y = (gimp_image_height(l_tmp_frame_id) * l_pvals->apv_scaley) / 100; l_size_y = (gimp_image_height(l_tmp_frame_id) * l_pvals->apv_scaley) / 100;
l_params = gimp_run_procedure ("gimp_image_scale", l_params = gimp_run_procedure ("gimp_image_scale",
&l_retvals, &l_retvals,
PARAM_IMAGE, l_tmp_frame_id, GIMP_PDB_IMAGE, l_tmp_frame_id,
PARAM_INT32, l_size_x, GIMP_PDB_INT32, l_size_x,
PARAM_INT32, l_size_y, GIMP_PDB_INT32, l_size_y,
PARAM_END); GIMP_PDB_END);
} }
g_free(l_filename); g_free(l_filename);
break; break;
@ -783,7 +783,7 @@ p_mov_anim_preview(t_mov_values *pvals_orig, t_anim_info *ainfo_ptr, gint previe
* gap_move * gap_move
* ============================================================================ * ============================================================================
*/ */
int gap_move(GRunModeType run_mode, gint32 image_id) int gap_move(GimpRunModeType run_mode, gint32 image_id)
{ {
int l_rc; int l_rc;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
@ -801,7 +801,7 @@ int gap_move(GRunModeType run_mode, gint32 image_id)
if(0 != p_chk_framerange(ainfo_ptr)) return -1; if(0 != p_chk_framerange(ainfo_ptr)) return -1;
l_mov_data.dst_ainfo_ptr = ainfo_ptr; l_mov_data.dst_ainfo_ptr = ainfo_ptr;
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_rc = p_move_dialog (&l_mov_data); l_rc = p_move_dialog (&l_mov_data);
if(0 != p_chk_framechange(ainfo_ptr)) if(0 != p_chk_framechange(ainfo_ptr))

2
plug-ins/gap/gap_mov_exec.h
View File

@ -38,7 +38,7 @@
#include "libgimp/gimp.h" #include "libgimp/gimp.h"
#include "gap_mov_dialog.h" #include "gap_mov_dialog.h"
int gap_move(GRunModeType run_mode, gint32 image_id); int gap_move(GimpRunModeType run_mode, gint32 image_id);
gint32 p_mov_anim_preview(t_mov_values *pvals_orig, t_anim_info *ainfo_ptr, gint preview_frame_nr); gint32 p_mov_anim_preview(t_mov_values *pvals_orig, t_anim_info *ainfo_ptr, gint preview_frame_nr);
#endif #endif

4
plug-ins/gap/gap_mpege.c
View File

@ -935,7 +935,7 @@ int p_mpege_gen_parfile(t_anim_info *ainfo_ptr, t_mpg_par *mp_ptr, t_gap_mpeg_en
* ============================================================================ * ============================================================================
*/ */
int gap_mpeg_encode(GRunModeType run_mode, int gap_mpeg_encode(GimpRunModeType run_mode,
gint32 image_id, gint32 image_id,
t_gap_mpeg_encoder encoder t_gap_mpeg_encoder encoder
) )
@ -1000,7 +1000,7 @@ int gap_mpeg_encode(GRunModeType run_mode,
if(l_rc == 0) if(l_rc == 0)
{ {
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_genmode = p_mpege_dialog(ainfo_ptr, &mp_par, encoder); l_genmode = p_mpege_dialog(ainfo_ptr, &mp_par, encoder);
if(l_genmode < 0) l_rc = -1; if(l_genmode < 0) l_rc = -1;

2
plug-ins/gap/gap_mpege.h
View File

@ -40,7 +40,7 @@ typedef enum
} t_gap_mpeg_encoder; } t_gap_mpeg_encoder;
int gap_mpeg_encode(GRunModeType run_mode, int gap_mpeg_encode(GimpRunModeType run_mode,
gint32 image_id, gint32 image_id,
t_gap_mpeg_encoder encoder t_gap_mpeg_encoder encoder
/* , /* ,

270
plug-ins/gap/gap_navigator_dialog.c
View File

@ -420,10 +420,10 @@ int gap_debug = 0;
static void query(void); static void query(void);
static void run(char *name, int nparam, GParam *param, static void run(char *name, int nparam, GimpParam *param,
int *nretvals, GParam **retvals); int *nretvals, GimpParam **retvals);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -441,15 +441,15 @@ MAIN ()
static void static void
query () query ()
{ {
static GParamDef args_navigator[] = static GimpParamDef args_navigator[] =
{ {
{PARAM_INT32, "run_mode", "Interactive"}, {GIMP_PDB_INT32, "run_mode", "Interactive"},
{PARAM_IMAGE, "image", "(unused)"}, {GIMP_PDB_IMAGE, "image", "(unused)"},
{PARAM_DRAWABLE, "drawable", "(unused)"}, {GIMP_PDB_DRAWABLE, "drawable", "(unused)"},
}; };
static int nargs_navigator = sizeof(args_navigator) / sizeof(args_navigator[0]); static int nargs_navigator = sizeof(args_navigator) / sizeof(args_navigator[0]);
static GParamDef *return_vals = NULL; static GimpParamDef *return_vals = NULL;
static int nreturn_vals = 0; static int nreturn_vals = 0;
@ -461,7 +461,7 @@ query ()
gap_navigator_version, gap_navigator_version,
N_("<Image>/Video/VCR Navigator..."), N_("<Image>/Video/VCR Navigator..."),
"RGB*, INDEXED*, GRAY*", "RGB*, INDEXED*, GRAY*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs_navigator, nreturn_vals, nargs_navigator, nreturn_vals,
args_navigator, return_vals); args_navigator, return_vals);
} /* end query */ } /* end query */
@ -471,16 +471,16 @@ query ()
static void static void
run (char *name, run (char *name,
int n_params, int n_params,
GParam *param, GimpParam *param,
int *nreturn_vals, int *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
gint32 l_active_image; gint32 l_active_image;
char *l_env; char *l_env;
static GParam values[2]; static GimpParam values[2];
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 nr; gint32 nr;
pid_t l_navid_pid; pid_t l_navid_pid;
@ -505,7 +505,7 @@ run (char *name,
l_active_image = param[1].data.d_image; l_active_image = param[1].data.d_image;
if (run_mode == RUN_NONINTERACTIVE) { if (run_mode == GIMP_RUN_NONINTERACTIVE) {
INIT_I18N(); INIT_I18N();
} else { } else {
INIT_I18N_UI(); INIT_I18N_UI();
@ -522,7 +522,7 @@ run (char *name,
*/ */
if (0 == kill(l_navid_pid, 0)) if (0 == kill(l_navid_pid, 0))
{ {
p_msg_win(RUN_INTERACTIVE, _("Cant open two or more Video Navigator Windows.")); p_msg_win(GIMP_RUN_INTERACTIVE, _("Cant open two or more Video Navigator Windows."));
l_rc = -1; l_rc = -1;
} }
} }
@ -535,12 +535,12 @@ run (char *name,
gimp_set_data(PLUGIN_NAME, &l_navid_pid, sizeof(pid_t)); gimp_set_data(PLUGIN_NAME, &l_navid_pid, sizeof(pid_t));
if (strcmp (name, PLUGIN_NAME) == 0) if (strcmp (name, PLUGIN_NAME) == 0)
{ {
if (run_mode != RUN_INTERACTIVE) if (run_mode != GIMP_RUN_INTERACTIVE)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
l_rc = gap_navigator(l_active_image); l_rc = gap_navigator(l_active_image);
} }
@ -554,10 +554,10 @@ run (char *name,
if(l_rc < 0) if(l_rc < 0)
{ {
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
} }
@ -584,7 +584,7 @@ edit_cut_callback (GtkWidget *w, gpointer client_data)
static void static void
p_edit_paste_call(gint32 paste_mode) p_edit_paste_call(gint32 paste_mode)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
if(naviD->paste_at_frame >= 0) if(naviD->paste_at_frame >= 0)
@ -592,23 +592,23 @@ p_edit_paste_call(gint32 paste_mode)
/* goto the first selected frame */ /* goto the first selected frame */
return_vals = gimp_run_procedure ("plug_in_gap_goto", return_vals = gimp_run_procedure ("plug_in_gap_goto",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, naviD->paste_at_frame, GIMP_PDB_INT32, naviD->paste_at_frame,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status != STATUS_SUCCESS) if (return_vals[0].data.d_status != GIMP_PDB_SUCCESS)
{ {
return; return;
} }
} }
return_vals = gimp_run_procedure ("plug_in_gap_video_edit_paste", return_vals = gimp_run_procedure ("plug_in_gap_video_edit_paste",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, paste_mode, GIMP_PDB_INT32, paste_mode,
PARAM_END); GIMP_PDB_END);
navi_update_after_goto(); navi_update_after_goto();
} }
@ -631,16 +631,16 @@ edit_paster_callback (GtkWidget *w, gpointer client_data)
static void static void
edit_clrpaste_callback (GtkWidget *w, gpointer client_data) edit_clrpaste_callback (GtkWidget *w, gpointer client_data)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
if(gap_debug) printf("edit_clrpaste_callback\n"); if(gap_debug) printf("edit_clrpaste_callback\n");
return_vals = gimp_run_procedure ("plug_in_gap_video_edit_clear", return_vals = gimp_run_procedure ("plug_in_gap_video_edit_clear",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_END); GIMP_PDB_END);
} }
@ -650,7 +650,7 @@ navi_vid_copy_and_cut(gint cut_flag)
SelectedRange *range_list; SelectedRange *range_list;
SelectedRange *range_list2; SelectedRange *range_list2;
SelectedRange *range_item; SelectedRange *range_item;
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
if(gap_debug) printf("navi_dialog_vid_copy_callback\n"); if(gap_debug) printf("navi_dialog_vid_copy_callback\n");
@ -688,12 +688,12 @@ navi_vid_copy_and_cut(gint cut_flag)
return_vals = gimp_run_procedure ("plug_in_gap_video_edit_copy", return_vals = gimp_run_procedure ("plug_in_gap_video_edit_copy",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, range_list2->from, GIMP_PDB_INT32, range_list2->from,
PARAM_INT32, range_list2->to, GIMP_PDB_INT32, range_list2->to,
PARAM_END); GIMP_PDB_END);
range_item = range_list2; range_item = range_list2;
range_list2 = range_list2->prev; range_list2 = range_list2->prev;
} }
@ -707,20 +707,20 @@ navi_vid_copy_and_cut(gint cut_flag)
return_vals = gimp_run_procedure ("plug_in_gap_goto", return_vals = gimp_run_procedure ("plug_in_gap_goto",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, range_list->from, GIMP_PDB_INT32, range_list->from,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return_vals = gimp_run_procedure ("plug_in_gap_del", return_vals = gimp_run_procedure ("plug_in_gap_del",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, 1 + (range_list->to - range_list->from), /* number of frames to delete */ GIMP_PDB_INT32, 1 + (range_list->to - range_list->from), /* number of frames to delete */
PARAM_END); GIMP_PDB_END);
} }
} }
@ -829,7 +829,7 @@ t_anim_info *
navi_get_ainfo(gint32 image_id, t_anim_info *old_ainfo_ptr) navi_get_ainfo(gint32 image_id, t_anim_info *old_ainfo_ptr)
{ {
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
ainfo_ptr = p_alloc_ainfo(image_id, RUN_NONINTERACTIVE); ainfo_ptr = p_alloc_ainfo(image_id, GIMP_RUN_NONINTERACTIVE);
if(ainfo_ptr) if(ainfo_ptr)
{ {
if(old_ainfo_ptr) if(old_ainfo_ptr)
@ -1122,7 +1122,7 @@ navi_check_image_menu_changes()
} }
item_list = NULL; item_list = NULL;
item_count = 0; item_count = 0;
images = gimp_query_images (&nimages); images = gimp_image_list (&nimages);
for (i = 0; i < nimages; i++) for (i = 0; i < nimages; i++)
{ {
frame_nr = p_get_frame_nr(images[i]); /* check for anim frame */ frame_nr = p_get_frame_nr(images[i]); /* check for anim frame */
@ -1383,7 +1383,7 @@ static void navi_playback(gint32 optimize)
gint32 l_to; gint32 l_to;
gint32 l_new_image_id; gint32 l_new_image_id;
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
char l_frame_name[50]; char l_frame_name[50];
int l_frame_delay; int l_frame_delay;
@ -1422,22 +1422,22 @@ static void navi_playback(gint32 optimize)
return_vals = gimp_run_procedure ("plug_in_gap_range_to_multilayer", return_vals = gimp_run_procedure ("plug_in_gap_range_to_multilayer",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, l_from, GIMP_PDB_INT32, l_from,
PARAM_INT32, l_to, GIMP_PDB_INT32, l_to,
PARAM_INT32, 3, /* flatten image */ GIMP_PDB_INT32, 3, /* flatten image */
PARAM_INT32, 1, /* BG_VISIBLE */ GIMP_PDB_INT32, 1, /* BG_VISIBLE */
PARAM_INT32, (gint32)naviD->vin_ptr->framerate, GIMP_PDB_INT32, (gint32)naviD->vin_ptr->framerate,
PARAM_STRING, l_frame_name, GIMP_PDB_STRING, l_frame_name,
PARAM_INT32, 6, /* use all visible layers */ GIMP_PDB_INT32, 6, /* use all visible layers */
PARAM_INT32, 0, /* ignore case */ GIMP_PDB_INT32, 0, /* ignore case */
PARAM_INT32, 0, /* normal selection (no invert) */ GIMP_PDB_INT32, 0, /* normal selection (no invert) */
PARAM_STRING, "0", /* select string (ignored) */ GIMP_PDB_STRING, "0", /* select string (ignored) */
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
l_new_image_id = return_vals[1].data.d_image; l_new_image_id = return_vals[1].data.d_image;
@ -1445,11 +1445,11 @@ static void navi_playback(gint32 optimize)
{ {
return_vals = gimp_run_procedure ("plug_in_animationoptimize", return_vals = gimp_run_procedure ("plug_in_animationoptimize",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, l_new_image_id, GIMP_PDB_IMAGE, l_new_image_id,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
#ifdef COMMENT_BLOCK #ifdef COMMENT_BLOCK
/* sorry, plug_in_animationoptimize does create /* sorry, plug_in_animationoptimize does create
@ -1471,10 +1471,10 @@ static void navi_playback(gint32 optimize)
*/ */
return_vals = gimp_run_procedure ("plug_in_animationplay", return_vals = gimp_run_procedure ("plug_in_animationplay",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, l_new_image_id, GIMP_PDB_IMAGE, l_new_image_id,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_END); GIMP_PDB_END);
} }
} }
@ -1495,7 +1495,7 @@ void navi_dialog_frames_duplicate_frame_callback(GtkWidget *w, gpointer data)
{ {
SelectedRange *range_list; SelectedRange *range_list;
SelectedRange *range_item; SelectedRange *range_item;
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
@ -1517,22 +1517,22 @@ void navi_dialog_frames_duplicate_frame_callback(GtkWidget *w, gpointer data)
return_vals = gimp_run_procedure ("plug_in_gap_goto", return_vals = gimp_run_procedure ("plug_in_gap_goto",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, range_list->from, GIMP_PDB_INT32, range_list->from,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return_vals = gimp_run_procedure ("plug_in_gap_dup", return_vals = gimp_run_procedure ("plug_in_gap_dup",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, 1, /* copy block 1 times */ GIMP_PDB_INT32, 1, /* copy block 1 times */
PARAM_INT32, range_list->from, GIMP_PDB_INT32, range_list->from,
PARAM_INT32, range_list->to, GIMP_PDB_INT32, range_list->to,
PARAM_END); GIMP_PDB_END);
} }
range_item = range_list; range_item = range_list;
range_list = range_list->next; range_list = range_list->next;
@ -1546,7 +1546,7 @@ void navi_dialog_frames_delete_frame_callback(GtkWidget *w, gpointer data)
{ {
SelectedRange *range_list; SelectedRange *range_list;
SelectedRange *range_item; SelectedRange *range_item;
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
@ -1568,20 +1568,20 @@ void navi_dialog_frames_delete_frame_callback(GtkWidget *w, gpointer data)
return_vals = gimp_run_procedure ("plug_in_gap_goto", return_vals = gimp_run_procedure ("plug_in_gap_goto",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, range_list->from, GIMP_PDB_INT32, range_list->from,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return_vals = gimp_run_procedure ("plug_in_gap_del", return_vals = gimp_run_procedure ("plug_in_gap_del",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, 1 + (range_list->to - range_list->from), /* number of frames to delete */ GIMP_PDB_INT32, 1 + (range_list->to - range_list->from), /* number of frames to delete */
PARAM_END); GIMP_PDB_END);
} }
range_item = range_list; range_item = range_list;
range_list = range_list->next; range_list = range_list->next;
@ -1593,50 +1593,50 @@ void navi_dialog_frames_delete_frame_callback(GtkWidget *w, gpointer data)
void navi_dialog_goto_callback(gint32 dst_framenr) void navi_dialog_goto_callback(gint32 dst_framenr)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
if(gap_debug) printf("navi_dialog_goto_callback\n"); if(gap_debug) printf("navi_dialog_goto_callback\n");
navi_set_waiting_cursor(); navi_set_waiting_cursor();
return_vals = gimp_run_procedure ("plug_in_gap_goto", return_vals = gimp_run_procedure ("plug_in_gap_goto",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_INT32, dst_framenr, GIMP_PDB_INT32, dst_framenr,
PARAM_END); GIMP_PDB_END);
navi_update_after_goto(); navi_update_after_goto();
} }
void navi_dialog_vcr_goto_first_callback(GtkWidget *w, gpointer data) void navi_dialog_vcr_goto_first_callback(GtkWidget *w, gpointer data)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
if(gap_debug) printf("navi_dialog_vcr_goto_first_callback\n"); if(gap_debug) printf("navi_dialog_vcr_goto_first_callback\n");
navi_set_waiting_cursor(); navi_set_waiting_cursor();
return_vals = gimp_run_procedure ("plug_in_gap_first", return_vals = gimp_run_procedure ("plug_in_gap_first",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_END); GIMP_PDB_END);
navi_update_after_goto(); navi_update_after_goto();
} }
void navi_dialog_vcr_goto_prev_callback(GtkWidget *w, gpointer data) void navi_dialog_vcr_goto_prev_callback(GtkWidget *w, gpointer data)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
if(gap_debug) printf("navi_dialog_vcr_goto_prev_callback\n"); if(gap_debug) printf("navi_dialog_vcr_goto_prev_callback\n");
navi_set_waiting_cursor(); navi_set_waiting_cursor();
return_vals = gimp_run_procedure ("plug_in_gap_prev", return_vals = gimp_run_procedure ("plug_in_gap_prev",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_END); GIMP_PDB_END);
navi_update_after_goto(); navi_update_after_goto();
} }
@ -1656,17 +1656,17 @@ void navi_dialog_vcr_goto_prevblock_callback(GtkWidget *w, gpointer data)
void navi_dialog_vcr_goto_next_callback(GtkWidget *w, gpointer data) void navi_dialog_vcr_goto_next_callback(GtkWidget *w, gpointer data)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
if(gap_debug) printf("navi_dialog_vcr_goto_next_callback\n"); if(gap_debug) printf("navi_dialog_vcr_goto_next_callback\n");
navi_set_waiting_cursor(); navi_set_waiting_cursor();
return_vals = gimp_run_procedure ("plug_in_gap_next", return_vals = gimp_run_procedure ("plug_in_gap_next",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_END); GIMP_PDB_END);
navi_update_after_goto(); navi_update_after_goto();
} }
void navi_dialog_vcr_goto_nextblock_callback(GtkWidget *w, gpointer data) void navi_dialog_vcr_goto_nextblock_callback(GtkWidget *w, gpointer data)
@ -1685,17 +1685,17 @@ void navi_dialog_vcr_goto_nextblock_callback(GtkWidget *w, gpointer data)
void navi_dialog_vcr_goto_last_callback(GtkWidget *w, gpointer data) void navi_dialog_vcr_goto_last_callback(GtkWidget *w, gpointer data)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
if(gap_debug) printf("navi_dialog_vcr_goto_last_callback\n"); if(gap_debug) printf("navi_dialog_vcr_goto_last_callback\n");
navi_set_waiting_cursor(); navi_set_waiting_cursor();
return_vals = gimp_run_procedure ("plug_in_gap_last", return_vals = gimp_run_procedure ("plug_in_gap_last",
&nreturn_vals, &nreturn_vals,
PARAM_INT32, RUN_NONINTERACTIVE, GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE,
PARAM_IMAGE, naviD->active_imageid, GIMP_PDB_IMAGE, naviD->active_imageid,
PARAM_DRAWABLE, -1, /* dummy */ GIMP_PDB_DRAWABLE, -1, /* dummy */
PARAM_END); GIMP_PDB_END);
navi_update_after_goto(); navi_update_after_goto();
} }

292
plug-ins/gap/gap_pdb_calls.c
View File

@ -109,15 +109,15 @@ gint
p_get_gimp_selection_bounds (gint32 image_id, gint32 *x1, gint32 *y1, gint32 *x2, gint32 *y2) p_get_gimp_selection_bounds (gint32 image_id, gint32 *x1, gint32 *y1, gint32 *x2, gint32 *y2)
{ {
static char *l_get_sel_bounds_proc = "gimp_selection_bounds"; static char *l_get_sel_bounds_proc = "gimp_selection_bounds";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_get_sel_bounds_proc, return_vals = gimp_run_procedure (l_get_sel_bounds_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
*x1 = return_vals[2].data.d_int32; *x1 = return_vals[2].data.d_int32;
*y1 = return_vals[3].data.d_int32; *y1 = return_vals[3].data.d_int32;
@ -139,15 +139,15 @@ gint
p_gimp_selection_load (gint32 channel_id) p_gimp_selection_load (gint32 channel_id)
{ {
static char *l_sel_load = "gimp_selection_load"; static char *l_sel_load = "gimp_selection_load";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_sel_load, return_vals = gimp_run_procedure (l_sel_load,
&nreturn_vals, &nreturn_vals,
PARAM_CHANNEL, channel_id, GIMP_PDB_CHANNEL, channel_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(TRUE); return(TRUE);
} }
@ -166,16 +166,16 @@ int
p_layer_set_linked (gint32 layer_id, gint32 new_state) p_layer_set_linked (gint32 layer_id, gint32 new_state)
{ {
static char *l_set_linked_proc = "gimp_layer_set_linked"; static char *l_set_linked_proc = "gimp_layer_set_linked";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_set_linked_proc, return_vals = gimp_run_procedure (l_set_linked_proc,
&nreturn_vals, &nreturn_vals,
PARAM_LAYER, layer_id, GIMP_PDB_LAYER, layer_id,
PARAM_INT32, new_state, /* TRUE or FALSE */ GIMP_PDB_INT32, new_state, /* TRUE or FALSE */
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return (0); return (0);
} }
@ -192,17 +192,17 @@ p_layer_set_linked (gint32 layer_id, gint32 new_state)
gint p_layer_get_linked(gint32 layer_id) gint p_layer_get_linked(gint32 layer_id)
{ {
static char *l_get_linked_proc = "gimp_layer_get_linked"; static char *l_get_linked_proc = "gimp_layer_get_linked";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
gint32 is_linked; gint32 is_linked;
is_linked = FALSE; is_linked = FALSE;
return_vals = gimp_run_procedure (l_get_linked_proc, return_vals = gimp_run_procedure (l_get_linked_proc,
&nreturn_vals, &nreturn_vals,
PARAM_LAYER, layer_id, GIMP_PDB_LAYER, layer_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
is_linked = return_vals[1].data.d_int32; is_linked = return_vals[1].data.d_int32;
} }
@ -220,15 +220,15 @@ gint p_layer_get_linked(gint32 layer_id)
gint32 p_gimp_image_floating_sel_attached_to(gint32 image_id) gint32 p_gimp_image_floating_sel_attached_to(gint32 image_id)
{ {
static char *l_fsel_attached_to_proc = "gimp_image_floating_sel_attached_to"; static char *l_fsel_attached_to_proc = "gimp_image_floating_sel_attached_to";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_fsel_attached_to_proc, return_vals = gimp_run_procedure (l_fsel_attached_to_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(return_vals[1].data.d_drawable); return(return_vals[1].data.d_drawable);
} }
@ -245,16 +245,16 @@ gint32 p_gimp_image_floating_sel_attached_to(gint32 image_id)
gint p_gimp_floating_sel_attach(gint32 layer_id, gint32 drawable_id) gint p_gimp_floating_sel_attach(gint32 layer_id, gint32 drawable_id)
{ {
static char *l_fsel_attach_proc = "gimp_floating_sel_attach"; static char *l_fsel_attach_proc = "gimp_floating_sel_attach";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_fsel_attach_proc, return_vals = gimp_run_procedure (l_fsel_attach_proc,
&nreturn_vals, &nreturn_vals,
PARAM_LAYER, layer_id, GIMP_PDB_LAYER, layer_id,
PARAM_DRAWABLE, drawable_id, GIMP_PDB_DRAWABLE, drawable_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return (0); return (0);
} }
@ -271,16 +271,16 @@ gint p_gimp_floating_sel_attach(gint32 layer_id, gint32 drawable_id)
gint p_gimp_floating_sel_rigor(gint32 layer_id, gint32 undo) gint p_gimp_floating_sel_rigor(gint32 layer_id, gint32 undo)
{ {
static char *l_fsel_rigor_proc = "gimp_floating_sel_rigor"; static char *l_fsel_rigor_proc = "gimp_floating_sel_rigor";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_fsel_rigor_proc, return_vals = gimp_run_procedure (l_fsel_rigor_proc,
&nreturn_vals, &nreturn_vals,
PARAM_LAYER, layer_id, GIMP_PDB_LAYER, layer_id,
PARAM_INT32, undo, GIMP_PDB_INT32, undo,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return (0); return (0);
} }
@ -297,16 +297,16 @@ gint p_gimp_floating_sel_rigor(gint32 layer_id, gint32 undo)
gint p_gimp_floating_sel_relax(gint32 layer_id, gint32 undo) gint p_gimp_floating_sel_relax(gint32 layer_id, gint32 undo)
{ {
static char *l_fsel_relax_proc = "gimp_floating_sel_relax"; static char *l_fsel_relax_proc = "gimp_floating_sel_relax";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_fsel_relax_proc, return_vals = gimp_run_procedure (l_fsel_relax_proc,
&nreturn_vals, &nreturn_vals,
PARAM_LAYER, layer_id, GIMP_PDB_LAYER, layer_id,
PARAM_INT32, undo, GIMP_PDB_INT32, undo,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return (0); return (0);
} }
@ -326,10 +326,10 @@ gint p_gimp_floating_sel_relax(gint32 layer_id, gint32 undo)
gint32 p_gimp_image_add_guide(gint32 image_id, gint32 position, gint32 orientation) gint32 p_gimp_image_add_guide(gint32 image_id, gint32 position, gint32 orientation)
{ {
static char *l_add_guide_proc; static char *l_add_guide_proc;
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
if (orientation == ORIENTATION_VERTICAL) if (orientation == GIMP_VERTICAL)
{ {
l_add_guide_proc = "gimp_image_add_vguide"; l_add_guide_proc = "gimp_image_add_vguide";
} }
@ -340,11 +340,11 @@ gint32 p_gimp_image_add_guide(gint32 image_id, gint32 position, gint32 orienta
return_vals = gimp_run_procedure (l_add_guide_proc, return_vals = gimp_run_procedure (l_add_guide_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_INT32, position, GIMP_PDB_INT32, position,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(return_vals[1].data.d_int32); /* return the guide ID */ return(return_vals[1].data.d_int32); /* return the guide ID */
} }
@ -367,16 +367,16 @@ gint32 p_gimp_image_add_guide(gint32 image_id, gint32 position, gint32 orienta
gint32 p_gimp_image_findnext_guide(gint32 image_id, gint32 guide_id) gint32 p_gimp_image_findnext_guide(gint32 image_id, gint32 guide_id)
{ {
static char *l_findnext_guide_proc = "gimp_image_find_next_guide"; static char *l_findnext_guide_proc = "gimp_image_find_next_guide";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_findnext_guide_proc, return_vals = gimp_run_procedure (l_findnext_guide_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_INT32, guide_id, GIMP_PDB_INT32, guide_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(return_vals[1].data.d_int32); /* return the next guide ID */ return(return_vals[1].data.d_int32); /* return the next guide ID */
} }
@ -395,16 +395,16 @@ gint32 p_gimp_image_findnext_guide(gint32 image_id, gint32 guide_id)
gint32 p_gimp_image_get_guide_position(gint32 image_id, gint32 guide_id) gint32 p_gimp_image_get_guide_position(gint32 image_id, gint32 guide_id)
{ {
static char *l_get_guide_pos_proc = "gimp_image_get_guide_position"; static char *l_get_guide_pos_proc = "gimp_image_get_guide_position";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_get_guide_pos_proc, return_vals = gimp_run_procedure (l_get_guide_pos_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_INT32, guide_id, GIMP_PDB_INT32, guide_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(return_vals[1].data.d_int32); /* return the guide position */ return(return_vals[1].data.d_int32); /* return the guide position */
} }
@ -422,16 +422,16 @@ gint32 p_gimp_image_get_guide_position(gint32 image_id, gint32 guide_id)
gint32 p_gimp_image_get_guide_orientation(gint32 image_id, gint32 guide_id) gint32 p_gimp_image_get_guide_orientation(gint32 image_id, gint32 guide_id)
{ {
static char *l_get_guide_pos_orient = "gimp_image_get_guide_orientation"; static char *l_get_guide_pos_orient = "gimp_image_get_guide_orientation";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_get_guide_pos_orient, return_vals = gimp_run_procedure (l_get_guide_pos_orient,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_INT32, guide_id, GIMP_PDB_INT32, guide_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(return_vals[1].data.d_int32); /* return the guide orientation */ return(return_vals[1].data.d_int32); /* return the guide orientation */
} }
@ -449,16 +449,16 @@ gint32 p_gimp_image_get_guide_orientation(gint32 image_id, gint32 guide_id)
gint32 p_gimp_image_delete_guide(gint32 image_id, gint32 guide_id) gint32 p_gimp_image_delete_guide(gint32 image_id, gint32 guide_id)
{ {
static char *l_delete_guide_proc = "gimp_image_delete_guide"; static char *l_delete_guide_proc = "gimp_image_delete_guide";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_delete_guide_proc, return_vals = gimp_run_procedure (l_delete_guide_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_INT32, guide_id, GIMP_PDB_INT32, guide_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(return_vals[1].data.d_int32); /* return the next guide ID */ return(return_vals[1].data.d_int32); /* return the next guide ID */
} }
@ -476,15 +476,15 @@ gint32 p_gimp_image_delete_guide(gint32 image_id, gint32 guide_id)
gint p_gimp_selection_none(gint32 image_id) gint p_gimp_selection_none(gint32 image_id)
{ {
static char *l_sel_none_proc = "gimp_selection_none"; static char *l_sel_none_proc = "gimp_selection_none";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_sel_none_proc, return_vals = gimp_run_procedure (l_sel_none_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return (0); return (0);
} }
@ -502,7 +502,7 @@ gint p_gimp_selection_none(gint32 image_id)
gint p_gimp_rotate(gint32 drawable_id, gint32 interpolation, gdouble angle_deg) gint p_gimp_rotate(gint32 drawable_id, gint32 interpolation, gdouble angle_deg)
{ {
static char *l_rotate_proc = "gimp_rotate"; static char *l_rotate_proc = "gimp_rotate";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
gdouble l_angle_rad; gdouble l_angle_rad;
@ -510,11 +510,11 @@ gint p_gimp_rotate(gint32 drawable_id, gint32 interpolation, gdouble angle_deg)
return_vals = gimp_run_procedure (l_rotate_proc, return_vals = gimp_run_procedure (l_rotate_proc,
&nreturn_vals, &nreturn_vals,
PARAM_DRAWABLE, drawable_id, GIMP_PDB_DRAWABLE, drawable_id,
PARAM_INT32, interpolation, GIMP_PDB_INT32, interpolation,
PARAM_FLOAT, l_angle_rad, GIMP_PDB_FLOAT, l_angle_rad,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(0); return(0);
} }
@ -529,17 +529,17 @@ gint p_gimp_rotate(gint32 drawable_id, gint32 interpolation, gdouble angle_deg)
*/ */
gint32 p_gimp_channel_ops_duplicate (gint32 image_ID) gint32 p_gimp_channel_ops_duplicate (gint32 image_ID)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
gint32 new_image_ID; gint32 new_image_ID;
return_vals = gimp_run_procedure ("gimp_channel_ops_duplicate", return_vals = gimp_run_procedure ("gimp_channel_ops_duplicate",
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_ID, GIMP_PDB_IMAGE, image_ID,
PARAM_END); GIMP_PDB_END);
new_image_ID = -1; new_image_ID = -1;
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
new_image_ID = return_vals[1].data.d_image; new_image_ID = return_vals[1].data.d_image;
} }
@ -558,16 +558,16 @@ gint32 p_gimp_channel_ops_duplicate (gint32 image_ID)
gint p_gimp_drawable_set_image(gint32 drawable_id, gint32 image_id) gint p_gimp_drawable_set_image(gint32 drawable_id, gint32 image_id)
{ {
static char *l_drawable_set_img_proc = "gimp_drawable_set_image"; static char *l_drawable_set_img_proc = "gimp_drawable_set_image";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_drawable_set_img_proc, return_vals = gimp_run_procedure (l_drawable_set_img_proc,
&nreturn_vals, &nreturn_vals,
PARAM_DRAWABLE, drawable_id, GIMP_PDB_DRAWABLE, drawable_id,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return (0); return (0);
} }
@ -583,17 +583,17 @@ gint p_gimp_drawable_set_image(gint32 drawable_id, gint32 image_id)
char* char*
p_gimp_gimprc_query(char *key) p_gimp_gimprc_query(char *key)
{ {
GParam *return_vals; GimpParam *return_vals;
gint nreturn_vals; gint nreturn_vals;
char *value; char *value;
return_vals = gimp_run_procedure ("gimp_gimprc_query", return_vals = gimp_run_procedure ("gimp_gimprc_query",
&nreturn_vals, &nreturn_vals,
PARAM_STRING, key, GIMP_PDB_STRING, key,
PARAM_END); GIMP_PDB_END);
value = NULL; value = NULL;
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
if(return_vals[1].data.d_string != NULL) if(return_vals[1].data.d_string != NULL)
{ {
@ -616,16 +616,16 @@ gint
p_gimp_file_save_thumbnail(gint32 image_id, char* filename) p_gimp_file_save_thumbnail(gint32 image_id, char* filename)
{ {
static char *l_called_proc = "gimp_file_save_thumbnail"; static char *l_called_proc = "gimp_file_save_thumbnail";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_STRING, filename, GIMP_PDB_STRING, filename,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return (0); return (0);
} }
@ -644,16 +644,16 @@ p_gimp_file_load_thumbnail(char* filename, gint32 *th_width, gint32 *th_height,
gint32 *th_data_count, unsigned char **th_data) gint32 *th_data_count, unsigned char **th_data)
{ {
static char *l_called_proc = "gimp_file_load_thumbnail"; static char *l_called_proc = "gimp_file_load_thumbnail";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
*th_data = NULL; *th_data = NULL;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_STRING, filename, GIMP_PDB_STRING, filename,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
*th_width = return_vals[1].data.d_int32; *th_width = return_vals[1].data.d_int32;
*th_height = return_vals[2].data.d_int32; *th_height = return_vals[2].data.d_int32;
@ -672,18 +672,18 @@ gint p_gimp_image_thumbnail(gint32 image_id, gint32 width, gint32 height,
gint32 *th_data_count, unsigned char **th_data) gint32 *th_data_count, unsigned char **th_data)
{ {
static char *l_called_proc = "gimp_image_thumbnail"; static char *l_called_proc = "gimp_image_thumbnail";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
*th_data = NULL; *th_data = NULL;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_INT32, width, GIMP_PDB_INT32, width,
PARAM_INT32, height, GIMP_PDB_INT32, height,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
*th_width = return_vals[1].data.d_int32; *th_width = return_vals[1].data.d_int32;
*th_height = return_vals[2].data.d_int32; *th_height = return_vals[2].data.d_int32;
@ -708,19 +708,19 @@ p_gimp_path_set_points(gint32 image_id, char *name,
gint32 path_type, gint32 num_points, gdouble *path_points) gint32 path_type, gint32 num_points, gdouble *path_points)
{ {
static char *l_called_proc = "gimp_path_set_points"; static char *l_called_proc = "gimp_path_set_points";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_STRING, name, GIMP_PDB_STRING, name,
PARAM_INT32, path_type, GIMP_PDB_INT32, path_type,
PARAM_INT32, num_points, GIMP_PDB_INT32, num_points,
PARAM_FLOATARRAY, path_points, GIMP_PDB_FLOATARRAY, path_points,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(0); /* OK */ return(0); /* OK */
} }
@ -740,16 +740,16 @@ p_gimp_path_get_points(gint32 image_id, char *name,
gint32 *path_type, gint32 *path_closed, gint32 *num_points) gint32 *path_type, gint32 *path_closed, gint32 *num_points)
{ {
static char *l_called_proc = "gimp_path_get_points"; static char *l_called_proc = "gimp_path_get_points";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_STRING, name, GIMP_PDB_STRING, name,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
*path_type = return_vals[1].data.d_int32; *path_type = return_vals[1].data.d_int32;
*path_closed = return_vals[2].data.d_int32; *path_closed = return_vals[2].data.d_int32;
@ -771,16 +771,16 @@ gint
p_gimp_path_delete(gint32 image_id, char *name) p_gimp_path_delete(gint32 image_id, char *name)
{ {
static char *l_called_proc = "gimp_path_delete"; static char *l_called_proc = "gimp_path_delete";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_STRING, name, GIMP_PDB_STRING, name,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return (0); return (0);
} }
@ -799,15 +799,15 @@ char **
p_gimp_path_list(gint32 image_id, gint32 *num_paths) p_gimp_path_list(gint32 image_id, gint32 *num_paths)
{ {
static char *l_called_proc = "gimp_path_list"; static char *l_called_proc = "gimp_path_list";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
*num_paths = return_vals[1].data.d_int32; *num_paths = return_vals[1].data.d_int32;
return(return_vals[2].data.d_stringarray); /* OK, return path names */ return(return_vals[2].data.d_stringarray); /* OK, return path names */
@ -827,15 +827,15 @@ char *
p_gimp_path_get_current(gint32 image_id) p_gimp_path_get_current(gint32 image_id)
{ {
static char *l_called_proc = "gimp_path_get_current"; static char *l_called_proc = "gimp_path_get_current";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(g_strdup(return_vals[1].data.d_string)); /* OK */ return(g_strdup(return_vals[1].data.d_string)); /* OK */
} }
@ -853,16 +853,16 @@ gint
p_gimp_path_set_current(gint32 image_id, char *name) p_gimp_path_set_current(gint32 image_id, char *name)
{ {
static char *l_called_proc = "gimp_path_set_current"; static char *l_called_proc = "gimp_path_set_current";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_STRING, name, GIMP_PDB_STRING, name,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(0); /* OK */ return(0); /* OK */
} }
@ -879,16 +879,16 @@ gint32
p_gimp_path_get_locked(gint32 image_id, gchar *name) p_gimp_path_get_locked(gint32 image_id, gchar *name)
{ {
static gchar *l_called_proc = "gimp_path_get_locked"; static gchar *l_called_proc = "gimp_path_get_locked";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_STRING, name, GIMP_PDB_STRING, name,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(return_vals[1].data.d_int32); /* OK */ return(return_vals[1].data.d_int32); /* OK */
} }
@ -905,17 +905,17 @@ gint
p_gimp_path_set_locked(gint32 image_id, gchar *name, gint32 lockstatus) p_gimp_path_set_locked(gint32 image_id, gchar *name, gint32 lockstatus)
{ {
static gchar *l_called_proc = "gimp_path_set_locked"; static gchar *l_called_proc = "gimp_path_set_locked";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_called_proc, return_vals = gimp_run_procedure (l_called_proc,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_STRING, name, GIMP_PDB_STRING, name,
PARAM_INT32, lockstatus, GIMP_PDB_INT32, lockstatus,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
return(0); /* OK */ return(0); /* OK */
} }
@ -932,15 +932,15 @@ gchar **
p_gimp_image_parasite_list (gint32 image_id, gint32 *num_parasites) p_gimp_image_parasite_list (gint32 image_id, gint32 *num_parasites)
{ {
static gchar *l_procname = "gimp_image_parasite_list"; static gchar *l_procname = "gimp_image_parasite_list";
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure (l_procname, return_vals = gimp_run_procedure (l_procname,
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
*num_parasites = return_vals[1].data.d_int32; *num_parasites = return_vals[1].data.d_int32;
return(return_vals[2].data.d_stringarray); /* OK, return name list */ return(return_vals[2].data.d_stringarray); /* OK, return name list */

124
plug-ins/gap/gap_range_ops.c
View File

@ -39,12 +39,12 @@
* 1.1.10a 1999/10/22 hof: bugfix: have to use the changed PDB-Interface * 1.1.10a 1999/10/22 hof: bugfix: have to use the changed PDB-Interface
* for gimp_convert_indexed * for gimp_convert_indexed
* (with extended dither options and extra dialog window) * (with extended dither options and extra dialog window)
* 1.1.9a 1999/09/21 hof: bugfix RUN_NONINTERACTIVE did not work in * 1.1.9a 1999/09/21 hof: bugfix GIMP_RUN_NONINTERACTIVE did not work in
* plug_in_gap_range_convert * plug_in_gap_range_convert
* plug_in_gap_range_layer_del * plug_in_gap_range_layer_del
* plug_in_gap_range_flatten * plug_in_gap_range_flatten
* 1.1.8 1999/08/31 hof: frames convert: save subsequent frames * 1.1.8 1999/08/31 hof: frames convert: save subsequent frames
* with rumode RUN_WITH_LAST_VALS * with rumode GIMP_RUN_WITH_LAST_VALS
* 0.97.00; 1998/10/19 hof: gap_range_to_multilayer: extended layer selection * 0.97.00; 1998/10/19 hof: gap_range_to_multilayer: extended layer selection
* 0.96.03; 1998/08/31 hof: gap_range_to_multilayer: all params available * 0.96.03; 1998/08/31 hof: gap_range_to_multilayer: all params available
* in non-interactive runmode * in non-interactive runmode
@ -419,7 +419,7 @@ p_convert_indexed_dialog(gint32 *dest_colors, gint32 *dest_dither,
static long static long
p_convert_dialog(t_anim_info *ainfo_ptr, p_convert_dialog(t_anim_info *ainfo_ptr,
long *range_from, long *range_to, long *flatten, long *range_from, long *range_to, long *flatten,
GImageType *dest_type, gint32 *dest_colors, gint32 *dest_dither, GimpImageBaseType *dest_type, gint32 *dest_colors, gint32 *dest_dither,
char *basename, gint len_base, char *basename, gint len_base,
char *extension, gint len_ext, char *extension, gint len_ext,
gint32 *palette_type, gint32 *alpha_dither, gint32 *remove_unused, gint32 *palette_type, gint32 *alpha_dither, gint32 *remove_unused,
@ -492,16 +492,16 @@ p_convert_dialog(t_anim_info *ainfo_ptr,
switch(argv[5].radio_ret) switch(argv[5].radio_ret)
{ {
case 1: case 1:
*dest_type = RGB; *dest_type = GIMP_RGB;
break; break;
case 2: case 2:
*dest_type = GRAY; *dest_type = GIMP_GRAY;
break; break;
case 3: case 3:
*dest_type = INDEXED; *dest_type = GIMP_INDEXED;
break; break;
default: default:
*dest_type = 9444; *dest_type = 9444; /* huh ?? */
break; break;
} }
*flatten = (long)(argv[6].int_ret); *flatten = (long)(argv[6].int_ret);
@ -512,7 +512,7 @@ p_convert_dialog(t_anim_info *ainfo_ptr,
*alpha_dither = 0; *alpha_dither = 0;
*remove_unused = 0; *remove_unused = 0;
if(*dest_type == INDEXED) if(*dest_type == GIMP_INDEXED)
{ {
/* Open a 2.nd dialog for the Dither Options */ /* Open a 2.nd dialog for the Dither Options */
if(0 != p_convert_indexed_dialog(dest_colors, if(0 != p_convert_indexed_dialog(dest_colors,
@ -719,7 +719,7 @@ p_frames_to_multilayer(t_anim_info *ainfo_ptr,
gint32 sel_mode, gint32 sel_case, gint32 sel_mode, gint32 sel_case,
gint32 sel_invert, char *sel_pattern) gint32 sel_invert, char *sel_pattern)
{ {
GImageType l_type; GimpImageBaseType l_type;
guint l_width, l_height; guint l_width, l_height;
long l_cur_frame_nr; long l_cur_frame_nr;
long l_step, l_begin, l_end; long l_step, l_begin, l_end;
@ -742,7 +742,7 @@ p_frames_to_multilayer(t_anim_info *ainfo_ptr,
l_percentage = 0.0; l_percentage = 0.0;
l_nlayers_result = 0; l_nlayers_result = 0;
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
gimp_progress_init( _("Creating Layer-Animated Image...")); gimp_progress_init( _("Creating Layer-Animated Image..."));
} }
@ -897,7 +897,7 @@ p_frames_to_multilayer(t_anim_info *ainfo_ptr,
/* destroy the tmp image */ /* destroy the tmp image */
gimp_image_delete(l_tmp_image_id); gimp_image_delete(l_tmp_image_id);
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -926,7 +926,7 @@ error:
* gap_range_to_multilayer * gap_range_to_multilayer
* ============================================================================ * ============================================================================
*/ */
gint32 gap_range_to_multilayer(GRunModeType run_mode, gint32 image_id, gint32 gap_range_to_multilayer(GimpRunModeType run_mode, gint32 image_id,
long range_from, long range_to, long range_from, long range_to,
long flatten_mode, long bg_visible, long flatten_mode, long bg_visible,
long framerate, long framerate,
@ -952,7 +952,7 @@ gint32 gap_range_to_multilayer(GRunModeType run_mode, gint32 image_id,
{ {
if (0 == p_dir_ainfo(ainfo_ptr)) if (0 == p_dir_ainfo(ainfo_ptr))
{ {
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_framerate = 24.0; l_framerate = 24.0;
vin_ptr = p_get_video_info(ainfo_ptr->basename); vin_ptr = p_get_video_info(ainfo_ptr->basename);
@ -1012,10 +1012,10 @@ gint32 gap_range_to_multilayer(GRunModeType run_mode, gint32 image_id,
* ============================================================================ * ============================================================================
*/ */
static int static int
p_type_convert(gint32 image_id, GImageType dest_type, gint32 dest_colors, gint32 dest_dither, p_type_convert(gint32 image_id, GimpImageBaseType dest_type, gint32 dest_colors, gint32 dest_dither,
gint32 palette_type, gint32 alpha_dither, gint32 remove_unused, char *palette) gint32 palette_type, gint32 alpha_dither, gint32 remove_unused, char *palette)
{ {
GParam *l_params; GimpParam *l_params;
gint l_retvals; gint l_retvals;
int l_rc; int l_rc;
@ -1024,33 +1024,33 @@ p_type_convert(gint32 image_id, GImageType dest_type, gint32 dest_colors, gint32
switch(dest_type) switch(dest_type)
{ {
case INDEXED: case GIMP_INDEXED:
if(gap_debug) fprintf(stderr, "DEBUG: p_type_convert to INDEXED ncolors=%d, palette_type=%d palette_name=%s'\n", if(gap_debug) fprintf(stderr, "DEBUG: p_type_convert to INDEXED ncolors=%d, palette_type=%d palette_name=%s'\n",
(int)dest_colors, (int)palette_type, palette); (int)dest_colors, (int)palette_type, palette);
l_params = gimp_run_procedure ("gimp_convert_indexed", l_params = gimp_run_procedure ("gimp_convert_indexed",
&l_retvals, &l_retvals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_INT32, dest_dither, /* value 1== floyd-steinberg */ GIMP_PDB_INT32, dest_dither, /* value 1== floyd-steinberg */
PARAM_INT32, palette_type, /* value 0: MAKE_PALETTE, 2: WEB_PALETTE 4:CUSTOM_PALETTE */ GIMP_PDB_INT32, palette_type, /* value 0: MAKE_PALETTE, 2: WEB_PALETTE 4:CUSTOM_PALETTE */
PARAM_INT32, dest_colors, GIMP_PDB_INT32, dest_colors,
PARAM_INT32, alpha_dither, GIMP_PDB_INT32, alpha_dither,
PARAM_INT32, remove_unused, GIMP_PDB_INT32, remove_unused,
PARAM_STRING, palette, /* name of custom palette */ GIMP_PDB_STRING, palette, /* name of custom palette */
PARAM_END); GIMP_PDB_END);
break; break;
case GRAY: case GIMP_GRAY:
if(gap_debug) fprintf(stderr, "DEBUG: p_type_convert to GRAY'\n"); if(gap_debug) fprintf(stderr, "DEBUG: p_type_convert to GRAY'\n");
l_params = gimp_run_procedure ("gimp_convert_grayscale", l_params = gimp_run_procedure ("gimp_convert_grayscale",
&l_retvals, &l_retvals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
break; break;
case RGB: case GIMP_RGB:
if(gap_debug) fprintf(stderr, "DEBUG: p_type_convert to RGB'\n"); if(gap_debug) fprintf(stderr, "DEBUG: p_type_convert to RGB'\n");
l_params = gimp_run_procedure ("gimp_convert_rgb", l_params = gimp_run_procedure ("gimp_convert_rgb",
&l_retvals, &l_retvals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_END); GIMP_PDB_END);
break; break;
default: default:
if(gap_debug) fprintf(stderr, "DEBUG: p_type_convert AS_IT_IS (dont convert)'\n"); if(gap_debug) fprintf(stderr, "DEBUG: p_type_convert AS_IT_IS (dont convert)'\n");
@ -1085,10 +1085,10 @@ p_frames_convert(t_anim_info *ainfo_ptr,
long range_from, long range_to, long range_from, long range_to,
char *save_proc_name, char *new_basename, char *new_extension, char *save_proc_name, char *new_basename, char *new_extension,
int flatten, int flatten,
GImageType dest_type, gint32 dest_colors, gint32 dest_dither, GimpImageBaseType dest_type, gint32 dest_colors, gint32 dest_dither,
gint32 palette_type, gint32 alpha_dither, gint32 remove_unused, char *palette) gint32 palette_type, gint32 alpha_dither, gint32 remove_unused, char *palette)
{ {
GRunModeType l_run_mode; GimpRunModeType l_run_mode;
gint32 l_tmp_image_id; gint32 l_tmp_image_id;
long l_cur_frame_nr; long l_cur_frame_nr;
long l_step, l_begin, l_end; long l_step, l_begin, l_end;
@ -1106,7 +1106,7 @@ p_frames_convert(t_anim_info *ainfo_ptr,
l_overwrite_mode = 0; l_overwrite_mode = 0;
l_percentage = 0.0; l_percentage = 0.0;
l_run_mode = ainfo_ptr->run_mode; l_run_mode = ainfo_ptr->run_mode;
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
if(save_proc_name == NULL) gimp_progress_init( _("Flattening Frames...")); if(save_proc_name == NULL) gimp_progress_init( _("Flattening Frames..."));
else gimp_progress_init( _("Converting Frames...")); else gimp_progress_init( _("Converting Frames..."));
@ -1262,9 +1262,9 @@ p_frames_convert(t_anim_info *ainfo_ptr,
"or desired save plugin not available.")); "or desired save plugin not available."));
} }
} }
if(l_run_mode == RUN_INTERACTIVE) if(l_run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_run_mode = RUN_WITH_LAST_VALS; /* for all further calls */ l_run_mode = GIMP_RUN_WITH_LAST_VALS; /* for all further calls */
} }
g_free(l_sav_name); g_free(l_sav_name);
} }
@ -1273,7 +1273,7 @@ p_frames_convert(t_anim_info *ainfo_ptr,
/* destroy the tmp image */ /* destroy the tmp image */
gimp_image_delete(l_tmp_image_id); gimp_image_delete(l_tmp_image_id);
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -1304,7 +1304,7 @@ int p_image_sizechange(gint32 image_id,
long offs_x, long offs_y long offs_x, long offs_y
) )
{ {
GParam *l_params; GimpParam *l_params;
gint l_retvals; gint l_retvals;
switch(asiz_mode) switch(asiz_mode)
@ -1312,12 +1312,12 @@ int p_image_sizechange(gint32 image_id,
case ASIZ_CROP: case ASIZ_CROP:
l_params = gimp_run_procedure ("gimp_crop", l_params = gimp_run_procedure ("gimp_crop",
&l_retvals, &l_retvals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_INT32, size_x, GIMP_PDB_INT32, size_x,
PARAM_INT32, size_y, GIMP_PDB_INT32, size_y,
PARAM_INT32, offs_x, GIMP_PDB_INT32, offs_x,
PARAM_INT32, offs_y, GIMP_PDB_INT32, offs_y,
PARAM_END); GIMP_PDB_END);
break; break;
case ASIZ_RESIZE: case ASIZ_RESIZE:
gimp_image_resize(image_id, (guint)size_x, (guint)size_y, (gint)offs_x, (gint)offs_y); gimp_image_resize(image_id, (guint)size_x, (guint)size_y, (gint)offs_x, (gint)offs_y);
@ -1325,10 +1325,10 @@ int p_image_sizechange(gint32 image_id,
default: default:
l_params = gimp_run_procedure ("gimp_image_scale", l_params = gimp_run_procedure ("gimp_image_scale",
&l_retvals, &l_retvals,
PARAM_IMAGE, image_id, GIMP_PDB_IMAGE, image_id,
PARAM_INT32, size_x, GIMP_PDB_INT32, size_x,
PARAM_INT32, size_y, GIMP_PDB_INT32, size_y,
PARAM_END); GIMP_PDB_END);
break; break;
} }
@ -1352,7 +1352,7 @@ gint32 p_anim_sizechange(t_anim_info *ainfo_ptr,
long l_step, l_begin, l_end; long l_step, l_begin, l_end;
gint32 l_tmp_image_id; gint32 l_tmp_image_id;
gdouble l_percentage, l_percentage_step; gdouble l_percentage, l_percentage_step;
GParam *l_params; GimpParam *l_params;
int l_rc; int l_rc;
l_rc = 0; l_rc = 0;
@ -1360,7 +1360,7 @@ gint32 p_anim_sizechange(t_anim_info *ainfo_ptr,
l_percentage = 0.0; l_percentage = 0.0;
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
switch(asiz_mode) switch(asiz_mode)
{ {
@ -1417,7 +1417,7 @@ gint32 p_anim_sizechange(t_anim_info *ainfo_ptr,
/* destroy the tmp image */ /* destroy the tmp image */
gimp_image_delete(l_tmp_image_id); gimp_image_delete(l_tmp_image_id);
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -1441,7 +1441,7 @@ gint32 p_anim_sizechange(t_anim_info *ainfo_ptr,
* gap_range_flatten * gap_range_flatten
* ============================================================================ * ============================================================================
*/ */
int gap_range_flatten(GRunModeType run_mode, gint32 image_id, int gap_range_flatten(GimpRunModeType run_mode, gint32 image_id,
long range_from, long range_to) long range_from, long range_to)
{ {
int l_rc; int l_rc;
@ -1454,7 +1454,7 @@ int gap_range_flatten(GRunModeType run_mode, gint32 image_id,
{ {
if (0 == p_dir_ainfo(ainfo_ptr)) if (0 == p_dir_ainfo(ainfo_ptr))
{ {
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_rc = p_range_dialog (ainfo_ptr, &l_from, &l_to, l_rc = p_range_dialog (ainfo_ptr, &l_from, &l_to,
_("Flatten Frames"), _("Flatten Frames"),
@ -1511,7 +1511,7 @@ p_frames_layer_del(t_anim_info *ainfo_ptr,
l_rc = 0; l_rc = 0;
l_percentage = 0.0; l_percentage = 0.0;
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_buff = g_strdup_printf (_("Removing Layer (pos:%ld) from Frames..."), position); l_buff = g_strdup_printf (_("Removing Layer (pos:%ld) from Frames..."), position);
gimp_progress_init(l_buff); gimp_progress_init(l_buff);
@ -1597,7 +1597,7 @@ p_frames_layer_del(t_anim_info *ainfo_ptr,
/* destroy the tmp image */ /* destroy the tmp image */
gimp_image_delete(l_tmp_image_id); gimp_image_delete(l_tmp_image_id);
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -1619,7 +1619,7 @@ p_frames_layer_del(t_anim_info *ainfo_ptr,
* gap_range_layer_del * gap_range_layer_del
* ============================================================================ * ============================================================================
*/ */
int gap_range_layer_del(GRunModeType run_mode, gint32 image_id, int gap_range_layer_del(GimpRunModeType run_mode, gint32 image_id,
long range_from, long range_to, long position) long range_from, long range_to, long position)
{ {
int l_rc; int l_rc;
@ -1634,7 +1634,7 @@ int gap_range_layer_del(GRunModeType run_mode, gint32 image_id,
{ {
if (0 == p_dir_ainfo(ainfo_ptr)) if (0 == p_dir_ainfo(ainfo_ptr))
{ {
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_rc = p_range_dialog (ainfo_ptr, &l_from, &l_to, l_rc = p_range_dialog (ainfo_ptr, &l_from, &l_to,
_("Delete Layers in Frames"), _("Delete Layers in Frames"),
@ -1672,10 +1672,10 @@ int gap_range_layer_del(GRunModeType run_mode, gint32 image_id,
* convert frame range to any gimp supported fileformat * convert frame range to any gimp supported fileformat
* ============================================================================ * ============================================================================
*/ */
gint32 gap_range_conv(GRunModeType run_mode, gint32 image_id, gint32 gap_range_conv(GimpRunModeType run_mode, gint32 image_id,
long range_from, long range_to, long range_from, long range_to,
long flatten, long flatten,
GImageType dest_type, GimpImageBaseType dest_type,
gint32 dest_colors, gint32 dest_colors,
gint32 dest_dither, gint32 dest_dither,
char *basename, char *basename,
@ -1693,7 +1693,7 @@ gint32 gap_range_conv(GRunModeType run_mode, gint32 image_id,
gint32 l_palette_type; gint32 l_palette_type;
gint32 l_alpha_dither; gint32 l_alpha_dither;
gint32 l_remove_unused; gint32 l_remove_unused;
GImageType l_dest_type; GimpImageBaseType l_dest_type;
t_anim_info *ainfo_ptr; t_anim_info *ainfo_ptr;
char l_save_proc_name[128]; char l_save_proc_name[128];
@ -1715,7 +1715,7 @@ gint32 gap_range_conv(GRunModeType run_mode, gint32 image_id,
strncpy(l_basename, ainfo_ptr->basename, sizeof(l_basename) -1); strncpy(l_basename, ainfo_ptr->basename, sizeof(l_basename) -1);
l_basename[sizeof(l_basename) -1] = '\0'; l_basename[sizeof(l_basename) -1] = '\0';
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_flatten = 1; l_flatten = 1;
@ -1795,7 +1795,7 @@ gint32 gap_range_conv(GRunModeType run_mode, gint32 image_id,
* (depending on asiz_mode) * (depending on asiz_mode)
* ============================================================================ * ============================================================================
*/ */
int gap_anim_sizechange(GRunModeType run_mode, t_gap_asiz asiz_mode, gint32 image_id, int gap_anim_sizechange(GimpRunModeType run_mode, t_gap_asiz asiz_mode, gint32 image_id,
long size_x, long size_y, long offs_x, long offs_y) long size_x, long size_y, long offs_x, long offs_y)
{ {
int l_rc; int l_rc;
@ -1809,7 +1809,7 @@ int gap_anim_sizechange(GRunModeType run_mode, t_gap_asiz asiz_mode, gint32 imag
{ {
if (0 == p_dir_ainfo(ainfo_ptr)) if (0 == p_dir_ainfo(ainfo_ptr))
{ {
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_rc = p_anim_sizechange_dialog (ainfo_ptr, asiz_mode, l_rc = p_anim_sizechange_dialog (ainfo_ptr, asiz_mode,
&l_size_x, &l_size_y, &l_size_x, &l_size_y,

12
plug-ins/gap/gap_range_ops.h
View File

@ -55,7 +55,7 @@ typedef enum
gint32 gap_range_to_multilayer(GRunModeType run_mode, gint32 gap_range_to_multilayer(GimpRunModeType run_mode,
gint32 image_id, gint32 image_id,
long range_from, long range_to, long range_from, long range_to,
long flatten_mode, long bg_visible, long flatten_mode, long bg_visible,
@ -64,18 +64,18 @@ gint32 gap_range_to_multilayer(GRunModeType run_mode,
gint32 sel_invert, char *sel_pattern gint32 sel_invert, char *sel_pattern
); );
int gap_range_flatten(GRunModeType run_mode, int gap_range_flatten(GimpRunModeType run_mode,
gint32 image_id, gint32 image_id,
long range_from, long range_to); long range_from, long range_to);
int gap_range_layer_del(GRunModeType run_mode, int gap_range_layer_del(GimpRunModeType run_mode,
gint32 image_id, gint32 image_id,
long range_from, long range_to, long position); long range_from, long range_to, long position);
int gap_range_conv(GRunModeType run_mode, int gap_range_conv(GimpRunModeType run_mode,
gint32 image_id, gint32 image_id,
long range_from, long range_to, long range_from, long range_to,
long flatten, long flatten,
GImageType dest_type, GimpImageBaseType dest_type,
gint32 dest_colors, gint32 dest_colors,
gint32 dest_dither, gint32 dest_dither,
char *basename, char *basename,
@ -86,7 +86,7 @@ int gap_range_conv(GRunModeType run_mode,
char *palette char *palette
); );
int gap_anim_sizechange(GRunModeType run_mode, int gap_anim_sizechange(GimpRunModeType run_mode,
t_gap_asiz asiz_mode, t_gap_asiz asiz_mode,
gint32 image_id, gint32 image_id,
long size_x, long size_x,

20
plug-ins/gap/gap_split.c
View File

@ -26,9 +26,9 @@
*/ */
/* revision history /* revision history
* 1.1.9a; 1999/09/21 hof: bugfix RUN_NONINTERACTIVE mode did not work * 1.1.9a; 1999/09/21 hof: bugfix GIMP_RUN_NONINTERACTIVE mode did not work
* 1.1.8a; 1999/08/31 hof: accept anim framenames without underscore '_' * 1.1.8a; 1999/08/31 hof: accept anim framenames without underscore '_'
* 1.1.5a; 1999/05/08 hof: bugix (dont mix GDrawableType with GImageType) * 1.1.5a; 1999/05/08 hof: bugix (dont mix GimpImageType with GimpImageBaseType)
* 0.96.00; 1998/07/01 hof: - added scale, resize and crop * 0.96.00; 1998/07/01 hof: - added scale, resize and crop
* (affects full range == all anim frames) * (affects full range == all anim frames)
* - now using gap_arr_dialog.h * - now using gap_arr_dialog.h
@ -75,9 +75,9 @@ p_split_image(t_anim_info *ainfo_ptr,
char *new_extension, char *new_extension,
gint invers, gint no_alpha) gint invers, gint no_alpha)
{ {
GImageType l_type; GimpImageBaseType l_type;
guint l_width, l_height; guint l_width, l_height;
GRunModeType l_run_mode; GimpRunModeType l_run_mode;
gint32 l_new_image_id; gint32 l_new_image_id;
gint l_nlayers; gint l_nlayers;
gint32 *l_layers_list; gint32 *l_layers_list;
@ -95,7 +95,7 @@ p_split_image(t_anim_info *ainfo_ptr,
l_rc = -1; l_rc = -1;
l_percentage = 0.0; l_percentage = 0.0;
l_run_mode = ainfo_ptr->run_mode; l_run_mode = ainfo_ptr->run_mode;
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
gimp_progress_init( _("Splitting into Frames...")); gimp_progress_init( _("Splitting into Frames..."));
} }
@ -149,7 +149,7 @@ p_split_image(t_anim_info *ainfo_ptr,
/* add a dummy layer (flatten needs at least 2 layers) */ /* add a dummy layer (flatten needs at least 2 layers) */
l_cp_layer_id = gimp_layer_new(l_new_image_id, "dummy", l_cp_layer_id = gimp_layer_new(l_new_image_id, "dummy",
4, 4, /* width, height */ 4, 4, /* width, height */
((l_type * 2 ) + 1), /* convert from GImageType to GDrawableType, and add alpha */ ((l_type * 2 ) + 1), /* convert from GimpImageBaseType to GimpImageType, and add alpha */
0.0, /* Opacity full transparent */ 0.0, /* Opacity full transparent */
0); /* NORMAL */ 0); /* NORMAL */
gimp_image_add_layer(l_new_image_id, l_cp_layer_id, 0); gimp_image_add_layer(l_new_image_id, l_cp_layer_id, 0);
@ -178,7 +178,7 @@ p_split_image(t_anim_info *ainfo_ptr,
break; break;
} }
l_run_mode = RUN_NONINTERACTIVE; /* for all further calls */ l_run_mode = GIMP_RUN_NONINTERACTIVE; /* for all further calls */
/* set image name */ /* set image name */
gimp_image_set_filename (l_new_image_id, l_sav_name); gimp_image_set_filename (l_new_image_id, l_sav_name);
@ -193,7 +193,7 @@ p_split_image(t_anim_info *ainfo_ptr,
/* show progress bar */ /* show progress bar */
if(ainfo_ptr->run_mode == RUN_INTERACTIVE) if(ainfo_ptr->run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_percentage += l_percentage_step; l_percentage += l_percentage_step;
gimp_progress_update (l_percentage); gimp_progress_update (l_percentage);
@ -268,7 +268,7 @@ p_split_dialog(t_anim_info *ainfo_ptr, gint *inverse_order, gint *no_alpha, char
* one frame per layer. * one frame per layer.
* ============================================================================ * ============================================================================
*/ */
int gap_split_image(GRunModeType run_mode, int gap_split_image(GimpRunModeType run_mode,
gint32 image_id, gint32 image_id,
gint32 inverse_order, gint32 inverse_order,
gint32 no_alpha, gint32 no_alpha,
@ -301,7 +301,7 @@ int gap_split_image(GRunModeType run_mode,
} }
else else
{ {
if(run_mode == RUN_INTERACTIVE) if(run_mode == GIMP_RUN_INTERACTIVE)
{ {
l_rc = p_split_dialog (ainfo_ptr, &l_inverse_order, &l_no_alpha, &l_extension[0], sizeof(l_extension)); l_rc = p_split_dialog (ainfo_ptr, &l_inverse_order, &l_no_alpha, &l_extension[0], sizeof(l_extension));
} }

2
plug-ins/gap/gap_split.h
View File

@ -35,7 +35,7 @@
int gap_split_image(GRunModeType run_mode, int gap_split_image(GimpRunModeType run_mode,
gint32 image_id, gint32 image_id,
gint32 inverse_order, gint32 inverse_order,
gint32 no_alpha, gint32 no_alpha,

16
plug-ins/gdyntext/gdyntext.c
View File

@ -132,7 +132,7 @@ gdt_run (gchar *name,
switch(run_mode) switch(run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
memset (&oldvals, 0, sizeof(GdtVals)); memset (&oldvals, 0, sizeof(GdtVals));
gimp_get_data ("plug_in_gdyntext", &oldvals); gimp_get_data ("plug_in_gdyntext", &oldvals);
@ -158,13 +158,13 @@ gdt_run (gchar *name,
return; return;
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
#ifdef DEBUG #ifdef DEBUG
g_print ("%d\n", nparams); g_print ("%d\n", nparams);
#endif #endif
if (nparams != 11) if (nparams != 11)
{ {
values[0].data.d_status = STATUS_CALLING_ERROR; values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
return; return;
} }
else else
@ -183,7 +183,7 @@ gdt_run (gchar *name,
} }
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data ("plug_in_gdyntext", &gdtvals); gimp_get_data ("plug_in_gdyntext", &gdtvals);
gdtvals.image_id = param[1].data.d_image; gdtvals.image_id = param[1].data.d_image;
gdtvals.drawable_id = param[2].data.d_drawable; gdtvals.drawable_id = param[2].data.d_drawable;
@ -194,7 +194,7 @@ gdt_run (gchar *name,
gdt_render_text (&gdtvals); gdt_render_text (&gdtvals);
if (run_mode == RUN_INTERACTIVE) if (run_mode == GIMP_RUN_INTERACTIVE)
{ {
gdtvals.valid = TRUE; gdtvals.valid = TRUE;
gimp_set_data ("plug_in_gdyntext", &gdtvals, sizeof(GdtVals)); gimp_set_data ("plug_in_gdyntext", &gdtvals, sizeof(GdtVals));
@ -304,8 +304,8 @@ gdt_save (GdtVals *data)
g_free(text); g_free(text);
parasite = gimp_parasite_new (GDYNTEXT_PARASITE, parasite = gimp_parasite_new (GDYNTEXT_PARASITE,
PARASITE_PERSISTENT | PARASITE_UNDOABLE, strlen(lname), lname); GIMP_PARASITE_PERSISTENT | GIMP_PARASITE_UNDOABLE, strlen(lname), lname);
gimp_drawable_attach_parasite (data->drawable_id, parasite); gimp_drawable_parasite_attach (data->drawable_id, parasite);
gimp_parasite_free (parasite); gimp_parasite_free (parasite);
if (!data->change_layer_name) if (!data->change_layer_name)
@ -447,7 +447,7 @@ gdt_render_text_p (GdtVals *data,
data->layer_id = data->drawable_id = gimp_layer_new (data->image_id, data->layer_id = data->drawable_id = gimp_layer_new (data->image_id,
_("GDynText Layer"), layer_width, layer_height, _("GDynText Layer"), layer_width, layer_height,
(GimpImageType)(gimp_image_base_type (data->image_id) * 2 + 1), (GimpImageType)(gimp_image_base_type (data->image_id) * 2 + 1),
100.0, NORMAL_MODE); 100.0, GIMP_NORMAL_MODE);
gimp_layer_add_alpha (data->layer_id); gimp_layer_add_alpha (data->layer_id);
gimp_image_add_layer (data->image_id, data->layer_id, 0); gimp_image_add_layer (data->image_id, data->layer_id, 0);
gimp_image_set_active_layer (data->image_id, data->layer_id); gimp_image_set_active_layer (data->image_id, data->layer_id);

2
plug-ins/gdyntext/gdyntextcompat.h
View File

@ -65,7 +65,7 @@ typedef enum
/* gimp-1.1.14+ function names reorganization forgotten something */ /* gimp-1.1.14+ function names reorganization forgotten something */
#if defined(GIMP_HAVE_PARASITES) && GIMP_MICRO_VERSION < 14 #if defined(GIMP_HAVE_PARASITES) && GIMP_MICRO_VERSION < 14
# warning Replacing missing function 'gimp_drawable_parasite_find' # warning Replacing missing function 'gimp_drawable_parasite_find'
# define gimp_drawable_parasite_find gimp_drawable_find_parasite # define gimp_drawable_parasite_find gimp_drawable_parasite_find
#endif #endif

100
plug-ins/gfig/gfig.c
View File

@ -117,7 +117,7 @@ extern void * gdk_root_parent;
GDK_KEY_PRESS_MASK | \ GDK_KEY_PRESS_MASK | \
GDK_KEY_RELEASE_MASK GDK_KEY_RELEASE_MASK
static GDrawable *gfig_select_drawable; static GimpDrawable *gfig_select_drawable;
static GtkWidget *gfig_preview; static GtkWidget *gfig_preview;
static GtkWidget *pic_preview; static GtkWidget *pic_preview;
static GtkWidget *gfig_gtk_list; static GtkWidget *gfig_gtk_list;
@ -133,9 +133,9 @@ static gint img_width, img_height, img_bpp, real_img_bpp;
static void query (void); static void query (void);
static void run (gchar *name, static void run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
static gint gfig_dialog (void); static gint gfig_dialog (void);
static void gfig_clear_selection (gint32 ID); static void gfig_clear_selection (gint32 ID);
@ -223,7 +223,7 @@ static gint calculate_point_to_line_distance (GdkPoint *p,
GdkPoint *B, GdkPoint *B,
GdkPoint *I); GdkPoint *I);
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -652,12 +652,12 @@ MAIN ()
static void static void
query (void) query (void)
{ {
static GParamDef args[] = static GimpParamDef args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (unused)" }, { GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_INT32, "dummy", "dummy" } { GIMP_PDB_INT32, "dummy", "dummy" }
}; };
static gint nargs = sizeof (args) / sizeof (args[0]); static gint nargs = sizeof (args) / sizeof (args[0]);
@ -669,7 +669,7 @@ query (void)
"1997", "1997",
N_("<Image>/Filters/Render/Gfig..."), N_("<Image>/Filters/Render/Gfig..."),
"RGB*, GRAY*", "RGB*, GRAY*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs, 0, nargs, 0,
args, NULL); args, NULL);
} }
@ -677,14 +677,14 @@ query (void)
static void static void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
GParam * values = g_new (GParam, 1); GimpParam * values = g_new (GimpParam, 1);
GDrawable *drawable; GimpDrawable *drawable;
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint pwidth, pheight; gint pwidth, pheight;
@ -697,7 +697,7 @@ run (gchar *name,
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
gfig_select_drawable = drawable = gfig_select_drawable = drawable =
@ -737,7 +737,7 @@ run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
/*gimp_get_data ("plug_in_gfig", &selvals);*/ /*gimp_get_data ("plug_in_gfig", &selvals);*/
INIT_I18N_UI (); INIT_I18N_UI ();
if (!gfig_dialog ()) if (!gfig_dialog ())
@ -747,11 +747,11 @@ run (gchar *name,
} }
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
/*gimp_get_data ("plug_in_gfig", &selvals);*/ /*gimp_get_data ("plug_in_gfig", &selvals);*/
break; break;
@ -768,17 +768,17 @@ run (gchar *name,
do_gfig (); do_gfig ();
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush (); gimp_displays_flush ();
#if 0 #if 0
if (run_mode == RUN_INTERACTIVE) if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data ("plug_in_gfig", &selvals, sizeof (SelectItVals)); gimp_set_data ("plug_in_gfig", &selvals, sizeof (SelectItVals));
#endif /* 0 */ #endif /* 0 */
} }
else else
{ {
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
values[0].data.d_status = status; values[0].data.d_status = status;
@ -789,7 +789,7 @@ run (gchar *name,
static void static void
gfig_clear_selection (gint32 image_ID) gfig_clear_selection (gint32 image_ID)
{ {
GParam *return_vals; GimpParam *return_vals;
gint nreturn_vals; gint nreturn_vals;
/* Clear any selection - needed because drawing circles/ellipses /* Clear any selection - needed because drawing circles/ellipses
@ -797,8 +797,8 @@ gfig_clear_selection (gint32 image_ID)
*/ */
return_vals = gimp_run_procedure ("gimp_selection_clear", return_vals = gimp_run_procedure ("gimp_selection_clear",
&nreturn_vals, &nreturn_vals,
PARAM_IMAGE, image_ID, GIMP_PDB_IMAGE, image_ID,
PARAM_END); GIMP_PDB_END);
gimp_destroy_params (return_vals, nreturn_vals); gimp_destroy_params (return_vals, nreturn_vals);
} }
@ -1639,7 +1639,7 @@ void * yyy;
static void static void
cache_preview (void) cache_preview (void)
{ {
GPixelRgn src_rgn; GimpPixelRgn src_rgn;
int y, x; int y, x;
guchar *src_rows; guchar *src_rows;
guchar *p; guchar *p;
@ -1666,8 +1666,8 @@ cache_preview (void)
switch (gimp_drawable_type (gfig_select_drawable->id)) switch (gimp_drawable_type (gfig_select_drawable->id))
{ {
case GRAYA_IMAGE: case GIMP_GRAYA_IMAGE:
case GRAY_IMAGE: case GIMP_GRAY_IMAGE:
isgrey = 1; isgrey = 1;
default: default:
break; break;
@ -2422,8 +2422,8 @@ gfig_brush_fill_preview (GtkWidget *pw,
gint32 layer_ID, gint32 layer_ID,
BrushDesc *bdesc) BrushDesc *bdesc)
{ {
GPixelRgn src_rgn; GimpPixelRgn src_rgn;
GDrawable *brushdrawable; GimpDrawable *brushdrawable;
gint bcount = 3; gint bcount = 3;
if (bdesc->pv_buf) if (bdesc->pv_buf)
@ -2452,15 +2452,15 @@ gfig_brush_fill_preview (GtkWidget *pw,
static void static void
mygimp_brush_set (gchar *bname) mygimp_brush_set (gchar *bname)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_brushes_set_brush", return_vals = gimp_run_procedure ("gimp_brushes_set_brush",
&nreturn_vals, &nreturn_vals,
PARAM_STRING, bname, GIMP_PDB_STRING, bname,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status != STATUS_SUCCESS) if (return_vals[0].data.d_status != GIMP_PDB_SUCCESS)
{ {
g_message ("Can't set brush...(1)"); g_message ("Can't set brush...(1)");
} }
@ -2471,15 +2471,15 @@ mygimp_brush_set (gchar *bname)
static gchar * static gchar *
mygimp_brush_get (void) mygimp_brush_get (void)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
static gchar saved_bname[1024]; /* required to be static - returned from proc */ static gchar saved_bname[1024]; /* required to be static - returned from proc */
return_vals = gimp_run_procedure ("gimp_brushes_get_brush", return_vals = gimp_run_procedure ("gimp_brushes_get_brush",
&nreturn_vals, &nreturn_vals,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
strncpy (saved_bname, return_vals[1].data.d_string, sizeof (saved_bname)); strncpy (saved_bname, return_vals[1].data.d_string, sizeof (saved_bname));
} }
@ -2497,14 +2497,14 @@ static void
mygimp_brush_info (gint32 *width, mygimp_brush_info (gint32 *width,
gint32 *height) gint32 *height)
{ {
GParam *return_vals; GimpParam *return_vals;
int nreturn_vals; int nreturn_vals;
return_vals = gimp_run_procedure ("gimp_brushes_get_brush", return_vals = gimp_run_procedure ("gimp_brushes_get_brush",
&nreturn_vals, &nreturn_vals,
PARAM_END); GIMP_PDB_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS) if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
{ {
*width = MAX (return_vals[2].data.d_int32, 32); *width = MAX (return_vals[2].data.d_int32, 32);
*height = MAX (return_vals[3].data.d_int32, 32); *height = MAX (return_vals[3].data.d_int32, 32);
@ -4621,8 +4621,8 @@ paint_layer_new (gchar *new_name)
switch (gimp_drawable_type (gfig_select_drawable->id)) switch (gimp_drawable_type (gfig_select_drawable->id))
{ {
case GRAYA_IMAGE: case GIMP_GRAYA_IMAGE:
case GRAY_IMAGE: case GIMP_GRAY_IMAGE:
isgrey = 2; isgrey = 2;
default: default:
break; break;
@ -7174,7 +7174,7 @@ d_draw_circle (Dobject * obj)
static void static void
d_paint_circle (Dobject *obj) d_paint_circle (Dobject *obj)
{ {
GParam *return_vals; GimpParam *return_vals;
gint nreturn_vals; gint nreturn_vals;
DobjPoints * center_pnt; DobjPoints * center_pnt;
DobjPoints * edge_pnt; DobjPoints * edge_pnt;
@ -7239,8 +7239,8 @@ d_paint_circle (Dobject *obj)
gimp_edit_stroke (gfig_drawable); gimp_edit_stroke (gfig_drawable);
return_vals = gimp_run_procedure ("gimp_selection_clear", &nreturn_vals, return_vals = gimp_run_procedure ("gimp_selection_clear", &nreturn_vals,
PARAM_IMAGE, gfig_image, GIMP_PDB_IMAGE, gfig_image,
PARAM_END); GIMP_PDB_END);
gimp_destroy_params (return_vals, nreturn_vals); gimp_destroy_params (return_vals, nreturn_vals);
@ -7644,7 +7644,7 @@ d_paint_approx_ellipse (Dobject *obj)
static void static void
d_paint_ellipse (Dobject *obj) d_paint_ellipse (Dobject *obj)
{ {
GParam *return_vals; GimpParam *return_vals;
gint nreturn_vals; gint nreturn_vals;
DobjPoints * center_pnt; DobjPoints * center_pnt;
DobjPoints * edge_pnt; DobjPoints * edge_pnt;
@ -7722,8 +7722,8 @@ d_paint_ellipse (Dobject *obj)
gimp_edit_stroke (gfig_drawable); gimp_edit_stroke (gfig_drawable);
return_vals = gimp_run_procedure ("gimp_selection_clear", &nreturn_vals, return_vals = gimp_run_procedure ("gimp_selection_clear", &nreturn_vals,
PARAM_IMAGE, gfig_image, GIMP_PDB_IMAGE, gfig_image,
PARAM_END); GIMP_PDB_END);
gimp_destroy_params (return_vals, nreturn_vals); gimp_destroy_params (return_vals, nreturn_vals);

78
plug-ins/gflare/gflare.c
View File

@ -316,7 +316,7 @@ typedef struct
typedef struct typedef struct
{ {
GTile *tile; GimpTile *tile;
gint col; gint col;
gint row; gint row;
gint shadow; gint shadow;
@ -408,9 +408,9 @@ typedef void (*QueryFunc) (GtkWidget *, gpointer, gpointer);
static void plugin_query (void); static void plugin_query (void);
static void plugin_run (gchar *name, static void plugin_run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
static void plug_in_parse_gflare_path (void); static void plug_in_parse_gflare_path (void);
@ -507,7 +507,7 @@ static void gradient_cache_flush (void);
*** Variables *** Variables
**/ **/
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -598,7 +598,7 @@ static gchar *gflare_menu_modes[] =
}; };
static gint32 image_ID; static gint32 image_ID;
static GDrawable *drawable; static GimpDrawable *drawable;
static DrawableInfo dinfo; static DrawableInfo dinfo;
static TileKeeper *tk_read; static TileKeeper *tk_read;
static TileKeeper *tk_write; static TileKeeper *tk_write;
@ -790,22 +790,22 @@ MAIN ();
void void
plugin_query (void) plugin_query (void)
{ {
static GParamDef args[]= static GimpParamDef args[]=
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (unused)" }, { GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_STRING, "gflare_name", "The name of GFlare" }, { GIMP_PDB_STRING, "gflare_name", "The name of GFlare" },
{ PARAM_INT32, "xcenter", "X coordinate of center of GFlare" }, { GIMP_PDB_INT32, "xcenter", "X coordinate of center of GFlare" },
{ PARAM_INT32, "ycenter", "Y coordinate of center of GFlare" }, { GIMP_PDB_INT32, "ycenter", "Y coordinate of center of GFlare" },
{ PARAM_FLOAT, "radius", "Radius of GFlare (pixel)" }, { GIMP_PDB_FLOAT, "radius", "Radius of GFlare (pixel)" },
{ PARAM_FLOAT, "rotation", "Rotation of GFlare (degree)" }, { GIMP_PDB_FLOAT, "rotation", "Rotation of GFlare (degree)" },
{ PARAM_FLOAT, "hue", "Hue rotation of GFlare (degree)" }, { GIMP_PDB_FLOAT, "hue", "Hue rotation of GFlare (degree)" },
{ PARAM_FLOAT, "vangle", "Vector angle for second flares (degree)" }, { GIMP_PDB_FLOAT, "vangle", "Vector angle for second flares (degree)" },
{ PARAM_FLOAT, "vlength", "Vector length for second flares (percentage to Radius)" }, { GIMP_PDB_FLOAT, "vlength", "Vector length for second flares (percentage to Radius)" },
{ PARAM_INT32, "use_asupsample", "Whether it uses or not adaptive supersampling while rendering (boolean)" }, { GIMP_PDB_INT32, "use_asupsample", "Whether it uses or not adaptive supersampling while rendering (boolean)" },
{ PARAM_INT32, "asupsample_max_depth", "Max depth for adaptive supersampling"}, { GIMP_PDB_INT32, "asupsample_max_depth", "Max depth for adaptive supersampling"},
{ PARAM_FLOAT, "asupsample_threshold", "Threshold for adaptive supersampling"} { GIMP_PDB_FLOAT, "asupsample_threshold", "Threshold for adaptive supersampling"}
}; };
static gint nargs = sizeof (args) / sizeof (args[0]); static gint nargs = sizeof (args) / sizeof (args[0]);
@ -825,7 +825,7 @@ plugin_query (void)
"1997", "1997",
N_("<Image>/Filters/Light Effects/GFlare..."), N_("<Image>/Filters/Light Effects/GFlare..."),
"RGB*, GRAY*", "RGB*, GRAY*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs, 0, nargs, 0,
args, NULL); args, NULL);
} }
@ -833,13 +833,13 @@ plugin_query (void)
void void
plugin_run (gchar *name, plugin_run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[1]; static GimpParam values[1];
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
/* Initialize */ /* Initialize */
run_mode = param[0].data.d_int32; run_mode = param[0].data.d_int32;
@ -847,7 +847,7 @@ plugin_run (gchar *name,
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
/* /*
@ -881,7 +881,7 @@ plugin_run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
INIT_I18N_UI(); INIT_I18N_UI();
/* Possibly retrieve data */ /* Possibly retrieve data */
@ -895,15 +895,15 @@ plugin_run (gchar *name,
} }
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
#if 0 #if 0
printf("Currently non interactive call of gradient flare is not supported\n"); printf("Currently non interactive call of gradient flare is not supported\n");
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
#endif #endif
if (nparams != 14) if (nparams != 14)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
else else
{ {
@ -920,11 +920,11 @@ plugin_run (gchar *name,
pvals.asupsample_threshold = param[13].data.d_float; pvals.asupsample_threshold = param[13].data.d_float;
if (pvals.radius <= 0) if (pvals.radius <= 0)
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
} }
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */ /* Possibly retrieve data */
gimp_get_data ("plug_in_gflare", &pvals); gimp_get_data ("plug_in_gflare", &pvals);
break; break;
@ -933,7 +933,7 @@ plugin_run (gchar *name,
break; break;
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
/* Make sure that the drawable is gray or RGB color */ /* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) || if (gimp_drawable_is_rgb (drawable->id) ||
@ -942,17 +942,17 @@ plugin_run (gchar *name,
gimp_progress_init (_("Gradient Flare...")); gimp_progress_init (_("Gradient Flare..."));
plugin_do (); plugin_do ();
if (run_mode != RUN_NONINTERACTIVE) if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush (); gimp_displays_flush ();
/* Store data */ /* Store data */
if (run_mode == RUN_INTERACTIVE) if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data ("plug_in_gflare", &pvals, sizeof (PluginValues)); gimp_set_data ("plug_in_gflare", &pvals, sizeof (PluginValues));
} }
else else
{ {
g_message (_("GFlare: cannot operate on indexed color images")); g_message (_("GFlare: cannot operate on indexed color images"));
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
} }
@ -1063,7 +1063,7 @@ plugin_do (void)
static void static void
plugin_do_non_asupsample (void) plugin_do_non_asupsample (void)
{ {
GPixelRgn src_rgn, dest_rgn; GimpPixelRgn src_rgn, dest_rgn;
gpointer pr; gpointer pr;
guchar *src_row, *dest_row; guchar *src_row, *dest_row;
guchar *src, *dest; guchar *src, *dest;
@ -2771,7 +2771,7 @@ dlg_preview_init_func (Preview *preview, gpointer data)
static void static void
dlg_preview_render_func (Preview *preview, guchar *dest, gint y, gpointer data) dlg_preview_render_func (Preview *preview, guchar *dest, gint y, gpointer data)
{ {
GPixelRgn srcPR; GimpPixelRgn srcPR;
gint x; gint x;
gint dx, dy; /* drawable x, y */ gint dx, dy; /* drawable x, y */
guchar *src_row, *src; guchar *src_row, *src;

140
plug-ins/gfli/gfli.c
View File

@ -69,9 +69,9 @@
static void query (void); static void query (void);
static void run (gchar *name, static void run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
/* return the image-ID of the new image, or -1 in case of an error */ /* return the image-ID of the new image, or -1 in case of an error */
static gint32 load_image (gchar *filename, static gint32 load_image (gchar *filename,
@ -95,7 +95,7 @@ static gint get_info (gchar *filename,
/* /*
* GIMP interface * GIMP interface
*/ */
GPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
{ {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
@ -103,44 +103,44 @@ GPlugInInfo PLUG_IN_INFO =
run, /* run_proc */ run, /* run_proc */
}; };
GParamDef load_args[] = GimpParamDef load_args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_STRING, "filename", "The name of the file to load" }, { GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name entered" }, { GIMP_PDB_STRING, "raw_filename", "The name entered" },
{ PARAM_INT32, "from_frame", "Load beginning from this frame" }, { GIMP_PDB_INT32, "from_frame", "Load beginning from this frame" },
{ PARAM_INT32, "to_frame", "End loading with this frame" }, { GIMP_PDB_INT32, "to_frame", "End loading with this frame" },
}; };
GParamDef load_return_vals[] = GimpParamDef load_return_vals[] =
{ {
{ PARAM_IMAGE, "image", "Output image" }, { GIMP_PDB_IMAGE, "image", "Output image" },
}; };
gint nload_args = sizeof (load_args) / sizeof (load_args[0]); gint nload_args = sizeof (load_args) / sizeof (load_args[0]);
gint nload_return_vals = (sizeof (load_return_vals) / gint nload_return_vals = (sizeof (load_return_vals) /
sizeof (load_return_vals[0])); sizeof (load_return_vals[0]));
GParamDef save_args[] = GimpParamDef save_args[] =
{ {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" }, { GIMP_PDB_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Input drawable (unused)" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)" },
{ PARAM_STRING, "filename", "The name of the file to save" }, { GIMP_PDB_STRING, "filename", "The name of the file to save" },
{ PARAM_STRING, "raw_filename", "The name entered" }, { GIMP_PDB_STRING, "raw_filename", "The name entered" },
{ PARAM_INT32, "from_frame", "Save beginning from this frame" }, { GIMP_PDB_INT32, "from_frame", "Save beginning from this frame" },
{ PARAM_INT32, "to_frame", "End saving with this frame" }, { GIMP_PDB_INT32, "to_frame", "End saving with this frame" },
}; };
gint nsave_args = sizeof (save_args) / sizeof (save_args[0]); gint nsave_args = sizeof (save_args) / sizeof (save_args[0]);
GParamDef info_args[] = GimpParamDef info_args[] =
{ {
{ PARAM_STRING, "filename", "The name of the file to get info" }, { GIMP_PDB_STRING, "filename", "The name of the file to get info" },
}; };
GParamDef info_return_vals[] = GimpParamDef info_return_vals[] =
{ {
{ PARAM_INT32, "width", "Width of one frame" }, { GIMP_PDB_INT32, "width", "Width of one frame" },
{ PARAM_INT32, "height", "Height of one frame" }, { GIMP_PDB_INT32, "height", "Height of one frame" },
{ PARAM_INT32, "frames", "Number of Frames" }, { GIMP_PDB_INT32, "frames", "Number of Frames" },
}; };
gint ninfo_args = sizeof (info_args) / sizeof (info_args[0]); gint ninfo_args = sizeof (info_args) / sizeof (info_args[0]);
gint ninfo_return_vals = (sizeof (info_return_vals) / gint ninfo_return_vals = (sizeof (info_return_vals) /
@ -166,7 +166,7 @@ query (void)
"1997", "1997",
"<Load>/FLI", "<Load>/FLI",
NULL, NULL,
PROC_PLUG_IN, GIMP_PLUGIN,
nload_args - 2, nload_return_vals, nload_args - 2, nload_return_vals,
load_args, load_return_vals); load_args, load_return_vals);
@ -183,7 +183,7 @@ query (void)
"1997", "1997",
"<Save>/FLI", "<Save>/FLI",
"INDEXED,GRAY", "INDEXED,GRAY",
PROC_PLUG_IN, GIMP_PLUGIN,
nsave_args, 0, nsave_args, 0,
save_args, NULL); save_args, NULL);
@ -203,22 +203,22 @@ query (void)
"1997", "1997",
NULL, NULL,
NULL, NULL,
PROC_EXTENSION, GIMP_EXTENSION,
ninfo_args, ninfo_return_vals, ninfo_args, ninfo_return_vals,
info_args, info_return_vals); info_args, info_return_vals);
} }
GParam values[5]; GimpParam values[5];
static void static void
run (gchar *name, run (gchar *name,
gint nparams, gint nparams,
GParam *param, GimpParam *param,
gint *nreturn_vals, gint *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GRunModeType run_mode; GimpRunModeType run_mode;
gint32 pc; gint32 pc;
gint32 image_ID; gint32 image_ID;
gint32 drawable_ID; gint32 drawable_ID;
@ -229,8 +229,8 @@ run (gchar *name,
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = STATUS_EXECUTION_ERROR; values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, "file_fli_load") == 0) if (strcmp (name, "file_fli_load") == 0)
{ {
@ -238,21 +238,21 @@ run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
/* /*
* check for valid parameters: * check for valid parameters:
* (Or can I trust GIMP ?) * (Or can I trust GIMP ?)
*/ */
if ((nparams < nload_args - 2) || (nload_args < nparams)) if ((nparams < nload_args - 2) || (nload_args < nparams))
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
} }
for (pc = 0; pc < nload_args - 2; pc++) for (pc = 0; pc < nload_args - 2; pc++)
{ {
if (load_args[pc].type != param[pc].type) if (load_args[pc].type != param[pc].type)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
} }
} }
@ -260,7 +260,7 @@ run (gchar *name,
{ {
if (load_args[pc].type != param[pc].type) if (load_args[pc].type != param[pc].type)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
} }
} }
@ -273,14 +273,14 @@ run (gchar *name,
if (image_ID != -1) if (image_ID != -1)
{ {
*nreturn_vals = 2; *nreturn_vals = 2;
values[1].type = PARAM_IMAGE; values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID; values[1].data.d_image = image_ID;
} }
else else
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
break; break;
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
if (load_dialog (param[1].data.d_string)) if (load_dialog (param[1].data.d_string))
{ {
image_ID = load_image (param[1].data.d_string, image_ID = load_image (param[1].data.d_string,
@ -289,18 +289,18 @@ run (gchar *name,
if (image_ID != -1) if (image_ID != -1)
{ {
*nreturn_vals = 2; *nreturn_vals = 2;
values[1].type = PARAM_IMAGE; values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID; values[1].data.d_image = image_ID;
} }
else else
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
else else
status = STATUS_CANCEL; status = GIMP_PDB_CANCEL;
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
} }
} }
@ -313,28 +313,28 @@ run (gchar *name,
switch (run_mode) switch (run_mode)
{ {
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
if (nparams!=nsave_args) if (nparams!=nsave_args)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
} }
for (pc = 0; pc < nsave_args; pc++) for (pc = 0; pc < nsave_args; pc++)
{ {
if (save_args[pc].type!=param[pc].type) if (save_args[pc].type!=param[pc].type)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
} }
} }
if (! save_image (param[3].data.d_string, image_ID, if (! save_image (param[3].data.d_string, image_ID,
param[5].data.d_int32, param[5].data.d_int32,
param[6].data.d_int32)) param[6].data.d_int32))
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
break; break;
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init ("gfli", FALSE); gimp_ui_init ("gfli", FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, "FLI", export = gimp_export_image (&image_ID, &drawable_ID, "FLI",
(CAN_HANDLE_INDEXED | (CAN_HANDLE_INDEXED |
@ -343,17 +343,17 @@ run (gchar *name,
CAN_HANDLE_LAYERS)); CAN_HANDLE_LAYERS));
if (export == EXPORT_CANCEL) if (export == EXPORT_CANCEL)
{ {
values[0].data.d_status = STATUS_CANCEL; values[0].data.d_status = GIMP_PDB_CANCEL;
return; return;
} }
if (save_dialog (param[1].data.d_image)) if (save_dialog (param[1].data.d_image))
{ {
if (! save_image (param[3].data.d_string, image_ID, from_frame, to_frame)) if (! save_image (param[3].data.d_string, image_ID, from_frame, to_frame))
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
else else
status = STATUS_CANCEL; status = GIMP_PDB_CANCEL;
break; break;
} }
@ -370,38 +370,38 @@ run (gchar *name,
* check for valid parameters; * check for valid parameters;
*/ */
if (nparams != ninfo_args) if (nparams != ninfo_args)
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
for (pc = 0; pc < nsave_args; pc++) for (pc = 0; pc < nsave_args; pc++)
{ {
if (info_args[pc].type != param[pc].type) if (info_args[pc].type != param[pc].type)
{ {
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
break; break;
} }
} }
} }
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
if (get_info (param[0].data.d_string, &width, &height, &frames)) if (get_info (param[0].data.d_string, &width, &height, &frames))
{ {
*nreturn_vals = 4; *nreturn_vals = 4;
values[1].type = PARAM_INT32; values[1].type = GIMP_PDB_INT32;
values[1].data.d_int32 = width; values[1].data.d_int32 = width;
values[2].type = PARAM_INT32; values[2].type = GIMP_PDB_INT32;
values[2].data.d_int32 = height; values[2].data.d_int32 = height;
values[3].type = PARAM_INT32; values[3].type = GIMP_PDB_INT32;
values[3].data.d_int32 = frames; values[3].data.d_int32 = frames;
} }
else else
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
} }
} }
else else
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
values[0].data.d_status = status; values[0].data.d_status = status;
} }
@ -446,12 +446,12 @@ load_image (gchar *filename,
{ {
FILE *file; FILE *file;
gchar *name_buf; gchar *name_buf;
GDrawable *drawable; GimpDrawable *drawable;
gint32 image_id, layer_ID; gint32 image_id, layer_ID;
guchar *fb, *ofb, *fb_x; guchar *fb, *ofb, *fb_x;
guchar cm[768], ocm[768]; guchar cm[768], ocm[768];
GPixelRgn pixel_rgn; GimpPixelRgn pixel_rgn;
s_fli_header fli_header; s_fli_header fli_header;
gint cnt; gint cnt;
@ -526,7 +526,7 @@ load_image (gchar *filename,
name_buf = g_strdup_printf (_("Frame (%i)"), cnt); name_buf = g_strdup_printf (_("Frame (%i)"), cnt);
layer_ID = gimp_layer_new (image_id, name_buf, layer_ID = gimp_layer_new (image_id, name_buf,
fli_header.width, fli_header.height, fli_header.width, fli_header.height,
INDEXED_IMAGE, 100, NORMAL_MODE); GIMP_INDEXED_IMAGE, 100, GIMP_NORMAL_MODE);
g_free (name_buf); g_free (name_buf);
drawable = gimp_drawable_get (layer_ID); drawable = gimp_drawable_get (layer_ID);
@ -581,7 +581,7 @@ save_image (gchar *filename,
{ {
FILE *file; FILE *file;
gchar *name_buf; gchar *name_buf;
GDrawable *drawable; GimpDrawable *drawable;
gint32 *framelist; gint32 *framelist;
gint nframes; gint nframes;
gint colors, i; gint colors, i;
@ -594,7 +594,7 @@ save_image (gchar *filename,
guchar *src_row; guchar *src_row;
guchar *fb, *ofb; guchar *fb, *ofb;
guchar cm[768]; guchar cm[768];
GPixelRgn pixel_rgn; GimpPixelRgn pixel_rgn;
s_fli_header fli_header; s_fli_header fli_header;
gint cnt; gint cnt;

4
plug-ins/gimpressionist/brush.c
View File

@ -45,7 +45,7 @@ int colorfile(char *fn)
void brushdmenuselect(gint32 id, gpointer data) void brushdmenuselect(gint32 id, gpointer data)
{ {
GPixelRgn src_rgn; GimpPixelRgn src_rgn;
guchar *src_row; guchar *src_row;
guchar *src; guchar *src;
gint alpha, has_alpha, bpp; gint alpha, has_alpha, bpp;
@ -53,7 +53,7 @@ void brushdmenuselect(gint32 id, gpointer data)
struct ppm *p; struct ppm *p;
gint x1, y1, x2, y2; gint x1, y1, x2, y2;
gint row, col; gint row, col;
GDrawable *drawable; GimpDrawable *drawable;
int rowstride; int rowstride;
if(brushfile == 2) return; /* Not finished GUI-building yet */ if(brushfile == 2) return; /* Not finished GUI-building yet */

54
plug-ins/gimpressionist/gimp.c
View File

@ -12,7 +12,7 @@
static void query(void); static void query(void);
static void gimpressionist_main(void); static void gimpressionist_main(void);
static void run(char *, int, GParam *, int *, GParam **); static void run(char *, int, GimpParam *, int *, GimpParam **);
void repaint(struct ppm *p, struct ppm *a); void repaint(struct ppm *p, struct ppm *a);
int create_gimpressionist(void); int create_gimpressionist(void);
@ -21,7 +21,7 @@ static gint img_width, img_height, img_bpp;
gint img_has_alpha = 0; gint img_has_alpha = 0;
static gint sel_x1, sel_y1, sel_x2, sel_y2; static gint sel_x1, sel_y1, sel_x2, sel_y2;
GPlugInInfo PLUG_IN_INFO = { GimpPlugInInfo PLUG_IN_INFO = {
NULL, /* init_proc */ NULL, /* init_proc */
NULL, /* quit_proc */ NULL, /* quit_proc */
query, /* query_proc */ query, /* query_proc */
@ -79,18 +79,18 @@ gimpressionist_vals_t defaultpcvals = {
0, 0.0 0, 0.0
}; };
static GDrawable *drawable; static GimpDrawable *drawable;
static void static void
query(void) query(void)
{ {
static GParamDef args[] = { static GimpParamDef args[] = {
{ PARAM_INT32, "run_mode", "Interactive" }, { GIMP_PDB_INT32, "run_mode", "Interactive" },
{ PARAM_IMAGE, "image", "Input image" }, { GIMP_PDB_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
}; /* args */ }; /* args */
static GParamDef *return_vals = NULL; static GimpParamDef *return_vals = NULL;
static int nargs = sizeof(args) / sizeof(args[0]); static int nargs = sizeof(args) / sizeof(args[0]);
static int nreturn_vals = 0; static int nreturn_vals = 0;
@ -104,7 +104,7 @@ query(void)
PLUG_IN_VERSION, PLUG_IN_VERSION,
N_("<Image>/Filters/Artistic/GIMPressionist..."), N_("<Image>/Filters/Artistic/GIMPressionist..."),
"RGB*, GRAY*", "RGB*, GRAY*",
PROC_PLUG_IN, GIMP_PLUGIN,
nargs, nargs,
nreturn_vals, nreturn_vals,
args, args,
@ -120,17 +120,17 @@ gimpressionist_get_data(char *name, void *ptr)
static void static void
run(char *name, int nparams, GParam *param, int *nreturn_vals, GParam **return_vals) run(char *name, int nparams, GimpParam *param, int *nreturn_vals, GimpParam **return_vals)
{ {
static GParam values[1]; static GimpParam values[1];
GRunModeType run_mode; GimpRunModeType run_mode;
GStatusType status; GimpPDBStatusType status;
status = STATUS_SUCCESS; status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32; run_mode = param[0].data.d_int32;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
*nreturn_vals = 1; *nreturn_vals = 1;
@ -148,35 +148,35 @@ run(char *name, int nparams, GParam *param, int *nreturn_vals, GParam **return_v
gimp_drawable_mask_bounds(drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2); gimp_drawable_mask_bounds(drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
switch (run_mode) { switch (run_mode) {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
INIT_I18N_UI(); INIT_I18N_UI();
gimpressionist_get_data(PLUG_IN_NAME, &pcvals); gimpressionist_get_data(PLUG_IN_NAME, &pcvals);
if(!create_gimpressionist()) if(!create_gimpressionist())
return; return;
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
INIT_I18N(); INIT_I18N();
g_message("GIMPressionist: RUN_NONINTERACTIVE not implemented yet!\n"); g_message("GIMPressionist: GIMP_RUN_NONINTERACTIVE not implemented yet!\n");
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
INIT_I18N_UI(); INIT_I18N_UI();
gimpressionist_get_data(PLUG_IN_NAME, &pcvals); gimpressionist_get_data(PLUG_IN_NAME, &pcvals);
break; break;
default: default:
g_message("Huh?!\n"); g_message("Huh?!\n");
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
break; break;
} }
if((status == STATUS_SUCCESS) && (gimp_drawable_is_rgb(drawable->id) || gimp_drawable_is_gray(drawable->id))) { if((status == GIMP_PDB_SUCCESS) && (gimp_drawable_is_rgb(drawable->id) || gimp_drawable_is_gray(drawable->id))) {
gimpressionist_main(); gimpressionist_main();
gimp_displays_flush (); gimp_displays_flush ();
if (run_mode == RUN_INTERACTIVE) if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data(PLUG_IN_NAME, &pcvals, sizeof(gimpressionist_vals_t)); gimp_set_data(PLUG_IN_NAME, &pcvals, sizeof(gimpressionist_vals_t));
} else if(status == STATUS_SUCCESS) } else if(status == GIMP_PDB_SUCCESS)
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
values[0].data.d_status = status; values[0].data.d_status = status;
@ -185,7 +185,7 @@ run(char *name, int nparams, GParam *param, int *nreturn_vals, GParam **return_v
void grabarea(void) void grabarea(void)
{ {
GPixelRgn src_rgn; GimpPixelRgn src_rgn;
guchar *src_row; guchar *src_row;
guchar *src; guchar *src;
gint alpha, has_alpha, bpp; gint alpha, has_alpha, bpp;
@ -273,7 +273,7 @@ void grabarea(void)
void gimpressionist_main(void) void gimpressionist_main(void)
{ {
GPixelRgn dest_rgn; GimpPixelRgn dest_rgn;
guchar *dest_row; guchar *dest_row;
guchar *dest; guchar *dest;
gint alpha, has_alpha, bpp; gint alpha, has_alpha, bpp;

2
plug-ins/gimpressionist/gimpressionist.c
View File

@ -522,7 +522,7 @@ int create_gimpressionist(void)
char *standalone = NULL; char *standalone = NULL;
extern GPlugInInfo PLUG_IN_INFO; extern GimpPlugInInfo PLUG_IN_INFO;
#ifdef G_OS_WIN32 #ifdef G_OS_WIN32
/* No standalone on win32. */ /* No standalone on win32. */

42
plug-ins/script-fu/script-fu-console.c
View File

@ -127,19 +127,19 @@ extern FILE *siod_output;
void void
script_fu_console_run (char *name, script_fu_console_run (char *name,
int nparams, int nparams,
GParam *params, GimpParam *params,
int *nreturn_vals, int *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[1]; static GimpParam values[1];
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GRunModeType run_mode; GimpRunModeType run_mode;
run_mode = params[0].data.d_int32; run_mode = params[0].data.d_int32;
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
/* Enable SIOD output */ /* Enable SIOD output */
script_fu_open_siod_console (); script_fu_open_siod_console ();
@ -150,9 +150,9 @@ script_fu_console_run (char *name,
script_fu_close_siod_console (); script_fu_close_siod_console ();
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
gimp_message (_("Script-Fu console mode allows only interactive invocation")); gimp_message (_("Script-Fu console mode allows only interactive invocation"));
break; break;
@ -163,7 +163,7 @@ script_fu_console_run (char *name,
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
} }
@ -605,26 +605,26 @@ script_fu_close_siod_console (void)
void void
script_fu_eval_run (char *name, script_fu_eval_run (char *name,
int nparams, int nparams,
GParam *params, GimpParam *params,
int *nreturn_vals, int *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[1]; static GimpParam values[1];
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GRunModeType run_mode; GimpRunModeType run_mode;
run_mode = params[0].data.d_int32; run_mode = params[0].data.d_int32;
switch (run_mode) switch (run_mode)
{ {
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
if (repl_c_string (params[1].data.d_string, 0, 0, 1) != 0) if (repl_c_string (params[1].data.d_string, 0, 0, 1) != 0)
status = STATUS_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
break; break;
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
gimp_message (_("Script-Fu evaluate mode allows only noninteractive invocation")); gimp_message (_("Script-Fu evaluate mode allows only noninteractive invocation"));
break; break;
@ -635,6 +635,6 @@ script_fu_eval_run (char *name,
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
} }

20
plug-ins/script-fu/script-fu-console.h
View File

@ -19,15 +19,15 @@
#ifndef __SCRIPT_FU_CONSOLE_H__ #ifndef __SCRIPT_FU_CONSOLE_H__
#define __SCRIPT_FU_CONSOLE_H__ #define __SCRIPT_FU_CONSOLE_H__
void script_fu_console_run (char *name, void script_fu_console_run (gchar *name,
int nparams, gint nparams,
GParam *params, GimpParam *params,
int *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
void script_fu_eval_run (char *name, void script_fu_eval_run (gchar *name,
int nparams, gint nparams,
GParam *params, GimpParam *params,
int *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
#endif /* __SCRIPT_FU_CONSOLE__ */ #endif /* __SCRIPT_FU_CONSOLE__ */

18
plug-ins/script-fu/script-fu-interface.c
View File

@ -779,7 +779,7 @@ script_fu_install_script (gpointer foo,
script->date, script->date,
menu_path, menu_path,
script->img_types, script->img_types,
PROC_TEMPORARY, GIMP_TEMPORARY,
script->num_args + 1, 0, script->num_args + 1, 0,
script->args, NULL, script->args, NULL,
script_fu_script_proc); script_fu_script_proc);
@ -812,7 +812,7 @@ script_fu_script_proc (gchar *name,
GimpParam **return_vals) GimpParam **return_vals)
{ {
static GimpParam values[1]; static GimpParam values[1];
GimpPDBStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunModeType run_mode; GimpRunModeType run_mode;
SFScript *script; SFScript *script;
gint min_args; gint min_args;
@ -821,16 +821,16 @@ script_fu_script_proc (gchar *name,
run_mode = params[0].data.d_int32; run_mode = params[0].data.d_int32;
if (! (script = script_fu_find_script (name))) if (! (script = script_fu_find_script (name)))
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
else else
{ {
if (script->num_args == 0) if (script->num_args == 0)
run_mode = RUN_NONINTERACTIVE; run_mode = GIMP_RUN_NONINTERACTIVE;
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
/* Determine whether the script is image based (runs on an image) */ /* Determine whether the script is image based (runs on an image) */
if (strncmp (script->description, "<Image>", 7) == 0) if (strncmp (script->description, "<Image>", 7) == 0)
{ {
@ -850,11 +850,11 @@ script_fu_script_proc (gchar *name,
break; break;
} }
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */ /* Make sure all the arguments are there! */
if (nparams != (script->num_args + 1)) if (nparams != (script->num_args + 1))
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
gchar *text = NULL; gchar *text = NULL;
gchar *command; gchar *command;

18
plug-ins/script-fu/script-fu-scripts.c
View File

@ -779,7 +779,7 @@ script_fu_install_script (gpointer foo,
script->date, script->date,
menu_path, menu_path,
script->img_types, script->img_types,
PROC_TEMPORARY, GIMP_TEMPORARY,
script->num_args + 1, 0, script->num_args + 1, 0,
script->args, NULL, script->args, NULL,
script_fu_script_proc); script_fu_script_proc);
@ -812,7 +812,7 @@ script_fu_script_proc (gchar *name,
GimpParam **return_vals) GimpParam **return_vals)
{ {
static GimpParam values[1]; static GimpParam values[1];
GimpPDBStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunModeType run_mode; GimpRunModeType run_mode;
SFScript *script; SFScript *script;
gint min_args; gint min_args;
@ -821,16 +821,16 @@ script_fu_script_proc (gchar *name,
run_mode = params[0].data.d_int32; run_mode = params[0].data.d_int32;
if (! (script = script_fu_find_script (name))) if (! (script = script_fu_find_script (name)))
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
else else
{ {
if (script->num_args == 0) if (script->num_args == 0)
run_mode = RUN_NONINTERACTIVE; run_mode = GIMP_RUN_NONINTERACTIVE;
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
/* Determine whether the script is image based (runs on an image) */ /* Determine whether the script is image based (runs on an image) */
if (strncmp (script->description, "<Image>", 7) == 0) if (strncmp (script->description, "<Image>", 7) == 0)
{ {
@ -850,11 +850,11 @@ script_fu_script_proc (gchar *name,
break; break;
} }
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */ /* Make sure all the arguments are there! */
if (nparams != (script->num_args + 1)) if (nparams != (script->num_args + 1))
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
if (status == STATUS_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
gchar *text = NULL; gchar *text = NULL;
gchar *command; gchar *command;

22
plug-ins/script-fu/script-fu-server.c
View File

@ -165,19 +165,19 @@ extern LISP repl_return_val;
void void
script_fu_server_run (char *name, script_fu_server_run (char *name,
int nparams, int nparams,
GParam *params, GimpParam *params,
int *nreturn_vals, int *nreturn_vals,
GParam **return_vals) GimpParam **return_vals)
{ {
static GParam values[1]; static GimpParam values[1];
GStatusType status = STATUS_SUCCESS; GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GRunModeType run_mode; GimpRunModeType run_mode;
run_mode = params[0].data.d_int32; run_mode = params[0].data.d_int32;
switch (run_mode) switch (run_mode)
{ {
case RUN_INTERACTIVE: case GIMP_RUN_INTERACTIVE:
if (server_interface ()) if (server_interface ())
{ {
server_mode = TRUE; server_mode = TRUE;
@ -187,7 +187,7 @@ script_fu_server_run (char *name,
} }
break; break;
case RUN_NONINTERACTIVE: case GIMP_RUN_NONINTERACTIVE:
/* Set server_mode to TRUE */ /* Set server_mode to TRUE */
server_mode = TRUE; server_mode = TRUE;
@ -195,9 +195,9 @@ script_fu_server_run (char *name,
server_start (params[1].data.d_int32, params[2].data.d_string); server_start (params[1].data.d_int32, params[2].data.d_string);
break; break;
case RUN_WITH_LAST_VALS: case GIMP_RUN_WITH_LAST_VALS:
status = STATUS_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;
g_warning ("Script-Fu server does handle \"RUN_WITH_LAST_VALS\""); g_warning ("Script-Fu server does handle \"GIMP_RUN_WITH_LAST_VALS\"");
default: default:
break; break;
@ -206,7 +206,7 @@ script_fu_server_run (char *name,
*nreturn_vals = 1; *nreturn_vals = 1;
*return_vals = values; *return_vals = values;
values[0].type = PARAM_STATUS; values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status; values[0].data.d_status = status;
} }

12
plug-ins/script-fu/script-fu-server.h
View File

@ -19,12 +19,12 @@
#ifndef __SCRIPT_FU_SERVER_H__ #ifndef __SCRIPT_FU_SERVER_H__
#define __SCRIPT_FU_SERVER_H__ #define __SCRIPT_FU_SERVER_H__
void script_fu_server_run (char *name, void script_fu_server_run (gchar *name,
int nparams, gint nparams,
GParam *params, GimpParam *params,
int *nreturn_vals, gint *nreturn_vals,
GParam **return_vals); GimpParam **return_vals);
void script_fu_server_listen (gint timeout); void script_fu_server_listen (gint timeout);
#endif /* __SCRIPT_FU_SERVER__ */ #endif /* __SCRIPT_FU_SERVER__ */

14
plug-ins/script-fu/script-fu.c
View File

@ -314,7 +314,7 @@ init_procedures (void)
init_lsubr ("script-fu-register", script_fu_register_call); init_lsubr ("script-fu-register", script_fu_register_call);
init_lsubr ("script-fu-quit", script_fu_quit_call); init_lsubr ("script-fu-quit", script_fu_quit_call);
gimp_query_database (".*", ".*", ".*", ".*", ".*", ".*", ".*", &num_procs, &proc_list); gimp_procedural_db_query (".*", ".*", ".*", ".*", ".*", ".*", ".*", &num_procs, &proc_list);
/* Register each procedure as a scheme func */ /* Register each procedure as a scheme func */
for (i = 0; i < num_procs; i++) for (i = 0; i < num_procs; i++)
@ -413,12 +413,12 @@ init_constants (void)
setvar (cintern ("BLUR"), flocons (0), NIL); setvar (cintern ("BLUR"), flocons (0), NIL);
setvar (cintern ("SHARPEN"), flocons (1), NIL); setvar (cintern ("SHARPEN"), flocons (1), NIL);
setvar (cintern ("RGB_IMAGE"), flocons (0), NIL); setvar (cintern ("GIMP_RGB_IMAGE"), flocons (0), NIL);
setvar (cintern ("RGBA_IMAGE"), flocons (1), NIL); setvar (cintern ("GIMP_RGBA_IMAGE"), flocons (1), NIL);
setvar (cintern ("GRAY_IMAGE"), flocons (2), NIL); setvar (cintern ("GIMP_GRAY_IMAGE"), flocons (2), NIL);
setvar (cintern ("GRAYA_IMAGE"), flocons (3), NIL); setvar (cintern ("GIMP_GRAYA_IMAGE"), flocons (3), NIL);
setvar (cintern ("INDEXED_IMAGE"), flocons (4), NIL); setvar (cintern ("GIMP_INDEXED_IMAGE"), flocons (4), NIL);
setvar (cintern ("INDEXEDA_IMAGE"), flocons (5), NIL); setvar (cintern ("GIMP_INDEXEDA_IMAGE"), flocons (5), NIL);
/* Useful misc stuff */ /* Useful misc stuff */
setvar (cintern ("TRUE"), flocons (1), NIL); setvar (cintern ("TRUE"), flocons (1), NIL);