2020-08-02 22:22:19 +00:00
|
|
|
/*
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-FileCopyrightText: 2006 Lubos Lunak <l.lunak@kde.org>
|
|
|
|
SPDX-FileCopyrightText: 2009 Fredrik Höglund <fredrik@kde.org>
|
|
|
|
SPDX-FileCopyrightText: 2013 Martin Gräßlin <mgraesslin@kde.org>
|
2020-08-02 22:10:35 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2007-04-29 17:35:43 +00:00
|
|
|
#include "scene_xrender.h"
|
2014-12-05 10:42:15 +00:00
|
|
|
#include "utils.h"
|
2020-12-05 15:54:19 +00:00
|
|
|
#include "xrenderbackend.h"
|
2014-12-05 10:42:15 +00:00
|
|
|
|
2007-12-17 14:14:53 +00:00
|
|
|
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2017-08-10 16:13:42 +00:00
|
|
|
#include "logging.h"
|
2007-04-29 17:35:43 +00:00
|
|
|
#include "toplevel.h"
|
2019-09-24 08:48:08 +00:00
|
|
|
#include "x11client.h"
|
2013-06-19 11:31:28 +00:00
|
|
|
#include "composite.h"
|
2007-04-29 17:35:43 +00:00
|
|
|
#include "deleted.h"
|
|
|
|
#include "effects.h"
|
2013-06-25 07:53:45 +00:00
|
|
|
#include "main.h"
|
2011-07-06 09:58:23 +00:00
|
|
|
#include "overlaywindow.h"
|
2017-08-07 15:54:56 +00:00
|
|
|
#include "platform.h"
|
2021-01-26 12:18:29 +00:00
|
|
|
#include "renderloop.h"
|
2016-06-08 10:46:02 +00:00
|
|
|
#include "screens.h"
|
2012-12-21 14:11:31 +00:00
|
|
|
#include "xcbutils.h"
|
2014-07-22 11:11:19 +00:00
|
|
|
#include "decorations/decoratedclient.h"
|
2007-04-29 17:35:43 +00:00
|
|
|
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
#include <kwineffectquickview.h>
|
|
|
|
#include <kwinxrenderutils.h>
|
|
|
|
|
2013-02-06 06:58:33 +00:00
|
|
|
#include <xcb/xfixes.h>
|
2008-09-18 15:27:13 +00:00
|
|
|
|
2013-09-02 11:14:39 +00:00
|
|
|
#include <QDebug>
|
2018-06-05 10:52:57 +00:00
|
|
|
#include <QPainter>
|
2019-07-09 19:19:26 +00:00
|
|
|
#include <QtMath>
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
|
|
|
ScreenPaintData SceneXrender::screen_paint;
|
|
|
|
|
2013-07-03 19:30:51 +00:00
|
|
|
#define DOUBLE_TO_FIXED(d) ((xcb_render_fixed_t) ((d) * 65536))
|
|
|
|
#define FIXED_TO_DOUBLE(f) ((double) ((f) / 65536.0))
|
|
|
|
|
2013-06-17 13:25:32 +00:00
|
|
|
//****************************************
|
|
|
|
// SceneXrender
|
|
|
|
//****************************************
|
2016-06-01 10:51:10 +00:00
|
|
|
|
2015-02-23 13:41:45 +00:00
|
|
|
SceneXrender* SceneXrender::createScene(QObject *parent)
|
2013-06-17 13:25:32 +00:00
|
|
|
{
|
2020-12-05 15:54:19 +00:00
|
|
|
QScopedPointer<XRenderBackend> backend(kwinApp()->platform()->createXRenderBackend());
|
|
|
|
if (!backend || backend->isFailed()) {
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
return nullptr;
|
2013-06-17 13:25:32 +00:00
|
|
|
}
|
2015-02-23 13:41:45 +00:00
|
|
|
return new SceneXrender(backend.take(), parent);
|
2013-06-17 13:25:32 +00:00
|
|
|
}
|
|
|
|
|
2015-02-23 13:41:45 +00:00
|
|
|
SceneXrender::SceneXrender(XRenderBackend *backend, QObject *parent)
|
|
|
|
: Scene(parent)
|
2013-06-17 13:25:32 +00:00
|
|
|
, m_backend(backend)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
SceneXrender::~SceneXrender()
|
|
|
|
{
|
|
|
|
SceneXrender::Window::cleanup();
|
|
|
|
SceneXrender::EffectFrame::cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SceneXrender::initFailed() const
|
|
|
|
{
|
|
|
|
return false;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-05-30 14:22:09 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
// the entry point for painting
|
Provide expected presentation time to effects
Effects are given the interval between two consecutive frames. The main
flaw of this approach is that if the Compositor transitions from the idle
state to "active" state, i.e. when there is something to repaint,
effects may see a very large interval between the last painted frame and
the current. In order to address this issue, the Scene invalidates the
timer that is used to measure time between consecutive frames before the
Compositor is about to become idle.
While this works perfectly fine with Xinerama-style rendering, with per
screen rendering, determining whether the compositor is about to idle is
rather a tedious task mostly because a single output can't be used for
the test.
Furthermore, since the Compositor schedules pointless repaints just to
ensure that it's idle, it might take several attempts to figure out
whether the scene timer must be invalidated if you use (true) per screen
rendering.
Ideally, all effects should use a timeline helper that is aware of the
underlying render loop and its timings. However, this option is off the
table because it will involve a lot of work to implement it.
Alternative and much simpler option is to pass the expected presentation
time to effects rather than time between consecutive frames. This means
that effects are responsible for determining how much animation timelines
have to be advanced. Typically, an effect would have to store the
presentation timestamp provided in either prePaint{Screen,Window} and
use it in the subsequent prePaint{Screen,Window} call to estimate the
amount of time passed between the next and the last frames.
Unfortunately, this is an API incompatible change. However, it shouldn't
take a lot of work to port third-party binary effects, which don't use the
AnimationEffect class, to the new API. On the bright side, we no longer
need to be concerned about the Compositor getting idle.
We do still try to determine whether the Compositor is about to idle,
primarily, because the OpenGL render backend swaps buffers on present,
but that will change with the ongoing compositing timing rework.
2020-11-20 15:44:04 +00:00
|
|
|
void SceneXrender::paint(int screenId, const QRegion &damage, const QList<Toplevel *> &toplevels,
|
2021-01-26 12:18:29 +00:00
|
|
|
RenderLoop *renderLoop)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2020-11-09 14:10:03 +00:00
|
|
|
painted_screen = screenId;
|
2011-10-29 15:09:26 +00:00
|
|
|
|
2013-06-24 07:53:11 +00:00
|
|
|
createStackingOrder(toplevels);
|
2011-10-29 15:09:26 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
int mask = 0;
|
2013-11-21 09:44:06 +00:00
|
|
|
QRegion updateRegion, validRegion;
|
2021-01-26 12:18:29 +00:00
|
|
|
renderLoop->beginFrame();
|
|
|
|
paintScreen(&mask, damage, QRegion(), &updateRegion, &validRegion, renderLoop);
|
|
|
|
renderLoop->endFrame();
|
2011-10-29 15:09:26 +00:00
|
|
|
|
2013-06-17 13:25:32 +00:00
|
|
|
m_backend->showOverlay();
|
2011-10-29 15:09:26 +00:00
|
|
|
|
2013-06-17 13:25:32 +00:00
|
|
|
m_backend->present(mask, updateRegion);
|
2008-09-18 15:27:13 +00:00
|
|
|
// do cleanup
|
2013-06-24 07:53:11 +00:00
|
|
|
clearStackingOrder();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2008-09-18 15:27:13 +00:00
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneXrender::paintGenericScreen(int mask, const ScreenPaintData &data)
|
2012-03-20 21:44:20 +00:00
|
|
|
{
|
|
|
|
screen_paint = data; // save, transformations will be done when painting windows
|
|
|
|
Scene::paintGenericScreen(mask, data);
|
|
|
|
}
|
|
|
|
|
2012-03-29 18:17:57 +00:00
|
|
|
void SceneXrender::paintDesktop(int desktop, int mask, const QRegion ®ion, ScreenPaintData &data)
|
|
|
|
{
|
|
|
|
PaintClipper::push(region);
|
|
|
|
KWin::Scene::paintDesktop(desktop, mask, region, data);
|
|
|
|
PaintClipper::pop(region);
|
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
// fill the screen background
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneXrender::paintBackground(const QRegion ®ion)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2013-02-27 14:08:09 +00:00
|
|
|
xcb_render_color_t col = { 0, 0, 0, 0xffff }; // black
|
|
|
|
const QVector<xcb_rectangle_t> &rects = Xcb::regionToRects(region);
|
2017-08-08 15:13:59 +00:00
|
|
|
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, xrenderBufferPicture(), col, rects.count(), rects.data());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2013-06-24 07:53:11 +00:00
|
|
|
Scene::Window *SceneXrender::createWindow(Toplevel *toplevel)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2013-06-17 13:25:32 +00:00
|
|
|
return new Window(toplevel, this);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2013-06-24 06:49:24 +00:00
|
|
|
Scene::EffectFrame *SceneXrender::createEffectFrame(EffectFrameImpl *frame)
|
|
|
|
{
|
|
|
|
return new SceneXrender::EffectFrame(frame);
|
|
|
|
}
|
|
|
|
|
2013-06-24 07:06:50 +00:00
|
|
|
Shadow *SceneXrender::createShadow(Toplevel *toplevel)
|
|
|
|
{
|
|
|
|
return new SceneXRenderShadow(toplevel);
|
|
|
|
}
|
|
|
|
|
2014-07-22 11:11:19 +00:00
|
|
|
Decoration::Renderer *SceneXrender::createDecorationRenderer(Decoration::DecoratedClientImpl* client)
|
|
|
|
{
|
|
|
|
return new SceneXRenderDecorationRenderer(client);
|
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
//****************************************
|
|
|
|
// SceneXrender::Window
|
|
|
|
//****************************************
|
|
|
|
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
XRenderPicture *SceneXrender::Window::s_tempPicture = nullptr;
|
2012-03-10 10:34:56 +00:00
|
|
|
QRect SceneXrender::Window::temp_visibleRect;
|
2016-06-01 10:51:10 +00:00
|
|
|
XRenderPicture *SceneXrender::Window::s_fadeAlphaPicture = nullptr;
|
2009-04-22 17:29:56 +00:00
|
|
|
|
2013-06-17 13:25:32 +00:00
|
|
|
SceneXrender::Window::Window(Toplevel* c, SceneXrender *scene)
|
2011-01-30 14:34:42 +00:00
|
|
|
: Scene::Window(c)
|
2013-06-17 13:25:32 +00:00
|
|
|
, m_scene(scene)
|
2014-08-28 18:20:41 +00:00
|
|
|
, format(XRenderUtils::findPictFormat(c->visual()))
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
|
|
|
SceneXrender::Window::~Window()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2013-02-11 20:01:41 +00:00
|
|
|
void SceneXrender::Window::cleanup()
|
|
|
|
{
|
|
|
|
delete s_tempPicture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
s_tempPicture = nullptr;
|
2016-06-01 10:51:10 +00:00
|
|
|
delete s_fadeAlphaPicture;
|
|
|
|
s_fadeAlphaPicture = nullptr;
|
2013-02-11 20:01:41 +00:00
|
|
|
}
|
|
|
|
|
2009-04-22 17:29:56 +00:00
|
|
|
// Maps window coordinates to screen coordinates
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect SceneXrender::Window::mapToScreen(int mask, const WindowPaintData &data, const QRect &rect) const
|
|
|
|
{
|
2009-04-22 17:29:56 +00:00
|
|
|
QRect r = rect;
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (mask & PAINT_WINDOW_TRANSFORMED) {
|
2009-04-22 17:29:56 +00:00
|
|
|
// Apply the window transformation
|
2012-05-28 12:45:46 +00:00
|
|
|
r.moveTo(r.x() * data.xScale() + data.xTranslation(),
|
|
|
|
r.y() * data.yScale() + data.yTranslation());
|
2012-05-28 10:00:31 +00:00
|
|
|
r.setWidth(r.width() * data.xScale());
|
|
|
|
r.setHeight(r.height() * data.yScale());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-04-22 17:29:56 +00:00
|
|
|
|
|
|
|
// Move the rectangle to the screen position
|
2011-01-30 14:34:42 +00:00
|
|
|
r.translate(x(), y());
|
2009-04-22 17:29:56 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (mask & PAINT_SCREEN_TRANSFORMED) {
|
2009-04-22 17:29:56 +00:00
|
|
|
// Apply the screen transformation
|
2012-05-28 12:45:46 +00:00
|
|
|
r.moveTo(r.x() * screen_paint.xScale() + screen_paint.xTranslation(),
|
|
|
|
r.y() * screen_paint.yScale() + screen_paint.yTranslation());
|
2012-05-28 10:00:31 +00:00
|
|
|
r.setWidth(r.width() * screen_paint.xScale());
|
|
|
|
r.setHeight(r.height() * screen_paint.yScale());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-04-22 17:29:56 +00:00
|
|
|
|
|
|
|
return r;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-04-22 17:29:56 +00:00
|
|
|
|
|
|
|
// Maps window coordinates to screen coordinates
|
2011-01-30 14:34:42 +00:00
|
|
|
QPoint SceneXrender::Window::mapToScreen(int mask, const WindowPaintData &data, const QPoint &point) const
|
|
|
|
{
|
2009-04-22 17:29:56 +00:00
|
|
|
QPoint pt = point;
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (mask & PAINT_WINDOW_TRANSFORMED) {
|
2009-04-22 17:29:56 +00:00
|
|
|
// Apply the window transformation
|
2012-05-28 12:45:46 +00:00
|
|
|
pt.rx() = pt.x() * data.xScale() + data.xTranslation();
|
|
|
|
pt.ry() = pt.y() * data.yScale() + data.yTranslation();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-04-22 17:29:56 +00:00
|
|
|
|
|
|
|
// Move the point to the screen position
|
|
|
|
pt += QPoint(x(), y());
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (mask & PAINT_SCREEN_TRANSFORMED) {
|
2009-04-22 17:29:56 +00:00
|
|
|
// Apply the screen transformation
|
2012-05-28 12:45:46 +00:00
|
|
|
pt.rx() = pt.x() * screen_paint.xScale() + screen_paint.xTranslation();
|
|
|
|
pt.ry() = pt.y() * screen_paint.yScale() + screen_paint.yTranslation();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-04-22 17:29:56 +00:00
|
|
|
|
|
|
|
return pt;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-04-22 17:29:56 +00:00
|
|
|
|
2019-12-12 12:39:03 +00:00
|
|
|
QRect SceneXrender::Window::bufferToWindowRect(const QRect &rect) const
|
|
|
|
{
|
|
|
|
return rect.translated(bufferOffset());
|
|
|
|
}
|
|
|
|
|
|
|
|
QRegion SceneXrender::Window::bufferToWindowRegion(const QRegion ®ion) const
|
|
|
|
{
|
|
|
|
return region.translated(bufferOffset());
|
|
|
|
}
|
|
|
|
|
2011-07-24 21:04:06 +00:00
|
|
|
void SceneXrender::Window::prepareTempPixmap()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2013-02-11 20:01:41 +00:00
|
|
|
const QSize oldSize = temp_visibleRect.size();
|
2012-03-10 10:34:56 +00:00
|
|
|
temp_visibleRect = toplevel->visibleRect().translated(-toplevel->pos());
|
2013-02-11 20:01:41 +00:00
|
|
|
if (s_tempPicture && (oldSize.width() < temp_visibleRect.width() || oldSize.height() < temp_visibleRect.height())) {
|
|
|
|
delete s_tempPicture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
s_tempPicture = nullptr;
|
2012-03-04 08:52:32 +00:00
|
|
|
scene_setXRenderOffscreenTarget(0); // invalidate, better crash than cause weird results for developers
|
|
|
|
}
|
2013-02-11 20:01:41 +00:00
|
|
|
if (!s_tempPicture) {
|
|
|
|
xcb_pixmap_t pix = xcb_generate_id(connection());
|
|
|
|
xcb_create_pixmap(connection(), 32, pix, rootWindow(), temp_visibleRect.width(), temp_visibleRect.height());
|
|
|
|
s_tempPicture = new XRenderPicture(pix, 32);
|
|
|
|
xcb_free_pixmap(connection(), pix);
|
2011-05-12 16:52:38 +00:00
|
|
|
}
|
2013-02-11 20:01:41 +00:00
|
|
|
const xcb_render_color_t transparent = {0, 0, 0, 0};
|
|
|
|
const xcb_rectangle_t rect = {0, 0, uint16_t(temp_visibleRect.width()), uint16_t(temp_visibleRect.height())};
|
|
|
|
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, *s_tempPicture, transparent, 1, &rect);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2009-04-22 17:29:56 +00:00
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
// paint the window
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneXrender::Window::performPaint(int mask, const QRegion &_region, const WindowPaintData &data)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2020-03-13 16:41:56 +00:00
|
|
|
QRegion region = _region;
|
2011-01-30 14:34:42 +00:00
|
|
|
setTransformedShape(QRegion()); // maybe nothing will be painted
|
2007-04-29 17:35:43 +00:00
|
|
|
// check if there is something to paint
|
2012-07-12 15:20:17 +00:00
|
|
|
bool opaque = isOpaque() && qFuzzyCompare(data.opacity(), 1.0);
|
2008-10-04 17:36:26 +00:00
|
|
|
/* HACK: It seems this causes painting glitches, disable temporarily
|
2011-01-30 14:34:42 +00:00
|
|
|
if (( mask & PAINT_WINDOW_OPAQUE ) ^ ( mask & PAINT_WINDOW_TRANSLUCENT ))
|
2008-09-27 06:23:33 +00:00
|
|
|
{ // We are only painting either opaque OR translucent windows, not both
|
2011-01-30 14:34:42 +00:00
|
|
|
if ( mask & PAINT_WINDOW_OPAQUE && !opaque )
|
2008-09-27 06:23:33 +00:00
|
|
|
return; // Only painting opaque and window is translucent
|
2011-01-30 14:34:42 +00:00
|
|
|
if ( mask & PAINT_WINDOW_TRANSLUCENT && opaque )
|
2008-09-27 06:23:33 +00:00
|
|
|
return; // Only painting translucent and window is opaque
|
2008-10-04 17:36:26 +00:00
|
|
|
}*/
|
2011-04-28 15:34:50 +00:00
|
|
|
// Intersect the clip region with the rectangle the window occupies on the screen
|
|
|
|
if (!(mask & (PAINT_WINDOW_TRANSFORMED | PAINT_SCREEN_TRANSFORMED)))
|
|
|
|
region &= toplevel->visibleRect();
|
|
|
|
|
|
|
|
if (region.isEmpty())
|
|
|
|
return;
|
2013-05-10 10:07:56 +00:00
|
|
|
XRenderWindowPixmap *pixmap = windowPixmap<XRenderWindowPixmap>();
|
|
|
|
if (!pixmap || !pixmap->isValid()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
xcb_render_picture_t pic = pixmap->picture();
|
2013-02-27 14:08:09 +00:00
|
|
|
if (pic == XCB_RENDER_PICTURE_NONE) // The render format can be null for GL and/or Xv visuals
|
2007-04-29 17:35:43 +00:00
|
|
|
return;
|
2013-05-10 10:07:56 +00:00
|
|
|
toplevel->resetDamage();
|
2007-04-29 17:35:43 +00:00
|
|
|
// set picture filter
|
2012-02-20 09:25:13 +00:00
|
|
|
if (options->isXrenderSmoothScale()) { // only when forced, it's slow
|
2011-01-30 14:34:42 +00:00
|
|
|
if (mask & PAINT_WINDOW_TRANSFORMED)
|
2007-04-29 17:35:43 +00:00
|
|
|
filter = ImageFilterGood;
|
2011-01-30 14:34:42 +00:00
|
|
|
else if (mask & PAINT_SCREEN_TRANSFORMED)
|
2007-04-29 17:35:43 +00:00
|
|
|
filter = ImageFilterGood;
|
|
|
|
else
|
|
|
|
filter = ImageFilterFast;
|
2011-01-30 14:34:42 +00:00
|
|
|
} else
|
2007-04-29 17:35:43 +00:00
|
|
|
filter = ImageFilterFast;
|
|
|
|
// do required transformations
|
2009-04-22 17:29:56 +00:00
|
|
|
const QRect wr = mapToScreen(mask, data, QRect(0, 0, width(), height()));
|
2019-12-12 12:39:03 +00:00
|
|
|
QRect cr = QRect(toplevel->clientPos(), toplevel->clientSize()); // Content rect (in the buffer)
|
2012-05-28 10:00:31 +00:00
|
|
|
qreal xscale = 1;
|
|
|
|
qreal yscale = 1;
|
2009-04-22 17:29:56 +00:00
|
|
|
bool scaled = false;
|
2009-05-04 22:35:33 +00:00
|
|
|
|
2019-09-24 08:48:08 +00:00
|
|
|
X11Client *client = dynamic_cast<X11Client *>(toplevel);
|
2011-01-30 14:34:42 +00:00
|
|
|
Deleted *deleted = dynamic_cast<Deleted*>(toplevel);
|
2020-01-28 18:45:58 +00:00
|
|
|
const QRect decorationRect = toplevel->rect();
|
2020-11-04 07:22:32 +00:00
|
|
|
if ((client && client->isDecorated()) || (deleted && deleted->wasDecorated())) {
|
2012-12-06 14:37:18 +00:00
|
|
|
// decorated client
|
2011-09-26 13:01:05 +00:00
|
|
|
transformed_shape = decorationRect;
|
2012-12-06 14:37:18 +00:00
|
|
|
if (toplevel->shape()) {
|
|
|
|
// "xeyes" + decoration
|
2019-12-12 12:39:03 +00:00
|
|
|
transformed_shape -= bufferToWindowRect(cr);
|
|
|
|
transformed_shape += bufferToWindowRegion(bufferShape());
|
2012-12-06 14:37:18 +00:00
|
|
|
}
|
|
|
|
} else {
|
2019-12-12 12:39:03 +00:00
|
|
|
transformed_shape = bufferToWindowRegion(bufferShape());
|
2012-12-06 14:37:18 +00:00
|
|
|
}
|
2019-09-29 11:15:18 +00:00
|
|
|
if (toplevel->shadow()) {
|
2011-07-02 19:39:01 +00:00
|
|
|
transformed_shape |= toplevel->shadow()->shadowRegion();
|
2019-09-29 11:15:18 +00:00
|
|
|
}
|
2011-07-02 19:39:01 +00:00
|
|
|
|
2013-02-27 14:08:09 +00:00
|
|
|
xcb_render_transform_t xform = {
|
|
|
|
DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0),
|
|
|
|
DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0),
|
|
|
|
DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1)
|
2011-01-30 14:34:42 +00:00
|
|
|
};
|
2014-09-27 18:30:49 +00:00
|
|
|
static const xcb_render_transform_t identity = {
|
2013-02-27 14:08:09 +00:00
|
|
|
DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0),
|
|
|
|
DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0),
|
|
|
|
DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1)
|
2011-01-30 14:34:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
if (mask & PAINT_WINDOW_TRANSFORMED) {
|
2012-05-28 10:00:31 +00:00
|
|
|
xscale = data.xScale();
|
|
|
|
yscale = data.yScale();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (mask & PAINT_SCREEN_TRANSFORMED) {
|
2012-05-28 10:00:31 +00:00
|
|
|
xscale *= screen_paint.xScale();
|
|
|
|
yscale *= screen_paint.yScale();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
|
|
|
if (!qFuzzyCompare(xscale, 1.0) || !qFuzzyCompare(yscale, 1.0)) {
|
2009-04-22 17:29:56 +00:00
|
|
|
scaled = true;
|
2013-02-27 14:08:09 +00:00
|
|
|
xform.matrix11 = DOUBLE_TO_FIXED(1.0 / xscale);
|
|
|
|
xform.matrix22 = DOUBLE_TO_FIXED(1.0 / yscale);
|
2009-04-22 17:29:56 +00:00
|
|
|
|
2011-04-25 14:47:10 +00:00
|
|
|
// transform the shape for clipping in paintTransformedScreen()
|
2019-07-09 20:08:47 +00:00
|
|
|
QVector<QRect> rects;
|
|
|
|
rects.reserve(transformed_shape.rectCount());
|
|
|
|
for (const QRect &rect : transformed_shape) {
|
|
|
|
const QRect transformedRect(
|
|
|
|
qRound(rect.x() * xscale),
|
|
|
|
qRound(rect.y() * yscale),
|
|
|
|
qRound(rect.width() * xscale),
|
|
|
|
qRound(rect.height() * yscale)
|
|
|
|
);
|
|
|
|
rects.append(transformedRect);
|
2011-04-25 14:47:10 +00:00
|
|
|
}
|
|
|
|
transformed_shape.setRects(rects.constData(), rects.count());
|
|
|
|
}
|
|
|
|
|
|
|
|
transformed_shape.translate(mapToScreen(mask, data, QPoint(0, 0)));
|
|
|
|
PaintClipper pcreg(region); // clip by the region to paint
|
|
|
|
PaintClipper pc(transformed_shape); // clip by window's shape
|
|
|
|
|
2012-02-07 09:41:40 +00:00
|
|
|
const bool wantShadow = m_shadow && !m_shadow->shadowRegion().isEmpty();
|
2011-07-24 21:04:06 +00:00
|
|
|
|
2011-04-25 14:47:10 +00:00
|
|
|
// In order to obtain a pixel perfect rescaling
|
|
|
|
// we need to blit the window content togheter with
|
|
|
|
// decorations in a temporary pixmap and scale
|
|
|
|
// the temporary pixmap at the end.
|
|
|
|
// We should do this only if there is scaling and
|
|
|
|
// the window has border
|
|
|
|
// This solves a number of glitches and on top of this
|
|
|
|
// it optimizes painting quite a bit
|
2013-07-03 19:30:51 +00:00
|
|
|
const bool blitInTempPixmap = xRenderOffscreen() || (data.crossFadeProgress() < 1.0 && !opaque) ||
|
2020-11-04 07:22:32 +00:00
|
|
|
(scaled && (wantShadow || (client && client->isDecorated()) || (deleted && deleted->wasDecorated())));
|
2011-04-25 14:47:10 +00:00
|
|
|
|
2017-08-08 15:13:59 +00:00
|
|
|
xcb_render_picture_t renderTarget = m_scene->xrenderBufferPicture();
|
2011-07-24 21:04:06 +00:00
|
|
|
if (blitInTempPixmap) {
|
2012-03-10 10:34:56 +00:00
|
|
|
if (scene_xRenderOffscreenTarget()) {
|
|
|
|
temp_visibleRect = toplevel->visibleRect().translated(-toplevel->pos());
|
2012-03-04 08:52:32 +00:00
|
|
|
renderTarget = *scene_xRenderOffscreenTarget();
|
2012-03-10 10:34:56 +00:00
|
|
|
} else {
|
2012-03-04 08:52:32 +00:00
|
|
|
prepareTempPixmap();
|
2013-02-11 20:01:41 +00:00
|
|
|
renderTarget = *s_tempPicture;
|
2012-03-04 08:52:32 +00:00
|
|
|
}
|
2011-07-24 21:04:06 +00:00
|
|
|
} else {
|
2013-02-27 14:08:09 +00:00
|
|
|
xcb_render_set_picture_transform(connection(), pic, xform);
|
2011-04-25 14:47:10 +00:00
|
|
|
if (filter == ImageFilterGood) {
|
2013-02-27 14:08:09 +00:00
|
|
|
setPictureFilter(pic, KWin::Scene::ImageFilterGood);
|
2011-04-25 14:47:10 +00:00
|
|
|
}
|
2009-04-22 17:29:56 +00:00
|
|
|
|
2011-07-24 21:04:06 +00:00
|
|
|
//BEGIN OF STUPID RADEON HACK
|
2009-12-16 18:51:36 +00:00
|
|
|
// This is needed to avoid hitting a fallback in the radeon driver.
|
|
|
|
// The Render specification states that sampling pixels outside the
|
|
|
|
// source picture results in alpha=0 pixels. This can be achieved by
|
|
|
|
// setting the border color to transparent black, but since the border
|
|
|
|
// color has the same format as the texture, it only works when the
|
|
|
|
// texture has an alpha channel. So the driver falls back to software
|
|
|
|
// when the repeat mode is RepeatNone, the picture has a non-identity
|
|
|
|
// transformation matrix, and doesn't have an alpha channel.
|
|
|
|
// Since we only scale the picture, we can work around this by setting
|
|
|
|
// the repeat mode to RepeatPad.
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!window()->hasAlpha()) {
|
2013-02-27 14:08:09 +00:00
|
|
|
const uint32_t values[] = {XCB_RENDER_REPEAT_PAD};
|
|
|
|
xcb_render_change_picture(connection(), pic, XCB_RENDER_CP_REPEAT, values);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2011-07-24 21:04:06 +00:00
|
|
|
//END OF STUPID RADEON HACK
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2011-07-24 21:04:06 +00:00
|
|
|
#define MAP_RECT_TO_TARGET(_RECT_) \
|
2012-03-10 10:34:56 +00:00
|
|
|
if (blitInTempPixmap) _RECT_.translate(-temp_visibleRect.topLeft()); else _RECT_ = mapToScreen(mask, data, _RECT_)
|
2011-07-24 21:04:06 +00:00
|
|
|
|
|
|
|
//BEGIN deco preparations
|
|
|
|
bool noBorder = true;
|
2013-02-18 08:07:42 +00:00
|
|
|
xcb_render_picture_t left = XCB_RENDER_PICTURE_NONE;
|
|
|
|
xcb_render_picture_t top = XCB_RENDER_PICTURE_NONE;
|
|
|
|
xcb_render_picture_t right = XCB_RENDER_PICTURE_NONE;
|
|
|
|
xcb_render_picture_t bottom = XCB_RENDER_PICTURE_NONE;
|
2011-07-24 21:04:06 +00:00
|
|
|
QRect dtr, dlr, drr, dbr;
|
2014-07-23 07:20:28 +00:00
|
|
|
const SceneXRenderDecorationRenderer *renderer = nullptr;
|
2020-11-04 07:22:32 +00:00
|
|
|
if (client && client->isDecorated()) {
|
|
|
|
SceneXRenderDecorationRenderer *r = static_cast<SceneXRenderDecorationRenderer*>(client->decoratedClient()->renderer());
|
|
|
|
if (r) {
|
|
|
|
r->render();
|
|
|
|
renderer = r;
|
2011-07-24 21:04:06 +00:00
|
|
|
}
|
2020-11-04 07:22:32 +00:00
|
|
|
noBorder = false;
|
|
|
|
client->layoutDecorationRects(dlr, dtr, drr, dbr);
|
|
|
|
} else if (deleted && deleted->wasDecorated()) {
|
2014-07-23 07:20:28 +00:00
|
|
|
renderer = static_cast<const SceneXRenderDecorationRenderer*>(deleted->decorationRenderer());
|
2020-11-04 07:22:32 +00:00
|
|
|
noBorder = false;
|
2014-07-25 10:55:28 +00:00
|
|
|
deleted->layoutDecorationRects(dlr, dtr, drr, dbr);
|
2014-07-23 07:20:28 +00:00
|
|
|
}
|
2014-07-22 11:11:19 +00:00
|
|
|
if (renderer) {
|
|
|
|
left = renderer->picture(SceneXRenderDecorationRenderer::DecorationPart::Left);
|
|
|
|
top = renderer->picture(SceneXRenderDecorationRenderer::DecorationPart::Top);
|
|
|
|
right = renderer->picture(SceneXRenderDecorationRenderer::DecorationPart::Right);
|
|
|
|
bottom = renderer->picture(SceneXRenderDecorationRenderer::DecorationPart::Bottom);
|
|
|
|
}
|
|
|
|
if (!noBorder) {
|
|
|
|
MAP_RECT_TO_TARGET(dtr);
|
|
|
|
MAP_RECT_TO_TARGET(dlr);
|
|
|
|
MAP_RECT_TO_TARGET(drr);
|
|
|
|
MAP_RECT_TO_TARGET(dbr);
|
2011-07-24 21:04:06 +00:00
|
|
|
}
|
|
|
|
//END deco preparations
|
|
|
|
|
|
|
|
//BEGIN shadow preparations
|
2011-07-02 19:39:01 +00:00
|
|
|
QRect stlr, str, strr, srr, sbrr, sbr, sblr, slr;
|
|
|
|
SceneXRenderShadow* m_xrenderShadow = static_cast<SceneXRenderShadow*>(m_shadow);
|
2011-07-24 21:04:06 +00:00
|
|
|
|
2011-07-02 19:39:01 +00:00
|
|
|
if (wantShadow) {
|
2011-04-28 15:22:17 +00:00
|
|
|
m_xrenderShadow->layoutShadowRects(str, strr, srr, sbrr, sbr, sblr, slr, stlr);
|
2011-07-24 21:04:06 +00:00
|
|
|
MAP_RECT_TO_TARGET(stlr);
|
|
|
|
MAP_RECT_TO_TARGET(str);
|
|
|
|
MAP_RECT_TO_TARGET(strr);
|
|
|
|
MAP_RECT_TO_TARGET(srr);
|
|
|
|
MAP_RECT_TO_TARGET(sbrr);
|
|
|
|
MAP_RECT_TO_TARGET(sbr);
|
|
|
|
MAP_RECT_TO_TARGET(sblr);
|
|
|
|
MAP_RECT_TO_TARGET(slr);
|
|
|
|
}
|
|
|
|
//BEGIN end preparations
|
|
|
|
|
|
|
|
//BEGIN client preparations
|
|
|
|
QRect dr = cr;
|
|
|
|
if (blitInTempPixmap) {
|
2012-03-10 10:34:56 +00:00
|
|
|
dr.translate(-temp_visibleRect.topLeft());
|
2011-07-24 21:04:06 +00:00
|
|
|
} else {
|
2019-12-12 12:39:03 +00:00
|
|
|
dr = mapToScreen(mask, data, bufferToWindowRect(dr)); // Destination rect
|
2011-07-24 21:04:06 +00:00
|
|
|
if (scaled) {
|
|
|
|
cr.moveLeft(cr.x() * xscale);
|
|
|
|
cr.moveTop(cr.y() * yscale);
|
2011-04-28 15:22:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-27 14:08:09 +00:00
|
|
|
const int clientRenderOp = (opaque || blitInTempPixmap) ? XCB_RENDER_PICT_OP_SRC : XCB_RENDER_PICT_OP_OVER;
|
2011-07-24 21:04:06 +00:00
|
|
|
//END client preparations
|
|
|
|
|
|
|
|
#undef MAP_RECT_TO_TARGET
|
|
|
|
|
|
|
|
for (PaintClipper::Iterator iterator; !iterator.isDone(); iterator.next()) {
|
2011-07-02 19:39:01 +00:00
|
|
|
|
|
|
|
#define RENDER_SHADOW_TILE(_TILE_, _RECT_) \
|
2013-02-27 11:56:38 +00:00
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, m_xrenderShadow->picture(SceneXRenderShadow::ShadowElement##_TILE_), \
|
2011-07-24 21:04:06 +00:00
|
|
|
shadowAlpha, renderTarget, 0, 0, 0, 0, _RECT_.x(), _RECT_.y(), _RECT_.width(), _RECT_.height())
|
2011-07-02 19:39:01 +00:00
|
|
|
|
|
|
|
//shadow
|
|
|
|
if (wantShadow) {
|
2013-02-27 11:10:22 +00:00
|
|
|
xcb_render_picture_t shadowAlpha = XCB_RENDER_PICTURE_NONE;
|
|
|
|
if (!opaque) {
|
|
|
|
shadowAlpha = xRenderBlendPicture(data.opacity());
|
|
|
|
}
|
2011-07-24 21:04:06 +00:00
|
|
|
RENDER_SHADOW_TILE(TopLeft, stlr);
|
|
|
|
RENDER_SHADOW_TILE(Top, str);
|
|
|
|
RENDER_SHADOW_TILE(TopRight, strr);
|
|
|
|
RENDER_SHADOW_TILE(Left, slr);
|
|
|
|
RENDER_SHADOW_TILE(Right, srr);
|
|
|
|
RENDER_SHADOW_TILE(BottomLeft, sblr);
|
|
|
|
RENDER_SHADOW_TILE(Bottom, sbr);
|
|
|
|
RENDER_SHADOW_TILE(BottomRight, sbrr);
|
2011-07-02 19:39:01 +00:00
|
|
|
}
|
|
|
|
#undef RENDER_SHADOW_TILE
|
|
|
|
|
2012-01-10 17:56:14 +00:00
|
|
|
// Paint the window contents
|
2012-03-07 21:02:26 +00:00
|
|
|
if (!(client && client->isShade())) {
|
2013-02-27 11:10:22 +00:00
|
|
|
xcb_render_picture_t clientAlpha = XCB_RENDER_PICTURE_NONE;
|
|
|
|
if (!opaque) {
|
|
|
|
clientAlpha = xRenderBlendPicture(data.opacity());
|
|
|
|
}
|
2013-07-03 19:30:51 +00:00
|
|
|
xcb_render_composite(connection(), clientRenderOp, pic, clientAlpha, renderTarget,
|
|
|
|
cr.x(), cr.y(), 0, 0, dr.x(), dr.y(), dr.width(), dr.height());
|
|
|
|
if (data.crossFadeProgress() < 1.0 && data.crossFadeProgress() > 0.0) {
|
|
|
|
XRenderWindowPixmap *previous = previousWindowPixmap<XRenderWindowPixmap>();
|
|
|
|
if (previous && previous != pixmap) {
|
|
|
|
static xcb_render_color_t cFadeColor = {0, 0, 0, 0};
|
|
|
|
cFadeColor.alpha = uint16_t((1.0 - data.crossFadeProgress()) * 0xffff);
|
2016-06-01 10:51:10 +00:00
|
|
|
if (!s_fadeAlphaPicture) {
|
|
|
|
s_fadeAlphaPicture = new XRenderPicture(xRenderFill(cFadeColor));
|
2013-07-03 19:30:51 +00:00
|
|
|
} else {
|
|
|
|
xcb_rectangle_t rect = {0, 0, 1, 1};
|
2016-06-01 10:51:10 +00:00
|
|
|
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, *s_fadeAlphaPicture, cFadeColor , 1, &rect);
|
2013-07-03 19:30:51 +00:00
|
|
|
}
|
|
|
|
if (previous->size() != pixmap->size()) {
|
|
|
|
xcb_render_transform_t xform2 = {
|
|
|
|
DOUBLE_TO_FIXED(FIXED_TO_DOUBLE(xform.matrix11) * previous->size().width() / pixmap->size().width()), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0),
|
|
|
|
DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(FIXED_TO_DOUBLE(xform.matrix22) * previous->size().height() / pixmap->size().height()), DOUBLE_TO_FIXED(0),
|
|
|
|
DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1)
|
|
|
|
};
|
|
|
|
xcb_render_set_picture_transform(connection(), previous->picture(), xform2);
|
|
|
|
}
|
|
|
|
|
|
|
|
xcb_render_composite(connection(), opaque ? XCB_RENDER_PICT_OP_OVER : XCB_RENDER_PICT_OP_ATOP,
|
2016-06-01 10:51:10 +00:00
|
|
|
previous->picture(), *s_fadeAlphaPicture, renderTarget,
|
2013-07-03 19:30:51 +00:00
|
|
|
cr.x(), cr.y(), 0, 0, dr.x(), dr.y(), dr.width(), dr.height());
|
|
|
|
|
|
|
|
if (previous->size() != pixmap->size()) {
|
|
|
|
xcb_render_set_picture_transform(connection(), previous->picture(), identity);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-11-20 00:12:14 +00:00
|
|
|
if (!opaque)
|
|
|
|
transformed_shape = QRegion();
|
|
|
|
}
|
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (client || deleted) {
|
|
|
|
if (!noBorder) {
|
2014-08-04 19:12:34 +00:00
|
|
|
xcb_render_picture_t decorationAlpha = xRenderBlendPicture(data.opacity());
|
2014-04-04 13:23:23 +00:00
|
|
|
auto renderDeco = [decorationAlpha, renderTarget](xcb_render_picture_t deco, const QRect &rect) {
|
|
|
|
if (deco == XCB_RENDER_PICTURE_NONE) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, deco, decorationAlpha, renderTarget,
|
|
|
|
0, 0, 0, 0, rect.x(), rect.y(), rect.width(), rect.height());
|
|
|
|
};
|
|
|
|
renderDeco(top, dtr);
|
|
|
|
renderDeco(left, dlr);
|
|
|
|
renderDeco(right, drr);
|
|
|
|
renderDeco(bottom, dbr);
|
2009-04-22 17:29:56 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2011-07-24 21:04:06 +00:00
|
|
|
|
2012-12-22 22:40:20 +00:00
|
|
|
if (data.brightness() != 1.0) {
|
2008-05-08 19:08:05 +00:00
|
|
|
// fake brightness change by overlaying black
|
2012-12-22 22:40:20 +00:00
|
|
|
const float alpha = (1 - data.brightness()) * data.opacity();
|
2013-02-12 09:57:27 +00:00
|
|
|
xcb_rectangle_t rect;
|
2011-04-25 14:47:10 +00:00
|
|
|
if (blitInTempPixmap) {
|
2013-02-12 09:57:27 +00:00
|
|
|
rect.x = -temp_visibleRect.left();
|
|
|
|
rect.y = -temp_visibleRect.top();
|
|
|
|
rect.width = width();
|
|
|
|
rect.height = height();
|
2011-04-25 14:47:10 +00:00
|
|
|
} else {
|
2013-02-12 09:57:27 +00:00
|
|
|
rect.x = wr.x();
|
|
|
|
rect.y = wr.y();
|
|
|
|
rect.width = wr.width();
|
|
|
|
rect.height = wr.height();
|
2011-04-25 14:47:10 +00:00
|
|
|
}
|
2013-02-12 09:57:27 +00:00
|
|
|
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_OVER, renderTarget,
|
|
|
|
preMultiply(data.brightness() < 1.0 ? QColor(0,0,0,255*alpha) : QColor(255,255,255,-alpha*255)),
|
|
|
|
1, &rect);
|
2011-04-25 14:47:10 +00:00
|
|
|
}
|
|
|
|
if (blitInTempPixmap) {
|
2012-03-10 10:34:56 +00:00
|
|
|
const QRect r = mapToScreen(mask, data, temp_visibleRect);
|
2013-02-27 14:08:09 +00:00
|
|
|
xcb_render_set_picture_transform(connection(), *s_tempPicture, xform);
|
2013-07-07 18:09:50 +00:00
|
|
|
setPictureFilter(*s_tempPicture, filter);
|
2013-02-27 14:08:09 +00:00
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *s_tempPicture,
|
2017-08-08 15:13:59 +00:00
|
|
|
XCB_RENDER_PICTURE_NONE, m_scene->xrenderBufferPicture(),
|
2013-02-27 14:08:09 +00:00
|
|
|
0, 0, 0, 0, r.x(), r.y(), r.width(), r.height());
|
|
|
|
xcb_render_set_picture_transform(connection(), *s_tempPicture, identity);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2011-04-25 14:47:10 +00:00
|
|
|
if (scaled && !blitInTempPixmap) {
|
2013-02-27 14:08:09 +00:00
|
|
|
xcb_render_set_picture_transform(connection(), pic, identity);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (filter == ImageFilterGood)
|
2013-02-27 14:08:09 +00:00
|
|
|
setPictureFilter(pic, KWin::Scene::ImageFilterFast);
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!window()->hasAlpha()) {
|
2013-02-27 14:08:09 +00:00
|
|
|
const uint32_t values[] = {XCB_RENDER_REPEAT_NONE};
|
|
|
|
xcb_render_change_picture(connection(), pic, XCB_RENDER_CP_REPEAT, values);
|
2007-04-29 17:35:43 +00:00
|
|
|
}
|
|
|
|
}
|
2012-03-04 08:52:32 +00:00
|
|
|
if (xRenderOffscreen())
|
2013-02-11 20:01:41 +00:00
|
|
|
scene_setXRenderOffscreenTarget(*s_tempPicture);
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2007-04-29 17:35:43 +00:00
|
|
|
|
2013-02-27 14:08:09 +00:00
|
|
|
void SceneXrender::Window::setPictureFilter(xcb_render_picture_t pic, Scene::ImageFilterType filter)
|
|
|
|
{
|
|
|
|
QByteArray filterName;
|
|
|
|
switch (filter) {
|
|
|
|
case KWin::Scene::ImageFilterFast:
|
|
|
|
filterName = QByteArray("fast");
|
|
|
|
break;
|
|
|
|
case KWin::Scene::ImageFilterGood:
|
|
|
|
filterName = QByteArray("good");
|
|
|
|
break;
|
|
|
|
}
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
xcb_render_set_picture_filter(connection(), pic, filterName.length(), filterName.constData(), 0, nullptr);
|
2013-02-27 14:08:09 +00:00
|
|
|
}
|
|
|
|
|
2013-05-10 10:07:56 +00:00
|
|
|
WindowPixmap* SceneXrender::Window::createWindowPixmap()
|
|
|
|
{
|
|
|
|
return new XRenderWindowPixmap(this, format);
|
|
|
|
}
|
|
|
|
|
2011-11-26 15:15:46 +00:00
|
|
|
void SceneXrender::screenGeometryChanged(const QSize &size)
|
|
|
|
{
|
|
|
|
Scene::screenGeometryChanged(size);
|
2013-06-17 13:25:32 +00:00
|
|
|
m_backend->screenGeometryChanged(size);
|
2011-11-26 15:15:46 +00:00
|
|
|
}
|
|
|
|
|
2020-12-05 15:54:19 +00:00
|
|
|
xcb_render_picture_t SceneXrender::xrenderBufferPicture() const
|
|
|
|
{
|
|
|
|
return m_backend->buffer();
|
|
|
|
}
|
|
|
|
|
|
|
|
OverlayWindow *SceneXrender::overlayWindow() const
|
|
|
|
{
|
|
|
|
return m_backend->overlayWindow();
|
|
|
|
}
|
|
|
|
|
2013-05-10 10:07:56 +00:00
|
|
|
//****************************************
|
|
|
|
// XRenderWindowPixmap
|
|
|
|
//****************************************
|
|
|
|
|
|
|
|
XRenderWindowPixmap::XRenderWindowPixmap(Scene::Window *window, xcb_render_pictformat_t format)
|
|
|
|
: WindowPixmap(window)
|
|
|
|
, m_picture(XCB_RENDER_PICTURE_NONE)
|
|
|
|
, m_format(format)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
XRenderWindowPixmap::~XRenderWindowPixmap()
|
|
|
|
{
|
|
|
|
if (m_picture != XCB_RENDER_PICTURE_NONE) {
|
|
|
|
xcb_render_free_picture(connection(), m_picture);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void XRenderWindowPixmap::create()
|
|
|
|
{
|
|
|
|
if (isValid()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
KWin::WindowPixmap::create();
|
|
|
|
if (!isValid()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_picture = xcb_generate_id(connection());
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
xcb_render_create_picture(connection(), m_picture, pixmap(), m_format, 0, nullptr);
|
2013-05-10 10:07:56 +00:00
|
|
|
}
|
|
|
|
|
2010-07-18 16:32:37 +00:00
|
|
|
//****************************************
|
|
|
|
// SceneXrender::EffectFrame
|
|
|
|
//****************************************
|
|
|
|
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
XRenderPicture *SceneXrender::EffectFrame::s_effectFrameCircle = nullptr;
|
2013-02-06 07:03:14 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
SceneXrender::EffectFrame::EffectFrame(EffectFrameImpl* frame)
|
|
|
|
: Scene::EffectFrame(frame)
|
|
|
|
{
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_picture = nullptr;
|
|
|
|
m_textPicture = nullptr;
|
|
|
|
m_iconPicture = nullptr;
|
|
|
|
m_selectionPicture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
SceneXrender::EffectFrame::~EffectFrame()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_picture;
|
|
|
|
delete m_textPicture;
|
2010-07-20 21:11:03 +00:00
|
|
|
delete m_iconPicture;
|
2010-07-26 20:00:04 +00:00
|
|
|
delete m_selectionPicture;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2013-02-06 07:03:14 +00:00
|
|
|
void SceneXrender::EffectFrame::cleanup()
|
|
|
|
{
|
|
|
|
delete s_effectFrameCircle;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
s_effectFrameCircle = nullptr;
|
2013-02-06 07:03:14 +00:00
|
|
|
}
|
|
|
|
|
2010-07-18 16:32:37 +00:00
|
|
|
void SceneXrender::EffectFrame::free()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_picture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_picture = nullptr;
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_textPicture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textPicture = nullptr;
|
2010-07-20 21:11:03 +00:00
|
|
|
delete m_iconPicture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_iconPicture = nullptr;
|
2010-07-26 20:00:04 +00:00
|
|
|
delete m_selectionPicture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_selectionPicture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-20 21:11:03 +00:00
|
|
|
|
|
|
|
void SceneXrender::EffectFrame::freeIconFrame()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-20 21:11:03 +00:00
|
|
|
delete m_iconPicture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_iconPicture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
void SceneXrender::EffectFrame::freeTextFrame()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_textPicture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textPicture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2010-07-26 20:00:04 +00:00
|
|
|
void SceneXrender::EffectFrame::freeSelection()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-26 20:00:04 +00:00
|
|
|
delete m_selectionPicture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_selectionPicture = nullptr;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-26 20:00:04 +00:00
|
|
|
|
2010-08-07 14:08:34 +00:00
|
|
|
void SceneXrender::EffectFrame::crossFadeIcon()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-08-07 14:08:34 +00:00
|
|
|
// TODO: implement me
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-08-07 14:08:34 +00:00
|
|
|
|
|
|
|
void SceneXrender::EffectFrame::crossFadeText()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-08-07 14:08:34 +00:00
|
|
|
// TODO: implement me
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-08-07 14:08:34 +00:00
|
|
|
|
2020-03-13 16:41:56 +00:00
|
|
|
void SceneXrender::EffectFrame::render(const QRegion ®ion, double opacity, double frameOpacity)
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2011-12-31 14:04:14 +00:00
|
|
|
Q_UNUSED(region)
|
2011-01-30 14:34:42 +00:00
|
|
|
if (m_effectFrame->geometry().isEmpty()) {
|
2010-07-18 16:32:37 +00:00
|
|
|
return; // Nothing to display
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
// Render the actual frame
|
2013-02-06 07:03:14 +00:00
|
|
|
if (m_effectFrame->style() == EffectFrameUnstyled) {
|
|
|
|
renderUnstyled(effects->xrenderBufferPicture(), m_effectFrame->geometry(), opacity * frameOpacity);
|
|
|
|
} else if (m_effectFrame->style() == EffectFrameStyled) {
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!m_picture) { // Lazy creation
|
2010-07-18 16:32:37 +00:00
|
|
|
updatePicture();
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2011-06-11 12:48:16 +00:00
|
|
|
if (m_picture) {
|
|
|
|
qreal left, top, right, bottom;
|
|
|
|
m_effectFrame->frame().getMargins(left, top, right, bottom); // m_geometry is the inner geometry
|
|
|
|
QRect geom = m_effectFrame->geometry().adjusted(-left, -top, right, bottom);
|
2013-02-27 12:04:06 +00:00
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *m_picture,
|
|
|
|
XCB_RENDER_PICTURE_NONE, effects->xrenderBufferPicture(),
|
|
|
|
0, 0, 0, 0, geom.x(), geom.y(), geom.width(), geom.height());
|
2011-06-11 12:48:16 +00:00
|
|
|
}
|
2011-04-28 11:41:11 +00:00
|
|
|
}
|
|
|
|
if (!m_effectFrame->selection().isNull()) {
|
|
|
|
if (!m_selectionPicture) { // Lazy creation
|
2011-06-11 12:48:16 +00:00
|
|
|
const QPixmap pix = m_effectFrame->selectionFrame().framePixmap();
|
|
|
|
if (!pix.isNull()) // don't try if there's no content
|
2013-08-13 05:19:09 +00:00
|
|
|
m_selectionPicture = new XRenderPicture(m_effectFrame->selectionFrame().framePixmap().toImage());
|
2011-06-11 12:48:16 +00:00
|
|
|
}
|
|
|
|
if (m_selectionPicture) {
|
|
|
|
const QRect geom = m_effectFrame->selection();
|
2013-02-27 12:04:06 +00:00
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *m_selectionPicture,
|
|
|
|
XCB_RENDER_PICTURE_NONE, effects->xrenderBufferPicture(),
|
|
|
|
0, 0, 0, 0, geom.x(), geom.y(), geom.width(), geom.height());
|
2010-07-18 16:32:37 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
XRenderPicture fill = xRenderBlendPicture(opacity);
|
|
|
|
|
|
|
|
// Render icon
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
|
|
|
|
QPoint topLeft(m_effectFrame->geometry().x(), m_effectFrame->geometry().center().y() - m_effectFrame->iconSize().height() / 2);
|
|
|
|
|
|
|
|
if (!m_iconPicture) // lazy creation
|
2013-12-06 13:41:23 +00:00
|
|
|
m_iconPicture = new XRenderPicture(m_effectFrame->icon().pixmap(m_effectFrame->iconSize()).toImage());
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect geom = QRect(topLeft, m_effectFrame->iconSize());
|
2013-02-27 12:04:06 +00:00
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *m_iconPicture, fill,
|
|
|
|
effects->xrenderBufferPicture(),
|
|
|
|
0, 0, 0, 0, geom.x(), geom.y(), geom.width(), geom.height());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
// Render text
|
2011-01-30 14:34:42 +00:00
|
|
|
if (!m_effectFrame->text().isEmpty()) {
|
|
|
|
if (!m_textPicture) { // Lazy creation
|
2010-07-18 16:32:37 +00:00
|
|
|
updateTextPicture();
|
|
|
|
}
|
2016-04-08 07:26:12 +00:00
|
|
|
|
|
|
|
if (m_textPicture) {
|
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *m_textPicture, fill, effects->xrenderBufferPicture(),
|
|
|
|
0, 0, 0, 0, m_effectFrame->geometry().x(), m_effectFrame->geometry().y(),
|
|
|
|
m_effectFrame->geometry().width(), m_effectFrame->geometry().height());
|
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2013-02-06 07:03:14 +00:00
|
|
|
void SceneXrender::EffectFrame::renderUnstyled(xcb_render_picture_t pict, const QRect &rect, qreal opacity)
|
|
|
|
{
|
|
|
|
const int roundness = 5;
|
|
|
|
const QRect area = rect.adjusted(-roundness, -roundness, roundness, roundness);
|
|
|
|
xcb_rectangle_t rects[3];
|
|
|
|
// center
|
|
|
|
rects[0].x = area.left();
|
|
|
|
rects[0].y = area.top() + roundness;
|
|
|
|
rects[0].width = area.width();
|
|
|
|
rects[0].height = area.height() - roundness * 2;
|
|
|
|
// top
|
|
|
|
rects[1].x = area.left() + roundness;
|
|
|
|
rects[1].y = area.top();
|
|
|
|
rects[1].width = area.width() - roundness * 2;
|
|
|
|
rects[1].height = roundness;
|
|
|
|
// bottom
|
|
|
|
rects[2].x = area.left() + roundness;
|
|
|
|
rects[2].y = area.top() + area.height() - roundness;
|
|
|
|
rects[2].width = area.width() - roundness * 2;
|
|
|
|
rects[2].height = roundness;
|
|
|
|
xcb_render_color_t color = {0, 0, 0, uint16_t(opacity * 0xffff)};
|
|
|
|
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_OVER, pict, color, 3, rects);
|
|
|
|
|
|
|
|
if (!s_effectFrameCircle) {
|
|
|
|
// create the circle
|
|
|
|
const int diameter = roundness * 2;
|
|
|
|
xcb_pixmap_t pix = xcb_generate_id(connection());
|
|
|
|
xcb_create_pixmap(connection(), 32, pix, rootWindow(), diameter, diameter);
|
|
|
|
s_effectFrameCircle = new XRenderPicture(pix, 32);
|
|
|
|
xcb_free_pixmap(connection(), pix);
|
|
|
|
|
|
|
|
// clear it with transparent
|
|
|
|
xcb_rectangle_t xrect = {0, 0, diameter, diameter};
|
|
|
|
xcb_render_color_t tranparent = {0, 0, 0, 0};
|
|
|
|
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, *s_effectFrameCircle, tranparent, 1, &xrect);
|
|
|
|
|
2014-09-27 18:30:49 +00:00
|
|
|
static const int num_segments = 80;
|
|
|
|
static const qreal theta = 2 * M_PI / qreal(num_segments);
|
|
|
|
static const qreal c = qCos(theta); //precalculate the sine and cosine
|
|
|
|
static const qreal s = qSin(theta);
|
2013-02-06 07:03:14 +00:00
|
|
|
qreal t;
|
|
|
|
|
|
|
|
qreal x = roundness;//we start at angle = 0
|
|
|
|
qreal y = 0;
|
2013-07-03 19:30:51 +00:00
|
|
|
|
2013-02-06 07:03:14 +00:00
|
|
|
QVector<xcb_render_pointfix_t> points;
|
|
|
|
xcb_render_pointfix_t point;
|
|
|
|
point.x = DOUBLE_TO_FIXED(roundness);
|
|
|
|
point.y = DOUBLE_TO_FIXED(roundness);
|
|
|
|
points << point;
|
|
|
|
for (int ii = 0; ii <= num_segments; ++ii) {
|
|
|
|
point.x = DOUBLE_TO_FIXED(x + roundness);
|
|
|
|
point.y = DOUBLE_TO_FIXED(y + roundness);
|
|
|
|
points << point;
|
|
|
|
//apply the rotation matrix
|
|
|
|
t = x;
|
|
|
|
x = c * x - s * y;
|
|
|
|
y = s * t + c * y;
|
|
|
|
}
|
|
|
|
XRenderPicture fill = xRenderFill(Qt::black);
|
|
|
|
xcb_render_tri_fan(connection(), XCB_RENDER_PICT_OP_OVER, fill, *s_effectFrameCircle,
|
|
|
|
0, 0, 0, points.count(), points.constData());
|
|
|
|
}
|
|
|
|
// TODO: merge alpha mask with SceneXrender::Window::alphaMask
|
|
|
|
// alpha mask
|
|
|
|
xcb_pixmap_t pix = xcb_generate_id(connection());
|
|
|
|
xcb_create_pixmap(connection(), 8, pix, rootWindow(), 1, 1);
|
|
|
|
XRenderPicture alphaMask(pix, 8);
|
|
|
|
xcb_free_pixmap(connection(), pix);
|
|
|
|
const uint32_t values[] = {true};
|
|
|
|
xcb_render_change_picture(connection(), alphaMask, XCB_RENDER_CP_REPEAT, values);
|
|
|
|
color.alpha = int(opacity * 0xffff);
|
|
|
|
xcb_rectangle_t xrect = {0, 0, 1, 1};
|
|
|
|
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, alphaMask, color, 1, &xrect);
|
|
|
|
|
|
|
|
// TODO: replace by lambda
|
|
|
|
#define RENDER_CIRCLE(srcX, srcY, destX, destY) \
|
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *s_effectFrameCircle, alphaMask, \
|
|
|
|
pict, srcX, srcY, 0, 0, destX, destY, roundness, roundness)
|
|
|
|
|
|
|
|
RENDER_CIRCLE(0, 0, area.left(), area.top());
|
|
|
|
RENDER_CIRCLE(0, roundness, area.left(), area.top() + area.height() - roundness);
|
|
|
|
RENDER_CIRCLE(roundness, 0, area.left() + area.width() - roundness, area.top());
|
|
|
|
RENDER_CIRCLE(roundness, roundness,
|
|
|
|
area.left() + area.width() - roundness, area.top() + area.height() - roundness);
|
|
|
|
#undef RENDER_CIRCLE
|
|
|
|
}
|
|
|
|
|
2010-07-18 16:32:37 +00:00
|
|
|
void SceneXrender::EffectFrame::updatePicture()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_picture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_picture = nullptr;
|
2011-06-11 12:48:16 +00:00
|
|
|
if (m_effectFrame->style() == EffectFrameStyled) {
|
|
|
|
const QPixmap pix = m_effectFrame->frame().framePixmap();
|
|
|
|
if (!pix.isNull())
|
2013-08-13 05:19:09 +00:00
|
|
|
m_picture = new XRenderPicture(pix.toImage());
|
2011-06-11 12:48:16 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
void SceneXrender::EffectFrame::updateTextPicture()
|
2011-01-30 14:34:42 +00:00
|
|
|
{
|
|
|
|
// Mostly copied from SceneOpenGL::EffectFrame::updateTextTexture() above
|
2010-07-18 16:32:37 +00:00
|
|
|
delete m_textPicture;
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_textPicture = nullptr;
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2011-01-30 14:34:42 +00:00
|
|
|
if (m_effectFrame->text().isEmpty()) {
|
2010-07-18 16:32:37 +00:00
|
|
|
return;
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
// Determine position on texture to paint text
|
2011-01-30 14:34:42 +00:00
|
|
|
QRect rect(QPoint(0, 0), m_effectFrame->geometry().size());
|
|
|
|
if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
|
|
|
|
rect.setLeft(m_effectFrame->iconSize().width());
|
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
|
|
|
// If static size elide text as required
|
|
|
|
QString text = m_effectFrame->text();
|
2011-01-30 14:34:42 +00:00
|
|
|
if (m_effectFrame->isStatic()) {
|
|
|
|
QFontMetrics metrics(m_effectFrame->text());
|
|
|
|
text = metrics.elidedText(text, Qt::ElideRight, rect.width());
|
|
|
|
}
|
|
|
|
|
|
|
|
QPixmap pixmap(m_effectFrame->geometry().size());
|
|
|
|
pixmap.fill(Qt::transparent);
|
|
|
|
QPainter p(&pixmap);
|
|
|
|
p.setFont(m_effectFrame->font());
|
|
|
|
if (m_effectFrame->style() == EffectFrameStyled) {
|
|
|
|
p.setPen(m_effectFrame->styledTextColor());
|
|
|
|
} else {
|
2010-07-18 16:32:37 +00:00
|
|
|
// TODO: What about no frame? Custom color setting required
|
2011-01-30 14:34:42 +00:00
|
|
|
p.setPen(Qt::white);
|
2010-07-18 16:32:37 +00:00
|
|
|
}
|
2011-01-30 14:34:42 +00:00
|
|
|
p.drawText(rect, m_effectFrame->alignment(), text);
|
|
|
|
p.end();
|
2013-08-13 05:19:09 +00:00
|
|
|
m_textPicture = new XRenderPicture(pixmap.toImage());
|
2011-01-30 14:34:42 +00:00
|
|
|
}
|
2010-07-18 16:32:37 +00:00
|
|
|
|
2011-04-28 15:22:17 +00:00
|
|
|
SceneXRenderShadow::SceneXRenderShadow(Toplevel *toplevel)
|
|
|
|
:Shadow(toplevel)
|
|
|
|
{
|
2013-02-27 11:56:38 +00:00
|
|
|
for (int i=0; i<ShadowElementsCount; ++i) {
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
m_pictures[i] = nullptr;
|
2013-02-27 11:56:38 +00:00
|
|
|
}
|
2011-04-28 15:22:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SceneXRenderShadow::~SceneXRenderShadow()
|
|
|
|
{
|
2013-02-27 11:56:38 +00:00
|
|
|
for (int i=0; i<ShadowElementsCount; ++i) {
|
|
|
|
delete m_pictures[i];
|
|
|
|
}
|
2011-04-28 15:22:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SceneXRenderShadow::layoutShadowRects(QRect& top, QRect& topRight,
|
|
|
|
QRect& right, QRect& bottomRight,
|
|
|
|
QRect& bottom, QRect& bottomLeft,
|
|
|
|
QRect& left, QRect& topLeft)
|
|
|
|
{
|
|
|
|
WindowQuadList quads = shadowQuads();
|
|
|
|
|
|
|
|
if (quads.count() == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
WindowQuad topQuad = quads.select(WindowQuadShadowTop)[0];
|
|
|
|
WindowQuad topRightQuad = quads.select(WindowQuadShadowTopRight)[0];
|
|
|
|
WindowQuad topLeftQuad = quads.select(WindowQuadShadowTopLeft)[0];
|
|
|
|
WindowQuad leftQuad = quads.select(WindowQuadShadowLeft)[0];
|
|
|
|
WindowQuad rightQuad = quads.select(WindowQuadShadowRight)[0];
|
|
|
|
WindowQuad bottomQuad = quads.select(WindowQuadShadowBottom)[0];
|
|
|
|
WindowQuad bottomRightQuad = quads.select(WindowQuadShadowBottomRight)[0];
|
|
|
|
WindowQuad bottomLeftQuad = quads.select(WindowQuadShadowBottomLeft)[0];
|
|
|
|
|
|
|
|
top = QRect(topQuad.left(), topQuad.top(), (topQuad.right()-topQuad.left()), (topQuad.bottom()-topQuad.top()));
|
|
|
|
topLeft = QRect(topLeftQuad.left(), topLeftQuad.top(), (topLeftQuad.right()-topLeftQuad.left()), (topLeftQuad.bottom()-topLeftQuad.top()));
|
|
|
|
topRight = QRect(topRightQuad.left(), topRightQuad.top(), (topRightQuad.right()-topRightQuad.left()), (topRightQuad.bottom()-topRightQuad.top()));
|
|
|
|
left = QRect(leftQuad.left(), leftQuad.top(), (leftQuad.right()-leftQuad.left()), (leftQuad.bottom()-leftQuad.top()));
|
|
|
|
right = QRect(rightQuad.left(), rightQuad.top(), (rightQuad.right()-rightQuad.left()), (rightQuad.bottom()-rightQuad.top()));
|
|
|
|
bottom = QRect(bottomQuad.left(), bottomQuad.top(), (bottomQuad.right()-bottomQuad.left()), (bottomQuad.bottom()-bottomQuad.top()));
|
|
|
|
bottomLeft = QRect(bottomLeftQuad.left(), bottomLeftQuad.top(), (bottomLeftQuad.right()-bottomLeftQuad.left()), (bottomLeftQuad.bottom()-bottomLeftQuad.top()));
|
|
|
|
bottomRight = QRect(bottomRightQuad.left(), bottomRightQuad.top(), (bottomRightQuad.right()-bottomRightQuad.left()), (bottomRightQuad.bottom()-bottomRightQuad.top()));
|
|
|
|
}
|
|
|
|
|
|
|
|
void SceneXRenderShadow::buildQuads()
|
|
|
|
{
|
|
|
|
Shadow::buildQuads();
|
|
|
|
|
2011-05-09 15:13:05 +00:00
|
|
|
if (shadowQuads().count() == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-04-28 15:22:17 +00:00
|
|
|
QRect stlr, str, strr, srr, sbrr, sbr, sblr, slr;
|
|
|
|
layoutShadowRects(str, strr, srr, sbrr, sbr, sblr, slr, stlr);
|
2013-02-27 11:56:38 +00:00
|
|
|
}
|
2011-04-28 15:22:17 +00:00
|
|
|
|
2013-02-27 11:56:38 +00:00
|
|
|
bool SceneXRenderShadow::prepareBackend()
|
|
|
|
{
|
2014-07-24 06:39:25 +00:00
|
|
|
if (hasDecorationShadow()) {
|
2015-01-12 09:13:47 +00:00
|
|
|
const QImage shadowImage = decorationShadowImage();
|
|
|
|
QPainter p;
|
|
|
|
int x = 0;
|
|
|
|
int y = 0;
|
|
|
|
auto drawElement = [this, &x, &y, &p, &shadowImage] (ShadowElements element) {
|
|
|
|
QPixmap pix(elementSize(element));
|
|
|
|
pix.fill(Qt::transparent);
|
|
|
|
p.begin(&pix);
|
|
|
|
p.drawImage(0, 0, shadowImage, x, y, pix.width(), pix.height());
|
|
|
|
p.end();
|
|
|
|
setShadowElement(pix, element);
|
|
|
|
return pix.size();
|
|
|
|
};
|
|
|
|
x += drawElement(ShadowElementTopLeft).width();
|
|
|
|
x += drawElement(ShadowElementTop).width();
|
|
|
|
y += drawElement(ShadowElementTopRight).height();
|
|
|
|
drawElement(ShadowElementRight);
|
|
|
|
x = 0;
|
|
|
|
y += drawElement(ShadowElementLeft).height();
|
|
|
|
x += drawElement(ShadowElementBottomLeft).width();
|
|
|
|
x += drawElement(ShadowElementBottom).width();
|
|
|
|
drawElement(ShadowElementBottomRight).width();
|
2014-07-24 06:39:25 +00:00
|
|
|
}
|
2013-02-27 11:56:38 +00:00
|
|
|
const uint32_t values[] = {XCB_RENDER_REPEAT_NORMAL};
|
|
|
|
for (int i=0; i<ShadowElementsCount; ++i) {
|
|
|
|
delete m_pictures[i];
|
2013-08-13 05:19:09 +00:00
|
|
|
m_pictures[i] = new XRenderPicture(shadowPixmap(ShadowElements(i)).toImage());
|
2013-02-27 11:56:38 +00:00
|
|
|
xcb_render_change_picture(connection(), *m_pictures[i], XCB_RENDER_CP_REPEAT, values);
|
2011-07-24 21:04:06 +00:00
|
|
|
}
|
2013-02-27 11:56:38 +00:00
|
|
|
return true;
|
|
|
|
}
|
2011-07-24 21:04:06 +00:00
|
|
|
|
2013-02-27 11:56:38 +00:00
|
|
|
xcb_render_picture_t SceneXRenderShadow::picture(Shadow::ShadowElements element) const
|
|
|
|
{
|
|
|
|
if (!m_pictures[element]) {
|
|
|
|
return XCB_RENDER_PICTURE_NONE;
|
|
|
|
}
|
|
|
|
return *m_pictures[element];
|
2011-04-28 15:22:17 +00:00
|
|
|
}
|
|
|
|
|
2014-07-22 11:11:19 +00:00
|
|
|
SceneXRenderDecorationRenderer::SceneXRenderDecorationRenderer(Decoration::DecoratedClientImpl *client)
|
|
|
|
: Renderer(client)
|
|
|
|
, m_gc(XCB_NONE)
|
|
|
|
{
|
2015-12-03 16:12:25 +00:00
|
|
|
connect(this, &Renderer::renderScheduled, client->client(), static_cast<void (AbstractClient::*)(const QRect&)>(&AbstractClient::addRepaint));
|
2014-07-22 11:11:19 +00:00
|
|
|
for (int i = 0; i < int(DecorationPart::Count); ++i) {
|
|
|
|
m_pixmaps[i] = XCB_PIXMAP_NONE;
|
|
|
|
m_pictures[i] = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SceneXRenderDecorationRenderer::~SceneXRenderDecorationRenderer()
|
|
|
|
{
|
|
|
|
for (int i = 0; i < int(DecorationPart::Count); ++i) {
|
|
|
|
if (m_pixmaps[i] != XCB_PIXMAP_NONE) {
|
|
|
|
xcb_free_pixmap(connection(), m_pixmaps[i]);
|
|
|
|
}
|
|
|
|
delete m_pictures[i];
|
|
|
|
}
|
|
|
|
if (m_gc != 0) {
|
|
|
|
xcb_free_gc(connection(), m_gc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SceneXRenderDecorationRenderer::render()
|
|
|
|
{
|
2015-01-19 14:28:17 +00:00
|
|
|
QRegion scheduled = getScheduled();
|
2014-07-22 11:11:19 +00:00
|
|
|
if (scheduled.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (areImageSizesDirty()) {
|
|
|
|
resizePixmaps();
|
|
|
|
resetImageSizesDirty();
|
|
|
|
}
|
|
|
|
|
|
|
|
const QRect top(QPoint(0, 0), m_sizes[int(DecorationPart::Top)]);
|
|
|
|
const QRect left(QPoint(0, top.height()), m_sizes[int(DecorationPart::Left)]);
|
|
|
|
const QRect right(QPoint(top.width() - m_sizes[int(DecorationPart::Right)].width(), top.height()), m_sizes[int(DecorationPart::Right)]);
|
|
|
|
const QRect bottom(QPoint(0, left.y() + left.height()), m_sizes[int(DecorationPart::Bottom)]);
|
|
|
|
|
|
|
|
xcb_connection_t *c = connection();
|
|
|
|
if (m_gc == 0) {
|
|
|
|
m_gc = xcb_generate_id(connection());
|
|
|
|
xcb_create_gc(c, m_gc, m_pixmaps[int(DecorationPart::Top)], 0, nullptr);
|
|
|
|
}
|
|
|
|
auto renderPart = [this, c](const QRect &geo, const QPoint &offset, int index) {
|
2019-07-20 13:13:58 +00:00
|
|
|
if (!geo.isValid()) {
|
2014-07-22 11:11:19 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
QImage image = renderToImage(geo);
|
2017-11-01 17:54:21 +00:00
|
|
|
Q_ASSERT(image.devicePixelRatio() == 1);
|
2014-07-22 11:11:19 +00:00
|
|
|
xcb_put_image(c, XCB_IMAGE_FORMAT_Z_PIXMAP, m_pixmaps[index], m_gc,
|
|
|
|
image.width(), image.height(), geo.x() - offset.x(), geo.y() - offset.y(), 0, 32,
|
2019-07-09 21:10:56 +00:00
|
|
|
image.sizeInBytes(), image.constBits());
|
2014-07-22 11:11:19 +00:00
|
|
|
};
|
|
|
|
const QRect geometry = scheduled.boundingRect();
|
|
|
|
renderPart(left.intersected(geometry), left.topLeft(), int(DecorationPart::Left));
|
|
|
|
renderPart(top.intersected(geometry), top.topLeft(), int(DecorationPart::Top));
|
|
|
|
renderPart(right.intersected(geometry), right.topLeft(), int(DecorationPart::Right));
|
|
|
|
renderPart(bottom.intersected(geometry), bottom.topLeft(), int(DecorationPart::Bottom));
|
|
|
|
xcb_flush(c);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SceneXRenderDecorationRenderer::resizePixmaps()
|
|
|
|
{
|
|
|
|
QRect left, top, right, bottom;
|
2014-07-25 10:55:28 +00:00
|
|
|
client()->client()->layoutDecorationRects(left, top, right, bottom);
|
2014-07-22 11:11:19 +00:00
|
|
|
|
|
|
|
xcb_connection_t *c = connection();
|
|
|
|
auto checkAndCreate = [this, c](int border, const QRect &rect) {
|
|
|
|
const QSize size = rect.size();
|
|
|
|
if (m_sizes[border] != size) {
|
|
|
|
m_sizes[border] = size;
|
|
|
|
if (m_pixmaps[border] != XCB_PIXMAP_NONE) {
|
|
|
|
xcb_free_pixmap(c, m_pixmaps[border]);
|
|
|
|
}
|
|
|
|
delete m_pictures[border];
|
|
|
|
if (!size.isEmpty()) {
|
|
|
|
m_pixmaps[border] = xcb_generate_id(connection());
|
|
|
|
xcb_create_pixmap(connection(), 32, m_pixmaps[border], rootWindow(), size.width(), size.height());
|
|
|
|
m_pictures[border] = new XRenderPicture(m_pixmaps[border], 32);
|
|
|
|
} else {
|
|
|
|
m_pixmaps[border] = XCB_PIXMAP_NONE;
|
|
|
|
m_pictures[border] = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!m_pictures[border]) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// fill transparent
|
|
|
|
xcb_rectangle_t r = {0, 0, uint16_t(size.width()), uint16_t(size.height())};
|
|
|
|
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, *m_pictures[border], preMultiply(Qt::transparent), 1, &r);
|
|
|
|
};
|
|
|
|
|
|
|
|
checkAndCreate(int(DecorationPart::Left), left);
|
|
|
|
checkAndCreate(int(DecorationPart::Top), top);
|
|
|
|
checkAndCreate(int(DecorationPart::Right), right);
|
|
|
|
checkAndCreate(int(DecorationPart::Bottom), bottom);
|
|
|
|
}
|
|
|
|
|
|
|
|
xcb_render_picture_t SceneXRenderDecorationRenderer::picture(SceneXRenderDecorationRenderer::DecorationPart part) const
|
|
|
|
{
|
|
|
|
Q_ASSERT(part != DecorationPart::Count);
|
|
|
|
XRenderPicture *picture = m_pictures[int(part)];
|
|
|
|
if (!picture) {
|
|
|
|
return XCB_RENDER_PICTURE_NONE;
|
|
|
|
}
|
|
|
|
return *picture;
|
|
|
|
}
|
|
|
|
|
2014-07-23 07:20:28 +00:00
|
|
|
void SceneXRenderDecorationRenderer::reparent(Deleted *deleted)
|
|
|
|
{
|
|
|
|
render();
|
|
|
|
Renderer::reparent(deleted);
|
|
|
|
}
|
|
|
|
|
2013-07-03 19:30:51 +00:00
|
|
|
#undef DOUBLE_TO_FIXED
|
|
|
|
#undef FIXED_TO_DOUBLE
|
|
|
|
|
2017-08-10 16:13:42 +00:00
|
|
|
XRenderFactory::XRenderFactory(QObject *parent)
|
|
|
|
: SceneFactory(parent)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
XRenderFactory::~XRenderFactory() = default;
|
|
|
|
|
|
|
|
Scene *XRenderFactory::create(QObject *parent) const
|
|
|
|
{
|
|
|
|
auto s = SceneXrender::createScene(parent);
|
|
|
|
if (s && s->initFailed()) {
|
|
|
|
delete s;
|
|
|
|
s = nullptr;
|
|
|
|
}
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2007-04-29 17:35:43 +00:00
|
|
|
} // namespace
|
|
|
|
#endif
|
2017-06-12 20:28:39 +00:00
|
|
|
|
|
|
|
|
2020-10-26 07:39:55 +00:00
|
|
|
void KWin::SceneXrender::paintCursor(const QRegion ®ion)
|
2017-06-12 20:28:39 +00:00
|
|
|
{
|
2020-10-26 07:39:55 +00:00
|
|
|
Q_UNUSED(region)
|
2017-06-12 20:28:39 +00:00
|
|
|
}
|
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect
Summary:
EffectQuickView/Scene is a convenient class to render a QtQuick
scenegraph into an effect.
Current methods (such as present windows) involve creating an underlying
platform window which is expensive, causes a headache to filter out
again in the rest of the code, and only works as an overlay.
The new class exposes things more natively to an effect where we don't
mess with real windows, we can perform the painting anywhere in the view
and we don't have issues with hiding/closing.
QtQuick has both software and hardware accelerated modes, and kwin also
has 3 render backends. Every combination is supported.
* When used in OpenGL mode for both, we render into an FBO export the
texture ID then it's up to the effect to render that into a scene.
* When using software QtQuick rendering we blit into an image, upload
that into a KWinGLTexture which serves as an abstraction layer and
render that into the scene.
* When using GL for QtQuick and XRender/QPainter in kwin everything is
rendered into the internal FBO, blit and exported as an image.
* When using software rendering for both an image gets passed directly.
Mouse and keyboard events can be forwarded, only if the effect
intercepts them.
The class is meant to be generic enough that we can remove all the
QtQuick code from Aurorae.
The intention is also to replace EffectFrameImpl using this backend and
we can kill all of the EffectFrame code throughout the scenes.
The close button in present windows will also be ported to this,
simplifiying that code base.
Classes that handle the rendering and handling QML are intentionally
split so that in the future we can have a declarative effects API create
overlays from within the same context. Similar to how one can
instantiate windows from a typical QML scene.
Notes:
I don't like how I pass the kwin GL context from the backends into the
effect, but I need something that works with the library separation. It
also currently has wayland problem if I create a QOpenGLContext before
the QPA is set up with a scene - but I don't have anything better?
I know for the EffectFrame we need an API to push things through the
effects stack to handle blur/invert etc. Will deal with that when we
port the EffectFrame.
Test Plan: Used in an effect
Reviewers: #kwin, zzag
Reviewed By: #kwin, zzag
Subscribers: zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
|
|
|
|
|
|
|
void KWin::SceneXrender::paintEffectQuickView(KWin::EffectQuickView *w)
|
|
|
|
{
|
|
|
|
const QImage buffer = w->bufferAsImage();
|
|
|
|
if (buffer.isNull()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
XRenderPicture picture(buffer);
|
|
|
|
xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, picture, XCB_RENDER_PICTURE_NONE,
|
|
|
|
effects->xrenderBufferPicture(),
|
|
|
|
0, 0, 0, 0, w->geometry().x(), w->geometry().y(),
|
|
|
|
w->geometry().width(), w->geometry().height());
|
|
|
|
}
|