widgets: Outsource buttons layout calculation

doronbehar · doronbehar · commit 7ef400de459a · 2025-12-07T21:16:22.000+02:00
diff --git a/lib/matplotlib/widgets.py b/lib/matplotlib/widgets.py
@@ -1558,6 +1558,150 @@ def disconnect(self, cid):
         self._observers.disconnect(cid)
 
 
+def _calculate_widget_button_layout(ax, labels, label_props, layout):
+    """
+    Calculate positions for button widgets (RadioButtons, CheckButtons).
+
+    Parameters
+    ----------
+    ax : `~matplotlib.axes.Axes`
+        The Axes to calculate positions for.
+    labels : list of str
+        The button labels.
+    label_props : iterable of dict
+        Text properties for each label (from _expand_text_props).
+    layout : None, "vertical", "horizontal", or (int, int)
+        The layout specification:
+        - None: Use legacy vertical layout (fixed positions).
+        - "vertical": Arrange buttons in a single column.
+        - "horizontal": Arrange buttons in a single row.
+        - (rows, cols): Arrange buttons in a grid.
+
+    Returns
+    -------
+    button_xs : list of float
+        X coordinates for buttons in axes coordinates.
+    button_ys : list of float
+        Y coordinates for buttons in axes coordinates.
+    label_xs : list of float
+        X coordinates for labels in axes coordinates.
+    label_ys : list of float
+        Y coordinates for labels in axes coordinates.
+    """
+    n_labels = len(labels)
+
+    if layout is None:
+        # Legacy behavior: simple vertical layout with fixed positions
+        ys = np.linspace(1, 0, n_labels + 2)[1:-1]
+        button_xs = [0.15] * n_labels
+        button_ys = list(ys)
+        label_xs = [0.25] * n_labels
+        label_ys = list(ys)
+        return button_xs, button_ys, label_xs, label_ys
+
+    # New layout algorithm with text measurement
+    # Parse layout parameter
+    bad_layout_raise_msg = \
+        "layout must be None, 'vertical', 'horizontal', or a (rows, cols) tuple; " \
+        f"got {layout!r}"
+    if isinstance(layout, str):
+        if layout == "vertical":
+            n_rows, n_cols = n_labels, 1
+        elif layout == "horizontal":
+            n_rows, n_cols = 1, n_labels
+        else:
+            raise ValueError(bad_layout_raise_msg)
+    elif isinstance(layout, tuple) and len(layout) == 2:
+        n_rows, n_cols = layout
+        if not (isinstance(n_rows, int) and isinstance(n_cols, int)):
+            raise TypeError(
+                f"layout tuple must contain two integers; got {layout!r}"
+            )
+        if n_rows * n_cols < n_labels:
+            raise ValueError(
+                f"layout {layout} has {n_rows * n_cols} positions but "
+                f"{n_labels} labels were provided"
+            )
+    else:
+        raise ValueError(bad_layout_raise_msg)
+
+    # Define spacing in display units (pixels) for consistency
+    # across different axes sizes
+    axes_width_display = ax.bbox.width
+    left_margin_display = 15  # pixels
+    button_text_offset_display = 6.5  # pixels
+    col_spacing_display = 15  # pixels
+
+    # Convert to axes coordinates
+    left_margin = left_margin_display / axes_width_display
+    button_text_offset = button_text_offset_display / axes_width_display
+    col_spacing = col_spacing_display / axes_width_display
+
+    # Create temporary text objects to measure widths
+    temp_texts = []
+    for label, props in zip(labels, label_props):
+        temp_texts.append(ax.text(
+            0,
+            0,
+            label,
+            transform=ax.transAxes,
+            **props,
+        ))
+    # Force a draw to get accurate text measurements
+    ax.figure.canvas.draw()
+
+    # Calculate max text width per column (in axes coordinates)
+    col_widths = []
+    for col_idx in range(n_cols):
+        col_texts = []
+        for row_idx in range(n_rows):
+            label_idx = row_idx * n_cols + col_idx
+            if label_idx < n_labels:
+                col_texts.append(temp_texts[label_idx])
+        if col_texts:
+            col_widths.append(
+                max(
+                    text.get_window_extent(
+                        ax.figure.canvas.get_renderer()
+                    ).width
+                    for text in col_texts
+                ) / axes_width_display
+            )
+        else:
+            col_widths.append(0)
+    # Remove temporary text objects
+    for text in temp_texts:
+        text.remove()
+
+    # Center rows vertically in the axes
+    ys_per_row = np.linspace(1, 0, n_rows + 2)[1:-1]
+    # Calculate x positions based on text widths
+    col_x_positions = [left_margin]  # First column starts at left margin
+    for col_idx in range(n_cols - 1):
+        col_x_positions.append(
+            col_x_positions[-1] +
+            button_text_offset +
+            col_widths[col_idx] +
+            col_spacing
+        )
+    # Create final positions (left-to-right, top-to-bottom)
+    button_xs = []
+    button_ys = []
+    label_xs = []
+    label_ys = []
+    for label_idx in range(n_labels):
+        row_idx = label_idx // n_cols
+        col_idx = label_idx % n_cols
+        x = col_x_positions[col_idx]
+        y = ys_per_row[row_idx]
+        button_xs.append(x)
+        button_ys.append(y)
+        label_xs.append(x + button_text_offset)
+        label_ys.append(y)
+
+    return button_xs, button_ys, label_xs, label_ys
+
+
 class RadioButtons(AxesWidget):
     """
     A GUI neutral radio button.
@@ -1582,7 +1726,7 @@ class RadioButtons(AxesWidget):
     """
 
     def __init__(self, ax, labels, active=0, activecolor=None, *,
-                 layout="vertical", useblit=True, label_props=None, radio_props=None):
+                 layout=None, useblit=True, label_props=None, radio_props=None):
         """
         Add radio buttons to an `~.axes.Axes`.
 
@@ -1597,14 +1741,18 @@ def __init__(self, ax, labels, active=0, activecolor=None, *,
         activecolor : :mpltype:`color`
             The color of the selected button. The default is ``'blue'`` if not
             specified here or in *radio_props*.
-        layout : {"vertical", "horizontal"} or (int, int), default: "vertical"
+        layout : None, {"vertical", "horizontal"} or (int, int), default: None
             The layout of the radio buttons. Options are:
 
-            - ``"vertical"``: Arrange buttons in a single column (default).
-            - ``"horizontal"``: Arrange buttons in a single row.
+            - ``None``: Use legacy vertical layout (default, keeps backward
+              compatibility with fixed button and label positions).
+            - ``"vertical"``: Arrange buttons in a single column with
+              dynamic positioning based on text widths.
+            - ``"horizontal"``: Arrange buttons in a single row with
+              dynamic positioning based on text widths.
             - ``(rows, cols)`` tuple: Arrange buttons in a grid with the
               specified number of rows and columns. Buttons are placed
-              left-to-right, top-to-bottom.
+              left-to-right, top-to-bottom with dynamic positioning.
 
             .. versionadded:: 3.11
         useblit : bool, default: True
@@ -1640,31 +1788,6 @@ def __init__(self, ax, labels, active=0, activecolor=None, *,
         labels = list(labels)
         n_labels = len(labels)
 
-        bad_layout_raise_msg = \
-            "layout must be 'vertical', 'horizontal', or a (rows, cols) tuple; " \
-            f"got {layout!r}"
-        # Parse layout parameter
-        if isinstance(layout, str):
-            if layout == "vertical":
-                n_rows, n_cols = n_labels, 1
-            elif layout == "horizontal":
-                n_rows, n_cols = 1, n_labels
-            else:
-                raise ValueError(bad_layout_raise_msg)
-        elif isinstance(layout, tuple) and len(layout) == 2:
-            n_rows, n_cols = layout
-            if not (isinstance(n_rows, int) and isinstance(n_cols, int)):
-                raise TypeError(
-                    f"layout tuple must contain two integers; got {layout!r}"
-                )
-            if n_rows * n_cols < n_labels:
-                raise ValueError(
-                    f"layout {layout} has {n_rows * n_cols} positions but "
-                    f"{n_labels} labels were provided"
-                )
-        else:
-            raise ValueError(bad_layout_raise_msg)
-
         radio_props = cbook.normalize_kwargs(radio_props,
                                              collections.PathCollection)
         if activecolor is not None:
@@ -1690,81 +1813,16 @@ def __init__(self, ax, labels, active=0, activecolor=None, *,
 
         label_props = _expand_text_props(label_props)
 
-        # Define spacing in display units (pixels) for consistency
-        # across different axes sizes
-        axes_width_display = ax.bbox.width
-        left_margin_display = 15  # pixels
-        button_text_offset_display = 6.5  # pixels
-        col_spacing_display = 15  # pixels
-
-        # Convert to axes coordinates
-        left_margin = left_margin_display / axes_width_display
-        button_text_offset = button_text_offset_display / axes_width_display
-        col_spacing = col_spacing_display / axes_width_display
-
-        # Create temporary text objects to measure widths
-        temp_texts = []
-        for label, props in zip(labels, label_props):
-            temp_texts.append(ax.text(
-                0,
-                0,
-                label,
-                transform=ax.transAxes,
-                **props,
-            ))
-        # Force a draw to get accurate text measurements
-        ax.figure.canvas.draw()
-
-        # Calculate max text width per column (in axes coordinates)
-        col_widths = []
-        for col_idx in range(n_cols):
-            col_texts = []
-            for row_idx in range(n_rows):
-                label_idx = row_idx * n_cols + col_idx
-                if label_idx < n_labels:
-                    col_texts.append(temp_texts[label_idx])
-            if col_texts:
-                col_widths.append(
-                    max(
-                        text.get_window_extent(
-                            ax.figure.canvas.get_renderer()
-                        ).width
-                        for text in col_texts
-                    ) / axes_width_display
-                )
-            else:
-                col_widths.append(0)
-        # Remove temporary text objects
-        for text in temp_texts:
-            text.remove()
-
-        # Center rows vertically in the axes
-        ys_per_row = np.linspace(1, 0, n_rows + 2)[1:-1]
-        # Calculate x positions based on text widths
-        col_x_positions = [left_margin]  # First column starts at left margin
-        for col_idx in range(n_cols - 1):
-            col_x_positions.append(
-                col_x_positions[-1] +
-                button_text_offset +
-                col_widths[col_idx] +
-                col_spacing
-            )
-        # Create final positions (left-to-right, top-to-bottom)
-        xs = []
-        ys = []
-        for label_idx in range(n_labels):
-            row_idx = label_idx // n_cols
-            col_idx = label_idx % n_cols
-            x = col_x_positions[col_idx]
-            y = ys_per_row[row_idx]
-            xs.append(x)
-            ys.append(y)
+        # Calculate button and label positions
+        button_xs, button_ys, label_xs, label_ys = _calculate_widget_button_layout(
+            ax, labels, label_props, layout
+        )
 
         self.labels = [
-            ax.text(x + button_text_offset, y, label, transform=ax.transAxes,
+            ax.text(x, y, label, transform=ax.transAxes,
                     horizontalalignment="left", verticalalignment="center",
                     **props)
-            for x, y, label, props in zip(xs, ys, labels, label_props)]
+            for x, y, label, props in zip(label_xs, label_ys, labels, label_props)]
         text_size = np.array([text.get_fontsize() for text in self.labels]) / 2
 
         radio_props = {
@@ -1777,7 +1835,7 @@ def __init__(self, ax, labels, active=0, activecolor=None, *,
         radio_props.setdefault('edgecolor', radio_props.get('color', 'black'))
         radio_props.setdefault('facecolor',
                                radio_props.pop('color', activecolor))
-        self._buttons = ax.scatter(xs, ys, **radio_props)
+        self._buttons = ax.scatter(button_xs, button_ys, **radio_props)
         # The user may have passed custom colours in radio_props, so we need to
         # create the radios, and modify the visibility after getting whatever
         # the user set.
diff --git a/lib/matplotlib/widgets.pyi b/lib/matplotlib/widgets.pyi
@@ -210,7 +210,7 @@ class RadioButtons(AxesWidget):
         active: int = ...,
         activecolor: ColorType | None = ...,
         *,
-        layout: Literal["vertical", "horizontal"] | tuple[int, int] = ...,
+        layout: Literal["vertical", "horizontal"] | tuple[int, int] | None = ...,
         useblit: bool = ...,
         label_props: dict[str, Sequence[Any]] | None = ...,
         radio_props: dict[str, Any] | None = ...,
