numeric_up_down.rs

use azul::prelude::*;

use azul::app::AppStateNoData;
use azul::callbacks::{DefaultCallback, DefaultCallbackId};
use azul::widgets::button::Button;
use azul::widgets::label::Label;
use azul::window::FakeWindow;
use std::marker::PhantomData;

pub struct IntegerUpDown<T : Layout>
{
    minimum: i128,
    maximum: i128,
    callbacks: Option<Callbacks>,
    marker: PhantomData<T>
}

struct Callbacks
{
    text_input: DefaultCallbackId,
    virtual_key_down: DefaultCallbackId
}

impl<T : Layout> IntegerUpDown<T>
{
    pub fn new(minimum: i128, maximum: i128) -> Self
    {
        IntegerUpDown
        {
            minimum,
            maximum,
            callbacks: None,
            marker: PhantomData
        }
    }

    pub fn bind(mut self, window: &mut FakeWindow<T>, state: &IntegerUpDownState, data: &T) -> Self
    {
        let state_ptr = StackCheckedPointer::new(data, state).unwrap();
        let text_input = window.add_callback(state_ptr, DefaultCallback(Self::on_text_input));
        let virtual_key_down = window.add_callback(state_ptr, DefaultCallback(Self::on_virtual_key_down));
        self.callbacks = Some(Callbacks
        {
            text_input,
            virtual_key_down
        });
        return self;
    }

    pub fn dom(self, state: &IntegerUpDownState) -> Dom<T> 
    {
        let mut container = Dom::new(NodeType::Div).with_class("integer-up-down");
        let callbacks = self.callbacks.expect("IntegerUpDown default callbacks missing");
        container.add_default_callback_id(On::TextInput, callbacks.text_input);
        container.add_default_callback_id(On::VirtualKeyDown, callbacks.virtual_key_down);
        container.add_child(Label::new(state.value.clone()).dom());
        return container;
    }

    fn on_text_input(data: &StackCheckedPointer<T>, app_state_no_data: &mut AppStateNoData<T>, window_event: &mut CallbackInfo<T>) -> UpdateScreen 
    {
        println!("Text");
        unsafe { data.invoke_mut(IntegerUpDownState::on_text_input, app_state_no_data, window_event) }
    }

    fn on_virtual_key_down(data: &StackCheckedPointer<T>, app_state_no_data: &mut AppStateNoData<T>, window_event: &mut CallbackInfo<T>) -> UpdateScreen 
    {
        println!("VK");
        unsafe { data.invoke_mut(IntegerUpDownState::on_virtual_key_down, app_state_no_data, window_event) }
    }
}

pub struct IntegerUpDownState
{
    value: String,
    default: String
}

impl IntegerUpDownState
{
    pub fn new(default: i128) -> Self
    {
        IntegerUpDownState
        {
            value: default.to_string(),
            default: default.to_string()
        }
    }

    pub fn on_text_input<T : Layout>(&mut self, app_state: &mut AppStateNoData<T>, event: &mut CallbackInfo<T>) -> UpdateScreen 
    {
        println!("Hey");
        let ch = app_state.windows[event.window_id].get_keyboard_state().current_char?;
        if ch.is_ascii_digit()
        {
            if self.value == self.default
            {
                self.value = ch.to_string();
            }
            else
            {
                self.value.push(ch);
            }
            return Redraw
        }
        return DontRedraw
    }

    pub fn on_virtual_key_down<T : Layout>(&mut self, app_state: &mut AppStateNoData<T>, event: &mut CallbackInfo<T>) -> UpdateScreen 
    {
        println!("VK2");
        return DontRedraw
    }
}