Photoshop – QGraphicsItem only visible when parent selected

While my other answer is acceptable, I don’t really like the fact that each item is connected to the selection change signal.

In case the scene may potentially contain lots of items (in the order of hundreds or thousands), this means that every time the selection changes the signal will call the connected function of each one of those items, and even unnecessarily if the selection change doesn’t affect any of those item types.

The Graphics View framework is quite fast, but there’s little point in repeating the same calls that result in the same output (such as scene.selectedItems()) especially when dealing with the python bottleneck.

In such situations, it’s usually preferable to use centralized functions to handle such a common and repeated job, possibly adopting some optimizations to improve its performance and return to the event loop as soon as possible.
Doing that may increase code complexity, but could also result in faster response times for complex scenes with an undefined (and possibly extremely high) item count.

The following alternative uses a custom QGraphicsScene to handle selection changes and child visibility on its own; when the signal is emitted, it only iterates between all known "annotation items", and each item will eventually iterate and change the visibility of its control points only in case the selection change has actually affected them.

I also added a basic object subclass intended to be used as a mixin, with the benefit of being able to use it as a primitive class for any annotation-based item that uses control points. With proper implementation, you can also use this with all basic QGraphicsItems, including QGraphicsPathItem.

class AnnotationPointItem(QGraphicsEllipseItem):
    def __init__(self, pos=QPointF(), parent=None):
        super().__init__(
            -handle_radius, -handle_radius, 
            2*handle_radius, 2*handle_radius, 
            parent
        )
        
        self.setFlags(
            QGraphicsItem.ItemIsMovable 
            | QGraphicsItem.ItemIsSelectable 
            | QGraphicsItem.ItemSendsScenePositionChanges
        )
        self.setPen(QPen(handle_color, 4, Qt.SolidLine))
        self.setBrush(Qt.white)

    def itemChange(self, change, value):
        if change == QGraphicsItem.ItemPositionHasChanged:
            parent = self.parentItem()
            if parent:
                parent.updatePoint(self)
        return super().itemChange(change, value)


class _AnnotationItemBase:
    _pointsVisible = False
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._controlPoints = []
        # a set used for performance reasons in selection checks;
        # self is included by default to improve comparison
        self._cpset = set([self] + self._controlPoints)

    def addControlPoints(self, *cplist):
        self.insertControlPoints(-1, *cplist)

    def insertControlPoints(self, index, *cplist):
        if index < 0:
            index = len(self._controlPoints)
        self._controlPoints[index:index] = cplist
        self._cpset |= set(cplist)

    def removeControlPoints(self, *cplist):
        for cp in cplist:
            if cp in self._controlPoints:
                self._controlPoints.remove(cp)
        self._cpset -= set(cplist)

    def updateSelection(self, selection):
        if not selection and not self._pointsVisible:
            # the selection is empty, and control points were not previously 
            # visible, so there is no point (pun intended) in going further
            return

        # check if self or any control points are part of the selection; 
        # note that the intuitive approach would use set intersection (&):
        #     visible = self in selection or bool(selection & self._cpset)
        # in reality, set.isdisjoint() seems to a better approach than 
        # intersection because of its actual behavior (see note below)
        visible = not self._cpset.isdisjoint(selection)
        if self._pointsVisible != visible:
            for i in self._controlPoints:
                i.setVisible(visible)
            self._pointsVisible = visible

    def itemChange(self, change, value):
        if change == QGraphicsItem.ItemSceneChange:
            oldScene = self.scene()
            if oldScene != value:
                if oldScene:
                    oldScene.unsubscribeAnnotationItem(self)
                if value:
                    value.subscribeAnnotationItem(self)
        return super().itemChange(change, value)


class AnnotationPathItem(_AnnotationItemBase, QGraphicsLineItem):
    def __init__(
        self, 
        start=QPointF(), end=QPointF(), 
        color=Qt.green, thickness=10, 
        parent=None
    ):
        super().__init__(start.x(), start.y(), end.x(), end.y(), parent)

        self._color = color
        self._thickness = thickness

        self.setFlags(
            QGraphicsItem.ItemIsMovable 
            | QGraphicsItem.ItemIsSelectable
        )
        self.setPen(QPen(self._color, self._thickness, Qt.SolidLine))

        # child items
        self.startPointItem = AnnotationPointItem(parent=self)
        self.startPointItem.hide()
        self.startPointItem.setPos(self.line().p1())

        self.endPointItem = AnnotationPointItem(parent=self)
        self.endPointItem.hide()
        self.endPointItem.setPos(self.line().p2())

        self.addControlPoints(self.startPointItem, self.endPointItem)

    def paint(self, painter, option, widget=None):
        # Remove the selection outline
        if self.isSelected():
            option.state &= ~QStyle.State_Selected

        super().paint(painter, option, widget)

    def setPoints(self, start=None, end=None):
        currentLine = self.line()
        if start != None:
            currentLine.setP1(start)
        if end != None:
            currentLine.setP2(end)
        self.setLine(currentLine)

    def updatePoint(self, cp):
        if cp == self.startPointItem:
            self.setPoints(start=cp.pos())
        elif cp == self.endPointItem:
            self.setPoints(end=cp.pos())


class CustomScene(QGraphicsScene):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.multiSelectionItems = set()
        self.selectionChanged.connect(self.updateAnnotationSelections)

    def subscribeAnnotationItem(self, item):
        self.multiSelectionItems.add(item)

    def unsubscribeAnnotationItem(self, item):
        self.multiSelectionItems.discard(item)

    def updateAnnotationSelections(self):
        selection = set(self.selectedItems())
        for item in self.multiSelectionItems:
            item.updateSelection(selection)


class MainWindow(QWidget):
    def __init__(self):
        super().__init__()

        self.scene = CustomScene(self)
        ...

Note the remark about the set comparison: I’ve not done thorough research about the low level implementation, but according to this and this related posts, using set.isdisjoint() is a better choice, and despite what the documentation may let assume, which says:

Return True if the set has no elements in common with other. Sets are disjoint if and only if their intersection is the empty set.

As far as I can understand, that can (should?) probably be rephrased as:

Return False as soon as any element in the set is found on other.

Assuming that my understanding is correct, not set.isdisjoint(other) is much faster than checking the intersection, and especially for this case:

• set intersections create a further set, iterating through all contents of both sets, and that has to be eventually checked with bool();
• isdisjoint() just returns False as soon as a common element is found, which is exactly what we need; if no element is found in the selection, it would still return True, but without the overhead of creating a further set;