refactor(modules): rename home module to draw, restore first-tab order

The Home tab was already titled "Draw"; rename the module to match:
folder modules/home → modules/draw, HomeModule → DrawModule, id "home"
→ "draw". The inner draw/ command folder is kept (modules::draw::draw).

Update build.rs PRIORITY ("home" → "draw") so the tab returns to the
front of the ribbon; registry.rs regenerates accordingly.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/modules/draw/inquiry/area.rs

@@ -0,0 +1,88 @@
+// AREA command — compute area and perimeter of a polygon picked point by point.
+// Press Enter to close and calculate.
+
+use glam::Vec3;
+
+use crate::command::{CadCommand, CmdResult};
+use crate::scene::model::wire_model::WireModel;
+
+pub struct AreaCommand {
+    points: Vec<Vec3>,
+}
+
+impl AreaCommand {
+    pub fn new() -> Self {
+        Self { points: vec![] }
+    }
+}
+
+impl CadCommand for AreaCommand {
+    fn name(&self) -> &'static str {
+        "AREA"
+    }
+
+    fn prompt(&self) -> String {
+        if self.points.is_empty() {
+            "AREA  Specify first corner point (Enter to cancel):".into()
+        } else {
+            format!(
+                "AREA  Specify next point ({} picked, Enter to calculate):",
+                self.points.len()
+            )
+        }
+    }
+
+    fn on_point(&mut self, pt: Vec3) -> CmdResult {
+        self.points.push(pt);
+        CmdResult::NeedPoint
+    }
+
+    fn on_enter(&mut self) -> CmdResult {
+        if self.points.len() < 3 {
+            return CmdResult::Cancel;
+        }
+        // Shoelace formula in the world XY plane.
+        let n = self.points.len();
+        let mut area_sum = 0.0f32;
+        let mut perimeter = 0.0f32;
+        for idx in 0..n {
+            let a = self.points[idx];
+            let b = self.points[(idx + 1) % n];
+            area_sum += a.x * b.y - b.x * a.y;
+            perimeter += (b - a).length();
+        }
+        let area = (area_sum * 0.5).abs();
+        let msg = format!("Area = {area:.4},  Perimeter = {perimeter:.4}");
+        CmdResult::Measurement(msg)
+    }
+
+    fn on_mouse_move(&mut self, pt: Vec3) -> Option<WireModel> {
+        if self.points.is_empty() {
+            return None;
+        }
+        let mut pts: Vec<[f32; 3]> = self.points.iter().map(|p| [p.x, p.y, p.z]).collect();
+        pts.push([pt.x, pt.y, pt.z]);
+        pts.push([self.points[0].x, self.points[0].y, self.points[0].z]);
+        Some(WireModel {
+            name: "area_preview".into(),
+            points: pts,
+            color: WireModel::CYAN,
+            selected: false,
+            pattern_length: 0.0,
+            pattern: [0.0; 8],
+            line_weight_px: 1.0,
+            snap_pts: vec![],
+            tangent_geoms: vec![],
+            aci: 0,
+            key_vertices: vec![],
+            aabb: WireModel::UNBOUNDED_AABB,
+            plinegen: true,
+            vp_scissor: None,
+            fill_tris: vec![],
+        })
+    }
+}
+
+
+// ── Autocomplete registry ─────────────────────────────────
+inventory::submit!(crate::command::CommandRegistration { names: &["AREA"] });  // AreaCommand

src/modules/draw/inquiry/dist.rs

@@ -0,0 +1,83 @@
+// DIST command — measure distance and angle between two picked points.
+
+use glam::Vec3;
+
+use crate::command::{CadCommand, CmdResult};
+use crate::scene::model::wire_model::WireModel;
+
+pub struct DistCommand {
+    first: Option<Vec3>,
+}
+
+impl DistCommand {
+    pub fn new() -> Self {
+        Self { first: None }
+    }
+}
+
+impl CadCommand for DistCommand {
+    fn name(&self) -> &'static str {
+        "DIST"
+    }
+
+    fn prompt(&self) -> String {
+        if self.first.is_none() {
+            "DIST  Specify first point:".into()
+        } else {
+            "DIST  Specify second point:".into()
+        }
+    }
+
+    fn on_point(&mut self, pt: Vec3) -> CmdResult {
+        if let Some(p1) = self.first {
+            let delta = pt - p1;
+            let dist = delta.length();
+            let dx = delta.x;
+            let dy = delta.y; // drawing plane is world XY
+            let dz = delta.z; // elevation
+
+            // Angle in XY plane — degrees from +X
+            let angle_xy = dy.atan2(dx).to_degrees();
+            // Angle from XY plane toward Z (elevation angle)
+            let dist_xy = dx.hypot(dy);
+            let angle_z = dz.atan2(dist_xy).to_degrees();
+
+            let msg = format!(
+                "Distance = {dist:.4},  Angle in XY Plane = {angle_xy:.4}°,  Angle from XY Plane = {angle_z:.4}°\n  Delta X = {dx:.4},  Delta Y = {dy:.4},  Delta Z = {dz:.4}",
+            );
+            CmdResult::Measurement(msg)
+        } else {
+            self.first = Some(pt);
+            CmdResult::NeedPoint
+        }
+    }
+
+    fn on_enter(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+
+    fn on_mouse_move(&mut self, pt: Vec3) -> Option<WireModel> {
+        let p1 = self.first?;
+        Some(WireModel {
+            name: "dist_preview".into(),
+            points: vec![[p1.x, p1.y, p1.z], [pt.x, pt.y, pt.z]],
+            color: WireModel::CYAN,
+            selected: false,
+            pattern_length: 0.0,
+            pattern: [0.0; 8],
+            line_weight_px: 1.0,
+            snap_pts: vec![],
+            tangent_geoms: vec![],
+            aci: 0,
+            key_vertices: vec![],
+            aabb: WireModel::UNBOUNDED_AABB,
+            plinegen: true,
+            vp_scissor: None,
+            fill_tris: vec![],
+        })
+    }
+}
+
+
+// ── Autocomplete registry ─────────────────────────────────
+inventory::submit!(crate::command::CommandRegistration { names: &["DI", "DIST"] });  // DistCommand

src/modules/draw/inquiry/divide.rs

@@ -0,0 +1,318 @@
+// DIVIDE command — place Point entities at N equal intervals along an entity.
+// MEASURE command — place Point entities at fixed-distance intervals along an entity.
+
+use std::f64::consts::PI;
+
+use acadrust::entities::Point as PointEnt;
+use acadrust::types::Vector3;
+use acadrust::{EntityType, Handle};
+use glam::Vec3;
+
+use crate::command::{CadCommand, CmdResult};
+
+// ── DIVIDE ─────────────────────────────────────────────────────────────────
+
+pub struct DivideCommand {
+    target: Option<Handle>,
+    waiting_for_n: bool,
+}
+
+impl DivideCommand {
+    pub fn new() -> Self {
+        Self {
+            target: None,
+            waiting_for_n: false,
+        }
+    }
+}
+
+impl CadCommand for DivideCommand {
+    fn name(&self) -> &'static str {
+        "DIVIDE"
+    }
+
+    fn prompt(&self) -> String {
+        if self.target.is_none() {
+            "DIVIDE  Select object to divide:".into()
+        } else {
+            "DIVIDE  Enter number of segments:".into()
+        }
+    }
+
+    fn needs_entity_pick(&self) -> bool {
+        self.target.is_none()
+    }
+
+    fn on_entity_pick(&mut self, handle: Handle, _pt: Vec3) -> CmdResult {
+        if handle.is_null() {
+            return CmdResult::NeedPoint;
+        }
+        self.target = Some(handle);
+        self.waiting_for_n = true;
+        CmdResult::NeedPoint
+    }
+
+    fn wants_text_input(&self) -> bool {
+        self.waiting_for_n
+    }
+
+    fn dyn_field(&self) -> crate::command::DynField {
+        if self.waiting_for_n {
+            crate::command::DynField::Scalar
+        } else {
+            crate::command::DynField::Point
+        }
+    }
+
+    fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
+        let n: usize = text.trim().parse().ok().filter(|&n| n >= 2)?;
+        let handle = self.target?;
+        self.waiting_for_n = false;
+        Some(CmdResult::DivideEntity { handle, n })
+    }
+
+    fn on_point(&mut self, _pt: Vec3) -> CmdResult {
+        CmdResult::NeedPoint
+    }
+    fn on_enter(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+}
+
+// ── MEASURE ────────────────────────────────────────────────────────────────
+
+pub struct MeasureCommand {
+    target: Option<Handle>,
+    waiting_for_dist: bool,
+}
+
+impl MeasureCommand {
+    pub fn new() -> Self {
+        Self {
+            target: None,
+            waiting_for_dist: false,
+        }
+    }
+}
+
+impl CadCommand for MeasureCommand {
+    fn name(&self) -> &'static str {
+        "MEASURE"
+    }
+
+    fn prompt(&self) -> String {
+        if self.target.is_none() {
+            "MEASURE  Select object to measure:".into()
+        } else {
+            "MEASURE  Specify segment length:".into()
+        }
+    }
+
+    fn needs_entity_pick(&self) -> bool {
+        self.target.is_none()
+    }
+
+    fn on_entity_pick(&mut self, handle: Handle, _pt: Vec3) -> CmdResult {
+        if handle.is_null() {
+            return CmdResult::NeedPoint;
+        }
+        self.target = Some(handle);
+        self.waiting_for_dist = true;
+        CmdResult::NeedPoint
+    }
+
+    fn wants_text_input(&self) -> bool {
+        self.waiting_for_dist
+    }
+
+    fn dyn_field(&self) -> crate::command::DynField {
+        if self.waiting_for_dist {
+            crate::command::DynField::Scalar
+        } else {
+            crate::command::DynField::Point
+        }
+    }
+
+    fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
+        let dist: f64 = text
+            .trim()
+            .replace(',', ".")
+            .parse()
+            .ok()
+            .filter(|&d: &f64| d > 0.0)?;
+        let handle = self.target?;
+        self.waiting_for_dist = false;
+        Some(CmdResult::MeasureEntity {
+            handle,
+            segment_length: dist,
+        })
+    }
+
+    fn on_point(&mut self, _pt: Vec3) -> CmdResult {
+        CmdResult::NeedPoint
+    }
+    fn on_enter(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+}
+
+// ── Geometry ───────────────────────────────────────────────────────────────
+
+/// Compute N-1 equally spaced points along the entity (DIVIDE).
+pub fn divide_entity(entity: &EntityType, n: usize) -> Vec<EntityType> {
+    if n < 2 {
+        return vec![];
+    }
+    let total = entity_length(entity);
+    if total < 1e-10 {
+        return vec![];
+    }
+    let step = total / n as f64;
+    (1..n)
+        .filter_map(|k| {
+            let t = step * k as f64;
+            point_at_distance(entity, t).map(make_point)
+        })
+        .collect()
+}
+
+/// Compute points at fixed `segment_length` intervals along the entity (MEASURE).
+pub fn measure_entity(entity: &EntityType, segment_length: f64) -> Vec<EntityType> {
+    if segment_length <= 0.0 {
+        return vec![];
+    }
+    let total = entity_length(entity);
+    if total < 1e-10 {
+        return vec![];
+    }
+    let mut pts = Vec::new();
+    let mut t = segment_length;
+    while t < total - 1e-6 {
+        if let Some(p) = point_at_distance(entity, t) {
+            pts.push(make_point(p));
+        }
+        t += segment_length;
+    }
+    pts
+}
+
+fn make_point(pos: Vector3) -> EntityType {
+    let mut p = PointEnt::new();
+    p.location = pos;
+    EntityType::Point(p)
+}
+
+fn entity_length(entity: &EntityType) -> f64 {
+    match entity {
+        EntityType::Line(l) => {
+            let dx = l.end.x - l.start.x;
+            let dy = l.end.y - l.start.y;
+            let dz = l.end.z - l.start.z;
+            (dx * dx + dy * dy + dz * dz).sqrt()
+        }
+        EntityType::Arc(a) => {
+            let span = arc_span_rad(a.start_angle, a.end_angle);
+            a.radius * span
+        }
+        EntityType::Circle(c) => 2.0 * PI * c.radius,
+        EntityType::LwPolyline(p) => {
+            let n = p.vertices.len();
+            if n < 2 {
+                return 0.0;
+            }
+            let segs = if p.is_closed { n } else { n - 1 };
+            (0..segs)
+                .map(|i| {
+                    let v0 = &p.vertices[i];
+                    let v1 = &p.vertices[(i + 1) % n];
+                    let dx = v1.location.x - v0.location.x;
+                    let dy = v1.location.y - v0.location.y;
+                    (dx * dx + dy * dy).sqrt()
+                })
+                .sum()
+        }
+        _ => 0.0,
+    }
+}
+
+fn point_at_distance(entity: &EntityType, d: f64) -> Option<Vector3> {
+    match entity {
+        EntityType::Line(l) => {
+            let total = entity_length(entity);
+            if total < 1e-10 {
+                return None;
+            }
+            let t = (d / total).clamp(0.0, 1.0);
+            Some(Vector3::new(
+                l.start.x + t * (l.end.x - l.start.x),
+                l.start.y + t * (l.end.y - l.start.y),
+                l.start.z + t * (l.end.z - l.start.z),
+            ))
+        }
+        EntityType::Arc(a) => {
+            let span = arc_span_rad(a.start_angle, a.end_angle);
+            let t = d / a.radius; // arc_length = r * theta
+            if t > span {
+                return None;
+            }
+            let angle = a.start_angle + t;
+            Some(Vector3::new(
+                a.center.x + a.radius * angle.cos(),
+                a.center.y + a.radius * angle.sin(),
+                a.center.z,
+            ))
+        }
+        EntityType::Circle(c) => {
+            let circumference = 2.0 * PI * c.radius;
+            if circumference < 1e-10 {
+                return None;
+            }
+            let angle = 2.0 * PI * (d / circumference);
+            Some(Vector3::new(
+                c.center.x + c.radius * angle.cos(),
+                c.center.y + c.radius * angle.sin(),
+                c.center.z,
+            ))
+        }
+        EntityType::LwPolyline(p) => {
+            let n = p.vertices.len();
+            if n < 2 {
+                return None;
+            }
+            let segs = if p.is_closed { n } else { n - 1 };
+            let mut acc = 0.0f64;
+            for i in 0..segs {
+                let v0 = &p.vertices[i];
+                let v1 = &p.vertices[(i + 1) % n];
+                let dx = v1.location.x - v0.location.x;
+                let dy = v1.location.y - v0.location.y;
+                let seg_len = (dx * dx + dy * dy).sqrt();
+                if acc + seg_len >= d - 1e-10 {
+                    let t = (d - acc) / seg_len.max(1e-10);
+                    return Some(Vector3::new(
+                        v0.location.x + t * dx,
+                        v0.location.y + t * dy,
+                        p.elevation,
+                    ));
+                }
+                acc += seg_len;
+            }
+            None
+        }
+        _ => None,
+    }
+}
+
+fn arc_span_rad(start: f64, end: f64) -> f64 {
+    let span = (end - start).rem_euclid(2.0 * PI);
+    if span < 1e-6 {
+        2.0 * PI
+    } else {
+        span
+    }
+}
+
+
+// ── Autocomplete registry ─────────────────────────────────
+inventory::submit!(crate::command::CommandRegistration { names: &["DIV", "DIVIDE"] });  // DivideCommand
+inventory::submit!(crate::command::CommandRegistration { names: &["ME", "MEASURE"] });  // MeasureCommand

src/modules/draw/inquiry/id.rs

@@ -0,0 +1,40 @@
+// ID command — report coordinates of a picked point.
+
+use glam::Vec3;
+
+use crate::command::{CadCommand, CmdResult};
+
+pub struct IdCommand;
+
+impl IdCommand {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl CadCommand for IdCommand {
+    fn name(&self) -> &'static str {
+        "ID"
+    }
+
+    fn prompt(&self) -> String {
+        "ID  Specify point:".into()
+    }
+
+    fn on_point(&mut self, pt: Vec3) -> CmdResult {
+        // Drawing plane is world XY (z = elevation).
+        let x = pt.x;
+        let y = pt.y;
+        let z = pt.z;
+        let msg = format!("X = {x:.4},  Y = {y:.4},  Z = {z:.4}");
+        CmdResult::Measurement(msg)
+    }
+
+    fn on_enter(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+}
+
+
+// ── Autocomplete registry ─────────────────────────────────
+inventory::submit!(crate::command::CommandRegistration { names: &["ID"] });  // IdCommand

src/modules/draw/inquiry/mod.rs

@@ -0,0 +1,4 @@
+pub mod area;
+pub mod dist;
+pub mod divide;
+pub mod id;