effect.h

Go to the documentation of this file.

/*
    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/globals.h"
 
#include <QRegion>
 
#include <KPluginFactory>
#include <KSharedConfig>
 
class QKeyEvent;
class QTabletEvent;
 
namespace KWin
{
 
class EffectWindow;
class Output;
class PaintDataPrivate;
class RenderTarget;
class RenderViewport;
class WindowPaintDataPrivate;
 
#define KWIN_EFFECT_API_MAKE_VERSION(major, minor) ((major) << 8 | (minor))
#define KWIN_EFFECT_API_VERSION_MAJOR 0
#define KWIN_EFFECT_API_VERSION_MINOR 236
#define KWIN_EFFECT_API_VERSION KWIN_EFFECT_API_MAKE_VERSION( \
    KWIN_EFFECT_API_VERSION_MAJOR, KWIN_EFFECT_API_VERSION_MINOR)
 
class KWIN_EXPORT PaintData
{
public:
    virtual ~PaintData();
    qreal xScale() const;
    qreal yScale() const;
    qreal zScale() const;
    void setXScale(qreal scale);
    void setYScale(qreal scale);
    void setZScale(qreal scale);
    void setScale(const QVector2D &scale);
    void setScale(const QVector3D &scale);
    const QVector3D &scale() const;
    const QVector3D &translation() const;
    qreal xTranslation() const;
    qreal yTranslation() const;
    qreal zTranslation() const;
    void setXTranslation(qreal translate);
    void setYTranslation(qreal translate);
    void setZTranslation(qreal translate);
    void translate(qreal x, qreal y = 0.0, qreal z = 0.0);
    void translate(const QVector3D &translate);
 
    void setRotationAngle(qreal angle);
    qreal rotationAngle() const;
    void setRotationOrigin(const QVector3D &origin);
    QVector3D rotationOrigin() const;
    void setRotationAxis(const QVector3D &axis);
    void setRotationAxis(Qt::Axis axis);
    QVector3D rotationAxis() const;
 
    QMatrix4x4 toMatrix(qreal deviceScale) const;
 
protected:
    PaintData();
    PaintData(const PaintData &other);
 
private:
    const std::unique_ptr<PaintDataPrivate> d;
};
 
class KWIN_EXPORT WindowPrePaintData
{
public:
    int mask;
    QRegion paint;
    QRegion opaque;
    void setTranslucent();
    void setTransformed();
};
 
class KWIN_EXPORT WindowPaintData : public PaintData
{
public:
    WindowPaintData();
    explicit WindowPaintData(const QMatrix4x4 &projectionMatrix);
    WindowPaintData(const WindowPaintData &other);
    ~WindowPaintData() override;
    WindowPaintData &operator*=(qreal scale);
    WindowPaintData &operator*=(const QVector2D &scale);
    WindowPaintData &operator*=(const QVector3D &scale);
    WindowPaintData &operator+=(const QPointF &translation);
    WindowPaintData &operator+=(const QPoint &translation);
    WindowPaintData &operator+=(const QVector2D &translation);
    WindowPaintData &operator+=(const QVector3D &translation);
    qreal opacity() const;
    void setOpacity(qreal opacity);
    qreal multiplyOpacity(qreal factor);
    qreal saturation() const;
    void setSaturation(qreal saturation) const;
    qreal multiplySaturation(qreal factor);
    qreal brightness() const;
    void setBrightness(qreal brightness);
    qreal multiplyBrightness(qreal factor);
    int screen() const;
    void setScreen(int screen) const;
    void setCrossFadeProgress(qreal factor);
    qreal crossFadeProgress() const;
 
    void setProjectionMatrix(const QMatrix4x4 &matrix);
 
    QMatrix4x4 projectionMatrix() const;
 
    QMatrix4x4 &rprojectionMatrix();
 
private:
    const std::unique_ptr<WindowPaintDataPrivate> d;
};
 
class KWIN_EXPORT ScreenPrePaintData
{
public:
    int mask;
    QRegion paint;
    Output *screen = nullptr;
};
 
class KWIN_EXPORT Effect : public QObject
{
    Q_OBJECT
public:
    // TODO: is that ok here?
    enum {
        PAINT_WINDOW_OPAQUE = 1 << 0,
        PAINT_WINDOW_TRANSLUCENT = 1 << 1,
        PAINT_WINDOW_TRANSFORMED = 1 << 2,
        PAINT_SCREEN_REGION = 1 << 3,
        PAINT_SCREEN_TRANSFORMED = 1 << 4,
        PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS = 1 << 5,
        PAINT_SCREEN_BACKGROUND_FIRST = 1 << 6,
    };
 
    enum Feature {
        Nothing = 0,
        ScreenInversion,
        Blur,
        Contrast,
        HighlightWindows
    };
 
    Effect(QObject *parent = nullptr);
    ~Effect() override;
 
    enum ReconfigureFlag {
        ReconfigureAll = 1 << 0 
    };
    Q_DECLARE_FLAGS(ReconfigureFlags, ReconfigureFlag)
 
    
    virtual void reconfigure(ReconfigureFlags flags);
 
    virtual void prePaintScreen(ScreenPrePaintData &data,
                                std::chrono::milliseconds presentTime);
    virtual void paintScreen(const RenderTarget &renderTarget, const RenderViewport &viewport, int mask, const QRegion &region, Output *screen);
    virtual void postPaintScreen();
 
    virtual void prePaintWindow(EffectWindow *w, WindowPrePaintData &data,
                                std::chrono::milliseconds presentTime);
    virtual void paintWindow(const RenderTarget &renderTarget, const RenderViewport &viewport, EffectWindow *w, int mask, QRegion region, WindowPaintData &data);
    virtual void postPaintWindow(EffectWindow *w);
 
    virtual bool provides(Feature);
 
    virtual bool perform(Feature feature, const QVariantList &arguments);
 
    virtual void drawWindow(const RenderTarget &renderTarget, const RenderViewport &viewport, EffectWindow *w, int mask, const QRegion &region, WindowPaintData &data);
 
    virtual void windowInputMouseEvent(QEvent *e);
    virtual void grabbedKeyboardEvent(QKeyEvent *e);
 
    virtual bool isActive() const;
 
    virtual QString debug(const QString &parameter) const;
 
    virtual int requestedEffectChainPosition() const;
 
    virtual bool touchDown(qint32 id, const QPointF &pos, std::chrono::microseconds time);
    virtual bool touchMotion(qint32 id, const QPointF &pos, std::chrono::microseconds time);
    virtual bool touchUp(qint32 id, std::chrono::microseconds time);
 
    virtual bool tabletToolEvent(QTabletEvent *event);
 
    virtual bool tabletToolButtonEvent(uint button, bool pressed, quint64 tabletToolId);
 
    virtual bool tabletPadButtonEvent(uint button, bool pressed, void *tabletPadId);
 
    virtual bool tabletPadStripEvent(int number, int position, bool isFinger, void *tabletPadId);
 
    virtual bool tabletPadRingEvent(int number, int position, bool isFinger, void *tabletPadId);
 
    static QPointF cursorPos();
 
    // return type is intentionally double so that one can divide using it without losing data
    static double animationTime(const KConfigGroup &cfg, const QString &key, int defaultTime);
    static double animationTime(int defaultTime);
    template<typename T>
    int animationTime(int defaultDuration);
    static double interpolate(double x, double y, double a)
    {
        return x * (1 - a) + y * a;
    }
    static void setPositionTransformations(WindowPaintData &data, QRect &region, EffectWindow *w,
                                           const QRect &r, Qt::AspectRatioMode aspect);
 
    virtual bool blocksDirectScanout() const;
 
public Q_SLOTS:
    virtual bool borderActivated(ElectricBorder border);
};
 
template<typename T>
int Effect::animationTime(int defaultDuration)
{
    return animationTime(T::duration() != 0 ? T::duration() : defaultDuration);
}
 
class KWIN_EXPORT EffectPluginFactory : public KPluginFactory
{
    Q_OBJECT
public:
    EffectPluginFactory();
    ~EffectPluginFactory() override;
    virtual bool isSupported() const;
    virtual bool enabledByDefault() const;
    virtual KWin::Effect *createEffect() const = 0;
};
 
#define EffectPluginFactory_iid "org.kde.kwin.EffectPluginFactory" KWIN_PLUGIN_VERSION_STRING
#define KWIN_PLUGIN_FACTORY_NAME KPLUGINFACTORY_PLUGIN_CLASS_INTERNAL_NAME
 
#define KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED(className, jsonFile, supported, enabled) \
    class KWIN_PLUGIN_FACTORY_NAME : public KWin::EffectPluginFactory                  \
    {                                                                                  \
        Q_OBJECT                                                                       \
        Q_PLUGIN_METADATA(IID EffectPluginFactory_iid FILE jsonFile)                   \
        Q_INTERFACES(KPluginFactory)                                                   \
    public:                                                                            \
        explicit KWIN_PLUGIN_FACTORY_NAME()                                            \
        {                                                                              \
        }                                                                              \
        ~KWIN_PLUGIN_FACTORY_NAME()                                                    \
        {                                                                              \
        }                                                                              \
        bool isSupported() const override                                              \
        {                                                                              \
            supported                                                                  \
        }                                                                              \
        bool enabledByDefault() const override{                                        \
            enabled} KWin::Effect *createEffect() const override                       \
        {                                                                              \
            return new className();                                                    \
        }                                                                              \
    };
 
#define KWIN_EFFECT_FACTORY_ENABLED(className, jsonFile, enabled) \
    KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED(className, jsonFile, return true;, enabled)
 
#define KWIN_EFFECT_FACTORY_SUPPORTED(className, jsonFile, supported) \
    KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED(className, jsonFile, supported, return true;)
 
#define KWIN_EFFECT_FACTORY(className, jsonFile) \
    KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED(className, jsonFile, return true;, return true;)
 
} // namespace KWin