Struct AppState 

pub struct AppState<PageId, ButtonId> {
    pub current_page: PageId,
    pub scene_transition: Option<SceneTransition<PageId>>,
    pub current_transition_type: Option<TransitionType>,
    pub window_size: (u32, u32),
    pub capturing_input: (bool, Option<ButtonId>),
    pub all_events_disable: bool,
    pub stretch_mode_is_on: bool,
}

Global application state that holds page navigation, transitions, and user input tracking.

Fields

current_page: PageId

scene_transition: Option<SceneTransition<PageId>>

current_transition_type: Option<TransitionType>

window_size: (u32, u32)

capturing_input: (bool, Option<ButtonId>)

all_events_disable: bool

stretch_mode_is_on: bool

Implementations

impl<PageId: Copy + Eq + Debug, ButtonId: Copy + Eq + Debug> AppState<PageId, ButtonId>

pub fn new( start_page: PageId, window_size: (u32, u32), stretch_mode_is_on: bool, ) -> Self

Create a new app state with a starting page.

Examples found in repository

examples/SimpleExample/demo.rs (line 43)

fn main()
{
    // To Be Ignored, Just An Setup To Configure The Build
    setup_build();
    let window_config = WindowConfig 
    {
        window_title: "SimpleExample".to_string(),
        icon: (None, None),
        // Recommended to start with 16:9 aspect ratio
        start_window_size: (800, 450),
        // Recommended to have minimum size with 16:9 aspect ratio
        window_minimum_size: (800, 450),
        resizable: true,
        centered: true,
        // By Default SDL_LOGICAL_PRESENTATION_STRETCH Is Set, Only Setting It Here For Demonstration Purpose
        different_sdl_presentation_mode: Some(SDL_LOGICAL_PRESENTATION_STRETCH),
        font: ("JetBrainsMono".to_string(), Some("Bold".to_string()))
    };

    let mut window_modules = create_window(window_config);
    let mut input_handler = InputHandler::new(true);
    let mut app_state = AppState::new(PageId::Page1, window_modules.canvas.window().size(), window_modules.stretch_mode_status);
    let mut page_data = PageData::new(&app_state);
    let renderer_config = RendererConfig { canvas: window_modules.canvas, texture_creator: &window_modules.texture_creator, ttf_context: &window_modules.ttf_context, font_path: &window_modules.font_path, decrease_color_when_selected: Some((25, 25, 25)), selection_color: Some((0, 0, 200, 125)), assets_dir: None };
    let mut renderer = Renderer::new(renderer_config);

    populate_page_data(&mut page_data);

    // Wrap the button_action function in a mutable closure so it can capture
    // additional context if needed. Passing a closure here allows the
    // button handler API to accept additional arguments beyond the default.
    let mut button_action_closure = |app_state: &mut AppState<PageId, ButtonId>, button_id: &ButtonId, page_data: &mut PageData<PageId, ButtonId>| button_action(app_state, button_id, page_data);

    loop
    {
        println!("{:?}", page_data.persistent_elements_to_render.is_some());
        //using 900 / your_refresh_rate to a very crispy experience
        std::thread::sleep(Duration::from_millis(900 / get_monitor_refresh_rate()));
        app_state.update_window_size(renderer.canvas.window().size().0, renderer.canvas.window().size().1);
        input_handler.handle_input(&mut window_modules.event_pump, &mut window_modules.clipboard_system, &mut page_data, &mut app_state, &mut button_action_closure);
        page_data.create_current_page(&mut app_state);
        renderer.render(&page_data, &mut app_state, &input_handler);
    }
}

examples/AdvancedExample/demo.rs (line 51)

fn main()
{
    // To Be Ignored, Just An Setup To Configure Some Assets
    setup_build();
    list_embedded(&ASSETS);

    let window_config = WindowConfig {
        window_title: "AdvancedExample".to_string(),
        icon: (Some("image_example/example_2.bmp".to_string()), Some(&ASSETS)),
        // Recommended to start with 16:9 aspect ratio
        start_window_size: (800, 450),
        // Recommended to have minimum size with 16:9 aspect ratio
        window_minimum_size: (800, 450),
        resizable: true,
        centered: true,
        // By Default SDL_LOGICAL_PRESENTATION_STRETCH Is Set, Only Setting It Here For Demonstration Purpose
        different_sdl_presentation_mode: Some(SDL_LOGICAL_PRESENTATION_STRETCH),
        font: ("JetBrainsMono".to_string(), Some("Bold".to_string()))
    };
    let mut window_modules = create_window(window_config);
    //bool is reffered to the rollback pages system, with "Mouse side buttons" or ("Alt" + "Arrows Keys") | (true = Page Rollback On), (false = Page Rollback Off)
    let mut input_handler = InputHandler::new(true);
    let mut app_state = AppState::new(PageId::Page1, window_modules.canvas.window().size(), window_modules.stretch_mode_status);
    let mut page_data = PageData::new(&app_state);

    let renderer_config = RendererConfig { canvas: window_modules.canvas, texture_creator: &window_modules.texture_creator, ttf_context: &window_modules.ttf_context, font_path: &window_modules.font_path, decrease_color_when_selected: Some((25, 25, 25)), selection_color: Some((0, 0, 200, 125)), assets_dir: Some(&ASSETS) };
    let mut renderer = Renderer::new(renderer_config);


    populate_page_data(&mut page_data);

    // Wrap the button_action function in a mutable closure so it can capture
    // additional context if needed. Passing a closure here allows the
    // button handler API to accept additional arguments beyond the default.
    let mut button_action_closure = |app_state: &mut AppState<PageId, ButtonId>, button_id: &ButtonId, page_data: &mut PageData<PageId, ButtonId>| button_action(app_state, button_id, page_data);

    loop
    {
        //using (900 / your_refresh_rate) to a very crispy experience
        std::thread::sleep(Duration::from_millis(900 / get_monitor_refresh_rate()));
        input_handler.handle_input(&mut window_modules.event_pump, &mut window_modules.clipboard_system, &mut page_data, &mut app_state, &mut button_action_closure);
        app_state.update_window_size(renderer.canvas.window().size().0, renderer.canvas.window().size().1);
        page_data.create_current_page(&mut app_state);
        renderer.render(&page_data, &mut app_state, &input_handler);
    }
}

pub fn change_current_page( &mut self, page_data: &mut PageData<PageId, ButtonId>, next_page: PageId, button_id: &ButtonId, )

Change to a new page, optionally triggering a transition.

Examples found in repository

examples/SimpleExample/demo.rs (line 76)

pub fn button_action(app_state: &mut AppState<PageId, ButtonId>, button_id: &ButtonId, app_data: &mut PageData<PageId, ButtonId>)
{
    if !app_state.capturing_input.0
    {
        if &ButtonId::ButtonPage1 == button_id
        {
            app_state.change_current_page(app_data, PageId::Page1, button_id);
            return;
        };
        if &ButtonId::ButtonSubPage == button_id
        {
            app_state.change_current_page(app_data, PageId::Page1SubPage, button_id);
            return;
        };
        if &ButtonId::ButtonBack == button_id
        {
            println!("button back clicked");
            app_state.change_current_page(app_data, PageId::Page1, button_id);
            return;
        };
        // Non Handle Buttons Will Be Considered User Input Buttons
        app_state.capturing_input = (true, Some(*button_id));
    }
}

examples/AdvancedExample/actions/buttons_actions.rs (line 16)

pub fn button_action(app_state: &mut AppState<PageId, ButtonId>, button_id: &ButtonId, app_data: &mut PageData<PageId, ButtonId>)
{
    if !app_state.capturing_input.0
    {
        if &ButtonId::ButtonPage1 == button_id
        {
            //this disable all eventpump events, it's just here for demonstration porpuse
            app_state.all_events_disable = true;
            app_data.forced_persistent_elements = Some(vec![persistent_elements2()]);
            app_state.change_current_page(app_data, PageId::Page1, button_id);
            app_state.all_events_disable = false;
            return;
        };
        if &ButtonId::ButtonPage2 == button_id
        {
            app_state.change_current_page(app_data, PageId::Page2, button_id);
            return;
        };
        if &ButtonId::ButtonSubPage == button_id
        {
            app_state.change_current_page(app_data, PageId::Page2SubPage, button_id);
            return;
        };
        if &ButtonId::ButtonBack == button_id
        {
            app_state.change_current_page(app_data, PageId::Page2, button_id);
            return;
        };
        // Non Handle Buttons Will Be Considered User Input Buttons
        app_state.capturing_input = (true, Some(*button_id));
    }
}

pub fn is_transition_active(&self) -> bool

Returns whether a scene transition is currently active.

pub fn update_window_size(&mut self, width: u32, height: u32)

Update window size (e.g., on resize events)

Examples found in repository

examples/SimpleExample/demo.rs (line 60)

fn main()
{
    // To Be Ignored, Just An Setup To Configure The Build
    setup_build();
    let window_config = WindowConfig 
    {
        window_title: "SimpleExample".to_string(),
        icon: (None, None),
        // Recommended to start with 16:9 aspect ratio
        start_window_size: (800, 450),
        // Recommended to have minimum size with 16:9 aspect ratio
        window_minimum_size: (800, 450),
        resizable: true,
        centered: true,
        // By Default SDL_LOGICAL_PRESENTATION_STRETCH Is Set, Only Setting It Here For Demonstration Purpose
        different_sdl_presentation_mode: Some(SDL_LOGICAL_PRESENTATION_STRETCH),
        font: ("JetBrainsMono".to_string(), Some("Bold".to_string()))
    };

    let mut window_modules = create_window(window_config);
    let mut input_handler = InputHandler::new(true);
    let mut app_state = AppState::new(PageId::Page1, window_modules.canvas.window().size(), window_modules.stretch_mode_status);
    let mut page_data = PageData::new(&app_state);
    let renderer_config = RendererConfig { canvas: window_modules.canvas, texture_creator: &window_modules.texture_creator, ttf_context: &window_modules.ttf_context, font_path: &window_modules.font_path, decrease_color_when_selected: Some((25, 25, 25)), selection_color: Some((0, 0, 200, 125)), assets_dir: None };
    let mut renderer = Renderer::new(renderer_config);

    populate_page_data(&mut page_data);

    // Wrap the button_action function in a mutable closure so it can capture
    // additional context if needed. Passing a closure here allows the
    // button handler API to accept additional arguments beyond the default.
    let mut button_action_closure = |app_state: &mut AppState<PageId, ButtonId>, button_id: &ButtonId, page_data: &mut PageData<PageId, ButtonId>| button_action(app_state, button_id, page_data);

    loop
    {
        println!("{:?}", page_data.persistent_elements_to_render.is_some());
        //using 900 / your_refresh_rate to a very crispy experience
        std::thread::sleep(Duration::from_millis(900 / get_monitor_refresh_rate()));
        app_state.update_window_size(renderer.canvas.window().size().0, renderer.canvas.window().size().1);
        input_handler.handle_input(&mut window_modules.event_pump, &mut window_modules.clipboard_system, &mut page_data, &mut app_state, &mut button_action_closure);
        page_data.create_current_page(&mut app_state);
        renderer.render(&page_data, &mut app_state, &input_handler);
    }
}

examples/AdvancedExample/demo.rs (line 70)

fn main()
{
    // To Be Ignored, Just An Setup To Configure Some Assets
    setup_build();
    list_embedded(&ASSETS);

    let window_config = WindowConfig {
        window_title: "AdvancedExample".to_string(),
        icon: (Some("image_example/example_2.bmp".to_string()), Some(&ASSETS)),
        // Recommended to start with 16:9 aspect ratio
        start_window_size: (800, 450),
        // Recommended to have minimum size with 16:9 aspect ratio
        window_minimum_size: (800, 450),
        resizable: true,
        centered: true,
        // By Default SDL_LOGICAL_PRESENTATION_STRETCH Is Set, Only Setting It Here For Demonstration Purpose
        different_sdl_presentation_mode: Some(SDL_LOGICAL_PRESENTATION_STRETCH),
        font: ("JetBrainsMono".to_string(), Some("Bold".to_string()))
    };
    let mut window_modules = create_window(window_config);
    //bool is reffered to the rollback pages system, with "Mouse side buttons" or ("Alt" + "Arrows Keys") | (true = Page Rollback On), (false = Page Rollback Off)
    let mut input_handler = InputHandler::new(true);
    let mut app_state = AppState::new(PageId::Page1, window_modules.canvas.window().size(), window_modules.stretch_mode_status);
    let mut page_data = PageData::new(&app_state);

    let renderer_config = RendererConfig { canvas: window_modules.canvas, texture_creator: &window_modules.texture_creator, ttf_context: &window_modules.ttf_context, font_path: &window_modules.font_path, decrease_color_when_selected: Some((25, 25, 25)), selection_color: Some((0, 0, 200, 125)), assets_dir: Some(&ASSETS) };
    let mut renderer = Renderer::new(renderer_config);


    populate_page_data(&mut page_data);

    // Wrap the button_action function in a mutable closure so it can capture
    // additional context if needed. Passing a closure here allows the
    // button handler API to accept additional arguments beyond the default.
    let mut button_action_closure = |app_state: &mut AppState<PageId, ButtonId>, button_id: &ButtonId, page_data: &mut PageData<PageId, ButtonId>| button_action(app_state, button_id, page_data);

    loop
    {
        //using (900 / your_refresh_rate) to a very crispy experience
        std::thread::sleep(Duration::from_millis(900 / get_monitor_refresh_rate()));
        input_handler.handle_input(&mut window_modules.event_pump, &mut window_modules.clipboard_system, &mut page_data, &mut app_state, &mut button_action_closure);
        app_state.update_window_size(renderer.canvas.window().size().0, renderer.canvas.window().size().1);
        page_data.create_current_page(&mut app_state);
        renderer.render(&page_data, &mut app_state, &input_handler);
    }
}

pub fn begin_capturing_input(&mut self, button: ButtonId)

Begin capturing user input for a specific button ID

pub fn stop_capturing_input(&mut self)

Stop capturing user input

pub fn is_capturing(&self) -> bool

Check if currently capturing input

Trait Implementations

impl<PageId: Clone, ButtonId: Clone> Clone for AppState<PageId, ButtonId>

fn clone(&self) -> AppState<PageId, ButtonId>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<PageId: Debug, ButtonId: Debug> Debug for AppState<PageId, ButtonId>

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

Formats the value using the given formatter.