slint-interpreter 1.12.1

Interpreter library for Slint
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

// Copyright © SixtyFPS GmbH <info@slint.dev>
// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0

use crate::api::Value;
use core::cell::Cell;
use i_slint_core::model::{Model, ModelNotify, ModelRc, ModelTracker};

pub struct ValueModel {
    value: Value,
}

impl ValueModel {
    pub fn new(value: Value) -> Self {
        Self { value }
    }
}

impl ModelTracker for ValueModel {
    fn attach_peer(&self, peer: i_slint_core::model::ModelPeer) {
        if let Value::Model(ref model_ptr) = self.value {
            model_ptr.model_tracker().attach_peer(peer)
        }
    }

    fn track_row_count_changes(&self) {
        if let Value::Model(ref model_ptr) = self.value {
            model_ptr.model_tracker().track_row_count_changes()
        }
    }

    fn track_row_data_changes(&self, row: usize) {
        if let Value::Model(ref model_ptr) = self.value {
            model_ptr.model_tracker().track_row_data_changes(row)
        }
    }
}

impl Model for ValueModel {
    type Data = Value;

    fn row_count(&self) -> usize {
        match &self.value {
            Value::Bool(b) => {
                if *b {
                    1
                } else {
                    0
                }
            }
            Value::Number(x) => x.max(Default::default()) as usize,
            Value::Void => 0,
            Value::Model(model_ptr) => model_ptr.row_count(),
            x => panic!("Invalid model {x:?}"),
        }
    }

    fn row_data(&self, row: usize) -> Option<Self::Data> {
        if row >= self.row_count() {
            None
        } else {
            Some(match &self.value {
                Value::Bool(_) => Value::Void,
                Value::Number(_) => Value::Number(row as _),
                Value::Model(model_ptr) => model_ptr.row_data(row)?,
                x => panic!("Invalid model {x:?}"),
            })
        }
    }

    fn model_tracker(&self) -> &dyn ModelTracker {
        self
    }

    fn set_row_data(&self, row: usize, data: Self::Data) {
        match &self.value {
            Value::Model(model_ptr) => model_ptr.set_row_data(row, data),
            _ => eprintln!("Trying to change the value of a read-only integer model."),
        }
    }

    fn as_any(&self) -> &dyn core::any::Any {
        self
    }
}

/// A model for conditional elements
#[derive(Default)]
pub(crate) struct BoolModel {
    value: Cell<bool>,
    notify: ModelNotify,
}

impl Model for BoolModel {
    type Data = Value;
    fn row_count(&self) -> usize {
        if self.value.get() {
            1
        } else {
            0
        }
    }
    fn row_data(&self, row: usize) -> Option<Self::Data> {
        (row == 0 && self.value.get()).then_some(Value::Void)
    }
    fn model_tracker(&self) -> &dyn ModelTracker {
        &self.notify
    }
}

impl BoolModel {
    pub fn set_value(&self, val: bool) {
        let old = self.value.replace(val);
        if old != val {
            self.notify.reset();
        }
    }
}

// A map model that wraps a Model
pub struct ValueMapModel<T>(pub ModelRc<T>);

impl<T: TryFrom<Value> + Into<Value> + 'static> Model for ValueMapModel<T> {
    type Data = Value;

    fn row_count(&self) -> usize {
        self.0.row_count()
    }

    fn row_data(&self, row: usize) -> Option<Self::Data> {
        self.0.row_data(row).map(|x| x.into())
    }

    fn model_tracker(&self) -> &dyn ModelTracker {
        self.0.model_tracker()
    }

    fn as_any(&self) -> &dyn core::any::Any {
        self
    }

    fn set_row_data(&self, row: usize, data: Self::Data) {
        if let Ok(data) = data.try_into() {
            self.0.set_row_data(row, data)
        }
    }
}