tg_windows5.12.6/Telegram/SourceFiles/ui/chat/message_bar.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 "ui/chat/message_bar.h"

#include "ui/effects/spoiler_mess.h"
#include "ui/image/image_prepare.h"
#include "ui/painter.h"
#include "ui/power_saving.h"
#include "ui/text/text_options.h"
#include "ui/ui_utility.h"
#include "styles/style_chat.h"
#include "styles/style_chat_helpers.h"
#include "styles/palette.h"

namespace Ui {
namespace {

[[nodiscard]] int SameFirstPartLength(const QString &a, const QString &b) {
	const auto &[i, j] = ranges::mismatch(a, b);
	return (i - a.begin());
}

[[nodiscard]] bool MuchDifferent(
		int same,
		const QString &a,
		const QString &b) {
	return (same * 2 < a.size()) || (same * 2 < b.size());
}

[[nodiscard]] bool MuchDifferent(const QString &a, const QString &b) {
	return MuchDifferent(SameFirstPartLength(a, b), a, b);
}

[[nodiscard]] bool ComplexTitleAnimation(
		int same,
		const QString &a,
		const QString &b) {
	return !MuchDifferent(same, a, b)
		&& (same != a.size() || same != b.size());
}

} // namespace

MessageBar::MessageBar(
	not_null<QWidget*> parent,
	const style::MessageBar &st,
	Fn<bool()> customEmojiPaused)
: _st(st)
, _widget(parent)
, _customEmojiPaused(std::move(customEmojiPaused)) {
	setup();

	style::PaletteChanged(
	) | rpl::start_with_next([=] {
		_topBarGradient = _bottomBarGradient = QPixmap();
	}, _widget.lifetime());
}

void MessageBar::customEmojiRepaint() {
	if (_customEmojiRepaintScheduled) {
		return;
	}
	_customEmojiRepaintScheduled = true;
	_widget.update();
}

void MessageBar::setup() {
	_widget.resize(0, st::historyReplyHeight);
	_widget.paintRequest(
	) | rpl::start_with_next([=](QRect rect) {
		auto p = Painter(&_widget);
		p.setInactive(_customEmojiPaused());
		_customEmojiRepaintScheduled = false;
		paint(p);
	}, _widget.lifetime());
}

void MessageBar::set(MessageBarContent &&content) {
	_contentLifetime.destroy();
	tweenTo(std::move(content));
}

void MessageBar::set(rpl::producer<MessageBarContent> content) {
	_contentLifetime.destroy();
	std::move(
		content
	) | rpl::start_with_next([=](MessageBarContent &&content) {
		tweenTo(std::move(content));
	}, _contentLifetime);
}

MessageBar::BodyAnimation MessageBar::DetectBodyAnimationType(
		Animation *currentAnimation,
		const MessageBarContent &currentContent,
		const MessageBarContent &nextContent) {
	const auto now = currentAnimation
		? currentAnimation->bodyAnimation
		: BodyAnimation::None;
	const auto somethingChanged = (currentContent.text != nextContent.text)
		|| (currentContent.title != nextContent.title)
		|| (currentContent.index != nextContent.index)
		|| (currentContent.count != nextContent.count);
	return (now == BodyAnimation::Full
		|| MuchDifferent(currentContent.title, nextContent.title)
		|| (currentContent.title.isEmpty() && somethingChanged))
		? BodyAnimation::Full
		: (now == BodyAnimation::Text || somethingChanged)
		? BodyAnimation::Text
		: BodyAnimation::None;
}

void MessageBar::tweenTo(MessageBarContent &&content) {
	Expects(content.count > 0);
	Expects(content.index >= 0 && content.index < content.count);

	_widget.update();
	if (!_st.duration || anim::Disabled() || _widget.size().isEmpty()) {
		updateFromContent(std::move(content));
		return;
	}
	const auto hasImageChanged = (_content.preview.isNull()
		!= content.preview.isNull());
	const auto bodyChanged = (_content.index != content.index
		|| _content.count != content.count
		|| _content.title != content.title
		|| _content.text != content.text
		|| _content.preview.constBits() != content.preview.constBits());
	const auto barCountChanged = (_content.count != content.count);
	const auto barFrom = _content.index;
	const auto barTo = content.index;
	auto animation = Animation();
	animation.bodyAnimation = DetectBodyAnimationType(
		_animation.get(),
		_content,
		content);
	animation.movingTo = (content.index > _content.index)
		? RectPart::Top
		: (content.index < _content.index)
		? RectPart::Bottom
		: RectPart::None;
	animation.imageFrom = grabImagePart();
	animation.spoilerFrom = std::move(_spoiler);
	animation.bodyOrTextFrom = grabBodyOrTextPart(animation.bodyAnimation);
	const auto sameLength = SameFirstPartLength(
		_content.title,
		content.title);
	if (animation.bodyAnimation == BodyAnimation::Text
		&& ComplexTitleAnimation(sameLength, _content.title, content.title)) {
		animation.titleSame = grabTitleBase(sameLength);
		animation.titleFrom = grabTitlePart(sameLength);
	}
	auto was = std::move(_animation);
	updateFromContent(std::move(content));
	animation.imageTo = grabImagePart();
	animation.bodyOrTextTo = grabBodyOrTextPart(animation.bodyAnimation);
	if (!animation.titleSame.isNull()) {
		animation.titleTo = grabTitlePart(sameLength);
	}
	if (was) {
		_animation = std::move(was);
		std::swap(*_animation, animation);
		_animation->imageShown = std::move(animation.imageShown);
		_animation->barScroll = std::move(animation.barScroll);
		_animation->barTop = std::move(animation.barTop);
	} else {
		_animation = std::make_unique<Animation>(std::move(animation));
	}

	if (hasImageChanged) {
		_animation->imageShown.start(
			[=] { _widget.update(); },
			_image.isNull() ? 1. : 0.,
			_image.isNull() ? 0. : 1.,
			_st.duration);
	}
	if (bodyChanged) {
		_animation->bodyMoved.start(
			[=] { _widget.update(); },
			0.,
			1.,
			_st.duration);
	}
	if (barCountChanged) {
		_animation->barScroll.stop();
		_animation->barTop.stop();
	} else if (barFrom != barTo) {
		const auto wasState = countBarState(barFrom);
		const auto nowState = countBarState(barTo);
		_animation->barScroll.start(
			[=] { _widget.update(); },
			wasState.scroll,
			nowState.scroll,
			_st.duration);
		_animation->barTop.start(
			[] {},
			wasState.offset,
			nowState.offset,
			_st.duration);
	}
}

void MessageBar::updateFromContent(MessageBarContent &&content) {
	_content = std::move(content);
	_title.setText(_st.title, _content.title);
	_text.setMarkedText(
		_st.text,
		_content.text,
		Ui::DialogTextOptions(),
		_content.context);
	_image = prepareImage(_content.preview);
	if (!_content.spoilerRepaint) {
		_spoiler = nullptr;
	} else if (!_spoiler) {
		_spoiler = std::make_unique<SpoilerAnimation>(
			_content.spoilerRepaint);
	}
}

QRect MessageBar::imageRect() const {
	const auto left = st::msgReplyBarSkip + st::msgReplyBarSkip;
	const auto top = (st::historyReplyHeight - st::historyReplyPreview) / 2;
	const auto size = st::historyReplyPreview;
	return QRect(left, top, size, size);
}

QRect MessageBar::titleRangeRect(int from, int till) const {
	auto result = bodyRect();
	result.setHeight(st::msgServiceNameFont->height);
	const auto left = from
		? st::msgServiceNameFont->width(_content.title.mid(0, from))
		: 0;
	const auto right = (till <= _content.title.size())
		? st::msgServiceNameFont->width(_content.title.mid(0, till))
		: result.width();
	result.setLeft(result.left() + left);
	result.setWidth(right - left);
	return result;
}

QRect MessageBar::bodyRect(bool withImage) const {
	const auto innerLeft = st::msgReplyBarSkip + st::msgReplyBarSkip;
	const auto imageSkip = st::historyReplyPreview + st::msgReplyBarSkip;
	const auto left = innerLeft + (withImage ? imageSkip : 0);
	const auto top = st::msgReplyPadding.top();
	const auto width = _widget.width() - left - st::msgReplyPadding.right();
	const auto height = (st::historyReplyHeight - 2 * top);
	return QRect(left, top, width, height) - _content.margins;
}

QRect MessageBar::bodyRect() const {
	return bodyRect(!_image.isNull());
}

QRect MessageBar::textRect() const {
	auto result = bodyRect();
	result.setTop(result.top() + st::msgServiceNameFont->height);
	return result;
}

auto MessageBar::makeGrabGuard() {
	auto imageShown = _animation
		? std::move(_animation->imageShown)
		: Ui::Animations::Simple();
	auto spoiler = std::move(_spoiler);
	auto fromSpoiler = _animation
		? std::move(_animation->spoilerFrom)
		: nullptr;
	return gsl::finally([
		&,
		shown = std::move(imageShown),
		spoiler = std::move(spoiler),
		fromSpoiler = std::move(fromSpoiler)
	]() mutable {
		if (_animation) {
			_animation->imageShown = std::move(shown);
			_animation->spoilerFrom = std::move(fromSpoiler);
		}
		_spoiler = std::move(spoiler);
	});
}

QPixmap MessageBar::grabBodyOrTextPart(BodyAnimation type) {
	return (type == BodyAnimation::Full)
		? grabBodyPart()
		: (type == BodyAnimation::Text)
		? grabTextPart()
		: QPixmap();
}

QPixmap MessageBar::grabTitleBase(int till) {
	return grabTitleRange(0, till);
}

QPixmap MessageBar::grabTitlePart(int from) {
	Expects(from <= _content.title.size());

	return grabTitleRange(from, _content.title.size());
}

QPixmap MessageBar::grabTitleRange(int from, int till) {
	const auto guard = makeGrabGuard();
	return GrabWidget(widget(), titleRangeRect(from, till));
}

QPixmap MessageBar::grabBodyPart() {
	const auto guard = makeGrabGuard();
	return GrabWidget(widget(), bodyRect());
}

QPixmap MessageBar::grabTextPart() {
	const auto guard = makeGrabGuard();
	return GrabWidget(widget(), textRect());
}

QPixmap MessageBar::grabImagePart() {
	if (!_animation) {
		return _image;
	}
	const auto guard = makeGrabGuard();
	return (_animation->bodyMoved.animating()
		&& !_animation->imageFrom.isNull()
		&& !_animation->imageTo.isNull())
		? GrabWidget(widget(), imageRect())
		: _animation->imageFrom;
}

void MessageBar::finishAnimating() {
	if (_animation) {
		_animation = nullptr;
		_widget.update();
	}
}

QPixmap MessageBar::prepareImage(const QImage &preview) {
	return QPixmap::fromImage(preview, Qt::ColorOnly);
}

void MessageBar::paint(Painter &p) {
	const auto progress = _animation ? _animation->bodyMoved.value(1.) : 1.;
	const auto imageFinal = _image.isNull() ? 0. : 1.;
	const auto imageShown = _animation
		? _animation->imageShown.value(imageFinal)
		: imageFinal;
	if (progress == 1. && imageShown == imageFinal && _animation) {
		_animation = nullptr;
	}
	const auto body = [&] {
		if (!_animation || !_animation->imageShown.animating()) {
			return bodyRect();
		}
		const auto noImage = bodyRect(false);
		const auto withImage = bodyRect(true);
		return QRect(
			anim::interpolate(noImage.x(), withImage.x(), imageShown),
			noImage.y(),
			anim::interpolate(noImage.width(), withImage.width(), imageShown),
			noImage.height());
	}();
	const auto text = textRect();
	const auto image = imageRect();
	const auto width = _widget.width();
	const auto noShift = !_animation
		|| (_animation->movingTo == RectPart::None);
	const auto shiftFull = st::msgReplyBarSkip;
	const auto shiftTo = noShift
		? 0
		: (_animation->movingTo == RectPart::Top)
		? anim::interpolate(shiftFull, 0, progress)
		: anim::interpolate(-shiftFull, 0, progress);
	const auto shiftFrom = noShift
		? 0
		: (_animation->movingTo == RectPart::Top)
		? (shiftTo - shiftFull)
		: (shiftTo + shiftFull);
	const auto now = crl::now();
	const auto paused = p.inactive();
	const auto pausedSpoiler = paused || On(PowerSaving::kChatSpoiler);

	paintLeftBar(p);

	if (!_animation) {
		if (!_image.isNull()) {
			paintImageWithSpoiler(
				p,
				image,
				_image,
				_spoiler.get(),
				now,
				pausedSpoiler);
		}
	} else if (!_animation->imageTo.isNull()
		|| (!_animation->imageFrom.isNull()
			&& _animation->imageShown.animating())) {
		const auto rect = [&] {
			if (!_animation->imageShown.animating()) {
				return image;
			}
			const auto size = anim::interpolate(0, image.width(), imageShown);
			return QRect(
				image.x(),
				image.y() + (image.height() - size) / 2,
				size,
				size);
		}();
		if (_animation->bodyMoved.animating()) {
			p.setOpacity(1. - progress);
			paintImageWithSpoiler(
				p,
				rect.translated(0, shiftFrom),
				_animation->imageFrom,
				_animation->spoilerFrom.get(),
				now,
				pausedSpoiler);
			p.setOpacity(progress);
			paintImageWithSpoiler(
				p,
				rect.translated(0, shiftTo),
				_animation->imageTo,
				_spoiler.get(),
				now,
				pausedSpoiler);
			p.setOpacity(1.);
		} else {
			paintImageWithSpoiler(
				p,
				rect,
				_image,
				_spoiler.get(),
				now,
				pausedSpoiler);
		}
	}
	if (!_animation || _animation->bodyAnimation == BodyAnimation::None) {
		if (_title.isEmpty()) {
			// "Loading..." state.
			p.setPen(st::historyComposeAreaFgService);
			_text.draw(p, {
				.position = {
					body.x(),
					body.y() + (body.height() - st::normalFont->height) / 2,
				},
				.outerWidth = width,
				.availableWidth = body.width(),
				.elisionLines = 1,
			});
		} else {
			p.setPen(_st.textFg);
			_text.draw(p, {
				.position = { body.x(), text.y() },
				.outerWidth = width,
				.availableWidth = body.width(),
				.palette = &_st.textPalette,
				.spoiler = Ui::Text::DefaultSpoilerCache(),
				.now = now,
				.pausedEmoji = paused || On(PowerSaving::kEmojiChat),
				.pausedSpoiler = pausedSpoiler,
				.elisionLines = 1,
			});
		}
	} else if (_animation->bodyAnimation == BodyAnimation::Text) {
		p.setOpacity(1. - progress);
		p.drawPixmap(
			body.x(),
			text.y() + shiftFrom,
			_animation->bodyOrTextFrom);
		p.setOpacity(progress);
		p.drawPixmap(body.x(), text.y() + shiftTo, _animation->bodyOrTextTo);
		p.setOpacity(1.);
	}
	if (!_animation || _animation->bodyAnimation != BodyAnimation::Full) {
		if (_animation && !_animation->titleSame.isNull()) {
			const auto factor = style::DevicePixelRatio();
			p.drawPixmap(body.x(), body.y(), _animation->titleSame);
			p.setOpacity(1. - progress);
			p.drawPixmap(
				body.x() + (_animation->titleSame.width() / factor),
				body.y() + shiftFrom,
				_animation->titleFrom);
			p.setOpacity(progress);
			p.drawPixmap(
				body.x() + (_animation->titleSame.width() / factor),
				body.y() + shiftTo,
				_animation->titleTo);
			p.setOpacity(1.);
		} else {
			p.setPen(_st.titleFg);
			_title.drawLeftElided(p, body.x(), body.y(), body.width(), width);
		}
	} else {
		p.setOpacity(1. - progress);
		p.drawPixmap(
			body.x(),
			body.y() + shiftFrom,
			_animation->bodyOrTextFrom);
		p.setOpacity(progress);
		p.drawPixmap(body.x(), body.y() + shiftTo, _animation->bodyOrTextTo);
		p.setOpacity(1.);
	}
}

auto MessageBar::countBarState(int index) const -> BarState {
	Expects(index >= 0 && index < _content.count);

	auto result = BarState();
	const auto line = st::msgReplyBarSize.width();
	const auto height = st::msgReplyBarSize.height();
	const auto count = _content.count;
	const auto shownCount = std::min(count, 4);
	const auto dividers = (shownCount - 1) * line;
	const auto size = float64(st::msgReplyBarSize.height() - dividers)
		/ shownCount;
	const auto fullHeight = count * size + (count - 1) * line;
	const auto topByIndex = [&](int index) {
		return index * (size + line);
	};
	result.scroll = (count < 5 || index < 2)
		? 0
		: (index >= count - 2)
		? (fullHeight - height)
		: (topByIndex(index) - (height - size) / 2);
	result.size = size;
	result.skip = line;
	result.offset = topByIndex(index);
	return result;
}

auto MessageBar::countBarState() const -> BarState {
	return countBarState(_content.index);
}

void MessageBar::ensureGradientsCreated(int size) {
	if (!_topBarGradient.isNull()) {
		return;
	}
	const auto rows = size * style::DevicePixelRatio() - 2;
	auto bottomMask = QImage(
		QSize(1, size) * style::DevicePixelRatio(),
		QImage::Format_ARGB32_Premultiplied);
	const auto step = ((1ULL << 24) - 1) / rows;
	const auto limit = step * rows;
	auto bits = bottomMask.bits();
	const auto perLine = bottomMask.bytesPerLine();
	for (auto counter = uint32(0); counter != limit; counter += step) {
		const auto value = (counter >> 16);
		memset(bits, int(value), perLine);
		bits += perLine;
	}
	memset(bits, 255, perLine * 2);
	auto bottom = style::colorizeImage(bottomMask, st::historyPinnedBg);
	bottom.setDevicePixelRatio(style::DevicePixelRatio());
	auto top = bottom.mirrored();
	_bottomBarGradient = Images::PixmapFast(std::move(bottom));
	_topBarGradient = Images::PixmapFast(std::move(top));
}

void MessageBar::paintImageWithSpoiler(
		QPainter &p,
		QRect rect,
		const QPixmap &image,
		SpoilerAnimation *spoiler,
		crl::time now,
		bool paused) const {
	p.drawPixmap(rect, image);
	if (spoiler) {
		const auto frame = DefaultImageSpoiler().frame(
			spoiler->index(now, paused));
		FillSpoilerRect(p, rect, frame);
	}
}

void MessageBar::paintLeftBar(Painter &p) {
	const auto state = countBarState();
	const auto gradientSize = int(std::ceil(state.size * 2.5));
	if (_content.count > 4) {
		ensureGradientsCreated(gradientSize);
	}

	const auto scroll = _animation
		? _animation->barScroll.value(state.scroll)
		: state.scroll;
	const auto offset = _animation
		? _animation->barTop.value(state.offset)
		: state.offset;
	const auto line = st::msgReplyBarSize.width();
	const auto height = st::msgReplyBarSize.height();
	const auto activeFrom = offset - scroll;
	const auto activeTill = activeFrom + state.size;
	const auto single = state.size + state.skip;

	const auto barSkip = st::msgReplyPadding.top() + st::msgReplyBarPos.y();
	const auto fullHeight = barSkip + height + barSkip;
	const auto bar = QRect(
		st::msgReplyBarSkip + st::msgReplyBarPos.x(),
		barSkip,
		line,
		state.size);
	const auto paintFromScroll = std::max(scroll - barSkip, 0.);
	const auto paintFrom = int(std::floor(paintFromScroll / single));
	const auto paintTillScroll = (scroll + height + barSkip);
	const auto paintTill = std::min(
		int(std::floor(paintTillScroll / single)) + 1,
		_content.count);

	p.setPen(Qt::NoPen);
	const auto activeBrush = QBrush(st::msgInReplyBarColor);
	const auto inactiveBrush = QBrush(QColor(
		st::msgInReplyBarColor->c.red(),
		st::msgInReplyBarColor->c.green(),
		st::msgInReplyBarColor->c.blue(),
		st::msgInReplyBarColor->c.alpha() / 3));
	const auto radius = line / 2.;
	auto hq = PainterHighQualityEnabler(p);
	p.setClipRect(bar.x(), 0, bar.width(), fullHeight);
	for (auto i = paintFrom; i != paintTill; ++i) {
		const auto top = i * single - scroll;
		const auto bottom = top + state.size;
		const auto active = (top == activeFrom);
		p.setBrush(active ? activeBrush : inactiveBrush);
		p.drawRoundedRect(bar.translated(0, top), radius, radius);
		if (active
			|| bottom - line <= activeFrom
			|| top + line >= activeTill) {
			continue;
		}
		const auto partFrom = std::max(top, activeFrom);
		const auto partTill = std::min(bottom, activeTill);
		p.setBrush(activeBrush);
		p.drawRoundedRect(
			QRect(bar.x(), bar.y() + partFrom, line, partTill - partFrom),
			radius,
			radius);
	}
	p.setClipping(false);
	if (_content.count > 4) {
		const auto firstScroll = countBarState(2).scroll;
		const auto gradientTop = (scroll >= firstScroll)
			? 0
			: anim::interpolate(-gradientSize, 0, scroll / firstScroll);
		const auto lastScroll = countBarState(_content.count - 3).scroll;
		const auto largestScroll = countBarState(_content.count - 1).scroll;
		const auto gradientBottom = (scroll <= lastScroll)
			? fullHeight
			: anim::interpolate(
				fullHeight,
				fullHeight + gradientSize,
				(scroll - lastScroll) / (largestScroll - lastScroll));
		if (gradientTop > -gradientSize) {
			p.drawPixmap(
				QRect(bar.x(), gradientTop, bar.width(), gradientSize),
				_topBarGradient);
		}
		if (gradientBottom < fullHeight + gradientSize) {
			p.drawPixmap(
				QRect(
					bar.x(),
					gradientBottom - gradientSize,
					bar.width(),
					gradientSize),
				_bottomBarGradient);
		}
	}
}

} // namespace Ui