Show explaining preview of forwards privacy.

Telegram/SourceFiles/settings/settings_privacy_controllers.cpp

@@ -16,12 +16,21 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
 #include "storage/localstorage.h"
 #include "data/data_user.h"
 #include "data/data_session.h"
+#include "history/admin_log/history_admin_log_item.h"
+#include "history/view/history_view_element.h"
+#include "history/view/history_view_message.h"
+#include "history/history_item_components.h"
+#include "history/history_message.h"
 #include "history/history.h"
 #include "calls/calls_instance.h"
 #include "ui/widgets/checkbox.h"
+#include "ui/wrap/padding_wrap.h"
 #include "ui/wrap/vertical_layout.h"
+#include "ui/image/image_prepare.h"
+#include "window/section_widget.h"
 #include "boxes/peer_list_controllers.h"
 #include "boxes/confirm_box.h"
+#include "styles/style_history.h"
 #include "styles/style_boxes.h"
 #include "styles/style_settings.h"
 
@@ -91,6 +100,54 @@ std::unique_ptr<BlockUserBoxController::Row> BlockUserBoxController::createRow(n
 	return nullptr;
 }
 
+AdminLog::OwnedItem GenerateForwardedItem(
+		not_null<HistoryView::ElementDelegate*> delegate,
+		not_null<History*> history,
+		const QString &text) {
+	Expects(history->peer->isUser());
+
+	using Flag = MTPDmessage::Flag;
+	using FwdFlag = MTPDmessageFwdHeader::Flag;
+	// #TODO common global incrementable id for fake items, like clientMsgId.
+	static auto id = ServerMaxMsgId + (ServerMaxMsgId / 6);
+	const auto flags = Flag::f_from_id | Flag::f_fwd_from;
+	const auto replyTo = 0;
+	const auto viaBotId = 0;
+	const auto item = MTP_message(
+		MTP_flags(flags),
+		MTP_int(++id),
+		MTP_int(peerToUser(history->peer->id)),
+		peerToMTP(history->session().userPeerId()),
+		MTP_messageFwdHeader(
+			MTP_flags(FwdFlag::f_from_id),
+			MTP_int(history->session().userId()),
+			MTPstring(), // from_name
+			MTP_int(unixtime()),
+			MTPint(), // channel_id
+			MTPint(), // channel_post
+			MTPstring(), // post_author
+			MTPPeer(), // saved_from_peer
+			MTPint()), // saved_from_msg_id
+		MTPint(), // via_bot_id
+		MTPint(), // reply_to_msg_id,
+		MTP_int(unixtime()), // date
+		MTP_string(text),
+		MTPMessageMedia(),
+		MTPReplyMarkup(),
+		MTPnullEntities,
+		MTPint(), // views
+		MTPint(), // edit_date
+		MTPstring(), // post_author
+		MTPlong() // grouped_id
+	).match([&](const MTPDmessage & data) {
+		return new HistoryMessage(history, data);
+	}, [](auto &&) -> HistoryMessage* {
+		Unexpected("Type in GenerateForwardedItem.");
+	});
+
+	return AdminLog::OwnedItem(delegate, item);
+}
+
 } // namespace
 
 void BlockedBoxController::prepare() {
@@ -473,6 +530,186 @@ auto ForwardsPrivacyController::exceptionsDescription()
 	return Lang::Viewer(lng_edit_privacy_forwards_exceptions);
 }
 
+object_ptr<Ui::RpWidget> ForwardsPrivacyController::setupAboveWidget(
+		not_null<QWidget*> parent,
+		rpl::producer<Option> optionValue) {
+	using namespace rpl::mappers;
+
+	auto message = GenerateForwardedItem(
+		delegate(),
+		Auth().data().history(
+			peerFromUser(PeerData::kServiceNotificationsId)),
+		lang(lng_edit_privacy_forwards_sample_message));
+	const auto view = message.get();
+
+	auto result = object_ptr<Ui::RpWidget>(parent);
+	const auto widget = result.data();
+	Ui::AttachAsChild(widget, std::move(message));
+
+	const auto option = widget->lifetime().make_state<Option>();
+
+	const auto padding = st::settingsForwardPrivacyPadding;
+	widget->widthValue(
+	) | rpl::filter(
+		_1 >= (st::historyMinimalWidth / 2)
+	) | rpl::start_with_next([=](int width) {
+		const auto height = view->resizeGetHeight(width);
+		const auto top = view->marginTop();
+		const auto bottom = view->marginBottom();
+		const auto full = padding + bottom + height + top + padding;
+		widget->resize(width, full);
+	}, widget->lifetime());
+
+	widget->paintRequest(
+	) | rpl::start_with_next([=](QRect rect) {
+		Window::SectionWidget::PaintBackground(widget, rect);
+
+		Painter p(widget);
+		p.translate(0, padding + view->marginBottom());
+		view->draw(p, widget->rect(), TextSelection(), crl::now());
+
+		PaintForwardedTooltip(p, view, *option);
+	}, widget->lifetime());
+
+	std::move(
+		optionValue
+	) | rpl::start_with_next([=](Option value) {
+		*option = value;
+		widget->update();
+	}, widget->lifetime());
+
+	return result;
+}
+
+void ForwardsPrivacyController::PaintForwardedTooltip(
+		Painter &p,
+		not_null<HistoryView::Element*> view,
+		Option value) {
+	// This breaks HistoryView::Element encapsulation :(
+	const auto forwarded = view->data()->Get<HistoryMessageForwarded>();
+	const auto availableWidth = view->width()
+		- st::msgMargin.left()
+		- st::msgMargin.right();
+	const auto bubbleWidth = ranges::min({
+		availableWidth,
+		view->maxWidth(),
+		st::msgMaxWidth
+	});
+	const auto innerWidth = bubbleWidth
+		- st::msgPadding.left()
+		- st::msgPadding.right();
+	const auto phrase = lng_forwarded(
+		lt_user,
+		App::peerName(view->data()->history()->session().user()));
+	const auto possiblePosition = Lang::FindTagReplacementPosition(
+		lang(lng_forwarded__tagged),
+		lt_user);
+	const auto position = (possiblePosition >= 0
+		&& possiblePosition < phrase.size())
+		? possiblePosition
+		: 0;
+	const auto before = phrase.mid(0, position);
+	const auto skip = st::msgMargin.left() + st::msgPadding.left();
+	const auto small = forwarded->text.countHeight(innerWidth)
+		< 2 * st::msgServiceFont->height;
+	const auto nameLeft = skip + (small ? st::msgServiceFont->width(before) : 0);
+	const auto right = skip + innerWidth;
+	const auto key = [&] {
+		switch (value) {
+		case Option::Everyone:
+			return lng_edit_privacy_forwards_sample_everyone;
+		case Option::Contacts:
+			return lng_edit_privacy_forwards_sample_contacts;
+		case Option::Nobody:
+			return lng_edit_privacy_forwards_sample_nobody;
+		}
+		Unexpected("Option value in ForwardsPrivacyController.");
+	}();
+	const auto text = lang(key);
+	const auto &font = st::toastTextStyle.font;
+	const auto textWidth = font->width(text);
+	const auto arrowSkip = st::settingsForwardPrivacyArrowSkip;
+	const auto arrowSize = st::settingsForwardPrivacyArrowSize;
+	const auto fullWidth = std::max(textWidth, 2 * arrowSkip);
+	const auto padding = st::settingsForwardPrivacyTooltipPadding;
+	const auto rect = QRect(0, 0, textWidth, font->height).marginsAdded(
+		padding
+	).translated(padding.left(), padding.top());
+
+	const auto top = view->marginTop()
+		+ st::msgPadding.top()
+		+ (small ? 1 : 2) * st::msgServiceFont->height
+		+ arrowSize;
+	const auto left1 = std::min(nameLeft, right - rect.width());
+	const auto left2 = std::max(left1, skip);
+	const auto left = left2;
+	const auto arrowLeft1 = nameLeft + arrowSkip;
+	const auto arrowLeft2 = std::min(
+		arrowLeft1,
+		std::max((left + right) / 2, right - arrowSkip));
+	const auto arrowLeft = arrowLeft2;
+	const auto geometry = rect.translated(left, top);
+
+	App::roundRect(p, geometry, st::toastBg, ImageRoundRadius::Small);
+
+	p.setFont(font);
+	p.setPen(st::toastFg);
+	p.drawText(
+		geometry.x() + padding.left(),
+		geometry.y() + padding.top() + font->ascent,
+		text);
+
+	QPainterPath path;
+	path.moveTo(arrowLeft - arrowSize, top);
+	path.lineTo(arrowLeft, top - arrowSize);
+	path.lineTo(arrowLeft + arrowSize, top);
+	path.lineTo(arrowLeft - arrowSize, top);
+	{
+		PainterHighQualityEnabler hq(p);
+		p.setPen(Qt::NoPen);
+		p.fillPath(path, st::toastBg);
+	}
+}
+
+auto ForwardsPrivacyController::delegate()
+-> not_null<HistoryView::ElementDelegate*> {
+	return static_cast<HistoryView::ElementDelegate*>(this);
+}
+
+HistoryView::Context ForwardsPrivacyController::elementContext() {
+	return HistoryView::Context::ContactPreview;
+}
+
+auto ForwardsPrivacyController::elementCreate(
+	not_null<HistoryMessage*> message)
+-> std::unique_ptr<HistoryView::Element> {
+	return std::make_unique<HistoryView::Message>(delegate(), message);
+}
+
+auto ForwardsPrivacyController::elementCreate(
+	not_null<HistoryService*> message)
+-> std::unique_ptr<HistoryView::Element> {
+	Unexpected("Service message in ForwardsPrivacyController.");
+}
+
+bool ForwardsPrivacyController::elementUnderCursor(
+		not_null<const Element*> view) {
+	return false;
+}
+
+void ForwardsPrivacyController::elementAnimationAutoplayAsync(
+	not_null<const Element*> element) {
+}
+
+crl::time ForwardsPrivacyController::elementHighlightTime(
+		not_null<const Element*> element) {
+	return crl::time(0);
+}
+
+bool ForwardsPrivacyController::elementInSelectionMode() {
+	return false;
+}
+
 ApiWrap::Privacy::Key ProfilePhotoPrivacyController::key() {
 	return Key::ProfilePhoto;
 }