static GimpValueArray *
register_thumbnail_loader_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
const gchar *load_proc;
const gchar *thumb_proc;
load_proc = g_value_get_string (gimp_value_array_index (args, 0));
thumb_proc = g_value_get_string (gimp_value_array_index (args, 1));
if (success)
{
gchar *canonical = gimp_canonicalize_identifier (load_proc);
gchar *canon_thumb = gimp_canonicalize_identifier (thumb_proc);
success = gimp_plug_in_manager_register_thumb_loader (gimp->plug_in_manager,
canonical, canon_thumb);
g_free (canonical);
g_free (canon_thumb);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GValueArray *
plugin_menu_register_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args,
GError **error)
{
gboolean success = TRUE;
const gchar *procedure_name;
const gchar *menu_path;
procedure_name = g_value_get_string (&args->values[0]);
menu_path = g_value_get_string (&args->values[1]);
if (success)
{
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
if (plug_in)
{
gchar *canonical = gimp_canonicalize_identifier (procedure_name);
success = gimp_plug_in_menu_register (plug_in, canonical, menu_path);
g_free (canonical);
}
else
{
success = FALSE;
}
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
procedural_db_set_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
const gchar *identifier;
gint32 bytes;
const guint8 *data;
identifier = g_value_get_string (gimp_value_array_index (args, 0));
bytes = g_value_get_int (gimp_value_array_index (args, 1));
data = gimp_value_get_int8array (gimp_value_array_index (args, 2));
if (success)
{
gchar *canonical = gimp_canonicalize_identifier (identifier);
gimp_plug_in_manager_set_data (gimp->plug_in_manager,
canonical, bytes, data);
g_free (canonical);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
procedural_db_get_data_size_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *identifier;
gint32 bytes = 0;
identifier = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
gchar *canonical = gimp_canonicalize_identifier (identifier);
if (! gimp_plug_in_manager_get_data (gimp->plug_in_manager,
canonical, &bytes))
success = FALSE;
g_free (canonical);
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_int (gimp_value_array_index (return_vals, 1), bytes);
return return_vals;
}
static GimpValueArray *
register_file_handler_mime_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
const gchar *procedure_name;
const gchar *mime_type;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
mime_type = g_value_get_string (gimp_value_array_index (args, 1));
if (success)
{
gchar *canonical = gimp_canonicalize_identifier (procedure_name);
success = gimp_plug_in_manager_register_mime_type (gimp->plug_in_manager,
canonical, mime_type);
g_free (canonical);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
register_magic_load_handler_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
const gchar *procedure_name;
const gchar *extensions;
const gchar *prefixes;
const gchar *magics;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
extensions = g_value_get_string (gimp_value_array_index (args, 1));
prefixes = g_value_get_string (gimp_value_array_index (args, 2));
magics = g_value_get_string (gimp_value_array_index (args, 3));
if (success)
{
gchar *canonical = gimp_canonicalize_identifier (procedure_name);
success = gimp_plug_in_manager_register_load_handler (gimp->plug_in_manager,
canonical,
extensions, prefixes, magics);
g_free (canonical);
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
procedural_db_proc_info_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *procedure_name;
gchar *blurb = NULL;
gchar *help = NULL;
gchar *author = NULL;
gchar *copyright = NULL;
gchar *date = NULL;
gint32 proc_type = 0;
gint32 num_args = 0;
gint32 num_values = 0;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
GimpPDBProcType ptype;
gchar *canonical;
canonical = gimp_canonicalize_identifier (procedure_name);
success = gimp_pdb_proc_info (gimp->pdb, canonical,
&blurb, &help, &author,
©right, &date, &ptype,
&num_args, &num_values,
error);
proc_type = ptype;
g_free (canonical);
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_take_string (gimp_value_array_index (return_vals, 1), blurb);
g_value_take_string (gimp_value_array_index (return_vals, 2), help);
g_value_take_string (gimp_value_array_index (return_vals, 3), author);
g_value_take_string (gimp_value_array_index (return_vals, 4), copyright);
g_value_take_string (gimp_value_array_index (return_vals, 5), date);
g_value_set_enum (gimp_value_array_index (return_vals, 6), proc_type);
g_value_set_int (gimp_value_array_index (return_vals, 7), num_args);
g_value_set_int (gimp_value_array_index (return_vals, 8), num_values);
}
return return_vals;
}
static GValueArray *
plugin_icon_register_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args,
GError **error)
{
gboolean success = TRUE;
const gchar *procedure_name;
gint32 icon_type;
gint32 icon_data_length;
const guint8 *icon_data;
procedure_name = g_value_get_string (&args->values[0]);
icon_type = g_value_get_enum (&args->values[1]);
icon_data_length = g_value_get_int (&args->values[2]);
icon_data = gimp_value_get_int8array (&args->values[3]);
if (success)
{
GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
if (plug_in && plug_in->call_mode == GIMP_PLUG_IN_CALL_QUERY)
{
GimpPlugInProcedure *proc;
gchar *canonical;
canonical = gimp_canonicalize_identifier (procedure_name);
proc = gimp_plug_in_procedure_find (plug_in->plug_in_def->procedures,
canonical);
g_free (canonical);
if (proc)
gimp_plug_in_procedure_set_icon (proc, icon_type,
icon_data, icon_data_length);
else
success = FALSE;
}
else
{
success = FALSE;
}
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GimpValueArray *
procedural_db_proc_exists_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *procedure_name;
gboolean exists = FALSE;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
GimpProcedure *procedure;
gchar *canonical;
canonical = gimp_canonicalize_identifier (procedure_name);
procedure = gimp_pdb_lookup_procedure (gimp->pdb, canonical);
if (! procedure)
{
procedure_name = gimp_pdb_lookup_compat_proc_name (gimp->pdb, canonical);
if (procedure_name)
procedure = gimp_pdb_lookup_procedure (gimp->pdb, procedure_name);
}
g_free (canonical);
exists = (procedure != NULL);
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
g_value_set_boolean (gimp_value_array_index (return_vals, 1), exists);
return return_vals;
}
static void
gimp_plug_in_handle_proc_uninstall (GimpPlugIn *plug_in,
GPProcUninstall *proc_uninstall)
{
GimpPlugInProcedure *proc;
gchar *canonical;
g_return_if_fail (proc_uninstall != NULL);
g_return_if_fail (proc_uninstall->name != NULL);
canonical = gimp_canonicalize_identifier (proc_uninstall->name);
proc = gimp_plug_in_procedure_find (plug_in->temp_procedures, canonical);
if (proc)
gimp_plug_in_remove_temp_proc (plug_in, GIMP_TEMPORARY_PROCEDURE (proc));
g_free (canonical);
}
static GTokenType
plug_in_procedure_deserialize (GScanner *scanner,
Gimp *gimp,
GFile *file,
GimpPlugInProcedure **proc)
{
GimpProcedure *procedure;
GTokenType token;
gchar *str;
gint proc_type;
gint n_args;
gint n_return_vals;
gint n_menu_paths;
gint i;
if (! gimp_scanner_parse_string (scanner, &str))
return G_TOKEN_STRING;
if (! gimp_scanner_parse_int (scanner, &proc_type))
{
g_free (str);
return G_TOKEN_INT;
}
procedure = gimp_plug_in_procedure_new (proc_type, file);
*proc = GIMP_PLUG_IN_PROCEDURE (procedure);
gimp_object_take_name (GIMP_OBJECT (procedure),
gimp_canonicalize_identifier (str));
procedure->original_name = str;
if (! gimp_scanner_parse_string (scanner, &procedure->blurb))
return G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &procedure->help))
return G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &procedure->author))
return G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &procedure->copyright))
return G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &procedure->date))
return G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &(*proc)->menu_label))
return G_TOKEN_STRING;
if (! gimp_scanner_parse_int (scanner, &n_menu_paths))
return G_TOKEN_INT;
for (i = 0; i < n_menu_paths; i++)
{
token = plug_in_menu_path_deserialize (scanner, *proc);
if (token != G_TOKEN_LEFT_PAREN)
return token;
}
token = plug_in_icon_deserialize (scanner, *proc);
if (token != G_TOKEN_LEFT_PAREN)
return token;
token = plug_in_file_proc_deserialize (scanner, *proc);
if (token != G_TOKEN_LEFT_PAREN)
return token;
if (! gimp_scanner_parse_string (scanner, &str))
return G_TOKEN_STRING;
gimp_plug_in_procedure_set_image_types (*proc, str);
g_free (str);
if (! gimp_scanner_parse_int (scanner, (gint *) &n_args))
return G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, (gint *) &n_return_vals))
return G_TOKEN_INT;
for (i = 0; i < n_args; i++)
{
token = plug_in_proc_arg_deserialize (scanner, gimp, procedure, FALSE);
if (token != G_TOKEN_LEFT_PAREN)
return token;
}
for (i = 0; i < n_return_vals; i++)
{
token = plug_in_proc_arg_deserialize (scanner, gimp, procedure, TRUE);
if (token != G_TOKEN_LEFT_PAREN)
return token;
}
if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN))
return G_TOKEN_RIGHT_PAREN;
return G_TOKEN_LEFT_PAREN;
}
static GimpValueArray *
procedural_db_proc_val_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *procedure_name;
gint32 val_num;
gint32 val_type = 0;
gchar *val_name = NULL;
gchar *val_desc = NULL;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
val_num = g_value_get_int (gimp_value_array_index (args, 1));
if (success)
{
GimpProcedure *proc;
gchar *canonical;
canonical = gimp_canonicalize_identifier (procedure_name);
proc = gimp_pdb_lookup_procedure (gimp->pdb, canonical);
if (! proc)
{
const gchar *compat_name;
compat_name = gimp_pdb_lookup_compat_proc_name (gimp->pdb, canonical);
if (compat_name)
proc = gimp_pdb_lookup_procedure (gimp->pdb, compat_name);
}
g_free (canonical);
if (proc && (val_num >= 0 && val_num < proc->num_values))
{
GParamSpec *pspec = proc->values[val_num];
val_type = gimp_pdb_compat_arg_type_from_gtype (G_PARAM_SPEC_VALUE_TYPE (pspec));
val_name = g_strdup (g_param_spec_get_name (pspec));
val_desc = gimp_param_spec_get_desc (pspec);
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_enum (gimp_value_array_index (return_vals, 1), val_type);
g_value_take_string (gimp_value_array_index (return_vals, 2), val_name);
g_value_take_string (gimp_value_array_index (return_vals, 3), val_desc);
}
return return_vals;
}
static void
gimp_plug_in_handle_proc_install (GimpPlugIn *plug_in,
GPProcInstall *proc_install)
{
GimpPlugInProcedure *proc = NULL;
GimpProcedure *procedure = NULL;
gchar *canonical;
gboolean null_name = FALSE;
gboolean valid_utf8 = FALSE;
gint i;
g_return_if_fail (proc_install != NULL);
g_return_if_fail (proc_install->name != NULL);
canonical = gimp_canonicalize_identifier (proc_install->name);
/* Sanity check for array arguments */
for (i = 1; i < proc_install->nparams; i++)
{
if ((proc_install->params[i].type == GIMP_PDB_INT32ARRAY ||
proc_install->params[i].type == GIMP_PDB_INT8ARRAY ||
proc_install->params[i].type == GIMP_PDB_FLOATARRAY ||
proc_install->params[i].type == GIMP_PDB_STRINGARRAY ||
proc_install->params[i].type == GIMP_PDB_COLORARRAY)
&&
proc_install->params[i - 1].type != GIMP_PDB_INT32)
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"Plug-In \"%s\"\n(%s)\n\n"
"attempted to install procedure \"%s\" "
"which fails to comply with the array parameter "
"passing standard. Argument %d is noncompliant.",
gimp_object_get_name (plug_in),
gimp_file_get_utf8_name (plug_in->file),
canonical, i);
g_free (canonical);
return;
}
}
/* Sanity check strings for UTF-8 validity */
#define VALIDATE(str) (g_utf8_validate ((str), -1, NULL))
#define VALIDATE_OR_NULL(str) ((str) == NULL || g_utf8_validate ((str), -1, NULL))
if (VALIDATE_OR_NULL (proc_install->menu_path) &&
VALIDATE (canonical) &&
VALIDATE_OR_NULL (proc_install->blurb) &&
VALIDATE_OR_NULL (proc_install->help) &&
VALIDATE_OR_NULL (proc_install->author) &&
VALIDATE_OR_NULL (proc_install->copyright) &&
VALIDATE_OR_NULL (proc_install->date))
{
null_name = FALSE;
valid_utf8 = TRUE;
for (i = 0; i < proc_install->nparams && valid_utf8 && !null_name; i++)
{
if (! proc_install->params[i].name)
{
null_name = TRUE;
}
else if (! (VALIDATE (proc_install->params[i].name) &&
VALIDATE_OR_NULL (proc_install->params[i].description)))
{
valid_utf8 = FALSE;
}
}
for (i = 0; i < proc_install->nreturn_vals && valid_utf8 && !null_name; i++)
{
if (! proc_install->return_vals[i].name)
{
null_name = TRUE;
}
else if (! (VALIDATE (proc_install->return_vals[i].name) &&
VALIDATE_OR_NULL (proc_install->return_vals[i].description)))
{
valid_utf8 = FALSE;
}
}
}
#undef VALIDATE
#undef VALIDATE_OR_NULL
if (null_name)
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"Plug-In \"%s\"\n(%s)\n\n"
"attempted to install a procedure NULL parameter name.",
gimp_object_get_name (plug_in),
gimp_file_get_utf8_name (plug_in->file));
g_free (canonical);
return;
}
if (! valid_utf8)
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"Plug-In \"%s\"\n(%s)\n\n"
"attempted to install a procedure with invalid UTF-8 strings.",
gimp_object_get_name (plug_in),
gimp_file_get_utf8_name (plug_in->file));
g_free (canonical);
return;
}
/* Create the procedure object */
switch (proc_install->type)
{
case GIMP_PLUGIN:
case GIMP_EXTENSION:
procedure = gimp_plug_in_procedure_new (proc_install->type,
plug_in->file);
break;
case GIMP_TEMPORARY:
procedure = gimp_temporary_procedure_new (plug_in);
break;
}
proc = GIMP_PLUG_IN_PROCEDURE (procedure);
proc->mtime = time (NULL);
proc->installed_during_init = (plug_in->call_mode == GIMP_PLUG_IN_CALL_INIT);
gimp_object_take_name (GIMP_OBJECT (procedure), canonical);
gimp_procedure_set_strings (procedure,
proc_install->name,
proc_install->blurb,
proc_install->help,
proc_install->author,
proc_install->copyright,
proc_install->date,
NULL);
gimp_plug_in_procedure_set_image_types (proc, proc_install->image_types);
for (i = 0; i < proc_install->nparams; i++)
{
GParamSpec *pspec =
gimp_pdb_compat_param_spec (plug_in->manager->gimp,
proc_install->params[i].type,
proc_install->params[i].name,
proc_install->params[i].description);
gimp_procedure_add_argument (procedure, pspec);
}
for (i = 0; i < proc_install->nreturn_vals; i++)
{
GParamSpec *pspec =
gimp_pdb_compat_param_spec (plug_in->manager->gimp,
proc_install->return_vals[i].type,
proc_install->return_vals[i].name,
proc_install->return_vals[i].description);
gimp_procedure_add_return_value (procedure, pspec);
}
/* Sanity check menu path */
if (proc_install->menu_path && strlen (proc_install->menu_path))
{
if (proc_install->menu_path[0] == '<')
{
GError *error = NULL;
if (! gimp_plug_in_procedure_add_menu_path (proc,
proc_install->menu_path,
&error))
{
gimp_message_literal (plug_in->manager->gimp,
NULL, GIMP_MESSAGE_WARNING,
error->message);
g_clear_error (&error);
}
}
else
{
proc->menu_label = g_strdup (proc_install->menu_path);
}
}
/* Install the procedure */
switch (proc_install->type)
{
case GIMP_PLUGIN:
case GIMP_EXTENSION:
gimp_plug_in_def_add_procedure (plug_in->plug_in_def, proc);
break;
case GIMP_TEMPORARY:
gimp_plug_in_add_temp_proc (plug_in, GIMP_TEMPORARY_PROCEDURE (proc));
break;
}
g_object_unref (proc);
}
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);
}