vispy 0.15.1__cp310-cp310-win_amd64.whl → 0.15.2__cp310-cp310-win_amd64.whl

vispy/scene/widgets/grid.py

@@ -4,7 +4,11 @@
 """Grid widget for providing a gridded layout to child widgets."""
 
 from __future__ import division
+
+from typing import Tuple, Union, Dict
+
 import numpy as np
+from numpy.typing import NDArray
 
 from vispy.geometry import Rect
 from .widget import Widget
@@ -21,17 +25,19 @@ class Grid(Widget):
 
     Parameters
     ----------
-    spacing : int
-        Spacing between widgets.
+    spacing : int | tuple[int, int]
+        Spacing between widgets. If `tuple` then it must be of length two, the first element
+        being `width_spacing` and the second being `height_spacing`.
     **kwargs : dict
         Keyword arguments to pass to `Widget`.
     """
 
-    def __init__(self, spacing=6, **kwargs):
+    def __init__(self, spacing=0, **kwargs):
         """Create solver and basic grid parameters."""
         self._next_cell = [0, 0]  # row, col
         self._cells = {}
         self._grid_widgets = {}
+
         self.spacing = spacing
         self._n_added = 0
         self._default_class = ViewBox  # what to add when __getitem__ is used
@@ -45,9 +51,6 @@ class Grid(Widget):
         self._width_grid = None
         self._height_grid = None
 
-        # self._height_stay = None
-        # self._width_stay = None
-
         Widget.__init__(self, **kwargs)
 
     def __getitem__(self, idxs):
@@ -256,53 +259,129 @@ class Grid(Widget):
             locs[r:r + rs, c:c + cs] = key
         return locs
 
+    @property
+    def spacing(self):
+        """
+        The spacing between individual Viewbox widgets in the grid.
+        """
+        return self._spacing
+
+    @spacing.setter
+    def spacing(self, value: Union[int, Tuple[int, int]]):
+        if not (
+            isinstance(value, int)
+            or isinstance(value, tuple)
+            and len(value) == 2
+            and isinstance(value[0], int)
+            and isinstance(value[1], int)
+        ):
+            raise ValueError('spacing must be of type int | tuple[int, int]')
+
+        self._spacing = value
+        self._need_solver_recreate = True
+
     def __repr__(self):
         return (('<Grid at %s:\n' % hex(id(self))) +
                 str(self.layout_array + 1) + '>')
 
     @staticmethod
-    def _add_total_width_constraints(solver, width_grid, _var_w):
-        for ws in width_grid:
-            width_expr = ws[0]
-            for w in ws[1:]:
-                width_expr += w
-            solver.addConstraint(width_expr == _var_w)
+    def _add_total_dim_length_constraints(solver: Solver, grid_dim_variables: NDArray[Variable],
+                                          n_added: int, _var_dim_length: Variable, spacing: float):
+        """Add constraint: total height == sum(col heights) + sum(spacing).
 
-    @staticmethod
-    def _add_total_height_constraints(solver, height_grid, _var_h):
-        for hs in height_grid:
-            height_expr = hs[0]
-            for h in hs[1:]:
-                height_expr += h
-            solver.addConstraint(height_expr == _var_h)
+        The total height of the grid is constrained to be equal to the sum of the heights of
+        its columns, including spacing between widgets.
+
+        Parameters
+        ----------
+        solver: Solver
+            Solver for a system of linear equations.
+        grid_dim_variables: NDArray[Variable]:
+            The grid of width or height variables of either shape col * row or row * col with each element being a
+            Variable in the solver representing the height or width of each grid box.
+        n_added: int
+            The number of ViewBoxes added to the grid.
+        _var_dim_length: Variable
+            The solver variable representing either total width or height of the grid.
+        spacing: float
+            The amount of spacing between single adjacent Viewbox widgets in the grid.
+        """
+        total_spacing = 0
+        if n_added > 1:
+            for _ in range(grid_dim_variables.shape[1] - 1):
+                total_spacing += spacing
+
+        for ds in grid_dim_variables:
+            dim_length_expr = ds[0]
+            for d in ds[1:]:
+                dim_length_expr += d
+            dim_length_expr += total_spacing
+            solver.addConstraint(dim_length_expr == _var_dim_length)
 
     @staticmethod
-    def _add_gridding_width_constraints(solver, width_grid):
+    def _add_gridding_dim_constraints(solver: Solver, grid_dim_variables: NDArray[Variable]):
+        """Add constraint: all viewbox dims in each dimension are equal.
+
+        With all dims the reserved space for a widget with a col_span and row_span of 1 is meant, e.g. we have 3
+        widgets arranged in columns or rows with col_span or row_span 1 and those are being constrained to all be of
+        width/height 100. In other words the same dim length is reserved for each position in the grid, not taking
+        into account the spacing between grid positions.
+
+        Parameters
+        ----------
+        solver: Solver
+            Solver for a system of linear equations.
+        grid_dim_variables:
+            The grid of width or height variables of either shape col * row or row * col with each element being a
+            Variable in the solver representing the height or width of each grid box.
+        """
         # access widths of one "y", different x
-        for ws in width_grid.T:
-            for w in ws[1:]:
-                solver.addConstraint(ws[0] == w)
+        for ds in grid_dim_variables.T:
+            for d in ds[1:]:
+                solver.addConstraint(ds[0] == d)
 
     @staticmethod
-    def _add_gridding_height_constraints(solver, height_grid):
-        # access heights of one "y"
-        for hs in height_grid.T:
-            for h in hs[1:]:
-                solver.addConstraint(hs[0] == h)
+    def _add_stretch_constraints(solver: Solver, width_grid: NDArray[Variable] , height_grid: NDArray[Variable],
+                                 grid_widgets: Dict[int, Tuple[int, int, int, int, ViewBox]],
+                                 widget_grid: NDArray[ViewBox]):
+        """
+        Add proportional stretch constraints to the linear system solver of the grid.
 
-    @staticmethod
-    def _add_stretch_constraints(solver, width_grid, height_grid,
-                                 grid_widgets, widget_grid):
+        This method enforces that grid rows and columns stretch in proportion
+        to the widgets' specified stretch factors. It uses weak constraints
+        so that proportionality is preserved when possible but can be violated
+        if stronger layout constraints are present.
+
+        Parameters
+        ----------
+        solver : Solver
+            Solver for a system of linear equations.
+        width_grid : NDArray[Variable]
+            The grid of width variables in the linear system of equations to be solved.
+        height_grid : NDArray[Variable]
+            The grid of height variables in the linear system of equations to be solved.
+        grid_widgets : dict[int, tuple[int, int, int, int, ViewBox]]
+            Dictionary mapping order of viewboxes added as int to their grid layout description:
+            (start_y, start_x, span_y, span_x, ViewBox).
+        widget_grid : NDArray[ViewBox]
+            Array of viewboxes in shape n_columns x n_rows.
+
+        Notes
+        -----
+        - Stretch constraints are added with 'weak' strength, allowing them to
+          be overridden by stronger constraints such as fixed sizes or min/max bounds.
+        - The constraint `total_size / stretch_factor` is used to maintain
+          proportional relationships among rows and columns.
+        """
         xmax = len(height_grid)
         ymax = len(width_grid)
 
-        stretch_widths = [[] for _ in range(0, ymax)]
-        stretch_heights = [[] for _ in range(0, xmax)]
+        stretch_widths = [[] for _ in range(ymax)]
+        stretch_heights = [[] for _ in range(xmax)]
 
         for (y, x, ys, xs, widget) in grid_widgets.values():
             for ws in width_grid[y:y+ys]:
                 total_w = np.sum(ws[x:x+xs])
-
                 for sw in stretch_widths[y:y+ys]:
                     sw.append((total_w, widget.stretch[0]))
 
@@ -339,14 +418,36 @@ class Grid(Widget):
                                      'weak')
 
     @staticmethod
-    def _add_widget_dim_constraints(solver, width_grid, height_grid,
-                                    total_var_w, total_var_h, grid_widgets):
+    def _add_widget_dim_constraints(solver: Solver, width_grid: NDArray[Variable], height_grid: NDArray[Variable],
+                                    total_var_w: Variable, total_var_h: Variable,
+                                    grid_widgets: Dict[int, Tuple[int, int, int, int, ViewBox]]):
+        """Add constraints based on min/max width/height of widgets.
+
+        These constraints ensure that each widget's dimensions stay within its
+        specified minimum and maximum values.
+
+        Parameters
+        ----------
+        solver : Solver
+            Solver for a system of linear equations.
+        width_grid : NDArray[Variable]
+            The grid of width variables in the linear system of equations to be solved.
+        height_grid : NDArray[Variable]
+            The grid of height variables in the linear system of equations to be solved.
+        total_var_w : Variable
+            The Variable representing the total width of the grid in the linear system of equations.
+        total_var_w : Variable
+            The Variable representing the total height of the grid in the linear system of equations.
+        grid_widgets : dict[int, tuple[int, int, int, int, ViewBox]]
+            Dictionary mapping order of viewboxes added as int to their grid layout description:
+            (start_y, start_x, span_y, span_x, ViewBox).
+                """
         assert(total_var_w is not None)
         assert(total_var_h is not None)
 
         for ws in width_grid:
             for w in ws:
-                solver.addConstraint(w >= 0,)
+                solver.addConstraint(w >= 0)
 
         for hs in height_grid:
             for h in hs:
@@ -375,6 +476,7 @@ class Grid(Widget):
                     solver.addConstraint(total_h <= total_var_h)
 
     def _recreate_solver(self):
+        """Recreate the linear system solver with all constraints."""
         self._solver.reset()
         self._var_w = Variable("w_rect")
         self._var_h = Variable("h_rect")
@@ -390,43 +492,40 @@ class Grid(Widget):
         self._solver.addConstraint(self._var_w >= 0)
         self._solver.addConstraint(self._var_h >= 0)
 
-        # self._height_stay = None
-        # self._width_stay = None
-
         # add widths
-        self._width_grid = np.array([[Variable("width(x: %s, y: %s)" % (x, y))
-                                      for x in range(0, xmax)]
-                                     for y in range(0, ymax)])
+        self._width_grid = np.array(
+            [
+                [Variable(f"width(x: {x}, y: {y})") for x in range(xmax)]
+                for y in range(ymax)
+            ]
+        )
 
         # add heights
-        self._height_grid = np.array([[Variable("height(x: %s, y: %s" % (x, y))
-                                       for y in range(0, ymax)]
-                                      for x in range(0, xmax)])
-
-        # setup stretch
-        stretch_grid = np.zeros(shape=(xmax, ymax, 2), dtype=float)
-        stretch_grid.fill(1)
-
-        for (_, val) in self._grid_widgets.items():
-            (y, x, ys, xs, widget) = val
-            stretch_grid[x:x+xs, y:y+ys] = widget.stretch
-
+        self._height_grid = np.array(
+            [
+                [Variable(f"height(x: {x}, y: {y})") for y in range(ymax)]
+                for x in range(xmax)
+            ]
+        )
+
+        if isinstance(self.spacing, tuple):
+            width_spacing, height_spacing = self.spacing
+        else:
+            width_spacing = height_spacing = self.spacing
         # even though these are REQUIRED, these should never fail
         # since they're added first, and thus the slack will "simply work".
-        Grid._add_total_width_constraints(self._solver,
-                                          self._width_grid, self._var_w)
-        Grid._add_total_height_constraints(self._solver,
-                                           self._height_grid, self._var_h)
+        Grid._add_total_dim_length_constraints(self._solver,
+                                          self._width_grid, self._n_added, self._var_w, width_spacing)
+        Grid._add_total_dim_length_constraints(self._solver,
+                                           self._height_grid, self._n_added, self._var_h, height_spacing)
 
         try:
             # these are REQUIRED constraints for width and height.
             # These are the constraints which can fail if
             # the corresponding dimension of the widget cannot be fit in the
             # grid.
-            Grid._add_gridding_width_constraints(self._solver,
-                                                 self._width_grid)
-            Grid._add_gridding_height_constraints(self._solver,
-                                                  self._height_grid)
+            Grid._add_gridding_dim_constraints(self._solver, self._width_grid)
+            Grid._add_gridding_dim_constraints(self._solver, self._height_grid)
         except UnsatisfiableConstraint:
             self._need_solver_recreate = True
 
@@ -436,24 +535,27 @@ class Grid(Widget):
                                       self._width_grid,
                                       self._height_grid,
                                       self._grid_widgets,
-                                      self._widget_grid)
+                                      self._widget_grid,
+                                      )
 
         Grid._add_widget_dim_constraints(self._solver,
                                          self._width_grid,
                                          self._height_grid,
                                          self._var_w,
                                          self._var_h,
-                                         self._grid_widgets)
+                                         self._grid_widgets
+                                         )
 
         self._solver.updateVariables()
 
     def _update_child_widget_dim(self):
+        """Solve the linear system of equations in order to assign Viewbox parameters such as position."""
         # think in terms of (x, y). (row, col) makes code harder to read
         ymax, xmax = self.grid_size
         if ymax <= 0 or xmax <= 0:
             return
 
-        rect = self.rect  # .padded(self.padding + self.margin)
+        rect = self.rect.padded(self.padding + self.margin)
         if rect.width <= 0 or rect.height <= 0:
             return
         if self._need_solver_recreate:
@@ -474,22 +576,40 @@ class Grid(Widget):
 
         value_vectorized = np.vectorize(lambda x: x.value())
 
-        for (_, val) in self._grid_widgets.items():
+        if isinstance(self.spacing, tuple):
+            width_spacing, height_spacing = self.spacing
+        else:
+            width_spacing = height_spacing = self.spacing
+
+        for index, (_, val) in enumerate(self._grid_widgets.items()):
             (row, col, rspan, cspan, widget) = val
 
+            # If spacing, always one spacing unit between 2 grid positions, even when span is > 1.
+            # If span is > 1, spacing will be added to the dim length of Viewbox
+            spacing_width_offset = col * width_spacing if self._n_added > 1 else 0
+            spacing_height_offset = row * height_spacing if self._n_added > 1 else 0
+
+            # Add one spacing unit to dim length of the Viewbox per grid positions the ViewBox spans if span > 1.
+            width_increase_spacing = width_spacing * (cspan - 1)
+            height_increase_spacing = height_spacing * (rspan - 1)
+
             width = np.sum(value_vectorized(
-                           self._width_grid[row][col:col+cspan]))
+                           self._width_grid[row][col:col+cspan])) + width_increase_spacing
             height = np.sum(value_vectorized(
-                            self._height_grid[col][row:row+rspan]))
+                            self._height_grid[col][row:row+rspan])) + height_increase_spacing
+
             if col == 0:
                 x = 0
             else:
-                x = np.sum(value_vectorized(self._width_grid[row][0:col]))
+                x = np.sum(value_vectorized(self._width_grid[row][:col])) + spacing_width_offset
 
             if row == 0:
                 y = 0
             else:
-                y = np.sum(value_vectorized(self._height_grid[col][0:row]))
+                y = np.sum(value_vectorized(self._height_grid[col][:row])) + spacing_height_offset
+
+            x += self.padding
+            y += self.padding
 
             if isinstance(widget, ViewBox):
                 widget.rect = Rect(x, y, width, height)

vispy/scene/widgets/widget.py

@@ -312,6 +312,17 @@ class Widget(Compound):
         self._update_line()
         self.update()
 
+    @property
+    def border_width(self):
+        """The width of the border."""
+        return self._border_width
+
+    @border_width.setter
+    def border_width(self, b):
+        self._border_width = float(b)
+        self._update_line()
+        self.update()
+
     @property
     def bgcolor(self):
         """The background color of the Widget."""

vispy/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.15.1'
-__version_tuple__ = version_tuple = (0, 15, 1)
+__version__ = version = '0.15.2'
+__version_tuple__ = version_tuple = (0, 15, 2)

{vispy-0.15.1.dist-info → vispy-0.15.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vispy
-Version: 0.15.1
+Version: 0.15.2
 Summary: Interactive visualization in Python
 Home-page: http://vispy.org
 Download-URL: https://pypi.python.org/pypi/vispy

{vispy-0.15.1.dist-info → vispy-0.15.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 vispy/__init__.py,sha256=Q-ECX_hCYaK0N0nHaVUQM6bNTUf4A3uGTxGcnlY2FFU,935
 vispy/conftest.py,sha256=SUNIUsn7o-cQa0mDMAhxoyeU_ENZjqO5B_xTJSNi-yQ,501
-vispy/version.py,sha256=ulS2RZ9STsnWuZeHLOlxa2v2JVm3vz4cADUp-FUtCQU,534
+vispy/version.py,sha256=FcgcUHimv_-asWfNIYd3Rsj0Nwxxy5PM5GkTpNL_x7g,534
 vispy/app/__init__.py,sha256=NDhvVlPpRUm5zkfs4L1VwbdE1Hhg7dGEkI28RYH2KTM,640
 vispy/app/_default_app.py,sha256=ACldZQfK7nl2zGInuJBsCm1sfFKZE-UFBgSeavG8gVo,2497
 vispy/app/_detect_eventloop.py,sha256=h7IMsSZXuIAz9M3bezB_gB2BQqcfiPcdpo5vAn8cd7Y,6622
@@ -296,10 +296,10 @@ vispy/scene/widgets/anchor.py,sha256=EHuMUcdR7HZYNlfgMwuRzP8bD65EXElF8AVXxptsi7o
 vispy/scene/widgets/axis.py,sha256=rv2Egm1Fukybm08m--GDqxsIlk9-qkUHPSWtAJSM3Do,3042
 vispy/scene/widgets/colorbar.py,sha256=kGgNv4gwzLfXpjOu8oZNS1kXozH02L7ymeHWym7EqmE,6334
 vispy/scene/widgets/console.py,sha256=NqM_5k97owZfGigtnTRkopfy9PzM067SW0Y0HMbmHGI,14364
-vispy/scene/widgets/grid.py,sha256=SOXH5UT2qNlKVPrrNQOIm_rAFrG1IB-ngFiwO46l_8I,19165
+vispy/scene/widgets/grid.py,sha256=qQ4JL-oop_nka8mgI0eICNkRBc7kpLhTxaz97znBoFE,25429
 vispy/scene/widgets/label.py,sha256=t_UuHoqezAJZA7HZHfczRIZ0Yu2bjvQLe9ACsfyfmvs,1358
 vispy/scene/widgets/viewbox.py,sha256=_JjowJ5U8MJtaFduOk0wvIec59TKRKU3dffcIkkVti4,6873
-vispy/scene/widgets/widget.py,sha256=489bq_DqHGGwBxtxfCSPBkfGlFjT6Zp37DCygmnKsRI,14341
+vispy/scene/widgets/widget.py,sha256=3n78S_HJd_IJgf8fN6odp_z0qYy7OSRd5oV5ZONdnhI,14613
 vispy/scene/widgets/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/scene/widgets/tests/test_colorbar.py,sha256=f1FeuORX6gNAlpOM8UwTTjbP1Wj4T9cX3W3q61OWkOw,1409
 vispy/testing/__init__.py,sha256=u0CuG-XtGGsOUwzCgMf6o7iLo-DVRjqDGFek1BGVO3c,2488
@@ -500,7 +500,7 @@ vispy/visuals/tests/test_text.py,sha256=webfWtJcSgUkj3QBtZ4kggrs5OdkGZGb0byYc4mt
 vispy/visuals/tests/test_volume.py,sha256=mepaB3ssWl0s4gFU_yYTlhsQ1TCCkg_KtdTkLvR2Brs,18120
 vispy/visuals/tests/test_windbarb.py,sha256=cqEEcAnPMf29ZloL2fWJo2N04lrJgmQnD-Kt8mXWEQA,1135
 vispy/visuals/text/__init__.py,sha256=qWgGDKR-ezH4ZzzGKfs72S_zOauVDn5snJ5uHnYv6LE,364
-vispy/visuals/text/_sdf_cpu.cp310-win_amd64.pyd,sha256=l13DEYD12VgSkdcSUc6sUwSWLb2JWZzqzIn9zclx-Tc,142336
+vispy/visuals/text/_sdf_cpu.cp310-win_amd64.pyd,sha256=8h2FaEte-WwGqgQkhpBWyMsGQ91EjD7Ykkck2wMUMFo,142336
 vispy/visuals/text/_sdf_cpu.pyx,sha256=ymPErgiHN9jhBFuj_GXnChAzTeDbGM-MUQl3lIlzENE,3922
 vispy/visuals/text/_sdf_gpu.py,sha256=XW5nKivmvUx7tA8LebC7u7N37QQfBcMSUrdPvkG9JU8,10796
 vispy/visuals/text/text.py,sha256=hK8oSjF34PfczzBa5V7nmsR6uCfI-eqcR3zUB73YpjA,25928
@@ -514,8 +514,8 @@ vispy/visuals/transforms/nonlinear.py,sha256=oiHDhqoM9E4rBGMmqZtVSJVspt1FgZORig6
 vispy/visuals/transforms/transform_system.py,sha256=dKRMid1Gm0bhh9K_v1RiC-xxbmQF61OHz_0Ur8GdMmU,14098
 vispy/visuals/transforms/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/visuals/transforms/tests/test_transforms.py,sha256=QbAo0I3g5VkaQzzsZ03zktP-ge2JiXQeD2rqV6_LK7o,7114
-vispy-0.15.1.dist-info/licenses/LICENSE.txt,sha256=P3Z4TJCTzLqGNr2AqFiKF7o5T9LmKWb0FfaY0VN1bnA,1810
-vispy-0.15.1.dist-info/METADATA,sha256=g2efwbCtuEoxwGGoSSwi-qs3PKDNJYg4QiBsQ9-yCg4,9221
-vispy-0.15.1.dist-info/WHEEL,sha256=dxB0iZ3Mvzd8V_Aq2NX6qUGg5t_kvD8jd3ilOpEpgek,101
-vispy-0.15.1.dist-info/top_level.txt,sha256=mciStn1SI48jYwEhJXlrMJ3HaJ90XOr5ZGJ8YdFI674,6
-vispy-0.15.1.dist-info/RECORD,,
+vispy-0.15.2.dist-info/licenses/LICENSE.txt,sha256=P3Z4TJCTzLqGNr2AqFiKF7o5T9LmKWb0FfaY0VN1bnA,1810
+vispy-0.15.2.dist-info/METADATA,sha256=owPWvLknX3dW9nfORM763J-AtIHhiT7VMg0Els9PZ0s,9221
+vispy-0.15.2.dist-info/WHEEL,sha256=KuuxPnOSDo1K7Ftl6Qe10qwYOgcJ4uyjbQRY_npPeyg,101
+vispy-0.15.2.dist-info/top_level.txt,sha256=mciStn1SI48jYwEhJXlrMJ3HaJ90XOr5ZGJ8YdFI674,6
+vispy-0.15.2.dist-info/RECORD,,

{vispy-0.15.1.dist-info → vispy-0.15.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.6.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: false
 Tag: cp310-cp310-win_amd64