def mouseMoveEvent(self, ev: QtGui.QMouseEvent):
if self.last_pos is None:
return
travel_x = ev.globalPos().x() - self.last_pos.x()
travel_y = ev.globalPos().y() - self.last_pos.y()
self.last_pos = ev.globalPos()
pos = self.parent().geometry()
pos.setWidth(pos.width() + travel_x)
pos.setHeight(pos.height() + travel_y)
self.parent().setGeometry(pos)
def mousePressEvent(self, event: QMouseEvent):
if event.button() == Qt.LeftButton:
self.dragPosition = event.globalPos() - self.frameGeometry(
).topLeft()
self.cursor = QCursor()
self.cursor.setShape(Qt.SizeAllCursor)
self.setCursor(self.cursor)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
"""Qt Mouse-Move Event: Window dragging"""
if self.__mouse_pressed and self.__drag_move_enabled:
# CODE TO DETECT DISPLAY CHANGE
# display = self.screen().virtualSiblingAt(event.globalPos()).name()
# if display != self.__old_display:
# print('DISPLAY CHANGED TO %s' % display, self.__old_size)
# self.__old_display = display
self.move(self.__window_pos +
(event.globalPos() - self.__mouse_pos))
def mousePressEvent(self, event: QMouseEvent) -> None:
"""Qt Mouse-Press Event: Window dragging"""
if not self.__drag_move_enabled:
return
radius = self.__style.window.SHADOW_RADIUS_PX if self.__use_shadow else 0
ep = event.pos()
if radius <= ep.y() <= self.__titlebar_height + radius + 1:
epx = ep.x()
if radius < epx < self.width() - radius:
self.__mouse_pressed = True
self.__mouse_pos = event.globalPos()
self.__window_pos = self.pos()
def mouseMoveEvent(self, event: QtGui.QMouseEvent) -> None:
super(DragListWidget, self).mouseMoveEvent(event)
# check if mouse is inside widget
if not self.rect().contains(event.globalPos()):
self._mouseOverIndex = None
pass
# iterate over rects with latest drawn (ie deepest in hierarchy) first
for i, rect in enumerate(reversed(self.dragRects)):
if rect.contains(event.pos()):
self._mouseOverIndex = len(self.dragRects) - i
break
def mouseMoveEvent(self, ev: QtGui.QMouseEvent):
if not self.hasMouseTracking():
# don't accept propagated events
return
pos = self.geometry()
width = pos.width()
height = pos.height()
map = self.parent().mapFromGlobal(ev.globalPos() - self.drag_offset)
pos.setX(map.x())
pos.setY(map.y())
pos.setWidth(width)
pos.setHeight(height)
self.setGeometry(pos)
def mousePressEvent(self, ev: QtGui.QMouseEvent):
if ev.button() == QtCore.Qt.LeftButton:
self.drag_offset = ev.globalPos() - self.parent().mapToGlobal(self.pos())
self.setMouseTracking(True)
ev.accept()
elif ev.button() == QtCore.Qt.RightButton:
"""Open context dialog"""
dialog = QtWidgets.QMenu("Actions")
dialog.setParent(self.parent())
dialog.setStyleSheet("""
QMenu {{
background-color: {};
}}
QMenu::item {{
background-color: transparent;
}}
QMenu::item:selected {{
background-color: {};
color: {};
}}
""".format(PAGE_ITEM_MENU_BG, PAGE_ITEM_MENU_SELECTED, DEFAULT_ITEM_TEXT_COLOR))
close_option = QtWidgets.QAction("Remove", dialog)
close_option.setStatusTip("Delete this text box and all its contents")
close_option.triggered.connect(self.deleteLater)
raise_option = QtWidgets.QAction("Bring To Front", dialog)
# Using parent() (and especially parent().parent()) is extremely fragile.
# TODO make more clear cut ways of retrieving the element we want
raise_option.triggered.connect(lambda: self.raised.emit(self.z_index))
lower_option = QtWidgets.QAction("Send To Back", dialog)
lower_option.triggered.connect(lambda: self.lowered.emit(self.z_index))
rename_option = QtWidgets.QAction("Rename", dialog)
rename_option.triggered.connect(self._rename_dialog)
cancel_option = QtWidgets.QAction("Cancel", dialog)
# Image specific options
if self._type == "image":
edit_image_action = QtWidgets.QAction("Edit Image", dialog)
dialog.addAction(raise_option)
dialog.addAction(lower_option)
dialog.addAction(rename_option)
dialog.addSeparator()
dialog.addAction(close_option)
dialog.addSeparator()
if self._type == "image":
dialog.addAction(edit_image_action)
dialog.addSeparator()
dialog.addAction(cancel_option)
dialog.triggered.connect(lambda _: dialog.deleteLater())
pos = self.mapToGlobal(ev.pos())
dialog.popup(self.parent().parent().mapFromGlobal(pos))
ev.accept()
def on_listwidget_double_cicked(self, evt: QMouseEvent):
print('edit', evt)
pos = evt.globalPos()
current_item: QListWidgetItem = self.list_widget.currentItem()
def set_value():
current_item.setText(self.text_edit.text())
self.text_edit.hide()
self.text_edit.returnPressed.disconnect(set_value)
item: QListWidgetItem = self.list_widget.currentItem()
self.text_edit.setGeometry(pos.x(), pos.y(), 200, 20)
self.text_edit.returnPressed.connect(set_value)
self.text_edit.show()
def mousePressEvent(self, event: QMouseEvent) -> None:
"""Qt Mouse-Press Event"""
self.__mouse_pressed = True
self.__mouse_pos = event.globalPos()
if self.__type == self.TOP:
self.__window_pos_y = self.__parent.pos().y()
self.__window_geometry_x = self.__parent.geometry().x()
elif self.__type in [self.BOTTOM, self.RIGHT, self.BOTTOM_RIGHT]:
self.__window_geometry_x = self.__parent.geometry().x()
self.__window_geometry_y = self.__parent.geometry().y()
elif self.__type == self.LEFT:
self.__window_pos_x = self.__parent.pos().x()
self.__window_geometry_y = self.__parent.geometry().y()
elif self.__type in [self.TOP_LEFT, self.TOP_RIGHT, self.BOTTOM_LEFT]:
self.__window_pos_x = self.__parent.pos().x()
self.__window_pos_y = self.__parent.pos().y()
self.__window_geometry_width = self.__parent.geometry().width()
self.__window_geometry_height = self.__parent.geometry().height()
def mouseMoveEvent(self, event: QMouseEvent) -> None:
"""Qt Mouse-Move Event"""
def get_top_resize_values() -> Tuple[int, int]:
"""calculates vertial position and height"""
py: int = (event.globalPos() - self.__mouse_pos).y()
if self.__window_geometry_height - py < self.__parent.minimumSize(
).height():
height: int = self.__parent.minimumSize().height()
pos_y: int = self.__window_pos_y + self.__window_geometry_height - height
else:
height = self.__window_geometry_height - py
pos_y = self.__window_pos_y + py
return pos_y, height
def get_left_resize_values() -> Tuple[int, int]:
"""calculates horizontal position and width"""
px: int = (event.globalPos() - self.__mouse_pos).x()
if self.__window_geometry_width - px < self.__parent.minimumSize(
).width():
width: int = self.__parent.minimumSize().width()
pos_x: int = self.__window_pos_x + self.__window_geometry_width - width
else:
width = self.__window_geometry_width - px
pos_x = self.__window_pos_x + px
return pos_x, width
if self.__mouse_pressed:
if self.__type == self.BOTTOM:
py = (event.globalPos() - self.__mouse_pos).y()
geometry = QRect(self.__window_geometry_x,
self.__window_geometry_y,
self.__window_geometry_width,
self.__window_geometry_height + py)
elif self.__type == self.RIGHT:
px = (event.globalPos() - self.__mouse_pos).x()
geometry = QRect(self.__window_geometry_x,
self.__window_geometry_y,
self.__window_geometry_width + px,
self.__window_geometry_height)
elif self.__type == self.TOP:
pos_y, height = get_top_resize_values()
geometry = QRect(self.__window_geometry_x, pos_y,
self.__window_geometry_width, height)
elif self.__type == self.LEFT:
pos_x, width = get_left_resize_values()
geometry = QRect(pos_x, self.__window_geometry_y, width,
self.__window_geometry_height)
elif self.__type == self.TOP_LEFT:
pos_x, width = get_left_resize_values()
pos_y, height = get_top_resize_values()
geometry = QRect(pos_x, pos_y, width, height)
elif self.__type == self.TOP_RIGHT:
px = (event.globalPos() - self.__mouse_pos).x()
pos_y, height = get_top_resize_values()
geometry = QRect(self.__window_pos_x, pos_y,
self.__window_geometry_width + px, height)
elif self.__type == self.BOTTOM_LEFT:
pos_x, width = get_left_resize_values()
py = (event.globalPos() - self.__mouse_pos).y()
geometry = QRect(pos_x, self.__window_pos_y, width,
self.__window_geometry_height + py)
elif self.__type == self.BOTTOM_RIGHT:
px = (event.globalPos() - self.__mouse_pos).x()
py = (event.globalPos() - self.__mouse_pos).y()
geometry = QRect(self.__window_geometry_x,
self.__window_geometry_y,
self.__window_geometry_width + px,
self.__window_geometry_height + py)
if geometry.width() < self.__parent.minimumSize().width():
geometry.setWidth(self.__parent.minimumSize().width())
if geometry.height() < self.__parent.minimumSize().height():
geometry.setHeight(self.__parent.minimumSize().height())
self.__parent.setGeometry(geometry)
self.adjust_resizers(geometry)
def mouseMoveEvent(self, e: QtGui.QMouseEvent):
QWidget.mouseMoveEvent(self, e)
if not self.m_isEditing:
return
if not self.m_infocus:
return
if not e.buttons() and QtCore.Qt.LeftButton:
p = QPoint(e.x() + self.geometry().x(),
e.y() + self.geometry().y())
self.setCursorShape(p)
return
if (self.mode == Mode.MOVE or self.mode
== Mode.NONE) and e.buttons() and QtCore.Qt.LeftButton:
toMove = e.globalPos() - self.position
if toMove.x() < 0: return
if toMove.y() < 0: return
if toMove.x() > self.parentWidget().width() - self.width(): return
self.move(toMove)
self.newGeometry.emit(self.geometry())
self.parentWidget().repaint()
return
if (self.mode != Mode.MOVE) and e.buttons() and QtCore.Qt.LeftButton:
if self.mode == Mode.RESIZETL: # Left - Top
newwidth = e.globalX() - self.position.x() - self.geometry().x(
)
newheight = e.globalY() - self.position.y() - self.geometry(
).y()
toMove = e.globalPos() - self.position
self.resize(self.geometry().width() - newwidth,
self.geometry().height() - newheight)
self.move(toMove.x(), toMove.y())
elif self.mode == Mode.RESIZETR: # Right - Top
newheight = e.globalY() - self.position.y() - self.geometry(
).y()
toMove = e.globalPos() - self.position
self.resize(e.x(), self.geometry().height() - newheight)
self.move(self.x(), toMove.y())
elif self.mode == Mode.RESIZEBL: # Left - Bottom
newwidth = e.globalX() - self.position.x() - self.geometry().x(
)
toMove = e.globalPos() - self.position
self.resize(self.geometry().width() - newwidth, e.y())
self.move(toMove.x(), self.y())
elif self.mode == Mode.RESIZEB: # Bottom
self.resize(self.width(), e.y())
elif self.mode == Mode.RESIZEL: # Left
newwidth = e.globalX() - self.position.x() - self.geometry().x(
)
toMove = e.globalPos() - self.position
self.resize(self.geometry().width() - newwidth, self.height())
self.move(toMove.x(), self.y())
elif self.mode == Mode.RESIZET: # Top
newheight = e.globalY() - self.position.y() - self.geometry(
).y()
toMove = e.globalPos() - self.position
self.resize(self.width(), self.geometry().height() - newheight)
self.move(self.x(), toMove.y())
elif self.mode == Mode.RESIZER: # Right
self.resize(e.x(), self.height())
elif self.mode == Mode.RESIZEBR: # Right - Bottom
self.resize(e.x(), e.y())
self.parentWidget().repaint()
self.newGeometry.emit(self.geometry())
# class MainWindow(QMainWindow):
# def __init__(self):
# super().__init__()
# self.showMaximized()
# lab1 = QLabel("Label1")
# lab2 = QLabel("Label2")
# con1 = TContainer(self, QPoint(10,10), lab1)
# con2 = TContainer(self, QPoint(20,50), lab2)
# if __name__ == '__main__':
# app = QApplication(sys.argv)
# ex = MainWindow()
# sys.exit(app.exec_())
def mousePressEvent(self, event: QtGui.QMouseEvent):
self.old_pos = event.globalPos()
def mouseReleaseEvent(self, event: QMouseEvent):
if event.button() == Qt.LeftButton:
self.move(event.globalPos() - self.dragPosition)
self.cursor.setShape(Qt.ArrowCursor)
self.setCursor(self.cursor)
def mouseMoveEvent(self, event: QMouseEvent):
self.move(event.globalPos() - self.dragPosition)
self.update()
def mousePressEvent(self, ev: QtGui.QMouseEvent):
self.last_pos = ev.globalPos()
self.setMouseTracking(True)
def mouse_move_event(self, model, event: QMouseEvent):
if self.common_model.show_cursor_position:
QToolTip.showText(event.globalPos(),
f"{event.globalPos().x()}, {event.globalPos().y()}")
return True
def mouseMoveEvent(self, event: QtGui.QMouseEvent):
teta = QtCore.QPoint(event.globalPos() - self.old_pos)
self.move(self.x() + teta.x(), self.y() + teta.y())
self.old_pos = event.globalPos()
def mouseMoveEvent(self, event: QMouseEvent):
"""
:type event: QMouseEvent
:param event:
:return:
"""
self.mousePoint = QPoint(event.globalPos().x(), event.globalPos().y())
if self.action is None:
self.action = ACTION_SELECT
if not self.mousePressed:
point = QPoint(event.x(), event.y())
self.detect_mouse_position(point)
self.setCursorStyle()
self.redraw()
else:
self.endX, self.endY = event.x(), event.y()
# if self.mousePosition != OUTSIDE_AREA:
# self.action = ACTION_MOVE_SELECTED
if self.action == ACTION_SELECT:
self.selected_area.setBottomRight(QPoint(event.x(), event.y()))
self.redraw()
elif self.action == ACTION_MOVE_SELECTED:
self.selected_area = QRect(self.selectedAreaRaw)
if self.mousePosition == MousePosition.INSIDE_AREA:
move_to_x = event.x(
) - self.startX + self.selected_area.left()
move_to_y = event.y(
) - self.startY + self.selected_area.top()
if 0 <= move_to_x <= self.screenPixel.width(
) - 1 - self.selected_area.width():
self.selected_area.moveLeft(move_to_x)
if 0 <= move_to_y <= self.screenPixel.height(
) - 1 - self.selected_area.height():
self.selected_area.moveTop(move_to_y)
self.selected_area = self.selected_area.normalized()
self.selectedAreaRaw = QRect(self.selected_area)
self.startX, self.startY = event.x(), event.y()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_LEFT_SIDE:
move_to_x = event.x(
) - self.startX + self.selected_area.left()
if move_to_x <= self.selected_area.right():
self.selected_area.setLeft(move_to_x)
self.selected_area = self.selected_area.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_RIGHT_SIDE:
move_to_x = event.x(
) - self.startX + self.selected_area.right()
self.selected_area.setRight(move_to_x)
self.selected_area = self.selected_area.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_UP_SIDE:
move_to_y = event.y(
) - self.startY + self.selected_area.top()
self.selected_area.setTop(move_to_y)
self.selected_area = self.selected_area.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_DOWN_SIDE:
move_to_y = event.y(
) - self.startY + self.selected_area.bottom()
self.selected_area.setBottom(move_to_y)
self.selected_area = self.selected_area.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_TOP_LEFT_CORNER:
move_to_x = event.x(
) - self.startX + self.selected_area.left()
move_to_y = event.y(
) - self.startY + self.selected_area.top()
self.selected_area.setTopLeft(QPoint(move_to_x, move_to_y))
self.selected_area = self.selected_area.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_BOTTOM_RIGHT_CORNER:
move_to_x = event.x(
) - self.startX + self.selected_area.right()
move_to_y = event.y(
) - self.startY + self.selected_area.bottom()
self.selected_area.setBottomRight(
QPoint(move_to_x, move_to_y))
self.selected_area = self.selected_area.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_TOP_RIGHT_CORNER:
move_to_x = event.x(
) - self.startX + self.selected_area.right()
move_to_y = event.y(
) - self.startY + self.selected_area.top()
self.selected_area.setTopRight(QPoint(
move_to_x, move_to_y))
self.selected_area = self.selected_area.normalized()
self.redraw()
elif self.mousePosition == MousePosition.ON_THE_BOTTOM_LEFT_CORNER:
move_to_x = event.x(
) - self.startX + self.selected_area.left()
move_to_y = event.y(
) - self.startY + self.selected_area.bottom()
self.selected_area.setBottomLeft(
QPoint(move_to_x, move_to_y))
self.redraw()
else:
pass
elif self.action == ACTION_RECT:
self.drawRect(self.startX, self.startY, event.x(), event.y(),
False)
self.redraw()
pass
elif self.action == ACTION_ELLIPSE:
self.drawEllipse(self.startX, self.startY, event.x(),
event.y(), False)
self.redraw()
elif self.action == ACTION_ARROW:
self.drawArrow(self.startX, self.startY, event.x(), event.y(),
False)
self.redraw()
elif self.action == ACTION_LINE:
self.drawLine(self.startX, self.startY, event.x(), event.y(),
False)
self.redraw()
elif self.action == ACTION_FREEPEN:
y1, y2 = event.x(), event.y()
rect = self.selected_area.normalized()
if y1 <= rect.left():
y1 = rect.left()
elif y1 >= rect.right():
y1 = rect.right()
if y2 <= rect.top():
y2 = rect.top()
elif y2 >= rect.bottom():
y2 = rect.bottom()
self.pointPath.lineTo(y1, y2)
self.drawFreeLine(self.pointPath, False)
self.redraw()
