Trait nannou::ui::Positionable[−][src]

pub trait Positionable {
    fn x_position(self, Position) -> Self;

    fn y_position(self, Position) -> Self;

    fn get_x_position(&self, ui: &Ui) -> Position;

    fn get_y_position(&self, ui: &Ui) -> Position;

    fn depth(self, depth: f32) -> Self;

    fn get_depth(&self) -> f32;

    fn x(self, x: f64) -> Self { ... }

    fn y(self, y: f64) -> Self { ... }

    fn xy(self, point: [f64; 2]) -> Self { ... }

    fn x_y(self, x: f64, y: f64) -> Self { ... }

    fn x_position_relative(self, x: Relative) -> Self { ... }

    fn y_position_relative(self, y: Relative) -> Self { ... }

    fn x_y_position_relative(self, x: Relative, y: Relative) -> Self { ... }

    fn x_position_relative_to(self, other: NodeIndex<u32>, x: Relative) -> Self { ... }

    fn y_position_relative_to(self, other: NodeIndex<u32>, y: Relative) -> Self { ... }

    fn x_y_position_relative_to(
        self, 
        other: NodeIndex<u32>, 
        x: Relative, 
        y: Relative
    ) -> Self { ... }

    fn x_relative(self, x: f64) -> Self { ... }

    fn y_relative(self, y: f64) -> Self { ... }

    fn xy_relative(self, point: [f64; 2]) -> Self { ... }

    fn x_y_relative(self, x: f64, y: f64) -> Self { ... }

    fn x_relative_to(self, other: NodeIndex<u32>, x: f64) -> Self { ... }

    fn y_relative_to(self, other: NodeIndex<u32>, y: f64) -> Self { ... }

    fn xy_relative_to(self, other: NodeIndex<u32>, xy: [f64; 2]) -> Self { ... }

    fn x_y_relative_to(self, other: NodeIndex<u32>, x: f64, y: f64) -> Self { ... }

    fn x_direction(self, direction: Direction, x: f64) -> Self { ... }

    fn y_direction(self, direction: Direction, y: f64) -> Self { ... }

    fn down(self, y: f64) -> Self { ... }

    fn up(self, y: f64) -> Self { ... }

    fn left(self, x: f64) -> Self { ... }

    fn right(self, x: f64) -> Self { ... }

    fn x_direction_from(
        self, 
        other: NodeIndex<u32>, 
        direction: Direction, 
        x: f64
    ) -> Self { ... }

    fn y_direction_from(
        self, 
        other: NodeIndex<u32>, 
        direction: Direction, 
        y: f64
    ) -> Self { ... }

    fn down_from(self, other: NodeIndex<u32>, y: f64) -> Self { ... }

    fn up_from(self, other: NodeIndex<u32>, y: f64) -> Self { ... }

    fn left_from(self, other: NodeIndex<u32>, x: f64) -> Self { ... }

    fn right_from(self, other: NodeIndex<u32>, x: f64) -> Self { ... }

    fn x_align(self, align: Align) -> Self { ... }

    fn y_align(self, align: Align) -> Self { ... }

    fn align_left(self) -> Self { ... }

    fn align_middle_x(self) -> Self { ... }

    fn align_right(self) -> Self { ... }

    fn align_top(self) -> Self { ... }

    fn align_middle_y(self) -> Self { ... }

    fn align_bottom(self) -> Self { ... }

    fn x_align_to(self, other: NodeIndex<u32>, align: Align) -> Self { ... }

    fn y_align_to(self, other: NodeIndex<u32>, align: Align) -> Self { ... }

    fn align_left_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn align_middle_x_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn align_right_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn align_top_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn align_middle_y_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn align_bottom_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn x_place_on(self, other: NodeIndex<u32>, place: Place) -> Self { ... }

    fn y_place_on(self, other: NodeIndex<u32>, place: Place) -> Self { ... }

    fn middle_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn top_left_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn top_left_with_margin_on(self, other: NodeIndex<u32>, mgn: f64) -> Self { ... }

    fn top_left_with_margins_on(
        self, 
        other: NodeIndex<u32>, 
        top: f64, 
        left: f64
    ) -> Self { ... }

    fn top_right_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn top_right_with_margin_on(self, other: NodeIndex<u32>, mgn: f64) -> Self { ... }

    fn top_right_with_margins_on(
        self, 
        other: NodeIndex<u32>, 
        top: f64, 
        right: f64
    ) -> Self { ... }

    fn bottom_left_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn bottom_left_with_margin_on(self, other: NodeIndex<u32>, mgn: f64) -> Self { ... }

    fn bottom_left_with_margins_on(
        self, 
        other: NodeIndex<u32>, 
        bottom: f64, 
        left: f64
    ) -> Self { ... }

    fn bottom_right_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn bottom_right_with_margin_on(
        self, 
        other: NodeIndex<u32>, 
        mgn: f64
    ) -> Self { ... }

    fn bottom_right_with_margins_on(
        self, 
        other: NodeIndex<u32>, 
        bottom: f64, 
        right: f64
    ) -> Self { ... }

    fn mid_top_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn mid_top_with_margin_on(self, other: NodeIndex<u32>, mgn: f64) -> Self { ... }

    fn mid_bottom_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn mid_bottom_with_margin_on(self, other: NodeIndex<u32>, mgn: f64) -> Self { ... }

    fn mid_left_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn mid_left_with_margin_on(self, other: NodeIndex<u32>, mgn: f64) -> Self { ... }

    fn mid_right_of(self, other: NodeIndex<u32>) -> Self { ... }

    fn mid_right_with_margin_on(self, other: NodeIndex<u32>, mgn: f64) -> Self { ... }

    fn x_place(self, place: Place) -> Self { ... }

    fn y_place(self, place: Place) -> Self { ... }

    fn middle(self) -> Self { ... }

    fn top_left(self) -> Self { ... }

    fn top_left_with_margin(self, mgn: f64) -> Self { ... }

    fn top_left_with_margins(self, top: f64, left: f64) -> Self { ... }

    fn top_right(self) -> Self { ... }

    fn top_right_with_margin(self, mgn: f64) -> Self { ... }

    fn top_right_with_margins(self, top: f64, right: f64) -> Self { ... }

    fn bottom_left(self) -> Self { ... }

    fn bottom_left_with_margin(self, mgn: f64) -> Self { ... }

    fn bottom_left_with_margins(self, bottom: f64, left: f64) -> Self { ... }

    fn bottom_right(self) -> Self { ... }

    fn bottom_right_with_margin(self, mgn: f64) -> Self { ... }

    fn bottom_right_with_margins(self, bottom: f64, right: f64) -> Self { ... }

    fn mid_top(self) -> Self { ... }

    fn mid_top_with_margin(self, mgn: f64) -> Self { ... }

    fn mid_bottom(self) -> Self { ... }

    fn mid_bottom_with_margin(self, mgn: f64) -> Self { ... }

    fn mid_left(self) -> Self { ... }

    fn mid_left_with_margin(self, mgn: f64) -> Self { ... }

    fn mid_right(self) -> Self { ... }

    fn mid_right_with_margin(self, mgn: f64) -> Self { ... }
}

Widgets that are positionable.

A Position is stored internally within the widget::CommonBuilder type, allowing all widgets to be positioned in a variety of different ways.

Thus, Positionable can be implemented for all types that implement Widget.

Required Methods

Build with the given Position along the x axis.

Build with the given Position along the y axis.

Get the Position along the x axis.

Get the Position along the y axis.

The depth at which the widget should be rendered relatively to its sibling widgets.

Return the depth.

Provided Methods

Build with the given Absolute Position along the x axis.

Build with the given Absolute Position along the y axis.

Set the Position with some Point.

Set the Position with x y coordinates.

Set the x Position Relative to the previous widget.

Set the y Position Relative to the previous widget.

Set the x and y Positions Relative to the previous widget.

Set the x Position Relative to the given widget.

Set the y Position Relative to the given widget.

Set the x and y Positions Relative to the given widget.

Set the Position as a Scalar along the x axis Relative to the middle of previous widget.

Set the Position as a Scalar along the y axis Relative to the middle of previous widget.

Set the Position as a Point Relative to the middle of the previous widget.

Set the Position as Scalars along the x and y axes Relative to the middle of the previous widget.

Set the position relative to the widget with the given widget::Id.

Set the position relative to the widget with the given widget::Id.

Set the position relative to the widget with the given widget::Id.

Set the position relative to the widget with the given widget::Id.

Build with the Position along the x axis as some distance from another widget.

Build with the Position along the y axis as some distance from another widget.

Build with the Position as some distance below another widget.

Build with the Position as some distance above another widget.

Build with the Position as some distance to the left of another widget.

Build with the Position as some distance to the right of another widget.

Build with the Position along the x axis as some distance from the given widget.

Build with the Position along the y axis as some distance from the given widget.

Build with the Position as some distance below the given widget.

Build with the Position as some distance above the given widget.

Build with the Position as some distance to the left of the given widget.

Build with the Position as some distance to the right of the given widget.

Align the Position of the widget along the x axis.

Align the Position of the widget along the y axis.

Align the position to the left (only effective for Up or Down Directions).

Align the position to the middle (only effective for Up or Down Directions).

Align the position to the right (only effective for Up or Down Directions).

Align the position to the top (only effective for Left or Right Directions).

Align the position to the middle (only effective for Left or Right Directions).

Align the position to the bottom (only effective for Left or Right Directions).

Align the Position of the widget with the given widget along the x axis.

Align the Position of the widget with the given widget along the y axis.

Align the position to the left (only effective for Up or Down Directions).

Align the position to the middle (only effective for Up or Down Directions).

Align the position to the right (only effective for Up or Down Directions).

Align the position to the top (only effective for Left or Right Directions).

Align the position to the middle (only effective for Left or Right Directions).

Align the position to the bottom (only effective for Left or Right Directions).

Place the widget at some position on the other Widget along the x axis.

Place the widget at some position on the other Widget along the y axis.

Place the widget in the middle of the given Widget.

Place the widget in the top left corner of the given Widget.

Place the widget in the top left corner of the given Widget with the given margin between both edges.

Place the widget in the top left corner of the given Widget with the given margins between each respective edge.

Place the widget in the top right corner of the given Widget.

Place the widget in the top right corner of the given Widget with the given margin between both edges.

Place the widget in the top right corner of the given Widget with the given margins between each respective edge.

Place the widget in the bottom left corner of the given Widget.

Place the widget in the bottom left corner of the given Widget with the given margin between both edges.

Place the widget in the bottom left corner of the given Widget with the given margins between each respective edge.

Place the widget in the bottom right corner of the given Widget.

Place the widget in the bottom right corner of the given Widget with the given margin between both edges.

Place the widget in the bottom right corner of the given Widget with the given margins between each respective edge.

Place the widget in the middle of the top edge of the given Widget.

Place the widget in the middle of the top edge of the given Widget with the given margin between the edges.

Place the widget in the middle of the bottom edge of the given Widget.

Place the widget in the middle of the bottom edge of the given Widget with the given margin between the edges.

Place the widget in the middle of the left edge of the given Widget.

Place the widget in the middle of the left edge of the given Widget with the given margin between the edges.

Place the widget in the middle of the right edge of the given Widget.

Place the widget in the middle of the right edge of the given Widget with the given margin between the edges.

Place the widget at some position on the Widget along the x axis.

Place the widget at some position on the Widget along the y axis.

Place the widget in the middle of the current parent Widget.

Place the widget in the top left corner of the current parent Widget.

Place the widget in the top left corner of the current parent Widget with the given margin between both edges.

Place the widget in the top left corner of the current parent Widget with the given margins between each respective edge.

Place the widget in the top right corner of the current parent Widget.

Place the widget in the top right corner of the current parent Widget with the given margin between both edges.

Place the widget in the top right corner of the current parent Widget with the given margins between each respective edge.

Place the widget in the bottom left corner of the current parent Widget.

Place the widget in the bottom left corner of the current parent Widget with the given margin between both edges.

Place the widget in the bottom left corner of the current parent Widget with the given margins between each respective edge.

Place the widget in the bottom right corner of the current parent Widget.

Place the widget in the bottom right corner of the current parent Widget with the given margin between both edges.

Place the widget in the bottom right corner of the current parent Widget with the given margins between each respective edge.

Place the widget in the middle of the top edge of the current parent Widget.

Place the widget in the middle of the top edge of the current parent Widget with the given margin from the edge.

Place the widget in the middle of the bottom edge of the current parent Widget.

Place the widget in the middle of the bottom edge of the current parent Widget with the given margin from the edge.

Place the widget in the middle of the left edge of the current parent Widget.

Place the widget in the middle of the left edge of the current parent Widget with the given margin from the edge.

Place the widget in the middle of the right edge of the current parent Widget.

Place the widget in the middle of the right edge of the current parent Widget with the given margin from the edge.

Implementors