AyuGramDesktop/Telegram/SourceFiles/dialogs/ui/dialogs_top_bar_suggestion_content.cpp

/*
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 "dialogs/ui/dialogs_top_bar_suggestion_content.h"

#include "base/call_delayed.h"
#include "data/data_authorization.h"
#include "lang/lang_keys.h"
#include "lottie/lottie_icon.h"
#include "settings/settings_common.h"
#include "ui/effects/animation_value.h"
#include "ui/layers/generic_box.h"
#include "ui/painter.h"
#include "ui/power_saving.h"
#include "ui/rect.h"
#include "ui/text/format_values.h"
#include "ui/text/text_custom_emoji.h"
#include "ui/ui_rpl_filter.h"
#include "ui/ui_utility.h"
#include "ui/vertical_list.h"
#include "ui/vertical_list.h"
#include "ui/widgets/buttons.h"
#include "ui/widgets/labels.h"
#include "ui/widgets/shadow.h"
#include "ui/wrap/fade_wrap.h"
#include "ui/wrap/padding_wrap.h"
#include "ui/wrap/slide_wrap.h"
#include "ui/wrap/vertical_layout.h"
#include "styles/style_boxes.h"
#include "styles/style_chat_helpers.h"
#include "styles/style_chat.h"
#include "styles/style_dialogs.h"
#include "styles/style_layers.h"
#include "styles/style_premium.h"
#include "styles/style_settings.h"

namespace Dialogs {
namespace {

constexpr auto kLinesForPhoto = 3;

} // namespace

UnconfirmedAuthWrap::UnconfirmedAuthWrap(
	not_null<Ui::RpWidget*> parent,
	object_ptr<Ui::VerticalLayout> &&child)
: Ui::SlideWrap<Ui::VerticalLayout>(parent, std::move(child)) {
	paintRequest() | rpl::on_next([=] {
		if (!_collapseSnapshot.isNull()) {
			auto p = QPainter(this);
			p.drawPixmap(0, 0, _collapseSnapshot);
		}
	}, lifetime());
}

rpl::producer<int> UnconfirmedAuthWrap::desiredHeightValue() const {
	return entity()->heightValue();
}

void UnconfirmedAuthWrap::setCollapseProgress(
		rpl::producer<float64> progress) {
	std::move(progress) | rpl::on_next([=](float64 value) {
		if (_collapseProgress == value) {
			return;
		}
		_collapseProgress = value;
		if (value == 0.) {
			releaseCollapseSnapshot();
		}
		resizeToWidth(width());
		update();
	}, lifetime());
}

void UnconfirmedAuthWrap::prepareCollapseSnapshot() {
	_collapseSnapshot = Ui::GrabWidget(this);
	if (const auto w = wrapped()) {
		w->hide();
	}
	update();
}

void UnconfirmedAuthWrap::releaseCollapseSnapshot() {
	if (_collapseSnapshot.isNull()) {
		return;
	}
	_collapseSnapshot = QPixmap();
	if (const auto w = wrapped()) {
		w->show();
	}
}

int UnconfirmedAuthWrap::resizeGetHeight(int newWidth) {
	if (!_collapseSnapshot.isNull()) {
		const auto fullHeight = int(_collapseSnapshot.height()
			/ _collapseSnapshot.devicePixelRatio());
		return int(base::SafeRound(
			fullHeight * (1. - _collapseProgress)));
	}
	if (const auto w = wrapped()) {
		w->resizeToWidth(newWidth);
	}
	return wrapped() ? wrapped()->height() : 0;
}

not_null<UnconfirmedAuthWrap*> CreateUnconfirmedAuthContent(
		not_null<Ui::RpWidget*> parent,
		const std::vector<Data::UnreviewedAuth> &list,
		Fn<void(bool)> callback,
		rpl::producer<float64> collapseProgress) {
	const auto wrap = Ui::CreateChild<UnconfirmedAuthWrap>(
		parent,
		object_ptr<Ui::VerticalLayout>(parent));
	wrap->setCollapseProgress(std::move(collapseProgress));
	const auto content = wrap->entity();
	content->paintRequest() | rpl::on_next([=] {
		auto p = QPainter(content);
		p.fillRect(content->rect(), st::dialogsBg);
	}, content->lifetime());

	const auto padding = st::dialogsUnconfirmedAuthPadding;

	Ui::AddSkip(content);

	content->add(
		object_ptr<Ui::FlatLabel>(
			content,
			tr::lng_unconfirmed_auth_title(),
			st::dialogsUnconfirmedAuthTitle),
		padding,
		style::al_top);

	Ui::AddSkip(content);

	auto messageText = QString();
	if (list.size() == 1) {
		const auto &auth = list.at(0);
		messageText = tr::lng_unconfirmed_auth_single(
			tr::now,
			lt_from,
			auth.device,
			lt_country,
			auth.location);
	} else {
		auto commonLocation = list.at(0).location;
		for (auto i = 1; i < list.size(); ++i) {
			if (commonLocation != list.at(i).location) {
				commonLocation.clear();
				break;
			}
		}
		if (commonLocation.isEmpty()) {
			messageText = tr::lng_unconfirmed_auth_multiple(
				tr::now,
				lt_count,
				list.size());
		} else {
			messageText = tr::lng_unconfirmed_auth_multiple_from(
				tr::now,
				lt_count,
				list.size(),
				lt_country,
				commonLocation);
		}
	}

	content->add(
		object_ptr<Ui::FlatLabel>(
			content,
			rpl::single(messageText),
			st::dialogsUnconfirmedAuthAbout),
		padding,
		style::al_top)->setTryMakeSimilarLines(true);

	Ui::AddSkip(content);
	const auto buttons = content->add(object_ptr<Ui::FixedHeightWidget>(
		content,
		st::dialogsUnconfirmedAuthButton.height));
	const auto yes = Ui::CreateChild<Ui::RoundButton>(
		buttons,
		tr::lng_unconfirmed_auth_confirm(),
		st::dialogsUnconfirmedAuthButton);
	const auto no = Ui::CreateChild<Ui::RoundButton>(
		buttons,
		tr::lng_unconfirmed_auth_deny(),
		st::dialogsUnconfirmedAuthButtonNo);
	yes->setClickedCallback([=] {
		wrap->toggle(false, anim::type::normal);
		base::call_delayed(st::universalDuration, wrap, [=] {
			callback(true);
		});
	});
	no->setClickedCallback([=] {
		wrap->toggle(false, anim::type::normal);
		base::call_delayed(st::universalDuration, wrap, [=] {
			callback(false);
		});
	});
	buttons->sizeValue(
	) | rpl::filter_size(
	) | rpl::on_next([=](const QSize &s) {
		const auto halfWidth = (s.width() - rect::m::sum::h(padding)) / 2;
		yes->moveToLeft(
			padding.left() + (halfWidth - yes->width()) / 2,
			0);
		no->moveToLeft(
			padding.left() + halfWidth + (halfWidth - no->width()) / 2,
			0);
	}, buttons->lifetime());
	Ui::AddSkip(content);
	content->add(object_ptr<Ui::FadeShadow>(content));

	return wrap;
}

TopBarSuggestionContent::TopBarSuggestionContent(
	not_null<Ui::RpWidget*> parent,
	Fn<bool()> emojiPaused)
: Ui::RippleButton(parent, st::defaultRippleAnimationBgOver)
, _titleSt(st::semiboldTextStyle)
, _contentTitleSt(st::dialogsTopBarSuggestionTitleStyle)
, _contentTextSt(st::dialogsTopBarSuggestionAboutStyle)
, _emojiPaused(std::move(emojiPaused)) {
	_leftPadding = st::dialogsTopBarLeftPadding;
	setRightIcon(RightIcon::Close);
}

void TopBarSuggestionContent::setRightIcon(RightIcon icon) {
	_rightButton = nullptr;
	if (icon == _rightIcon) {
		return;
	}
	_rightHide = nullptr;
	_rightArrow = nullptr;
	_rightIcon = icon;
	if (icon == RightIcon::Close) {
		_rightHide = base::make_unique_q<Ui::IconButton>(
			this,
			st::dialogsCancelSearchInPeer);
		const auto rightHide = _rightHide.get();
		sizeValue() | rpl::filter_size(
		) | rpl::on_next([=](const QSize &s) {
			rightHide->moveToRight(st::buttonRadius, st::lineWidth);
		}, rightHide->lifetime());
		rightHide->show();
	} else if (icon == RightIcon::Arrow) {
		_rightArrow = base::make_unique_q<Ui::IconButton>(
			this,
			st::backButton);
		const auto arrow = _rightArrow.get();
		arrow->setIconOverride(
			&st::settingsPremiumArrow,
			&st::settingsPremiumArrowOver);
		arrow->setAttribute(Qt::WA_TransparentForMouseEvents);
		sizeValue() | rpl::filter_size(
		) | rpl::on_next([=](const QSize &s) {
			const auto &point = st::settingsPremiumArrowShift;
			arrow->moveToLeft(
				s.width() - arrow->width(),
				point.y() + (s.height() - arrow->height()) / 2);
		}, arrow->lifetime());
		arrow->show();
	}
	resizeToWidth(width());
}

void TopBarSuggestionContent::setRightButton(
		rpl::producer<TextWithEntities> text,
		Fn<void()> callback) {
	_rightHide = nullptr;
	_rightArrow = nullptr;
	_rightIcon = RightIcon::None;
	if (!text) {
		_rightButton = nullptr;
		return;
	}
	using namespace Ui;
	_rightButton = base::make_unique_q<RoundButton>(
		this,
		rpl::single(QString()),
		st::dialogsTopBarRightButton);
	_rightButton->setText(std::move(text));
	rpl::combine(
		sizeValue(),
		_rightButton->sizeValue()
	) | rpl::on_next([=](QSize outer, QSize inner) {
		const auto top = (outer.height() - inner.height()) / 2;
		_rightButton->moveToRight(top, top, outer.width());
	}, _rightButton->lifetime());
	_rightButton->setFullRadius(true);
	_rightButton->setClickedCallback(std::move(callback));
	_rightButton->show();
}

void TopBarSuggestionContent::draw(QPainter &p) {
	const auto r = Ui::RpWidget::rect();
	p.fillRect(r, st::historyPinnedBg);
	p.fillRect(
		r.x(),
		r.y() + r.height() - st::lineWidth,
		r.width(),
		st::lineWidth,
		st::shadowFg);
	Ui::RippleButton::paintRipple(p, 0, 0);
	const auto leftPadding = _leftPadding;
	const auto rightPadding = 0;
	const auto topPadding = st::msgReplyPadding.top();
	const auto availableWidthNoPhoto = r.width()
		- (_rightArrow
			? (_rightArrow->width() / 4 * 3) // Takes full height.
			: 0)
		- leftPadding
		- rightPadding;
	const auto availableWidth = availableWidthNoPhoto
		- (_rightHide ? _rightHide->width() : 0);
	const auto titleRight = leftPadding;
	const auto hasSecondLineTitle = availableWidth < _contentTitle.maxWidth();
	const auto paused = On(PowerSaving::kEmojiChat)
		|| (_emojiPaused && _emojiPaused());
	p.setPen(st::windowActiveTextFg);
	p.setPen(st::windowFg);
	{
		const auto left = leftPadding;
		const auto top = topPadding;
		_contentTitle.draw(p, {
			.position = QPoint(left, top),
			.outerWidth = hasSecondLineTitle
				? availableWidth
				: (availableWidth - titleRight),
			.availableWidth = availableWidth,
			.pausedEmoji = paused,
			.elisionLines = hasSecondLineTitle ? 2 : 1,
		});
	}
	{
		const auto left = leftPadding;
		const auto top = hasSecondLineTitle
			? (topPadding
				+ _titleSt.font->height
				+ _contentTitleSt.font->height)
			: topPadding + _titleSt.font->height;
		const auto lineHeight = _contentTextSt.font->height;
		const auto lineLayout = [=](int line) -> Ui::Text::LineGeometry {
			line++;
			const auto diff = (st::sponsoredMessageBarMaxHeight)
				- line * lineHeight;
			if (diff < 3 * lineHeight) {
				return {
					.width = availableWidthNoPhoto,
					.elided = true,
				};
			} else if (diff < 2 * lineHeight) {
				return {};
			}
			line += (hasSecondLineTitle ? 2 : 1) + 1;
			return {
				.width = (line > kLinesForPhoto)
					? availableWidthNoPhoto
					: availableWidth,
			};
		};
		p.setPen(_descriptionColorOverride.value_or(st::windowSubTextFg->c));
		_contentText.draw(p, {
			.position = QPoint(left, top),
			.outerWidth = availableWidth,
			.availableWidth = availableWidth,
			.geometry = Ui::Text::GeometryDescriptor{
				.layout = std::move(lineLayout),
			},
			.pausedEmoji = paused,
		});
	}
}

void TopBarSuggestionContent::setContent(
		TextWithEntities title,
		TextWithEntities description,
		std::optional<Ui::Text::MarkedContext> context,
		std::optional<QColor> descriptionColorOverride) {
	_descriptionColorOverride = descriptionColorOverride;
	if (context) {
		context->repaint = [=] { update(); };
		_contentTitle.setMarkedText(
			_contentTitleSt,
			std::move(title),
			kMarkupTextOptions,
			*context);
		_contentText.setMarkedText(
			_contentTextSt,
			std::move(description),
			kMarkupTextOptions,
			base::take(*context));
	} else {
		_contentTitle.setMarkedText(_contentTitleSt, std::move(title));
		_contentText.setMarkedText(_contentTextSt, std::move(description));
	}
	resizeToWidth(width());
	update();
}

void TopBarSuggestionContent::paintEvent(QPaintEvent *) {
	auto p = QPainter(this);
	if (!_collapseSnapshot.isNull()) {
		p.drawPixmap(0, 0, _collapseSnapshot);
		return;
	}
	draw(p);
}

void TopBarSuggestionContent::prepareCollapseSnapshot() {
	_collapseSnapshot = Ui::GrabWidget(this);
	for (const auto child : children()) {
		if (const auto widget = qobject_cast<QWidget*>(child)) {
			widget->hide();
		}
	}
	update();
}

void TopBarSuggestionContent::releaseCollapseSnapshot() {
	if (_collapseSnapshot.isNull()) {
		return;
	}
	_collapseSnapshot = QPixmap();
	for (const auto child : children()) {
		if (const auto widget = qobject_cast<QWidget*>(child)) {
			widget->show();
		}
	}
}

int TopBarSuggestionContent::resizeGetHeight(int newWidth) {
	if (!_collapseSnapshot.isNull()) {
		const auto fullHeight = int(_collapseSnapshot.height()
			/ _collapseSnapshot.devicePixelRatio());
		return int(base::SafeRound(
			fullHeight * (1. - _collapseProgress)));
	}
	const auto topPadding = st::msgReplyPadding.top();
	const auto bottomPadding = st::msgReplyPadding.top();
	const auto availableWidthNoPhoto = newWidth
		- (_rightArrow
			? (_rightArrow->width() / 4 * 3) // Takes full height.
			: 0)
		- _leftPadding;
	const auto availableWidth = availableWidthNoPhoto
		- (_rightHide ? _rightHide->width() : 0);
	if (availableWidth <= 0) {
		return topPadding + bottomPadding;
	}
	const auto hasSecondLineTitle
		= (availableWidth < _contentTitle.maxWidth());
	const auto textTop = hasSecondLineTitle
		? (topPadding
			+ _titleSt.font->height
			+ _contentTitleSt.font->height)
		: (topPadding + _titleSt.font->height);

	const auto lineHeight = _contentTextSt.font->height;
	auto lineLayout = [=](int line) -> Ui::Text::LineGeometry {
		line++;
		const auto diff = (st::sponsoredMessageBarMaxHeight)
			- line * lineHeight;
		if (diff < 3 * lineHeight) {
			return {
				.width = availableWidthNoPhoto,
				.elided = true,
			};
		} else if (diff < 2 * lineHeight) {
			return {};
		}
		line += (hasSecondLineTitle ? 2 : 1) + 1;
		return {
			.width = (line > kLinesForPhoto)
				? availableWidthNoPhoto
				: availableWidth,
		};
	};
	const auto dims = _contentText.countDimensions(
		Ui::Text::GeometryDescriptor{ .layout = std::move(lineLayout) });
	const auto natural = textTop + dims.height + bottomPadding;
	const auto capped = std::min(
		natural,
		st::sponsoredMessageBarMaxHeight);
	return int(base::SafeRound(capped * (1. - _collapseProgress)));
}

void TopBarSuggestionContent::setCollapseProgress(
		rpl::producer<float64> progress) {
	std::move(progress) | rpl::on_next([=](float64 value) {
		if (_collapseProgress == value) {
			return;
		}
		_collapseProgress = value;
		if (value == 0.) {
			releaseCollapseSnapshot();
		}
		resizeToWidth(width());
		update();
	}, lifetime());
}

void TopBarSuggestionContent::setHideCallback(Fn<void()> hideCallback) {
	Expects(_rightHide != nullptr);
	_rightHide->setClickedCallback(std::move(hideCallback));
}

void TopBarSuggestionContent::setLeadingWidget(Ui::RpWidget *widget) {
	_leadingWidgetLifetime.destroy();
	if (_leadingWidget && _leadingWidget != widget) {
		_leadingWidget->deleteLater();
	}
	_leadingWidget = widget;
	const auto basePadding = st::dialogsTopBarLeftPadding;
	if (!widget) {
		if (_leftPadding != basePadding) {
			_leftPadding = basePadding;
			resizeToWidth(width());
			update();
		}
		return;
	}
	widget->setParent(this);
	widget->setAttribute(Qt::WA_TransparentForMouseEvents);
	sizeValue() | rpl::filter_size(
	) | rpl::on_next([=](const QSize &s) {
		widget->raise();
		widget->show();
		widget->moveToLeft(
			basePadding,
			(s.height() - widget->height()) / 2);
	}, _leadingWidgetLifetime);
	const auto padding = widget->width() + basePadding * 2;
	if (_leftPadding != padding) {
		_leftPadding = padding;
		resizeToWidth(width());
		update();
	}
}

const style::TextStyle & TopBarSuggestionContent::contentTitleSt() const {
	return _contentTitleSt;
}

} // namespace Dialogs