/* 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 <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 "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);
}
