mirror of https://github.com/cutefishos/qt-plugins
refactor(qt-plugins): remove X11 integrations
reionwong
3 weeks ago
parent
dccded7c80
commit
688d4d44d9
@ -1,136 +0,0 @@
|
|||||||
/* This file is part of the KDE libraries
|
|
||||||
* Copyright 2015 Martin Gräßlin <mgraesslin@kde.org>
|
|
||||||
* Copyright 2016 Marco Martin <mart@kde.org>
|
|
||||||
*
|
|
||||||
* This library is free software; you can redistribute it and/or modify
|
|
||||||
* it under the terms of the GNU Lesser General Public License as published by
|
|
||||||
* the Free Software Foundation; either version 2 of the License or ( at
|
|
||||||
* your option ) version 3 or, at the discretion of KDE e.V. ( which shall
|
|
||||||
* act as a proxy as in section 14 of the GPLv3 ), any later version.
|
|
||||||
*
|
|
||||||
* This library 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
|
|
||||||
* Library General Public License for more details.
|
|
||||||
*
|
|
||||||
* You should have received a copy of the GNU Lesser General Public License
|
|
||||||
* along with this library; see the file COPYING.LIB. If not, write to
|
|
||||||
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
||||||
* Boston, MA 02110-1301, USA.
|
|
||||||
*/
|
|
||||||
#include "x11integration.h"
|
|
||||||
#include "x11utils.h"
|
|
||||||
|
|
||||||
#include <QCoreApplication>
|
|
||||||
#include <QPlatformSurfaceEvent>
|
|
||||||
#include <QGuiApplication>
|
|
||||||
#include <QtGui/qguiapplication_platform.h>
|
|
||||||
#include <QWindow>
|
|
||||||
#include <QWidget>
|
|
||||||
#include <QVariant>
|
|
||||||
#include <QRegion>
|
|
||||||
#include <QDebug>
|
|
||||||
|
|
||||||
#include <NETWM>
|
|
||||||
#include <KWindowEffects>
|
|
||||||
|
|
||||||
#include <xcb/xcb.h>
|
|
||||||
|
|
||||||
static const char s_schemePropertyName[] = "KDE_COLOR_SCHEME_PATH";
|
|
||||||
static const QByteArray s_blurBehindPropertyName = QByteArrayLiteral("ENABLE_BLUR_BEHIND_HINT");
|
|
||||||
static const QByteArray s_blurRegionPropertyName = QByteArrayLiteral("BLUR_REGION");
|
|
||||||
|
|
||||||
X11Integration::X11Integration()
|
|
||||||
: QObject()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
X11Integration::~X11Integration() = default;
|
|
||||||
|
|
||||||
void X11Integration::init()
|
|
||||||
{
|
|
||||||
QCoreApplication::instance()->installEventFilter(this);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool X11Integration::eventFilter(QObject *watched, QEvent *event)
|
|
||||||
{
|
|
||||||
//the drag and drop window should NOT be a tooltip
|
|
||||||
//https://bugreports.qt.io/browse/QTBUG-52560
|
|
||||||
if (event->type() == QEvent::Show && watched->inherits("QShapedPixmapWindow")) {
|
|
||||||
//static cast should be safe there
|
|
||||||
QWindow *w = static_cast<QWindow *>(watched);
|
|
||||||
NETWinInfo info(qGuiApp->nativeInterface<QNativeInterface::QX11Application>()->connection(), w->winId(), Cutefish::X11::rootWindow(), NET::WMWindowType, NET::Properties2());
|
|
||||||
info.setWindowType(NET::DNDIcon);
|
|
||||||
// TODO: does this flash the xcb connection?
|
|
||||||
}
|
|
||||||
|
|
||||||
// if (event->type() == QEvent::PlatformSurface) {
|
|
||||||
// if (QWindow *w = qobject_cast<QWindow*>(watched)) {
|
|
||||||
// QPlatformSurfaceEvent *pe = static_cast<QPlatformSurfaceEvent*>(event);
|
|
||||||
// if (!w->flags().testFlag(Qt::ForeignWindow)) {
|
|
||||||
// if (pe->surfaceEventType() == QPlatformSurfaceEvent::SurfaceCreated) {
|
|
||||||
// const auto blurBehindProperty = w->property(s_blurBehindPropertyName.constData());
|
|
||||||
// if (blurBehindProperty.isValid()) {
|
|
||||||
// KWindowEffects::enableBlurBehind(w->winId(), blurBehindProperty.toBool());
|
|
||||||
// }
|
|
||||||
// installDesktopFileName(w);
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
||||||
// if (event->type() == QEvent::ApplicationPaletteChange) {
|
|
||||||
// const auto topLevelWindows = QGuiApplication::topLevelWindows();
|
|
||||||
// for (QWindow *w : topLevelWindows) {
|
|
||||||
// installColorScheme(w);
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
void X11Integration::installDesktopFileName(QWindow *w)
|
|
||||||
{
|
|
||||||
if (!w->isTopLevel()) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
QString desktopFileName = QGuiApplication::desktopFileName();
|
|
||||||
if (desktopFileName.isEmpty()) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
// handle apps which set the desktopFileName property with filename suffix,
|
|
||||||
// due to unclear API dox (https://bugreports.qt.io/browse/QTBUG-75521)
|
|
||||||
if (desktopFileName.endsWith(QLatin1String(".desktop"))) {
|
|
||||||
desktopFileName.chop(8);
|
|
||||||
}
|
|
||||||
NETWinInfo info(qGuiApp->nativeInterface<QNativeInterface::QX11Application>()->connection(), w->winId(), Cutefish::X11::rootWindow(), NET::Properties(), NET::Properties2());
|
|
||||||
info.setDesktopFileName(desktopFileName.toUtf8().constData());
|
|
||||||
}
|
|
||||||
|
|
||||||
void X11Integration::setWindowProperty(QWindow *window, const QByteArray &name, const QByteArray &value)
|
|
||||||
{
|
|
||||||
auto *c = qGuiApp->nativeInterface<QNativeInterface::QX11Application>()->connection();
|
|
||||||
|
|
||||||
xcb_atom_t atom;
|
|
||||||
auto it = m_atoms.find(name);
|
|
||||||
if (it == m_atoms.end()) {
|
|
||||||
const xcb_intern_atom_cookie_t cookie = xcb_intern_atom(c, false, name.length(), name.constData());
|
|
||||||
QScopedPointer<xcb_intern_atom_reply_t, QScopedPointerPodDeleter> reply(xcb_intern_atom_reply(c, cookie, nullptr));
|
|
||||||
if (!reply.isNull()) {
|
|
||||||
atom = reply->atom;
|
|
||||||
m_atoms[name] = atom;
|
|
||||||
} else {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
atom = *it;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (value.isEmpty()) {
|
|
||||||
xcb_delete_property(c, window->winId(), atom);
|
|
||||||
} else {
|
|
||||||
xcb_change_property(c, XCB_PROP_MODE_REPLACE, window->winId(), atom, XCB_ATOM_STRING,
|
|
||||||
8, value.length(), value.constData());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,47 +0,0 @@
|
|||||||
/* This file is part of the KDE libraries
|
|
||||||
* Copyright 2015 Martin Gräßlin <mgraesslin@kde.org>
|
|
||||||
* Copyright 2016 Marco Martin <mart@kde.org>
|
|
||||||
*
|
|
||||||
* This library is free software; you can redistribute it and/or modify
|
|
||||||
* it under the terms of the GNU Lesser General Public License as published by
|
|
||||||
* the Free Software Foundation; either version 2 of the License or ( at
|
|
||||||
* your option ) version 3 or, at the discretion of KDE e.V. ( which shall
|
|
||||||
* act as a proxy as in section 14 of the GPLv3 ), any later version.
|
|
||||||
*
|
|
||||||
* This library 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
|
|
||||||
* Library General Public License for more details.
|
|
||||||
*
|
|
||||||
* You should have received a copy of the GNU Lesser General Public License
|
|
||||||
* along with this library; see the file COPYING.LIB. If not, write to
|
|
||||||
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
||||||
* Boston, MA 02110-1301, USA.
|
|
||||||
*/
|
|
||||||
#ifndef X11INTEGRATION_H
|
|
||||||
#define X11INTEGRATION_H
|
|
||||||
|
|
||||||
#include <QObject>
|
|
||||||
#include <QHash>
|
|
||||||
#include <xcb/xcb.h>
|
|
||||||
|
|
||||||
class QWindow;
|
|
||||||
|
|
||||||
class X11Integration : public QObject
|
|
||||||
{
|
|
||||||
Q_OBJECT
|
|
||||||
public:
|
|
||||||
explicit X11Integration();
|
|
||||||
~X11Integration() override;
|
|
||||||
void init();
|
|
||||||
|
|
||||||
void setWindowProperty(QWindow *window, const QByteArray &name, const QByteArray &value);
|
|
||||||
|
|
||||||
bool eventFilter(QObject *watched, QEvent *event) override;
|
|
||||||
|
|
||||||
private:
|
|
||||||
void installDesktopFileName(QWindow *w);
|
|
||||||
QHash<QByteArray, xcb_atom_t> m_atoms;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,170 +0,0 @@
|
|||||||
//////////////////////////////////////////////////////////////////////////////
|
|
||||||
// breezeblurhelper.cpp
|
|
||||||
// handle regions passed to kwin for blurring
|
|
||||||
// -------------------
|
|
||||||
//
|
|
||||||
// Copyright (C) 2021 Reion Wong <reionwong@gmail.com>
|
|
||||||
// Copyright (C) 2018 Alex Nemeth <alex.nemeth329@gmail.com>
|
|
||||||
//
|
|
||||||
// Largely rewritten from Oxygen widget style
|
|
||||||
// Copyright (C) 2007 Thomas Luebking <thomas.luebking@web.de>
|
|
||||||
// Copyright (c) 2010 Hugo Pereira Da Costa <hugo.pereira@free.fr>
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
// of this software and associated documentation files (the "Software"), to
|
|
||||||
// deal in the Software without restriction, including without limitation the
|
|
||||||
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
||||||
// sell copies of the Software, and to permit persons to whom the Software is
|
|
||||||
// furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in
|
|
||||||
// all copies or substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
||||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
||||||
// IN THE SOFTWARE.
|
|
||||||
//////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#include "blurhelper.h"
|
|
||||||
#include "x11utils.h"
|
|
||||||
|
|
||||||
// KDE Frameworks
|
|
||||||
#include <KWindowEffects>
|
|
||||||
#include <KWindowSystem>
|
|
||||||
|
|
||||||
// Qt
|
|
||||||
#include <QWidget>
|
|
||||||
#include <QWindow>
|
|
||||||
#include <QScreen>
|
|
||||||
#include <QRect>
|
|
||||||
#include <QVariant>
|
|
||||||
#include <QEvent>
|
|
||||||
#include <QPainterPath>
|
|
||||||
#include <QApplication>
|
|
||||||
#include <QtGui/qguiapplication_platform.h>
|
|
||||||
|
|
||||||
// XCB
|
|
||||||
#include <xcb/xcb.h>
|
|
||||||
#include <xcb/shape.h>
|
|
||||||
#include <xcb/xcb_icccm.h>
|
|
||||||
|
|
||||||
BlurHelper::BlurHelper(QObject *parent)
|
|
||||||
: QObject(parent)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
void BlurHelper::registerWidget(QWidget *widget)
|
|
||||||
{
|
|
||||||
// install event filter
|
|
||||||
addEventFilter(widget);
|
|
||||||
|
|
||||||
// schedule shadow area repaint
|
|
||||||
update(widget);
|
|
||||||
}
|
|
||||||
|
|
||||||
void BlurHelper::unregisterWidget(QWidget *widget)
|
|
||||||
{
|
|
||||||
// remove event filter
|
|
||||||
widget->removeEventFilter(this);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool BlurHelper::eventFilter(QObject *object, QEvent *event)
|
|
||||||
{
|
|
||||||
switch (event->type()) {
|
|
||||||
case QEvent::Hide:
|
|
||||||
case QEvent::Show:
|
|
||||||
case QEvent::Resize: {
|
|
||||||
// cast to widget and check
|
|
||||||
QWidget *widget(qobject_cast<QWidget*>(object));
|
|
||||||
|
|
||||||
if (!widget)
|
|
||||||
break;
|
|
||||||
|
|
||||||
update(widget);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
default: break;
|
|
||||||
}
|
|
||||||
|
|
||||||
// never eat events
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void BlurHelper::update(QWidget *widget) const
|
|
||||||
{
|
|
||||||
// KWindowEffects is an X11/EWMH integration. On Wayland there is no X11
|
|
||||||
// native interface to pass the blur region to, and calling it can crash
|
|
||||||
// while a QMenu is being painted.
|
|
||||||
if (!KWindowSystem::isPlatformX11())
|
|
||||||
return;
|
|
||||||
|
|
||||||
/*
|
|
||||||
directly from bespin code. Supposedly prevent playing with some 'pseudo-widgets'
|
|
||||||
that have winId matching some other -random- window
|
|
||||||
*/
|
|
||||||
if (!(widget->testAttribute(Qt::WA_WState_Created) || widget->internalWinId()))
|
|
||||||
return;
|
|
||||||
|
|
||||||
QWindow *window = widget->windowHandle();
|
|
||||||
if (!window)
|
|
||||||
return;
|
|
||||||
|
|
||||||
if (widget->mask().isEmpty()) {
|
|
||||||
KWindowEffects::enableBlurBehind(window, true);
|
|
||||||
} else {
|
|
||||||
KWindowEffects::enableBlurBehind(window, true, widget->mask());
|
|
||||||
}
|
|
||||||
|
|
||||||
// force update
|
|
||||||
if (widget->isVisible()) {
|
|
||||||
widget->update();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void BlurHelper::enableBlurBehind(QWidget *widget, bool enable, qreal windowRadius)
|
|
||||||
{
|
|
||||||
if (!widget || !KWindowSystem::isPlatformX11())
|
|
||||||
return;
|
|
||||||
|
|
||||||
const auto native = qGuiApp->nativeInterface<QNativeInterface::QX11Application>();
|
|
||||||
if (!native)
|
|
||||||
return;
|
|
||||||
|
|
||||||
xcb_connection_t *c = native->connection();
|
|
||||||
if (!c)
|
|
||||||
return;
|
|
||||||
|
|
||||||
const QByteArray effectName = QByteArrayLiteral("_KDE_NET_WM_BLUR_BEHIND_REGION");
|
|
||||||
xcb_intern_atom_cookie_t atomCookie = xcb_intern_atom_unchecked(c, false, effectName.length(), effectName.constData());
|
|
||||||
QScopedPointer<xcb_intern_atom_reply_t, QScopedPointerPodDeleter> atom(xcb_intern_atom_reply(c, atomCookie, nullptr));
|
|
||||||
if (!atom)
|
|
||||||
return;
|
|
||||||
|
|
||||||
if (enable) {
|
|
||||||
qreal devicePixelRatio = qApp->devicePixelRatio();
|
|
||||||
QPainterPath path;
|
|
||||||
path.addRoundedRect(QRectF(QPoint(0, 0), widget->size() * devicePixelRatio),
|
|
||||||
windowRadius * devicePixelRatio,
|
|
||||||
windowRadius * devicePixelRatio);
|
|
||||||
QVector<uint32_t> data;
|
|
||||||
for (const QPolygonF &polygon : path.toFillPolygons()) {
|
|
||||||
QRegion region = polygon.toPolygon();
|
|
||||||
for (auto i = region.begin(); i != region.end(); ++i) {
|
|
||||||
data << i->x() << i->y() << i->width() << i->height();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
xcb_change_property(c, XCB_PROP_MODE_REPLACE, widget->winId(),
|
|
||||||
atom->atom, XCB_ATOM_CARDINAL,
|
|
||||||
32, data.size(), data.constData());
|
|
||||||
|
|
||||||
} else {
|
|
||||||
xcb_delete_property(c, widget->winId(), atom->atom);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,59 +0,0 @@
|
|||||||
//////////////////////////////////////////////////////////////////////////////
|
|
||||||
// breezeblurhelper.h
|
|
||||||
// handle regions passed to kwin for blurring
|
|
||||||
// -------------------
|
|
||||||
//
|
|
||||||
// Copyright (C) 2018 Alex Nemeth <alex.nemeth329@gmail.com>
|
|
||||||
//
|
|
||||||
// Largely rewritten from Oxygen widget style
|
|
||||||
// Copyright (C) 2007 Thomas Luebking <thomas.luebking@web.de>
|
|
||||||
// Copyright (c) 2010 Hugo Pereira Da Costa <hugo.pereira@free.fr>
|
|
||||||
//
|
|
||||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
// of this software and associated documentation files (the "Software"), to
|
|
||||||
// deal in the Software without restriction, including without limitation the
|
|
||||||
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
||||||
// sell copies of the Software, and to permit persons to whom the Software is
|
|
||||||
// furnished to do so, subject to the following conditions:
|
|
||||||
//
|
|
||||||
// The above copyright notice and this permission notice shall be included in
|
|
||||||
// all copies or substantial portions of the Software.
|
|
||||||
//
|
|
||||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
||||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
||||||
// IN THE SOFTWARE.
|
|
||||||
//////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#ifndef BLURHELPER_H
|
|
||||||
#define BLURHELPER_H
|
|
||||||
|
|
||||||
#include <QObject>
|
|
||||||
|
|
||||||
class BlurHelper : public QObject
|
|
||||||
{
|
|
||||||
Q_OBJECT
|
|
||||||
|
|
||||||
public:
|
|
||||||
explicit BlurHelper(QObject *parent = nullptr);
|
|
||||||
|
|
||||||
void registerWidget(QWidget *);
|
|
||||||
void unregisterWidget(QWidget *);
|
|
||||||
bool eventFilter(QObject *, QEvent *) override;
|
|
||||||
|
|
||||||
void update(QWidget *) const;
|
|
||||||
|
|
||||||
void enableBlurBehind(QWidget *widget, bool enable = true, qreal windowRadius = 0.0);
|
|
||||||
|
|
||||||
protected:
|
|
||||||
void addEventFilter(QObject *object) {
|
|
||||||
object->removeEventFilter(this);
|
|
||||||
object->installEventFilter(this);
|
|
||||||
}
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif // BLURHELPER_H
|
|
||||||
@ -1,348 +0,0 @@
|
|||||||
/*
|
|
||||||
* Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
|
|
||||||
*
|
|
||||||
* The box blur implementation is based on AlphaBoxBlur from Firefox.
|
|
||||||
*
|
|
||||||
* 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, write to the Free Software
|
|
||||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
*/
|
|
||||||
|
|
||||||
// own
|
|
||||||
#include "boxshadowrenderer.h"
|
|
||||||
|
|
||||||
// Qt
|
|
||||||
#include <QPainter>
|
|
||||||
#include <QtMath>
|
|
||||||
|
|
||||||
static inline int calculateBlurRadius(qreal stdDev)
|
|
||||||
{
|
|
||||||
// See https://www.w3.org/TR/SVG11/filters.html#feGaussianBlurElement
|
|
||||||
const qreal gaussianScaleFactor = (3.0 * qSqrt(2.0 * M_PI) / 4.0) * 1.5;
|
|
||||||
return qMax(2, qFloor(stdDev * gaussianScaleFactor + 0.5));
|
|
||||||
}
|
|
||||||
|
|
||||||
static inline qreal calculateBlurStdDev(int radius)
|
|
||||||
{
|
|
||||||
// See https://www.w3.org/TR/css-backgrounds-3/#shadow-blur
|
|
||||||
return radius * 0.5;
|
|
||||||
}
|
|
||||||
|
|
||||||
static inline QSize calculateBlurExtent(int radius)
|
|
||||||
{
|
|
||||||
const int blurRadius = calculateBlurRadius(calculateBlurStdDev(radius));
|
|
||||||
return QSize(blurRadius, blurRadius);
|
|
||||||
}
|
|
||||||
|
|
||||||
struct BoxLobes
|
|
||||||
{
|
|
||||||
int left; ///< how many pixels sample to the left
|
|
||||||
int right; ///< how many pixels sample to the right
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Compute box filter parameters.
|
|
||||||
*
|
|
||||||
* @param radius The blur radius.
|
|
||||||
* @returns Parameters for three box filters.
|
|
||||||
**/
|
|
||||||
static QVector<BoxLobes> computeLobes(int radius)
|
|
||||||
{
|
|
||||||
const int blurRadius = calculateBlurRadius(calculateBlurStdDev(radius));
|
|
||||||
const int z = blurRadius / 3;
|
|
||||||
|
|
||||||
int major;
|
|
||||||
int minor;
|
|
||||||
int final;
|
|
||||||
|
|
||||||
switch (blurRadius % 3) {
|
|
||||||
case 0:
|
|
||||||
major = z;
|
|
||||||
minor = z;
|
|
||||||
final = z;
|
|
||||||
break;
|
|
||||||
|
|
||||||
case 1:
|
|
||||||
major = z + 1;
|
|
||||||
minor = z;
|
|
||||||
final = z;
|
|
||||||
break;
|
|
||||||
|
|
||||||
case 2:
|
|
||||||
major = z + 1;
|
|
||||||
minor = z;
|
|
||||||
final = z + 1;
|
|
||||||
break;
|
|
||||||
|
|
||||||
default:
|
|
||||||
Q_UNREACHABLE();
|
|
||||||
}
|
|
||||||
|
|
||||||
Q_ASSERT(major + minor + final == blurRadius);
|
|
||||||
|
|
||||||
return {
|
|
||||||
{major, minor},
|
|
||||||
{minor, major},
|
|
||||||
{final, final}
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Process a row with a box filter.
|
|
||||||
*
|
|
||||||
* @param src The start of the row.
|
|
||||||
* @param dst The destination.
|
|
||||||
* @param width The width of the row, in pixels.
|
|
||||||
* @param horizontalStride The number of bytes from one alpha value to the
|
|
||||||
* next alpha value.
|
|
||||||
* @param verticalStride The number of bytes from one row to the next row.
|
|
||||||
* @param lobes Params of the box filter.
|
|
||||||
* @param transposeInput Whether the input is transposed.
|
|
||||||
* @param transposeOutput Whether the output should be transposed.
|
|
||||||
**/
|
|
||||||
static inline void boxBlurRowAlpha(const uint8_t *src, uint8_t *dst, int width, int horizontalStride,
|
|
||||||
int verticalStride, const BoxLobes &lobes, bool transposeInput,
|
|
||||||
bool transposeOutput)
|
|
||||||
{
|
|
||||||
const int inputStep = transposeInput ? verticalStride : horizontalStride;
|
|
||||||
const int outputStep = transposeOutput ? verticalStride : horizontalStride;
|
|
||||||
|
|
||||||
const int boxSize = lobes.left + 1 + lobes.right;
|
|
||||||
const int reciprocal = (1 << 24) / boxSize;
|
|
||||||
|
|
||||||
uint32_t alphaSum = (boxSize + 1) / 2;
|
|
||||||
|
|
||||||
const uint8_t *left = src;
|
|
||||||
const uint8_t *right = src;
|
|
||||||
uint8_t *out = dst;
|
|
||||||
|
|
||||||
const uint8_t firstValue = src[0];
|
|
||||||
const uint8_t lastValue = src[(width - 1) * inputStep];
|
|
||||||
|
|
||||||
alphaSum += firstValue * lobes.left;
|
|
||||||
|
|
||||||
const uint8_t *initEnd = src + (boxSize - lobes.left) * inputStep;
|
|
||||||
while (right < initEnd) {
|
|
||||||
alphaSum += *right;
|
|
||||||
right += inputStep;
|
|
||||||
}
|
|
||||||
|
|
||||||
const uint8_t *leftEnd = src + boxSize * inputStep;
|
|
||||||
while (right < leftEnd) {
|
|
||||||
*out = (alphaSum * reciprocal) >> 24;
|
|
||||||
alphaSum += *right - firstValue;
|
|
||||||
right += inputStep;
|
|
||||||
out += outputStep;
|
|
||||||
}
|
|
||||||
|
|
||||||
const uint8_t *centerEnd = src + width * inputStep;
|
|
||||||
while (right < centerEnd) {
|
|
||||||
*out = (alphaSum * reciprocal) >> 24;
|
|
||||||
alphaSum += *right - *left;
|
|
||||||
left += inputStep;
|
|
||||||
right += inputStep;
|
|
||||||
out += outputStep;
|
|
||||||
}
|
|
||||||
|
|
||||||
const uint8_t *rightEnd = dst + width * outputStep;
|
|
||||||
while (out < rightEnd) {
|
|
||||||
*out = (alphaSum * reciprocal) >> 24;
|
|
||||||
alphaSum += lastValue - *left;
|
|
||||||
left += inputStep;
|
|
||||||
out += outputStep;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Blur the alpha channel of a given image.
|
|
||||||
*
|
|
||||||
* @param image The input image.
|
|
||||||
* @param radius The blur radius.
|
|
||||||
* @param rect Specifies what part of the image to blur. If nothing is provided, then
|
|
||||||
* the whole alpha channel of the input image will be blurred.
|
|
||||||
**/
|
|
||||||
static inline void boxBlurAlpha(QImage &image, int radius, const QRect &rect = {})
|
|
||||||
{
|
|
||||||
if (radius < 2) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
const QVector<BoxLobes> lobes = computeLobes(radius);
|
|
||||||
|
|
||||||
const QRect blurRect = rect.isNull() ? image.rect() : rect;
|
|
||||||
|
|
||||||
const int alphaOffset = QSysInfo::ByteOrder == QSysInfo::BigEndian ? 0 : 3;
|
|
||||||
const int width = blurRect.width();
|
|
||||||
const int height = blurRect.height();
|
|
||||||
const int rowStride = image.bytesPerLine();
|
|
||||||
const int pixelStride = image.depth() >> 3;
|
|
||||||
|
|
||||||
const int bufferStride = qMax(width, height) * pixelStride;
|
|
||||||
QScopedPointer<uint8_t, QScopedPointerArrayDeleter<uint8_t> > buf(new uint8_t[2 * bufferStride]);
|
|
||||||
uint8_t *buf1 = buf.data();
|
|
||||||
uint8_t *buf2 = buf1 + bufferStride;
|
|
||||||
|
|
||||||
// Blur the image in horizontal direction.
|
|
||||||
for (int i = 0; i < height; ++i) {
|
|
||||||
uint8_t *row = image.scanLine(blurRect.y() + i) + blurRect.x() * pixelStride + alphaOffset;
|
|
||||||
boxBlurRowAlpha(row, buf1, width, pixelStride, rowStride, lobes[0], false, false);
|
|
||||||
boxBlurRowAlpha(buf1, buf2, width, pixelStride, rowStride, lobes[1], false, false);
|
|
||||||
boxBlurRowAlpha(buf2, row, width, pixelStride, rowStride, lobes[2], false, false);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Blur the image in vertical direction.
|
|
||||||
for (int i = 0; i < width; ++i) {
|
|
||||||
uint8_t *column = image.scanLine(blurRect.y()) + (blurRect.x() + i) * pixelStride + alphaOffset;
|
|
||||||
boxBlurRowAlpha(column, buf1, height, pixelStride, rowStride, lobes[0], true, false);
|
|
||||||
boxBlurRowAlpha(buf1, buf2, height, pixelStride, rowStride, lobes[1], false, false);
|
|
||||||
boxBlurRowAlpha(buf2, column, height, pixelStride, rowStride, lobes[2], false, true);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static inline void mirrorTopLeftQuadrant(QImage &image)
|
|
||||||
{
|
|
||||||
const int width = image.width();
|
|
||||||
const int height = image.height();
|
|
||||||
|
|
||||||
const int centerX = qCeil(width * 0.5);
|
|
||||||
const int centerY = qCeil(height * 0.5);
|
|
||||||
|
|
||||||
const int alphaOffset = QSysInfo::ByteOrder == QSysInfo::BigEndian ? 0 : 3;
|
|
||||||
const int stride = image.depth() >> 3;
|
|
||||||
|
|
||||||
for (int y = 0; y < centerY; ++y) {
|
|
||||||
uint8_t *in = image.scanLine(y) + alphaOffset;
|
|
||||||
uint8_t *out = in + (width - 1) * stride;
|
|
||||||
|
|
||||||
for (int x = 0; x < centerX; ++x, in += stride, out -= stride) {
|
|
||||||
*out = *in;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for (int y = 0; y < centerY; ++y) {
|
|
||||||
const uint8_t *in = image.scanLine(y) + alphaOffset;
|
|
||||||
uint8_t *out = image.scanLine(width - y - 1) + alphaOffset;
|
|
||||||
|
|
||||||
for (int x = 0; x < width; ++x, in += stride, out += stride) {
|
|
||||||
*out = *in;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void renderShadow(QPainter *painter, const QRect &rect, qreal borderRadius, const QPoint &offset, int radius, const QColor &color)
|
|
||||||
{
|
|
||||||
const QSize inflation = calculateBlurExtent(radius);
|
|
||||||
const QSize size = rect.size() + 2 * inflation;
|
|
||||||
|
|
||||||
const qreal dpr = painter->device()->devicePixelRatioF();
|
|
||||||
|
|
||||||
QImage shadow(size * dpr, QImage::Format_ARGB32_Premultiplied);
|
|
||||||
shadow.setDevicePixelRatio(dpr);
|
|
||||||
shadow.fill(Qt::transparent);
|
|
||||||
|
|
||||||
QRect boxRect(QPoint(0, 0), rect.size());
|
|
||||||
boxRect.moveCenter(QRect(QPoint(0, 0), size).center());
|
|
||||||
|
|
||||||
const qreal xRadius = 2.0 * borderRadius / boxRect.width();
|
|
||||||
const qreal yRadius = 2.0 * borderRadius / boxRect.height();
|
|
||||||
|
|
||||||
QPainter shadowPainter;
|
|
||||||
shadowPainter.begin(&shadow);
|
|
||||||
shadowPainter.setRenderHint(QPainter::Antialiasing);
|
|
||||||
shadowPainter.setPen(Qt::NoPen);
|
|
||||||
shadowPainter.setBrush(Qt::black);
|
|
||||||
shadowPainter.drawRoundedRect(boxRect, xRadius, yRadius);
|
|
||||||
shadowPainter.end();
|
|
||||||
|
|
||||||
// Because the shadow texture is symmetrical, that's enough to blur
|
|
||||||
// only the top-left quadrant and then mirror it.
|
|
||||||
const QRect blurRect(0, 0, qCeil(shadow.width() * 0.5), qCeil(shadow.height() * 0.5));
|
|
||||||
const int scaledRadius = qRound(radius * dpr);
|
|
||||||
boxBlurAlpha(shadow, scaledRadius, blurRect);
|
|
||||||
mirrorTopLeftQuadrant(shadow);
|
|
||||||
|
|
||||||
// Give the shadow a tint of the desired color.
|
|
||||||
shadowPainter.begin(&shadow);
|
|
||||||
shadowPainter.setCompositionMode(QPainter::CompositionMode_SourceIn);
|
|
||||||
shadowPainter.fillRect(shadow.rect(), color);
|
|
||||||
shadowPainter.end();
|
|
||||||
|
|
||||||
// Actually, present the shadow.
|
|
||||||
QRect shadowRect = shadow.rect();
|
|
||||||
shadowRect.setSize(shadowRect.size() / dpr);
|
|
||||||
shadowRect.moveCenter(rect.center() + offset);
|
|
||||||
painter->drawImage(shadowRect, shadow);
|
|
||||||
}
|
|
||||||
|
|
||||||
void BoxShadowRenderer::setBoxSize(const QSize &size)
|
|
||||||
{
|
|
||||||
m_boxSize = size;
|
|
||||||
}
|
|
||||||
|
|
||||||
void BoxShadowRenderer::setBorderRadius(qreal radius)
|
|
||||||
{
|
|
||||||
m_borderRadius = radius;
|
|
||||||
}
|
|
||||||
|
|
||||||
void BoxShadowRenderer::setDevicePixelRatio(qreal dpr)
|
|
||||||
{
|
|
||||||
m_dpr = dpr;
|
|
||||||
}
|
|
||||||
|
|
||||||
void BoxShadowRenderer::addShadow(const QPoint &offset, int radius, const QColor &color)
|
|
||||||
{
|
|
||||||
Shadow shadow = {};
|
|
||||||
shadow.offset = offset;
|
|
||||||
shadow.radius = radius;
|
|
||||||
shadow.color = color;
|
|
||||||
m_shadows.append(shadow);
|
|
||||||
}
|
|
||||||
|
|
||||||
QImage BoxShadowRenderer::render() const
|
|
||||||
{
|
|
||||||
if (m_shadows.isEmpty()) {
|
|
||||||
return {};
|
|
||||||
}
|
|
||||||
|
|
||||||
QSize canvasSize;
|
|
||||||
for (const Shadow &shadow : qAsConst(m_shadows)) {
|
|
||||||
canvasSize = canvasSize.expandedTo(
|
|
||||||
calculateMinimumShadowTextureSize(m_boxSize, shadow.radius, shadow.offset));
|
|
||||||
}
|
|
||||||
|
|
||||||
QImage canvas(canvasSize * m_dpr, QImage::Format_ARGB32_Premultiplied);
|
|
||||||
canvas.setDevicePixelRatio(m_dpr);
|
|
||||||
canvas.fill(Qt::transparent);
|
|
||||||
|
|
||||||
QRect boxRect(QPoint(0, 0), m_boxSize);
|
|
||||||
boxRect.moveCenter(QRect(QPoint(0, 0), canvasSize).center());
|
|
||||||
|
|
||||||
QPainter painter(&canvas);
|
|
||||||
for (const Shadow &shadow : qAsConst(m_shadows)) {
|
|
||||||
renderShadow(&painter, boxRect, m_borderRadius, shadow.offset, shadow.radius, shadow.color);
|
|
||||||
}
|
|
||||||
painter.end();
|
|
||||||
|
|
||||||
return canvas;
|
|
||||||
}
|
|
||||||
|
|
||||||
QSize BoxShadowRenderer::calculateMinimumBoxSize(int radius)
|
|
||||||
{
|
|
||||||
const QSize blurExtent = calculateBlurExtent(radius);
|
|
||||||
return 2 * blurExtent + QSize(1, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
QSize BoxShadowRenderer::calculateMinimumShadowTextureSize(const QSize &boxSize, int radius, const QPoint &offset)
|
|
||||||
{
|
|
||||||
return boxSize + 2 * calculateBlurExtent(radius) + QSize(qAbs(offset.x()), qAbs(offset.y()));
|
|
||||||
}
|
|
||||||
@ -1,97 +0,0 @@
|
|||||||
/*
|
|
||||||
* Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@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, write to the Free Software
|
|
||||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
||||||
*/
|
|
||||||
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
// Qt
|
|
||||||
#include <QColor>
|
|
||||||
#include <QImage>
|
|
||||||
#include <QPoint>
|
|
||||||
#include <QSize>
|
|
||||||
|
|
||||||
class BoxShadowRenderer
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
// Compiler generated constructors & destructor are fine.
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Set the size of the box.
|
|
||||||
* @param size The size of the box.
|
|
||||||
**/
|
|
||||||
void setBoxSize(const QSize &size);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Set the radius of box' corners.
|
|
||||||
* @param radius The border radius, in pixels.
|
|
||||||
**/
|
|
||||||
void setBorderRadius(qreal radius);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Set the device pixel ratio of the resulting shadow texture.
|
|
||||||
* @param dpr The device pixel ratio.
|
|
||||||
**/
|
|
||||||
void setDevicePixelRatio(qreal dpr);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Add a shadow.
|
|
||||||
* @param offset The offset of the shadow.
|
|
||||||
* @param radius The blur radius.
|
|
||||||
* @param color The color of the shadow.
|
|
||||||
**/
|
|
||||||
void addShadow(const QPoint &offset, int radius, const QColor &color);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Render the shadow.
|
|
||||||
**/
|
|
||||||
QImage render() const;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Calculate the minimum size of the box.
|
|
||||||
*
|
|
||||||
* This helper computes the minimum size of the box so the shadow behind it has
|
|
||||||
* full its strength.
|
|
||||||
*
|
|
||||||
* @param radius The blur radius of the shadow.
|
|
||||||
**/
|
|
||||||
static QSize calculateMinimumBoxSize(int radius);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Calculate the minimum size of the shadow texture.
|
|
||||||
*
|
|
||||||
* This helper computes the minimum size of the resulting texture so the shadow
|
|
||||||
* is not clipped.
|
|
||||||
*
|
|
||||||
* @param boxSize The size of the box.
|
|
||||||
* @param radius The blur radius.
|
|
||||||
* @param offset The offset of the shadow.
|
|
||||||
**/
|
|
||||||
static QSize calculateMinimumShadowTextureSize(const QSize &boxSize, int radius, const QPoint &offset);
|
|
||||||
|
|
||||||
private:
|
|
||||||
QSize m_boxSize;
|
|
||||||
qreal m_borderRadius = 0.0;
|
|
||||||
qreal m_dpr = 1.0;
|
|
||||||
|
|
||||||
struct Shadow {
|
|
||||||
QPoint offset;
|
|
||||||
int radius;
|
|
||||||
QColor color;
|
|
||||||
};
|
|
||||||
|
|
||||||
QVector<Shadow> m_shadows;
|
|
||||||
};
|
|
||||||
@ -1,414 +0,0 @@
|
|||||||
/*************************************************************************
|
|
||||||
* Copyright (C) 2014 by Hugo Pereira Da Costa <hugo.pereira@free.fr> *
|
|
||||||
* Copyright (C) 2018, 2020 by Vlad Zahorodnii <vlad.zahorodnii@kde.org> *
|
|
||||||
* Copyright (C) 2020, 2020 by Reven Martin <revenmartin@gmail.com> *
|
|
||||||
* *
|
|
||||||
* 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, write to the *
|
|
||||||
* Free Software Foundation, Inc., *
|
|
||||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
|
|
||||||
*************************************************************************/
|
|
||||||
|
|
||||||
#include "shadowhelper.h"
|
|
||||||
#include "boxshadowrenderer.h"
|
|
||||||
|
|
||||||
#include <QDockWidget>
|
|
||||||
#include <QEvent>
|
|
||||||
#include <QApplication>
|
|
||||||
#include <QMenu>
|
|
||||||
#include <QPainter>
|
|
||||||
#include <QPixmap>
|
|
||||||
#include <QPlatformSurfaceEvent>
|
|
||||||
#include <QToolBar>
|
|
||||||
#include <QTextStream>
|
|
||||||
|
|
||||||
#include <KWindowSystem>
|
|
||||||
|
|
||||||
const char netWMSkipShadow[] = "_CUTEFISH_NET_WM_SKIP_SHADOW";
|
|
||||||
const char netWMForceShadow[] = "_CUTEFISH_NET_WM_FORCE_SHADOW";
|
|
||||||
const char netWMFrameRadius[] = "_CUTEFISH_NET_WM_FRAME_RADIUS";
|
|
||||||
|
|
||||||
enum {
|
|
||||||
ShadowNone,
|
|
||||||
ShadowSmall,
|
|
||||||
ShadowMedium,
|
|
||||||
ShadowLarge,
|
|
||||||
ShadowVeryLarge
|
|
||||||
};
|
|
||||||
|
|
||||||
const CompositeShadowParams s_shadowParams[] = {
|
|
||||||
// None
|
|
||||||
CompositeShadowParams(),
|
|
||||||
// Small
|
|
||||||
CompositeShadowParams(
|
|
||||||
QPoint(0, 3),
|
|
||||||
ShadowParams(QPoint(0, 0), 16, 0.26),
|
|
||||||
ShadowParams(QPoint(0, -2), 8, 0.16)),
|
|
||||||
// Medium
|
|
||||||
CompositeShadowParams(
|
|
||||||
QPoint(0, 4),
|
|
||||||
ShadowParams(QPoint(0, 0), 20, 0.24),
|
|
||||||
ShadowParams(QPoint(0, -2), 10, 0.14)),
|
|
||||||
// Large
|
|
||||||
CompositeShadowParams(
|
|
||||||
QPoint(0, 5),
|
|
||||||
ShadowParams(QPoint(0, 0), 24, 0.22),
|
|
||||||
ShadowParams(QPoint(0, -3), 12, 0.12)),
|
|
||||||
// Very Large
|
|
||||||
CompositeShadowParams(
|
|
||||||
QPoint(0, 6),
|
|
||||||
ShadowParams(QPoint(0, 0), 32, 0.2),
|
|
||||||
ShadowParams(QPoint(0, -3), 16, 0.1))
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
ShadowHelper::ShadowHelper(QObject * parent)
|
|
||||||
: QObject(parent),
|
|
||||||
m_frameRadius(12)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
ShadowHelper::~ShadowHelper()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
CompositeShadowParams ShadowHelper::lookupShadowParams(int shadowSizeEnum)
|
|
||||||
{
|
|
||||||
switch (shadowSizeEnum) {
|
|
||||||
case ShadowNone:
|
|
||||||
return s_shadowParams[0];
|
|
||||||
case ShadowSmall:
|
|
||||||
return s_shadowParams[1];
|
|
||||||
case ShadowMedium:
|
|
||||||
return s_shadowParams[2];
|
|
||||||
case ShadowLarge:
|
|
||||||
return s_shadowParams[3];
|
|
||||||
case ShadowVeryLarge:
|
|
||||||
return s_shadowParams[4];
|
|
||||||
default:
|
|
||||||
// Fallback to the Large size.
|
|
||||||
return s_shadowParams[3];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ShadowHelper::registerWidget(QWidget *widget, bool force)
|
|
||||||
{
|
|
||||||
// make sure widget is not already registered
|
|
||||||
if (m_widgets.contains(widget))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// check if widget qualifies
|
|
||||||
if (!(force || acceptWidget(widget)))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
qreal frameRadius = m_frameRadius;
|
|
||||||
const auto frameRadiusProperty = widget->property(netWMFrameRadius);
|
|
||||||
if (frameRadiusProperty.isValid())
|
|
||||||
frameRadius = frameRadiusProperty.toReal();
|
|
||||||
|
|
||||||
installShadows(widget, shadowTiles(frameRadius));
|
|
||||||
m_widgets.insert(widget);
|
|
||||||
|
|
||||||
// install event filter
|
|
||||||
widget->removeEventFilter(this);
|
|
||||||
widget->installEventFilter(this);
|
|
||||||
|
|
||||||
// connect destroy signal
|
|
||||||
connect(widget, &QObject::destroyed, this, &ShadowHelper::objectDeleted);
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
void ShadowHelper::unregisterWidget(QWidget *widget)
|
|
||||||
{
|
|
||||||
if (m_widgets.remove(widget)) {
|
|
||||||
// uninstall the event filter
|
|
||||||
widget->removeEventFilter(this);
|
|
||||||
|
|
||||||
// disconnect all signals
|
|
||||||
disconnect(widget, nullptr, this, nullptr);
|
|
||||||
|
|
||||||
// uninstall the shadow
|
|
||||||
uninstallShadows(widget);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ShadowHelper::eventFilter(QObject *object, QEvent *event)
|
|
||||||
{
|
|
||||||
if (KWindowSystem::isPlatformX11()) {
|
|
||||||
// check event type
|
|
||||||
if (event->type() == QEvent::WinIdChange) {
|
|
||||||
QWidget *widget = static_cast<QWidget *>(object);
|
|
||||||
|
|
||||||
qreal frameRadius = m_frameRadius;
|
|
||||||
const auto frameRadiusProperty = widget->property(netWMFrameRadius);
|
|
||||||
if (frameRadiusProperty.isValid())
|
|
||||||
frameRadius = frameRadiusProperty.toReal();
|
|
||||||
TileSet shadowTileSet = shadowTiles(frameRadius);
|
|
||||||
installShadows(widget, shadowTileSet);
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if (event->type() != QEvent::PlatformSurface)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// QWidget *widget(static_cast<QWidget *>(object));
|
|
||||||
QPlatformSurfaceEvent* surfaceEvent(static_cast<QPlatformSurfaceEvent*>(event));
|
|
||||||
|
|
||||||
switch (surfaceEvent->surfaceEventType()) {
|
|
||||||
case QPlatformSurfaceEvent::SurfaceCreated:
|
|
||||||
//installShadows(widget);
|
|
||||||
break;
|
|
||||||
case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
|
|
||||||
// Don't care.
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
TileSet ShadowHelper::shadowTiles(const qreal frameRadius)
|
|
||||||
{
|
|
||||||
const CompositeShadowParams params = lookupShadowParams(ShadowVeryLarge);
|
|
||||||
|
|
||||||
if (params.isNone())
|
|
||||||
return TileSet();
|
|
||||||
// } else if (_shadowTiles.isValid()) {
|
|
||||||
// return _shadowTiles;
|
|
||||||
// }
|
|
||||||
|
|
||||||
auto withOpacity = [](const QColor &color, qreal opacity) -> QColor {
|
|
||||||
QColor c(color);
|
|
||||||
c.setAlphaF(opacity);
|
|
||||||
return c;
|
|
||||||
};
|
|
||||||
|
|
||||||
const QColor color = Qt::black;
|
|
||||||
// const qreal strength = static_cast<qreal>(255) / 255.0;
|
|
||||||
const qreal strength = 1.5;
|
|
||||||
|
|
||||||
const QSize boxSize = BoxShadowRenderer::calculateMinimumBoxSize(params.shadow1.radius)
|
|
||||||
.expandedTo(BoxShadowRenderer::calculateMinimumBoxSize(params.shadow2.radius));
|
|
||||||
|
|
||||||
const qreal dpr = qApp->devicePixelRatio();
|
|
||||||
|
|
||||||
BoxShadowRenderer shadowRenderer;
|
|
||||||
shadowRenderer.setBorderRadius(frameRadius);
|
|
||||||
shadowRenderer.setBoxSize(boxSize);
|
|
||||||
shadowRenderer.setDevicePixelRatio(dpr);
|
|
||||||
|
|
||||||
shadowRenderer.addShadow(params.shadow1.offset, params.shadow1.radius,
|
|
||||||
withOpacity(color, params.shadow1.opacity * strength));
|
|
||||||
shadowRenderer.addShadow(params.shadow2.offset, params.shadow2.radius,
|
|
||||||
withOpacity(color, params.shadow2.opacity * strength));
|
|
||||||
|
|
||||||
QImage shadowTexture = shadowRenderer.render();
|
|
||||||
|
|
||||||
const QRect outerRect(QPoint(0, 0), shadowTexture.size() / dpr);
|
|
||||||
|
|
||||||
QRect boxRect(QPoint(0, 0), boxSize);
|
|
||||||
boxRect.moveCenter(outerRect.center());
|
|
||||||
|
|
||||||
// Mask out inner rect.
|
|
||||||
QPainter painter(&shadowTexture);
|
|
||||||
painter.setRenderHint(QPainter::Antialiasing);
|
|
||||||
|
|
||||||
int Shadow_Overlap = 3;
|
|
||||||
const QMargins margins = QMargins(
|
|
||||||
boxRect.left() - outerRect.left() - Shadow_Overlap - params.offset.x(),
|
|
||||||
boxRect.top() - outerRect.top() - Shadow_Overlap - params.offset.y(),
|
|
||||||
outerRect.right() - boxRect.right() - Shadow_Overlap + params.offset.x(),
|
|
||||||
outerRect.bottom() - boxRect.bottom() - Shadow_Overlap + params.offset.y());
|
|
||||||
|
|
||||||
painter.setPen(Qt::NoPen);
|
|
||||||
painter.setBrush(Qt::black);
|
|
||||||
painter.setCompositionMode(QPainter::CompositionMode_DestinationOut);
|
|
||||||
painter.drawRoundedRect(
|
|
||||||
outerRect - margins,
|
|
||||||
frameRadius,
|
|
||||||
frameRadius);
|
|
||||||
|
|
||||||
// We're done.
|
|
||||||
painter.end();
|
|
||||||
|
|
||||||
const QPoint innerRectTopLeft = outerRect.center();
|
|
||||||
TileSet tiles = TileSet(
|
|
||||||
QPixmap::fromImage(shadowTexture),
|
|
||||||
innerRectTopLeft.x(),
|
|
||||||
innerRectTopLeft.y(),
|
|
||||||
1, 1);
|
|
||||||
|
|
||||||
return tiles;
|
|
||||||
}
|
|
||||||
|
|
||||||
void ShadowHelper::objectDeleted(QObject *object)
|
|
||||||
{
|
|
||||||
QWidget *widget(static_cast<QWidget *>(object));
|
|
||||||
m_widgets.remove(widget);
|
|
||||||
m_shadows.remove(widget);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ShadowHelper::isMenu(QWidget *widget) const
|
|
||||||
{
|
|
||||||
return qobject_cast<QMenu*>(widget);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ShadowHelper::isToolTip(QWidget *widget) const
|
|
||||||
{
|
|
||||||
return widget->inherits("QTipLabel") || (widget->windowFlags() & Qt::WindowType_Mask) == Qt::ToolTip;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ShadowHelper::isDockWidget(QWidget *widget) const
|
|
||||||
{
|
|
||||||
return qobject_cast<QDockWidget*>(widget);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ShadowHelper::isToolBar(QWidget *widget) const
|
|
||||||
{
|
|
||||||
return qobject_cast<QToolBar*>(widget);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ShadowHelper::acceptWidget(QWidget *widget) const
|
|
||||||
{
|
|
||||||
// flags
|
|
||||||
if (widget->property(netWMSkipShadow).toBool())
|
|
||||||
return false;
|
|
||||||
if (widget->property(netWMForceShadow).toBool())
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// menus
|
|
||||||
if (isMenu(widget))
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// combobox dropdown lists
|
|
||||||
if (widget->inherits("QComboBoxPrivateContainer"))
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// tooltips
|
|
||||||
if (isToolTip(widget) && !widget->inherits("Plasma::ToolTip"))
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// detached widgets
|
|
||||||
if (isDockWidget(widget) || isToolBar(widget))
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// reject
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
KWindowShadowTile::Ptr ShadowHelper::createTile(const QPixmap& source)
|
|
||||||
{
|
|
||||||
KWindowShadowTile::Ptr tile = KWindowShadowTile::Ptr::create();
|
|
||||||
tile->setImage(source.toImage());
|
|
||||||
return tile;
|
|
||||||
}
|
|
||||||
|
|
||||||
void ShadowHelper::installShadows(QWidget *widget, TileSet shadowTiles)
|
|
||||||
{
|
|
||||||
if (!widget)
|
|
||||||
return;
|
|
||||||
|
|
||||||
// only toplevel widgets can cast drop-shadows
|
|
||||||
if (!widget->isWindow())
|
|
||||||
return;
|
|
||||||
|
|
||||||
// widget must have valid native window
|
|
||||||
if (!widget->testAttribute(Qt::WA_WState_Created))
|
|
||||||
return;
|
|
||||||
|
|
||||||
// create platform shadow tiles
|
|
||||||
QVector<KWindowShadowTile::Ptr> tiles = {
|
|
||||||
createTile(shadowTiles.pixmap(1)),
|
|
||||||
createTile(shadowTiles.pixmap(2)),
|
|
||||||
createTile(shadowTiles.pixmap(5)),
|
|
||||||
createTile(shadowTiles.pixmap(8)),
|
|
||||||
createTile(shadowTiles.pixmap(7)),
|
|
||||||
createTile(shadowTiles.pixmap(6)),
|
|
||||||
createTile(shadowTiles.pixmap(3)),
|
|
||||||
createTile(shadowTiles.pixmap(0))
|
|
||||||
};
|
|
||||||
if (tiles.count() != numTiles)
|
|
||||||
return;
|
|
||||||
|
|
||||||
// find a shadow associated with the widget
|
|
||||||
KWindowShadow*& shadow = m_shadows[ widget ];
|
|
||||||
|
|
||||||
if (!shadow)
|
|
||||||
shadow = new KWindowShadow(widget);
|
|
||||||
|
|
||||||
if (shadow->isCreated())
|
|
||||||
shadow->destroy();
|
|
||||||
|
|
||||||
shadow->setTopTile(tiles[ 0 ]);
|
|
||||||
shadow->setTopRightTile(tiles[ 1 ]);
|
|
||||||
shadow->setRightTile(tiles[ 2 ]);
|
|
||||||
shadow->setBottomRightTile(tiles[ 3 ]);
|
|
||||||
shadow->setBottomTile(tiles[ 4 ]);
|
|
||||||
shadow->setBottomLeftTile(tiles[ 5 ]);
|
|
||||||
shadow->setLeftTile(tiles[ 6 ]);
|
|
||||||
shadow->setTopLeftTile(tiles[ 7 ]);
|
|
||||||
shadow->setPadding(shadowMargins(widget, shadowTiles));
|
|
||||||
shadow->setWindow(widget->windowHandle());
|
|
||||||
shadow->create();
|
|
||||||
}
|
|
||||||
|
|
||||||
QMargins ShadowHelper::shadowMargins(QWidget *widget, TileSet shadowTiles) const
|
|
||||||
{
|
|
||||||
const CompositeShadowParams params = lookupShadowParams(ShadowVeryLarge);
|
|
||||||
if (params.isNone())
|
|
||||||
return QMargins();
|
|
||||||
|
|
||||||
const QSize boxSize = BoxShadowRenderer::calculateMinimumBoxSize(params.shadow1.radius)
|
|
||||||
.expandedTo(BoxShadowRenderer::calculateMinimumBoxSize(params.shadow2.radius));
|
|
||||||
|
|
||||||
const QSize shadowSize = BoxShadowRenderer::calculateMinimumShadowTextureSize(boxSize, params.shadow1.radius, params.shadow1.offset)
|
|
||||||
.expandedTo(BoxShadowRenderer::calculateMinimumShadowTextureSize(boxSize, params.shadow2.radius, params.shadow2.offset));
|
|
||||||
|
|
||||||
const QRect shadowRect(QPoint(0, 0), shadowSize);
|
|
||||||
|
|
||||||
QRect boxRect(QPoint(0, 0), boxSize);
|
|
||||||
boxRect.moveCenter(shadowRect.center());
|
|
||||||
|
|
||||||
int Shadow_Overlap = 4;
|
|
||||||
QMargins margins(
|
|
||||||
boxRect.left() - shadowRect.left() - Shadow_Overlap - params.offset.x(),
|
|
||||||
boxRect.top() - shadowRect.top() - Shadow_Overlap - params.offset.y(),
|
|
||||||
shadowRect.right() - boxRect.right() - Shadow_Overlap + params.offset.x(),
|
|
||||||
shadowRect.bottom() - boxRect.bottom() - Shadow_Overlap + params.offset.y());
|
|
||||||
|
|
||||||
if (widget->inherits("QBalloonTip")) {
|
|
||||||
// Balloon tip needs special margins to deal with the arrow.
|
|
||||||
int top = widget->contentsMargins().top();
|
|
||||||
int bottom = widget->contentsMargins().bottom();
|
|
||||||
|
|
||||||
// Need to decrement default size further due to extra hard coded round corner.
|
|
||||||
margins -= 1;
|
|
||||||
|
|
||||||
// Arrow can be either to the top or the bottom. Adjust margins accordingly.
|
|
||||||
const int diff = qAbs(top - bottom);
|
|
||||||
if (top > bottom) {
|
|
||||||
margins.setTop(margins.top() - diff);
|
|
||||||
} else {
|
|
||||||
margins.setBottom(margins.bottom() - diff);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
margins *= shadowTiles.pixmap(0).devicePixelRatio();
|
|
||||||
|
|
||||||
return margins;
|
|
||||||
}
|
|
||||||
|
|
||||||
void ShadowHelper::uninstallShadows(QWidget *widget)
|
|
||||||
{
|
|
||||||
delete m_shadows.take(widget);
|
|
||||||
}
|
|
||||||
@ -1,148 +0,0 @@
|
|||||||
/*************************************************************************
|
|
||||||
* Copyright (C) 2014 by Hugo Pereira Da Costa <hugo.pereira@free.fr> *
|
|
||||||
* Copyright (C) 2020 by Vlad Zahorodnii <vlad.zahorodnii@kde.org> *
|
|
||||||
* Copyright (C) 2020, 2020 by Reven Martin <revenmartin@gmail.com> *
|
|
||||||
* *
|
|
||||||
* 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, write to the *
|
|
||||||
* Free Software Foundation, Inc., *
|
|
||||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
|
|
||||||
*************************************************************************/
|
|
||||||
|
|
||||||
#ifndef SHADOWHELPER_H
|
|
||||||
#define SHADOWHELPER_H
|
|
||||||
|
|
||||||
#include "tileset.h"
|
|
||||||
#include <KWindowShadow>
|
|
||||||
|
|
||||||
#include <QObject>
|
|
||||||
#include <QPointer>
|
|
||||||
#include <QMap>
|
|
||||||
#include <QMargins>
|
|
||||||
#include <QSet>
|
|
||||||
|
|
||||||
struct ShadowParams
|
|
||||||
{
|
|
||||||
ShadowParams() = default;
|
|
||||||
|
|
||||||
ShadowParams(const QPoint &offset, int radius, qreal opacity):
|
|
||||||
offset(offset),
|
|
||||||
radius(radius),
|
|
||||||
opacity(opacity)
|
|
||||||
{}
|
|
||||||
|
|
||||||
QPoint offset;
|
|
||||||
int radius = 0;
|
|
||||||
qreal opacity = 0;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct CompositeShadowParams
|
|
||||||
{
|
|
||||||
CompositeShadowParams() = default;
|
|
||||||
|
|
||||||
CompositeShadowParams(
|
|
||||||
const QPoint &offset,
|
|
||||||
const ShadowParams &shadow1,
|
|
||||||
const ShadowParams &shadow2)
|
|
||||||
: offset(offset)
|
|
||||||
, shadow1(shadow1)
|
|
||||||
, shadow2(shadow2) {}
|
|
||||||
|
|
||||||
bool isNone() const
|
|
||||||
{ return qMax(shadow1.radius, shadow2.radius) == 0; }
|
|
||||||
|
|
||||||
QPoint offset;
|
|
||||||
ShadowParams shadow1;
|
|
||||||
ShadowParams shadow2;
|
|
||||||
};
|
|
||||||
|
|
||||||
//* handle shadow pixmaps passed to window manager via X property
|
|
||||||
class ShadowHelper: public QObject
|
|
||||||
{
|
|
||||||
Q_OBJECT
|
|
||||||
|
|
||||||
public:
|
|
||||||
//* constructor
|
|
||||||
ShadowHelper(QObject *);
|
|
||||||
|
|
||||||
//* destructor
|
|
||||||
~ShadowHelper() override;
|
|
||||||
|
|
||||||
//* shadow params from size enum
|
|
||||||
static CompositeShadowParams lookupShadowParams(int shadowSizeEnum);
|
|
||||||
|
|
||||||
//* register widget
|
|
||||||
bool registerWidget(QWidget *, bool force = false);
|
|
||||||
|
|
||||||
//* unregister widget
|
|
||||||
void unregisterWidget(QWidget *);
|
|
||||||
|
|
||||||
//* event filter
|
|
||||||
bool eventFilter(QObject *, QEvent *) override;
|
|
||||||
|
|
||||||
void setFrameRadius(qreal radius) { m_frameRadius = radius; }
|
|
||||||
|
|
||||||
//* shadow tiles
|
|
||||||
/** is public because it is also needed for mdi windows */
|
|
||||||
// TileSet shadowTiles();
|
|
||||||
|
|
||||||
TileSet shadowTiles(const qreal frameRadius);
|
|
||||||
|
|
||||||
protected Q_SLOTS:
|
|
||||||
//* unregister widget
|
|
||||||
void objectDeleted(QObject *);
|
|
||||||
|
|
||||||
protected:
|
|
||||||
//* true if widget is a menu
|
|
||||||
bool isMenu(QWidget *) const;
|
|
||||||
|
|
||||||
//* true if widget is a tooltip
|
|
||||||
bool isToolTip(QWidget *) const;
|
|
||||||
|
|
||||||
//* dock widget
|
|
||||||
bool isDockWidget(QWidget *) const;
|
|
||||||
|
|
||||||
//* toolbar
|
|
||||||
bool isToolBar(QWidget *) const;
|
|
||||||
|
|
||||||
//* accept widget
|
|
||||||
bool acceptWidget(QWidget *) const;
|
|
||||||
|
|
||||||
// create shadow tile from pixmap
|
|
||||||
KWindowShadowTile::Ptr createTile(const QPixmap &);
|
|
||||||
|
|
||||||
//* installs shadow on given widget in a platform independent way
|
|
||||||
// void installShadows( QWidget * );
|
|
||||||
|
|
||||||
void installShadows(QWidget *widget, TileSet shadowTiles);
|
|
||||||
|
|
||||||
//* uninstalls shadow on given widget in a platform independent way
|
|
||||||
void uninstallShadows(QWidget *);
|
|
||||||
|
|
||||||
//* gets the shadow margins for the given widget
|
|
||||||
QMargins shadowMargins(QWidget*, TileSet) const;
|
|
||||||
|
|
||||||
private:
|
|
||||||
//* registered widgets
|
|
||||||
QSet<QWidget *> m_widgets;
|
|
||||||
|
|
||||||
//* managed shadows
|
|
||||||
QMap<QWidget *, KWindowShadow *> m_shadows;
|
|
||||||
|
|
||||||
qreal m_frameRadius;
|
|
||||||
|
|
||||||
//* number of tiles
|
|
||||||
enum { numTiles = 8 };
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,183 +0,0 @@
|
|||||||
/*************************************************************************
|
|
||||||
* Copyright (C) 2014 by Hugo Pereira Da Costa <hugo.pereira@free.fr> *
|
|
||||||
* *
|
|
||||||
* 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, write to the *
|
|
||||||
* Free Software Foundation, Inc., *
|
|
||||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
|
|
||||||
*************************************************************************/
|
|
||||||
|
|
||||||
#include "tileset.h"
|
|
||||||
|
|
||||||
#include <QPainter>
|
|
||||||
|
|
||||||
//___________________________________________________________
|
|
||||||
inline bool bits(TileSet::Tiles flags, TileSet::Tiles testFlags)
|
|
||||||
{ return (flags & testFlags) == testFlags; }
|
|
||||||
|
|
||||||
//______________________________________________________________________________________
|
|
||||||
inline qreal devicePixelRatio( const QPixmap& pixmap )
|
|
||||||
{
|
|
||||||
return pixmap.devicePixelRatio();
|
|
||||||
}
|
|
||||||
|
|
||||||
//______________________________________________________________________________________
|
|
||||||
inline void setDevicePixelRatio( QPixmap& pixmap, qreal value )
|
|
||||||
{
|
|
||||||
return pixmap.setDevicePixelRatio( value );
|
|
||||||
}
|
|
||||||
|
|
||||||
//______________________________________________________________
|
|
||||||
void TileSet::initPixmap( PixmapList& pixmaps, const QPixmap &source, int width, int height, const QRect &rect)
|
|
||||||
{
|
|
||||||
QSize size( width, height );
|
|
||||||
if( !( size.isValid() && rect.isValid() ) )
|
|
||||||
{
|
|
||||||
pixmaps.append( QPixmap() );
|
|
||||||
|
|
||||||
} else if( size != rect.size() ) {
|
|
||||||
|
|
||||||
const qreal dpiRatio( devicePixelRatio( source ) );
|
|
||||||
const QRect scaledRect( rect.topLeft()*dpiRatio, rect.size()*dpiRatio );
|
|
||||||
const QSize scaledSize( size*dpiRatio );
|
|
||||||
const QPixmap tile( source.copy(scaledRect) );
|
|
||||||
QPixmap pixmap( scaledSize );
|
|
||||||
|
|
||||||
pixmap.fill(Qt::transparent);
|
|
||||||
QPainter painter(&pixmap);
|
|
||||||
painter.drawTiledPixmap(0, 0, scaledSize.width(), scaledSize.height(), tile);
|
|
||||||
setDevicePixelRatio( pixmap, dpiRatio );
|
|
||||||
pixmaps.append( pixmap );
|
|
||||||
|
|
||||||
} else {
|
|
||||||
|
|
||||||
const qreal dpiRatio( devicePixelRatio( source ) );
|
|
||||||
const QRect scaledRect( rect.topLeft()*dpiRatio, rect.size()*dpiRatio );
|
|
||||||
QPixmap pixmap( source.copy( scaledRect ) );
|
|
||||||
setDevicePixelRatio( pixmap, dpiRatio );
|
|
||||||
pixmaps.append( pixmap );
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
//______________________________________________________________
|
|
||||||
TileSet::TileSet():
|
|
||||||
_w1(0),
|
|
||||||
_h1(0),
|
|
||||||
_w3(0),
|
|
||||||
_h3(0)
|
|
||||||
{ _pixmaps.reserve(9); }
|
|
||||||
|
|
||||||
//______________________________________________________________
|
|
||||||
TileSet::TileSet(const QPixmap &source, int w1, int h1, int w2, int h2 ):
|
|
||||||
_w1(w1),
|
|
||||||
_h1(h1),
|
|
||||||
_w3(0),
|
|
||||||
_h3(0)
|
|
||||||
{
|
|
||||||
_pixmaps.reserve(9);
|
|
||||||
if( source.isNull() ) return;
|
|
||||||
|
|
||||||
_w3 = source.width()/devicePixelRatio( source ) - (w1 + w2);
|
|
||||||
_h3 = source.height()/devicePixelRatio( source ) - (h1 + h2);
|
|
||||||
int w = w2;
|
|
||||||
int h = h2;
|
|
||||||
|
|
||||||
// initialise pixmap array
|
|
||||||
initPixmap( _pixmaps, source, _w1, _h1, QRect(0, 0, _w1, _h1) );
|
|
||||||
initPixmap( _pixmaps, source, w, _h1, QRect(_w1, 0, w2, _h1) );
|
|
||||||
initPixmap( _pixmaps, source, _w3, _h1, QRect(_w1+w2, 0, _w3, _h1) );
|
|
||||||
initPixmap( _pixmaps, source, _w1, h, QRect(0, _h1, _w1, h2) );
|
|
||||||
initPixmap( _pixmaps, source, w, h, QRect(_w1, _h1, w2, h2) );
|
|
||||||
initPixmap( _pixmaps, source, _w3, h, QRect(_w1+w2, _h1, _w3, h2) );
|
|
||||||
initPixmap( _pixmaps, source, _w1, _h3, QRect(0, _h1+h2, _w1, _h3) );
|
|
||||||
initPixmap( _pixmaps, source, w, _h3, QRect(_w1, _h1+h2, w2, _h3) );
|
|
||||||
initPixmap( _pixmaps, source, _w3, _h3, QRect(_w1+w2, _h1+h2, _w3, _h3) );
|
|
||||||
}
|
|
||||||
|
|
||||||
//___________________________________________________________
|
|
||||||
void TileSet::render(const QRect &constRect, QPainter *painter, Tiles tiles) const
|
|
||||||
{
|
|
||||||
|
|
||||||
const bool oldHint( painter->testRenderHint( QPainter::SmoothPixmapTransform ) );
|
|
||||||
painter->setRenderHint( QPainter::SmoothPixmapTransform, true );
|
|
||||||
|
|
||||||
// check initialization
|
|
||||||
if( _pixmaps.size() < 9 ) return;
|
|
||||||
|
|
||||||
// copy source rect
|
|
||||||
QRect rect( constRect );
|
|
||||||
|
|
||||||
// get rect dimensions
|
|
||||||
int x0, y0, w, h;
|
|
||||||
rect.getRect(&x0, &y0, &w, &h);
|
|
||||||
|
|
||||||
// calculate pixmaps widths
|
|
||||||
int wLeft(0);
|
|
||||||
int wRight(0);
|
|
||||||
if( _w1+_w3 > 0 )
|
|
||||||
{
|
|
||||||
qreal wRatio( qreal( _w1 )/qreal( _w1 + _w3 ) );
|
|
||||||
wLeft = (tiles&Right) ? qMin( _w1, int(w*wRatio) ):_w1;
|
|
||||||
wRight = (tiles&Left) ? qMin( _w3, int(w*(1.0-wRatio)) ):_w3;
|
|
||||||
}
|
|
||||||
|
|
||||||
// calculate pixmap heights
|
|
||||||
int hTop(0);
|
|
||||||
int hBottom(0);
|
|
||||||
if( _h1+_h3 > 0 )
|
|
||||||
{
|
|
||||||
qreal hRatio( qreal( _h1 )/qreal( _h1 + _h3 ) );
|
|
||||||
hTop = (tiles&Bottom) ? qMin( _h1, int(h*hRatio) ):_h1;
|
|
||||||
hBottom = (tiles&Top) ? qMin( _h3, int(h*(1.0-hRatio)) ):_h3;
|
|
||||||
}
|
|
||||||
|
|
||||||
// calculate corner locations
|
|
||||||
w -= wLeft + wRight;
|
|
||||||
h -= hTop + hBottom;
|
|
||||||
const int x1 = x0 + wLeft;
|
|
||||||
const int x2 = x1 + w;
|
|
||||||
const int y1 = y0 + hTop;
|
|
||||||
const int y2 = y1 + h;
|
|
||||||
|
|
||||||
const int w2 = _pixmaps.at(7).width()/devicePixelRatio( _pixmaps.at(7) );
|
|
||||||
const int h2 = _pixmaps.at(5).height()/devicePixelRatio( _pixmaps.at(5) );
|
|
||||||
|
|
||||||
// corner
|
|
||||||
if( bits( tiles, Top|Left) ) painter->drawPixmap(x0, y0, _pixmaps.at(0), 0, 0, wLeft*devicePixelRatio( _pixmaps.at(0) ), hTop*devicePixelRatio( _pixmaps.at(0) ));
|
|
||||||
if( bits( tiles, Top|Right) ) painter->drawPixmap(x2, y0, _pixmaps.at(2), (_w3-wRight)*devicePixelRatio( _pixmaps.at(2) ), 0, wRight*devicePixelRatio( _pixmaps.at(2) ), hTop*devicePixelRatio( _pixmaps.at(2) ) );
|
|
||||||
if( bits( tiles, Bottom|Left) ) painter->drawPixmap(x0, y2, _pixmaps.at(6), 0, (_h3-hBottom)*devicePixelRatio( _pixmaps.at(6) ), wLeft*devicePixelRatio( _pixmaps.at(6) ), hBottom*devicePixelRatio( _pixmaps.at(6) ));
|
|
||||||
if( bits( tiles, Bottom|Right) ) painter->drawPixmap(x2, y2, _pixmaps.at(8), (_w3-wRight)*devicePixelRatio( _pixmaps.at(8) ), (_h3-hBottom)*devicePixelRatio( _pixmaps.at(8) ), wRight*devicePixelRatio( _pixmaps.at(8) ), hBottom*devicePixelRatio( _pixmaps.at(8) ) );
|
|
||||||
|
|
||||||
// top and bottom
|
|
||||||
if( w > 0 )
|
|
||||||
{
|
|
||||||
if( tiles&Top ) painter->drawPixmap(x1, y0, w, hTop, _pixmaps.at(1), 0, 0, w2*devicePixelRatio( _pixmaps.at(1) ), hTop*devicePixelRatio( _pixmaps.at(1) ) );
|
|
||||||
if( tiles&Bottom ) painter->drawPixmap(x1, y2, w, hBottom, _pixmaps.at(7), 0, (_h3-hBottom)*devicePixelRatio( _pixmaps.at(7) ), w2*devicePixelRatio( _pixmaps.at(7) ), hBottom*devicePixelRatio( _pixmaps.at(7) ) );
|
|
||||||
}
|
|
||||||
|
|
||||||
// left and right
|
|
||||||
if( h > 0 )
|
|
||||||
{
|
|
||||||
if( tiles&Left ) painter->drawPixmap(x0, y1, wLeft, h, _pixmaps.at(3), 0, 0, wLeft*devicePixelRatio( _pixmaps.at(3) ), h2*devicePixelRatio( _pixmaps.at(3) ) );
|
|
||||||
if( tiles&Right ) painter->drawPixmap(x2, y1, wRight, h, _pixmaps.at(5), (_w3-wRight)*devicePixelRatio( _pixmaps.at(5) ), 0, wRight*devicePixelRatio( _pixmaps.at(5) ), h2*devicePixelRatio( _pixmaps.at(5) ) );
|
|
||||||
}
|
|
||||||
|
|
||||||
// center
|
|
||||||
if( (tiles&Center) && h > 0 && w > 0 ) painter->drawPixmap(x1, y1, w, h, _pixmaps.at(4));
|
|
||||||
|
|
||||||
// restore
|
|
||||||
painter->setRenderHint( QPainter::SmoothPixmapTransform, oldHint );
|
|
||||||
|
|
||||||
}
|
|
||||||
@ -1,121 +0,0 @@
|
|||||||
#ifndef TILESET_H
|
|
||||||
#define TILESET_H
|
|
||||||
|
|
||||||
/*************************************************************************
|
|
||||||
* Copyright (C) 2014 by Hugo Pereira Da Costa <hugo.pereira@free.fr> *
|
|
||||||
* *
|
|
||||||
* 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, write to the *
|
|
||||||
* Free Software Foundation, Inc., *
|
|
||||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
|
|
||||||
*************************************************************************/
|
|
||||||
|
|
||||||
|
|
||||||
#include <QPixmap>
|
|
||||||
#include <QRect>
|
|
||||||
#include <QVector>
|
|
||||||
|
|
||||||
//* handles proper scaling of pixmap to match widget rect.
|
|
||||||
/**
|
|
||||||
tilesets are collections of stretchable pixmaps corresponding to a given widget corners, sides, and center.
|
|
||||||
corner pixmaps are never stretched. center pixmaps are
|
|
||||||
*/
|
|
||||||
class TileSet
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
/**
|
|
||||||
Create a TileSet from a pixmap. The size of the bottom/right chunks is
|
|
||||||
whatever is left over from the other chunks, whose size is specified
|
|
||||||
in the required parameters.
|
|
||||||
|
|
||||||
@param w1 width of the left chunks
|
|
||||||
@param h1 height of the top chunks
|
|
||||||
@param w2 width of the not-left-or-right chunks
|
|
||||||
@param h2 height of the not-top-or-bottom chunks
|
|
||||||
*/
|
|
||||||
TileSet(const QPixmap&, int w1, int h1, int w2, int h2 );
|
|
||||||
|
|
||||||
//* empty constructor
|
|
||||||
TileSet();
|
|
||||||
|
|
||||||
//* destructor
|
|
||||||
virtual ~TileSet()
|
|
||||||
{}
|
|
||||||
|
|
||||||
/**
|
|
||||||
Flags specifying what sides to draw in ::render. Corners are drawn when
|
|
||||||
the sides forming that corner are drawn, e.g. Top|Left draws the
|
|
||||||
top-center, center-left, and top-left chunks. The center-center chunk is
|
|
||||||
only drawn when Center is requested.
|
|
||||||
*/
|
|
||||||
enum Tile {
|
|
||||||
Top = 0x1,
|
|
||||||
Left = 0x2,
|
|
||||||
Bottom = 0x4,
|
|
||||||
Right = 0x8,
|
|
||||||
Center = 0x10,
|
|
||||||
TopLeft = Top|Left,
|
|
||||||
TopRight = Top|Right,
|
|
||||||
BottomLeft = Bottom|Left,
|
|
||||||
BottomRight = Bottom|Right,
|
|
||||||
Ring = Top|Left|Bottom|Right,
|
|
||||||
Horizontal = Left|Right|Center,
|
|
||||||
Vertical = Top|Bottom|Center,
|
|
||||||
Full = Ring|Center
|
|
||||||
};
|
|
||||||
Q_DECLARE_FLAGS(Tiles, Tile)
|
|
||||||
|
|
||||||
/**
|
|
||||||
Fills the specified rect with tiled chunks. Corners are never tiled,
|
|
||||||
edges are tiled in one direction, and the center chunk is tiled in both
|
|
||||||
directions. Partial tiles are used as needed so that the entire rect is
|
|
||||||
perfectly filled. Filling is performed as if all chunks are being drawn.
|
|
||||||
*/
|
|
||||||
void render(const QRect&, QPainter*, Tiles = Ring) const;
|
|
||||||
|
|
||||||
//* return size associated to this tileset
|
|
||||||
QSize size() const
|
|
||||||
{ return QSize( _w1 + _w3, _h1 + _h3 ); }
|
|
||||||
|
|
||||||
//* is valid
|
|
||||||
bool isValid() const
|
|
||||||
{ return _pixmaps.size() == 9; }
|
|
||||||
|
|
||||||
//* returns pixmap for given index
|
|
||||||
QPixmap pixmap( int index ) const
|
|
||||||
{ return _pixmaps[index]; }
|
|
||||||
|
|
||||||
protected:
|
|
||||||
|
|
||||||
//* shortcut to pixmap list
|
|
||||||
using PixmapList = QVector<QPixmap>;
|
|
||||||
|
|
||||||
//* initialize pixmap
|
|
||||||
void initPixmap( PixmapList&, const QPixmap&, int w, int h, const QRect& );
|
|
||||||
|
|
||||||
private:
|
|
||||||
|
|
||||||
//* pixmap arry
|
|
||||||
PixmapList _pixmaps;
|
|
||||||
|
|
||||||
// dimensions
|
|
||||||
int _w1;
|
|
||||||
int _h1;
|
|
||||||
int _w3;
|
|
||||||
int _h3;
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
Q_DECLARE_OPERATORS_FOR_FLAGS(TileSet::Tiles)
|
|
||||||
|
|
||||||
#endif //TILESET_H
|
|
||||||
@ -1,21 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <QGuiApplication>
|
|
||||||
#include <QtGui/qguiapplication_platform.h>
|
|
||||||
|
|
||||||
#include <xcb/xcb.h>
|
|
||||||
|
|
||||||
namespace Cutefish::X11
|
|
||||||
{
|
|
||||||
inline xcb_window_t rootWindow()
|
|
||||||
{
|
|
||||||
const auto native = qGuiApp ? qGuiApp->nativeInterface<QNativeInterface::QX11Application>() : nullptr;
|
|
||||||
const auto c = native ? native->connection() : nullptr;
|
|
||||||
if (!c)
|
|
||||||
return XCB_WINDOW_NONE;
|
|
||||||
|
|
||||||
const auto *setup = xcb_get_setup(c);
|
|
||||||
const auto iterator = xcb_setup_roots_iterator(setup);
|
|
||||||
return iterator.data ? iterator.data->root : XCB_WINDOW_NONE;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue