Source code for arcade.gui.widgets.layout

from __future__ import annotations

from dataclasses import dataclass
from typing import Dict, Iterable, List, Optional, Tuple, TypeVar

from typing_extensions import Literal, override

from arcade.gui.property import bind, unbind
from arcade.gui.widgets import UILayout, UIWidget, _ChildEntry

__all__ = ["UILayout", "UIAnchorLayout", "UIBoxLayout", "UIGridLayout"]

W = TypeVar("W", bound="UIWidget")


[docs] class UIAnchorLayout(UILayout): """Places children based on anchor values. Defaults to ``size_hint = (1, 1)``. Supports the options ``size_hint``, ``size_hint_min``, and ``size_hint_max``. Children are allowed to overlap. Child are resized based on ``size_hint``. ``size_hint_min/max`` only take effect if a ``size_hint`` is set. Allowed keyword options for :py:meth:`~arcade.gui.UIAnchorLayout.add`: - ``anchor_x``: ``str`` = ``None`` Horizontal anchor position for the layout. The class constant :py:attr:`~arcade.gui.UIAnchorLayout.default_anchor_x` is used as default. - ``anchor_y``: ``str`` = ``None`` Vertical anchor position for the layout. The class constant :py:attr:`~arcade.gui.UIAnchorLayout.default_anchor_y` is used as default. - ``align_x``: ``float`` = 0 Horizontal alignment for the layout. - ``align_y``: ``float`` = 0 Vertical alignement for the layout. Args: x: ``x`` coordinate of the bottom left corner. y: ``y`` coordinate of the bottom left corner. width: Width of the layout. height: Height of the layout. children: Initial list of children. More can be added later. size_hint: Size hint for :py:class:`~arcade.gui.UILayout` size_hint_min: Minimum width and height in pixels. size_hint_max: Maximum width and height in pixels. **kwargs: Additional keyword arguments passed to UILayout. """ default_anchor_x = "center" default_anchor_y = "center" _restrict_child_size = False """Whether to restrict the child size to the layout size. For scroll use cases this is not wanted, but for UITextWidgets it is. """ def __init__( self, *, x: float = 0, y: float = 0, width: float = 1, height: float = 1, children: Iterable["UIWidget"] = tuple(), size_hint=(1, 1), size_hint_min=None, size_hint_max=None, **kwargs, ): super().__init__( x=x, y=y, width=width, height=height, children=children, size_hint=size_hint, size_hint_min=size_hint_min, size_hint_max=size_hint_max, **kwargs, )
[docs] def do_layout(self): """Executes the layout algorithm. Children are placed based on their anchor values.""" for child, data in self._children: self._place_child(child, **data)
[docs] def add( self, child: W, *, anchor_x: Optional[str] = None, align_x: float = 0, anchor_y: Optional[str] = None, align_y: float = 0, **kwargs, ) -> W: """Add a widget to the layout as a child. Added widgets will receive all user-interface events and be rendered. By default, the latest added widget will receive events first and will be rendered on top of others. The widgets will be automatically placed within this widget. Args: child: Specified child widget to add. anchor_x: Horizontal anchor. Valid options are ``left``, ``right``, and ``center``. align_x: Offset or padding for the horizontal anchor. anchor_y: Vertical anchor. Valid options are ``top``, ``center``, and ``bottom``. align_y: Offset or padding for the vertical anchor. Returns: Given child that was just added to the layout. """ return super().add( child=child, anchor_x=anchor_x, align_x=align_x, anchor_y=anchor_y, align_y=align_y, **kwargs, )
def _place_child( self, child: UIWidget, anchor_x: Optional[str] = None, align_x: float = 0, anchor_y: Optional[str] = None, align_y: float = 0, ): anchor_x = anchor_x or self.default_anchor_x anchor_y = anchor_y or self.default_anchor_y # Handle size_hints new_child_rect = child.rect sh_w, sh_h = child.size_hint or (None, None) shmn_w, shmn_h = child.size_hint_min or (None, None) shmx_w, shmx_h = child.size_hint_max or (None, None) if sh_w is not None: new_child_rect = new_child_rect.resize(width=self.content_width * sh_w) if shmn_w: new_child_rect = new_child_rect.min_size(width=shmn_w) if shmx_w: new_child_rect = new_child_rect.max_size(width=shmx_w) if self._restrict_child_size: new_child_rect = new_child_rect.max_size(width=self.content_width) if sh_h is not None: new_child_rect = new_child_rect.resize(height=self.content_height * sh_h) if shmn_h: new_child_rect = new_child_rect.min_size(height=shmn_h) if shmx_h: new_child_rect = new_child_rect.max_size(height=shmx_h) if self._restrict_child_size: new_child_rect = new_child_rect.max_size(height=self.content_height) # Calculate position content_rect = self.content_rect anchor_x = "center_x" if anchor_x == "center" else anchor_x child_anchor_x_value = getattr(new_child_rect, anchor_x) own_anchor_x_value = getattr(content_rect, anchor_x) diff_x = own_anchor_x_value + align_x - child_anchor_x_value anchor_y = "center_y" if anchor_y == "center" else anchor_y child_anchor_y_value = getattr(new_child_rect, anchor_y) own_anchor_y_value = getattr(content_rect, anchor_y) diff_y = own_anchor_y_value + align_y - child_anchor_y_value # Check if changes are required if diff_x or diff_y or child.rect != new_child_rect: child.rect = new_child_rect.move(diff_x, diff_y)
[docs] class UIBoxLayout(UILayout): """Place widgets next to each other. Depending on the :py:class:`~arcade.gui.UIBoxLayout.vertical` attribute, the widgets are placed top to bottom or left to right. .. hint:: :py:class:`~arcade.gui.UIBoxLayout` does not adjust its own size if children are added. This requires a :py:class:`~arcade.gui.UIManager` or a :py:class:`~arcade.gui.UIAnchorLayout` as a parent. Or use :py:meth:`arcade.gui.UIBoxLayout.fit_content` to resize the layout. The bottom-left corner is used as the default anchor point. Supports the options: ``size_hint``, ``size_hint_min``, ``size_hint_max``. ``size_hint_min`` is automatically updated based on the minimal required space by children. If a child widget provides a ``size_hint`` for a dimension, the child will be resized within the given range of ``size_hint_min`` and ``size_hint_max`` (unrestricted if not given). If the parameter ``vertical`` is True, any available space (``layout size - min_size`` of children) will be distributed to the child widgets based on their ``size_hint``. Args: x: ``x`` coordinate of the bottom left corner. y: ``y`` coordinate of the bottom left corner. vertical: Layout children vertical (True) or horizontal (False). align: Align children in orthogonal direction:: - ``x``: ``left``, ``center``, and ``right`` - ``y``: ``top``, ``center``, and ``bottom`` children: Initial list of children. More can be added later. size_hint: Size hint for the :py:class:`~arcade.gui.UILayout` if the widget would like to grow. Defaults to ``0, 0`` -> minimal size to contain children. size_hint_max: Maximum width and height in pixels. space_between: Space in pixels between the children. """ def __init__( self, *, x=0, y=0, width=1, height=1, vertical=True, align="center", children: Iterable[UIWidget] = tuple(), size_hint=(0, 0), size_hint_max=None, space_between=0, style=None, **kwargs, ): super().__init__( x=x, y=y, width=width, height=height, children=children, size_hint=size_hint, size_hint_max=size_hint_max, style=style, **kwargs, ) self.align = align self.vertical = vertical self._space_between = space_between self._size_hint_requires_update = True bind(self, "_children", self._update_size_hints) bind(self, "_border_width", self._update_size_hints) bind(self, "_padding_left", self._update_size_hints) bind(self, "_padding_right", self._update_size_hints) bind(self, "_padding_top", self._update_size_hints) bind(self, "_padding_bottom", self._update_size_hints) self._update_size_hints()
[docs] @override def add(self, child: W, **kwargs) -> W: """Add a widget to this layout Args: child: The widget to add to the layout. """ # subscribe to child's changes, which might affect the own size hint bind(child, "_children", self._trigger_size_hint_update) bind(child, "rect", self._trigger_size_hint_update) bind(child, "size_hint", self._trigger_size_hint_update) bind(child, "size_hint_min", self._trigger_size_hint_update) bind(child, "size_hint_max", self._trigger_size_hint_update) return super().add(child, **kwargs)
[docs] @override def remove(self, child: "UIWidget"): """Remove a child from the layout.""" # unsubscribe from child's changes unbind(child, "_children", self._trigger_size_hint_update) unbind(child, "rect", self._trigger_size_hint_update) unbind(child, "size_hint", self._trigger_size_hint_update) unbind(child, "size_hint_min", self._trigger_size_hint_update) unbind(child, "size_hint_max", self._trigger_size_hint_update) return super().remove(child)
def _trigger_size_hint_update(self): self._size_hint_requires_update = True def _update_size_hints(self): self._size_hint_requires_update = False required_space_between = max(0, len(self.children) - 1) * self._space_between min_child_sizes = [UILayout.min_size_of(child) for child in self.children] if len(self.children) == 0: width = 0 height = 0 elif self.vertical: width = max(size[0] for size in min_child_sizes) height_of_children = sum(size[1] for size in min_child_sizes) height = height_of_children + required_space_between else: width_of_children = sum(size[0] for size in min_child_sizes) width = width_of_children + required_space_between height = max(size[1] for size in min_child_sizes) base_width = self._padding_left + self._padding_right + 2 * self._border_width base_height = self._padding_top + self._padding_bottom + 2 * self._border_width self.size_hint_min = base_width + width, base_height + height
[docs] def fit_content(self): """Resize the layout to fit the content. This will take the minimal required size into account.""" self._update_size_hints() self.rect = self.rect.resize(self.size_hint_min[0], self.size_hint_min[1])
[docs] def prepare_layout(self): """Updates the size hints if required.""" super().prepare_layout() if self._size_hint_requires_update: self._update_size_hints()
[docs] def do_layout(self): """Executes the layout algorithm. This method is called by the parent layout to place the children, after the rect was set. The layout algorithm will place the children based on the size hints next to each other. Depending on the vertical attribute, the children are placed top to bottom or left to right. """ start_y = self.content_rect.top start_x = self.content_rect.left if not self.children: return # main axis constraints = [ _C.from_widget_height(child) if self.vertical else _C.from_widget_width(child) for child, _ in self._children ] available_space = ( self.content_height if self.vertical else self.content_width ) - self._space_between * (len(self.children) - 1) main_sizes = _box_axis_algorithm(constraints, available_space) # orthogonal axis constraints = [ _C.from_widget_width(child) if self.vertical else _C.from_widget_height(child) for child, _ in self._children ] orthogonal_sizes = _box_orthogonal_algorithm( constraints, self.content_width if self.vertical else self.content_height ) for (child, data), main_size, ortho_size in zip( self._children, main_sizes, orthogonal_sizes ): # apply calculated sizes, condition regarding existing size_hint # are already covered in calculation input new_rect = child.rect.resize( height=main_size if self.vertical else ortho_size, width=ortho_size if self.vertical else main_size, ) new_rect = ( new_rect.align_x(start_x + self.content_width / 2) if self.vertical else new_rect.align_y(start_y - self.content_height // 2) ) # align on main and orthogonal axis and update start position if self.vertical: if self.align == "left": new_rect = new_rect.align_left(start_x) elif self.align == "right": new_rect = new_rect.align_right(start_x + self.content_width) else: center_x = start_x + self.content_width // 2 new_rect = new_rect.align_x(center_x) new_rect = new_rect.align_top(start_y) start_y -= main_size + self._space_between else: if self.align == "top": new_rect = new_rect.align_top(start_y) elif self.align == "bottom": new_rect = new_rect.align_bottom(start_y - self.content_height) else: center_y = start_y - self.content_height // 2 new_rect = new_rect.align_y(center_y) new_rect = new_rect.align_left(start_x) start_x += main_size + self._space_between # update child rect child.rect = new_rect
def __str__(self): return f"UIBoxLayout(vertical={self.vertical})"
[docs] class UIGridLayout(UILayout): """Place widgets in a grid. Widgets can span multiple columns and rows. By default, the layout will only use the minimal required space (``size_hint = (0, 0)``). Widgets can provide a ``size_hint`` to request dynamic space relative to the layout size. A size_hint of ``(1, 1)`` will fill the available space, while ``(0.1, 0.1)`` will use maximum 10% of the layouts total size. Children are resized based on ``size_hint``. Maximum and minimum ``size_hint``s only take effect if a ``size_hint`` is given. The layouts ``size_hint_min`` is automatically updated based on the minimal required space by children, after layouting. The width of columns and height of rows are calculated based on the size hints of the children. The highest size_hint_min of a child in a column or row is used. If a child has no size_hint, the actual size is considered. Args: x: ``x`` coordinate of bottom left corner. y: ``y`` coordinate of bottom left corner. width: Width of the layout. height: Height of the layout. align_horizontal: Align children in orthogonal direction. Options include ``left``, ``center``, and ``right``. align_vertical: Align children in orthogonal direction. Options include ``top``, ``center``, and ``bottom``. children: Initial list of children. More can be added later. size_hint: A size hint for :py:class:`~arcade.gui.UILayout`, if the :py:class:`~arcade.gui.UIWidget` would like to grow. size_hint_max: Maximum width and height in pixels. horizontal_spacing: Space between columns. vertical_spacing: Space between rows. column_count: Number of columns in the grid. This can be changed later. row_count: Number of rows in the grid. This can be changed later. """ def __init__( self, *, x=0, y=0, width=1, height=1, align_horizontal="center", align_vertical="center", children: Iterable[UIWidget] = tuple(), size_hint=(0, 0), size_hint_max=None, horizontal_spacing: int = 0, vertical_spacing: int = 0, column_count: int = 1, row_count: int = 1, **kwargs, ): super(UIGridLayout, self).__init__( x=x, y=y, width=width, height=height, children=children, size_hint=size_hint, size_hint_max=size_hint_max, **kwargs, ) self._size_hint_requires_update = True self._horizontal_spacing = horizontal_spacing self._vertical_spacing = vertical_spacing self.column_count = column_count self.row_count = row_count self.align_horizontal = align_horizontal self.align_vertical = align_vertical bind(self, "_children", self._trigger_size_hint_update) bind(self, "_border_width", self._trigger_size_hint_update) bind(self, "_padding_left", self._trigger_size_hint_update) bind(self, "_padding_right", self._trigger_size_hint_update) bind(self, "_padding_top", self._trigger_size_hint_update) bind(self, "_padding_bottom", self._trigger_size_hint_update) # initially update size hints # TODO is this required? self._update_size_hints()
[docs] def add( self, child: W, column: int = 0, row: int = 0, column_span: int = 1, row_span: int = 1, **kwargs, ) -> W: """Add a widget to the grid layout. Args: child: Specified widget to add as a child of the layout. column: Column index in which the widget is to be added. The first column at the left of the widget starts at 0. row: The row number in which the widget is to be added. The first row at the top of the layout is numbered 0. column_span: Number of columns the widget will stretch for. row_span: Number of rows the widget will stretch for. """ # subscribe to child's changes, which might affect the own size hint bind(child, "_children", self._trigger_size_hint_update) bind(child, "rect", self._trigger_size_hint_update) bind(child, "size_hint", self._trigger_size_hint_update) bind(child, "size_hint_min", self._trigger_size_hint_update) bind(child, "size_hint_max", self._trigger_size_hint_update) return super().add( child, column=column, row=row, column_span=column_span, row_span=row_span, **kwargs, )
[docs] def remove(self, child: "UIWidget"): """Remove a child from the layout.""" # unsubscribe from child's changes unbind(child, "_children", self._trigger_size_hint_update) unbind(child, "rect", self._trigger_size_hint_update) unbind(child, "size_hint", self._trigger_size_hint_update) unbind(child, "size_hint_min", self._trigger_size_hint_update) unbind(child, "size_hint_max", self._trigger_size_hint_update) return super().remove(child)
def _trigger_size_hint_update(self): self._size_hint_requires_update = True
[docs] def prepare_layout(self): """Updates the size hints if required.""" super().prepare_layout() if self._size_hint_requires_update: self._update_size_hints()
def _update_size_hints(self): self._size_hint_requires_update = False if not self.children: self.size_hint_min = (0, 0) return # 0. generate list for all rows and columns columns = [] for i in range(self.column_count): columns.append([]) rows = [] for i in range(self.row_count): rows.append([]) for entry in self._children: col_num = entry.data["column"] row_num = entry.data["row"] col_span = entry.data["column_span"] row_span = entry.data["row_span"] # we put the entry in all columns and rows it spans for c in range(col_span): columns[col_num + c].append(entry) for r in range(row_span): rows[row_num + r].append(entry) # 1.a per column, collect max of size_hint_min and max size_hint minimal_width_per_column = [] for col in columns: min_width = 0 max_sh = 0 for entry in col: col_span = entry.data["column_span"] # if the cell spans multiple columns, # we need to reduce the minimal required width by the horizontal spacing consumed_space = self._horizontal_spacing if col_span > 1 else 0 min_w, _ = UILayout.min_size_of(entry.child) min_width = max(min_width, min_w / col_span - consumed_space) shw, _ = entry.child.size_hint or (0, 0) max_sh = max(max_sh, shw) if shw else max_sh minimal_width_per_column.append(min_width) # 1.b per row, collect max of size_hint_min and max size_hint minimal_height_per_row = [] for row in rows: min_height = 0 max_sh = 0 for entry in row: row_span = entry.data["row_span"] # if the cell spans multiple rows, # we need to reduce the minimal required height by the vertical spacing consumed_space = self._vertical_spacing if row_span > 1 else 0 _, min_h = UILayout.min_size_of(entry.child) min_height = max(min_height, min_h / row_span - consumed_space) _, shh = entry.child.size_hint or (0, 0) max_sh = max(max_sh, shh) if shh else max_sh minimal_height_per_row.append(min_height) base_width = self._padding_left + self._padding_right + 2 * self._border_width base_height = self._padding_top + self._padding_bottom + 2 * self._border_width self.size_hint_min = ( base_width + sum(minimal_width_per_column) + (self.column_count - 1) * self._horizontal_spacing, base_height + sum(minimal_height_per_row) + (self.row_count - 1) * self._vertical_spacing, )
[docs] def do_layout(self): """Executes the layout algorithm. Children are placed in a grid layout based on the size hints. Algorithm --------- 0. generate list for all rows and columns 1. per column, collect max of size_hint_min and max size_hint (widths) 2. per row, collect max of size_hint_min and max size_hint (heights) 3. use box layout algorithm to distribute space 4. place widgets in grid layout """ # skip if no children if not self.children: return # 0. generate list for all rows and columns columns = [] for i in range(self.column_count): columns.append([]) rows = [] for i in range(self.row_count): rows.append([]) lookup: Dict[Tuple[int, int], _ChildEntry] = {} for entry in self._children: col_num = entry.data["column"] row_num = entry.data["row"] col_span = entry.data["column_span"] row_span = entry.data["row_span"] # we put the entry in all columns and rows it spans for c in range(col_span): columns[col_num + c].append(entry) for r in range(row_span): rows[row_num + r].append(entry) lookup[(col_num, row_num)] = entry # 1.a per column, collect max of size_hint_min and max size_hint minimal_width_per_column = [] max_size_hint_per_column = [] for col in columns: min_width = 0 max_sh = 0 for entry in col: col_span = entry.data["column_span"] # if the cell spans multiple columns, # we need to reduce the minimal required width by the horizontal spacing consumed_space = self._horizontal_spacing if col_span > 1 else 0 min_w, _ = UILayout.min_size_of(entry.child) min_width = max(min_width, min_w / col_span - consumed_space) shw, _ = entry.child.size_hint or (0, 0) max_sh = max(max_sh, shw) if shw else max_sh minimal_width_per_column.append(min_width) max_size_hint_per_column.append(max_sh) # 1.b per row, collect max of size_hint_min and max size_hint minimal_height_per_row = [] max_size_hint_per_row = [] for row in rows: min_height = 0 max_sh = 0 for entry in row: row_span = entry.data["row_span"] # if the cell spans multiple rows, # we need to reduce the minimal required height by the vertical spacing consumed_space = self._vertical_spacing if row_span > 1 else 0 _, min_h = UILayout.min_size_of(entry.child) min_height = max(min_height, min_h / row_span - consumed_space) _, shh = entry.child.size_hint or (0, 0) max_sh = max(max_sh, shh) if shh else max_sh minimal_height_per_row.append(min_height) max_size_hint_per_row.append(max_sh) # 2. use box layout algorithm to distribute space column_constraints = [ _C(minimal_width_per_column[i], None, max_size_hint_per_column[i]) for i in range(self.column_count) ] column_sizes = _box_axis_algorithm( column_constraints, self.content_width - (self.column_count - 1) * self._horizontal_spacing, ) row_constraints = [ _C(minimal_height_per_row[i], None, max_size_hint_per_row[i]) for i in range(self.row_count) ] row_sizes = _box_axis_algorithm( row_constraints, self.content_height - (self.row_count - 1) * self._vertical_spacing ) # 3. place widgets in grid layout start_y = self.content_rect.top for row_num in range(self.row_count): start_x = self.content_rect.left for col_num in range(self.column_count): entry = lookup.get((col_num, row_num)) if not entry: # still need to update start_x start_x += column_sizes[col_num] + self._horizontal_spacing continue # TODO handle row_span and col_span child = entry.child new_rect = child.rect # combine size of cells this entry spans and add spacing column_span = entry.data["column_span"] cell_width: float = sum(column_sizes[col_num : col_num + column_span]) cell_width += (column_span - 1) * self._horizontal_spacing row_span = entry.data["row_span"] cell_height: float = sum(row_sizes[row_num : row_num + row_span]) cell_height += (row_span - 1) * self._vertical_spacing # apply calculated sizes, when size_hint is given shw, shh = child.size_hint or (None, None) shmn_w, shmn_h = child.size_hint_min or (None, None) shmx_w, shmx_h = child.size_hint_max or (None, None) new_width = child.width if shw is not None: new_width = min(cell_width, shw * self.content_width) new_width = max(new_width, shmn_w or 0) if shmx_w is not None: new_width = min(new_width, shmx_w) new_height = child.height if shh is not None: new_height = min(cell_height, shh * self.content_height) new_height = max(new_height, shmn_h or 0) if shmx_h is not None: new_height = min(new_height, shmx_h) new_rect = new_rect.resize(width=new_width, height=new_height) # align within cell center_y = start_y - (cell_height / 2) center_x = start_x + (cell_width / 2) if self.align_vertical == "top": new_rect = new_rect.align_top(start_y) elif self.align_vertical == "bottom": new_rect = new_rect.align_bottom(start_y - row_sizes[row_num]) else: new_rect = new_rect.align_y(center_y) if self.align_horizontal == "left": new_rect = new_rect.align_left(start_x) elif self.align_horizontal == "right": new_rect = new_rect.align_right(start_x + cell_width) else: new_rect = new_rect.align_x(center_x) # update child rect child.rect = new_rect start_x += column_sizes[col_num] + self._horizontal_spacing start_y -= row_sizes[row_num] + self._vertical_spacing
@dataclass class _C: """Constrain values for the box algorithm. size_hint and min values of None are resolved to 0.0. """ min: float max: float | None hint: float _final_size: float = 0.0 """The final size of the entry which will be returned by the algorithm""" @staticmethod def from_widget(widget: UIWidget, dimension: Literal["width", "height"]) -> _C: index = 0 if dimension == "width" else 1 # get hint values from different formats None and (float|None, float|None) sh = widget.size_hint[index] if widget.size_hint else None sh_min = widget.size_hint_min[index] if widget.size_hint_min else None sh_max = widget.size_hint_max[index] if widget.size_hint_max else None # resolve min and max values if no size hint is given min_value = widget.size[index] if sh is None else sh_min max_value = widget.size[index] if sh is None else sh_max # clean up None values min_value = min_value or 0 sh = sh or 0.0 return _C( min=min_value, max=max_value, hint=sh, ) @staticmethod def from_widget_width(widget: UIWidget) -> _C: return _C.from_widget(widget, "width") @staticmethod def from_widget_height(widget: UIWidget) -> _C: return _C.from_widget(widget, "height") def _box_orthogonal_algorithm(constraints: list[_C], container_size: float) -> List[float]: """Calculate the 1 dimensional size of each entry based on the hint value and the available space in the container. This calculation is done for the orthogonal axis of the box layout, which only applies the size hint to the orthogonal axis. Args: constraints: List of constraints with hint, min and max values container_size: The total size of the container """ # calculate the width of each entry based on the hint for c in constraints: size = container_size * c.hint c.max = container_size if c.max is None else c.max c._final_size = min(max(c.min, size), c.max) # clamp width to min and max values return [c._final_size for c in constraints] def _box_axis_algorithm(constraints: list[_C], container_size: float) -> List[float]: """ The box algorithm calculates the 1 dimensional size of each entry based on the hint value and the available space in the container. Args: constraints: List of constraints with hint, min and max values container_size: The total size of the container Returns: List of tuples with the sizes of each element """ # adjust hint value based on min and max values for c in constraints: c.hint = max(c.min / container_size, c.hint) if c.max is not None: c.hint = min(c.hint, c.max / container_size) # normalize hint - which will cover cases, where the sum of the hints is greater than 1. # children will get a relative size based on their hint total_hint = sum(c.hint for c in constraints) if total_hint > 1: for c in constraints: c.hint /= total_hint # adjust hint value based on min values, again for c in constraints: c.hint = max(c.min / container_size, c.hint) # check if the total hint is greater than 1, again (caused by reapplied min values) total_hint = sum(c.hint for c in constraints) if total_hint > 1: # calculate the total hint value of all adjustable constraints total_adjustable_hint = sum(c.hint - c.min / container_size for c in constraints) # check if we have any adjustable constraints if total_adjustable_hint > 0: # reduce hint values of adjustable constraints to fit the container size required_adjustment = total_hint - 1 possible_adjustment = min(required_adjustment, total_adjustable_hint) for c in constraints: adjustable_size = c.hint - c.min / container_size c.hint -= possible_adjustment * (adjustable_size / total_adjustable_hint) # calculate the width of each entry based on the hint for c in constraints: c._final_size = container_size * c.hint # return the calculated sizes, round to avoid floating point errors return [round(c._final_size, 5) for c in constraints]