diff -Nru gtk+3.0-3.14.15/debian/changelog gtk+3.0-3.14.15/debian/changelog --- gtk+3.0-3.14.15/debian/changelog 2015-08-24 15:26:44.000000000 +0000 +++ gtk+3.0-3.14.15/debian/changelog 2015-09-07 08:19:56.000000000 +0000 @@ -1,3 +1,9 @@ +gtk+3.0 (3.14.15-0ubuntu2) vivid; urgency=medium + + * Refresh of mir patches to match current API + + -- Andreas Pokorny Mon, 07 Sep 2015 10:18:57 +0200 + gtk+3.0 (3.14.15-0ubuntu1) vivid; urgency=medium * New upstream release 3.14.15, fixing bugs: diff -Nru gtk+3.0-3.14.15/debian/patches/mir-backend-unmerged.patch gtk+3.0-3.14.15/debian/patches/mir-backend-unmerged.patch --- gtk+3.0-3.14.15/debian/patches/mir-backend-unmerged.patch 2015-08-24 15:26:44.000000000 +0000 +++ gtk+3.0-3.14.15/debian/patches/mir-backend-unmerged.patch 2015-09-07 08:18:50.000000000 +0000 @@ -39,11 +39,11 @@ gdk/mir/gdkmirwindowimpl.c | 95 +++++++++++++++---- 7 files changed, 295 insertions(+), 94 deletions(-) -diff --git a/gdk/mir/gdkmir-private.h b/gdk/mir/gdkmir-private.h -index 053615a..6f0b6c3 100644 ---- a/gdk/mir/gdkmir-private.h -+++ b/gdk/mir/gdkmir-private.h -@@ -69,6 +69,8 @@ GdkDevice *_gdk_mir_device_manager_get_keyboard (GdkDeviceManager *device_manage +Index: gtk+-3.14.13/gdk/mir/gdkmir-private.h +=================================================================== +--- gtk+-3.14.13.orig/gdk/mir/gdkmir-private.h ++++ gtk+-3.14.13/gdk/mir/gdkmir-private.h +@@ -45,6 +45,8 @@ GdkDevice *_gdk_mir_device_manager_get_k GdkKeymap *_gdk_mir_keymap_new (void); @@ -52,28 +52,94 @@ GdkDevice *_gdk_mir_keyboard_new (GdkDeviceManager *device_manager, const gchar *name); GdkDevice *_gdk_mir_pointer_new (GdkDeviceManager *device_manager, const gchar *name); -@@ -131,4 +133,16 @@ void _gdk_mir_print_resize_event (const MirResizeEvent *event); +@@ -63,9 +65,9 @@ void _gdk_mir_window_impl_set_surface_st - void _gdk_mir_print_event (const MirEvent *event); + void _gdk_mir_window_impl_set_surface_type (GdkMirWindowImpl *impl, MirSurfaceType type); -+/* TODO: Remove once we have proper transient window support. */ -+GdkWindow * _gdk_mir_window_get_visible_transient_child (GdkWindow *window, -+ gdouble x, -+ gdouble y, -+ gdouble *out_x, -+ gdouble *out_y); -+ -+/* TODO: Remove once we have proper transient window support. */ -+void _gdk_mir_window_transient_children_foreach (GdkWindow *window, -+ void (*func) (GdkWindow *, gpointer), -+ gpointer user_data); -+ - #endif /* __GDK_PRIVATE_MIR_H__ */ -diff --git a/gdk/mir/gdkmirdisplay.c b/gdk/mir/gdkmirdisplay.c -index 5c27b53..cc92a53 100644 ---- a/gdk/mir/gdkmirdisplay.c -+++ b/gdk/mir/gdkmirdisplay.c -@@ -416,9 +416,20 @@ gdk_mir_display_create_window_impl (GdkDisplay *display, +-void _gdk_mir_window_impl_set_cursor_state (GdkMirWindowImpl *impl, gdouble x, gdouble y, gboolean cursor_inside, MirMotionButton button_state); ++void _gdk_mir_window_impl_set_cursor_state (GdkMirWindowImpl *impl, gdouble x, gdouble y, gboolean cursor_inside, guint button_state); + +-void _gdk_mir_window_impl_get_cursor_state (GdkMirWindowImpl *impl, gdouble *x, gdouble *y, gboolean *cursor_inside, MirMotionButton *button_state); ++void _gdk_mir_window_impl_get_cursor_state (GdkMirWindowImpl *impl, gdouble *x, gdouble *y, gboolean *cursor_inside, guint *button_state); + + GdkMirEventSource *_gdk_mir_display_get_event_source (GdkDisplay *display); + +@@ -77,11 +79,12 @@ void _gdk_mir_window_reference_unref (Gd + + void _gdk_mir_event_source_queue (GdkMirWindowReference *window_ref, const MirEvent *event); + ++MirPixelFormat _gdk_mir_display_get_pixel_format (GdkDisplay *display, MirBufferUsage usage); + void _gdk_mir_print_modifiers (unsigned int modifiers); + +-void _gdk_mir_print_key_event (const MirKeyEvent *event); ++void _gdk_mir_print_key_event (const MirInputEvent *event); + +-void _gdk_mir_print_motion_event (const MirMotionEvent *event); ++void _gdk_mir_print_motion_event (const MirInputEvent *event); + + void _gdk_mir_print_surface_event (const MirSurfaceEvent *event); + +Index: gtk+-3.14.13/gdk/mir/gdkmirdisplay.c +=================================================================== +--- gtk+-3.14.13.orig/gdk/mir/gdkmirdisplay.c ++++ gtk+-3.14.13/gdk/mir/gdkmirdisplay.c +@@ -46,6 +46,8 @@ typedef struct GdkMirDisplay + GdkScreen *screen; + + GdkKeymap *keymap; ++ ++ MirPixelFormat sw_pixel_format; + } GdkMirDisplay; + + typedef struct GdkMirDisplayClass +@@ -53,6 +55,8 @@ typedef struct GdkMirDisplayClass + GdkDisplayClass parent_class; + } GdkMirDisplayClass; + ++static void get_pixel_format (MirConnection *, MirPixelFormat *sw); ++ + /** + * SECTION:mir_interaction + * @Short_description: Mir backend-specific functions +@@ -93,6 +97,7 @@ GdkDisplay * + _gdk_mir_display_open (const gchar *display_name) + { + MirConnection *connection; ++ MirPixelFormat sw_pixel_format; + GdkMirDisplay *display; + + g_printerr ("gdk_mir_display_open\n"); +@@ -100,6 +105,7 @@ _gdk_mir_display_open (const gchar *disp + connection = mir_connect_sync (NULL, "GDK-Mir"); + if (!connection) + return NULL; ++ + if (!mir_connection_is_valid (connection)) + { + g_printerr ("Failed to connect to Mir: %s\n", mir_connection_get_error_message (connection)); +@@ -107,11 +113,21 @@ _gdk_mir_display_open (const gchar *disp + return NULL; + } + ++ get_pixel_format (connection, &sw_pixel_format); ++ ++ if (sw_pixel_format == mir_pixel_format_invalid) ++ { ++ g_printerr ("Mir display does not support required pixel formats\n"); ++ mir_connection_release (connection); ++ return NULL; ++ } ++ + display = g_object_new (GDK_TYPE_MIR_DISPLAY, NULL); + + display->connection = connection; + GDK_DISPLAY (display)->device_manager = _gdk_mir_device_manager_new (GDK_DISPLAY (display)); + display->screen = _gdk_mir_screen_new (GDK_DISPLAY (display)); ++ display->sw_pixel_format = sw_pixel_format; + + g_signal_emit_by_name (display, "opened"); + +@@ -391,9 +407,20 @@ gdk_mir_display_create_window_impl (GdkD g_printerr (" location=(%d, %d)", window->x, window->y); g_printerr (" size=(%d, %d)", window->width, window->height); g_printerr ("\n"); @@ -97,10 +163,56 @@ } static GdkKeymap * -diff --git a/gdk/mir/gdkmireventsource.c b/gdk/mir/gdkmireventsource.c -index cfe36e8..9843e2a 100644 ---- a/gdk/mir/gdkmireventsource.c -+++ b/gdk/mir/gdkmireventsource.c +@@ -480,6 +507,45 @@ gdk_mir_display_text_property_to_utf8_li + return 0; + } + ++static void ++get_pixel_format (MirConnection *connection, ++ MirPixelFormat *sw_pixel_format) ++{ ++ MirPixelFormat formats[mir_pixel_formats]; ++ unsigned int n_formats, i; ++ ++ mir_connection_get_available_surface_formats (connection, formats, ++ mir_pixel_formats, &n_formats); ++ ++ if (sw_pixel_format) ++ { ++ *sw_pixel_format = mir_pixel_format_invalid; ++ ++ for (i = 0; i < n_formats; i++) ++ { ++ if (formats[i] == mir_pixel_format_argb_8888) ++ { ++ *sw_pixel_format = formats[i]; ++ break; ++ } ++ } ++ } ++} ++ ++MirPixelFormat ++_gdk_mir_display_get_pixel_format (GdkDisplay *display, ++ MirBufferUsage usage) ++{ ++ GdkMirDisplay *mir_dpy = GDK_MIR_DISPLAY (display); ++ ++ if (usage == mir_buffer_usage_hardware) ++ return mir_pixel_format_invalid; ++ ++ return mir_dpy->sw_pixel_format; ++} ++ ++ ++ + static gchar * + gdk_mir_display_utf8_to_string_target (GdkDisplay *display, + const gchar *str) +Index: gtk+-3.14.13/gdk/mir/gdkmireventsource.c +=================================================================== +--- gtk+-3.14.13.orig/gdk/mir/gdkmireventsource.c ++++ gtk+-3.14.13/gdk/mir/gdkmireventsource.c @@ -22,6 +22,8 @@ #include "gdkmir.h" #include "gdkmir-private.h" @@ -110,6 +222,15 @@ struct _GdkMirWindowReference { GdkMirEventSource *source; GdkWindow *window; +@@ -30,7 +32,7 @@ struct _GdkMirWindowReference { + + typedef struct { + GdkMirWindowReference *window_ref; +- MirEvent event; ++ const MirEvent *event; + } GdkMirQueuedEvent; + + struct _GdkMirEventSource @@ -39,6 +41,7 @@ struct _GdkMirEventSource GMutex mir_event_lock; @@ -118,7 +239,7 @@ GdkDisplay *display; }; -@@ -50,6 +53,7 @@ send_event (GdkWindow *window, GdkDevice *device, GdkEvent *event) +@@ -50,6 +53,7 @@ send_event (GdkWindow *window, GdkDevice GList *node; gdk_event_set_device (event, device); @@ -126,7 +247,7 @@ gdk_event_set_screen (event, gdk_display_get_screen (gdk_window_get_display (window), 0)); event->any.window = g_object_ref (window); -@@ -118,7 +122,7 @@ set_key_event_string (GdkEventKey *event) +@@ -118,7 +122,7 @@ set_key_event_string (GdkEventKey *event } static void @@ -135,7 +256,7 @@ { GdkEvent *event; -@@ -127,6 +131,7 @@ generate_key_event (GdkWindow *window, GdkEventType type, guint state, guint key +@@ -127,6 +131,7 @@ generate_key_event (GdkWindow *window, G event->key.keyval = keyval; event->key.hardware_keycode = keycode + 8; event->key.is_modifier = is_modifier; @@ -152,7 +273,7 @@ { GdkEvent *event; -@@ -148,12 +153,13 @@ generate_button_event (GdkWindow *window, GdkEventType type, gdouble x, gdouble +@@ -148,12 +153,13 @@ generate_button_event (GdkWindow *window event->button.y = y; event->button.state = state; event->button.button = button; @@ -167,7 +288,7 @@ { GdkEvent *event; -@@ -161,15 +167,28 @@ generate_scroll_event (GdkWindow *window, gdouble x, gdouble y, gdouble delta_x, +@@ -161,15 +167,28 @@ generate_scroll_event (GdkWindow *window event->scroll.x = x; event->scroll.y = y; event->scroll.state = state; @@ -200,7 +321,7 @@ { GdkEvent *event; -@@ -178,12 +197,13 @@ generate_motion_event (GdkWindow *window, gdouble x, gdouble y, guint state) +@@ -178,12 +197,13 @@ generate_motion_event (GdkWindow *window event->motion.y = y; event->motion.state = state; event->motion.is_hint = FALSE; @@ -215,7 +336,7 @@ { GdkEvent *event; -@@ -193,6 +213,7 @@ generate_crossing_event (GdkWindow *window, GdkEventType type, gdouble x, gdoubl +@@ -193,6 +213,7 @@ generate_crossing_event (GdkWindow *wind event->crossing.mode = GDK_CROSSING_NORMAL; event->crossing.detail = GDK_NOTIFY_ANCESTOR; event->crossing.focus = TRUE; @@ -223,7 +344,49 @@ send_event (window, get_pointer (window), event); } -@@ -239,35 +260,30 @@ get_modifier_state (unsigned int modifiers, unsigned int button_state) +@@ -219,55 +240,66 @@ get_modifier_state (unsigned int modifie + { + guint modifier_state = 0; + +- if ((modifiers & mir_key_modifier_alt) != 0) ++ if ((modifiers & (mir_input_event_modifier_alt | ++ mir_input_event_modifier_alt_left | ++ mir_input_event_modifier_alt_right)) != 0) + modifier_state |= GDK_MOD1_MASK; +- if ((modifiers & mir_key_modifier_shift) != 0) ++ if ((modifiers & (mir_input_event_modifier_shift | ++ mir_input_event_modifier_shift_left | ++ mir_input_event_modifier_shift_right)) != 0) + modifier_state |= GDK_SHIFT_MASK; +- if ((modifiers & mir_key_modifier_ctrl) != 0) ++ if ((modifiers & (mir_input_event_modifier_ctrl | ++ mir_input_event_modifier_ctrl_left | ++ mir_input_event_modifier_ctrl_right)) != 0) + modifier_state |= GDK_CONTROL_MASK; +- if ((modifiers & mir_key_modifier_meta) != 0) +- modifier_state |= GDK_SUPER_MASK; +- if ((modifiers & mir_key_modifier_caps_lock) != 0) ++ if ((modifiers & (mir_input_event_modifier_meta | ++ mir_input_event_modifier_meta_left | ++ mir_input_event_modifier_meta_right)) != 0) ++ modifier_state |= GDK_META_MASK; ++ if ((modifiers & mir_input_event_modifier_caps_lock) != 0) + modifier_state |= GDK_LOCK_MASK; +- if ((button_state & mir_motion_button_primary) != 0) ++ if ((button_state & mir_pointer_button_primary) != 0) + modifier_state |= GDK_BUTTON1_MASK; +- if ((button_state & mir_motion_button_secondary) != 0) +- modifier_state |= GDK_BUTTON3_MASK; +- if ((button_state & mir_motion_button_tertiary) != 0) ++ if ((button_state & mir_pointer_button_secondary) != 0) + modifier_state |= GDK_BUTTON2_MASK; ++ if ((button_state & mir_pointer_button_tertiary) != 0) ++ modifier_state |= GDK_BUTTON3_MASK; ++ if ((button_state & mir_pointer_button_back) != 0) ++ modifier_state |= GDK_BUTTON4_MASK; ++ if ((button_state & mir_pointer_button_forward) != 0) ++ modifier_state |= GDK_BUTTON5_MASK; + return modifier_state; } @@ -237,123 +400,149 @@ -*/ - static void - handle_key_event (GdkWindow *window, const MirKeyEvent *event) +-handle_key_event (GdkWindow *window, const MirKeyEvent *event) ++handle_key_event (GdkWindow *window, const MirInputEvent *event) { ++ const MirKeyboardEvent *keyboard_event = mir_input_event_get_keyboard_event (event); + GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); + GdkKeymap *keymap; guint modifier_state; - gboolean is_modifier = FALSE; -- ++ guint button_state; + - modifier_state = get_modifier_state (event->modifiers, 0); // FIXME: Need to track button state -+ MirMotionButton button_state; ++ if (!keyboard_event) ++ return; - switch (event->action) +- switch (event->action) ++ switch (mir_keyboard_event_action (keyboard_event)) { - case mir_key_action_down: - case mir_key_action_up: +- case mir_key_action_down: +- case mir_key_action_up: ++ case mir_keyboard_action_up: ++ case mir_keyboard_action_down: // FIXME: Convert keycode - // FIXME: is_modifier + _gdk_mir_window_impl_get_cursor_state (impl, NULL, NULL, NULL, &button_state); -+ modifier_state = get_modifier_state (event->modifiers, button_state); ++ modifier_state = get_modifier_state (mir_keyboard_event_modifiers (keyboard_event), button_state); + keymap = gdk_keymap_get_for_display (gdk_window_get_display (window)); + generate_key_event (window, - event->action == mir_key_action_down ? GDK_KEY_PRESS : GDK_KEY_RELEASE, +- event->action == mir_key_action_down ? GDK_KEY_PRESS : GDK_KEY_RELEASE, ++ mir_keyboard_event_action (keyboard_event) == mir_keyboard_action_down ? GDK_KEY_PRESS : GDK_KEY_RELEASE, modifier_state, - event->key_code, - event->scan_code, +- event->key_code, +- event->scan_code, - is_modifier); -+ _gdk_mir_keymap_key_is_modifier (keymap, event->key_code), -+ NANO_TO_MILLI (event->event_time)); ++ mir_keyboard_event_key_code (keyboard_event), ++ mir_keyboard_event_scan_code (keyboard_event), ++ _gdk_mir_keymap_key_is_modifier (keymap, mir_keyboard_event_key_code (keyboard_event)), ++ NANO_TO_MILLI (mir_input_event_get_event_time (event))); break; default: //case mir_key_action_multiple: -@@ -276,6 +292,47 @@ handle_key_event (GdkWindow *window, const MirKeyEvent *event) +@@ -276,83 +308,162 @@ handle_key_event (GdkWindow *window, con } } -+/* TODO: Remove once we have proper transient window support. */ -+typedef struct ++static guint ++mir_pointer_event_get_button_state (const MirPointerEvent *event) +{ -+ GdkWindow *except; -+ gdouble x; -+ gdouble y; -+ guint32 time; -+} LeaveInfo; -+ -+/* TODO: Remove once we have proper transient window support. */ -+/* -+ * leave_windows_except: -+ * -+ * Generate a leave event for every window except the one the cursor is in. -+ */ -+static void -+leave_windows_except (GdkWindow *window, -+ gpointer user_data) -+{ -+ LeaveInfo info = *((LeaveInfo *) user_data); -+ -+ info.x -= window->x; -+ info.y -= window->y; -+ -+ _gdk_mir_window_transient_children_foreach (window, leave_windows_except, &info); -+ -+ if (window != info.except) -+ { -+ GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); -+ gboolean cursor_inside; -+ MirMotionButton button_state; -+ -+ _gdk_mir_window_impl_get_cursor_state (impl, NULL, NULL, &cursor_inside, &button_state); ++ guint button_state = 0; + -+ if (cursor_inside) -+ generate_crossing_event (window, GDK_LEAVE_NOTIFY, info.x, info.y, info.time); ++ if (mir_pointer_event_button_state (event, mir_pointer_button_primary)) ++ button_state |= mir_pointer_button_primary; ++ if (mir_pointer_event_button_state (event, mir_pointer_button_secondary)) ++ button_state |= mir_pointer_button_secondary; ++ if (mir_pointer_event_button_state (event, mir_pointer_button_tertiary)) ++ button_state |= mir_pointer_button_tertiary; ++ if (mir_pointer_event_button_state (event, mir_pointer_button_back)) ++ button_state |= mir_pointer_button_back; ++ if (mir_pointer_event_button_state (event, mir_pointer_button_forward)) ++ button_state |= mir_pointer_button_forward; + -+ _gdk_mir_window_impl_set_cursor_state (impl, info.x, info.y, FALSE, button_state); -+ } ++ return button_state; +} + static void - handle_motion_event (GdkWindow *window, const MirMotionEvent *event) +-handle_motion_event (GdkWindow *window, const MirMotionEvent *event) ++handle_motion_event (GdkWindow *window, const MirInputEvent *event) { -@@ -284,6 +341,7 @@ handle_motion_event (GdkWindow *window, const MirMotionEvent *event) ++ const MirPointerEvent *pointer_event = mir_input_event_get_pointer_event (event); + GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); + gdouble x, y; gboolean cursor_inside; - MirMotionButton button_state; +- MirMotionButton button_state; ++ guint button_state; guint modifier_state; + guint32 event_time; GdkEventType event_type; - MirMotionButton changed_button_state; +- MirMotionButton changed_button_state; ++ guint changed_button_state; ++ ++ if (!pointer_event) ++ return; -@@ -294,45 +352,87 @@ handle_motion_event (GdkWindow *window, const MirMotionEvent *event) - y = event->pointer_coordinates[0].y; - } - modifier_state = get_modifier_state (event->modifiers, event->button_state); -+ event_time = NANO_TO_MILLI (event->event_time); + _gdk_mir_window_impl_get_cursor_state (impl, &x, &y, &cursor_inside, &button_state); +- if (event->pointer_count > 0) +- { +- x = event->pointer_coordinates[0].x; +- y = event->pointer_coordinates[0].y; +- } +- modifier_state = get_modifier_state (event->modifiers, event->button_state); ++ modifier_state = get_modifier_state (mir_pointer_event_modifiers (pointer_event), mir_pointer_event_get_button_state (pointer_event)); ++ event_time = NANO_TO_MILLI (mir_input_event_get_event_time (event)); - /* The Mir events generate hover-exits even while inside the window so - counteract this by always generating an enter notify on all other events */ - if (!cursor_inside && event->action != mir_motion_action_hover_exit) -+ /* TODO: Remove once we have proper transient window support. */ -+ if (event->action == mir_motion_action_hover_exit) ++ if (window) { - cursor_inside = TRUE; - generate_crossing_event (window, GDK_ENTER_NOTIFY, x, y); - } -+ LeaveInfo info; ++ gdouble new_x; ++ gdouble new_y; ++ gdouble hscroll; ++ gdouble vscroll; ++ ++ /* Update which window has focus */ ++ _gdk_mir_pointer_set_location (get_pointer (window), x, y, window, modifier_state); ++ switch (mir_pointer_event_action (pointer_event)) ++ { ++ case mir_pointer_action_button_up: ++ case mir_pointer_action_button_down: ++ g_print ("%s button up/down\n", G_STRFUNC); ++ ++ event_type = mir_pointer_event_action (pointer_event) == mir_pointer_action_button_down ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE; ++ changed_button_state = button_state ^ mir_pointer_event_get_button_state (pointer_event); ++ if (changed_button_state == 0 || (changed_button_state & mir_pointer_button_primary) != 0) ++ generate_button_event (window, event_type, x, y, GDK_BUTTON_PRIMARY, modifier_state, event_time); ++ if ((changed_button_state & mir_pointer_button_secondary) != 0) ++ generate_button_event (window, event_type, x, y, GDK_BUTTON_SECONDARY, modifier_state, event_time); ++ if ((changed_button_state & mir_pointer_button_tertiary) != 0) ++ generate_button_event (window, event_type, x, y, GDK_BUTTON_MIDDLE, modifier_state, event_time); ++ button_state = mir_pointer_event_get_button_state (pointer_event); ++ break; ++ case mir_pointer_action_motion: ++ new_x = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_x); ++ new_y = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_y); ++ hscroll = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_hscroll); ++ vscroll = mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_vscroll); ++ ++ if (ABS (hscroll) > 0.5 || ABS (vscroll) > 0.5) ++ generate_scroll_event (window, x, y, hscroll, vscroll, modifier_state, event_time); ++ if (ABS (new_x - x) > 0.5 || ABS (new_y - y) > 0.5) ++ { ++ generate_motion_event (window, new_x, new_y, modifier_state, event_time); ++ x = new_x; ++ y = new_y; ++ } - /* Update which window has focus */ - _gdk_mir_pointer_set_location (get_pointer (window), x, y, window, modifier_state); - switch (event->action) -+ info.x = x; -+ info.y = y; -+ info.time = event_time; -+ info.except = window; -+ -+ /* Leave all transient children from leaf to root, except the root since we do it later. */ -+ _gdk_mir_window_transient_children_foreach (window, leave_windows_except, &info); -+ } -+ else - { +- { - case mir_motion_action_down: - case mir_motion_action_up: - event_type = event->action == mir_motion_action_down ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE; @@ -377,99 +566,206 @@ - cursor_inside = FALSE; - generate_crossing_event (window, GDK_LEAVE_NOTIFY, x, y); - break; -+ LeaveInfo info; -+ -+ info.x = x; -+ info.y = y; -+ info.time = event_time; -+ info.except = _gdk_mir_window_get_visible_transient_child (window, x, y, &x, &y); -+ -+ /* Leave all transient children from leaf to root, except the pointer window since we enter it. */ -+ _gdk_mir_window_transient_children_foreach (window, leave_windows_except, &info); -+ -+ window = info.except; -+ -+ if (window) -+ { -+ /* Enter the pointer window. */ -+ gboolean cursor_inside_pointer_window; -+ -+ impl = GDK_MIR_WINDOW_IMPL (window->impl); -+ _gdk_mir_window_impl_get_cursor_state (impl, NULL, NULL, &cursor_inside_pointer_window, NULL); -+ -+ if (!cursor_inside_pointer_window) +- } ++ break; ++ case mir_pointer_action_enter: ++ if (!cursor_inside) + { ++ cursor_inside = TRUE; + generate_crossing_event (window, GDK_ENTER_NOTIFY, x, y, event_time); -+ _gdk_mir_window_impl_set_cursor_state (impl, x, y, TRUE, event->button_state); + } -+ } - } - -- _gdk_mir_window_impl_set_cursor_state (impl, x, y, cursor_inside, button_state); -+ if (window) -+ { -+ /* Update which window has focus */ -+ _gdk_mir_pointer_set_location (get_pointer (window), x, y, window, modifier_state); -+ switch (event->action) -+ { -+ case mir_motion_action_down: -+ case mir_motion_action_up: -+ event_type = event->action == mir_motion_action_down ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE; -+ changed_button_state = button_state ^ event->button_state; -+ if (changed_button_state == 0 || (changed_button_state & mir_motion_button_primary) != 0) -+ generate_button_event (window, event_type, x, y, GDK_BUTTON_PRIMARY, modifier_state, event_time); -+ if ((changed_button_state & mir_motion_button_secondary) != 0) -+ generate_button_event (window, event_type, x, y, GDK_BUTTON_SECONDARY, modifier_state, event_time); -+ if ((changed_button_state & mir_motion_button_tertiary) != 0) -+ generate_button_event (window, event_type, x, y, GDK_BUTTON_MIDDLE, modifier_state, event_time); -+ button_state = event->button_state; -+ break; -+ case mir_motion_action_scroll: -+ generate_scroll_event (window, x, y, event->pointer_coordinates[0].hscroll, event->pointer_coordinates[0].vscroll, modifier_state, event_time); -+ break; -+ case mir_motion_action_move: // move with button -+ case mir_motion_action_hover_move: // move without button -+ generate_motion_event (window, x, y, modifier_state, event_time); + break; -+ case mir_motion_action_hover_exit: ++ case mir_pointer_action_leave: + if (cursor_inside) + { + cursor_inside = FALSE; + generate_crossing_event (window, GDK_LEAVE_NOTIFY, x, y, event_time); + } + break; ++ default: ++ break; + } -+ + +- _gdk_mir_window_impl_set_cursor_state (impl, x, y, cursor_inside, button_state); + _gdk_mir_window_impl_set_cursor_state (impl, x, y, cursor_inside, button_state); + } } static void -@@ -396,9 +496,6 @@ gdk_mir_event_source_queue_event (GdkDisplay *display, + handle_surface_event (GdkWindow *window, const MirSurfaceEvent *event) + { + GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); ++ MirSurfaceState state; + +- switch (event->attrib) ++ switch (mir_surface_event_get_attribute (event)) + { + case mir_surface_attrib_type: +- _gdk_mir_window_impl_set_surface_type (impl, event->value); ++ _gdk_mir_window_impl_set_surface_type (impl, mir_surface_event_get_attribute_value (event)); + break; + case mir_surface_attrib_state: +- _gdk_mir_window_impl_set_surface_state (impl, event->value); +- // FIXME: notify ++ state = mir_surface_event_get_attribute_value (event); ++ _gdk_mir_window_impl_set_surface_state (impl, state); ++ ++ switch (state) ++ { ++ case mir_surface_state_restored: ++ case mir_surface_state_hidden: ++ gdk_synthesize_window_state (window, ++ GDK_WINDOW_STATE_ICONIFIED | ++ GDK_WINDOW_STATE_MAXIMIZED | ++ GDK_WINDOW_STATE_FULLSCREEN, ++ 0); ++ break; ++ case mir_surface_state_minimized: ++ gdk_synthesize_window_state (window, ++ GDK_WINDOW_STATE_MAXIMIZED | ++ GDK_WINDOW_STATE_FULLSCREEN, ++ GDK_WINDOW_STATE_ICONIFIED); ++ break; ++ case mir_surface_state_maximized: ++ case mir_surface_state_vertmaximized: ++ case mir_surface_state_horizmaximized: ++ gdk_synthesize_window_state (window, ++ GDK_WINDOW_STATE_ICONIFIED | ++ GDK_WINDOW_STATE_FULLSCREEN, ++ GDK_WINDOW_STATE_MAXIMIZED); ++ break; ++ case mir_surface_state_fullscreen: ++ gdk_synthesize_window_state (window, ++ GDK_WINDOW_STATE_ICONIFIED | ++ GDK_WINDOW_STATE_MAXIMIZED, ++ GDK_WINDOW_STATE_FULLSCREEN); ++ break; ++ default: ++ break; ++ } ++ + break; + case mir_surface_attrib_swapinterval: + break; + case mir_surface_attrib_focus: +- generate_focus_event (window, event->value != 0); ++ generate_focus_event (window, mir_surface_event_get_attribute_value (event) != 0); + break; + default: + break; +@@ -378,17 +489,25 @@ static void + handle_resize_event (GdkWindow *window, + const MirResizeEvent *event) + { +- window->width = event->width; +- window->height = event->height; ++ window->width = mir_resize_event_get_width (event); ++ window->height = mir_resize_event_get_height (event); + _gdk_window_update_size (window); + +- generate_configure_event (window, event->width, event->height); ++ generate_configure_event (window, mir_resize_event_get_width (event), mir_resize_event_get_height (event)); ++} ++ ++static void ++handle_close_event (GdkWindow *window, ++ const MirCloseSurfaceEvent *event) ++{ ++ send_event (window, get_pointer (window), gdk_event_new (GDK_DESTROY)); ++ gdk_window_destroy_notify (window); + } + + typedef struct + { + GdkWindow *window; +- MirEvent event; ++ MirEvent *event; + } EventData; + + static void +@@ -396,23 +515,39 @@ gdk_mir_event_source_queue_event (GdkDis GdkWindow *window, const MirEvent *event) { - if (g_getenv ("GDK_MIR_LOG_EVENTS")) - _gdk_mir_print_event (event); -- ++ const MirInputEvent *input_event; + // FIXME: Only generate events if the window wanted them? - switch (event->type) +- switch (event->type) ++ switch (mir_event_get_type (event)) { -@@ -459,7 +556,12 @@ gdk_mir_event_source_convert_events (GdkMirEventSource *source) ++ case mir_event_type_input: ++ input_event = mir_event_get_input_event (event); ++ ++ switch (mir_input_event_get_type (input_event)) ++ { ++ case mir_input_event_type_key: ++ handle_key_event (window, input_event); ++ break; ++ case mir_input_event_type_touch: ++ handle_motion_event (window, input_event); ++ break; ++ case mir_input_event_type_pointer: ++ handle_motion_event (window, input_event); ++ break; ++ } ++ ++ break; + case mir_event_type_key: +- handle_key_event (window, &event->key); ++ handle_key_event (window, mir_event_get_input_event (event)); + break; + case mir_event_type_motion: +- handle_motion_event (window, &event->motion); ++ handle_motion_event (window, mir_event_get_input_event (event)); + break; + case mir_event_type_surface: +- handle_surface_event (window, &event->surface); ++ handle_surface_event (window, mir_event_get_surface_event (event)); + break; + case mir_event_type_resize: +- handle_resize_event (window, &event->resize); ++ handle_resize_event (window, mir_event_get_resize_event (event)); + break; + case mir_event_type_prompt_session_state_change: + // FIXME? +@@ -420,8 +555,11 @@ gdk_mir_event_source_queue_event (GdkDis + case mir_event_type_orientation: + // FIXME? + break; ++ case mir_event_type_close_surface: ++ handle_close_event (window, mir_event_get_close_surface_event (event)); ++ break; + default: +- g_warning ("Ignoring unknown Mir event %d", event->type); ++ g_warning ("Ignoring unknown Mir event %d", mir_event_get_type (event)); + // FIXME? + break; + } +@@ -443,6 +581,7 @@ static void + gdk_mir_queued_event_free (GdkMirQueuedEvent *event) + { + _gdk_mir_window_reference_unref (event->window_ref); ++ mir_event_unref (event->event); + g_slice_free (GdkMirQueuedEvent, event); + } + +@@ -459,7 +598,12 @@ gdk_mir_event_source_convert_events (Gdk * event was being dispatched... */ if (window != NULL) - gdk_mir_event_source_queue_event (source->display, window, &event->event); + { + if (source->log_events) -+ _gdk_mir_print_event (&event->event); ++ _gdk_mir_print_event (event->event); + -+ gdk_mir_event_source_queue_event (source->display, window, &event->event); ++ gdk_mir_event_source_queue_event (source->display, window, event->event); + } else g_warning ("window was destroyed before event arrived..."); -@@ -554,6 +656,7 @@ _gdk_mir_event_source_new (GdkDisplay *display) +@@ -554,6 +698,7 @@ _gdk_mir_event_source_new (GdkDisplay *d source = (GdkMirEventSource *) g_source; g_mutex_init (&source->mir_event_lock); source->display = display; @@ -477,11 +773,20 @@ return source; } -diff --git a/gdk/mir/gdkmirkeymap.c b/gdk/mir/gdkmirkeymap.c -index 3e8c829..82f0d2c 100644 ---- a/gdk/mir/gdkmirkeymap.c -+++ b/gdk/mir/gdkmirkeymap.c -@@ -31,6 +31,12 @@ typedef struct GdkMirKeymapClass GdkMirKeymapClass; +@@ -621,7 +766,7 @@ _gdk_mir_event_source_queue (GdkMirWindo + queued_event = g_slice_new (GdkMirQueuedEvent); + g_atomic_int_inc (&window_ref->ref_count); + queued_event->window_ref = window_ref; +- queued_event->event = *event; ++ queued_event->event = mir_event_ref (event); + + g_mutex_lock (&source->mir_event_lock); + g_queue_push_tail (&source->mir_events, queued_event); +Index: gtk+-3.14.13/gdk/mir/gdkmirkeymap.c +=================================================================== +--- gtk+-3.14.13.orig/gdk/mir/gdkmirkeymap.c ++++ gtk+-3.14.13/gdk/mir/gdkmirkeymap.c +@@ -31,6 +31,12 @@ typedef struct GdkMirKeymapClass GdkMirK #define GDK_IS_MIR_KEYMAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_MIR_KEYMAP)) #define GDK_MIR_KEYMAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_MIR_KEYMAP, GdkMirKeymapClass)) @@ -494,7 +799,7 @@ struct GdkMirKeymap { GdkKeymap parent_instance; -@@ -342,6 +348,14 @@ gdk_mir_keymap_get_modifier_state (GdkKeymap *keymap) +@@ -342,6 +348,14 @@ gdk_mir_keymap_get_modifier_state (GdkKe return get_gdk_modifiers (mir_keymap->xkb_keymap, mods); } @@ -509,10 +814,10 @@ static void update_direction (GdkMirKeymap *keymap) { -diff --git a/gdk/mir/gdkmirpointer.c b/gdk/mir/gdkmirpointer.c -index 96c7e74..3937361 100644 ---- a/gdk/mir/gdkmirpointer.c -+++ b/gdk/mir/gdkmirpointer.c +Index: gtk+-3.14.13/gdk/mir/gdkmirpointer.c +=================================================================== +--- gtk+-3.14.13.orig/gdk/mir/gdkmirpointer.c ++++ gtk+-3.14.13/gdk/mir/gdkmirpointer.c @@ -17,6 +17,7 @@ #include "config.h" @@ -521,7 +826,7 @@ #include "gdkdeviceprivate.h" #include "gdkscreen.h" #include "gdkwindow.h" -@@ -183,6 +184,11 @@ gdk_mir_pointer_ungrab (GdkDevice *device, +@@ -183,6 +184,11 @@ gdk_mir_pointer_ungrab (GdkDevice *devic { //g_printerr ("gdk_mir_pointer_ungrab\n"); /* Mir doesn't do grabs */ @@ -533,11 +838,11 @@ } static GdkWindow * -diff --git a/gdk/mir/gdkmirscreen.c b/gdk/mir/gdkmirscreen.c -index 2b53cef..e29ddb3 100644 ---- a/gdk/mir/gdkmirscreen.c -+++ b/gdk/mir/gdkmirscreen.c -@@ -327,35 +327,31 @@ gdk_mir_screen_get_monitor_plug_name (GdkScreen *screen, +Index: gtk+-3.14.13/gdk/mir/gdkmirscreen.c +=================================================================== +--- gtk+-3.14.13.orig/gdk/mir/gdkmirscreen.c ++++ gtk+-3.14.13/gdk/mir/gdkmirscreen.c +@@ -327,35 +327,31 @@ gdk_mir_screen_get_monitor_plug_name (Gd switch (output->type) { case mir_display_output_type_unknown: @@ -582,44 +887,438 @@ } } -diff --git a/gdk/mir/gdkmirwindowimpl.c b/gdk/mir/gdkmirwindowimpl.c -index 6431ed4..37f96dc 100644 ---- a/gdk/mir/gdkmirwindowimpl.c -+++ b/gdk/mir/gdkmirwindowimpl.c -@@ -288,13 +288,22 @@ redraw_transient (GdkWindow *window) - gdk_window_invalidate_rect (GDK_MIR_WINDOW_IMPL (window->impl)->transient_for, &r, FALSE); +Index: gtk+-3.14.13/gdk/mir/gdkmirwindowimpl.c +=================================================================== +--- gtk+-3.14.13.orig/gdk/mir/gdkmirwindowimpl.c ++++ gtk+-3.14.13/gdk/mir/gdkmirwindowimpl.c +@@ -43,11 +43,8 @@ struct _GdkMirWindowImpl + gint transient_x; + gint transient_y; + +- /* Child windows (e.g. tooltips) */ +- GList *transient_children; +- + /* Desired surface attributes */ +- MirSurfaceType surface_type; ++ GdkWindowTypeHint type_hint; + MirSurfaceState surface_state; + + /* Pattern for background */ +@@ -56,7 +53,7 @@ struct _GdkMirWindowImpl + /* Current button state for checking which buttons are being pressed / released */ + gdouble x; + gdouble y; +- MirMotionButton button_state; ++ guint button_state; + + /* Surface being rendered to (only exists when window visible) */ + MirSurface *surface; +@@ -93,9 +90,9 @@ _gdk_mir_window_impl_set_surface_state ( + } + + void +-_gdk_mir_window_impl_set_surface_type (GdkMirWindowImpl *impl, MirSurfaceType type) ++_gdk_mir_window_impl_set_surface_type (GdkMirWindowImpl *impl, ++ MirSurfaceType type) + { +- impl->surface_type = type; + } + + void +@@ -103,7 +100,7 @@ _gdk_mir_window_impl_set_cursor_state (G + gdouble x, + gdouble y, + gboolean cursor_inside, +- MirMotionButton button_state) ++ guint button_state) + { + impl->x = x; + impl->y = y; +@@ -116,7 +113,7 @@ _gdk_mir_window_impl_get_cursor_state (G + gdouble *x, + gdouble *y, + gboolean *cursor_inside, +- MirMotionButton *button_state) ++ guint *button_state) + { + if (x) + *x = impl->x; +@@ -131,16 +128,10 @@ _gdk_mir_window_impl_get_cursor_state (G + static void + gdk_mir_window_impl_init (GdkMirWindowImpl *impl) + { +- impl->surface_type = mir_surface_type_normal; ++ impl->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL; + impl->surface_state = mir_surface_state_unknown; + } + +-static MirConnection * +-get_connection (GdkWindow *window) +-{ +- return gdk_mir_display_get_mir_connection (gdk_window_get_display (window)); +-} +- + static void + set_surface_state (GdkMirWindowImpl *impl, + MirSurfaceState state) +@@ -154,33 +145,146 @@ set_surface_state (GdkMirWindowImpl *imp } -+/* TODO: Remove once we have proper transient window support. */ -+static gboolean -+should_render_in_parent (GdkWindow *window) + static void +-set_surface_type (GdkMirWindowImpl *impl, +- MirSurfaceType type) ++event_cb (MirSurface *surface, ++ const MirEvent *event, ++ void *context) + { +- if (impl->surface_type == type) +- return; ++ _gdk_mir_event_source_queue (context, event); ++} + +- impl->surface_type = type; +- if (impl->surface) +- mir_surface_set_type (impl->surface, type); ++static MirSurface * ++create_mir_surface (GdkDisplay *display, ++ GdkWindow *parent, ++ gint x, ++ gint y, ++ gint width, ++ gint height, ++ GdkWindowTypeHint type, ++ MirBufferUsage buffer_usage) +{ -+ GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); ++ GdkMirWindowImpl *parent_impl; ++ MirSurfaceSpec *spec; ++ MirConnection *connection; ++ MirPixelFormat format; ++ MirSurface *surface; ++ MirRectangle rect; ++ ++ connection = gdk_mir_display_get_mir_connection (display); ++ format = _gdk_mir_display_get_pixel_format (display, buffer_usage); ++ ++ if (parent) ++ parent_impl = GDK_MIR_WINDOW_IMPL (parent->impl); ++ else ++ parent_impl = NULL; ++ ++ switch (type) ++ { ++ case GDK_WINDOW_TYPE_HINT_DIALOG: ++ case GDK_WINDOW_TYPE_HINT_DOCK: ++ spec = mir_connection_create_spec_for_dialog (connection, ++ width, ++ height, ++ format); ++ break; ++ case GDK_WINDOW_TYPE_HINT_MENU: ++ case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU: ++ case GDK_WINDOW_TYPE_HINT_POPUP_MENU: ++ case GDK_WINDOW_TYPE_HINT_TOOLBAR: ++ case GDK_WINDOW_TYPE_HINT_COMBO: ++ rect.left = x; ++ rect.top = y; ++ rect.width = 1; ++ rect.height = 1; ++ spec = mir_connection_create_spec_for_menu (connection, ++ width, ++ height, ++ format, ++ parent_impl ? parent_impl->surface : NULL, ++ &rect, ++ mir_edge_attachment_any); ++ break; ++ case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN: ++ case GDK_WINDOW_TYPE_HINT_UTILITY: ++ spec = mir_connection_create_spec_for_modal_dialog (connection, ++ width, ++ height, ++ format, ++ parent_impl ? parent_impl->surface : NULL); ++ break; ++ case GDK_WINDOW_TYPE_HINT_DND: ++ case GDK_WINDOW_TYPE_HINT_TOOLTIP: ++ case GDK_WINDOW_TYPE_HINT_NOTIFICATION: ++ rect.left = x; ++ rect.top = y; ++ rect.width = 1; ++ rect.height = 1; ++ spec = mir_connection_create_spec_for_tooltip (connection, ++ width, ++ height, ++ format, ++ parent_impl ? parent_impl->surface : NULL, ++ &rect); ++ break; ++ case GDK_WINDOW_TYPE_HINT_NORMAL: ++ case GDK_WINDOW_TYPE_HINT_DESKTOP: ++ default: ++ spec = mir_connection_create_spec_for_normal_surface (connection, ++ width, ++ height, ++ format); ++ break; ++ } ++ ++ mir_surface_spec_set_name (spec, g_get_prgname ()); ++ mir_surface_spec_set_buffer_usage (spec, buffer_usage); ++ surface = mir_surface_create_sync (spec); ++ mir_surface_spec_release (spec); + -+ return impl->transient_for && gdk_window_get_window_type (window) != GDK_WINDOW_TOPLEVEL; ++ return surface; +} + ++static GdkDevice * ++get_pointer (GdkWindow *window) ++{ ++ return gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (gdk_window_get_display (window))); + } + + static void +-event_cb (MirSurface *surface, +- const MirEvent *event, +- void *context) ++send_event (GdkWindow *window, GdkDevice *device, GdkEvent *event) + { +- _gdk_mir_event_source_queue (context, event); ++ GdkDisplay *display; ++ GList *node; ++ ++ gdk_event_set_device (event, device); ++ gdk_event_set_source_device (event, device); ++ gdk_event_set_screen (event, gdk_display_get_screen (gdk_window_get_display (window), 0)); ++ event->any.window = g_object_ref (window); ++ ++ display = gdk_window_get_display (window); ++ node = _gdk_event_queue_append (display, event); ++ _gdk_windowing_got_event (display, node, event, _gdk_display_get_next_serial (display)); + } + + static void +-ensure_surface (GdkWindow *window) ++generate_configure_event (GdkWindow *window, ++ gint width, ++ gint height) ++{ ++ GdkEvent *event; ++ ++ event = gdk_event_new (GDK_CONFIGURE); ++ event->configure.send_event = FALSE; ++ event->configure.width = width; ++ event->configure.height = height; ++ ++ send_event (window, get_pointer (window), event); ++} ++ ++static void ++ensure_surface_full (GdkWindow *window, ++ MirBufferUsage buffer_usage) + { + GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); +- MirPixelFormat formats[mir_pixel_formats], pixel_format = mir_pixel_format_invalid; +- unsigned int n_formats, i; +- MirSurfaceParameters parameters; +- MirEventDelegate event_delegate = { event_cb, NULL }; + GdkMirWindowReference *window_ref; + + if (impl->surface) +@@ -191,42 +295,35 @@ ensure_surface (GdkWindow *window) + */ + window_ref = _gdk_mir_event_source_get_window_reference (window); + +- event_delegate.context = window_ref; ++ impl->surface = create_mir_surface (gdk_window_get_display (window), impl->transient_for, ++ impl->transient_x, impl->transient_y, ++ window->width, window->height, ++ impl->type_hint, ++ buffer_usage); + +- // Should probably calculate this once? +- // Should prefer certain formats over others +- mir_connection_get_available_surface_formats (get_connection (window), formats, mir_pixel_formats, &n_formats); +- for (i = 0; i < n_formats; i++) +- if (formats[i] == mir_pixel_format_argb_8888) +- { +- pixel_format = formats[i]; +- break; +- } +- +- parameters.name = "GTK+ Mir"; +- parameters.width = window->width; +- parameters.height = window->height; +- parameters.pixel_format = pixel_format; +- parameters.buffer_usage = mir_buffer_usage_software; +- parameters.output_id = mir_display_output_id_invalid; +- impl->surface = mir_connection_create_surface_sync (get_connection (window), ¶meters); +- +- MirGraphicsRegion region; +- MirEvent resize_event; +- +- mir_surface_get_graphics_region (impl->surface, ®ion); ++ /* FIXME: can't make an initial resize event */ ++ // MirEvent *resize_event; + + /* Send the initial configure with the size the server gave... */ ++ /* FIXME: can't make an initial resize event */ ++ /* + resize_event.resize.type = mir_event_type_resize; + resize_event.resize.surface_id = 0; +- resize_event.resize.width = region.width; +- resize_event.resize.height = region.height; ++ resize_event.resize.width = window->width; ++ resize_event.resize.height = window->height; + + _gdk_mir_event_source_queue (window_ref, &resize_event); ++ */ + +- mir_surface_set_event_handler (impl->surface, &event_delegate); // FIXME: Ignore some events until shown +- set_surface_type (impl, impl->surface_type); +- set_surface_state (impl, impl->surface_state); ++ generate_configure_event (window, window->width, window->height); ++ ++ mir_surface_set_event_handler (impl->surface, event_cb, window_ref); // FIXME: Ignore some events until shown ++} ++ ++static void ++ensure_surface (GdkWindow *window) ++{ ++ ensure_surface_full (window, mir_buffer_usage_software); + } + + static void +@@ -237,77 +334,25 @@ ensure_no_surface (GdkWindow *window) + if (impl->cairo_surface) + { + cairo_surface_finish (impl->cairo_surface); +- cairo_surface_destroy (impl->cairo_surface); +- impl->cairo_surface = NULL; ++ g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy); + } + +- if (impl->surface) +- { +- mir_surface_release_sync (impl->surface); +- impl->surface = NULL; +- } ++ g_clear_pointer(&impl->surface, mir_surface_release_sync); + } + +-static void +-redraw_transient (GdkWindow *window) +-{ +- GdkRectangle r; +- r.x = window->x; +- r.y = window->y; +- r.width = window->width; +- r.height = window->height; +- gdk_window_invalidate_rect (GDK_MIR_WINDOW_IMPL (window->impl)->transient_for, &r, FALSE); +-} ++// CLEARN ++// CLEARM + static void send_buffer (GdkWindow *window) { GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); - /* Transient windows draw onto parent instead */ +- /* Transient windows draw onto parent instead */ - if (impl->transient_for) -+ if (should_render_in_parent (window)) - { - redraw_transient (window); - return; -@@ -352,7 +361,7 @@ gdk_mir_window_impl_ref_cairo_surface (GdkWindow *window) +- { +- redraw_transient (window); +- return; +- } +- +- /* Composite transient windows over this one */ +- if (impl->transient_children) +- { +- cairo_surface_t *surface; +- cairo_t *c; +- GList *link; +- +- surface = gdk_mir_window_impl_ref_cairo_surface (window); +- c = cairo_create (surface); +- +- for (link = impl->transient_children; link; link = link->next) +- { +- GdkWindow *child_window = link->data; +- GdkMirWindowImpl *child_impl = GDK_MIR_WINDOW_IMPL (child_window->impl); +- +- /* Skip children not yet drawn to */ +- if (!child_impl->cairo_surface) +- continue; +- +- cairo_set_source_surface (c, child_impl->cairo_surface, child_window->x, child_window->y); +- cairo_rectangle (c, child_window->x, child_window->y, child_window->width, child_window->height); +- cairo_fill (c); +- } +- +- cairo_destroy (c); +- cairo_surface_destroy (surface); +- } +- + /* Send the completed buffer to Mir */ +- mir_surface_swap_buffers_sync (impl->surface); ++ mir_buffer_stream_swap_buffers_sync (mir_surface_get_buffer_stream (impl->surface)); + + /* The Cairo context is no longer valid */ +- if (impl->cairo_surface) +- { +- cairo_surface_destroy (impl->cairo_surface); +- impl->cairo_surface = NULL; +- } ++ g_clear_pointer (&impl->cairo_surface, cairo_surface_destroy); + } + + static cairo_surface_t * +@@ -316,7 +361,7 @@ gdk_mir_window_impl_ref_cairo_surface (G + //g_printerr ("gdk_mir_window_impl_ref_cairo_surface window=%p\n", window); + GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); + MirGraphicsRegion region; +- cairo_format_t pixel_format = CAIRO_FORMAT_INVALID; ++ cairo_format_t pixel_format = CAIRO_FORMAT_ARGB32; + cairo_surface_t *cairo_surface; + cairo_t *c; + +@@ -327,31 +372,16 @@ gdk_mir_window_impl_ref_cairo_surface (G } /* Transient windows get rendered into a buffer and copied onto their parent */ - if (impl->transient_for) -+ if (should_render_in_parent (window)) ++ //if (should_render_in_parent (window)) { - cairo_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, window->width, window->height); +- cairo_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, window->width, window->height); ++ //cairo_surface = cairo_image_surface_create (pixel_format, window->width, window->height); } -@@ -373,13 +382,13 @@ gdk_mir_window_impl_ref_cairo_surface (GdkWindow *window) +- else ++ //else + { + ensure_surface (window); + +- mir_surface_get_graphics_region (impl->surface, ®ion); +- +- // FIXME: Should calculate this once +- switch (region.pixel_format) +- { +- case mir_pixel_format_argb_8888: +- pixel_format = CAIRO_FORMAT_ARGB32; +- break; +- default: +- case mir_pixel_format_abgr_8888: +- case mir_pixel_format_xbgr_8888: +- case mir_pixel_format_xrgb_8888: +- case mir_pixel_format_bgr_888: +- // uh-oh... +- g_printerr ("Unsupported pixel format %d\n", region.pixel_format); +- break; +- } ++ mir_buffer_stream_get_graphics_region (mir_surface_get_buffer_stream (impl->surface), ®ion); ++ g_assert (region.pixel_format == mir_pixel_format_argb_8888); + + cairo_surface = cairo_image_surface_create_for_data ((unsigned char *) region.vaddr, + pixel_format, +@@ -363,13 +393,13 @@ gdk_mir_window_impl_ref_cairo_surface (G impl->cairo_surface = cairo_surface_reference (cairo_surface); /* Draw background */ @@ -639,33 +1338,55 @@ return cairo_surface; } -@@ -446,10 +455,11 @@ gdk_mir_window_impl_hide (GdkWindow *window) +@@ -388,13 +418,6 @@ static void + gdk_mir_window_impl_finalize (GObject *object) + { + GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (object); +- GList *link; +- +- for (link = impl->transient_children; link; link = link->next) +- { +- GdkWindow *window = link->data; +- gdk_window_destroy (window); +- } + + if (impl->background) + cairo_pattern_destroy (impl->background); +@@ -402,7 +425,6 @@ gdk_mir_window_impl_finalize (GObject *o + mir_surface_release_sync (impl->surface); + if (impl->cairo_surface) + cairo_surface_destroy (impl->cairo_surface); +- g_list_free (impl->transient_children); + + G_OBJECT_CLASS (gdk_mir_window_impl_parent_class)->finalize (object); + } +@@ -433,11 +455,9 @@ gdk_mir_window_impl_hide (GdkWindow *win //g_printerr ("gdk_mir_window_impl_hide window=%p\n", window); GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); + impl->cursor_inside = FALSE; impl->visible = FALSE; ensure_no_surface (window); - +- - if (impl->transient_for) -+ if (should_render_in_parent (window)) - redraw_transient (window); +- redraw_transient (window); } -@@ -459,10 +469,11 @@ gdk_mir_window_impl_withdraw (GdkWindow *window) + static void +@@ -446,11 +466,9 @@ gdk_mir_window_impl_withdraw (GdkWindow //g_printerr ("gdk_mir_window_impl_withdraw window=%p\n", window); GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); + impl->cursor_inside = FALSE; impl->visible = FALSE; ensure_no_surface (window); - +- - if (impl->transient_for) -+ if (should_render_in_parent (window)) - redraw_transient (window); +- redraw_transient (window); } -@@ -505,6 +516,7 @@ gdk_mir_window_impl_move_resize (GdkWindow *window, + static void +@@ -492,6 +510,7 @@ gdk_mir_window_impl_move_resize (GdkWind gint width, gint height) { @@ -673,36 +1394,60 @@ g_printerr ("gdk_mir_window_impl_move_resize"); g_printerr (" window=%p", window); if (with_move) -@@ -512,16 +524,17 @@ gdk_mir_window_impl_move_resize (GdkWindow *window, +@@ -499,24 +518,18 @@ gdk_mir_window_impl_move_resize (GdkWind if (width > 0) g_printerr (" size=%dx%dpx", width, height); g_printerr ("\n"); + */ GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); - - /* Redraw parent where we moved from */ +- +- /* Redraw parent where we moved from */ - if (impl->transient_for) -+ if (should_render_in_parent (window)) - redraw_transient (window); +- redraw_transient (window); ++ gboolean recreate_surface = FALSE; /* Transient windows can move wherever they want */ if (with_move) { - if (impl->transient_for) -+ if (should_render_in_parent (window)) +- { +- window->x = x; +- window->y = y; +- } +- else ++ if (x != impl->transient_x || y != impl->transient_y) { - window->x = x; - window->y = y; -@@ -548,7 +561,7 @@ gdk_mir_window_impl_move_resize (GdkWindow *window, + impl->transient_x = x; + impl->transient_y = y; ++ recreate_surface = TRUE; + } + } + +@@ -526,17 +539,14 @@ gdk_mir_window_impl_move_resize (GdkWind + /* We accept any resize */ + window->width = width; + window->height = height; +- +- if (impl->surface) +- { +- ensure_no_surface (window); +- ensure_surface (window); +- } ++ recreate_surface = TRUE; } - /* Redraw parent where we moved to */ +- /* Redraw parent where we moved to */ - if (impl->transient_for) -+ if (should_render_in_parent (window)) - redraw_transient (window); +- redraw_transient (window); ++ if (recreate_surface && impl->surface) ++ { ++ ensure_no_surface (window); ++ ensure_surface (window); ++ } } -@@ -711,7 +724,7 @@ gdk_mir_window_impl_input_shape_combine_region (GdkWindow *window, + static void +@@ -699,7 +709,7 @@ gdk_mir_window_impl_input_shape_combine_ gint offset_x, gint offset_y) { @@ -711,16 +1456,101 @@ } static void -@@ -725,7 +738,7 @@ gdk_mir_window_impl_destroy (GdkWindow *window, +@@ -712,16 +722,6 @@ gdk_mir_window_impl_destroy (GdkWindow * + impl->visible = FALSE; ensure_no_surface (window); - +- - if (impl->transient_for) -+ if (should_render_in_parent (window)) +- { +- /* Redraw parent */ +- redraw_transient (window); +- +- /* Remove from transient list */ +- GdkMirWindowImpl *parent_impl = GDK_MIR_WINDOW_IMPL (impl->transient_for->impl); +- parent_impl->transient_children = g_list_remove (parent_impl->transient_children, window); +- } + } + + static void +@@ -741,41 +741,13 @@ static void + gdk_mir_window_impl_set_type_hint (GdkWindow *window, + GdkWindowTypeHint hint) + { +- MirSurfaceType mir_type = mir_surface_type_normal; ++ GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); + +- switch (hint) ++ if (hint != impl->type_hint) { - /* Redraw parent */ - redraw_transient (window); -@@ -862,7 +875,7 @@ static void +- case GDK_WINDOW_TYPE_HINT_NORMAL: +- case GDK_WINDOW_TYPE_HINT_DOCK: +- case GDK_WINDOW_TYPE_HINT_DESKTOP: +- mir_type = mir_surface_type_normal; +- break; +- case GDK_WINDOW_TYPE_HINT_DIALOG: +- mir_type = mir_surface_type_dialog; +- break; +- case GDK_WINDOW_TYPE_HINT_UTILITY: +- mir_type = mir_surface_type_utility; +- break; +- case GDK_WINDOW_TYPE_HINT_MENU: +- case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU: +- case GDK_WINDOW_TYPE_HINT_POPUP_MENU: +- case GDK_WINDOW_TYPE_HINT_COMBO: +- mir_type = mir_surface_type_menu; +- break; +- case GDK_WINDOW_TYPE_HINT_TOOLTIP: +- mir_type = mir_surface_type_tip; +- break; +- case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN: +- case GDK_WINDOW_TYPE_HINT_DND: +- case GDK_WINDOW_TYPE_HINT_NOTIFICATION: +- mir_type = mir_surface_type_overlay; +- break; +- case GDK_WINDOW_TYPE_HINT_TOOLBAR: +- mir_type = mir_surface_type_satellite; +- break; ++ impl->type_hint = hint; ++ ensure_no_surface (window); + } +- +- set_surface_type (GDK_MIR_WINDOW_IMPL (window->impl), mir_type); + } + + static GdkWindowTypeHint +@@ -783,29 +755,7 @@ gdk_mir_window_impl_get_type_hint (GdkWi + { + GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); + +- switch (impl->surface_type) +- { +- case mir_surface_type_normal: +- case mir_surface_type_freestyle: +- case mir_surface_type_inputmethod: +- return GDK_WINDOW_TYPE_HINT_NORMAL; +- case mir_surface_type_utility: +- return GDK_WINDOW_TYPE_HINT_UTILITY; +- case mir_surface_type_dialog: +- return GDK_WINDOW_TYPE_HINT_DIALOG; +- case mir_surface_type_tip: +- return GDK_WINDOW_TYPE_HINT_TOOLTIP; +- case mir_surface_type_menu: +- return GDK_WINDOW_TYPE_HINT_MENU; +- case mir_surface_type_overlay: +- return GDK_WINDOW_TYPE_HINT_NOTIFICATION; +- case mir_surface_type_satellite: +- return GDK_WINDOW_TYPE_HINT_TOOLBAR; +- case mir_surface_types: +- break; +- } +- +- return GDK_WINDOW_TYPE_HINT_NORMAL; ++ return impl->type_hint; + } + + void +@@ -850,7 +800,7 @@ static void gdk_mir_window_impl_set_title (GdkWindow *window, const gchar *title) { @@ -729,69 +1559,29 @@ } static void -@@ -893,7 +906,7 @@ gdk_mir_window_impl_set_transient_for (GdkWindow *window, +@@ -881,21 +831,6 @@ gdk_mir_window_impl_set_transient_for (G /* Link this window to the parent */ impl->transient_for = parent; - if (parent) -+ if (should_render_in_parent (window)) - { - GdkMirWindowImpl *parent_impl = GDK_MIR_WINDOW_IMPL (parent->impl); - parent_impl->transient_children = g_list_append (parent_impl->transient_children, window); -@@ -907,7 +920,51 @@ gdk_mir_window_impl_set_transient_for (GdkWindow *window, - } - - /* Remove surface if we had made one before this was set */ +- { +- GdkMirWindowImpl *parent_impl = GDK_MIR_WINDOW_IMPL (parent->impl); +- parent_impl->transient_children = g_list_append (parent_impl->transient_children, window); +- +- /* Move to where the client requested */ +- window->x = impl->transient_x; +- window->y = impl->transient_y; +- +- /* Redraw onto parent */ +- redraw_transient (window); +- } +- +- /* Remove surface if we had made one before this was set */ - ensure_no_surface (window); -+ if (should_render_in_parent (window)) -+ ensure_no_surface (window); -+} -+ -+/* TODO: Remove once we have proper transient window support. */ -+GdkWindow * -+_gdk_mir_window_get_visible_transient_child (GdkWindow *window, -+ gdouble x, -+ gdouble y, -+ gdouble *out_x, -+ gdouble *out_y) -+{ -+ GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); -+ GdkWindow *child = NULL; -+ GList *i; -+ -+ x -= window->x; -+ y -= window->y; -+ -+ if (x < 0 || x >= window->width || y < 0 || y >= window->height) -+ return NULL; -+ -+ for (i = impl->transient_children; i && !child; i = i->next) -+ { -+ if (GDK_MIR_WINDOW_IMPL (GDK_WINDOW (i->data)->impl)->visible) -+ child = _gdk_mir_window_get_visible_transient_child (i->data, x, y, out_x, out_y); -+ } -+ -+ if (child) -+ return child; -+ -+ *out_x = x; -+ *out_y = y; -+ -+ return window; -+} -+ -+/* TODO: Remove once we have proper transient window support. */ -+void -+_gdk_mir_window_transient_children_foreach (GdkWindow *window, -+ void (*func) (GdkWindow *, gpointer), -+ gpointer user_data) -+{ -+ GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl); -+ g_list_foreach (impl->transient_children, (GFunc) func, user_data); } static void -@@ -1254,7 +1311,7 @@ gdk_mir_window_impl_set_shadow_width (GdkWindow *window, +@@ -1242,7 +1177,7 @@ gdk_mir_window_impl_set_shadow_width (Gd gint top, gint bottom) { @@ -800,6 +1590,376 @@ } static void --- -2.1.4 - +Index: gtk+-3.14.13/gdk/mir/gdkmir-debug.c +=================================================================== +--- gtk+-3.14.13.orig/gdk/mir/gdkmir-debug.c ++++ gtk+-3.14.13/gdk/mir/gdkmir-debug.c +@@ -21,225 +21,132 @@ void + _gdk_mir_print_modifiers (unsigned int modifiers) + { + g_printerr (" Modifiers"); +- if ((modifiers & mir_key_modifier_alt) != 0) ++ if ((modifiers & mir_input_event_modifier_alt) != 0) + g_printerr (" alt"); +- if ((modifiers & mir_key_modifier_alt_left) != 0) ++ if ((modifiers & mir_input_event_modifier_alt_left) != 0) + g_printerr (" alt-left"); +- if ((modifiers & mir_key_modifier_alt_right) != 0) ++ if ((modifiers & mir_input_event_modifier_alt_right) != 0) + g_printerr (" alt-right"); +- if ((modifiers & mir_key_modifier_shift) != 0) ++ if ((modifiers & mir_input_event_modifier_shift) != 0) + g_printerr (" shift"); +- if ((modifiers & mir_key_modifier_shift_left) != 0) ++ if ((modifiers & mir_input_event_modifier_shift_left) != 0) + g_printerr (" shift-left"); +- if ((modifiers & mir_key_modifier_shift_right) != 0) ++ if ((modifiers & mir_input_event_modifier_shift_right) != 0) + g_printerr (" shift-right"); +- if ((modifiers & mir_key_modifier_sym) != 0) ++ if ((modifiers & mir_input_event_modifier_sym) != 0) + g_printerr (" sym"); +- if ((modifiers & mir_key_modifier_function) != 0) ++ if ((modifiers & mir_input_event_modifier_function) != 0) + g_printerr (" function"); +- if ((modifiers & mir_key_modifier_ctrl) != 0) ++ if ((modifiers & mir_input_event_modifier_ctrl) != 0) + g_printerr (" ctrl"); +- if ((modifiers & mir_key_modifier_ctrl_left) != 0) ++ if ((modifiers & mir_input_event_modifier_ctrl_left) != 0) + g_printerr (" ctrl-left"); +- if ((modifiers & mir_key_modifier_ctrl_right) != 0) ++ if ((modifiers & mir_input_event_modifier_ctrl_right) != 0) + g_printerr (" ctrl-right"); +- if ((modifiers & mir_key_modifier_meta) != 0) ++ if ((modifiers & mir_input_event_modifier_meta) != 0) + g_printerr (" meta"); +- if ((modifiers & mir_key_modifier_meta_left) != 0) ++ if ((modifiers & mir_input_event_modifier_meta_left) != 0) + g_printerr (" meta-left"); +- if ((modifiers & mir_key_modifier_meta_right) != 0) ++ if ((modifiers & mir_input_event_modifier_meta_right) != 0) + g_printerr (" meta-right"); +- if ((modifiers & mir_key_modifier_caps_lock) != 0) ++ if ((modifiers & mir_input_event_modifier_caps_lock) != 0) + g_printerr (" caps-lock"); +- if ((modifiers & mir_key_modifier_num_lock) != 0) ++ if ((modifiers & mir_input_event_modifier_num_lock) != 0) + g_printerr (" num-lock"); +- if ((modifiers & mir_key_modifier_scroll_lock) != 0) ++ if ((modifiers & mir_input_event_modifier_scroll_lock) != 0) + g_printerr (" scroll-lock"); + g_printerr ("\n"); + } + + void +-_gdk_mir_print_key_event (const MirKeyEvent *event) ++_gdk_mir_print_key_event (const MirInputEvent *event) + { ++ const MirKeyboardEvent *keyboard_event = mir_input_event_get_keyboard_event (event); ++ ++ if (!keyboard_event) ++ return; ++ + g_printerr ("KEY\n"); +- g_printerr (" Device %i\n", event->device_id); +- g_printerr (" Source %i\n", event->source_id); ++ g_printerr (" Device %lld\n", (long long int) mir_input_event_get_device_id (event)); + g_printerr (" Action "); +- switch (event->action) ++ switch (mir_keyboard_event_action (keyboard_event)) + { +- case mir_key_action_down: ++ case mir_keyboard_action_down: + g_printerr ("down"); + break; +- case mir_key_action_up: ++ case mir_keyboard_action_up: + g_printerr ("up"); + break; +- case mir_key_action_multiple: +- g_printerr ("multiple"); ++ case mir_keyboard_action_repeat: ++ g_printerr ("repeat"); + break; + default: +- g_printerr ("%u", event->action); ++ g_printerr ("%u", mir_keyboard_event_action (keyboard_event)); + break; + } + g_printerr ("\n"); +- g_printerr (" Flags"); +- if ((event->flags & mir_key_flag_woke_here) != 0) +- g_printerr (" woke-here"); +- if ((event->flags & mir_key_flag_soft_keyboard) != 0) +- g_printerr (" soft-keyboard"); +- if ((event->flags & mir_key_flag_keep_touch_mode) != 0) +- g_printerr (" keep-touch-mode"); +- if ((event->flags & mir_key_flag_from_system) != 0) +- g_printerr (" from-system"); +- if ((event->flags & mir_key_flag_editor_action) != 0) +- g_printerr (" editor-action"); +- if ((event->flags & mir_key_flag_canceled) != 0) +- g_printerr (" canceled"); +- if ((event->flags & mir_key_flag_virtual_hard_key) != 0) +- g_printerr (" virtual-hard-key"); +- if ((event->flags & mir_key_flag_long_press) != 0) +- g_printerr (" long-press"); +- if ((event->flags & mir_key_flag_canceled_long_press) != 0) +- g_printerr (" canceled-long-press"); +- if ((event->flags & mir_key_flag_tracking) != 0) +- g_printerr (" tracking"); +- if ((event->flags & mir_key_flag_fallback) != 0) +- g_printerr (" fallback"); +- g_printerr ("\n"); +- _gdk_mir_print_modifiers (event->modifiers); +- g_printerr (" Key Code %i\n", event->key_code); +- g_printerr (" Scan Code %i\n", event->scan_code); +- g_printerr (" Repeat Count %i\n", event->repeat_count); +- g_printerr (" Down Time %lli\n", (long long int) event->down_time); +- g_printerr (" Event Time %lli\n", (long long int) event->event_time); +- g_printerr (" Is System Key %s\n", event->is_system_key ? "true" : "false"); ++ _gdk_mir_print_modifiers (mir_keyboard_event_modifiers (keyboard_event)); ++ g_printerr (" Key Code %i\n", mir_keyboard_event_key_code (keyboard_event)); ++ g_printerr (" Scan Code %i\n", mir_keyboard_event_scan_code (keyboard_event)); ++ g_printerr (" Event Time %lli\n", (long long int) mir_input_event_get_event_time (event)); + } + + void +-_gdk_mir_print_motion_event (const MirMotionEvent *event) ++_gdk_mir_print_motion_event (const MirInputEvent *event) + { +- size_t i; ++ const MirPointerEvent *pointer_event = mir_input_event_get_pointer_event (event); ++ ++ if (!pointer_event) ++ return; + + g_printerr ("MOTION\n"); +- g_printerr (" Device %i\n", event->device_id); +- g_printerr (" Source %i\n", event->source_id); ++ g_printerr (" Device %lld\n", (long long int) mir_input_event_get_device_id (event)); + g_printerr (" Action "); +- switch (event->action) ++ switch (mir_pointer_event_action (pointer_event)) + { +- case mir_motion_action_down: ++ case mir_pointer_action_button_down: + g_printerr ("down"); + break; +- case mir_motion_action_up: ++ case mir_pointer_action_button_up: + g_printerr ("up"); + break; +- case mir_motion_action_move: +- g_printerr ("move"); +- break; +- case mir_motion_action_cancel: +- g_printerr ("cancel"); +- break; +- case mir_motion_action_outside: +- g_printerr ("outside"); +- break; +- case mir_motion_action_pointer_down: +- g_printerr ("pointer-down"); +- break; +- case mir_motion_action_pointer_up: +- g_printerr ("pointer-up"); +- break; +- case mir_motion_action_hover_move: +- g_printerr ("hover-move"); ++ case mir_pointer_action_enter: ++ g_printerr ("enter"); + break; +- case mir_motion_action_scroll: +- g_printerr ("scroll"); ++ case mir_pointer_action_leave: ++ g_printerr ("leave"); + break; +- case mir_motion_action_hover_enter: +- g_printerr ("hover-enter"); +- break; +- case mir_motion_action_hover_exit: +- g_printerr ("hover-exit"); ++ case mir_pointer_action_motion: ++ g_printerr ("motion"); + break; + default: +- g_printerr ("%u", event->action); +- } +- g_printerr ("\n"); +- g_printerr (" Flags"); +- switch (event->flags) +- { +- case mir_motion_flag_window_is_obscured: +- g_printerr (" window-is-obscured"); +- break; ++ g_printerr ("%u", mir_pointer_event_action (pointer_event)); + } + g_printerr ("\n"); +- _gdk_mir_print_modifiers (event->modifiers); +- g_printerr (" Edge Flags %i\n", event->edge_flags); ++ _gdk_mir_print_modifiers (mir_pointer_event_modifiers (pointer_event)); + g_printerr (" Button State"); +- switch (event->button_state) +- { +- case mir_motion_button_primary: +- g_printerr (" primary"); +- break; +- case mir_motion_button_secondary: +- g_printerr (" secondary"); +- break; +- case mir_motion_button_tertiary: +- g_printerr (" tertiary"); +- break; +- case mir_motion_button_back: +- g_printerr (" back"); +- break; +- case mir_motion_button_forward: +- g_printerr (" forward"); +- break; +- } +- g_printerr ("\n"); +- g_printerr (" Offset (%f, %f)\n", event->x_offset, event->y_offset); +- g_printerr (" Precision (%f, %f)\n", event->x_precision, event->y_precision); +- g_printerr (" Down Time %lli\n", (long long int) event->down_time); +- g_printerr (" Event Time %lli\n", (long long int) event->event_time); +- g_printerr (" Pointer Coordinates\n"); +- for (i = 0; i < event->pointer_count; i++) +- { +- g_printerr (" ID=%i location=(%f, %f) raw=(%f, %f) touch=(%f, %f) size=%f pressure=%f orientation=%f scroll=(%f, %f) tool=", +- event->pointer_coordinates[i].id, +- event->pointer_coordinates[i].x, event->pointer_coordinates[i].y, +- event->pointer_coordinates[i].raw_x, event->pointer_coordinates[i].raw_y, +- event->pointer_coordinates[i].touch_major, event->pointer_coordinates[i].touch_minor, +- event->pointer_coordinates[i].size, +- event->pointer_coordinates[i].pressure, +- event->pointer_coordinates[i].orientation, +- event->pointer_coordinates[i].hscroll, event->pointer_coordinates[i].vscroll); +- switch (event->pointer_coordinates[i].tool_type) +- { +- case mir_motion_tool_type_unknown: +- g_printerr ("unknown"); +- break; +- case mir_motion_tool_type_finger: +- g_printerr ("finger"); +- break; +- case mir_motion_tool_type_stylus: +- g_printerr ("stylus"); +- break; +- case mir_motion_tool_type_mouse: +- g_printerr ("mouse"); +- break; +- case mir_motion_tool_type_eraser: +- g_printerr ("eraser"); +- break; +- default: +- g_printerr ("%u", event->pointer_coordinates[i].tool_type); +- break; +- } +- g_printerr ("\n"); +- } ++ if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_primary)) ++ g_printerr (" primary"); ++ if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_secondary)) ++ g_printerr (" secondary"); ++ if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_tertiary)) ++ g_printerr (" tertiary"); ++ if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_back)) ++ g_printerr (" back"); ++ if (mir_pointer_event_button_state (pointer_event, mir_pointer_button_forward)) ++ g_printerr (" forward"); ++ g_printerr ("\n"); ++ g_printerr (" Offset (%f, %f)\n", mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_x), ++ mir_pointer_event_axis_value (pointer_event, mir_pointer_axis_y)); ++ g_printerr (" Event Time %lli\n", (long long int) mir_input_event_get_event_time (event)); + } + + void + _gdk_mir_print_surface_event (const MirSurfaceEvent *event) + { + g_printerr ("SURFACE\n"); +- g_printerr (" Surface %i\n", event->id); + g_printerr (" Attribute "); +- switch (event->attrib) ++ switch (mir_surface_event_get_attribute (event)) + { + case mir_surface_attrib_type: + g_printerr ("type"); +@@ -254,40 +161,66 @@ _gdk_mir_print_surface_event (const MirS + g_printerr ("focus"); + break; + default: +- g_printerr ("%u", event->attrib); ++ g_printerr ("%u", mir_surface_event_get_attribute (event)); + break; + } + g_printerr ("\n"); +- g_printerr (" Value %i\n", event->value); ++ g_printerr (" Value %i\n", mir_surface_event_get_attribute_value (event)); + } + + void + _gdk_mir_print_resize_event (const MirResizeEvent *event) + { + g_printerr ("RESIZE\n"); +- g_printerr (" Surface %i\n", event->surface_id); +- g_printerr (" Size (%i, %i)\n", event->width, event->height); ++ g_printerr (" Size (%i, %i)\n", mir_resize_event_get_width (event), mir_resize_event_get_height (event)); ++} ++ ++void ++_gdk_mir_print_close_event (const MirCloseSurfaceEvent *event) ++{ ++ g_printerr ("CLOSED\n"); + } + + void + _gdk_mir_print_event (const MirEvent *event) + { +- switch (event->type) ++ const MirInputEvent *input_event; ++ ++ switch (mir_event_get_type (event)) + { ++ case mir_event_type_input: ++ input_event = mir_event_get_input_event (event); ++ ++ switch (mir_input_event_get_type (input_event)) ++ { ++ case mir_input_event_type_key: ++ _gdk_mir_print_key_event (mir_event_get_input_event (event)); ++ break; ++ case mir_input_event_type_touch: ++ _gdk_mir_print_motion_event (mir_event_get_input_event (event)); ++ break; ++ case mir_input_event_type_pointer: ++ _gdk_mir_print_motion_event (mir_event_get_input_event (event)); ++ break; ++ } ++ break; + case mir_event_type_key: +- _gdk_mir_print_key_event (&event->key); ++ _gdk_mir_print_key_event (mir_event_get_input_event (event)); + break; + case mir_event_type_motion: +- _gdk_mir_print_motion_event (&event->motion); ++ _gdk_mir_print_motion_event (mir_event_get_input_event (event)); + break; + case mir_event_type_surface: +- _gdk_mir_print_surface_event (&event->surface); ++ _gdk_mir_print_surface_event (mir_event_get_surface_event (event)); + break; + case mir_event_type_resize: +- _gdk_mir_print_resize_event (&event->resize); ++ _gdk_mir_print_resize_event (mir_event_get_resize_event (event)); ++ break; ++ case mir_event_type_close_surface: ++ _gdk_mir_print_close_event (mir_event_get_close_surface_event (event)); + break; + default: +- g_printerr ("EVENT %u\n", event->type); ++ g_printerr ("EVENT %u\n", mir_event_get_type (event)); + break; + } + } diff -Nru gtk+3.0-3.14.15/debian/rules gtk+3.0-3.14.15/debian/rules --- gtk+3.0-3.14.15/debian/rules 2015-08-24 15:26:44.000000000 +0000 +++ gtk+3.0-3.14.15/debian/rules 2015-09-07 08:18:50.000000000 +0000 @@ -75,10 +75,6 @@ --enable-cloudprint \ --disable-static -ifneq (,$(filter $(DEB_HOST_ARCH), amd64 arm64 armhf i386)) - DEB_CONFIGURE_FLAGS_shared += --enable-mir-backend -endif - ifeq (,$(filter stage1,$(DEB_BUILD_PROFILES))) DEB_CONFIGURE_FLAGS_shared += --enable-colord else @@ -86,9 +82,9 @@ endif ifeq (linux,$(DEB_HOST_ARCH_OS)) -DEB_CONFIGURE_FLAGS_shared += --enable-wayland-backend +DEB_CONFIGURE_FLAGS_shared += --enable-wayland-backend --enable-mir-backend else -DEB_CONFIGURE_FLAGS_shared += --disable-wayland-backend +DEB_CONFIGURE_FLAGS_shared += --disable-wayland-backend --disable-mir-backend endif DEB_CONFIGURE_FLAGS_shared_udeb = \