void vectors_import_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; GtkWidget *dialog; return_if_no_image (image, data); return_if_no_widget (widget, data); #define IMPORT_DIALOG_KEY "gimp-vectors-import-dialog" dialog = dialogs_get_dialog (G_OBJECT (image), IMPORT_DIALOG_KEY); if (! dialog) { GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config); GFile *folder = NULL; if (config->vectors_import_path) folder = gimp_file_new_for_config_path (config->vectors_import_path, NULL); dialog = vectors_import_dialog_new (image, widget, folder, config->vectors_import_merge, config->vectors_import_scale, vectors_import_callback, NULL); dialogs_attach_dialog (G_OBJECT (image), IMPORT_DIALOG_KEY, dialog); } gtk_window_present (GTK_WINDOW (dialog)); }
void edit_copy_visible_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GError *error = NULL; return_if_no_image (image, data); if (gimp_edit_copy_visible (image, action_data_get_context (data), &error)) { GimpDisplay *display = action_data_get_display (data); if (display) gimp_message_literal (image->gimp, G_OBJECT (display), GIMP_MESSAGE_INFO, _("Copied pixels to the clipboard")); gimp_image_flush (image); } else { gimp_message_literal (image->gimp, G_OBJECT (action_data_get_display (data)), GIMP_MESSAGE_WARNING, error->message); g_clear_error (&error); } }
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 vectors_select_cmd_callback (GtkAction *action, gint value, gpointer data) { GimpImage *image; GimpVectors *vectors; GimpContainer *container; GimpVectors *new_vectors; return_if_no_image (image, data); vectors = gimp_image_get_active_vectors (image); if (vectors) container = gimp_item_get_container (GIMP_ITEM (vectors)); else container = gimp_image_get_vectors (image); new_vectors = (GimpVectors *) action_select_object ((GimpActionSelectType) value, container, (GimpObject *) vectors); if (new_vectors && new_vectors != vectors) { gimp_image_set_active_vectors (image, new_vectors); gimp_image_flush (image); } }
void channels_new_cmd_callback (GtkAction *action, gpointer data) { ChannelOptionsDialog *options; GimpImage *image; GtkWidget *widget; return_if_no_image (image, data); return_if_no_widget (widget, data); options = channel_options_dialog_new (image, NULL, action_data_get_context (data), widget, &channel_color, channel_name ? channel_name : _("Channel"), _("New Channel"), "gimp-channel-new", GIMP_STOCK_CHANNEL, _("New Channel Options"), GIMP_HELP_CHANNEL_NEW, _("New Channel Color"), _("_Fill opacity:"), TRUE); g_signal_connect (options->dialog, "response", G_CALLBACK (channels_new_channel_response), options); gtk_widget_show (options->dialog); }
void select_float_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; GError *error = NULL; return_if_no_image (image, data); return_if_no_widget (widget, data); if (gimp_selection_float (GIMP_SELECTION (gimp_image_get_mask (image)), gimp_image_get_active_drawable (image), action_data_get_context (data), TRUE, 0, 0, &error)) { gimp_image_flush (image); } else { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, error->message); g_clear_error (&error); } }
void vectors_paste_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; gchar *svg; gsize svg_size; return_if_no_image (image, data); return_if_no_widget (widget, data); svg = gimp_clipboard_get_svg (image->gimp, &svg_size); if (svg) { GError *error = NULL; if (! gimp_vectors_import_buffer (image, svg, svg_size, TRUE, FALSE, GIMP_IMAGE_ACTIVE_PARENT, -1, NULL, &error)) { gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } else { gimp_image_flush (image); } g_free (svg); } }
void select_stroke_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpDrawable *drawable; GtkWidget *widget; GtkWidget *dialog; return_if_no_image (image, data); return_if_no_widget (widget, data); drawable = gimp_image_get_active_drawable (image); if (! drawable) { gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, _("There is no active layer or channel to stroke to.")); return; } dialog = stroke_dialog_new (GIMP_ITEM (gimp_image_get_mask (image)), action_data_get_context (data), _("Stroke Selection"), GIMP_STOCK_SELECTION_STROKE, GIMP_HELP_SELECTION_STROKE, widget); gtk_widget_show (dialog); }
void vectors_new_cmd_callback (GtkAction *action, gpointer data) { VectorsOptionsDialog *options; GimpImage *image; GtkWidget *widget; return_if_no_image (image, data); return_if_no_widget (widget, data); options = vectors_options_dialog_new (image, NULL, action_data_get_context (data), widget, vectors_name ? vectors_name : _("New Path"), _("New Path"), "gimp-vectors-new", GIMP_STOCK_PATH, _("New Path Options"), GIMP_HELP_PATH_NEW); g_signal_connect (options->dialog, "response", G_CALLBACK (vectors_new_vectors_response), options); gtk_widget_show (options->dialog); }
void view_use_gegl_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpDisplayShell *shell; GList *layers; GList *list; gboolean active; return_if_no_image (image, data); return_if_no_shell (shell, data); active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)); gimp_image_get_projection (image)->use_gegl = active; layers = gimp_image_get_layer_list (image); for (list = layers; list; list = g_list_next (list)) { GimpLayer *layer = list->data; if (GIMP_IS_GROUP_LAYER (layer)) gimp_group_layer_get_projection (GIMP_GROUP_LAYER (layer))->use_gegl = active; } g_list_free (layers); gimp_image_invalidate (image, 0, 0, gimp_image_get_width (image), gimp_image_get_height (image)); gimp_image_flush (image); }
void colormap_edit_color_cmd_callback (GtkAction *action, gpointer data) { GimpColormapEditor *editor; GimpImage *image; const guchar *colormap; GimpRGB color; gchar *desc; return_if_no_image (image, data); editor = GIMP_COLORMAP_EDITOR (data); colormap = gimp_image_get_colormap (image); gimp_rgba_set_uchar (&color, colormap[editor->col_index * 3], colormap[editor->col_index * 3 + 1], colormap[editor->col_index * 3 + 2], OPAQUE_OPACITY); desc = g_strdup_printf (_("Edit colormap entry #%d"), editor->col_index); if (! editor->color_dialog) { editor->color_dialog = gimp_color_dialog_new (GIMP_VIEWABLE (image), action_data_get_context (data), _("Edit Colormap Entry"), GIMP_STOCK_COLORMAP, desc, GTK_WIDGET (editor), gimp_dialog_factory_from_name ("toplevel"), "gimp-colormap-editor-color-dialog", (const GimpRGB *) &color, FALSE, FALSE); g_signal_connect (editor->color_dialog, "destroy", G_CALLBACK (gtk_widget_destroyed), &editor->color_dialog); g_signal_connect (editor->color_dialog, "update", G_CALLBACK (colormap_edit_color_update), editor); } else { gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (editor->color_dialog), GIMP_VIEWABLE (image), action_data_get_context (data)); g_object_set (editor->color_dialog, "description", desc, NULL); gimp_color_dialog_set_color (GIMP_COLOR_DIALOG (editor->color_dialog), &color); } g_free (desc); gtk_window_present (GTK_WINDOW (editor->color_dialog)); }
void debug_show_image_graph_cmd_callback (GtkAction *action, gpointer data) { GimpImage *source_image = NULL; return_if_no_image (source_image, data); g_idle_add ((GSourceFunc) debug_show_image_graph, g_object_ref (source_image)); }
void edit_strong_undo_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; return_if_no_image (image, data); if (gimp_image_strong_undo (image)) gimp_image_flush (image); }
void image_flatten_image_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; return_if_no_image (image, data); gimp_image_flatten (image, action_data_get_context (data)); gimp_image_flush (image); }
void select_all_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; return_if_no_image (image, data); gimp_channel_all (gimp_image_get_mask (image), TRUE); gimp_image_flush (image); }
void vectors_selection_to_vectors_cmd_callback (GtkAction *action, gint value, gpointer data) { GimpImage *image; GtkWidget *widget; GimpProcedure *procedure; GimpValueArray *args; GimpDisplay *display; GError *error = NULL; return_if_no_image (image, data); return_if_no_widget (widget, data); if (value) procedure = gimp_pdb_lookup_procedure (image->gimp->pdb, "plug-in-sel2path-advanced"); else procedure = gimp_pdb_lookup_procedure (image->gimp->pdb, "plug-in-sel2path"); if (! procedure) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR, "Selection to path procedure lookup failed."); return; } display = gimp_context_get_display (action_data_get_context (data)); args = gimp_procedure_get_arguments (procedure); gimp_value_array_truncate (args, 2); g_value_set_int (gimp_value_array_index (args, 0), GIMP_RUN_INTERACTIVE); gimp_value_set_image (gimp_value_array_index (args, 1), image); gimp_procedure_execute_async (procedure, image->gimp, action_data_get_context (data), GIMP_PROGRESS (display), args, GIMP_OBJECT (display), &error); gimp_value_array_unref (args); if (error) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR, error->message); g_error_free (error); } }
void channels_new_last_vals_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpChannel *new_channel; gint width, height; GimpRGB color; return_if_no_image (image, data); if (GIMP_IS_CHANNEL (GIMP_ACTION (action)->viewable)) { GimpChannel *template = GIMP_CHANNEL (GIMP_ACTION (action)->viewable);
void edit_redo_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpDisplay *display; return_if_no_image (image, data); return_if_no_display (display, data); if (tool_manager_redo_active (image->gimp, display) || gimp_image_redo (image)) { gimp_image_flush (image); } }
void vectors_new_last_vals_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpVectors *new_vectors; return_if_no_image (image, data); new_vectors = gimp_vectors_new (image, vectors_name ? vectors_name : _("New Path")); gimp_image_add_vectors (image, new_vectors, -1); gimp_image_flush (image); }
void quick_mask_configure_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; GtkWidget *dialog; return_if_no_image (image, data); return_if_no_widget (widget, data); #define CONFIGURE_DIALOG_KEY "gimp-image-quick-mask-configure-dialog" dialog = dialogs_get_dialog (G_OBJECT (image), CONFIGURE_DIALOG_KEY); if (! dialog) { GimpRGB color; gimp_image_get_quick_mask_color (image, &color); dialog = channel_options_dialog_new (image, NULL, action_data_get_context (data), widget, _("Quick Mask Attributes"), "gimp-quick-mask-edit", GIMP_ICON_QUICK_MASK_ON, _("Edit Quick Mask Attributes"), GIMP_HELP_QUICK_MASK_EDIT, _("Edit Quick Mask Color"), _("_Mask opacity:"), FALSE, NULL, &color, FALSE, FALSE, GIMP_COLOR_TAG_NONE, FALSE, FALSE, quick_mask_configure_callback, NULL); item_options_dialog_set_switches_visible (dialog, FALSE); dialogs_attach_dialog (G_OBJECT (image), CONFIGURE_DIALOG_KEY, dialog); } gtk_window_present (GTK_WINDOW (dialog)); }
void layers_new_cmd_callback (GtkAction *action, gpointer data) { LayerOptionsDialog *dialog; GimpImage *image; GtkWidget *widget; GimpLayer *floating_sel; return_if_no_image (image, data); return_if_no_widget (widget, data); /* If there is a floating selection, the new command transforms * the current fs into a new layer */ if ((floating_sel = gimp_image_get_floating_selection (image))) { GError *error = NULL; if (! floating_sel_to_layer (floating_sel, &error)) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, error->message); g_clear_error (&error); return; } gimp_image_flush (image); return; } dialog = layer_options_dialog_new (image, NULL, action_data_get_context (data), widget, layer_name ? layer_name : _("Layer"), layer_fill_type, _("New Layer"), "gimp-layer-new", GIMP_STOCK_LAYER, _("Create a New Layer"), GIMP_HELP_LAYER_NEW); g_signal_connect (dialog->dialog, "response", G_CALLBACK (layers_new_layer_response), dialog); gtk_widget_show (dialog->dialog); }
void select_save_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; return_if_no_image (image, data); return_if_no_widget (widget, data); gimp_selection_save (gimp_image_get_mask (image)); gimp_image_flush (image); gimp_dialog_factory_dialog_raise (global_dock_factory, gtk_widget_get_screen (widget), "gimp-channel-list", -1); }
void quick_mask_toggle_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; gboolean active; return_if_no_image (image, data); active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)); if (active != gimp_image_get_quick_mask_state (image)) { gimp_image_set_quick_mask_state (image, active); gimp_image_flush (image); } }
void vectors_new_last_vals_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpVectors *vectors; GimpDialogConfig *config; return_if_no_image (image, data); config = GIMP_DIALOG_CONFIG (image->gimp->config); vectors = gimp_vectors_new (image, config->vectors_new_name); gimp_image_add_vectors (image, vectors, GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE); gimp_image_flush (image); }
void channels_new_last_vals_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpChannel *new_channel; gint width, height; GimpRGB color; GimpDialogConfig *config; return_if_no_image (image, data); config = GIMP_DIALOG_CONFIG (image->gimp->config); if (GIMP_IS_CHANNEL (GIMP_ACTION (action)->viewable)) { GimpChannel *template = GIMP_CHANNEL (GIMP_ACTION (action)->viewable);
void select_stroke_last_vals_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpDrawable *drawable; GimpContext *context; GtkWidget *widget; GimpStrokeOptions *options; GError *error = NULL; return_if_no_image (image, data); return_if_no_context (context, data); return_if_no_widget (widget, data); drawable = gimp_image_get_active_drawable (image); if (! drawable) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, _("There is no active layer or channel to stroke to.")); return; } options = g_object_get_data (G_OBJECT (image->gimp), "saved-stroke-options"); if (options) g_object_ref (options); else options = gimp_stroke_options_new (image->gimp, context, TRUE); if (! gimp_item_stroke (GIMP_ITEM (gimp_image_get_mask (image)), drawable, context, options, NULL, TRUE, NULL, &error)) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, error->message); g_clear_error (&error); } else { gimp_image_flush (image); } g_object_unref (options); }
void quick_mask_invert_cmd_callback (GtkAction *action, GtkAction *current, gpointer data) { GimpImage *image; gint value; return_if_no_image (image, data); value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action)); if (value != gimp_image_get_quick_mask_inverted (image)) { gimp_image_quick_mask_invert (image); gimp_image_flush (image); } }
void view_zoom_selection_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GimpImage *image; gint x, y, width, height; return_if_no_display (display, data); return_if_no_image (image, data); gimp_item_bounds (GIMP_ITEM (gimp_image_get_mask (image)), &x, &y, &width, &height); gimp_display_shell_scale_to_rectangle (gimp_display_get_shell (display), GIMP_ZOOM_IN, x, y, width, height, FALSE); }
void channels_new_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; GtkWidget *dialog; return_if_no_image (image, data); return_if_no_widget (widget, data); #define NEW_DIALOG_KEY "gimp-channel-new-dialog" dialog = dialogs_get_dialog (G_OBJECT (image), NEW_DIALOG_KEY); if (! dialog) { GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config); dialog = channel_options_dialog_new (image, NULL, action_data_get_context (data), widget, _("New Channel"), "gimp-channel-new", GIMP_STOCK_CHANNEL, _("Create a New Channel"), GIMP_HELP_CHANNEL_NEW, _("New Channel Color"), _("_Fill opacity:"), TRUE, config->channel_new_name, &config->channel_new_color, TRUE, FALSE, GIMP_COLOR_TAG_NONE, FALSE, FALSE, channels_new_callback, NULL); dialogs_attach_dialog (G_OBJECT (image), NEW_DIALOG_KEY, dialog); } gtk_window_present (GTK_WINDOW (dialog)); }
void edit_named_copy_visible_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; GtkWidget *dialog; return_if_no_image (image, data); return_if_no_widget (widget, data); dialog = gimp_query_string_box (_("Copy Visible Named "), widget, gimp_standard_help_func, GIMP_HELP_BUFFER_COPY, _("Enter a name for this buffer"), NULL, G_OBJECT (image), "disconnect", copy_named_visible_buffer_callback, image); gtk_widget_show (dialog); }