Struct carbide_core::widget::primitive::image::Image

pub struct Image {
    pub image_id: Id,
    pub src_rect: Option<Rect>,
    pub style: Style,
    // some fields omitted
}

A primitive and basic widget for drawing an Image.

Fields

image_id: Id

The unique identifier for the image that will be drawn.

src_rect: Option<Rect>

The rectangle area of the original source image that should be used.

style: Style

Unique styling.

Implementations

impl Image

pub fn old_new(image_id: Id) -> Self

Construct a new Image.

Note that the Image widget does not require borrowing or owning any image data directly. Instead, image data is stored within a carbide::image::Map where image::Ids are mapped to their associated data.

This is done for a few reasons:

• To avoid requiring that the widget graph owns an instance of each image
• To avoid requiring that the user passes the image data to the Image every update unnecessarily
• To make it easier for users to borrow and mutate their images without needing to index into the Ui's widget graph (which also requires casting render).

During rendering, carbide will take the image::Map, retrieve the data associated with each image and yield it via the render::Primitive::Image variant.

Note: this implies that the type must be the same for all Image widgets instantiated via the same Ui. In the case that you require multiple different render of images, we recommend that you either:

1. use an enum with a variant for each type
2. use a trait object, where the trait is implemented for each of your image render or
3. use an index type which may be mapped to your various image render.

pub fn new(id: Id) -> Box<Self>

pub fn source_rectangle(self, rect: Rect) -> Self

The rectangular area of the image that we wish to display.

If this method is not called, the entire image will be used.

pub fn resizeable(self) -> Box<Self>

pub fn scaled_to_fit(self) -> Box<Self>

pub fn scaled_to_fill(self) -> Box<Self>

pub fn aspect_ratio(self, mode: ScaleMode) -> Box<Self>

Trait Implementations

impl Clone for Image

fn clone(&self) -> Image

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 Image

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 Debug for Image

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

Formats the value using the given formatter.

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

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> Layout<S> for Image

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<S>
) -> Dimensions

fn position_children(&mut self)

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

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

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

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 Image

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

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>>