2014-05-30 08:53:19 +00:00
|
|
|
/*
|
|
|
|
This file is part of Telegram Desktop,
|
2014-12-01 10:47:38 +00:00
|
|
|
the official desktop version of Telegram messaging app, see https://telegram.org
|
2014-05-30 08:53:19 +00:00
|
|
|
|
|
|
|
Telegram Desktop is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
It is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
2015-10-03 13:16:42 +00:00
|
|
|
In addition, as a special exception, the copyright holders give permission
|
|
|
|
to link the code of portions of this program with the OpenSSL library.
|
|
|
|
|
2014-05-30 08:53:19 +00:00
|
|
|
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
|
2015-10-03 13:16:42 +00:00
|
|
|
Copyright (c) 2014-2015 John Preston, https://desktop.telegram.org
|
2014-05-30 08:53:19 +00:00
|
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include "types.h"
|
|
|
|
#include <QtCore/QTimer>
|
|
|
|
#include <QtGui/QColor>
|
|
|
|
|
|
|
|
namespace anim {
|
|
|
|
|
|
|
|
typedef float64 (*transition)(const float64 &delta, const float64 &dt);
|
|
|
|
|
|
|
|
float64 linear(const float64 &delta, const float64 &dt);
|
|
|
|
float64 sineInOut(const float64 &delta, const float64 &dt);
|
|
|
|
float64 halfSine(const float64 &delta, const float64 &dt);
|
|
|
|
float64 easeOutBack(const float64 &delta, const float64 &dt);
|
|
|
|
float64 easeInCirc(const float64 &delta, const float64 &dt);
|
|
|
|
float64 easeOutCirc(const float64 &delta, const float64 &dt);
|
|
|
|
float64 easeInCubic(const float64 &delta, const float64 &dt);
|
|
|
|
float64 easeOutCubic(const float64 &delta, const float64 &dt);
|
|
|
|
float64 easeInQuint(const float64 &delta, const float64 &dt);
|
|
|
|
float64 easeOutQuint(const float64 &delta, const float64 &dt);
|
|
|
|
|
|
|
|
class fvalue { // float animated value
|
|
|
|
public:
|
|
|
|
|
|
|
|
fvalue() {
|
|
|
|
}
|
|
|
|
fvalue(const float64 &from) : _cur(from), _from(from), _delta(0) {
|
|
|
|
}
|
|
|
|
fvalue(const float64 &from, const float64 &to) : _cur(from), _from(from), _delta(to - from) {
|
|
|
|
}
|
|
|
|
void start(const float64 &to) {
|
|
|
|
_from = _cur;
|
|
|
|
_delta = to - _from;
|
|
|
|
}
|
|
|
|
void restart() {
|
|
|
|
_delta = _from + _delta - _cur;
|
|
|
|
_from = _cur;
|
|
|
|
}
|
|
|
|
const float64 ¤t() const {
|
|
|
|
return _cur;
|
|
|
|
}
|
2014-10-17 12:57:14 +00:00
|
|
|
float64 to() const {
|
|
|
|
return _from + _delta;
|
|
|
|
}
|
2014-08-11 09:03:45 +00:00
|
|
|
fvalue &update(const float64 &dt, transition func) {
|
2014-05-30 08:53:19 +00:00
|
|
|
_cur = _from + (*func)(_delta, dt);
|
2014-08-11 09:03:45 +00:00
|
|
|
return *this;
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
void finish() {
|
|
|
|
_cur = _from + _delta;
|
|
|
|
_from = _cur;
|
|
|
|
_delta = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
float64 _cur, _from, _delta;
|
|
|
|
};
|
|
|
|
|
|
|
|
class ivalue { // int animated value
|
|
|
|
public:
|
|
|
|
|
|
|
|
ivalue() {
|
|
|
|
}
|
|
|
|
ivalue(int32 from) : _cur(from), _from(float64(from)), _delta(0) {
|
|
|
|
}
|
|
|
|
ivalue(int32 from, int32 to) : _cur(from), _from(float64(from)), _delta(float64(to - from)) {
|
|
|
|
}
|
|
|
|
void start(int32 to) {
|
|
|
|
_from = float64(_cur);
|
|
|
|
_delta = float64(to) - _from;
|
|
|
|
}
|
|
|
|
void restart() {
|
|
|
|
_delta = _from + _delta - float64(_cur);
|
|
|
|
_from = float64(_cur);
|
|
|
|
}
|
|
|
|
int32 current() const {
|
|
|
|
return _cur;
|
|
|
|
}
|
2014-10-17 12:57:14 +00:00
|
|
|
int32 to() const {
|
|
|
|
return _from + _delta;
|
|
|
|
}
|
2014-08-11 09:03:45 +00:00
|
|
|
ivalue &update(const float64 &dt, transition func) {
|
2014-05-30 08:53:19 +00:00
|
|
|
_cur = qRound(_from + (*func)(_delta, dt));
|
2014-08-11 09:03:45 +00:00
|
|
|
return *this;
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
void finish() {
|
|
|
|
_cur = qRound(_from + _delta);
|
|
|
|
_from = _cur;
|
|
|
|
_delta = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
int32 _cur;
|
|
|
|
float64 _from, _delta;
|
|
|
|
};
|
|
|
|
|
|
|
|
class cvalue { // QColor animated value
|
|
|
|
public:
|
|
|
|
|
|
|
|
cvalue() {
|
|
|
|
}
|
|
|
|
cvalue(const QColor &from) : _cur(from), _from_r(from.redF()), _from_g(from.greenF()), _from_b(from.blueF()), _from_a(from.alphaF()), _delta_r(0), _delta_g(0), _delta_b(0), _delta_a(0) {
|
|
|
|
}
|
|
|
|
cvalue(const QColor &from, const QColor &to)
|
|
|
|
: _cur(from)
|
|
|
|
, _from_r(from.redF()), _from_g(from.greenF()), _from_b(from.blueF()), _from_a(from.alphaF())
|
|
|
|
, _delta_r(to.redF() - from.redF()), _delta_g(to.greenF() - from.greenF()), _delta_b(to.blueF() - from.blueF()), _delta_a(to.alphaF() - from.alphaF())
|
|
|
|
{
|
|
|
|
}
|
|
|
|
void start(const QColor &to) {
|
|
|
|
_from_r = _cur.redF();
|
|
|
|
_from_g = _cur.greenF();
|
|
|
|
_from_b = _cur.blueF();
|
|
|
|
_from_a = _cur.alphaF();
|
|
|
|
_delta_r = to.redF() - _from_r;
|
|
|
|
_delta_g = to.greenF() - _from_g;
|
|
|
|
_delta_b = to.blueF() - _from_b;
|
|
|
|
_delta_a = to.alphaF() - _from_a;
|
|
|
|
}
|
|
|
|
void restart() {
|
|
|
|
_delta_r = _from_r + _delta_r - _cur.redF();
|
|
|
|
_delta_g = _from_g + _delta_g - _cur.greenF();
|
|
|
|
_delta_b = _from_b + _delta_b - _cur.blueF();
|
|
|
|
_delta_a = _from_a + _delta_a - _cur.alphaF();
|
|
|
|
_from_r = _cur.redF();
|
|
|
|
_from_g = _cur.greenF();
|
|
|
|
_from_b = _cur.blueF();
|
|
|
|
_from_a = _cur.alphaF();
|
|
|
|
}
|
|
|
|
const QColor ¤t() const {
|
|
|
|
return _cur;
|
|
|
|
}
|
2014-10-17 12:57:14 +00:00
|
|
|
QColor to() const {
|
|
|
|
QColor result;
|
|
|
|
result.setRedF(_from_r + _delta_r);
|
|
|
|
result.setGreenF(_from_g + _delta_g);
|
|
|
|
result.setBlueF(_from_b + _delta_b);
|
|
|
|
result.setAlphaF(_from_a + _delta_a);
|
|
|
|
return result;
|
|
|
|
}
|
2014-08-11 09:03:45 +00:00
|
|
|
cvalue &update(const float64 &dt, transition func) {
|
2014-05-30 08:53:19 +00:00
|
|
|
_cur.setRedF(_from_r + (*func)(_delta_r, dt));
|
|
|
|
_cur.setGreenF(_from_g + (*func)(_delta_g, dt));
|
|
|
|
_cur.setBlueF(_from_b + (*func)(_delta_b, dt));
|
|
|
|
_cur.setAlphaF(_from_a + (*func)(_delta_a, dt));
|
2014-08-11 09:03:45 +00:00
|
|
|
return *this;
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
void finish() {
|
|
|
|
_cur.setRedF(_from_r + _delta_r);
|
|
|
|
_cur.setGreenF(_from_g + _delta_g);
|
|
|
|
_cur.setBlueF(_from_b + _delta_b);
|
|
|
|
_cur.setAlphaF(_from_a + _delta_a);
|
|
|
|
_from_r = _cur.redF();
|
|
|
|
_from_g = _cur.greenF();
|
|
|
|
_from_b = _cur.blueF();
|
|
|
|
_from_a = _cur.alphaF();
|
|
|
|
_delta_r = _delta_g = _delta_b = _delta_a = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
QColor _cur;
|
|
|
|
float64 _from_r, _from_g, _from_b, _from_a, _delta_r, _delta_g, _delta_b, _delta_a;
|
|
|
|
};
|
|
|
|
|
|
|
|
void startManager();
|
|
|
|
void stopManager();
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
class Animation;
|
|
|
|
|
|
|
|
class AnimationCallbacks {
|
2014-05-30 08:53:19 +00:00
|
|
|
public:
|
2015-12-08 12:33:37 +00:00
|
|
|
virtual void start() {
|
|
|
|
}
|
2014-05-30 08:53:19 +00:00
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
virtual void step(Animation *a, uint64 ms, bool timer) = 0;
|
|
|
|
|
|
|
|
virtual ~AnimationCallbacks() {
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
2015-12-08 12:33:37 +00:00
|
|
|
};
|
2014-05-30 08:53:19 +00:00
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
class Animation {
|
|
|
|
public:
|
2014-05-30 08:53:19 +00:00
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
Animation(AnimationCallbacks *cb) : _cb(cb), _animating(false) {
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
void start();
|
|
|
|
void stop();
|
|
|
|
|
|
|
|
void step(uint64 ms, bool timer = false) {
|
|
|
|
_cb->step(this, ms, timer);
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
void step() {
|
|
|
|
step(getms(), false);
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
bool animating() const {
|
|
|
|
return _animating;
|
|
|
|
}
|
2014-05-30 08:53:19 +00:00
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
~Animation() {
|
|
|
|
if (_animating) stop();
|
|
|
|
delete _cb;
|
|
|
|
}
|
2014-05-30 08:53:19 +00:00
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
private:
|
|
|
|
AnimationCallbacks *_cb;
|
|
|
|
bool _animating;
|
2014-05-30 08:53:19 +00:00
|
|
|
|
2015-05-29 18:52:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename Type>
|
2015-12-08 12:33:37 +00:00
|
|
|
class AnimationCallbacksRelative : public AnimationCallbacks {
|
2015-05-29 18:52:43 +00:00
|
|
|
public:
|
2015-12-08 12:33:37 +00:00
|
|
|
typedef void (Type::*Method)(float64, bool);
|
2015-05-29 18:52:43 +00:00
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
AnimationCallbacksRelative(Type *obj, Method method) : _started(0), _obj(obj), _method(method) {
|
2015-05-29 18:52:43 +00:00
|
|
|
}
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
void start() {
|
|
|
|
_started = float64(getms());
|
2015-05-29 18:52:43 +00:00
|
|
|
}
|
2015-12-08 12:33:37 +00:00
|
|
|
|
|
|
|
void step(Animation *a, uint64 ms, bool timer) {
|
|
|
|
(_obj->*_method)(ms - _started, timer);
|
|
|
|
}
|
|
|
|
|
2015-05-29 18:52:43 +00:00
|
|
|
private:
|
2015-12-08 12:33:37 +00:00
|
|
|
float64 _started;
|
2015-05-29 18:52:43 +00:00
|
|
|
Type *_obj;
|
|
|
|
Method _method;
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
};
|
2015-05-29 18:52:43 +00:00
|
|
|
template <typename Type>
|
2015-12-08 12:33:37 +00:00
|
|
|
AnimationCallbacks *animation(Type *obj, typename AnimationCallbacksRelative<Type>::Method method) {
|
|
|
|
return new AnimationCallbacksRelative<Type>(obj, method);
|
2015-05-29 18:52:43 +00:00
|
|
|
}
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
template <typename Type>
|
|
|
|
class AnimationCallbacksAbsolute : public AnimationCallbacks {
|
2015-05-29 18:52:43 +00:00
|
|
|
public:
|
2015-12-08 12:33:37 +00:00
|
|
|
typedef void (Type::*Method)(uint64, bool);
|
2015-05-29 18:52:43 +00:00
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
AnimationCallbacksAbsolute(Type *obj, Method method) : _obj(obj), _method(method) {
|
2015-05-29 18:52:43 +00:00
|
|
|
}
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
void step(Animation *a, uint64 ms, bool timer) {
|
|
|
|
(_obj->*_method)(ms, timer);
|
2015-05-29 18:52:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2015-12-08 12:33:37 +00:00
|
|
|
Type *_obj;
|
|
|
|
Method _method;
|
2015-05-29 18:52:43 +00:00
|
|
|
|
|
|
|
};
|
2015-12-08 12:33:37 +00:00
|
|
|
template <typename Type>
|
|
|
|
AnimationCallbacks *animation(Type *obj, typename AnimationCallbacksAbsolute<Type>::Method method) {
|
|
|
|
return new AnimationCallbacksAbsolute<Type>(obj, method);
|
|
|
|
}
|
2015-05-29 18:52:43 +00:00
|
|
|
|
2014-05-30 08:53:19 +00:00
|
|
|
class AnimationManager : public QObject {
|
|
|
|
Q_OBJECT
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
AnimationManager() : _timer(this), _iterating(false) {
|
|
|
|
_timer.setSingleShot(false);
|
|
|
|
connect(&_timer, SIGNAL(timeout()), this, SLOT(timeout()));
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
void start(Animation *obj) {
|
|
|
|
if (_iterating) {
|
|
|
|
_starting.insert(obj, NullType());
|
|
|
|
if (!_stopping.isEmpty()) {
|
|
|
|
_stopping.remove(obj);
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
} else {
|
2015-12-08 12:33:37 +00:00
|
|
|
if (_objects.isEmpty()) {
|
|
|
|
_timer.start(AnimationTimerDelta);
|
2015-04-19 19:01:45 +00:00
|
|
|
}
|
2015-12-08 12:33:37 +00:00
|
|
|
_objects.insert(obj, NullType());
|
2015-04-19 19:01:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
void stop(Animation *obj) {
|
|
|
|
if (_iterating) {
|
|
|
|
_stopping.insert(obj, NullType());
|
|
|
|
if (!_starting.isEmpty()) {
|
|
|
|
_starting.insert(obj, NullType());
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
} else {
|
2015-12-08 12:33:37 +00:00
|
|
|
AnimatingObjects::iterator i = _objects.find(obj);
|
|
|
|
if (i != _objects.cend()) {
|
|
|
|
_objects.erase(i);
|
|
|
|
if (_objects.isEmpty()) {
|
|
|
|
_timer.stop();
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public slots:
|
2015-12-08 12:33:37 +00:00
|
|
|
|
2014-05-30 08:53:19 +00:00
|
|
|
void timeout() {
|
2015-12-08 12:33:37 +00:00
|
|
|
_iterating = true;
|
|
|
|
uint64 ms = getms();
|
|
|
|
for (AnimatingObjects::const_iterator i = _objects.begin(), e = _objects.end(); i != e; ++i) {
|
|
|
|
i.key()->step(ms, true);
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
2015-12-08 12:33:37 +00:00
|
|
|
_iterating = false;
|
|
|
|
|
|
|
|
if (!_starting.isEmpty()) {
|
|
|
|
for (AnimatingObjects::iterator i = _starting.begin(), e = _starting.end(); i != e; ++i) {
|
|
|
|
_objects.insert(i.key(), NullType());
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
2015-12-08 12:33:37 +00:00
|
|
|
_starting.clear();
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
2015-12-08 12:33:37 +00:00
|
|
|
if (!_stopping.isEmpty()) {
|
|
|
|
for (AnimatingObjects::iterator i = _stopping.begin(), e = _stopping.end(); i != e; ++i) {
|
|
|
|
_objects.remove(i.key());
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
2015-12-08 12:33:37 +00:00
|
|
|
_stopping.clear();
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
2015-12-08 12:33:37 +00:00
|
|
|
if (!_objects.size()) {
|
|
|
|
_timer.stop();
|
2014-05-30 08:53:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
typedef QMap<Animation*, NullType> AnimatingObjects;
|
|
|
|
AnimatingObjects _objects, _starting, _stopping;
|
|
|
|
QTimer _timer;
|
|
|
|
bool _iterating;
|
2014-05-30 08:53:19 +00:00
|
|
|
|
|
|
|
};
|
2015-04-19 10:29:19 +00:00
|
|
|
|
|
|
|
class HistoryItem;
|
2015-11-26 17:34:52 +00:00
|
|
|
class FileLocation;
|
2015-12-08 12:33:37 +00:00
|
|
|
class AnimatedGif : public QObject {
|
2015-04-19 10:29:19 +00:00
|
|
|
Q_OBJECT
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
AnimatedGif() : QObject()
|
|
|
|
, msg(0)
|
|
|
|
, file(0)
|
|
|
|
, access(false)
|
|
|
|
, reader(0)
|
|
|
|
, w(0)
|
|
|
|
, h(0)
|
|
|
|
, frame(0)
|
|
|
|
, framesCount(0)
|
|
|
|
, duration(0)
|
|
|
|
, _a_frames(animation(this, &AnimatedGif::step_frame)) {
|
2015-04-19 10:29:19 +00:00
|
|
|
}
|
|
|
|
|
2015-12-08 12:33:37 +00:00
|
|
|
void step_frame(float64 ms, bool timer);
|
2015-04-19 10:29:19 +00:00
|
|
|
|
2015-11-26 17:34:52 +00:00
|
|
|
void start(HistoryItem *row, const FileLocation &file);
|
2015-04-19 10:29:19 +00:00
|
|
|
void stop(bool onItemRemoved = false);
|
|
|
|
|
|
|
|
bool isNull() const {
|
|
|
|
return !reader;
|
|
|
|
}
|
|
|
|
|
|
|
|
~AnimatedGif() {
|
|
|
|
stop(true);
|
|
|
|
}
|
|
|
|
|
2015-05-21 12:08:05 +00:00
|
|
|
const QPixmap ¤t(int32 width = 0, int32 height = 0, bool rounded = false);
|
|
|
|
|
2015-04-19 10:29:19 +00:00
|
|
|
signals:
|
|
|
|
|
|
|
|
void updated();
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
HistoryItem *msg;
|
|
|
|
QImage img;
|
2015-11-26 17:34:52 +00:00
|
|
|
FileLocation *file;
|
|
|
|
bool access;
|
2015-04-19 10:29:19 +00:00
|
|
|
QImageReader *reader;
|
2015-05-21 12:08:05 +00:00
|
|
|
int32 w, h, frame;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2015-04-19 10:29:19 +00:00
|
|
|
QVector<QPixmap> frames;
|
2015-05-21 12:08:05 +00:00
|
|
|
QVector<QImage> images;
|
2015-04-19 10:29:19 +00:00
|
|
|
QVector<int64> delays;
|
2015-05-21 12:08:05 +00:00
|
|
|
int32 framesCount, duration;
|
2015-12-08 12:33:37 +00:00
|
|
|
|
|
|
|
Animation _a_frames;
|
|
|
|
|
2015-04-19 10:29:19 +00:00
|
|
|
};
|