Refactor src/main.rs into modular src/app/ structure

Split the 4500-line main.rs into focused submodules under src/app/:
- mod.rs: H7CAD struct, Message enum, boot/new/run
- document.rs: DocumentTab, HistorySnapshot, HistoryState
- helpers.rs: pure helper functions
- history.rs: undo/redo logic
- properties.rs: properties panel logic
- layers.rs: layer sync
- commands.rs: dispatch_command
- cmd_result.rs: apply_cmd_result
- view.rs: view, subscription, tab bar
- update.rs: update message handler

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/app/helpers.rs

@@ -0,0 +1,205 @@
+use crate::ui::overlay::GridPlane;
+use crate::scene::WireModel;
+
+// ── Coordinate parsing ─────────────────────────────────────────────────────
+
+/// Parse a typed coordinate string into a world-space Vec3.
+/// Accepts "x,y"   → Vec3(x, y, 0)
+///         "x,y,z" → Vec3(x, y, z)
+/// Separators: comma or semicolon; decimal point or decimal comma.
+pub(super) fn parse_coord(text: &str) -> Option<glam::Vec3> {
+    let parts: Vec<f32> = text
+        .split(|c| c == ',' || c == ';')
+        .map(|s| s.trim().replace(',', "."))
+        .filter_map(|s| s.parse().ok())
+        .collect();
+    match parts.as_slice() {
+        [x, y] => Some(glam::Vec3::new(*x, *y, 0.0)),
+        [x, y, z] => Some(glam::Vec3::new(*x, *y, *z)),
+        _ => None,
+    }
+}
+
+pub(super) fn angle_close(a: f32, b: f32, tol: f32) -> bool {
+    let diff = (a - b).rem_euclid(std::f32::consts::TAU);
+    let diff = if diff > std::f32::consts::PI {
+        diff - std::f32::consts::TAU
+    } else {
+        diff
+    };
+    diff.abs() < tol
+}
+
+// ── Grid plane detection ───────────────────────────────────────────────────
+
+/// Choose the grid plane whose normal is most aligned with the camera view direction.
+pub(super) fn grid_plane_from_camera(pitch: f32, yaw: f32) -> GridPlane {
+    let fz = pitch.sin().abs();
+    let fy = (pitch.cos() * yaw.cos()).abs();
+    let fx = (pitch.cos() * yaw.sin()).abs();
+    if fz >= fy && fz >= fx {
+        GridPlane::Xy
+    } else if fy >= fx {
+        GridPlane::Xz
+    } else {
+        GridPlane::Yz
+    }
+}
+
+// ── Drawing constraint helpers ─────────────────────────────────────────────
+
+/// Constrain `pt` to the nearest 90° direction from `base` (XY plane, Z-up).
+pub(super) fn ortho_constrain(pt: glam::Vec3, base: glam::Vec3) -> glam::Vec3 {
+    let dx = (pt.x - base.x).abs();
+    let dy = (pt.y - base.y).abs();
+    if dx >= dy {
+        glam::Vec3::new(pt.x, base.y, pt.z)
+    } else {
+        glam::Vec3::new(base.x, pt.y, pt.z)
+    }
+}
+
+/// Constrain `pt` to the nearest polar angle multiple from `base` (XY plane, Z-up).
+pub(super) fn polar_constrain(pt: glam::Vec3, base: glam::Vec3, step_deg: f32) -> glam::Vec3 {
+    let dx = pt.x - base.x;
+    let dy = pt.y - base.y;
+    let dist = (dx * dx + dy * dy).sqrt();
+    if dist < 1e-6 {
+        return pt;
+    }
+    let step = step_deg.to_radians();
+    let angle = dy.atan2(dx);
+    let snapped = (angle / step).round() * step;
+    glam::Vec3::new(
+        base.x + dist * snapped.cos(),
+        base.y + dist * snapped.sin(),
+        pt.z,
+    )
+}
+
+// ── Clipboard / selection helpers ──────────────────────────────────────────
+
+/// Compute the centroid of a set of wire models (average of all points).
+pub(super) fn entities_centroid(wires: &[WireModel]) -> glam::Vec3 {
+    let mut sum = glam::Vec3::ZERO;
+    let mut count = 0usize;
+    for w in wires {
+        for p in &w.points {
+            sum += glam::Vec3::from(*p);
+            count += 1;
+        }
+    }
+    if count > 0 { sum / count as f32 } else { glam::Vec3::ZERO }
+}
+
+/// Generate the next available auto group name ("*A1", "*A2", …).
+pub(super) fn next_group_auto_name(scene: &crate::scene::Scene) -> String {
+    let existing: std::collections::HashSet<String> =
+        scene.groups().map(|g| g.name.clone()).collect();
+    for n in 1..=9999 {
+        let name = format!("*A{n}");
+        if !existing.contains(&name) {
+            return name;
+        }
+    }
+    "*A".to_string()
+}
+
+// ── Entity type labels ─────────────────────────────────────────────────────
+
+pub(super) fn entity_type_label(entity: &acadrust::EntityType) -> String {
+    use acadrust::EntityType::*;
+    match entity {
+        Line(_) => "Line",
+        Circle(_) => "Circle",
+        Arc(_) => "Arc",
+        Ellipse(_) => "Ellipse",
+        Spline(_) => "Spline",
+        LwPolyline(_) => "Polyline",
+        Text(_) => "Text",
+        MText(_) => "MText",
+        Dimension(_) => "Dimension",
+        Insert(_) => "Block Reference",
+        Point(_) => "Point",
+        Hatch(_) => "Hatch",
+        _ => "Entity",
+    }
+    .to_string()
+}
+
+pub(super) fn entity_type_key(entity: &acadrust::EntityType) -> String {
+    match entity {
+        acadrust::EntityType::LwPolyline(_) => "pline",
+        acadrust::EntityType::Circle(_) => "circle",
+        acadrust::EntityType::Line(_) => "line",
+        acadrust::EntityType::Arc(_) => "arc",
+        acadrust::EntityType::Ellipse(_) => "ellipse",
+        acadrust::EntityType::Spline(_) => "spline",
+        acadrust::EntityType::Text(_) => "text",
+        acadrust::EntityType::MText(_) => "mtext",
+        acadrust::EntityType::Dimension(_) => "dimension",
+        acadrust::EntityType::Insert(_) => "insert",
+        acadrust::EntityType::Point(_) => "point",
+        acadrust::EntityType::Hatch(_) => "hatch",
+        _ => "entity",
+    }
+    .to_string()
+}
+
+pub(super) fn title_case_word(value: &str) -> String {
+    let mut chars = value.chars();
+    match chars.next() {
+        Some(first) => {
+            let mut out = first.to_uppercase().collect::<String>();
+            out.push_str(chars.as_str());
+            out
+        }
+        None => String::new(),
+    }
+}
+
+// ── Window icon ────────────────────────────────────────────────────────────
+
+/// Builds a 32×32 RGBA icon: red background with H7 drawn in white pixels.
+pub(super) fn build_window_icon() -> Vec<u8> {
+    const W: usize = 32;
+    const SZ: usize = W * W * 4;
+
+    let bg = [176u8, 48, 32, 255];
+    let fg = [255u8, 255, 255, 255];
+
+    let mut px = vec![0u8; SZ];
+    for i in 0..W * W {
+        px[i * 4..i * 4 + 4].copy_from_slice(&bg);
+    }
+
+    fn stroke(px: &mut Vec<u8>, ax: i32, ay: i32, bx: i32, by: i32, fg: [u8; 4]) {
+        let steps = ((bx - ax).abs().max((by - ay).abs()) * 3).max(1);
+        for s in 0..=steps {
+            let t = s as f32 / steps as f32;
+            let cx = ax as f32 + (bx - ax) as f32 * t;
+            let cy = ay as f32 + (by - ay) as f32 * t;
+            for dy in -1i32..=1 {
+                for dx in -1i32..=1 {
+                    let ix = cx.round() as i32 + dx;
+                    let iy = cy.round() as i32 + dy;
+                    if ix >= 0 && ix < W as i32 && iy >= 0 && iy < W as i32 {
+                        let idx = (iy as usize * W + ix as usize) * 4;
+                        px[idx..idx + 4].copy_from_slice(&fg);
+                    }
+                }
+            }
+        }
+    }
+
+    // H
+    stroke(&mut px, 4, 5, 4, 26, fg);
+    stroke(&mut px, 13, 5, 13, 26, fg);
+    stroke(&mut px, 4, 15, 13, 15, fg);
+    // 7
+    stroke(&mut px, 17, 5, 27, 5, fg);
+    stroke(&mut px, 27, 5, 20, 26, fg);
+    stroke(&mut px, 20, 16, 26, 16, fg);
+
+    px
+}