From 7a573bf8099ba2d35eb39a9a0d89e5c91d5d0f5e Mon Sep 17 00:00:00 2001 From: 23rd <23rd@vivaldi.net> Date: Mon, 26 Jan 2026 09:29:25 +0300 Subject: [PATCH] Added initial api support of url auth login with details. --- Telegram/Resources/langs/lang.strings | 11 + Telegram/SourceFiles/api/api_bot.cpp | 2 +- Telegram/SourceFiles/boxes/boxes.style | 5 + Telegram/SourceFiles/boxes/url_auth_box.cpp | 584 ++++++++++++++++-- Telegram/SourceFiles/boxes/url_auth_box.h | 74 +-- Telegram/SourceFiles/core/ui_integration.cpp | 8 +- .../SourceFiles/window/window_setup_email.cpp | 1 + 7 files changed, 569 insertions(+), 116 deletions(-) diff --git a/Telegram/Resources/langs/lang.strings b/Telegram/Resources/langs/lang.strings index 270755cfea..7ef7357a68 100644 --- a/Telegram/Resources/langs/lang.strings +++ b/Telegram/Resources/langs/lang.strings @@ -4648,6 +4648,17 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL "lng_url_auth_open_confirm" = "Do you want to open {link}?"; "lng_url_auth_login_option" = "Log in to {domain} as {user}"; "lng_url_auth_allow_messages" = "Allow {bot} to send me messages"; +"lng_url_auth_login_title" = "Log in to {domain}"; +"lng_url_auth_login_button" = "Log in"; +"lng_url_auth_site_access" = "This site will receive your **name**, **username** and **profile photo**."; +"lng_url_auth_device_label" = "Device"; +"lng_url_auth_ip_label" = "IP Address"; +"lng_url_auth_login_attempt" = "This login attempt came from the device above."; +"lng_url_auth_allow_messages_label" = "Allow Messages"; +"lng_url_auth_allow_messages_about" = "This will allow {bot} to message you"; +"lng_url_auth_phone_sure_title" = "Phone Number"; +"lng_url_auth_phone_sure_text" = "{domain} wants to access your phone number **{phone}**.\n\nAllow access?"; +"lng_url_auth_phone_sure_deny" = "Deny"; "lng_bot_start" = "Start"; "lng_bot_choose_group" = "Select a Group"; diff --git a/Telegram/SourceFiles/api/api_bot.cpp b/Telegram/SourceFiles/api/api_bot.cpp index 8a2a3cc090..af159e3486 100644 --- a/Telegram/SourceFiles/api/api_bot.cpp +++ b/Telegram/SourceFiles/api/api_bot.cpp @@ -482,7 +482,7 @@ void ActivateBotCommand(ClickHandlerContext context, int row, int column) { } break; case ButtonType::Auth: - UrlAuthBox::Activate(item, row, column); + UrlAuthBox::ActivateButton(controller->uiShow(), item, row, column); break; case ButtonType::UserProfile: { diff --git a/Telegram/SourceFiles/boxes/boxes.style b/Telegram/SourceFiles/boxes/boxes.style index f12f528fe4..2202cc12c4 100644 --- a/Telegram/SourceFiles/boxes/boxes.style +++ b/Telegram/SourceFiles/boxes/boxes.style @@ -809,6 +809,11 @@ backgroundConfirmCancel: RoundButton(backgroundConfirm) { urlAuthCheckbox: Checkbox(defaultBoxCheckbox) { width: 240px; } +urlAuthCheckboxAbout: FlatLabel(defaultPeerListAbout) { + style: TextStyle(boxTextStyle) { + font: font(12px); + } +} addContactFieldMargin: margins(19px, 0px, 19px, 10px); addContactWarningMargin: margins(19px, 10px, 19px, 5px); diff --git a/Telegram/SourceFiles/boxes/url_auth_box.cpp b/Telegram/SourceFiles/boxes/url_auth_box.cpp index c311d9c825..4e835d77dc 100644 --- a/Telegram/SourceFiles/boxes/url_auth_box.cpp +++ b/Telegram/SourceFiles/boxes/url_auth_box.cpp @@ -7,24 +7,315 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL */ #include "boxes/url_auth_box.h" -#include "boxes/abstract_box.h" -#include "history/history.h" -#include "history/history_item.h" -#include "history/history_item_components.h" +#include "apiwrap.h" +#include "base/qthelp_url.h" +#include "core/application.h" +#include "core/click_handler_types.h" +#include "data/data_peer.h" #include "data/data_session.h" #include "data/data_user.h" -#include "core/click_handler_types.h" +#include "history/history_item_components.h" +#include "history/history_item.h" +#include "history/history.h" +#include "info/profile/info_profile_values.h" +#include "lang/lang_keys.h" +#include "main/main_account.h" +#include "main/main_domain.h" +#include "main/main_session.h" +#include "send_credits_box.h" +#include "ui/boxes/confirm_box.h" +#include "ui/controls/userpic_button.h" +#include "ui/layers/generic_box.h" #include "ui/text/text_utilities.h" -#include "ui/wrap/vertical_layout.h" +#include "ui/userpic_view.h" +#include "ui/vertical_list.h" #include "ui/widgets/checkbox.h" #include "ui/widgets/labels.h" -#include "lang/lang_keys.h" -#include "main/main_session.h" -#include "apiwrap.h" +#include "ui/widgets/menu/menu_action.h" +#include "ui/widgets/popup_menu.h" +#include "ui/wrap/vertical_layout.h" #include "styles/style_layers.h" #include "styles/style_boxes.h" +#include "styles/style_settings.h" +#include "styles/style_premium.h" +#include "styles/style_window.h" +#include "styles/style_menu_icons.h" -void UrlAuthBox::Activate( +namespace UrlAuthBox { +namespace { + +class SwitchableUserpicButton final : public Ui::RippleButton { +public: + SwitchableUserpicButton( + not_null parent, + not_null peer, + int size); + + void setExpanded(bool expanded); + [[nodiscard]] bool isExpanded() const { + return _expanded; + } + + void setUser(not_null user); + [[nodiscard]] not_null user() const { + return _user; + } + +private: + void paintEvent(QPaintEvent *e) override; + QImage prepareRippleMask() const override; + QPoint prepareRippleStartPosition() const override; + + const int _size; + const int _userpicSize; + const int _skip; + bool _expanded = false; + not_null _user; + base::unique_qptr _userpic; + +}; + +SwitchableUserpicButton::SwitchableUserpicButton( + not_null parent, + not_null peer, + int size) +: RippleButton(parent, st::defaultRippleAnimation) +, _size(size) +, _userpicSize(st::restoreUserpicIcon.photoSize) +, _skip((_size - _userpicSize) / 2) +, _user(peer) +, _userpic(base::make_unique_q( + this, + peer, + st::restoreUserpicIcon)) { + resize(_size, _size); + _userpic->move(_skip, _skip); + _userpic->setAttribute(Qt::WA_TransparentForMouseEvents); +} + +void SwitchableUserpicButton::setUser(not_null user) { + if (_user == user) { + return; + } + _user = user; + _userpic = base::make_unique_q( + this, + user, + st::restoreUserpicIcon); + _userpic->moveToRight(_skip, _skip); + _userpic->setAttribute(Qt::WA_TransparentForMouseEvents); + _userpic->show(); + update(); +} + +void SwitchableUserpicButton::setExpanded(bool expanded) { + if (_expanded == expanded) { + return; + } + _expanded = expanded; + const auto w = _expanded + ? (_size * 2.5 - _userpicSize) + : _size; + resize(w, _size); + _userpic->moveToRight(_skip, _skip); + update(); +} + +void SwitchableUserpicButton::paintEvent(QPaintEvent *e) { + auto p = QPainter(this); + paintRipple(p, 0, 0); + + if (!_expanded) { + return; + } + + const auto arrowSize = st::lineWidth * 12; + const auto center = QPoint(_size / 2, height() / 2 + st::lineWidth * 4); + + auto pen = QPen(st::windowSubTextFg); + pen.setWidthF(st::lineWidth * 1.5); + p.setPen(pen); + p.setRenderHint(QPainter::Antialiasing); + + p.drawLine(center, center + QPoint(-arrowSize / 2, -arrowSize / 2)); + p.drawLine(center, center + QPoint(arrowSize / 2, -arrowSize / 2)); +} + +QImage SwitchableUserpicButton::prepareRippleMask() const { + return _expanded + ? Ui::RippleAnimation::RoundRectMask(size(), height() / 2) + : Ui::RippleAnimation::EllipseMask(size()); +} + +QPoint SwitchableUserpicButton::prepareRippleStartPosition() const { + return mapFromGlobal(QCursor::pos()); +} + +using AnotherSessionFactory = Fn()>; + +struct SwitchAccountResult { + not_null widget; + AnotherSessionFactory anotherSession; +}; + +[[nodiscard]] SwitchAccountResult AddAccountsMenu( + not_null parent) { + const auto session = &Core::App().domain().active().session(); + const auto widget = Ui::CreateChild( + parent, + session->user(), + st::restoreUserpicIcon.photoSize + st::lineWidth * 8); + const auto isCurrentTest = session->isTestMode(); + const auto filtered = [=] { + auto result = std::vector>(); + for (const auto &account : Core::App().domain().orderedAccounts()) { + if (!account->sessionExists() + || (account->session().user() == widget->user()) + || (account->session().isTestMode() != isCurrentTest)) { + continue; + } + result.push_back(&account->session()); + } + return result; + }; + const auto isSingle = filtered().empty(); + widget->setExpanded(!isSingle); + widget->setAttribute(Qt::WA_TransparentForMouseEvents, isSingle); + struct State { + base::unique_qptr menu; + }; + const auto state = widget->lifetime().make_state(); + widget->setClickedCallback([=] { + const auto &st = st::popupMenuWithIcons; + state->menu = base::make_unique_q(widget, st); + for (const auto &anotherSession : filtered()) { + const auto user = anotherSession->user(); + const auto action = new QAction(user->name(), state->menu); + QObject::connect(action, &QAction::triggered, [=] { + widget->setUser(user); + }); + auto owned = base::make_unique_q( + state->menu->menu(), + state->menu->menu()->st(), + action, + nullptr, + nullptr); + const auto userpic = Ui::CreateChild( + owned.get(), + user, + st::lockSetupEmailUserpicSmall); + userpic->setAttribute(Qt::WA_TransparentForMouseEvents); + userpic->move(st.menu.itemIconPosition); + state->menu->addAction(std::move(owned)); + } + + state->menu->setForcedOrigin(Ui::PanelAnimation::Origin::TopRight); + state->menu->popup( + widget->mapToGlobal( + QPoint( + widget->width() + st.shadow.extend.right(), + widget->height()))); + }); + return { + widget, + [=] { return &widget->user()->session(); }, + }; +} + +void AddAuthInfoRow( + not_null container, + const QString &topText, + const QString &bottomText, + const QString &leftText, + const style::icon &icon) { + const auto row = container->add( + object_ptr(container), + st::boxRowPadding); + + const auto topLabel = Ui::CreateChild( + row, + topText, + st::boxLabel); + const auto bottomLabel = Ui::CreateChild( + row, + bottomText, + st::sessionValueLabel); + const auto leftLabel = Ui::CreateChild( + row, + leftText, + st::boxLabel); + + rpl::combine( + row->widthValue(), + topLabel->sizeValue(), + bottomLabel->sizeValue() + ) | rpl::on_next([=](int rowWidth, QSize topSize, QSize bottomSize) { + const auto totalHeight = topSize.height() + bottomSize.height(); + row->resize(rowWidth, totalHeight); + + topLabel->moveToRight(0, 0); + bottomLabel->moveToRight(0, topSize.height()); + + const auto left = st::sessionValuePadding.left(); + leftLabel->moveToLeft(left, (totalHeight - leftLabel->height()) / 2); + }, row->lifetime()); + + { + const auto widget = Ui::CreateChild(row); + widget->resize(icon.size()); + + rpl::combine( + row->widthValue(), + topLabel->sizeValue(), + bottomLabel->sizeValue() + ) | rpl::on_next([=](int rowWidth, QSize topSize, QSize bottomSize) { + const auto totalHeight = topSize.height() + bottomSize.height(); + widget->moveToLeft(0, (totalHeight - leftLabel->height()) / 2); + }, row->lifetime()); + + widget->paintRequest() | rpl::on_next([=, &icon] { + auto p = QPainter(widget); + icon.paintInCenter(p, widget->rect()); + }, widget->lifetime()); + } +} + +} // namespace + +void RequestButton( + std::shared_ptr show, + const MTPDurlAuthResultRequest &request, + not_null message, + int row, + int column); +void RequestUrl( + std::shared_ptr show, + const MTPDurlAuthResultRequest &request, + not_null session, + const QString &url, + QVariant context); + +void Show( + not_null box, + not_null session, + const QString &url, + const QString &domain, + UserData *bot, + Fn callback); +void ShowDetails( + not_null box, + not_null session, + const QString &url, + const QString &domain, + Fn callback, + UserData *bot, + const QString &browser, + const QString &platform, + const QString &ip, + const QString ®ion); + +void ActivateButton( + std::shared_ptr show, not_null message, int row, int column) { @@ -68,7 +359,7 @@ void UrlAuthBox::Activate( HiddenUrlClickHandler::Open(url); }, [&](const MTPDurlAuthResultRequest &data) { if (const auto item = session->data().message(itemId)) { - Request(data, item, row, column); + RequestButton(show, data, item, row, column); } }); }).fail([=] { @@ -77,14 +368,17 @@ void UrlAuthBox::Activate( itemId, row, column); - if (!button) return; + if (!button) { + return; + } button->requestId = 0; HiddenUrlClickHandler::Open(url); }).send(); } -void UrlAuthBox::Activate( +void ActivateUrl( + std::shared_ptr show, not_null session, const QString &url, QVariant context) { @@ -107,14 +401,15 @@ void UrlAuthBox::Activate( }, [&](const MTPDurlAuthResultDefault &data) { HiddenUrlClickHandler::Open(url, context); }, [&](const MTPDurlAuthResultRequest &data) { - Request(data, session, url, context); + RequestUrl(show, data, session, url, context); }); }).fail([=] { HiddenUrlClickHandler::Open(url, context); }).send(); } -void UrlAuthBox::Request( +void RequestButton( + std::shared_ptr show, const MTPDurlAuthResultRequest &request, not_null message, int row, @@ -125,7 +420,7 @@ void UrlAuthBox::Request( itemId, row, column); - if (button->requestId || !message->isRegular()) { + if (!button || button->requestId || !message->isRegular()) { return; } const auto session = &message->history()->session(); @@ -144,12 +439,13 @@ void UrlAuthBox::Request( UrlClickHandler::Open(url); }; const auto callback = [=](Result result) { - if (result == Result::None) { + if (!result.auth) { finishWithUrl(url); } else if (session->data().message(itemId)) { - const auto allowWrite = (result == Result::AuthAndAllowWrite); using Flag = MTPmessages_AcceptUrlAuth::Flag; - const auto flags = (allowWrite ? Flag::f_write_allowed : Flag(0)) + const auto flags = Flag(0) + | (result.allowWrite ? Flag::f_write_allowed : Flag(0)) + | (result.sharePhone ? Flag::f_share_phone_number : Flag(0)) | (Flag::f_peer | Flag::f_msg_id | Flag::f_button_id); session->api().request(MTPmessages_AcceptUrlAuth( MTP_flags(flags), @@ -174,12 +470,13 @@ void UrlAuthBox::Request( }).send(); } }; - *box = Ui::show( - Box(session, url, qs(request.vdomain()), bot, callback), + *box = show->show( + Box(Show, session, url, qs(request.vdomain()), bot, callback), Ui::LayerOption::KeepOther); } -void UrlAuthBox::Request( +void RequestUrl( + std::shared_ptr show, const MTPDurlAuthResultRequest &request, not_null session, const QString &url, @@ -194,15 +491,20 @@ void UrlAuthBox::Request( } UrlClickHandler::Open(url, context); }; - const auto callback = [=](Result result) { - if (result == Result::None) { + const auto anotherSessionFactory + = std::make_shared(nullptr); + const auto sendRequest = [=](Result result) { + if (!result.auth) { finishWithUrl(url); } else { - const auto allowWrite = (result == Result::AuthAndAllowWrite); using Flag = MTPmessages_AcceptUrlAuth::Flag; - const auto flags = (allowWrite ? Flag::f_write_allowed : Flag(0)) - | Flag::f_url; - session->api().request(MTPmessages_AcceptUrlAuth( + const auto flags = Flag::f_url + | (result.allowWrite ? Flag::f_write_allowed : Flag(0)) + | (result.sharePhone ? Flag::f_share_phone_number : Flag(0)); + const auto currentSession = anotherSessionFactory + ? (*anotherSessionFactory)() + : session; + currentSession->api().request(MTPmessages_AcceptUrlAuth( MTP_flags(flags), MTPInputPeer(), MTPint(), // msg_id @@ -225,44 +527,91 @@ void UrlAuthBox::Request( }).send(); } }; - *box = Ui::show( - Box(session, url, qs(request.vdomain()), bot, callback), - Ui::LayerOption::KeepOther); + const auto requestPhone = request.is_request_phone_number(); + const auto domain = qs(request.vdomain()); + const auto browser = qs(request.vbrowser().value_or("Unknown browser")); + const auto device = qs(request.vplatform().value_or("Unknown platform")); + const auto ip = qs(request.vip().value_or("Unknown IP")); + const auto region = qs(request.vregion().value_or("Unknown region")); + *box = show->show(Box([=](not_null box) { + const auto callback = [=](Result result) { + if (!requestPhone) { + return sendRequest(result); + } + box->uiShow()->show(Box([=](not_null box) { + box->setTitle(tr::lng_url_auth_phone_sure_title()); + const auto confirm = [=](bool confirmed) { + return [=](Fn close) { + auto copy = result; + copy.sharePhone = confirmed; + sendRequest(copy); + close(); + }; + }; + const auto currentSession = anotherSessionFactory + ? (*anotherSessionFactory)() + : session; + const auto capitalized = [=](const QString &value) { + return value.left(1).toUpper() + value.mid(1).toLower(); + }; + using namespace Info::Profile; + Ui::ConfirmBox( + box, + Ui::ConfirmBoxArgs{ + .text = tr::lng_url_auth_phone_sure_text( + lt_domain, + rpl::single(tr::bold(capitalized(domain))), + lt_phone, + PhoneValue(currentSession->user()), + tr::rich), + .confirmed = confirm(true), + .cancelled = confirm(false), + .confirmText = tr::lng_allow_bot(), + .cancelText = tr::lng_url_auth_phone_sure_deny(), + }); + })); + }; + ShowDetails( + box, + session, + url, + domain, + callback, + bot, + browser, + device, + ip, + region); + + const auto content = box->verticalLayout(); + const auto accountResult = AddAccountsMenu(content); + content->widthValue() | rpl::on_next([=, w = accountResult.widget] { + w->moveToRight(st::lineWidth * 4, 0); + }, accountResult.widget->lifetime()); + *anotherSessionFactory = accountResult.anotherSession; + })); } -UrlAuthBox::UrlAuthBox( - QWidget*, - not_null session, - const QString &url, - const QString &domain, - UserData *bot, - Fn callback) -: _content(setupContent(session, url, domain, bot, std::move(callback))) { -} - -void UrlAuthBox::prepare() { - setDimensionsToContent(st::boxWidth, _content); - addButton(tr::lng_open_link(), [=] { _callback(); }); - addButton(tr::lng_cancel(), [=] { closeBox(); }); -} - -not_null UrlAuthBox::setupContent( +void Show( + not_null box, not_null session, const QString &url, const QString &domain, UserData *bot, Fn callback) { - const auto result = Ui::CreateChild(this); - result->add( + box->setWidth(st::boxWidth); + + box->addRow( object_ptr( - result, + box, tr::lng_url_auth_open_confirm(tr::now, lt_link, url), st::boxLabel), st::boxPadding); + const auto addCheckbox = [&](const TextWithEntities &text) { - const auto checkbox = result->add( + const auto checkbox = box->addRow( object_ptr( - result, + box, text, true, st::urlAuthCheckbox), @@ -274,6 +623,7 @@ not_null UrlAuthBox::setupContent( checkbox->setAllowTextLines(); return checkbox; }; + const auto auth = addCheckbox( tr::lng_url_auth_login_option( tr::now, @@ -282,6 +632,7 @@ not_null UrlAuthBox::setupContent( lt_user, tr::bold(session->user()->name()), tr::marked)); + const auto allow = bot ? addCheckbox(tr::lng_url_auth_allow_messages( tr::now, @@ -289,6 +640,7 @@ not_null UrlAuthBox::setupContent( tr::bold(bot->firstName), tr::marked)) : nullptr; + if (allow) { rpl::single( auth->checked() @@ -301,15 +653,123 @@ not_null UrlAuthBox::setupContent( allow->setDisabled(!checked); }, auth->lifetime()); } - _callback = [=, callback = std::move(callback)]() { + + box->addButton(tr::lng_open_link(), [=] { const auto authed = auth->checked(); const auto allowed = (authed && allow && allow->checked()); - const auto onstack = callback; - onstack(allowed - ? Result::AuthAndAllowWrite - : authed - ? Result::Auth - : Result::None); - }; - return result; + callback({ + .auth = authed, + .allowWrite = allowed, + }); + }); + box->addButton(tr::lng_cancel(), [=] { box->closeBox(); }); } + +void ShowDetails( + not_null box, + not_null session, + const QString &url, + const QString &domain, + Fn callback, + UserData *bot, + const QString &browser, + const QString &platform, + const QString &ip, + const QString ®ion) { + box->setWidth(st::boxWidth); + + const auto content = box->verticalLayout(); + + Ui::AddSkip(content); + Ui::AddSkip(content); + if (bot) { + const auto userpic = content->add( + object_ptr( + content, + bot, + st::defaultUserpicButton, + Ui::PeerUserpicShape::Forum), + st::boxRowPadding, + style::al_top); + userpic->setAttribute(Qt::WA_TransparentForMouseEvents); + Ui::AddSkip(content); + Ui::AddSkip(content); + } + + const auto domainUrl = qthelp::validate_url(domain); + content->add( + object_ptr( + content, + domainUrl.isEmpty() + ? tr::lng_url_auth_login_button(tr::marked) + : tr::lng_url_auth_login_title( + lt_domain, + rpl::single(Ui::Text::Link(domain, domainUrl)), + tr::marked), + st::boxTitle), + st::boxRowPadding, + style::al_top); + Ui::AddSkip(content); + + content->add( + object_ptr( + content, + tr::lng_url_auth_site_access(tr::rich), + st::urlAuthCheckboxAbout), + st::boxRowPadding); + + Ui::AddSkip(content); + Ui::AddSkip(content); + if (!platform.isEmpty() || !browser.isEmpty()) { + AddAuthInfoRow( + content, + platform, + browser, + tr::lng_url_auth_device_label(tr::now), + st::menuIconDevices); + } + Ui::AddSkip(content); + Ui::AddSkip(content); + + if (!ip.isEmpty() || !region.isEmpty()) { + AddAuthInfoRow( + content, + ip, + region, + tr::lng_url_auth_ip_label(tr::now), + st::menuIconAddress); + } + Ui::AddSkip(content); + Ui::AddSkip(content); + + Ui::AddDividerText( + content, + rpl::single(tr::lng_url_auth_login_attempt(tr::now))); + Ui::AddSkip(content); + + auto allowMessages = (Ui::SettingsButton*)(nullptr); + if (bot) { + allowMessages = content->add( + object_ptr( + content, + tr::lng_url_auth_allow_messages_label())); + allowMessages->toggleOn(rpl::single(false)); + Ui::AddSkip(content); + Ui::AddDividerText( + content, + tr::lng_url_auth_allow_messages_about( + lt_bot, + Info::Profile::NameValue(bot))); + Ui::AddSkip(content); + } + + box->addButton(tr::lng_url_auth_login_button(), [=] { + callback({ + .auth = true, + .allowWrite = (allowMessages && allowMessages->toggled()), + }); + }); + box->addButton(tr::lng_cancel(), [=] { box->closeBox(); }); +} + +} // namespace UrlAuthBox diff --git a/Telegram/SourceFiles/boxes/url_auth_box.h b/Telegram/SourceFiles/boxes/url_auth_box.h index f48af20826..23b45249ae 100644 --- a/Telegram/SourceFiles/boxes/url_auth_box.h +++ b/Telegram/SourceFiles/boxes/url_auth_box.h @@ -7,8 +7,6 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL */ #pragma once -#include "ui/layers/box_content.h" - class HistoryItem; struct HistoryMessageMarkupButton; @@ -16,56 +14,28 @@ namespace Main { class Session; } // namespace Main -class UrlAuthBox : public Ui::BoxContent { -public: - static void Activate( - not_null message, - int row, - int column); - static void Activate( - not_null session, - const QString &url, - QVariant context); +namespace Ui { +class GenericBox; +class Show; +} // namespace Ui -protected: - void prepare() override; - -private: - static void Request( - const MTPDurlAuthResultRequest &request, - not_null message, - int row, - int column); - static void Request( - const MTPDurlAuthResultRequest &request, - not_null session, - const QString &url, - QVariant context); - - enum class Result { - None, - Auth, - AuthAndAllowWrite, - }; - -public: - UrlAuthBox( - QWidget*, - not_null session, - const QString &url, - const QString &domain, - UserData *bot, - Fn callback); - -private: - not_null setupContent( - not_null session, - const QString &url, - const QString &domain, - UserData *bot, - Fn callback); - - Fn _callback; - not_null _content; +namespace UrlAuthBox { +struct Result { + bool auth : 1 = false; + bool allowWrite : 1 = false; + bool sharePhone : 1 = false; }; + +void ActivateButton( + std::shared_ptr show, + not_null message, + int row, + int column); +void ActivateUrl( + std::shared_ptr show, + not_null session, + const QString &url, + QVariant context); + +} // namespace UrlAuthBox diff --git a/Telegram/SourceFiles/core/ui_integration.cpp b/Telegram/SourceFiles/core/ui_integration.cpp index 715ff47054..9cdaaa3b39 100644 --- a/Telegram/SourceFiles/core/ui_integration.cpp +++ b/Telegram/SourceFiles/core/ui_integration.cpp @@ -85,18 +85,24 @@ const auto kBadPrefix = u"http://"_q; QVariant context) { auto &account = Core::App().activeAccount(); const auto &config = account.appConfig(); + const auto my = context.value(); + const auto window = my.sessionWindow.get(); + const auto show = window + ? window->uiShow() + : my.show; const auto domains = config.get>( "url_auth_domains", {}); if (!account.sessionExists() || domain.isEmpty() + || !show || !ranges::contains(domains, domain)) { return false; } const auto good = url.startsWith(kBadPrefix, Qt::CaseInsensitive) ? (kGoodPrefix + url.mid(kBadPrefix.size())) : url; - UrlAuthBox::Activate(&account.session(), good, context); + UrlAuthBox::ActivateUrl(show, &account.session(), good, context); return true; } diff --git a/Telegram/SourceFiles/window/window_setup_email.cpp b/Telegram/SourceFiles/window/window_setup_email.cpp index 5307689252..f7f7b2ec84 100644 --- a/Telegram/SourceFiles/window/window_setup_email.cpp +++ b/Telegram/SourceFiles/window/window_setup_email.cpp @@ -657,6 +657,7 @@ void SetupEmailLockWidget::showAccountsMenu() { user, st::lockSetupEmailUserpicSmall); userpic->move(st.menu.itemIconPosition); + userpic->setAttribute(Qt::WA_TransparentForMouseEvents); _accountsMenu->addAction(std::move(owned)); }