def wheelEvent(self, e: QtGui.QWheelEvent) -> None:
# 鼠标指针位于x轴范围内
if e.pos().x() >= padding_left and e.pos().y(
) >= self.size().height() - padding_bottom:
if e.angleDelta().y() > 0:
if self.x_show_interval > 1:
self.x_show_interval -= 1
else:
self.x_plot_interval += 1
else:
if self.x_plot_interval > 25:
self.x_plot_interval -= 1
else:
self.x_show_interval += 1
# 鼠标指针位于y轴范围内
if e.pos().x() <= padding_left and e.pos().y(
) <= self.size().height() - padding_bottom:
interval = random.randint(200, 500) # 随机增减y轴坐标
if e.angleDelta().y() > 0:
self.y_max -= interval
if self.y_max < 1023:
self.y_max = 1023
self.y_min += interval
if self.y_min > -1024:
self.y_min = -1024
else:
self.y_max += interval
if self.y_max > 32767:
self.y_max = 32767
self.y_min -= interval
if self.y_min < -32768:
self.y_min = -32768
self.update()
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 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: QWheelEvent):
"""
Zoom in or out of the view.
"""
if event.modifiers() & Qt.ControlModifier or event.modifiers(
) & Qt.MetaModifier:
zoomInFactor = 1.25
zoomOutFactor = 1 / zoomInFactor
# Save the scene pos
oldPos = self.mapToScene(event.pos())
# Zoom
if event.angleDelta().y() > 0:
zoomFactor = zoomInFactor
else:
zoomFactor = zoomOutFactor
self.scale(zoomFactor, zoomFactor)
# Get the new position
newPos = self.mapToScene(event.pos())
# Move scene to old position
delta = newPos - oldPos
self.translate(delta.x(), delta.y())
def wheelEvent(self, event: QWheelEvent):
if self.capturing_data:
return
delta = event.angleDelta().y()
zoom_factor = 1.001**delta
p0scene = self.mapToScene(event.pos())
w = self.view_rect().width()
zooming_in = zoom_factor > 1
if zooming_in and w / zoom_factor < self.min_width:
return
max_width = self.max_width
if self.max_width == "auto":
max_width = self.sceneRect().width()
if not zooming_in and w / zoom_factor > max_width:
self.update()
return
self.scale(zoom_factor, 1)
p1mouse = self.mapFromScene(p0scene)
move = p1mouse - event.pos()
self.horizontalScrollBar().setValue(move.x() +
self.horizontalScrollBar().value())
self.zoomed.emit(zoom_factor)
def wheelEvent(self, event: QtGui.QWheelEvent):
x, y = self.translate(event.pos().x(), event.pos().y())
new_zoom = self.zoom + event.angleDelta().y() / 400
if new_zoom < self.min_scale and event.angleDelta().y() < 0:
new_zoom = self.min_scale
self.offset_x = ((new_zoom - self.zoom) * x + self.zoom * self.offset_x) / new_zoom
self.offset_y = ((new_zoom - self.zoom) * y + self.zoom * self.offset_y) / new_zoom
self.zoom = new_zoom
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, a0: QtGui.QWheelEvent) -> None:
if self.selector.labels and self.pressHoldSel:
return super().wheelEvent(a0)
if a0.modifiers() & QtCore.Qt.KeyboardModifier.ShiftModifier:
c = self.hover.cats()
if len(c) == 1:
v = a0.angleDelta().y() or a0.angleDelta().x()
self.hover.incr() if v > 0 else self.hover.decr()
self.repaint()
return super().wheelEvent(a0)
lastScale = self.scale
if a0.angleDelta().y() > 0:
self.scale = min(
self.scale < 1 and self.scale + 0.125 or self.scale + 1, 32)
else:
self.scale = max(
self.scale <= 1 and self.scale - 0.125 or self.scale - 1, 0.25)
c = a0.pos()
self.viewOrigin[0] = int((self.viewOrigin[0] - c.x()) * self.scale /
lastScale + c.x())
self.viewOrigin[1] = int((self.viewOrigin[1] - c.y()) * self.scale /
lastScale + c.y())
self.pan(0, 0)
return super().wheelEvent(a0)
def wheelEvent(self, event: QtGui.QWheelEvent) -> None:
if (event.modifiers() & QtCore.Qt.ControlModifier
or settings.IMAGE_VIEW_SCROLL_DEFAULT_ZOOM.get_value()):
transform = self.transform()
x_scale, y_scale = transform.m11(), transform.m22()
delta = event.angleDelta().y() / 2000
x_scale, y_scale = [
max(.1, min(4, scale + delta)) for scale in (x_scale, y_scale)
]
old_position = self.mapToScene(event.pos())
self.resetTransform()
self.scale(x_scale, y_scale)
new_position = self.mapToScene(event.pos())
position_delta = new_position - old_position
self.translate(position_delta.x(), position_delta.y())
else:
super().wheelEvent(event)
def process_viewport_wheel_event(self, event: QWheelEvent):
# print("size when wheeling: ", self.view.viewport().size())
zoom_in = self.zoom_step
zoom_out = 1 / zoom_in
zoom_ = zoom_in if event.angleDelta().y() > 0 else zoom_out
self.update_scale(event.pos(), zoom_)
event.accept()
self.on_view_changed()
return True
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: QWheelEvent):
factor = 1.1
if event.angleDelta().x() or event.angleDelta().y() < 0:
factor = 0.9
view_pos = event.pos()
scene_pos = self.mapToScene(view_pos)
self.centerOn(scene_pos)
self.scale(factor, factor)
delta = self.mapToScene(view_pos) - self.mapToScene(
self.viewport().rect().center())
self.centerOn(scene_pos - delta)
def zoom(self, factor, suppress_signal=False, event: QWheelEvent = None):
if factor > 1 and self.view_rect().width() / factor < 300:
factor = self.view_rect().width() / 300
old_pos = self.mapToScene(event.pos()) if event is not None else None
if self.view_rect().width() / factor > self.sceneRect().width():
self.show_full_scene()
factor = 1
self.scale(factor, 1)
if not suppress_signal:
self.zoomed.emit(factor)
if event:
move = self.mapToScene(event.pos()) - old_pos
self.translate(move.x(), 0)
else:
self.centerOn(self.view_rect().x() + self.view_rect().width() / 2,
self.y_center)
def wheelEvent(self, event: QWheelEvent):
"""
Zoom in or out of the view by mouse wheel scroll
"""
zoomInFactor = 1.1
zoomOutFactor = 0.9
# Save the scene pos
oldPos = self.mapToGlobal(event.pos())
# oldPos = self.graphmapToScene(event.pos())
# Zoom
if event.angleDelta().y() > 0:
zoomFactor = zoomInFactor
else:
zoomFactor = zoomOutFactor
self.scale(zoomFactor, zoomFactor)
# Get the new position
newPos = self.mapToScene(event.pos())
# Move scene to old position
delta = newPos - oldPos
self.translate(delta.x(), delta.y())
def wheelEvent(self, event: QWheelEvent):
#------
if self.Clicable:
a = event.angleDelta().y()
self.my_wheel_event_freq.emit(a)
#------
self.wheel_event_triggered.emit(event)
if event.globalPos:
self.scene().get_freq_for_pos(int(self.mapToScene(event.pos()).x()))
# self.my_freq_wheel.emit(freq)
if self.capturing_data:
return
super().wheelEvent(event)
def on_wheel_rotated(self, event: QtGui.QWheelEvent) -> None:
# find the current position in data coordinates
painter = QtGui.QPainter(self)
temp_width = painter.device().width()
x_scale = float(self._display_x_max - self._display_x_min) / float(temp_width)
cur_pos_x = self._display_x_min + event.pos().x() * x_scale
mid_x = 0.5 * (self._display_x_max + self._display_x_min)
# calculate the new display window width
num_steps = event.angleDelta().y() / 120
if num_steps > 0:
# zoom in based on cursor location
wnd_x = 0.25 * (self._display_x_max - self._display_x_min)
else:
# zoom out based on cursor location
wnd_x = self._display_x_max - self._display_x_min
# change the display window based on position
if cur_pos_x < mid_x:
new_left_x = cur_pos_x - wnd_x
if new_left_x < self._scale_x_min:
wnd_x += self._scale_x_min - new_left_x
new_left_x = self._scale_x_min
self._display_x_min = new_left_x
new_right_x = cur_pos_x + wnd_x
self._display_x_max = new_right_x if new_right_x < self._scale_x_max else self._scale_x_max
else:
new_right_x = cur_pos_x + wnd_x
if new_right_x > self._scale_x_max:
wnd_x += new_right_x - self._scale_x_max
new_right_x = self._scale_x_max
self._display_x_max = new_right_x
new_left_x = cur_pos_x - wnd_x
self._display_x_min = new_left_x if new_left_x > self._scale_x_min else self._scale_x_min
# notify others of the zoom
self.rescaled_x.emit()
# update the view
self.update()
def wheelEvent(self, event: QWheelEvent):
factor = 1.1
if event.angleDelta().x() or event.angleDelta().y() < 0:
factor = 0.9
self.b_platform.set_line_width(self.b_platform.line_width + 0.02)
self.b_platform.dot_radius += 0.03
else:
self.b_platform.set_line_width(self.b_platform.line_width - 0.02)
self.b_platform.dot_radius -= 0.03
view_pos = event.pos()
scene_pos = self.mapToScene(view_pos)
self.centerOn(scene_pos)
self.scale(factor, factor)
delta = self.mapToScene(view_pos) - self.mapToScene(
self.viewport().rect().center())
self.centerOn(scene_pos - delta)
self.reload_mat_and_update()
def _on_central_mouse_wheel(self, event: QtGui.QWheelEvent):
# print("_on_central_mouse_wheel")
# add to always request a stop any current GPU work to free it up for scrolling
self._controller.stop_request()
view_state_ = self._view_state
steps: float = self._get_scroll_steps(event)
# print("_on_central_mouse_wheel")
if view_state_.ready_to_zoom:
extra_scaling = 0.9**steps
view_state_.scaling_requested *= extra_scaling
if steps > 0: # zooming in
pos = event.pos()
cursor = self._frame_image_to_frame_cartesian(x=pos.x(),
y=pos.y())
zoom_point = self._get_zoom_point(cursor)
self._zoom(zoom_point)
else: # zooming out, always just go out, no movement
self._zoom()
def wheelEvent(self, event: QtGui.QWheelEvent):
dScale = event.angleDelta().y() / 120.0
if dScale == 0:
return
dScale = 1.10**dScale
# Keep location under mouse during zoom
bKeepLocation = True
if bKeepLocation:
# zoom centered on current mouse pointer location
mouse_pos = WindowPos.from_QPoint(event.pos())
c_args = (self.camera, self.size())
mpc1 = CanvasPos.from_WindowPos(mouse_pos, *c_args)
self.camera.zoom *= dScale
mpc2 = CanvasPos.from_WindowPos(mouse_pos, *c_args)
self.camera.center += mpc1 - mpc2
else:
# zoom centered on widget center
self.camera.zoom *= dScale
self.camera.notify()
def wheelMeasureEvent(
self, measure: measured_track_editor.BaseMeasureEditor, evt: QtGui.QWheelEvent) -> None:
assert isinstance(measure, BeatMeasureEditor), type(measure).__name__
if evt.modifiers() in (Qt.NoModifier, Qt.ShiftModifier):
if evt.modifiers() == Qt.ShiftModifier:
vel_delta = (1 if evt.angleDelta().y() > 0 else -1)
else:
vel_delta = (10 if evt.angleDelta().y() > 0 else -10)
click_time = measure.xToTime(evt.pos().x())
for beat in measure.measure.beats:
if beat.time == click_time:
with self.project.apply_mutations(
'%s: Change beat velocity' % measure.track.name):
beat.velocity = max(0, min(127, beat.velocity + vel_delta))
evt.accept()
return
super().wheelMeasureEvent(measure, evt)
def wheelEvent(self, event: QWheelEvent):
"""
Zoom in/out on the mouse cursor
"""
# zoom only when CTRL key pressed
if (event.modifiers() & Qt.ControlModifier) == Qt.ControlModifier:
steps = event.angleDelta().y() / 15 / 8
if steps == 0:
event.ignore()
return
# scale factor 1.25
sc = pow(1.25, steps)
self.scale(sc, sc)
self.centerOn(self.mapToScene(event.pos()))
event.accept()
# act normally on scrollbar
else:
# transmit event to parent class wheelevent
super(QGraphicsView, self).wheelEvent(event)
def wheelEvent(self, event: QWheelEvent):
"""
Zoom in/out on the mouse cursor
"""
# zoom only when CTRL key pressed
if (event.modifiers() & Qt.ControlModifier) == Qt.ControlModifier:
steps = event.angleDelta().y() / 15 / 8
if steps == 0:
event.ignore()
return
# scale factor 1.25
sc = pow(1.25, steps)
self.scale(sc, sc)
self.centerOn(self.mapToScene(event.pos()))
event.accept()
# act normally on scrollbar
else:
# transmit event to parent class wheelevent
super(QGraphicsView, self).wheelEvent(event)
def wheelEvent(self, event: QWheelEvent):
zoom_factor = 1.001 ** event.angleDelta().y()
self.zoom(zoom_factor, cursor_pos=event.pos())
def wheelEvent(self, event: QWheelEvent):
zoom_factor = 1.001**event.angleDelta().y()
self.zoom(zoom_factor, cursor_pos=event.pos())
class ScrollArea(QScrollArea):
""" 一个可以平滑滚动的区域 """
def __init__(self, parent=None):
super().__init__(parent)
self.fps = 60
self.duration = 400
self.stepsTotal = 0
self.stepRatio = 1.5
self.acceleration = 1
self.lastWheelEvent = None
self.scrollStamps = deque()
self.stepsLeftQueue = deque()
self.smoothMoveTimer = QTimer(self)
self.smoothMode = SmoothMode(SmoothMode.COSINE)
self.smoothMoveTimer.timeout.connect(self.smoothMove)
def setSMoothMode(self, smoothMode):
""" 设置滚动模式 """
self.smoothMode = smoothMode
def wheelEvent(self, e: QWheelEvent):
""" 实现平滑滚动效果 """
if self.smoothMode == SmoothMode.NO_SMOOTH:
super().wheelEvent(e)
return
# 将当前时间点插入队尾
now = QDateTime.currentDateTime().toMSecsSinceEpoch()
self.scrollStamps.append(now)
while now - self.scrollStamps[0] > 500:
self.scrollStamps.popleft()
# 根据未处理完的事件调整移动速率增益
accerationRatio = min(len(self.scrollStamps) / 15, 1)
if not self.lastWheelEvent:
self.lastWheelEvent = QWheelEvent(e)
else:
self.lastWheelEvent = e
# 计算步数
self.stepsTotal = self.fps * self.duration / 1000
# 计算每一个事件对应的移动距离
delta = e.angleDelta().y() * self.stepRatio
if self.acceleration > 0:
delta += delta * self.acceleration * accerationRatio
# 将移动距离和步数组成列表，插入队列等待处理
self.stepsLeftQueue.append([delta, self.stepsTotal])
# 定时器的溢出时间t=1000ms/帧数
self.smoothMoveTimer.start(1000 / self.fps)
def smoothMove(self):
""" 计时器溢出时进行平滑滚动 """
totalDelta = 0
# 计算所有未处理完事件的滚动距离，定时器每溢出一次就将步数-1
for i in self.stepsLeftQueue:
totalDelta += self.subDelta(i[0], i[1])
i[1] -= 1
# 如果事件已处理完，就将其移出队列
while self.stepsLeftQueue and self.stepsLeftQueue[0][1] == 0:
self.stepsLeftQueue.popleft()
# 构造滚轮事件
e = QWheelEvent(self.lastWheelEvent.pos(),
self.lastWheelEvent.globalPos(),
self.lastWheelEvent.pos(),
self.lastWheelEvent.globalPos(),
round(totalDelta),
Qt.Vertical,
self.lastWheelEvent.buttons(),
Qt.NoModifier)
# 将构造出来的滚轮事件发送给app处理
QApplication.sendEvent(self.verticalScrollBar(), e)
# 如果队列已空，停止滚动
if not self.stepsLeftQueue:
self.smoothMoveTimer.stop()
def subDelta(self, delta, stepsLeft):
""" 计算每一步的插值 """
m = self.stepsTotal / 2
x = abs(self.stepsTotal - stepsLeft - m)
# 根据滚动模式计算插值
res = 0
if self.smoothMode == SmoothMode.NO_SMOOTH:
res = 0
elif self.smoothMode == SmoothMode.CONSTANT:
res = delta / self.stepsTotal
elif self.smoothMode == SmoothMode.LINEAR:
res = 2 * delta / self.stepsTotal * (m - x) / m
elif self.smoothMode == SmoothMode.QUADRATI:
res = 3 / 4 / m * (1 - x * x / m / m) * delta
elif self.smoothMode == SmoothMode.COSINE:
res = (cos(x * pi / m) + 1) / (2 * m) * delta
return res
def wheelEvent(self, event: QtGui.QWheelEvent) -> None:
if event.modifiers() & QtCore.Qt.ControlModifier:
self._zoomed(event.angleDelta().y(),
event.pos().x() / self.width())
else:
self._scrolled(event.angleDelta().y())
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)
