Struct GridParams 

pub struct GridParams {
    pub x: i32,
    pub y: i32,
    pub width: i32,
    pub height: i32,
}

Parameters required when adding an item to a Grid container.

Fields

x: i32

Index of the column this item is starting from.

y: i32

Index of the row this item is starting from.

width: i32

Number of columns this item spans.

height: i32

Number of rows this item spans.

Implementations

impl GridParams

pub fn new(x: i32, y: i32, width: i32, height: i32) -> GridParams

Create grid parameters with the given values.

Panics

When debug assertions are on, panics if the width or height is less than or equal to zero or if x or y is negative.

Examples found in repository

examples/calc.rs (line 220)

fn app_logic(data: &mut Calculator) -> impl WidgetView<Calculator> + use<> {
    grid(
        (
            // Display
            centered_flex_row((
                FlexSpacer::Flex(0.1),
                display_label(data.numbers[0].as_ref()),
                data.operation
                    .map(|operation| display_label(operation.as_str())),
                display_label(data.numbers[1].as_ref()),
                data.result.is_some().then(|| display_label("=")),
                data.result
                    .as_ref()
                    .map(|result| display_label(result.as_ref())),
                FlexSpacer::Flex(0.1),
            ))
            .grid_item(GridParams::new(0, 0, 4, 1)),
            // Top row
            expanded_button(
                label("CE").color(if data.get_current_number().is_empty() {
                    palette::css::MEDIUM_VIOLET_RED
                } else {
                    palette::css::WHITE
                }),
                Calculator::clear_entry,
            )
            .grid_pos(0, 1),
            expanded_button(label("C"), Calculator::clear_all).grid_pos(1, 1),
            expanded_button(label("DEL"), Calculator::on_delete).grid_pos(2, 1),
            operator_button(MathOperator::Divide).grid_pos(3, 1),
            num_row(["7", "8", "9"], 2),
            operator_button(MathOperator::Multiply).grid_pos(3, 2),
            num_row(["4", "5", "6"], 3),
            operator_button(MathOperator::Subtract).grid_pos(3, 3),
            num_row(["1", "2", "3"], 4),
            operator_button(MathOperator::Add).grid_pos(3, 4),
            // bottom row
            expanded_button(label("±"), Calculator::negate).grid_pos(0, 5),
            digit_button("0").grid_pos(1, 5),
            expanded_button(label("."), |data: &mut Calculator| {
                data.on_entered_digit(".");
            })
            .grid_pos(2, 5),
            expanded_button(label("="), Calculator::on_equals).grid_pos(3, 5),
        ),
        4,
        6,
    )
    .spacing(GRID_GAP)
}

Trait Implementations

impl Clone for GridParams

fn clone(&self) -> GridParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for GridParams

impl Debug for GridParams

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

Formats the value using the given formatter.

impl Default for GridParams

fn default() -> GridParams

Returns the “default value” for a type.

impl PartialEq for GridParams

fn eq(&self, other: &GridParams) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for GridParams