1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

xdg-shell: upgrade to support current version (weston-1.5.0)

Browse Source 
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
Change-Id: I41ca2f89c09a8b6348ce2fbf6d59f44b4c8134df
Reviewed-by: Giulio Camuffo <giulio.camuffo@jollamobile.com>
Reviewed-by: Philippe Coval <rzr@gna.org>
This commit is contained in:
Philippe Coval 2014-06-10 16:22:17 +02:00 committed by Philippe Coval
parent 43cd8c4fe7
commit b4e47c370d
8 changed files with 372 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

304
src/3rdparty/wayland/protocols/xdg-shell.xml vendored
View File

@ -40,19 +40,22 @@
<enum name="version"> <enum name="version">
<description summary="latest protocol version"> <description summary="latest protocol version">
Use this enum to check the protocol version, and it will be updated The 'current' member of this enum gives the version of the
automatically. protocol. Implementations can compare this to the version
they implement using static_assert to ensure the protocol and
implementation versions match.
</description> </description>
<entry name="current" value="1" summary="Always the latest version"/> <entry name="current" value="3" summary="Always the latest version"/>
</enum> </enum>
<request name="use_unstable_version"> <request name="use_unstable_version">
<description summary="enable use of this unstable version"> <description summary="enable use of this unstable version">
Use this request in order to enable use of this interface. Negotiate the unstable version of the interface. This
mechanism is in place to ensure client and server agree on the
Understand and agree that one is using an unstable interface, unstable versions of the protocol that they speak or exit
that will likely change in the future, breaking the API. cleanly if they don't agree. This request will go away once
the xdg-shell protocol is stable.
</description> </description>
<arg name="version" type="int"/> <arg name="version" type="int"/>
</request> </request>
@ -84,6 +87,28 @@
<arg name="y" type="int"/> <arg name="y" type="int"/>
<arg name="flags" type="uint"/> <arg name="flags" type="uint"/>
</request> </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>
<interface name="xdg_surface" version="1"> <interface name="xdg_surface" version="1">
@ -124,6 +149,32 @@
<arg name="parent" type="object" interface="wl_surface" allow-null="true"/> <arg name="parent" type="object" interface="wl_surface" allow-null="true"/>
</request> </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"> <request name="set_title">
<description summary="set surface title"> <description summary="set surface title">
Set a short title for the surface. Set a short title for the surface.
@ -150,22 +201,6 @@
<arg name="app_id" type="string"/> <arg name="app_id" type="string"/>
</request> </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"> <request name="move">
<description summary="start an interactive move"> <description summary="start an interactive move">
Start a pointer-driven move of the surface. Start a pointer-driven move of the surface.
@ -217,12 +252,6 @@
ignore it if it doesn't resize, pick a smaller size (to ignore it if it doesn't resize, pick a smaller size (to
satisfy aspect ratio or resize in steps of NxM pixels). 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 The client is free to dismiss all but the last configure
event it received. event it received.
@ -230,7 +259,6 @@
in surface local coordinates. in surface local coordinates.
</description> </description>
<arg name="edges" type="uint"/>
<arg name="width" type="int"/> <arg name="width" type="int"/>
<arg name="height" type="int"/> <arg name="height" type="int"/>
</event> </event>
@ -250,128 +278,122 @@
<arg name="output" type="object" interface="wl_output" allow-null="true"/> <arg name="output" type="object" interface="wl_output" allow-null="true"/>
</request> </request>
<event name="request_set_fullscreen"> <enum name="state">
<description summary="server requests that the client set fullscreen"> <description summary="types of state on the surface">
Event sent from the compositor to the client requesting that the client The different state values used on the surface. This is designed for
goes to a fullscreen state. It's the client job to call set_fullscreen state values like maximized, fullscreen. It is paired with the
and really trigger the fullscreen state. request_change_state event to ensure that both the client and the
compositor setting the state can be synchronized.
States set in this way are double-buffered. They will get applied on
the next commit.
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.
The current reserved ranges are:
0x0000 - 0x0FFF: xdg-shell core values, documented below.
0x1000 - 0x1FFF: GNOME
</description> </description>
</event> <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>
<event name="request_unset_fullscreen"> <request name="request_change_state">
<description summary="server requests that the client unset fullscreen"> <description summary="client requests to change a surface's state">
Event sent from the compositor to the client requesting that the client This asks the compositor to change the state. If the compositor wants
leaves the fullscreen state. It's the client job to call to change the state, it will send a change_state event with the same
unset_fullscreen and really leave the fullscreen state. state_type, value, and serial, and the event flow continues as if it
</description> it was initiated by the compositor.
</event>
If the compositor does not want to change the state, it will send a
<request name="set_fullscreen"> change_state to the client with the old value of the state.
<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> </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> </request>
<request name="unset_fullscreen"> <event name="change_state">
<description summary="unset the surface state as fullscreen"> <description summary="compositor wants to change a surface's state">
Unset the surface fullscreen 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
Same negotiation as set_fullscreen must be used. guarantee that the compositor knows that the client has seen it.
</description> </description>
</request>
<event name="request_set_maximized"> <arg name="state_type" type="uint" summary="the state to set"/>
<description summary="server requests that the client set maximized"> <arg name="value" type="uint" summary="the value to change the state to"/>
Event sent from the compositor to the client requesting that the client <arg name="serial" type="uint" summary="a serial for the compositor's own tracking"/>
goes to a maximized state. It's the client job to call set_maximized
and really trigger the maximized state.
</description>
</event> </event>
<event name="request_unset_maximized"> <request name="ack_change_state">
<description summary="server requests that the client unset maximized"> <description summary="ack a change_state event">
Event sent from the compositor to the client requesting that the client When a change_state event is received, a client should then ack it
leaves the maximized state. It's the client job to call unset_maximized using the ack_change_state request to ensure that the compositor
and really leave the maximized state. knows the client has seen the event.
</description>
</event> By this point, the state is confirmed, and the next attach should
contain the buffer drawn for the new state value.
<request name="set_maximized">
<description summary="set the surface state as maximized"> The values here need to be the same as the values in the cooresponding
Set the surface as maximized. change_state event.
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> </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>
<request name="set_minimized"> <request name="set_minimized">
<description summary="set the surface state as minimized"> <description summary="minimize the surface">
Set the surface minimized state. Minimize the surface.
Setting one state won't unset another state.
</description> </description>
</request> </request>
<event name="focused_set"> <event name="activated">
<description summary="surface was focused"> <description summary="surface was activated">
The focused_set event is sent when this surface has been The activated_set event is sent when this surface has been
activated. Window decorations should be updated accordingly. 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> </description>
</event> </event>
<event name="focused_unset"> <event name="deactivated">
<description summary="surface was unfocused"> <description summary="surface was deactivated">
The focused_unset event is sent when this surface has been The deactivate event is sent when this surface has been
deactivated, because another surface has been activated. Window deactivated, which means that the surface lost user attention.
decorations should be updated accordingly. 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="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> </description>
</event> </event>
</interface> </interface>
@ -409,22 +431,6 @@
</description> </description>
</request> </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"> <event name="popup_done">
<description summary="popup interaction is done"> <description summary="popup interaction is done">
The popup_done event is sent out when a popup grab is broken, The popup_done event is sent out when a popup grab is broken,

2
src/plugins/platforms/wayland/client.pro
View File

@ -60,6 +60,7 @@ SOURCES += qwaylandintegration.cpp \
qwaylanddatasource.cpp \ qwaylanddatasource.cpp \
qwaylandshellsurface.cpp \ qwaylandshellsurface.cpp \
qwaylandwlshellsurface.cpp \ qwaylandwlshellsurface.cpp \
qwaylandxdgshell.cpp \
qwaylandxdgsurface.cpp \ qwaylandxdgsurface.cpp \
qwaylandextendedoutput.cpp \ qwaylandextendedoutput.cpp \
qwaylandextendedsurface.cpp \ qwaylandextendedsurface.cpp \
@ -90,6 +91,7 @@ HEADERS += qwaylandintegration_p.h \
qwaylanddatasource_p.h \ qwaylanddatasource_p.h \
qwaylandshellsurface_p.h \ qwaylandshellsurface_p.h \
qwaylandwlshellsurface_p.h \ qwaylandwlshellsurface_p.h \
qwaylandxdgshell_p.h \
qwaylandxdgsurface_p.h \ qwaylandxdgsurface_p.h \
qwaylandextendedoutput_p.h \ qwaylandextendedoutput_p.h \
qwaylandextendedsurface_p.h \ qwaylandextendedsurface_p.h \

10
src/plugins/platforms/wayland/qwaylanddisplay.cpp
View File

@ -50,7 +50,7 @@
#include "qwaylandclipboard_p.h" #include "qwaylandclipboard_p.h"
#include "qwaylanddatadevicemanager_p.h" #include "qwaylanddatadevicemanager_p.h"
#include "qwaylandhardwareintegration_p.h" #include "qwaylandhardwareintegration_p.h"
#include "qwaylandxdgshell_p.h"
#include "qwaylandwindowmanagerintegration_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)); mShm = static_cast<struct wl_shm *>(wl_registry_bind(registry, id, &wl_shm_interface,1));
} else if (interface == QStringLiteral("xdg_shell") } else if (interface == QStringLiteral("xdg_shell")
&& qEnvironmentVariableIsSet("QT_WAYLAND_USE_XDG_SHELL")) { && qEnvironmentVariableIsSet("QT_WAYLAND_USE_XDG_SHELL")) {
mShellXdg.reset(new QtWayland::xdg_shell(registry, id)); mShellXdg.reset(new QWaylandXdgShell(registry,id));
mShellXdg->use_unstable_version(QtWayland::xdg_shell::version_current);
} else if (interface == QStringLiteral("wl_shell")){ } else if (interface == QStringLiteral("wl_shell")){
mShell.reset(new QtWayland::wl_shell(registry, id)); mShell.reset(new QtWayland::wl_shell(registry, id));
} else if (interface == QStringLiteral("wl_seat")) { } else if (interface == QStringLiteral("wl_seat")) {
@ -275,4 +274,9 @@ void QWaylandDisplay::forceRoundTrip()
wl_display_roundtrip(mDisplay); wl_display_roundtrip(mDisplay);
} }
QtWayland::xdg_shell *QWaylandDisplay::shellXdg()
{
return mShellXdg.data();
}
QT_END_NAMESPACE QT_END_NAMESPACE

5
src/plugins/platforms/wayland/qwaylanddisplay_p.h
View File

@ -72,6 +72,7 @@ class QWaylandWindow;
class QWaylandEventThread; class QWaylandEventThread;
class QWaylandIntegration; class QWaylandIntegration;
class QWaylandHardwareIntegration; class QWaylandHardwareIntegration;
class QWaylandXdgShell;
namespace QtWayland { namespace QtWayland {
class qt_output_extension; class qt_output_extension;
@ -115,7 +116,7 @@ public:
QtWayland::wl_compositor *compositor() { return &mCompositor; } QtWayland::wl_compositor *compositor() { return &mCompositor; }
QtWayland::wl_shell *shell() { return mShell.data(); } QtWayland::wl_shell *shell() { return mShell.data(); }
QtWayland::xdg_shell *shellXdg() { return mShellXdg.data(); } QtWayland::xdg_shell *shellXdg();
QList<QWaylandInputDevice *> inputDevices() const { return mInputDevices; } QList<QWaylandInputDevice *> inputDevices() const { return mInputDevices; }
QWaylandInputDevice *defaultInputDevice() const; QWaylandInputDevice *defaultInputDevice() const;
@ -171,7 +172,7 @@ private:
QThread *mEventThread; QThread *mEventThread;
QWaylandEventThread *mEventThreadObject; QWaylandEventThread *mEventThreadObject;
QScopedPointer<QtWayland::wl_shell> mShell; QScopedPointer<QtWayland::wl_shell> mShell;
QScopedPointer<QtWayland::xdg_shell> mShellXdg; QScopedPointer<QWaylandXdgShell> mShellXdg;
QList<QPlatformScreen *> mScreens; QList<QPlatformScreen *> mScreens;
QList<QWaylandInputDevice *> mInputDevices; QList<QWaylandInputDevice *> mInputDevices;
QList<Listener> mRegistryListeners; QList<Listener> mRegistryListeners;

77
src/plugins/platforms/wayland/qwaylandxdgshell.cpp Normal file
View File

@ -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

73
src/plugins/platforms/wayland/qwaylandxdgshell_p.h Normal file
View File

@ -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

60
src/plugins/platforms/wayland/qwaylandxdgsurface.cpp
View File

@ -87,23 +87,25 @@ void QWaylandXdgSurface::move(QWaylandInputDevice *inputDevice)
void QWaylandXdgSurface::setMaximized() void QWaylandXdgSurface::setMaximized()
{ {
m_maximized = true; if (!m_maximized)
m_size = m_window->window()->geometry().size(); request_change_state(XDG_SURFACE_STATE_MAXIMIZED, true, 0);
set_maximized();
} }
void QWaylandXdgSurface::setFullscreen() void QWaylandXdgSurface::setFullscreen()
{ {
m_fullscreen = true; if (!m_fullscreen)
m_size = m_window->window()->geometry().size(); request_change_state(XDG_SURFACE_STATE_FULLSCREEN, true, 0);
set_fullscreen();
} }
void QWaylandXdgSurface::setNormal() void QWaylandXdgSurface::setNormal()
{ {
if (m_fullscreen || m_maximized || m_minimized) { if (m_fullscreen || m_maximized || m_minimized) {
if (m_maximized) { unset_maximized(); } if (m_maximized) {
if (m_fullscreen) { unset_fullscreen(); } 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; m_fullscreen = m_maximized = m_minimized = false;
setTopLevel(); setTopLevel();
@ -158,16 +160,48 @@ void QWaylandXdgSurface::setAppId(const QString & appId)
return QtWayland::xdg_surface::set_app_id(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, void QWaylandXdgSurface::xdg_surface_change_state(uint32_t state,
int32_t height) 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 QT_END_NAMESPACE

11
src/plugins/platforms/wayland/qwaylandxdgsurface_p.h
View File

@ -93,10 +93,15 @@ private:
bool m_fullscreen; bool m_fullscreen;
QSize m_size; QSize m_size;
void xdg_surface_ping(uint32_t serial) Q_DECL_OVERRIDE; void xdg_surface_configure(int32_t width,
void xdg_surface_configure(uint32_t edges,
int32_t width,
int32_t height) Q_DECL_OVERRIDE; 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; friend class QWaylandWindow;
}; };