static gint32
tile (gint32 image_id,
gint32 drawable_id,
gint32 *layer_id)
{
GimpPixelRgn src_rgn;
GimpPixelRgn dest_rgn;
GimpDrawable *drawable;
GimpDrawable *new_layer;
GimpImageBaseType image_type = GIMP_RGB;
gint32 new_image_id = 0;
gint old_width;
gint old_height;
gint i, j;
gint progress;
gint max_progress;
gpointer pr;
/* sanity check parameters */
if (tvals.new_width < 1 || tvals.new_height < 1)
{
*layer_id = -1;
return -1;
}
/* initialize */
old_width = gimp_drawable_width (drawable_id);
old_height = gimp_drawable_height (drawable_id);
if (tvals.new_image)
{
/* create a new image */
switch (gimp_drawable_type (drawable_id))
{
case GIMP_RGB_IMAGE:
case GIMP_RGBA_IMAGE:
image_type = GIMP_RGB;
break;
case GIMP_GRAY_IMAGE:
case GIMP_GRAYA_IMAGE:
image_type = GIMP_GRAY;
break;
case GIMP_INDEXED_IMAGE:
case GIMP_INDEXEDA_IMAGE:
image_type = GIMP_INDEXED;
break;
}
new_image_id = gimp_image_new (tvals.new_width, tvals.new_height,
image_type);
gimp_image_undo_disable (new_image_id);
*layer_id = gimp_layer_new (new_image_id, _("Background"),
tvals.new_width, tvals.new_height,
gimp_drawable_type (drawable_id),
100, GIMP_NORMAL_MODE);
if (*layer_id == -1)
return -1;
gimp_image_add_layer (new_image_id, *layer_id, 0);
new_layer = gimp_drawable_get (*layer_id);
/* Get the source drawable */
drawable = gimp_drawable_get (drawable_id);
}
else
{
gimp_image_undo_group_start (image_id);
gimp_image_resize (image_id,
tvals.new_width, tvals.new_height,
0, 0);
if (gimp_drawable_is_layer (drawable_id))
gimp_layer_resize (drawable_id,
tvals.new_width, tvals.new_height,
0, 0);
/* Get the source drawable */
drawable = gimp_drawable_get (drawable_id);
new_layer = drawable;
}
/* progress */
progress = 0;
max_progress = tvals.new_width * tvals.new_height;
/* tile... */
for (i = 0; i < tvals.new_height; i += old_height)
{
gint height = old_height;
if (height + i > tvals.new_height)
height = tvals.new_height - i;
for (j = 0; j < tvals.new_width; j += old_width)
{
gint width = old_width;
gint c;
if (width + j > tvals.new_width)
width = tvals.new_width - j;
gimp_pixel_rgn_init (&src_rgn, drawable,
0, 0, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, new_layer,
j, i, width, height, TRUE, FALSE);
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn), c = 0;
pr != NULL;
pr = gimp_pixel_rgns_process (pr), c++)
{
gint k;
for (k = 0; k < src_rgn.h; k++)
memcpy (dest_rgn.data + k * dest_rgn.rowstride,
src_rgn.data + k * src_rgn.rowstride,
src_rgn.w * src_rgn.bpp);
progress += src_rgn.w * src_rgn.h;
if (c % 16 == 0)
gimp_progress_update ((gdouble) progress /
(gdouble) max_progress);
}
}
}
gimp_drawable_update (new_layer->drawable_id,
0, 0, new_layer->width, new_layer->height);
gimp_drawable_detach (drawable);
if (tvals.new_image)
{
gimp_drawable_detach (new_layer);
/* copy the colormap, if necessary */
if (image_type == GIMP_INDEXED)
{
guchar *cmap;
gint ncols;
cmap = gimp_image_get_colormap (image_id, &ncols);
gimp_image_set_colormap (new_image_id, cmap, ncols);
g_free (cmap);
}
gimp_image_undo_enable (new_image_id);
}
else
{
gimp_image_undo_group_end (image_id);
}
return new_image_id;
}
gint
dialog_I (PlugInImageVals * image_vals,
PlugInDrawableVals * drawable_vals,
PlugInVals * vals,
PlugInUIVals * ui_vals,
PlugInColVals * col_vals,
PlugInDialogVals * dialog_vals)
{
gint32 image_ID;
gint32 layer_ID;
gint orig_width, orig_height;
GtkWidget *main_hbox;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *vbox3;
GtkWidget *hbox;
GtkWidget *hbox2;
GtkWidget *frame;
GtkWidget *filler;
GtkWidget *pres_use_image;
GtkWidget *disc_use_image;
GtkWidget *rigmask_use_image;
//GtkWidget *noninter_button;
GtkWidget *resetvalues_event_box;
GtkWidget *resetvalues_button;
GtkWidget *resetvalues_icon;
GtkWidget *flatten_event_box;
GtkWidget *flatten_button;
GtkWidget *flatten_icon;
GtkWidget *show_info_event_box;
GtkWidget *show_info_button;
GtkWidget *show_info_icon;
GtkWidget *dump_event_box;
GtkWidget *dump_button;
GtkWidget *dump_icon;
//GtkWidget *lastvalues_event_box;
//GtkWidget *lastvalues_button;
//GtkWidget *lastvalues_icon;
gboolean has_mask = FALSE;
GimpUnit unit;
gdouble xres, yres;
GtkWidget * v_separator;
GtkWidget *info_title_label;
GtkWidget * info_label;
CarverData * carver_data;
image_ID = image_vals->image_ID;
layer_ID = drawable_vals->layer_ID;
state = g_new (PlugInVals, 1);
memcpy (state, vals, sizeof (PlugInVals));
ui_state = g_new (PlugInUIVals, 1);
memcpy (ui_state, ui_vals, sizeof (PlugInUIVals));
dialog_state = dialog_vals;
orig_width = gimp_drawable_width (layer_ID);
orig_height = gimp_drawable_height (layer_ID);
g_assert (gimp_drawable_is_layer (layer_ID) == TRUE);
interface_I_data.orig_width = orig_width;
interface_I_data.orig_height = orig_height;
interface_I_data.col_vals = col_vals;
interface_I_data.vmap_layer_ID = -1;
reader_go = TRUE;
if (gimp_layer_get_mask (layer_ID) != -1)
{
has_mask = TRUE;
}
dlg = gtk_dialog_new_with_buttons (_("GIMP LiquidRescale Plug-In"),
NULL, 0,
//GIMP_STOCK_RESET, RESPONSE_RESET,
//GTK_STOCK_REFRESH, RESPONSE_REFRESH,
GTK_STOCK_GO_BACK, RESPONSE_NONINTERACTIVE,
GTK_STOCK_CLOSE, GTK_RESPONSE_OK, NULL);
gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE);
gtk_window_set_keep_above(GTK_WINDOW (dlg), TRUE);
if (dialog_state->has_pos)
{
//printf("move window, x,y=%i,%i\n", dialog_state->x, dialog_state->y); fflush(stdout);
gtk_window_move (GTK_WINDOW(dlg), dialog_state->x, dialog_state->y);
dialog_state->has_pos = FALSE;
}
g_signal_connect (dlg, "response", G_CALLBACK (callback_dialog_I_response),
(gpointer) (NULL));
/* dlg_tips = gtk_tooltips_new (); */
main_hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG (dlg))), main_hbox);
vbox = gtk_vbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
/* New size */
frame = gimp_frame_new (_("Set width and height"));
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
hbox = gtk_hbox_new (FALSE, 4);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
vbox3 = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (hbox), vbox3, FALSE, FALSE, 0);
gtk_widget_show (vbox3);
unit = gimp_image_get_unit (image_ID);
gimp_image_get_resolution (image_ID, &xres, &yres);
coordinates =
alt_coordinates_new (unit, "%p", TRUE, TRUE, SPIN_BUTTON_WIDTH,
ALT_SIZE_ENTRY_UPDATE_SIZE, ui_state->chain_active,
TRUE, _("Width:"), state->new_width, xres, 2,
GIMP_MAX_IMAGE_SIZE, 0, orig_width,
_("Height:"), state->new_height, yres, 2,
GIMP_MAX_IMAGE_SIZE, 0, orig_height);
interface_I_data.coordinates = coordinates;
g_signal_connect (ALT_SIZE_ENTRY (coordinates), "value-changed",
G_CALLBACK (callback_size_changed),
(gpointer) & interface_I_data);
g_signal_connect (ALT_SIZE_ENTRY (coordinates), "refval-changed",
G_CALLBACK (callback_size_changed),
(gpointer) & interface_I_data);
g_signal_connect (ALT_SIZE_ENTRY (coordinates), "coordinates-alarm",
G_CALLBACK (callback_alarm_triggered),
(gpointer) & interface_I_data);
gtk_box_pack_start (GTK_BOX (vbox3), coordinates, FALSE, FALSE, 0);
gtk_widget_show (coordinates);
/* Aux layer usage icons */
hbox2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 4);
gtk_box_pack_start (GTK_BOX (vbox3), hbox2, FALSE, FALSE, 0);
gtk_widget_show (hbox2);
filler = gtk_image_new ();
gtk_box_pack_start (GTK_BOX (hbox2), filler, TRUE, TRUE, 0);
gtk_widget_show (filler);
filler = gtk_image_new ();
gtk_box_pack_end (GTK_BOX (hbox2), filler, TRUE, TRUE, 0);
gtk_widget_show (filler);
pres_use_image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_GREEN,
GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox2), pres_use_image, FALSE, FALSE, 0);
gtk_widget_show (pres_use_image);
disc_use_image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_RED,
GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox2), disc_use_image, FALSE, FALSE, 0);
gtk_widget_show (disc_use_image);
rigmask_use_image = gtk_image_new_from_stock (GIMP_STOCK_CHANNEL_BLUE,
GTK_ICON_SIZE_MENU);
gtk_widget_show (rigmask_use_image);
gtk_box_pack_start (GTK_BOX (hbox2), rigmask_use_image, FALSE, FALSE, 0);
update_info_aux_use_icons(vals, ui_vals, pres_use_image, disc_use_image, rigmask_use_image);
/* Reset size button */
vbox2 = gtk_vbox_new (FALSE, 4);
gtk_box_pack_end (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
gtk_widget_show (vbox2);
resetvalues_event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (vbox2), resetvalues_event_box, FALSE, FALSE,
0);
gtk_widget_show (resetvalues_event_box);
gimp_help_set_help_data (resetvalues_event_box,
_
("Reset width and height to their original values"),
NULL);
resetvalues_button = gtk_button_new ();
resetvalues_icon =
gtk_image_new_from_stock (GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (resetvalues_button), resetvalues_icon);
gtk_widget_show (resetvalues_icon);
gtk_container_add (GTK_CONTAINER (resetvalues_event_box),
resetvalues_button);
gtk_widget_show (resetvalues_button);
g_signal_connect (resetvalues_button, "clicked",
G_CALLBACK (callback_resetvalues_button),
(gpointer) & interface_I_data);
/* Map info */
v_separator = gtk_vseparator_new();
gtk_box_pack_start (GTK_BOX (main_hbox), v_separator, TRUE, TRUE, 0);
gtk_widget_show(v_separator);
vbox = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
hbox2 = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0);
gtk_widget_show (hbox2);
info_title_label = gtk_label_new ("");
/* Please keep the <b> and </b> tags in translations */
gtk_label_set_markup(GTK_LABEL(info_title_label), _("<b>Map</b>"));
gtk_box_pack_start (GTK_BOX (hbox2), info_title_label, FALSE, FALSE, 0);
gtk_widget_show (info_title_label);
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
vbox2 = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
gtk_widget_show (vbox2);
show_info_event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (vbox2), show_info_event_box, FALSE, FALSE,
0);
gtk_widget_show (show_info_event_box);
gimp_help_set_help_data (show_info_event_box,
_
("Show/hide internal map information"),
NULL);
show_info_button = gtk_toggle_button_new ();
show_info_icon =
gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (show_info_button), show_info_icon);
gtk_widget_show (show_info_icon);
gtk_container_add (GTK_CONTAINER (show_info_event_box),
show_info_button);
gtk_widget_show (show_info_button);
g_signal_connect (show_info_button, "toggled",
G_CALLBACK (callback_show_info_button),
(gpointer) & interface_I_data);
flatten_event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (vbox2), flatten_event_box, FALSE, FALSE,
0);
gtk_widget_show (flatten_event_box);
gimp_help_set_help_data (flatten_event_box,
_
("Reset the internal map"),
NULL);
flatten_button = gtk_button_new ();
flatten_icon =
gtk_image_new_from_stock (GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (flatten_button), flatten_icon);
gtk_widget_show (flatten_icon);
gtk_container_add (GTK_CONTAINER (flatten_event_box),
flatten_button);
gtk_widget_show (flatten_button);
g_signal_connect (flatten_button, "clicked",
G_CALLBACK (callback_flatten_button),
(gpointer) & interface_I_data);
dump_event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (vbox2), dump_event_box, FALSE, FALSE,
0);
gtk_widget_show (dump_event_box);
gimp_help_set_help_data (dump_event_box,
_
("Dump the internal map on a new layer (RGB images only)"),
NULL);
dump_button = gtk_button_new ();
dump_icon =
gtk_image_new_from_stock (GIMP_STOCK_VISIBLE, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (dump_button), dump_icon);
gtk_widget_show (dump_icon);
gtk_container_add (GTK_CONTAINER (dump_event_box),
dump_button);
gtk_widget_show (dump_button);
g_signal_connect (dump_button, "clicked",
G_CALLBACK (callback_dump_button),
(gpointer) & interface_I_data);
gtk_widget_set_sensitive(dump_button, FALSE);
interface_I_data.dump_button = dump_button;
info_label = gtk_label_new("");
//set_info_label_text (info_label, orig_width, orig_height, 0, 0, state->enl_step / 100);
gtk_label_set_selectable(GTK_LABEL(info_label), TRUE);
//gtk_container_add (GTK_CONTAINER (info_frame), info_label);
gtk_box_pack_start (GTK_BOX (hbox), info_label, TRUE, TRUE, 0);
gtk_label_set_justify(GTK_LABEL (info_label), GTK_JUSTIFY_LEFT);
gtk_widget_show (info_label);
//interface_I_data.info_frame = info_frame;
interface_I_data.info_label = info_label;
callback_show_info_button(show_info_button, (gpointer) &interface_I_data);
/*
noninter_button = gtk_button_new_with_mnemonic ("_Non-interactive");
g_signal_connect (GTK_BUTTON (noninter_button), "clicked",
G_CALLBACK (callback_noninter_button), (gpointer) dlg);
gtk_box_pack_start (GTK_BOX (vbox2), noninter_button, FALSE, FALSE, 0);
gtk_widget_show (noninter_button);
*/
/* Initialize the carver */
AUX_LAYER_STATUS(state->pres_layer_ID, ui_state->pres_status);
AUX_LAYER_STATUS(state->disc_layer_ID, ui_state->disc_status);
AUX_LAYER_STATUS(state->rigmask_layer_ID, ui_state->rigmask_status);
gimp_image_undo_group_start(image_ID);
carver_data = render_init_carver(image_vals, drawable_vals, state, TRUE);
gimp_image_undo_group_end(image_ID);
if (carver_data == NULL)
{
return RESPONSE_FATAL;
}
interface_I_data.carver_data = carver_data;
image_vals->image_ID = carver_data->image_ID;
drawable_vals->layer_ID = carver_data->layer_ID;
set_info_label_text (&interface_I_data);
//set_alarm (ALARM_DELAY);
size_changed = 1;
/* register size reader */
g_timeout_add (READER_INTERVAL, check_size_changes, NULL);
/* Show the main containers */
gtk_widget_show (main_hbox);
gtk_widget_show (dlg);
gtk_main ();
lqr_carver_destroy (carver_data->carver);
switch (dialog_I_response)
{
case RESPONSE_NONINTERACTIVE:
switch (state->output_target)
{
case OUTPUT_TARGET_NEW_LAYER:
case OUTPUT_TARGET_NEW_IMAGE:
state->output_target = OUTPUT_TARGET_SAME_LAYER;
break;
case OUTPUT_TARGET_SAME_LAYER:
default:
break;
}
case GTK_RESPONSE_OK:
/* Save ui values */
ui_state->chain_active =
gimp_chain_button_get_active (GIMP_COORDINATES_CHAINBUTTON
(coordinates));
/* save all */
memcpy (vals, state, sizeof (PlugInVals));
memcpy (ui_vals, ui_state, sizeof (PlugInUIVals));
break;
default:
break;
}
gtk_widget_destroy (dlg);
reader_go = FALSE;
return dialog_I_response;
}
/* -----------------------------
* gap_fg_matting_exec_apply_run
* -----------------------------
* handle undo, progress init and
* apply the processing functions
*/
gint32
gap_fg_matting_exec_apply_run (gint32 image_id, gint32 drawable_id
, gboolean doProgress, gboolean doFlush
, GapFgExtractValues *fgValPtr)
{
gint32 retLayerId;
gint32 oldLayerMaskId;
gint32 triMapOrig;
gint32 triMapRelevant;
gint32 dummyLayerId;
GimpDrawable *maskDrawable;
GimpDrawable *activeDrawable;
/* dont operate on other drawables than layers */
g_return_val_if_fail (gimp_drawable_is_layer(drawable_id), -1);
globalDoProgress = doProgress;
triMapOrig = fgValPtr->tri_map_drawable_id;
/* try to use layermask as tri-mask
* in case negative id was specified by the caller
*/
oldLayerMaskId = gimp_layer_get_mask(drawable_id);
if (fgValPtr->tri_map_drawable_id < 0)
{
fgValPtr->tri_map_drawable_id = oldLayerMaskId;
}
gimp_image_undo_group_start (image_id);
if (doProgress)
{
gimp_progress_init (_("Foreground Extract"));
}
activeDrawable = gimp_drawable_get (drawable_id);
triMapRelevant = p_tri_map_preprocessing (activeDrawable, fgValPtr, &dummyLayerId);
maskDrawable = gimp_drawable_get(triMapRelevant);
if (maskDrawable == NULL)
{
gimp_image_undo_group_end (image_id);
gimp_drawable_detach (activeDrawable);
printf("ERROR: no valid tri-mask was specified\n");
return (-1);
}
if(gap_debug)
{
printf("gap_fg_matting_exec_apply_run START: drawableID:%d triMapOrig:%d tri_map_drawable_id:%d triMapRelevant:%d\n"
" create_layermask:%d lock_color:%d "
" create_result:%d colordiff_threshold:%.5f"
"\n"
, (int)drawable_id
, (int)triMapOrig
, (int)fgValPtr->tri_map_drawable_id
, (int)triMapRelevant
, (int)fgValPtr->create_layermask
, (int)fgValPtr->lock_color
, (int)fgValPtr->create_result
, (float)fgValPtr->colordiff_threshold
);
}
retLayerId = gap_drawable_foreground_extract (activeDrawable, maskDrawable, fgValPtr);
gimp_drawable_detach (maskDrawable);
if(dummyLayerId >= 0)
{
if(gap_debug)
{
printf("removing dummy layer:%d\n"
,(int) dummyLayerId
);
}
gimp_image_remove_layer(image_id, dummyLayerId);
}
if (doProgress)
{
gimp_progress_update(1.0);
}
gimp_image_undo_group_end (image_id);
if(gap_debug)
{
printf("gap_fg_matting_exec_apply_run DONE: retLayerId:%d\n"
, (int)retLayerId
);
}
if (doFlush != FALSE)
{
gimp_drawable_flush (activeDrawable);
}
gimp_drawable_detach (activeDrawable);
return (retLayerId);
} /* end gap_fg_matting_exec_apply_run */
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
gint32 image_ID;
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
image_ID = param[1].data.d_image;
drawable = gimp_drawable_get (param[2].data.d_drawable);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
gimp_get_data (PLUG_IN_PROC, &pvals);
if (! color_to_alpha_dialog (drawable))
{
gimp_drawable_detach (drawable);
return;
}
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 4)
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
pvals.color = param[3].data.d_color;
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &pvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS &&
gimp_drawable_is_rgb (drawable->drawable_id) &&
gimp_drawable_is_layer (drawable->drawable_id))
{
gboolean lock_alpha;
gimp_image_undo_group_start (image_ID);
/* Add alpha if not present */
gimp_layer_add_alpha (drawable->drawable_id);
/* Reget the drawable, bpp might have changed */
drawable = gimp_drawable_get (drawable->drawable_id);
/* Unset 'Lock alpha' */
lock_alpha = gimp_layer_get_lock_alpha (drawable->drawable_id);
gimp_layer_set_lock_alpha (drawable->drawable_id, FALSE);
gimp_progress_init (_("Removing color"));
gimp_rgn_iterate2 (drawable, 0 /* unused */, to_alpha_func, NULL);
gimp_layer_set_lock_alpha (drawable->drawable_id, lock_alpha);
gimp_image_undo_group_end (image_ID);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
gimp_drawable_detach (drawable);
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &pvals, sizeof (pvals));
values[0].data.d_status = status;
}
static void
run (const gchar *name, /* name of plugin */
gint nparams, /* number of in-paramters */
const GimpParam * param, /* in-parameters */
gint *nreturn_vals, /* number of out-parameters */
GimpParam ** return_vals) /* out-parameters */
{
const gchar *l_env;
gint32 image_id = -1;
gint32 drawable_id = -1;
gint32 trans_drawable_id = -1;
/* Get the runmode from the in-parameters */
GimpRunMode run_mode = param[0].data.d_int32;
/* status variable, use it to check for errors in invocation usualy only
during non-interactive calling */
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
/* always return at least the status to the caller. */
static GimpParam values[2];
INIT_I18N();
l_env = g_getenv("GAP_DEBUG");
if(l_env != NULL)
{
if((*l_env != 'n') && (*l_env != 'N')) gap_debug = 1;
}
if(gap_debug) printf("\n\nDEBUG: run %s\n", name);
/* initialize the return of the status */
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
values[1].type = GIMP_PDB_DRAWABLE;
values[1].data.d_drawable = -1;
*nreturn_vals = 2;
*return_vals = values;
/* get image and drawable */
image_id = param[1].data.d_int32;
drawable_id = param[2].data.d_int32;
if (strcmp (name, PLUG_IN_PROC) == 0)
{
if(gimp_drawable_is_layer(drawable_id))
{
gboolean run_flag;
/* Initial values */
glob_vals.corpus_border_radius = 20;
glob_vals.alt_selection = -1;
run_flag = TRUE;
/* Possibly retrieve data from a previous run */
gimp_get_data (name, &glob_vals);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Get information from the dialog */
run_flag = p_dialog(&glob_vals, drawable_id);
break;
case GIMP_RUN_NONINTERACTIVE:
/* check to see if invoked with the correct number of parameters */
if (nparams >= global_number_in_args)
{
glob_vals.corpus_border_radius = param[3].data.d_int32;
glob_vals.alt_selection = param[4].data.d_int32;
glob_vals.seed = param[5].data.d_int32;
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
break;
default:
break;
}
/* here the action starts, we transform the drawable */
if(run_flag)
{
trans_drawable_id = p_process_layer(image_id
, drawable_id
, &glob_vals
);
if (trans_drawable_id < 0)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
values[1].data.d_drawable = drawable_id;
/* Store variable states for next run
* (the parameters for the transform wrapper plugins are stored
* even if they contain just a dummy
* this is done to fullfill the GIMP-GAP LAST_VALUES conventions
* for filtermacro and animated calls)
*/
if (run_mode == GIMP_RUN_INTERACTIVE)
{
gimp_set_data (name, &glob_vals, sizeof (TransValues));
}
}
}
}
else
{
status = GIMP_PDB_CALLING_ERROR;
if (run_mode == GIMP_RUN_INTERACTIVE)
{
g_message(_("The plug-in %s\noperates only on layers\n"
"(but was called on mask or channel)")
, name
);
}
}
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
/* If run mode is interactive, flush displays, else (script) don't
* do it, as the screen updates would make the scripts slow
*/
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
values[0].data.d_status = status;
} /* end run */
