screenedge.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2011 Arthur Arlt <a.arlt@stud.uni-heidelberg.de>
    SPDX-FileCopyrightText: 2013 Martin Gräßlin <mgraesslin@kde.org>
 
    Since the functionality provided in this class has been moved from
    class Workspace, it is not clear who exactly has written the code.
    The list below contains the copyright holders of the class Workspace.
 
    SPDX-FileCopyrightText: 1999, 2000 Matthias Ettrich <ettrich@kde.org>
    SPDX-FileCopyrightText: 2003 Lubos Lunak <l.lunak@kde.org>
    SPDX-FileCopyrightText: 2009 Lucas Murray <lmurray@undefinedfire.com>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
 
#pragma once
// KWin
#include "effect/globals.h"
// KDE includes
#include <KSharedConfig>
// Qt
#include <QDateTime>
#include <QList>
#include <QObject>
#include <QRect>
 
#include <memory>
#include <xcb/xcb.h>
 
class QAction;
class QMouseEvent;
 
namespace KWin
{
 
class Window;
class Output;
class GestureRecognizer;
class ScreenEdges;
class SwipeGesture;
 
class TouchCallback
{
public:
    using CallbackFunction = std::function<void(ElectricBorder border, const QPointF &, Output *output)>;
    explicit TouchCallback(QAction *touchUpAction, TouchCallback::CallbackFunction progressCallback);
    ~TouchCallback();
 
    QAction *touchUpAction() const;
    void progressCallback(ElectricBorder border, const QPointF &deltaProgress, Output *output) const;
    bool hasProgressCallback() const;
 
private:
    QAction *m_touchUpAction = nullptr;
    TouchCallback::CallbackFunction m_progressCallback;
};
 
class KWIN_EXPORT Edge : public QObject
{
    Q_OBJECT
public:
    explicit Edge(ScreenEdges *parent);
    ~Edge() override;
    bool isLeft() const;
    bool isTop() const;
    bool isRight() const;
    bool isBottom() const;
    bool isCorner() const;
    bool isScreenEdge() const;
    bool triggersFor(const QPoint &cursorPos) const;
    bool check(const QPoint &cursorPos, const QDateTime &triggerTime, bool forceNoPushBack = false);
    void markAsTriggered(const QPoint &cursorPos, const QDateTime &triggerTime);
    bool isReserved() const;
    const QRect &approachGeometry() const;
 
    ElectricBorder border() const;
    void reserve(QObject *object, const char *slot);
    const QHash<QObject *, QByteArray> &callBacks() const;
    void reserveTouchCallBack(QAction *action, TouchCallback::CallbackFunction callback = nullptr);
    void unreserveTouchCallBack(QAction *action);
    void startApproaching();
    void stopApproaching();
    bool isApproaching() const;
    void setClient(Window *client);
    Window *client() const;
    void setOutput(Output *output);
    Output *output() const;
    const QRect &geometry() const;
    void setTouchAction(ElectricBorderAction action);
 
    bool activatesForPointer() const;
    bool activatesForTouchGesture() const;
 
    virtual quint32 window() const;
    virtual quint32 approachWindow() const;
 
public Q_SLOTS:
    void reserve();
    void unreserve();
    void unreserve(QObject *object);
    void setBorder(ElectricBorder border);
    void setAction(ElectricBorderAction action);
    void setGeometry(const QRect &geometry);
    void updateApproaching(const QPointF &point);
    void checkBlocking();
Q_SIGNALS:
    void approaching(ElectricBorder border, qreal factor, const QRect &geometry);
    void activatesForTouchGestureChanged();
 
protected:
    ScreenEdges *edges();
    const ScreenEdges *edges() const;
    bool isBlocked() const;
    virtual void doGeometryUpdate();
    virtual void doActivate();
    virtual void doDeactivate();
    virtual void doStartApproaching();
    virtual void doStopApproaching();
    virtual void doUpdateBlocking();
 
private:
    void activate();
    void deactivate();
    bool canActivate(const QPoint &cursorPos, const QDateTime &triggerTime);
    void handle(const QPoint &cursorPos);
    bool handleAction(ElectricBorderAction action);
    bool handlePointerAction()
    {
        return handleAction(m_action);
    }
    bool handleTouchAction()
    {
        return handleAction(m_touchAction);
    }
    bool handleByCallback();
    void handleTouchCallback();
    void switchDesktop(const QPoint &cursorPos);
    void pushCursorBack(const QPoint &cursorPos);
    void reserveTouchCallBack(const TouchCallback &callback);
    QList<TouchCallback> touchCallBacks() const
    {
        return m_touchCallbacks;
    }
    ScreenEdges *m_edges;
    ElectricBorder m_border;
    ElectricBorderAction m_action;
    ElectricBorderAction m_touchAction = ElectricActionNone;
    int m_reserved;
    QRect m_geometry;
    QRect m_approachGeometry;
    QDateTime m_lastTrigger;
    QDateTime m_lastReset;
    QPoint m_triggeredPoint;
    QHash<QObject *, QByteArray> m_callBacks;
    bool m_approaching;
    int m_lastApproachingFactor;
    bool m_blocked;
    bool m_pushBackBlocked;
    Window *m_client;
    Output *m_output;
    std::unique_ptr<SwipeGesture> m_gesture;
    QList<TouchCallback> m_touchCallbacks;
    friend class ScreenEdges;
};
 
class KWIN_EXPORT ScreenEdges : public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool desktopSwitching READ isDesktopSwitching)
    Q_PROPERTY(bool desktopSwitchingMovingClients READ isDesktopSwitchingMovingClients)
    Q_PROPERTY(QSize cursorPushBackDistance READ cursorPushBackDistance)
    Q_PROPERTY(int timeThreshold READ timeThreshold)
    Q_PROPERTY(int reActivateThreshold READ reActivationThreshold)
    Q_PROPERTY(int actionTopLeft READ actionTopLeft)
    Q_PROPERTY(int actionTop READ actionTop)
    Q_PROPERTY(int actionTopRight READ actionTopRight)
    Q_PROPERTY(int actionRight READ actionRight)
    Q_PROPERTY(int actionBottomRight READ actionBottomRight)
    Q_PROPERTY(int actionBottom READ actionBottom)
    Q_PROPERTY(int actionBottomLeft READ actionBottomLeft)
    Q_PROPERTY(int actionLeft READ actionLeft)
public:
    explicit ScreenEdges();
    void setConfig(KSharedConfig::Ptr config);
    void init();
    void check(const QPoint &pos, const QDateTime &now, bool forceNoPushBack = false);
    int cornerOffset() const;
    void reserve(ElectricBorder border, QObject *object, const char *callback);
    void unreserve(ElectricBorder border, QObject *object);
    bool reserve(KWin::Window *client, ElectricBorder border);
 
    void reserveTouch(ElectricBorder border, QAction *action, TouchCallback::CallbackFunction callback = nullptr);
    void unreserveTouch(ElectricBorder border, QAction *action);
 
    void reserveDesktopSwitching(bool isToReserve, Qt::Orientations o);
    void ensureOnTop();
    bool isEntered(QMouseEvent *event);
 
    QList<xcb_window_t> windows() const;
 
    bool isDesktopSwitching() const;
    bool isDesktopSwitchingMovingClients() const;
    const QSize &cursorPushBackDistance() const;
    int timeThreshold() const;
    int reActivationThreshold() const;
    ElectricBorderAction actionTopLeft() const;
    ElectricBorderAction actionTop() const;
    ElectricBorderAction actionTopRight() const;
    ElectricBorderAction actionRight() const;
    ElectricBorderAction actionBottomRight() const;
    ElectricBorderAction actionBottom() const;
    ElectricBorderAction actionBottomLeft() const;
    ElectricBorderAction actionLeft() const;
 
    ElectricBorderAction actionForTouchBorder(ElectricBorder border) const;
 
    GestureRecognizer *gestureRecognizer() const
    {
        return m_gestureRecognizer;
    }
 
    bool handleDndNotify(xcb_window_t window, const QPoint &point);
    bool handleEnterNotifiy(xcb_window_t window, const QPoint &point, const QDateTime &timestamp);
    bool remainActiveOnFullscreen() const;
    const std::vector<std::unique_ptr<Edge>> &edges() const;
 
public Q_SLOTS:
    void reconfigure();
    void updateLayout();
    void recreateEdges();
 
Q_SIGNALS:
    void approaching(ElectricBorder border, qreal factor, const QRect &geometry);
    void checkBlocking();
 
private:
    enum {
        ElectricDisabled = 0,
        ElectricMoveOnly = 1,
        ElectricAlways = 2,
    };
    void setDesktopSwitching(bool enable);
    void setDesktopSwitchingMovingClients(bool enable);
    void setCursorPushBackDistance(const QSize &distance);
    void setTimeThreshold(int threshold);
    void setReActivationThreshold(int threshold);
    void createHorizontalEdge(ElectricBorder border, const QRect &screen, const QRect &fullArea, Output *output);
    void createVerticalEdge(ElectricBorder border, const QRect &screen, const QRect &fullArea, Output *output);
    std::unique_ptr<Edge> createEdge(ElectricBorder border, int x, int y, int width, int height, Output *output, bool createAction = true);
    void setActionForBorder(ElectricBorder border, ElectricBorderAction *oldValue, ElectricBorderAction newValue);
    void setActionForTouchBorder(ElectricBorder border, ElectricBorderAction newValue);
    void setRemainActiveOnFullscreen(bool remainActive);
    ElectricBorderAction actionForEdge(Edge *edge) const;
    ElectricBorderAction actionForTouchEdge(Edge *edge) const;
    bool createEdgeForClient(Window *client, ElectricBorder border);
    void deleteEdgeForClient(Window *client);
    bool m_desktopSwitching;
    bool m_desktopSwitchingMovingClients;
    QSize m_cursorPushBackDistance;
    int m_timeThreshold;
    int m_reactivateThreshold;
    Qt::Orientations m_virtualDesktopLayout;
    std::vector<std::unique_ptr<Edge>> m_edges;
    KSharedConfig::Ptr m_config;
    ElectricBorderAction m_actionTopLeft;
    ElectricBorderAction m_actionTop;
    ElectricBorderAction m_actionTopRight;
    ElectricBorderAction m_actionRight;
    ElectricBorderAction m_actionBottomRight;
    ElectricBorderAction m_actionBottom;
    ElectricBorderAction m_actionBottomLeft;
    ElectricBorderAction m_actionLeft;
    QMap<ElectricBorder, ElectricBorderAction> m_touchCallbacks;
    int m_cornerOffset;
    GestureRecognizer *m_gestureRecognizer;
    bool m_remainActiveOnFullscreen = false;
};
 
/**********************************************************
 * Inlines Edge
 *********************************************************/
 
inline bool Edge::isBottom() const
{
    return m_border == ElectricBottom || m_border == ElectricBottomLeft || m_border == ElectricBottomRight;
}
 
inline bool Edge::isLeft() const
{
    return m_border == ElectricLeft || m_border == ElectricTopLeft || m_border == ElectricBottomLeft;
}
 
inline bool Edge::isRight() const
{
    return m_border == ElectricRight || m_border == ElectricTopRight || m_border == ElectricBottomRight;
}
 
inline bool Edge::isTop() const
{
    return m_border == ElectricTop || m_border == ElectricTopLeft || m_border == ElectricTopRight;
}
 
inline bool Edge::isCorner() const
{
    return m_border == ElectricTopLeft
        || m_border == ElectricTopRight
        || m_border == ElectricBottomRight
        || m_border == ElectricBottomLeft;
}
 
inline bool Edge::isScreenEdge() const
{
    return m_border == ElectricLeft
        || m_border == ElectricRight
        || m_border == ElectricTop
        || m_border == ElectricBottom;
}
 
inline bool Edge::isReserved() const
{
    return m_reserved != 0;
}
 
inline void Edge::setAction(ElectricBorderAction action)
{
    m_action = action;
}
 
inline ScreenEdges *Edge::edges()
{
    return m_edges;
}
 
inline const ScreenEdges *Edge::edges() const
{
    return m_edges;
}
 
inline const QRect &Edge::geometry() const
{
    return m_geometry;
}
 
inline const QRect &Edge::approachGeometry() const
{
    return m_approachGeometry;
}
 
inline ElectricBorder Edge::border() const
{
    return m_border;
}
 
inline const QHash<QObject *, QByteArray> &Edge::callBacks() const
{
    return m_callBacks;
}
 
inline bool Edge::isBlocked() const
{
    return m_blocked;
}
 
inline Window *Edge::client() const
{
    return m_client;
}
 
inline bool Edge::isApproaching() const
{
    return m_approaching;
}
 
/**********************************************************
 * Inlines ScreenEdges
 *********************************************************/
inline void ScreenEdges::setConfig(KSharedConfig::Ptr config)
{
    m_config = config;
}
 
inline int ScreenEdges::cornerOffset() const
{
    return m_cornerOffset;
}
 
inline const QSize &ScreenEdges::cursorPushBackDistance() const
{
    return m_cursorPushBackDistance;
}
 
inline bool ScreenEdges::isDesktopSwitching() const
{
    return m_desktopSwitching;
}
 
inline bool ScreenEdges::isDesktopSwitchingMovingClients() const
{
    return m_desktopSwitchingMovingClients;
}
 
inline int ScreenEdges::reActivationThreshold() const
{
    return m_reactivateThreshold;
}
 
inline int ScreenEdges::timeThreshold() const
{
    return m_timeThreshold;
}
 
inline void ScreenEdges::setCursorPushBackDistance(const QSize &distance)
{
    m_cursorPushBackDistance = distance;
}
 
inline void ScreenEdges::setDesktopSwitching(bool enable)
{
    if (enable == m_desktopSwitching) {
        return;
    }
    m_desktopSwitching = enable;
    reserveDesktopSwitching(enable, m_virtualDesktopLayout);
}
 
inline void ScreenEdges::setDesktopSwitchingMovingClients(bool enable)
{
    m_desktopSwitchingMovingClients = enable;
}
 
inline void ScreenEdges::setReActivationThreshold(int threshold)
{
    Q_ASSERT(threshold >= m_timeThreshold);
    m_reactivateThreshold = threshold;
}
 
inline void ScreenEdges::setTimeThreshold(int threshold)
{
    m_timeThreshold = threshold;
}
 
#define ACTION(name)                                      \
    inline ElectricBorderAction ScreenEdges::name() const \
    {                                                     \
        return m_##name;                                  \
    }
 
ACTION(actionTopLeft)
ACTION(actionTop)
ACTION(actionTopRight)
ACTION(actionRight)
ACTION(actionBottomRight)
ACTION(actionBottom)
ACTION(actionBottomLeft)
ACTION(actionLeft)
 
#undef ACTION
 
}