Revision control
Copy as Markdown
// Copyright (C) 2017-2015 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
// Copyright (C) 2017 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:critical reason:network-protocol
#ifndef QWAYLANDCOMPOSITOR_P_H
#define QWAYLANDCOMPOSITOR_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtWaylandCompositor/private/qtwaylandcompositorglobal_p.h>
#include <QtWaylandCompositor/QWaylandCompositor>
#include <QtCore/private/qobject_p.h>
#include <QtCore/QSet>
#include <QtCore/QElapsedTimer>
#include <QtWaylandCompositor/private/qwayland-server-wayland.h>
#include <QtCore/qpointer.h>
#include <vector>
#if QT_CONFIG(xkbcommon)
#include <QtGui/private/qxkbcommon_p.h>
#endif
QT_BEGIN_NAMESPACE
namespace QtWayland {
class HardwareIntegration;
class ClientBufferIntegration;
class ServerBufferIntegration;
class DataDeviceManager;
class BufferManager;
}
class QWindowSystemEventHandler;
class QWaylandSurface;
class Q_WAYLANDCOMPOSITOR_EXPORT QWaylandCompositorPrivate : public QObjectPrivate, public QtWaylandServer::wl_compositor, public QtWaylandServer::wl_subcompositor
{
public:
static QWaylandCompositorPrivate *get(QWaylandCompositor *compositor) { return compositor->d_func(); }
QWaylandCompositorPrivate(QWaylandCompositor *compositor);
~QWaylandCompositorPrivate() override;
#if QT_CONFIG(xkbcommon)
struct xkb_context *xkbContext() const { return mXkbContext.get(); }
#endif
void preInit();
void init();
void destroySurface(QWaylandSurface *surface);
void unregisterSurface(QWaylandSurface *surface);
QWaylandOutput *defaultOutput() const { return outputs.size() ? outputs.first() : nullptr; }
inline const QList<QtWayland::ClientBufferIntegration *> clientBufferIntegrations() const;
inline QtWayland::ServerBufferIntegration *serverBufferIntegration() const;
#if QT_CONFIG(wayland_datadevice)
QtWayland::DataDeviceManager *dataDeviceManager() const { return data_device_manager; }
#endif
QtWayland::BufferManager *bufferManager() const { return buffer_manager; }
void feedRetainedSelectionData(QMimeData *data);
QWaylandPointer *callCreatePointerDevice(QWaylandSeat *seat)
{ return q_func()->createPointerDevice(seat); }
QWaylandKeyboard *callCreateKeyboardDevice(QWaylandSeat *seat)
{ return q_func()->createKeyboardDevice(seat); }
QWaylandTouch *callCreateTouchDevice(QWaylandSeat *seat)
{ return q_func()->createTouchDevice(seat); }
inline void addClient(QWaylandClient *client);
inline void removeClient(QWaylandClient *client);
void addPolishObject(QObject *object);
inline void addOutput(QWaylandOutput *output);
inline void removeOutput(QWaylandOutput *output);
void connectToExternalSockets();
virtual QWaylandSeat *seatFor(QInputEvent *inputEvent);
protected:
void compositor_create_surface(wl_compositor::Resource *resource, uint32_t id) override;
void compositor_create_region(wl_compositor::Resource *resource, uint32_t id) override;
void subcompositor_get_subsurface(wl_subcompositor::Resource *resource, uint32_t id, struct ::wl_resource *surface, struct ::wl_resource *parent) override;
virtual QWaylandSurface *createDefaultSurface();
protected:
void initializeHardwareIntegration();
void initializeExtensions();
void initializeSeats();
void loadClientBufferIntegration();
void loadServerBufferIntegration();
QByteArray socket_name;
QList<int> externally_added_socket_fds;
struct wl_display *display = nullptr;
bool ownsDisplay = false;
QVector<QWaylandCompositor::ShmFormat> shmFormats;
QList<QWaylandSeat *> seats;
QList<QWaylandOutput *> outputs;
QList<QWaylandSurface *> all_surfaces;
#if QT_CONFIG(wayland_datadevice)
QtWayland::DataDeviceManager *data_device_manager = nullptr;
#endif
QtWayland::BufferManager *buffer_manager = nullptr;
QElapsedTimer timer;
wl_event_loop *loop = nullptr;
QList<QWaylandClient *> clients;
#if QT_CONFIG(opengl)
bool use_hw_integration_extension = true;
QScopedPointer<QtWayland::HardwareIntegration> hw_integration;
QScopedPointer<QtWayland::ServerBufferIntegration> server_buffer_integration;
#endif
QList<QtWayland::ClientBufferIntegration*> client_buffer_integrations;
QScopedPointer<QWindowSystemEventHandler> eventHandler;
bool retainSelection = false;
bool preInitialized = false;
bool initialized = false;
std::vector<QPointer<QObject> > polish_objects;
#if QT_CONFIG(xkbcommon)
QXkbCommon::ScopedXKBContext mXkbContext;
#endif
Q_DECLARE_PUBLIC(QWaylandCompositor)
Q_DISABLE_COPY(QWaylandCompositorPrivate)
};
const QList<QtWayland::ClientBufferIntegration *> QWaylandCompositorPrivate::clientBufferIntegrations() const
{
return client_buffer_integrations;
}
QtWayland::ServerBufferIntegration * QWaylandCompositorPrivate::serverBufferIntegration() const
{
#if QT_CONFIG(opengl)
return server_buffer_integration.data();
#else
return 0;
#endif
}
void QWaylandCompositorPrivate::addClient(QWaylandClient *client)
{
Q_ASSERT(!clients.contains(client));
clients.append(client);
}
void QWaylandCompositorPrivate::removeClient(QWaylandClient *client)
{
Q_ASSERT(clients.contains(client));
clients.removeOne(client);
}
void QWaylandCompositorPrivate::addOutput(QWaylandOutput *output)
{
Q_ASSERT(output);
Q_Q(QWaylandCompositor);
if (outputs.contains(output))
return;
outputs.append(output);
emit q->outputAdded(output);
if (!outputs.isEmpty() && outputs.first() == output)
emit q->defaultOutputChanged();
}
void QWaylandCompositorPrivate::removeOutput(QWaylandOutput *output)
{
Q_ASSERT(output);
Q_ASSERT(outputs.count(output) == 1);
Q_Q(QWaylandCompositor);
bool wasDefault = !outputs.isEmpty() && outputs.first() == output;
if (!outputs.removeOne(output))
return;
emit q->outputRemoved(output);
if (wasDefault)
emit q->defaultOutputChanged();
}
QT_END_NAMESPACE
#endif //QWAYLANDCOMPOSITOR_P_H