scriptedeffect.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-FileCopyrightText: 2018 David Edmundson <davidedmundson@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
 
#pragma once
 
#include "effect/animationeffect.h"
 
#include <QJSEngine>
#include <QJSValue>
 
class KConfigLoader;
class KPluginMetaData;
 
class QAction;
 
namespace KWin
{
 
class KWIN_EXPORT ScriptedEffect : public KWin::AnimationEffect
{
    Q_OBJECT
 
    Q_ENUMS(DataRole)
    Q_ENUMS(Qt::Axis)
    Q_ENUMS(Anchor)
    Q_ENUMS(MetaType)
    Q_ENUMS(EasingCurve)
    Q_ENUMS(SessionState)
    Q_ENUMS(ElectricBorder)
    Q_ENUMS(ShaderTrait)
    Q_PROPERTY(QString pluginId READ pluginId CONSTANT)
    Q_PROPERTY(bool isActiveFullScreenEffect READ isActiveFullScreenEffect NOTIFY isActiveFullScreenEffectChanged)
 
public:
    // copied from kwineffects.h
    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, 
        WindowBlurBehindRole, 
        WindowForceBackgroundContrastRole, 
        WindowBackgroundContrastRole, 
    };
    enum EasingCurve {
        GaussianCurve = 128
    };
    // copied from kwinglutils.h
    enum class ShaderTrait {
        MapTexture = (1 << 0),
        UniformColor = (1 << 1),
        Modulate = (1 << 2),
        AdjustSaturation = (1 << 3),
    };
 
    const QString &scriptFile() const
    {
        return m_scriptFile;
    }
    void reconfigure(ReconfigureFlags flags) override;
    int requestedEffectChainPosition() const override
    {
        return m_chainPosition;
    }
    QString activeConfig() const;
    void setActiveConfig(const QString &name);
    static ScriptedEffect *create(const QString &effectName, const QString &pathToScript, int chainPosition, const QString &exclusiveCategory);
    static ScriptedEffect *create(const KPluginMetaData &effect);
    static bool supported();
    ~ScriptedEffect() override;
    Q_SCRIPTABLE bool isGrabbed(KWin::EffectWindow *w, DataRole grabRole);
 
    Q_SCRIPTABLE bool grab(KWin::EffectWindow *w, DataRole grabRole, bool force = false);
 
    Q_SCRIPTABLE bool ungrab(KWin::EffectWindow *w, DataRole grabRole);
 
    Q_SCRIPTABLE QJSValue readConfig(const QString &key, const QJSValue &defaultValue = QJSValue());
 
    Q_SCRIPTABLE int displayWidth() const;
    Q_SCRIPTABLE int displayHeight() const;
    Q_SCRIPTABLE int animationTime(int defaultTime) const;
 
    Q_SCRIPTABLE void registerShortcut(const QString &objectName, const QString &text,
                                       const QString &keySequence, const QJSValue &callback);
    Q_SCRIPTABLE bool registerScreenEdge(int edge, const QJSValue &callback);
    Q_SCRIPTABLE bool registerRealtimeScreenEdge(int edge, const QJSValue &callback);
    Q_SCRIPTABLE bool unregisterScreenEdge(int edge);
    Q_SCRIPTABLE bool registerTouchScreenEdge(int edge, const QJSValue &callback);
    Q_SCRIPTABLE bool unregisterTouchScreenEdge(int edge);
 
    Q_SCRIPTABLE quint64 animate(KWin::EffectWindow *window, Attribute attribute, int ms,
                                 const QJSValue &to, const QJSValue &from = QJSValue(),
                                 uint metaData = 0, int curve = QEasingCurve::Linear, int delay = 0,
                                 bool fullScreen = false, bool keepAlive = true, uint shaderId = 0);
    Q_SCRIPTABLE QJSValue animate(const QJSValue &object);
 
    Q_SCRIPTABLE quint64 set(KWin::EffectWindow *window, Attribute attribute, int ms,
                             const QJSValue &to, const QJSValue &from = QJSValue(),
                             uint metaData = 0, int curve = QEasingCurve::Linear, int delay = 0,
                             bool fullScreen = false, bool keepAlive = true, uint shaderId = 0);
    Q_SCRIPTABLE QJSValue set(const QJSValue &object);
 
    Q_SCRIPTABLE bool retarget(quint64 animationId, const QJSValue &newTarget,
                               int newRemainingTime = -1);
    Q_SCRIPTABLE bool retarget(const QList<quint64> &animationIds, const QJSValue &newTarget,
                               int newRemainingTime = -1);
    Q_SCRIPTABLE bool freezeInTime(quint64 animationId, qint64 frozenTime);
    Q_SCRIPTABLE bool freezeInTime(const QList<quint64> &animationIds, qint64 frozenTime);
 
    Q_SCRIPTABLE bool redirect(quint64 animationId, Direction direction,
                               TerminationFlags terminationFlags = TerminateAtSource);
    Q_SCRIPTABLE bool redirect(const QList<quint64> &animationIds, Direction direction,
                               TerminationFlags terminationFlags = TerminateAtSource);
 
    Q_SCRIPTABLE bool complete(quint64 animationId);
    Q_SCRIPTABLE bool complete(const QList<quint64> &animationIds);
 
    Q_SCRIPTABLE bool cancel(quint64 animationId);
    Q_SCRIPTABLE bool cancel(const QList<quint64> &animationIds);
 
    Q_SCRIPTABLE QList<int> touchEdgesForAction(const QString &action) const;
 
    Q_SCRIPTABLE uint addFragmentShader(ShaderTrait traits, const QString &fragmentShaderFile = {});
 
    Q_SCRIPTABLE void setUniform(uint shaderId, const QString &name, const QJSValue &value);
 
    QHash<int, QJSValueList> &screenEdgeCallbacks()
    {
        return m_screenEdgeCallbacks;
    }
 
    QHash<int, QJSValueList> &realtimeScreenEdgeCallbacks()
    {
        return m_realtimeScreenEdgeCallbacks;
    }
 
    QString pluginId() const;
    bool isActiveFullScreenEffect() const;
 
public Q_SLOTS:
    bool borderActivated(ElectricBorder border) override;
 
Q_SIGNALS:
    void configChanged();
    void animationEnded(KWin::EffectWindow *w, quint64 animationId);
    void isActiveFullScreenEffectChanged();
 
protected:
    ScriptedEffect();
    QJSEngine *engine() const;
    bool init(const QString &effectName, const QString &pathToScript);
    void animationEnded(KWin::EffectWindow *w, Attribute a, uint meta) override;
 
private:
    enum class AnimationType {
        Animate,
        Set
    };
 
    QJSValue animate_helper(const QJSValue &object, AnimationType animationType);
 
    GLShader *findShader(uint shaderId) const;
 
    QJSEngine *m_engine;
    QString m_effectName;
    QString m_scriptFile;
    QString m_exclusiveCategory;
    QHash<int, QJSValueList> m_screenEdgeCallbacks;
    QHash<int, QJSValueList> m_realtimeScreenEdgeCallbacks;
    KConfigLoader *m_config;
    int m_chainPosition;
    QHash<int, QAction *> m_touchScreenEdgeCallbacks;
    Effect *m_activeFullScreenEffect = nullptr;
    std::map<uint, std::unique_ptr<GLShader>> m_shaders;
    uint m_nextShaderId{1u};
};
}