def wheelEvent(self, e: QWheelEvent):
if e.modifiers() & Qt.ControlModifier:
if e.delta() > 0:
self.view.zoomIn(6)
else:
self.view.zoomOut(6)
else:
QGraphicsView.wheelEvent(e)
def wheelEvent(self, event: QWheelEvent):
value_delta = event.angleDelta().y() / 120
if event.modifiers() & Qt.ControlModifier:
value_delta *= 10
self.set_focus()
self.increase_value(value_delta)
event.accept()
def wheelEvent(self, event: QWheelEvent):
"""
Forward the wheel event to target view to handle zoom events.
"""
if event.modifiers() & Qt.ControlModifier == Qt.ControlModifier:
self._target_view.centerOn(
self.map_event_pos_to_target_scene_pos(event.pos()))
self._target_view.wheelEvent(event)
def wheelEvent(self, event: QtGui.QWheelEvent):
numPixels: QtCore.QPoint = event.pixelDelta()
numDegrees: QtCore.QPoint = event.angleDelta() / 8
if not numPixels.isNull():
self.zoomWithPixels(numPixels)
elif not numDegrees.isNull():
numSteps: QtCore.QPoint = numDegrees / 15
self.zoomWithDegrees(numSteps)
event.accept()
def wheelEvent(self, event: QWheelEvent) -> None:
if event.source() == Qt.MouseEventSource.MouseEventSynthesizedBySystem:
# track pad
scroll_delta = event.pixelDelta()
self.engine.pan(self._factor * scroll_delta.x(),
self._factor * scroll_delta.y())
else:
# mouse wheel
zoom_delta = event.angleDelta().y()
self.engine.zoom(zoom_delta / 500.0, self._factor * event.x(),
self._factor * event.y())
def wheelEvent(self, event: QWheelEvent):
if not self.handleEvents:
return
x, y = self.getMousePosition(event)
delta = event.delta()
horizontal = event.orientation() == Qt.Orientation.Horizontal
event.setAccepted(True)
pdu = PlayerMouseWheelPDU(self.layer.getCurrentTimeStamp(), x, y,
delta, horizontal)
self.layer.sendPDU(pdu)
def wheelEvent(self, event: QWheelEvent) -> None:
degrees: int = event.delta() // 8 # 滚动的角度,*8就是鼠标滚动的距离
steps: int = degrees // 15 # 滚动的步数,*15就是鼠标滚动的角度
# 如果是正数代表为左边移动,负数代表为右边移动
if event.orientation() is Qt.Vertical:
index: int = self.__currentIndex - steps
if steps > 0:
if index > 0: self.currentIndex = index
else: self.currentIndex = 0
else:
if index < self.__listValue.__len__() - 1:
self.currentIndex = index
else:
self.currentIndex = self.__listValue.__len__() - 1
def sendEvent(self, event: QEvent) -> None:
"""
Send an event.
Args:
event: The event to send.
"""
if event.type() == QEvent.Type.FocusOut:
# Ignored - cannot get focus back reliably :-(
return
if isinstance(event, QMouseEvent):
# `windowPos` is replaced with `localPos` as it has no meaning in offscreen rendering.
event = QMouseEvent(event.type(), event.localPos(),
event.screenPos(), event.button(),
event.buttons(), event.modifiers())
elif isinstance(event, QWheelEvent):
event = QWheelEvent(event.position(), event.position(),
event.pixelDelta(), event.angleDelta(),
event.buttons(), event.modifiers(),
event.phase(), event.inverted(),
event.source())
self._window.contentItem().forceActiveFocus()
QCoreApplication.sendEvent(self._window, event)
def wheelEvent(self, event: QWheelEvent) -> None: """ Handle wheel scroll events. This will zoom in or out if the Ctrl key is pressed. :param event: the wheel scroll event :type event: QWheelEvent :return: None :rtype: NoneType """ if event.modifiers() != Qt.ControlModifier: return # Zoom if event.delta() > 0: self.zoomIn(event.pos()) else: self.zoomOut(event.pos())
def wheelEvent(self, event: QWheelEvent):
x, y = event.pos().toTuple()
obj_under_cursor = self.object_at(x, y)
if obj_under_cursor is None:
return False
if isinstance(self.level_ref.level, WorldMap):
return False
# scrolling through the level could unintentionally change objects, if the cursor would wander onto them.
# this is annoying (to me) so only change already selected objects
if obj_under_cursor not in self.level_ref.selected_objects:
return False
self.change_object_on_mouse_wheel(event.pos(), event.angleDelta().y())
return True
def on_scroll_event(self, wl_view, type_, modifiers, delta_x, delta_y,
local_x, local_y, window_x, window_y, screen_x,
screen_y):
pixelDelta = QPoint(int(delta_x),
int(delta_y)) if delta_x or delta_y else QPoint()
buttons = Qt.NoButton
for button in self.mouse_buttons:
buttons |= button
event = QWheelEvent(QPointF(local_x, local_y),
QPointF(screen_x, screen_y), pixelDelta,
WHEEL_ANGLES[type_], buttons,
deserialize_modifiers(modifiers), Qt.NoScrollPhase,
False)
self.renderer.sendEvent(event)
def wheelEvent(self, event: QWheelEvent):
step_w = -event.angleDelta().y() * self.step_each_angle
mouse_pos = event.position().toTuple()
step_x = step_w * mouse_pos[0] / self.max_rect[0]
step_h = step_w / self.max_rect[0] * self.max_rect[1]
step_y = step_h * mouse_pos[1] / self.max_rect[1]
tem_x = self.cur_pos_rect[0] - step_x
tem_y = self.cur_pos_rect[1] - step_y
tem_w = self.cur_pos_rect[2] + step_w
tem_h = self.cur_pos_rect[3] + step_h
if step_w > 0:
tem_x = max(tem_x, 0)
tem_y = max(tem_y, 0)
tem_w = min(tem_w, self.max_rect[0])
tem_h = min(tem_h, self.max_rect[1])
else:
tem_x = min(tem_x, self.max_rect[0] - self.min_rect[0])
tem_y = min(tem_y, self.max_rect[1] - self.min_rect[1])
tem_w = max(tem_w, self.min_rect[0])
tem_h = max(tem_h, self.min_rect[1])
self.cur_pos_rect = [tem_x, tem_y, tem_w, tem_h]
if self.last_frame is not None:
self.set_image(self.last_frame)
def wheelEvent(self, event: QtGui.QWheelEvent):
# Save transformation anchor and set to mouse position
anchor = self.transformationAnchor()
self.setTransformationAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
rect = self.mapFromScene(self.sceneRect()).boundingRect()
# Scale a small amount per scroll
scale = pow(2, event.angleDelta().y() / 360.0)
self.scale(scale, scale)
rect = self.mapFromScene(self.sceneRect()).boundingRect()
if self.viewport().rect().contains(rect):
self.fitInView(self.sceneRect(), QtCore.Qt.KeepAspectRatio)
self.viewScaleChanged.emit()
self.setTransformationAnchor(anchor)
def wheelEvent(self, event: QWheelEvent):
if event.angleDelta().y() > 0:
factor = 1.25
self._zoom += 1
if self._zoom < 10:
self.scale(factor, factor)
self.factorized *= factor
else:
self._zoom = 9
else:
factor = 0.8
self._zoom -= 1
if self._zoom > -5:
self.scale(factor, factor)
self.factorized *= factor
else:
self._zoom = -4
def test_wheel_event(scroll_amount, coordinates, wheel_delta, type_change,
main_window, qtbot):
# GIVEN a level view and a cursor position over an object
x, y = coordinates
level_view = main_window.level_view
object_under_cursor = level_view.object_at(x, y)
original_type = object_under_cursor.type
SETTINGS["object_scroll_enabled"] = True
# WHEN level view is scrolled horizontally, the object is selected and the scroll wheel is used on it
main_window.scroll_panel.horizontalScrollBar().setMaximum(
level_view.width())
main_window.scroll_panel.horizontalScrollBar().setValue(scroll_amount)
main_window.show()
qtbot.wait_for_window_shown(main_window)
main_window.hide()
qtbot.mouseClick(level_view, Qt.LeftButton, pos=QPoint(x, y))
assert object_under_cursor.selected
event = QWheelEvent(
QPoint(x, y),
QPoint(-1, -1),
QPoint(0, wheel_delta),
QPoint(0, wheel_delta),
Qt.LeftButton,
Qt.NoModifier,
Qt.ScrollEnd,
False,
)
assert level_view.wheelEvent(event)
# THEN the type of the object should have changed
new_type = level_view.object_at(*coordinates).type
assert new_type == original_type + type_change, (original_type, new_type)
def wheelEvent(self, e: QWheelEvent):
qDebug("myMouseWheel in Item...")
self.__m_lastMouseWheel = self.__cloneMouseWheelEvent(e)
self.__m_lastMouseWheel.ignore()
e.accept()
self.update()
def __cloneMouseWheelEvent(self, e: QWheelEvent):
pos = e.pos()
globalPos = e.globalPos()
pixelDelta = e.pixelDelta()
angleDelta = e.angleDelta()
buttons = e.buttons()
modifiers = e.modifiers()
phase = e.phase()
inverted = e.inverted()
clone = QWheelEvent(pos, globalPos, pixelDelta, angleDelta, buttons, modifiers, phase, inverted)
clone.ignore()
clone.accepted = False
return clone
def wheelEvent(self, event: QtGui.QWheelEvent):
self.camera.zoom(event.delta())
self.update()
def wheelEvent(self, event: QtGui.QWheelEvent):
"""Implementation.
Handles zooming the editor's view.
"""
if (event.modifiers() & Qt.ControlModifier
and event.orientation() == Qt.Vertical):
if event.delta() > 0:
self.zoomIn()
else:
self.zoomOut()
# TODO: Improve cursor anchoring; be more like Aseprite
prevAnchor = self.transformationAnchor()
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setTransform(QTransform.fromScale(self.zoom(), self.zoom()))
self.updateSceneRect(self.zoom())
self.setTransformationAnchor(prevAnchor)
event.accept()
elif event.orientation() == Qt.Horizontal:
# XXX: Workaround for the insane horizontal scroll delta of 15240 on the
# Logitech G502 mouse.
if abs(event.delta()) == 15240:
newDelta = 120 if event.delta() > 0 else -120
event = QtGui.QWheelEvent(event.pos(),
event.globalPos(),
newDelta,
event.buttons(),
event.modifiers(),
orient=Qt.Horizontal)
super().wheelEvent(event)
else:
super().wheelEvent(event)
def wheelEvent(self, event: QWheelEvent) -> None:
if self._chartIsSet and self._zoomEnabled:
delta: int = event.angleDelta().y()
factor = pow(1.25, delta / 240.0)
self.chart().zoom(factor)
event.accept()
def wheelEvent(self, event:QtGui.QWheelEvent):
if event.modifiers() & Qt.ControlModifier:
point = event.angleDelta()
delta = point.x()+point.y() # allow left-to-right balls as well
self.loader.setZoomFactor(min(max(self.loader.zoomFactor() + delta*0.005, 0.25), 5.0))
def wheelEvent(self, e: QWheelEvent):
self.__m_lastMouseWheel = self.__cloneMouseWheelEvent(e)
self.__m_lastMouseWheel.ignore()
e.accept()
self.update()
def wheelEvent(
self,
event: QtGui.QWheelEvent
) -> None:
super(ImageViewer, self).wheelEvent(event)
self.wheelSignal.emit(event.angleDelta().y())
def wheelEvent(self, event: QWheelEvent):
self.camera.zoom(event.angleDelta().y() / 8 / 15)
self.camera.transformed.emit()
event.accept()
