From d3f62d971dbed6f1c7e251743725b825fb9ac123 Mon Sep 17 00:00:00 2001
From: John Preston <johnprestonmail@gmail.com>
Date: Tue, 12 Jul 2022 16:44:34 +0300
Subject: [PATCH] Use unified StickersListFooter for emoji / stickers.

---
 Telegram/CMakeLists.txt                       |    2 +
 .../chat_helpers/emoji_list_widget.cpp        |  111 +-
 .../chat_helpers/emoji_list_widget.h          |   18 +-
 .../chat_helpers/stickers_list_footer.cpp     |  936 +++++++++++++++
 .../chat_helpers/stickers_list_footer.h       |  207 ++++
 .../chat_helpers/stickers_list_widget.cpp     | 1030 +----------------
 .../chat_helpers/stickers_list_widget.h       |   15 +-
 .../chat_helpers/tabbed_selector.cpp          |    2 +-
 8 files changed, 1292 insertions(+), 1029 deletions(-)
 create mode 100644 Telegram/SourceFiles/chat_helpers/stickers_list_footer.cpp
 create mode 100644 Telegram/SourceFiles/chat_helpers/stickers_list_footer.h

diff --git a/Telegram/CMakeLists.txt b/Telegram/CMakeLists.txt
index e698cbb9b..ffa80a517 100644
--- a/Telegram/CMakeLists.txt
+++ b/Telegram/CMakeLists.txt
@@ -370,6 +370,8 @@ PRIVATE
     chat_helpers/stickers_emoji_pack.h
     chat_helpers/stickers_dice_pack.cpp
     chat_helpers/stickers_dice_pack.h
+    chat_helpers/stickers_list_footer.cpp
+    chat_helpers/stickers_list_footer.h
     chat_helpers/stickers_list_widget.cpp
     chat_helpers/stickers_list_widget.h
     chat_helpers/stickers_lottie.cpp
diff --git a/Telegram/SourceFiles/chat_helpers/emoji_list_widget.cpp b/Telegram/SourceFiles/chat_helpers/emoji_list_widget.cpp
index e0faaff5c..3f3714679 100644
--- a/Telegram/SourceFiles/chat_helpers/emoji_list_widget.cpp
+++ b/Telegram/SourceFiles/chat_helpers/emoji_list_widget.cpp
@@ -23,6 +23,7 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
 #include "data/stickers/data_stickers.h"
 #include "data/stickers/data_custom_emoji.h"
 #include "chat_helpers/stickers_list_widget.h"
+#include "chat_helpers/stickers_list_footer.h"
 #include "emoji_suggestions_data.h"
 #include "emoji_suggestions_helper.h"
 #include "main/main_session.h"
@@ -85,6 +86,7 @@ private:
 
 };
 
+#if 0
 class EmojiListWidget::Footer : public TabbedSelector::InnerFooter {
 public:
 	Footer(not_null<EmojiListWidget*> parent);
@@ -102,6 +104,7 @@ private:
 	std::array<object_ptr<Ui::IconButton>, kEmojiSectionCount> _sections;
 
 };
+#endif
 
 struct EmojiListWidget::CustomInstance {
 	CustomInstance(
@@ -127,6 +130,7 @@ EmojiListWidget::CustomInstance::CustomInstance(
 , object(&emoji, std::move(repaint)) {
 }
 
+#if 0
 EmojiListWidget::Footer::Footer(not_null<EmojiListWidget*> parent)
 : InnerFooter(parent)
 , _pan(parent)
@@ -185,6 +189,7 @@ void EmojiListWidget::Footer::setCurrentSectionIcon(Section section) {
 void EmojiListWidget::Footer::setActiveSection(Ui::Emoji::Section section) {
 	_pan->showEmojiSection(section);
 }
+#endif
 
 EmojiColorPicker::EmojiColorPicker(QWidget *parent)
 : RpWidget(parent) {
@@ -552,7 +557,9 @@ void EmojiListWidget::visibleTopBottomUpdated(
 		int visibleBottom) {
 	Inner::visibleTopBottomUpdated(visibleTop, visibleBottom);
 	if (_footer) {
-		_footer->setCurrentSectionIcon(currentSection(visibleTop));
+		_footer->validateSelectedIcon(
+			currentSet(visibleTop),
+			ValidateIconAnimations::Full);
 	}
 	unloadNotSeenCustom(visibleTop, visibleBottom);
 }
@@ -580,8 +587,19 @@ void EmojiListWidget::unloadNotSeenCustom(
 
 object_ptr<TabbedSelector::InnerFooter> EmojiListWidget::createFooter() {
 	Expects(_footer == nullptr);
-	auto result = object_ptr<Footer>(this);
+
+	using FooterDescriptor = StickersListFooter::Descriptor;
+	auto result = object_ptr<StickersListFooter>(FooterDescriptor{
+		.controller = controller(),
+		.parent = this,
+	});
 	_footer = result;
+
+	_footer->setChosen(
+	) | rpl::start_with_next([=](uint64 setId) {
+		showSet(setId);
+	}, _footer->lifetime());
+
 	return result;
 }
 
@@ -665,7 +683,17 @@ int EmojiListWidget::countDesiredHeight(int newWidth) {
 	_rowsLeft -= st::roundRadiusSmall;
 	_singleSize = QSize(singleWidth, singleWidth - 4 * st::lineWidth);
 	_picker->setSingleSize(_singleSize);
-	return sectionInfo(sectionsCount() - 1).rowsBottom + st::emojiPanPadding;
+
+	auto visibleHeight = minimalHeight();
+	auto minimalHeight = (visibleHeight - st::stickerPanPadding);
+	auto countResult = [this](int minimalLastHeight) {
+		const auto info = sectionInfo(sectionsCount() - 1);
+		return info.top
+			+ qMax(info.rowsBottom - info.top, minimalLastHeight);
+	};
+	const auto minimalLastHeight = minimalHeight;
+	return qMax(minimalHeight, countResult(minimalLastHeight))
+		+ st::emojiPanPadding;
 }
 
 void EmojiListWidget::ensureLoaded(int section) {
@@ -1052,8 +1080,8 @@ void EmojiListWidget::clearSelection() {
 	_lastMousePos = mapToGlobal(QPoint(-10, -10));
 }
 
-Ui::Emoji::Section EmojiListWidget::currentSection(int yOffset) const {
-	return static_cast<Section>(sectionInfoByOffset(yOffset).section);
+uint64 EmojiListWidget::currentSet(int yOffset) const {
+	return sectionSetId(sectionInfoByOffset(yOffset).section);
 }
 
 QString EmojiListWidget::tooltipText() const {
@@ -1132,7 +1160,7 @@ void EmojiListWidget::refreshCustom() {
 				return true;
 			}();
 			if (valid) {
-				_custom.push_back(base::take(*i));
+				_custom.push_back(std::move(*i));
 				continue;
 			}
 		}
@@ -1170,10 +1198,51 @@ void EmojiListWidget::refreshCustom() {
 		}
 		_custom.push_back({
 			.id = setId,
+			.set = it->second.get(),
 			.title = it->second->title,
 			.list = std::move(set),
 		});
 	}
+	_footer->refreshIcons(
+		fillIcons(),
+		nullptr,
+		ValidateIconAnimations::None);
+}
+
+std::vector<StickerIcon> EmojiListWidget::fillIcons() {
+	auto result = std::vector<StickerIcon>();
+	result.reserve(kEmojiSectionCount + _custom.size());
+
+	for (auto i = 0; i != kEmojiSectionCount; ++i) {
+		result.emplace_back(EmojiSectionSetId(static_cast<Section>(i)));
+	}
+	for (const auto &custom : _custom) {
+		const auto set = custom.set;
+		const auto s = custom.list[0].document;
+		const auto availw = st::stickerIconWidth - 2 * st::stickerIconPadding;
+		const auto availh = st::emojiFooterHeight - 2 * st::stickerIconPadding;
+		const auto size = set->hasThumbnail()
+			? QSize(
+				set->thumbnailLocation().width(),
+				set->thumbnailLocation().height())
+			: s->hasThumbnail()
+			? QSize(
+				s->thumbnailLocation().width(),
+				s->thumbnailLocation().height())
+			: QSize();
+		auto thumbw = size.width(), thumbh = size.height(), pixw = 1, pixh = 1;
+		if (availw * thumbh > availh * thumbw) {
+			pixh = availh;
+			pixw = (pixh * thumbw) / thumbh;
+		} else {
+			pixw = availw;
+			pixh = thumbw ? ((pixw * thumbh) / thumbw) : 1;
+		}
+		if (pixw < 1) pixw = 1;
+		if (pixh < 1) pixh = 1;
+		result.emplace_back(set, s, pixw, pixh);
+	}
+	return result;
 }
 
 bool EmojiListWidget::eventHook(QEvent *e) {
@@ -1293,13 +1362,17 @@ QPoint EmojiListWidget::buttonRippleTopLeft(int section) const {
 }
 
 void EmojiListWidget::showEmojiSection(Section section) {
+	showSet(EmojiSectionSetId(section));
+}
+
+void EmojiListWidget::showSet(uint64 setId) {
 	clearSelection();
 
 	refreshRecent();
 
 	auto y = 0;
 	enumerateSections([&](const SectionInfo &info) {
-		if (static_cast<Section>(info.section) == section) {
+		if (setId == sectionSetId(info.section)) {
 			y = info.top;
 			return false;
 		}
@@ -1312,26 +1385,14 @@ void EmojiListWidget::showEmojiSection(Section section) {
 	update();
 }
 
-void EmojiListWidget::showCustomSet(uint64 setId) {
-	clearSelection();
+uint64 EmojiListWidget::sectionSetId(int section) const {
+	Expects(section < kEmojiSectionCount
+		|| (section - kEmojiSectionCount) < _custom.size());
 
-	refreshCustom();
+	return (section < kEmojiSectionCount)
+		? EmojiSectionSetId(static_cast<Section>(section))
+		: _custom[section - kEmojiSectionCount].id;
 
-	auto y = 0;
-	enumerateSections([&](const SectionInfo &info) {
-		if (info.section >= kEmojiSectionCount) {
-			if (_custom[info.section - kEmojiSectionCount].id == setId) {
-				y = info.top;
-				return false;
-			}
-		}
-		return true;
-	});
-	scrollTo(y);
-
-	_lastMousePos = QCursor::pos();
-
-	update();
 }
 
 tr::phrase<> EmojiCategoryTitle(int index) {
diff --git a/Telegram/SourceFiles/chat_helpers/emoji_list_widget.h b/Telegram/SourceFiles/chat_helpers/emoji_list_widget.h
index 0d57bbf2e..44f696a2f 100644
--- a/Telegram/SourceFiles/chat_helpers/emoji_list_widget.h
+++ b/Telegram/SourceFiles/chat_helpers/emoji_list_widget.h
@@ -11,6 +11,10 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
 #include "ui/widgets/tooltip.h"
 #include "base/timer.h"
 
+namespace Data {
+class StickersSet;
+} // namespace Data
+
 namespace tr {
 template <typename ...Tags>
 struct phrase;
@@ -37,7 +41,9 @@ namespace ChatHelpers {
 
 inline constexpr auto kEmojiSectionCount = 8;
 
+struct StickerIcon;
 class EmojiColorPicker;
+class StickersListFooter;
 
 class EmojiListWidget
 	: public TabbedSelector::Inner
@@ -55,9 +61,8 @@ public:
 	object_ptr<TabbedSelector::InnerFooter> createFooter() override;
 
 	void showEmojiSection(Section section);
-	[[nodiscard]] Section currentSection(int yOffset) const;
-
-	void showCustomSet(uint64 setId);
+	void showSet(uint64 setId);
+	[[nodiscard]] uint64 currentSet(int yOffset) const;
 
 	// Ui::AbstractTooltipShower interface.
 	QString tooltipText() const override;
@@ -87,8 +92,6 @@ protected:
 	int countDesiredHeight(int newWidth) override;
 
 private:
-	class Footer;
-
 	struct SectionInfo {
 		int section = 0;
 		int count = 0;
@@ -104,6 +107,7 @@ private:
 	};
 	struct CustomSet {
 		uint64 id = 0;
+		not_null<Data::StickersSet*> set;
 		QString title;
 		std::vector<CustomOne> list;
 		std::unique_ptr<Ui::RippleAnimation> ripple;
@@ -188,6 +192,8 @@ private:
 	[[nodiscard]] QRect emojiRect(int section, int index) const;
 	[[nodiscard]] int emojiRight() const;
 	[[nodiscard]] int emojiLeft() const;
+	[[nodiscard]] uint64 sectionSetId(int section) const;
+	[[nodiscard]] std::vector<StickerIcon> fillIcons();
 
 	void displaySet(uint64 setId);
 	void removeSet(uint64 setId);
@@ -204,7 +210,7 @@ private:
 	void scheduleRepaintTimer();
 	void invokeRepaints();
 
-	Footer *_footer = nullptr;
+	StickersListFooter *_footer = nullptr;
 
 	int _counts[kEmojiSectionCount];
 	QVector<EmojiPtr> _emoji[kEmojiSectionCount];
diff --git a/Telegram/SourceFiles/chat_helpers/stickers_list_footer.cpp b/Telegram/SourceFiles/chat_helpers/stickers_list_footer.cpp
new file mode 100644
index 000000000..e460f726a
--- /dev/null
+++ b/Telegram/SourceFiles/chat_helpers/stickers_list_footer.cpp
@@ -0,0 +1,936 @@
+/*
+This file is part of Telegram Desktop,
+the official desktop application for the Telegram messaging service.
+
+For license and copyright information please follow this link:
+https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
+*/
+#include "chat_helpers/stickers_list_footer.h"
+
+#include "chat_helpers/stickers_lottie.h"
+#include "data/stickers/data_stickers_set.h"
+#include "data/stickers/data_stickers.h"
+#include "data/data_file_origin.h"
+#include "data/data_channel.h"
+#include "data/data_session.h"
+#include "data/data_document.h"
+#include "data/data_document_media.h"
+#include "main/main_session.h"
+#include "lang/lang_keys.h"
+#include "lottie/lottie_single_player.h"
+#include "ui/widgets/input_fields.h"
+#include "ui/widgets/buttons.h"
+#include "window/window_session_controller.h"
+#include "styles/style_chat_helpers.h"
+
+#include <QtWidgets/QApplication>
+
+namespace ChatHelpers {
+namespace {
+
+constexpr auto kEmojiSectionSetIdBase = uint64(0x77FF'FFFF'FFFF'FFF0ULL);
+
+using EmojiSection = Ui::Emoji::Section;
+
+} // namespace
+
+uint64 EmojiSectionSetId(EmojiSection section) {
+	Expects(section >= EmojiSection::Recent
+		&& section <= EmojiSection::Symbols);
+
+	return kEmojiSectionSetIdBase + static_cast<uint64>(section);
+}
+
+std::optional<EmojiSection> SetIdEmojiSection(uint64 id) {
+	const auto base = EmojiSectionSetId(EmojiSection::Recent);
+	if (id < base) {
+		return {};
+	}
+	const auto index = id - base;
+	return (index <= uint64(EmojiSection::Symbols))
+		? static_cast<EmojiSection>(index)
+		: std::optional<EmojiSection>();
+}
+
+StickerIcon::StickerIcon(uint64 setId) : setId(setId) {
+}
+
+StickerIcon::StickerIcon(
+	not_null<Data::StickersSet*> set,
+	DocumentData *sticker,
+	int pixw,
+	int pixh)
+: setId(set->id)
+, set(set)
+, sticker(sticker)
+, pixw(pixw)
+, pixh(pixh) {
+}
+
+StickerIcon::StickerIcon(StickerIcon&&) = default;
+
+StickerIcon &StickerIcon::operator=(StickerIcon&&) = default;
+
+StickerIcon::~StickerIcon() = default;
+
+void StickerIcon::ensureMediaCreated() const {
+	if (!sticker) {
+		return;
+	} else if (set->hasThumbnail()) {
+		if (!thumbnailMedia) {
+			thumbnailMedia = set->createThumbnailView();
+			set->loadThumbnail();
+		}
+	} else if (!stickerMedia) {
+		stickerMedia = sticker->createMediaView();
+		stickerMedia->thumbnailWanted(sticker->stickerSetOrigin());
+	}
+}
+
+StickersListFooter::StickersListFooter(Descriptor &&descriptor)
+: InnerFooter(descriptor.parent)
+, _controller(descriptor.controller)
+, _searchButtonVisible(descriptor.searchButtonVisible)
+, _settingsButtonVisible(descriptor.settingsButtonVisible)
+, _iconsAnimation([=](crl::time now) {
+	return iconsAnimationCallback(now);
+}) {
+	setMouseTracking(true);
+
+	_iconsLeft = st::emojiCategorySkip + (_searchButtonVisible
+		? st::stickerIconWidth
+		: 0);
+	_iconsRight = st::emojiCategorySkip + (_settingsButtonVisible
+		? st::stickerIconWidth
+		: 0);
+
+	_controller->session().downloaderTaskFinished(
+	) | rpl::start_with_next([=] {
+		update();
+	}, lifetime());
+
+	style::PaletteChanged(
+	) | rpl::start_with_next([=] {
+		_premiumIcon = QImage();
+	}, lifetime());
+}
+
+void StickersListFooter::validatePremiumIcon() const {
+	if (!_premiumIcon.isNull()) {
+		return;
+	}
+	const auto size = st::stickersPremium.size();
+	const auto mask = st::stickersPremium.instance(Qt::white);
+	const auto factor = style::DevicePixelRatio();
+	_premiumIcon = QImage(
+		size * factor,
+		QImage::Format_ARGB32_Premultiplied);
+	_premiumIcon.setDevicePixelRatio(factor);
+
+	QPainter p(&_premiumIcon);
+	auto gradient = QLinearGradient(
+		QPoint(0, size.height()),
+		QPoint(size.width(), 0));
+	gradient.setStops({
+		{ 0., st::stickerPanPremium1->c },
+		{ 1., st::stickerPanPremium2->c },
+	});
+	p.fillRect(QRect(QPoint(), size), gradient);
+	p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
+	p.drawImage(QRect(QPoint(), size), mask);
+}
+
+void StickersListFooter::clearHeavyData() {
+	const auto count = int(_icons.size());
+	const auto iconsX = qRound(_iconsX.current());
+	enumerateIcons([&](const IconInfo &info) {
+		auto &icon = _icons[info.index];
+		icon.webm = nullptr;
+		icon.lottie = nullptr;
+		icon.lifetime.destroy();
+		icon.stickerMedia = nullptr;
+		if (!info.visible) {
+			icon.savedFrame = QPixmap();
+		}
+	});
+}
+
+void StickersListFooter::initSearch() {
+	_searchField.create(
+		this,
+		st::gifsSearchField,
+		tr::lng_stickers_search_sets());
+	_searchCancel.create(this, st::gifsSearchCancel);
+	_searchField->show();
+	_searchCancel->show(anim::type::instant);
+
+	const auto cancelSearch = [=] {
+		if (_searchField->getLastText().isEmpty()) {
+			toggleSearch(false);
+		} else {
+			_searchField->setText(QString());
+		}
+	};
+	connect(_searchField, &Ui::InputField::submitted, [=] {
+		_searchRequests.fire({
+			.text = _searchField->getLastText(),
+			.forced = true,
+		});
+	});
+	connect(_searchField, &Ui::InputField::cancelled, cancelSearch);
+	connect(_searchField, &Ui::InputField::changed, [=] {
+		_searchRequests.fire({
+			.text = _searchField->getLastText(),
+		});
+	});
+	_searchCancel->setClickedCallback(cancelSearch);
+
+	resizeSearchControls();
+}
+
+void StickersListFooter::toggleSearch(bool visible) {
+	if (_searchShown == visible) {
+		return;
+	}
+	_searchShown = visible;
+	if (_searchShown) {
+		initSearch();
+		stealFocus();
+	} else if (_searchField) {
+		returnFocus();
+		_searchField.destroy();
+		_searchCancel.destroy();
+		_focusTakenFrom = nullptr;
+	}
+	update();
+}
+
+void StickersListFooter::stealFocus() {
+	if (_searchField) {
+		if (!_focusTakenFrom) {
+			_focusTakenFrom = QApplication::focusWidget();
+		}
+		_searchField->setFocus();
+	}
+}
+
+void StickersListFooter::returnFocus() {
+	if (_searchField && _focusTakenFrom) {
+		if (_searchField->hasFocus()) {
+			_focusTakenFrom->setFocus();
+		}
+		_focusTakenFrom = nullptr;
+	}
+}
+
+void StickersListFooter::enumerateVisibleIcons(
+		Fn<void(const IconInfo &)> callback) {
+	auto iconsX = qRound(_iconsX.current());
+	auto x = _iconsLeft - (iconsX % st::stickerIconWidth);
+	auto first = floorclamp(iconsX, st::stickerIconWidth, 0, _icons.size());
+	auto last = ceilclamp(
+		iconsX + width(),
+		st::stickerIconWidth,
+		0,
+		_icons.size());
+	for (auto index = first; index != last; ++index) {
+		callback({ .index = index, .left = x, .visible = true });
+		x += st::stickerIconWidth;
+	}
+}
+
+void StickersListFooter::enumerateIcons(
+		Fn<void(const IconInfo &)> callback) {
+	auto iconsX = qRound(_iconsX.current());
+	auto x = _iconsLeft - (iconsX % st::stickerIconWidth);
+	auto first = floorclamp(iconsX, st::stickerIconWidth, 0, _icons.size());
+	auto last = ceilclamp(
+		iconsX + width(),
+		st::stickerIconWidth,
+		0,
+		_icons.size());
+	x -= first * st::stickerIconWidth;
+	for (auto i = 0, count = int(_icons.size()); i != count; ++i) {
+		const auto visible = (i >= first && i < last);
+		callback({ .index = i, .left = x, .visible = visible });
+		x += st::stickerIconWidth;
+	}
+}
+
+void StickersListFooter::preloadImages() {
+	enumerateVisibleIcons([&](const IconInfo &info) {
+		const auto &icon = _icons[info.index];
+		if (const auto sticker = icon.sticker) {
+			Assert(icon.set != nullptr);
+			if (icon.set->hasThumbnail()) {
+				icon.set->loadThumbnail();
+			} else {
+				sticker->loadThumbnail(sticker->stickerSetOrigin());
+			}
+		}
+	});
+}
+
+void StickersListFooter::validateSelectedIcon(
+		uint64 setId,
+		ValidateIconAnimations animations) {
+	_activeByScrollId = setId;
+
+	auto favedIconIndex = -1;
+	auto newSelected = -1;
+	for (auto i = 0, l = int(_icons.size()); i != l; ++i) {
+		if (_icons[i].setId == setId
+			|| (_icons[i].setId == Data::Stickers::FavedSetId
+				&& setId == Data::Stickers::RecentSetId)) {
+			newSelected = i;
+			break;
+		} else if (_icons[i].setId == Data::Stickers::FavedSetId) {
+			favedIconIndex = i;
+		}
+	}
+	setSelectedIcon(
+		(newSelected >= 0
+			? newSelected
+			: (favedIconIndex >= 0) ? favedIconIndex : 0),
+		animations);
+}
+
+void StickersListFooter::setSelectedIcon(
+		int newSelected,
+		ValidateIconAnimations animations) {
+	if (_iconSel == newSelected) {
+		return;
+	}
+	_iconSel = newSelected;
+	auto iconSelXFinal = _iconSel * st::stickerIconWidth;
+	if (animations == ValidateIconAnimations::Full) {
+		_iconSelX.start(iconSelXFinal);
+	} else {
+		_iconSelX = anim::value(iconSelXFinal, iconSelXFinal);
+	}
+	auto iconsCountForCentering = (2 * _iconSel + 1);
+	auto iconsWidthForCentering = iconsCountForCentering
+		* st::stickerIconWidth;
+	auto iconsXFinal = std::clamp(
+		(_iconsLeft + iconsWidthForCentering + _iconsRight - width()) / 2,
+		0,
+		_iconsMax);
+	if (animations == ValidateIconAnimations::None) {
+		_iconsX = anim::value(iconsXFinal, iconsXFinal);
+		_iconsAnimation.stop();
+	} else {
+		_iconsX.start(iconsXFinal);
+		_iconsStartAnim = crl::now();
+		_iconsAnimation.start();
+	}
+	updateSelected();
+	update();
+}
+
+void StickersListFooter::processHideFinished() {
+	_iconOver = _iconDown = SpecialOver::None;
+	_iconsStartAnim = 0;
+	_iconsAnimation.stop();
+	_iconsX.finish();
+	_iconSelX.finish();
+	_horizontal = false;
+}
+
+void StickersListFooter::leaveToChildEvent(QEvent *e, QWidget *child) {
+	_iconsMousePos = QCursor::pos();
+	updateSelected();
+}
+
+void StickersListFooter::setLoading(bool loading) {
+	if (_searchCancel) {
+		_searchCancel->setLoadingAnimation(loading);
+	}
+}
+
+void StickersListFooter::paintEvent(QPaintEvent *e) {
+	Painter p(this);
+
+	if (_searchButtonVisible) {
+		paintSearchIcon(p);
+	}
+	if (_icons.empty() || _searchShown) {
+		return;
+	}
+
+	if (_settingsButtonVisible && !hasOnlyFeaturedSets()) {
+		paintStickerSettingsIcon(p);
+	}
+
+	auto clip = QRect(
+		_iconsLeft,
+		_iconsTop,
+		width() - _iconsLeft - _iconsRight,
+		st::emojiFooterHeight);
+	if (rtl()) {
+		clip.moveLeft(width() - _iconsLeft - clip.width());
+	}
+	p.setClipRect(clip);
+
+	const auto now = crl::now();
+	const auto paused = _controller->isGifPausedAtLeastFor(
+		Window::GifPauseReason::SavedGifs);
+	enumerateVisibleIcons([&](const IconInfo &info) {
+		paintSetIcon(p, info, now, paused);
+	});
+
+	paintSelectionBar(p);
+	paintLeftRightFading(p);
+}
+
+void StickersListFooter::paintSelectionBar(Painter &p) const {
+	auto selxrel = _iconsLeft + qRound(_iconSelX.current());
+	auto selx = selxrel - qRound(_iconsX.current());
+	if (rtl()) {
+		selx = width() - selx - st::stickerIconWidth;
+	}
+	p.fillRect(
+		selx,
+		_iconsTop + st::emojiFooterHeight - st::stickerIconPadding,
+		st::stickerIconWidth,
+		st::stickerIconSel,
+		st::stickerIconSelColor);
+}
+
+void StickersListFooter::paintLeftRightFading(Painter &p) const {
+	auto o_left = std::clamp(
+		_iconsX.current() / st::stickerIconLeft.width(),
+		0.,
+		1.);
+	if (o_left > 0) {
+		p.setOpacity(o_left);
+		st::stickerIconLeft.fill(p, style::rtlrect(_iconsLeft, _iconsTop, st::stickerIconLeft.width(), st::emojiFooterHeight, width()));
+		p.setOpacity(1.);
+	}
+	auto o_right = std::clamp(
+		(_iconsMax - _iconsX.current()) / st::stickerIconRight.width(),
+		0.,
+		1.);
+	if (o_right > 0) {
+		p.setOpacity(o_right);
+		st::stickerIconRight.fill(p, style::rtlrect(width() - _iconsRight - st::stickerIconRight.width(), _iconsTop, st::stickerIconRight.width(), st::emojiFooterHeight, width()));
+		p.setOpacity(1.);
+	}
+}
+
+void StickersListFooter::resizeEvent(QResizeEvent *e) {
+	if (_searchField) {
+		resizeSearchControls();
+	}
+	refreshIconsGeometry(ValidateIconAnimations::None);
+}
+
+void StickersListFooter::resizeSearchControls() {
+	Expects(_searchField != nullptr);
+	Expects(_searchCancel != nullptr);
+
+	const auto fieldWidth = width()
+		- st::gifsSearchFieldPosition.x()
+		- st::gifsSearchCancelPosition.x()
+		- st::gifsSearchCancel.width;
+	_searchField->resizeToWidth(fieldWidth);
+	_searchField->moveToLeft(st::gifsSearchFieldPosition.x(), st::gifsSearchFieldPosition.y());
+	_searchCancel->moveToRight(st::gifsSearchCancelPosition.x(), st::gifsSearchCancelPosition.y());
+}
+
+rpl::producer<uint64> StickersListFooter::setChosen() const {
+	return _setChosen.events();
+}
+
+rpl::producer<> StickersListFooter::openSettingsRequests() const {
+	return _openSettingsRequests.events();
+}
+
+rpl::producer<StickersListFooter::SearchRequest> StickersListFooter::searchRequests() const {
+	return _searchRequests.events();
+}
+
+void StickersListFooter::mousePressEvent(QMouseEvent *e) {
+	if (e->button() != Qt::LeftButton) {
+		return;
+	}
+	_iconsMousePos = e ? e->globalPos() : QCursor::pos();
+	updateSelected();
+
+	if (_iconOver == SpecialOver::Settings) {
+		_openSettingsRequests.fire({});
+	} else if (_iconOver == SpecialOver::Search) {
+		toggleSearch(true);
+	} else {
+		_iconDown = _iconOver;
+		_iconsMouseDown = _iconsMousePos;
+		_iconsStartX = qRound(_iconsX.current());
+	}
+}
+
+void StickersListFooter::mouseMoveEvent(QMouseEvent *e) {
+	_iconsMousePos = e ? e->globalPos() : QCursor::pos();
+	updateSelected();
+
+	if (!_iconsDragging
+		&& !_icons.empty()
+		&& v::is<int>(_iconDown)) {
+		if ((_iconsMousePos - _iconsMouseDown).manhattanLength() >= QApplication::startDragDistance()) {
+			_iconsDragging = true;
+		}
+	}
+	if (_iconsDragging) {
+		auto newX = std::clamp(
+			(rtl() ? -1 : 1) * (_iconsMouseDown.x() - _iconsMousePos.x())
+				+ _iconsStartX,
+			0,
+			_iconsMax);
+		if (newX != qRound(_iconsX.current())) {
+			_iconsX = anim::value(newX, newX);
+			_iconsStartAnim = 0;
+			_iconsAnimation.stop();
+			update();
+		}
+	}
+}
+
+void StickersListFooter::mouseReleaseEvent(QMouseEvent *e) {
+	if (_icons.empty()) {
+		return;
+	}
+
+	const auto wasDown = std::exchange(_iconDown, SpecialOver::None);
+
+	_iconsMousePos = e ? e->globalPos() : QCursor::pos();
+	if (_iconsDragging) {
+		finishDragging();
+		return;
+	}
+
+	updateSelected();
+	if (wasDown == _iconOver) {
+		if (const auto index = std::get_if<int>(&_iconOver)) {
+			_iconSelX = anim::value(
+				*index * st::stickerIconWidth,
+				*index * st::stickerIconWidth);
+			_setChosen.fire_copy(_icons[*index].setId);
+		}
+	}
+}
+
+void StickersListFooter::finishDragging() {
+	auto newX = std::clamp(
+		_iconsStartX + _iconsMouseDown.x() - _iconsMousePos.x(),
+		0,
+		_iconsMax);
+	if (newX != qRound(_iconsX.current())) {
+		_iconsX = anim::value(newX, newX);
+		_iconsStartAnim = 0;
+		_iconsAnimation.stop();
+		update();
+	}
+	_iconsDragging = false;
+	updateSelected();
+}
+
+bool StickersListFooter::eventHook(QEvent *e) {
+	if (e->type() == QEvent::TouchBegin) {
+	} else if (e->type() == QEvent::Wheel) {
+		if (!_icons.empty()
+			&& v::is<int>(_iconOver)
+			&& (_iconDown == SpecialOver::None)) {
+			scrollByWheelEvent(static_cast<QWheelEvent*>(e));
+		}
+	}
+	return InnerFooter::eventHook(e);
+}
+
+void StickersListFooter::scrollByWheelEvent(
+		not_null<QWheelEvent*> e) {
+	auto horizontal = (e->angleDelta().x() != 0);
+	auto vertical = (e->angleDelta().y() != 0);
+	if (horizontal) {
+		_horizontal = true;
+	}
+	auto newX = qRound(_iconsX.current());
+	if (/*_horizontal && */horizontal) {
+		newX = std::clamp(
+			newX - (rtl() ? -1 : 1) * (e->pixelDelta().x()
+				? e->pixelDelta().x()
+				: e->angleDelta().x()),
+			0,
+			_iconsMax);
+	} else if (/*!_horizontal && */vertical) {
+		newX = std::clamp(
+			newX - (e->pixelDelta().y()
+				? e->pixelDelta().y()
+				: e->angleDelta().y()),
+			0,
+			_iconsMax);
+	}
+	if (newX != qRound(_iconsX.current())) {
+		_iconsX = anim::value(newX, newX);
+		_iconsStartAnim = 0;
+		_iconsAnimation.stop();
+		updateSelected();
+		update();
+	}
+}
+
+void StickersListFooter::clipCallback(
+		Media::Clip::Notification notification,
+		uint64 setId) {
+	using namespace Media::Clip;
+	switch (notification) {
+	case Notification::Reinit: {
+		enumerateIcons([&](const IconInfo &info) {
+			auto &icon = _icons[info.index];
+			if (icon.setId != setId || !icon.webm) {
+				return;
+			} else if (icon.webm->state() == State::Error) {
+				icon.webm.setBad();
+			} else if (!info.visible) {
+				icon.webm = nullptr;
+			} else if (icon.webm->ready() && !icon.webm->started()) {
+				icon.webm->start({
+					.frame = { icon.pixw, icon.pixh },
+					.keepAlpha = true,
+				});
+			}
+			updateSetIconAt(info.left);
+		});
+	} break;
+
+	case Notification::Repaint:
+		updateSetIcon(setId);
+		break;
+	}
+}
+
+void StickersListFooter::updateSelected() {
+	if (_iconDown != SpecialOver::None) {
+		return;
+	}
+
+	auto p = mapFromGlobal(_iconsMousePos);
+	auto x = p.x(), y = p.y();
+	if (rtl()) x = width() - x;
+	const auto settingsLeft = width() - _iconsRight;
+	const auto searchLeft = _iconsLeft - st::stickerIconWidth;
+	auto newOver = OverState(SpecialOver::None);
+	if (_searchButtonVisible
+		&& x >= searchLeft
+		&& x < searchLeft + st::stickerIconWidth
+		&& y >= _iconsTop
+		&& y < _iconsTop + st::emojiFooterHeight) {
+		newOver = SpecialOver::Search;
+	} else if (_settingsButtonVisible
+		&& x >= settingsLeft
+		&& x < settingsLeft + st::stickerIconWidth
+		&& y >= _iconsTop
+		&& y < _iconsTop + st::emojiFooterHeight) {
+		if (!_icons.empty() && !hasOnlyFeaturedSets()) {
+			newOver = SpecialOver::Settings;
+		}
+	} else if (!_icons.empty()) {
+		if (y >= _iconsTop
+			&& y < _iconsTop + st::emojiFooterHeight
+			&& x >= _iconsLeft
+			&& x < width() - _iconsRight) {
+			x += qRound(_iconsX.current()) - _iconsLeft;
+			if (x < _icons.size() * st::stickerIconWidth) {
+				newOver = qFloor(x / st::stickerIconWidth);
+			}
+		}
+	}
+	if (newOver != _iconOver) {
+		if (newOver == SpecialOver::None) {
+			setCursor(style::cur_default);
+		} else if (_iconOver == SpecialOver::None) {
+			setCursor(style::cur_pointer);
+		}
+		_iconOver = newOver;
+	}
+}
+
+auto StickersListFooter::getLottieRenderer()
+-> std::shared_ptr<Lottie::FrameRenderer> {
+	if (auto result = _lottieRenderer.lock()) {
+		return result;
+	}
+	auto result = Lottie::MakeFrameRenderer();
+	_lottieRenderer = result;
+	return result;
+}
+
+void StickersListFooter::refreshIcons(
+		std::vector<StickerIcon> icons,
+		Fn<std::shared_ptr<Lottie::FrameRenderer>()> renderer,
+		ValidateIconAnimations animations) {
+	_renderer = renderer
+		? std::move(renderer)
+		: [=] { return getLottieRenderer(); };
+
+	auto indices = base::flat_map<uint64, int>();
+	indices.reserve(_icons.size());
+	auto index = 0;
+	for (const auto &entry : _icons) {
+		indices.emplace(entry.setId, index++);
+	}
+
+	for (auto &now : icons) {
+		if (const auto i = indices.find(now.setId); i != end(indices)) {
+			auto &was = _icons[i->second];
+			if (now.sticker == was.sticker) {
+				now.webm = std::move(was.webm);
+				now.lottie = std::move(was.lottie);
+				now.lifetime = std::move(was.lifetime);
+				now.savedFrame = std::move(was.savedFrame);
+			}
+		}
+	}
+
+	_icons = std::move(icons);
+	refreshIconsGeometry(animations);
+}
+
+void StickersListFooter::refreshIconsGeometry(
+		ValidateIconAnimations animations) {
+	_iconOver = _iconDown = SpecialOver::None;
+	_iconsX.finish();
+	_iconSelX.finish();
+	_iconsStartAnim = 0;
+	_iconsAnimation.stop();
+	_iconsMax = std::max(
+		_iconsLeft + int(_icons.size()) * st::stickerIconWidth + _iconsRight - width(),
+		0);
+	if (_iconsX.current() > _iconsMax) {
+		_iconsX = anim::value(_iconsMax, _iconsMax);
+	}
+	updateSelected();
+	validateSelectedIcon(_activeByScrollId, animations);
+	update();
+}
+
+bool StickersListFooter::hasOnlyFeaturedSets() const {
+	return (_icons.size() == 1)
+		&& (_icons[0].setId == Data::Stickers::FeaturedSetId);
+}
+
+void StickersListFooter::paintStickerSettingsIcon(Painter &p) const {
+	const auto settingsLeft = width() - _iconsRight;
+	st::stickersSettings.paint(
+		p,
+		settingsLeft
+			+ (st::stickerIconWidth - st::stickersSettings.width()) / 2,
+		_iconsTop + st::emojiCategory.iconPosition.y(),
+		width());
+}
+
+void StickersListFooter::paintSearchIcon(Painter &p) const {
+	const auto searchLeft = _iconsLeft - st::stickerIconWidth;
+	st::stickersSearch.paint(
+		p,
+		searchLeft + (st::stickerIconWidth - st::stickersSearch.width()) / 2,
+		_iconsTop + st::emojiCategory.iconPosition.y(),
+		width());
+}
+
+void StickersListFooter::validateIconLottieAnimation(
+		const StickerIcon &icon) {
+	icon.ensureMediaCreated();
+	if (icon.lottie
+		|| !icon.sticker
+		|| !HasLottieThumbnail(
+			icon.set ? icon.set->flags : Data::StickersSetFlags(),
+			icon.thumbnailMedia.get(),
+			icon.stickerMedia.get())) {
+		return;
+	}
+	auto player = LottieThumbnail(
+		icon.thumbnailMedia.get(),
+		icon.stickerMedia.get(),
+		StickerLottieSize::StickersFooter,
+		QSize(
+			st::stickerIconWidth - 2 * st::stickerIconPadding,
+			st::emojiFooterHeight - 2 * st::stickerIconPadding
+		) * cIntRetinaFactor(),
+		_renderer());
+	if (!player) {
+		return;
+	}
+	icon.lottie = std::move(player);
+
+	const auto id = icon.setId;
+	icon.lottie->updates(
+	) | rpl::start_with_next([=] {
+		updateSetIcon(id);
+	}, icon.lifetime);
+}
+
+void StickersListFooter::validateIconWebmAnimation(
+		const StickerIcon &icon) {
+	icon.ensureMediaCreated();
+	if (icon.webm
+		|| !icon.sticker
+		|| !HasWebmThumbnail(
+			icon.set ? icon.set->flags : Data::StickersSetFlags(),
+			icon.thumbnailMedia.get(),
+			icon.stickerMedia.get())) {
+		return;
+	}
+	const auto id = icon.setId;
+	auto callback = [=](Media::Clip::Notification notification) {
+		clipCallback(notification, id);
+	};
+	icon.webm = WebmThumbnail(
+		icon.thumbnailMedia.get(),
+		icon.stickerMedia.get(),
+		std::move(callback));
+}
+
+void StickersListFooter::validateIconAnimation(
+		const StickerIcon &icon) {
+	validateIconWebmAnimation(icon);
+	validateIconLottieAnimation(icon);
+}
+
+void StickersListFooter::updateSetIcon(uint64 setId) {
+	enumerateVisibleIcons([&](const IconInfo &info) {
+		if (_icons[info.index].setId != setId) {
+			return;
+		}
+		updateSetIconAt(info.left);
+	});
+}
+
+void StickersListFooter::updateSetIconAt(int left) {
+	update(left, _iconsTop, st::stickerIconWidth, st::emojiFooterHeight);
+}
+
+void StickersListFooter::paintSetIcon(
+		Painter &p,
+		const IconInfo &info,
+		crl::time now,
+		bool paused) const {
+	const auto &icon = _icons[info.index];
+	if (icon.sticker) {
+		icon.ensureMediaCreated();
+		const_cast<StickersListFooter*>(this)->validateIconAnimation(icon);
+		const auto origin = icon.sticker->stickerSetOrigin();
+		const auto thumb = icon.thumbnailMedia
+			? icon.thumbnailMedia->image()
+			: icon.stickerMedia
+			? icon.stickerMedia->thumbnail()
+			: nullptr;
+		const auto x = info.left + (st::stickerIconWidth - icon.pixw) / 2;
+		const auto y = _iconsTop + (st::emojiFooterHeight - icon.pixh) / 2;
+		if (icon.lottie && icon.lottie->ready()) {
+			const auto frame = icon.lottie->frame();
+			const auto size = frame.size() / cIntRetinaFactor();
+			if (icon.savedFrame.isNull()) {
+				icon.savedFrame = QPixmap::fromImage(frame, Qt::ColorOnly);
+				icon.savedFrame.setDevicePixelRatio(cRetinaFactor());
+			}
+			p.drawImage(
+				QRect(
+					info.left + (st::stickerIconWidth - size.width()) / 2,
+					_iconsTop + (st::emojiFooterHeight - size.height()) / 2,
+					size.width(),
+					size.height()),
+				frame);
+			if (!paused) {
+				icon.lottie->markFrameShown();
+			}
+		} else if (icon.webm && icon.webm->started()) {
+			const auto frame = icon.webm->current(
+				{ .frame = { icon.pixw, icon.pixh }, .keepAlpha = true },
+				paused ? 0 : now);
+			if (icon.savedFrame.isNull()) {
+				icon.savedFrame = frame;
+				icon.savedFrame.setDevicePixelRatio(cRetinaFactor());
+			}
+			p.drawPixmapLeft(x, y, width(), frame);
+		} else if (!icon.savedFrame.isNull() || thumb) {
+			const auto pixmap = !icon.savedFrame.isNull()
+				? icon.savedFrame
+				: (!icon.lottie && thumb)
+				? thumb->pix(icon.pixw, icon.pixh)
+				: QPixmap();
+			if (pixmap.isNull()) {
+				return;
+			} else if (icon.savedFrame.isNull()) {
+				icon.savedFrame = pixmap;
+			}
+			p.drawPixmapLeft(x, y, width(), pixmap);
+		}
+	} else if (icon.megagroup) {
+		const auto size = st::stickerGroupCategorySize;
+		icon.megagroup->paintUserpicLeft(
+			p,
+			icon.megagroupUserpic,
+			info.left + (st::stickerIconWidth - size) / 2,
+			_iconsTop + (st::emojiFooterHeight - size) / 2,
+			width(),
+			st::stickerGroupCategorySize);
+	} else if (icon.setId == Data::Stickers::PremiumSetId) {
+		validatePremiumIcon();
+		const auto size = st::stickersPremium.size();
+		p.drawImage(
+			info.left + (st::stickerIconWidth - size.width()) / 2,
+			_iconsTop + (st::emojiFooterHeight - size.height()) / 2,
+			_premiumIcon);
+	} else {
+		const auto paintedIcon = [&] {
+			if (icon.setId == Data::Stickers::FeaturedSetId) {
+				const auto session = &_controller->session();
+				return session->data().stickers().featuredSetsUnreadCount()
+					? &st::stickersTrendingUnread
+					: &st::stickersTrending;
+			//} else if (setId == Stickers::FavedSetId) {
+			//	return &st::stickersFaved;
+			} else if (const auto section = SetIdEmojiSection(icon.setId)) {
+				using Section = Ui::Emoji::Section;
+				switch (*section) {
+				case Section::Recent: return &st::emojiRecent;
+				case Section::People: return &st::emojiPeople;
+				case Section::Nature: return &st::emojiNature;
+				case Section::Food: return &st::emojiFood;
+				case Section::Activity: return &st::emojiActivity;
+				case Section::Travel: return &st::emojiTravel;
+				case Section::Objects: return &st::emojiObjects;
+				case Section::Symbols: return &st::emojiSymbols;
+				}
+				Unexpected("Section in SetIdEmojiSection result.");
+			}
+			return &st::emojiRecent;
+		}();
+		paintedIcon->paint(
+			p,
+			info.left + (st::stickerIconWidth - paintedIcon->width()) / 2,
+			_iconsTop + (st::emojiFooterHeight - paintedIcon->height()) / 2,
+			width());
+	}
+}
+
+bool StickersListFooter::iconsAnimationCallback(crl::time now) {
+	if (anim::Disabled()) {
+		now += st::stickerIconMove;
+	}
+	if (_iconsStartAnim) {
+		const auto dt = (now - _iconsStartAnim) / float64(st::stickerIconMove);
+		if (dt >= 1.) {
+			_iconsStartAnim = 0;
+			_iconsX.finish();
+			_iconSelX.finish();
+		} else {
+			_iconsX.update(dt, anim::linear);
+			_iconSelX.update(dt, anim::linear);
+		}
+	}
+
+	update();
+
+	return (_iconsStartAnim != 0);
+}
+
+} // namespace ChatHelpers
diff --git a/Telegram/SourceFiles/chat_helpers/stickers_list_footer.h b/Telegram/SourceFiles/chat_helpers/stickers_list_footer.h
new file mode 100644
index 000000000..d5c1afded
--- /dev/null
+++ b/Telegram/SourceFiles/chat_helpers/stickers_list_footer.h
@@ -0,0 +1,207 @@
+/*
+This file is part of Telegram Desktop,
+the official desktop application for the Telegram messaging service.
+
+For license and copyright information please follow this link:
+https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
+*/
+#pragma once
+
+#include "media/clip/media_clip_reader.h"
+#include "chat_helpers/tabbed_selector.h"
+
+namespace Ui {
+class InputField;
+class CrossButton;
+} // namespace Ui
+
+namespace Data {
+class StickersSet;
+class StickersSetThumbnailView;
+class DocumentMedia;
+class CloudImageView;
+} // namespace Data
+
+namespace Lottie {
+class SinglePlayer;
+class FrameRenderer;
+} // namespace Lottie
+
+namespace Window {
+class SessionController;
+} // namespace Window
+
+namespace ChatHelpers {
+
+enum class ValidateIconAnimations {
+	Full,
+	Scroll,
+	None,
+};
+
+[[nodiscard]] uint64 EmojiSectionSetId(Ui::Emoji::Section section);
+[[nodiscard]] std::optional<Ui::Emoji::Section> SetIdEmojiSection(uint64 id);
+
+struct StickerIcon {
+	explicit StickerIcon(uint64 setId);
+	StickerIcon(
+		not_null<Data::StickersSet*> set,
+		DocumentData *sticker,
+		int pixw,
+		int pixh);
+	StickerIcon(StickerIcon&&);
+	StickerIcon &operator=(StickerIcon&&);
+	~StickerIcon();
+
+	void ensureMediaCreated() const;
+
+	uint64 setId = 0;
+	Data::StickersSet *set = nullptr;
+	mutable std::unique_ptr<Lottie::SinglePlayer> lottie;
+	mutable Media::Clip::ReaderPointer webm;
+	mutable QPixmap savedFrame;
+	DocumentData *sticker = nullptr;
+	ChannelData *megagroup = nullptr;
+	mutable std::shared_ptr<Data::StickersSetThumbnailView> thumbnailMedia;
+	mutable std::shared_ptr<Data::DocumentMedia> stickerMedia;
+	mutable std::shared_ptr<Data::CloudImageView> megagroupUserpic;
+	int pixw = 0;
+	int pixh = 0;
+	mutable rpl::lifetime lifetime;
+};
+
+class StickersListFooter final : public TabbedSelector::InnerFooter {
+public:
+	struct Descriptor {
+		not_null<Window::SessionController*> controller;
+		not_null<RpWidget*> parent;
+		bool searchButtonVisible = false;
+		bool settingsButtonVisible = false;
+	};
+	explicit StickersListFooter(Descriptor &&descriptor);
+
+	void preloadImages();
+	void validateSelectedIcon(
+		uint64 setId,
+		ValidateIconAnimations animations);
+	void refreshIcons(
+		std::vector<StickerIcon> icons,
+		Fn<std::shared_ptr<Lottie::FrameRenderer>()> renderer,
+		ValidateIconAnimations animations);
+	[[nodiscard]] bool hasOnlyFeaturedSets() const;
+
+	void leaveToChildEvent(QEvent *e, QWidget *child) override;
+
+	void stealFocus();
+	void returnFocus();
+	void setLoading(bool loading);
+
+	void clearHeavyData();
+
+	[[nodiscard]] rpl::producer<uint64> setChosen() const;
+	[[nodiscard]] rpl::producer<> openSettingsRequests() const;
+
+	struct SearchRequest {
+		QString text;
+		bool forced = false;
+	};
+	[[nodiscard]] rpl::producer<SearchRequest> searchRequests() const;
+
+protected:
+	void paintEvent(QPaintEvent *e) override;
+	void resizeEvent(QResizeEvent *e) override;
+	void mousePressEvent(QMouseEvent *e) override;
+	void mouseMoveEvent(QMouseEvent *e) override;
+	void mouseReleaseEvent(QMouseEvent *e) override;
+	bool eventHook(QEvent *e) override;
+
+	void processHideFinished() override;
+
+private:
+	enum class SpecialOver {
+		None,
+		Search,
+		Settings,
+	};
+	using OverState = std::variant<SpecialOver, int>;
+	struct IconInfo {
+		int index = 0;
+		int left = 0;
+		bool visible = false;
+	};
+
+	void enumerateVisibleIcons(Fn<void(const IconInfo &)> callback);
+	void enumerateIcons(Fn<void(const IconInfo &)> callback);
+
+	[[nodiscard]] std::shared_ptr<Lottie::FrameRenderer> getLottieRenderer();
+	bool iconsAnimationCallback(crl::time now);
+	void setSelectedIcon(
+		int newSelected,
+		ValidateIconAnimations animations);
+	void validateIconLottieAnimation(const StickerIcon &icon);
+	void validateIconWebmAnimation(const StickerIcon &icon);
+	void validateIconAnimation(const StickerIcon &icon);
+
+	void refreshIconsGeometry(ValidateIconAnimations animations);
+	void updateSelected();
+	void updateSetIcon(uint64 setId);
+	void updateSetIconAt(int left);
+	void finishDragging();
+	void paintStickerSettingsIcon(Painter &p) const;
+	void paintSearchIcon(Painter &p) const;
+	void paintSetIcon(
+		Painter &p,
+		const IconInfo &info,
+		crl::time now,
+		bool paused) const;
+	void paintSelectionBar(Painter &p) const;
+	void paintLeftRightFading(Painter &p) const;
+	void validatePremiumIcon() const;
+
+	void initSearch();
+	void toggleSearch(bool visible);
+	void resizeSearchControls();
+	void scrollByWheelEvent(not_null<QWheelEvent*> e);
+
+	void clipCallback(Media::Clip::Notification notification, uint64 setId);
+
+	const not_null<Window::SessionController*> _controller;
+	const bool _searchButtonVisible = false;
+	const bool _settingsButtonVisible = false;
+
+	static constexpr auto kVisibleIconsCount = 8;
+
+	std::weak_ptr<Lottie::FrameRenderer> _lottieRenderer;
+	std::vector<StickerIcon> _icons;
+	Fn<std::shared_ptr<Lottie::FrameRenderer>()> _renderer;
+	uint64 _activeByScrollId = 0;
+	OverState _iconOver = SpecialOver::None;
+	int _iconSel = 0;
+	OverState _iconDown = SpecialOver::None;
+	bool _iconsDragging = false;
+	Ui::Animations::Basic _iconsAnimation;
+	QPoint _iconsMousePos, _iconsMouseDown;
+	mutable QImage _premiumIcon;
+	int _iconsLeft = 0;
+	int _iconsRight = 0;
+	int _iconsTop = 0;
+	int _iconsStartX = 0;
+	int _iconsMax = 0;
+	anim::value _iconsX;
+	anim::value _iconSelX;
+	crl::time _iconsStartAnim = 0;
+
+	bool _horizontal = false;
+
+	bool _searchShown = false;
+	object_ptr<Ui::InputField> _searchField = { nullptr };
+	object_ptr<Ui::CrossButton> _searchCancel = { nullptr };
+	QPointer<QWidget> _focusTakenFrom;
+
+	rpl::event_stream<> _openSettingsRequests;
+	rpl::event_stream<uint64> _setChosen;
+	rpl::event_stream<SearchRequest> _searchRequests;
+
+};
+
+} // namespace ChatHelpers
diff --git a/Telegram/SourceFiles/chat_helpers/stickers_list_widget.cpp b/Telegram/SourceFiles/chat_helpers/stickers_list_widget.cpp
index 349656946..4ce3697b0 100644
--- a/Telegram/SourceFiles/chat_helpers/stickers_list_widget.cpp
+++ b/Telegram/SourceFiles/chat_helpers/stickers_list_widget.cpp
@@ -17,6 +17,7 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
 #include "data/data_peer_values.h"
 #include "menu/menu_send.h" // SendMenu::FillSendMenu
 #include "chat_helpers/stickers_lottie.h"
+#include "chat_helpers/stickers_list_footer.h"
 #include "ui/widgets/buttons.h"
 #include "ui/widgets/popup_menu.h"
 #include "ui/effects/animations.h"
@@ -70,164 +71,6 @@ using SetFlag = Data::StickersSetFlag;
 
 } // namespace
 
-struct StickerIcon {
-	StickerIcon(uint64 setId) : setId(setId) {
-	}
-	StickerIcon(
-		not_null<StickersSet*> set,
-		DocumentData *sticker,
-		int pixw,
-		int pixh)
-	: setId(set->id)
-	, set(set)
-	, sticker(sticker)
-	, pixw(pixw)
-	, pixh(pixh) {
-	}
-
-	void ensureMediaCreated() const {
-		if (!sticker) {
-			return;
-		} else if (set->hasThumbnail()) {
-			if (!thumbnailMedia) {
-				thumbnailMedia = set->createThumbnailView();
-				set->loadThumbnail();
-			}
-		} else if (!stickerMedia) {
-			stickerMedia = sticker->createMediaView();
-			stickerMedia->thumbnailWanted(sticker->stickerSetOrigin());
-		}
-	}
-
-	uint64 setId = 0;
-	StickersSet *set = nullptr;
-	mutable std::unique_ptr<Lottie::SinglePlayer> lottie;
-	mutable Media::Clip::ReaderPointer webm;
-	mutable QPixmap savedFrame;
-	DocumentData *sticker = nullptr;
-	ChannelData *megagroup = nullptr;
-	mutable std::shared_ptr<StickersSetThumbnailView> thumbnailMedia;
-	mutable std::shared_ptr<Data::DocumentMedia> stickerMedia;
-	mutable std::shared_ptr<Data::CloudImageView> megagroupUserpic;
-	int pixw = 0;
-	int pixh = 0;
-	mutable rpl::lifetime lifetime;
-
-};
-
-class StickersListWidget::Footer final : public TabbedSelector::InnerFooter {
-public:
-	explicit Footer(
-		not_null<StickersListWidget*> parent,
-		bool searchButtonVisible);
-
-	void preloadImages();
-	void validateSelectedIcon(
-		uint64 setId,
-		ValidateIconAnimations animations);
-	void refreshIcons(ValidateIconAnimations animations);
-	[[nodiscard]] bool hasOnlyFeaturedSets() const;
-
-	void leaveToChildEvent(QEvent *e, QWidget *child) override;
-
-	void stealFocus();
-	void returnFocus();
-	void setLoading(bool loading);
-
-	void clearHeavyData();
-
-	[[nodiscard]] rpl::producer<> openSettingsRequests() const;
-
-protected:
-	void paintEvent(QPaintEvent *e) override;
-	void resizeEvent(QResizeEvent *e) override;
-	void mousePressEvent(QMouseEvent *e) override;
-	void mouseMoveEvent(QMouseEvent *e) override;
-	void mouseReleaseEvent(QMouseEvent *e) override;
-	bool eventHook(QEvent *e) override;
-
-	void processHideFinished() override;
-
-private:
-	enum class SpecialOver {
-		None,
-		Search,
-		Settings,
-	};
-	using OverState = std::variant<SpecialOver, int>;
-	struct IconInfo {
-		int index = 0;
-		int left = 0;
-		bool visible = false;
-	};
-
-	void enumerateVisibleIcons(Fn<void(const IconInfo &)> callback);
-	void enumerateIcons(Fn<void(const IconInfo &)> callback);
-
-	bool iconsAnimationCallback(crl::time now);
-	void setSelectedIcon(
-		int newSelected,
-		ValidateIconAnimations animations);
-	void validateIconLottieAnimation(const StickerIcon &icon);
-	void validateIconWebmAnimation(const StickerIcon &icon);
-	void validateIconAnimation(const StickerIcon &icon);
-
-	void refreshIconsGeometry(ValidateIconAnimations animations);
-	void updateSelected();
-	void updateSetIcon(uint64 setId);
-	void updateSetIconAt(int left);
-	void finishDragging();
-	void paintStickerSettingsIcon(Painter &p) const;
-	void paintSearchIcon(Painter &p) const;
-	void paintSetIcon(
-		Painter &p,
-		const IconInfo &info,
-		crl::time now,
-		bool paused) const;
-	void paintSelectionBar(Painter &p) const;
-	void paintLeftRightFading(Painter &p) const;
-	void validatePremiumIcon() const;
-
-	void initSearch();
-	void toggleSearch(bool visible);
-	void resizeSearchControls();
-	void scrollByWheelEvent(not_null<QWheelEvent*> e);
-
-	void clipCallback(Media::Clip::Notification notification, uint64 setId);
-
-	const not_null<StickersListWidget*> _pan;
-	const bool _searchButtonVisible = true;
-
-	static constexpr auto kVisibleIconsCount = 8;
-
-	std::vector<StickerIcon> _icons;
-	OverState _iconOver = SpecialOver::None;
-	int _iconSel = 0;
-	OverState _iconDown = SpecialOver::None;
-	bool _iconsDragging = false;
-	Ui::Animations::Basic _iconsAnimation;
-	QPoint _iconsMousePos, _iconsMouseDown;
-	mutable QImage _premiumIcon;
-	int _iconsLeft = 0;
-	int _iconsRight = 0;
-	int _iconsTop = 0;
-	int _iconsStartX = 0;
-	int _iconsMax = 0;
-	anim::value _iconsX;
-	anim::value _iconSelX;
-	crl::time _iconsStartAnim = 0;
-
-	bool _horizontal = false;
-
-	bool _searchShown = false;
-	object_ptr<Ui::InputField> _searchField = { nullptr };
-	object_ptr<Ui::CrossButton> _searchCancel = { nullptr };
-	QPointer<QWidget> _focusTakenFrom;
-
-	rpl::event_stream<> _openSettingsRequests;
-
-};
-
 struct StickersListWidget::Sticker {
 	not_null<DocumentData*> document;
 	std::shared_ptr<Data::DocumentMedia> documentMedia;
@@ -315,814 +158,6 @@ void StickersListWidget::Sticker::ensureMediaCreated() {
 	documentMedia = document->createMediaView();
 }
 
-StickersListWidget::Footer::Footer(
-	not_null<StickersListWidget*> parent,
-	bool searchButtonVisible)
-: InnerFooter(parent)
-, _pan(parent)
-, _searchButtonVisible(searchButtonVisible)
-, _iconsAnimation([=](crl::time now) {
-	return iconsAnimationCallback(now);
-}) {
-	setMouseTracking(true);
-
-	_iconsLeft = st::emojiCategorySkip + (_searchButtonVisible
-		? st::stickerIconWidth
-		: 0);
-	_iconsRight = st::emojiCategorySkip + st::stickerIconWidth;
-
-	_pan->session().downloaderTaskFinished(
-	) | rpl::start_with_next([=] {
-		update();
-	}, lifetime());
-
-	style::PaletteChanged(
-	) | rpl::start_with_next([=] {
-		_premiumIcon = QImage();
-	}, lifetime());
-}
-
-void StickersListWidget::Footer::validatePremiumIcon() const {
-	if (!_premiumIcon.isNull()) {
-		return;
-	}
-	const auto size = st::stickersPremium.size();
-	const auto mask = st::stickersPremium.instance(Qt::white);
-	const auto factor = style::DevicePixelRatio();
-	_premiumIcon = QImage(
-		size * factor,
-		QImage::Format_ARGB32_Premultiplied);
-	_premiumIcon.setDevicePixelRatio(factor);
-
-	QPainter p(&_premiumIcon);
-	auto gradient = QLinearGradient(
-		QPoint(0, size.height()),
-		QPoint(size.width(), 0));
-	gradient.setStops({
-		{ 0., st::stickerPanPremium1->c },
-		{ 1., st::stickerPanPremium2->c },
-	});
-	p.fillRect(QRect(QPoint(), size), gradient);
-	p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
-	p.drawImage(QRect(QPoint(), size), mask);
-}
-
-void StickersListWidget::Footer::clearHeavyData() {
-	const auto count = int(_icons.size());
-	const auto iconsX = qRound(_iconsX.current());
-	const auto first = floorclamp(iconsX, st::stickerIconWidth, 0, count);
-	const auto last = ceilclamp(
-		iconsX + width(),
-		st::stickerIconWidth,
-		0,
-		count);
-	for (auto i = 0; i != count; ++i) {
-		auto &icon = _icons[i];
-		icon.webm = nullptr;
-		icon.lottie = nullptr;
-		icon.lifetime.destroy();
-		icon.stickerMedia = nullptr;
-		if (i < first || i >= last) {
-			// Not visible icon.
-			icon.savedFrame = QPixmap();
-		}
-	}
-}
-
-void StickersListWidget::Footer::initSearch() {
-	_searchField.create(
-		this,
-		st::gifsSearchField,
-		tr::lng_stickers_search_sets());
-	_searchCancel.create(this, st::gifsSearchCancel);
-	_searchField->show();
-	_searchCancel->show(anim::type::instant);
-
-	const auto cancelSearch = [=] {
-		if (_searchField->getLastText().isEmpty()) {
-			toggleSearch(false);
-		} else {
-			_searchField->setText(QString());
-		}
-	};
-	connect(_searchField, &Ui::InputField::submitted, [=] {
-		_pan->sendSearchRequest();
-	});
-	connect(_searchField, &Ui::InputField::cancelled, cancelSearch);
-	connect(_searchField, &Ui::InputField::changed, [=] {
-		_pan->searchForSets(_searchField->getLastText());
-	});
-	_searchCancel->setClickedCallback(cancelSearch);
-
-	resizeSearchControls();
-}
-
-void StickersListWidget::Footer::toggleSearch(bool visible) {
-	if (_searchShown == visible) {
-		return;
-	}
-	_searchShown = visible;
-	if (_searchShown) {
-		initSearch();
-		stealFocus();
-	} else if (_searchField) {
-		returnFocus();
-		_searchField.destroy();
-		_searchCancel.destroy();
-		_focusTakenFrom = nullptr;
-	}
-	update();
-}
-
-void StickersListWidget::Footer::stealFocus() {
-	if (_searchField) {
-		if (!_focusTakenFrom) {
-			_focusTakenFrom = QApplication::focusWidget();
-		}
-		_searchField->setFocus();
-	}
-}
-
-void StickersListWidget::Footer::returnFocus() {
-	if (_searchField && _focusTakenFrom) {
-		if (_searchField->hasFocus()) {
-			_focusTakenFrom->setFocus();
-		}
-		_focusTakenFrom = nullptr;
-	}
-}
-
-void StickersListWidget::Footer::enumerateVisibleIcons(
-		Fn<void(const IconInfo &)> callback) {
-	auto iconsX = qRound(_iconsX.current());
-	auto x = _iconsLeft - (iconsX % st::stickerIconWidth);
-	auto first = floorclamp(iconsX, st::stickerIconWidth, 0, _icons.size());
-	auto last = ceilclamp(
-		iconsX + width(),
-		st::stickerIconWidth,
-		0,
-		_icons.size());
-	for (auto index = first; index != last; ++index) {
-		callback({ .index = index, .left = x, .visible = true });
-		x += st::stickerIconWidth;
-	}
-}
-
-void StickersListWidget::Footer::enumerateIcons(
-		Fn<void(const IconInfo &)> callback) {
-	auto iconsX = qRound(_iconsX.current());
-	auto x = _iconsLeft - (iconsX % st::stickerIconWidth);
-	auto first = floorclamp(iconsX, st::stickerIconWidth, 0, _icons.size());
-	auto last = ceilclamp(
-		iconsX + width(),
-		st::stickerIconWidth,
-		0,
-		_icons.size());
-	x -= first * st::stickerIconWidth;
-	for (auto i = 0, count = int(_icons.size()); i != count; ++i) {
-		const auto visible = (i >= first && i < last);
-		callback({ .index = i, .left = x, .visible = visible });
-		x += st::stickerIconWidth;
-	}
-}
-
-void StickersListWidget::Footer::preloadImages() {
-	enumerateVisibleIcons([&](const IconInfo &info) {
-		const auto &icon = _icons[info.index];
-		if (const auto sticker = icon.sticker) {
-			Assert(icon.set != nullptr);
-			if (icon.set->hasThumbnail()) {
-				icon.set->loadThumbnail();
-			} else {
-				sticker->loadThumbnail(sticker->stickerSetOrigin());
-			}
-		}
-	});
-}
-
-void StickersListWidget::Footer::validateSelectedIcon(
-		uint64 setId,
-		ValidateIconAnimations animations) {
-	auto favedIconIndex = -1;
-	auto newSelected = -1;
-	for (auto i = 0, l = int(_icons.size()); i != l; ++i) {
-		if (_icons[i].setId == setId
-			|| (_icons[i].setId == Data::Stickers::FavedSetId
-				&& setId == Data::Stickers::RecentSetId)) {
-			newSelected = i;
-			break;
-		} else if (_icons[i].setId == Data::Stickers::FavedSetId) {
-			favedIconIndex = i;
-		}
-	}
-	setSelectedIcon(
-		(newSelected >= 0
-			? newSelected
-			: (favedIconIndex >= 0) ? favedIconIndex : 0),
-		animations);
-}
-
-void StickersListWidget::Footer::setSelectedIcon(
-		int newSelected,
-		ValidateIconAnimations animations) {
-	if (_iconSel == newSelected) {
-		return;
-	}
-	_iconSel = newSelected;
-	auto iconSelXFinal = _iconSel * st::stickerIconWidth;
-	if (animations == ValidateIconAnimations::Full) {
-		_iconSelX.start(iconSelXFinal);
-	} else {
-		_iconSelX = anim::value(iconSelXFinal, iconSelXFinal);
-	}
-	auto iconsCountForCentering = (2 * _iconSel + 1);
-	auto iconsWidthForCentering = iconsCountForCentering
-		* st::stickerIconWidth;
-	auto iconsXFinal = std::clamp(
-		(_iconsLeft + iconsWidthForCentering + _iconsRight - width()) / 2,
-		0,
-		_iconsMax);
-	if (animations == ValidateIconAnimations::None) {
-		_iconsX = anim::value(iconsXFinal, iconsXFinal);
-		_iconsAnimation.stop();
-	} else {
-		_iconsX.start(iconsXFinal);
-		_iconsStartAnim = crl::now();
-		_iconsAnimation.start();
-	}
-	updateSelected();
-	update();
-}
-
-void StickersListWidget::Footer::processHideFinished() {
-	_iconOver = _iconDown = SpecialOver::None;
-	_iconsStartAnim = 0;
-	_iconsAnimation.stop();
-	_iconsX.finish();
-	_iconSelX.finish();
-	_horizontal = false;
-}
-
-void StickersListWidget::Footer::leaveToChildEvent(QEvent *e, QWidget *child) {
-	_iconsMousePos = QCursor::pos();
-	updateSelected();
-}
-
-void StickersListWidget::Footer::setLoading(bool loading) {
-	if (_searchCancel) {
-		_searchCancel->setLoadingAnimation(loading);
-	}
-}
-
-void StickersListWidget::Footer::paintEvent(QPaintEvent *e) {
-	Painter p(this);
-
-	paintSearchIcon(p);
-
-	if (_icons.empty() || _searchShown) {
-		return;
-	}
-
-	if (!hasOnlyFeaturedSets()) {
-		paintStickerSettingsIcon(p);
-	}
-
-	auto clip = QRect(
-		_iconsLeft,
-		_iconsTop,
-		width() - _iconsLeft - _iconsRight,
-		st::emojiFooterHeight);
-	if (rtl()) {
-		clip.moveLeft(width() - _iconsLeft - clip.width());
-	}
-	p.setClipRect(clip);
-
-	const auto now = crl::now();
-	const auto paused = _pan->controller()->isGifPausedAtLeastFor(
-		Window::GifPauseReason::SavedGifs);
-	enumerateVisibleIcons([&](const IconInfo &info) {
-		paintSetIcon(p, info, now, paused);
-	});
-
-	paintSelectionBar(p);
-	paintLeftRightFading(p);
-}
-
-void StickersListWidget::Footer::paintSelectionBar(Painter &p) const {
-	auto selxrel = _iconsLeft + qRound(_iconSelX.current());
-	auto selx = selxrel - qRound(_iconsX.current());
-	if (rtl()) {
-		selx = width() - selx - st::stickerIconWidth;
-	}
-	p.fillRect(
-		selx,
-		_iconsTop + st::emojiFooterHeight - st::stickerIconPadding,
-		st::stickerIconWidth,
-		st::stickerIconSel,
-		st::stickerIconSelColor);
-}
-
-void StickersListWidget::Footer::paintLeftRightFading(Painter &p) const {
-	auto o_left = std::clamp(
-		_iconsX.current() / st::stickerIconLeft.width(),
-		0.,
-		1.);
-	if (o_left > 0) {
-		p.setOpacity(o_left);
-		st::stickerIconLeft.fill(p, style::rtlrect(_iconsLeft, _iconsTop, st::stickerIconLeft.width(), st::emojiFooterHeight, width()));
-		p.setOpacity(1.);
-	}
-	auto o_right = std::clamp(
-		(_iconsMax - _iconsX.current()) / st::stickerIconRight.width(),
-		0.,
-		1.);
-	if (o_right > 0) {
-		p.setOpacity(o_right);
-		st::stickerIconRight.fill(p, style::rtlrect(width() - _iconsRight - st::stickerIconRight.width(), _iconsTop, st::stickerIconRight.width(), st::emojiFooterHeight, width()));
-		p.setOpacity(1.);
-	}
-}
-
-void StickersListWidget::Footer::resizeEvent(QResizeEvent *e) {
-	if (_searchField) {
-		resizeSearchControls();
-	}
-	refreshIconsGeometry(ValidateIconAnimations::None);
-}
-
-void StickersListWidget::Footer::resizeSearchControls() {
-	Expects(_searchField != nullptr);
-	Expects(_searchCancel != nullptr);
-
-	const auto fieldWidth = width()
-		- st::gifsSearchFieldPosition.x()
-		- st::gifsSearchCancelPosition.x()
-		- st::gifsSearchCancel.width;
-	_searchField->resizeToWidth(fieldWidth);
-	_searchField->moveToLeft(st::gifsSearchFieldPosition.x(), st::gifsSearchFieldPosition.y());
-	_searchCancel->moveToRight(st::gifsSearchCancelPosition.x(), st::gifsSearchCancelPosition.y());
-}
-
-rpl::producer<> StickersListWidget::Footer::openSettingsRequests() const {
-	return _openSettingsRequests.events();
-}
-
-void StickersListWidget::Footer::mousePressEvent(QMouseEvent *e) {
-	if (e->button() != Qt::LeftButton) {
-		return;
-	}
-	_iconsMousePos = e ? e->globalPos() : QCursor::pos();
-	updateSelected();
-
-	if (_iconOver == SpecialOver::Settings) {
-		_openSettingsRequests.fire({});
-	} else if (_iconOver == SpecialOver::Search) {
-		toggleSearch(true);
-	} else {
-		_iconDown = _iconOver;
-		_iconsMouseDown = _iconsMousePos;
-		_iconsStartX = qRound(_iconsX.current());
-	}
-}
-
-void StickersListWidget::Footer::mouseMoveEvent(QMouseEvent *e) {
-	_iconsMousePos = e ? e->globalPos() : QCursor::pos();
-	updateSelected();
-
-	if (!_iconsDragging
-		&& !_icons.empty()
-		&& v::is<int>(_iconDown)) {
-		if ((_iconsMousePos - _iconsMouseDown).manhattanLength() >= QApplication::startDragDistance()) {
-			_iconsDragging = true;
-		}
-	}
-	if (_iconsDragging) {
-		auto newX = std::clamp(
-			(rtl() ? -1 : 1) * (_iconsMouseDown.x() - _iconsMousePos.x())
-				+ _iconsStartX,
-			0,
-			_iconsMax);
-		if (newX != qRound(_iconsX.current())) {
-			_iconsX = anim::value(newX, newX);
-			_iconsStartAnim = 0;
-			_iconsAnimation.stop();
-			update();
-		}
-	}
-}
-
-void StickersListWidget::Footer::mouseReleaseEvent(QMouseEvent *e) {
-	if (_icons.empty()) {
-		return;
-	}
-
-	const auto wasDown = std::exchange(_iconDown, SpecialOver::None);
-
-	_iconsMousePos = e ? e->globalPos() : QCursor::pos();
-	if (_iconsDragging) {
-		finishDragging();
-		return;
-	}
-
-	updateSelected();
-	if (wasDown == _iconOver) {
-		if (const auto index = std::get_if<int>(&_iconOver)) {
-			_iconSelX = anim::value(
-				*index * st::stickerIconWidth,
-				*index * st::stickerIconWidth);
-			_pan->showStickerSet(_icons[*index].setId);
-		}
-	}
-}
-
-void StickersListWidget::Footer::finishDragging() {
-	auto newX = std::clamp(
-		_iconsStartX + _iconsMouseDown.x() - _iconsMousePos.x(),
-		0,
-		_iconsMax);
-	if (newX != qRound(_iconsX.current())) {
-		_iconsX = anim::value(newX, newX);
-		_iconsStartAnim = 0;
-		_iconsAnimation.stop();
-		update();
-	}
-	_iconsDragging = false;
-	updateSelected();
-}
-
-bool StickersListWidget::Footer::eventHook(QEvent *e) {
-	if (e->type() == QEvent::TouchBegin) {
-	} else if (e->type() == QEvent::Wheel) {
-		if (!_icons.empty()
-			&& v::is<int>(_iconOver)
-			&& (_iconDown == SpecialOver::None)) {
-			scrollByWheelEvent(static_cast<QWheelEvent*>(e));
-		}
-	}
-	return InnerFooter::eventHook(e);
-}
-
-void StickersListWidget::Footer::scrollByWheelEvent(
-		not_null<QWheelEvent*> e) {
-	auto horizontal = (e->angleDelta().x() != 0);
-	auto vertical = (e->angleDelta().y() != 0);
-	if (horizontal) {
-		_horizontal = true;
-	}
-	auto newX = qRound(_iconsX.current());
-	if (/*_horizontal && */horizontal) {
-		newX = std::clamp(
-			newX - (rtl() ? -1 : 1) * (e->pixelDelta().x()
-				? e->pixelDelta().x()
-				: e->angleDelta().x()),
-			0,
-			_iconsMax);
-	} else if (/*!_horizontal && */vertical) {
-		newX = std::clamp(
-			newX - (e->pixelDelta().y()
-				? e->pixelDelta().y()
-				: e->angleDelta().y()),
-			0,
-			_iconsMax);
-	}
-	if (newX != qRound(_iconsX.current())) {
-		_iconsX = anim::value(newX, newX);
-		_iconsStartAnim = 0;
-		_iconsAnimation.stop();
-		updateSelected();
-		update();
-	}
-}
-
-void StickersListWidget::Footer::clipCallback(
-		Media::Clip::Notification notification,
-		uint64 setId) {
-	using namespace Media::Clip;
-	switch (notification) {
-	case Notification::Reinit: {
-		enumerateIcons([&](const IconInfo &info) {
-			auto &icon = _icons[info.index];
-			if (icon.setId != setId || !icon.webm) {
-				return;
-			} else if (icon.webm->state() == State::Error) {
-				icon.webm.setBad();
-			} else if (!info.visible) {
-				icon.webm = nullptr;
-			} else if (icon.webm->ready() && !icon.webm->started()) {
-				icon.webm->start({
-					.frame = { icon.pixw, icon.pixh },
-					.keepAlpha = true,
-				});
-			}
-			updateSetIconAt(info.left);
-		});
-	} break;
-
-	case Notification::Repaint:
-		updateSetIcon(setId);
-		break;
-	}
-}
-
-void StickersListWidget::Footer::updateSelected() {
-	if (_iconDown != SpecialOver::None) {
-		return;
-	}
-
-	auto p = mapFromGlobal(_iconsMousePos);
-	auto x = p.x(), y = p.y();
-	if (rtl()) x = width() - x;
-	const auto settingsLeft = width() - _iconsRight;
-	const auto searchLeft = _iconsLeft - st::stickerIconWidth;
-	auto newOver = OverState(SpecialOver::None);
-	if (_searchButtonVisible
-		&& x >= searchLeft
-		&& x < searchLeft + st::stickerIconWidth
-		&& y >= _iconsTop
-		&& y < _iconsTop + st::emojiFooterHeight) {
-		newOver = SpecialOver::Search;
-	} else if (x >= settingsLeft
-		&& x < settingsLeft + st::stickerIconWidth
-		&& y >= _iconsTop
-		&& y < _iconsTop + st::emojiFooterHeight) {
-		if (!_icons.empty() && !hasOnlyFeaturedSets()) {
-			newOver = SpecialOver::Settings;
-		}
-	} else if (!_icons.empty()) {
-		if (y >= _iconsTop
-			&& y < _iconsTop + st::emojiFooterHeight
-			&& x >= _iconsLeft
-			&& x < width() - _iconsRight) {
-			x += qRound(_iconsX.current()) - _iconsLeft;
-			if (x < _icons.size() * st::stickerIconWidth) {
-				newOver = qFloor(x / st::stickerIconWidth);
-			}
-		}
-	}
-	if (newOver != _iconOver) {
-		if (newOver == SpecialOver::None) {
-			setCursor(style::cur_default);
-		} else if (_iconOver == SpecialOver::None) {
-			setCursor(style::cur_pointer);
-		}
-		_iconOver = newOver;
-	}
-}
-
-void StickersListWidget::Footer::refreshIcons(
-		ValidateIconAnimations animations) {
-	auto icons = _pan->fillIcons();
-
-	auto indices = base::flat_map<uint64, int>();
-	indices.reserve(_icons.size());
-	auto index = 0;
-	for (const auto &entry : _icons) {
-		indices.emplace(entry.setId, index++);
-	}
-
-	for (auto &now : icons) {
-		if (const auto i = indices.find(now.setId); i != end(indices)) {
-			auto &was = _icons[i->second];
-			if (now.sticker == was.sticker) {
-				now.webm = std::move(was.webm);
-				now.lottie = std::move(was.lottie);
-				now.lifetime = std::move(was.lifetime);
-				now.savedFrame = std::move(was.savedFrame);
-			}
-		}
-	}
-
-	_icons = std::move(icons);
-	refreshIconsGeometry(animations);
-}
-
-void StickersListWidget::Footer::refreshIconsGeometry(
-		ValidateIconAnimations animations) {
-	_iconOver = _iconDown = SpecialOver::None;
-	_iconsX.finish();
-	_iconSelX.finish();
-	_iconsStartAnim = 0;
-	_iconsAnimation.stop();
-	_iconsMax = std::max(
-		_iconsLeft + int(_icons.size()) * st::stickerIconWidth + _iconsRight - width(),
-		0);
-	if (_iconsX.current() > _iconsMax) {
-		_iconsX = anim::value(_iconsMax, _iconsMax);
-	}
-	updateSelected();
-	_pan->validateSelectedIcon(animations);
-	update();
-}
-
-bool StickersListWidget::Footer::hasOnlyFeaturedSets() const {
-	return (_icons.size() == 1)
-		&& (_icons[0].setId == Data::Stickers::FeaturedSetId);
-}
-
-void StickersListWidget::Footer::paintStickerSettingsIcon(Painter &p) const {
-	const auto settingsLeft = width() - _iconsRight;
-	st::stickersSettings.paint(
-		p,
-		settingsLeft
-			+ (st::stickerIconWidth - st::stickersSettings.width()) / 2,
-		_iconsTop + st::emojiCategory.iconPosition.y(),
-		width());
-}
-
-void StickersListWidget::Footer::paintSearchIcon(Painter &p) const {
-	const auto searchLeft = _iconsLeft - st::stickerIconWidth;
-	st::stickersSearch.paint(
-		p,
-		searchLeft + (st::stickerIconWidth - st::stickersSearch.width()) / 2,
-		_iconsTop + st::emojiCategory.iconPosition.y(),
-		width());
-}
-
-void StickersListWidget::Footer::validateIconLottieAnimation(
-		const StickerIcon &icon) {
-	icon.ensureMediaCreated();
-	if (icon.lottie
-		|| !icon.sticker
-		|| !HasLottieThumbnail(
-			icon.set ? icon.set->flags : Data::StickersSetFlags(),
-			icon.thumbnailMedia.get(),
-			icon.stickerMedia.get())) {
-		return;
-	}
-	auto player = LottieThumbnail(
-		icon.thumbnailMedia.get(),
-		icon.stickerMedia.get(),
-		StickerLottieSize::StickersFooter,
-		QSize(
-			st::stickerIconWidth - 2 * st::stickerIconPadding,
-			st::emojiFooterHeight - 2 * st::stickerIconPadding
-		) * cIntRetinaFactor(),
-		_pan->getLottieRenderer());
-	if (!player) {
-		return;
-	}
-	icon.lottie = std::move(player);
-
-	const auto id = icon.setId;
-	icon.lottie->updates(
-	) | rpl::start_with_next([=] {
-		updateSetIcon(id);
-	}, icon.lifetime);
-}
-
-void StickersListWidget::Footer::validateIconWebmAnimation(
-		const StickerIcon &icon) {
-	icon.ensureMediaCreated();
-	if (icon.webm
-		|| !icon.sticker
-		|| !HasWebmThumbnail(
-			icon.set ? icon.set->flags : Data::StickersSetFlags(),
-			icon.thumbnailMedia.get(),
-			icon.stickerMedia.get())) {
-		return;
-	}
-	const auto id = icon.setId;
-	auto callback = [=](Media::Clip::Notification notification) {
-		clipCallback(notification, id);
-	};
-	icon.webm = WebmThumbnail(
-		icon.thumbnailMedia.get(),
-		icon.stickerMedia.get(),
-		std::move(callback));
-}
-
-void StickersListWidget::Footer::validateIconAnimation(
-		const StickerIcon &icon) {
-	validateIconWebmAnimation(icon);
-	validateIconLottieAnimation(icon);
-}
-
-void StickersListWidget::Footer::updateSetIcon(uint64 setId) {
-	enumerateVisibleIcons([&](const IconInfo &info) {
-		if (_icons[info.index].setId != setId) {
-			return;
-		}
-		updateSetIconAt(info.left);
-	});
-}
-
-void StickersListWidget::Footer::updateSetIconAt(int left) {
-	update(left, _iconsTop, st::stickerIconWidth, st::emojiFooterHeight);
-}
-
-void StickersListWidget::Footer::paintSetIcon(
-		Painter &p,
-		const IconInfo &info,
-		crl::time now,
-		bool paused) const {
-	const auto &icon = _icons[info.index];
-	if (icon.sticker) {
-		icon.ensureMediaCreated();
-		const_cast<Footer*>(this)->validateIconAnimation(icon);
-		const auto origin = icon.sticker->stickerSetOrigin();
-		const auto thumb = icon.thumbnailMedia
-			? icon.thumbnailMedia->image()
-			: icon.stickerMedia
-			? icon.stickerMedia->thumbnail()
-			: nullptr;
-		const auto x = info.left + (st::stickerIconWidth - icon.pixw) / 2;
-		const auto y = _iconsTop + (st::emojiFooterHeight - icon.pixh) / 2;
-		if (icon.lottie && icon.lottie->ready()) {
-			const auto frame = icon.lottie->frame();
-			const auto size = frame.size() / cIntRetinaFactor();
-			if (icon.savedFrame.isNull()) {
-				icon.savedFrame = QPixmap::fromImage(frame, Qt::ColorOnly);
-				icon.savedFrame.setDevicePixelRatio(cRetinaFactor());
-			}
-			p.drawImage(
-				QRect(
-					info.left + (st::stickerIconWidth - size.width()) / 2,
-					_iconsTop + (st::emojiFooterHeight - size.height()) / 2,
-					size.width(),
-					size.height()),
-				frame);
-			if (!paused) {
-				icon.lottie->markFrameShown();
-			}
-		} else if (icon.webm && icon.webm->started()) {
-			const auto frame = icon.webm->current(
-				{ .frame = { icon.pixw, icon.pixh }, .keepAlpha = true },
-				paused ? 0 : now);
-			if (icon.savedFrame.isNull()) {
-				icon.savedFrame = frame;
-				icon.savedFrame.setDevicePixelRatio(cRetinaFactor());
-			}
-			p.drawPixmapLeft(x, y, width(), frame);
-		} else if (!icon.savedFrame.isNull() || thumb) {
-			const auto pixmap = !icon.savedFrame.isNull()
-				? icon.savedFrame
-				: (!icon.lottie && thumb)
-				? thumb->pix(icon.pixw, icon.pixh)
-				: QPixmap();
-			if (pixmap.isNull()) {
-				return;
-			} else if (icon.savedFrame.isNull()) {
-				icon.savedFrame = pixmap;
-			}
-			p.drawPixmapLeft(x, y, width(), pixmap);
-		}
-	} else if (icon.megagroup) {
-		const auto size = st::stickerGroupCategorySize;
-		icon.megagroup->paintUserpicLeft(
-			p,
-			icon.megagroupUserpic,
-			info.left + (st::stickerIconWidth - size) / 2,
-			_iconsTop + (st::emojiFooterHeight - size) / 2,
-			width(),
-			st::stickerGroupCategorySize);
-	} else if (icon.setId == Data::Stickers::PremiumSetId) {
-		validatePremiumIcon();
-		const auto size = st::stickersPremium.size();
-		p.drawImage(
-			info.left + (st::stickerIconWidth - size.width()) / 2,
-			_iconsTop + (st::emojiFooterHeight - size.height()) / 2,
-			_premiumIcon);
-	} else {
-		const auto paintedIcon = [&] {
-			if (icon.setId == Data::Stickers::FeaturedSetId) {
-				const auto session = &_pan->session();
-				return session->data().stickers().featuredSetsUnreadCount()
-					? &st::stickersTrendingUnread
-					: &st::stickersTrending;
-			//} else if (setId == Stickers::FavedSetId) {
-			//	return &st::stickersFaved;
-			}
-			return &st::emojiRecent;
-		}();
-		paintedIcon->paint(
-			p,
-			info.left + (st::stickerIconWidth - paintedIcon->width()) / 2,
-			_iconsTop + (st::emojiFooterHeight - paintedIcon->height()) / 2,
-			width());
-	}
-}
-
-bool StickersListWidget::Footer::iconsAnimationCallback(crl::time now) {
-	if (anim::Disabled()) {
-		now += st::stickerIconMove;
-	}
-	if (_iconsStartAnim) {
-		const auto dt = (now - _iconsStartAnim) / float64(st::stickerIconMove);
-		if (dt >= 1.) {
-			_iconsStartAnim = 0;
-			_iconsX.finish();
-			_iconSelX.finish();
-		} else {
-			_iconsX.update(dt, anim::linear);
-			_iconSelX.update(dt, anim::linear);
-		}
-	}
-
-	update();
-
-	return (_iconsStartAnim != 0);
-}
-
 StickersListWidget::StickersListWidget(
 	QWidget *parent,
 	not_null<Window::SessionController*> controller,
@@ -1211,9 +246,20 @@ auto StickersListWidget::choosingUpdated() const
 object_ptr<TabbedSelector::InnerFooter> StickersListWidget::createFooter() {
 	Expects(_footer == nullptr);
 
-	auto result = object_ptr<Footer>(this, !_isMasks);
+	using FooterDescriptor = StickersListFooter::Descriptor;
+	auto result = object_ptr<StickersListFooter>(FooterDescriptor{
+		.controller = controller(),
+		.parent = this,
+		.searchButtonVisible = !_isMasks,
+		.settingsButtonVisible = true,
+	});
 	_footer = result;
 
+	_footer->setChosen(
+	) | rpl::start_with_next([=](uint64 setId) {
+		showStickerSet(setId);
+	}, _footer->lifetime());
+
 	_footer->openSettingsRequests(
 	) | rpl::start_with_next([=] {
 		const auto onlyFeatured = _footer->hasOnlyFeaturedSets();
@@ -1227,6 +273,16 @@ object_ptr<TabbedSelector::InnerFooter> StickersListWidget::createFooter() {
 			onlyFeatured ? false : _isMasks),
 		Ui::LayerOption::KeepOther);
 	}, _footer->lifetime());
+
+	_footer->searchRequests(
+	) | rpl::start_with_next([=](StickersListFooter::SearchRequest request) {
+		if (request.forced) {
+			sendSearchRequest();
+		} else {
+			searchForSets(request.text);
+		}
+	}, _footer->lifetime());
+
 	return result;
 }
 
@@ -1245,7 +301,11 @@ void StickersListWidget::visibleTopBottomUpdated(
 	} else {
 		checkVisibleLottie();
 	}
-	validateSelectedIcon(ValidateIconAnimations::Full);
+	if (_footer) {
+		_footer->validateSelectedIcon(
+			currentSet(top),
+			ValidateIconAnimations::Full);
+	}
 }
 
 void StickersListWidget::checkVisibleFeatured(
@@ -1570,9 +630,7 @@ void StickersListWidget::refreshSearchRows(
 	if (cloudSets) {
 		fillCloudSearchRows(*cloudSets);
 	}
-	if (_footer) {
-		_footer->refreshIcons(ValidateIconAnimations::Scroll);
-	}
+	refreshIcons(ValidateIconAnimations::Scroll);
 
 	_lastMousePosition = QCursor::pos();
 
@@ -2695,15 +1753,6 @@ void StickersListWidget::mouseReleaseEvent(QMouseEvent *e) {
 	}
 }
 
-void StickersListWidget::validateSelectedIcon(
-		ValidateIconAnimations animations) {
-	if (_footer) {
-		_footer->validateSelectedIcon(
-			currentSet(getVisibleTop()),
-			animations);
-	}
-}
-
 void StickersListWidget::removeRecentSticker(int section, int index) {
 	if ((_section != Section::Stickers)
 		|| (section >= int(_mySets.size()))
@@ -2865,6 +1914,8 @@ void StickersListWidget::refreshStickers() {
 	_lastMousePosition = QCursor::pos();
 	updateSelected();
 	repaintItems();
+
+	visibleTopBottomUpdated(getVisibleTop(), getVisibleBottom());
 }
 
 void StickersListWidget::refreshMySets() {
@@ -2972,7 +2023,7 @@ void StickersListWidget::refreshSettingsVisibility() {
 }
 
 void StickersListWidget::refreshFooterIcons() {
-	_footer->refreshIcons(ValidateIconAnimations::None);
+	refreshIcons(ValidateIconAnimations::None);
 	if (_footer->hasOnlyFeaturedSets() && _section != Section::Featured) {
 		showStickerSet(Data::Stickers::FeaturedSetId);
 	}
@@ -3504,9 +2555,7 @@ void StickersListWidget::showStickerSet(uint64 setId) {
 			setSection(Section::Featured);
 			refreshRecentStickers(true);
 			refreshSettingsVisibility();
-			if (_footer) {
-				_footer->refreshIcons(ValidateIconAnimations::Scroll);
-			}
+			refreshIcons(ValidateIconAnimations::Scroll);
 			repaintItems();
 		}
 
@@ -3533,8 +2582,8 @@ void StickersListWidget::showStickerSet(uint64 setId) {
 	scrollTo(y);
 	_scrollUpdated.fire({});
 
-	if (needRefresh && _footer) {
-		_footer->refreshIcons(ValidateIconAnimations::Scroll);
+	if (needRefresh) {
+		refreshIcons(ValidateIconAnimations::Scroll);
 	}
 
 	_lastMousePosition = QCursor::pos();
@@ -3542,6 +2591,15 @@ void StickersListWidget::showStickerSet(uint64 setId) {
 	repaintItems();
 }
 
+void StickersListWidget::refreshIcons(ValidateIconAnimations animations) {
+	if (_footer) {
+		_footer->refreshIcons(
+			fillIcons(),
+			[=] { return getLottieRenderer(); },
+			animations);
+	}
+}
+
 void StickersListWidget::refreshMegagroupSetGeometry() {
 	auto left = megagroupSetInfoLeft();
 	auto availableWidth = (width() - left);
diff --git a/Telegram/SourceFiles/chat_helpers/stickers_list_widget.h b/Telegram/SourceFiles/chat_helpers/stickers_list_widget.h
index a15a9313d..2a29e9d0b 100644
--- a/Telegram/SourceFiles/chat_helpers/stickers_list_widget.h
+++ b/Telegram/SourceFiles/chat_helpers/stickers_list_widget.h
@@ -47,6 +47,8 @@ enum class Notification;
 namespace ChatHelpers {
 
 struct StickerIcon;
+enum class ValidateIconAnimations;
+class StickersListFooter;
 
 class StickersListWidget final : public TabbedSelector::Inner {
 public:
@@ -113,7 +115,6 @@ protected:
 	int countDesiredHeight(int newWidth) override;
 
 private:
-	class Footer;
 	struct Sticker;
 	struct Set;
 
@@ -231,13 +232,6 @@ private:
 	std::unique_ptr<Ui::RippleAnimation> createButtonRipple(int section);
 	QPoint buttonRippleTopLeft(int section) const;
 
-	enum class ValidateIconAnimations {
-		Full,
-		Scroll,
-		None,
-	};
-	void validateSelectedIcon(ValidateIconAnimations animations);
-
 	std::vector<Set> &shownSets();
 	const std::vector<Set> &shownSets() const;
 	int featuredRowHeight() const;
@@ -313,6 +307,7 @@ private:
 	void removeFavedSticker(int section, int index);
 	void setColumnCount(int count);
 	void refreshFooterIcons();
+	void refreshIcons(ValidateIconAnimations animations);
 
 	void showStickerSetBox(not_null<DocumentData*> document);
 
@@ -362,9 +357,7 @@ private:
 	base::Timer _updateSetsTimer;
 	base::flat_set<uint64> _repaintSetsIds;
 
-	uint64 _removingSetId = 0;
-
-	Footer *_footer = nullptr;
+	StickersListFooter *_footer = nullptr;
 	int _rowsLeft = 0;
 	int _columnCount = 1;
 	QSize _singleSize;
diff --git a/Telegram/SourceFiles/chat_helpers/tabbed_selector.cpp b/Telegram/SourceFiles/chat_helpers/tabbed_selector.cpp
index 972105ed3..d4e59c173 100644
--- a/Telegram/SourceFiles/chat_helpers/tabbed_selector.cpp
+++ b/Telegram/SourceFiles/chat_helpers/tabbed_selector.cpp
@@ -407,7 +407,7 @@ TabbedSelector::TabbedSelector(
 		session().data().stickers().emojiSetInstalled(
 		) | rpl::start_with_next([=](uint64 setId) {
 			_tabsSlider->setActiveSection(indexByType(SelectorTab::Emoji));
-			emoji()->showCustomSet(setId);
+			emoji()->showSet(setId);
 			_showRequests.fire({});
 		}, lifetime());
 	}