Feat: ROADMAP Phase 1-5 batch — trim/extend, plot scale, viewport UX, mline caps, table alignment

- TRIM/EXTEND: Ray and XLine entities supported as cutting boundaries and trim targets;
  trim results in Ray→Line/Ray, XLine→Ray/Ray or Line; hover preview added
- Plot scale override: Fit/1:1/1:2/1:5/1:10/1:20/1:50/1:100/2:1 buttons added to Page Setup
  panel; PageSetupCommit applies scale to PlotSettings
- Viewport UX: locked viewport gets orange border; selected viewport gets white border
- Named view → viewport assignment: Choice dropdown in properties panel copies
  view_target/direction/height to the viewport entity
- MLine caps: perpendicular start/end cap lines added for open (non-closed) MLines
- Wipeout polygon grips: boundary vertices become editable grips when clipping_enabled+Polygonal;
  world→pixel back-projection on drag
- Table cell alignment: CellStyle.alignment (1-9) drives left/center/right + top/middle/bottom
  text positioning; cxf::measure_text() helper added
- New commands/features: DIMCONTINUE (DCO), DIMBASELINE (DBA), TOLERANCE (TOL), TABLE,
  ATTDEF, ATTEDIT, ATTDISP, BREAKATPOINT (BAP), PLOTWINDOW (PW), MLINE (ML);
  DIMSTYLE/DIMCURRENT/CLAYER/LTSCALE/CELTSCALE/SCALETEXT/XDATA/UCSICON/REGEN/DRAWORDER extended
- PLINE arc mode: A/L/CLOSE text input, bulge computation, arc preview
- Warning cleanup: removed unused imports and unreachable patterns

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

src/modules/annotate/dim_baseline.rs

@@ -0,0 +1,138 @@
+// DIMBASELINE command — stacked baseline dimensions all measured from the same origin.
+//
+// Each new point becomes the second extension line origin of a new dimension.
+// The first extension line is always the same base origin point.
+// Each new dimension line is placed further from the baseline by DIMDLI (increment).
+//
+// Constructed from commands.rs after finding the last placed linear/aligned dimension.
+
+use acadrust::entities::{Dimension, DimensionLinear};
+use acadrust::types::Vector3;
+use acadrust::EntityType;
+use glam::Vec3;
+
+use crate::command::{CadCommand, CmdResult};
+use crate::scene::wire_model::WireModel;
+
+/// Default stacking increment (world units) between successive baseline dimensions.
+const DIMDLI: f32 = 1.5;
+
+pub struct DimBaselineCommand {
+    /// Fixed first-extension-line origin (never changes).
+    base_p1: Vec3,
+    /// Direction along the measurement direction (0.0 = horizontal, PI/2 = vertical).
+    rotation: f64,
+    /// Unit vector perpendicular to the dimension axis, pointing toward the dim line side.
+    perp: Vec3,
+    /// Perpendicular distance of the NEXT dimension line from the extension-line axis.
+    next_offset: f32,
+    /// True once we have a base dimension loaded.
+    ready: bool,
+}
+
+impl DimBaselineCommand {
+    /// No base dim found — cancel immediately.
+    pub fn new() -> Self {
+        Self {
+            base_p1: Vec3::ZERO,
+            rotation: 0.0,
+            perp: Vec3::Y,
+            next_offset: DIMDLI,
+            ready: false,
+        }
+    }
+
+    /// Build from the last placed dimension.
+    ///
+    /// `p1` — first extension line origin (fixed baseline).
+    /// `p2` — second extension line origin of the base dim (unused for placement, kept for context).
+    /// `definition_point` — dim-line position of the base dim (defines perpendicular side).
+    /// `rotation` — 0.0 = horizontal, PI/2 = vertical.
+    pub fn from_base(p1: Vec3, _p2: Vec3, definition_point: Vec3, rotation: f64) -> Self {
+        let axis = if rotation.abs() < 0.1 { Vec3::X } else { Vec3::Y };
+        let perp = Vec3::new(-axis.y, axis.x, 0.0);
+        let base_offset = (definition_point - p1).dot(perp);
+        // Next baseline dim goes one DIMDLI further from the baseline.
+        let next_offset = base_offset + DIMDLI;
+        Self {
+            base_p1: p1,
+            rotation,
+            perp,
+            next_offset,
+            ready: true,
+        }
+    }
+}
+
+impl CadCommand for DimBaselineCommand {
+    fn name(&self) -> &'static str { "DIMBASELINE" }
+
+    fn prompt(&self) -> String {
+        if !self.ready {
+            "DIMBASELINE  No base dimension found. Place a dimension first.".into()
+        } else {
+            "DIMBASELINE  Specify a second extension line origin (Enter to exit):".into()
+        }
+    }
+
+    fn on_point(&mut self, pt: Vec3) -> CmdResult {
+        if !self.ready {
+            return CmdResult::Cancel;
+        }
+        let p1 = self.base_p1;
+        let p2 = pt;
+
+        // Build a new linear dimension.
+        let mut dim = DimensionLinear::new(v3(p1), v3(p2));
+        dim.rotation = self.rotation;
+
+        let dim_line_pt = p1 + self.perp * self.next_offset;
+        let dim_line_pt2 = p2 + self.perp * self.next_offset;
+        dim.definition_point = v3(dim_line_pt);
+        dim.base.definition_point = v3(dim_line_pt);
+        dim.base.text_middle_point = v3((dim_line_pt + dim_line_pt2) * 0.5);
+        dim.base.insertion_point = dim.base.text_middle_point;
+        dim.base.actual_measurement = dim.measurement();
+
+        // Stack the next dim line further out.
+        self.next_offset += DIMDLI;
+
+        CmdResult::CommitEntity(EntityType::Dimension(Dimension::Linear(dim)))
+    }
+
+    fn on_enter(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+
+    fn on_mouse_move(&mut self, pt: Vec3) -> Option<WireModel> {
+        if !self.ready {
+            return None;
+        }
+        let p1 = self.base_p1;
+        let dim_line_pt = p1 + self.perp * self.next_offset;
+        let dim_line_pt2 = pt + self.perp * self.next_offset;
+        Some(WireModel {
+            name: "dimbase_preview".into(),
+            points: vec![
+                [p1.x, p1.y, p1.z], [dim_line_pt.x, dim_line_pt.y, dim_line_pt.z],
+                [f32::NAN, 0.0, 0.0],
+                [pt.x, pt.y, pt.z], [dim_line_pt2.x, dim_line_pt2.y, dim_line_pt2.z],
+                [f32::NAN, 0.0, 0.0],
+                [dim_line_pt.x, dim_line_pt.y, dim_line_pt.z],
+                [dim_line_pt2.x, dim_line_pt2.y, dim_line_pt2.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![],
+            key_vertices: vec![],
+        })
+    }
+}
+
+fn v3(p: Vec3) -> Vector3 {
+    Vector3::new(p.x as f64, p.y as f64, p.z as f64)
+}

src/modules/annotate/dim_continue.rs

@@ -0,0 +1,135 @@
+// DIMCONTINUE command — chain linear/aligned dimensions end-to-end.
+//
+// Each new point becomes the second extension line origin of a new dimension,
+// whose first extension line origin is the second extension line of the previous dim.
+// The dimension line stays at the same perpendicular offset as the base dimension.
+//
+// Constructed from commands.rs after finding the last placed linear/aligned dimension.
+
+use acadrust::entities::{Dimension, DimensionLinear};
+use acadrust::types::Vector3;
+use acadrust::EntityType;
+use glam::Vec3;
+
+use crate::command::{CadCommand, CmdResult};
+use crate::scene::wire_model::WireModel;
+
+pub struct DimContinueCommand {
+    /// Fixed first-extension-line origin for the current step (moves each iteration).
+    chain_p1: Vec3,
+    /// Direction along the dimension axis (0.0 = horizontal, PI/2 = vertical).
+    rotation: f64,
+    /// Perpendicular distance from the extension-line axis to the dimension line.
+    /// Preserved from the base dimension.
+    dim_offset: f32,
+    /// Direction of "up" perpendicular to the dim axis (points toward the dim line).
+    perp: Vec3,
+    /// True once we have a base dimension loaded.
+    ready: bool,
+}
+
+impl DimContinueCommand {
+    /// No base dim found — will show an error prompt and cancel immediately.
+    pub fn new() -> Self {
+        Self {
+            chain_p1: Vec3::ZERO,
+            rotation: 0.0,
+            dim_offset: 0.0,
+            perp: Vec3::Y,
+            ready: false,
+        }
+    }
+
+    /// Build from the last placed dimension.
+    ///
+    /// `p1` / `p2` — extension line origins of the base dim.
+    /// `definition_point` — where the dim line was placed (defines perpendicular offset).
+    /// `rotation` — 0.0 = horizontal dim, PI/2 = vertical dim.
+    pub fn from_base(p1: Vec3, p2: Vec3, definition_point: Vec3, rotation: f64) -> Self {
+        // Axis unit vector along the measurement direction.
+        let axis = if rotation.abs() < 0.1 { Vec3::X } else { Vec3::Y };
+        // Perpendicular unit vector toward the dim line.
+        let perp = Vec3::new(-axis.y, axis.x, 0.0);
+        let dim_offset = (definition_point - p1).dot(perp);
+        Self {
+            chain_p1: p2,
+            rotation,
+            dim_offset,
+            perp,
+            ready: true,
+        }
+    }
+}
+
+impl CadCommand for DimContinueCommand {
+    fn name(&self) -> &'static str { "DIMCONTINUE" }
+
+    fn prompt(&self) -> String {
+        if !self.ready {
+            "DIMCONTINUE  No base dimension found. Place a dimension first.".into()
+        } else {
+            "DIMCONTINUE  Specify a second extension line origin (Enter to exit):".into()
+        }
+    }
+
+    fn on_point(&mut self, pt: Vec3) -> CmdResult {
+        if !self.ready {
+            return CmdResult::Cancel;
+        }
+        let p1 = self.chain_p1;
+        let p2 = pt;
+
+        // Build a new linear dimension.
+        let mut dim = DimensionLinear::new(v3(p1), v3(p2));
+        dim.rotation = self.rotation;
+
+        // Dim-line position: same perpendicular distance as base.
+        let dim_line_pt = p1 + self.perp * self.dim_offset;
+        dim.definition_point = v3(dim_line_pt);
+        dim.base.definition_point = v3(dim_line_pt);
+        dim.base.text_middle_point = v3((dim_line_pt + (p2 + self.perp * self.dim_offset)) * 0.5);
+        dim.base.insertion_point = dim.base.text_middle_point;
+        dim.base.actual_measurement = dim.measurement();
+
+        // Advance chain: next dim's P1 = this dim's P2.
+        self.chain_p1 = p2;
+
+        CmdResult::CommitEntity(EntityType::Dimension(Dimension::Linear(dim)))
+    }
+
+    fn on_enter(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+
+    fn on_mouse_move(&mut self, pt: Vec3) -> Option<WireModel> {
+        if !self.ready {
+            return None;
+        }
+        let p1 = self.chain_p1;
+        let dim_line_pt = p1 + self.perp * self.dim_offset;
+        let dim_line_pt2 = pt + self.perp * self.dim_offset;
+        Some(WireModel {
+            name: "dimcont_preview".into(),
+            points: vec![
+                [p1.x, p1.y, p1.z], [dim_line_pt.x, dim_line_pt.y, dim_line_pt.z],
+                [f32::NAN, 0.0, 0.0],
+                [pt.x, pt.y, pt.z], [dim_line_pt2.x, dim_line_pt2.y, dim_line_pt2.z],
+                [f32::NAN, 0.0, 0.0],
+                [dim_line_pt.x, dim_line_pt.y, dim_line_pt.z],
+                [dim_line_pt2.x, dim_line_pt2.y, dim_line_pt2.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![],
+            key_vertices: vec![],
+        })
+    }
+}
+
+fn v3(p: Vec3) -> Vector3 {
+    Vector3::new(p.x as f64, p.y as f64, p.z as f64)
+}

src/modules/annotate/mod.rs

@@ -3,12 +3,16 @@
 pub mod aligned_dim;
 pub mod angular_dim;
 pub mod diameter_dim;
+pub mod dim_baseline;
+pub mod dim_continue;
 pub mod leader_cmd;
 pub mod linear_dim;
 pub mod mleader_cmd;
 pub mod mtext;
 pub mod radius_dim;
+pub mod table_cmd;
 pub mod text;
+pub mod tolerance_cmd;
 
 use crate::modules::{CadModule, RibbonGroup, RibbonItem};
 

src/modules/annotate/table_cmd.rs

@@ -0,0 +1,139 @@
+// TABLE command — create an empty table entity.
+//
+// Workflow:
+//   1. Text: Enter number of columns  (default 3)
+//   2. Text: Enter number of rows     (default 4, includes header row)
+//   3. Point: Click insertion point
+//
+// Creates a Table entity with uniform row height (0.5) and column width (2.0).
+
+use acadrust::entities::TableBuilder;
+use acadrust::types::Vector3;
+use acadrust::EntityType;
+use glam::Vec3;
+
+use crate::command::{CadCommand, CmdResult};
+use crate::scene::wire_model::WireModel;
+
+const DEFAULT_COLS: usize = 3;
+const DEFAULT_ROWS: usize = 4;
+const COL_WIDTH: f64 = 2.0;
+const ROW_HEIGHT: f64 = 0.5;
+
+enum Step {
+    Columns,
+    Rows { cols: usize },
+    Insertion { cols: usize, rows: usize },
+}
+
+pub struct TableCommand {
+    step: Step,
+}
+
+impl TableCommand {
+    pub fn new() -> Self {
+        Self { step: Step::Columns }
+    }
+}
+
+impl CadCommand for TableCommand {
+    fn name(&self) -> &'static str { "TABLE" }
+
+    fn prompt(&self) -> String {
+        match &self.step {
+            Step::Columns => format!("TABLE  Enter number of columns [{DEFAULT_COLS}]:"),
+            Step::Rows { cols } => format!("TABLE  Enter number of rows (incl. header) [{DEFAULT_ROWS}]  ({cols} cols):"),
+            Step::Insertion { cols, rows } => format!("TABLE  Specify insertion point  [{cols}×{rows}]:"),
+        }
+    }
+
+    fn wants_text_input(&self) -> bool {
+        !matches!(self.step, Step::Insertion { .. })
+    }
+
+    fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
+        let t = text.trim();
+        match &self.step {
+            Step::Columns => {
+                let cols = if t.is_empty() {
+                    DEFAULT_COLS
+                } else {
+                    t.parse::<usize>().ok().filter(|&n| n >= 1)?
+                };
+                self.step = Step::Rows { cols };
+                Some(CmdResult::NeedPoint)
+            }
+            Step::Rows { cols } => {
+                let cols = *cols;
+                let rows = if t.is_empty() {
+                    DEFAULT_ROWS
+                } else {
+                    t.parse::<usize>().ok().filter(|&n| n >= 1)?
+                };
+                self.step = Step::Insertion { cols, rows };
+                Some(CmdResult::NeedPoint)
+            }
+            Step::Insertion { .. } => None,
+        }
+    }
+
+    fn on_enter(&mut self) -> CmdResult {
+        match &self.step {
+            Step::Columns => {
+                // Accept default.
+                self.step = Step::Rows { cols: DEFAULT_COLS };
+                CmdResult::NeedPoint
+            }
+            Step::Rows { cols } => {
+                let cols = *cols;
+                self.step = Step::Insertion { cols, rows: DEFAULT_ROWS };
+                CmdResult::NeedPoint
+            }
+            Step::Insertion { .. } => CmdResult::Cancel,
+        }
+    }
+
+    fn on_point(&mut self, pt: Vec3) -> CmdResult {
+        if let Step::Insertion { cols, rows } = self.step {
+            let ins = Vector3::new(pt.x as f64, pt.z as f64, pt.y as f64);
+            let table = TableBuilder::new(rows, cols)
+                .at(ins)
+                .row_height(ROW_HEIGHT)
+                .column_width(COL_WIDTH)
+                .build();
+            CmdResult::CommitAndExit(EntityType::Table(table))
+        } else {
+            CmdResult::NeedPoint
+        }
+    }
+
+    fn on_mouse_move(&mut self, pt: Vec3) -> Option<WireModel> {
+        if let Step::Insertion { cols, rows } = self.step {
+            // Preview: outline of the table bounding box.
+            let w = (cols as f32) * COL_WIDTH as f32;
+            let h = (rows as f32) * ROW_HEIGHT as f32;
+            let x = pt.x;
+            let y = pt.y;
+            let z = pt.z;
+            Some(WireModel {
+                name: "table_preview".into(),
+                points: vec![
+                    [x, y, z], [x + w, y, z],
+                    [x + w, y, z], [x + w, y, z - h],
+                    [x + w, y, z - h], [x, y, z - h],
+                    [x, y, z - h], [x, y, 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![],
+                key_vertices: vec![],
+            })
+        } else {
+            None
+        }
+    }
+}

src/modules/annotate/tolerance_cmd.rs

@@ -0,0 +1,89 @@
+// TOLERANCE command — place a GD&T (geometric dimensioning & tolerancing) frame.
+//
+// Workflow:
+//   1. Text: Enter tolerance string  (e.g. "%%v0.05|A" or plain text)
+//   2. Point: Click insertion point
+
+use acadrust::entities::Tolerance;
+use acadrust::types::Vector3;
+use acadrust::EntityType;
+use glam::Vec3;
+
+use crate::command::{CadCommand, CmdResult};
+use crate::scene::wire_model::WireModel;
+
+enum Step {
+    Text,
+    Insertion { text: String },
+}
+
+pub struct ToleranceCommand {
+    step: Step,
+}
+
+impl ToleranceCommand {
+    pub fn new() -> Self {
+        Self { step: Step::Text }
+    }
+}
+
+impl CadCommand for ToleranceCommand {
+    fn name(&self) -> &'static str { "TOLERANCE" }
+
+    fn prompt(&self) -> String {
+        match &self.step {
+            Step::Text => "TOLERANCE  Enter tolerance text:".into(),
+            Step::Insertion { text } => format!("TOLERANCE  Specify insertion point  [{text}]:"),
+        }
+    }
+
+    fn wants_text_input(&self) -> bool {
+        matches!(self.step, Step::Text)
+    }
+
+    fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
+        let t = text.trim().to_string();
+        if t.is_empty() {
+            return Some(CmdResult::Cancel);
+        }
+        self.step = Step::Insertion { text: t };
+        Some(CmdResult::NeedPoint)
+    }
+
+    fn on_point(&mut self, pt: Vec3) -> CmdResult {
+        if let Step::Insertion { text } = &self.step {
+            let ins = Vector3::new(pt.x as f64, pt.z as f64, pt.y as f64);
+            let tol = Tolerance::with_text(ins, text.clone());
+            CmdResult::CommitAndExit(EntityType::Tolerance(tol))
+        } else {
+            CmdResult::NeedPoint
+        }
+    }
+
+    fn on_enter(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+
+    fn on_mouse_move(&mut self, pt: Vec3) -> Option<WireModel> {
+        if !matches!(self.step, Step::Insertion { .. }) {
+            return None;
+        }
+        let d = 0.15_f32;
+        Some(WireModel {
+            name: "tolerance_preview".into(),
+            points: vec![
+                [pt.x - d, pt.y, pt.z], [pt.x + d, pt.y, pt.z],
+                [f32::NAN, 0.0, 0.0],
+                [pt.x, pt.y, pt.z - d], [pt.x, pt.y, pt.z + d],
+            ],
+            color: WireModel::CYAN,
+            selected: false,
+            pattern_length: 0.0,
+            pattern: [0.0; 8],
+            line_weight_px: 1.0,
+            snap_pts: vec![],
+            tangent_geoms: vec![],
+            key_vertices: vec![],
+        })
+    }
+}