tdesktop/Telegram/SourceFiles/window/window_connecting_widget.cpp

619 lines
16 KiB
C++
Raw Normal View History

2018-05-07 17:44:33 +00:00
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "window/window_connecting_widget.h"
#include "ui/widgets/buttons.h"
#include "ui/effects/radial_animation.h"
2019-09-13 12:22:54 +00:00
#include "ui/ui_utility.h"
#include "mtproto/mtp_instance.h"
2019-11-13 08:31:12 +00:00
#include "mtproto/facade.h"
#include "main/main_account.h"
#include "core/application.h"
#include "core/core_settings.h"
#include "core/update_checker.h"
2018-05-07 17:44:33 +00:00
#include "boxes/connection_box.h"
2019-09-18 11:19:05 +00:00
#include "boxes/abstract_box.h"
2018-05-07 17:44:33 +00:00
#include "lang/lang_keys.h"
#include "styles/style_window.h"
namespace Window {
namespace {
constexpr auto kIgnoreStartConnectingFor = crl::time(3000);
constexpr auto kConnectingStateDelay = crl::time(1000);
constexpr auto kRefreshTimeout = crl::time(200);
constexpr auto kMinimalWaitingStateDuration = crl::time(4000);
2018-05-07 17:44:33 +00:00
class Progress : public Ui::RpWidget {
public:
Progress(QWidget *parent);
protected:
void paintEvent(QPaintEvent *e) override;
private:
void animationStep();
2018-05-07 17:44:33 +00:00
Ui::InfiniteRadialAnimation _animation;
};
Progress::Progress(QWidget *parent)
: RpWidget(parent)
, _animation([=] { animationStep(); }, st::connectingRadial) {
2018-05-07 17:44:33 +00:00
setAttribute(Qt::WA_OpaquePaintEvent);
setAttribute(Qt::WA_TransparentForMouseEvents);
resize(st::connectingRadial.size);
2019-02-10 16:29:55 +00:00
_animation.start(st::connectingRadial.sineDuration);
2018-05-07 17:44:33 +00:00
}
void Progress::paintEvent(QPaintEvent *e) {
Painter p(this);
p.fillRect(e->rect(), st::windowBg);
const auto &st = st::connectingRadial;
const auto shift = st.thickness - (st.thickness / 2);
_animation.draw(
p,
{ shift, shift },
QSize(st.size.width() - 2 * shift, st.size.height() - 2 * shift),
width());
}
void Progress::animationStep() {
if (!anim::Disabled()) {
2018-05-07 17:44:33 +00:00
update();
}
}
} // namespace
2019-02-10 16:29:55 +00:00
class ConnectionState::Widget : public Ui::AbstractButton {
public:
2020-06-10 14:52:44 +00:00
Widget(
QWidget *parent,
not_null<Main::Account*> account,
const Layout &layout);
2019-02-10 16:29:55 +00:00
void refreshRetryLink(bool hasRetry);
void setLayout(const Layout &layout);
void setProgressVisibility(bool visible);
rpl::producer<> refreshStateRequests() const;
protected:
void resizeEvent(QResizeEvent *e) override;
void paintEvent(QPaintEvent *e) override;
void onStateChanged(State was, StateChangeSource source) override;
private:
class ProxyIcon;
using State = ConnectionState::State;
using Layout = ConnectionState::Layout;
void updateRetryGeometry();
QRect innerRect() const;
QRect contentRect() const;
QRect textRect() const;
const not_null<Main::Account*> _account;
2019-02-10 16:29:55 +00:00
Layout _currentLayout;
base::unique_qptr<Ui::LinkButton> _retry;
QPointer<Ui::RpWidget> _progress;
QPointer<ProxyIcon> _proxyIcon;
rpl::event_stream<> _refreshStateRequests;
};
class ConnectionState::Widget::ProxyIcon final : public Ui::RpWidget {
2018-05-07 17:44:33 +00:00
public:
ProxyIcon(QWidget *parent);
void setToggled(bool toggled);
void setOpacity(float64 opacity);
protected:
void paintEvent(QPaintEvent *e) override;
private:
void refreshCacheImages();
2018-05-07 17:44:33 +00:00
float64 _opacity = 1.;
QPixmap _cacheOn;
QPixmap _cacheOff;
bool _toggled = true;
};
2019-02-10 16:29:55 +00:00
ConnectionState::Widget::ProxyIcon::ProxyIcon(QWidget *parent) : RpWidget(parent) {
2018-05-07 17:44:33 +00:00
resize(
std::max(
st::connectingRadial.size.width(),
st::connectingProxyOn.width()),
std::max(
st::connectingRadial.size.height(),
st::connectingProxyOn.height()));
style::PaletteChanged(
) | rpl::start_with_next([=] {
refreshCacheImages();
}, lifetime());
refreshCacheImages();
}
2019-02-10 16:29:55 +00:00
void ConnectionState::Widget::ProxyIcon::refreshCacheImages() {
2018-05-07 17:44:33 +00:00
const auto prepareCache = [&](const style::icon &icon) {
auto image = QImage(
size() * cIntRetinaFactor(),
QImage::Format_ARGB32_Premultiplied);
image.setDevicePixelRatio(cRetinaFactor());
2018-05-07 17:44:33 +00:00
image.fill(st::windowBg->c);
{
Painter p(&image);
icon.paint(
p,
(width() - icon.width()) / 2,
(height() - icon.height()) / 2,
width());
}
2021-05-07 14:33:53 +00:00
return Ui::PixmapFromImage(std::move(image));
2018-05-07 17:44:33 +00:00
};
_cacheOn = prepareCache(st::connectingProxyOn);
_cacheOff = prepareCache(st::connectingProxyOff);
}
2019-02-10 16:29:55 +00:00
void ConnectionState::Widget::ProxyIcon::setToggled(bool toggled) {
2018-05-07 17:44:33 +00:00
if (_toggled != toggled) {
_toggled = toggled;
update();
}
}
2019-02-10 16:29:55 +00:00
void ConnectionState::Widget::ProxyIcon::setOpacity(float64 opacity) {
2018-05-07 17:44:33 +00:00
_opacity = opacity;
if (_opacity == 0.) {
hide();
} else if (isHidden()) {
show();
}
update();
}
2019-02-10 16:29:55 +00:00
void ConnectionState::Widget::ProxyIcon::paintEvent(QPaintEvent *e) {
2018-05-07 17:44:33 +00:00
Painter p(this);
p.setOpacity(_opacity);
p.drawPixmap(0, 0, _toggled ? _cacheOn : _cacheOff);
}
2019-02-11 12:55:54 +00:00
bool ConnectionState::State::operator==(const State &other) const {
2018-05-07 17:44:33 +00:00
return (type == other.type)
&& (useProxy == other.useProxy)
&& (underCursor == other.underCursor)
&& (updateReady == other.updateReady)
2018-05-07 17:44:33 +00:00
&& (waitTillRetry == other.waitTillRetry);
}
2019-02-10 16:29:55 +00:00
ConnectionState::ConnectionState(
not_null<Ui::RpWidget*> parent,
2020-06-10 14:52:44 +00:00
not_null<Main::Account*> account,
2019-02-10 16:29:55 +00:00
rpl::producer<bool> shown)
2020-06-10 14:52:44 +00:00
: _account(account)
, _parent(parent)
2018-05-07 17:44:33 +00:00
, _refreshTimer([=] { refreshState(); })
, _currentLayout(computeLayout(_state)) {
2019-02-10 16:29:55 +00:00
rpl::combine(
std::move(shown),
visibility()
) | rpl::start_with_next([=](bool shown, float64 visible) {
if (!shown || visible == 0.) {
_widget = nullptr;
} else if (!_widget) {
createWidget();
}
}, _lifetime);
2018-05-07 17:44:33 +00:00
if (!Core::UpdaterDisabled()) {
Core::UpdateChecker checker;
rpl::merge(
rpl::single(rpl::empty_value()),
checker.ready()
) | rpl::start_with_next([=] {
refreshState();
}, _lifetime);
}
Core::App().settings().proxy().connectionTypeValue(
) | rpl::start_with_next([=] {
refreshState();
}, _lifetime);
2018-05-07 17:44:33 +00:00
}
2019-02-10 16:29:55 +00:00
void ConnectionState::createWidget() {
2020-06-10 14:52:44 +00:00
_widget = base::make_unique_q<Widget>(_parent, _account, _currentLayout);
2019-02-10 16:29:55 +00:00
_widget->setVisible(!_forceHidden);
2018-05-07 17:44:33 +00:00
2019-02-10 16:29:55 +00:00
updateWidth();
2018-05-07 17:44:33 +00:00
rpl::combine(
2019-02-10 16:29:55 +00:00
visibility(),
_parent->heightValue()
2018-05-10 10:24:40 +00:00
) | rpl::start_with_next([=](float64 visible, int height) {
2019-02-10 16:29:55 +00:00
_widget->moveToLeft(0, anim::interpolate(
2018-05-07 17:44:33 +00:00
height - st::connectingMargin.top(),
2019-02-10 16:29:55 +00:00
height - _widget->height(),
2018-05-07 17:44:33 +00:00
visible));
2019-02-10 16:29:55 +00:00
}, _widget->lifetime());
2018-05-07 17:44:33 +00:00
2019-02-10 16:29:55 +00:00
_widget->refreshStateRequests(
) | rpl::start_with_next([=] {
refreshState();
}, _widget->lifetime());
2018-05-07 17:44:33 +00:00
}
2019-02-10 16:29:55 +00:00
void ConnectionState::raise() {
if (_widget) {
_widget->raise();
2018-05-07 17:44:33 +00:00
}
}
2019-02-10 16:29:55 +00:00
void ConnectionState::finishAnimating() {
if (_contentWidth.animating()) {
2019-04-02 09:13:30 +00:00
_contentWidth.stop();
2019-02-10 16:29:55 +00:00
updateWidth();
2018-05-07 17:44:33 +00:00
}
2019-02-10 16:29:55 +00:00
if (_visibility.animating()) {
2019-04-02 09:13:30 +00:00
_visibility.stop();
2019-02-10 16:29:55 +00:00
updateVisibility();
2018-05-07 17:44:33 +00:00
}
}
2019-02-10 16:29:55 +00:00
void ConnectionState::setForceHidden(bool hidden) {
_forceHidden = hidden;
if (_widget) {
_widget->setVisible(!hidden);
2018-05-07 17:44:33 +00:00
}
}
2019-02-10 16:29:55 +00:00
void ConnectionState::refreshState() {
using Checker = Core::UpdateChecker;
2018-05-07 17:44:33 +00:00
const auto state = [&]() -> State {
2019-02-10 16:29:55 +00:00
const auto under = _widget && _widget->isOver();
const auto ready = (Checker().state() == Checker::State::Ready);
const auto state = _account->mtp().dcstate();
const auto proxy = Core::App().settings().proxy().isEnabled();
if (state == MTP::ConnectingState
|| state == MTP::DisconnectedState
|| (state < 0 && state > -600)) {
return { State::Type::Connecting, proxy, under, ready };
} else if (state < 0
&& state >= -kMinimalWaitingStateDuration
2018-05-07 17:44:33 +00:00
&& _state.type != State::Type::Waiting) {
return { State::Type::Connecting, proxy, under, ready };
} else if (state < 0) {
const auto wait = ((-state) / 1000) + 1;
return { State::Type::Waiting, proxy, under, ready, wait };
2018-05-07 17:44:33 +00:00
}
return { State::Type::Connected, proxy, under, ready };
2018-05-07 17:44:33 +00:00
}();
if (state.waitTillRetry > 0) {
_refreshTimer.callOnce(kRefreshTimeout);
}
if (state == _state) {
return;
} else if (state.type == State::Type::Connecting
&& _state.type == State::Type::Connected) {
const auto now = crl::now();
2018-05-07 17:44:33 +00:00
if (!_connectingStartedAt) {
_connectingStartedAt = now;
_refreshTimer.callOnce(kConnectingStateDelay);
return;
}
const auto applyConnectingAt = std::max(
_connectingStartedAt + kConnectingStateDelay,
kIgnoreStartConnectingFor);
if (now < applyConnectingAt) {
_refreshTimer.callOnce(applyConnectingAt - now);
return;
}
}
applyState(state);
}
2019-02-10 16:29:55 +00:00
void ConnectionState::applyState(const State &state) {
2018-05-07 17:44:33 +00:00
const auto newLayout = computeLayout(state);
2019-02-10 16:29:55 +00:00
const auto guard = gsl::finally([&] { updateWidth(); });
2018-05-07 17:44:33 +00:00
_state = state;
if (_currentLayout.visible != newLayout.visible) {
changeVisibilityWithLayout(newLayout);
return;
}
if (_currentLayout.contentWidth != newLayout.contentWidth) {
if (!_currentLayout.contentWidth
|| !newLayout.contentWidth
|| _contentWidth.animating()) {
_contentWidth.start(
[=] { updateWidth(); },
_currentLayout.contentWidth,
newLayout.contentWidth,
st::connectingDuration);
}
}
const auto saved = _currentLayout;
setLayout(newLayout);
if (_currentLayout.text.isEmpty()
&& !saved.text.isEmpty()
&& _contentWidth.animating()) {
_currentLayout.text = saved.text;
_currentLayout.textWidth = saved.textWidth;
}
}
2019-02-10 16:29:55 +00:00
void ConnectionState::changeVisibilityWithLayout(const Layout &layout) {
2018-05-07 17:44:33 +00:00
Expects(_currentLayout.visible != layout.visible);
const auto changeLayout = !_currentLayout.visible;
_visibility.start(
[=] { updateVisibility(); },
layout.visible ? 0. : 1.,
layout.visible ? 1. : 0.,
st::connectingDuration);
if (_contentWidth.animating()) {
_contentWidth.start(
[=] { updateWidth(); },
_currentLayout.contentWidth,
(changeLayout ? layout : _currentLayout).contentWidth,
st::connectingDuration);
}
if (changeLayout) {
setLayout(layout);
} else {
_currentLayout.visible = layout.visible;
}
}
2019-02-10 16:29:55 +00:00
void ConnectionState::setLayout(const Layout &layout) {
2018-05-07 17:44:33 +00:00
_currentLayout = layout;
2019-02-10 16:29:55 +00:00
if (_widget) {
_widget->setLayout(layout);
}
refreshProgressVisibility();
2018-05-07 17:44:33 +00:00
}
2019-02-10 16:29:55 +00:00
void ConnectionState::refreshProgressVisibility() {
if (_widget) {
_widget->setProgressVisibility(_contentWidth.animating()
|| _currentLayout.progressShown);
2018-05-07 17:44:33 +00:00
}
}
2019-02-10 16:29:55 +00:00
void ConnectionState::updateVisibility() {
2018-05-07 17:44:33 +00:00
const auto value = currentVisibility();
if (value == 0. && _contentWidth.animating()) {
2019-04-02 09:13:30 +00:00
_contentWidth.stop();
2018-05-07 17:44:33 +00:00
updateWidth();
}
_visibilityValues.fire_copy(value);
}
2019-02-10 16:29:55 +00:00
float64 ConnectionState::currentVisibility() const {
2019-04-02 09:13:30 +00:00
return _visibility.value(_currentLayout.visible ? 1. : 0.);
2018-05-07 17:44:33 +00:00
}
2019-02-10 16:29:55 +00:00
rpl::producer<float64> ConnectionState::visibility() const {
return _visibilityValues.events_starting_with(currentVisibility());
}
auto ConnectionState::computeLayout(const State &state) const -> Layout {
2018-05-07 17:44:33 +00:00
auto result = Layout();
result.proxyEnabled = state.useProxy;
result.progressShown = (state.type != State::Type::Connected);
result.visible = !state.updateReady
&& (state.useProxy
|| state.type == State::Type::Connecting
|| state.type == State::Type::Waiting);
2018-05-07 17:44:33 +00:00
switch (state.type) {
case State::Type::Connecting:
result.text = state.underCursor
? tr::lng_connecting(tr::now)
: QString();
2018-05-07 17:44:33 +00:00
break;
case State::Type::Waiting:
Assert(state.waitTillRetry > 0);
result.text = tr::lng_reconnecting(
tr::now,
lt_count,
state.waitTillRetry);
2018-05-07 17:44:33 +00:00
break;
}
result.textWidth = st::normalFont->width(result.text);
result.contentWidth = (result.textWidth > 0)
? (st::connectingTextPadding.left()
+ result.textWidth
+ st::connectingTextPadding.right())
: 0;
if (state.type == State::Type::Waiting) {
result.contentWidth += st::connectingRetryLink.padding.left()
+ st::connectingRetryLink.font->width(
2019-06-19 15:09:03 +00:00
tr::lng_reconnecting_try_now(tr::now))
2018-05-07 17:44:33 +00:00
+ st::connectingRetryLink.padding.right();
}
result.hasRetry = (state.type == State::Type::Waiting);
return result;
}
2019-02-10 16:29:55 +00:00
void ConnectionState::updateWidth() {
2019-04-02 09:13:30 +00:00
const auto current = _contentWidth.value(_currentLayout.contentWidth);
2018-05-07 17:44:33 +00:00
const auto height = st::connectingLeft.height();
const auto desired = QRect(0, 0, current, height).marginsAdded(
style::margins(
st::connectingLeft.width(),
0,
st::connectingRight.width(),
0)
).marginsAdded(
st::connectingMargin
);
2019-02-10 16:29:55 +00:00
if (_widget) {
_widget->resize(desired.size());
_widget->update();
}
refreshProgressVisibility();
}
2020-06-10 14:52:44 +00:00
ConnectionState::Widget::Widget(
QWidget *parent,
not_null<Main::Account*> account,
const Layout &layout)
2019-02-10 16:29:55 +00:00
: AbstractButton(parent)
, _account(account)
2019-02-10 16:29:55 +00:00
, _currentLayout(layout) {
_proxyIcon = Ui::CreateChild<ProxyIcon>(this);
_progress = Ui::CreateChild<Progress>(this);
addClickHandler([=] {
2020-06-10 14:52:44 +00:00
Ui::show(ProxiesBoxController::CreateOwningBox(account));
2019-02-10 16:29:55 +00:00
});
}
void ConnectionState::Widget::onStateChanged(
AbstractButton::State was,
StateChangeSource source) {
Ui::PostponeCall(crl::guard(this, [=] {
_refreshStateRequests.fire({});
}));
}
rpl::producer<> ConnectionState::Widget::refreshStateRequests() const {
return _refreshStateRequests.events();
}
void ConnectionState::Widget::paintEvent(QPaintEvent *e) {
Painter p(this);
PainterHighQualityEnabler hq(p);
p.setPen(Qt::NoPen);
p.setBrush(st::windowBg);
const auto inner = innerRect();
const auto content = contentRect();
const auto text = textRect();
const auto left = inner.topLeft();
const auto right = content.topLeft() + QPoint(content.width(), 0);
st::connectingLeftShadow.paint(p, left, width());
st::connectingLeft.paint(p, left, width());
st::connectingRightShadow.paint(p, right, width());
st::connectingRight.paint(p, right, width());
st::connectingBodyShadow.fill(p, content);
st::connectingBody.fill(p, content);
const auto available = text.width();
if (available > 0 && !_currentLayout.text.isEmpty()) {
p.setFont(st::normalFont);
p.setPen(st::windowSubTextFg);
if (available >= _currentLayout.textWidth) {
p.drawTextLeft(
text.x(),
text.y(),
width(),
_currentLayout.text,
_currentLayout.textWidth);
} else {
p.drawTextLeft(
text.x(),
text.y(),
width(),
st::normalFont->elided(_currentLayout.text, available));
}
}
}
QRect ConnectionState::Widget::innerRect() const {
return rect().marginsRemoved(
st::connectingMargin
);
}
QRect ConnectionState::Widget::contentRect() const {
return innerRect().marginsRemoved(style::margins(
st::connectingLeft.width(),
0,
st::connectingRight.width(),
0));
}
QRect ConnectionState::Widget::textRect() const {
return contentRect().marginsRemoved(
st::connectingTextPadding
);
}
void ConnectionState::Widget::resizeEvent(QResizeEvent *e) {
{
const auto xShift = (height() - _progress->width()) / 2;
const auto yShift = (height() - _progress->height()) / 2;
_progress->moveToLeft(xShift, yShift);
}
{
const auto xShift = (height() - _proxyIcon->width()) / 2;
const auto yShift = (height() - _proxyIcon->height()) / 2;
_proxyIcon->moveToRight(xShift, yShift);
}
updateRetryGeometry();
}
void ConnectionState::Widget::updateRetryGeometry() {
if (!_retry) {
return;
}
const auto text = textRect();
const auto available = text.width() - _currentLayout.textWidth;
if (available <= 0) {
_retry->hide();
} else {
_retry->show();
_retry->resize(
std::min(available, _retry->naturalWidth()),
innerRect().height());
_retry->moveToLeft(
text.x() + text.width() - _retry->width(),
st::connectingMargin.top());
}
}
void ConnectionState::Widget::setLayout(const Layout &layout) {
_currentLayout = layout;
_proxyIcon->setToggled(_currentLayout.proxyEnabled);
refreshRetryLink(_currentLayout.hasRetry);
}
void ConnectionState::Widget::setProgressVisibility(bool visible) {
if (_progress->isHidden() == visible) {
_progress->setVisible(visible);
}
}
void ConnectionState::Widget::refreshRetryLink(bool hasRetry) {
if (hasRetry && !_retry) {
_retry = base::make_unique_q<Ui::LinkButton>(
this,
2019-06-19 15:09:03 +00:00
tr::lng_reconnecting_try_now(tr::now),
2019-02-10 16:29:55 +00:00
st::connectingRetryLink);
_retry->addClickHandler([=] {
_account->mtp().restart();
2019-02-10 16:29:55 +00:00
});
updateRetryGeometry();
} else if (!hasRetry) {
_retry = nullptr;
2018-05-07 17:44:33 +00:00
}
}
} // namespace Window