Members of the KDE Community are recommended to subscribe to the kde-community mailing list at https://mail.kde.org/mailman/listinfo/kde-community to allow them to participate in important discussions and receive other important announcements

Commit f1e4f103 authored by Vlad Zahorodnii's avatar Vlad Zahorodnii

[libbreezecommon] Use box blur instead of FFT blur

Summary:
Creation of shadows (especially for "Large" and "Very large" sizes) is
a computation expensive task because we have to blur alpha channel of a
shadow texture (which then will be tinted with desired shadow color).

Currently, we use the following approach:
* for blur radius less than 64, use naive 2-pass algorithm;
* for blur radius greater than or equal to 64, use FFT.

Even though the FFT approach is doing its the best, it still takes
impresive amount of time to blur the alpha channel.

What makes things even worse is that while we're blurring the alpha
channel, we're blocking the main thread of KWin (decorations are not
rendered in their own thread). This can result in frame drops (2 or 3
frames, something like that).

So, the only viable alternative is to use an approximation of the Gaussian
blur. As such an approximation, I picked the box blur because it's quite
simple, it's fast, and it takes small amount of iterations to have something
similar to the true Gaussian blur.

In general, there are no big differences between true gaussian shadows
and approximated shadows:

Before:
{F6312610}

After:
{F6312613}

Before:
{F6280935}

After:
{F6312608}

As a win, it takes much less time to generate decoration shadows.

Reviewers: #kwin, #plasma, #breeze, #vdg, ngraham

Reviewed By: #breeze, #vdg, ngraham

Subscribers: cfeck, ngraham, abetts, plasma-devel

Tags: #plasma

Differential Revision: https://phabricator.kde.org/D15514
parent cef36ae4
......@@ -10,8 +10,6 @@ include(GenerateExportHeader)
include(WriteBasicConfigVersionFile)
include(FeatureSummary)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules")
if(USE_KDE4)
find_package(KDE4 REQUIRED)
include(KDE4Defaults)
......
# Find the FFTW library
#
# Usage:
# find_package(FFTW [REQUIRED])
#
# It sets the following variables:
# FFTW_FOUND
# FFTW_INCLUDES
# FFTW_LIBRARIES
find_path(FFTW_INCLUDES fftw3.h)
find_library(FFTW_LIBRARIES NAMES fftw3)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(FFTW DEFAULT_MSG
FFTW_INCLUDES FFTW_LIBRARIES)
mark_as_advanced(FFTW_INCLUDES FFTW_LIBRARIES)
/*
* Copyright 2014 Martin Gräßlin <mgraesslin@kde.org>
* Copyright 2014 Hugo Pereira Da Costa <hugo.pereira@free.fr>
* Copyright 2018 Vlad Zagorodniy <vladzzag@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
......@@ -29,7 +30,7 @@
#include "breezebutton.h"
#include "breezesizegrip.h"
#include "breezeboxshadowhelper.h"
#include "breezeboxshadowrenderer.h"
#include <KDecoration2/DecoratedClient>
#include <KDecoration2/DecorationButtonGroup>
......@@ -729,43 +730,37 @@ namespace Breeze
return c;
};
// In order to properly render a box shadow with a given radius `shadowSize`,
// the box size should be at least `2 * QSize(shadowSize, shadowSize)`.
const int shadowSize = qMax(params.shadow1.radius, params.shadow2.radius);
const QRect box(shadowSize, shadowSize, 2 * shadowSize + 1, 2 * shadowSize + 1);
const QRect rect = box.adjusted(-shadowSize, -shadowSize, shadowSize, shadowSize);
const QSize boxSize = BoxShadowRenderer::calculateMinimumBoxSize(params.shadow1.radius)
.expandedTo(BoxShadowRenderer::calculateMinimumBoxSize(params.shadow2.radius));
QImage shadow(rect.size(), QImage::Format_ARGB32_Premultiplied);
shadow.fill(Qt::transparent);
QPainter painter(&shadow);
painter.setRenderHint(QPainter::Antialiasing);
BoxShadowRenderer shadowRenderer;
shadowRenderer.setBorderRadius(Metrics::Frame_FrameRadius + 0.5);
shadowRenderer.setBoxSize(boxSize);
shadowRenderer.setDevicePixelRatio(1.0); // TODO: Create HiDPI shadows?
const qreal strength = static_cast<qreal>(g_shadowStrength) / 255.0;
// Draw the "shape" shadow.
BoxShadowHelper::boxShadow(
&painter,
box,
params.shadow1.offset,
params.shadow1.radius,
shadowRenderer.addShadow(params.shadow1.offset, params.shadow1.radius,
withOpacity(g_shadowColor, params.shadow1.opacity * strength));
// Draw the "contrast" shadow.
BoxShadowHelper::boxShadow(
&painter,
box,
params.shadow2.offset,
params.shadow2.radius,
shadowRenderer.addShadow(params.shadow2.offset, params.shadow2.radius,
withOpacity(g_shadowColor, params.shadow2.opacity * strength));
QImage shadowTexture = shadowRenderer.render();
QPainter painter(&shadowTexture);
painter.setRenderHint(QPainter::Antialiasing);
const QRect outerRect = shadowTexture.rect();
QRect boxRect(QPoint(0, 0), boxSize);
boxRect.moveCenter(outerRect.center());
// Mask out inner rect.
const QMargins padding = QMargins(
shadowSize - Metrics::Shadow_Overlap - params.offset.x(),
shadowSize - Metrics::Shadow_Overlap - params.offset.y(),
shadowSize - Metrics::Shadow_Overlap + params.offset.x(),
shadowSize - Metrics::Shadow_Overlap + params.offset.y());
const QRect innerRect = rect - padding;
boxRect.left() - outerRect.left() - Metrics::Shadow_Overlap - params.offset.x(),
boxRect.top() - outerRect.top() - Metrics::Shadow_Overlap - params.offset.y(),
outerRect.right() - boxRect.right() - Metrics::Shadow_Overlap + params.offset.x(),
outerRect.bottom() - boxRect.bottom() - Metrics::Shadow_Overlap + params.offset.y());
const QRect innerRect = outerRect - padding;
painter.setPen(Qt::NoPen);
painter.setBrush(Qt::black);
......@@ -788,8 +783,8 @@ namespace Breeze
g_sShadow = QSharedPointer<KDecoration2::DecorationShadow>::create();
g_sShadow->setPadding(padding);
g_sShadow->setInnerShadowRect(QRect(shadow.rect().center(), QSize(1, 1)));
g_sShadow->setShadow(shadow);
g_sShadow->setInnerShadowRect(QRect(outerRect.center(), QSize(1, 1)));
g_sShadow->setShadow(shadowTexture);
}
setShadow(g_sShadow);
......
......@@ -20,6 +20,7 @@
#include "breezemdiwindowshadow.h"
#include "breeze.h"
#include "breezeboxshadowrenderer.h"
#include "breezeshadowhelper.h"
#include "breezestyleconfigdata.h"
......@@ -50,12 +51,21 @@ namespace Breeze
const CompositeShadowParams params = ShadowHelper::lookupShadowParams( StyleConfigData::shadowSize() );
if( params.isNone() ) return;
const int shadowSize = qMax( params.shadow1.radius, params.shadow2.radius );
const int size( shadowSize - Metrics::Shadow_Overlap );
const int topSize( size - params.offset.y() );
const int bottomSize( size + params.offset.y() );
const int leftSize( size - params.offset.x() );
const int rightSize( size + params.offset.x() );
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());
const int topSize( boxRect.top() - shadowRect.top() - Metrics::Shadow_Overlap - params.offset.y() );
const int bottomSize( shadowRect.bottom() - boxRect.bottom() - Metrics::Shadow_Overlap + params.offset.y() );
const int leftSize( boxRect.left() - shadowRect.left() - Metrics::Shadow_Overlap - params.offset.x() );
const int rightSize( shadowRect.right() - boxRect.right() - Metrics::Shadow_Overlap + params.offset.x() );
// get tileSet rect
auto hole = _widget->frameGeometry();
......
/*************************************************************************
* Copyright (C) 2014 by Hugo Pereira Da Costa <hugo.pereira@free.fr> *
* Copyright (C) 2018 by Vlad Zagorodniy <vladzzag@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 *
......@@ -20,7 +21,7 @@
#include "breezeshadowhelper.h"
#include "breeze.h"
#include "breezeboxshadowhelper.h"
#include "breezeboxshadowrenderer.h"
#include "breezehelper.h"
#include "breezepropertynames.h"
#include "breezestyleconfigdata.h"
......@@ -285,46 +286,46 @@ namespace Breeze
return c;
};
const int shadowSize = qMax(params.shadow1.radius, params.shadow2.radius);
const QColor color = StyleConfigData::shadowColor();
const qreal strength = static_cast<qreal>(StyleConfigData::shadowStrength()) / 255.0;
const QRect box(
shadowSize,
shadowSize,
2 * shadowSize + 1,
2 * shadowSize + 1);
const QRect outerRect = box.adjusted(-shadowSize, -shadowSize, shadowSize, shadowSize);
const QSize boxSize = BoxShadowRenderer::calculateMinimumBoxSize(params.shadow1.radius)
.expandedTo(BoxShadowRenderer::calculateMinimumBoxSize(params.shadow2.radius));
QPixmap shadow = _helper.highDpiPixmap(outerRect.width(), outerRect.height());
shadow.fill(Qt::transparent);
#if QT_VERSION >= 0x050300
const qreal dpr = qApp->devicePixelRatio();
#else
const qreal dpr = 1.0;
#endif
QPainter painter(&shadow);
painter.setRenderHint(QPainter::Antialiasing);
const qreal frameRadius = _helper.frameRadius();
// Draw the "shape" shadow.
BoxShadowHelper::boxShadow(
&painter,
box,
params.shadow1.offset,
params.shadow1.radius,
withOpacity(color, params.shadow1.opacity * strength));
BoxShadowRenderer shadowRenderer;
shadowRenderer.setBorderRadius(frameRadius);
shadowRenderer.setBoxSize(boxSize);
shadowRenderer.setDevicePixelRatio(dpr);
// Draw the "contrast" shadow.
BoxShadowHelper::boxShadow(
&painter,
box,
params.shadow2.offset,
params.shadow2.radius,
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);
const QMargins margins = QMargins(
shadowSize - Metrics::Shadow_Overlap - params.offset.x(),
shadowSize - Metrics::Shadow_Overlap - params.offset.y(),
shadowSize - Metrics::Shadow_Overlap + params.offset.x(),
shadowSize - Metrics::Shadow_Overlap + params.offset.y());
const qreal frameRadius = _helper.frameRadius();
boxRect.left() - outerRect.left() - Metrics::Shadow_Overlap - params.offset.x(),
boxRect.top() - outerRect.top() - Metrics::Shadow_Overlap - params.offset.y(),
outerRect.right() - boxRect.right() - Metrics::Shadow_Overlap + params.offset.x(),
outerRect.bottom() - boxRect.bottom() - Metrics::Shadow_Overlap + params.offset.y());
painter.setPen(Qt::NoPen);
painter.setBrush(Qt::black);
......@@ -343,7 +344,7 @@ namespace Breeze
const QPoint innerRectTopLeft = outerRect.center();
_shadowTiles = TileSet(
shadow,
QPixmap::fromImage(shadowTexture),
innerRectTopLeft.x(),
innerRectTopLeft.y(),
1, 1);
......@@ -573,12 +574,22 @@ namespace Breeze
return QMargins();
}
const int shadowSize = qMax(params.shadow1.radius, params.shadow2.radius);
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());
QMargins margins(
shadowSize - Metrics::Shadow_Overlap - params.offset.x(),
shadowSize - Metrics::Shadow_Overlap - params.offset.y(),
shadowSize - Metrics::Shadow_Overlap + params.offset.x(),
shadowSize - Metrics::Shadow_Overlap + params.offset.y());
boxRect.left() - shadowRect.left() - Metrics::Shadow_Overlap - params.offset.x(),
boxRect.top() - shadowRect.top() - Metrics::Shadow_Overlap - params.offset.y(),
shadowRect.right() - boxRect.right() - Metrics::Shadow_Overlap + params.offset.x(),
shadowRect.bottom() - boxRect.right() - Metrics::Shadow_Overlap + params.offset.y());
if (widget->inherits("QBalloonTip")) {
// Balloon tip needs special margins to deal with the arrow.
......
......@@ -11,9 +11,6 @@ if (BREEZE_COMMON_USE_KDE4)
endif ()
################# dependencies #################
### FFTW
find_package(FFTW REQUIRED)
### Qt/KDE
if (NOT BREEZE_COMMON_USE_KDE4)
find_package(Qt5 REQUIRED CONFIG COMPONENTS Widgets)
......@@ -24,7 +21,7 @@ configure_file(config-breezecommon.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-br
################# breezestyle target #################
set(breezecommon_LIB_SRCS
breezeboxshadowhelper.cpp
breezeboxshadowrenderer.cpp
)
if (BREEZE_COMMON_USE_KDE4)
......@@ -35,7 +32,6 @@ if (BREEZE_COMMON_USE_KDE4)
EXPORT_FILE_NAME breezecommon_export.h)
target_link_libraries(breezecommon4 ${KDE4_KDEUI_LIBS})
target_link_libraries(breezecommon4 ${FFTW_LIBRARIES})
set_target_properties(breezecommon4 PROPERTIES
VERSION ${PROJECT_VERSION}
......@@ -52,9 +48,7 @@ else ()
target_link_libraries(breezecommon5
PUBLIC
Qt5::Core
Qt5::Gui
PRIVATE
${FFTW_LIBRARIES})
Qt5::Gui)
set_target_properties(breezecommon5 PROPERTIES
VERSION ${PROJECT_VERSION}
......
/*
* Copyright (C) 2018 Vlad Zagorodniy <vladzzag@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) version 3 or any later version
* accepted by the membership of KDE e.V. (or its successor approved
* by the membership of KDE e.V.), which shall act as a proxy
* defined in Section 14 of version 3 of the license.
*
* 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/>.
*/
#include "breezeboxshadowhelper.h"
#include "config-breezecommon.h"
#include <QVector>
#include <fftw3.h>
#include <cmath>
namespace Breeze {
namespace BoxShadowHelper {
namespace {
// FFT approach outperforms naive blur method when blur radius >= 64.
// (was discovered after doing a lot of benchmarks)
const int FFT_BLUR_RADIUS_THRESHOLD = 64;
// According to the CSS Level 3 spec, standard deviation must be equal to
// half of the blur radius. https://www.w3.org/TR/css-backgrounds-3/#shadow-blur
// Current window size is too small for sigma equal to half of the blur radius.
// As a workaround, sigma blur scale is lowered. With the lowered sigma
// blur scale, area under the kernel equals to 0.98, which is pretty enough.
// Maybe, it should be changed in the future.
const double SIGMA_BLUR_SCALE = 0.4375;
}
inline int kernelSizeToRadius(int kernelSize)
{
return (kernelSize - 1) / 2;
}
inline int radiusToKernelSize(int radius)
{
return radius * 2 + 1;
}
QVector<double> computeGaussianKernel(int radius)
{
QVector<double> kernel;
const int kernelSize = radiusToKernelSize(radius);
kernel.reserve(kernelSize);
const double sigma = SIGMA_BLUR_SCALE * radius;
const double den = std::sqrt(2.0) * sigma;
double kernelNorm = 0.0;
double lastInt = 0.5 * std::erf((-radius - 0.5) / den);
for (int i = 0; i < kernelSize; i++) {
const double currInt = 0.5 * std::erf((i - radius + 0.5) / den);
const double w = currInt - lastInt;
kernel << w;
kernelNorm += w;
lastInt = currInt;
}
for (auto &w : kernel) {
w /= kernelNorm;
}
return kernel;
}
// Do horizontal pass of the Gaussian filter. Please notice that the result
// is transposed. So, the dst image should have proper size, e.g. if the src
// image have (wxh) size then the dst image should have (hxw) size. The
// result is transposed so we read memory in linear order.
void blurAlphaNaivePass(const QImage &src, QImage &dst, const QVector<double> &kernel)
{
const int alphaOffset = QSysInfo::ByteOrder == QSysInfo::BigEndian ? 0 : 3;
const int alphaStride = src.depth() >> 3;
const int radius = kernelSizeToRadius(kernel.size());
for (int y = 0; y < src.height(); y++) {
const uchar *in = src.scanLine(y) + alphaOffset;
uchar *out = dst.scanLine(0) + alphaOffset + y * alphaStride;
for (int x = 0; x < radius; x++) {
const uchar *window = in;
double alpha = 0.0;
for (int k = radius - x; k < kernel.size(); k++) {
alpha += *window * kernel[k];
window += alphaStride;
}
*out = static_cast<uchar>(alpha);
out += dst.width() * alphaStride;
}
for (int x = radius; x < src.width() - radius; x++) {
const uchar *window = in + (x - radius) * alphaStride;
double alpha = 0.0;
for (int k = 0; k < kernel.size(); k++) {
alpha += *window * kernel[k];
window += alphaStride;
}
*out = static_cast<uchar>(alpha);
out += dst.width() * alphaStride;
}
for (int x = src.width() - radius; x < src.width(); x++) {
const uchar *window = in + (x - radius - 1) * alphaStride;
double alpha = 0.0;
const int outside = x + radius - src.width();
for (int k = 0; k < kernel.size() - outside; k++) {
alpha += *window * kernel[k];
window += alphaStride;
}
*out = static_cast<uchar>(alpha);
out += dst.width() * alphaStride;
}
}
}
// Blur alpha channel of the given image using separable convolution
// gaussian kernel. Not very efficient with big blur radii.
void blurAlphaNaive(QImage &img, int radius)
{
const QVector<double> kernel = computeGaussianKernel(radius);
QImage tmp(img.height(), img.width(), img.format());
blurAlphaNaivePass(img, tmp, kernel); // horizontal pass
blurAlphaNaivePass(tmp, img, kernel); // vertical pass
}
// Blur alpha channel of the given image using Fourier Transform.
// It's somewhat efficient with big blur radii.
//
// It works as follows:
// - do FFT on given input image(it is expected, that the
// input image was padded before)
// - compute Gaussian kernel, pad it to the size of the input
// image, and do FFT on it
// - multiply the two in the frequency domain(element-wise)
// - transform the result back to "time domain"
//
void blurAlphaFFT(QImage &img, int radius)
{
const int alphaOffset = QSysInfo::ByteOrder == QSysInfo::BigEndian ? 0 : 3;
const int alphaStride = img.depth() >> 3;
const int size = img.width() * img.height();
// Use FFTW's malloc function so the returned pointer obeys any
// special alignment restrictions. (e.g. for SIMD acceleration, etc)
// See http://www.fftw.org/fftw3_doc/MekernelSizeToRadius(mory-Allocation.html
fftw_complex *imageIn = fftw_alloc_complex(size);
fftw_complex *imageOut = fftw_alloc_complex(size);
uchar *data = img.scanLine(0) + alphaOffset;
for (int i = 0; i < size; i++) {
imageIn[i][0] = *data;
imageIn[i][1] = 0.0;
data += alphaStride;
}
fftw_plan imageFFT = fftw_plan_dft_2d(
img.height(), img.width(),
imageIn, imageOut,
FFTW_FORWARD, FFTW_ESTIMATE);
fftw_plan imageIFFT = fftw_plan_dft_2d(
img.height(), img.width(),
imageOut, imageIn,
FFTW_BACKWARD, FFTW_ESTIMATE);
// The computed Gaussian kernel has to have the same size as the input image.
// Please note that the center of the computed Gaussian kernel is placed
// at the top-left corner and the whole kernel is wrapped around so we read
// result in linear order.
// Note: the kernel is computed by taking a product of two 1-D Gaussian kernels.
QVector<double> kernel(size, 0);
const QVector<double> kernel_ = computeGaussianKernel(radius);
for (int y = 0; y < kernel_.size(); y++) {
const int i = (img.height() + y - radius) % img.height();
for (int x = 0; x < kernel_.size(); x++) {
const int j = (img.width() + x - radius) % img.width();
kernel[j + i * img.width()] = kernel_[x] * kernel_[y];
}
}
fftw_complex *kernelIn = fftw_alloc_complex(kernel.size());
fftw_complex *kernelOut = fftw_alloc_complex(kernel.size());
for (int i = 0; i < size; i++) {
kernelIn[i][0] = kernel[i];
kernelIn[i][1] = 0.0;
}
fftw_plan kernelFFT = fftw_plan_dft_2d(
img.height(), img.width(),
kernelIn, kernelOut,
FFTW_FORWARD, FFTW_ESTIMATE);
// Do actual FFT.
fftw_execute(imageFFT);
fftw_execute(kernelFFT);
for (int i = 0; i < size; i++) {
const double re = imageOut[i][0] * kernelOut[i][0] - imageOut[i][1] * kernelOut[i][1];
const double im = imageOut[i][0] * kernelOut[i][1] + imageOut[i][1] * kernelOut[i][0];
imageOut[i][0] = re;
imageOut[i][1] = im;
}
fftw_execute(imageIFFT);
// Copy result back. Please note, result is scaled by `width x height` so we need to scale it down.
const double invSize = 1.0 / size;
data = img.scanLine(0) + alphaOffset;
for (int i = 0; i < size; i++) {
*data = imageIn[i][0] * invSize;
data += alphaStride;
}
fftw_destroy_plan(kernelFFT);
fftw_destroy_plan(imageFFT);
fftw_destroy_plan(imageIFFT);
fftw_free(kernelIn);
fftw_free(kernelOut);
fftw_free(imageIn);
fftw_free(imageOut);
}
void boxShadow(QPainter *p, const QRect &box, const QPoint &offset, int radius, const QColor &color)
{
const QSize size = box.size() + 2 * QSize(radius, radius);
#if BREEZE_COMMON_USE_KDE4
const qreal dpr = 1.0;
#else
const qreal dpr = p->device()->devicePixelRatioF();
#endif
QPainter painter;
QImage shadow(size * dpr, QImage::Format_ARGB32_Premultiplied);
#if !BREEZE_COMMON_USE_KDE4
shadow.setDevicePixelRatio(dpr);
#endif
shadow.fill(Qt::transparent);
painter.begin(&shadow);
painter.fillRect(QRect(QPoint(radius, radius), box.size()), Qt::black);
painter.end();
// There is no need to blur RGB channels. Blur the alpha
// channel and then give the shadow a tint of the desired color.
const int radius_ = radius * dpr;
if (radius_ < FFT_BLUR_RADIUS_THRESHOLD) {
blurAlphaNaive(shadow, radius_);
} else {
blurAlphaFFT(shadow, radius_);
}
painter.begin(&shadow);
painter.setCompositionMode(QPainter::CompositionMode_SourceIn);
painter.fillRect(shadow.rect(), color);
painter.end();
QRect shadowRect = shadow.rect();
shadowRect.setSize(shadowRect.size() / dpr);
shadowRect.moveCenter(box.center() + offset);
p->drawImage(shadowRect, shadow);
}
} // BoxShadowHelper
} // Breeze
/*
* Copyright (C) 2018 Vlad Zagorodniy <vladzzag@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) version 3 or any later version
* accepted by the membership of KDE e.V. (or its successor approved
* by the membership of KDE e.V.), which shall act as a proxy
* defined in Section 14 of version 3 of the license.
*
* 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 BREEZE_COMMON_BOXSHADOWHELPER_H
#define BREEZE_COMMON_BOXSHADOWHELPER_H
#include "breezecommon_export.h"
#include <QColor>
#include <QPainter>
#include <QPoint>
#include <QRect>
namespace Breeze {
namespace BoxShadowHelper {
void BREEZECOMMON_EXPORT boxShadow(QPainter *p, const QRect &box, const QPoint &offset,
int radius, const QColor &color);
} // BoxShadowHelper
} // Breeze
#endif // BREEZE_COMMON_BOXSHADOWHELPER_H
This diff is collapsed.