[weston,v2,02/21] input: Make pointer grab motion callbacks take an event struct

Submitted by Jonas Ådahl on May 13, 2015, 10:26 a.m.

Details

Message ID 1431512802-6194-3-git-send-email-jadahl@gmail.com
State Superseded
Delegated to: Daniel Stone
Headers show

Not browsing as part of any series.

Commit Message

Jonas Ådahl May 13, 2015, 10:26 a.m.
Instead of only passing absolute pointer coordinates, effectively
loosing motion event data, pass a struct that can potentially contain
different types of motion events, currently being absolute and relative.

A helper function to get resulting absolute coordinates was added for
when previous callbacks simply used the (x, y) coordinates.

Signed-off-by: Jonas Ådahl <jadahl@gmail.com>
---
 desktop-shell/exposay.c    |  4 +--
 desktop-shell/shell.c      | 22 +++++++++--------
 ivi-shell/hmi-controller.c |  9 ++++---
 src/compositor-x11.c       | 13 +++++++---
 src/compositor.h           | 24 +++++++++++++++---
 src/data-device.c          |  4 +--
 src/input.c                | 61 +++++++++++++++++++++++++++++++++++++---------
 src/libinput-device.c      | 13 ++++++----
 tests/weston-test.c        | 11 ++++++---
 9 files changed, 119 insertions(+), 42 deletions(-)

Patch hide | download patch | download mbox

diff --git a/desktop-shell/exposay.c b/desktop-shell/exposay.c
index dc3fee0..a44c1f7 100644
--- a/desktop-shell/exposay.c
+++ b/desktop-shell/exposay.c
@@ -340,12 +340,12 @@  exposay_focus(struct weston_pointer_grab *grab)
 
 static void
 exposay_motion(struct weston_pointer_grab *grab, uint32_t time,
-	       wl_fixed_t x, wl_fixed_t y)
+	       struct weston_pointer_motion_event *event)
 {
 	struct desktop_shell *shell =
 		container_of(grab, struct desktop_shell, exposay.grab_ptr);
 
-	weston_pointer_move(grab->pointer, x, y);
+	weston_pointer_move(grab->pointer, event);
 
 	exposay_pick(shell,
 	             wl_fixed_to_int(grab->pointer->x),
diff --git a/desktop-shell/shell.c b/desktop-shell/shell.c
index aa26b58..c66a976 100644
--- a/desktop-shell/shell.c
+++ b/desktop-shell/shell.c
@@ -1694,14 +1694,14 @@  constrain_position(struct weston_move_grab *move, int *cx, int *cy)
 
 static void
 move_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
-		 wl_fixed_t x, wl_fixed_t y)
+		 struct weston_pointer_motion_event *event)
 {
 	struct weston_move_grab *move = (struct weston_move_grab *) grab;
 	struct weston_pointer *pointer = grab->pointer;
 	struct shell_surface *shsurf = move->base.shsurf;
 	int cx, cy;
 
-	weston_pointer_move(pointer, x, y);
+	weston_pointer_move(pointer, event);
 	if (!shsurf)
 		return;
 
@@ -1816,7 +1816,7 @@  struct weston_resize_grab {
 
 static void
 resize_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
-		   wl_fixed_t x, wl_fixed_t y)
+		   struct weston_pointer_motion_event *event)
 {
 	struct weston_resize_grab *resize = (struct weston_resize_grab *) grab;
 	struct weston_pointer *pointer = grab->pointer;
@@ -1825,7 +1825,7 @@  resize_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
 	wl_fixed_t from_x, from_y;
 	wl_fixed_t to_x, to_y;
 
-	weston_pointer_move(pointer, x, y);
+	weston_pointer_move(pointer, event);
 
 	if (!shsurf)
 		return;
@@ -2030,9 +2030,9 @@  busy_cursor_grab_focus(struct weston_pointer_grab *base)
 
 static void
 busy_cursor_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
-			wl_fixed_t x, wl_fixed_t y)
+			struct weston_pointer_motion_event *event)
 {
-	weston_pointer_move(grab->pointer, x, y);
+	weston_pointer_move(grab->pointer, event);
 }
 
 static void
@@ -3182,18 +3182,20 @@  popup_grab_focus(struct weston_pointer_grab *grab)
 
 static void
 popup_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
-		  wl_fixed_t x, wl_fixed_t y)
+		  struct weston_pointer_motion_event *event)
 {
 	struct weston_pointer *pointer = grab->pointer;
 	struct wl_resource *resource;
+	wl_fixed_t x, y;
 	wl_fixed_t sx, sy;
 
 	if (pointer->focus) {
+		weston_pointer_motion_to_abs(pointer, event, &x, &y);
 		weston_view_from_global_fixed(pointer->focus, x, y,
 					      &pointer->sx, &pointer->sy);
 	}
 
-	weston_pointer_move(pointer, x, y);
+	weston_pointer_move(pointer, event);
 
 	wl_resource_for_each(resource, &pointer->focus_resource_list) {
 		weston_view_from_global_fixed(pointer->focus,
@@ -4886,7 +4888,7 @@  terminate_binding(struct weston_seat *seat, uint32_t time, uint32_t key,
 
 static void
 rotate_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
-		   wl_fixed_t x, wl_fixed_t y)
+		   struct weston_pointer_motion_event *event)
 {
 	struct rotate_grab *rotate =
 		container_of(grab, struct rotate_grab, base.grab);
@@ -4894,7 +4896,7 @@  rotate_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
 	struct shell_surface *shsurf = rotate->base.shsurf;
 	float cx, cy, dx, dy, cposx, cposy, dposx, dposy, r;
 
-	weston_pointer_move(pointer, x, y);
+	weston_pointer_move(pointer, event);
 
 	if (!shsurf)
 		return;
diff --git a/ivi-shell/hmi-controller.c b/ivi-shell/hmi-controller.c
index bad2418..5cd5ac9 100644
--- a/ivi-shell/hmi-controller.c
+++ b/ivi-shell/hmi-controller.c
@@ -1360,16 +1360,19 @@  layer_set_pos(struct ivi_layout_layer *layer, wl_fixed_t pos_x,
 
 static void
 pointer_move_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
-			 wl_fixed_t x, wl_fixed_t y)
+			 struct weston_pointer_motion_event *event)
 {
 	struct pointer_move_grab *pnt_move_grab =
 		(struct pointer_move_grab *)grab;
-	wl_fixed_t pointer_pos[2] = {x, y};
+	wl_fixed_t pointer_pos[2] = {
+		wl_fixed_from_double(event->x),
+		wl_fixed_from_double(event->y),
+	};
 
 	move_grab_update(&pnt_move_grab->move, pointer_pos);
 	layer_set_pos(pnt_move_grab->base.layer,
 		      pnt_move_grab->move.pos[0], pnt_move_grab->move.pos[1]);
-	weston_pointer_move(pnt_move_grab->base.grab.pointer, x, y);
+	weston_pointer_move(pnt_move_grab->base.grab.pointer, event);
 }
 
 static void
diff --git a/src/compositor-x11.c b/src/compositor-x11.c
index 5129e85..57a7d11 100644
--- a/src/compositor-x11.c
+++ b/src/compositor-x11.c
@@ -1087,12 +1087,13 @@  x11_compositor_deliver_button_event(struct x11_compositor *c,
 
 static void
 x11_compositor_deliver_motion_event(struct x11_compositor *c,
-					xcb_generic_event_t *event)
+				    xcb_generic_event_t *xcb_event)
 {
 	struct x11_output *output;
 	wl_fixed_t x, y;
+	struct weston_pointer_motion_event event = { 0 };
 	xcb_motion_notify_event_t *motion_notify =
-			(xcb_motion_notify_event_t *) event;
+			(xcb_motion_notify_event_t *) xcb_event;
 
 	if (!c->has_xkb)
 		update_xkb_state_from_core(c, motion_notify->state);
@@ -1105,8 +1106,14 @@  x11_compositor_deliver_motion_event(struct x11_compositor *c,
 					   wl_fixed_from_int(motion_notify->event_y),
 					   &x, &y);
 
+	event = (struct weston_pointer_motion_event) {
+		.mask = WESTON_POINTER_MOTION_REL,
+		.dx = wl_fixed_to_double(x - c->prev_x),
+		.dy = wl_fixed_to_double(y - c->prev_y)
+	};
+
 	notify_motion(&c->core_seat, weston_compositor_get_time(),
-		      x - c->prev_x, y - c->prev_y);
+		      &event);
 
 	c->prev_x = x;
 	c->prev_y = y;
diff --git a/src/compositor.h b/src/compositor.h
index fc80eb0..dc4b830 100644
--- a/src/compositor.h
+++ b/src/compositor.h
@@ -246,11 +246,24 @@  struct weston_output {
 	struct weston_timeline_object timeline;
 };
 
+enum weston_pointer_motion_mask {
+	WESTON_POINTER_MOTION_ABS = 1 << 0,
+	WESTON_POINTER_MOTION_REL = 1 << 1,
+};
+
+struct weston_pointer_motion_event {
+	uint32_t mask;
+	double x;
+	double y;
+	double dx;
+	double dy;
+};
+
 struct weston_pointer_grab;
 struct weston_pointer_grab_interface {
 	void (*focus)(struct weston_pointer_grab *grab);
 	void (*motion)(struct weston_pointer_grab *grab, uint32_t time,
-		       wl_fixed_t x, wl_fixed_t y);
+		       struct weston_pointer_motion_event *event);
 	void (*button)(struct weston_pointer_grab *grab,
 		       uint32_t time, uint32_t button, uint32_t state);
 	void (*axis)(struct weston_pointer_grab *grab,
@@ -372,6 +385,11 @@  struct weston_touch {
 	uint32_t grab_time;
 };
 
+void
+weston_pointer_motion_to_abs(struct weston_pointer *pointer,
+			     struct weston_pointer_motion_event *event,
+			     wl_fixed_t *x, wl_fixed_t *y);
+
 struct weston_pointer *
 weston_pointer_create(struct weston_seat *seat);
 void
@@ -393,7 +411,7 @@  weston_pointer_clamp(struct weston_pointer *pointer,
 			    wl_fixed_t *fx, wl_fixed_t *fy);
 void
 weston_pointer_move(struct weston_pointer *pointer,
-		    wl_fixed_t x, wl_fixed_t y);
+		    struct weston_pointer_motion_event *event);
 void
 weston_pointer_set_default_grab(struct weston_pointer *pointer,
 		const struct weston_pointer_grab_interface *interface);
@@ -1064,7 +1082,7 @@  weston_surface_activate(struct weston_surface *surface,
 			struct weston_seat *seat);
 void
 notify_motion(struct weston_seat *seat, uint32_t time,
-	      wl_fixed_t dx, wl_fixed_t dy);
+	      struct weston_pointer_motion_event *event);
 void
 notify_motion_absolute(struct weston_seat *seat, uint32_t time,
 		       wl_fixed_t x, wl_fixed_t y);
diff --git a/src/data-device.c b/src/data-device.c
index fc93435..1f709b8 100644
--- a/src/data-device.c
+++ b/src/data-device.c
@@ -330,7 +330,7 @@  drag_grab_focus(struct weston_pointer_grab *grab)
 
 static void
 drag_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
-		 wl_fixed_t x, wl_fixed_t y)
+		 struct weston_pointer_motion_event *event)
 {
 	struct weston_pointer_drag *drag =
 		container_of(grab, struct weston_pointer_drag, grab);
@@ -338,7 +338,7 @@  drag_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
 	float fx, fy;
 	wl_fixed_t sx, sy;
 
-	weston_pointer_move(pointer, x, y);
+	weston_pointer_move(pointer, event);
 
 	if (drag->base.icon) {
 		fx = wl_fixed_to_double(pointer->x) + drag->base.dx;
diff --git a/src/input.c b/src/input.c
index fe1851a..a7d8daa 100644
--- a/src/input.c
+++ b/src/input.c
@@ -163,17 +163,20 @@  default_grab_pointer_focus(struct weston_pointer_grab *grab)
 
 static void
 default_grab_pointer_motion(struct weston_pointer_grab *grab, uint32_t time,
-			    wl_fixed_t x, wl_fixed_t y)
+			    struct weston_pointer_motion_event *event)
 {
 	struct weston_pointer *pointer = grab->pointer;
 	struct wl_list *resource_list;
 	struct wl_resource *resource;
+	wl_fixed_t x, y;
 
-	if (pointer->focus)
+	if (pointer->focus) {
+		weston_pointer_motion_to_abs(pointer, event, &x, &y);
 		weston_view_from_global_fixed(pointer->focus, x, y,
 					      &pointer->sx, &pointer->sy);
+	}
 
-	weston_pointer_move(pointer, x, y);
+	weston_pointer_move(pointer, event);
 
 	resource_list = &pointer->focus_resource_list;
 	wl_resource_for_each(resource, resource_list) {
@@ -888,9 +891,9 @@  weston_pointer_clamp(struct weston_pointer *pointer, wl_fixed_t *fx, wl_fixed_t
 		weston_pointer_clamp_for_output(pointer, prev, fx, fy);
 }
 
-/* Takes absolute values */
-WL_EXPORT void
-weston_pointer_move(struct weston_pointer *pointer, wl_fixed_t x, wl_fixed_t y)
+static void
+weston_pointer_move_to(struct weston_pointer *pointer,
+		       wl_fixed_t x, wl_fixed_t y)
 {
 	int32_t ix, iy;
 
@@ -913,6 +916,33 @@  weston_pointer_move(struct weston_pointer *pointer, wl_fixed_t x, wl_fixed_t y)
 	wl_signal_emit(&pointer->motion_signal, pointer);
 }
 
+WL_EXPORT void
+weston_pointer_motion_to_abs(struct weston_pointer *pointer,
+			     struct weston_pointer_motion_event *event,
+			     wl_fixed_t *x, wl_fixed_t *y)
+{
+	if (event->mask & WESTON_POINTER_MOTION_ABS) {
+		*x = wl_fixed_from_double(event->x);
+		*y = wl_fixed_from_double(event->y);
+	} else if (event->mask & WESTON_POINTER_MOTION_REL) {
+		*x = pointer->x + wl_fixed_from_double(event->dx);
+		*y = pointer->y + wl_fixed_from_double(event->dy);
+	} else {
+		assert(!"invalid motion event");
+		*x = *y = 0;
+	}
+}
+
+WL_EXPORT void
+weston_pointer_move(struct weston_pointer *pointer,
+		    struct weston_pointer_motion_event *event)
+{
+	wl_fixed_t x, y;
+
+	weston_pointer_motion_to_abs(pointer, event, &x, &y);
+	weston_pointer_move_to(pointer, x, y);
+}
+
 /** Verify if the pointer is in a valid position and move it if it isn't.
  */
 static void
@@ -954,18 +984,19 @@  weston_pointer_handle_output_destroy(struct wl_listener *listener, void *data)
 	fy = pointer->y;
 
 	weston_pointer_clamp_for_output(pointer, closest, &fx, &fy);
-	weston_pointer_move(pointer, fx, fy);
+	weston_pointer_move_to(pointer, fx, fy);
 }
 
 WL_EXPORT void
 notify_motion(struct weston_seat *seat,
-	      uint32_t time, wl_fixed_t dx, wl_fixed_t dy)
+	      uint32_t time,
+	      struct weston_pointer_motion_event *event)
 {
 	struct weston_compositor *ec = seat->compositor;
 	struct weston_pointer *pointer = seat->pointer;
 
 	weston_compositor_wake(ec);
-	pointer->grab->interface->motion(pointer->grab, time, pointer->x + dx, pointer->y + dy);
+	pointer->grab->interface->motion(pointer->grab, time, event);
 }
 
 static void
@@ -1010,9 +1041,17 @@  notify_motion_absolute(struct weston_seat *seat,
 {
 	struct weston_compositor *ec = seat->compositor;
 	struct weston_pointer *pointer = seat->pointer;
+	struct weston_pointer_motion_event event = { 0 };
 
 	weston_compositor_wake(ec);
-	pointer->grab->interface->motion(pointer->grab, time, x, y);
+
+	event = (struct weston_pointer_motion_event) {
+		.mask = WESTON_POINTER_MOTION_ABS,
+		.x = wl_fixed_to_double(x),
+		.y = wl_fixed_to_double(y),
+	};
+
+	pointer->grab->interface->motion(pointer->grab, time, &event);
 }
 
 WL_EXPORT void
@@ -1388,7 +1427,7 @@  notify_pointer_focus(struct weston_seat *seat, struct weston_output *output,
 		     wl_fixed_t x, wl_fixed_t y)
 {
 	if (output) {
-		weston_pointer_move(seat->pointer, x, y);
+		weston_pointer_move_to(seat->pointer, x, y);
 	} else {
 		/* FIXME: We should call weston_pointer_set_focus(seat,
 		 * NULL) here, but somehow that breaks re-entry... */
diff --git a/src/libinput-device.c b/src/libinput-device.c
index 567e5ea..28cc565 100644
--- a/src/libinput-device.c
+++ b/src/libinput-device.c
@@ -84,14 +84,17 @@  handle_pointer_motion(struct libinput_device *libinput_device,
 {
 	struct evdev_device *device =
 		libinput_device_get_user_data(libinput_device);
-	wl_fixed_t dx, dy;
+	struct weston_pointer_motion_event event = { 0 };
+
+	event = (struct weston_pointer_motion_event) {
+		.mask = WESTON_POINTER_MOTION_REL,
+		.dx = libinput_event_pointer_get_dx(pointer_event),
+		.dy = libinput_event_pointer_get_dy(pointer_event),
+	};
 
-	dx = wl_fixed_from_double(libinput_event_pointer_get_dx(pointer_event));
-	dy = wl_fixed_from_double(libinput_event_pointer_get_dy(pointer_event));
 	notify_motion(device->seat,
 		      libinput_event_pointer_get_time(pointer_event),
-		      dx,
-		      dy);
+		      &event);
 }
 
 static void
diff --git a/tests/weston-test.c b/tests/weston-test.c
index 9f1f49b..f6c500c 100644
--- a/tests/weston-test.c
+++ b/tests/weston-test.c
@@ -140,10 +140,15 @@  move_pointer(struct wl_client *client, struct wl_resource *resource,
 	struct weston_test *test = wl_resource_get_user_data(resource);
 	struct weston_seat *seat = get_seat(test);
 	struct weston_pointer *pointer = seat->pointer;
+	struct weston_pointer_motion_event event = { 0 };
 
-	notify_motion(seat, 100,
-		      wl_fixed_from_int(x) - pointer->x,
-		      wl_fixed_from_int(y) - pointer->y);
+	event = (struct weston_pointer_motion_event) {
+		.mask = WESTON_POINTER_MOTION_REL,
+		.dx = wl_fixed_to_double(wl_fixed_from_int(x) - pointer->x),
+		.dy = wl_fixed_to_double(wl_fixed_from_int(y) - pointer->y),
+	};
+
+	notify_motion(seat, 100, &event);
 
 	notify_pointer_position(test, resource);
 }

Comments

Hi Jonas,

On 13 May 2015 at 11:26, Jonas Ådahl <jadahl@gmail.com> wrote:
> @@ -3182,18 +3182,20 @@ popup_grab_focus(struct weston_pointer_grab *grab)
>
>  static void
>  popup_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
> -                 wl_fixed_t x, wl_fixed_t y)
> +                 struct weston_pointer_motion_event *event)
>  {
>         struct weston_pointer *pointer = grab->pointer;
>         struct wl_resource *resource;
> +       wl_fixed_t x, y;
>         wl_fixed_t sx, sy;
>
>         if (pointer->focus) {
> +               weston_pointer_motion_to_abs(pointer, event, &x, &y);
>                 weston_view_from_global_fixed(pointer->focus, x, y,
>                                               &pointer->sx, &pointer->sy);
>         }
>
> -       weston_pointer_move(pointer, x, y);
> +       weston_pointer_move(pointer, event);
>
>         wl_resource_for_each(resource, &pointer->focus_resource_list) {
>                 weston_view_from_global_fixed(pointer->focus,
> diff --git a/ivi-shell/hmi-controller.c b/ivi-shell/hmi-controller.c
> index bad2418..5cd5ac9 100644
> --- a/ivi-shell/hmi-controller.c
> +++ b/ivi-shell/hmi-controller.c
> @@ -1360,16 +1360,19 @@ layer_set_pos(struct ivi_layout_layer *layer, wl_fixed_t pos_x,
>
>  static void
>  pointer_move_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
> -                        wl_fixed_t x, wl_fixed_t y)
> +                        struct weston_pointer_motion_event *event)
>  {
>         struct pointer_move_grab *pnt_move_grab =
>                 (struct pointer_move_grab *)grab;
> -       wl_fixed_t pointer_pos[2] = {x, y};
> +       wl_fixed_t pointer_pos[2] = {
> +               wl_fixed_from_double(event->x),
> +               wl_fixed_from_double(event->y),
> +       };

Should this also be weston_pointer_motion_to_abs()?

> diff --git a/src/compositor-x11.c b/src/compositor-x11.c
> index 5129e85..57a7d11 100644
> --- a/src/compositor-x11.c
> +++ b/src/compositor-x11.c
> @@ -1105,8 +1106,14 @@ x11_compositor_deliver_motion_event(struct x11_compositor *c,
>                                            wl_fixed_from_int(motion_notify->event_y),
>                                            &x, &y);
>
> +       event = (struct weston_pointer_motion_event) {
> +               .mask = WESTON_POINTER_MOTION_REL,
> +               .dx = wl_fixed_to_double(x - c->prev_x),
> +               .dy = wl_fixed_to_double(y - c->prev_y)
> +       };
> +

To be honest, I'm somewhat skeptical of faking relative motion from
abs in general.

Cheers,
Daniel
Agreed. Absolute input needs to be handled separately. The usage pattern on
an absolute input device is that the cursor warps to the new position, it
didn't simply move from the old to the new.

As an example, pointer barriers shouldn't take effect on absolute input.

On Tue, Oct 27, 2015, 10:40 AM Daniel Stone <daniel@fooishbar.org> wrote:

> Hi Jonas,
>
> On 13 May 2015 at 11:26, Jonas Ådahl <jadahl@gmail.com> wrote:
> > @@ -3182,18 +3182,20 @@ popup_grab_focus(struct weston_pointer_grab
> *grab)
> >
> >  static void
> >  popup_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
> > -                 wl_fixed_t x, wl_fixed_t y)
> > +                 struct weston_pointer_motion_event *event)
> >  {
> >         struct weston_pointer *pointer = grab->pointer;
> >         struct wl_resource *resource;
> > +       wl_fixed_t x, y;
> >         wl_fixed_t sx, sy;
> >
> >         if (pointer->focus) {
> > +               weston_pointer_motion_to_abs(pointer, event, &x, &y);
> >                 weston_view_from_global_fixed(pointer->focus, x, y,
> >                                               &pointer->sx,
> &pointer->sy);
> >         }
> >
> > -       weston_pointer_move(pointer, x, y);
> > +       weston_pointer_move(pointer, event);
> >
> >         wl_resource_for_each(resource, &pointer->focus_resource_list) {
> >                 weston_view_from_global_fixed(pointer->focus,
> > diff --git a/ivi-shell/hmi-controller.c b/ivi-shell/hmi-controller.c
> > index bad2418..5cd5ac9 100644
> > --- a/ivi-shell/hmi-controller.c
> > +++ b/ivi-shell/hmi-controller.c
> > @@ -1360,16 +1360,19 @@ layer_set_pos(struct ivi_layout_layer *layer,
> wl_fixed_t pos_x,
> >
> >  static void
> >  pointer_move_grab_motion(struct weston_pointer_grab *grab, uint32_t
> time,
> > -                        wl_fixed_t x, wl_fixed_t y)
> > +                        struct weston_pointer_motion_event *event)
> >  {
> >         struct pointer_move_grab *pnt_move_grab =
> >                 (struct pointer_move_grab *)grab;
> > -       wl_fixed_t pointer_pos[2] = {x, y};
> > +       wl_fixed_t pointer_pos[2] = {
> > +               wl_fixed_from_double(event->x),
> > +               wl_fixed_from_double(event->y),
> > +       };
>
> Should this also be weston_pointer_motion_to_abs()?
>
> > diff --git a/src/compositor-x11.c b/src/compositor-x11.c
> > index 5129e85..57a7d11 100644
> > --- a/src/compositor-x11.c
> > +++ b/src/compositor-x11.c
> > @@ -1105,8 +1106,14 @@ x11_compositor_deliver_motion_event(struct
> x11_compositor *c,
> >
> wl_fixed_from_int(motion_notify->event_y),
> >                                            &x, &y);
> >
> > +       event = (struct weston_pointer_motion_event) {
> > +               .mask = WESTON_POINTER_MOTION_REL,
> > +               .dx = wl_fixed_to_double(x - c->prev_x),
> > +               .dy = wl_fixed_to_double(y - c->prev_y)
> > +       };
> > +
>
> To be honest, I'm somewhat skeptical of faking relative motion from
> abs in general.
>
> Cheers,
> Daniel
> _______________________________________________
> wayland-devel mailing list
> wayland-devel@lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/wayland-devel
>
On Tue, Oct 27, 2015 at 05:40:33PM +0000, Daniel Stone wrote:
> Hi Jonas,
> 
> On 13 May 2015 at 11:26, Jonas Ådahl <jadahl@gmail.com> wrote:
> > @@ -3182,18 +3182,20 @@ popup_grab_focus(struct weston_pointer_grab *grab)
> >
> >  static void
> >  popup_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
> > -                 wl_fixed_t x, wl_fixed_t y)
> > +                 struct weston_pointer_motion_event *event)
> >  {
> >         struct weston_pointer *pointer = grab->pointer;
> >         struct wl_resource *resource;
> > +       wl_fixed_t x, y;
> >         wl_fixed_t sx, sy;
> >
> >         if (pointer->focus) {
> > +               weston_pointer_motion_to_abs(pointer, event, &x, &y);
> >                 weston_view_from_global_fixed(pointer->focus, x, y,
> >                                               &pointer->sx, &pointer->sy);
> >         }
> >
> > -       weston_pointer_move(pointer, x, y);
> > +       weston_pointer_move(pointer, event);
> >
> >         wl_resource_for_each(resource, &pointer->focus_resource_list) {
> >                 weston_view_from_global_fixed(pointer->focus,
> > diff --git a/ivi-shell/hmi-controller.c b/ivi-shell/hmi-controller.c
> > index bad2418..5cd5ac9 100644
> > --- a/ivi-shell/hmi-controller.c
> > +++ b/ivi-shell/hmi-controller.c
> > @@ -1360,16 +1360,19 @@ layer_set_pos(struct ivi_layout_layer *layer, wl_fixed_t pos_x,
> >
> >  static void
> >  pointer_move_grab_motion(struct weston_pointer_grab *grab, uint32_t time,
> > -                        wl_fixed_t x, wl_fixed_t y)
> > +                        struct weston_pointer_motion_event *event)
> >  {
> >         struct pointer_move_grab *pnt_move_grab =
> >                 (struct pointer_move_grab *)grab;
> > -       wl_fixed_t pointer_pos[2] = {x, y};
> > +       wl_fixed_t pointer_pos[2] = {
> > +               wl_fixed_from_double(event->x),
> > +               wl_fixed_from_double(event->y),
> > +       };
> 
> Should this also be weston_pointer_motion_to_abs()?

Yes, it probably should.

> 
> > diff --git a/src/compositor-x11.c b/src/compositor-x11.c
> > index 5129e85..57a7d11 100644
> > --- a/src/compositor-x11.c
> > +++ b/src/compositor-x11.c
> > @@ -1105,8 +1106,14 @@ x11_compositor_deliver_motion_event(struct x11_compositor *c,
> >                                            wl_fixed_from_int(motion_notify->event_y),
> >                                            &x, &y);
> >
> > +       event = (struct weston_pointer_motion_event) {
> > +               .mask = WESTON_POINTER_MOTION_REL,
> > +               .dx = wl_fixed_to_double(x - c->prev_x),
> > +               .dy = wl_fixed_to_double(y - c->prev_y)
> > +       };
> > +
> 
> To be honest, I'm somewhat skeptical of faking relative motion from
> abs in general.

Sure. Though, this is nothing new with this patch. We've sent X11
pointer movements like this since as far as I can remember.


Jonas

> 
> Cheers,
> Daniel