Запрос рекомендаций по изменению размера функциональности в приложении PyQt6 ⇐ Python

[Anonymous]

Я хотел бы выразить признательность за любые рекомендации, которые вы можете предоставить по моему вопросу, поскольку это моя первая попытка обратиться за помощью. Кроме того, я был бы признателен за ваши отзывы о любых потенциальных ошибках в моем вопросе, что позволит мне исправить их в будущем.
В настоящее время я разрабатываю приложение Python, предназначенное для представления диаграмм в интерактивный формат. С этой целью я реализовал два класса, а именно HorizontalResizeHandle и ВертикальныйResizeHandle.
Проблема, с которой я столкнулся, связана с функциональностью изменения размера диаграмм и осей. В частности, использование методов setFixedWidth и setFixedHeight мешает общим возможностям приложения по изменению размера. Следовательно, это приводит к осложнениям при попытке изменить размер окна или впоследствии настроить другие диаграммы и оси.
Я подозреваю, что корень проблемы может быть связан с методом _resize. внутри соответствующих классов ResizeHandle. Мы будем очень признательны за ваше мнение по этому вопросу.
Это код:

Код: Выделить всё

from sys import argv
from sys import exit as ex
from PyQt6.QtCore import Qt, QRect, QTimer, QPointF
from PyQt6.QtWidgets import QApplication, QWidget, QVBoxLayout, QGridLayout, QSizePolicy
from PyQt6.QtGui import QMouseEvent, QPainter, QColor, QPen, QBrush

class AbstractWindow(QWidget):
def __init__(
self,
area: QRect | None = None,
title: str = "",
parent: QWidget | None = None,
flags: Qt.WindowType = Qt.WindowType.Window,
) -> None:
super().__init__(parent, flags)
self.area: QRect = area
self.title: str = title
self._setup()

def _setup(self) -> None:
self.setWindowTitle(self.title)
if self.area is not None:
self.setGeometry(self.area)

class Axis(QWidget):
pass

class VerticalAxis(Axis):
def draw(self):
self.update()

def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter(self)
color = QColor(100, 25, 40)
painter.setPen(QPen(color, 1, Qt.PenStyle.SolidLine))
painter.setBrush(QBrush(color, Qt.BrushStyle.SolidPattern))
painter.drawRect(self.rect())

class HorizontalAxis(Axis):
def draw(self):
self.update()

def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter(self)
color = QColor(100, 25, 40)
painter.setPen(QPen(color, 1, Qt.PenStyle.SolidLine))
painter.setBrush(QBrush(color, Qt.BrushStyle.SolidPattern))
painter.drawRect(self.rect())

class ResizeHandle(QWidget):
def __init__(
self, parent: QWidget | None = None, flags: Qt.WindowType = Qt.WindowType.Widget
):
super().__init__(parent, flags)
self.delta = QPointF(0, 0)
self.mouse_old_position = QPointF(0, 0)

def mousePressEvent(self, event: QMouseEvent):
self.mouse_old_position = event.position()
super().mousePressEvent(event)

def mouseMoveEvent(self, event: QMouseEvent):
self.delta = QPointF(event.position() - self.mouse_old_position)
super().mouseMoveEvent(event)

def mouseReleaseEvent(self, event: QMouseEvent):
self.mouse_old_position = event.position()
super().mouseReleaseEvent(event)

class VerticalResizeHandle(ResizeHandle):
def __init__(
self, parent: QWidget | None = None, flags: Qt.WindowType = Qt.WindowType.Widget
):
super().__init__(parent, flags)
self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
self.setMinimumWidth(2)
self.setCursor(Qt.CursorShape.SizeHorCursor)
self.left_target = None
self.right_target = None
self.left_target_minimum_width = None
self.right_target_minimum_width = None

def set_target(
self,
left_target,
right_target,
left_target_minimum_width=0,
right_target_minimum_width=0,
):
self.left_target = left_target
self.right_target = right_target
self.left_target_minimum_width = left_target_minimum_width
self.right_target_minimum_width = right_target_minimum_width

def _resize(self, delta):  # The problem should be here.
if (
self.left_target.width() > self.left_target_minimum_width or delta > 0
) and (
self.right_target.width() > self.right_target_minimum_width or delta <  0
):
self.left_target.setFixedWidth(self.left_target.width() + round(delta))
self.right_target.setFixedWidth(self.right_target.width() - round(delta))

def mouseMoveEvent(self, event: QMouseEvent):
super().mouseMoveEvent(event)
self._resize(self.delta.x())

class HorizontalResizeHandle(ResizeHandle):
def __init__(
self, parent: QWidget | None = None, flags: Qt.WindowType = Qt.WindowType.Widget
):
super().__init__(parent, flags)
self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
self.setMinimumHeight(2)
self.setCursor(Qt.CursorShape.SizeVerCursor)
self.above_target = None
self.below_target = None
self.above_target_minimum_height = None
self.below_target_minimum_height = None

def set_target(
self,
above_target,
below_target,
above_target_minimum_height=0,
below_target_minimum_height=0,
):
self.above_target = above_target
self.below_target = below_target
self.above_target_minimum_height = above_target_minimum_height
self.below_target_minimum_height = below_target_minimum_height

def _resize(self, delta):  # The problem should be here.
if (
self.above_target.height() > self.above_target_minimum_height or delta > 0
) and (
self.below_target.height() > self.below_target_minimum_height or delta < 0
):
self.above_target.setFixedHeight(self.above_target.height() + round(delta))
self.below_target.setFixedHeight(self.below_target.height() - round(delta))

def mouseMoveEvent(self, event: QMouseEvent):
super().mouseMoveEvent(event)
self._resize(self.delta.y())

class Chart(QWidget):
def _draw_background(self, painter: QPainter):
painter.save()
color = QColor(25, 25, 40)
painter.setPen(QPen(color, 1, Qt.PenStyle.SolidLine))
painter.setBrush(QBrush(color, Qt.BrushStyle.SolidPattern))
painter.drawRect(self.rect())
painter.restore()

def draw(self):
self.update()

def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter(self)
self._draw_background(painter)

class Canvas(QWidget):
def __init__(
self, parent: QWidget | None = None, flags: Qt.WindowType = Qt.WindowType.Widget
):
super().__init__(parent, flags)
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
self.chart = Chart()
layout.addWidget(self.chart, 0, 0)
horizontal_resize_handle = HorizontalResizeHandle(self)
layout.addWidget(horizontal_resize_handle, 1, 0)
self.x_axis = HorizontalAxis()
self.x_axis.setFixedHeight(30)
layout.addWidget(self.x_axis, 2, 0)
vertical_resize_handle = VerticalResizeHandle(self)
layout.addWidget(vertical_resize_handle, 0, 1)
self.y_axis = VerticalAxis()
self.y_axis.setFixedWidth(130)
layout.addWidget(self.y_axis, 0, 2)
self.setLayout(layout)
horizontal_resize_handle.set_target(self.chart, self.x_axis)
vertical_resize_handle.set_target(self.chart, self.y_axis)
self.timer = QTimer(self)
self.timer.timeout.connect(self.draw)
self.timer.start(1)

def draw(self):
self.chart.draw()
self.x_axis.draw()
self.y_axis.draw()

class MainWindow(AbstractWindow):
def __init__(
self,
area: QRect | None = None,
title: str = "",
parent: QWidget | None = None,
flags: Qt.WindowType = Qt.WindowType.Window,
) ->  None:
super().__init__(area, title, parent, flags)
self._init_geometry()

def _setup(self):
super()._setup()
window_layout = QVBoxLayout(self)
canvas_layout = QGridLayout()
canvas_layout.setSpacing(0)
first_canvas = Canvas()
canvas_layout.addWidget(first_canvas, 0, 0)
second_canvas = Canvas()
canvas_layout.addWidget(second_canvas, 0, 2)
third_canvas = Canvas()
canvas_layout.addWidget(third_canvas, 2, 0)
forth_canvas = Canvas()
canvas_layout.addWidget(forth_canvas, 2, 2)
horizontal_resize_handle = HorizontalResizeHandle()
horizontal_resize_handle.set_target(first_canvas, third_canvas)
canvas_layout.addWidget(horizontal_resize_handle, 1, 0)
horizontal_resize_handle = HorizontalResizeHandle()
horizontal_resize_handle.set_target(second_canvas, forth_canvas)
canvas_layout.addWidget(horizontal_resize_handle, 1, 2)
vertical_resize_handle = VerticalResizeHandle()
vertical_resize_handle.set_target(first_canvas, second_canvas)
canvas_layout.addWidget(vertical_resize_handle, 0, 1)
vertical_resize_handle = VerticalResizeHandle()
vertical_resize_handle.set_target(third_canvas, forth_canvas)
canvas_layout.addWidget(vertical_resize_handle, 2, 1)
window_layout.addLayout(canvas_layout)

def _init_geometry(self) -> None:
rect = QRect(0, 0, 1200, 800)
self.setGeometry(rect)

def main(cli_args: list[str]) -> None:
application: QApplication = QApplication(cli_args)
main_window = MainWindow(title="APlotLib")
main_window.show()
exec_code = application.exec()
ex(exec_code)

if __name__ == "__main__":
main(argv)

Я попытался использовать методы setMinimumSize и setMaximumSize; однако они также дали неожиданные результаты.

Подробнее здесь: https://stackoverflow.com/questions/793 ... pplication