xengui 0.2.3

a reactive gui library in rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// SPDX-License-Identifier: Apache-2.0
use crate::Widget;
use smol_str::SmolStr;
use std::collections::HashMap;

/// Diffs a freshly rendered widget tree against the previous frame's tree and
/// transfers persistent state (interaction, measured layout, dirty flag)
/// from matching old widgets into the new ones in place.
///
/// Matching rules:
/// - A widget with a key is matched only against an old widget with the same
///   key, regardless of position, so it survives reordering.
/// - A widget without a key is matched against the next unclaimed unkeyed
///   old widget in sibling order.
/// - A match is only honored when both widgets share the same concrete
///   type; a type change at a given key/position is treated as unmount +
///   mount rather than an update, so state never leaks across widget kinds.
pub(crate) fn reconcile(new_nodes: &mut [Box<dyn Widget>], old_nodes: &[Box<dyn Widget>]) {
    let mut keyed_old: HashMap<&SmolStr, usize> = HashMap::new();
    let mut consumed = vec![false; old_nodes.len()];
    for (i, old) in old_nodes.iter().enumerate() {
        if let Some(key) = old.get_key() {
            keyed_old.entry(key).or_insert(i);
        }
    }

    let mut positional_cursor = 0usize;

    for new_node in new_nodes.iter_mut() {
        let matched_idx = match new_node.get_key() {
            Some(key) => keyed_old.get(key).copied(),
            None => {
                let mut found = None;
                while positional_cursor < old_nodes.len() {
                    let candidate = positional_cursor;
                    positional_cursor += 1;
                    if consumed[candidate] || old_nodes[candidate].get_key().is_some() {
                        continue;
                    }
                    found = Some(candidate);
                    break;
                }
                found
            }
        };

        let Some(old_idx) = matched_idx else {
            continue;
        };
        if consumed[old_idx] {
            // Duplicate key in the old tree: first match wins, rest mount fresh.
            continue;
        }

        let old_node = &old_nodes[old_idx];

        if new_node.as_any().type_id() != old_node.as_any().type_id() {
            continue;
        }

        consumed[old_idx] = true;

        let interaction_changed = new_node.transfer_interaction_state(old_node.as_ref());
        new_node.after_interaction_transfer();

        if !interaction_changed && new_node.content_eq(old_node.as_ref()) {
            new_node.transfer_measured_state(old_node.as_ref());
            new_node.set_dirty(false);
        }

        if let Some(new_children) = new_node.children_mut() {
            reconcile(new_children, old_node.children());
        }
    }
}