static void
gimp_temporary_procedure_execute_async (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpValueArray *args,
GimpObject *display)
{
GimpTemporaryProcedure *temp_procedure = GIMP_TEMPORARY_PROCEDURE (procedure);
GimpValueArray *return_vals;
return_vals = gimp_plug_in_manager_call_run_temp (gimp->plug_in_manager,
context, progress,
temp_procedure,
args);
if (return_vals)
{
GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (procedure);
gimp_plug_in_procedure_handle_return_values (proc,
gimp, progress,
return_vals);
gimp_value_array_unref (return_vals);
}
}
void
gimp_plug_in_add_temp_proc (GimpPlugIn *plug_in,
GimpTemporaryProcedure *proc)
{
GimpPlugInProcedure *overridden;
const gchar *locale_domain;
const gchar *help_domain;
g_return_if_fail (GIMP_IS_PLUG_IN (plug_in));
g_return_if_fail (GIMP_IS_TEMPORARY_PROCEDURE (proc));
overridden = gimp_plug_in_procedure_find (plug_in->temp_procedures,
gimp_object_get_name (proc));
if (overridden)
gimp_plug_in_remove_temp_proc (plug_in,
GIMP_TEMPORARY_PROCEDURE (overridden));
locale_domain = gimp_plug_in_manager_get_locale_domain (plug_in->manager,
plug_in->prog,
NULL);
help_domain = gimp_plug_in_manager_get_help_domain (plug_in->manager,
plug_in->prog,
NULL);
gimp_plug_in_procedure_set_locale_domain (GIMP_PLUG_IN_PROCEDURE (proc),
locale_domain);
gimp_plug_in_procedure_set_help_domain (GIMP_PLUG_IN_PROCEDURE (proc),
help_domain);
plug_in->temp_procedures = g_slist_prepend (plug_in->temp_procedures,
g_object_ref (proc));
gimp_plug_in_manager_add_temp_proc (plug_in->manager, proc);
}
static GValueArray *
gimp_temporary_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args)
{
return gimp_plug_in_manager_call_run_temp (gimp->plug_in_manager,
context, progress,
GIMP_TEMPORARY_PROCEDURE (procedure),
args);
}
gboolean
gimp_plug_in_progress_install (GimpPlugIn *plug_in,
const gchar *progress_callback)
{
GimpPlugInProcFrame *proc_frame;
GimpProcedure *procedure;
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), FALSE);
g_return_val_if_fail (progress_callback != NULL, FALSE);
procedure = gimp_pdb_lookup_procedure (plug_in->manager->gimp->pdb,
progress_callback);
if (! GIMP_IS_TEMPORARY_PROCEDURE (procedure) ||
GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in != plug_in ||
procedure->num_args != 3 ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
! G_IS_PARAM_SPEC_DOUBLE (procedure->args[2]))
{
return FALSE;
}
proc_frame = gimp_plug_in_get_proc_frame (plug_in);
if (proc_frame->progress)
{
gimp_plug_in_progress_end (plug_in, proc_frame);
if (proc_frame->progress)
{
g_object_unref (proc_frame->progress);
proc_frame->progress = NULL;
}
}
proc_frame->progress = g_object_new (GIMP_TYPE_PDB_PROGRESS,
"pdb", plug_in->manager->gimp->pdb,
"context", proc_frame->main_context,
"callback-name", progress_callback,
NULL);
gimp_plug_in_progress_attach (proc_frame->progress);
return TRUE;
}
static void
gimp_temporary_procedure_execute_async (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args,
GimpObject *display)
{
GValueArray *return_vals;
return_vals = gimp_plug_in_manager_call_run_temp (gimp->plug_in_manager,
context, progress,
GIMP_TEMPORARY_PROCEDURE (procedure),
args);
g_value_array_free (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 GFile *
gimp_temporary_procedure_get_file (const GimpPlugInProcedure *procedure)
{
return GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in->file;
}
const gchar *
gimp_temporary_procedure_get_progname (const GimpPlugInProcedure *procedure)
{
return GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in->prog;
}
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);
}
