From e42129241681dde7adae7d20697e7b421682fbb4 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 18:23:22 +0200 Subject: Adding upstream version 2.10.22. Signed-off-by: Daniel Baumann --- app/tools/gimpfiltertool-widgets.c | 964 +++++++++++++++++++++++++++++++++++++ 1 file changed, 964 insertions(+) create mode 100644 app/tools/gimpfiltertool-widgets.c (limited to 'app/tools/gimpfiltertool-widgets.c') diff --git a/app/tools/gimpfiltertool-widgets.c b/app/tools/gimpfiltertool-widgets.c new file mode 100644 index 0000000..d5cf6fe --- /dev/null +++ b/app/tools/gimpfiltertool-widgets.c @@ -0,0 +1,964 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpfiltertool-widgets.c + * + * 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 "libgimpmath/gimpmath.h" + +#include "tools-types.h" + +#include "core/gimpcontainer.h" +#include "core/gimpitem.h" + +#include "display/gimpdisplay.h" +#include "display/gimptoolfocus.h" +#include "display/gimptoolgyroscope.h" +#include "display/gimptoolline.h" +#include "display/gimptooltransformgrid.h" +#include "display/gimptoolwidgetgroup.h" + +#include "gimpfilteroptions.h" +#include "gimpfiltertool.h" +#include "gimpfiltertool-widgets.h" + + +typedef struct _Controller Controller; + +struct _Controller +{ + GimpFilterTool *filter_tool; + GimpControllerType controller_type; + GimpToolWidget *widget; + GCallback creator_callback; + gpointer creator_data; +}; + + +/* local function prototypes */ + +static Controller * gimp_filter_tool_controller_new (void); +static void gimp_filter_tool_controller_free (Controller *controller); + +static void gimp_filter_tool_set_line (Controller *controller, + GeglRectangle *area, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2); +static void gimp_filter_tool_line_changed (GimpToolWidget *widget, + Controller *controller); + +static void gimp_filter_tool_set_slider_line (Controller *controller, + GeglRectangle *area, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2, + const GimpControllerSlider *sliders, + gint n_sliders); +static void gimp_filter_tool_slider_line_changed (GimpToolWidget *widget, + Controller *controller); + +static void gimp_filter_tool_set_transform_grid (Controller *controller, + GeglRectangle *area, + const GimpMatrix3 *transform); +static void gimp_filter_tool_transform_grid_changed (GimpToolWidget *widget, + Controller *controller); + +static void gimp_filter_tool_set_transform_grids (Controller *controller, + GeglRectangle *area, + const GimpMatrix3 *transforms, + gint n_transforms); +static void gimp_filter_tool_transform_grids_changed (GimpToolWidget *widget, + Controller *controller); + +static void gimp_filter_tool_set_gyroscope (Controller *controller, + GeglRectangle *area, + gdouble yaw, + gdouble pitch, + gdouble roll, + gdouble zoom, + gboolean invert); +static void gimp_filter_tool_gyroscope_changed (GimpToolWidget *widget, + Controller *controller); + +static void gimp_filter_tool_set_focus (Controller *controller, + GeglRectangle *area, + GimpLimitType type, + gdouble x, + gdouble y, + gdouble radius, + gdouble aspect_ratio, + gdouble angle, + gdouble inner_limit, + gdouble midpoint); +static void gimp_filter_tool_focus_changed (GimpToolWidget *widget, + Controller *controller); + + +/* public functions */ + +GimpToolWidget * +gimp_filter_tool_create_widget (GimpFilterTool *filter_tool, + GimpControllerType controller_type, + const gchar *status_title, + GCallback callback, + gpointer callback_data, + GCallback *set_func, + gpointer *set_func_data) +{ + GimpTool *tool; + GimpDisplayShell *shell; + Controller *controller; + + g_return_val_if_fail (GIMP_IS_FILTER_TOOL (filter_tool), NULL); + g_return_val_if_fail (filter_tool->config != NULL, NULL); + + tool = GIMP_TOOL (filter_tool); + + g_return_val_if_fail (tool->display != NULL, NULL); + + shell = gimp_display_get_shell (tool->display); + + controller = gimp_filter_tool_controller_new (); + + controller->filter_tool = filter_tool; + controller->controller_type = controller_type; + controller->creator_callback = callback; + controller->creator_data = callback_data; + + switch (controller_type) + { + case GIMP_CONTROLLER_TYPE_LINE: + controller->widget = gimp_tool_line_new (shell, 100, 100, 500, 500); + + g_object_set (controller->widget, + "status-title", status_title, + NULL); + + g_signal_connect (controller->widget, "changed", + G_CALLBACK (gimp_filter_tool_line_changed), + controller); + + *set_func = (GCallback) gimp_filter_tool_set_line; + *set_func_data = controller; + break; + + case GIMP_CONTROLLER_TYPE_SLIDER_LINE: + controller->widget = gimp_tool_line_new (shell, 100, 100, 500, 500); + + g_object_set (controller->widget, + "status-title", status_title, + NULL); + + g_signal_connect (controller->widget, "changed", + G_CALLBACK (gimp_filter_tool_slider_line_changed), + controller); + + *set_func = (GCallback) gimp_filter_tool_set_slider_line; + *set_func_data = controller; + break; + + case GIMP_CONTROLLER_TYPE_TRANSFORM_GRID: + { + GimpMatrix3 transform; + gint off_x, off_y; + GeglRectangle area; + gdouble x1, y1; + gdouble x2, y2; + + gimp_matrix3_identity (&transform); + + gimp_filter_tool_get_drawable_area (filter_tool, &off_x, &off_y, &area); + + x1 = off_x + area.x; + y1 = off_y + area.y; + x2 = x1 + area.width; + y2 = y1 + area.height; + + controller->widget = gimp_tool_transform_grid_new (shell, &transform, + x1, y1, x2, y2); + + g_object_set (controller->widget, + "pivot-x", (x1 + x2) / 2.0, + "pivot-y", (y1 + y2) / 2.0, + "inside-function", GIMP_TRANSFORM_FUNCTION_MOVE, + "outside-function", GIMP_TRANSFORM_FUNCTION_ROTATE, + "use-corner-handles", TRUE, + "use-perspective-handles", TRUE, + "use-side-handles", TRUE, + "use-shear-handles", TRUE, + "use-pivot-handle", TRUE, + NULL); + + g_signal_connect (controller->widget, "changed", + G_CALLBACK (gimp_filter_tool_transform_grid_changed), + controller); + + *set_func = (GCallback) gimp_filter_tool_set_transform_grid; + *set_func_data = controller; + } + break; + + case GIMP_CONTROLLER_TYPE_TRANSFORM_GRIDS: + { + controller->widget = gimp_tool_widget_group_new (shell); + + gimp_tool_widget_group_set_auto_raise ( + GIMP_TOOL_WIDGET_GROUP (controller->widget), TRUE); + + g_signal_connect (controller->widget, "changed", + G_CALLBACK (gimp_filter_tool_transform_grids_changed), + controller); + + *set_func = (GCallback) gimp_filter_tool_set_transform_grids; + *set_func_data = controller; + } + break; + + case GIMP_CONTROLLER_TYPE_GYROSCOPE: + { + GeglRectangle area; + gint off_x, off_y; + + gimp_filter_tool_get_drawable_area (filter_tool, &off_x, &off_y, &area); + + controller->widget = gimp_tool_gyroscope_new (shell); + + g_object_set (controller->widget, + "speed", 1.0 / MAX (area.width, area.height), + "pivot-x", off_x + area.x + area.width / 2.0, + "pivot-y", off_y + area.y + area.height / 2.0, + NULL); + + g_signal_connect (controller->widget, "changed", + G_CALLBACK (gimp_filter_tool_gyroscope_changed), + controller); + + *set_func = (GCallback) gimp_filter_tool_set_gyroscope; + *set_func_data = controller; + } + break; + + case GIMP_CONTROLLER_TYPE_FOCUS: + controller->widget = gimp_tool_focus_new (shell); + + g_signal_connect (controller->widget, "changed", + G_CALLBACK (gimp_filter_tool_focus_changed), + controller); + + *set_func = (GCallback) gimp_filter_tool_set_focus; + *set_func_data = controller; + break; + } + + g_object_add_weak_pointer (G_OBJECT (controller->widget), + (gpointer) &controller->widget); + + g_object_set_data_full (filter_tool->config, + "gimp-filter-tool-controller", controller, + (GDestroyNotify) gimp_filter_tool_controller_free); + + return controller->widget; +} + +static void +gimp_filter_tool_reset_transform_grid (GimpToolWidget *widget, + GimpFilterTool *filter_tool) +{ + GimpMatrix3 *transform; + gint off_x, off_y; + GeglRectangle area; + gdouble x1, y1; + gdouble x2, y2; + gdouble pivot_x, pivot_y; + + g_object_get (widget, + "transform", &transform, + NULL); + + gimp_filter_tool_get_drawable_area (filter_tool, &off_x, &off_y, &area); + + x1 = off_x + area.x; + y1 = off_y + area.y; + x2 = x1 + area.width; + y2 = y1 + area.height; + + gimp_matrix3_transform_point (transform, + (x1 + x2) / 2.0, (y1 + y2) / 2.0, + &pivot_x, &pivot_y); + + g_object_set (widget, + "pivot-x", pivot_x, + "pivot-y", pivot_y, + NULL); + + g_free (transform); +} + +void +gimp_filter_tool_reset_widget (GimpFilterTool *filter_tool, + GimpToolWidget *widget) +{ + Controller *controller; + + g_return_if_fail (GIMP_IS_FILTER_TOOL (filter_tool)); + g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget)); + g_return_if_fail (filter_tool->config != NULL); + + controller = g_object_get_data (filter_tool->config, + "gimp-filter-tool-controller"); + + g_return_if_fail (controller != NULL); + + switch (controller->controller_type) + { + case GIMP_CONTROLLER_TYPE_TRANSFORM_GRID: + { + g_signal_handlers_block_by_func (controller->widget, + gimp_filter_tool_transform_grid_changed, + controller); + + gimp_filter_tool_reset_transform_grid (controller->widget, filter_tool); + + g_signal_handlers_unblock_by_func (controller->widget, + gimp_filter_tool_transform_grid_changed, + controller); + } + break; + + case GIMP_CONTROLLER_TYPE_TRANSFORM_GRIDS: + { + g_signal_handlers_block_by_func (controller->widget, + gimp_filter_tool_transform_grids_changed, + controller); + + gimp_container_foreach ( + gimp_tool_widget_group_get_children ( + GIMP_TOOL_WIDGET_GROUP (controller->widget)), + (GFunc) gimp_filter_tool_reset_transform_grid, + filter_tool); + + g_signal_handlers_unblock_by_func (controller->widget, + gimp_filter_tool_transform_grids_changed, + controller); + } + break; + + default: + break; + } +} + + +/* private functions */ + +static Controller * +gimp_filter_tool_controller_new (void) +{ + return g_slice_new0 (Controller); +} + +static void +gimp_filter_tool_controller_free (Controller *controller) +{ + if (controller->widget) + { + g_signal_handlers_disconnect_by_data (controller->widget, controller); + + g_object_remove_weak_pointer (G_OBJECT (controller->widget), + (gpointer) &controller->widget); + } + + g_slice_free (Controller, controller); +} + +static void +gimp_filter_tool_set_line (Controller *controller, + GeglRectangle *area, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2) +{ + GimpTool *tool; + GimpDrawable *drawable; + + if (! controller->widget) + return; + + tool = GIMP_TOOL (controller->filter_tool); + drawable = tool->drawable; + + if (drawable) + { + gint off_x, off_y; + + gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); + + x1 += off_x + area->x; + y1 += off_y + area->y; + x2 += off_x + area->x; + y2 += off_y + area->y; + } + + g_signal_handlers_block_by_func (controller->widget, + gimp_filter_tool_line_changed, + controller); + + g_object_set (controller->widget, + "x1", x1, + "y1", y1, + "x2", x2, + "y2", y2, + NULL); + + g_signal_handlers_unblock_by_func (controller->widget, + gimp_filter_tool_line_changed, + controller); +} + +static void +gimp_filter_tool_line_changed (GimpToolWidget *widget, + Controller *controller) +{ + GimpFilterTool *filter_tool = controller->filter_tool; + GimpControllerLineCallback line_callback; + gdouble x1, y1, x2, y2; + gint off_x, off_y; + GeglRectangle area; + + line_callback = (GimpControllerLineCallback) controller->creator_callback; + + g_object_get (widget, + "x1", &x1, + "y1", &y1, + "x2", &x2, + "y2", &y2, + NULL); + + gimp_filter_tool_get_drawable_area (filter_tool, &off_x, &off_y, &area); + + x1 -= off_x + area.x; + y1 -= off_y + area.y; + x2 -= off_x + area.x; + y2 -= off_y + area.y; + + line_callback (controller->creator_data, + &area, x1, y1, x2, y2); +} + +static void +gimp_filter_tool_set_slider_line (Controller *controller, + GeglRectangle *area, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2, + const GimpControllerSlider *sliders, + gint n_sliders) +{ + GimpTool *tool; + GimpDrawable *drawable; + + if (! controller->widget) + return; + + tool = GIMP_TOOL (controller->filter_tool); + drawable = tool->drawable; + + if (drawable) + { + gint off_x, off_y; + + gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); + + x1 += off_x + area->x; + y1 += off_y + area->y; + x2 += off_x + area->x; + y2 += off_y + area->y; + } + + g_signal_handlers_block_by_func (controller->widget, + gimp_filter_tool_slider_line_changed, + controller); + + g_object_set (controller->widget, + "x1", x1, + "y1", y1, + "x2", x2, + "y2", y2, + NULL); + + gimp_tool_line_set_sliders (GIMP_TOOL_LINE (controller->widget), + sliders, n_sliders); + + g_signal_handlers_unblock_by_func (controller->widget, + gimp_filter_tool_slider_line_changed, + controller); +} + +static void +gimp_filter_tool_slider_line_changed (GimpToolWidget *widget, + Controller *controller) +{ + GimpFilterTool *filter_tool = controller->filter_tool; + GimpControllerSliderLineCallback slider_line_callback; + gdouble x1, y1, x2, y2; + const GimpControllerSlider *sliders; + gint n_sliders; + gint off_x, off_y; + GeglRectangle area; + + slider_line_callback = + (GimpControllerSliderLineCallback) controller->creator_callback; + + g_object_get (widget, + "x1", &x1, + "y1", &y1, + "x2", &x2, + "y2", &y2, + NULL); + + sliders = gimp_tool_line_get_sliders (GIMP_TOOL_LINE (controller->widget), + &n_sliders); + + gimp_filter_tool_get_drawable_area (filter_tool, &off_x, &off_y, &area); + + x1 -= off_x + area.x; + y1 -= off_y + area.y; + x2 -= off_x + area.x; + y2 -= off_y + area.y; + + slider_line_callback (controller->creator_data, + &area, x1, y1, x2, y2, sliders, n_sliders); +} + +static void +gimp_filter_tool_set_transform_grid (Controller *controller, + GeglRectangle *area, + const GimpMatrix3 *transform) +{ + GimpTool *tool; + GimpDrawable *drawable; + gdouble x1 = area->x; + gdouble y1 = area->y; + gdouble x2 = area->x + area->width; + gdouble y2 = area->y + area->height; + GimpMatrix3 matrix; + + if (! controller->widget) + return; + + tool = GIMP_TOOL (controller->filter_tool); + drawable = tool->drawable; + + if (drawable) + { + gint off_x, off_y; + + gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); + + x1 += off_x; + y1 += off_y; + x2 += off_x; + y2 += off_y; + } + + gimp_matrix3_identity (&matrix); + gimp_matrix3_translate (&matrix, -x1, -y1); + gimp_matrix3_mult (transform, &matrix); + gimp_matrix3_translate (&matrix, +x1, +y1); + + g_signal_handlers_block_by_func (controller->widget, + gimp_filter_tool_transform_grid_changed, + controller); + + g_object_set (controller->widget, + "transform", &matrix, + "x1", x1, + "y1", y1, + "x2", x2, + "y2", y2, + NULL); + + g_signal_handlers_unblock_by_func (controller->widget, + gimp_filter_tool_transform_grid_changed, + controller); +} + +static void +gimp_filter_tool_transform_grid_changed (GimpToolWidget *widget, + Controller *controller) +{ + GimpFilterTool *filter_tool = controller->filter_tool; + GimpControllerTransformGridCallback transform_grid_callback; + gint off_x, off_y; + GeglRectangle area; + GimpMatrix3 *transform; + GimpMatrix3 matrix; + + transform_grid_callback = + (GimpControllerTransformGridCallback) controller->creator_callback; + + g_object_get (widget, + "transform", &transform, + NULL); + + gimp_filter_tool_get_drawable_area (filter_tool, &off_x, &off_y, &area); + + gimp_matrix3_identity (&matrix); + gimp_matrix3_translate (&matrix, +(off_x + area.x), +(off_y + area.y)); + gimp_matrix3_mult (transform, &matrix); + gimp_matrix3_translate (&matrix, -(off_x + area.x), -(off_y + area.y)); + + transform_grid_callback (controller->creator_data, + &area, &matrix); + + g_free (transform); +} + +static void +gimp_filter_tool_set_transform_grids (Controller *controller, + GeglRectangle *area, + const GimpMatrix3 *transforms, + gint n_transforms) +{ + GimpTool *tool; + GimpDisplayShell *shell; + GimpDrawable *drawable; + GimpContainer *grids; + GimpToolWidget *grid = NULL; + gdouble x1 = area->x; + gdouble y1 = area->y; + gdouble x2 = area->x + area->width; + gdouble y2 = area->y + area->height; + GimpMatrix3 matrix; + gint i; + + if (! controller->widget) + return; + + tool = GIMP_TOOL (controller->filter_tool); + shell = gimp_display_get_shell (tool->display); + drawable = tool->drawable; + + g_signal_handlers_block_by_func (controller->widget, + gimp_filter_tool_transform_grids_changed, + controller); + + if (drawable) + { + gint off_x, off_y; + + gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); + + x1 += off_x; + y1 += off_y; + x2 += off_x; + y2 += off_y; + } + + grids = gimp_tool_widget_group_get_children ( + GIMP_TOOL_WIDGET_GROUP (controller->widget)); + + if (n_transforms > gimp_container_get_n_children (grids)) + { + gimp_matrix3_identity (&matrix); + + for (i = gimp_container_get_n_children (grids); i < n_transforms; i++) + { + gdouble pivot_x; + gdouble pivot_y; + + grid = gimp_tool_transform_grid_new (shell, &matrix, x1, y1, x2, y2); + + if (i > 0 && ! memcmp (&transforms[i], &transforms[i - 1], + sizeof (GimpMatrix3))) + { + g_object_get (gimp_container_get_last_child (grids), + "pivot-x", &pivot_x, + "pivot-y", &pivot_y, + NULL); + } + else + { + pivot_x = (x1 + x2) / 2.0; + pivot_y = (y1 + y2) / 2.0; + + gimp_matrix3_transform_point (&transforms[i], + pivot_x, pivot_y, + &pivot_x, &pivot_y); + } + + g_object_set (grid, + "pivot-x", pivot_x, + "pivot-y", pivot_y, + "inside-function", GIMP_TRANSFORM_FUNCTION_MOVE, + "outside-function", GIMP_TRANSFORM_FUNCTION_ROTATE, + "use-corner-handles", TRUE, + "use-perspective-handles", TRUE, + "use-side-handles", TRUE, + "use-shear-handles", TRUE, + "use-pivot-handle", TRUE, + NULL); + + gimp_container_add (grids, GIMP_OBJECT (grid)); + + g_object_unref (grid); + } + + gimp_tool_widget_set_focus (grid, TRUE); + } + else + { + while (gimp_container_get_n_children (grids) > n_transforms) + gimp_container_remove (grids, gimp_container_get_last_child (grids)); + } + + for (i = 0; i < n_transforms; i++) + { + gimp_matrix3_identity (&matrix); + gimp_matrix3_translate (&matrix, -x1, -y1); + gimp_matrix3_mult (&transforms[i], &matrix); + gimp_matrix3_translate (&matrix, +x1, +y1); + + g_object_set (gimp_container_get_child_by_index (grids, i), + "transform", &matrix, + "x1", x1, + "y1", y1, + "x2", x2, + "y2", y2, + NULL); + } + + g_signal_handlers_unblock_by_func (controller->widget, + gimp_filter_tool_transform_grids_changed, + controller); +} + +static void +gimp_filter_tool_transform_grids_changed (GimpToolWidget *widget, + Controller *controller) +{ + GimpFilterTool *filter_tool = controller->filter_tool; + GimpControllerTransformGridsCallback transform_grids_callback; + GimpContainer *grids; + gint off_x, off_y; + GeglRectangle area; + GimpMatrix3 *transforms; + gint n_transforms; + gint i; + + transform_grids_callback = + (GimpControllerTransformGridsCallback) controller->creator_callback; + + grids = gimp_tool_widget_group_get_children ( + GIMP_TOOL_WIDGET_GROUP (controller->widget)); + + gimp_filter_tool_get_drawable_area (filter_tool, &off_x, &off_y, &area); + + n_transforms = gimp_container_get_n_children (grids); + transforms = g_new (GimpMatrix3, n_transforms); + + for (i = 0; i < n_transforms; i++) + { + GimpMatrix3 *transform; + + g_object_get (gimp_container_get_child_by_index (grids, i), + "transform", &transform, + NULL); + + gimp_matrix3_identity (&transforms[i]); + gimp_matrix3_translate (&transforms[i], + +(off_x + area.x), +(off_y + area.y)); + gimp_matrix3_mult (transform, &transforms[i]); + gimp_matrix3_translate (&transforms[i], + -(off_x + area.x), -(off_y + area.y)); + + g_free (transform); + } + + transform_grids_callback (controller->creator_data, + &area, transforms, n_transforms); + + g_free (transforms); +} + +static void +gimp_filter_tool_set_gyroscope (Controller *controller, + GeglRectangle *area, + gdouble yaw, + gdouble pitch, + gdouble roll, + gdouble zoom, + gboolean invert) +{ + if (! controller->widget) + return; + + g_signal_handlers_block_by_func (controller->widget, + gimp_filter_tool_gyroscope_changed, + controller); + + g_object_set (controller->widget, + "yaw", yaw, + "pitch", pitch, + "roll", roll, + "zoom", zoom, + "invert", invert, + NULL); + + g_signal_handlers_unblock_by_func (controller->widget, + gimp_filter_tool_gyroscope_changed, + controller); +} + +static void +gimp_filter_tool_gyroscope_changed (GimpToolWidget *widget, + Controller *controller) +{ + GimpFilterTool *filter_tool = controller->filter_tool; + GimpControllerGyroscopeCallback gyroscope_callback; + gint off_x, off_y; + GeglRectangle area; + gdouble yaw; + gdouble pitch; + gdouble roll; + gdouble zoom; + gboolean invert; + + gyroscope_callback = + (GimpControllerGyroscopeCallback) controller->creator_callback; + + gimp_filter_tool_get_drawable_area (filter_tool, &off_x, &off_y, &area); + + g_object_get (widget, + "yaw", &yaw, + "pitch", &pitch, + "roll", &roll, + "zoom", &zoom, + "invert", &invert, + NULL); + + gyroscope_callback (controller->creator_data, + &area, yaw, pitch, roll, zoom, invert); +} + +static void +gimp_filter_tool_set_focus (Controller *controller, + GeglRectangle *area, + GimpLimitType type, + gdouble x, + gdouble y, + gdouble radius, + gdouble aspect_ratio, + gdouble angle, + gdouble inner_limit, + gdouble midpoint) +{ + GimpTool *tool; + GimpDrawable *drawable; + + if (! controller->widget) + return; + + tool = GIMP_TOOL (controller->filter_tool); + drawable = tool->drawable; + + if (drawable) + { + gint off_x, off_y; + + gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); + + x += off_x + area->x; + y += off_y + area->y; + } + + g_signal_handlers_block_by_func (controller->widget, + gimp_filter_tool_focus_changed, + controller); + + g_object_set (controller->widget, + "type", type, + "x", x, + "y", y, + "radius", radius, + "aspect-ratio", aspect_ratio, + "angle", angle, + "inner-limit", inner_limit, + "midpoint", midpoint, + NULL); + + g_signal_handlers_unblock_by_func (controller->widget, + gimp_filter_tool_focus_changed, + controller); +} + +static void +gimp_filter_tool_focus_changed (GimpToolWidget *widget, + Controller *controller) +{ + GimpFilterTool *filter_tool = controller->filter_tool; + GimpControllerFocusCallback focus_callback; + GimpLimitType type; + gdouble x, y; + gdouble radius; + gdouble aspect_ratio; + gdouble angle; + gdouble inner_limit; + gdouble midpoint; + gint off_x, off_y; + GeglRectangle area; + + focus_callback = (GimpControllerFocusCallback) controller->creator_callback; + + g_object_get (widget, + "type", &type, + "x", &x, + "y", &y, + "radius", &radius, + "aspect-ratio", &aspect_ratio, + "angle", &angle, + "inner-limit", &inner_limit, + "midpoint", &midpoint, + NULL); + + gimp_filter_tool_get_drawable_area (filter_tool, &off_x, &off_y, &area); + + x -= off_x + area.x; + y -= off_y + area.y; + + focus_callback (controller->creator_data, + &area, + type, + x, + y, + radius, + aspect_ratio, + angle, + inner_limit, + midpoint); +} -- cgit v1.2.3