procxx
/
kepka
mirror of https://github.com/procxx/kepka.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Revert "Don't restart animations timer." 

This reverts commit 392d90dc1d.

Otherwise scrolling while typing animates lags terribly on macOS.
This commit is contained in:
John Preston 2019-04-11 10:15:47 +04:00
parent 5187e6dc58
commit 71f340d9b5
2 changed files with 56 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
Telegram/SourceFiles/ui/effects/animations.cpp
View File

@ -53,22 +53,21 @@ void Basic::markStopped() {
Manager::Manager() { Manager::Manager() {
Core::Sandbox::Instance().widgetUpdateRequests( Core::Sandbox::Instance().widgetUpdateRequests(
/*) | rpl::filter([=] { ) | rpl::filter([=] {
return (_lastUpdateTime + kIgnoreUpdatesTimeout < crl::now()); return (_lastUpdateTime + kIgnoreUpdatesTimeout < crl::now());
}*/) | rpl::start_with_next([=] { }) | rpl::start_with_next([=] {
update(UpdateSource::RepaintRequest); update();
}, _lifetime); }, _lifetime);
} }
void Manager::start(not_null<Basic*> animation) { void Manager::start(not_null<Basic*> animation) {
_forceUpdateProcessing = true; _forceImmediateUpdate = true;
if (_updating) { if (_updating) {
_starting.emplace_back(animation.get()); _starting.emplace_back(animation.get());
return; } else {
schedule();
_active.emplace_back(animation.get());
} }
_active.emplace_back(animation.get());
startTimer();
updateQueued();
} }
void Manager::stop(not_null<Basic*> animation) { void Manager::stop(not_null<Basic*> animation) {
@ -90,16 +89,15 @@ void Manager::stop(not_null<Basic*> animation) {
} }
} }
void Manager::update(UpdateSource source) { void Manager::update() {
if (_active.empty() || _updating) { if (_active.empty() || _updating || _scheduled) {
return; return;
} }
const auto now = crl::now(); const auto now = crl::now();
if (_forceUpdateProcessing) { if (_forceImmediateUpdate) {
_forceUpdateProcessing = false; _forceImmediateUpdate = false;
} else if (now < _lastUpdateTime + kIgnoreUpdatesTimeout) {
return;
} }
schedule();
_updating = true; _updating = true;
const auto guard = gsl::finally([&] { _updating = false; }); const auto guard = gsl::finally([&] { _updating = false; });
@ -110,30 +108,48 @@ void Manager::update(UpdateSource source) {
}; };
_active.erase(ranges::remove_if(_active, isFinished), end(_active)); _active.erase(ranges::remove_if(_active, isFinished), end(_active));
if (empty(_starting)) { if (!empty(_starting)) {
if (empty(_active)) { _active.insert(
stopTimer(); end(_active),
} std::make_move_iterator(begin(_starting)),
return; std::make_move_iterator(end(_starting)));
} _starting.clear();
_active.insert(
end(_active),
std::make_move_iterator(begin(_starting)),
std::make_move_iterator(end(_starting)));
_starting.clear();
if (_forceUpdateProcessing) {
updateQueued();
} }
} }
void Manager::updateQueued() { void Manager::updateQueued() {
if (_queued) { Expects(_timerId == 0);
_timerId = -1;
crl::on_main(delayedCallGuard(), [=] {
Expects(_timerId < 0);
_timerId = 0;
update();
});
}
void Manager::schedule() {
if (_scheduled || _timerId < 0) {
return; return;
} }
_queued = true; stopTimer();
crl::on_main(delayedCallGuard(), [=] {
_queued = false; _scheduled = true;
update(UpdateSource::Queued); Ui::PostponeCall(delayedCallGuard(), [=] {
_scheduled = false;
if (_forceImmediateUpdate) {
_forceImmediateUpdate = false;
updateQueued();
} else {
const auto next = _lastUpdateTime + kAnimationTimeout;
const auto now = crl::now();
if (now < next) {
_timerId = startTimer(next - now, Qt::PreciseTimer);
} else {
updateQueued();
}
}
}); });
} }
@ -141,22 +157,14 @@ not_null<const QObject*> Manager::delayedCallGuard() const {
return static_cast<const QObject*>(this); return static_cast<const QObject*>(this);
} }
void Manager::startTimer() {
if (_timerId) {
return;
}
_timerId = QObject::startTimer(kAnimationTick, Qt::PreciseTimer);
}
void Manager::stopTimer() { void Manager::stopTimer() {
if (!_timerId) { if (_timerId > 0) {
return; killTimer(base::take(_timerId));
} }
killTimer(base::take(_timerId));
} }
void Manager::timerEvent(QTimerEvent *e) { void Manager::timerEvent(QTimerEvent *e) {
update(UpdateSource::TimerEvent); update();
} }
} // namespace Animations } // namespace Animations

15
Telegram/SourceFiles/ui/effects/animations.h
View File

@ -101,13 +101,9 @@ class Manager final : private QObject {
public: public:
Manager(); Manager();
private: void update();
enum class UpdateSource {
Queued,
TimerEvent,
RepaintRequest,
};
private:
class ActiveBasicPointer { class ActiveBasicPointer {
public: public:
ActiveBasicPointer(Basic *value = nullptr) : _value(value) { ActiveBasicPointer(Basic *value = nullptr) : _value(value) {
@ -155,21 +151,20 @@ private:
friend class Basic; friend class Basic;
void timerEvent(QTimerEvent *e) override; void timerEvent(QTimerEvent *e) override;
void update(UpdateSource source);
void start(not_null<Basic*> animation); void start(not_null<Basic*> animation);
void stop(not_null<Basic*> animation); void stop(not_null<Basic*> animation);
void schedule();
void updateQueued(); void updateQueued();
void startTimer();
void stopTimer(); void stopTimer();
not_null<const QObject*> delayedCallGuard() const; not_null<const QObject*> delayedCallGuard() const;
crl::time _lastUpdateTime = 0; crl::time _lastUpdateTime = 0;
int _timerId = 0; int _timerId = 0;
bool _updating = false; bool _updating = false;
bool _queued = false; bool _scheduled = false;
bool _forceUpdateProcessing = false; bool _forceImmediateUpdate = false;
std::vector<ActiveBasicPointer> _active; std::vector<ActiveBasicPointer> _active;
std::vector<ActiveBasicPointer> _starting; std::vector<ActiveBasicPointer> _starting;
rpl::lifetime _lifetime; rpl::lifetime _lifetime;