/**
* Print information on a GIMP procedure.
*/
static void
pdb_print_info (gchar *proc_name)
{
gint i;
// Lots and lots and lots of fields for getting info.
gchar *proc_blurb;
gchar *proc_help;
gchar *proc_author;
gchar *proc_copyright;
gchar *proc_date;
GimpPDBProcType proc_type;
GimpParamDef *params;
gint nparams;
GimpParamDef *return_vals;
gint nreturn_vals;
if (! gimp_procedural_db_proc_info (proc_name,
&proc_blurb,
&proc_help,
&proc_author,
&proc_copyright,
&proc_date,
&proc_type,
&nparams, &nreturn_vals,
¶ms, &return_vals))
{
printf ("%s is undefined.\n", proc_name);
} // if we could not look up the procedure
else
{
printf ("Procedure: %s\n", proc_name);
printf (" Blurb: %s\n", proc_blurb);
printf (" Help: %s\n", proc_help);
printf (" Author: %s\n", proc_author);
printf (" Copyright: %s\n", proc_copyright);
printf (" Date: %s\n", proc_date);
printf (" Parameters:\n");
for (i = 0; i < nparams; i++)
{
printf (" %d: (%s) %s // %s\n",
i,
pdb_readable_typename (params[i].type),
params[i].name,
params[i].description);
}
printf (" Return Values:\n");
for (i = 0; i < nreturn_vals; i++)
{
printf (" %d: (%s) %s // %s\n",
i,
pdb_readable_typename (return_vals[i].type),
return_vals[i].name,
return_vals[i].description);
}
} // found
printf ("\n");
} // pdib_print_info
static gboolean proc_has_compatible_params(gchar* proc_name)
{
gchar* proc_blurb;
gchar* proc_help;
gchar* proc_author;
gchar* proc_copyright;
gchar* proc_date;
GimpPDBProcType proc_type;
gint num_params;
gint num_values;
GimpParamDef *params;
GimpParamDef *return_vals;
gimp_procedural_db_proc_info (
proc_name,
&proc_blurb,
&proc_help,
&proc_author,
&proc_copyright,
&proc_date,
&proc_type,
&num_params,
&num_values,
¶ms,
&return_vals
);
int i;
GimpParamDef param;
gboolean compatible = TRUE;
for (i = 0; (i < num_params) && compatible; i++) {
param = bimp_get_param_info(proc_name, i);
if (
param.type == GIMP_PDB_INT32 ||
param.type == GIMP_PDB_INT16 ||
param.type == GIMP_PDB_INT8 ||
param.type == GIMP_PDB_FLOAT ||
//(param.type == GIMP_PDB_STRING && strstr(param.name, "filename") == NULL) ||
param.type == GIMP_PDB_STRING ||
param.type == GIMP_PDB_COLOR ||
param.type == GIMP_PDB_DRAWABLE ||
param.type == GIMP_PDB_IMAGE
) {
compatible = TRUE;
} else {
compatible = FALSE;
}
}
return (compatible && num_params > 0);
}
static PyObject *
pygimp_pdb_function_new_from_proc_db(char *name)
{
PyObject *ret;
char *b,*h,*a,*c,*d;
int np, nr;
GimpPDBProcType pt;
GimpParamDef *p, *r;
if (!gimp_procedural_db_proc_info (name, &b, &h, &a, &c, &d, &pt,
&np, &nr, &p, &r)) {
PyErr_SetString(pygimp_error, "procedure not found");
return NULL;
}
ret = pygimp_pdb_function_new(name, b, h, a, c, d, pt, np, nr, p, r);
g_free(b); g_free(h); g_free(a); g_free(c); g_free(d);
return ret;
}
static void
script_fu_browse_response (GtkWidget *widget,
gint response_id,
ConsoleInterface *console)
{
GimpProcBrowserDialog *dialog = GIMP_PROC_BROWSER_DIALOG (widget);
gchar *proc_name;
gchar *proc_blurb;
gchar *proc_help;
gchar *proc_author;
gchar *proc_copyright;
gchar *proc_date;
GimpPDBProcType proc_type;
gint n_params;
gint n_return_vals;
GimpParamDef *params;
GimpParamDef *return_vals;
gint i;
GString *text;
if (response_id != GTK_RESPONSE_APPLY)
{
gtk_widget_destroy (widget);
return;
}
proc_name = gimp_proc_browser_dialog_get_selected (dialog);
if (proc_name == NULL)
return;
gimp_procedural_db_proc_info (proc_name,
&proc_blurb,
&proc_help,
&proc_author,
&proc_copyright,
&proc_date,
&proc_type,
&n_params,
&n_return_vals,
¶ms,
&return_vals);
text = g_string_new ("(");
text = g_string_append (text, proc_name);
for (i = 0; i < n_params; i++)
{
text = g_string_append_c (text, ' ');
text = g_string_append (text, params[i].name);
}
text = g_string_append_c (text, ')');
gtk_window_set_focus (GTK_WINDOW (console->dialog), console->cc);
gtk_entry_set_text (GTK_ENTRY (console->cc), text->str);
gtk_editable_set_position (GTK_EDITABLE (console->cc),
g_utf8_pointer_to_offset (text->str,
text->str +
strlen (proc_name) + 2));
g_string_free (text, TRUE);
gtk_window_present (GTK_WINDOW (console->dialog));
g_free (proc_name);
g_free (proc_blurb);
g_free (proc_help);
g_free (proc_author);
g_free (proc_copyright);
g_free (proc_date);
gimp_destroy_paramdefs (params, n_params);
gimp_destroy_paramdefs (return_vals, n_return_vals);
}
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;
}
}
gint p_procedure_available(char *proc_name, t_proc_type ptype)
{
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;
gint l_rc;
l_rc = 0;
/* Query the gimp application's procedural database
* regarding a particular procedure.
*/
if (gimp_procedural_db_proc_info (proc_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))
{
/* procedure found in PDB */
if(gap_debug) fprintf(stderr, "DEBUG: found in PDB %s\n", proc_name);
switch(ptype)
{
case PTYP_ITERATOR:
/* check exactly for Input Parametertypes (common to all Iterators) */
if (l_proc_type != GIMP_EXTENSION ) { l_rc = -1; break; }
if (l_nparams != 4) { l_rc = -1; break; }
if (l_params[0].type != GIMP_PDB_INT32) { l_rc = -1; break; }
if (l_params[1].type != GIMP_PDB_INT32) { l_rc = -1; break; }
if (l_params[2].type != GIMP_PDB_FLOAT) { l_rc = -1; break; }
if (l_params[3].type != GIMP_PDB_INT32) { l_rc = -1; break; }
break;
case PTYP_CAN_OPERATE_ON_DRAWABLE:
/* check if plugin can be a typical one, that works on one drawable */
if (l_proc_type != GIMP_PLUGIN) { l_rc = -1; break; }
if (l_nparams < 3) { l_rc = -1; break; }
if (l_params[0].type != GIMP_PDB_INT32) { l_rc = -1; break; }
if (l_params[1].type != GIMP_PDB_IMAGE) { l_rc = -1; break; }
if (l_params[2].type != GIMP_PDB_DRAWABLE) { l_rc = -1; break; }
break;
default:
break;
}
/* 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);
}
else
{
return -1;
}
return l_rc;
} /* end p_procedure_available */
