2010-06-15 05:25:08 +08:00
|
|
|
/* GIMP - The GNU Image Manipulation Program
|
2010-07-01 02:27:52 +08:00
|
|
|
*
|
|
|
|
* gimpcagetool.c
|
|
|
|
* Copyright (C) 2010 Michael Muré <batolettre@gmail.com>
|
2010-06-15 05:25:08 +08:00
|
|
|
*
|
|
|
|
* 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 <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include <string.h>
|
2011-01-10 21:55:38 +08:00
|
|
|
#include <stdlib.h>
|
2010-06-15 05:25:08 +08:00
|
|
|
|
2010-07-22 06:07:27 +08:00
|
|
|
#include <gegl.h>
|
2010-06-15 05:25:08 +08:00
|
|
|
#include <gtk/gtk.h>
|
2010-07-12 23:43:12 +08:00
|
|
|
#include <gdk/gdkkeysyms.h>
|
2010-06-15 05:25:08 +08:00
|
|
|
|
2010-11-05 05:14:58 +08:00
|
|
|
#include "libgimpbase/gimpbase.h"
|
2010-06-15 05:25:08 +08:00
|
|
|
#include "libgimpmath/gimpmath.h"
|
|
|
|
#include "libgimpwidgets/gimpwidgets.h"
|
|
|
|
|
|
|
|
#include "tools-types.h"
|
|
|
|
|
2010-11-05 05:14:58 +08:00
|
|
|
#include "base/tile-manager.h"
|
2010-08-15 07:29:34 +08:00
|
|
|
|
2010-07-22 06:07:27 +08:00
|
|
|
#include "core/gimp.h"
|
2010-11-04 06:10:22 +08:00
|
|
|
#include "core/gimpchannel.h"
|
2010-08-07 21:10:23 +08:00
|
|
|
#include "core/gimpdrawable-shadow.h"
|
2010-11-04 06:10:22 +08:00
|
|
|
#include "core/gimpimage.h"
|
2010-08-10 05:33:11 +08:00
|
|
|
#include "core/gimpimagemap.h"
|
2010-11-04 06:10:22 +08:00
|
|
|
#include "core/gimplayer.h"
|
|
|
|
#include "core/gimpprogress.h"
|
2010-11-05 05:14:58 +08:00
|
|
|
#include "core/gimpprojection.h"
|
|
|
|
|
|
|
|
#include "gegl/gimpcageconfig.h"
|
|
|
|
|
|
|
|
#include "widgets/gimphelp-ids.h"
|
2010-11-10 02:35:54 +08:00
|
|
|
#include "widgets/gimpwidgets-utils.h"
|
2010-08-14 00:25:48 +08:00
|
|
|
|
2010-11-10 02:35:54 +08:00
|
|
|
#include "display/gimpcanvasprogress.h"
|
2010-08-14 00:25:48 +08:00
|
|
|
#include "display/gimpdisplay.h"
|
|
|
|
#include "display/gimpdisplayshell.h"
|
2010-11-10 02:35:54 +08:00
|
|
|
#include "display/gimpdisplayshell-items.h"
|
2010-08-14 00:25:48 +08:00
|
|
|
#include "display/gimpdisplayshell-transform.h"
|
|
|
|
|
2010-06-15 05:25:08 +08:00
|
|
|
#include "gimpcagetool.h"
|
2010-07-01 02:27:52 +08:00
|
|
|
#include "gimpcageoptions.h"
|
2010-11-05 05:14:58 +08:00
|
|
|
#include "gimptoolcontrol.h"
|
2010-06-15 05:25:08 +08:00
|
|
|
|
|
|
|
#include "gimp-intl.h"
|
|
|
|
|
2010-11-05 05:14:58 +08:00
|
|
|
|
|
|
|
static void gimp_cage_tool_finalize (GObject *object);
|
|
|
|
static void gimp_cage_tool_start (GimpCageTool *ct,
|
|
|
|
GimpDisplay *display);
|
|
|
|
static void gimp_cage_tool_halt (GimpCageTool *ct);
|
2011-01-22 07:44:35 +08:00
|
|
|
static void gimp_cage_tool_options_notify (GimpTool *tool,
|
|
|
|
GimpToolOptions *options,
|
|
|
|
const GParamSpec *pspec);
|
2010-11-05 05:14:58 +08:00
|
|
|
static void gimp_cage_tool_button_press (GimpTool *tool,
|
|
|
|
const GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpButtonPressType press_type,
|
|
|
|
GimpDisplay *display);
|
|
|
|
static void gimp_cage_tool_button_release (GimpTool *tool,
|
|
|
|
const GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpButtonReleaseType release_type,
|
|
|
|
GimpDisplay *display);
|
|
|
|
static gboolean gimp_cage_tool_key_press (GimpTool *tool,
|
|
|
|
GdkEventKey *kevent,
|
|
|
|
GimpDisplay *display);
|
|
|
|
static void gimp_cage_tool_motion (GimpTool *tool,
|
|
|
|
const GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *display);
|
|
|
|
static void gimp_cage_tool_control (GimpTool *tool,
|
|
|
|
GimpToolAction action,
|
|
|
|
GimpDisplay *display);
|
|
|
|
static void gimp_cage_tool_cursor_update (GimpTool *tool,
|
|
|
|
const GimpCoords *coords,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *display);
|
|
|
|
static void gimp_cage_tool_oper_update (GimpTool *tool,
|
|
|
|
const GimpCoords *coords,
|
|
|
|
GdkModifierType state,
|
|
|
|
gboolean proximity,
|
|
|
|
GimpDisplay *display);
|
|
|
|
|
|
|
|
static void gimp_cage_tool_draw (GimpDrawTool *draw_tool);
|
|
|
|
|
2011-01-02 23:15:55 +08:00
|
|
|
static gint gimp_cage_tool_is_on_handle (GimpCageTool *ct,
|
2010-11-05 05:38:41 +08:00
|
|
|
GimpDrawTool *draw_tool,
|
|
|
|
GimpDisplay *display,
|
|
|
|
gdouble x,
|
|
|
|
gdouble y,
|
|
|
|
gint handle_size);
|
2010-11-05 05:14:58 +08:00
|
|
|
|
|
|
|
static void gimp_cage_tool_remove_last_handle (GimpCageTool *ct);
|
|
|
|
static void gimp_cage_tool_compute_coef (GimpCageTool *ct,
|
|
|
|
GimpDisplay *display);
|
2010-11-06 02:10:03 +08:00
|
|
|
static void gimp_cage_tool_create_image_map (GimpCageTool *ct,
|
2010-11-06 02:42:42 +08:00
|
|
|
GimpDrawable *drawable);
|
2010-11-06 02:10:03 +08:00
|
|
|
static void gimp_cage_tool_image_map_flush (GimpImageMap *image_map,
|
|
|
|
GimpTool *tool);
|
2010-12-17 21:49:37 +08:00
|
|
|
static void gimp_cage_tool_image_map_update (GimpCageTool *ct);
|
2010-11-05 05:14:58 +08:00
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
static void gimp_cage_tool_create_render_node (GimpCageTool *ct);
|
|
|
|
static void gimp_cage_tool_render_node_update (GimpCageTool *ct);
|
2010-10-07 05:37:04 +08:00
|
|
|
|
2010-07-17 19:33:48 +08:00
|
|
|
G_DEFINE_TYPE (GimpCageTool, gimp_cage_tool, GIMP_TYPE_DRAW_TOOL)
|
2010-06-15 05:25:08 +08:00
|
|
|
|
|
|
|
#define parent_class gimp_cage_tool_parent_class
|
|
|
|
|
2010-12-17 21:49:37 +08:00
|
|
|
enum
|
|
|
|
{
|
|
|
|
CAGE_STATE_INIT,
|
|
|
|
CAGE_STATE_WAIT,
|
|
|
|
CAGE_STATE_MOVE_HANDLE,
|
|
|
|
CAGE_STATE_CLOSING,
|
|
|
|
DEFORM_STATE_WAIT,
|
|
|
|
DEFORM_STATE_MOVE_HANDLE,
|
2011-01-10 21:55:38 +08:00
|
|
|
DEFORM_STATE_SELECTING
|
2010-12-17 21:49:37 +08:00
|
|
|
};
|
2010-06-15 05:25:08 +08:00
|
|
|
|
|
|
|
void
|
|
|
|
gimp_cage_tool_register (GimpToolRegisterCallback callback,
|
2010-11-05 05:38:41 +08:00
|
|
|
gpointer data)
|
2010-06-15 05:25:08 +08:00
|
|
|
{
|
2010-11-05 05:14:58 +08:00
|
|
|
(* callback) (GIMP_TYPE_CAGE_TOOL,
|
|
|
|
GIMP_TYPE_CAGE_OPTIONS,
|
|
|
|
gimp_cage_options_gui,
|
|
|
|
0,
|
2010-06-15 05:25:08 +08:00
|
|
|
"gimp-cage-tool",
|
2010-07-01 02:27:52 +08:00
|
|
|
_("Cage Transform"),
|
|
|
|
_("Cage Transform: Deform a selection with a cage"),
|
2010-11-05 04:44:31 +08:00
|
|
|
N_("_Cage Transform"), "<shift>G",
|
2010-07-01 02:27:52 +08:00
|
|
|
NULL, GIMP_HELP_TOOL_CAGE,
|
|
|
|
GIMP_STOCK_TOOL_CAGE,
|
2010-06-15 05:25:08 +08:00
|
|
|
data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gimp_cage_tool_class_init (GimpCageToolClass *klass)
|
|
|
|
{
|
2010-11-05 05:14:58 +08:00
|
|
|
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->finalize = gimp_cage_tool_finalize;
|
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
tool_class->options_notify = gimp_cage_tool_options_notify;
|
2010-11-05 05:14:58 +08:00
|
|
|
tool_class->button_press = gimp_cage_tool_button_press;
|
|
|
|
tool_class->button_release = gimp_cage_tool_button_release;
|
|
|
|
tool_class->key_press = gimp_cage_tool_key_press;
|
|
|
|
tool_class->motion = gimp_cage_tool_motion;
|
|
|
|
tool_class->control = gimp_cage_tool_control;
|
|
|
|
tool_class->cursor_update = gimp_cage_tool_cursor_update;
|
|
|
|
tool_class->oper_update = gimp_cage_tool_oper_update;
|
|
|
|
|
|
|
|
draw_tool_class->draw = gimp_cage_tool_draw;
|
2010-06-15 05:25:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gimp_cage_tool_init (GimpCageTool *self)
|
|
|
|
{
|
2010-11-06 06:49:48 +08:00
|
|
|
GimpTool *tool = GIMP_TOOL (self);
|
|
|
|
|
2010-11-21 21:13:58 +08:00
|
|
|
gimp_tool_control_set_dirty_mask (tool->control,
|
|
|
|
GIMP_DIRTY_IMAGE |
|
|
|
|
GIMP_DIRTY_IMAGE_STRUCTURE |
|
|
|
|
GIMP_DIRTY_DRAWABLE |
|
|
|
|
GIMP_DIRTY_SELECTION);
|
|
|
|
gimp_tool_control_set_wants_click (tool->control, TRUE);
|
|
|
|
gimp_tool_control_set_tool_cursor (tool->control,
|
|
|
|
GIMP_TOOL_CURSOR_PERSPECTIVE);
|
|
|
|
|
2010-11-06 06:49:48 +08:00
|
|
|
self->config = g_object_new (GIMP_TYPE_CAGE_CONFIG, NULL);
|
|
|
|
self->hovering_handle = -1;
|
|
|
|
self->cage_complete = FALSE;
|
2010-12-17 21:49:37 +08:00
|
|
|
self->tool_state = CAGE_STATE_INIT;
|
2010-11-06 06:49:48 +08:00
|
|
|
|
|
|
|
self->coef = NULL;
|
2011-01-22 07:44:35 +08:00
|
|
|
self->render_node = NULL;
|
|
|
|
self->coef_node = NULL;
|
|
|
|
self->cage_node = NULL;
|
2010-11-06 06:49:48 +08:00
|
|
|
self->image_map = NULL;
|
2010-12-17 21:49:37 +08:00
|
|
|
|
|
|
|
gimp_tool_control_set_wants_click (tool->control, TRUE);
|
|
|
|
gimp_tool_control_set_tool_cursor (tool->control,
|
|
|
|
GIMP_TOOL_CURSOR_PERSPECTIVE);
|
2010-06-15 05:25:08 +08:00
|
|
|
}
|
|
|
|
|
2010-07-01 02:27:52 +08:00
|
|
|
static void
|
|
|
|
gimp_cage_tool_finalize (GObject *object)
|
|
|
|
{
|
2010-11-05 05:14:58 +08:00
|
|
|
GimpCageTool *ct = GIMP_CAGE_TOOL (object);
|
2010-07-01 02:27:52 +08:00
|
|
|
|
2010-08-12 02:27:32 +08:00
|
|
|
gimp_cage_tool_halt (ct);
|
|
|
|
|
2010-07-01 02:27:52 +08:00
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
|
|
}
|
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
static void
|
|
|
|
gimp_cage_tool_control (GimpTool *tool,
|
2010-11-05 05:14:58 +08:00
|
|
|
GimpToolAction action,
|
|
|
|
GimpDisplay *display)
|
2010-09-03 03:28:06 +08:00
|
|
|
{
|
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case GIMP_TOOL_ACTION_PAUSE:
|
|
|
|
case GIMP_TOOL_ACTION_RESUME:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GIMP_TOOL_ACTION_HALT:
|
|
|
|
gimp_cage_tool_halt (GIMP_CAGE_TOOL (tool));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
|
|
|
|
}
|
|
|
|
|
2010-07-12 23:43:12 +08:00
|
|
|
static void
|
2010-11-05 05:14:58 +08:00
|
|
|
gimp_cage_tool_start (GimpCageTool *ct,
|
|
|
|
GimpDisplay *display)
|
2010-07-12 23:43:12 +08:00
|
|
|
{
|
2010-11-05 16:49:03 +08:00
|
|
|
GimpTool *tool = GIMP_TOOL (ct);
|
|
|
|
GimpImage *image = gimp_display_get_image (display);
|
|
|
|
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
|
2010-11-05 05:14:58 +08:00
|
|
|
gint off_x;
|
|
|
|
gint off_y;
|
2010-07-12 23:43:12 +08:00
|
|
|
|
|
|
|
gimp_tool_control_activate (tool->control);
|
|
|
|
|
|
|
|
tool->display = display;
|
2010-08-12 02:27:32 +08:00
|
|
|
|
|
|
|
if (ct->config)
|
2010-09-03 03:28:06 +08:00
|
|
|
{
|
|
|
|
g_object_unref (ct->config);
|
2010-11-06 02:59:48 +08:00
|
|
|
ct->config = NULL;
|
2010-09-03 03:28:06 +08:00
|
|
|
}
|
2010-08-14 00:25:48 +08:00
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
if (ct->coef)
|
|
|
|
{
|
|
|
|
gegl_buffer_destroy (ct->coef);
|
|
|
|
ct->dirty_coef = TRUE;
|
|
|
|
ct->coef = NULL;
|
|
|
|
}
|
|
|
|
|
2010-08-14 00:25:48 +08:00
|
|
|
if (ct->image_map)
|
2010-09-03 03:28:06 +08:00
|
|
|
{
|
|
|
|
gimp_image_map_abort (ct->image_map);
|
|
|
|
g_object_unref (ct->image_map);
|
2010-11-06 02:59:48 +08:00
|
|
|
ct->image_map = NULL;
|
2010-09-03 03:28:06 +08:00
|
|
|
}
|
2010-08-14 00:25:48 +08:00
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
if (ct->render_node)
|
|
|
|
{
|
|
|
|
g_object_unref (ct->render_node);
|
|
|
|
ct->render_node = NULL;
|
|
|
|
ct->coef_node = NULL;
|
|
|
|
ct->cage_node = NULL;
|
|
|
|
}
|
|
|
|
|
2010-11-06 06:49:48 +08:00
|
|
|
ct->config = g_object_new (GIMP_TYPE_CAGE_CONFIG, NULL);
|
|
|
|
ct->hovering_handle = -1;
|
|
|
|
ct->cage_complete = FALSE;
|
2010-12-17 21:49:37 +08:00
|
|
|
ct->tool_state = CAGE_STATE_INIT;
|
2010-11-04 06:10:22 +08:00
|
|
|
|
2010-11-05 05:14:58 +08:00
|
|
|
/* Setting up cage offset to convert the cage point coords to
|
|
|
|
* drawable coords
|
|
|
|
*/
|
|
|
|
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
|
2010-11-04 06:10:22 +08:00
|
|
|
|
2011-01-02 23:15:55 +08:00
|
|
|
ct->offset_x = off_x;
|
|
|
|
ct->offset_y = off_y;
|
2010-11-04 06:10:22 +08:00
|
|
|
|
2010-11-05 16:49:03 +08:00
|
|
|
gimp_draw_tool_start (GIMP_DRAW_TOOL (ct), display);
|
2010-07-12 23:43:12 +08:00
|
|
|
}
|
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
static void
|
|
|
|
gimp_cage_tool_options_notify (GimpTool *tool,
|
|
|
|
GimpToolOptions *options,
|
|
|
|
const GParamSpec *pspec)
|
|
|
|
{
|
|
|
|
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
|
|
|
|
|
|
|
|
GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
|
|
|
|
|
|
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
|
|
|
|
|
|
|
|
if (strcmp (pspec->name, "cage-mode") == 0)
|
|
|
|
{
|
|
|
|
GimpCageMode mode;
|
|
|
|
|
|
|
|
g_object_get (options,
|
|
|
|
"cage-mode", &mode,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
if (mode == GIMP_CAGE_MODE_DEFORM)
|
|
|
|
/* switch to deform mode */
|
|
|
|
{
|
|
|
|
ct->cage_complete = TRUE;
|
|
|
|
gimp_cage_config_reset_displacement (ct->config);
|
|
|
|
gimp_cage_config_reverse_cage_if_needed (ct->config);
|
|
|
|
gimp_tool_push_status (tool, tool->display, _("Press ENTER to commit the transform"));
|
|
|
|
ct->tool_state = DEFORM_STATE_WAIT;
|
|
|
|
|
|
|
|
if (ct->dirty_coef)
|
|
|
|
{
|
|
|
|
gimp_cage_tool_compute_coef (ct, tool->display);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ct->render_node)
|
|
|
|
{
|
|
|
|
gimp_cage_tool_create_render_node (ct);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ct->image_map)
|
|
|
|
{
|
|
|
|
GimpImage *image = gimp_display_get_image (tool->display);
|
|
|
|
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
|
|
|
|
gimp_cage_tool_create_image_map (ct, drawable);
|
|
|
|
}
|
|
|
|
|
|
|
|
gimp_cage_tool_image_map_update (ct);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
/* switch to edit mode */
|
|
|
|
{
|
|
|
|
gimp_image_map_clear (ct->image_map);
|
|
|
|
gimp_image_flush (gimp_display_get_image (tool->display));
|
|
|
|
gimp_tool_pop_status (tool, tool->display);
|
|
|
|
ct->tool_state = CAGE_STATE_WAIT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (strcmp (pspec->name, "fill-plain-color") == 0)
|
|
|
|
{
|
|
|
|
gimp_cage_tool_render_node_update (ct);
|
|
|
|
gimp_cage_tool_image_map_update (ct);
|
|
|
|
}
|
|
|
|
|
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
|
|
|
|
}
|
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
static gboolean
|
|
|
|
gimp_cage_tool_key_press (GimpTool *tool,
|
|
|
|
GdkEventKey *kevent,
|
|
|
|
GimpDisplay *display)
|
2010-07-01 02:27:52 +08:00
|
|
|
{
|
2010-11-05 05:14:58 +08:00
|
|
|
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
|
2010-07-12 23:43:12 +08:00
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
switch (kevent->keyval)
|
|
|
|
{
|
|
|
|
case GDK_BackSpace:
|
2010-12-17 21:49:37 +08:00
|
|
|
if (! ct->cage_complete && ct->tool_state == CAGE_STATE_WAIT)
|
2010-11-06 06:49:48 +08:00
|
|
|
gimp_cage_tool_remove_last_handle (ct);
|
2010-09-03 03:28:06 +08:00
|
|
|
return TRUE;
|
2010-07-12 23:43:12 +08:00
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
case GDK_Return:
|
|
|
|
case GDK_KP_Enter:
|
|
|
|
case GDK_ISO_Enter:
|
2010-12-17 21:49:37 +08:00
|
|
|
if (ct->tool_state == DEFORM_STATE_WAIT)
|
2010-11-05 05:14:58 +08:00
|
|
|
{
|
2010-11-06 02:10:03 +08:00
|
|
|
gimp_tool_control_set_preserve (tool->control, TRUE);
|
|
|
|
|
|
|
|
gimp_image_map_commit (ct->image_map);
|
2010-11-05 05:14:58 +08:00
|
|
|
g_object_unref (ct->image_map);
|
|
|
|
ct->image_map = NULL;
|
|
|
|
|
2010-11-06 02:10:03 +08:00
|
|
|
gimp_tool_control_set_preserve (tool->control, FALSE);
|
|
|
|
|
|
|
|
gimp_image_flush (gimp_display_get_image (display));
|
|
|
|
|
|
|
|
gimp_cage_tool_halt (ct);
|
2010-11-05 05:14:58 +08:00
|
|
|
}
|
2010-09-03 03:28:06 +08:00
|
|
|
return TRUE;
|
2010-07-01 02:27:52 +08:00
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
case GDK_Escape:
|
|
|
|
gimp_cage_tool_halt (ct);
|
|
|
|
return TRUE;
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2010-08-14 00:25:48 +08:00
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
return FALSE;
|
|
|
|
}
|
2010-09-03 01:11:34 +08:00
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
static void
|
|
|
|
gimp_cage_tool_motion (GimpTool *tool,
|
2010-11-05 05:14:58 +08:00
|
|
|
const GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *display)
|
2010-09-03 03:28:06 +08:00
|
|
|
{
|
2010-12-17 21:49:37 +08:00
|
|
|
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
|
|
|
|
GimpCageOptions *options = GIMP_CAGE_TOOL_GET_OPTIONS (ct);
|
2010-08-14 00:25:48 +08:00
|
|
|
|
2010-11-06 06:49:48 +08:00
|
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
|
2010-08-14 00:25:48 +08:00
|
|
|
|
2010-11-06 06:49:48 +08:00
|
|
|
ct->cursor_x = coords->x;
|
|
|
|
ct->cursor_y = coords->y;
|
2010-08-14 00:25:48 +08:00
|
|
|
|
2010-12-17 21:49:37 +08:00
|
|
|
switch (ct->tool_state)
|
|
|
|
{
|
|
|
|
case CAGE_STATE_MOVE_HANDLE:
|
2011-01-22 07:44:35 +08:00
|
|
|
case CAGE_STATE_CLOSING:
|
2010-12-17 21:49:37 +08:00
|
|
|
case DEFORM_STATE_MOVE_HANDLE:
|
2011-01-02 23:15:55 +08:00
|
|
|
gimp_cage_config_add_displacement (ct->config,
|
|
|
|
options->cage_mode,
|
|
|
|
ct->cursor_x - ct->movement_start_x,
|
|
|
|
ct->cursor_y - ct->movement_start_y);
|
2010-12-17 21:49:37 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-11-06 06:49:48 +08:00
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
|
2010-07-01 02:27:52 +08:00
|
|
|
}
|
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
static void
|
2010-11-05 05:14:58 +08:00
|
|
|
gimp_cage_tool_oper_update (GimpTool *tool,
|
|
|
|
const GimpCoords *coords,
|
|
|
|
GdkModifierType state,
|
|
|
|
gboolean proximity,
|
|
|
|
GimpDisplay *display)
|
2010-09-03 03:28:06 +08:00
|
|
|
{
|
2010-11-06 06:49:48 +08:00
|
|
|
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
|
|
|
|
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
|
|
|
|
GimpCageConfig *config = ct->config;
|
|
|
|
gint handle = -1;
|
2010-09-03 03:28:06 +08:00
|
|
|
|
|
|
|
if (config)
|
2011-01-02 23:15:55 +08:00
|
|
|
handle = gimp_cage_tool_is_on_handle (ct,
|
2010-11-06 06:49:48 +08:00
|
|
|
draw_tool,
|
|
|
|
display,
|
|
|
|
coords->x,
|
|
|
|
coords->y,
|
2010-11-09 05:37:00 +08:00
|
|
|
GIMP_TOOL_HANDLE_SIZE_CIRCLE);
|
2010-09-03 03:28:06 +08:00
|
|
|
|
2010-11-06 06:49:48 +08:00
|
|
|
gimp_draw_tool_pause (draw_tool);
|
2010-09-03 03:28:06 +08:00
|
|
|
|
2010-11-06 06:49:48 +08:00
|
|
|
ct->hovering_handle = handle;
|
|
|
|
ct->cursor_x = coords->x;
|
|
|
|
ct->cursor_y = coords->y;
|
|
|
|
|
|
|
|
gimp_draw_tool_resume (draw_tool);
|
2010-09-03 03:28:06 +08:00
|
|
|
}
|
|
|
|
|
2010-08-15 07:29:34 +08:00
|
|
|
static void
|
2010-11-05 05:14:58 +08:00
|
|
|
gimp_cage_tool_button_press (GimpTool *tool,
|
|
|
|
const GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpButtonPressType press_type,
|
|
|
|
GimpDisplay *display)
|
2010-07-12 23:43:12 +08:00
|
|
|
{
|
2010-12-17 21:49:37 +08:00
|
|
|
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
|
|
|
|
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
|
|
|
|
gint handle = -1;
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-07-12 23:43:12 +08:00
|
|
|
if (display != tool->display)
|
2010-11-06 06:49:48 +08:00
|
|
|
gimp_cage_tool_start (ct, display);
|
2010-08-15 07:29:34 +08:00
|
|
|
|
2010-12-17 21:49:37 +08:00
|
|
|
if (ct->config)
|
2011-01-02 23:15:55 +08:00
|
|
|
handle = gimp_cage_tool_is_on_handle (ct,
|
2010-12-17 21:49:37 +08:00
|
|
|
draw_tool,
|
|
|
|
display,
|
|
|
|
coords->x,
|
|
|
|
coords->y,
|
|
|
|
GIMP_TOOL_HANDLE_SIZE_CIRCLE);
|
2011-01-02 23:15:55 +08:00
|
|
|
ct->movement_start_x = coords->x;
|
|
|
|
ct->movement_start_y = coords->y;
|
2010-12-17 21:49:37 +08:00
|
|
|
|
|
|
|
switch (ct->tool_state)
|
|
|
|
{
|
|
|
|
case CAGE_STATE_INIT:
|
|
|
|
/* No handle yet, we add the first one and swith the tool to moving handle state. */
|
|
|
|
gimp_cage_config_add_cage_point (ct->config,
|
2011-01-11 22:34:28 +08:00
|
|
|
coords->x - ct->offset_x,
|
|
|
|
coords->y - ct->offset_y);
|
2011-01-02 23:15:55 +08:00
|
|
|
gimp_cage_config_select_point (ct->config, 0);
|
2010-12-17 21:49:37 +08:00
|
|
|
ct->tool_state = CAGE_STATE_MOVE_HANDLE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CAGE_STATE_WAIT:
|
|
|
|
if (ct->cage_complete == FALSE)
|
|
|
|
{
|
|
|
|
if (handle == -1)
|
|
|
|
/* User clicked on the background, we add a new handle and move it */
|
|
|
|
{
|
|
|
|
gimp_cage_config_add_cage_point (ct->config,
|
2011-01-11 22:34:28 +08:00
|
|
|
coords->x - ct->offset_x,
|
|
|
|
coords->y - ct->offset_y);
|
2011-01-02 23:15:55 +08:00
|
|
|
gimp_cage_config_select_point (ct->config, ct->config->n_cage_vertices - 1);
|
2010-12-17 21:49:37 +08:00
|
|
|
ct->tool_state = CAGE_STATE_MOVE_HANDLE;
|
|
|
|
}
|
|
|
|
if (handle == 0 && ct->config->n_cage_vertices > 2)
|
|
|
|
/* User clicked on the first handle, we wait for release for closing the cage and switching to deform if possible */
|
|
|
|
{
|
2011-01-02 23:15:55 +08:00
|
|
|
gimp_cage_config_select_point (ct->config, 0);
|
2010-12-17 21:49:37 +08:00
|
|
|
ct->tool_state = CAGE_STATE_CLOSING;
|
|
|
|
}
|
|
|
|
if (handle > 0)
|
|
|
|
/* User clicked on a handle, so we move it */
|
|
|
|
{
|
2011-01-02 23:15:55 +08:00
|
|
|
if (state & GDK_SHIFT_MASK)
|
|
|
|
/* Multiple selection */
|
|
|
|
{
|
|
|
|
gimp_cage_config_toggle_point_selection (ct->config, handle);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
/* New selection */
|
|
|
|
{
|
|
|
|
if (! ct->config->cage_points[handle].selected)
|
|
|
|
{
|
|
|
|
gimp_cage_config_select_point (ct->config, handle);
|
|
|
|
}
|
|
|
|
}
|
2010-12-17 21:49:37 +08:00
|
|
|
ct->tool_state = CAGE_STATE_MOVE_HANDLE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else /* Cage already closed */
|
|
|
|
{
|
|
|
|
if (handle >= 0)
|
|
|
|
/* User clicked on a handle, so we move it */
|
|
|
|
{
|
2011-01-02 23:15:55 +08:00
|
|
|
if (state & GDK_SHIFT_MASK)
|
|
|
|
/* Multiple selection */
|
|
|
|
{
|
|
|
|
gimp_cage_config_toggle_point_selection (ct->config, handle);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
/* New selection */
|
|
|
|
{
|
|
|
|
if (! ct->config->cage_points[handle].selected)
|
|
|
|
{
|
|
|
|
gimp_cage_config_select_point (ct->config, handle);
|
|
|
|
}
|
|
|
|
}
|
2010-12-17 21:49:37 +08:00
|
|
|
ct->tool_state = CAGE_STATE_MOVE_HANDLE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DEFORM_STATE_WAIT:
|
2011-01-10 21:55:38 +08:00
|
|
|
if (handle == -1)
|
|
|
|
/* User clicked on the background, we start a rubber band selection */
|
|
|
|
{
|
|
|
|
ct->selection_start_x = coords->x;
|
|
|
|
ct->selection_start_y = coords->y;
|
|
|
|
ct->tool_state = DEFORM_STATE_SELECTING;
|
|
|
|
}
|
2010-12-17 21:49:37 +08:00
|
|
|
if (handle >= 0)
|
|
|
|
/* User clicked on a handle, so we move it */
|
|
|
|
{
|
2011-01-02 23:15:55 +08:00
|
|
|
if (state & GDK_SHIFT_MASK)
|
|
|
|
/* Multiple selection */
|
|
|
|
{
|
|
|
|
gimp_cage_config_toggle_point_selection (ct->config, handle);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
/* New selection */
|
|
|
|
{
|
|
|
|
if (! ct->config->cage_points[handle].selected)
|
|
|
|
{
|
|
|
|
gimp_cage_config_select_point (ct->config, handle);
|
|
|
|
}
|
|
|
|
}
|
2010-12-17 21:49:37 +08:00
|
|
|
ct->tool_state = DEFORM_STATE_MOVE_HANDLE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2010-07-12 23:43:12 +08:00
|
|
|
}
|
|
|
|
|
2010-08-15 07:29:34 +08:00
|
|
|
void
|
2010-07-12 23:43:12 +08:00
|
|
|
gimp_cage_tool_button_release (GimpTool *tool,
|
|
|
|
const GimpCoords *coords,
|
|
|
|
guint32 time,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpButtonReleaseType release_type,
|
|
|
|
GimpDisplay *display)
|
2010-08-12 02:27:32 +08:00
|
|
|
{
|
2010-11-06 06:49:48 +08:00
|
|
|
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
|
2011-01-22 07:44:35 +08:00
|
|
|
GimpCageOptions *options = GIMP_CAGE_TOOL_GET_OPTIONS (ct);
|
2010-11-06 06:49:48 +08:00
|
|
|
|
|
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (ct));
|
|
|
|
|
2010-12-17 21:49:37 +08:00
|
|
|
if (state & GDK_BUTTON3_MASK)
|
2011-01-02 23:15:55 +08:00
|
|
|
/* Cancelling */
|
2010-11-05 05:14:58 +08:00
|
|
|
{
|
2010-12-17 21:49:37 +08:00
|
|
|
switch(ct->tool_state)
|
2010-11-06 06:49:48 +08:00
|
|
|
{
|
2010-12-17 21:49:37 +08:00
|
|
|
case CAGE_STATE_CLOSING:
|
|
|
|
ct->tool_state = CAGE_STATE_WAIT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CAGE_STATE_MOVE_HANDLE:
|
|
|
|
gimp_cage_config_remove_last_cage_point (ct->config);
|
|
|
|
ct->tool_state = CAGE_STATE_WAIT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DEFORM_STATE_MOVE_HANDLE:
|
|
|
|
gimp_cage_tool_image_map_update (ct);
|
|
|
|
ct->tool_state = DEFORM_STATE_WAIT;
|
|
|
|
break;
|
2011-01-10 21:55:38 +08:00
|
|
|
|
|
|
|
case DEFORM_STATE_SELECTING:
|
|
|
|
ct->tool_state = DEFORM_STATE_WAIT;
|
|
|
|
break;
|
2010-11-06 06:49:48 +08:00
|
|
|
}
|
2011-01-02 23:15:55 +08:00
|
|
|
gimp_cage_config_reset_displacement (ct->config);
|
2010-11-06 06:49:48 +08:00
|
|
|
}
|
|
|
|
else
|
2011-01-02 23:15:55 +08:00
|
|
|
/* Normal release */
|
2010-11-06 06:49:48 +08:00
|
|
|
{
|
2010-12-17 21:49:37 +08:00
|
|
|
switch(ct->tool_state)
|
2010-11-06 06:49:48 +08:00
|
|
|
{
|
2010-12-17 21:49:37 +08:00
|
|
|
case CAGE_STATE_CLOSING:
|
2011-01-22 07:44:35 +08:00
|
|
|
ct->dirty_coef = TRUE;
|
|
|
|
gimp_cage_config_commit_displacement (ct->config);
|
|
|
|
g_object_set (options, "cage-mode", GIMP_CAGE_MODE_DEFORM, NULL);
|
2010-12-17 21:49:37 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CAGE_STATE_MOVE_HANDLE:
|
2011-01-22 07:44:35 +08:00
|
|
|
ct->dirty_coef = TRUE;
|
2010-12-17 21:49:37 +08:00
|
|
|
ct->tool_state = CAGE_STATE_WAIT;
|
2011-01-22 07:44:35 +08:00
|
|
|
gimp_cage_config_commit_displacement (ct->config);
|
2010-12-17 21:49:37 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DEFORM_STATE_MOVE_HANDLE:
|
|
|
|
ct->tool_state = DEFORM_STATE_WAIT;
|
2011-01-22 07:44:35 +08:00
|
|
|
gimp_cage_config_commit_displacement (ct->config);
|
2010-12-17 21:49:37 +08:00
|
|
|
gimp_cage_tool_image_map_update (ct);
|
|
|
|
break;
|
2011-01-10 21:55:38 +08:00
|
|
|
|
|
|
|
case DEFORM_STATE_SELECTING:
|
|
|
|
{
|
2011-01-11 01:24:27 +08:00
|
|
|
GeglRectangle area = {MIN(ct->selection_start_x, coords->x) - ct->offset_x,
|
|
|
|
MIN(ct->selection_start_y, coords->y) - ct->offset_y,
|
2011-01-10 21:55:38 +08:00
|
|
|
abs (ct->selection_start_x - coords->x),
|
|
|
|
abs (ct->selection_start_y - coords->y)};
|
|
|
|
|
|
|
|
if (state & GDK_SHIFT_MASK)
|
|
|
|
{
|
|
|
|
gimp_cage_config_select_add_area (ct->config, GIMP_CAGE_MODE_DEFORM, area);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
gimp_cage_config_select_area (ct->config, GIMP_CAGE_MODE_DEFORM, area);
|
|
|
|
}
|
|
|
|
ct->tool_state = DEFORM_STATE_WAIT;
|
|
|
|
}
|
|
|
|
break;
|
2010-11-06 06:49:48 +08:00
|
|
|
}
|
2010-12-17 21:49:37 +08:00
|
|
|
}
|
2010-11-06 06:49:48 +08:00
|
|
|
|
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
|
2010-07-12 23:43:12 +08:00
|
|
|
}
|
2010-07-01 02:27:52 +08:00
|
|
|
|
2010-07-12 23:43:12 +08:00
|
|
|
static void
|
2010-11-05 05:14:58 +08:00
|
|
|
gimp_cage_tool_cursor_update (GimpTool *tool,
|
|
|
|
const GimpCoords *coords,
|
|
|
|
GdkModifierType state,
|
|
|
|
GimpDisplay *display)
|
2010-07-12 23:43:12 +08:00
|
|
|
{
|
2010-11-06 07:03:38 +08:00
|
|
|
GimpCageTool *ct = GIMP_CAGE_TOOL (tool);
|
|
|
|
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_PLUS;
|
2010-07-12 23:43:12 +08:00
|
|
|
|
2010-11-06 07:03:38 +08:00
|
|
|
if (tool->display)
|
2010-07-12 23:43:12 +08:00
|
|
|
{
|
2010-11-06 07:03:38 +08:00
|
|
|
if (ct->hovering_handle != -1)
|
2010-11-05 05:14:58 +08:00
|
|
|
{
|
2010-11-06 07:03:38 +08:00
|
|
|
modifier = GIMP_CURSOR_MODIFIER_MOVE;
|
2010-11-05 05:14:58 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-11-06 07:03:38 +08:00
|
|
|
if (ct->cage_complete)
|
|
|
|
modifier = GIMP_CURSOR_MODIFIER_BAD;
|
2010-11-05 05:14:58 +08:00
|
|
|
}
|
2010-07-12 23:43:12 +08:00
|
|
|
}
|
2010-11-06 07:03:38 +08:00
|
|
|
|
|
|
|
gimp_tool_control_set_cursor_modifier (tool->control, modifier);
|
|
|
|
|
|
|
|
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
|
2010-07-12 23:43:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gimp_cage_tool_draw (GimpDrawTool *draw_tool)
|
|
|
|
{
|
2010-11-05 05:14:58 +08:00
|
|
|
GimpCageTool *ct = GIMP_CAGE_TOOL (draw_tool);
|
|
|
|
GimpCageOptions *options = GIMP_CAGE_TOOL_GET_OPTIONS (ct);
|
|
|
|
GimpCageConfig *config = ct->config;
|
2010-11-06 02:59:48 +08:00
|
|
|
GimpCanvasGroup *stroke_group;
|
2010-11-05 17:04:45 +08:00
|
|
|
gint n_vertices;
|
2010-11-06 06:49:48 +08:00
|
|
|
gint i;
|
2010-12-17 21:49:37 +08:00
|
|
|
GimpHandleType handle;
|
2010-11-06 06:49:48 +08:00
|
|
|
|
|
|
|
n_vertices = config->n_cage_vertices;
|
2010-07-17 22:32:46 +08:00
|
|
|
|
2010-12-17 21:49:37 +08:00
|
|
|
if (ct->tool_state == CAGE_STATE_INIT)
|
2010-07-12 23:43:12 +08:00
|
|
|
return;
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-11-06 02:59:48 +08:00
|
|
|
stroke_group = gimp_draw_tool_add_stroke_group (draw_tool);
|
|
|
|
|
|
|
|
gimp_draw_tool_push_group (draw_tool, stroke_group);
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-12-17 21:49:37 +08:00
|
|
|
/* If needed, draw ligne to the cursor. */
|
2011-01-22 07:44:35 +08:00
|
|
|
if (!ct->cage_complete)
|
2010-11-05 05:14:58 +08:00
|
|
|
{
|
2011-01-02 23:15:55 +08:00
|
|
|
GimpVector2 last_point = gimp_cage_config_get_point_coordinate (ct->config, GIMP_CAGE_MODE_CAGE_CHANGE, n_vertices - 1);
|
|
|
|
gimp_draw_tool_add_line (draw_tool,
|
|
|
|
last_point.x + ct->offset_x,
|
|
|
|
last_point.y + ct->offset_y,
|
|
|
|
ct->cursor_x,
|
|
|
|
ct->cursor_y);
|
2010-11-05 05:14:58 +08:00
|
|
|
}
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-11-06 02:59:48 +08:00
|
|
|
gimp_draw_tool_pop_group (draw_tool);
|
|
|
|
|
2010-12-17 21:49:37 +08:00
|
|
|
/* Draw the cage with handles. */
|
2010-11-05 17:04:45 +08:00
|
|
|
for (i = 0; i < n_vertices; i++)
|
2010-07-12 23:43:12 +08:00
|
|
|
{
|
2011-01-02 23:15:55 +08:00
|
|
|
GimpVector2 point1, point2;
|
2010-11-06 02:59:48 +08:00
|
|
|
|
2011-01-02 23:15:55 +08:00
|
|
|
point1 = gimp_cage_config_get_point_coordinate (ct->config,
|
|
|
|
options->cage_mode,
|
|
|
|
i);
|
|
|
|
point1.x += ct->offset_x;
|
|
|
|
point1.y += ct->offset_y;
|
2010-11-06 06:49:48 +08:00
|
|
|
|
|
|
|
if (i > 0 || ct->cage_complete)
|
|
|
|
{
|
2011-01-02 23:15:55 +08:00
|
|
|
gint index_point2;
|
2010-11-06 06:49:48 +08:00
|
|
|
|
|
|
|
if (i == 0)
|
2011-01-02 23:15:55 +08:00
|
|
|
index_point2 = n_vertices - 1;
|
2010-11-06 06:49:48 +08:00
|
|
|
else
|
2011-01-02 23:15:55 +08:00
|
|
|
index_point2 = i - 1;
|
2010-11-06 06:49:48 +08:00
|
|
|
|
2011-01-02 23:15:55 +08:00
|
|
|
point2 = gimp_cage_config_get_point_coordinate (ct->config,
|
|
|
|
options->cage_mode,
|
|
|
|
index_point2);
|
|
|
|
point2.x += ct->offset_x;
|
|
|
|
point2.y += ct->offset_y;
|
2010-11-06 06:49:48 +08:00
|
|
|
|
2010-11-06 02:59:48 +08:00
|
|
|
gimp_draw_tool_push_group (draw_tool, stroke_group);
|
|
|
|
|
|
|
|
gimp_draw_tool_add_line (draw_tool,
|
2011-01-02 23:15:55 +08:00
|
|
|
point1.x,
|
|
|
|
point1.y,
|
|
|
|
point2.x,
|
|
|
|
point2.y);
|
2010-11-06 02:59:48 +08:00
|
|
|
|
|
|
|
gimp_draw_tool_pop_group (draw_tool);
|
|
|
|
}
|
2010-11-05 05:14:58 +08:00
|
|
|
|
2010-11-06 06:49:48 +08:00
|
|
|
if (i == ct->hovering_handle)
|
2010-11-05 05:14:58 +08:00
|
|
|
handle = GIMP_HANDLE_FILLED_CIRCLE;
|
2010-11-06 02:59:48 +08:00
|
|
|
else
|
|
|
|
handle = GIMP_HANDLE_CIRCLE;
|
2010-11-05 05:14:58 +08:00
|
|
|
|
|
|
|
gimp_draw_tool_add_handle (draw_tool,
|
|
|
|
handle,
|
2011-01-02 23:15:55 +08:00
|
|
|
point1.x,
|
|
|
|
point1.y,
|
2010-11-09 05:37:00 +08:00
|
|
|
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
|
|
|
|
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
|
2010-11-05 05:47:03 +08:00
|
|
|
GIMP_HANDLE_ANCHOR_CENTER);
|
2011-01-02 23:15:55 +08:00
|
|
|
|
|
|
|
if (ct->config->cage_points[i].selected)
|
|
|
|
{
|
|
|
|
gimp_draw_tool_add_handle (draw_tool,
|
|
|
|
GIMP_HANDLE_SQUARE,
|
|
|
|
point1.x,
|
|
|
|
point1.y,
|
|
|
|
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
|
|
|
|
GIMP_TOOL_HANDLE_SIZE_CIRCLE,
|
|
|
|
GIMP_HANDLE_ANCHOR_CENTER);
|
|
|
|
}
|
2010-07-12 23:43:12 +08:00
|
|
|
}
|
2011-01-10 21:55:38 +08:00
|
|
|
|
|
|
|
if (ct->tool_state == DEFORM_STATE_SELECTING)
|
|
|
|
{
|
|
|
|
gimp_draw_tool_add_rectangle (draw_tool,
|
|
|
|
FALSE,
|
|
|
|
MIN(ct->selection_start_x, ct->cursor_x),
|
|
|
|
MIN(ct->selection_start_y, ct->cursor_y),
|
|
|
|
abs (ct->selection_start_x - ct->cursor_x),
|
|
|
|
abs (ct->selection_start_y - ct->cursor_y));
|
|
|
|
}
|
2010-07-12 23:43:12 +08:00
|
|
|
}
|
|
|
|
|
2010-09-05 18:33:26 +08:00
|
|
|
static gint
|
2011-01-02 23:15:55 +08:00
|
|
|
gimp_cage_tool_is_on_handle (GimpCageTool *ct,
|
2010-11-05 05:14:58 +08:00
|
|
|
GimpDrawTool *draw_tool,
|
|
|
|
GimpDisplay *display,
|
|
|
|
gdouble x,
|
|
|
|
gdouble y,
|
|
|
|
gint handle_size)
|
2010-09-05 18:33:26 +08:00
|
|
|
{
|
2011-01-02 23:15:55 +08:00
|
|
|
GimpCageOptions *options = GIMP_CAGE_TOOL_GET_OPTIONS (ct);
|
|
|
|
GimpCageConfig *config = ct->config;
|
|
|
|
gdouble dist = G_MAXDOUBLE;
|
|
|
|
gint i;
|
|
|
|
GimpVector2 cage_point;
|
2010-09-05 18:33:26 +08:00
|
|
|
|
2011-01-02 23:15:55 +08:00
|
|
|
g_return_val_if_fail (GIMP_IS_CAGE_TOOL (ct), -1);
|
2010-09-05 18:33:26 +08:00
|
|
|
|
2011-01-02 23:15:55 +08:00
|
|
|
if (config->n_cage_vertices == 0)
|
2010-09-05 18:33:26 +08:00
|
|
|
return -1;
|
|
|
|
|
2011-01-02 23:15:55 +08:00
|
|
|
for (i = 0; i < config->n_cage_vertices; i++)
|
2010-09-05 18:33:26 +08:00
|
|
|
{
|
2011-01-02 23:15:55 +08:00
|
|
|
cage_point = gimp_cage_config_get_point_coordinate (config,
|
|
|
|
options->cage_mode,
|
|
|
|
i);
|
|
|
|
cage_point.x += ct->offset_x;
|
|
|
|
cage_point.y += ct->offset_y;
|
2010-11-05 05:14:58 +08:00
|
|
|
|
|
|
|
dist = gimp_draw_tool_calc_distance_square (GIMP_DRAW_TOOL (draw_tool),
|
|
|
|
display,
|
|
|
|
x, y,
|
2011-01-02 23:15:55 +08:00
|
|
|
cage_point.x,
|
|
|
|
cage_point.y);
|
2010-11-05 05:14:58 +08:00
|
|
|
|
2010-11-06 07:05:35 +08:00
|
|
|
if (dist <= SQR (handle_size / 2))
|
2010-11-05 05:14:58 +08:00
|
|
|
return i;
|
2010-09-05 18:33:26 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-07-12 23:43:12 +08:00
|
|
|
static void
|
|
|
|
gimp_cage_tool_remove_last_handle (GimpCageTool *ct)
|
|
|
|
{
|
2010-11-05 05:14:58 +08:00
|
|
|
GimpCageConfig *config = ct->config;
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-07-12 23:43:12 +08:00
|
|
|
gimp_draw_tool_pause (GIMP_DRAW_TOOL (ct));
|
2010-11-05 05:14:58 +08:00
|
|
|
|
2010-07-27 01:24:05 +08:00
|
|
|
gimp_cage_config_remove_last_cage_point (config);
|
2010-11-05 05:14:58 +08:00
|
|
|
|
2010-07-12 23:43:12 +08:00
|
|
|
gimp_draw_tool_resume (GIMP_DRAW_TOOL (ct));
|
2010-07-22 06:07:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-27 01:24:05 +08:00
|
|
|
gimp_cage_tool_compute_coef (GimpCageTool *ct,
|
|
|
|
GimpDisplay *display)
|
|
|
|
{
|
2010-11-10 02:35:54 +08:00
|
|
|
GimpDisplayShell *shell = gimp_display_get_shell (display);
|
|
|
|
GimpCageConfig *config = ct->config;
|
|
|
|
Babl *format;
|
|
|
|
GeglNode *gegl;
|
|
|
|
GeglNode *input;
|
|
|
|
GeglNode *output;
|
|
|
|
GeglProcessor *processor;
|
|
|
|
GimpCanvasItem *p;
|
|
|
|
GimpProgress *progress;
|
|
|
|
GeglBuffer *buffer;
|
|
|
|
gdouble value;
|
|
|
|
|
|
|
|
{
|
|
|
|
gint x, y, w, h;
|
|
|
|
|
|
|
|
gimp_display_shell_untransform_viewport (shell, &x, &y, &w, &h);
|
|
|
|
|
|
|
|
p = gimp_canvas_progress_new (shell, GIMP_HANDLE_ANCHOR_CENTER,
|
|
|
|
x + w / 2, y + h / 2);
|
|
|
|
gimp_display_shell_add_item (shell, p);
|
|
|
|
g_object_unref (p);
|
|
|
|
}
|
|
|
|
|
|
|
|
progress = gimp_progress_start (GIMP_PROGRESS (p),
|
|
|
|
_("Coefficient computation"),
|
|
|
|
FALSE);
|
|
|
|
gimp_widget_flush_expose (shell->canvas);
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-07-27 01:24:05 +08:00
|
|
|
if (ct->coef)
|
2010-11-05 05:14:58 +08:00
|
|
|
{
|
|
|
|
gegl_buffer_destroy (ct->coef);
|
|
|
|
ct->coef = NULL;
|
|
|
|
}
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-11-05 05:14:58 +08:00
|
|
|
format = babl_format_n (babl_type ("float"),
|
2010-11-05 17:04:45 +08:00
|
|
|
config->n_cage_vertices * 2);
|
2010-08-15 20:20:47 +08:00
|
|
|
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-07-27 01:24:05 +08:00
|
|
|
gegl = gegl_node_new ();
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-07-27 01:24:05 +08:00
|
|
|
input = gegl_node_new_child (gegl,
|
2010-11-05 19:45:07 +08:00
|
|
|
"operation", "gimp:cage-coef-calc",
|
2010-11-05 05:14:58 +08:00
|
|
|
"config", ct->config,
|
|
|
|
NULL);
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-07-27 01:24:05 +08:00
|
|
|
output = gegl_node_new_child (gegl,
|
2010-11-05 05:14:58 +08:00
|
|
|
"operation", "gegl:buffer-sink",
|
|
|
|
"buffer", &buffer,
|
|
|
|
"format", format,
|
|
|
|
NULL);
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-07-27 01:24:05 +08:00
|
|
|
gegl_node_connect_to (input, "output",
|
2010-10-07 05:37:04 +08:00
|
|
|
output, "input");
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-08-15 07:29:34 +08:00
|
|
|
processor = gegl_node_new_processor (output, NULL);
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-07-27 01:24:05 +08:00
|
|
|
while (gegl_processor_work (processor, &value))
|
2010-11-05 05:14:58 +08:00
|
|
|
{
|
2010-07-27 01:24:05 +08:00
|
|
|
gimp_progress_set_value (progress, value);
|
2010-11-10 02:35:54 +08:00
|
|
|
gimp_widget_flush_expose (shell->canvas);
|
2010-11-05 05:14:58 +08:00
|
|
|
}
|
2010-07-27 01:24:05 +08:00
|
|
|
|
|
|
|
gimp_progress_end (progress);
|
2010-11-05 05:14:58 +08:00
|
|
|
|
2010-08-15 07:29:34 +08:00
|
|
|
gegl_processor_destroy (processor);
|
2010-07-27 01:24:05 +08:00
|
|
|
|
|
|
|
ct->coef = buffer;
|
|
|
|
g_object_unref (gegl);
|
2010-11-10 02:35:54 +08:00
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
ct->dirty_coef = FALSE;
|
|
|
|
|
2010-11-10 02:35:54 +08:00
|
|
|
gimp_display_shell_remove_item (shell, p);
|
2010-07-27 01:24:05 +08:00
|
|
|
}
|
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
static void
|
2010-11-06 02:47:57 +08:00
|
|
|
gimp_cage_tool_create_render_node (GimpCageTool *ct)
|
2010-10-07 05:37:04 +08:00
|
|
|
{
|
2010-11-05 05:14:58 +08:00
|
|
|
GimpCageOptions *options = GIMP_CAGE_TOOL_GET_OPTIONS (ct);
|
|
|
|
GeglNode *coef, *cage, *render; /* Render nodes */
|
|
|
|
GeglNode *input, *output; /* Proxy nodes*/
|
|
|
|
GeglNode *node; /* wraper to be returned */
|
2010-10-07 05:37:04 +08:00
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
g_return_if_fail (ct->render_node == NULL);
|
|
|
|
/* render_node is not supposed to be recreated */
|
|
|
|
|
2010-11-06 02:47:57 +08:00
|
|
|
node = gegl_node_new ();
|
2010-10-07 05:37:04 +08:00
|
|
|
|
|
|
|
input = gegl_node_get_input_proxy (node, "input");
|
|
|
|
output = gegl_node_get_output_proxy (node, "output");
|
|
|
|
|
2010-11-06 02:47:57 +08:00
|
|
|
coef = gegl_node_new_child (node,
|
2010-11-04 03:08:10 +08:00
|
|
|
"operation", "gegl:buffer-source",
|
|
|
|
"buffer", ct->coef,
|
|
|
|
NULL);
|
2010-10-07 05:37:04 +08:00
|
|
|
|
2010-11-06 02:47:57 +08:00
|
|
|
cage = gegl_node_new_child (node,
|
2010-11-05 19:45:07 +08:00
|
|
|
"operation", "gimp:cage-transform",
|
2010-11-05 05:14:58 +08:00
|
|
|
"config", ct->config,
|
2010-10-07 05:37:04 +08:00
|
|
|
"fill_plain_color", options->fill_plain_color,
|
|
|
|
NULL);
|
|
|
|
|
2010-11-06 02:47:57 +08:00
|
|
|
render = gegl_node_new_child (node,
|
2010-11-03 02:56:11 +08:00
|
|
|
"operation", "gegl:map-absolute",
|
2010-10-07 05:37:04 +08:00
|
|
|
NULL);
|
|
|
|
|
|
|
|
gegl_node_connect_to (input, "output",
|
|
|
|
cage, "input");
|
|
|
|
|
2010-11-04 03:08:10 +08:00
|
|
|
gegl_node_connect_to (coef, "output",
|
2010-10-07 05:37:04 +08:00
|
|
|
cage, "aux");
|
|
|
|
|
|
|
|
gegl_node_connect_to (input, "output",
|
|
|
|
render, "input");
|
|
|
|
|
|
|
|
gegl_node_connect_to (cage, "output",
|
|
|
|
render, "aux");
|
|
|
|
|
|
|
|
gegl_node_connect_to (render, "output",
|
|
|
|
output, "input");
|
2010-11-06 02:10:03 +08:00
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
ct->render_node = node;
|
|
|
|
ct->cage_node = cage;
|
|
|
|
ct->coef_node = coef;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gimp_cage_tool_render_node_update (GimpCageTool *ct)
|
|
|
|
{
|
|
|
|
GimpCageOptions *options = GIMP_CAGE_TOOL_GET_OPTIONS (ct);
|
|
|
|
gboolean option_fill, node_fill;
|
|
|
|
GeglBuffer *buffer;
|
|
|
|
|
|
|
|
g_object_get (options,
|
|
|
|
"fill-plain-color", &option_fill,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
gegl_node_get (ct->cage_node,
|
|
|
|
"fill-plain-color", &node_fill,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
if (option_fill != node_fill)
|
|
|
|
{
|
|
|
|
gegl_node_set (ct->cage_node,
|
|
|
|
"fill_plain_color", option_fill,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
gegl_node_get (ct->coef_node,
|
|
|
|
"buffer", &buffer,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
if (option_fill != node_fill)
|
|
|
|
{
|
|
|
|
gegl_node_set (ct->coef_node,
|
|
|
|
"buffer", ct->coef,
|
|
|
|
NULL);
|
|
|
|
}
|
2010-10-07 05:37:04 +08:00
|
|
|
}
|
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
static void
|
2010-11-06 02:10:03 +08:00
|
|
|
gimp_cage_tool_create_image_map (GimpCageTool *ct,
|
2010-11-06 02:42:42 +08:00
|
|
|
GimpDrawable *drawable)
|
2010-09-03 03:28:06 +08:00
|
|
|
{
|
2011-01-22 07:44:35 +08:00
|
|
|
if (!ct->render_node)
|
|
|
|
gimp_cage_tool_create_render_node (ct);
|
2010-09-03 03:28:06 +08:00
|
|
|
|
|
|
|
ct->image_map = gimp_image_map_new (drawable,
|
|
|
|
_("Cage transform"),
|
2011-01-22 07:44:35 +08:00
|
|
|
ct->render_node,
|
2010-09-03 03:28:06 +08:00
|
|
|
NULL,
|
|
|
|
NULL);
|
2010-11-06 02:10:03 +08:00
|
|
|
|
|
|
|
g_signal_connect (ct->image_map, "flush",
|
|
|
|
G_CALLBACK (gimp_cage_tool_image_map_flush),
|
|
|
|
ct);
|
2010-09-03 03:28:06 +08:00
|
|
|
}
|
|
|
|
|
2010-11-06 02:10:03 +08:00
|
|
|
static void
|
|
|
|
gimp_cage_tool_image_map_flush (GimpImageMap *image_map,
|
|
|
|
GimpTool *tool)
|
2010-09-03 03:28:06 +08:00
|
|
|
{
|
2010-11-06 02:10:03 +08:00
|
|
|
GimpImage *image = gimp_display_get_image (tool->display);
|
2010-09-03 03:28:06 +08:00
|
|
|
|
2010-11-06 02:10:03 +08:00
|
|
|
gimp_projection_flush_now (gimp_image_get_projection (image));
|
|
|
|
gimp_display_flush_now (tool->display);
|
2010-09-03 03:28:06 +08:00
|
|
|
}
|
|
|
|
|
2010-12-17 21:49:37 +08:00
|
|
|
static void
|
|
|
|
gimp_cage_tool_image_map_update (GimpCageTool *ct)
|
|
|
|
{
|
|
|
|
GimpTool *tool = GIMP_TOOL (ct);
|
|
|
|
GimpDisplayShell *shell = gimp_display_get_shell (tool->display);
|
|
|
|
GimpItem *item = GIMP_ITEM (tool->drawable);
|
|
|
|
gint x, y;
|
|
|
|
gint w, h;
|
|
|
|
gint off_x, off_y;
|
|
|
|
GeglRectangle visible;
|
|
|
|
|
|
|
|
gimp_display_shell_untransform_viewport (shell, &x, &y, &w, &h);
|
|
|
|
|
|
|
|
gimp_item_get_offset (item, &off_x, &off_y);
|
|
|
|
|
|
|
|
gimp_rectangle_intersect (x, y, w, h,
|
|
|
|
off_x,
|
|
|
|
off_y,
|
|
|
|
gimp_item_get_width (item),
|
|
|
|
gimp_item_get_height (item),
|
|
|
|
&visible.x,
|
|
|
|
&visible.y,
|
|
|
|
&visible.width,
|
|
|
|
&visible.height);
|
|
|
|
|
|
|
|
visible.x -= off_x;
|
|
|
|
visible.y -= off_y;
|
|
|
|
|
|
|
|
gimp_image_map_apply (ct->image_map, &visible);
|
|
|
|
}
|
|
|
|
|
2010-08-10 05:33:11 +08:00
|
|
|
static void
|
2010-09-03 03:28:06 +08:00
|
|
|
gimp_cage_tool_halt (GimpCageTool *ct)
|
2010-08-10 05:33:11 +08:00
|
|
|
{
|
2010-11-05 05:14:58 +08:00
|
|
|
GimpTool *tool = GIMP_TOOL (ct);
|
|
|
|
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (ct);
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
if (gimp_draw_tool_is_active (draw_tool))
|
|
|
|
gimp_draw_tool_stop (draw_tool);
|
2010-08-12 02:27:32 +08:00
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
if (gimp_tool_control_is_active (tool->control))
|
|
|
|
gimp_tool_control_halt (tool->control);
|
|
|
|
|
|
|
|
if (ct->config)
|
2010-11-05 05:14:58 +08:00
|
|
|
{
|
|
|
|
g_object_unref (ct->config);
|
|
|
|
ct->config = NULL;
|
|
|
|
}
|
2010-08-14 00:25:48 +08:00
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
if (ct->coef)
|
2010-11-05 05:14:58 +08:00
|
|
|
{
|
|
|
|
gegl_buffer_destroy (ct->coef);
|
|
|
|
ct->coef = NULL;
|
|
|
|
}
|
2010-08-14 00:25:48 +08:00
|
|
|
|
2011-01-22 07:44:35 +08:00
|
|
|
if (ct->render_node)
|
|
|
|
{
|
|
|
|
g_object_unref (ct->render_node);
|
|
|
|
ct->render_node = NULL;
|
|
|
|
ct->coef_node = NULL;
|
|
|
|
ct->cage_node = NULL;
|
|
|
|
}
|
|
|
|
|
2010-09-03 03:28:06 +08:00
|
|
|
if (ct->image_map)
|
|
|
|
{
|
2010-11-05 05:14:58 +08:00
|
|
|
gimp_tool_control_set_preserve (tool->control, TRUE);
|
2010-08-10 05:33:11 +08:00
|
|
|
|
2010-11-05 05:14:58 +08:00
|
|
|
gimp_image_map_abort (ct->image_map);
|
|
|
|
g_object_unref (ct->image_map);
|
|
|
|
ct->image_map = NULL;
|
2010-08-10 05:33:11 +08:00
|
|
|
|
2010-11-05 05:14:58 +08:00
|
|
|
gimp_tool_control_set_preserve (tool->control, FALSE);
|
2010-09-03 03:28:06 +08:00
|
|
|
|
2010-11-05 05:14:58 +08:00
|
|
|
gimp_image_flush (gimp_display_get_image (tool->display));
|
|
|
|
}
|
2010-09-03 03:28:06 +08:00
|
|
|
|
|
|
|
tool->display = NULL;
|
2010-11-05 05:14:58 +08:00
|
|
|
}
|