void
documents_raise_or_open_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
RaiseClosure closure;
closure.name = gimp_object_get_name (imagefile);
closure.found = FALSE;
gimp_container_foreach (context->gimp->displays,
(GFunc) documents_raise_display,
&closure);
if (! closure.found)
documents_open_image (GTK_WIDGET (editor), context, imagefile);
}
}
void
tool_presets_save_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpToolPreset *preset;
GimpToolInfo *tool_info;
context = gimp_container_view_get_context (editor->view);
preset = gimp_context_get_tool_preset (context);
tool_info = gimp_context_get_tool (gimp_get_user_context (context->gimp));
if (tool_info && preset)
{
GimpToolInfo *preset_tool;
preset_tool = gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options));
if (tool_info != preset_tool)
{
gimp_message (context->gimp,
G_OBJECT (editor), GIMP_MESSAGE_WARNING,
_("Can't save '%s' tool options to an "
"existing '%s' tool preset."),
tool_info->blurb,
preset_tool->blurb);
return;
}
gimp_config_sync (G_OBJECT (tool_info->tool_options),
G_OBJECT (preset->tool_options), 0);
}
}
void
documents_show_in_file_manager_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile)
{
GFile *file = g_file_new_for_uri (gimp_object_get_name (imagefile));
GError *error = NULL;
if (! gimp_file_show_in_file_manager (file, &error))
{
gimp_message (context->gimp, G_OBJECT (editor),
GIMP_MESSAGE_ERROR,
_("Can't show file in file manager: %s"),
error->message);
g_clear_error (&error);
}
g_object_unref (file);
}
}
void
images_raise_views_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContainer *container;
GimpContext *context;
GimpImage *image;
container = gimp_container_view_get_container (editor->view);
context = gimp_container_view_get_context (editor->view);
image = gimp_context_get_image (context);
if (image && gimp_container_have (container, GIMP_OBJECT (image)))
{
GList *list;
for (list = gimp_get_display_iter (image->gimp);
list;
list = g_list_next (list))
{
GimpDisplay *display = list->data;
if (gimp_display_get_image (display) == image)
gimp_display_shell_present (gimp_display_get_shell (display));
}
}
}
void
buffers_paste_as_new_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContainer *container;
GimpContext *context;
GimpBuffer *buffer;
container = gimp_container_view_get_container (editor->view);
context = gimp_container_view_get_context (editor->view);
buffer = gimp_context_get_buffer (context);
if (buffer && gimp_container_have (container, GIMP_OBJECT (buffer)))
{
GimpImage *image = gimp_context_get_image (context);
if (image)
{
GimpImage *new_image;
new_image = gimp_image_new_from_buffer (image->gimp, image, buffer);
gimp_create_display (image->gimp, new_image,
GIMP_UNIT_PIXEL, 1.0);
g_object_unref (new_image);
}
}
}
void
documents_recreate_preview_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
GError *error = NULL;
if (! gimp_imagefile_create_thumbnail (imagefile,
context, NULL,
context->gimp->config->thumbnail_size,
FALSE, &error))
{
gimp_message_literal (context->gimp,
NULL , GIMP_MESSAGE_ERROR,
error->message);
g_clear_error (&error);
}
}
}
void
documents_remove_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context = gimp_container_view_get_context (editor->view);
GimpImagefile *imagefile = gimp_context_get_imagefile (context);
const gchar *uri;
uri = gimp_object_get_name (imagefile);
gtk_recent_manager_remove_item (gtk_recent_manager_get_default (), uri, NULL);
gimp_container_view_remove_active (editor->view);
}
void
documents_copy_location_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile)
gimp_clipboard_set_text (context->gimp,
gimp_object_get_name (imagefile));
}
void
tool_presets_restore_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpToolPreset *preset;
context = gimp_container_view_get_context (editor->view);
preset = gimp_context_get_tool_preset (context);
if (preset)
gimp_context_tool_preset_changed (gimp_get_user_context (context->gimp));
}
GimpContext *
action_data_get_context (gpointer data)
{
GimpContext *result = NULL;
static gboolean recursion = FALSE;
if (! data || recursion)
return NULL;
recursion = TRUE;
if (GIMP_IS_DOCK (data))
result = gimp_dock_get_context ((GimpDock *) data);
else if (GIMP_IS_DOCK_WINDOW (data))
result = gimp_dock_window_get_context (((GimpDockWindow *) data));
else if (GIMP_IS_CONTAINER_VIEW (data))
result = gimp_container_view_get_context ((GimpContainerView *) data);
else if (GIMP_IS_CONTAINER_EDITOR (data))
result = gimp_container_view_get_context (((GimpContainerEditor *) data)->view);
else if (GIMP_IS_IMAGE_EDITOR (data))
result = ((GimpImageEditor *) data)->context;
else if (GIMP_IS_NAVIGATION_EDITOR (data))
result = ((GimpNavigationEditor *) data)->context;
if (! result)
{
Gimp *gimp = action_data_get_gimp (data);
if (gimp)
result = gimp_get_user_context (gimp);
}
recursion = FALSE;
return result;
}
static void
buffers_paste (GimpBufferView *view,
gboolean paste_into)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (view);
GimpContainer *container;
GimpContext *context;
GimpBuffer *buffer;
container = gimp_container_view_get_container (editor->view);
context = gimp_container_view_get_context (editor->view);
buffer = gimp_context_get_buffer (context);
if (buffer && gimp_container_have (container, GIMP_OBJECT (buffer)))
{
GimpDisplay *display = gimp_context_get_display (context);
GimpImage *image = NULL;
gint x = -1;
gint y = -1;
gint width = -1;
gint height = -1;
if (display)
{
GimpDisplayShell *shell = gimp_display_get_shell (display);
gimp_display_shell_untransform_viewport (shell,
&x, &y, &width, &height);
image = gimp_display_get_image (display);
}
else
{
image = gimp_context_get_image (context);
}
if (image)
{
gimp_edit_paste (image, gimp_image_get_active_drawable (image),
buffer, paste_into, x, y, width, height);
gimp_image_flush (image);
}
}
}
static void
gimp_template_view_activate_item (GimpContainerEditor *editor,
GimpViewable *viewable)
{
GimpTemplateView *view = GIMP_TEMPLATE_VIEW (editor);
GimpContainer *container;
GimpContext *context;
if (GIMP_CONTAINER_EDITOR_CLASS (parent_class)->activate_item)
GIMP_CONTAINER_EDITOR_CLASS (parent_class)->activate_item (editor, viewable);
container = gimp_container_view_get_container (editor->view);
context = gimp_container_view_get_context (editor->view);
if (viewable && gimp_container_have (container, GIMP_OBJECT (viewable)))
{
gtk_button_clicked (GTK_BUTTON (view->create_button));
}
}
void
images_new_view_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContainer *container;
GimpContext *context;
GimpImage *image;
container = gimp_container_view_get_container (editor->view);
context = gimp_container_view_get_context (editor->view);
image = gimp_context_get_image (context);
if (image && gimp_container_have (container, GIMP_OBJECT (image)))
{
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0);
}
}
void
images_delete_image_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContainer *container;
GimpContext *context;
GimpImage *image;
container = gimp_container_view_get_container (editor->view);
context = gimp_container_view_get_context (editor->view);
image = gimp_context_get_image (context);
if (image && gimp_container_have (container, GIMP_OBJECT (image)))
{
if (gimp_image_get_display_count (image) == 0)
g_object_unref (image);
}
}
static gpointer
gimp_container_grid_view_insert_item (GimpContainerView *container_view,
GimpViewable *viewable,
gpointer parent_insert_data,
gint index)
{
GimpContainerGridView *grid_view = GIMP_CONTAINER_GRID_VIEW (container_view);
GtkWidget *view;
gint view_size;
view_size = gimp_container_view_get_view_size (container_view, NULL);
view = gimp_view_new_full (gimp_container_view_get_context (container_view),
viewable,
view_size, view_size, 1,
FALSE, TRUE, TRUE);
gimp_view_renderer_set_border_type (GIMP_VIEW (view)->renderer,
GIMP_VIEW_BORDER_WHITE);
gimp_view_renderer_remove_idle (GIMP_VIEW (view)->renderer);
gtk_wrap_box_pack (GTK_WRAP_BOX (grid_view->wrap_box), view,
FALSE, FALSE, FALSE, FALSE);
if (index != -1)
gtk_wrap_box_reorder_child (GTK_WRAP_BOX (grid_view->wrap_box),
view, index);
gtk_widget_show (view);
g_signal_connect (view, "button-press-event",
G_CALLBACK (gimp_container_grid_view_item_selected),
container_view);
g_signal_connect (view, "double-clicked",
G_CALLBACK (gimp_container_grid_view_item_activated),
container_view);
g_signal_connect (view, "context",
G_CALLBACK (gimp_container_grid_view_item_context),
container_view);
return (gpointer) view;
}
void
documents_file_open_dialog_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
file_file_open_dialog (context->gimp,
gimp_imagefile_get_file (imagefile),
GTK_WIDGET (editor));
}
}
void
documents_recreate_preview_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpContainer *container;
GimpImagefile *imagefile;
context = gimp_container_view_get_context (editor->view);
container = gimp_container_view_get_container (editor->view);
imagefile = gimp_context_get_imagefile (context);
if (imagefile && gimp_container_have (container, GIMP_OBJECT (imagefile)))
{
gimp_imagefile_create_thumbnail (imagefile,
context, NULL,
context->gimp->config->thumbnail_size,
FALSE);
}
}
static void
gimp_container_combo_box_set (GimpContainerComboBox *combo_box,
GtkTreeIter *iter,
GimpViewable *viewable)
{
GimpContainerView *view = GIMP_CONTAINER_VIEW (combo_box);
GtkTreeModel *model;
GimpViewRenderer *renderer;
gchar *name;
gint view_size;
gint border_width;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box));
view_size = gimp_container_view_get_view_size (view, &border_width);
name = gimp_viewable_get_description (viewable, NULL);
renderer = gimp_view_renderer_new (gimp_container_view_get_context (view),
G_TYPE_FROM_INSTANCE (viewable),
view_size, border_width,
FALSE);
gimp_view_renderer_set_viewable (renderer, viewable);
gimp_view_renderer_remove_idle (renderer);
g_signal_connect (renderer, "update",
G_CALLBACK (gimp_container_combo_box_renderer_update),
view);
gtk_list_store_set (GTK_LIST_STORE (model), iter,
COLUMN_RENDERER, renderer,
COLUMN_NAME, name,
-1);
g_object_unref (renderer);
g_free (name);
}
void
documents_clear_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context = gimp_container_view_get_context (editor->view);
Gimp *gimp = context->gimp;
GtkWidget *dialog;
dialog = gimp_message_dialog_new (_("Clear Document History"),
GIMP_STOCK_SHRED,
GTK_WIDGET (editor),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
gimp_standard_help_func, NULL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_CLEAR, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect_object (gtk_widget_get_toplevel (GTK_WIDGET (editor)),
"unmap",
G_CALLBACK (gtk_widget_destroy),
dialog, G_CONNECT_SWAPPED);
gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box,
_("Clear the Recent Documents list?"));
gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box,
_("Clearing the document history will "
"permanently remove all images from "
"the recent documents list."));
if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
GtkRecentManager *manager = gtk_recent_manager_get_default ();
GList *items;
GList *list;
items = gtk_recent_manager_get_items (manager);
for (list = items; list; list = list->next)
{
GtkRecentInfo *info = list->data;
if (gtk_recent_info_has_application (info,
"GNU Image Manipulation Program"))
{
gtk_recent_manager_remove_item (manager,
gtk_recent_info_get_uri (info),
NULL);
}
gtk_recent_info_unref (info);
}
g_list_free (items);
gimp_container_clear (gimp->documents);
}
gtk_widget_destroy (dialog);
}
void
gradients_save_as_pov_ray_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context;
GimpGradient *gradient;
GtkWidget *dialog;
context = gimp_container_view_get_context (editor->view);
gradient = gimp_context_get_gradient (context);
if (! gradient)
return;
#define SAVE_AS_POV_DIALOG_KEY "gimp-save-as-pov-ray-dialog"
dialog = dialogs_get_dialog (G_OBJECT (gradient), SAVE_AS_POV_DIALOG_KEY);
if (! dialog)
{
gchar *title = g_strdup_printf (_("Save '%s' as POV-Ray"),
gimp_object_get_name (gradient));
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_OK,
NULL);
g_free (title);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gimp_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_object_set_data (G_OBJECT (dialog), "gimp", context->gimp);
gtk_window_set_screen (GTK_WINDOW (dialog),
gtk_widget_get_screen (GTK_WIDGET (editor)));
gtk_window_set_role (GTK_WINDOW (dialog), "gimp-gradient-save-pov");
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
TRUE);
g_signal_connect (dialog, "response",
G_CALLBACK (gradients_save_as_pov_ray_response),
gradient);
g_signal_connect (dialog, "delete-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect_object (dialog, "destroy",
G_CALLBACK (g_object_unref),
g_object_ref (gradient),
G_CONNECT_SWAPPED);
gimp_help_connect (dialog, gimp_standard_help_func,
GIMP_HELP_GRADIENT_SAVE_AS_POV, NULL);
dialogs_attach_dialog (G_OBJECT (gradient),
SAVE_AS_POV_DIALOG_KEY, dialog);
}
gtk_window_present (GTK_WINDOW (dialog));
}
void
plug_in_run_cmd_callback (GtkAction *action,
GimpPlugInProcedure *proc,
gpointer data)
{
GimpProcedure *procedure = GIMP_PROCEDURE (proc);
Gimp *gimp;
GimpValueArray *args;
gint n_args = 0;
GimpDisplay *display = NULL;
return_if_no_gimp (gimp, data);
args = gimp_procedure_get_arguments (procedure);
/* initialize the first argument */
g_value_set_int (gimp_value_array_index (args, n_args),
GIMP_RUN_INTERACTIVE);
n_args++;
switch (procedure->proc_type)
{
case GIMP_EXTENSION:
break;
case GIMP_PLUGIN:
case GIMP_TEMPORARY:
if (GIMP_IS_DATA_FACTORY_VIEW (data) ||
GIMP_IS_FONT_VIEW (data) ||
GIMP_IS_BUFFER_VIEW (data))
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContainer *container;
GimpContext *context;
GimpObject *object;
container = gimp_container_view_get_container (editor->view);
context = gimp_container_view_get_context (editor->view);
object = gimp_context_get_by_type (context,
gimp_container_get_children_type (container));
n_args = plug_in_collect_data_args (action, object,
procedure->args,
args, n_args);
}
else if (GIMP_IS_IMAGE_EDITOR (data))
{
GimpImageEditor *editor = GIMP_IMAGE_EDITOR (data);
GimpImage *image;
image = gimp_image_editor_get_image (editor);
n_args = plug_in_collect_image_args (action, image,
procedure->args,
args, n_args);
}
else if (GIMP_IS_ITEM_TREE_VIEW (data))
{
GimpItemTreeView *view = GIMP_ITEM_TREE_VIEW (data);
GimpImage *image;
GimpItem *item;
image = gimp_item_tree_view_get_image (view);
if (image)
item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (image);
else
item = NULL;
n_args = plug_in_collect_item_args (action, image, item,
procedure->args,
args, n_args);
}
else
{
display = action_data_get_display (data);
n_args = plug_in_collect_display_args (action,
display,
procedure->args,
args, n_args);
}
break;
case GIMP_INTERNAL:
g_warning ("Unhandled procedure type.");
n_args = -1;
break;
}
if (n_args >= 1)
plug_in_procedure_execute (proc, gimp, display, args, n_args);
gimp_value_array_unref (args);
}
