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

Move NonComposited Outline into the X11 standalone platform

Browse source 
Summary:
Creating the OutlineVisual is moved into the Platform API. The default
implementation creates the composited OutlineVisual. The X11 standalone
platform overrides it and creates the non composited outline in case no
compositing is used.

Test Plan:
Run kwin_x11 with KWIN_COMPOSE=N and KWIN_COMPOSE=X,
non composited outline and composited outline loaded

Reviewers: #kwin, #plasma

Subscribers: plasma-devel, kwin

Tags: #kwin

Differential Revision: https://phabricator.kde.org/D7450
This commit is contained in:
Martin Flöser 2017-08-21 11:59:52 +02:00
parent f0652970f4
commit a3dc2ad5a2
9 changed files with 246 additions and 161 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

133
outline.cpp
View file

@ -22,10 +22,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "outline.h"
// KWin
#include "composite.h"
#include "main.h"
#include "platform.h"
#include "scripting/scripting.h"
// KWin libs
#include <kwinxrenderutils.h>
#include "workspace.h"
#include "utils.h"
// Frameworks
#include <KConfigGroup>
// Qt
@ -35,8 +35,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <QQmlEngine>
#include <QQuickWindow>
#include <QStandardPaths>
// xcb
#include <xcb/render.h>
namespace KWin {
@ -122,11 +120,7 @@ void Outline::createHelper()
if (!m_visual.isNull()) {
return;
}
if (Compositor::compositing()) {
m_visual.reset(new CompositedOutlineVisual(this));
} else {
m_visual.reset(new NonCompositedOutlineVisual(this));
}
m_visual.reset(kwinApp()->platform()->createOutline(this));
}
void Outline::compositingChanged()
@ -189,123 +183,4 @@ void CompositedOutlineVisual::show()
}
}
NonCompositedOutlineVisual::NonCompositedOutlineVisual(Outline *outline)
: OutlineVisual(outline)
, m_initialized(false)
{
}
NonCompositedOutlineVisual::~NonCompositedOutlineVisual()
{
}
void NonCompositedOutlineVisual::show()
{
if (!m_initialized) {
const QRect geo(0, 0, 1, 1);
const uint32_t values[] = {true};
// TODO: use template variant
m_leftOutline.create(geo, XCB_CW_OVERRIDE_REDIRECT, values);
m_rightOutline.create(geo, XCB_CW_OVERRIDE_REDIRECT, values);
m_topOutline.create(geo, XCB_CW_OVERRIDE_REDIRECT, values);
m_bottomOutline.create(geo, XCB_CW_OVERRIDE_REDIRECT, values);
m_initialized = true;
}
const int defaultDepth = Xcb::defaultDepth();
const QRect &outlineGeometry = outline()->geometry();
// left/right parts are between top/bottom, they don't reach as far as the corners
const uint16_t verticalWidth = 5;
const uint16_t verticalHeight = outlineGeometry.height() - 10;
const uint16_t horizontalWidth = outlineGeometry.width();
const uint horizontalHeight = 5;
m_leftOutline.setGeometry(outlineGeometry.x(), outlineGeometry.y() + 5, verticalWidth, verticalHeight);
m_rightOutline.setGeometry(outlineGeometry.x() + outlineGeometry.width() - 5, outlineGeometry.y() + 5, verticalWidth, verticalHeight);
m_topOutline.setGeometry(outlineGeometry.x(), outlineGeometry.y(), horizontalWidth, horizontalHeight);
m_bottomOutline.setGeometry(outlineGeometry.x(), outlineGeometry.y() + outlineGeometry.height() - 5, horizontalWidth, horizontalHeight);
const xcb_render_color_t white = {0xffff, 0xffff, 0xffff, 0xffff};
QColor qGray(Qt::gray);
const xcb_render_color_t gray = {
uint16_t(0xffff * qGray.redF()),
uint16_t(0xffff * qGray.greenF()),
uint16_t(0xffff * qGray.blueF()),
0xffff
};
const xcb_render_color_t black = {0, 0, 0, 0xffff};
{
xcb_pixmap_t xpix = xcb_generate_id(connection());
xcb_create_pixmap(connection(), defaultDepth, xpix, rootWindow(), verticalWidth, verticalHeight);
XRenderPicture pic(xpix, defaultDepth);
xcb_rectangle_t rect = {0, 0, 5, verticalHeight};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, white, 1, &rect);
rect.x = 1;
rect.width = 3;
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, gray, 1, &rect);
rect.x = 2;
rect.width = 1;
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, black, 1, &rect);
m_leftOutline.setBackgroundPixmap(xpix);
m_rightOutline.setBackgroundPixmap(xpix);
// According to the XSetWindowBackgroundPixmap documentation the pixmap can be freed.
xcb_free_pixmap(connection(), xpix);
}
{
xcb_pixmap_t xpix = xcb_generate_id(connection());
xcb_create_pixmap(connection(), defaultDepth, xpix, rootWindow(), horizontalWidth, horizontalHeight);
XRenderPicture pic(xpix, defaultDepth);
xcb_rectangle_t rect = {0, 0, horizontalWidth, horizontalHeight};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, white, 1, &rect);
xcb_rectangle_t grayRects[] = {
{1, 1, uint16_t(horizontalWidth -2), 3},
{1, 4, 3, 1},
{int16_t(horizontalWidth - 4), 4, 3, 1}
};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, gray, 3, grayRects);
xcb_rectangle_t blackRects[] = {
{2, 2, uint16_t(horizontalWidth -4), 1},
{2, 3, 1, 2},
{int16_t(horizontalWidth - 3), 3, 1, 2}
};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, black, 3, blackRects);
m_topOutline.setBackgroundPixmap(xpix);
// According to the XSetWindowBackgroundPixmap documentation the pixmap can be freed.
xcb_free_pixmap(connection(), xpix);
}
{
xcb_pixmap_t xpix = xcb_generate_id(connection());
xcb_create_pixmap(connection(), defaultDepth, xpix, rootWindow(), outlineGeometry.width(), 5);
XRenderPicture pic(xpix, defaultDepth);
xcb_rectangle_t rect = {0, 0, horizontalWidth, horizontalHeight};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, white, 1, &rect);
xcb_rectangle_t grayRects[] = {
{1, 1, uint16_t(horizontalWidth -2), 3},
{1, 0, 3, 1},
{int16_t(horizontalWidth - 4), 0, 3, 1}
};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, gray, 3, grayRects);
xcb_rectangle_t blackRects[] = {
{2, 2, uint16_t(horizontalWidth -4), 1},
{2, 0, 1, 2},
{int16_t(horizontalWidth - 3), 0, 1, 2}
};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, black, 3, blackRects);
m_bottomOutline.setBackgroundPixmap(xpix);
// According to the XSetWindowBackgroundPixmap documentation the pixmap can be freed.
xcb_free_pixmap(connection(), xpix);
}
forEachWindow(&Xcb::Window::clear);
forEachWindow(&Xcb::Window::map);
}
void NonCompositedOutlineVisual::hide()
{
forEachWindow(&Xcb::Window::unmap);
}
} // namespace

36
outline.h
View file

@ -20,10 +20,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef KWIN_OUTLINE_H
#define KWIN_OUTLINE_H
#include "xcbutils.h"
#include <kwinglobals.h>
#include <QRect>
#include <QWidget>
#include <QObject>
#include <kwin_export.h>
class QQmlContext;
class QQmlComponent;
@ -125,7 +126,7 @@ private:
KWIN_SINGLETON(Outline)
};
class OutlineVisual
class KWIN_EXPORT OutlineVisual
{
public:
OutlineVisual(Outline *outline);
@ -152,25 +153,6 @@ private:
QScopedPointer<QObject> m_mainItem;
};
class NonCompositedOutlineVisual : public OutlineVisual
{
public:
NonCompositedOutlineVisual(Outline *outline);
virtual ~NonCompositedOutlineVisual();
virtual void show();
virtual void hide();
private:
// TODO: variadic template arguments for adding method arguments
template <typename T>
void forEachWindow(T method);
bool m_initialized;
Xcb::Window m_topOutline;
Xcb::Window m_rightOutline;
Xcb::Window m_bottomOutline;
Xcb::Window m_leftOutline;
};
inline
bool Outline::isActive() const
{
@ -201,16 +183,6 @@ const Outline *OutlineVisual::outline() const
return m_outline;
}
template <typename T>
inline
void NonCompositedOutlineVisual::forEachWindow(T method)
{
(m_topOutline.*method)();
(m_rightOutline.*method)();
(m_bottomOutline.*method)();
(m_leftOutline.*method)();
}
inline
Outline *outline()
{

9
platform.cpp
View file

@ -24,6 +24,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "cursor.h"
#include "input.h"
#include "overlaywindow.h"
#include "outline.h"
#include "pointer_input.h"
#include "scene_opengl.h"
#include "screenedge.h"
@ -470,4 +471,12 @@ void Platform::updateXTime()
{
}
OutlineVisual *Platform::createOutline(Outline *outline)
{
if (Compositor::compositing()) {
return new CompositedOutlineVisual(outline);
}
return nullptr;
}
}

8
platform.h
View file

@ -42,6 +42,8 @@ namespace KWin
class Edge;
class OverlayWindow;
class OpenGLBackend;
class Outline;
class OutlineVisual;
class QPainterBackend;
class Screens;
class ScreenEdges;
@ -317,6 +319,12 @@ public:
**/
virtual void updateXTime();
/**
* Creates the OutlineVisual for the given @p outline.
* Default implementation creates an OutlineVisual suited for composited usage.
**/
virtual OutlineVisual *createOutline(Outline *outline);
public Q_SLOTS:
void pointerMotion(const QPointF &position, quint32 time);
void pointerButtonPressed(quint32 button, quint32 time);

1
plugins/platforms/x11/standalone/CMakeLists.txt
View file

@ -7,6 +7,7 @@ set(X11PLATFORM_SOURCES
windowselector.cpp
overlaywindow_x11.cpp
screenedges_filter.cpp
non_composited_outline.cpp
)
if(X11_Xinput_FOUND)

150
plugins/platforms/x11/standalone/non_composited_outline.cpp Normal file
View file

@ -0,0 +1,150 @@
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2011 Arthur Arlt <a.arlt@stud.uni-heidelberg.de>
Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
// own
#include "non_composited_outline.h"
// KWin libs
#include <kwinxrenderutils.h>
// xcb
#include <xcb/render.h>
namespace KWin
{
NonCompositedOutlineVisual::NonCompositedOutlineVisual(Outline *outline)
: OutlineVisual(outline)
, m_initialized(false)
{
}
NonCompositedOutlineVisual::~NonCompositedOutlineVisual()
{
}
void NonCompositedOutlineVisual::show()
{
if (!m_initialized) {
const QRect geo(0, 0, 1, 1);
const uint32_t values[] = {true};
// TODO: use template variant
m_leftOutline.create(geo, XCB_CW_OVERRIDE_REDIRECT, values);
m_rightOutline.create(geo, XCB_CW_OVERRIDE_REDIRECT, values);
m_topOutline.create(geo, XCB_CW_OVERRIDE_REDIRECT, values);
m_bottomOutline.create(geo, XCB_CW_OVERRIDE_REDIRECT, values);
m_initialized = true;
}
const int defaultDepth = Xcb::defaultDepth();
const QRect &outlineGeometry = outline()->geometry();
// left/right parts are between top/bottom, they don't reach as far as the corners
const uint16_t verticalWidth = 5;
const uint16_t verticalHeight = outlineGeometry.height() - 10;
const uint16_t horizontalWidth = outlineGeometry.width();
const uint horizontalHeight = 5;
m_leftOutline.setGeometry(outlineGeometry.x(), outlineGeometry.y() + 5, verticalWidth, verticalHeight);
m_rightOutline.setGeometry(outlineGeometry.x() + outlineGeometry.width() - 5, outlineGeometry.y() + 5, verticalWidth, verticalHeight);
m_topOutline.setGeometry(outlineGeometry.x(), outlineGeometry.y(), horizontalWidth, horizontalHeight);
m_bottomOutline.setGeometry(outlineGeometry.x(), outlineGeometry.y() + outlineGeometry.height() - 5, horizontalWidth, horizontalHeight);
const xcb_render_color_t white = {0xffff, 0xffff, 0xffff, 0xffff};
QColor qGray(Qt::gray);
const xcb_render_color_t gray = {
uint16_t(0xffff * qGray.redF()),
uint16_t(0xffff * qGray.greenF()),
uint16_t(0xffff * qGray.blueF()),
0xffff
};
const xcb_render_color_t black = {0, 0, 0, 0xffff};
{
xcb_pixmap_t xpix = xcb_generate_id(connection());
xcb_create_pixmap(connection(), defaultDepth, xpix, rootWindow(), verticalWidth, verticalHeight);
XRenderPicture pic(xpix, defaultDepth);
xcb_rectangle_t rect = {0, 0, 5, verticalHeight};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, white, 1, &rect);
rect.x = 1;
rect.width = 3;
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, gray, 1, &rect);
rect.x = 2;
rect.width = 1;
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, black, 1, &rect);
m_leftOutline.setBackgroundPixmap(xpix);
m_rightOutline.setBackgroundPixmap(xpix);
// According to the XSetWindowBackgroundPixmap documentation the pixmap can be freed.
xcb_free_pixmap(connection(), xpix);
}
{
xcb_pixmap_t xpix = xcb_generate_id(connection());
xcb_create_pixmap(connection(), defaultDepth, xpix, rootWindow(), horizontalWidth, horizontalHeight);
XRenderPicture pic(xpix, defaultDepth);
xcb_rectangle_t rect = {0, 0, horizontalWidth, horizontalHeight};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, white, 1, &rect);
xcb_rectangle_t grayRects[] = {
{1, 1, uint16_t(horizontalWidth -2), 3},
{1, 4, 3, 1},
{int16_t(horizontalWidth - 4), 4, 3, 1}
};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, gray, 3, grayRects);
xcb_rectangle_t blackRects[] = {
{2, 2, uint16_t(horizontalWidth -4), 1},
{2, 3, 1, 2},
{int16_t(horizontalWidth - 3), 3, 1, 2}
};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, black, 3, blackRects);
m_topOutline.setBackgroundPixmap(xpix);
// According to the XSetWindowBackgroundPixmap documentation the pixmap can be freed.
xcb_free_pixmap(connection(), xpix);
}
{
xcb_pixmap_t xpix = xcb_generate_id(connection());
xcb_create_pixmap(connection(), defaultDepth, xpix, rootWindow(), outlineGeometry.width(), 5);
XRenderPicture pic(xpix, defaultDepth);
xcb_rectangle_t rect = {0, 0, horizontalWidth, horizontalHeight};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, white, 1, &rect);
xcb_rectangle_t grayRects[] = {
{1, 1, uint16_t(horizontalWidth -2), 3},
{1, 0, 3, 1},
{int16_t(horizontalWidth - 4), 0, 3, 1}
};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, gray, 3, grayRects);
xcb_rectangle_t blackRects[] = {
{2, 2, uint16_t(horizontalWidth -4), 1},
{2, 0, 1, 2},
{int16_t(horizontalWidth - 3), 0, 1, 2}
};
xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, pic, black, 3, blackRects);
m_bottomOutline.setBackgroundPixmap(xpix);
// According to the XSetWindowBackgroundPixmap documentation the pixmap can be freed.
xcb_free_pixmap(connection(), xpix);
}
forEachWindow(&Xcb::Window::clear);
forEachWindow(&Xcb::Window::map);
}
void NonCompositedOutlineVisual::hide()
{
forEachWindow(&Xcb::Window::unmap);
}
} // namespace

59
plugins/platforms/x11/standalone/non_composited_outline.h Normal file
View file

@ -0,0 +1,59 @@
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2011 Arthur Arlt <a.arlt@stud.uni-heidelberg.de>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#ifndef KWIN_NON_COMPOSITED_OUTLINE_H
#define KWIN_NON_COMPOSITED_OUTLINE_H
#include "outline.h"
#include "xcbutils.h"
namespace KWin
{
class NonCompositedOutlineVisual : public OutlineVisual
{
public:
NonCompositedOutlineVisual(Outline *outline);
virtual ~NonCompositedOutlineVisual();
virtual void show();
virtual void hide();
private:
// TODO: variadic template arguments for adding method arguments
template <typename T>
void forEachWindow(T method);
bool m_initialized;
Xcb::Window m_topOutline;
Xcb::Window m_rightOutline;
Xcb::Window m_bottomOutline;
Xcb::Window m_leftOutline;
};
template <typename T>
inline
void NonCompositedOutlineVisual::forEachWindow(T method)
{
(m_topOutline.*method)();
(m_rightOutline.*method)();
(m_bottomOutline.*method)();
(m_leftOutline.*method)();
}
}
#endif

10
plugins/platforms/x11/standalone/x11_platform.cpp
View file

@ -36,6 +36,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "screenedges_filter.h"
#include "options.h"
#include "overlaywindow_x11.h"
#include "non_composited_outline.h"
#include <KConfigGroup>
#include <KLocalizedString>
@ -335,5 +336,14 @@ void X11StandalonePlatform::updateXTime()
kwinApp()->setX11Time(QX11Info::getTimestamp(), Application::TimestampUpdate::Always);
}
OutlineVisual *X11StandalonePlatform::createOutline(Outline *outline)
{
// first try composited Outline
auto ret = Platform::createOutline(outline);
if (!ret) {
ret = new NonCompositedOutlineVisual(outline);
}
return ret;
}
}

1
plugins/platforms/x11/standalone/x11_platform.h
View file

@ -59,6 +59,7 @@ public:
OverlayWindow *createOverlayWindow() override;
void updateXTime() override;
OutlineVisual *createOutline(Outline *outline) override;
protected:
void doHideCursor() override;