/* PIKA - Photo and Image Kooker Application * a rebranding of The GNU Image Manipulation Program (created with heckimp) * A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio * * Original copyright, applying to most contents (license remains unchanged): * Copyright (C) 1995 Spencer Kimball and Peter Mattis * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "config.h" #include #include #include #include "libpikabase/pikabase.h" #include "libpikamath/pikamath.h" #include "libpikawidgets/pikawidgets.h" #include "tools-types.h" #include "operations/pika-operation-config.h" #include "core/pikadata.h" #include "core/pikagradient.h" #include "core/pika-gradients.h" #include "core/pikaimage.h" #include "widgets/pikacolorpanel.h" #include "widgets/pikaeditor.h" #include "widgets/pikawidgets-utils.h" #include "display/pikadisplay.h" #include "display/pikadisplayshell.h" #include "display/pikatoolgui.h" #include "display/pikatoolline.h" #include "pikagradientoptions.h" #include "pikagradienttool.h" #include "pikagradienttool-editor.h" #include "pika-intl.h" #define EPSILON 2e-10 typedef enum { DIRECTION_NONE, DIRECTION_LEFT, DIRECTION_RIGHT } Direction; typedef struct { /* line endpoints at the beginning of the operation */ gdouble start_x; gdouble start_y; gdouble end_x; gdouble end_y; /* copy of the gradient at the beginning of the operation, owned by the gradient * info, or NULL, if the gradient isn't affected */ PikaGradient *gradient; /* handle added by the operation, or HANDLE_NONE */ gint added_handle; /* handle removed by the operation, or HANDLE_NONE */ gint removed_handle; /* selected handle at the end of the operation, or HANDLE_NONE */ gint selected_handle; } GradientInfo; /* local function prototypes */ static gboolean pika_gradient_tool_editor_line_can_add_slider (PikaToolLine *line, gdouble value, PikaGradientTool *gradient_tool); static gint pika_gradient_tool_editor_line_add_slider (PikaToolLine *line, gdouble value, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_line_prepare_to_remove_slider (PikaToolLine *line, gint slider, gboolean remove, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_line_remove_slider (PikaToolLine *line, gint slider, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_line_selection_changed (PikaToolLine *line, PikaGradientTool *gradient_tool); static gboolean pika_gradient_tool_editor_line_handle_clicked (PikaToolLine *line, gint handle, GdkModifierType state, PikaButtonPressType press_type, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_gui_response (PikaToolGui *gui, gint response_id, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_color_entry_color_clicked (PikaColorButton *button, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_color_entry_color_changed (PikaColorButton *button, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_color_entry_color_response (PikaColorButton *button, PikaColorDialogState state, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_color_entry_type_changed (GtkComboBox *combo, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_endpoint_se_value_changed (PikaSizeEntry *se, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_stop_se_value_changed (PikaSizeEntry *se, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_stop_delete_clicked (GtkWidget *button, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_midpoint_se_value_changed (PikaSizeEntry *se, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_midpoint_type_changed (GtkComboBox *combo, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_midpoint_color_changed (GtkComboBox *combo, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_midpoint_new_stop_clicked (GtkWidget *button, PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_midpoint_center_clicked (GtkWidget *button, PikaGradientTool *gradient_tool); static gboolean pika_gradient_tool_editor_flush_idle (PikaGradientTool *gradient_tool); static gboolean pika_gradient_tool_editor_is_gradient_editable (PikaGradientTool *gradient_tool); static gboolean pika_gradient_tool_editor_handle_is_endpoint (PikaGradientTool *gradient_tool, gint handle); static gboolean pika_gradient_tool_editor_handle_is_stop (PikaGradientTool *gradient_tool, gint handle); static gboolean pika_gradient_tool_editor_handle_is_midpoint (PikaGradientTool *gradient_tool, gint handle); static PikaGradientSegment * pika_gradient_tool_editor_handle_get_segment (PikaGradientTool *gradient_tool, gint handle); static void pika_gradient_tool_editor_block_handlers (PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_unblock_handlers (PikaGradientTool *gradient_tool); static gboolean pika_gradient_tool_editor_are_handlers_blocked (PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_freeze_gradient (PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_thaw_gradient (PikaGradientTool *gradient_tool); static gint pika_gradient_tool_editor_add_stop (PikaGradientTool *gradient_tool, gdouble value); static void pika_gradient_tool_editor_delete_stop (PikaGradientTool *gradient_tool, gint slider); static gint pika_gradient_tool_editor_midpoint_to_stop (PikaGradientTool *gradient_tool, gint slider); static void pika_gradient_tool_editor_update_sliders (PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_purge_gradient_history (GSList **stack); static void pika_gradient_tool_editor_purge_gradient (PikaGradientTool *gradient_tool); static GtkWidget * pika_gradient_tool_editor_color_entry_new (PikaGradientTool *gradient_tool, const gchar *title, Direction direction, GtkWidget *chain_button, GtkWidget **color_panel, GtkWidget **type_combo); static void pika_gradient_tool_editor_init_endpoint_gui (PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_init_stop_gui (PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_init_midpoint_gui (PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_update_endpoint_gui (PikaGradientTool *gradient_tool, gint selection); static void pika_gradient_tool_editor_update_stop_gui (PikaGradientTool *gradient_tool, gint selection); static void pika_gradient_tool_editor_update_midpoint_gui (PikaGradientTool *gradient_tool, gint selection); static void pika_gradient_tool_editor_update_gui (PikaGradientTool *gradient_tool); static GradientInfo * pika_gradient_tool_editor_gradient_info_new (PikaGradientTool *gradient_tool); static void pika_gradient_tool_editor_gradient_info_free (GradientInfo *info); static void pika_gradient_tool_editor_gradient_info_apply (PikaGradientTool *gradient_tool, const GradientInfo *info, gboolean set_selection); static gboolean pika_gradient_tool_editor_gradient_info_is_trivial (PikaGradientTool *gradient_tool, const GradientInfo *info); /* private functions */ static gboolean pika_gradient_tool_editor_line_can_add_slider (PikaToolLine *line, gdouble value, PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); gdouble offset = options->offset / 100.0; return pika_gradient_tool_editor_is_gradient_editable (gradient_tool) && value >= offset; } static gint pika_gradient_tool_editor_line_add_slider (PikaToolLine *line, gdouble value, PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaPaintOptions *paint_options = PIKA_PAINT_OPTIONS (options); gdouble offset = options->offset / 100.0; /* adjust slider value according to the offset */ value = (value - offset) / (1.0 - offset); /* flip the slider value, if necessary */ if (paint_options->gradient_options->gradient_reverse) value = 1.0 - value; return pika_gradient_tool_editor_add_stop (gradient_tool, value); } static void pika_gradient_tool_editor_line_prepare_to_remove_slider (PikaToolLine *line, gint slider, gboolean remove, PikaGradientTool *gradient_tool) { if (remove) { GradientInfo *info; PikaGradient *tentative_gradient; /* show a tentative gradient, demonstrating the result of actually * removing the slider */ info = gradient_tool->undo_stack->data; if (info->added_handle == slider) { /* see comment in pika_gradient_tool_editor_delete_stop() */ pika_assert (info->gradient != NULL); tentative_gradient = g_object_ref (info->gradient); } else { PikaGradientSegment *seg; gint i; tentative_gradient = PIKA_GRADIENT (pika_data_duplicate (PIKA_DATA (gradient_tool->gradient))); seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, slider); i = pika_gradient_segment_range_get_n_segments (gradient_tool->gradient, gradient_tool->gradient->segments, seg) - 1; seg = pika_gradient_segment_get_nth (tentative_gradient->segments, i); pika_gradient_segment_range_merge (tentative_gradient, seg, seg->next, NULL, NULL); } pika_gradient_tool_set_tentative_gradient (gradient_tool, tentative_gradient); g_object_unref (tentative_gradient); } else { pika_gradient_tool_set_tentative_gradient (gradient_tool, NULL); } } static void pika_gradient_tool_editor_line_remove_slider (PikaToolLine *line, gint slider, PikaGradientTool *gradient_tool) { pika_gradient_tool_editor_delete_stop (gradient_tool, slider); pika_gradient_tool_set_tentative_gradient (gradient_tool, NULL); } static void pika_gradient_tool_editor_line_selection_changed (PikaToolLine *line, PikaGradientTool *gradient_tool) { gint selection; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); if (gradient_tool->gui) { /* hide all color dialogs */ pika_color_panel_dialog_response ( PIKA_COLOR_PANEL (gradient_tool->endpoint_color_panel), PIKA_COLOR_DIALOG_OK); pika_color_panel_dialog_response ( PIKA_COLOR_PANEL (gradient_tool->stop_left_color_panel), PIKA_COLOR_DIALOG_OK); pika_color_panel_dialog_response ( PIKA_COLOR_PANEL (gradient_tool->stop_right_color_panel), PIKA_COLOR_DIALOG_OK); /* reset the stop colors chain button */ if (pika_gradient_tool_editor_handle_is_stop (gradient_tool, selection)) { const PikaGradientSegment *seg; gboolean homogeneous; seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); homogeneous = seg->right_color.r == seg->next->left_color.r && seg->right_color.g == seg->next->left_color.g && seg->right_color.b == seg->next->left_color.b && seg->right_color.a == seg->next->left_color.a && seg->right_color_type == seg->next->left_color_type; pika_chain_button_set_active ( PIKA_CHAIN_BUTTON (gradient_tool->stop_chain_button), homogeneous); } } pika_gradient_tool_editor_update_gui (gradient_tool); } static gboolean pika_gradient_tool_editor_line_handle_clicked (PikaToolLine *line, gint handle, GdkModifierType state, PikaButtonPressType press_type, PikaGradientTool *gradient_tool) { if (pika_gradient_tool_editor_handle_is_midpoint (gradient_tool, handle)) { if (press_type == PIKA_BUTTON_PRESS_DOUBLE && pika_gradient_tool_editor_is_gradient_editable (gradient_tool)) { gint stop; stop = pika_gradient_tool_editor_midpoint_to_stop (gradient_tool, handle); pika_tool_line_set_selection (line, stop); /* return FALSE, so that the new slider can be dragged immediately */ return FALSE; } } return FALSE; } static void pika_gradient_tool_editor_gui_response (PikaToolGui *gui, gint response_id, PikaGradientTool *gradient_tool) { switch (response_id) { default: pika_tool_line_set_selection (PIKA_TOOL_LINE (gradient_tool->widget), PIKA_TOOL_LINE_HANDLE_NONE); break; } } static void pika_gradient_tool_editor_color_entry_color_clicked (PikaColorButton *button, PikaGradientTool *gradient_tool) { pika_gradient_tool_editor_start_edit (gradient_tool); } static void pika_gradient_tool_editor_color_entry_color_changed (PikaColorButton *button, PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaPaintOptions *paint_options = PIKA_PAINT_OPTIONS (options); gint selection; PikaRGB color; Direction direction; GtkWidget *chain_button; PikaGradientSegment *seg; if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); pika_color_button_get_color (button, &color); direction = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (button), "pika-gradient-tool-editor-direction")); chain_button = g_object_get_data (G_OBJECT (button), "pika-gradient-tool-editor-chain-button"); pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); /* swap the endpoint handles, if necessary */ if (paint_options->gradient_options->gradient_reverse) { switch (selection) { case PIKA_TOOL_LINE_HANDLE_START: selection = PIKA_TOOL_LINE_HANDLE_END; break; case PIKA_TOOL_LINE_HANDLE_END: selection = PIKA_TOOL_LINE_HANDLE_START; break; } } seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); switch (selection) { case PIKA_TOOL_LINE_HANDLE_START: seg->left_color = color; seg->left_color_type = PIKA_GRADIENT_COLOR_FIXED; break; case PIKA_TOOL_LINE_HANDLE_END: seg->right_color = color; seg->right_color_type = PIKA_GRADIENT_COLOR_FIXED; break; default: if (direction == DIRECTION_LEFT || (chain_button && pika_chain_button_get_active (PIKA_CHAIN_BUTTON (chain_button)))) { seg->right_color = color; seg->right_color_type = PIKA_GRADIENT_COLOR_FIXED; } if (direction == DIRECTION_RIGHT || (chain_button && pika_chain_button_get_active (PIKA_CHAIN_BUTTON (chain_button)))) { seg->next->left_color = color; seg->next->left_color_type = PIKA_GRADIENT_COLOR_FIXED; } } pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static void pika_gradient_tool_editor_color_entry_color_response (PikaColorButton *button, PikaColorDialogState state, PikaGradientTool *gradient_tool) { pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static void pika_gradient_tool_editor_color_entry_type_changed (GtkComboBox *combo, PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaPaintOptions *paint_options = PIKA_PAINT_OPTIONS (options); gint selection; gint color_type; Direction direction; GtkWidget *chain_button; PikaGradientSegment *seg; if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); if (! pika_int_combo_box_get_active (PIKA_INT_COMBO_BOX (combo), &color_type)) return; direction = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (combo), "pika-gradient-tool-editor-direction")); chain_button = g_object_get_data (G_OBJECT (combo), "pika-gradient-tool-editor-chain-button"); pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); /* swap the endpoint handles, if necessary */ if (paint_options->gradient_options->gradient_reverse) { switch (selection) { case PIKA_TOOL_LINE_HANDLE_START: selection = PIKA_TOOL_LINE_HANDLE_END; break; case PIKA_TOOL_LINE_HANDLE_END: selection = PIKA_TOOL_LINE_HANDLE_START; break; } } seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); switch (selection) { case PIKA_TOOL_LINE_HANDLE_START: seg->left_color_type = color_type; break; case PIKA_TOOL_LINE_HANDLE_END: seg->right_color_type = color_type; break; default: if (direction == DIRECTION_LEFT || (chain_button && pika_chain_button_get_active (PIKA_CHAIN_BUTTON (chain_button)))) { seg->right_color_type = color_type; } if (direction == DIRECTION_RIGHT || (chain_button && pika_chain_button_get_active (PIKA_CHAIN_BUTTON (chain_button)))) { seg->next->left_color_type = color_type; } } pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static void pika_gradient_tool_editor_endpoint_se_value_changed (PikaSizeEntry *se, PikaGradientTool *gradient_tool) { gint selection; gdouble x; gdouble y; if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); if (selection == PIKA_TOOL_LINE_HANDLE_NONE) return; x = pika_size_entry_get_refval (se, 0); y = pika_size_entry_get_refval (se, 1); pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_block_handlers (gradient_tool); switch (selection) { case PIKA_TOOL_LINE_HANDLE_START: g_object_set (gradient_tool->widget, "x1", x, "y1", y, NULL); break; case PIKA_TOOL_LINE_HANDLE_END: g_object_set (gradient_tool->widget, "x2", x, "y2", y, NULL); break; default: pika_assert_not_reached (); } pika_gradient_tool_editor_unblock_handlers (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static void pika_gradient_tool_editor_stop_se_value_changed (PikaSizeEntry *se, PikaGradientTool *gradient_tool) { gint selection; gdouble value; PikaGradientSegment *seg; if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); if (selection == PIKA_TOOL_LINE_HANDLE_NONE) return; value = pika_size_entry_get_refval (se, 0) / 100.0; pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); pika_gradient_segment_range_compress (gradient_tool->gradient, seg, seg, seg->left, value); pika_gradient_segment_range_compress (gradient_tool->gradient, seg->next, seg->next, value, seg->next->right); pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static void pika_gradient_tool_editor_stop_delete_clicked (GtkWidget *button, PikaGradientTool *gradient_tool) { gint selection; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); pika_gradient_tool_editor_delete_stop (gradient_tool, selection); } static void pika_gradient_tool_editor_midpoint_se_value_changed (PikaSizeEntry *se, PikaGradientTool *gradient_tool) { gint selection; gdouble value; PikaGradientSegment *seg; if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); if (selection == PIKA_TOOL_LINE_HANDLE_NONE) return; value = pika_size_entry_get_refval (se, 0) / 100.0; pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); seg->middle = value; pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static void pika_gradient_tool_editor_midpoint_type_changed (GtkComboBox *combo, PikaGradientTool *gradient_tool) { gint selection; gint type; PikaGradientSegment *seg; if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); if (! pika_int_combo_box_get_active (PIKA_INT_COMBO_BOX (combo), &type)) return; pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); seg->type = type; pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static void pika_gradient_tool_editor_midpoint_color_changed (GtkComboBox *combo, PikaGradientTool *gradient_tool) { gint selection; gint color; PikaGradientSegment *seg; if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); if (! pika_int_combo_box_get_active (PIKA_INT_COMBO_BOX (combo), &color)) return; pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); seg->color = color; pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static void pika_gradient_tool_editor_midpoint_new_stop_clicked (GtkWidget *button, PikaGradientTool *gradient_tool) { gint selection; gint stop; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); stop = pika_gradient_tool_editor_midpoint_to_stop (gradient_tool, selection); pika_tool_line_set_selection (PIKA_TOOL_LINE (gradient_tool->widget), stop); } static void pika_gradient_tool_editor_midpoint_center_clicked (GtkWidget *button, PikaGradientTool *gradient_tool) { gint selection; PikaGradientSegment *seg; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); pika_gradient_segment_range_recenter_handles (gradient_tool->gradient, seg, seg); pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static gboolean pika_gradient_tool_editor_flush_idle (PikaGradientTool *gradient_tool) { PikaDisplay *display = PIKA_TOOL (gradient_tool)->display; pika_image_flush (pika_display_get_image (display)); gradient_tool->flush_idle_id = 0; return G_SOURCE_REMOVE; } static gboolean pika_gradient_tool_editor_is_gradient_editable (PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); return ! options->modify_active || pika_data_is_writable (PIKA_DATA (gradient_tool->gradient)); } static gboolean pika_gradient_tool_editor_handle_is_endpoint (PikaGradientTool *gradient_tool, gint handle) { return handle == PIKA_TOOL_LINE_HANDLE_START || handle == PIKA_TOOL_LINE_HANDLE_END; } static gboolean pika_gradient_tool_editor_handle_is_stop (PikaGradientTool *gradient_tool, gint handle) { gint n_sliders; pika_tool_line_get_sliders (PIKA_TOOL_LINE (gradient_tool->widget), &n_sliders); return handle >= 0 && handle < n_sliders / 2; } static gboolean pika_gradient_tool_editor_handle_is_midpoint (PikaGradientTool *gradient_tool, gint handle) { gint n_sliders; pika_tool_line_get_sliders (PIKA_TOOL_LINE (gradient_tool->widget), &n_sliders); return handle >= n_sliders / 2; } static PikaGradientSegment * pika_gradient_tool_editor_handle_get_segment (PikaGradientTool *gradient_tool, gint handle) { switch (handle) { case PIKA_TOOL_LINE_HANDLE_START: return gradient_tool->gradient->segments; case PIKA_TOOL_LINE_HANDLE_END: return pika_gradient_segment_get_last (gradient_tool->gradient->segments); default: { const PikaControllerSlider *sliders; gint n_sliders; gint seg_i; sliders = pika_tool_line_get_sliders (PIKA_TOOL_LINE (gradient_tool->widget), &n_sliders); pika_assert (handle >= 0 && handle < n_sliders); seg_i = GPOINTER_TO_INT (sliders[handle].data); return pika_gradient_segment_get_nth (gradient_tool->gradient->segments, seg_i); } } } static void pika_gradient_tool_editor_block_handlers (PikaGradientTool *gradient_tool) { gradient_tool->block_handlers_count++; } static void pika_gradient_tool_editor_unblock_handlers (PikaGradientTool *gradient_tool) { pika_assert (gradient_tool->block_handlers_count > 0); gradient_tool->block_handlers_count--; } static gboolean pika_gradient_tool_editor_are_handlers_blocked (PikaGradientTool *gradient_tool) { return gradient_tool->block_handlers_count > 0; } static void pika_gradient_tool_editor_freeze_gradient (PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaGradient *custom; GradientInfo *info; pika_gradient_tool_editor_block_handlers (gradient_tool); custom = pika_gradients_get_custom (PIKA_CONTEXT (options)->pika); if (gradient_tool->gradient == custom || options->modify_active) { pika_assert (pika_gradient_tool_editor_is_gradient_editable (gradient_tool)); pika_data_freeze (PIKA_DATA (gradient_tool->gradient)); } else { /* copy the active gradient to the custom gradient, and make the custom * gradient active. */ pika_data_freeze (PIKA_DATA (custom)); pika_data_copy (PIKA_DATA (custom), PIKA_DATA (gradient_tool->gradient)); pika_context_set_gradient (PIKA_CONTEXT (options), custom); pika_assert (gradient_tool->gradient == custom); pika_assert (pika_gradient_tool_editor_is_gradient_editable (gradient_tool)); } if (gradient_tool->edit_count > 0) { info = gradient_tool->undo_stack->data; if (! info->gradient) { info->gradient = PIKA_GRADIENT (pika_data_duplicate (PIKA_DATA (gradient_tool->gradient))); } } } static void pika_gradient_tool_editor_thaw_gradient (PikaGradientTool *gradient_tool) { pika_data_thaw (PIKA_DATA (gradient_tool->gradient)); pika_gradient_tool_editor_update_sliders (gradient_tool); pika_gradient_tool_editor_update_gui (gradient_tool); pika_gradient_tool_editor_unblock_handlers (gradient_tool); } static gint pika_gradient_tool_editor_add_stop (PikaGradientTool *gradient_tool, gdouble value) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaPaintOptions *paint_options = PIKA_PAINT_OPTIONS (options); PikaGradientSegment *seg; gint stop; GradientInfo *info; pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); pika_gradient_split_at (gradient_tool->gradient, PIKA_CONTEXT (options), NULL, value, paint_options->gradient_options->gradient_blend_color_space, &seg, NULL); stop = pika_gradient_segment_range_get_n_segments (gradient_tool->gradient, gradient_tool->gradient->segments, seg) - 1; info = gradient_tool->undo_stack->data; info->added_handle = stop; pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); return stop; } static void pika_gradient_tool_editor_delete_stop (PikaGradientTool *gradient_tool, gint slider) { GradientInfo *info; pika_assert (pika_gradient_tool_editor_handle_is_stop (gradient_tool, slider)); pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); info = gradient_tool->undo_stack->data; if (info->added_handle == slider) { /* when removing a stop that was added as part of the current action, * restore the original gradient at the beginning of the action, rather * than deleting the stop from the current gradient, so that the affected * midpoint returns to its state at the beginning of the action, instead * of being reset. * * note that this assumes that the gradient hasn't changed in any other * way during the action, which is ugly, but currently always true. */ pika_assert (info->gradient != NULL); pika_data_copy (PIKA_DATA (gradient_tool->gradient), PIKA_DATA (info->gradient)); g_clear_object (&info->gradient); info->added_handle = PIKA_TOOL_LINE_HANDLE_NONE; } else { PikaGradientSegment *seg; seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, slider); pika_gradient_segment_range_merge (gradient_tool->gradient, seg, seg->next, NULL, NULL); info->removed_handle = slider; } pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } static gint pika_gradient_tool_editor_midpoint_to_stop (PikaGradientTool *gradient_tool, gint slider) { const PikaControllerSlider *sliders; pika_assert (pika_gradient_tool_editor_handle_is_midpoint (gradient_tool, slider)); sliders = pika_tool_line_get_sliders (PIKA_TOOL_LINE (gradient_tool->widget), NULL); if (sliders[slider].value > sliders[slider].min + EPSILON && sliders[slider].value < sliders[slider].max - EPSILON) { const PikaGradientSegment *seg; gint stop; GradientInfo *info; seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, slider); stop = pika_gradient_tool_editor_add_stop (gradient_tool, seg->middle); info = gradient_tool->undo_stack->data; info->removed_handle = slider; slider = stop; } return slider; } static void pika_gradient_tool_editor_update_sliders (PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaPaintOptions *paint_options = PIKA_PAINT_OPTIONS (options); gdouble offset = options->offset / 100.0; gboolean editable; PikaControllerSlider *sliders; gint n_sliders; gint n_segments; PikaGradientSegment *seg; PikaControllerSlider *slider; gint i; if (! gradient_tool->widget || options->instant) return; editable = pika_gradient_tool_editor_is_gradient_editable (gradient_tool); n_segments = pika_gradient_segment_range_get_n_segments ( gradient_tool->gradient, gradient_tool->gradient->segments, NULL); n_sliders = (n_segments - 1) + /* gradient stops, between each adjacent * pair of segments */ (n_segments); /* midpoints, inside each segment */ sliders = g_new (PikaControllerSlider, n_sliders); slider = sliders; /* initialize the gradient-stop sliders */ for (seg = gradient_tool->gradient->segments, i = 0; seg->next; seg = seg->next, i++) { *slider = PIKA_CONTROLLER_SLIDER_DEFAULT; slider->value = seg->right; slider->min = seg->left; slider->max = seg->next->right; slider->movable = editable; slider->removable = editable; slider->data = GINT_TO_POINTER (i); slider++; } /* initialize the midpoint sliders */ for (seg = gradient_tool->gradient->segments, i = 0; seg; seg = seg->next, i++) { *slider = PIKA_CONTROLLER_SLIDER_DEFAULT; slider->value = seg->middle; slider->min = seg->left; slider->max = seg->right; /* hide midpoints of zero-length segments, since they'd otherwise * prevent the segment's endpoints from being selected */ slider->visible = fabs (slider->max - slider->min) > EPSILON; slider->movable = editable; slider->autohide = TRUE; slider->type = PIKA_HANDLE_FILLED_CIRCLE; slider->size = 0.6; slider->data = GINT_TO_POINTER (i); slider++; } /* flip the slider limits and values, if necessary */ if (paint_options->gradient_options->gradient_reverse) { for (i = 0; i < n_sliders; i++) { gdouble temp; sliders[i].value = 1.0 - sliders[i].value; temp = sliders[i].min; sliders[i].min = 1.0 - sliders[i].max; sliders[i].max = 1.0 - temp; } } /* adjust the sliders according to the offset */ for (i = 0; i < n_sliders; i++) { sliders[i].value = (1.0 - offset) * sliders[i].value + offset; sliders[i].min = (1.0 - offset) * sliders[i].min + offset; sliders[i].max = (1.0 - offset) * sliders[i].max + offset; } /* avoid updating the gradient in pika_gradient_tool_editor_line_changed() */ pika_gradient_tool_editor_block_handlers (gradient_tool); pika_tool_line_set_sliders (PIKA_TOOL_LINE (gradient_tool->widget), sliders, n_sliders); pika_gradient_tool_editor_unblock_handlers (gradient_tool); g_free (sliders); } static void pika_gradient_tool_editor_purge_gradient_history (GSList **stack) { GSList *link; /* eliminate all history steps that modify the gradient */ while ((link = *stack)) { GradientInfo *info = link->data; if (info->gradient) { pika_gradient_tool_editor_gradient_info_free (info); *stack = g_slist_delete_link (*stack, link); } else { stack = &link->next; } } } static void pika_gradient_tool_editor_purge_gradient (PikaGradientTool *gradient_tool) { if (gradient_tool->widget) { pika_gradient_tool_editor_update_sliders (gradient_tool); pika_tool_line_set_selection (PIKA_TOOL_LINE (gradient_tool->widget), PIKA_TOOL_LINE_HANDLE_NONE); } pika_gradient_tool_editor_purge_gradient_history (&gradient_tool->undo_stack); pika_gradient_tool_editor_purge_gradient_history (&gradient_tool->redo_stack); } static GtkWidget * pika_gradient_tool_editor_color_entry_new (PikaGradientTool *gradient_tool, const gchar *title, Direction direction, GtkWidget *chain_button, GtkWidget **color_panel, GtkWidget **type_combo) { PikaContext *context = PIKA_CONTEXT (PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool)); GtkWidget *hbox; GtkWidget *button; GtkWidget *combo; PikaRGB color = {}; hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); /* the color panel */ *color_panel = button = pika_color_panel_new (title, &color, PIKA_COLOR_AREA_SMALL_CHECKS, 24, 24); pika_color_button_set_update (PIKA_COLOR_BUTTON (button), TRUE); pika_color_panel_set_context (PIKA_COLOR_PANEL (button), context); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "pika-gradient-tool-editor-direction", GINT_TO_POINTER (direction)); g_object_set_data (G_OBJECT (button), "pika-gradient-tool-editor-chain-button", chain_button); g_signal_connect (button, "clicked", G_CALLBACK (pika_gradient_tool_editor_color_entry_color_clicked), gradient_tool); g_signal_connect (button, "color-changed", G_CALLBACK (pika_gradient_tool_editor_color_entry_color_changed), gradient_tool); g_signal_connect (button, "response", G_CALLBACK (pika_gradient_tool_editor_color_entry_color_response), gradient_tool); /* the color type combo */ *type_combo = combo = pika_enum_combo_box_new (PIKA_TYPE_GRADIENT_COLOR); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, TRUE, 0); gtk_widget_show (combo); g_object_set_data (G_OBJECT (combo), "pika-gradient-tool-editor-direction", GINT_TO_POINTER (direction)); g_object_set_data (G_OBJECT (combo), "pika-gradient-tool-editor-chain-button", chain_button); g_signal_connect (combo, "changed", G_CALLBACK (pika_gradient_tool_editor_color_entry_type_changed), gradient_tool); return hbox; } static void pika_gradient_tool_editor_init_endpoint_gui (PikaGradientTool *gradient_tool) { PikaDisplay *display = PIKA_TOOL (gradient_tool)->display; PikaDisplayShell *shell = pika_display_get_shell (display); PikaImage *image = pika_display_get_image (display); gdouble xres; gdouble yres; GtkWidget *editor; GtkWidget *grid; GtkWidget *label; GtkWidget *spinbutton; GtkWidget *se; GtkWidget *hbox; gint row = 0; pika_image_get_resolution (image, &xres, &yres); /* the endpoint editor */ gradient_tool->endpoint_editor = editor = pika_editor_new (); gtk_box_pack_start (GTK_BOX (pika_tool_gui_get_vbox (gradient_tool->gui)), editor, FALSE, TRUE, 0); /* the main grid */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 4); gtk_grid_set_column_spacing (GTK_GRID (grid), 4); gtk_box_pack_start (GTK_BOX (editor), grid, FALSE, TRUE, 0); gtk_widget_show (grid); /* the position labels */ label = gtk_label_new (_("X:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), label, 0, row, 1, 1); gtk_widget_show (label); label = gtk_label_new (_("Y:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), label, 0, row + 1, 1, 1); gtk_widget_show (label); /* the position size entry */ spinbutton = pika_spin_button_new_with_range (0.0, 0.0, 1.0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 6); gradient_tool->endpoint_se = se = pika_size_entry_new (1, PIKA_UNIT_PIXEL, "%a", TRUE, TRUE, FALSE, 6, PIKA_SIZE_ENTRY_UPDATE_SIZE); gtk_grid_set_row_spacing (GTK_GRID (se), 4); gtk_grid_set_column_spacing (GTK_GRID (se), 2); pika_size_entry_add_field (PIKA_SIZE_ENTRY (se), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_grid_attach (GTK_GRID (se), spinbutton, 1, 0, 1, 1); gtk_widget_show (spinbutton); gtk_grid_attach (GTK_GRID (grid), se, 1, row, 1, 2); gtk_widget_show (se); pika_size_entry_set_unit (PIKA_SIZE_ENTRY (se), shell->unit); pika_size_entry_set_resolution (PIKA_SIZE_ENTRY (se), 0, xres, FALSE); pika_size_entry_set_resolution (PIKA_SIZE_ENTRY (se), 1, yres, FALSE); pika_size_entry_set_refval_boundaries (PIKA_SIZE_ENTRY (se), 0, -PIKA_MAX_IMAGE_SIZE, PIKA_MAX_IMAGE_SIZE); pika_size_entry_set_refval_boundaries (PIKA_SIZE_ENTRY (se), 1, -PIKA_MAX_IMAGE_SIZE, PIKA_MAX_IMAGE_SIZE); pika_size_entry_set_size (PIKA_SIZE_ENTRY (se), 0, 0, pika_image_get_width (image)); pika_size_entry_set_size (PIKA_SIZE_ENTRY (se), 1, 0, pika_image_get_height (image)); g_signal_connect (se, "value-changed", G_CALLBACK (pika_gradient_tool_editor_endpoint_se_value_changed), gradient_tool); row += 2; /* the color label */ label = gtk_label_new (_("Color:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), label, 0, row, 1, 1); gtk_widget_show (label); /* the color entry */ hbox = pika_gradient_tool_editor_color_entry_new ( gradient_tool, _("Change Endpoint Color"), DIRECTION_NONE, NULL, &gradient_tool->endpoint_color_panel, &gradient_tool->endpoint_type_combo); gtk_grid_attach (GTK_GRID (grid), hbox, 1, row, 1, 1); gtk_widget_show (hbox); row++; } static void pika_gradient_tool_editor_init_stop_gui (PikaGradientTool *gradient_tool) { GtkWidget *editor; GtkWidget *grid; GtkWidget *label; GtkWidget *se; GtkWidget *grid2; GtkWidget *button; GtkWidget *hbox; GtkWidget *separator; gint row = 0; /* the stop editor */ gradient_tool->stop_editor = editor = pika_editor_new (); gtk_box_pack_start (GTK_BOX (pika_tool_gui_get_vbox (gradient_tool->gui)), editor, FALSE, TRUE, 0); /* the main grid */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 4); gtk_grid_set_column_spacing (GTK_GRID (grid), 4); gtk_box_pack_start (GTK_BOX (editor), grid, FALSE, TRUE, 0); gtk_widget_show (grid); /* the position label */ label = gtk_label_new (_("Position:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), label, 0, row, 1, 1); gtk_widget_show (label); /* the position size entry */ gradient_tool->stop_se = se = pika_size_entry_new (1, PIKA_UNIT_PERCENT, "%a", FALSE, TRUE, FALSE, 6, PIKA_SIZE_ENTRY_UPDATE_SIZE); pika_size_entry_show_unit_menu (PIKA_SIZE_ENTRY (se), FALSE); gtk_grid_attach (GTK_GRID (grid), se, 1, row, 1, 1); gtk_widget_show (se); g_signal_connect (se, "value-changed", G_CALLBACK (pika_gradient_tool_editor_stop_se_value_changed), gradient_tool); row++; /* the color labels */ label = gtk_label_new (_("Left color:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), label, 0, row, 1, 1); gtk_widget_show (label); label = gtk_label_new (_("Right color:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), label, 0, row + 1, 1, 1); gtk_widget_show (label); /* the color entries grid */ grid2 = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid2), 4); gtk_grid_set_column_spacing (GTK_GRID (grid2), 2); gtk_grid_attach (GTK_GRID (grid), grid2, 1, row, 1, 2); gtk_widget_show (grid2); /* the color entries chain button */ gradient_tool->stop_chain_button = button = pika_chain_button_new (PIKA_CHAIN_RIGHT); gtk_grid_attach (GTK_GRID (grid2), button, 1, 0, 1, 2); gtk_widget_show (button); /* the color entries */ hbox = pika_gradient_tool_editor_color_entry_new ( gradient_tool, _("Change Stop Color"), DIRECTION_LEFT, button, &gradient_tool->stop_left_color_panel, &gradient_tool->stop_left_type_combo); gtk_grid_attach (GTK_GRID (grid2), hbox, 0, 0, 1, 1); gtk_widget_show (hbox); hbox = pika_gradient_tool_editor_color_entry_new ( gradient_tool, _("Change Stop Color"), DIRECTION_RIGHT, button, &gradient_tool->stop_right_color_panel, &gradient_tool->stop_right_type_combo); gtk_grid_attach (GTK_GRID (grid2), hbox, 0, 1, 1, 1); gtk_widget_show (hbox); row += 2; /* the action buttons separator */ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); gtk_grid_attach (GTK_GRID (grid), separator, 0, row, 2, 1); gtk_widget_show (separator); row++; /* the delete button */ pika_editor_add_button (PIKA_EDITOR (editor), PIKA_ICON_EDIT_DELETE, _("Delete stop"), NULL, G_CALLBACK (pika_gradient_tool_editor_stop_delete_clicked), NULL, G_OBJECT (gradient_tool)); } static void pika_gradient_tool_editor_init_midpoint_gui (PikaGradientTool *gradient_tool) { GtkWidget *editor; GtkWidget *grid; GtkWidget *label; GtkWidget *se; GtkWidget *combo; GtkWidget *separator; gint row = 0; /* the stop editor */ gradient_tool->midpoint_editor = editor = pika_editor_new (); gtk_box_pack_start (GTK_BOX (pika_tool_gui_get_vbox (gradient_tool->gui)), editor, FALSE, TRUE, 0); /* the main grid */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 4); gtk_grid_set_column_spacing (GTK_GRID (grid), 4); gtk_box_pack_start (GTK_BOX (editor), grid, FALSE, TRUE, 0); gtk_widget_show (grid); /* the position label */ label = gtk_label_new (_("Position:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), label, 0, row, 1, 1); gtk_widget_show (label); /* the position size entry */ gradient_tool->midpoint_se = se = pika_size_entry_new (1, PIKA_UNIT_PERCENT, "%a", FALSE, TRUE, FALSE, 6, PIKA_SIZE_ENTRY_UPDATE_SIZE); pika_size_entry_show_unit_menu (PIKA_SIZE_ENTRY (se), FALSE); gtk_grid_attach (GTK_GRID (grid), se, 1, row, 1, 1); gtk_widget_show (se); g_signal_connect (se, "value-changed", G_CALLBACK (pika_gradient_tool_editor_midpoint_se_value_changed), gradient_tool); row++; /* the type label */ label = gtk_label_new (_("Blending:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), label, 0, row, 1, 1); gtk_widget_show (label); /* the type combo */ gradient_tool->midpoint_type_combo = combo = pika_enum_combo_box_new (PIKA_TYPE_GRADIENT_SEGMENT_TYPE); gtk_grid_attach (GTK_GRID (grid), combo, 1, row, 1, 1); gtk_widget_show (combo); g_signal_connect (combo, "changed", G_CALLBACK (pika_gradient_tool_editor_midpoint_type_changed), gradient_tool); row++; /* the color label */ label = gtk_label_new (_("Coloring:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_grid_attach (GTK_GRID (grid), label, 0, row, 1, 1); gtk_widget_show (label); /* the color combo */ gradient_tool->midpoint_color_combo = combo = pika_enum_combo_box_new (PIKA_TYPE_GRADIENT_SEGMENT_COLOR); gtk_grid_attach (GTK_GRID (grid), combo, 1, row, 1, 1); gtk_widget_show (combo); g_signal_connect (combo, "changed", G_CALLBACK (pika_gradient_tool_editor_midpoint_color_changed), gradient_tool); row++; /* the action buttons separator */ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); gtk_grid_attach (GTK_GRID (grid), separator, 0, row, 2, 1); gtk_widget_show (separator); row++; /* the new stop button */ gradient_tool->midpoint_new_stop_button = pika_editor_add_button (PIKA_EDITOR (editor), PIKA_ICON_DOCUMENT_NEW, _("New stop at midpoint"), NULL, G_CALLBACK (pika_gradient_tool_editor_midpoint_new_stop_clicked), NULL, G_OBJECT (gradient_tool)); /* the center button */ gradient_tool->midpoint_center_button = pika_editor_add_button (PIKA_EDITOR (editor), PIKA_ICON_CENTER_HORIZONTAL, _("Center midpoint"), NULL, G_CALLBACK (pika_gradient_tool_editor_midpoint_center_clicked), NULL, G_OBJECT (gradient_tool)); } static void pika_gradient_tool_editor_update_endpoint_gui (PikaGradientTool *gradient_tool, gint selection) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaPaintOptions *paint_options = PIKA_PAINT_OPTIONS (options); PikaContext *context = PIKA_CONTEXT (options); gboolean editable; PikaGradientSegment *seg; const gchar *title; gdouble x; gdouble y; PikaRGB color; PikaGradientColor color_type; editable = pika_gradient_tool_editor_is_gradient_editable (gradient_tool); switch (selection) { case PIKA_TOOL_LINE_HANDLE_START: g_object_get (gradient_tool->widget, "x1", &x, "y1", &y, NULL); break; case PIKA_TOOL_LINE_HANDLE_END: g_object_get (gradient_tool->widget, "x2", &x, "y2", &y, NULL); break; default: pika_assert_not_reached (); } /* swap the endpoint handles, if necessary */ if (paint_options->gradient_options->gradient_reverse) { switch (selection) { case PIKA_TOOL_LINE_HANDLE_START: selection = PIKA_TOOL_LINE_HANDLE_END; break; case PIKA_TOOL_LINE_HANDLE_END: selection = PIKA_TOOL_LINE_HANDLE_START; break; } } seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); switch (selection) { case PIKA_TOOL_LINE_HANDLE_START: title = _("Start Endpoint"); pika_gradient_segment_get_left_flat_color (gradient_tool->gradient, context, seg, &color); color_type = seg->left_color_type; break; case PIKA_TOOL_LINE_HANDLE_END: title = _("End Endpoint"); pika_gradient_segment_get_right_flat_color (gradient_tool->gradient, context, seg, &color); color_type = seg->right_color_type; break; default: pika_assert_not_reached (); } pika_tool_gui_set_title (gradient_tool->gui, title); pika_size_entry_set_refval (PIKA_SIZE_ENTRY (gradient_tool->endpoint_se), 0, x); pika_size_entry_set_refval (PIKA_SIZE_ENTRY (gradient_tool->endpoint_se), 1, y); pika_color_button_set_color ( PIKA_COLOR_BUTTON (gradient_tool->endpoint_color_panel), &color); pika_int_combo_box_set_active ( PIKA_INT_COMBO_BOX (gradient_tool->endpoint_type_combo), color_type); gtk_widget_set_sensitive (gradient_tool->endpoint_color_panel, editable); gtk_widget_set_sensitive (gradient_tool->endpoint_type_combo, editable); gtk_widget_show (gradient_tool->endpoint_editor); } static void pika_gradient_tool_editor_update_stop_gui (PikaGradientTool *gradient_tool, gint selection) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaContext *context = PIKA_CONTEXT (options); gboolean editable; PikaGradientSegment *seg; gint index; gchar *title; gdouble min; gdouble max; gdouble value; PikaRGB left_color; PikaGradientColor left_color_type; PikaRGB right_color; PikaGradientColor right_color_type; editable = pika_gradient_tool_editor_is_gradient_editable (gradient_tool); seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); index = GPOINTER_TO_INT ( pika_tool_line_get_sliders (PIKA_TOOL_LINE (gradient_tool->widget), NULL)[selection].data); title = g_strdup_printf (_("Stop %d"), index + 1); min = seg->left; max = seg->next->right; value = seg->right; pika_gradient_segment_get_right_flat_color (gradient_tool->gradient, context, seg, &left_color); left_color_type = seg->right_color_type; pika_gradient_segment_get_left_flat_color (gradient_tool->gradient, context, seg->next, &right_color); right_color_type = seg->next->left_color_type; pika_tool_gui_set_title (gradient_tool->gui, title); pika_size_entry_set_refval_boundaries (PIKA_SIZE_ENTRY (gradient_tool->stop_se), 0, 100.0 * min, 100.0 * max); pika_size_entry_set_refval (PIKA_SIZE_ENTRY (gradient_tool->stop_se), 0, 100.0 * value); pika_color_button_set_color ( PIKA_COLOR_BUTTON (gradient_tool->stop_left_color_panel), &left_color); pika_int_combo_box_set_active ( PIKA_INT_COMBO_BOX (gradient_tool->stop_left_type_combo), left_color_type); pika_color_button_set_color ( PIKA_COLOR_BUTTON (gradient_tool->stop_right_color_panel), &right_color); pika_int_combo_box_set_active ( PIKA_INT_COMBO_BOX (gradient_tool->stop_right_type_combo), right_color_type); gtk_widget_set_sensitive (gradient_tool->stop_se, editable); gtk_widget_set_sensitive (gradient_tool->stop_left_color_panel, editable); gtk_widget_set_sensitive (gradient_tool->stop_left_type_combo, editable); gtk_widget_set_sensitive (gradient_tool->stop_right_color_panel, editable); gtk_widget_set_sensitive (gradient_tool->stop_right_type_combo, editable); gtk_widget_set_sensitive (gradient_tool->stop_chain_button, editable); gtk_widget_set_sensitive ( GTK_WIDGET (pika_editor_get_button_box (PIKA_EDITOR (gradient_tool->stop_editor))), editable); g_free (title); gtk_widget_show (gradient_tool->stop_editor); } static void pika_gradient_tool_editor_update_midpoint_gui (PikaGradientTool *gradient_tool, gint selection) { gboolean editable; const PikaGradientSegment *seg; gint index; gchar *title; gdouble min; gdouble max; gdouble value; PikaGradientSegmentType type; PikaGradientSegmentColor color; editable = pika_gradient_tool_editor_is_gradient_editable (gradient_tool); seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, selection); index = GPOINTER_TO_INT ( pika_tool_line_get_sliders (PIKA_TOOL_LINE (gradient_tool->widget), NULL)[selection].data); title = g_strdup_printf (_("Midpoint %d"), index + 1); min = seg->left; max = seg->right; value = seg->middle; type = seg->type; color = seg->color; pika_tool_gui_set_title (gradient_tool->gui, title); pika_size_entry_set_refval_boundaries (PIKA_SIZE_ENTRY (gradient_tool->midpoint_se), 0, 100.0 * min, 100.0 * max); pika_size_entry_set_refval (PIKA_SIZE_ENTRY (gradient_tool->midpoint_se), 0, 100.0 * value); pika_int_combo_box_set_active ( PIKA_INT_COMBO_BOX (gradient_tool->midpoint_type_combo), type); pika_int_combo_box_set_active ( PIKA_INT_COMBO_BOX (gradient_tool->midpoint_color_combo), color); gtk_widget_set_sensitive (gradient_tool->midpoint_new_stop_button, value > min + EPSILON && value < max - EPSILON); gtk_widget_set_sensitive (gradient_tool->midpoint_center_button, fabs (value - (min + max) / 2.0) > EPSILON); gtk_widget_set_sensitive (gradient_tool->midpoint_se, editable); gtk_widget_set_sensitive (gradient_tool->midpoint_type_combo, editable); gtk_widget_set_sensitive (gradient_tool->midpoint_color_combo, editable); gtk_widget_set_sensitive ( GTK_WIDGET (pika_editor_get_button_box (PIKA_EDITOR (gradient_tool->midpoint_editor))), editable); g_free (title); gtk_widget_show (gradient_tool->midpoint_editor); } static void pika_gradient_tool_editor_update_gui (PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); if (gradient_tool->gradient && gradient_tool->widget && ! options->instant) { gint selection; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); if (selection != PIKA_TOOL_LINE_HANDLE_NONE) { if (! gradient_tool->gui) { PikaDisplayShell *shell; shell = pika_tool_widget_get_shell (gradient_tool->widget); gradient_tool->gui = pika_tool_gui_new (PIKA_TOOL (gradient_tool)->tool_info, NULL, NULL, NULL, NULL, pika_widget_get_monitor (GTK_WIDGET (shell)), TRUE, _("_Close"), GTK_RESPONSE_CLOSE, NULL); pika_tool_gui_set_shell (gradient_tool->gui, shell); pika_tool_gui_set_viewable (gradient_tool->gui, PIKA_VIEWABLE (gradient_tool->gradient)); pika_tool_gui_set_auto_overlay (gradient_tool->gui, TRUE); g_signal_connect (gradient_tool->gui, "response", G_CALLBACK (pika_gradient_tool_editor_gui_response), gradient_tool); pika_gradient_tool_editor_init_endpoint_gui (gradient_tool); pika_gradient_tool_editor_init_stop_gui (gradient_tool); pika_gradient_tool_editor_init_midpoint_gui (gradient_tool); } pika_gradient_tool_editor_block_handlers (gradient_tool); if (pika_gradient_tool_editor_handle_is_endpoint (gradient_tool, selection)) pika_gradient_tool_editor_update_endpoint_gui (gradient_tool, selection); else gtk_widget_hide (gradient_tool->endpoint_editor); if (pika_gradient_tool_editor_handle_is_stop (gradient_tool, selection)) pika_gradient_tool_editor_update_stop_gui (gradient_tool, selection); else gtk_widget_hide (gradient_tool->stop_editor); if (pika_gradient_tool_editor_handle_is_midpoint (gradient_tool, selection)) pika_gradient_tool_editor_update_midpoint_gui (gradient_tool, selection); else gtk_widget_hide (gradient_tool->midpoint_editor); pika_gradient_tool_editor_unblock_handlers (gradient_tool); pika_tool_gui_show (gradient_tool->gui); return; } } if (gradient_tool->gui) pika_tool_gui_hide (gradient_tool->gui); } static GradientInfo * pika_gradient_tool_editor_gradient_info_new (PikaGradientTool *gradient_tool) { GradientInfo *info = g_slice_new (GradientInfo); info->start_x = gradient_tool->start_x; info->start_y = gradient_tool->start_y; info->end_x = gradient_tool->end_x; info->end_y = gradient_tool->end_y; info->gradient = NULL; info->added_handle = PIKA_TOOL_LINE_HANDLE_NONE; info->removed_handle = PIKA_TOOL_LINE_HANDLE_NONE; info->selected_handle = PIKA_TOOL_LINE_HANDLE_NONE; return info; } static void pika_gradient_tool_editor_gradient_info_free (GradientInfo *info) { if (info->gradient) g_object_unref (info->gradient); g_slice_free (GradientInfo, info); } static void pika_gradient_tool_editor_gradient_info_apply (PikaGradientTool *gradient_tool, const GradientInfo *info, gboolean set_selection) { gint selection; pika_assert (gradient_tool->widget != NULL); pika_assert (gradient_tool->gradient != NULL); /* pick the handle to select */ if (info->gradient) { if (info->removed_handle != PIKA_TOOL_LINE_HANDLE_NONE) { /* we're undoing a stop-deletion or midpoint-to-stop operation; * select the removed handle */ selection = info->removed_handle; } else if (info->added_handle != PIKA_TOOL_LINE_HANDLE_NONE) { /* we're undoing a stop addition operation */ pika_assert (pika_gradient_tool_editor_handle_is_stop (gradient_tool, info->added_handle)); selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); /* if the selected handle is a stop... */ if (pika_gradient_tool_editor_handle_is_stop (gradient_tool, selection)) { /* if the added handle is selected, clear the selection */ if (selection == info->added_handle) selection = PIKA_TOOL_LINE_HANDLE_NONE; /* otherwise, keep the currently selected stop, possibly * adjusting its handle index */ else if (selection > info->added_handle) selection--; } /* otherwise, if the selected handle is a midpoint... */ else if (pika_gradient_tool_editor_handle_is_midpoint (gradient_tool, selection)) { const PikaControllerSlider *sliders; gint seg_i; sliders = pika_tool_line_get_sliders (PIKA_TOOL_LINE (gradient_tool->widget), NULL); seg_i = GPOINTER_TO_INT (sliders[selection].data); /* if the midpoint belongs to one of the two segments incident to * the added stop, clear the selection */ if (seg_i == info->added_handle || seg_i == info->added_handle + 1) { selection = PIKA_TOOL_LINE_HANDLE_NONE; } /* otherwise, keep the currently selected stop, adjusting its * handle index */ else { /* midpoint handles follow stop handles; since we removed a * stop, we must decrement the handle index */ selection--; if (seg_i > info->added_handle) selection--; } } /* otherwise, don't change the selection */ else { set_selection = FALSE; } } else if (info->selected_handle != PIKA_TOOL_LINE_HANDLE_NONE) { /* we're undoing a property change operation; select the handle * corresponding to the affected object */ selection = info->selected_handle; } else { /* something went wrong... */ g_warn_if_reached (); set_selection = FALSE; } } else if ((info->start_x != gradient_tool->start_x || info->start_y != gradient_tool->start_y) && (info->end_x == gradient_tool->end_x && info->end_y == gradient_tool->end_y)) { /* we're undoing a start-endpoint move operation; select the start * endpoint */ selection = PIKA_TOOL_LINE_HANDLE_START; } else if ((info->end_x != gradient_tool->end_x || info->end_y != gradient_tool->end_y) && (info->start_x == gradient_tool->start_x && info->start_y == gradient_tool->start_y)) { /* we're undoing am end-endpoint move operation; select the end * endpoint */ selection = PIKA_TOOL_LINE_HANDLE_END; } else { /* we're undoing a line move operation; don't change the selection */ set_selection = FALSE; } pika_gradient_tool_editor_block_handlers (gradient_tool); g_object_set (gradient_tool->widget, "x1", info->start_x, "y1", info->start_y, "x2", info->end_x, "y2", info->end_y, NULL); if (info->gradient) { pika_gradient_tool_editor_freeze_gradient (gradient_tool); pika_data_copy (PIKA_DATA (gradient_tool->gradient), PIKA_DATA (info->gradient)); pika_gradient_tool_editor_thaw_gradient (gradient_tool); } if (set_selection) { pika_tool_line_set_selection (PIKA_TOOL_LINE (gradient_tool->widget), selection); } pika_gradient_tool_editor_update_gui (gradient_tool); pika_gradient_tool_editor_unblock_handlers (gradient_tool); } static gboolean pika_gradient_tool_editor_gradient_info_is_trivial (PikaGradientTool *gradient_tool, const GradientInfo *info) { const PikaGradientSegment *seg1; const PikaGradientSegment *seg2; if (info->start_x != gradient_tool->start_x || info->start_y != gradient_tool->start_y || info->end_x != gradient_tool->end_x || info->end_y != gradient_tool->end_y) { return FALSE; } if (info->gradient) { for (seg1 = info->gradient->segments, seg2 = gradient_tool->gradient->segments; seg1 && seg2; seg1 = seg1->next, seg2 = seg2->next) { if (memcmp (seg1, seg2, G_STRUCT_OFFSET (PikaGradientSegment, prev))) return FALSE; } if (seg1 || seg2) return FALSE; } return TRUE; } /* public functions */ void pika_gradient_tool_editor_options_notify (PikaGradientTool *gradient_tool, PikaToolOptions *options, const GParamSpec *pspec) { if (! strcmp (pspec->name, "modify-active")) { pika_gradient_tool_editor_update_sliders (gradient_tool); pika_gradient_tool_editor_update_gui (gradient_tool); } else if (! strcmp (pspec->name, "gradient-reverse")) { pika_gradient_tool_editor_update_sliders (gradient_tool); /* if an endpoint is selected, swap the selected endpoint */ if (gradient_tool->widget) { gint selection; selection = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); switch (selection) { case PIKA_TOOL_LINE_HANDLE_START: pika_tool_line_set_selection (PIKA_TOOL_LINE (gradient_tool->widget), PIKA_TOOL_LINE_HANDLE_END); break; case PIKA_TOOL_LINE_HANDLE_END: pika_tool_line_set_selection (PIKA_TOOL_LINE (gradient_tool->widget), PIKA_TOOL_LINE_HANDLE_START); break; } } } else if (gradient_tool->render_node && gegl_node_find_property (gradient_tool->render_node, pspec->name)) { pika_gradient_tool_editor_update_sliders (gradient_tool); } } void pika_gradient_tool_editor_start (PikaGradientTool *gradient_tool) { g_signal_connect (gradient_tool->widget, "can-add-slider", G_CALLBACK (pika_gradient_tool_editor_line_can_add_slider), gradient_tool); g_signal_connect (gradient_tool->widget, "add-slider", G_CALLBACK (pika_gradient_tool_editor_line_add_slider), gradient_tool); g_signal_connect (gradient_tool->widget, "prepare-to-remove-slider", G_CALLBACK (pika_gradient_tool_editor_line_prepare_to_remove_slider), gradient_tool); g_signal_connect (gradient_tool->widget, "remove-slider", G_CALLBACK (pika_gradient_tool_editor_line_remove_slider), gradient_tool); g_signal_connect (gradient_tool->widget, "selection-changed", G_CALLBACK (pika_gradient_tool_editor_line_selection_changed), gradient_tool); g_signal_connect (gradient_tool->widget, "handle-clicked", G_CALLBACK (pika_gradient_tool_editor_line_handle_clicked), gradient_tool); } void pika_gradient_tool_editor_halt (PikaGradientTool *gradient_tool) { g_clear_object (&gradient_tool->gui); gradient_tool->edit_count = 0; if (gradient_tool->undo_stack) { g_slist_free_full (gradient_tool->undo_stack, (GDestroyNotify) pika_gradient_tool_editor_gradient_info_free); gradient_tool->undo_stack = NULL; } if (gradient_tool->redo_stack) { g_slist_free_full (gradient_tool->redo_stack, (GDestroyNotify) pika_gradient_tool_editor_gradient_info_free); gradient_tool->redo_stack = NULL; } if (gradient_tool->flush_idle_id) { g_source_remove (gradient_tool->flush_idle_id); gradient_tool->flush_idle_id = 0; } } gboolean pika_gradient_tool_editor_line_changed (PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaPaintOptions *paint_options = PIKA_PAINT_OPTIONS (options); gdouble offset = options->offset / 100.0; const PikaControllerSlider *sliders; gint n_sliders; gint i; PikaGradientSegment *seg; gboolean changed = FALSE; if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return FALSE; if (! gradient_tool->gradient || offset == 1.0) return FALSE; sliders = pika_tool_line_get_sliders (PIKA_TOOL_LINE (gradient_tool->widget), &n_sliders); if (n_sliders == 0) return FALSE; /* update the midpoints first, since moving the gradient stops may change the * gradient's midpoints w.r.t. the sliders, but not the other way around. */ for (seg = gradient_tool->gradient->segments, i = n_sliders / 2; seg; seg = seg->next, i++) { gdouble value; value = sliders[i].value; /* adjust slider value according to the offset */ value = (value - offset) / (1.0 - offset); /* flip the slider value, if necessary */ if (paint_options->gradient_options->gradient_reverse) value = 1.0 - value; if (fabs (value - seg->middle) > EPSILON) { if (! changed) { pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); /* refetch the segment, since the gradient might have changed */ seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, i); changed = TRUE; } seg->middle = value; } } /* update the gradient stops */ for (seg = gradient_tool->gradient->segments, i = 0; seg->next; seg = seg->next, i++) { gdouble value; value = sliders[i].value; /* adjust slider value according to the offset */ value = (value - offset) / (1.0 - offset); /* flip the slider value, if necessary */ if (paint_options->gradient_options->gradient_reverse) value = 1.0 - value; if (fabs (value - seg->right) > EPSILON) { if (! changed) { pika_gradient_tool_editor_start_edit (gradient_tool); pika_gradient_tool_editor_freeze_gradient (gradient_tool); /* refetch the segment, since the gradient might have changed */ seg = pika_gradient_tool_editor_handle_get_segment (gradient_tool, i); changed = TRUE; } pika_gradient_segment_range_compress (gradient_tool->gradient, seg, seg, seg->left, value); pika_gradient_segment_range_compress (gradient_tool->gradient, seg->next, seg->next, value, seg->next->right); } } if (changed) { pika_gradient_tool_editor_thaw_gradient (gradient_tool); pika_gradient_tool_editor_end_edit (gradient_tool, FALSE); } pika_gradient_tool_editor_update_gui (gradient_tool); return changed; } void pika_gradient_tool_editor_fg_bg_changed (PikaGradientTool *gradient_tool) { pika_gradient_tool_editor_update_gui (gradient_tool); } void pika_gradient_tool_editor_gradient_dirty (PikaGradientTool *gradient_tool) { if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return; pika_gradient_tool_editor_purge_gradient (gradient_tool); } void pika_gradient_tool_editor_gradient_changed (PikaGradientTool *gradient_tool) { PikaGradientOptions *options = PIKA_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); PikaContext *context = PIKA_CONTEXT (options); if (options->modify_active_frame) { gtk_widget_set_sensitive (options->modify_active_frame, gradient_tool->gradient != pika_gradients_get_custom (context->pika)); } if (options->modify_active_hint) { gtk_widget_set_visible (options->modify_active_hint, gradient_tool->gradient && ! pika_data_is_writable (PIKA_DATA (gradient_tool->gradient))); } if (pika_gradient_tool_editor_are_handlers_blocked (gradient_tool)) return; pika_gradient_tool_editor_purge_gradient (gradient_tool); } const gchar * pika_gradient_tool_editor_can_undo (PikaGradientTool *gradient_tool) { if (! gradient_tool->undo_stack || gradient_tool->edit_count > 0) return NULL; return _("Gradient Step"); } const gchar * pika_gradient_tool_editor_can_redo (PikaGradientTool *gradient_tool) { if (! gradient_tool->redo_stack || gradient_tool->edit_count > 0) return NULL; return _("Gradient Step"); } gboolean pika_gradient_tool_editor_undo (PikaGradientTool *gradient_tool) { PikaTool *tool = PIKA_TOOL (gradient_tool); GradientInfo *info; GradientInfo *new_info; pika_assert (gradient_tool->undo_stack != NULL); pika_assert (gradient_tool->edit_count == 0); info = gradient_tool->undo_stack->data; new_info = pika_gradient_tool_editor_gradient_info_new (gradient_tool); if (info->gradient) { new_info->gradient = PIKA_GRADIENT (pika_data_duplicate (PIKA_DATA (gradient_tool->gradient))); /* swap the added and removed handles, so that gradient_info_apply() does * the right thing on redo */ new_info->added_handle = info->removed_handle; new_info->removed_handle = info->added_handle; new_info->selected_handle = info->selected_handle; } gradient_tool->undo_stack = g_slist_remove (gradient_tool->undo_stack, info); gradient_tool->redo_stack = g_slist_prepend (gradient_tool->redo_stack, new_info); pika_gradient_tool_editor_gradient_info_apply (gradient_tool, info, TRUE); pika_gradient_tool_editor_gradient_info_free (info); /* the initial state of the gradient tool is not useful; we might as well halt */ if (! gradient_tool->undo_stack) pika_tool_control (tool, PIKA_TOOL_ACTION_HALT, tool->display); return TRUE; } gboolean pika_gradient_tool_editor_redo (PikaGradientTool *gradient_tool) { GradientInfo *info; GradientInfo *new_info; pika_assert (gradient_tool->redo_stack != NULL); pika_assert (gradient_tool->edit_count == 0); info = gradient_tool->redo_stack->data; new_info = pika_gradient_tool_editor_gradient_info_new (gradient_tool); if (info->gradient) { new_info->gradient = PIKA_GRADIENT (pika_data_duplicate (PIKA_DATA (gradient_tool->gradient))); /* swap the added and removed handles, so that gradient_info_apply() does * the right thing on undo */ new_info->added_handle = info->removed_handle; new_info->removed_handle = info->added_handle; new_info->selected_handle = info->selected_handle; } gradient_tool->redo_stack = g_slist_remove (gradient_tool->redo_stack, info); gradient_tool->undo_stack = g_slist_prepend (gradient_tool->undo_stack, new_info); pika_gradient_tool_editor_gradient_info_apply (gradient_tool, info, TRUE); pika_gradient_tool_editor_gradient_info_free (info); return TRUE; } void pika_gradient_tool_editor_start_edit (PikaGradientTool *gradient_tool) { if (gradient_tool->edit_count++ == 0) { GradientInfo *info; info = pika_gradient_tool_editor_gradient_info_new (gradient_tool); gradient_tool->undo_stack = g_slist_prepend (gradient_tool->undo_stack, info); /* update the undo actions / menu items */ if (! gradient_tool->flush_idle_id) { gradient_tool->flush_idle_id = g_idle_add ((GSourceFunc) pika_gradient_tool_editor_flush_idle, gradient_tool); } } } void pika_gradient_tool_editor_end_edit (PikaGradientTool *gradient_tool, gboolean cancel) { /* can happen when halting using esc */ if (gradient_tool->edit_count == 0) return; if (--gradient_tool->edit_count == 0) { GradientInfo *info = gradient_tool->undo_stack->data; info->selected_handle = pika_tool_line_get_selection (PIKA_TOOL_LINE (gradient_tool->widget)); if (cancel || pika_gradient_tool_editor_gradient_info_is_trivial (gradient_tool, info)) { /* if the edit is canceled, or if nothing changed, undo the last * step */ pika_gradient_tool_editor_gradient_info_apply (gradient_tool, info, FALSE); gradient_tool->undo_stack = g_slist_remove (gradient_tool->undo_stack, info); pika_gradient_tool_editor_gradient_info_free (info); } else { /* otherwise, blow the redo stack */ g_slist_free_full (gradient_tool->redo_stack, (GDestroyNotify) pika_gradient_tool_editor_gradient_info_free); gradient_tool->redo_stack = NULL; } /* update the undo actions / menu items */ if (! gradient_tool->flush_idle_id) { gradient_tool->flush_idle_id = g_idle_add ((GSourceFunc) pika_gradient_tool_editor_flush_idle, gradient_tool); } } }