Struct TimerWidget

pub struct TimerWidget { /* private fields */ }

This is the storage object for the TimerWidget. It stores the config, properties, callback registry, an enabled flag, timeout, a last-time-triggered value, and a timeout callback store.

Implementations

impl TimerWidget

Creates a new TimerWidget. This Widget will call a function defined in on_timeout when a specific number of milliseconds has elapsed.

pub fn new(timeout: u64, enabled: bool) -> Self

Creates a new TimerWidget object to call the on_timeout timeout callback every timeout milliseconds. Setting enabled to true will automatically enable the timer, where as false will add the timer, but it will not be enabled.

Examples found in repository

examples/timer.rs (line 50)

pub fn main() {
    let sdl_context = sdl2::init().unwrap();
    let video_subsystem = sdl_context.video().unwrap();
    let window = video_subsystem
        .window("pushrod-render timer demo", 400, 180)
        .position_centered()
        .opengl()
        .build()
        .unwrap();
    let mut engine = Engine::new(400, 180, 30);
    let mut widget1 = ProgressWidget::new(make_points(20, 20), make_size(360, 40), 25);

    widget1.set_color(CONFIG_COLOR_SECONDARY, Color::RGB(255, 0, 0));
    widget1.set_color(CONFIG_COLOR_BORDER, Color::RGB(0, 0, 255));

    let mut widget2 = ProgressWidget::new(make_points(20, 70), make_size(360, 40), 50);

    widget2.set_color(CONFIG_COLOR_SECONDARY, Color::RGB(255, 0, 0));
    widget2.set_color(CONFIG_COLOR_BORDER, Color::RGB(0, 255, 0));

    let mut widget3 = ProgressWidget::new(make_points(20, 120), make_size(360, 40), 75);

    widget3.set_color(CONFIG_COLOR_SECONDARY, Color::RGB(255, 0, 0));
    widget3.set_color(CONFIG_COLOR_BORDER, Color::RGB(0, 255, 255));

    let mut timer = TimerWidget::new(100, true);
    timer.on_timeout(|_, _widgets, _layouts| {
        let widget1_id = widget_id_for_name(_widgets, String::from("widget1"));
        let widget2_id = widget_id_for_name(_widgets, String::from("widget2"));
        let widget3_id = widget_id_for_name(_widgets, String::from("widget3"));
        let progress1_value: u8 =
            (cast!(_widgets, widget1_id, ProgressWidget).get_progress() + 1) % 100;
        let progress2_value: u8 =
            (cast!(_widgets, widget2_id, ProgressWidget).get_progress() + 1) % 100;
        let progress3_value: u8 =
            (cast!(_widgets, widget3_id, ProgressWidget).get_progress() + 1) % 100;

        cast!(_widgets, widget1_id, ProgressWidget).set_progress(progress1_value);
        cast!(_widgets, widget2_id, ProgressWidget).set_progress(progress2_value);
        cast!(_widgets, widget3_id, ProgressWidget).set_progress(progress3_value);
    });

    engine.add_widget(Box::new(widget1), String::from("widget1"));
    engine.add_widget(Box::new(widget2), String::from("widget2"));
    engine.add_widget(Box::new(widget3), String::from("widget3"));
    engine.add_widget(Box::new(timer), String::from("timer1"));

    engine.run(sdl_context, window);
}

pub fn enable(&mut self)

Re-enables the timer. This will also reset the elapsed timer.

pub fn disable(&mut self)

Disables the timer. Once disabled, the on_timeout callback will never be called.

pub fn is_enabled(&self) -> bool

Returns the enabled state.

pub fn on_timeout<F>(&mut self, callback: F)

where F: FnMut(&mut TimerWidget, &[WidgetContainer], &[LayoutContainer]) + 'static,

Assigns the callback closure that will be used when a timer tick is triggered.

Examples found in repository

examples/timer.rs (lines 51-65)

pub fn main() {
    let sdl_context = sdl2::init().unwrap();
    let video_subsystem = sdl_context.video().unwrap();
    let window = video_subsystem
        .window("pushrod-render timer demo", 400, 180)
        .position_centered()
        .opengl()
        .build()
        .unwrap();
    let mut engine = Engine::new(400, 180, 30);
    let mut widget1 = ProgressWidget::new(make_points(20, 20), make_size(360, 40), 25);

    widget1.set_color(CONFIG_COLOR_SECONDARY, Color::RGB(255, 0, 0));
    widget1.set_color(CONFIG_COLOR_BORDER, Color::RGB(0, 0, 255));

    let mut widget2 = ProgressWidget::new(make_points(20, 70), make_size(360, 40), 50);

    widget2.set_color(CONFIG_COLOR_SECONDARY, Color::RGB(255, 0, 0));
    widget2.set_color(CONFIG_COLOR_BORDER, Color::RGB(0, 255, 0));

    let mut widget3 = ProgressWidget::new(make_points(20, 120), make_size(360, 40), 75);

    widget3.set_color(CONFIG_COLOR_SECONDARY, Color::RGB(255, 0, 0));
    widget3.set_color(CONFIG_COLOR_BORDER, Color::RGB(0, 255, 255));

    let mut timer = TimerWidget::new(100, true);
    timer.on_timeout(|_, _widgets, _layouts| {
        let widget1_id = widget_id_for_name(_widgets, String::from("widget1"));
        let widget2_id = widget_id_for_name(_widgets, String::from("widget2"));
        let widget3_id = widget_id_for_name(_widgets, String::from("widget3"));
        let progress1_value: u8 =
            (cast!(_widgets, widget1_id, ProgressWidget).get_progress() + 1) % 100;
        let progress2_value: u8 =
            (cast!(_widgets, widget2_id, ProgressWidget).get_progress() + 1) % 100;
        let progress3_value: u8 =
            (cast!(_widgets, widget3_id, ProgressWidget).get_progress() + 1) % 100;

        cast!(_widgets, widget1_id, ProgressWidget).set_progress(progress1_value);
        cast!(_widgets, widget2_id, ProgressWidget).set_progress(progress2_value);
        cast!(_widgets, widget3_id, ProgressWidget).set_progress(progress3_value);
    });

    engine.add_widget(Box::new(widget1), String::from("widget1"));
    engine.add_widget(Box::new(widget2), String::from("widget2"));
    engine.add_widget(Box::new(widget3), String::from("widget3"));
    engine.add_widget(Box::new(timer), String::from("timer1"));

    engine.run(sdl_context, window);
}

Trait Implementations

impl Widget for TimerWidget

This is the Widget implementation of the TimerWidget.

fn tick(&mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer])

The TimerWidget responds to the tick callback, which is used to determine the timer display ticks. This function is only called when the timer tick occurs, so if there is a function inside the drawing loop that drops frames, this timer may not get called reliably.

fn as_any(&mut self) -> &mut dyn Any

This function is a macro-created getter function that returns the Widget as an Any type. This allows the Widget trait to be downcast into a struct that implements the Widget trait.

fn get_config(&mut self) -> &mut WidgetConfig

This function is a macro-created getter function that returns the Widget’s configuration object as a borrowed mutable reference. This code is auto-generated using the default_widget_properties!() macro.

fn get_system_properties(&mut self) -> &mut HashMap<i32, String>

This function is a macro-created getter function that returns the Widget’s system properties as a borrowed mutable reference. This code is auto-generated using the default_widget_properties!() macro.

fn get_callbacks(&mut self) -> &mut CallbackRegistry

This function is a macro-created getter function that returns the Widget’s CallbackRegistry object as a borrowed mutable reference. This code is auto-generated using the default_widget_properties!() macro.

fn draw( &mut self, _c: &mut Canvas<Window>, _t: &mut TextureCache, ) -> Option<&Texture>

Draws the widget. If you wish to modify the canvas object, you must declare it as mut in your implementation (ie fn draw(&mut self, mut canvas: Canvas<Window>)). The _canvas is the currently active drawing canvas at the time this function is called. This called during the draw loop of the Engine. This returns a reference to the stored Texture object within the Widget. It is then copied to the canvas, and displayed in the display loop. In this function, you can just return a reference to the Texture if no invalidation state was set, otherwise, the draw can be re-performed, and the Texture returned. If the drawing function returns no texture, return a None, and it will not be rendered during the display loop, but it will still be called. A TextureCache is provided in case your Widget needs to cache an image or a font store.

fn mouse_entered( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], )

When a mouse enters the bounds of the Widget, this function is triggered. This function implementation is optional.

fn mouse_exited( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], )

When a mouse exits the bounds of the Widget, this function is triggered. This function implementation is optional.

fn mouse_moved( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], _points: Points, )

When a mouse moves within the bounds of the Widget, this function is triggered. It contains the X and Y coordinates relative to the bounds of the Widget. The points start at 0x0. This function implementation is optional.

fn mouse_scrolled( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], _points: Points, )

When a mouse scroll is triggered within the bounds of the Widget, this function is triggered. Movement along the X axis indicate horizontal movement, where the Y axis indicates vertical movement. Positive movement means to the right or down, respectively. Negative movement means to the left or up, respectively. This function implementation is optional.

fn button_clicked( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], _button: u8, _clicks: u8, _state: bool, )

When a mouse button is clicked within (or outside of) the bounds of the Widget, this function is called. If a mouse button is clicked, and the mouse leaves the bounds of the Widget, the mouse release event will still be triggered for the last Widget which received the mouse down state. This prevents Widgets from becoming confused. This behavior is tracked by the main loop, not by the Widget code. Therefore, when a mouse button is released outside of the bounds of this Widget, you must adjust your state accordingly, if you pay attention to the button_clicked function. This function implementation is optional.

fn other_event( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], _event: Event, )

When an Event is sent to the application that is not handled by the Engine::run loop, this method is called, sending the unhandled Event to the currently active Widget. This behavior is subject to change as the Engine::run loop is modified to handle more Events.

fn tick_callback( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], )

This calls the on_tick callback. This is implemented by the default_widget_callbacks! macro, so you do not need to implement it. However, you need to call this function if you wish to honor an on_tick callback.

fn mouse_entered_callback( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], )

This calls the on_mouse_entered callback. This is implemented by the default_widget_callbacks! macro, so you do not need to implement it. However, you need to call this function if you wish to honor an on_mouse_entered callback.

fn mouse_exited_callback( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], )

This calls the on_mouse_exited callback. This is implemented by the default_widget_callbacks! macro, so you do not need to implement it. However, you need to call this function if you wish to honor an on_mouse_exited callback.

fn mouse_moved_callback( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], _points: Points, )

This calls the on_mouse_moved callback. This is implemented by the default_widget_callbacks! macro, so you do not need to implement it. However, you need to call this function if you wish to honor an on_mouse_moved callback.

fn mouse_scrolled_callback( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], _points: Points, )

This calls the on_mouse_scrolled callback. This is implemented by the default_widget_callbacks! macro, so you do not need to implement it. However, you need to call this function if you wish to honor an on_mouse_scrolled callback.

fn button_clicked_callback( &mut self, _widgets: &[WidgetContainer], _layouts: &[LayoutContainer], _button: u8, _clicks: u8, _state: bool, )

This calls the on_button_clicked callback. This is implemented by the default_widget_callbacks! macro, so you do not need to implement it. However, you need to call this function if you wish to honor an on_button_clicked callback.

fn on_config_changed(&mut self, _k: u8, _v: Config)

This callback is called when a setter is used to configure a value. It is not called when a call to get_config() using the setter is called, so it is best to use the top-level setters and getters for the configuration values - at least, until the get_config() call can be made private.

fn set_point(&mut self, config: u8, x: i32, y: i32)

Sets a point for a configuration key.

fn set_color(&mut self, config: u8, color: Color)

Sets a color for a configuration key.

fn set_numeric(&mut self, config: u8, value: i32)

Sets a numeric value for a configuration key.

fn set_text(&mut self, config: u8, text: String)

Sets a text value for a configuration key.

fn set_toggle(&mut self, config: u8, flag: bool)

Sets a toggle for a configuration key.

fn set_compass(&mut self, config: u8, value: CompassPosition)

Sets a compass position for a configuration key.

fn get_point(&mut self, k: u8) -> Points

Retrieves a Points for a configuration key. Returns Points::default if not set.

fn get_size(&mut self, k: u8) -> Size

Retrieves a Size for a configuration key. Returns a Size::default if not set.

fn get_color(&mut self, k: u8) -> Color

Retrieves a Color for a configuration key. Returns white if not set.

fn get_numeric(&mut self, k: u8) -> i32

Retrieves a numeric value for a configuration key. Returns 0 if not set.

fn get_text(&mut self, k: u8) -> String

Retrieves text for a configuration key. Returns a blank string if not set.

fn get_toggle(&mut self, k: u8) -> bool

Retrieves a boolean toggle for a configuration key. Returns false if not set.

fn get_compass(&mut self, k: u8) -> CompassPosition

Retrieves a CompassPosition toggle for a configuration key. Returns CompassPosition::W if not set.

fn set_origin(&mut self, _origin: Points)

Sets the origin of the Widget, adjusting the X and Y coordinates. Automatically sets the invalidate flag to true when adjusted, but only if the new origin is not the same as the previous origin.

fn set_size(&mut self, _size: Vec<u32>)

Sets the size of the Widget, adjusting the width and height. Automatically sets the invalidate flag to true when adjusted, but only if the new size is not the same as the previous size.

fn get_drawing_area(&mut self) -> Rect

Returns a Rect object containing the drawing bounds of this Widget.

fn is_invalidated(&mut self) -> bool

Returns whether or not a Widget is invalidated state.

fn set_invalidated(&mut self, flag: bool)

Sets invalidation state for the current Widget.