tg_windows5.12.6/Telegram/SourceFiles/platform/mac/overlay_widget_mac.mm

/*
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 "platform/mac/overlay_widget_mac.h"

#include "base/object_ptr.h"
#include "ui/platform/ui_platform_window_title.h"
#include "ui/widgets/buttons.h"
#include "ui/widgets/rp_window.h"
#include "styles/style_media_view.h"

#include <QtGui/QWindow>
#include <Cocoa/Cocoa.h>

namespace Platform {
namespace {

using namespace Media::View;

} // namespace

struct MacOverlayWidgetHelper::Data {
	const not_null<Ui::RpWindow*> window;
	const Fn<void(bool)> maximize;
	object_ptr<Ui::AbstractButton> buttonClose = { nullptr };
	object_ptr<Ui::AbstractButton> buttonMinimize = { nullptr };
	object_ptr<Ui::AbstractButton> buttonMaximize = { nullptr };
	rpl::event_stream<> activations;
	rpl::variable<float64> masterOpacity = 1.;
	rpl::variable<bool> maximized = false;
	rpl::event_stream<> clearStateRequests;
	bool anyOver = false;
	NSWindow * __weak native = nil;
	rpl::variable<int> topNotchSkip;
};

MacOverlayWidgetHelper::MacOverlayWidgetHelper(
	not_null<Ui::RpWindow*> window,
	Fn<void(bool)> maximize)
: _data(std::make_unique<Data>(Data{
	.window = window,
	.maximize = std::move(maximize),
})) {
	_data->buttonClose = create(window, Control::Close);
	_data->buttonMinimize = create(window, Control::Minimize);
	_data->buttonMaximize = create(window, Control::Maximize);
}

MacOverlayWidgetHelper::~MacOverlayWidgetHelper() = default;

void MacOverlayWidgetHelper::activate(Control control) {
	const auto fullscreen = (_data->window->windowHandle()->flags() & Qt::FramelessWindowHint);
	switch (control) {
	case Control::Close: _data->window->close(); return;
	case Control::Minimize: [_data->native miniaturize:_data->native]; return;
	case Control::Maximize: _data->maximize(!fullscreen); return;
	}
}

void MacOverlayWidgetHelper::beforeShow(bool fullscreen) {
	_data->window->setAttribute(Qt::WA_MacAlwaysShowToolWindow, !fullscreen);
	_data->window->windowHandle()->setFlag(Qt::FramelessWindowHint, fullscreen);
	updateStyles(fullscreen);
	clearState();
}

void MacOverlayWidgetHelper::afterShow(bool fullscreen) {
	updateStyles(fullscreen);
	refreshButtons(fullscreen);
	_data->window->activateWindow();
}

void MacOverlayWidgetHelper::resolveNative() {
	if (const auto handle = _data->window->winId()) {
		_data->native = [reinterpret_cast<NSView*>(handle) window];
	}
}

void MacOverlayWidgetHelper::updateStyles(bool fullscreen) {
	_data->maximized = fullscreen;

	resolveNative();
	if (!_data->native) {
		return;
	}

	const auto window = _data->native;
	const auto level = !fullscreen
		? NSNormalWindowLevel
		: NSPopUpMenuWindowLevel;
	[window setLevel:level];
	[window setHidesOnDeactivate:!_data->window->testAttribute(Qt::WA_MacAlwaysShowToolWindow)];
	[window setTitleVisibility:NSWindowTitleHidden];
	[window setTitlebarAppearsTransparent:YES];
	[window setStyleMask:[window styleMask] | NSWindowStyleMaskFullSizeContentView];
	if (@available(macOS 12.0, *)) {
		_data->topNotchSkip = [[window screen] safeAreaInsets].top;
	}
}

void MacOverlayWidgetHelper::refreshButtons(bool fullscreen) {
	Expects(_data->native != nullptr);

	const auto window = _data->native;
	const auto process = [&](NSWindowButton type) {
		if (const auto button = [window standardWindowButton:type]) {
			[button setHidden:YES];
		}
	};
	process(NSWindowCloseButton);
	process(NSWindowMiniaturizeButton);
	process(NSWindowZoomButton);
	_data->buttonClose->moveToLeft(0, 0);
	_data->buttonClose->raise();
	_data->buttonClose->show();
	_data->buttonMinimize->moveToLeft(_data->buttonClose->width(), 0);
	_data->buttonMinimize->raise();
	_data->buttonMinimize->show();
	_data->buttonMaximize->moveToLeft(_data->buttonClose->width() + _data->buttonMinimize->width(), 0);
	_data->buttonMaximize->raise();
	_data->buttonMaximize->show();
}

void MacOverlayWidgetHelper::notifyFileDialogShown(bool shown) {
	resolveNative();
	if (_data->native && !_data->window->isHidden()) {
		const auto level = [_data->native level];
		if (level != NSNormalWindowLevel) {
			const auto level = shown
				? NSModalPanelWindowLevel
				: NSPopUpMenuWindowLevel;
			[_data->native setLevel:level];
		}
	}
}

void MacOverlayWidgetHelper::minimize(not_null<Ui::RpWindow*> window) {
	resolveNative();
	if (_data->native) {
		[_data->native miniaturize:_data->native];
	}
}

void MacOverlayWidgetHelper::clearState() {
	_data->clearStateRequests.fire({});
}

void MacOverlayWidgetHelper::setControlsOpacity(float64 opacity) {
	_data->masterOpacity = opacity;
}

rpl::producer<bool> MacOverlayWidgetHelper::controlsSideRightValue() {
	return rpl::single(false);
}

rpl::producer<int> MacOverlayWidgetHelper::topNotchSkipValue() {
	return _data->topNotchSkip.value();
}

object_ptr<Ui::AbstractButton> MacOverlayWidgetHelper::create(
		not_null<QWidget*> parent,
		Control control) {
	auto result = object_ptr<Ui::AbstractButton>(parent);
	const auto raw = result.data();

	raw->setClickedCallback([=] { activate(control); });

	struct State {
		Ui::Animations::Simple animation;
		float64 progress = -1.;
		QImage frame;
		bool maximized = false;
		bool anyOver = false;
		bool over = false;
	};
	const auto state = raw->lifetime().make_state<State>();

	rpl::merge(
		_data->masterOpacity.changes() | rpl::to_empty,
		_data->maximized.changes() | rpl::to_empty
	) | rpl::start_with_next([=] {
		raw->update();
	}, raw->lifetime());

	_data->clearStateRequests.events(
	) | rpl::start_with_next([=] {
		raw->clearState();
		raw->update();
		state->over = raw->isOver();
		_data->anyOver = false;
		state->animation.stop();
	}, raw->lifetime());

	struct Info {
		const style::icon *icon = nullptr;
		style::margins padding;
	};
	const auto info = [&]() -> Info {
		switch (control) {
		case Control::Minimize:
			return { &st::mediaviewTitleMinimizeMac, st::mediaviewTitleMinimizeMacPadding };
		case Control::Maximize:
			return { &st::mediaviewTitleMaximizeMac, st::mediaviewTitleMaximizeMacPadding };
		case Control::Close:
			return { &st::mediaviewTitleCloseMac, st::mediaviewTitleCloseMacPadding };
		}
		Unexpected("Value in DefaultOverlayWidgetHelper::Buttons::create.");
	}();
	const auto icon = info.icon;

	raw->resize(QRect(QPoint(), icon->size()).marginsAdded(info.padding).size());
	state->frame = QImage(
		icon->size() * style::DevicePixelRatio(),
		QImage::Format_ARGB32_Premultiplied);
	state->frame.setDevicePixelRatio(style::DevicePixelRatio());

	const auto updateOver = [=] {
		const auto over = raw->isOver();
		if (state->over == over) {
			return;
		}
		state->over = over;
		const auto anyOver = over
			|| _data->buttonClose->isOver()
			|| _data->buttonMinimize->isOver()
			|| _data->buttonMaximize->isOver();
		if (_data->anyOver != anyOver) {
			_data->anyOver = anyOver;
			_data->buttonClose->update();
			_data->buttonMinimize->update();
			_data->buttonMaximize->update();
		}
		state->animation.start(
			[=] { raw->update(); },
			state->over ? 0. : 1.,
			state->over ? 1. : 0.,
			st::mediaviewFadeDuration);
	};

	const auto prepareFrame = [=] {
		const auto progress = state->animation.value(state->over ? 1. : 0.);
		const auto maximized = _data->maximized.current();
		const auto anyOver = _data->anyOver;
		if (state->progress == progress
			&& state->maximized == maximized
			&& state->anyOver == anyOver) {
			return;
		}
		state->progress = progress;
		state->maximized = maximized;
		state->anyOver = anyOver;
		auto current = icon;
		if (control == Control::Maximize) {
			current = maximized ? &st::mediaviewTitleRestoreMac : icon;
		}
		state->frame.fill(Qt::transparent);

		auto q = QPainter(&state->frame);
		const auto normal = maximized
			? kMaximizedIconOpacity
			: kNormalIconOpacity;
		q.setOpacity(progress + (1 - progress) * normal);
		st::mediaviewTitleButtonMac.paint(q, 0, 0, raw->width());
		if (anyOver) {
			q.setOpacity(1.);
			current->paint(q, 0, 0, raw->width());
		}
		q.end();
	};

	raw->paintRequest(
	) | rpl::start_with_next([=, padding = info.padding] {
		updateOver();
		prepareFrame();

		auto p = QPainter(raw);
		p.setOpacity(_data->masterOpacity.current());
		p.drawImage(padding.left(), padding.top(), state->frame);
	}, raw->lifetime());

	return result;
}

std::unique_ptr<OverlayWidgetHelper> CreateOverlayWidgetHelper(
		not_null<Ui::RpWindow*> window,
		Fn<void(bool)> maximize) {
	return std::make_unique<MacOverlayWidgetHelper>(
		window,
		std::move(maximize));
}

} // namespace Platform