PIKApp/app/tools/pikabrushtool.c

456 lines
17 KiB
C
Raw Permalink Normal View History

2023-09-26 00:35:21 +02:00
/* 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 <https://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <gegl.h>
#include <gtk/gtk.h>
#include "libpikamath/pikamath.h"
#include "tools-types.h"
#include "config/pikadisplayconfig.h"
#include "core/pika.h"
#include "core/pikabezierdesc.h"
#include "core/pikabrush.h"
#include "core/pikaimage.h"
#include "core/pikatoolinfo.h"
#include "paint/pikabrushcore.h"
#include "paint/pikapaintoptions.h"
#include "display/pikacanvashandle.h"
#include "display/pikacanvaspath.h"
#include "display/pikadisplay.h"
#include "display/pikadisplayshell.h"
#include "pikabrushtool.h"
#include "pikapainttool-paint.h"
#include "pikatoolcontrol.h"
static void pika_brush_tool_constructed (GObject *object);
static void pika_brush_tool_oper_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
gboolean proximity,
PikaDisplay *display);
static void pika_brush_tool_cursor_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display);
static void pika_brush_tool_options_notify (PikaTool *tool,
PikaToolOptions *options,
const GParamSpec *pspec);
static void pika_brush_tool_paint_start (PikaPaintTool *paint_tool);
static void pika_brush_tool_paint_end (PikaPaintTool *paint_tool);
static void pika_brush_tool_paint_flush (PikaPaintTool *paint_tool);
static PikaCanvasItem *
pika_brush_tool_get_outline (PikaPaintTool *paint_tool,
PikaDisplay *display,
gdouble x,
gdouble y);
static void pika_brush_tool_brush_changed (PikaContext *context,
PikaBrush *brush,
PikaBrushTool *brush_tool);
static void pika_brush_tool_set_brush (PikaBrushCore *brush_core,
PikaBrush *brush,
PikaBrushTool *brush_tool);
static const PikaBezierDesc *
pika_brush_tool_get_boundary (PikaBrushTool *brush_tool,
gint *width,
gint *height);
G_DEFINE_TYPE (PikaBrushTool, pika_brush_tool, PIKA_TYPE_PAINT_TOOL)
#define parent_class pika_brush_tool_parent_class
static void
pika_brush_tool_class_init (PikaBrushToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
PikaToolClass *tool_class = PIKA_TOOL_CLASS (klass);
PikaPaintToolClass *paint_tool_class = PIKA_PAINT_TOOL_CLASS (klass);
object_class->constructed = pika_brush_tool_constructed;
tool_class->oper_update = pika_brush_tool_oper_update;
tool_class->cursor_update = pika_brush_tool_cursor_update;
tool_class->options_notify = pika_brush_tool_options_notify;
paint_tool_class->paint_start = pika_brush_tool_paint_start;
paint_tool_class->paint_end = pika_brush_tool_paint_end;
paint_tool_class->paint_flush = pika_brush_tool_paint_flush;
paint_tool_class->get_outline = pika_brush_tool_get_outline;
}
static void
pika_brush_tool_init (PikaBrushTool *brush_tool)
{
PikaTool *tool = PIKA_TOOL (brush_tool);
pika_tool_control_set_action_pixel_size (tool->control,
"tools-paintbrush-pixel-size-set");
pika_tool_control_set_action_size (tool->control,
"tools-paintbrush-size-set");
pika_tool_control_set_action_aspect (tool->control,
"tools-paintbrush-aspect-ratio-set");
pika_tool_control_set_action_angle (tool->control,
"tools-paintbrush-angle-set");
pika_tool_control_set_action_spacing (tool->control,
"tools-paintbrush-spacing-set");
pika_tool_control_set_action_hardness (tool->control,
"tools-paintbrush-hardness-set");
pika_tool_control_set_action_force (tool->control,
"tools-paintbrush-force-set");
pika_tool_control_set_action_object_1 (tool->control,
"context-brush-select-set");
}
static void
pika_brush_tool_constructed (GObject *object)
{
PikaTool *tool = PIKA_TOOL (object);
PikaPaintTool *paint_tool = PIKA_PAINT_TOOL (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
pika_assert (PIKA_IS_BRUSH_CORE (paint_tool->core));
g_signal_connect_object (pika_tool_get_options (tool), "brush-changed",
G_CALLBACK (pika_brush_tool_brush_changed),
paint_tool, 0);
g_signal_connect_object (paint_tool->core, "set-brush",
G_CALLBACK (pika_brush_tool_set_brush),
paint_tool, 0);
}
static void
pika_brush_tool_oper_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
gboolean proximity,
PikaDisplay *display)
{
PikaPaintOptions *paint_options = PIKA_PAINT_TOOL_GET_OPTIONS (tool);
PikaImage *image = pika_display_get_image (display);
pika_draw_tool_pause (PIKA_DRAW_TOOL (tool));
PIKA_TOOL_CLASS (parent_class)->oper_update (tool, coords, state,
proximity, display);
if (! pika_color_tool_is_enabled (PIKA_COLOR_TOOL (tool)) &&
image && proximity)
{
PikaContext *context = PIKA_CONTEXT (paint_options);
PikaPaintTool *paint_tool = PIKA_PAINT_TOOL (tool);
PikaBrushCore *brush_core = PIKA_BRUSH_CORE (paint_tool->core);
pika_brush_core_set_brush (brush_core,
pika_context_get_brush (context));
pika_brush_core_set_dynamics (brush_core,
pika_context_get_dynamics (context));
if (PIKA_BRUSH_CORE_GET_CLASS (brush_core)->handles_transforming_brush)
{
pika_brush_core_eval_transform_dynamics (brush_core,
image,
paint_options,
coords);
}
}
pika_draw_tool_resume (PIKA_DRAW_TOOL (tool));
}
static void
pika_brush_tool_cursor_update (PikaTool *tool,
const PikaCoords *coords,
GdkModifierType state,
PikaDisplay *display)
{
PikaBrushTool *brush_tool = PIKA_BRUSH_TOOL (tool);
PikaBrushCore *brush_core = PIKA_BRUSH_CORE (PIKA_PAINT_TOOL (brush_tool)->core);
if (! pika_color_tool_is_enabled (PIKA_COLOR_TOOL (tool)))
{
if (! brush_core->main_brush || ! brush_core->dynamics)
{
pika_tool_set_cursor (tool, display,
pika_tool_control_get_cursor (tool->control),
pika_tool_control_get_tool_cursor (tool->control),
PIKA_CURSOR_MODIFIER_BAD);
return;
}
}
PIKA_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static void
pika_brush_tool_options_notify (PikaTool *tool,
PikaToolOptions *options,
const GParamSpec *pspec)
{
PIKA_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"))
{
PikaPaintTool *paint_tool = PIKA_PAINT_TOOL (tool);
PikaBrushCore *brush_core = PIKA_BRUSH_CORE (paint_tool->core);
g_signal_emit_by_name (brush_core, "set-brush",
brush_core->main_brush);
}
}
static void
pika_brush_tool_paint_start (PikaPaintTool *paint_tool)
{
PikaBrushTool *brush_tool = PIKA_BRUSH_TOOL (paint_tool);
PikaBrushCore *brush_core = PIKA_BRUSH_CORE (paint_tool->core);
const PikaBezierDesc *boundary;
if (PIKA_PAINT_TOOL_CLASS (parent_class)->paint_start)
PIKA_PAINT_TOOL_CLASS (parent_class)->paint_start (paint_tool);
boundary = pika_brush_tool_get_boundary (brush_tool,
&brush_tool->boundary_width,
&brush_tool->boundary_height);
if (boundary)
brush_tool->boundary = pika_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
pika_brush_tool_paint_end (PikaPaintTool *paint_tool)
{
PikaBrushTool *brush_tool = PIKA_BRUSH_TOOL (paint_tool);
g_clear_pointer (&brush_tool->boundary, pika_bezier_desc_free);
if (PIKA_PAINT_TOOL_CLASS (parent_class)->paint_end)
PIKA_PAINT_TOOL_CLASS (parent_class)->paint_end (paint_tool);
}
static void
pika_brush_tool_paint_flush (PikaPaintTool *paint_tool)
{
PikaBrushTool *brush_tool = PIKA_BRUSH_TOOL (paint_tool);
PikaBrushCore *brush_core = PIKA_BRUSH_CORE (paint_tool->core);
const PikaBezierDesc *boundary;
if (PIKA_PAINT_TOOL_CLASS (parent_class)->paint_flush)
PIKA_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, pika_bezier_desc_free);
boundary = pika_brush_tool_get_boundary (brush_tool,
&brush_tool->boundary_width,
&brush_tool->boundary_height);
if (boundary)
brush_tool->boundary = pika_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 PikaCanvasItem *
pika_brush_tool_get_outline (PikaPaintTool *paint_tool,
PikaDisplay *display,
gdouble x,
gdouble y)
{
PikaBrushTool *brush_tool = PIKA_BRUSH_TOOL (paint_tool);
PikaCanvasItem *item;
item = pika_brush_tool_create_outline (brush_tool, display, x, y);
if (! item)
{
PikaBrushCore *brush_core = PIKA_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.
*/
PikaPaintOptions *options;
options = PIKA_PAINT_TOOL_GET_OPTIONS (brush_tool);
pika_paint_tool_set_draw_fallback (paint_tool,
TRUE, options->brush_size);
}
}
return item;
}
PikaCanvasItem *
pika_brush_tool_create_outline (PikaBrushTool *brush_tool,
PikaDisplay *display,
gdouble x,
gdouble y)
{
PikaTool *tool;
PikaDisplayShell *shell;
const PikaBezierDesc *boundary = NULL;
gint width = 0;
gint height = 0;
g_return_val_if_fail (PIKA_IS_BRUSH_TOOL (brush_tool), NULL);
g_return_val_if_fail (PIKA_IS_DISPLAY (display), NULL);
if (pika_paint_tool_paint_is_active (PIKA_PAINT_TOOL (brush_tool)))
{
boundary = brush_tool->boundary;
width = brush_tool->boundary_width;
height = brush_tool->boundary_height;
}
else
{
boundary = pika_brush_tool_get_boundary (brush_tool, &width, &height);
}
if (! boundary)
return NULL;
tool = PIKA_TOOL (brush_tool);
shell = pika_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 (pika_tool_control_get_precision (tool->control) ==
PIKA_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 pika_canvas_path_new (shell, boundary, x, y, FALSE,
PIKA_PATH_STYLE_OUTLINE);
}
return NULL;
}
static void
pika_brush_tool_brush_changed (PikaContext *context,
PikaBrush *brush,
PikaBrushTool *brush_tool)
{
PikaPaintTool *paint_tool = PIKA_PAINT_TOOL (brush_tool);
PikaBrushCore *brush_core = PIKA_BRUSH_CORE (paint_tool->core);
pika_brush_core_set_brush (brush_core, brush);
}
static void
pika_brush_tool_set_brush (PikaBrushCore *brush_core,
PikaBrush *brush,
PikaBrushTool *brush_tool)
{
pika_draw_tool_pause (PIKA_DRAW_TOOL (brush_tool));
if (PIKA_BRUSH_CORE_GET_CLASS (brush_core)->handles_transforming_brush)
{
PikaPaintCore *paint_core = PIKA_PAINT_CORE (brush_core);
pika_brush_core_eval_transform_dynamics (brush_core,
NULL,
PIKA_PAINT_TOOL_GET_OPTIONS (brush_tool),
&paint_core->cur_coords);
}
pika_draw_tool_resume (PIKA_DRAW_TOOL (brush_tool));
}
static const PikaBezierDesc *
pika_brush_tool_get_boundary (PikaBrushTool *brush_tool,
gint *width,
gint *height)
{
PikaPaintTool *paint_tool = PIKA_PAINT_TOOL (brush_tool);
PikaBrushCore *brush_core = PIKA_BRUSH_CORE (paint_tool->core);
if (paint_tool->draw_brush &&
brush_core->main_brush &&
brush_core->dynamics &&
brush_core->scale > 0.0)
{
return pika_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;
}