tdesktop/Telegram/SourceFiles/facades.cpp

304 lines
7.6 KiB
C++
Raw Normal View History

2015-12-07 13:05:00 +00:00
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
2015-12-07 13:05:00 +00:00
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
2015-12-07 13:05:00 +00:00
*/
2017-09-13 16:57:44 +00:00
#include "facades.h"
#include "api/api_bot.h"
#include "info/info_memento.h"
#include "core/click_handler_types.h"
#include "core/application.h"
#include "media/clip/media_clip_reader.h"
#include "window/window_session_controller.h"
#include "window/window_peer_menu.h"
#include "history/history_item_components.h"
2019-09-17 16:13:12 +00:00
#include "base/platform/base_platform_info.h"
#include "data/data_peer.h"
#include "data/data_user.h"
#include "mainwindow.h"
2015-12-07 13:05:00 +00:00
#include "mainwidget.h"
#include "apiwrap.h"
2019-07-24 11:45:24 +00:00
#include "main/main_session.h"
2020-06-26 11:48:28 +00:00
#include "main/main_domain.h"
2021-10-18 21:36:55 +00:00
#include "ui/boxes/confirm_box.h"
2019-05-22 14:29:02 +00:00
#include "boxes/url_auth_box.h"
2019-09-18 11:19:05 +00:00
#include "ui/layers/layer_widget.h"
2017-04-13 08:27:10 +00:00
#include "lang/lang_keys.h"
2017-04-06 14:38:10 +00:00
#include "base/observer.h"
#include "history/history.h"
#include "history/history_item.h"
#include "history/view/media/history_view_media.h"
2021-03-23 12:34:34 +00:00
#include "payments/payments_checkout_process.h"
#include "data/data_session.h"
2020-10-10 09:15:37 +00:00
#include "styles/style_chat.h"
2020-06-26 11:48:28 +00:00
namespace {
[[nodiscard]] MainWidget *CheckMainWidget(not_null<Main::Session*> session) {
if (const auto m = App::main()) { // multi good
if (&m->session() == session) {
return m;
}
}
if (&Core::App().domain().active() != &session->account()) {
Core::App().domain().activate(&session->account());
}
if (const auto m = App::main()) { // multi good
if (&m->session() == session) {
return m;
}
}
return nullptr;
}
} // namespace
2015-12-07 13:05:00 +00:00
namespace App {
2020-06-10 18:08:17 +00:00
void hideSingleUseKeyboard(not_null<const HistoryItem*> message) {
2020-06-26 11:48:28 +00:00
if (const auto m = CheckMainWidget(&message->history()->session())) {
m->hideSingleUseKeyboard(message->history()->peer, message->id);
}
}
bool insertBotCommand(const QString &cmd) {
2020-06-10 18:08:17 +00:00
if (const auto m = App::main()) { // multi good
return m->insertBotCommand(cmd);
2016-04-14 19:24:42 +00:00
}
return false;
}
2015-12-07 13:05:00 +00:00
void activateBotCommand(
2021-07-26 23:45:01 +00:00
Window::SessionController *sessionController,
not_null<const HistoryItem*> msg,
int row,
int column) {
2020-06-08 15:17:33 +00:00
const auto button = HistoryMessageMarkupButton::Get(
&msg->history()->owner(),
msg->fullId(),
row,
column);
if (!button) {
return;
}
using ButtonType = HistoryMessageMarkupButton::Type;
switch (button->type) {
case ButtonType::Default: {
// Copy string before passing it to the sending method
// because the original button can be destroyed inside.
2021-07-26 23:45:01 +00:00
if (sessionController) {
MsgId replyTo = msg->isRegular() ? msg->id : 0;
2021-07-26 23:45:01 +00:00
sessionController->content()->sendBotCommand({
.peer = msg->history()->peer,
.command = QString(button->text),
.context = msg->fullId(),
.replyTo = replyTo,
});
}
} break;
case ButtonType::Callback:
case ButtonType::Game: {
Api::SendBotCallbackData(
const_cast<HistoryItem*>(msg.get()),
row,
column);
} break;
case ButtonType::CallbackWithPassword: {
Api::SendBotCallbackDataWithPassword(
const_cast<HistoryItem*>(msg.get()),
row,
column);
} break;
case ButtonType::Buy: {
2021-03-31 05:56:45 +00:00
Payments::CheckoutProcess::Start(
msg,
Payments::Mode::Payment,
crl::guard(App::wnd(), [] { App::wnd()->activate(); }));
} break;
case ButtonType::Url: {
auto url = QString::fromUtf8(button->data);
auto skipConfirmation = false;
2020-06-10 18:08:17 +00:00
if (const auto bot = msg->getMessageBot()) {
if (bot->isVerified()) {
skipConfirmation = true;
}
}
if (skipConfirmation) {
UrlClickHandler::Open(url);
} else {
HiddenUrlClickHandler::Open(url);
}
} break;
case ButtonType::RequestLocation: {
hideSingleUseKeyboard(msg);
2021-10-18 22:28:08 +00:00
Ui::show(Box<Ui::InformBox>(
2020-06-08 15:17:33 +00:00
tr::lng_bot_share_location_unavailable(tr::now)));
} break;
case ButtonType::RequestPhone: {
hideSingleUseKeyboard(msg);
const auto msgId = msg->id;
const auto history = msg->history();
2021-10-18 22:28:08 +00:00
Ui::show(Box<Ui::ConfirmBox>(
tr::lng_bot_share_phone(tr::now),
tr::lng_bot_share_phone_confirm(tr::now),
[=] {
Ui::showPeerHistory(history, ShowAtTheEndMsgId);
auto action = Api::SendAction(history);
action.clearDraft = false;
action.replyTo = msgId;
history->session().api().shareContact(
history->session().user(),
action);
}));
} break;
case ButtonType::RequestPoll: {
hideSingleUseKeyboard(msg);
auto chosen = PollData::Flags();
auto disabled = PollData::Flags();
if (!button->data.isEmpty()) {
disabled |= PollData::Flag::Quiz;
if (button->data[0]) {
chosen |= PollData::Flag::Quiz;
}
}
2020-06-26 11:48:28 +00:00
if (const auto m = CheckMainWidget(&msg->history()->session())) {
2020-11-11 20:47:40 +00:00
const auto replyToId = MsgId(0);
Window::PeerMenuCreatePoll(
m->controller(),
msg->history()->peer,
replyToId,
chosen,
disabled);
2020-06-10 18:08:17 +00:00
}
} break;
case ButtonType::SwitchInlineSame:
case ButtonType::SwitchInline: {
2020-06-10 18:08:17 +00:00
const auto session = &msg->history()->session();
2020-06-26 11:48:28 +00:00
if (const auto m = CheckMainWidget(session)) {
if (const auto bot = msg->getMessageBot()) {
const auto fastSwitchDone = [&] {
auto samePeer = (button->type == ButtonType::SwitchInlineSame);
if (samePeer) {
Notify::switchInlineBotButtonReceived(session, QString::fromUtf8(button->data), bot, msg->id);
return true;
} else if (bot->isBot() && bot->botInfo->inlineReturnTo.key) {
2020-06-26 11:48:28 +00:00
if (Notify::switchInlineBotButtonReceived(session, QString::fromUtf8(button->data))) {
return true;
}
}
2020-06-26 11:48:28 +00:00
return false;
}();
if (!fastSwitchDone) {
m->inlineSwitchLayer('@' + bot->username + ' ' + QString::fromUtf8(button->data));
}
}
}
} break;
2019-05-22 14:29:02 +00:00
case ButtonType::Auth:
UrlAuthBox::Activate(msg, row, column);
break;
2021-11-05 12:05:11 +00:00
case ButtonType::UserProfile: {
const auto session = &msg->history()->session();
const auto userId = UserId(button->data.toULongLong());
if (const auto user = session->data().userLoaded(userId)) {
const auto &windows = session->windows();
if (!windows.empty()) {
windows.front()->showPeerInfo(user);
}
}
} break;
}
}
} // namespace App
2015-12-07 13:05:00 +00:00
namespace Ui {
2015-12-07 18:09:05 +00:00
void showPeerProfile(not_null<PeerData*> peer) {
if (const auto window = App::wnd()) { // multi good
if (const auto controller = window->sessionController()) {
if (&controller->session() == &peer->session()) {
controller->showPeerInfo(peer);
2020-07-02 08:15:21 +00:00
return;
}
}
2020-06-26 11:48:28 +00:00
if (&Core::App().domain().active() != &peer->session().account()) {
Core::App().domain().activate(&peer->session().account());
}
if (const auto controller = window->sessionController()) {
if (&controller->session() == &peer->session()) {
controller->showPeerInfo(peer);
}
}
}
}
void showPeerProfile(not_null<const History*> history) {
showPeerProfile(history->peer);
}
void showChatsList(not_null<Main::Session*> session) {
2020-06-26 11:48:28 +00:00
if (const auto m = CheckMainWidget(session)) {
m->ui_showPeerHistory(
0,
::Window::SectionShow::Way::ClearStack,
2020-06-26 11:48:28 +00:00
0);
}
}
void showPeerHistory(not_null<const History*> history, MsgId msgId) {
2020-06-10 18:08:17 +00:00
showPeerHistory(history->peer, msgId);
}
2020-06-10 18:08:17 +00:00
void showPeerHistory(not_null<const PeerData*> peer, MsgId msgId) {
2020-06-26 11:48:28 +00:00
if (const auto m = CheckMainWidget(&peer->session())) {
m->ui_showPeerHistory(
peer->id,
::Window::SectionShow::Way::ClearStack,
2020-06-26 11:48:28 +00:00
msgId);
2020-06-10 18:08:17 +00:00
}
}
bool skipPaintEvent(QWidget *widget, QPaintEvent *event) {
if (auto w = App::wnd()) {
if (w->contentOverlapped(widget, event)) {
return true;
}
}
return false;
}
} // namespace Ui
2015-12-07 13:05:00 +00:00
namespace Notify {
2020-06-10 18:08:17 +00:00
bool switchInlineBotButtonReceived(
not_null<Main::Session*> session,
const QString &query,
UserData *samePeerBot,
MsgId samePeerReplyTo) {
2020-06-26 11:48:28 +00:00
if (const auto m = CheckMainWidget(session)) {
return m->notify_switchInlineBotButtonReceived(
query,
samePeerBot,
samePeerReplyTo);
}
return false;
}
} // namespace Notify