2020-08-02 22:22:19 +00:00
|
|
|
/*
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
2019-06-13 09:27:01 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-FileCopyrightText: 2019 Roman Gilg <subdiff@gmail.com>
|
2019-06-13 09:27:01 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2019-06-13 09:27:01 +00:00
|
|
|
#ifndef KWIN_X11WINDOWED_OUTPUT_H
|
|
|
|
#define KWIN_X11WINDOWED_OUTPUT_H
|
|
|
|
|
2019-06-13 09:36:07 +00:00
|
|
|
#include "abstract_wayland_output.h"
|
2019-06-13 09:27:01 +00:00
|
|
|
#include <kwin_export.h>
|
|
|
|
|
|
|
|
#include <QObject>
|
|
|
|
#include <QSize>
|
|
|
|
#include <QString>
|
|
|
|
|
|
|
|
#include <xcb/xcb.h>
|
|
|
|
|
|
|
|
class NETWinInfo;
|
|
|
|
|
|
|
|
namespace KWin
|
|
|
|
{
|
Introduce RenderLoop
At the moment, our frame scheduling infrastructure is still heavily
based on Xinerama-style rendering. Specifically, we assume that painting
is driven by a single timer, etc.
This change introduces a new type - RenderLoop. Its main purpose is to
drive compositing on a specific output, or in case of X11, on the
overlay window.
With RenderLoop, compositing is synchronized to vblank events. It
exposes the last and the next estimated presentation timestamp. The
expected presentation timestamp can be used by effects to ensure that
animations are synchronized with the upcoming vblank event.
On Wayland, every outputs has its own render loop. On X11, per screen
rendering is not possible, therefore the platform exposes the render
loop for the overlay window. Ideally, the Scene has to expose the
RenderLoop, but as the first step towards better compositing scheduling
it's good as is for the time being.
The RenderLoop tries to minimize the latency by delaying compositing as
close as possible to the next vblank event. One tricky thing about it is
that if compositing is too close to the next vblank event, animations
may become a little bit choppy. However, increasing the latency reduces
the choppiness.
Given that, there is no any "silver bullet" solution for the choppiness
issue, a new option has been added in the Compositing KCM to specify the
amount of latency. By default, it's "Medium," but if a user is not
satisfied with the upstream default, they can tweak it.
2020-11-19 08:52:29 +00:00
|
|
|
|
|
|
|
class SoftwareVsyncMonitor;
|
2019-06-13 09:27:01 +00:00
|
|
|
class X11WindowedBackend;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Wayland outputs in a nested X11 setup
|
2019-07-29 18:58:33 +00:00
|
|
|
*/
|
2019-06-13 09:36:07 +00:00
|
|
|
class KWIN_EXPORT X11WindowedOutput : public AbstractWaylandOutput
|
2019-06-13 09:27:01 +00:00
|
|
|
{
|
|
|
|
Q_OBJECT
|
|
|
|
public:
|
|
|
|
explicit X11WindowedOutput(X11WindowedBackend *backend);
|
|
|
|
~X11WindowedOutput() override;
|
|
|
|
|
Introduce RenderLoop
At the moment, our frame scheduling infrastructure is still heavily
based on Xinerama-style rendering. Specifically, we assume that painting
is driven by a single timer, etc.
This change introduces a new type - RenderLoop. Its main purpose is to
drive compositing on a specific output, or in case of X11, on the
overlay window.
With RenderLoop, compositing is synchronized to vblank events. It
exposes the last and the next estimated presentation timestamp. The
expected presentation timestamp can be used by effects to ensure that
animations are synchronized with the upcoming vblank event.
On Wayland, every outputs has its own render loop. On X11, per screen
rendering is not possible, therefore the platform exposes the render
loop for the overlay window. Ideally, the Scene has to expose the
RenderLoop, but as the first step towards better compositing scheduling
it's good as is for the time being.
The RenderLoop tries to minimize the latency by delaying compositing as
close as possible to the next vblank event. One tricky thing about it is
that if compositing is too close to the next vblank event, animations
may become a little bit choppy. However, increasing the latency reduces
the choppiness.
Given that, there is no any "silver bullet" solution for the choppiness
issue, a new option has been added in the Compositing KCM to specify the
amount of latency. By default, it's "Medium," but if a user is not
satisfied with the upstream default, they can tweak it.
2020-11-19 08:52:29 +00:00
|
|
|
RenderLoop *renderLoop() const override;
|
|
|
|
SoftwareVsyncMonitor *vsyncMonitor() const;
|
|
|
|
|
2019-08-27 10:31:42 +00:00
|
|
|
void init(const QPoint &logicalPosition, const QSize &pixelSize);
|
2019-06-13 09:27:01 +00:00
|
|
|
|
|
|
|
xcb_window_t window() const {
|
|
|
|
return m_window;
|
|
|
|
}
|
|
|
|
|
|
|
|
QPoint internalPosition() const;
|
|
|
|
QPoint hostPosition() const {
|
|
|
|
return m_hostPosition;
|
|
|
|
}
|
|
|
|
void setHostPosition(const QPoint &pos);
|
|
|
|
|
|
|
|
void setWindowTitle(const QString &title);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief defines the geometry of the output
|
|
|
|
* @param logicalPosition top left position of the output in compositor space
|
|
|
|
* @param pixelSize output size as seen from the outside
|
|
|
|
*/
|
|
|
|
void setGeometry(const QPoint &logicalPosition, const QSize &pixelSize);
|
|
|
|
|
2019-09-14 18:19:20 +00:00
|
|
|
/**
|
|
|
|
* Translates the global X11 screen coordinate @p pos to output coordinates.
|
|
|
|
*/
|
|
|
|
QPointF mapFromGlobal(const QPointF &pos) const;
|
|
|
|
|
2019-06-13 09:27:01 +00:00
|
|
|
private:
|
|
|
|
void initXInputForWindow();
|
Introduce RenderLoop
At the moment, our frame scheduling infrastructure is still heavily
based on Xinerama-style rendering. Specifically, we assume that painting
is driven by a single timer, etc.
This change introduces a new type - RenderLoop. Its main purpose is to
drive compositing on a specific output, or in case of X11, on the
overlay window.
With RenderLoop, compositing is synchronized to vblank events. It
exposes the last and the next estimated presentation timestamp. The
expected presentation timestamp can be used by effects to ensure that
animations are synchronized with the upcoming vblank event.
On Wayland, every outputs has its own render loop. On X11, per screen
rendering is not possible, therefore the platform exposes the render
loop for the overlay window. Ideally, the Scene has to expose the
RenderLoop, but as the first step towards better compositing scheduling
it's good as is for the time being.
The RenderLoop tries to minimize the latency by delaying compositing as
close as possible to the next vblank event. One tricky thing about it is
that if compositing is too close to the next vblank event, animations
may become a little bit choppy. However, increasing the latency reduces
the choppiness.
Given that, there is no any "silver bullet" solution for the choppiness
issue, a new option has been added in the Compositing KCM to specify the
amount of latency. By default, it's "Medium," but if a user is not
satisfied with the upstream default, they can tweak it.
2020-11-19 08:52:29 +00:00
|
|
|
void vblank(std::chrono::nanoseconds timestamp);
|
2019-06-13 09:27:01 +00:00
|
|
|
|
|
|
|
xcb_window_t m_window = XCB_WINDOW_NONE;
|
|
|
|
NETWinInfo *m_winInfo = nullptr;
|
Introduce RenderLoop
At the moment, our frame scheduling infrastructure is still heavily
based on Xinerama-style rendering. Specifically, we assume that painting
is driven by a single timer, etc.
This change introduces a new type - RenderLoop. Its main purpose is to
drive compositing on a specific output, or in case of X11, on the
overlay window.
With RenderLoop, compositing is synchronized to vblank events. It
exposes the last and the next estimated presentation timestamp. The
expected presentation timestamp can be used by effects to ensure that
animations are synchronized with the upcoming vblank event.
On Wayland, every outputs has its own render loop. On X11, per screen
rendering is not possible, therefore the platform exposes the render
loop for the overlay window. Ideally, the Scene has to expose the
RenderLoop, but as the first step towards better compositing scheduling
it's good as is for the time being.
The RenderLoop tries to minimize the latency by delaying compositing as
close as possible to the next vblank event. One tricky thing about it is
that if compositing is too close to the next vblank event, animations
may become a little bit choppy. However, increasing the latency reduces
the choppiness.
Given that, there is no any "silver bullet" solution for the choppiness
issue, a new option has been added in the Compositing KCM to specify the
amount of latency. By default, it's "Medium," but if a user is not
satisfied with the upstream default, they can tweak it.
2020-11-19 08:52:29 +00:00
|
|
|
RenderLoop *m_renderLoop;
|
|
|
|
SoftwareVsyncMonitor *m_vsyncMonitor;
|
2019-06-13 09:27:01 +00:00
|
|
|
QPoint m_hostPosition;
|
|
|
|
|
|
|
|
X11WindowedBackend *m_backend;
|
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|