File indexing completed on 2024-04-28 15:32:04

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 1998 Jörg Habenicht <j.habenicht@europemail.com>
     SPDX-FileCopyrightText: 2010 Christoph Feck <cfeck@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kled.h"
 
 #include <QImage>
 #include <QPainter>
 #include <QStyle>
 #include <QStyleOption>
 
 class KLedPrivate
 {
 public:
     int darkFactor = 300;
     QColor color;
     KLed::State state = KLed::On;
     KLed::Look look = KLed::Raised;
     KLed::Shape shape = KLed::Circular;
 
     QPixmap cachedPixmap[2]; // for both states
 };
 
 KLed::KLed(QWidget *parent)
     : QWidget(parent)
     , d(new KLedPrivate)
 {
     setColor(Qt::green);
     updateAccessibleName();
 }
 
 KLed::KLed(const QColor &color, QWidget *parent)
     : QWidget(parent)
     , d(new KLedPrivate)
 {
     setColor(color);
     updateAccessibleName();
 }
 
 KLed::KLed(const QColor &color, State state, Look look, Shape shape, QWidget *parent)
     : QWidget(parent)
     , d(new KLedPrivate)
 {
     d->state = (state == Off ? Off : On);
     d->look = look;
     d->shape = shape;
 
     setColor(color);
     updateAccessibleName();
 }
 
 KLed::~KLed() = default;
 
 KLed::State KLed::state() const
 {
     return d->state;
 }
 
 KLed::Shape KLed::shape() const
 {
     return d->shape;
 }
 
 QColor KLed::color() const
 {
     return d->color;
 }
 
 KLed::Look KLed::look() const
 {
     return d->look;
 }
 
 void KLed::setState(State state)
 {
     if (d->state == state) {
         return;
     }
 
     d->state = (state == Off ? Off : On);
     updateCachedPixmap();
     updateAccessibleName();
 }
 
 void KLed::setShape(Shape shape)
 {
     if (d->shape == shape) {
         return;
     }
 
     d->shape = shape;
     updateCachedPixmap();
 }
 
 void KLed::setColor(const QColor &color)
 {
     if (d->color == color) {
         return;
     }
 
     d->color = color;
     updateCachedPixmap();
 }
 
 void KLed::setDarkFactor(int darkFactor)
 {
     if (d->darkFactor == darkFactor) {
         return;
     }
 
     d->darkFactor = darkFactor;
     updateCachedPixmap();
 }
 
 int KLed::darkFactor() const
 {
     return d->darkFactor;
 }
 
 void KLed::setLook(Look look)
 {
     if (d->look == look) {
         return;
     }
 
     d->look = look;
     updateCachedPixmap();
 }
 
 void KLed::toggle()
 {
     d->state = (d->state == On ? Off : On);
     updateCachedPixmap();
     updateAccessibleName();
 }
 
 void KLed::on()
 {
     setState(On);
 }
 
 void KLed::off()
 {
     setState(Off);
 }
 
 void KLed::resizeEvent(QResizeEvent *)
 {
     updateCachedPixmap();
 }
 
 QSize KLed::sizeHint() const
 {
     QStyleOption option;
     option.initFrom(this);
     int iconSize = style()->pixelMetric(QStyle::PM_SmallIconSize, &option, this);
     return QSize(iconSize, iconSize);
 }
 
 QSize KLed::minimumSizeHint() const
 {
     return QSize(16, 16);
 }
 
 void KLed::updateAccessibleName()
 {
 #ifndef QT_NO_ACCESSIBILITY
     QString onName = tr("LED on", "Accessible name of a Led whose state is on");
     QString offName = tr("LED off", "Accessible name of a Led whose state is off");
     QString lastName = accessibleName();
 
     if (lastName.isEmpty() || lastName == onName || lastName == offName) {
         // Accessible name has not been manually set.
 
         setAccessibleName(d->state == On ? onName : offName);
     }
 #endif
 }
 
 void KLed::updateCachedPixmap()
 {
     d->cachedPixmap[Off] = QPixmap();
     d->cachedPixmap[On] = QPixmap();
     update();
 }
 
 void KLed::paintEvent(QPaintEvent *)
 {
     if (!d->cachedPixmap[d->state].isNull()) {
         QPainter painter(this);
         painter.drawPixmap(1, 1, d->cachedPixmap[d->state]);
         return;
     }
 
     QSize size(width() - 2, height() - 2);
     if (d->shape == Circular) {
         // Make sure the LED is round
         const int dim = qMin(width(), height()) - 2;
         size = QSize(dim, dim);
     }
     QPointF center(size.width() / 2.0, size.height() / 2.0);
     const int smallestSize = qMin(size.width(), size.height());
     QPainter painter;
 
     QImage image(size, QImage::Format_ARGB32_Premultiplied);
     image.fill(0);
 
     QRadialGradient fillGradient(center, smallestSize / 2.0, QPointF(center.x(), size.height() / 3.0));
     const QColor fillColor = d->state != Off ? d->color : d->color.darker(d->darkFactor);
     fillGradient.setColorAt(0.0, fillColor.lighter(250));
     fillGradient.setColorAt(0.5, fillColor.lighter(130));
     fillGradient.setColorAt(1.0, fillColor);
 
     QConicalGradient borderGradient(center, d->look == Sunken ? 90 : -90);
     QColor borderColor = palette().color(QPalette::Dark);
     if (d->state == On) {
         QColor glowOverlay = fillColor;
         glowOverlay.setAlpha(80);
 
         // This isn't the fastest way, but should be "fast enough".
         // It's also the only safe way to use QPainter::CompositionMode
         QImage img(1, 1, QImage::Format_ARGB32_Premultiplied);
         QPainter p(&img);
         QColor start = borderColor;
         start.setAlpha(255); // opaque
         p.fillRect(0, 0, 1, 1, start);
         p.setCompositionMode(QPainter::CompositionMode_SourceOver);
         p.fillRect(0, 0, 1, 1, glowOverlay);
         p.end();
 
         borderColor = img.pixel(0, 0);
     }
     borderGradient.setColorAt(0.2, borderColor);
     borderGradient.setColorAt(0.5, palette().color(QPalette::Light));
     borderGradient.setColorAt(0.8, borderColor);
 
     painter.begin(&image);
     painter.setRenderHint(QPainter::Antialiasing);
     painter.setBrush(d->look == Flat ? QBrush(fillColor) : QBrush(fillGradient));
     const QBrush penBrush = (d->look == Flat) ? QBrush(borderColor) : QBrush(borderGradient);
     const qreal penWidth = smallestSize / 8.0;
     painter.setPen(QPen(penBrush, penWidth));
     QRectF r(penWidth / 2.0, penWidth / 2.0, size.width() - penWidth, size.height() - penWidth);
     if (d->shape == Rectangular) {
         painter.drawRect(r);
     } else {
         painter.drawEllipse(r);
     }
     painter.end();
 
     d->cachedPixmap[d->state] = QPixmap::fromImage(image);
     painter.begin(this);
     painter.drawPixmap(1, 1, d->cachedPixmap[d->state]);
     painter.end();
 }
 
 #include "moc_kled.cpp"