#include "wayland-brcm-client-protocol.h"
-QWaylandBrcmEglIntegration::QWaylandBrcmEglIntegration(struct wl_display *waylandDisplay)
- : m_waylandDisplay(waylandDisplay)
+QWaylandBrcmEglIntegration::QWaylandBrcmEglIntegration(QWaylandDisplay *waylandDisplay)
+ : m_waylandDisplay(waylandDisplay->wl_display())
{
- wl_display_add_global_listener(waylandDisplay, wlDisplayHandleGlobal, this);
qDebug() << "Using Brcm-EGL";
+ waylandDisplay->addRegistryListener(wlDisplayHandleGlobal, this);
}
-void QWaylandBrcmEglIntegration::wlDisplayHandleGlobal(wl_display *display, uint32_t id, const char *interface, uint32_t version, void *data)
+void QWaylandBrcmEglIntegration::wlDisplayHandleGlobal(void *data, struct wl_registry *registry, uint32_t id, const char *interface, uint32_t version)
{
Q_UNUSED(version);
if (strcmp(interface, "wl_brcm") == 0) {
QWaylandBrcmEglIntegration *integration = static_cast<QWaylandBrcmEglIntegration *>(data);
- integration->m_waylandBrcm = static_cast<struct wl_brcm *>(wl_display_bind(display, id, &wl_brcm_interface));
+ integration->m_waylandBrcm = static_cast<struct wl_brcm *>(wl_registry_bind(registry, id, &wl_brcm_interface, 1));
}
}
QWaylandGLIntegration *QWaylandGLIntegration::createGLIntegration(QWaylandDisplay *waylandDisplay)
{
- return new QWaylandBrcmEglIntegration(waylandDisplay->wl_display());
+ return new QWaylandBrcmEglIntegration(waylandDisplay);
}
class QWaylandBrcmEglIntegration : public QWaylandGLIntegration
{
public:
- QWaylandBrcmEglIntegration(struct wl_display *waylandDisplay);
+ QWaylandBrcmEglIntegration(QWaylandDisplay *waylandDisplay);
~QWaylandBrcmEglIntegration();
void initialize();
PFNEGLDESTROYGLOBALIMAGEBRCMPROC eglDestroyGlobalImageBRCM;
private:
- static void wlDisplayHandleGlobal(wl_display *display, uint32_t id, const char *interface, uint32_t version, void *data);
+ static void wlDisplayHandleGlobal(void *data, struct wl_registry *registry, uint32_t id, const char *interface, uint32_t version);
struct wl_display *m_waylandDisplay;
struct wl_brcm *m_waylandBrcm;
return new QWaylandXCompositeEGLIntegration(waylandDisplay);
}
-QWaylandXCompositeEGLIntegration::QWaylandXCompositeEGLIntegration(QWaylandDisplay * waylandDispaly)
+QWaylandXCompositeEGLIntegration::QWaylandXCompositeEGLIntegration(QWaylandDisplay * waylandDisplay)
: QWaylandGLIntegration()
- , mWaylandDisplay(waylandDispaly)
+ , mWaylandDisplay(waylandDisplay)
{
qDebug() << "Using XComposite-EGL";
- wl_display_add_global_listener(mWaylandDisplay->wl_display(), QWaylandXCompositeEGLIntegration::wlDisplayHandleGlobal,
- this);
+ waylandDisplay->addRegistryListener(&wlDisplayHandleGlobal, this);
}
QWaylandXCompositeEGLIntegration::~QWaylandXCompositeEGLIntegration()
QWaylandXCompositeEGLIntegration::rootInformation
};
-void QWaylandXCompositeEGLIntegration::wlDisplayHandleGlobal(wl_display *display, uint32_t id, const char *interface, uint32_t version, void *data)
+void QWaylandXCompositeEGLIntegration::wlDisplayHandleGlobal(void *data, wl_registry *registry, uint32_t id, const char *interface, uint32_t version)
{
Q_UNUSED(version);
if (strcmp(interface, "wl_xcomposite") == 0) {
QWaylandXCompositeEGLIntegration *integration = static_cast<QWaylandXCompositeEGLIntegration *>(data);
- integration->mWaylandComposite = static_cast<struct wl_xcomposite *>(wl_display_bind(display,id,&wl_xcomposite_interface));
+ integration->mWaylandComposite = static_cast<struct wl_xcomposite *>(wl_registry_bind(registry,id,&wl_xcomposite_interface,1));
wl_xcomposite_add_listener(integration->mWaylandComposite,&xcomposite_listener,integration);
}
int mScreen;
Window mRootWindow;
- static void wlDisplayHandleGlobal(struct wl_display *display, uint32_t id,
- const char *interface, uint32_t version, void *data);
+ static void wlDisplayHandleGlobal(void *data, struct wl_registry *registry, uint32_t id,
+ const char *interface, uint32_t version);
static const struct wl_xcomposite_listener xcomposite_listener;
static void rootInformation(void *data,
, mRootWindow(0)
{
qDebug() << "Using XComposite-GLX";
- wl_display_add_global_listener(waylandDisplay->wl_display(), QWaylandXCompositeGLXIntegration::wlDisplayHandleGlobal,
- this);
+ waylandDisplay->addRegistryListener(QWaylandXCompositeGLXIntegration::wlDisplayHandleGlobal, this);
}
QWaylandXCompositeGLXIntegration::~QWaylandXCompositeGLXIntegration()
QWaylandXCompositeGLXIntegration::rootInformation
};
-void QWaylandXCompositeGLXIntegration::wlDisplayHandleGlobal(wl_display *display, uint32_t id, const char *interface, uint32_t version, void *data)
+void QWaylandXCompositeGLXIntegration::wlDisplayHandleGlobal(void *data, wl_registry *registry, uint32_t id, const char *interface, uint32_t version)
{
Q_UNUSED(version);
if (strcmp(interface, "wl_xcomposite") == 0) {
qDebug("XComposite-GLX: got wl_xcomposite global");
QWaylandXCompositeGLXIntegration *integration = static_cast<QWaylandXCompositeGLXIntegration *>(data);
- integration->mWaylandComposite = static_cast<struct wl_xcomposite *>(wl_display_bind(display, id, &wl_xcomposite_interface));
+ integration->mWaylandComposite = static_cast<struct wl_xcomposite *>(wl_registry_bind(registry, id, &wl_xcomposite_interface, 1));
wl_xcomposite_add_listener(integration->mWaylandComposite,&xcomposite_listener,integration);
}
int mScreen;
Window mRootWindow;
- static void wlDisplayHandleGlobal(struct wl_display *display, uint32_t id,
- const char *interface, uint32_t version, void *data);
+ static void wlDisplayHandleGlobal(void *data, struct wl_registry *registry, uint32_t id,
+ const char *interface, uint32_t version);
static const struct wl_xcomposite_listener xcomposite_listener;
static void rootInformation(void *data,
, m_drag_icon_buffer(0)
, m_drag_can_drop(false)
{
- m_data_device_manager = static_cast<struct wl_data_device_manager *>(wl_display_bind(display->wl_display(),id,&wl_data_device_manager_interface));
+ m_data_device_manager = static_cast<struct wl_data_device_manager *>(wl_registry_bind(display->wl_registry(),id,&wl_data_device_manager_interface,1));
// Create transfer devices for all input devices.
// ### This only works if we get the global before all devices and is surely wrong when hotplugging.
static QWaylandDisplay *display = 0;
+const struct wl_registry_listener QWaylandDisplay::registryListener = {
+ QWaylandDisplay::displayHandleGlobal
+};
+
QWaylandDisplay::QWaylandDisplay(void)
: mLastKeyboardFocusInputDevice(0)
, mDndSelectionHandler(0)
qFatal("No wayland connection available.");
}
- wl_display_add_global_listener(mDisplay, QWaylandDisplay::displayHandleGlobal, this);
+ mFd = wl_display_get_fd(mDisplay);
- mFd = wl_display_get_fd(mDisplay, 0, 0);
+ mRegistry = wl_display_get_registry(mDisplay);
+ wl_registry_add_listener(mRegistry, ®istryListener, this);
#ifdef WAYLAND_CLIENT_THREAD_AFFINITY
mWritableNotificationFd = wl_display_get_write_notification_fd(mDisplay);
wl_display_disconnect(mDisplay);
}
-void QWaylandDisplay::createNewScreen(struct wl_output *output, QRect geometry)
+void QWaylandDisplay::createNewScreen(struct wl_output *output)
{
- QWaylandScreen *waylandScreen = new QWaylandScreen(this,output,geometry);
+ QWaylandScreen *waylandScreen = new QWaylandScreen(this,output);
mScreens.append(waylandScreen);
}
void QWaylandDisplay::flushRequests()
{
+ wl_display_dispatch_pending(mDisplay);
wl_display_flush(mDisplay);
}
return;
}
- wl_display_iterate(mDisplay, WL_DISPLAY_READABLE);
+ wl_display_dispatch(mDisplay);
}
void QWaylandDisplay::blockingReadEvents()
{
- wl_display_iterate(mDisplay, WL_DISPLAY_READABLE);
+ wl_display_dispatch(mDisplay);
}
QWaylandScreen *QWaylandDisplay::screenForOutput(struct wl_output *output) const
}
void QWaylandDisplay::outputHandleGeometry(void *data,
- wl_output *output,
+ struct wl_output *output,
int32_t x, int32_t y,
int32_t physicalWidth,
int32_t physicalHeight,
Q_UNUSED(transform);
QWaylandDisplay *waylandDisplay = static_cast<QWaylandDisplay *>(data);
QRect outputRect = QRect(x, y, physicalWidth, physicalHeight);
- waylandDisplay->createNewScreen(output,outputRect);
+ waylandDisplay->screenForOutput(output)->setGeometry(outputRect);
}
void QWaylandDisplay::mode(void *data,
}
}
+void QWaylandDisplay::addRegistryListener(RegistryListener listener, void *data)
+{
+ Listener l = { listener, data };
+ mRegistryListeners.append(l);
+}
+
const struct wl_output_listener QWaylandDisplay::outputListener = {
QWaylandDisplay::outputHandleGeometry,
QWaylandDisplay::mode
blockingReadEvents();
}
-void QWaylandDisplay::displayHandleGlobal(struct wl_display *display,
+void QWaylandDisplay::displayHandleGlobal(void *data,
+ struct wl_registry *registry,
uint32_t id,
const char *interface,
- uint32_t version,
- void *data)
+ uint32_t version)
{
- Q_UNUSED(display);
+ Q_UNUSED(registry);
QWaylandDisplay *that = static_cast<QWaylandDisplay *>(data);
that->displayHandleGlobal(id, QByteArray(interface), version);
}
uint32_t version)
{
Q_UNUSED(version);
+
if (interface == "wl_output") {
- struct wl_output *output = static_cast<struct wl_output *>(wl_display_bind(mDisplay,id,&wl_output_interface));
+ struct wl_output *output = static_cast<struct wl_output *>(wl_registry_bind(mRegistry,id,&wl_output_interface,1));
+ createNewScreen(output);
wl_output_add_listener(output, &outputListener, this);
} else if (interface == "wl_compositor") {
- mCompositor = static_cast<struct wl_compositor *>(wl_display_bind(mDisplay, id,&wl_compositor_interface));
+ mCompositor = static_cast<struct wl_compositor *>(wl_registry_bind(mRegistry, id,&wl_compositor_interface,1));
} else if (interface == "wl_shm") {
- mShm = static_cast<struct wl_shm *>(wl_display_bind(mDisplay, id, &wl_shm_interface));
+ mShm = static_cast<struct wl_shm *>(wl_registry_bind(mRegistry, id, &wl_shm_interface,1));
} else if (interface == "wl_shell"){
mShell = new QWaylandShell(this,id,version);
} else if (interface == "wl_seat") {
} else if (interface == "wl_qtkey_extension") {
mQtKeyExtension = new QWaylandQtKeyExtension(this, id);
}
+
+ foreach (Listener l, mRegistryListeners) {
+ (*l.listener)(l.data, mRegistry, id, interface, version);
+ }
}
uint32_t QWaylandDisplay::currentTimeMillisec()
class QWaylandTouchExtension;
class QWaylandQtKeyExtension;
+typedef void (*RegistryListener)(void *data,
+ struct wl_registry *registry,
+ uint32_t id,
+ const char *interface,
+ uint32_t version);
+
class QWaylandDisplay : public QObject {
Q_OBJECT
void setCursor(wl_surface *surface, int32_t x, int32_t y);
struct wl_display *wl_display() const { return mDisplay; }
+ struct wl_registry *wl_registry() const { return mRegistry; }
struct wl_compositor *wl_compositor() const { return mCompositor; }
QWaylandShell *shell() const { return mShell; }
QWaylandOutputExtension *outputExtension() const { return mOutputExtension; }
QWaylandTouchExtension *touchExtension() const { return mTouchExtension; }
+ /* wl_registry_add_listener does not add but rather sets a listener, so this function is used
+ * to enable many listeners at once. */
+ void addRegistryListener(RegistryListener listener, void *data);
+
struct wl_shm *shm() const { return mShm; }
static uint32_t currentTimeMillisec();
void forceRoundTrip();
+
public slots:
- void createNewScreen(struct wl_output *output, QRect geometry);
+ void createNewScreen(struct wl_output *output);
void readEvents();
void blockingReadEvents();
void flushRequests();
const QByteArray &interface,
uint32_t version);
+ struct Listener {
+ RegistryListener listener;
+ void *data;
+ };
+
struct wl_display *mDisplay;
+ struct wl_registry *mRegistry;
struct wl_compositor *mCompositor;
struct wl_shm *mShm;
QWaylandShell *mShell;
QList<QPlatformScreen *> mScreens;
QList<QWaylandInputDevice *> mInputDevices;
+ QList<Listener> mRegistryListeners;
QWaylandInputDevice *mLastKeyboardFocusInputDevice;
QWaylandDataDeviceManager *mDndSelectionHandler;
QWaylandSurfaceExtension *mWindowExtension;
int mWritableNotificationFd;
bool mScreensInitialized;
+ static const struct wl_registry_listener registryListener;
static const struct wl_output_listener outputListener;
- static void displayHandleGlobal(struct wl_display *display,
+
+ static void displayHandleGlobal(void *data,
+ struct wl_registry *registry,
uint32_t id,
const char *interface,
- uint32_t version, void *data);
+ uint32_t version);
static void outputHandleGeometry(void *data,
struct wl_output *output,
int32_t x, int32_t y,
QWaylandOutputExtension::QWaylandOutputExtension(QWaylandDisplay *display, uint32_t id)
{
m_output_extension = static_cast<struct wl_output_extension *>(
- wl_display_bind(display->wl_display(),id, &wl_output_extension_interface));
+ wl_registry_bind(display->wl_registry(), id, &wl_output_extension_interface, 1));
QList<QPlatformScreen *> platformScreens = display->screens();
for (int i = 0; i < platformScreens.size(); i++) {
QWaylandSurfaceExtension::QWaylandSurfaceExtension(QWaylandDisplay *display, uint32_t id)
{
m_surface_extension = static_cast<struct wl_surface_extension *>(
- wl_display_bind(display->wl_display(),id, &wl_surface_extension_interface));
+ wl_registry_bind(display->wl_registry(), id, &wl_surface_extension_interface, 1));
}
QWaylandExtendedSurface *QWaylandSurfaceExtension::getExtendedWindow(QWaylandWindow *window)
, mXkbState(0)
#endif
{
- mSeat = static_cast<struct wl_seat *>(wl_display_bind(mDisplay, id, &wl_seat_interface));
+ mSeat = static_cast<struct wl_seat *>(wl_registry_bind(display->wl_registry(), id, &wl_seat_interface, 1));
wl_seat_add_listener(mSeat, &seatListener, this);
wl_seat_set_user_data(mSeat, this);
QWaylandQtKeyExtension::QWaylandQtKeyExtension(QWaylandDisplay *display, uint32_t id)
: m_display(display)
{
- m_qtkey = static_cast<struct wl_qtkey_extension *>(wl_display_bind(display->wl_display(), id, &wl_qtkey_extension_interface));
+ m_qtkey = static_cast<struct wl_qtkey_extension *>(wl_registry_bind(display->wl_registry(), id, &wl_qtkey_extension_interface, 1));
wl_qtkey_extension_add_listener(m_qtkey, &qtkey_listener, this);
}
#include <qpa/qwindowsysteminterface.h>
-QWaylandScreen::QWaylandScreen(QWaylandDisplay *waylandDisplay, struct wl_output *output, QRect geometry)
+QWaylandScreen::QWaylandScreen(QWaylandDisplay *waylandDisplay, struct wl_output *output)
: QPlatformScreen()
, mWaylandDisplay(waylandDisplay)
, mOutput(output)
, mExtendedOutput(0)
- , mGeometry(geometry)
, mDepth(32)
, mRefreshRate(60)
, mFormat(QImage::Format_ARGB32_Premultiplied)
return mWaylandDisplay;
}
+void QWaylandScreen::setGeometry(const QRect &geom)
+{
+ mGeometry = geom;
+}
+
QRect QWaylandScreen::geometry() const
{
return mGeometry;
class QWaylandScreen : public QPlatformScreen
{
public:
- QWaylandScreen(QWaylandDisplay *waylandDisplay, struct wl_output *output, QRect geometry);
+ QWaylandScreen(QWaylandDisplay *waylandDisplay, struct wl_output *output);
~QWaylandScreen();
QWaylandDisplay *display() const;
void handleMode(const QSize &size, int refreshRate);
+ void setGeometry(const QRect &geom);
+
private:
QWaylandDisplay *mWaylandDisplay;
struct wl_output *mOutput;
: m_display(display)
{
Q_UNUSED(version)
- m_shell = static_cast<struct wl_shell *>(wl_display_bind(m_display->wl_display(), id, &wl_shell_interface));
+ m_shell = static_cast<struct wl_shell *>(wl_registry_bind(m_display->wl_registry(), id, &wl_shell_interface, 1));
}
QWaylandShellSurface *QWaylandShell::getShellSurface(QWaylandWindow *window)
QWaylandSubSurfaceExtension::QWaylandSubSurfaceExtension(QWaylandDisplay *display, uint32_t id)
{
m_sub_surface_extension = static_cast<struct wl_sub_surface_extension *>(
- wl_display_bind(display->wl_display(),id, &wl_sub_surface_extension_interface));
+ wl_registry_bind(display->wl_registry(), id, &wl_sub_surface_extension_interface, 1));
}
QWaylandSubSurface *QWaylandSubSurfaceExtension::getSubSurfaceAwareWindow(QWaylandWindow *window)
mMouseSourceId(-1),
mInputDevice(0)
{
- mTouch = static_cast<struct wl_touch_extension *>(wl_display_bind(display->wl_display(), id, &wl_touch_extension_interface));
+ mTouch = static_cast<struct wl_touch_extension *>(wl_registry_bind(display->wl_registry(), id, &wl_touch_extension_interface, 1));
wl_touch_extension_add_listener(mTouch, &touch_listener, this);
}
wl_surface_damage(mSurface,
rect.x(), rect.y(), rect.width(), rect.height());
+ wl_surface_commit(mSurface);
}
const wl_callback_listener QWaylandWindow::callbackListener = {
: d_ptr(new QWaylandWindowManagerIntegrationPrivate(waylandDisplay))
{
m_instance = this;
-
- wl_display_add_global_listener(d_ptr->m_waylandDisplay->wl_display(),
- QWaylandWindowManagerIntegration::wlHandleListenerGlobal,
- this);
+ waylandDisplay->addRegistryListener(&wlHandleListenerGlobal, this);
}
QWaylandWindowManagerIntegration::~QWaylandWindowManagerIntegration()
return d->m_showIsFullScreen;
}
-void QWaylandWindowManagerIntegration::wlHandleListenerGlobal(wl_display *display, uint32_t id, const char *interface, uint32_t version, void *data)
+void QWaylandWindowManagerIntegration::wlHandleListenerGlobal(void *data, wl_registry *registry, uint32_t id, const char *interface, uint32_t version)
{
Q_UNUSED(version);
if (strcmp(interface, "wl_windowmanager") == 0) {
QWaylandWindowManagerIntegration *integration = static_cast<QWaylandWindowManagerIntegration *>(data);
integration->d_ptr->m_waylandWindowManager =
- static_cast<struct wl_windowmanager *>(wl_display_bind(display, id, &wl_windowmanager_interface));
+ static_cast<struct wl_windowmanager *>(wl_registry_bind(registry, id, &wl_windowmanager_interface, 1));
wl_windowmanager_add_listener(integration->d_ptr->m_waylandWindowManager, &windowmanager_listener, integration);
}
}
bool showIsFullScreen() const;
private:
- static void wlHandleListenerGlobal(wl_display *display, uint32_t id,
- const char *interface, uint32_t version, void *data);
+ static void wlHandleListenerGlobal(void *data, wl_registry *registry, uint32_t id,
+ const char *interface, uint32_t version);
-private:
QScopedPointer<QWaylandWindowManagerIntegrationPrivate> d_ptr;
static QWaylandWindowManagerIntegration *m_instance;