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 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):
try:
zoom = super().page().mainFrame().zoomFactor()
if self.ctrlOn is True:
event.accept()
if event.angleDelta().y() > 0:
zoom += 0.2
else:
zoom -= 0.2
if zoom <= 0.2: zoom = 0.2
if zoom >= 3: zoom = 3
print('zoom = {}'.format(zoom))
super().page().mainFrame().setZoomFactor(zoom)
# super().page().repaint()
else:
if self.mode.value == QwwMode.CBZ.value:
super().page().mainFrame().setZoomFactor(1)
event.accept()
passed = 0
if event.angleDelta().y() < 0: passed = 1
elif event.angleDelta().y() > 0: passed = -1
self.updatePositionCbz(passed)
else:
self.updatePositionEpub(event.angleDelta().y() * -1)
event.ignore()
except Exception:
traceback.print_exc()
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, a0: QtGui.QWheelEvent) -> None:
if len(self.tdrWindow.td) == 0:
a0.ignore()
return
chart_height = self.chartHeight
chart_width = self.chartWidth
do_zoom_x = do_zoom_y = True
if a0.modifiers() == QtCore.Qt.ShiftModifier:
do_zoom_x = False
if a0.modifiers() == QtCore.Qt.ControlModifier:
do_zoom_y = False
if a0.angleDelta().y() > 0:
# Zoom in
a0.accept()
# Center of zoom = a0.x(), a0.y()
# We zoom in by 1/10 of the width/height.
rate = a0.angleDelta().y() / 120
if do_zoom_x:
zoomx = rate * chart_width / 10
else:
zoomx = 0
if do_zoom_y:
zoomy = rate * chart_height / 10
else:
zoomy = 0
absx = max(0, a0.x() - self.leftMargin)
absy = max(0, a0.y() - self.topMargin)
ratiox = absx / chart_width
ratioy = absy / chart_height
# TODO: Change zoom to center on the mouse if possible, or extend box to the side that has room if not.
p1x = int(self.leftMargin + ratiox * zoomx)
p1y = int(self.topMargin + ratioy * zoomy)
p2x = int(self.leftMargin + chart_width - (1 - ratiox) * zoomx)
p2y = int(self.topMargin + chart_height - (1 - ratioy) * zoomy)
self.zoomTo(p1x, p1y, p2x, p2y)
elif a0.angleDelta().y() < 0:
# Zoom out
a0.accept()
# Center of zoom = a0.x(), a0.y()
# We zoom out by 1/9 of the width/height, to match zoom in.
rate = -a0.angleDelta().y() / 120
if do_zoom_x:
zoomx = rate * chart_width / 9
else:
zoomx = 0
if do_zoom_y:
zoomy = rate * chart_height / 9
else:
zoomy = 0
absx = max(0, a0.x() - self.leftMargin)
absy = max(0, a0.y() - self.topMargin)
ratiox = absx / chart_width
ratioy = absy / chart_height
p1x = int(self.leftMargin - ratiox * zoomx)
p1y = int(self.topMargin - ratioy * zoomy)
p2x = int(self.leftMargin + chart_width + (1 - ratiox) * zoomx)
p2y = int(self.topMargin + chart_height + (1 - ratioy) * zoomy)
self.zoomTo(p1x, p1y, p2x, p2y)
else:
a0.ignore()
def on_wheel_turn(self, event: QtGui.QWheelEvent) -> None:
if event.modifiers() & PAN_X_MODIFIER:
self._api.video.view.pan_x += event.angleDelta().y() / 15 / 100
elif event.modifiers() & PAN_Y_MODIFIER:
self._api.video.view.pan_y += event.angleDelta().y() / 15 / 100
else:
self._api.video.view.zoom += event.angleDelta().y() / 15 / 100
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: 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, a0: QtGui.QWheelEvent) -> None:
if len(self.data) == 0 and len(self.reference) == 0:
a0.ignore()
return
do_zoom_x = do_zoom_y = True
if a0.modifiers() == QtCore.Qt.ShiftModifier:
do_zoom_x = False
if a0.modifiers() == QtCore.Qt.ControlModifier:
do_zoom_y = False
if a0.angleDelta().y() > 0:
# Zoom in
a0.accept()
# Center of zoom = a0.x(), a0.y()
# We zoom in by 1/10 of the width/height.
rate = a0.angleDelta().y() / 120
if do_zoom_x:
zoomx = rate * self.chartWidth / 10
else:
zoomx = 0
if do_zoom_y:
zoomy = rate * self.chartHeight / 10
else:
zoomy = 0
absx = max(0, a0.x() - self.leftMargin)
absy = max(0, a0.y() - self.topMargin)
ratiox = absx / self.chartWidth
ratioy = absy / self.chartHeight
p1x = int(self.leftMargin + ratiox * zoomx)
p1y = int(self.topMargin + ratioy * zoomy)
p2x = int(self.leftMargin + self.chartWidth - (1 - ratiox) * zoomx)
p2y = int(self.topMargin + self.chartHeight - (1 - ratioy) * zoomy)
self.zoomTo(p1x, p1y, p2x, p2y)
elif a0.angleDelta().y() < 0:
# Zoom out
a0.accept()
# Center of zoom = a0.x(), a0.y()
# We zoom out by 1/9 of the width/height, to match zoom in.
rate = -a0.angleDelta().y() / 120
if do_zoom_x:
zoomx = rate * self.chartWidth / 9
else:
zoomx = 0
if do_zoom_y:
zoomy = rate * self.chartHeight / 9
else:
zoomy = 0
absx = max(0, a0.x() - self.leftMargin)
absy = max(0, a0.y() - self.topMargin)
ratiox = absx / self.chartWidth
ratioy = absy / self.chartHeight
p1x = int(self.leftMargin - ratiox * zoomx)
p1y = int(self.topMargin - ratioy * zoomy)
p2x = int(self.leftMargin + self.chartWidth + (1 - ratiox) * zoomx)
p2y = int(self.topMargin + self.chartHeight + (1 - ratioy) * zoomy)
self.zoomTo(p1x, p1y, p2x, p2y)
else:
a0.ignore()
def wheelEvent(self, event: QWheelEvent) -> None:
y_delta = event.angleDelta().y()
if y_delta:
notches = ceil(y_delta / 120)
self._v_scrollbar.setValue(self._v_scrollbar.value() - notches)
x_delta = event.angleDelta().x()
if x_delta:
notches = ceil(x_delta / 120)
self._h_scrollbar.setValue(self._h_scrollbar.value() - notches)
def wheel_callback(self, event: QtGui.QWheelEvent):
self.zoom_level += (event.angleDelta().y()) / (abs(
event.angleDelta().y())) * 0.05
if self.zoom_level < 0.05:
self.zoom_level = 0.05
if self.zoom_level > 10:
self.zoom_level = 10
self.update_zoom_level()
def wheelEvent(self, event: QWheelEvent) -> None:
# print(click_descriptor(event, 'scroll'))
# Zoom on Ctrl-scroll
if with_control_key(event) and event.angleDelta().y():
if event.angleDelta().y() > 0:
self.zoom_in()
else:
self.zoom_out()
else:
super().wheelEvent(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 wheelEvent(self, event: QtGui.QWheelEvent) -> None:
"""
Performs zoom in & out according to mousewheel moves
:param event: The Qt wheel event
:type event: QtGui.QWheelEvent
"""
if event.angleDelta().y() > 0:
self.scale(ImageView._ZOOM_FACTOR, ImageView._ZOOM_FACTOR)
elif event.angleDelta().y() < 0:
self.scale(1 / ImageView._ZOOM_FACTOR, 1 / ImageView._ZOOM_FACTOR)
def wheelEvent(self, event: QtGui.QWheelEvent) -> None:
modifiers = event.modifiers()
angle = event.angleDelta()
print(f'common angle = {angle}')
if modifiers == QtCore.Qt.ControlModifier:
print(f'mods = {modifiers}')
angle = event.angleDelta()
if angle.y() > 0:
self.zoom_in()
elif angle.y() < 0:
self.zoom_out()
event.accept()
def wheelEvent(self, event: QWheelEvent):
if self.__controlIsPressed:
if self.zoom + 0.005 * event.angleDelta().y() > 0:
self.zoom += 0.005 * event.angleDelta().y()
else:
self.zoom = 0.1
self.__zoomed = True
else:
self.verticalScrollbar.setValue(self.verticalScrollbar.value() -
event.angleDelta().y())
self.__viewchanged = True
self.update()
def wheelEvent(self, event: QtGui.QWheelEvent) -> None:
if event.angleDelta().isNull():
return
# if event.modifiers() != QtCore.Qt.ControlModifier:
return
numDegrees = event.angleDelta().y() / 8;
numSteps = numDegrees / 15
if numSteps > 0:
self._num_vertices += 1
self.update()
elif numSteps < 0 and self._num_vertices>10:
self._num_vertices -= 1
self.update()
def wheelEvent(self, a0: QtGui.QWheelEvent) -> None:
if ((len(self.data) == 0 and len(self.reference) == 0)
or a0.angleDelta().y() == 0):
a0.ignore()
return
do_zoom_x = do_zoom_y = True
if a0.modifiers() == QtCore.Qt.ShiftModifier:
do_zoom_x = False
if a0.modifiers() == QtCore.Qt.ControlModifier:
do_zoom_y = False
self._wheel_zomm(a0, do_zoom_x, do_zoom_y,
math.copysign(1,
a0.angleDelta().y()))
def wheelEvent(self, a0: QWheelEvent):
if(a0.modifiers() == QtCore.Qt.NoModifier):
dz = a0.angleDelta().y() * 0.01
self.DistanceStack[self.activeCamStackIdx] *= math.pow(1.2, -dz)
self.DistanceStack[self.activeCamStackIdx] = self.SceneUserLimit if (self.DistanceStack[self.activeCamStackIdx] > self.SceneUserLimit) else self.DistanceStack[self.activeCamStackIdx]
if (a0.modifiers() == QtCore.Qt.ControlModifier):
dz = a0.angleDelta().y() * 0.005
Val = self.FOVYStack[self.activeCamStackIdx] * math.pow(1.2, -dz)
if Val > 1 and Val < 360:
self.FOVYStack[self.activeCamStackIdx] = Val
self.update()
def mouse_scroll_event(self, a0: QtGui.QWheelEvent):
if self.selected_side:
self.side_mode = True
if self.drawing_mode.is_active() and (not self.ctrl_pressed):
self.drawing_mode.drawing_strategy.register_scrolling(
a0.angleDelta().y())
elif self.side_mode and self.bbox_controler.has_active_bbox():
self.bbox_controler.get_active_bbox().change_side(
self.selected_side,
-a0.angleDelta().y() / 4000) # ToDo implement method
else:
self.pcd_controler.zoom_into(a0.angleDelta().y())
self.scroll_mode = True
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, 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 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):
"""
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: 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, a0: QWheelEvent) -> None:
if a0.modifiers() & Qt.ControlModifier:
# ctrl press + scroll
delta = a0.angleDelta().y()
self.ctrlWheelScrolled.emit(delta)
else:
super(BasicTreeView, self).wheelEvent(a0)
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) -> None:
if self.parent.mediaAvailable:
if event.angleDelta().y() > 0:
self.parent.mpvWidget.frameBackStep()
else:
self.parent.mpvWidget.frameStep()
event.accept()
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()
# print(delta_x, delta_y)
# else:
delta_x = event.angleDelta().x()
delta_y = event.angleDelta().y()
self.model.change_x_range(delta_y)
self.model.change_x_pos(delta_x)
super().wheelEvent(event)
def wheelEvent(self, e: QWheelEvent):
super(_DialLineEdit, self).wheelEvent(e)
turns = e.angleDelta().y() // 120
try:
val = float(self.text())
except ValueError:
return
lb = self.lb_val()
ub = self.ub_val()
if lb is None or ub is None:
return
coef = turns / 10 if turns > 0 else turns / 11
val += val * np.sign(
val) * coef # increase/decrease in 10th of original value
if val < lb:
val = lb
if val > ub:
val = ub
self.setText(f'{val:.4g}')
self.simulation_requested.emit()
def _prev_or_next_track(self, event: QtGui.QWheelEvent) -> None:
with self.exception_guard():
self._connection.send(
[
"script-message-to",
"playlist",
"playlist-next"
if event.angleDelta().y() > 0
else "playlist-prev",
]
)
self.refresh()
self.render()
def wheelEvent(self, event: QtGui.QWheelEvent):
if self.hasImage:
factor=event.angleDelta().y()/120
if factor>0:
#self.transform变换，获取放缩后的倍数，在变换的基础上
s = self.transform().scale(1.1, 1.1).mapRect(QtCore.QRectF(0, 0, 1, 1)).width()
self.scale(1.1,1.1)
#print(self.transform().scale(factor*10,factor*10))
else:
s = self.transform().scale(0.9,0.9).mapRect(QtCore.QRectF(0, 0, 1, 1)).width()
self.scale(0.9,0.9)
self.scale_factor = s
def _wheel(self, event: QtGui.QWheelEvent) -> None:
with self.exception_guard():
workspace_widgets = list(self._workspace_widgets)
focused_widget_idx = None
for i, workspace_widget in enumerate(workspace_widgets):
workspace = self._widget_to_workspace(workspace_widget)
if workspace.focused:
focused_widget_idx = i
break
if focused_widget_idx is None:
return
focused_widget_idx += 1 if event.angleDelta().y() > 0 else -1
focused_widget_idx %= len(workspace_widgets)
focused_workspace = self._widget_to_workspace(
workspace_widgets[focused_widget_idx]
)
run(["bspc", "desktop", "-f", focused_workspace.name or "?"])
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):
self.safeScale(event.angleDelta().y())
def wheelEvent(self, event: QWheelEvent):
zoom_factor = 1.001 ** event.angleDelta().y()
self.zoom(zoom_factor, cursor_pos=event.pos())
