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);
}
}
void
edit_paste_as_new_layer_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GimpImage *image;
GimpBuffer *buffer;
return_if_no_gimp (gimp, data);
return_if_no_image (image, data);
buffer = gimp_clipboard_get_buffer (gimp);
if (buffer)
{
GimpLayer *layer;
layer = gimp_layer_new_from_buffer (gimp_buffer_get_buffer (buffer),
image,
gimp_image_get_layer_format (image,
TRUE),
_("Clipboard"),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
g_object_unref (buffer);
gimp_image_add_layer (image, layer,
GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
gimp_image_flush (image);
}
else
{
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_WARNING,
_("There is no image data in the clipboard to paste."));
}
}
void
edit_paste_as_new_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GimpBuffer *buffer;
return_if_no_gimp (gimp, data);
buffer = gimp_clipboard_get_buffer (gimp);
if (buffer)
{
GimpImage *image;
image = gimp_image_new_from_buffer (gimp, action_data_get_image (data),
buffer);
g_object_unref (buffer);
gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0);
g_object_unref (image);
}
else
{
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_WARNING,
_("There is no image data in the clipboard to paste."));
}
}
void
plug_in_reset_all_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GtkWidget *dialog;
return_if_no_gimp (gimp, data);
dialog = gimp_message_dialog_new (_("Reset all Filters"), GIMP_STOCK_QUESTION,
NULL, 0,
gimp_standard_help_func, NULL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GIMP_STOCK_RESET, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect (dialog, "response",
G_CALLBACK (plug_in_reset_all_response),
gimp);
gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box,
_("Do you really want to reset all "
"filters to default values?"));
gtk_widget_show (dialog);
}
void
file_quit_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
return_if_no_gimp (gimp, data);
gimp_exit (gimp, FALSE);
}
void
file_open_recent_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
Gimp *gimp;
GimpImagefile *imagefile;
gint num_entries;
return_if_no_gimp (gimp, data);
num_entries = gimp_container_get_n_children (gimp->documents);
if (value >= num_entries)
return;
imagefile = (GimpImagefile *)
gimp_container_get_child_by_index (gimp->documents, value);
if (imagefile)
{
GimpDisplay *display;
GimpProgress *progress;
GimpImage *image;
GimpPDBStatusType status;
GError *error = NULL;
return_if_no_display (display, data);
g_object_ref (display);
g_object_ref (imagefile);
progress = gimp_display_get_image (display) ?
NULL : GIMP_PROGRESS (display);
image = file_open_with_display (gimp, action_data_get_context (data),
progress,
gimp_object_get_name (imagefile), FALSE,
&status, &error);
if (! image && status != GIMP_PDB_CANCEL)
{
gchar *filename =
file_utils_uri_display_name (gimp_object_get_name (imagefile));
gimp_message (gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"),
filename, error->message);
g_clear_error (&error);
g_free (filename);
}
g_object_unref (imagefile);
g_object_unref (display);
}
}
void
help_help_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GimpDisplay *display;
return_if_no_gimp (gimp, data);
return_if_no_display (display, data);
gimp_help_show (gimp, GIMP_PROGRESS (display), NULL, NULL);
}
void
debug_mem_profile_cmd_callback (GtkAction *action,
gpointer data)
{
extern gboolean gimp_debug_memsize;
Gimp *gimp;
return_if_no_gimp (gimp, data);
gimp_debug_memsize = TRUE;
gimp_object_get_memsize (GIMP_OBJECT (gimp), NULL);
gimp_debug_memsize = FALSE;
}
void
windows_use_single_window_mode_cmd_callback (GtkAction *action,
gpointer data)
{
gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
Gimp *gimp;
return_if_no_gimp (gimp, data);
if (GIMP_GUI_CONFIG (gimp->config)->single_window_mode == active)
return;
g_object_set (gimp->config,
"single-window-mode", active,
NULL);
}
void
windows_hide_docks_cmd_callback (GtkAction *action,
gpointer data)
{
gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
Gimp *gimp;
return_if_no_gimp (gimp, data);
if (GIMP_GUI_CONFIG (gimp->config)->hide_docks == active)
return;
g_object_set (gimp->config,
"hide-docks", active,
NULL);
}
void
view_navigation_window_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GimpDisplayShell *shell;
return_if_no_gimp (gimp, data);
return_if_no_shell (shell, data);
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (gimp)),
gimp,
gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (GTK_WIDGET (shell)),
"gimp-navigation-view");
}
void
edit_named_paste_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GtkWidget *widget;
return_if_no_gimp (gimp, data);
return_if_no_widget (widget, data);
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (gimp)),
gimp,
gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (widget),
"gimp-buffer-list|gimp-buffer-grid");
}
void
file_open_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GtkWidget *widget;
GimpImage *image;
return_if_no_gimp (gimp, data);
return_if_no_widget (widget, data);
image = action_data_get_image (data);
file_open_dialog_show (gimp, widget,
_("Open Image"),
image, NULL, FALSE);
}
void
dialogs_create_dockable_cmd_callback (GtkAction *action,
const gchar *value,
gpointer data)
{
Gimp *gimp;
GtkWidget *widget;
return_if_no_gimp (gimp, data);
return_if_no_widget (widget, data);
if (value)
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (gimp)),
gimp,
gimp_dialog_factory_get_singleton (),
gimp_widget_get_monitor (widget),
value);
}
void
tools_select_cmd_callback (GtkAction *action,
const gchar *value,
gpointer data)
{
Gimp *gimp;
GimpToolInfo *tool_info;
GimpContext *context;
GimpDisplay *display;
gboolean rotate_layer = FALSE;
return_if_no_gimp (gimp, data);
/* special case gimp-rotate-tool being called from the Layer menu */
if (strcmp (value, "gimp-rotate-layer") == 0)
{
rotate_layer = TRUE;
value = "gimp-rotate-tool";
}
tool_info = gimp_get_tool_info (gimp, value);
context = gimp_get_user_context (gimp);
/* always allocate a new tool when selected from the image menu
*/
if (gimp_context_get_tool (context) != tool_info)
{
gimp_context_set_tool (context, tool_info);
if (rotate_layer)
g_object_set (tool_info->tool_options,
"type", GIMP_TRANSFORM_TYPE_LAYER,
NULL);
}
else
{
gimp_context_tool_changed (context);
}
display = gimp_context_get_display (context);
if (display && gimp_display_get_image (display))
tool_manager_initialize_active (gimp, display);
}
void
file_last_opened_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
Gimp *gimp;
GimpImagefile *imagefile;
gint num_entries;
return_if_no_gimp (gimp, data);
num_entries = gimp_container_num_children (gimp->documents);
if (value >= num_entries)
return;
imagefile = (GimpImagefile *)
gimp_container_get_child_by_index (gimp->documents, value);
if (imagefile)
{
GimpImage *image;
GimpPDBStatusType status;
GError *error = NULL;
image = file_open_with_display (gimp, action_data_get_context (data),
NULL,
GIMP_OBJECT (imagefile)->name, FALSE,
&status, &error);
if (! image && status != GIMP_PDB_CANCEL)
{
gchar *filename =
file_utils_uri_display_name (GIMP_OBJECT (imagefile)->name);
gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR,
_("Opening '%s' failed:\n\n%s"),
filename, error->message);
g_clear_error (&error);
g_free (filename);
}
}
}
void
file_open_as_layers_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
GtkWidget *widget;
GimpDisplay *display;
GimpImage *image = NULL;
return_if_no_gimp (gimp, data);
return_if_no_widget (widget, data);
display = action_data_get_display (data);
if (display)
image = gimp_display_get_image (display);
file_open_dialog_show (gimp, widget,
_("Open Image as Layers"),
image, NULL, TRUE);
}
void
file_close_all_cmd_callback (GtkAction *action,
gpointer data)
{
Gimp *gimp;
return_if_no_gimp (gimp, data);
if (! gimp_displays_dirty (gimp))
{
gimp_displays_close (gimp);
}
else
{
GtkWidget *widget;
return_if_no_widget (widget, data);
gimp_dialog_factory_dialog_raise (gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (widget),
"gimp-close-all-dialog", -1);
}
}
void
windows_show_display_previous_cmd_callback (GtkAction *action,
gpointer data)
{
GimpDisplay *display;
Gimp *gimp;
gint index;
return_if_no_display (display, data);
return_if_no_gimp (gimp, data);
index = gimp_container_get_child_index (gimp->displays,
GIMP_OBJECT (display));
index--;
if (index < 0)
index = gimp_container_get_n_children (gimp->displays) - 1;
display = GIMP_DISPLAY (gimp_container_get_child_by_index (gimp->displays,
index));
gimp_display_shell_present (gimp_display_get_shell (display));
}
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);
}
void
file_save_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
Gimp *gimp;
GimpDisplay *display;
GimpImage *image;
GtkWidget *widget;
GimpSaveMode save_mode;
const gchar *uri;
gboolean saved = FALSE;
return_if_no_gimp (gimp, data);
return_if_no_display (display, data);
return_if_no_widget (widget, data);
image = gimp_display_get_image (display);
save_mode = (GimpSaveMode) value;
if (! gimp_image_get_active_drawable (image))
return;
uri = gimp_image_get_uri (image);
switch (save_mode)
{
case GIMP_SAVE_MODE_SAVE:
case GIMP_SAVE_MODE_SAVE_AND_CLOSE:
/* Only save if the image has been modified, or if it is new. */
if ((gimp_image_is_dirty (image) ||
! GIMP_GUI_CONFIG (image->gimp->config)->trust_dirty_flag) ||
uri == NULL)
{
GimpPlugInProcedure *save_proc = gimp_image_get_save_proc (image);
if (uri && ! save_proc)
{
save_proc =
file_procedure_find (image->gimp->plug_in_manager->save_procs,
uri, NULL);
}
if (uri && save_proc)
{
saved = file_save_dialog_save_image (GIMP_PROGRESS (display),
gimp, image, uri,
save_proc,
GIMP_RUN_WITH_LAST_VALS,
TRUE, FALSE, FALSE, TRUE);
break;
}
/* fall thru */
}
else
{
gimp_message_literal (image->gimp,
G_OBJECT (display), GIMP_MESSAGE_INFO,
_("No changes need to be saved"));
saved = TRUE;
break;
}
case GIMP_SAVE_MODE_SAVE_AS:
file_save_dialog_show (gimp, image, widget,
_("Save Image"), FALSE,
save_mode == GIMP_SAVE_MODE_SAVE_AND_CLOSE, display);
break;
case GIMP_SAVE_MODE_SAVE_A_COPY:
file_save_dialog_show (gimp, image, widget,
_("Save a Copy of the Image"), TRUE,
FALSE, display);
break;
case GIMP_SAVE_MODE_EXPORT:
file_export_dialog_show (gimp, image, widget);
break;
case GIMP_SAVE_MODE_EXPORT_TO:
case GIMP_SAVE_MODE_OVERWRITE:
{
const gchar *uri = NULL;
GimpPlugInProcedure *export_proc;
gboolean overwrite;
if (save_mode == GIMP_SAVE_MODE_EXPORT_TO)
{
uri = gimp_image_get_exported_uri (image);
if (! uri)
{
/* Behave as if Export... was invoked */
file_export_dialog_show (gimp, image, widget);
break;
}
overwrite = FALSE;
}
else if (save_mode == GIMP_SAVE_MODE_OVERWRITE)
{
uri = gimp_image_get_imported_uri (image);
overwrite = TRUE;
}
if (uri)
{
export_proc =
file_procedure_find (image->gimp->plug_in_manager->export_procs,
uri, NULL);
}
if (uri && export_proc)
{
char *uri_copy;
/* The memory that 'uri' points to can be freed by
file_save_dialog_save_image(), when it eventually calls
gimp_image_set_imported_uri() to reset the imported uri,
resulting in garbage. So make a duplicate of it here. */
uri_copy = g_strdup (uri);
saved = file_save_dialog_save_image (GIMP_PROGRESS (display),
gimp, image, uri_copy,
export_proc,
GIMP_RUN_WITH_LAST_VALS,
FALSE,
overwrite, ! overwrite,
TRUE);
g_free (uri_copy);
}
}
break;
}
if (save_mode == GIMP_SAVE_MODE_SAVE_AND_CLOSE &&
saved &&
! gimp_image_is_dirty (image))
{
gimp_display_close (display);
}
}
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);
}
