yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/abstract_backend.h

133 lines
4 KiB
C
Raw Normal View History

Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#ifndef KWIN_ABSTRACT_BACKEND_H
#define KWIN_ABSTRACT_BACKEND_H
[wayland] Backends are no longer singletons They are installed in the WaylandServer, thus we don't need an explicit singleton accessor. If we need to differentiate we can cast.
2015-03-23 13:29:07 +00:00
#include <kwin_export.h>
[wayland] Add support for a "software" cursor At least the framebuffer backend does not have support for an overlay cursor. Thus the cursor needs to be rendered by the scene. This change allows a backend to set that it needs a software cursor which triggers tracking in the AbstractBackend. A repaint for the old cursor region is triggered whenever the cursor pos changes. So far only the QPainter/framebuffer scene is adjusted to render the software cursor. This is done after rendering a frame with the up to date cursor position. There is one problem, though: the KWin internal cursors don't work as we need to get it from the theme. Using wayland-cursor doesn't help as it gives us a (client) wl_buffer* and we cannot read the memory back.
2015-04-01 13:36:40 +00:00
#include <QImage>
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
#include <QObject>
namespace KWin
{
[wayland] Create OpenGLBackend through the AbstractBackend Replaces casting logic in the SceneOpenGL. Now the create is delegated to the backend allowing also to move the ifdef logic to where it belongs.
2015-03-27 07:51:56 +00:00
class OpenGLBackend;
[wayland] Create QPainterBackend through the AbstractBackend SceneQPainter delegates creation to the AbstractBackend removing the casting logic.
2015-03-27 08:05:03 +00:00
class QPainterBackend;
[wayland] Create Screens through the AbstractBackend The AbstractBackend provides a virtual method to create the Screens. A concrete backend can implement this method to create the backend specific Screens instance. This removes the casting logic from Screens::create.
2015-03-27 06:52:59 +00:00
class Screens;
[wayland] Set internal cursor through WaylandCursorTheme in AbstractBackend Getting the cursor image from the cursor theme is unfortunately not straight forward. We have three different libraries and all have drawbacks: * XCursor - we just kicked it out * xcb-util/cursor - only provides xcb_cursor_t, so a dependency on X * wayland-cursor - only a client side API The picked solution is using wayland-cursor. It provides the cursor in a wl_buffer. Unfortunately the client side API does not easily allow to a) read it back b) init without a wl_shm_pool Thus we need to work this around: * create an internal connection * get a ShmPool on it * init WaylandCursorTheme with this ShmPool * get the cursor wl_buffer from the theme * trigger a roundtrip * get the corresponding BufferInterface for the buffer * set the content as the software cursor
2015-04-02 12:37:23 +00:00
class WaylandCursorTheme;
[wayland] Backends are no longer singletons They are installed in the WaylandServer, thus we don't need an explicit singleton accessor. If we need to differentiate we can cast.
2015-03-23 13:29:07 +00:00
class KWIN_EXPORT AbstractBackend : public QObject
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
{
Q_OBJECT
public:
virtual ~AbstractBackend();
[wayland] Use a pure virtual AbstractBackend::init method Two backends already used an init method, let's make that the same in all backends to be able to have shared startup code.
2015-05-06 06:32:39 +00:00
virtual void init() = 0;
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
virtual void installCursorFromServer();
virtual void installCursorImage(Qt::CursorShape shape);
[wayland] Create Screens through the AbstractBackend The AbstractBackend provides a virtual method to create the Screens. A concrete backend can implement this method to create the backend specific Screens instance. This removes the casting logic from Screens::create.
2015-03-27 06:52:59 +00:00
virtual Screens *createScreens(QObject *parent = nullptr);
[wayland] Create OpenGLBackend through the AbstractBackend Replaces casting logic in the SceneOpenGL. Now the create is delegated to the backend allowing also to move the ifdef logic to where it belongs.
2015-03-27 07:51:56 +00:00
virtual OpenGLBackend *createOpenGLBackend();
[wayland] Create QPainterBackend through the AbstractBackend SceneQPainter delegates creation to the AbstractBackend removing the casting logic.
2015-03-27 08:05:03 +00:00
virtual QPainterBackend *createQPainterBackend();
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
[wayland] Add support for a "software" cursor At least the framebuffer backend does not have support for an overlay cursor. Thus the cursor needs to be rendered by the scene. This change allows a backend to set that it needs a software cursor which triggers tracking in the AbstractBackend. A repaint for the old cursor region is triggered whenever the cursor pos changes. So far only the QPainter/framebuffer scene is adjusted to render the software cursor. This is done after rendering a frame with the up to date cursor position. There is one problem, though: the KWin internal cursors don't work as we need to get it from the theme. Using wayland-cursor doesn't help as it gives us a (client) wl_buffer* and we cannot read the memory back.
2015-04-01 13:36:40 +00:00
bool usesSoftwareCursor() const {
return m_softWareCursor;
}
QImage softwareCursor() const {
return m_cursor.image;
}
QPoint softwareCursorHotspot() const {
return m_cursor.hotspot;
}
void markCursorAsRendered();
[wayland] Allow the AbstractBackend subclasses to manage OutputInterfaces This gives the backend more control without needing to provide all information in Screens.
2015-04-24 10:00:19 +00:00
bool handlesOutputs() const {
return m_handlesOutputs;
}
[wayland] A backend can mark whether it is ready Replaces the functionality of the WaylandBackend and makes it available to all backends by providing the functionality directly in AbstractBackend. By default a backend is not ready and the implementation must call setReady(true) to indicate that setup has finished successfully. The compositor won't start till the backend indicates that it is ready.
2015-05-05 17:02:52 +00:00
bool isReady() const {
return m_ready;
}
[wayland] Add an initialWindowSize to AbstractBackend Useful for windowed backends like X11 and Wayland.
2015-05-06 07:26:08 +00:00
void setInitialWindowSize(const QSize &size) {
m_initialWindowSize = size;
}
[wayland] Introduce a deviceIdentifier in AbstractBackend To be used by the concrete backends for e.g. framebuffer device name, DISPLAY or WAYLAND_DISPLAY variable.
2015-05-06 07:37:25 +00:00
void setDeviceIdentifier(const QByteArray &identifier) {
m_deviceIdentifier = identifier;
}
[wayland] Allow the AbstractBackend subclasses to manage OutputInterfaces This gives the backend more control without needing to provide all information in Screens.
2015-04-24 10:00:19 +00:00
[backends/hwcomposer] Forward input events to main thread Libhybris input events are generated in a different thread, but we want them in the main thread (InputRedirection and KWayland are not (yet) thread safe). Thus all events need to be send to the main thread using QMetaObject::invokeMethod.
2015-05-11 13:43:30 +00:00
public Q_SLOTS:
[wayland] Don't call into InputRedirection from AbstractBackend implementations Instead the AbstractBackend provides methods which delegate into InputRedirection.
2015-05-05 08:44:46 +00:00
void pointerMotion(const QPointF &position, quint32 time);
void pointerButtonPressed(quint32 button, quint32 time);
void pointerButtonReleased(quint32 button, quint32 time);
void pointerAxisHorizontal(qreal delta, quint32 time);
void pointerAxisVertical(qreal delta, quint32 time);
void keyboardKeyPressed(quint32 key, quint32 time);
void keyboardKeyReleased(quint32 key, quint32 time);
void keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
void keymapChange(int fd, uint32_t size);
void touchDown(qint32 id, const QPointF &pos, quint32 time);
void touchUp(qint32 id, quint32 time);
void touchMotion(qint32 id, const QPointF &pos, quint32 time);
void touchCancel();
void touchFrame();
Add support for hardware cursors in DrmBackend Creates two buffers with the size queried through the drm capabilities. The actual cursor image is retrieved using the software cursor functionality from the AbstractBackend and rendered into the shared memory buffer. The the buffer is set as the new cursor image and the rendering buffer for the cursor is swapped. The position is updated whenever the cursor image changes or the mouse position changes.
2015-04-13 14:25:34 +00:00
Q_SIGNALS:
[wayland] AbstractBackend provides signal screensQueried With this change all backends need to emit the screensQueried signal at some point. So far only x11 backend did not provide the signal, wayland had a comparable delayed init mechanism. Now all backends use the same mechanism.
2015-05-06 07:03:54 +00:00
void screensQueried();
[wayland] AbstractBackend can emit an initFailed signal Replaces the custom handling for Wayland and X11 Backend. Now they can just emit the initFailed signal.
2015-05-06 07:16:36 +00:00
void initFailed();
Add support for hardware cursors in DrmBackend Creates two buffers with the size queried through the drm capabilities. The actual cursor image is retrieved using the software cursor functionality from the AbstractBackend and rendered into the shared memory buffer. The the buffer is set as the new cursor image and the rendering buffer for the cursor is swapped. The position is updated whenever the cursor image changes or the mouse position changes.
2015-04-13 14:25:34 +00:00
void cursorChanged();
[wayland] A backend can mark whether it is ready Replaces the functionality of the WaylandBackend and makes it available to all backends by providing the functionality directly in AbstractBackend. By default a backend is not ready and the implementation must call setReady(true) to indicate that setup has finished successfully. The compositor won't start till the backend indicates that it is ready.
2015-05-05 17:02:52 +00:00
void readyChanged(bool);
Add support for hardware cursors in DrmBackend Creates two buffers with the size queried through the drm capabilities. The actual cursor image is retrieved using the software cursor functionality from the AbstractBackend and rendered into the shared memory buffer. The the buffer is set as the new cursor image and the rendering buffer for the cursor is swapped. The position is updated whenever the cursor image changes or the mouse position changes.
2015-04-13 14:25:34 +00:00
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
protected:
explicit AbstractBackend(QObject *parent = nullptr);
[wayland] Add support for a "software" cursor At least the framebuffer backend does not have support for an overlay cursor. Thus the cursor needs to be rendered by the scene. This change allows a backend to set that it needs a software cursor which triggers tracking in the AbstractBackend. A repaint for the old cursor region is triggered whenever the cursor pos changes. So far only the QPainter/framebuffer scene is adjusted to render the software cursor. This is done after rendering a frame with the up to date cursor position. There is one problem, though: the KWin internal cursors don't work as we need to get it from the theme. Using wayland-cursor doesn't help as it gives us a (client) wl_buffer* and we cannot read the memory back.
2015-04-01 13:36:40 +00:00
void setSoftWareCursor(bool set);
Add support for hardware cursors in DrmBackend Creates two buffers with the size queried through the drm capabilities. The actual cursor image is retrieved using the software cursor functionality from the AbstractBackend and rendered into the shared memory buffer. The the buffer is set as the new cursor image and the rendering buffer for the cursor is swapped. The position is updated whenever the cursor image changes or the mouse position changes.
2015-04-13 14:25:34 +00:00
void updateCursorFromServer();
void updateCursorImage(Qt::CursorShape shape);
[wayland] Allow the AbstractBackend subclasses to manage OutputInterfaces This gives the backend more control without needing to provide all information in Screens.
2015-04-24 10:00:19 +00:00
void handleOutputs() {
m_handlesOutputs = true;
}
[wayland] Add protected AbstractBackend::repaint(const QRect&) Allows to trigger a repaint in the Compositor. This way the implementation does not need to call into Compositor.
2015-05-05 08:54:13 +00:00
void repaint(const QRect &rect);
[wayland] A backend can mark whether it is ready Replaces the functionality of the WaylandBackend and makes it available to all backends by providing the functionality directly in AbstractBackend. By default a backend is not ready and the implementation must call setReady(true) to indicate that setup has finished successfully. The compositor won't start till the backend indicates that it is ready.
2015-05-05 17:02:52 +00:00
void setReady(bool ready);
[wayland] Add an initialWindowSize to AbstractBackend Useful for windowed backends like X11 and Wayland.
2015-05-06 07:26:08 +00:00
QSize initialWindowSize() const {
return m_initialWindowSize;
}
[wayland] Introduce a deviceIdentifier in AbstractBackend To be used by the concrete backends for e.g. framebuffer device name, DISPLAY or WAYLAND_DISPLAY variable.
2015-05-06 07:37:25 +00:00
QByteArray deviceIdentifier() const {
return m_deviceIdentifier;
}
[wayland] Add support for a "software" cursor At least the framebuffer backend does not have support for an overlay cursor. Thus the cursor needs to be rendered by the scene. This change allows a backend to set that it needs a software cursor which triggers tracking in the AbstractBackend. A repaint for the old cursor region is triggered whenever the cursor pos changes. So far only the QPainter/framebuffer scene is adjusted to render the software cursor. This is done after rendering a frame with the up to date cursor position. There is one problem, though: the KWin internal cursors don't work as we need to get it from the theme. Using wayland-cursor doesn't help as it gives us a (client) wl_buffer* and we cannot read the memory back.
2015-04-01 13:36:40 +00:00
[wayland] Set internal cursor through WaylandCursorTheme in AbstractBackend Getting the cursor image from the cursor theme is unfortunately not straight forward. We have three different libraries and all have drawbacks: * XCursor - we just kicked it out * xcb-util/cursor - only provides xcb_cursor_t, so a dependency on X * wayland-cursor - only a client side API The picked solution is using wayland-cursor. It provides the cursor in a wl_buffer. Unfortunately the client side API does not easily allow to a) read it back b) init without a wl_shm_pool Thus we need to work this around: * create an internal connection * get a ShmPool on it * init WaylandCursorTheme with this ShmPool * get the cursor wl_buffer from the theme * trigger a roundtrip * get the corresponding BufferInterface for the buffer * set the content as the software cursor
2015-04-02 12:37:23 +00:00
private Q_SLOTS:
void installThemeCursor(quint32 id, const QPoint &hotspot);
[wayland] Add support for a "software" cursor At least the framebuffer backend does not have support for an overlay cursor. Thus the cursor needs to be rendered by the scene. This change allows a backend to set that it needs a software cursor which triggers tracking in the AbstractBackend. A repaint for the old cursor region is triggered whenever the cursor pos changes. So far only the QPainter/framebuffer scene is adjusted to render the software cursor. This is done after rendering a frame with the up to date cursor position. There is one problem, though: the KWin internal cursors don't work as we need to get it from the theme. Using wayland-cursor doesn't help as it gives us a (client) wl_buffer* and we cannot read the memory back.
2015-04-01 13:36:40 +00:00
private:
void triggerCursorRepaint();
bool m_softWareCursor = false;
struct {
QPoint hotspot;
QImage image;
QPoint lastRenderedPosition;
} m_cursor;
[wayland] Split out WaylandCursorTheme into own header/implementation It's used by both the WaylandBackend and AbstractBackend. By splitting it out the AbstractBackend doesn't need to depend on an implementation.
2015-05-05 11:02:16 +00:00
WaylandCursorTheme *m_cursorTheme = nullptr;
[wayland] Allow the AbstractBackend subclasses to manage OutputInterfaces This gives the backend more control without needing to provide all information in Screens.
2015-04-24 10:00:19 +00:00
bool m_handlesOutputs = false;
[wayland] A backend can mark whether it is ready Replaces the functionality of the WaylandBackend and makes it available to all backends by providing the functionality directly in AbstractBackend. By default a backend is not ready and the implementation must call setReady(true) to indicate that setup has finished successfully. The compositor won't start till the backend indicates that it is ready.
2015-05-05 17:02:52 +00:00
bool m_ready = false;
[wayland] Add an initialWindowSize to AbstractBackend Useful for windowed backends like X11 and Wayland.
2015-05-06 07:26:08 +00:00
QSize m_initialWindowSize;
[wayland] Introduce a deviceIdentifier in AbstractBackend To be used by the concrete backends for e.g. framebuffer device name, DISPLAY or WAYLAND_DISPLAY variable.
2015-05-06 07:37:25 +00:00
QByteArray m_deviceIdentifier;
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
};
}
Create a plugin for each of the wayland backends Each of the backends becomes a plugin. This allows kwin_wayland to load the requested plugin and kwin itself doesn't need to link all the libraries needed. E.g. libdrm is no longer linked if running kwin_x11. Also this allows to create backends for the non-standard EGL platforms (examples could be raspberrypi or Android devices).
2015-05-05 15:58:09 +00:00
Q_DECLARE_INTERFACE(KWin::AbstractBackend, "org.kde.kwin.AbstractBackend")
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
#endif
Reference in a new issue Copy permalink