include/ui/Ripple.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

#ifndef UI_RIPPLE_H
#define UI_RIPPLE_H

#include <QBrush>
#include <QEasingCurve>
#include <QParallelAnimationGroup>
#include <QPoint>
#include <QPropertyAnimation>

class RippleOverlay;

class Ripple : public QParallelAnimationGroup
{
	Q_OBJECT

	Q_PROPERTY(qreal radius WRITE setRadius READ radius)
	Q_PROPERTY(qreal opacity WRITE setOpacity READ opacity)

public:
	explicit Ripple(const QPoint &center, QObject *parent = 0);
	Ripple(const QPoint &center, RippleOverlay *overlay, QObject *parent = 0);
	~Ripple();

	inline void setOverlay(RippleOverlay *overlay);

	void setRadius(qreal radius);
	void setOpacity(qreal opacity);
	void setColor(const QColor &color);
	void setBrush(const QBrush &brush);

	inline qreal radius() const;
	inline qreal opacity() const;
	inline QColor color() const;
	inline QBrush brush() const;
	inline QPoint center() const;

	inline QPropertyAnimation *radiusAnimation() const;
	inline QPropertyAnimation *opacityAnimation() const;

	inline void setOpacityStartValue(qreal value);
	inline void setOpacityEndValue(qreal value);
	inline void setRadiusStartValue(qreal value);
	inline void setRadiusEndValue(qreal value);
	inline void setDuration(int msecs);

protected slots:
	void destroy();

private:
	Q_DISABLE_COPY(Ripple)

	QPropertyAnimation *animate(const QByteArray &property,
				    const QEasingCurve &easing = QEasingCurve::OutQuad,
				    int duration = 800);

	void init();

	RippleOverlay *overlay_;

	QPropertyAnimation *const radius_anim_;
	QPropertyAnimation *const opacity_anim_;

	qreal radius_;
	qreal opacity_;

	QPoint center_;
	QBrush brush_;
};

inline void Ripple::setOverlay(RippleOverlay *overlay)
{
	overlay_ = overlay;
}

inline qreal Ripple::radius() const
{
	return radius_;
}

inline qreal Ripple::opacity() const
{
	return opacity_;
}

inline QColor Ripple::color() const
{
	return brush_.color();
}

inline QBrush Ripple::brush() const
{
	return brush_;
}

inline QPoint Ripple::center() const
{
	return center_;
}

inline QPropertyAnimation *Ripple::radiusAnimation() const
{
	return radius_anim_;
}

inline QPropertyAnimation *Ripple::opacityAnimation() const
{
	return opacity_anim_;
}

inline void Ripple::setOpacityStartValue(qreal value)
{
	opacity_anim_->setStartValue(value);
}

inline void Ripple::setOpacityEndValue(qreal value)
{
	opacity_anim_->setEndValue(value);
}

inline void Ripple::setRadiusStartValue(qreal value)
{
	radius_anim_->setStartValue(value);
}

inline void Ripple::setRadiusEndValue(qreal value)
{
	radius_anim_->setEndValue(value);
}

inline void Ripple::setDuration(int msecs)
{
	radius_anim_->setDuration(msecs);
	opacity_anim_->setDuration(msecs);
}

#endif  // UI_RIPPLE_H