effecthandler.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2006 Lubos Lunak <l.lunak@kde.org>
    SPDX-FileCopyrightText: 2009 Lucas Murray <lmurray@undefinedfire.com>
    SPDX-FileCopyrightText: 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
    SPDX-FileCopyrightText: 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
 
#pragma once
 
#include "effect/effect.h"
#include "effect/effectwindow.h"
 
#include <QEasingCurve>
#include <QIcon>
#include <QPair>
#include <QRect>
#include <QRegion>
#include <QSet>
 
#include <QHash>
#include <QList>
#include <QLoggingCategory>
#include <QStack>
 
#include <netwm.h>
 
#include <functional>
 
class KConfigGroup;
class QFont;
class QKeyEvent;
class QMatrix4x4;
class QMouseEvent;
class QWheelEvent;
class QAction;
class QTabletEvent;
class QQmlEngine;
 
Q_DECLARE_LOGGING_CATEGORY(KWINEFFECTS)
 
namespace KDecoration2
{
class Decoration;
}
 
namespace KWin
{
 
class SurfaceInterface;
class Display;
class PaintDataPrivate;
class WindowPaintDataPrivate;
 
class Compositor;
class EffectLoader;
class EffectWindow;
class EffectWindowGroup;
class OffscreenQuickView;
class Group;
class Output;
class Effect;
class TabletEvent;
class TabletPadId;
class TabletToolId;
class Window;
class WindowItem;
class WindowPropertyNotifyX11Filter;
class WorkspaceScene;
class VirtualDesktop;
 
typedef QPair<QString, Effect *> EffectPair;
 
enum DataRole {
    // Grab roles are used to force all other animations to ignore the window.
    // The value of the data is set to the Effect's `this` value.
    WindowAddedGrabRole = 1,
    WindowClosedGrabRole,
    WindowMinimizedGrabRole,
    WindowUnminimizedGrabRole,
    WindowForceBlurRole, 
    WindowForceBackgroundContrastRole, 
};
 
class KWIN_EXPORT EffectsHandler : public QObject
{
    Q_OBJECT
    Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Effects")
 
    Q_PROPERTY(QStringList activeEffects READ activeEffects)
    Q_PROPERTY(QStringList loadedEffects READ loadedEffects)
    Q_PROPERTY(QStringList listOfEffects READ listOfEffects)
 
    Q_PROPERTY(KWin::VirtualDesktop *currentDesktop READ currentDesktop WRITE setCurrentDesktop NOTIFY desktopChanged)
    Q_PROPERTY(QString currentActivity READ currentActivity NOTIFY currentActivityChanged)
    Q_PROPERTY(KWin::EffectWindow *activeWindow READ activeWindow WRITE activateWindow NOTIFY windowActivated)
    Q_PROPERTY(QSize desktopGridSize READ desktopGridSize NOTIFY desktopGridSizeChanged)
    Q_PROPERTY(int desktopGridWidth READ desktopGridWidth NOTIFY desktopGridWidthChanged)
    Q_PROPERTY(int desktopGridHeight READ desktopGridHeight NOTIFY desktopGridHeightChanged)
    Q_PROPERTY(int workspaceWidth READ workspaceWidth)
    Q_PROPERTY(int workspaceHeight READ workspaceHeight)
    Q_PROPERTY(QList<KWin::VirtualDesktop *> desktops READ desktops)
    Q_PROPERTY(bool optionRollOverDesktops READ optionRollOverDesktops)
    Q_PROPERTY(KWin::Output *activeScreen READ activeScreen)
    Q_PROPERTY(qreal animationTimeFactor READ animationTimeFactor)
    Q_PROPERTY(QList<EffectWindow *> stackingOrder READ stackingOrder)
    Q_PROPERTY(bool decorationsHaveAlpha READ decorationsHaveAlpha)
    Q_PROPERTY(CompositingType compositingType READ compositingType CONSTANT)
    Q_PROPERTY(QPointF cursorPos READ cursorPos)
    Q_PROPERTY(QSize virtualScreenSize READ virtualScreenSize NOTIFY virtualScreenSizeChanged)
    Q_PROPERTY(QRect virtualScreenGeometry READ virtualScreenGeometry NOTIFY virtualScreenGeometryChanged)
    Q_PROPERTY(bool hasActiveFullScreenEffect READ hasActiveFullScreenEffect NOTIFY hasActiveFullScreenEffectChanged)
 
    Q_PROPERTY(KWin::SessionState sessionState READ sessionState NOTIFY sessionStateChanged)
 
    Q_PROPERTY(KWin::EffectWindow *inputPanel READ inputPanel NOTIFY inputPanelChanged)
 
    friend class Effect;
 
public:
    using TouchBorderCallback = std::function<void(ElectricBorder border, const QPointF &, Output *screen)>;
 
    EffectsHandler(Compositor *compositor, WorkspaceScene *scene);
    ~EffectsHandler() override;
 
    // internal (used by kwin core or compositing code)
    void startPaint();
 
    // for use by effects
    void prePaintScreen(ScreenPrePaintData &data, std::chrono::milliseconds presentTime);
    void paintScreen(const RenderTarget &renderTarget, const RenderViewport &viewport, int mask, const QRegion &region, Output *screen);
    void postPaintScreen();
    void prePaintWindow(EffectWindow *w, WindowPrePaintData &data, std::chrono::milliseconds presentTime);
    void paintWindow(const RenderTarget &renderTarget, const RenderViewport &viewport, EffectWindow *w, int mask, const QRegion &region, WindowPaintData &data);
    void postPaintWindow(EffectWindow *w);
    void drawWindow(const RenderTarget &renderTarget, const RenderViewport &viewport, EffectWindow *w, int mask, const QRegion &region, WindowPaintData &data);
    void renderWindow(const RenderTarget &renderTarget, const RenderViewport &viewport, EffectWindow *w, int mask, const QRegion &region, WindowPaintData &data);
    QVariant kwinOption(KWinOption kwopt);
    virtual void defineCursor(Qt::CursorShape shape);
    QPointF cursorPos() const;
    bool grabKeyboard(Effect *effect);
    void ungrabKeyboard();
    void startMouseInterception(Effect *effect, Qt::CursorShape shape);
    void stopMouseInterception(Effect *effect);
    bool isMouseInterception() const;
 
    bool checkInputWindowEvent(QMouseEvent *e);
    bool checkInputWindowEvent(QWheelEvent *e);
    void checkInputWindowStacking();
 
    void grabbedKeyboardEvent(QKeyEvent *e);
    bool hasKeyboardGrab() const;
 
    void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action);
    void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action);
 
    void registerTouchpadSwipeShortcut(SwipeDirection dir, uint fingerCount, QAction *onUp, std::function<void(qreal)> progressCallback = {});
 
    void registerTouchpadPinchShortcut(PinchDirection dir, uint fingerCount, QAction *onUp, std::function<void(qreal)> progressCallback = {});
 
    void registerTouchscreenSwipeShortcut(SwipeDirection direction, uint fingerCount, QAction *action, std::function<void(qreal)> progressCallback);
 
    // Mouse polling
    void startMousePolling();
    void stopMousePolling();
 
    void reserveElectricBorder(ElectricBorder border, Effect *effect);
    void unreserveElectricBorder(ElectricBorder border, Effect *effect);
 
    void registerTouchBorder(ElectricBorder border, QAction *action);
 
    void registerRealtimeTouchBorder(ElectricBorder border, QAction *action, TouchBorderCallback progressCallback);
 
    void unregisterTouchBorder(ElectricBorder border, QAction *action);
 
    // functions that allow controlling windows/desktop
    void activateWindow(KWin::EffectWindow *c);
    KWin::EffectWindow *activeWindow() const;
    Q_SCRIPTABLE void moveWindow(KWin::EffectWindow *w, const QPoint &pos, bool snap = false, double snapAdjust = 1.0);
 
    Q_SCRIPTABLE void windowToDesktops(KWin::EffectWindow *w, const QList<KWin::VirtualDesktop *> &desktops);
 
    Q_SCRIPTABLE void windowToScreen(KWin::EffectWindow *w, Output *screen);
    void setShowingDesktop(bool showing);
 
    // Activities
    QString currentActivity() const;
    // Desktops
    VirtualDesktop *currentDesktop() const;
    QList<VirtualDesktop *> desktops() const;
    void setCurrentDesktop(KWin::VirtualDesktop *desktop);
    QSize desktopGridSize() const;
    int desktopGridWidth() const;
    int desktopGridHeight() const;
    int workspaceWidth() const;
    int workspaceHeight() const;
    VirtualDesktop *desktopAtCoords(QPoint coords) const;
    QPoint desktopGridCoords(VirtualDesktop *desktop) const;
    QPoint desktopCoords(VirtualDesktop *desktop) const;
    Q_SCRIPTABLE KWin::VirtualDesktop *desktopAbove(KWin::VirtualDesktop *desktop = nullptr, bool wrap = true) const;
    Q_SCRIPTABLE KWin::VirtualDesktop *desktopToRight(KWin::VirtualDesktop *desktop = nullptr, bool wrap = true) const;
    Q_SCRIPTABLE KWin::VirtualDesktop *desktopBelow(KWin::VirtualDesktop *desktop = nullptr, bool wrap = true) const;
    Q_SCRIPTABLE KWin::VirtualDesktop *desktopToLeft(KWin::VirtualDesktop *desktop = nullptr, bool wrap = true) const;
    Q_SCRIPTABLE QString desktopName(KWin::VirtualDesktop *desktop) const;
    bool optionRollOverDesktops() const;
 
    Output *activeScreen() const; // Xinerama
    QRectF clientArea(clientAreaOption, const Output *screen, const VirtualDesktop *desktop) const;
    QRectF clientArea(clientAreaOption, const EffectWindow *c) const;
    QRectF clientArea(clientAreaOption, const QPoint &p, const VirtualDesktop *desktop) const;
 
    QSize virtualScreenSize() const;
    QRect virtualScreenGeometry() const;
    double animationTimeFactor() const;
 
    Q_SCRIPTABLE KWin::EffectWindow *findWindow(WId id) const;
    Q_SCRIPTABLE KWin::EffectWindow *findWindow(SurfaceInterface *surf) const;
    Q_SCRIPTABLE KWin::EffectWindow *findWindow(QWindow *w) const;
    Q_SCRIPTABLE KWin::EffectWindow *findWindow(const QUuid &id) const;
    QList<EffectWindow *> stackingOrder() const;
    // window will be temporarily painted as if being at the top of the stack
    Q_SCRIPTABLE void setElevatedWindow(KWin::EffectWindow *w, bool set);
 
    void setTabBoxWindow(EffectWindow *);
    QList<EffectWindow *> currentTabBoxWindowList() const;
    void refTabBox();
    void unrefTabBox();
    void closeTabBox();
    EffectWindow *currentTabBoxWindow() const;
 
    void setActiveFullScreenEffect(Effect *e);
    Effect *activeFullScreenEffect() const;
 
    Q_SCRIPTABLE void addRepaintFull();
    Q_SCRIPTABLE void addRepaint(const QRectF &r);
    Q_SCRIPTABLE void addRepaint(const QRect &r);
    Q_SCRIPTABLE void addRepaint(const QRegion &r);
    Q_SCRIPTABLE void addRepaint(int x, int y, int w, int h);
 
    CompositingType compositingType() const;
    bool isOpenGLCompositing() const;
    QPainter *scenePainter();
    void reconfigure();
 
    QByteArray readRootProperty(long atom, long type, int format) const;
    xcb_atom_t announceSupportProperty(const QByteArray &propertyName, Effect *effect);
    void removeSupportProperty(const QByteArray &propertyName, Effect *effect);
 
    bool hasDecorationShadows() const;
 
    bool decorationsHaveAlpha() const;
 
    void reloadEffect(Effect *effect);
    Effect *provides(Effect::Feature ef);
    Effect *findEffect(const QString &name) const;
    QStringList loadedEffects() const;
    QStringList listOfEffects() const;
    void unloadAllEffects();
    QStringList activeEffects() const;
    bool isEffectActive(const QString &pluginId) const;
 
    bool isScreenLocked() const;
 
    bool makeOpenGLContextCurrent();
    void doneOpenGLContextCurrent();
 
    xcb_connection_t *xcbConnection() const;
    xcb_window_t x11RootWindow() const;
 
    Display *waylandDisplay() const;
 
    bool animationsSupported() const;
 
    PlatformCursorImage cursorImage() const;
 
    void hideCursor();
 
    void showCursor();
 
    bool isCursorHidden() const;
 
    void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow *)> callback);
 
    void startInteractivePositionSelection(std::function<void(const QPointF &)> callback);
 
    void showOnScreenMessage(const QString &message, const QString &iconName = QString());
 
    enum class OnScreenMessageHideFlag {
        SkipsCloseAnimation = 1
    };
    Q_DECLARE_FLAGS(OnScreenMessageHideFlags, OnScreenMessageHideFlag)
    void hideOnScreenMessage(OnScreenMessageHideFlags flags = OnScreenMessageHideFlags());
 
    /*
     * @returns The configuration used by the EffectsHandler.
     * @since 5.10
     */
    KSharedConfigPtr config() const;
 
    KSharedConfigPtr inputConfig() const;
 
    bool hasActiveFullScreenEffect() const;
 
    void renderOffscreenQuickView(const RenderTarget &renderTarget, const RenderViewport &viewport, OffscreenQuickView *effectQuickView) const;
 
    SessionState sessionState() const;
 
    QList<Output *> screens() const;
    Output *screenAt(const QPoint &point) const;
    Output *findScreen(const QString &name) const;
    Output *findScreen(int screenId) const;
 
    KWin::EffectWindow *inputPanel() const;
    bool isInputPanelOverlay() const;
 
    QQmlEngine *qmlEngine() const;
 
    bool blocksDirectScanout() const;
 
    WorkspaceScene *scene() const
    {
        return m_scene;
    }
 
    bool touchDown(qint32 id, const QPointF &pos, std::chrono::microseconds time);
    bool touchMotion(qint32 id, const QPointF &pos, std::chrono::microseconds time);
    bool touchUp(qint32 id, std::chrono::microseconds time);
 
    bool tabletToolEvent(KWin::TabletEvent *event);
    bool tabletToolButtonEvent(uint button, bool pressed, const KWin::TabletToolId &tabletToolId, std::chrono::microseconds time);
    bool tabletPadButtonEvent(uint button, bool pressed, const KWin::TabletPadId &tabletPadId, std::chrono::microseconds time);
    bool tabletPadStripEvent(int number, int position, bool isFinger, const KWin::TabletPadId &tabletPadId, std::chrono::microseconds time);
    bool tabletPadRingEvent(int number, int position, bool isFinger, const KWin::TabletPadId &tabletPadId, std::chrono::microseconds time);
 
    void highlightWindows(const QList<EffectWindow *> &windows);
 
    bool isPropertyTypeRegistered(xcb_atom_t atom) const
    {
        return registered_atoms.contains(atom);
    }
 
Q_SIGNALS:
    void screenAdded(KWin::Output *screen);
    void screenRemoved(KWin::Output *screen);
    void desktopChanged(KWin::VirtualDesktop *oldDesktop, KWin::VirtualDesktop *newDesktop, KWin::EffectWindow *with);
 
    void desktopChanging(KWin::VirtualDesktop *currentDesktop, QPointF offset, KWin::EffectWindow *with);
    void desktopChangingCancelled();
    void desktopAdded(KWin::VirtualDesktop *desktop);
    void desktopRemoved(KWin::VirtualDesktop *desktop);
 
    void desktopGridSizeChanged(const QSize &size);
    void desktopGridWidthChanged(int width);
    void desktopGridHeightChanged(int height);
    void showingDesktopChanged(bool);
    void windowAdded(KWin::EffectWindow *w);
    void windowClosed(KWin::EffectWindow *w);
    void windowActivated(KWin::EffectWindow *w);
    void windowDeleted(KWin::EffectWindow *w);
    void tabBoxAdded(int mode);
    void tabBoxClosed();
    void tabBoxUpdated();
    void tabBoxKeyEvent(QKeyEvent *event);
    void mouseChanged(const QPointF &pos, const QPointF &oldpos,
                      Qt::MouseButtons buttons, Qt::MouseButtons oldbuttons,
                      Qt::KeyboardModifiers modifiers, Qt::KeyboardModifiers oldmodifiers);
    void cursorShapeChanged();
    void propertyNotify(KWin::EffectWindow *w, long atom);
 
    void currentActivityChanged(const QString &id);
    void activityAdded(const QString &id);
    void activityRemoved(const QString &id);
    void screenLockingChanged(bool locked);
 
    void screenAboutToLock();
 
    void stackingOrderChanged();
    void screenEdgeApproaching(ElectricBorder border, qreal factor, const QRect &geometry);
    void virtualScreenSizeChanged();
    void virtualScreenGeometryChanged();
 
    void windowDataChanged(KWin::EffectWindow *w, int role);
 
    void xcbConnectionChanged();
 
    void activeFullScreenEffectChanged();
 
    void hasActiveFullScreenEffectChanged();
 
    void sessionStateChanged();
 
    void startupAdded(const QString &id, const QIcon &icon);
    void startupChanged(const QString &id, const QIcon &icon);
    void startupRemoved(const QString &id);
 
    void inputPanelChanged();
 
public Q_SLOTS:
    // slots for D-Bus interface
    Q_SCRIPTABLE void reconfigureEffect(const QString &name);
    Q_SCRIPTABLE bool loadEffect(const QString &name);
    Q_SCRIPTABLE void toggleEffect(const QString &name);
    Q_SCRIPTABLE void unloadEffect(const QString &name);
    Q_SCRIPTABLE bool isEffectLoaded(const QString &name) const;
    Q_SCRIPTABLE bool isEffectSupported(const QString &name);
    Q_SCRIPTABLE QList<bool> areEffectsSupported(const QStringList &names);
    Q_SCRIPTABLE QString supportInformation(const QString &name) const;
    Q_SCRIPTABLE QString debug(const QString &name, const QString &parameter = QString()) const;
 
protected:
    void connectNotify(const QMetaMethod &signal) override;
    void disconnectNotify(const QMetaMethod &signal) override;
    void effectsChanged();
    void setupWindowConnections(KWin::Window *window);
 
    virtual bool doGrabKeyboard();
    virtual void doUngrabKeyboard();
 
    virtual void doStartMouseInterception(Qt::CursorShape shape);
 
    virtual void doStopMouseInterception();
 
    virtual void doCheckInputWindowStacking();
 
    void registerPropertyType(long atom, bool reg);
    void destroyEffect(Effect *effect);
    void reconfigureEffects();
 
    typedef QList<Effect *> EffectsList;
    typedef EffectsList::const_iterator EffectsIterator;
 
    Effect *keyboard_grab_effect;
    Effect *fullscreen_effect;
    QMultiMap<int, EffectPair> effect_order;
    QHash<long, int> registered_atoms;
    QList<EffectPair> loaded_effects;
    CompositingType compositing_type;
    EffectsList m_activeEffects;
    EffectsIterator m_currentDrawWindowIterator;
    EffectsIterator m_currentPaintWindowIterator;
    EffectsIterator m_currentPaintScreenIterator;
    typedef QHash<QByteArray, QList<Effect *>> PropertyEffectMap;
    PropertyEffectMap m_propertiesForEffects;
    QHash<QByteArray, qulonglong> m_managedProperties;
    Compositor *m_compositor;
    WorkspaceScene *m_scene;
    QList<Effect *> m_grabbedMouseEffects;
    EffectLoader *m_effectLoader;
    int m_trackingCursorChanges;
    std::unique_ptr<WindowPropertyNotifyX11Filter> m_x11WindowPropertyNotify;
};
 
extern KWIN_EXPORT EffectsHandler *effects;
 
} // namespace