def mouseDoubleClickEvent(
self, event: QtWidgets.QGraphicsSceneMouseEvent) -> None:
"""Intercept events and pass to overlay."""
view_pos = event.widget().mapFromGlobal(event.screenPos())
for item in self.overlayitems:
if item.contains(view_pos, event.widget().rect()):
item.item.mouseDoubleClickEvent(event)
def sceneMousePressEvent(self, event: QGraphicsSceneMouseEvent):
if self.state == QLiberationMapState.MOVING_UNIT:
if event.buttons() == Qt.RightButton:
pass
elif event.buttons() == Qt.LeftButton:
if self.selected_cp is not None:
# Set movement position for the cp
pos = event.scenePos()
point = Point(int(pos.x()), int(pos.y()))
proj = self._scene_to_dcs_coords(point)
if self.is_valid_ship_pos(point):
self.selected_cp.control_point.target_position = proj
else:
self.selected_cp.control_point.target_position = None
GameUpdateSignal.get_instance().updateGame(
self.game_model.game)
else:
return
self.state = QLiberationMapState.NORMAL
try:
self.scene().removeItem(self.movement_line)
except:
pass
self.selected_cp = None
def mouseReleaseEvent(self,
event: QtWidgets.QGraphicsSceneMouseEvent) -> None:
if not event.button() & QtCore.Qt.LeftButton:
return
modes = list(self.modifierModes(event.modifiers()))
pixel = self.pixelSize()
array = polygonf_to_array(self.poly)
# Get start and end points of area
x1, x2 = np.amin(array[:, 0]), np.amax(array[:, 0])
y1, y2 = np.amin(array[:, 1]), np.amax(array[:, 1])
# Bound to image area
x1, y1 = max(x1, 0.0), max(y1, 0.0)
x2 = min(x2, self.rect.width() - pixel.width() / 2.0)
y2 = min(y2, self.rect.height() - pixel.height() / 2.0)
# Generate pixel centers
xs = np.arange(x1, x2, pixel.width()) + pixel.width() / 2.0
ys = np.arange(y1, y2, pixel.height()) + pixel.height() / 2.0
X, Y = np.meshgrid(xs, ys)
pixels = np.stack((X.flat, Y.flat), axis=1)
# Get mask of selected area
mask = np.zeros(self.image_shape, dtype=bool)
polymask = polygonf_contains_points(self.poly,
pixels).reshape(ys.size, xs.size)
# Insert
ix, iy = int(x1 / pixel.width()), int(y1 / pixel.height())
mask[iy:iy + ys.size, ix:ix + xs.size] = polymask
# self.poly.append(self.poly.first())
self.poly.clear()
self.prepareGeometryChange()
self.selectionChanged.emit(mask, modes)
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):
super(QGraphicsBlockItem, self).mouseMoveEvent(event)
self.setPos(event.scenePos() - event.buttonDownPos(Qt.MouseButton.LeftButton))
self.c, self.cS = self.closestItem()
imgPosibleConnectH = self.scene().imgPosibleConnectH
imgPosibleConnectV = self.scene().imgPosibleConnectV
if self.c is not None:
if self.c.type is ConnectionType.TOP:
imgPosibleConnectH.setPos(self.c.parent.pos())
imgPosibleConnectH.setVisible(True)
imgPosibleConnectH.setZValue(1)
elif self.c.type is ConnectionType.BOTTOM:
imgPosibleConnectH.setPos(self.c.parent.pos() + QPointF(0, self.c.parent.pixmap().height() - 5))
imgPosibleConnectH.setVisible(True)
imgPosibleConnectH.setZValue(1)
elif self.c.type is ConnectionType.RIGHT:
imgPosibleConnectV.setPos(
self.c.parent.pos() + QPointF(self.c.parent.pixmap().width() - 5, 0) + QPointF(0, 5))
imgPosibleConnectV.setVisible(True)
imgPosibleConnectV.setZValue(1)
elif self.c.type is ConnectionType.LEFT:
imgPosibleConnectV.setPos(self.c.parent.pos() + QPointF(0, 5))
imgPosibleConnectV.setVisible(True)
imgPosibleConnectV.setZValue(1)
elif self.c.type is ConnectionType.BOTTOMIN:
imgPosibleConnectH.setPos(self.c.parent.pos() + QPointF(16, 38))
imgPosibleConnectH.setVisible(True)
imgPosibleConnectH.setZValue(1)
else:
imgPosibleConnectH.setVisible(False)
imgPosibleConnectV.setVisible(False)
def mousePressEvent(self,
event: QtWidgets.QGraphicsSceneMouseEvent) -> None:
if not event.button() & QtCore.Qt.LeftButton:
return
self._rect.setTopLeft(event.pos())
self._rect.setBottomRight(event.pos())
self.prepareGeometryChange()
def mouseDoubleClickEvent(self, event:QtWidgets.QGraphicsSceneMouseEvent) -> None:
""""""
super(MouseDragScene, self).mouseDoubleClickEvent(event)
if event.isAccepted():
return
if self.items(event.pos()):
self.itemsDoubleClicked.emit({"items" : self.items(event.pos())})
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):
if event.buttons() and Qt.LeftButton:
self.__m_point = self.mapToParent(event.pos())
self.setPos(self.__m_point)
self.scene().update()
super().mouseMoveEvent(event)
def mousePressEvent(self,
event: QtWidgets.QGraphicsSceneMouseEvent) -> None:
if not event.button() & QtCore.Qt.LeftButton:
return
self.poly.clear()
self.poly.append(self.snapPos(event.pos()))
self.prepareGeometryChange()
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):
box = QRectF(self.buttonDownRect)
pos = event.pos()
offset = pos - event.buttonDownPos(Qt.LeftButton)
if self.handleSelected is None:
box.translate(offset)
new_box = box
elif self.handleSelected == 0:
pos = box.topLeft() + offset
new_size = box.bottomRight() - pos
width = max(new_size.x(), 0)
height = max(new_size.y(), 0)
left = min(pos.x(), box.right())
top = min(pos.y(), box.bottom())
new_box = QRectF(left, top, width, height)
elif self.handleSelected == 1:
pos = box.topLeft() + offset
height = max(box.bottom() - pos.y(), 0)
top = min(pos.y(), box.bottom())
new_box = QRectF(box.left(), top, box.width(), height)
elif self.handleSelected == 2:
pos = box.topRight() + offset
top = min(pos.y(), box.bottom())
width = max(pos.x() - box.left(), 0)
height = max(box.bottom() - pos.y(), 0)
new_box = QRectF(box.left(), top, width, height)
elif self.handleSelected == 3:
pos = box.topRight() + offset
width = max(pos.x() - box.left(), 0)
new_box = QRectF(box.left(), box.top(), width, box.height())
elif self.handleSelected == 4:
pos = box.bottomRight() + offset
new_size = pos - box.topLeft()
width = max(new_size.x(), 0)
height = max(new_size.y(), 0)
new_box = QRectF(box.left(), box.top(), width, height)
elif self.handleSelected == 5:
pos = box.bottomRight() + offset
height = max(pos.y() - box.top(), 0)
new_box = QRectF(box.left(), box.top(), box.width(), height)
elif self.handleSelected == 6:
pos = box.bottomLeft() + offset
left = min(pos.x(), box.right())
width = max(box.right() - pos.x(), 0)
height = max(pos.y() - box.top(), 0)
new_box = QRectF(left, box.top(), width, height)
elif self.handleSelected == 7:
pos = box.bottomLeft() + offset
left = min(pos.x(), box.right())
width = max(box.right() - pos.x(), 0)
new_box = QRectF(left, box.top(), width, box.height())
new_box = QRectF(round(new_box.left()), round(new_box.top()),
round(new_box.width()), round(new_box.height()))
self.setRect(new_box)
self.setHandlesPos()
self.signalHandler.boxChanged.emit(self.tabIndex, self.rowIndex,
new_box)
def sceneMouseMovedEvent(self, event: QGraphicsSceneMouseEvent):
if self.game is None:
return
mouse_position = Point(event.scenePos().x(), event.scenePos().y())
if self.state == QLiberationMapState.MOVING_UNIT:
self.setCursor(Qt.PointingHandCursor)
self.movement_line.setLine(
QLineF(self.movement_line.line().p1(), event.scenePos())
)
if self.is_valid_ship_pos(mouse_position):
self.movement_line.setPen(CONST.COLORS["green"])
else:
self.movement_line.setPen(CONST.COLORS["red"])
mouse_world_pos = self._scene_to_dcs_coords(mouse_position)
if DisplayOptions.navmeshes.blue_navmesh:
self.highlight_mouse_navmesh(
self.scene(),
self.game.blue_navmesh,
self._scene_to_dcs_coords(mouse_position),
)
if DisplayOptions.path_debug.shortest_path:
self.draw_shortest_path(
self.scene(), self.game.blue_navmesh, mouse_world_pos, player=True
)
if DisplayOptions.navmeshes.red_navmesh:
self.highlight_mouse_navmesh(
self.scene(), self.game.red_navmesh, mouse_world_pos
)
debug_blue = DisplayOptions.path_debug_faction.blue
if DisplayOptions.path_debug.shortest_path:
self.draw_shortest_path(
self.scene(),
self.game.navmesh_for(player=debug_blue),
mouse_world_pos,
player=False,
)
elif not DisplayOptions.path_debug.hide:
if DisplayOptions.path_debug.barcap:
task = FlightType.BARCAP
elif DisplayOptions.path_debug.cas:
task = FlightType.CAS
elif DisplayOptions.path_debug.sweep:
task = FlightType.SWEEP
elif DisplayOptions.path_debug.strike:
task = FlightType.STRIKE
elif DisplayOptions.path_debug.tarcap:
task = FlightType.TARCAP
else:
raise ValueError("Unexpected value for DisplayOptions.path_debug")
self.draw_test_flight_plan(
self.scene(), task, mouse_world_pos, player=debug_blue
)
def mouseMoveEvent(self,
event: QtWidgets.QGraphicsSceneMouseEvent) -> None:
if not event.buttons() & QtCore.Qt.LeftButton:
return
if self.poly.size() == 0:
return
pos = self.snapPos(event.pos())
if self.poly.last() != pos:
self.poly.append(pos)
self.prepareGeometryChange()
def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
movingItem = self.itemAt(event.scenePos(), self.view.transform())
if movingItem is None and event.button() is Qt.MouseButton.RightButton:
self.popMenu.exec_(event.screenPos())
if movingItem is not None and event.button(
) is Qt.MouseButton.LeftButton:
self.oldPos = movingItem.pos()
self.clearSelection()
super(Scene, self).mousePressEvent(event)
def sceneMouseMovedEvent(self, event: QGraphicsSceneMouseEvent):
if self.state == QLiberationMapState.MOVING_UNIT:
self.setCursor(Qt.PointingHandCursor)
self.movement_line.setLine(
QLineF(self.movement_line.line().p1(), event.scenePos()))
pos = Point(event.scenePos().x(), event.scenePos().y())
if self.is_valid_ship_pos(pos):
self.movement_line.setPen(CONST.COLORS["green"])
else:
self.movement_line.setPen(CONST.COLORS["red"])
def mousePressEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent):
if event.buttons() & QtCore.Qt.LeftButton:
if (
self.image.rect.left() < event.pos().x() < self.image.rect.right()
and self.image.rect.top() < event.pos().y() < self.image.rect.bottom()
):
self.line.setPoints(event.pos(), event.pos())
self.sliced = None
self.poly = QtGui.QPolygonF()
self.prepareGeometryChange()
super().mousePressEvent(event)
def mouseMoveEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent):
if event.buttons() & QtCore.Qt.LeftButton:
pos = self.line.p2()
if self.image.rect.left() < event.pos().x() < self.image.rect.right():
pos.setX(event.pos().x())
if self.image.rect.top() < event.pos().y() < self.image.rect.bottom():
pos.setY(event.pos().y())
self.line.setP2(pos)
self.createSlicePoly()
self.prepareGeometryChange()
super().mouseMoveEvent(event)
def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
if self.isEnabled():
self.setZValue(1)
if event.button() is Qt.MouseButton.LeftButton:
pass
# self.posmouseinItem = event.scenePos() - self.pos()
# items = self.scene().selectedItems()
# if self not in items:
# self.scene().clearSelection()
# if self.DialogVar is not None:
# self.DialogVar.close()
if event.button() is Qt.MouseButton.RightButton:
self.popMenu.exec_(event.screenPos())
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):
if (QLineF(event.screenPos(), event.buttonDownScreenPos(
Qt.LeftButton)).length() < QApplication.startDragDistance()):
return
self.parentItem().edgeDragStart()
package = QMimeData()
package.setData(self.DragMimeType, bytes())
drag = QDrag(event.widget())
drag.setMimeData(package)
drag.exec_()
self.parentItem().edgeDragStop()
def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
if event.button() == Qt.LeftButton and \
event.modifiers() & Qt.ControlModifier:
tabIndex = self.tabWidget.currentIndex()
tabName = self.tabWidget.tabText(tabIndex)
rowIndex = self.tabWidget.getCurrentTableModel().rowCount(
QModelIndex())
label = self.comboBox.currentText()
box = QRectF(event.buttonDownScenePos(Qt.LeftButton), QSizeF(1, 1))
color = self.tabWidget.color_map(tabIndex)[label]
rect = self.addBox(tabIndex, tabName, rowIndex, self.page, label,
box, color)
rect.handleSelected = 4
self.signalHandler.boxCreated.emit(rect)
super().mousePressEvent(event)
def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
"""Implementation.
A left-click places a tile on a grid space, while a right-click removes a
tile.
"""
editor = self._editor
pos = event.buttonDownScenePos(event.button())
if editor.validGridPos(pos, scene=True):
self.lastTilePos = editor.sceneToGrid(pos)
if event.button() is Qt.LeftButton:
return self.handleLeftButton(pos)
elif event.button() is Qt.RightButton:
return self.handleRightButton(pos)
def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent):
if self.m_Item is not None and event.button() == Qt.LeftButton:
self.itemLock.emit(self.m_Item)
if self.m_oldPos != self.m_Item.pos():
self.itemMoveSignal.emit(self.m_Item, self.m_oldPos)
self.m_Item = None
super(GraphicsScene, self).mouseReleaseEvent(event)
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):
if event.buttons() and Qt.LeftButton:
item = self.collidingItem()
if item is not None:
self.setBezierEdges(item)
super().mouseMoveEvent(event)
def test_clear_notifications(self):
with patch("PySide2.QtWidgets.QToolTip.showText") as show_text:
icon = ExclamationIcon(None)
icon.add_notification("Please note!")
icon.clear_notifications()
icon.hoverEnterEvent(QGraphicsSceneMouseEvent())
show_text.assert_not_called()
def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
self.signalHandler.boxPressed.emit(self.tabIndex, self.rowIndex)
self.buttonDownRect = QRectF(self.rect())
for i, handle in enumerate(self.handles):
if handle.boundingRect().contains(event.pos()):
if self.handleSelected is None:
self.handleSelected = i
def hoverMoveEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent) -> None:
if self.isSelected():
edge = self.edgeAt(event.pos())
if edge is None:
self.setCursor(QtCore.Qt.ArrowCursor)
else:
self.setCursor(self.cursors[edge])
super().hoverMoveEvent(event)
def test_drag_icon(self):
icon = ProjectItemIcon(self._toolbox, "", QColor(Qt.gray),
QColor(Qt.green))
self.assertEqual(icon.x(), 0.0)
self.assertEqual(icon.y(), 0.0)
icon.mousePressEvent(
QGraphicsSceneMouseEvent(QEvent.GraphicsSceneMousePress))
icon.mouseMoveEvent(
QGraphicsSceneMouseEvent(QEvent.GraphicsSceneMouseMove))
icon.moveBy(99.0, 88.0)
icon.mouseReleaseEvent(
QGraphicsSceneMouseEvent(QEvent.GraphicsSceneMouseRelease))
self.assertEqual(icon.x(), 99.0)
self.assertEqual(icon.y(), 88.0)
self.assertEqual(self._toolbox.undo_stack.count(), 1)
move_command = self._toolbox.undo_stack.command(0)
self.assertIsInstance(move_command, MoveIconCommand)
def mouseMoveEvent(self, sceneMouseEvent: QGraphicsSceneMouseEvent):
mousePoint = sceneMouseEvent.scenePos()
mouseRow, mouseColumn = round(mousePoint.x()), round(mousePoint.y())
row, column = self.tetris.falling_tetrimino.row, self.tetris.falling_tetrimino.column
if mouseColumn - column > 0:
self.tetris.move_right()
if mouseColumn - column < 0:
self.tetris.move_left()
def test_drag_icon(self):
item = add_view(self._toolbox.project(), "View")
icon = item.get_icon()
self.assertEqual(icon.x(), 0.0)
self.assertEqual(icon.y(), 0.0)
icon.mousePressEvent(
QGraphicsSceneMouseEvent(QEvent.GraphicsSceneMousePress))
icon.mouseMoveEvent(
QGraphicsSceneMouseEvent(QEvent.GraphicsSceneMouseMove))
icon.moveBy(99.0, 88.0)
icon.mouseReleaseEvent(
QGraphicsSceneMouseEvent(QEvent.GraphicsSceneMouseRelease))
self.assertEqual(icon.x(), 99.0)
self.assertEqual(icon.y(), 88.0)
self.assertEqual(self._toolbox.undo_stack.count(),
2) # First in the stack is Add item command
move_command = self._toolbox.undo_stack.command(1)
self.assertIsInstance(move_command, MoveIconCommand)
def mouseMoveEvent(self, sceneMouseEvent: QGraphicsSceneMouseEvent):
mousePoint = sceneMouseEvent.scenePos()
mouseRow, mouseColumn = round(mousePoint.x()), round(
mousePoint.y())
row, column = self.tetris.falling_tetrimino.row, self.tetris.falling_tetrimino.column
if mouseColumn - column > 0:
self.tetris.move_right()
if mouseColumn - column < 0:
self.tetris.move_left()
def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent):
if len(self.selectedItems()) is not 0:
movingItem = self.selectedItems()[0]
else:
movingItem = None
if movingItem is not None and event.button(
) is Qt.MouseButton.LeftButton:
if self.oldPos is not movingItem.pos():
self.undoStack.push(MoveCommand(movingItem, self.oldPos, self))
super(Scene, self).mouseReleaseEvent(event)
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):
"""Implementation.
Handles mouse movement events in the editor. Dragging the mouse with a
button pressed will place or remove all tiles passed over.
"""
editor = self._editor
pos = event.scenePos()
tilePos = editor.sceneToGrid(pos)
item = editor.itemAt(pos, QTransform())
if tilePos != self.lastTilePos:
self.lastTilePos = tilePos
if editor.validGridPos(tilePos):
if event.buttons() & Qt.LeftButton:
return self.handleLeftButton(pos)
elif event.buttons() & Qt.RightButton:
return self.handleRightButton(pos)
def mousePressEvent(self, event: QGraphicsSceneMouseEvent):
accept = False
if event.button() == Qt.LeftButton and QApplication.keyboardModifiers() in (Qt.NoModifier, Qt.ControlModifier):
# toggle selection
self.infodock.toggle_instruction_selection(
self.addr,
insn_pos=self.scenePos(),
unique=QApplication.keyboardModifiers() != Qt.ControlModifier)
accept = True
if event.button() == Qt.RightButton and QApplication.keyboardModifiers() == Qt.NoModifier:
if self.addr not in self.infodock.selected_insns:
self.infodock.toggle_instruction_selection(self.addr, insn_pos=self.scenePos(), unique=True)
self.disasm_view.instruction_context_menu(self.insn, QCursor.pos())
accept = True
if self.workspace.plugins.handle_click_insn(self, event):
accept = True
if accept:
event.accept()
else:
super().mousePressEvent(event)
def mouseReleaseEvent(self, sceneMouseEvent: QGraphicsSceneMouseEvent):
if sceneMouseEvent.button() == Qt.LeftButton:
self.tetris.drop()
if sceneMouseEvent.button() == Qt.RightButton:
self.tetris.rotate()