static gboolean
motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
{
gdouble x, y;
gdouble pressure;
GdkModifierType state;
if (event->is_hint)
{
gdk_device_get_state (event->device, event->window, NULL, &state);
gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_X, &x);
gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_Y, &y);
gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
}
else
{
x = event->x;
y = event->y;
gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
state = event->state;
}
if (state & GDK_BUTTON1_MASK && pixmap != NULL)
draw_brush (widget, event->device->source, x, y, pressure);
return TRUE;
}
static gint tablet_preview_motion(GtkWidget *widget, GdkEventMotion *event)
{
gdouble pressure = 0.0;
GdkModifierType state;
#if GTK_MAJOR_VERSION == 1
if (event->is_hint)
{
gdk_input_window_get_pointer (event->window, event->deviceid,
NULL, NULL, &pressure, NULL, NULL, &state);
}
else
{
pressure = event->pressure;
state = event->state;
}
#endif
#if GTK_MAJOR_VERSION == 2
if (event->is_hint) gdk_device_get_state (event->device, event->window, NULL, &state);
else state = event->state;
gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
#endif
if (state & GDK_BUTTON1_MASK)
tablet_update_pressure( pressure );
return TRUE;
}
static VALUE
gdkevent_get_axis(VALUE self, VALUE axis_use)
{
gdouble value;
gboolean ret = gdk_event_get_axis(get_gdkevent(self),
RVAL2GENUM(axis_use, GDK_TYPE_AXIS_USE), &value);
return ret ? rb_float_new(value) : Qnil;
}
static VALUE
gdkevent_get_axis(VALUE self, VALUE axis_use)
{
gdouble value;
gboolean ret = gdk_event_get_axis(RVAL2GDKEVENT(self),
RVAL2GDKAXISUSE(axis_use), &value);
return ret ? rb_float_new(value) : Qnil;
}
gboolean on_buttonpress (GtkWidget *win,
GdkEventButton *ev,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
gdouble pressure = 0.5;
/* get the data for this device */
GdkDevice *master = ev->device;
GromitDeviceData *masterdata =
g_hash_table_lookup(data->devdatatable, master);
GdkDevice *slave =
gdk_event_get_source_device ((GdkEvent *) ev);
GromitDeviceData *slavedata =
g_hash_table_lookup(data->devdatatable, slave);
if(data->debug)
g_printerr("DEBUG: Device '%s': Button %i Down at (x,y)=(%.2f : %.2f)\n",
gdk_device_get_name(slave), ev->button, ev->x, ev->y);
if (!masterdata->is_grabbed)
return FALSE;
/* See GdkModifierType. Am I fixing a Gtk misbehaviour??? */
ev->state |= 1 << (ev->button + 7);
if (ev->state != masterdata->state ||
ev->state != slavedata->state ||
masterdata->lastslave != slave)
select_tool (data, master, slave, ev->state);
slavedata->lastx = ev->x;
slavedata->lasty = ev->y;
slavedata->motion_time = ev->time;
snap_undo_state (data);
if (gdk_device_get_source(slave) == GDK_SOURCE_MOUSE)
{
data->maxwidth = slavedata->cur_context->width;
}
else
{
gdk_event_get_axis ((GdkEvent *) ev, GDK_AXIS_PRESSURE, &pressure);
data->maxwidth = (CLAMP (pressure + line_thickener, 0, 1) *
(double) (slavedata->cur_context->width -
slavedata->cur_context->minwidth) +
slavedata->cur_context->minwidth);
}
if (ev->button <= 5)
draw_line (data, slave, ev->x, ev->y, ev->x, ev->y);
coord_list_prepend (data, slave, ev->x, ev->y, data->maxwidth);
return TRUE;
}
static gboolean
button_press_event (GtkWidget *widget, GdkEventButton *event)
{
print_button_press (event->device);
if (event->button == 1 && pixmap != NULL) {
gdouble pressure;
gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
draw_brush (widget, event->device->source, event->x, event->y, pressure);
}
return TRUE;
}
/* Return the pressure passing the event. */
static gdouble
get_pressure (GdkEvent *ev)
{
gdouble ret_value = 1.0;
gdouble pressure = ret_value;
gboolean ret = gdk_event_get_axis (ev, GDK_AXIS_PRESSURE, &pressure);
if (ret)
{
ret_value = pressure;
}
return ret_value;
}
static gint
motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
{
GdkTimeCoord **events;
int n_events;
int i;
current_device = event->device;
cursor_proximity = TRUE;
if (event->state & GDK_BUTTON1_MASK && pixmap != NULL)
{
if (gdk_device_get_history (event->device, event->window,
motion_time, event->time,
&events, &n_events))
{
for (i=0; i<n_events; i++)
{
double x = 0, y = 0, pressure = 0.5;
gdk_device_get_axis (event->device, events[i]->axes, GDK_AXIS_X, &x);
gdk_device_get_axis (event->device, events[i]->axes, GDK_AXIS_Y, &y);
gdk_device_get_axis (event->device, events[i]->axes, GDK_AXIS_PRESSURE, &pressure);
draw_brush (widget, event->device->source, x, y, pressure);
print_axes (event->device, events[i]->axes);
}
gdk_device_free_history (events, n_events);
}
else
{
double pressure = 0.5;
gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
draw_brush (widget, event->device->source, event->x, event->y, pressure);
}
motion_time = event->time;
}
if (event->is_hint)
gdk_device_get_state (event->device, event->window, NULL, NULL);
print_axes (event->device, event->axes);
update_cursor (widget, event->x, event->y);
return TRUE;
}
static gint tablet_preview_button (GtkWidget *widget, GdkEventButton *event)
{
gdouble pressure = 0.0;
if (event->button == 1)
{
#if GTK_MAJOR_VERSION == 1
pressure = event->pressure;
#endif
#if GTK_MAJOR_VERSION == 2
gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
#endif
tablet_update_pressure( pressure );
}
return TRUE;
}
double get_pressure_multiplier(GdkEvent *event)
{
double rawpressure;
if (!gdk_event_get_axis(event, GDK_AXIS_PRESSURE, &rawpressure)) {
// it does not have the pressure then return 1
return 1.0;
}
// printf("Pressure [%f]\n", rawpressure);
return rawpressure;
/*
rawpressure = axes[2] / (device->axes[2].max - device->axes[2].min);
if (!finite_sized(rawpressure)) return 1.0;
return ((1-rawpressure)*5 + rawpressure*15);
*/
}
gboolean
gimp_device_info_get_event_coords (GimpDeviceInfo *info,
GdkWindow *window,
GdkEvent *event,
GimpCoords *coords)
{
gdouble x;
if (gdk_event_get_axis (event, GDK_AXIS_X, &x))
{
*coords = default_coords;
coords->x = x;
gdk_event_get_axis (event, GDK_AXIS_Y, &coords->y);
if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &coords->pressure))
{
coords->pressure = gimp_device_info_map_axis (info,
GDK_AXIS_PRESSURE,
coords->pressure);
}
if (gdk_event_get_axis (event, GDK_AXIS_XTILT, &coords->xtilt))
{
coords->xtilt = gimp_device_info_map_axis (info,
GDK_AXIS_XTILT,
coords->xtilt);
}
if (gdk_event_get_axis (event, GDK_AXIS_YTILT, &coords->ytilt))
{
coords->ytilt = gimp_device_info_map_axis (info,
GDK_AXIS_YTILT,
coords->ytilt);
}
if (gdk_event_get_axis (event, GDK_AXIS_WHEEL, &coords->wheel))
{
coords->wheel = gimp_device_info_map_axis (info,
GDK_AXIS_WHEEL,
coords->wheel);
}
return TRUE;
}
gimp_device_info_get_device_coords (info, window, coords);
return FALSE;
}
/**
* hildon_helper_event_button_is_finger:
* @event: A #GtkEventButton to check
*
* Checks if the given button event is a finger event.
*
* Return value: TRUE if the event is a finger event.
**/
gboolean
hildon_helper_event_button_is_finger (GdkEventButton *event)
{
gdouble pressure;
if (gdk_event_get_axis ((GdkEvent*) event, GDK_AXIS_PRESSURE, &pressure) &&
pressure > HILDON_FINGER_PRESSURE_THRESHOLD)
return TRUE;
if (event->button == HILDON_FINGER_BUTTON)
return TRUE;
if (event->button == HILDON_FINGER_ALT_BUTTON &&
event->state & HILDON_FINGER_ALT_MASK)
return TRUE;
if (event->button == HILDON_FINGER_SIMULATE_BUTTON)
return TRUE;
return FALSE;
}
static gint
button_press_event (GtkWidget *widget, GdkEventButton *event)
{
current_device = event->device;
cursor_proximity = TRUE;
if (event->button == 1 && pixmap != NULL)
{
gdouble pressure = 0.5;
print_axes (event->device, event->axes);
gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
draw_brush (widget, event->device->source, event->x, event->y, pressure);
motion_time = event->time;
}
update_cursor (widget, event->x, event->y);
return TRUE;
}
gboolean
gimp_device_info_get_event_coords (GimpDeviceInfo *info,
GdkWindow *window,
const GdkEvent *event,
GimpCoords *coords)
{
gdouble x;
if (gdk_event_get_axis (event, GDK_AXIS_X, &x))
{
*coords = default_coords;
coords->x = x;
gdk_event_get_axis (event, GDK_AXIS_Y, &coords->y);
/* translate event coordinates to window coordinates, only
* happens if we drag a guide from a ruler
*/
if (event->any.window &&
event->any.window != window)
{
GtkWidget *src_widget;
GtkWidget *dest_widget;
src_widget = gtk_get_event_widget ((GdkEvent *) event);
gdk_window_get_user_data (window, (gpointer) &dest_widget);
if (src_widget && dest_widget)
{
gint offset_x;
gint offset_y;
if (gtk_widget_translate_coordinates (src_widget, dest_widget,
0, 0,
&offset_x, &offset_y))
{
coords->x += offset_x;
coords->y += offset_y;
}
}
}
if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &coords->pressure))
{
coords->pressure = gimp_device_info_map_axis (info,
GDK_AXIS_PRESSURE,
coords->pressure);
}
if (gdk_event_get_axis (event, GDK_AXIS_XTILT, &coords->xtilt))
{
coords->xtilt = gimp_device_info_map_axis (info,
GDK_AXIS_XTILT,
coords->xtilt);
}
if (gdk_event_get_axis (event, GDK_AXIS_YTILT, &coords->ytilt))
{
coords->ytilt = gimp_device_info_map_axis (info,
GDK_AXIS_YTILT,
coords->ytilt);
}
if (gdk_event_get_axis (event, GDK_AXIS_WHEEL, &coords->wheel))
{
coords->wheel = gimp_device_info_map_axis (info,
GDK_AXIS_WHEEL,
coords->wheel);
}
if (gimp_device_info_get_mode (info) != GDK_MODE_DISABLED &&
gdk_device_get_source (info->device) != GDK_SOURCE_MOUSE)
{
/* The event was generated by an enabled extended non-mouse device */
coords->extended = TRUE;
}
else
{
/* The event was generated by a not extended enabled device */
coords->extended = FALSE;
}
return TRUE;
}
gimp_device_info_get_device_coords (info, window, coords);
return FALSE;
}
static gboolean
motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
ColorselWater *water)
{
GtkAllocation allocation;
GdkTimeCoord **coords;
gint nevents;
gint i;
gboolean erase;
gtk_widget_get_allocation (widget, &allocation);
if (event->state & (GDK_BUTTON1_MASK |
GDK_BUTTON2_MASK |
GDK_BUTTON3_MASK |
GDK_BUTTON4_MASK))
{
guint32 last_motion_time = event->time;
erase = ((event->state &
(GDK_BUTTON2_MASK | GDK_BUTTON3_MASK | GDK_BUTTON4_MASK)) ||
FALSE);
/* FIXME: (event->source == GDK_SOURCE_ERASER) */
if (event->state & GDK_SHIFT_MASK)
erase = !erase;
water->motion_time = event->time;
if (gdk_device_get_history (event->device,
event->window,
last_motion_time,
event->time,
&coords,
&nevents))
{
for (i = 0; i < nevents; i++)
{
gdouble x = 0.0;
gdouble y = 0.0;
gdouble pressure = 0.5;
gdk_device_get_axis (event->device, coords[i]->axes,
GDK_AXIS_X, &x);
gdk_device_get_axis (event->device, coords[i]->axes,
GDK_AXIS_Y, &y);
gdk_device_get_axis (event->device, coords[i]->axes,
GDK_AXIS_PRESSURE, &pressure);
draw_brush (water, widget, erase,
x / allocation.width,
y / allocation.height, pressure);
}
g_free (coords);
}
else
{
gdouble pressure = 0.5;
gdk_event_get_axis ((GdkEvent *) event, GDK_AXIS_PRESSURE, &pressure);
draw_brush (water, widget, erase,
event->x / allocation.width,
event->y / allocation.height, pressure);
}
}
/* Ask for more motion events in case the event was a hint */
gdk_event_request_motions (event);
return TRUE;
}
gboolean
gimp_device_info_get_event_coords (GimpDeviceInfo *info,
GdkWindow *window,
const GdkEvent *event,
GimpCoords *coords)
{
gdouble x;
if (gdk_event_get_axis (event, GDK_AXIS_X, &x))
{
*coords = default_coords;
coords->x = x;
gdk_event_get_axis (event, GDK_AXIS_Y, &coords->y);
/* translate event coordinates to window coordinates, only
* happens if we drag a guide from a ruler
*/
if (event->any.window &&
event->any.window != window)
{
GtkWidget *src_widget;
GtkWidget *dest_widget;
src_widget = gtk_get_event_widget ((GdkEvent *) event);
gdk_window_get_user_data (window, (gpointer) &dest_widget);
if (src_widget && dest_widget)
{
gint offset_x;
gint offset_y;
gtk_widget_translate_coordinates (src_widget, dest_widget,
0, 0, &offset_x, &offset_y);
coords->x += offset_x;
coords->y += offset_y;
}
}
if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &coords->pressure))
{
coords->pressure = gimp_device_info_map_axis (info,
GDK_AXIS_PRESSURE,
coords->pressure);
}
if (gdk_event_get_axis (event, GDK_AXIS_XTILT, &coords->xtilt))
{
coords->xtilt = gimp_device_info_map_axis (info,
GDK_AXIS_XTILT,
coords->xtilt);
}
if (gdk_event_get_axis (event, GDK_AXIS_YTILT, &coords->ytilt))
{
coords->ytilt = gimp_device_info_map_axis (info,
GDK_AXIS_YTILT,
coords->ytilt);
}
if (gdk_event_get_axis (event, GDK_AXIS_WHEEL, &coords->wheel))
{
coords->wheel = gimp_device_info_map_axis (info,
GDK_AXIS_WHEEL,
coords->wheel);
}
return TRUE;
}
gimp_device_info_get_device_coords (info, window, coords);
return FALSE;
}
gboolean on_motion (GtkWidget *win,
GdkEventMotion *ev,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
GdkTimeCoord **coords = NULL;
gint nevents;
int i;
gdouble pressure = 0.5;
/* get the data for this device */
GdkDevice *master = ev->device;
GromitDeviceData *masterdata =
g_hash_table_lookup(data->devdatatable, master);
if (!masterdata->is_grabbed)
return FALSE;
GdkDevice *slave =
gdk_event_get_source_device ((GdkEvent *) ev);
GromitDeviceData *slavedata =
g_hash_table_lookup(data->devdatatable, slave);
if (ev->state != masterdata->state ||
ev->state != slavedata->state ||
masterdata->lastslave != slave)
select_tool (data, master, slave, ev->state);
if(!(ev->state & (GDK_BUTTON1_MASK|
GDK_BUTTON2_MASK|
GDK_BUTTON3_MASK|
GDK_BUTTON4_MASK|
GDK_BUTTON5_MASK)))
return TRUE;
gdk_device_get_history (slave, ev->window,
slavedata->motion_time, ev->time,
&coords, &nevents);
if(!data->xinerama && nevents > 0)
{
for (i=0; i < nevents; i++)
{
gdouble x, y;
gdk_device_get_axis (slave, coords[i]->axes,
GDK_AXIS_PRESSURE, &pressure);
if (pressure > 0)
{
if (gdk_device_get_source(slave) == GDK_SOURCE_MOUSE)
data->maxwidth = slavedata->cur_context->width;
else
data->maxwidth = (CLAMP (pressure + line_thickener, 0, 1) *
(double) (slavedata->cur_context->width -
slavedata->cur_context->minwidth) +
slavedata->cur_context->minwidth);
gdk_device_get_axis(slave, coords[i]->axes,
GDK_AXIS_X, &x);
gdk_device_get_axis(slave, coords[i]->axes,
GDK_AXIS_Y, &y);
draw_line (data, slave, slavedata->lastx, slavedata->lasty, x, y);
coord_list_prepend (data, slave, x, y, data->maxwidth);
slavedata->lastx = x;
slavedata->lasty = y;
}
}
slavedata->motion_time = coords[nevents-1]->time;
g_free (coords);
}
/* always paint to the current event coordinate. */
gdk_event_get_axis ((GdkEvent *) ev, GDK_AXIS_PRESSURE, &pressure);
if (pressure > 0)
{
if (gdk_device_get_source(slave) == GDK_SOURCE_MOUSE)
data->maxwidth = slavedata->cur_context->width;
else
data->maxwidth = (CLAMP (pressure + line_thickener, 0, 1) *
(double) (slavedata->cur_context->width -
slavedata->cur_context->minwidth) +
slavedata->cur_context->minwidth);
if(slavedata->motion_time > 0)
{
draw_line (data, slave, slavedata->lastx, slavedata->lasty, ev->x, ev->y);
coord_list_prepend (data, slave, ev->x, ev->y, data->maxwidth);
}
}
slavedata->lastx = ev->x;
slavedata->lasty = ev->y;
slavedata->motion_time = ev->time;
return TRUE;
}
/**
* Called to handle events on knots.
*/
static int sp_knot_handler(SPCanvasItem */*item*/, GdkEvent *event, SPKnot *knot)
{
g_assert(knot != NULL);
g_assert(SP_IS_KNOT(knot));
/* Run client universal event handler, if present */
gboolean consumed = FALSE;
g_signal_emit(knot, knot_signals[EVENT], 0, event, &consumed);
if (consumed) {
return TRUE;
}
g_object_ref(knot);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
switch (event->type) {
case GDK_2BUTTON_PRESS:
if (event->button.button == 1) {
g_signal_emit(knot, knot_signals[DOUBLECLICKED], 0, event->button.state);
grabbed = FALSE;
moved = FALSE;
consumed = TRUE;
}
break;
case GDK_BUTTON_PRESS:
if (event->button.button == 1 && !knot->desktop->event_context->space_panning) {
Geom::Point const p = knot->desktop->w2d(Geom::Point(event->button.x, event->button.y));
sp_knot_start_dragging(knot, p, (gint) event->button.x, (gint) event->button.y, event->button.time);
consumed = TRUE;
}
break;
case GDK_BUTTON_RELEASE:
if (event->button.button == 1 && !knot->desktop->event_context->space_panning) {
knot->pressure = 0;
if (transform_escaped) {
transform_escaped = false;
consumed = TRUE;
} else {
sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
if (!nograb) {
sp_canvas_item_ungrab(knot->item, event->button.time);
}
if (moved) {
sp_knot_set_flag(knot,
SP_KNOT_DRAGGING,
FALSE);
g_signal_emit(knot,
knot_signals[UNGRABBED], 0,
event->button.state);
knot->_ungrabbed_signal.emit(knot);
} else {
g_signal_emit(knot,
knot_signals[CLICKED], 0,
event->button.state);
knot->_click_signal.emit(knot, event->button.state);
}
grabbed = FALSE;
moved = FALSE;
consumed = TRUE;
}
}
break;
case GDK_MOTION_NOTIFY:
if (grabbed && !knot->desktop->event_context->space_panning) {
consumed = TRUE;
if ( within_tolerance
&& ( abs( (gint) event->motion.x - xp ) < tolerance )
&& ( abs( (gint) event->motion.y - yp ) < tolerance ) ) {
break; // do not drag if we're within tolerance from origin
}
// Once the user has moved farther than tolerance from the original location
// (indicating they intend to move the object, not click), then always process the
// motion notify coordinates as given (no snapping back to origin)
within_tolerance = false;
if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &knot->pressure))
knot->pressure = CLAMP (knot->pressure, 0, 1);
else
knot->pressure = 0.5;
if (!moved) {
g_signal_emit(knot,
knot_signals[GRABBED], 0,
event->motion.state);
sp_knot_set_flag(knot,
SP_KNOT_DRAGGING,
TRUE);
}
Geom::Point const motion_w(event->motion.x, event->motion.y);
Geom::Point const motion_dt = knot->desktop->w2d(motion_w);
Geom::Point p = motion_dt - knot->grabbed_rel_pos;
sp_knot_request_position (knot, p, event->motion.state);
knot->desktop->scroll_to_point (motion_dt);
knot->desktop->set_coordinate_status(knot->pos); // display the coordinate of knot, not cursor - they may be different!
if (event->motion.state & GDK_BUTTON1_MASK)
gobble_motion_events(GDK_BUTTON1_MASK);
moved = TRUE;
}
break;
case GDK_ENTER_NOTIFY:
sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, TRUE);
sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
if (knot->tip) {
knot->desktop->event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, knot->tip);
}
grabbed = FALSE;
moved = FALSE;
consumed = TRUE;
break;
case GDK_LEAVE_NOTIFY:
sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, FALSE);
sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
if (knot->tip) {
knot->desktop->event_context->defaultMessageContext()->clear();
}
grabbed = FALSE;
moved = FALSE;
consumed = TRUE;
break;
case GDK_KEY_PRESS: // keybindings for knot
switch (get_group0_keyval(&event->key)) {
case GDK_Escape:
sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
if (!nograb) {
sp_canvas_item_ungrab(knot->item, event->button.time);
}
if (moved) {
sp_knot_set_flag(knot,
SP_KNOT_DRAGGING,
FALSE);
g_signal_emit(knot,
knot_signals[UNGRABBED], 0,
event->button.state);
sp_document_undo(sp_desktop_document(knot->desktop));
knot->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Node or handle drag canceled."));
transform_escaped = true;
consumed = TRUE;
}
grabbed = FALSE;
moved = FALSE;
break;
default:
consumed = FALSE;
break;
}
break;
default:
break;
}
g_object_unref(knot);
return consumed;
}