340 lines
8.7 KiB
C++
340 lines
8.7 KiB
C++
/*
|
|
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_lock_widgets.h"
|
|
|
|
#include "lang/lang_keys.h"
|
|
#include "storage/storage_domain.h"
|
|
#include "mainwindow.h"
|
|
#include "core/application.h"
|
|
#include "api/api_text_entities.h"
|
|
#include "ui/text/text.h"
|
|
#include "ui/widgets/buttons.h"
|
|
#include "ui/widgets/checkbox.h"
|
|
#include "ui/widgets/input_fields.h"
|
|
#include "ui/widgets/labels.h"
|
|
#include "ui/wrap/vertical_layout.h"
|
|
#include "ui/toast/toast.h"
|
|
#include "window/window_controller.h"
|
|
#include "window/window_slide_animation.h"
|
|
#include "window/window_session_controller.h"
|
|
#include "main/main_domain.h"
|
|
#include "styles/style_layers.h"
|
|
#include "styles/style_boxes.h"
|
|
|
|
namespace Window {
|
|
|
|
LockWidget::LockWidget(QWidget *parent, not_null<Controller*> window)
|
|
: RpWidget(parent)
|
|
, _window(window) {
|
|
show();
|
|
}
|
|
|
|
LockWidget::~LockWidget() = default;
|
|
|
|
not_null<Controller*> LockWidget::window() const {
|
|
return _window;
|
|
}
|
|
|
|
void LockWidget::setInnerFocus() {
|
|
if (const auto controller = _window->sessionController()) {
|
|
controller->setDialogsListFocused(false);
|
|
}
|
|
setFocus();
|
|
}
|
|
|
|
void LockWidget::showAnimated(QPixmap oldContentCache) {
|
|
_showAnimation = nullptr;
|
|
|
|
showChildren();
|
|
setInnerFocus();
|
|
auto newContentCache = Ui::GrabWidget(this);
|
|
hideChildren();
|
|
|
|
_showAnimation = std::make_unique<Window::SlideAnimation>();
|
|
_showAnimation->setRepaintCallback([=] { update(); });
|
|
_showAnimation->setFinishedCallback([=] { showFinished(); });
|
|
_showAnimation->setPixmaps(oldContentCache, newContentCache);
|
|
_showAnimation->start();
|
|
|
|
show();
|
|
}
|
|
|
|
void LockWidget::showFinished() {
|
|
showChildren();
|
|
_window->widget()->setInnerFocus();
|
|
_showAnimation = nullptr;
|
|
if (const auto controller = _window->sessionController()) {
|
|
controller->clearSectionStack();
|
|
}
|
|
}
|
|
|
|
void LockWidget::paintEvent(QPaintEvent *e) {
|
|
auto p = QPainter(this);
|
|
|
|
if (_showAnimation) {
|
|
_showAnimation->paintContents(p);
|
|
return;
|
|
}
|
|
paintContent(p);
|
|
}
|
|
|
|
void LockWidget::paintContent(QPainter &p) {
|
|
p.fillRect(rect(), st::windowBg);
|
|
}
|
|
|
|
PasscodeLockWidget::PasscodeLockWidget(
|
|
QWidget *parent,
|
|
not_null<Controller*> window)
|
|
: LockWidget(parent, window)
|
|
, _passcode(this, st::passcodeInput, tr::lng_passcode_ph())
|
|
, _submit(this, tr::lng_passcode_submit(), st::passcodeSubmit)
|
|
, _logout(this, tr::lng_passcode_logout(tr::now)) {
|
|
connect(_passcode, &Ui::MaskedInputField::changed, [=] { changed(); });
|
|
connect(_passcode, &Ui::MaskedInputField::submitted, [=] { submit(); });
|
|
|
|
_submit->setTextTransform(Ui::RoundButton::TextTransform::NoTransform);
|
|
_submit->setClickedCallback([=] { submit(); });
|
|
_logout->setClickedCallback([=] {
|
|
window->showLogoutConfirmation();
|
|
});
|
|
}
|
|
|
|
void PasscodeLockWidget::paintContent(QPainter &p) {
|
|
LockWidget::paintContent(p);
|
|
|
|
p.setFont(st::passcodeHeaderFont);
|
|
p.setPen(st::windowFg);
|
|
p.drawText(QRect(0, _passcode->y() - st::passcodeHeaderHeight, width(), st::passcodeHeaderHeight), tr::lng_passcode_enter(tr::now), style::al_center);
|
|
|
|
if (!_error.isEmpty()) {
|
|
p.setFont(st::boxTextFont);
|
|
p.setPen(st::boxTextFgError);
|
|
p.drawText(QRect(0, _passcode->y() + _passcode->height(), width(), st::passcodeSubmitSkip), _error, style::al_center);
|
|
}
|
|
}
|
|
|
|
void PasscodeLockWidget::submit() {
|
|
if (_passcode->text().isEmpty()) {
|
|
_passcode->showError();
|
|
return;
|
|
}
|
|
if (!passcodeCanTry()) {
|
|
_error = tr::lng_flood_error(tr::now);
|
|
_passcode->showError();
|
|
update();
|
|
return;
|
|
}
|
|
|
|
const auto passcode = _passcode->text().toUtf8();
|
|
auto &domain = Core::App().domain();
|
|
const auto correct = domain.started()
|
|
? domain.local().checkPasscode(passcode)
|
|
: (domain.start(passcode) == Storage::StartResult::Success);
|
|
if (!correct) {
|
|
cSetPasscodeBadTries(cPasscodeBadTries() + 1);
|
|
cSetPasscodeLastTry(crl::now());
|
|
error();
|
|
return;
|
|
}
|
|
|
|
Core::App().unlockPasscode(); // Destroys this widget.
|
|
}
|
|
|
|
void PasscodeLockWidget::error() {
|
|
_error = tr::lng_passcode_wrong(tr::now);
|
|
_passcode->selectAll();
|
|
_passcode->showError();
|
|
update();
|
|
}
|
|
|
|
void PasscodeLockWidget::changed() {
|
|
if (!_error.isEmpty()) {
|
|
_error = QString();
|
|
update();
|
|
}
|
|
}
|
|
|
|
void PasscodeLockWidget::resizeEvent(QResizeEvent *e) {
|
|
_passcode->move((width() - _passcode->width()) / 2, (height() / 3));
|
|
_submit->move(_passcode->x(), _passcode->y() + _passcode->height() + st::passcodeSubmitSkip);
|
|
_logout->move(_passcode->x() + (_passcode->width() - _logout->width()) / 2, _submit->y() + _submit->height() + st::linkFont->ascent);
|
|
}
|
|
|
|
void PasscodeLockWidget::setInnerFocus() {
|
|
LockWidget::setInnerFocus();
|
|
_passcode->setFocusFast();
|
|
}
|
|
|
|
TermsLock TermsLock::FromMTP(
|
|
Main::Session *session,
|
|
const MTPDhelp_termsOfService &data) {
|
|
const auto minAge = data.vmin_age_confirm();
|
|
return {
|
|
bytes::make_vector(data.vid().c_dataJSON().vdata().v),
|
|
TextWithEntities {
|
|
qs(data.vtext()),
|
|
Api::EntitiesFromMTP(session, data.ventities().v) },
|
|
(minAge ? std::make_optional(minAge->v) : std::nullopt),
|
|
data.is_popup()
|
|
};
|
|
}
|
|
|
|
TermsBox::TermsBox(
|
|
QWidget*,
|
|
const TermsLock &data,
|
|
rpl::producer<QString> agree,
|
|
rpl::producer<QString> cancel)
|
|
: _data(data)
|
|
, _agree(std::move(agree))
|
|
, _cancel(std::move(cancel)) {
|
|
}
|
|
|
|
TermsBox::TermsBox(
|
|
QWidget*,
|
|
const TextWithEntities &text,
|
|
rpl::producer<QString> agree,
|
|
rpl::producer<QString> cancel,
|
|
bool attentionAgree)
|
|
: _data{ {}, text, std::nullopt, false }
|
|
, _agree(std::move(agree))
|
|
, _cancel(std::move(cancel))
|
|
, _attentionAgree(attentionAgree) {
|
|
}
|
|
|
|
rpl::producer<> TermsBox::agreeClicks() const {
|
|
return _agreeClicks.events();
|
|
}
|
|
|
|
rpl::producer<> TermsBox::cancelClicks() const {
|
|
return _cancelClicks.events();
|
|
}
|
|
|
|
void TermsBox::prepare() {
|
|
setTitle(tr::lng_terms_header());
|
|
|
|
auto check = std::make_unique<Ui::CheckView>(st::defaultCheck, false);
|
|
const auto ageCheck = check.get();
|
|
const auto age = _data.minAge
|
|
? Ui::CreateChild<Ui::PaddingWrap<Ui::Checkbox>>(
|
|
this,
|
|
object_ptr<Ui::Checkbox>(
|
|
this,
|
|
tr::lng_terms_age(tr::now, lt_count, *_data.minAge),
|
|
st::defaultCheckbox,
|
|
std::move(check)),
|
|
st::termsAgePadding)
|
|
: nullptr;
|
|
if (age) {
|
|
age->resizeToNaturalWidth(st::boxWideWidth);
|
|
}
|
|
|
|
const auto content = setInnerWidget(
|
|
object_ptr<Ui::PaddingWrap<Ui::FlatLabel>>(
|
|
this,
|
|
object_ptr<Ui::FlatLabel> (
|
|
this,
|
|
rpl::single(_data.text),
|
|
st::termsContent),
|
|
st::termsPadding),
|
|
0,
|
|
age ? age->height() : 0);
|
|
const auto show = uiShow();
|
|
content->entity()->setClickHandlerFilter([=](
|
|
const ClickHandlerPtr &handler,
|
|
Qt::MouseButton button) {
|
|
const auto link = handler
|
|
? handler->copyToClipboardText()
|
|
: QString();
|
|
if (TextUtilities::RegExpMention().match(link).hasMatch()) {
|
|
_lastClickedMention = link;
|
|
show->showToast(
|
|
tr::lng_terms_agree_to_proceed(tr::now, lt_bot, link));
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
const auto errorAnimationCallback = [=] {
|
|
const auto check = ageCheck;
|
|
const auto error = _ageErrorAnimation.value(
|
|
_ageErrorShown ? 1. : 0.);
|
|
if (error == 0.) {
|
|
check->setUntoggledOverride(std::nullopt);
|
|
} else {
|
|
const auto color = anim::color(
|
|
st::defaultCheck.untoggledFg,
|
|
st::boxTextFgError,
|
|
error);
|
|
check->setUntoggledOverride(color);
|
|
}
|
|
};
|
|
const auto toggleAgeError = [=](bool shown) {
|
|
if (_ageErrorShown != shown) {
|
|
_ageErrorShown = shown;
|
|
_ageErrorAnimation.start(
|
|
[=] { errorAnimationCallback(); },
|
|
_ageErrorShown ? 0. : 1.,
|
|
_ageErrorShown ? 1. : 0.,
|
|
st::defaultCheck.duration);
|
|
}
|
|
};
|
|
|
|
const auto &agreeStyle = _attentionAgree
|
|
? st::attentionBoxButton
|
|
: st::defaultBoxButton;
|
|
addButton(std::move(_agree), [=] {}, agreeStyle)->clicks(
|
|
) | rpl::filter([=] {
|
|
if (age && !age->entity()->checked()) {
|
|
toggleAgeError(true);
|
|
return false;
|
|
}
|
|
return true;
|
|
}) | rpl::to_empty | rpl::start_to_stream(_agreeClicks, lifetime());
|
|
|
|
if (_cancel) {
|
|
addButton(std::move(_cancel), [] {})->clicks(
|
|
) | rpl::to_empty | rpl::start_to_stream(_cancelClicks, lifetime());
|
|
}
|
|
|
|
if (age) {
|
|
age->entity()->checkedChanges(
|
|
) | rpl::start_with_next([=] {
|
|
toggleAgeError(false);
|
|
}, age->lifetime());
|
|
|
|
heightValue(
|
|
) | rpl::start_with_next([=](int height) {
|
|
age->moveToLeft(0, height - age->height());
|
|
}, age->lifetime());
|
|
}
|
|
|
|
content->resizeToWidth(st::boxWideWidth);
|
|
|
|
using namespace rpl::mappers;
|
|
rpl::combine(
|
|
content->heightValue(),
|
|
age ? age->heightValue() : rpl::single(0),
|
|
_1 + _2
|
|
) | rpl::start_with_next([=](int height) {
|
|
setDimensions(st::boxWideWidth, height);
|
|
}, content->lifetime());
|
|
}
|
|
|
|
void TermsBox::keyPressEvent(QKeyEvent *e) {
|
|
if (e->key() == Qt::Key_Enter || e->key() == Qt::Key_Return) {
|
|
_agreeClicks.fire({});
|
|
} else {
|
|
BoxContent::keyPressEvent(e);
|
|
}
|
|
}
|
|
|
|
QString TermsBox::lastClickedMention() const {
|
|
return _lastClickedMention;
|
|
}
|
|
|
|
} // namespace Window
|