File indexing completed on 2024-04-28 16:48:41

 /*
     SPDX-FileCopyrightText: 2022 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "cursorsource.h"
 #include "cursor.h"
 #include "wayland/clientconnection.h"
 #include "wayland/shmclientbuffer.h"
 #include "wayland/surface_interface.h"
 
 namespace KWin
 {
 
 CursorSource::CursorSource(QObject *parent)
     : QObject(parent)
 {
 }
 
 QImage CursorSource::image() const
 {
     return m_image;
 }
 
 QSize CursorSource::size() const
 {
     return m_size;
 }
 
 QPoint CursorSource::hotspot() const
 {
     return m_hotspot;
 }
 
 ImageCursorSource::ImageCursorSource(QObject *parent)
     : CursorSource(parent)
 {
 }
 
 void ImageCursorSource::update(const QImage &image, const QPoint &hotspot)
 {
     m_image = image;
     m_size = image.size() / image.devicePixelRatio();
     m_hotspot = hotspot;
     Q_EMIT changed();
 }
 
 ShapeCursorSource::ShapeCursorSource(QObject *parent)
     : CursorSource(parent)
 {
     m_delayTimer.setSingleShot(true);
     connect(&m_delayTimer, &QTimer::timeout, this, &ShapeCursorSource::selectNextSprite);
 }
 
 QByteArray ShapeCursorSource::shape() const
 {
     return m_shape;
 }
 
 void ShapeCursorSource::setShape(const QByteArray &shape)
 {
     if (m_shape != shape) {
         m_shape = shape;
         refresh();
     }
 }
 
 void ShapeCursorSource::setShape(Qt::CursorShape shape)
 {
     setShape(CursorShape(shape).name());
 }
 
 KXcursorTheme ShapeCursorSource::theme() const
 {
     return m_theme;
 }
 
 void ShapeCursorSource::setTheme(const KXcursorTheme &theme)
 {
     if (m_theme != theme) {
         m_theme = theme;
         refresh();
     }
 }
 
 void ShapeCursorSource::refresh()
 {
     m_currentSprite = -1;
     m_delayTimer.stop();
 
     m_sprites = m_theme.shape(m_shape);
     if (m_sprites.isEmpty()) {
         const auto alternativeNames = Cursor::cursorAlternativeNames(m_shape);
         for (const QByteArray &alternativeName : alternativeNames) {
             m_sprites = m_theme.shape(alternativeName);
             if (!m_sprites.isEmpty()) {
                 break;
             }
         }
     }
 
     if (!m_sprites.isEmpty()) {
         selectSprite(0);
     }
 }
 
 void ShapeCursorSource::selectNextSprite()
 {
     selectSprite((m_currentSprite + 1) % m_sprites.size());
 }
 
 void ShapeCursorSource::selectSprite(int index)
 {
     if (m_currentSprite == index) {
         return;
     }
     const KXcursorSprite &sprite = m_sprites[index];
     m_currentSprite = index;
     m_image = sprite.data();
     m_size = m_image.size() / m_image.devicePixelRatio();
     m_hotspot = sprite.hotspot();
     if (sprite.delay().count() && m_sprites.size() > 1) {
         m_delayTimer.start(sprite.delay());
     }
     Q_EMIT changed();
 }
 
 SurfaceCursorSource::SurfaceCursorSource(QObject *parent)
     : CursorSource(parent)
 {
 }
 
 KWaylandServer::SurfaceInterface *SurfaceCursorSource::surface() const
 {
     return m_surface;
 }
 
 void SurfaceCursorSource::update(KWaylandServer::SurfaceInterface *surface, const QPoint &hotspot)
 {
     if (!surface) {
         m_image = QImage();
         m_size = QSize(0, 0);
         m_hotspot = QPoint();
         m_surface = nullptr;
     } else {
         // TODO Plasma 6: once Xwayland cursor scaling can be done correctly, remove this
         // scaling is intentionally applied "wrong" here to make the cursor stay a consistent size even with un-scaled Xwayland:
         // - the device pixel ratio of the image is not multiplied by scaleOverride
         // - the surface size is scaled up with scaleOverride, to un-do the scaling done elsewhere
         auto buffer = qobject_cast<KWaylandServer::ShmClientBuffer *>(surface->buffer());
         if (buffer) {
             m_image = buffer->data().copy();
             m_image.setDevicePixelRatio(surface->bufferScale());
         } else {
             m_image = QImage();
         }
         m_size = (surface->size() * surface->client()->scaleOverride()).toSize();
         m_hotspot = hotspot;
         m_surface = surface;
     }
     Q_EMIT changed();
 }
 
 } // namespace KWin