Match DIVIDE marker placement behavior

src/app/command_driver.rs

@@ -3149,23 +3149,25 @@ impl OpenCADStudio {
                 self.tabs[i].scene.clear_preview_wire();
                 self.restore_pre_cmd_tangent();
             }
-            CmdResult::DivideEntity { handle, n } => {
+            CmdResult::DivideEntity { handle, n, marker } => {
                 use crate::modules::draw::inquiry::divide::divide_entity;
                 let pts = self.tabs[i]
                     .scene
                     .document
                     .get_entity(handle)
-                    .map(|e| divide_entity(e, n))
+                    .map(|e| divide_entity(e, n, marker.as_ref()))
                     .unwrap_or_default();
                 let count = pts.len();
                 if count > 0 {
                     self.push_undo_snapshot(i, "DIVIDE");
-                    for p in pts {
+                    let layer = self.tabs[i].active_layer.clone();
+                    for mut p in pts {
+                        p.as_entity_mut().set_layer(layer.clone());
                         self.tabs[i].scene.add_entity(p);
                     }
                     self.tabs[i].dirty = true;
                     self.command_line
-                        .push_output(crate::tf!("DIVIDE: {count} point(s) placed.").as_ref());
+                        .push_output(crate::tf!("DIVIDE: {count} marker(s) placed.").as_ref());
                 } else {
                     self.command_line
                         .push_error(crate::t!("DIVIDE: entity type not supported or N < 2.").as_ref());

src/app/commands/inquiry.rs

@@ -975,7 +975,7 @@ impl OpenCADStudio {
 
             "DIVIDE" => {
                 use crate::modules::draw::inquiry::divide::DivideCommand;
-                let cmd = DivideCommand::new();
+                let cmd = DivideCommand::new().with_blocks(self.tabs[i].scene.custom_block_names());
                 self.command_line.push_info(&cmd.prompt());
                 self.tabs[i].active_cmd = Some(Box::new(cmd));
             }

src/command.rs

@@ -1481,7 +1481,7 @@ pub enum CmdResult {
         op: crate::modules::draw::modify::pedit::PeditOp,
     },
     /// Place Point entities at N equal intervals along the entity.
-    DivideEntity { handle: Handle, n: usize },
+    DivideEntity { handle: Handle, n: usize, marker: Option<CurveMarker> },
     /// Place Point entities at `segment_length` intervals along the entity.
     MeasureEntity { handle: Handle, segment_length: f64 },
     /// Extend/trim a Line or Arc by the given mode; end command.
@@ -1939,6 +1939,14 @@ impl InputKind {
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct CurveMarker {
+    pub block: String,
+    pub align: bool,
+    pub plane: WorkingPlane,
+}
+
+
 pub trait CadCommand: Send {
     /// Keep the layer already carried by entities committed by this command
     /// instead of replacing it with the current drawing layer.

src/modules/draw/inquiry/divide.rs

@@ -1,86 +1,125 @@
-// 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 acadrust::entities::Point as PointEnt;
-use cadkernel::space::PlanarCurve;
+// DIVIDE and MEASURE place points or block references along a curve.
+use acadrust::entities::{Insert, Point as PointEnt};
 use acadrust::types::Vector3;
-use acadrust::{EntityType, Handle};
+use acadrust::{Entity, EntityType, Handle};
+use cadkernel::space::PlanarCurve;
 use glam::DVec3;
+use crate::command::{CadCommand, CmdOption, CmdResult, CurveMarker, WorkingPlane};
 use crate::entities::curve::entity_curve;
 use crate::t;
+const MEASURE: bool = false;
 
-use crate::command::{CadCommand, CmdResult};
+#[derive(Clone, Copy, PartialEq)]
+enum Step { Pick, Amount, BlockName, Align }
 
-// ── DIVIDE ─────────────────────────────────────────────────────────────────
-
-pub struct DivideCommand {
+pub struct DivisionMarkerCommand {
     target: Option<Handle>,
-    waiting_for_n: bool,
+    pick_point: DVec3,
+    step: Step,
+    blocks: Vec<String>,
+    block: Option<String>,
+    align: bool,
+    plane: WorkingPlane,
+    valid_pick: bool,
 }
 
-impl DivideCommand {
+pub type DivideCommand = DivisionMarkerCommand;
+
+impl DivisionMarkerCommand {
     pub fn new() -> Self {
-        Self {
-            target: None,
-            waiting_for_n: false,
-        }
+        Self { target: None, pick_point: DVec3::ZERO, step: Step::Pick,
+            blocks: Vec::new(), block: None, align: true,
+            plane: WorkingPlane::default(), valid_pick: false }
+    }
+    pub fn with_blocks(mut self, blocks: Vec<String>) -> Self {
+        self.blocks = blocks;
+        self
+    }
+    fn marker(&self) -> Option<CurveMarker> {
+        self.block.as_ref().map(|name| CurveMarker {
+            block: name.clone(), align: self.align, plane: self.plane,
+        })
     }
 }
 
-impl CadCommand for DivideCommand {
-    fn name(&self) -> &'static str {
-        "DIVIDE"
-    }
-
+impl CadCommand for DivisionMarkerCommand {
+    fn name(&self) -> &'static str { if MEASURE { "MEASURE" } else { "DIVIDE" } }
     fn prompt(&self) -> String {
-        if self.target.is_none() {
-            t!("DIVIDE  Select object to divide:").into_owned()
-        } else {
-            t!("DIVIDE  Enter number of segments:").into_owned()
+        let prompt = match self.step {
+            Step::Pick if MEASURE => "Select object to measure:",
+            Step::Pick => "Select object to divide:",
+            Step::BlockName => "Enter name of block to insert:",
+            Step::Align => "Align block with object? [Yes/No] <Yes>:",
+            Step::Amount if MEASURE && self.block.is_none() => "Specify length of segment or [Block]:",
+            Step::Amount if MEASURE => "Specify length of segment:",
+            Step::Amount if self.block.is_none() => "Enter number of segments or [Block]:",
+            Step::Amount => "Enter number of segments:",
+        };
+        format!("{}  {}", self.name(), prompt)
+    }
+    fn options(&self) -> Vec<CmdOption> {
+        match self.step {
+            Step::Amount if self.block.is_none() => vec![CmdOption::new("Block", "B")],
+            Step::Align => vec![CmdOption::new("Yes", "Y"), CmdOption::new("No", "N")],
+            _ => vec![],
         }
     }
-
-    fn needs_entity_pick(&self) -> bool {
-        self.target.is_none()
+    fn set_working_plane(&mut self, plane: WorkingPlane) { self.plane = plane; }
+    fn needs_entity_pick(&self) -> bool { self.step == Step::Pick }
+    fn inject_before_entity_pick(&self) -> bool { true }
+    fn inject_picked_entity(&mut self, entity: EntityType) {
+        self.valid_pick = measurable(&entity).is_some();
     }
-
-    fn on_entity_pick(&mut self, handle: Handle, _pt: DVec3) -> CmdResult {
-        if handle.is_null() {
-            return CmdResult::NeedPoint;
-        }
+    fn on_entity_pick(&mut self, handle: Handle, pt: DVec3) -> CmdResult {
+        if handle.is_null() || !self.valid_pick { return CmdResult::NeedPoint; }
         self.target = Some(handle);
-        self.waiting_for_n = true;
+        self.pick_point = pt;
+        self.step = Step::Amount;
         CmdResult::NeedPoint
     }
-
-    fn wants_text_input(&self) -> bool {
-        self.waiting_for_n
-    }
-
+    fn wants_text_input(&self) -> bool { self.step != Step::Pick }
     fn dyn_field(&self) -> crate::command::DynField {
-        if self.waiting_for_n {
-            crate::command::DynField::Scalar
-        } else {
-            crate::command::DynField::Point
-        }
+        if self.step == Step::Amount { crate::command::DynField::Scalar }
+        else { crate::command::DynField::Point }
     }
-
+    fn dyn_commit_as_text(&self) -> bool { self.step == Step::Amount }
     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: DVec3) -> CmdResult {
-        CmdResult::NeedPoint
+        let text = text.trim();
+        match self.step {
+            Step::BlockName => {
+                self.block = Some(self.blocks.iter().find(|name| name.eq_ignore_ascii_case(text))?.clone());
+                self.step = Step::Align;
+            }
+            Step::Align => {
+                self.align = match text.to_ascii_uppercase().as_str() {
+                    "Y" | "YES" => true,
+                    "N" | "NO" => false,
+                    _ => return None,
+                };
+                self.step = Step::Amount;
+            }
+            Step::Amount => {
+                if self.block.is_none() && matches!(text.to_ascii_uppercase().as_str(), "B" | "BLOCK") {
+                    self.step = Step::BlockName;
+                } else {
+                    let n = text.parse::<usize>().ok().filter(|n| (2..=32767).contains(n))?;
+                    return Some(CmdResult::DivideEntity { handle: self.target?, n, marker: self.marker() });
+                }
+            }
+            Step::Pick => return None,
+        }
+        Some(CmdResult::NeedPoint)
     }
+    fn on_point(&mut self, _pt: DVec3) -> CmdResult { CmdResult::NeedPoint }
     fn on_enter(&mut self) -> CmdResult {
-        CmdResult::Cancel
+        if self.step == Step::Align {
+            self.align = true;
+            self.step = Step::Amount;
+            CmdResult::NeedPoint
+        } else { CmdResult::Cancel }
     }
 }
 
-// ── MEASURE ────────────────────────────────────────────────────────────────
 
 pub struct MeasureCommand {
     target: Option<Handle>,
@@ -157,23 +196,21 @@ impl CadCommand for MeasureCommand {
     }
 }
 
-// ── Geometry ───────────────────────────────────────────────────────────────
 
-/// Compute N-1 equally spaced points along the entity (DIVIDE).
-pub fn divide_entity(entity: &EntityType, n: usize) -> Vec<EntityType> {
-    if n < 2 {
+pub fn divide_entity(entity: &EntityType, n: usize, marker: Option<&CurveMarker>) -> Vec<EntityType> {
+    if !(2..=32767).contains(&n) {
         return vec![];
     }
     let Some((curve, total)) = measurable(entity) else {
         return vec![];
     };
     let step = total / n as f64;
-    (1..n)
-        .map(|k| make_point(curve.point_at_distance(step * k as f64)))
+    let last = if curve.is_closed() { n } else { n - 1 };
+    (1..=last)
+        .map(|k| make_marker(&curve, step * k as f64, marker))
         .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![];
@@ -190,21 +227,35 @@ pub fn measure_entity(entity: &EntityType, segment_length: f64) -> Vec<EntityTyp
     pts
 }
 
+fn make_marker(curve: &PlanarCurve, distance: f64, marker: Option<&CurveMarker>) -> EntityType {
+    let pos = curve.point_at_distance(distance);
+    let Some(marker) = marker else {
+        let mut point = PointEnt::new();
+        point.location = Vector3::new(pos[0], pos[1], pos[2]);
+        return EntityType::Point(point);
+    };
+    let local = marker.plane.to_local(DVec3::from_array(pos));
+    let mut insert = Insert::new(marker.block.clone(), Vector3::new(local.x, local.y, local.z));
+    if marker.align {
+        let tangent = DVec3::from_array(curve.tangent_at(curve.parameter_at_distance(distance)));
+        let tangent = marker.plane.vector_to_local(tangent);
+        insert.rotation = tangent.y.atan2(tangent.x);
+    }
+    insert.apply_transform(&marker.plane.to_world_transform());
+    EntityType::Insert(insert)
+}
+
 fn make_point(pos: [f64; 3]) -> EntityType {
     let mut p = PointEnt::new();
     p.location = Vector3::new(pos[0], pos[1], pos[2]);
     EntityType::Point(p)
 }
 
-/// The entity's curve and its length, or `None` for anything that cannot be
-/// walked along — a hatch, a block, an unbounded ray.
 fn measurable(entity: &EntityType) -> Option<(PlanarCurve, f64)> {
     let curve = entity_curve(entity)?;
     let total = curve.curve.length();
     (total.is_finite() && total > 1e-10).then_some((curve, total))
 }
 
-
-// ── Autocomplete registry ─────────────────────────────────
-inventory::submit!(crate::command::CommandRegistration { names: &["DIVIDE"] });  // DivideCommand
-inventory::submit!(crate::command::CommandRegistration { names: &["MEASURE"] });  // MeasureCommand
+inventory::submit!(crate::command::CommandRegistration { names: &["DIVIDE"] });
+inventory::submit!(crate::command::CommandRegistration { names: &["MEASURE"] });