init

Telegram/SourceFiles/calls/group/calls_group_viewport_tile.cpp

@@ -0,0 +1,278 @@
+/*
+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 "calls/group/calls_group_viewport_tile.h"
+
+#include "calls/group/calls_group_members_row.h"
+#include "webrtc/webrtc_video_track.h"
+#include "lang/lang_keys.h"
+#include "ui/round_rect.h"
+#include "ui/painter.h"
+#include "ui/effects/cross_line.h"
+#include "styles/style_calls.h"
+
+#include <QtGui/QOpenGLFunctions>
+
+namespace Calls::Group {
+namespace {
+
+constexpr auto kPausedVideoSize = 90;
+
+} // namespace
+
+Viewport::VideoTile::VideoTile(
+	const VideoEndpoint &endpoint,
+	VideoTileTrack track,
+	rpl::producer<QSize> trackSize,
+	rpl::producer<bool> pinned,
+	Fn<void()> update,
+	bool self)
+: _endpoint(endpoint)
+, _update(std::move(update))
+, _track(std::move(track))
+, _peer(_track.row->peer())
+, _trackSize(std::move(trackSize))
+, _rtmp(endpoint.rtmp())
+, _self(self) {
+	Expects(_track.track != nullptr);
+
+	using namespace rpl::mappers;
+	_track.track->stateValue(
+	) | rpl::filter(
+		_1 == Webrtc::VideoState::Paused
+	) | rpl::take(1) | rpl::on_next([=] {
+		_wasPaused = true;
+	}, _lifetime);
+
+	setup(std::move(pinned));
+}
+
+bool Viewport::VideoTile::mirror() const {
+	return _self && (_endpoint.type == VideoEndpointType::Camera);
+}
+
+QRect Viewport::VideoTile::pinOuter() const {
+	return _pinOuter;
+}
+
+QRect Viewport::VideoTile::pinInner() const {
+	return _pinInner.translated(0, -topControlsSlide());
+}
+
+QRect Viewport::VideoTile::backOuter() const {
+	return _backOuter;
+}
+
+QRect Viewport::VideoTile::backInner() const {
+	return _backInner.translated(0, -topControlsSlide());
+}
+
+int Viewport::VideoTile::topControlsSlide() const {
+	return anim::interpolate(
+		st::groupCallVideoTile.pinPosition.y() + _pinInner.height(),
+		0,
+		_topControlsShownAnimation.value(_topControlsShown ? 1. : 0.));
+}
+
+QSize Viewport::VideoTile::PausedVideoSize() {
+	return QSize(kPausedVideoSize, kPausedVideoSize);
+}
+
+QSize Viewport::VideoTile::trackOrUserpicSize() const {
+	if (const auto size = trackSize(); !size.isEmpty()) {
+		return size;
+	}
+	return _wasPaused ? PausedVideoSize() : QSize();
+}
+
+bool Viewport::VideoTile::screencast() const {
+	return (_endpoint.type == VideoEndpointType::Screen);
+}
+
+void Viewport::VideoTile::setGeometry(
+		QRect geometry,
+		TileAnimation animation) {
+	_hidden = false;
+	_geometry = geometry;
+	_animation = animation;
+	updateTopControlsPosition();
+}
+
+void Viewport::VideoTile::hide() {
+	_hidden = true;
+	_quality = std::nullopt;
+}
+
+void Viewport::VideoTile::toggleTopControlsShown(bool shown) {
+	if (_topControlsShown == shown) {
+		return;
+	}
+	_topControlsShown = shown;
+	_topControlsShownAnimation.start(
+		_update,
+		shown ? 0. : 1.,
+		shown ? 1. : 0.,
+		st::slideWrapDuration);
+}
+
+bool Viewport::VideoTile::updateRequestedQuality(VideoQuality quality) {
+	if (_hidden) {
+		_quality = std::nullopt;
+		return false;
+	} else if (_quality && *_quality == quality) {
+		return false;
+	}
+	_quality = quality;
+	return true;
+}
+
+QSize Viewport::VideoTile::PinInnerSize(bool pinned) {
+	const auto &st = st::groupCallVideoTile;
+	const auto &icon = st::groupCallVideoTile.pin.icon;
+	const auto innerWidth = icon.width()
+		+ st.pinTextPosition.x()
+		+ st::semiboldFont->width(pinned
+			? tr::lng_pinned_unpin(tr::now)
+			: tr::lng_pinned_pin(tr::now));
+	const auto innerHeight = icon.height();
+	const auto buttonWidth = st.pinPadding.left()
+		+ innerWidth
+		+ st.pinPadding.right();
+	const auto buttonHeight = st.pinPadding.top()
+		+ innerHeight
+		+ st.pinPadding.bottom();
+	return { buttonWidth, buttonHeight };
+}
+
+void Viewport::VideoTile::PaintPinButton(
+		Painter &p,
+		bool pinned,
+		int x,
+		int y,
+		int outerWidth,
+		not_null<Ui::RoundRect*> background,
+		not_null<Ui::CrossLineAnimation*> icon) {
+	const auto &st = st::groupCallVideoTile;
+	const auto rect = QRect(QPoint(x, y), PinInnerSize(pinned));
+	background->paint(p, rect);
+	icon->paint(
+		p,
+		rect.marginsRemoved(st.pinPadding).topLeft(),
+		pinned ? 1. : 0.);
+	p.setPen(st::groupCallVideoTextFg);
+	p.setFont(st::semiboldFont);
+	p.drawTextLeft(
+		(x
+			+ st.pinPadding.left()
+			+ st::groupCallVideoTile.pin.icon.width()
+			+ st.pinTextPosition.x()),
+		(y
+			+ st.pinPadding.top()
+			+ st.pinTextPosition.y()),
+		outerWidth,
+		(pinned
+			? tr::lng_pinned_unpin(tr::now)
+			: tr::lng_pinned_pin(tr::now)));
+
+}
+
+QSize Viewport::VideoTile::BackInnerSize() {
+	const auto &st = st::groupCallVideoTile;
+	const auto &icon = st::groupCallVideoTile.back;
+	const auto innerWidth = icon.width()
+		+ st.pinTextPosition.x()
+		+ st::semiboldFont->width(tr::lng_create_group_back(tr::now));
+	const auto innerHeight = icon.height();
+	const auto buttonWidth = st.pinPadding.left()
+		+ innerWidth
+		+ st.pinPadding.right();
+	const auto buttonHeight = st.pinPadding.top()
+		+ innerHeight
+		+ st.pinPadding.bottom();
+	return { buttonWidth, buttonHeight };
+}
+
+void Viewport::VideoTile::PaintBackButton(
+		Painter &p,
+		int x,
+		int y,
+		int outerWidth,
+		not_null<Ui::RoundRect*> background) {
+	const auto &st = st::groupCallVideoTile;
+	const auto rect = QRect(QPoint(x, y), BackInnerSize());
+	background->paint(p, rect);
+	st.back.paint(
+		p,
+		rect.marginsRemoved(st.pinPadding).topLeft(),
+		outerWidth);
+	p.setPen(st::groupCallVideoTextFg);
+	p.setFont(st::semiboldFont);
+	p.drawTextLeft(
+		(x
+			+ st.pinPadding.left()
+			+ st::groupCallVideoTile.pin.icon.width()
+			+ st.pinTextPosition.x()),
+		(y
+			+ st.pinPadding.top()
+			+ st.pinTextPosition.y()),
+		outerWidth,
+		tr::lng_create_group_back(tr::now));
+}
+
+void Viewport::VideoTile::updateTopControlsSize() {
+	const auto &st = st::groupCallVideoTile;
+
+	const auto pinSize = PinInnerSize(_pinned);
+	const auto pinWidth = st.pinPosition.x() * 2 + pinSize.width();
+	const auto pinHeight = st.pinPosition.y() * 2 + pinSize.height();
+	_pinInner = QRect(QPoint(), pinSize);
+	_pinOuter = QRect(0, 0, pinWidth, pinHeight);
+
+	const auto backSize = BackInnerSize();
+	const auto backWidth = st.pinPosition.x() * 2 + backSize.width();
+	const auto backHeight = st.pinPosition.y() * 2 + backSize.height();
+	_backInner = QRect(QPoint(), backSize);
+	_backOuter = QRect(0, 0, backWidth, backHeight);
+}
+
+void Viewport::VideoTile::updateTopControlsPosition() {
+	const auto &st = st::groupCallVideoTile;
+
+	_pinInner = QRect(
+		_geometry.width() - st.pinPosition.x() - _pinInner.width(),
+		st.pinPosition.y(),
+		_pinInner.width(),
+		_pinInner.height());
+	_pinOuter = QRect(
+		_geometry.width() - _pinOuter.width(),
+		0,
+		_pinOuter.width(),
+		_pinOuter.height());
+	_backInner = QRect(st.pinPosition, _backInner.size());
+}
+
+void Viewport::VideoTile::setup(rpl::producer<bool> pinned) {
+	std::move(
+		pinned
+	) | rpl::filter([=](bool pinned) {
+		return (_pinned != pinned);
+	}) | rpl::on_next([=](bool pinned) {
+		_pinned = pinned;
+		updateTopControlsSize();
+		if (!_hidden) {
+			updateTopControlsPosition();
+			_update();
+		}
+	}, _lifetime);
+
+	_track.track->renderNextFrame(
+	) | rpl::on_next(_update, _lifetime);
+
+	updateTopControlsSize();
+}
+
+} // namespace Calls::Group