static void
gimp_plug_in_cleanup_item (GimpPlugInProcFrame *proc_frame,
GimpPlugInCleanupItem *cleanup)
{
GimpItem *item = cleanup->item;
if (cleanup->shadow_buffer)
{
GIMP_LOG (SHADOW_TILES,
"Freeing shadow buffer of drawable '%s' on behalf of '%s'.",
gimp_object_get_name (item),
gimp_procedure_get_label (proc_frame->procedure));
gimp_drawable_free_shadow_buffer (GIMP_DRAWABLE (item));
}
}
static void
gimp_plug_in_cleanup_image (GimpPlugInProcFrame *proc_frame,
GimpPlugInCleanupImage *cleanup)
{
GimpImage *image = cleanup->image;
if (gimp_image_get_undo_group_count (image) == 0)
return;
if (cleanup->undo_group_count != gimp_image_get_undo_group_count (image))
{
g_message ("Plug-In '%s' left image undo in inconsistent state, "
"closing open undo groups.",
gimp_procedure_get_label (proc_frame->procedure));
while (cleanup->undo_group_count < gimp_image_get_undo_group_count (image))
{
if (! gimp_image_undo_group_end (image))
break;
}
}
}
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);
}
static const gchar *
gimp_procedure_real_get_menu_label (GimpProcedure *procedure)
{
return gimp_procedure_get_label (procedure);
}
/**
* 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;
}
static void
filters_actions_history_changed (Gimp *gimp,
GimpActionGroup *group)
{
GimpProcedure *proc;
GimpActionGroup *plug_in_group;
gint i;
plug_in_group = filters_actions_get_plug_in_group (group);
proc = gimp_filter_history_nth (gimp, 0);
if (proc)
{
GtkAction *actual_action = NULL;
const gchar *label;
gchar *repeat;
gchar *reshow;
gboolean sensitive = FALSE;
label = gimp_procedure_get_label (proc);
repeat = g_strdup_printf (_("Re_peat \"%s\""), label);
reshow = g_strdup_printf (_("R_e-Show \"%s\""), label);
gimp_action_group_set_action_label (group, "filters-repeat", repeat);
gimp_action_group_set_action_label (group, "filters-reshow", reshow);
g_free (repeat);
g_free (reshow);
if (g_str_has_prefix (gimp_object_get_name (proc), "filters-"))
{
actual_action =
gtk_action_group_get_action (GTK_ACTION_GROUP (group),
gimp_object_get_name (proc));
}
else if (plug_in_group)
{
/* copy the sensitivity of the plug-in procedure's actual
* action instead of calling filters_actions_update()
* because doing the latter would set the sensitivity of
* this image's action on all images' actions. See bug
* #517683.
*/
actual_action =
gtk_action_group_get_action (GTK_ACTION_GROUP (plug_in_group),
gimp_object_get_name (proc));
}
if (actual_action)
sensitive = gtk_action_get_sensitive (actual_action);
gimp_action_group_set_action_sensitive (group, "filters-repeat",
sensitive);
gimp_action_group_set_action_sensitive (group, "filters-reshow",
sensitive);
}
else
{
gimp_action_group_set_action_label (group, "filters-repeat",
_("Repeat Last"));
gimp_action_group_set_action_label (group, "filters-reshow",
_("Re-Show Last"));
gimp_action_group_set_action_sensitive (group, "filters-repeat", FALSE);
gimp_action_group_set_action_sensitive (group, "filters-reshow", FALSE);
}
for (i = 0; i < gimp_filter_history_length (gimp); i++)
{
GtkAction *action;
GtkAction *actual_action = NULL;
const gchar *label;
gchar *name;
gboolean sensitive = FALSE;
name = g_strdup_printf ("filter-recent-%02d", i + 1);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), name);
g_free (name);
proc = gimp_filter_history_nth (gimp, i);
label = gimp_procedure_get_menu_label (proc);
if (g_str_has_prefix (gimp_object_get_name (proc), "filters-"))
{
actual_action =
gtk_action_group_get_action (GTK_ACTION_GROUP (group),
gimp_object_get_name (proc));
}
else if (plug_in_group)
{
/* see comment above */
actual_action =
gtk_action_group_get_action (GTK_ACTION_GROUP (plug_in_group),
gimp_object_get_name (proc));
}
if (actual_action)
sensitive = gtk_action_get_sensitive (actual_action);
g_object_set (action,
"visible", TRUE,
"sensitive", sensitive,
"procedure", proc,
"label", label,
"icon-name", gimp_viewable_get_icon_name (GIMP_VIEWABLE (proc)),
"tooltip", gimp_procedure_get_blurb (proc),
NULL);
}
for (; i < gimp_filter_history_size (gimp); i++)
{
GtkAction *action;
gchar *name = g_strdup_printf ("filter-recent-%02d", i + 1);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), name);
g_free (name);
g_object_set (action,
"visible", FALSE,
"procedure", NULL,
NULL);
}
}
GimpImage *
file_open_image (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GFile *file,
GFile *entered_file,
gboolean as_new,
GimpPlugInProcedure *file_proc,
GimpRunMode run_mode,
GimpPDBStatusType *status,
const gchar **mime_type,
GError **error)
{
GimpValueArray *return_vals;
GimpImage *image = NULL;
GFile *local_file = NULL;
gchar *path = NULL;
gchar *entered_uri = NULL;
GError *my_error = 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 (G_IS_FILE (file), NULL);
g_return_val_if_fail (G_IS_FILE (entered_file), NULL);
g_return_val_if_fail (status != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
*status = GIMP_PDB_EXECUTION_ERROR;
/* 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_READ,
G_FILE_QUERY_INFO_NONE,
NULL, error);
if (! info)
return NULL;
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);
return NULL;
}
if (! g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Permission denied"));
g_object_unref (info);
return NULL;
}
g_object_unref (info);
}
if (! file_proc)
file_proc = gimp_plug_in_manager_file_procedure_find (gimp->plug_in_manager,
GIMP_FILE_PROCEDURE_GROUP_OPEN,
file, error);
if (! file_proc)
{
/* don't bail out on remote files, they might need to be
* downloaded for magic matching
*/
if (g_file_is_native (file))
return NULL;
g_clear_error (error);
}
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;
return NULL;
}
if (! file_proc || ! file_proc->handles_uri)
{
path = g_file_get_path (file);
if (! path)
{
local_file = file_remote_download_image (gimp, file, progress,
&my_error);
if (! local_file)
{
if (my_error)
g_propagate_error (error, my_error);
else
*status = GIMP_PDB_CANCEL;
return NULL;
}
/* if we don't have a file proc yet, try again on the local
* file
*/
if (! file_proc)
file_proc = gimp_plug_in_manager_file_procedure_find (gimp->plug_in_manager,
GIMP_FILE_PROCEDURE_GROUP_OPEN,
local_file, error);
if (! file_proc)
{
g_file_delete (local_file, NULL, NULL);
g_object_unref (local_file);
return NULL;
}
path = g_file_get_path (local_file);
}
}
if (! path)
path = g_file_get_uri (file);
entered_uri = g_file_get_uri (entered_file);
if (! entered_uri)
entered_uri = g_strdup (path);
if (progress)
g_object_add_weak_pointer (G_OBJECT (progress), (gpointer) &progress);
return_vals =
gimp_pdb_execute_procedure_by_name (gimp->pdb,
context, progress, error,
gimp_object_get_name (file_proc),
GIMP_TYPE_INT32, run_mode,
G_TYPE_STRING, path,
G_TYPE_STRING, entered_uri,
G_TYPE_NONE);
if (progress)
g_object_remove_weak_pointer (G_OBJECT (progress), (gpointer) &progress);
g_free (path);
g_free (entered_uri);
*status = g_value_get_enum (gimp_value_array_index (return_vals, 0));
if (*status == GIMP_PDB_SUCCESS)
image = gimp_value_get_image (gimp_value_array_index (return_vals, 1),
gimp);
if (local_file)
{
if (image)
gimp_image_set_file (image, file);
g_file_delete (local_file, NULL, NULL);
g_object_unref (local_file);
}
if (*status == GIMP_PDB_SUCCESS)
{
if (image)
{
/* Only set the load procedure if it hasn't already been set. */
if (! gimp_image_get_load_proc (image))
gimp_image_set_load_proc (image, file_proc);
file_proc = gimp_image_get_load_proc (image);
if (mime_type)
*mime_type = file_proc->mime_type;
}
else
{
if (error && ! *error)
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("%s plug-in returned SUCCESS but did not "
"return an image"),
gimp_procedure_get_label (GIMP_PROCEDURE (file_proc)));
*status = GIMP_PDB_EXECUTION_ERROR;
}
}
else if (*status != GIMP_PDB_CANCEL)
{
if (error && ! *error)
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("%s plug-In could not open image"),
gimp_procedure_get_label (GIMP_PROCEDURE (file_proc)));
}
gimp_value_array_unref (return_vals);
if (image)
{
gimp_image_undo_disable (image);
gimp_image_import_color_profile (image, context, progress,
run_mode == GIMP_RUN_INTERACTIVE ?
TRUE : FALSE);
if (file_open_file_proc_is_import (file_proc))
{
/* Remember the import source */
gimp_image_set_imported_file (image, file);
/* We shall treat this file as an Untitled file */
gimp_image_set_file (image, NULL);
}
/* Enables undo again */
file_open_sanitize_image (image, as_new);
}
return image;
}
