ZaStoGram_desktop/Telegram/SourceFiles/tgw/tgw_touch.cpp
John Preston e40b9ea80b Move widgets to widget-sandbox v0.1.3 with its TwidgetCore
Task: 2026/10/24/move-widgets-to-widget-sandbox-v0-1-3-and-give-vertical-touch-drags-to-the-chat
2026-11-05 17:12:55 +04:00

412 lines
9.7 KiB
C++

/*
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 "tgw/tgw_touch.h"
#include "base/platform/base_platform_info.h"
#include "history/view/media/history_view_html_widget.h"
#include "history/view/history_view_element.h"
#include "tgw/tgw_renderer.h"
#include "ui/click_handler.h"
#include <QtGui/QGuiApplication>
#include <QtGui/QStyleHints>
#include <chrono>
namespace Tgw {
namespace {
constexpr auto kMinHoldDelay = crl::time(1);
auto BridgeDepth = 0;
// WHY: the same steady_clock reading as TwidgetCore's arbiter, taken after
// the core's down, so a hold awarded here is due by the core's clock and
// RendererCore::fingerHold() delivers its contextmenu before any cancel.
[[nodiscard]] double Now() {
const auto now = std::chrono::steady_clock::now().time_since_epoch();
return std::chrono::duration<double, std::milli>(now).count();
}
[[nodiscard]] int Modifiers() {
return DomModifiers(QGuiApplication::keyboardModifiers());
}
[[nodiscard]] bool MenuOnRelease() {
#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
return (QGuiApplication::styleHints()->contextMenuTrigger()
== Qt::ContextMenuTrigger::Release);
#else // Qt >= 6.8.0
return Platform::IsWindows();
#endif // Qt < 6.8.0
}
} // namespace
TouchBridge::TouchBridge() {
++BridgeDepth;
}
TouchBridge::~TouchBridge() {
--BridgeDepth;
}
bool TouchBridge::Active() {
return (BridgeDepth > 0);
}
WidgetTouch::WidgetTouch(WidgetTouchArgs &&args)
: _list(args.list)
, _viewAt(std::move(args.viewAt))
, _mapToItem(std::move(args.mapToItem))
, _covered(std::move(args.covered))
, _menu(std::move(args.menu))
, _resetSpeed(std::move(args.resetSpeed))
, _dropTouch(std::move(args.dropTouch))
, _holdTimer([=] { hold(); }) {
}
WidgetTouch::~WidgetTouch() {
finish();
releaseMenu();
}
bool WidgetTouch::begin(QPoint global) {
finish();
const auto local = _list->mapFromGlobal(global);
const auto view = _viewAt(local);
const auto widget = view
? dynamic_cast<HistoryView::HtmlWidget*>(view->media())
: nullptr;
if (!widget || (_covered && _covered(local))) {
return false;
}
const auto at = _mapToItem(local, view) - view->mediaTopLeft();
const auto core = widget->touchCore(at);
const auto claim = core
? core->fingerPress(widget->cssPoint(at), Modifiers())
: std::nullopt;
if (!claim) {
return false;
}
_widget = base::make_weak(widget);
_core = base::make_weak(core);
_last = global;
_owner = Owner::Pending;
// WHY: TwidgetCore runs the same policy on its own clock. Starting this
// press after the core's and deciding later steps before forwarding
// keeps bubble cancellation ahead of the corresponding core input.
const auto lead = widget->gesturePoint(at);
_arbiter.down(Now(), lead.x(), lead.y(), *claim);
scheduleHold();
_resetSpeed();
return true;
}
std::optional<bool> WidgetTouch::update(QPoint global) {
if (_owner == Owner::None) {
return std::nullopt;
}
step(global);
return (_owner == Owner::Scroll);
}
std::optional<bool> WidgetTouch::end(QPoint global) {
if (_owner == Owner::None) {
return std::nullopt;
}
release(global);
const auto owner = _owner;
const auto widget = _widget.get();
const auto local = _list->mapFromGlobal(global);
const auto menu = (owner == Owner::Menu)
&& widget
&& (_viewAt(local) == widget->parent().get());
finish();
if (menu) {
auto e = QContextMenuEvent(QContextMenuEvent::Mouse, local, global);
_menu(&e);
}
return (owner == Owner::Scroll);
}
void WidgetTouch::cancel() {
if (_owner == Owner::None) {
return;
}
_arbiter.cancel();
finish();
}
void WidgetTouch::retire() {
if (_owner == Owner::None) {
return;
}
cancel();
_dropTouch();
_resetSpeed();
}
void WidgetTouch::mousePress(Qt::MouseButton button) {
if (button != Qt::RightButton) {
return;
} else if (_menuAhead) {
_menuAhead = false;
return;
}
decideMenu();
_menuPending = true;
}
bool WidgetTouch::mouseMenu(not_null<QContextMenuEvent*> e) {
if (e->reason() != QContextMenuEvent::Mouse) {
return false;
} else if (_menuPending) {
_menuPending = false;
return _menuTaken;
} else if (!(QGuiApplication::mouseButtons() & Qt::RightButton)) {
return false;
}
// WHY: on a press trigger the second press of a right double click
// reaches here before its double click event, which an opened menu
// may take instead, so this early decision expires if not consumed.
decideMenu();
_menuAhead = true;
crl::on_main(this, [=] {
_menuAhead = false;
});
return _menuTaken;
}
void WidgetTouch::mouseRelease(Qt::MouseButton button) {
if (button != Qt::RightButton) {
return;
}
_menuAhead = false;
if (!MenuOnRelease()) {
_menuPending = false;
}
releaseMenu();
}
Ui::Controls::SwipeHandoff WidgetTouch::swipeHandoff() {
const auto weak = base::make_weak(this);
return {
.owned = [=] {
const auto strong = weak.get();
return strong && (strong->_owner != Owner::None);
},
.swipe = [=](not_null<QTouchEvent*> e) {
const auto strong = weak.get();
return strong && strong->handoff(e);
},
.lost = [=] {
const auto strong = weak.get();
if (strong && (strong->_owner != Owner::None)) {
strong->lose();
}
},
};
}
bool WidgetTouch::handoff(not_null<QTouchEvent*> e) {
if (_owner == Owner::None) {
return false;
} else if (e->type() == QEvent::TouchCancel) {
lose();
return false;
}
const auto &points = e->touchPoints();
if (points.size() != 1
|| (e->type() != QEvent::TouchEnd
&& (int(points.front().state()) & int(Qt::TouchPointReleased)))) {
lose();
return false;
}
const auto global = points.front().screenPos().toPoint();
if (e->type() == QEvent::TouchEnd) {
release(global);
} else {
step(global);
}
return (_owner == Owner::Swipe);
}
RendererCore *WidgetTouch::held() const {
const auto core = _core.get();
return (core && core->fingerPressed()) ? core : nullptr;
}
QPoint WidgetTouch::mediaPoint(
not_null<HistoryView::HtmlWidget*> widget,
QPoint global) const {
const auto view = widget->parent();
return _mapToItem(_list->mapFromGlobal(global), view)
- view->mediaTopLeft();
}
void WidgetTouch::step(QPoint global) {
if (_released) {
return;
}
if (_owner == Owner::Menu) {
if (!_widget) {
lose();
}
return;
} else if (_owner != Owner::Pending && _owner != Owner::Widget) {
return;
}
const auto widget = _widget.get();
const auto core = held();
if (!widget || !core) {
lose();
return;
}
if (global == _last) {
return;
}
_last = global;
const auto at = mediaPoint(widget, global);
// A hold the widget won is still locked by its first move past the slop.
const auto lead = widget->gesturePoint(at);
const auto verdict = _arbiter.move(Now(), lead.x(), lead.y());
if (!verdict) {
lose();
return;
}
decide(*verdict);
if (_owner == Owner::Pending || _owner == Owner::Widget) {
core->fingerMove(widget->cssPoint(at), Modifiers());
}
}
void WidgetTouch::release(QPoint global) {
if (_released) {
return;
}
_released = true;
_holdTimer.cancel();
if (_owner != Owner::Pending && _owner != Owner::Widget) {
return;
}
const auto widget = _widget.get();
const auto core = held();
if (!widget || !core) {
lose();
return;
}
_last = global;
const auto at = mediaPoint(widget, global);
const auto lead = widget->gesturePoint(at);
const auto verdict = _arbiter.up(Now(), lead.x(), lead.y());
if (!verdict) {
lose();
} else if (verdict->owner == twidget::GestureOwner::Bubble) {
decide(*verdict);
} else {
_owner = Owner::Widget;
core->fingerRelease(widget->cssPoint(at), Modifiers());
}
}
void WidgetTouch::decide(const twidget::GestureVerdict &verdict) {
using Action = twidget::BubbleAction;
if (verdict.owner == twidget::GestureOwner::Pending) {
return;
}
_holdTimer.cancel();
if (verdict.owner == twidget::GestureOwner::Widget) {
_owner = Owner::Widget;
if (verdict.event == twidget::GestureEvent::ContextMenu) {
if (const auto core = held()) {
core->fingerHold();
}
}
return;
}
if (const auto core = held()) {
core->fingerCancel();
}
switch (verdict.action.value_or(Action::Menu)) {
case Action::Menu: _owner = Owner::Menu; break;
case Action::Swipe:
case Action::Back: _owner = Owner::Swipe; break;
case Action::Scroll: _owner = Owner::Scroll; break;
}
}
void WidgetTouch::scheduleHold() {
if (const auto deadline = _arbiter.holdDeadline()) {
_holdTimer.callOnce(std::max(
crl::time(std::ceil(*deadline - Now())),
kMinHoldDelay));
}
}
void WidgetTouch::hold() {
if (_owner != Owner::Pending) {
return;
} else if (!_widget || !held()) {
lose();
return;
}
const auto verdict = _arbiter.tick(Now());
if (!verdict) {
lose();
} else if (verdict->owner == twidget::GestureOwner::Pending) {
scheduleHold();
} else {
decide(*verdict);
}
}
void WidgetTouch::lose() {
_holdTimer.cancel();
_arbiter.cancel();
if (const auto core = held()) {
core->fingerCancel();
}
_owner = Owner::Lost;
}
void WidgetTouch::finish() {
_holdTimer.cancel();
if (const auto core = held()) {
core->fingerCancel();
}
if (_owner != Owner::None
&& !(_released && _owner == Owner::Widget)) {
_arbiter.cancel();
}
_widget = nullptr;
_core = nullptr;
_owner = Owner::None;
_released = false;
}
void WidgetTouch::decideMenu() {
releaseMenu();
const auto view = HistoryView::Element::HoveredLink();
const auto widget = view
? dynamic_cast<HistoryView::HtmlWidget*>(view->media())
: nullptr;
const auto core = widget
? widget->menuPress(ClickHandler::getActive())
: nullptr;
_menuCore = base::make_weak(core);
_menuTaken = (core != nullptr);
}
void WidgetTouch::releaseMenu() {
if (const auto core = base::take(_menuCore).get()) {
core->menuRelease(Modifiers());
}
}
} // namespace Tgw