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

libgimp, plug-ins, extensions: gimp_image_procedure_new2() renamed gimp_image_procedure_new().

This commit is contained in:
Jehan 2023-10-01 18:23:57 +02:00
parent 5c8aa1f242
commit 1d50c81130
57 changed files with 225 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
extensions/goat-exercises/goat-exercise-c.c
View File

@ -103,9 +103,9 @@ goat_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
goat_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
goat_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

2
extensions/goat-exercises/goat-exercise-gjs.js
View File

@ -72,7 +72,7 @@ var Goat = GObject.registerClass({
return procedure;
}
run(procedure, run_mode, image, drawables, args, run_data) {
run(procedure, run_mode, image, drawables, config, run_data) {
/* TODO: localization. */
if (drawables.length != 1) {

2
extensions/goat-exercises/goat-exercise-lua.lua
View File

@ -41,7 +41,7 @@ function _(message)
return GLib.dgettext(nil, message);
end
function run(procedure, run_mode, image, drawables, args, run_data)
function run(procedure, run_mode, image, drawables, config, run_data)
-- procedure:new_return_values() crashes LGI so we construct the
-- GimpValueArray manually.
local retval = Gimp.ValueArray(1)

6
extensions/goat-exercises/goat-exercise-py3.py
View File

@ -37,8 +37,8 @@ class Goat (Gimp.PlugIn):
def do_create_procedure(self, name):
procedure = Gimp.ImageProcedure.new(self, name,
Gimp.PDBProcType.PLUGIN,
self.run, None)
Gimp.PDBProcType.PLUGIN,
self.run, None)
procedure.set_image_types("*")
procedure.set_sensitivity_mask (Gimp.ProcedureSensitivityMask.DRAWABLE)
@ -54,7 +54,7 @@ class Goat (Gimp.PlugIn):
return procedure
def run(self, procedure, run_mode, image, n_drawables, drawables, args, run_data):
def run(self, procedure, run_mode, image, n_drawables, drawables, config, run_data):
if n_drawables != 1:
msg = _("Procedure '{}' only works with one drawable.").format(procedure.get_name())
error = GLib.Error.new_literal(Gimp.PlugIn.error_quark(), msg, 0)

2
extensions/goat-exercises/goat-exercise-vala.vala
View File

@ -57,7 +57,7 @@ public class Goat : Gimp.PlugIn {
Gimp.RunMode run_mode,
Gimp.Image image,
Gimp.Drawable[] drawables,
Gimp.ValueArray args) {
Gimp.ProcedureConfig config) {
var drawable = drawables[0];
if (run_mode == Gimp.RunMode.INTERACTIVE) {

1
libgimp/gimp.def
View File

@ -471,7 +471,6 @@ EXPORTS
gimp_image_policy_rotate
gimp_image_procedure_get_type
gimp_image_procedure_new
gimp_image_procedure_new2
gimp_image_raise_item
gimp_image_raise_item_to_top
gimp_image_remove_channel

102
libgimp/gimpimageprocedure.c
View File

@ -48,7 +48,6 @@
struct _GimpImageProcedurePrivate
{
GimpRunImageFunc run_func;
GimpRunImageFunc2 run_func2;
gpointer run_data;
GDestroyNotify run_data_destroy;
};
@ -145,14 +144,16 @@ static GimpValueArray *
gimp_image_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args)
{
GimpImageProcedure *image_proc = GIMP_IMAGE_PROCEDURE (procedure);
GimpValueArray *remaining;
GimpValueArray *return_values;
GimpRunMode run_mode;
GimpImage *image;
GimpDrawable **drawables;
gint n_drawables;
gint i;
GimpImageProcedure *image_proc = GIMP_IMAGE_PROCEDURE (procedure);
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
GimpProcedureConfig *config;
GimpValueArray *remaining;
GimpValueArray *return_values;
GimpRunMode run_mode;
GimpImage *image;
GimpDrawable **drawables;
gint n_drawables;
gint i;
run_mode = GIMP_VALUES_GET_ENUM (args, 0);
image = GIMP_VALUES_GET_IMAGE (args, 1);
@ -168,45 +169,31 @@ gimp_image_procedure_run (GimpProcedure *procedure,
gimp_value_array_append (remaining, value);
}
if (image_proc->priv->run_func2)
{
GimpProcedureConfig *config;
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
config = gimp_procedure_create_config (procedure);
gimp_procedure_config_begin_run (config, image, run_mode, remaining);
config = gimp_procedure_create_config (procedure);
gimp_procedure_config_begin_run (config, image, run_mode, remaining);
return_values = image_proc->priv->run_func (procedure,
run_mode,
image, n_drawables, drawables,
config,
image_proc->priv->run_data);
return_values = image_proc->priv->run_func2 (procedure,
run_mode,
image, n_drawables, drawables,
config,
image_proc->priv->run_data);
if (return_values != NULL &&
gimp_value_array_length (return_values) > 0 &&
G_VALUE_HOLDS_ENUM (gimp_value_array_index (return_values, 0)))
status = GIMP_VALUES_GET_ENUM (return_values, 0);
if (return_values != NULL &&
gimp_value_array_length (return_values) > 0 &&
G_VALUE_HOLDS_ENUM (gimp_value_array_index (return_values, 0)))
status = GIMP_VALUES_GET_ENUM (return_values, 0);
gimp_procedure_config_end_run (config, status);
gimp_procedure_config_end_run (config, status);
/* This is debug printing to help plug-in developers figure out best
* practices.
*/
if (G_OBJECT (config)->ref_count > 1)
g_printerr ("%s: ERROR: the GimpProcedureConfig object was refed "
"by plug-in, it MUST NOT do that!\n", G_STRFUNC);
/* This is debug printing to help plug-in developers figure out best
* practices.
*/
if (G_OBJECT (config)->ref_count > 1)
g_printerr ("%s: ERROR: the GimpProcedureConfig object was refed "
"by plug-in, it MUST NOT do that!\n", G_STRFUNC);
g_object_unref (config);
}
else
{
return_values = image_proc->priv->run_func (procedure,
run_mode,
image, n_drawables, drawables,
remaining,
image_proc->priv->run_data);
}
g_object_unref (config);
gimp_value_array_unref (remaining);
return return_values;
@ -272,7 +259,7 @@ gimp_image_procedure_set_sensitivity (GimpProcedure *procedure,
*
* Since: 3.0
**/
GimpProcedure *
GimpProcedure *
gimp_image_procedure_new (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
@ -300,32 +287,3 @@ gimp_image_procedure_new (GimpPlugIn *plug_in,
return GIMP_PROCEDURE (procedure);
}
GimpProcedure *
gimp_image_procedure_new2 (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
GimpRunImageFunc2 run_func,
gpointer run_data,
GDestroyNotify run_data_destroy)
{
GimpImageProcedure *procedure;
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL);
g_return_val_if_fail (gimp_is_canonical_identifier (name), NULL);
g_return_val_if_fail (proc_type != GIMP_PDB_PROC_TYPE_INTERNAL, NULL);
g_return_val_if_fail (proc_type != GIMP_PDB_PROC_TYPE_EXTENSION, NULL);
g_return_val_if_fail (run_func != NULL, NULL);
procedure = g_object_new (GIMP_TYPE_IMAGE_PROCEDURE,
"plug-in", plug_in,
"name", name,
"procedure-type", proc_type,
NULL);
procedure->priv->run_func2 = run_func;
procedure->priv->run_data = run_data;
procedure->priv->run_data_destroy = run_data_destroy;
return GIMP_PROCEDURE (procedure);
}

35
libgimp/gimpimageprocedure.h
View File

@ -36,7 +36,7 @@ G_BEGIN_DECLS
* @image: the #GimpImage.
* @n_drawables: the number of #GimpDrawable-s.
* @drawables: (array length=n_drawables): the input #GimpDrawable-s.
* @args: the @procedure's remaining arguments.
* @config: the @procedure's remaining arguments.
* @run_data: (closure): the run_data given in gimp_image_procedure_new().
*
* The image function is run during the lifetime of the GIMP session,
@ -51,34 +51,9 @@ typedef GimpValueArray * (* GimpRunImageFunc) (GimpProcedure *procedure,
GimpImage *image,
gint n_drawables,
GimpDrawable **drawables,
const GimpValueArray *args,
GimpProcedureConfig *config,
gpointer run_data);
/**
* GimpRunImageFunc2:
* @procedure: the #GimpProcedure that runs.
* @run_mode: the #GimpRunMode.
* @image: the #GimpImage.
* @n_drawables: the number of #GimpDrawable-s.
* @drawables: (array length=n_drawables): the input #GimpDrawable-s.
* @config: the @procedure's remaining arguments.
* @run_data: (closure): the run_data given in gimp_image_procedure_new().
*
* The image function is run during the lifetime of the GIMP session,
* each time a plug-in image procedure is called.
*
* Returns: (transfer full): the @procedure's return values.
*
* Since: 3.0
**/
typedef GimpValueArray * (* GimpRunImageFunc2) (GimpProcedure *procedure,
GimpRunMode run_mode,
GimpImage *image,
gint n_drawables,
GimpDrawable **drawables,
GimpProcedureConfig *config,
gpointer run_data);
#define GIMP_TYPE_IMAGE_PROCEDURE (gimp_image_procedure_get_type ())
#define GIMP_IMAGE_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_IMAGE_PROCEDURE, GimpImageProcedure))
@ -113,12 +88,6 @@ GimpProcedure * gimp_image_procedure_new (GimpPlugIn *plug_in,
GimpRunImageFunc run_func,
gpointer run_data,
GDestroyNotify run_data_destroy);
GimpProcedure * gimp_image_procedure_new2 (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
GimpRunImageFunc2 run_func,
gpointer run_data,
GDestroyNotify run_data_destroy);
G_END_DECLS

6
plug-ins/common/align-layers.c
View File

@ -166,9 +166,9 @@ align_layers_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
align_layers_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
align_layers_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

30
plug-ins/common/animation-optimize.c
View File

@ -167,9 +167,9 @@ optimize_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, OPTIMIZE_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
gimp_procedure_set_sensitivity_mask (procedure,
GIMP_PROCEDURE_SENSITIVE_DRAWABLE |
@ -195,9 +195,9 @@ optimize_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, OPTIMIZE_DIFF_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
gimp_procedure_set_sensitivity_mask (procedure,
GIMP_PROCEDURE_SENSITIVE_DRAWABLE |
@ -220,9 +220,9 @@ optimize_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, UNOPTIMIZE_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
gimp_procedure_set_sensitivity_mask (procedure,
GIMP_PROCEDURE_SENSITIVE_DRAWABLE |
@ -242,9 +242,9 @@ optimize_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, REMOVE_BACKDROP_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
gimp_procedure_set_sensitivity_mask (procedure,
GIMP_PROCEDURE_SENSITIVE_DRAWABLE |
@ -263,9 +263,9 @@ optimize_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, FIND_BACKDROP_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
optimize_run, NULL, NULL);
gimp_procedure_set_sensitivity_mask (procedure,
GIMP_PROCEDURE_SENSITIVE_DRAWABLE |

6
plug-ins/common/animation-play.c
View File

@ -317,9 +317,9 @@ play_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
play_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
play_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/blinds.c
View File

@ -129,9 +129,9 @@ blinds_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
blinds_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
blinds_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/border-average.c
View File

@ -113,9 +113,9 @@ border_average_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
border_average_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
border_average_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/checkerboard.c
View File

@ -111,9 +111,9 @@ checkerboard_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
checkerboard_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
checkerboard_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/cml-explorer.c
View File

@ -497,9 +497,9 @@ explorer_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
explorer_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
explorer_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

12
plug-ins/common/colormap-remap.c
View File

@ -173,9 +173,9 @@ remap_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC_REMAP))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
remap_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
remap_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "INDEXED*");
gimp_procedure_set_sensitivity_mask (procedure,
@ -207,9 +207,9 @@ remap_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, PLUG_IN_PROC_SWAP))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
remap_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
remap_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "INDEXED*");
gimp_procedure_set_sensitivity_mask (procedure,

18
plug-ins/common/compose.c
View File

@ -390,9 +390,9 @@ compose_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, COMPOSE_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
compose_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
compose_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,
@ -458,9 +458,9 @@ compose_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, DRAWABLE_COMPOSE_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
compose_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
compose_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,
@ -521,9 +521,9 @@ compose_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, RECOMPOSE_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
compose_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
compose_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/contrast-retinex.c
View File

@ -167,9 +167,9 @@ retinex_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
retinex_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
retinex_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/crop-zealous.c
View File

@ -103,9 +103,9 @@ crop_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
crop_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
crop_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/curve-bend.c
View File

@ -409,9 +409,9 @@ bender_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
bender_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
bender_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, PLUG_IN_IMAGE_TYPES);
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/decompose.c
View File

@ -271,9 +271,9 @@ decompose_create_procedure (GimpPlugIn *plug_in,
g_string_append_c (type_desc, '"');
}
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
decompose_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
decompose_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/depth-merge.c
View File

@ -193,9 +193,9 @@ merge_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
merge_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
merge_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/despeckle.c
View File

@ -158,9 +158,9 @@ despeckle_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
despeckle_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
despeckle_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/destripe.c
View File

@ -115,9 +115,9 @@ destripe_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
destripe_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
destripe_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/film.c
View File

@ -167,9 +167,9 @@ film_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
film_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
film_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

20
plug-ins/common/gradient-map.c
View File

@ -119,11 +119,11 @@ map_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, GRADMAP_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
map_run,
GINT_TO_POINTER (GRADIENT_MODE),
NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
map_run,
GINT_TO_POINTER (GRADIENT_MODE),
NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,
@ -155,11 +155,11 @@ map_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, PALETTEMAP_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
map_run,
GINT_TO_POINTER (PALETTE_MODE),
NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
map_run,
GINT_TO_POINTER (PALETTE_MODE),
NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/grid.c
View File

@ -146,9 +146,9 @@ grid_create_procedure (GimpPlugIn *plug_in,
{
const GimpRGB black = { 0.0, 0.0, 0.0, 1.0 };
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
grid_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
grid_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/guillotine.c
View File

@ -99,9 +99,9 @@ guillotine_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
guillotine_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
guillotine_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/hot.c
View File

@ -238,9 +238,9 @@ hot_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
hot_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
hot_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/jigsaw.c
View File

@ -387,9 +387,9 @@ jigsaw_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
jigsaw_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
jigsaw_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/mail.c
View File

@ -175,9 +175,9 @@ mail_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
mail_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
mail_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/nl-filter.c
View File

@ -147,9 +147,9 @@ nlfilter_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
nlfilter_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
nlfilter_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB, GRAY");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/qbist.c
View File

@ -174,9 +174,9 @@ qbist_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
qbist_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
qbist_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/sample-colorize.c
View File

@ -315,9 +315,9 @@ colorize_create_procedure (GimpPlugIn *plug_in,
" (the image with the dst_drawable is converted to RGB if necessary)"
" The sample_drawable should be of type RGB or RGBA";
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
colorize_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
colorize_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/smooth-palette.c
View File

@ -110,9 +110,9 @@ palette_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
palette_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
palette_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/sparkle.c
View File

@ -166,9 +166,9 @@ sparkle_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
sparkle_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
sparkle_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/sphere-designer.c
View File

@ -399,9 +399,9 @@ designer_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
designer_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
designer_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/tile-small.c
View File

@ -260,9 +260,9 @@ tile_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
tile_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
tile_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/tile.c
View File

@ -120,9 +120,9 @@ tile_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
tile_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
tile_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/van-gogh-lic.c
View File

@ -867,9 +867,9 @@ lic_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
lic_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
lic_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/warp.c
View File

@ -208,9 +208,9 @@ warp_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
warp_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
warp_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/common/wavelet-decompose.c
View File

@ -107,9 +107,9 @@ wavelet_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
wavelet_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
wavelet_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

18
plug-ins/file-dds/dds.c
View File

@ -315,9 +315,9 @@ dds_create_procedure (GimpPlugIn *plug_in,
#if 0
else if (! strcmp (name, DECODE_YCOCG_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
dds_decode, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
dds_decode, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGBA");
gimp_procedure_set_sensitivity_mask (procedure,
@ -337,9 +337,9 @@ dds_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, DECODE_YCOCG_SCALED_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
dds_decode, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
dds_decode, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGBA");
gimp_procedure_set_sensitivity_mask (procedure,
@ -361,9 +361,9 @@ dds_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, DECODE_ALPHA_EXP_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
dds_decode, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
dds_decode, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGBA");
gimp_procedure_set_sensitivity_mask (procedure,

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

@ -164,9 +164,9 @@ flame_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
flame_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
flame_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/fractal-explorer/fractal-explorer.c
View File

@ -231,9 +231,9 @@ explorer_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
explorer_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
explorer_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

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

@ -159,9 +159,9 @@ gfig_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
gfig_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
gfig_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

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

@ -110,9 +110,9 @@ gimpressionist_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
gimpressionist_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
gimpressionist_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/gradient-flare/gradient-flare.c
View File

@ -798,9 +798,9 @@ gflare_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
gflare_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
gflare_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/ifs-compose/ifs-compose.c
View File

@ -422,9 +422,9 @@ ifs_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
ifs_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
ifs_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/imagemap/imap_main.c
View File

@ -209,9 +209,9 @@ imap_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
imap_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
imap_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/lighting/lighting-main.c
View File

@ -110,9 +110,9 @@ lighting_create_procedure (GimpPlugIn *plug_in,
{
GimpRGB white = { 1.0, 1.0, 1.0, 1.0 };
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
lighting_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
lighting_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*");
gimp_procedure_set_sensitivity_mask (procedure,

2
plug-ins/map-object/map-object-main.c
View File

@ -110,7 +110,7 @@ map_create_procedure (GimpPlugIn *plug_in,
{
GimpRGB white = { 1.0, 1.0, 1.0, 1.0 };
procedure = gimp_image_procedure_new2 (plug_in, name,
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
map_run, NULL, NULL);

6
plug-ins/pagecurl/pagecurl.c
View File

@ -205,9 +205,9 @@ pagecurl_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
pagecurl_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
pagecurl_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
gimp_procedure_set_sensitivity_mask (procedure,

12
plug-ins/print/print.c
View File

@ -154,9 +154,9 @@ print_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PRINT_PROC_NAME))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
print_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
print_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,
@ -182,9 +182,9 @@ print_create_procedure (GimpPlugIn *plug_in,
#ifndef EMBED_PAGE_SETUP
else if (! strcmp (name, PAGE_SETUP_PROC_NAME))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
print_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
print_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");

10
plug-ins/script-fu/libscriptfu/script-fu-script.c
View File

@ -160,11 +160,11 @@ script_fu_script_create_PDB_procedure (GimpPlugIn *plug_in,
g_debug ("script_fu_script_create_PDB_procedure: %s, plugin type %i, image_proc",
script->name, plug_in_type);
procedure = gimp_image_procedure_new2 (plug_in, script->name,
plug_in_type,
(GimpRunImageFunc2) script_fu_run_image_procedure,
script, /* user_data, pointer in extension-script-fu process */
NULL);
procedure = gimp_image_procedure_new (plug_in, script->name,
plug_in_type,
(GimpRunImageFunc) script_fu_run_image_procedure,
script, /* user_data, pointer in extension-script-fu process */
NULL);
script_fu_script_set_proc_metadata (procedure, script);

6
plug-ins/selection-to-path/selection-to-path.c
View File

@ -129,9 +129,9 @@ sel2path_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_PROC))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
sel2path_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
sel2path_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,

6
plug-ins/twain/twain.c
View File

@ -193,9 +193,9 @@ twain_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, PLUG_IN_NAME))
{
procedure = gimp_image_procedure_new2 (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
twain_run, NULL, NULL);
procedure = gimp_image_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
twain_run, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
gimp_procedure_set_sensitivity_mask (procedure,