drawsvg-ui 0.4.0__py3-none-any.whl

items/shapes/polygons.py

@@ -0,0 +1,359 @@
+"""Polygon-based shape items."""
+
+from __future__ import annotations
+
+from PySide6 import QtCore, QtGui, QtWidgets
+
+from constants import DEFAULT_FILL, PEN_NORMAL, PEN_SELECTED
+from ..base import (
+    DIVIDER_HANDLE_COLOR,
+    DIVIDER_HANDLE_DIAMETER,
+    ResizableItem,
+    _should_draw_selection,
+    snap_to_grid,
+)
+from ..labels import ShapeLabelMixin
+
+
+class TriangleItem(ResizableItem, QtWidgets.QGraphicsPolygonItem):
+    def __init__(self, x, y, w, h):
+        QtWidgets.QGraphicsPolygonItem.__init__(self)
+        ResizableItem.__init__(self)
+        self._w = w
+        self._h = h
+        self._update_polygon()
+        self.setPos(x, y)
+        self.setTransformOriginPoint(w / 2.0, h / 2.0)
+        self.setFlags(
+            QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable
+        )
+        self.setPen(PEN_NORMAL)
+        self.setBrush(DEFAULT_FILL)
+
+    def _update_polygon(self):
+        poly = QtGui.QPolygonF(
+            [
+                QtCore.QPointF(self._w / 2.0, 0.0),
+                QtCore.QPointF(0.0, self._h),
+                QtCore.QPointF(self._w, self._h),
+            ]
+        )
+        self.setPolygon(poly)
+
+    def set_size(self, w, h, adjust_origin: bool = True):
+        self._w = w
+        self._h = h
+        self._update_polygon()
+        if adjust_origin:
+            self.setTransformOriginPoint(w / 2.0, h / 2.0)
+
+    def paint(self, painter, option, widget=None):
+        opt = QtWidgets.QStyleOptionGraphicsItem(option)
+        opt.state &= ~QtWidgets.QStyle.StateFlag.State_Selected
+        super().paint(painter, opt, widget)
+        if _should_draw_selection(self):
+            painter.save()
+            painter.setPen(PEN_SELECTED)
+            painter.setBrush(QtCore.Qt.BrushStyle.NoBrush)
+            painter.drawRect(self.boundingRect())
+            painter.restore()
+
+
+class DiamondItem(ShapeLabelMixin, ResizableItem, QtWidgets.QGraphicsPolygonItem):
+    def __init__(self, x: float, y: float, w: float, h: float):
+        QtWidgets.QGraphicsPolygonItem.__init__(self)
+        ResizableItem.__init__(self)
+        self._w = w
+        self._h = h
+        self._update_polygon()
+        self.setPos(x, y)
+        self.setTransformOriginPoint(w / 2.0, h / 2.0)
+        self.setFlags(
+            QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable
+        )
+        self._init_shape_label()
+        self.setPen(PEN_NORMAL)
+        self.setBrush(DEFAULT_FILL)
+
+    def _label_base_rect(self) -> QtCore.QRectF:
+        return QtCore.QRectF(self.boundingRect())
+
+    def _update_polygon(self) -> None:
+        half_w = self._w / 2.0
+        half_h = self._h / 2.0
+        poly = QtGui.QPolygonF(
+            [
+                QtCore.QPointF(half_w, 0.0),
+                QtCore.QPointF(self._w, half_h),
+                QtCore.QPointF(half_w, self._h),
+                QtCore.QPointF(0.0, half_h),
+            ]
+        )
+        self.setPolygon(poly)
+        if hasattr(self, "_label"):
+            self._update_label_geometry()
+
+    def set_size(self, w: float, h: float, adjust_origin: bool = True) -> None:
+        self._w = w
+        self._h = h
+        self._update_polygon()
+        if adjust_origin:
+            self.setTransformOriginPoint(w / 2.0, h / 2.0)
+        self._update_label_geometry()
+
+    def setPen(self, pen: QtGui.QPen | QtGui.QColor) -> None:  # type: ignore[override]
+        super().setPen(pen)
+        self._update_label_color()
+
+    def paint(self, painter, option, widget=None):
+        opt = QtWidgets.QStyleOptionGraphicsItem(option)
+        opt.state &= ~QtWidgets.QStyle.StateFlag.State_Selected
+        super().paint(painter, opt, widget)
+        if _should_draw_selection(self):
+            painter.save()
+            painter.setPen(PEN_SELECTED)
+            painter.setBrush(QtCore.Qt.BrushStyle.NoBrush)
+            painter.drawRect(self.boundingRect())
+            painter.restore()
+
+    def mouseDoubleClickEvent(
+        self, event: QtWidgets.QGraphicsSceneMouseEvent
+    ) -> None:  # type: ignore[override]
+        if event.button() == QtCore.Qt.MouseButton.LeftButton:
+            self._begin_label_edit()
+            event.accept()
+            return
+        super().mouseDoubleClickEvent(event)
+
+
+class BlockArrowHandle(QtWidgets.QGraphicsEllipseItem):
+    """Special orange handles for :class:`BlockArrowItem`."""
+
+    def __init__(self, parent: "BlockArrowItem", role: str):
+        radius = DIVIDER_HANDLE_DIAMETER / 2.0
+        super().__init__(
+            -radius,
+            -radius,
+            DIVIDER_HANDLE_DIAMETER,
+            DIVIDER_HANDLE_DIAMETER,
+            parent,
+        )
+        self._role = role
+        self.setBrush(DIVIDER_HANDLE_COLOR)
+        self.setPen(QtGui.QPen(QtCore.Qt.PenStyle.NoPen))
+        self.setAcceptedMouseButtons(QtCore.Qt.MouseButton.LeftButton)
+        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIgnoresTransformations)
+        if role == "head":
+            self.setCursor(QtCore.Qt.CursorShape.SizeHorCursor)
+        else:
+            self.setCursor(QtCore.Qt.CursorShape.SizeVerCursor)
+        self._parent_was_movable = False
+
+    def mousePressEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent):
+        parent = self.parentItem()
+        if parent is not None:
+            flags = parent.flags()
+            self._parent_was_movable = bool(
+                flags & QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable
+            )
+            if self._parent_was_movable:
+                parent.setFlag(
+                    QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable,
+                    False,
+                )
+        event.accept()
+
+    def mouseMoveEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent):
+        parent: "BlockArrowItem" = self.parentItem()  # type: ignore[assignment]
+        if parent is not None:
+            parent._handle_special_drag(self._role, event)
+        event.accept()
+
+    def mouseReleaseEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent):
+        parent = self.parentItem()
+        if parent is not None and self._parent_was_movable:
+            parent.setFlag(
+                QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable,
+                True,
+            )
+            self._parent_was_movable = False
+        event.accept()
+
+
+class BlockArrowItem(ResizableItem, QtWidgets.QGraphicsPolygonItem):
+    def __init__(self, x: float, y: float, w: float, h: float):
+        QtWidgets.QGraphicsPolygonItem.__init__(self)
+        ResizableItem.__init__(self)
+        self._w = w
+        self._h = h
+        self._head_ratio = 0.35
+        self._shaft_ratio = 0.35
+        self._head_handle: BlockArrowHandle | None = None
+        self._body_handle: BlockArrowHandle | None = None
+        self._update_polygon()
+        self.setPos(x, y)
+        self.setTransformOriginPoint(w / 2.0, h / 2.0)
+        self.setFlags(
+            QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable
+        )
+        self.setPen(PEN_NORMAL)
+        self.setBrush(DEFAULT_FILL)
+
+    def _clamp_head_ratio(self, ratio: float) -> float:
+        return max(0.05, min(0.8, ratio))
+
+    def _clamp_shaft_ratio(self, ratio: float) -> float:
+        return max(0.1, min(0.9, ratio))
+
+    def head_ratio(self) -> float:
+        return self._head_ratio
+
+    def set_head_ratio(self, ratio: float) -> None:
+        self._head_ratio = self._clamp_head_ratio(ratio)
+        self._update_polygon()
+
+    def shaft_ratio(self) -> float:
+        return self._shaft_ratio
+
+    def set_shaft_ratio(self, ratio: float) -> None:
+        self._shaft_ratio = self._clamp_shaft_ratio(ratio)
+        self._update_polygon()
+
+    def _head_width(self) -> float:
+        return self._w * self._clamp_head_ratio(self._head_ratio)
+
+    def _shaft_bounds(self) -> tuple[float, float]:
+        shaft_h = self._h * self._clamp_shaft_ratio(self._shaft_ratio)
+        top = (self._h - shaft_h) / 2.0
+        return top, top + shaft_h
+
+    def _update_polygon(self) -> None:
+        self.prepareGeometryChange()
+        w = self._w
+        h = self._h
+        head_w = self._head_width()
+        shaft_top, shaft_bottom = self._shaft_bounds()
+        poly = QtGui.QPolygonF(
+            [
+                QtCore.QPointF(0.0, shaft_top),
+                QtCore.QPointF(w - head_w, shaft_top),
+                QtCore.QPointF(w - head_w, 0.0),
+                QtCore.QPointF(w, h / 2.0),
+                QtCore.QPointF(w - head_w, h),
+                QtCore.QPointF(w - head_w, shaft_bottom),
+                QtCore.QPointF(0.0, shaft_bottom),
+            ]
+        )
+        self.setPolygon(poly)
+        self.setTransformOriginPoint(self._w / 2.0, self._h / 2.0)
+        self._update_custom_handles()
+
+    def _update_custom_handles(self) -> None:
+        if not (self._head_handle and self._body_handle):
+            return
+        head_w = self._head_width()
+        shaft_top, shaft_bottom = self._shaft_bounds()
+        tail_width = self._w - head_w
+        margin = DIVIDER_HANDLE_DIAMETER / 2.0
+        head_pos = QtCore.QPointF(self._w - head_w, shaft_top - margin)
+        body_pos = QtCore.QPointF(max(0.0, tail_width / 2.0), shaft_bottom + margin)
+        self._head_handle.setPos(head_pos)
+        self._body_handle.setPos(body_pos)
+
+    def _handle_special_drag(self, role: str, event: QtWidgets.QGraphicsSceneMouseEvent) -> None:
+        scene_pos = event.scenePos()
+        if not (event.modifiers() & QtCore.Qt.KeyboardModifier.AltModifier):
+            scene_pos = snap_to_grid(self, scene_pos)
+        local = self.mapFromScene(scene_pos)
+        if role == "head":
+            self._apply_head_drag(local.x())
+        else:
+            self._apply_body_drag(local.y())
+
+    def _apply_head_drag(self, local_x: float) -> None:
+        w = self._w
+        if w <= 0:
+            return
+        min_tail = max(8.0, min(w - 8.0, w * 0.1))
+        min_head = max(8.0, w * 0.1)
+        max_x = max(min_tail, w - min_head)
+        min_x = min_tail
+        if max_x < min_x:
+            min_x = max_x = w / 2.0
+        clamped_x = max(min_x, min(local_x, max_x))
+        ratio = (w - clamped_x) / w
+        self.set_head_ratio(ratio)
+
+    def _apply_body_drag(self, local_y: float) -> None:
+        h = self._h
+        if h <= 0:
+            return
+        center = h / 2.0
+        min_shaft = max(8.0, h * 0.15)
+        min_bottom = center + min_shaft / 2.0
+        clamped_y = max(min_bottom, min(local_y, h))
+        shaft_height = (clamped_y - center) * 2.0
+        ratio = shaft_height / h
+        self.set_shaft_ratio(ratio)
+
+    def update_handles(self):  # type: ignore[override]
+        super().update_handles()
+        if self._handles:
+            tip: QtCore.QPointF | None = None
+            poly = self.polygon()
+            if len(poly) >= 4:
+                tip = QtCore.QPointF(poly[3])
+            else:
+                tip = QtCore.QPointF(self._w, self._h / 2.0)
+            for handle in self._handles:
+                if getattr(handle, "_direction", None) == "right":
+                    handle.setPos(tip)
+                    break
+        self._update_custom_handles()
+
+    def paint(self, painter, option, widget=None):
+        opt = QtWidgets.QStyleOptionGraphicsItem(option)
+        opt.state &= ~QtWidgets.QStyle.StateFlag.State_Selected
+        super().paint(painter, opt, widget)
+        if _should_draw_selection(self):
+            painter.save()
+            painter.setPen(PEN_SELECTED)
+            painter.setBrush(QtCore.Qt.BrushStyle.NoBrush)
+            painter.drawRect(self.boundingRect())
+            painter.restore()
+
+    def show_handles_once(self):
+        if not self._head_handle:
+            self._head_handle = BlockArrowHandle(self, "head")
+            self._head_handle.setZValue(1.0)
+        if not self._body_handle:
+            self._body_handle = BlockArrowHandle(self, "body")
+            self._body_handle.setZValue(1.0)
+        self._update_custom_handles()
+
+    def show_handles(self):  # type: ignore[override]
+        self.show_handles_once()
+        super().show_handles()
+        if self._head_handle:
+            self._head_handle.show()
+        if self._body_handle:
+            self._body_handle.show()
+
+    def hide_handles(self):  # type: ignore[override]
+        super().hide_handles()
+        if self._head_handle:
+            self._head_handle.hide()
+        if self._body_handle:
+            self._body_handle.hide()
+
+
+__all__ = ["BlockArrowHandle", "BlockArrowItem", "DiamondItem", "TriangleItem"]

items/shapes/rects.py

@@ -0,0 +1,310 @@
+"""Rectangular shapes and related handles."""
+
+from __future__ import annotations
+
+from PySide6 import QtCore, QtGui, QtWidgets
+
+from constants import DEFAULT_FILL, PEN_NORMAL, PEN_SELECTED
+from ..base import (
+    DIVIDER_HANDLE_COLOR,
+    DIVIDER_HANDLE_DIAMETER,
+    ResizableItem,
+    _should_draw_selection,
+)
+from ..labels import ShapeLabelMixin
+
+
+class SplitDividerHandle(QtWidgets.QGraphicsEllipseItem):
+    """Drag handle for the horizontal split in :class:`SplitRoundedRectItem`."""
+
+    def __init__(self, parent: "SplitRoundedRectItem"):
+        radius = DIVIDER_HANDLE_DIAMETER / 2.0
+        super().__init__(
+            -radius,
+            -radius,
+            DIVIDER_HANDLE_DIAMETER,
+            DIVIDER_HANDLE_DIAMETER,
+            parent,
+        )
+        self.setBrush(DIVIDER_HANDLE_COLOR)
+        self.setPen(QtGui.QPen(QtCore.Qt.PenStyle.NoPen))
+        self.setAcceptedMouseButtons(QtCore.Qt.MouseButton.LeftButton)
+        self.setCursor(QtCore.Qt.CursorShape.SizeVerCursor)
+        self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIgnoresTransformations)
+        self._parent_was_movable = False
+
+    def mousePressEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent):
+        parent = self.parentItem()
+        if parent is not None:
+            flags = parent.flags()
+            self._parent_was_movable = bool(
+                flags & QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable
+            )
+            if self._parent_was_movable:
+                parent.setFlag(
+                    QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable,
+                    False,
+                )
+        event.accept()
+
+    def mouseMoveEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent):
+        parent = self.parentItem()
+        if parent is not None:
+            parent._set_divider_from_scene_pos(event.scenePos())  # type: ignore[attr-defined]
+        event.accept()
+
+    def mouseReleaseEvent(self, event: QtWidgets.QGraphicsSceneMouseEvent):
+        parent = self.parentItem()
+        if parent is not None and self._parent_was_movable:
+            parent.setFlag(
+                QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable,
+                True,
+            )
+        self._parent_was_movable = False
+        event.accept()
+
+
+class RectItem(ShapeLabelMixin, ResizableItem, QtWidgets.QGraphicsRectItem):
+    def __init__(self, x, y, w, h, rx: float = 0.0, ry: float = 0.0):
+        QtWidgets.QGraphicsRectItem.__init__(self, 0, 0, w, h)
+        ResizableItem.__init__(self)
+        self.setPos(x, y)
+        self.setTransformOriginPoint(w / 2.0, h / 2.0)
+        self.setFlags(
+            QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable
+        )
+        self.rx = rx
+        self.ry = ry
+        self._init_shape_label()
+        self.setPen(PEN_NORMAL)
+        self.setBrush(DEFAULT_FILL)
+
+    def _label_base_rect(self) -> QtCore.QRectF:
+        return QtCore.QRectF(self.rect())
+
+    def setRect(self, x: float, y: float, w: float, h: float) -> None:  # type: ignore[override]
+        QtWidgets.QGraphicsRectItem.setRect(self, x, y, w, h)
+        self._update_label_geometry()
+
+    def setPen(self, pen):  # type: ignore[override]
+        super().setPen(pen)
+        self._update_label_color()
+
+    def mouseDoubleClickEvent(
+        self, event: QtWidgets.QGraphicsSceneMouseEvent
+    ) -> None:  # type: ignore[override]
+        if event.button() == QtCore.Qt.MouseButton.LeftButton:
+            self._begin_label_edit()
+            event.accept()
+            return
+        super().mouseDoubleClickEvent(event)
+
+    def paint(self, painter, option, widget=None):
+        opt = QtWidgets.QStyleOptionGraphicsItem(option)
+        opt.state &= ~QtWidgets.QStyle.StateFlag.State_Selected
+        if self.rx or self.ry:
+            painter.setPen(self.pen())
+            painter.setBrush(self.brush())
+            painter.drawRoundedRect(self.rect(), self.rx, self.ry)
+        else:
+            super().paint(painter, opt, widget)
+        if _should_draw_selection(self):
+            painter.save()
+            painter.setPen(PEN_SELECTED)
+            painter.setBrush(QtCore.Qt.BrushStyle.NoBrush)
+            painter.drawRect(self.boundingRect())
+            painter.restore()
+
+
+class SplitRoundedRectItem(ResizableItem, QtWidgets.QGraphicsRectItem):
+    def __init__(
+        self,
+        x: float,
+        y: float,
+        w: float,
+        h: float,
+        rx: float = 15.0,
+        ry: float | None = None,
+    ):
+        QtWidgets.QGraphicsRectItem.__init__(self, 0, 0, w, h)
+        ResizableItem.__init__(self)
+        self.setPos(x, y)
+        self.setTransformOriginPoint(w / 2.0, h / 2.0)
+        self.setFlags(
+            QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges
+            | QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsFocusable
+        )
+
+        self.rx = rx
+        self.ry = ry if ry is not None else rx
+        self._split_ratio = 1.0 / 3.0
+        self._top_brush = QtGui.QBrush(QtGui.QColor("#f6e3b0"))
+        self._bottom_brush = QtGui.QBrush(DEFAULT_FILL)
+        self._divider_pen = QtGui.QPen(QtGui.QColor("#777"), 1.5)
+        self._divider_pen.setCosmetic(True)
+
+        self.setPen(PEN_NORMAL)
+
+        self._divider_handle = SplitDividerHandle(self)
+        self._divider_handle.setZValue(1.0)
+        self._divider_handle.hide()
+        self._update_divider_handle()
+
+    def _handle_margin(self) -> float:
+        bounds = self._divider_handle.boundingRect()
+        return max(bounds.width(), bounds.height()) / 2.0
+
+    def _line_y(self) -> float:
+        rect = self.rect()
+        return rect.top() + rect.height() * self._split_ratio
+
+    def divider_ratio(self) -> float:
+        return self._split_ratio
+
+    def set_divider_ratio(self, ratio: float) -> None:
+        rect = self.rect()
+        if rect.height() <= 0:
+            self._split_ratio = 0.5
+        else:
+            clamped = max(0.0, min(1.0, ratio))
+            target = rect.top() + rect.height() * clamped
+            self.set_divider_y(target)
+
+    def set_divider_y(self, y: float) -> None:
+        rect = self.rect()
+        if rect.height() <= 0:
+            self._split_ratio = 0.5
+        else:
+            margin = self._handle_margin()
+            min_y = rect.top() + margin
+            max_y = rect.bottom() - margin
+            if max_y < min_y:
+                y = rect.center().y()
+            else:
+                y = min(max(y, min_y), max_y)
+            self._split_ratio = (y - rect.top()) / rect.height()
+        self.update()
+        self._update_divider_handle()
+
+    def _update_divider_handle(self) -> None:
+        rect = self.rect()
+        self._divider_handle.setPos(rect.center().x(), self._line_y())
+
+    def _set_divider_from_scene_pos(self, scene_pos: QtCore.QPointF) -> None:
+        local = self.mapFromScene(scene_pos)
+        self.set_divider_y(local.y())
+
+    def topBrush(self) -> QtGui.QBrush:
+        return QtGui.QBrush(self._top_brush)
+
+    def setTopBrush(self, brush: QtGui.QBrush | QtGui.QColor) -> None:
+        self._top_brush = QtGui.QBrush(brush)
+        self.update()
+
+    def bottomBrush(self) -> QtGui.QBrush:
+        return QtGui.QBrush(self._bottom_brush)
+
+    def setBottomBrush(self, brush: QtGui.QBrush | QtGui.QColor) -> None:
+        self._bottom_brush = QtGui.QBrush(brush)
+        self.update()
+
+    def brush(self) -> QtGui.QBrush:  # type: ignore[override]
+        return self.bottomBrush()
+
+    def setBrush(self, brush: QtGui.QBrush | QtGui.QColor) -> None:  # type: ignore[override]
+        self.setBottomBrush(brush)
+
+    def setPen(self, pen: QtGui.QPen | QtGui.QColor) -> None:  # type: ignore[override]
+        qpen = QtGui.QPen(pen)
+        QtWidgets.QGraphicsRectItem.setPen(self, qpen)
+        divider_width = max(1.0, qpen.widthF() * 0.75)
+        self._divider_pen = QtGui.QPen(qpen.color(), divider_width)
+        self._divider_pen.setCosmetic(True)
+        self.update()
+
+    def show_handles(self):  # type: ignore[override]
+        super().show_handles()
+        self._divider_handle.show()
+        self._update_divider_handle()
+
+    def hide_handles(self):  # type: ignore[override]
+        super().hide_handles()
+        self._divider_handle.hide()
+
+    def update_handles(self):  # type: ignore[override]
+        super().update_handles()
+        self._update_divider_handle()
+
+    def setRect(self, x: float, y: float, w: float, h: float) -> None:  # type: ignore[override]
+        QtWidgets.QGraphicsRectItem.setRect(self, x, y, w, h)
+        self._update_divider_handle()
+
+    def paint(self, painter, option, widget=None):  # type: ignore[override]
+        rect = self.rect()
+        painter.save()
+        painter.setRenderHint(QtGui.QPainter.RenderHint.Antialiasing, True)
+
+        rx = max(0.0, min(self.rx, rect.width() / 2.0, 50.0))
+        ry = max(0.0, min(self.ry, rect.height() / 2.0, 50.0))
+
+        base_path = QtGui.QPainterPath()
+        if rx > 0.0 or ry > 0.0:
+            base_path.addRoundedRect(rect, rx, ry)
+        else:
+            base_path.addRect(rect)
+
+        line_y = self._line_y()
+
+        top_clip = QtGui.QPainterPath()
+        top_clip.addRect(rect.left(), rect.top(), rect.width(), max(0.0, line_y - rect.top()))
+        top_path = base_path.intersected(top_clip)
+        if not top_path.isEmpty():
+            painter.fillPath(top_path, self._top_brush)
+
+        bottom_clip = QtGui.QPainterPath()
+        bottom_clip.addRect(
+            rect.left(),
+            line_y,
+            rect.width(),
+            max(0.0, rect.bottom() - line_y),
+        )
+        bottom_path = base_path.intersected(bottom_clip)
+        if not bottom_path.isEmpty():
+            painter.fillPath(bottom_path, self._bottom_brush)
+
+        painter.setBrush(QtCore.Qt.BrushStyle.NoBrush)
+        painter.setPen(self.pen())
+        if rx > 0.0 or ry > 0.0:
+            painter.drawRoundedRect(rect, rx, ry)
+        else:
+            painter.drawRect(rect)
+
+        painter.setPen(self._divider_pen)
+        painter.drawLine(rect.left(), line_y, rect.right(), line_y)
+        painter.restore()
+
+        if _should_draw_selection(self):
+            painter.save()
+            painter.setPen(PEN_SELECTED)
+            painter.setBrush(QtCore.Qt.BrushStyle.NoBrush)
+            painter.drawRect(self.boundingRect())
+            painter.restore()
+
+    def shape(self) -> QtGui.QPainterPath:  # type: ignore[override]
+        rect = self.rect()
+        path = QtGui.QPainterPath()
+        rx = max(0.0, min(self.rx, rect.width() / 2.0, 50.0))
+        ry = max(0.0, min(self.ry, rect.height() / 2.0, 50.0))
+        if rx > 0.0 or ry > 0.0:
+            path.addRoundedRect(rect, rx, ry)
+        else:
+            path.addRect(rect)
+        return path
+
+
+__all__ = ["RectItem", "SplitDividerHandle", "SplitRoundedRectItem"]