Advance Wayland and KDE package bring-up

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

local/recipes/kde/kf6-kwidgetsaddons/source/src/kpixmapsequenceoverlaypainter.cpp

@@ -0,0 +1,262 @@
+/*
+    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"