dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app: factor-out common free/fg-select logic into GimpPolygonSelectTool 

We currently derive GimpForegroundSelectTool from
GimpFreeSelectTool, which prevents us from making changes that are
limited to the free-select tool.

Factor out the common free-select and foreground-select logic into
a new GimpPolygonSelectTool base-class, and derive both from this
class.
This commit is contained in:
Ell 2019-04-25 05:40:24 -04:00
parent 134ff92fe0
commit afab7deaa3
7 changed files with 749 additions and 492 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
app/tools/Makefile.am
View File

@ -84,14 +84,14 @@ libapptools_a_sources = \
gimpflipoptions.h \ gimpflipoptions.h \
gimpfliptool.c \ gimpfliptool.c \
gimpfliptool.h \ gimpfliptool.h \
gimpfreeselecttool.c \
gimpfreeselecttool.h \
gimpforegroundselectoptions.c \ gimpforegroundselectoptions.c \
gimpforegroundselectoptions.h \ gimpforegroundselectoptions.h \
gimpforegroundselecttool.c \ gimpforegroundselecttool.c \
gimpforegroundselecttool.h \ gimpforegroundselecttool.h \
gimpforegroundselecttoolundo.c \ gimpforegroundselecttoolundo.c \
gimpforegroundselecttoolundo.h \ gimpforegroundselecttoolundo.h \
gimpfreeselecttool.c \
gimpfreeselecttool.h \
gimpfuzzyselecttool.c \ gimpfuzzyselecttool.c \
gimpfuzzyselecttool.h \ gimpfuzzyselecttool.h \
gimpgegltool.c \ gimpgegltool.c \
@ -160,6 +160,8 @@ libapptools_a_sources = \
gimpperspectiveclonetool.h \ gimpperspectiveclonetool.h \
gimpperspectivetool.c \ gimpperspectivetool.c \
gimpperspectivetool.h \ gimpperspectivetool.h \
gimppolygonselecttool.c \
gimppolygonselecttool.h \
gimprectangleselecttool.c \ gimprectangleselecttool.c \
gimprectangleselecttool.h \ gimprectangleselecttool.h \
gimprectangleselectoptions.c \ gimprectangleselectoptions.c \

100
app/tools/gimpforegroundselecttool.c
View File

@ -139,10 +139,8 @@ static void gimp_foreground_select_tool_options_notify (GimpTool *tool
static void gimp_foreground_select_tool_draw (GimpDrawTool *draw_tool); static void gimp_foreground_select_tool_draw (GimpDrawTool *draw_tool);
static void gimp_foreground_select_tool_select (GimpFreeSelectTool *free_sel, static void gimp_foreground_select_tool_confirm (GimpPolygonSelectTool *poly_sel,
GimpDisplay *display, GimpDisplay *display);
const GimpVector2 *points,
gint n_points);
static void gimp_foreground_select_tool_halt (GimpForegroundSelectTool *fg_select); static void gimp_foreground_select_tool_halt (GimpForegroundSelectTool *fg_select);
static void gimp_foreground_select_tool_commit (GimpForegroundSelectTool *fg_select); static void gimp_foreground_select_tool_commit (GimpForegroundSelectTool *fg_select);
@ -172,7 +170,7 @@ static void gimp_foreground_select_undo_free (StrokeUndo
G_DEFINE_TYPE (GimpForegroundSelectTool, gimp_foreground_select_tool, G_DEFINE_TYPE (GimpForegroundSelectTool, gimp_foreground_select_tool,
GIMP_TYPE_FREE_SELECT_TOOL) GIMP_TYPE_POLYGON_SELECT_TOOL)
#define parent_class gimp_foreground_select_tool_parent_class #define parent_class gimp_foreground_select_tool_parent_class
@ -198,34 +196,34 @@ gimp_foreground_select_tool_register (GimpToolRegisterCallback callback,
static void static void
gimp_foreground_select_tool_class_init (GimpForegroundSelectToolClass *klass) gimp_foreground_select_tool_class_init (GimpForegroundSelectToolClass *klass)
{ {
GObjectClass *object_class = G_OBJECT_CLASS (klass); GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass); GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass); GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
GimpFreeSelectToolClass *free_select_tool_class; GimpPolygonSelectToolClass *polygon_select_tool_class;
free_select_tool_class = GIMP_FREE_SELECT_TOOL_CLASS (klass); polygon_select_tool_class = GIMP_POLYGON_SELECT_TOOL_CLASS (klass);
object_class->finalize = gimp_foreground_select_tool_finalize; object_class->finalize = gimp_foreground_select_tool_finalize;
tool_class->initialize = gimp_foreground_select_tool_initialize; tool_class->initialize = gimp_foreground_select_tool_initialize;
tool_class->control = gimp_foreground_select_tool_control; tool_class->control = gimp_foreground_select_tool_control;
tool_class->button_press = gimp_foreground_select_tool_button_press; tool_class->button_press = gimp_foreground_select_tool_button_press;
tool_class->button_release = gimp_foreground_select_tool_button_release; tool_class->button_release = gimp_foreground_select_tool_button_release;
tool_class->motion = gimp_foreground_select_tool_motion; tool_class->motion = gimp_foreground_select_tool_motion;
tool_class->key_press = gimp_foreground_select_tool_key_press; tool_class->key_press = gimp_foreground_select_tool_key_press;
tool_class->modifier_key = gimp_foreground_select_tool_modifier_key; tool_class->modifier_key = gimp_foreground_select_tool_modifier_key;
tool_class->active_modifier_key = gimp_foreground_select_tool_active_modifier_key; tool_class->active_modifier_key = gimp_foreground_select_tool_active_modifier_key;
tool_class->oper_update = gimp_foreground_select_tool_oper_update; tool_class->oper_update = gimp_foreground_select_tool_oper_update;
tool_class->cursor_update = gimp_foreground_select_tool_cursor_update; tool_class->cursor_update = gimp_foreground_select_tool_cursor_update;
tool_class->can_undo = gimp_foreground_select_tool_can_undo; tool_class->can_undo = gimp_foreground_select_tool_can_undo;
tool_class->can_redo = gimp_foreground_select_tool_can_redo; tool_class->can_redo = gimp_foreground_select_tool_can_redo;
tool_class->undo = gimp_foreground_select_tool_undo; tool_class->undo = gimp_foreground_select_tool_undo;
tool_class->redo = gimp_foreground_select_tool_redo; tool_class->redo = gimp_foreground_select_tool_redo;
tool_class->options_notify = gimp_foreground_select_tool_options_notify; tool_class->options_notify = gimp_foreground_select_tool_options_notify;
draw_tool_class->draw = gimp_foreground_select_tool_draw; draw_tool_class->draw = gimp_foreground_select_tool_draw;
free_select_tool_class->select = gimp_foreground_select_tool_select; polygon_select_tool_class->confirm = gimp_foreground_select_tool_confirm;
} }
static void static void
@ -430,14 +428,6 @@ gimp_foreground_select_tool_button_release (GimpTool *tool,
{ {
GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state, GIMP_TOOL_CLASS (parent_class)->button_release (tool, coords, time, state,
release_type, display); release_type, display);
/* see comment in gimp_foreground_select_tool_select() */
if (fg_select->in_double_click)
{
gimp_foreground_select_tool_set_trimap (fg_select);
fg_select->in_double_click = FALSE;
}
} }
else else
{ {
@ -610,7 +600,12 @@ gimp_foreground_select_tool_oper_update (GimpTool *tool,
{ {
if (GIMP_SELECTION_TOOL (tool)->function == SELECTION_SELECT) if (GIMP_SELECTION_TOOL (tool)->function == SELECTION_SELECT)
{ {
if (gimp_free_select_tool_get_n_points (GIMP_FREE_SELECT_TOOL (tool)) > 2) gint n_points;
gimp_polygon_select_tool_get_points (GIMP_POLYGON_SELECT_TOOL (tool),
NULL, &n_points);
if (n_points > 2)
{ {
status_mode = _("Roughly outline the object to extract"); status_mode = _("Roughly outline the object to extract");
status_stage = _("press Enter to refine."); status_stage = _("press Enter to refine.");
@ -898,18 +893,20 @@ gimp_foreground_select_tool_draw (GimpDrawTool *draw_tool)
} }
static void static void
gimp_foreground_select_tool_select (GimpFreeSelectTool *free_sel, gimp_foreground_select_tool_confirm (GimpPolygonSelectTool *poly_sel,
GimpDisplay *display, GimpDisplay *display)
const GimpVector2 *points,
gint n_points)
{ {
GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (free_sel); GimpForegroundSelectTool *fg_select = GIMP_FOREGROUND_SELECT_TOOL (poly_sel);
GimpImage *image = gimp_display_get_image (display); GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (drawable && fg_select->state == MATTING_STATE_FREE_SELECT) if (drawable && fg_select->state == MATTING_STATE_FREE_SELECT)
{ {
GimpScanConvert *scan_convert = gimp_scan_convert_new (); GimpScanConvert *scan_convert = gimp_scan_convert_new ();
const GimpVector2 *points;
gint n_points;
gimp_polygon_select_tool_get_points (poly_sel, &points, &n_points);
gimp_scan_convert_add_polyline (scan_convert, n_points, points, TRUE); gimp_scan_convert_add_polyline (scan_convert, n_points, points, TRUE);
@ -923,20 +920,7 @@ gimp_foreground_select_tool_select (GimpFreeSelectTool *free_sel,
0, 0, 0.5); 0, 0, 0.5);
gimp_scan_convert_free (scan_convert); gimp_scan_convert_free (scan_convert);
if (! gimp_tool_control_is_active (GIMP_TOOL (fg_select)->control)) gimp_foreground_select_tool_set_trimap (fg_select);
{
gimp_foreground_select_tool_set_trimap (fg_select);
}
else
{
/* if the tool is active we got here by double click
* detected in the parent class. We can't switch to trimap
* mode in the middle of a click. Set a flag and let
* button_release() forward the release to the parent class
* so it can conclude its operation
*/
fg_select->in_double_click = TRUE;
}
} }
} }
@ -1031,7 +1015,7 @@ gimp_foreground_select_tool_set_trimap (GimpForegroundSelectTool *fg_select)
options = GIMP_FOREGROUND_SELECT_TOOL_GET_OPTIONS (tool); options = GIMP_FOREGROUND_SELECT_TOOL_GET_OPTIONS (tool);
gimp_free_select_tool_halt (GIMP_FREE_SELECT_TOOL (fg_select)); gimp_polygon_select_tool_halt (GIMP_POLYGON_SELECT_TOOL (fg_select));
gimp_foreground_select_options_get_mask_color (options, &color); gimp_foreground_select_options_get_mask_color (options, &color);
gimp_display_shell_set_mask (gimp_display_get_shell (tool->display), gimp_display_shell_set_mask (gimp_display_get_shell (tool->display),

25
app/tools/gimpforegroundselecttool.h
View File

@ -19,7 +19,7 @@
#define __GIMP_FOREGROUND_SELECT_TOOL_H__ #define __GIMP_FOREGROUND_SELECT_TOOL_H__
#include "gimpfreeselecttool.h" #include "gimppolygonselecttool.h"
typedef enum typedef enum
@ -45,26 +45,25 @@ typedef struct _GimpForegroundSelectToolClass GimpForegroundSelectToolClass;
struct _GimpForegroundSelectTool struct _GimpForegroundSelectTool
{ {
GimpFreeSelectTool parent_instance; GimpPolygonSelectTool parent_instance;
MattingState state; MattingState state;
gboolean in_double_click;
GimpCoords last_coords; GimpCoords last_coords;
GArray *stroke; GArray *stroke;
GeglBuffer *trimap; GeglBuffer *trimap;
GeglBuffer *mask; GeglBuffer *mask;
GList *undo_stack; GList *undo_stack;
GList *redo_stack; GList *redo_stack;
GimpToolGui *gui; GimpToolGui *gui;
GtkWidget *preview_toggle; GtkWidget *preview_toggle;
}; };
struct _GimpForegroundSelectToolClass struct _GimpForegroundSelectToolClass
{ {
GimpFreeSelectToolClass parent_class; GimpPolygonSelectToolClass parent_class;
}; };

462
app/tools/gimpfreeselecttool.c
View File

@ -46,72 +46,30 @@
struct _GimpFreeSelectToolPrivate struct _GimpFreeSelectToolPrivate
{ {
gboolean started;
/* The selection operation active when the tool was started */ /* The selection operation active when the tool was started */
GimpChannelOps operation_at_start; GimpChannelOps operation_at_start;
GimpToolWidget *widget;
GimpToolWidget *grab_widget;
}; };
static void gimp_free_select_tool_finalize (GObject *object); static void gimp_free_select_tool_control (GimpTool *tool,
static void gimp_free_select_tool_control (GimpTool *tool, GimpToolAction action,
GimpToolAction action, GimpDisplay *display);
GimpDisplay *display); static void gimp_free_select_tool_button_press (GimpTool *tool,
static void gimp_free_select_tool_oper_update (GimpTool *tool, const GimpCoords *coords,
const GimpCoords *coords, guint32 time,
GdkModifierType state, GdkModifierType state,
gboolean proximity, GimpButtonPressType press_type,
GimpDisplay *display); GimpDisplay *display);
static void gimp_free_select_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display);
static void gimp_free_select_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display);
static void gimp_free_select_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display);
static void gimp_free_select_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display);
static gboolean gimp_free_select_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display);
static void gimp_free_select_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display);
static void gimp_free_select_tool_active_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display);
static void gimp_free_select_tool_real_select (GimpFreeSelectTool *fst, static void gimp_free_select_tool_commit (GimpFreeSelectTool *free_sel,
GimpDisplay *display, GimpDisplay *display);
const GimpVector2 *points, static void gimp_free_select_tool_halt (GimpFreeSelectTool *free_sel);
gint n_points);
static void gimp_free_select_tool_polygon_changed (GimpToolWidget *polygon,
GimpFreeSelectTool *fst);
static void gimp_free_select_tool_polygon_response (GimpToolWidget *polygon,
gint response_id,
GimpFreeSelectTool *fst);
G_DEFINE_TYPE_WITH_PRIVATE (GimpFreeSelectTool, gimp_free_select_tool, G_DEFINE_TYPE_WITH_PRIVATE (GimpFreeSelectTool, gimp_free_select_tool,
GIMP_TYPE_SELECTION_TOOL) GIMP_TYPE_POLYGON_SELECT_TOOL)
#define parent_class gimp_free_select_tool_parent_class #define parent_class gimp_free_select_tool_parent_class
@ -134,132 +92,24 @@ gimp_free_select_tool_register (GimpToolRegisterCallback callback,
data); data);
} }
gint
gimp_free_select_tool_get_n_points (GimpFreeSelectTool *tool)
{
GimpFreeSelectToolPrivate *private = tool->private;
const GimpVector2 *points;
gint n_points = 0;
if (private->widget)
gimp_tool_polygon_get_points (GIMP_TOOL_POLYGON (private->widget),
&points, &n_points);
return n_points;
}
static void static void
gimp_free_select_tool_class_init (GimpFreeSelectToolClass *klass) gimp_free_select_tool_class_init (GimpFreeSelectToolClass *klass)
{ {
GObjectClass *object_class = G_OBJECT_CLASS (klass); GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
object_class->finalize = gimp_free_select_tool_finalize; tool_class->control = gimp_free_select_tool_control;
tool_class->button_press = gimp_free_select_tool_button_press;
tool_class->control = gimp_free_select_tool_control;
tool_class->oper_update = gimp_free_select_tool_oper_update;
tool_class->cursor_update = gimp_free_select_tool_cursor_update;
tool_class->button_press = gimp_free_select_tool_button_press;
tool_class->button_release = gimp_free_select_tool_button_release;
tool_class->motion = gimp_free_select_tool_motion;
tool_class->key_press = gimp_free_select_tool_key_press;
tool_class->modifier_key = gimp_free_select_tool_modifier_key;
tool_class->active_modifier_key = gimp_free_select_tool_active_modifier_key;
klass->select = gimp_free_select_tool_real_select;
} }
static void static void
gimp_free_select_tool_init (GimpFreeSelectTool *fst) gimp_free_select_tool_init (GimpFreeSelectTool *free_sel)
{ {
GimpTool *tool = GIMP_TOOL (fst); GimpTool *tool = GIMP_TOOL (free_sel);
fst->private = gimp_free_select_tool_get_instance_private (fst); free_sel->priv = gimp_free_select_tool_get_instance_private (free_sel);
gimp_tool_control_set_motion_mode (tool->control, gimp_tool_control_set_tool_cursor (tool->control,
GIMP_MOTION_MODE_EXACT); GIMP_TOOL_CURSOR_FREE_SELECT);
gimp_tool_control_set_wants_click (tool->control, TRUE);
gimp_tool_control_set_wants_double_click (tool->control, TRUE);
gimp_tool_control_set_active_modifiers (tool->control,
GIMP_TOOL_ACTIVE_MODIFIERS_SEPARATE);
gimp_tool_control_set_precision (tool->control,
GIMP_CURSOR_PRECISION_SUBPIXEL);
gimp_tool_control_set_tool_cursor (tool->control,
GIMP_TOOL_CURSOR_FREE_SELECT);
}
static void
gimp_free_select_tool_finalize (GObject *object)
{
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (object);
GimpFreeSelectToolPrivate *priv = fst->private;
g_clear_object (&priv->widget);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_free_select_tool_start (GimpFreeSelectTool *fst,
GimpDisplay *display)
{
GimpTool *tool = GIMP_TOOL (fst);
GimpFreeSelectToolPrivate *private = fst->private;
GimpSelectionOptions *options = GIMP_SELECTION_TOOL_GET_OPTIONS (tool);
GimpDisplayShell *shell = gimp_display_get_shell (display);
tool->display = display;
/* We want to apply the selection operation that was current when
* the tool was started, so we save this information
*/
private->operation_at_start = options->operation;
private->widget = gimp_tool_polygon_new (shell);
gimp_draw_tool_set_widget (GIMP_DRAW_TOOL (tool), private->widget);
g_signal_connect (private->widget, "changed",
G_CALLBACK (gimp_free_select_tool_polygon_changed),
fst);
g_signal_connect (private->widget, "response",
G_CALLBACK (gimp_free_select_tool_polygon_response),
fst);
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
}
void
gimp_free_select_tool_halt (GimpFreeSelectTool *fst)
{
GimpFreeSelectToolPrivate *private = fst->private;
gimp_draw_tool_set_widget (GIMP_DRAW_TOOL (fst), NULL);
g_clear_object (&private->widget);
}
static void
gimp_free_select_tool_commit (GimpFreeSelectTool *fst,
GimpDisplay *display)
{
GimpFreeSelectToolPrivate *private = fst->private;
if (private->widget)
{
const GimpVector2 *points;
gint n_points;
gimp_tool_polygon_get_points (GIMP_TOOL_POLYGON (private->widget),
&points, &n_points);
if (n_points >= 3)
{
GIMP_FREE_SELECT_TOOL_GET_CLASS (fst)->select (fst, display,
points, n_points);
}
}
gimp_image_flush (gimp_display_get_image (display));
} }
static void static void
@ -267,7 +117,7 @@ gimp_free_select_tool_control (GimpTool *tool,
GimpToolAction action, GimpToolAction action,
GimpDisplay *display) GimpDisplay *display)
{ {
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (tool); GimpFreeSelectTool *free_sel = GIMP_FREE_SELECT_TOOL (tool);
switch (action) switch (action)
{ {
@ -276,69 +126,17 @@ gimp_free_select_tool_control (GimpTool *tool,
break; break;
case GIMP_TOOL_ACTION_HALT: case GIMP_TOOL_ACTION_HALT:
gimp_free_select_tool_halt (fst); gimp_free_select_tool_halt (free_sel);
break; break;
case GIMP_TOOL_ACTION_COMMIT: case GIMP_TOOL_ACTION_COMMIT:
gimp_free_select_tool_commit (fst, display); gimp_free_select_tool_commit (free_sel, display);
break; break;
} }
GIMP_TOOL_CLASS (parent_class)->control (tool, action, display); GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
} }
static void
gimp_free_select_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (tool);
GimpFreeSelectToolPrivate *priv = fst->private;
if (display != tool->display)
{
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state,
proximity, display);
return;
}
if (priv->widget)
{
gimp_tool_widget_hover (priv->widget, coords, state, proximity);
}
}
static void
gimp_free_select_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (tool);
GimpFreeSelectToolPrivate *priv = fst->private;
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE;
if (tool->display == NULL)
{
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state,
display);
return;
}
if (priv->widget && display == tool->display)
{
gimp_tool_widget_get_cursor (priv->widget, coords, state,
NULL, NULL, &modifier);
}
gimp_tool_set_cursor (tool, display,
gimp_tool_control_get_cursor (tool->control),
gimp_tool_control_get_tool_cursor (tool->control),
modifier);
}
static void static void
gimp_free_select_tool_button_press (GimpTool *tool, gimp_free_select_tool_button_press (GimpTool *tool,
const GimpCoords *coords, const GimpCoords *coords,
@ -347,199 +145,59 @@ gimp_free_select_tool_button_press (GimpTool *tool,
GimpButtonPressType press_type, GimpButtonPressType press_type,
GimpDisplay *display) GimpDisplay *display)
{ {
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (tool); GimpSelectionOptions *options = GIMP_SELECTION_TOOL_GET_OPTIONS (tool);
GimpFreeSelectToolPrivate *private = fst->private; GimpFreeSelectTool *free_sel = GIMP_FREE_SELECT_TOOL (tool);
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
GimpFreeSelectToolPrivate *priv = free_sel->priv;
if (tool->display && tool->display != display) GIMP_TOOL_CLASS (parent_class)->button_press (tool, coords, time, state,
gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, tool->display); press_type, display);
if (! private->widget) /* not tool->display, we have a subclass */ if (press_type == GIMP_BUTTON_PRESS_NORMAL &&
gimp_polygon_select_tool_is_grabbed (poly_sel))
{ {
/* First of all handle delegation to the selection mask edit logic if (! priv->started)
* if appropriate.
*/
if (gimp_selection_tool_start_edit (GIMP_SELECTION_TOOL (fst),
display, coords))
{ {
return; priv->started = TRUE;
} priv->operation_at_start = options->operation;
gimp_free_select_tool_start (fst, display);
gimp_tool_widget_hover (private->widget, coords, state, TRUE);
}
if (gimp_tool_widget_button_press (private->widget, coords, time, state,
press_type))
{
private->grab_widget = private->widget;
}
if (press_type == GIMP_BUTTON_PRESS_NORMAL)
gimp_tool_control_activate (tool->control);
}
static void
gimp_free_select_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (tool);
GimpFreeSelectToolPrivate *priv = fst->private;
GimpImage *image = gimp_display_get_image (display);
gimp_tool_control_halt (tool->control);
switch (release_type)
{
case GIMP_BUTTON_RELEASE_CLICK:
case GIMP_BUTTON_RELEASE_NO_MOTION:
/* If there is a floating selection, anchor it */
if (gimp_image_get_floating_selection (image))
{
floating_sel_anchor (gimp_image_get_floating_selection (image));
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
return;
}
/* fallthru */
default:
if (priv->grab_widget)
{
gimp_tool_widget_button_release (priv->grab_widget,
coords, time, state, release_type);
priv->grab_widget = NULL;
} }
} }
} }
static void static void
gimp_free_select_tool_motion (GimpTool *tool, gimp_free_select_tool_halt (GimpFreeSelectTool *free_sel)
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{ {
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (tool); GimpFreeSelectToolPrivate *priv = free_sel->priv;
GimpFreeSelectToolPrivate *priv = fst->private;
if (priv->grab_widget) priv->started = FALSE;
{
gimp_tool_widget_motion (priv->grab_widget, coords, time, state);
}
}
static gboolean
gimp_free_select_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display)
{
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (tool);
GimpFreeSelectToolPrivate *priv = fst->private;
if (priv->widget && display == tool->display)
{
return gimp_tool_widget_key_press (priv->widget, kevent);
}
return FALSE;
} }
static void static void
gimp_free_select_tool_modifier_key (GimpTool *tool, gimp_free_select_tool_commit (GimpFreeSelectTool *free_sel,
GdkModifierType key, GimpDisplay *display)
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{ {
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (tool); GimpSelectionOptions *options = GIMP_SELECTION_TOOL_GET_OPTIONS (free_sel);
GimpFreeSelectToolPrivate *priv = fst->private; GimpFreeSelectToolPrivate *priv = free_sel->priv;
if (priv->widget && display == tool->display)
{
gimp_tool_widget_hover_modifier (priv->widget, key, press, state);
}
GIMP_TOOL_CLASS (parent_class)->modifier_key (tool, key, press, state,
display);
}
static void
gimp_free_select_tool_active_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpFreeSelectTool *fst = GIMP_FREE_SELECT_TOOL (tool);
GimpFreeSelectToolPrivate *priv = fst->private;
if (priv->widget)
{
gimp_tool_widget_motion_modifier (priv->widget, key, press, state);
GIMP_TOOL_CLASS (parent_class)->active_modifier_key (tool,
key, press, state,
display);
}
}
static void
gimp_free_select_tool_real_select (GimpFreeSelectTool *fst,
GimpDisplay *display,
const GimpVector2 *points,
gint n_points)
{
GimpSelectionOptions *options = GIMP_SELECTION_TOOL_GET_OPTIONS (fst);
GimpFreeSelectToolPrivate *priv = fst->private;
GimpImage *image = gimp_display_get_image (display); GimpImage *image = gimp_display_get_image (display);
const GimpVector2 *points;
gint n_points;
gimp_channel_select_polygon (gimp_image_get_mask (image), gimp_polygon_select_tool_get_points (GIMP_POLYGON_SELECT_TOOL (free_sel),
C_("command", "Free Select"), &points, &n_points);
n_points,
points,
priv->operation_at_start,
options->antialias,
options->feather,
options->feather_radius,
options->feather_radius,
TRUE);
gimp_tool_control (GIMP_TOOL (fst), GIMP_TOOL_ACTION_HALT, display); if (n_points > 2)
}
static void
gimp_free_select_tool_polygon_changed (GimpToolWidget *polygon,
GimpFreeSelectTool *fst)
{
}
static void
gimp_free_select_tool_polygon_response (GimpToolWidget *polygon,
gint response_id,
GimpFreeSelectTool *fst)
{
GimpTool *tool = GIMP_TOOL (fst);
switch (response_id)
{ {
case GIMP_TOOL_WIDGET_RESPONSE_CONFIRM: gimp_channel_select_polygon (gimp_image_get_mask (image),
/* don't gimp_tool_control(COMMIT) here because we don't always C_("command", "Free Select"),
* want to HALT the tool after committing because we have a n_points,
* subclass, we do that in the default implementation of points,
* select(). priv->operation_at_start,
*/ options->antialias,
gimp_free_select_tool_commit (fst, tool->display); options->feather,
break; options->feather_radius,
options->feather_radius,
TRUE);
case GIMP_TOOL_WIDGET_RESPONSE_CANCEL: gimp_image_flush (image);
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display);
break;
} }
} }

21
app/tools/gimpfreeselecttool.h
View File

@ -19,7 +19,7 @@
#define __GIMP_FREE_SELECT_TOOL_H__ #define __GIMP_FREE_SELECT_TOOL_H__
#include "gimpselectiontool.h" #include "gimppolygonselecttool.h"
#define GIMP_TYPE_FREE_SELECT_TOOL (gimp_free_select_tool_get_type ()) #define GIMP_TYPE_FREE_SELECT_TOOL (gimp_free_select_tool_get_type ())
@ -36,21 +36,14 @@ typedef struct _GimpFreeSelectToolClass GimpFreeSelectToolClass;
struct _GimpFreeSelectTool struct _GimpFreeSelectTool
{ {
GimpSelectionTool parent_instance; GimpPolygonSelectTool parent_instance;
GimpFreeSelectToolPrivate *private; GimpFreeSelectToolPrivate *priv;
}; };
struct _GimpFreeSelectToolClass struct _GimpFreeSelectToolClass
{ {
GimpSelectionToolClass parent_class; GimpPolygonSelectToolClass parent_class;
/* virtual function */
void (* select) (GimpFreeSelectTool *free_select_tool,
GimpDisplay *display,
const GimpVector2 *points,
gint n_points);
}; };
@ -59,11 +52,5 @@ void gimp_free_select_tool_register (GimpToolRegisterCallback callback,
GType gimp_free_select_tool_get_type (void) G_GNUC_CONST; GType gimp_free_select_tool_get_type (void) G_GNUC_CONST;
gint gimp_free_select_tool_get_n_points (GimpFreeSelectTool *tool);
/* protected functions */
void gimp_free_select_tool_halt (GimpFreeSelectTool *tool);
#endif /* __GIMP_FREE_SELECT_TOOL_H__ */ #endif /* __GIMP_FREE_SELECT_TOOL_H__ */

558
app/tools/gimppolygonselecttool.c Normal file
View File

@ -0,0 +1,558 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* Major improvement to support polygonal segments
* Copyright (C) 2008 Martin Nordholts
*
* This program is polygon software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Polygon 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 <gegl.h>
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "tools-types.h"
#include "core/gimpchannel.h"
#include "core/gimpchannel-select.h"
#include "core/gimpimage.h"
#include "core/gimplayer-floating-selection.h"
#include "widgets/gimphelp-ids.h"
#include "display/gimpdisplay.h"
#include "display/gimptoolpolygon.h"
#include "gimppolygonselecttool.h"
#include "gimpselectionoptions.h"
#include "gimptoolcontrol.h"
struct _GimpPolygonSelectToolPrivate
{
GimpToolWidget *widget;
GimpToolWidget *grab_widget;
gboolean pending_response;
gint pending_response_id;
};
/* local function prototypes */
static void gimp_polygon_select_tool_finalize (GObject *object);
static void gimp_polygon_select_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display);
static void gimp_polygon_select_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display);
static void gimp_polygon_select_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display);
static void gimp_polygon_select_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display);
static void gimp_polygon_select_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display);
static void gimp_polygon_select_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display);
static gboolean gimp_polygon_select_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display);
static void gimp_polygon_select_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display);
static void gimp_polygon_select_tool_active_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display);
static void gimp_polygon_select_tool_real_confirm (GimpPolygonSelectTool *poly_sel,
GimpDisplay *display);
static void gimp_polygon_select_tool_polygon_change_complete (GimpToolWidget *polygon,
GimpPolygonSelectTool *poly_sel);
static void gimp_polygon_select_tool_polygon_response (GimpToolWidget *polygon,
gint response_id,
GimpPolygonSelectTool *poly_sel);
static void gimp_polygon_select_tool_start (GimpPolygonSelectTool *poly_sel,
GimpDisplay *display);
G_DEFINE_TYPE_WITH_PRIVATE (GimpPolygonSelectTool, gimp_polygon_select_tool,
GIMP_TYPE_SELECTION_TOOL)
#define parent_class gimp_polygon_select_tool_parent_class
/* private functions */
static void
gimp_polygon_select_tool_class_init (GimpPolygonSelectToolClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
object_class->finalize = gimp_polygon_select_tool_finalize;
tool_class->control = gimp_polygon_select_tool_control;
tool_class->oper_update = gimp_polygon_select_tool_oper_update;
tool_class->cursor_update = gimp_polygon_select_tool_cursor_update;
tool_class->button_press = gimp_polygon_select_tool_button_press;
tool_class->button_release = gimp_polygon_select_tool_button_release;
tool_class->motion = gimp_polygon_select_tool_motion;
tool_class->key_press = gimp_polygon_select_tool_key_press;
tool_class->modifier_key = gimp_polygon_select_tool_modifier_key;
tool_class->active_modifier_key = gimp_polygon_select_tool_active_modifier_key;
klass->change_complete = NULL;
klass->confirm = gimp_polygon_select_tool_real_confirm;
}
static void
gimp_polygon_select_tool_init (GimpPolygonSelectTool *poly_sel)
{
GimpTool *tool = GIMP_TOOL (poly_sel);
poly_sel->priv = gimp_polygon_select_tool_get_instance_private (poly_sel);
gimp_tool_control_set_motion_mode (tool->control,
GIMP_MOTION_MODE_EXACT);
gimp_tool_control_set_wants_click (tool->control, TRUE);
gimp_tool_control_set_wants_double_click (tool->control, TRUE);
gimp_tool_control_set_active_modifiers (tool->control,
GIMP_TOOL_ACTIVE_MODIFIERS_SEPARATE);
gimp_tool_control_set_precision (tool->control,
GIMP_CURSOR_PRECISION_SUBPIXEL);
}
static void
gimp_polygon_select_tool_finalize (GObject *object)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (object);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
g_clear_object (&priv->widget);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_polygon_select_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
switch (action)
{
case GIMP_TOOL_ACTION_PAUSE:
case GIMP_TOOL_ACTION_RESUME:
break;
case GIMP_TOOL_ACTION_HALT:
gimp_polygon_select_tool_halt (poly_sel);
break;
case GIMP_TOOL_ACTION_COMMIT:
break;
}
GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
}
static void
gimp_polygon_select_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
if (display != tool->display)
{
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state,
proximity, display);
return;
}
if (priv->widget)
{
gimp_tool_widget_hover (priv->widget, coords, state, proximity);
}
}
static void
gimp_polygon_select_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_NONE;
if (tool->display == NULL)
{
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state,
display);
return;
}
if (priv->widget && display == tool->display)
{
gimp_tool_widget_get_cursor (priv->widget, coords, state,
NULL, NULL, &modifier);
}
gimp_tool_set_cursor (tool, display,
gimp_tool_control_get_cursor (tool->control),
gimp_tool_control_get_tool_cursor (tool->control),
modifier);
}
static void
gimp_polygon_select_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
if (tool->display && tool->display != display)
gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, tool->display);
if (! priv->widget) /* not tool->display, we have a subclass */
{
/* First of all handle delegation to the selection mask edit logic
* if appropriate.
*/
if (gimp_selection_tool_start_edit (GIMP_SELECTION_TOOL (poly_sel),
display, coords))
{
return;
}
gimp_polygon_select_tool_start (poly_sel, display);
gimp_tool_widget_hover (priv->widget, coords, state, TRUE);
}
if (gimp_tool_widget_button_press (priv->widget, coords, time, state,
press_type))
{
priv->grab_widget = priv->widget;
}
if (press_type == GIMP_BUTTON_PRESS_NORMAL)
gimp_tool_control_activate (tool->control);
}
static void
gimp_polygon_select_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
GimpImage *image = gimp_display_get_image (display);
gimp_tool_control_halt (tool->control);
switch (release_type)
{
case GIMP_BUTTON_RELEASE_CLICK:
case GIMP_BUTTON_RELEASE_NO_MOTION:
/* If there is a floating selection, anchor it */
if (gimp_image_get_floating_selection (image))
{
floating_sel_anchor (gimp_image_get_floating_selection (image));
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display);
return;
}
/* fallthru */
default:
if (priv->grab_widget)
{
gimp_tool_widget_button_release (priv->grab_widget,
coords, time, state, release_type);
priv->grab_widget = NULL;
}
}
if (priv->pending_response)
{
gimp_polygon_select_tool_polygon_response (priv->widget,
priv->pending_response_id,
poly_sel);
priv->pending_response = FALSE;
}
}
static void
gimp_polygon_select_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
if (priv->grab_widget)
{
gimp_tool_widget_motion (priv->grab_widget, coords, time, state);
}
}
static gboolean
gimp_polygon_select_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
if (priv->widget && display == tool->display)
{
return gimp_tool_widget_key_press (priv->widget, kevent);
}
return FALSE;
}
static void
gimp_polygon_select_tool_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
if (priv->widget && display == tool->display)
{
gimp_tool_widget_hover_modifier (priv->widget, key, press, state);
}
GIMP_TOOL_CLASS (parent_class)->modifier_key (tool, key, press, state,
display);
}
static void
gimp_polygon_select_tool_active_modifier_key (GimpTool *tool,
GdkModifierType key,
gboolean press,
GdkModifierType state,
GimpDisplay *display)
{
GimpPolygonSelectTool *poly_sel = GIMP_POLYGON_SELECT_TOOL (tool);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
if (priv->widget)
{
gimp_tool_widget_motion_modifier (priv->widget, key, press, state);
GIMP_TOOL_CLASS (parent_class)->active_modifier_key (tool,
key, press, state,
display);
}
}
static void
gimp_polygon_select_tool_real_confirm (GimpPolygonSelectTool *poly_sel,
GimpDisplay *display)
{
gimp_tool_control (GIMP_TOOL (poly_sel), GIMP_TOOL_ACTION_COMMIT, display);
}
static void
gimp_polygon_select_tool_polygon_change_complete (GimpToolWidget *polygon,
GimpPolygonSelectTool *poly_sel)
{
if (GIMP_POLYGON_SELECT_TOOL_GET_CLASS (poly_sel)->change_complete)
{
GIMP_POLYGON_SELECT_TOOL_GET_CLASS (poly_sel)->change_complete (
poly_sel, GIMP_TOOL (poly_sel)->display);
}
}
static void
gimp_polygon_select_tool_polygon_response (GimpToolWidget *polygon,
gint response_id,
GimpPolygonSelectTool *poly_sel)
{
GimpTool *tool = GIMP_TOOL (poly_sel);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
/* if we're in the middle of a click, defer the response to the
* button_release() event
*/
if (gimp_tool_control_is_active (tool->control))
{
priv->pending_response = TRUE;
priv->pending_response_id = response_id;
return;
}
switch (response_id)
{
case GIMP_TOOL_WIDGET_RESPONSE_CONFIRM:
/* don't gimp_tool_control(COMMIT) here because we don't always
* want to HALT the tool after committing because we have a
* subclass, we do that in the default implementation of
* confirm().
*/
if (GIMP_POLYGON_SELECT_TOOL_GET_CLASS (poly_sel)->confirm)
{
GIMP_POLYGON_SELECT_TOOL_GET_CLASS (poly_sel)->confirm (
poly_sel, tool->display);
}
break;
case GIMP_TOOL_WIDGET_RESPONSE_CANCEL:
gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display);
break;
}
}
static void
gimp_polygon_select_tool_start (GimpPolygonSelectTool *poly_sel,
GimpDisplay *display)
{
GimpTool *tool = GIMP_TOOL (poly_sel);
GimpPolygonSelectToolPrivate *priv = poly_sel->priv;
GimpDisplayShell *shell = gimp_display_get_shell (display);
tool->display = display;
priv->widget = gimp_tool_polygon_new (shell);
gimp_draw_tool_set_widget (GIMP_DRAW_TOOL (tool), priv->widget);
g_signal_connect (priv->widget, "change-complete",
G_CALLBACK (gimp_polygon_select_tool_polygon_change_complete),
poly_sel);
g_signal_connect (priv->widget, "response",
G_CALLBACK (gimp_polygon_select_tool_polygon_response),
poly_sel);
gimp_draw_tool_start (GIMP_DRAW_TOOL (tool), display);
}
/* public functions */
gboolean
gimp_polygon_select_tool_is_closed (GimpPolygonSelectTool *poly_sel)
{
GimpPolygonSelectToolPrivate *priv;
g_return_val_if_fail (GIMP_IS_POLYGON_SELECT_TOOL (poly_sel), FALSE);
priv = poly_sel->priv;
if (priv->widget)
return gimp_tool_polygon_is_closed (GIMP_TOOL_POLYGON (priv->widget));
return FALSE;
}
void
gimp_polygon_select_tool_get_points (GimpPolygonSelectTool *poly_sel,
const GimpVector2 **points,
gint *n_points)
{
GimpPolygonSelectToolPrivate *priv;
g_return_if_fail (GIMP_IS_POLYGON_SELECT_TOOL (poly_sel));
priv = poly_sel->priv;
if (priv->widget)
{
gimp_tool_polygon_get_points (GIMP_TOOL_POLYGON (priv->widget),
points, n_points);
}
else
{
if (points) *points = NULL;
if (n_points) *n_points = 0;
}
}
/* protected functions */
gboolean
gimp_polygon_select_tool_is_grabbed (GimpPolygonSelectTool *poly_sel)
{
GimpPolygonSelectToolPrivate *priv;
g_return_val_if_fail (GIMP_IS_POLYGON_SELECT_TOOL (poly_sel), FALSE);
priv = poly_sel->priv;
return priv->grab_widget != NULL;
}
void
gimp_polygon_select_tool_halt (GimpPolygonSelectTool *poly_sel)
{
GimpPolygonSelectToolPrivate *priv;
g_return_if_fail (GIMP_IS_POLYGON_SELECT_TOOL (poly_sel));
priv = poly_sel->priv;
gimp_draw_tool_set_widget (GIMP_DRAW_TOOL (poly_sel), NULL);
g_clear_object (&priv->widget);
}

69
app/tools/gimppolygonselecttool.h Normal file
View File

@ -0,0 +1,69 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is polygon software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Polygon 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/>.
*/
#ifndef __GIMP_POLYGON_SELECT_TOOL_H__
#define __GIMP_POLYGON_SELECT_TOOL_H__
#include "gimpselectiontool.h"
#define GIMP_TYPE_POLYGON_SELECT_TOOL (gimp_polygon_select_tool_get_type ())
#define GIMP_POLYGON_SELECT_TOOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_POLYGON_SELECT_TOOL, GimpPolygonSelectTool))
#define GIMP_POLYGON_SELECT_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_POLYGON_SELECT_TOOL, GimpPolygonSelectToolClass))
#define GIMP_IS_POLYGON_SELECT_TOOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_POLYGON_SELECT_TOOL))
#define GIMP_IS_POLYGON_SELECT_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_POLYGON_SELECT_TOOL))
#define GIMP_POLYGON_SELECT_TOOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_POLYGON_SELECT_TOOL, GimpPolygonSelectToolClass))
typedef struct _GimpPolygonSelectTool GimpPolygonSelectTool;
typedef struct _GimpPolygonSelectToolPrivate GimpPolygonSelectToolPrivate;
typedef struct _GimpPolygonSelectToolClass GimpPolygonSelectToolClass;
struct _GimpPolygonSelectTool
{
GimpSelectionTool parent_instance;
GimpPolygonSelectToolPrivate *priv;
};
struct _GimpPolygonSelectToolClass
{
GimpSelectionToolClass parent_class;
/* virtual functions */
void (* change_complete) (GimpPolygonSelectTool *poly_sel,
GimpDisplay *display);
void (* confirm) (GimpPolygonSelectTool *poly_sel,
GimpDisplay *display);
};
GType gimp_polygon_select_tool_get_type (void) G_GNUC_CONST;
gboolean gimp_polygon_select_tool_is_closed (GimpPolygonSelectTool *poly_sel);
void gimp_polygon_select_tool_get_points (GimpPolygonSelectTool *poly_sel,
const GimpVector2 **points,
gint *n_points);
/* protected functions */
gboolean gimp_polygon_select_tool_is_grabbed (GimpPolygonSelectTool *poly_sel);
void gimp_polygon_select_tool_halt (GimpPolygonSelectTool *poly_sel);
#endif /* __GIMP_POLYGON_SELECT_TOOL_H__ */