static void
plug_in_procedure_execute (GimpPlugInProcedure *procedure,
Gimp *gimp,
GimpDisplay *display,
GimpValueArray *args,
gint n_args)
{
GError *error = NULL;
gimp_value_array_truncate (args, n_args);
/* run the plug-in procedure */
gimp_procedure_execute_async (GIMP_PROCEDURE (procedure), gimp,
gimp_get_user_context (gimp),
GIMP_PROGRESS (display), args,
GIMP_OBJECT (display), &error);
if (error)
{
gimp_message_literal (gimp,
G_OBJECT (display), GIMP_MESSAGE_ERROR,
error->message);
g_error_free (error);
}
else
{
/* remember only image plug-ins */
if (GIMP_PROCEDURE (procedure)->num_args >= 2 &&
GIMP_IS_PARAM_SPEC_IMAGE_ID (GIMP_PROCEDURE (procedure)->args[1]))
{
gimp_plug_in_manager_history_add (gimp->plug_in_manager, procedure);
}
}
}
void
plug_in_repeat_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpPlugInProcedure *procedure;
Gimp *gimp;
GimpDisplay *display;
GimpRunMode run_mode;
return_if_no_gimp (gimp, data);
return_if_no_display (display, data);
run_mode = (GimpRunMode) value;
procedure = gimp_plug_in_manager_history_nth (gimp->plug_in_manager, 0);
if (procedure)
{
GimpValueArray *args;
gint n_args;
args = gimp_procedure_get_arguments (GIMP_PROCEDURE (procedure));
g_value_set_int (gimp_value_array_index (args, 0), run_mode);
n_args = plug_in_collect_display_args (action, display,
GIMP_PROCEDURE (procedure)->args,
args, 1);
plug_in_procedure_execute (procedure, gimp, display, args, n_args);
gimp_value_array_unref (args);
}
}
static void
plug_in_actions_add_proc (GimpActionGroup *group,
GimpPlugInProcedure *proc)
{
GimpProcedureActionEntry entry;
const gchar *locale_domain;
GList *list;
locale_domain = gimp_plug_in_procedure_get_locale_domain (proc);
entry.name = gimp_object_get_name (proc);
entry.icon_name = gimp_viewable_get_icon_name (GIMP_VIEWABLE (proc));
entry.label = gimp_procedure_get_menu_label (GIMP_PROCEDURE (proc));
entry.accelerator = NULL;
entry.tooltip = gimp_procedure_get_blurb (GIMP_PROCEDURE (proc));
entry.procedure = GIMP_PROCEDURE (proc);
entry.help_id = gimp_procedure_get_help_id (GIMP_PROCEDURE (proc));
gimp_action_group_add_procedure_actions (group, &entry, 1,
G_CALLBACK (plug_in_run_cmd_callback));
for (list = proc->menu_paths; list; list = g_list_next (list))
{
const gchar *original = list->data;
const gchar *translated = dgettext (locale_domain, original);
if (plug_in_actions_check_translation (original, translated))
plug_in_actions_build_path (group, original, translated);
else
plug_in_actions_build_path (group, original, original);
}
if (proc->image_types_val)
{
GimpContext *context = gimp_get_user_context (group->gimp);
GimpImage *image = gimp_context_get_image (context);
GimpDrawable *drawable = NULL;
gboolean sensitive;
const gchar *tooltip;
if (image)
drawable = gimp_image_get_active_drawable (image);
sensitive = gimp_procedure_get_sensitive (GIMP_PROCEDURE (proc),
GIMP_OBJECT (drawable),
&tooltip);
gimp_action_group_set_action_sensitive (group,
gimp_object_get_name (proc),
sensitive);
if (! sensitive && drawable && tooltip)
gimp_action_group_set_action_tooltip (group,
gimp_object_get_name (proc),
tooltip);
}
}
/**
* gimp_pdb_get_deprecated_procedures:
* @pdb:
*
* Returns: A new #GList with the deprecated procedures. Free with
* g_list_free().
**/
GList *
gimp_pdb_get_deprecated_procedures (GimpPDB *pdb)
{
GList *result = NULL;
GList *procs;
GList *iter;
g_return_val_if_fail (GIMP_IS_PDB (pdb), NULL);
procs = g_hash_table_get_values (pdb->procedures);
for (iter = procs;
iter;
iter = g_list_next (iter))
{
GList *proc_list = iter->data;
/* Only care about the first procedure in the list */
GimpProcedure *procedure = GIMP_PROCEDURE (proc_list->data);
if (procedure->deprecated)
result = g_list_prepend (result, procedure);
}
result = g_list_sort (result, (GCompareFunc) gimp_procedure_name_compare);
g_list_free (procs);
return result;
}
gboolean
gimp_plug_in_manager_register_save_handler (GimpPlugInManager *manager,
const gchar *name,
const gchar *extensions,
const gchar *prefixes)
{
GimpPlugInProcedure *file_proc;
GimpProcedure *procedure;
GSList *list;
g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), FALSE);
g_return_val_if_fail (name != NULL, FALSE);
if (manager->current_plug_in && manager->current_plug_in->plug_in_def)
list = manager->current_plug_in->plug_in_def->procedures;
else
list = manager->plug_in_procedures;
file_proc = gimp_plug_in_procedure_find (list, name);
if (! file_proc)
{
gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"attempt to register nonexistent save handler \"%s\"",
name);
return FALSE;
}
procedure = GIMP_PROCEDURE (file_proc);
if ((procedure->num_args < 5) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
! GIMP_IS_PARAM_SPEC_DRAWABLE_ID (procedure->args[2]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[3]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[4]))
{
gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"save handler \"%s\" does not take the standard "
"save handler args", name);
return FALSE;
}
gimp_plug_in_procedure_set_file_proc (file_proc,
extensions, prefixes, NULL);
if (file_procedure_in_group (file_proc, FILE_PROCEDURE_GROUP_SAVE))
{
if (! g_slist_find (manager->save_procs, file_proc))
manager->save_procs = g_slist_prepend (manager->save_procs, file_proc);
}
if (file_procedure_in_group (file_proc, FILE_PROCEDURE_GROUP_EXPORT))
{
if (! g_slist_find (manager->export_procs, file_proc))
manager->export_procs = g_slist_prepend (manager->export_procs, file_proc);
}
return TRUE;
}
static gint64
gimp_procedure_get_memsize (GimpObject *object,
gint64 *gui_size)
{
GimpProcedure *procedure = GIMP_PROCEDURE (object);
gint64 memsize = 0;
gint i;
if (! procedure->static_strings)
{
memsize += gimp_string_get_memsize (procedure->original_name);
memsize += gimp_string_get_memsize (procedure->blurb);
memsize += gimp_string_get_memsize (procedure->help);
memsize += gimp_string_get_memsize (procedure->author);
memsize += gimp_string_get_memsize (procedure->copyright);
memsize += gimp_string_get_memsize (procedure->date);
memsize += gimp_string_get_memsize (procedure->deprecated);
}
memsize += procedure->num_args * sizeof (GParamSpec *);
for (i = 0; i < procedure->num_args; i++)
memsize += gimp_g_param_spec_get_memsize (procedure->args[i]);
memsize += procedure->num_values * sizeof (GParamSpec *);
for (i = 0; i < procedure->num_values; i++)
memsize += gimp_g_param_spec_get_memsize (procedure->values[i]);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);
}
static void
gimp_procedure_finalize (GObject *object)
{
GimpProcedure *procedure = GIMP_PROCEDURE (object);
gint i;
gimp_procedure_free_strings (procedure);
if (procedure->args)
{
for (i = 0; i < procedure->num_args; i++)
g_param_spec_unref (procedure->args[i]);
g_free (procedure->args);
procedure->args = NULL;
}
if (procedure->values)
{
for (i = 0; i < procedure->num_values; i++)
g_param_spec_unref (procedure->values[i]);
g_free (procedure->values);
procedure->values = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_plug_in_procedure_init (GimpPlugInProcedure *proc)
{
GIMP_PROCEDURE (proc)->proc_type = GIMP_PLUGIN;
proc->label = NULL;
proc->icon_data_length = -1;
}
GimpProcedure *
gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
const gchar *prog)
{
GimpPlugInProcedure *proc;
g_return_val_if_fail (proc_type == GIMP_PLUGIN ||
proc_type == GIMP_EXTENSION, NULL);
g_return_val_if_fail (prog != NULL, NULL);
proc = g_object_new (GIMP_TYPE_PLUG_IN_PROCEDURE, NULL);
proc->prog = g_strdup (prog);
GIMP_PROCEDURE (proc)->proc_type = proc_type;
return GIMP_PROCEDURE (proc);
}
GimpProcedure *
gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
GFile *file)
{
GimpPlugInProcedure *proc;
g_return_val_if_fail (proc_type == GIMP_PLUGIN ||
proc_type == GIMP_EXTENSION, NULL);
g_return_val_if_fail (G_IS_FILE (file), NULL);
proc = g_object_new (GIMP_TYPE_PLUG_IN_PROCEDURE, NULL);
proc->file = g_object_ref (file);
GIMP_PROCEDURE (proc)->proc_type = proc_type;
return GIMP_PROCEDURE (proc);
}
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;
}
gboolean
gimp_plug_in_manager_register_load_handler (GimpPlugInManager *manager,
const gchar *name,
const gchar *extensions,
const gchar *prefixes,
const gchar *magics)
{
GimpPlugInProcedure *file_proc;
GimpProcedure *procedure;
GSList *list;
g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), FALSE);
g_return_val_if_fail (name != NULL, FALSE);
if (manager->current_plug_in && manager->current_plug_in->plug_in_def)
list = manager->current_plug_in->plug_in_def->procedures;
else
list = manager->plug_in_procedures;
file_proc = gimp_plug_in_procedure_find (list, name);
if (! file_proc)
{
gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"attempt to register nonexistent load handler \"%s\"",
name);
return FALSE;
}
procedure = GIMP_PROCEDURE (file_proc);
if ((procedure->num_args < 3) ||
(procedure->num_values < 1) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[2]) ||
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->values[0]))
{
gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"load handler \"%s\" does not take the standard "
"load handler args", name);
return FALSE;
}
gimp_plug_in_procedure_set_file_proc (file_proc,
extensions, prefixes, magics);
if (! g_slist_find (manager->load_procs, file_proc))
manager->load_procs = g_slist_prepend (manager->load_procs, file_proc);
return TRUE;
}
GimpProcedure *
gimp_temporary_procedure_new (GimpPlugIn *plug_in)
{
GimpTemporaryProcedure *proc;
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL);
proc = g_object_new (GIMP_TYPE_TEMPORARY_PROCEDURE, NULL);
proc->plug_in = plug_in;
GIMP_PLUG_IN_PROCEDURE (proc)->file = g_file_new_for_path ("none");
return GIMP_PROCEDURE (proc);
}
void
plug_in_history_cmd_callback (GtkAction *action,
GimpPlugInProcedure *procedure,
gpointer data)
{
Gimp *gimp;
GimpDisplay *display;
GimpValueArray *args;
gint n_args;
return_if_no_gimp (gimp, data);
return_if_no_display (display, data);
args = gimp_procedure_get_arguments (GIMP_PROCEDURE (procedure));
g_value_set_int (gimp_value_array_index (args, 0), GIMP_RUN_INTERACTIVE);
n_args = plug_in_collect_display_args (action, display,
GIMP_PROCEDURE (procedure)->args,
args, 1);
plug_in_procedure_execute (procedure, gimp, display, args, n_args);
gimp_value_array_unref (args);
}
const gchar *
gimp_plug_in_procedure_get_blurb (const GimpPlugInProcedure *proc)
{
GimpProcedure *procedure;
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
procedure = GIMP_PROCEDURE (proc);
/* do not to pass the empty string to gettext() */
if (procedure->blurb && strlen (procedure->blurb))
return dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
procedure->blurb);
return NULL;
}
void
plug_in_actions_setup (GimpActionGroup *group)
{
GimpPlugInManager *manager = group->gimp->plug_in_manager;
GSList *list;
gimp_action_group_add_actions (group, "plug-in-action",
plug_in_actions,
G_N_ELEMENTS (plug_in_actions));
for (list = gimp_plug_in_manager_get_menu_branches (manager);
list;
list = g_slist_next (list))
{
GimpPlugInMenuBranch *branch = list->data;
plug_in_actions_menu_branch_added (manager,
branch->file,
branch->menu_path,
branch->menu_label,
group);
}
g_signal_connect_object (manager,
"menu-branch-added",
G_CALLBACK (plug_in_actions_menu_branch_added),
group, 0);
for (list = manager->plug_in_procedures;
list;
list = g_slist_next (list))
{
GimpPlugInProcedure *plug_in_proc = list->data;
if (plug_in_proc->file)
plug_in_actions_register_procedure (group->gimp->pdb,
GIMP_PROCEDURE (plug_in_proc),
group);
}
g_signal_connect_object (group->gimp->pdb, "register-procedure",
G_CALLBACK (plug_in_actions_register_procedure),
group, 0);
g_signal_connect_object (group->gimp->pdb, "unregister-procedure",
G_CALLBACK (plug_in_actions_unregister_procedure),
group, 0);
}
static void
gimp_plug_in_manager_add_to_db (GimpPlugInManager *manager,
GimpContext *context,
GimpPlugInProcedure *proc)
{
gimp_pdb_register_procedure (manager->gimp->pdb, GIMP_PROCEDURE (proc));
if (proc->file_proc)
{
GValueArray *return_vals;
GError *error = NULL;
if (proc->image_types)
{
return_vals =
gimp_pdb_execute_procedure_by_name (manager->gimp->pdb,
context, NULL, &error,
"gimp-register-save-handler",
G_TYPE_STRING, gimp_object_get_name (proc),
G_TYPE_STRING, proc->extensions,
G_TYPE_STRING, proc->prefixes,
G_TYPE_NONE);
}
else
{
return_vals =
gimp_pdb_execute_procedure_by_name (manager->gimp->pdb,
context, NULL, &error,
"gimp-register-magic-load-handler",
G_TYPE_STRING, gimp_object_get_name (proc),
G_TYPE_STRING, proc->extensions,
G_TYPE_STRING, proc->prefixes,
G_TYPE_STRING, proc->magics,
G_TYPE_NONE);
}
g_value_array_free (return_vals);
if (error)
{
gimp_message_literal (manager->gimp, NULL, GIMP_MESSAGE_ERROR,
error->message);
g_error_free (error);
}
}
}
void
plug_in_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpPlugInManager *manager = group->gimp->plug_in_manager;
GimpDrawable *drawable = NULL;
GSList *list;
if (image)
drawable = gimp_image_get_active_drawable (image);
for (list = manager->plug_in_procedures; list; list = g_slist_next (list))
{
GimpPlugInProcedure *proc = list->data;
if (proc->menu_label &&
! proc->file_proc &&
proc->image_types_val)
{
GimpProcedure *procedure = GIMP_PROCEDURE (proc);
gboolean sensitive;
const gchar *tooltip;
sensitive = gimp_procedure_get_sensitive (procedure,
GIMP_OBJECT (drawable),
&tooltip);
gimp_action_group_set_action_sensitive (group,
gimp_object_get_name (proc),
sensitive);
if (sensitive || ! drawable || ! tooltip)
tooltip = gimp_procedure_get_blurb (procedure);
gimp_action_group_set_action_tooltip (group,
gimp_object_get_name (proc),
tooltip);
}
}
}
static gboolean
gimp_option_dump_pdb_procedures_deprecated (const gchar *option_name,
const gchar *value,
gpointer data,
GError **error)
{
Gimp *gimp;
GList *deprecated_procs;
GList *iter;
babl_init ();
gimp = g_object_new (GIMP_TYPE_GIMP, NULL);
/* Make sure to turn on compatibility mode so deprecated procedures
* are included
*/
gimp->pdb_compat_mode = GIMP_PDB_COMPAT_ON;
/* Initialize the list of procedures */
internal_procs_init (gimp->pdb);
/* Get deprecated procedures */
deprecated_procs = gimp_pdb_get_deprecated_procedures (gimp->pdb);
for (iter = deprecated_procs; iter; iter = g_list_next (iter))
{
GimpProcedure *procedure = GIMP_PROCEDURE (iter->data);
g_print ("%s\n", procedure->original_name);
}
g_list_free (deprecated_procs);
g_object_unref (gimp);
app_exit (EXIT_SUCCESS);
return FALSE;
}
/* called from the PDB (gimp_plugin_menu_register) */
gboolean
gimp_plug_in_menu_register (GimpPlugIn *plug_in,
const gchar *proc_name,
const gchar *menu_path)
{
GimpPlugInProcedure *proc = NULL;
GError *error = NULL;
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), FALSE);
g_return_val_if_fail (proc_name != NULL, FALSE);
g_return_val_if_fail (menu_path != NULL, FALSE);
if (plug_in->plug_in_def)
proc = gimp_plug_in_procedure_find (plug_in->plug_in_def->procedures,
proc_name);
if (! proc)
proc = gimp_plug_in_procedure_find (plug_in->temp_procedures, proc_name);
if (! proc)
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"Plug-in \"%s\"\n(%s)\n"
"attempted to register the menu item \"%s\" "
"for the procedure \"%s\".\n"
"It has however not installed that procedure. This "
"is not allowed.",
gimp_object_get_name (plug_in),
gimp_filename_to_utf8 (plug_in->prog),
menu_path, proc_name);
return FALSE;
}
switch (GIMP_PROCEDURE (proc)->proc_type)
{
case GIMP_INTERNAL:
return FALSE;
case GIMP_PLUGIN:
case GIMP_EXTENSION:
if (plug_in->call_mode != GIMP_PLUG_IN_CALL_QUERY &&
plug_in->call_mode != GIMP_PLUG_IN_CALL_INIT)
return FALSE;
case GIMP_TEMPORARY:
break;
}
if (! proc->menu_label)
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"Plug-in \"%s\"\n(%s)\n"
"attempted to register the menu item \"%s\" "
"for procedure \"%s\".\n"
"The menu label given in gimp_install_procedure() "
"already contained a path. To make this work, "
"pass just the menu's label to "
"gimp_install_procedure().",
gimp_object_get_name (plug_in),
gimp_filename_to_utf8 (plug_in->prog),
menu_path, proc_name);
return FALSE;
}
if (! strlen (proc->menu_label))
{
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,
"Plug-in \"%s\"\n(%s)\n"
"attempted to register the procedure \"%s\" "
"in the menu \"%s\", but the procedure has no label. "
"This is not allowed.",
gimp_object_get_name (plug_in),
gimp_filename_to_utf8 (plug_in->prog),
proc_name, menu_path);
return FALSE;
}
if (! gimp_plug_in_procedure_add_menu_path (proc, menu_path, &error))
{
gimp_message_literal (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,
error->message);
g_clear_error (&error);
return FALSE;
}
return TRUE;
}
GimpPDBStatusType
file_save (Gimp *gimp,
GimpImage *image,
GimpProgress *progress,
const gchar *uri,
GimpPlugInProcedure *file_proc,
GimpRunMode run_mode,
gboolean change_saved_state,
gboolean export_backward,
gboolean export_forward,
GError **error)
{
GimpDrawable *drawable;
GimpValueArray *return_vals;
GimpPDBStatusType status;
gchar *filename;
gint32 image_ID;
gint32 drawable_ID;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (uri != NULL, GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (file_proc),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail ((export_backward && export_forward) == FALSE,
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (error == NULL || *error == NULL,
GIMP_PDB_CALLING_ERROR);
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return GIMP_PDB_EXECUTION_ERROR;
filename = file_utils_filename_from_uri (uri);
if (filename)
{
/* check if we are saving to a file */
if (g_file_test (filename, G_FILE_TEST_EXISTS))
{
if (! g_file_test (filename, G_FILE_TEST_IS_REGULAR))
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Not a regular file"));
status = GIMP_PDB_EXECUTION_ERROR;
goto out;
}
if (g_access (filename, W_OK) != 0)
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_ACCES,
g_strerror (errno));
status = GIMP_PDB_EXECUTION_ERROR;
goto out;
}
}
if (file_proc->handles_uri)
{
g_free (filename);
filename = g_strdup (uri);
}
}
else
{
filename = g_strdup (uri);
}
/* ref the image, so it can't get deleted during save */
g_object_ref (image);
image_ID = gimp_image_get_ID (image);
drawable_ID = gimp_item_get_ID (GIMP_ITEM (drawable));
return_vals =
gimp_pdb_execute_procedure_by_name (image->gimp->pdb,
gimp_get_user_context (gimp),
progress, error,
gimp_object_get_name (file_proc),
GIMP_TYPE_INT32, run_mode,
GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_STRING, filename,
G_TYPE_STRING, uri,
G_TYPE_NONE);
status = g_value_get_enum (gimp_value_array_index (return_vals, 0));
gimp_value_array_unref (return_vals);
if (status == GIMP_PDB_SUCCESS)
{
GimpDocumentList *documents;
GimpImagefile *imagefile;
if (change_saved_state)
{
gimp_image_set_uri (image, uri);
gimp_image_set_save_proc (image, file_proc);
/* Forget the import source when we save. We interpret a
* save as that the user is not interested in being able
* to quickly export back to the original any longer
*/
gimp_image_set_imported_uri (image, NULL);
gimp_image_clean_all (image);
}
else if (export_backward)
{
/* We exported the image back to its imported source,
* change nothing about export/import flags, only set
* the export state to clean
*/
gimp_image_export_clean_all (image);
gimp_object_name_changed (GIMP_OBJECT (image));
}
else if (export_forward)
{
/* Remember the last entered Export URI for the image. We
* only need to do this explicitly when exporting. It
* happens implicitly when saving since the GimpObject name
* of a GimpImage is the last-save URI
*/
gimp_image_set_exported_uri (image, uri);
/* An image can not be considered both exported and imported
* at the same time, so stop consider it as imported now
* that we consider it exported.
*/
gimp_image_set_imported_uri (image, NULL);
gimp_image_export_clean_all (image);
}
if (export_backward || export_forward)
gimp_image_exported (image, uri);
else
gimp_image_saved (image, uri);
documents = GIMP_DOCUMENT_LIST (image->gimp->documents);
imagefile = gimp_document_list_add_uri (documents,
uri,
file_proc->mime_type);
/* only save a thumbnail if we are saving as XCF, see bug #25272 */
if (GIMP_PROCEDURE (file_proc)->proc_type == GIMP_INTERNAL)
gimp_imagefile_save_thumbnail (imagefile, file_proc->mime_type, image);
}
else if (status != GIMP_PDB_CANCEL)
{
if (error && *error == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("%s plug-in could not save image"),
gimp_plug_in_procedure_get_label (file_proc));
}
}
gimp_image_flush (image);
g_object_unref (image);
out:
g_free (filename);
return status;
}
GtkWidget *
gimp_file_proc_view_new (Gimp *gimp,
GSList *procedures,
const gchar *automatic,
const gchar *automatic_help_id)
{
GtkTreeView *view;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkListStore *store;
GSList *list;
GtkTreeIter iter;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
store = gtk_list_store_new (N_COLUMNS,
GIMP_TYPE_PLUG_IN_PROCEDURE, /* COLUMN_PROC */
G_TYPE_STRING, /* COLUMN_LABEL */
G_TYPE_STRING, /* COLUMN_EXTENSIONS */
G_TYPE_STRING); /* COLUMN_HELP_ID */
view = g_object_new (GIMP_TYPE_FILE_PROC_VIEW,
"model", store,
"rules-hint", TRUE,
NULL);
g_object_unref (store);
for (list = procedures; list; list = g_slist_next (list))
{
GimpPlugInProcedure *proc = list->data;
if (! proc->prefixes_list) /* skip URL loaders */
{
const gchar *label = gimp_procedure_get_label (GIMP_PROCEDURE (proc));
const gchar *help_id = gimp_procedure_get_help_id (GIMP_PROCEDURE (proc));
GSList *list2;
if (label)
{
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COLUMN_PROC, proc,
COLUMN_LABEL, label,
COLUMN_EXTENSIONS, proc->extensions,
COLUMN_HELP_ID, help_id,
-1);
}
for (list2 = proc->extensions_list;
list2;
list2 = g_slist_next (list2))
{
GimpFileProcView *proc_view = GIMP_FILE_PROC_VIEW (view);
const gchar *ext = list2->data;
const gchar *dot = strchr (ext, '.');
if (dot && dot != ext)
proc_view->meta_extensions =
g_list_append (proc_view->meta_extensions,
g_strdup (dot + 1));
}
}
}
if (automatic)
{
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
COLUMN_PROC, NULL,
COLUMN_LABEL, automatic,
COLUMN_HELP_ID, automatic_help_id,
-1);
}
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("File Type"));
gtk_tree_view_column_set_expand (column, TRUE);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text", COLUMN_LABEL,
NULL);
gtk_tree_view_append_column (view, column);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Extensions"));
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text", COLUMN_EXTENSIONS,
NULL);
gtk_tree_view_append_column (view, column);
g_signal_connect (gtk_tree_view_get_selection (view), "changed",
G_CALLBACK (gimp_file_proc_view_selection_changed),
view);
return GTK_WIDGET (view);
}
gboolean
plug_in_rc_write (GSList *plug_in_defs,
GFile *file,
GError **error)
{
GimpConfigWriter *writer;
GEnumClass *enum_class;
GSList *list;
writer = gimp_config_writer_new_gfile (file,
FALSE,
"GIMP pluginrc\n\n"
"This file can safely be removed and "
"will be automatically regenerated by "
"querying the installed plugins.",
error);
if (!writer)
return FALSE;
enum_class = g_type_class_ref (GIMP_TYPE_ICON_TYPE);
gimp_config_writer_open (writer, "protocol-version");
gimp_config_writer_printf (writer, "%d", GIMP_PROTOCOL_VERSION);
gimp_config_writer_close (writer);
gimp_config_writer_open (writer, "file-version");
gimp_config_writer_printf (writer, "%d", PLUG_IN_RC_FILE_VERSION);
gimp_config_writer_close (writer);
gimp_config_writer_linefeed (writer);
for (list = plug_in_defs; list; list = list->next)
{
GimpPlugInDef *plug_in_def = list->data;
if (plug_in_def->procedures)
{
GSList *list2;
gchar *path;
gchar *utf8;
path = g_file_get_path (plug_in_def->file);
utf8 = g_filename_to_utf8 (path, -1, NULL, NULL, NULL);
g_free (path);
if (! utf8)
continue;
gimp_config_writer_open (writer, "plug-in-def");
gimp_config_writer_string (writer, utf8);
gimp_config_writer_printf (writer, "%"G_GINT64_FORMAT,
plug_in_def->mtime);
g_free (utf8);
for (list2 = plug_in_def->procedures; list2; list2 = list2->next)
{
GimpPlugInProcedure *proc = list2->data;
GimpProcedure *procedure = GIMP_PROCEDURE (proc);
GEnumValue *enum_value;
GList *list3;
gint i;
if (proc->installed_during_init)
continue;
gimp_config_writer_open (writer, "proc-def");
gimp_config_writer_printf (writer, "\"%s\" %d",
procedure->original_name,
procedure->proc_type);
gimp_config_writer_linefeed (writer);
gimp_config_writer_string (writer, procedure->blurb);
gimp_config_writer_linefeed (writer);
gimp_config_writer_string (writer, procedure->help);
gimp_config_writer_linefeed (writer);
gimp_config_writer_string (writer, procedure->author);
gimp_config_writer_linefeed (writer);
gimp_config_writer_string (writer, procedure->copyright);
gimp_config_writer_linefeed (writer);
gimp_config_writer_string (writer, procedure->date);
gimp_config_writer_linefeed (writer);
gimp_config_writer_string (writer, proc->menu_label);
gimp_config_writer_linefeed (writer);
gimp_config_writer_printf (writer, "%d",
g_list_length (proc->menu_paths));
for (list3 = proc->menu_paths; list3; list3 = list3->next)
{
gimp_config_writer_open (writer, "menu-path");
gimp_config_writer_string (writer, list3->data);
gimp_config_writer_close (writer);
}
gimp_config_writer_open (writer, "icon");
enum_value = g_enum_get_value (enum_class, proc->icon_type);
gimp_config_writer_identifier (writer, enum_value->value_nick);
gimp_config_writer_printf (writer, "%d",
proc->icon_data_length);
switch (proc->icon_type)
{
case GIMP_ICON_TYPE_ICON_NAME:
case GIMP_ICON_TYPE_IMAGE_FILE:
gimp_config_writer_string (writer, (gchar *) proc->icon_data);
break;
case GIMP_ICON_TYPE_INLINE_PIXBUF:
gimp_config_writer_data (writer, proc->icon_data_length,
proc->icon_data);
break;
}
gimp_config_writer_close (writer);
if (proc->file_proc)
{
gimp_config_writer_open (writer,
proc->image_types ?
"save-proc" : "load-proc");
if (proc->extensions && *proc->extensions)
{
gimp_config_writer_open (writer, "extension");
gimp_config_writer_string (writer, proc->extensions);
gimp_config_writer_close (writer);
}
if (proc->prefixes && *proc->prefixes)
{
gimp_config_writer_open (writer, "prefix");
gimp_config_writer_string (writer, proc->prefixes);
gimp_config_writer_close (writer);
}
if (proc->magics && *proc->magics)
{
gimp_config_writer_open (writer, "magic");
gimp_config_writer_string (writer, proc->magics);
gimp_config_writer_close (writer);
}
if (proc->mime_type)
{
gimp_config_writer_open (writer, "mime-type");
gimp_config_writer_string (writer, proc->mime_type);
gimp_config_writer_close (writer);
}
if (proc->handles_uri)
{
gimp_config_writer_open (writer, "handles-uri");
gimp_config_writer_close (writer);
}
if (proc->thumb_loader)
{
gimp_config_writer_open (writer, "thumb-loader");
gimp_config_writer_string (writer, proc->thumb_loader);
gimp_config_writer_close (writer);
}
gimp_config_writer_close (writer);
}
gimp_config_writer_linefeed (writer);
gimp_config_writer_string (writer, proc->image_types);
gimp_config_writer_linefeed (writer);
gimp_config_writer_printf (writer, "%d %d",
procedure->num_args,
procedure->num_values);
for (i = 0; i < procedure->num_args; i++)
{
GParamSpec *pspec = procedure->args[i];
gimp_config_writer_open (writer, "proc-arg");
gimp_config_writer_printf (writer, "%d",
gimp_pdb_compat_arg_type_from_gtype (G_PARAM_SPEC_VALUE_TYPE (pspec)));
gimp_config_writer_string (writer,
g_param_spec_get_name (pspec));
gimp_config_writer_string (writer,
g_param_spec_get_blurb (pspec));
gimp_config_writer_close (writer);
}
for (i = 0; i < procedure->num_values; i++)
{
GParamSpec *pspec = procedure->values[i];
gimp_config_writer_open (writer, "proc-arg");
gimp_config_writer_printf (writer, "%d",
gimp_pdb_compat_arg_type_from_gtype (G_PARAM_SPEC_VALUE_TYPE (pspec)));
gimp_config_writer_string (writer,
g_param_spec_get_name (pspec));
gimp_config_writer_string (writer,
g_param_spec_get_blurb (pspec));
gimp_config_writer_close (writer);
}
gimp_config_writer_close (writer);
}
if (plug_in_def->locale_domain_name)
{
gimp_config_writer_open (writer, "locale-def");
gimp_config_writer_string (writer,
plug_in_def->locale_domain_name);
if (plug_in_def->locale_domain_path)
gimp_config_writer_string (writer,
plug_in_def->locale_domain_path);
gimp_config_writer_close (writer);
}
if (plug_in_def->help_domain_name)
{
gimp_config_writer_open (writer, "help-def");
gimp_config_writer_string (writer,
plug_in_def->help_domain_name);
if (plug_in_def->help_domain_uri)
gimp_config_writer_string (writer,
plug_in_def->help_domain_uri);
gimp_config_writer_close (writer);
}
if (plug_in_def->has_init)
{
gimp_config_writer_open (writer, "has-init");
gimp_config_writer_close (writer);
}
gimp_config_writer_close (writer);
}
}
g_type_class_unref (enum_class);
return gimp_config_writer_finish (writer, "end of pluginrc", error);
}
GimpPDBStatusType
file_save (Gimp *gimp,
GimpImage *image,
GimpProgress *progress,
GFile *file,
GimpPlugInProcedure *file_proc,
GimpRunMode run_mode,
gboolean change_saved_state,
gboolean export_backward,
gboolean export_forward,
GError **error)
{
GimpDrawable *drawable;
GimpValueArray *return_vals;
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
GFile *local_file = NULL;
gchar *path = NULL;
gchar *uri = NULL;
gint32 image_ID;
gint32 drawable_ID;
GError *my_error = NULL;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (G_IS_FILE (file), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (file_proc),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail ((export_backward && export_forward) == FALSE,
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (error == NULL || *error == NULL,
GIMP_PDB_CALLING_ERROR);
/* ref image and file, so they can't get deleted during save */
g_object_ref (image);
g_object_ref (file);
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
goto out;
/* FIXME enable these tests for remote files again, needs testing */
if (g_file_is_native (file) &&
g_file_query_exists (file, NULL))
{
GFileInfo *info;
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE,
NULL, error);
if (! info)
goto out;
if (g_file_info_get_file_type (info) != G_FILE_TYPE_REGULAR)
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Not a regular file"));
g_object_unref (info);
goto out;
}
if (! g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Permission denied"));
g_object_unref (info);
goto out;
}
g_object_unref (info);
}
if (! g_file_is_native (file) &&
! file_remote_mount_file (gimp, file, progress, &my_error))
{
if (my_error)
g_propagate_error (error, my_error);
else
status = GIMP_PDB_CANCEL;
goto out;
}
if (! file_proc->handles_uri)
{
path = g_file_get_path (file);
if (! path)
{
local_file = file_remote_upload_image_prepare (gimp, file, progress,
&my_error);
if (! local_file)
{
if (my_error)
g_propagate_error (error, my_error);
else
status = GIMP_PDB_CANCEL;
goto out;
}
path = g_file_get_path (local_file);
}
}
if (! path)
path = g_file_get_uri (file);
uri = g_file_get_uri (file);
image_ID = gimp_image_get_ID (image);
drawable_ID = gimp_item_get_ID (GIMP_ITEM (drawable));
return_vals =
gimp_pdb_execute_procedure_by_name (image->gimp->pdb,
gimp_get_user_context (gimp),
progress, error,
gimp_object_get_name (file_proc),
GIMP_TYPE_INT32, run_mode,
GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_STRING, path,
G_TYPE_STRING, uri,
G_TYPE_NONE);
status = g_value_get_enum (gimp_value_array_index (return_vals, 0));
gimp_value_array_unref (return_vals);
if (local_file)
{
if (status == GIMP_PDB_SUCCESS)
{
GError *my_error = NULL;
if (! file_remote_upload_image_finish (gimp, file, local_file,
progress, &my_error))
{
status = GIMP_PDB_EXECUTION_ERROR;
if (my_error)
g_propagate_error (error, my_error);
else
status = GIMP_PDB_CANCEL;
}
}
g_file_delete (local_file, NULL, NULL);
g_object_unref (local_file);
}
if (status == GIMP_PDB_SUCCESS)
{
GimpDocumentList *documents;
GimpImagefile *imagefile;
if (change_saved_state)
{
gimp_image_set_file (image, file);
gimp_image_set_save_proc (image, file_proc);
/* Forget the import source when we save. We interpret a
* save as that the user is not interested in being able
* to quickly export back to the original any longer
*/
gimp_image_set_imported_file (image, NULL);
gimp_image_clean_all (image);
}
else if (export_backward)
{
/* We exported the image back to its imported source,
* change nothing about export/import flags, only set
* the export state to clean
*/
gimp_image_export_clean_all (image);
gimp_object_name_changed (GIMP_OBJECT (image));
}
else if (export_forward)
{
/* Remember the last entered Export URI for the image. We
* only need to do this explicitly when exporting. It
* happens implicitly when saving since the GimpObject name
* of a GimpImage is the last-save URI
*/
gimp_image_set_exported_file (image, file);
gimp_image_set_export_proc (image, file_proc);
/* An image can not be considered both exported and imported
* at the same time, so stop consider it as imported now
* that we consider it exported.
*/
gimp_image_set_imported_file (image, NULL);
gimp_image_export_clean_all (image);
}
if (export_backward || export_forward)
gimp_image_exported (image, file);
else
gimp_image_saved (image, file);
documents = GIMP_DOCUMENT_LIST (image->gimp->documents);
imagefile = gimp_document_list_add_file (documents, file,
file_proc->mime_type);
/* only save a thumbnail if we are saving as XCF, see bug #25272 */
if (GIMP_PROCEDURE (file_proc)->proc_type == GIMP_INTERNAL)
gimp_imagefile_save_thumbnail (imagefile, file_proc->mime_type, image,
NULL);
}
else if (status != GIMP_PDB_CANCEL)
{
if (error && *error == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("%s plug-in could not save image"),
gimp_plug_in_procedure_get_label (file_proc));
}
}
gimp_image_flush (image);
out:
g_object_unref (file);
g_object_unref (image);
g_free (path);
g_free (uri);
return status;
}
GimpValueArray *
gimp_plug_in_manager_call_run_temp (GimpPlugInManager *manager,
GimpContext *context,
GimpProgress *progress,
GimpTemporaryProcedure *procedure,
GimpValueArray *args)
{
GimpValueArray *return_vals = NULL;
GimpPlugIn *plug_in;
g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), NULL);
g_return_val_if_fail (GIMP_IS_PDB_CONTEXT (context), NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
g_return_val_if_fail (GIMP_IS_TEMPORARY_PROCEDURE (procedure), NULL);
g_return_val_if_fail (args != NULL, NULL);
plug_in = procedure->plug_in;
if (plug_in)
{
GimpPlugInProcFrame *proc_frame;
GPProcRun proc_run;
proc_frame = gimp_plug_in_proc_frame_push (plug_in, context, progress,
procedure);
proc_run.name = GIMP_PROCEDURE (procedure)->original_name;
proc_run.nparams = gimp_value_array_length (args);
proc_run.params = plug_in_args_to_params (args, FALSE);
if (! gp_temp_proc_run_write (plug_in->my_write, &proc_run, plug_in) ||
! gimp_wire_flush (plug_in->my_write, plug_in))
{
const gchar *name = gimp_object_get_name (plug_in);
GError *error = g_error_new (GIMP_PLUG_IN_ERROR,
GIMP_PLUG_IN_EXECUTION_FAILED,
_("Failed to run plug-in \"%s\""),
name);
g_free (proc_run.params);
gimp_plug_in_proc_frame_pop (plug_in);
return_vals = gimp_procedure_get_return_values (GIMP_PROCEDURE (procedure),
FALSE, error);
g_error_free (error);
return return_vals;
}
g_free (proc_run.params);
g_object_ref (plug_in);
gimp_plug_in_proc_frame_ref (proc_frame);
gimp_plug_in_main_loop (plug_in);
/* main_loop is quit and proc_frame is popped in
* gimp_plug_in_handle_temp_proc_return()
*/
return_vals = gimp_plug_in_proc_frame_get_return_values (proc_frame);
gimp_plug_in_proc_frame_unref (proc_frame, plug_in);
g_object_unref (plug_in);
}
return return_vals;
}
/**
* gimp_file_proc_view_process_procedure:
* @file_proc:
* @all:
*
* Creates a #GtkFileFilter of @file_proc and adds the extensions to
* the @all filter.
* The returned #GtkFileFilter has a normal ref and must be unreffed
* when used.
**/
static GtkFileFilter *
gimp_file_proc_view_process_procedure (GimpPlugInProcedure *file_proc,
GtkFileFilter *all)
{
GtkFileFilter *filter;
GString *str;
GSList *list;
gint i;
if (! file_proc->extensions_list)
return NULL;
filter = gtk_file_filter_new ();
str = g_string_new (gimp_procedure_get_label (GIMP_PROCEDURE (file_proc)));
/* Take ownership directly so we don't have to mess with a floating
* ref
*/
g_object_ref_sink (filter);
for (list = file_proc->mime_types_list; list; list = g_slist_next (list))
{
const gchar *mime_type = list->data;
gtk_file_filter_add_mime_type (filter, mime_type);
gtk_file_filter_add_mime_type (all, mime_type);
}
for (list = file_proc->extensions_list, i = 0;
list;
list = g_slist_next (list), i++)
{
const gchar *extension = list->data;
gchar *pattern;
pattern = gimp_file_proc_view_pattern_from_extension (extension);
gtk_file_filter_add_pattern (filter, pattern);
gtk_file_filter_add_pattern (all, pattern);
g_free (pattern);
if (i == 0)
{
g_string_append (str, " (");
}
else if (i <= MAX_EXTENSIONS)
{
g_string_append (str, ", ");
}
if (i < MAX_EXTENSIONS)
{
g_string_append (str, "*.");
g_string_append (str, extension);
}
else if (i == MAX_EXTENSIONS)
{
g_string_append (str, "...");
}
if (! list->next)
{
g_string_append (str, ")");
}
}
gtk_file_filter_set_name (filter, str->str);
g_string_free (str, TRUE);
return filter;
}
/* run automatically started extensions */
static void
gimp_plug_in_manager_run_extensions (GimpPlugInManager *manager,
GimpContext *context,
GimpInitStatusFunc status_callback)
{
Gimp *gimp = manager->gimp;
GSList *list;
GList *extensions = NULL;
gint n_extensions;
/* build list of automatically started extensions */
for (list = manager->plug_in_procedures; list; list = list->next)
{
GimpPlugInProcedure *proc = list->data;
if (proc->prog &&
GIMP_PROCEDURE (proc)->proc_type == GIMP_EXTENSION &&
GIMP_PROCEDURE (proc)->num_args == 0)
{
extensions = g_list_prepend (extensions, proc);
}
}
extensions = g_list_reverse (extensions);
n_extensions = g_list_length (extensions);
/* run the available extensions */
if (extensions)
{
GList *list;
gint nth;
status_callback (_("Starting Extensions"), "", 0.0);
for (list = extensions, nth = 0; list; list = g_list_next (list), nth++)
{
GimpPlugInProcedure *proc = list->data;
GValueArray *args;
GError *error = NULL;
if (gimp->be_verbose)
g_print ("Starting extension: '%s'\n", gimp_object_get_name (proc));
status_callback (NULL, gimp_object_get_name (proc),
(gdouble) nth / (gdouble) n_extensions);
args = g_value_array_new (0);
gimp_procedure_execute_async (GIMP_PROCEDURE (proc),
gimp, context, NULL,
args, NULL, &error);
g_value_array_free (args);
if (error)
{
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR,
error->message);
g_clear_error (&error);
}
}
g_list_free (extensions);
status_callback (NULL, "", 1.0);
}
}
static void
gimp_temporary_procedure_init (GimpTemporaryProcedure *proc)
{
GIMP_PROCEDURE (proc)->proc_type = GIMP_TEMPORARY;
}
gboolean
gimp_plug_in_procedure_add_menu_path (GimpPlugInProcedure *proc,
const gchar *menu_path,
GError **error)
{
GimpProcedure *procedure;
gchar *basename = NULL;
const gchar *required = NULL;
gchar *p;
gchar *mapped_path;
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), FALSE);
g_return_val_if_fail (menu_path != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
procedure = GIMP_PROCEDURE (proc);
p = strchr (menu_path, '>');
if (p == NULL || (*(++p) && *p != '/'))
{
basename = g_filename_display_basename (proc->prog);
g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED,
"Plug-In \"%s\"\n(%s)\n"
"attempted to install procedure \"%s\"\n"
"in the invalid menu location \"%s\".\n"
"The menu path must look like either \"<Prefix>\" "
"or \"<Prefix>/path/to/item\".",
basename, gimp_filename_to_utf8 (proc->prog),
gimp_object_get_name (proc),
menu_path);
goto failure;
}
if (g_str_has_prefix (menu_path, "<Toolbox>") ||
g_str_has_prefix (menu_path, "<Image>"))
{
if ((procedure->num_args < 1) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]))
{
required = "INT32";
goto failure;
}
}
else if (g_str_has_prefix (menu_path, "<Layers>"))
{
if ((procedure->num_args < 3) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
! (G_TYPE_FROM_INSTANCE (procedure->args[2])
== GIMP_TYPE_PARAM_LAYER_ID ||
G_TYPE_FROM_INSTANCE (procedure->args[2])
== GIMP_TYPE_PARAM_DRAWABLE_ID))
{
required = "INT32, IMAGE, (LAYER | DRAWABLE)";
goto failure;
}
}
else if (g_str_has_prefix (menu_path, "<Channels>"))
{
if ((procedure->num_args < 3) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
! (G_TYPE_FROM_INSTANCE (procedure->args[2])
== GIMP_TYPE_PARAM_CHANNEL_ID ||
G_TYPE_FROM_INSTANCE (procedure->args[2])
== GIMP_TYPE_PARAM_DRAWABLE_ID))
{
required = "INT32, IMAGE, (CHANNEL | DRAWABLE)";
goto failure;
}
}
else if (g_str_has_prefix (menu_path, "<Vectors>"))
{
if ((procedure->num_args < 3) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
! GIMP_IS_PARAM_SPEC_VECTORS_ID (procedure->args[2]))
{
required = "INT32, IMAGE, VECTORS";
goto failure;
}
}
else if (g_str_has_prefix (menu_path, "<Colormap>"))
{
if ((procedure->num_args < 2) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]))
{
required = "INT32, IMAGE";
goto failure;
}
}
else if (g_str_has_prefix (menu_path, "<Load>"))
{
if ((procedure->num_args < 3) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[2]))
{
required = "INT32, STRING, STRING";
goto failure;
}
if ((procedure->num_values < 1) ||
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->values[0]))
{
required = "IMAGE";
goto failure;
}
}
else if (g_str_has_prefix (menu_path, "<Save>"))
{
if ((procedure->num_args < 5) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
! GIMP_IS_PARAM_SPEC_DRAWABLE_ID (procedure->args[2]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[3]) ||
! G_IS_PARAM_SPEC_STRING (procedure->args[4]))
{
required = "INT32, IMAGE, DRAWABLE, STRING, STRING";
goto failure;
}
}
else if (g_str_has_prefix (menu_path, "<Brushes>") ||
g_str_has_prefix (menu_path, "<Gradients>") ||
g_str_has_prefix (menu_path, "<Palettes>") ||
g_str_has_prefix (menu_path, "<Patterns>") ||
g_str_has_prefix (menu_path, "<Fonts>") ||
g_str_has_prefix (menu_path, "<Buffers>"))
{
if ((procedure->num_args < 1) ||
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]))
{
required = "INT32";
goto failure;
}
}
else
{
basename = g_filename_display_basename (proc->prog);
g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED,
"Plug-In \"%s\"\n(%s)\n"
"attempted to install procedure \"%s\" "
"in the invalid menu location \"%s\".\n"
"Use either \"<Toolbox>\", \"<Image>\", "
"\"<Layers>\", \"<Channels>\", \"<Vectors>\", "
"\"<Colormap>\", \"<Load>\", \"<Save>\", "
"\"<Brushes>\", \"<Gradients>\", \"<Palettes>\", "
"\"<Patterns>\" or \"<Buffers>\".",
basename, gimp_filename_to_utf8 (proc->prog),
gimp_object_get_name (proc),
menu_path);
goto failure;
}
g_free (basename);
mapped_path = plug_in_menu_path_map (menu_path, NULL);
proc->menu_paths = g_list_append (proc->menu_paths, mapped_path);
g_signal_emit (proc, gimp_plug_in_procedure_signals[MENU_PATH_ADDED], 0,
mapped_path);
return TRUE;
failure:
if (required)
{
gchar *prefix = g_strdup (menu_path);
p = strchr (prefix, '>') + 1;
*p = '\0';
basename = g_filename_display_basename (proc->prog);
g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED,
"Plug-In \"%s\"\n(%s)\n\n"
"attempted to install %s procedure \"%s\" "
"which does not take the standard %s Plug-In "
"arguments: (%s).",
basename, gimp_filename_to_utf8 (proc->prog),
prefix, gimp_object_get_name (proc), prefix,
required);
g_free (prefix);
}
g_free (basename);
return FALSE;
}
void
plug_in_actions_setup (GimpActionGroup *group)
{
GimpPlugInActionEntry *entries;
GSList *list;
gint n_entries;
gint i;
gimp_action_group_add_actions (group,
plug_in_actions,
G_N_ELEMENTS (plug_in_actions));
gimp_action_group_add_enum_actions (group,
plug_in_repeat_actions,
G_N_ELEMENTS (plug_in_repeat_actions),
G_CALLBACK (plug_in_repeat_cmd_callback));
for (list = group->gimp->plug_in_manager->menu_branches;
list;
list = g_slist_next (list))
{
GimpPlugInMenuBranch *branch = list->data;
plug_in_actions_menu_branch_added (group->gimp->plug_in_manager,
branch->prog_name,
branch->menu_path,
branch->menu_label,
group);
}
g_signal_connect_object (group->gimp->plug_in_manager,
"menu-branch-added",
G_CALLBACK (plug_in_actions_menu_branch_added),
group, 0);
for (list = group->gimp->plug_in_manager->plug_in_procedures;
list;
list = g_slist_next (list))
{
GimpPlugInProcedure *plug_in_proc = list->data;
if (plug_in_proc->prog)
plug_in_actions_register_procedure (group->gimp->pdb,
GIMP_PROCEDURE (plug_in_proc),
group);
}
g_signal_connect_object (group->gimp->pdb, "register-procedure",
G_CALLBACK (plug_in_actions_register_procedure),
group, 0);
g_signal_connect_object (group->gimp->pdb, "unregister-procedure",
G_CALLBACK (plug_in_actions_unregister_procedure),
group, 0);
n_entries = gimp_plug_in_manager_history_size (group->gimp->plug_in_manager);
entries = g_new0 (GimpPlugInActionEntry, n_entries);
for (i = 0; i < n_entries; i++)
{
entries[i].name = g_strdup_printf ("plug-in-recent-%02d", i + 1);
entries[i].stock_id = NULL;
entries[i].label = "";
entries[i].accelerator = "";
entries[i].tooltip = NULL;
entries[i].procedure = NULL;
entries[i].help_id = GIMP_HELP_FILTER_RESHOW;
}
gimp_action_group_add_plug_in_actions (group, entries, n_entries,
G_CALLBACK (plug_in_history_cmd_callback));
for (i = 0; i < n_entries; i++)
{
gimp_action_group_set_action_visible (group, entries[i].name, FALSE);
g_free ((gchar *) entries[i].name);
}
g_free (entries);
g_signal_connect_object (group->gimp->plug_in_manager, "history-changed",
G_CALLBACK (plug_in_actions_history_changed),
group, 0);
plug_in_actions_history_changed (group->gimp->plug_in_manager, group);
}
