Compare commits
20 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Matthias Clasen
|
2f57ab8aee | ||
|
Matthias Clasen
|
1f3b307c2f | ||
|
Matthias Clasen
|
9b17f02fa3 | ||
|
Matthias Clasen
|
35d2dac64c | ||
|
Matthias Clasen
|
d4920b9bb5 | ||
|
Matthias Clasen
|
e7fe73558b | ||
|
Matthias Clasen
|
159b7e847f | ||
|
Matthias Clasen
|
ebd9d7b577 | ||
|
Matthias Clasen
|
bfc51444b7 | ||
|
Matthias Clasen
|
9029260d31 | ||
|
Matthias Clasen
|
8f78a3c417 | ||
|
Matthias Clasen
|
0167bb7348 | ||
|
Matthias Clasen
|
b2c317e33a | ||
|
Matthias Clasen
|
e2a6d045e4 | ||
|
Matthias Clasen
|
d9c43f67f2 | ||
|
Matthias Clasen
|
c6d122ccb7 | ||
|
Matthias Clasen
|
1375f35a6b | ||
|
Matthias Clasen
|
13e8d6f744 | ||
|
Matthias Clasen
|
fad20bcb29 | ||
|
Matthias Clasen
|
04b4b5f6ca |
@@ -100,17 +100,16 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
surface = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_surface_id));
|
||||
if (surface)
|
||||
{
|
||||
event = gdk_event_new (GDK_ENTER_NOTIFY);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->crossing.time = message->base.time;
|
||||
event->crossing.x = message->pointer.win_x;
|
||||
event->crossing.y = message->pointer.win_y;
|
||||
event->crossing.x_root = message->pointer.root_x;
|
||||
event->crossing.y_root = message->pointer.root_y;
|
||||
event->crossing.state = message->pointer.state;
|
||||
event->crossing.mode = message->crossing.mode;
|
||||
event->crossing.detail = GDK_NOTIFY_ANCESTOR;
|
||||
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
|
||||
event = gdk_event_crossing_new (GDK_ENTER_NOTIFY,
|
||||
surface,
|
||||
gdk_seat_get_pointer (seat),
|
||||
gdk_seat_get_pointer (seat),
|
||||
message->base.time,
|
||||
message->pointer.state,
|
||||
message->pointer.win_x,
|
||||
message->pointer.win_y,
|
||||
message->crossing.mode,
|
||||
GDK_NOTIFY_ANCESTOR);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
@@ -120,17 +119,16 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
surface = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_surface_id));
|
||||
if (surface)
|
||||
{
|
||||
event = gdk_event_new (GDK_LEAVE_NOTIFY);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->crossing.time = message->base.time;
|
||||
event->crossing.x = message->pointer.win_x;
|
||||
event->crossing.y = message->pointer.win_y;
|
||||
event->crossing.x_root = message->pointer.root_x;
|
||||
event->crossing.y_root = message->pointer.root_y;
|
||||
event->crossing.state = message->pointer.state;
|
||||
event->crossing.mode = message->crossing.mode;
|
||||
event->crossing.detail = GDK_NOTIFY_ANCESTOR;
|
||||
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
|
||||
event = gdk_event_crossing_new (GDK_LEAVE_NOTIFY,
|
||||
surface,
|
||||
gdk_seat_get_pointer (seat),
|
||||
gdk_seat_get_pointer (seat),
|
||||
message->base.time,
|
||||
message->pointer.state,
|
||||
message->pointer.win_x,
|
||||
message->pointer.win_y,
|
||||
message->crossing.mode,
|
||||
GDK_NOTIFY_ANCESTOR);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
@@ -143,15 +141,14 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
surface = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_surface_id));
|
||||
if (surface)
|
||||
{
|
||||
event = gdk_event_new (GDK_MOTION_NOTIFY);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->motion.time = message->base.time;
|
||||
event->motion.x = message->pointer.win_x;
|
||||
event->motion.y = message->pointer.win_y;
|
||||
event->motion.x_root = message->pointer.root_x;
|
||||
event->motion.y_root = message->pointer.root_y;
|
||||
event->motion.state = message->pointer.state;
|
||||
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
|
||||
event = gdk_event_motion_new (surface,
|
||||
gdk_seat_get_pointer (seat),
|
||||
gdk_seat_get_pointer (seat),
|
||||
NULL,
|
||||
message->base.time,
|
||||
message->pointer.state,
|
||||
message->pointer.win_x,
|
||||
message->pointer.win_y);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
@@ -167,16 +164,18 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
surface = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_surface_id));
|
||||
if (surface)
|
||||
{
|
||||
event = gdk_event_new (message->base.type == BROADWAY_EVENT_BUTTON_PRESS ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->button.time = message->base.time;
|
||||
event->button.x = message->pointer.win_x;
|
||||
event->button.y = message->pointer.win_y;
|
||||
event->button.x_root = message->pointer.root_x;
|
||||
event->button.y_root = message->pointer.root_y;
|
||||
event->button.button = message->button.button;
|
||||
event->button.state = message->pointer.state;
|
||||
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
|
||||
event = gdk_event_button_new (message->base.type == BROADWAY_EVENT_BUTTON_PRESS
|
||||
? GDK_BUTTON_PRESS
|
||||
: GDK_BUTTON_RELEASE,
|
||||
surface,
|
||||
gdk_seat_get_pointer (seat),
|
||||
gdk_seat_get_pointer (seat),
|
||||
NULL,
|
||||
message->base.time,
|
||||
message->pointer.win_x,
|
||||
message->pointer.win_y,
|
||||
message->button.button,
|
||||
message->pointer.state);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
@@ -187,16 +186,17 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
surface = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_surface_id));
|
||||
if (surface)
|
||||
{
|
||||
event = gdk_event_new (GDK_SCROLL);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->scroll.time = message->base.time;
|
||||
event->scroll.x = message->pointer.win_x;
|
||||
event->scroll.y = message->pointer.win_y;
|
||||
event->scroll.x_root = message->pointer.root_x;
|
||||
event->scroll.y_root = message->pointer.root_y;
|
||||
event->scroll.direction = message->scroll.dir == 0 ? GDK_SCROLL_UP : GDK_SCROLL_DOWN;
|
||||
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
|
||||
|
||||
event = gdk_event_discrete_scroll_new (surface,
|
||||
gdk_seat_get_pointer (seat),
|
||||
gdk_seat_get_pointer (seat),
|
||||
NULL,
|
||||
message->base.time,
|
||||
0,
|
||||
message->scroll.dir == 0
|
||||
? GDK_SCROLL_UP
|
||||
: GDK_SCROLL_DOWN,
|
||||
FALSE);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
}
|
||||
@@ -207,6 +207,8 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
if (surface)
|
||||
{
|
||||
GdkEventType event_type = 0;
|
||||
GdkModifierType state;
|
||||
GdkDevice *source_device;
|
||||
|
||||
switch (message->touch.touch_type) {
|
||||
case 0:
|
||||
@@ -226,30 +228,28 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
message->touch.is_emulated && _gdk_broadway_moveresize_handle_event (display, message))
|
||||
break;
|
||||
|
||||
event = gdk_event_new (event_type);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->touch.sequence = GUINT_TO_POINTER(message->touch.sequence_id);
|
||||
event->touch.emulating_pointer = message->touch.is_emulated;
|
||||
event->touch.time = message->base.time;
|
||||
event->touch.x = message->touch.win_x;
|
||||
event->touch.y = message->touch.win_y;
|
||||
event->touch.x_root = message->touch.root_x;
|
||||
event->touch.y_root = message->touch.root_y;
|
||||
event->touch.state = message->touch.state;
|
||||
|
||||
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
|
||||
source_device = gdk_seat_get_pointer (seat);
|
||||
{
|
||||
GList *devices;
|
||||
devices = gdk_seat_get_slaves (seat, GDK_SEAT_CAPABILITY_TOUCH);
|
||||
if (devices)
|
||||
gdk_event_set_source_device (event, GDK_DEVICE (devices->data));
|
||||
source_device = GDK_DEVICE (devices->data);
|
||||
g_list_free (devices);
|
||||
}
|
||||
if (message->touch.is_emulated)
|
||||
gdk_event_set_pointer_emulated (event, TRUE);
|
||||
|
||||
state = message->touch.state;
|
||||
if (event_type == GDK_TOUCH_BEGIN || event_type == GDK_TOUCH_UPDATE)
|
||||
event->touch.state |= GDK_BUTTON1_MASK;
|
||||
state |= GDK_BUTTON1_MASK;
|
||||
|
||||
event = gdk_event_touch_new (event_type,
|
||||
surface,
|
||||
gdk_seat_get_pointer (seat),
|
||||
source_device,
|
||||
message->base.time,
|
||||
state,
|
||||
message->touch.win_x,
|
||||
message->touch.win_y,
|
||||
message->touch.is_emulated);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
@@ -262,14 +262,19 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
GINT_TO_POINTER (message->key.surface_id));
|
||||
if (surface)
|
||||
{
|
||||
event = gdk_event_new (message->base.type == BROADWAY_EVENT_KEY_PRESS ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->key.time = message->base.time;
|
||||
event->key.keyval = message->key.key;
|
||||
event->key.state = message->key.state;
|
||||
event->key.hardware_keycode = message->key.key;
|
||||
gdk_event_set_scancode (event, message->key.key);
|
||||
gdk_event_set_device (event, gdk_seat_get_keyboard (seat));
|
||||
event = gdk_event_key_new (message->base.type == BROADWAY_EVENT_KEY_PRESS
|
||||
? GDK_KEY_PRESS
|
||||
: GDK_KEY_RELEASE,
|
||||
surface,
|
||||
gdk_seat_get_keyboard (seat),
|
||||
gdk_seat_get_keyboard (seat),
|
||||
message->base.time,
|
||||
message->key.state,
|
||||
message->key.key,
|
||||
message->key.key,
|
||||
message->key.key,
|
||||
0,
|
||||
FALSE);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
@@ -290,12 +295,9 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
|
||||
gdk_broadway_surface_update_popups (surface);
|
||||
|
||||
event = gdk_event_new (GDK_CONFIGURE);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->configure.x = message->configure_notify.x;
|
||||
event->configure.y = message->configure_notify.y;
|
||||
event->configure.width = message->configure_notify.width;
|
||||
event->configure.height = message->configure_notify.height;
|
||||
event = gdk_event_configure_new (surface,
|
||||
message->configure_notify.width,
|
||||
message->configure_notify.height);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
@@ -324,20 +326,22 @@ _gdk_broadway_events_got_input (GdkDisplay *display,
|
||||
surface = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->focus.old_id));
|
||||
if (surface)
|
||||
{
|
||||
event = gdk_event_new (GDK_FOCUS_CHANGE);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->focus_change.in = FALSE;
|
||||
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
|
||||
event = gdk_event_focus_new (surface,
|
||||
gdk_seat_get_keyboard (seat),
|
||||
gdk_seat_get_keyboard (seat),
|
||||
FALSE);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
}
|
||||
surface = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->focus.new_id));
|
||||
if (surface)
|
||||
{
|
||||
event = gdk_event_new (GDK_FOCUS_CHANGE);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->focus_change.in = TRUE;
|
||||
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
|
||||
event = gdk_event_focus_new (surface,
|
||||
gdk_seat_get_keyboard (seat),
|
||||
gdk_seat_get_keyboard (seat),
|
||||
TRUE);
|
||||
|
||||
node = _gdk_event_queue_append (display, event);
|
||||
_gdk_windowing_got_event (display, node, event, message->base.serial);
|
||||
}
|
||||
|
||||
+28
-38
@@ -923,11 +923,12 @@ gdk_drop_emit_enter_event (GdkDrop *self,
|
||||
GdkDropPrivate *priv = gdk_drop_get_instance_private (self);
|
||||
GdkEvent *event;
|
||||
|
||||
event = gdk_event_new (GDK_DRAG_ENTER);
|
||||
event->any.surface = g_object_ref (priv->surface);
|
||||
event->dnd.drop = g_object_ref (self);
|
||||
event->dnd.time = time;
|
||||
gdk_event_set_device (event, priv->device);
|
||||
event = gdk_event_drag_new (GDK_DRAG_ENTER,
|
||||
priv->surface,
|
||||
priv->device,
|
||||
self,
|
||||
time,
|
||||
0, 0);
|
||||
|
||||
gdk_drop_do_emit_event (event, dont_queue);
|
||||
}
|
||||
@@ -935,25 +936,19 @@ gdk_drop_emit_enter_event (GdkDrop *self,
|
||||
void
|
||||
gdk_drop_emit_motion_event (GdkDrop *self,
|
||||
gboolean dont_queue,
|
||||
double x_root,
|
||||
double y_root,
|
||||
double x,
|
||||
double y,
|
||||
guint32 time)
|
||||
{
|
||||
GdkDropPrivate *priv = gdk_drop_get_instance_private (self);
|
||||
GdkEvent *event;
|
||||
int x, y;
|
||||
|
||||
gdk_surface_get_origin (priv->surface, &x, &y);
|
||||
|
||||
event = gdk_event_new (GDK_DRAG_MOTION);
|
||||
event->any.surface = g_object_ref (priv->surface);
|
||||
event->dnd.drop = g_object_ref (self);
|
||||
event->dnd.time = time;
|
||||
event->dnd.x_root = x_root;
|
||||
event->dnd.y_root = y_root;
|
||||
event->dnd.x = x_root - x;
|
||||
event->dnd.y = y_root - y;
|
||||
gdk_event_set_device (event, priv->device);
|
||||
event = gdk_event_drag_new (GDK_DRAG_MOTION,
|
||||
priv->surface,
|
||||
priv->device,
|
||||
self,
|
||||
time,
|
||||
x, y);
|
||||
|
||||
gdk_drop_do_emit_event (event, dont_queue);
|
||||
}
|
||||
@@ -966,11 +961,12 @@ gdk_drop_emit_leave_event (GdkDrop *self,
|
||||
GdkDropPrivate *priv = gdk_drop_get_instance_private (self);
|
||||
GdkEvent *event;
|
||||
|
||||
event = gdk_event_new (GDK_DRAG_LEAVE);
|
||||
event->any.surface = g_object_ref (priv->surface);
|
||||
event->dnd.drop = g_object_ref (self);
|
||||
event->dnd.time = time;
|
||||
gdk_event_set_device (event, priv->device);
|
||||
event = gdk_event_drag_new (GDK_DRAG_LEAVE,
|
||||
priv->surface,
|
||||
priv->device,
|
||||
self,
|
||||
time,
|
||||
0, 0);
|
||||
|
||||
gdk_drop_do_emit_event (event, dont_queue);
|
||||
}
|
||||
@@ -978,25 +974,19 @@ gdk_drop_emit_leave_event (GdkDrop *self,
|
||||
void
|
||||
gdk_drop_emit_drop_event (GdkDrop *self,
|
||||
gboolean dont_queue,
|
||||
double x_root,
|
||||
double y_root,
|
||||
double x,
|
||||
double y,
|
||||
guint32 time)
|
||||
{
|
||||
GdkDropPrivate *priv = gdk_drop_get_instance_private (self);
|
||||
GdkEvent *event;
|
||||
int x, y;
|
||||
|
||||
gdk_surface_get_origin (priv->surface, &x, &y);
|
||||
|
||||
event = gdk_event_new (GDK_DROP_START);
|
||||
event->any.surface = g_object_ref (priv->surface);
|
||||
event->dnd.drop = g_object_ref (self);
|
||||
event->dnd.time = time;
|
||||
event->dnd.x_root = x_root;
|
||||
event->dnd.y_root = y_root;
|
||||
event->dnd.x = x_root - x;
|
||||
event->dnd.y = y_root - y;
|
||||
gdk_event_set_device (event, priv->device);
|
||||
event = gdk_event_drag_new (GDK_DROP_START,
|
||||
priv->surface,
|
||||
priv->device,
|
||||
self,
|
||||
time,
|
||||
x, y);
|
||||
|
||||
gdk_drop_do_emit_event (event, dont_queue);
|
||||
}
|
||||
|
||||
@@ -64,16 +64,16 @@ void gdk_drop_emit_enter_event (GdkDrop
|
||||
guint32 time);
|
||||
void gdk_drop_emit_motion_event (GdkDrop *self,
|
||||
gboolean dont_queue,
|
||||
double x_root,
|
||||
double y_root,
|
||||
double x,
|
||||
double y,
|
||||
guint32 time);
|
||||
void gdk_drop_emit_leave_event (GdkDrop *self,
|
||||
gboolean dont_queue,
|
||||
guint32 time);
|
||||
void gdk_drop_emit_drop_event (GdkDrop *self,
|
||||
gboolean dont_queue,
|
||||
double x_root,
|
||||
double y_root,
|
||||
double x,
|
||||
double y,
|
||||
guint32 time);
|
||||
|
||||
G_END_DECLS
|
||||
|
||||
+480
-23
@@ -478,15 +478,11 @@ gdk_event_constructed (GObject *object)
|
||||
case GDK_MOTION_NOTIFY:
|
||||
new_event->motion.x = 0.;
|
||||
new_event->motion.y = 0.;
|
||||
new_event->motion.x_root = 0.;
|
||||
new_event->motion.y_root = 0.;
|
||||
break;
|
||||
case GDK_BUTTON_PRESS:
|
||||
case GDK_BUTTON_RELEASE:
|
||||
new_event->button.x = 0.;
|
||||
new_event->button.y = 0.;
|
||||
new_event->button.x_root = 0.;
|
||||
new_event->button.y_root = 0.;
|
||||
break;
|
||||
case GDK_TOUCH_BEGIN:
|
||||
case GDK_TOUCH_UPDATE:
|
||||
@@ -494,14 +490,10 @@ gdk_event_constructed (GObject *object)
|
||||
case GDK_TOUCH_CANCEL:
|
||||
new_event->touch.x = 0.;
|
||||
new_event->touch.y = 0.;
|
||||
new_event->touch.x_root = 0.;
|
||||
new_event->touch.y_root = 0.;
|
||||
break;
|
||||
case GDK_SCROLL:
|
||||
new_event->scroll.x = 0.;
|
||||
new_event->scroll.y = 0.;
|
||||
new_event->scroll.x_root = 0.;
|
||||
new_event->scroll.y_root = 0.;
|
||||
new_event->scroll.delta_x = 0.;
|
||||
new_event->scroll.delta_y = 0.;
|
||||
new_event->scroll.is_stop = FALSE;
|
||||
@@ -510,16 +502,12 @@ gdk_event_constructed (GObject *object)
|
||||
case GDK_LEAVE_NOTIFY:
|
||||
new_event->crossing.x = 0.;
|
||||
new_event->crossing.y = 0.;
|
||||
new_event->crossing.x_root = 0.;
|
||||
new_event->crossing.y_root = 0.;
|
||||
break;
|
||||
case GDK_TOUCHPAD_SWIPE:
|
||||
new_event->touchpad_swipe.x = 0;
|
||||
new_event->touchpad_swipe.y = 0;
|
||||
new_event->touchpad_swipe.dx = 0;
|
||||
new_event->touchpad_swipe.dy = 0;
|
||||
new_event->touchpad_swipe.x_root = 0;
|
||||
new_event->touchpad_swipe.y_root = 0;
|
||||
break;
|
||||
case GDK_TOUCHPAD_PINCH:
|
||||
new_event->touchpad_pinch.x = 0;
|
||||
@@ -528,8 +516,6 @@ gdk_event_constructed (GObject *object)
|
||||
new_event->touchpad_pinch.dy = 0;
|
||||
new_event->touchpad_pinch.angle_delta = 0;
|
||||
new_event->touchpad_pinch.scale = 0;
|
||||
new_event->touchpad_pinch.x_root = 0;
|
||||
new_event->touchpad_pinch.y_root = 0;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
@@ -707,6 +693,15 @@ gdk_event_finalize (GObject *object)
|
||||
g_list_free_full (event->motion.history, g_free);
|
||||
break;
|
||||
|
||||
case GDK_PROXIMITY_IN:
|
||||
case GDK_PROXIMITY_OUT:
|
||||
g_clear_object (&event->proximity.tool);
|
||||
break;
|
||||
|
||||
case GDK_SCROLL:
|
||||
g_clear_object (&event->scroll.tool);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@@ -1132,15 +1127,6 @@ gdk_event_get_keyval (const GdkEvent *event,
|
||||
return fetched;
|
||||
}
|
||||
|
||||
void
|
||||
gdk_event_set_keyval (GdkEvent *event,
|
||||
guint keyval)
|
||||
{
|
||||
if (event->any.type == GDK_KEY_PRESS ||
|
||||
event->any.type == GDK_KEY_RELEASE)
|
||||
event->key.keyval = keyval;
|
||||
}
|
||||
|
||||
/**
|
||||
* gdk_event_get_keycode:
|
||||
* @event: a #GdkEvent
|
||||
@@ -1834,6 +1820,11 @@ gdk_event_get_device_tool (const GdkEvent *event)
|
||||
return event->button.tool;
|
||||
else if (event->any.type == GDK_MOTION_NOTIFY)
|
||||
return event->motion.tool;
|
||||
else if (event->any.type == GDK_PROXIMITY_IN ||
|
||||
event->any.type == GDK_PROXIMITY_OUT)
|
||||
return event->proximity.tool;
|
||||
else if (event->any.type == GDK_SCROLL)
|
||||
return event->scroll.tool;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
@@ -1854,6 +1845,11 @@ gdk_event_set_device_tool (GdkEvent *event,
|
||||
g_set_object (&event->button.tool, tool);
|
||||
else if (event->any.type == GDK_MOTION_NOTIFY)
|
||||
g_set_object (&event->motion.tool, tool);
|
||||
else if (event->any.type == GDK_PROXIMITY_IN ||
|
||||
event->any.type == GDK_PROXIMITY_OUT)
|
||||
g_set_object (&event->proximity.tool, tool);
|
||||
else if (event->any.type == GDK_SCROLL)
|
||||
g_set_object (&event->scroll.tool, tool);
|
||||
}
|
||||
|
||||
void
|
||||
@@ -2405,3 +2401,464 @@ gdk_event_get_motion_history (const GdkEvent *event)
|
||||
return NULL;
|
||||
return g_list_reverse (g_list_copy (event->motion.history));
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_button_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time,
|
||||
double x,
|
||||
double y,
|
||||
guint button,
|
||||
GdkModifierType state)
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
g_return_val_if_fail (type == GDK_BUTTON_PRESS ||
|
||||
type == GDK_BUTTON_RELEASE, NULL);
|
||||
|
||||
event = gdk_event_new (type);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->button.tool = tool ? g_object_ref (tool) : NULL;
|
||||
event->button.time = time;
|
||||
event->button.axes = NULL;
|
||||
event->button.state = state;
|
||||
event->button.button = button;
|
||||
event->button.x = x;
|
||||
event->button.y = y;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_motion_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_MOTION_NOTIFY);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->motion.tool = tool ? g_object_ref (tool) : NULL;
|
||||
event->motion.time = time;
|
||||
event->motion.x = x;
|
||||
event->motion.y = y;
|
||||
event->motion.state = state;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_crossing_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double x,
|
||||
double y,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType detail)
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
g_return_val_if_fail (type == GDK_ENTER_NOTIFY ||
|
||||
type == GDK_LEAVE_NOTIFY, NULL);
|
||||
|
||||
event = gdk_event_new (type);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->crossing.time = time;
|
||||
event->crossing.state = state;
|
||||
event->crossing.x = x;
|
||||
event->crossing.y = y;
|
||||
event->crossing.mode = mode;
|
||||
event->crossing.detail = detail;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_proximity_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time)
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
g_return_val_if_fail (type == GDK_PROXIMITY_IN ||
|
||||
type == GDK_PROXIMITY_OUT, NULL);
|
||||
|
||||
event = gdk_event_new (type);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->proximity.tool = tool ? g_object_ref (tool) : NULL;
|
||||
event->proximity.time = time;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_key_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
guint keyval,
|
||||
guint16 keycode,
|
||||
guint16 scancode,
|
||||
guint8 group,
|
||||
gboolean is_modifier)
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
g_return_val_if_fail (type == GDK_KEY_PRESS ||
|
||||
type == GDK_KEY_RELEASE, NULL);
|
||||
|
||||
event = gdk_event_new (type);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->key.time = time;
|
||||
event->key.state = state;
|
||||
event->key.keyval = keyval;
|
||||
event->key.hardware_keycode = keycode;
|
||||
event->key.group = group;
|
||||
event->key.is_modifier = is_modifier;
|
||||
gdk_event_set_scancode (event, scancode);
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_configure_new (GdkSurface *surface,
|
||||
int width,
|
||||
int height)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_CONFIGURE);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
|
||||
event->configure.width = width;
|
||||
event->configure.height = height;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_delete_new (GdkSurface *surface)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_DELETE);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_focus_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
gboolean focus_in)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_FOCUS_CHANGE);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->focus_change.in = focus_in;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_scroll_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double delta_x,
|
||||
double delta_y,
|
||||
gboolean is_stop)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_SCROLL);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->scroll.tool = tool ? g_object_ref (tool) : NULL;
|
||||
event->scroll.time = time;
|
||||
event->scroll.state = state;
|
||||
event->scroll.x = NAN;
|
||||
event->scroll.y = NAN;
|
||||
event->scroll.direction = GDK_SCROLL_SMOOTH;
|
||||
event->scroll.delta_x = delta_x;
|
||||
event->scroll.delta_y = delta_y;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_discrete_scroll_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
GdkScrollDirection direction,
|
||||
gboolean emulated)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_SCROLL);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->scroll.tool = tool ? g_object_ref (tool) : NULL;
|
||||
event->scroll.time = time;
|
||||
event->scroll.state = state;
|
||||
event->scroll.x = NAN;
|
||||
event->scroll.y = NAN;
|
||||
event->scroll.direction = direction;
|
||||
gdk_event_set_pointer_emulated (event, emulated);
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_touch_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double x,
|
||||
double y,
|
||||
gboolean emulating)
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
g_return_val_if_fail (type == GDK_TOUCH_BEGIN ||
|
||||
type == GDK_TOUCH_END ||
|
||||
type == GDK_TOUCH_UPDATE ||
|
||||
type == GDK_TOUCH_CANCEL, NULL);
|
||||
|
||||
event = gdk_event_new (type);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->touch.time = time;
|
||||
event->touch.state = state;
|
||||
event->touch.x = x;
|
||||
event->touch.y = y;
|
||||
event->touch.emulating_pointer = emulating;
|
||||
gdk_event_set_pointer_emulated (event, emulating);
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_touchpad_swipe_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double x,
|
||||
double y,
|
||||
int n_fingers,
|
||||
double dx,
|
||||
double dy)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_TOUCHPAD_SWIPE);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->touchpad_swipe.time = time;
|
||||
event->touchpad_swipe.state = state;
|
||||
event->touchpad_swipe.x = x;
|
||||
event->touchpad_swipe.y = y;
|
||||
event->touchpad_swipe.dx = dx;
|
||||
event->touchpad_swipe.dy = dy;
|
||||
event->touchpad_swipe.n_fingers = n_fingers;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_touchpad_pinch_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
GdkTouchpadGesturePhase phase,
|
||||
double x,
|
||||
double y,
|
||||
int n_fingers,
|
||||
double dx,
|
||||
double dy,
|
||||
double scale,
|
||||
double angle_delta)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_TOUCHPAD_PINCH);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->touchpad_pinch.time = time;
|
||||
event->touchpad_pinch.state = state;
|
||||
event->touchpad_pinch.phase = phase;
|
||||
event->touchpad_pinch.x = x;
|
||||
event->touchpad_pinch.y = y;
|
||||
event->touchpad_pinch.dx = dx;
|
||||
event->touchpad_pinch.dy = dy;
|
||||
event->touchpad_pinch.n_fingers = n_fingers;
|
||||
event->touchpad_pinch.scale = scale;
|
||||
event->touchpad_pinch.angle_delta = angle_delta;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_pad_ring_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
guint group,
|
||||
guint index,
|
||||
guint mode,
|
||||
double value)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_PAD_RING);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->pad_axis.time = time;
|
||||
event->pad_axis.group = group;
|
||||
event->pad_axis.index = index;
|
||||
event->pad_axis.mode = mode;
|
||||
event->pad_axis.value = value;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_pad_strip_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
guint group,
|
||||
guint index,
|
||||
guint mode,
|
||||
double value)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_PAD_STRIP);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->pad_axis.time = time;
|
||||
event->pad_axis.group = group;
|
||||
event->pad_axis.index = index;
|
||||
event->pad_axis.mode = mode;
|
||||
event->pad_axis.value = value;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_pad_button_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
guint group,
|
||||
guint button,
|
||||
guint mode)
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
g_return_val_if_fail (type == GDK_PAD_BUTTON_PRESS ||
|
||||
type == GDK_PAD_BUTTON_RELEASE, NULL);
|
||||
|
||||
event = gdk_event_new (type);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->pad_button.time = time;
|
||||
event->pad_button.group = group;
|
||||
event->pad_button.button = button;
|
||||
event->pad_axis.mode = mode;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_pad_group_mode_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
guint group,
|
||||
guint mode)
|
||||
{
|
||||
GdkEvent *event = gdk_event_new (GDK_PAD_GROUP_MODE);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->any.source_device = g_object_ref (source_device);
|
||||
event->pad_group_mode.time = time;
|
||||
event->pad_group_mode.group = group;
|
||||
event->pad_group_mode.mode = mode;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
GdkEvent *
|
||||
gdk_event_drag_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDrop *drop,
|
||||
guint32 time,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
g_return_val_if_fail (type == GDK_DRAG_ENTER ||
|
||||
type == GDK_DRAG_MOTION ||
|
||||
type == GDK_DRAG_LEAVE ||
|
||||
type == GDK_DROP_START, NULL);
|
||||
|
||||
event = gdk_event_new (type);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.device = g_object_ref (device);
|
||||
event->dnd.drop = g_object_ref (drop);
|
||||
event->dnd.time = time;
|
||||
event->dnd.x = x;
|
||||
event->dnd.y = y;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
@@ -373,10 +373,6 @@ GDK_AVAILABLE_IN_ALL
|
||||
gboolean gdk_event_get_keyval (const GdkEvent *event,
|
||||
guint *keyval);
|
||||
|
||||
GDK_AVAILABLE_IN_ALL
|
||||
void gdk_event_set_keyval (GdkEvent *event,
|
||||
guint keyval);
|
||||
|
||||
GDK_AVAILABLE_IN_ALL
|
||||
gboolean gdk_event_get_keycode (const GdkEvent *event,
|
||||
guint16 *keycode);
|
||||
|
||||
+159
-36
@@ -79,9 +79,6 @@ struct _GdkEventAny
|
||||
* buttons. See #GdkModifierType.
|
||||
* @device: the master device that the event originated from. Use
|
||||
* gdk_event_get_source_device() to get the slave device.
|
||||
* @x_root: the x coordinate of the pointer relative to the root of the
|
||||
* screen.
|
||||
* @y_root: the y coordinate of the pointer relative to the root of the
|
||||
* screen.
|
||||
*
|
||||
* Generated when the pointer moves.
|
||||
@@ -95,7 +92,6 @@ struct _GdkEventMotion
|
||||
gdouble *axes;
|
||||
guint state;
|
||||
GdkDeviceTool *tool;
|
||||
gdouble x_root, y_root;
|
||||
GList *history;
|
||||
};
|
||||
|
||||
@@ -118,9 +114,6 @@ struct _GdkEventMotion
|
||||
* often be simulated by pressing both mouse buttons together.
|
||||
* @device: the master device that the event originated from. Use
|
||||
* gdk_event_get_source_device() to get the slave device.
|
||||
* @x_root: the x coordinate of the pointer relative to the root of the
|
||||
* screen.
|
||||
* @y_root: the y coordinate of the pointer relative to the root of the
|
||||
* screen.
|
||||
*
|
||||
* Used for button press and button release events. The
|
||||
@@ -136,7 +129,6 @@ struct _GdkEventButton
|
||||
guint state;
|
||||
guint button;
|
||||
GdkDeviceTool *tool;
|
||||
gdouble x_root, y_root;
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -158,9 +150,6 @@ struct _GdkEventButton
|
||||
* pointer event
|
||||
* @device: the master device that the event originated from. Use
|
||||
* gdk_event_get_source_device() to get the slave device.
|
||||
* @x_root: the x coordinate of the pointer relative to the root of the
|
||||
* screen
|
||||
* @y_root: the y coordinate of the pointer relative to the root of the
|
||||
* screen
|
||||
*
|
||||
* Used for touch events.
|
||||
@@ -184,7 +173,6 @@ struct _GdkEventTouch
|
||||
guint state;
|
||||
GdkEventSequence *sequence;
|
||||
gboolean emulating_pointer;
|
||||
gdouble x_root, y_root;
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -203,10 +191,6 @@ struct _GdkEventTouch
|
||||
* %GDK_SCROLL_SMOOTH).
|
||||
* @device: the master device that the event originated from. Use
|
||||
* gdk_event_get_source_device() to get the slave device.
|
||||
* @x_root: the x coordinate of the pointer relative to the root of the
|
||||
* screen.
|
||||
* @y_root: the y coordinate of the pointer relative to the root of the
|
||||
* screen.
|
||||
* @delta_x: the x coordinate of the scroll delta
|
||||
* @delta_y: the y coordinate of the scroll delta
|
||||
*
|
||||
@@ -227,10 +211,10 @@ struct _GdkEventScroll
|
||||
gdouble y;
|
||||
guint state;
|
||||
GdkScrollDirection direction;
|
||||
gdouble x_root, y_root;
|
||||
gdouble delta_x;
|
||||
gdouble delta_y;
|
||||
guint is_stop : 1;
|
||||
GdkDeviceTool *tool;
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -273,8 +257,6 @@ struct _GdkEventKey
|
||||
* @time: the time of the event in milliseconds.
|
||||
* @x: the x coordinate of the pointer relative to the surface.
|
||||
* @y: the y coordinate of the pointer relative to the surface.
|
||||
* @x_root: the x coordinate of the pointer relative to the root of the screen.
|
||||
* @y_root: the y coordinate of the pointer relative to the root of the screen.
|
||||
* @mode: the crossing mode (%GDK_CROSSING_NORMAL, %GDK_CROSSING_GRAB,
|
||||
* %GDK_CROSSING_UNGRAB, %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB or
|
||||
* %GDK_CROSSING_STATE_CHANGED). %GDK_CROSSING_GTK_GRAB, %GDK_CROSSING_GTK_UNGRAB,
|
||||
@@ -297,8 +279,6 @@ struct _GdkEventCrossing
|
||||
guint32 time;
|
||||
gdouble x;
|
||||
gdouble y;
|
||||
gdouble x_root;
|
||||
gdouble y_root;
|
||||
GdkCrossingMode mode;
|
||||
GdkNotifyType detail;
|
||||
gboolean focus;
|
||||
@@ -370,6 +350,7 @@ struct _GdkEventProximity
|
||||
{
|
||||
GdkEventAny any;
|
||||
guint32 time;
|
||||
GdkDeviceTool *tool;
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -406,10 +387,6 @@ struct _GdkEventGrabBroken {
|
||||
* @send_event: %TRUE if the event was sent explicitly.
|
||||
* @drop: the #GdkDrop for the current DND operation.
|
||||
* @time: the time of the event in milliseconds.
|
||||
* @x_root: the x coordinate of the pointer relative to the root of the
|
||||
* screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START.
|
||||
* @y_root: the y coordinate of the pointer relative to the root of the
|
||||
* screen, only set for %GDK_DRAG_MOTION and %GDK_DROP_START.
|
||||
*
|
||||
* Generated during DND operations.
|
||||
*/
|
||||
@@ -418,7 +395,6 @@ struct _GdkEventDND {
|
||||
GdkDrop *drop;
|
||||
|
||||
guint32 time;
|
||||
double x_root, y_root;
|
||||
double x;
|
||||
double y;
|
||||
};
|
||||
@@ -435,10 +411,6 @@ struct _GdkEventDND {
|
||||
* @y: The Y coordinate of the pointer
|
||||
* @dx: Movement delta in the X axis of the swipe focal point
|
||||
* @dy: Movement delta in the Y axis of the swipe focal point
|
||||
* @x_root: The X coordinate of the pointer, relative to the
|
||||
* root of the screen.
|
||||
* @y_root: The Y coordinate of the pointer, relative to the
|
||||
* root of the screen.
|
||||
* @state: (type GdkModifierType): a bit-mask representing the state of
|
||||
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
|
||||
* buttons. See #GdkModifierType.
|
||||
@@ -454,7 +426,6 @@ struct _GdkEventTouchpadSwipe {
|
||||
gdouble y;
|
||||
gdouble dx;
|
||||
gdouble dy;
|
||||
gdouble x_root, y_root;
|
||||
guint state;
|
||||
};
|
||||
|
||||
@@ -474,10 +445,6 @@ struct _GdkEventTouchpadSwipe {
|
||||
* denote counter-clockwise movements
|
||||
* @scale: The current scale, relative to that at the time of
|
||||
* the corresponding %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN event
|
||||
* @x_root: The X coordinate of the pointer, relative to the
|
||||
* root of the screen.
|
||||
* @y_root: The Y coordinate of the pointer, relative to the
|
||||
* root of the screen.
|
||||
* @state: (type GdkModifierType): a bit-mask representing the state of
|
||||
* the modifier keys (e.g. Control, Shift and Alt) and the pointer
|
||||
* buttons. See #GdkModifierType.
|
||||
@@ -495,7 +462,6 @@ struct _GdkEventTouchpadPinch {
|
||||
gdouble dy;
|
||||
gdouble angle_delta;
|
||||
gdouble scale;
|
||||
gdouble x_root, y_root;
|
||||
guint state;
|
||||
};
|
||||
|
||||
@@ -649,5 +615,162 @@ GObject * gdk_event_get_related_target (const GdkEvent *event);
|
||||
|
||||
gboolean check_event_sanity (GdkEvent *event);
|
||||
|
||||
GdkEvent * gdk_event_button_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time,
|
||||
double x,
|
||||
double y,
|
||||
guint button,
|
||||
GdkModifierType state);
|
||||
|
||||
GdkEvent * gdk_event_motion_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double x,
|
||||
double y);
|
||||
|
||||
GdkEvent * gdk_event_crossing_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double x,
|
||||
double y,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType notify);
|
||||
|
||||
GdkEvent * gdk_event_proximity_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time);
|
||||
|
||||
GdkEvent * gdk_event_key_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
guint keyval,
|
||||
guint16 keycode,
|
||||
guint16 scancode,
|
||||
guint8 group,
|
||||
gboolean is_modifier);
|
||||
|
||||
GdkEvent * gdk_event_focus_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
gboolean focus_in);
|
||||
|
||||
GdkEvent * gdk_event_configure_new (GdkSurface *surface,
|
||||
int width,
|
||||
int height);
|
||||
|
||||
GdkEvent * gdk_event_delete_new (GdkSurface *surface);
|
||||
|
||||
GdkEvent * gdk_event_scroll_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double delta_x,
|
||||
double delta_y,
|
||||
gboolean is_stop);
|
||||
|
||||
GdkEvent * gdk_event_discrete_scroll_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
GdkDeviceTool *tool,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
GdkScrollDirection direction,
|
||||
gboolean emulated);
|
||||
|
||||
GdkEvent * gdk_event_touch_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double x,
|
||||
double y,
|
||||
gboolean emulating);
|
||||
|
||||
GdkEvent * gdk_event_touchpad_swipe_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
double x,
|
||||
double y,
|
||||
int n_fingers,
|
||||
double dx,
|
||||
double dy);
|
||||
|
||||
GdkEvent * gdk_event_touchpad_pinch_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
GdkModifierType state,
|
||||
GdkTouchpadGesturePhase phase,
|
||||
double x,
|
||||
double y,
|
||||
int n_fingers,
|
||||
double dx,
|
||||
double dy,
|
||||
double scale,
|
||||
double angle_delta);
|
||||
|
||||
GdkEvent * gdk_event_pad_ring_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
guint group,
|
||||
guint index,
|
||||
guint mode,
|
||||
double value);
|
||||
|
||||
GdkEvent * gdk_event_pad_strip_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
guint group,
|
||||
guint index,
|
||||
guint mode,
|
||||
double value);
|
||||
|
||||
GdkEvent * gdk_event_pad_button_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
guint group,
|
||||
guint button,
|
||||
guint mode);
|
||||
|
||||
GdkEvent * gdk_event_pad_group_mode_new (GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
guint32 time,
|
||||
guint group,
|
||||
guint mode);
|
||||
|
||||
GdkEvent * gdk_event_drag_new (GdkEventType type,
|
||||
GdkSurface *surface,
|
||||
GdkDevice *device,
|
||||
GdkDrop *drop,
|
||||
guint32 time,
|
||||
double x,
|
||||
double y);
|
||||
|
||||
#endif /* __GDK_EVENTS_PRIVATE_H__ */
|
||||
|
||||
|
||||
+288
-379
@@ -532,40 +532,6 @@ gdk_wayland_device_set_surface_cursor (GdkDevice *device,
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
get_coordinates (GdkDevice *device,
|
||||
double *x,
|
||||
double *y,
|
||||
double *x_root,
|
||||
double *y_root)
|
||||
{
|
||||
GdkWaylandPointerData *pointer = GDK_WAYLAND_DEVICE (device)->pointer;
|
||||
int root_x, root_y;
|
||||
|
||||
if (x)
|
||||
*x = pointer->surface_x;
|
||||
if (y)
|
||||
*y = pointer->surface_y;
|
||||
|
||||
if (pointer->focus)
|
||||
{
|
||||
gdk_surface_get_root_coords (pointer->focus,
|
||||
pointer->surface_x,
|
||||
pointer->surface_y,
|
||||
&root_x, &root_y);
|
||||
}
|
||||
else
|
||||
{
|
||||
root_x = pointer->surface_x;
|
||||
root_y = pointer->surface_y;
|
||||
}
|
||||
|
||||
if (x_root)
|
||||
*x_root = root_x;
|
||||
if (y_root)
|
||||
*y_root = root_y;
|
||||
}
|
||||
|
||||
static GdkModifierType
|
||||
device_get_modifiers (GdkDevice *device)
|
||||
{
|
||||
@@ -583,8 +549,8 @@ device_get_modifiers (GdkDevice *device)
|
||||
|
||||
static void
|
||||
gdk_wayland_device_query_state (GdkDevice *device,
|
||||
GdkSurface *surface,
|
||||
GdkSurface **child_surface,
|
||||
GdkSurface *surface,
|
||||
GdkSurface **child_surface,
|
||||
gdouble *root_x,
|
||||
gdouble *root_y,
|
||||
gdouble *win_x,
|
||||
@@ -593,6 +559,7 @@ gdk_wayland_device_query_state (GdkDevice *device,
|
||||
{
|
||||
GdkWaylandPointerData *pointer;
|
||||
GList *children = NULL;
|
||||
int x_root, y_root;
|
||||
|
||||
if (surface == NULL)
|
||||
children = gdk_wayland_display_get_toplevel_surfaces (gdk_device_get_display (device));
|
||||
@@ -605,7 +572,28 @@ gdk_wayland_device_query_state (GdkDevice *device,
|
||||
if (mask)
|
||||
*mask = device_get_modifiers (device);
|
||||
|
||||
get_coordinates (device, win_x, win_y, root_x, root_y);
|
||||
if (win_x)
|
||||
*win_x = pointer->surface_x;
|
||||
if (win_y)
|
||||
*win_y = pointer->surface_y;
|
||||
|
||||
if (pointer->focus)
|
||||
{
|
||||
gdk_surface_get_root_coords (pointer->focus,
|
||||
pointer->surface_x,
|
||||
pointer->surface_y,
|
||||
&x_root, &y_root);
|
||||
}
|
||||
else
|
||||
{
|
||||
x_root = pointer->surface_x;
|
||||
y_root = pointer->surface_y;
|
||||
}
|
||||
|
||||
if (root_x)
|
||||
*root_x = x_root;
|
||||
if (root_y)
|
||||
*root_y = y_root;
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -617,21 +605,19 @@ emulate_crossing (GdkSurface *surface,
|
||||
guint32 time_)
|
||||
{
|
||||
GdkEvent *event;
|
||||
GdkModifierType state;
|
||||
double x, y;
|
||||
|
||||
event = gdk_event_new (type);
|
||||
event->any.surface = surface ? g_object_ref (surface) : NULL;
|
||||
event->crossing.child_surface = child_surface ? g_object_ref (child_surface) : NULL;
|
||||
event->crossing.time = time_;
|
||||
event->crossing.mode = mode;
|
||||
event->crossing.detail = GDK_NOTIFY_NONLINEAR;
|
||||
gdk_event_set_device (event, device);
|
||||
gdk_event_set_source_device (event, device);
|
||||
|
||||
gdk_surface_get_device_position (surface, device,
|
||||
&event->crossing.x, &event->crossing.y,
|
||||
&event->crossing.state);
|
||||
event->crossing.x_root = event->crossing.x;
|
||||
event->crossing.y_root = event->crossing.y;
|
||||
gdk_surface_get_device_position (surface, device, &x, &y, &state);
|
||||
event = gdk_event_crossing_new (type,
|
||||
surface,
|
||||
device,
|
||||
device,
|
||||
time_,
|
||||
state,
|
||||
x, y,
|
||||
mode,
|
||||
GDK_NOTIFY_NONLINEAR);
|
||||
|
||||
_gdk_wayland_display_deliver_event (gdk_surface_get_display (surface), event);
|
||||
}
|
||||
@@ -648,19 +634,15 @@ emulate_touch_crossing (GdkSurface *surface,
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
event = gdk_event_new (type);
|
||||
event->any.surface = surface ? g_object_ref (surface) : NULL;
|
||||
event->crossing.child_surface = child_surface ? g_object_ref (child_surface) : NULL;
|
||||
event->crossing.time = time_;
|
||||
event->crossing.mode = mode;
|
||||
event->crossing.detail = GDK_NOTIFY_NONLINEAR;
|
||||
gdk_event_set_device (event, device);
|
||||
gdk_event_set_source_device (event, source);
|
||||
|
||||
event->crossing.x = touch->x;
|
||||
event->crossing.y = touch->y;
|
||||
event->crossing.x_root = event->crossing.x;
|
||||
event->crossing.y_root = event->crossing.y;
|
||||
event = gdk_event_crossing_new (type,
|
||||
surface,
|
||||
device,
|
||||
source,
|
||||
time_,
|
||||
0,
|
||||
touch->x, touch->y,
|
||||
mode,
|
||||
GDK_NOTIFY_NONLINEAR);
|
||||
|
||||
_gdk_wayland_display_deliver_event (gdk_surface_get_display (surface), event);
|
||||
}
|
||||
@@ -671,13 +653,7 @@ emulate_focus (GdkSurface *surface,
|
||||
gboolean focus_in,
|
||||
guint32 time_)
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
event = gdk_event_new (GDK_FOCUS_CHANGE);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->focus_change.in = focus_in;
|
||||
gdk_event_set_device (event, device);
|
||||
gdk_event_set_source_device (event, device);
|
||||
GdkEvent *event = gdk_event_focus_new (surface, device, device, focus_in);
|
||||
|
||||
_gdk_wayland_display_deliver_event (gdk_surface_get_display (surface), event);
|
||||
}
|
||||
@@ -1387,34 +1363,6 @@ static const struct wl_data_device_listener data_device_listener = {
|
||||
static GdkDevice * get_scroll_device (GdkWaylandSeat *seat,
|
||||
enum wl_pointer_axis_source source);
|
||||
|
||||
static GdkEvent *
|
||||
create_scroll_event (GdkWaylandSeat *seat,
|
||||
GdkWaylandPointerData *pointer_info,
|
||||
GdkDevice *device,
|
||||
GdkDevice *source_device,
|
||||
gboolean emulated)
|
||||
{
|
||||
GdkEvent *event;
|
||||
|
||||
event = gdk_event_new (GDK_SCROLL);
|
||||
event->any.surface = g_object_ref (pointer_info->focus);
|
||||
gdk_event_set_device (event, device);
|
||||
gdk_event_set_source_device (event, source_device);
|
||||
event->scroll.time = pointer_info->time;
|
||||
event->scroll.state = device_get_modifiers (device);
|
||||
gdk_event_set_display (event, seat->display);
|
||||
|
||||
gdk_event_set_pointer_emulated (event, emulated);
|
||||
|
||||
get_coordinates (device,
|
||||
&event->scroll.x,
|
||||
&event->scroll.y,
|
||||
&event->scroll.x_root,
|
||||
&event->scroll.y_root);
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
static void
|
||||
flush_discrete_scroll_event (GdkWaylandSeat *seat,
|
||||
GdkScrollDirection direction)
|
||||
@@ -1423,9 +1371,14 @@ flush_discrete_scroll_event (GdkWaylandSeat *seat,
|
||||
GdkDevice *source;
|
||||
|
||||
source = get_scroll_device (seat, seat->pointer_info.frame.source);
|
||||
event = create_scroll_event (seat, &seat->pointer_info,
|
||||
seat->master_pointer, source, TRUE);
|
||||
event->scroll.direction = direction;
|
||||
event = gdk_event_discrete_scroll_new (seat->pointer_info.focus,
|
||||
seat->master_pointer,
|
||||
source,
|
||||
NULL,
|
||||
seat->pointer_info.time,
|
||||
device_get_modifiers (seat->master_pointer),
|
||||
direction,
|
||||
TRUE);
|
||||
|
||||
_gdk_wayland_display_deliver_event (seat->display, event);
|
||||
}
|
||||
@@ -1440,12 +1393,14 @@ flush_smooth_scroll_event (GdkWaylandSeat *seat,
|
||||
GdkDevice *source;
|
||||
|
||||
source = get_scroll_device (seat, seat->pointer_info.frame.source);
|
||||
event = create_scroll_event (seat, &seat->pointer_info,
|
||||
seat->master_pointer, source, FALSE);
|
||||
event->scroll.direction = GDK_SCROLL_SMOOTH;
|
||||
event->scroll.delta_x = delta_x;
|
||||
event->scroll.delta_y = delta_y;
|
||||
event->scroll.is_stop = is_stop;
|
||||
event = gdk_event_scroll_new (seat->pointer_info.focus,
|
||||
seat->master_pointer,
|
||||
source,
|
||||
NULL,
|
||||
seat->pointer_info.time,
|
||||
device_get_modifiers (seat->master_pointer),
|
||||
delta_x, delta_x,
|
||||
is_stop);
|
||||
|
||||
_gdk_wayland_display_deliver_event (seat->display, event);
|
||||
}
|
||||
@@ -1514,16 +1469,15 @@ gdk_wayland_seat_flush_frame_event (GdkWaylandSeat *seat)
|
||||
}
|
||||
}
|
||||
|
||||
static GdkEvent *
|
||||
gdk_wayland_seat_get_frame_event (GdkWaylandSeat *seat,
|
||||
GdkEventType evtype)
|
||||
static void
|
||||
gdk_wayland_seat_set_frame_event (GdkWaylandSeat *seat,
|
||||
GdkEvent *event)
|
||||
{
|
||||
if (seat->pointer_info.frame.event &&
|
||||
seat->pointer_info.frame.event->any.type != evtype)
|
||||
seat->pointer_info.frame.event->any.type != event->any.type)
|
||||
gdk_wayland_seat_flush_frame_event (seat);
|
||||
|
||||
seat->pointer_info.frame.event = gdk_event_new (evtype);
|
||||
return seat->pointer_info.frame.event;
|
||||
seat->pointer_info.frame.event = event;
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -1536,8 +1490,7 @@ pointer_handle_enter (void *data,
|
||||
{
|
||||
GdkWaylandSeat *seat = data;
|
||||
GdkEvent *event;
|
||||
GdkWaylandDisplay *display_wayland =
|
||||
GDK_WAYLAND_DISPLAY (seat->display);
|
||||
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (seat->display);
|
||||
|
||||
if (!surface)
|
||||
return;
|
||||
@@ -1556,25 +1509,20 @@ pointer_handle_enter (void *data,
|
||||
seat->pointer_info.surface_y = wl_fixed_to_double (sy);
|
||||
seat->pointer_info.enter_serial = serial;
|
||||
|
||||
event = gdk_wayland_seat_get_frame_event (seat, GDK_ENTER_NOTIFY);
|
||||
event->any.surface = g_object_ref (seat->pointer_info.focus);
|
||||
gdk_event_set_device (event, seat->master_pointer);
|
||||
gdk_event_set_source_device (event, seat->pointer);
|
||||
event->crossing.child_surface = NULL;
|
||||
event->crossing.time = (guint32)(g_get_monotonic_time () / 1000);
|
||||
event->crossing.mode = GDK_CROSSING_NORMAL;
|
||||
event->crossing.detail = GDK_NOTIFY_NONLINEAR;
|
||||
event->crossing.focus = TRUE;
|
||||
event->crossing.state = 0;
|
||||
event = gdk_event_crossing_new (GDK_ENTER_NOTIFY,
|
||||
seat->pointer_info.focus,
|
||||
seat->master_pointer,
|
||||
seat->pointer,
|
||||
0,
|
||||
0,
|
||||
seat->pointer_info.surface_x,
|
||||
seat->pointer_info.surface_y,
|
||||
GDK_CROSSING_NORMAL,
|
||||
GDK_NOTIFY_NONLINEAR);
|
||||
gdk_wayland_seat_set_frame_event (seat, event);
|
||||
|
||||
gdk_wayland_device_update_surface_cursor (seat->master_pointer);
|
||||
|
||||
get_coordinates (seat->master_pointer,
|
||||
&event->crossing.x,
|
||||
&event->crossing.y,
|
||||
&event->crossing.x_root,
|
||||
&event->crossing.y_root);
|
||||
|
||||
GDK_SEAT_NOTE (seat, EVENTS,
|
||||
g_message ("enter, seat %p surface %p",
|
||||
seat, seat->pointer_info.focus));
|
||||
@@ -1604,25 +1552,20 @@ pointer_handle_leave (void *data,
|
||||
|
||||
_gdk_wayland_display_update_serial (display_wayland, serial);
|
||||
|
||||
event = gdk_wayland_seat_get_frame_event (seat, GDK_LEAVE_NOTIFY);
|
||||
event->any.surface = g_object_ref (seat->pointer_info.focus);
|
||||
gdk_event_set_device (event, seat->master_pointer);
|
||||
gdk_event_set_source_device (event, seat->pointer);
|
||||
event->crossing.child_surface = NULL;
|
||||
event->crossing.time = (guint32)(g_get_monotonic_time () / 1000);
|
||||
event->crossing.mode = GDK_CROSSING_NORMAL;
|
||||
event->crossing.detail = GDK_NOTIFY_NONLINEAR;
|
||||
event->crossing.focus = TRUE;
|
||||
event->crossing.state = 0;
|
||||
event = gdk_event_crossing_new (GDK_LEAVE_NOTIFY,
|
||||
seat->pointer_info.focus,
|
||||
seat->master_pointer,
|
||||
seat->pointer,
|
||||
0,
|
||||
0,
|
||||
seat->pointer_info.surface_x,
|
||||
seat->pointer_info.surface_y,
|
||||
GDK_CROSSING_NORMAL,
|
||||
GDK_NOTIFY_NONLINEAR);
|
||||
gdk_wayland_seat_set_frame_event (seat, event);
|
||||
|
||||
gdk_wayland_device_update_surface_cursor (seat->master_pointer);
|
||||
|
||||
get_coordinates (seat->master_pointer,
|
||||
&event->crossing.x,
|
||||
&event->crossing.y,
|
||||
&event->crossing.x_root,
|
||||
&event->crossing.y_root);
|
||||
|
||||
GDK_SEAT_NOTE (seat, EVENTS,
|
||||
g_message ("leave, seat %p surface %p",
|
||||
seat, seat->pointer_info.focus));
|
||||
@@ -1654,24 +1597,19 @@ pointer_handle_motion (void *data,
|
||||
seat->pointer_info.surface_x = wl_fixed_to_double (sx);
|
||||
seat->pointer_info.surface_y = wl_fixed_to_double (sy);
|
||||
|
||||
event = gdk_wayland_seat_get_frame_event (seat, GDK_MOTION_NOTIFY);
|
||||
event->any.surface = g_object_ref (seat->pointer_info.focus);
|
||||
gdk_event_set_device (event, seat->master_pointer);
|
||||
gdk_event_set_source_device (event, seat->pointer);
|
||||
event->motion.time = time;
|
||||
event->motion.axes = NULL;
|
||||
event->motion.state = device_get_modifiers (seat->master_pointer);
|
||||
gdk_event_set_display (event, seat->display);
|
||||
|
||||
get_coordinates (seat->master_pointer,
|
||||
&event->motion.x,
|
||||
&event->motion.y,
|
||||
&event->motion.x_root,
|
||||
&event->motion.y_root);
|
||||
event = gdk_event_motion_new (seat->pointer_info.focus,
|
||||
seat->master_pointer,
|
||||
seat->pointer,
|
||||
NULL,
|
||||
time,
|
||||
device_get_modifiers (seat->master_pointer),
|
||||
seat->pointer_info.surface_x,
|
||||
seat->pointer_info.surface_y);
|
||||
gdk_wayland_seat_set_frame_event (seat, event);
|
||||
|
||||
GDK_SEAT_NOTE (seat, EVENTS,
|
||||
g_message ("motion %f %f, seat %p state %d",
|
||||
wl_fixed_to_double (sx), wl_fixed_to_double (sy),
|
||||
event->motion.x, event->motion.y,
|
||||
seat, event->motion.state));
|
||||
|
||||
if (display->seat_version < WL_POINTER_HAS_FRAME)
|
||||
@@ -1718,23 +1656,18 @@ pointer_handle_button (void *data,
|
||||
if (state)
|
||||
seat->pointer_info.press_serial = serial;
|
||||
|
||||
event = gdk_wayland_seat_get_frame_event (seat,
|
||||
state ? GDK_BUTTON_PRESS :
|
||||
GDK_BUTTON_RELEASE);
|
||||
event->any.surface = g_object_ref (seat->pointer_info.focus);
|
||||
gdk_event_set_device (event, seat->master_pointer);
|
||||
gdk_event_set_source_device (event, seat->pointer);
|
||||
event->button.time = time;
|
||||
event->button.axes = NULL;
|
||||
event->button.state = device_get_modifiers (seat->master_pointer);
|
||||
event->button.button = gdk_button;
|
||||
gdk_event_set_display (event, seat->display);
|
||||
event = gdk_event_button_new (state ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE,
|
||||
seat->pointer_info.focus,
|
||||
seat->master_pointer,
|
||||
seat->pointer,
|
||||
NULL,
|
||||
time,
|
||||
seat->pointer_info.surface_x,
|
||||
seat->pointer_info.surface_y,
|
||||
gdk_button,
|
||||
device_get_modifiers (seat->master_pointer));
|
||||
|
||||
get_coordinates (seat->master_pointer,
|
||||
&event->button.x,
|
||||
&event->button.y,
|
||||
&event->button.x_root,
|
||||
&event->button.y_root);
|
||||
gdk_wayland_seat_set_frame_event (seat, event);
|
||||
|
||||
modifier = 1 << (8 + gdk_button - 1);
|
||||
if (state)
|
||||
@@ -1965,12 +1898,10 @@ keyboard_handle_enter (void *data,
|
||||
g_object_ref (seat->keyboard_focus);
|
||||
seat->repeat_key = 0;
|
||||
|
||||
event = gdk_event_new (GDK_FOCUS_CHANGE);
|
||||
event->any.surface = g_object_ref (seat->keyboard_focus);
|
||||
event->any.send_event = FALSE;
|
||||
event->focus_change.in = TRUE;
|
||||
gdk_event_set_device (event, seat->master_keyboard);
|
||||
gdk_event_set_source_device (event, seat->keyboard);
|
||||
event = gdk_event_focus_new (seat->keyboard_focus,
|
||||
seat->master_keyboard,
|
||||
seat->keyboard,
|
||||
TRUE);
|
||||
|
||||
GDK_SEAT_NOTE (seat, EVENTS,
|
||||
g_message ("focus in, seat %p surface %p",
|
||||
@@ -2002,12 +1933,10 @@ keyboard_handle_leave (void *data,
|
||||
|
||||
_gdk_wayland_display_update_serial (display, serial);
|
||||
|
||||
event = gdk_event_new (GDK_FOCUS_CHANGE);
|
||||
event->any.surface = g_object_ref (seat->keyboard_focus);
|
||||
event->any.send_event = FALSE;
|
||||
event->focus_change.in = FALSE;
|
||||
gdk_event_set_device (event, seat->master_keyboard);
|
||||
gdk_event_set_source_device (event, seat->keyboard);
|
||||
event = gdk_event_focus_new (seat->keyboard_focus,
|
||||
seat->master_keyboard,
|
||||
seat->keyboard,
|
||||
FALSE);
|
||||
|
||||
g_object_unref (seat->keyboard_focus);
|
||||
seat->keyboard_focus = NULL;
|
||||
@@ -2094,17 +2023,17 @@ deliver_key_event (GdkWaylandSeat *seat,
|
||||
seat->pointer_info.time = time_;
|
||||
seat->key_modifiers = gdk_keymap_get_modifier_state (keymap);
|
||||
|
||||
event = gdk_event_new (state ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
|
||||
event->any.surface = seat->keyboard_focus ? g_object_ref (seat->keyboard_focus) : NULL;
|
||||
gdk_event_set_device (event, seat->master_keyboard);
|
||||
gdk_event_set_source_device (event, seat->keyboard);
|
||||
event->key.time = time_;
|
||||
event->key.state = device_get_modifiers (seat->master_pointer);
|
||||
event->key.group = 0;
|
||||
event->key.hardware_keycode = key;
|
||||
gdk_event_set_scancode (event, key);
|
||||
event->key.keyval = sym;
|
||||
event->key.is_modifier = _gdk_wayland_keymap_key_is_modifier (keymap, key);
|
||||
event = gdk_event_key_new (state ? GDK_KEY_PRESS : GDK_KEY_RELEASE,
|
||||
seat->keyboard_focus,
|
||||
seat->master_keyboard,
|
||||
seat->keyboard,
|
||||
time_,
|
||||
device_get_modifiers (seat->master_pointer),
|
||||
sym,
|
||||
key,
|
||||
key,
|
||||
0,
|
||||
_gdk_wayland_keymap_key_is_modifier (keymap, key));
|
||||
|
||||
_gdk_wayland_display_deliver_event (seat->display, event);
|
||||
|
||||
@@ -2289,42 +2218,6 @@ gdk_wayland_seat_remove_touch (GdkWaylandSeat *seat,
|
||||
g_hash_table_remove (seat->touches, GUINT_TO_POINTER (id));
|
||||
}
|
||||
|
||||
static GdkEvent *
|
||||
_create_touch_event (GdkWaylandSeat *seat,
|
||||
GdkWaylandTouchData *touch,
|
||||
GdkEventType evtype,
|
||||
uint32_t time)
|
||||
{
|
||||
gint x_root, y_root;
|
||||
GdkEvent *event;
|
||||
|
||||
event = gdk_event_new (evtype);
|
||||
event->any.surface = g_object_ref (touch->surface);
|
||||
gdk_event_set_device (event, seat->touch_master);
|
||||
gdk_event_set_source_device (event, seat->touch);
|
||||
event->touch.time = time;
|
||||
event->touch.state = device_get_modifiers (seat->touch_master);
|
||||
gdk_event_set_display (event, seat->display);
|
||||
event->touch.sequence = GDK_SLOT_TO_EVENT_SEQUENCE (touch->id);
|
||||
|
||||
if (touch->initial_touch)
|
||||
{
|
||||
gdk_event_set_pointer_emulated (event, TRUE);
|
||||
event->touch.emulating_pointer = TRUE;
|
||||
}
|
||||
|
||||
gdk_surface_get_root_coords (touch->surface,
|
||||
touch->x, touch->y,
|
||||
&x_root, &y_root);
|
||||
|
||||
event->touch.x = touch->x;
|
||||
event->touch.y = touch->y;
|
||||
event->touch.x_root = x_root;
|
||||
event->touch.y_root = y_root;
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
static void
|
||||
mimic_pointer_emulating_touch_info (GdkDevice *device,
|
||||
GdkWaylandTouchData *touch)
|
||||
@@ -2387,7 +2280,14 @@ touch_handle_down (void *data,
|
||||
touch->y = wl_fixed_to_double (y);
|
||||
touch->touch_down_serial = serial;
|
||||
|
||||
event = _create_touch_event (seat, touch, GDK_TOUCH_BEGIN, time);
|
||||
event = gdk_event_touch_new (GDK_TOUCH_BEGIN,
|
||||
touch->surface,
|
||||
seat->touch_master,
|
||||
seat->touch,
|
||||
time,
|
||||
device_get_modifiers (seat->touch_master),
|
||||
touch->x, touch->y,
|
||||
touch->initial_touch);
|
||||
|
||||
if (touch->initial_touch)
|
||||
{
|
||||
@@ -2417,7 +2317,14 @@ touch_handle_up (void *data,
|
||||
_gdk_wayland_display_update_serial (display, serial);
|
||||
|
||||
touch = gdk_wayland_seat_get_touch (seat, id);
|
||||
event = _create_touch_event (seat, touch, GDK_TOUCH_END, time);
|
||||
event = gdk_event_touch_new (GDK_TOUCH_END,
|
||||
touch->surface,
|
||||
seat->touch_master,
|
||||
seat->touch,
|
||||
time,
|
||||
device_get_modifiers (seat->touch_master),
|
||||
touch->x, touch->y,
|
||||
touch->initial_touch);
|
||||
|
||||
GDK_SEAT_NOTE (seat, EVENTS,
|
||||
g_message ("touch end %f %f", event->touch.x, event->touch.y));
|
||||
@@ -2449,7 +2356,14 @@ touch_handle_motion (void *data,
|
||||
if (touch->initial_touch)
|
||||
mimic_pointer_emulating_touch_info (seat->touch_master, touch);
|
||||
|
||||
event = _create_touch_event (seat, touch, GDK_TOUCH_UPDATE, time);
|
||||
event = gdk_event_touch_new (GDK_TOUCH_UPDATE,
|
||||
touch->surface,
|
||||
seat->touch_master,
|
||||
seat->touch,
|
||||
time,
|
||||
device_get_modifiers (seat->touch_master),
|
||||
touch->x, touch->y,
|
||||
touch->initial_touch);
|
||||
|
||||
GDK_SEAT_NOTE (seat, EVENTS,
|
||||
g_message ("touch update %f %f", event->touch.x, event->touch.y));
|
||||
@@ -2467,28 +2381,34 @@ static void
|
||||
touch_handle_cancel (void *data,
|
||||
struct wl_touch *wl_touch)
|
||||
{
|
||||
GdkWaylandSeat *wayland_seat = data;
|
||||
GdkWaylandSeat *seat = data;
|
||||
GdkWaylandTouchData *touch;
|
||||
GHashTableIter iter;
|
||||
GdkEvent *event;
|
||||
|
||||
if (GDK_WAYLAND_DEVICE (wayland_seat->touch_master)->emulating_touch)
|
||||
if (GDK_WAYLAND_DEVICE (seat->touch_master)->emulating_touch)
|
||||
{
|
||||
touch = GDK_WAYLAND_DEVICE (wayland_seat->touch_master)->emulating_touch;
|
||||
GDK_WAYLAND_DEVICE (wayland_seat->touch_master)->emulating_touch = NULL;
|
||||
touch = GDK_WAYLAND_DEVICE (seat->touch_master)->emulating_touch;
|
||||
GDK_WAYLAND_DEVICE (seat->touch_master)->emulating_touch = NULL;
|
||||
}
|
||||
|
||||
g_hash_table_iter_init (&iter, wayland_seat->touches);
|
||||
g_hash_table_iter_init (&iter, seat->touches);
|
||||
|
||||
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &touch))
|
||||
{
|
||||
event = _create_touch_event (wayland_seat, touch, GDK_TOUCH_CANCEL,
|
||||
GDK_CURRENT_TIME);
|
||||
_gdk_wayland_display_deliver_event (wayland_seat->display, event);
|
||||
event = gdk_event_touch_new (GDK_TOUCH_CANCEL,
|
||||
touch->surface,
|
||||
seat->touch_master,
|
||||
seat->touch,
|
||||
GDK_CURRENT_TIME,
|
||||
device_get_modifiers (seat->touch_master),
|
||||
touch->x, touch->y,
|
||||
touch->initial_touch);
|
||||
_gdk_wayland_display_deliver_event (seat->display, event);
|
||||
g_hash_table_iter_remove (&iter);
|
||||
}
|
||||
|
||||
GDK_SEAT_NOTE (wayland_seat, EVENTS, g_message ("touch cancel"));
|
||||
GDK_SEAT_NOTE (seat, EVENTS, g_message ("touch cancel"));
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -2506,23 +2426,15 @@ emit_gesture_swipe_event (GdkWaylandSeat *seat,
|
||||
|
||||
seat->pointer_info.time = _time;
|
||||
|
||||
event = gdk_event_new (GDK_TOUCHPAD_SWIPE);
|
||||
event->touchpad_swipe.phase = phase;
|
||||
event->any.surface = g_object_ref (seat->pointer_info.focus);
|
||||
gdk_event_set_device (event, seat->master_pointer);
|
||||
gdk_event_set_source_device (event, seat->pointer);
|
||||
event->touchpad_swipe.time = _time;
|
||||
event->touchpad_swipe.state = device_get_modifiers (seat->master_pointer);
|
||||
gdk_event_set_display (event, seat->display);
|
||||
event->touchpad_swipe.dx = dx;
|
||||
event->touchpad_swipe.dy = dy;
|
||||
event->touchpad_swipe.n_fingers = n_fingers;
|
||||
|
||||
get_coordinates (seat->master_pointer,
|
||||
&event->touchpad_swipe.x,
|
||||
&event->touchpad_swipe.y,
|
||||
&event->touchpad_swipe.x_root,
|
||||
&event->touchpad_swipe.y_root);
|
||||
event = gdk_event_touchpad_swipe_new (seat->pointer_info.focus,
|
||||
seat->master_pointer,
|
||||
seat->pointer,
|
||||
_time,
|
||||
device_get_modifiers (seat->master_pointer),
|
||||
seat->pointer_info.surface_x,
|
||||
seat->pointer_info.surface_y,
|
||||
n_fingers,
|
||||
dx, dy);
|
||||
|
||||
GDK_SEAT_NOTE (seat, EVENTS,
|
||||
g_message ("swipe event %d, coords: %f %f, seat %p state %d",
|
||||
@@ -2607,25 +2519,17 @@ emit_gesture_pinch_event (GdkWaylandSeat *seat,
|
||||
|
||||
seat->pointer_info.time = _time;
|
||||
|
||||
event = gdk_event_new (GDK_TOUCHPAD_PINCH);
|
||||
event->touchpad_pinch.phase = phase;
|
||||
event->any.surface = g_object_ref (seat->pointer_info.focus);
|
||||
gdk_event_set_device (event, seat->master_pointer);
|
||||
gdk_event_set_source_device (event, seat->pointer);
|
||||
event->touchpad_pinch.time = _time;
|
||||
event->touchpad_pinch.state = device_get_modifiers (seat->master_pointer);
|
||||
gdk_event_set_display (event, seat->display);
|
||||
event->touchpad_pinch.dx = dx;
|
||||
event->touchpad_pinch.dy = dy;
|
||||
event->touchpad_pinch.scale = scale;
|
||||
event->touchpad_pinch.angle_delta = angle_delta * G_PI / 180;
|
||||
event->touchpad_pinch.n_fingers = n_fingers;
|
||||
|
||||
get_coordinates (seat->master_pointer,
|
||||
&event->touchpad_pinch.x,
|
||||
&event->touchpad_pinch.y,
|
||||
&event->touchpad_pinch.x_root,
|
||||
&event->touchpad_pinch.y_root);
|
||||
event = gdk_event_touchpad_pinch_new (seat->pointer_info.focus,
|
||||
seat->master_pointer,
|
||||
seat->pointer,
|
||||
_time,
|
||||
device_get_modifiers (seat->master_pointer),
|
||||
phase,
|
||||
seat->pointer_info.surface_x,
|
||||
seat->pointer_info.surface_y,
|
||||
n_fingers,
|
||||
dx, dy,
|
||||
scale, angle_delta * G_PI / 180);
|
||||
|
||||
GDK_SEAT_NOTE (seat, EVENTS,
|
||||
g_message ("pinch event %d, coords: %f %f, seat %p state %d",
|
||||
@@ -3351,16 +3255,15 @@ gdk_wayland_tablet_flush_frame_event (GdkWaylandTabletData *tablet,
|
||||
g_object_unref (event);
|
||||
}
|
||||
|
||||
static GdkEvent *
|
||||
gdk_wayland_tablet_get_frame_event (GdkWaylandTabletData *tablet,
|
||||
GdkEventType evtype)
|
||||
static void
|
||||
gdk_wayland_tablet_set_frame_event (GdkWaylandTabletData *tablet,
|
||||
GdkEvent *event)
|
||||
{
|
||||
if (tablet->pointer_info.frame.event &&
|
||||
tablet->pointer_info.frame.event->any.type != evtype)
|
||||
tablet->pointer_info.frame.event->any.type != event->any.type)
|
||||
gdk_wayland_tablet_flush_frame_event (tablet, GDK_CURRENT_TIME);
|
||||
|
||||
tablet->pointer_info.frame.event = gdk_event_new (evtype);
|
||||
return tablet->pointer_info.frame.event;
|
||||
tablet->pointer_info.frame.event = event;
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -3472,18 +3375,19 @@ tablet_tool_handle_proximity_in (void *data,
|
||||
tablet->pointer_info.enter_serial = serial;
|
||||
|
||||
tablet->pointer_info.focus = g_object_ref (surface);
|
||||
tablet->current_device =
|
||||
tablet_select_device_for_tool (tablet, tool->tool);
|
||||
tablet->current_device = tablet_select_device_for_tool (tablet, tool->tool);
|
||||
|
||||
gdk_device_update_tool (tablet->current_device, tool->tool);
|
||||
gdk_wayland_device_tablet_clone_tool_axes (tablet, tool->tool);
|
||||
gdk_wayland_mimic_device_axes (tablet->master, tablet->current_device);
|
||||
|
||||
event = gdk_wayland_tablet_get_frame_event (tablet, GDK_PROXIMITY_IN);
|
||||
event->any.surface = g_object_ref (tablet->pointer_info.focus);
|
||||
gdk_event_set_device (event, tablet->master);
|
||||
gdk_event_set_source_device (event, tablet->current_device);
|
||||
gdk_event_set_device_tool (event, tool->tool);
|
||||
event = gdk_event_proximity_new (GDK_PROXIMITY_IN,
|
||||
tablet->pointer_info.focus,
|
||||
tablet->master,
|
||||
tablet->current_device,
|
||||
tool->tool,
|
||||
tablet->pointer_info.time);
|
||||
gdk_wayland_tablet_set_frame_event (tablet, event);
|
||||
|
||||
tablet->pointer_info.pointer_surface_outputs =
|
||||
g_slist_append (tablet->pointer_info.pointer_surface_outputs,
|
||||
@@ -3508,11 +3412,13 @@ tablet_tool_handle_proximity_out (void *data,
|
||||
g_message ("proximity out, seat %p, tool %d", tool->seat,
|
||||
gdk_device_tool_get_tool_type (tool->tool)));
|
||||
|
||||
event = gdk_wayland_tablet_get_frame_event (tablet, GDK_PROXIMITY_OUT);
|
||||
event->any.surface = g_object_ref (tablet->pointer_info.focus);
|
||||
gdk_event_set_device (event, tablet->master);
|
||||
gdk_event_set_source_device (event, tablet->current_device);
|
||||
gdk_event_set_device_tool (event, tool->tool);
|
||||
event = gdk_event_proximity_new (GDK_PROXIMITY_OUT,
|
||||
tablet->pointer_info.focus,
|
||||
tablet->master,
|
||||
tablet->current_device,
|
||||
tool->tool,
|
||||
tablet->pointer_info.time);
|
||||
gdk_wayland_tablet_set_frame_event (tablet, event);
|
||||
|
||||
gdk_wayland_pointer_stop_cursor_animation (&tablet->pointer_info);
|
||||
|
||||
@@ -3536,21 +3442,17 @@ tablet_create_button_event_frame (GdkWaylandTabletData *tablet,
|
||||
GdkWaylandSeat *seat = GDK_WAYLAND_SEAT (tablet->seat);
|
||||
GdkEvent *event;
|
||||
|
||||
event = gdk_wayland_tablet_get_frame_event (tablet, evtype);
|
||||
event->any.surface = g_object_ref (tablet->pointer_info.focus);
|
||||
gdk_event_set_device (event, tablet->master);
|
||||
gdk_event_set_source_device (event, tablet->current_device);
|
||||
gdk_event_set_device_tool (event, tablet->current_tool->tool);
|
||||
event->button.time = tablet->pointer_info.time;
|
||||
event->button.state = device_get_modifiers (tablet->master);
|
||||
event->button.button = button;
|
||||
gdk_event_set_display (event, seat->display);
|
||||
|
||||
get_coordinates (tablet->master,
|
||||
&event->button.x,
|
||||
&event->button.y,
|
||||
&event->button.x_root,
|
||||
&event->button.y_root);
|
||||
event = gdk_event_button_new (evtype,
|
||||
tablet->pointer_info.focus,
|
||||
tablet->master,
|
||||
tablet->current_device,
|
||||
tablet->current_tool->tool,
|
||||
tablet->pointer_info.time,
|
||||
tablet->pointer_info.surface_x,
|
||||
tablet->pointer_info.surface_y,
|
||||
button,
|
||||
device_get_modifiers (seat->master_pointer));
|
||||
gdk_wayland_tablet_set_frame_event (tablet, event);
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -3606,20 +3508,16 @@ tablet_tool_handle_motion (void *data,
|
||||
tablet->pointer_info.surface_x,
|
||||
tablet->pointer_info.surface_y));
|
||||
|
||||
event = gdk_wayland_tablet_get_frame_event (tablet, GDK_MOTION_NOTIFY);
|
||||
event->any.surface = g_object_ref (tablet->pointer_info.focus);
|
||||
gdk_event_set_device (event, tablet->master);
|
||||
gdk_event_set_source_device (event, tablet->current_device);
|
||||
gdk_event_set_device_tool (event, tool->tool);
|
||||
event->motion.time = tablet->pointer_info.time;
|
||||
event->motion.state = device_get_modifiers (tablet->master);
|
||||
gdk_event_set_display (event, seat->display);
|
||||
event = gdk_event_motion_new (tablet->pointer_info.focus,
|
||||
tablet->master,
|
||||
tablet->current_device,
|
||||
tool->tool,
|
||||
tablet->pointer_info.time,
|
||||
device_get_modifiers (tablet->master),
|
||||
tablet->pointer_info.surface_x,
|
||||
tablet->pointer_info.surface_y);
|
||||
|
||||
get_coordinates (tablet->master,
|
||||
&event->motion.x,
|
||||
&event->motion.y,
|
||||
&event->motion.x_root,
|
||||
&event->motion.y_root);
|
||||
gdk_wayland_tablet_set_frame_event (tablet, event);
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -3771,18 +3669,27 @@ tablet_tool_handle_wheel (void *data,
|
||||
return;
|
||||
|
||||
/* Send smooth event */
|
||||
event = create_scroll_event (seat, &tablet->pointer_info,
|
||||
tablet->master, tablet->current_device, FALSE);
|
||||
gdk_event_set_device_tool (event, tablet->current_tool->tool);
|
||||
event->scroll.direction = GDK_SCROLL_SMOOTH;
|
||||
event->scroll.delta_y = clicks;
|
||||
event = gdk_event_scroll_new (tablet->pointer_info.focus,
|
||||
tablet->master,
|
||||
tablet->current_device,
|
||||
tablet->current_tool->tool,
|
||||
tablet->pointer_info.time,
|
||||
device_get_modifiers (tablet->master),
|
||||
0, clicks,
|
||||
FALSE);
|
||||
|
||||
_gdk_wayland_display_deliver_event (seat->display, event);
|
||||
|
||||
/* Send discrete event */
|
||||
event = create_scroll_event (seat, &tablet->pointer_info,
|
||||
tablet->master, tablet->current_device, TRUE);
|
||||
gdk_event_set_device_tool (event, tablet->current_tool->tool);
|
||||
event->scroll.direction = (clicks > 0) ? GDK_SCROLL_DOWN : GDK_SCROLL_UP;
|
||||
event = gdk_event_discrete_scroll_new (tablet->pointer_info.focus,
|
||||
tablet->master,
|
||||
tablet->current_device,
|
||||
tablet->current_tool->tool,
|
||||
tablet->pointer_info.time,
|
||||
device_get_modifiers (tablet->master),
|
||||
clicks > 0 ? GDK_SCROLL_DOWN : GDK_SCROLL_UP,
|
||||
TRUE);
|
||||
|
||||
_gdk_wayland_display_deliver_event (seat->display, event);
|
||||
}
|
||||
|
||||
@@ -3885,15 +3792,14 @@ tablet_pad_ring_handle_frame (void *data,
|
||||
GDK_SEAT_NOTE (seat, EVENTS,
|
||||
g_message ("tablet pad ring handle frame, ring = %p", wp_tablet_pad_ring));
|
||||
|
||||
event = gdk_event_new (GDK_PAD_RING);
|
||||
g_set_object (&event->any.surface, seat->keyboard_focus);
|
||||
event->pad_axis.time = time;
|
||||
event->pad_axis.group = g_list_index (pad->mode_groups, group);
|
||||
event->pad_axis.index = g_list_index (pad->rings, wp_tablet_pad_ring);
|
||||
event->pad_axis.mode = group->current_mode;
|
||||
event->pad_axis.value = group->axis_tmp_info.value;
|
||||
gdk_event_set_device (event, pad->device);
|
||||
gdk_event_set_source_device (event, pad->device);
|
||||
event = gdk_event_pad_ring_new (seat->keyboard_focus,
|
||||
pad->device,
|
||||
pad->device,
|
||||
time,
|
||||
g_list_index (pad->mode_groups, group),
|
||||
g_list_index (pad->rings, wp_tablet_pad_ring),
|
||||
group->current_mode,
|
||||
group->axis_tmp_info.value);
|
||||
|
||||
_gdk_wayland_display_deliver_event (gdk_seat_get_display (pad->seat),
|
||||
event);
|
||||
@@ -3961,16 +3867,14 @@ tablet_pad_strip_handle_frame (void *data,
|
||||
g_message ("tablet pad strip handle frame, strip = %p",
|
||||
wp_tablet_pad_strip));
|
||||
|
||||
event = gdk_event_new (GDK_PAD_STRIP);
|
||||
g_set_object (&event->any.surface, seat->keyboard_focus);
|
||||
event->pad_axis.time = time;
|
||||
event->pad_axis.group = g_list_index (pad->mode_groups, group);
|
||||
event->pad_axis.index = g_list_index (pad->strips, wp_tablet_pad_strip);
|
||||
event->pad_axis.mode = group->current_mode;
|
||||
event->pad_axis.value = group->axis_tmp_info.value;
|
||||
|
||||
gdk_event_set_device (event, pad->device);
|
||||
gdk_event_set_source_device (event, pad->device);
|
||||
event = gdk_event_pad_strip_new (seat->keyboard_focus,
|
||||
pad->device,
|
||||
pad->device,
|
||||
time,
|
||||
g_list_index (pad->mode_groups, group),
|
||||
g_list_index (pad->strips, wp_tablet_pad_strip),
|
||||
group->current_mode,
|
||||
group->axis_tmp_info.value);
|
||||
|
||||
_gdk_wayland_display_deliver_event (gdk_seat_get_display (pad->seat),
|
||||
event);
|
||||
@@ -4089,13 +3993,12 @@ tablet_pad_group_handle_mode (void *data,
|
||||
group->current_mode = mode;
|
||||
n_group = g_list_index (pad->mode_groups, group);
|
||||
|
||||
event = gdk_event_new (GDK_PAD_GROUP_MODE);
|
||||
g_set_object (&event->any.surface, seat->keyboard_focus);
|
||||
event->pad_group_mode.group = n_group;
|
||||
event->pad_group_mode.mode = mode;
|
||||
event->pad_group_mode.time = time;
|
||||
gdk_event_set_device (event, pad->device);
|
||||
gdk_event_set_source_device (event, pad->device);
|
||||
event = gdk_event_pad_group_mode_new (seat->keyboard_focus,
|
||||
pad->device,
|
||||
pad->device,
|
||||
time,
|
||||
n_group,
|
||||
mode);
|
||||
|
||||
_gdk_wayland_display_deliver_event (gdk_seat_get_display (pad->seat),
|
||||
event);
|
||||
@@ -4202,16 +4105,16 @@ tablet_pad_handle_button (void *data,
|
||||
group = tablet_pad_lookup_button_group (pad, button);
|
||||
n_group = g_list_index (pad->mode_groups, group);
|
||||
|
||||
event = gdk_event_new (state == ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED ?
|
||||
GDK_PAD_BUTTON_PRESS :
|
||||
GDK_PAD_BUTTON_RELEASE);
|
||||
g_set_object (&event->any.surface, GDK_WAYLAND_SEAT (pad->seat)->keyboard_focus);
|
||||
event->pad_button.button = button;
|
||||
event->pad_button.group = n_group;
|
||||
event->pad_button.mode = group->current_mode;
|
||||
event->pad_button.time = time;
|
||||
gdk_event_set_device (event, pad->device);
|
||||
gdk_event_set_source_device (event, pad->device);
|
||||
event = gdk_event_pad_button_new (state == ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED
|
||||
? GDK_PAD_BUTTON_PRESS
|
||||
: GDK_PAD_BUTTON_RELEASE,
|
||||
GDK_WAYLAND_SEAT (pad->seat)->keyboard_focus,
|
||||
pad->device,
|
||||
pad->device,
|
||||
time,
|
||||
n_group,
|
||||
button,
|
||||
group->current_mode);
|
||||
|
||||
_gdk_wayland_display_deliver_event (gdk_seat_get_display (pad->seat), event);
|
||||
}
|
||||
@@ -5036,8 +4939,14 @@ gdk_wayland_device_unset_touch_grab (GdkDevice *gdk_device,
|
||||
GDK_CURRENT_TIME);
|
||||
}
|
||||
|
||||
event = _create_touch_event (seat, touch, GDK_TOUCH_CANCEL,
|
||||
GDK_CURRENT_TIME);
|
||||
event = gdk_event_touch_new (GDK_TOUCH_CANCEL,
|
||||
touch->surface,
|
||||
seat->touch_master,
|
||||
seat->touch,
|
||||
GDK_CURRENT_TIME,
|
||||
device_get_modifiers (seat->touch_master),
|
||||
touch->x, touch->y,
|
||||
touch->initial_touch);
|
||||
_gdk_wayland_display_deliver_event (seat->display, event);
|
||||
}
|
||||
|
||||
|
||||
@@ -680,11 +680,7 @@ gdk_wayland_surface_resize (GdkSurface *surface,
|
||||
GdkDisplay *display;
|
||||
GdkEvent *event;
|
||||
|
||||
event = gdk_event_new (GDK_CONFIGURE);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.send_event = FALSE;
|
||||
event->configure.width = width;
|
||||
event->configure.height = height;
|
||||
event = gdk_event_configure_new (surface, width, height);
|
||||
|
||||
gdk_wayland_surface_update_size (surface, width, height, scale);
|
||||
_gdk_surface_update_size (surface);
|
||||
@@ -1255,9 +1251,7 @@ gdk_wayland_surface_handle_close (GdkSurface *surface)
|
||||
|
||||
GDK_DISPLAY_NOTE (display, EVENTS, g_message ("close %p", surface));
|
||||
|
||||
event = gdk_event_new (GDK_DELETE);
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.send_event = TRUE;
|
||||
event = gdk_event_delete_new (surface);
|
||||
|
||||
_gdk_wayland_display_deliver_event (display, event);
|
||||
}
|
||||
|
||||
@@ -1639,8 +1639,6 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
|
||||
event->scroll.time = xev->time;
|
||||
event->scroll.x = (gdouble) xev->event_x / scale;
|
||||
event->scroll.y = (gdouble) xev->event_y / scale;
|
||||
event->scroll.x_root = (gdouble) xev->root_x / scale;
|
||||
event->scroll.y_root = (gdouble) xev->root_y / scale;
|
||||
event->scroll.delta_x = 0;
|
||||
event->scroll.delta_y = 0;
|
||||
|
||||
@@ -1662,8 +1660,6 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
|
||||
event->button.time = xev->time;
|
||||
event->button.x = (gdouble) xev->event_x / scale;
|
||||
event->button.y = (gdouble) xev->event_y / scale;
|
||||
event->button.x_root = (gdouble) xev->root_x / scale;
|
||||
event->button.y_root = (gdouble) xev->root_y / scale;
|
||||
|
||||
device = g_hash_table_lookup (device_manager->id_table,
|
||||
GUINT_TO_POINTER (xev->deviceid));
|
||||
@@ -1746,8 +1742,6 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
|
||||
event->scroll.time = xev->time;
|
||||
event->scroll.x = (gdouble) xev->event_x / scale;
|
||||
event->scroll.y = (gdouble) xev->event_y / scale;
|
||||
event->scroll.x_root = (gdouble) xev->root_x / scale;
|
||||
event->scroll.y_root = (gdouble) xev->root_y / scale;
|
||||
event->scroll.delta_x = delta_x;
|
||||
event->scroll.delta_y = delta_y;
|
||||
|
||||
@@ -1763,8 +1757,6 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
|
||||
event->motion.time = xev->time;
|
||||
event->motion.x = (gdouble) xev->event_x / scale;
|
||||
event->motion.y = (gdouble) xev->event_y / scale;
|
||||
event->motion.x_root = (gdouble) xev->root_x / scale;
|
||||
event->motion.y_root = (gdouble) xev->root_y / scale;
|
||||
|
||||
gdk_event_set_device (event, device);
|
||||
gdk_event_set_source_device (event, source_device);
|
||||
@@ -1809,8 +1801,6 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
|
||||
event->touch.time = xev->time;
|
||||
event->touch.x = (gdouble) xev->event_x / scale;
|
||||
event->touch.y = (gdouble) xev->event_y / scale;
|
||||
event->touch.x_root = (gdouble) xev->root_x / scale;
|
||||
event->touch.y_root = (gdouble) xev->root_y / scale;
|
||||
|
||||
device = g_hash_table_lookup (device_manager->id_table,
|
||||
GUINT_TO_POINTER (xev->deviceid));
|
||||
@@ -1872,8 +1862,6 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
|
||||
event->touch.time = xev->time;
|
||||
event->touch.x = (gdouble) xev->event_x / scale;
|
||||
event->touch.y = (gdouble) xev->event_y / scale;
|
||||
event->touch.x_root = (gdouble) xev->root_x / scale;
|
||||
event->touch.y_root = (gdouble) xev->root_y / scale;
|
||||
|
||||
device = g_hash_table_lookup (device_manager->id_table,
|
||||
GINT_TO_POINTER (xev->deviceid));
|
||||
@@ -1927,8 +1915,6 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
|
||||
|
||||
event->crossing.x = (gdouble) xev->event_x / scale;
|
||||
event->crossing.y = (gdouble) xev->event_y / scale;
|
||||
event->crossing.x_root = (gdouble) xev->root_x / scale;
|
||||
event->crossing.y_root = (gdouble) xev->root_y / scale;
|
||||
event->crossing.time = xev->time;
|
||||
event->crossing.focus = xev->focus;
|
||||
|
||||
|
||||
@@ -2243,15 +2243,18 @@ gdk_drag_update (GdkDrag *drag,
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gdk_dnd_handle_motion_event (GdkDrag *drag,
|
||||
const GdkEventMotion *event)
|
||||
gdk_dnd_handle_motion_event (GdkDrag *drag,
|
||||
const GdkEvent *event)
|
||||
{
|
||||
GdkModifierType state;
|
||||
int x_root, y_root;
|
||||
|
||||
if (!gdk_event_get_state ((GdkEvent *) event, &state))
|
||||
return FALSE;
|
||||
|
||||
gdk_drag_update (drag, event->x_root, event->y_root, state,
|
||||
x_root = event->any.surface->x + event->motion.x;
|
||||
y_root = event->any.surface->y + event->motion.y;
|
||||
gdk_drag_update (drag, x_root, y_root, state,
|
||||
gdk_event_get_time ((GdkEvent *) event));
|
||||
return TRUE;
|
||||
}
|
||||
@@ -2407,7 +2410,7 @@ gdk_x11_drag_handle_event (GdkDrag *drag,
|
||||
switch ((guint) event->any.type)
|
||||
{
|
||||
case GDK_MOTION_NOTIFY:
|
||||
return gdk_dnd_handle_motion_event (drag, &event->motion);
|
||||
return gdk_dnd_handle_motion_event (drag, event);
|
||||
case GDK_BUTTON_RELEASE:
|
||||
return gdk_dnd_handle_button_event (drag, &event->button);
|
||||
case GDK_KEY_PRESS:
|
||||
|
||||
@@ -647,7 +647,8 @@ xdnd_position_filter (GdkSurface *surface,
|
||||
if ((drop != NULL) &&
|
||||
(drop_x11->source_window == source_window))
|
||||
{
|
||||
impl = GDK_X11_SURFACE (gdk_drop_get_surface (drop));
|
||||
surface = gdk_drop_get_surface (drop);
|
||||
impl = GDK_X11_SURFACE (surface);
|
||||
|
||||
drop_x11->suggested_action = xdnd_action_from_atom (display, action);
|
||||
gdk_x11_drop_update_actions (drop_x11);
|
||||
@@ -655,7 +656,7 @@ xdnd_position_filter (GdkSurface *surface,
|
||||
drop_x11->last_x = x_root / impl->surface_scale;
|
||||
drop_x11->last_y = y_root / impl->surface_scale;
|
||||
|
||||
gdk_drop_emit_motion_event (drop, FALSE, drop_x11->last_x, drop_x11->last_y, time);
|
||||
gdk_drop_emit_motion_event (drop, FALSE, drop_x11->last_x - surface->x, drop_x11->last_y - surface->y, time);
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
@@ -687,9 +688,10 @@ xdnd_drop_filter (GdkSurface *surface,
|
||||
if ((drop != NULL) &&
|
||||
(drop_x11->source_window == source_window))
|
||||
{
|
||||
gdk_x11_surface_set_user_time (gdk_drop_get_surface (drop), time);
|
||||
GdkSurface *s = gdk_drop_get_surface (drop);
|
||||
gdk_x11_surface_set_user_time (s, time);
|
||||
|
||||
gdk_drop_emit_drop_event (drop, FALSE, drop_x11->last_x, drop_x11->last_y, time);
|
||||
gdk_drop_emit_drop_event (drop, FALSE, drop_x11->last_x - s->x, drop_x11->last_y - s->y, time);
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
|
||||
+6
-11
@@ -256,9 +256,8 @@ static gboolean gtk_calendar_key_controller_key_pressed (GtkEventControllerKey *
|
||||
guint keycode,
|
||||
GdkModifierType state,
|
||||
GtkWidget *widget);
|
||||
static void gtk_calendar_key_controller_focus (GtkEventControllerKey *controller,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType detail,
|
||||
static void gtk_calendar_key_controller_focus (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
GtkWidget *widget);
|
||||
static void gtk_calendar_state_flags_changed (GtkWidget *widget,
|
||||
GtkStateFlags previous_state);
|
||||
@@ -570,10 +569,7 @@ gtk_calendar_init (GtkCalendar *calendar)
|
||||
g_signal_connect (controller, "key-pressed",
|
||||
G_CALLBACK (gtk_calendar_key_controller_key_pressed),
|
||||
calendar);
|
||||
g_signal_connect (controller, "focus-in",
|
||||
G_CALLBACK (gtk_calendar_key_controller_focus),
|
||||
calendar);
|
||||
g_signal_connect (controller, "focus-out",
|
||||
g_signal_connect (controller, "focus-change",
|
||||
G_CALLBACK (gtk_calendar_key_controller_focus),
|
||||
calendar);
|
||||
gtk_widget_add_controller (GTK_WIDGET (calendar), controller);
|
||||
@@ -1370,10 +1366,9 @@ gtk_calendar_key_controller_key_pressed (GtkEventControllerKey *controller,
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_calendar_key_controller_focus (GtkEventControllerKey *key,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType detail,
|
||||
GtkWidget *widget)
|
||||
gtk_calendar_key_controller_focus (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
GtkWidget *widget)
|
||||
{
|
||||
GtkCalendar *calendar = GTK_CALENDAR (widget);
|
||||
GtkCalendarPrivate *priv = gtk_calendar_get_instance_private (calendar);
|
||||
|
||||
+6
-5
@@ -117,7 +117,9 @@ static gboolean gtk_drop_target_accept (GtkDropTarget *dest,
|
||||
GdkDrop *drop);
|
||||
|
||||
static gboolean gtk_drop_target_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event);
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y);
|
||||
static gboolean gtk_drop_target_filter_event (GtkEventController *controller,
|
||||
const GdkEvent *event);
|
||||
static void gtk_drop_target_set_widget (GtkEventController *controller,
|
||||
@@ -747,11 +749,12 @@ gtk_drop_set_current_dest (GdkDrop *drop,
|
||||
|
||||
static gboolean
|
||||
gtk_drop_target_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkDropTarget *dest = GTK_DROP_TARGET (controller);
|
||||
GdkDrop *drop;
|
||||
double x, y;
|
||||
GtkDropStatus status;
|
||||
gboolean found = FALSE;
|
||||
|
||||
@@ -761,8 +764,6 @@ gtk_drop_target_handle_event (GtkEventController *controller,
|
||||
if (status == GTK_DROP_STATUS_DENIED)
|
||||
return FALSE;
|
||||
|
||||
gdk_event_get_coords (event, &x, &y);
|
||||
|
||||
switch ((int)gdk_event_get_event_type (event))
|
||||
{
|
||||
case GDK_DRAG_MOTION:
|
||||
|
||||
@@ -2307,13 +2307,13 @@ accept_completion_callback (GtkEntryCompletion *completion)
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
text_focus_out (GtkEntryCompletion *completion)
|
||||
static void
|
||||
text_focus_change (GtkEntryCompletion *completion,
|
||||
const GtkCrossingData *crossing)
|
||||
{
|
||||
if (gtk_widget_get_mapped (completion->priv->popup_window))
|
||||
return FALSE;
|
||||
|
||||
return accept_completion_callback (completion);
|
||||
if (crossing->direction == GTK_CROSSING_OUT &&
|
||||
!gtk_widget_get_mapped (completion->priv->popup_window))
|
||||
accept_completion_callback (completion);
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -2349,7 +2349,7 @@ connect_completion_signals (GtkEntryCompletion *completion)
|
||||
controller = priv->entry_key_controller = gtk_event_controller_key_new ();
|
||||
g_signal_connect (controller, "key-pressed",
|
||||
G_CALLBACK (gtk_entry_completion_key_pressed), completion);
|
||||
g_signal_connect_swapped (controller, "focus-out", G_CALLBACK (text_focus_out), completion);
|
||||
g_signal_connect_swapped (controller, "focus-change", G_CALLBACK (text_focus_change), completion);
|
||||
gtk_widget_add_controller (GTK_WIDGET (text), controller);
|
||||
|
||||
completion->priv->changed_id =
|
||||
|
||||
@@ -120,11 +120,21 @@ gtk_event_controller_filter_event_default (GtkEventController *self,
|
||||
|
||||
static gboolean
|
||||
gtk_event_controller_handle_event_default (GtkEventController *self,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_event_controller_handle_crossing_default (GtkEventController *self,
|
||||
const GtkCrossingData *crossing,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_event_controller_set_property (GObject *object,
|
||||
guint prop_id,
|
||||
@@ -202,6 +212,7 @@ gtk_event_controller_class_init (GtkEventControllerClass *klass)
|
||||
klass->unset_widget = gtk_event_controller_unset_widget;
|
||||
klass->filter_event = gtk_event_controller_filter_event_default;
|
||||
klass->handle_event = gtk_event_controller_handle_event_default;
|
||||
klass->handle_crossing = gtk_event_controller_handle_crossing_default;
|
||||
|
||||
object_class->finalize = gtk_event_controller_finalize;
|
||||
object_class->set_property = gtk_event_controller_set_property;
|
||||
@@ -269,6 +280,8 @@ gtk_event_controller_init (GtkEventController *controller)
|
||||
* gtk_event_controller_handle_event:
|
||||
* @controller: a #GtkEventController
|
||||
* @event: a #GdkEvent
|
||||
* @x: event position in widget coordinates, or 0 if not a pointer event
|
||||
* @y: event position in widget coordinates, or 0 if not a pointer event
|
||||
*
|
||||
* Feeds an event into @controller, so it can be interpreted
|
||||
* and the controller actions triggered.
|
||||
@@ -278,7 +291,9 @@ gtk_event_controller_init (GtkEventController *controller)
|
||||
**/
|
||||
gboolean
|
||||
gtk_event_controller_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkEventControllerClass *controller_class;
|
||||
gboolean retval = FALSE;
|
||||
@@ -294,13 +309,41 @@ gtk_event_controller_handle_event (GtkEventController *controller,
|
||||
if (controller_class->handle_event)
|
||||
{
|
||||
g_object_ref (controller);
|
||||
retval = controller_class->handle_event (controller, event);
|
||||
retval = controller_class->handle_event (controller, event, x, y);
|
||||
g_object_unref (controller);
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/**
|
||||
* gtk_event_controller_handle_crossing:
|
||||
* @controller: a #GtkEventController
|
||||
* @crossing: a #GtkCrossingData
|
||||
* @x: event position in widget coordinates
|
||||
* @y: event position in widget coordinates
|
||||
*
|
||||
* Feeds a crossing event into @controller, so it can be interpreted
|
||||
* and the controller actions triggered.
|
||||
**/
|
||||
void
|
||||
gtk_event_controller_handle_crossing (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkEventControllerClass *controller_class;
|
||||
|
||||
g_return_if_fail (GTK_IS_EVENT_CONTROLLER (controller));
|
||||
g_return_if_fail (crossing != NULL);
|
||||
|
||||
controller_class = GTK_EVENT_CONTROLLER_GET_CLASS (controller);
|
||||
|
||||
g_object_ref (controller);
|
||||
controller_class->handle_crossing (controller, crossing, x, y);
|
||||
g_object_unref (controller);
|
||||
}
|
||||
|
||||
/**
|
||||
* gtk_event_controller_get_widget:
|
||||
* @controller: a #GtkEventController
|
||||
@@ -445,3 +488,33 @@ gtk_event_controller_set_name (GtkEventController *controller,
|
||||
g_free (priv->name);
|
||||
priv->name = g_strdup (name);
|
||||
}
|
||||
|
||||
static GtkCrossingData *
|
||||
gtk_crossing_data_copy (GtkCrossingData *crossing)
|
||||
{
|
||||
GtkCrossingData *copy;
|
||||
|
||||
copy = g_new (GtkCrossingData, 1);
|
||||
|
||||
copy->type = crossing->type;
|
||||
copy->direction = crossing->direction;
|
||||
|
||||
if (crossing->old_target)
|
||||
copy->old_target = g_object_ref (crossing->old_target);
|
||||
if (crossing->new_target)
|
||||
copy->new_target = g_object_ref (crossing->new_target);
|
||||
|
||||
return copy;
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_crossing_data_free (GtkCrossingData *crossing)
|
||||
{
|
||||
g_clear_object (&crossing->old_target);
|
||||
g_clear_object (&crossing->new_target);
|
||||
|
||||
g_free (crossing);
|
||||
}
|
||||
|
||||
G_DEFINE_BOXED_TYPE (GtkCrossingData, gtk_crossing_data,
|
||||
gtk_crossing_data_copy, gtk_crossing_data_free)
|
||||
|
||||
@@ -40,6 +40,44 @@ G_BEGIN_DECLS
|
||||
#define GTK_EVENT_CONTROLLER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_EVENT_CONTROLLER, GtkEventControllerClass))
|
||||
|
||||
|
||||
typedef struct _GtkCrossingData GtkCrossingData;
|
||||
|
||||
typedef enum {
|
||||
GTK_CROSSING_FOCUS,
|
||||
GTK_CROSSING_POINTER
|
||||
} GtkCrossingType;
|
||||
|
||||
typedef enum {
|
||||
GTK_CROSSING_IN,
|
||||
GTK_CROSSING_OUT
|
||||
} GtkCrossingDirection;
|
||||
|
||||
/**
|
||||
* GtkCrossingData:
|
||||
* @type: the type of crossing event
|
||||
* @direction: whether this is a focus-in or focus-out event
|
||||
* @old_target: The old target
|
||||
* @new_target: The new target
|
||||
*
|
||||
* The struct that is passed to gtk_event_controller_handle_crossing()
|
||||
* and is also passed to #GtkEventControllerKey::focus-change.
|
||||
*
|
||||
* The @old_target and @new_target fields are set to the old or new
|
||||
* focus or hover location.
|
||||
*/
|
||||
struct _GtkCrossingData {
|
||||
GtkCrossingType type;
|
||||
GtkCrossingDirection direction;
|
||||
GtkWidget *old_target;
|
||||
GtkWidget *new_target;
|
||||
};
|
||||
|
||||
#define GTK_TYPE_CROSSING_DATA (gtk_crossing_data_get_type ())
|
||||
|
||||
GDK_AVAILABLE_IN_ALL
|
||||
GType gtk_crossing_data_get_type (void) G_GNUC_CONST;
|
||||
|
||||
|
||||
GDK_AVAILABLE_IN_ALL
|
||||
GType gtk_event_controller_get_type (void) G_GNUC_CONST;
|
||||
|
||||
@@ -48,7 +86,14 @@ GtkWidget * gtk_event_controller_get_widget (GtkEventController *controller
|
||||
|
||||
GDK_AVAILABLE_IN_ALL
|
||||
gboolean gtk_event_controller_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event);
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y);
|
||||
GDK_AVAILABLE_IN_ALL
|
||||
void gtk_event_controller_handle_crossing (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
double x,
|
||||
double y);
|
||||
GDK_AVAILABLE_IN_ALL
|
||||
void gtk_event_controller_reset (GtkEventController *controller);
|
||||
|
||||
|
||||
+64
-117
@@ -65,8 +65,7 @@ enum {
|
||||
KEY_RELEASED,
|
||||
MODIFIERS,
|
||||
IM_UPDATE,
|
||||
FOCUS_IN,
|
||||
FOCUS_OUT,
|
||||
FOCUS_CHANGE,
|
||||
N_SIGNALS
|
||||
};
|
||||
|
||||
@@ -94,60 +93,11 @@ gtk_event_controller_key_finalize (GObject *object)
|
||||
G_OBJECT_CLASS (gtk_event_controller_key_parent_class)->finalize (object);
|
||||
}
|
||||
|
||||
static void
|
||||
update_focus (GtkEventControllerKey *key,
|
||||
gboolean focus_in,
|
||||
GdkNotifyType detail)
|
||||
{
|
||||
gboolean is_focus;
|
||||
gboolean contains_focus;
|
||||
|
||||
switch (detail)
|
||||
{
|
||||
case GDK_NOTIFY_VIRTUAL:
|
||||
case GDK_NOTIFY_NONLINEAR_VIRTUAL:
|
||||
is_focus = FALSE;
|
||||
contains_focus = focus_in;
|
||||
break;
|
||||
case GDK_NOTIFY_ANCESTOR:
|
||||
case GDK_NOTIFY_NONLINEAR:
|
||||
is_focus = focus_in;
|
||||
contains_focus = is_focus;
|
||||
break;
|
||||
case GDK_NOTIFY_INFERIOR:
|
||||
is_focus = focus_in;
|
||||
contains_focus = TRUE;
|
||||
break;
|
||||
case GDK_NOTIFY_UNKNOWN:
|
||||
default:
|
||||
g_warning ("Unknown focus change detail");
|
||||
return;
|
||||
}
|
||||
|
||||
g_object_freeze_notify (G_OBJECT (key));
|
||||
if (key->is_focus != is_focus)
|
||||
{
|
||||
key->is_focus = is_focus;
|
||||
g_object_notify (G_OBJECT (key), "is-focus");
|
||||
if (key->im_context)
|
||||
{
|
||||
if (focus_in)
|
||||
gtk_im_context_focus_in (key->im_context);
|
||||
else
|
||||
gtk_im_context_focus_out (key->im_context);
|
||||
}
|
||||
}
|
||||
if (key->contains_focus != contains_focus)
|
||||
{
|
||||
key->contains_focus = contains_focus;
|
||||
g_object_notify (G_OBJECT (key), "contains-focus");
|
||||
}
|
||||
g_object_thaw_notify (G_OBJECT (key));
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gtk_event_controller_key_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkEventControllerKey *key = GTK_EVENT_CONTROLLER_KEY (controller);
|
||||
GdkEventType event_type = gdk_event_get_event_type (event);
|
||||
@@ -156,30 +106,6 @@ gtk_event_controller_key_handle_event (GtkEventController *controller,
|
||||
guint keyval;
|
||||
gboolean handled = FALSE;
|
||||
|
||||
if (event_type == GDK_FOCUS_CHANGE)
|
||||
{
|
||||
gboolean focus_in;
|
||||
GdkCrossingMode mode;
|
||||
GdkNotifyType detail;
|
||||
|
||||
gdk_event_get_focus_in (event, &focus_in);
|
||||
gdk_event_get_crossing_mode (event, &mode);
|
||||
gdk_event_get_crossing_detail (event, &detail);
|
||||
|
||||
update_focus (key, focus_in, detail);
|
||||
|
||||
key->current_event = event;
|
||||
|
||||
if (focus_in)
|
||||
g_signal_emit (controller, signals[FOCUS_IN], 0, mode, detail);
|
||||
else
|
||||
g_signal_emit (controller, signals[FOCUS_OUT], 0, mode, detail);
|
||||
|
||||
key->current_event = NULL;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (event_type != GDK_KEY_PRESS && event_type != GDK_KEY_RELEASE)
|
||||
return FALSE;
|
||||
|
||||
@@ -227,6 +153,58 @@ gtk_event_controller_key_handle_event (GtkEventController *controller,
|
||||
return handled;
|
||||
}
|
||||
|
||||
static void
|
||||
update_focus (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing)
|
||||
{
|
||||
GtkEventControllerKey *key = GTK_EVENT_CONTROLLER_KEY (controller);
|
||||
GtkWidget *widget = gtk_event_controller_get_widget (controller);
|
||||
gboolean is_focus = FALSE;
|
||||
gboolean contains_focus = FALSE;
|
||||
|
||||
if (crossing->direction == GTK_CROSSING_IN)
|
||||
{
|
||||
if (crossing->new_target == widget)
|
||||
is_focus = TRUE;
|
||||
if (crossing->new_target != NULL)
|
||||
contains_focus = TRUE;
|
||||
}
|
||||
|
||||
g_object_freeze_notify (G_OBJECT (key));
|
||||
if (key->is_focus != is_focus)
|
||||
{
|
||||
key->is_focus = is_focus;
|
||||
g_object_notify (G_OBJECT (key), "is-focus");
|
||||
if (key->im_context)
|
||||
{
|
||||
if (is_focus)
|
||||
gtk_im_context_focus_in (key->im_context);
|
||||
else
|
||||
gtk_im_context_focus_out (key->im_context);
|
||||
}
|
||||
}
|
||||
if (key->contains_focus != contains_focus)
|
||||
{
|
||||
key->contains_focus = contains_focus;
|
||||
g_object_notify (G_OBJECT (key), "contains-focus");
|
||||
}
|
||||
g_object_thaw_notify (G_OBJECT (key));
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_event_controller_key_handle_crossing (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
if (crossing->type != GTK_CROSSING_FOCUS)
|
||||
return;
|
||||
|
||||
update_focus (controller, crossing);
|
||||
|
||||
g_signal_emit (controller, signals[FOCUS_CHANGE], 0, crossing);
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_event_controller_key_get_property (GObject *object,
|
||||
guint prop_id,
|
||||
@@ -259,6 +237,7 @@ gtk_event_controller_key_class_init (GtkEventControllerKeyClass *klass)
|
||||
object_class->finalize = gtk_event_controller_key_finalize;
|
||||
object_class->get_property = gtk_event_controller_key_get_property;
|
||||
controller_class->handle_event = gtk_event_controller_key_handle_event;
|
||||
controller_class->handle_crossing = gtk_event_controller_key_handle_crossing;
|
||||
|
||||
/**
|
||||
* GtkEventControllerKey:is-focus:
|
||||
@@ -379,47 +358,15 @@ gtk_event_controller_key_class_init (GtkEventControllerKeyClass *klass)
|
||||
NULL,
|
||||
G_TYPE_NONE, 0);
|
||||
|
||||
/**
|
||||
* GtkEventControllerKey::focus-in:
|
||||
* @controller: the object which received the signal.
|
||||
* @mode: crossing mode indicating what caused this change
|
||||
* @detail: detail indication where the focus is coming from
|
||||
*
|
||||
* This signal is emitted whenever the widget controlled
|
||||
* by the @controller or one of its descendants) is given
|
||||
* the keyboard focus.
|
||||
*/
|
||||
signals[FOCUS_IN] =
|
||||
g_signal_new (I_("focus-in"),
|
||||
signals[FOCUS_CHANGE] =
|
||||
g_signal_new (I_("focus-change"),
|
||||
GTK_TYPE_EVENT_CONTROLLER_KEY,
|
||||
G_SIGNAL_RUN_LAST,
|
||||
0, NULL, NULL,
|
||||
NULL,
|
||||
G_TYPE_NONE,
|
||||
2,
|
||||
GDK_TYPE_CROSSING_MODE,
|
||||
GDK_TYPE_NOTIFY_TYPE);
|
||||
|
||||
/**
|
||||
* GtkEventControllerKey::focus-out:
|
||||
* @controller: the object which received the signal.
|
||||
* @mode: crossing mode indicating what caused this change
|
||||
* @detail: detail indication where the focus is going
|
||||
*
|
||||
* This signal is emitted whenever the widget controlled
|
||||
* by the @controller (or one of its descendants) loses
|
||||
* the keyboard focus.
|
||||
*/
|
||||
signals[FOCUS_OUT] =
|
||||
g_signal_new (I_("focus-out"),
|
||||
GTK_TYPE_EVENT_CONTROLLER_KEY,
|
||||
G_SIGNAL_RUN_LAST,
|
||||
0, NULL, NULL,
|
||||
NULL,
|
||||
G_TYPE_NONE,
|
||||
2,
|
||||
GDK_TYPE_CROSSING_MODE,
|
||||
GDK_TYPE_NOTIFY_TYPE);
|
||||
1,
|
||||
GTK_TYPE_CROSSING_DATA | G_SIGNAL_TYPE_STATIC_SCOPE);
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -506,13 +453,13 @@ gtk_event_controller_key_forward (GtkEventControllerKey *controller,
|
||||
if (!gtk_widget_get_realized (widget))
|
||||
gtk_widget_realize (widget);
|
||||
|
||||
if (gtk_widget_run_controllers (widget, controller->current_event,
|
||||
if (gtk_widget_run_controllers (widget, controller->current_event, 0, 0,
|
||||
GTK_PHASE_CAPTURE))
|
||||
return TRUE;
|
||||
if (gtk_widget_run_controllers (widget, controller->current_event,
|
||||
if (gtk_widget_run_controllers (widget, controller->current_event, 0, 0,
|
||||
GTK_PHASE_TARGET))
|
||||
return TRUE;
|
||||
if (gtk_widget_run_controllers (widget, controller->current_event,
|
||||
if (gtk_widget_run_controllers (widget, controller->current_event, 0, 0,
|
||||
GTK_PHASE_BUBBLE))
|
||||
return TRUE;
|
||||
|
||||
|
||||
@@ -59,7 +59,9 @@ G_DEFINE_TYPE (GtkEventControllerLegacy, gtk_event_controller_legacy,
|
||||
|
||||
static gboolean
|
||||
gtk_event_controller_legacy_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
gboolean handled;
|
||||
|
||||
|
||||
+49
-114
@@ -53,8 +53,7 @@ struct _GtkEventControllerMotionClass
|
||||
};
|
||||
|
||||
enum {
|
||||
ENTER,
|
||||
LEAVE,
|
||||
POINTER_CHANGE,
|
||||
MOTION,
|
||||
N_SIGNALS
|
||||
};
|
||||
@@ -71,34 +70,39 @@ static guint signals[N_SIGNALS] = { 0 };
|
||||
|
||||
G_DEFINE_TYPE (GtkEventControllerMotion, gtk_event_controller_motion, GTK_TYPE_EVENT_CONTROLLER)
|
||||
|
||||
static void
|
||||
update_pointer_focus (GtkEventControllerMotion *motion,
|
||||
gboolean enter,
|
||||
GdkNotifyType detail)
|
||||
static gboolean
|
||||
gtk_event_controller_motion_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
gboolean is_pointer;
|
||||
gboolean contains_pointer;
|
||||
GtkEventControllerClass *parent_class;
|
||||
GdkEventType type;
|
||||
|
||||
switch (detail)
|
||||
type = gdk_event_get_event_type (event);
|
||||
if (type == GDK_MOTION_NOTIFY)
|
||||
g_signal_emit (controller, signals[MOTION], 0, x, y);
|
||||
|
||||
parent_class = GTK_EVENT_CONTROLLER_CLASS (gtk_event_controller_motion_parent_class);
|
||||
|
||||
return parent_class->handle_event (controller, event, x, y);
|
||||
}
|
||||
|
||||
static void
|
||||
update_pointer_focus (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing)
|
||||
{
|
||||
GtkEventControllerMotion *motion = GTK_EVENT_CONTROLLER_MOTION (controller);
|
||||
GtkWidget *widget = gtk_event_controller_get_widget (controller);
|
||||
gboolean is_pointer = FALSE;
|
||||
gboolean contains_pointer = FALSE;
|
||||
|
||||
if (crossing->direction == GTK_CROSSING_IN)
|
||||
{
|
||||
case GDK_NOTIFY_VIRTUAL:
|
||||
case GDK_NOTIFY_NONLINEAR_VIRTUAL:
|
||||
is_pointer = FALSE;
|
||||
contains_pointer = enter;
|
||||
break;
|
||||
case GDK_NOTIFY_ANCESTOR:
|
||||
case GDK_NOTIFY_NONLINEAR:
|
||||
is_pointer = enter;
|
||||
contains_pointer = enter;
|
||||
break;
|
||||
case GDK_NOTIFY_INFERIOR:
|
||||
is_pointer = enter;
|
||||
contains_pointer = TRUE;
|
||||
break;
|
||||
case GDK_NOTIFY_UNKNOWN:
|
||||
default:
|
||||
g_warning ("Unknown crossing detail");
|
||||
return;
|
||||
if (crossing->new_target == widget)
|
||||
is_pointer = TRUE;
|
||||
if (crossing->new_target != NULL)
|
||||
contains_pointer = TRUE;
|
||||
}
|
||||
|
||||
g_object_freeze_notify (G_OBJECT (motion));
|
||||
@@ -115,61 +119,18 @@ update_pointer_focus (GtkEventControllerMotion *motion,
|
||||
g_object_thaw_notify (G_OBJECT (motion));
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gtk_event_controller_motion_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
static void
|
||||
gtk_event_controller_motion_handle_crossing (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkEventControllerMotion *motion = GTK_EVENT_CONTROLLER_MOTION (controller);
|
||||
GtkEventControllerClass *parent_class;
|
||||
GdkEventType type;
|
||||
if (crossing->type != GTK_CROSSING_POINTER)
|
||||
return;
|
||||
|
||||
type = gdk_event_get_event_type (event);
|
||||
if (type == GDK_ENTER_NOTIFY)
|
||||
{
|
||||
double x, y;
|
||||
GdkCrossingMode mode;
|
||||
GdkNotifyType detail;
|
||||
update_pointer_focus (controller, crossing);
|
||||
|
||||
gdk_event_get_coords (event, &x, &y);
|
||||
gdk_event_get_crossing_mode (event, &mode);
|
||||
gdk_event_get_crossing_detail (event, &detail);
|
||||
|
||||
update_pointer_focus (motion, TRUE, detail);
|
||||
|
||||
motion->current_event = event;
|
||||
|
||||
g_signal_emit (controller, signals[ENTER], 0, x, y, mode, detail);
|
||||
|
||||
motion->current_event = NULL;
|
||||
}
|
||||
else if (type == GDK_LEAVE_NOTIFY)
|
||||
{
|
||||
GdkCrossingMode mode;
|
||||
GdkNotifyType detail;
|
||||
|
||||
gdk_event_get_crossing_mode (event, &mode);
|
||||
gdk_event_get_crossing_detail (event, &detail);
|
||||
|
||||
update_pointer_focus (motion, FALSE, detail);
|
||||
|
||||
motion->current_event = event;
|
||||
|
||||
g_signal_emit (controller, signals[LEAVE], 0, mode, detail);
|
||||
|
||||
motion->current_event = NULL;
|
||||
}
|
||||
else if (type == GDK_MOTION_NOTIFY)
|
||||
{
|
||||
double x, y;
|
||||
|
||||
gdk_event_get_coords (event, &x, &y);
|
||||
|
||||
g_signal_emit (controller, signals[MOTION], 0, x, y);
|
||||
}
|
||||
|
||||
parent_class = GTK_EVENT_CONTROLLER_CLASS (gtk_event_controller_motion_parent_class);
|
||||
|
||||
return parent_class->handle_event (controller, event);
|
||||
g_signal_emit (controller, signals[POINTER_CHANGE], 0, crossing, x, y);
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -204,6 +165,7 @@ gtk_event_controller_motion_class_init (GtkEventControllerMotionClass *klass)
|
||||
object_class->get_property = gtk_event_controller_motion_get_property;
|
||||
|
||||
controller_class->handle_event = gtk_event_controller_motion_handle_event;
|
||||
controller_class->handle_crossing = gtk_event_controller_motion_handle_crossing;
|
||||
|
||||
/**
|
||||
* GtkEventControllerMotion:is-pointer:
|
||||
@@ -243,52 +205,25 @@ gtk_event_controller_motion_class_init (GtkEventControllerMotionClass *klass)
|
||||
g_object_class_install_properties (object_class, NUM_PROPERTIES, props);
|
||||
|
||||
/**
|
||||
* GtkEventControllerMotion::enter:
|
||||
* GtkEventControllerMotion::pointer-change:
|
||||
* @controller: The object that received the signal
|
||||
* @crossing: the #GtkCrossingData
|
||||
* @x: the x coordinate
|
||||
* @y: the y coordinate
|
||||
* @crossing_mode: the crossing mode of this event
|
||||
* @notify_type: the kind of crossing event
|
||||
*
|
||||
* Signals that the pointer has entered the widget.
|
||||
* Signals that the pointer has entered or left the widget.
|
||||
*/
|
||||
signals[ENTER] =
|
||||
g_signal_new (I_("enter"),
|
||||
signals[POINTER_CHANGE] =
|
||||
g_signal_new (I_("pointer-change"),
|
||||
GTK_TYPE_EVENT_CONTROLLER_MOTION,
|
||||
G_SIGNAL_RUN_FIRST,
|
||||
0, NULL, NULL,
|
||||
_gtk_marshal_VOID__DOUBLE_DOUBLE_ENUM_ENUM,
|
||||
G_TYPE_NONE,
|
||||
4,
|
||||
3,
|
||||
GTK_TYPE_CROSSING_DATA | G_SIGNAL_TYPE_STATIC_SCOPE,
|
||||
G_TYPE_DOUBLE,
|
||||
G_TYPE_DOUBLE,
|
||||
GDK_TYPE_CROSSING_MODE,
|
||||
GDK_TYPE_NOTIFY_TYPE);
|
||||
g_signal_set_va_marshaller (signals[ENTER],
|
||||
G_TYPE_FROM_CLASS (klass),
|
||||
_gtk_marshal_VOID__DOUBLE_DOUBLE_ENUM_ENUMv);
|
||||
|
||||
/**
|
||||
* GtkEventControllerMotion::leave:
|
||||
* @controller: The object that received the signal
|
||||
* @crossing_mode: the crossing mode of this event
|
||||
* @notify_type: the kind of crossing event
|
||||
*
|
||||
* Signals that pointer has left the widget.
|
||||
*/
|
||||
signals[LEAVE] =
|
||||
g_signal_new (I_("leave"),
|
||||
GTK_TYPE_EVENT_CONTROLLER_MOTION,
|
||||
G_SIGNAL_RUN_FIRST,
|
||||
0, NULL, NULL,
|
||||
_gtk_marshal_VOID__ENUM_ENUM,
|
||||
G_TYPE_NONE,
|
||||
2,
|
||||
GDK_TYPE_CROSSING_MODE,
|
||||
GDK_TYPE_NOTIFY_TYPE);
|
||||
g_signal_set_va_marshaller (signals[LEAVE],
|
||||
G_TYPE_FROM_CLASS (klass),
|
||||
_gtk_marshal_VOID__ENUM_ENUMv);
|
||||
G_TYPE_DOUBLE);
|
||||
|
||||
/**
|
||||
* GtkEventControllerMotion::motion:
|
||||
|
||||
@@ -35,9 +35,16 @@ struct _GtkEventControllerClass
|
||||
GtkWidget *widget);
|
||||
void (* unset_widget) (GtkEventController *controller);
|
||||
gboolean (* handle_event) (GtkEventController *controller,
|
||||
const GdkEvent *event);
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y);
|
||||
void (* reset) (GtkEventController *controller);
|
||||
|
||||
void (* handle_crossing) (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
double x,
|
||||
double y);
|
||||
|
||||
/*<private>*/
|
||||
|
||||
/* Tells whether the event is filtered out, %TRUE makes
|
||||
|
||||
@@ -238,7 +238,9 @@ gtk_event_controller_scroll_get_property (GObject *object,
|
||||
|
||||
static gboolean
|
||||
gtk_event_controller_scroll_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkEventControllerScroll *scroll = GTK_EVENT_CONTROLLER_SCROLL (controller);
|
||||
GdkScrollDirection direction = GDK_SCROLL_SMOOTH;
|
||||
|
||||
@@ -259,12 +259,12 @@ match_func (GtkEntryCompletion *compl,
|
||||
}
|
||||
|
||||
static void
|
||||
chooser_entry_focus_out (GtkEventControllerKey *key_controller,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType detail,
|
||||
GtkFileChooserEntry *chooser_entry)
|
||||
chooser_entry_focus_change (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
GtkFileChooserEntry *chooser_entry)
|
||||
{
|
||||
set_complete_on_load (chooser_entry, FALSE);
|
||||
if (crossing->direction == GTK_CROSSING_OUT)
|
||||
set_complete_on_load (chooser_entry, FALSE);
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -312,7 +312,7 @@ _gtk_file_chooser_entry_init (GtkFileChooserEntry *chooser_entry)
|
||||
G_CALLBACK (gtk_file_chooser_entry_tab_handler),
|
||||
chooser_entry);
|
||||
g_signal_connect (controller,
|
||||
"focus-out", G_CALLBACK (chooser_entry_focus_out),
|
||||
"focus-change", G_CALLBACK (chooser_entry_focus_change),
|
||||
chooser_entry);
|
||||
gtk_widget_add_controller (GTK_WIDGET (chooser_entry), controller);
|
||||
|
||||
|
||||
+10
-35
@@ -414,36 +414,6 @@ _update_touchpad_deltas (PointData *data)
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
_get_event_coordinates (PointData *data,
|
||||
gdouble *x,
|
||||
gdouble *y)
|
||||
{
|
||||
gdouble event_x, event_y;
|
||||
|
||||
g_assert (data->event != NULL);
|
||||
|
||||
gdk_event_get_coords (data->event, &event_x, &event_y);
|
||||
event_x += data->accum_dx;
|
||||
event_y += data->accum_dy;
|
||||
|
||||
if (x)
|
||||
*x = event_x;
|
||||
if (y)
|
||||
*y = event_y;
|
||||
}
|
||||
|
||||
static void
|
||||
_update_widget_coordinates (GtkGesture *gesture,
|
||||
PointData *data)
|
||||
{
|
||||
gdouble event_x, event_y;
|
||||
|
||||
_get_event_coordinates (data, &event_x, &event_y);
|
||||
data->widget_x = event_x;
|
||||
data->widget_y = event_y;
|
||||
}
|
||||
|
||||
static GtkEventSequenceState
|
||||
gtk_gesture_get_group_state (GtkGesture *gesture,
|
||||
GdkEventSequence *sequence)
|
||||
@@ -470,6 +440,8 @@ gtk_gesture_get_group_state (GtkGesture *gesture,
|
||||
static gboolean
|
||||
_gtk_gesture_update_point (GtkGesture *gesture,
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y,
|
||||
gboolean add)
|
||||
{
|
||||
GdkEventSequence *sequence;
|
||||
@@ -533,8 +505,9 @@ _gtk_gesture_update_point (GtkGesture *gesture,
|
||||
g_object_unref (data->event);
|
||||
|
||||
data->event = g_object_ref ((gpointer) event);
|
||||
data->widget_x = x;
|
||||
data->widget_y = y;
|
||||
_update_touchpad_deltas (data);
|
||||
_update_widget_coordinates (gesture, data);
|
||||
|
||||
/* Deny the sequence right away if the expected
|
||||
* number of points is exceeded, so this sequence
|
||||
@@ -627,7 +600,9 @@ gtk_gesture_filter_event (GtkEventController *controller,
|
||||
|
||||
static gboolean
|
||||
gtk_gesture_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkGesture *gesture = GTK_GESTURE (controller);
|
||||
GdkEventSequence *sequence;
|
||||
@@ -658,7 +633,7 @@ gtk_gesture_handle_event (GtkEventController *controller,
|
||||
(event_type == GDK_TOUCHPAD_SWIPE && phase == GDK_TOUCHPAD_GESTURE_PHASE_BEGIN) ||
|
||||
(event_type == GDK_TOUCHPAD_PINCH && phase == GDK_TOUCHPAD_GESTURE_PHASE_BEGIN))
|
||||
{
|
||||
if (_gtk_gesture_update_point (gesture, event, TRUE))
|
||||
if (_gtk_gesture_update_point (gesture, event, x, y, TRUE))
|
||||
{
|
||||
gboolean triggered_recognition;
|
||||
|
||||
@@ -692,7 +667,7 @@ gtk_gesture_handle_event (GtkEventController *controller,
|
||||
{
|
||||
gboolean was_claimed;
|
||||
|
||||
if (_gtk_gesture_update_point (gesture, event, FALSE))
|
||||
if (_gtk_gesture_update_point (gesture, event, x, y, FALSE))
|
||||
{
|
||||
if (was_recognized &&
|
||||
_gtk_gesture_check_recognized (gesture, sequence))
|
||||
@@ -717,7 +692,7 @@ gtk_gesture_handle_event (GtkEventController *controller,
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (_gtk_gesture_update_point (gesture, event, FALSE) &&
|
||||
if (_gtk_gesture_update_point (gesture, event, x, y, FALSE) &&
|
||||
_gtk_gesture_check_recognized (gesture, sequence))
|
||||
g_signal_emit (gesture, signals[UPDATE], 0, sequence);
|
||||
}
|
||||
|
||||
@@ -307,13 +307,14 @@ gtk_gesture_click_reset (GtkEventController *controller)
|
||||
|
||||
static gboolean
|
||||
gtk_gesture_click_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkEventControllerClass *parent_controller;
|
||||
GtkGestureClickPrivate *priv;
|
||||
GdkEventSequence *sequence;
|
||||
guint button;
|
||||
gdouble x, y;
|
||||
|
||||
priv = gtk_gesture_click_get_instance_private (GTK_GESTURE_CLICK (controller));
|
||||
parent_controller = GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_click_parent_class);
|
||||
@@ -326,12 +327,11 @@ gtk_gesture_click_handle_event (GtkEventController *controller,
|
||||
{
|
||||
if (!gdk_event_get_button (event, &button))
|
||||
button = 0;
|
||||
gdk_event_get_coords (event, &x, &y);
|
||||
g_signal_emit (controller, signals[UNPAIRED_RELEASE], 0,
|
||||
x, y, button, sequence);
|
||||
}
|
||||
|
||||
return parent_controller->handle_event (controller, event);
|
||||
return parent_controller->handle_event (controller, event, x, y);
|
||||
}
|
||||
|
||||
static void
|
||||
|
||||
@@ -192,7 +192,9 @@ gtk_gesture_rotate_filter_event (GtkEventController *controller,
|
||||
|
||||
static gboolean
|
||||
gtk_gesture_rotate_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkGestureRotate *rotate = GTK_GESTURE_ROTATE (controller);
|
||||
GtkGestureRotatePrivate *priv;
|
||||
@@ -213,7 +215,7 @@ gtk_gesture_rotate_handle_event (GtkEventController *controller,
|
||||
priv->accum_touchpad_angle += delta;
|
||||
}
|
||||
|
||||
return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_rotate_parent_class)->handle_event (controller, event);
|
||||
return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_rotate_parent_class)->handle_event (controller, event, x, y);
|
||||
}
|
||||
|
||||
static void
|
||||
|
||||
@@ -131,7 +131,9 @@ gtk_gesture_single_cancel (GtkGesture *gesture,
|
||||
|
||||
static gboolean
|
||||
gtk_gesture_single_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GdkEventSequence *sequence = NULL;
|
||||
GtkGestureSinglePrivate *priv;
|
||||
@@ -201,8 +203,7 @@ gtk_gesture_single_handle_event (GtkEventController *controller,
|
||||
case GDK_TOUCH_CANCEL:
|
||||
case GDK_GRAB_BROKEN:
|
||||
case GDK_TOUCHPAD_SWIPE:
|
||||
return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_single_parent_class)->handle_event (controller,
|
||||
event);
|
||||
return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_single_parent_class)->handle_event (controller, event, x, y);
|
||||
break;
|
||||
default:
|
||||
return FALSE;
|
||||
@@ -226,7 +227,7 @@ gtk_gesture_single_handle_event (GtkEventController *controller,
|
||||
priv->current_button = button;
|
||||
}
|
||||
|
||||
retval = GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_single_parent_class)->handle_event (controller, event);
|
||||
retval = GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_single_parent_class)->handle_event (controller, event, x, y);
|
||||
|
||||
if (sequence == priv->current_sequence &&
|
||||
(event_type == GDK_BUTTON_RELEASE || event_type == GDK_TOUCH_END))
|
||||
|
||||
@@ -49,18 +49,17 @@ static guint signals[N_SIGNALS] = { 0, };
|
||||
|
||||
static gboolean
|
||||
gtk_gesture_stylus_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GdkModifierType modifiers;
|
||||
guint n_signal;
|
||||
gdouble x, y;
|
||||
|
||||
GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_stylus_parent_class)->handle_event (controller, event);
|
||||
GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_stylus_parent_class)->handle_event (controller, event, x, y);
|
||||
|
||||
if (!gdk_event_get_device_tool (event))
|
||||
return FALSE;
|
||||
if (!gdk_event_get_coords (event, &x, &y))
|
||||
return FALSE;
|
||||
|
||||
switch ((guint) gdk_event_get_event_type (event))
|
||||
{
|
||||
|
||||
+57
-32
@@ -122,6 +122,13 @@ static void gtk_im_context_simple_get_preedit_string (GtkIMContext
|
||||
gint *cursor_pos);
|
||||
static void gtk_im_context_simple_set_client_widget (GtkIMContext *context,
|
||||
GtkWidget *widget);
|
||||
static gboolean gtk_im_context_simple_filter_key (GtkIMContext *context,
|
||||
GdkSurface *surface,
|
||||
guint keyval,
|
||||
GdkModifierType state,
|
||||
int scancode,
|
||||
gboolean press);
|
||||
|
||||
|
||||
G_DEFINE_TYPE_WITH_CODE (GtkIMContextSimple, gtk_im_context_simple, GTK_TYPE_IM_CONTEXT,
|
||||
G_ADD_PRIVATE (GtkIMContextSimple)
|
||||
@@ -893,7 +900,10 @@ beep_surface (GdkSurface *surface)
|
||||
static gboolean
|
||||
no_sequence_matches (GtkIMContextSimple *context_simple,
|
||||
gint n_compose,
|
||||
GdkEventKey *event)
|
||||
GdkSurface *surface,
|
||||
guint event_keyval,
|
||||
GdkModifierType state,
|
||||
int scancode)
|
||||
{
|
||||
GtkIMContextSimplePrivate *priv = context_simple->priv;
|
||||
GtkIMContext *context;
|
||||
@@ -913,27 +923,24 @@ no_sequence_matches (GtkIMContextSimple *context_simple,
|
||||
gtk_im_context_simple_commit_char (context, priv->tentative_match);
|
||||
priv->compose_buffer[0] = 0;
|
||||
|
||||
for (i=0; i < n_compose - len - 1; i++)
|
||||
for (i = 0; i < n_compose - len - 1; i++)
|
||||
{
|
||||
GdkEvent *tmp_event = gdk_event_copy ((GdkEvent *)event);
|
||||
gdk_event_set_keyval (tmp_event, priv->compose_buffer[len + i]);
|
||||
|
||||
gtk_im_context_filter_keypress (context, (GdkEventKey *)tmp_event);
|
||||
g_object_unref (tmp_event);
|
||||
keyval = priv->compose_buffer[len + i];
|
||||
gtk_im_context_simple_filter_key (context, surface, keyval, state, 0, TRUE);
|
||||
}
|
||||
|
||||
return gtk_im_context_filter_keypress (context, event);
|
||||
return gtk_im_context_simple_filter_key (context, surface, event_keyval, state, scancode, TRUE);
|
||||
}
|
||||
else if (gdk_event_get_keyval ((GdkEvent *) event, &keyval))
|
||||
else if (event_keyval)
|
||||
{
|
||||
priv->compose_buffer[0] = 0;
|
||||
if (n_compose > 1) /* Invalid sequence */
|
||||
if (n_compose > 1) /* Invalid sequence */
|
||||
{
|
||||
beep_surface (gdk_event_get_surface ((GdkEvent *) event));
|
||||
beep_surface (surface);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
ch = gdk_keyval_to_unicode (keyval);
|
||||
ch = gdk_keyval_to_unicode (event_keyval);
|
||||
if (ch != 0 && !g_unichar_iscntrl (ch))
|
||||
{
|
||||
gtk_im_context_simple_commit_char (context, ch);
|
||||
@@ -955,18 +962,16 @@ is_hex_keyval (guint keyval)
|
||||
}
|
||||
|
||||
static guint
|
||||
canonical_hex_keyval (GdkEventKey *event)
|
||||
canonical_hex_keyval (GdkSurface *surface,
|
||||
guint event_keyval,
|
||||
guint event_scancode)
|
||||
{
|
||||
GdkSurface *surface = gdk_event_get_surface ((GdkEvent *) event);
|
||||
GdkKeymap *keymap = gdk_display_get_keymap (gdk_surface_get_display (surface));
|
||||
guint keyval, event_keyval;
|
||||
guint keyval;
|
||||
guint *keyvals = NULL;
|
||||
gint n_vals = 0;
|
||||
gint i;
|
||||
|
||||
if (!gdk_event_get_keyval ((GdkEvent *) event, &event_keyval))
|
||||
return 0;
|
||||
|
||||
/* See if the keyval is already a hex digit */
|
||||
if (is_hex_keyval (event_keyval))
|
||||
return event_keyval;
|
||||
@@ -975,7 +980,7 @@ canonical_hex_keyval (GdkEventKey *event)
|
||||
* any other state, and return that hex keyval if so
|
||||
*/
|
||||
gdk_keymap_get_entries_for_keycode (keymap,
|
||||
gdk_event_get_scancode ((GdkEvent *) event),
|
||||
event_scancode,
|
||||
NULL,
|
||||
&keyvals, &n_vals);
|
||||
|
||||
@@ -1003,14 +1008,16 @@ canonical_hex_keyval (GdkEventKey *event)
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gtk_im_context_simple_filter_keypress (GtkIMContext *context,
|
||||
GdkEventKey *event)
|
||||
gtk_im_context_simple_filter_key (GtkIMContext *context,
|
||||
GdkSurface *surface,
|
||||
guint keyval,
|
||||
GdkModifierType state,
|
||||
int scancode,
|
||||
gboolean press)
|
||||
{
|
||||
GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
|
||||
GtkIMContextSimplePrivate *priv = context_simple->priv;
|
||||
GdkSurface *surface = gdk_event_get_surface ((GdkEvent *) event);
|
||||
GdkDisplay *display = gdk_surface_get_display (surface);
|
||||
GdkKeymap *keymap = gdk_display_get_keymap (display);
|
||||
GdkKeymap *keymap = gdk_display_get_keymap (gdk_surface_get_display (surface));
|
||||
GSList *tmp_list;
|
||||
int n_compose = 0;
|
||||
GdkModifierType hex_mod_mask;
|
||||
@@ -1024,16 +1031,11 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
|
||||
gboolean compose_finish;
|
||||
gboolean compose_match;
|
||||
gunichar output_char;
|
||||
guint keyval, state;
|
||||
|
||||
while (priv->compose_buffer[n_compose] != 0)
|
||||
n_compose++;
|
||||
|
||||
if (!gdk_event_get_keyval ((GdkEvent *) event, &keyval) ||
|
||||
!gdk_event_get_state ((GdkEvent *) event, &state))
|
||||
return GDK_EVENT_PROPAGATE;
|
||||
|
||||
if (gdk_event_get_event_type ((GdkEvent *) event) == GDK_KEY_RELEASE)
|
||||
if (!press)
|
||||
{
|
||||
if (priv->in_hex_sequence &&
|
||||
(keyval == GDK_KEY_Control_L || keyval == GDK_KEY_Control_R ||
|
||||
@@ -1092,7 +1094,7 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
|
||||
keyval == GDK_KEY_KP_Enter);
|
||||
is_backspace = keyval == GDK_KEY_BackSpace;
|
||||
is_escape = keyval == GDK_KEY_Escape;
|
||||
hex_keyval = canonical_hex_keyval (event);
|
||||
hex_keyval = canonical_hex_keyval (surface, keyval, scancode);
|
||||
|
||||
/* If we are already in a non-hex sequence, or
|
||||
* this keystroke is not hex modifiers + hex digit, don't filter
|
||||
@@ -1345,7 +1347,30 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
|
||||
}
|
||||
|
||||
/* The current compose_buffer doesn't match anything */
|
||||
return no_sequence_matches (context_simple, n_compose, event);
|
||||
return no_sequence_matches (context_simple, n_compose, surface, keyval, state, scancode);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
gtk_im_context_simple_filter_keypress (GtkIMContext *context,
|
||||
GdkEventKey *event)
|
||||
{
|
||||
GdkSurface *surface;
|
||||
guint keyval;
|
||||
int scancode;
|
||||
GdkModifierType state;
|
||||
gboolean press;
|
||||
|
||||
surface = gdk_event_get_surface ((GdkEvent *) event);
|
||||
|
||||
if (!gdk_event_get_keyval ((GdkEvent *) event, &keyval) ||
|
||||
!gdk_event_get_state ((GdkEvent *) event, &state))
|
||||
return GDK_EVENT_PROPAGATE;
|
||||
|
||||
scancode = gdk_event_get_scancode ((GdkEvent *) event);
|
||||
|
||||
press = gdk_event_get_event_type ((GdkEvent *) event) == GDK_KEY_PRESS;
|
||||
|
||||
return gtk_im_context_simple_filter_key (context, surface, keyval, state, scancode, press);
|
||||
}
|
||||
|
||||
static void
|
||||
|
||||
+62
-69
@@ -1248,6 +1248,52 @@ check_event_in_child_popover (GtkWidget *event_widget,
|
||||
return (popover_parent == grab_widget || gtk_widget_is_ancestor (popover_parent, grab_widget));
|
||||
}
|
||||
|
||||
static void
|
||||
synthesize_pointer_change_events (GtkWindow *toplevel,
|
||||
GtkWidget *old_target,
|
||||
GtkWidget *new_target)
|
||||
{
|
||||
GtkCrossingData crossing;
|
||||
GtkWidget *widget;
|
||||
GList *list, *l;
|
||||
GtkStateFlags flags;
|
||||
|
||||
flags = GTK_STATE_FLAG_PRELIGHT;
|
||||
|
||||
crossing.type = GTK_CROSSING_POINTER;
|
||||
crossing.old_target = old_target;
|
||||
crossing.new_target = new_target;
|
||||
|
||||
crossing.direction = GTK_CROSSING_OUT;
|
||||
|
||||
widget = old_target;
|
||||
while (widget)
|
||||
{
|
||||
gtk_widget_handle_crossing (widget, &crossing, 0, 0);
|
||||
gtk_widget_unset_state_flags (widget, flags);
|
||||
widget = gtk_widget_get_parent (widget);
|
||||
}
|
||||
|
||||
list = NULL;
|
||||
widget = new_target;
|
||||
while (widget)
|
||||
{
|
||||
list = g_list_prepend (list, widget);
|
||||
widget = gtk_widget_get_parent (widget);
|
||||
}
|
||||
|
||||
crossing.direction = GTK_CROSSING_IN;
|
||||
|
||||
for (l = list; l; l = l->next)
|
||||
{
|
||||
widget = l->data;
|
||||
gtk_widget_handle_crossing (widget, &crossing, 0, 0);
|
||||
gtk_widget_set_state_flags (widget, flags, FALSE);
|
||||
}
|
||||
|
||||
g_list_free (list);
|
||||
}
|
||||
|
||||
static GdkNotifyType
|
||||
get_virtual_notify_type (GdkNotifyType notify_type)
|
||||
{
|
||||
@@ -1314,76 +1360,26 @@ synth_crossing (GtkWidget *widget,
|
||||
GdkCrossingMode crossing_mode)
|
||||
{
|
||||
GdkEvent *event;
|
||||
GtkStateFlags flags;
|
||||
|
||||
if (gdk_event_get_event_type (source) == GDK_FOCUS_CHANGE)
|
||||
{
|
||||
event = gdk_event_new (GDK_FOCUS_CHANGE);
|
||||
event->focus_change.in = enter;
|
||||
event->focus_change.mode = crossing_mode;
|
||||
event->focus_change.detail = notify_type;
|
||||
|
||||
flags = GTK_STATE_FLAG_FOCUSED;
|
||||
if (!GTK_IS_WINDOW (toplevel) || gtk_window_get_focus_visible (GTK_WINDOW (toplevel)))
|
||||
flags |= GTK_STATE_FLAG_FOCUS_VISIBLE;
|
||||
}
|
||||
else
|
||||
{
|
||||
gdouble x, y;
|
||||
event = gdk_event_new (enter ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY);
|
||||
if (related_target)
|
||||
{
|
||||
GdkSurface *surface;
|
||||
|
||||
surface = gtk_native_get_surface (gtk_widget_get_native (related_target));
|
||||
event->crossing.child_surface = g_object_ref (surface);
|
||||
}
|
||||
gdk_event_get_coords (source, &x, &y);
|
||||
event->crossing.x = x;
|
||||
event->crossing.y = y;
|
||||
event->crossing.mode = crossing_mode;
|
||||
event->crossing.detail = notify_type;
|
||||
|
||||
flags = GTK_STATE_FLAG_PRELIGHT;
|
||||
}
|
||||
gdouble x, y;
|
||||
|
||||
gdk_event_get_coords (source, &x, &y);
|
||||
event = gdk_event_crossing_new (enter ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY,
|
||||
gtk_native_get_surface (gtk_widget_get_native (toplevel)),
|
||||
source->any.device,
|
||||
source->any.source_device,
|
||||
GDK_CURRENT_TIME,
|
||||
0,
|
||||
x, y,
|
||||
crossing_mode,
|
||||
notify_type);
|
||||
gdk_event_set_target (event, G_OBJECT (target));
|
||||
gdk_event_set_related_target (event, G_OBJECT (related_target));
|
||||
gdk_event_set_device (event, gdk_event_get_device (source));
|
||||
gdk_event_set_source_device (event, gdk_event_get_source_device (source));
|
||||
|
||||
event->any.surface = gtk_native_get_surface (gtk_widget_get_native (toplevel));
|
||||
if (event->any.surface)
|
||||
g_object_ref (event->any.surface);
|
||||
|
||||
if (is_or_contains (enter, notify_type))
|
||||
gtk_widget_set_state_flags (widget, flags, FALSE);
|
||||
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_PRELIGHT, FALSE);
|
||||
else
|
||||
gtk_widget_unset_state_flags (widget, flags);
|
||||
gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_PRELIGHT);
|
||||
|
||||
if (gdk_event_get_event_type (source) == GDK_FOCUS_CHANGE)
|
||||
{
|
||||
/* maintain focus chain */
|
||||
if (enter || notify_type == GDK_NOTIFY_INFERIOR)
|
||||
{
|
||||
GtkWidget *parent = gtk_widget_get_parent (widget);
|
||||
if (parent)
|
||||
gtk_widget_set_focus_child (parent, widget);
|
||||
}
|
||||
else if (!enter && notify_type != GDK_NOTIFY_INFERIOR)
|
||||
{
|
||||
GtkWidget *parent = gtk_widget_get_parent (widget);
|
||||
if (parent)
|
||||
gtk_widget_set_focus_child (parent, NULL);
|
||||
}
|
||||
|
||||
/* maintain widget state */
|
||||
if (notify_type == GDK_NOTIFY_ANCESTOR ||
|
||||
notify_type == GDK_NOTIFY_INFERIOR ||
|
||||
notify_type == GDK_NOTIFY_NONLINEAR)
|
||||
gtk_widget_set_has_focus (widget, enter);
|
||||
}
|
||||
|
||||
gtk_widget_event (widget, event);
|
||||
g_object_unref (event);
|
||||
}
|
||||
@@ -1605,8 +1601,7 @@ handle_pointing_event (GdkEvent *event)
|
||||
old_target = update_pointer_focus_state (toplevel, event, NULL);
|
||||
|
||||
if (event->any.type == GDK_LEAVE_NOTIFY)
|
||||
gtk_synthesize_crossing_events (GTK_ROOT (toplevel), old_target, NULL,
|
||||
event, event->crossing.mode);
|
||||
synthesize_pointer_change_events (toplevel, old_target, NULL);
|
||||
break;
|
||||
case GDK_ENTER_NOTIFY:
|
||||
if (event->crossing.mode == GDK_CROSSING_GRAB ||
|
||||
@@ -1631,8 +1626,7 @@ handle_pointing_event (GdkEvent *event)
|
||||
if (!gtk_window_lookup_pointer_focus_implicit_grab (toplevel, device,
|
||||
sequence))
|
||||
{
|
||||
gtk_synthesize_crossing_events (GTK_ROOT (toplevel), old_target, target,
|
||||
event, GDK_CROSSING_NORMAL);
|
||||
synthesize_pointer_change_events (toplevel, old_target, target);
|
||||
}
|
||||
|
||||
gtk_window_maybe_update_cursor (toplevel, NULL, device);
|
||||
@@ -1661,8 +1655,7 @@ handle_pointing_event (GdkEvent *event)
|
||||
new_target = gtk_widget_pick (GTK_WIDGET (native), x, y, GTK_PICK_DEFAULT);
|
||||
if (new_target == NULL)
|
||||
new_target = GTK_WIDGET (toplevel);
|
||||
gtk_synthesize_crossing_events (GTK_ROOT (toplevel), target, new_target, event,
|
||||
GDK_CROSSING_UNGRAB);
|
||||
synthesize_pointer_change_events (toplevel, target, new_target);
|
||||
gtk_window_maybe_update_cursor (toplevel, NULL, device);
|
||||
}
|
||||
|
||||
|
||||
+11
-9
@@ -1352,19 +1352,21 @@ leave_cb (GtkEventController *controller,
|
||||
}
|
||||
|
||||
static void
|
||||
focus_in_cb (GtkEventController *controller,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType type,
|
||||
gpointer data)
|
||||
focus_change_cb (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
gpointer data)
|
||||
{
|
||||
GtkWidget *target;
|
||||
GtkWidget *popover;
|
||||
|
||||
target = gtk_event_controller_get_widget (controller);
|
||||
popover = gtk_widget_get_ancestor (target, GTK_TYPE_POPOVER_MENU);
|
||||
if (crossing->direction == GTK_CROSSING_IN)
|
||||
{
|
||||
target = gtk_event_controller_get_widget (controller);
|
||||
popover = gtk_widget_get_ancestor (target, GTK_TYPE_POPOVER_MENU);
|
||||
|
||||
if (popover)
|
||||
gtk_popover_menu_set_active_item (GTK_POPOVER_MENU (popover), target);
|
||||
if (popover)
|
||||
gtk_popover_menu_set_active_item (GTK_POPOVER_MENU (popover), target);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -1393,7 +1395,7 @@ gtk_model_button_init (GtkModelButton *self)
|
||||
gtk_widget_add_controller (GTK_WIDGET (self), controller);
|
||||
|
||||
controller = gtk_event_controller_key_new ();
|
||||
g_signal_connect (controller, "focus-in", G_CALLBACK (focus_in_cb), NULL);
|
||||
g_signal_connect (controller, "focus-change", G_CALLBACK (focus_change_cb), NULL);
|
||||
gtk_widget_add_controller (GTK_WIDGET (self), controller);
|
||||
|
||||
gesture = gtk_gesture_click_new ();
|
||||
|
||||
@@ -229,7 +229,9 @@ gtk_pad_controller_filter_event (GtkEventController *controller,
|
||||
|
||||
static gboolean
|
||||
gtk_pad_controller_handle_event (GtkEventController *controller,
|
||||
const GdkEvent *event)
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkPadController *pad_controller = GTK_PAD_CONTROLLER (controller);
|
||||
GdkEventType event_type = gdk_event_get_event_type (event);
|
||||
|
||||
@@ -383,17 +383,6 @@ gtk_popover_native_check_resize (GtkNative *native)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
gtk_popover_focus_in (GtkWidget *widget)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_popover_focus_out (GtkWidget *widget)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
close_menu (GtkPopover *popover)
|
||||
{
|
||||
@@ -569,8 +558,6 @@ gtk_popover_init (GtkPopover *popover)
|
||||
priv->has_arrow = TRUE;
|
||||
|
||||
controller = gtk_event_controller_key_new ();
|
||||
g_signal_connect_swapped (controller, "focus-in", G_CALLBACK (gtk_popover_focus_in), popover);
|
||||
g_signal_connect_swapped (controller, "focus-out", G_CALLBACK (gtk_popover_focus_out), popover);
|
||||
g_signal_connect_swapped (controller, "key-pressed", G_CALLBACK (gtk_popover_key_pressed), popover);
|
||||
gtk_widget_add_controller (GTK_WIDGET (popover), controller);
|
||||
|
||||
|
||||
@@ -168,14 +168,14 @@ visible_submenu_changed (GObject *object,
|
||||
}
|
||||
|
||||
static void
|
||||
focus_out (GtkEventControllerKey *controller,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType detail,
|
||||
GtkPopoverMenu *menu)
|
||||
focus_change (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
GtkPopoverMenu *menu)
|
||||
{
|
||||
GtkWidget *new_focus = gtk_root_get_focus (gtk_widget_get_root (GTK_WIDGET (menu)));
|
||||
|
||||
if (!gtk_event_controller_key_contains_focus (controller) &&
|
||||
if (crossing->direction == GTK_CROSSING_OUT &&
|
||||
!gtk_event_controller_key_contains_focus (GTK_EVENT_CONTROLLER_KEY (controller)) &&
|
||||
new_focus != NULL)
|
||||
{
|
||||
if (menu->parent_menu &&
|
||||
@@ -216,7 +216,7 @@ gtk_popover_menu_init (GtkPopoverMenu *popover)
|
||||
gtk_widget_add_css_class (GTK_WIDGET (popover), "menu");
|
||||
|
||||
controller = gtk_event_controller_key_new ();
|
||||
g_signal_connect (controller, "focus-out", G_CALLBACK (focus_out), popover);
|
||||
g_signal_connect (controller, "focus-change", G_CALLBACK (focus_change), popover);
|
||||
gtk_widget_add_controller (GTK_WIDGET (popover), controller);
|
||||
|
||||
controller = gtk_event_controller_motion_new ();
|
||||
|
||||
+7
-7
@@ -920,14 +920,14 @@ key_controller_key_released (GtkEventControllerKey *key,
|
||||
}
|
||||
|
||||
static void
|
||||
key_controller_focus_out (GtkEventControllerKey *key,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType detail,
|
||||
GtkSpinButton *spin_button)
|
||||
key_controller_focus_change (GtkEventController *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
GtkSpinButton *spin_button)
|
||||
{
|
||||
GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
|
||||
|
||||
if (gtk_editable_get_editable (GTK_EDITABLE (priv->entry)))
|
||||
if (crossing->direction == GTK_CROSSING_OUT &&
|
||||
gtk_editable_get_editable (GTK_EDITABLE (priv->entry)))
|
||||
gtk_spin_button_update (spin_button);
|
||||
}
|
||||
|
||||
@@ -1015,8 +1015,8 @@ gtk_spin_button_init (GtkSpinButton *spin_button)
|
||||
controller = gtk_event_controller_key_new ();
|
||||
g_signal_connect (controller, "key-released",
|
||||
G_CALLBACK (key_controller_key_released), spin_button);
|
||||
g_signal_connect (controller, "focus-out",
|
||||
G_CALLBACK (key_controller_focus_out), spin_button);
|
||||
g_signal_connect (controller, "focus-change",
|
||||
G_CALLBACK (key_controller_focus_change), spin_button);
|
||||
gtk_widget_add_controller (GTK_WIDGET (spin_button), controller);
|
||||
}
|
||||
|
||||
|
||||
+42
-46
@@ -323,8 +323,8 @@ static void gtk_text_size_allocate (GtkWidget *widget,
|
||||
int baseline);
|
||||
static void gtk_text_snapshot (GtkWidget *widget,
|
||||
GtkSnapshot *snapshot);
|
||||
static void gtk_text_focus_in (GtkWidget *widget);
|
||||
static void gtk_text_focus_out (GtkWidget *widget);
|
||||
static void gtk_text_focus_change (GtkWidget *widget,
|
||||
const GtkCrossingData *crossing);
|
||||
static gboolean gtk_text_grab_focus (GtkWidget *widget);
|
||||
static void gtk_text_css_changed (GtkWidget *widget,
|
||||
GtkCssStyleChange *change);
|
||||
@@ -1783,10 +1783,8 @@ gtk_text_init (GtkText *self)
|
||||
G_CALLBACK (gtk_text_key_controller_key_pressed), self);
|
||||
g_signal_connect_swapped (priv->key_controller, "im-update",
|
||||
G_CALLBACK (gtk_text_schedule_im_reset), self);
|
||||
g_signal_connect_swapped (priv->key_controller, "focus-in",
|
||||
G_CALLBACK (gtk_text_focus_in), self);
|
||||
g_signal_connect_swapped (priv->key_controller, "focus-out",
|
||||
G_CALLBACK (gtk_text_focus_out), self);
|
||||
g_signal_connect_swapped (priv->key_controller, "focus-change",
|
||||
G_CALLBACK (gtk_text_focus_change), self);
|
||||
gtk_event_controller_key_set_im_context (GTK_EVENT_CONTROLLER_KEY (priv->key_controller),
|
||||
priv->im_context);
|
||||
gtk_widget_add_controller (GTK_WIDGET (self), priv->key_controller);
|
||||
@@ -3054,55 +3052,53 @@ gtk_text_key_controller_key_pressed (GtkEventControllerKey *controller,
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_text_focus_in (GtkWidget *widget)
|
||||
gtk_text_focus_change (GtkWidget *widget,
|
||||
const GtkCrossingData *crossing)
|
||||
{
|
||||
GtkText *self = GTK_TEXT (widget);
|
||||
GtkTextPrivate *priv = gtk_text_get_instance_private (self);
|
||||
GdkKeymap *keymap;
|
||||
|
||||
gtk_widget_queue_draw (widget);
|
||||
|
||||
keymap = gdk_display_get_keymap (gtk_widget_get_display (widget));
|
||||
|
||||
if (priv->editable)
|
||||
if (crossing->direction == GTK_CROSSING_IN)
|
||||
{
|
||||
gtk_text_schedule_im_reset (self);
|
||||
gtk_im_context_focus_in (priv->im_context);
|
||||
gtk_widget_queue_draw (widget);
|
||||
|
||||
keymap = gdk_display_get_keymap (gtk_widget_get_display (widget));
|
||||
|
||||
if (priv->editable)
|
||||
{
|
||||
gtk_text_schedule_im_reset (self);
|
||||
gtk_im_context_focus_in (priv->im_context);
|
||||
}
|
||||
|
||||
g_signal_connect (keymap, "direction-changed",
|
||||
G_CALLBACK (keymap_direction_changed), self);
|
||||
|
||||
gtk_text_reset_blink_time (self);
|
||||
gtk_text_check_cursor_blink (self);
|
||||
}
|
||||
|
||||
g_signal_connect (keymap, "direction-changed",
|
||||
G_CALLBACK (keymap_direction_changed), self);
|
||||
|
||||
gtk_text_reset_blink_time (self);
|
||||
gtk_text_check_cursor_blink (self);
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_text_focus_out (GtkWidget *widget)
|
||||
{
|
||||
GtkText *self = GTK_TEXT (widget);
|
||||
GtkTextPrivate *priv = gtk_text_get_instance_private (self);
|
||||
GdkKeymap *keymap;
|
||||
|
||||
gtk_text_selection_bubble_popup_unset (self);
|
||||
|
||||
if (priv->text_handle)
|
||||
_gtk_text_handle_set_mode (priv->text_handle,
|
||||
GTK_TEXT_HANDLE_MODE_NONE);
|
||||
|
||||
gtk_widget_queue_draw (widget);
|
||||
|
||||
keymap = gdk_display_get_keymap (gtk_widget_get_display (widget));
|
||||
|
||||
if (priv->editable)
|
||||
else
|
||||
{
|
||||
gtk_text_schedule_im_reset (self);
|
||||
gtk_im_context_focus_out (priv->im_context);
|
||||
gtk_text_selection_bubble_popup_unset (self);
|
||||
|
||||
if (priv->text_handle)
|
||||
_gtk_text_handle_set_mode (priv->text_handle,
|
||||
GTK_TEXT_HANDLE_MODE_NONE);
|
||||
|
||||
gtk_widget_queue_draw (widget);
|
||||
|
||||
keymap = gdk_display_get_keymap (gtk_widget_get_display (widget));
|
||||
|
||||
if (priv->editable)
|
||||
{
|
||||
gtk_text_schedule_im_reset (self);
|
||||
gtk_im_context_focus_out (priv->im_context);
|
||||
}
|
||||
|
||||
gtk_text_check_cursor_blink (self);
|
||||
|
||||
g_signal_handlers_disconnect_by_func (keymap, keymap_direction_changed, self);
|
||||
}
|
||||
|
||||
gtk_text_check_cursor_blink (self);
|
||||
|
||||
g_signal_handlers_disconnect_by_func (keymap, keymap_direction_changed, self);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
|
||||
+53
-63
@@ -404,8 +404,8 @@ static gboolean gtk_text_view_key_controller_key_pressed (GtkEventControllerKey
|
||||
static void gtk_text_view_key_controller_im_update (GtkEventControllerKey *controller,
|
||||
GtkTextView *text_view);
|
||||
|
||||
static void gtk_text_view_focus_in (GtkWidget *widget);
|
||||
static void gtk_text_view_focus_out (GtkWidget *widget);
|
||||
static void gtk_text_view_focus_change (GtkWidget *widget,
|
||||
const GtkCrossingData *crossing);
|
||||
static void gtk_text_view_motion (GtkEventController *controller,
|
||||
double x,
|
||||
double y,
|
||||
@@ -1698,11 +1698,8 @@ gtk_text_view_init (GtkTextView *text_view)
|
||||
g_signal_connect (priv->key_controller, "im-update",
|
||||
G_CALLBACK (gtk_text_view_key_controller_im_update),
|
||||
widget);
|
||||
g_signal_connect_swapped (priv->key_controller, "focus-in",
|
||||
G_CALLBACK (gtk_text_view_focus_in),
|
||||
widget);
|
||||
g_signal_connect_swapped (priv->key_controller, "focus-out",
|
||||
G_CALLBACK (gtk_text_view_focus_out),
|
||||
g_signal_connect_swapped (priv->key_controller, "focus-change",
|
||||
G_CALLBACK (gtk_text_view_focus_change),
|
||||
widget);
|
||||
gtk_event_controller_key_set_im_context (GTK_EVENT_CONTROLLER_KEY (priv->key_controller),
|
||||
priv->im_context);
|
||||
@@ -5321,72 +5318,65 @@ keymap_direction_changed (GdkKeymap *keymap,
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_text_view_focus_in (GtkWidget *widget)
|
||||
gtk_text_view_focus_change (GtkWidget *widget,
|
||||
const GtkCrossingData *crossing)
|
||||
{
|
||||
GtkTextView *text_view;
|
||||
GtkTextViewPrivate *priv;
|
||||
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
|
||||
GtkTextViewPrivate *priv = text_view->priv;
|
||||
|
||||
text_view = GTK_TEXT_VIEW (widget);
|
||||
priv = text_view->priv;
|
||||
|
||||
gtk_widget_queue_draw (widget);
|
||||
|
||||
DV(g_print (G_STRLOC": focus_in\n"));
|
||||
|
||||
gtk_text_view_reset_blink_time (text_view);
|
||||
|
||||
if (cursor_visible (text_view) && priv->layout)
|
||||
if (crossing->direction == GTK_CROSSING_IN)
|
||||
{
|
||||
gtk_text_layout_set_cursor_visible (priv->layout, TRUE);
|
||||
gtk_text_view_check_cursor_blink (text_view);
|
||||
gtk_widget_queue_draw (widget);
|
||||
|
||||
DV(g_print (G_STRLOC": focus_in\n"));
|
||||
|
||||
gtk_text_view_reset_blink_time (text_view);
|
||||
|
||||
if (cursor_visible (text_view) && priv->layout)
|
||||
{
|
||||
gtk_text_layout_set_cursor_visible (priv->layout, TRUE);
|
||||
gtk_text_view_check_cursor_blink (text_view);
|
||||
}
|
||||
|
||||
g_signal_connect (gdk_display_get_keymap (gtk_widget_get_display (widget)),
|
||||
"direction-changed",
|
||||
G_CALLBACK (keymap_direction_changed), text_view);
|
||||
gtk_text_view_check_keymap_direction (text_view);
|
||||
|
||||
if (priv->editable)
|
||||
{
|
||||
priv->need_im_reset = TRUE;
|
||||
gtk_im_context_focus_in (priv->im_context);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
gtk_text_view_end_selection_drag (text_view);
|
||||
|
||||
g_signal_connect (gdk_display_get_keymap (gtk_widget_get_display (widget)),
|
||||
"direction-changed",
|
||||
G_CALLBACK (keymap_direction_changed), text_view);
|
||||
gtk_text_view_check_keymap_direction (text_view);
|
||||
gtk_widget_queue_draw (widget);
|
||||
|
||||
if (priv->editable)
|
||||
{
|
||||
priv->need_im_reset = TRUE;
|
||||
gtk_im_context_focus_in (priv->im_context);
|
||||
}
|
||||
}
|
||||
DV(g_print (G_STRLOC": focus_out\n"));
|
||||
|
||||
static void
|
||||
gtk_text_view_focus_out (GtkWidget *widget)
|
||||
{
|
||||
GtkTextView *text_view;
|
||||
GtkTextViewPrivate *priv;
|
||||
if (cursor_visible (text_view) && priv->layout)
|
||||
{
|
||||
gtk_text_view_check_cursor_blink (text_view);
|
||||
gtk_text_layout_set_cursor_visible (priv->layout, FALSE);
|
||||
}
|
||||
|
||||
text_view = GTK_TEXT_VIEW (widget);
|
||||
priv = text_view->priv;
|
||||
g_signal_handlers_disconnect_by_func (gdk_display_get_keymap (gtk_widget_get_display (widget)),
|
||||
keymap_direction_changed,
|
||||
text_view);
|
||||
gtk_text_view_selection_bubble_popup_unset (text_view);
|
||||
|
||||
gtk_text_view_end_selection_drag (text_view);
|
||||
if (priv->text_handle)
|
||||
_gtk_text_handle_set_mode (priv->text_handle,
|
||||
GTK_TEXT_HANDLE_MODE_NONE);
|
||||
|
||||
gtk_widget_queue_draw (widget);
|
||||
|
||||
DV(g_print (G_STRLOC": focus_out\n"));
|
||||
|
||||
if (cursor_visible (text_view) && priv->layout)
|
||||
{
|
||||
gtk_text_view_check_cursor_blink (text_view);
|
||||
gtk_text_layout_set_cursor_visible (priv->layout, FALSE);
|
||||
}
|
||||
|
||||
g_signal_handlers_disconnect_by_func (gdk_display_get_keymap (gtk_widget_get_display (widget)),
|
||||
keymap_direction_changed,
|
||||
text_view);
|
||||
gtk_text_view_selection_bubble_popup_unset (text_view);
|
||||
|
||||
if (priv->text_handle)
|
||||
_gtk_text_handle_set_mode (priv->text_handle,
|
||||
GTK_TEXT_HANDLE_MODE_NONE);
|
||||
|
||||
if (priv->editable)
|
||||
{
|
||||
priv->need_im_reset = TRUE;
|
||||
gtk_im_context_focus_out (priv->im_context);
|
||||
if (priv->editable)
|
||||
{
|
||||
priv->need_im_reset = TRUE;
|
||||
gtk_im_context_focus_out (priv->im_context);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+16
-21
@@ -667,10 +667,9 @@ static void gtk_tree_view_key_controller_key_released (GtkEventControllerKey
|
||||
guint keycode,
|
||||
GdkModifierType state,
|
||||
GtkTreeView *tree_view);
|
||||
static void gtk_tree_view_key_controller_focus_out (GtkEventControllerKey *key,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType detail,
|
||||
GtkTreeView *tree_view);
|
||||
static void gtk_tree_view_key_controller_focus_change (GtkEventController *key,
|
||||
const GtkCrossingData *crossing,
|
||||
GtkTreeView *tree_view);
|
||||
|
||||
static gint gtk_tree_view_focus (GtkWidget *widget,
|
||||
GtkDirectionType direction);
|
||||
@@ -1839,8 +1838,8 @@ gtk_tree_view_init (GtkTreeView *tree_view)
|
||||
G_CALLBACK (gtk_tree_view_key_controller_key_pressed), tree_view);
|
||||
g_signal_connect (controller, "key-released",
|
||||
G_CALLBACK (gtk_tree_view_key_controller_key_released), tree_view);
|
||||
g_signal_connect (controller, "focus-out",
|
||||
G_CALLBACK (gtk_tree_view_key_controller_focus_out), tree_view);
|
||||
g_signal_connect (controller, "focus-change",
|
||||
G_CALLBACK (gtk_tree_view_key_controller_focus_change), tree_view);
|
||||
gtk_widget_add_controller (GTK_WIDGET (tree_view), controller);
|
||||
}
|
||||
|
||||
@@ -5546,23 +5545,19 @@ gtk_tree_view_motion_controller_leave (GtkEventControllerMotion *controller,
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_tree_view_key_controller_focus_out (GtkEventControllerKey *key,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType detail,
|
||||
GtkTreeView *tree_view)
|
||||
gtk_tree_view_key_controller_focus_change (GtkEventController *key,
|
||||
const GtkCrossingData *crossing,
|
||||
GtkTreeView *tree_view)
|
||||
{
|
||||
gboolean is_focus, contains_focus;
|
||||
if (crossing->direction == GTK_CROSSING_OUT)
|
||||
{
|
||||
gtk_widget_queue_draw (GTK_WIDGET (tree_view));
|
||||
|
||||
gtk_widget_queue_draw (GTK_WIDGET (tree_view));
|
||||
|
||||
g_object_get (key,
|
||||
"is-focus", &is_focus,
|
||||
"contains-focus", &contains_focus,
|
||||
NULL);
|
||||
|
||||
if (tree_view->search_popover && !gtk_event_controller_key_contains_focus (key))
|
||||
gtk_tree_view_search_popover_hide (tree_view->search_popover, tree_view,
|
||||
gtk_get_current_event_device ());
|
||||
if (tree_view->search_popover &&
|
||||
!gtk_event_controller_key_contains_focus (GTK_EVENT_CONTROLLER_KEY (key)))
|
||||
gtk_tree_view_search_popover_hide (tree_view->search_popover, tree_view,
|
||||
gtk_get_current_event_device ());
|
||||
}
|
||||
}
|
||||
|
||||
/* Incremental Reflow
|
||||
|
||||
@@ -830,12 +830,12 @@ gtk_tree_view_column_cell_layout_get_area (GtkCellLayout *cell_layout)
|
||||
}
|
||||
|
||||
static void
|
||||
focus_in (GtkEventControllerKey *controller,
|
||||
GdkCrossingMode mode,
|
||||
GdkNotifyType detail,
|
||||
GtkTreeViewColumn *column)
|
||||
focus_in (GtkEventControllerKey *controller,
|
||||
const GtkCrossingData *crossing,
|
||||
GtkTreeViewColumn *column)
|
||||
{
|
||||
_gtk_tree_view_set_focus_column (GTK_TREE_VIEW (column->priv->tree_view), column);
|
||||
if (crossing->direction == GTK_CROSSING_IN)
|
||||
_gtk_tree_view_set_focus_column (GTK_TREE_VIEW (column->priv->tree_view), column);
|
||||
}
|
||||
|
||||
/* Button handling code
|
||||
@@ -866,7 +866,7 @@ gtk_tree_view_column_create_button (GtkTreeViewColumn *tree_column)
|
||||
gtk_widget_add_controller (priv->button, controller);
|
||||
|
||||
controller = gtk_event_controller_key_new ();
|
||||
g_signal_connect (controller, "focus-in", G_CALLBACK (focus_in), tree_column);
|
||||
g_signal_connect (controller, "focus-change", G_CALLBACK (focus_in), tree_column);
|
||||
gtk_widget_add_controller (priv->button, controller);
|
||||
|
||||
priv->frame = gtk_frame_new (NULL);
|
||||
|
||||
+87
-64
@@ -2066,47 +2066,58 @@ _gtk_widget_emulate_press (GtkWidget *widget,
|
||||
event->any.type == GDK_TOUCH_UPDATE ||
|
||||
event->any.type == GDK_TOUCH_END)
|
||||
{
|
||||
press = gdk_event_copy (event);
|
||||
press->any.type = GDK_TOUCH_BEGIN;
|
||||
press = gdk_event_touch_new (GDK_TOUCH_BEGIN,
|
||||
event->any.surface,
|
||||
event->any.device,
|
||||
event->any.source_device,
|
||||
event->touch.time,
|
||||
event->touch.state,
|
||||
p.x, p.y,
|
||||
event->touch.emulating_pointer);
|
||||
}
|
||||
else if (event->any.type == GDK_BUTTON_PRESS ||
|
||||
event->any.type == GDK_BUTTON_RELEASE)
|
||||
{
|
||||
press = gdk_event_copy (event);
|
||||
press->any.type = GDK_BUTTON_PRESS;
|
||||
press = gdk_event_button_new (GDK_BUTTON_PRESS,
|
||||
event->any.surface,
|
||||
event->any.device,
|
||||
event->any.source_device,
|
||||
event->button.tool,
|
||||
event->button.time,
|
||||
p.x, p.y,
|
||||
event->button.button,
|
||||
event->button.state);
|
||||
}
|
||||
else if (event->any.type == GDK_MOTION_NOTIFY)
|
||||
{
|
||||
press = gdk_event_new (GDK_BUTTON_PRESS);
|
||||
press->any.surface = g_object_ref (event->any.surface);
|
||||
press->button.time = event->motion.time;
|
||||
press->button.state = event->motion.state;
|
||||
|
||||
press->button.axes = g_memdup (event->motion.axes,
|
||||
sizeof (gdouble) *
|
||||
gdk_device_get_n_axes (event->any.device));
|
||||
|
||||
int button;
|
||||
if (event->motion.state & GDK_BUTTON3_MASK)
|
||||
press->button.button = 3;
|
||||
button = 3;
|
||||
else if (event->motion.state & GDK_BUTTON2_MASK)
|
||||
press->button.button = 2;
|
||||
button = 2;
|
||||
else
|
||||
{
|
||||
if ((event->motion.state & GDK_BUTTON1_MASK) == 0)
|
||||
g_critical ("Guessing button number 1 on generated button press event");
|
||||
|
||||
press->button.button = 1;
|
||||
button = 1;
|
||||
}
|
||||
|
||||
gdk_event_set_device (press, gdk_event_get_device (event));
|
||||
gdk_event_set_source_device (press, gdk_event_get_source_device (event));
|
||||
press = gdk_event_button_new (GDK_BUTTON_PRESS,
|
||||
event->any.surface,
|
||||
event->any.device,
|
||||
event->any.source_device,
|
||||
NULL,
|
||||
event->motion.time,
|
||||
p.x, p.y,
|
||||
button,
|
||||
event->motion.state);
|
||||
}
|
||||
else
|
||||
return;
|
||||
|
||||
gdk_event_set_coords (press, p.x, p.y);
|
||||
|
||||
press->any.send_event = TRUE;
|
||||
next_child = event_widget;
|
||||
parent = _gtk_widget_get_parent (next_child);
|
||||
|
||||
@@ -4762,6 +4773,8 @@ gtk_widget_event (GtkWidget *widget,
|
||||
gboolean
|
||||
gtk_widget_run_controllers (GtkWidget *widget,
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y,
|
||||
GtkPropagationPhase phase)
|
||||
{
|
||||
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
|
||||
@@ -4797,7 +4810,7 @@ gtk_widget_run_controllers (GtkWidget *widget,
|
||||
gboolean is_gesture;
|
||||
|
||||
is_gesture = GTK_IS_GESTURE (controller);
|
||||
this_handled = gtk_event_controller_handle_event (controller, event);
|
||||
this_handled = gtk_event_controller_handle_event (controller, event, x, y);
|
||||
|
||||
handled |= this_handled;
|
||||
|
||||
@@ -4818,18 +4831,38 @@ gtk_widget_run_controllers (GtkWidget *widget,
|
||||
return handled;
|
||||
}
|
||||
|
||||
void
|
||||
gtk_widget_handle_crossing (GtkWidget *widget,
|
||||
const GtkCrossingData *crossing,
|
||||
double x,
|
||||
double y)
|
||||
{
|
||||
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
|
||||
GList *l;
|
||||
|
||||
g_object_ref (widget);
|
||||
|
||||
for (l = priv->event_controllers; l; l = l->next)
|
||||
{
|
||||
GtkEventController *controller = l->data;
|
||||
|
||||
gtk_event_controller_handle_crossing (controller, crossing, x, y);
|
||||
}
|
||||
|
||||
g_object_unref (widget);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
translate_event_coordinates (GdkEvent *event,
|
||||
double event_x,
|
||||
double event_y,
|
||||
double *x,
|
||||
double *y,
|
||||
GtkWidget *widget);
|
||||
gboolean
|
||||
_gtk_widget_captured_event (GtkWidget *widget,
|
||||
GdkEvent *event)
|
||||
{
|
||||
gboolean return_val = FALSE;
|
||||
double old_x, old_y;
|
||||
gboolean reset_event = FALSE;
|
||||
double x, y;
|
||||
|
||||
g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
|
||||
g_return_val_if_fail (WIDGET_REALIZED_FOR_EVENT (widget, event), TRUE);
|
||||
@@ -4837,18 +4870,12 @@ _gtk_widget_captured_event (GtkWidget *widget,
|
||||
if (!event_surface_is_still_viewable (event))
|
||||
return TRUE;
|
||||
|
||||
if (gdk_event_get_coords (event, &old_x, &old_y))
|
||||
{
|
||||
reset_event = TRUE;
|
||||
translate_event_coordinates (event, old_x, old_y, widget);
|
||||
}
|
||||
x = y = 0;
|
||||
translate_event_coordinates (event, &x, &y, widget);
|
||||
|
||||
return_val = gtk_widget_run_controllers (widget, event, GTK_PHASE_CAPTURE);
|
||||
return_val = gtk_widget_run_controllers (widget, event, x, y, GTK_PHASE_CAPTURE);
|
||||
return_val |= !WIDGET_REALIZED_FOR_EVENT (widget, event);
|
||||
|
||||
if (reset_event)
|
||||
gdk_event_set_coords (event, old_x, old_y);
|
||||
|
||||
return return_val;
|
||||
}
|
||||
|
||||
@@ -4891,12 +4918,18 @@ event_surface_is_still_viewable (const GdkEvent *event)
|
||||
|
||||
static gboolean
|
||||
translate_event_coordinates (GdkEvent *event,
|
||||
double event_x,
|
||||
double event_y,
|
||||
double *x,
|
||||
double *y,
|
||||
GtkWidget *widget)
|
||||
{
|
||||
GtkWidget *event_widget;
|
||||
graphene_point_t p;
|
||||
double event_x, event_y;
|
||||
|
||||
*x = *y = 0;
|
||||
|
||||
if (!gdk_event_get_coords (event, &event_x, &event_y))
|
||||
return FALSE;
|
||||
|
||||
event_widget = gtk_get_event_widget (event);
|
||||
|
||||
@@ -4906,7 +4939,8 @@ translate_event_coordinates (GdkEvent *event,
|
||||
&p))
|
||||
return FALSE;
|
||||
|
||||
gdk_event_set_coords (event, p.x, p.y);
|
||||
*x = p.x;
|
||||
*y = p.y;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
@@ -4916,8 +4950,7 @@ gtk_widget_event_internal (GtkWidget *widget,
|
||||
GdkEvent *event)
|
||||
{
|
||||
gboolean return_val = FALSE;
|
||||
gboolean reset_event = FALSE;
|
||||
double old_x, old_y;
|
||||
double x, y;
|
||||
|
||||
/* We check only once for is-still-visible; if someone
|
||||
* hides the window in on of the signals on the widget,
|
||||
@@ -4930,26 +4963,20 @@ gtk_widget_event_internal (GtkWidget *widget,
|
||||
if (!_gtk_widget_get_mapped (widget))
|
||||
return FALSE;
|
||||
|
||||
if (gdk_event_get_coords (event, &old_x, &old_y))
|
||||
{
|
||||
reset_event = TRUE;
|
||||
translate_event_coordinates (event, old_x, old_y, widget);
|
||||
}
|
||||
x = y = 0;
|
||||
translate_event_coordinates (event, &x, &y, widget);
|
||||
|
||||
if (widget == gtk_get_event_target (event))
|
||||
return_val |= gtk_widget_run_controllers (widget, event, GTK_PHASE_TARGET);
|
||||
return_val |= gtk_widget_run_controllers (widget, event, x, y, GTK_PHASE_TARGET);
|
||||
|
||||
if (return_val == FALSE)
|
||||
return_val |= gtk_widget_run_controllers (widget, event, GTK_PHASE_BUBBLE);
|
||||
return_val |= gtk_widget_run_controllers (widget, event, x, y, GTK_PHASE_BUBBLE);
|
||||
|
||||
if (return_val == FALSE &&
|
||||
(event->any.type == GDK_KEY_PRESS ||
|
||||
event->any.type == GDK_KEY_RELEASE))
|
||||
return_val |= gtk_bindings_activate_event (G_OBJECT (widget), (GdkEventKey *) event);
|
||||
|
||||
if (reset_event)
|
||||
gdk_event_set_coords (event, old_x, old_y);
|
||||
|
||||
return return_val;
|
||||
}
|
||||
|
||||
@@ -7929,23 +7956,19 @@ synth_crossing (GtkWidget *widget,
|
||||
GdkNotifyType detail)
|
||||
{
|
||||
GdkEvent *event;
|
||||
double x, y;
|
||||
GdkModifierType state;
|
||||
|
||||
event = gdk_event_new (type);
|
||||
|
||||
event->any.surface = g_object_ref (surface);
|
||||
event->any.send_event = TRUE;
|
||||
event->crossing.child_surface = g_object_ref (surface);
|
||||
event->crossing.time = GDK_CURRENT_TIME;
|
||||
gdk_surface_get_device_position (surface,
|
||||
device,
|
||||
&event->crossing.x,
|
||||
&event->crossing.y,
|
||||
NULL);
|
||||
event->crossing.mode = mode;
|
||||
event->crossing.detail = detail;
|
||||
event->crossing.focus = FALSE;
|
||||
event->crossing.state = 0;
|
||||
gdk_event_set_device (event, device);
|
||||
gdk_surface_get_device_position (surface, device, &x, &y, &state);
|
||||
event = gdk_event_crossing_new (type,
|
||||
surface,
|
||||
device,
|
||||
device,
|
||||
GDK_CURRENT_TIME,
|
||||
state,
|
||||
x, y,
|
||||
mode,
|
||||
detail);
|
||||
|
||||
if (!widget)
|
||||
widget = gtk_get_event_widget (event);
|
||||
|
||||
@@ -344,7 +344,13 @@ void gtk_widget_cancel_event_sequence (GtkWidget
|
||||
|
||||
gboolean gtk_widget_run_controllers (GtkWidget *widget,
|
||||
const GdkEvent *event,
|
||||
double x,
|
||||
double y,
|
||||
GtkPropagationPhase phase);
|
||||
void gtk_widget_handle_crossing (GtkWidget *widget,
|
||||
const GtkCrossingData *crossing,
|
||||
double x,
|
||||
double y);
|
||||
|
||||
|
||||
guint gtk_widget_add_surface_transform_changed_callback (GtkWidget *widget,
|
||||
|
||||
+79
-42
@@ -394,8 +394,8 @@ static void gtk_window_size_allocate (GtkWidget *widget,
|
||||
int height,
|
||||
int baseline);
|
||||
static gboolean gtk_window_close_request (GtkWindow *window);
|
||||
static void gtk_window_focus_in (GtkWidget *widget);
|
||||
static void gtk_window_focus_out (GtkWidget *widget);
|
||||
static void gtk_window_focus_change (GtkWidget *widget,
|
||||
const GtkCrossingData *crossing);
|
||||
static gboolean gtk_window_key_pressed (GtkWidget *widget,
|
||||
guint keyval,
|
||||
guint keycode,
|
||||
@@ -1847,10 +1847,8 @@ gtk_window_init (GtkWindow *window)
|
||||
|
||||
priv->key_controller = gtk_event_controller_key_new ();
|
||||
gtk_event_controller_set_propagation_phase (priv->key_controller, GTK_PHASE_CAPTURE);
|
||||
g_signal_connect_swapped (priv->key_controller, "focus-in",
|
||||
G_CALLBACK (gtk_window_focus_in), window);
|
||||
g_signal_connect_swapped (priv->key_controller, "focus-out",
|
||||
G_CALLBACK (gtk_window_focus_out), window);
|
||||
g_signal_connect_swapped (priv->key_controller, "focus-change",
|
||||
G_CALLBACK (gtk_window_focus_change), window);
|
||||
g_signal_connect_swapped (priv->key_controller, "key-pressed",
|
||||
G_CALLBACK (gtk_window_key_pressed), window);
|
||||
g_signal_connect_swapped (priv->key_controller, "key-released",
|
||||
@@ -6124,33 +6122,33 @@ gtk_window_has_mnemonic_modifier_pressed (GtkWindow *window)
|
||||
}
|
||||
|
||||
static void
|
||||
gtk_window_focus_in (GtkWidget *widget)
|
||||
gtk_window_focus_change (GtkWidget *widget,
|
||||
const GtkCrossingData *crossing)
|
||||
{
|
||||
GtkWindow *window = GTK_WINDOW (widget);
|
||||
|
||||
/* It appears spurious focus in events can occur when
|
||||
* the window is hidden. So we'll just check to see if
|
||||
* the window is visible before actually handling the
|
||||
* event
|
||||
*/
|
||||
if (gtk_widget_get_visible (widget))
|
||||
if (crossing->direction == GTK_CROSSING_IN)
|
||||
{
|
||||
_gtk_window_set_is_active (window, TRUE);
|
||||
/* It appears spurious focus in events can occur when
|
||||
* the window is hidden. So we'll just check to see if
|
||||
* the window is visible before actually handling the
|
||||
* event
|
||||
*/
|
||||
if (gtk_widget_get_visible (widget))
|
||||
{
|
||||
_gtk_window_set_is_active (window, TRUE);
|
||||
|
||||
if (gtk_window_has_mnemonic_modifier_pressed (window))
|
||||
_gtk_window_schedule_mnemonics_visible (window);
|
||||
if (gtk_window_has_mnemonic_modifier_pressed (window))
|
||||
_gtk_window_schedule_mnemonics_visible (window);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_gtk_window_set_is_active (window, FALSE);
|
||||
|
||||
static void
|
||||
gtk_window_focus_out (GtkWidget *widget)
|
||||
{
|
||||
GtkWindow *window = GTK_WINDOW (widget);
|
||||
|
||||
_gtk_window_set_is_active (window, FALSE);
|
||||
|
||||
/* set the mnemonic-visible property to false */
|
||||
gtk_window_set_mnemonics_visible (window, FALSE);
|
||||
/* set the mnemonic-visible property to false */
|
||||
gtk_window_set_mnemonics_visible (window, FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -6350,6 +6348,60 @@ gtk_window_move_focus (GtkWidget *widget,
|
||||
gtk_window_set_focus (GTK_WINDOW (widget), NULL);
|
||||
}
|
||||
|
||||
static void
|
||||
synthesize_focus_change_events (GtkWindow *window,
|
||||
GtkWidget *old_focus,
|
||||
GtkWidget *new_focus)
|
||||
{
|
||||
GtkCrossingData crossing;
|
||||
GtkWidget *widget, *focus_child;
|
||||
GList *list, *l;
|
||||
GtkStateFlags flags;
|
||||
|
||||
flags = GTK_STATE_FLAG_FOCUSED;
|
||||
if (gtk_window_get_focus_visible (GTK_WINDOW (window)))
|
||||
flags |= GTK_STATE_FLAG_FOCUS_VISIBLE;
|
||||
|
||||
crossing.type = GTK_CROSSING_FOCUS;
|
||||
crossing.old_target = old_focus;
|
||||
crossing.new_target = new_focus;
|
||||
|
||||
crossing.direction = GTK_CROSSING_OUT;
|
||||
|
||||
widget = old_focus;
|
||||
while (widget)
|
||||
{
|
||||
gtk_widget_handle_crossing (widget, &crossing, 0, 0);
|
||||
gtk_widget_unset_state_flags (widget, flags);
|
||||
gtk_widget_set_focus_child (widget, NULL);
|
||||
widget = gtk_widget_get_parent (widget);
|
||||
}
|
||||
|
||||
list = NULL;
|
||||
widget = new_focus;
|
||||
while (widget)
|
||||
{
|
||||
list = g_list_prepend (list, widget);
|
||||
widget = gtk_widget_get_parent (widget);
|
||||
}
|
||||
|
||||
crossing.direction = GTK_CROSSING_IN;
|
||||
|
||||
for (l = list; l; l = l->next)
|
||||
{
|
||||
widget = l->data;
|
||||
if (l->next)
|
||||
focus_child = l->next->data;
|
||||
else
|
||||
focus_child = NULL;
|
||||
gtk_widget_handle_crossing (widget, &crossing, 0, 0);
|
||||
gtk_widget_set_state_flags (widget, flags, FALSE);
|
||||
gtk_widget_set_focus_child (widget, focus_child);
|
||||
}
|
||||
|
||||
g_list_free (list);
|
||||
}
|
||||
|
||||
/**
|
||||
* gtk_window_set_focus:
|
||||
* @window: a #GtkWindow
|
||||
@@ -6368,9 +6420,6 @@ gtk_window_set_focus (GtkWindow *window,
|
||||
{
|
||||
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
|
||||
GtkWidget *old_focus = NULL;
|
||||
GdkSeat *seat;
|
||||
GdkDevice *device;
|
||||
GdkEvent *event;
|
||||
|
||||
g_return_if_fail (GTK_IS_WINDOW (window));
|
||||
|
||||
@@ -6384,19 +6433,7 @@ gtk_window_set_focus (GtkWindow *window,
|
||||
old_focus = g_object_ref (priv->focus_widget);
|
||||
g_set_object (&priv->focus_widget, NULL);
|
||||
|
||||
seat = gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET (window)));
|
||||
device = gdk_seat_get_keyboard (seat);
|
||||
|
||||
event = gdk_event_new (GDK_FOCUS_CHANGE);
|
||||
gdk_event_set_display (event, gtk_widget_get_display (GTK_WIDGET (window)));
|
||||
gdk_event_set_device (event, device);
|
||||
event->any.surface = priv->surface;
|
||||
if (event->any.surface)
|
||||
g_object_ref (event->any.surface);
|
||||
|
||||
gtk_synthesize_crossing_events (GTK_ROOT (window), old_focus, focus, event, GDK_CROSSING_NORMAL);
|
||||
|
||||
g_object_unref (event);
|
||||
synthesize_focus_change_events (window, old_focus, focus);
|
||||
|
||||
g_set_object (&priv->focus_widget, focus);
|
||||
|
||||
|
||||
Reference in New Issue
Block a user