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;
}
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_xml_align_dialog
* ---------------------------
* return TRUE.. OK
* FALSE.. in case of Error or cancel
*/
gboolean
gap_detail_xml_align_dialog(XmlAlignValues *xaVals)
{
#define SPINBUTTON_ENTRY_WIDTH 70
#define DETAIL_ALIGN_XML_DIALOG_ARGC 3
static GapArrArg argv[DETAIL_ALIGN_XML_DIALOG_ARGC];
gint ii;
gint ii_framePhase;
ii=0; gap_arr_arg_init(&argv[ii], GAP_ARR_WGT_INT_PAIR); ii_framePhase = ii;
argv[ii].label_txt = _("Frame Phase:");
argv[ii].help_txt = _("Frame number (phase) to be rendered.");
argv[ii].constraint = FALSE;
argv[ii].int_min = 1;
argv[ii].int_max = 9999;
argv[ii].umin = 1;
argv[ii].umax = 999999;
argv[ii].int_ret = xaVals->framePhase;
argv[ii].entry_width = SPINBUTTON_ENTRY_WIDTH;
argv[ii].has_default = TRUE;
argv[ii].int_default = DEFAULT_framePhase;
ii++; gap_arr_arg_init(&argv[ii], GAP_ARR_WGT_FILESEL);
argv[ii].label_txt = _("XML file:");
argv[ii].help_txt = _("Name of the xml file that contains the tracked detail coordinates. "
" (recorded with the detail tracking feature).");
argv[ii].text_buf_len = sizeof(xaVals->moveLogFile);
argv[ii].text_buf_ret = &xaVals->moveLogFile[0];
argv[ii].entry_width = 400;
ii++; gap_arr_arg_init(&argv[ii], GAP_ARR_WGT_DEFAULT_BUTTON);
argv[ii].label_txt = _("Default");
argv[ii].help_txt = _("Reset all parameters to default values");
if(TRUE == gap_arr_ok_cancel_dialog(_("Detail Align via XML"),
_("Settings :"),
DETAIL_ALIGN_XML_DIALOG_ARGC, argv))
{
xaVals->framePhase = (gint32)(argv[ii_framePhase].int_ret);
gimp_set_data (GAP_DETAIL_TRACKING_XML_ALIGNER_PLUG_IN_NAME
, xaVals, sizeof (XmlAlignValues));
return TRUE;
}
else
{
return FALSE;
}
} /* end gap_detail_xml_align_dialog */
static void
gimp_aspect_preview_dispose (GObject *object)
{
const gchar *data_name = g_object_get_data (G_OBJECT (object),
"gimp-aspect-preview-data-name");
if (data_name)
{
GimpPreview *preview = GIMP_PREVIEW (object);
PreviewSettings settings;
settings.update = gimp_preview_get_update (preview);
gimp_set_data (data_name, &settings, sizeof (PreviewSettings));
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
dialog_unmap (GtkWidget *window,
GtkWidget *paned)
{
DialogData data;
gtk_window_get_size (GTK_WINDOW (window), &data.width, &data.height);
data.paned_position = gtk_paned_get_position (GTK_PANED (paned));
data.show_index = gtk_widget_get_visible (sidebar);
data.zoom = (view ?
webkit_web_view_get_zoom_level (WEBKIT_WEB_VIEW (view)) : 1.0);
gimp_set_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data, sizeof (data));
gtk_main_quit ();
}
/* -------------------------------
* p_set_frameHistInfo
* -------------------------------
* store frame history information
* (for the next run in the same gimp session)
*/
static void
p_set_frameHistInfo(FrameHistInfo *frameHistInfo)
{
if(gap_debug)
{
printf("p_SET_frameHistInfo: %s frameNr:%d px:%d py:%d valid:%d prevPx:%d prevPy:%d prevValid:%d\n\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
);
}
gimp_set_data(GAP_DETAIL_FRAME_HISTORY_INFO, frameHistInfo, sizeof(FrameHistInfo));
} /* end p_set_frameHistInfo */
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;
}
static void
params_save_to_gimp (void)
{
gimp_set_data (PLUG_IN_PROC, &p.params, sizeof p.params);
}
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 */
/*
* '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[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[MAX_EXTRACT_IMAGES + 1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 num_images;
gint32 image_ID_extract[MAX_EXTRACT_IMAGES];
gint32 layer_ID_extract[MAX_EXTRACT_IMAGES];
gint j;
gint32 layer;
gint32 num_layers;
gint32 image_ID;
INIT_I18N ();
run_mode = param[0].data.d_int32;
image_ID = param[1].data.d_image;
layer = param[2].data.d_drawable;
*nreturn_vals = MAX_EXTRACT_IMAGES+1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
for (j = 0; j < MAX_EXTRACT_IMAGES; j++)
{
values[j+1].type = GIMP_PDB_IMAGE;
values[j+1].data.d_int32 = -1;
}
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &decovals);
/* First acquire information with a dialog */
if (! decompose_dialog ())
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 4 && nparams != 5 && nparams != 6)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
strncpy (decovals.extract_type, param[3].data.d_string,
sizeof (decovals.extract_type));
decovals.extract_type[sizeof (decovals.extract_type)-1] = '\0';
decovals.as_layers = nparams > 4 ? param[4].data.d_int32 : FALSE;
decovals.use_registration = (strcmp (name, PLUG_IN_PROC_REG) == 0);
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &decovals);
break;
default:
break;
}
/* Make sure that the drawable is RGB color */
if (gimp_drawable_type_with_alpha (layer) != GIMP_RGBA_IMAGE)
{
g_message ("Can only work on RGB images.");
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
gimp_progress_init (_("Decomposing"));
num_images = decompose (image_ID, layer,
decovals.extract_type,
image_ID_extract,
&num_layers,
layer_ID_extract);
if (num_images <= 0)
{
status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
/* create decompose-data parasite */
GString *data = g_string_new ("");
g_string_printf (data, "source=%d type=%s ",
layer, decovals.extract_type);
for (j = 0; j < num_layers; j++)
g_string_append_printf (data, "%d ", layer_ID_extract[j]);
for (j = 0; j < num_images; j++)
{
values[j+1].data.d_int32 = image_ID_extract[j];
gimp_image_undo_enable (image_ID_extract[j]);
gimp_image_clean_all (image_ID_extract[j]);
gimp_image_attach_new_parasite (image_ID_extract[j],
"decompose-data",
0, data->len + 1, data->str);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_display_new (image_ID_extract[j]);
}
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &decovals, sizeof (DecoVals));
}
}
values[0].data.d_status = status;
}
static void
run (const gchar *name,
gint nparam,
const GimpParam *param,
gint *nretvals,
GimpParam **retvals)
{
static GimpParam rvals[1];
piArgs args;
*nretvals = 1;
*retvals = rvals;
INIT_I18N ();
memset (&args, 0, sizeof (args));
args.mode = -1;
gimp_get_data (PLUG_IN_PROC, &args);
args.image = param[1].data.d_image;
args.drawable = param[2].data.d_drawable;
rvals[0].type = GIMP_PDB_STATUS;
rvals[0].data.d_status = GIMP_PDB_SUCCESS;
switch (param[0].data.d_int32)
{
case GIMP_RUN_INTERACTIVE:
/* XXX: add code here for interactive running */
if (args.mode == -1)
{
args.mode = MODE_NTSC;
args.action = ACT_LREDUX;
args.new_layerp = 1;
}
if (plugin_dialog (&args))
{
if (! pluginCore (&args))
{
rvals[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
}
}
else
{
rvals[0].data.d_status = GIMP_PDB_CANCEL;
}
gimp_set_data (PLUG_IN_PROC, &args, sizeof (args));
break;
case GIMP_RUN_NONINTERACTIVE:
/* XXX: add code here for non-interactive running */
if (nparam != 6)
{
rvals[0].data.d_status = GIMP_PDB_CALLING_ERROR;
break;
}
args.mode = param[3].data.d_int32;
args.action = param[4].data.d_int32;
args.new_layerp = param[5].data.d_int32;
if (! pluginCore (&args))
{
rvals[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
break;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* XXX: add code here for last-values running */
if (! pluginCore (&args))
{
rvals[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
}
break;
}
}
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[2];
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);
gimp_tile_cache_ntiles (2 * drawable->ntile_cols);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &bvals);
/* First acquire information with a dialog */
if (! sobel_dialog (drawable))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
if (nparams != 6)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
bvals.horizontal = (param[4].data.d_int32) ? TRUE : FALSE;
bvals.vertical = (param[5].data.d_int32) ? TRUE : FALSE;
bvals.keep_sign = (param[6].data.d_int32) ? TRUE : FALSE;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &bvals);
break;
default:
break;
}
/* 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))
{
sobel (drawable,
bvals.horizontal, bvals.vertical, bvals.keep_sign,
NULL);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/* Store data */
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &bvals, sizeof (bvals));
}
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.");
}
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];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpRunMode run_mode;
/* Plug-in variables */
gboolean single_image;
gboolean defaults_proc;
/* Plug-In variables */
cairo_surface_t *pdf_file;
cairo_t *cr;
GimpExportCapabilities capabilities;
guint32 i = 0;
gint32 j = 0;
gdouble x_res, y_res;
gdouble x_scale, y_scale;
gint32 image_id;
gboolean exported;
GimpImageBaseType type;
gint32 temp;
gint *layers;
gint32 num_of_layers;
GimpDrawable *layer;
cairo_surface_t *layer_image;
gdouble opacity;
gint x, y;
GimpRGB layer_color;
gboolean single_color;
gint32 mask_id = -1;
GimpDrawable *mask = NULL;
cairo_surface_t *mask_image = NULL;
FILE *fp;
INIT_I18N ();
/* Setting mandatory output values */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Initializing all the settings */
multi_page.image_count = 0;
if (! init_vals (name, nparams, param, &single_image,
&defaults_proc, &run_mode))
{
values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
return;
}
/* Starting the executions */
if (run_mode == GIMP_RUN_INTERACTIVE)
{
if (single_image)
{
if (! gui_single ())
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
}
else if (! gui_multi ())
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
if (file_name == NULL)
{
values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
gimp_message (_("You must select a file to save!"));
return;
}
}
fp = g_fopen (file_name, "wb");
pdf_file = cairo_pdf_surface_create_for_stream (write_func, fp, 1, 1);
if (cairo_surface_status (pdf_file) != CAIRO_STATUS_SUCCESS)
{
char *str = g_strdup_printf
(_("An error occured while creating the PDF file:\n"
"%s\n"
"Make sure you entered a valid filename and that the selected location isn't read only!"),
cairo_status_to_string (cairo_surface_status (pdf_file)));
gimp_message (str);
g_free (str);
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
return;
}
cr = cairo_create (pdf_file);
capabilities = GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_ALPHA |
GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_LAYERS |
GIMP_EXPORT_CAN_HANDLE_INDEXED;
if (optimize.apply_masks)
capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS;
for (i = 0; i < multi_page.image_count; i++)
{
/* Save the state of the surface before any changes, so that settings
* from one page won't affect all the others */
cairo_save (cr);
image_id = multi_page.images[i];
/* We need the active layer in order to use gimp_image_export */
temp = gimp_image_get_active_drawable (image_id);
if (temp == -1)
exported = gimp_export_image (&image_id, &temp, NULL, capabilities) == GIMP_EXPORT_EXPORT;
else
exported = FALSE;
type = gimp_image_base_type (image_id);
gimp_image_get_resolution (image_id, &x_res, &y_res);
x_scale = 72.0 / x_res;
y_scale = 72.0 / y_res;
cairo_pdf_surface_set_size (pdf_file,
gimp_image_width (image_id) * x_scale,
gimp_image_height (image_id) * y_scale);
/* This way we set how many pixels are there in every inch.
* It's very important for PangoCairo */
cairo_surface_set_fallback_resolution (pdf_file, x_res, y_res);
/* PDF is usually 72 points per inch. If we have a different resolution,
* we will need this to fit our drawings */
cairo_scale (cr, x_scale, y_scale);
/* Now, we should loop over the layers of each image */
layers = gimp_image_get_layers (image_id, &num_of_layers);
for (j = 0; j < num_of_layers; j++)
{
layer = gimp_drawable_get (layers [num_of_layers-j-1]);
opacity = gimp_layer_get_opacity (layer->drawable_id)/100.0;
/* Gimp doesn't display indexed layers with opacity below 50%
* And if it's above 50%, it will be rounded to 100% */
if (type == GIMP_INDEXED)
{
if (opacity <= 0.5)
opacity = 0.0;
else
opacity = 1.0;
}
if (gimp_item_get_visible (layer->drawable_id)
&& (! optimize.ignore_hidden || (optimize.ignore_hidden && opacity > 0.0)))
{
mask_id = gimp_layer_get_mask (layer->drawable_id);
if (mask_id != -1)
{
mask = gimp_drawable_get (mask_id);
mask_image = get_drawable_image (mask);
}
gimp_drawable_offsets (layer->drawable_id, &x, &y);
/* For raster layers */
if (!gimp_item_is_text_layer (layer->drawable_id))
{
layer_color = get_layer_color (layer, &single_color);
cairo_rectangle (cr, x, y, layer->width, layer->height);
if (optimize.vectorize && single_color)
{
cairo_set_source_rgba (cr, layer_color.r, layer_color.g, layer_color.b, layer_color.a * opacity);
if (mask_id != -1)
cairo_mask_surface (cr, mask_image, x, y);
else
cairo_fill (cr);
}
else
{
cairo_clip (cr);
layer_image = get_drawable_image (layer);
cairo_set_source_surface (cr, layer_image, x, y);
cairo_push_group (cr);
cairo_paint_with_alpha (cr, opacity);
cairo_pop_group_to_source (cr);
if (mask_id != -1)
cairo_mask_surface (cr, mask_image, x, y);
else
cairo_paint (cr);
cairo_reset_clip (cr);
cairo_surface_destroy (layer_image);
}
}
/* For text layers */
else
{
drawText (layer, opacity, cr, x_res, y_res);
}
}
/* We are done with the layer - time to free some resources */
gimp_drawable_detach (layer);
if (mask_id != -1)
{
gimp_drawable_detach (mask);
cairo_surface_destroy (mask_image);
}
}
/* We are done with this image - Show it! */
cairo_show_page (cr);
cairo_restore (cr);
if (exported)
gimp_image_delete (image_id);
}
/* We are done with all the images - time to free the resources */
cairo_surface_destroy (pdf_file);
cairo_destroy (cr);
fclose (fp);
/* Finally done, let's save the parameters */
gimp_set_data (DATA_OPTIMIZE, &optimize, sizeof (optimize));
if (!single_image)
{
g_strlcpy (multi_page.file_name, file_name, MAX_FILE_NAME_LENGTH);
gimp_set_data (DATA_IMAGE_LIST, &multi_page, sizeof (multi_page));
}
}
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;
}