tdesktop/Telegram/SourceFiles/window/window_lock_widgets.cpp

341 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/fields/password_input.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