static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
GimpRunMode run_mode;
gint image_id, layer_num;
run_mode = param[0].data.d_int32;
image_id = param[1].data.d_int32;
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
switch ( run_mode )
{
case GIMP_RUN_INTERACTIVE:
gimp_image_get_layers (image_id, &layer_num);
if (layer_num < 2)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_STRING;
values[1].data.d_string = _("There are not enough layers to align.");
return;
}
gimp_get_data (PLUG_IN_PROC, &VALS);
VALS.grid_size = MAX (VALS.grid_size, 1);
if (! align_layers_dialog ())
return;
break;
case GIMP_RUN_NONINTERACTIVE:
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &VALS);
break;
}
status = align_layers (image_id);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS)
gimp_set_data (PLUG_IN_PROC, &VALS, sizeof (ValueType));
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
GimpDrawable *drawable;
INIT_I18N ();
run_mode = param[0].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_int32);
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
gimp_get_data (HSV_NOISE_PROC, &VALS);
if (!gimp_drawable_is_rgb (drawable->drawable_id))
{
g_message (_("Can only operate on RGB drawables."));
return;
}
if (! scatter_hsv_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
VALS.holdness = CLAMP (param[3].data.d_int32, 1, 8);
VALS.hue_distance = CLAMP (param[4].data.d_int32, 0, 180);
VALS.saturation_distance = CLAMP (param[5].data.d_int32, 0, 255);
VALS.value_distance = CLAMP (param[6].data.d_int32, 0, 255);
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (HSV_NOISE_PROC, &VALS);
break;
}
scatter_hsv (drawable);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush();
if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS )
gimp_set_data (HSV_NOISE_PROC, &VALS, sizeof (ValueType));
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpDrawable *drawable;
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
GimpRunMode run_mode;
run_mode = param[0].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_drawable);
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
gimp_get_data (PLUG_IN_PROC, &pvals);
/* Since a channel might be selected, we must check wheter RGB or not. */
if (!gimp_drawable_is_rgb (drawable->drawable_id))
{
g_message (_("Can only operate on RGB drawables."));
return;
}
if (! max_rgb_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* You must copy the values of parameters to pvals or dialog variables. */
pvals.max_p = param[3].data.d_int32;
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &pvals);
break;
}
status = main_function (drawable, NULL);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
if (run_mode == GIMP_RUN_INTERACTIVE && status == GIMP_PDB_SUCCESS)
gimp_set_data (PLUG_IN_PROC, &pvals, sizeof (ValueType));
values[0].data.d_status = status;
}
/* -----------------------------------
* gap_detail_xml_align_get_values
* -----------------------------------
* This procedure is typically called
* on the snapshot image created by the Player.
* This image has one layer at the first snapshot
* and each further snapshot adds one layer on top of the layerstack.
*
* The start is detected when the image has only one layer.
* optionally the numer of layers can be limted
* to 2 (or more) layers.
*/
void
gap_detail_xml_align_get_values(XmlAlignValues *xaVals)
{
int l_len;
/* init default values */
xaVals->framePhase = DEFAULT_framePhase;
xaVals->moveLogFile[0] = '\0';
l_len = gimp_get_data_size (GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME);
if (l_len == sizeof(XmlAlignValues))
{
/* Possibly retrieve data from a previous interactive run */
gimp_get_data (GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME, xaVals);
if(gap_debug)
{
printf("gap_detail_xml_align_get_values FOUND data for key:%s\n"
, GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME
);
}
}
if(gap_debug)
{
printf("gap_detail_xml_align_get_values:\n"
" framePhase:%d moveLogFile:%s\n"
, (int)xaVals->framePhase
, xaVals->moveLogFile
);
}
} /* end gap_detail_xml_align_get_values */
static void
params_load_from_gimp (void)
{
gimp_get_data (PLUG_IN_PROC, &p.params);
if (0 < p.params.division_x)
{
p.params.tile_width = p.drawable->width / p.params.division_x;
if (0 < p.params.tile_width)
{
p.params.division_y = p.drawable->height / p.params.tile_height;
}
}
if (p.params.tile_width <= 0 ||
p.params.tile_height <= 0 ||
p.params.division_x <= 0 ||
p.params.division_y <= 0)
{
p.params.tile_width = p.drawable->width;
p.params.tile_height = p.drawable->height;
p.params.division_x = p.drawable->width / p.params.tile_width;
p.params.division_y = p.drawable->height / p.params.tile_height;
}
if (!p.drawable_has_alpha)
{
if (p.params.background_type == BACKGROUND_TYPE_TRANSPARENT)
{
p.params.background_type = BACKGROUND_TYPE_INVERTED;
}
gimp_rgb_set_alpha (&p.params.background_color, 1.0);
}
}
static void run(const gchar G_GNUC_UNUSED *nome, gint nparams, const GimpParam * params, gint *nretvals, GimpParam ** retparams)
{
static GimpParam ret[1];
GimpPDBStatusType* status;
GimpDrawable* drawable;
param_type p = VIZ4;
*nretvals = 1;
*retparams = ret;
ret[0].type = GIMP_PDB_STATUS;
status = (GimpPDBStatusType*) &(ret[0].data.d_status);
*status = GIMP_PDB_CALLING_ERROR;
drawable = gimp_drawable_get(params[2].data.d_drawable);
if (!gimp_get_data(nome, &p))
p = VIZ4;
switch (params[0].data.d_int32)
{
case GIMP_RUN_INTERACTIVE:
if (!show_dialog(&p))
{
ret[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 4)
{
/* retorna o erro de chamadoa para o gimp */
ret[0].data.d_status = GIMP_PDB_CALLING_ERROR;
return;
}
p = params[3].data.d_int8;
break;
default:
g_error("programa no lugar errado");
ret[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
return;
}
gimp_set_data(nome, &p, sizeof(param_type));
*status = execute_plugin(drawable, nome, &p);
ret[0].data.d_status = GIMP_PDB_SUCCESS;
return;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GError *error = NULL;
INIT_I18N ();
gegl_init (NULL, NULL);
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
gimp_get_data (SAVE_PROC, >mvals);
if (save_dialog (param[1].data.d_int32))
{
GeglBuffer *buffer;
buffer = gimp_drawable_get_buffer (param[2].data.d_int32);
if (save_image (param[3].data.d_string, buffer, &error))
{
gimp_set_data (SAVE_PROC, >mvals, sizeof (GTMValues));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
g_object_unref (buffer);
}
else
{
status = GIMP_PDB_CANCEL;
}
if (status != GIMP_PDB_SUCCESS && error)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_STRING;
values[1].data.d_string = error->message;
}
values[0].data.d_status = status;
}
/* -----------------------------------
* gap_detail_tracking_get_values
* -----------------------------------
* This procedure is typically called
* on the snapshot image created by the Player.
* This image has one layer at the first snapshot
* and each further snapshot adds one layer on top of the layerstack.
*
* The start is detected when the image has only one layer.
* optionally the numer of layers can be limted
* to 2 (or more) layers.
*/
void
gap_detail_tracking_get_values(FilterValues *fiVals)
{
int l_len;
/* init default values */
fiVals->refShapeRadius = DEFAULT_refShapeRadius;
fiVals->targetMoveRadius = DEFAULT_targetMoveRadius;
fiVals->loacteColodiffThreshold = DEFAULT_loacteColodiffThreshold;
fiVals->coordsRelToFrame1 = DEFAULT_coordsRelToFrame1;
fiVals->offsX = DEFAULT_offsX;
fiVals->offsY = DEFAULT_offsY;
fiVals->offsRotate = DEFAULT_offsRotate;
fiVals->enableScaling = DEFAULT_enableScaling;
fiVals->removeMidlayers = DEFAULT_removeMidlayers;
fiVals->bgLayerIsReference = DEFAULT_bgLayerIsReference;
fiVals->moveLogFile[0] = '\0';
l_len = gimp_get_data_size (GAP_DETAIL_TRACKING_PLUG_IN_NAME);
if (l_len == sizeof(FilterValues))
{
/* Possibly retrieve data from a previous interactive run */
gimp_get_data (GAP_DETAIL_TRACKING_PLUG_IN_NAME, fiVals);
if(gap_debug)
{
printf("gap_detail_tracking_get_values FOUND data for key:%s\n"
, GAP_DETAIL_TRACKING_PLUG_IN_NAME
);
}
}
if(gap_debug)
{
printf("gap_detail_tracking_get_values:\n"
" refShapeRadius:%d targetMoveRadius:%d locateColordiff:%.4f\n"
" coordsRelToFrame1:%d offsX:%d offsY:%d removeMidlayers:%d bgLayerIsReference:%d\n"
" moveLogFile:%s\n"
, (int)fiVals->refShapeRadius
, (int)fiVals->targetMoveRadius
, (float)fiVals->loacteColodiffThreshold
, (int)fiVals->coordsRelToFrame1
, (int)fiVals->offsX
, (int)fiVals->offsY
, (int)fiVals->removeMidlayers
, (int)fiVals->bgLayerIsReference
, fiVals->moveLogFile
);
}
} /* end gap_detail_tracking_get_values */
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpExportReturn export = GIMP_EXPORT_CANCEL;
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 = GIMP_PDB_EXECUTION_ERROR;
if (run_mode == GIMP_RUN_INTERACTIVE &&
strcmp (name, SAVE_PROC) == 0)
{
gint32 image_ID = param[1].data.d_int32;
gint32 drawable_ID = param[2].data.d_int32;
GimpParasite *parasite;
gchar *x;
GimpImageType drawable_type = gimp_drawable_type (drawable_ID);
gimp_get_data (SAVE_PROC, &config);
config.prefixed_name = "gimp_image";
config.comment = NULL;
config.file_name = param[3].data.d_string;
config.alpha = (drawable_type == GIMP_RGBA_IMAGE ||
drawable_type == GIMP_GRAYA_IMAGE ||
drawable_type == GIMP_INDEXEDA_IMAGE);
parasite = gimp_image_parasite_find (image_ID, "gimp-comment");
if (parasite)
{
config.comment = g_strndup (gimp_parasite_data (parasite),
gimp_parasite_data_size (parasite));
gimp_parasite_free (parasite);
}
x = config.comment;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, "C Source",
/* -------------------------------
* p_get_frameHistInfo
* -------------------------------
*/
static void
p_get_frameHistInfo(FrameHistInfo *frameHistInfo)
{
int l_len;
frameHistInfo->workImageId = -1;
frameHistInfo->frameNr = 0;
frameHistInfo->startCoords.valid = FALSE;
frameHistInfo->startCoords.px = 0;
frameHistInfo->startCoords.py = 0;
frameHistInfo->lostTraceCount = 0;
l_len = gimp_get_data_size (GAP_DETAIL_FRAME_HISTORY_INFO);
if(gap_debug)
{
printf("p_get_frameHistInfo: %s len:%d sizeof(FrameHistInfo):%d\n"
, GAP_DETAIL_FRAME_HISTORY_INFO
, (int)l_len
, (int)sizeof(FrameHistInfo)
);
}
if (l_len == sizeof(FrameHistInfo))
{
gimp_get_data(GAP_DETAIL_FRAME_HISTORY_INFO, frameHistInfo);
if(gap_debug)
{
printf("p_get_frameHistInfo: %s frameNr:%d px:%d py:%d valid:%d\n"
" prevPx:%d prevPy:%d prevValid:%d lostTraceCount:%d\n"
, GAP_DETAIL_FRAME_HISTORY_INFO
, (int)frameHistInfo->frameNr
, (int)frameHistInfo->startCoords.px
, (int)frameHistInfo->startCoords.py
, (int)frameHistInfo->startCoords.valid
, (int)frameHistInfo->prevCoords.px
, (int)frameHistInfo->prevCoords.py
, (int)frameHistInfo->prevCoords.valid
, (int)frameHistInfo->lostTraceCount
);
}
}
} /* end p_get_frameHistInfo */
static void
gimp_aspect_preview_constructed (GObject *object)
{
gchar *data_name;
PreviewSettings settings;
G_OBJECT_CLASS (parent_class)->constructed (object);
data_name = g_strdup_printf ("%s-aspect-preview-%d",
g_get_prgname (),
gimp_aspect_preview_counter++);
if (gimp_get_data (data_name, &settings))
{
gimp_preview_set_update (GIMP_PREVIEW (object), settings.update);
}
g_object_set_data_full (object, "gimp-aspect-preview-data-name",
data_name, (GDestroyNotify) g_free);
}
/* ============================================================================
* p_get_data
* try to get the plugin's data (key is usually the name of the plugin)
* and check for the length of the retrieved data.
* if all done OK return the length of the retrieved data,
* return -1 in case of errors.
* ============================================================================
*/
gint p_get_data(char *key)
{
int l_len;
l_len = gimp_get_data_size (key);
if(l_len < 1)
{
fprintf(stderr, "ERROR: no stored data found for Key %s\n", key);
return -1;
}
if(global_plugin_data)
{
g_free(global_plugin_data);
}
global_plugin_data = g_malloc0(l_len+1);
gimp_get_data(key, global_plugin_data);
if(gap_debug) printf("DEBUG p_get_data Key:%s retrieved bytes %d\n", key, (int)l_len);
return (l_len);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpRunMode run_mode;
GimpDrawable *drawable;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* set the tile cache size */
gimp_tile_cache_ntiles (TILE_CACHE_SIZE);
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
INIT_I18N();
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &cvals);
/* First acquire information with a dialog */
if (! cartoon_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
cvals.mask_radius = param[3].data.d_float;
cvals.pct_black = param[4].data.d_float;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &cvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is RGB or GRAY color */
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init ("Cartoon");
cartoon (drawable, NULL);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &cvals, sizeof (CartoonVals));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
*nreturn_vals = 2;
values[1].type = GIMP_PDB_STRING;
values[1].data.d_string = _("Cannot operate on indexed color images.");
}
}
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpPDBStatusType status;
GimpDrawable *drawable;
gint x1, y1, x2, y2;
INIT_I18N ();
status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Get the active drawable info */
drawable = gimp_drawable_get (param[2].data.d_drawable);
img_width = gimp_drawable_width (drawable->drawable_id);
img_height = gimp_drawable_height (drawable->drawable_id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
mbvals.center_x = (gdouble) (x1 + x2 - 1) / 2.0;
mbvals.center_y = (gdouble) (y1 + y2 - 1) / 2.0;
/* Set the tile cache size */
gimp_tile_cache_ntiles (2 * drawable->ntile_cols);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &mbvals);
/* Get information from the dialog */
if (! mblur_dialog (param[1].data.d_image, drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
if (strcmp (name, PLUG_IN_PROC_INWARD) == 0)
mbvals.blur_outward = FALSE;
if (nparams == 8)
{
mbvals.center_x = param[6].data.d_float;
mbvals.center_y = param[7].data.d_float;
}
else if (nparams != 6)
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
mbvals.mblur_type = param[3].data.d_int32;
mbvals.length = param[4].data.d_int32;
mbvals.angle = param[5].data.d_int32;
}
if ((mbvals.mblur_type < 0) || (mbvals.mblur_type > MBLUR_MAX))
status= GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &mbvals);
break;
default:
break;
}
/* Blur the image */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb(drawable->drawable_id) ||
gimp_drawable_is_gray(drawable->drawable_id)))
{
/* Run! */
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
mblur (drawable, NULL);
/* If run mode is interactive, flush displays */
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &mbvals, sizeof (mblur_vals_t));
}
else if (status == GIMP_PDB_SUCCESS)
status = GIMP_PDB_EXECUTION_ERROR;
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
INIT_I18N ();
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &svals);
/* In order to prepare the dialog I need to know wether it's grayscale or not */
drawable = gimp_drawable_get (param[2].data.d_drawable);
thePreview = mw_preview_build_virgin(drawable);
drawable_is_grayscale = gimp_drawable_is_gray (drawable->drawable_id);
if (! sinus_dialog ())
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 17)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
svals.scalex = param[3].data.d_float;
svals.scaley = param[4].data.d_float;
svals.cmplx = param[5].data.d_float;
svals.seed = param[6].data.d_int32;
svals.tiling = param[7].data.d_int32;
svals.perturbation = param[8].data.d_int32;
svals.colors = param[9].data.d_int32;
svals.col1 = param[10].data.d_color;
svals.col2 = param[11].data.d_color;
gimp_rgb_set_alpha (&svals.col1, param[12].data.d_float);
gimp_rgb_set_alpha (&svals.col2, param[13].data.d_float);
svals.colorization = param[14].data.d_int32;
svals.blend_power = param[15].data.d_float;
if (svals.random_seed)
svals.seed = g_random_int ();
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &svals);
if (svals.random_seed)
svals.seed = g_random_int ();
break;
default:
break;
}
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Make sure that the drawable is gray or RGB */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
gimp_progress_init (_("Sinus: rendering"));
gimp_tile_cache_ntiles (1);
sinus ();
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &svals, sizeof (SinusVals));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2]; /* Return values */
GimpRunMode run_mode;
gint32 image_ID;
gint32 drawable_ID;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image;
GimpExportReturn export = GIMP_EXPORT_CANCEL;
GError *error = NULL;
run_mode = param[0].data.d_int32;
INIT_I18N ();
/* Set up default return values */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, LOAD_PROC) == 0)
{
if (run_mode != GIMP_RUN_NONINTERACTIVE)
{
data_length = gimp_get_data_size (SAVE_PROC);
if (data_length > 0)
{
palette_file = g_malloc (data_length);
gimp_get_data (SAVE_PROC, palette_file);
}
else
{
palette_file = g_strdup ("*.kcf");
data_length = strlen (palette_file) + 1;
}
}
if (run_mode == GIMP_RUN_NONINTERACTIVE)
{
palette_file = param[3].data.d_string;
data_length = strlen (palette_file) + 1;
}
else if (run_mode == GIMP_RUN_INTERACTIVE)
{
/* Let user choose KCF palette (cancel ignores) */
if (need_palette (param[1].data.d_string))
palette_dialog (_("Load KISS Palette"));
gimp_set_data (SAVE_PROC, palette_file, data_length);
}
image = load_image (param[1].data.d_string, param[2].data.d_string,
&error);
if (image != -1)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
else if (strcmp (name, SAVE_PROC) == 0)
{
image_ID = param[1].data.d_int32;
drawable_ID = param[2].data.d_int32;
/* eventually export the image */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init (PLUG_IN_BINARY, FALSE);
export = gimp_export_image (&image_ID, &drawable_ID, "CEL",
(GIMP_EXPORT_CAN_HANDLE_RGB |
GIMP_EXPORT_CAN_HANDLE_ALPHA |
GIMP_EXPORT_CAN_HANDLE_INDEXED
));
if (export == GIMP_EXPORT_CANCEL)
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
break;
default:
break;
}
/*
* 'run()' - Run the plug-in...
*/
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[4];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
const gchar *filename = NULL;
GError *error = NULL;
gint32 image_ID = -1;
gint width = 0;
gint height = 0;
INIT_I18N ();
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, LOAD_PROC) == 0)
{
filename = param[1].data.d_string;
gimp_get_data (LOAD_PROC, &load_vals);
switch (run_mode)
{
case GIMP_RUN_NONINTERACTIVE:
if (nparams > 3) load_vals.resolution = param[3].data.d_float;
if (nparams > 4) load_vals.width = param[4].data.d_int32;
if (nparams > 5) load_vals.height = param[5].data.d_int32;
break;
case GIMP_RUN_INTERACTIVE:
if (!load_dialog (param[1].data.d_string))
status = GIMP_PDB_CANCEL;
break;
case GIMP_RUN_WITH_LAST_VALS:
break;
}
}
else if (strcmp (name, LOAD_THUMB_PROC) == 0)
{
gint size = param[1].data.d_int32;
filename = param[0].data.d_string;
if (size > 0 &&
load_wmf_size (filename, &load_vals) &&
load_vals.width > 0 &&
load_vals.height > 0)
{
width = load_vals.width;
height = load_vals.height;
if ((gdouble) load_vals.width > (gdouble) load_vals.height)
{
load_vals.width = size;
load_vals.height *= size / (gdouble) load_vals.width;
}
else
{
load_vals.width *= size / (gdouble) load_vals.height;
load_vals.height = size;
}
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
if (load_vals.resolution < GIMP_MIN_RESOLUTION ||
load_vals.resolution > GIMP_MAX_RESOLUTION)
{
load_vals.resolution = WMF_DEFAULT_RESOLUTION;
}
image_ID = load_image (filename, &error);
if (image_ID != -1)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
if (status == GIMP_PDB_SUCCESS)
{
if (strcmp (name, LOAD_THUMB_PROC) == 0)
{
*nreturn_vals = 4;
values[2].type = GIMP_PDB_INT32;
values[2].data.d_int32 = width;
values[3].type = GIMP_PDB_INT32;
values[3].data.d_int32 = height;
}
else
{
gimp_set_data (LOAD_PROC, &load_vals, sizeof (load_vals));
}
}
if (status != GIMP_PDB_SUCCESS && error)
{
*nreturn_vals = 2;
values[1].type = GIMP_PDB_STRING;
values[1].data.d_string = error->message;
}
values[0].data.d_status = status;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[3];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 new_layer = -1;
gint width;
gint height;
run_mode = param[0].data.d_int32;
INIT_I18N ();
*nreturn_vals = 3;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
values[1].type = GIMP_PDB_IMAGE;
values[2].type = GIMP_PDB_LAYER;
width = gimp_drawable_width (param[2].data.d_drawable);
height = gimp_drawable_height (param[2].data.d_drawable);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &tvals);
/* First acquire information with a dialog */
if (! tile_dialog (param[1].data.d_image,
param[2].data.d_drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 6)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
tvals.new_width = param[3].data.d_int32;
tvals.new_height = param[4].data.d_int32;
tvals.new_image = param[5].data.d_int32 ? TRUE : FALSE;
if (tvals.new_width < 0 || tvals.new_height < 0)
status = GIMP_PDB_CALLING_ERROR;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &tvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
gimp_progress_init (_("Tiling"));
values[1].data.d_image = tile (param[1].data.d_image,
param[2].data.d_drawable,
&new_layer);
values[2].data.d_layer = new_layer;
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &tvals, sizeof (TileVals));
if (run_mode != GIMP_RUN_NONINTERACTIVE)
{
if (tvals.new_image)
gimp_display_new (values[1].data.d_image);
else
gimp_displays_flush ();
}
}
values[0].data.d_status = status;
}
/* ---------------------------------
* run
* ---------------------------------
*/
static void
run(const gchar *name
, gint n_params
, const GimpParam *param
, gint *nreturn_vals
, GimpParam **return_vals)
{
const gchar *l_env;
static GimpParam values[2];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GapBlueboxGlobalParams *bbp;
gint32 l_rc;
*nreturn_vals = 1;
*return_vals = values;
l_rc = 0;
INIT_I18N();
l_env = g_getenv("GAP_DEBUG");
if(l_env != NULL)
{
if((*l_env != 'n') && (*l_env != 'N')) gap_debug = 1;
}
bbp = gap_bluebox_bbp_new(param[2].data.d_drawable);
run_mode = param[0].data.d_int32;
bbp->run_mode = param[0].data.d_int32;
bbp->image_id = param[1].data.d_image;
gimp_image_undo_group_start (bbp->image_id);
gap_bluebox_init_default_vals(bbp);
if(gap_debug) printf("\n\ngap_bluebox main: debug name = %s\n", name);
if (strcmp (name, GAP_BLUEBOX_PLUGIN_NAME) == 0)
{
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
{
/* Possibly retrieve data */
gimp_get_data (GAP_BLUEBOX_DATA_KEY_VALS, &bbp->vals);
l_rc = gap_bluebox_dialog(bbp);
if(l_rc < 0)
{
status = GIMP_PDB_CANCEL;
}
}
break;
case GIMP_RUN_NONINTERACTIVE:
{
if (n_params != G_N_ELEMENTS (args_bluebox))
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
bbp->vals.keycolor = param[3].data.d_color;
bbp->vals.thres_mode = param[4].data.d_int32;
bbp->vals.thres_r = param[5].data.d_float;
bbp->vals.thres_g = param[6].data.d_float;
bbp->vals.thres_b = param[7].data.d_float;
bbp->vals.thres_h = param[8].data.d_float;
bbp->vals.thres_s = param[9].data.d_float;
bbp->vals.thres_v = param[10].data.d_float;
bbp->vals.thres = param[11].data.d_float;
bbp->vals.tolerance = param[12].data.d_float;
bbp->vals.grow = (gdouble)param[13].data.d_int32;
bbp->vals.feather_edges = param[14].data.d_int32;
bbp->vals.feather_radius = param[15].data.d_float;
bbp->vals.source_alpha = param[16].data.d_float;
bbp->vals.target_alpha = param[17].data.d_float;
bbp->run_flag = TRUE;
}
}
break;
case GIMP_RUN_WITH_LAST_VALS:
{
/* Possibly retrieve data */
gimp_get_data (GAP_BLUEBOX_DATA_KEY_VALS, &bbp->vals);
bbp->run_flag = TRUE;
}
break;
default:
break;
}
}
if(status == GIMP_PDB_SUCCESS)
{
bbp->layer_id = bbp->drawable_id;
l_rc = gap_bluebox_apply(bbp);
if(l_rc < 0)
{
status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
gimp_set_data (GAP_BLUEBOX_DATA_KEY_VALS, &bbp->vals, sizeof (bbp->vals));
}
}
gimp_image_undo_group_end (bbp->image_id);
/* ---------- return handling --------- */
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
} /* end run */
void
browser_dialog_open (const gchar *plug_in_binary)
{
GtkWidget *window;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *toolbar;
GtkWidget *paned;
GtkWidget *scrolled;
GtkToolItem *item;
GtkAction *action;
DialogData data = { 720, 560, 240, TRUE, 1.0 };
gimp_ui_init (plug_in_binary, TRUE);
gimp_get_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data);
/* the dialog window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser"));
gtk_window_set_role (GTK_WINDOW (window), plug_in_binary);
gtk_window_set_default_size (GTK_WINDOW (window), data.width, data.height);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
window_set_icons (window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
ui_manager = ui_manager_new (window);
toolbar = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar");
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
gtk_widget_show (toolbar);
item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0);
gtk_widget_show (GTK_WIDGET (item));
action = gtk_ui_manager_get_action (ui_manager,
"/ui/help-browser-popup/forward");
gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action);
g_object_notify (G_OBJECT (action), "tooltip");
button_next = GTK_WIDGET (item);
item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0);
gtk_widget_show (GTK_WIDGET (item));
action = gtk_ui_manager_get_action (ui_manager,
"/ui/help-browser-popup/back");
gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action);
g_object_notify (G_OBJECT (action), "tooltip");
button_prev = GTK_WIDGET (item);
item =
GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager,
"/help-browser-toolbar/space"));
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
gtk_tool_item_set_expand (item, TRUE);
/* the horizontal paned */
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0);
gtk_widget_show (paned);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (paned), scrolled);
gtk_paned_set_position (GTK_PANED (paned), data.paned_position);
sidebar = scrolled;
if (data.show_index)
gtk_widget_show (sidebar);
tree_view = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
gtk_container_add (GTK_CONTAINER (scrolled), tree_view);
gtk_widget_show (tree_view);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1,
NULL,
gtk_cell_renderer_text_new (),
"text", 1,
NULL);
g_signal_connect (tree_view, "row-activated",
G_CALLBACK (row_activated),
NULL);
/* HTML view */
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (main_vbox);
gtk_paned_pack2 (GTK_PANED (paned), main_vbox, TRUE, TRUE);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrolled, 300, 200);
gtk_box_pack_start (GTK_BOX (main_vbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show (scrolled);
view = webkit_web_view_new ();
webkit_web_view_set_maintains_back_forward_list (WEBKIT_WEB_VIEW (view),
TRUE);
gtk_container_add (GTK_CONTAINER (scrolled), view);
gtk_widget_show (view);
g_signal_connect (view, "realize",
G_CALLBACK (view_realize),
NULL);
g_signal_connect (view, "unrealize",
G_CALLBACK (view_unrealize),
NULL);
g_signal_connect (view, "popup-menu",
G_CALLBACK (view_popup_menu),
NULL);
g_signal_connect (view, "button-press-event",
G_CALLBACK (view_button_press),
NULL);
g_signal_connect (view, "key-press-event",
G_CALLBACK (view_key_press),
NULL);
webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (view), data.zoom);
g_signal_connect (view, "title-changed",
G_CALLBACK (title_changed),
window);
g_signal_connect (view, "load-started",
G_CALLBACK (load_started),
NULL);
g_signal_connect (view, "load-finished",
G_CALLBACK (load_finished),
NULL);
gtk_widget_grab_focus (view);
g_signal_connect (window, "unmap",
G_CALLBACK (dialog_unmap),
paned);
update_actions ();
/* Searchbar */
searchbar = build_searchbar ();
gtk_box_pack_start (GTK_BOX (main_vbox), searchbar, FALSE, FALSE, 0);
}
/* A function that takes care of loading the basic
* parameters */
static gboolean
init_vals (const gchar *name,
gint nparams,
const GimpParam *param,
gboolean *single_image,
gboolean *defaults_proc,
GimpRunMode *run_mode)
{
gboolean had_saved_list = FALSE;
gboolean single;
gboolean defaults = FALSE;
gint32 i;
gint32 image;
if (g_str_equal (name, SAVE_PROC))
{
single = TRUE;
if (nparams != SA_ARG_COUNT && nparams != SA_ARG_COUNT_DEFAULT)
return FALSE;
*run_mode = param[SA_RUN_MODE].data.d_int32;
image = param[SA_IMAGE].data.d_int32;
file_name = param[SA_FILENAME].data.d_string;
if (nparams == SA_ARG_COUNT)
{
optimize.apply_masks = param[SA_APPLY_MASKS].data.d_int32;
optimize.vectorize = param[SA_VECTORIZE].data.d_int32;
optimize.ignore_hidden = param[SA_IGNORE_HIDDEN].data.d_int32;
}
else
defaults = TRUE;
}
else if (g_str_equal (name, SAVE_MULTI_PROC))
{
single = FALSE;
if (nparams != SMA_ARG_COUNT)
return FALSE;
*run_mode = param[SMA_RUN_MODE].data.d_int32;
image = -1;
file_name = param[SA_FILENAME].data.d_string;
optimize.apply_masks = param[SMA_APPLY_MASKS].data.d_int32;
optimize.vectorize = param[SMA_VECTORIZE].data.d_int32;
optimize.ignore_hidden = param[SMA_IGNORE_HIDDEN].data.d_int32;
}
else
return FALSE;
switch (*run_mode)
{
case GIMP_RUN_NONINTERACTIVE:
if (single)
{
init_image_list_defaults (image);
}
else
{
multi_page.image_count = param[SMA_COUNT].data.d_int32;
if (param[SMA_IMAGES].data.d_int32array != NULL)
for (i = 0; i < param[SMA_COUNT].data.d_int32; i++)
multi_page.images[i] = param[SMA_IMAGES].data.d_int32array[i];
}
break;
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (DATA_OPTIMIZE, &optimize);
had_saved_list = gimp_get_data (DATA_IMAGE_LIST, &multi_page);
if (had_saved_list && (file_name == NULL || strlen (file_name) == 0))
{
file_name = multi_page.file_name;
}
if (single || ! had_saved_list )
init_image_list_defaults (image);
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
if (!single)
{
had_saved_list = gimp_get_data (DATA_IMAGE_LIST, &multi_page);
if (had_saved_list)
{
file_name = multi_page.file_name;
}
}
else
{
init_image_list_defaults (image);
}
gimp_get_data (DATA_OPTIMIZE, &optimize);
break;
}
*defaults_proc = defaults;
*single_image = single;
validate_image_list ();
return TRUE;
}
static void
run (const gchar *name,
gint n_params,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
gint32 image_ID;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1;
*return_vals = values;
/* Initialize i18n support */
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
textdomain (GETTEXT_PACKAGE);
run_mode = param[0].data.d_int32;
image_ID = param[1].data.d_int32;
drawable = gimp_drawable_get(param[2].data.d_drawable);
/* Initialize with default values */
vals = default_vals;
image_vals = default_image_vals;
drawable_vals = default_drawable_vals;
ui_vals = default_ui_vals;
if (strcmp (name, PROCEDURE_NAME) == 0)
{
switch (run_mode)
{
case GIMP_RUN_NONINTERACTIVE:
if (n_params != 8)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
vals.SampleTileWidth = param[3].data.d_int32;
vals.SampleTileHeight = param[4].data.d_int32;
vals.ActualTileWidth = param[5].data.d_int32;
vals.ActualTileHeight = param[6].data.d_int32;
vals.DestinationWidth = param[7].data.d_int32;
vals.DestinationHeight = param[8].data.d_int32;
vals.SourceWidth = param[9].data.d_int32;
vals.SourceHeight = param[10].data.d_int32;
vals.MetricType = param[11].data.d_int8;
vals.minMetric = param[12].data.d_float;
}
break;
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (DATA_KEY_VALS, &vals);
gimp_get_data (DATA_KEY_UI_VALS, &ui_vals);
if (! dialog (image_ID, drawable,
&vals, &image_vals, &drawable_vals, &ui_vals))
{
status = GIMP_PDB_CANCEL;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (DATA_KEY_VALS, &vals);
break;
default:
break;
}
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
render (image_ID, drawable, &vals, &image_vals, &drawable_vals);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
if (run_mode == GIMP_RUN_INTERACTIVE)
{
gimp_set_data (DATA_KEY_VALS, &vals, sizeof (vals));
gimp_set_data (DATA_KEY_UI_VALS, &ui_vals, sizeof (ui_vals));
}
gimp_drawable_detach (drawable);
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
gint32 image_ID;
GimpDrawable *drawable;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Get the specified image and drawable */
image_ID = param[1].data.d_image;
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* set the tile cache size so that the gaussian blur works well */
gimp_tile_cache_ntiles (2 *
(MAX (drawable->width, drawable->height) /
gimp_tile_width () + 1));
if (strcmp (name, PLUG_IN_PROC) == 0)
{
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &dogvals);
/* First acquire information with a dialog */
if (! dog_dialog (image_ID, drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 7)
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
{
dogvals.inner = param[3].data.d_float;
dogvals.outer = param[4].data.d_float;
dogvals.normalize = param[5].data.d_int32;
dogvals.invert = param[6].data.d_int32;
}
if (status == GIMP_PDB_SUCCESS &&
(dogvals.inner <= 0.0 && dogvals.outer <= 0.0))
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &dogvals);
break;
default:
break;
}
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("DoG Edge Detect"));
/* run the Difference of Gaussians */
gimp_image_undo_group_start (image_ID);
dog (image_ID, drawable, dogvals.inner, dogvals.outer, TRUE);
gimp_image_undo_group_end (image_ID);
gimp_progress_update (1.0);
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &dogvals, sizeof (DoGValues));
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else
{
g_message (_("Cannot operate on indexed color images."));
status = GIMP_PDB_EXECUTION_ERROR;
}
gimp_drawable_detach (drawable);
}
values[0].data.d_status = status;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
gint32 image_ID;
GimpRunMode run_mode;
gint pwidth;
gint pheight;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint sel_width;
gint sel_height;
run_mode = param[0].data.d_int32;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
image_ID = param[1].data.d_image;
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
/* Calculate preview size */
if (sel_width > sel_height)
{
pwidth = MIN (sel_width, PREVIEW_SIZE);
pheight = sel_height * pwidth / sel_width;
}
else
{
pheight = MIN (sel_height, PREVIEW_SIZE);
pwidth = sel_width * pheight / sel_height;
}
preview_width = MAX (pwidth, 2);
preview_height = MAX (pheight, 2);
/* See how we will run */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data ("plug_in_fractalexplorer", &wvals);
/* Get information from the dialog */
if (!explorer_dialog ())
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are present */
if (nparams != 22)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
wvals.fractaltype = param[3].data.d_int8;
wvals.xmin = param[4].data.d_float;
wvals.xmax = param[5].data.d_float;
wvals.ymin = param[6].data.d_float;
wvals.ymax = param[7].data.d_float;
wvals.iter = param[8].data.d_float;
wvals.cx = param[9].data.d_float;
wvals.cy = param[10].data.d_float;
wvals.colormode = param[11].data.d_int8;
wvals.redstretch = param[12].data.d_float;
wvals.greenstretch = param[13].data.d_float;
wvals.bluestretch = param[14].data.d_float;
wvals.redmode = param[15].data.d_int8;
wvals.greenmode = param[16].data.d_int8;
wvals.bluemode = param[17].data.d_int8;
wvals.redinvert = param[18].data.d_int8;
wvals.greeninvert = param[19].data.d_int8;
wvals.blueinvert = param[20].data.d_int8;
wvals.ncolors = CLAMP (param[21].data.d_int32, 2, MAXNCOLORS);
}
make_color_map();
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data ("plug_in_fractalexplorer", &wvals);
make_color_map ();
break;
default:
break;
}
xmin = wvals.xmin;
xmax = wvals.xmax;
ymin = wvals.ymin;
ymax = wvals.ymax;
cx = wvals.cx;
cy = wvals.cy;
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is not indexed */
if (! gimp_drawable_is_indexed (drawable->drawable_id))
{
gimp_progress_init (_("Rendering fractal"));
/* Set the tile cache size */
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width() + 1));
/* Run! */
explorer (drawable);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data ("plug_in_fractalexplorer",
&wvals, sizeof (explorer_vals_t));
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_ID;
gint32 drawable_ID;
INIT_I18N ();
run_mode = param[0].data.d_int32;
image_ID = param[1].data.d_image;
drawable_ID = param[2].data.d_drawable;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, PLUG_IN_PROC) == 0)
{
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
gimp_get_data (PLUG_IN_PROC, &mail_info);
{
gchar *filename = gimp_image_get_filename (image_ID);
if (filename)
{
gchar *basename = g_filename_display_basename (filename);
g_strlcpy (mail_info.filename, basename, BUFFER_SIZE);
g_free (basename);
g_free (filename);
}
}
if (! save_dialog ())
status = GIMP_PDB_CANCEL;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams < 8)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
g_strlcpy (mail_info.filename,
param[3].data.d_string, BUFFER_SIZE);
g_strlcpy (mail_info.receipt,
param[4].data.d_string, BUFFER_SIZE);
g_strlcpy (mail_info.from,
param[5].data.d_string, BUFFER_SIZE);
g_strlcpy (mail_info.subject,
param[6].data.d_string, BUFFER_SIZE);
g_strlcpy (mail_info.comment,
param[7].data.d_string, BUFFER_SIZE);
}
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &mail_info);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
status = save_image (mail_info.filename,
image_ID,
drawable_ID,
run_mode);
if (status == GIMP_PDB_SUCCESS)
{
if (mesg_body)
g_strlcpy (mail_info.comment, mesg_body, BUFFER_SIZE);
gimp_set_data (PLUG_IN_PROC, &mail_info, sizeof (m_info));
}
}
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
values[0].data.d_status = status;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
GimpDrawable *drawable;
run_mode = param[0].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_int32);
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
if (strcmp (name, VPROPAGATE_PROC) == 0)
{
gimp_get_data (VPROPAGATE_PROC, &vpvals);
/* building the values of dialog variables from vpvals. */
propagate_alpha =
(vpvals.propagating_channel & PROPAGATING_ALPHA) ? TRUE : FALSE;
propagate_value =
(vpvals.propagating_channel & PROPAGATING_VALUE) ? TRUE : FALSE;
{
gint i;
for (i = 0; i < 4; i++)
direction_mask_vec[i] =
(vpvals.direction_mask & (1 << i)) ? TRUE : FALSE;
}
if (! vpropagate_dialog (drawable))
return;
}
else if (strcmp (name, ERODE_PROC) == 0 ||
strcmp (name, DILATE_PROC) == 0)
{
vpvals.propagating_channel = PROPAGATING_VALUE;
vpvals.propagating_rate = 1.0;
vpvals.direction_mask = 15;
vpvals.lower_limit = 0;
vpvals.upper_limit = 255;
if (strcmp (name, ERODE_PROC) == 0)
vpvals.propagate_mode = 1;
else if (strcmp (name, DILATE_PROC) == 0)
vpvals.propagate_mode = 0;
}
break;
case GIMP_RUN_NONINTERACTIVE:
if (strcmp (name, VPROPAGATE_PROC) == 0)
{
vpvals.propagate_mode = param[3].data.d_int32;
vpvals.propagating_channel = param[4].data.d_int32;
vpvals.propagating_rate = param[5].data.d_float;
vpvals.direction_mask = param[6].data.d_int32;
vpvals.lower_limit = param[7].data.d_int32;
vpvals.upper_limit = param[8].data.d_int32;
}
else if (strcmp (name, ERODE_PROC) == 0 ||
strcmp (name, DILATE_PROC) == 0)
{
vpvals.propagating_channel = PROPAGATING_VALUE;
vpvals.propagating_rate = 1.0;
vpvals.direction_mask = 15;
vpvals.lower_limit = 0;
vpvals.upper_limit = 255;
if (strcmp (name, ERODE_PROC) == 0)
vpvals.propagate_mode = 1;
else if (strcmp (name, DILATE_PROC) == 0)
vpvals.propagate_mode = 0;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (name, &vpvals);
break;
}
status = value_propagate (drawable);
if (status == GIMP_PDB_SUCCESS)
{
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (name, &vpvals, sizeof (VPValueType));
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
/*
* run
*
* The plug-in is being requested to run.
* Capture an window image.
*/
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpRunMode run_mode;
/* Initialize the return values
* Always return at least the status to the caller.
*/
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1;
*return_vals = values;
/* Get the runmode from the in-parameters */
run_mode = param[0].data.d_int32;
INIT_I18N ();
/* Set up the rest of the return parameters */
values[1].type = GIMP_PDB_INT32;
values[1].data.d_int32 = 0;
/* Get the data from last run */
gimp_get_data (PLUG_IN_PROC, &winsnapvals);
/* How are we running today? */
switch (run_mode) {
case GIMP_RUN_INTERACTIVE:
/* Get information from the dialog */
if (!snap_dialog())
return;
break;
case GIMP_RUN_NONINTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
if (!winsnapvals.root)
values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
break;
default:
break;
} /* switch */
/* Do the actual window capture */
if (winsnapvals.root)
doRootWindowCapture();
else
doWindowCapture();
/* Check to make sure we got at least one valid
* image.
*/
if (values[1].data.d_int32 > 0) {
/* A window was captured.
* Do final Interactive steps.
*/
if (run_mode == GIMP_RUN_INTERACTIVE) {
/* Store variable states for next run */
gimp_set_data (PLUG_IN_PROC, &winsnapvals, sizeof(WinSnapValues));
}
/* Set return values */
*nreturn_vals = 2;
} else {
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
}
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpDrawable *drawable;
run_mode = param[0].data.d_int32;
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_tile_cache_ntiles (2 * (drawable->ntile_cols));
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, >vals);
/* First acquire information with a dialog */
if (! glasstile_dialog (drawable))
{
gimp_drawable_detach (drawable);
return;
}
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 5)
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
{
gtvals.xblock = (gint) param[3].data.d_int32;
gtvals.yblock = (gint) param[4].data.d_int32;
}
if (gtvals.xblock < 10 || gtvals.xblock > 50)
status = GIMP_PDB_CALLING_ERROR;
if (gtvals.yblock < 10 || gtvals.yblock > 50)
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, >vals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Glass Tile"));
glasstile (drawable, NULL);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
{
gimp_set_data (PLUG_IN_PROC, >vals, sizeof (GlassValues));
}
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PIXELIZE_PROC, &pvals);
/* First acquire information with a dialog */
if (! pixelize_dialog (drawable))
{
gimp_drawable_detach (drawable);
return;
}
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if ((! strcmp (name, PIXELIZE_PROC) && nparams != 4) ||
(! strcmp (name, PIXELIZE2_PROC) && nparams != 5))
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
pvals.pixelwidth = (gdouble) param[3].data.d_int32;
if (nparams == 4)
pvals.pixelheight = pvals.pixelwidth;
else
pvals.pixelheight = (gdouble) param[4].data.d_int32;
}
if ((status == GIMP_PDB_SUCCESS) &&
(pvals.pixelwidth <= 0 || pvals.pixelheight <= 0))
{
status = GIMP_PDB_CALLING_ERROR;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PIXELIZE_PROC, &pvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Pixelizing"));
/* set the tile cache size */
gimp_tile_cache_ntiles (TILE_CACHE_SIZE);
/* run the pixelize effect */
pixelize (drawable, NULL);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PIXELIZE_PROC, &pvals, sizeof (PixelizeValues));
}
else
{
/* g_message ("pixelize: cannot operate on indexed color images"); */
status = GIMP_PDB_EXECUTION_ERROR;
}
}
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpRunMode run_mode = param[0].data.d_int32;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GdkScreen *screen = NULL;
gint32 image_ID;
static GimpParam values[2];
/* initialize the return of the status */
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
/* how are we running today? */
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_PROC, &shootvals);
shootvals.window_id = 0;
/* Get information from the dialog */
if (! shoot_dialog (&screen))
status = GIMP_PDB_CANCEL;
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams == 3)
{
gboolean do_root = param[1].data.d_int32;
shootvals.shoot_type = do_root ? SHOOT_ROOT : SHOOT_WINDOW;
shootvals.window_id = param[2].data.d_int32;
shootvals.select_delay = 0;
}
else if (nparams == 7)
{
shootvals.shoot_type = SHOOT_REGION;
shootvals.window_id = param[2].data.d_int32;
shootvals.select_delay = 0;
shootvals.x1 = param[3].data.d_int32;
shootvals.y1 = param[4].data.d_int32;
shootvals.x2 = param[5].data.d_int32;
shootvals.y2 = param[6].data.d_int32;
}
else
{
status = GIMP_PDB_CALLING_ERROR;
}
if (! gdk_init_check (NULL, NULL))
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data from a previous run */
gimp_get_data (PLUG_IN_PROC, &shootvals);
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
if (shootvals.select_delay > 0)
shoot_delay (shootvals.select_delay);
if (shootvals.shoot_type != SHOOT_ROOT && ! shootvals.window_id)
{
shootvals.window_id = select_window (screen);
if (! shootvals.window_id)
status = GIMP_PDB_CANCEL;
}
}
if (status == GIMP_PDB_SUCCESS)
{
image_ID = shoot (screen);
if (image_ID == -1)
status = GIMP_PDB_EXECUTION_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
if (run_mode == GIMP_RUN_INTERACTIVE)
{
/* Store variable states for next run */
gimp_set_data (PLUG_IN_PROC, &shootvals, sizeof (ScreenshotValues));
gimp_display_new (image_ID);
}
/* set return values */
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
}
values[0].data.d_status = status;
}
