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

1134 lines
34 KiB
C
Raw Blame History

/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimptoolwidget.c
* Copyright (C) 2017 Michael Natterer <mitch@gimp.org>
*
* 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 <stdarg.h>
#include <gegl.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "libgimpbase/gimpbase.h"
#include "display-types.h"
#include "core/gimpmarshal.h"
#include "gimpcanvasarc.h"
#include "gimpcanvascorner.h"
#include "gimpcanvasgroup.h"
#include "gimpcanvashandle.h"
#include "gimpcanvaslimit.h"
#include "gimpcanvasline.h"
#include "gimpcanvaspath.h"
#include "gimpcanvaspolygon.h"
#include "gimpcanvasrectangle.h"
#include "gimpcanvasrectangleguides.h"
#include "gimpcanvastransformguides.h"
#include "gimpdisplayshell.h"
#include "gimptoolwidget.h"
enum
{
PROP_0,
PROP_SHELL,
PROP_ITEM
};
enum
{
CHANGED,
RESPONSE,
SNAP_OFFSETS,
STATUS,
STATUS_COORDS,
MESSAGE,
FOCUS_CHANGED,
LAST_SIGNAL
};
struct _GimpToolWidgetPrivate
{
GimpDisplayShell *shell;
GimpCanvasItem *item;
GList *group_stack;
gint snap_offset_x;
gint snap_offset_y;
gint snap_width;
gint snap_height;
gboolean visible;
gboolean focus;
};
/* local function prototypes */
static void gimp_tool_widget_finalize (GObject *object);
static void gimp_tool_widget_constructed (GObject *object);
static void gimp_tool_widget_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_tool_widget_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_tool_widget_properties_changed (GObject *object,
guint n_pspecs,
GParamSpec **pspecs);
static void gimp_tool_widget_real_leave_notify (GimpToolWidget *widget);
static gboolean gimp_tool_widget_real_key_press (GimpToolWidget *widget,
GdkEventKey *kevent);
G_DEFINE_TYPE_WITH_PRIVATE (GimpToolWidget, gimp_tool_widget, GIMP_TYPE_OBJECT)
#define parent_class gimp_tool_widget_parent_class
static guint widget_signals[LAST_SIGNAL] = { 0 };
static void
gimp_tool_widget_class_init (GimpToolWidgetClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gimp_tool_widget_finalize;
object_class->constructed = gimp_tool_widget_constructed;
object_class->set_property = gimp_tool_widget_set_property;
object_class->get_property = gimp_tool_widget_get_property;
object_class->dispatch_properties_changed = gimp_tool_widget_properties_changed;
klass->leave_notify = gimp_tool_widget_real_leave_notify;
klass->key_press = gimp_tool_widget_real_key_press;
widget_signals[CHANGED] =
g_signal_new ("changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpToolWidgetClass, changed),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
widget_signals[RESPONSE] =
g_signal_new ("response",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpToolWidgetClass, response),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
G_TYPE_INT);
widget_signals[SNAP_OFFSETS] =
g_signal_new ("snap-offsets",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpToolWidgetClass, snap_offsets),
NULL, NULL,
gimp_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
widget_signals[STATUS] =
g_signal_new ("status",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpToolWidgetClass, status),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
G_TYPE_STRING);
widget_signals[STATUS_COORDS] =
g_signal_new ("status-coords",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpToolWidgetClass, status_coords),
NULL, NULL,
gimp_marshal_VOID__STRING_DOUBLE_STRING_DOUBLE_STRING,
G_TYPE_NONE, 5,
G_TYPE_STRING,
G_TYPE_DOUBLE,
G_TYPE_STRING,
G_TYPE_DOUBLE,
G_TYPE_STRING);
widget_signals[MESSAGE] =
g_signal_new ("message",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpToolWidgetClass, message),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
G_TYPE_STRING);
widget_signals[FOCUS_CHANGED] =
g_signal_new ("focus-changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpToolWidgetClass, focus_changed),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
g_object_class_install_property (object_class, PROP_SHELL,
g_param_spec_object ("shell",
NULL, NULL,
GIMP_TYPE_DISPLAY_SHELL,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_ITEM,
g_param_spec_object ("item",
NULL, NULL,
GIMP_TYPE_CANVAS_ITEM,
GIMP_PARAM_READABLE));
}
static void
gimp_tool_widget_init (GimpToolWidget *widget)
{
widget->private = gimp_tool_widget_get_instance_private (widget);
widget->private->visible = TRUE;
}
static void
gimp_tool_widget_constructed (GObject *object)
{
GimpToolWidget *widget = GIMP_TOOL_WIDGET (object);
GimpToolWidgetPrivate *private = widget->private;
GimpToolWidgetClass *klass = GIMP_TOOL_WIDGET_GET_CLASS (widget);
G_OBJECT_CLASS (parent_class)->constructed (object);
gimp_assert (GIMP_IS_DISPLAY_SHELL (private->shell));
private->item = gimp_canvas_group_new (private->shell);
gimp_canvas_item_set_visible (private->item, private->visible);
if (klass->changed)
{
if (klass->update_on_scale)
{
g_signal_connect_object (private->shell, "scaled",
G_CALLBACK (klass->changed),
widget,
G_CONNECT_SWAPPED);
}
if (klass->update_on_scroll)
{
g_signal_connect_object (private->shell, "scrolled",
G_CALLBACK (klass->changed),
widget,
G_CONNECT_SWAPPED);
}
if (klass->update_on_rotate)
{
g_signal_connect_object (private->shell, "rotated",
G_CALLBACK (klass->changed),
widget,
G_CONNECT_SWAPPED);
}
}
}
static void
gimp_tool_widget_finalize (GObject *object)
{
GimpToolWidget *widget = GIMP_TOOL_WIDGET (object);
GimpToolWidgetPrivate *private = widget->private;
g_clear_object (&private->item);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_tool_widget_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpToolWidget *widget = GIMP_TOOL_WIDGET (object);
GimpToolWidgetPrivate *private = widget->private;
switch (property_id)
{
case PROP_SHELL:
private->shell = g_value_get_object (value); /* don't ref */
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_tool_widget_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpToolWidget *widget = GIMP_TOOL_WIDGET (object);
GimpToolWidgetPrivate *private = widget->private;
switch (property_id)
{
case PROP_SHELL:
g_value_set_object (value, private->shell);
break;
case PROP_ITEM:
g_value_set_object (value, private->item);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_tool_widget_properties_changed (GObject *object,
guint n_pspecs,
GParamSpec **pspecs)
{
GimpToolWidget *widget = GIMP_TOOL_WIDGET (object);
G_OBJECT_CLASS (parent_class)->dispatch_properties_changed (object,
n_pspecs,
pspecs);
gimp_tool_widget_changed (widget);
}
static void
gimp_tool_widget_real_leave_notify (GimpToolWidget *widget)
{
gimp_tool_widget_set_status (widget, NULL);
}
static gboolean
gimp_tool_widget_real_key_press (GimpToolWidget *widget,
GdkEventKey *kevent)
{
switch (kevent->keyval)
{
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
gimp_tool_widget_response (widget, GIMP_TOOL_WIDGET_RESPONSE_CONFIRM);
return TRUE;
case GDK_KEY_Escape:
gimp_tool_widget_response (widget, GIMP_TOOL_WIDGET_RESPONSE_CANCEL);
return TRUE;
case GDK_KEY_BackSpace:
gimp_tool_widget_response (widget, GIMP_TOOL_WIDGET_RESPONSE_RESET);
return TRUE;
default:
break;
}
return FALSE;
}
/* public functions */
GimpDisplayShell *
gimp_tool_widget_get_shell (GimpToolWidget *widget)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
return widget->private->shell;
}
GimpCanvasItem *
gimp_tool_widget_get_item (GimpToolWidget *widget)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
return widget->private->item;
}
void
gimp_tool_widget_set_visible (GimpToolWidget *widget,
gboolean visible)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
if (visible != widget->private->visible)
{
widget->private->visible = visible;
if (widget->private->item)
gimp_canvas_item_set_visible (widget->private->item, visible);
if (! visible)
gimp_tool_widget_set_status (widget, NULL);
}
}
gboolean
gimp_tool_widget_get_visible (GimpToolWidget *widget)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), FALSE);
return widget->private->visible;
}
void
gimp_tool_widget_set_focus (GimpToolWidget *widget,
gboolean focus)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
if (focus != widget->private->focus)
{
widget->private->focus = focus;
g_signal_emit (widget, widget_signals[FOCUS_CHANGED], 0);
}
}
gboolean
gimp_tool_widget_get_focus (GimpToolWidget *widget)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), FALSE);
return widget->private->focus;
}
void
gimp_tool_widget_changed (GimpToolWidget *widget)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_signal_emit (widget, widget_signals[CHANGED], 0);
}
void
gimp_tool_widget_response (GimpToolWidget *widget,
gint response_id)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_signal_emit (widget, widget_signals[RESPONSE], 0,
response_id);
}
void
gimp_tool_widget_set_snap_offsets (GimpToolWidget *widget,
gint offset_x,
gint offset_y,
gint width,
gint height)
{
GimpToolWidgetPrivate *private;
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
private = widget->private;
if (offset_x != private->snap_offset_x ||
offset_y != private->snap_offset_y ||
width != private->snap_width ||
height != private->snap_height)
{
private->snap_offset_x = offset_x;
private->snap_offset_y = offset_y;
private->snap_width = width;
private->snap_height = height;
g_signal_emit (widget, widget_signals[SNAP_OFFSETS], 0,
offset_x, offset_y, width, height);
}
}
void
gimp_tool_widget_get_snap_offsets (GimpToolWidget *widget,
gint *offset_x,
gint *offset_y,
gint *width,
gint *height)
{
GimpToolWidgetPrivate *private;
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
private = widget->private;
if (offset_x) *offset_x = private->snap_offset_x;
if (offset_y) *offset_y = private->snap_offset_y;
if (width) *width = private->snap_width;
if (height) *height = private->snap_height;
}
void
gimp_tool_widget_set_status (GimpToolWidget *widget,
const gchar *status)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_signal_emit (widget, widget_signals[STATUS], 0,
status);
}
void
gimp_tool_widget_set_status_coords (GimpToolWidget *widget,
const gchar *title,
gdouble x,
const gchar *separator,
gdouble y,
const gchar *help)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_signal_emit (widget, widget_signals[STATUS_COORDS], 0,
title, x, separator, y, help);
}
void
gimp_tool_widget_message (GimpToolWidget *widget,
const gchar *format,
...)
{
va_list args;
gchar *message;
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_return_if_fail (format != NULL);
va_start (args, format);
message = g_strdup_vprintf (format, args);
va_end (args);
gimp_tool_widget_message_literal (widget, message);
g_free (message);
}
void
gimp_tool_widget_message_literal (GimpToolWidget *widget,
const gchar *message)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_return_if_fail (message != NULL);
g_signal_emit (widget, widget_signals[MESSAGE], 0,
message);
}
void
gimp_tool_widget_add_item (GimpToolWidget *widget,
GimpCanvasItem *item)
{
GimpCanvasGroup *group;
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_return_if_fail (GIMP_IS_CANVAS_ITEM (item));
group = GIMP_CANVAS_GROUP (widget->private->item);
if (widget->private->group_stack)
group = widget->private->group_stack->data;
gimp_canvas_group_add_item (group, item);
}
void
gimp_tool_widget_remove_item (GimpToolWidget *widget,
GimpCanvasItem *item)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_return_if_fail (GIMP_IS_CANVAS_ITEM (item));
gimp_canvas_group_remove_item (GIMP_CANVAS_GROUP (widget->private->item),
item);
}
GimpCanvasGroup *
gimp_tool_widget_add_group (GimpToolWidget *widget)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_group_new (widget->private->shell);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return GIMP_CANVAS_GROUP (item);
}
GimpCanvasGroup *
gimp_tool_widget_add_stroke_group (GimpToolWidget *widget)
{
GimpCanvasGroup *group;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
group = gimp_tool_widget_add_group (widget);
gimp_canvas_group_set_group_stroking (group, TRUE);
return group;
}
GimpCanvasGroup *
gimp_tool_widget_add_fill_group (GimpToolWidget *widget)
{
GimpCanvasGroup *group;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
group = gimp_tool_widget_add_group (widget);
gimp_canvas_group_set_group_filling (group, TRUE);
return group;
}
void
gimp_tool_widget_push_group (GimpToolWidget *widget,
GimpCanvasGroup *group)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_return_if_fail (GIMP_IS_CANVAS_GROUP (group));
widget->private->group_stack = g_list_prepend (widget->private->group_stack,
group);
}
void
gimp_tool_widget_pop_group (GimpToolWidget *widget)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_return_if_fail (widget->private->group_stack != NULL);
widget->private->group_stack = g_list_remove (widget->private->group_stack,
widget->private->group_stack->data);
}
/**
* gimp_tool_widget_add_line:
* @widget: the #GimpToolWidget
* @x1: start point X in image coordinates
* @y1: start point Y in image coordinates
* @x2: end point X in image coordinates
* @y2: end point Y in image coordinates
*
* This function adds a #GimpCanvasLine to @widget.
**/
GimpCanvasItem *
gimp_tool_widget_add_line (GimpToolWidget *widget,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_line_new (widget->private->shell,
x1, y1, x2, y2);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_rectangle (GimpToolWidget *widget,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
gboolean filled)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_rectangle_new (widget->private->shell,
x, y, width, height, filled);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_arc (GimpToolWidget *widget,
gdouble center_x,
gdouble center_y,
gdouble radius_x,
gdouble radius_y,
gdouble start_angle,
gdouble slice_angle,
gboolean filled)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_arc_new (widget->private->shell,
center_x, center_y,
radius_x, radius_y,
start_angle, slice_angle,
filled);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_limit (GimpToolWidget *widget,
GimpLimitType type,
gdouble x,
gdouble y,
gdouble radius,
gdouble aspect_ratio,
gdouble angle,
gboolean dashed)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_limit_new (widget->private->shell,
type,
x, y,
radius,
aspect_ratio,
angle,
dashed);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_polygon (GimpToolWidget *widget,
GimpMatrix3 *transform,
const GimpVector2 *points,
gint n_points,
gboolean filled)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
g_return_val_if_fail (points == NULL || n_points > 0, NULL);
item = gimp_canvas_polygon_new (widget->private->shell,
points, n_points,
transform, filled);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_polygon_from_coords (GimpToolWidget *widget,
GimpMatrix3 *transform,
const GimpCoords *points,
gint n_points,
gboolean filled)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
g_return_val_if_fail (points == NULL || n_points > 0, NULL);
item = gimp_canvas_polygon_new_from_coords (widget->private->shell,
points, n_points,
transform, filled);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_path (GimpToolWidget *widget,
const GimpBezierDesc *desc)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_path_new (widget->private->shell,
desc, 0, 0, FALSE, GIMP_PATH_STYLE_DEFAULT);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_handle (GimpToolWidget *widget,
GimpHandleType type,
gdouble x,
gdouble y,
gint width,
gint height,
GimpHandleAnchor anchor)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_handle_new (widget->private->shell,
type, anchor, x, y, width, height);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_corner (GimpToolWidget *widget,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpHandleAnchor anchor,
gint corner_width,
gint corner_height,
gboolean outside)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_corner_new (widget->private->shell,
x, y, width, height,
anchor, corner_width, corner_height,
outside);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_rectangle_guides (GimpToolWidget *widget,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
GimpGuidesType type)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_rectangle_guides_new (widget->private->shell,
x, y, width, height, type, 4);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
GimpCanvasItem *
gimp_tool_widget_add_transform_guides (GimpToolWidget *widget,
const GimpMatrix3 *transform,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
GimpGuidesType type,
gint n_guides,
gboolean clip)
{
GimpCanvasItem *item;
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
item = gimp_canvas_transform_guides_new (widget->private->shell,
transform, x1, y1, x2, y2,
type, n_guides, clip);
gimp_tool_widget_add_item (widget, item);
g_object_unref (item);
return item;
}
gint
gimp_tool_widget_button_press (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), 0);
g_return_val_if_fail (coords != NULL, 0);
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->button_press)
{
return GIMP_TOOL_WIDGET_GET_CLASS (widget)->button_press (widget,
coords, time,
state,
press_type);
}
return 0;
}
void
gimp_tool_widget_button_release (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_return_if_fail (coords != NULL);
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->button_release)
{
GIMP_TOOL_WIDGET_GET_CLASS (widget)->button_release (widget,
coords, time, state,
release_type);
}
}
void
gimp_tool_widget_motion (GimpToolWidget *widget,
const GimpCoords *coords,
guint32 time,
GdkModifierType state)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_return_if_fail (coords != NULL);
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->motion)
{
GIMP_TOOL_WIDGET_GET_CLASS (widget)->motion (widget,
coords, time, state);
}
}
GimpHit
gimp_tool_widget_hit (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), GIMP_HIT_NONE);
g_return_val_if_fail (coords != NULL, GIMP_HIT_NONE);
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->hit)
{
return GIMP_TOOL_WIDGET_GET_CLASS (widget)->hit (widget,
coords, state,
proximity);
}
return GIMP_HIT_NONE;
}
void
gimp_tool_widget_hover (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
g_return_if_fail (coords != NULL);
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->hover)
{
GIMP_TOOL_WIDGET_GET_CLASS (widget)->hover (widget,
coords, state, proximity);
}
}
void
gimp_tool_widget_leave_notify (GimpToolWidget *widget)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->leave_notify)
{
GIMP_TOOL_WIDGET_GET_CLASS (widget)->leave_notify (widget);
}
}
gboolean
gimp_tool_widget_key_press (GimpToolWidget *widget,
GdkEventKey *kevent)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), FALSE);
g_return_val_if_fail (kevent != NULL, FALSE);
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->key_press)
{
return GIMP_TOOL_WIDGET_GET_CLASS (widget)->key_press (widget, kevent);
}
return FALSE;
}
gboolean
gimp_tool_widget_key_release (GimpToolWidget *widget,
GdkEventKey *kevent)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), FALSE);
g_return_val_if_fail (kevent != NULL, FALSE);
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->key_release)
{
return GIMP_TOOL_WIDGET_GET_CLASS (widget)->key_release (widget, kevent);
}
return FALSE;
}
void
gimp_tool_widget_motion_modifier (GimpToolWidget *widget,
GdkModifierType key,
gboolean press,
GdkModifierType state)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->motion_modifier)
{
GIMP_TOOL_WIDGET_GET_CLASS (widget)->motion_modifier (widget,
key, press, state);
}
}
void
gimp_tool_widget_hover_modifier (GimpToolWidget *widget,
GdkModifierType key,
gboolean press,
GdkModifierType state)
{
g_return_if_fail (GIMP_IS_TOOL_WIDGET (widget));
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->hover_modifier)
{
GIMP_TOOL_WIDGET_GET_CLASS (widget)->hover_modifier (widget,
key, press, state);
}
}
gboolean
gimp_tool_widget_get_cursor (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
GimpCursorType *cursor,
GimpToolCursorType *tool_cursor,
GimpCursorModifier *modifier)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), FALSE);
g_return_val_if_fail (coords != NULL, FALSE);
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->get_cursor)
{
GimpCursorType my_cursor;
GimpToolCursorType my_tool_cursor;
GimpCursorModifier my_modifier;
if (cursor) my_cursor = *cursor;
if (tool_cursor) my_tool_cursor = *tool_cursor;
if (modifier) my_modifier = *modifier;
if (GIMP_TOOL_WIDGET_GET_CLASS (widget)->get_cursor (widget, coords,
state,
&my_cursor,
&my_tool_cursor,
&my_modifier))
{
if (cursor) *cursor = my_cursor;
if (tool_cursor) *tool_cursor = my_tool_cursor;
if (modifier) *modifier = my_modifier;
return TRUE;
}
}
return FALSE;
}
GimpUIManager *
gimp_tool_widget_get_popup (GimpToolWidget *widget,
const GimpCoords *coords,
GdkModifierType state,
const gchar **ui_path)
{
g_return_val_if_fail (GIMP_IS_TOOL_WIDGET (widget), NULL);
g_return_val_if_fail (coords != NULL, NULL);
if (widget->private->visible &&
GIMP_TOOL_WIDGET_GET_CLASS (widget)->get_popup)
{
return GIMP_TOOL_WIDGET_GET_CLASS (widget)->get_popup (widget, coords,
state, ui_path);
}
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink