def wheelEvent(self, event: QtGui.QWheelEvent):
items = self.items()
plot: PlotItem = items[0]
axis: AxisItem = items[1]
axis.data_range_x_pix += event.pixelDelta().x()
axis.update()
plot.data_range_x_pix += event.pixelDelta().x()
plot.update()
super().wheelEvent(event)
def wheelEvent(self, event: QtGui.QWheelEvent):
delta_x = 0
delta_y = 0
if platform == "linux" or platform == "linux2":
delta_x = event.angleDelta().x()
delta_y = event.angleDelta().y()
elif platform == "darwin":
delta_x = event.pixelDelta().x()
delta_y = event.pixelDelta().y()
elif platform == "win32":
delta_x = event.angleDelta().x()
delta_y = event.angleDelta().y()
self.trans.moving_x(delta_x)
self.trans.moving_range(delta_y)
plot: QGraphicsItem = self.scene().items()[0]
trans = plot.transform()
trans.translate(delta_x, 0)
scale_x, scale_y = trans.m11(), trans.m22()
print(scale_x, scale_y)
trans.scale(1 + delta_y / scale_x / 100, 1 + delta_y / scale_y / 100)
plot.setTransform(trans)
print(trans.m11(), trans.m12(), trans.m13())
print(trans.m21(), trans.m22(), trans.m23())
print(trans.m31(), trans.m32(), trans.m33())
super().wheelEvent(event)
def mouse_wheel_event(self, e: QWheelEvent):
delta: QtCore.QPoint = e.pixelDelta()
if delta is None or delta.y() == 0:
delta = e.angleDelta() / 10
modifiers = int(e.modifiers())
if modifiers and modifiers & MOD_MASK == modifiers:
keyname = QKeySequence(modifiers).toString()
if keyname == "Ctrl+":
oldpos = self.UI.graphicsView.mapToScene(e.pos())
self.scale_display(delta.y() * 0.01)
newpos = self.UI.graphicsView.mapToScene(e.pos())
deltapos = newpos - oldpos
self.UI.graphicsView.translate(deltapos.x(), deltapos.y())
if keyname == "Ctrl+Shift+":
value = self.UI.BrushSizeSlider.value() + delta.y()
self.UI.BrushSizeSlider.setValue(value)
if keyname == "Shift+":
delta *= self.scroll_speed
value = self.UI.graphicsView.horizontalScrollBar().value(
) + delta.y()
self.UI.graphicsView.horizontalScrollBar().setValue(value)
else:
delta *= self.scroll_speed
value = self.UI.graphicsView.verticalScrollBar().value() + delta.y(
)
self.UI.graphicsView.verticalScrollBar().setValue(value)
if self.paint_mode == PMode.Brush:
# Update cursor position
r = int(self.brush_size / 2)
curr_pos = self.UI.graphicsView.mapToScene(e.pos())
curr_pos.setX(curr_pos.x() - r)
curr_pos.setY(curr_pos.y() - r)
self.brush_cursor.setPos(curr_pos)
def wheelEvent(self, event: QtGui.QWheelEvent):
# print(event.pixelDelta())
plot: QGraphicsPathItem = self.scene().items()[0]
trans = plot.transform()
trans.translate(event.pixelDelta().x(), 0)
plot.setTransform(trans)
def wheelEvent(self, event: QtGui.QWheelEvent):
""" ChartView's wheel event handler
Handle mouse wheel event.
This method must handle :
1. Change range of model by y-axis
2. Change translate of model by x-axis
Parameters
----------
event : QtGui.QWheelEvent
QGraphicsView's wheel event.
"""
if self.open_file_finished:
if platform == "darwin":
delta_x = event.pixelDelta().x()
delta_y = event.pixelDelta().y()
else:
delta_x = event.angleDelta().x()
delta_y = event.angleDelta().y()
self.model.change_x_range(delta_y)
super().wheelEvent(event)
def wheelEvent(self, event: QWheelEvent) -> None:
if Town.isPointInRect(
event.pos(),
(QPoint(0,
self.height() * .8), QSize(self.width(),
self.height() * .2))):
if self.menu_mode == 1:
types = Town.BuildingTypes
elif self.menu_mode == 2:
types = Town.RoadTypes
delta = event.pixelDelta()
if delta is None:
delta = -event.angleDelta().y() / 2
else:
delta = -delta.x() / 2
max_scroll = (3 * len(types.sorted_names) +
1) / 15 * self.height() - self.width() - 4
if Town.isPointInRect(
event.pos(),
(QPoint(self.height() / 15 - 4,
self.height() * .8),
QSize(self.width(),
self.height() *
.2))) and (delta > 0 and max_scroll > self.scrollAmount
or delta < 0 and self.scrollAmount > 0):
self.scrollAmount += delta
if max_scroll < self.scrollAmount:
self.scrollAmount = max_scroll
elif self.scrollAmount < 0:
self.scrollAmount = 0
elif self.mode != Modes.Instructions:
self.town.scaleByEvent(event)
def wheelEvent(self, event: QWheelEvent):
"""
WheelEvent is the callback for wheel events of the operating system.
Dependent on the OS, this can be a trackpad or a mouse wheel
"""
if not (self.imageOpened):
return
# Disable wheel if x position is leaving image compartment
if (event.x() > self.ui.verticalScrollBar.pos().x()):
return
if (event.source() == Qt.MouseEventSynthesizedBySystem):
# touch pad geasture - use direct scrolling, not zooming
# this is usually indicative for Mac OS
subs = np.asarray(
[float(event.pixelDelta().x()),
float(event.pixelDelta().y())]) / 32000.0 * self.getZoomValue()
self.relativeCoords -= subs
if (self.relativeCoords[0] < -0.5):
self.relativeCoords[0] = -0.5
if (self.relativeCoords[1] < -0.5):
self.relativeCoords[1] = -0.5
else: # mouse wheel - use scrolling
inc = 1
if (event.angleDelta().y() > 0):
inc = -1
self.setZoomValue(self.getZoomValue() * np.power(1.25, -inc))
self.showImage()
self.updateScrollbars()
def wheelEvent(self, event):
if self.control_scheme.wheel_zooms:
dy = event.angleDelta().y()
# Filter out horizontal wheel motion. We don't support this yet.
if dy == 0:
event.ignore()
return
self.zoom_camera(dy)
else:
if event.modifiers() & Qt.ShiftModifier:
event = QWheelEvent(event.posF(),
event.globalPosF(),
event.pixelDelta(),
event.angleDelta(),
# Value magically chosen to approximate
# what is happening on nirvana using
# a steelseries mouse...
event.angleDelta().y() / 8,
Qt.Horizontal, # Qt4 crap
event.buttons(),
event.modifiers(),
event.phase())
super().wheelEvent(event)
def wheelEvent(self, event: QtGui.QWheelEvent):
"""Translate Qt wheelEvent to MPL scroll_event"""
pxDelta = event.pixelDelta()
# See QWheelEvent::pixelDelta docs
if not pxDelta.isNull():
step = pxDelta.y()
else:
step = event.angleDelta().y() / 120
if step:
self.scroll_event(*self.mapToFigure(event.pos()), step, event)
def wheelEvent(self, event: qtgui.QWheelEvent):
numPixels = event.pixelDelta()
numDegrees = event.angleDelta() / 8
if numPixels:
self.scrollWithPixels(numPixels.y())
elif numDegrees:
numSteps = numDegrees / 15
self.scrollWithDegrees(numSteps.y())
event.accept()
def wheelEvent(self, evt: QtGui.QWheelEvent) -> None:
self.__mouse_pos = evt.pos()
measure_editor = self.track.measureEditorAt(evt.pos())
if isinstance(measure_editor, MeasureEditor):
measure_evt = QtGui.QWheelEvent(
evt.pos() - measure_editor.topLeft(), evt.globalPos(),
evt.pixelDelta(), evt.angleDelta(), 0, Qt.Horizontal,
evt.buttons(), evt.modifiers(), evt.phase(), evt.source())
measure_evt.setAccepted(False)
self.wheelMeasureEvent(measure_editor, measure_evt)
evt.setAccepted(measure_evt.isAccepted())
def wheelEvent(self, e: QtGui.QWheelEvent) -> None:
pDelta = e.pixelDelta()
aDelta = e.angleDelta() / 8
alt = int(e.modifiers()) & Qt.AltModifier
steps = QPoint(0, 0)
if not pDelta.isNull():
# TODO: test this
steps = pDelta
elif not aDelta.isNull():
steps = aDelta / 15
fac = steps.x() if alt else steps.y()
if fac > 0:
self.scale(1.25, 1.25)
else:
self.scale(.8, .8)
def eventFilter(self, object, event):
if (event.type() == QEvent.Wheel and not self.__d_ignoreWheelEvent):
we = QWheelEvent(event)
pos = self.wheelRect().center()
wheelEvent = QWheelEvent(pos, QWidget.mapToGlobal(self, pos),
we.pixelDelta(), we.angleDelta(),
we.buttons(), we.modifiers(), we.phase(),
we.inverted(), we.source())
self.__d_ignoreWheelEvent = True
QApplication.sendEvent(self, wheelEvent)
self.__d_ignoreWheelEvent = False
return True
return Qwt.QwtWheel.eventFilter(object, event)
def wheelEvent(self, event: QWheelEvent):
if self.thumbs_manager is None:
event.ignore()
return
numPixels: QPoint = event.pixelDelta()
numDegrees: QPoint = event.angleDelta() / 8
if not numPixels.isNull():
event.ignore()
elif not numDegrees.isNull():
num_steps: QPoint = numDegrees / 15 # .y() == Down: -1, Up: 1
if num_steps.y() == -1:
self.thumbs_manager.show_next()
event.accept()
elif num_steps.y() == 1:
self.thumbs_manager.show_previous()
event.accept()
else:
event.ignore()
def wheelEvent(self, evt: QtGui.QWheelEvent) -> None:
evt = QtGui.QWheelEvent(evt.pos() + self.offset(), evt.globalPos(),
evt.pixelDelta(), evt.angleDelta(), 0,
Qt.Horizontal, evt.buttons(), evt.modifiers(),
evt.phase(), evt.source())
self.__toolbox.wheelEvent(evt)
def wheelEvent(self, event:QWheelEvent):
if event.pixelDelta().y() > 5:
self.scrolledUp.emit()
elif event.pixelDelta().y() < -5:
self.scrolledDown.emit()
