gboolean
procedure_commands_run_procedure (GimpProcedure *procedure,
Gimp *gimp,
GimpProgress *progress,
GimpRunMode run_mode,
GimpValueArray *args,
GimpDisplay *display)
{
GError *error = NULL;
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), FALSE);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);
g_return_val_if_fail (display == NULL || GIMP_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (args != NULL, FALSE);
g_value_set_int (gimp_value_array_index (args, 0), run_mode);
gimp_procedure_execute_async (procedure, gimp,
gimp_get_user_context (gimp),
progress, args,
GIMP_OBJECT (display), &error);
if (error)
{
gimp_message_literal (gimp,
G_OBJECT (progress), GIMP_MESSAGE_ERROR,
error->message);
g_clear_error (&error);
return FALSE;
}
return TRUE;
}
void
gimp_procedure_execute_async (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args,
GimpObject *display,
GError **error)
{
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_CONTEXT (context));
g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
g_return_if_fail (args != NULL);
g_return_if_fail (display == NULL || GIMP_IS_OBJECT (display));
g_return_if_fail (error == NULL || *error == NULL);
if (gimp_procedure_validate_args (procedure,
procedure->args, procedure->num_args,
args, FALSE, error))
{
if (GIMP_IS_PDB_CONTEXT (context))
context = g_object_ref (context);
else
context = gimp_pdb_context_new (gimp, context, TRUE);
GIMP_PROCEDURE_GET_CLASS (procedure)->execute_async (procedure, gimp,
context, progress,
args, display);
g_object_unref (context);
}
}
const gchar *
gimp_procedure_get_help_id (GimpProcedure *procedure)
{
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), NULL);
return GIMP_PROCEDURE_GET_CLASS (procedure)->get_help_id (procedure);
}
gboolean
gimp_procedure_get_sensitive (GimpProcedure *procedure,
GimpObject *object)
{
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), FALSE);
g_return_val_if_fail (object == NULL || GIMP_IS_OBJECT (object), FALSE);
return GIMP_PROCEDURE_GET_CLASS (procedure)->get_sensitive (procedure,
object);
}
void
gimp_pdb_unregister_procedure (GimpPDB *pdb,
GimpProcedure *procedure)
{
g_return_if_fail (GIMP_IS_PDB (pdb));
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
g_signal_emit (pdb, gimp_pdb_signals[UNREGISTER_PROCEDURE], 0,
procedure);
}
void
gimp_pdb_register_procedure (GimpPDB *pdb,
GimpProcedure *procedure)
{
g_return_if_fail (GIMP_IS_PDB (pdb));
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
if (! procedure->deprecated ||
pdb->gimp->pdb_compat_mode != GIMP_PDB_COMPAT_OFF)
{
g_signal_emit (pdb, gimp_pdb_signals[REGISTER_PROCEDURE], 0,
procedure);
}
}
void
gimp_procedure_add_return_value (GimpProcedure *procedure,
GParamSpec *pspec)
{
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
g_return_if_fail (G_IS_PARAM_SPEC (pspec));
procedure->values = g_renew (GParamSpec *, procedure->values,
procedure->num_values + 1);
procedure->values[procedure->num_values] = pspec;
g_param_spec_ref_sink (pspec);
procedure->num_values++;
}
void
gimp_procedure_add_argument (GimpProcedure *procedure,
GParamSpec *pspec)
{
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
g_return_if_fail (G_IS_PARAM_SPEC (pspec));
procedure->args = g_renew (GParamSpec *, procedure->args,
procedure->num_args + 1);
procedure->args[procedure->num_args] = pspec;
g_param_spec_ref (pspec);
g_param_spec_sink (pspec);
procedure->num_args++;
}
GValueArray *
gimp_procedure_get_arguments (GimpProcedure *procedure)
{
GValueArray *args;
GValue value = { 0, };
gint i;
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), NULL);
args = g_value_array_new (procedure->num_args);
for (i = 0; i < procedure->num_args; i++)
{
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (procedure->args[i]));
g_value_array_append (args, &value);
g_value_unset (&value);
}
return args;
}
void
gimp_filter_history_remove (Gimp *gimp,
GimpProcedure *procedure)
{
GList *link;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
link = g_list_find_custom (gimp->filter_history, procedure,
(GCompareFunc) gimp_filter_history_compare);
if (link)
{
g_object_unref (link->data);
gimp->filter_history = g_list_delete_link (gimp->filter_history, link);
gimp_filter_history_changed (gimp);
}
}
void
gimp_filter_history_add (Gimp *gimp,
GimpProcedure *procedure)
{
GList *link;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
/* return early if the procedure is already at the top */
if (gimp->filter_history &&
gimp_filter_history_compare (gimp->filter_history->data, procedure) == 0)
return;
/* ref new first then unref old, they might be the same */
g_object_ref (procedure);
link = g_list_find_custom (gimp->filter_history, procedure,
(GCompareFunc) gimp_filter_history_compare);
if (link)
{
g_object_unref (link->data);
gimp->filter_history = g_list_delete_link (gimp->filter_history, link);
}
gimp->filter_history = g_list_prepend (gimp->filter_history, procedure);
link = g_list_nth (gimp->filter_history, gimp_filter_history_size (gimp));
if (link)
{
g_object_unref (link->data);
gimp->filter_history = g_list_delete_link (gimp->filter_history, link);
}
gimp_filter_history_changed (gimp);
}
void
gimp_procedure_take_strings (GimpProcedure *procedure,
gchar *original_name,
gchar *blurb,
gchar *help,
gchar *author,
gchar *copyright,
gchar *date,
gchar *deprecated)
{
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
gimp_procedure_free_strings (procedure);
procedure->original_name = original_name;
procedure->blurb = blurb;
procedure->help = help;
procedure->author = author;
procedure->copyright = copyright;
procedure->date = date;
procedure->deprecated = deprecated;
procedure->static_strings = FALSE;
}
void
gimp_procedure_set_static_strings (GimpProcedure *procedure,
const gchar *original_name,
const gchar *blurb,
const gchar *help,
const gchar *author,
const gchar *copyright,
const gchar *date,
const gchar *deprecated)
{
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
gimp_procedure_free_strings (procedure);
procedure->original_name = (gchar *) original_name;
procedure->blurb = (gchar *) blurb;
procedure->help = (gchar *) help;
procedure->author = (gchar *) author;
procedure->copyright = (gchar *) copyright;
procedure->date = (gchar *) date;
procedure->deprecated = (gchar *) deprecated;
procedure->static_strings = TRUE;
}
void
gimp_procedure_set_strings (GimpProcedure *procedure,
const gchar *original_name,
const gchar *blurb,
const gchar *help,
const gchar *author,
const gchar *copyright,
const gchar *date,
const gchar *deprecated)
{
g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
gimp_procedure_free_strings (procedure);
procedure->original_name = g_strdup (original_name);
procedure->blurb = g_strdup (blurb);
procedure->help = g_strdup (help);
procedure->author = g_strdup (author);
procedure->copyright = g_strdup (copyright);
procedure->date = g_strdup (date);
procedure->deprecated = g_strdup (deprecated);
procedure->static_strings = FALSE;
}
GValueArray *
gimp_procedure_get_return_values (GimpProcedure *procedure,
gboolean success,
const GError *error)
{
GValueArray *args;
GValue value = { 0, };
gint i;
g_return_val_if_fail (success == FALSE || GIMP_IS_PROCEDURE (procedure),
NULL);
if (success)
{
args = g_value_array_new (procedure->num_values + 1);
g_value_init (&value, GIMP_TYPE_PDB_STATUS_TYPE);
g_value_set_enum (&value, GIMP_PDB_SUCCESS);
g_value_array_append (args, &value);
g_value_unset (&value);
for (i = 0; i < procedure->num_values; i++)
{
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (procedure->values[i]));
g_value_array_append (args, &value);
g_value_unset (&value);
}
}
else
{
args = g_value_array_new ((error && error->message) ? 2 : 1);
g_value_init (&value, GIMP_TYPE_PDB_STATUS_TYPE);
/* errors in the GIMP_PDB_ERROR domain are calling errors */
if (error && error->domain == GIMP_PDB_ERROR)
{
switch ((GimpPdbErrorCode) error->code)
{
case GIMP_PDB_PROCEDURE_NOT_FOUND:
case GIMP_PDB_INVALID_ARGUMENT:
case GIMP_PDB_INVALID_RETURN_VALUE:
case GIMP_PDB_INTERNAL_ERROR:
g_value_set_enum (&value, GIMP_PDB_CALLING_ERROR);
break;
case GIMP_PDB_CANCELLED:
g_value_set_enum (&value, GIMP_PDB_CANCEL);
break;
default:
g_assert_not_reached ();
}
}
else
{
g_value_set_enum (&value, GIMP_PDB_EXECUTION_ERROR);
}
g_value_array_append (args, &value);
g_value_unset (&value);
if (error && error->message)
{
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, error->message);
g_value_array_append (args, &value);
g_value_unset (&value);
}
}
return args;
}
GimpValueArray *
gimp_pdb_execute_procedure_by_name_args (GimpPDB *pdb,
GimpContext *context,
GimpProgress *progress,
GError **error,
const gchar *name,
GimpValueArray *args)
{
GimpValueArray *return_vals = NULL;
GList *list;
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);
list = g_hash_table_lookup (pdb->procedures, name);
if (list == NULL)
{
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;
}
g_return_val_if_fail (args != NULL, NULL);
for (; list; list = g_list_next (list))
{
GimpProcedure *procedure = list->data;
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), NULL);
return_vals = gimp_procedure_execute (procedure,
pdb->gimp, context, progress,
args, error);
if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) ==
GIMP_PDB_PASS_THROUGH)
{
/* If the return value is GIMP_PDB_PASS_THROUGH and there is
* a next procedure in the list, destroy the return values
* and run the next procedure.
*/
if (g_list_next (list))
{
gimp_value_array_unref (return_vals);
g_clear_error (error);
}
}
else
{
/* No GIMP_PDB_PASS_THROUGH, break out of the list of
* procedures and return the current return values.
*/
break;
}
}
return return_vals;
}
GValueArray *
gimp_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args,
GError **error)
{
GValueArray *return_vals;
GError *pdb_error = NULL;
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), NULL);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), 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 (args != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (! gimp_procedure_validate_args (procedure,
procedure->args, procedure->num_args,
args, FALSE, &pdb_error))
{
return_vals = gimp_procedure_get_return_values (procedure, FALSE,
pdb_error);
g_propagate_error (error, pdb_error);
return return_vals;
}
if (GIMP_IS_PDB_CONTEXT (context))
context = g_object_ref (context);
else
context = gimp_pdb_context_new (gimp, context, TRUE);
/* call the procedure */
return_vals = GIMP_PROCEDURE_GET_CLASS (procedure)->execute (procedure,
gimp,
context,
progress,
args,
error);
g_object_unref (context);
if (return_vals)
{
switch (g_value_get_enum (&return_vals->values[0]))
{
case GIMP_PDB_CALLING_ERROR:
case GIMP_PDB_EXECUTION_ERROR:
/* If the error has not already been set, construct one
* from the error message that is optionally passed with
* the return values.
*/
if (error && *error == NULL)
{
if (return_vals->n_values > 1 &&
G_VALUE_HOLDS_STRING (&return_vals->values[1]))
{
g_set_error_literal (error, GIMP_PDB_ERROR, GIMP_PDB_FAILED,
g_value_get_string (&return_vals->values[1]));
}
}
break;
default:
break;
}
}
else
{
g_warning ("%s: no return values, shouldn't happen", G_STRFUNC);
pdb_error = g_error_new (GIMP_PDB_ERROR, GIMP_PDB_INVALID_RETURN_VALUE,
_("Procedure '%s' returned no return values"),
gimp_object_get_name (procedure));
return_vals = gimp_procedure_get_return_values (procedure, FALSE,
pdb_error);
if (error && *error == NULL)
g_propagate_error (error, pdb_error);
else
g_error_free (pdb_error);
}
return return_vals;
}
