motionmanager.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-License-Identifier: GPL-2.0-or-later
*/
 
#pragma once
 
#include "effect/effecthandler.h"
 
namespace KWin
{
 
template<typename T>
class KWIN_EXPORT Motion
{
public:
    explicit Motion(T initial, double strength, double smoothness);
    Motion(const Motion<T> &other);
    ~Motion();
 
    inline T value() const
    {
        return m_value;
    }
    inline void setValue(const T value)
    {
        m_value = value;
    }
    inline T target() const
    {
        return m_target;
    }
    inline void setTarget(const T target)
    {
        m_start = m_value;
        m_target = target;
    }
    inline T velocity() const
    {
        return m_velocity;
    }
    inline void setVelocity(const T velocity)
    {
        m_velocity = velocity;
    }
 
    inline double strength() const
    {
        return m_strength;
    }
    inline void setStrength(const double strength)
    {
        m_strength = strength;
    }
    inline double smoothness() const
    {
        return m_smoothness;
    }
    inline void setSmoothness(const double smoothness)
    {
        m_smoothness = smoothness;
    }
    inline T startValue()
    {
        return m_start;
    }
 
    inline T distance() const
    {
        return m_target - m_value;
    }
 
    void calculate(const int msec);
    void finish();
 
private:
    T m_value;
    T m_start;
    T m_target;
    T m_velocity;
    double m_strength;
    double m_smoothness;
};
 
class KWIN_EXPORT Motion1D : public Motion<double>
{
public:
    explicit Motion1D(double initial = 0.0, double strength = 0.08, double smoothness = 4.0);
    Motion1D(const Motion1D &other);
    ~Motion1D();
};
 
class KWIN_EXPORT Motion2D : public Motion<QPointF>
{
public:
    explicit Motion2D(QPointF initial = QPointF(), double strength = 0.08, double smoothness = 4.0);
    Motion2D(const Motion2D &other);
    ~Motion2D();
};
 
class KWIN_EXPORT WindowMotionManager
{
public:
    explicit WindowMotionManager(bool useGlobalAnimationModifier = true);
    ~WindowMotionManager();
 
    void manage(EffectWindow *w);
    inline void manage(const QList<EffectWindow *> &list)
    {
        for (int i = 0; i < list.size(); i++) {
            manage(list.at(i));
        }
    }
    void unmanage(EffectWindow *w);
    void unmanageAll();
    void calculate(int time);
    void apply(EffectWindow *w, WindowPaintData &data);
    void reset();
    void reset(EffectWindow *w);
 
    void moveWindow(EffectWindow *w, QPoint target, double scale = 1.0, double yScale = 0.0);
    inline void moveWindow(EffectWindow *w, QRect target)
    {
        // TODO: Scale might be slightly different in the comparison due to rounding
        moveWindow(w, target.topLeft(),
                   target.width() / double(w->width()), target.height() / double(w->height()));
    }
 
    QRectF transformedGeometry(EffectWindow *w) const;
    void setTransformedGeometry(EffectWindow *w, const QRectF &geometry);
    QRectF targetGeometry(EffectWindow *w) const;
    EffectWindow *windowAtPoint(QPoint point, bool useStackingOrder = true) const;
 
    inline QList<EffectWindow *> managedWindows() const
    {
        return m_managedWindows.keys();
    }
    inline bool isManaging(EffectWindow *w) const
    {
        return m_managedWindows.contains(w);
    }
    inline bool managingWindows() const
    {
        return !m_managedWindows.empty();
    }
    inline bool areWindowsMoving() const
    {
        return !m_movingWindowsSet.isEmpty();
    }
    inline bool isWindowMoving(EffectWindow *w) const
    {
        return m_movingWindowsSet.contains(w);
    }
 
private:
    bool m_useGlobalAnimationModifier;
    struct WindowMotion
    {
        // TODO: Rotation, etc?
        Motion2D translation; // Absolute position
        Motion2D scale; // xScale and yScale
    };
    QHash<EffectWindow *, WindowMotion> m_managedWindows;
    QSet<EffectWindow *> m_movingWindowsSet;
};
 
template<typename T>
Motion<T>::Motion(T initial, double strength, double smoothness)
    : m_value(initial)
    , m_start(initial)
    , m_target(initial)
    , m_velocity()
    , m_strength(strength)
    , m_smoothness(smoothness)
{
}
 
template<typename T>
Motion<T>::Motion(const Motion &other)
    : m_value(other.value())
    , m_start(other.target())
    , m_target(other.target())
    , m_velocity(other.velocity())
    , m_strength(other.strength())
    , m_smoothness(other.smoothness())
{
}
 
template<typename T>
Motion<T>::~Motion()
{
}
 
template<typename T>
void Motion<T>::calculate(const int msec)
{
    if (m_value == m_target && m_velocity == T()) { // At target and not moving
        return;
    }
 
    // Poor man's time independent calculation
    int steps = std::max(1, msec / 5);
    for (int i = 0; i < steps; i++) {
        T diff = m_target - m_value;
        T strength = diff * m_strength;
        m_velocity = (m_smoothness * m_velocity + strength) / (m_smoothness + 1.0);
        m_value += m_velocity;
    }
}
 
template<typename T>
void Motion<T>::finish()
{
    m_value = m_target;
    m_velocity = T();
}
 
} // namespace KWin