├── .gitignore
├── COPYING
├── Cargo.toml
├── README.md
├── _test.sh
├── examples
    ├── blockcode.rs
    ├── demo.rs
    ├── hex_test.png
    └── list_test.rs
├── res
    ├── dejavu-fonts-ttf-2.37.zip
    └── gui_mockup.svg
├── rustfmt.toml
└── src
    ├── blocklang.rs
    ├── font.ttf
    ├── font_mono.ttf
    ├── layout.rs
    ├── lib.rs
    ├── markdown.rs
    ├── painter.rs
    ├── rect.rs
    ├── style.rs
    ├── ui.rs
    ├── widget.rs
    ├── widget_store.rs
    ├── widgets
        ├── blockcode.rs
        ├── connector.rs
        ├── entry.rs
        ├── graph.rs
        ├── graph_minmax.rs
        ├── hexgrid.rs
        ├── hexknob.rs
        ├── list.rs
        ├── mod.rs
        ├── octave_keys.rs
        ├── pattern_editor.rs
        ├── scope.rs
        └── wichtext.rs
    └── window.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | *.history
3 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name        = "hexotk"
 3 | version     = "0.5.1"
 4 | authors     = ["Weird Constructor <weirdconstructor@m8geil.de>"]
 5 | edition     = "2021"
 6 | license     = "GPL-3.0-or-later"
 7 | description = "HexoTK - A GUI Toolkit for Audio Plugins"
 8 | 
 9 | [lib]
10 | name = "hexotk"
11 | 
12 | [features]
13 | default=[]
14 | driver=[]
15 | 
16 | [dependencies]
17 | hexodsp            = { git = "https://github.com/WeirdConstructor/HexoDSP.git" }
18 | #hexodsp             = { path = "../hexodsp" }
19 | femtovg            = { git = "https://github.com/femtovg/femtovg", default-features = false, features = ["image-loading"] }
20 | #femtovg            = { path = "../other/femtovg", features = ["image-loading"] }
21 | image              = { version = "0.24.3", features = ["png", "jpeg"] }
22 | raw-gl-context     = { git = "https://github.com/glowcoil/raw-gl-context" }
23 | morphorm           = { git = "https://github.com/WeirdConstructor/morphorm.git" }
24 | #morphorm           = { path = "../morphorm" }
25 | baseview           = { git = "https://github.com/RustAudio/baseview.git", features = ["opengl"] }
26 | keyboard-types     = { version = "0.6.1", default-features = false }
27 | pulldown-cmark     = "0.9.2"
28 | raw-window-handle  = "0.5.0"
29 | gl                 = "0.14.0"
30 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # HexoTK - A graphic user interface toolkit for audio plugins
 2 | 
 3 | ## State of Development
 4 | 
 5 | Super early!
 6 | 
 7 | ## Building
 8 | 
 9 |     cargo run --example demo
10 | 
11 | 
12 | ## TODO / Features
13 | 
14 | * Everything
15 | 
16 | ## Known Bugs
17 | 
18 | * The ones you encounter and create as issues on GitHub.
19 | 
20 | ## Support Development
21 | 
22 | You can support me (and the development of this project) via Liberapay:
23 | 
24 | <a href="https://liberapay.com/WeirdConstructor/donate"><img alt="Donate using Liberapay" src="https://liberapay.com/assets/widgets/donate.svg"></a>
25 | 
26 | ## License
27 | 
28 | This project is licensed under the GNU Affero General Public License Version 3 or
29 | later.
30 | 
31 | The DSP code that was partially translated from LMMS C++ to Rust and was
32 | originally released under GNU General Public License Version 2 or any later.
33 | The former authors were:
34 | 
35 | * Copyright (c) 2006-2014 Tobias Doerffel <tobydox/at/users.sourceforge.net>
36 | * Copyright (c) 2014 grejppi <grejppi/at/gmail.com>
37 | 
38 | The fonts DejaVuSerif.ttf and DejaVuSansMono.ttf under the license:
39 | 
40 |     Fonts are (c) Bitstream (see below). DejaVu changes are in public domain.
41 |     Glyphs imported from Arev fonts are (c) Tavmjong Bah (see below)
42 | 
43 | ### Why GPL?
44 | 
45 | Picking a license for my code bothered me for a long time. I read many
46 | discussions about this topic. Read the license explanations. And discussed
47 | this matter with other developers.
48 | 
49 | First about _why I write code for free_ at all, the reasons are:
50 | 
51 | - It's my passion to write computer programs. In my free time I can
52 | write the code I want, when I want and the way I want. I can freely
53 | allocate my time and freely choose the projects I want to work on.
54 | - To help a friend or member of my family.
55 | - To solve a problem I have.
56 | - To learn something new.
57 | 
58 | Those are the reasons why I write code for free. Now the reasons
59 | _why I publish the code_, when I could as well keep it to myself:
60 | 
61 | - So that it may bring value to users and the free software community.
62 | - Show my work as an artist.
63 | - To get into contact with other developers.
64 | - To exchange knowledge and help other developers.
65 | - And it's a nice change to put some more polish on my private projects.
66 | 
67 | Most of those reasons don't yet justify GPL. The main point of the GPL, as far
68 | as I understand: The GPL makes sure the software stays free software until
69 | eternity. That the _end user_ of the software always stays in control. That the users
70 | have the means to adapt the software to new platforms or use cases.
71 | Even if the original authors don't maintain the software anymore.
72 | It ultimately prevents _"vendor lock in"_. I really dislike vendor lock in,
73 | especially as developer. Especially as developer I want and need to stay
74 | in control of the computers and software I use.
75 | 
76 | Another point is, that my work (and the work of any other developer) has a
77 | value. If I give away my work without _any_ strings attached, I effectively
78 | work for free. This compromises the price I (and potentially other developers)
79 | can demand for the skill, workforce and time.
80 | 
81 | This makes two reasons for me to choose the GPL:
82 | 
83 | 1. I do not want to support vendor lock in scenarios for free.
84 |    I want to prevent those when I have a choice, when I invest my private
85 |    time to bring value to the end users.
86 | 2. I don't want to low ball my own (and other developer's) wage and prices
87 |    by giving away the work I spent my scarce private time on with no strings
88 |    attached. I do not want companies to be able to use it in closed source
89 |    projects to drive a vendor lock in scenario.
90 | 
91 | We can discuss relicensing of my code or project if you are interested in using
92 | it in a closed source project. Bear in mind, that I can only relicense the
93 | parts of the project I wrote. If the project contains GPL code from other
94 | projects and authors, I can't relicense it.
95 | 


--------------------------------------------------------------------------------
/_test.sh:
--------------------------------------------------------------------------------
1 | cargo run --release --color=always --example demo 2>&1 | less -R
2 | 


--------------------------------------------------------------------------------
/examples/blockcode.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoTK. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use hexodsp::wblockdsp::*;
  6 | use hexotk::*;
  7 | use std::cell::RefCell;
  8 | use std::rc::Rc;
  9 | use std::sync::{Arc, Mutex};
 10 | 
 11 | const WINDOW_W: i32 = 1020;
 12 | const WINDOW_H: i32 = 720;
 13 | 
 14 | #[derive(Debug)]
 15 | pub struct ASTNode {
 16 |     pub id: usize,
 17 |     pub typ: String,
 18 |     pub lbl: String,
 19 |     pub nodes: Vec<(String, String, ASTNodeRef)>,
 20 | }
 21 | 
 22 | #[derive(Debug, Clone)]
 23 | pub struct ASTNodeRef(Rc<RefCell<ASTNode>>);
 24 | 
 25 | impl ASTNodeRef {
 26 |     pub fn walk_dump(&self, input: &str, output: &str, indent: usize) -> String {
 27 |         let indent_str = "   ".repeat(indent + 1);
 28 | 
 29 |         let out_port = if output.len() > 0 { format!("(out: {})", output) } else { "".to_string() };
 30 |         let in_port = if input.len() > 0 { format!("(in: {})", input) } else { "".to_string() };
 31 | 
 32 |         let mut s = format!(
 33 |             "{}{}#{}[{}] {}{}\n",
 34 |             indent_str,
 35 |             self.0.borrow().id,
 36 |             self.0.borrow().typ,
 37 |             self.0.borrow().lbl,
 38 |             out_port,
 39 |             in_port
 40 |         );
 41 | 
 42 |         for (inp, out, n) in &self.0.borrow().nodes {
 43 |             s += &n.walk_dump(&inp, &out, indent + 1);
 44 |         }
 45 | 
 46 |         s
 47 |     }
 48 | }
 49 | 
 50 | impl BlockASTNode for ASTNodeRef {
 51 |     fn from(id: usize, typ: &str, lbl: &str) -> ASTNodeRef {
 52 |         ASTNodeRef(Rc::new(RefCell::new(ASTNode {
 53 |             id,
 54 |             typ: typ.to_string(),
 55 |             lbl: lbl.to_string(),
 56 |             nodes: vec![],
 57 |         })))
 58 |     }
 59 | 
 60 |     fn add_node(&self, in_port: String, out_port: String, node: ASTNodeRef) {
 61 |         self.0.borrow_mut().nodes.push((in_port, out_port, node));
 62 |     }
 63 | }
 64 | 
 65 | fn make_block_lang() -> Rc<RefCell<BlockLanguage>> {
 66 |     let mut lang = BlockLanguage::new();
 67 | 
 68 |     lang.define(BlockType {
 69 |         category: "source".to_string(),
 70 |         name: "phse".to_string(),
 71 |         rows: 1,
 72 |         inputs: vec![Some("f".to_string())],
 73 |         outputs: vec![Some("".to_string())],
 74 |         area_count: 0,
 75 |         user_input: BlockUserInput::None,
 76 |         description:
 77 |             "A phasor, returns a saw tooth wave to scan through things or use as modulator."
 78 |                 .to_string(),
 79 |         color: 2,
 80 |     });
 81 | 
 82 |     lang.define(BlockType {
 83 |         category: "literals".to_string(),
 84 |         name: "zero".to_string(),
 85 |         rows: 1,
 86 |         inputs: vec![],
 87 |         outputs: vec![Some("".to_string())],
 88 |         area_count: 0,
 89 |         user_input: BlockUserInput::None,
 90 |         description: "The 0.0 value".to_string(),
 91 |         color: 1,
 92 |     });
 93 | 
 94 |     lang.define(BlockType {
 95 |         category: "routing".to_string(),
 96 |         name: "->".to_string(),
 97 |         rows: 1,
 98 |         inputs: vec![Some("".to_string())],
 99 |         outputs: vec![Some("".to_string())],
100 |         area_count: 0,
101 |         user_input: BlockUserInput::None,
102 |         description: "Forwards the value one block".to_string(),
103 |         color: 6,
104 |     });
105 | 
106 |     lang.define(BlockType {
107 |         category: "routing".to_string(),
108 |         name: "->2".to_string(),
109 |         rows: 2,
110 |         inputs: vec![Some("".to_string())],
111 |         outputs: vec![Some("".to_string()), Some("".to_string())],
112 |         area_count: 0,
113 |         user_input: BlockUserInput::None,
114 |         description: "Forwards the value one block and sends it to multiple destinations"
115 |             .to_string(),
116 |         color: 6,
117 |     });
118 | 
119 |     lang.define(BlockType {
120 |         category: "routing".to_string(),
121 |         name: "->3".to_string(),
122 |         rows: 3,
123 |         inputs: vec![Some("".to_string())],
124 |         outputs: vec![Some("".to_string()), Some("".to_string()), Some("".to_string())],
125 |         area_count: 0,
126 |         user_input: BlockUserInput::None,
127 |         description: "Forwards the value one block and sends it to multiple destinations"
128 |             .to_string(),
129 |         color: 6,
130 |     });
131 | 
132 |     lang.define(BlockType {
133 |         category: "variables".to_string(),
134 |         name: "set".to_string(),
135 |         rows: 1,
136 |         inputs: vec![Some("".to_string())],
137 |         outputs: vec![],
138 |         area_count: 0,
139 |         user_input: BlockUserInput::Identifier,
140 |         description: "Stores into a variable".to_string(),
141 |         color: 2,
142 |     });
143 | 
144 |     lang.define(BlockType {
145 |         category: "variables".to_string(),
146 |         name: "get".to_string(),
147 |         rows: 1,
148 |         inputs: vec![],
149 |         outputs: vec![Some("".to_string())],
150 |         area_count: 0,
151 |         user_input: BlockUserInput::Identifier,
152 |         description: "Loads a variable".to_string(),
153 |         color: 12,
154 |     });
155 | 
156 |     lang.define(BlockType {
157 |         category: "variables".to_string(),
158 |         name: "if".to_string(),
159 |         rows: 1,
160 |         inputs: vec![Some("".to_string())],
161 |         outputs: vec![Some("".to_string())],
162 |         area_count: 2,
163 |         user_input: BlockUserInput::None,
164 |         description: "Divides the controlflow based on a true (>= 0.5) \
165 |                          or false (< 0.5) input value."
166 |             .to_string(),
167 |         color: 0,
168 |     });
169 | 
170 |     lang.define(BlockType {
171 |         category: "nodes".to_string(),
172 |         name: "1pole".to_string(),
173 |         rows: 2,
174 |         inputs: vec![Some("in".to_string()), Some("f".to_string())],
175 |         outputs: vec![Some("lp".to_string()), Some("hp".to_string())],
176 |         area_count: 0,
177 |         user_input: BlockUserInput::None,
178 |         description: "Runs a simple one pole filter on the input".to_string(),
179 |         color: 8,
180 |     });
181 | 
182 |     lang.define(BlockType {
183 |         category: "nodes".to_string(),
184 |         name: "svf".to_string(),
185 |         rows: 3,
186 |         inputs: vec![Some("in".to_string()), Some("f".to_string()), Some("r".to_string())],
187 |         outputs: vec![Some("lp".to_string()), Some("bp".to_string()), Some("hp".to_string())],
188 |         area_count: 0,
189 |         user_input: BlockUserInput::None,
190 |         description: "Runs a state variable filter on the input".to_string(),
191 |         color: 8,
192 |     });
193 | 
194 |     lang.define(BlockType {
195 |         category: "functions".to_string(),
196 |         name: "sin".to_string(),
197 |         rows: 1,
198 |         inputs: vec![Some("".to_string())],
199 |         outputs: vec![Some("".to_string())],
200 |         area_count: 0,
201 |         user_input: BlockUserInput::None,
202 |         description: "Calculates the sine of the input".to_string(),
203 |         color: 16,
204 |     });
205 | 
206 |     lang.define(BlockType {
207 |         category: "nodes".to_string(),
208 |         name: "delay".to_string(),
209 |         rows: 2,
210 |         inputs: vec![Some("in".to_string()), Some("t".to_string())],
211 |         outputs: vec![Some("".to_string())],
212 |         area_count: 0,
213 |         user_input: BlockUserInput::None,
214 |         description: "Runs a linearly interpolated delay on the input".to_string(),
215 |         color: 8,
216 |     });
217 | 
218 |     for fun_name in &["+", "-", "*", "/"] {
219 |         lang.define(BlockType {
220 |             category: "arithmetics".to_string(),
221 |             name: fun_name.to_string(),
222 |             rows: 2,
223 |             inputs: if fun_name == &"-" || fun_name == &"/" {
224 |                 vec![Some("a".to_string()), Some("b".to_string())]
225 |             } else {
226 |                 vec![Some("".to_string()), Some("".to_string())]
227 |             },
228 |             outputs: vec![Some("".to_string())],
229 |             area_count: 0,
230 |             user_input: BlockUserInput::None,
231 |             description: "A binary arithmetics operation".to_string(),
232 |             color: 4,
233 |         });
234 |     }
235 | 
236 |     lang.define_identifier("alpha");
237 |     lang.define_identifier("beta");
238 |     lang.define_identifier("delta");
239 |     lang.define_identifier("gamma");
240 |     lang.define_identifier("&sig1");
241 |     lang.define_identifier("&sig2");
242 | 
243 |     Rc::new(RefCell::new(lang))
244 | }
245 | 
246 | fn main() {
247 |     let concurrent_data = Arc::new(Mutex::new(CloneMutable::new(("Count:".to_string(), 0))));
248 | 
249 |     std::thread::spawn({
250 |         let data = concurrent_data.clone();
251 |         move || loop {
252 |             if let Ok(mut data) = data.lock() {
253 |                 (*data).1 += 1;
254 |             }
255 |             std::thread::sleep(std::time::Duration::from_millis(1000));
256 |         }
257 |     });
258 | 
259 |     open_window(
260 |         "HexoTK BlockCode Test",
261 |         WINDOW_W,
262 |         WINDOW_H,
263 |         None,
264 |         Box::new(|| {
265 |             let mut style = Style::new();
266 |             style.font_size = 20.0;
267 | 
268 |             let style_ref = Rc::new(style.clone());
269 | 
270 |             let lang = make_block_lang();
271 | 
272 |             let block_fun = Arc::new(Mutex::new(BlockFun::new(lang)));
273 |             {
274 |                 let mut block_fun_acc = block_fun.lock().unwrap();
275 |                 block_fun_acc.instanciate_at(0, 3, 3, "phse", None).unwrap();
276 |             }
277 | 
278 |             let s = style_ref.with_style_clone(|style| {
279 |                 style.bg_color = hexotk::style::UI_ACCENT_BG1_CLR;
280 |                 style.border_style = BorderStyle::Rect;
281 |                 style.pad_top = 0.0;
282 |                 style.pad_left = 0.0;
283 |                 style.pad_right = 0.0;
284 |                 style.pad_bottom = 0.0;
285 |                 style.border = 2.0;
286 |                 style.shadow_offs = (0.0, 0.0);
287 |                 style.border_color = hexotk::style::UI_SELECT_CLR;
288 |                 style.font_size = 10.0;
289 |                 style.ext = StyleExt::BlockCode {
290 |                     with_markers: true,
291 |                     grid_marker_color: hexotk::style::UI_ACCENT_DARK_CLR,
292 |                     block_bg_hover_color: hexotk::style::UI_ACCENT_CLR,
293 |                     block_bg_color: hexotk::style::UI_ACCENT_BG2_CLR,
294 |                     port_select_color: hexotk::style::UI_SELECT_CLR,
295 |                 };
296 |             });
297 | 
298 |             let root = Widget::new(style_ref.clone());
299 |             root.set_ctrl(Control::Rect);
300 |             root.enable_cache();
301 |             root.change_layout(|l| l.layout_type = Some(LayoutType::Column));
302 | 
303 |             let blockcode = Widget::new(s.clone());
304 |             blockcode
305 |                 .set_ctrl(Control::BlockCode { code: Box::new(BlockCode::new(block_fun.clone())) });
306 | 
307 |             {
308 |                 let mut block_fun_acc = block_fun.lock().unwrap();
309 |                 block_fun_acc.instanciate_at(0, 5, 5, "phse", None).unwrap();
310 |             }
311 | 
312 |             let code = block_fun.clone();
313 |             blockcode.reg("click", move |_ctx, _wid, ev| {
314 |                 if let EvPayload::BlockPos { button, at, .. } = ev.data {
315 |                     if let BlockPos::Block { row, col, .. } = at {
316 |                         let (id, x, y) = at.pos();
317 | 
318 |                         let mut code = code.lock().unwrap();
319 | 
320 |                         if button == MButton::Right {
321 |                             println!("PORT CLICK {:?}", at);
322 |                             code.shift_port(id, x, y, row, col == 1);
323 |                         } else {
324 |                             if col == 1 {
325 |                                 let _ = code.split_block_chain_after(id, x, y, Some("->"));
326 |                             } else {
327 |                                 let _ = code.split_block_chain_after(id, x - 1, y, None);
328 |                             }
329 |                         }
330 | 
331 |                         let tree = code.generate_tree::<ASTNodeRef>("zero").unwrap();
332 |                         println!("{}", tree.walk_dump("", "", 0));
333 | 
334 |                         code.recalculate_area_sizes();
335 |                     } else {
336 |                         println!("CLICK POPUP {:?}", at);
337 |                         //                    state.insert_event(
338 |                         //                        Event::new(PopupEvent::OpenAtCursor)
339 |                         //                        .target(pop)
340 |                         //                        .origin(Entity::root()));
341 |                     }
342 |                     //                    (*on_change)(state, entity, code.clone());
343 |                 }
344 |                 println!("CLICK: {:?}", ev);
345 |             });
346 | 
347 |             let code = block_fun.clone();
348 |             blockcode.reg("drag", move |_ctx, _wid, ev| {
349 |                 if let EvPayload::BlockPos { at, to: Some(to), button } = ev.data {
350 |                     println!("CLICK: {:?}", ev);
351 |                     let (id, x, y) = at.pos();
352 |                     let (id2, x2, y2) = to.pos();
353 | 
354 |                     println!("P1={:?} P2={:?}", at, to);
355 |                     let mut code = code.lock().unwrap();
356 | 
357 |                     if let BlockPos::Cell { .. } = at {
358 |                         if let BlockPos::Block { .. } = to {
359 |                             let _ = code.clone_block_from_to(id2, x2, y2, id, x, y);
360 |                             code.recalculate_area_sizes();
361 | 
362 |                             // (*ouagen_change)(state, entity, code.clone());
363 |                         }
364 |                     } else {
365 |                         if button == MButton::Right {
366 |                             let _ = code.move_block_from_to(id, x, y, id2, x2, y2);
367 |                         } else {
368 |                             if at.pos() == to.pos() {
369 |                                 let _ = code.remove_at(id, x, y);
370 |                             } else {
371 |                                 let _ = code.move_block_chain_from_to(id, x, y, id2, x2, y2);
372 |                             }
373 |                         }
374 | 
375 |                         code.recalculate_area_sizes();
376 | 
377 |                         // (*on_change)(state, entity, code.clone());
378 |                     }
379 |                 }
380 |             });
381 | 
382 |             root.add(blockcode);
383 | 
384 |             let mut ui = Box::new(UI::new(Rc::new(RefCell::new(1))));
385 | 
386 |             ui.add_layer_root(root);
387 | 
388 |             ui
389 |         }),
390 |     );
391 | }
392 | 


--------------------------------------------------------------------------------
/examples/hex_test.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WeirdConstructor/HexoTK/e949aabda88f009f0d6b446d057f9aff4d4a19be/examples/hex_test.png


--------------------------------------------------------------------------------
/examples/list_test.rs:
--------------------------------------------------------------------------------
 1 | use hexotk::*;
 2 | use std::cell::RefCell;
 3 | use std::rc::Rc;
 4 | use std::sync::{Arc, Mutex};
 5 | 
 6 | const WINDOW_W: i32 = 1020;
 7 | const WINDOW_H: i32 = 720;
 8 | 
 9 | fn main() {
10 |     open_window(
11 |         "HexoTK List Test",
12 |         WINDOW_W,
13 |         WINDOW_H,
14 |         None,
15 |         Box::new(|| {
16 |             let mut style = Style::new();
17 |             style.font_size = 20.0;
18 | 
19 |             let style_ref = Rc::new(style.clone());
20 | 
21 |             let s = style_ref.with_style_clone(|style| {
22 |                 style.bg_color = hexotk::style::UI_ACCENT_BG1_CLR;
23 |                 style.border_style = BorderStyle::Rect;
24 |                 style.pad_top = 0.0;
25 |                 style.pad_left = 0.0;
26 |                 style.pad_right = 0.0;
27 |                 style.pad_bottom = 0.0;
28 |                 style.border = 4.0;
29 |                 style.shadow_offs = (0.0, 0.0);
30 |                 style.border_color = hexotk::style::UI_SELECT_CLR;
31 |             });
32 |             let root = Widget::new(s.clone());
33 |             root.set_ctrl(Control::Rect);
34 |             root.enable_cache();
35 |             root.change_layout(|l| l.layout_type = Some(LayoutType::Column));
36 | 
37 |             let list_data = Rc::new(RefCell::new(ListData::new()));
38 |             list_data.borrow_mut().push("Test123".to_string());
39 |             list_data.borrow_mut().push("fiefi oewf eowijfewo ifjweo jwefoi jweofiew".to_string());
40 |             list_data.borrow_mut().push("Oooofeofewofe wf ewf owef ewo".to_string());
41 |             for i in 0..100 {
42 |                 list_data.borrow_mut().push(format!("Item {}", i));
43 |             }
44 | 
45 |             let list = Widget::new(s.with_style_clone(|s| {
46 |                 s.bg_color = hexotk::style::UI_LBL_BG_CLR;
47 |                 s.font_size = 18.0;
48 |                 s.border_color = (0.0, 1.0, 0.0);
49 |                 s.pad_item = 5.0;
50 |             }));
51 |             list.set_ctrl(Control::List { list: Box::new(List::new(list_data.clone(), ListScrollMode::Detached)) });
52 |             list.enable_cache();
53 |             list.change_layout(|l| {
54 |                 l.left = Some(Units::Pixels(30.0));
55 |                 l.top = Some(Units::Pixels(50.0));
56 |                 l.width = Some(Units::Pixels(200.0));
57 |             });
58 | 
59 |             root.add(list);
60 | 
61 |             let mut ui = Box::new(UI::new(Rc::new(RefCell::new(1))));
62 | 
63 |             ui.add_layer_root(root);
64 | 
65 |             ui
66 |         }),
67 |     );
68 | }
69 | 


--------------------------------------------------------------------------------
/res/dejavu-fonts-ttf-2.37.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WeirdConstructor/HexoTK/e949aabda88f009f0d6b446d057f9aff4d4a19be/res/dejavu-fonts-ttf-2.37.zip


--------------------------------------------------------------------------------
/rustfmt.toml:
--------------------------------------------------------------------------------
1 | use_small_heuristics = "Max"
2 | use_field_init_shorthand = true
3 | 


--------------------------------------------------------------------------------
/src/font.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WeirdConstructor/HexoTK/e949aabda88f009f0d6b446d057f9aff4d4a19be/src/font.ttf


--------------------------------------------------------------------------------
/src/font_mono.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/WeirdConstructor/HexoTK/e949aabda88f009f0d6b446d057f9aff4d4a19be/src/font_mono.ttf


--------------------------------------------------------------------------------
/src/layout.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoTK. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use crate::widget_store::WidgetStore;
  6 | use crate::Rect;
  7 | 
  8 | use std::cell::RefCell;
  9 | use std::collections::HashMap;
 10 | use std::rc::Rc;
 11 | 
 12 | use morphorm::{Cache, GeometryChanged, LayoutType, Node, PositionType, Units};
 13 | 
 14 | #[derive(Debug, Default, Clone, Copy)]
 15 | pub struct CachedLayout {
 16 |     geometry_changed: GeometryChanged,
 17 | 
 18 |     width: f32,
 19 |     height: f32,
 20 |     posx: f32,
 21 |     posy: f32,
 22 | 
 23 |     left: f32,
 24 |     right: f32,
 25 |     top: f32,
 26 |     bottom: f32,
 27 | 
 28 |     new_width: f32,
 29 |     new_height: f32,
 30 | 
 31 |     child_width_max: f32,
 32 |     child_width_sum: f32,
 33 |     child_height_max: f32,
 34 |     child_height_sum: f32,
 35 |     grid_row_max: f32,
 36 |     grid_col_max: f32,
 37 | 
 38 |     horizontal_free_space: f32,
 39 |     vertical_free_space: f32,
 40 | 
 41 |     vertical_stretch_sum: f32,
 42 |     horizontal_stretch_sum: f32,
 43 | 
 44 |     stack_first_child: bool,
 45 |     stack_last_child: bool,
 46 | }
 47 | 
 48 | pub struct LayoutCache {
 49 |     layouts: HashMap<usize, CachedLayout>,
 50 |     store: Rc<RefCell<WidgetStore>>,
 51 | }
 52 | 
 53 | impl LayoutCache {
 54 |     pub fn new(store: Rc<RefCell<WidgetStore>>) -> Self {
 55 |         Self { layouts: HashMap::new(), store }
 56 |     }
 57 | 
 58 |     pub fn get_widget_rect_by_id(&self, w_id: &WidgetId) -> Rect {
 59 |         if let Some(layout) = self.layouts.get(&w_id.unique_id()) {
 60 |             Rect { x: layout.posx, y: layout.posy, w: layout.width, h: layout.height }
 61 |         } else {
 62 |             Rect::from(0.0, 0.0, 0.0, 0.0)
 63 |         }
 64 |     }
 65 | 
 66 |     pub fn layout_mut<R: Default, F: FnOnce(&mut CachedLayout) -> R>(
 67 |         &mut self,
 68 |         w_id: &WidgetId,
 69 |         f: F,
 70 |     ) -> R {
 71 |         if let Some(layout) = self.layouts.get_mut(&w_id.unique_id()) {
 72 |             f(layout)
 73 |         } else {
 74 |             R::default()
 75 |         }
 76 |     }
 77 | 
 78 |     pub fn layout<R: Default, F: FnOnce(&CachedLayout) -> R>(&self, w_id: &WidgetId, f: F) -> R {
 79 |         if let Some(layout) = self.layouts.get(&w_id.unique_id()) {
 80 |             f(layout)
 81 |         } else {
 82 |             R::default()
 83 |         }
 84 |     }
 85 | 
 86 |     pub fn clear(&mut self) {
 87 |         self.layouts.clear();
 88 |         self.store.borrow_mut().for_each_widget(|wid| {
 89 |             self.layouts.insert(wid.unique_id(), CachedLayout::default());
 90 |         });
 91 |     }
 92 | }
 93 | 
 94 | impl Cache for LayoutCache {
 95 |     type Item = WidgetId;
 96 | 
 97 |     fn geometry_changed(&self, node: Self::Item) -> GeometryChanged {
 98 |         self.layout(&node, |l| l.geometry_changed)
 99 |     }
100 | 
101 |     fn visible(&self, node: Self::Item) -> bool {
102 |         self.store
103 |             .borrow()
104 |             .get(node.unique_id())
105 |             .map(|w| w.with_layout(|l| l.visible))
106 |             .unwrap_or(false)
107 |     }
108 | 
109 |     fn width(&self, node: Self::Item) -> f32 {
110 |         self.layout(&node, |l| l.width)
111 |     }
112 | 
113 |     fn height(&self, node: Self::Item) -> f32 {
114 |         self.layout(&node, |l| l.height)
115 |     }
116 | 
117 |     fn posx(&self, node: Self::Item) -> f32 {
118 |         self.layout(&node, |l| l.posx)
119 |     }
120 | 
121 |     fn posy(&self, node: Self::Item) -> f32 {
122 |         self.layout(&node, |l| l.posy)
123 |     }
124 | 
125 |     fn left(&self, node: Self::Item) -> f32 {
126 |         self.layout(&node, |l| l.left)
127 |     }
128 |     fn right(&self, node: Self::Item) -> f32 {
129 |         self.layout(&node, |l| l.right)
130 |     }
131 |     fn top(&self, node: Self::Item) -> f32 {
132 |         self.layout(&node, |l| l.top)
133 |     }
134 |     fn bottom(&self, node: Self::Item) -> f32 {
135 |         self.layout(&node, |l| l.bottom)
136 |     }
137 | 
138 |     fn new_width(&self, node: Self::Item) -> f32 {
139 |         self.layout(&node, |l| l.new_width)
140 |     }
141 |     fn new_height(&self, node: Self::Item) -> f32 {
142 |         self.layout(&node, |l| l.new_height)
143 |     }
144 | 
145 |     fn child_width_max(&self, node: Self::Item) -> f32 {
146 |         self.layout(&node, |l| l.child_width_max)
147 |     }
148 | 
149 |     fn child_width_sum(&self, node: Self::Item) -> f32 {
150 |         self.layout(&node, |l| l.child_width_sum)
151 |     }
152 | 
153 |     fn child_height_max(&self, node: Self::Item) -> f32 {
154 |         self.layout(&node, |l| l.child_height_max)
155 |     }
156 | 
157 |     fn child_height_sum(&self, node: Self::Item) -> f32 {
158 |         self.layout(&node, |l| l.child_height_sum)
159 |     }
160 | 
161 |     fn grid_row_max(&self, node: Self::Item) -> f32 {
162 |         self.layout(&node, |l| l.grid_row_max)
163 |     }
164 | 
165 |     fn grid_col_max(&self, node: Self::Item) -> f32 {
166 |         self.layout(&node, |l| l.grid_col_max)
167 |     }
168 | 
169 |     fn set_grid_col_max(&mut self, node: Self::Item, value: f32) {
170 |         self.layout_mut(&node, |l| l.grid_col_max = value)
171 |     }
172 | 
173 |     fn set_grid_row_max(&mut self, node: Self::Item, value: f32) {
174 |         self.layout_mut(&node, |l| l.grid_row_max = value)
175 |     }
176 | 
177 |     fn set_visible(&mut self, _node: Self::Item, _value: bool) {
178 |         // nop
179 |     }
180 | 
181 |     fn set_geo_changed(&mut self, node: Self::Item, flag: GeometryChanged, value: bool) {
182 |         self.layout_mut(&node, |l| l.geometry_changed.set(flag, value))
183 |     }
184 | 
185 |     fn set_child_width_sum(&mut self, node: Self::Item, value: f32) {
186 |         self.layout_mut(&node, |l| l.child_width_sum = value)
187 |     }
188 |     fn set_child_height_sum(&mut self, node: Self::Item, value: f32) {
189 |         self.layout_mut(&node, |l| l.child_height_sum = value)
190 |     }
191 |     fn set_child_width_max(&mut self, node: Self::Item, value: f32) {
192 |         self.layout_mut(&node, |l| l.child_width_max = value)
193 |     }
194 |     fn set_child_height_max(&mut self, node: Self::Item, value: f32) {
195 |         self.layout_mut(&node, |l| l.child_height_max = value)
196 |     }
197 | 
198 |     fn horizontal_free_space(&self, node: Self::Item) -> f32 {
199 |         self.layout(&node, |l| l.horizontal_free_space)
200 |     }
201 |     fn set_horizontal_free_space(&mut self, node: Self::Item, value: f32) {
202 |         self.layout_mut(&node, |l| l.horizontal_free_space = value)
203 |     }
204 |     fn vertical_free_space(&self, node: Self::Item) -> f32 {
205 |         self.layout(&node, |l| l.vertical_free_space)
206 |     }
207 |     fn set_vertical_free_space(&mut self, node: Self::Item, value: f32) {
208 |         self.layout_mut(&node, |l| l.vertical_free_space = value)
209 |     }
210 | 
211 |     fn horizontal_stretch_sum(&self, node: Self::Item) -> f32 {
212 |         self.layout(&node, |l| l.horizontal_stretch_sum)
213 |     }
214 |     fn set_horizontal_stretch_sum(&mut self, node: Self::Item, value: f32) {
215 |         self.layout_mut(&node, |l| l.horizontal_stretch_sum = value)
216 |     }
217 |     fn vertical_stretch_sum(&self, node: Self::Item) -> f32 {
218 |         self.layout(&node, |l| l.vertical_stretch_sum)
219 |     }
220 |     fn set_vertical_stretch_sum(&mut self, node: Self::Item, value: f32) {
221 |         self.layout_mut(&node, |l| l.vertical_stretch_sum = value)
222 |     }
223 | 
224 |     fn set_width(&mut self, node: Self::Item, value: f32) {
225 |         self.layout_mut(&node, |l| l.width = value)
226 |     }
227 |     fn set_height(&mut self, node: Self::Item, value: f32) {
228 |         self.layout_mut(&node, |l| l.height = value)
229 |     }
230 |     fn set_posx(&mut self, node: Self::Item, value: f32) {
231 |         self.layout_mut(&node, |l| l.posx = value)
232 |     }
233 |     fn set_posy(&mut self, node: Self::Item, value: f32) {
234 |         self.layout_mut(&node, |l| l.posy = value)
235 |     }
236 | 
237 |     fn set_left(&mut self, node: Self::Item, value: f32) {
238 |         self.layout_mut(&node, |l| l.left = value)
239 |     }
240 |     fn set_right(&mut self, node: Self::Item, value: f32) {
241 |         self.layout_mut(&node, |l| l.right = value)
242 |     }
243 |     fn set_top(&mut self, node: Self::Item, value: f32) {
244 |         self.layout_mut(&node, |l| l.top = value)
245 |     }
246 |     fn set_bottom(&mut self, node: Self::Item, value: f32) {
247 |         self.layout_mut(&node, |l| l.bottom = value)
248 |     }
249 | 
250 |     fn set_new_width(&mut self, node: Self::Item, value: f32) {
251 |         self.layout_mut(&node, |l| l.new_width = value)
252 |     }
253 |     fn set_new_height(&mut self, node: Self::Item, value: f32) {
254 |         self.layout_mut(&node, |l| l.new_height = value)
255 |     }
256 | 
257 |     fn stack_first_child(&self, node: Self::Item) -> bool {
258 |         self.layout(&node, |l| l.stack_first_child)
259 |     }
260 |     fn set_stack_first_child(&mut self, node: Self::Item, value: bool) {
261 |         self.layout_mut(&node, |l| l.stack_first_child = value)
262 |     }
263 |     fn stack_last_child(&self, node: Self::Item) -> bool {
264 |         self.layout(&node, |l| l.stack_last_child)
265 |     }
266 |     fn set_stack_last_child(&mut self, node: Self::Item, value: bool) {
267 |         self.layout_mut(&node, |l| l.stack_last_child = value)
268 |     }
269 | }
270 | 
271 | #[derive(Debug, Clone, Copy)]
272 | pub struct WidgetId {
273 |     unique_id: usize,
274 | }
275 | 
276 | impl WidgetId {
277 |     pub fn from(unique_id: usize) -> Self {
278 |         Self { unique_id }
279 |     }
280 | 
281 |     pub fn unique_id(&self) -> usize {
282 |         self.unique_id
283 |     }
284 | }
285 | 
286 | #[derive(Clone)]
287 | pub struct LayoutTree {
288 |     pub dpi_factor: f32,
289 |     pub store: Rc<RefCell<WidgetStore>>,
290 | }
291 | 
292 | macro_rules! get_size {
293 |     ($self: ident, $tree: ident, $field: ident) => {
294 |         match $tree.store.borrow().with_layout($self, |l| l.$field) {
295 |             Some(Units::Pixels(px)) => Some(Units::Pixels(px * $tree.dpi_factor)),
296 |             u => u,
297 |         }
298 |     };
299 | }
300 | 
301 | impl Node<'_> for WidgetId {
302 |     type Data = LayoutTree;
303 | 
304 |     fn layout_type(&self, tree: &'_ Self::Data) -> Option<LayoutType> {
305 |         tree.store.borrow().with_layout(self, |l| l.layout_type)
306 |     }
307 | 
308 |     fn position_type(&self, tree: &'_ Self::Data) -> Option<PositionType> {
309 |         tree.store.borrow().with_layout(self, |l| l.position_type)
310 |     }
311 | 
312 |     fn width(&self, tree: &'_ Self::Data) -> Option<Units> {
313 |         get_size!(self, tree, width)
314 |     }
315 | 
316 |     fn height(&self, tree: &'_ Self::Data) -> Option<Units> {
317 |         get_size!(self, tree, height)
318 |     }
319 | 
320 |     fn min_width(&self, tree: &'_ Self::Data) -> Option<Units> {
321 |         get_size!(self, tree, min_width)
322 |     }
323 | 
324 |     fn min_height(&self, tree: &'_ Self::Data) -> Option<Units> {
325 |         get_size!(self, tree, min_height)
326 |     }
327 | 
328 |     fn max_width(&self, tree: &'_ Self::Data) -> Option<Units> {
329 |         get_size!(self, tree, max_width)
330 |     }
331 | 
332 |     fn max_height(&self, tree: &'_ Self::Data) -> Option<Units> {
333 |         get_size!(self, tree, max_height)
334 |     }
335 | 
336 |     fn left(&self, tree: &'_ Self::Data) -> Option<Units> {
337 |         get_size!(self, tree, left)
338 |     }
339 | 
340 |     fn right(&self, tree: &'_ Self::Data) -> Option<Units> {
341 |         get_size!(self, tree, right)
342 |     }
343 | 
344 |     fn top(&self, tree: &'_ Self::Data) -> Option<Units> {
345 |         get_size!(self, tree, top)
346 |     }
347 | 
348 |     fn bottom(&self, tree: &'_ Self::Data) -> Option<Units> {
349 |         get_size!(self, tree, bottom)
350 |     }
351 | 
352 |     fn min_left(&self, tree: &'_ Self::Data) -> Option<Units> {
353 |         get_size!(self, tree, min_left)
354 |     }
355 | 
356 |     fn max_left(&self, tree: &'_ Self::Data) -> Option<Units> {
357 |         get_size!(self, tree, max_left)
358 |     }
359 | 
360 |     fn min_right(&self, tree: &'_ Self::Data) -> Option<Units> {
361 |         get_size!(self, tree, min_right)
362 |     }
363 | 
364 |     fn max_right(&self, tree: &'_ Self::Data) -> Option<Units> {
365 |         get_size!(self, tree, max_right)
366 |     }
367 | 
368 |     fn min_top(&self, tree: &'_ Self::Data) -> Option<Units> {
369 |         get_size!(self, tree, min_top)
370 |     }
371 | 
372 |     fn max_top(&self, tree: &'_ Self::Data) -> Option<Units> {
373 |         get_size!(self, tree, max_top)
374 |     }
375 | 
376 |     fn min_bottom(&self, tree: &'_ Self::Data) -> Option<Units> {
377 |         get_size!(self, tree, min_bottom)
378 |     }
379 | 
380 |     fn max_bottom(&self, tree: &'_ Self::Data) -> Option<Units> {
381 |         get_size!(self, tree, max_bottom)
382 |     }
383 | 
384 |     fn child_left(&self, tree: &'_ Self::Data) -> Option<Units> {
385 |         get_size!(self, tree, child_left)
386 |     }
387 | 
388 |     fn child_right(&self, tree: &'_ Self::Data) -> Option<Units> {
389 |         get_size!(self, tree, child_right)
390 |     }
391 | 
392 |     fn child_top(&self, tree: &'_ Self::Data) -> Option<Units> {
393 |         get_size!(self, tree, child_top)
394 |     }
395 | 
396 |     fn child_bottom(&self, tree: &'_ Self::Data) -> Option<Units> {
397 |         get_size!(self, tree, child_bottom)
398 |     }
399 | 
400 |     fn row_between(&self, tree: &'_ Self::Data) -> Option<Units> {
401 |         get_size!(self, tree, row_between)
402 |     }
403 | 
404 |     fn col_between(&self, tree: &'_ Self::Data) -> Option<Units> {
405 |         get_size!(self, tree, col_between)
406 |     }
407 | 
408 |     fn grid_rows(&self, tree: &'_ Self::Data) -> Option<Vec<Units>> {
409 |         tree.store.borrow().with_layout(self, |l| l.grid_rows.clone())
410 |     }
411 | 
412 |     fn grid_cols(&self, tree: &'_ Self::Data) -> Option<Vec<Units>> {
413 |         tree.store.borrow().with_layout(self, |l| l.grid_cols.clone())
414 |     }
415 | 
416 |     fn row_index(&self, tree: &'_ Self::Data) -> Option<usize> {
417 |         tree.store.borrow().with_layout(self, |l| l.row_index)
418 |     }
419 | 
420 |     fn col_index(&self, tree: &'_ Self::Data) -> Option<usize> {
421 |         tree.store.borrow().with_layout(self, |l| l.col_index)
422 |     }
423 |     fn row_span(&self, tree: &'_ Self::Data) -> Option<usize> {
424 |         tree.store.borrow().with_layout(self, |l| l.row_span)
425 |     }
426 |     fn col_span(&self, tree: &'_ Self::Data) -> Option<usize> {
427 |         tree.store.borrow().with_layout(self, |l| l.col_span)
428 |     }
429 |     fn border_left(&self, tree: &'_ Self::Data) -> Option<Units> {
430 |         let w = tree.store.borrow().get(self.unique_id)?;
431 |         let style = w.style();
432 |         if w.has_default_style() {
433 |             Some(Units::Pixels(tree.dpi_factor * (style.border + style.pad_left)))
434 |         } else {
435 |             Some(Units::Pixels(tree.dpi_factor * style.pad_left))
436 |         }
437 |     }
438 |     fn border_right(&self, tree: &'_ Self::Data) -> Option<Units> {
439 |         let w = tree.store.borrow().get(self.unique_id)?;
440 |         let style = w.style();
441 |         if w.has_default_style() {
442 |             Some(Units::Pixels(tree.dpi_factor * (style.border + style.pad_right)))
443 |         } else {
444 |             Some(Units::Pixels(tree.dpi_factor * style.pad_right))
445 |         }
446 |     }
447 |     fn border_top(&self, tree: &'_ Self::Data) -> Option<Units> {
448 |         let w = tree.store.borrow().get(self.unique_id)?;
449 |         let style = w.style();
450 |         if w.has_default_style() {
451 |             Some(Units::Pixels(tree.dpi_factor * (style.border + style.pad_top)))
452 |         } else {
453 |             Some(Units::Pixels(tree.dpi_factor * style.pad_top))
454 |         }
455 |     }
456 |     fn border_bottom(&self, tree: &'_ Self::Data) -> Option<Units> {
457 |         let w = tree.store.borrow().get(self.unique_id)?;
458 |         let style = w.style();
459 |         if w.has_default_style() {
460 |             Some(Units::Pixels(tree.dpi_factor * (style.border + style.pad_bottom)))
461 |         } else {
462 |             Some(Units::Pixels(tree.dpi_factor * style.pad_bottom))
463 |         }
464 |     }
465 | }
466 | 


--------------------------------------------------------------------------------
/src/markdown.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoTK. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use pulldown_cmark::{Event, HeadingLevel, CodeBlockKind, Options, Parser, Tag};
  6 | 
  7 | pub struct MarkdownWichtextGenerator {
  8 |     header_color_font_size: Vec<(u8, u8)>,
  9 |     block_width: u16,
 10 |     text_lines: Vec<String>,
 11 | }
 12 | 
 13 | fn escape(s: &str) -> String {
 14 |     s.replace("[", "[[").replace("]", "]]")
 15 | }
 16 | 
 17 | const CODE_COLOR_IDX: u8 = 15;
 18 | const LINK_COLOR_IDX: u8 = 8;
 19 | const STRONG_COLOR_IDX: u8 = 4;
 20 | const EMPHASIS_COLOR_IDX: u8 = 2;
 21 | const STRIKE_COLOR_IDX: u8 = 11;
 22 | const LIST_MARK_COLOR_IDX: u8 = 17;
 23 | 
 24 | struct Style {
 25 |     add_fmt: Option<String>,
 26 |     color: Option<u8>,
 27 |     size: Option<u8>,
 28 |     raw: bool,
 29 |     code: bool,
 30 | }
 31 | 
 32 | impl Style {
 33 |     pub fn new() -> Self {
 34 |         Self { add_fmt: None, color: None, size: None, raw: false, code: false }
 35 |     }
 36 | 
 37 |     pub fn with_list_mark(&self) -> Self {
 38 |         Self {
 39 |             add_fmt: self.add_fmt.clone(),
 40 |             color: Some(LIST_MARK_COLOR_IDX),
 41 |             size: self.size,
 42 |             raw: self.raw,
 43 |             code: false,
 44 |         }
 45 |     }
 46 | 
 47 |     pub fn with_strong(&self) -> Self {
 48 |         Self {
 49 |             add_fmt: self.add_fmt.clone(),
 50 |             color: Some(STRONG_COLOR_IDX),
 51 |             size: self.size,
 52 |             raw: self.raw,
 53 |             code: false,
 54 |         }
 55 |     }
 56 | 
 57 |     pub fn with_emphasis(&self) -> Self {
 58 |         Self {
 59 |             add_fmt: self.add_fmt.clone(),
 60 |             color: Some(EMPHASIS_COLOR_IDX),
 61 |             size: self.size,
 62 |             raw: self.raw,
 63 |             code: false,
 64 |         }
 65 |     }
 66 | 
 67 |     pub fn with_strike(&self) -> Self {
 68 |         Self {
 69 |             add_fmt: self.add_fmt.clone(),
 70 |             color: Some(STRIKE_COLOR_IDX),
 71 |             size: self.size,
 72 |             raw: self.raw,
 73 |             code: false,
 74 |         }
 75 |     }
 76 | 
 77 |     pub fn with_raw_code(&self) -> Self {
 78 |         Self {
 79 |             add_fmt: None,
 80 |             color: None,
 81 |             size: None,
 82 |             raw: true,
 83 |             code: true,
 84 |         }
 85 |     }
 86 | 
 87 |     pub fn with_code(&self) -> Self {
 88 |         Self {
 89 |             add_fmt: self.add_fmt.clone(),
 90 |             color: Some(CODE_COLOR_IDX),
 91 |             size: self.size,
 92 |             raw: self.raw,
 93 |             code: true,
 94 |         }
 95 |     }
 96 | 
 97 |     pub fn with_link(&self, lref: &str) -> Self {
 98 |         if lref.starts_with("$") {
 99 |             Self {
100 |                 add_fmt: Some(lref.trim_start_matches('$').to_string()),
101 |                 color: None,
102 |                 size: None,
103 |                 raw: false,
104 |                 code: false,
105 |             }
106 | 
107 |         } else {
108 |             let mut add_fmt =
109 |                 if let Some(add_fmt) = &self.add_fmt { add_fmt.to_string() } else { String::new() };
110 |             add_fmt += "a";
111 |             Self {
112 |                 add_fmt: Some(add_fmt),
113 |                 color: Some(LINK_COLOR_IDX),
114 |                 size: self.size,
115 |                 raw: lref == "$",
116 |                 code: false,
117 |             }
118 |         }
119 |     }
120 | 
121 |     pub fn with_heading_level(&self, hl: HeadingLevel, heading_styles: &[(u8, u8)]) -> Self {
122 |         let index = match hl {
123 |             HeadingLevel::H1 => 0,
124 |             HeadingLevel::H2 => 1,
125 |             HeadingLevel::H3 => 2,
126 |             HeadingLevel::H4 => 3,
127 |             HeadingLevel::H5 => 4,
128 |             HeadingLevel::H6 => 5,
129 |         };
130 | 
131 |         let size_idx = index.min(heading_styles.len() - 1);
132 |         let (color, size) = heading_styles[size_idx];
133 | 
134 |         Self {
135 |             add_fmt: self.add_fmt.clone(),
136 |             color: Some(color),
137 |             size: Some(size),
138 |             raw: self.raw,
139 |             code: false,
140 |         }
141 |     }
142 | 
143 |     pub fn in_code(&self) -> bool {
144 |         self.code
145 |     }
146 | 
147 |     pub fn fmt_word(&self, word: &str) -> String {
148 |         if self.raw {
149 |             return word.to_string();
150 |         }
151 |         if word.is_empty() {
152 |             return String::new();
153 |         }
154 | 
155 |         let mut fmt = String::new();
156 | 
157 |         if let Some(size) = self.size {
158 |             fmt += &format!("f{}", size);
159 |         }
160 |         if let Some(color) = self.color {
161 |             fmt += &format!("c{}", color);
162 |         }
163 |         if let Some(add_fmt) = &self.add_fmt {
164 |             fmt += add_fmt;
165 |         }
166 | 
167 |         let word = escape(word);
168 |         if fmt.len() > 0 {
169 |             format!("[{}:{}]", fmt, word)
170 |         } else {
171 |             word
172 |         }
173 |     }
174 | }
175 | 
176 | fn indent_str(indent: u16) -> String {
177 |     let mut indent_s = String::new();
178 |     for _ in 0..indent {
179 |         indent_s += " ";
180 |     }
181 |     indent_s
182 | }
183 | 
184 | struct BlockLayout {
185 |     indent: u16,
186 |     indent_stack: Vec<u16>,
187 |     width: usize,
188 |     cur_line: String,
189 |     cur_line_w: usize,
190 | }
191 | 
192 | impl BlockLayout {
193 |     pub fn new(width: usize) -> Self {
194 |         Self {
195 |             indent: 0,
196 |             indent_stack: vec![],
197 |             width,
198 |             cur_line: String::new(),
199 |             cur_line_w: 0,
200 |         }
201 |     }
202 | 
203 |     pub fn push_indent(&mut self, inc: u16) {
204 |         self.indent_stack.push(self.indent);
205 |         self.indent += inc;
206 |     }
207 | 
208 |     pub fn pop_indent(&mut self) {
209 |         self.indent = self.indent_stack.pop().unwrap_or(0);
210 |     }
211 | 
212 |     pub fn indent(&self) -> u16 { self.indent }
213 | 
214 |     pub fn force_space(&mut self) {
215 |         self.cur_line += " ";
216 |         self.cur_line_w += 1;
217 |     }
218 | 
219 |     pub fn ensure_space(&mut self) {
220 |         if self.cur_line_w > 0 {
221 |             if self.cur_line.chars().last().unwrap_or('_') != ' ' {
222 |                 self.cur_line += " ";
223 |                 self.cur_line_w += 1;
224 |             }
225 |         }
226 |     }
227 | 
228 |     pub fn add_words_from_string(&mut self, s: &str, style: &Style, out_lines: &mut Vec<String>) {
229 |         let indent_s = indent_str(self.indent);
230 | 
231 |         if self.cur_line.is_empty() {
232 |             self.cur_line = indent_s.clone();
233 |             self.cur_line_w = indent_s.len();
234 |         }
235 | 
236 |         if style.in_code() {
237 |             self.cur_line += &style.fmt_word(s.trim_end());
238 |             self.cur_line_w = self.cur_line.len();
239 |             return;
240 |         }
241 | 
242 |         let words: Vec<&str> = s.split(" ").collect();
243 | 
244 |         let mut started_block = true;
245 | 
246 |         for word in words.iter() {
247 |             let word = word.trim();
248 | 
249 |             if self.cur_line_w > 0
250 |                && (self.cur_line_w + word.len()) > self.width.into()
251 |             {
252 |                 out_lines.push(self.cur_line.clone());
253 |                 self.cur_line = indent_s.clone();
254 |                 self.cur_line_w = indent_s.len();
255 |             }
256 | 
257 |             if !started_block && self.cur_line.find(|c| !char::is_whitespace(c)).is_some() {
258 |                 self.cur_line += " ";
259 |                 self.cur_line_w += 1;
260 |             }
261 | 
262 |             self.cur_line += &style.fmt_word(word);
263 |             self.cur_line_w += word.len();
264 | 
265 |             started_block = false;
266 |         }
267 |     }
268 | 
269 |     pub fn flush(&mut self, out_lines: &mut Vec<String>) {
270 |         if self.cur_line_w > 0 {
271 |             out_lines.push(self.cur_line.clone());
272 |             self.cur_line = String::new();
273 |             self.cur_line_w = 0;
274 |         }
275 |     }
276 | }
277 | 
278 | impl MarkdownWichtextGenerator {
279 |     pub fn new(bw: u16) -> Self {
280 |         Self {
281 |             header_color_font_size: vec![(15, 22), (11, 21), (7, 20), (17, 19)],
282 |             block_width: bw,
283 |             text_lines: vec![],
284 |         }
285 |     }
286 | 
287 |     fn ensure_empty_line(&mut self) {
288 |         let prev_empty = if let Some(l) = self.text_lines.last() { l.is_empty() } else { true };
289 |         if !prev_empty {
290 |             self.text_lines.push(String::new());
291 |         }
292 |     }
293 | 
294 |     pub fn parse(&mut self, txt: &str) {
295 |         let mut options = Options::empty();
296 |         options.insert(Options::ENABLE_STRIKETHROUGH);
297 |         let parser = Parser::new_ext(txt, options);
298 | 
299 |         let mut layout = BlockLayout::new(self.block_width.into());
300 | 
301 |         let mut style_stack = vec![Style::new()];
302 | 
303 |         let mut list_stack = vec![];
304 |         let mut current_list_index = None;
305 | 
306 |         for ev in parser {
307 |             //d// println!("EVENT: {:?}", ev);
308 | 
309 |             match ev {
310 |                 Event::Rule => {
311 |                     let indent_s = indent_str(layout.indent);
312 |                     let mut dashes = String::from("[c11:");
313 |                     for _ in 0..self.block_width {
314 |                         dashes += "-";
315 |                     }
316 |                     dashes += "]";
317 |                     self.ensure_empty_line();
318 |                     self.text_lines.push(indent_s + &dashes);
319 |                 }
320 |                 Event::Start(tag) => match tag {
321 |                     Tag::List(start) => {
322 |                         list_stack.push(current_list_index);
323 |                         current_list_index = start;
324 |                         layout.flush(&mut self.text_lines);
325 |                     }
326 |                     Tag::Item => {
327 |                         layout.flush(&mut self.text_lines);
328 |                         let item = if let Some(index) = &mut current_list_index {
329 |                             *index += 1;
330 |                             format!("{}", *index - 1)
331 |                         } else {
332 |                             "*".to_string()
333 |                         };
334 |                         layout.add_words_from_string(
335 |                             &item,
336 |                             &style_stack.last().unwrap().with_list_mark(),
337 |                             &mut self.text_lines,
338 |                         );
339 |                         layout.force_space();
340 |                         layout.push_indent(2);
341 |                     }
342 |                     Tag::Image(_, lref, _) => {
343 |                         let v: Vec<&str> = lref.split("?").collect();
344 |                         self.text_lines.push(
345 |                             format!(
346 |                                 "[h{}I{}:]",
347 |                                 v.get(1).unwrap_or(&"300"),
348 |                                 v.get(0).unwrap_or(&"broken.png")));
349 |                     }
350 |                     Tag::Link(_, lref, _) => {
351 |                         style_stack.push(style_stack.last().unwrap().with_link(&lref));
352 |                     }
353 |                     Tag::CodeBlock(code_type) => {
354 |                         layout.flush(&mut self.text_lines);
355 |                         self.ensure_empty_line();
356 | 
357 |                         match code_type {
358 |                             CodeBlockKind::Fenced(lang) => {
359 |                                 if &*lang == "wichtext" {
360 |                                     style_stack.push(style_stack.last().unwrap().with_raw_code());
361 |                                 } else {
362 |                                     style_stack.push(style_stack.last().unwrap().with_code());
363 |                                 }
364 |                                 layout.push_indent(0);
365 |                             },
366 |                             CodeBlockKind::Indented => {
367 |                                 style_stack.push(style_stack.last().unwrap().with_code());
368 |                                 layout.push_indent(4);
369 |                             },
370 |                         }
371 |                     }
372 |                     Tag::Heading(hl, _, _) => {
373 |                         layout.flush(&mut self.text_lines);
374 |                         self.ensure_empty_line();
375 | 
376 |                         style_stack.push(
377 |                             style_stack
378 |                                 .last()
379 |                                 .unwrap()
380 |                                 .with_heading_level(hl, &self.header_color_font_size),
381 |                         );
382 |                     }
383 |                     Tag::Strong => {
384 |                         style_stack.push(style_stack.last().unwrap().with_strong());
385 |                     }
386 |                     Tag::Emphasis => {
387 |                         style_stack.push(style_stack.last().unwrap().with_emphasis());
388 |                     }
389 |                     Tag::Strikethrough => {
390 |                         style_stack.push(style_stack.last().unwrap().with_strike());
391 |                     }
392 |                     _ => {}
393 |                 },
394 |                 Event::End(tag) => match tag {
395 |                     Tag::CodeBlock(_) => {
396 |                         style_stack.pop();
397 |                         layout.flush(&mut self.text_lines);
398 |                         layout.pop_indent();
399 |                         self.ensure_empty_line();
400 |                     }
401 |                     Tag::List(_) => {
402 |                         current_list_index = list_stack.pop().flatten();
403 |                         if layout.indent() == 0 {
404 |                             self.ensure_empty_line();
405 |                         }
406 |                     }
407 |                     Tag::Image(_, _, _) => {}
408 |                     Tag::Link(_, _, _) => {
409 |                         style_stack.pop();
410 |                     }
411 |                     Tag::Item => {
412 |                         layout.flush(&mut self.text_lines);
413 |                         layout.pop_indent();
414 |                     }
415 |                     Tag::Heading(_, _, _) => {
416 |                         style_stack.pop();
417 |                         layout.flush(&mut self.text_lines);
418 |                         self.ensure_empty_line();
419 |                     }
420 |                     Tag::Paragraph => {
421 |                         layout.flush(&mut self.text_lines);
422 |                         self.ensure_empty_line();
423 |                     }
424 |                     Tag::Strong => {
425 |                         style_stack.pop();
426 |                     }
427 |                     Tag::Emphasis => {
428 |                         style_stack.pop();
429 |                     }
430 |                     Tag::Strikethrough => {
431 |                         style_stack.pop();
432 |                     }
433 |                     _ => {}
434 |                 },
435 |                 Event::Code(s) => {
436 |                     style_stack.push(style_stack.last().unwrap().with_code());
437 |                     layout.add_words_from_string(
438 |                         &s,
439 |                         style_stack.last().unwrap(),
440 |                         &mut self.text_lines,
441 |                     );
442 |                     style_stack.pop();
443 |                 }
444 |                 Event::Text(s) => {
445 |                     layout.add_words_from_string(
446 |                         &s,
447 |                         style_stack.last().unwrap(),
448 |                         &mut self.text_lines,
449 |                     );
450 |                     if style_stack.last().unwrap().in_code() {
451 |                         layout.flush(&mut self.text_lines);
452 |                     }
453 |                 }
454 |                 Event::HardBreak => {
455 |                     layout.flush(&mut self.text_lines);
456 |                 }
457 |                 Event::SoftBreak => {
458 |                     layout.ensure_space();
459 |                 }
460 |                 _ => {}
461 |             }
462 |         }
463 |     }
464 | 
465 |     pub fn to_string(&self) -> String {
466 |         self.text_lines.join("\n")
467 |     }
468 | }
469 | 
470 | #[cfg(test)]
471 | mod tests {
472 |     use super::*;
473 | 
474 |     #[test]
475 |     fn check_mkd2wt_1() {
476 |         let mut mwg = MarkdownWichtextGenerator::new(20);
477 |         let text = r#"
478 | 
479 | 
480 | fpoiewj fewoifj ewoifeowj 
481 | f weiofj eiwoofj wejfwe
482 | feiowjfeiowfeiowfwiofew
483 | 
484 | ===================
485 | 
486 | feiofj wiofjwowe
487 | f weoifewj ioewj fweo feiwjfewoi
488 | 
489 | -------
490 | 
491 | Test
492 | ====
493 | 
494 | ## Test 123 *foobar* __LOL__ ´323423423´
495 | 
496 | AAA `cccc` DDDD
497 | 
498 | -------
499 | 
500 | BBBBB
501 | 
502 | ### And here: [Foobar]()
503 | 
504 | Test 123 fiuowe fieuwf hewuif hewiuf weiuf hweifu wehfi uwehf iweufh ewiuf hweiuf weiuf weiuf
505 | Test 123 fiuowe fieuwf hewuif hewiuf weiuf hweifu wehfi uwehf iweufh ewiuf hweiuf weiuf weiuf
506 | Test 123 _fiuowe fieuwf hewuif hewiuf_ weiuf hweifu wehfi uwehf iweufh ewiuf hweiuf weiuf weiuf
507 | Test 123 fiuowe fieuwf hewuif hewiuf weiuf hweifu wehfi uwehf iweufh ewiuf hweiuf weiuf weiuf
508 | Test 123 fiuowe fieuwf hewuif hewiuf weiuf hweifu wehfi uwehf iweufh ewiuf hweiuf weiuf weiuf
509 | 
510 | 1. List Itmee 1
511 | 2. List Item 2
512 | 2. List Item
513 | foieuwj fewo fejwiof ewjfioe wiofj weoif iofwe
514 | foieuwj fewo fejwiof ewjfioe wiofj weoif iofwe
515 | foieuwj fewo fejwiof ewjfioe wiofj weoif iofwe
516 | foieuwj fewo fejwiof ewjfioe wiofj weoif iofwe
517 |     ```text
518 |     Test 123 892u 923u 2389r 2389rj 98ew
519 |     Test 123 892u 923u 2389r 2389rj 98ew
520 |     Test 123 892u 923u 2389r 2389rj 98ew
521 |     ```
522 | 3. Foobar lololol
523 |   * Item A
524 |   * Item B
525 |   * Item C
526 |   * Item D
527 | 
528 | Intdent start:
529 | 
530 |     fiif ewoif ejwoifw joiwej foiwef jeowiefwoi fjiowe
531 |     fiif ewoif ejwoifw joiwej foiwef jeowiefwoi fjiowe
532 |     fiif ewoif ejwoifw joiwej foiwef jeowiefwoi fjiowe
533 |     fiif ewoif ejwoifw joiwej foiwef jeowiefwoi fjiowe
534 |     fiif ewoif ejwoifw joiwej foiwef jeowiefwoi fjiowe
535 | 
536 | eindent end
537 | 
538 | ---------------------------------------
539 | ```
540 | COde blcapfcelfw
541 | feiow fewf
542 | ```
543 | - Other A
544 | - Other B
545 | - Other C
546 | - Other D
547 | - Other E
548 | 
549 | > ## Bla bla
550 | > feoiwfjew ofew
551 | > feoiwfjew ofew
552 | > feoiwfjew ofew
553 | > feoiwfjew ofew
554 | 
555 | [[c15f30:Foobar] Lol]($)
556 | 
557 | Image here: ![](main/bla.png)
558 | 
559 | **Strong text here lo lof efew jofiewj oiewfjoi we**
560 | 
561 | *Emphasis text hefew ewfhweiu fhweiu hewiuf ewiufhew*
562 | 
563 | ~~Strike~~
564 |         "#;
565 |         //        for block in tree.iter() {
566 |         //            mwg.append_block(block, 0);
567 |         //        }
568 |         mwg.parse(text);
569 |         println!("RES:\n{}", mwg.to_string());
570 |     }
571 | 
572 |     #[test]
573 |     fn check_mkd2wt_para() {
574 |         let mut mwg = MarkdownWichtextGenerator::new(50);
575 |         mwg.parse("A\n\nC\n");
576 |         assert_eq!(mwg.to_string(), "A\n\nC\n");
577 |     }
578 | 
579 |     #[test]
580 |     fn check_mkd2wt_lists() {
581 |         let mut mwg = MarkdownWichtextGenerator::new(50);
582 |         mwg.parse("- A\n  - B\n- C\n");
583 |         println!("RES:\n{}", mwg.to_string());
584 |         assert_eq!(mwg.to_string(), "[c17:*] A\n  [c17:*] B\n[c17:*] C\n");
585 | 
586 |         let mut mwg = MarkdownWichtextGenerator::new(50);
587 |         mwg.parse("- A\n  - B\n\n- C\n");
588 |         println!("RES:\n{}", mwg.to_string());
589 |         assert_eq!(mwg.to_string(), "[c17:*] A\n\n  [c17:*] B\n[c17:*] C\n");
590 |     }
591 | 
592 |     #[test]
593 |     fn check_mkd2wt_emph() {
594 |         let mut mwg = MarkdownWichtextGenerator::new(50);
595 |         mwg.parse("A*B*C");
596 |         println!("RES:\n{}", mwg.to_string());
597 |         assert_eq!(mwg.to_string(), "A[c2:B]C\n");
598 | 
599 |         let mut mwg = MarkdownWichtextGenerator::new(50);
600 |         mwg.parse("A<B@fo.de>C");
601 |         println!("RES:\n{}", mwg.to_string());
602 |         assert_eq!(mwg.to_string(), "A[c8a:B@fo.de]C\n");
603 | 
604 |         let mut mwg = MarkdownWichtextGenerator::new(50);
605 |         mwg.parse("A <B@fo.de> C");
606 |         println!("RES:\n{}", mwg.to_string());
607 |         assert_eq!(mwg.to_string(), "A [c8a:B@fo.de] C\n");
608 |     }
609 | 
610 |     #[test]
611 |     fn check_mkd2wt_softbreaks() {
612 |         let mut mwg = MarkdownWichtextGenerator::new(10);
613 |         mwg.parse("soft breaks\nsoft\nbreaks\nsoft\nbreaks");
614 |         println!("RES:\n{}", mwg.to_string());
615 |         assert_eq!(mwg.to_string(), "soft breaks \nsoft \nbreaks \nsoft \nbreaks\n");
616 |     }
617 | 
618 |     #[test]
619 |     fn check_mkd2wt_code() {
620 |         let mut mwg = MarkdownWichtextGenerator::new(10);
621 |         mwg.parse("a\n\n    soft\n      fo\n\nb");
622 |         println!("RES:\n{}", mwg.to_string());
623 |         assert_eq!(mwg.to_string(), "a\n\n    [c15:soft]\n    [c15:  fo]\n\nb\n");
624 |     }
625 | 
626 |     #[test]
627 |     fn check_mkd2wt_inline_wt() {
628 |         let mut mwg = MarkdownWichtextGenerator::new(10);
629 |         mwg.parse("[Test 123 feio fejwoif jewfo iewjfo iewjf weoi]($c19)");
630 |         println!("RES:\n{}", mwg.to_string());
631 |         assert_eq!(mwg.to_string(),  "[c19:Test] [c19:123]\n[c19:feio]\n[c19:fejwoif]\n[c19:jewfo]\n[c19:iewjfo]\n[c19:iewjf] [c19:weoi]\n");
632 |     }
633 | 
634 |     #[test]
635 |     fn check_mkd2wt_inline_raw_wt() {
636 |         let mut mwg = MarkdownWichtextGenerator::new(10);
637 |         mwg.parse("```wichtext\n    [c19:Test fei fjewoif jweofiew joifewwe]\n    fioewfijoiwefjewifwe\n```");
638 |         println!("RES:\n{}", mwg.to_string());
639 |         assert_eq!(mwg.to_string(), "    [c19:Test fei fjewoif jweofiew joifewwe]\n    fioewfijoiwefjewifwe\n");
640 |     }
641 | 
642 |     #[test]
643 |     fn check_mkd2wt_force_break() {
644 |         let mut mwg = MarkdownWichtextGenerator::new(10);
645 |         mwg.parse("bla  \nblo");
646 |         println!("RES:\n{}", mwg.to_string());
647 |         assert_eq!(mwg.to_string(), "bla\nblo\n");
648 |     }
649 | 
650 |     #[test]
651 |     fn check_mkd2wt_image() {
652 |         let mut mwg = MarkdownWichtextGenerator::new(10);
653 |         mwg.parse("![](node.png)");
654 |         assert_eq!(mwg.to_string(), "[h300Inode.png:]\n");
655 | 
656 |         let mut mwg = MarkdownWichtextGenerator::new(10);
657 |         mwg.parse("![](node.png?400)");
658 |         assert_eq!(mwg.to_string(), "[h400Inode.png:]\n");
659 |     }
660 | }
661 | 


--------------------------------------------------------------------------------
/src/painter.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2021-2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoTK. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use super::Rect;
  6 | 
  7 | use std::cell::RefCell;
  8 | use std::rc::Rc;
  9 | 
 10 | use std::collections::HashMap;
 11 | 
 12 | use femtovg::{renderer::OpenGl, Canvas, Color, FontId, ImageFlags, ImageId};
 13 | 
 14 | #[macro_export]
 15 | macro_rules! hxclr {
 16 |     ($i: expr) => {
 17 |         (
 18 |             ($i >> 16 & 0xFF) as f32 / 255.0,
 19 |             ($i >> 8 & 0xFF) as f32 / 255.0,
 20 |             ($i & 0xFF) as f32 / 255.0,
 21 |         )
 22 |     };
 23 | }
 24 | 
 25 | #[allow(unused)]
 26 | pub fn darken_clr(depth: u32, clr: (f32, f32, f32)) -> (f32, f32, f32) {
 27 |     if depth == 0 {
 28 |         return clr;
 29 |     }
 30 |     (
 31 |         (clr.0 * (1.0 / (1.2_f32).powf(depth as f32))).clamp(0.0, 1.0),
 32 |         (clr.1 * (1.0 / (1.2_f32).powf(depth as f32))).clamp(0.0, 1.0),
 33 |         (clr.2 * (1.0 / (1.2_f32).powf(depth as f32))).clamp(0.0, 1.0),
 34 |     )
 35 | }
 36 | 
 37 | #[allow(unused)]
 38 | pub fn lighten_clr(depth: u32, clr: (f32, f32, f32)) -> (f32, f32, f32) {
 39 |     if depth == 0 {
 40 |         return clr;
 41 |     }
 42 |     (
 43 |         (clr.0 * (1.2_f32).powf(depth as f32)).clamp(0.0, 1.0),
 44 |         (clr.1 * (1.2_f32).powf(depth as f32)).clamp(0.0, 1.0),
 45 |         (clr.2 * (1.2_f32).powf(depth as f32)).clamp(0.0, 1.0),
 46 |     )
 47 | }
 48 | 
 49 | //pub fn tpl2clr(clr: (f32, f32, f32)) -> tuix::Color {
 50 | //    tuix::Color::rgb(
 51 | //        (clr.0 * 255.0) as u8,
 52 | //        (clr.1 * 255.0) as u8,
 53 | //        (clr.2 * 255.0) as u8)
 54 | //}
 55 | 
 56 | pub struct ImageStore {
 57 |     // TODO: FREE THESE IMAGES OR WE HAVE A MEMORY LEAK!
 58 |     freed_images: Vec<ImageId>,
 59 | }
 60 | pub struct ImgRef {
 61 |     store: Rc<RefCell<ImageStore>>,
 62 |     image_id: ImageId,
 63 |     w: f32,
 64 |     h: f32,
 65 | }
 66 | 
 67 | impl ImgRef {
 68 |     pub fn w(&self) -> f32 {
 69 |         self.w
 70 |     }
 71 |     pub fn h(&self) -> f32 {
 72 |         self.h
 73 |     }
 74 | }
 75 | 
 76 | impl Drop for ImgRef {
 77 |     fn drop(&mut self) {
 78 |         self.store.borrow_mut().freed_images.push(self.image_id);
 79 |     }
 80 | }
 81 | 
 82 | pub struct PersistPainterData {
 83 |     render_targets: Vec<femtovg::RenderTarget>,
 84 |     store: Rc<RefCell<ImageStore>>,
 85 |     image_files: HashMap<String, ImageId>,
 86 |     image_data: HashMap<String, Vec<u8>>,
 87 | }
 88 | impl PersistPainterData {
 89 |     pub fn new() -> Self {
 90 |         Self {
 91 |             render_targets: vec![],
 92 |             store: Rc::new(RefCell::new(ImageStore { freed_images: vec![] })),
 93 |             image_files: HashMap::new(),
 94 |             image_data: HashMap::new(),
 95 |         }
 96 |     }
 97 | 
 98 |     pub fn preload_image(&mut self, file: &str, data: Vec<u8>) {
 99 |         self.image_data.insert(file.to_string(), data);
100 |     }
101 | 
102 |     pub fn get_image_file(&mut self, file: &str, canvas: &mut Canvas<OpenGl>) -> Option<ImageId> {
103 |         if let Some(image_id) = self.image_files.get(file) {
104 |             Some(*image_id)
105 |         } else {
106 |             let image_data = self.image_data.get(file)?;
107 | 
108 |             match canvas.load_image_mem(&image_data[..], ImageFlags::empty()) {
109 |                 Ok(img_id) => {
110 |                     self.image_files.insert(file.to_string(), img_id);
111 |                     Some(img_id)
112 |                 }
113 |                 Err(e) => {
114 |                     eprintln!("Error loading image: {}", e);
115 |                     None
116 |                 }
117 |             }
118 |         }
119 |     }
120 | 
121 |     pub fn init_render_targets(&mut self, target: femtovg::RenderTarget) {
122 |         self.render_targets.clear();
123 |         self.render_targets.push(target);
124 |     }
125 | 
126 |     pub fn cleanup(&self, canvas: &mut Canvas<OpenGl>) {
127 |         let mut store = self.store.borrow_mut();
128 |         if !store.freed_images.is_empty() {
129 |             for img in store.freed_images.iter() {
130 |                 canvas.delete_image(*img);
131 |                 //d// println!("CLEANUP IMAGE!");
132 |             }
133 | 
134 |             store.freed_images.clear();
135 |         }
136 |     }
137 | }
138 | 
139 | #[derive(Debug, Clone, Copy)]
140 | pub struct LblDebugTag {
141 |     wid_id: usize,
142 |     x: i32,
143 |     y: i32,
144 |     offs_x: f32,
145 |     offs_y: f32,
146 |     source: &'static str,
147 | }
148 | 
149 | impl LblDebugTag {
150 |     pub fn new(wid_id: usize, x: i32, y: i32, source: &'static str) -> Self {
151 |         Self { wid_id, x, y, offs_x: 0.0, offs_y: 0.0, source }
152 |     }
153 | 
154 |     pub fn from_id(wid_id: usize) -> Self {
155 |         Self { wid_id, x: 0, y: 0, offs_x: 0.0, offs_y: 0.0, source: "?" }
156 |     }
157 | 
158 |     pub fn info(&self) -> (usize, &'static str, (i32, i32)) {
159 |         (self.wid_id, self.source, (self.x, self.y))
160 |     }
161 | 
162 |     pub fn set_logic_pos(&mut self, x: i32, y: i32) {
163 |         self.x = x;
164 |         self.y = y;
165 |     }
166 | 
167 |     pub fn set_offs(&mut self, offs: (f32, f32)) {
168 |         self.offs_x = offs.0;
169 |         self.offs_y = offs.1;
170 |     }
171 | 
172 |     pub fn offs_src(&mut self, offs: (f32, f32), src: &'static str) -> &mut Self {
173 |         self.offs_x = offs.0;
174 |         self.offs_y = offs.1;
175 |         self.source = src;
176 |         self
177 |     }
178 | 
179 |     pub fn source(&mut self, src: &'static str) -> &mut Self {
180 |         self.source = src;
181 |         self
182 |     }
183 | }
184 | 
185 | pub struct Painter<'a, 'b> {
186 |     pub canvas: &'a mut Canvas<OpenGl>,
187 |     pub data: &'b mut PersistPainterData,
188 |     pub lbl_collect: Option<Vec<(LblDebugTag, (f32, f32, f32, f32, String))>>,
189 |     pub font: FontId,
190 |     pub font_mono: FontId,
191 |     pub dpi_factor: f32,
192 | }
193 | 
194 | fn color_paint(color: (f32, f32, f32)) -> femtovg::Paint {
195 |     femtovg::Paint::color(Color::rgbf(color.0 as f32, color.1 as f32, color.2 as f32))
196 | }
197 | 
198 | impl<'a, 'b> Painter<'a, 'b> {
199 |     pub fn start_label_collector(&mut self) {
200 |         self.lbl_collect = Some(vec![]);
201 |     }
202 | 
203 |     pub fn needs_labels(&self) -> bool {
204 |         self.lbl_collect.is_some()
205 |     }
206 | 
207 |     pub fn get_label_collection(
208 |         &mut self,
209 |     ) -> Option<Vec<(LblDebugTag, (f32, f32, f32, f32, String))>> {
210 |         self.lbl_collect.take()
211 |     }
212 | 
213 |     pub fn new_image(&mut self, w: f32, h: f32) -> ImgRef {
214 |         let image_id = self
215 |             .canvas
216 |             .create_image_empty(
217 |                 w as usize,
218 |                 h as usize,
219 |                 femtovg::PixelFormat::Rgba8,
220 |                 femtovg::ImageFlags::FLIP_Y,
221 |             )
222 |             .expect("making image buffer");
223 | 
224 |         //d// println!("new_image w={}, h={} id={:?}", w, h, image_id);
225 | 
226 |         ImgRef { store: self.data.store.clone(), w, h, image_id }
227 |     }
228 | 
229 |     pub fn start_image(&mut self, image: &ImgRef) {
230 |         //d// println!("start_image {:?}", image.image_id);
231 |         self.canvas.save();
232 |         self.canvas.set_render_target(femtovg::RenderTarget::Image(image.image_id));
233 |         self.data.render_targets.push(femtovg::RenderTarget::Image(image.image_id));
234 |         self.canvas.clear_rect(
235 |             0,
236 |             0,
237 |             image.w as u32,
238 |             image.h as u32,
239 |             Color::rgbaf(0.0, 0.0, 0.0, 0.0),
240 |         );
241 |     }
242 | 
243 |     pub fn finish_image(&mut self) {
244 |         //d// println!("finish_image");
245 |         self.canvas.flush();
246 |         self.canvas.restore();
247 |         self.data.render_targets.pop();
248 |         if let Some(rt) = self.data.render_targets.last() {
249 |             self.canvas.set_render_target(*rt);
250 |         }
251 |     }
252 | 
253 |     pub fn draw_image(&mut self, image: &ImgRef, screen_x: f32, screen_y: f32) {
254 |         //d// println!("draw_image id={:?} x={}, y={}, w={}, h={}",
255 |         //d//     image.image_id,
256 |         //d//     screen_x,
257 |         //d//     screen_y,
258 |         //d//     image.w,
259 |         //d//     image.h);
260 |         let img_paint = femtovg::Paint::image(
261 |             image.image_id,
262 |             screen_x,
263 |             screen_y,
264 |             image.w as f32,
265 |             image.h as f32,
266 |             0.0,
267 |             1.0,
268 |         );
269 |         let mut path = femtovg::Path::new();
270 |         path.rect(screen_x as f32, screen_y as f32, image.w as f32, image.h as f32);
271 |         self.canvas.fill_path(&mut path, &img_paint);
272 |     }
273 | 
274 |     pub fn draw_image_file(&mut self, file: &str, x: f32, y: f32, _w: f32, h: f32) {
275 |         if let Some(img_id) = self.data.get_image_file(file, self.canvas) {
276 |             if let Ok((imgw, imgh)) = self.canvas.image_size(img_id) {
277 |                 if imgh as f32 > 0.0 && h > 0.0 {
278 |                     let w = (imgw as f32 * h) / imgh as f32;
279 | 
280 |                     let img_paint =
281 |                         femtovg::Paint::image(img_id, x, y, w as f32, h as f32, 0.0, 1.0);
282 |                     let mut path = femtovg::Path::new();
283 |                     path.rect(x, y, w, h);
284 |                     self.canvas.fill_path(&mut path, &img_paint);
285 |                 }
286 |             }
287 |         }
288 |     }
289 | 
290 |     #[allow(unused_variables)]
291 |     fn label_with_font(
292 |         &mut self,
293 |         size: f32,
294 |         align: i8,
295 |         rot: f32,
296 |         color: (f32, f32, f32),
297 |         x: f32,
298 |         y: f32,
299 |         xoi: f32,
300 |         yoi: f32,
301 |         w: f32,
302 |         h: f32,
303 |         text: &str,
304 |         font: FontId,
305 |         dbg: &LblDebugTag,
306 |     ) {
307 |         let mut paint = color_paint(color);
308 |         paint.set_font(&[font]);
309 |         paint.set_font_size(size as f32);
310 |         paint.set_text_baseline(femtovg::Baseline::Middle);
311 |         let x = x.round();
312 | 
313 |         let (x, y) = if rot > 0.0 {
314 |             self.canvas.save();
315 |             let x = x as f32;
316 |             let y = y as f32;
317 |             let wh = (w / 2.0) as f32;
318 |             let hh = (h / 2.0) as f32;
319 | 
320 |             let rot = rot.to_radians() as f32;
321 | 
322 |             self.canvas.translate(x + wh, y + hh);
323 |             self.canvas.rotate(rot);
324 |             self.canvas.translate(xoi as f32, yoi as f32);
325 | 
326 |             (-wh, -hh)
327 |         } else {
328 |             (x, y)
329 |         };
330 | 
331 |         //        let mut p = femtovg::Path::new();
332 |         //        p.rect(x as f32, y as f32, w as f32, h as f32);
333 |         //        self.canvas.stroke_path(&mut p, paint);
334 |         let (rx, ry) = match align {
335 |             -1 => {
336 |                 paint.set_text_align(femtovg::Align::Left);
337 |                 (x as f32, (y + h / 2.0).round() as f32)
338 |             }
339 |             0 => {
340 |                 paint.set_text_align(femtovg::Align::Center);
341 |                 ((x + (w / 2.0)) as f32, (y + h / 2.0).round() as f32)
342 |             }
343 |             _ => {
344 |                 paint.set_text_align(femtovg::Align::Right);
345 |                 ((x + w) as f32, (y + h / 2.0).round() as f32)
346 |             }
347 |         };
348 | 
349 |         let _ = self.canvas.fill_text(rx, ry, text, &paint);
350 | 
351 |         if let Some(collector) = &mut self.lbl_collect {
352 |             if let Ok(metr) = self.canvas.measure_text(rx, ry, text, &paint) {
353 |                 collector.push((
354 |                     *dbg,
355 |                     (
356 |                         rx + dbg.offs_x,
357 |                         ry + dbg.offs_y,
358 |                         metr.width(),
359 |                         metr.height(),
360 |                         text.to_string(),
361 |                     ),
362 |                 ));
363 |             }
364 |         }
365 | 
366 |         //        let mut p = femtovg::Path::new();
367 |         //        let mut paint2 = color_paint((1.0, 1.0, 1.0));
368 |         //        p.rect((x - 1.0) as f32, (y - 1.0) as f32, 2.0, 2.0);
369 |         //        p.rect(((x + 0.5 * w) - 1.0) as f32, ((y + 0.5 * h) - 1.0) as f32, 2.0, 2.0);
370 |         //        self.canvas.stroke_path(&mut p, paint2);
371 | 
372 |         if rot > 0.0 {
373 |             //            self.canvas.translate(-(0.5 * w) as f32, 0.0);
374 |             self.canvas.restore();
375 |         }
376 |     }
377 | }
378 | 
379 | impl<'a, 'b> Painter<'a, 'b> {
380 |     pub fn clip_region(&mut self, x: f32, y: f32, w: f32, h: f32) {
381 |         self.canvas.save();
382 |         self.canvas.scissor(x as f32, y as f32, w as f32, h as f32);
383 |     }
384 | 
385 |     pub fn reset_clip_region(&mut self) {
386 |         self.canvas.reset_scissor();
387 |         self.canvas.restore();
388 |     }
389 | 
390 |     pub fn path_fill_rot(
391 |         &mut self,
392 |         color: (f32, f32, f32),
393 |         rot: f32,
394 |         x: f32,
395 |         y: f32,
396 |         xo: f32,
397 |         yo: f32,
398 |         segments: &mut dyn std::iter::Iterator<Item = (f32, f32)>,
399 |         closed: bool,
400 |     ) {
401 |         self.canvas.save();
402 |         let rot = rot.to_radians();
403 | 
404 |         self.canvas.translate(x as f32, y as f32);
405 |         self.canvas.rotate(rot as f32);
406 |         self.canvas.translate(xo as f32, yo as f32);
407 | 
408 |         self.path_fill(color, segments, closed);
409 | 
410 |         self.canvas.restore();
411 |     }
412 | 
413 |     #[allow(dead_code)]
414 |     pub fn path_stroke_rot(
415 |         &mut self,
416 |         width: f32,
417 |         color: (f32, f32, f32),
418 |         rot: f32,
419 |         x: f32,
420 |         y: f32,
421 |         xo: f32,
422 |         yo: f32,
423 |         segments: &mut dyn std::iter::Iterator<Item = (f32, f32)>,
424 |         closed: bool,
425 |     ) {
426 |         self.canvas.save();
427 |         let rot = rot.to_radians();
428 | 
429 |         self.canvas.translate(x as f32, y as f32);
430 |         self.canvas.rotate(rot as f32);
431 |         self.canvas.translate(xo as f32, yo as f32);
432 | 
433 |         self.path_stroke(width, color, segments, closed);
434 | 
435 |         self.canvas.restore();
436 |     }
437 | 
438 |     pub fn path_fill(
439 |         &mut self,
440 |         color: (f32, f32, f32),
441 |         segments: &mut dyn std::iter::Iterator<Item = (f32, f32)>,
442 |         closed: bool,
443 |     ) {
444 |         let mut p = femtovg::Path::new();
445 |         let paint = color_paint(color);
446 | 
447 |         let mut first = true;
448 |         for s in segments {
449 |             if first {
450 |                 p.move_to(s.0 as f32, s.1 as f32);
451 |                 first = false;
452 |             } else {
453 |                 p.line_to(s.0 as f32, s.1 as f32);
454 |             }
455 |         }
456 | 
457 |         if closed {
458 |             p.close();
459 |         }
460 | 
461 |         self.canvas.fill_path(&mut p, &paint);
462 |     }
463 | 
464 |     pub fn stroke(
465 |         &mut self,
466 |         width: f32,
467 |         color: (f32, f32, f32),
468 |         segments: &[(f32, f32)],
469 |         closed: bool,
470 |     ) {
471 |         self.path_stroke(width, color, &mut segments.iter().copied(), closed);
472 |     }
473 | 
474 |     pub fn path_stroke(
475 |         &mut self,
476 |         width: f32,
477 |         color: (f32, f32, f32),
478 |         segments: &mut dyn std::iter::Iterator<Item = (f32, f32)>,
479 |         closed: bool,
480 |     ) {
481 |         let mut p = femtovg::Path::new();
482 |         let mut paint = color_paint(color);
483 |         paint.set_line_join(femtovg::LineJoin::Round);
484 |         // paint.set_line_cap(femtovg::LineCap::Round);
485 |         paint.set_line_width(width as f32);
486 | 
487 |         let mut first = true;
488 |         for s in segments {
489 |             if first {
490 |                 p.move_to(s.0 as f32, s.1 as f32);
491 |                 first = false;
492 |             } else {
493 |                 p.line_to(s.0 as f32, s.1 as f32);
494 |             }
495 |         }
496 | 
497 |         if closed {
498 |             p.close();
499 |         }
500 | 
501 |         self.canvas.stroke_path(&mut p, &paint);
502 |     }
503 | 
504 |     pub fn arc_stroke(
505 |         &mut self,
506 |         width: f32,
507 |         color: (f32, f32, f32),
508 |         radius: f32,
509 |         from_rad: f32,
510 |         to_rad: f32,
511 |         x: f32,
512 |         y: f32,
513 |     ) {
514 |         let mut p = femtovg::Path::new();
515 |         let mut paint = color_paint(color);
516 |         paint.set_line_width(width as f32);
517 |         p.arc(
518 |             x as f32,
519 |             y as f32,
520 |             radius as f32,
521 |             from_rad as f32,
522 |             to_rad as f32,
523 |             femtovg::Solidity::Hole,
524 |         );
525 |         self.canvas.stroke_path(&mut p, &paint);
526 |     }
527 | 
528 |     pub fn rect_border_fill_r(
529 |         &mut self,
530 |         border: f32,
531 |         color: (f32, f32, f32),
532 |         bg_color: (f32, f32, f32),
533 |         rect: Rect,
534 |     ) {
535 |         self.rect_fill(color, rect.x, rect.y, rect.w, rect.h);
536 |         let rect = rect.shrink(border, border);
537 |         self.rect_fill(bg_color, rect.x, rect.y, rect.w, rect.h);
538 |     }
539 | 
540 |     pub fn rect_fill_r(&mut self, color: (f32, f32, f32), rect: Rect) {
541 |         self.rect_fill(color, rect.x, rect.y, rect.w, rect.h)
542 |     }
543 | 
544 |     pub fn rect_fill(&mut self, color: (f32, f32, f32), x: f32, y: f32, w: f32, h: f32) {
545 |         let mut pth = femtovg::Path::new();
546 |         pth.rect(x as f32, y as f32, w as f32, h as f32);
547 |         self.canvas.fill_path(&mut pth, &color_paint(color));
548 |     }
549 | 
550 |     pub fn rect_stroke_r(&mut self, width: f32, color: (f32, f32, f32), r: Rect) {
551 |         self.rect_stroke(width, color, r.x, r.y, r.w, r.h)
552 |     }
553 | 
554 |     pub fn rect_stroke(
555 |         &mut self,
556 |         width: f32,
557 |         color: (f32, f32, f32),
558 |         x: f32,
559 |         y: f32,
560 |         w: f32,
561 |         h: f32,
562 |     ) {
563 |         let mut pth = femtovg::Path::new();
564 |         pth.rect(x as f32, y as f32, w as f32, h as f32);
565 |         let mut paint = color_paint(color);
566 |         paint.set_line_width(width as f32);
567 |         self.canvas.stroke_path(&mut pth, &paint);
568 |     }
569 | 
570 |     pub fn label(
571 |         &mut self,
572 |         size: f32,
573 |         align: i8,
574 |         color: (f32, f32, f32),
575 |         x: f32,
576 |         y: f32,
577 |         w: f32,
578 |         h: f32,
579 |         text: &str,
580 |         dbg: &LblDebugTag,
581 |     ) {
582 |         self.label_with_font(size, align, 0.0, color, x, y, 0.0, 0.0, w, h, text, self.font, dbg);
583 |     }
584 | 
585 |     pub fn label_rot(
586 |         &mut self,
587 |         size: f32,
588 |         align: i8,
589 |         rot: f32,
590 |         color: (f32, f32, f32),
591 |         x: f32,
592 |         y: f32,
593 |         xo: f32,
594 |         yo: f32,
595 |         w: f32,
596 |         h: f32,
597 |         text: &str,
598 |         dbg: &LblDebugTag,
599 |     ) {
600 |         self.label_with_font(size, align, rot, color, x, y, xo, yo, w, h, text, self.font, dbg);
601 |     }
602 | 
603 |     pub fn label_mono(
604 |         &mut self,
605 |         size: f32,
606 |         align: i8,
607 |         color: (f32, f32, f32),
608 |         x: f32,
609 |         y: f32,
610 |         w: f32,
611 |         h: f32,
612 |         text: &str,
613 |         dbg: &LblDebugTag,
614 |     ) {
615 |         self.label_with_font(
616 |             size,
617 |             align,
618 |             0.0,
619 |             color,
620 |             x,
621 |             y,
622 |             0.0,
623 |             0.0,
624 |             w,
625 |             h,
626 |             text,
627 |             self.font_mono,
628 |             dbg,
629 |         );
630 |     }
631 | 
632 |     pub fn text_width(&mut self, size: f32, mono: bool, text: &str) -> f32 {
633 |         let mut paint = color_paint((1.0, 0.0, 1.0));
634 |         if mono {
635 |             paint.set_font(&[self.font_mono]);
636 |         } else {
637 |             paint.set_font(&[self.font]);
638 |         }
639 |         paint.set_font_size(size);
640 |         if let Ok(metr) = self.canvas.measure_text(0.0, 0.0, text, &paint) {
641 |             metr.width()
642 |         } else {
643 |             20.0
644 |         }
645 |     }
646 | 
647 |     pub fn font_height(&mut self, size: f32, mono: bool) -> f32 {
648 |         let mut paint = color_paint((1.0, 0.0, 1.0));
649 |         if mono {
650 |             paint.set_font(&[self.font_mono]);
651 |         } else {
652 |             paint.set_font(&[self.font]);
653 |         }
654 |         paint.set_font_size(size);
655 |         if let Ok(metr) = self.canvas.measure_font(&paint) {
656 |             metr.height()
657 |         } else {
658 |             UI_ELEM_TXT_DEFAULT_H as f32
659 |         }
660 |     }
661 | 
662 |     pub fn define_debug_area<F: FnMut() -> (LblDebugTag, String)>(&mut self, pos: Rect, mut f: F) {
663 |         if let Some(collector) = &mut self.lbl_collect {
664 |             let (dbg, text) = f();
665 |             collector.push((dbg, (pos.x + dbg.offs_x, pos.y + dbg.offs_y, pos.w, pos.h, text)));
666 |         }
667 |     }
668 | 
669 |     pub fn translate(&mut self, x: f32, y: f32) {
670 |         // , x2: f64, y2: f64, factor: f64) {
671 |         self.canvas.save();
672 |         //        self.cur_scale = factor as f32;
673 |         //        let factor = self.cur_scale;
674 |         //        self.canvas.translate(x as f32, y as f32);
675 |         self.canvas.translate(x, y);
676 |         //        self.canvas.scale(factor, factor);
677 |         //        self.canvas.translate(x2 as f32, y2 as f32);
678 |         //        self.canvas.translate(-x as f32 / factor, -y as f32 / factor);
679 |     }
680 | 
681 |     pub fn restore(&mut self) {
682 |         self.canvas.restore();
683 |     }
684 | }
685 | 
686 | #[allow(unused)]
687 | pub fn calc_font_size_from_text(
688 |     p: &mut Painter,
689 |     txt: &str,
690 |     mut max_fs: f32,
691 |     max_width: f32,
692 | ) -> f32 {
693 |     while p.text_width(max_fs, false, txt) > max_width {
694 |         let step = (max_fs * 0.1).max(0.1);
695 |         max_fs -= step;
696 | 
697 |         if max_fs < 1.0 {
698 |             break;
699 |         }
700 |     }
701 | 
702 |     max_fs
703 | }
704 | 
705 | pub const UI_ELEM_TXT_DEFAULT_H: f32 = 16.0;
706 | 


--------------------------------------------------------------------------------
/src/rect.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2021 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoTK. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | #[derive(Debug, Clone, Copy, PartialEq)]
  6 | pub struct Rect {
  7 |     pub x: f32,
  8 |     pub y: f32,
  9 |     pub w: f32,
 10 |     pub h: f32,
 11 | }
 12 | 
 13 | #[allow(dead_code)]
 14 | impl Rect {
 15 |     pub fn from_tpl(t: (f32, f32, f32, f32)) -> Self {
 16 |         Self { x: t.0, y: t.1, w: t.2, h: t.3 }
 17 |     }
 18 | 
 19 |     pub fn from(x: f32, y: f32, w: f32, h: f32) -> Self {
 20 |         Self { x, y, w, h }
 21 |     }
 22 | 
 23 |     pub fn clip_wh(&self) -> Self {
 24 |         Self { x: self.x, y: self.y, w: self.w.max(0.0), h: self.h.max(0.0) }
 25 |     }
 26 | 
 27 |     pub fn round(&self) -> Self {
 28 |         Self { x: self.x.round(), y: self.y.round(), w: self.w.round(), h: self.h.round() }
 29 |     }
 30 | 
 31 |     pub fn floor(&self) -> Self {
 32 |         Self { x: self.x.floor(), y: self.y.floor(), w: self.w.floor(), h: self.h.floor() }
 33 |     }
 34 | 
 35 |     pub fn resize(&self, w: f32, h: f32) -> Self {
 36 |         Self { x: self.x, y: self.y, w, h }
 37 |     }
 38 | 
 39 |     pub fn scale(&self, factor: f32) -> Self {
 40 |         Self { x: self.x, y: self.y, w: self.w * factor, h: self.h * factor }
 41 |     }
 42 | 
 43 |     pub fn center(&self) -> Self {
 44 |         Self { x: self.x + self.w * 0.5, y: self.y + self.h * 0.5, w: 1.0, h: 1.0 }
 45 |     }
 46 | 
 47 |     pub fn crop_left(&self, delta: f32) -> Self {
 48 |         Self { x: self.x + delta, y: self.y, w: self.w - delta, h: self.h }
 49 |     }
 50 | 
 51 |     pub fn crop_right(&self, delta: f32) -> Self {
 52 |         Self { x: self.x, y: self.y, w: self.w - delta, h: self.h }
 53 |     }
 54 | 
 55 |     pub fn crop_bottom(&self, delta: f32) -> Self {
 56 |         Self { x: self.x, y: self.y, w: self.w, h: self.h - delta }
 57 |     }
 58 | 
 59 |     pub fn crop_top(&self, delta: f32) -> Self {
 60 |         Self { x: self.x, y: self.y + delta, w: self.w, h: self.h - delta }
 61 |     }
 62 | 
 63 |     pub fn crop(&self, left: f32, right: f32, top: f32, bottom: f32) -> Self {
 64 |         self.crop_left(left).crop_right(right).crop_top(top).crop_bottom(bottom)
 65 |     }
 66 | 
 67 |     pub fn shrink(&self, delta_x: f32, delta_y: f32) -> Self {
 68 |         Self {
 69 |             x: self.x + delta_x,
 70 |             y: self.y + delta_y,
 71 |             w: self.w - 2.0 * delta_x,
 72 |             h: self.h - 2.0 * delta_y,
 73 |         }
 74 |     }
 75 | 
 76 |     pub fn grow(&self, delta_x: f32, delta_y: f32) -> Self {
 77 |         Self {
 78 |             x: self.x - delta_x,
 79 |             y: self.y - delta_y,
 80 |             w: self.w + 2.0 * delta_x,
 81 |             h: self.h + 2.0 * delta_y,
 82 |         }
 83 |     }
 84 | 
 85 |     pub fn offs(&self, x: f32, y: f32) -> Self {
 86 |         Self { x: self.x + x, y: self.y + y, w: self.w, h: self.h }
 87 |     }
 88 | 
 89 |     pub fn move_into(mut self, pos: &Rect) -> Self {
 90 |         if self.x < pos.x {
 91 |             self.x = pos.x;
 92 |         }
 93 |         if self.y < pos.y {
 94 |             self.y = pos.y;
 95 |         }
 96 | 
 97 |         if (self.x + self.w) > (pos.x + pos.w) {
 98 |             self.x = (pos.x + pos.w) - self.w;
 99 |         }
100 | 
101 |         if (self.y + self.h) > (pos.y + pos.h) {
102 |             self.y = (pos.y + pos.h) - self.h;
103 |         }
104 | 
105 |         self
106 |     }
107 | 
108 |     pub fn aabb_is_inside(&self, aabb: Rect) -> bool {
109 |         if self.is_inside(aabb.x, aabb.y) {
110 |             return true;
111 |         }
112 |         if self.is_inside(aabb.x + aabb.w, aabb.y) {
113 |             return true;
114 |         }
115 |         if self.is_inside(aabb.x, aabb.y + aabb.h) {
116 |             return true;
117 |         }
118 |         if self.is_inside(aabb.x + aabb.w, aabb.y + aabb.h) {
119 |             return true;
120 |         }
121 |         false
122 |     }
123 | 
124 |     pub fn is_inside(&self, x: f32, y: f32) -> bool {
125 |         x >= self.x && x <= (self.x + self.w) && y >= self.y && y <= (self.y + self.h)
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/src/style.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoTK. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use crate::hxclr;
  6 | use crate::Rect;
  7 | 
  8 | use std::rc::Rc;
  9 | 
 10 | pub const UI_BOX_H: f32 = 200.0;
 11 | pub const UI_BOX_BORD: f32 = 2.0;
 12 | pub const UI_MARGIN: f32 = 4.0;
 13 | pub const UI_PADDING: f32 = 6.0;
 14 | pub const UI_ELEM_TXT_H: f32 = 16.0;
 15 | pub const UI_SAFETY_PAD: f32 = 1.0;
 16 | 
 17 | pub const UI_BG_CLR: (f32, f32, f32) = hxclr!(0x414a51); // 473f49
 18 | pub const UI_BG2_CLR: (f32, f32, f32) = hxclr!(0x4b535a); // 594f5d
 19 | pub const UI_BG3_CLR: (f32, f32, f32) = hxclr!(0x545b61); // 645868
 20 | pub const UI_TXT_CLR: (f32, f32, f32) = hxclr!(0xdcdcf0);
 21 | pub const UI_BORDER_CLR: (f32, f32, f32) = hxclr!(0x163239); // 2b0530);
 22 | pub const UI_LBL_BG_CLR: (f32, f32, f32) = hxclr!(0x111920); // hxclr!(0x16232f); // 1a2733); // 200e1f);
 23 | pub const UI_LBL_BG_ALT_CLR: (f32, f32, f32) = hxclr!(0x2d4d5e); // 323237
 24 | pub const UI_ACCENT_CLR: (f32, f32, f32) = hxclr!(0x922f93); // b314aa);
 25 | pub const UI_ACCENT_DARK_CLR: (f32, f32, f32) = hxclr!(0x1e333d); // 4d184a); // 4d184a);
 26 | pub const UI_ACCENT_BG1_CLR: (f32, f32, f32) = hxclr!(0x111920); // UI_LBL_BG_CLR; // hxclr!(0x111920); // UI_LBL_BG_CLR; // hxclr!(0x27091b); // 381c38); // 200e1f);
 27 | pub const UI_ACCENT_BG2_CLR: (f32, f32, f32) = hxclr!(0x192129); // 2c132a);
 28 | pub const UI_PRIM_CLR: (f32, f32, f32) = hxclr!(0x03fdcb); // 69e8ed
 29 | pub const UI_PRIM2_CLR: (f32, f32, f32) = hxclr!(0x228f9d); // 1aaeb3
 30 | pub const UI_HLIGHT_CLR: (f32, f32, f32) = hxclr!(0xecf9ce); // e9f840
 31 | pub const UI_HLIGHT2_CLR: (f32, f32, f32) = hxclr!(0xbcf9cd); // b5c412
 32 | pub const UI_SELECT_CLR: (f32, f32, f32) = hxclr!(0xd73988); // 0xdc1821);
 33 | pub const UI_INACTIVE_CLR: (f32, f32, f32) = hxclr!(0x6f8782);
 34 | pub const UI_INACTIVE2_CLR: (f32, f32, f32) = hxclr!(0xa6dbd0);
 35 | 
 36 | pub fn get_ui_colors() -> Vec<(&'static str, (f32, f32, f32))> {
 37 |     vec![
 38 |         ("UI_BG_CLR", UI_BG_CLR),
 39 |         ("UI_BG2_CLR", UI_BG2_CLR),
 40 |         ("UI_BG3_CLR", UI_BG3_CLR),
 41 |         ("UI_TXT_CLR", UI_TXT_CLR),
 42 |         ("UI_BORDER_CLR", UI_BORDER_CLR),
 43 |         ("UI_LBL_BG_CLR", UI_LBL_BG_CLR),
 44 |         ("UI_LBL_BG_ALT_CLR", UI_LBL_BG_ALT_CLR),
 45 |         ("UI_ACCENT_CLR", UI_ACCENT_CLR),
 46 |         ("UI_ACCENT_DARK_CLR", UI_ACCENT_DARK_CLR),
 47 |         ("UI_ACCENT_BG1_CLR", UI_ACCENT_BG1_CLR),
 48 |         ("UI_ACCENT_BG2_CLR", UI_ACCENT_BG2_CLR),
 49 |         ("UI_PRIM_CLR", UI_PRIM_CLR),
 50 |         ("UI_PRIM2_CLR", UI_PRIM2_CLR),
 51 |         ("UI_HLIGHT_CLR", UI_HLIGHT_CLR),
 52 |         ("UI_HLIGHT2_CLR", UI_HLIGHT2_CLR),
 53 |         ("UI_SELECT_CLR", UI_SELECT_CLR),
 54 |         ("UI_INACTIVE_CLR", UI_INACTIVE_CLR),
 55 |         ("UI_INACTIVE2_CLR", UI_INACTIVE2_CLR),
 56 |     ]
 57 | }
 58 | 
 59 | pub fn get_standard_colors() -> Vec<(f32, f32, f32)> {
 60 |     vec![
 61 |         hxclr!(0x922f93), // 0
 62 |         hxclr!(0x862b37),
 63 |         hxclr!(0xb45745),
 64 |         hxclr!(0x835933),
 65 |         hxclr!(0xa69b64),
 66 |         hxclr!(0xbec8a6),
 67 |         hxclr!(0x346c38), // 6
 68 |         hxclr!(0x1fb349),
 69 |         hxclr!(0x4cdb80),
 70 |         hxclr!(0x59bca3),
 71 |         hxclr!(0x228f9d),
 72 |         hxclr!(0x03b5e7),
 73 |         hxclr!(0x3b5eca), // 12
 74 |         hxclr!(0x594fa1),
 75 |         hxclr!(0xc2b2eb),
 76 |         hxclr!(0xac70fa),
 77 |         hxclr!(0x9850a9),
 78 |         hxclr!(0xdc4fc1), // 17
 79 |         hxclr!(0x03fdcb), // 18
 80 |     ]
 81 | }
 82 | 
 83 | #[derive(Debug, Clone, Copy)]
 84 | pub enum Align {
 85 |     Center,
 86 |     Left,
 87 |     Right,
 88 | }
 89 | 
 90 | #[derive(Debug, Clone, Copy)]
 91 | pub enum VAlign {
 92 |     Middle,
 93 |     Top,
 94 |     Bottom,
 95 | }
 96 | 
 97 | #[derive(Debug, Clone, Copy)]
 98 | pub enum BorderStyle {
 99 |     Rect,
100 |     Hex { offset: f32 },
101 |     Bevel { corner_offsets: (f32, f32, f32, f32) },
102 | }
103 | 
104 | #[derive(Debug, Clone)]
105 | pub enum StyleExt {
106 |     None,
107 |     Graph {
108 |         graph_line: f32,
109 |         vline1: f32,
110 |         vline2: f32,
111 |         vline1_color: (f32, f32, f32),
112 |         vline2_color: (f32, f32, f32),
113 |         hline: f32,
114 |         hline_color: (f32, f32, f32),
115 |     },
116 |     PatternEditor {
117 |         row_height: f32,
118 |         col_width: f32,
119 |         col_div_pad: f32,
120 |     },
121 |     BlockCode {
122 |         with_markers: bool,
123 |         grid_marker_color: (f32, f32, f32),
124 |         block_bg_hover_color: (f32, f32, f32),
125 |         block_bg_color: (f32, f32, f32),
126 |         port_select_color: (f32, f32, f32),
127 |     },
128 | }
129 | 
130 | #[derive(Debug, Clone)]
131 | pub struct Style {
132 |     pub border_style: BorderStyle,
133 |     pub bg_color: (f32, f32, f32),
134 |     pub border_color: (f32, f32, f32),
135 |     pub border2_color: (f32, f32, f32),
136 |     pub color: (f32, f32, f32),
137 |     pub color2: (f32, f32, f32),
138 |     pub border: f32,
139 |     pub border2: f32,
140 |     pub line: f32,
141 |     pub pad_left: f32,
142 |     pub pad_right: f32,
143 |     pub pad_top: f32,
144 |     pub pad_bottom: f32,
145 |     pub pad_item: f32,
146 |     pub shadow_offs: (f32, f32),
147 |     pub shadow_color: (f32, f32, f32),
148 |     pub hover_shadow_color: (f32, f32, f32),
149 |     pub hover_border_color: (f32, f32, f32),
150 |     pub hover_color: (f32, f32, f32),
151 |     pub active_shadow_color: (f32, f32, f32),
152 |     pub active_border_color: (f32, f32, f32),
153 |     pub active_color: (f32, f32, f32),
154 |     pub inactive_color: (f32, f32, f32),
155 |     pub selected_color: (f32, f32, f32),
156 |     pub text_align: Align,
157 |     pub text_valign: VAlign,
158 |     pub font_size: f32,
159 |     pub colors: Vec<(f32, f32, f32)>,
160 |     pub ext: StyleExt,
161 | }
162 | 
163 | impl Style {
164 |     pub fn new() -> Self {
165 |         let colors = get_standard_colors();
166 | 
167 |         Self {
168 |             bg_color: UI_BG_CLR,
169 |             border_color: UI_BORDER_CLR,
170 |             border2_color: UI_ACCENT_CLR,
171 |             color: UI_PRIM_CLR,
172 |             color2: UI_PRIM2_CLR,
173 |             border: UI_BOX_BORD,
174 |             border2: UI_BOX_BORD,
175 |             line: 2.0 * UI_BOX_BORD,
176 |             border_style: BorderStyle::Rect,
177 |             pad_left: 0.0,
178 |             pad_right: 0.0,
179 |             pad_top: 0.0,
180 |             pad_bottom: 0.0,
181 |             pad_item: 0.0,
182 |             shadow_offs: (0.0, 0.0),
183 |             shadow_color: UI_PRIM_CLR,
184 |             hover_shadow_color: UI_SELECT_CLR,
185 |             hover_border_color: UI_HLIGHT_CLR,
186 |             hover_color: UI_HLIGHT_CLR,
187 |             active_shadow_color: UI_HLIGHT_CLR,
188 |             active_border_color: UI_SELECT_CLR,
189 |             active_color: UI_HLIGHT2_CLR,
190 |             inactive_color: UI_INACTIVE_CLR,
191 |             selected_color: UI_SELECT_CLR,
192 |             text_align: Align::Center,
193 |             text_valign: VAlign::Middle,
194 |             font_size: 14.0,
195 |             ext: StyleExt::None,
196 |             colors,
197 |         }
198 |     }
199 | 
200 |     pub fn apply_padding(&self, dpi_f: f32, pos: Rect) -> Rect {
201 |         Rect {
202 |             x: pos.x + dpi_f * self.pad_left,
203 |             y: pos.y + dpi_f * self.pad_top,
204 |             w: pos.w - dpi_f * (self.pad_left + self.pad_right),
205 |             h: pos.h - dpi_f * (self.pad_top + self.pad_bottom),
206 |         }
207 |     }
208 | 
209 |     pub fn with_style_clone<F: FnOnce(&mut Style)>(&self, f: F) -> Rc<Self> {
210 |         let mut clone = self.clone();
211 |         f(&mut clone);
212 |         Rc::new(clone)
213 |     }
214 | 
215 |     pub fn color_by_idx(&self, idx: usize) -> (f32, f32, f32) {
216 |         self.colors[idx % self.colors.len()]
217 |     }
218 | 
219 |     pub fn choose_shadow_color(&self, is_active: bool, is_hovered: bool) -> (f32, f32, f32) {
220 |         if is_active {
221 |             self.active_shadow_color
222 |         } else if is_hovered {
223 |             self.hover_shadow_color
224 |         } else {
225 |             self.shadow_color
226 |         }
227 |     }
228 | 
229 |     pub fn choose_border_color(&self, is_active: bool, is_hovered: bool) -> (f32, f32, f32) {
230 |         if is_active {
231 |             self.active_border_color
232 |         } else if is_hovered {
233 |             self.hover_border_color
234 |         } else {
235 |             self.border_color
236 |         }
237 |     }
238 | 
239 |     pub fn choose_color(&self, is_active: bool, is_hovered: bool) -> (f32, f32, f32) {
240 |         if is_active {
241 |             self.active_color
242 |         } else if is_hovered {
243 |             self.hover_color
244 |         } else {
245 |             self.color
246 |         }
247 |     }
248 | }
249 | 
250 | pub struct DPIStyle<'a> {
251 |     style: &'a Style,
252 |     dpi_factor: f32,
253 | }
254 | 
255 | macro_rules! dpi_accessor {
256 |     ($field: ident) => {
257 |         pub fn $field(&self) -> f32 {
258 |             self.style.$field * self.dpi_factor
259 |         }
260 |     };
261 | }
262 | 
263 | macro_rules! dpi_ext_accessor {
264 |     ($enum: ident :: $opt: ident, $field: ident, $default: expr) => {
265 |         pub fn $field(&self) -> f32 {
266 |             if let $enum::$opt { $field, .. } = &self.style.ext {
267 |                 $field * self.dpi_factor
268 |             } else {
269 |                 $default * self.dpi_factor
270 |             }
271 |         }
272 |     };
273 | }
274 | 
275 | macro_rules! color_accessor {
276 |     ($field: ident) => {
277 |         pub fn $field(&self) -> (f32, f32, f32) {
278 |             self.style.$field
279 |         }
280 |     };
281 | }
282 | 
283 | macro_rules! color_ext_accessor {
284 |     ($enum: ident :: $opt: ident, $field: ident, $default: expr) => {
285 |         pub fn $field(&self) -> (f32, f32, f32) {
286 |             if let $enum::$opt { $field, .. } = &self.style.ext {
287 |                 *$field
288 |             } else {
289 |                 $default
290 |             }
291 |         }
292 |     };
293 | }
294 | 
295 | macro_rules! bool_ext_accessor {
296 |     ($enum: ident :: $opt: ident, $field: ident, $default: expr) => {
297 |         pub fn $field(&self) -> bool {
298 |             if let $enum::$opt { $field, .. } = &self.style.ext {
299 |                 *$field
300 |             } else {
301 |                 $default
302 |             }
303 |         }
304 |     };
305 | }
306 | 
307 | impl<'a> DPIStyle<'a> {
308 |     pub fn new_from(dpi_factor: f32, style: &'a Style) -> Self {
309 |         Self { style, dpi_factor }
310 |     }
311 | 
312 |     pub fn border_style(&self) -> BorderStyle {
313 |         match self.style.border_style {
314 |             BorderStyle::Rect => BorderStyle::Rect,
315 |             BorderStyle::Hex { offset } => BorderStyle::Hex { offset: offset * self.dpi_factor },
316 |             BorderStyle::Bevel { corner_offsets } => BorderStyle::Bevel {
317 |                 corner_offsets: (
318 |                     corner_offsets.0 * self.dpi_factor,
319 |                     corner_offsets.1 * self.dpi_factor,
320 |                     corner_offsets.2 * self.dpi_factor,
321 |                     corner_offsets.3 * self.dpi_factor,
322 |                 ),
323 |             },
324 |         }
325 |     }
326 | 
327 |     pub fn text_align(&self) -> Align {
328 |         self.style.text_align
329 |     }
330 | 
331 |     pub fn text_valign(&self) -> VAlign {
332 |         self.style.text_valign
333 |     }
334 | 
335 |     pub fn color_by_idx(&self, idx: usize) -> (f32, f32, f32) {
336 |         self.style.color_by_idx(idx)
337 |     }
338 | 
339 |     pub fn choose_shadow_color(&self, is_active: bool, is_hovered: bool) -> (f32, f32, f32) {
340 |         self.style.choose_shadow_color(is_active, is_hovered)
341 |     }
342 | 
343 |     pub fn choose_border_color(&self, is_active: bool, is_hovered: bool) -> (f32, f32, f32) {
344 |         self.style.choose_border_color(is_active, is_hovered)
345 |     }
346 | 
347 |     pub fn choose_color(&self, is_active: bool, is_hovered: bool) -> (f32, f32, f32) {
348 |         self.style.choose_color(is_active, is_hovered)
349 |     }
350 | 
351 |     pub fn shadow_offs(&self) -> (f32, f32) {
352 |         (self.style.shadow_offs.0 * self.dpi_factor, self.style.shadow_offs.1 * self.dpi_factor)
353 |     }
354 | 
355 |     pub fn apply_padding(&self, pos: Rect) -> Rect {
356 |         self.style.apply_padding(self.dpi_factor, pos)
357 |     }
358 | 
359 |     dpi_accessor! {border}
360 |     dpi_accessor! {border2}
361 |     dpi_accessor! {line}
362 |     dpi_accessor! {pad_left}
363 |     dpi_accessor! {pad_right}
364 |     dpi_accessor! {pad_top}
365 |     dpi_accessor! {pad_bottom}
366 |     dpi_accessor! {pad_item}
367 |     dpi_accessor! {font_size}
368 | 
369 |     dpi_ext_accessor! {StyleExt::Graph, graph_line, 0.9}
370 |     dpi_ext_accessor! {StyleExt::Graph, vline1, 1.0}
371 |     dpi_ext_accessor! {StyleExt::Graph, vline2, 1.0}
372 |     dpi_ext_accessor! {StyleExt::Graph, hline, 0.0}
373 | 
374 |     dpi_ext_accessor! {StyleExt::PatternEditor, row_height, 14.0}
375 |     dpi_ext_accessor! {StyleExt::PatternEditor, col_width, 38.0}
376 |     dpi_ext_accessor! {StyleExt::PatternEditor, col_div_pad, 3.0}
377 | 
378 |     color_accessor! {bg_color}
379 |     color_accessor! {color}
380 |     color_accessor! {color2}
381 |     color_accessor! {border_color}
382 |     color_accessor! {border2_color}
383 |     color_accessor! {shadow_color}
384 |     color_accessor! {hover_shadow_color}
385 |     color_accessor! {hover_border_color}
386 |     color_accessor! {hover_color}
387 |     color_accessor! {active_shadow_color}
388 |     color_accessor! {active_border_color}
389 |     color_accessor! {active_color}
390 |     color_accessor! {inactive_color}
391 |     color_accessor! {selected_color}
392 | 
393 |     color_ext_accessor! {StyleExt::Graph, hline_color, UI_ACCENT_CLR}
394 |     color_ext_accessor! {StyleExt::Graph, vline1_color, UI_PRIM2_CLR}
395 |     color_ext_accessor! {StyleExt::Graph, vline2_color, UI_PRIM_CLR}
396 | 
397 |     color_ext_accessor! {StyleExt::BlockCode, grid_marker_color, UI_ACCENT_DARK_CLR}
398 |     color_ext_accessor! {StyleExt::BlockCode, block_bg_hover_color, UI_ACCENT_CLR}
399 |     color_ext_accessor! {StyleExt::BlockCode, block_bg_color, UI_ACCENT_BG2_CLR}
400 |     color_ext_accessor! {StyleExt::BlockCode, port_select_color, UI_SELECT_CLR}
401 | 
402 |     bool_ext_accessor! {StyleExt::BlockCode, with_markers, false}
403 | }
404 | 


--------------------------------------------------------------------------------
/src/widget.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2021-2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoTK. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use crate::painter::{ImgRef, LblDebugTag};
  6 | use crate::style::Style;
  7 | use crate::{Control, EvPayload, Event, EventCore, Painter, PopupPos, Rect, UINotifierRef};
  8 | use std::cell::RefCell;
  9 | use std::rc::{Rc, Weak};
 10 | 
 11 | use morphorm::{LayoutType, PositionType, Units};
 12 | 
 13 | thread_local! {
 14 |     pub static WIDGET_ID_COUNTER: RefCell<usize> = RefCell::new(1);
 15 | }
 16 | 
 17 | #[derive(Debug, Clone)]
 18 | pub struct Layout {
 19 |     pub visible: bool,
 20 | 
 21 |     pub layout_type: Option<LayoutType>,
 22 |     pub position_type: Option<PositionType>,
 23 |     pub width: Option<Units>,
 24 |     pub height: Option<Units>,
 25 |     pub min_width: Option<Units>,
 26 |     pub min_height: Option<Units>,
 27 |     pub max_width: Option<Units>,
 28 |     pub max_height: Option<Units>,
 29 |     pub left: Option<Units>,
 30 |     pub right: Option<Units>,
 31 |     pub top: Option<Units>,
 32 |     pub bottom: Option<Units>,
 33 |     pub min_left: Option<Units>,
 34 |     pub max_left: Option<Units>,
 35 |     pub min_right: Option<Units>,
 36 |     pub max_right: Option<Units>,
 37 |     pub min_top: Option<Units>,
 38 |     pub max_top: Option<Units>,
 39 |     pub min_bottom: Option<Units>,
 40 |     pub max_bottom: Option<Units>,
 41 |     pub child_left: Option<Units>,
 42 |     pub child_right: Option<Units>,
 43 |     pub child_top: Option<Units>,
 44 |     pub child_bottom: Option<Units>,
 45 |     pub row_between: Option<Units>,
 46 |     pub col_between: Option<Units>,
 47 |     pub grid_rows: Option<Vec<Units>>,
 48 |     pub grid_cols: Option<Vec<Units>>,
 49 |     pub row_index: Option<usize>,
 50 |     pub col_index: Option<usize>,
 51 |     pub col_span: Option<usize>,
 52 |     pub row_span: Option<usize>,
 53 |     pub border_left: Option<Units>,
 54 |     pub border_right: Option<Units>,
 55 |     pub border_top: Option<Units>,
 56 |     pub border_bottom: Option<Units>,
 57 | }
 58 | 
 59 | impl Layout {
 60 |     pub fn new() -> Self {
 61 |         Self {
 62 |             visible: true,
 63 |             layout_type: None,
 64 |             position_type: None,
 65 |             width: None,
 66 |             height: None,
 67 |             min_width: None,
 68 |             min_height: None,
 69 |             max_width: None,
 70 |             max_height: None,
 71 |             left: None,
 72 |             right: None,
 73 |             top: None,
 74 |             bottom: None,
 75 |             min_left: None,
 76 |             max_left: None,
 77 |             min_right: None,
 78 |             max_right: None,
 79 |             min_top: None,
 80 |             max_top: None,
 81 |             min_bottom: None,
 82 |             max_bottom: None,
 83 |             child_left: None,
 84 |             child_right: None,
 85 |             child_top: None,
 86 |             child_bottom: None,
 87 |             row_between: None,
 88 |             col_between: None,
 89 |             grid_rows: None,
 90 |             grid_cols: None,
 91 |             row_index: None,
 92 |             col_index: None,
 93 |             col_span: None,
 94 |             row_span: None,
 95 |             border_left: None,
 96 |             border_right: None,
 97 |             border_top: None,
 98 |             border_bottom: None,
 99 |         }
100 |     }
101 | }
102 | 
103 | #[derive(Debug, Clone)]
104 | pub struct Widget(Rc<RefCell<WidgetImpl>>);
105 | 
106 | impl Widget {
107 |     pub fn new(style: Rc<Style>) -> Self {
108 |         Self(Rc::new(RefCell::new(WidgetImpl::new(style))))
109 |     }
110 | 
111 |     pub fn debug_tag(&self) -> LblDebugTag {
112 |         LblDebugTag::from_id(self.unique_id())
113 |     }
114 | 
115 |     pub fn event(&self, name: &str, data: EvPayload) -> (usize, Event) {
116 |         (self.unique_id(), Event { name: name.to_string(), data })
117 |     }
118 | 
119 |     pub fn set_tree_pos(&self, idx: usize, depth: usize) {
120 |         self.0.borrow_mut().set_tree_pos(idx, depth)
121 |     }
122 | 
123 |     pub fn layer_idx(&self) -> usize {
124 |         self.0.borrow().layer_idx()
125 |     }
126 | 
127 |     pub fn tree_depth(&self) -> usize {
128 |         self.0.borrow().tree_depth()
129 |     }
130 | 
131 |     pub fn for_each_child<F: FnMut(&WidgetImpl, usize, bool)>(&self, f: F) {
132 |         self.0.borrow().for_each_child(f);
133 |     }
134 | 
135 |     pub fn from_weak(w: &Weak<RefCell<WidgetImpl>>) -> Option<Widget> {
136 |         w.upgrade().map(|w| Widget(w))
137 |     }
138 | 
139 |     pub fn as_weak(&self) -> Weak<RefCell<WidgetImpl>> {
140 |         Rc::downgrade(&self.0)
141 |     }
142 | 
143 |     pub fn reg<F: 'static + FnMut(&mut dyn std::any::Any, Widget, &Event)>(
144 |         &self,
145 |         ev_name: &str,
146 |         cb: F,
147 |     ) {
148 |         self.0.borrow_mut().reg(ev_name, Box::new(cb));
149 |     }
150 | 
151 |     pub fn take_event_core(&self) -> Option<EventCore> {
152 |         self.0.borrow_mut().take_event_core()
153 |     }
154 | 
155 |     pub fn set_drag_widget(&self, wid: Widget) {
156 |         self.0.borrow_mut().set_drag_widget(wid);
157 |     }
158 |     pub fn drag_widget(&self) -> Option<Widget> {
159 |         self.0.borrow().drag_widget()
160 |     }
161 | 
162 |     pub fn give_back_event_core(&self, evc: EventCore) {
163 |         self.0.borrow_mut().give_back_event_core(evc)
164 |     }
165 | 
166 |     pub fn is_cached(&self) -> bool {
167 |         self.0.borrow_mut().is_cached()
168 |     }
169 |     pub fn enable_cache(&self) {
170 |         self.0.borrow_mut().enable_cache();
171 |     }
172 | 
173 |     pub fn take_cache_img(&self) -> Option<ImgRef> {
174 |         self.0.borrow_mut().take_cache_img()
175 |     }
176 |     pub fn give_cache_img(&self, img: ImgRef) {
177 |         self.0.borrow_mut().give_cache_img(img);
178 |     }
179 | 
180 |     pub fn relayout(&self, pos: Rect) -> Option<Rect> {
181 |         self.0.borrow_mut().relayout(pos)
182 |     }
183 | 
184 |     #[allow(unused)]
185 |     fn emit_layout_change(&self) {
186 |         self.0.borrow_mut().emit_layout_change();
187 |     }
188 | 
189 |     pub fn emit_redraw_required(&self) {
190 |         self.0.borrow_mut().emit_redraw_required();
191 |     }
192 | 
193 |     pub fn activate(&self) {
194 |         self.0.borrow_mut().activate();
195 |     }
196 | 
197 |     pub fn deactivate(&self) {
198 |         self.0.borrow_mut().deactivate();
199 |     }
200 | 
201 |     pub fn is_active(&self) -> bool {
202 |         self.0.borrow_mut().is_active()
203 |     }
204 | 
205 |     pub fn set_notifier(&self, not: UINotifierRef) {
206 |         self.0.borrow_mut().set_notifier(not)
207 |     }
208 | 
209 |     pub fn is_hovered(&self) -> bool {
210 |         self.0.borrow().is_hovered()
211 |     }
212 | 
213 |     pub fn does_show_hover(&self) -> bool {
214 |         self.0.borrow().does_show_hover()
215 |     }
216 | 
217 |     pub fn unique_id(&self) -> usize {
218 |         self.0.borrow().unique_id()
219 |     }
220 | 
221 |     pub fn set_tag(&self, tag: String) {
222 |         self.0.borrow_mut().set_tag(tag);
223 |     }
224 |     pub fn tag(&self) -> String {
225 |         self.0.borrow().tag().to_string()
226 |     }
227 | 
228 |     pub fn check_data_change(&self) -> bool {
229 |         self.0.borrow_mut().check_data_change()
230 |     }
231 | 
232 |     pub fn set_ctrl(&self, ctrl: Control) {
233 |         self.0.borrow_mut().set_ctrl(ctrl)
234 |     }
235 | 
236 |     pub fn has_default_style(&self) -> bool {
237 |         self.0.borrow().has_default_style()
238 |     }
239 | 
240 |     pub fn take_ctrl(&self) -> Option<Box<Control>> {
241 |         self.0.borrow_mut().ctrl.take()
242 |     }
243 | 
244 |     pub fn give_ctrl_back(&self, ctrl: Box<Control>) {
245 |         self.0.borrow_mut().ctrl = Some(ctrl);
246 |     }
247 | 
248 |     pub fn with_ctrl<R, F: FnOnce(&mut Control) -> R>(&self, f: F) -> Option<R> {
249 |         self.0.borrow_mut().with_ctrl(f)
250 |     }
251 | 
252 |     pub fn can_hover(&self) -> bool {
253 |         self.0.borrow_mut().can_hover()
254 |     }
255 | 
256 |     pub fn set_pos(&self, pos: Rect) {
257 |         self.emit_redraw_required();
258 |         self.0.borrow_mut().pos = pos;
259 |     }
260 | 
261 |     pub fn pos(&self) -> Rect {
262 |         self.0.borrow().pos
263 |     }
264 | 
265 |     pub fn style(&self) -> Rc<Style> {
266 |         self.0.borrow().style.clone()
267 |     }
268 | 
269 |     pub fn set_style(&self, style: Rc<Style>) {
270 |         self.0.borrow_mut().set_style(style);
271 |     }
272 | 
273 |     pub fn parent(&self) -> Option<Widget> {
274 |         self.0.borrow().parent()
275 |     }
276 | 
277 |     pub fn add(&self, child: Widget) {
278 |         self.0.borrow_mut().add(child);
279 |     }
280 | 
281 |     pub fn remove_childs(&self) {
282 |         self.0.borrow_mut().remove_childs();
283 |     }
284 | 
285 |     pub fn remove_child(&self, child: Widget) {
286 |         self.0.borrow_mut().remove_child(child);
287 |     }
288 | 
289 |     pub fn set_parent(&self, parent: &Widget) {
290 |         self.0.borrow_mut().set_parent(parent);
291 |     }
292 | 
293 |     pub fn clear(&self, recursive: bool) {
294 |         self.0.borrow_mut().clear(recursive);
295 |     }
296 | 
297 |     pub fn with_layout<R, F: FnOnce(&Layout) -> R>(&self, f: F) -> R {
298 |         self.0.borrow().with_layout(f)
299 |     }
300 | 
301 |     pub fn change_layout<R, F: FnOnce(&mut Layout) -> R>(&self, f: F) -> R {
302 |         self.0.borrow_mut().change_layout(f)
303 |     }
304 | 
305 |     pub(crate) fn change_layout_silent<R, F: FnOnce(&mut Layout) -> R>(&self, f: F) -> R {
306 |         self.0.borrow_mut().change_layout_silent(f)
307 |     }
308 | 
309 |     pub fn is_visible(&self) -> bool {
310 |         self.0.borrow().is_visible()
311 |     }
312 | 
313 |     pub fn show(&self) {
314 |         self.0.borrow_mut().change_layout(|layout| layout.visible = true);
315 |     }
316 | 
317 |     pub fn hide(&self) {
318 |         self.0.borrow_mut().change_layout(|layout| layout.visible = false);
319 |     }
320 | 
321 |     pub fn auto_hide(&self) {
322 |         self.0.borrow_mut().auto_hide = true;
323 |         self.0.borrow_mut().notifier.as_mut().map(|n| n.set_tree_changed());
324 |     }
325 | 
326 |     pub fn wants_auto_hide(&self) -> bool {
327 |         self.0.borrow_mut().wants_auto_hide()
328 |     }
329 | 
330 |     pub fn popup_at(&self, pos: PopupPos) {
331 |         self.0.borrow().popup_at(pos)
332 |     }
333 | }
334 | 
335 | pub struct WidgetImpl {
336 |     unique_id: usize,
337 |     layer_idx: usize,
338 |     tree_depth: usize,
339 |     pub evc: Option<EventCore>,
340 |     parent: Option<Weak<RefCell<WidgetImpl>>>,
341 |     childs: Option<Vec<Widget>>,
342 |     pub ctrl: Option<Box<Control>>,
343 |     pos: Rect,
344 |     layout: Layout,
345 |     style: Rc<Style>,
346 |     notifier: Option<UINotifierRef>,
347 |     data_gen: u64,
348 |     drag_widget: Option<Widget>,
349 |     auto_hide: bool,
350 |     show_hover: bool,
351 |     tag: Option<String>,
352 | 
353 |     cached: bool,
354 |     cache_img: Option<ImgRef>,
355 | }
356 | 
357 | impl std::fmt::Debug for WidgetImpl {
358 |     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
359 |         f.debug_struct("Widget")
360 |             .field("unique_id", &self.unique_id)
361 |             .field("tag", &self.tag)
362 |             .finish()
363 |     }
364 | }
365 | 
366 | impl Drop for WidgetImpl {
367 |     fn drop(&mut self) {
368 |         eprintln!("HexoTK drop widget ID={}", self.unique_id);
369 |     }
370 | }
371 | 
372 | impl WidgetImpl {
373 |     pub fn new(style: Rc<Style>) -> Self {
374 |         let unique_id = WIDGET_ID_COUNTER.with(|cnt| {
375 |             let unique_id = *cnt.borrow();
376 |             *cnt.borrow_mut() += 1;
377 |             unique_id
378 |         });
379 | 
380 |         Self {
381 |             unique_id,
382 |             layer_idx: 0,
383 |             tree_depth: 0,
384 |             evc: Some(EventCore::new()),
385 |             parent: None,
386 |             childs: Some(vec![]),
387 |             ctrl: Some(Box::new(Control::None)),
388 |             data_gen: 0,
389 |             pos: Rect::from(0.0, 0.0, 0.0, 0.0),
390 |             layout: Layout::new(),
391 |             notifier: None,
392 |             drag_widget: None,
393 |             cached: false,
394 |             cache_img: None,
395 |             auto_hide: false,
396 |             show_hover: false,
397 |             tag: None,
398 |             style,
399 |         }
400 |     }
401 | 
402 |     pub fn set_tree_pos(&mut self, idx: usize, depth: usize) {
403 |         self.layer_idx = idx;
404 |         self.tree_depth = depth;
405 |     }
406 | 
407 |     pub fn layer_idx(&self) -> usize {
408 |         self.layer_idx
409 |     }
410 | 
411 |     pub fn tree_depth(&self) -> usize {
412 |         self.tree_depth
413 |     }
414 | 
415 |     pub fn for_each_child<F: FnMut(&WidgetImpl, usize, bool)>(&self, mut f: F) {
416 |         if let Some(childs) = &self.childs {
417 |             let len = childs.len();
418 |             for (i, w) in childs.iter().enumerate() {
419 |                 f(&mut w.0.borrow(), i, (i + 1) == len)
420 |             }
421 |         }
422 |     }
423 | 
424 |     pub fn is_visible(&self) -> bool {
425 |         if let Some(parent) = self.parent() {
426 |             parent.is_visible() && self.with_layout(|layout| layout.visible)
427 |         } else {
428 |             self.with_layout(|layout| layout.visible)
429 |         }
430 |     }
431 | 
432 |     pub fn reg(
433 |         &mut self,
434 |         ev_name: &str,
435 |         cb: Box<dyn FnMut(&mut dyn std::any::Any, Widget, &Event)>,
436 |     ) {
437 |         if let Some(evc) = &mut self.evc {
438 |             evc.reg(ev_name, cb);
439 |         }
440 |     }
441 | 
442 |     pub fn take_event_core(&mut self) -> Option<EventCore> {
443 |         self.evc.take()
444 |     }
445 | 
446 |     pub fn give_back_event_core(&mut self, evc: EventCore) {
447 |         self.evc = Some(evc);
448 |     }
449 | 
450 |     pub fn set_drag_widget(&mut self, wid: Widget) {
451 |         self.drag_widget = Some(wid);
452 |     }
453 |     pub fn drag_widget(&self) -> Option<Widget> {
454 |         self.drag_widget.clone()
455 |     }
456 | 
457 |     pub fn is_cached(&mut self) -> bool {
458 |         self.cached
459 |     }
460 |     pub fn enable_cache(&mut self) {
461 |         self.cached = true;
462 |     }
463 | 
464 |     pub fn take_cache_img(&mut self) -> Option<ImgRef> {
465 |         self.cache_img.take()
466 |     }
467 |     pub fn give_cache_img(&mut self, img: ImgRef) {
468 |         self.cache_img = Some(img);
469 |     }
470 | 
471 |     pub fn with_layout<R, F: FnOnce(&Layout) -> R>(&self, f: F) -> R {
472 |         f(&self.layout)
473 |     }
474 | 
475 |     pub fn change_layout<R, F: FnOnce(&mut Layout) -> R>(&mut self, f: F) -> R {
476 |         let ret = f(&mut self.layout);
477 |         self.emit_layout_change();
478 |         ret
479 |     }
480 | 
481 |     pub(crate) fn change_layout_silent<R, F: FnOnce(&mut Layout) -> R>(&mut self, f: F) -> R {
482 |         f(&mut self.layout)
483 |     }
484 | 
485 |     pub fn relayout(&mut self, pos: Rect) -> Option<Rect> {
486 |         // call relayout on childs...
487 |         Some(pos)
488 |     }
489 | 
490 |     fn emit_layout_change(&self) {
491 |         self.notifier.as_ref().map(|n| n.set_layout_changed());
492 |     }
493 | 
494 |     pub fn emit_redraw_required(&self) {
495 |         if self.is_visible() {
496 |             //d// println!("Emit Redraw by {} / {}", self.unique_id(), self.tag());
497 |             self.notifier.as_ref().map(|n| n.redraw(self.unique_id));
498 |         }
499 |     }
500 | 
501 |     pub fn activate(&self) {
502 |         self.notifier.as_ref().map(|n| n.activate(self.unique_id));
503 |     }
504 | 
505 |     pub fn deactivate(&self) {
506 |         self.notifier.as_ref().map(|n| n.deactivate(self.unique_id));
507 |     }
508 | 
509 |     pub fn is_active(&self) -> bool {
510 |         self.unique_id == self.notifier.as_ref().map(|n| n.active()).flatten().unwrap_or(0)
511 |     }
512 | 
513 |     pub fn set_notifier(&mut self, not: UINotifierRef) {
514 |         self.notifier = Some(not);
515 |     }
516 | 
517 |     pub fn is_hovered(&self) -> bool {
518 |         self.unique_id == self.notifier.as_ref().map(|n| n.hover()).unwrap_or(0)
519 |     }
520 | 
521 |     pub fn does_show_hover(&self) -> bool {
522 |         self.show_hover
523 |     }
524 | 
525 |     pub fn unique_id(&self) -> usize {
526 |         self.unique_id
527 |     }
528 | 
529 |     pub fn set_tag(&mut self, tag: String) {
530 |         self.tag = Some(tag);
531 |     }
532 |     pub fn tag(&self) -> &str {
533 |         self.tag.as_ref().map(|t| &t[..]).unwrap_or("")
534 |     }
535 | 
536 |     pub fn check_data_change(&mut self) -> bool {
537 |         if let Some(ctrl) = &mut self.ctrl {
538 |             let current_data_gen = ctrl.get_generation();
539 |             let has_changed = self.data_gen != current_data_gen;
540 |             self.data_gen = current_data_gen;
541 |             has_changed
542 |         } else {
543 |             false
544 |         }
545 |     }
546 | 
547 |     pub fn set_ctrl(&mut self, ctrl: Control) {
548 |         self.show_hover = ctrl.can_show_hover();
549 |         self.ctrl = Some(Box::new(ctrl));
550 |     }
551 | 
552 |     pub fn has_default_style(&self) -> bool {
553 |         self.ctrl.as_ref().map(|c| c.has_default_style()).unwrap_or(false)
554 |     }
555 | 
556 |     pub fn can_hover(&self) -> bool {
557 |         self.ctrl.as_ref().map(|c| c.can_hover()).unwrap_or(false)
558 |     }
559 | 
560 |     pub fn with_ctrl<R, F: FnOnce(&mut Control) -> R>(&mut self, f: F) -> Option<R> {
561 |         if let Some(ctrl) = self.ctrl.as_mut() {
562 |             Some(f(ctrl))
563 |         } else {
564 |             None
565 |         }
566 |     }
567 | 
568 |     pub fn pos(&self) -> Rect {
569 |         self.pos
570 |     }
571 | 
572 |     pub fn style(&self) -> &Style {
573 |         &*self.style
574 |     }
575 | 
576 |     pub fn set_style(&mut self, style: Rc<Style>) {
577 |         if self.style.border != style.border {
578 |             self.emit_layout_change();
579 |         }
580 | 
581 |         self.style = style;
582 | 
583 |         self.emit_redraw_required();
584 |     }
585 | 
586 |     pub fn new_ref(style: Rc<Style>) -> Rc<RefCell<Self>> {
587 |         Rc::new(RefCell::new(Self::new(style)))
588 |     }
589 | 
590 |     pub fn parent(&self) -> Option<Widget> {
591 |         self.parent.as_ref().map(|p| Widget::from_weak(p)).flatten()
592 |     }
593 | 
594 |     pub fn add(&mut self, child: Widget) {
595 |         if let Some(childs) = &mut self.childs {
596 |             childs.push(child);
597 |         }
598 | 
599 |         self.notifier.as_mut().map(|n| n.set_tree_changed());
600 |     }
601 | 
602 |     pub fn popup_at(&self, pos: PopupPos) {
603 |         self.notifier.as_ref().map(|n| n.popup(self.unique_id, pos));
604 |     }
605 | 
606 |     pub fn remove_childs(&mut self) {
607 |         if let Some(childs) = &mut self.childs {
608 |             if !childs.is_empty() {
609 |                 for c in childs.iter() {
610 |                     c.0.borrow_mut().parent = None;
611 |                 }
612 | 
613 |                 childs.clear();
614 | 
615 |                 self.notifier.as_mut().map(|n| n.set_tree_changed());
616 |             }
617 |         }
618 |     }
619 | 
620 |     pub fn remove_child(&mut self, child: Widget) {
621 |         let child_addr = child.0.as_ptr();
622 | 
623 |         if let Some(childs) = &mut self.childs {
624 |             let mut idx = None;
625 |             let mut child = None;
626 | 
627 |             for (i, c) in childs.iter().enumerate() {
628 |                 if std::ptr::eq(c.0.as_ptr(), child_addr) {
629 |                     idx = Some(i);
630 |                     child = Some(c.clone());
631 |                     break;
632 |                 }
633 |             }
634 | 
635 |             if let Some(child) = child {
636 |                 child.0.borrow_mut().parent = None;
637 |             }
638 | 
639 |             if let Some(idx) = idx {
640 |                 childs.remove(idx);
641 |                 self.notifier.as_mut().map(|n| n.set_tree_changed());
642 |             }
643 |         }
644 |     }
645 | 
646 |     pub fn wants_auto_hide(&self) -> bool {
647 |         self.auto_hide
648 |     }
649 | 
650 |     pub fn set_parent(&mut self, parent: &Widget) {
651 |         self.parent = Some(Rc::downgrade(&parent.0));
652 |     }
653 | 
654 |     pub fn clear(&mut self, recursive: bool) {
655 |         self.evc.as_mut().map(|evc| evc.clear());
656 |         self.ctrl = None;
657 |         self.parent = None;
658 |         self.unique_id = usize::MAX;
659 | 
660 |         if let Some(childs) = &mut self.childs {
661 |             if recursive {
662 |                 for c in childs.iter_mut() {
663 |                     c.clear(recursive);
664 |                 }
665 |             }
666 | 
667 |             childs.clear();
668 |         }
669 |     }
670 | }
671 | 
672 | pub fn widget_draw(
673 |     widget: &Widget,
674 |     redraw: &std::collections::HashSet<usize>,
675 |     draw_origin: Rect,
676 |     painter: &mut Painter,
677 | ) {
678 |     let visible = widget.0.borrow().layout.visible;
679 |     if !visible {
680 |         return;
681 |     }
682 | 
683 |     //d// println!("REDRAW {} ({}) is_cached={}", widget.unique_id(), widget.tag(), widget.is_cached());
684 | 
685 |     let ctrl = widget.0.borrow_mut().ctrl.take();
686 |     let childs = widget.0.borrow_mut().childs.take();
687 | 
688 |     if let Some(mut ctrl) = ctrl {
689 |         ctrl.draw(draw_origin, widget, Some(redraw), childs.as_ref(), painter);
690 | 
691 |         widget.0.borrow_mut().childs = childs;
692 |         widget.0.borrow_mut().ctrl = Some(ctrl);
693 |     }
694 | }
695 | 
696 | pub fn widget_draw_shallow(
697 |     widget: &Widget,
698 |     _redraw: bool,
699 |     draw_origin: Rect,
700 |     painter: &mut Painter,
701 | ) {
702 |     let visible = widget.0.borrow().layout.visible;
703 |     if !visible {
704 |         return;
705 |     }
706 | 
707 |     let ctrl = widget.0.borrow_mut().ctrl.take();
708 |     if let Some(mut ctrl) = ctrl {
709 |         ctrl.draw(draw_origin, widget, None, None, painter);
710 |         widget.0.borrow_mut().ctrl = Some(ctrl);
711 |     }
712 | }
713 | 
714 | pub fn widget_draw_frame(widget: &Widget, painter: &mut Painter) {
715 |     let ctrl = widget.0.borrow_mut().ctrl.take();
716 |     let childs = widget.0.borrow_mut().childs.take();
717 | 
718 |     if let Some(mut ctrl) = ctrl {
719 |         ctrl.draw_frame(widget, painter);
720 | 
721 |         if let Some(childs) = childs {
722 |             for c in childs.iter() {
723 |                 widget_draw_frame(c, painter);
724 |             }
725 |             widget.0.borrow_mut().childs = Some(childs);
726 |         }
727 | 
728 |         widget.0.borrow_mut().ctrl = Some(ctrl);
729 |     }
730 | }
731 | 
732 | pub fn widget_annotate_drop_event(widget: &Widget, mouse_pos: (f32, f32), ev: Event) -> Event {
733 |     let ctrl = widget.0.borrow_mut().ctrl.take();
734 | 
735 |     if let Some(mut ctrl) = ctrl {
736 |         let ret = ctrl.annotate_drop_event(mouse_pos, ev);
737 |         widget.0.borrow_mut().ctrl = Some(ctrl);
738 |         ret
739 |     } else {
740 |         ev
741 |     }
742 | }
743 | 
744 | pub fn widget_walk_impl<F: FnMut(&Widget, Option<&Widget>, bool, bool, usize)>(
745 |     widget: &Widget,
746 |     parent: Option<&Widget>,
747 |     cb: &mut F,
748 |     is_first: bool,
749 |     is_last: bool,
750 |     depth: usize,
751 | ) {
752 |     cb(widget, parent, is_first, is_last, depth);
753 | 
754 |     if let Some(childs) = &widget.0.borrow().childs {
755 |         let len = childs.len();
756 |         for (i, c) in childs.iter().enumerate() {
757 |             widget_walk_impl(&c, Some(&widget), cb, i == 0, (i + 1) == len, depth + 1)
758 |         }
759 |     }
760 | }
761 | 
762 | pub fn widget_walk<F: FnMut(&Widget, Option<&Widget>, bool, bool, usize)>(
763 |     widget: &Widget,
764 |     mut cb: F,
765 | ) {
766 |     widget_walk_impl(widget, None, &mut cb, true, true, 0);
767 | }
768 | 
769 | pub fn widget_walk_parents<F: FnMut(&Widget)>(widget: &Widget, mut cb: F) {
770 |     let mut cur_parent = widget.parent();
771 | 
772 |     while cur_parent.is_some() {
773 |         cb(cur_parent.as_ref().unwrap());
774 |         cur_parent = cur_parent.unwrap().parent();
775 |     }
776 | }
777 | 


--------------------------------------------------------------------------------
/src/widget_store.rs:
--------------------------------------------------------------------------------
  1 | use crate::layout::{LayoutCache, WidgetId};
  2 | use crate::widget::{widget_walk, Widget, WidgetImpl};
  3 | use std::cell::RefCell;
  4 | use std::collections::HashMap;
  5 | use std::rc::{Rc, Weak};
  6 | 
  7 | use morphorm::Hierarchy;
  8 | 
  9 | pub struct WidgetStore {
 10 |     widgets: HashMap<usize, Weak<RefCell<WidgetImpl>>>,
 11 | }
 12 | 
 13 | impl WidgetStore {
 14 |     pub fn new() -> Self {
 15 |         Self { widgets: HashMap::new() }
 16 |     }
 17 | 
 18 |     pub fn for_each_widget<F: FnMut(Widget)>(&self, mut f: F) {
 19 |         for (_id, w) in self.widgets.iter() {
 20 |             if let Some(w) = Widget::from_weak(w) {
 21 |                 f(w);
 22 |             }
 23 |         }
 24 |     }
 25 | 
 26 |     pub fn for_each_widget_impl<F: FnMut(&mut WidgetImpl)>(&self, mut f: F) {
 27 |         for (_id, w) in self.widgets.iter() {
 28 |             if let Some(w) = w.upgrade() {
 29 |                 f(&mut w.borrow_mut());
 30 |             }
 31 |         }
 32 |     }
 33 | 
 34 |     pub fn clear(&mut self) {
 35 |         self.widgets.clear();
 36 |     }
 37 | 
 38 |     pub fn add_root(&mut self, root: &Widget, layer_idx: usize) {
 39 |         widget_walk(root, |wid, parent, _is_first, _is_last, depth| {
 40 |             if let Some(parent) = parent {
 41 |                 wid.set_parent(parent);
 42 |             }
 43 | 
 44 |             wid.set_tree_pos(layer_idx, depth);
 45 |             self.widgets.insert(wid.unique_id(), wid.as_weak());
 46 |         });
 47 |     }
 48 | 
 49 |     pub fn get(&self, unique_id: usize) -> Option<Widget> {
 50 |         let wid = self.widgets.get(&unique_id)?;
 51 |         Widget::from_weak(wid)
 52 |     }
 53 | 
 54 |     pub fn with_layout<R, F: FnOnce(&crate::widget::Layout) -> Option<R>>(
 55 |         &self,
 56 |         w_id: &WidgetId,
 57 |         f: F,
 58 |     ) -> Option<R> {
 59 |         self.get(w_id.unique_id()).map(|w| w.with_layout(f)).flatten()
 60 |     }
 61 | }
 62 | 
 63 | pub struct WidgetTree {
 64 |     store: Rc<RefCell<WidgetStore>>,
 65 |     widgets: HashMap<usize, (Option<WidgetId>, bool, bool)>,
 66 |     widget_dfs_vec: Vec<WidgetId>,
 67 | }
 68 | 
 69 | impl WidgetTree {
 70 |     pub fn from_root(store: Rc<RefCell<WidgetStore>>, root: &Widget) -> Self {
 71 |         let mut widgets = HashMap::new();
 72 |         let mut widget_dfs_vec = vec![];
 73 | 
 74 |         widget_walk(root, |wid, _parent, is_first, is_last, _depth| {
 75 |             widget_dfs_vec.push(WidgetId::from(wid.unique_id()));
 76 |             widgets.insert(
 77 |                 wid.unique_id(),
 78 |                 (wid.parent().map(|w| WidgetId::from(w.unique_id())), is_first, is_last),
 79 |             );
 80 |         });
 81 | 
 82 |         Self { store, widgets, widget_dfs_vec }
 83 |     }
 84 | 
 85 |     pub fn apply_layout_to_widgets(&self, cache: &LayoutCache) {
 86 |         for w_id in &self.widget_dfs_vec {
 87 |             let pos = cache.get_widget_rect_by_id(w_id).round();
 88 |             //d// println!("apply_layout[{}] = {:?}", w_id.unique_id(), pos);
 89 | 
 90 |             if let Some(widget) = self.store.borrow().get(w_id.unique_id()) {
 91 |                 widget.set_pos(pos);
 92 |             }
 93 |         }
 94 |     }
 95 | }
 96 | 
 97 | impl<'a> Hierarchy<'a> for WidgetTree {
 98 |     type Item = WidgetId;
 99 | 
100 |     fn up_iter<F: FnMut(Self::Item)>(&'a self, mut f: F) {
101 |         for w_id in self.widget_dfs_vec.iter().rev() {
102 |             (f)(*w_id);
103 |         }
104 |     }
105 | 
106 |     fn down_iter<F: FnMut(Self::Item)>(&'a self, mut f: F) {
107 |         for w_id in self.widget_dfs_vec.iter() {
108 |             (f)(*w_id);
109 |         }
110 |     }
111 | 
112 |     fn child_iter<F: FnMut(Self::Item)>(&'a self, node: Self::Item, mut f: F) {
113 |         let w = self.store.borrow().get(node.unique_id()).unwrap();
114 | 
115 |         w.for_each_child(|w, _, _| {
116 |             (f)(WidgetId::from(w.unique_id()));
117 |         });
118 |     }
119 | 
120 |     fn parent(&self, node: Self::Item) -> Option<Self::Item> {
121 |         self.widgets.get(&node.unique_id()).map(|(w, _, _)| *w)?
122 |     }
123 | 
124 |     fn is_first_child(&self, node: Self::Item) -> bool {
125 |         self.widgets.get(&node.unique_id()).map(|(_, is_first, _)| *is_first).unwrap_or(false)
126 |     }
127 | 
128 |     fn is_last_child(&self, node: Self::Item) -> bool {
129 |         self.widgets.get(&node.unique_id()).map(|(_, _, is_last)| *is_last).unwrap_or(false)
130 |     }
131 | }
132 | 


--------------------------------------------------------------------------------
/src/widgets/connector.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2021 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoDSP. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use crate::{EvPayload, Event, InputEvent, MButton, Widget};
  6 | 
  7 | use crate::style::*;
  8 | 
  9 | use crate::painter::*;
 10 | use crate::rect::*;
 11 | 
 12 | use std::cell::RefCell;
 13 | use std::rc::Rc;
 14 | 
 15 | #[derive(Debug, Clone)]
 16 | pub struct ConnectorData {
 17 |     connection: Option<(usize, usize)>,
 18 |     items_left: Vec<(String, bool)>,
 19 |     items_right: Vec<(String, bool)>,
 20 |     generation: u64,
 21 | }
 22 | 
 23 | impl ConnectorData {
 24 |     pub fn new() -> Self {
 25 |         Self { connection: None, items_left: vec![], items_right: vec![], generation: 0 }
 26 |     }
 27 | 
 28 |     pub fn clear(&mut self) {
 29 |         self.connection = None;
 30 |         self.items_left.clear();
 31 |         self.items_right.clear();
 32 |         self.generation += 1;
 33 |     }
 34 | 
 35 |     pub fn add_input(&mut self, lbl: String, active: bool) {
 36 |         self.items_right.push((lbl, active));
 37 |         self.generation += 1;
 38 |     }
 39 |     pub fn add_output(&mut self, lbl: String, active: bool) {
 40 |         self.items_left.push((lbl, active));
 41 |         self.generation += 1;
 42 |     }
 43 | 
 44 |     pub fn set_connection(&mut self, i: usize, o: usize) {
 45 |         self.connection = Some((i, o));
 46 |         self.generation += 1;
 47 |     }
 48 | 
 49 |     pub fn clear_connection(&mut self) {
 50 |         self.connection = None;
 51 |         self.generation += 1;
 52 |     }
 53 | 
 54 |     pub fn get_connection(&mut self) -> Option<(usize, usize)> {
 55 |         self.connection
 56 |     }
 57 | }
 58 | 
 59 | pub struct Connector {
 60 |     data: Rc<RefCell<ConnectorData>>,
 61 | 
 62 |     yrow: f32,
 63 |     hover_idx: Option<(bool, usize)>,
 64 |     drag_src_idx: Option<(bool, usize)>,
 65 |     drag: bool,
 66 | 
 67 |     mouse_pos: (f32, f32),
 68 |     zones: Vec<(Rect, (bool, usize))>,
 69 |     debug_lbls: Vec<(&'static str, &'static str)>,
 70 | }
 71 | 
 72 | impl Connector {
 73 |     pub fn new(data: Rc<RefCell<ConnectorData>>) -> Self {
 74 |         Self {
 75 |             data,
 76 | 
 77 |             yrow: 0.0,
 78 |             hover_idx: None,
 79 |             drag_src_idx: None,
 80 |             drag: false,
 81 | 
 82 |             mouse_pos: (0.0, 0.0),
 83 |             zones: vec![],
 84 |             debug_lbls: vec![
 85 |                 ("input_0", "output_0"),
 86 |                 ("input_1", "output_1"),
 87 |                 ("input_2", "output_2"),
 88 |                 ("input_3", "output_3"),
 89 |                 ("input_4", "output_4"),
 90 |                 ("input_5", "output_5"),
 91 |                 ("input_6", "output_6"),
 92 |                 ("input_7", "output_7"),
 93 |                 ("input_8", "output_8"),
 94 |                 ("input_9", "output_9"),
 95 |                 ("input_10", "output_10"),
 96 |                 ("input_11", "output_11"),
 97 |                 ("input_12", "output_12"),
 98 |                 ("input_13", "output_13"),
 99 |                 ("input_14", "output_14"),
100 |                 ("input_15", "output_15"),
101 |                 ("input_16", "output_16"),
102 |                 ("input_17", "output_17"),
103 |                 ("input_18", "output_18"),
104 |                 ("input_19", "output_19"),
105 |             ],
106 |         }
107 |     }
108 | 
109 |     fn xy2pos(&self, x: f32, y: f32) -> Option<(bool, usize)> {
110 |         for z in &self.zones {
111 |             if z.0.is_inside(x, y) {
112 |                 return Some(z.1);
113 |             }
114 |         }
115 | 
116 |         None
117 |     }
118 | 
119 |     fn get_current_con(&self) -> Option<(bool, (usize, usize))> {
120 |         let data = self.data.borrow();
121 | 
122 |         let (a_inp, a) = if let Some((inputs, row)) = self.drag_src_idx {
123 |             (inputs, row)
124 |         } else {
125 |             return data.connection.map(|con| (false, con));
126 |         };
127 | 
128 |         let (b_inp, b) = if let Some((inputs, row)) = self.hover_idx {
129 |             (inputs, row)
130 |         } else {
131 |             return data.connection.map(|con| (false, con));
132 |         };
133 | 
134 |         if a_inp == b_inp {
135 |             if a_inp {
136 |                 if data.items_left.len() == 1 {
137 |                     return Some((true, (0, a)));
138 |                 }
139 |             } else {
140 |                 if data.items_right.len() == 1 {
141 |                     return Some((true, (a, 0)));
142 |                 }
143 |             }
144 |             return data.connection.map(|con| (false, con));
145 |         }
146 | 
147 |         let (a, b) = if b_inp { (a, b) } else { (b, a) };
148 | 
149 |         if !data.items_left.get(a).map(|x| x.1).unwrap_or(false) {
150 |             return data.connection.map(|con| (false, con));
151 |         }
152 | 
153 |         if !data.items_right.get(b).map(|x| x.1).unwrap_or(false) {
154 |             return data.connection.map(|con| (false, con));
155 |         }
156 | 
157 |         Some((true, (a, b)))
158 |     }
159 | }
160 | 
161 | impl Connector {
162 |     pub fn handle(&mut self, w: &Widget, event: &InputEvent, out_events: &mut Vec<(usize, Event)>) {
163 |         match event {
164 |             InputEvent::MouseButtonPressed(MButton::Left) => {
165 |                 if !w.is_hovered() {
166 |                     return;
167 |                 }
168 | 
169 |                 let (x, y) = self.mouse_pos;
170 |                 self.drag = true;
171 |                 self.drag_src_idx = self.xy2pos(x, y);
172 | 
173 |                 if let Some((inputs, _)) = self.drag_src_idx {
174 |                     if inputs {
175 |                         if self.data.borrow().items_left.len() == 1 {
176 |                             self.drag_src_idx = Some((false, 0));
177 |                         }
178 |                     } else {
179 |                         if self.data.borrow().items_right.len() == 1 {
180 |                             self.drag_src_idx = Some((true, 0));
181 |                         }
182 |                     }
183 |                 }
184 | 
185 |                 w.activate();
186 |                 w.emit_redraw_required();
187 |             }
188 |             InputEvent::MouseButtonReleased(MButton::Left) => {
189 |                 if !w.is_active() {
190 |                     return;
191 |                 }
192 | 
193 |                 if let Some((_drag, con)) = self.get_current_con() {
194 |                     self.data.borrow_mut().connection = Some(con);
195 |                 } else {
196 |                     self.data.borrow_mut().connection = None;
197 |                 }
198 | 
199 |                 out_events.push(
200 |                     w.event("change", EvPayload::SetConnection(self.data.borrow().connection)),
201 |                 );
202 | 
203 |                 self.drag = false;
204 |                 self.drag_src_idx = None;
205 | 
206 |                 w.deactivate();
207 |                 w.emit_redraw_required();
208 |             }
209 |             InputEvent::MousePosition(x, y) => {
210 |                 self.mouse_pos = (*x, *y);
211 | 
212 |                 let old_hover = self.hover_idx;
213 |                 self.hover_idx = self.xy2pos(*x, *y);
214 | 
215 |                 if old_hover != self.hover_idx {
216 |                     if let Some((inputs, idx)) = self.hover_idx {
217 |                         out_events.push(w.event(
218 |                             "connection_hover",
219 |                             EvPayload::ConnectionHover { is_input: inputs, index: idx },
220 |                         ));
221 |                     }
222 | 
223 |                     w.emit_redraw_required();
224 |                 }
225 |             }
226 |             _ => {}
227 |         }
228 |     }
229 | 
230 |     pub fn draw(
231 |         &mut self,
232 |         w: &Widget,
233 |         style: &DPIStyle,
234 |         pos: Rect,
235 |         real_pos: Rect,
236 |         p: &mut Painter,
237 |     ) {
238 |         // FIXME: The usage of dpi_f * 1.0 is suspicious, but I currently don't know
239 |         //        why the offsets are there where they are and don't have the time to investigate.
240 |         let dpi_f = p.dpi_factor;
241 | 
242 |         let mut dbg = w.debug_tag();
243 |         dbg.set_offs((real_pos.x - pos.x, real_pos.y - pos.y));
244 | 
245 |         let data = self.data.borrow();
246 | 
247 |         self.zones.clear();
248 |         let pos = pos.floor();
249 | 
250 |         let row_h = data.items_left.len().max(data.items_right.len());
251 | 
252 |         // XXX: - 1.0 on height and width for some extra margin so that the
253 |         //      rectangles for the ports are not clipped.
254 |         let yrow = (pos.h / (row_h as f32)).floor();
255 |         let xcol = (pos.w / 3.0).floor();
256 | 
257 |         self.yrow = yrow;
258 | 
259 |         let pos = Rect { x: pos.x, y: pos.y, w: xcol * 3.0, h: yrow * (row_h as f32) };
260 | 
261 |         let does_hover_this_widget = w.is_hovered();
262 | 
263 |         let btn_rect = Rect::from(0.0, 0.0, xcol, yrow);
264 |         for row in 0..row_h {
265 |             let yo = row as f32 * yrow;
266 |             let txt_pad = 2.0 * style.border2();
267 |             let txt_w = xcol - 2.0 * txt_pad;
268 | 
269 |             if let Some((lbl, active)) = data.items_left.get(row) {
270 |                 p.rect_stroke_r(
271 |                     style.border2(),
272 |                     style.border2_color(),
273 |                     btn_rect.offs(pos.x, pos.y + yo),
274 |                 );
275 |                 self.zones.push((btn_rect.offs(real_pos.x, real_pos.y + yo), (false, row)));
276 | 
277 |                 let fs = calc_font_size_from_text(p, &lbl, style.font_size(), txt_w);
278 |                 p.label(
279 |                     fs,
280 |                     -1,
281 |                     if *active { style.color() } else { style.inactive_color() },
282 |                     pos.x + txt_pad,
283 |                     pos.y + yo,
284 |                     txt_w,
285 |                     yrow,
286 |                     &lbl,
287 |                     dbg.source(self.debug_lbls.get(row).unwrap_or(&("input_", "output_")).0),
288 |                 );
289 |             }
290 | 
291 |             if let Some((lbl, active)) = data.items_right.get(row) {
292 |                 p.rect_stroke_r(
293 |                     style.border2(),
294 |                     style.border2_color(),
295 |                     btn_rect.offs(pos.x + 2.0 * xcol - dpi_f * 1.0, pos.y + yo),
296 |                 );
297 |                 self.zones.push((
298 |                     btn_rect.offs(real_pos.x + 2.0 * xcol - dpi_f * 1.0, real_pos.y + yo),
299 |                     (true, row),
300 |                 ));
301 | 
302 |                 let fs = calc_font_size_from_text(p, &lbl, style.font_size(), txt_w);
303 |                 p.label(
304 |                     fs,
305 |                     1,
306 |                     if *active { style.color() } else { style.inactive_color() },
307 |                     pos.x + txt_pad + 2.0 * xcol - style.border2(),
308 |                     pos.y + yo,
309 |                     txt_w,
310 |                     yrow,
311 |                     &lbl,
312 |                     dbg.source(self.debug_lbls.get(row).unwrap_or(&("input_", "output_")).1),
313 |                 );
314 |             }
315 |         }
316 | 
317 |         if let Some((inputs, row)) = self.hover_idx {
318 |             let items = if inputs { &data.items_right } else { &data.items_left };
319 | 
320 |             if let Some((_lbl, active)) = items.get(row) {
321 |                 if *active {
322 |                     let xo = if inputs { xcol * 2.0 - dpi_f * 1.0 } else { 0.0 };
323 |                     let yo = row as f32 * yrow;
324 | 
325 |                     if does_hover_this_widget {
326 |                         p.rect_stroke_r(
327 |                             style.border2(),
328 |                             style.hover_color(),
329 |                             btn_rect.offs(pos.x + xo, pos.y + yo),
330 |                         );
331 |                     }
332 |                 }
333 |             }
334 |         }
335 | 
336 |         if let Some((inputs, row)) = self.drag_src_idx {
337 |             let xo = if inputs { xcol * 2.0 - dpi_f * 1.0 } else { 0.0 };
338 |             let yo = row as f32 * yrow;
339 | 
340 |             if self.drag {
341 |                 p.rect_stroke_r(
342 |                     style.border2(),
343 |                     style.active_color(),
344 |                     btn_rect.offs(pos.x + xo, pos.y + yo),
345 |                 );
346 |             }
347 |         }
348 | 
349 |         if let Some((drag, (a, b))) = self.get_current_con() {
350 |             let ay = a as f32 * yrow;
351 |             let by = b as f32 * yrow;
352 | 
353 |             p.path_stroke(
354 |                 style.line(),
355 |                 if drag { style.hover_color() } else { style.color() },
356 |                 &mut [
357 |                     (xcol, ay + yrow * 0.5),
358 |                     (xcol + xcol * 0.25, ay + yrow * 0.5),
359 |                     (2.0 * xcol - xcol * 0.25, by + yrow * 0.5),
360 |                     (2.0 * xcol - style.border2(), by + yrow * 0.5),
361 |                 ]
362 |                 .iter()
363 |                 .copied()
364 |                 .map(|(x, y)| ((pos.x + x).floor(), (pos.y + y).floor())),
365 |                 false,
366 |             );
367 |         }
368 |     }
369 | 
370 |     pub fn get_generation(&self) -> u64 {
371 |         self.data.borrow().generation
372 |     }
373 | }
374 | 


--------------------------------------------------------------------------------
/src/widgets/entry.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2021-2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoTK. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use crate::{EvPayload, Event, InputEvent, MButton, Mutable, Widget};
  6 | use keyboard_types::Key;
  7 | 
  8 | use crate::style::DPIStyle;
  9 | 
 10 | use crate::painter::*;
 11 | use crate::rect::*;
 12 | 
 13 | use std::cell::RefCell;
 14 | use std::rc::Rc;
 15 | 
 16 | pub trait EditableText: Mutable {
 17 |     fn update(&self, changed: String);
 18 |     fn get(&self) -> String;
 19 | }
 20 | 
 21 | #[derive(Debug, Clone)]
 22 | pub struct TextField(Rc<RefCell<(String, u64)>>);
 23 | 
 24 | impl TextField {
 25 |     pub fn new() -> Self {
 26 |         Self(Rc::new(RefCell::new((String::from(""), 0))))
 27 |     }
 28 | 
 29 |     pub fn set(&self, new: String) {
 30 |         let mut tf = self.0.borrow_mut();
 31 |         tf.0 = new;
 32 |         tf.1 += 1;
 33 |     }
 34 | }
 35 | 
 36 | impl Mutable for TextField {
 37 |     fn get_generation(&mut self) -> u64 {
 38 |         let tf = self.0.borrow_mut();
 39 |         tf.1
 40 |     }
 41 | }
 42 | 
 43 | impl EditableText for TextField {
 44 |     fn update(&self, changed: String) {
 45 |         let mut tf = self.0.borrow_mut();
 46 |         tf.0 = changed;
 47 |     }
 48 | 
 49 |     fn get(&self) -> String {
 50 |         let tf = self.0.borrow_mut();
 51 |         tf.0.clone()
 52 |     }
 53 | }
 54 | 
 55 | pub struct Entry {
 56 |     update_text: Box<dyn EditableText>,
 57 |     data: String,
 58 |     data_gen: u64,
 59 |     pre_string: String,
 60 |     post_string: String,
 61 |     cursor: usize,
 62 |     mouse_pos: (f32, f32),
 63 | }
 64 | 
 65 | impl Entry {
 66 |     pub fn new(update_text: Box<dyn EditableText>) -> Self {
 67 |         Self {
 68 |             update_text,
 69 |             data: String::from(""),
 70 |             data_gen: 0,
 71 |             pre_string: String::from(""),
 72 |             post_string: String::from(""),
 73 |             cursor: 0,
 74 |             mouse_pos: (0.0, 0.0),
 75 |         }
 76 |     }
 77 | 
 78 |     pub fn get_generation(&mut self) -> u64 {
 79 |         let cur_data_gen = self.update_text.get_generation();
 80 | 
 81 |         if cur_data_gen != self.data_gen {
 82 |             self.data = self.update_text.get();
 83 |             self.cursor = self.data.len();
 84 |             self.update_cursor();
 85 |             self.data_gen = cur_data_gen;
 86 |         }
 87 | 
 88 |         cur_data_gen
 89 |     }
 90 | 
 91 |     fn update_cursor(&mut self) {
 92 |         self.pre_string = self.data.chars().take(self.cursor).collect();
 93 |         self.post_string = self.data.chars().skip(self.cursor).collect();
 94 |     }
 95 | 
 96 |     pub fn draw(
 97 |         &mut self,
 98 |         w: &Widget,
 99 |         style: &DPIStyle,
100 |         pos: Rect,
101 |         real_pos: Rect,
102 |         p: &mut Painter,
103 |     ) {
104 |         let real_offs = (real_pos.x - pos.x, real_pos.y - pos.y);
105 | 
106 |         p.clip_region(pos.x, pos.y, pos.w, pos.h);
107 |         let is_hovered = w.is_hovered();
108 |         let is_active = w.is_active();
109 | 
110 |         let fh = p.font_height(style.font_size(), true);
111 |         let cur_start_x = p.text_width(style.font_size(), true, &self.pre_string[..]);
112 | 
113 |         let color = if is_active {
114 |             style.active_color()
115 |         } else if is_hovered {
116 |             style.hover_color()
117 |         } else {
118 |             style.color()
119 |         };
120 | 
121 |         let y = ((pos.h - fh) * 0.5).round();
122 | 
123 |         let mut xo = 0.0;
124 |         while (cur_start_x + xo) > 0.75 * pos.w {
125 |             xo -= pos.w * 0.25;
126 |         }
127 |         xo = xo.round();
128 | 
129 |         let mut dbg = w.debug_tag();
130 | 
131 |         p.label_mono(
132 |             style.font_size(),
133 |             -1,
134 |             style.color(),
135 |             pos.x + xo,
136 |             pos.y + y,
137 |             pos.w,
138 |             fh,
139 |             &self.data,
140 |             dbg.offs_src(real_offs, "text"),
141 |         );
142 | 
143 |         p.stroke(
144 |             1.0,
145 |             color,
146 |             &[
147 |                 ((pos.x + cur_start_x + xo).round() + 0.5, pos.y + y),
148 |                 ((pos.x + cur_start_x + xo).round() + 0.5, pos.y + y + fh),
149 |             ],
150 |             false,
151 |         );
152 |         p.reset_clip_region();
153 |     }
154 | 
155 |     pub fn handle(&mut self, w: &Widget, event: &InputEvent, out_events: &mut Vec<(usize, Event)>) {
156 |         let is_hovered = w.is_hovered();
157 |         let is_active = w.is_active();
158 | 
159 |         //d// println!("ENTRY EV: {:?}", event);
160 | 
161 |         let mut changed = false;
162 | 
163 |         match event {
164 |             InputEvent::KeyPressed(key) => {
165 |                 let len = self.data.chars().count();
166 | 
167 |                 if !is_active {
168 |                     return;
169 |                 }
170 | 
171 |                 match &key.key {
172 |                     Key::Character(s) => {
173 |                         self.data = self.pre_string.clone() + &s + &self.post_string;
174 |                         changed = true;
175 |                         self.cursor += 1;
176 |                         self.update_cursor();
177 |                         w.emit_redraw_required();
178 |                     }
179 |                     Key::Home => {
180 |                         self.cursor = 0;
181 |                         self.update_cursor();
182 |                         w.emit_redraw_required();
183 |                     }
184 |                     Key::End => {
185 |                         self.cursor = len;
186 |                         self.update_cursor();
187 |                         w.emit_redraw_required();
188 |                     }
189 |                     Key::Backspace => {
190 |                         if self.cursor > 0 {
191 |                             let spre: String =
192 |                                 self.pre_string.chars().take(self.cursor - 1).collect();
193 |                             changed = true;
194 |                             self.data = spre + &self.post_string;
195 |                             self.cursor -= 1;
196 |                             self.update_cursor();
197 |                             w.emit_redraw_required();
198 |                         }
199 |                     }
200 |                     Key::Delete => {
201 |                         if self.cursor < len {
202 |                             let spost: String = self.post_string.chars().skip(1).collect();
203 |                             changed = true;
204 |                             self.data = self.pre_string.clone() + &spost;
205 |                             self.update_cursor();
206 |                             w.emit_redraw_required();
207 |                         }
208 |                     }
209 |                     Key::ArrowRight => {
210 |                         if (self.cursor + 1) <= len {
211 |                             self.cursor += 1;
212 |                             self.update_cursor();
213 |                             w.emit_redraw_required();
214 |                         }
215 |                     }
216 |                     Key::ArrowLeft => {
217 |                         if self.cursor > 0 {
218 |                             self.cursor -= 1;
219 |                             self.update_cursor();
220 |                             w.emit_redraw_required();
221 |                         }
222 |                     }
223 |                     Key::Enter => {
224 |                         self.update_text.update(self.data.clone());
225 |                         out_events.push(w.event("enter", EvPayload::Text(self.data.clone())));
226 |                     }
227 |                     _ => {}
228 |                 }
229 |             }
230 |             InputEvent::MouseButtonPressed(btn) => {
231 |                 if is_hovered {
232 |                     if *btn == MButton::Left {
233 |                         w.activate();
234 |                         w.emit_redraw_required();
235 |                     }
236 |                 }
237 |             }
238 |             InputEvent::MouseButtonReleased(_btn) => {
239 |                 //                if w.is_active() {
240 |                 //                    let (x, y) = self.mouse_pos;
241 |                 //
242 |                 //                    if *btn == MButton::Left {
243 |                 ////                        w.deactivate();
244 |                 ////                        w.emit_redraw_required();
245 |                 //                    }
246 |                 //                }
247 |             }
248 |             InputEvent::MousePosition(x, y) => {
249 |                 self.mouse_pos = (*x, *y);
250 |             }
251 |             _ => {}
252 |         }
253 | 
254 |         if changed {
255 |             self.update_text.update(self.data.clone());
256 |             out_events.push(w.event("changed", EvPayload::Text(self.data.clone())));
257 |         }
258 |     }
259 | }
260 | 


--------------------------------------------------------------------------------
/src/widgets/graph.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoDSP. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use crate::Widget;
  6 | 
  7 | use crate::style::*;
  8 | 
  9 | use crate::painter::*;
 10 | use crate::rect::*;
 11 | 
 12 | use std::cell::RefCell;
 13 | use std::rc::Rc;
 14 | 
 15 | pub trait GraphModel {
 16 |     fn get_generation(&self) -> u64;
 17 |     fn f(&mut self, init: bool, x: f64, x_next: f64) -> f64;
 18 |     fn vline1_pos(&self) -> Option<f64>;
 19 |     fn vline2_pos(&self) -> Option<f64>;
 20 | }
 21 | 
 22 | #[derive(Debug, Clone)]
 23 | pub struct StaticGraphData {
 24 |     points: Vec<f64>,
 25 |     vline1: Option<f64>,
 26 |     vline2: Option<f64>,
 27 |     generation: u64,
 28 | }
 29 | 
 30 | impl StaticGraphData {
 31 |     pub fn new() -> Self {
 32 |         Self { points: vec![], vline1: None, vline2: None, generation: 0 }
 33 |     }
 34 | 
 35 |     pub fn clear(&mut self) {
 36 |         self.points.clear();
 37 |         self.generation += 1;
 38 |     }
 39 | 
 40 |     pub fn set_vline1(&mut self, x: Option<f64>) {
 41 |         self.vline1 = x;
 42 |         self.generation += 1;
 43 |     }
 44 | 
 45 |     pub fn set_vline2(&mut self, x: Option<f64>) {
 46 |         self.vline2 = x;
 47 |         self.generation += 1;
 48 |     }
 49 | 
 50 |     pub fn set_point(&mut self, i: usize, y: f64) {
 51 |         if self.points.len() <= i {
 52 |             self.points.resize(i + 1, 0.0);
 53 |         }
 54 |         self.points[i] = y;
 55 |         self.generation += 1;
 56 |     }
 57 | }
 58 | 
 59 | impl GraphModel for StaticGraphData {
 60 |     fn get_generation(&self) -> u64 {
 61 |         self.generation
 62 |     }
 63 |     fn f(&mut self, _init: bool, x: f64, _x_next: f64) -> f64 {
 64 |         if self.points.is_empty() {
 65 |             return 0.0;
 66 |         }
 67 | 
 68 |         let x = (self.points.len() - 1) as f64 * x.clamp(0.0, 1.0);
 69 |         let i_start = (x.floor() as usize).clamp(0, self.points.len() - 1);
 70 |         let i_end = (x.ceil() as usize).clamp(0, self.points.len() - 1);
 71 |         let xr = x - x.floor();
 72 | 
 73 |         self.points[i_start] * (1.0 - xr) + self.points[i_end] * xr
 74 |     }
 75 |     fn vline1_pos(&self) -> Option<f64> {
 76 |         self.vline1
 77 |     }
 78 |     fn vline2_pos(&self) -> Option<f64> {
 79 |         self.vline2
 80 |     }
 81 | }
 82 | 
 83 | pub struct Graph {
 84 |     data: Rc<RefCell<dyn GraphModel>>,
 85 |     draw_buf: Vec<(f32, f32)>,
 86 |     live_area: Rect,
 87 |     live_draw: bool,
 88 |     samples: u16,
 89 |     vline1_pos: Option<[(f32, f32); 2]>,
 90 |     vline2_pos: Option<[(f32, f32); 2]>,
 91 | }
 92 | 
 93 | impl Graph {
 94 |     pub fn new(data: Rc<RefCell<dyn GraphModel>>, samples: u16, live_draw: bool) -> Self {
 95 |         Self {
 96 |             live_area: Rect::from(0.0, 0.0, 0.0, 0.0),
 97 |             draw_buf: vec![],
 98 |             vline1_pos: None,
 99 |             vline2_pos: None,
100 |             samples,
101 |             data,
102 |             live_draw,
103 |         }
104 |     }
105 | 
106 |     pub fn get_generation(&self) -> u64 {
107 |         self.data.borrow().get_generation()
108 |     }
109 | 
110 |     fn draw_samples(&mut self, pos: Rect) {
111 |         let samples = self.samples as f64;
112 |         let mut data = self.data.borrow_mut();
113 | 
114 |         let mut x: f64 = 0.0;
115 |         let xd = 1.0 / (samples - 1.0);
116 |         for i in 0..(self.samples as usize) {
117 |             let gx = x * (pos.w as f64);
118 |             let gy = (1.0 - data.f(i == 0, x, x + xd).clamp(0.0, 1.0)) * pos.h as f64;
119 | 
120 |             self.draw_buf[i] = ((pos.x + (gx as f32)), (pos.y + (gy as f32)));
121 | 
122 |             x += xd;
123 |         }
124 | 
125 |         if let Some(x) = data.vline1_pos() {
126 |             let rx = ((pos.w as f64 * x) as f32).round();
127 |             self.vline1_pos = Some([(pos.x + rx, pos.y), (pos.x + rx, pos.y + pos.h)]);
128 |         } else {
129 |             self.vline1_pos = None;
130 |         }
131 | 
132 |         if let Some(x) = data.vline2_pos() {
133 |             let rx = ((pos.w as f64 * x) as f32).round();
134 |             self.vline2_pos = Some([(pos.x + rx, pos.y), (pos.x + rx, pos.y + pos.h)]);
135 |         } else {
136 |             self.vline2_pos = None;
137 |         }
138 |     }
139 | 
140 |     fn draw_graph(&mut self, style: &DPIStyle, p: &mut Painter) {
141 |         let line_color = style.color();
142 |         let line_w = style.graph_line();
143 |         let line1 = style.vline1();
144 |         let line2 = style.vline2();
145 |         let line1_color = style.vline1_color();
146 |         let line2_color = style.vline2_color();
147 | 
148 |         p.path_stroke(line_w, line_color, &mut self.draw_buf.iter().copied(), false);
149 | 
150 |         if let Some(linepos) = &self.vline1_pos {
151 |             p.path_stroke(line1, line1_color, &mut linepos.iter().copied(), false);
152 |         }
153 | 
154 |         if let Some(linepos) = &self.vline2_pos {
155 |             p.path_stroke(line2, line2_color, &mut linepos.iter().copied(), false);
156 |         }
157 |     }
158 | 
159 |     pub fn draw(
160 |         &mut self,
161 |         _w: &Widget,
162 |         style: &DPIStyle,
163 |         pos: Rect,
164 |         real_pos: Rect,
165 |         p: &mut Painter,
166 |     ) {
167 |         self.live_area = real_pos;
168 | 
169 |         if self.draw_buf.len() != (self.samples as usize) {
170 |             self.draw_buf.resize(self.samples as usize, (0.0, 0.0));
171 |         }
172 | 
173 |         let hline = style.hline();
174 |         let hline_color = style.hline_color();
175 | 
176 |         if hline > 0.1 {
177 |             p.path_stroke(
178 |                 hline,
179 |                 hline_color,
180 |                 &mut [
181 |                     (pos.x, (pos.y + pos.h * 0.5).round()),
182 |                     (pos.x + pos.w, (pos.y + pos.h * 0.5).round()),
183 |                 ]
184 |                 .iter()
185 |                 .copied(),
186 |                 false,
187 |             );
188 |         }
189 | 
190 |         if self.live_draw {
191 |             return;
192 |         }
193 | 
194 |         self.draw_samples(pos);
195 |         self.draw_graph(style, p);
196 |     }
197 | 
198 |     pub fn draw_frame(&mut self, _w: &Widget, style: &DPIStyle, p: &mut Painter) {
199 |         if !self.live_draw {
200 |             return;
201 |         }
202 | 
203 |         self.draw_samples(self.live_area);
204 |         self.draw_graph(style, p);
205 |     }
206 | }
207 | 


--------------------------------------------------------------------------------
/src/widgets/graph_minmax.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoDSP. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use crate::style::*;
  6 | use crate::Widget;
  7 | 
  8 | use crate::painter::*;
  9 | use crate::rect::*;
 10 | 
 11 | use std::cell::RefCell;
 12 | use std::rc::Rc;
 13 | 
 14 | const WAVEFORM_SCALE_FACTOR: f32 = 0.9;
 15 | 
 16 | pub trait GraphMinMaxModel {
 17 |     fn read(&mut self, dst: &mut [(f32, f32)]);
 18 |     fn fmt_val(&mut self, buf: &mut [u8]) -> usize;
 19 |     fn get_generation(&self) -> u64;
 20 | }
 21 | 
 22 | #[derive(Debug, Clone)]
 23 | pub struct StaticGraphMinMaxData {
 24 |     minmax: Vec<(f32, f32)>,
 25 |     generation: u64,
 26 | }
 27 | 
 28 | impl StaticGraphMinMaxData {
 29 |     pub fn new() -> Self {
 30 |         Self { minmax: vec![], generation: 0 }
 31 |     }
 32 | 
 33 |     pub fn clear(&mut self) {
 34 |         self.minmax.clear();
 35 |         self.generation += 1;
 36 |     }
 37 | 
 38 |     pub fn set_point(&mut self, i: usize, v: (f32, f32)) {
 39 |         if self.minmax.len() <= i {
 40 |             self.minmax.resize(i + 1, (0.0, 0.0));
 41 |         }
 42 |         self.minmax[i] = v;
 43 |         self.generation += 1;
 44 |     }
 45 | }
 46 | 
 47 | impl GraphMinMaxModel for StaticGraphMinMaxData {
 48 |     fn get_generation(&self) -> u64 {
 49 |         self.generation
 50 |     }
 51 |     fn read(&mut self, dst: &mut [(f32, f32)]) {
 52 |         for i in 0..dst.len() {
 53 |             if i < self.minmax.len() {
 54 |                 dst[i] = self.minmax[i];
 55 |             } else {
 56 |                 dst[i] = (0.0, 0.0);
 57 |             }
 58 |         }
 59 |     }
 60 |     fn fmt_val(&mut self, buf: &mut [u8]) -> usize {
 61 |         use std::io::Write;
 62 |         let max_len = buf.len();
 63 |         let mut bw = std::io::BufWriter::new(buf);
 64 |         match write!(
 65 |             bw,
 66 |             "{:6.3} | {:6.3} | {:6.3}",
 67 |             //                   self.min, self.max, self.avg)
 68 |             -0.1212,
 69 |             0.992343,
 70 |             0.3432
 71 |         ) {
 72 |             Ok(_) => {
 73 |                 if bw.buffer().len() > max_len {
 74 |                     max_len
 75 |                 } else {
 76 |                     bw.buffer().len()
 77 |                 }
 78 |             }
 79 |             Err(_) => 0,
 80 |         }
 81 |     }
 82 | }
 83 | 
 84 | //---------------------------------------------------------------------------
 85 | 
 86 | pub struct GraphMinMax {
 87 |     live_area: Rect,
 88 |     data: Rc<RefCell<dyn GraphMinMaxModel>>,
 89 |     buf: Vec<(f32, f32)>,
 90 |     minmax_buf: Vec<(f32, f32)>,
 91 |     minmax_sample_count: usize,
 92 |     lbl_buf: [u8; 50],
 93 | }
 94 | 
 95 | impl GraphMinMax {
 96 |     pub fn new(data: Rc<RefCell<dyn GraphMinMaxModel>>, minmax_sample_count: usize) -> Self {
 97 |         let mut buf = vec![];
 98 |         buf.resize(2 * minmax_sample_count, (0.0, 0.0));
 99 | 
100 |         let mut minmax_buf = vec![];
101 |         minmax_buf.resize(minmax_sample_count, (0.0, 0.0));
102 | 
103 |         Self {
104 |             live_area: Rect::from(0.0, 0.0, 0.0, 0.0),
105 |             data,
106 |             buf,
107 |             minmax_buf,
108 |             minmax_sample_count,
109 |             lbl_buf: [0; 50],
110 |         }
111 |     }
112 | 
113 |     pub fn get_generation(&self) -> u64 {
114 |         self.data.borrow().get_generation()
115 |     }
116 | 
117 |     pub fn draw(
118 |         &mut self,
119 |         _w: &Widget,
120 |         _style: &DPIStyle,
121 |         _pos: Rect,
122 |         real_pos: Rect,
123 |         _p: &mut Painter,
124 |     ) {
125 |         self.live_area = real_pos;
126 |     }
127 | 
128 |     pub fn draw_frame(&mut self, w: &Widget, style: &DPIStyle, p: &mut Painter) {
129 |         let mut dbg = w.debug_tag();
130 | 
131 |         let line_color = style.color();
132 |         let line_w = style.graph_line();
133 |         let line_c = style.vline1();
134 |         let line_c_color = style.vline1_color();
135 | 
136 |         let pos = self.live_area;
137 |         let mut data = self.data.borrow_mut();
138 | 
139 |         let txt_h = p.font_height(style.font_size() as f32, true);
140 |         let val_pos = pos.resize(pos.w, txt_h);
141 |         let grph_pos = pos.crop_top(txt_h);
142 | 
143 |         data.read(&mut self.minmax_buf[..]);
144 | 
145 |         let xd = 1.0 / (self.minmax_sample_count - 1) as f32;
146 |         let mut x = 0.0;
147 | 
148 |         let mut last_minmax = (-1.0, 1.0);
149 | 
150 |         for i in 0..self.minmax_sample_count {
151 |             let (min, max) = self.minmax_buf[i];
152 | 
153 |             let min = min.clamp(-1.0, 1.0) * WAVEFORM_SCALE_FACTOR;
154 |             let max = max.clamp(-1.0, 1.0) * WAVEFORM_SCALE_FACTOR;
155 |             let min = (min + 1.0) * 0.5;
156 |             let max = (max + 1.0) * 0.5;
157 | 
158 |             // - 1.0 for preventing bleeding into the border.
159 |             let gx = x * (grph_pos.w - 1.0) + 0.5;
160 |             let gy1 = (1.0 - min) * grph_pos.h;
161 |             let gy2 = (1.0 - max) * grph_pos.h;
162 | 
163 |             self.buf[i * 2] = ((grph_pos.x + gx), (grph_pos.y + gy1));
164 | 
165 |             if (last_minmax.1 - 0.00001) <= max {
166 |                 // (probably) Rising edge
167 |                 self.buf[i * 2 + 1] = ((grph_pos.x + gx + 0.5), (grph_pos.y + gy2));
168 |             } else {
169 |                 // (probably) Falling edge
170 |                 self.buf[i * 2 + 1] = ((grph_pos.x + gx - 0.5), (grph_pos.y + gy2));
171 |             }
172 | 
173 |             last_minmax = (min, max);
174 | 
175 |             x += xd;
176 |         }
177 | 
178 |         p.path_stroke(
179 |             line_c,
180 |             line_c_color,
181 |             &mut ([
182 |                 (grph_pos.x, grph_pos.y + grph_pos.h * 0.5),
183 |                 (grph_pos.x + grph_pos.w, grph_pos.y + grph_pos.h * 0.5),
184 |             ]
185 |             .iter()
186 |             .copied()
187 |             .map(|p| (p.0.floor(), p.1.floor() + 0.5))),
188 |             false,
189 |         );
190 | 
191 |         p.path_stroke(
192 |             line_w,
193 |             line_color,
194 |             &mut self.buf.iter().copied().map(|p| (p.0, p.1 + 0.5)),
195 |             false,
196 |         );
197 | 
198 |         let len = data.fmt_val(&mut self.lbl_buf[..]);
199 |         let val_s = std::str::from_utf8(&self.lbl_buf[0..len]).unwrap();
200 |         p.label(
201 |             style.font_size(),
202 |             0,
203 |             style.color(),
204 |             val_pos.x,
205 |             val_pos.y,
206 |             val_pos.w,
207 |             txt_h,
208 |             val_s,
209 |             dbg.source("graph_minmax_label"),
210 |         );
211 |     }
212 | }
213 | 


--------------------------------------------------------------------------------
/src/widgets/list.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoDSP. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use super::ModifierTracker;
  6 | use crate::{EvPayload, Event, InputEvent, MButton, Widget};
  7 | 
  8 | use crate::style::*;
  9 | 
 10 | use crate::painter::*;
 11 | use crate::rect::*;
 12 | 
 13 | use std::cell::RefCell;
 14 | use std::rc::Rc;
 15 | 
 16 | pub trait ListModel {
 17 |     fn len(&self) -> usize;
 18 |     fn fmt_item<'a>(&self, item: usize, buf: &'a mut [u8]) -> Option<usize>;
 19 |     fn selected_item(&self) -> Option<usize>;
 20 |     fn deselect(&mut self);
 21 |     fn select(&mut self, idx: usize);
 22 | 
 23 |     /// Should return the generation counter for the internal data.
 24 |     /// The generation counter should increase for every change on the data.
 25 |     /// This is used by the widget to determine whether they need to be redrawn.
 26 |     fn get_generation(&mut self) -> u64;
 27 | }
 28 | 
 29 | pub struct ListData {
 30 |     items: Vec<String>,
 31 |     selected_item: Option<usize>,
 32 |     generation: u64,
 33 | }
 34 | 
 35 | impl ListData {
 36 |     pub fn new() -> Self {
 37 |         Self { items: vec![], generation: 0, selected_item: None }
 38 |     }
 39 | 
 40 |     pub fn clear(&mut self) {
 41 |         self.items.clear();
 42 |         self.selected_item = None;
 43 |         self.generation += 1;
 44 |     }
 45 | 
 46 |     pub fn push(&mut self, item: String) {
 47 |         self.items.push(item);
 48 |         self.generation += 1;
 49 |     }
 50 | 
 51 |     pub fn generation(&self) -> u64 {
 52 |         self.generation
 53 |     }
 54 | }
 55 | 
 56 | impl ListModel for ListData {
 57 |     fn len(&self) -> usize {
 58 |         self.items.len()
 59 |     }
 60 |     fn selected_item(&self) -> Option<usize> {
 61 |         self.selected_item
 62 |     }
 63 | 
 64 |     fn deselect(&mut self) {
 65 |         self.selected_item = None;
 66 |         self.generation += 1;
 67 |     }
 68 | 
 69 |     fn select(&mut self, idx: usize) {
 70 |         if idx < self.items.len() {
 71 |             self.selected_item = Some(idx);
 72 |             self.generation += 1;
 73 |         }
 74 |     }
 75 | 
 76 |     fn fmt_item<'a>(&self, index: usize, buf: &'a mut [u8]) -> Option<usize> {
 77 |         let item = self.items.get(index)?;
 78 | 
 79 |         use std::io::Write;
 80 |         let mut bw = std::io::BufWriter::new(buf);
 81 |         match write!(bw, "{}", item) {
 82 |             Ok(_) => Some(bw.buffer().len()),
 83 |             Err(_) => Some(0),
 84 |         }
 85 |     }
 86 |     fn get_generation(&mut self) -> u64 {
 87 |         self.generation
 88 |     }
 89 | }
 90 | 
 91 | #[derive(Debug, Clone, PartialEq)]
 92 | pub enum ListScrollMode {
 93 |     ItemCentered,
 94 |     Detached,
 95 | }
 96 | 
 97 | pub struct List {
 98 |     item_buf: [u8; 256],
 99 |     model: Rc<RefCell<dyn ListModel>>,
100 |     real_pos: Rect,
101 |     modkeys: ModifierTracker,
102 |     hover: Option<i32>,
103 |     item_areas: Vec<(i32, Rect)>,
104 |     shown_item_count: usize,
105 |     scroll_mode: ListScrollMode,
106 |     scroll_page: usize,
107 | }
108 | 
109 | impl List {
110 |     pub fn new(model: Rc<RefCell<dyn ListModel>>, scroll_mode: ListScrollMode) -> Self {
111 |         Self {
112 |             model,
113 |             item_buf: [0; 256],
114 |             real_pos: Rect::from(0.0, 0.0, 0.0, 0.0),
115 |             modkeys: ModifierTracker::new(),
116 |             hover: None,
117 |             item_areas: vec![],
118 |             shown_item_count: 0,
119 |             scroll_mode,
120 |             scroll_page: 0,
121 |         }
122 |     }
123 | 
124 |     fn mouse_zone(&self) -> Option<i32> {
125 |         self.zone(self.modkeys.mouse.x, self.modkeys.mouse.y)
126 |     }
127 | 
128 |     fn zone(&self, x: f32, y: f32) -> Option<i32> {
129 |         for ia in self.item_areas.iter() {
130 |             if ia.1.is_inside(x, y) {
131 |                 return Some(ia.0 as i32);
132 |             }
133 |         }
134 | 
135 |         None
136 |     }
137 | 
138 |     pub fn get_generation(&mut self) -> u64 {
139 |         self.model.borrow_mut().get_generation()
140 |     }
141 | 
142 |     pub fn calc_row_offs(&self, rows: usize, sel_item: i64) -> usize {
143 |         let rows = rows as i64;
144 |         let mut cur = sel_item;
145 | 
146 |         let margin = rows / 3;
147 |         let margin = (margin / 2) * 2;
148 |         let page_rows = rows - margin;
149 | 
150 |         if page_rows <= 0 {
151 |             return cur as usize;
152 |         }
153 | 
154 |         let mut scroll_page = 0;
155 | 
156 |         while cur >= page_rows {
157 |             cur -= page_rows;
158 |             scroll_page += 1;
159 |         }
160 | 
161 |         if scroll_page > 0 {
162 |             (scroll_page * page_rows - (margin / 2)) as usize
163 |         } else {
164 |             0
165 |         }
166 |     }
167 | 
168 |     fn handle_scroll(&mut self, w: &Widget, zone: i32, out_events: &mut Vec<(usize, Event)>) {
169 |         let item_count = self.model.borrow_mut().len();
170 |         let page_offs = self.shown_item_count / 2;
171 | 
172 |         match self.scroll_mode {
173 |             ListScrollMode::ItemCentered => match zone {
174 |                 -1 => {
175 |                     let mut cur =
176 |                         self.model.borrow_mut().selected_item().unwrap_or(0);
177 |                     if cur < page_offs {
178 |                         cur = 0;
179 |                     } else {
180 |                         cur -= page_offs;
181 |                     }
182 | 
183 |                     self.model.borrow_mut().select(cur);
184 |                     out_events.push(w.event(
185 |                         "select",
186 |                         EvPayload::ItemSelect { index: cur as i32 },
187 |                     ));
188 |                 }
189 |                 -2 => {
190 |                     let mut cur =
191 |                         self.model.borrow_mut().selected_item().unwrap_or(0);
192 |                     if cur == 0 {
193 |                         cur = item_count - 1;
194 |                     } else {
195 |                         cur = (cur - 1) % item_count;
196 |                     }
197 |                     self.model.borrow_mut().select(cur);
198 |                     out_events.push(w.event(
199 |                         "select",
200 |                         EvPayload::ItemSelect { index: cur as i32 },
201 |                     ));
202 |                 }
203 |                 -3 => {
204 |                     let mut cur =
205 |                         self.model.borrow_mut().selected_item().unwrap_or(0);
206 |                     cur = (cur + 1) % item_count;
207 |                     self.model.borrow_mut().select(cur);
208 |                     out_events.push(w.event(
209 |                         "select",
210 |                         EvPayload::ItemSelect { index: cur as i32 },
211 |                     ));
212 |                 }
213 |                 -4 => {
214 |                     let mut cur =
215 |                         self.model.borrow_mut().selected_item().unwrap_or(0);
216 |                     cur += page_offs;
217 |                     if item_count > 0 {
218 |                         cur = cur.min(item_count - 1);
219 |                     } else {
220 |                         cur = 0;
221 |                     }
222 | 
223 |                     self.model.borrow_mut().select(cur);
224 |                     out_events.push(w.event(
225 |                         "select",
226 |                         EvPayload::ItemSelect { index: cur as i32 },
227 |                     ));
228 |                 }
229 |                 _ => {}
230 |             },
231 |             ListScrollMode::Detached => match zone {
232 |                 -1 => {
233 |                     if self.scroll_page > 0 {
234 |                         self.scroll_page -= 1;
235 |                     }
236 |                 }
237 |                 -4 => {
238 |                     self.scroll_page += 1;
239 |                 }
240 |                 _ => {}
241 |             },
242 |         };
243 |     }
244 | 
245 |     pub fn handle(&mut self, w: &Widget, event: &InputEvent, out_events: &mut Vec<(usize, Event)>) {
246 |         let is_hovered = w.is_hovered();
247 | 
248 |         self.modkeys.handle(event);
249 | 
250 |         match event {
251 |             InputEvent::MouseButtonPressed(MButton::Left) => {
252 |                 if !is_hovered {
253 |                     return;
254 |                 }
255 |                 if self.mouse_zone().is_some() {
256 |                     w.activate();
257 |                     w.emit_redraw_required();
258 |                 }
259 |             }
260 |             InputEvent::MouseButtonReleased(MButton::Left) => {
261 |                 if w.is_active() {
262 |                     if let Some(zone) = self.mouse_zone() {
263 |                         if zone >= 0 {
264 |                             self.model.borrow_mut().select(zone as usize);
265 |                             out_events
266 |                                 .push(w.event("select", EvPayload::ItemSelect { index: zone }));
267 |                         } else {
268 |                             self.handle_scroll(w, zone, out_events);
269 |                         }
270 |                     }
271 | 
272 |                     w.emit_redraw_required();
273 |                     w.deactivate();
274 |                 }
275 |             }
276 |             InputEvent::MouseWheel(y) => {
277 |                 if !is_hovered {
278 |                     self.hover = None;
279 |                     return;
280 |                 }
281 |                 if *y < 0.0 {
282 |                     self.handle_scroll(w, -4, out_events);
283 |                 } else {
284 |                     self.handle_scroll(w, -1, out_events);
285 |                 }
286 |                 w.emit_redraw_required();
287 |             },
288 |             InputEvent::MousePosition(_x, _y) => {
289 |                 if !is_hovered {
290 |                     self.hover = None;
291 |                     return;
292 |                 }
293 | 
294 |                 let old_hover = self.hover;
295 |                 self.hover = self.mouse_zone();
296 | 
297 |                 if old_hover != self.hover {
298 |                     w.emit_redraw_required();
299 |                 }
300 |             }
301 |             _ => {}
302 |         }
303 |     }
304 | 
305 |     pub fn draw(
306 |         &mut self,
307 |         w: &Widget,
308 |         style: &DPIStyle,
309 |         pos: Rect,
310 |         real_pos: Rect,
311 |         p: &mut Painter,
312 |     ) {
313 |         let is_hovered = w.is_hovered();
314 |         let is_active = w.is_active();
315 | 
316 |         let dpi_f = p.dpi_factor;
317 |         let mut dbg = w.debug_tag();
318 |         let (dx, dy) = (real_pos.x - pos.x, real_pos.y - pos.y);
319 |         dbg.set_offs((dx, dy));
320 |         self.real_pos = real_pos;
321 | 
322 |         let fh = p.font_height(style.font_size(), true);
323 | 
324 |         let pad = style.pad_item();
325 | 
326 |         let button_width = 30.0 * dpi_f;
327 | 
328 |         let buttons_pos = pos.crop_left(pos.w - button_width);
329 |         let list_pos = pos.crop_right(button_width);
330 | 
331 |         let button_h = buttons_pos.h / 4.0;
332 | 
333 |         self.item_areas.clear();
334 | 
335 |         let mut draw_button = |index: usize| {
336 |             let zone_idx = (index + 1) as i32 * -1;
337 |             let mut color = style.border_color();
338 | 
339 |             if let Some(hover_idx) = self.hover {
340 |                 if hover_idx == zone_idx {
341 |                     if is_active {
342 |                         color = style.active_border_color();
343 |                     } else {
344 |                         color = style.hover_border_color();
345 |                     }
346 |                 }
347 |             }
348 | 
349 |             let y = button_h.floor() * (index as f32);
350 |             let pos = Rect::from(buttons_pos.x, buttons_pos.y + y, buttons_pos.w, button_h.floor());
351 |             p.rect_border_fill_r(style.border2(), color, style.bg_color(), pos);
352 | 
353 |             let lbl = match index {
354 |                 0 => "⇑",
355 |                 1 => "↑",
356 |                 2 => "↓",
357 |                 3 => "⇓",
358 |                 _ => "↑",
359 |             };
360 | 
361 |             p.label(
362 |                 style.font_size() * 2.0,
363 |                 0,
364 |                 color,
365 |                 pos.x,
366 |                 pos.y,
367 |                 pos.w,
368 |                 pos.h,
369 |                 lbl,
370 |                 dbg.source("button"),
371 |             );
372 | 
373 |             self.item_areas.push((zone_idx, pos.offs(dx, dy)));
374 |         };
375 | 
376 |         draw_button(0);
377 |         if self.scroll_mode != ListScrollMode::Detached {
378 |             draw_button(1);
379 |             draw_button(2);
380 |         }
381 |         draw_button(3);
382 | 
383 |         let line_height = 2.0 * pad + style.border2() + fh;
384 |         let visible_lines = (list_pos.h / line_height).ceil() as usize;
385 |         let dh = line_height;
386 |         self.shown_item_count = visible_lines;
387 | 
388 |         let model = self.model.borrow_mut();
389 |         //let item_count = model.len();
390 |         let scroll_offs = match self.scroll_mode {
391 |             ListScrollMode::ItemCentered => {
392 |                 self.calc_row_offs(visible_lines, model.selected_item().unwrap_or(0) as i64)
393 |             }
394 |             ListScrollMode::Detached => {
395 |                 let page_len = self.shown_item_count / 2;
396 |                 let max_page = model.len() / page_len;
397 |                 //d// println!("PAGE_LEN={}, max_page={}, vislines={}, items={}",
398 |                 //d//     page_len, max_page, visible_lines, item_count);
399 |                 if self.scroll_page > max_page {
400 |                     self.scroll_page = max_page;
401 |                 }
402 |                 let offs = self.scroll_page * page_len;
403 | 
404 |                 offs
405 |             }
406 |         };
407 | 
408 |         let selected_item = model.selected_item();
409 | 
410 |         p.clip_region(list_pos.x, list_pos.y, list_pos.w, list_pos.h);
411 |         let mut y: f32 = 0.0;
412 |         for row_idx in 0..visible_lines {
413 |             let item_idx = row_idx + scroll_offs;
414 | 
415 |             let yd = y.round();
416 |             p.stroke(
417 |                 style.border2(),
418 |                 style.color2(),
419 |                 &[(list_pos.x, list_pos.y + yd), (list_pos.x + list_pos.w, list_pos.y + yd)],
420 |                 false,
421 |             );
422 | 
423 |             if let Some(len) = model.fmt_item(item_idx, &mut self.item_buf[..]) {
424 |                 let mut item_pos = list_pos;
425 |                 item_pos.y += yd;
426 |                 item_pos.h = dh;
427 |                 let item_outer = item_pos;
428 |                 let item_pos = item_pos.shrink(pad, pad);
429 | 
430 |                 let mut color = style.color();
431 |                 if Some(item_idx) == selected_item {
432 |                     color = style.selected_color();
433 |                 }
434 |                 if is_hovered {
435 |                     if let Some(hover_idx) = self.hover {
436 |                         if hover_idx >= 0 {
437 |                             if hover_idx == (item_idx as i32) {
438 |                                 if is_active {
439 |                                     color = style.active_color();
440 |                                 } else {
441 |                                     color = style.hover_color();
442 |                                 }
443 |                             }
444 |                         }
445 |                     }
446 |                 }
447 | 
448 |                 let item_s = std::str::from_utf8(&self.item_buf[0..len]).unwrap();
449 |                 p.label(
450 |                     style.font_size(),
451 |                     -1,
452 |                     color,
453 |                     item_pos.x,
454 |                     item_pos.y,
455 |                     item_pos.w,
456 |                     item_pos.h,
457 |                     item_s,
458 |                     dbg.source("item"),
459 |                 );
460 | 
461 |                 self.item_areas.push((item_idx as i32, item_outer.offs(dx, dy)));
462 |             }
463 | 
464 |             y += dh;
465 |         }
466 |         p.reset_clip_region();
467 |     }
468 | }
469 | 


--------------------------------------------------------------------------------
/src/widgets/mod.rs:
--------------------------------------------------------------------------------
 1 | mod blockcode;
 2 | mod connector;
 3 | mod entry;
 4 | mod graph;
 5 | mod graph_minmax;
 6 | mod hexgrid;
 7 | mod hexknob;
 8 | mod octave_keys;
 9 | mod pattern_editor;
10 | mod scope;
11 | mod wichtext;
12 | mod list;
13 | 
14 | pub use blockcode::{BlockCode, BlockPos};
15 | pub use connector::{Connector, ConnectorData};
16 | pub use entry::{EditableText, Entry, TextField};
17 | pub use graph::{Graph, GraphModel, StaticGraphData};
18 | pub use graph_minmax::{GraphMinMax, GraphMinMaxModel, StaticGraphMinMaxData};
19 | pub use hexgrid::{HexCell, HexDir, HexEdge, HexGrid, HexGridModel, HexHLight};
20 | pub use hexknob::{ChangeRes, DummyParamModel, HexKnob, ParamModel};
21 | pub use octave_keys::{DummyOctaveKeysData, OctaveKeys, OctaveKeysModel};
22 | pub use pattern_editor::{
23 |     PatternData, PatternEditor, PatternEditorFeedback, PatternEditorFeedbackDummy, UIPatternModel,
24 | };
25 | pub use scope::{Scope, ScopeModel, StaticScopeData, SCOPE_SAMPLES};
26 | pub use wichtext::{WichText, WichTextData, WichTextSimpleDataStore};
27 | pub use list::{List, ListModel, ListData, ListScrollMode};
28 | 
29 | use keyboard_types::Key;
30 | 
31 | #[derive(Debug)]
32 | pub struct ModifierTracker {
33 |     pub ctrl: bool,
34 |     pub shift: bool,
35 |     pub mouse: crate::rect::Rect,
36 | }
37 | 
38 | impl ModifierTracker {
39 |     pub fn new() -> Self {
40 |         Self { ctrl: false, shift: false, mouse: crate::rect::Rect::from(0.0, 0.0, 0.0, 0.0) }
41 |     }
42 | 
43 |     pub fn handle(&mut self, event: &crate::InputEvent) {
44 |         match event {
45 |             crate::InputEvent::KeyPressed(key) => match key.key {
46 |                 Key::Shift => {
47 |                     self.shift = true;
48 |                 }
49 |                 Key::Control => {
50 |                     self.ctrl = true;
51 |                 }
52 |                 _ => {}
53 |             },
54 |             crate::InputEvent::KeyReleased(key) => match key.key {
55 |                 Key::Shift => {
56 |                     self.shift = false;
57 |                 }
58 |                 Key::Control => {
59 |                     self.ctrl = false;
60 |                 }
61 |                 _ => {}
62 |             },
63 |             crate::InputEvent::MousePosition(x, y) => {
64 |                 self.mouse.x = *x;
65 |                 self.mouse.y = *y;
66 |             }
67 |             _ => {}
68 |         }
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/widgets/octave_keys.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2021 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoDSP. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use crate::{EvPayload, Event, InputEvent, MButton, Widget};
  6 | 
  7 | use crate::style::*;
  8 | 
  9 | use crate::painter::*;
 10 | use crate::rect::*;
 11 | 
 12 | use std::cell::RefCell;
 13 | use std::rc::Rc;
 14 | 
 15 | pub const UI_GRPH_BORDER_CLR: (f32, f32, f32) = UI_ACCENT_CLR;
 16 | pub const UI_GRPH_LINE_CLR: (f32, f32, f32) = UI_PRIM_CLR;
 17 | pub const UI_GRPH_PHASE_CLR: (f32, f32, f32) = UI_SELECT_CLR;
 18 | pub const UI_GRPH_PHASE_BG_CLR: (f32, f32, f32) = UI_HLIGHT2_CLR;
 19 | pub const UI_GRPH_BG: (f32, f32, f32) = UI_LBL_BG_CLR;
 20 | 
 21 | pub trait OctaveKeysModel {
 22 |     fn key_mask(&self) -> i64;
 23 |     fn phase_value(&self) -> f64;
 24 |     fn get_generation(&self) -> u64;
 25 |     fn change(&mut self, new_mask: i64);
 26 | }
 27 | 
 28 | #[derive(Debug, Clone)]
 29 | pub struct DummyOctaveKeysData {
 30 |     key_mask: i64,
 31 |     generation: u64,
 32 | }
 33 | 
 34 | impl DummyOctaveKeysData {
 35 |     pub fn new() -> Self {
 36 |         Self { key_mask: 0x0, generation: 0 }
 37 |     }
 38 | 
 39 |     pub fn clear(&mut self) {
 40 |         self.key_mask = 0;
 41 |         self.generation += 1;
 42 |     }
 43 | 
 44 |     pub fn set_key_mask(&mut self, mask: i64) {
 45 |         self.key_mask = mask;
 46 |         self.generation += 1;
 47 |     }
 48 | }
 49 | 
 50 | impl OctaveKeysModel for DummyOctaveKeysData {
 51 |     fn key_mask(&self) -> i64 {
 52 |         self.key_mask
 53 |     }
 54 |     fn phase_value(&self) -> f64 {
 55 |         0.0
 56 |     }
 57 |     fn get_generation(&self) -> u64 {
 58 |         self.generation
 59 |     }
 60 |     fn change(&mut self, new: i64) {
 61 |         self.key_mask = new;
 62 |     }
 63 | }
 64 | 
 65 | pub struct OctaveKeys {
 66 |     data: Rc<RefCell<dyn OctaveKeysModel>>,
 67 |     key_areas: Vec<(usize, Rect)>,
 68 |     hover_index: Option<usize>,
 69 |     mouse_pos: (f32, f32),
 70 | }
 71 | 
 72 | impl OctaveKeys {
 73 |     pub fn new(data: Rc<RefCell<dyn OctaveKeysModel>>) -> Self {
 74 |         Self { data, key_areas: vec![], hover_index: None, mouse_pos: (0.0, 0.0) }
 75 |     }
 76 | 
 77 |     pub fn get_generation(&self) -> u64 {
 78 |         self.data.borrow().get_generation()
 79 |     }
 80 | 
 81 |     fn get_key_index_at(&self, x: f32, y: f32) -> Option<usize> {
 82 |         let mut ret = None;
 83 | 
 84 |         for (idx, area) in &self.key_areas {
 85 |             if area.is_inside(x, y) {
 86 |                 ret = Some(*idx);
 87 |             }
 88 |         }
 89 | 
 90 |         ret
 91 |     }
 92 | }
 93 | 
 94 | fn draw_key(
 95 |     p: &mut Painter,
 96 |     key_mask: i64,
 97 |     key: &Rect,
 98 |     hover_idx: Option<usize>,
 99 |     index: usize,
100 |     phase_index: usize,
101 | ) {
102 |     let key_is_set = key_mask & (0x1 << index) > 0;
103 | 
104 |     let mut hover_this_key = false;
105 |     if let Some(hover_idx) = hover_idx {
106 |         hover_this_key = hover_idx == index;
107 |     }
108 | 
109 |     let (mut bg_color, mut line_color) = if key_is_set {
110 |         if hover_this_key {
111 |             (UI_GRPH_PHASE_BG_CLR, UI_GRPH_BG)
112 |         } else {
113 |             (UI_GRPH_LINE_CLR, UI_GRPH_BG)
114 |         }
115 |     } else if hover_this_key {
116 |         (UI_GRPH_PHASE_BG_CLR, UI_GRPH_BG)
117 |     } else {
118 |         (UI_GRPH_BG, UI_GRPH_LINE_CLR)
119 |     };
120 | 
121 |     if phase_index == index {
122 |         if key_is_set {
123 |             bg_color = UI_GRPH_PHASE_CLR;
124 |         } else {
125 |             bg_color = UI_GRPH_BORDER_CLR;
126 |         }
127 | 
128 |         line_color = UI_GRPH_BG;
129 |     }
130 | 
131 |     let key_border = p.dpi_factor * 1.0;
132 | 
133 |     p.rect_fill(line_color, key.x, key.y, key.w, key.h);
134 |     let k2 = key.shrink(key_border, key_border);
135 |     p.rect_fill(bg_color, k2.x, k2.y, k2.w, k2.h);
136 | }
137 | 
138 | impl OctaveKeys {
139 |     pub fn handle(&mut self, w: &Widget, event: &InputEvent, out_events: &mut Vec<(usize, Event)>) {
140 |         match event {
141 |             InputEvent::MouseButtonPressed(MButton::Left) => {
142 |                 if !w.is_hovered() {
143 |                     return;
144 |                 }
145 | 
146 |                 w.activate();
147 |                 w.emit_redraw_required();
148 |             }
149 |             InputEvent::MouseButtonReleased(MButton::Left) => {
150 |                 if !w.is_active() {
151 |                     return;
152 |                 }
153 | 
154 |                 let (x, y) = self.mouse_pos;
155 | 
156 |                 if let Some(key_idx) = self.get_key_index_at(x, y) {
157 |                     let mut new_key_mask = self.data.borrow().key_mask();
158 |                     if key_idx < 64 {
159 |                         new_key_mask ^= 0x1 << key_idx;
160 |                     }
161 | 
162 |                     self.data.borrow_mut().change(new_key_mask);
163 |                     out_events.push(w.event("changed", EvPayload::KeyMask(new_key_mask)));
164 |                 }
165 | 
166 |                 w.deactivate();
167 |                 w.emit_redraw_required();
168 |             }
169 |             InputEvent::MousePosition(x, y) => {
170 |                 self.mouse_pos = (*x, *y);
171 | 
172 |                 let old_hover = self.hover_index;
173 |                 self.hover_index = self.get_key_index_at(*x, *y);
174 | 
175 |                 if old_hover != self.hover_index {
176 |                     w.emit_redraw_required();
177 |                 }
178 |             }
179 |             _ => {}
180 |         }
181 |     }
182 | 
183 |     pub fn draw(
184 |         &mut self,
185 |         w: &Widget,
186 |         _style: &DPIStyle,
187 |         pos: Rect,
188 |         real_pos: Rect,
189 |         _p: &mut Painter,
190 |     ) {
191 |         let mut dbg = w.debug_tag();
192 |         let rp_offset = (real_pos.x - pos.x, real_pos.y - pos.y);
193 |         dbg.set_offs(rp_offset);
194 | 
195 |         // let border_color =
196 |         //     if state.hovered == entity { UI_GRPH_BORDER_HOVER_CLR }
197 |         //     else { UI_GRPH_BORDER_CLR };
198 | 
199 |         let xd = (pos.w / 7.0).floor();
200 |         let xd_pad_for_center = ((pos.w - xd * 7.0) * 0.5).floor();
201 |         let pos = pos.shrink(xd_pad_for_center, 0.0).round();
202 | 
203 |         let xoffs_w = [
204 |             (0, 0.0 * xd),  // white C
205 |             (2, 1.0 * xd),  // white D
206 |             (4, 2.0 * xd),  // white E
207 |             (5, 3.0 * xd),  // white F
208 |             (7, 4.0 * xd),  // white G
209 |             (9, 5.0 * xd),  // white A
210 |             (11, 6.0 * xd), // white B
211 |         ];
212 | 
213 |         let xoffs_b = [
214 |             (1, 1.0 * xd),  // black C#
215 |             (3, 2.0 * xd),  // black D#
216 |             (6, 4.0 * xd),  // black F#
217 |             (8, 5.0 * xd),  // black G#
218 |             (10, 6.0 * xd), // black A#
219 |         ];
220 | 
221 |         self.key_areas.clear();
222 |         for xw in xoffs_w.iter() {
223 |             let key = Rect { x: pos.x + (*xw).1, y: pos.y, w: xd, h: pos.h };
224 | 
225 |             //            draw_key(p, key_mask, key, hover_idx, (*xw).0, phase_index);
226 |             self.key_areas.push(((*xw).0, key.offs(rp_offset.0, rp_offset.1)));
227 |         }
228 | 
229 |         let black_width = (xd * 0.75).round();
230 |         let black_width =
231 |             if (black_width as i64) % 2 == 1 { black_width + 1.0 } else { black_width };
232 | 
233 |         for xb in xoffs_b.iter() {
234 |             let key = Rect {
235 |                 x: pos.x + (*xb).1 - black_width * 0.5,
236 |                 y: pos.y,
237 |                 w: black_width,
238 |                 h: pos.h * 0.5,
239 |             };
240 | 
241 |             //            draw_key(p, key_mask, key, hover_idx, (*xb).0, phase_index);
242 |             self.key_areas.push(((*xb).0, key.offs(rp_offset.0, rp_offset.1)));
243 |         }
244 |     }
245 | 
246 |     pub fn draw_frame(&mut self, w: &Widget, _style: &DPIStyle, painter: &mut Painter) {
247 |         let phase = self.data.borrow().phase_value();
248 |         let phase_index = (phase * 12.0).floor() as usize;
249 | 
250 |         let mut hover_idx = self.hover_index;
251 |         if !w.is_hovered() {
252 |             hover_idx = None;
253 |         }
254 | 
255 |         let key_mask = self.data.borrow().key_mask();
256 | 
257 |         for (index, key) in self.key_areas.iter() {
258 |             draw_key(painter, key_mask, key, hover_idx, *index, phase_index);
259 |         }
260 |     }
261 | }
262 | 


--------------------------------------------------------------------------------
/src/widgets/scope.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2022 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoDSP. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use crate::Widget;
  6 | 
  7 | use crate::style::*;
  8 | 
  9 | use crate::painter::*;
 10 | use crate::rect::*;
 11 | 
 12 | use std::cell::RefCell;
 13 | use std::rc::Rc;
 14 | 
 15 | pub const SCOPE_SAMPLES: usize = 512;
 16 | 
 17 | pub trait ScopeModel {
 18 |     fn signal_count(&self) -> usize;
 19 |     fn signal_len(&self) -> usize;
 20 |     fn get(&self, sig: usize, idx: usize) -> (f32, f32);
 21 |     fn get_offs_gain(&self, sig: usize) -> (f32, f32);
 22 |     fn get_threshold(&self) -> Option<f32>;
 23 |     fn is_active(&self, sig: usize) -> bool;
 24 |     fn fmt_val(&self, sig: usize, buf: &mut [u8]) -> usize;
 25 | }
 26 | 
 27 | #[derive(Debug, Clone)]
 28 | pub struct StaticScopeData {
 29 |     samples: Vec<Vec<f32>>,
 30 | }
 31 | 
 32 | impl StaticScopeData {
 33 |     pub fn new() -> Self {
 34 |         let mut v = vec![];
 35 |         v.push(vec![0.0; SCOPE_SAMPLES]);
 36 |         v.push(vec![0.0; SCOPE_SAMPLES]);
 37 |         v.push(vec![0.0; SCOPE_SAMPLES]);
 38 |         Self { samples: v }
 39 |     }
 40 | 
 41 |     pub fn clear(&mut self) {
 42 |         self.samples[0].clear();
 43 |         self.samples[1].clear();
 44 |         self.samples[2].clear();
 45 |     }
 46 | 
 47 |     pub fn set_sample(&mut self, sig: usize, i: usize, y: f32) {
 48 |         if self.samples[sig].len() <= i {
 49 |             self.samples[sig].resize(i + 1, 0.0);
 50 |         }
 51 |         self.samples[sig][i] = y;
 52 |     }
 53 | }
 54 | 
 55 | impl ScopeModel for StaticScopeData {
 56 |     fn signal_count(&self) -> usize {
 57 |         3
 58 |     }
 59 |     fn signal_len(&self) -> usize {
 60 |         self.samples.len()
 61 |     }
 62 |     fn get(&self, sig: usize, idx: usize) -> (f32, f32) {
 63 |         let v = self.samples[sig][idx];
 64 |         (v, v)
 65 |     }
 66 |     fn get_offs_gain(&self, sig: usize) -> (f32, f32) {
 67 |         if sig == 0 {
 68 |             (0.0, 1.0)
 69 |         } else if sig == 1 {
 70 |             (0.25, 0.25)
 71 |         } else {
 72 |             (-0.25, 0.25)
 73 |         }
 74 |     }
 75 |     fn get_threshold(&self) -> Option<f32> {
 76 |         Some(0.9)
 77 |     }
 78 |     fn is_active(&self, _sig: usize) -> bool {
 79 |         true
 80 |     }
 81 |     fn fmt_val(&self, sig: usize, buf: &mut [u8]) -> usize {
 82 |         use std::io::Write;
 83 |         let max_len = buf.len();
 84 |         let mut bw = std::io::BufWriter::new(buf);
 85 |         match write!(
 86 |             bw,
 87 |             "{} min: {:6.3} max: {:6.3} rng: {:6.3}",
 88 |             //                   self.min, self.max, self.avg)
 89 |             sig,
 90 |             -0.1212,
 91 |             0.992343,
 92 |             0.3432
 93 |         ) {
 94 |             Ok(_) => {
 95 |                 if bw.buffer().len() > max_len {
 96 |                     max_len
 97 |                 } else {
 98 |                     bw.buffer().len()
 99 |                 }
100 |             }
101 |             Err(_) => 0,
102 |         }
103 |     }
104 | }
105 | 
106 | pub struct Scope {
107 |     draw_buf: Vec<[(f32, f32); 2 * SCOPE_SAMPLES]>,
108 |     data: Rc<RefCell<dyn ScopeModel>>,
109 |     live_area: Rect,
110 |     lbl_buf: [u8; 50],
111 |     txt_h: f32,
112 | }
113 | 
114 | impl Scope {
115 |     pub fn new(data: Rc<RefCell<dyn ScopeModel>>) -> Self {
116 |         Self {
117 |             data,
118 |             draw_buf: vec![],
119 |             live_area: Rect::from(0.0, 0.0, 0.0, 0.0),
120 |             lbl_buf: [0; 50],
121 |             txt_h: 0.0,
122 |         }
123 |     }
124 | 
125 |     pub fn get_generation(&self) -> u64 {
126 |         0
127 |     }
128 | 
129 |     fn draw_samples(&mut self, style: &DPIStyle, pos: Rect) {
130 |         let line_w = style.graph_line();
131 |         let line1 = style.vline1();
132 |         let line2 = style.vline2();
133 |         let data = self.data.borrow();
134 | 
135 |         for (sig_idx, buf) in self.draw_buf.iter_mut().enumerate() {
136 |             let (offs, gain) = data.get_offs_gain(sig_idx);
137 | 
138 |             if !data.is_active(sig_idx) {
139 |                 continue;
140 |             }
141 | 
142 |             let line_w = match sig_idx {
143 |                 1 => line1,
144 |                 2 => line2,
145 |                 _ => line_w,
146 |             };
147 | 
148 |             for i in 0..SCOPE_SAMPLES {
149 |                 let (max, min) = data.get(sig_idx, i);
150 | 
151 |                 let gx = (i as f32 * self.live_area.w) / (SCOPE_SAMPLES as f32);
152 | 
153 |                 let gy_max = (1.0 - ((max * gain + offs) * 0.5 + 0.5)) * pos.h - 0.5 * line_w;
154 |                 let gy_min = (1.0 - ((min * gain + offs) * 0.5 + 0.5)) * pos.h + 0.5 * line_w;
155 | 
156 |                 buf[i] = ((pos.x + (gx as f32)), (pos.y + (gy_max as f32)));
157 |                 buf[SCOPE_SAMPLES + (SCOPE_SAMPLES - (i + 1))] =
158 |                     ((pos.x + (gx as f32)), (pos.y + (gy_min as f32)));
159 |             }
160 |         }
161 |     }
162 | 
163 |     fn draw_graph(&mut self, style: &DPIStyle, pos: Rect, p: &mut Painter) {
164 |         let data = self.data.borrow();
165 | 
166 |         let line_color = style.color();
167 |         let line1_color = style.vline1_color();
168 |         let line2_color = style.vline2_color();
169 |         let hline = style.hline();
170 |         let hline_color = style.hline_color();
171 | 
172 |         for (i, buf) in self.draw_buf.iter().enumerate().rev() {
173 |             if !data.is_active(i) {
174 |                 continue;
175 |             }
176 | 
177 |             let color = match i {
178 |                 1 => line1_color,
179 |                 2 => line2_color,
180 |                 _ => line_color,
181 |             };
182 | 
183 |             let (offs, _) = data.get_offs_gain(i);
184 |             if offs.abs() > 0.001 {
185 |                 p.path_stroke(
186 |                     hline,
187 |                     darken_clr(2, color),
188 |                     &mut [
189 |                         (pos.x, (pos.y + pos.h * (0.5 - offs * 0.5)).round()),
190 |                         (pos.x + pos.w, (pos.y + pos.h * (0.5 - offs * 0.5)).round()),
191 |                     ]
192 |                     .iter()
193 |                     .copied(),
194 |                     false,
195 |                 );
196 |             }
197 | 
198 |             p.path_fill(color, &mut buf.iter().copied(), false);
199 |         }
200 | 
201 |         if let Some(thres) = data.get_threshold() {
202 |             let (offs, gain) = data.get_offs_gain(0);
203 | 
204 |             let thres_y = (pos.y + pos.h * (0.5 - (thres * gain + offs) * 0.5)).round();
205 | 
206 |             p.path_stroke(
207 |                 hline,
208 |                 lighten_clr(3, hline_color),
209 |                 &mut [(pos.x, thres_y), (pos.x + pos.w, thres_y)].iter().copied(),
210 |                 false,
211 |             );
212 |             let marker_h = hline * 6.0;
213 |             let marker_w = hline * 10.0;
214 |             p.rect_fill(
215 |                 lighten_clr(2, hline_color),
216 |                 pos.x + pos.w - marker_w,
217 |                 thres_y - marker_h * 0.5,
218 |                 marker_w,
219 |                 marker_h,
220 |             );
221 |         }
222 |     }
223 | 
224 |     pub fn draw(
225 |         &mut self,
226 |         _w: &Widget,
227 |         style: &DPIStyle,
228 |         pos: Rect,
229 |         real_pos: Rect,
230 |         p: &mut Painter,
231 |     ) {
232 |         self.live_area = real_pos;
233 | 
234 |         let hline = style.hline();
235 |         let hline_color = style.hline_color();
236 | 
237 |         self.txt_h = p.font_height(style.font_size() as f32, true);
238 | 
239 |         if hline > 0.1 {
240 |             p.path_stroke(
241 |                 hline,
242 |                 hline_color,
243 |                 &mut [
244 |                     (pos.x, (pos.y + pos.h * 0.5).round()),
245 |                     (pos.x + pos.w, (pos.y + pos.h * 0.5).round()),
246 |                 ]
247 |                 .iter()
248 |                 .copied(),
249 |                 false,
250 |             );
251 |         }
252 |     }
253 | 
254 |     pub fn draw_frame(&mut self, w: &Widget, style: &DPIStyle, p: &mut Painter) {
255 |         let mut dbg = w.debug_tag();
256 | 
257 |         let sig_cnt = self.data.borrow().signal_count();
258 |         if sig_cnt > self.draw_buf.len() {
259 |             self.draw_buf.resize_with(sig_cnt, || [(0.0, 0.0); 2 * SCOPE_SAMPLES]);
260 |         }
261 | 
262 |         // Some extra padding for the clip region, so that waveforms
263 |         // are not cut off at the top or bottom.
264 |         let extra_pad = 5.0 * p.dpi_factor;
265 | 
266 |         let draw_region = self.live_area.shrink(0.0, self.txt_h * 2.0);
267 |         self.draw_samples(style, draw_region);
268 |         p.clip_region(
269 |             draw_region.x,
270 |             draw_region.y - extra_pad,
271 |             draw_region.w,
272 |             draw_region.h + 2.0 * extra_pad,
273 |         );
274 |         self.draw_graph(style, draw_region, p);
275 |         p.reset_clip_region();
276 | 
277 |         let line_color = style.color();
278 |         let line1_color = style.vline1_color();
279 |         let line2_color = style.vline2_color();
280 | 
281 |         let data = self.data.borrow();
282 |         for i in 0..sig_cnt {
283 |             if !data.is_active(i) {
284 |                 continue;
285 |             }
286 | 
287 |             let color = match i {
288 |                 1 => line1_color,
289 |                 2 => line2_color,
290 |                 _ => line_color,
291 |             };
292 | 
293 |             let len = data.fmt_val(i, &mut self.lbl_buf[..]);
294 |             let val_s = std::str::from_utf8(&self.lbl_buf[0..len]).unwrap();
295 |             dbg.set_logic_pos(i as i32, 0);
296 | 
297 |             let y = if i == 2 {
298 |                 self.live_area.y + self.live_area.h - self.txt_h
299 |             } else {
300 |                 self.live_area.y + self.txt_h * (i as f32)
301 |             };
302 |             p.label(
303 |                 style.font_size(),
304 |                 0,
305 |                 color,
306 |                 self.live_area.x,
307 |                 y,
308 |                 self.live_area.w,
309 |                 self.txt_h,
310 |                 val_s,
311 |                 dbg.source("scope_label"),
312 |             );
313 |         }
314 |     }
315 | }
316 | 


--------------------------------------------------------------------------------
/src/window.rs:
--------------------------------------------------------------------------------
  1 | // Copyright (c) 2021 Weird Constructor <weirdconstructor@gmail.com>
  2 | // This file is a part of HexoTK. Released under GPL-3.0-or-later.
  3 | // See README.md and COPYING for details.
  4 | 
  5 | use femtovg::{renderer::OpenGl, Canvas, Color, FontId, ImageId};
  6 | 
  7 | use crate::painter::{Painter, PersistPainterData};
  8 | 
  9 | use raw_window_handle::RawWindowHandle;
 10 | 
 11 | use baseview::{
 12 |     Event, EventStatus, MouseButton, MouseEvent, ScrollDelta, Size, Window, WindowEvent,
 13 |     WindowHandle, WindowHandler, WindowOpenOptions, WindowScalePolicy,
 14 | };
 15 | 
 16 | use crate::{InputEvent, MButton, WindowUI};
 17 | 
 18 | pub struct FrameTimeMeasurement {
 19 |     buf: [u128; 240],
 20 |     idx: usize,
 21 |     cur: Option<std::time::Instant>,
 22 |     lbl: String,
 23 | }
 24 | 
 25 | impl FrameTimeMeasurement {
 26 |     pub fn new(lbl: &str) -> Self {
 27 |         Self { buf: [0; 240], idx: 0, cur: None, lbl: lbl.to_string() }
 28 |     }
 29 | 
 30 |     pub fn start_measure(&mut self) {
 31 |         self.cur = Some(std::time::Instant::now());
 32 |     }
 33 | 
 34 |     pub fn end_measure(&mut self) {
 35 |         if let Some(cur) = self.cur.take() {
 36 |             let dur_microseconds = cur.elapsed().as_micros();
 37 |             if (self.idx + 1) >= self.buf.len() {
 38 |                 let mut min = 99999999;
 39 |                 let mut max = 0;
 40 |                 let mut avg = 0;
 41 | 
 42 |                 for b in self.buf.iter() {
 43 |                     if *b < min {
 44 |                         min = *b;
 45 |                     }
 46 |                     if *b > max {
 47 |                         max = *b;
 48 |                     }
 49 |                     avg += *b;
 50 |                 }
 51 | 
 52 |                 avg /= self.buf.len() as u128;
 53 | 
 54 |                 println!(
 55 |                     "Frame time [{:10}]: min={:5.3}, max={:5.3}, avg={:5.3}",
 56 |                     self.lbl,
 57 |                     min as f32 / 1000.0,
 58 |                     max as f32 / 1000.0,
 59 |                     avg as f32 / 1000.0
 60 |                 );
 61 | 
 62 |                 self.idx = 0;
 63 |             } else {
 64 |                 self.idx += 1;
 65 |             }
 66 |             self.buf[self.idx] = dur_microseconds;
 67 |         }
 68 |     }
 69 | }
 70 | 
 71 | pub struct GUIWindowHandler {
 72 |     canvas: Canvas<OpenGl>,
 73 |     font: FontId,
 74 |     font_mono: FontId,
 75 |     img_buf: ImageId,
 76 |     //    ftm:        FrameTimeMeasurement,
 77 |     //    ftm_redraw: FrameTimeMeasurement,
 78 |     ui: Box<dyn WindowUI>,
 79 |     size: (f32, f32),
 80 |     dpi_factor: f32,
 81 |     scale_policy: WindowScalePolicy,
 82 |     // focused:    bool,
 83 |     counter: usize,
 84 | 
 85 |     bg_color: (f32, f32, f32),
 86 | 
 87 |     painter_data: PersistPainterData,
 88 | }
 89 | 
 90 | impl WindowHandler for GUIWindowHandler {
 91 |     fn on_event(&mut self, _: &mut Window, event: Event) -> EventStatus {
 92 |         match event {
 93 |             Event::Mouse(MouseEvent::CursorMoved { position: p, .. }) => {
 94 |                 self.ui.handle_input_event(InputEvent::MousePosition(
 95 |                     p.x as f32 * self.dpi_factor,
 96 |                     p.y as f32 * self.dpi_factor,
 97 |                 ));
 98 |             }
 99 |             Event::Mouse(MouseEvent::ButtonPressed { button, .. }) => {
100 |                 let ev_btn = match button {
101 |                     MouseButton::Left => MButton::Left,
102 |                     MouseButton::Right => MButton::Right,
103 |                     MouseButton::Middle => MButton::Middle,
104 |                     _ => MButton::Left,
105 |                 };
106 |                 self.ui.handle_input_event(InputEvent::MouseButtonPressed(ev_btn));
107 |             }
108 |             Event::Mouse(MouseEvent::ButtonReleased { button, .. }) => {
109 |                 let ev_btn = match button {
110 |                     MouseButton::Left => MButton::Left,
111 |                     MouseButton::Right => MButton::Right,
112 |                     MouseButton::Middle => MButton::Middle,
113 |                     _ => MButton::Left,
114 |                 };
115 |                 self.ui.handle_input_event(InputEvent::MouseButtonReleased(ev_btn));
116 |             }
117 |             Event::Mouse(MouseEvent::WheelScrolled { delta, .. }) => match delta {
118 |                 ScrollDelta::Lines { y, .. } => {
119 |                     self.ui.handle_input_event(InputEvent::MouseWheel(y));
120 |                 }
121 |                 ScrollDelta::Pixels { y, .. } => {
122 |                     self.ui.handle_input_event(InputEvent::MouseWheel(y / 50.0));
123 |                 }
124 |             },
125 |             Event::Keyboard(ev) => {
126 |                 use keyboard_types::KeyState;
127 |                 match ev.state {
128 |                     KeyState::Up => {
129 |                         self.ui.handle_input_event(InputEvent::KeyReleased(ev));
130 |                     }
131 |                     KeyState::Down => {
132 |                         self.ui.handle_input_event(InputEvent::KeyPressed(ev));
133 |                     }
134 |                 }
135 |             }
136 |             Event::Window(WindowEvent::WillClose) => {
137 |                 self.ui.handle_input_event(InputEvent::WindowClose);
138 |             }
139 |             Event::Window(WindowEvent::Focused) => {
140 |                 // self.focused = true;
141 |             }
142 |             Event::Window(WindowEvent::Unfocused) => {
143 |                 // self.focused = false;
144 |             }
145 |             Event::Window(WindowEvent::Resized(info)) => {
146 |                 let size = info.physical_size();
147 |                 let scale = match self.scale_policy {
148 |                     WindowScalePolicy::SystemScaleFactor => info.scale() as f32,
149 |                     WindowScalePolicy::ScaleFactor(scale) => scale as f32,
150 |                 };
151 |                 self.dpi_factor = scale;
152 | 
153 |                 println!(
154 |                     "DPI FACTOR = {}, Phys={:?}, Logic={:?}",
155 |                     self.dpi_factor,
156 |                     info.physical_size(),
157 |                     info.logical_size(),
158 |                 );
159 | 
160 |                 self.canvas.set_size(size.width as u32, size.height as u32, 1.0);
161 |                 let (w, h) = (self.canvas.width(), self.canvas.height());
162 |                 self.canvas.delete_image(self.img_buf);
163 |                 self.img_buf = self
164 |                     .canvas
165 |                     .create_image_empty(
166 |                         w as usize,
167 |                         h as usize,
168 |                         femtovg::PixelFormat::Rgb8,
169 |                         femtovg::ImageFlags::FLIP_Y,
170 |                     )
171 |                     .expect("making image buffer");
172 | 
173 |                 self.size = (w as f32, h as f32);
174 |                 self.ui.set_window_size(w as f32, h as f32, self.dpi_factor);
175 |             }
176 |             _ => {
177 |                 println!("UNHANDLED EVENT: {:?}", event);
178 |             }
179 |         }
180 | 
181 |         EventStatus::Captured
182 |     }
183 | 
184 |     fn on_frame(&mut self, win: &mut Window) {
185 |         self.counter += 1;
186 |         if self.counter % 500 == 0 {
187 |             //            println!("REDRAW.....");
188 |             self.counter = 0;
189 |         }
190 | 
191 |         // some hosts only stop calling idle(), so we stop the UI redraw here:
192 |         if !self.ui.is_active() {
193 |             return;
194 |         }
195 | 
196 |         self.ui.pre_frame();
197 | 
198 |         self.canvas.save();
199 |         self.canvas.set_render_target(femtovg::RenderTarget::Image(self.img_buf));
200 |         self.painter_data.init_render_targets(femtovg::RenderTarget::Image(self.img_buf));
201 | 
202 |         self.canvas.clear_rect(
203 |             0,
204 |             0,
205 |             self.canvas.width() as u32,
206 |             self.canvas.height() as u32,
207 |             Color::rgbf(self.bg_color.0, self.bg_color.1, self.bg_color.2),
208 |         );
209 | 
210 |         {
211 |             let painter = &mut Painter {
212 |                 canvas: &mut self.canvas,
213 |                 data: &mut self.painter_data,
214 |                 font: self.font,
215 |                 font_mono: self.font_mono,
216 |                 lbl_collect: None,
217 |                 dpi_factor: self.dpi_factor,
218 |             };
219 |             self.ui.draw(painter);
220 |         }
221 | 
222 |         self.painter_data.cleanup(&mut self.canvas);
223 | 
224 |         let img_paint = femtovg::Paint::image(
225 |             self.img_buf,
226 |             0.0,
227 |             0.0,
228 |             self.canvas.width() as f32,
229 |             self.canvas.height() as f32,
230 |             0.0,
231 |             1.0,
232 |         );
233 |         let mut path = femtovg::Path::new();
234 |         path.rect(0.0, 0.0, self.canvas.width() as f32, self.canvas.height() as f32);
235 | 
236 |         self.canvas.set_render_target(femtovg::RenderTarget::Screen);
237 |         self.canvas.fill_path(&mut path, &img_paint);
238 | 
239 |         self.canvas.flush();
240 |         self.canvas.restore();
241 | 
242 |         win.gl_context().unwrap().swap_buffers();
243 | 
244 |         self.ui.post_frame();
245 |     }
246 | }
247 | 
248 | struct StupidWindowHandleHolder {
249 |     handle: RawWindowHandle,
250 | }
251 | 
252 | unsafe impl Send for StupidWindowHandleHolder {}
253 | 
254 | unsafe impl raw_window_handle::HasRawWindowHandle for StupidWindowHandleHolder {
255 |     fn raw_window_handle(&self) -> RawWindowHandle {
256 |         self.handle
257 |     }
258 | }
259 | 
260 | pub struct HexoTKWindowHandle {
261 |     hdl: Option<WindowHandle>,
262 | }
263 | 
264 | impl HexoTKWindowHandle {
265 |     pub fn close(&mut self) {
266 |         if let Some(mut hdl) = self.hdl.take() {
267 |             hdl.close();
268 |         }
269 |     }
270 |     pub fn is_open(&self) -> bool {
271 |         self.hdl.as_ref().map(|h| h.is_open()).unwrap_or(false)
272 |     }
273 | }
274 | 
275 | impl Drop for HexoTKWindowHandle {
276 |     fn drop(&mut self) {
277 |         self.close()
278 |     }
279 | }
280 | 
281 | pub fn open_window(
282 |     title: &str,
283 |     window_width: i32,
284 |     window_height: i32,
285 |     parent: Option<RawWindowHandle>,
286 |     factory: Box<dyn FnOnce() -> Box<dyn WindowUI> + Send>,
287 | ) -> Option<HexoTKWindowHandle> {
288 |     open_window_ext(
289 |         title,
290 |         window_width,
291 |         window_height,
292 |         parent,
293 |         factory,
294 |         WindowScalePolicy::SystemScaleFactor,
295 |     )
296 | }
297 | 
298 | pub fn open_window_ext(
299 |     title: &str,
300 |     window_width: i32,
301 |     window_height: i32,
302 |     parent: Option<RawWindowHandle>,
303 |     factory: Box<dyn FnOnce() -> Box<dyn WindowUI> + Send>,
304 |     scale_policy: WindowScalePolicy,
305 | ) -> Option<HexoTKWindowHandle> {
306 |     let dpi_factor = match scale_policy {
307 |         WindowScalePolicy::SystemScaleFactor => 1.0_f32, // How to get the real one?
308 |         WindowScalePolicy::ScaleFactor(scale) => scale as f32,
309 |     };
310 | 
311 |     //d// println!("*** OPEN WINDOW ***");
312 |     let options = WindowOpenOptions {
313 |         title: title.to_string(),
314 |         size: Size::new(window_width as f64, window_height as f64),
315 |         scale: scale_policy,
316 |         gl_config: Some(baseview::gl::GlConfig::default()),
317 |     };
318 | 
319 |     let window_create_fun = move |win: &mut Window| {
320 |         let context = win.gl_context().unwrap();
321 |         unsafe {
322 |             context.make_current();
323 |         }
324 |         gl::load_with(|symbol| context.get_proc_address(symbol) as *const _);
325 | 
326 |         #[allow(deprecated)]
327 |         let renderer = unsafe {
328 |             OpenGl::new_from_function(|symbol| context.get_proc_address(symbol) as *const _)
329 |         }
330 |         .expect("Cannot create renderer");
331 | 
332 |         let mut canvas = Canvas::new(renderer).expect("Cannot create canvas");
333 |         canvas.set_size(window_width as u32, window_height as u32, 1.0);
334 |         let font = canvas.add_font_mem(std::include_bytes!("font.ttf")).expect("can load font");
335 |         let font_mono =
336 |             canvas.add_font_mem(std::include_bytes!("font_mono.ttf")).expect("can load font");
337 |         let (w, h) = (canvas.width(), canvas.height());
338 |         let img_buf = canvas
339 |             .create_image_empty(
340 |                 w as usize,
341 |                 h as usize,
342 |                 femtovg::PixelFormat::Rgb8,
343 |                 femtovg::ImageFlags::FLIP_Y,
344 |             )
345 |             .expect("making image buffer");
346 | 
347 |         let mut ui = factory();
348 | 
349 |         let mut painter_data = PersistPainterData::new();
350 | 
351 |         for (file, data) in ui.get_image_data().iter() {
352 |             painter_data.preload_image(file, data.clone());
353 |         }
354 | 
355 |         ui.set_window_size(window_width as f32, window_height as f32, dpi_factor);
356 | 
357 |         GUIWindowHandler {
358 |             ui,
359 |             size: (window_width as f32, window_height as f32),
360 |             dpi_factor,
361 |             scale_policy,
362 |             canvas,
363 |             font,
364 |             font_mono,
365 |             img_buf,
366 |             //            ftm:        FrameTimeMeasurement::new("img"),
367 |             //            ftm_redraw: FrameTimeMeasurement::new("redraw"),
368 |             // focused:    false,
369 |             counter: 0,
370 |             painter_data,
371 |             bg_color: (0.3, 0.1, 0.3),
372 |         }
373 |     };
374 | 
375 |     if let Some(parent) = parent {
376 |         let swhh = StupidWindowHandleHolder { handle: parent };
377 |         Some(HexoTKWindowHandle {
378 |             hdl: Some(Window::open_parented(&swhh, options, window_create_fun)),
379 |         })
380 |     } else {
381 |         Window::open_blocking(options, window_create_fun);
382 |         None
383 |     }
384 | }
385 | 


--------------------------------------------------------------------------------