Struct Group 

pub struct Group {
    pub rect: TileRect,
    pub layout: GroupLayout,
    pub clip: bool,
    pub border: Option<Border>,
}

A layout container that manages children with coordinate translation.

Examples

use dotzuki_renderer::layout_engine::elements::group::{Group, GroupLayout};
use dotzuki_engine::render::TileRect;

let group = Group::new(TileRect::new(0, 0, 10, 10))
    .with_layout(GroupLayout::Vertical { gap: 1 })
    .with_clip(true);

Fields

rect: TileRect

The group’s bounding rectangle in screen-absolute tile coordinates.

layout: GroupLayout

How children are positioned within the group.

clip: bool

Whether child rendering is clipped to rect.

border: Option<Border>

Optional border rendered around the group.

Implementations

impl Group

pub fn new(rect: TileRect) -> Self

Create a new group with absolute layout, no clip, and no border.

pub fn with_layout(self, layout: GroupLayout) -> Self

Set the layout mode.

pub fn with_clip(self, clip: bool) -> Self

Enable or disable clipping.

pub fn with_border(self, border: Border) -> Self

Attach a border to the group.

pub fn to_absolute(&self, tx: u32, ty: u32) -> TilePos

Translate a group-relative tile position to screen-absolute.

Adds the group’s top-left offset to the given coordinates. This is the core coordinate translation used when rendering children that specify their positions relative to the group.

pub fn rect_to_absolute(&self, relative: TileRect) -> TileRect

Translate a group-relative tile rectangle to screen-absolute.

pub fn child_rect( &self, child: &LayoutElement, _index: usize, ctx: &DataContext, ) -> TileRect

Compute the screen-absolute rectangle for a child element.

For GroupLayout::Absolute, the child’s own rect.tx/rect.ty are treated as offsets from the group origin.

For automatic layouts (GroupLayout::Horizontal / GroupLayout::Vertical), the child’s explicit tx/ty are overridden by the computed layout position; the child still controls its own tw/th.

pub fn layout_offset( &self, index: usize, children: &[LayoutElement], ) -> (u32, u32)

Compute the layout offset for the child at index from the actual child list.

Returns the (x, y) offset in tiles from the group origin that this child should be placed at, based on the layout mode and the actual widths/heights of previous children.

For GroupLayout::Absolute, always returns (0, 0) — the child’s own rect.tx/rect.ty are used directly.

pub fn resolve_children( &self, children: &[LayoutElement], ctx: &DataContext, ) -> Vec<ChildRect>

Resolve all children to their screen-absolute rectangles.

Returns a vector of ChildRect in the same order as children, each with a computed absolute position based on the layout mode.

pub fn render_border(&self, painter: &mut dyn Painter)

Render the group’s border (if any) into the given Painter.

This does not render children — it only draws the group’s own border or background fill. Child rendering is handled by the layout engine’s element dispatch.

pub fn render( &self, children: &[LayoutElement], ctx: &DataContext, render_ctx: &RenderContext<'_>, painter: &mut dyn Painter, registry: &ElementRegistry, ) -> Result<(), RenderError>

Render the group including border and children via the layout engine.

When clip is enabled, pixels outside rect should be masked. Current implementation renders all visible children; clipping is a future enhancement for when a clip-stack is added to the painter.

Trait Implementations

impl Clone for Group

fn clone(&self) -> Group

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Group

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.