summaryrefslogtreecommitdiffstats
path: root/app/tools/gimpbrushtool.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/tools/gimpbrushtool.c')
-rw-r--r--app/tools/gimpbrushtool.c451
1 files changed, 451 insertions, 0 deletions
diff --git a/app/tools/gimpbrushtool.c b/app/tools/gimpbrushtool.c
new file mode 100644
index 0000000..08c8ed9
--- /dev/null
+++ b/app/tools/gimpbrushtool.c
@@ -0,0 +1,451 @@
+/* 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 <string.h>
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpmath/gimpmath.h"
+
+#include "tools-types.h"
+
+#include "config/gimpdisplayconfig.h"
+
+#include "core/gimp.h"
+#include "core/gimpbezierdesc.h"
+#include "core/gimpbrush.h"
+#include "core/gimpimage.h"
+#include "core/gimptoolinfo.h"
+
+#include "paint/gimpbrushcore.h"
+#include "paint/gimppaintoptions.h"
+
+#include "display/gimpcanvashandle.h"
+#include "display/gimpcanvaspath.h"
+#include "display/gimpdisplay.h"
+#include "display/gimpdisplayshell.h"
+
+#include "gimpbrushtool.h"
+#include "gimppainttool-paint.h"
+#include "gimptoolcontrol.h"
+
+
+static void gimp_brush_tool_constructed (GObject *object);
+
+static void gimp_brush_tool_oper_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ gboolean proximity,
+ GimpDisplay *display);
+static void gimp_brush_tool_cursor_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ GimpDisplay *display);
+static void gimp_brush_tool_options_notify (GimpTool *tool,
+ GimpToolOptions *options,
+ const GParamSpec *pspec);
+
+static void gimp_brush_tool_paint_start (GimpPaintTool *paint_tool);
+static void gimp_brush_tool_paint_end (GimpPaintTool *paint_tool);
+static void gimp_brush_tool_paint_flush (GimpPaintTool *paint_tool);
+static GimpCanvasItem *
+ gimp_brush_tool_get_outline (GimpPaintTool *paint_tool,
+ GimpDisplay *display,
+ gdouble x,
+ gdouble y);
+
+static void gimp_brush_tool_brush_changed (GimpContext *context,
+ GimpBrush *brush,
+ GimpBrushTool *brush_tool);
+static void gimp_brush_tool_set_brush (GimpBrushCore *brush_core,
+ GimpBrush *brush,
+ GimpBrushTool *brush_tool);
+
+static const GimpBezierDesc *
+ gimp_brush_tool_get_boundary (GimpBrushTool *brush_tool,
+ gint *width,
+ gint *height);
+
+
+G_DEFINE_TYPE (GimpBrushTool, gimp_brush_tool, GIMP_TYPE_PAINT_TOOL)
+
+#define parent_class gimp_brush_tool_parent_class
+
+
+static void
+gimp_brush_tool_class_init (GimpBrushToolClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
+ GimpPaintToolClass *paint_tool_class = GIMP_PAINT_TOOL_CLASS (klass);
+
+ object_class->constructed = gimp_brush_tool_constructed;
+
+ tool_class->oper_update = gimp_brush_tool_oper_update;
+ tool_class->cursor_update = gimp_brush_tool_cursor_update;
+ tool_class->options_notify = gimp_brush_tool_options_notify;
+
+ paint_tool_class->paint_start = gimp_brush_tool_paint_start;
+ paint_tool_class->paint_end = gimp_brush_tool_paint_end;
+ paint_tool_class->paint_flush = gimp_brush_tool_paint_flush;
+ paint_tool_class->get_outline = gimp_brush_tool_get_outline;
+}
+
+static void
+gimp_brush_tool_init (GimpBrushTool *brush_tool)
+{
+ GimpTool *tool = GIMP_TOOL (brush_tool);
+
+ gimp_tool_control_set_action_size (tool->control,
+ "tools/tools-paintbrush-size-set");
+ gimp_tool_control_set_action_aspect (tool->control,
+ "tools/tools-paintbrush-aspect-ratio-set");
+ gimp_tool_control_set_action_angle (tool->control,
+ "tools/tools-paintbrush-angle-set");
+ gimp_tool_control_set_action_spacing (tool->control,
+ "tools/tools-paintbrush-spacing-set");
+ gimp_tool_control_set_action_hardness (tool->control,
+ "tools/tools-paintbrush-hardness-set");
+ gimp_tool_control_set_action_force (tool->control,
+ "tools/tools-paintbrush-force-set");
+ gimp_tool_control_set_action_object_1 (tool->control,
+ "context/context-brush-select-set");
+}
+
+static void
+gimp_brush_tool_constructed (GObject *object)
+{
+ GimpTool *tool = GIMP_TOOL (object);
+ GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (object);
+
+ G_OBJECT_CLASS (parent_class)->constructed (object);
+
+ gimp_assert (GIMP_IS_BRUSH_CORE (paint_tool->core));
+
+ g_signal_connect_object (gimp_tool_get_options (tool), "brush-changed",
+ G_CALLBACK (gimp_brush_tool_brush_changed),
+ paint_tool, 0);
+
+ g_signal_connect_object (paint_tool->core, "set-brush",
+ G_CALLBACK (gimp_brush_tool_set_brush),
+ paint_tool, 0);
+}
+
+static void
+gimp_brush_tool_oper_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ gboolean proximity,
+ GimpDisplay *display)
+{
+ GimpPaintOptions *paint_options = GIMP_PAINT_TOOL_GET_OPTIONS (tool);
+ GimpDrawable *drawable;
+
+ gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
+
+ GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state,
+ proximity, display);
+
+ drawable = gimp_image_get_active_drawable (gimp_display_get_image (display));
+
+ if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)) &&
+ drawable && proximity)
+ {
+ GimpContext *context = GIMP_CONTEXT (paint_options);
+ GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
+ GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
+
+ gimp_brush_core_set_brush (brush_core,
+ gimp_context_get_brush (context));
+
+ gimp_brush_core_set_dynamics (brush_core,
+ gimp_context_get_dynamics (context));
+
+ if (GIMP_BRUSH_CORE_GET_CLASS (brush_core)->handles_transforming_brush)
+ {
+ gimp_brush_core_eval_transform_dynamics (brush_core,
+ drawable,
+ paint_options,
+ coords);
+ }
+ }
+
+ gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
+}
+
+static void
+gimp_brush_tool_cursor_update (GimpTool *tool,
+ const GimpCoords *coords,
+ GdkModifierType state,
+ GimpDisplay *display)
+{
+ GimpBrushTool *brush_tool = GIMP_BRUSH_TOOL (tool);
+ GimpBrushCore *brush_core = GIMP_BRUSH_CORE (GIMP_PAINT_TOOL (brush_tool)->core);
+
+ if (! gimp_color_tool_is_enabled (GIMP_COLOR_TOOL (tool)))
+ {
+ if (! brush_core->main_brush || ! brush_core->dynamics)
+ {
+ gimp_tool_set_cursor (tool, display,
+ gimp_tool_control_get_cursor (tool->control),
+ gimp_tool_control_get_tool_cursor (tool->control),
+ GIMP_CURSOR_MODIFIER_BAD);
+ return;
+ }
+ }
+
+ GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
+}
+
+static void
+gimp_brush_tool_options_notify (GimpTool *tool,
+ GimpToolOptions *options,
+ const GParamSpec *pspec)
+{
+ GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
+
+ if (! strcmp (pspec->name, "brush-size") ||
+ ! strcmp (pspec->name, "brush-angle") ||
+ ! strcmp (pspec->name, "brush-aspect-ratio"))
+ {
+ GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (tool);
+ GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
+
+ g_signal_emit_by_name (brush_core, "set-brush",
+ brush_core->main_brush);
+ }
+}
+
+static void
+gimp_brush_tool_paint_start (GimpPaintTool *paint_tool)
+{
+ GimpBrushTool *brush_tool = GIMP_BRUSH_TOOL (paint_tool);
+ GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
+ const GimpBezierDesc *boundary;
+
+ if (GIMP_PAINT_TOOL_CLASS (parent_class)->paint_start)
+ GIMP_PAINT_TOOL_CLASS (parent_class)->paint_start (paint_tool);
+
+ boundary = gimp_brush_tool_get_boundary (brush_tool,
+ &brush_tool->boundary_width,
+ &brush_tool->boundary_height);
+
+ if (boundary)
+ brush_tool->boundary = gimp_bezier_desc_copy (boundary);
+
+ brush_tool->boundary_scale = brush_core->scale;
+ brush_tool->boundary_aspect_ratio = brush_core->aspect_ratio;
+ brush_tool->boundary_angle = brush_core->angle;
+ brush_tool->boundary_reflect = brush_core->reflect;
+ brush_tool->boundary_hardness = brush_core->hardness;
+}
+
+static void
+gimp_brush_tool_paint_end (GimpPaintTool *paint_tool)
+{
+ GimpBrushTool *brush_tool = GIMP_BRUSH_TOOL (paint_tool);
+
+ g_clear_pointer (&brush_tool->boundary, gimp_bezier_desc_free);
+
+ if (GIMP_PAINT_TOOL_CLASS (parent_class)->paint_end)
+ GIMP_PAINT_TOOL_CLASS (parent_class)->paint_end (paint_tool);
+}
+
+static void
+gimp_brush_tool_paint_flush (GimpPaintTool *paint_tool)
+{
+ GimpBrushTool *brush_tool = GIMP_BRUSH_TOOL (paint_tool);
+ GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
+ const GimpBezierDesc *boundary;
+
+ if (GIMP_PAINT_TOOL_CLASS (parent_class)->paint_flush)
+ GIMP_PAINT_TOOL_CLASS (parent_class)->paint_flush (paint_tool);
+
+ if (brush_tool->boundary_scale != brush_core->scale ||
+ brush_tool->boundary_aspect_ratio != brush_core->aspect_ratio ||
+ brush_tool->boundary_angle != brush_core->angle ||
+ brush_tool->boundary_reflect != brush_core->reflect ||
+ brush_tool->boundary_hardness != brush_core->hardness)
+ {
+ g_clear_pointer (&brush_tool->boundary, gimp_bezier_desc_free);
+
+ boundary = gimp_brush_tool_get_boundary (brush_tool,
+ &brush_tool->boundary_width,
+ &brush_tool->boundary_height);
+
+ if (boundary)
+ brush_tool->boundary = gimp_bezier_desc_copy (boundary);
+
+ brush_tool->boundary_scale = brush_core->scale;
+ brush_tool->boundary_aspect_ratio = brush_core->aspect_ratio;
+ brush_tool->boundary_angle = brush_core->angle;
+ brush_tool->boundary_reflect = brush_core->reflect;
+ brush_tool->boundary_hardness = brush_core->hardness;
+ }
+}
+
+static GimpCanvasItem *
+gimp_brush_tool_get_outline (GimpPaintTool *paint_tool,
+ GimpDisplay *display,
+ gdouble x,
+ gdouble y)
+{
+ GimpBrushTool *brush_tool = GIMP_BRUSH_TOOL (paint_tool);
+ GimpCanvasItem *item;
+
+ item = gimp_brush_tool_create_outline (brush_tool, display, x, y);
+
+ if (! item)
+ {
+ GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
+
+ if (brush_core->main_brush && brush_core->dynamics)
+ {
+ /* if an outline was expected, but got scaled away by
+ * transform/dynamics, draw a circle in the "normal" size.
+ */
+ GimpPaintOptions *options;
+
+ options = GIMP_PAINT_TOOL_GET_OPTIONS (brush_tool);
+
+ gimp_paint_tool_set_draw_fallback (paint_tool,
+ TRUE, options->brush_size);
+ }
+ }
+
+ return item;
+}
+
+GimpCanvasItem *
+gimp_brush_tool_create_outline (GimpBrushTool *brush_tool,
+ GimpDisplay *display,
+ gdouble x,
+ gdouble y)
+{
+ GimpTool *tool;
+ GimpDisplayShell *shell;
+ const GimpBezierDesc *boundary = NULL;
+ gint width = 0;
+ gint height = 0;
+
+ g_return_val_if_fail (GIMP_IS_BRUSH_TOOL (brush_tool), NULL);
+ g_return_val_if_fail (GIMP_IS_DISPLAY (display), NULL);
+
+ if (gimp_paint_tool_paint_is_active (GIMP_PAINT_TOOL (brush_tool)))
+ {
+ boundary = brush_tool->boundary;
+ width = brush_tool->boundary_width;
+ height = brush_tool->boundary_height;
+ }
+ else
+ {
+ boundary = gimp_brush_tool_get_boundary (brush_tool, &width, &height);
+ }
+
+ if (! boundary)
+ return NULL;
+
+ tool = GIMP_TOOL (brush_tool);
+ shell = gimp_display_get_shell (display);
+
+ /* don't draw the boundary if it becomes too small */
+ if (SCALEX (shell, width) > 4 &&
+ SCALEY (shell, height) > 4)
+ {
+ x -= width / 2.0;
+ y -= height / 2.0;
+
+ if (gimp_tool_control_get_precision (tool->control) ==
+ GIMP_CURSOR_PRECISION_PIXEL_CENTER)
+ {
+#define EPSILON 0.000001
+ /* Add EPSILON before rounding since e.g.
+ * (5.0 - 0.5) may end up at (4.499999999....)
+ * due to floating point fnords
+ */
+ x = RINT (x + EPSILON);
+ y = RINT (y + EPSILON);
+#undef EPSILON
+ }
+
+ return gimp_canvas_path_new (shell, boundary, x, y, FALSE,
+ GIMP_PATH_STYLE_OUTLINE);
+ }
+
+ return NULL;
+}
+
+static void
+gimp_brush_tool_brush_changed (GimpContext *context,
+ GimpBrush *brush,
+ GimpBrushTool *brush_tool)
+{
+ GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (brush_tool);
+ GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
+
+ gimp_brush_core_set_brush (brush_core, brush);
+
+}
+
+static void
+gimp_brush_tool_set_brush (GimpBrushCore *brush_core,
+ GimpBrush *brush,
+ GimpBrushTool *brush_tool)
+{
+ gimp_draw_tool_pause (GIMP_DRAW_TOOL (brush_tool));
+
+ if (GIMP_BRUSH_CORE_GET_CLASS (brush_core)->handles_transforming_brush)
+ {
+ GimpPaintCore *paint_core = GIMP_PAINT_CORE (brush_core);
+
+ gimp_brush_core_eval_transform_dynamics (brush_core,
+ NULL,
+ GIMP_PAINT_TOOL_GET_OPTIONS (brush_tool),
+ &paint_core->cur_coords);
+ }
+
+ gimp_draw_tool_resume (GIMP_DRAW_TOOL (brush_tool));
+}
+
+static const GimpBezierDesc *
+gimp_brush_tool_get_boundary (GimpBrushTool *brush_tool,
+ gint *width,
+ gint *height)
+{
+ GimpPaintTool *paint_tool = GIMP_PAINT_TOOL (brush_tool);
+ GimpBrushCore *brush_core = GIMP_BRUSH_CORE (paint_tool->core);
+
+ if (paint_tool->draw_brush &&
+ brush_core->main_brush &&
+ brush_core->dynamics &&
+ brush_core->scale > 0.0)
+ {
+ return gimp_brush_transform_boundary (brush_core->main_brush,
+ brush_core->scale,
+ brush_core->aspect_ratio,
+ brush_core->angle,
+ brush_core->reflect,
+ brush_core->hardness,
+ width,
+ height);
+ }
+
+ return NULL;
+}