grx 0.2.0

Abstraction layer for UI development
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
108

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

//! The text area component

use glib::{Cast, CastNone};
use grx_macros::{gtk_component, props};
use gtk::glib;
use gtk::traits::TextBufferExt;
use gtk::traits::TextViewExt;
use gtk::traits::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<TextArea>>,
    pub on_blur: Option<Handler<TextArea>>,
    pub password: Option<bool>,
    pub disabled: 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)
            .field("disabled", &self.disabled)
            .finish()
    }
}

pub fn text_area(mut props: Props) -> Rc<TextArea> {
    let text_area: gtk::TextView = gtk::TextView::builder().build();
    let on_blur = props.on_blur.take();
    let on_change = props.on_change.take();

    text_area.set_sensitive(!props.disabled);

    let w = text_area.clone();
    let component = new_gc!(TextArea { w, props });

    apply(component.clone());

    if let Some(onc) = on_change {
        let comp = component.clone();
        text_area.connect_buffer_notify(move |_| {
            onc(comp.clone());
        });
    }

    if let Some(onb) = on_blur {
        let comp = component.clone();
        if let Some(text) = text_area.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::TextView)]
#[derive(Debug)]
pub struct TextArea {}

impl Interactable for TextArea {
    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_buffer_notify(move |_| handler(&s));
        // TextViewExt::connect
    }

    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 TextArea {
    fn text(self: &Rc<Self>) -> String {
        self.widget.buffer().to_string()
    }

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