animationeffect.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2011 Thomas Lübking <thomas.luebking@web.de>
    SPDX-FileCopyrightText: 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
 
#pragma once
 
#include "kwin_export.h"
 
#include "effect/offscreeneffect.h"
#include <QEasingCurve>
#include <QElapsedTimer>
#include <QtMath>
 
namespace KWin
{
 
class KWIN_EXPORT FPx2
{
public:
    FPx2()
    {
        f[0] = f[1] = 0.0;
        valid = false;
    }
    explicit FPx2(float v)
    {
        f[0] = f[1] = v;
        valid = true;
    }
    FPx2(float v1, float v2)
    {
        f[0] = v1;
        f[1] = v2;
        valid = true;
    }
    FPx2(const FPx2 &other)
    {
        f[0] = other.f[0];
        f[1] = other.f[1];
        valid = other.valid;
    }
    explicit FPx2(const QPoint &other)
    {
        f[0] = other.x();
        f[1] = other.y();
        valid = true;
    }
    explicit FPx2(const QPointF &other)
    {
        f[0] = other.x();
        f[1] = other.y();
        valid = true;
    }
    explicit FPx2(const QSize &other)
    {
        f[0] = other.width();
        f[1] = other.height();
        valid = true;
    }
    explicit FPx2(const QSizeF &other)
    {
        f[0] = other.width();
        f[1] = other.height();
        valid = true;
    }
    inline void invalidate()
    {
        valid = false;
    }
    inline bool isValid() const
    {
        return valid;
    }
    inline float operator[](int n) const
    {
        return f[n];
    }
    inline QString toString() const
    {
        QString ret;
        if (valid) {
            ret = QString::number(f[0]) + QLatin1Char(',') + QString::number(f[1]);
        } else {
            ret = QString();
        }
        return ret;
    }
 
    inline FPx2 &operator=(const FPx2 &other)
    {
        f[0] = other.f[0];
        f[1] = other.f[1];
        valid = other.valid;
        return *this;
    }
    inline FPx2 &operator+=(const FPx2 &other)
    {
        f[0] += other[0];
        f[1] += other[1];
        return *this;
    }
    inline FPx2 &operator-=(const FPx2 &other)
    {
        f[0] -= other[0];
        f[1] -= other[1];
        return *this;
    }
    inline FPx2 &operator*=(float fl)
    {
        f[0] *= fl;
        f[1] *= fl;
        return *this;
    }
    inline FPx2 &operator/=(float fl)
    {
        f[0] /= fl;
        f[1] /= fl;
        return *this;
    }
 
    friend inline bool operator==(const FPx2 &f1, const FPx2 &f2)
    {
        return f1[0] == f2[0] && f1[1] == f2[1];
    }
    friend inline bool operator!=(const FPx2 &f1, const FPx2 &f2)
    {
        return f1[0] != f2[0] || f1[1] != f2[1];
    }
    friend inline const FPx2 operator+(const FPx2 &f1, const FPx2 &f2)
    {
        return FPx2(f1[0] + f2[0], f1[1] + f2[1]);
    }
    friend inline const FPx2 operator-(const FPx2 &f1, const FPx2 &f2)
    {
        return FPx2(f1[0] - f2[0], f1[1] - f2[1]);
    }
    friend inline const FPx2 operator*(const FPx2 &f, float fl)
    {
        return FPx2(f[0] * fl, f[1] * fl);
    }
    friend inline const FPx2 operator*(float fl, const FPx2 &f)
    {
        return FPx2(f[0] * fl, f[1] * fl);
    }
    friend inline const FPx2 operator-(const FPx2 &f)
    {
        return FPx2(-f[0], -f[1]);
    }
    friend inline const FPx2 operator/(const FPx2 &f, float fl)
    {
        return FPx2(f[0] / fl, f[1] / fl);
    }
 
    inline void set(float v)
    {
        f[0] = v;
        valid = true;
    }
    inline void set(float v1, float v2)
    {
        f[0] = v1;
        f[1] = v2;
        valid = true;
    }
 
private:
    float f[2];
    bool valid;
};
 
class AniData;
class AnimationEffectPrivate;
 
class KWIN_EXPORT AnimationEffect : public CrossFadeEffect
{
    Q_OBJECT
 
public:
    enum Anchor { Left = 1 << 0,
                  Top = 1 << 1,
                  Right = 1 << 2,
                  Bottom = 1 << 3,
                  Horizontal = Left | Right,
                  Vertical = Top | Bottom,
                  Mouse = 1 << 4 };
    Q_ENUM(Anchor)
 
    enum Attribute {
        Opacity = 0,
        Brightness,
        Saturation,
        Scale,
        Rotation,
        Position,
        Size,
        Translation,
        Clip,
        Generic,
        CrossFadePrevious,
        Shader,
        ShaderUniform,
        NonFloatBase = Position
    };
    Q_ENUM(Attribute)
 
    enum MetaType { SourceAnchor,
                    TargetAnchor,
                    RelativeSourceX,
                    RelativeSourceY,
                    RelativeTargetX,
                    RelativeTargetY,
                    Axis };
    Q_ENUM(MetaType)
 
    
    enum Direction {
        Forward, 
        Backward 
    };
    Q_ENUM(Direction)
 
    
    enum TerminationFlag {
        DontTerminate = 0x00,
        TerminateAtSource = 0x01,
        TerminateAtTarget = 0x02
    };
    Q_DECLARE_FLAGS(TerminationFlags, TerminationFlag)
    Q_FLAG(TerminationFlags)
 
    
    AnimationEffect();
    ~AnimationEffect() override;
 
    bool isActive() const override;
 
    static int metaData(MetaType type, uint meta);
 
    static void setMetaData(MetaType type, uint value, uint &meta);
 
    // Reimplemented from KWin::Effect.
    QString debug(const QString &parameter) const override;
    void prePaintWindow(EffectWindow *w, WindowPrePaintData &data, std::chrono::milliseconds presentTime) override;
    void paintWindow(const RenderTarget &renderTarget, const RenderViewport &viewport, EffectWindow *w, int mask, QRegion region, WindowPaintData &data) override;
    void postPaintScreen() override;
 
    static qreal qecGaussian(qreal progress)
    {
        progress = 2 * progress - 1;
        progress *= -5 * progress;
        return qExp(progress);
    }
 
    static inline qint64 clock()
    {
        return s_clock.elapsed();
    }
 
protected:
    quint64 animate(EffectWindow *w, Attribute a, uint meta, int ms, const FPx2 &to, const QEasingCurve &curve = QEasingCurve(), int delay = 0, const FPx2 &from = FPx2(), bool fullScreen = false, bool keepAlive = true, GLShader *shader = nullptr)
    {
        return p_animate(w, a, meta, ms, to, curve, delay, from, false, fullScreen, keepAlive, shader);
    }
 
    quint64 set(EffectWindow *w, Attribute a, uint meta, int ms, const FPx2 &to, const QEasingCurve &curve = QEasingCurve(), int delay = 0, const FPx2 &from = FPx2(), bool fullScreen = false, bool keepAlive = true, GLShader *shader = nullptr)
    {
        return p_animate(w, a, meta, ms, to, curve, delay, from, true, fullScreen, keepAlive, shader);
    }
 
    bool retarget(quint64 animationId, FPx2 newTarget, int newRemainingTime = -1);
 
    bool freezeInTime(quint64 animationId, qint64 frozenTime);
 
    bool redirect(quint64 animationId,
                  Direction direction,
                  TerminationFlags terminationFlags = TerminateAtSource);
 
    bool complete(quint64 animationId);
 
    virtual void animationEnded(EffectWindow *w, Attribute a, uint meta);
 
    bool cancel(quint64 animationId);
 
    virtual void genericAnimation(EffectWindow *w, WindowPaintData &data, float progress, uint meta);
 
    typedef QMap<EffectWindow *, QPair<QList<AniData>, QRect>> AniMap;
 
    AniMap state() const;
 
private:
    quint64 p_animate(EffectWindow *w, Attribute a, uint meta, int ms, FPx2 to, const QEasingCurve &curve, int delay, FPx2 from, bool keepAtTarget, bool fullScreenEffect, bool keepAlive, GLShader *shader);
    QRect clipRect(const QRect &windowRect, const AniData &) const;
    float interpolated(const AniData &, int i = 0) const;
    float progress(const AniData &) const;
    void updateLayerRepaints();
    void validate(Attribute a, uint &meta, FPx2 *from, FPx2 *to, const EffectWindow *w) const;
 
private Q_SLOTS:
    void init();
    void triggerRepaint();
    void _windowClosed(KWin::EffectWindow *w);
    void _windowDeleted(KWin::EffectWindow *w);
    void _windowExpandedGeometryChanged(KWin::EffectWindow *w);
 
private:
    static QElapsedTimer s_clock;
    const std::unique_ptr<AnimationEffectPrivate> d_ptr;
    Q_DECLARE_PRIVATE(AnimationEffect)
    Q_DISABLE_COPY(AnimationEffect)
};
 
} // namespace
 
Q_DECLARE_METATYPE(KWin::FPx2)
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::AnimationEffect::TerminationFlags)