grx 0.3.2

Abstraction layer for UI development
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

// SPDX-License-Identifier: GPL-3.0-or-later

//! The entry/input component

use glib::prelude::{Cast, CastNone};
use grx_macros::{gtk_component, props};
use gtk::glib;
use gtk::{
    prelude::EditableExtManual,
    prelude::{EditableExt, WidgetExt},
};
use std::rc::Rc;

use crate::{default_on_click, default_on_swipe, handlers::Handler, new_gc, Interactable, Textual};

use super::gtk_props::apply;

#[props]
#[derive(Default)]
pub struct Props {
    pub on_change: Option<Handler<Entry>>,
    pub on_blur: Option<Handler<Entry>>,
    pub password: Option<bool>,
}

impl std::fmt::Debug for Props {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Props")
            .field("id", &self.id)
            .field("classes", &self.classes)
            .field("styles", &self.styles)
            .field("children", &self.children)
            .field("on_change", &self.on_change.is_some())
            .field("on_blur", &self.on_blur.is_some())
            .field("password", &self.password)
            .finish()
    }
}

pub fn entry(mut props: Props) -> Rc<Entry> {
    let entry: gtk::Editable = match props.password {
        Some(true) => gtk::PasswordEntry::builder().build().upcast(),
        _ => gtk::Entry::builder().build().upcast(),
    };
    let on_blur = props.on_blur.take();
    let on_change = props.on_change.take();

    let w = entry.clone();
    let component = new_gc!(Entry { w, props });

    apply(component.clone());

    if let Some(onc) = on_change {
        let comp = component.clone();
        entry.connect_insert_text(move |_, _, _| {
            onc(comp.clone());
        });
    }

    if let Some(onb) = on_blur {
        let comp = component.clone();
        if let Some(text) = entry.first_child().and_downcast_ref::<gtk::Text>() {
            text.connect_has_focus_notify(move |w| {
                if !w.has_focus() {
                    onb(comp.clone())
                }
            });
        }
    }

    component
}

#[gtk_component(gtk::Editable)]
#[derive(Debug)]
pub struct Entry {}

impl Interactable for Entry {
    default_on_click! {}
    default_on_swipe! {}

    fn on_change(self: &Rc<Self>, handler: impl Fn(&Rc<Self>) + 'static) {
        let s = self.clone();
        self.widget.connect_insert_text(move |_, _, _| handler(&s));
    }

    fn on_blur(self: &Rc<Self>, handler: impl Fn(&Rc<Self>) + 'static) {
        let s = self.clone();
        if let Some(text) = self.widget.first_child().and_downcast_ref::<gtk::Text>() {
            text.connect_has_focus_notify(move |w| {
                if !w.has_focus() {
                    handler(&s)
                }
            });
        }
    }
}

impl Textual for Entry {
    fn text(self: &Rc<Self>) -> String {
        self.widget.text().to_string()
    }

    fn set_text(self: &Rc<Self>, text: &str) {
        self.widget.set_text(text)
    }
}