vioken / waylib Goto Github PK

A wrapper for wlroots based on Qt

C++ 96.71% CMake 2.12% Nix 0.77% QML 0.40%

waylib's Introduction

waylib

Introduction

waylib is a Wayland compositor development library, based on qwlroots, provides a Qt-style development interface. It is designed to be deeply integrated with QtQuick, taking advantage of QtQuick's Scene Graphics model to simplify the complexity of window management. In waylib, it is possible to attach one or multiple Wayland Outputs to a QQuickWindow, and a corresponding Wayland Surface can be attached to a QQuickItem, allowing it to be mixed with QtQuick's graphics components and supporting QRHI for OpenGL and Vulkan compatibility in a single piece of code.

Creating a Wayland compositor using waylib can be simple and efficient, which, on top of wlroots, provides:

QtQuick-based rendering model
Qt event model support
Session management system (under development)
Client/window group policies (under development)
Window management abstraction (under development)

Based on the above features, compositor developers need only focus on the business requirements of window management and can develop window compositors as if they were implementing a regular application.

Features

Support switch different display backend: DRM, Wayland, X11
Support custom input backend, by default it uses libinput
Support for rendering cursors in both hardware and software
Support for X Window cursor file format and theme
Support for running in environments without dri devices
Coexistence with Qt platform plug-in system
Provides QML components

Building

Step 1: Compiling and Installing wlroots and qwlroots

waylib requires the development version (0.17) of wlroots, which needs to be compiled and installed manually. Arch Linux users can install wlroots-git from AUR.

For qwlroots, it is currently recommended to use the version provided as a submodule. However, you can also compile and install it by yourself.

If using the submodule version, please note the following two points:

Initialize the submodules when you clone the source code: git clone [email protected]:vioken/waylib.git --recursive
Before the final compilation, add the cmake parameter "-DWITH_SUBMODULE_QWLROOTS=ON" to enable the building of the submodule.

Step 2: Installing other dependencies

Debian

# apt install pkg-config qt6-base-private-dev qt6-base-dev-tools qt6-declarative-private-dev wayland-protocols libpixman-1-dev

Archlinux

# pacman -Syu --noconfirm qt6-base qt6-declarative cmake pkgconfig pixman wayland-protocols ninja

NixOS:

It is recommended to manage dependencies using nix-direnv, or you can use the command nix develop to enter the build environment.

You can also packaging by using the command "nix build -v -L".

Step 3: Execute the following commands

cmake -B build -DWITH_SUBMODULE_QWLROOTS=ON
cmake --build build

How to Contribute

This project assumes that you already have experience with Qt and wlroots libraries. In order to better integrate with Qt and wlroots, waylib adheres to Qt's guidelines in terms of interface style, wlroots' modular design philosophy with regards to the underlying design, and Qt's wrapping + layering design for the upper layers that are not directly related to wlroots.

You are free to contribute as much code as you want to this project, provided that you follow the waylib design philosophy and the following types of requirements.

Code Style

When modifying existing code, the current code style should be respected.
New code: the part that is closely related to wlroots should follow the code style of wlroots, underscore naming convention should be used for the corresponding slot function; other parts should follow the code style of Qt (https://wiki.qt.io/Qt_Coding_Style this link is for reference only. The actual Qt source code shall prevail)
There is no absolute right or wrong code style, please consider the big picture, and do not rigidly stick to the small details

Code Architecture Guidelines

The code should be simple and easy to understand.
Add comments to key nodes whether you change or add new code
Security > Compatibility > Extensibility >= Performance

Contribution Guideline

Contribution steps.
1. First login to your Github account and fork the project
2. Pull the forked project locally using git clone.
3. Push the new commit to your project using git push.
4. commit your code to the upstream project on Github using the Pull Requese feature.
commit message specification: align with Qt project, use English. Be sure to describe exactly what the commit "does" and "why it was made"
A commit only does one thing, and the smaller the code changes, the easier it is to accept the commit. For larger code changes, try to split the commit into multiple commits (satisfying the git commit principle as a prerequisite)
Please do your own testing and code review before committing the code, and submit the PR after confirming that the code is working correctly

Roadmap

Support of vulkan
Support Hardware Plane
Support for virtual devices (remote screen projection, mouse, keyboard multi-device sharing)
Support multi-platform integration
Support high refresh rate (120Hz)
Support variable screen refresh rate

waylib's People

Contributors

Stargazers

Watchers

waylib's Issues

Support restart compositor when crash

https://www.youtube.com/watch?v=fRdnRwPBFBk&t=1202s&ab_channel=X.OrgFoundation
https://invent.kde.org/plasma/kwin/-/wikis/Restarting
https://www.phoronix.com/news/Qt-Wayland-Compositor-Restart

Support for the cmake/qmake/pkgconfig

cmake package (*.cmake)
qmake module (*.pri)
pkgconfig (*.pc)

Implement wlr-foreign-toplevel-management

The purpose of this protocol is to enable the creation of taskbars and docks by providing them with a list of opened applications and letting them request certain actions on them, like maximizing, etc.

https://wayland.app/protocols/wlr-foreign-toplevel-management-unstable-v1

Support screen capture for XWayland client

Use cmake

The qmake is not recommend, should use cmake follow the Qt Project.

Build failure on openSUSE Tumbleweed

It is a link check error:

[ 61s] /usr/lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/bin/ld: ../../src/server/libwaylibserver.so.0.1.1: undefined reference to QWLRoots::QWLayerSurfaceV1::surfaceAt(QPointF const&, QPointF*) const' [ 61s] /usr/lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/bin/ld: ../../src/server/libwaylibserver.so.0.1.1: undefined reference to QWLRoots::QWLayerSurfaceV1::surface() const'
[ 61s] /usr/lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/bin/ld: ../../src/server/libwaylibserver.so.0.1.1: undefined reference to QWLRoots::QWLayerShellV1::create(QWLRoots::QWDisplay*, unsigned int)' [ 61s] /usr/lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/bin/ld: ../../src/server/libwaylibserver.so.0.1.1: undefined reference to QWLRoots::QWLayerSurfaceV1::configure(unsigned int, unsigned int)'
[ 61s] collect2: error: ld returned 1 exit status
[ 61s] make[2]: *** [examples/tinywl/CMakeFiles/tinywl-qtquick.dir/build.make:613: examples/tinywl/tinywl-qtquick] Error 1
[ 61s] make[2]: Leaving directory '/home/abuild/rpmbuild/BUILD/waylib-0.1.1/build'
[ 61s] make[1]: *** [CMakeFiles/Makefile2:677: examples/tinywl/CMakeFiles/tinywl-qtquick.dir/all] Error 2
[ 61s] make: *** [Makefile:136: all] Error 2
[ 61s] error: Bad exit status from /var/tmp/rpm-tmp.sEd9C2 (%build)

More tiling layout

Some thing like https://hackage.haskell.org/package/xmonad-0.17.2/docs/XMonad-Layout.html
https://betweentwocommits.com/blog/xmonad-layouts-guide

Tall：has the master pane on the left, taking half of the screen
Full: Simple fullscreen mode. Renders the focused window fullscreen.
Mirror ... : Mirror a layout, compute its 90 degree rotated form.

Support wlr-layer-shell to v5

allow set_exclusive_edge
https://gitlab.freedesktop.org/wlroots/wlr-protocols/-/commit/2b8d43325b7012cc3f9b55c08d26e50e42beac7d

Refactor

A new QPA plugin for compositor #47
using qwlroots from QPA plugin
Move part of implementation to qwlroots
~~Re-design namespace, use Vioken replace Waylib?~~
Qt6 only, >= Qt6.4
SPDX Style License

Change handle type to QWOutput ffor WOutput

Manager the damages for the output

Support the wlr_output_damage

#30
Use wlr_output_damage on Qt software render #126
Use wlr_output_damage on Qt QRHI render

Base qwlroots

Update the READMD.md

Sections

Languages

en_US
zh_CN

Support touch event

Implement security-context-v1

https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/3589

Use wlr_output_damage for wlr_output

Implement input-method

Corresponds to a text input on the input method side. An input method context is created on text input activation on the input method side. It allows receiving information about the text input from the application via events. Input method contexts do not keep state after deactivation and should be destroyed after deactivation is handled.

https://gitlab.freedesktop.org/wayland/wayland-protocols/-/issues/39

Clean the Chinese comments

Use the ASCII characters only

Allow add multi socket to WServer

Support subsurface

Support set cursor for WOutputRenderWindow

Support Qt6

The QtQuick and qml has a large of changes in the Qt6, It's better(eg, the qml can compile to c++), and more and more projects is supported the Qt6 now, we should follow them.

Support transform of output by QtQuick's transform

Support popup surface

Add copyright for CMakeLists.txt

WQuickXdgDecorationManager support set DecorationMode for each xdg surface

support set different DecorationMode for which xdg surface

Resizing Qt widget application very slow

#308 avoids stretching surface buffer, test ok on gtk4 / wayland native (foot) / some X11 apps (glxgears, xeye).
But Qt widget apps like Qt creator encounters high latency

The client window contents is fuzziness

See the button texts, it's fuzziness.

Support wlr_output_layer

Implement wlr_layer_shell_v1

Clients can use this interface to assign the surface_layer role to wl_surfaces. Such surfaces are assigned to a "layer" of the output and rendered with a defined z-depth respective to each other. They may also be anchored to the edges and corners of a screen and specify input handling semantics. This interface should be suitable for the implementation of many desktop shell components, and a broad number of other applications that interact with the desktop.

https://wayland.app/protocols/wlr-layer-shell-unstable-v1

reference implement：

Support set cursor of QQuickItem in WOutputRenderWindow

Drop WSignalConnector

Make WServerInterface inherit QObject

Many WServerInterface derived classes require the use of Qt's signals and slots，we should make WServerInterface inherit form QObject

Support vulkan

Support build package for the Archlinux

PKGBUILD

Build issue with wlroots 0.17-dev

wlroots version=0.17.0-dev, major=0, minor=17, patch=0
QT_VERSION_MAJOR 6
Using QWlroots from submodule

[ 26%] Building CXX object qwlroots/src/CMakeFiles/qwlroots.dir/types/qwxdgshell.cpp.o
/home/shtirlic/projects/waylib/qwlroots/src/types/qwxdgshell.cpp: In constructor ‘QWLRoots::QWXdgSurfacePrivate::QWXdgSurfacePrivate(wlr_xdg_surface*, bool, QWLRoots::QWXdgSurface*)’:
/home/shtirlic/projects/waylib/qwlroots/src/types/qwxdgshell.cpp:104:36: error: ‘struct wlr_xdg_surface::<unnamed>’ has no member named ‘map’
  104 |         sc.connect(&handle->events.map, this, &QWXdgSurfacePrivate::on_map);
      |                                    ^~~
/home/shtirlic/projects/waylib/qwlroots/src/types/qwxdgshell.cpp:105:36: error: ‘struct wlr_xdg_surface::<unnamed>’ has no member named ‘unmap’
  105 |         sc.connect(&handle->events.unmap, this, &QWXdgSurfacePrivate::on_unmap);
      |                                    ^~~~~
make[2]: *** [qwlroots/src/CMakeFiles/qwlroots.dir/build.make:272: qwlroots/src/CMakeFiles/qwlroots.dir/types/qwxdgshell.cpp.o] Error 1
make[1]: *** [CMakeFiles/Makefile2:216: qwlroots/src/CMakeFiles/qwlroots.dir/all] Error 2
make: *** [Makefile:136: all] Error 2

Cursor support hotspot

Support animation cursor

treeland qml组件丢失滚轮信号

failed to compile with clang (15.0.6)

Example:

 /usr/src/packages/BUILD/waylib/src/waylib/src/server/qtquick/woutputhelper.cpp:446:5: error: attempt to use a deleted function
     delete texture;
     ^
 /usr/include/qwlroots/qwtexture.h:21:5: note: '~QWTexture' has been explicitly marked deleted here
     ~QWTexture() = delete;
     ^

Upgrade wlroots to 0.18

Support ignore the output scale to render specific wl_surface

Because same wl_surface is not support scale, maybe like as XWayalnd windows?
If we force scale the wl_surface to output, you will see same fuzzy windows.

TODO: cursor alternative names

#278 lost some cursor

reference from kwin

QVector<QByteArray> Cursor::cursorAlternativeNames(const QByteArray &name)
{
    static const QHash<QByteArray, QVector<QByteArray>> alternatives = {
        {QByteArrayLiteral("left_ptr"),       {QByteArrayLiteral("arrow"),
                                                QByteArrayLiteral("dnd-none"),
                                                QByteArrayLiteral("op_left_arrow")}},
        {QByteArrayLiteral("cross"),          {QByteArrayLiteral("crosshair"),
                                                QByteArrayLiteral("diamond-cross"),
                                                QByteArrayLiteral("cross-reverse")}},
        {QByteArrayLiteral("up_arrow"),       {QByteArrayLiteral("center_ptr"),
                                                QByteArrayLiteral("sb_up_arrow"),
                                                QByteArrayLiteral("centre_ptr")}},
        {QByteArrayLiteral("wait"),           {QByteArrayLiteral("watch"),
                                                QByteArrayLiteral("progress")}},
        {QByteArrayLiteral("ibeam"),          {QByteArrayLiteral("xterm"),
                                                QByteArrayLiteral("text")}},
        {QByteArrayLiteral("size_all"),       {QByteArrayLiteral("fleur")}},
        {QByteArrayLiteral("pointing_hand"),  {QByteArrayLiteral("hand2"),
                                                QByteArrayLiteral("hand"),
                                                QByteArrayLiteral("hand1"),
                                                QByteArrayLiteral("pointer"),
                                                QByteArrayLiteral("e29285e634086352946a0e7090d73106"),
                                                QByteArrayLiteral("9d800788f1b08800ae810202380a0822")}},
        {QByteArrayLiteral("size_ver"),       {QByteArrayLiteral("00008160000006810000408080010102"),
                                                QByteArrayLiteral("sb_v_double_arrow"),
                                                QByteArrayLiteral("v_double_arrow"),
                                                QByteArrayLiteral("n-resize"),
                                                QByteArrayLiteral("s-resize"),
                                                QByteArrayLiteral("col-resize"),
                                                QByteArrayLiteral("top_side"),
                                                QByteArrayLiteral("bottom_side"),
                                                QByteArrayLiteral("base_arrow_up"),
                                                QByteArrayLiteral("base_arrow_down"),
                                                QByteArrayLiteral("based_arrow_down"),
                                                QByteArrayLiteral("based_arrow_up")}},
        {QByteArrayLiteral("size_hor"),       {QByteArrayLiteral("028006030e0e7ebffc7f7070c0600140"),
                                                QByteArrayLiteral("sb_h_double_arrow"),
                                                QByteArrayLiteral("h_double_arrow"),
                                                QByteArrayLiteral("e-resize"),
                                                QByteArrayLiteral("w-resize"),
                                                QByteArrayLiteral("row-resize"),
                                                QByteArrayLiteral("right_side"),
                                                QByteArrayLiteral("left_side")}},
        {QByteArrayLiteral("size_bdiag"),     {QByteArrayLiteral("fcf1c3c7cd4491d801f1e1c78f100000"),
                                                QByteArrayLiteral("fd_double_arrow"),
                                                QByteArrayLiteral("bottom_left_corner"),
                                                QByteArrayLiteral("top_right_corner")}},
        {QByteArrayLiteral("size_fdiag"),     {QByteArrayLiteral("c7088f0f3e6c8088236ef8e1e3e70000"),
                                                QByteArrayLiteral("bd_double_arrow"),
                                                QByteArrayLiteral("bottom_right_corner"),
                                                QByteArrayLiteral("top_left_corner")}},
        {QByteArrayLiteral("whats_this"),     {QByteArrayLiteral("d9ce0ab605698f320427677b458ad60b"),
                                                QByteArrayLiteral("left_ptr_help"),
                                                QByteArrayLiteral("help"),
                                                QByteArrayLiteral("question_arrow"),
                                                QByteArrayLiteral("dnd-ask"),
                                                QByteArrayLiteral("5c6cd98b3f3ebcb1f9c7f1c204630408")}},
        {QByteArrayLiteral("split_h"),        {QByteArrayLiteral("14fef782d02440884392942c11205230"),
                                                QByteArrayLiteral("size_hor")}},
        {QByteArrayLiteral("split_v"),        {QByteArrayLiteral("2870a09082c103050810ffdffffe0204"),
                                                QByteArrayLiteral("size_ver")}},
        {QByteArrayLiteral("forbidden"),      {QByteArrayLiteral("03b6e0fcb3499374a867c041f52298f0"),
                                                QByteArrayLiteral("circle"),
                                                QByteArrayLiteral("dnd-no-drop"),
                                                QByteArrayLiteral("not-allowed")}},
        {QByteArrayLiteral("left_ptr_watch"), {QByteArrayLiteral("3ecb610c1bf2410f44200f48c40d3599"),
                                                QByteArrayLiteral("00000000000000020006000e7e9ffc3f"),
                                                QByteArrayLiteral("08e8e1c95fe2fc01f976f1e063a24ccd")}},
        {QByteArrayLiteral("openhand"),       {QByteArrayLiteral("9141b49c8149039304290b508d208c40"),
                                                QByteArrayLiteral("all_scroll"),
                                                QByteArrayLiteral("all-scroll")}},
        {QByteArrayLiteral("closedhand"),     {QByteArrayLiteral("05e88622050804100c20044008402080"),
                                                QByteArrayLiteral("4498f0e0c1937ffe01fd06f973665830"),
                                                QByteArrayLiteral("9081237383d90e509aa00f00170e968f"),
                                                QByteArrayLiteral("fcf21c00b30f7e3f83fe0dfd12e71cff")}},
        {QByteArrayLiteral("dnd-link"),       {QByteArrayLiteral("link"),
                                                QByteArrayLiteral("alias"),
                                                QByteArrayLiteral("3085a0e285430894940527032f8b26df"),
                                                QByteArrayLiteral("640fb0e74195791501fd1ed57b41487f"),
                                                QByteArrayLiteral("a2a266d0498c3104214a47bd64ab0fc8")}},
        {QByteArrayLiteral("dnd-copy"),       {QByteArrayLiteral("copy"),
                                                QByteArrayLiteral("1081e37283d90000800003c07f3ef6bf"),
                                                QByteArrayLiteral("6407b0e94181790501fd1e167b474872"),
                                                QByteArrayLiteral("b66166c04f8c3109214a4fbd64a50fc8")}},
        {QByteArrayLiteral("dnd-move"),       {QByteArrayLiteral("move")}},
        {QByteArrayLiteral("sw-resize"),        {QByteArrayLiteral("size_bdiag"),
                                                QByteArrayLiteral("fcf1c3c7cd4491d801f1e1c78f100000"),
                                                QByteArrayLiteral("fd_double_arrow"),
                                                QByteArrayLiteral("bottom_left_corner")}},
        {QByteArrayLiteral("se-resize"),         {QByteArrayLiteral("size_fdiag"),
                                                QByteArrayLiteral("c7088f0f3e6c8088236ef8e1e3e70000"),
                                                QByteArrayLiteral("bd_double_arrow"),
                                                QByteArrayLiteral("bottom_right_corner")}},
        {QByteArrayLiteral("ne-resize"),         {QByteArrayLiteral("size_bdiag"),
                                                QByteArrayLiteral("fcf1c3c7cd4491d801f1e1c78f100000"),
                                                QByteArrayLiteral("fd_double_arrow"),
                                                QByteArrayLiteral("top_right_corner")}},
        {QByteArrayLiteral("nw-resize"),         {QByteArrayLiteral("size_fdiag"),
                                                QByteArrayLiteral("c7088f0f3e6c8088236ef8e1e3e70000"),
                                                QByteArrayLiteral("bd_double_arrow"),
                                                QByteArrayLiteral("top_left_corner")}},
        {QByteArrayLiteral("n-resize"),       {QByteArrayLiteral("size_ver"),
                                                QByteArrayLiteral("00008160000006810000408080010102"),
                                                QByteArrayLiteral("sb_v_double_arrow"),
                                                QByteArrayLiteral("v_double_arrow"),
                                                QByteArrayLiteral("col-resize"),
                                               QByteArrayLiteral("top_side")}},
        {QByteArrayLiteral("e-resize"),       {QByteArrayLiteral("size_hor"),
                                                QByteArrayLiteral("028006030e0e7ebffc7f7070c0600140"),
                                                QByteArrayLiteral("sb_h_double_arrow"),
                                                QByteArrayLiteral("h_double_arrow"),
                                                QByteArrayLiteral("row-resize"),
                                                QByteArrayLiteral("left_side")}},
        {QByteArrayLiteral("s-resize"),       {QByteArrayLiteral("size_ver"),
                                                QByteArrayLiteral("00008160000006810000408080010102"),
                                                QByteArrayLiteral("sb_v_double_arrow"),
                                                QByteArrayLiteral("v_double_arrow"),
                                                QByteArrayLiteral("col-resize"),
                                                QByteArrayLiteral("bottom_side")}},
         {QByteArrayLiteral("w-resize"),       {QByteArrayLiteral("size_hor"),
                                                QByteArrayLiteral("028006030e0e7ebffc7f7070c0600140"),
                                                QByteArrayLiteral("sb_h_double_arrow"),
                                                QByteArrayLiteral("h_double_arrow"),
                                                QByteArrayLiteral("right_side")}}
    };
    auto it = alternatives.find(name);
    if (it != alternatives.end()) {
        return it.value();
    }
    return QVector<QByteArray>();
}

WSurfaceItem: set implicitWidth and implicitHeight property

How to run TinyWL example?

I've compiled the whole project & submodules according to instructions without any error.
And the tinywl-qtquick binary can run and display without crash in tty.
(Run as root, XDG_RUNTIME_DIR set to /run/user/$UID, seatd.sock in /run (require root permission), wayland-0 in /tmp/runtime-$USER/)

However, problems exist that:

Cannot run in X11 like weston. Since wlroots-0.17.0 invokes a incompatible GBM func, I disabled it in wlroots. Don't know if this is related.
(EE) could not connect to wayland server. The client didn't start in tinywl, although the startDemo func returned true.

00:00:30.706 [INFO] [xwayland/server.c:218] Restarting Xwayland
00:00:30.711 [INFO] [wayland] wl_display_destroy_clients: cannot destroy all clients because new ones were created by destroy callbacks
00:00:30.716 [INFO] [xwayland/server.c:108] Starting Xwayland on :3
(EE) failed to read Wayland events: Broken pipe

Enabling WAYLAND_DEBUG=1 provides a little more log, but is still limited.
logs.txt
strace.txt

TODO： Wayland Protocols

necessary

low priority

Waiting for upstream

Support XWayland in qml

Drop XXXX::nativeInterface template function

Direct return QWXXXX instance in XXXX::handle function, drop WXXXXXHandle type. for an example:

class WCursor : public QObject, public WObject
{
    Q_OBJECT
    W_DECLARE_PRIVATE(WCursor)

public:
    explicit WCursor(QObject *parent = nullptr);

    QWCursor *handle() const;
    static WCursor *fromHandle(const QWCursor *handle);
};

Implement wp_fractional_scale_v1

support workspaces

Workspaces can better manage display for multiple applications