Improve peer context menu for info.

Telegram/SourceFiles/dialogs/dialogs_inner_widget.cpp

@@ -38,6 +38,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #include "auth_session.h"
 #include "window/notifications_manager.h"
 #include "window/window_controller.h"
+#include "window/window_peer_menu.h"
 #include "ui/widgets/multi_select.h"
 
 namespace {
@@ -1240,9 +1241,14 @@ void DialogsInner::contextMenuEvent(QContextMenuEvent *e) {
 	}
 
 	_menu = new Ui::PopupMenu(nullptr);
-	App::main()->fillPeerMenu(_menuPeer, [this](const QString &text, base::lambda<void()> callback) {
-		return _menu->addAction(text, std::move(callback));
-	}, true);
+	Window::PeerMenuOptions options;
+	options.pinToggle = options.showInfo = options.search = true;
+	Window::FillPeerMenu(
+		_menuPeer,
+		[this](const QString &text, base::lambda<void()> callback) {
+			return _menu->addAction(text, std::move(callback));
+		},
+		options);
 	connect(_menu, SIGNAL(destroyed(QObject*)), this, SLOT(onMenuDestroyed(QObject*)));
 	_menu->popup(e->globalPos());
 	e->accept();

Telegram/SourceFiles/history/history_widget.cpp

@@ -4565,12 +4565,12 @@ void HistoryWidget::onReportSpamClear() {
 		if (peer->isUser()) {
 			App::main()->deleteConversation(peer);
 		} else if (auto chat = peer->asChat()) {
-			MTP::send(MTPmessages_DeleteChatUser(chat->inputChat, App::self()->inputUser), App::main()->rpcDone(&MainWidget::deleteHistoryAfterLeave, peer), App::main()->rpcFail(&MainWidget::leaveChatFailed, peer));
+			App::main()->deleteAndExit(chat);
 		} else if (auto channel = peer->asChannel()) {
 			if (channel->migrateFrom()) {
 				App::main()->deleteConversation(channel->migrateFrom());
 			}
-			MTP::send(MTPchannels_LeaveChannel(channel->inputChannel), App::main()->rpcDone(&MainWidget::sentUpdatesReceived));
+			Auth().api().leaveChannel(channel);
 		}
 	});
 

Telegram/SourceFiles/mainwidget.cpp

@@ -2309,148 +2309,6 @@ void MainWidget::scheduleViewIncrement(HistoryItem *item) {
 	j.value().insert(item->id, true);
 }
 
-void MainWidget::fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> handler)> callback, bool pinToggle) {
-	if (pinToggle) {
-		auto isPinned = false;
-		if (auto history = App::historyLoaded(peer)) {
-			isPinned = history->isPinnedDialog();
-		}
-		auto pinSubscription = MakeShared<base::Subscription>();
-		auto pinAction = callback(lang(isPinned ? lng_context_unpin_from_top : lng_context_pin_to_top), [peer, pinSubscription] {
-			auto history = App::history(peer);
-			auto isPinned = !history->isPinnedDialog();
-			if (isPinned && App::histories().pinnedCount() >= Global::PinnedDialogsCountMax()) {
-				// Some old chat, that was converted to supergroup, maybe is still pinned.
-				auto findWastedPin = []() -> History* {
-					auto order = App::histories().getPinnedOrder();
-					for_const (auto pinned, order) {
-						if (pinned->peer->isChat()
-							&& pinned->peer->asChat()->isDeactivated()
-							&& !pinned->inChatList(Dialogs::Mode::All)) {
-							return pinned;
-						}
-					}
-					return nullptr;
-				};
-				if (auto wasted = findWastedPin()) {
-					wasted->setPinnedDialog(false);
-					history->setPinnedDialog(isPinned);
-					App::histories().savePinnedToServer();
-				} else {
-					Ui::show(Box<InformBox>(lng_error_pinned_max(lt_count, Global::PinnedDialogsCountMax())));
-				}
-				return;
-			}
-
-			history->setPinnedDialog(isPinned);
-			auto flags = MTPmessages_ToggleDialogPin::Flags(0);
-			if (isPinned) {
-				flags |= MTPmessages_ToggleDialogPin::Flag::f_pinned;
-			}
-			MTP::send(MTPmessages_ToggleDialogPin(MTP_flags(flags), peer->input));
-			if (isPinned) {
-				if (auto main = App::main()) {
-					main->dialogsToUp();
-				}
-			}
-		});
-		auto pinChangedHandler = Notify::PeerUpdatedHandler(Notify::PeerUpdate::Flag::PinnedChanged, [pinAction, peer](const Notify::PeerUpdate &update) {
-			if (update.peer != peer) return;
-			pinAction->setText(lang(App::history(peer)->isPinnedDialog() ? lng_context_unpin_from_top : lng_context_pin_to_top));
-		});
-		*pinSubscription = Notify::PeerUpdated().add_subscription(std::move(pinChangedHandler));
-	}
-	callback(lang((peer->isChat() || peer->isMegagroup()) ? lng_context_view_group : (peer->isUser() ? lng_context_view_profile : lng_context_view_channel)), [peer] {
-		Ui::showPeerProfile(peer);
-	});
-	auto muteSubscription = MakeShared<base::Subscription>();
-    auto muteAction = callback(!peer->isMuted() ? lang(lng_disable_notifications_from_tray) : lang(lng_enable_notifications_from_tray), [peer, muteSubscription] {
-		// We have to capture the muteSubscription pointer in this lambda for
-		// real time updates of the action when an user changes mute status of
-		// the peer on his (her) another device. Otherwise, the subscription
-		// will be destroyed ahead of time.
-		if (!peer->isMuted()) {
-			Ui::show(Box<MuteSettingsBox>(peer));
-		} else {
-			App::main()->updateNotifySetting(peer, NotifySettingSetNotify);
-		}
-	});
-	auto muteChangedHandler = Notify::PeerUpdatedHandler(Notify::PeerUpdate::Flag::NotificationsEnabled, [muteAction, peer](const Notify::PeerUpdate &update) {
-		if (update.peer != peer) return;
-		muteAction->setText(lang(peer->isMuted() ? lng_enable_notifications_from_tray : lng_disable_notifications_from_tray));
-	});
-	*muteSubscription = Notify::PeerUpdated().add_subscription(std::move(muteChangedHandler));
-
-	callback(lang(lng_profile_search_messages), [peer] {
-		App::main()->searchInPeer(peer);
-	});
-
-	auto clearHistoryHandler = [peer] {
-		auto text = peer->isUser() ? lng_sure_delete_history(lt_contact, peer->name) : lng_sure_delete_group_history(lt_group, peer->name);
-		Ui::show(Box<ConfirmBox>(text, lang(lng_box_delete), st::attentionBoxButton, [peer] {
-			if (!App::main()) return;
-
-			Ui::hideLayer();
-			App::main()->clearHistory(peer);
-		}));
-	};
-	auto deleteAndLeaveHandler = [peer] {
-		auto warningText = peer->isUser() ? lng_sure_delete_history(lt_contact, peer->name) :
-			peer->isChat() ? lng_sure_delete_and_exit(lt_group, peer->name) :
-			lang(peer->isMegagroup() ? lng_sure_leave_group : lng_sure_leave_channel);
-		auto confirmText = lang(peer->isUser() ? lng_box_delete : lng_box_leave);
-		auto &confirmStyle = peer->isChannel() ? st::defaultBoxButton : st::attentionBoxButton;
-		Ui::show(Box<ConfirmBox>(warningText, confirmText, confirmStyle, [peer] {
-			if (!App::main()) return;
-
-			Ui::hideLayer();
-			Ui::showChatsList();
-			if (peer->isUser()) {
-				App::main()->deleteConversation(peer);
-			} else if (peer->isChat()) {
-				MTP::send(MTPmessages_DeleteChatUser(peer->asChat()->inputChat, App::self()->inputUser), App::main()->rpcDone(&MainWidget::deleteHistoryAfterLeave, peer), App::main()->rpcFail(&MainWidget::leaveChatFailed, peer));
-			} else if (peer->isChannel()) {
-				if (peer->migrateFrom()) {
-					App::main()->deleteConversation(peer->migrateFrom());
-				}
-				MTP::send(MTPchannels_LeaveChannel(peer->asChannel()->inputChannel), App::main()->rpcDone(&MainWidget::sentUpdatesReceived));
-			}
-		}));
-	};
-	if (auto user = peer->asUser()) {
-		callback(lang(lng_profile_delete_conversation), std::move(deleteAndLeaveHandler));
-		callback(lang(lng_profile_clear_history), std::move(clearHistoryHandler));
-		if (!user->isInaccessible() && user != App::self()) {
-			auto blockSubscription = MakeShared<base::Subscription>();
-			auto blockAction = callback(lang(user->isBlocked() ? (user->botInfo ? lng_profile_unblock_bot : lng_profile_unblock_user) : (user->botInfo ? lng_profile_block_bot : lng_profile_block_user)), [user, blockSubscription] {
-				auto willBeBlocked = !user->isBlocked();
-				auto handler = ::rpcDone([user, willBeBlocked](const MTPBool &result) {
-					user->setBlockStatus(willBeBlocked ? UserData::BlockStatus::Blocked : UserData::BlockStatus::NotBlocked);
-				});
-				if (willBeBlocked) {
-					MTP::send(MTPcontacts_Block(user->inputUser), std::move(handler));
-				} else {
-					MTP::send(MTPcontacts_Unblock(user->inputUser), std::move(handler));
-				}
-			});
-			auto blockChangedHandler = Notify::PeerUpdatedHandler(Notify::PeerUpdate::Flag::UserIsBlocked, [blockAction, peer](const Notify::PeerUpdate &update) {
-				if (update.peer != peer) return;
-				blockAction->setText(lang(peer->asUser()->isBlocked() ? (peer->asUser()->botInfo ? lng_profile_unblock_bot : lng_profile_unblock_user) : (peer->asUser()->botInfo ? lng_profile_block_bot : lng_profile_block_user)));
-			});
-			*blockSubscription = Notify::PeerUpdated().add_subscription(std::move(blockChangedHandler));
-
-			if (user->blockStatus() == UserData::BlockStatus::Unknown) {
-				Auth().api().requestFullPeer(user);
-			}
-		}
-	} else if (peer->isChat()) {
-		callback(lang(lng_profile_clear_and_exit), std::move(deleteAndLeaveHandler));
-		callback(lang(lng_profile_clear_history), std::move(clearHistoryHandler));
-	} else if (peer->isChannel() && peer->asChannel()->amIn() && !peer->asChannel()->amCreator()) {
-		callback(lang(peer->isMegagroup() ? lng_profile_leave_group : lng_profile_leave_channel), std::move(deleteAndLeaveHandler));
-	}
-}
-
 void MainWidget::onViewsIncrement() {
 	for (ViewsIncrement::iterator i = _viewsToIncrement.begin(); i != _viewsToIncrement.cend();) {
 		if (_viewsIncrementRequests.contains(i.key())) {

Telegram/SourceFiles/mainwidget.h

@@ -323,8 +323,6 @@ public:
 
 	void scheduleViewIncrement(HistoryItem *item);
 
-	void fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> handler)> callback, bool pinToggle);
-
 	void gotRangeDifference(ChannelData *channel, const MTPupdates_ChannelDifference &diff);
 	void onSelfParticipantUpdated(ChannelData *channel);
 

Telegram/SourceFiles/ui/rp_widget.h

@@ -26,6 +26,23 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #include "base/unique_qptr.h"
 
 namespace Ui {
+namespace details {
+
+template <typename Value>
+class AttachmentOwner : public QObject {
+public:
+	template <typename OtherValue>
+	AttachmentOwner(QObject *parent, OtherValue &&value)
+	: QObject(parent)
+	, _value(std::forward<OtherValue>(value)) {
+	}
+
+private:
+	Value _value;
+
+};
+
+} // namespace details
 
 template <typename Widget, typename ...Args>
 inline base::unique_qptr<Widget> CreateObject(Args &&...args) {
@@ -44,6 +61,14 @@ inline Widget *CreateChild(
 		std::forward<Args>(args)...).release();
 }
 
+template <typename Value>
+inline void AttachAsChild(not_null<QObject*> parent, Value &&value) {
+	using PlainValue = std::decay_t<Value>;
+	CreateChild<details::AttachmentOwner<PlainValue>>(
+		parent.get(),
+		std::forward<Value>(value));
+}
+
 template <typename Widget>
 using RpWidgetParent = std::conditional_t<
 	std::is_same_v<Widget, QWidget>,

Telegram/SourceFiles/window/top_bar_widget.cpp

@@ -36,6 +36,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #include "ui/widgets/dropdown_menu.h"
 #include "dialogs/dialogs_layout.h"
 #include "window/window_controller.h"
+#include "window/window_peer_menu.h"
 #include "calls/calls_instance.h"
 #include "observer_peer.h"
 
@@ -185,9 +186,23 @@ void TopBarWidget::showMenu() {
 					}
 				}));
 				_menuToggle->installEventFilter(_menu);
-				App::main()->fillPeerMenu(peer, [this](const QString &text, base::lambda<void()> callback) {
-					return _menu->addAction(text, std::move(callback));
-				}, false);
+				Window::PeerMenuOptions options;
+				options.showInfo = [&] {
+					if (!Adaptive::ThreeColumn()) {
+						return true;
+					} else if (
+						!Auth().data().thirdSectionInfoEnabled() &&
+						!Auth().data().tabbedReplacedWithInfo()) {
+						return true;
+					}
+					return false;
+				}();
+				Window::FillPeerMenu(
+					peer,
+					[this](const QString &text, base::lambda<void()> callback) {
+						return _menu->addAction(text, std::move(callback));
+					},
+					options);
 				_menu->moveToRight((parentWidget()->width() - width()) + st::topBarMenuPosition.x(), st::topBarMenuPosition.y());
 				_menu->showAnimated(Ui::PanelAnimation::Origin::TopRight);
 			}

Telegram/SourceFiles/window/window_peer_menu.cpp

@@ -0,0 +1,328 @@
+/*
+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-2017 John Preston, https://desktop.telegram.org
+*/
+#include "window/window_peer_menu.h"
+
+#include "lang/lang_keys.h"
+#include "boxes/confirm_box.h"
+#include "boxes/mute_settings_box.h"
+#include "auth_session.h"
+#include "apiwrap.h"
+#include "mainwidget.h"
+#include "observer_peer.h"
+#include "styles/style_boxes.h"
+
+namespace Window {
+namespace{
+
+class Filler {
+public:
+	Filler(
+		not_null<PeerData*> peer,
+		const PeerMenuCallback &callback,
+		const PeerMenuOptions &options);
+	void fill();
+
+private:
+	void addPinToggle();
+	void addInfo();
+	void addNotifications();
+	void addSearch();
+	void addUserActions(not_null<UserData*> user);
+	void addBlockUser(not_null<UserData*> user);
+	void addChatActions(not_null<ChatData*> chat);
+	void addChannelActions(not_null<ChannelData*> channel);
+
+	not_null<PeerData*> _peer;
+	const PeerMenuCallback &_callback;
+	const PeerMenuOptions &_options;
+
+};
+
+History *FindWastedPin() {
+	auto order = App::histories().getPinnedOrder();
+	for_const (auto pinned, order) {
+		if (pinned->peer->isChat()
+			&& pinned->peer->asChat()->isDeactivated()
+			&& !pinned->inChatList(Dialogs::Mode::All)) {
+			return pinned;
+		}
+	}
+	return nullptr;
+}
+
+auto ClearHistoryHandler(not_null<PeerData*> peer) {
+	return [peer] {
+		auto text = peer->isUser() ? lng_sure_delete_history(lt_contact, peer->name) : lng_sure_delete_group_history(lt_group, peer->name);
+		Ui::show(Box<ConfirmBox>(text, lang(lng_box_delete), st::attentionBoxButton, [peer] {
+			if (!App::main()) return;
+
+			Ui::hideLayer();
+			App::main()->clearHistory(peer);
+		}));
+	};
+}
+
+auto DeleteAndLeaveHandler(not_null<PeerData*> peer) {
+	return [peer] {
+		auto warningText = peer->isUser() ? lng_sure_delete_history(lt_contact, peer->name) :
+			peer->isChat() ? lng_sure_delete_and_exit(lt_group, peer->name) :
+			lang(peer->isMegagroup() ? lng_sure_leave_group : lng_sure_leave_channel);
+		auto confirmText = lang(peer->isUser() ? lng_box_delete : lng_box_leave);
+		auto &confirmStyle = peer->isChannel() ? st::defaultBoxButton : st::attentionBoxButton;
+		Ui::show(Box<ConfirmBox>(warningText, confirmText, confirmStyle, [peer] {
+			if (!App::main()) return;
+
+			Ui::hideLayer();
+			Ui::showChatsList();
+			if (peer->isUser()) {
+				App::main()->deleteConversation(peer);
+			} else if (auto chat = peer->asChat()) {
+				App::main()->deleteAndExit(chat);
+			} else if (auto channel = peer->asChannel()) {
+				if (auto migrateFrom = channel->migrateFrom()) {
+					App::main()->deleteConversation(migrateFrom);
+				}
+				Auth().api().leaveChannel(channel);
+			}
+		}));
+	};
+}
+
+Filler::Filler(
+	not_null<PeerData*> peer,
+	const PeerMenuCallback &callback,
+	const PeerMenuOptions &options)
+: _peer(peer)
+, _callback(callback)
+, _options(options) {
+}
+
+void Filler::addPinToggle() {
+	auto peer = _peer;
+	auto isPinned = false;
+	if (auto history = App::historyLoaded(peer)) {
+		isPinned = history->isPinnedDialog();
+	}
+	auto pinText = [](bool isPinned) {
+		return lang(isPinned
+			? lng_context_unpin_from_top
+			: lng_context_pin_to_top);
+	};
+	auto pinToggle = [peer] {
+		auto history = App::history(peer);
+		auto isPinned = !history->isPinnedDialog();
+		auto pinnedCount = App::histories().pinnedCount();
+		auto pinnedMax = Global::PinnedDialogsCountMax();
+		if (isPinned && pinnedCount >= pinnedMax) {
+			// Some old chat, that was converted to supergroup, maybe is still pinned.
+			if (auto wasted = FindWastedPin()) {
+				wasted->setPinnedDialog(false);
+				history->setPinnedDialog(isPinned);
+				App::histories().savePinnedToServer();
+			} else {
+				auto errorText = lng_error_pinned_max(
+					lt_count,
+					pinnedMax);
+				Ui::show(Box<InformBox>(errorText));
+			}
+			return;
+		}
+
+		history->setPinnedDialog(isPinned);
+		auto flags = MTPmessages_ToggleDialogPin::Flags(0);
+		if (isPinned) {
+			flags |= MTPmessages_ToggleDialogPin::Flag::f_pinned;
+		}
+		MTP::send(MTPmessages_ToggleDialogPin(MTP_flags(flags), peer->input));
+		if (isPinned) {
+			if (auto main = App::main()) {
+				main->dialogsToUp();
+			}
+		}
+	};
+	auto pinAction = _callback(pinText(isPinned), pinToggle);
+
+	auto lifetime = Notify::PeerUpdateViewer(
+		peer,
+		Notify::PeerUpdate::Flag::PinnedChanged)
+		| rpl::start_with_next([peer, pinAction, pinText] {
+			auto isPinned = App::history(peer)->isPinnedDialog();
+			pinAction->setText(pinText(isPinned));
+		});
+
+	Ui::AttachAsChild(pinAction, std::move(lifetime));
+}
+
+void Filler::addInfo() {
+	auto infoKey = (_peer->isChat() || _peer->isMegagroup())
+		? lng_context_view_group
+		: (_peer->isUser()
+			? lng_context_view_profile
+			: lng_context_view_channel);
+	_callback(lang(infoKey), [peer = _peer] {
+		Ui::showPeerProfile(peer);
+	});
+}
+
+void Filler::addNotifications() {
+	auto peer = _peer;
+	auto muteText = [](bool isMuted) {
+		return lang(isMuted
+			? lng_enable_notifications_from_tray
+			: lng_disable_notifications_from_tray);
+	};
+	auto muteAction = _callback(muteText(peer->isMuted()), [peer] {
+		if (!peer->isMuted()) {
+			Ui::show(Box<MuteSettingsBox>(peer));
+		} else {
+			App::main()->updateNotifySetting(
+				peer,
+				NotifySettingSetNotify);
+		}
+	});
+
+	auto lifetime = Notify::PeerUpdateViewer(
+		_peer,
+		Notify::PeerUpdate::Flag::NotificationsEnabled)
+		| rpl::start_with_next([=] {
+			muteAction->setText(muteText(peer->isMuted()));
+		});
+
+	Ui::AttachAsChild(muteAction, std::move(lifetime));
+}
+
+void Filler::addSearch() {
+	_callback(lang(lng_profile_search_messages), [peer = _peer] {
+		App::main()->searchInPeer(peer);
+	});
+}
+
+void Filler::addBlockUser(not_null<UserData*> user) {
+	auto blockText = [](not_null<UserData*> user) {
+		return lang(user->isBlocked()
+			? (user->botInfo
+				? lng_profile_unblock_bot
+				: lng_profile_unblock_user)
+			: (user->botInfo
+				? lng_profile_block_bot
+				: lng_profile_block_user));
+	};
+	auto blockAction = _callback(blockText(user), [user] {
+		auto willBeBlocked = !user->isBlocked();
+		auto handler = ::rpcDone([user, willBeBlocked](const MTPBool &result) {
+			user->setBlockStatus(willBeBlocked
+				? UserData::BlockStatus::Blocked
+				: UserData::BlockStatus::NotBlocked);
+		});
+		if (willBeBlocked) {
+			MTP::send(
+				MTPcontacts_Block(user->inputUser),
+				std::move(handler));
+		} else {
+			MTP::send(
+				MTPcontacts_Unblock(user->inputUser),
+				std::move(handler));
+		}
+	});
+
+	auto lifetime = Notify::PeerUpdateViewer(
+		_peer,
+		Notify::PeerUpdate::Flag::UserIsBlocked)
+		| rpl::start_with_next([=] {
+			blockAction->setText(blockText(user));
+		});
+
+	Ui::AttachAsChild(blockAction, std::move(lifetime));
+
+	if (user->blockStatus() == UserData::BlockStatus::Unknown) {
+		Auth().api().requestFullPeer(user);
+	}
+}
+
+void Filler::addUserActions(not_null<UserData*> user) {
+	if (user->isContact()) {
+		// edit contact
+		// share contact
+	} else if (user->canShareThisContact()) {
+		// add contact
+		// share contact
+	}
+	_callback(
+		lang(lng_profile_delete_conversation),
+		DeleteAndLeaveHandler(user));
+	_callback(
+		lang(lng_profile_clear_history),
+		ClearHistoryHandler(user));
+	if (!user->isInaccessible() && user != App::self()) {
+		addBlockUser(user);
+	}
+}
+
+void Filler::addChatActions(not_null<ChatData*> chat) {
+	_callback(
+		lang(lng_profile_clear_and_exit),
+		DeleteAndLeaveHandler(_peer));
+	_callback(
+		lang(lng_profile_clear_history),
+		ClearHistoryHandler(_peer));
+}
+
+void Filler::addChannelActions(not_null<ChannelData*> channel) {
+	if (channel->amIn() && !channel->amCreator()) {
+		auto leaveText = lang(channel->isMegagroup()
+			? lng_profile_leave_group
+			: lng_profile_leave_channel);
+		_callback(leaveText, DeleteAndLeaveHandler(channel));
+	}
+}
+
+void Filler::fill() {
+	if (_options.pinToggle) {
+		addPinToggle();
+	}
+	if (_options.showInfo) {
+		addInfo();
+	}
+	addNotifications();
+	if (_options.search) {
+		addSearch();
+	}
+
+	if (auto user = _peer->asUser()) {
+		addUserActions(user);
+	} else if (auto chat = _peer->asChat()) {
+		addChatActions(chat);
+	} else if (auto channel = _peer->asChannel()) {
+		addChannelActions(channel);
+	}
+}
+
+} // namespace
+
+void FillPeerMenu(
+		not_null<PeerData*> peer,
+		const PeerMenuCallback &callback,
+		const PeerMenuOptions &options) {
+	Filler filler(peer, callback, options);
+	filler.fill();
+}
+
+} // namespace Window

Telegram/SourceFiles/window/window_peer_menu.h

@@ -0,0 +1,40 @@
+/*
+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-2017 John Preston, https://desktop.telegram.org
+*/
+#pragma once
+
+namespace Window {
+
+struct PeerMenuOptions {
+	bool pinToggle = false;
+	bool showInfo = false;
+	bool search = false;
+};
+
+using PeerMenuCallback = base::lambda<QAction*(
+	const QString &text,
+	base::lambda<void()> handler)>;
+
+void FillPeerMenu(
+	not_null<PeerData*> peer,
+	const PeerMenuCallback &callback,
+	const PeerMenuOptions &options);
+
+} // namespace Window

Telegram/gyp/telegram_sources.txt

@@ -631,6 +631,8 @@
 <(src_loc)/window/window_controller.h
 <(src_loc)/window/window_main_menu.cpp
 <(src_loc)/window/window_main_menu.h
+<(src_loc)/window/window_peer_menu.cpp
+<(src_loc)/window/window_peer_menu.h
 <(src_loc)/window/window_slide_animation.cpp
 <(src_loc)/window/window_slide_animation.h
 <(src_loc)/window/window_title.h