cursor.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2013 Martin Gräßlin <mgraesslin@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once
// kwin
#include "effect/globals.h"
// Qt
#include <QHash>
#include <QObject>
#include <QPoint>
// KF
#include <KSharedConfig>
// xcb
#include <xcb/xcb.h>
 
class QTimer;
 
namespace KWin
{
 
class CursorSource;
class Output;
 
namespace ExtendedCursor
{
enum Shape {
    SizeNorthWest = 0x100 + 0,
    SizeNorth = 0x100 + 1,
    SizeNorthEast = 0x100 + 2,
    SizeEast = 0x100 + 3,
    SizeWest = 0x100 + 4,
    SizeSouthEast = 0x100 + 5,
    SizeSouth = 0x100 + 6,
    SizeSouthWest = 0x100 + 7
};
}
 
class KWIN_EXPORT CursorShape
{
public:
    CursorShape() = default;
    CursorShape(Qt::CursorShape qtShape)
    {
        m_shape = qtShape;
    }
    CursorShape(KWin::ExtendedCursor::Shape kwinShape)
    {
        m_shape = kwinShape;
    }
    bool operator==(const CursorShape &o) const
    {
        return m_shape == o.m_shape;
    }
    operator int() const
    {
        return m_shape;
    }
    QByteArray name() const;
 
    static QList<QByteArray> alternatives(const QByteArray &name);
 
private:
    int m_shape = Qt::ArrowCursor;
};
 
class KWIN_EXPORT Cursor : public QObject
{
    Q_OBJECT
public:
    Cursor();
    ~Cursor() override;
    void startMousePolling();
    void stopMousePolling();
    void startCursorTracking();
    void stopCursorTracking();
 
    const QString &themeName() const;
    int themeSize() const;
    static QString defaultThemeName();
    static int defaultThemeSize();
 
    QPointF pos();
    void setPos(const QPointF &pos);
    xcb_cursor_t x11Cursor(CursorShape shape);
    xcb_cursor_t x11Cursor(const QByteArray &name);
 
    QPointF hotspot() const;
    QRectF geometry() const;
    QRectF rect() const;
 
    CursorSource *source() const;
    void setSource(CursorSource *source);
 
    bool isOnOutput(Output *output) const;
 
    void markAsRendered(std::chrono::milliseconds timestamp);
 
Q_SIGNALS:
    void posChanged(const QPointF &pos);
    void mouseChanged(const QPointF &pos, const QPointF &oldpos,
                      Qt::MouseButtons buttons, Qt::MouseButtons oldbuttons,
                      Qt::KeyboardModifiers modifiers, Qt::KeyboardModifiers oldmodifiers);
    void cursorChanged();
    void themeChanged();
    void rendered(std::chrono::milliseconds timestamp);
 
protected:
    virtual void doSetPos();
    virtual void doGetPos();
    virtual void doStartMousePolling();
    virtual void doStopMousePolling();
    virtual void doStartCursorTracking();
    virtual void doStopCursorTracking();
    bool isCursorTracking() const;
    const QPointF &currentPos() const;
    void updatePos(const QPointF &pos);
 
private Q_SLOTS:
    void loadThemeSettings();
    void slotKGlobalSettingsNotifyChange(int type, int arg);
 
private:
    void updateTheme(const QString &name, int size);
    void loadThemeFromKConfig();
    CursorSource *m_source = nullptr;
    QHash<QByteArray, xcb_cursor_t> m_cursors;
    QPointF m_pos;
    int m_mousePollingCounter;
    int m_cursorTrackingCounter;
    QString m_themeName;
    int m_themeSize;
};
 
class KWIN_EXPORT Cursors : public QObject
{
    Q_OBJECT
public:
    Cursor *mouse() const
    {
        return m_mouse;
    }
 
    void setMouse(Cursor *mouse)
    {
        if (m_mouse != mouse) {
            m_mouse = mouse;
 
            addCursor(m_mouse);
            setCurrentCursor(m_mouse);
        }
    }
 
    void addCursor(Cursor *cursor);
    void removeCursor(Cursor *cursor);
 
    Cursor *currentCursor() const
    {
        return m_currentCursor;
    }
 
    void hideCursor();
    void showCursor();
    bool isCursorHidden() const;
 
    static Cursors *self();
 
Q_SIGNALS:
    void currentCursorChanged(Cursor *cursor);
    void hiddenChanged();
    void positionChanged(Cursor *cursor, const QPointF &position);
 
private:
    void emitCurrentCursorChanged();
    void setCurrentCursor(Cursor *cursor);
 
    static Cursors *s_self;
    Cursor *m_currentCursor = nullptr;
    Cursor *m_mouse = nullptr;
    QList<Cursor *> m_cursors;
    int m_cursorHideCounter = 0;
};
 
inline const QPointF &Cursor::currentPos() const
{
    return m_pos;
}
 
inline const QString &Cursor::themeName() const
{
    return m_themeName;
}
 
inline int Cursor::themeSize() const
{
    return m_themeSize;
}
 
inline bool Cursor::isCursorTracking() const
{
    return m_cursorTrackingCounter > 0;
}
 
}
 
Q_DECLARE_METATYPE(KWin::CursorShape)