Struct cushy::widgets::Custom

pub struct Custom { /* private fields */ }

A callback-based custom widget.

This type can be used to create inline widgets without defining a new type and implementing Widget/WrapperWidget for it.

Implementations

impl Custom

pub fn empty() -> Self

Returns a custom widget that has no child.

pub fn new(child: impl MakeWidget) -> Self

Returns a custom widget that contains child.

pub fn background_color(self, color: impl IntoValue<Color>) -> Self

Sets the background color of this widget to color and returns self.

If the color is set to a non-transparent value, it will be filled before any of the redraw callbacks are invoked.

This value coresponds to WrapperWidget::background_color.

pub fn on_redraw<Redraw>(self, redraw: Redraw) -> Self

where Redraw: Send + 'static + for<'context, 'clip, 'gfx, 'pass> FnMut(&mut GraphicsContext<'context, 'clip, 'gfx, 'pass>),

Sets redraw as the callback to invoke when redrawing this control.

If this control contains a child, its redraw function will be invoked after redraw is invoked. Use Self::on_redraw_after_child() to draw after the child widget.

This callback corresponds to WrapperWidget::redraw_background.

pub fn on_redraw_after_child<Redraw>(self, redraw: Redraw) -> Self

where Redraw: Send + 'static + for<'context, 'clip, 'gfx, 'pass> FnMut(&mut GraphicsContext<'context, 'clip, 'gfx, 'pass>),

Sets redraw as the callback to invoke when redrawing this control, after the child control has been redrawn.

If this control contains a child, its redraw function will be invoked before redraw is invoked. Use Self::on_redraw() to draw before the child widget.

redraw will be invoked regardless of whether a child is present.

This callback corresponds to WrapperWidget::redraw_foreground.

pub fn on_mounted<Mounted>(self, mounted: Mounted) -> Self

where Mounted: Send + 'static + for<'context> FnMut(&mut EventContext<'context>),

Sets mounted to be invoked when this widget is mounted into a parent.

This callback corresponds to WrapperWidget::mounted.

pub fn on_unmounted<Mounted>(self, mounted: Mounted) -> Self

where Mounted: Send + 'static + for<'context> FnMut(&mut EventContext<'context>),

Sets unmounted to be invoked when this widget is unmounted from its parent.

This callback corresponds to WrapperWidget::unmounted.

pub fn on_unhover<Unhover>(self, unhovered: Unhover) -> Self

where Unhover: Send + 'static + for<'context> FnMut(&mut EventContext<'context>),

Invokes unhovered when the mouse cursor leaves the widget’s boundary.

This callback corresponds to WrapperWidget::unhover.

pub fn on_focus<Focused>(self, focus: Focused) -> Self

where Focused: Send + 'static + for<'context> FnMut(&mut EventContext<'context>),

Invokes focus when the widget receives input focus.

This callback corresponds to WrapperWidget::focus.

pub fn on_blur<Blur>(self, blur: Blur) -> Self

where Blur: Send + 'static + for<'context> FnMut(&mut EventContext<'context>),

Invokes blur when the widget loses input focus.

This callback corresponds to WrapperWidget::blur.

pub fn on_activate<Activated>(self, activated: Activated) -> Self

where Activated: Send + 'static + for<'context> FnMut(&mut EventContext<'context>),

Invokes activated when this widget becomes the active widget.

This callback corresponds to WrapperWidget::activate.

pub fn on_deactivate<Deactivated>(self, deactivated: Deactivated) -> Self

where Deactivated: Send + 'static + for<'context> FnMut(&mut EventContext<'context>),

Invokes deactivated when this widget no longer is the active widget.

This callback corresponds to WrapperWidget::deactivate.

pub fn on_accept_focus<AcceptFocus>(self, accept: AcceptFocus) -> Self

where AcceptFocus: Send + 'static + for<'context> FnMut(&mut EventContext<'context>) -> bool,

Invokes accept when this widget is set to receive input focus. If this function returns true, this widget will become the focused widget.

This callback corresponds to WrapperWidget::accept_focus.

pub fn on_allow_blur<AllowBlur>(self, allow_blur: AllowBlur) -> Self

where AllowBlur: Send + 'static + for<'context> FnMut(&mut EventContext<'context>) -> bool,

Invokes allow_blur when this widget is about to lose focus. If allow_blur returns false, focus will be disallowed from leaving this widget.

This callback corresponds to WrapperWidget::allow_blur.

pub fn on_advance_focus<AdvanceFocus>(self, advance_focus: AdvanceFocus) -> Self

where AdvanceFocus: Send + 'static + for<'context> FnMut(VisualOrder, &mut EventContext<'context>) -> EventHandling,

Invokes advance_focus when this widget has focus and focus is requested to advance to another widget. Returning HANDLED will signal to Cushy that the focus has moved and the request should not be processed any further.

This callback corresponds to WrapperWidget::advance_focus.

pub fn on_adjust_child_constraints<AdjustChildConstraints>( self, adjust_child_constraints: AdjustChildConstraints, ) -> Self

where AdjustChildConstraints: Send + 'static + for<'context, 'clip, 'gfx, 'pass> FnMut(Size<ConstraintLimit>, &mut LayoutContext<'context, 'clip, 'gfx, 'pass>) -> Size<ConstraintLimit>,

Invokes adjust_child_constraints before measuring the child widget. The returned constraints will be passed along to the child in its layout function.

This callback corresponds to WrapperWidget::adjust_child_constraints.

pub fn on_position_child<PositionChild>( self, position_child: PositionChild, ) -> Self

where PositionChild: Send + 'static + for<'context, 'clip, 'gfx, 'pass> FnMut(Size<Px>, Size<ConstraintLimit>, &mut LayoutContext<'context, 'clip, 'gfx, 'pass>) -> WrappedLayout,

Invokes position_child to determine the position of a measured child.

This callback corresponds to WrapperWidget::position_child.

pub fn on_hit_test<HitTest>(self, hit_test: HitTest) -> Self

where HitTest: Send + 'static + for<'context> FnMut(Point<Px>, &mut EventContext<'context>) -> bool,

Invokes hit_test when determining if a location should be considered interacting with this widget.

This callback corresponds to WrapperWidget::hit_test.

pub fn on_hover<Hover>(self, hover: Hover) -> Self

where Hover: Send + 'static + for<'context> FnMut(Point<Px>, &mut EventContext<'context>) -> Option<CursorIcon>,

Invokes hover when a mouse cursor is above this widget.

This callback corresponds to WrapperWidget::hover.

pub fn on_mouse_down<MouseDown>(self, mouse_down: MouseDown) -> Self

where MouseDown: Send + 'static + for<'context> FnMut(Point<Px>, DeviceId, MouseButton, &mut EventContext<'context>) -> EventHandling,

Invokes mouse_down when a mouse button is pushed on a location where Self::on_hit_test returned true.

Returning HANDLED will set this widget as the handler for the DeviceId and [MouseButton]. Future mouse events for the same device and button will be sent to this widget’s Self::on_mouse_drag and Self::on_mouse_up callbacks.

This callback corresponds to WrapperWidget::mouse_down.

pub fn on_mouse_drag<MouseDrag>(self, mouse_drag: MouseDrag) -> Self

where MouseDrag: Send + 'static + for<'context> FnMut(Point<Px>, DeviceId, MouseButton, &mut EventContext<'context>),

Invokes mouse_drag when the mouse cursor moves while a tracked button is presed.

This callback corresponds to WrapperWidget::mouse_drag.

pub fn on_mouse_up<MouseUp>(self, mouse_up: MouseUp) -> Self

where MouseUp: Send + 'static + for<'context> FnMut(Option<Point<Px>>, DeviceId, MouseButton, &mut EventContext<'context>),

Invokes mouse_up when a tracked mouse button is released.

This callback corresponds to WrapperWidget::mouse_up.

pub fn on_ime<OnIme>(self, ime: OnIme) -> Self

where OnIme: Send + 'static + for<'context> FnMut(Ime, &mut EventContext<'context>) -> EventHandling,

Invokes ime when an input manager event occurs.

This callback corresponds to WrapperWidget::ime.

pub fn on_keyboard_input<KeyboardInput>( self, keyboard_input: KeyboardInput, ) -> Self

where KeyboardInput: Send + 'static + for<'context> FnMut(DeviceId, KeyEvent, bool, &mut EventContext<'context>) -> EventHandling,

Invokes keyboard_input when a keyboard event occurs.

This callback corresponds to WrapperWidget::keyboard_input.

pub fn mouse_wheel<MouseWheel>(self, mouse_wheel: MouseWheel) -> Self

where MouseWheel: Send + 'static + for<'context> FnMut(DeviceId, MouseScrollDelta, TouchPhase, &mut EventContext<'context>) -> EventHandling,

Invokes mouse_wheel when a mouse wheel event occurs.

This callback corresponds to WrapperWidget::mouse_wheel.

Trait Implementations

impl Debug for Custom

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

Formats the value using the given formatter.

impl Default for Custom

fn default() -> Self

Returns the “default value” for a type.

impl WrapperWidget for Custom

fn child_mut(&mut self) -> &mut WidgetRef

Returns the child widget.

fn redraw_background(&mut self, context: &mut GraphicsContext<'_, '_, '_, '_>)

Draws the background of the widget.

fn redraw_foreground(&mut self, context: &mut GraphicsContext<'_, '_, '_, '_>)

Draws the foreground of the widget.

fn adjust_child_constraints( &mut self, available_space: Size<ConstraintLimit>, context: &mut LayoutContext<'_, '_, '_, '_>, ) -> Size<ConstraintLimit>

Returns the adjusted contraints to use when laying out the child.

fn position_child( &mut self, size: Size<Px>, available_space: Size<ConstraintLimit>, context: &mut LayoutContext<'_, '_, '_, '_>, ) -> WrappedLayout

Returns the layout after positioning the child that occupies size.

fn background_color(&mut self, context: &WidgetContext<'_>) -> Option<Color>

Returns the background color to render behind the wrapped widget.

fn mounted(&mut self, context: &mut EventContext<'_>)

The widget has been mounted into a parent widget.

fn unmounted(&mut self, context: &mut EventContext<'_>)

The widget has been removed from its parent widget.

fn hit_test( &mut self, location: Point<Px>, context: &mut EventContext<'_>, ) -> bool

Returns true if this widget should respond to mouse input at location.

fn hover( &mut self, location: Point<Px>, context: &mut EventContext<'_>, ) -> Option<CursorIcon>

The widget is currently has a cursor hovering it at location.

fn unhover(&mut self, context: &mut EventContext<'_>)

The widget is no longer being hovered.

fn accept_focus(&mut self, context: &mut EventContext<'_>) -> bool

This widget has been targeted to be focused. If this function returns true, the widget will be focused. If false, Cushy will continue searching for another focus target.

fn focus(&mut self, context: &mut EventContext<'_>)

The widget has received focus for user input.

fn blur(&mut self, context: &mut EventContext<'_>)

The widget is no longer focused for user input.

fn activate(&mut self, context: &mut EventContext<'_>)

The widget has become the active widget.

fn deactivate(&mut self, context: &mut EventContext<'_>)

The widget is no longer active.

fn mouse_down( &mut self, location: Point<Px>, device_id: DeviceId, button: MouseButton, context: &mut EventContext<'_>, ) -> EventHandling

A mouse button event has occurred at location. Returns whether the event has been handled or not.

fn mouse_drag( &mut self, location: Point<Px>, device_id: DeviceId, button: MouseButton, context: &mut EventContext<'_>, )

A mouse button is being held down as the cursor is moved across the widget.

fn mouse_up( &mut self, location: Option<Point<Px>>, device_id: DeviceId, button: MouseButton, context: &mut EventContext<'_>, )

A mouse button is no longer being pressed.

fn keyboard_input( &mut self, device_id: DeviceId, input: KeyEvent, is_synthetic: bool, context: &mut EventContext<'_>, ) -> EventHandling

A keyboard event has been sent to this widget. Returns whether the event has been handled or not.

fn ime(&mut self, ime: Ime, context: &mut EventContext<'_>) -> EventHandling

An input manager event has been sent to this widget. Returns whether the event has been handled or not.

fn mouse_wheel( &mut self, device_id: DeviceId, delta: MouseScrollDelta, phase: TouchPhase, context: &mut EventContext<'_>, ) -> EventHandling

A mouse wheel event has been sent to this widget. Returns whether the event has been handled or not.

fn advance_focus( &mut self, direction: VisualOrder, context: &mut EventContext<'_>, ) -> EventHandling

The widget should switch to the next focusable area within this widget, honoring direction in a consistent manner. Returning HANDLED will cause the search for the next focus widget stop.

fn allow_blur(&mut self, context: &mut EventContext<'_>) -> bool

The widget is about to lose focus. Returning true allows the focus to switch away from this widget.

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

Writes a summary of this widget into fmt.

fn root_behavior( &mut self, context: &mut EventContext<'_>, ) -> Option<RootBehavior>

Returns the behavior this widget should apply when positioned at the root of the window.

fn layout_child( &mut self, available_space: Size<ConstraintLimit>, context: &mut LayoutContext<'_, '_, '_, '_>, ) -> WrappedLayout

Returns the rectangle that the child widget should occupy given available_space.