static gboolean apply_userdef(userdef_settings settings, image_output out)
{
gboolean success = TRUE;
int param_i;
GimpParamDef param_info;
gboolean saving_function = (strstr(settings->procedure, "-save") != NULL);
int single_drawable = gimp_image_merge_visible_layers(out->image_id, GIMP_CLIP_TO_IMAGE);
for (param_i = 0; param_i < settings->num_params; param_i++) {
switch((settings->params[param_i]).type) {
case GIMP_PDB_IMAGE:
(settings->params[param_i]).data.d_image = out->image_id;
break;
case GIMP_PDB_DRAWABLE:
case GIMP_PDB_ITEM:
(settings->params[param_i]).data.d_drawable = single_drawable;
break;
case GIMP_PDB_STRING:
if (saving_function) {
param_info = pdb_proc_get_param_info(settings->procedure, param_i);
if (strcmp(param_info.name, "filename") == 0) {
(settings->params[param_i]).data.d_string = g_strdup(out->filepath);
}
else if (strcmp(param_info.name, "raw-filename") == 0) {
(settings->params[param_i]).data.d_string = g_strdup(out->filename);
}
}
break;
default: break;
}
}
gint nreturn_vals;
GimpParam *return_vals = gimp_run_procedure2(
settings->procedure,
&nreturn_vals,
settings->num_params,
settings->params
);
gimp_image_merge_visible_layers(out->image_id, GIMP_CLIP_TO_IMAGE);
g_free(out->drawable_ids);
out->drawable_ids = gimp_image_get_layers(out->image_id, &out->drawable_count);
return success;
}
static void run(
const gchar * name,
gint nparams, // !!! Always 3 for INTERACTIVE, not lengthof(param)?
const GimpParam * param,
gint * nreturn_vals,
GimpParam ** return_vals)
{
static GimpParam values[1]; // return values persist after run() returns
Parameters parameters;
gboolean ok;
/* Unless anything goes wrong, result is success */
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_SUCCESS;
/* Initialize i18n support */
#if defined(G_OS_WIN32)
bindtextdomain (GETTEXT_PACKAGE, gimp_locale_directory());
#else
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
#endif
#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
textdomain (GETTEXT_PACKAGE);
/* Don't really need the drawable or its tiles until we get to the engine. */
gint32 drawable_id;
drawable_id = param[2].data.d_drawable;
/* Assert the image type is OK because Gimp checked it. */
/* Deal with run mode */
ok = FALSE;
switch(param[0].data.d_int32)
{
case GIMP_RUN_INTERACTIVE :
get_last_parameters(¶meters, drawable_id, RESYNTH_CONTROLS_PDB_NAME );
init_gtk();
/* GUI dialog. */
ok = get_parameters_by_asking(¶meters,drawable_id);
if (ok) /* Not canceled and not an exception. */
set_last_parameters(¶meters, drawable_id);
break;
case GIMP_RUN_NONINTERACTIVE :
/* GUI CAN be called noninteractively, in batch mode or otherwise. */
ok = get_parameters_from_list(¶meters, nparams, param);
break;
case GIMP_RUN_WITH_LAST_VALS :
ok = get_last_parameters(¶meters,drawable_id, RESYNTH_CONTROLS_PDB_NAME);
break;
}
if (!ok)
{
/* No message displayed here because it is usually Cancel button, else the resynthesizer
control panel GUI already displayed an error message?
*/
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
return;
}
/* Prepare params for engine: augment passed params with user's choices. */
static GimpParam temp[RESYNTH_PARAMETER_COUNT];
set_parameters_to_list(¶meters, param, nparams, GIMP_RUN_NONINTERACTIVE, temp);
/* Call resynthesizer engine. */
GimpParam * engine_result;
gint engine_n_return_vals;
engine_result = gimp_run_procedure2(
RESYNTH_ENGINE_PDB_NAME,
&engine_n_return_vals,
RESYNTH_PARAMETER_COUNT, /* !!! Not nparams */
temp
);
/* Always a status. */
if (engine_result[0].data.d_status != GIMP_PDB_SUCCESS)
{
/* Reraise engine error. */
*nreturn_vals = engine_n_return_vals;
*return_vals = engine_result;
}
else
{
/* Free engine result, return our own. */
gimp_destroy_params(engine_result, engine_n_return_vals);
}
}
static PyObject *
pf_call(PyGimpPDBFunction *self, PyObject *args, PyObject *kwargs)
{
GimpParam *params, *ret;
int nret;
PyObject *t = NULL, *r;
GimpRunMode run_mode = GIMP_RUN_NONINTERACTIVE;
#if PG_DEBUG > 0
g_printerr("--- %s --- ", PyString_AsString(self->proc_name));
#endif
if (kwargs) {
int len, pos;
PyObject *key, *val;
len = PyDict_Size(kwargs);
if (len == 1) {
pos = 0;
PyDict_Next(kwargs, &pos, &key, &val);
if (!PyString_Check(key)) {
PyErr_SetString(PyExc_TypeError,
"keyword argument name is not a string");
return NULL;
}
if (strcmp(PyString_AsString(key), "run_mode") != 0) {
PyErr_SetString(PyExc_TypeError,
"only 'run_mode' keyword argument accepted");
return NULL;
}
if (pyg_enum_get_value(GIMP_TYPE_RUN_MODE, val, (gpointer)&run_mode))
return NULL;
} else if (len != 0) {
PyErr_SetString(PyExc_TypeError,
"expecting at most one keyword argument");
return NULL;
}
}
if (self->nparams > 0 && !strcmp(self->params[0].name, "run-mode")) {
params = pygimp_param_from_tuple(args, self->params + 1,
self->nparams - 1);
if (params == NULL)
return NULL;
params[0].type = self->params[0].type;
params[0].data.d_int32 = run_mode;
#if PG_DEBUG > 1
pygimp_param_print(self->nparams, params);
#endif
ret = gimp_run_procedure2(self->name, &nret, self->nparams, params);
} else {
params = pygimp_param_from_tuple(args, self->params, self->nparams);
if (params == NULL)
return NULL;
#if PG_DEBUG > 1
pygimp_param_print(self->nparams, params+1);
#endif
ret = gimp_run_procedure2(self->name, &nret, self->nparams, params + 1);
}
gimp_destroy_params(params, self->nparams);
if (!ret) {
PyErr_SetString(pygimp_error, "no status returned");
#if PG_DEBUG >= 1
g_printerr("ret == NULL\n");
#endif
return NULL;
}
switch(ret[0].data.d_status) {
case GIMP_PDB_EXECUTION_ERROR:
#if PG_DEBUG > 0
g_printerr("execution error\n");
#endif
gimp_destroy_params(ret, nret);
PyErr_SetString(PyExc_RuntimeError, "execution error");
return NULL;
break;
case GIMP_PDB_CALLING_ERROR:
#if PG_DEBUG > 0
g_printerr("calling error\n");
#endif
gimp_destroy_params(ret, nret);
PyErr_SetString(PyExc_TypeError, "invalid arguments");
return NULL;
break;
case GIMP_PDB_SUCCESS:
#if PG_DEBUG > 0
g_printerr("success\n");
#endif
t = pygimp_param_to_tuple(nret-1, ret+1);
gimp_destroy_params(ret, nret);
if (t == NULL) {
PyErr_SetString(pygimp_error, "could not make return value");
return NULL;
}
break;
default:
#if PG_DEBUG > 0
g_printerr("unknown - %i (type %i)\n",
ret[0].data.d_status, ret[0].type);
#endif
PyErr_SetString(pygimp_error, "unknown return code");
return NULL;
break;
}
if (PyTuple_Size(t) == 1) {
r = PyTuple_GetItem(t, 0);
Py_INCREF(r);
Py_DECREF(t);
return r;
}
if (PyTuple_Size(t) == 0) {
r = Py_None;
Py_INCREF(r);
Py_DECREF(t);
return r;
}
return t;
}
gint p_call_plugin(char *plugin_name, gint32 image_id, gint32 layer_id, GimpRunModeType run_mode)
{
GimpDrawable *l_drawable;
GimpParam *l_ret_params;
GimpParam *l_argv;
gint l_retvals;
gint l_idx;
gint l_nparams;
gint l_nreturn_vals;
GimpPDBProcType l_proc_type;
gchar *l_proc_blurb;
gchar *l_proc_help;
gchar *l_proc_author;
gchar *l_proc_copyright;
gchar *l_proc_date;
GimpParamDef *l_params;
GimpParamDef *l_return_vals;
l_drawable = gimp_drawable_get(layer_id); /* use the background layer */
/* query for plugin_name to get its argument types */
if (!gimp_procedural_db_proc_info (plugin_name,
&l_proc_blurb,
&l_proc_help,
&l_proc_author,
&l_proc_copyright,
&l_proc_date,
&l_proc_type,
&l_nparams,
&l_nreturn_vals,
&l_params,
&l_return_vals))
{
fprintf(stderr, "ERROR: Plugin not available, Name was %s\n", plugin_name);
return -1;
}
/* construct the procedures arguments */
l_argv = g_new (GimpParam, l_nparams);
memset (l_argv, 0, (sizeof (GimpParam) * l_nparams));
/* initialize the argument types */
for (l_idx = 0; l_idx < l_nparams; l_idx++)
{
l_argv[l_idx].type = l_params[l_idx].type;
switch(l_params[l_idx].type)
{
case GIMP_PDB_DISPLAY:
l_argv[l_idx].data.d_display = -1;
break;
case GIMP_PDB_DRAWABLE:
case GIMP_PDB_LAYER:
case GIMP_PDB_CHANNEL:
l_argv[l_idx].data.d_drawable = -1;
break;
case GIMP_PDB_IMAGE:
l_argv[l_idx].data.d_image = -1;
break;
case GIMP_PDB_INT32:
case GIMP_PDB_INT16:
case GIMP_PDB_INT8:
l_argv[l_idx].data.d_int32 = 0;
break;
case GIMP_PDB_FLOAT:
l_argv[l_idx].data.d_float = 0.0;
break;
case GIMP_PDB_STRING:
l_argv[l_idx].data.d_string = NULL;
break;
default:
l_argv[l_idx].data.d_int32 = 0;
break;
}
}
/* init the standard parameters, that should be common to all plugins */
l_argv[0].data.d_int32 = run_mode;
l_argv[1].data.d_image = image_id;
l_argv[2].data.d_drawable = l_drawable->id;
/* run the plug-in procedure */
l_ret_params = gimp_run_procedure2 (plugin_name, &l_retvals, l_nparams, l_argv);
/* free up arguments and values */
g_free (l_argv);
/* free the query information */
g_free (l_proc_blurb);
g_free (l_proc_help);
g_free (l_proc_author);
g_free (l_proc_copyright);
g_free (l_proc_date);
g_free (l_params);
g_free (l_return_vals);
if (l_ret_params[0].data.d_status == FALSE)
{
fprintf(stderr, "ERROR: p_call_plugin %s failed.\n", plugin_name);
g_free(l_ret_params);
return -1;
}
else
{
if(gap_debug) fprintf(stderr, "DEBUG: p_call_plugin: %s successful.\n", plugin_name);
g_free(l_ret_params);
return 0;
}
}
