virtualdesktops.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2012 Martin Gräßlin <mgraesslin@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once
// KWin
#include "effect/globals.h"
#include <kwin_export.h>
// Qt includes
#include <QAction>
#include <QObject>
#include <QPoint>
#include <QPointer>
#include <QSize>
 
// KDE includes
#include <KConfig>
#include <KSharedConfig>
 
class KLocalizedString;
class NETRootInfo;
class QAction;
 
namespace KWin
{
 
class Options;
class PlasmaVirtualDesktopManagementInterface;
 
class KWIN_EXPORT VirtualDesktop : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString id READ id CONSTANT)
    Q_PROPERTY(uint x11DesktopNumber READ x11DesktopNumber NOTIFY x11DesktopNumberChanged)
    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
public:
    explicit VirtualDesktop(QObject *parent = nullptr);
    ~VirtualDesktop() override;
 
    void setId(const QString &id);
    QString id() const
    {
        return m_id;
    }
 
    void setName(const QString &name);
    QString name() const
    {
        return m_name;
    }
 
    void setX11DesktopNumber(uint number);
    uint x11DesktopNumber() const
    {
        return m_x11DesktopNumber;
    }
 
Q_SIGNALS:
    void nameChanged();
    void x11DesktopNumberChanged();
    void aboutToBeDestroyed();
 
private:
    QString m_id;
    QString m_name;
    int m_x11DesktopNumber = 0;
};
 
class VirtualDesktopGrid
{
public:
    VirtualDesktopGrid();
    ~VirtualDesktopGrid();
    void update(const QSize &size, const QList<VirtualDesktop *> &desktops);
    QPoint gridCoords(uint id) const;
    QPoint gridCoords(VirtualDesktop *vd) const;
    VirtualDesktop *at(const QPoint &coords) const;
    int width() const;
    int height() const;
    const QSize &size() const;
 
private:
    QSize m_size;
    QList<QList<VirtualDesktop *>> m_grid;
};
 
class KWIN_EXPORT VirtualDesktopManager : public QObject
{
    Q_OBJECT
    Q_PROPERTY(uint count READ count WRITE setCount NOTIFY countChanged)
    Q_PROPERTY(uint current READ current WRITE setCurrent NOTIFY currentChanged)
    Q_PROPERTY(bool navigationWrappingAround READ isNavigationWrappingAround WRITE setNavigationWrappingAround NOTIFY navigationWrappingAroundChanged)
public:
    ~VirtualDesktopManager() override;
    void setRootInfo(NETRootInfo *info);
    void setVirtualDesktopManagement(PlasmaVirtualDesktopManagementInterface *management);
    void setConfig(KSharedConfig::Ptr config);
    uint count() const;
    uint rows() const;
    uint current() const;
    VirtualDesktop *currentDesktop() const;
    template<typename Direction>
    void moveTo(bool wrap = false);
 
    bool isNavigationWrappingAround() const;
 
    const VirtualDesktopGrid &grid() const;
 
    enum class Direction {
        Up,
        Down,
        Right,
        Left,
        Next,
        Previous
    };
    VirtualDesktop *inDirection(VirtualDesktop *desktop, Direction direction, bool wrap = true);
    uint inDirection(uint desktop, Direction direction, bool wrap = true);
    void moveTo(Direction direction, bool wrap = true);
 
    VirtualDesktop *above(VirtualDesktop *desktop, bool wrap = true) const;
    VirtualDesktop *toRight(VirtualDesktop *desktop, bool wrap = true) const;
    VirtualDesktop *below(VirtualDesktop *desktop, bool wrap = true) const;
    VirtualDesktop *toLeft(VirtualDesktop *desktop, bool wrap = true) const;
    VirtualDesktop *next(VirtualDesktop *desktop = nullptr, bool wrap = true) const;
    VirtualDesktop *previous(VirtualDesktop *desktop = nullptr, bool wrap = true) const;
 
    void initShortcuts();
 
    QList<VirtualDesktop *> desktops() const
    {
        return m_desktops;
    }
 
    VirtualDesktop *desktopForX11Id(uint id) const;
 
    VirtualDesktop *desktopForId(const QString &id) const;
 
    VirtualDesktop *createVirtualDesktop(uint position, const QString &name = QString());
 
    void removeVirtualDesktop(const QString &id);
    void removeVirtualDesktop(VirtualDesktop *desktop);
 
    void updateRootInfo();
 
    static uint maximum();
 
public Q_SLOTS:
    void setCount(uint count);
    bool setCurrent(uint current);
    bool setCurrent(VirtualDesktop *current);
    void setRows(uint rows);
    void updateLayout();
    void setNavigationWrappingAround(bool enabled);
    void load();
    void save();
 
Q_SIGNALS:
    void countChanged(uint previousCount, uint newCount);
 
    void rowsChanged(uint rows);
 
    void desktopAdded(KWin::VirtualDesktop *desktop);
 
    void desktopRemoved(KWin::VirtualDesktop *desktop);
 
    void currentChanged(KWin::VirtualDesktop *previousDesktop, KWin::VirtualDesktop *newDesktop);
 
    void currentChanging(KWin::VirtualDesktop *currentDesktop, QPointF offset);
    void currentChangingCancelled();
 
    void layoutChanged(int columns, int rows);
    void navigationWrappingAroundChanged();
 
private Q_SLOTS:
    void slotSwitchTo();
    void slotNext();
    void slotPrevious();
    void slotRight();
    void slotLeft();
    void slotUp();
    void slotDown();
 
    /* For gestured desktopSwitching
     * Called when gesture ended, the thing that actually switches the desktop.
     */
    void gestureReleasedY();
    void gestureReleasedX();
 
private:
    QString defaultName(int desktop) const;
    void initSwitchToShortcuts();
    QAction *addAction(const QString &name, const KLocalizedString &label, uint value, const QKeySequence &key, void (VirtualDesktopManager::*slot)());
    QAction *addAction(const QString &name, const QString &label, const QKeySequence &key, void (VirtualDesktopManager::*slot)());
 
    QList<VirtualDesktop *> m_desktops;
    QPointer<VirtualDesktop> m_current;
    quint32 m_rows = 2;
    bool m_navigationWrapsAround;
    VirtualDesktopGrid m_grid;
    // TODO: QPointer
    NETRootInfo *m_rootInfo;
    PlasmaVirtualDesktopManagementInterface *m_virtualDesktopManagement = nullptr;
    KSharedConfig::Ptr m_config;
 
    std::unique_ptr<QAction> m_swipeGestureReleasedY;
    std::unique_ptr<QAction> m_swipeGestureReleasedX;
    QPointF m_currentDesktopOffset = QPointF(0, 0);
 
    KWIN_SINGLETON_VARIABLE(VirtualDesktopManager, s_manager)
};
 
inline int VirtualDesktopGrid::width() const
{
    return m_size.width();
}
 
inline int VirtualDesktopGrid::height() const
{
    return m_size.height();
}
 
inline const QSize &VirtualDesktopGrid::size() const
{
    return m_size;
}
 
inline uint VirtualDesktopManager::maximum()
{
    return 20;
}
 
inline uint VirtualDesktopManager::count() const
{
    return m_desktops.count();
}
 
inline bool VirtualDesktopManager::isNavigationWrappingAround() const
{
    return m_navigationWrapsAround;
}
 
inline void VirtualDesktopManager::setConfig(KSharedConfig::Ptr config)
{
    m_config = std::move(config);
}
 
inline const VirtualDesktopGrid &VirtualDesktopManager::grid() const
{
    return m_grid;
}
 
} // namespace KWin