dendrogram: Fix public method naming

Author: ales-erjavec

Orange/widgets/utils/dendrogram.py

@@ -199,7 +199,7 @@ def boundingRect(self):
                 self.__boundingRect = sh.boundingRect().adjusted(-pw, -pw, pw, pw)
             return self.__boundingRect
 
-    class SelectionItem(QGraphicsItemGroup):
+    class _SelectionItem(QGraphicsItemGroup):
         def __init__(self, parent, path, unscaled_path, label=""):
             super().__init__(parent)
             self.path = QGraphicsPathItem(path, self)
@@ -243,13 +243,14 @@ def _update_label_pos(self):
 
     #: Emitted when a user clicks on the cluster item.
     itemClicked = Signal(ClusterGraphicsItem)
+    #: Signal emitted when the selection changes.
     selectionChanged = Signal()
+    #: Signal emitted when the selection was changed by the user.
     selectionEdited = Signal()
 
     def __init__(self, parent=None, root=None, orientation=Left,
                  hoverHighlightEnabled=True, selectionMode=ExtendedSelection,
                  **kwargs):
-
         super().__init__(None, **kwargs)
         # Filter all events from children (`ClusterGraphicsItem`s)
         self.setFiltersChildEvents(True)
@@ -272,11 +273,46 @@ def __init__(self, parent=None, root=None, orientation=Left,
         self.__hoverHighlightEnabled = hoverHighlightEnabled
         self.__selectionMode = selectionMode
         self.setContentsMargins(0, 0, 0, 0)
-        self.set_root(root)
+        self.setRoot(root)
         if parent is not None:
             self.setParentItem(parent)
 
+    def setSelectionMode(self, mode):
+        """
+        Set the selection mode.
+        """
+        assert mode in [DendrogramWidget.NoSelection,
+                        DendrogramWidget.SingleSelection,
+                        DendrogramWidget.ExtendedSelection]
+
+        if self.__selectionMode != mode:
+            self.__selectionMode = mode
+            if self.__selectionMode == DendrogramWidget.NoSelection and \
+                    self._selection:
+                self.setSelectedClusters([])
+            elif self.__selectionMode == DendrogramWidget.SingleSelection and \
+                    len(self._selection) > 1:
+                self.setSelectedClusters([self.selected_nodes()[-1]])
+
+    def selectionMode(self):
+        """
+        Return the current selection mode.
+        """
+        return self.__selectionMode
+
+    def setHoverHighlightEnabled(self, enabled):
+        if self.__hoverHighlightEnabled != bool(enabled):
+            self.__hoverHighlightEnabled = bool(enabled)
+            if self._highlighted_item is not None:
+                self._set_hover_item(None)
+
+    def isHoverHighlightEnabled(self):
+        return self.__hoverHighlightEnabled
+
     def clear(self):
+        """
+        Clear the widget.
+        """
         scene = self.scene()
         if scene is not None:
             scene.removeItem(self._itemgroup)
@@ -299,10 +335,15 @@ def clear(self):
         self._cluster_parent = {}
         self.updateGeometry()
 
-    def set_root(self, root):
-        """Set the root cluster.
+    def setRoot(self, root):
+        # type: (Tree) -> None
+        """
+        Set the root cluster tree node for display.
 
-        :param Tree root: Root tree.
+        Parameters
+        ----------
+        root : Tree
+            The tree root node.
         """
         self.clear()
         self._root = root
@@ -322,17 +363,30 @@ def set_root(self, root):
             self._relayout()
             self._rescale()
         self.updateGeometry()
+    set_root = setRoot
 
-    def item(self, node):
-        """Return the DendrogramNode instance representing the cluster.
+    def root(self):
+        # type: () -> Tree
+        """
+        Return the cluster tree root node.
 
-        :type cluster: :class:`Tree`
+        Returns
+        -------
+        root : Tree
+        """
+        return self._root
 
+    def item(self, node):
+        # type: (Tree) -> DendrogramWidget.ClusterGraphicsItem
+        """
+        Return the ClusterGraphicsItem instance representing the cluster `node`.
         """
         return self._items.get(node)
 
-    def height_at(self, point):
-        """Return the cluster height at the point in widget local coordinates.
+    def heightAt(self, point):
+        # type: (QPointF) -> float
+        """
+        Return the cluster height at the point in widget local coordinates.
         """
         if not self._root:
             return 0
@@ -356,10 +410,12 @@ def height_at(self, point):
         if self.orientation in [self.Left, self.Bottom]:
             height = Fr(base) - Fr(height)
         return float(height)
+    height_at = heightAt
 
-    def pos_at_height(self, height):
-        """Return a point in local coordinates for `height` (in cluster
-        height scale).
+    def posAtHeight(self, height):
+        # type: (float) -> float
+        """
+        Return a point in local coordinates for `height` (in cluster
         """
         if not self._root:
             return QPointF()
@@ -374,6 +430,7 @@ def pos_at_height(self, height):
         else:
             p = QPointF(0, height)
         return self._transform.map(p)
+    pos_at_height = posAtHeight
 
     def _set_hover_item(self, item):
         """Set the currently highlighted item."""
@@ -394,32 +451,34 @@ def branches(item):
             for it in postorder(item, branches):
                 it.setPen(hpen)
 
-    def leaf_items(self):
+    def leafItems(self):
         """Iterate over the dendrogram leaf items (:class:`QGraphicsItem`).
         """
         if self._root:
             return (self._items[leaf] for leaf in leaves(self._root))
         else:
             return iter(())
+    leaf_items = leafItems
 
-    def leaf_anchors(self):
+    def leafAnchors(self):
         """Iterate over the dendrogram leaf anchor points (:class:`QPointF`).
 
         The points are in the widget local coordinates.
         """
-        for item in self.leaf_items():
+        for item in self.leafItems():
             anchor = QPointF(item.element.anchor)
             yield self.mapFromItem(item, anchor)
+    leaf_anchors = leafAnchors
 
-    def selected_nodes(self):
-        """Return the selected clusters."""
+    def selectedNodes(self):
+        """
+        Return the selected cluster nodes.
+        """
         return [item.node for item in self._selection]
+    selected_nodes = selectedNodes
 
-    def set_selected_items(self, items):
-        """Set the item selection.
-
-        :param items: List of `GraphicsItems`s to select.
-        """
+    def setSelectedItems(self, items: List[ClusterGraphicsItem]):
+        """Set the item selection."""
         to_remove = set(self._selection) - set(items)
         to_add = set(items) - set(self._selection)
 
@@ -431,27 +490,26 @@ def set_selected_items(self, items):
         if to_add or to_remove:
             self._re_enumerate_selections()
             self.selectionChanged.emit()
+    set_selected_items = setSelectedItems
 
-    def set_selected_clusters(self, clusters):
+    def setSelectedClusters(self, clusters: List[Tree]) -> None:
         """Set the selected clusters.
-
-        :param Tree items: List of cluster nodes to select .
         """
-        self.set_selected_items(list(map(self.item, clusters)))
+        self.setSelectedItems(list(map(self.item, clusters)))
+    set_selected_clusters = setSelectedClusters
 
-    def is_selected(self, item):
+    def isItemSelected(self, item: ClusterGraphicsItem) -> bool:
+        """Is `item` selected (is a root of a selection)."""
         return item in self._selection
 
-    def is_included(self, item):
+    def isItemIncludedInSelection(self, item: ClusterGraphicsItem) -> bool:
+        """Is item included in any selection."""
         return self._selected_super_item(item) is not None
+    is_included = isItemIncludedInSelection
 
-    def select_item(self, item, state):
-        """Set the `item`s selection state to `select_state`
-
-        :param item: QGraphicsItem.
-        :param bool state: New selection state for item.
-
-        """
+    def setItemSelected(self, item, state):
+        # type: (ClusterGraphicsItem, bool) -> None
+        """Set the `item`s selection state to `state`."""
         if state is False and item not in self._selection or \
                 state is True and item in self._selection:
             return  # State unchanged
@@ -482,6 +540,7 @@ def select_item(self, item, state):
 
             self._re_enumerate_selections()
             self.selectionChanged.emit()
+    select_item = setItemSelected
 
     @staticmethod
     def _create_path(item, path):
@@ -493,7 +552,6 @@ def _create_path(item, path):
             ppath = path_outline(ppath, width=-8)
         return ppath
 
-
     @staticmethod
     def _create_label(i):
         return f"C{i + 1}"
@@ -505,7 +563,7 @@ def _add_selection(self, item):
         path = self._transform.map(outline)
         ppath = self._create_path(item, path)
         label = self._create_label(len(self._selection))
-        selection_item = self.SelectionItem(self, ppath, outline, label)
+        selection_item = self._SelectionItem(self, ppath, outline, label)
         selection_item.setPos(self.contentsRect().topLeft())
         self._selection[item] = selection_item
 
@@ -697,7 +755,8 @@ def _rescale(self):
         self._selection_items = None
         self._update_selection_items()
 
-    def sizeHint(self, which, constraint=QSizeF()):
+    def sizeHint(self, which: Qt.SizeHint, constraint=QSizeF()) -> QRectF:
+        # reimplemented
         fm = QFontMetrics(self.font())
         spacing = fm.lineSpacing()
         mleft, mtop, mright, mbottom = self.getContentsMargins()
@@ -726,31 +785,31 @@ def sceneEventFilter(self, obj, event):
             elif event.type() == QEvent.GraphicsSceneMousePress and \
                     event.button() == Qt.LeftButton:
 
-                is_selected = self.is_selected(obj)
+                is_selected = self.isItemSelected(obj)
                 is_included = self.is_included(obj)
                 current_selection = list(self._selection)
 
                 if self.__selectionMode == DendrogramWidget.SingleSelection:
                     if event.modifiers() & Qt.ControlModifier:
-                        self.set_selected_items(
+                        self.setSelectedItems(
                             [obj] if not is_selected else [])
                     elif event.modifiers() & Qt.AltModifier:
-                        self.set_selected_items([])
+                        self.setSelectedItems([])
                     elif event.modifiers() & Qt.ShiftModifier:
                         if not is_included:
-                            self.set_selected_items([obj])
+                            self.setSelectedItems([obj])
                     elif current_selection != [obj]:
-                        self.set_selected_items([obj])
+                        self.setSelectedItems([obj])
                 elif self.__selectionMode == DendrogramWidget.ExtendedSelection:
                     if event.modifiers() & Qt.ControlModifier:
-                        self.select_item(obj, not is_selected)
+                        self.setItemSelected(obj, not is_selected)
                     elif event.modifiers() & Qt.AltModifier:
-                        self.select_item(self._selected_super_item(obj), False)
+                        self.setItemSelected(self._selected_super_item(obj), False)
                     elif event.modifiers() & Qt.ShiftModifier:
                         if not is_included:
-                            self.select_item(obj, True)
+                            self.setItemSelected(obj, True)
                     elif current_selection != [obj]:
-                        self.set_selected_items([obj])
+                        self.setSelectedItems([obj])
 
                 if current_selection != self._selection:
                     self.selectionEdited.emit()
@@ -764,6 +823,7 @@ def sceneEventFilter(self, obj, event):
         return super().sceneEventFilter(obj, event)
 
     def changeEvent(self, event):
+        # reimplemented
         super().changeEvent(event)
 
         if event.type() == QEvent.FontChange:
@@ -774,11 +834,13 @@ def changeEvent(self, event):
             self._rescale()
 
     def resizeEvent(self, event):
+        # reimplemented
         super().resizeEvent(event)
         self._rescale()
 
     def mousePressEvent(self, event):
-        QGraphicsWidget.mousePressEvent(self, event)
+        # reimplemented
+        super().mousePressEvent(event)
         # A mouse press on an empty widget part
         if event.modifiers() == Qt.NoModifier and self._selection:
             self.set_selected_clusters([])