static GimpValueArray *
file_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
GimpValueArray *new_args;
GimpValueArray *return_vals;
GimpPlugInProcedure *file_proc;
GimpProcedure *proc;
gchar *uri;
gint i;
uri = file_utils_filename_to_uri (gimp,
g_value_get_string (gimp_value_array_index (args, 3)),
error);
if (! uri)
return gimp_procedure_get_return_values (procedure, FALSE,
error ? *error : NULL);
file_proc =
file_procedure_find (gimp->plug_in_manager->save_procs, uri, NULL);
if (! file_proc)
file_proc = file_procedure_find (gimp->plug_in_manager->export_procs, uri, error);
g_free (uri);
if (! file_proc)
return gimp_procedure_get_return_values (procedure, FALSE,
error ? *error : NULL);
proc = GIMP_PROCEDURE (file_proc);
new_args = gimp_procedure_get_arguments (proc);
for (i = 0; i < 5; i++)
g_value_transform (gimp_value_array_index (args, i),
gimp_value_array_index (new_args, i));
for (i = 5; i < proc->num_args; i++)
if (G_IS_PARAM_SPEC_STRING (proc->args[i]))
g_value_set_static_string (gimp_value_array_index (new_args, i), "");
return_vals =
gimp_pdb_execute_procedure_by_name_args (gimp->pdb,
context, progress, error,
gimp_object_get_name (proc),
new_args);
gimp_value_array_unref (new_args);
return return_vals;
}
static void
batch_run_cmd (Gimp *gimp,
const gchar *proc_name,
GimpProcedure *procedure,
GimpRunMode run_mode,
const gchar *cmd)
{
GValueArray *args;
GValueArray *return_vals;
GError *error = NULL;
gint i = 0;
args = gimp_procedure_get_arguments (procedure);
if (procedure->num_args > i && GIMP_IS_PARAM_SPEC_INT32 (procedure->args[i]))
g_value_set_int (&args->values[i++], run_mode);
if (procedure->num_args > i && GIMP_IS_PARAM_SPEC_STRING (procedure->args[i]))
g_value_set_static_string (&args->values[i++], cmd);
return_vals =
gimp_pdb_execute_procedure_by_name_args (gimp->pdb,
gimp_get_user_context (gimp),
NULL, &error,
proc_name, args);
switch (g_value_get_enum (&return_vals->values[0]))
{
case GIMP_PDB_EXECUTION_ERROR:
if (error)
{
g_printerr ("batch command experienced an execution error: %s\n",
error->message);
}
else
{
g_printerr ("batch command experienced an execution error\n");
}
break;
case GIMP_PDB_CALLING_ERROR:
if (error)
{
g_printerr ("batch command experienced a calling error: %s\n",
error->message);
}
else
{
g_printerr ("batch command experienced a calling error\n");
}
break;
case GIMP_PDB_SUCCESS:
g_printerr ("batch command executed successfully\n");
break;
}
g_value_array_free (return_vals);
g_value_array_free (args);
if (error)
g_error_free (error);
return;
}
GimpValueArray *
gimp_pdb_execute_procedure_by_name (GimpPDB *pdb,
GimpContext *context,
GimpProgress *progress,
GError **error,
const gchar *name,
...)
{
GimpProcedure *procedure;
GimpValueArray *args;
GimpValueArray *return_vals;
va_list va_args;
gint i;
g_return_val_if_fail (GIMP_IS_PDB (pdb), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
g_return_val_if_fail (name != NULL, NULL);
procedure = gimp_pdb_lookup_procedure (pdb, name);
if (! procedure)
{
GError *pdb_error = g_error_new (GIMP_PDB_ERROR,
GIMP_PDB_ERROR_PROCEDURE_NOT_FOUND,
_("Procedure '%s' not found"), name);
return_vals = gimp_procedure_get_return_values (NULL, FALSE, pdb_error);
g_propagate_error (error, pdb_error);
return return_vals;
}
args = gimp_procedure_get_arguments (procedure);
va_start (va_args, name);
for (i = 0; i < procedure->num_args; i++)
{
GValue *value;
GType arg_type;
gchar *error_msg = NULL;
arg_type = va_arg (va_args, GType);
if (arg_type == G_TYPE_NONE)
break;
value = gimp_value_array_index (args, i);
if (arg_type != G_VALUE_TYPE (value))
{
GError *pdb_error;
const gchar *expected = g_type_name (G_VALUE_TYPE (value));
const gchar *got = g_type_name (arg_type);
gimp_value_array_unref (args);
pdb_error = g_error_new (GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Procedure '%s' has been called with a "
"wrong type for argument #%d. "
"Expected %s, got %s."),
gimp_object_get_name (procedure),
i + 1, expected, got);
return_vals = gimp_procedure_get_return_values (procedure,
FALSE, pdb_error);
g_propagate_error (error, pdb_error);
va_end (va_args);
return return_vals;
}
G_VALUE_COLLECT (value, va_args, G_VALUE_NOCOPY_CONTENTS, &error_msg);
if (error_msg)
{
GError *pdb_error = g_error_new_literal (GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INTERNAL_ERROR,
error_msg);
g_warning ("%s: %s", G_STRFUNC, error_msg);
g_free (error_msg);
gimp_value_array_unref (args);
return_vals = gimp_procedure_get_return_values (procedure,
FALSE, pdb_error);
g_propagate_error (error, pdb_error);
va_end (va_args);
return return_vals;
}
}
va_end (va_args);
return_vals = gimp_pdb_execute_procedure_by_name_args (pdb, context,
progress, error,
name, args);
gimp_value_array_unref (args);
return return_vals;
}
static GimpValueArray *
file_load_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
GimpValueArray *new_args;
GimpValueArray *return_vals;
GimpPlugInProcedure *file_proc;
GimpProcedure *proc;
gchar *uri;
gint i;
uri = file_utils_filename_to_uri (gimp,
g_value_get_string (gimp_value_array_index (args, 1)),
error);
if (! uri)
return gimp_procedure_get_return_values (procedure, FALSE,
error ? *error : NULL);
file_proc =
file_procedure_find (gimp->plug_in_manager->load_procs, uri, error);
g_free (uri);
if (! file_proc)
return gimp_procedure_get_return_values (procedure, FALSE,
error ? *error : NULL);
proc = GIMP_PROCEDURE (file_proc);
new_args = gimp_procedure_get_arguments (proc);
for (i = 0; i < 3; i++)
g_value_transform (gimp_value_array_index (args, i),
gimp_value_array_index (new_args, i));
for (i = 3; i < proc->num_args; i++)
if (G_IS_PARAM_SPEC_STRING (proc->args[i]))
g_value_set_static_string (gimp_value_array_index (new_args, i), "");
return_vals =
gimp_pdb_execute_procedure_by_name_args (gimp->pdb,
context, progress, error,
gimp_object_get_name (proc),
new_args);
gimp_value_array_unref (new_args);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) ==
GIMP_PDB_SUCCESS)
{
if (gimp_value_array_length (return_vals) > 1 &&
GIMP_VALUE_HOLDS_IMAGE_ID (gimp_value_array_index (return_vals, 1)))
{
GimpImage *image =
gimp_value_get_image (gimp_value_array_index (return_vals, 1),
gimp);
gimp_image_set_load_proc (image, file_proc);
}
}
return return_vals;
}
static void
gimp_plug_in_handle_proc_run (GimpPlugIn *plug_in,
GPProcRun *proc_run)
{
GimpPlugInProcFrame *proc_frame;
gchar *canonical;
const gchar *proc_name = NULL;
GimpProcedure *procedure;
GimpValueArray *args = NULL;
GimpValueArray *return_vals = NULL;
GError *error = NULL;
g_return_if_fail (proc_run != NULL);
g_return_if_fail (proc_run->name != NULL);
canonical = gimp_canonicalize_identifier (proc_run->name);
proc_frame = gimp_plug_in_get_proc_frame (plug_in);
procedure = gimp_pdb_lookup_procedure (plug_in->manager->gimp->pdb,
canonical);
if (! procedure)
{
proc_name = gimp_pdb_lookup_compat_proc_name (plug_in->manager->gimp->pdb,
canonical);
if (proc_name)
{
procedure = gimp_pdb_lookup_procedure (plug_in->manager->gimp->pdb,
proc_name);
if (plug_in->manager->gimp->pdb_compat_mode == GIMP_PDB_COMPAT_WARN)
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_WARNING,
"Plug-In \"%s\"\n(%s)\n"
"called deprecated procedure '%s'.\n"
"It should call '%s' instead!",
gimp_object_get_name (plug_in),
gimp_file_get_utf8_name (plug_in->file),
canonical, proc_name);
}
}
}
else if (procedure->deprecated)
{
if (plug_in->manager->gimp->pdb_compat_mode == GIMP_PDB_COMPAT_WARN)
{
if (! strcmp (procedure->deprecated, "NONE"))
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_WARNING,
"Plug-In \"%s\"\n(%s)\n"
"called deprecated procedure '%s'.",
gimp_object_get_name (plug_in),
gimp_file_get_utf8_name (plug_in->file),
canonical);
}
else
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_WARNING,
"WARNING: Plug-In \"%s\"\n(%s)\n"
"called deprecated procedure '%s'.\n"
"It should call '%s' instead!",
gimp_object_get_name (plug_in),
gimp_file_get_utf8_name (plug_in->file),
canonical, procedure->deprecated);
}
}
}
if (! proc_name)
proc_name = canonical;
args = plug_in_params_to_args (procedure ? procedure->args : NULL,
procedure ? procedure->num_args : 0,
proc_run->params, proc_run->nparams,
FALSE, FALSE);
/* Execute the procedure even if gimp_pdb_lookup_procedure()
* returned NULL, gimp_pdb_execute_procedure_by_name_args() will
* return appropriate error return_vals.
*/
gimp_plug_in_manager_plug_in_push (plug_in->manager, plug_in);
return_vals = gimp_pdb_execute_procedure_by_name_args (plug_in->manager->gimp->pdb,
proc_frame->context_stack ?
proc_frame->context_stack->data :
proc_frame->main_context,
proc_frame->progress,
&error,
proc_name,
args);
gimp_plug_in_manager_plug_in_pop (plug_in->manager);
gimp_value_array_unref (args);
if (error)
{
gimp_plug_in_handle_proc_error (plug_in, proc_frame,
canonical, error);
g_error_free (error);
}
g_free (canonical);
/* Don't bother to send the return value if executing the procedure
* closed the plug-in (e.g. if the procedure is gimp-quit)
*/
if (plug_in->open)
{
GPProcReturn proc_return;
/* Return the name we got called with, *not* proc_name or canonical,
* since proc_name may have been remapped by gimp->procedural_compat_ht
* and canonical may be different too.
*/
proc_return.name = proc_run->name;
proc_return.nparams = gimp_value_array_length (return_vals);
proc_return.params = plug_in_args_to_params (return_vals, FALSE);
if (! gp_proc_return_write (plug_in->my_write, &proc_return, plug_in))
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"%s: ERROR", G_STRFUNC);
gimp_plug_in_close (plug_in, TRUE);
}
g_free (proc_return.params);
}
gimp_value_array_unref (return_vals);
}
