Struct carbide_core::widget::primitive::border::Border

pub struct Border<GS> where
    GS: GlobalState,  { /* fields omitted */ }

A basic, non-interactive rectangle shape widget.

Implementations

impl<S: GlobalState> Border<S>

pub fn color(self, color: Color) -> Box<Self>

pub fn border_width(self, width: u32) -> Box<Self>

pub fn initialize(child: Box<dyn Widget<S>>) -> Box<Self>

Trait Implementations

impl<GS: Clone> Clone for Border<GS> where
    GS: GlobalState, 

fn clone(&self) -> Border<GS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: GlobalState> CommonWidget<S> for Border<S>

fn get_id(&self) -> Uuid

fn get_flag(&self) -> Flags

fn get_children(&self) -> WidgetIter<'_, S>

fn get_children_mut(&mut self) -> WidgetIterMut<'_, S>

fn get_proxied_children(&mut self) -> WidgetIterMut<'_, S>

fn get_position(&self) -> Point

fn set_position(&mut self, position: Dimensions)

fn get_dimension(&self) -> Dimensions

fn set_dimension(&mut self, dimensions: Dimensions)

fn get_x(&self) -> Scalar

fn set_x(&mut self, x: Scalar)

fn get_y(&self) -> Scalar

fn set_y(&mut self, y: Scalar)

fn get_width(&self) -> Scalar

fn set_width(&mut self, width: Scalar)

fn get_height(&self) -> Scalar

fn set_height(&mut self, height: Scalar)

fn is_inside(&self, point: Point) -> bool

impl<GS: Debug> Debug for Border<GS> where
    GS: GlobalState, 

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

Formats the value using the given formatter.

impl<GS: GlobalState> Event<GS> for Border<GS>

fn handle_mouse_event(
    &mut self,
    event: &MouseEvent,
    consumed: &bool,
    env: &mut Environment<GS>,
    global_state: &mut GS
)

A function that will be called when a mouse event occurs. It will only get called on the events where the cursor is inside. Return true if the event is consumed, and will thus not be delegated to other widgets.

fn handle_keyboard_event(
    &mut self,
    event: &KeyboardEvent,
    env: &mut Environment<GS>,
    global_state: &mut GS
)

A function that will get called when a keyboard event occurs. This event will be given to all widgets, no matter if they are in focus or not. This is because the focus will be decided by the widgets themselves.

fn handle_other_event(&mut self, event: &WidgetEvent)

This will get called if there are event that are not covered by the other functions. This will get delegated to all widgets. It will never get called with mouse or keyboard events. TODO: Separate touch events. And add global state

fn process_mouse_event(
    &mut self,
    event: &MouseEvent,
    consumed: &bool,
    env: &mut Environment<GS>,
    global_state: &mut GS
)

fn process_keyboard_event(
    &mut self,
    event: &KeyboardEvent,
    env: &mut Environment<GS>,
    global_state: &mut GS
)

fn process_other_event(
    &mut self,
    event: &WidgetEvent,
    env: &mut Environment<GS>,
    global_state: &mut GS
)

fn process_mouse_event_default(
    &mut self,
    event: &MouseEvent,
    consumed: &bool,
    env: &mut Environment<S>,
    global_state: &mut S
)

fn process_keyboard_event_default(
    &mut self,
    event: &KeyboardEvent,
    env: &mut Environment<S>,
    global_state: &mut S
)

fn process_other_event_default(
    &mut self,
    event: &WidgetEvent,
    env: &mut Environment<S>,
    global_state: &mut S
)

impl<S: GlobalState> Render<S> for Border<S>

fn get_primitives(&mut self, fonts: &Map) -> Vec<Primitive>

impl<S: GlobalState> SingleChildLayout for Border<S>

fn flexibility(&self) -> u32

impl<GS: GlobalState> StateSync<GS> for Border<GS>

fn insert_local_state(&self, env: &mut Environment<GS>)

Insert local state from the widget into the environment. Return true if any of the keys from the widget was already in the local state.

fn update_all_widget_state(&mut self, env: &Environment<GS>, global_state: &GS)

Update the state for this widget. Update both local, global and environment state

fn update_local_widget_state(&mut self, env: &Environment<GS>)

Update only the local state for the widget

fn sync_state(&mut self, env: &mut Environment<GS>, global_state: &GS)

This should be implemented to synchronize both global and local state. A general implementation should:

fn default_sync_state(&mut self, env: &mut Environment<S>, global_state: &S)

impl<GS: GlobalState> Widget<GS> for Border<GS>

impl<GS: GlobalState> WidgetExt<GS> for Border<GS>

fn frame(
    self,
    width: Box<dyn State<f64, GS>>,
    height: Box<dyn State<f64, GS>>
) -> Box<Frame<GS>>

fn frame_width(self, width: Box<dyn State<f64, GS>>) -> Box<Frame<GS>>

fn padding(self, edge_insets: EdgeInsets) -> Box<Padding<GS>>

fn clip(self) -> Box<Clip<GS>>

fn hidden(self) -> Box<Hidden<GS>>

fn offset(
    self,
    offset_x: CommonState<f64, GS>,
    offset_y: CommonState<f64, GS>
) -> Box<Offset<GS>>

fn border(self) -> Box<Border<GS>>