rust_widgets 2.8.2

Pure Rust cross-platform native GUI library with hardware-adaptive rendering, 180 widgets, touch/gesture support, i18n, and SVG-pipeline-accurate output
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// SPDX-FileCopyrightText: Copyright (c) 2026 Mike Li/Mikewolfli/Wei Li(mikewolfli@163.com)
// SPDX-License-Identifier: MIT

//! Icon census probe (BLUE25 ICON-6) — the machine-readable view of the icon set.
//!
//! # What this measures, and why a gate needs it
//!
//! The icon data is only useful if a *draw* uses it. `tests/icon_data_integrity_test.rs` proves the
//! table is complete and distinct; it cannot prove the table **reaches a picture**. So this probe
//! renders every `IconName` through the real pipeline and prints, per token, what came out:
//!
//! | Field | Meaning |
//! |---|---|
//! | `token` | the canonical name |
//! | `contours` | closed outlines the flattened icon produced |
//! | `ink` | drawn elements in the SVG (the picture is not blank) |
//! | `sha256` | digest of the rendering, so two tokens cannot draw one picture unnoticed |
//!
//! `tests/icon_census_test.rs` asserts the same facts, and `tools/icon_census.txt` is the committed
//! output — so a change in what an icon draws shows up as a diff in a reviewable file.
//!
//! # Why the census is a digest and not a shape description
//!
//! The defect this replaces — `Close` and `Cross` drawn by one method — is not visible in any
//! summary statistic: both names had ink, both had contours, and both were "a valid icon". The only
//! property that distinguishes them is that their **pictures differ**, so the census records a
//! digest of the picture and lets the gate require all of them to be distinct.
//!
//! # Why the probe prints and does not assert
//!
//! Same reason as `widget_reachability`: an example is the smallest target that can be built on
//! demand, and the assertion belongs in a test the suite runs. This file is the producer for the
//! committed census; the test is the judge.

#![cfg(all(feature = "icons", not(feature = "mini")))]

use rust_widgets::core::Rect;
use rust_widgets::widget::svg::render_to_svg;
use rust_widgets::widget::{Icon, IconName};

fn main() {
    for token in IconName::ALL {
        let mut icon = Icon::new(Rect::new(0, 0, 24, 24));
        icon.set_icon_enum(token);
        let svg = render_to_svg(&mut icon);
        // Count the drawing elements, so "the picture is not blank" is a number a reader can see.
        let ink = svg.matches("<path").count()
            + svg.matches("<line").count()
            + svg.matches("<circle").count()
            + svg.matches("<rect").count();
        // The backdrop `<rect>` is not the icon; subtract it so a blank icon reports zero ink
        // rather than one. `render_to_svg` always fills the frame.
        let ink = ink.saturating_sub(1);
        let contours = svg.matches("<path").count();
        println!(
            "{}\tcontours={}\tink={}\tsha256={}",
            token.as_str(),
            contours,
            ink,
            sha256_hex(svg.as_bytes())
        );
    }
}

/// A SHA-256 of `data`, hex-encoded.
///
/// Hand-rolled rather than pulled in as a dependency: this is a probe, not the library, and the
/// crate deliberately has no digest crate. The algorithm is short enough that a second
/// implementation is not a maintenance risk, and it is only ever run for a report.
fn sha256_hex(data: &[u8]) -> String {
    // The round constants and initial state, per FIPS 180-4.
    const K: [u32; 64] = [
        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4,
        0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe,
        0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f,
        0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
        0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
        0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
        0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116,
        0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
        0xc67178f2,
    ];
    let mut h: [u32; 8] = [
        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
        0x5be0cd19,
    ];
    let mut message = data.to_vec();
    let bit_len = (data.len() as u64) * 8;
    message.push(0x80);
    while message.len() % 64 != 56 {
        message.push(0);
    }
    message.extend_from_slice(&bit_len.to_be_bytes());

    for chunk in message.chunks(64) {
        let mut w = [0u32; 64];
        for (index, word) in chunk.chunks(4).enumerate() {
            w[index] = u32::from_be_bytes([word[0], word[1], word[2], word[3]]);
        }
        for index in 16..64 {
            let s0 = w[index - 15].rotate_right(7)
                ^ w[index - 15].rotate_right(18)
                ^ (w[index - 15] >> 3);
            let s1 = w[index - 2].rotate_right(17)
                ^ w[index - 2].rotate_right(19)
                ^ (w[index - 2] >> 10);
            w[index] = w[index - 16].wrapping_add(s0).wrapping_add(w[index - 7]).wrapping_add(s1);
        }
        let [mut a, mut b, mut c, mut d, mut e, mut f, mut g, mut hh] = h;
        for index in 0..64 {
            let s1 = e.rotate_right(6) ^ e.rotate_right(11) ^ e.rotate_right(25);
            let ch = (e & f) ^ (!e & g);
            let temp1 =
                hh.wrapping_add(s1).wrapping_add(ch).wrapping_add(K[index]).wrapping_add(w[index]);
            let s0 = a.rotate_right(2) ^ a.rotate_right(13) ^ a.rotate_right(22);
            let maj = (a & b) ^ (a & c) ^ (b & c);
            let temp2 = s0.wrapping_add(maj);
            hh = g;
            g = f;
            f = e;
            e = d.wrapping_add(temp1);
            d = c;
            c = b;
            b = a;
            a = temp1.wrapping_add(temp2);
        }
        h[0] = h[0].wrapping_add(a);
        h[1] = h[1].wrapping_add(b);
        h[2] = h[2].wrapping_add(c);
        h[3] = h[3].wrapping_add(d);
        h[4] = h[4].wrapping_add(e);
        h[5] = h[5].wrapping_add(f);
        h[6] = h[6].wrapping_add(g);
        h[7] = h[7].wrapping_add(hh);
    }

    let mut out = String::with_capacity(64);
    for word in h {
        out.push_str(&format!("{word:08x}"));
    }
    out
}