Struct carbide_controls::List

pub struct List<GS, T> where
    GS: GlobalState,
    T: ListIndex + 'static,  { /* fields omitted */ }

Implementations

impl<GS: GlobalState, T: ListIndex + 'static> List<GS, T>

pub fn new(
    delegate: Box<dyn Widget<GS>>,
    model: Box<dyn State<Vec<T>, GS>>
) -> Box<Self>

pub fn id_state(self, state: Box<dyn State<T, GS>>) -> Box<Self>

pub fn index_state(self, state: Box<dyn State<usize, GS>>) -> Box<Self>

Trait Implementations

impl<GS: GlobalState, T: ListIndex> ChildRender for List<GS, T>

impl<GS: Clone, T: Clone> Clone for List<GS, T> where
    GS: GlobalState,
    T: ListIndex + 'static, 

fn clone(&self) -> List<GS, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<GS: GlobalState, T: ListIndex> CommonWidget<GS> for List<GS, T>

fn get_id(&self) -> Id

fn get_flag(&self) -> Flags

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

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

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

fn get_position(&self) -> Point

fn set_position(&mut self, position: Dimensions)

fn get_dimension(&self) -> Dimensions

fn set_dimension(&mut self, dimensions: Dimensions)

pub fn get_x(&self) -> f64

pub fn set_x(&mut self, x: f64)

pub fn get_y(&self) -> f64

pub fn set_y(&mut self, y: f64)

pub fn get_width(&self) -> f64

pub fn set_width(&mut self, width: f64)

pub fn get_height(&self) -> f64

pub fn set_height(&mut self, height: f64)

pub fn is_inside(&self, point: [f64; 2]) -> bool

impl<T, GS: GlobalState> Event<GS> for List<GS, T> where
    T: ListIndex + 'static, 

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
)

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

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

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

impl<GS: GlobalState, T: ListIndex> Layout<GS> for List<GS, T>

fn flexibility(&self) -> u32

0 is the most flexible and the largest number is the least flexible

fn calculate_size(
    &mut self,
    requested_size: Dimensions,
    env: &Environment<GS>
) -> Dimensions

fn position_children(&mut self)

impl<T, GS: GlobalState> StateSync<GS> for List<GS, T> where
    T: ListIndex + 'static, 

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:

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

impl<T, GS: GlobalState> Widget<GS> for List<GS, T> where
    T: ListIndex + 'static, 

impl<GS: GlobalState, T: ListIndex + 'static> WidgetExt<GS> for List<GS, T>

pub fn frame(
    self,
    width: Box<dyn State<f64, GS> + 'static, Global>,
    height: Box<dyn State<f64, GS> + 'static, Global>
) -> Box<Frame<GS>, Global>

pub fn frame_width(
    self,
    width: Box<dyn State<f64, GS> + 'static, Global>
) -> Box<Frame<GS>, Global>

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

pub fn clip(self) -> Box<Clip<GS>, Global>

pub fn hidden(self) -> Box<Hidden<GS>, Global>

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

pub fn border(self) -> Box<Border<GS>, Global>