fix(sectionplane): persist and clip section modes correctly

tests/section_plane_roundtrip.rs

@@ -0,0 +1,110 @@
+use acadrust::entities::{EntityCommon, ExtendedEntity, ExtendedEntityData, SectionObjectData};
+use acadrust::objects::{ClassObjectData, ObjectType};
+use acadrust::types::{Color, Handle, Vector3};
+use acadrust::xdata::{ExtendedDataRecord, XDataValue};
+use acadrust::EntityType;
+use OpenCADStudio::scene::Scene;
+
+fn add_slice(scene: &mut Scene) -> Handle {
+    let mut common = EntityCommon::new();
+    let mut slice = ExtendedDataRecord::new("IsSlice");
+    slice.values = vec![XDataValue::Integer16(0), XDataValue::Integer16(1)];
+    common.extended_data.add_record(slice);
+    let mut thickness = ExtendedDataRecord::new("ThicknessDepth");
+    thickness.values = vec![XDataValue::Real(0.75)];
+    common.extended_data.add_record(thickness);
+
+    scene.add_entity(EntityType::Extended(ExtendedEntity {
+        common,
+        data: ExtendedEntityData::SectionObject(SectionObjectData {
+            state: 1,
+            flags: 5,
+            name: "Section Plane (1)".to_string(),
+            vertical_direction: Vector3::UNIT_Z,
+            top_height: 5.0,
+            bottom_height: 5.0,
+            indicator_alpha: 70,
+            indicator_color: Color::from_index(9),
+            vertices: vec![Vector3::ZERO, Vector3::new(10.0, 0.0, 0.0)],
+            back_line_vertices: Vec::new(),
+            settings_handle: Handle::NULL,
+        }),
+    }))
+}
+
+fn assert_section_graph(document: &acadrust::CadDocument, extension: &str) {
+    let (handle, section) = document
+        .entities()
+        .find_map(|entity| match entity {
+            EntityType::Extended(extended) => match &extended.data {
+                ExtendedEntityData::SectionObject(_) => Some((extended.common.handle, extended)),
+                _ => None,
+            },
+            _ => None,
+        })
+        .unwrap_or_else(|| panic!("section entity should round-trip through {extension}"));
+    let ExtendedEntityData::SectionObject(data) = &section.data else {
+        unreachable!();
+    };
+    assert_eq!(data.state, 1);
+    assert!(data.back_line_vertices.is_empty());
+    assert!(matches!(
+        section
+            .common
+            .extended_data
+            .get_record("IsSlice")
+            .map(|record| record.values.as_slice()),
+        Some([XDataValue::Integer16(0), XDataValue::Integer16(1)])
+    ));
+    assert!(matches!(
+        section
+            .common
+            .extended_data
+            .get_record("ThicknessDepth")
+            .and_then(|record| record.values.first()),
+        Some(XDataValue::Real(value)) if (*value - 0.75).abs() < 1e-12
+    ));
+    assert!(matches!(
+        document.objects.get(&data.settings_handle),
+        Some(ObjectType::ClassObject(object))
+            if object.owner == handle
+                && matches!(&object.data, ClassObjectData::SectionSettings(_))
+    ));
+
+    let root = document
+        .objects
+        .get(&document.header.named_objects_dict_handle)
+        .expect("root dictionary should round-trip");
+    let ObjectType::Dictionary(root) = root else {
+        panic!("root should be a dictionary");
+    };
+    let manager_handle = root
+        .entries
+        .iter()
+        .find(|(name, _)| name == "ACAD_SECTION_MANAGER")
+        .map(|(_, handle)| *handle)
+        .expect("section manager should be registered");
+    let Some(ObjectType::ClassObject(manager)) = document.objects.get(&manager_handle) else {
+        panic!("section manager handle should resolve");
+    };
+    let ClassObjectData::SectionManager(manager) = &manager.data else {
+        panic!("registered object should be a section manager");
+    };
+    assert_eq!(manager.sections, vec![handle]);
+}
+
+#[test]
+fn section_plane_graph_survives_dxf_and_dwg_roundtrips() {
+    let mut scene = Scene::new();
+    add_slice(&mut scene);
+
+    for extension in ["dxf", "dwg"] {
+        let bytes =
+            OpenCADStudio::io::save_to_bytes(&scene.document, extension, scene.document.version)
+                .expect("section document should save");
+        let document =
+            OpenCADStudio::io::load_bytes(&format!("section-roundtrip.{extension}"), bytes)
+                .expect("section document should reload");
+        assert_section_graph(&document, extension);
+    }
+}