tdesktop/Telegram/SourceFiles/facades.cpp

/*
This file is part of Telegram Desktop,
the official desktop version of Telegram messaging app, see https://telegram.org

Telegram Desktop is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

It is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

In addition, as a special exception, the copyright holders give permission
to link the code of portions of this program with the OpenSSL library.

Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
Copyright (c) 2014-2016 John Preston, https://desktop.telegram.org
*/
#include "stdafx.h"

#include "window.h"
#include "mainwidget.h"
#include "application.h"

#include "boxes/confirmbox.h"

#include "layerwidget.h"
#include "lang.h"

Q_DECLARE_METATYPE(ClickHandlerPtr);
Q_DECLARE_METATYPE(Qt::MouseButton);

namespace App {

	void sendBotCommand(PeerData *peer, const QString &cmd, MsgId replyTo) {
		if (MainWidget *m = main()) m->sendBotCommand(peer, cmd, replyTo);
	}

	void sendBotCallback(PeerData *peer, const QByteArray &data, MsgId replyTo) {
		if (MainWidget *m = main()) m->sendBotCallback(peer, data, replyTo);
	}

	bool insertBotCommand(const QString &cmd, bool specialGif) {
		if (MainWidget *m = main()) return m->insertBotCommand(cmd, specialGif);
		return false;
	}

	void activateBotCommand(PeerData *peer, const HistoryMessageReplyMarkup::Button &button, MsgId replyTo) {
		switch (button.type) {
		case HistoryMessageReplyMarkup::Button::Default: {
			// copy string before passing it to the sending method
			// the original button can be destroyed inside
			sendBotCommand(peer, QString(button.text), replyTo);
		} break;

		case HistoryMessageReplyMarkup::Button::Callback: {
			sendBotCallback(peer, button.data, replyTo);
		} break;

		case HistoryMessageReplyMarkup::Button::Url: {
			auto url = QString::fromUtf8(button.data);
			HiddenUrlClickHandler(url).onClick(Qt::LeftButton);
		} break;

		case HistoryMessageReplyMarkup::Button::RequestLocation: {
			Ui::showLayer(new InformBox(lang(lng_bot_share_location_unavailable)));
		} break;

		case HistoryMessageReplyMarkup::Button::RequestPhone: {
			SharePhoneConfirmBox *box = new SharePhoneConfirmBox(peer);
			box->connect(box, SIGNAL(confirmed(PeerData*)), App::main(), SLOT(onSharePhoneWithBot(PeerData*)));
			Ui::showLayer(box);
		} break;
		}
	}

	void searchByHashtag(const QString &tag, PeerData *inPeer) {
		if (MainWidget *m = main()) m->searchMessages(tag + ' ', (inPeer && inPeer->isChannel() && !inPeer->isMegagroup()) ? inPeer : 0);
	}

	void openPeerByName(const QString &username, MsgId msgId, const QString &startToken) {
		if (MainWidget *m = main()) m->openPeerByName(username, msgId, startToken);
	}

	void joinGroupByHash(const QString &hash) {
		if (MainWidget *m = main()) m->joinGroupByHash(hash);
	}

	void stickersBox(const QString &name) {
		if (MainWidget *m = main()) m->stickersBox(MTP_inputStickerSetShortName(MTP_string(name)));
	}

	void openLocalUrl(const QString &url) {
		if (MainWidget *m = main()) m->openLocalUrl(url);
	}

	bool forward(const PeerId &peer, ForwardWhatMessages what) {
		if (MainWidget *m = main()) return m->onForward(peer, what);
		return false;
	}

	void removeDialog(History *history) {
		if (MainWidget *m = main()) {
			m->removeDialog(history);
		}
	}

	void showSettings() {
		if (Window *w = wnd()) {
			w->showSettings();
		}
	}

	void activateClickHandler(ClickHandlerPtr handler, Qt::MouseButton button) {
		if (Window *w = wnd()) {
			qRegisterMetaType<ClickHandlerPtr>();
			qRegisterMetaType<Qt::MouseButton>();
			QMetaObject::invokeMethod(w, "app_activateClickHandler", Qt::QueuedConnection, Q_ARG(ClickHandlerPtr, handler), Q_ARG(Qt::MouseButton, button));
		}
	}

	void logOutDelayed() {
		if (Window *w = App::wnd()) {
			QMetaObject::invokeMethod(w, "onLogoutSure", Qt::QueuedConnection);
		}
	}

}

namespace Ui {

	void showStickerPreview(DocumentData *sticker) {
		if (Window *w = App::wnd()) {
			w->ui_showStickerPreview(sticker);
		}
	}

	void hideStickerPreview() {
		if (Window *w = App::wnd()) {
			w->ui_hideStickerPreview();
		}
	}

	void showLayer(LayeredWidget *box, ShowLayerOptions options) {
		if (Window *w = App::wnd()) {
			w->ui_showLayer(box, options);
		} else {
			delete box;
		}
	}

	void hideLayer(bool fast) {
		if (Window *w = App::wnd()) w->ui_showLayer(0, ShowLayerOptions(CloseOtherLayers) | (fast ? ForceFastShowLayer : AnimatedShowLayer));
	}

	bool isLayerShown() {
		if (Window *w = App::wnd()) return w->ui_isLayerShown();
		return false;
	}

	bool isMediaViewShown() {
		if (Window *w = App::wnd()) return w->ui_isMediaViewShown();
		return false;
	}

	bool isInlineItemBeingChosen() {
		if (MainWidget *m = App::main()) return m->ui_isInlineItemBeingChosen();
		return false;
	}

	void repaintHistoryItem(const HistoryItem *item) {
		if (!item) return;
		if (MainWidget *m = App::main()) m->ui_repaintHistoryItem(item);
	}

	void repaintInlineItem(const LayoutInlineItem *layout) {
		if (!layout) return;
		if (MainWidget *m = App::main()) m->ui_repaintInlineItem(layout);
	}

	bool isInlineItemVisible(const LayoutInlineItem *layout) {
		if (MainWidget *m = App::main()) return m->ui_isInlineItemVisible(layout);
		return false;
	}

	void autoplayMediaInlineAsync(const FullMsgId &msgId) {
		if (MainWidget *m = App::main()) {
			QMetaObject::invokeMethod(m, "ui_autoplayMediaInlineAsync", Qt::QueuedConnection, Q_ARG(qint32, msgId.channel), Q_ARG(qint32, msgId.msg));
		}
	}

	void showPeerHistory(const PeerId &peer, MsgId msgId, bool back) {
		if (MainWidget *m = App::main()) m->ui_showPeerHistory(peer, msgId, back);
	}

	void showPeerHistoryAsync(const PeerId &peer, MsgId msgId) {
		if (MainWidget *m = App::main()) {
			QMetaObject::invokeMethod(m, "ui_showPeerHistoryAsync", Qt::QueuedConnection, Q_ARG(quint64, peer), Q_ARG(qint32, msgId));
		}
	}

	PeerData *getPeerForMouseAction() {
		if (Window *w = App::wnd()) {
			return w->ui_getPeerForMouseAction();
		}
		return nullptr;
	}

	bool hideWindowNoQuit() {
		if (!App::quitting()) {
			if (Window *w = App::wnd()) {
				if (cWorkMode() == dbiwmTrayOnly || cWorkMode() == dbiwmWindowAndTray) {
					return w->minimizeToTray();
				} else if (cPlatform() == dbipMac || cPlatform() == dbipMacOld) {
					w->hide();
					w->updateIsActive(Global::OfflineBlurTimeout());
					w->updateGlobalMenu();
					return true;
				}
			}
		}
		return false;
	}

}

namespace Notify {

	void userIsBotChanged(UserData *user) {
		if (MainWidget *m = App::main()) m->notify_userIsBotChanged(user);
	}

	void userIsContactChanged(UserData *user, bool fromThisApp) {
		if (MainWidget *m = App::main()) m->notify_userIsContactChanged(user, fromThisApp);
	}

	void botCommandsChanged(UserData *user) {
		if (MainWidget *m = App::main()) m->notify_botCommandsChanged(user);
	}

	void inlineBotRequesting(bool requesting) {
		if (MainWidget *m = App::main()) m->notify_inlineBotRequesting(requesting);
	}

	void replyMarkupUpdated(const HistoryItem *item) {
		if (MainWidget *m = App::main()) {
			m->notify_replyMarkupUpdated(item);
		}
	}

	void migrateUpdated(PeerData *peer) {
		if (MainWidget *m = App::main()) m->notify_migrateUpdated(peer);
	}

	void clipStopperHidden(ClipStopperType type) {
		if (MainWidget *m = App::main()) m->notify_clipStopperHidden(type);
	}

	void historyItemLayoutChanged(const HistoryItem *item) {
		if (MainWidget *m = App::main()) m->notify_historyItemLayoutChanged(item);
	}

	void automaticLoadSettingsChangedGif() {
		if (MainWidget *m = App::main()) m->notify_automaticLoadSettingsChangedGif();
	}

	void handlePendingHistoryUpdate() {
		if (MainWidget *m = App::main()) {
			m->notify_handlePendingHistoryUpdate();
		}
		for_const (HistoryItem *item, Global::PendingRepaintItems()) {
			Ui::repaintHistoryItem(item);
		}
		Global::RefPendingRepaintItems().clear();
	}

}

#define DefineReadOnlyVar(Namespace, Type, Name) const Type &Name() { \
	t_assert_full(Namespace##Data != 0, #Namespace "Data is null in " #Namespace "::" #Name, __FILE__, __LINE__); \
	return Namespace##Data->Name; \
}
#define DefineRefVar(Namespace, Type, Name) DefineReadOnlyVar(Namespace, Type, Name) \
Type &Ref##Name() { \
	t_assert_full(Namespace##Data != 0, #Namespace "Data is null in Global::Ref" #Name, __FILE__, __LINE__); \
	return Namespace##Data->Name; \
}
#define DefineVar(Namespace, Type, Name) DefineRefVar(Namespace, Type, Name) \
void Set##Name(const Type &Name) { \
	t_assert_full(Namespace##Data != 0, #Namespace "Data is null in Global::Set" #Name, __FILE__, __LINE__); \
	Namespace##Data->Name = Name; \
}

namespace Sandbox {

	namespace internal {

		struct Data {
			QString LangSystemISO;
			int32 LangSystem = languageDefault;

			QByteArray LastCrashDump;
			ConnectionProxy PreLaunchProxy;
		};

	}

}
Sandbox::internal::Data *SandboxData = 0;
uint64 SandboxUserTag = 0;

namespace Sandbox {

	bool CheckBetaVersionDir() {
		QFile beta(cExeDir() + qsl("TelegramBeta_data/tdata/beta"));
		if (cBetaVersion()) {
			cForceWorkingDir(cExeDir() + qsl("TelegramBeta_data/"));
			QDir().mkpath(cWorkingDir() + qstr("tdata"));
			if (*BetaPrivateKey) {
				cSetBetaPrivateKey(QByteArray(BetaPrivateKey));
			}
			if (beta.open(QIODevice::WriteOnly)) {
				QDataStream dataStream(&beta);
				dataStream.setVersion(QDataStream::Qt_5_3);
				dataStream << quint64(cRealBetaVersion()) << cBetaPrivateKey();
			} else {
				LOG(("FATAL: Could not open '%1' for writing private key!").arg(beta.fileName()));
				return false;
			}
		} else if (beta.exists()) {
			cForceWorkingDir(cExeDir() + qsl("TelegramBeta_data/"));
			if (beta.open(QIODevice::ReadOnly)) {
				QDataStream dataStream(&beta);
				dataStream.setVersion(QDataStream::Qt_5_3);

				quint64 v;
				QByteArray k;
				dataStream >> v >> k;
				if (dataStream.status() == QDataStream::Ok) {
					cSetBetaVersion(qMax(v, AppVersion * 1000ULL));
					cSetBetaPrivateKey(k);
					cSetRealBetaVersion(v);
				} else {
					LOG(("FATAL: '%1' is corrupted, reinstall private beta!").arg(beta.fileName()));
					return false;
				}
			} else {
				LOG(("FATAL: could not open '%1' for reading private key!").arg(beta.fileName()));
				return false;
			}
		}
		return true;
	}

	void WorkingDirReady() {
		if (QFile(cWorkingDir() + qsl("tdata/withtestmode")).exists()) {
			cSetTestMode(true);
		}
		if (!cDebug() && QFile(cWorkingDir() + qsl("tdata/withdebug")).exists()) {
			cSetDebug(true);
		}
		if (cBetaVersion()) {
			cSetDevVersion(false);
		} else if (!cDevVersion() && QFile(cWorkingDir() + qsl("tdata/devversion")).exists()) {
			cSetDevVersion(true);
		} else if (DevVersion) {
			QFile f(cWorkingDir() + qsl("tdata/devversion"));
			if (!f.exists() && f.open(QIODevice::WriteOnly)) {
				f.write("1");
			}
		}

		srand((int32)time(NULL));

		SandboxUserTag = 0;
		QFile usertag(cWorkingDir() + qsl("tdata/usertag"));
		if (usertag.open(QIODevice::ReadOnly)) {
			if (usertag.read(reinterpret_cast<char*>(&SandboxUserTag), sizeof(uint64)) != sizeof(uint64)) {
				SandboxUserTag = 0;
			}
			usertag.close();
		}
		if (!SandboxUserTag) {
			do {
				memsetrnd_bad(SandboxUserTag);
			} while (!SandboxUserTag);

			if (usertag.open(QIODevice::WriteOnly)) {
				usertag.write(reinterpret_cast<char*>(&SandboxUserTag), sizeof(uint64));
				usertag.close();
			}
		}
	}

	void start() {
		SandboxData = new internal::Data();

		SandboxData->LangSystemISO = psCurrentLanguage();
		if (SandboxData->LangSystemISO.isEmpty()) SandboxData->LangSystemISO = qstr("en");
		QByteArray l = LangSystemISO().toLatin1();
		for (int32 i = 0; i < languageCount; ++i) {
			if (l.at(0) == LanguageCodes[i][0] && l.at(1) == LanguageCodes[i][1]) {
				SandboxData->LangSystem = i;
				break;
			}
		}
	}

	void finish() {
		delete SandboxData;
		SandboxData = 0;
	}

	uint64 UserTag() {
		return SandboxUserTag;
	}

	DefineReadOnlyVar(Sandbox, QString, LangSystemISO);
	DefineReadOnlyVar(Sandbox, int32, LangSystem);
	DefineVar(Sandbox, QByteArray, LastCrashDump);
	DefineVar(Sandbox, ConnectionProxy, PreLaunchProxy);

}

namespace Global {
	namespace internal {

		struct Data {
			uint64 LaunchId = 0;
			SingleDelayedCall HandleHistoryUpdate = { App::app(), "call_handleHistoryUpdate" };

			Adaptive::Layout AdaptiveLayout = Adaptive::NormalLayout;
			bool AdaptiveForWide = true;

			int32 DebugLoggingFlags = 0;

			// config
			int32 ChatSizeMax = 200;
			int32 MegagroupSizeMax = 1000;
			int32 ForwardedCountMax = 100;
			int32 OnlineUpdatePeriod = 120000;
			int32 OfflineBlurTimeout = 5000;
			int32 OfflineIdleTimeout = 30000;
			int32 OnlineFocusTimeout = 1000;
			int32 OnlineCloudTimeout = 300000;
			int32 NotifyCloudDelay = 30000;
			int32 NotifyDefaultDelay = 1500;
			int32 ChatBigSize = 10;
			int32 PushChatPeriod = 60000;
			int32 PushChatLimit = 2;
			int32 SavedGifsLimit = 200;
			int32 EditTimeLimit = 172800;

			HiddenPinnedMessagesMap HiddenPinnedMessages;

			PendingItemsMap PendingRepaintItems;

			Stickers::Sets StickerSets;
			Stickers::Order StickerSetsOrder;
			uint64 LastStickersUpdate = 0;

			MTP::DcOptions DcOptions;

			CircleMasksMap CircleMasks;
		};

	}
}

Global::internal::Data *GlobalData = 0;

namespace Global {

	bool started() {
		return GlobalData != 0;
	}

	void start() {
		GlobalData = new internal::Data();

		memset_rand(&GlobalData->LaunchId, sizeof(GlobalData->LaunchId));
	}

	void finish() {
		delete GlobalData;
		GlobalData = 0;
	}

	DefineReadOnlyVar(Global, uint64, LaunchId);
	DefineRefVar(Global, SingleDelayedCall, HandleHistoryUpdate);

	DefineVar(Global, Adaptive::Layout, AdaptiveLayout);
	DefineVar(Global, bool, AdaptiveForWide);

	DefineVar(Global, int32, DebugLoggingFlags);

	// config
	DefineVar(Global, int32, ChatSizeMax);
	DefineVar(Global, int32, MegagroupSizeMax);
	DefineVar(Global, int32, ForwardedCountMax);
	DefineVar(Global, int32, OnlineUpdatePeriod);
	DefineVar(Global, int32, OfflineBlurTimeout);
	DefineVar(Global, int32, OfflineIdleTimeout);
	DefineVar(Global, int32, OnlineFocusTimeout);
	DefineVar(Global, int32, OnlineCloudTimeout);
	DefineVar(Global, int32, NotifyCloudDelay);
	DefineVar(Global, int32, NotifyDefaultDelay);
	DefineVar(Global, int32, ChatBigSize);
	DefineVar(Global, int32, PushChatPeriod);
	DefineVar(Global, int32, PushChatLimit);
	DefineVar(Global, int32, SavedGifsLimit);
	DefineVar(Global, int32, EditTimeLimit);

	DefineVar(Global, HiddenPinnedMessagesMap, HiddenPinnedMessages);

	DefineRefVar(Global, PendingItemsMap, PendingRepaintItems);

	DefineVar(Global, Stickers::Sets, StickerSets);
	DefineVar(Global, Stickers::Order, StickerSetsOrder);
	DefineVar(Global, uint64, LastStickersUpdate);

	DefineVar(Global, MTP::DcOptions, DcOptions);

	DefineRefVar(Global, CircleMasksMap, CircleMasks);

};