diff options
Diffstat (limited to 'recipes-qt/qt5/qtwayland')
10 files changed, 3102 insertions, 0 deletions
diff --git a/recipes-qt/qt5/qtwayland/0001-protocol-update-3rd-party-ivi-application-protocol.patch b/recipes-qt/qt5/qtwayland/0001-protocol-update-3rd-party-ivi-application-protocol.patch new file mode 100644 index 000000000..c91e11704 --- /dev/null +++ b/recipes-qt/qt5/qtwayland/0001-protocol-update-3rd-party-ivi-application-protocol.patch @@ -0,0 +1,56 @@ +From 8caaf802a8b42e9bb1d74fc335a571882c75d73e Mon Sep 17 00:00:00 2001 +From: Holger Behrens <holger.behrens@windriver.com> +Date: Tue, 3 Feb 2015 09:52:52 +0100 +Subject: [meta-ivi-demo][PATCH 1/2] protocol: update 3rd party ivi-application + protocol + +Signed-off-by: Holger Behrens <holger.behrens@windriver.com> +--- + src/3rdparty/protocol/ivi-application.xml | 31 +++---------------------------- + 1 file changed, 3 insertions(+), 28 deletions(-) + +diff --git a/src/3rdparty/protocol/ivi-application.xml b/src/3rdparty/protocol/ivi-application.xml +index 833fd38..b06ae6c 100644 +--- a/src/3rdparty/protocol/ivi-application.xml ++++ b/src/3rdparty/protocol/ivi-application.xml +@@ -42,34 +42,9 @@ + <arg name="visibility" type="int"/> + </event> + +- <enum name="warning_code"> +- <description summary="possible warning codes returned by ivi compositor"> +- These define all possible warning codes returned by ivi compositor on server-side warnings. +- invalid_wl_surface: +- - wl_surface already has a another role. +- - wl_surface is destroyed before the ivi_surface is destroyed. +- ivi_id_in_use: ivi_id is already assigned by another application. +- </description> +- <entry name="invalid_wl_surface" value="1" summary="wl_surface is invalid"/> +- <entry name="ivi_id_in_use" value="2" summary="ivi_id is in use and can not be shared"/> +- </enum> +- +- <event name="warning"> +- <description summary="server-side warning detected"> +- The ivi compositor encountered warning while processing a request by this +- application. The warning is defined by argument warning_code and optional +- warning_text. If the warning is detected, client shall destroy the ivi_surface +- object. +- +- When a warning event is sent, the compositor turns the ivi_surface object inert. +- The ivi_surface will not deliver further events, all requests on it are ignored +- except 'destroy', and the association to the ivi_id is removed. The client +- should destroy the ivi_surface object. If an inert ivi_surface object is used as +- an argument to any other object's request, that request will [produce a fatal +- error / produce a warning / be ignored]. +- </description> +- <arg name="warning_code" type="int"/> +- <arg name="warning_text" type="string" allow-null="true"/> ++ <event name="configure"> ++ <arg name="width" type="int"/> ++ <arg name="height" type="int"/> + </event> + + </interface> +-- +2.2.1 + diff --git a/recipes-qt/qt5/qtwayland/0002-qwaylandwindow-add-support-for-IVI-Surface-ID-proper.patch b/recipes-qt/qt5/qtwayland/0002-qwaylandwindow-add-support-for-IVI-Surface-ID-proper.patch new file mode 100644 index 000000000..591ef71c5 --- /dev/null +++ b/recipes-qt/qt5/qtwayland/0002-qwaylandwindow-add-support-for-IVI-Surface-ID-proper.patch @@ -0,0 +1,34 @@ +From 31c60aedf415fd06b5c1aa16fdcef1504b67b96d Mon Sep 17 00:00:00 2001 +From: Holger Behrens <holger.behrens@windriver.com> +Date: Tue, 3 Feb 2015 09:53:43 +0100 +Subject: [meta-ivi-demo][PATCH 2/2] qwaylandwindow: add support for + IVI-Surface-ID property + +Signed-off-by: Holger Behrens <holger.behrens@windriver.com> +--- + src/client/qwaylandwindow.cpp | 9 ++++++++- + 1 file changed, 8 insertions(+), 1 deletion(-) + +diff --git a/src/client/qwaylandwindow.cpp b/src/client/qwaylandwindow.cpp +index 45a58f2..781081a 100644 +--- a/src/client/qwaylandwindow.cpp ++++ b/src/client/qwaylandwindow.cpp +@@ -100,7 +100,14 @@ QWaylandWindow::QWaylandWindow(QWindow *window) + + if (!(window->flags() & Qt::BypassWindowManagerHint)) { + if (mDisplay->shellIvi()) { +- mShellSurface = new QWaylandIviSurface(mDisplay->shellIvi()->surface_create(IVI_SURFACE_ID + getpid(), object()), this); ++ unsigned int id = 0; ++ QVariant value = window->property("IVI-Surface-ID"); ++ if (value.isValid()) { ++ id = value.toUInt(); ++ } else { ++ id = IVI_SURFACE_ID + getpid(); ++ } ++ mShellSurface = new QWaylandIviSurface(mDisplay->shellIvi()->surface_create(id, object()), this); + } else if (mDisplay->shellXdg()) { + if (window->type() & Qt::Window) { + mShellSurface = new QWaylandXdgSurface(mDisplay->shellXdg()->get_xdg_surface(object()), this); +-- +2.2.1 + diff --git a/recipes-qt/qt5/qtwayland/0010-Added-manifest-file-according-to-smack-3-domain-mode.patch b/recipes-qt/qt5/qtwayland/0010-Added-manifest-file-according-to-smack-3-domain-mode.patch new file mode 100644 index 000000000..39296c769 --- /dev/null +++ b/recipes-qt/qt5/qtwayland/0010-Added-manifest-file-according-to-smack-3-domain-mode.patch @@ -0,0 +1,33 @@ +Add qt5wayland.manifest. Removed specfile change from patch. + +Adapted from: + +From 424c23191d81b072255bd7f178ad0ee2c2ea091a Mon Sep 17 00:00:00 2001 +From: Tomasz Olszak <olszak.tomasz@gmail.com> +Date: Fri, 25 Apr 2014 14:32:22 +0200 +Subject: [PATCH 10/21] Added manifest file according to smack 3-domain model. + +Bug-Tizen:TIVI-2416 + +Change-Id: I414e245a5c8847bec32ef6a97569d0f06221e1db +Signed-off-by: Tomasz Olszak <olszak.tomasz@gmail.com> +--- + packaging/qt5-qtwayland.manifest | 5 +++++ + packaging/qt5-qtwayland.spec | 4 ++++ + 2 files changed, 9 insertions(+) + create mode 100644 packaging/qt5-qtwayland.manifest + +diff --git a/packaging/qt5-qtwayland.manifest b/packaging/qt5-qtwayland.manifest +new file mode 100644 +index 0000000..75b0fa5 +--- /dev/null ++++ b/packaging/qt5-qtwayland.manifest +@@ -0,0 +1,5 @@ ++<manifest> ++ <request> ++ <domain name="_"/> ++ </request> ++</manifest> +-- +1.9.1 + diff --git a/recipes-qt/qt5/qtwayland/0016-xdg-shell-Add-xdg-shell-protocol-file-version-1.4.0.patch b/recipes-qt/qt5/qtwayland/0016-xdg-shell-Add-xdg-shell-protocol-file-version-1.4.0.patch new file mode 100644 index 000000000..6bea62621 --- /dev/null +++ b/recipes-qt/qt5/qtwayland/0016-xdg-shell-Add-xdg-shell-protocol-file-version-1.4.0.patch @@ -0,0 +1,468 @@ +From 5cd43dc7519f54f9786fb6c686a2ce1e682d4366 Mon Sep 17 00:00:00 2001 +From: Philippe Coval <philippe.coval@open.eurogiciel.org> +Date: Fri, 25 Apr 2014 10:31:42 +0200 +Subject: [PATCH 16/21] xdg-shell: Add xdg-shell protocol file version 1.4.0 + +Source: http://cgit.freedesktop.org/wayland/weston/plain/protocol/xdg-shell.xml?id=1.4.0 + +This file will need to be refreshed on protocol update +until xdg-shell land in wayland's public headers + +Task-number: QTBUG-38633/part/1of2 +Change-Id: I397d863dcfc2223ac6eb234c37dbcd7449ecffff +Reviewed-by: Giulio Camuffo <giulio.camuffo@jollamobile.com> +Origin: https://www.qt.gitorious.org/qt/qtwayland/commit/c2a22eea6716e073875474adf624d8463eba836c +Bug-Tizen: TIVI-3113/part +Signed-off-by: Philippe Coval <philippe.coval@open.eurogiciel.org> +--- + src/3rdparty/protocol/xdg-shell.xml | 438 ++++++++++++++++++++++++++++++++++++ + 1 file changed, 438 insertions(+) + create mode 100644 src/3rdparty/protocol/xdg-shell.xml + +diff --git a/src/3rdparty/protocol/xdg-shell.xml b/src/3rdparty/protocol/xdg-shell.xml +new file mode 100644 +index 0000000..4e5cff8 +--- /dev/null ++++ b/src/3rdparty/protocol/xdg-shell.xml +@@ -0,0 +1,438 @@ ++<?xml version="1.0" encoding="UTF-8"?> ++<protocol name="xdg_shell"> ++ ++ <copyright> ++ Copyright © 2008-2013 Kristian Høgsberg ++ Copyright © 2013 Rafael Antognolli ++ Copyright © 2013 Jasper St. Pierre ++ Copyright © 2010-2013 Intel Corporation ++ ++ Permission to use, copy, modify, distribute, and sell this ++ software and its documentation for any purpose is hereby granted ++ without fee, provided that the above copyright notice appear in ++ all copies and that both that copyright notice and this permission ++ notice appear in supporting documentation, and that the name of ++ the copyright holders not be used in advertising or publicity ++ pertaining to distribution of the software without specific, ++ written prior permission. The copyright holders make no ++ representations about the suitability of this software for any ++ purpose. It is provided "as is" without express or implied ++ warranty. ++ ++ THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS ++ SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND ++ FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY ++ SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES ++ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN ++ AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ++ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF ++ THIS SOFTWARE. ++ </copyright> ++ ++ <interface name="xdg_shell" version="1"> ++ <description summary="create desktop-style surfaces"> ++ This interface is implemented by servers that provide ++ desktop-style user interfaces. ++ ++ It allows clients to associate a xdg_surface with ++ a basic surface. ++ </description> ++ ++ <enum name="version"> ++ <description summary="latest protocol version"> ++ Use this enum to check the protocol version, and it will be updated ++ automatically. ++ </description> ++ <entry name="current" value="1" summary="Always the latest version"/> ++ </enum> ++ ++ ++ <request name="use_unstable_version"> ++ <description summary="enable use of this unstable version"> ++ Use this request in order to enable use of this interface. ++ ++ Understand and agree that one is using an unstable interface, ++ that will likely change in the future, breaking the API. ++ </description> ++ <arg name="version" type="int"/> ++ </request> ++ ++ <request name="get_xdg_surface"> ++ <description summary="create a shell surface from a surface"> ++ Create a shell surface for an existing surface. ++ ++ Only one shell or popup surface can be associated with a given ++ surface. ++ </description> ++ <arg name="id" type="new_id" interface="xdg_surface"/> ++ <arg name="surface" type="object" interface="wl_surface"/> ++ </request> ++ ++ <request name="get_xdg_popup"> ++ <description summary="create a shell surface from a surface"> ++ Create a popup surface for an existing surface. ++ ++ Only one shell or popup surface can be associated with a given ++ surface. ++ </description> ++ <arg name="id" type="new_id" interface="xdg_popup"/> ++ <arg name="surface" type="object" interface="wl_surface"/> ++ <arg name="parent" type="object" interface="wl_surface"/> ++ <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat whose pointer is used"/> ++ <arg name="serial" type="uint" summary="serial of the implicit grab on the pointer"/> ++ <arg name="x" type="int"/> ++ <arg name="y" type="int"/> ++ <arg name="flags" type="uint"/> ++ </request> ++ </interface> ++ ++ <interface name="xdg_surface" version="1"> ++ ++ <description summary="desktop-style metadata interface"> ++ An interface that may be implemented by a wl_surface, for ++ implementations that provide a desktop-style user interface. ++ ++ It provides requests to treat surfaces like windows, allowing to set ++ properties like maximized, fullscreen, minimized, and to move and resize ++ them, and associate metadata like title and app id. ++ ++ On the server side the object is automatically destroyed when ++ the related wl_surface is destroyed. On client side, ++ xdg_surface.destroy() must be called before destroying ++ the wl_surface object. ++ </description> ++ ++ <request name="destroy" type="destructor"> ++ <description summary="remove xdg_surface interface"> ++ The xdg_surface interface is removed from the wl_surface object ++ that was turned into a xdg_surface with ++ xdg_shell.get_xdg_surface request. The xdg_surface properties, ++ like maximized and fullscreen, are lost. The wl_surface loses ++ its role as a xdg_surface. The wl_surface is unmapped. ++ </description> ++ </request> ++ ++ <request name="set_transient_for"> ++ <description summary="surface is a child of another surface"> ++ Setting a surface as transient of another means that it is child ++ of another surface. ++ ++ Child surfaces are stacked above their parents, and will be ++ unmapped if the parent is unmapped too. They should not appear ++ on task bars and alt+tab. ++ </description> ++ <arg name="parent" type="object" interface="wl_surface" allow-null="true"/> ++ </request> ++ ++ <request name="set_title"> ++ <description summary="set surface title"> ++ Set a short title for the surface. ++ ++ This string may be used to identify the surface in a task bar, ++ window list, or other user interface elements provided by the ++ compositor. ++ ++ The string must be encoded in UTF-8. ++ </description> ++ <arg name="title" type="string"/> ++ </request> ++ ++ <request name="set_app_id"> ++ <description summary="set surface class"> ++ Set an id for the surface. ++ ++ The app id identifies the general class of applications to which ++ the surface belongs. ++ ++ It should be the ID that appears in the new desktop entry ++ specification, the interface name. ++ </description> ++ <arg name="app_id" type="string"/> ++ </request> ++ ++ <request name="pong"> ++ <description summary="respond to a ping event"> ++ A client must respond to a ping event with a pong request or ++ the client may be deemed unresponsive. ++ </description> ++ <arg name="serial" type="uint" summary="serial of the ping event"/> ++ </request> ++ ++ <event name="ping"> ++ <description summary="ping client"> ++ Ping a client to check if it is receiving events and sending ++ requests. A client is expected to reply with a pong request. ++ </description> ++ <arg name="serial" type="uint"/> ++ </event> ++ ++ <request name="move"> ++ <description summary="start an interactive move"> ++ Start a pointer-driven move of the surface. ++ ++ This request must be used in response to a button press event. ++ The server may ignore move requests depending on the state of ++ the surface (e.g. fullscreen or maximized). ++ </description> ++ <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat whose pointer is used"/> ++ <arg name="serial" type="uint" summary="serial of the implicit grab on the pointer"/> ++ </request> ++ ++ <enum name="resize_edge"> ++ <description summary="edge values for resizing"> ++ These values are used to indicate which edge of a surface ++ is being dragged in a resize operation. The server may ++ use this information to adapt its behavior, e.g. choose ++ an appropriate cursor image. ++ </description> ++ <entry name="none" value="0"/> ++ <entry name="top" value="1"/> ++ <entry name="bottom" value="2"/> ++ <entry name="left" value="4"/> ++ <entry name="top_left" value="5"/> ++ <entry name="bottom_left" value="6"/> ++ <entry name="right" value="8"/> ++ <entry name="top_right" value="9"/> ++ <entry name="bottom_right" value="10"/> ++ </enum> ++ ++ <request name="resize"> ++ <description summary="start an interactive resize"> ++ Start a pointer-driven resizing of the surface. ++ ++ This request must be used in response to a button press event. ++ The server may ignore resize requests depending on the state of ++ the surface (e.g. fullscreen or maximized). ++ </description> ++ <arg name="seat" type="object" interface="wl_seat" summary="the wl_seat whose pointer is used"/> ++ <arg name="serial" type="uint" summary="serial of the implicit grab on the pointer"/> ++ <arg name="edges" type="uint" summary="which edge or corner is being dragged"/> ++ </request> ++ ++ <event name="configure"> ++ <description summary="suggest resize"> ++ The configure event asks the client to resize its surface. ++ ++ The size is a hint, in the sense that the client is free to ++ ignore it if it doesn't resize, pick a smaller size (to ++ satisfy aspect ratio or resize in steps of NxM pixels). ++ ++ The edges parameter provides a hint about how the surface ++ was resized. The client may use this information to decide ++ how to adjust its content to the new size (e.g. a scrolling ++ area might adjust its content position to leave the viewable ++ content unmoved). Valid edge values are from resize_edge enum. ++ ++ The client is free to dismiss all but the last configure ++ event it received. ++ ++ The width and height arguments specify the size of the window ++ in surface local coordinates. ++ </description> ++ ++ <arg name="edges" type="uint"/> ++ <arg name="width" type="int"/> ++ <arg name="height" type="int"/> ++ </event> ++ ++ <request name="set_output"> ++ <description summary="set the default output used by this surface"> ++ Set the default output used by this surface when it is first mapped. ++ ++ If this value is NULL (default), it's up to the compositor to choose ++ which display will be used to map this surface. ++ ++ When fullscreen or maximized state are set on this surface, and it ++ wasn't mapped yet, the output set with this method will be used. ++ Otherwise, the output where the surface is currently mapped will be ++ used. ++ </description> ++ <arg name="output" type="object" interface="wl_output" allow-null="true"/> ++ </request> ++ ++ <event name="request_set_fullscreen"> ++ <description summary="server requests that the client set fullscreen"> ++ Event sent from the compositor to the client requesting that the client ++ goes to a fullscreen state. It's the client job to call set_fullscreen ++ and really trigger the fullscreen state. ++ </description> ++ </event> ++ ++ <event name="request_unset_fullscreen"> ++ <description summary="server requests that the client unset fullscreen"> ++ Event sent from the compositor to the client requesting that the client ++ leaves the fullscreen state. It's the client job to call ++ unset_fullscreen and really leave the fullscreen state. ++ </description> ++ </event> ++ ++ <request name="set_fullscreen"> ++ <description summary="set the surface state as fullscreen"> ++ Set the surface as fullscreen. ++ ++ After this request, the compositor should send a configure event ++ informing the output size. ++ ++ This request informs the compositor that the next attached buffer ++ committed will be in a fullscreen state. The buffer size should be the ++ same size as the size informed in the configure event, if the client ++ doesn't want to leave any empty area. ++ ++ In other words: the next attached buffer after set_maximized is the new ++ maximized buffer. And the surface will be positioned at the maximized ++ position on commit. ++ ++ A simple way to synchronize and wait for the correct configure event is ++ to use a wl_display.sync request right after the set_fullscreen ++ request. When the sync callback returns, the last configure event ++ received just before it will be the correct one, and should contain the ++ right size for the surface to maximize. ++ ++ Setting one state won't unset another state. Use ++ xdg_surface.unset_fullscreen for unsetting it. ++ </description> ++ </request> ++ ++ <request name="unset_fullscreen"> ++ <description summary="unset the surface state as fullscreen"> ++ Unset the surface fullscreen state. ++ ++ Same negotiation as set_fullscreen must be used. ++ </description> ++ </request> ++ ++ <event name="request_set_maximized"> ++ <description summary="server requests that the client set maximized"> ++ Event sent from the compositor to the client requesting that the client ++ goes to a maximized state. It's the client job to call set_maximized ++ and really trigger the maximized state. ++ </description> ++ </event> ++ ++ <event name="request_unset_maximized"> ++ <description summary="server requests that the client unset maximized"> ++ Event sent from the compositor to the client requesting that the client ++ leaves the maximized state. It's the client job to call unset_maximized ++ and really leave the maximized state. ++ </description> ++ </event> ++ ++ <request name="set_maximized"> ++ <description summary="set the surface state as maximized"> ++ Set the surface as maximized. ++ ++ After this request, the compositor will send a configure event ++ informing the output size minus panel and other MW decorations. ++ ++ This request informs the compositor that the next attached buffer ++ committed will be in a maximized state. The buffer size should be the ++ same size as the size informed in the configure event, if the client ++ doesn't want to leave any empty area. ++ ++ In other words: the next attached buffer after set_maximized is the new ++ maximized buffer. And the surface will be positioned at the maximized ++ position on commit. ++ ++ A simple way to synchronize and wait for the correct configure event is ++ to use a wl_display.sync request right after the set_maximized request. ++ When the sync callback returns, the last configure event received just ++ before it will be the correct one, and should contain the right size ++ for the surface to maximize. ++ ++ Setting one state won't unset another state. Use ++ xdg_surface.unset_maximized for unsetting it. ++ </description> ++ </request> ++ ++ <request name="unset_maximized"> ++ <description summary="unset the surface state as maximized"> ++ Unset the surface maximized state. ++ ++ Same negotiation as set_maximized must be used. ++ </description> ++ </request> ++ ++ <request name="set_minimized"> ++ <description summary="set the surface state as minimized"> ++ Set the surface minimized state. ++ ++ Setting one state won't unset another state. ++ </description> ++ </request> ++ ++ <event name="focused_set"> ++ <description summary="surface was focused"> ++ The focused_set event is sent when this surface has been ++ activated. Window decorations should be updated accordingly. ++ </description> ++ </event> ++ ++ <event name="focused_unset"> ++ <description summary="surface was unfocused"> ++ The focused_unset event is sent when this surface has been ++ deactivated, because another surface has been activated. Window ++ decorations should be updated accordingly. ++ </description> ++ </event> ++ </interface> ++ ++ <interface name="xdg_popup" version="1"> ++ <description summary="desktop-style metadata interface"> ++ An interface that may be implemented by a wl_surface, for ++ implementations that provide a desktop-style popups/menus. A popup ++ surface is a transient surface with an added pointer grab. ++ ++ An existing implicit grab will be changed to owner-events mode, ++ and the popup grab will continue after the implicit grab ends ++ (i.e. releasing the mouse button does not cause the popup to be ++ unmapped). ++ ++ The popup grab continues until the window is destroyed or a mouse ++ button is pressed in any other clients window. A click in any of ++ the clients surfaces is reported as normal, however, clicks in ++ other clients surfaces will be discarded and trigger the callback. ++ ++ The x and y arguments specify the locations of the upper left ++ corner of the surface relative to the upper left corner of the ++ parent surface, in surface local coordinates. ++ ++ xdg_popup surfaces are always transient for another surface. ++ </description> ++ ++ <request name="destroy" type="destructor"> ++ <description summary="remove xdg_surface interface"> ++ The xdg_surface interface is removed from the wl_surface object ++ that was turned into a xdg_surface with ++ xdg_shell.get_xdg_surface request. The xdg_surface properties, ++ like maximized and fullscreen, are lost. The wl_surface loses ++ its role as a xdg_surface. The wl_surface is unmapped. ++ </description> ++ </request> ++ ++ <request name="pong"> ++ <description summary="respond to a ping event"> ++ A client must respond to a ping event with a pong request or ++ the client may be deemed unresponsive. ++ </description> ++ <arg name="serial" type="uint" summary="serial of the ping event"/> ++ </request> ++ ++ <event name="ping"> ++ <description summary="ping client"> ++ Ping a client to check if it is receiving events and sending ++ requests. A client is expected to reply with a pong request. ++ </description> ++ <arg name="serial" type="uint"/> ++ </event> ++ ++ <event name="popup_done"> ++ <description summary="popup interaction is done"> ++ The popup_done event is sent out when a popup grab is broken, ++ that is, when the users clicks a surface that doesn't belong ++ to the client owning the popup surface. ++ </description> ++ <arg name="serial" type="uint" summary="serial of the implicit grab on the pointer"/> ++ </event> ++ ++ </interface> ++</protocol> +-- +1.9.1 + diff --git a/recipes-qt/qt5/qtwayland/0017-xdg-shell-Add-minimize-feature-to-QWindow-using-wayl.patch b/recipes-qt/qt5/qtwayland/0017-xdg-shell-Add-minimize-feature-to-QWindow-using-wayl.patch new file mode 100644 index 000000000..fe1bb50e8 --- /dev/null +++ b/recipes-qt/qt5/qtwayland/0017-xdg-shell-Add-minimize-feature-to-QWindow-using-wayl.patch @@ -0,0 +1,1029 @@ +From 0edba039247ce888dbb7ff0a93c7b9ec01bac46e Mon Sep 17 00:00:00 2001 +From: Philippe Coval <philippe.coval@open.eurogiciel.org> +Date: Wed, 26 Mar 2014 10:16:01 +0100 +Subject: [PATCH 17/21] xdg-shell: Add minimize feature to QWindow using + wayland's xdg-shell + +The feature is disabled by default, +and can be enabled at runtime +by exporting QT_WAYLAND_USE_XDG_SHELL env variable. + +This patch relies on presence of protocol file +which has been imported from weston-1.4.0 sources, +until the xdg-shell is merge into wayland itself. + +Because xdg-shell is experimental, +code fallback to WaylandShell if no XdgShell +but keep in mind those shells are exclusive. + +Since xdg-shell and wayland-shell share most of the API, +some factorization is done by an (empty) abstraction class +to keep the code more readable. + +Despite xdg-shell introduces new popups concept, +they're not used on this change for maitainance purpose. + +Notes: + +* This change depends on presence of xdg-shell protocol file. + +* You can check a demo video + (qt-tizen-cinematic-experience-20140430-rzr) + of the test case at : + https://www.youtube.com/watch?v=pY_XXvKc_0E# + +* Use Super+Tab to show window again if hidden + +Task-number: QTBUG-38633/part/2of2 +Change-Id: I2d7ed85bea1847d82439fdfc893a3dbb2581ffff +Reviewed-by: Giulio Camuffo <giulio.camuffo@jollamobile.com> +Origin: https://www.qt.gitorious.org/qt/qtwayland/commit/768484daaa64bea965bef981a16f59be8db0c190 +Bug-Tizen: TIVI-3113/part +Signed-off-by: Philippe Coval <philippe.coval@open.eurogiciel.org> +--- + src/client/client.pro | 5 + + src/client/qwaylanddisplay.cpp | 5 + + src/client/qwaylanddisplay_p.h | 4 + + src/client/qwaylandshellsurface.cpp | 134 ------------------------ + src/client/qwaylandshellsurface_p.h | 40 +++----- + src/client/qwaylandwindow.cpp | 40 ++++++-- + src/client/qwaylandwlshellsurface.cpp | 186 ++++++++++++++++++++++++++++++++++ + src/client/qwaylandwlshellsurface_p.h | 101 ++++++++++++++++++ + src/client/qwaylandxdgsurface.cpp | 173 +++++++++++++++++++++++++++++++ + src/client/qwaylandxdgsurface_p.h | 105 +++++++++++++++++++ + 10 files changed, 625 insertions(+), 168 deletions(-) + create mode 100644 src/client/qwaylandwlshellsurface.cpp + create mode 100644 src/client/qwaylandwlshellsurface_p.h + create mode 100644 src/client/qwaylandxdgsurface.cpp + create mode 100644 src/client/qwaylandxdgsurface_p.h + +diff --git a/src/client/client.pro b/src/client/client.pro +index 10cbd31..9ecf82f 100644 +--- a/src/client/client.pro ++++ b/src/client/client.pro +@@ -41,6 +41,7 @@ WAYLANDCLIENTSOURCES += \ + ../extensions/qtkey-extension.xml \ + ../extensions/windowmanager.xml \ + ../3rdparty/protocol/text.xml \ ++ ../3rdparty/protocol/xdg-shell.xml \ + + SOURCES += qwaylandintegration.cpp \ + qwaylandnativeinterface.cpp \ +@@ -57,6 +58,8 @@ SOURCES += qwaylandintegration.cpp \ + qwaylanddatadevicemanager.cpp \ + qwaylanddatasource.cpp \ + qwaylandshellsurface.cpp \ ++ qwaylandwlshellsurface.cpp \ ++ qwaylandxdgsurface.cpp \ + qwaylandextendedoutput.cpp \ + qwaylandextendedsurface.cpp \ + qwaylandsubsurface.cpp \ +@@ -85,6 +88,8 @@ HEADERS += qwaylandintegration_p.h \ + qwaylanddatadevicemanager_p.h \ + qwaylanddatasource_p.h \ + qwaylandshellsurface_p.h \ ++ qwaylandwlshellsurface_p.h \ ++ qwaylandxdgsurface_p.h \ + qwaylandextendedoutput_p.h \ + qwaylandextendedsurface_p.h \ + qwaylandsubsurface_p.h \ +diff --git a/src/client/qwaylanddisplay.cpp b/src/client/qwaylanddisplay.cpp +index 0b715c0..7f953ad 100644 +--- a/src/client/qwaylanddisplay.cpp ++++ b/src/client/qwaylanddisplay.cpp +@@ -61,6 +61,7 @@ + #include "qwaylandqtkey_p.h" + + #include <QtWaylandClient/private/qwayland-text.h> ++#include <QtWaylandClient/private/qwayland-xdg-shell.h> + + #include <QtCore/QAbstractEventDispatcher> + #include <QtGui/private/qguiapplication_p.h> +@@ -206,6 +207,10 @@ void QWaylandDisplay::registry_global(uint32_t id, const QString &interface, uin + mCompositor.init(registry, id); + } else if (interface == QStringLiteral("wl_shm")) { + mShm = static_cast<struct wl_shm *>(wl_registry_bind(registry, id, &wl_shm_interface,1)); ++ } else if (interface == QStringLiteral("xdg_shell") ++ && qEnvironmentVariableIsSet("QT_WAYLAND_USE_XDG_SHELL")) { ++ mShellXdg.reset(new QtWayland::xdg_shell(registry, id)); ++ mShellXdg->use_unstable_version(QtWayland::xdg_shell::version_current); + } else if (interface == QStringLiteral("wl_shell")){ + mShell.reset(new QtWayland::wl_shell(registry, id)); + } else if (interface == QStringLiteral("wl_seat")) { +diff --git a/src/client/qwaylanddisplay_p.h b/src/client/qwaylanddisplay_p.h +index 40cb2b2..cf5dfc2 100644 +--- a/src/client/qwaylanddisplay_p.h ++++ b/src/client/qwaylanddisplay_p.h +@@ -51,6 +51,7 @@ + + #include <QtWaylandClient/private/qwayland-wayland.h> + #include <QtWaylandClient/private/qwaylandclientexport_p.h> ++#include <QtWaylandClient/private/qwayland-xdg-shell.h> + + struct wl_cursor_image; + +@@ -78,6 +79,7 @@ namespace QtWayland { + class qt_sub_surface_extension; + class qt_surface_extension; + class wl_text_input_manager; ++ class xdg_shell; + } + + typedef void (*RegistryListener)(void *data, +@@ -113,6 +115,7 @@ public: + QtWayland::wl_compositor *compositor() { return &mCompositor; } + + QtWayland::wl_shell *shell() { return mShell.data(); } ++ QtWayland::xdg_shell *shellXdg() { return mShellXdg.data(); } + + QList<QWaylandInputDevice *> inputDevices() const { return mInputDevices; } + QWaylandInputDevice *defaultInputDevice() const; +@@ -168,6 +171,7 @@ private: + QThread *mEventThread; + QWaylandEventThread *mEventThreadObject; + QScopedPointer<QtWayland::wl_shell> mShell; ++ QScopedPointer<QtWayland::xdg_shell> mShellXdg; + QList<QPlatformScreen *> mScreens; + QList<QWaylandInputDevice *> mInputDevices; + QList<Listener> mRegistryListeners; +diff --git a/src/client/qwaylandshellsurface.cpp b/src/client/qwaylandshellsurface.cpp +index b7a819f..80e509b 100644 +--- a/src/client/qwaylandshellsurface.cpp ++++ b/src/client/qwaylandshellsurface.cpp +@@ -40,137 +40,3 @@ + ****************************************************************************/ + + #include "qwaylandshellsurface_p.h" +- +-#include "qwaylanddisplay_p.h" +-#include "qwaylandwindow_p.h" +-#include "qwaylandinputdevice_p.h" +-#include "qwaylanddecoration_p.h" +-#include "qwaylandscreen_p.h" +- +-#include <QtCore/QDebug> +- +-QT_BEGIN_NAMESPACE +- +-QWaylandShellSurface::QWaylandShellSurface(struct ::wl_shell_surface *shell_surface, QWaylandWindow *window) +- : QtWayland::wl_shell_surface(shell_surface) +- , m_window(window) +- , m_maximized(false) +- , m_fullscreen(false) +-{ +-} +- +-QWaylandShellSurface::~QWaylandShellSurface() +-{ +- wl_shell_surface_destroy(object()); +-} +- +-void QWaylandShellSurface::resize(QWaylandInputDevice *inputDevice, enum wl_shell_surface_resize edges) +-{ +- resize(inputDevice->wl_seat(), +- inputDevice->serial(), +- edges); +-} +- +-void QWaylandShellSurface::move(QWaylandInputDevice *inputDevice) +-{ +- move(inputDevice->wl_seat(), +- inputDevice->serial()); +-} +- +-void QWaylandShellSurface::setMaximized() +-{ +- m_maximized = true; +- m_size = m_window->window()->geometry().size(); +- set_maximized(0); +-} +- +-void QWaylandShellSurface::setFullscreen() +-{ +- m_fullscreen = true; +- m_size = m_window->window()->geometry().size(); +- set_fullscreen(WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, 0); +-} +- +-void QWaylandShellSurface::setNormal() +-{ +- if (m_fullscreen || m_maximized) { +- m_fullscreen = m_maximized = false; +- setTopLevel(); +- QMargins m = m_window->frameMargins(); +- m_window->configure(0, m_size.width() + m.left() + m.right(), m_size.height() + m.top() + m.bottom()); +- } +-} +- +-void QWaylandShellSurface::setMinimized() +-{ +- // TODO: There's no wl_shell_surface API for this +-} +- +-void QWaylandShellSurface::setTopLevel() +-{ +- set_toplevel(); +-} +- +-void QWaylandShellSurface::updateTransientParent(QWindow *parent) +-{ +- QWaylandWindow *parent_wayland_window = static_cast<QWaylandWindow *>(parent->handle()); +- if (!parent_wayland_window) +- return; +- +- // set_transient expects a position relative to the parent +- QPoint transientPos = m_window->geometry().topLeft(); // this is absolute +- QWindow *parentWin = m_window->window()->transientParent(); +- transientPos -= parentWin->geometry().topLeft(); +- if (parent_wayland_window->decoration()) { +- transientPos.setX(transientPos.x() + parent_wayland_window->decoration()->margins().left()); +- transientPos.setY(transientPos.y() + parent_wayland_window->decoration()->margins().top()); +- } +- +- uint32_t flags = 0; +- Qt::WindowFlags wf = m_window->window()->flags(); +- if (wf.testFlag(Qt::ToolTip) +- || wf.testFlag(Qt::WindowTransparentForInput)) +- flags |= WL_SHELL_SURFACE_TRANSIENT_INACTIVE; +- +- set_transient(parent_wayland_window->object(), +- transientPos.x(), +- transientPos.y(), +- flags); +-} +- +-void QWaylandShellSurface::setPopup(QWaylandWindow *parent, QWaylandInputDevice *device, int serial) +-{ +- QWaylandWindow *parent_wayland_window = parent; +- if (!parent_wayland_window) +- return; +- +- // set_popup expects a position relative to the parent +- QPoint transientPos = m_window->geometry().topLeft(); // this is absolute +- transientPos -= parent_wayland_window->geometry().topLeft(); +- if (parent_wayland_window->decoration()) { +- transientPos.setX(transientPos.x() + parent_wayland_window->decoration()->margins().left()); +- transientPos.setY(transientPos.y() + parent_wayland_window->decoration()->margins().top()); +- } +- +- set_popup(device->wl_seat(), serial, parent_wayland_window->object(), +- transientPos.x(), transientPos.y(), 0); +-} +- +-void QWaylandShellSurface::shell_surface_ping(uint32_t serial) +-{ +- pong(serial); +-} +- +-void QWaylandShellSurface::shell_surface_configure(uint32_t edges, +- int32_t width, +- int32_t height) +-{ +- m_window->configure(edges, width, height); +-} +- +-void QWaylandShellSurface::shell_surface_popup_done() +-{ +- QCoreApplication::postEvent(m_window->window(), new QCloseEvent()); +-} +- +-QT_END_NAMESPACE +diff --git a/src/client/qwaylandshellsurface_p.h b/src/client/qwaylandshellsurface_p.h +index 2477c3f..2f59f60 100644 +--- a/src/client/qwaylandshellsurface_p.h ++++ b/src/client/qwaylandshellsurface_p.h +@@ -55,39 +55,25 @@ class QWaylandWindow; + class QWaylandInputDevice; + class QWindow; + +-class Q_WAYLAND_CLIENT_EXPORT QWaylandShellSurface : public QtWayland::wl_shell_surface ++class Q_WAYLAND_CLIENT_EXPORT QWaylandShellSurface + { + public: +- QWaylandShellSurface(struct ::wl_shell_surface *shell_surface, QWaylandWindow *window); +- ~QWaylandShellSurface(); ++ virtual ~QWaylandShellSurface() {} ++ virtual void resize(QWaylandInputDevice * /*inputDevice*/, enum wl_shell_surface_resize /*edges*/) ++ {} + +- using QtWayland::wl_shell_surface::resize; +- void resize(QWaylandInputDevice *inputDevice, enum wl_shell_surface_resize edges); +- +- using QtWayland::wl_shell_surface::move; +- void move(QWaylandInputDevice *inputDevice); ++ virtual void move(QWaylandInputDevice * /*inputDevice*/) {} ++ virtual void setTitle(const QString & /*title*/) {} ++ virtual void setAppId(const QString & /*appId*/) {} + + private: +- void setMaximized(); +- void setFullscreen(); +- void setNormal(); +- void setMinimized(); +- +- void setTopLevel(); +- void updateTransientParent(QWindow *parent); +- void setPopup(QWaylandWindow *parent, QWaylandInputDevice *device, int serial); +- +- QWaylandWindow *m_window; +- bool m_maximized; +- bool m_fullscreen; +- QSize m_size; +- +- void shell_surface_ping(uint32_t serial) Q_DECL_OVERRIDE; +- void shell_surface_configure(uint32_t edges, +- int32_t width, +- int32_t height) Q_DECL_OVERRIDE; +- void shell_surface_popup_done() Q_DECL_OVERRIDE; ++ virtual void setMaximized() {} ++ virtual void setFullscreen() {} ++ virtual void setNormal() {} ++ virtual void setMinimized() {} + ++ virtual void setTopLevel() {} ++ virtual void updateTransientParent(QWindow * /*parent*/) {} + friend class QWaylandWindow; + }; + +diff --git a/src/client/qwaylandwindow.cpp b/src/client/qwaylandwindow.cpp +index 920c977..3fb3a49 100644 +--- a/src/client/qwaylandwindow.cpp ++++ b/src/client/qwaylandwindow.cpp +@@ -46,6 +46,8 @@ + #include "qwaylandinputdevice_p.h" + #include "qwaylandscreen_p.h" + #include "qwaylandshellsurface_p.h" ++#include "qwaylandwlshellsurface_p.h" ++#include "qwaylandxdgsurface_p.h" + #include "qwaylandextendedsurface_p.h" + #include "qwaylandsubsurface_p.h" + #include "qwaylanddecoration_p.h" +@@ -92,8 +94,16 @@ QWaylandWindow::QWaylandWindow(QWindow *window) + static WId id = 1; + mWindowId = id++; + +- if (mDisplay->shell() && window->type() & Qt::Window && !(window->flags() & Qt::BypassWindowManagerHint)) +- mShellSurface = new QWaylandShellSurface(mDisplay->shell()->get_shell_surface(object()), this); ++ if (!(window->flags() & Qt::BypassWindowManagerHint)) { ++ if (mDisplay->shellXdg()) { ++ if (window->type() & Qt::Window) { ++ mShellSurface = new QWaylandXdgSurface(mDisplay->shellXdg()->get_xdg_surface(object()), this); ++ } ++ } else if (mDisplay->shell() && window->type() & Qt::Window) { ++ mShellSurface = new QWaylandWlShellSurface(mDisplay->shell()->get_shell_surface(object()), this); ++ } ++ } ++ + if (mDisplay->windowExtension()) + mExtendedWindow = new QWaylandExtendedSurface(this, mDisplay->windowExtension()->get_extended_surface(object())); + if (mDisplay->subSurfaceExtension()) +@@ -101,12 +111,12 @@ QWaylandWindow::QWaylandWindow(QWindow *window) + + if (mShellSurface) { + // Set initial surface title +- mShellSurface->set_title(window->title()); ++ mShellSurface->setTitle(window->title()); + + // Set surface class to the .desktop file name (obtained from executable name) + QFileInfo exeFileInfo(qApp->applicationFilePath()); + QString className = exeFileInfo.baseName() + QLatin1String(".desktop"); +- mShellSurface->set_class(className); ++ mShellSurface->setAppId(className); + } + + if (QPlatformWindow::parent() && mSubSurfaceWindow) { +@@ -170,7 +180,7 @@ void QWaylandWindow::setParent(const QPlatformWindow *parent) + void QWaylandWindow::setWindowTitle(const QString &title) + { + if (mShellSurface) { +- mShellSurface->set_title(title); ++ mShellSurface->setTitle(title); + } + + if (mWindowDecoration && window()->isVisible()) +@@ -212,8 +222,10 @@ void QWaylandWindow::setVisible(bool visible) + mMouseDevice = parent->mMouseDevice; + mMouseSerial = parent->mMouseSerial; + +- if (mMouseDevice) +- mShellSurface->setPopup(transientParent(), mMouseDevice, mMouseSerial); ++ QWaylandWlShellSurface *wlshellSurface = dynamic_cast<QWaylandWlShellSurface*>(mShellSurface); ++ if (mMouseDevice && wlshellSurface) { ++ wlshellSurface->setPopup(transientParent(), mMouseDevice, mMouseSerial); ++ } + } + + if (!mSentInitialResize) { +@@ -428,6 +440,20 @@ void QWaylandWindow::setWindowFlags(Qt::WindowFlags flags) + + bool QWaylandWindow::createDecoration() + { ++ // so far only xdg-shell support this "unminimize" trick, may be moved elsewhere ++ if (mState == Qt::WindowMinimized) { ++ QWaylandXdgSurface *xdgSurface = dynamic_cast<QWaylandXdgSurface *>(mShellSurface); ++ if ( xdgSurface ) { ++ if (xdgSurface->isFullscreen()) { ++ setWindowStateInternal(Qt::WindowFullScreen); ++ } else if (xdgSurface->isMaximized()) { ++ setWindowStateInternal(Qt::WindowMaximized); ++ } else { ++ setWindowStateInternal(Qt::WindowNoState); ++ } ++ } ++ } ++ + static bool disableWaylandDecorations = !qgetenv("QT_WAYLAND_DISABLE_WINDOWDECORATION").isEmpty(); + if (disableWaylandDecorations) + return false; +diff --git a/src/client/qwaylandwlshellsurface.cpp b/src/client/qwaylandwlshellsurface.cpp +new file mode 100644 +index 0000000..4b73ec2 +--- /dev/null ++++ b/src/client/qwaylandwlshellsurface.cpp +@@ -0,0 +1,186 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies). ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include "qwaylandwlshellsurface_p.h" ++ ++#include "qwaylanddisplay_p.h" ++#include "qwaylandwindow_p.h" ++#include "qwaylandinputdevice_p.h" ++#include "qwaylanddecoration_p.h" ++#include "qwaylandscreen_p.h" ++ ++#include <QtCore/QDebug> ++ ++QT_BEGIN_NAMESPACE ++ ++QWaylandWlShellSurface::QWaylandWlShellSurface(struct ::wl_shell_surface *shell_surface, QWaylandWindow *window) ++ : QtWayland::wl_shell_surface(shell_surface) ++ , m_window(window) ++ , m_maximized(false) ++ , m_fullscreen(false) ++{ ++} ++ ++QWaylandWlShellSurface::~QWaylandWlShellSurface() ++{ ++ wl_shell_surface_destroy(object()); ++} ++ ++void QWaylandWlShellSurface::resize(QWaylandInputDevice *inputDevice, enum wl_shell_surface_resize edges) ++{ ++ resize(inputDevice->wl_seat(), ++ inputDevice->serial(), ++ edges); ++} ++ ++void QWaylandWlShellSurface::move(QWaylandInputDevice *inputDevice) ++{ ++ move(inputDevice->wl_seat(), ++ inputDevice->serial()); ++} ++ ++void QWaylandWlShellSurface::setTitle(const QString & title) ++{ ++ return QtWayland::wl_shell_surface::set_title(title); ++} ++ ++void QWaylandWlShellSurface::setAppId(const QString & appId) ++{ ++ return QtWayland::wl_shell_surface::set_class(appId); ++} ++ ++void QWaylandWlShellSurface::setMaximized() ++{ ++ m_maximized = true; ++ m_size = m_window->window()->geometry().size(); ++ set_maximized(0); ++} ++ ++void QWaylandWlShellSurface::setFullscreen() ++{ ++ m_fullscreen = true; ++ m_size = m_window->window()->geometry().size(); ++ set_fullscreen(WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, 0); ++} ++ ++void QWaylandWlShellSurface::setNormal() ++{ ++ if (m_fullscreen || m_maximized) { ++ m_fullscreen = m_maximized = false; ++ setTopLevel(); ++ QMargins m = m_window->frameMargins(); ++ m_window->configure(0, m_size.width() + m.left() + m.right(), m_size.height() + m.top() + m.bottom()); ++ } ++} ++ ++void QWaylandWlShellSurface::setMinimized() ++{ ++ // TODO: There's no wl_shell_surface API for this ++} ++ ++void QWaylandWlShellSurface::setTopLevel() ++{ ++ set_toplevel(); ++} ++ ++void QWaylandWlShellSurface::updateTransientParent(QWindow *parent) ++{ ++ QWaylandWindow *parent_wayland_window = static_cast<QWaylandWindow *>(parent->handle()); ++ if (!parent_wayland_window) ++ return; ++ ++ // set_transient expects a position relative to the parent ++ QPoint transientPos = m_window->geometry().topLeft(); // this is absolute ++ QWindow *parentWin = m_window->window()->transientParent(); ++ transientPos -= parentWin->geometry().topLeft(); ++ if (parent_wayland_window->decoration()) { ++ transientPos.setX(transientPos.x() + parent_wayland_window->decoration()->margins().left()); ++ transientPos.setY(transientPos.y() + parent_wayland_window->decoration()->margins().top()); ++ } ++ ++ uint32_t flags = 0; ++ Qt::WindowFlags wf = m_window->window()->flags(); ++ if (wf.testFlag(Qt::ToolTip) ++ || wf.testFlag(Qt::WindowTransparentForInput)) ++ flags |= WL_SHELL_SURFACE_TRANSIENT_INACTIVE; ++ ++ set_transient(parent_wayland_window->object(), ++ transientPos.x(), ++ transientPos.y(), ++ flags); ++} ++ ++void QWaylandWlShellSurface::setPopup(QWaylandWindow *parent, QWaylandInputDevice *device, int serial) ++{ ++ QWaylandWindow *parent_wayland_window = parent; ++ if (!parent_wayland_window) ++ return; ++ ++ // set_popup expects a position relative to the parent ++ QPoint transientPos = m_window->geometry().topLeft(); // this is absolute ++ transientPos -= parent_wayland_window->geometry().topLeft(); ++ if (parent_wayland_window->decoration()) { ++ transientPos.setX(transientPos.x() + parent_wayland_window->decoration()->margins().left()); ++ transientPos.setY(transientPos.y() + parent_wayland_window->decoration()->margins().top()); ++ } ++ ++ set_popup(device->wl_seat(), serial, parent_wayland_window->object(), ++ transientPos.x(), transientPos.y(), 0); ++} ++ ++void QWaylandWlShellSurface::shell_surface_ping(uint32_t serial) ++{ ++ pong(serial); ++} ++ ++void QWaylandWlShellSurface::shell_surface_configure(uint32_t edges, ++ int32_t width, ++ int32_t height) ++{ ++ m_window->configure(edges, width, height); ++} ++ ++void QWaylandWlShellSurface::shell_surface_popup_done() ++{ ++ QCoreApplication::postEvent(m_window->window(), new QCloseEvent()); ++} ++ ++QT_END_NAMESPACE +diff --git a/src/client/qwaylandwlshellsurface_p.h b/src/client/qwaylandwlshellsurface_p.h +new file mode 100644 +index 0000000..d02bb7b +--- /dev/null ++++ b/src/client/qwaylandwlshellsurface_p.h +@@ -0,0 +1,101 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies). ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#ifndef QWAYLANDWLSHELLSURFACE_H ++#define QWAYLANDWLSHELLSURFACE_H ++ ++#include <QtCore/QSize> ++ ++#include <wayland-client.h> ++ ++#include <QtWaylandClient/private/qwayland-wayland.h> ++#include <QtWaylandClient/private/qwaylandclientexport_p.h> ++#include "qwaylandshellsurface_p.h" ++ ++QT_BEGIN_NAMESPACE ++ ++class QWaylandWindow; ++class QWaylandInputDevice; ++class QWindow; ++ ++class Q_WAYLAND_CLIENT_EXPORT QWaylandWlShellSurface : public QtWayland::wl_shell_surface ++ , public QWaylandShellSurface ++{ ++public: ++ QWaylandWlShellSurface(struct ::wl_shell_surface *shell_surface, QWaylandWindow *window); ++ virtual ~QWaylandWlShellSurface(); ++ ++ using QtWayland::wl_shell_surface::resize; ++ void resize(QWaylandInputDevice *inputDevice, enum wl_shell_surface_resize edges) Q_DECL_OVERRIDE; ++ ++ using QtWayland::wl_shell_surface::move; ++ void move(QWaylandInputDevice *inputDevice) Q_DECL_OVERRIDE; ++ ++ void setTitle(const QString & title) Q_DECL_OVERRIDE; ++ void setAppId(const QString &appId) Q_DECL_OVERRIDE; ++ ++private: ++ void setMaximized() Q_DECL_OVERRIDE; ++ void setFullscreen() Q_DECL_OVERRIDE; ++ void setNormal() Q_DECL_OVERRIDE; ++ void setMinimized() Q_DECL_OVERRIDE; ++ ++ void setTopLevel() Q_DECL_OVERRIDE; ++ void updateTransientParent(QWindow *parent) Q_DECL_OVERRIDE; ++ void setPopup(QWaylandWindow *parent, QWaylandInputDevice *device, int serial); ++ ++ QWaylandWindow *m_window; ++ bool m_maximized; ++ bool m_fullscreen; ++ QSize m_size; ++ ++ void shell_surface_ping(uint32_t serial) Q_DECL_OVERRIDE; ++ void shell_surface_configure(uint32_t edges, ++ int32_t width, ++ int32_t height) Q_DECL_OVERRIDE; ++ void shell_surface_popup_done() Q_DECL_OVERRIDE; ++ ++ friend class QWaylandWindow; ++}; ++ ++QT_END_NAMESPACE ++ ++#endif // QWAYLANDSHELLSURFACE_H +diff --git a/src/client/qwaylandxdgsurface.cpp b/src/client/qwaylandxdgsurface.cpp +new file mode 100644 +index 0000000..1b8affa +--- /dev/null ++++ b/src/client/qwaylandxdgsurface.cpp +@@ -0,0 +1,173 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies). ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include "qwaylandxdgsurface_p.h" ++ ++#include "qwaylanddisplay_p.h" ++#include "qwaylandwindow_p.h" ++#include "qwaylandinputdevice_p.h" ++#include "qwaylanddecoration_p.h" ++#include "qwaylandscreen_p.h" ++ ++#include <QtCore/QDebug> ++ ++QT_BEGIN_NAMESPACE ++ ++QWaylandXdgSurface::QWaylandXdgSurface(struct ::xdg_surface *xdg_surface, QWaylandWindow *window) ++ : QtWayland::xdg_surface(xdg_surface) ++ , m_window(window) ++ , m_maximized(false) ++ , m_minimized(false) ++ , m_fullscreen(false) ++{ ++} ++ ++QWaylandXdgSurface::~QWaylandXdgSurface() ++{ ++ xdg_surface_destroy(object()); ++} ++ ++void QWaylandXdgSurface::resize(QWaylandInputDevice *inputDevice, enum wl_shell_surface_resize edges) ++{ ++ // May need some conversion if types get incompatibles, ATM they're identical ++ enum resize_edge const * const arg = reinterpret_cast<enum resize_edge const * const>(&edges); ++ resize(inputDevice, *arg); ++} ++ ++void QWaylandXdgSurface::resize(QWaylandInputDevice *inputDevice, enum resize_edge edges) ++{ ++ resize(inputDevice->wl_seat(), ++ inputDevice->serial(), ++ edges); ++} ++ ++void QWaylandXdgSurface::move(QWaylandInputDevice *inputDevice) ++{ ++ move(inputDevice->wl_seat(), ++ inputDevice->serial()); ++} ++ ++void QWaylandXdgSurface::setMaximized() ++{ ++ m_maximized = true; ++ m_size = m_window->window()->geometry().size(); ++ set_maximized(); ++} ++ ++void QWaylandXdgSurface::setFullscreen() ++{ ++ m_fullscreen = true; ++ m_size = m_window->window()->geometry().size(); ++ set_fullscreen(); ++} ++ ++void QWaylandXdgSurface::setNormal() ++{ ++ if (m_fullscreen || m_maximized || m_minimized) { ++ if (m_maximized) { unset_maximized(); } ++ if (m_fullscreen) { unset_fullscreen(); } ++ ++ m_fullscreen = m_maximized = m_minimized = false; ++ setTopLevel(); ++ QMargins m = m_window->frameMargins(); ++ m_window->configure(0, m_size.width() + m.left() + m.right(), m_size.height() + m.top() + m.bottom()); ++ } ++} ++ ++void QWaylandXdgSurface::setMinimized() ++{ ++ m_minimized = true; ++ m_size = m_window->window()->geometry().size(); ++ set_minimized(); ++} ++ ++void QWaylandXdgSurface::setTopLevel() ++{ ++ // There's no xdg_shell_surface API for this, ignoring ++} ++ ++void QWaylandXdgSurface::updateTransientParent(QWindow *parent) ++{ ++ QWaylandWindow *parent_wayland_window = static_cast<QWaylandWindow *>(parent->handle()); ++ if (!parent_wayland_window) ++ return; ++ ++ // set_transient expects a position relative to the parent ++ QPoint transientPos = m_window->geometry().topLeft(); // this is absolute ++ QWindow *parentWin = m_window->window()->transientParent(); ++ transientPos -= parentWin->geometry().topLeft(); ++ if (parent_wayland_window->decoration()) { ++ transientPos.setX(transientPos.x() + parent_wayland_window->decoration()->margins().left()); ++ transientPos.setY(transientPos.y() + parent_wayland_window->decoration()->margins().top()); ++ } ++ ++ uint32_t flags = 0; ++ Qt::WindowFlags wf = m_window->window()->flags(); ++ if (wf.testFlag(Qt::ToolTip) ++ || wf.testFlag(Qt::WindowTransparentForInput)) ++ flags |= XDG_SURFACE_SET_TRANSIENT_FOR; ++ ++ set_transient_for(parent_wayland_window->object()); ++} ++ ++void QWaylandXdgSurface::setTitle(const QString & title) ++{ ++ return QtWayland::xdg_surface::set_title(title); ++} ++ ++void QWaylandXdgSurface::setAppId(const QString & appId) ++{ ++ return QtWayland::xdg_surface::set_app_id(appId); ++} ++ ++void QWaylandXdgSurface::xdg_surface_ping(uint32_t serial) ++{ ++ pong(serial); ++} ++ ++void QWaylandXdgSurface::xdg_surface_configure(uint32_t edges, int32_t width, ++ int32_t height) ++{ ++ m_window->configure(edges, width, height); ++} ++ ++ ++QT_END_NAMESPACE +diff --git a/src/client/qwaylandxdgsurface_p.h b/src/client/qwaylandxdgsurface_p.h +new file mode 100644 +index 0000000..744d3f3 +--- /dev/null ++++ b/src/client/qwaylandxdgsurface_p.h +@@ -0,0 +1,105 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies). ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#ifndef QWAYLANDXDGSURFACE_H ++#define QWAYLANDXDGSURFACE_H ++ ++#include <QtCore/QSize> ++ ++#include <wayland-client.h> ++ ++#include <QtWaylandClient/private/qwayland-xdg-shell.h> ++#include <QtWaylandClient/private/qwaylandclientexport_p.h> ++#include "qwaylandshellsurface_p.h" ++ ++QT_BEGIN_NAMESPACE ++ ++class QWaylandWindow; ++class QWaylandInputDevice; ++class QWindow; ++ ++class Q_WAYLAND_CLIENT_EXPORT QWaylandXdgSurface : public QtWayland::xdg_surface ++ , public QWaylandShellSurface ++{ ++public: ++ QWaylandXdgSurface(struct ::xdg_surface *shell_surface, QWaylandWindow *window); ++ virtual ~QWaylandXdgSurface(); ++ ++ using QtWayland::xdg_surface::resize; ++ void resize(QWaylandInputDevice *inputDevice, enum resize_edge edges); ++ ++ void resize(QWaylandInputDevice *inputDevice, enum wl_shell_surface_resize edges) Q_DECL_OVERRIDE; ++ ++ using QtWayland::xdg_surface::move; ++ void move(QWaylandInputDevice *inputDevice) Q_DECL_OVERRIDE; ++ ++ void setTitle(const QString &title) Q_DECL_OVERRIDE; ++ void setAppId(const QString &appId) Q_DECL_OVERRIDE; ++ ++ bool isFullscreen() const { return m_fullscreen; } ++ bool isMaximized() const { return m_maximized; } ++ ++private: ++ void setMaximized() Q_DECL_OVERRIDE; ++ void setFullscreen() Q_DECL_OVERRIDE; ++ void setNormal() Q_DECL_OVERRIDE; ++ void setMinimized() Q_DECL_OVERRIDE; ++ ++ void setTopLevel() Q_DECL_OVERRIDE; ++ void updateTransientParent(QWindow *parent) Q_DECL_OVERRIDE; ++ ++private: ++ QWaylandWindow *m_window; ++ bool m_maximized; ++ bool m_minimized; ++ bool m_fullscreen; ++ QSize m_size; ++ ++ void xdg_surface_ping(uint32_t serial) Q_DECL_OVERRIDE; ++ void xdg_surface_configure(uint32_t edges, ++ int32_t width, ++ int32_t height) Q_DECL_OVERRIDE; ++ friend class QWaylandWindow; ++}; ++ ++QT_END_NAMESPACE ++ ++#endif // QWAYLANDXDGSURFACE_H +-- +1.9.1 + diff --git a/recipes-qt/qt5/qtwayland/0019-xdg-shell-upgrade-to-support-current-version-weston-.patch b/recipes-qt/qt5/qtwayland/0019-xdg-shell-upgrade-to-support-current-version-weston-.patch new file mode 100644 index 000000000..8f0425a76 --- /dev/null +++ b/recipes-qt/qt5/qtwayland/0019-xdg-shell-upgrade-to-support-current-version-weston-.patch @@ -0,0 +1,772 @@ +From c4219cca0febd7119e0bec776fdc2877b3448e0b Mon Sep 17 00:00:00 2001 +From: Philippe Coval <philippe.coval@open.eurogiciel.org> +Date: Tue, 10 Jun 2014 16:22:17 +0200 +Subject: [PATCH 19/21] xdg-shell: upgrade to support current version + (weston-1.5.0) + +The protocol file is a raw copy of + +Source: http://cgit.freedesktop.org/wayland/weston/plain/protocol/xdg-shell.xml?id=1.5.0 + +Task-number: QTBUG-38633/related +Reviewed-by: Giulio Camuffo <giulio.camuffo@jollamobile.com> +Reviewed-by: Philippe Coval <rzr@gna.org> +Origin: https://www.qt.gitorious.org/qt/qtwayland/commit/4bac130b97fbaa565aa9883eb302557ef0185d50 +Change-Id: I41ca2f89c09a8b6348ce2fbf6d59f44b4c81ffff +--- + src/3rdparty/protocol/xdg-shell.xml | 288 ++++++++++++++++++------------------ + src/client/client.pro | 2 + + src/client/qwaylanddisplay.cpp | 10 +- + src/client/qwaylanddisplay_p.h | 5 +- + src/client/qwaylandxdgshell.cpp | 77 ++++++++++ + src/client/qwaylandxdgshell_p.h | 73 +++++++++ + src/client/qwaylandxdgsurface.cpp | 60 ++++++-- + src/client/qwaylandxdgsurface_p.h | 11 +- + 8 files changed, 364 insertions(+), 162 deletions(-) + create mode 100644 src/client/qwaylandxdgshell.cpp + create mode 100644 src/client/qwaylandxdgshell_p.h + +diff --git a/src/3rdparty/protocol/xdg-shell.xml b/src/3rdparty/protocol/xdg-shell.xml +index 4e5cff8..79a2831 100644 +--- a/src/3rdparty/protocol/xdg-shell.xml ++++ b/src/3rdparty/protocol/xdg-shell.xml +@@ -40,19 +40,22 @@ + + <enum name="version"> + <description summary="latest protocol version"> +- Use this enum to check the protocol version, and it will be updated +- automatically. ++ The 'current' member of this enum gives the version of the ++ protocol. Implementations can compare this to the version ++ they implement using static_assert to ensure the protocol and ++ implementation versions match. + </description> +- <entry name="current" value="1" summary="Always the latest version"/> ++ <entry name="current" value="3" summary="Always the latest version"/> + </enum> + + + <request name="use_unstable_version"> + <description summary="enable use of this unstable version"> +- Use this request in order to enable use of this interface. +- +- Understand and agree that one is using an unstable interface, +- that will likely change in the future, breaking the API. ++ Negotiate the unstable version of the interface. This ++ mechanism is in place to ensure client and server agree on the ++ unstable versions of the protocol that they speak or exit ++ cleanly if they don't agree. This request will go away once ++ the xdg-shell protocol is stable. + </description> + <arg name="version" type="int"/> + </request> +@@ -84,6 +87,28 @@ + <arg name="y" type="int"/> + <arg name="flags" type="uint"/> + </request> ++ ++ <event name="ping"> ++ <description summary="check if the client is alive"> ++ The ping event asks the client if it's still alive. Pass the ++ serial specified in the event back to the compositor by sending ++ a "pong" request back with the specified serial. ++ ++ Compositors can use this to determine if the client is still ++ alive. It's unspecified what will happen if the client doesn't ++ respond to the ping request, or in what timeframe. Clients should ++ try to respond in a reasonable amount of time. ++ </description> ++ <arg name="serial" type="uint" summary="pass this to the callback"/> ++ </event> ++ ++ <request name="pong"> ++ <description summary="respond to a ping event"> ++ A client must respond to a ping event with a pong request or ++ the client may be deemed unresponsive. ++ </description> ++ <arg name="serial" type="uint" summary="serial of the ping event"/> ++ </request> + </interface> + + <interface name="xdg_surface" version="1"> +@@ -124,6 +149,32 @@ + <arg name="parent" type="object" interface="wl_surface" allow-null="true"/> + </request> + ++ <request name="set_margin"> ++ <description summary="set the visible frame boundaries"> ++ This tells the compositor what the visible size of the window ++ should be, so it can use it to determine what borders to use for ++ constrainment and alignment. ++ ++ CSD often has invisible areas for decoration purposes, like drop ++ shadows. These "shadow" drawings need to be subtracted out of the ++ normal boundaries of the window when computing where to place ++ windows (e.g. to set this window so it's centered on top of another, ++ or to put it to the left or right of the screen.) ++ ++ This value should change as little as possible at runtime, to ++ prevent flicker. ++ ++ This value is also ignored when the window is maximized or ++ fullscreen, and assumed to be 0. ++ ++ If never called, this value is assumed to be 0. ++ </description> ++ <arg name="left_margin" type="int"/> ++ <arg name="right_margin" type="int"/> ++ <arg name="top_margin" type="int"/> ++ <arg name="bottom_margin" type="int"/> ++ </request> ++ + <request name="set_title"> + <description summary="set surface title"> + Set a short title for the surface. +@@ -150,22 +201,6 @@ + <arg name="app_id" type="string"/> + </request> + +- <request name="pong"> +- <description summary="respond to a ping event"> +- A client must respond to a ping event with a pong request or +- the client may be deemed unresponsive. +- </description> +- <arg name="serial" type="uint" summary="serial of the ping event"/> +- </request> +- +- <event name="ping"> +- <description summary="ping client"> +- Ping a client to check if it is receiving events and sending +- requests. A client is expected to reply with a pong request. +- </description> +- <arg name="serial" type="uint"/> +- </event> +- + <request name="move"> + <description summary="start an interactive move"> + Start a pointer-driven move of the surface. +@@ -217,12 +252,6 @@ + ignore it if it doesn't resize, pick a smaller size (to + satisfy aspect ratio or resize in steps of NxM pixels). + +- The edges parameter provides a hint about how the surface +- was resized. The client may use this information to decide +- how to adjust its content to the new size (e.g. a scrolling +- area might adjust its content position to leave the viewable +- content unmoved). Valid edge values are from resize_edge enum. +- + The client is free to dismiss all but the last configure + event it received. + +@@ -230,7 +259,6 @@ + in surface local coordinates. + </description> + +- <arg name="edges" type="uint"/> + <arg name="width" type="int"/> + <arg name="height" type="int"/> + </event> +@@ -250,128 +278,122 @@ + <arg name="output" type="object" interface="wl_output" allow-null="true"/> + </request> + +- <event name="request_set_fullscreen"> +- <description summary="server requests that the client set fullscreen"> +- Event sent from the compositor to the client requesting that the client +- goes to a fullscreen state. It's the client job to call set_fullscreen +- and really trigger the fullscreen state. +- </description> +- </event> +- +- <event name="request_unset_fullscreen"> +- <description summary="server requests that the client unset fullscreen"> +- Event sent from the compositor to the client requesting that the client +- leaves the fullscreen state. It's the client job to call +- unset_fullscreen and really leave the fullscreen state. +- </description> +- </event> ++ <enum name="state"> ++ <description summary="types of state on the surface"> ++ The different state values used on the surface. This is designed for ++ state values like maximized, fullscreen. It is paired with the ++ request_change_state event to ensure that both the client and the ++ compositor setting the state can be synchronized. + +- <request name="set_fullscreen"> +- <description summary="set the surface state as fullscreen"> +- Set the surface as fullscreen. ++ States set in this way are double-buffered. They will get applied on ++ the next commit. + +- After this request, the compositor should send a configure event +- informing the output size. ++ Desktop environments may extend this enum by taking up a range of ++ values and documenting the range they chose in this description. ++ They are not required to document the values for the range that they ++ chose. Ideally, any good extensions from a desktop environment should ++ make its way into standardization into this enum. + +- This request informs the compositor that the next attached buffer +- committed will be in a fullscreen state. The buffer size should be the +- same size as the size informed in the configure event, if the client +- doesn't want to leave any empty area. ++ The current reserved ranges are: + +- In other words: the next attached buffer after set_maximized is the new +- maximized buffer. And the surface will be positioned at the maximized +- position on commit. +- +- A simple way to synchronize and wait for the correct configure event is +- to use a wl_display.sync request right after the set_fullscreen +- request. When the sync callback returns, the last configure event +- received just before it will be the correct one, and should contain the +- right size for the surface to maximize. +- +- Setting one state won't unset another state. Use +- xdg_surface.unset_fullscreen for unsetting it. ++ 0x0000 - 0x0FFF: xdg-shell core values, documented below. ++ 0x1000 - 0x1FFF: GNOME + </description> +- </request> ++ <entry name="maximized" value="1" summary="the surface is maximized"> ++ A non-zero value indicates the surface is maximized. Otherwise, ++ the surface is unmaximized. ++ </entry> ++ <entry name="fullscreen" value="2" summary="the surface is fullscreen"> ++ A non-zero value indicates the surface is fullscreen. Otherwise, ++ the surface is not fullscreen. ++ </entry> ++ </enum> + +- <request name="unset_fullscreen"> +- <description summary="unset the surface state as fullscreen"> +- Unset the surface fullscreen state. ++ <request name="request_change_state"> ++ <description summary="client requests to change a surface's state"> ++ This asks the compositor to change the state. If the compositor wants ++ to change the state, it will send a change_state event with the same ++ state_type, value, and serial, and the event flow continues as if it ++ it was initiated by the compositor. + +- Same negotiation as set_fullscreen must be used. ++ If the compositor does not want to change the state, it will send a ++ change_state to the client with the old value of the state. + </description> ++ <arg name="state_type" type="uint" summary="the state to set"/> ++ <arg name="value" type="uint" summary="the value to change the state to"/> ++ <arg name="serial" type="uint" summary="an event serial"> ++ This serial is so the client can know which change_state event corresponds ++ to which request_change_state request it sent out. ++ </arg> + </request> + +- <event name="request_set_maximized"> +- <description summary="server requests that the client set maximized"> +- Event sent from the compositor to the client requesting that the client +- goes to a maximized state. It's the client job to call set_maximized +- and really trigger the maximized state. ++ <event name="change_state"> ++ <description summary="compositor wants to change a surface's state"> ++ This event tells the client to change a surface's state. The client ++ should respond with an ack_change_state request to the compositor to ++ guarantee that the compositor knows that the client has seen it. + </description> +- </event> + +- <event name="request_unset_maximized"> +- <description summary="server requests that the client unset maximized"> +- Event sent from the compositor to the client requesting that the client +- leaves the maximized state. It's the client job to call unset_maximized +- and really leave the maximized state. +- </description> ++ <arg name="state_type" type="uint" summary="the state to set"/> ++ <arg name="value" type="uint" summary="the value to change the state to"/> ++ <arg name="serial" type="uint" summary="a serial for the compositor's own tracking"/> + </event> + +- <request name="set_maximized"> +- <description summary="set the surface state as maximized"> +- Set the surface as maximized. +- +- After this request, the compositor will send a configure event +- informing the output size minus panel and other MW decorations. +- +- This request informs the compositor that the next attached buffer +- committed will be in a maximized state. The buffer size should be the +- same size as the size informed in the configure event, if the client +- doesn't want to leave any empty area. ++ <request name="ack_change_state"> ++ <description summary="ack a change_state event"> ++ When a change_state event is received, a client should then ack it ++ using the ack_change_state request to ensure that the compositor ++ knows the client has seen the event. + +- In other words: the next attached buffer after set_maximized is the new +- maximized buffer. And the surface will be positioned at the maximized +- position on commit. ++ By this point, the state is confirmed, and the next attach should ++ contain the buffer drawn for the new state value. + +- A simple way to synchronize and wait for the correct configure event is +- to use a wl_display.sync request right after the set_maximized request. +- When the sync callback returns, the last configure event received just +- before it will be the correct one, and should contain the right size +- for the surface to maximize. +- +- Setting one state won't unset another state. Use +- xdg_surface.unset_maximized for unsetting it. ++ The values here need to be the same as the values in the cooresponding ++ change_state event. + </description> ++ <arg name="state_type" type="uint" summary="the state to set"/> ++ <arg name="value" type="uint" summary="the value to change the state to"/> ++ <arg name="serial" type="uint" summary="a serial to pass to change_state"/> + </request> + +- <request name="unset_maximized"> +- <description summary="unset the surface state as maximized"> +- Unset the surface maximized state. +- +- Same negotiation as set_maximized must be used. ++ <request name="set_minimized"> ++ <description summary="minimize the surface"> ++ Minimize the surface. + </description> + </request> + +- <request name="set_minimized"> +- <description summary="set the surface state as minimized"> +- Set the surface minimized state. +- +- Setting one state won't unset another state. ++ <event name="activated"> ++ <description summary="surface was activated"> ++ The activated_set event is sent when this surface has been ++ activated, which means that the surface has user attention. ++ Window decorations should be updated accordingly. You should ++ not use this event for anything but the style of decorations ++ you display, use wl_keyboard.enter and wl_keyboard.leave for ++ determining keyboard focus. + </description> +- </request> ++ </event> + +- <event name="focused_set"> +- <description summary="surface was focused"> +- The focused_set event is sent when this surface has been +- activated. Window decorations should be updated accordingly. ++ <event name="deactivated"> ++ <description summary="surface was deactivated"> ++ The deactivate event is sent when this surface has been ++ deactivated, which means that the surface lost user attention. ++ Window decorations should be updated accordingly. You should ++ not use this event for anything but the style of decorations ++ you display, use wl_keyboard.enter and wl_keyboard.leave for ++ determining keyboard focus. + </description> + </event> + +- <event name="focused_unset"> +- <description summary="surface was unfocused"> +- The focused_unset event is sent when this surface has been +- deactivated, because another surface has been activated. Window +- decorations should be updated accordingly. ++ <event name="close"> ++ <description summary="surface wants to be closed"> ++ The close event is sent by the compositor when the user ++ wants the surface to be closed. This should be equivalent to ++ the user clicking the close button in client-side decorations, ++ if your application has any... ++ ++ This is only a request that the user intends to close your ++ window. The client may choose to ignore this request, or show ++ a dialog to ask the user to save their data... + </description> + </event> + </interface> +@@ -409,22 +431,6 @@ + </description> + </request> + +- <request name="pong"> +- <description summary="respond to a ping event"> +- A client must respond to a ping event with a pong request or +- the client may be deemed unresponsive. +- </description> +- <arg name="serial" type="uint" summary="serial of the ping event"/> +- </request> +- +- <event name="ping"> +- <description summary="ping client"> +- Ping a client to check if it is receiving events and sending +- requests. A client is expected to reply with a pong request. +- </description> +- <arg name="serial" type="uint"/> +- </event> +- + <event name="popup_done"> + <description summary="popup interaction is done"> + The popup_done event is sent out when a popup grab is broken, +diff --git a/src/client/client.pro b/src/client/client.pro +index 9ecf82f..73e3b7f 100644 +--- a/src/client/client.pro ++++ b/src/client/client.pro +@@ -59,6 +59,7 @@ SOURCES += qwaylandintegration.cpp \ + qwaylanddatasource.cpp \ + qwaylandshellsurface.cpp \ + qwaylandwlshellsurface.cpp \ ++ qwaylandxdgshell.cpp \ + qwaylandxdgsurface.cpp \ + qwaylandextendedoutput.cpp \ + qwaylandextendedsurface.cpp \ +@@ -89,6 +90,7 @@ HEADERS += qwaylandintegration_p.h \ + qwaylanddatasource_p.h \ + qwaylandshellsurface_p.h \ + qwaylandwlshellsurface_p.h \ ++ qwaylandxdgshell_p.h \ + qwaylandxdgsurface_p.h \ + qwaylandextendedoutput_p.h \ + qwaylandextendedsurface_p.h \ +diff --git a/src/client/qwaylanddisplay.cpp b/src/client/qwaylanddisplay.cpp +index 7f953ad..2e25672 100644 +--- a/src/client/qwaylanddisplay.cpp ++++ b/src/client/qwaylanddisplay.cpp +@@ -50,7 +50,7 @@ + #include "qwaylandclipboard_p.h" + #include "qwaylanddatadevicemanager_p.h" + #include "qwaylandhardwareintegration_p.h" +- ++#include "qwaylandxdgshell_p.h" + + #include "qwaylandwindowmanagerintegration_p.h" + +@@ -209,8 +209,7 @@ void QWaylandDisplay::registry_global(uint32_t id, const QString &interface, uin + mShm = static_cast<struct wl_shm *>(wl_registry_bind(registry, id, &wl_shm_interface,1)); + } else if (interface == QStringLiteral("xdg_shell") + && qEnvironmentVariableIsSet("QT_WAYLAND_USE_XDG_SHELL")) { +- mShellXdg.reset(new QtWayland::xdg_shell(registry, id)); +- mShellXdg->use_unstable_version(QtWayland::xdg_shell::version_current); ++ mShellXdg.reset(new QWaylandXdgShell(registry,id)); + } else if (interface == QStringLiteral("wl_shell")){ + mShell.reset(new QtWayland::wl_shell(registry, id)); + } else if (interface == QStringLiteral("wl_seat")) { +@@ -275,4 +274,9 @@ void QWaylandDisplay::forceRoundTrip() + wl_display_roundtrip(mDisplay); + } + ++QtWayland::xdg_shell *QWaylandDisplay::shellXdg() ++{ ++ return mShellXdg.data(); ++} ++ + QT_END_NAMESPACE +diff --git a/src/client/qwaylanddisplay_p.h b/src/client/qwaylanddisplay_p.h +index cf5dfc2..f1b35a7 100644 +--- a/src/client/qwaylanddisplay_p.h ++++ b/src/client/qwaylanddisplay_p.h +@@ -72,6 +72,7 @@ class QWaylandWindow; + class QWaylandEventThread; + class QWaylandIntegration; + class QWaylandHardwareIntegration; ++class QWaylandXdgShell; + + namespace QtWayland { + class qt_output_extension; +@@ -115,7 +116,7 @@ public: + QtWayland::wl_compositor *compositor() { return &mCompositor; } + + QtWayland::wl_shell *shell() { return mShell.data(); } +- QtWayland::xdg_shell *shellXdg() { return mShellXdg.data(); } ++ QtWayland::xdg_shell *shellXdg(); + + QList<QWaylandInputDevice *> inputDevices() const { return mInputDevices; } + QWaylandInputDevice *defaultInputDevice() const; +@@ -171,7 +172,7 @@ private: + QThread *mEventThread; + QWaylandEventThread *mEventThreadObject; + QScopedPointer<QtWayland::wl_shell> mShell; +- QScopedPointer<QtWayland::xdg_shell> mShellXdg; ++ QScopedPointer<QWaylandXdgShell> mShellXdg; + QList<QPlatformScreen *> mScreens; + QList<QWaylandInputDevice *> mInputDevices; + QList<Listener> mRegistryListeners; +diff --git a/src/client/qwaylandxdgshell.cpp b/src/client/qwaylandxdgshell.cpp +new file mode 100644 +index 0000000..eb9f91c +--- /dev/null ++++ b/src/client/qwaylandxdgshell.cpp +@@ -0,0 +1,77 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2014 Eurogiciel, author: <philippe.coval@eurogiciel.fr> ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include "qwaylandxdgshell_p.h" ++ ++#include "qwaylanddisplay_p.h" ++#include "qwaylandwindow_p.h" ++#include "qwaylandinputdevice_p.h" ++#include "qwaylanddecoration_p.h" ++#include "qwaylandscreen_p.h" ++ ++#include <QtCore/QDebug> ++ ++QT_BEGIN_NAMESPACE ++ ++QWaylandXdgShell::QWaylandXdgShell(struct ::xdg_shell *shell) ++ : QtWayland::xdg_shell(shell) ++{ ++} ++ ++QWaylandXdgShell::QWaylandXdgShell(struct ::wl_registry *registry, uint32_t id) ++ : QtWayland::xdg_shell(registry, id) ++{ ++ use_unstable_version(QtWayland::xdg_shell::version_current); ++} ++ ++QWaylandXdgShell::~QWaylandXdgShell() ++{ ++ xdg_shell_destroy(object()); ++} ++ ++ ++void QWaylandXdgShell::xdg_shell_ping(uint32_t serial) ++{ ++ pong(serial); ++} ++ ++ ++QT_END_NAMESPACE +diff --git a/src/client/qwaylandxdgshell_p.h b/src/client/qwaylandxdgshell_p.h +new file mode 100644 +index 0000000..6a396bd +--- /dev/null ++++ b/src/client/qwaylandxdgshell_p.h +@@ -0,0 +1,73 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2014 Eurogiciel, author: <philippe.coval@eurogiciel.fr> ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#ifndef QWAYLANDXDGSHELL_H ++#define QWAYLANDXDGSHELL_H ++ ++#include <QtCore/QSize> ++ ++#include <wayland-client.h> ++ ++#include <QtWaylandClient/private/qwayland-xdg-shell.h> ++#include <QtWaylandClient/private/qwaylandclientexport_p.h> ++#include "qwaylandshellsurface_p.h" ++ ++QT_BEGIN_NAMESPACE ++ ++class QWaylandWindow; ++class QWaylandInputDevice; ++class QWindow; ++ ++class Q_WAYLAND_CLIENT_EXPORT QWaylandXdgShell : public QtWayland::xdg_shell ++{ ++public: ++ QWaylandXdgShell(struct ::xdg_shell *shell); ++ QWaylandXdgShell(struct ::wl_registry *registry, uint32_t id); ++ ++ virtual ~QWaylandXdgShell(); ++ ++private: ++ void xdg_shell_ping(uint32_t serial) Q_DECL_OVERRIDE; ++}; ++ ++QT_END_NAMESPACE ++ ++#endif // QWAYLANDXDGSHELL_H +diff --git a/src/client/qwaylandxdgsurface.cpp b/src/client/qwaylandxdgsurface.cpp +index 1b8affa..5fb74d2 100644 +--- a/src/client/qwaylandxdgsurface.cpp ++++ b/src/client/qwaylandxdgsurface.cpp +@@ -87,23 +87,25 @@ void QWaylandXdgSurface::move(QWaylandInputDevice *inputDevice) + + void QWaylandXdgSurface::setMaximized() + { +- m_maximized = true; +- m_size = m_window->window()->geometry().size(); +- set_maximized(); ++ if (!m_maximized) ++ request_change_state(XDG_SURFACE_STATE_MAXIMIZED, true, 0); + } + + void QWaylandXdgSurface::setFullscreen() + { +- m_fullscreen = true; +- m_size = m_window->window()->geometry().size(); +- set_fullscreen(); ++ if (!m_fullscreen) ++ request_change_state(XDG_SURFACE_STATE_FULLSCREEN, true, 0); + } + + void QWaylandXdgSurface::setNormal() + { + if (m_fullscreen || m_maximized || m_minimized) { +- if (m_maximized) { unset_maximized(); } +- if (m_fullscreen) { unset_fullscreen(); } ++ if (m_maximized) { ++ request_change_state(XDG_SURFACE_STATE_MAXIMIZED, false, 0); ++ } ++ if (m_fullscreen) { ++ request_change_state(XDG_SURFACE_STATE_FULLSCREEN, false, 0); ++ } + + m_fullscreen = m_maximized = m_minimized = false; + setTopLevel(); +@@ -158,16 +160,48 @@ void QWaylandXdgSurface::setAppId(const QString & appId) + return QtWayland::xdg_surface::set_app_id(appId); + } + +-void QWaylandXdgSurface::xdg_surface_ping(uint32_t serial) ++void QWaylandXdgSurface::xdg_surface_configure(int32_t width, int32_t height) + { +- pong(serial); ++ m_window->configure(0 , width, height); + } + +-void QWaylandXdgSurface::xdg_surface_configure(uint32_t edges, int32_t width, +- int32_t height) ++void QWaylandXdgSurface::xdg_surface_change_state(uint32_t state, ++ uint32_t value, ++ uint32_t serial) + { +- m_window->configure(edges, width, height); ++ ++ if (state == XDG_SURFACE_STATE_MAXIMIZED ++ || state == XDG_SURFACE_STATE_FULLSCREEN) { ++ if (value) { ++ m_size = m_window->window()->geometry().size(); ++ } else { ++ QMargins m = m_window->frameMargins(); ++ m_window->configure(0, m_size.width() + m.left() + m.right(), m_size.height() + m.top() + m.bottom()); ++ } ++ } ++ ++ switch (state) { ++ case XDG_SURFACE_STATE_MAXIMIZED: ++ m_maximized = value; ++ break; ++ case XDG_SURFACE_STATE_FULLSCREEN: ++ m_fullscreen = value; ++ break; ++ } ++ ++ xdg_surface_ack_change_state(object(), state, value, serial); + } + ++void QWaylandXdgSurface::xdg_surface_activated() ++{ ++} ++ ++void QWaylandXdgSurface::xdg_surface_deactivated() ++{ ++} ++ ++void QWaylandXdgSurface::xdg_surface_close() ++{ ++} + + QT_END_NAMESPACE +diff --git a/src/client/qwaylandxdgsurface_p.h b/src/client/qwaylandxdgsurface_p.h +index 744d3f3..d2a154e 100644 +--- a/src/client/qwaylandxdgsurface_p.h ++++ b/src/client/qwaylandxdgsurface_p.h +@@ -93,10 +93,15 @@ private: + bool m_fullscreen; + QSize m_size; + +- void xdg_surface_ping(uint32_t serial) Q_DECL_OVERRIDE; +- void xdg_surface_configure(uint32_t edges, +- int32_t width, ++ void xdg_surface_configure(int32_t width, + int32_t height) Q_DECL_OVERRIDE; ++ void xdg_surface_change_state(uint32_t state, ++ uint32_t value, ++ uint32_t serial) Q_DECL_OVERRIDE; ++ void xdg_surface_activated() Q_DECL_OVERRIDE; ++ void xdg_surface_deactivated() Q_DECL_OVERRIDE; ++ void xdg_surface_close() Q_DECL_OVERRIDE; ++ + friend class QWaylandWindow; + }; + +-- +1.9.1 + diff --git a/recipes-qt/qt5/qtwayland/0020-Add-IVI-Shell-protocol-file-version-patch-v6.patch b/recipes-qt/qt5/qtwayland/0020-Add-IVI-Shell-protocol-file-version-patch-v6.patch new file mode 100644 index 000000000..413459fb6 --- /dev/null +++ b/recipes-qt/qt5/qtwayland/0020-Add-IVI-Shell-protocol-file-version-patch-v6.patch @@ -0,0 +1,128 @@ +From b4f032b13338ad6c21024177b031c75063ef7493 Mon Sep 17 00:00:00 2001 +From: Manuel Bachmann <manuel.bachmann@open.eurogiciel.org> +Date: Sun, 7 Sep 2014 08:19:30 +0200 +Subject: [PATCH 20/21] Add IVI-Shell protocol file version patch v6 + +Source : http://lists.freedesktop.org/archives/wayland-devel/2014-June/015617.html + +This file comes from the last proposed definition of the IVI-Shell protocol, +and will need to be refreshed on protocol update. + +Task-number: QTBUG-XXXXX/part/1of2 + +Signed-off-by: Manuel Bachmann <manuel.bachmann@open.eurogiciel.org> +--- + src/3rdparty/protocol/ivi-application.xml | 101 ++++++++++++++++++++++++++++++ + 1 file changed, 101 insertions(+) + create mode 100644 src/3rdparty/protocol/ivi-application.xml + +diff --git a/src/3rdparty/protocol/ivi-application.xml b/src/3rdparty/protocol/ivi-application.xml +new file mode 100644 +index 0000000..833fd38 +--- /dev/null ++++ b/src/3rdparty/protocol/ivi-application.xml +@@ -0,0 +1,101 @@ ++<?xml version="1.0" encoding="UTF-8"?> ++<protocol name="ivi_application"> ++ ++ <copyright> ++ Copyright (C) 2013 DENSO CORPORATION ++ Copyright (c) 2013 BMW Car IT GmbH ++ ++ Permission is hereby granted, free of charge, to any person obtaining a copy ++ of this software and associated documentation files (the "Software"), to deal ++ in the Software without restriction, including without limitation the rights ++ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++ copies of the Software, and to permit persons to whom the Software is ++ furnished to do so, subject to the following conditions: ++ ++ The above copyright notice and this permission notice shall be included in ++ all copies or substantial portions of the Software. ++ ++ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN ++ THE SOFTWARE. ++ </copyright> ++ ++ <interface name="ivi_surface" version="1"> ++ <description summary="application interface to surface in ivi compositor"/> ++ ++ <request name="destroy" type="destructor"> ++ <description summary="destroy ivi_surface"> ++ This removes link from ivi_id to wl_surface and destroys ivi_surface. ++ </description> ++ </request> ++ ++ <event name="visibility"> ++ <description summary="visibility of surface in ivi compositor has changed"> ++ The new visibility state is provided in argument visibility. ++ If visibility is 0, the surface has become invisible. ++ If visibility is not 0, the surface has become visible. ++ </description> ++ <arg name="visibility" type="int"/> ++ </event> ++ ++ <enum name="warning_code"> ++ <description summary="possible warning codes returned by ivi compositor"> ++ These define all possible warning codes returned by ivi compositor on server-side warnings. ++ invalid_wl_surface: ++ - wl_surface already has a another role. ++ - wl_surface is destroyed before the ivi_surface is destroyed. ++ ivi_id_in_use: ivi_id is already assigned by another application. ++ </description> ++ <entry name="invalid_wl_surface" value="1" summary="wl_surface is invalid"/> ++ <entry name="ivi_id_in_use" value="2" summary="ivi_id is in use and can not be shared"/> ++ </enum> ++ ++ <event name="warning"> ++ <description summary="server-side warning detected"> ++ The ivi compositor encountered warning while processing a request by this ++ application. The warning is defined by argument warning_code and optional ++ warning_text. If the warning is detected, client shall destroy the ivi_surface ++ object. ++ ++ When a warning event is sent, the compositor turns the ivi_surface object inert. ++ The ivi_surface will not deliver further events, all requests on it are ignored ++ except 'destroy', and the association to the ivi_id is removed. The client ++ should destroy the ivi_surface object. If an inert ivi_surface object is used as ++ an argument to any other object's request, that request will [produce a fatal ++ error / produce a warning / be ignored]. ++ </description> ++ <arg name="warning_code" type="int"/> ++ <arg name="warning_text" type="string" allow-null="true"/> ++ </event> ++ ++ </interface> ++ ++ <interface name="ivi_application" version="1"> ++ <description summary="create ivi-style surfaces"> ++ This interface is implemented by servers that provide desktop-style user interfaces. ++ It allows clients to associate a ivi_surface with a basic surface. ++ </description> ++ ++ <request name="surface_create"> ++ <description summary="create ivi_surface with numeric ID in ivi compositor"> ++ surface_create will create a interface:ivi_surface with numeric ID; ivi_id in ++ ivi compositor. These ivi_ids are defined as unique in the system to identify ++ it inside of ivi compositor. The ivi compositor implements business logic how to ++ set properties of the surface with ivi_id according to status of the system. ++ E.g. a unique ID for Car Navigation application is used for implementing special ++ logic of the application about where it shall be located. ++ if a wl_surface which already has another role is set, the server regards this as ++ error and disconnects the client. ++ </description> ++ <arg name="ivi_id" type="uint"/> ++ <arg name="surface" type="object" interface="wl_surface"/> ++ <arg name="id" type="new_id" interface="ivi_surface"/> ++ </request> ++ ++ </interface> ++ ++</protocol> +-- +1.9.1 + diff --git a/recipes-qt/qt5/qtwayland/0021-Implement-initial-IVI-Shell-support.patch b/recipes-qt/qt5/qtwayland/0021-Implement-initial-IVI-Shell-support.patch new file mode 100644 index 000000000..8723def26 --- /dev/null +++ b/recipes-qt/qt5/qtwayland/0021-Implement-initial-IVI-Shell-support.patch @@ -0,0 +1,539 @@ +From 1ddfa43692cabae0f552351cfbc09377e479471e Mon Sep 17 00:00:00 2001 +From: Manuel Bachmann <manuel.bachmann@open.eurogiciel.org> +Date: Mon, 8 Sep 2014 11:38:01 +0200 +Subject: [PATCH 21/21] Implement initial IVI-Shell support + +IVI-Shell provides a shell interface for Weston, which maps the GENIVI API (http://www.genivi.org) for In-Vehicle Infotainment. + +This patch enables detecting the IVI-Shell interface at runtime, and creating compatible surfaces if found. + +Task-number: QTBUG-XXXXX/part/2of2 + +Change-Id: I1f6c11bf56b727a54fb48faab9c076b61d635440 +Signed-off-by: Manuel Bachmann <manuel.bachmann@open.eurogiciel.org> +--- + src/client/client.pro | 5 ++ + src/client/qwaylanddisplay.cpp | 9 ++++ + src/client/qwaylanddisplay_p.h | 5 ++ + src/client/qwaylandivishell.cpp | 69 +++++++++++++++++++++++++ + src/client/qwaylandivishell_p.h | 70 +++++++++++++++++++++++++ + src/client/qwaylandivisurface.cpp | 105 ++++++++++++++++++++++++++++++++++++++ + src/client/qwaylandivisurface_p.h | 90 ++++++++++++++++++++++++++++++++ + src/client/qwaylandwindow.cpp | 8 ++- + 8 files changed, 360 insertions(+), 1 deletion(-) + create mode 100644 src/client/qwaylandivishell.cpp + create mode 100644 src/client/qwaylandivishell_p.h + create mode 100644 src/client/qwaylandivisurface.cpp + create mode 100644 src/client/qwaylandivisurface_p.h + +diff --git a/src/client/client.pro b/src/client/client.pro +index 73e3b7f..adb526d 100644 +--- a/src/client/client.pro ++++ b/src/client/client.pro +@@ -42,6 +42,7 @@ WAYLANDCLIENTSOURCES += \ + ../extensions/windowmanager.xml \ + ../3rdparty/protocol/text.xml \ + ../3rdparty/protocol/xdg-shell.xml \ ++ ../3rdparty/protocol/ivi-application.xml \ + + SOURCES += qwaylandintegration.cpp \ + qwaylandnativeinterface.cpp \ +@@ -61,6 +62,8 @@ SOURCES += qwaylandintegration.cpp \ + qwaylandwlshellsurface.cpp \ + qwaylandxdgshell.cpp \ + qwaylandxdgsurface.cpp \ ++ qwaylandivishell.cpp \ ++ qwaylandivisurface.cpp \ + qwaylandextendedoutput.cpp \ + qwaylandextendedsurface.cpp \ + qwaylandsubsurface.cpp \ +@@ -92,6 +95,8 @@ HEADERS += qwaylandintegration_p.h \ + qwaylandwlshellsurface_p.h \ + qwaylandxdgshell_p.h \ + qwaylandxdgsurface_p.h \ ++ qwaylandivishell_p.h \ ++ qwaylandivisurface_p.h \ + qwaylandextendedoutput_p.h \ + qwaylandextendedsurface_p.h \ + qwaylandsubsurface_p.h \ +diff --git a/src/client/qwaylanddisplay.cpp b/src/client/qwaylanddisplay.cpp +index 2e25672..2a93db7 100644 +--- a/src/client/qwaylanddisplay.cpp ++++ b/src/client/qwaylanddisplay.cpp +@@ -51,6 +51,7 @@ + #include "qwaylanddatadevicemanager_p.h" + #include "qwaylandhardwareintegration_p.h" + #include "qwaylandxdgshell_p.h" ++#include "qwaylandivishell_p.h" + + #include "qwaylandwindowmanagerintegration_p.h" + +@@ -62,6 +63,7 @@ + + #include <QtWaylandClient/private/qwayland-text.h> + #include <QtWaylandClient/private/qwayland-xdg-shell.h> ++#include <QtWaylandClient/private/qwayland-ivi-application.h> + + #include <QtCore/QAbstractEventDispatcher> + #include <QtGui/private/qguiapplication_p.h> +@@ -207,6 +209,8 @@ void QWaylandDisplay::registry_global(uint32_t id, const QString &interface, uin + mCompositor.init(registry, id); + } else if (interface == QStringLiteral("wl_shm")) { + mShm = static_cast<struct wl_shm *>(wl_registry_bind(registry, id, &wl_shm_interface,1)); ++ } else if (interface == QStringLiteral("ivi_application")) { ++ mShellIvi.reset(new QWaylandIviShell(registry,id)); + } else if (interface == QStringLiteral("xdg_shell") + && qEnvironmentVariableIsSet("QT_WAYLAND_USE_XDG_SHELL")) { + mShellXdg.reset(new QWaylandXdgShell(registry,id)); +@@ -279,4 +283,9 @@ QtWayland::xdg_shell *QWaylandDisplay::shellXdg() + return mShellXdg.data(); + } + ++QtWayland::ivi_application *QWaylandDisplay::shellIvi() ++{ ++ return mShellIvi.data(); ++} ++ + QT_END_NAMESPACE +diff --git a/src/client/qwaylanddisplay_p.h b/src/client/qwaylanddisplay_p.h +index f1b35a7..b9c686c 100644 +--- a/src/client/qwaylanddisplay_p.h ++++ b/src/client/qwaylanddisplay_p.h +@@ -52,6 +52,7 @@ + #include <QtWaylandClient/private/qwayland-wayland.h> + #include <QtWaylandClient/private/qwaylandclientexport_p.h> + #include <QtWaylandClient/private/qwayland-xdg-shell.h> ++#include <QtWaylandClient/private/qwayland-ivi-application.h> + + struct wl_cursor_image; + +@@ -72,6 +73,7 @@ class QWaylandWindow; + class QWaylandEventThread; + class QWaylandIntegration; + class QWaylandHardwareIntegration; ++class QWaylandIviShell; + class QWaylandXdgShell; + + namespace QtWayland { +@@ -81,6 +83,7 @@ namespace QtWayland { + class qt_surface_extension; + class wl_text_input_manager; + class xdg_shell; ++ class ivi_application; + } + + typedef void (*RegistryListener)(void *data, +@@ -117,6 +120,7 @@ public: + + QtWayland::wl_shell *shell() { return mShell.data(); } + QtWayland::xdg_shell *shellXdg(); ++ QtWayland::ivi_application *shellIvi(); + + QList<QWaylandInputDevice *> inputDevices() const { return mInputDevices; } + QWaylandInputDevice *defaultInputDevice() const; +@@ -173,6 +177,7 @@ private: + QWaylandEventThread *mEventThreadObject; + QScopedPointer<QtWayland::wl_shell> mShell; + QScopedPointer<QWaylandXdgShell> mShellXdg; ++ QScopedPointer<QWaylandIviShell> mShellIvi; + QList<QPlatformScreen *> mScreens; + QList<QWaylandInputDevice *> mInputDevices; + QList<Listener> mRegistryListeners; +diff --git a/src/client/qwaylandivishell.cpp b/src/client/qwaylandivishell.cpp +new file mode 100644 +index 0000000..9d63d0d +--- /dev/null ++++ b/src/client/qwaylandivishell.cpp +@@ -0,0 +1,69 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2014 Eurogiciel, author: <manuel.bachmann@open.eurogiciel.org> ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include "qwaylandivishell_p.h" ++ ++#include "qwaylanddisplay_p.h" ++#include "qwaylandwindow_p.h" ++#include "qwaylandinputdevice_p.h" ++#include "qwaylanddecoration_p.h" ++#include "qwaylandscreen_p.h" ++ ++#include <QtCore/QDebug> ++ ++QT_BEGIN_NAMESPACE ++ ++QWaylandIviShell::QWaylandIviShell(struct ::ivi_application *shell) ++ : QtWayland::ivi_application(shell) ++{ ++} ++ ++QWaylandIviShell::QWaylandIviShell(struct ::wl_registry *registry, uint32_t id) ++ : QtWayland::ivi_application(registry, id) ++{ ++} ++ ++QWaylandIviShell::~QWaylandIviShell() ++{ ++ ivi_application_destroy(object()); ++} ++ ++QT_END_NAMESPACE +diff --git a/src/client/qwaylandivishell_p.h b/src/client/qwaylandivishell_p.h +new file mode 100644 +index 0000000..f9f6983 +--- /dev/null ++++ b/src/client/qwaylandivishell_p.h +@@ -0,0 +1,70 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2014 Eurogiciel, author: <manuel.bachmann@open.eurogiciel.org> ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#ifndef QWAYLANDIVISHELL_H ++#define QWAYLANDIVISHELL_H ++ ++#include <QtCore/QSize> ++ ++#include <wayland-client.h> ++ ++#include <QtWaylandClient/private/qwayland-ivi-application.h> ++#include <QtWaylandClient/private/qwaylandclientexport_p.h> ++#include "qwaylandshellsurface_p.h" ++ ++QT_BEGIN_NAMESPACE ++ ++class QWaylandWindow; ++class QWaylandInputDevice; ++class QWindow; ++ ++class Q_WAYLAND_CLIENT_EXPORT QWaylandIviShell : public QtWayland::ivi_application ++{ ++public: ++ QWaylandIviShell(struct ::ivi_application *shell); ++ QWaylandIviShell(struct ::wl_registry *registry, uint32_t id); ++ ++ virtual ~QWaylandIviShell(); ++}; ++ ++QT_END_NAMESPACE ++ ++#endif // QWAYLANDIVISHELL_H +diff --git a/src/client/qwaylandivisurface.cpp b/src/client/qwaylandivisurface.cpp +new file mode 100644 +index 0000000..a12309e +--- /dev/null ++++ b/src/client/qwaylandivisurface.cpp +@@ -0,0 +1,105 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies). ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include "qwaylandivisurface_p.h" ++ ++#include "qwaylanddisplay_p.h" ++#include "qwaylandwindow_p.h" ++#include "qwaylandinputdevice_p.h" ++#include "qwaylanddecoration_p.h" ++#include "qwaylandscreen_p.h" ++ ++#include <QtCore/QDebug> ++ ++QT_BEGIN_NAMESPACE ++ ++QWaylandIviSurface::QWaylandIviSurface(struct ::ivi_surface *ivi_surface, QWaylandWindow *window) ++ : QtWayland::ivi_surface(ivi_surface) ++ , m_window(window) ++{ ++} ++ ++QWaylandIviSurface::~QWaylandIviSurface() ++{ ++ ivi_surface_destroy(object()); ++} ++ ++void QWaylandIviSurface::resize(QWaylandInputDevice *inputDevice, enum wl_shell_surface_resize edges) ++{ ++} ++ ++void QWaylandIviSurface::move(QWaylandInputDevice *inputDevice) ++{ ++} ++ ++void QWaylandIviSurface::setMaximized() ++{ ++} ++ ++void QWaylandIviSurface::setFullscreen() ++{ ++} ++ ++void QWaylandIviSurface::setNormal() ++{ ++} ++ ++void QWaylandIviSurface::setMinimized() ++{ ++} ++ ++void QWaylandIviSurface::setTopLevel() ++{ ++} ++ ++void QWaylandIviSurface::updateTransientParent(QWindow *parent) ++{ ++} ++ ++void QWaylandIviSurface::setTitle(const QString & title) ++{ ++} ++ ++void QWaylandIviSurface::setAppId(const QString & appId) ++{ ++} ++ ++QT_END_NAMESPACE +diff --git a/src/client/qwaylandivisurface_p.h b/src/client/qwaylandivisurface_p.h +new file mode 100644 +index 0000000..c6a7ce6 +--- /dev/null ++++ b/src/client/qwaylandivisurface_p.h +@@ -0,0 +1,90 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies). ++** Contact: http://www.qt-project.org/legal ++** ++** This file is part of the config.tests of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and Digia. For licensing terms and ++** conditions see http://qt.digia.com/licensing. For further information ++** use the contact form at http://qt.digia.com/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Digia gives you certain additional ++** rights. These rights are described in the Digia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 3.0 as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU General Public License version 3.0 requirements will be ++** met: http://www.gnu.org/copyleft/gpl.html. ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#ifndef QWAYLANDIVISURFACE_H ++#define QWAYLANDIVISURFACE_H ++ ++#include <QtCore/QSize> ++ ++#include <wayland-client.h> ++ ++#include <QtWaylandClient/private/qwayland-ivi-application.h> ++#include <QtWaylandClient/private/qwaylandclientexport_p.h> ++#include "qwaylandshellsurface_p.h" ++ ++QT_BEGIN_NAMESPACE ++ ++class QWaylandWindow; ++class QWaylandInputDevice; ++class QWindow; ++class QWaylandExtendedSurface; ++ ++class Q_WAYLAND_CLIENT_EXPORT QWaylandIviSurface : public QtWayland::ivi_surface ++ , public QWaylandShellSurface ++{ ++public: ++ QWaylandIviSurface(struct ::ivi_surface *shell_surface, QWaylandWindow *window); ++ virtual ~QWaylandIviSurface(); ++ ++ void resize(QWaylandInputDevice *inputDevice, enum wl_shell_surface_resize edges) Q_DECL_OVERRIDE; ++ void move(QWaylandInputDevice *inputDevice) Q_DECL_OVERRIDE; ++ ++ void setTitle(const QString &title) Q_DECL_OVERRIDE; ++ void setAppId(const QString &appId) Q_DECL_OVERRIDE; ++ ++private: ++ void setMaximized() Q_DECL_OVERRIDE; ++ void setFullscreen() Q_DECL_OVERRIDE; ++ void setNormal() Q_DECL_OVERRIDE; ++ void setMinimized() Q_DECL_OVERRIDE; ++ ++ void setTopLevel() Q_DECL_OVERRIDE; ++ void updateTransientParent(QWindow *parent) Q_DECL_OVERRIDE; ++ ++private: ++ QWaylandWindow *m_window; ++ ++ friend class QWaylandWindow; ++}; ++ ++QT_END_NAMESPACE ++ ++#endif // QWAYLANDIVISURFACE_H +diff --git a/src/client/qwaylandwindow.cpp b/src/client/qwaylandwindow.cpp +index 3fb3a49..45a58f2 100644 +--- a/src/client/qwaylandwindow.cpp ++++ b/src/client/qwaylandwindow.cpp +@@ -39,6 +39,8 @@ + ** + ****************************************************************************/ + ++#include <unistd.h> ++ + #include "qwaylandwindow_p.h" + + #include "qwaylandbuffer_p.h" +@@ -48,10 +50,12 @@ + #include "qwaylandshellsurface_p.h" + #include "qwaylandwlshellsurface_p.h" + #include "qwaylandxdgsurface_p.h" ++#include "qwaylandivisurface_p.h" + #include "qwaylandextendedsurface_p.h" + #include "qwaylandsubsurface_p.h" + #include "qwaylanddecoration_p.h" + #include "qwaylandwindowmanagerintegration_p.h" ++#define IVI_SURFACE_ID 8000 + + #include <QtCore/QFileInfo> + #include <QtGui/QWindow> +@@ -95,7 +99,9 @@ QWaylandWindow::QWaylandWindow(QWindow *window) + mWindowId = id++; + + if (!(window->flags() & Qt::BypassWindowManagerHint)) { +- if (mDisplay->shellXdg()) { ++ if (mDisplay->shellIvi()) { ++ mShellSurface = new QWaylandIviSurface(mDisplay->shellIvi()->surface_create(IVI_SURFACE_ID + getpid(), object()), this); ++ } else if (mDisplay->shellXdg()) { + if (window->type() & Qt::Window) { + mShellSurface = new QWaylandXdgSurface(mDisplay->shellXdg()->get_xdg_surface(object()), this); + } +-- +1.9.1 + diff --git a/recipes-qt/qt5/qtwayland/UNUSED_NEEDS_CHECK_YOCTO_0018-packaging-enable-xdg-shell-at-runtime.patch b/recipes-qt/qt5/qtwayland/UNUSED_NEEDS_CHECK_YOCTO_0018-packaging-enable-xdg-shell-at-runtime.patch new file mode 100644 index 000000000..bca61b5db --- /dev/null +++ b/recipes-qt/qt5/qtwayland/UNUSED_NEEDS_CHECK_YOCTO_0018-packaging-enable-xdg-shell-at-runtime.patch @@ -0,0 +1,31 @@ +From 9617c349a212d5407087daf4f4a2386bce94ecc1 Mon Sep 17 00:00:00 2001 +From: Philippe Coval <philippe.coval@open.eurogiciel.org> +Date: Thu, 12 Jun 2014 11:55:29 +0200 +Subject: [PATCH 18/21] packaging: enable xdg-shell at runtime + +Change-Id: Iffbae496f1e09c8fa44a28d4eb515678e3bbb297 +Bug-Tizen: TIVI-3113/part +Signed-off-by: Philippe Coval <philippe.coval@open.eurogiciel.org> +--- + packaging/qt5-qtwayland.spec | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/packaging/qt5-qtwayland.spec b/packaging/qt5-qtwayland.spec +index cba18e2..ff32185 100644 +--- a/packaging/qt5-qtwayland.spec ++++ b/packaging/qt5-qtwayland.spec +@@ -97,6 +97,11 @@ rm -rf %{buildroot} + + %post + /sbin/ldconfig ++ ++f="/etc/profile.d/qt.sh" ++grep QT_WAYLAND_USE_XDG_SHELL $f \ ++ || echo "QT_WAYLAND_USE_XDG_SHELL='defined'; export QT_WAYLAND_USE_XDG_SHELL" >> $f ++ + %postun + /sbin/ldconfig + +-- +1.9.1 + diff --git a/recipes-qt/qt5/qtwayland/disable_xcomposite_egl_qt_wayland_client_buffer_integration.patch b/recipes-qt/qt5/qtwayland/disable_xcomposite_egl_qt_wayland_client_buffer_integration.patch new file mode 100644 index 000000000..f113266e4 --- /dev/null +++ b/recipes-qt/qt5/qtwayland/disable_xcomposite_egl_qt_wayland_client_buffer_integration.patch @@ -0,0 +1,12 @@ +Index: git/qtwayland.pro +=================================================================== +--- git.orig/qtwayland.pro 2014-09-18 12:01:23.883582734 +0300 ++++ git/qtwayland.pro 2014-09-18 12:05:49.743574961 +0300 +@@ -7,7 +7,6 @@ + qtCompileTest(egl) + qtCompileTest(brcm_egl) + qtCompileTest(glx) +-qtCompileTest(xcomposite) + qtCompileTest(drm_egl_server) + + load(qt_parts) |