forked from 1b-agent/opencadstudio-upstream
Hakan SevenandClaude Opus 5.5
091331f3bd
Only the definition's entities crossed drawings: its record's object graph (parameters, visibility states, grips) stayed behind, and a reference showing an evaluated copy lost the link to its definition. The clipboard now captures the graph and the dynamic definition of an evaluated reference, and paste and the block palette's insert-from-file recreate them on the new records, re-pointing members and element tags. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1674 lines
67 KiB
Rust
1674 lines
67 KiB
Rust
use super::*;
|
|
|
|
impl OpenCADStudio {
|
|
pub(super) fn handle_copy_to_clipboard(&mut self, handles: Vec<Handle>, base: glam::DVec3) {
|
|
let i = self.active_tab;
|
|
let count = self.copy_entities_to_clipboard(i, &handles, base);
|
|
self.command_line
|
|
.push_info(crate::tf!("{} object(s) copied to clipboard.", count).as_ref());
|
|
let prompt = self.tabs[i]
|
|
.active_cmd
|
|
.as_ref()
|
|
.map(|command| command.prompt());
|
|
if let Some(prompt) = prompt {
|
|
self.command_line.push_info(&prompt);
|
|
}
|
|
self.command_line.set_step_options(
|
|
self.tabs[i]
|
|
.active_cmd
|
|
.as_ref()
|
|
.map(|command| command.options())
|
|
.unwrap_or_default(),
|
|
);
|
|
if !self.tabs[i]
|
|
.active_cmd
|
|
.as_ref()
|
|
.is_some_and(|command| command.entity_pick_highlights_hover())
|
|
{
|
|
self.tabs[i].scene.set_hover_highlight(None);
|
|
}
|
|
self.sync_dyn_fields();
|
|
self.refresh_area_preview(i);
|
|
}
|
|
|
|
pub(super) fn handle_batch_copy(
|
|
&mut self,
|
|
mut handles: Vec<Handle>,
|
|
transforms: Vec<crate::command::EntityTransform>,
|
|
) -> Option<Task<Message>> {
|
|
let i = self.active_tab;
|
|
handles.retain(|handle| !self.tabs[i].scene.is_layer_locked(*handle));
|
|
if handles.is_empty() {
|
|
self.tabs[i].active_cmd = None;
|
|
return Some(Task::none());
|
|
}
|
|
let label = self.history_label_from_active_cmd(i, "ARRAY");
|
|
let count = transforms.len();
|
|
// Same gate as COPY (dimension-free), sized by the total number
|
|
// of copies the array will add.
|
|
let delta_safe = self.delta_copy_safe(i, &handles);
|
|
let pending = self.begin_undo(i, label.clone(), handles.len() * count, delta_safe);
|
|
for t in &transforms {
|
|
self.tabs[i].scene.copy_entities(&handles, t);
|
|
}
|
|
self.tabs[i].dirty = true;
|
|
self.tabs[i].scene.clear_preview_wire();
|
|
self.tabs[i].active_cmd = None;
|
|
self.tabs[i].snap_result = None;
|
|
self.restore_pre_cmd_tangent();
|
|
let noun = if count == 1 { "copy" } else { "copies" };
|
|
self.command_line
|
|
.push_output(crate::tf!("{label}: {count} {noun} created.").as_ref());
|
|
self.refresh_properties();
|
|
if let Some(pd) = pending {
|
|
self.commit_undo_delta(i, pd);
|
|
}
|
|
None
|
|
}
|
|
|
|
/// ARRAYRECT / ARRAYPOLAR with Associative on: the objects become the
|
|
/// source of an associative array, in one undo step.
|
|
pub(super) fn handle_assoc_array(
|
|
&mut self,
|
|
mut handles: Vec<Handle>,
|
|
spec: crate::scene::assoc_array::AssocArraySpec,
|
|
) {
|
|
let i = self.active_tab;
|
|
handles.retain(|handle| !self.tabs[i].scene.is_layer_locked(*handle));
|
|
self.tabs[i].scene.clear_preview_wire();
|
|
self.tabs[i].active_cmd = None;
|
|
self.tabs[i].snap_result = None;
|
|
self.restore_pre_cmd_tangent();
|
|
if handles.is_empty() {
|
|
return;
|
|
}
|
|
let label = self.history_label_from_active_cmd(i, "ARRAY");
|
|
let source_point = crate::app::helpers::entities_lower_left_by_bbox(
|
|
&self.tabs[i].scene.document,
|
|
&handles,
|
|
);
|
|
self.push_undo_snapshot(i, label.clone());
|
|
match crate::scene::assoc_array::create_from_spec(
|
|
&mut self.tabs[i].scene,
|
|
&handles,
|
|
source_point,
|
|
&spec,
|
|
) {
|
|
Ok(array) => {
|
|
self.tabs[i].scene.deselect_all();
|
|
self.tabs[i].scene.select_entity(array, false);
|
|
self.command_line
|
|
.push_output(crate::tf!("{label}: associative array created.").as_ref());
|
|
}
|
|
Err(error) => self.command_line.push_error(&format!("{label}: {error}")),
|
|
}
|
|
self.tabs[i].dirty = true;
|
|
self.refresh_properties();
|
|
}
|
|
|
|
pub(super) fn handle_replace_many(
|
|
&mut self,
|
|
replacements: Vec<(Handle, Vec<codec::EntityType>)>,
|
|
additions: Vec<codec::EntityType>,
|
|
) -> Option<Task<Message>> {
|
|
let i = self.active_tab;
|
|
if let Some((handle, _)) = replacements
|
|
.iter()
|
|
.find(|(handle, _)| self.tabs[i].scene.is_layer_locked(*handle))
|
|
{
|
|
self.reject_locked_edit(i, *handle);
|
|
self.tabs[i].active_cmd = None;
|
|
return Some(Task::none());
|
|
}
|
|
let label = self.history_label_from_active_cmd(i, "FILLET");
|
|
let was_catchment = self.tabs[i]
|
|
.active_cmd
|
|
.as_ref()
|
|
.is_some_and(|c| c.name() == "SS_CATCHMENT");
|
|
self.push_undo_snapshot(i, label);
|
|
for (handle, entities) in replacements {
|
|
self.replace_command_entity(i, handle, entities);
|
|
}
|
|
for entity in additions {
|
|
self.tabs[i].scene.add_entity(entity);
|
|
}
|
|
self.tabs[i].dirty = true;
|
|
self.tabs[i].scene.clear_preview_wire();
|
|
self.tabs[i].active_cmd = None;
|
|
self.tabs[i].snap_result = None;
|
|
if was_catchment {
|
|
self.command_line
|
|
.push_info(crate::t!("Catchment tagged successfully.").as_ref());
|
|
}
|
|
self.refresh_properties();
|
|
None
|
|
}
|
|
|
|
pub(super) fn handle_replace_many_continue(
|
|
&mut self,
|
|
replacements: Vec<(Handle, Vec<codec::EntityType>)>,
|
|
) -> Option<Task<Message>> {
|
|
let i = self.active_tab;
|
|
if let Some((handle, _)) = replacements
|
|
.iter()
|
|
.find(|(handle, _)| self.tabs[i].scene.is_layer_locked(*handle))
|
|
{
|
|
self.reject_locked_edit(i, *handle);
|
|
return Some(Task::none());
|
|
}
|
|
let label = self.history_label_from_active_cmd(i, "TRIM");
|
|
self.push_undo_snapshot(i, label);
|
|
for (handle, entities) in replacements {
|
|
let new_handles = self.replace_command_entity(i, handle, entities);
|
|
if let Some(command) = self.tabs[i].active_cmd.as_mut() {
|
|
command.on_entity_replaced(handle, &new_handles);
|
|
}
|
|
}
|
|
self.tabs[i].dirty = true;
|
|
self.tabs[i].scene.clear_preview_wire();
|
|
self.tabs[i].snap_result = None;
|
|
if let Some(prompt) = self.tabs[i]
|
|
.active_cmd
|
|
.as_ref()
|
|
.map(|command| command.prompt())
|
|
{
|
|
self.command_line.push_info(&prompt);
|
|
}
|
|
self.refresh_properties();
|
|
None
|
|
}
|
|
|
|
pub(super) fn handle_replace_entity(
|
|
&mut self,
|
|
handle: Handle,
|
|
new_entities: Vec<codec::EntityType>,
|
|
) -> Option<Task<Message>> {
|
|
let i = self.active_tab;
|
|
if self.reject_locked_edit(i, handle) {
|
|
return Some(Task::none());
|
|
}
|
|
// Detect SPLINEDIT sentinel: a single XLine with a magic layer name.
|
|
if new_entities.len() == 1 {
|
|
if let codec::EntityType::XLine(ref xl) = new_entities[0] {
|
|
let op = xl.common.layer.clone();
|
|
if op.starts_with("__SPLINEDIT_") {
|
|
let label = self.history_label_from_active_cmd(i, "SPLINEDIT");
|
|
self.push_undo_snapshot(i, label);
|
|
crate::modules::draw::modify::splinedit::apply_spline_op(
|
|
&mut self.tabs[i].scene.document,
|
|
handle,
|
|
&op,
|
|
);
|
|
self.tabs[i].dirty = true;
|
|
let prompt = self.tabs[i].active_cmd.as_ref().map(|c| c.prompt());
|
|
if let Some(p) = prompt {
|
|
self.command_line.push_info(&p);
|
|
}
|
|
return Some(Task::none());
|
|
}
|
|
}
|
|
}
|
|
let label = self.history_label_from_active_cmd(i, "TRIM");
|
|
self.push_undo_snapshot(i, label);
|
|
// A replacement reusing the original handle must land after the erase;
|
|
// fresh pieces take over its hatch associations before it goes.
|
|
let reuses_handle = new_entities.iter().any(|e| e.common().handle == handle);
|
|
if reuses_handle {
|
|
self.tabs[i].scene.erase_entities(&[handle]);
|
|
}
|
|
let new_handles: Vec<codec::Handle> = new_entities
|
|
.into_iter()
|
|
.map(|e| self.tabs[i].scene.add_entity(e))
|
|
.collect();
|
|
if !reuses_handle {
|
|
self.tabs[i].scene.split_hatch_source(handle, &new_handles);
|
|
self.tabs[i].scene.erase_entities(&[handle]);
|
|
}
|
|
// Rebuild replaced dimensions from edited data.
|
|
for &nh in &new_handles {
|
|
if matches!(
|
|
self.tabs[i].scene.document.get_entity(nh),
|
|
Some(codec::EntityType::Dimension(_))
|
|
) {
|
|
self.tabs[i].scene.invalidate_dim_block_recorded(nh);
|
|
}
|
|
}
|
|
let pedit_entities = if self.tabs[i]
|
|
.active_cmd
|
|
.as_ref()
|
|
.is_some_and(|command| command.name() == "PEDIT")
|
|
{
|
|
new_handles
|
|
.iter()
|
|
.filter_map(|new| self.tabs[i].scene.document.get_entity(*new).cloned())
|
|
.collect::<Vec<_>>()
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
if let Some(cmd) = &mut self.tabs[i].active_cmd {
|
|
cmd.on_entity_replaced(handle, &new_handles);
|
|
for entity in pedit_entities {
|
|
cmd.inject_picked_entity(entity);
|
|
}
|
|
}
|
|
self.tabs[i].dirty = true;
|
|
let prompt = self.tabs[i].active_cmd.as_ref().map(|c| c.prompt());
|
|
if let Some(p) = prompt {
|
|
self.command_line.push_info(&p);
|
|
}
|
|
None
|
|
}
|
|
|
|
pub(super) fn handle_paste_clipboard(&mut self, base_pt: glam::DVec3) {
|
|
let i = self.active_tab;
|
|
self.tabs[i].active_cmd = None;
|
|
self.tabs[i].snap_result = None;
|
|
self.tabs[i].scene.clear_preview_wire();
|
|
if self.clipboard.is_empty() {
|
|
self.command_line
|
|
.push_error(crate::t!("Clipboard is empty.").as_ref());
|
|
} else {
|
|
let delta = base_pt - self.clipboard_base;
|
|
let translate = crate::command::EntityTransform::Translate(delta);
|
|
self.push_undo_snapshot(i, "PASTECLIP");
|
|
let count = self.clipboard.len();
|
|
let by_index = self.finalize_paste(i, Some(translate));
|
|
self.tabs[i].scene.deselect_all();
|
|
for h in by_index.iter().copied().filter(|h| !h.is_null()) {
|
|
self.tabs[i].scene.select_entity(h, false);
|
|
}
|
|
self.tabs[i].dirty = true;
|
|
// Surface any layers the paste brought in (cross-drawing)
|
|
// in the layer manager and the layer dropdown.
|
|
self.refresh_layer_panel();
|
|
self.refresh_properties();
|
|
self.command_line
|
|
.push_info(crate::tf!("{count} object(s) pasted.").as_ref());
|
|
}
|
|
}
|
|
|
|
pub(crate) fn merge_clipboard_deps(&mut self, i: usize) {
|
|
let deps = self.clipboard_deps.clone();
|
|
self.merge_dependencies(i, &deps);
|
|
}
|
|
|
|
/// Recreate any block definition the pasted INSERTs reference but tab
|
|
/// `i`'s document lacks (cross-drawing paste), so the block reference
|
|
/// renders its geometry instead of nothing. No-op for same-document
|
|
/// pastes. (#135)
|
|
pub(crate) fn merge_clipboard_blocks(&mut self, i: usize) {
|
|
if self.clipboard_deps.blocks.is_empty() {
|
|
return;
|
|
}
|
|
let blocks = self.clipboard_deps.blocks.clone();
|
|
// Single shared copy — see `merge_block_defs`. One batched geometry
|
|
// rebuild instead of one per definition; same end state as the
|
|
// per-definition bumps `Scene::define_block_raw` used to run.
|
|
if merge_block_defs(&mut self.tabs[i].scene.document, &blocks) > 0 {
|
|
self.tabs[i].scene.bump_geometry();
|
|
}
|
|
}
|
|
|
|
/// Shared paste finalize for every paste path (PASTECLIP, PASTEORIG):
|
|
/// document-level paste runs in [`paste_entities_kernel`] (fresh handles,
|
|
/// dependency records, block definitions, `*D` re-point, xdictionary
|
|
/// graphs, LEADER relink); the Scene/render tail stays here (tessellation
|
|
/// bumps, group + constraint recreation, annotation-context display sync).
|
|
/// Returns the new handles, index-aligned with the clipboard
|
|
/// (NULL where an add failed). Keeping the document half in one kernel
|
|
/// means a new cross-drawing concern is wired once, not re-implemented
|
|
/// per command — and headless callers share it without a Scene.
|
|
pub(crate) fn finalize_paste(
|
|
&mut self,
|
|
i: usize,
|
|
translate: Option<crate::command::EntityTransform>,
|
|
) -> Vec<Handle> {
|
|
// Per-helper narrow/keep report (Task 4): the kernel ports what
|
|
// `&mut CadDocument` can do and this shell keeps the rest —
|
|
// merge_dependencies (table records) … KEEP in kernel (verbatim
|
|
// port; pure document-table work, no Document-level free fn existed)
|
|
// merge_clipboard_blocks / define_block_raw … KEEP in kernel minus
|
|
// the trailing bump_geometry (render cache — shelled below)
|
|
// add_entity_clone … NARROW: sub-handle reset + NULL handles +
|
|
// doc.add_entity in kernel; entity_mode default, layer/app-id
|
|
// ensure, ImageDefinition auto-create, BEDIT/paper-space owner
|
|
// routing, undo recording and per-add tessellation stay caller-side
|
|
// (Scene-only; NO Scene methods refactored)
|
|
// define_transformed_block (`*D` dim blocks) … KEEP in kernel
|
|
// (verbatim port; no render-cache tail exists)
|
|
// recreate_ext_subtree / remap_object … USE existing Document-level
|
|
// free fns directly (no Scene involved)
|
|
// translate_annotation_contexts … USE existing Document-level free fn
|
|
// LEADER annotation_handle relink … KEEP in kernel (get_entity_mut);
|
|
// sync_displayed_annotation_context stays caller-side (Scene)
|
|
// recreate_groups … CALLER-SIDE (Scene::recreate_groups: undo
|
|
// recording + group-dict naming; no Document equivalent exists)
|
|
// duplicate_parametric_constraints_for … CALLER-SIDE (Scene-owned
|
|
// constraint sets; no Document equivalent exists)
|
|
// populate_missing_meshes_from_document / bumps … CALLER-SIDE
|
|
let clipboard = self.clipboard.clone();
|
|
let deps = self.clipboard_deps.clone();
|
|
// Into the space new entities go: the edited block, the layout's
|
|
// paper space (no viewport active), or model space.
|
|
let scene = &self.tabs[i].scene;
|
|
let layout = scene.current_layout.clone();
|
|
let space = match scene.block_edit_block {
|
|
Some(block) => PasteSpace::Block(block),
|
|
None if layout != "Model" && scene.active_viewport.is_none() => {
|
|
PasteSpace::Layout(&layout)
|
|
}
|
|
None => PasteSpace::Model,
|
|
};
|
|
let (by_index, handle_map) = paste_entities_kernel(
|
|
&mut self.tabs[i].scene.document,
|
|
&clipboard,
|
|
&deps,
|
|
translate.as_ref(),
|
|
space,
|
|
);
|
|
// Batched equivalent of `add_entity`'s per-add bump (same pattern as
|
|
// `Scene::add_entities`): fresh top-level solids tessellate once here
|
|
// instead of once per entity. Block-definition merges (and pasted
|
|
// Block/BlockEnd sentinels) need the full geometry rebuild, matching
|
|
// the `bump_geometry` tails the Scene helpers used to run.
|
|
let mut needs_geometry_bump = !deps.blocks.is_empty();
|
|
let mut changes = Vec::new();
|
|
for &handle in &by_index {
|
|
if handle.is_null() {
|
|
continue;
|
|
}
|
|
// `add_entity` seeds fill and raster models; the document-level
|
|
// add above does not, so a pasted hatch without an association
|
|
// to rebuild it was never drawn. (#1807)
|
|
if matches!(
|
|
self.tabs[i].scene.document.get_entity(handle),
|
|
Some(
|
|
codec::EntityType::Hatch(_)
|
|
| codec::EntityType::Solid(_)
|
|
| codec::EntityType::RasterImage(_)
|
|
| codec::EntityType::Ole2Frame(_)
|
|
| codec::EntityType::Underlay(_)
|
|
)
|
|
) {
|
|
self.tabs[i].scene.reseed_derived_caches(handle);
|
|
}
|
|
if matches!(
|
|
self.tabs[i].scene.document.get_entity(handle),
|
|
Some(codec::EntityType::Block(_) | codec::EntityType::BlockEnd(_))
|
|
) {
|
|
needs_geometry_bump = true;
|
|
} else {
|
|
changes.push((handle, crate::scene::ChangeKind::Added));
|
|
}
|
|
}
|
|
if needs_geometry_bump {
|
|
self.tabs[i].scene.bump_geometry();
|
|
} else if !changes.is_empty() {
|
|
self.tabs[i].scene.bump_entities(&changes);
|
|
}
|
|
// The wires tessellated above predate the freshly attached clip object
|
|
// graphs; refresh the pasted entities so XCLIP-filtered inserts
|
|
// render clipped immediately.
|
|
if !deps.ext_objects.is_empty() {
|
|
let changes: Vec<_> = by_index
|
|
.iter()
|
|
.copied()
|
|
.filter(|handle| !handle.is_null())
|
|
.map(|handle| (handle, crate::scene::ChangeKind::Modified))
|
|
.collect();
|
|
self.tabs[i].scene.bump_entities(&changes);
|
|
}
|
|
// Source handles stored in the clipboard map one-to-one to the freshly
|
|
// pasted handles (see `handle_map`); refresh each pasted LEADER's
|
|
// displayed annotation context now that the relink ran in the kernel.
|
|
for &handle in by_index.iter().filter(|h| !h.is_null()) {
|
|
if matches!(
|
|
self.tabs[i].scene.document.get_entity(handle),
|
|
Some(codec::EntityType::Leader(_))
|
|
) {
|
|
let _ = self.tabs[i].scene.sync_displayed_annotation_context(handle);
|
|
}
|
|
}
|
|
// Recreate any group whose whole membership was copied, so a pasted
|
|
// group stays grouped — cross-drawing too, since the groups were
|
|
// snapshotted into the clipboard at copy time. `by_index` is aligned
|
|
// with `self.clipboard`, so the kernel's `handle_map` maps each
|
|
// clipboard clone to its new handle. Same shared `recreate_groups`
|
|
// the in-drawing COPY path uses. (#440)
|
|
if !deps.groups.is_empty() {
|
|
self.tabs[i]
|
|
.scene
|
|
.recreate_groups(deps.groups.clone(), &handle_map);
|
|
}
|
|
// Constraints wholly within the pasted selection follow it.
|
|
self.tabs[i]
|
|
.scene
|
|
.duplicate_parametric_constraints_for(&handle_map);
|
|
// Incremental: fresh top-level solids already tessellated above, and
|
|
// existing document solids are still cached — so only newly
|
|
// introduced block-definition solids need building. The full rebuild
|
|
// would clear and re-tessellate the entire document (every solid in the
|
|
// drawing) on each paste, which is what made a large paste stall.
|
|
self.tabs[i].scene.populate_missing_meshes_from_document();
|
|
by_index
|
|
}
|
|
|
|
/// Recreate the captured xdictionary subtrees in this document (fresh
|
|
/// handles, remapped references) WITHOUT an added host entity, returning
|
|
/// `entity_index → new xdictionary root`. Used by PASTEBLOCK, which folds
|
|
/// the clipboard into a new block definition: the caller stamps each new
|
|
/// root onto the matching entity's `xdictionary_handle` before defining the
|
|
/// block, so the block's nested insert keeps its XCLIP filter.
|
|
pub(crate) fn recreate_clipboard_ext_roots(
|
|
&mut self,
|
|
i: usize,
|
|
) -> std::collections::HashMap<usize, Handle> {
|
|
let mut out = std::collections::HashMap::new();
|
|
if self.clipboard_deps.ext_objects.is_empty() {
|
|
return out;
|
|
}
|
|
let captures = self.clipboard_deps.ext_objects.clone();
|
|
let doc = &mut self.tabs[i].scene.document;
|
|
let records = block_record_map(doc, &self.clipboard_deps.blocks);
|
|
for cap in &captures {
|
|
if let Some(new_root) = recreate_ext_subtree(doc, cap, None, &records) {
|
|
out.insert(cap.entity_index, new_root);
|
|
}
|
|
}
|
|
out
|
|
}
|
|
}
|
|
|
|
/// PASTECLIP kernel: paste a clipboard payload (`entities` + `deps`, as
|
|
/// captured by [`copy_to_clipboard_kernel`]) into `doc`, optionally
|
|
/// translated, returning the new handles index-aligned with `entities`
|
|
/// Recreate missing layer/linetype/text-style/dim-style records with fresh
|
|
/// handles from the target document. Shared by `merge_dependencies` (PASTEBLOCK
|
|
/// path) and `paste_entities_kernel` — one copy, not a port per caller.
|
|
pub(crate) fn merge_table_records(doc: &mut codec::CadDocument, deps: &crate::app::ClipboardDeps) {
|
|
use codec::TableEntry;
|
|
for rec in &deps.layers {
|
|
if !doc.layers.contains(rec.name()) {
|
|
let mut r = rec.clone();
|
|
r.set_handle(doc.allocate_handle());
|
|
let _ = doc.layers.add(r);
|
|
}
|
|
}
|
|
for rec in &deps.linetypes {
|
|
if !doc.line_types.contains(rec.name()) {
|
|
let mut r = rec.clone();
|
|
r.set_handle(doc.allocate_handle());
|
|
let _ = doc.line_types.add(r);
|
|
}
|
|
}
|
|
for rec in &deps.text_styles {
|
|
if !doc.text_styles.contains(rec.name()) {
|
|
let mut r = rec.clone();
|
|
r.set_handle(doc.allocate_handle());
|
|
let _ = doc.text_styles.add(r);
|
|
}
|
|
}
|
|
for rec in &deps.dim_styles {
|
|
if !doc.dim_styles.contains(rec.name()) {
|
|
let mut r = rec.clone();
|
|
r.set_handle(doc.allocate_handle());
|
|
let _ = doc.dim_styles.add(r);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Recreate block definitions the pasted INSERTs reference but the target
|
|
/// document lacks. Shared by `merge_clipboard_blocks` and
|
|
/// `paste_entities_kernel`. Returns how many definitions were created, so
|
|
/// render-cache callers can bump once instead of per definition.
|
|
pub(crate) fn merge_block_defs(
|
|
doc: &mut codec::CadDocument,
|
|
blocks: &[crate::app::BlockDef],
|
|
) -> usize {
|
|
let mut created = Vec::new();
|
|
for def in blocks {
|
|
let before = doc.block_records.len();
|
|
define_block_raw_doc(doc, &def.name, def.base_point, &def.entities);
|
|
if doc.block_records.len() > before {
|
|
created.push(def);
|
|
}
|
|
}
|
|
// Graphs name other records (an evaluated copy names its definition), so
|
|
// they go in once every record exists.
|
|
let records = block_record_map(doc, blocks);
|
|
for def in &created {
|
|
import_block_def_graph(doc, def, &records);
|
|
}
|
|
created.len()
|
|
}
|
|
|
|
/// Source record → this drawing's record of the same name, per definition.
|
|
pub(crate) fn block_record_map(
|
|
doc: &codec::CadDocument,
|
|
blocks: &[crate::app::BlockDef],
|
|
) -> std::collections::HashMap<Handle, Handle> {
|
|
blocks
|
|
.iter()
|
|
.filter_map(|def| Some((def.source, doc.block_records.get(&def.name)?.handle)))
|
|
.collect()
|
|
}
|
|
|
|
/// Carry `def`'s object graph (a dynamic block's parameters and states) onto
|
|
/// the record just defined from it here. `records` maps the source records
|
|
/// the graph may name.
|
|
pub(crate) fn import_block_def_graph(
|
|
doc: &mut codec::CadDocument,
|
|
def: &crate::app::BlockDef,
|
|
records: &std::collections::HashMap<Handle, Handle>,
|
|
) {
|
|
let Some(graph) = &def.graph else {
|
|
return;
|
|
};
|
|
let Some(record) = doc.block_records.get(&def.name).map(|record| record.handle) else {
|
|
return;
|
|
};
|
|
let members = crate::scene::block_authoring::members(doc, record);
|
|
if members.len() != def.entities.len() {
|
|
return;
|
|
}
|
|
let mut map = records.clone();
|
|
map.extend(def.entities.iter().map(|e| e.common().handle).zip(members));
|
|
doc.import_block_graph(graph, record, &map);
|
|
crate::scene::block_authoring::retag_members(doc, record);
|
|
}
|
|
|
|
/// (`NULL` where an add failed) plus the source-handle → pasted-handle map.
|
|
///
|
|
/// Document-level work lives here; Scene/render concerns stay caller-side in
|
|
/// `finalize_paste` (tessellation bumps, `populate_missing_meshes`,
|
|
/// `recreate_groups`, `duplicate_parametric_constraints_for`,
|
|
/// `sync_displayed_annotation_context`, undo/dirty/selection/echo/panels).
|
|
/// See the per-helper report in `finalize_paste`.
|
|
/// Where pasted entities go, the way `Scene::add_entity` routes a new one.
|
|
#[derive(Clone, Copy)]
|
|
pub(crate) enum PasteSpace<'a> {
|
|
Model,
|
|
/// A layout's paper space, when no viewport of it is active.
|
|
Layout(&'a str),
|
|
/// The block definition being edited (BEDIT).
|
|
Block(Handle),
|
|
}
|
|
|
|
pub(crate) fn paste_entities_kernel(
|
|
doc: &mut codec::CadDocument,
|
|
entities: &[codec::EntityType],
|
|
deps: &crate::app::ClipboardDeps,
|
|
translate: Option<&crate::command::EntityTransform>,
|
|
space: PasteSpace,
|
|
) -> (Vec<Handle>, rustc_hash::FxHashMap<Handle, Handle>) {
|
|
// Shared table-record merge (also used by `merge_dependencies`): recreate
|
|
// missing records with fresh handles from the target document.
|
|
merge_table_records(doc, deps);
|
|
// Shared block-definition merge (also used by `merge_clipboard_blocks`).
|
|
merge_block_defs(doc, &deps.blocks);
|
|
|
|
let by_index: Vec<Handle> = entities
|
|
.iter()
|
|
.cloned()
|
|
.map(|mut entity| {
|
|
let picture_placement = crate::scene::render_graph::dim_picture_placement(&entity);
|
|
if let Some(t) = translate {
|
|
crate::scene::view::dispatch::apply_transform(&mut entity, t);
|
|
}
|
|
crate::scene::render_graph::clear_dim_picture_placement(&mut entity);
|
|
// Same `*D`-block re-point as `finalize_paste` (#290, #161): the
|
|
// baked dimension geometry lives in WCS, so the paste gets its own
|
|
// transformed copy of the snapshotted block.
|
|
if let codec::EntityType::Dimension(d) = &entity {
|
|
let bn = d.base().block_name.clone();
|
|
if !bn.trim().is_empty() {
|
|
if let Some(subs) = deps
|
|
.dim_blocks
|
|
.iter()
|
|
.find(|b| b.name.eq_ignore_ascii_case(&bn))
|
|
.map(|def| def.entities.clone())
|
|
{
|
|
let mut subs = subs;
|
|
if let Some(placement) = &picture_placement {
|
|
for sub in &mut subs {
|
|
crate::scene::view::dispatch::apply_transform(sub, placement);
|
|
}
|
|
}
|
|
let bt = translate.cloned().unwrap_or(
|
|
crate::command::EntityTransform::Translate(glam::DVec3::ZERO),
|
|
);
|
|
if let Some(new_bn) = define_transformed_block_doc(doc, &subs, &bt) {
|
|
if let codec::EntityType::Dimension(d) = &mut entity {
|
|
d.base_mut().block_name = new_bn;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
add_entity_clone_doc(doc, entity, space)
|
|
})
|
|
.collect();
|
|
|
|
// Port of `merge_clipboard_ext_objects` minus the trailing `bump_entities`
|
|
// (render cache — caller-side): recreate each captured xdictionary graph
|
|
// with fresh handles and re-point the pasted entity at its new root.
|
|
let annotation_delta = match translate {
|
|
Some(crate::command::EntityTransform::Translate(delta)) => *delta,
|
|
_ => glam::DVec3::ZERO,
|
|
};
|
|
let records = block_record_map(doc, &deps.blocks);
|
|
for cap in &deps.ext_objects {
|
|
let Some(&new_entity) = by_index.get(cap.entity_index) else {
|
|
continue;
|
|
};
|
|
if new_entity.is_null() {
|
|
continue;
|
|
}
|
|
if let Some(new_root) = recreate_ext_subtree(doc, cap, Some(new_entity), &records) {
|
|
if let Some(e) = doc.get_entity_mut(new_entity) {
|
|
e.common_mut().xdictionary_handle = Some(new_root);
|
|
}
|
|
crate::scene::annotative::translate_annotation_contexts(
|
|
doc,
|
|
new_entity,
|
|
annotation_delta,
|
|
);
|
|
}
|
|
}
|
|
|
|
// Source handles map one-to-one to the freshly pasted handles; reconnect
|
|
// LEADER -> copied annotation through the map (the
|
|
// `sync_displayed_annotation_context` refresh stays caller-side).
|
|
let mut handle_map: rustc_hash::FxHashMap<Handle, Handle> = rustc_hash::FxHashMap::default();
|
|
for (source, &copied) in entities.iter().zip(by_index.iter()) {
|
|
if !copied.is_null() {
|
|
handle_map.insert(source.common().handle, copied);
|
|
}
|
|
}
|
|
// A pasted associative hatch follows the pasted boundary, or drops the
|
|
// association when the boundary was not pasted with it. (#1370)
|
|
crate::scene::remap_hatch_associations(doc, &handle_map);
|
|
// Reactors on the source drawing's objects do not travel with the paste.
|
|
crate::scene::remap_copied_reactors(doc, &handle_map);
|
|
let leader_links: Vec<(Handle, Handle)> = entities
|
|
.iter()
|
|
.filter_map(|source| {
|
|
let codec::EntityType::Leader(leader) = source else {
|
|
return None;
|
|
};
|
|
let copied_leader = handle_map.get(&source.common().handle).copied()?;
|
|
let copied_annotation = handle_map
|
|
.get(&leader.annotation_handle)
|
|
.copied()
|
|
.unwrap_or(Handle::NULL);
|
|
Some((copied_leader, copied_annotation))
|
|
})
|
|
.collect();
|
|
for (leader_handle, annotation_handle) in leader_links {
|
|
if let Some(codec::EntityType::Leader(leader)) = doc.get_entity_mut(leader_handle) {
|
|
leader.annotation_handle = annotation_handle;
|
|
}
|
|
}
|
|
(by_index, handle_map)
|
|
}
|
|
|
|
/// Document-level clone-add: the `&mut CadDocument` half of
|
|
/// `Scene::add_entity_clone` — fresh inline sub-handles (INSERT attributes,
|
|
/// 3D-polyline vertices; `reset_clone_subhandles` is `scene`-private so the
|
|
/// two lines are mirrored here), NULL top-level/owner handles, then
|
|
/// adds it to `space`. Tessellation/render caching stays caller-side in the
|
|
/// Scene shell.
|
|
fn add_entity_clone_doc(
|
|
doc: &mut codec::CadDocument,
|
|
mut entity: codec::EntityType,
|
|
space: PasteSpace,
|
|
) -> Handle {
|
|
match &mut entity {
|
|
codec::EntityType::Insert(ins) => {
|
|
for att in ins.attributes.iter_mut() {
|
|
att.common.handle = doc.allocate_handle();
|
|
}
|
|
}
|
|
codec::EntityType::Polyline3D(p) => {
|
|
for v in p.vertices.iter_mut() {
|
|
v.handle = doc.allocate_handle();
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
entity.common_mut().handle = Handle::NULL;
|
|
entity.common_mut().owner_handle = Handle::NULL;
|
|
match space {
|
|
PasteSpace::Model => doc.add_entity(entity),
|
|
PasteSpace::Layout(layout) => doc.add_entity_to_layout(entity, layout),
|
|
PasteSpace::Block(block) => {
|
|
entity.common_mut().owner_handle = block;
|
|
doc.add_entity(entity)
|
|
}
|
|
}
|
|
.unwrap_or(Handle::NULL)
|
|
}
|
|
|
|
/// Document-level verbatim block-definition recreate: the `&mut CadDocument`
|
|
/// half of `Scene::define_block_raw` (no-op when the block exists). The
|
|
/// trailing `bump_geometry` stays caller-side.
|
|
pub(crate) fn define_block_raw_doc(
|
|
doc: &mut codec::CadDocument,
|
|
name: &str,
|
|
base_point: codec::types::Vector3,
|
|
entities: &[codec::EntityType],
|
|
) {
|
|
if name.is_empty() || doc.block_records.get(name).is_some() {
|
|
return;
|
|
}
|
|
let next = doc.next_handle();
|
|
let br_handle = Handle::new(next);
|
|
let block_handle = Handle::new(next + 1);
|
|
let end_handle = Handle::new(next + 2);
|
|
let mut block_record = codec::tables::BlockRecord::new(name);
|
|
block_record.handle = br_handle;
|
|
block_record.block_entity_handle = block_handle;
|
|
block_record.block_end_handle = end_handle;
|
|
if doc.block_records.add(block_record).is_err() {
|
|
return;
|
|
}
|
|
let mut block = codec::entities::Block::new(name, base_point);
|
|
block.common.handle = block_handle;
|
|
block.common.owner_handle = br_handle;
|
|
let _ = doc.add_entity(codec::EntityType::Block(block));
|
|
let mut block_end = codec::entities::BlockEnd::new();
|
|
block_end.common.handle = end_handle;
|
|
block_end.common.owner_handle = br_handle;
|
|
let _ = doc.add_entity(codec::EntityType::BlockEnd(block_end));
|
|
for mut entity in entities.iter().cloned() {
|
|
add_entity_clone_doc_inner(doc, &mut entity, br_handle);
|
|
let _ = doc.add_entity(entity);
|
|
}
|
|
}
|
|
|
|
/// Shared sub-handle reset + owner stamp for block-definition members.
|
|
fn add_entity_clone_doc_inner(
|
|
doc: &mut codec::CadDocument,
|
|
entity: &mut codec::EntityType,
|
|
owner: Handle,
|
|
) {
|
|
match entity {
|
|
codec::EntityType::Insert(ins) => {
|
|
for att in ins.attributes.iter_mut() {
|
|
att.common.handle = doc.allocate_handle();
|
|
}
|
|
}
|
|
codec::EntityType::Polyline3D(p) => {
|
|
for v in p.vertices.iter_mut() {
|
|
v.handle = doc.allocate_handle();
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
entity.common_mut().handle = Handle::NULL;
|
|
entity.common_mut().owner_handle = owner;
|
|
// An extension dictionary is exclusively owned; the clone must not claim
|
|
// the source's (cross-drawing it would dangle into the source document),
|
|
// or file validation reports "Extension dictionary <H> Cannot access".
|
|
// Paste reattaches a recreated subtree afterwards (finalize_paste).
|
|
entity.common_mut().xdictionary_handle = None;
|
|
}
|
|
|
|
/// Document-level fresh `*D<n>` block from `subs`: the `&mut CadDocument`
|
|
/// half of `Scene::define_transformed_block` (which has no render-cache tail,
|
|
/// so this is a verbatim port). Returns the new block name, or `None` when
|
|
/// `subs` is empty.
|
|
fn define_transformed_block_doc(
|
|
doc: &mut codec::CadDocument,
|
|
subs: &[codec::EntityType],
|
|
t: &crate::command::EntityTransform,
|
|
) -> Option<String> {
|
|
if subs.is_empty() {
|
|
return None;
|
|
}
|
|
let mut n = 0u64;
|
|
let new_name = loop {
|
|
let cand = format!("*D{n}");
|
|
if doc.block_records.get(&cand).is_none() {
|
|
break cand;
|
|
}
|
|
n += 1;
|
|
};
|
|
let next = doc.next_handle();
|
|
let br_handle = Handle::new(next);
|
|
let block_handle = Handle::new(next + 1);
|
|
let end_handle = Handle::new(next + 2);
|
|
let mut br = codec::tables::BlockRecord::new(&new_name);
|
|
br.handle = br_handle;
|
|
br.block_entity_handle = block_handle;
|
|
br.block_end_handle = end_handle;
|
|
doc.block_records.add(br).ok()?;
|
|
let mut block = codec::entities::Block::new(&new_name, codec::types::Vector3::ZERO);
|
|
block.common.handle = block_handle;
|
|
block.common.owner_handle = br_handle;
|
|
doc.add_entity(codec::EntityType::Block(block)).ok()?;
|
|
let mut block_end = codec::entities::BlockEnd::new();
|
|
block_end.common.handle = end_handle;
|
|
block_end.common.owner_handle = br_handle;
|
|
doc.add_entity(codec::EntityType::BlockEnd(block_end))
|
|
.ok()?;
|
|
for sub in subs {
|
|
let mut sub = sub.clone();
|
|
crate::scene::view::dispatch::apply_transform(&mut sub, t);
|
|
add_entity_clone_doc_inner(doc, &mut sub, br_handle);
|
|
let _ = doc.add_entity(sub);
|
|
}
|
|
Some(new_name)
|
|
}
|
|
|
|
/// COPYCLIP kernel: clone the selected entities out of `doc` and snapshot
|
|
/// the table records / block definitions / xdictionary graphs they depend on,
|
|
/// so a later paste can recreate them (including cross-drawing). Clipboard
|
|
/// storage (`clipboard`, `clipboard_base`, `clipboard_deps`) and the echo stay
|
|
/// caller-side in `copy_entities_to_clipboard` / `handle_copy_to_clipboard`.
|
|
pub(crate) fn copy_to_clipboard_kernel(
|
|
doc: &codec::CadDocument,
|
|
handles: &[Handle],
|
|
) -> (Vec<codec::EntityType>, crate::app::ClipboardDeps) {
|
|
let entities: Vec<_> = handles
|
|
.iter()
|
|
.filter_map(|&handle| doc.get_entity(handle).cloned())
|
|
.collect();
|
|
let deps = crate::app::ClipboardDeps::capture(doc, &entities);
|
|
(entities, deps)
|
|
}
|
|
|
|
fn recreate_ext_subtree(
|
|
doc: &mut codec::CadDocument,
|
|
cap: &crate::app::ClipExtObjects,
|
|
entity_handle: Option<Handle>,
|
|
records: &std::collections::HashMap<Handle, Handle>,
|
|
) -> Option<Handle> {
|
|
use std::collections::HashMap;
|
|
let mut remap: HashMap<Handle, Handle> = records.clone();
|
|
if let Some(eh) = entity_handle {
|
|
remap.insert(cap.src_entity_handle, eh);
|
|
}
|
|
for (old, scale) in &cap.annotation_scales {
|
|
let target = crate::scene::annotative::ensure_scale_object(doc, scale);
|
|
remap.insert(*old, target);
|
|
}
|
|
for (old, _) in &cap.objects {
|
|
remap.insert(*old, doc.allocate_handle());
|
|
}
|
|
for (old, obj) in &cap.objects {
|
|
let mut obj = obj.clone();
|
|
let new_h = remap[old];
|
|
remap_object(&mut obj, new_h, &remap);
|
|
// A dynamic reference's link to its definition, indexed.
|
|
if let codec::objects::ObjectType::DynamicBlock(object) = &obj {
|
|
if let codec::objects::DynamicBlockData::Representation(link) = &object.data {
|
|
if object.dxf_name == "ACDB_BLOCKREPRESENTATION_DATA" {
|
|
doc.block_representations.insert(new_h, link.block);
|
|
}
|
|
}
|
|
}
|
|
doc.objects.insert(new_h, obj);
|
|
}
|
|
remap.get(&cap.root).copied()
|
|
}
|
|
|
|
/// Replace references to a clipboard entity inside one recreated extension
|
|
/// dictionary graph after its final block-owned handle becomes known.
|
|
pub(crate) fn remap_ext_subtree_reference(
|
|
doc: &mut codec::CadDocument,
|
|
root: Handle,
|
|
source_entity: Handle,
|
|
target_entity: Handle,
|
|
) {
|
|
use codec::objects::ObjectType;
|
|
use rustc_hash::FxHashSet;
|
|
use std::collections::HashMap;
|
|
|
|
let remap = HashMap::from([(source_entity, target_entity)]);
|
|
let mut seen = FxHashSet::default();
|
|
let mut pending = vec![root];
|
|
while let Some(handle) = pending.pop() {
|
|
if handle.is_null() || !seen.insert(handle) {
|
|
continue;
|
|
}
|
|
let children = match doc.objects.get(&handle) {
|
|
Some(ObjectType::Dictionary(dictionary)) => {
|
|
let mut children: Vec<_> =
|
|
dictionary.entries.iter().map(|(_, child)| *child).collect();
|
|
if let Some(extension) = dictionary.xdictionary_handle {
|
|
children.push(extension);
|
|
}
|
|
children
|
|
}
|
|
Some(ObjectType::DictionaryWithDefault(dictionary)) => {
|
|
let mut children: Vec<_> =
|
|
dictionary.entries.iter().map(|(_, child)| *child).collect();
|
|
children.push(dictionary.default_handle);
|
|
children
|
|
}
|
|
_ => Vec::new(),
|
|
};
|
|
pending.extend(children);
|
|
if let Some(mut object) = doc.objects.remove(&handle) {
|
|
remap_object(&mut object, handle, &remap);
|
|
doc.objects.insert(handle, object);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Rewrite a cloned extension-dictionary object onto fresh handles: set its own
|
|
/// handle to `new_handle` and remap its owner and any handle references it holds
|
|
/// through `remap` (a handle still in the source space stays unchanged, which is
|
|
/// correct for cross-references that point outside the captured subtree).
|
|
pub(crate) fn remap_object(
|
|
obj: &mut codec::objects::ObjectType,
|
|
new_handle: codec::Handle,
|
|
remap: &std::collections::HashMap<codec::Handle, codec::Handle>,
|
|
) {
|
|
use codec::objects::ObjectType;
|
|
let map = |h: codec::Handle| remap.get(&h).copied().unwrap_or(h);
|
|
match obj {
|
|
ObjectType::Dictionary(d) => {
|
|
d.handle = new_handle;
|
|
d.owner = map(d.owner);
|
|
for (_, h) in d.entries.iter_mut() {
|
|
*h = map(*h);
|
|
}
|
|
if let Some(x) = d.xdictionary_handle.as_mut() {
|
|
*x = map(*x);
|
|
}
|
|
for r in d.reactors.iter_mut() {
|
|
*r = map(*r);
|
|
}
|
|
}
|
|
ObjectType::DictionaryWithDefault(d) => {
|
|
d.handle = new_handle;
|
|
d.owner = map(d.owner);
|
|
for (_, h) in d.entries.iter_mut() {
|
|
*h = map(*h);
|
|
}
|
|
d.default_handle = map(d.default_handle);
|
|
}
|
|
ObjectType::DictionaryVariable(v) => {
|
|
v.handle = new_handle;
|
|
v.owner_handle = map(v.owner_handle);
|
|
}
|
|
ObjectType::SpatialFilter(s) => {
|
|
s.handle = new_handle;
|
|
s.owner = map(s.owner);
|
|
}
|
|
ObjectType::XRecord(x) => {
|
|
x.handle = new_handle;
|
|
x.owner = map(x.owner);
|
|
for entry in &mut x.entries {
|
|
if let codec::objects::XRecordValue::Handle(handle) = &mut entry.value {
|
|
*handle = map(*handle);
|
|
}
|
|
}
|
|
}
|
|
ObjectType::Group(g) => {
|
|
g.handle = new_handle;
|
|
g.owner = map(g.owner);
|
|
for h in g.entities.iter_mut() {
|
|
*h = map(*h);
|
|
}
|
|
}
|
|
ObjectType::ObjectContextData(context) => {
|
|
context.handle = new_handle;
|
|
context.owner_handle = map(context.owner_handle);
|
|
for reactor in &mut context.reactors {
|
|
*reactor = map(*reactor);
|
|
}
|
|
if let Some(dictionary) = &mut context.xdictionary_handle {
|
|
*dictionary = map(*dictionary);
|
|
}
|
|
context.scale = map(context.scale);
|
|
match &mut context.kind {
|
|
codec::objects::ObjectContextKind::Dim(dimension) => {
|
|
dimension.block = map(dimension.block);
|
|
}
|
|
codec::objects::ObjectContextKind::HatchView(hatch) => {
|
|
hatch.view = map(hatch.view);
|
|
}
|
|
codec::objects::ObjectContextKind::MTextAttribute(attribute) => {
|
|
if let Some(embedded) = &mut attribute.context {
|
|
embedded.owner_handle = map(embedded.owner_handle);
|
|
for reactor in &mut embedded.reactors {
|
|
*reactor = map(*reactor);
|
|
}
|
|
if let Some(dictionary) = &mut embedded.xdictionary_handle {
|
|
*dictionary = map(*dictionary);
|
|
}
|
|
embedded.scale = map(embedded.scale);
|
|
}
|
|
}
|
|
codec::objects::ObjectContextKind::MLeader(mleader) => {
|
|
if let Some(handle) = &mut mleader.text_style_handle {
|
|
*handle = map(*handle);
|
|
}
|
|
if let Some(handle) = &mut mleader.block_content_handle {
|
|
*handle = map(*handle);
|
|
}
|
|
if let Some(handle) = &mut mleader.scale_handle {
|
|
*handle = map(*handle);
|
|
}
|
|
for root in &mut mleader.leader_roots {
|
|
for line in &mut root.lines {
|
|
if let Some(handle) = &mut line.line_type_handle {
|
|
*handle = map(*handle);
|
|
}
|
|
if let Some(handle) = &mut line.arrowhead_handle {
|
|
*handle = map(*handle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
ObjectType::DynamicBlock(object) => {
|
|
object.handle = new_handle;
|
|
object.visit_handles_mut(&mut |h| *h = map(*h));
|
|
}
|
|
// Other leaf object kinds don't appear in an entity xdictionary; if one
|
|
// does, it's inserted with the fresh handle below via the caller's key,
|
|
// but its internal owner is left as-is (best effort).
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod clipboard_xdict_clone_tests {
|
|
use super::recreate_ext_subtree;
|
|
use super::remap_object;
|
|
use codec::Handle;
|
|
// Same re-export path `commands/blocks.rs:356` uses — this import proves
|
|
// the `mod.rs` re-export still covers external callers.
|
|
use super::super::remap_ext_subtree_reference;
|
|
use codec::objects::{ObjectType, XRecordValue};
|
|
|
|
/// A dictionary root pointing at one XRecord leaf that references the
|
|
/// source entity — the minimal shape of a captured XCLIP filter graph.
|
|
fn xdict_capture_fixture() -> crate::app::ClipExtObjects {
|
|
let mut src = codec::CadDocument::new();
|
|
let src_entity = src.allocate_handle();
|
|
let src_root = src.allocate_handle();
|
|
let src_leaf = src.allocate_handle();
|
|
|
|
let mut dict = codec::objects::Dictionary::new();
|
|
dict.handle = src_root;
|
|
dict.owner = src_entity;
|
|
dict.add_entry("XCLIP", src_leaf);
|
|
|
|
let mut xrec = codec::objects::XRecord::new();
|
|
xrec.handle = src_leaf;
|
|
xrec.owner = src_root;
|
|
xrec.entries.push(codec::objects::XRecordEntry::new(
|
|
340,
|
|
XRecordValue::Handle(src_entity),
|
|
));
|
|
|
|
crate::app::ClipExtObjects {
|
|
entity_index: 0,
|
|
src_entity_handle: src_entity,
|
|
root: src_root,
|
|
objects: vec![
|
|
(src_root, ObjectType::Dictionary(dict)),
|
|
(src_leaf, ObjectType::XRecord(xrec)),
|
|
],
|
|
annotation_scales: Vec::new(),
|
|
}
|
|
}
|
|
|
|
fn leaf_of(doc: &codec::CadDocument, root: Handle) -> Handle {
|
|
match doc.objects.get(&root) {
|
|
Some(ObjectType::Dictionary(d)) => {
|
|
assert_eq!(d.entries.len(), 1);
|
|
d.entries[0].1
|
|
}
|
|
other => panic!("expected recreated Dictionary root, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
/// Headless cross-drawing clone: recreate a captured xdictionary subtree
|
|
/// in a fresh document and assert every remapped handle resolves.
|
|
#[test]
|
|
fn cross_drawing_clone_remaps_xdict_handles() {
|
|
let cap = xdict_capture_fixture();
|
|
let mut dst = codec::CadDocument::new();
|
|
let before: Vec<Handle> = dst.objects.keys().copied().collect();
|
|
let dst_entity = dst.allocate_handle();
|
|
|
|
let new_root = recreate_ext_subtree(&mut dst, &cap, Some(dst_entity), &Default::default())
|
|
.expect("recreated xdictionary root");
|
|
assert!(!new_root.is_null());
|
|
assert!(!before.contains(&new_root), "clone must use a fresh handle");
|
|
assert_eq!(dst.objects.len(), before.len() + 2);
|
|
|
|
let leaf = leaf_of(&dst, new_root);
|
|
assert!(!before.contains(&leaf), "leaf must use a fresh handle");
|
|
match dst.objects.get(&new_root) {
|
|
Some(ObjectType::Dictionary(d)) => {
|
|
assert_eq!(d.handle, new_root);
|
|
assert_eq!(d.owner, dst_entity);
|
|
}
|
|
other => panic!("expected recreated Dictionary root, got {other:?}"),
|
|
}
|
|
match dst.objects.get(&leaf) {
|
|
Some(ObjectType::XRecord(x)) => {
|
|
assert_eq!(x.handle, leaf);
|
|
assert_eq!(x.owner, new_root);
|
|
assert_eq!(x.entries.len(), 1);
|
|
assert!(
|
|
matches!(&x.entries[0].value, XRecordValue::Handle(h) if *h == dst_entity),
|
|
"leaf entity reference must point at the pasted entity"
|
|
);
|
|
}
|
|
other => panic!("expected recreated XRecord leaf, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
/// PASTEBLOCK-style two-phase clone: recreate without a host entity, then
|
|
/// re-point the subtree at the final block-owned handle.
|
|
#[test]
|
|
fn cross_drawing_clone_two_phase_remap_resolves_reference() {
|
|
let cap = xdict_capture_fixture();
|
|
let mut dst = codec::CadDocument::new();
|
|
let before_len = dst.objects.len();
|
|
|
|
let root = recreate_ext_subtree(&mut dst, &cap, None, &Default::default())
|
|
.expect("recreated xdictionary root");
|
|
let leaf = leaf_of(&dst, root);
|
|
match dst.objects.get(&leaf) {
|
|
Some(ObjectType::XRecord(x)) => assert!(
|
|
matches!(&x.entries[0].value, XRecordValue::Handle(h) if *h == cap.src_entity_handle),
|
|
"unbound clone must keep the source-space reference"
|
|
),
|
|
other => panic!("expected recreated XRecord leaf, got {other:?}"),
|
|
}
|
|
|
|
let target = dst.allocate_handle();
|
|
remap_ext_subtree_reference(&mut dst, root, cap.src_entity_handle, target);
|
|
assert_eq!(dst.objects.len(), before_len + 2);
|
|
match dst.objects.get(&leaf) {
|
|
Some(ObjectType::XRecord(x)) => assert!(
|
|
matches!(&x.entries[0].value, XRecordValue::Handle(h) if *h == target),
|
|
"remapped leaf must point at the block-owned entity"
|
|
),
|
|
other => panic!("expected recreated XRecord leaf, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
/// The widened `pub(crate)` kernel rewrites a cloned dictionary onto
|
|
/// fresh handles through the remap table.
|
|
#[test]
|
|
fn remap_object_rewrites_dictionary_handles() {
|
|
use std::collections::HashMap;
|
|
let mut scratch = codec::CadDocument::new();
|
|
let old_self = scratch.allocate_handle();
|
|
let old_owner = scratch.allocate_handle();
|
|
let old_child = scratch.allocate_handle();
|
|
let new_self = scratch.allocate_handle();
|
|
let new_owner = scratch.allocate_handle();
|
|
let new_child = scratch.allocate_handle();
|
|
|
|
let mut dict = codec::objects::Dictionary::new();
|
|
dict.handle = old_self;
|
|
dict.owner = old_owner;
|
|
dict.add_entry("K", old_child);
|
|
let mut obj = ObjectType::Dictionary(dict);
|
|
let remap = HashMap::from([(old_owner, new_owner), (old_child, new_child)]);
|
|
remap_object(&mut obj, new_self, &remap);
|
|
match obj {
|
|
ObjectType::Dictionary(d) => {
|
|
assert_eq!(d.handle, new_self);
|
|
assert_eq!(d.owner, new_owner);
|
|
assert_eq!(d.entries[0].1, new_child);
|
|
}
|
|
other => panic!("expected Dictionary, got {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod copy_to_clipboard_kernel_tests {
|
|
use super::copy_to_clipboard_kernel;
|
|
|
|
fn line_on(layer: &str) -> codec::EntityType {
|
|
let mut line = codec::entities::Line::new();
|
|
line.common.layer = layer.to_string();
|
|
codec::EntityType::Line(line)
|
|
}
|
|
|
|
#[test]
|
|
fn clones_entities_and_captures_layer_deps() {
|
|
let mut doc = codec::CadDocument::new();
|
|
doc.layers
|
|
.add(codec::tables::Layer::new("WALLS"))
|
|
.expect("add layer");
|
|
let a = doc.add_entity(line_on("WALLS")).unwrap();
|
|
let b = doc.add_entity(line_on("WALLS")).unwrap();
|
|
|
|
let (entities, deps) = copy_to_clipboard_kernel(&doc, &[a, b]);
|
|
|
|
assert_eq!(entities.len(), 2);
|
|
assert!(entities.iter().all(|e| e.common().layer == "WALLS"));
|
|
let handles: Vec<_> = entities.iter().map(|e| e.common().handle).collect();
|
|
assert!(handles.contains(&a));
|
|
assert!(handles.contains(&b));
|
|
assert!(deps.layers.iter().any(|l| l.name == "WALLS"));
|
|
}
|
|
|
|
#[test]
|
|
fn skips_handles_missing_from_the_document() {
|
|
let mut doc = codec::CadDocument::new();
|
|
let kept = doc.add_entity(line_on("0")).unwrap();
|
|
let missing = doc.allocate_handle();
|
|
|
|
let (entities, _) = copy_to_clipboard_kernel(&doc, &[kept, missing]);
|
|
|
|
assert_eq!(entities.len(), 1);
|
|
assert_eq!(entities[0].common().handle, kept);
|
|
}
|
|
|
|
#[test]
|
|
fn empty_selection_yields_empty_payload() {
|
|
let doc = codec::CadDocument::new();
|
|
|
|
let (entities, deps) = copy_to_clipboard_kernel(&doc, &[]);
|
|
|
|
assert!(entities.is_empty());
|
|
assert!(deps.layers.is_empty());
|
|
assert!(deps.blocks.is_empty());
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod paste_entities_kernel_tests {
|
|
use super::{copy_to_clipboard_kernel, paste_entities_kernel};
|
|
use codec::Handle;
|
|
|
|
fn line_on(layer: &str) -> codec::EntityType {
|
|
let mut line = codec::entities::Line::new();
|
|
line.common.layer = layer.to_string();
|
|
codec::EntityType::Line(line)
|
|
}
|
|
|
|
#[test]
|
|
fn pastes_with_fresh_handles_and_translate() {
|
|
let mut seed = codec::CadDocument::new();
|
|
seed.layers
|
|
.add(codec::tables::Layer::new("WALLS"))
|
|
.expect("add layer");
|
|
// Position the seed line away from the origin so the translate is visible.
|
|
let mut seed_line = codec::entities::Line::from_points(
|
|
codec::types::Vector3::new(0.0, 0.0, 0.0),
|
|
codec::types::Vector3::new(10.0, 0.0, 0.0),
|
|
);
|
|
seed_line.common.layer = "WALLS".to_string();
|
|
let seed_handle = seed.add_entity(codec::EntityType::Line(seed_line)).unwrap();
|
|
let (entities, deps) = copy_to_clipboard_kernel(&seed, &[seed_handle]);
|
|
|
|
let mut dst = codec::CadDocument::new();
|
|
let delta = glam::DVec3::new(5.0, 7.0, 0.0);
|
|
let translate = crate::command::EntityTransform::Translate(delta);
|
|
let (handles, handle_map) = paste_entities_kernel(
|
|
&mut dst,
|
|
&entities,
|
|
&deps,
|
|
Some(&translate),
|
|
crate::app::PasteSpace::Model,
|
|
);
|
|
|
|
assert_eq!(handles.len(), 1);
|
|
let pasted = handles[0];
|
|
assert!(!pasted.is_null());
|
|
assert_ne!(pasted, seed_handle, "paste must use a fresh handle");
|
|
assert_eq!(handle_map.get(&seed_handle), Some(&pasted));
|
|
let line = match dst.get_entity(pasted) {
|
|
Some(codec::EntityType::Line(l)) => l,
|
|
other => panic!("expected pasted Line, got {other:?}"),
|
|
};
|
|
assert!(
|
|
(line.start.x - 5.0).abs() < 1e-9,
|
|
"start.x = {}",
|
|
line.start.x
|
|
);
|
|
assert!(
|
|
(line.start.y - 7.0).abs() < 1e-9,
|
|
"start.y = {}",
|
|
line.start.y
|
|
);
|
|
assert!((line.end.x - 15.0).abs() < 1e-9, "end.x = {}", line.end.x);
|
|
// The layer dependency must have been recreated in the target document.
|
|
assert!(dst.layers.contains("WALLS"));
|
|
assert_eq!(line.common.layer, "WALLS");
|
|
}
|
|
|
|
#[test]
|
|
fn remaps_leader_annotation_link_to_pasted_handles() {
|
|
let mut seed = codec::CadDocument::new();
|
|
let note = seed
|
|
.add_entity(codec::EntityType::MText(codec::entities::MText::new()))
|
|
.unwrap();
|
|
let mut leader = codec::entities::Leader::default();
|
|
leader.annotation_handle = note;
|
|
let leader_handle = seed.add_entity(codec::EntityType::Leader(leader)).unwrap();
|
|
let (entities, deps) = copy_to_clipboard_kernel(&seed, &[leader_handle, note]);
|
|
|
|
let mut dst = codec::CadDocument::new();
|
|
let (handles, _) = paste_entities_kernel(
|
|
&mut dst,
|
|
&entities,
|
|
&deps,
|
|
None,
|
|
crate::app::PasteSpace::Model,
|
|
);
|
|
|
|
assert_eq!(handles.len(), 2);
|
|
let pasted_leader = match dst.get_entity(handles[0]) {
|
|
Some(codec::EntityType::Leader(l)) => l,
|
|
other => panic!("expected pasted Leader, got {other:?}"),
|
|
};
|
|
assert_eq!(
|
|
pasted_leader.annotation_handle, handles[1],
|
|
"leader must point at the pasted annotation, not the source handle"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn recreates_ext_subtree_and_repoints_xdictionary() {
|
|
// Minimal XCLIP-shaped capture: a dictionary root over one XRecord leaf
|
|
// that references the source entity (mirrors clipboard_xdict_clone_tests).
|
|
use codec::objects::{Dictionary, ObjectType, XRecord, XRecordEntry, XRecordValue};
|
|
let mut seed = codec::CadDocument::new();
|
|
let seed_entity = seed.add_entity(line_on("0")).unwrap();
|
|
let src_root = seed.allocate_handle();
|
|
let src_leaf = seed.allocate_handle();
|
|
let mut dict = Dictionary::new();
|
|
dict.handle = src_root;
|
|
dict.owner = seed_entity;
|
|
dict.add_entry("XCLIP", src_leaf);
|
|
let mut xrec = XRecord::new();
|
|
xrec.handle = src_leaf;
|
|
xrec.owner = src_root;
|
|
xrec.entries
|
|
.push(XRecordEntry::new(340, XRecordValue::Handle(seed_entity)));
|
|
seed.objects.insert(src_root, ObjectType::Dictionary(dict));
|
|
seed.objects.insert(src_leaf, ObjectType::XRecord(xrec));
|
|
if let Some(e) = seed.get_entity_mut(seed_entity) {
|
|
e.common_mut().xdictionary_handle = Some(src_root);
|
|
}
|
|
let (entities, deps) = copy_to_clipboard_kernel(&seed, &[seed_entity]);
|
|
assert_eq!(deps.ext_objects.len(), 1, "capture must snapshot the xdict");
|
|
|
|
let mut dst = codec::CadDocument::new();
|
|
let before: Vec<Handle> = dst.objects.keys().copied().collect();
|
|
let (handles, _) = paste_entities_kernel(
|
|
&mut dst,
|
|
&entities,
|
|
&deps,
|
|
None,
|
|
crate::app::PasteSpace::Model,
|
|
);
|
|
|
|
assert_eq!(handles.len(), 1);
|
|
let pasted = handles[0];
|
|
let new_root = dst
|
|
.get_entity(pasted)
|
|
.and_then(|e| e.common().xdictionary_handle)
|
|
.expect("pasted entity must point at a recreated xdictionary root");
|
|
// Handles are document-local: freshness is judged within the target
|
|
// document, not against the source document's numbers.
|
|
assert!(
|
|
!before.contains(&new_root),
|
|
"recreated root must use a fresh handle in the target document"
|
|
);
|
|
let leaf = match dst.objects.get(&new_root) {
|
|
Some(ObjectType::Dictionary(d)) => {
|
|
assert_eq!(d.entries.len(), 1);
|
|
d.entries[0].1
|
|
}
|
|
other => panic!("expected recreated Dictionary root, got {other:?}"),
|
|
};
|
|
match dst.objects.get(&leaf) {
|
|
Some(ObjectType::XRecord(x)) => assert!(
|
|
matches!(&x.entries[0].value, XRecordValue::Handle(h) if *h == pasted),
|
|
"leaf reference must point at the pasted entity"
|
|
),
|
|
other => panic!("expected recreated XRecord leaf, got {other:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod headless_reuse_proof_tests {
|
|
// Task 5 reuse proof — headless only. This module constructs NO
|
|
// `OpenCADStudio` value and touches no UI/scene state: only
|
|
// `codec::CadDocument`, entities, and the shared kernels
|
|
// (`copy_to_clipboard_kernel`, `paste_entities_kernel`,
|
|
// `match_layer_kernel`, `match_properties_kernel` + `MatchOpts`).
|
|
use super::{copy_to_clipboard_kernel, paste_entities_kernel};
|
|
use crate::entities::match_props::{match_layer_kernel, match_properties_kernel, MatchOpts};
|
|
|
|
#[test]
|
|
fn headless_copy_paste_then_match_kernels_share_one_path() {
|
|
// Phase 1: copy in doc A, paste into doc B with a translate.
|
|
let mut doc_a = codec::CadDocument::new();
|
|
doc_a
|
|
.layers
|
|
.add(codec::tables::Layer::new("WALLS"))
|
|
.expect("add layer");
|
|
let mut seed_line = codec::entities::Line::from_points(
|
|
codec::types::Vector3::new(0.0, 0.0, 0.0),
|
|
codec::types::Vector3::new(10.0, 0.0, 0.0),
|
|
);
|
|
seed_line.common.layer = "WALLS".to_string();
|
|
let seed_handle = doc_a
|
|
.add_entity(codec::EntityType::Line(seed_line))
|
|
.unwrap();
|
|
|
|
let (entities, deps) = copy_to_clipboard_kernel(&doc_a, &[seed_handle]);
|
|
assert_eq!(entities.len(), 1);
|
|
assert_eq!(entities[0].common().layer, "WALLS");
|
|
|
|
let mut doc_b = codec::CadDocument::new();
|
|
let translate = crate::command::EntityTransform::Translate(glam::DVec3::new(5.0, 7.0, 0.0));
|
|
let (handles, handle_map) = paste_entities_kernel(
|
|
&mut doc_b,
|
|
&entities,
|
|
&deps,
|
|
Some(&translate),
|
|
crate::app::PasteSpace::Model,
|
|
);
|
|
|
|
assert_eq!(handles.len(), 1);
|
|
let pasted = handles[0];
|
|
assert!(!pasted.is_null());
|
|
assert_ne!(pasted, seed_handle, "paste must use a fresh handle");
|
|
assert_eq!(handle_map.get(&seed_handle), Some(&pasted));
|
|
assert!(doc_b.layers.contains("WALLS"), "layer dep must follow");
|
|
match doc_b.get_entity(pasted) {
|
|
Some(codec::EntityType::Line(l)) => {
|
|
assert_eq!(l.common.layer, "WALLS");
|
|
assert!((l.start.x - 5.0).abs() < 1e-9, "start.x = {}", l.start.x);
|
|
assert!((l.start.y - 7.0).abs() < 1e-9, "start.y = {}", l.start.y);
|
|
assert!((l.end.x - 15.0).abs() < 1e-9, "end.x = {}", l.end.x);
|
|
}
|
|
other => panic!("expected pasted Line, got {other:?}"),
|
|
}
|
|
|
|
// Phase 2: match kernels on a src/dst pair in the same headless doc.
|
|
let mut src_line = codec::entities::Line::new();
|
|
src_line.common.layer = "WALLS".to_string();
|
|
src_line.common.linetype_scale = 2.5;
|
|
src_line.thickness = 1.25;
|
|
let src = doc_b.add_entity(codec::EntityType::Line(src_line)).unwrap();
|
|
let mut dst_line = codec::entities::Line::new();
|
|
dst_line.common.layer = "0".to_string();
|
|
dst_line.common.linetype_scale = 1.0;
|
|
dst_line.thickness = 0.0;
|
|
let dst = doc_b.add_entity(codec::EntityType::Line(dst_line)).unwrap();
|
|
|
|
let count = match_layer_kernel(&mut doc_b, &[dst], src).expect("match layer");
|
|
assert_eq!(count, 1);
|
|
assert_eq!(
|
|
doc_b.get_entity(dst).unwrap().common().layer,
|
|
"WALLS",
|
|
"match_layer_kernel must transfer the layer"
|
|
);
|
|
|
|
let src_clone = doc_b.get_entity(src).cloned().unwrap();
|
|
{
|
|
let dst_entity = doc_b.get_entity_mut(dst).unwrap();
|
|
match_properties_kernel(&src_clone, dst_entity, &MatchOpts::all());
|
|
}
|
|
match doc_b.get_entity(dst) {
|
|
Some(codec::EntityType::Line(l)) => {
|
|
assert_eq!(l.common.layer, "WALLS");
|
|
assert!((l.common.linetype_scale - 2.5).abs() < 1e-9);
|
|
assert!((l.thickness - 1.25).abs() < 1e-9);
|
|
}
|
|
other => panic!("expected matched Line, got {other:?}"),
|
|
}
|
|
}
|
|
#[test]
|
|
fn paste_owner_override_routes_entity_into_block_record() {
|
|
let mut source = codec::CadDocument::new();
|
|
|
|
let line = codec::entities::Line::from_points(
|
|
codec::types::Vector3::new(0.0, 0.0, 0.0),
|
|
codec::types::Vector3::new(10.0, 0.0, 0.0),
|
|
);
|
|
let source_handle = source
|
|
.add_entity(codec::EntityType::Line(line))
|
|
.expect("source line");
|
|
|
|
let (entities, deps) = copy_to_clipboard_kernel(&source, &[source_handle]);
|
|
|
|
let mut target = codec::CadDocument::new();
|
|
|
|
let block_handle = target.allocate_handle();
|
|
let mut block = codec::tables::BlockRecord::new("BEDIT_TARGET");
|
|
block.handle = block_handle;
|
|
target
|
|
.block_records
|
|
.add(block)
|
|
.expect("target block record");
|
|
|
|
let (handles, _) = paste_entities_kernel(
|
|
&mut target,
|
|
&entities,
|
|
&deps,
|
|
None,
|
|
crate::app::PasteSpace::Block(block_handle),
|
|
);
|
|
|
|
assert_eq!(handles.len(), 1);
|
|
let pasted = handles[0];
|
|
assert!(!pasted.is_null());
|
|
|
|
let entity = target.get_entity(pasted).expect("pasted entity must exist");
|
|
|
|
assert_eq!(
|
|
entity.common().owner_handle,
|
|
block_handle,
|
|
"paste inside BEDIT must belong to the edited block record"
|
|
);
|
|
|
|
let record = target
|
|
.block_records
|
|
.get("BEDIT_TARGET")
|
|
.expect("block record must still exist");
|
|
|
|
assert!(
|
|
record.entity_handles.contains(&pasted),
|
|
"pasted entity must be registered as a member of the edited block"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod define_transformed_block_doc_xdict_tests {
|
|
use super::define_transformed_block_doc;
|
|
|
|
/// No extension dictionary may be referenced by more than one entity.
|
|
fn assert_no_shared_xdicts(doc: &codec::CadDocument) {
|
|
use std::collections::HashMap;
|
|
let mut owners: HashMap<codec::Handle, usize> = HashMap::new();
|
|
for entity in doc.entities() {
|
|
if let Some(xd) = entity.common().xdictionary_handle {
|
|
if !xd.is_null() {
|
|
*owners.entry(xd).or_default() += 1;
|
|
}
|
|
}
|
|
}
|
|
let shared: Vec<_> = owners
|
|
.iter()
|
|
.filter(|(_, &n)| n > 1)
|
|
.map(|(h, n)| format!("{h:?} x{n}"))
|
|
.collect();
|
|
assert!(
|
|
shared.is_empty(),
|
|
"shared extension dictionaries: {}",
|
|
shared.join(", ")
|
|
);
|
|
}
|
|
|
|
/// Pasted/derived sub-entities must not share the source's extension
|
|
/// dictionary. `define_transformed_block_doc` is the verbatim
|
|
/// document-level port of `Scene::define_transformed_block`, and its
|
|
/// clone helper likewise preserves `xdictionary_handle`; across drawings
|
|
/// that handle would dangle into the source document.
|
|
#[test]
|
|
fn cloned_subs_do_not_share_source_xdict() {
|
|
let mut doc = codec::CadDocument::new();
|
|
|
|
let dict_handle = doc.allocate_handle();
|
|
let mut dict = codec::objects::Dictionary::new();
|
|
dict.handle = dict_handle;
|
|
doc.objects
|
|
.insert(dict_handle, codec::objects::ObjectType::Dictionary(dict));
|
|
|
|
let mut line = codec::entities::Line::new();
|
|
line.common.xdictionary_handle = Some(dict_handle);
|
|
let src_handle = doc.add_entity(codec::EntityType::Line(line)).unwrap();
|
|
|
|
let subs = vec![doc.get_entity(src_handle).unwrap().clone()];
|
|
let name = define_transformed_block_doc(
|
|
&mut doc,
|
|
&subs,
|
|
&crate::command::EntityTransform::Translate(glam::DVec3::ZERO),
|
|
)
|
|
.expect("clone block must be created");
|
|
assert!(
|
|
name.starts_with("*D"),
|
|
"anonymous block expected, got {name}"
|
|
);
|
|
|
|
assert_no_shared_xdicts(&doc);
|
|
// Source keeps its dictionary.
|
|
match doc.get_entity(src_handle) {
|
|
Some(e) => assert_eq!(
|
|
e.common().xdictionary_handle,
|
|
Some(dict_handle),
|
|
"the source must keep its own dictionary"
|
|
),
|
|
None => panic!("source entity missing"),
|
|
}
|
|
// Clones carry none.
|
|
let owned = doc.block_records.get(&name).unwrap().entity_handles.clone();
|
|
assert!(!owned.is_empty(), "clone block should own sub-entities");
|
|
for h in &owned {
|
|
match doc.get_entity(*h) {
|
|
Some(e) => assert!(
|
|
e.common().xdictionary_handle.is_none(),
|
|
"cloned child {h:?} must not carry an extension dictionary"
|
|
),
|
|
None => panic!("cloned child {h:?} missing"),
|
|
}
|
|
}
|
|
}
|
|
}
|