# -*- coding: utf-8 -*-

#

# Licensed under the terms of the BSD 3-Clause

# (see plotpy/LICENSE for details)

# pylint: disable-msg=W0622,R0903

# W0622: complains about filter being a builtin

# R0903: complains about too few public methods which is the purpose here

"""

Event handling

--------------

Overview

^^^^^^^^

The :mod:`plotpy.events` module provides classes to handle events on a

:class:`plotpy.plot.PlotWidget`.

The following classes are available:

* :class:`.StatefulEventFilter`: stateful event filter

* :class:`.KeyEventMatch`: key event match

* :class:`.StandardKeyMatch`: standard key event match

* :class:`.MouseEventMatch`: mouse event match

* :class:`.GestureEventMatch`: gesture event match

* :class:`.DragHandler`: drag handler

* :class:`.ClickHandler`: click handler

* :class:`.PanHandler`: pan handler

* :class:`.ZoomHandler`: zoom handler

* :class:`.GestureHandler`: gesture handler

* :class:`.PinchPanGestureHandler`: pinch and pan gesture handler

* :class:`.MenuHandler`: menu handler

* :class:`.QtDragHandler`: Qt drag handler

* :class:`.AutoZoomHandler`: auto zoom handler

* :class:`.MoveHandler`: move handler

* :class:`.ObjectHandler`: object handler

* :class:`.RectangularSelectionHandler`: rectangular selection handler

* :class:`.PointSelectionHandler`: point selection handler

* :class:`.ZoomRectHandler`: zoom rectangle handler

Reference

^^^^^^^^^

.. autoclass:: StatefulEventFilter

:members:

.. autoclass:: KeyEventMatch

:members:

.. autoclass:: StandardKeyMatch

:members:

.. autoclass:: MouseEventMatch

:members:

.. autoclass:: GestureEventMatch

:members:

.. autoclass:: DragHandler

:members:

.. autoclass:: ClickHandler

:members:

.. autoclass:: PanHandler

:members:

.. autoclass:: ZoomHandler

:members:

.. autoclass:: GestureHandler

:members:

.. autoclass:: PinchPanGestureHandler

:members:

.. autoclass:: MenuHandler

:members:

.. autoclass:: QtDragHandler

:members:

.. autoclass:: AutoZoomHandler

:members:

.. autoclass:: MoveHandler

:members:

.. autoclass:: ObjectHandler

:members:

.. autoclass:: RectangularSelectionHandler

:members:

.. autoclass:: PointSelectionHandler

:members:

.. autoclass:: ZoomRectHandler

:members:

"""

from __future__ import annotations

import weakref

from typing import TYPE_CHECKING, Any, Callable

import numpy as np

from qtpy import QtCore as QC

from qtpy import QtGui as QG

from qtpy import QtWidgets as QW

from plotpy.config import CONF

from plotpy.constants import SHAPE_Z_OFFSET

from plotpy.coords import axes_to_canvas, canvas_to_axes

from plotpy.items import AnnotatedPolygon, Marker, PolygonShape

if TYPE_CHECKING:

from qtpy.QtCore import QPoint

from qtpy.QtGui import QMouseEvent

from plotpy.plot.base import BasePlot

def buttons_to_str(buttons: int) -> str:

"""Conversion of Qt flags to string

Args:

buttons: Qt flags (e.g. `Qt.LeftButton`, `Qt.RightButton`, etc.)

Returns:

Human readable string for the button flags

"""

string = ""

if buttons & QC.Qt.LeftButton:

string += "L"

if buttons & QC.Qt.MidButton: # Do not use QC.Qt.MouseButton.MidButton (Qt6!)

string += "M"

if buttons & QC.Qt.RightButton:

string += "R"

return string

def evt_type_to_str(type: int) -> str:

"""Convert event type to human readable string

Args:

type: event type

Returns:

Human readable string for the event type

"""

if type == QC.QEvent.MouseButtonPress:

return "Mpress"

elif type == QC.QEvent.MouseButtonRelease:

return "Mrelease"

elif type == QC.QEvent.MouseMove:

return "Mmove"

elif type == QC.QEvent.ContextMenu:

return "Context"

return f"{type:d}"

# MARK: Event handlers -----------------------------------------------------------------

class EventMatch:

"""A callable returning true if it matches an event"""

def __call__(self, event: QC.QEvent) -> bool:

"""Returns True if the event matches the event match

Args:

event: event to match

"""

raise NotImplementedError

def get_event_types(self) -> frozenset[int]:

"""Returns a set of event types handled by this

EventMatch.

This is used to quickly optimize events not handled by any event matchers

"""

return frozenset()

class KeyEventMatch(EventMatch):

"""

A callable returning True if it matches a key event

Args:

keys: list of keys or couples (key, modifier)

"""

def __init__(self, keys: list[int | tuple[int, int]]) -> None:

super().__init__()

key_list, mod_list = [], []

for item in keys:

if isinstance(item, (tuple, list)):

k, m = item

else:

k = item

# Avoid bad arguments: modifier instead of key

assert k not in (

QC.Qt.ControlModifier,

QC.Qt.ShiftModifier,

QC.Qt.AltModifier,

QC.Qt.NoModifier,

)

m = QC.Qt.NoModifier

key_list.append(k)

mod_list.append(m)

self.keys = key_list

self.mods = mod_list

def get_event_types(self) -> frozenset[int]:

"""Return the set of event types handled by this event match"""

return frozenset((QC.QEvent.KeyPress,))

def __call__(self, event: QG.QKeyEvent) -> bool:

"""Returns True if the event matches the event match

Args:

event: event to match

"""

if event.type() == QC.QEvent.KeyPress:

my_key = event.key()

my_mod = event.modifiers()

if my_key in self.keys:

mod = self.mods[self.keys.index(my_key)]

if mod == QC.Qt.NoModifier or my_mod & mod:

return True

return False

class StandardKeyMatch(EventMatch):

"""

A callable returning True if it matches a key event

Args:

keysequence: QKeySequence.StandardKey integer

"""

def __init__(self, keysequence: int) -> None:

super().__init__()

assert isinstance(keysequence, (int, QG.QKeySequence.StandardKey))

self.keyseq = keysequence

def get_event_types(self) -> frozenset[int]:

"""Return the set of event types handled by this event match"""

return frozenset((QC.QEvent.KeyPress,))

def __call__(self, event: QG.QKeyEvent) -> bool:

"""Returns True if the event matches the event match

Args:

event: event to match

"""

return event.type() == QC.QEvent.KeyPress and event.matches(self.keyseq)

class MouseEventMatch(EventMatch):

"""Base class for matching mouse events

Args:

evt_type: event type

btn: button to match

modifiers: keyboard modifiers to match

"""

def __init__(

self, evt_type: int, btn: int, modifiers: int = QC.Qt.NoModifier

) -> None:

super().__init__()

assert isinstance(modifiers, (int, QC.Qt.KeyboardModifier))

self.evt_type = evt_type

self.button = btn

self.modifiers = modifiers

def get_event_types(self) -> frozenset[int]:

"""Return the set of event types handled by this event match"""

return frozenset((self.evt_type,))

def __call__(self, event: QMouseEvent) -> bool:

"""Returns True if the event matches the event match

Args:

event: event to match

"""

if event.type() == self.evt_type:

if event.button() == self.button:

if self.modifiers != QC.Qt.NoModifier:

if (event.modifiers() & self.modifiers) == self.modifiers:

return True

elif event.modifiers() == QC.Qt.NoModifier:

return True

return False

def __repr__(self) -> str:

"""Return textual representation"""

return "<MouseMatch: {}/ {:08x}:{}>".format(

evt_type_to_str(self.evt_type), self.modifiers, buttons_to_str(self.button)

)

class MouseMoveMatch(MouseEventMatch):

def __call__(self, event: QMouseEvent) -> bool:

"""Returns True if the event matches the event match

Args:

event: event to match

"""

if event.type() == self.evt_type:

if (

self.button != QC.Qt.NoButton

and (event.buttons() & self.button == self.button)

) or event.buttons() == QC.Qt.NoButton:

if self.modifiers != QC.Qt.NoModifier:

if (event.modifiers() & self.modifiers) == self.modifiers:

return True

elif event.modifiers() == QC.Qt.NoModifier:

return True

return False

class GestureEventMatch(EventMatch):

"""Base class for matching gesture events"""

def __init__(self, gesture_type: int, gesture_state: int) -> None:

super().__init__()

self.gesture_type = gesture_type

self.gesture_state = gesture_state

@staticmethod

def __get_type_str(gesture_type: int) -> str:

"""Return text representation for gesture type"""

for attr in (

"TapGesture",

"TapAndHoldGesture",

"PanGesture",

"PinchGesture",

"SwipeGesture",

"CustomGesture",

):

if gesture_type == getattr(QC.Qt, attr):

return attr

@staticmethod

def __get_state_str(gesture_state: int) -> str:

"""Return text representation for gesture state"""

for attr in (

"GestureStarted",

"GestureUpdated",

"GestureFinished",

"GestureCanceled",

):

if gesture_state == getattr(QC.Qt, attr):

return attr

def get_event_types(self) -> frozenset[int]:

"""Return the set of event types handled by this event match"""

return frozenset((QC.QEvent.Gesture,))

def __call__(self, event: QC.QEvent) -> bool:

"""Returns True if the event matches the event match

Args:

event: event to match

"""

if event.type() == QC.QEvent.Gesture:

gesture = event.gesture(self.gesture_type)

return gesture and gesture.state() == self.gesture_state

return False

def __repr__(self) -> str:

"""Return textual representation"""

type_str = self.__get_type_str(self.gesture_type)

state_str = self.__get_state_str(self.gesture_state)

return "<GestureMatch: %s:%s>" % (type_str, state_str)

class WheelEventMatch(EventMatch):

"""A callable returning True if it matches a wheel event

Args:

modifiers: keyboard modifiers

"""

def __init__(self, modifiers: int = QC.Qt.KeyboardModifier.NoModifier) -> None:

super().__init__()

self.modifiers = modifiers

def get_event_types(self) -> frozenset[int]:

"""Return the set of event types handled by this event match"""

return frozenset((QC.QEvent.Type.Wheel,))

def __call__(self, event: QG.QWheelEvent) -> bool:

"""Returns True if the event matches the event match

Args:

event: event to match

"""

return isinstance(event, QG.QWheelEvent) and event.modifiers() == self.modifiers

# MARK: Finite state machine -----------------------------------------------------------

class StatefulEventFilter(QC.QObject):

"""State machine for handling events of a plot's canvas

Args:

parent: plot on which to install the event filter

"""

def __init__(self, parent: BasePlot) -> None:

super().__init__()

# Machine states: (0: cursor, 1: panning, 2: zooming)

self.states: dict[int, dict[EventMatch, list[list[callable], int]]] = {0: {}}

self.cursors: dict[int, QC.Qt.CursorShape] = {}

self.state = 0

self.max_state = 0

self.events: dict[tuple[str, int, int], EventMatch] = {}

self.plot: BasePlot = parent

self.all_event_types = frozenset()

def eventFilter(self, _obj: QC.QObject, event: QC.QEvent) -> bool:

"""The `eventfilter` callback for Qt"""

if not hasattr(self, "all_event_types"):

print(repr(self), self)

if event.type() not in self.all_event_types:

return False

state = self.states[self.state]

for match, (call_list, next_state) in list(state.items()):

if match(event):

self.set_state(next_state, event)

for call in call_list:

call(self, event) # might change state

return False

def set_state(self, state: int, event: QC.QEvent) -> None:

"""Change the current state.

Can be called by handlers to cancel a state change

Args:

state: new state

event: event that triggered the state change

"""

assert state in self.states

if state == self.state:

return

self.state = state

cursor = self.get_cursor(event)

if cursor is not None:

self.plot.canvas().setCursor(cursor)

def new_state(self) -> int:

"""Create (reserve) a new state number

Returns:

New state number

"""

self.max_state += 1

self.states[self.max_state] = {}

return self.max_state

def add_event(

self, state: int, match: EventMatch, call: callable, next_state: int = None

) -> int:

"""Add a transition to the state machine.

If next_state is provided, it must correspond to an existing state,

otherwise a new destination state is created

Args:

state: current state

match: event matcher

call: callable to execute when the event matches

next_state: next state to go to when the event matches

Returns:

Next state number

"""

assert isinstance(state, int)

assert isinstance(match, EventMatch)

self.all_event_types = self.all_event_types.union(match.get_event_types())

entry = self.states[state].setdefault(match, [[], None])

entry[0].append(call)

if entry[1] is None:

if next_state is None:

next_state = self.new_state()

else:

pass

else:

if next_state is not None:

assert next_state == entry[1]

else:

next_state = entry[1]

entry[1] = next_state

return next_state

def nothing(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:

"""A nothing filter, provided to help removing duplicate handlers

Args:

filter: event filter that contains the BasePlot instance

event: event that triggered the action

"""

pass

# Cursor management ----------------------------------------------------------------

def set_cursor(self, cursor: QC.Qt.CursorShape, *states: int) -> None:

"""Associate a cursor with one or more states

Args:

cursor: cursor shape

states: state numbers

"""

assert isinstance(cursor, QC.Qt.CursorShape)

for s in states:

self.cursors[s] = cursor

def get_cursor(self, _event: QC.QEvent) -> QC.Qt.CursorShape | None:

"""Get the cursor associated with a given state/event

Returns:

Cursor shape or None if no cursor is associated with the state

"""

# pass event to potentially choose the cursor based on modifier keys

cursor = self.cursors.get(self.state, None)

if cursor is None:

# no cursor specified : should keep previous one

return None

return cursor

# Mouse management -----------------------------------------------------------------

def mouse_press(

self, btn: int, modifiers: int = QC.Qt.NoModifier

) -> MouseEventMatch:

"""Create a filter for the MousePress event

Args:

btn: button to match

modifiers: keyboard modifiers to match

Returns:

An instance of MouseEventMatch that matches the MousePress event

"""

return self.events.setdefault(

("mousepress", btn, modifiers),

MouseEventMatch(QC.QEvent.MouseButtonPress, btn, modifiers),

)

def mouse_move(

self, btn: int, modifiers: int = QC.Qt.NoModifier

) -> MouseEventMatch:

"""Create a filter for the MouseMove event

Args:

btn: button to match

modifiers: keyboard modifiers to match

Returns:

An instance of MouseEventMatch that matches the MouseMove event

"""

return self.events.setdefault(

("mousemove", btn, modifiers),

MouseMoveMatch(QC.QEvent.MouseMove, btn, modifiers),

)

def mouse_release(

self, btn: int, modifiers: int = QC.Qt.NoModifier

) -> MouseEventMatch:

"""Create a filter for the MouseRelease event

Args:

btn: The button to match

modifiers: The keyboard modifiers to match

Returns:

An instance of MouseEventMatch that matches the MouseRelease event

"""

return self.events.setdefault(

("mouserelease", btn, modifiers),

MouseEventMatch(QC.QEvent.MouseButtonRelease, btn, modifiers),

)

# Gesture management ---------------------------------------------------------------

def gesture(self, kind: int, state: int) -> GestureEventMatch:

"""Create a filter for the gesture event

Args:

kind: The type of gesture

state: The state of the gesture

Returns:

An instance of GestureEventMatch that matches the gesture event

"""

return self.events.setdefault(

("gesture", kind, state), GestureEventMatch(kind, state)

)

# Wheel management -----------------------------------------------------------------

def wheel(

self, modifiers: int = QC.Qt.KeyboardModifier.NoModifier

) -> WheelEventMatch:

"""Create a filter for wheel events

Args:

modifiers: The keyboard modifiers to use with the wheel event

Returns:

An instance of WheelEventMatch that matches the wheel event"""

return self.events.setdefault(("wheel", modifiers), WheelEventMatch(modifiers))

# MARK: Event handlers -----------------------------------------------------------------

class DragHandler(QC.QObject):

"""Base class for click-drag-release event handlers.

Args:

filter: The StatefulEventFilter instance.

btn: The mouse button to match.

mods: The keyboard modifiers to match. (default: QC.Qt.NoModifier)

start_state: The starting state. (default: 0)

"""

cursor = None

def __init__(

self,

filter: StatefulEventFilter,

btn: int,

mods: int = QC.Qt.NoModifier,

start_state: int = 0,

) -> None:

super().__init__()

self.state0 = filter.add_event(

start_state, filter.mouse_press(btn, mods), self.start_tracking

)

self.state1 = filter.add_event(

self.state0, filter.mouse_move(btn, mods), self.start_moving

)

filter.add_event(

self.state1, filter.mouse_move(btn, mods), self.move, self.state1

)

filter.add_event(

self.state0,

filter.mouse_release(btn, mods),

self.stop_notmoving,

start_state,

)

filter.add_event(

self.state1, filter.mouse_release(btn, mods), self.stop_moving, start_state

)

if self.cursor is not None:

filter.set_cursor(self.cursor, self.state0, self.state1)

self.start = None # first mouse position

self.last = None # mouse position seen during last event

self.parent_tracking = None

def get_move_state(

self, filter: StatefulEventFilter, pos: QC.QPointF

) -> tuple[float, float]:

"""Get the movement state based on the current filter and position

Args:

filter: The StatefulEventFilter instance

pos: The current position

Returns:

A tuple containing the movement state in the x and y directions

"""

rct = filter.plot.contentsRect()

dx = (pos.x(), self.last.x(), self.start.x(), rct.width())

dy = (pos.y(), self.last.y(), self.start.y(), rct.height())

self.last = QC.QPointF(pos)

return dx, dy

def start_tracking(self, _filter: StatefulEventFilter, event: QMouseEvent) -> None:

"""Start tracking the mouse movement

Args:

_filter: The StatefulEventFilter instance

event: The mouse event

"""

self.start = self.last = QC.QPointF(event.pos())

def start_moving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:

"""Start moving the mouse

Args:

filter: The StatefulEventFilter instance

event: The mouse event

"""

return self.move(filter, event)

def stop_tracking(self, _filter: StatefulEventFilter, _event: QMouseEvent) -> None:

"""Stop tracking the mouse movement

Args:

_filter: The StatefulEventFilter instance

_event: The mouse event

"""

pass

# filter.plot.canvas().setMouseTracking(self.parent_tracking)

def stop_notmoving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:

"""Stop tracking the mouse movement when the mouse is not moving.

Args:

filter: The StatefulEventFilter instance.

event: The mouse event.

"""

self.stop_tracking(filter, event)

def stop_moving(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:

"""Stop moving the mouse

Args:

filter: The StatefulEventFilter instance

event: The mouse event

"""

self.stop_tracking(filter, event)

def move(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:

"""Move the mouse

Args:

filter: The StatefulEventFilter instance

event: The mouse event

"""

raise NotImplementedError()

class ClickHandler(QC.QObject):

"""Base class for click-release event handlers.

Args:

filter: The StatefulEventFilter instance.

btn: The mouse button to match.

mods: The keyboard modifiers to match. (default: QC.Qt.NoModifier)

start_state: The starting state. (default: 0)

Signals:

SIG_CLICK_EVENT: Signal emitted by ClickHandler on mouse click

"""

#: Signal emitted by ClickHandler on mouse click

SIG_CLICK_EVENT = QC.Signal(object, "QEvent")

def __init__(

self,

filter: StatefulEventFilter,

btn: int,

mods: int = QC.Qt.NoModifier,

start_state: int = 0,

) -> None:

super().__init__()

self.state0 = filter.add_event(

start_state, filter.mouse_press(btn, mods), filter.nothing

)

filter.add_event(

self.state0, filter.mouse_release(btn, mods), self.click, start_state

)

def click(self, filter: StatefulEventFilter, event: QC.QEvent) -> None:

"""Handle the click event.

Args:

filter: The StatefulEventFilter instance.

event: The mouse event.

"""

self.SIG_CLICK_EVENT.emit(filter, event)

class PanHandler(DragHandler):

cursor = QC.Qt.ClosedHandCursor

def move(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:

"""Move the mouse.

Args:

filter: The StatefulEventFilter instance.

event: The mouse event.

"""

x_state, y_state = self.get_move_state(filter, QC.QPointF(event.pos()))

filter.plot.do_pan_view(x_state, y_state)

class ZoomHandler(DragHandler):

cursor = QC.Qt.SizeAllCursor

def move(self, filter: StatefulEventFilter, event: QMouseEvent) -> None:

"""Move the mouse.

Args:

filter: The StatefulEventFilter instance.

event: The mouse event.

"""

x_state, y_state = self.get_move_state(filter, QC.QPointF(event.pos()))

filter.plot.do_zoom_view(x_state, y_state)

class GestureHandler(QC.QObject):

"""Base class used to handle gestures.

Args:

filter: event filter into which to add the handler instance.

start_state: start state to use in the event filter state machine.

Defaults to 0.

"""

kind: QC.Qt.GestureType | None = None

def __init__(self, filter: StatefulEventFilter, start_state: int = 0) -> None:

super().__init__()

filter.plot.canvas().grabGesture(self.kind)

self.state0 = filter.add_event(

start_state,

filter.gesture(self.kind, QC.Qt.GestureState.GestureStarted),

self.start_tracking,

)

self.state1 = filter.add_event(

self.state0,

filter.gesture(self.kind, QC.Qt.GestureState.GestureUpdated),

self.start_moving,

)

filter.add_event(

self.state1,

filter.gesture(self.kind, QC.Qt.GestureState.GestureUpdated),

self.move,

self.state1,

)

filter.add_event(

self.state0,

filter.gesture(self.kind, QC.Qt.GestureState.GestureFinished),

self.stop_tracking,

start_state,

)

filter.add_event(

self.state1,

filter.gesture(self.kind, QC.Qt.GestureState.GestureFinished),

self.stop_tracking,

start_state,

)

filter.add_event(

self.state0,

filter.gesture(self.kind, QC.Qt.GestureState.GestureCanceled),

self.stop_tracking,

start_state,

)

filter.add_event(

self.state1,

filter.gesture(self.kind, QC.Qt.GestureState.GestureCanceled),

self.stop_tracking,

start_state,

)

self.start = QC.QPoint() # first gesture position

self.last = QC.QPoint() # gesture position seen during last event

self.parent_tracking = None

def get_glob_position(self, event: QW.QGestureEvent) -> QC.QPointF:

"""Returns the hotspot global position of the gesture event.

Args:

event: event from which to get the position

Returns:

event hotspot poisition in global coordinates.

"""

return self.get_gesture(event).hotSpot()

def get_gesture(self, event: QW.QGestureEvent) -> QW.QGesture:

"""Returns the gesture from the event.

Args:

event: event from which to get the gesture.

Returns:

gesture from the event.

"""

return event.gesture(self.kind)

def start_tracking(

self, filter: StatefulEventFilter, event: QW.QGestureEvent

) -> None:

"""Handles the start of the gesture tracking.

Args:

filter: event filter that contains the BasePlot instance

event: event that triggered the start of the tracking, used to get

a position.

"""

origin = self.get_glob_position(event)

self.start = self.last = filter.plot.canvas().mapFromGlobal(origin.toPoint())

def start_moving(

self, filter: StatefulEventFilter, event: QW.QGestureEvent

) -> None:

"""Handles the start of the gesture moving.

Args:

filter: event filter that contains the BasePlot instance

event: event that triggered the start of the moving

"""

return self.move(filter, event)

def stop_tracking(

self, _filter: StatefulEventFilter, _event: QW.QGestureEvent

) -> None:

"""Handles the stop of the gesture tracking.

Args:

_filter: event filter that contains the BasePlot instance

_event: event that triggered the stop of the tracking

"""

pass

def move(self, filter: StatefulEventFilter, event: QW.QGestureEvent) -> None:

"""Handles the movement of the gesture.

Args:

filter: event filter that contains the BasePlot instance

event: event that triggered the movement

"""

raise NotImplementedError

class PinchPanGestureHandler(GestureHandler):

"""Class used to handle pinch and pan gestures.

Args:

filter: event filter into which to add the handler instance.

start_state: start state to use in the event filter state machine.

Defaults to 0.

"""

kind = QC.Qt.GestureType.PinchGesture

def __init__(

self,

filter: StatefulEventFilter,

start_state=0,

) -> None:

super().__init__(filter, start_state)

self.last_center_diff = 0

self.marker: Marker | None = None

def get_pan_param(

self, plot: BasePlot, pos: QPoint

) -> tuple[tuple[float, float, float, float], tuple[float, float, float, float]]:

"""Returns the parameters to use for panning the plot.

Args:

plot: instance of BasePlot to use as a reference.

pos: position on the plot canvas of the current hotspot.

Returns:

Returns two tuples of four floats each, representing the parameters used

by BasePlot.do_pan_view.

"""

rct = plot.contentsRect()

dx = (pos.x(), self.last.x(), self.start.x(), rct.width())

dy = (pos.y(), self.last.y(), self.start.y(), rct.height())

self.last = pos

return dx, dy

def get_zoom_param(

self, plot: BasePlot, pos: QPoint, factor: float

) -> tuple[tuple[float, float, float, float], tuple[float, float, float, float]]:

"""Returns the parameters to use for zooming on the plot.

Args:

plot: instance of BasePlot to use as a reference.

pos: position on the plot canvas of the current hotspot.

factor: factor by which to zoom (zero-centered).

Returns:

Returns two tuples of four floats each, representing the parameters used

by BasePlot.do_zoom_view.

"""

rect = plot.contentsRect()

w, h = rect.width(), rect.height()

x, y = pos.x(), pos.y()

dx = (

x + (w * factor),

x,

x,

w,

)

dy = (

y + (h * factor),

y,

y,

h,

)

return dx, dy

def start_tracking(

self, filter: StatefulEventFilter, event: QW.QGestureEvent

) -> None:

"""Overrides the GestureHandler.start_tracking method to add a marker at the

hostpot of the pinch gesture.

Args:

filter: event filter that contains the BasePlot instance

event: Gesture event that triggered the start of the tracking, used to get

a position.

"""

plot = filter.plot

if self.marker is None:

self.marker = Marker()

self.marker.attach(plot)

self.marker.setZ(plot.get_max_z() + 1)

self.marker.setVisible(True)

pos = plot.canvas().mapFromGlobal(self.get_glob_position(event).toPoint())

self.marker.move_local_point_to(0, pos)

return super().start_tracking(filter, event)