diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 03:13:10 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 03:13:10 +0000 |
commit | 3c57dd931145d43f2b0aef96c4d178135956bf91 (patch) | |
tree | 3de698981e9f0cc2c4f9569b19a5f3595e741f6b /app/tools/gimppainttool.c | |
parent | Initial commit. (diff) | |
download | gimp-3c57dd931145d43f2b0aef96c4d178135956bf91.tar.xz gimp-3c57dd931145d43f2b0aef96c4d178135956bf91.zip |
Adding upstream version 2.10.36.upstream/2.10.36
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'app/tools/gimppainttool.c')
-rw-r--r-- | app/tools/gimppainttool.c | 991 |
1 files changed, 991 insertions, 0 deletions
diff --git a/app/tools/gimppainttool.c b/app/tools/gimppainttool.c new file mode 100644 index 0000000..48eb215 --- /dev/null +++ b/app/tools/gimppainttool.c @@ -0,0 +1,991 @@ +/* GIMP - The GNU Image Manipulation Program + * 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 <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <gegl.h> +#include <gtk/gtk.h> + +#include "libgimpbase/gimpbase.h" +#include "libgimpmath/gimpmath.h" + +#include "tools-types.h" + +#include "config/gimpdisplayconfig.h" +#include "config/gimpguiconfig.h" + +#include "core/gimp.h" +#include "core/gimp-utils.h" +#include "core/gimpdrawable.h" +#include "core/gimperror.h" +#include "core/gimpimage.h" +#include "core/gimplayer.h" +#include "core/gimppaintinfo.h" +#include "core/gimpprojection.h" +#include "core/gimptoolinfo.h" + +#include "paint/gimppaintcore.h" +#include "paint/gimppaintoptions.h" + +#include "widgets/gimpdevices.h" +#include "widgets/gimpwidgets-utils.h" + +#include "display/gimpdisplay.h" +#include "display/gimpdisplayshell.h" +#include "display/gimpdisplayshell-selection.h" +#include "display/gimpdisplayshell-utils.h" + +#include "gimpcoloroptions.h" +#include "gimppaintoptions-gui.h" +#include "gimppainttool.h" +#include "gimppainttool-paint.h" +#include "gimptoolcontrol.h" +#include "gimptools-utils.h" + +#include "gimp-intl.h" + + +static void gimp_paint_tool_constructed (GObject *object); +static void gimp_paint_tool_finalize (GObject *object); + +static void gimp_paint_tool_control (GimpTool *tool, + GimpToolAction action, + GimpDisplay *display); +static void gimp_paint_tool_button_press (GimpTool *tool, + const GimpCoords *coords, + guint32 time, + GdkModifierType state, + GimpButtonPressType press_type, + GimpDisplay *display); +static void gimp_paint_tool_button_release (GimpTool *tool, + const GimpCoords *coords, + guint32 time, + GdkModifierType state, + GimpButtonReleaseType release_type, + GimpDisplay *display); +static void gimp_paint_tool_motion (GimpTool *tool, + const GimpCoords *coords, + guint32 time, + GdkModifierType state, + GimpDisplay *display); +static void gimp_paint_tool_modifier_key (GimpTool *tool, + GdkModifierType key, + gboolean press, + GdkModifierType state, + GimpDisplay *display); +static void gimp_paint_tool_cursor_update (GimpTool *tool, + const GimpCoords *coords, + GdkModifierType state, + GimpDisplay *display); +static void gimp_paint_tool_oper_update (GimpTool *tool, + const GimpCoords *coords, + GdkModifierType state, + gboolean proximity, + GimpDisplay *display); + +static void gimp_paint_tool_draw (GimpDrawTool *draw_tool); + +static void + gimp_paint_tool_real_paint_prepare (GimpPaintTool *paint_tool, + GimpDisplay *display); + +static GimpCanvasItem * + gimp_paint_tool_get_outline (GimpPaintTool *paint_tool, + GimpDisplay *display, + gdouble x, + gdouble y); + +static gboolean gimp_paint_tool_check_alpha (GimpPaintTool *paint_tool, + GimpDrawable *drawable, + GimpDisplay *display, + GError **error); + +static void gimp_paint_tool_hard_notify (GimpPaintOptions *options, + const GParamSpec *pspec, + GimpPaintTool *paint_tool); +static void gimp_paint_tool_cursor_notify (GimpDisplayConfig *config, + GParamSpec *pspec, + GimpPaintTool *paint_tool); + + +G_DEFINE_TYPE (GimpPaintTool, gimp_paint_tool, GIMP_TYPE_COLOR_TOOL) + +#define parent_class gimp_paint_tool_parent_class + + +static void +gimp_paint_tool_class_init (GimpPaintToolClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass); + GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass); + + object_class->constructed = gimp_paint_tool_constructed; + object_class->finalize = gimp_paint_tool_finalize; + + tool_class->control = gimp_paint_tool_control; + tool_class->button_press = gimp_paint_tool_button_press; + tool_class->button_release = gimp_paint_tool_button_release; + tool_class->motion = gimp_paint_tool_motion; + tool_class->modifier_key = gimp_paint_tool_modifier_key; + tool_class->cursor_update = gimp_paint_tool_cursor_update; + tool_class->oper_update = gimp_paint_tool_oper_update; + + draw_tool_class->draw = gimp_paint_tool_draw; + + klass->paint_prepare = gimp_paint_tool_real_paint_prepare; +} + +static void +gimp_paint_tool_init (GimpPaintTool *paint_tool) +{ + GimpTool *tool = GIMP_TOOL (paint_tool); + + gimp_tool_control_set_motion_mode (tool->control, GIMP_MOTION_MODE_EXACT); + gimp_tool_control_set_scroll_lock (tool->control, TRUE); + gimp_tool_control_set_action_opacity (tool->control, + "context/context-opacity-set"); + + paint_tool->active = TRUE; + paint_tool->pick_colors = FALSE; + paint_tool->draw_line = FALSE; + + paint_tool->show_cursor = TRUE; + paint_tool->draw_brush = TRUE; + paint_tool->snap_brush = FALSE; + paint_tool->draw_fallback = FALSE; + paint_tool->fallback_size = 0.0; + paint_tool->draw_circle = FALSE; + paint_tool->circle_size = 0.0; + + paint_tool->status = _("Click to paint"); + paint_tool->status_line = _("Click to draw the line"); + paint_tool->status_ctrl = _("%s to pick a color"); + + paint_tool->core = NULL; +} + +static void +gimp_paint_tool_constructed (GObject *object) +{ + GimpTool *tool = GIMP_TOOL (object); + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (object); + GimpPaintOptions *options = GIMP_PAINT_TOOL_GET_OPTIONS (tool); + GimpDisplayConfig *display_config; + GimpPaintInfo *paint_info; + + G_OBJECT_CLASS (parent_class)->constructed (object); + + gimp_assert (GIMP_IS_TOOL_INFO (tool->tool_info)); + gimp_assert (GIMP_IS_PAINT_INFO (tool->tool_info->paint_info)); + + display_config = GIMP_DISPLAY_CONFIG (tool->tool_info->gimp->config); + + paint_info = tool->tool_info->paint_info; + + gimp_assert (g_type_is_a (paint_info->paint_type, GIMP_TYPE_PAINT_CORE)); + + paint_tool->core = g_object_new (paint_info->paint_type, + "undo-desc", paint_info->blurb, + NULL); + + g_signal_connect_object (options, "notify::hard", + G_CALLBACK (gimp_paint_tool_hard_notify), + paint_tool, 0); + + gimp_paint_tool_hard_notify (options, NULL, paint_tool); + + paint_tool->show_cursor = display_config->show_paint_tool_cursor; + paint_tool->draw_brush = display_config->show_brush_outline; + paint_tool->snap_brush = display_config->snap_brush_outline; + + g_signal_connect_object (display_config, "notify::show-paint-tool-cursor", + G_CALLBACK (gimp_paint_tool_cursor_notify), + paint_tool, 0); + g_signal_connect_object (display_config, "notify::show-brush-outline", + G_CALLBACK (gimp_paint_tool_cursor_notify), + paint_tool, 0); + g_signal_connect_object (display_config, "notify::snap-brush-outline", + G_CALLBACK (gimp_paint_tool_cursor_notify), + paint_tool, 0); +} + +static void +gimp_paint_tool_finalize (GObject *object) +{ + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (object); + + if (paint_tool->core) + { + g_object_unref (paint_tool->core); + paint_tool->core = NULL; + } + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gimp_paint_tool_control (GimpTool *tool, + GimpToolAction action, + GimpDisplay *display) +{ + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); + + switch (action) + { + case GIMP_TOOL_ACTION_PAUSE: + case GIMP_TOOL_ACTION_RESUME: + break; + + case GIMP_TOOL_ACTION_HALT: + gimp_paint_core_cleanup (paint_tool->core); + break; + + case GIMP_TOOL_ACTION_COMMIT: + break; + } + + GIMP_TOOL_CLASS (parent_class)->control (tool, action, display); +} + +static void +gimp_paint_tool_button_press (GimpTool *tool, + const GimpCoords *coords, + guint32 time, + GdkModifierType state, + GimpButtonPressType press_type, + GimpDisplay *display) +{ + GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); + GimpPaintOptions *options = GIMP_PAINT_TOOL_GET_OPTIONS (tool); + GimpGuiConfig *config = GIMP_GUI_CONFIG (display->gimp->config); + GimpDisplayShell *shell = gimp_display_get_shell (display); + GimpImage *image = gimp_display_get_image (display); + GimpDrawable *drawable = gimp_image_get_active_drawable (image); + gboolean constrain; + GError *error = NULL; + + if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) + { + GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state, + press_type, display); + return; + } + + if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) + { + gimp_tool_message_literal (tool, display, + _("Cannot paint on layer groups.")); + return; + } + + if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) + { + gimp_tool_message_literal (tool, display, + _("The active layer's pixels are locked.")); + gimp_tools_blink_lock_box (display->gimp, GIMP_ITEM (drawable)); + return; + } + + if (! gimp_paint_tool_check_alpha (paint_tool, drawable, display, &error)) + { + GtkWidget *options_gui; + GtkWidget *mode_box; + + gimp_tool_message_literal (tool, display, error->message); + + options_gui = gimp_tools_get_tool_options_gui ( + GIMP_TOOL_OPTIONS (options)); + mode_box = gimp_paint_options_gui_get_paint_mode_box (options_gui); + + if (gtk_widget_is_sensitive (mode_box)) + gimp_widget_blink (mode_box); + + g_clear_error (&error); + + return; + } + + if (! gimp_item_is_visible (GIMP_ITEM (drawable)) && + ! config->edit_non_visible) + { + gimp_tool_message_literal (tool, display, + _("The active layer is not visible.")); + return; + } + + if (gimp_draw_tool_is_active (draw_tool)) + gimp_draw_tool_stop (draw_tool); + + if (tool->display && + tool->display != display && + gimp_display_get_image (tool->display) == image) + { + /* if this is a different display, but the same image, HACK around + * in tool internals AFTER stopping the current draw_tool, so + * straight line drawing works across different views of the + * same image. + */ + + tool->display = display; + } + + constrain = (state & gimp_get_constrain_behavior_mask ()) != 0; + + if (! gimp_paint_tool_paint_start (paint_tool, + display, coords, time, constrain, + &error)) + { + gimp_tool_message_literal (tool, display, error->message); + g_clear_error (&error); + return; + } + + tool->display = display; + tool->drawable = drawable; + + /* pause the current selection */ + gimp_display_shell_selection_pause (shell); + + gimp_draw_tool_start (draw_tool, display); + + gimp_tool_control_activate (tool->control); +} + +static void +gimp_paint_tool_button_release (GimpTool *tool, + const GimpCoords *coords, + guint32 time, + GdkModifierType state, + GimpButtonReleaseType release_type, + GimpDisplay *display) +{ + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); + GimpDisplayShell *shell = gimp_display_get_shell (display); + GimpImage *image = gimp_display_get_image (display); + gboolean cancel; + + if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) + { + GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, + state, release_type, + display); + return; + } + + cancel = (release_type == GIMP_BUTTON_RELEASE_CANCEL); + + gimp_paint_tool_paint_end (paint_tool, time, cancel); + + gimp_tool_control_halt (tool->control); + + gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); + + /* resume the current selection */ + gimp_display_shell_selection_resume (shell); + + gimp_image_flush (image); + + gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); +} + +static void +gimp_paint_tool_motion (GimpTool *tool, + const GimpCoords *coords, + guint32 time, + GdkModifierType state, + GimpDisplay *display) +{ + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); + + GIMP_TOOL_CLASS (parent_class)->motion (tool, coords, time, state, display); + + if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) + return; + + if (! paint_tool->snap_brush) + gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); + + gimp_paint_tool_paint_motion (paint_tool, coords, time); + + if (! paint_tool->snap_brush) + gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); +} + +static void +gimp_paint_tool_modifier_key (GimpTool *tool, + GdkModifierType key, + gboolean press, + GdkModifierType state, + GimpDisplay *display) +{ + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); + GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); + + if (paint_tool->pick_colors && ! paint_tool->draw_line) + { + if ((state & gimp_get_all_modifiers_mask ()) == + gimp_get_constrain_behavior_mask ()) + { + if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) + { + GimpToolInfo *info = gimp_get_tool_info (display->gimp, + "gimp-color-picker-tool"); + + if (GIMP_IS_TOOL_INFO (info)) + { + if (gimp_draw_tool_is_active (draw_tool)) + gimp_draw_tool_stop (draw_tool); + + gimp_color_tool_enable (GIMP_COLOR_TOOL (tool), + GIMP_COLOR_OPTIONS (info->tool_options)); + + switch (GIMP_COLOR_TOOL (tool)->pick_target) + { + case GIMP_COLOR_PICK_TARGET_FOREGROUND: + gimp_tool_push_status (tool, display, + _("Click in any image to pick the " + "foreground color")); + break; + + case GIMP_COLOR_PICK_TARGET_BACKGROUND: + gimp_tool_push_status (tool, display, + _("Click in any image to pick the " + "background color")); + break; + + default: + break; + } + } + } + } + else + { + if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) + { + gimp_tool_pop_status (tool, display); + gimp_color_tool_disable (GIMP_COLOR_TOOL (tool)); + } + } + } +} + +static void +gimp_paint_tool_cursor_update (GimpTool *tool, + const GimpCoords *coords, + GdkModifierType state, + GimpDisplay *display) +{ + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); + GimpGuiConfig *config = GIMP_GUI_CONFIG (display->gimp->config); + GimpCursorModifier modifier; + GimpCursorModifier toggle_modifier; + GimpCursorModifier old_modifier; + GimpCursorModifier old_toggle_modifier; + + modifier = tool->control->cursor_modifier; + toggle_modifier = tool->control->toggle_cursor_modifier; + + old_modifier = modifier; + old_toggle_modifier = toggle_modifier; + + if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) + { + GimpImage *image = gimp_display_get_image (display); + GimpDrawable *drawable = gimp_image_get_active_drawable (image); + + if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || + gimp_item_is_content_locked (GIMP_ITEM (drawable)) || + ! gimp_paint_tool_check_alpha (paint_tool, drawable, display, NULL) || + ! (gimp_item_is_visible (GIMP_ITEM (drawable)) || + config->edit_non_visible)) + { + modifier = GIMP_CURSOR_MODIFIER_BAD; + toggle_modifier = GIMP_CURSOR_MODIFIER_BAD; + } + + if (! paint_tool->show_cursor && + modifier != GIMP_CURSOR_MODIFIER_BAD) + { + gimp_tool_set_cursor (tool, display, + GIMP_CURSOR_NONE, + GIMP_TOOL_CURSOR_NONE, + GIMP_CURSOR_MODIFIER_NONE); + return; + } + + gimp_tool_control_set_cursor_modifier (tool->control, + modifier); + gimp_tool_control_set_toggle_cursor_modifier (tool->control, + toggle_modifier); + } + + GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, + display); + + /* reset old stuff here so we are not interfering with the modifiers + * set by our subclasses + */ + gimp_tool_control_set_cursor_modifier (tool->control, + old_modifier); + gimp_tool_control_set_toggle_cursor_modifier (tool->control, + old_toggle_modifier); +} + +static void +gimp_paint_tool_oper_update (GimpTool *tool, + const GimpCoords *coords, + GdkModifierType state, + gboolean proximity, + GimpDisplay *display) +{ + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool); + GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); + GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool); + GimpPaintCore *core = paint_tool->core; + GimpDisplayShell *shell = gimp_display_get_shell (display); + GimpImage *image = gimp_display_get_image (display); + GimpDrawable *drawable = gimp_image_get_active_drawable (image); + + if (gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool))) + { + GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, + proximity, display); + return; + } + + gimp_draw_tool_pause (draw_tool); + + if (gimp_draw_tool_is_active (draw_tool) && + draw_tool->display != display) + gimp_draw_tool_stop (draw_tool); + + gimp_tool_pop_status (tool, display); + + if (tool->display && + tool->display != display && + gimp_display_get_image (tool->display) == image) + { + /* if this is a different display, but the same image, HACK around + * in tool internals AFTER stopping the current draw_tool, so + * straight line drawing works across different views of the + * same image. + */ + + tool->display = display; + } + + if (drawable && proximity) + { + gchar *status; + gboolean constrain_mask = gimp_get_constrain_behavior_mask (); + gint off_x, off_y; + + core->cur_coords = *coords; + + gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); + + core->cur_coords.x -= off_x; + core->cur_coords.y -= off_y; + + if (display == tool->display && (state & GIMP_PAINT_TOOL_LINE_MASK)) + { + /* If shift is down and this is not the first paint stroke, + * draw a line. + */ + gchar *status_help; + gdouble offset_angle; + gdouble xres, yres; + + gimp_display_shell_get_constrained_line_params (shell, + &offset_angle, + &xres, &yres); + + gimp_paint_core_round_line (core, paint_options, + (state & constrain_mask) != 0, + offset_angle, xres, yres); + + status_help = gimp_suggest_modifiers (paint_tool->status_line, + constrain_mask & ~state, + NULL, + _("%s for constrained angles"), + NULL); + + status = gimp_display_shell_get_line_status (shell, status_help, + ". ", + core->last_coords.x, + core->last_coords.y, + core->cur_coords.x, + core->cur_coords.y); + g_free (status_help); + paint_tool->draw_line = TRUE; + } + else + { + GdkModifierType modifiers = 0; + + /* HACK: A paint tool may set status_ctrl to NULL to indicate that + * it ignores the Ctrl modifier (temporarily or permanently), so + * it should not be suggested. This is different from how + * gimp_suggest_modifiers() would interpret this parameter. + */ + if (paint_tool->status_ctrl != NULL) + modifiers |= constrain_mask; + + /* suggest drawing lines only after the first point is set + */ + if (display == tool->display) + modifiers |= GIMP_PAINT_TOOL_LINE_MASK; + + status = gimp_suggest_modifiers (paint_tool->status, + modifiers & ~state, + _("%s for a straight line"), + paint_tool->status_ctrl, + NULL); + paint_tool->draw_line = FALSE; + } + gimp_tool_push_status (tool, display, "%s", status); + g_free (status); + + paint_tool->cursor_x = core->cur_coords.x; + paint_tool->cursor_y = core->cur_coords.y; + + if (! gimp_draw_tool_is_active (draw_tool)) + gimp_draw_tool_start (draw_tool, display); + } + else if (gimp_draw_tool_is_active (draw_tool)) + { + gimp_draw_tool_stop (draw_tool); + } + + GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state, proximity, + display); + + gimp_draw_tool_resume (draw_tool); +} + +static void +gimp_paint_tool_draw (GimpDrawTool *draw_tool) +{ + GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (draw_tool); + + + if (paint_tool->active && + ! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (draw_tool))) + { + GimpPaintCore *core = paint_tool->core; + GimpImage *image = gimp_display_get_image (draw_tool->display); + GimpDrawable *drawable = gimp_image_get_active_drawable (image); + GimpCanvasItem *outline = NULL; + gboolean line_drawn = FALSE; + gdouble cur_x, cur_y; + gint off_x, off_y; + + gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); + + if (gimp_paint_tool_paint_is_active (paint_tool) && + paint_tool->snap_brush) + { + cur_x = paint_tool->paint_x + off_x; + cur_y = paint_tool->paint_y + off_y; + } + else + { + cur_x = paint_tool->cursor_x + off_x; + cur_y = paint_tool->cursor_y + off_y; + + if (paint_tool->draw_line && + ! gimp_tool_control_is_active (GIMP_TOOL (draw_tool)->control)) + { + GimpCanvasGroup *group; + gdouble last_x, last_y; + + last_x = core->last_coords.x + off_x; + last_y = core->last_coords.y + off_y; + + group = gimp_draw_tool_add_stroke_group (draw_tool); + gimp_draw_tool_push_group (draw_tool, group); + + gimp_draw_tool_add_handle (draw_tool, + GIMP_HANDLE_CIRCLE, + last_x, last_y, + GIMP_TOOL_HANDLE_SIZE_CIRCLE, + GIMP_TOOL_HANDLE_SIZE_CIRCLE, + GIMP_HANDLE_ANCHOR_CENTER); + + gimp_draw_tool_add_line (draw_tool, + last_x, last_y, + cur_x, cur_y); + + gimp_draw_tool_add_handle (draw_tool, + GIMP_HANDLE_CIRCLE, + cur_x, cur_y, + GIMP_TOOL_HANDLE_SIZE_CIRCLE, + GIMP_TOOL_HANDLE_SIZE_CIRCLE, + GIMP_HANDLE_ANCHOR_CENTER); + + gimp_draw_tool_pop_group (draw_tool); + + line_drawn = TRUE; + } + } + + gimp_paint_tool_set_draw_fallback (paint_tool, FALSE, 0.0); + + if (paint_tool->draw_brush) + outline = gimp_paint_tool_get_outline (paint_tool, + draw_tool->display, + cur_x, cur_y); + + if (outline) + { + gimp_draw_tool_add_item (draw_tool, outline); + g_object_unref (outline); + } + else if (paint_tool->draw_fallback) + { + /* Lets make a sensible fallback cursor + * + * Sensible cursor is + * * crossed to indicate draw point + * * reactive to options alterations + * * not a full circle that would be in the way + */ + gint size = (gint) paint_tool->fallback_size; + +#define TICKMARK_ANGLE 48 +#define ROTATION_ANGLE G_PI / 4 + + /* marks for indicating full size */ + gimp_draw_tool_add_arc (draw_tool, + FALSE, + cur_x - (size / 2.0), + cur_y - (size / 2.0), + size, size, + ROTATION_ANGLE - (2.0 * G_PI) / (TICKMARK_ANGLE * 2), + (2.0 * G_PI) / TICKMARK_ANGLE); + + gimp_draw_tool_add_arc (draw_tool, + FALSE, + cur_x - (size / 2.0), + cur_y - (size / 2.0), + size, size, + ROTATION_ANGLE + G_PI / 2 - (2.0 * G_PI) / (TICKMARK_ANGLE * 2), + (2.0 * G_PI) / TICKMARK_ANGLE); + + gimp_draw_tool_add_arc (draw_tool, + FALSE, + cur_x - (size / 2.0), + cur_y - (size / 2.0), + size, size, + ROTATION_ANGLE + G_PI - (2.0 * G_PI) / (TICKMARK_ANGLE * 2), + (2.0 * G_PI) / TICKMARK_ANGLE); + + gimp_draw_tool_add_arc (draw_tool, + FALSE, + cur_x - (size / 2.0), + cur_y - (size / 2.0), + size, size, + ROTATION_ANGLE + 3 * G_PI / 2 - (2.0 * G_PI) / (TICKMARK_ANGLE * 2), + (2.0 * G_PI) / TICKMARK_ANGLE); + } + else if (paint_tool->draw_circle) + { + gint size = (gint) paint_tool->circle_size; + + /* draw an indicatory circle */ + gimp_draw_tool_add_arc (draw_tool, + FALSE, + cur_x - (size / 2.0), + cur_y - (size / 2.0), + size, size, + 0.0, (2.0 * G_PI)); + } + + if (! outline && + ! line_drawn && + ! paint_tool->show_cursor && + ! paint_tool->draw_circle) + { + /* don't leave the user without any indication and draw + * a fallback crosshair + */ + gimp_draw_tool_add_handle (draw_tool, + GIMP_HANDLE_CROSSHAIR, + cur_x, cur_y, + GIMP_TOOL_HANDLE_SIZE_CROSSHAIR, + GIMP_TOOL_HANDLE_SIZE_CROSSHAIR, + GIMP_HANDLE_ANCHOR_CENTER); + } + } + + GIMP_DRAW_TOOL_CLASS (parent_class)->draw (draw_tool); +} + +static void +gimp_paint_tool_real_paint_prepare (GimpPaintTool *paint_tool, + GimpDisplay *display) +{ + GimpDisplayShell *shell = gimp_display_get_shell (display); + + gimp_paint_core_set_show_all (paint_tool->core, shell->show_all); +} + +static GimpCanvasItem * +gimp_paint_tool_get_outline (GimpPaintTool *paint_tool, + GimpDisplay *display, + gdouble x, + gdouble y) +{ + if (GIMP_PAINT_TOOL_GET_CLASS (paint_tool)->get_outline) + return GIMP_PAINT_TOOL_GET_CLASS (paint_tool)->get_outline (paint_tool, + display, x, y); + + return NULL; +} + +static gboolean +gimp_paint_tool_check_alpha (GimpPaintTool *paint_tool, + GimpDrawable *drawable, + GimpDisplay *display, + GError **error) +{ + GimpPaintToolClass *klass = GIMP_PAINT_TOOL_GET_CLASS (paint_tool); + + if (klass->is_alpha_only && klass->is_alpha_only (paint_tool, drawable)) + { + if (! gimp_drawable_has_alpha (drawable)) + { + g_set_error_literal ( + error, GIMP_ERROR, GIMP_FAILED, + _("The active layer does not have an alpha channel.")); + + return FALSE; + } + + if (GIMP_IS_LAYER (drawable) && + gimp_layer_get_lock_alpha (GIMP_LAYER (drawable))) + { + g_set_error_literal ( + error, GIMP_ERROR, GIMP_FAILED, + _("The active layer's alpha channel is locked.")); + + if (error) + gimp_tools_blink_lock_box (display->gimp, GIMP_ITEM (drawable)); + + return FALSE; + } + } + + return TRUE; +} + +static void +gimp_paint_tool_hard_notify (GimpPaintOptions *options, + const GParamSpec *pspec, + GimpPaintTool *paint_tool) +{ + if (paint_tool->active) + { + GimpTool *tool = GIMP_TOOL (paint_tool); + + gimp_tool_control_set_precision (tool->control, + options->hard ? + GIMP_CURSOR_PRECISION_PIXEL_CENTER : + GIMP_CURSOR_PRECISION_SUBPIXEL); + } +} + +static void +gimp_paint_tool_cursor_notify (GimpDisplayConfig *config, + GParamSpec *pspec, + GimpPaintTool *paint_tool) +{ + gimp_draw_tool_pause (GIMP_DRAW_TOOL (paint_tool)); + + paint_tool->show_cursor = config->show_paint_tool_cursor; + paint_tool->draw_brush = config->show_brush_outline; + paint_tool->snap_brush = config->snap_brush_outline; + + gimp_draw_tool_resume (GIMP_DRAW_TOOL (paint_tool)); +} + +void +gimp_paint_tool_set_active (GimpPaintTool *tool, + gboolean active) +{ + g_return_if_fail (GIMP_IS_PAINT_TOOL (tool)); + + if (active != tool->active) + { + GimpPaintOptions *options = GIMP_PAINT_TOOL_GET_OPTIONS (tool); + + gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool)); + + tool->active = active; + + if (active) + gimp_paint_tool_hard_notify (options, NULL, tool); + + gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool)); + } +} + +/** + * gimp_paint_tool_enable_color_picker: + * @tool: a #GimpPaintTool + * @target: the #GimpColorPickTarget to set + * + * This is a convenience function used from the init method of paint + * tools that want the color picking functionality. The @mode that is + * set here is used to decide what cursor modifier to draw and if the + * picked color goes to the foreground or background color. + **/ +void +gimp_paint_tool_enable_color_picker (GimpPaintTool *tool, + GimpColorPickTarget target) +{ + g_return_if_fail (GIMP_IS_PAINT_TOOL (tool)); + + tool->pick_colors = TRUE; + + GIMP_COLOR_TOOL (tool)->pick_target = target; +} + +void +gimp_paint_tool_set_draw_fallback (GimpPaintTool *tool, + gboolean draw_fallback, + gint fallback_size) +{ + g_return_if_fail (GIMP_IS_PAINT_TOOL (tool)); + + tool->draw_fallback = draw_fallback; + tool->fallback_size = fallback_size; +} + +void +gimp_paint_tool_set_draw_circle (GimpPaintTool *tool, + gboolean draw_circle, + gint circle_size) +{ + g_return_if_fail (GIMP_IS_PAINT_TOOL (tool)); + + tool->draw_circle = draw_circle; + tool->circle_size = circle_size; +} |