• Qt第二十七章：QWidget、QMainWindow自定义标题栏并自由移动缩放

    前提：UI必須采用自适应布局。 

    1. 自定义组件【直接CV】custom_components.py 
      1. # 自定义组件
      2. """
      3. QCustomTitleBar:自定义标题
      4. QWindowMoveResize：自定义缩放和拖动
      5. """
      6. import PySide6.QtGui
      7. from PySide6.QtGui import QPainter, QBrush
      8. from PySide6 import QtGui, QtWidgets, QtCore
      9. from PySide6.QtCore import Qt, QSize, QRect
      10. from PySide6.QtWidgets import QPushButton, QLabel, QWidget, QProgressBar, QHBoxLayout, QDialog
      11.  
      12.  
      13. # 自定义标题栏
      14. class QCustomTitleBar:
      15.     def __init__(self, window: QtWidgets):
      16.         self.window = window
      17.         # 默认标题栏高度 必须设
      18.         self.DEFAULT_TITILE_BAR_HEIGHT = 40
      19.         # 存储父类的双击事件
      20.         self.mouseDoubleClickEvent_parent = self.window.mouseDoubleClickEvent
      21.         # 将本类的双击事件赋值给将父类的双击事件
      22.         self.window.mouseDoubleClickEvent = self.mouseDoubleClickEvent
      23.  
      24.         # 存储父类的窗口大小改变事件
      25.         self.resizeEvent_parent = self.window.resizeEvent
      26.         # 将本类的窗口大小改变事件赋值给将父类的窗口大小改变事件
      27.         self.window.resizeEvent = self.resizeEvent
      28.  
      29.         # 设置ui文件里main_layout上边距，以免遮挡标题栏
      30.         self.window.setContentsMargins(0, self.DEFAULT_TITILE_BAR_HEIGHT, 0, 0)
      31.  
      32.         # 1.设置无边框 和 透明背景 无边框必须设置全，不然会导致点击任务栏不能最小化窗口
      33.         self.window.setWindowFlags(
      34.             Qt.Window
      35.             | Qt.FramelessWindowHint
      36.             | Qt.WindowSystemMenuHint
      37.             | Qt.WindowMinimizeButtonHint
      38.             | Qt.WindowMaximizeButtonHint
      39.         )
      40.         # self.window.setAttribute(Qt.WA_TranslucentBackground)
      41.         # 2.添加自定义的标题栏到最顶部
      42.         self.title = QLabel("", self.window)
      43.         # 3.设置标题栏样式
      44.         self.setStyle()
      45.         # 4.添加按钮
      46.         # 添加关闭按钮
      47.         self.close_btn = QPushButton("", self.window)
      48.         self.close_btn.setGeometry(self.window.width() - 33, 10, 20, 20)
      49.         # 添加最大化按钮
      50.         self.max_btn = QPushButton("", self.window)
      51.         self.max_btn.setGeometry(self.window.width() - 66, 10, 20, 20)
      52.         # 添加最小化按钮
      53.         self.min_btn = QPushButton("", self.window)
      54.         self.min_btn.setGeometry(self.window.width() - 99, 10, 20, 20)
      55.         # 设置三个按钮的鼠标样式
      56.         self.close_btn.setCursor(Qt.PointingHandCursor)
      57.         self.max_btn.setCursor(Qt.PointingHandCursor)
      58.         self.min_btn.setCursor(Qt.PointingHandCursor)
      59.         # 设置三个按钮的样式
      60.         self.close_btn.setStyleSheet(
      61.             "QPushButton{border-image:url('./images/close.png');background:#ff625f;border-radius:10px;}"
      62.             "QPushButton:hover{background:#eb4845;}"
      63.         )
      64.         self.max_btn.setStyleSheet(
      65.             "QPushButton{border-image:url('./images/max.png');background:#ffbe2f;border-radius:10px;}"
      66.             "QPushButton:hover{background:#ecae27;}"
      67.         )
      68.         self.min_btn.setStyleSheet(
      69.             "QPushButton{border-image:url('./images/min.png');background:#29c941;border-radius:10px;}"
      70.             "QPushButton:hover{background:#1ac033;}"
      71.         )
      72.  
      73.         # 5.添加工具栏按钮事件
      74.         # 关闭按钮点击绑定窗口关闭事件
      75.         self.close_btn.pressed.connect(self.window.close)
      76.         # 最大化按钮绑定窗口最大化事件
      77.         self.max_btn.pressed.connect(self.setMaxEvent)
      78.         # 最小化按钮绑定窗口最小化事件
      79.         self.min_btn.pressed.connect(self.window.showMinimized)
      80.         # 6.记录全屏窗口的大小-ps非常有用
      81.         self.window_max_size = None
      82.         # 7.设置标题栏鼠标跟踪 鼠标移入触发，不设置，移入标题栏不触发
      83.         self.title.setMouseTracking(True)
      84.  
      85.     def setMaxEvent(self, flag=False):
      86.         """
      87.         @description  最大化按钮绑定窗口最大化事件和事件 拿出来是因为拖动标题栏时需要恢复界面大小
      88.         @param flag 是否是拖动标题栏 bool
      89.         @return
      90.         """
      91.         if flag:
      92.             if self.window.isMaximized():
      93.                 self.window.showNormal()
      94.                 self.max_btn.setStyleSheet(
      95.                     "QPushButton{border-image:url('./images/max.png');background:#ffbe2f;border-radius:10px;}"
      96.                     "QPushButton:hover{background:#ecae27;}"
      97.                 )
      98.                 return self.window_max_size
      99.             return None
      100.         else:
      101.             if self.window.isMaximized():
      102.                 self.window.showNormal()
      103.                 self.max_btn.setStyleSheet(
      104.                     "QPushButton{border-image:url('./images/max.png');background:#ffbe2f;border-radius:10px;}"
      105.                     "QPushButton:hover{background:#ecae27;}"
      106.                 )
      107.             else:
      108.                 self.window.showMaximized()
      109.                 self.max_btn.setStyleSheet(
      110.                     "QPushButton{border-image:url('./images/restore.png');background:#ffbe2f;border-radius:10px;}"
      111.                     "QPushButton:hover{background:#ecae27;}"
      112.                 )
      113.                 # 记录最大化窗口的大小  用于返回最大化时拖动窗口恢复前的大小 这个程序循环帧会取不到恢复前的宽度
      114.                 self.window_max_size = QSize(self.window.width(), self.window.height())
      115.  
      116.     def setStyle(self, style: str = ""):
      117.         """
      118.         @description 设置自定义标题栏样式
      119.         @param
      120.         @return
      121.         """
      122.         # 想要边框 加上border:1px solid #cccccc;
      123.         DEFAULT_STYLE = """
      124.                             background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,stop:0 #fafafa,stop:1 #d1d1d1);
      125.                             color:#333333;padding:10px;border:1px solid #c6c6c6;
      126.                             border-top-left-radius:4px;
      127.                             border-top-right-radius:4px;
      128.                         """
      129.         self.title.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
      130.         # 设置样式
      131.         self.title.setStyleSheet(DEFAULT_STYLE if not style else DEFAULT_STYLE + style)
      132.         # 设置大小
      133.         self.title.setGeometry(0, 0, self.window.width(), self.DEFAULT_TITILE_BAR_HEIGHT)
      134.  
      135.     def mouseDoubleClickEvent(self, a0: QtGui.QMouseEvent) -> None:
      136.         """
      137.         @description 鼠标双击事件
      138.         @param
      139.         @return
      140.         """
      141.         # 如果双击的是鼠标左键 且在标题栏范围内 则放大缩小窗口
      142.         if a0.button() == Qt.MouseButton.LeftButton and a0.position().y() < self.title.height():
      143.             self.setMaxEvent()
      144.         return self.mouseDoubleClickEvent_parent(a0)
      145.  
      146.     def resizeEvent(self, a0: QtGui.QResizeEvent) -> None:
      147.         """
      148.         @description  窗口缩放事件
      149.         @param
      150.         @return
      151.         """
      152.         # 最大化最小化的时候，需要去改变按钮组位置
      153.         self.close_btn.move(self.window.width() - 33, 10)
      154.         self.max_btn.move(self.window.width() - 66, 10)
      155.         self.min_btn.move(self.window.width() - 99, 10)
      156.         self.title.resize(self.window.width(), self.DEFAULT_TITILE_BAR_HEIGHT)
      157.         return self.resizeEvent_parent(a0)
      158.  
      159.  
      160. # 实现拖动和缩放Widget
      161. class QWindowMoveResizeWidget(QWidget):
      162.  
      163.     def __init__(self, parent=None):
      164.         super(QWindowMoveResizeWidget, self).__init__(parent)
      165.         # 1.设置无边框 和 透明背景 无边框必须设置全，不然会导致点击任务栏不能最小化窗口
      166.         self.setWindowFlags(
      167.             Qt.Window
      168.             | Qt.FramelessWindowHint
      169.             | Qt.WindowSystemMenuHint
      170.             | Qt.WindowMinimizeButtonHint
      171.             | Qt.WindowMaximizeButtonHint
      172.         )
      173.         # 设置窗体透明
      174.         self.setAttribute(Qt.WA_TranslucentBackground)
      175.         # 默认标题栏高度 必须设
      176.         self.DEFAULT_TITILE_BAR_HEIGHT = 40
      177.         # 鼠标缩放窗口最小宽度，必须设
      178.         self.MIN_WINDOW_WIDTH = 10
      179.         self.MIN_WINDOW_HEIGHT = 10
      180.         # 鼠标拖动窗口的标识
      181.         self.m_flag = False
      182.         # 初始化鼠标拖动标题栏标志
      183.         self.drag_flag = False
      184.         # 记录按下时窗口坐标， 这个用于窗口移动
      185.         self.win_x = 0
      186.         self.win_y = 0
      187.         # 记录按下时鼠标坐标，这个用于计算鼠标移动的距离
      188.         self.mouse_x = 0
      189.         self.mouse_y = 0
      190.         # 记录鼠标移入的拖动区域，共8种区域 左上 左 左下 上 下 右上 右 右下
      191.         self.left_up = None
      192.         self.left = None
      193.         self.left_down = None
      194.         self.up = None
      195.         self.down = None
      196.         self.right_up = None
      197.         self.right = None
      198.         self.right_down = None
      199.         # 设置为True则mouseMoveEvent事件不需要按下也能触发,不然要按着鼠标左键或右键才能触发
      200.         self.setMouseTracking(True)
      201.         # 设置子类的mousetrack
      202.         # self.centralwidget.setMouseTracking(True)
      203.         # 记录按下时窗口的大小，用于计算鼠标相对于窗口移动的距离，用于缩放
      204.         self.win_w = 0
      205.         self.win_h = 0
      206.         # 初始化鼠标缩放标志
      207.         self.move_left_up_flag = False
      208.         self.move_left_flag = False
      209.         self.move_left_down_flag = False
      210.         self.move_up_flag = False
      211.         self.move_down_flag = False
      212.         self.move_right_up_flag = False
      213.         self.move_right_flag = False
      214.         self.move_right_down_flag = False
      215.  
      216.     # 设置边框圆角
      217.     def paintEvent(self, event: PySide6.QtGui.QPaintEvent) -> None:
      218.         painter = QPainter(self)
      219.         painter.setRenderHint(QPainter.RenderHint.Antialiasing)  # 设置抗锯齿，不然边框会有明显锯齿
      220.         painter.setBrush(Qt.white)  # 设置窗体颜色
      221.         painter.drawRoundedRect(self.rect(), 10, 10)
      222.         super().paintEvent(event)
      223.  
      224.     def resizeEvent(self, a0: QtGui.QResizeEvent) -> None:
      225.         """
      226.         @description  窗口缩放事件
      227.         @param
      228.         @return
      229.         """
      230.         # 最大化最小化的时候，需要去改变按钮组位置
      231.         # self.titleBar.close_btn.move(self.width() - 33, 10)
      232.         # self.titleBar.max_btn.move(self.width() - 66, 10)
      233.         # self.titleBar.min_btn.move(self.width() - 99, 10)
      234.         # self.titleBar.title.resize(self.width(), DEFAULT_TITILE_BAR_HEIGHT)
      235.  
      236.         # 记录鼠标移入的拖动区域，共8种区域
      237.         self.left_up = QRect(0, 0, 10, 10)
      238.         self.left = QRect(0, 10, 10, self.height() - 20)
      239.         self.left_down = QRect(0, self.height() - 10, 10, 10)
      240.         self.up = QRect(10, 0, self.width() - 20, 10)
      241.         self.down = QRect(10, self.height() - 10, self.width() - 20, 10)
      242.         self.right_up = QRect(self.width() - 10, 0, 10, 10)
      243.         self.right = QRect(self.width() - 10, 10, 10, self.height() - 20)
      244.         self.right_down = QRect(self.width() - 10, self.height() - 10, 10, 10)
      245.  
      246.         return super().resizeEvent(a0)
      247.  
      248.     def mousePressEvent(self, a0: QtGui.QMouseEvent) -> None:
      249.         """
      250.         拖动窗口
      251.         """
      252.         if a0.button() == QtCore.Qt.LeftButton and self.isMaximized() == False and self.cursor().shape() == QtGui.QCursor(
      253.                 QtCore.Qt.ArrowCursor).shape():
      254.             self.m_flag = True
      255.             self.m_Position = a0.globalPosition().toPoint() - self.pos()  # 获取鼠标相对窗口的位置
      256.             a0.accept()
      257.             self.setCursor(QtGui.QCursor(QtCore.Qt.OpenHandCursor))  # 更改鼠标图标
      258.         else:
      259.             """
      260.             @description 鼠标按下事件
      261.             @param
      262.             @return
      263.             """
      264.             # 记录按下时窗口坐标， 这个用于窗口移动
      265.             self.win_x = self.x()
      266.             self.win_y = self.y()
      267.             # 记录按下时鼠标坐标，这个用于计算鼠标移动的距离
      268.             self.mouse_x = a0.globalPosition().x()
      269.             self.mouse_y = a0.globalPosition().y()
      270.             # 记录按下时窗口的大小，用于计算鼠标相对于窗口移动的距离，用于缩放
      271.             self.win_w = self.width()
      272.             self.win_h = self.height()
      273.  
      274.             if not self.isMaximized():
      275.                 # 如果按下的是鼠标左键
      276.                 if a0.button() == Qt.MouseButton.LeftButton and self.left_up.contains(a0.position().x(),
      277.                                                                                       a0.position().y()):
      278.                     self.move_left_up_flag = True
      279.                 if a0.button() == Qt.MouseButton.LeftButton and self.left.contains(a0.position().x(),
      280.                                                                                    a0.position().y()):
      281.                     self.move_left_flag = True
      282.                 if a0.button() == Qt.MouseButton.LeftButton and self.left_down.contains(
      283.                         a0.position().x(), a0.position().y()
      284.                 ):
      285.                     self.move_left_down_flag = True
      286.                 if a0.button() == Qt.MouseButton.LeftButton and self.up.contains(a0.position().x(), a0.position().y()):
      287.                     self.move_up_flag = True
      288.                 if a0.button() == Qt.MouseButton.LeftButton and self.down.contains(a0.position().x(),
      289.                                                                                    a0.position().y()):
      290.                     self.move_down_flag = True
      291.                 if a0.button() == Qt.MouseButton.LeftButton and self.right_up.contains(
      292.                         a0.position().x(), a0.position().y()
      293.                 ):
      294.                     self.move_right_up_flag = True
      295.                 if a0.button() == Qt.MouseButton.LeftButton and self.right.contains(a0.position().x(),
      296.                                                                                     a0.position().y()):
      297.                     self.move_right_flag = True
      298.                 if a0.button() == Qt.MouseButton.LeftButton and self.right_down.contains(
      299.                         a0.position().x(), a0.position().y()
      300.                 ):
      301.                     self.move_right_down_flag = True
      302.             return super().mousePressEvent(a0)
      303.  
      304.     def mouseMoveEvent(self, a0: QtGui.QMouseEvent) -> None:
      305.         """
      306.         拖动窗口
      307.         """
      308.         if QtCore.Qt.LeftButton and self.m_flag and self.cursor().shape() == QtGui.QCursor(
      309.                 QtCore.Qt.OpenHandCursor).shape():
      310.             self.move(a0.globalPosition().toPoint() - self.m_Position)  # 更改窗口位置
      311.             a0.accept()
      312.         else:
      313.             """
      314.             @description 鼠标按下移动事件
      315.             @param
      316.             @return
      317.             """
      318.             # 获取移动后鼠标的位置
      319.             mouse_move_x = a0.globalPosition().x()
      320.             mouse_move_y = a0.globalPosition().y()
      321.             # 计算移动的距离
      322.             offset_x = mouse_move_x - self.mouse_x
      323.             offset_y = mouse_move_y - self.mouse_y
      324.             # 移动鼠标时设置鼠标样式
      325.             if not self.isMaximized():
      326.                 # 不是拖动的时才可能是缩放状态
      327.                 if not self.drag_flag:
      328.                     # 左上
      329.                     if self.left_up.contains(a0.position().x(), a0.position().y()):
      330.                         self.setCursor(Qt.SizeFDiagCursor)
      331.                     # 左
      332.                     elif self.left.contains(a0.position().x(), a0.position().y()):
      333.                         self.setCursor(Qt.SizeHorCursor)
      334.                     # 左下
      335.                     elif self.left_down.contains(a0.position().x(), a0.position().y()):
      336.                         self.setCursor(Qt.SizeBDiagCursor)
      337.                     # 上
      338.                     elif self.up.contains(a0.position().x(), a0.position().y()):
      339.                         self.setCursor(Qt.SizeVerCursor)
      340.                     # 下
      341.                     elif self.down.contains(a0.position().x(), a0.position().y()):
      342.                         self.setCursor(Qt.SizeVerCursor)
      343.                     # 右上
      344.                     elif self.right_up.contains(a0.position().x(), a0.position().y()):
      345.                         self.setCursor(Qt.SizeBDiagCursor)
      346.                     # 右
      347.                     elif self.right.contains(a0.position().x(), a0.position().y()):
      348.                         self.setCursor(Qt.SizeHorCursor)
      349.                     # 右下
      350.                     elif self.right_down.contains(a0.position().x(), a0.position().y()):
      351.                         self.setCursor(Qt.SizeFDiagCursor)
      352.                     else:
      353.                         self.setCursor(Qt.ArrowCursor)
      354.                 else:
      355.                     self.setCursor(Qt.ArrowCursor)
      356.             else:
      357.                 self.setCursor(Qt.ArrowCursor)
      358.             # 如果按下且在左上角范围内则缩放（其他代码参考左上）
      359.             if self.move_left_up_flag:
      360.                 # 拖动的时候也要设置一下形状
      361.                 self.setCursor(Qt.SizeFDiagCursor)
      362.                 resize_w = self.win_w - offset_x
      363.                 resize_h = self.win_h - offset_y
      364.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      365.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      366.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      367.                 # 设置窗口缩放尺寸
      368.                 self.resize(resize_w, resize_h)
      369.                 # 设置窗口移动,需要鼠标跟随
      370.                 # x y 都要鼠标跟随
      371.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      372.                     self.move(self.win_x + offset_x, self.win_y + offset_y)
      373.                 # 缩放宽度等于最小宽度，高度鼠标跟随
      374.                 if resize_w == self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      375.                     self.move(self.x(), self.win_y + offset_y)
      376.                 # 缩放高度等于最小高度，宽度鼠标跟随
      377.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h == self.MIN_WINDOW_HEIGHT:
      378.                     self.move(self.win_x + offset_x, self.y())
      379.             # 如果按下且在左边范围内则缩放
      380.             elif self.move_left_flag:
      381.                 # 拖动的时候也要设置一下形状
      382.                 self.setCursor(Qt.SizeHorCursor)
      383.                 resize_w = self.win_w - offset_x
      384.                 resize_h = self.win_h
      385.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      386.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      387.                 # 设置窗口缩放尺寸
      388.                 self.resize(resize_w, resize_h)
      389.                 # 设置窗口移动,需要鼠标跟随
      390.                 # 只要宽度鼠标跟随
      391.                 if resize_w != self.MIN_WINDOW_WIDTH:
      392.                     self.move(self.win_x + offset_x, self.win_y)
      393.             # 如果按下且在左下角范围内则缩放
      394.             elif self.move_left_down_flag:
      395.                 # 拖动的时候也要设置一下形状
      396.                 self.setCursor(Qt.SizeBDiagCursor)
      397.                 resize_w = self.win_w - offset_x
      398.                 resize_h = self.win_h + offset_y
      399.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      400.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      401.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      402.                 # 设置窗口缩放尺寸
      403.                 self.resize(resize_w, resize_h)
      404.                 # 设置窗口移动,需要鼠标跟随
      405.                 # x y 都要鼠标跟随
      406.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      407.                     self.move(self.win_x + offset_x, self.y())
      408.                 # 缩放高度等于最小高度，宽度鼠标跟随
      409.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h == self.MIN_WINDOW_HEIGHT:
      410.                     self.move(self.win_x + offset_x, self.y())
      411.             # 如果按下且在上边范围内则缩放
      412.             elif self.move_up_flag:
      413.                 # 拖动的时候也要设置一下形状
      414.                 self.setCursor(Qt.SizeVerCursor)
      415.                 resize_w = self.win_w
      416.                 resize_h = self.win_h - offset_y
      417.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      418.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      419.                 # 设置窗口缩放尺寸
      420.                 self.resize(resize_w, resize_h)
      421.                 # 设置窗口移动,需要鼠标跟随
      422.                 # 只要高度鼠标跟随
      423.                 if resize_h != self.MIN_WINDOW_HEIGHT:
      424.                     self.move(self.win_x, self.win_y + offset_y)
      425.             # 如果按下且在下边范围内则缩放
      426.             elif self.move_down_flag:
      427.                 # 拖动的时候也要设置一下形状
      428.                 self.setCursor(Qt.SizeVerCursor)
      429.                 resize_w = self.win_w
      430.                 resize_h = self.win_h + offset_y
      431.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      432.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      433.                 # 设置窗口缩放尺寸
      434.                 self.resize(resize_w, resize_h)
      435.             # 如果按下且在右上角范围内则缩放
      436.             elif self.move_right_up_flag:
      437.                 # 拖动的时候也要设置一下形状
      438.                 self.setCursor(Qt.SizeBDiagCursor)
      439.                 resize_w = self.win_w + offset_x
      440.                 resize_h = self.win_h - offset_y
      441.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      442.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      443.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      444.                 # 设置窗口缩放尺寸
      445.                 self.resize(resize_w, resize_h)
      446.                 # 设置窗口移动,需要鼠标跟随
      447.                 # x y 都要鼠标跟随
      448.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      449.                     self.move(self.win_x, self.win_y + offset_y)
      450.                 # 缩放宽度等于最小宽度，高度鼠标跟随
      451.                 if resize_w == self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      452.                     self.move(self.x(), self.win_y + offset_y)
      453.             # 如果按下且在右边范围内则缩放
      454.             elif self.move_right_flag:
      455.                 # 拖动的时候也要设置一下形状
      456.                 self.setCursor(Qt.SizeHorCursor)
      457.                 resize_w = self.win_w + offset_x
      458.                 resize_h = self.win_h
      459.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      460.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      461.                 # 设置窗口缩放尺寸
      462.                 self.resize(resize_w, resize_h)
      463.             # 如果按下且在右下角范围内则缩放
      464.             elif self.move_right_down_flag:
      465.                 # 拖动的时候也要设置一下形状
      466.                 self.setCursor(Qt.SizeFDiagCursor)
      467.                 resize_w = self.win_w + offset_x
      468.                 resize_h = self.win_h + offset_y
      469.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      470.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      471.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      472.                 # 设置窗口缩放尺寸
      473.                 self.resize(resize_w, resize_h)
      474.             # 如果按下才能移动
      475.             elif self.drag_flag:
      476.                 # 设置窗口移动的距离
      477.                 self.move(self.win_x + offset_x, self.win_y + offset_y)
      478.             return super().mouseMoveEvent(a0)
      479.  
      480.     def mouseReleaseEvent(self, a0: QtGui.QMouseEvent) -> None:
      481.         self.m_flag = False
      482.         self.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor))
      483.         """
      484.         @description 鼠标按下松开事件
      485.         @param
      486.         @return
      487.         """
      488.         self.drag_flag = False
      489.         self.move_left_up_flag = False
      490.         self.move_left_flag = False
      491.         self.move_left_down_flag = False
      492.         self.move_up_flag = False
      493.         self.move_down_flag = False
      494.         self.move_right_up_flag = False
      495.         self.move_right_flag = False
      496.         self.move_right_down_flag = False
      497.         self.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor))
      498.         return super().mouseReleaseEvent(a0)
      499.  
      500.  
      501. # 实现拖动和缩放Dialog
      502. class QWindowMoveResizeDialog(QDialog):
      503.  
      504.     def __init__(self, parent=None):
      505.         super(QWindowMoveResizeDialog, self).__init__(parent)
      506.         # 1.设置无边框 和 透明背景 无边框必须设置全，不然会导致点击任务栏不能最小化窗口
      507.         self.setWindowFlags(
      508.             Qt.Window
      509.             | Qt.FramelessWindowHint
      510.             | Qt.WindowSystemMenuHint
      511.             | Qt.WindowMinimizeButtonHint
      512.             | Qt.WindowMaximizeButtonHint
      513.         )
      514.         # 窗体透明
      515.         self.setAttribute(Qt.WA_TranslucentBackground)
      516.         # 默认标题栏高度 必须设
      517.         self.DEFAULT_TITILE_BAR_HEIGHT = 40
      518.         # 鼠标缩放窗口最小宽度，必须设
      519.         self.MIN_WINDOW_WIDTH = 10
      520.         self.MIN_WINDOW_HEIGHT = 10
      521.         # 鼠标拖动窗口的标识
      522.         self.m_flag = False
      523.         # 初始化鼠标拖动标题栏标志
      524.         self.drag_flag = False
      525.         # 记录按下时窗口坐标， 这个用于窗口移动
      526.         self.win_x = 0
      527.         self.win_y = 0
      528.         # 记录按下时鼠标坐标，这个用于计算鼠标移动的距离
      529.         self.mouse_x = 0
      530.         self.mouse_y = 0
      531.         # 记录鼠标移入的拖动区域，共8种区域 左上 左 左下 上 下 右上 右 右下
      532.         self.left_up = None
      533.         self.left = None
      534.         self.left_down = None
      535.         self.up = None
      536.         self.down = None
      537.         self.right_up = None
      538.         self.right = None
      539.         self.right_down = None
      540.         # 设置为True则mouseMoveEvent事件不需要按下也能触发,不然要按着鼠标左键或右键才能触发
      541.         self.setMouseTracking(True)
      542.         # 设置子类的mousetrack
      543.         # self.centralwidget.setMouseTracking(True)
      544.         # 记录按下时窗口的大小，用于计算鼠标相对于窗口移动的距离，用于缩放
      545.         self.win_w = 0
      546.         self.win_h = 0
      547.         # 初始化鼠标缩放标志
      548.         self.move_left_up_flag = False
      549.         self.move_left_flag = False
      550.         self.move_left_down_flag = False
      551.         self.move_up_flag = False
      552.         self.move_down_flag = False
      553.         self.move_right_up_flag = False
      554.         self.move_right_flag = False
      555.         self.move_right_down_flag = False
      556.  
      557.     # 设置边框圆角
      558.     def paintEvent(self, event: PySide6.QtGui.QPaintEvent) -> None:
      559.         painter = QPainter(self)
      560.         painter.setRenderHint(QPainter.RenderHint.Antialiasing)  # 设置抗锯齿，不然边框会有明显锯齿
      561.         painter.setBrush(Qt.white)  # 设置窗体颜色
      562.         painter.drawRoundedRect(self.rect(), 10, 10)
      563.         super().paintEvent(event)
      564.  
      565.     def resizeEvent(self, a0: QtGui.QResizeEvent) -> None:
      566.         """
      567.         @description  窗口缩放事件
      568.         @param
      569.         @return
      570.         """
      571.         # 最大化最小化的时候，需要去改变按钮组位置
      572.         # self.titleBar.close_btn.move(self.width() - 33, 10)
      573.         # self.titleBar.max_btn.move(self.width() - 66, 10)
      574.         # self.titleBar.min_btn.move(self.width() - 99, 10)
      575.         # self.titleBar.title.resize(self.width(), DEFAULT_TITILE_BAR_HEIGHT)
      576.  
      577.         # 记录鼠标移入的拖动区域，共8种区域
      578.         self.left_up = QRect(0, 0, 10, 10)
      579.         self.left = QRect(0, 10, 10, self.height() - 20)
      580.         self.left_down = QRect(0, self.height() - 10, 10, 10)
      581.         self.up = QRect(10, 0, self.width() - 20, 10)
      582.         self.down = QRect(10, self.height() - 10, self.width() - 20, 10)
      583.         self.right_up = QRect(self.width() - 10, 0, 10, 10)
      584.         self.right = QRect(self.width() - 10, 10, 10, self.height() - 20)
      585.         self.right_down = QRect(self.width() - 10, self.height() - 10, 10, 10)
      586.  
      587.         return super().resizeEvent(a0)
      588.  
      589.     def mousePressEvent(self, a0: QtGui.QMouseEvent) -> None:
      590.         """
      591.         拖动窗口
      592.         """
      593.         if a0.button() == QtCore.Qt.LeftButton and self.isMaximized() == False and self.cursor().shape() == QtGui.QCursor(
      594.                 QtCore.Qt.ArrowCursor).shape():
      595.             self.m_flag = True
      596.             self.m_Position = a0.globalPosition().toPoint() - self.pos()  # 获取鼠标相对窗口的位置
      597.             a0.accept()
      598.             self.setCursor(QtGui.QCursor(QtCore.Qt.OpenHandCursor))  # 更改鼠标图标
      599.         else:
      600.             """
      601.             @description 鼠标按下事件
      602.             @param
      603.             @return
      604.             """
      605.             # 记录按下时窗口坐标， 这个用于窗口移动
      606.             self.win_x = self.x()
      607.             self.win_y = self.y()
      608.             # 记录按下时鼠标坐标，这个用于计算鼠标移动的距离
      609.             self.mouse_x = a0.globalPosition().x()
      610.             self.mouse_y = a0.globalPosition().y()
      611.             # 记录按下时窗口的大小，用于计算鼠标相对于窗口移动的距离，用于缩放
      612.             self.win_w = self.width()
      613.             self.win_h = self.height()
      614.  
      615.             if not self.isMaximized():
      616.                 # 如果按下的是鼠标左键
      617.                 if a0.button() == Qt.MouseButton.LeftButton and self.left_up.contains(a0.position().x(),
      618.                                                                                       a0.position().y()):
      619.                     self.move_left_up_flag = True
      620.                 if a0.button() == Qt.MouseButton.LeftButton and self.left.contains(a0.position().x(),
      621.                                                                                    a0.position().y()):
      622.                     self.move_left_flag = True
      623.                 if a0.button() == Qt.MouseButton.LeftButton and self.left_down.contains(
      624.                         a0.position().x(), a0.position().y()
      625.                 ):
      626.                     self.move_left_down_flag = True
      627.                 if a0.button() == Qt.MouseButton.LeftButton and self.up.contains(a0.position().x(), a0.position().y()):
      628.                     self.move_up_flag = True
      629.                 if a0.button() == Qt.MouseButton.LeftButton and self.down.contains(a0.position().x(),
      630.                                                                                    a0.position().y()):
      631.                     self.move_down_flag = True
      632.                 if a0.button() == Qt.MouseButton.LeftButton and self.right_up.contains(
      633.                         a0.position().x(), a0.position().y()
      634.                 ):
      635.                     self.move_right_up_flag = True
      636.                 if a0.button() == Qt.MouseButton.LeftButton and self.right.contains(a0.position().x(),
      637.                                                                                     a0.position().y()):
      638.                     self.move_right_flag = True
      639.                 if a0.button() == Qt.MouseButton.LeftButton and self.right_down.contains(
      640.                         a0.position().x(), a0.position().y()
      641.                 ):
      642.                     self.move_right_down_flag = True
      643.             return super().mousePressEvent(a0)
      644.  
      645.     def mouseMoveEvent(self, a0: QtGui.QMouseEvent) -> None:
      646.         """
      647.         拖动窗口
      648.         """
      649.         if QtCore.Qt.LeftButton and self.m_flag and self.cursor().shape() == QtGui.QCursor(
      650.                 QtCore.Qt.OpenHandCursor).shape():
      651.             self.move(a0.globalPosition().toPoint() - self.m_Position)  # 更改窗口位置
      652.             a0.accept()
      653.         else:
      654.             """
      655.             @description 鼠标按下移动事件
      656.             @param
      657.             @return
      658.             """
      659.             # 获取移动后鼠标的位置
      660.             mouse_move_x = a0.globalPosition().x()
      661.             mouse_move_y = a0.globalPosition().y()
      662.             # 计算移动的距离
      663.             offset_x = mouse_move_x - self.mouse_x
      664.             offset_y = mouse_move_y - self.mouse_y
      665.             # 移动鼠标时设置鼠标样式
      666.             if not self.isMaximized():
      667.                 # 不是拖动的时才可能是缩放状态
      668.                 if not self.drag_flag:
      669.                     # 左上
      670.                     if self.left_up.contains(a0.position().x(), a0.position().y()):
      671.                         self.setCursor(Qt.SizeFDiagCursor)
      672.                     # 左
      673.                     elif self.left.contains(a0.position().x(), a0.position().y()):
      674.                         self.setCursor(Qt.SizeHorCursor)
      675.                     # 左下
      676.                     elif self.left_down.contains(a0.position().x(), a0.position().y()):
      677.                         self.setCursor(Qt.SizeBDiagCursor)
      678.                     # 上
      679.                     elif self.up.contains(a0.position().x(), a0.position().y()):
      680.                         self.setCursor(Qt.SizeVerCursor)
      681.                     # 下
      682.                     elif self.down.contains(a0.position().x(), a0.position().y()):
      683.                         self.setCursor(Qt.SizeVerCursor)
      684.                     # 右上
      685.                     elif self.right_up.contains(a0.position().x(), a0.position().y()):
      686.                         self.setCursor(Qt.SizeBDiagCursor)
      687.                     # 右
      688.                     elif self.right.contains(a0.position().x(), a0.position().y()):
      689.                         self.setCursor(Qt.SizeHorCursor)
      690.                     # 右下
      691.                     elif self.right_down.contains(a0.position().x(), a0.position().y()):
      692.                         self.setCursor(Qt.SizeFDiagCursor)
      693.                     else:
      694.                         self.setCursor(Qt.ArrowCursor)
      695.                 else:
      696.                     self.setCursor(Qt.ArrowCursor)
      697.             else:
      698.                 self.setCursor(Qt.ArrowCursor)
      699.             # 如果按下且在左上角范围内则缩放（其他代码参考左上）
      700.             if self.move_left_up_flag:
      701.                 # 拖动的时候也要设置一下形状
      702.                 self.setCursor(Qt.SizeFDiagCursor)
      703.                 resize_w = self.win_w - offset_x
      704.                 resize_h = self.win_h - offset_y
      705.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      706.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      707.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      708.                 # 设置窗口缩放尺寸
      709.                 self.resize(resize_w, resize_h)
      710.                 # 设置窗口移动,需要鼠标跟随
      711.                 # x y 都要鼠标跟随
      712.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      713.                     self.move(self.win_x + offset_x, self.win_y + offset_y)
      714.                 # 缩放宽度等于最小宽度，高度鼠标跟随
      715.                 if resize_w == self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      716.                     self.move(self.x(), self.win_y + offset_y)
      717.                 # 缩放高度等于最小高度，宽度鼠标跟随
      718.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h == self.MIN_WINDOW_HEIGHT:
      719.                     self.move(self.win_x + offset_x, self.y())
      720.             # 如果按下且在左边范围内则缩放
      721.             elif self.move_left_flag:
      722.                 # 拖动的时候也要设置一下形状
      723.                 self.setCursor(Qt.SizeHorCursor)
      724.                 resize_w = self.win_w - offset_x
      725.                 resize_h = self.win_h
      726.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      727.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      728.                 # 设置窗口缩放尺寸
      729.                 self.resize(resize_w, resize_h)
      730.                 # 设置窗口移动,需要鼠标跟随
      731.                 # 只要宽度鼠标跟随
      732.                 if resize_w != self.MIN_WINDOW_WIDTH:
      733.                     self.move(self.win_x + offset_x, self.win_y)
      734.             # 如果按下且在左下角范围内则缩放
      735.             elif self.move_left_down_flag:
      736.                 # 拖动的时候也要设置一下形状
      737.                 self.setCursor(Qt.SizeBDiagCursor)
      738.                 resize_w = self.win_w - offset_x
      739.                 resize_h = self.win_h + offset_y
      740.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      741.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      742.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      743.                 # 设置窗口缩放尺寸
      744.                 self.resize(resize_w, resize_h)
      745.                 # 设置窗口移动,需要鼠标跟随
      746.                 # x y 都要鼠标跟随
      747.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      748.                     self.move(self.win_x + offset_x, self.y())
      749.                 # 缩放高度等于最小高度，宽度鼠标跟随
      750.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h == self.MIN_WINDOW_HEIGHT:
      751.                     self.move(self.win_x + offset_x, self.y())
      752.             # 如果按下且在上边范围内则缩放
      753.             elif self.move_up_flag:
      754.                 # 拖动的时候也要设置一下形状
      755.                 self.setCursor(Qt.SizeVerCursor)
      756.                 resize_w = self.win_w
      757.                 resize_h = self.win_h - offset_y
      758.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      759.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      760.                 # 设置窗口缩放尺寸
      761.                 self.resize(resize_w, resize_h)
      762.                 # 设置窗口移动,需要鼠标跟随
      763.                 # 只要高度鼠标跟随
      764.                 if resize_h != self.MIN_WINDOW_HEIGHT:
      765.                     self.move(self.win_x, self.win_y + offset_y)
      766.             # 如果按下且在下边范围内则缩放
      767.             elif self.move_down_flag:
      768.                 # 拖动的时候也要设置一下形状
      769.                 self.setCursor(Qt.SizeVerCursor)
      770.                 resize_w = self.win_w
      771.                 resize_h = self.win_h + offset_y
      772.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      773.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      774.                 # 设置窗口缩放尺寸
      775.                 self.resize(resize_w, resize_h)
      776.             # 如果按下且在右上角范围内则缩放
      777.             elif self.move_right_up_flag:
      778.                 # 拖动的时候也要设置一下形状
      779.                 self.setCursor(Qt.SizeBDiagCursor)
      780.                 resize_w = self.win_w + offset_x
      781.                 resize_h = self.win_h - offset_y
      782.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      783.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      784.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      785.                 # 设置窗口缩放尺寸
      786.                 self.resize(resize_w, resize_h)
      787.                 # 设置窗口移动,需要鼠标跟随
      788.                 # x y 都要鼠标跟随
      789.                 if resize_w != self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      790.                     self.move(self.win_x, self.win_y + offset_y)
      791.                 # 缩放宽度等于最小宽度，高度鼠标跟随
      792.                 if resize_w == self.MIN_WINDOW_WIDTH and resize_h != self.MIN_WINDOW_HEIGHT:
      793.                     self.move(self.x(), self.win_y + offset_y)
      794.             # 如果按下且在右边范围内则缩放
      795.             elif self.move_right_flag:
      796.                 # 拖动的时候也要设置一下形状
      797.                 self.setCursor(Qt.SizeHorCursor)
      798.                 resize_w = self.win_w + offset_x
      799.                 resize_h = self.win_h
      800.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      801.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      802.                 # 设置窗口缩放尺寸
      803.                 self.resize(resize_w, resize_h)
      804.             # 如果按下且在右下角范围内则缩放
      805.             elif self.move_right_down_flag:
      806.                 # 拖动的时候也要设置一下形状
      807.                 self.setCursor(Qt.SizeFDiagCursor)
      808.                 resize_w = self.win_w + offset_x
      809.                 resize_h = self.win_h + offset_y
      810.                 # 如果缩放后的尺寸小于最小尺寸则窗口不能缩放了
      811.                 resize_w = self.MIN_WINDOW_WIDTH if resize_w < self.MIN_WINDOW_WIDTH else resize_w
      812.                 resize_h = self.MIN_WINDOW_HEIGHT if resize_h < self.MIN_WINDOW_HEIGHT else resize_h
      813.                 # 设置窗口缩放尺寸
      814.                 self.resize(resize_w, resize_h)
      815.             # 如果按下才能移动
      816.             elif self.drag_flag:
      817.                 # 设置窗口移动的距离
      818.                 self.move(self.win_x + offset_x, self.win_y + offset_y)
      819.             return super().mouseMoveEvent(a0)
      820.  
      821.     def mouseReleaseEvent(self, a0: QtGui.QMouseEvent) -> None:
      822.         self.m_flag = False
      823.         self.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor))
      824.         """
      825.         @description 鼠标按下松开事件
      826.         @param
      827.         @return
      828.         """
      829.         self.drag_flag = False
      830.         self.move_left_up_flag = False
      831.         self.move_left_flag = False
      832.         self.move_left_down_flag = False
      833.         self.move_up_flag = False
      834.         self.move_down_flag = False
      835.         self.move_right_up_flag = False
      836.         self.move_right_flag = False
      837.         self.move_right_down_flag = False
      838.         self.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor))
      839.         return super().mouseReleaseEvent(a0)
    2. 使用实例
      ①QWidget使用示例
      UI文件（转成py文件） 
      1. "1.0" encoding="UTF-8"?>
      2. <ui version="4.0">
      3.  <class>Formclass>
      4.  <widget class="QWidget" name="Form">
      5.   <property name="geometry">
      6.    <rect>
      7.     <x>0x>
      8.     <y>0y>
      9.     <width>400width>
      10.     <height>300height>
      11.    rect>
      12.   property>
      13.   <property name="windowTitle">
      14.    <string>Formstring>
      15.   property>
      16.   <layout class="QHBoxLayout" name="horizontalLayout_2">
      17.    <item>
      18.     <layout class="QVBoxLayout" name="verticalLayout">
      19.      <item>
      20.       <layout class="QHBoxLayout" name="horizontalLayout">
      21.        <item>
      22.         <widget class="QLineEdit" name="lineEdit"/>
      23.        item>
      24.        <item>
      25.         <widget class="QPushButton" name="pushButton">
      26.          <property name="text">
      27.           <string>PushButtonstring>
      28.          property>
      29.         widget>
      30.        item>
      31.       layout>
      32.      item>
      33.      <item>
      34.       <widget class="QTextEdit" name="textEdit"/>
      35.      item>
      36.     layout>
      37.    item>
      38.   layout>
      39.  widget>
      40.  <resources/>
      41.  <connections/>
      42. ui>
      1. from PySide6.QtWidgets import QApplication, QWidget
      2.  
      3. from custom_components import QWindowMoveResizeWidget, QCustomTitleBar
      4. from ui_widget_test import Ui_Form
      5.  
      6.  
      7. class TestWindow(QWindowMoveResizeWidget, Ui_Form):
      8.     def __init__(self, parent=None):
      9.         super(TestWindow, self).__init__(parent)
      10.         self.setupUi(self)
      11.         # 自定义标题栏
      12.         QCustomTitleBar(self)
      13.  
      14.  
      15. if __name__ == "__main__":
      16.     app = QApplication([])
      17.     window = TestWindow()
      18.     window.show()
      19.     app.exec()

       ②QMainWindow使用示例
      UI文件（转成py文件）

      1. "1.0" encoding="UTF-8"?>
      2. <ui version="4.0">
      3.  <class>MainWindowclass>
      4.  <widget class="QMainWindow" name="MainWindow">
      5.   <property name="geometry">
      6.    <rect>
      7.     <x>0x>
      8.     <y>0y>
      9.     <width>641width>
      10.     <height>444height>
      11.    rect>
      12.   property>
      13.   <property name="windowTitle">
      14.    <string>MainWindowstring>
      15.   property>
      16.   <widget class="QWidget" name="centralwidget">
      17.    <layout class="QHBoxLayout" name="horizontalLayout_2">
      18.     <item>
      19.      <layout class="QVBoxLayout" name="verticalLayout">
      20.       <item>
      21.        <layout class="QHBoxLayout" name="horizontalLayout">
      22.         <item>
      23.          <widget class="QLineEdit" name="lineEdit"/>
      24.         item>
      25.         <item>
      26.          <widget class="QPushButton" name="pushButton">
      27.           <property name="text">
      28.            <string>PushButtonstring>
      29.           property>
      30.          widget>
      31.         item>
      32.        layout>
      33.       item>
      34.       <item>
      35.        <widget class="QTextEdit" name="textEdit"/>
      36.       item>
      37.      layout>
      38.     item>
      39.    layout>
      40.   widget>
      41.   <widget class="QMenuBar" name="menubar">
      42.    <property name="geometry">
      43.     <rect>
      44.      <x>0x>
      45.      <y>0y>
      46.      <width>641width>
      47.      <height>23height>
      48.     rect>
      49.    property>
      50.    <widget class="QMenu" name="menu">
      51.     <property name="title">
      52.      <string>菜单string>
      53.     property>
      54.    widget>
      55.    <addaction name="menu"/>
      56.   widget>
      57.   <widget class="QStatusBar" name="statusbar"/>
      58.  widget>
      59.  <resources/>
      60.  <connections/>
      61. ui>
      1. from PySide6 import QtCore, QtGui
      2. from PySide6.QtWidgets import QApplication, QMainWindow
      3.  
      4. from custom_components import QCustomTitleBar
      5. from ui_main_window_test import Ui_MainWindow
      6.  
      7.  
      8. class TestWindow(QMainWindow, Ui_MainWindow):
      9.     def __init__(self, parent=None):
      10.         super(TestWindow, self).__init__(parent)
      11.         self.setupUi(self)
      12.         # 自定义标题栏
      13.         QCustomTitleBar(self)
      14.  
      15.     def mousePressEvent(self, event):
      16.         if event.button() == QtCore.Qt.LeftButton and self.isMaximized() == False:
      17.             self.m_flag = True
      18.             self.m_Position = event.globalPosition().toPoint() - self.pos()  # 获取鼠标相对窗口的位置
      19.             event.accept()
      20.             self.setCursor(QtGui.QCursor(QtCore.Qt.OpenHandCursor))  # 更改鼠标图标
      21.  
      22.     def mouseMoveEvent(self, mouse_event):
      23.         if QtCore.Qt.LeftButton and self.m_flag:
      24.             self.move(mouse_event.globalPosition().toPoint() - self.m_Position)  # 更改窗口位置
      25.             mouse_event.accept()
      26.  
      27.     def mouseReleaseEvent(self, mouse_event):
      28.         self.m_flag = False
      29.         self.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor))
      30.  
      31.  
      32. if __name__ == "__main__":
      33.     app = QApplication([])
      34.     window = TestWindow()
      35.     window.show()
      36.     app.exec()

  • 相关阅读:
    【机器学习范式】监督学习，无监督学习，强化学习， 半监督学习，自监督学习，迁移学习，对比分析+详解与示例代码
    淘宝/天猫API：item_search_img-按图搜索淘宝商品（拍立淘）
    【管理运筹学】第 9 章 | 网络计划（2，时间参数的计算 —— 工作时间的确定与事项的时间参数）
    Visual Studio Code 1.68.1简介及下载地址
    python学习笔记-09
    初识linux(1)
    Word、Excel、PPT文件转PDF文件(C#)
    C#面对对象（用Dictionary字典实现银行取钱系统）
    恭贺弘博创新2023下半年软考(中/高级)认证课程顺利举行
    代码随想录（番外）图论1
  • 原文地址：https://blog.csdn.net/wenxingchen/article/details/128147506