p53209761
/
qt5-ukui-platformtheme
forked from openkylin/qt5-ukui-platformtheme
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
qt5-ukui-platformtheme/ukui-styles/gesture-helper.cpp

372 lines
13 KiB
C++
Raw Blame History

/*
* Qt5-UKUI's Library
*
* Copyright (C) 2023, KylinSoft Co., Ltd.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this library. If not, see <https://www.gnu.org/licenses/>.
*
* Authors: Yue Lan <lanyue@kylinos.cn>
*
*/
#include "gesture-helper.h"
#include "ukui-two-finger-slide-gesture.h"
#include "ukui-two-finger-zoom-gesture.h"
#include <QWidget>
#include <QGestureEvent>
#include <QTapAndHoldGesture>
#include <QContextMenuEvent>
#include <QApplication>
#include <QMenu>
#include <QTouchEvent>
#include <QScroller>
#include <QMouseEvent>
#include <QAbstractItemView>
#include <QItemSelectionModel>
#include <QScroller>
#include <QWheelEvent>
#include <QtMath>
#include <QDebug>
GestureHelper::GestureHelper(QObject *parent) : QObject(parent)
{
// we translate event by ourselves
qApp->setAttribute(Qt::AA_SynthesizeTouchForUnhandledMouseEvents, false);
//qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, false);
m_menu_popped_timer.setInterval(500);
m_menu_popped_timer.setSingleShot(true);
m_pinch_operation_delayer.setInterval(200);
m_pinch_operation_delayer.setSingleShot(true);
m_slider = new UKUI::TwoFingerSlideGestureRecognizer;
m_zoomer = new UKUI::TwoFingerZoomGestureRecognizer;
m_slide_type = QGestureRecognizer::registerRecognizer(m_slider);
m_zoom_type = QGestureRecognizer::registerRecognizer(m_zoomer);
}
GestureHelper::~GestureHelper()
{
QGestureRecognizer::unregisterRecognizer(m_slide_type);
QGestureRecognizer::unregisterRecognizer(m_zoom_type);
}
void GestureHelper::registerWidget(QWidget *widget)
{
if (!widget)
return;
if (widget->contextMenuPolicy() == Qt::NoContextMenu)
return;
//widget->setAttribute(Qt::WA_AcceptTouchEvents, false);
widget->removeEventFilter(this);
//widget->grabGesture(Qt::TapGesture);
widget->grabGesture(Qt::TapAndHoldGesture);
//widget->grabGesture(Qt::PanGesture);
//widget->grabGesture(Qt::PinchGesture);
//widget->grabGesture(Qt::SwipeGesture);
//widget->grabGesture(m_slide_type);
//widget->grabGesture(m_zoom_type);
widget->installEventFilter(this);
}
void GestureHelper::unregisterWidget(QWidget *widget)
{
if (!widget)
return;
if (widget->contextMenuPolicy() == Qt::NoContextMenu)
return;
//widget->setAttribute(Qt::WA_AcceptTouchEvents, true);
widget->removeEventFilter(this);
//widget->ungrabGesture(Qt::TapGesture);
widget->ungrabGesture(Qt::TapAndHoldGesture);
//widget->ungrabGesture(Qt::PanGesture);
//widget->ungrabGesture(Qt::PinchGesture);
//widget->ungrabGesture(Qt::SwipeGesture);
//widget->ungrabGesture(m_slide_type);
//widget->ungrabGesture(m_zoom_type);
}
bool GestureHelper::eventFilter(QObject *watched, QEvent *event)
{
switch (event->type()) {
case QEvent::ActivationChange: {
// do not grab inactive window's gesture.
auto widget = qobject_cast<QWidget *>(watched);
if (widget->isActiveWindow()) {
widget->grabGesture(Qt::TapAndHoldGesture);
} else {
widget->ungrabGesture(Qt::TapAndHoldGesture);
}
return false;
}
case QEvent::TouchBegin: {
m_is_touching = true;
auto te = static_cast<QTouchEvent *>(event);
m_touch_points = te->touchPoints();
m_finger_count = te->touchPoints().count();
if (m_finger_count == 1)
m_hold_and_tap_pos = te->touchPoints().first().pos();
else
m_hold_and_tap_pos = QPointF();
if (m_touch_points.count() > 2) {
m_menu_popped_timer.stop();
}
break;
}
case QEvent::TouchUpdate: {
auto te = static_cast<QTouchEvent *>(event);
m_touch_points = te->touchPoints();
m_finger_count = te->touchPoints().count();
break;
}
case QEvent::TouchCancel:
case QEvent::TouchEnd: {
m_touch_points.clear();
m_is_touching = false;
m_finger_count = 0;
break;
}
case QEvent::Gesture: {
auto e = static_cast<QGestureEvent *>(event);
auto widget = qobject_cast<QWidget *>(watched);
if (!widget->isActiveWindow())
return false;
if (auto twoFingerSlideGesture = static_cast<UKUI::TwoFingerSlideGesture *>(e->gesture(m_slide_type))) {
//qDebug()<<"has slide gesture";
//qDebug()<<"slide"<<twoFingerSlideGesture->state()<<twoFingerSlideGesture->direction()<<twoFingerSlideGesture->totalDelta();
if (twoFingerSlideGesture->state() == Qt::GestureUpdated) {
// some view doesn't have scroller but also can scroll, such as process list view in ukui-system-monitor.
// we send the wheel event to trigger the scroll when slide gesture updated.
if (!QScroller::hasScroller(widget)) {
bool isHorizal = twoFingerSlideGesture->direction() == UKUI::TwoFingerSlideGesture::Horizal;
bool isVertical = twoFingerSlideGesture->direction() == UKUI::TwoFingerSlideGesture::Vertical;
if (isVertical) {
QWheelEvent we(twoFingerSlideGesture->hotSpot(), twoFingerSlideGesture->delta() * 10, Qt::NoButton, Qt::NoModifier, Qt::Vertical);
qApp->sendEvent(widget, &we);
} else if (isHorizal) {
QWheelEvent we(twoFingerSlideGesture->hotSpot(), twoFingerSlideGesture->delta() * 10, Qt::NoButton, Qt::NoModifier, Qt::Horizontal);
qApp->sendEvent(widget, &we);
}
}
}
}
if (auto twoFingerZoomGesture = static_cast<UKUI::TwoFingerZoomGesture *>(e->gesture(m_zoom_type))) {
//qDebug()<<"has zoom gesture"<<twoFingerZoomGesture->state()<<twoFingerZoomGesture->zoomDirection()<<twoFingerZoomGesture->startPoints()<<twoFingerZoomGesture->lastPoints()<<twoFingerZoomGesture->currentPoints();
switch (twoFingerZoomGesture->zoomDirection()) {
case UKUI::TwoFingerZoomGesture::ZoomIn: {
QWheelEvent we(twoFingerZoomGesture->hotSpot(), 100, Qt::NoButton, Qt::ControlModifier);
qApp->sendEvent(watched, &we);
break;
}
case UKUI::TwoFingerZoomGesture::ZoomOut: {
QWheelEvent we(twoFingerZoomGesture->hotSpot(), -100, Qt::NoButton, Qt::ControlModifier);
qApp->sendEvent(watched, &we);
break;
}
default:
break;
}
}
if (auto tapGesture = static_cast<QTapGesture *>(e->gesture(Qt::TapGesture))) {
//qDebug()<<tapGesture->gestureType()<<tapGesture->position()<<tapGesture->state();
switch (tapGesture->state()) {
case Qt::GestureStarted:
//mouse press event
break;
case Qt::GestureCanceled:
case Qt::GestureFinished: {
//mouse release event
break;
}
default:
break;
}
}
if (auto tapAndHoldGesture = static_cast<QTapAndHoldGesture*>(e->gesture(Qt::TapAndHoldGesture))) {
//qDebug()<<tapAndHoldGesture->gestureType()<<tapAndHoldGesture->position()<<tapAndHoldGesture->state();
if (m_menu_popped_timer.isActive())
return false;
m_hold_and_tap_pos = QPoint();
// check if there is a menu popped.
// note that the right click in a widget which has context menu
// will trigger the tap and hold gesture. I have no idea to deal
// with this case, because i didn't find how to recognize if this
// event is translated from mouse event.
if (qobject_cast<QMenu *>(watched) || qobject_cast<QMenu *>(qApp->activePopupWidget())) {
qDebug()<<"menu popped, may be right click";
m_menu_popped = true;
}
switch (tapAndHoldGesture->state()) {
case Qt::GestureStarted: {
if (m_menu_popped || m_is_mouse_pressed) {
return false;
} else {
m_menu_popped = true;
m_menu_popped_timer.start();
auto pos = widget->mapFromGlobal(tapAndHoldGesture->position().toPoint());
auto gpos = tapAndHoldGesture->position().toPoint();
if (m_is_native_mouse_move)
return false;
QMouseEvent me(QMouseEvent::MouseButtonRelease, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
qApp->sendEvent(widget, &me);
QContextMenuEvent ce(QContextMenuEvent::Other, pos, gpos, Qt::NoModifier);
qApp->sendEvent(widget, &ce);
}
break;
}
case Qt::GestureCanceled:
case Qt::GestureFinished: {
m_menu_popped = false;
break;
}
default:
break;
}
}
if (auto swipeGesture = static_cast<QSwipeGesture *>(e->gesture(Qt::SwipeGesture))) {
//qDebug()<<swipeGesture->gestureType()<<swipeGesture->state()<<swipeGesture->horizontalDirection()<<swipeGesture->verticalDirection()<<swipeGesture->swipeAngle();
}
if (auto panGesture = static_cast<QPanGesture*>(e->gesture(Qt::PanGesture))) {
//qDebug()<<panGesture->gestureType()<<panGesture->state()<<panGesture->delta()<<panGesture->hotSpot();
switch (panGesture->state()) {
case Qt::GestureStarted: {
auto widget = qobject_cast<QWidget *>(watched);
auto pos = widget->mapFromGlobal(QCursor::pos());
QMouseEvent me(QMouseEvent::MouseButtonRelease, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
qApp->sendEvent(widget, &me);
if (m_is_paning) {
return false;
} else {
m_is_paning = true;
}
break;
}
case Qt::GestureCanceled:
case Qt::GestureFinished: {
m_is_paning = false;
break;
}
default:
break;
}
return false;
}
break;
}
case QEvent::MouseMove: {
if (m_finger_count > 1)
return true;
QMouseEvent *me = static_cast<QMouseEvent *>(event);
auto widget = static_cast<QWidget *>(watched);
if (!widget)
return false;
//qDebug()<<me->type()<<me->pos();
bool isTranslatedFromTouch = me->source() == Qt::MouseEventSynthesizedByQt;
if (!isTranslatedFromTouch) {
// do not trigger tap and hold gesture handler
m_is_native_mouse_move = true;
return false;
}
m_is_native_mouse_move = false;
// if we do a hold and tap gesture, we should not trigger mouse move event.
// so we have to ignore the small offset of finger move.
auto lastTapPoint = m_hold_and_tap_pos.toPoint();
auto currentPoint = widget->mapTo(widget->topLevelWidget(), me->pos());
if (!lastTapPoint.isNull()) {
//qDebug()<<lastTapPoint<<currentPoint<<lenthSquared;
if (QRect(-50, -50, 100, 100).contains(lastTapPoint - currentPoint)) {
if (qobject_cast<QAbstractScrollArea *>(widget) || qobject_cast<QAbstractScrollArea *>(widget->parent()))
return true;
}
}
if (m_is_paning) {
return true;
}
return false;
}
case QEvent::DragEnter:
case QEvent::DragMove: {
if (m_is_paning)
return true;
}
case QEvent::MouseButtonPress: {
auto me = static_cast<QMouseEvent *>(event);
if (me->source() == Qt::MouseEventNotSynthesized)
m_is_mouse_pressed = true;
else
m_is_mouse_pressed = false;
break;
}
case QEvent::MouseButtonRelease: {
auto me = static_cast<QMouseEvent *>(event);
if (me->source() == Qt::MouseEventNotSynthesized)
m_is_mouse_pressed = false;
break;
}
default:
break;
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink