Info shared media and common groups counters.

Telegram/Resources/langs/lang.strings

@@ -599,6 +599,8 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 "lng_profile_files_header" = "Files";
 "lng_profile_audios#one" = "{count} voice message";
 "lng_profile_audios#other" = "{count} voice messages";
+"lng_profile_rounds#one" = "{count} video message";
+"lng_profile_rounds#other" = "{count} video messages";
 "lng_profile_audios_header" = "Voice messages";
 "lng_profile_shared_links#one" = "{count} shared link";
 "lng_profile_shared_links#other" = "{count} shared links";

Telegram/SourceFiles/apiwrap.cpp

@@ -286,6 +286,7 @@ void ApiWrap::gotChatFull(PeerData *peer, const MTPmessages_ChatFull &result, mt
 	App::feedUsers(d.vusers);
 	App::feedChats(d.vchats);
 
+	using UpdateFlag = Notify::PeerUpdate::Flag;
 	if (auto chat = peer->asChat()) {
 		if (d.vfull_chat.type() != mtpc_chatFull) {
 			LOG(("MTP Error: bad type in gotChatFull for chat: %1").arg(d.vfull_chat.type()));
@@ -305,11 +306,14 @@ void ApiWrap::gotChatFull(PeerData *peer, const MTPmessages_ChatFull &result, mt
 			} break;
 			}
 		}
+		auto newPhotoId = 0;
 		if (auto photo = App::feedPhoto(f.vchat_photo)) {
-			chat->photoId = photo->id;
+			newPhotoId = photo->id;
 			photo->peer = chat;
-		} else {
-			chat->photoId = 0;
+		}
+		if (chat->photoId != newPhotoId) {
+			chat->photoId = newPhotoId;
+			Notify::peerUpdatedDelayed(chat, UpdateFlag::PhotoChanged);
 		}
 		chat->setInviteLink((f.vexported_invite.type() == mtpc_chatInviteExported) ? qs(f.vexported_invite.c_chatInviteExported().vlink) : QString());
 		chat->fullUpdated();
@@ -327,11 +331,14 @@ void ApiWrap::gotChatFull(PeerData *peer, const MTPmessages_ChatFull &result, mt
 		auto canEditStickers = channel->canEditStickers();
 
 		channel->flagsFull = f.vflags.v;
+		auto newPhotoId = 0;
 		if (auto photo = App::feedPhoto(f.vchat_photo)) {
-			channel->photoId = photo->id;
+			newPhotoId = photo->id;
 			photo->peer = channel;
-		} else {
-			channel->photoId = 0;
+		}
+		if (channel->photoId != newPhotoId) {
+			channel->photoId = newPhotoId;
+			Notify::peerUpdatedDelayed(channel, UpdateFlag::PhotoChanged);
 		}
 		if (f.has_migrated_from_chat_id()) {
 			if (!channel->mgInfo) {
@@ -402,14 +409,14 @@ void ApiWrap::gotChatFull(PeerData *peer, const MTPmessages_ChatFull &result, mt
 				stickersChanged = true;
 			}
 			if (stickersChanged) {
-				Notify::peerUpdatedDelayed(channel, Notify::PeerUpdate::Flag::ChannelStickersChanged);
+				Notify::peerUpdatedDelayed(channel, UpdateFlag::ChannelStickersChanged);
 			}
 		}
 		channel->fullUpdated();
 
 		if (canViewAdmins != channel->canViewAdmins()
 			|| canViewMembers != channel->canViewMembers()) {
-			Notify::peerUpdatedDelayed(channel, Notify::PeerUpdate::Flag::ChannelRightsChanged);
+			Notify::peerUpdatedDelayed(channel, UpdateFlag::ChannelRightsChanged);
 		}
 
 		notifySettingReceived(MTP_inputNotifyPeer(peer->input), f.vnotify_settings);

Telegram/SourceFiles/boxes/boxes.style

@@ -627,6 +627,7 @@ adminLogFilterCheckbox: Checkbox(defaultBoxCheckbox) {
 adminLogFilterSkip: 32px;
 adminLogFilterUserCheckbox: Checkbox(defaultBoxCheckbox) {
 	margin: margins(8px, 6px, 8px, 6px);
+	checkPosition: point(8px, 6px);
 }
 
 rightsCheckbox: Checkbox(defaultBoxCheckbox) {

Telegram/SourceFiles/history/history_shared_media.cpp

@@ -91,6 +91,8 @@ private:
 		After,
 	};
 	void requestMessages(RequestDirection direction);
+	void requestMessagesCount();
+	void fillSkippedAndSliceToLimits();
 	void sliceToLimits();
 
 	void mergeSliceData(
@@ -244,11 +246,15 @@ bool SharedMediaSliceBuilder::applyUpdate(const SliceUpdate &update) {
 		return false;
 	}
 	auto intersects = [](MsgRange range1, MsgRange range2) {
-		return (range1.from <= range2.till) && (range2.from <= range1.till);
+		return (range1.from <= range2.till)
+			&& (range2.from <= range1.till);
 	};
-	if (!intersects(update.range, {
-		_ids.empty() ? _key.messageId : _ids.front(),
-		_ids.empty() ? _key.messageId : _ids.back() })) {
+	auto needMergeMessages = (update.messages != nullptr)
+		&& intersects(update.range, {
+			_ids.empty() ? _key.messageId : _ids.front(),
+			_ids.empty() ? _key.messageId : _ids.back()
+		});
+	if (!needMergeMessages && !update.count) {
 		return false;
 	}
 	auto skippedBefore = (update.range.from == 0)
@@ -259,7 +265,9 @@ bool SharedMediaSliceBuilder::applyUpdate(const SliceUpdate &update) {
 		: base::optional<int> {};
 	mergeSliceData(
 		update.count,
-		update.messages ? *update.messages : base::flat_set<MsgId> {},
+		needMergeMessages
+			? *update.messages
+			: base::flat_set<MsgId> {},
 		skippedBefore,
 		skippedAfter);
 	return true;
@@ -322,7 +330,7 @@ void SharedMediaSliceBuilder::mergeSliceData(
 				_skippedBefore = _skippedAfter = 0;
 			}
 		}
-		sliceToLimits();
+		fillSkippedAndSliceToLimits();
 		return;
 	}
 	if (count) {
@@ -359,7 +367,10 @@ void SharedMediaSliceBuilder::mergeSliceData(
 	} else {
 		_skippedAfter = base::none;
 	}
+	fillSkippedAndSliceToLimits();
+}
 
+void SharedMediaSliceBuilder::fillSkippedAndSliceToLimits() {
 	if (_fullCount) {
 		if (_skippedBefore && !_skippedAfter) {
 			_skippedAfter = *_fullCount
@@ -371,11 +382,17 @@ void SharedMediaSliceBuilder::mergeSliceData(
 				- int(_ids.size());
 		}
 	}
-
 	sliceToLimits();
 }
 
 void SharedMediaSliceBuilder::sliceToLimits() {
+	if (!_key.messageId) {
+		if (!_fullCount) {
+			requestMessagesCount();
+		}
+		return;
+	}
+	auto requestedSomething = false;
 	auto aroundIt = base::lower_bound(_ids, _key.messageId);
 	auto removeFromBegin = (aroundIt - _ids.begin() - _limitBefore);
 	auto removeFromEnd = (_ids.end() - aroundIt - _limitAfter - 1);
@@ -384,7 +401,9 @@ void SharedMediaSliceBuilder::sliceToLimits() {
 		if (_skippedBefore) {
 			*_skippedBefore += removeFromBegin;
 		}
-	} else if (removeFromBegin < 0 && (!_skippedBefore || *_skippedBefore > 0)) {
+	} else if (removeFromBegin < 0
+		&& (!_skippedBefore || *_skippedBefore > 0)) {
+		requestedSomething = true;
 		requestMessages(RequestDirection::Before);
 	}
 	if (removeFromEnd > 0) {
@@ -392,12 +411,18 @@ void SharedMediaSliceBuilder::sliceToLimits() {
 		if (_skippedAfter) {
 			*_skippedAfter += removeFromEnd;
 		}
-	} else if (removeFromEnd < 0 && (!_skippedAfter || *_skippedAfter > 0)) {
+	} else if (removeFromEnd < 0
+		&& (!_skippedAfter || *_skippedAfter > 0)) {
+		requestedSomething = true;
 		requestMessages(RequestDirection::After);
 	}
+	if (!_fullCount && !requestedSomething) {
+		requestMessagesCount();
+	}
 }
 
-void SharedMediaSliceBuilder::requestMessages(RequestDirection direction) {
+void SharedMediaSliceBuilder::requestMessages(
+		RequestDirection direction) {
 	using SliceType = ApiWrap::SliceType;
 	auto requestAroundData = [&]() -> AroundData {
 		if (_ids.empty()) {
@@ -410,6 +435,10 @@ void SharedMediaSliceBuilder::requestMessages(RequestDirection direction) {
 	_insufficientMediaAround.fire(requestAroundData());
 }
 
+void SharedMediaSliceBuilder::requestMessagesCount() {
+	_insufficientMediaAround.fire({ 0, ApiWrap::SliceType::Around });
+}
+
 SharedMediaSlice SharedMediaSliceBuilder::snapshot() const {
 	return SharedMediaSlice(
 		_key,

Telegram/SourceFiles/info/info.style

@@ -23,6 +23,30 @@ using "basic.style";
 using "boxes/boxes.style";
 using "ui/widgets/widgets.style";
 
+InfoToggle {
+	color: color;
+	duration: int;
+	size: pixels;
+	skip: pixels;
+	stroke: pixels;
+	rippleAreaPadding: pixels;
+}
+
+infoToggleCheckbox: Checkbox(defaultCheckbox) {
+	margin: margins(0px, 0px, 0px, 0px);
+	rippleBgActive: windowBgOver;
+	checkPosition: point(16px, 8px);
+	rippleAreaPosition: point(-8px, -8px);
+}
+infoToggle: InfoToggle {
+	color: menuIconFg;
+	duration: slideWrapDuration;
+	size: 24px;
+	skip: 5px;
+	stroke: 2px;
+	rippleAreaPadding: 8px;
+}
+
 infoScroll: ScrollArea(defaultScrollArea) {
 	bottomsh: 0px;
 	topsh: 0px;
@@ -85,27 +109,11 @@ infoProfilePhotoLeft: 19px;
 infoProfilePhotoTop: 18px;
 infoProfilePhotoBottom: 18px;
 
-infoProfileNameLeft: 109px;
-infoProfileNameRight: 20px;
-infoProfileNameTop: 32px;
-infoProfileNameLabel: FlatLabel(defaultFlatLabel) {
-	margin: margins(10px, 5px, 10px, 5px);
-	width: 160px;
-	maxHeight: 24px;
-	textFg: windowBoldFg;
-	style: TextStyle(defaultTextStyle) {
-		font: font(16px semibold);
-		linkFont: font(16px semibold);
-		linkFontOver: font(16px semibold underline);
-	}
-}
-
-infoProfileStatusLeft: infoProfileNameLeft;
-infoProfileStatusRight: infoProfileNameRight;
+infoProfileStatusLeft: 109px;
+infoProfileStatusRight: 20px;
 infoProfileStatusTop: 58px;
-infoProfileStatusLabel: FlatLabel(infoProfileNameLabel) {
-	margin: margins(10px, 5px, 10px, 5px);
-	width: 160px;
+infoProfileStatusLabel: FlatLabel(defaultFlatLabel) {
+	width: 0px;
 	maxHeight: 18px;
 	textFg: windowSubTextFg;
 	style: TextStyle(defaultTextStyle) {
@@ -118,8 +126,18 @@ infoProfileStatusLabel: FlatLabel(infoProfileNameLabel) {
 	}
 }
 
-infoProfileToggleRight: 12px;
-infoProfileToggleTop: 40px;
+infoProfileNameLeft: infoProfileStatusLeft;
+infoProfileNameRight: infoProfileStatusRight;
+infoProfileNameTop: 32px;
+infoProfileNameLabel: FlatLabel(infoProfileStatusLabel) {
+	maxHeight: 24px;
+	textFg: windowBoldFg;
+	style: TextStyle(defaultTextStyle) {
+		font: font(16px semibold);
+		linkFont: font(16px semibold);
+		linkFontOver: font(16px semibold underline);
+	}
+}
 
 infoProfileSkip: 12px;
 
@@ -131,11 +149,15 @@ infoProfileSeparatorPadding: margins(
 	infoProfileSkip);
 
 infoIconFg: menuIconFg;
-infoIconPosition: point(25px, 12px);
+infoIconPosition: point(20px, 12px);
 infoIconInformation: icon {{ "info_information", infoIconFg }};
 infoIconMembers: icon {{ "info_members", infoIconFg }};
 infoIconNotifications: icon {{ "info_notifications", infoIconFg }};
 infoIconActions: icon {{ "info_actions", infoIconFg }};
+infoIconMediaPhoto: icon {{ "info_media_photo", infoIconFg }};
+infoInformationIconPosition: point(25px, 12px);
+infoNotificationsIconPosition: point(20px, 5px);
+infoSharedMediaIconPosition: point(20px, 24px);
 
 infoLabeledOneLine: FlatLabel(defaultFlatLabel) {
 	width: 0px; // No need to set minWidth in one-line text.
@@ -182,8 +204,19 @@ infoProfileButton: InfoProfileButton {
 infoNotificationsButton: InfoProfileButton(infoProfileButton) {
 	padding: margins(79px, 13px, 8px, 9px);
 }
-infoNotificationsIconPosition: point(20px, 5px);
 infoMainButton: InfoProfileButton(infoProfileButton) {
 	textFg: lightButtonFg;
 	textFgOver: lightButtonFgOver;
 }
+infoSharedMediaCoverHeight: 62px;
+infoSharedMediaLabelPosition: point(79px, 22px);
+infoSharedMediaLabel: FlatLabel(infoProfileStatusLabel) {
+	textFg: windowBoldFg;
+	style: TextStyle(defaultTextStyle) {
+		font: semiboldFont;
+		linkFont: semiboldFont;
+		linkFontOver: semiboldFont;
+	}
+}
+infoSharedMediaButton: infoProfileButton;
+infoSharedMediaBottomSkip: 12px;

Telegram/SourceFiles/info/info_profile_inner_widget.cpp

@@ -21,12 +21,15 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #include "info/info_profile_inner_widget.h"
 
 #include <rpl/combine.h>
+#include <rpl/range.h>
+#include <rpl/then.h>
 #include "boxes/abstract_box.h"
 #include "boxes/add_contact_box.h"
 #include "mainwidget.h"
 #include "info/info_profile_widget.h"
 #include "info/info_profile_lines.h"
 #include "window/window_controller.h"
+#include "storage/storage_shared_media.h"
 #include "lang/lang_keys.h"
 #include "styles/style_info.h"
 #include "ui/widgets/buttons.h"
@@ -46,24 +49,37 @@ InnerWidget::InnerWidget(
 	setupContent();
 }
 
+bool InnerWidget::canHideDetailsEver() const {
+	return (_peer->isChat() || _peer->isMegagroup());
+}
+
+rpl::producer<bool> InnerWidget::canHideDetails() const {
+	using namespace rpl::mappers;
+	return MembersCountViewer(_peer)
+		| rpl::map($1 > 0);
+}
+
 void InnerWidget::setupContent() {
-	auto hideDetails = (_peer->isChat() || _peer->isMegagroup());
-	auto cover = _content->add(object_ptr<CoverLine>(this, _peer));
-	if (hideDetails) {
-		auto hiddenDetailsContent = setupDetailsContent(_content);
-		auto hiddenDetails = _content->add(object_ptr<Ui::SlideWrap<>>(
+	auto cover = _content->add(object_ptr<Cover>(
+		this,
+		_peer)
+	);
+	cover->setOnlineCount(rpl::single(0));
+	auto details = setupDetails(_content);
+	if (canHideDetailsEver()) {
+		cover->setToggleShown(canHideDetails());
+		_content->add(object_ptr<Ui::SlideWrap<>>(
 			this,
-			std::move(hiddenDetailsContent)));
-		cover->setHasToggle(true);
-		cover->toggled()
-		| rpl::start([=](bool expanded) {
-			hiddenDetails->toggleAnimated(expanded);
-		}, _lifetime);
-		hiddenDetails->hideFast();
+			std::move(details))
+		)->toggleOn(cover->toggledValue());
 	} else {
-		_content->add(setupDetailsContent(_content));
+		_content->add(std::move(details));
 	}
+	_content->add(setupSharedMedia(_content));
 	_content->add(object_ptr<BoxContentDivider>(this));
+	if (auto user = _peer->asUser()) {
+		_content->add(setupUserActions(_content, user));
+	}
 
 	_content->heightValue()
 		| rpl::start([this](int height) {
@@ -71,104 +87,25 @@ void InnerWidget::setupContent() {
 		}, _lifetime);
 }
 
-object_ptr<Ui::RpWidget> InnerWidget::setupDetailsContent(
+object_ptr<Ui::RpWidget> InnerWidget::setupDetails(
 		RpWidget *parent) const {
 	auto result = object_ptr<Ui::VerticalLayout>(parent);
-
 	result->add(object_ptr<BoxContentDivider>(result));
 	result->add(createSkipWidget(result));
-	result->add(setupInfoLines(result));
+	result->add(setupInfo(result));
 	result->add(setupMuteToggle(result));
 	if (auto user = _peer->asUser()) {
-		setupMainUserButtons(result, user);
+		setupUserButtons(result, user);
+	//} else if (auto channel = _peer->asChannel()) {
+	//	if (!channel->isMegagroup()) {
+	//		setupChannelButtons(result, channel);
+	//	}
 	}
 	result->add(createSkipWidget(result));
-
 	return std::move(result);
 }
 
-object_ptr<Ui::RpWidget> InnerWidget::setupMuteToggle(
-		RpWidget *parent) const {
-	auto result = object_ptr<Ui::VerticalLayout>(parent);
-	auto button = result->add(object_ptr<Button>(
-		result,
-		Lang::Viewer(lng_profile_enable_notifications),
-		st::infoNotificationsButton));
-	NotificationsEnabledViewer(_peer)
-		| rpl::start([button](bool enabled) {
-			button->setToggled(enabled);
-		}, button->lifetime());
-	button->clicks()
-		| rpl::start([this](auto) {
-			App::main()->updateNotifySetting(
-				_peer,
-				_peer->isMuted()
-					? NotifySettingSetNotify
-					: NotifySettingSetMuted);
-		}, button->lifetime());
-
-	object_ptr<FloatingIcon>(
-		result,
-		st::infoIconNotifications,
-		st::infoNotificationsIconPosition);
-	return std::move(result);
-}
-
-void InnerWidget::setupMainUserButtons(
-		Ui::VerticalLayout *wrap,
-		not_null<UserData*> user) const {
-	auto tracker = MultiLineTracker();
-	auto topSkip = wrap->add(createSlideSkipWidget(wrap));
-	auto addButton = [&](rpl::producer<QString> &&text) {
-		auto result = wrap->add(object_ptr<Ui::SlideWrap<Button>>(
-			wrap,
-			object_ptr<Button>(
-				wrap,
-				std::move(text),
-				st::infoMainButton)));
-		tracker.track(result);
-		return result;
-	};
-	auto sendMessage = addButton(
-		Lang::Viewer(lng_profile_send_message) | ToUpperValue());
-	_controller->historyPeer.value()
-		| rpl::map([user](PeerData *peer) { return peer == user; })
-		| rpl::start([sendMessage](bool peerHistoryShown) {
-			sendMessage->toggleAnimated(!peerHistoryShown);
-		}, sendMessage->lifetime());
-	sendMessage->entity()->clicks()
-		| rpl::start([this, user](auto&&) {
-			_controller->showPeerHistory(
-				user,
-				Ui::ShowWay::Forward);
-		}, sendMessage->lifetime());
-	sendMessage->finishAnimations();
-
-	auto addContact = addButton(
-		Lang::Viewer(lng_info_add_as_contact) | ToUpperValue());
-	CanAddContactViewer(user)
-		| rpl::start([addContact](bool canAdd) {
-			addContact->toggleAnimated(canAdd);
-		}, addContact->lifetime());
-	addContact->finishAnimations();
-	addContact->entity()->clicks()
-		| rpl::start([user](auto&&) {
-			auto firstName = user->firstName;
-			auto lastName = user->lastName;
-			auto phone = user->phone().isEmpty()
-				? App::phoneFromSharedContact(user->bareId())
-				: user->phone();
-			Ui::show(Box<AddContactBox>(firstName, lastName, phone));
-		}, addContact->lifetime());
-
-	std::move(tracker).atLeastOneShownValue()
-		| rpl::start([topSkip](bool someShown) {
-			topSkip->toggleAnimated(someShown);
-		}, topSkip->lifetime());
-	topSkip->finishAnimations();
-}
-
-object_ptr<Ui::RpWidget> InnerWidget::setupInfoLines(
+object_ptr<Ui::RpWidget> InnerWidget::setupInfo(
 		RpWidget *parent) const {
 	auto result = object_ptr<Ui::VerticalLayout>(parent);
 	auto tracker = MultiLineTracker();
@@ -204,18 +141,202 @@ object_ptr<Ui::RpWidget> InnerWidget::setupInfoLines(
 		addInfoOneLine(lng_info_link_label, LinkViewer(_peer));
 		addInfoLine(lng_info_about_label, AboutViewer(_peer));
 	}
-	auto separator = result->add(object_ptr<Ui::SlideWrap<>>(
+	result->add(object_ptr<Ui::SlideWrap<>>(
 		result,
 		object_ptr<Ui::PlainShadow>(result, st::shadowFg),
-		st::infoProfileSeparatorPadding));
-	std::move(tracker).atLeastOneShownValue()
-		| rpl::start([separator](bool someShown) {
-			separator->toggleAnimated(someShown);
-		}, separator->lifetime());
-	separator->finishAnimations();
+		st::infoProfileSeparatorPadding)
+	)->toggleOn(std::move(tracker).atLeastOneShownValue());
+	object_ptr<FloatingIcon>(
+		result,
+		st::infoIconInformation,
+		st::infoInformationIconPosition);
+	return std::move(result);
+}
 
-	object_ptr<FloatingIcon>(result, st::infoIconInformation);
+object_ptr<Ui::RpWidget> InnerWidget::setupMuteToggle(
+		RpWidget *parent) const {
+	auto result = object_ptr<Button>(
+		parent,
+		Lang::Viewer(lng_profile_enable_notifications),
+		st::infoNotificationsButton);
+	result->toggleOn(
+		NotificationsEnabledViewer(_peer)
+	)->clicks()
+		| rpl::start([this](auto) {
+			App::main()->updateNotifySetting(
+				_peer,
+				_peer->isMuted()
+					? NotifySettingSetNotify
+					: NotifySettingSetMuted);
+		}, result->lifetime());
+	object_ptr<FloatingIcon>(
+		result,
+		st::infoIconNotifications,
+		st::infoNotificationsIconPosition);
+	return std::move(result);
+}
 
+void InnerWidget::setupUserButtons(
+		Ui::VerticalLayout *wrap,
+		not_null<UserData*> user) const {
+	using namespace rpl::mappers;
+	auto tracker = MultiLineTracker();
+	auto topSkip = wrap->add(createSlideSkipWidget(wrap));
+	auto addButton = [&](rpl::producer<QString> &&text) {
+		auto result = wrap->add(object_ptr<Ui::SlideWrap<Button>>(
+			wrap,
+			object_ptr<Button>(
+				wrap,
+				std::move(text),
+				st::infoMainButton)));
+		tracker.track(result);
+		return result;
+	};
+	addButton(
+		Lang::Viewer(lng_profile_send_message) | ToUpperValue()
+	)->toggleOn(
+		_controller->historyPeer.value()
+		| rpl::map($1 != user)
+	)->entity()->clicks()
+		| rpl::start([this, user](auto&&) {
+			_controller->showPeerHistory(
+				user,
+				Ui::ShowWay::Forward);
+		}, wrap->lifetime());
+
+	addButton(
+		Lang::Viewer(lng_info_add_as_contact) | ToUpperValue()
+	)->toggleOn(
+		CanAddContactViewer(user)
+	)->entity()->clicks()
+		| rpl::start([user](auto&&) {
+			auto firstName = user->firstName;
+			auto lastName = user->lastName;
+			auto phone = user->phone().isEmpty()
+				? App::phoneFromSharedContact(user->bareId())
+				: user->phone();
+			Ui::show(Box<AddContactBox>(firstName, lastName, phone));
+		}, wrap->lifetime());
+
+	topSkip->toggleOn(std::move(tracker).atLeastOneShownValue());
+}
+
+object_ptr<Ui::RpWidget> InnerWidget::setupSharedMedia(
+		RpWidget *parent) const {
+	using namespace rpl::mappers;
+
+	auto content = object_ptr<Ui::VerticalLayout>(parent);
+	auto tracker = MultiLineTracker();
+	auto addButton = [&](
+			rpl::producer<int> &&count,
+			auto textFromCount) {
+		auto forked = rpl::single(0)
+			| rpl::then(std::move(count))
+			| start_spawning(content->lifetime());
+		auto button = content->add(object_ptr<Ui::SlideWrap<Button>>(
+			content,
+			object_ptr<Button>(
+				content,
+				rpl::duplicate(forked)
+					| rpl::map([textFromCount](int count) {
+						return (count > 0)
+							? textFromCount(count)
+							: QString();
+					}),
+				st::infoSharedMediaButton))
+		)->toggleOn(
+			rpl::duplicate(forked)
+				| rpl::map($1 > 0));
+		tracker.track(button);
+		return button;
+	};
+	using MediaType = Storage::SharedMediaType;
+	auto mediaText = [](MediaType type) {
+		switch (type) {
+		case MediaType::Photo: return lng_profile_photos;
+		case MediaType::Video: return lng_profile_videos;
+		case MediaType::File: return lng_profile_files;
+		case MediaType::MusicFile: return lng_profile_songs;
+		case MediaType::Link: return lng_profile_shared_links;
+		case MediaType::VoiceFile: return lng_profile_audios;
+		case MediaType::RoundFile: return lng_profile_rounds;
+		}
+		Unexpected("Type in setupSharedMedia()");
+	};
+	auto addMediaButton = [&](MediaType type) {
+		return addButton(
+			SharedMediaCountViewer(_peer, type),
+			[phrase = mediaText(type)](int count) {
+				return phrase(lt_count, count);
+			});
+	};
+	auto addCommonGroupsButton = [&](not_null<UserData*> user) {
+		return addButton(
+			CommonGroupsCountViewer(user),
+			[](int count) {
+				return lng_profile_common_groups(lt_count, count);
+			});
+	};
+	addMediaButton(MediaType::Photo);
+	addMediaButton(MediaType::Video);
+	addMediaButton(MediaType::File);
+	addMediaButton(MediaType::MusicFile);
+	addMediaButton(MediaType::Link);
+	if (auto user = _peer->asUser()) {
+		addCommonGroupsButton(user);
+	}
+	addMediaButton(MediaType::VoiceFile);
+	addMediaButton(MediaType::RoundFile);
+
+	auto result = object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
+		parent,
+		object_ptr<Ui::VerticalLayout>(parent)
+	);
+	result->toggleOn(tracker.atLeastOneShownValue());
+	auto layout = result->entity();
+
+	layout->add(object_ptr<BoxContentDivider>(result));
+	auto cover = layout->add(object_ptr<SharedMediaCover>(layout));
+	if (canHideDetailsEver()) {
+		cover->setToggleShown(canHideDetails());
+		layout->add(object_ptr<Ui::SlideWrap<>>(
+			layout,
+			std::move(content))
+		)->toggleOn(cover->toggledValue());
+	} else {
+		layout->add(std::move(content));
+	}
+	layout->add(object_ptr<Ui::FixedHeightWidget>(
+		layout,
+		st::infoSharedMediaBottomSkip)
+	)->setAttribute(Qt::WA_TransparentForMouseEvents);
+	object_ptr<FloatingIcon>(
+		result,
+		st::infoIconMediaPhoto,
+		st::infoSharedMediaIconPosition);
+	return std::move(result);
+}
+
+object_ptr<Ui::RpWidget> InnerWidget::setupUserActions(
+		RpWidget *parent,
+		not_null<UserData*> user) const {
+	auto result = object_ptr<Ui::VerticalLayout>(parent);
+	auto tracker = MultiLineTracker();
+	auto addButton = [&](rpl::producer<QString> &&text) {
+		auto button = result->add(object_ptr<Ui::SlideWrap<Button>>(
+			result,
+			object_ptr<Button>(
+				result,
+				std::move(text),
+				st::infoSharedMediaButton)));
+		tracker.track(button);
+		return button;
+	};
+	addButton(rpl::single(QString("test action")));
+	object_ptr<FloatingIcon>(
+		result,
+		st::infoIconActions,
+		st::infoIconPosition);
 	return std::move(result);
 }
 

Telegram/SourceFiles/info/info_profile_inner_widget.h

@@ -65,16 +65,24 @@ protected:
 
 private:
 	void setupContent();
-	object_ptr<RpWidget> setupDetailsContent(RpWidget *parent) const;
+	object_ptr<RpWidget> setupDetails(RpWidget *parent) const;
+	object_ptr<RpWidget> setupSharedMedia(RpWidget *parent) const;
 	object_ptr<RpWidget> setupMuteToggle(RpWidget *parent) const;
-	object_ptr<RpWidget> setupInfoLines(RpWidget *parent) const;
-	void setupMainUserButtons(
+	object_ptr<RpWidget> setupInfo(RpWidget *parent) const;
+	void setupUserButtons(
 		Ui::VerticalLayout *wrap,
 		not_null<UserData*> user) const;
+	object_ptr<RpWidget> setupUserActions(
+		RpWidget *parent,
+		not_null<UserData*> user) const;
+
 	object_ptr<RpWidget> createSkipWidget(RpWidget *parent) const;
 	object_ptr<Ui::SlideWrap<RpWidget>> createSlideSkipWidget(
 		RpWidget *parent) const;
 
+	bool canHideDetailsEver() const;
+	rpl::producer<bool> canHideDetails() const;
+
 	not_null<Window::Controller*> _controller;
 	not_null<PeerData*> _peer;
 

Telegram/SourceFiles/info/info_profile_lines.cpp

@@ -27,12 +27,14 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #include <rpl/combine.h>
 #include "styles/style_info.h"
 #include "profile/profile_userpic_button.h"
+#include "history/history_shared_media.h"
 #include "observer_peer.h"
 #include "auth_session.h"
 #include "apiwrap.h"
 #include "messenger.h"
 #include "ui/widgets/labels.h"
 #include "ui/widgets/checkbox.h"
+#include "ui/effects/ripple_animation.h"
 #include "lang/lang_keys.h"
 
 namespace Info {
@@ -190,37 +192,72 @@ rpl::producer<bool> CanAddContactViewer(
 			!$1 && $2);
 }
 
-FloatingIcon::FloatingIcon(
-	QWidget *parent,
-	not_null<RpWidget*> above,
-	const style::icon &icon)
-: FloatingIcon(parent, above, icon, st::infoIconPosition, Tag{}) {
+rpl::producer<int> MembersCountViewer(
+		not_null<PeerData*> peer) {
+	if (auto chat = peer->asChat()) {
+		return PeerUpdateValue(
+				peer,
+				Notify::PeerUpdate::Flag::MembersChanged)
+			| rpl::map([chat](auto&&) {
+				return chat->amIn()
+					? qMax(chat->count, chat->participants.size())
+					: 0;
+			});
+	} else if (auto channel = peer->asChannel()) {
+		return PeerUpdateValue(
+				peer,
+				Notify::PeerUpdate::Flag::MembersChanged)
+			| rpl::map([channel](auto &&) {
+				auto canViewCount = channel->canViewMembers()
+					|| !channel->isMegagroup();
+				return canViewCount
+					? qMax(channel->membersCount(), 1)
+					: 0;
+			});
+	}
+	Unexpected("User in MembersCountViewer().");
+}
+
+rpl::producer<int> SharedMediaCountViewer(
+		not_null<PeerData*> peer,
+		Storage::SharedMediaType type) {
+	auto initial = peer->migrateFrom() ? peer->migrateFrom() : peer;
+	auto migrated = initial->migrateTo();
+	auto aroundId = 0;
+	auto limit = 0;
+	return SharedMediaMergedViewer(
+		SharedMediaMergedSlice::Key(
+			peer->id,
+			migrated ? migrated->id : 0,
+			type,
+			aroundId),
+		limit,
+		limit)
+		| rpl::map([](const SharedMediaMergedSlice &slice) {
+			return slice.fullCount();
+		})
+		| rpl::filter_optional();
+}
+
+rpl::producer<int> CommonGroupsCountViewer(
+		not_null<UserData*> user) {
+	return PeerUpdateValue(
+		user,
+		Notify::PeerUpdate::Flag::UserCommonChatsChanged)
+		| rpl::map([user](auto&&) {
+			return user->commonChatsCount();
+		});
 }
 
 FloatingIcon::FloatingIcon(
-	QWidget *parent,
-	not_null<RpWidget*> above,
+	RpWidget *parent,
 	const style::icon &icon,
 	QPoint position)
-: FloatingIcon(parent, above, icon, position, Tag{}) {
+: FloatingIcon(parent, icon, position, Tag{}) {
 }
 
 FloatingIcon::FloatingIcon(
-	QWidget *parent,
-	const style::icon &icon)
-: FloatingIcon(parent, nullptr, icon, st::infoIconPosition, Tag{}) {
-}
-
-FloatingIcon::FloatingIcon(
-	QWidget *parent,
-	const style::icon &icon,
-	QPoint position)
-: FloatingIcon(parent, nullptr, icon, position, Tag{}) {
-}
-
-FloatingIcon::FloatingIcon(
-	QWidget *parent,
-	RpWidget *above,
+	RpWidget *parent,
 	const style::icon &icon,
 	QPoint position,
 	const Tag &)
@@ -231,17 +268,10 @@ FloatingIcon::FloatingIcon(
 		_point.x() + _icon->width(),
 		_point.y() + _icon->height());
 	setAttribute(Qt::WA_TransparentForMouseEvents);
-	if (above) {
-		above->geometryValue()
-			| rpl::start([this](const QRect &geometry) {
-				auto topLeft = rtlpoint(
-					geometry.topLeft(),
-					parentWidget()->width());
-				moveToLeft(topLeft.x(), topLeft.y() + geometry.height());
-			}, lifetime());
-	} else {
-		moveToLeft(0, 0);
-	}
+	parent->widthValue()
+		| rpl::start(
+			[this](auto&&) { moveToLeft(0, 0); },
+			lifetime());
 }
 
 void FloatingIcon::paintEvent(QPaintEvent *e) {
@@ -301,8 +331,12 @@ LabeledLine::LabeledLine(
 	finishAnimations();
 };
 
-CoverLine::CoverLine(QWidget *parent, not_null<PeerData*> peer)
-: RpWidget(parent)
+Cover::Cover(QWidget *parent, not_null<PeerData*> peer)
+: FixedHeightWidget(
+	parent,
+	st::infoProfilePhotoTop
+		+ st::infoProfilePhotoSize
+		+ st::infoProfilePhotoBottom)
 , _peer(peer)
 , _userpic(this, _peer, st::infoProfilePhotoSize)
 , _name(this, st::infoProfileNameLabel)
@@ -316,39 +350,72 @@ CoverLine::CoverLine(QWidget *parent, not_null<PeerData*> peer)
 	initUserpicButton();
 	refreshNameText();
 	refreshStatusText();
+	setupChildGeometry();
 }
 
-void CoverLine::setOnlineCount(int onlineCount) {
-	_onlineCount = onlineCount;
-	refreshStatusText();
+void Cover::setupChildGeometry() {
+	widthValue()
+		| rpl::start([this](int newWidth) {
+			_userpic->moveToLeft(
+				st::infoProfilePhotoLeft,
+				st::infoProfilePhotoTop,
+				newWidth);
+			refreshNameGeometry(newWidth);
+			refreshStatusGeometry(newWidth);
+		}, lifetime());
 }
 
-void CoverLine::setHasToggle(bool hasToggle) {
-	if (hasToggle && !_toggle) {
-		_toggle.create(this, QString());
-	} else if (!hasToggle && _toggle) {
-		_toggle.destroy();
-	}
+Cover *Cover::setOnlineCount(rpl::producer<int> &&count) {
+	std::move(count)
+		| rpl::start([this](int count) {
+			_onlineCount = count;
+			refreshStatusText();
+		}, lifetime());
+	return this;
 }
 
-void CoverLine::initViewers() {
+Cover *Cover::setToggleShown(rpl::producer<bool> &&shown) {
+	_toggle.create(
+		this,
+		QString(),
+		st::infoToggleCheckbox,
+		std::make_unique<SectionToggle>(
+			st::infoToggle,
+			false,
+			[this] { _toggle->updateCheck(); }));
+	_toggle->lower();
+	_toggle->setCheckAlignment(style::al_right);
+	widthValue()
+		| rpl::start([this](int newValue) {
+			_toggle->setGeometry(0, 0, newValue, height());
+		}, _toggle->lifetime());
+	std::move(shown)
+		| rpl::start([this](bool shown) {
+			if (_toggle->isHidden() == shown) {
+				_toggle->setVisible(shown);
+			}
+		}, lifetime());
+	return this;
+}
+
+void Cover::initViewers() {
 	using Flag = Notify::PeerUpdate::Flag;
 	PeerUpdateViewer(_peer, Flag::PhotoChanged)
 		| rpl::start(
 			[this](auto&&) { this->refreshUserpicLink(); },
-			_lifetime);
+			lifetime());
 	PeerUpdateViewer(_peer, Flag::NameChanged)
 		| rpl::start(
 			[this](auto&&) { this->refreshNameText(); },
-			_lifetime);
+			lifetime());
 	PeerUpdateViewer(_peer,
 		Flag::UserOnlineChanged | Flag::MembersChanged)
 		| rpl::start(
 			[this](auto&&) { this->refreshStatusText(); },
-			_lifetime);
+			lifetime());
 }
 
-void CoverLine::initUserpicButton() {
+void Cover::initUserpicButton() {
 	_userpic->setClickedCallback([this] {
 		auto hasPhoto = (_peer->photoId != 0);
 		auto knownPhoto = (_peer->photoId != UnknownPeerPhotoId);
@@ -363,7 +430,7 @@ void CoverLine::initUserpicButton() {
 	refreshUserpicLink();
 }
 
-void CoverLine::refreshUserpicLink() {
+void Cover::refreshUserpicLink() {
 	auto hasPhoto = (_peer->photoId != 0);
 	auto knownPhoto = (_peer->photoId != UnknownPeerPhotoId);
 	_userpic->setPointerCursor(hasPhoto && knownPhoto);
@@ -372,12 +439,12 @@ void CoverLine::refreshUserpicLink() {
 	}
 }
 
-void CoverLine::refreshNameText() {
+void Cover::refreshNameText() {
 	_name->setText(App::peerName(_peer));
 	refreshNameGeometry(width());
 }
 
-void CoverLine::refreshStatusText() {
+void Cover::refreshStatusText() {
 	auto statusText = [this] {
 		auto currentTime = unixtime();
 		if (auto user = _peer->asUser()) {
@@ -406,12 +473,13 @@ void CoverLine::refreshStatusText() {
 	refreshStatusGeometry(width());
 }
 
-void CoverLine::refreshNameGeometry(int newWidth) {
+void Cover::refreshNameGeometry(int newWidth) {
 	auto nameWidth = newWidth
 		- st::infoProfileNameLeft
 		- st::infoProfileNameRight;
 	if (_toggle) {
-		nameWidth -= _toggle->width() + st::infoProfileToggleRight;
+		nameWidth -= st::infoToggleCheckbox.checkPosition.x()
+			+ _toggle->checkRect().width();
 	}
 	_name->resizeToWidth(nameWidth);
 	_name->moveToLeft(
@@ -420,12 +488,13 @@ void CoverLine::refreshNameGeometry(int newWidth) {
 		newWidth);
 }
 
-void CoverLine::refreshStatusGeometry(int newWidth) {
+void Cover::refreshStatusGeometry(int newWidth) {
 	auto statusWidth = newWidth
 		- st::infoProfileStatusLeft
 		- st::infoProfileStatusRight;
 	if (_toggle) {
-		statusWidth -= _toggle->width() + st::infoProfileToggleRight;
+		statusWidth -= st::infoToggleCheckbox.checkPosition.x()
+			+ _toggle->checkRect().width();
 	}
 	_status->resizeToWidth(statusWidth);
 	_status->moveToLeft(
@@ -434,27 +503,71 @@ void CoverLine::refreshStatusGeometry(int newWidth) {
 		newWidth);
 }
 
-int CoverLine::resizeGetHeight(int newWidth) {
-	_userpic->moveToLeft(
-		st::infoProfilePhotoLeft,
-		st::infoProfilePhotoTop,
-		newWidth);
-	refreshNameGeometry(newWidth);
-	refreshStatusGeometry(newWidth);
-	if (_toggle) {
-		_toggle->moveToRight(
-			st::infoProfileToggleRight,
-			st::infoProfileToggleTop,
-			newWidth);
-	}
-	return st::infoProfilePhotoTop
-		+ _userpic->height()
-		+ st::infoProfilePhotoBottom;
+rpl::producer<bool> Cover::toggledValue() const {
+	return _toggle
+		? (rpl::single(_toggle->checked())
+			| rpl::then(
+				base::ObservableViewer(_toggle->checkedChanged)))
+		: rpl::never<bool>();
 }
 
-rpl::producer<bool> CoverLine::toggled() const {
+QMargins SharedMediaCover::getMargins() const {
+	return QMargins(0, 0, 0, st::infoSharedMediaBottomSkip);
+}
+
+SharedMediaCover::SharedMediaCover(QWidget *parent)
+: FixedHeightWidget(parent, st::infoSharedMediaCoverHeight) {
+	createLabel();
+}
+
+void SharedMediaCover::createLabel() {
+	auto label = object_ptr<Ui::FlatLabel>(
+		this,
+		Lang::Viewer(lng_profile_shared_media) | ToUpperValue(),
+		st::infoSharedMediaLabel);
+	label->setAttribute(Qt::WA_TransparentForMouseEvents);
+	widthValue()
+		| rpl::start([weak = label.data()](int newWidth) {
+			weak->resizeToNaturalWidth(newWidth
+				- st::infoSharedMediaLabelPosition.x()
+				- st::infoSharedMediaButton.padding.right());
+			weak->moveToLeft(
+				st::infoSharedMediaLabelPosition.x(),
+				st::infoSharedMediaLabelPosition.y(),
+				newWidth);
+		}, label->lifetime());
+}
+
+SharedMediaCover *SharedMediaCover::setToggleShown(
+		rpl::producer<bool> &&shown) {
+	_toggle.create(
+		this,
+		QString(),
+		st::infoToggleCheckbox,
+		std::make_unique<SectionToggle>(
+			st::infoToggle,
+			false,
+			[this] { _toggle->updateCheck(); }));
+	_toggle->lower();
+	_toggle->setCheckAlignment(style::al_right);
+	widthValue()
+		| rpl::start([this](int newValue) {
+			_toggle->setGeometry(0, 0, newValue, height());
+		}, _toggle->lifetime());
+	std::move(shown)
+		| rpl::start([this](bool shown) {
+			if (_toggle->isHidden() == shown) {
+				_toggle->setVisible(shown);
+			}
+		}, lifetime());
+	return this;
+}
+
+rpl::producer<bool> SharedMediaCover::toggledValue() const {
 	return _toggle
-		? base::ObservableViewer(_toggle->checkedChanged)
+		? (rpl::single(_toggle->checked())
+			| rpl::then(
+				base::ObservableViewer(_toggle->checkedChanged)))
 		: rpl::never<bool>();
 }
 
@@ -476,19 +589,22 @@ Button::Button(
 		}, lifetime());
 }
 
-void Button::setToggled(bool toggled) {
-	if (!_toggle) {
-		_toggle = std::make_unique<Ui::ToggleView>(
-			isOver() ? _st.toggleOver : _st.toggle,
-			toggled,
-			[this] { rtlupdate(toggleRect()); });
-		clicks()
-			| rpl::start([this](auto) {
-				_toggle->setCheckedAnimated(!_toggle->checked());
-			}, lifetime());
-	} else {
-		_toggle->setCheckedAnimated(toggled);
-	}
+Button *Button::toggleOn(rpl::producer<bool> &&toggled) {
+	_toggleOnLifetime.destroy();
+	_toggle = std::make_unique<Ui::ToggleView>(
+		isOver() ? _st.toggleOver : _st.toggle,
+		false,
+		[this] { rtlupdate(toggleRect()); });
+	clicks()
+		| rpl::start([this](auto) {
+			_toggle->setCheckedAnimated(!_toggle->checked());
+		}, _toggleOnLifetime);
+	std::move(toggled)
+		| rpl::start([this](bool toggled) {
+			_toggle->setCheckedAnimated(toggled);
+		}, _toggleOnLifetime);
+	_toggle->finishAnimation();
+	return this;
 }
 
 rpl::producer<bool> Button::toggledValue() const {
@@ -579,5 +695,77 @@ rpl::producer<bool> MultiLineTracker::atLeastOneShownValue() const {
 		});
 }
 
+SectionToggle::SectionToggle(
+		const style::InfoToggle &st,
+		bool checked,
+		base::lambda<void()> updateCallback)
+: AbstractCheckView(st.duration, checked, std::move(updateCallback))
+, _st(st) {
+}
+
+QSize SectionToggle::getSize() const {
+	return QSize(_st.size, _st.size);
+}
+
+void SectionToggle::paint(
+		Painter &p,
+		int left,
+		int top,
+		int outerWidth,
+		TimeMs ms) {
+	auto sqrt2 = sqrt(2.);
+	auto vLeft = rtlpoint(left + _st.skip, 0, outerWidth).x() + 0.;
+	auto vTop = top + _st.skip + 0.;
+	auto vWidth = _st.size - 2 * _st.skip;
+	auto vHeight = _st.size - 2 * _st.skip;
+	auto vStroke = _st.stroke / sqrt2;
+	constexpr auto kPointCount = 6;
+	std::array<QPointF, kPointCount> pathV = { {
+		{ vLeft, vTop + (vHeight / 4.) + vStroke },
+		{ vLeft + vStroke, vTop + (vHeight / 4.) },
+		{ vLeft + (vWidth / 2.), vTop + (vHeight * 3. / 4.) - vStroke },
+		{ vLeft + vWidth - vStroke, vTop + (vHeight / 4.) },
+		{ vLeft + vWidth, vTop + (vHeight / 4.) + vStroke },
+		{ vLeft + (vWidth / 2.), vTop + (vHeight * 3. / 4.) + vStroke },
+	} };
+
+	auto toggled = currentAnimationValue(ms);
+	auto alpha = (toggled - 1.) * M_PI_2;
+	auto cosalpha = cos(alpha);
+	auto sinalpha = sin(alpha);
+	auto shiftx = vLeft + (vWidth / 2.);
+	auto shifty = vTop + (vHeight / 2.);
+	for (auto &point : pathV) {
+		auto x = point.x() - shiftx;
+		auto y = point.y() - shifty;
+		point.setX(shiftx + x * cosalpha - y * sinalpha);
+		point.setY(shifty + y * cosalpha + x * sinalpha);
+	}
+	QPainterPath path;
+	path.moveTo(pathV[0]);
+	for (int i = 1; i != kPointCount; ++i) {
+		path.lineTo(pathV[i]);
+	}
+	path.lineTo(pathV[0]);
+
+	PainterHighQualityEnabler hq(p);
+	p.fillPath(path, _st.color);
+}
+
+QImage SectionToggle::prepareRippleMask() const {
+	return Ui::RippleAnimation::ellipseMask(rippleSize());
+}
+
+QSize SectionToggle::rippleSize() const {
+	return getSize() + 2 * QSize(
+		_st.rippleAreaPadding,
+		_st.rippleAreaPadding);
+}
+
+bool SectionToggle::checkRippleStartPosition(QPoint position) const {
+	return QRect(QPoint(0, 0), rippleSize()).contains(position);
+
+}
+
 } // namespace Profile
 } // namespace Info

Telegram/SourceFiles/info/info_profile_lines.h

@@ -21,6 +21,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #pragma once
 
 #include <rpl/producer.h>
+#include "ui/widgets/checkbox.h"
 #include "ui/wrap/padding_wrap.h"
 #include "ui/wrap/slide_wrap.h"
 #include "ui/wrap/vertical_layout.h"
@@ -31,6 +32,7 @@ enum LangKey : int;
 namespace style {
 struct FlatLabel;
 struct InfoProfileButton;
+struct InfoToggle;
 } // namespace style
 
 namespace Lang {
@@ -81,26 +83,18 @@ rpl::producer<bool> CanShareContactViewer(
 	not_null<UserData*> user);
 rpl::producer<bool> CanAddContactViewer(
 	not_null<UserData*> user);
+rpl::producer<int> MembersCountViewer(
+	not_null<PeerData*> peer);
+rpl::producer<int> SharedMediaCountViewer(
+	not_null<PeerData*> peer,
+	Storage::SharedMediaType type);
+rpl::producer<int> CommonGroupsCountViewer(
+	not_null<UserData*> user);
 
 class FloatingIcon : public Ui::RpWidget {
 public:
 	FloatingIcon(
-		QWidget *parent,
-		not_null<RpWidget*> above,
-		const style::icon &icon);
-
-	FloatingIcon(
-		QWidget *parent,
-		not_null<RpWidget*> above,
-		const style::icon &icon,
-		QPoint position);
-
-	FloatingIcon(
-		QWidget *parent,
-		const style::icon &icon);
-
-	FloatingIcon(
-		QWidget *parent,
+		RpWidget *parent,
 		const style::icon &icon,
 		QPoint position);
 
@@ -111,8 +105,7 @@ private:
 	struct Tag {
 	};
 	FloatingIcon(
-		QWidget *parent,
-		RpWidget *above,
+		RpWidget *parent,
 		const style::icon &icon,
 		QPoint position,
 		const Tag &);
@@ -139,19 +132,16 @@ public:
 
 };
 
-class CoverLine : public Ui::RpWidget {
+class Cover : public Ui::FixedHeightWidget {
 public:
-	CoverLine(QWidget *parent, not_null<PeerData*> peer);
+	Cover(QWidget *parent, not_null<PeerData*> peer);
 
-	void setOnlineCount(int onlineCount);
-	void setHasToggle(bool hasToggle);
-
-	rpl::producer<bool> toggled() const;
-
-protected:
-	int resizeGetHeight(int newWidth) override;
+	Cover *setOnlineCount(rpl::producer<int> &&count);
+	Cover *setToggleShown(rpl::producer<bool> &&shown);
+	rpl::producer<bool> toggledValue() const;
 
 private:
+	void setupChildGeometry();
 	void initViewers();
 	void initUserpicButton();
 	void refreshUserpicLink();
@@ -169,7 +159,21 @@ private:
 	object_ptr<Ui::Checkbox> _toggle = { nullptr };
 	//object_ptr<CoverDropArea> _dropArea = { nullptr };
 
-	rpl::lifetime _lifetime;
+};
+
+class SharedMediaCover : public Ui::FixedHeightWidget {
+public:
+	SharedMediaCover(QWidget *parent);
+
+	SharedMediaCover *setToggleShown(rpl::producer<bool> &&shown);
+	rpl::producer<bool> toggledValue() const;
+
+	QMargins getMargins() const override;
+
+private:
+	void createLabel();
+
+	object_ptr<Ui::Checkbox> _toggle = { nullptr };
 
 };
 
@@ -183,7 +187,7 @@ public:
 		rpl::producer<QString> &&text,
 		const style::InfoProfileButton &st);
 
-	void setToggled(bool toggled);
+	Button *toggleOn(rpl::producer<bool> &&toggled);
 	rpl::producer<bool> toggledValue() const;
 
 protected:
@@ -205,6 +209,7 @@ private:
 	int _originalWidth = 0;
 	int _textWidth = 0;
 	std::unique_ptr<Ui::ToggleView> _toggle;
+	rpl::lifetime _toggleOnLifetime;
 
 };
 
@@ -222,5 +227,29 @@ private:
 
 };
 
+class SectionToggle : public Ui::AbstractCheckView {
+public:
+	SectionToggle(
+		const style::InfoToggle &st,
+		bool checked,
+		base::lambda<void()> updateCallback);
+
+	QSize getSize() const override;
+	void paint(
+		Painter &p,
+		int left,
+		int top,
+		int outerWidth,
+		TimeMs ms) override;
+	QImage prepareRippleMask() const override;
+	bool checkRippleStartPosition(QPoint position) const override;
+
+private:
+	QSize rippleSize() const;
+
+	const style::InfoToggle &_st;
+
+};
+
 } // namespace Profile
 } // namespace Info

Telegram/SourceFiles/info/info_top_bar.cpp

@@ -44,8 +44,7 @@ void TopBar::enableBackButton(bool enable) {
 	if (enable) {
 		_back.create(this, _st.back);
 		_back->clicks()
-			| rpl::to_stream(_backClicks)
-			| rpl::start(_lifetime);
+			| rpl::start_to_stream(_backClicks, _lifetime);
 	} else {
 		_back.destroy();
 	}

Telegram/SourceFiles/mediaview.cpp

@@ -2808,6 +2808,8 @@ void MediaView::updateHeader() {
 	} else {
 		if (_doc) {
 			_headerText = _doc->name.isEmpty() ? lang(lng_mediaview_doc_image) : _doc->name;
+		} else if (_msgid) {
+			_headerText = lang(lng_mediaview_single_photo);
 		} else if (_user) {
 			_headerText = lang(lng_mediaview_profile_photo);
 		} else if ((_history && _history->channelId() && !_history->isMegagroup())

Telegram/SourceFiles/rpl/event_stream.h

@@ -21,8 +21,9 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #pragma once
 
 #include <rpl/producer.h>
-#include <rpl/single.h>
+#include <rpl/range.h>
 #include <rpl/then.h>
+#include <rpl/range.h>
 #include "base/algorithm.h"
 #include "base/assertion.h"
 #include "base/index_based_iterator.h"
@@ -154,10 +155,51 @@ inline event_stream<Value>::~event_stream() {
 }
 
 template <typename Value>
-inline auto to_stream(event_stream<Value> &stream) {
-	return on_next([&stream](auto &&value) {
+inline auto start_to_stream(
+		event_stream<Value> &stream,
+		lifetime &alive_while) {
+	return start([&stream](auto &&value) {
 		stream.fire_forward(std::forward<decltype(value)>(value));
-	});
+	}, alive_while);
+}
+
+namespace details {
+
+class start_spawning_helper {
+public:
+	start_spawning_helper(lifetime &alive_while)
+	: _lifetime(alive_while) {
+	}
+	template <typename Value, typename Error>
+	producer<Value, Error> operator()(
+			producer<Value, Error> &&initial) {
+		auto stream = _lifetime.make_state<event_stream<Value>>();
+		auto collected = std::vector<Value>();
+		{
+			auto collecting = stream->events().start(
+				[&collected](Value &&value) {
+					collected.push_back(std::move(value));
+				},
+				[](const Error &error) {},
+				[] {});
+			std::move(initial) | start_to_stream(*stream, _lifetime);
+		}
+		return collected.empty()
+			? stream->events()
+			: vector(std::move(collected))
+				| then(stream->events());
+	}
+
+private:
+	lifetime &_lifetime;
+
+};
+
+} // namespace details
+
+inline auto start_spawning(lifetime &alive_while)
+-> details::start_spawning_helper {
+	return details::start_spawning_helper(alive_while);
 }
 
 } // namespace rpl

Telegram/SourceFiles/rpl/filter.h

@@ -22,6 +22,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 
 #include <rpl/producer.h>
 #include <rpl/combine.h>
+#include "base/optional.h"
 
 namespace rpl {
 namespace details {
@@ -52,11 +53,16 @@ public:
 					predicate = std::move(predicate)
 				](auto &&value) {
 					const auto &immutable = value;
-					if (details::callable_invoke(predicate, immutable)) {
-						consumer.put_next_forward(std::forward<decltype(value)>(value));
+					if (details::callable_invoke(
+						predicate,
+						immutable)
+					) {
+						consumer.put_next_forward(
+							std::forward<decltype(value)>(value));
 					}
 				}, [consumer](auto &&error) {
-					consumer.put_error_forward(std::forward<decltype(error)>(error));
+					consumer.put_error_forward(
+						std::forward<decltype(error)>(error));
 				}, [consumer] {
 					consumer.put_done();
 				});
@@ -103,5 +109,50 @@ private:
 
 };
 
+template <typename Value>
+inline const Value &deref_optional_helper(
+		const base::optional<Value> &value) {
+	return *value;
+}
+
+template <typename Value>
+inline Value &&deref_optional_helper(
+		base::optional<Value> &&value) {
+	return std::move(*value);
+}
+
+class filter_optional_helper {
+public:
+	template <typename Value, typename Error>
+	rpl::producer<Value, Error> operator()(
+		rpl::producer<base::optional<Value>, Error> &&initial
+	) const {
+		return [initial = std::move(initial)](
+				const consumer<Value, Error> &consumer) mutable {
+			return std::move(initial).start(
+				[consumer](auto &&value) {
+					if (value) {
+						consumer.put_next_forward(
+							deref_optional_helper(
+								std::forward<decltype(value)>(
+									value)));
+					}
+				}, [consumer](auto &&error) {
+					consumer.put_error_forward(
+						std::forward<decltype(error)>(error));
+				}, [consumer] {
+					consumer.put_done();
+				});
+		};
+	}
+
+};
+
 } // namespace details
+
+inline auto filter_optional()
+-> details::filter_optional_helper {
+	return details::filter_optional_helper();
+}
+
 } // namespace rpl

Telegram/SourceFiles/rpl/range.h

@@ -40,7 +40,43 @@ inline producer<empty_value, Error> single() {
 	return [](const consumer<empty_value, Error> &consumer) {
 		consumer.put_next({});
 		consumer.put_done();
+		return lifetime();
 	};
 }
 
+template <typename Value, typename Error = no_error>
+inline producer<Value, Error> vector(std::vector<Value> &&values) {
+	return [values = std::move(values)](
+			const consumer<Value, Error> &consumer) mutable {
+		for (auto &value : values) {
+			consumer.put_next(std::move(value));
+		}
+		consumer.put_done();
+		return lifetime();
+	};
+}
+
+template <typename Value, typename Error = no_error, typename Range>
+inline producer<Value, Error> range(Range &&range) {
+	return vector(std::vector<Value>(
+		std::begin(range),
+		std::end(range)));
+}
+
+inline producer<int> ints(int from, int till) {
+	Expects(from <= till);
+	return [from, till](const consumer<int> &consumer) {
+		for (auto i = from; i != till; ++i) {
+			consumer.put_next_copy(i);
+		}
+		consumer.put_done();
+		return lifetime();
+	};
+}
+
+inline producer<int> ints(int count) {
+	return ints(0, count);
+}
+
 } // namespace rpl
+

Telegram/SourceFiles/rpl/rpl.h

@@ -25,7 +25,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 #include <rpl/producer.h>
 #include <rpl/event_stream.h>
 
-#include <rpl/single.h>
+#include <rpl/range.h>
 #include <rpl/complete.h>
 #include <rpl/fail.h>
 #include <rpl/never.h>

Telegram/SourceFiles/storage/storage_shared_media.cpp

@@ -174,11 +174,16 @@ void SharedMedia::List::removeAll() {
 rpl::producer<SharedMediaResult> SharedMedia::List::query(
 		SharedMediaQuery &&query) const {
 	return [this, query = std::move(query)](auto consumer) {
-		auto slice = base::lower_bound(
-			_slices,
-			query.key.messageId,
-			[](const Slice &slice, MsgId id) { return slice.range.till < id; });
-		if (slice != _slices.end() && slice->range.from <= query.key.messageId) {
+		auto slice = query.key.messageId
+			? base::lower_bound(
+				_slices,
+				query.key.messageId,
+				[](const Slice &slice, MsgId id) {
+					return slice.range.till < id;
+				})
+			: _slices.end();
+		if (slice != _slices.end()
+			&& slice->range.from <= query.key.messageId) {
 			consumer.put_next(queryFromSlice(query, *slice));
 		} else if (_count) {
 			auto result = SharedMediaResult {};

Telegram/SourceFiles/ui/twidget.h

@@ -424,7 +424,7 @@ protected:
 
 	// Resizes content and counts natural widget height for the desired width.
 	virtual int resizeGetHeight(int newWidth) {
-		return height();
+		return heightNoMargins();
 	}
 
 	virtual void visibleTopBottomUpdated(

Telegram/SourceFiles/ui/widgets/checkbox.cpp

@@ -71,7 +71,11 @@ float64 AbstractCheckView::currentAnimationValue(TimeMs ms) {
 	return ms ? _toggleAnimation.current(ms, _checked ? 1. : 0.) : _toggleAnimation.current(_checked ? 1. : 0.);
 }
 
-ToggleView::ToggleView(const style::Toggle &st, bool checked, base::lambda<void()> updateCallback) : AbstractCheckView(st.duration, checked, std::move(updateCallback))
+ToggleView::ToggleView(
+	const style::Toggle &st,
+	bool checked,
+	base::lambda<void()> updateCallback)
+: AbstractCheckView(st.duration, checked, std::move(updateCallback))
 , _st(&st) {
 }
 
@@ -318,12 +322,35 @@ Checkbox::Checkbox(QWidget *parent, const QString &text, const style::Checkbox &
 	setCursor(style::cur_pointer);
 }
 
+QRect Checkbox::checkRect() const {
+	auto size = _check->getSize();
+	return QRect({
+		(_checkAlignment & Qt::AlignHCenter)
+			? (width() - size.width()) / 2
+			: (_checkAlignment & Qt::AlignRight)
+				? (width() - _st.checkPosition.x() - size.width())
+				: _st.checkPosition.x(),
+		(_checkAlignment & Qt::AlignVCenter)
+			? (height() - size.height()) / 2
+			: (_checkAlignment & Qt::AlignBottom)
+				? (height() - _st.checkPosition.y() - size.height())
+				: _st.checkPosition.y()
+	}, size);
+}
+
 void Checkbox::setText(const QString &text) {
 	_text.setText(_st.style, text, _checkboxOptions);
 	resizeToText();
 	update();
 }
 
+void Checkbox::setCheckAlignment(style::align alignment) {
+	if (_checkAlignment != alignment) {
+		_checkAlignment = alignment;
+		update();
+	}
+}
+
 bool Checkbox::checked() const {
 	return _check->checked();
 }
@@ -334,7 +361,6 @@ void Checkbox::resizeToText() {
 	} else {
 		resizeToWidth(_st.width);
 	}
-	_checkRect = { QPoint(_st.margin.left(), _st.margin.top()), _check->getSize() };
 }
 
 void Checkbox::setChecked(bool checked, NotifyAboutChange notify) {
@@ -351,44 +377,82 @@ void Checkbox::finishAnimations() {
 }
 
 int Checkbox::naturalWidth() const {
-	return _checkRect.width() + _st.textPosition.x() + _text.maxWidth();
+	if (_st.width > 0) {
+		return _st.width;
+	}
+	auto result = _st.checkPosition.x() + _check->getSize().width();
+	if (!_text.isEmpty()) {
+		result += _st.textPosition.x() + _text.maxWidth();
+	}
+	return result - _st.width;
 }
 
 void Checkbox::paintEvent(QPaintEvent *e) {
 	Painter p(this);
 
+	auto check = checkRect();
 	auto ms = getms();
 	if (isDisabled()) {
 		p.setOpacity(_st.disabledOpacity);
 	} else {
 		auto active = _check->currentAnimationValue(ms);
 		auto color = anim::color(_st.rippleBg, _st.rippleBgActive, active);
-		paintRipple(p, _st.rippleAreaPosition.x(), _st.rippleAreaPosition.y(), ms, &color);
+		paintRipple(
+			p,
+			check.x() + _st.rippleAreaPosition.x(),
+			check.y() + _st.rippleAreaPosition.y(),
+			ms,
+			&color);
 	}
 
-	auto realCheckRect = myrtlrect(_checkRect);
+	auto realCheckRect = myrtlrect(check);
 	if (realCheckRect.intersects(e->rect())) {
 		if (isDisabled()) {
-			p.drawPixmapLeft(_checkRect.left(), _checkRect.top(), width(), _checkCache);
+			p.drawPixmapLeft(check.left(), check.top(), width(), _checkCache);
 		} else {
-			_check->paint(p, _checkRect.left(), _checkRect.top(), width());
+			_check->paint(p, check.left(), check.top(), width());
 		}
 	}
 	if (realCheckRect.contains(e->rect())) return;
 
-	auto textWidth = qMax(width() - (_checkRect.width() + _st.textPosition.x() + _st.textPosition.x()), 1);
+	auto leftSkip = _st.checkPosition.x()
+		+ check.width()
+		+ _st.textPosition.x();
+	auto availableTextWidth = qMax(width() - leftSkip, 1);
 
-	p.setPen(_st.textFg);
-	_text.drawLeftElided(p, _st.margin.left() + _checkRect.width() + _st.textPosition.x(), _st.margin.top() + _st.textPosition.y(), textWidth, width());
+	if (!_text.isEmpty()) {
+		Assert(!(_checkAlignment & Qt::AlignHCenter));
+		p.setPen(_st.textFg);
+		auto textSkip = _st.checkPosition.x()
+			+ check.width()
+			+ _st.textPosition.x();
+		auto textTop = _st.margin.top() + _st.textPosition.y();
+		if (_checkAlignment & Qt::AlignLeft) {
+			_text.drawLeftElided(
+				p,
+				textSkip,
+				textTop,
+				availableTextWidth,
+				width());
+		} else {
+			_text.drawRightElided(
+				p,
+				textSkip,
+				textTop,
+				availableTextWidth,
+				width());
+		}
+	}
 }
 
 QPixmap Checkbox::grabCheckCache() const {
-	auto image = QImage(_checkRect.size() * cIntRetinaFactor(), QImage::Format_ARGB32_Premultiplied);
+	auto checkSize = _check->getSize();
+	auto image = QImage(checkSize * cIntRetinaFactor(), QImage::Format_ARGB32_Premultiplied);
 	image.fill(Qt::transparent);
 	image.setDevicePixelRatio(cRetinaFactor());
 	{
 		Painter p(&image);
-		_check->paint(p, 0, 0, _checkRect.width());
+		_check->paint(p, 0, 0, checkSize.width());
 	}
 	return App::pixmapFromImageInPlace(std::move(image));
 }
@@ -429,8 +493,12 @@ QPoint Checkbox::prepareRippleStartPosition() const {
 	if (isDisabled()) {
 		return DisabledRippleStartPosition();
 	}
-	auto position = mapFromGlobal(QCursor::pos()) - _st.rippleAreaPosition;
-	return _check->checkRippleStartPosition(position) ? position : DisabledRippleStartPosition();
+	auto position = myrtlpoint(mapFromGlobal(QCursor::pos()))
+		- checkRect().topLeft()
+		- _st.rippleAreaPosition;
+	return _check->checkRippleStartPosition(position)
+		? position
+		: DisabledRippleStartPosition();
 }
 
 void RadiobuttonGroup::setValue(int value) {

Telegram/SourceFiles/ui/widgets/checkbox.h

@@ -130,6 +130,7 @@ public:
 	Checkbox(QWidget *parent, const QString &text, const style::Checkbox &st, std::unique_ptr<AbstractCheckView> check);
 
 	void setText(const QString &text);
+	void setCheckAlignment(style::align alignment);
 
 	bool checked() const;
 	enum class NotifyAboutChange {
@@ -146,6 +147,11 @@ public:
 	}
 	int naturalWidth() const override;
 
+	void updateCheck() {
+		rtlupdate(checkRect());
+	}
+	QRect checkRect() const;
+
 protected:
 	void paintEvent(QPaintEvent *e) override;
 
@@ -157,10 +163,6 @@ protected:
 
 	virtual void handlePress();
 
-	void updateCheck() {
-		rtlupdate(_checkRect);
-	}
-
 private:
 	void resizeToText();
 	QPixmap grabCheckCache() const;
@@ -170,7 +172,7 @@ private:
 	QPixmap _checkCache;
 
 	Text _text;
-	QRect _checkRect;
+	style::align _checkAlignment = style::al_left;
 
 };
 

Telegram/SourceFiles/ui/widgets/widgets.style

@@ -138,6 +138,7 @@ Checkbox {
 	margin: margins;
 
 	textPosition: point;
+	checkPosition: point;
 
 	style: TextStyle;
 
@@ -744,10 +745,11 @@ defaultCheckbox: Checkbox {
 	margin: margins(8px, 8px, 8px, 8px);
 
 	textPosition: point(10px, 2px);
+	checkPosition: point(8px, 8px);
 
 	style: defaultTextStyle;
 
-	rippleAreaPosition: point(0px, 0px);
+	rippleAreaPosition: point(-8px, -8px);
 	rippleBg: windowBgOver;
 	rippleBgActive: lightButtonBgOver;
 	ripple: defaultRippleAnimation;

Telegram/SourceFiles/ui/wrap/padding_wrap.h

@@ -37,12 +37,6 @@ public:
 		object_ptr<RpWidget> child,
 		const style::margins &padding);
 
-	PaddingWrap(
-		QWidget *parent,
-		const style::margins &padding)
-		: PaddingWrap(parent, nullptr, padding) {
-	}
-
 	int naturalWidth() const override;
 
 protected:
@@ -66,18 +60,23 @@ public:
 	: Parent(parent, std::move(child), padding) {
 	}
 
-	PaddingWrap(QWidget *parent, const style::margins &padding)
-	: Parent(parent, padding) {
+};
+
+class FixedHeightWidget : public RpWidget {
+public:
+	FixedHeightWidget(QWidget *parent, int height)
+	: RpWidget(parent) {
+		resize(width(), height);
 	}
 
 };
 
-inline object_ptr<PaddingWrap<>> CreateSkipWidget(
+inline object_ptr<FixedHeightWidget> CreateSkipWidget(
 		QWidget *parent,
 		int skip) {
-	return object_ptr<PaddingWrap<>>(
+	return object_ptr<FixedHeightWidget>(
 		parent,
-		QMargins(0, 0, 0, skip));
+		skip);
 }
 
 } // namespace Ui

Telegram/SourceFiles/ui/wrap/slide_wrap.cpp

@@ -28,53 +28,69 @@ SlideWrap<RpWidget>::SlideWrap(
 : SlideWrap(
 	parent,
 	std::move(child),
-	style::margins(),
-	st::slideWrapDuration) {
+	style::margins()) {
+}
+
+SlideWrap<RpWidget>::SlideWrap(
+	QWidget *parent,
+	const style::margins &padding)
+: SlideWrap(parent, nullptr, padding) {
 }
 
 SlideWrap<RpWidget>::SlideWrap(
 	QWidget *parent,
 	object_ptr<RpWidget> child,
 	const style::margins &padding)
-: SlideWrap(
-	parent,
-	std::move(child),
-	padding,
-	st::slideWrapDuration) {
-}
-
-SlideWrap<RpWidget>::SlideWrap(
-	QWidget *parent,
-	object_ptr<RpWidget> child,
-	int duration)
-: SlideWrap(parent, std::move(child), style::margins(), duration) {
-}
-
-SlideWrap<RpWidget>::SlideWrap(
-	QWidget *parent,
-	const style::margins &padding)
-: SlideWrap(parent, nullptr, padding, st::slideWrapDuration) {
-}
-
-SlideWrap<RpWidget>::SlideWrap(
-	QWidget *parent,
-	const style::margins &padding,
-	int duration)
-: SlideWrap(parent, nullptr, padding, duration) {
-}
-
-SlideWrap<RpWidget>::SlideWrap(
-	QWidget *parent,
-	object_ptr<RpWidget> child,
-	const style::margins &padding,
-	int duration)
 : Parent(
 	parent,
 	object_ptr<PaddingWrap<RpWidget>>(
 		parent,
 		std::move(child),
 		padding))
-, _duration(duration) {
+, _duration(st::slideWrapDuration) {
+}
+
+SlideWrap<RpWidget> *SlideWrap<RpWidget>::setDuration(int duration) {
+	_duration = duration;
+	return this;
+}
+
+SlideWrap<RpWidget> *SlideWrap<RpWidget>::toggleAnimated(
+		bool shown) {
+	if (_shown != shown) {
+		setShown(shown);
+		_slideAnimation.start(
+			[this] { animationStep(); },
+			_shown ? 0. : 1.,
+			_shown ? 1. : 0.,
+			_duration,
+			anim::linear);
+	}
+	animationStep();
+	return this;
+}
+
+SlideWrap<RpWidget> *SlideWrap<RpWidget>::toggleFast(bool shown) {
+	setShown(shown);
+	finishAnimations();
+	return this;
+}
+
+SlideWrap<RpWidget> *SlideWrap<RpWidget>::finishAnimations() {
+	_slideAnimation.finish();
+	animationStep();
+	return this;
+}
+
+SlideWrap<RpWidget> *SlideWrap<RpWidget>::toggleOn(
+		rpl::producer<bool> &&shown) {
+	_toggleOnLifetime.destroy();
+	std::move(shown)
+		| rpl::start([this](bool shown) {
+			toggleAnimated(shown);
+		}, _toggleOnLifetime);
+	finishAnimations();
+	return this;
 }
 
 void SlideWrap<RpWidget>::animationStep() {
@@ -107,31 +123,6 @@ void SlideWrap<RpWidget>::setShown(bool shown) {
 	_shownUpdated.fire_copy(_shown);
 }
 
-void SlideWrap<RpWidget>::toggleAnimated(bool shown) {
-	if (_shown == shown) {
-		animationStep();
-		return;
-	}
-	setShown(shown);
-	_slideAnimation.start(
-		[this] { animationStep(); },
-		_shown ? 0. : 1.,
-		_shown ? 1. : 0.,
-		_duration,
-		anim::linear);
-	animationStep();
-}
-
-void SlideWrap<RpWidget>::toggleFast(bool shown) {
-	setShown(shown);
-	finishAnimations();
-}
-
-void SlideWrap<RpWidget>::finishAnimations() {
-	_slideAnimation.finish();
-	animationStep();
-}
-
 QMargins SlideWrap<RpWidget>::getMargins() const {
 	auto result = wrapped()->getMargins();
 	return (animating() || !_shown)

Telegram/SourceFiles/ui/wrap/slide_wrap.h

@@ -32,49 +32,30 @@ class SlideWrap<RpWidget> : public Wrap<PaddingWrap<RpWidget>> {
 	using Parent = Wrap<PaddingWrap<RpWidget>>;
 
 public:
-	SlideWrap(QWidget *parent, object_ptr<RpWidget> child);
 	SlideWrap(
 		QWidget *parent,
-		object_ptr<RpWidget> child,
-		const style::margins &padding);
-	SlideWrap(
-		QWidget *parent,
-		object_ptr<RpWidget> child,
-		int duration);
+		object_ptr<RpWidget> child);
 	SlideWrap(
 		QWidget *parent,
 		const style::margins &padding);
-	SlideWrap(
-		QWidget *parent,
-		const style::margins &padding,
-		int duration);
 	SlideWrap(
 		QWidget *parent,
 		object_ptr<RpWidget> child,
-		const style::margins &padding,
-		int duration);
+		const style::margins &padding);
 
-	void toggleAnimated(bool shown);
-	void toggleFast(bool shown);
-
-	void showAnimated() {
-		toggleAnimated(true);
-	}
-	void hideAnimated() {
-		toggleAnimated(false);
-	}
-
-	void showFast() {
-		toggleFast(true);
-	}
-	void hideFast() {
-		toggleFast(false);
-	}
+	SlideWrap *setDuration(int duration);
+	SlideWrap *toggleAnimated(bool shown);
+	SlideWrap *toggleFast(bool shown);
+	SlideWrap *showAnimated() { return toggleAnimated(true); }
+	SlideWrap *hideAnimated() { return toggleAnimated(false); }
+	SlideWrap *showFast() { return toggleFast(true); }
+	SlideWrap *hideFast() { return toggleFast(false); }
+	SlideWrap *finishAnimations();
+	SlideWrap *toggleOn(rpl::producer<bool> &&shown);
 
 	bool animating() const {
 		return _slideAnimation.animating();
 	}
-	void finishAnimations();
 
 	QMargins getMargins() const override;
 
@@ -96,6 +77,7 @@ private:
 
 	bool _shown = true;
 	rpl::event_stream<bool> _shownUpdated;
+	rpl::lifetime _toggleOnLifetime;
 	Animation _slideAnimation;
 	int _duration = 0;
 
@@ -106,38 +88,54 @@ class SlideWrap : public Wrap<PaddingWrap<Widget>, SlideWrap<RpWidget>> {
 	using Parent = Wrap<PaddingWrap<Widget>, SlideWrap<RpWidget>>;
 
 public:
-	SlideWrap(QWidget *parent, object_ptr<Widget> child)
+	SlideWrap(
+		QWidget *parent,
+		object_ptr<Widget> child)
 	: Parent(parent, std::move(child)) {
 	}
-	SlideWrap(
-		QWidget *parent,
-		object_ptr<Widget> child,
-		const style::margins &padding)
-	: Parent(parent, std::move(child), padding) {
-	}
-	SlideWrap(
-		QWidget *parent,
-		object_ptr<Widget> child,
-		int duration)
-	: Parent(parent, std::move(child), duration) {
-	}
 	SlideWrap(
 		QWidget *parent,
 		const style::margins &padding)
 	: Parent(parent, padding) {
 	}
-	SlideWrap(
-		QWidget *parent,
-		const style::margins &padding,
-		int duration)
-	: Parent(parent, nullptr, padding, duration) {
-	}
 	SlideWrap(
 		QWidget *parent,
 		object_ptr<Widget> child,
-		const style::margins &padding,
-		int duration)
-	: Parent(parent, std::move(child), padding, duration) {
+		const style::margins &padding)
+	: Parent(parent, std::move(child), padding) {
+	}
+
+	SlideWrap *setDuration(int duration) {
+		return chain(Parent::setDuration(duration));
+	}
+	SlideWrap *toggleAnimated(bool shown) {
+		return chain(Parent::toggleAnimated(shown));
+	}
+	SlideWrap *toggleFast(bool shown) {
+		return chain(Parent::toggleFast(shown));
+	}
+	SlideWrap *showAnimated() {
+		return chain(Parent::showAnimated());
+	}
+	SlideWrap *hideAnimated() {
+		return chain(Parent::hideAnimated());
+	}
+	SlideWrap *showFast() {
+		return chain(Parent::showFast());
+	}
+	SlideWrap *hideFast() {
+		return chain(Parent::hideFast());
+	}
+	SlideWrap *finishAnimations() {
+		return chain(Parent::finishAnimations());
+	}
+	SlideWrap *toggleOn(rpl::producer<bool> &&shown) {
+		return chain(Parent::toggleOn(std::move(shown)));
+	}
+
+private:
+	SlideWrap *chain(SlideWrap<RpWidget> *result) {
+		return static_cast<SlideWrap*>(result);
 	}
 
 };

Telegram/SourceFiles/window/section_widget.cpp

@@ -22,7 +22,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
 
 #include "application.h"
 #include "window/section_memento.h"
-#include <rpl/single.h>
+#include <rpl/range.h>
 
 namespace Window {
 

Telegram/gyp/settings_win.gypi

@@ -37,10 +37,10 @@
           'DebugInformationFormat': '3',          # Program Database (/Zi)
           'AdditionalOptions': [
             '/std:c++latest',
-            '/MP',   # Enable multi process build.
-            '/EHsc', # Catch C++ exceptions only, extern C functions never throw a C++ exception.
-            '/WX',   # Treat warnings as errors.
-            '/std:c++latest',
+            '/MP',     # Enable multi process build.
+            '/EHsc',   # Catch C++ exceptions only, extern C functions never throw a C++ exception.
+            '/WX',     # Treat warnings as errors.
+            '/w14834', # [[nodiscard]]
           ],
           'TreatWChar_tAsBuiltInType': 'false',
         },

Telegram/gyp/tests/tests.gyp

@@ -118,8 +118,8 @@
       '<(src_loc)/rpl/operators_tests.cpp',
       '<(src_loc)/rpl/producer.h',
       '<(src_loc)/rpl/producer_tests.cpp',
+      '<(src_loc)/rpl/range.h',
       '<(src_loc)/rpl/rpl.h',
-      '<(src_loc)/rpl/single.h',
       '<(src_loc)/rpl/then.h',
       '<(src_loc)/rpl/variable.h',
     ],