File indexing completed on 2024-05-05 05:35:34

 //////////////////////////////////////////////////////////////////////////////
 // oxygenshadowcache.cpp
 // handles caching of TileSet objects to draw shadows
 // -------------------
 //
 // SPDX-FileCopyrightText: 2009 Hugo Pereira Da Costa <hugo.pereira@free.fr>
 //
 // SPDX-License-Identifier: MIT
 //////////////////////////////////////////////////////////////////////////////
 
 #include "oxygenshadowcache.h"
 #include "oxygenactiveshadowconfiguration.h"
 #include "oxygeninactiveshadowconfiguration.h"
 
 #include <KColorUtils>
 #include <QPainter>
 #include <QTextStream>
 
 namespace Oxygen
 {
 //* square utility function
 static qreal square(qreal x)
 {
     return x * x;
 }
 
 //* functions used to draw shadows
 class Parabolic
 {
 public:
     //* constructor
     Parabolic(qreal amplitude, qreal width)
         : amplitude_(amplitude)
         , width_(width)
     {
     }
 
     //* destructor
     virtual ~Parabolic(void)
     {
     }
 
     //* value
     virtual qreal operator()(qreal x) const
     {
         return qMax(0.0, amplitude_ * (1.0 - square(x / width_)));
     }
 
 private:
     qreal amplitude_;
     qreal width_;
 };
 
 //* functions used to draw shadows
 class Gaussian
 {
 public:
     //* constructor
     Gaussian(qreal amplitude, qreal width)
         : amplitude_(amplitude)
         , width_(width)
     {
     }
 
     //* destructor
     virtual ~Gaussian(void)
     {
     }
 
     //* value
     virtual qreal operator()(qreal x) const
     {
         return qMax(0.0, amplitude_ * (std::exp(-square(x / width_) - 0.05)));
     }
 
 private:
     qreal amplitude_;
     qreal width_;
 };
 
 //_______________________________________________________
 ShadowCache::ShadowCache(Helper &helper)
     : _helper(helper)
     , _enabled(true)
     , _activeShadowSize(40)
     , _inactiveShadowSize(40)
 {
     setMaxIndex(256);
 }
 
 //_______________________________________________________
 void ShadowCache::readConfig(void)
 {
     if (!_enabled)
         setEnabled(true);
 
     // shadows
     ActiveShadowConfiguration::self()->load();
     InactiveShadowConfiguration::self()->load();
 
     // copy sizes to local
     _activeShadowSize = ActiveShadowConfiguration::shadowSize();
     _inactiveShadowSize = InactiveShadowConfiguration::shadowSize();
 
     // invalidate caches
     invalidateCaches();
 }
 
 //_______________________________________________________
 void ShadowCache::setAnimationsDuration(int value)
 {
     setMaxIndex(qMin(256, int((120 * value) / 1000)));
     invalidateCaches();
 }
 
 //_______________________________________________________
 bool ShadowCache::isEnabled(QPalette::ColorGroup group) const
 {
     if (group == QPalette::Active)
         return ActiveShadowConfiguration::enabled();
     else if (group == QPalette::Inactive)
         return InactiveShadowConfiguration::enabled();
     else
         return false;
 }
 
 //_______________________________________________________
 void ShadowCache::setShadowSize(QPalette::ColorGroup group, int size)
 {
     if (group == QPalette::Active && _activeShadowSize != size) {
         _activeShadowSize = size;
         invalidateCaches();
 
     } else if (group == QPalette::Inactive && _inactiveShadowSize != size) {
         _inactiveShadowSize = size;
         invalidateCaches();
     }
 }
 
 //_______________________________________________________
 int ShadowCache::shadowSize(void) const
 {
     int activeSize(ActiveShadowConfiguration::enabled() ? _activeShadowSize : 0);
     int inactiveSize(InactiveShadowConfiguration::enabled() ? _inactiveShadowSize : 0);
 
     // even if shadows are disabled,
     return qMax(activeSize, inactiveSize);
 }
 
 //_______________________________________________________
 TileSet ShadowCache::tileSet(const Key &key)
 {
     // check if tileSet already in cache
     int hash(key.hash());
     if (_enabled) {
         if (TileSet *cachedTileSet = _shadowCache.object(hash)) {
             return *cachedTileSet;
         }
     }
 
     // create tileSet otherwise
     const qreal size(shadowSize() + overlap);
     TileSet tileSet(pixmap(key), size, size, size, size, size, size, 1, 1);
     _shadowCache.insert(hash, new TileSet(tileSet));
 
     return tileSet;
 }
 
 //_______________________________________________________
 TileSet ShadowCache::tileSet(Key key, qreal opacity)
 {
     int index(opacity * _maxIndex);
     Q_ASSERT(index <= _maxIndex);
 
     // construct key
     key.index = index;
 
     // check if tileSet already in cache
     int hash(key.hash());
     if (_enabled) {
         if (TileSet *cachedTileSet = _animatedShadowCache.object(hash)) {
             return *cachedTileSet;
         }
     }
 
     // create shadow and tileset otherwise
     const qreal size(shadowSize() + overlap);
     TileSet tileSet(animatedPixmap(key, opacity), size, size, 1, 1);
     _animatedShadowCache.insert(hash, new TileSet(tileSet));
     return tileSet;
 }
 
 //_______________________________________________________
 QPixmap ShadowCache::animatedPixmap(const Key &key, qreal opacity)
 {
     // create shadow and tileset otherwise
     const qreal size(shadowSize() + overlap);
 
     QPixmap shadow(_helper.highDpiPixmap(size * 2));
     shadow.fill(Qt::transparent);
     QPainter painter(&shadow);
     painter.setRenderHint(QPainter::Antialiasing);
 
     QPixmap inactiveShadow(pixmap(key, false));
     if (!inactiveShadow.isNull()) {
         QPainter local(&inactiveShadow);
         local.setRenderHint(QPainter::Antialiasing);
         local.setCompositionMode(QPainter::CompositionMode_DestinationIn);
         local.fillRect(inactiveShadow.rect(), QColor(0, 0, 0, 255 * (1.0 - opacity)));
     }
 
     QPixmap activeShadow(pixmap(key, true));
     if (!activeShadow.isNull()) {
         QPainter local(&activeShadow);
         local.setRenderHint(QPainter::Antialiasing);
         local.setCompositionMode(QPainter::CompositionMode_DestinationIn);
         local.fillRect(activeShadow.rect(), QColor(0, 0, 0, 255 * (opacity)));
     }
 
     painter.drawPixmap(QPointF(0, 0), inactiveShadow);
     painter.drawPixmap(QPointF(0, 0), activeShadow);
     painter.end();
 
     return shadow;
 }
 
 //_______________________________________________________
 QPixmap ShadowCache::pixmap(const Key &key, bool active) const
 {
     static const qreal fixedSize = 25.5;
     qreal size(shadowSize());
     qreal shadowSize(0);
 
     if (active && ActiveShadowConfiguration::enabled())
         shadowSize = _activeShadowSize;
     else if (!active && InactiveShadowConfiguration::enabled())
         shadowSize = _inactiveShadowSize;
 
     if (!shadowSize)
         return QPixmap();
 
     // add overlap
     size += overlap;
     shadowSize += overlap;
 
     QPixmap shadow(_helper.highDpiPixmap(size * 2));
     shadow.fill(Qt::transparent);
 
     QPainter painter(&shadow);
     painter.setRenderHint(QPainter::Antialiasing);
     painter.setPen(Qt::NoPen);
 
     // some gradients rendering are different at bottom corners if client has no border
     bool hasBorder(key.hasBorder || key.isShade);
 
     if (active) {
         {
             // inner (sharp) gradient
             const qreal gradientSize = qMin(shadowSize, (shadowSize + fixedSize) / 2);
             const qreal voffset = qMin(12.0 * (gradientSize * ActiveShadowConfiguration::verticalOffset()) / fixedSize, 4.0);
 
             QRadialGradient radialGradient = QRadialGradient(size, size + voffset, gradientSize);
             radialGradient.setColorAt(1, Qt::transparent);
 
             // gaussian shadow is used
             int nPoints((10 * gradientSize) / fixedSize);
             Gaussian f(0.85, 0.17);
             QColor c = ActiveShadowConfiguration::innerColor();
             for (int i = 0; i < nPoints; i++) {
                 qreal x = qreal(i) / nPoints;
                 c.setAlphaF(f(x));
                 radialGradient.setColorAt(x, c);
             }
 
             painter.setBrush(radialGradient);
             renderGradient(painter, shadow.rect(), radialGradient, hasBorder);
         }
 
         {
             // outer (spread) gradient
             const qreal gradientSize = shadowSize;
             const qreal voffset = qMin(12.0 * (gradientSize * ActiveShadowConfiguration::verticalOffset()) / fixedSize, 4.0);
 
             QRadialGradient radialGradient = QRadialGradient(size, size + voffset, gradientSize);
             radialGradient.setColorAt(1, Qt::transparent);
 
             // gaussian shadow is used
             int nPoints((10 * gradientSize) / fixedSize);
             Gaussian f(0.46, 0.34);
             QColor c = ActiveShadowConfiguration::useOuterColor() ? ActiveShadowConfiguration::outerColor() : ActiveShadowConfiguration::innerColor();
             for (int i = 0; i < nPoints; i++) {
                 qreal x = qreal(i) / nPoints;
                 c.setAlphaF(f(x));
                 radialGradient.setColorAt(x, c);
             }
 
             painter.setBrush(radialGradient);
             painter.drawRect(shadow.rect());
         }
 
     } else {
         {
             // inner (sharp gradient)
             const qreal gradientSize = qMin(shadowSize, fixedSize);
             const qreal voffset(0.2);
 
             QRadialGradient radialGradient = QRadialGradient(size, size + voffset, gradientSize);
             radialGradient.setColorAt(1, Qt::transparent);
 
             // parabolic shadow is used
             int nPoints((10 * gradientSize) / fixedSize);
             Parabolic f(1.0, 0.22);
             QColor c = InactiveShadowConfiguration::useOuterColor() ? InactiveShadowConfiguration::outerColor() : InactiveShadowConfiguration::innerColor();
             for (int i = 0; i < nPoints; i++) {
                 qreal x = qreal(i) / nPoints;
                 c.setAlphaF(f(x));
                 radialGradient.setColorAt(x, c);
             }
 
             painter.setBrush(radialGradient);
             renderGradient(painter, shadow.rect(), radialGradient, hasBorder);
         }
 
         {
             // mid gradient
             const qreal gradientSize = qMin(shadowSize, (shadowSize + 2 * fixedSize) / 3);
             const qreal voffset = qMin(8.0 * (gradientSize * InactiveShadowConfiguration::verticalOffset()) / fixedSize, 4.0);
 
             // gaussian shadow is used
             QRadialGradient radialGradient = QRadialGradient(size, size + voffset, gradientSize);
             radialGradient.setColorAt(1, Qt::transparent);
 
             int nPoints((10 * gradientSize) / fixedSize);
             Gaussian f(0.54, 0.21);
             QColor c = InactiveShadowConfiguration::useOuterColor() ? InactiveShadowConfiguration::outerColor() : InactiveShadowConfiguration::innerColor();
             for (int i = 0; i < nPoints; i++) {
                 qreal x = qreal(i) / nPoints;
                 c.setAlphaF(f(x));
                 radialGradient.setColorAt(x, c);
             }
 
             painter.setBrush(radialGradient);
             painter.drawRect(shadow.rect());
         }
 
         {
             // outer (spread) gradient
             const qreal gradientSize = shadowSize;
             const qreal voffset = qMin(20.0 * (gradientSize * InactiveShadowConfiguration::verticalOffset()) / fixedSize, 4.0);
 
             // gaussian shadow is used
             QRadialGradient radialGradient = QRadialGradient(size, size + voffset, gradientSize);
             radialGradient.setColorAt(1, Qt::transparent);
 
             int nPoints((20 * gradientSize) / fixedSize);
             Gaussian f(0.155, 0.445);
             QColor c = InactiveShadowConfiguration::useOuterColor() ? InactiveShadowConfiguration::outerColor() : InactiveShadowConfiguration::innerColor();
             for (int i = 0; i < nPoints; i++) {
                 qreal x = qreal(i) / nPoints;
                 c.setAlphaF(f(x));
                 radialGradient.setColorAt(x, c);
             }
 
             painter.setBrush(radialGradient);
             painter.drawRect(shadow.rect());
         }
     }
 
     // mask
     painter.setCompositionMode(QPainter::CompositionMode_DestinationOut);
     painter.setBrush(Qt::black);
     painter.drawEllipse(QRectF(size - 3, size - 3, 6, 6));
 
     painter.end();
     return shadow;
 }
 
 //_______________________________________________________
 void ShadowCache::renderGradient(QPainter &painter, const QRectF &rect, const QRadialGradient &radialGradient, bool hasBorder) const
 {
     if (hasBorder) {
         painter.setBrush(radialGradient);
         painter.drawRect(rect);
         return;
     }
 
     const qreal size(rect.width() / 2.0);
     const qreal hoffset(radialGradient.center().x() - size);
     const qreal voffset(radialGradient.center().y() - size);
     const qreal radius(radialGradient.radius());
 
     // load gradient stops
     QGradientStops stops(radialGradient.stops());
 
     // draw ellipse for the upper rect
     {
         QRectF rect(hoffset, voffset, 2 * size - hoffset, size);
         painter.setBrush(radialGradient);
         painter.drawRect(rect);
     }
 
     // draw square gradients for the lower rect
     {
         // vertical lines
         const QRectF rect(hoffset, size + voffset, 2 * size - hoffset, 4);
         QLinearGradient lg(hoffset, 0.0, 2 * size + hoffset, 0.0);
         for (int i = 0; i < stops.size(); i++) {
             const QColor c(stops[i].second);
             const qreal xx(stops[i].first * radius);
             lg.setColorAt((size - xx) / (2.0 * size), c);
             lg.setColorAt((size + xx) / (2.0 * size), c);
         }
 
         painter.setBrush(lg);
         painter.drawRect(rect);
     }
 
     {
         // horizontal line
         const QRectF rect(size - 4 + hoffset, size + voffset, 8, size);
         QLinearGradient lg = QLinearGradient(0, voffset, 0, 2 * size + voffset);
         for (int i = 0; i < stops.size(); i++) {
             const QColor c(stops[i].second);
             const qreal xx(stops[i].first * radius);
             lg.setColorAt((size + xx) / (2.0 * size), c);
         }
 
         painter.setBrush(lg);
         painter.drawRect(rect);
     }
 
     {
         // bottom-left corner
         const QRectF rect(hoffset, size + voffset + 4, size - 4, size);
         QRadialGradient radialGradient = QRadialGradient(size + hoffset - 4, size + voffset + 4, radius);
         for (int i = 0; i < stops.size(); i++) {
             QColor c(stops[i].second);
             qreal xx(stops[i].first - 4.0 / radius);
             if (xx < 0) {
                 if (i < stops.size() - 1) {
                     const qreal x1(stops[i + 1].first - 4.0 / radius);
                     c = KColorUtils::mix(c, stops[i + 1].second, -xx / (x1 - xx));
                 }
                 xx = 0;
             }
 
             radialGradient.setColorAt(xx, c);
         }
 
         painter.setBrush(radialGradient);
         painter.drawRect(rect);
     }
 
     {
         // bottom-right corner
         const QRectF rect(size + hoffset + 4, size + voffset + 4, size - 4, size);
         QRadialGradient radialGradient = QRadialGradient(size + hoffset + 4, size + voffset + 4, radius);
         for (int i = 0; i < stops.size(); i++) {
             QColor c(stops[i].second);
             qreal xx(stops[i].first - 4.0 / radius);
             if (xx < 0) {
                 if (i < stops.size() - 1) {
                     const qreal x1(stops[i + 1].first - 4.0 / radius);
                     c = KColorUtils::mix(c, stops[i + 1].second, -xx / (x1 - xx));
                 }
                 xx = 0;
             }
 
             radialGradient.setColorAt(xx, c);
         }
 
         painter.setBrush(radialGradient);
         painter.drawRect(rect);
     }
 }
 }