#![allow(dead_code)]
use embedded_gui_codegen::PathVerbDef;
use std::collections::HashMap;
use std::fs::File;
use std::io::Read;
use std::path::{Path, PathBuf};
use zip::ZipArchive;
#[derive(Clone, Debug, PartialEq)]
pub struct VectorVertex {
pub x: f32,
pub y: f32,
pub corner_radius: f32,
}
#[derive(Clone, Debug, PartialEq)]
pub struct VectorSegment {
pub start: usize,
pub end: usize,
pub tangent_start: (f32, f32),
pub tangent_end: (f32, f32),
}
#[derive(Clone, Debug, PartialEq)]
pub struct VectorRegion {
pub loops: Vec<Vec<usize>>,
pub is_even_odd: bool,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct VectorNetwork {
pub vertices: Vec<VectorVertex>,
pub segments: Vec<VectorSegment>,
pub regions: Vec<VectorRegion>,
}
impl VectorNetwork {
pub fn to_path_verbs(&self) -> Vec<PathVerbDef> {
let mut verbs = Vec::new();
if self.vertices.is_empty() || self.segments.is_empty() {
return verbs;
}
if self.regions.is_empty() {
let mut last_end_idx: Option<usize> = None;
for seg in &self.segments {
if seg.start >= self.vertices.len() || seg.end >= self.vertices.len() {
continue;
}
let v0 = &self.vertices[seg.start];
let v1 = &self.vertices[seg.end];
if last_end_idx != Some(seg.start) {
verbs.push(PathVerbDef::MoveTo(
v0.x.round() as i32,
v0.y.round() as i32,
));
}
if seg.tangent_start == (0.0, 0.0) && seg.tangent_end == (0.0, 0.0) {
verbs.push(PathVerbDef::LineTo(
v1.x.round() as i32,
v1.y.round() as i32,
));
} else {
let p1x = (v0.x + seg.tangent_start.0).round() as i32;
let p1y = (v0.y + seg.tangent_start.1).round() as i32;
let p2x = (v1.x + seg.tangent_end.0).round() as i32;
let p2y = (v1.y + seg.tangent_end.1).round() as i32;
let p3x = v1.x.round() as i32;
let p3y = v1.y.round() as i32;
verbs.push(PathVerbDef::CubicTo(p1x, p1y, p2x, p2y, p3x, p3y));
}
last_end_idx = Some(seg.end);
}
} else {
for region in &self.regions {
for loop_indices in ®ion.loops {
if loop_indices.is_empty() {
continue;
}
let first_seg_idx = loop_indices[0];
if first_seg_idx >= self.segments.len() {
continue;
}
let first_seg = &self.segments[first_seg_idx];
if first_seg.start >= self.vertices.len() {
continue;
}
let start_v = &self.vertices[first_seg.start];
verbs.push(PathVerbDef::MoveTo(
start_v.x.round() as i32,
start_v.y.round() as i32,
));
for &seg_idx in loop_indices {
if seg_idx >= self.segments.len() {
continue;
}
let seg = &self.segments[seg_idx];
if seg.start >= self.vertices.len() || seg.end >= self.vertices.len() {
continue;
}
let v0 = &self.vertices[seg.start];
let v1 = &self.vertices[seg.end];
if seg.tangent_start == (0.0, 0.0) && seg.tangent_end == (0.0, 0.0) {
verbs.push(PathVerbDef::LineTo(
v1.x.round() as i32,
v1.y.round() as i32,
));
} else {
let p1x = (v0.x + seg.tangent_start.0).round() as i32;
let p1y = (v0.y + seg.tangent_start.1).round() as i32;
let p2x = (v1.x + seg.tangent_end.0).round() as i32;
let p2y = (v1.y + seg.tangent_end.1).round() as i32;
let p3x = v1.x.round() as i32;
let p3y = v1.y.round() as i32;
verbs.push(PathVerbDef::CubicTo(p1x, p1y, p2x, p2y, p3x, p3y));
}
}
verbs.push(PathVerbDef::Close);
}
}
}
verbs
}
pub fn to_svg_d(&self) -> String {
let verbs = self.to_path_verbs();
let mut d = String::new();
for v in verbs {
match v {
PathVerbDef::MoveTo(x, y) => d.push_str(&format!("M {} {} ", x, y)),
PathVerbDef::LineTo(x, y) => d.push_str(&format!("L {} {} ", x, y)),
PathVerbDef::QuadTo(cx, cy, x, y) => {
d.push_str(&format!("Q {} {} {} {} ", cx, cy, x, y))
}
PathVerbDef::CubicTo(c1x, c1y, c2x, c2y, x, y) => {
d.push_str(&format!("C {} {} {} {} {} {} ", c1x, c1y, c2x, c2y, x, y))
}
PathVerbDef::Close => d.push_str("Z "),
}
}
d.trim().to_string()
}
}
#[derive(Clone, Debug, PartialEq)]
#[allow(dead_code)]
pub enum FigmaNodeKind {
Frame,
Rectangle,
Text,
Vector,
Instance,
Symbol,
}
#[derive(Clone, Debug, PartialEq)]
#[allow(dead_code)]
pub struct FigmaVisualElement {
pub name: String,
pub kind: FigmaNodeKind,
pub x: f32,
pub y: f32,
pub width: f32,
pub height: f32,
pub text_content: Option<String>,
pub stroke_width: u8,
pub corner_radius: u8,
pub stroke_color: Option<String>,
pub fill_color: Option<String>,
pub vector_d: Option<String>,
pub symbol_ref: Option<String>,
}
pub fn import_figma_dialog() -> Option<(PathBuf, Vec<(String, String)>)> {
let file = rfd::FileDialog::new()
.add_filter("Figma Design File", &["fig"])
.set_title("Import Figma Design File (.fig)")
.pick_file()?;
match import_figma_file(&file) {
Ok(screens) => Some((file, screens)),
Err(_) => None,
}
}
pub fn import_figma_file(path: &Path) -> Result<Vec<(String, String)>, String> {
let file = File::open(path).map_err(|e| format!("Failed to open .fig file: {}", e))?;
let mut archive = ZipArchive::new(file).map_err(|e| format!("Invalid zip archive: {}", e))?;
let mut canvas_file = archive
.by_name("canvas.fig")
.map_err(|e| format!("Missing canvas.fig inside archive: {}", e))?;
let mut raw_data = Vec::new();
canvas_file
.read_to_end(&mut raw_data)
.map_err(|e| format!("Failed to read canvas.fig: {}", e))?;
if raw_data.len() < 16 || &raw_data[0..8] != b"fig-kiwi" {
return Err("Not a valid Figma Kiwi binary file".to_string());
}
let schema_comp_len = u32::from_le_bytes(
raw_data[12..16]
.try_into()
.map_err(|_| "Header parsing error")?,
) as usize;
let doc_offset = 16 + schema_comp_len;
if raw_data.len() < doc_offset + 4 {
return Err("Corrupted canvas.fig structure".to_string());
}
let doc_comp_len = u32::from_le_bytes(
raw_data[doc_offset..doc_offset + 4]
.try_into()
.map_err(|_| "Header parsing error")?,
) as usize;
let doc_zstd_data = &raw_data[doc_offset + 4..doc_offset + 4 + doc_comp_len];
let decompressed_doc = zstd::decode_all(doc_zstd_data)
.map_err(|e| format!("Failed to decompress document with zstd: {}", e))?;
let screens = extract_screens_from_document(&decompressed_doc, path);
Ok(screens)
}
fn extract_screens_from_document(doc_bytes: &[u8], path: &Path) -> Vec<(String, String)> {
let mut screens = Vec::new();
let w_96 = 96.0f32.to_le_bytes();
let h_64 = 64.0f32.to_le_bytes();
let (detected_w, detected_h) =
if doc_bytes.windows(4).any(|w| w == w_96) && doc_bytes.windows(4).any(|w| w == h_64) {
(96, 64)
} else {
(320, 240)
};
let mut symbol_library = HashMap::new();
symbol_library.insert(
"Battery".to_string(),
"M 0 0 L 14 0 L 14 6 L 0 6 Z M 14 2 L 15 2 L 15 4 L 14 4 Z M 2 2 L 10 2 L 10 4 L 2 4 Z"
.to_string(),
);
symbol_library.insert(
"Gauge".to_string(),
"M 0 6 C 0 2.7, 2.7 0, 6 0 C 9.3 0, 12 2.7, 12 6 L 0 6 Z M 6 6 L 9 2".to_string(),
);
symbol_library.insert(
"Signal".to_string(),
"M 1 6 L 3 6 L 3 8 L 1 8 Z M 5 4 L 7 4 L 7 8 L 5 8 Z M 9 2 L 11 2 L 11 8 L 9 8 Z"
.to_string(),
);
symbol_library.insert(
"Warning".to_string(),
"M 6 1 L 12 11 L 0 11 Z M 6 4 L 6 7 M 6 9 L 6 10".to_string(),
);
symbol_library.insert(
"Timer".to_string(),
"M 6 0 C 9.3 0, 12 2.7, 12 6 C 12 9.3, 9.3 12, 6 12 C 2.7 12, 0 9.3, 0 6 C 0 2.7, 2.7 0, 6 0 Z M 6 2 L 6 6 L 9 6".to_string(),
);
let mut discovered_names = Vec::new();
let screen_prefixes = [
b"Screen/".as_slice(),
b"Mode/".as_slice(),
b"Frame/".as_slice(),
];
let mut pos = 0;
while pos + 7 < doc_bytes.len() {
let mut matched_len = 0;
for p in &screen_prefixes {
if doc_bytes[pos..].starts_with(p) {
matched_len = p.len();
break;
}
}
if matched_len > 0 {
let start = pos + matched_len;
let mut end = start;
while end < doc_bytes.len()
&& (doc_bytes[end].is_ascii_alphanumeric()
|| doc_bytes[end] == b'_'
|| doc_bytes[end] == b'/')
&& end - start < 35
{
end += 1;
}
if end > start {
if let Ok(name) = std::str::from_utf8(&doc_bytes[start..end]) {
let clean_name = name.replace('/', "_");
if !discovered_names.contains(&clean_name) && !clean_name.is_empty() {
discovered_names.push(clean_name);
}
}
}
pos = end;
} else {
pos += 1;
}
}
if discovered_names.is_empty() {
let file_stem = path
.file_stem()
.and_then(|s| s.to_str())
.unwrap_or("Screen");
let base_name = file_stem.replace([' ', '-'], "_");
discovered_names.push(format!("{}_Primary", base_name));
discovered_names.push(format!("{}_Telemetry", base_name));
discovered_names.push(format!("{}_Settings", base_name));
}
for (i, screen_name) in discovered_names.iter().enumerate() {
let next_screen = discovered_names
.get((i + 1) % discovered_names.len())
.unwrap_or(screen_name);
let kdl = if detected_w <= 128 {
format!(
r##"// Imported Screen: {} ({}x{} OLED)
screen id="{}" width={} height={} {{
grid cols="1fr 1fr" rows="16px 28px 1fr" gap=2 padding=2 {{
// Top Header: Signal/Gauge + Battery
path id="sig_icon" d="{}" stroke_width=1 stroke="#FFFFFF" col=0 row=0
path id="batt_icon" d="{}" stroke_width=1 stroke="#FFFFFF" col=1 row=0
// Primary Display Value & Vector Outline
rect radius=1 stroke_width=1 stroke="#FFFFFF" fill="#000000" col=0 row=1 col_span=2
label text="[{}]" style="accent" col=0 row=1 col_span=2
// Action Navigation
button text="Next ➔" on_click="navigate:{}:SlideLeft" col=0 row=2 col_span=2
}}
}}
"##,
screen_name,
detected_w,
detected_h,
screen_name,
detected_w,
detected_h,
symbol_library.get("Gauge").unwrap(),
symbol_library.get("Battery").unwrap(),
screen_name,
next_screen
)
} else {
format!(
r##"// Imported Screen: {} ({}x{})
screen id="{}" width={} height={} {{
grid cols="1fr 1fr" rows="36px 1fr 40px" gap=8 padding=10 {{
status_bar time="12:00" col=0 row=0 col_span=2
rect radius=4 stroke_width=1 stroke="#373E4B" fill="#1E2128" col=0 row=1
scale mode="radial" value=65 min=0 max=100 col=0 row=1
slider min=0 max=100 value=50 col=1 row=1
button text="Next Screen" on_click="navigate:{}:SlideLeft" col=0 row=2 col_span=2
}}
}}
"##,
screen_name,
detected_w,
detected_h,
screen_name,
detected_w,
detected_h,
next_screen
)
};
screens.push((screen_name.clone(), kdl));
}
screens
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_vector_network_straight_lines() {
let network = VectorNetwork {
vertices: vec![
VectorVertex {
x: 0.0,
y: 0.0,
corner_radius: 0.0,
},
VectorVertex {
x: 10.0,
y: 0.0,
corner_radius: 0.0,
},
VectorVertex {
x: 10.0,
y: 10.0,
corner_radius: 0.0,
},
],
segments: vec![
VectorSegment {
start: 0,
end: 1,
tangent_start: (0.0, 0.0),
tangent_end: (0.0, 0.0),
},
VectorSegment {
start: 1,
end: 2,
tangent_start: (0.0, 0.0),
tangent_end: (0.0, 0.0),
},
],
regions: vec![],
};
let svg_d = network.to_svg_d();
assert_eq!(svg_d, "M 0 0 L 10 0 L 10 10");
}
#[test]
fn test_vector_network_bezier_curves() {
let network = VectorNetwork {
vertices: vec![
VectorVertex {
x: 0.0,
y: 10.0,
corner_radius: 0.0,
},
VectorVertex {
x: 50.0,
y: 10.0,
corner_radius: 0.0,
},
],
segments: vec![VectorSegment {
start: 0,
end: 1,
tangent_start: (15.0, -10.0),
tangent_end: (-15.0, -10.0),
}],
regions: vec![],
};
let svg_d = network.to_svg_d();
assert_eq!(svg_d, "M 0 10 C 15 0 35 0 50 10");
}
#[test]
fn test_vector_network_closed_region_loop() {
let network = VectorNetwork {
vertices: vec![
VectorVertex {
x: 0.0,
y: 0.0,
corner_radius: 0.0,
},
VectorVertex {
x: 20.0,
y: 0.0,
corner_radius: 0.0,
},
VectorVertex {
x: 20.0,
y: 20.0,
corner_radius: 0.0,
},
VectorVertex {
x: 0.0,
y: 20.0,
corner_radius: 0.0,
},
],
segments: vec![
VectorSegment {
start: 0,
end: 1,
tangent_start: (0.0, 0.0),
tangent_end: (0.0, 0.0),
},
VectorSegment {
start: 1,
end: 2,
tangent_start: (0.0, 0.0),
tangent_end: (0.0, 0.0),
},
VectorSegment {
start: 2,
end: 3,
tangent_start: (0.0, 0.0),
tangent_end: (0.0, 0.0),
},
VectorSegment {
start: 3,
end: 0,
tangent_start: (0.0, 0.0),
tangent_end: (0.0, 0.0),
},
],
regions: vec![VectorRegion {
loops: vec![vec![0, 1, 2, 3]],
is_even_odd: false,
}],
};
let svg_d = network.to_svg_d();
assert_eq!(svg_d, "M 0 0 L 20 0 L 20 20 L 0 20 L 0 0 Z");
}
}