KisCanvasNavigationActionStrategyTouch Class Reference

#include <KisCanvasNavigationActionStrategyTouch.h>

Inheritance diagram for KisCanvasNavigationActionStrategyTouch:

Public Member Functions
void	inputEvent (QEvent *event) override
	KisCanvasNavigationActionStrategyTouch (Flags flags, const QTouchEvent *startEvent, KisCanvas2 *canvas)
bool	supportsEvent (QEvent *event) const override
Public Member Functions inherited from KisCanvasNavigationActionStrategy
Flags	flags () const
	KisCanvasNavigationActionStrategy (const Flags &flags)
virtual	~KisCanvasNavigationActionStrategy ()=default

Private Attributes
KoViewTransformStillPoint	m_actionStillPoint
KisCanvas2 *	m_canvas
qreal	m_lastDistance {0.0}
qreal	m_nonRoundedZoom {0.0}
SnappedRotationData	m_rotationData

Additional Inherited Members
Public Types inherited from KisCanvasNavigationActionStrategy
enum	Flag {   None = 0x0 , PanEnabled = 0x1 , ZoomEnabled = 0x2 , RotationEnabled = 0x4 ,   ZoomDescrete = 0x8 , RotationDescrete = 0x10 }
Static Public Member Functions inherited from KisCanvasNavigationActionStrategy
static qreal	canvasRotationAngleContinuous (qreal currentRotationOffset, qreal currectCanvasRotation, SnappedRotationData &data)
static qreal	canvasRotationAngleDescrete (qreal currentRotationOffset, SnappedRotationData &data)

Detailed Description

Definition at line 20 of file KisCanvasNavigationActionStrategyTouch.h.

Constructor & Destructor Documentation

KisCanvasNavigationActionStrategyTouch()

KisCanvasNavigationActionStrategyTouch::KisCanvasNavigationActionStrategyTouch	(	Flags	flags,
		const QTouchEvent *	startEvent,
		KisCanvas2 *	canvas )

Definition at line 70 of file KisCanvasNavigationActionStrategyTouch.cpp.

    : KisCanvasNavigationActionStrategy(flags)
    , m_canvas(canvas)
{
    m_actionStillPoint = canvas->coordinatesConverter()->makeWidgetStillPoint(
        calculateBasePointFromEvent(startEvent));
    m_nonRoundedZoom = canvas->viewConverter()->zoom();
}

References KisCanvas2::coordinatesConverter, m_actionStillPoint, m_nonRoundedZoom, KisCoordinatesConverter::makeWidgetStillPoint(), KisCanvas2::viewConverter(), and KoViewConverter::zoom().

Member Function Documentation

inputEvent()

void KisCanvasNavigationActionStrategyTouch::inputEvent ( QEvent * event )

overridevirtual

Zoom and Rotate actions will perform pan as part of the post-action recentering stage, so we should track if we really need to perform a separate pan action.

Implements KisCanvasNavigationActionStrategy.

Definition at line 87 of file KisCanvasNavigationActionStrategyTouch.cpp.

{
    if (event->type() != QEvent::TouchUpdate) return;
 
    QTouchEvent *tevent = dynamic_cast<QTouchEvent *>(event);
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
    auto points = tevent->touchPoints();
#else
    auto points = tevent->points();
#endif
 
    auto point0_it = std::find_if(points.begin(), points.end(), &testIfPointPressed);
    if (point0_it == points.end())
        return;
 
    auto point1_it = std::find_if(std::next(point0_it), points.end(), &testIfPointPressed);
    if (point1_it == points.end()) {
        if (flags() & (ZoomEnabled | RotationEnabled)) {
            return;
        } else {
            // we are doing pan-only, this action can be connected to
            // a single-finger gesture
            point1_it = point0_it;
        }
    }
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
    const QPointF p0 = point0_it->pos();
    const QPointF p1 = point1_it->pos();
#else
    const QPointF p0 = point0_it->position();
    const QPointF p1 = point1_it->position();
#endif
 
    const QPointF slope = p1 - p0;
 
    KisCanvasController *controller = static_cast<KisCanvasController *>(m_canvas->canvasController());
 
    KoViewTransformStillPoint adjustedStillPoint = m_actionStillPoint;
 
    bool needsSeparatePanAction = true;
 
    if (flags().testFlag(PanEnabled)) {
        adjustedStillPoint.second = calculateBasePointFromEvent(tevent);
    }
 
    if (flags().testFlag(ZoomEnabled)) {
        const qreal dist = KisAlgebra2D::norm(slope);
 
        qreal scaleDelta = qFuzzyIsNull(m_lastDistance) ? 1.0 : dist / m_lastDistance;
 
        // Make sure none of the TouchPoints are too close together, which
        // throws off the zoom calculations. This also addresses a glitch
        // where a newly pressed TouchPoint can incorrectly report another
        // existing TouchPoint's coordinates instead of its own.
 
        if (dist < 10) {
            scaleDelta = 1.0;
        }
 
        // Workaround: only apply the zoom delta if it's not too
        // outlandish. TouchPoint coordinates are not always 100% reliable.
 
        if (qAbs(scaleDelta) < 0.8 || qAbs(scaleDelta) > 1.2) {
            // just skip the current zoom step
            scaleDelta = 1.0;
        }
 
        const qreal newNonRoundedZoom = m_nonRoundedZoom * scaleDelta;
 
        if (flags().testFlag(ZoomDescrete)) {
            const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
            if (scaleDelta > 1.0) {
                const qreal nextExpectedZoom =
                    converter->findNextZoom(converter->zoom(), converter->standardZoomLevels());
                if (newNonRoundedZoom >= nextExpectedZoom) {
                    controller->setZoom(KoZoomMode::ZOOM_CONSTANT, nextExpectedZoom, adjustedStillPoint);
                    needsSeparatePanAction = false;
                }
            } else if (scaleDelta < 1.0) {
                const qreal prevExpectedZoom =
                    converter->findPrevZoom(converter->zoom(), converter->standardZoomLevels());
                if (newNonRoundedZoom <= prevExpectedZoom) {
                    controller->setZoom(KoZoomMode::ZOOM_CONSTANT, prevExpectedZoom, adjustedStillPoint);
                    needsSeparatePanAction = false;
                }
            }
 
        } else {
            controller->setZoom(KoZoomMode::ZOOM_CONSTANT, newNonRoundedZoom, adjustedStillPoint);
            needsSeparatePanAction = false;
        }
 
        m_lastDistance = dist;
        m_nonRoundedZoom = newNonRoundedZoom;
    }
 
    if (flags().testFlag(RotationEnabled)) {
        const qreal currentAngle = std::atan2(slope.y(), slope.x());
        qreal rotationAngle = 0.0;
 
        if (flags().testFlag(RotationDescrete)) {
            rotationAngle = canvasRotationAngleDescrete(currentAngle, m_rotationData);
        } else {
            KisCanvasController *controller = static_cast<KisCanvasController *>(m_canvas->canvasController());
            rotationAngle = canvasRotationAngleContinuous(currentAngle, controller->rotation(), m_rotationData);
        }
 
        if (!qFuzzyIsNull(rotationAngle)) {
            controller->rotateCanvas(rotationAngle, adjustedStillPoint);
            needsSeparatePanAction = false;
        }
    }
 
    if (needsSeparatePanAction) {
        const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
        const QPointF currentStillPointViewPosition = converter->documentToWidget(m_actionStillPoint.docPoint());
        const QPoint canvasOffset((adjustedStillPoint.viewPoint() - currentStillPointViewPosition).toPoint());
        controller->pan(-canvasOffset);
    }
}

References KoCanvasBase::canvasController(), KisCanvasNavigationActionStrategy::canvasRotationAngleContinuous(), KisCanvasNavigationActionStrategy::canvasRotationAngleDescrete(), KisCanvas2::coordinatesConverter, KoViewTransformStillPoint::docPoint(), KisCoordinatesConverter::documentToWidget(), KisCoordinatesConverter::findNextZoom(), KisCoordinatesConverter::findPrevZoom(), KisCanvasNavigationActionStrategy::flags(), m_actionStillPoint, m_canvas, m_lastDistance, m_nonRoundedZoom, m_rotationData, KisAlgebra2D::norm(), p0, p1, KoCanvasControllerWidget::pan(), KisCanvasNavigationActionStrategy::PanEnabled, qFuzzyIsNull(), KisCanvasController::rotateCanvas(), KisCanvasController::rotation(), KisCanvasNavigationActionStrategy::RotationDescrete, KisCanvasNavigationActionStrategy::RotationEnabled, KoCanvasControllerWidget::setZoom(), KisCoordinatesConverter::standardZoomLevels(), KoViewTransformStillPoint::viewPoint(), KoZoomHandler::zoom(), KoZoomMode::ZOOM_CONSTANT, KisCanvasNavigationActionStrategy::ZoomDescrete, and KisCanvasNavigationActionStrategy::ZoomEnabled.

supportsEvent()

bool KisCanvasNavigationActionStrategyTouch::supportsEvent ( QEvent * event ) const

overridevirtual

Implements KisCanvasNavigationActionStrategy.

Definition at line 81 of file KisCanvasNavigationActionStrategyTouch.cpp.

{
    return event->type() == QEvent::TouchBegin || event->type() == QEvent::TouchUpdate
        || event->type() == QEvent::TouchEnd;
}

Member Data Documentation

m_actionStillPoint

KoViewTransformStillPoint KisCanvasNavigationActionStrategyTouch::m_actionStillPoint

private

Definition at line 32 of file KisCanvasNavigationActionStrategyTouch.h.

m_canvas

KisCanvas2* KisCanvasNavigationActionStrategyTouch::m_canvas

private

Definition at line 29 of file KisCanvasNavigationActionStrategyTouch.h.

m_lastDistance

qreal KisCanvasNavigationActionStrategyTouch::m_lastDistance {0.0}

private

Definition at line 35 of file KisCanvasNavigationActionStrategyTouch.h.

{0.0};

m_nonRoundedZoom

qreal KisCanvasNavigationActionStrategyTouch::m_nonRoundedZoom {0.0}

private

Definition at line 31 of file KisCanvasNavigationActionStrategyTouch.h.

{0.0};

m_rotationData

SnappedRotationData KisCanvasNavigationActionStrategyTouch::m_rotationData

private

Definition at line 34 of file KisCanvasNavigationActionStrategyTouch.h.

---

The documentation for this class was generated from the following files:

• libs/ui/input/KisCanvasNavigationActionStrategyTouch.h
• libs/ui/input/KisCanvasNavigationActionStrategyTouch.cpp