forked from 1b-agent/opencadstudio-upstream
Hakan Seven
8c61d89b1e
Apply each layout's embedded page setup and plot style consistently across display, PDF, printing, and multi-layout output.\n\nRefs #844
812 lines
33 KiB
Rust
812 lines
33 KiB
Rust
use crate::command::CadCommand;
|
|
use crate::io::linetypes;
|
|
use crate::modules::draw::modify::block_edit::BlockEditSession;
|
|
use crate::modules::draw::modify::refedit::RefEditSession;
|
|
use crate::scene::pick::grip::GripEdit;
|
|
use crate::scene::GripDef;
|
|
use crate::scene::{ObjectIsolationState, Scene};
|
|
use crate::snap::SnapResult;
|
|
use crate::ui::{LayerPanel, PropertiesPanel};
|
|
use acadrust::tables::{normalize_name, Ucs};
|
|
use acadrust::{CadDocument, EntityType, Handle};
|
|
use iced;
|
|
use crate::t;
|
|
use std::any::Any;
|
|
use std::collections::HashMap;
|
|
use std::path::PathBuf;
|
|
use std::sync::atomic::{AtomicU64, Ordering};
|
|
use std::sync::Arc;
|
|
|
|
static NEXT_DOCUMENT_TAB_ID: AtomicU64 = AtomicU64::new(1);
|
|
|
|
// ── Dynamic input ──────────────────────────────────────────────────────────
|
|
|
|
/// One quantity shown in the dynamic-input overlay near the cursor.
|
|
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
|
pub(super) enum DynComponent {
|
|
/// Absolute X ordinate.
|
|
X,
|
|
/// Absolute Y ordinate.
|
|
Y,
|
|
/// Absolute Z ordinate (only visible after the user types a second
|
|
/// `,` separator from a cartesian X/Y configuration).
|
|
Z,
|
|
/// Linear distance from the last point.
|
|
Distance,
|
|
/// Angle from the last point, in degrees.
|
|
Angle,
|
|
/// A scalar the command reads from the command line (a count, a radius,
|
|
/// a delta). Typed-only — it has no geometric live value derived from
|
|
/// the cursor unless the command supplies one via `dyn_live_value`.
|
|
Scalar,
|
|
}
|
|
|
|
/// A single editable dynamic-input field. `buffer == None` means the box
|
|
/// tracks the cursor live; once the user types, the typed text is held in
|
|
/// `buffer` and the box stops following the cursor (it is "locked").
|
|
#[derive(Clone, Debug)]
|
|
pub(super) struct DynFieldEntry {
|
|
pub(super) component: DynComponent,
|
|
/// Semantic role — drives the label and value scaling (e.g. diameter).
|
|
/// Defaults to the role matching `component` on the legacy path.
|
|
pub(super) role: crate::command::DynRole,
|
|
pub(super) buffer: Option<String>,
|
|
}
|
|
|
|
impl DynFieldEntry {
|
|
pub(super) fn new(component: DynComponent) -> Self {
|
|
Self {
|
|
component,
|
|
role: default_role_for(component),
|
|
buffer: None,
|
|
}
|
|
}
|
|
/// Build from an explicit role (spec-driven path); the resolution
|
|
/// component is derived from the role.
|
|
pub(super) fn from_role(role: crate::command::DynRole) -> Self {
|
|
Self {
|
|
component: component_for_role(role),
|
|
role,
|
|
buffer: None,
|
|
}
|
|
}
|
|
pub(super) fn locked(&self) -> bool {
|
|
self.buffer.is_some()
|
|
}
|
|
}
|
|
|
|
/// Map a [`DynRole`](crate::command::DynRole) to the ordinate/distance/angle
|
|
/// component used by point resolution.
|
|
pub(super) fn component_for_role(role: crate::command::DynRole) -> DynComponent {
|
|
use crate::command::DynRole;
|
|
match role {
|
|
DynRole::X | DynRole::Width => DynComponent::X,
|
|
DynRole::Y | DynRole::Height => DynComponent::Y,
|
|
DynRole::Z => DynComponent::Z,
|
|
DynRole::Distance | DynRole::Radius | DynRole::Diameter => DynComponent::Distance,
|
|
DynRole::Angle => DynComponent::Angle,
|
|
DynRole::Factor | DynRole::Count => DynComponent::Scalar,
|
|
}
|
|
}
|
|
|
|
fn default_role_for(component: DynComponent) -> crate::command::DynRole {
|
|
use crate::command::DynRole;
|
|
match component {
|
|
DynComponent::X => DynRole::X,
|
|
DynComponent::Y => DynRole::Y,
|
|
DynComponent::Z => DynRole::Z,
|
|
DynComponent::Distance => DynRole::Distance,
|
|
DynComponent::Angle => DynRole::Angle,
|
|
DynComponent::Scalar => DynRole::Factor,
|
|
}
|
|
}
|
|
|
|
// ── Per-document tab state ─────────────────────────────────────────────────
|
|
|
|
pub(super) struct DocumentTab {
|
|
/// Stable identity across tab insert/remove operations. Background work
|
|
/// must never target a tab by its transient vector index.
|
|
pub(super) id: u64,
|
|
pub(super) scene: Scene,
|
|
pub(super) current_path: Option<PathBuf>,
|
|
/// Persistent native edit lease for the drawing currently at
|
|
/// `current_path`. The sidecar portion survives atomic file replacement.
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
pub(super) edit_lease: Option<crate::io::edit_lock::EditLease>,
|
|
/// True when another editor owns the drawing lease. Direct Save stays
|
|
/// blocked until Retry acquires it or the user chooses Save As.
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
pub(super) edit_lock_conflict: bool,
|
|
/// Disk state observed after open or the latest successful save.
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
pub(super) disk_fingerprint: Option<crate::io::edit_lock::FileFingerprint>,
|
|
pub(super) dirty: bool,
|
|
/// Direct Save is redirected to Save As after open-time repairs so the
|
|
/// source drawing cannot be overwritten accidentally.
|
|
pub(super) recovery_save_as_required: bool,
|
|
/// Monotonic committed-edit/undo/redo revision. Background save completion
|
|
/// uses it with scene epochs so an older snapshot never clears newer work.
|
|
pub(super) edit_revision: u64,
|
|
pub(super) tab_title: String,
|
|
pub(super) properties: PropertiesPanel,
|
|
pub(super) layers: LayerPanel,
|
|
pub(super) active_cmd: Option<Box<dyn CadCommand>>,
|
|
/// The selection set the most recent command worked on, captured when a
|
|
/// finishing command drops the live selection — re-selectable with the
|
|
/// "Previous" keyword at any Select objects prompt (#426).
|
|
pub(super) prev_selection: Vec<acadrust::Handle>,
|
|
pub(super) last_cmd: Option<String>,
|
|
/// Most recently created path drawable. A fresh LINE/PLINE can accept its
|
|
/// current final endpoint with Enter before the first click.
|
|
pub(super) last_draw_anchor: Option<Handle>,
|
|
pub(super) snap_result: Option<SnapResult>,
|
|
pub(super) active_grip: Option<GripEdit>,
|
|
pub(super) selected_grips: Vec<GripDef>,
|
|
/// Entity handle for each entry in `selected_grips`.
|
|
pub(super) selected_grip_handles: Vec<Handle>,
|
|
/// Shift-selected grips, keyed by entity and object-local grip id.
|
|
pub(super) hot_grips: rustc_hash::FxHashSet<(Handle, usize)>,
|
|
pub(super) selected_handle: Option<Handle>,
|
|
/// Dynamic-block visibility grip for the current single selection.
|
|
pub(super) visibility_grip: Option<super::visibility::VisibilityGrip>,
|
|
pub(super) wireframe: bool,
|
|
pub(super) render_mode: acadrust::entities::ViewportRenderMode,
|
|
pub(super) visual_style: String,
|
|
pub(super) last_cursor_world: glam::DVec3,
|
|
pub(super) last_cursor_screen: iced::Point,
|
|
/// Base point (`App::last_point`) projected to viewport pixels, refreshed
|
|
/// on cursor move. Lets the dynamic-input overlay place the distance label
|
|
/// along the rubber-band line and the angle label at its end.
|
|
pub(super) last_point_screen: Option<iced::Point>,
|
|
/// Dynamic-input fields shown near the cursor while a command waits
|
|
/// for a point/distance/angle. Rebuilt whenever the active command's
|
|
/// `dyn_field()` or the presence of a base point changes. Empty when
|
|
/// dynamic input is not active.
|
|
pub(super) dyn_fields: Vec<DynFieldEntry>,
|
|
/// Guide geometry the overlay draws for the current step (set alongside
|
|
/// `dyn_fields`). Polar arc, radius line, axis-delta projections, etc.
|
|
pub(super) dyn_guide: crate::command::DynGuide,
|
|
/// World-space anchor the current step's values are measured from. `None`
|
|
/// falls back to `App::last_point`.
|
|
pub(super) dyn_anchor: Option<glam::DVec3>,
|
|
/// Far end of a reference line through `dyn_anchor` (for the `Perp` guide:
|
|
/// the base edge / major axis the offset is measured square to).
|
|
pub(super) dyn_ref: Option<glam::DVec3>,
|
|
/// `dyn_ref` projected to viewport pixels.
|
|
pub(super) dyn_ref_screen: Option<iced::Point>,
|
|
/// Index of the field that TAB has focused (the one keystrokes edit).
|
|
pub(super) dyn_active: usize,
|
|
pub(super) history: HistoryState,
|
|
pub(super) active_layer: String,
|
|
/// Currently active UCS. `None` means WCS (identity transform).
|
|
pub(super) active_ucs: Option<Ucs>,
|
|
/// Custom model-space background color. `None` = default dark grey.
|
|
pub(super) bg_color: Option<[f32; 4]>,
|
|
/// Custom paper-space background color. `None` = default off-white grey.
|
|
pub(super) paper_bg_color: Option<[f32; 4]>,
|
|
/// Active REFEDIT session, if any.
|
|
pub(super) refedit_session: Option<RefEditSession>,
|
|
/// Open BEDIT block tabs. Definitions are edited live; each tab owns its
|
|
/// entry snapshot and camera so nested blocks can remain open independently.
|
|
pub(super) block_edits: Vec<BlockEditSession>,
|
|
/// Index of the block tab currently shown, or `None` for Model/Paper space.
|
|
pub(super) active_block_edit: Option<usize>,
|
|
/// Currently active MLeader style name.
|
|
pub(super) active_mleader_style: String,
|
|
/// Last camera_generation value written back to the document.
|
|
pub(super) last_synced_camera_gen: u64,
|
|
/// Sentinel "Welcome / Start" tab. Always at index 0 when present.
|
|
/// Cannot be closed; the viewport area renders a welcome page instead
|
|
/// of the model-space shader. The scene is still constructed so the
|
|
/// rest of the code can treat it as a normal tab when reading.
|
|
pub(super) is_start: bool,
|
|
/// Interactive PAN mode (the PAN command / tool). While active, a left-
|
|
/// button drag pans the view instead of selecting — the only pan path on a
|
|
/// device with no middle mouse button (a trackpad / web client). Exited
|
|
/// with Esc or by starting another command.
|
|
pub(super) pan_mode: bool,
|
|
/// Interactive 3-D orbit mode. While active, a left-button drag follows
|
|
/// the same camera-orbit path as Shift + middle-button drag.
|
|
pub(super) orbit_mode: bool,
|
|
/// Interactive ZOOM Dynamic mode. A left drag pans horizontally and zooms
|
|
/// vertically until Escape or another command ends the mode.
|
|
pub(super) zoom_dynamic_mode: bool,
|
|
/// Per-plugin document state (`plugin::BuiltinPlugin` manifest id → state).
|
|
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
|
|
pub(super) plugin_state: HashMap<&'static str, Box<dyn Any + Send + Sync>>,
|
|
pub(super) suspended_cmd: Option<Box<dyn CadCommand>>,
|
|
}
|
|
|
|
impl DocumentTab {
|
|
pub(super) fn rename_layer(&mut self, old_name: &str, new_name: &str) -> bool {
|
|
let active = normalize_name(&self.active_layer) == normalize_name(old_name);
|
|
if !self.scene.rename_layer(old_name, new_name) {
|
|
return false;
|
|
}
|
|
if active {
|
|
self.active_layer = new_name.to_string();
|
|
}
|
|
self.dirty = true;
|
|
true
|
|
}
|
|
|
|
pub(super) fn active_block_edit_session(&self) -> Option<&BlockEditSession> {
|
|
self.active_block_edit
|
|
.and_then(|index| self.block_edits.get(index))
|
|
}
|
|
|
|
pub(super) fn active_block_edit_session_mut(&mut self) -> Option<&mut BlockEditSession> {
|
|
self.active_block_edit
|
|
.and_then(|index| self.block_edits.get_mut(index))
|
|
}
|
|
|
|
/// The active WCS↔UCS converter for this tab — identity when no UCS is set.
|
|
/// Every consumer that needs UCS-relative coordinates goes through this.
|
|
pub(super) fn ucs_xform(&self) -> super::helpers::UcsXform {
|
|
super::helpers::UcsXform::from_active(self.active_ucs.as_ref())
|
|
}
|
|
|
|
/// World-space UCS origin in full f64 precision (stored f64 in the header /
|
|
/// viewport). Used to anchor the UCS icon and as the cursor-pick plane point
|
|
/// — `UcsXform`'s origin is f32 and would quantize the anchor at UTM scale.
|
|
pub(super) fn ucs_origin_world(&self) -> glam::DVec3 {
|
|
self.active_ucs
|
|
.as_ref()
|
|
.map(|u| glam::dvec3(u.origin.x, u.origin.y, u.origin.z))
|
|
.unwrap_or(glam::DVec3::ZERO)
|
|
}
|
|
|
|
/// True when the active pane has a drawing coordinate plane.
|
|
pub(super) fn editing_model_space(&self) -> bool {
|
|
self.scene.current_layout == "Model"
|
|
|| self.scene.active_viewport.is_some()
|
|
|| self.active_ucs.is_some()
|
|
}
|
|
|
|
/// The document's saved model-space UCS (header), as a `Ucs`. `None` when it
|
|
/// is identity (plain WCS).
|
|
pub(super) fn model_ucs_from_header(&self) -> Option<Ucs> {
|
|
let h = &self.scene.document.header;
|
|
let mut u = if h.model_space_ucs_name.is_empty() {
|
|
Ucs::new("*ACTIVE*")
|
|
} else {
|
|
self.scene
|
|
.document
|
|
.ucss
|
|
.get(&h.model_space_ucs_name)
|
|
.cloned()
|
|
.unwrap_or_else(|| Ucs::new(h.model_space_ucs_name.clone()))
|
|
};
|
|
u.origin = h.model_space_ucs_origin;
|
|
u.x_axis = h.model_space_ucs_x_axis;
|
|
u.y_axis = h.model_space_ucs_y_axis;
|
|
if h.model_space_ucs_name.is_empty()
|
|
&& super::helpers::UcsXform::from_ucs(&u).is_identity()
|
|
{
|
|
None
|
|
} else {
|
|
Some(u)
|
|
}
|
|
}
|
|
|
|
/// A floating viewport's own per-viewport UCS, if it has one set. `None`
|
|
/// when the viewport uses world coordinates or the handle is not a viewport.
|
|
pub(super) fn ucs_from_viewport(&self, h: Handle) -> Option<Ucs> {
|
|
let vp = match self.scene.document.get_entity(h) {
|
|
Some(acadrust::EntityType::Viewport(vp)) => vp,
|
|
_ => return None,
|
|
};
|
|
if !vp.ucs_per_viewport {
|
|
return None;
|
|
}
|
|
let mut u = if vp.ucs_handle.is_null() {
|
|
Ucs::new("*VPUCS*")
|
|
} else {
|
|
self.scene
|
|
.document
|
|
.ucss
|
|
.iter()
|
|
.find(|ucs| ucs.handle == vp.ucs_handle)
|
|
.cloned()
|
|
.unwrap_or_else(|| Ucs::new("*VPUCS*"))
|
|
};
|
|
u.origin = vp.ucs_origin;
|
|
u.x_axis = vp.ucs_x_axis;
|
|
u.y_axis = vp.ucs_y_axis;
|
|
if vp.ucs_handle.is_null() && super::helpers::UcsXform::from_ucs(&u).is_identity() {
|
|
None
|
|
} else {
|
|
Some(u)
|
|
}
|
|
}
|
|
|
|
pub(super) fn ucs_from_layout(&self) -> Option<Ucs> {
|
|
let layout = self.scene.document.objects.values().find_map(|object| {
|
|
let acadrust::objects::ObjectType::Layout(layout) = object else {
|
|
return None;
|
|
};
|
|
(layout.name == self.scene.current_layout).then_some(layout)
|
|
})?;
|
|
let mut ucs = self
|
|
.scene
|
|
.document
|
|
.ucss
|
|
.iter()
|
|
.find(|ucs| ucs.handle == layout.named_ucs)
|
|
.cloned()
|
|
.unwrap_or_else(|| Ucs::new("*PAPERUCS*"));
|
|
ucs.origin = acadrust::types::Vector3::new(
|
|
layout.ucs_origin.0,
|
|
layout.ucs_origin.1,
|
|
layout.ucs_origin.2,
|
|
);
|
|
ucs.x_axis = acadrust::types::Vector3::new(
|
|
layout.ucs_x_axis.0,
|
|
layout.ucs_x_axis.1,
|
|
layout.ucs_x_axis.2,
|
|
);
|
|
ucs.y_axis = acadrust::types::Vector3::new(
|
|
layout.ucs_y_axis.0,
|
|
layout.ucs_y_axis.1,
|
|
layout.ucs_y_axis.2,
|
|
);
|
|
ucs.elevation = layout.elevation;
|
|
ucs.ortho_type = layout.ucs_ortho_type;
|
|
ucs.named_ucs_handle = layout.named_ucs;
|
|
ucs.base_ucs_handle = layout.base_ucs;
|
|
let is_world = layout.named_ucs.is_null()
|
|
&& layout.base_ucs.is_null()
|
|
&& layout.ucs_ortho_type == 0
|
|
&& layout.elevation.abs() <= f64::EPSILON
|
|
&& super::helpers::UcsXform::from_ucs(&ucs).is_identity();
|
|
(!is_world).then_some(ucs)
|
|
}
|
|
|
|
/// Set `active_ucs` to the UCS of the *current pane*: the entered viewport's
|
|
/// own per-viewport UCS, the model header UCS, or the layout UCS. Keeps the
|
|
/// ViewCube in lock-step. Call on every pane
|
|
/// change (enter/exit viewport, layout / tab switch, load) so one field
|
|
/// drives all UCS-aware systems regardless of where editing happens.
|
|
pub(super) fn refresh_active_ucs(&mut self) {
|
|
self.active_ucs = if let Some(session) = self.active_block_edit_session() {
|
|
session.editor_ucs.clone()
|
|
} else if let Some(h) = self.scene.active_viewport {
|
|
self.ucs_from_viewport(h)
|
|
} else if self.scene.current_layout == "Model" {
|
|
self.model_ucs_from_header()
|
|
} else {
|
|
self.ucs_from_layout()
|
|
};
|
|
if self.active_block_edit.is_none()
|
|
&& self.scene.active_viewport.is_none()
|
|
&& self.scene.current_layout != "Model"
|
|
{
|
|
self.sync_paper_ucs_header();
|
|
}
|
|
self.sync_ucs_to_scene();
|
|
}
|
|
|
|
fn sync_paper_ucs_header(&mut self) {
|
|
use acadrust::types::Vector3;
|
|
let header = &mut self.scene.document.header;
|
|
match &self.active_ucs {
|
|
Some(ucs) => {
|
|
header.paper_space_ucs_origin = ucs.origin;
|
|
header.paper_space_ucs_x_axis = ucs.x_axis;
|
|
header.paper_space_ucs_y_axis = ucs.y_axis;
|
|
header.paper_elevation = ucs.elevation;
|
|
header.paper_space_ucs_name = if (ucs.named_ucs_handle.is_valid()
|
|
|| ucs.handle.is_valid())
|
|
&& !ucs.name.starts_with('*')
|
|
{
|
|
ucs.name.clone()
|
|
} else {
|
|
String::new()
|
|
};
|
|
header.paper_ucs_ortho_ref = ucs.base_ucs_handle;
|
|
header.paper_ucs_ortho_view = ucs.ortho_type;
|
|
}
|
|
None => {
|
|
header.paper_space_ucs_origin = Vector3::ZERO;
|
|
header.paper_space_ucs_x_axis = Vector3::UNIT_X;
|
|
header.paper_space_ucs_y_axis = Vector3::UNIT_Y;
|
|
header.paper_elevation = 0.0;
|
|
header.paper_space_ucs_name.clear();
|
|
header.paper_ucs_ortho_ref = Handle::NULL;
|
|
header.paper_ucs_ortho_view = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Persist `active_ucs` back to its pane's storage so it round-trips: the
|
|
/// entered viewport's per-viewport UCS fields, or the document header's
|
|
/// model-space UCS in the Model tab, or the layout UCS. Call after a change.
|
|
pub(super) fn persist_active_ucs(&mut self) {
|
|
use acadrust::types::Vector3;
|
|
if let Some(index) = self.active_block_edit {
|
|
let active_ucs = self.active_ucs.clone();
|
|
if let Some(session) = self.block_edits.get_mut(index) {
|
|
session.editor_ucs = active_ucs;
|
|
}
|
|
} else if let Some(h) = self.scene.active_viewport {
|
|
let (o, x, y, handle, per) = match &self.active_ucs {
|
|
Some(u) => (u.origin, u.x_axis, u.y_axis, u.handle, true),
|
|
None => (
|
|
Vector3::ZERO,
|
|
Vector3::UNIT_X,
|
|
Vector3::UNIT_Y,
|
|
Handle::NULL,
|
|
false,
|
|
),
|
|
};
|
|
if let Some(acadrust::EntityType::Viewport(vp)) = self.scene.document.get_entity_mut(h)
|
|
{
|
|
vp.ucs_origin = o;
|
|
vp.ucs_x_axis = x;
|
|
vp.ucs_y_axis = y;
|
|
vp.ucs_handle = handle;
|
|
vp.ucs_per_viewport = per;
|
|
}
|
|
} else if self.scene.current_layout == "Model" {
|
|
let h = &mut self.scene.document.header;
|
|
match &self.active_ucs {
|
|
Some(u) => {
|
|
h.model_space_ucs_origin = u.origin;
|
|
h.model_space_ucs_x_axis = u.x_axis;
|
|
h.model_space_ucs_y_axis = u.y_axis;
|
|
h.model_space_ucs_name = u.name.clone();
|
|
}
|
|
None => {
|
|
h.model_space_ucs_origin = Vector3::ZERO;
|
|
h.model_space_ucs_x_axis = Vector3::UNIT_X;
|
|
h.model_space_ucs_y_axis = Vector3::UNIT_Y;
|
|
h.model_space_ucs_name.clear();
|
|
}
|
|
}
|
|
} else {
|
|
let (origin, x_axis, y_axis, elevation, ortho, named, base) =
|
|
match &self.active_ucs {
|
|
Some(ucs) => (
|
|
ucs.origin,
|
|
ucs.x_axis,
|
|
ucs.y_axis,
|
|
ucs.elevation,
|
|
ucs.ortho_type,
|
|
if ucs.named_ucs_handle.is_valid() {
|
|
ucs.named_ucs_handle
|
|
} else {
|
|
ucs.handle
|
|
},
|
|
ucs.base_ucs_handle,
|
|
),
|
|
None => (
|
|
Vector3::ZERO,
|
|
Vector3::UNIT_X,
|
|
Vector3::UNIT_Y,
|
|
0.0,
|
|
0,
|
|
Handle::NULL,
|
|
Handle::NULL,
|
|
),
|
|
};
|
|
for object in self.scene.document.objects.values_mut() {
|
|
let acadrust::objects::ObjectType::Layout(layout) = object else {
|
|
continue;
|
|
};
|
|
if layout.name == self.scene.current_layout {
|
|
layout.ucs_origin = (origin.x, origin.y, origin.z);
|
|
layout.ucs_x_axis = (x_axis.x, x_axis.y, x_axis.z);
|
|
layout.ucs_y_axis = (y_axis.x, y_axis.y, y_axis.z);
|
|
layout.elevation = elevation;
|
|
layout.ucs_ortho_type = ortho;
|
|
layout.named_ucs = named;
|
|
layout.base_ucs = base;
|
|
break;
|
|
}
|
|
}
|
|
self.sync_paper_ucs_header();
|
|
}
|
|
}
|
|
|
|
/// Adopt the active pane's UCS on load (the file's saved model-space UCS in
|
|
/// the Model tab). Thin wrapper over [`refresh_active_ucs`] kept for the
|
|
/// load call sites.
|
|
pub(super) fn adopt_active_ucs_from_header(&mut self) {
|
|
self.refresh_active_ucs();
|
|
}
|
|
|
|
/// Push the active UCS rotation into the scene so the ViewCube composes with
|
|
/// it. Call after any change to `active_ucs`.
|
|
pub(super) fn sync_ucs_to_scene(&mut self) {
|
|
self.scene.viewcube_ucs = self.ucs_xform().rotation_mat();
|
|
}
|
|
|
|
/// Grid origin (render/wire space) and UCS→world rotation for grid snap and
|
|
/// the grid overlay. Identity / origin-at-zero outside model space.
|
|
pub(super) fn ucs_grid_basis(&self) -> (glam::Vec3, glam::Mat4) {
|
|
if !self.editing_model_space() {
|
|
return (glam::Vec3::ZERO, glam::Mat4::IDENTITY);
|
|
}
|
|
let xf = self.ucs_xform();
|
|
let (o, ..) = xf.axes();
|
|
let origin = glam::Vec3::new(o.x as f32, o.y as f32, o.z as f32);
|
|
(origin, xf.rotation_mat())
|
|
}
|
|
|
|
pub(super) fn new_drawing(n: usize) -> Self {
|
|
let mut scene = Scene::new();
|
|
linetypes::populate_document(&mut scene.document);
|
|
// Paper layouts start as A4 landscape.
|
|
for obj in scene.document.objects.values_mut() {
|
|
if let acadrust::objects::ObjectType::Layout(l) = obj {
|
|
if l.name != "Model" {
|
|
l.min_limits = (0.0, 0.0);
|
|
l.max_limits = (297.0, 210.0);
|
|
l.min_extents = (0.0, 0.0, 0.0);
|
|
l.max_extents = (297.0, 210.0, 0.0);
|
|
l.paper_width = 297.0;
|
|
l.paper_height = 210.0;
|
|
l.plot_paper_units = 1;
|
|
l.plot_scale_numerator = 1.0;
|
|
l.plot_scale_denominator = 1.0;
|
|
l.paper_size = "ISO_A4_(297.00_x_210.00_MM)".into();
|
|
}
|
|
}
|
|
}
|
|
Self {
|
|
id: NEXT_DOCUMENT_TAB_ID.fetch_add(1, Ordering::Relaxed),
|
|
scene,
|
|
current_path: None,
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
edit_lease: None,
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
edit_lock_conflict: false,
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
disk_fingerprint: None,
|
|
dirty: false,
|
|
recovery_save_as_required: false,
|
|
edit_revision: 0,
|
|
prev_selection: Vec::new(),
|
|
tab_title: format!("Drawing{}", n),
|
|
properties: PropertiesPanel::empty(),
|
|
layers: LayerPanel::default(),
|
|
active_cmd: None,
|
|
last_cmd: None,
|
|
last_draw_anchor: None,
|
|
snap_result: None,
|
|
active_grip: None,
|
|
selected_grips: vec![],
|
|
selected_grip_handles: vec![],
|
|
hot_grips: rustc_hash::FxHashSet::default(),
|
|
selected_handle: None,
|
|
visibility_grip: None,
|
|
wireframe: false,
|
|
render_mode: acadrust::entities::ViewportRenderMode::Wireframe2D,
|
|
visual_style: "Wireframe 2D".into(),
|
|
last_cursor_world: glam::DVec3::ZERO,
|
|
last_cursor_screen: iced::Point::ORIGIN,
|
|
last_point_screen: None,
|
|
dyn_fields: Vec::new(),
|
|
dyn_guide: crate::command::DynGuide::Polar,
|
|
dyn_anchor: None,
|
|
dyn_ref: None,
|
|
dyn_ref_screen: None,
|
|
dyn_active: 0,
|
|
history: HistoryState::default(),
|
|
active_layer: "0".to_string(),
|
|
active_ucs: None,
|
|
bg_color: None,
|
|
paper_bg_color: None,
|
|
refedit_session: None,
|
|
block_edits: Vec::new(),
|
|
active_block_edit: None,
|
|
active_mleader_style: "Standard".to_string(),
|
|
last_synced_camera_gen: 0,
|
|
is_start: false,
|
|
pan_mode: false,
|
|
orbit_mode: false,
|
|
zoom_dynamic_mode: false,
|
|
plugin_state: HashMap::new(),
|
|
suspended_cmd: None,
|
|
}
|
|
}
|
|
|
|
/// Welcome / Start tab. Carries a dummy Scene so the rest of the app
|
|
/// can read tab state uniformly; the viewport renderer detects
|
|
/// `is_start` and shows a welcome page instead.
|
|
pub(super) fn new_start() -> Self {
|
|
let mut t = Self::new_drawing(0);
|
|
t.tab_title = "Start".to_string();
|
|
t.is_start = true;
|
|
t
|
|
}
|
|
|
|
pub(super) fn tab_display_name(&self) -> String {
|
|
match &self.current_path {
|
|
Some(p) => p
|
|
.file_name()
|
|
.unwrap_or_default()
|
|
.to_string_lossy()
|
|
.to_string(),
|
|
None => {
|
|
if self.is_start {
|
|
t!("Start").into_owned()
|
|
} else {
|
|
self.tab_title.clone()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// One undo/redo entry. Every edit is represented as a first-touch entity delta
|
|
/// plus an optional structure-only document image, so history never clones the
|
|
/// full entity store.
|
|
#[derive(Clone)]
|
|
pub(super) enum HistorySnapshot {
|
|
Delta(DeltaSnapshot),
|
|
ObjectVisibility(ObjectVisibilitySnapshot),
|
|
}
|
|
|
|
impl HistorySnapshot {
|
|
pub(super) fn label(&self) -> &str {
|
|
match self {
|
|
HistorySnapshot::Delta(d) => &d.label,
|
|
HistorySnapshot::ObjectVisibility(v) => &v.label,
|
|
}
|
|
}
|
|
|
|
/// Approximate retained history memory. Entity images are shared through
|
|
/// `Arc`; the estimate conservatively budgets their payloads and optional
|
|
/// structure state to keep pathological histories bounded.
|
|
pub(super) fn estimated_bytes(&self) -> usize {
|
|
match self {
|
|
HistorySnapshot::Delta(d) => d
|
|
.entities
|
|
.len()
|
|
.saturating_mul(512)
|
|
.saturating_add(
|
|
d.structure
|
|
.as_ref()
|
|
.map_or(0, StructureSnapshot::estimated_bytes),
|
|
)
|
|
.saturating_add(d.selected_before.len().saturating_mul(16))
|
|
.saturating_add(d.selected_after.len().saturating_mul(16))
|
|
.saturating_add(
|
|
d.active_layer
|
|
.as_ref()
|
|
.map_or(0, |(before, after)| before.len().saturating_add(after.len())),
|
|
)
|
|
.saturating_add(d.label.len()),
|
|
HistorySnapshot::ObjectVisibility(v) => v
|
|
.before
|
|
.hidden
|
|
.len()
|
|
.saturating_add(
|
|
v.before
|
|
.keep
|
|
.as_ref()
|
|
.map_or(0, rustc_hash::FxHashSet::len),
|
|
)
|
|
.saturating_add(v.after.hidden.len())
|
|
.saturating_add(
|
|
v.after
|
|
.keep
|
|
.as_ref()
|
|
.map_or(0, rustc_hash::FxHashSet::len),
|
|
)
|
|
.saturating_add(v.selected_before.len())
|
|
.saturating_add(v.selected_after.len())
|
|
.saturating_mul(16)
|
|
.saturating_add(v.label.len()),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Symmetric undo/redo image for session-only object visibility. It contains
|
|
/// no document entity data and therefore can never make isolation serializable.
|
|
#[derive(Clone)]
|
|
pub(super) struct ObjectVisibilitySnapshot {
|
|
pub(super) before: ObjectIsolationState,
|
|
pub(super) after: ObjectIsolationState,
|
|
pub(super) selected_before: Vec<Handle>,
|
|
pub(super) selected_after: Vec<Handle>,
|
|
pub(super) label: String,
|
|
}
|
|
|
|
/// A transactional undo entry: for each touched handle, its before-image and
|
|
/// after-image (`None` = the entity was absent on that side, i.e. an add or an
|
|
/// erase). Symmetric — undo applies the before side, redo the after side — so
|
|
/// one delta moves between the undo and redo stacks without re-capturing. The
|
|
/// Optional structure state covers layers, objects, blocks and tables without
|
|
/// cloning the flat entity store.
|
|
#[derive(Clone)]
|
|
pub(super) struct DeltaSnapshot {
|
|
pub(super) entities: Vec<(Handle, Option<Arc<EntityType>>, Option<Arc<EntityType>>)>,
|
|
pub(super) current_layout_before: String,
|
|
pub(super) current_layout_after: String,
|
|
pub(super) selected_before: Vec<Handle>,
|
|
pub(super) selected_after: Vec<Handle>,
|
|
pub(super) dirty_before: bool,
|
|
pub(super) dirty_after: bool,
|
|
pub(super) active_layer: Option<(String, String)>,
|
|
/// Opposite non-entity document state. `apply_delta_state` swaps this with
|
|
/// the live structure, so the same allocation shuttles between undo/redo.
|
|
pub(super) structure: Option<StructureSnapshot>,
|
|
pub(super) label: String,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub(super) enum StructureSnapshot {
|
|
/// Compatibility fallback for genuinely broad structural commands.
|
|
Full(CadDocument),
|
|
/// Exact layer-table entries touched by one command.
|
|
Layers(Vec<TableEntryDelta<acadrust::tables::Layer>>),
|
|
/// Exact text-style entries touched by one command.
|
|
TextStyles(Vec<TableEntryDelta<acadrust::tables::TextStyle>>),
|
|
/// Exact dimension-style entries touched by one command.
|
|
DimStyles(Vec<TableEntryDelta<acadrust::tables::DimStyle>>),
|
|
/// Exact object-map entries touched by one command. This supports commands
|
|
/// such as groups/dictionaries without retaining every unrelated object.
|
|
Objects(Vec<ObjectEntryDelta>),
|
|
/// The bounded set of style tables, style objects, current-style pointers,
|
|
/// and matching ribbon state touched by one Style Manager transaction.
|
|
Styles {
|
|
before: super::style_ops::StyleStateSnapshot,
|
|
after: super::style_ops::StyleStateSnapshot,
|
|
text_names: Vec<String>,
|
|
dim_names: Vec<String>,
|
|
object_handles: Vec<Handle>,
|
|
},
|
|
}
|
|
|
|
impl StructureSnapshot {
|
|
pub(super) fn estimated_bytes(&self) -> usize {
|
|
match self {
|
|
Self::Full(doc) => doc.objects.len().saturating_mul(192),
|
|
Self::Layers(entries) => entries.len().saturating_mul(256),
|
|
Self::TextStyles(entries) => entries.len().saturating_mul(320),
|
|
Self::DimStyles(entries) => entries.len().saturating_mul(1024),
|
|
Self::Objects(entries) => entries.len().saturating_mul(384),
|
|
Self::Styles { before, after, .. } => before
|
|
.estimated_bytes()
|
|
.saturating_add(after.estimated_bytes()),
|
|
}
|
|
}
|
|
|
|
pub(super) fn is_full(&self) -> bool {
|
|
matches!(self, Self::Full(_))
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub(super) struct TableEntryDelta<T> {
|
|
pub(super) name: String,
|
|
pub(super) before: Option<T>,
|
|
pub(super) after: Option<T>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub(super) struct ObjectEntryDelta {
|
|
pub(super) handle: Handle,
|
|
pub(super) before: Option<acadrust::objects::ObjectType>,
|
|
pub(super) after: Option<acadrust::objects::ObjectType>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub(super) struct HistoryState {
|
|
pub(super) undo_stack: Vec<HistorySnapshot>,
|
|
pub(super) redo_stack: Vec<HistorySnapshot>,
|
|
pub(super) pending: Option<PendingHistorySnapshot>,
|
|
}
|
|
|
|
pub(super) struct PendingHistorySnapshot {
|
|
pub(super) label: String,
|
|
pub(super) current_layout: String,
|
|
pub(super) active_layer: String,
|
|
pub(super) selected_before: Vec<Handle>,
|
|
pub(super) dirty_before: bool,
|
|
pub(super) structure_before: CadDocument,
|
|
pub(super) recorder: Arc<acadrust::document::EntityChangeRecorder>,
|
|
}
|