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

 /*
     SPDX-FileCopyrightText: 2009 Sebastian Trueg <trueg@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-or-later
 */
 
 #include "kpixmapsequenceoverlaypainter.h"
 #include "kpixmapsequence.h"
 
 #include <QCoreApplication>
 #include <QEvent>
 #include <QPainter>
 #include <QPointer>
 #include <QRect>
 #include <QTimer>
 #include <QWidget>
 
 class KPixmapSequenceOverlayPainterPrivate
 {
 public:
     void init(KPixmapSequenceOverlayPainter *p);
     void timeout();
     void paintFrame();
 
     KPixmapSequence &sequence();
 
     QRect pixmapRect();
 
     KPixmapSequence m_sequence;
     QPointer<QWidget> m_widget;
     Qt::Alignment m_alignment;
     QPoint m_offset;
     QRect m_rect;
 
     QTimer m_timer;
     int m_counter;
 
     bool m_started;
 
     KPixmapSequenceOverlayPainter *q;
 };
 
 void KPixmapSequenceOverlayPainterPrivate::init(KPixmapSequenceOverlayPainter *p)
 {
     q = p;
     m_widget = nullptr;
     m_alignment = Qt::AlignCenter;
     m_started = false;
     q->setInterval(200);
     QObject::connect(&m_timer, &QTimer::timeout, q, [this]() {
         timeout();
     });
 }
 
 void KPixmapSequenceOverlayPainterPrivate::timeout()
 {
     if (sequence().isEmpty()) {
         return;
     }
     ++m_counter;
     m_counter %= sequence().frameCount();
     if (m_widget) {
         m_widget->update(pixmapRect());
     }
 }
 
 void KPixmapSequenceOverlayPainterPrivate::paintFrame()
 {
     if (m_counter >= sequence().frameCount()) {
         return;
     }
     QPainter p(m_widget);
     p.drawPixmap(pixmapRect(), sequence().frameAt(m_counter), QRect(QPoint(0, 0), sequence().frameSize()));
 }
 
 KPixmapSequence &KPixmapSequenceOverlayPainterPrivate::sequence()
 {
     return m_sequence;
 }
 
 QRect KPixmapSequenceOverlayPainterPrivate::pixmapRect()
 {
     QRect rect(m_rect);
     if (!rect.isValid()) {
         rect = m_widget->rect();
     }
 
     QPoint pos(rect.topLeft());
     if (m_alignment & Qt::AlignHCenter) {
         pos.setX(rect.center().x() - (sequence().frameSize().width() / 2));
     } else if (m_alignment & Qt::AlignRight) {
         pos.setX(rect.right() - sequence().frameSize().width());
     }
 
     if (m_alignment & Qt::AlignVCenter) {
         pos.setY(rect.center().y() - (sequence().frameSize().height() / 2));
     } else if (m_alignment & Qt::AlignBottom) {
         pos.setY(rect.bottom() - sequence().frameSize().height());
     }
 
     pos += m_offset;
 
     return QRect(pos, sequence().frameSize());
 }
 
 KPixmapSequenceOverlayPainter::KPixmapSequenceOverlayPainter(QObject *parent)
     : QObject(parent)
     , d(new KPixmapSequenceOverlayPainterPrivate)
 {
     d->init(this);
 }
 
 KPixmapSequenceOverlayPainter::KPixmapSequenceOverlayPainter(const KPixmapSequence &seq, QObject *parent)
     : QObject(parent)
     , d(new KPixmapSequenceOverlayPainterPrivate)
 {
     d->init(this);
     d->m_sequence = seq;
 }
 
 KPixmapSequenceOverlayPainter::~KPixmapSequenceOverlayPainter()
 {
     stop();
 }
 
 KPixmapSequence KPixmapSequenceOverlayPainter::sequence() const
 {
     return d->sequence();
 }
 
 int KPixmapSequenceOverlayPainter::interval() const
 {
     return d->m_timer.interval();
 }
 
 QRect KPixmapSequenceOverlayPainter::rect() const
 {
     if (d->m_rect.isValid()) {
         return d->m_rect;
     } else if (d->m_widget) {
         return d->m_widget->rect();
     } else {
         return QRect();
     }
 }
 
 Qt::Alignment KPixmapSequenceOverlayPainter::alignment() const
 {
     return d->m_alignment;
 }
 
 QPoint KPixmapSequenceOverlayPainter::offset() const
 {
     return d->m_offset;
 }
 
 void KPixmapSequenceOverlayPainter::setSequence(const KPixmapSequence &seq)
 {
     bool restart = d->m_started;
     stop();
     d->m_sequence = seq;
     if (restart) {
         start();
     }
 }
 
 void KPixmapSequenceOverlayPainter::setInterval(int msecs)
 {
     d->m_timer.setInterval(msecs);
 }
 
 void KPixmapSequenceOverlayPainter::setWidget(QWidget *w)
 {
     stop();
     d->m_widget = w;
 }
 
 void KPixmapSequenceOverlayPainter::setRect(const QRect &rect)
 {
     bool restart = d->m_started;
     stop();
     d->m_rect = rect;
     if (restart) {
         start();
     }
 }
 
 void KPixmapSequenceOverlayPainter::setAlignment(Qt::Alignment align)
 {
     bool restart = d->m_started;
     stop();
     d->m_alignment = align;
     if (restart) {
         start();
     }
 }
 
 void KPixmapSequenceOverlayPainter::setOffset(const QPoint &offset)
 {
     bool restart = d->m_started;
     stop();
     d->m_offset = offset;
     if (restart) {
         start();
     }
 }
 
 void KPixmapSequenceOverlayPainter::start()
 {
     if (d->m_widget) {
         stop();
 
         d->m_counter = 0;
         d->m_started = true;
         d->m_widget->installEventFilter(this);
         if (d->m_widget->isVisible()) {
             d->m_timer.start();
             d->m_widget->update(d->pixmapRect());
         }
     }
 }
 
 void KPixmapSequenceOverlayPainter::stop()
 {
     d->m_timer.stop();
     if (d->m_widget && d->m_started) {
         d->m_started = false;
         d->m_widget->removeEventFilter(this);
         d->m_widget->update(d->pixmapRect());
     }
 }
 
 bool KPixmapSequenceOverlayPainter::eventFilter(QObject *obj, QEvent *event)
 {
     if (obj == d->m_widget) {
         switch (event->type()) {
         case QEvent::Paint:
             // make sure we paint after everyone else including other event filters
             obj->removeEventFilter(this); // don't recourse...
             QCoreApplication::sendEvent(obj, event);
             d->paintFrame();
             obj->installEventFilter(this); // catch on...
             return true;
             break;
         case QEvent::Hide:
             d->m_timer.stop();
             break;
         case QEvent::Show:
             if (d->m_started) {
                 d->m_timer.start();
                 d->m_widget->update(d->pixmapRect());
             }
             break;
         default:
             break;
         }
     }
 
     return false;
 }
 
 #include "moc_kpixmapsequenceoverlaypainter.cpp"