acadrust 0.6.6

A pure Rust library for reading and writing CAD files in DXF format (ASCII and Binary) and DWG format (Binary).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::objects::{Dictionary, DictionaryVariable, ObjectType};
use crate::types::{Handle, Transparency};
use crate::CadDocument;

const VARIABLES: &str = "AcDbVariableDictionary";
const CURRENT: &str = "CETRANSPARENCY";

impl CadDocument {
    /// Current entity transparency, stored in the drawing variable dictionary.
    /// Missing or malformed values retain the inherited default.
    pub fn current_entity_transparency(&self) -> Transparency {
        let read = || {
            let ObjectType::Dictionary(root) =
                self.objects.get(&self.header.named_objects_dict_handle)?
            else {
                return None;
            };
            let ObjectType::Dictionary(variables) = self.objects.get(&root.get(VARIABLES)?)? else {
                return None;
            };
            let ObjectType::DictionaryVariable(value) =
                self.objects.get(&variables.get(CURRENT)?)?
            else {
                return None;
            };
            Some(Transparency::from_alpha_value(
                value.value.parse::<u32>().ok()?,
            ))
        };
        read().unwrap_or(Transparency::ByLayer)
    }

    /// Store current entity transparency using the packed dictionary value.
    /// Existing entries are updated in place; conflicting object types are preserved.
    pub fn set_current_entity_transparency(&mut self, value: Transparency) -> bool {
        if matches!(value, Transparency::Explicit(amount) if amount > 230) {
            return false;
        }
        let mut root_handle = self.header.named_objects_dict_handle;
        if root_handle == Handle::NULL {
            root_handle = self.allocate_handle();
            let mut root = Dictionary::new();
            root.handle = root_handle;
            self.objects
                .insert(root_handle, ObjectType::Dictionary(root));
            self.header.named_objects_dict_handle = root_handle;
        }
        let Some(ObjectType::Dictionary(root)) = self.objects.get(&root_handle) else {
            return false;
        };
        let variables_handle = root.get(VARIABLES);
        let variables_handle = if let Some(handle) = variables_handle {
            if !matches!(self.objects.get(&handle), Some(ObjectType::Dictionary(_))) {
                return false;
            }
            handle
        } else {
            let handle = self.allocate_handle();
            let mut variables = Dictionary::new();
            variables.handle = handle;
            variables.owner = root_handle;
            self.objects
                .insert(handle, ObjectType::Dictionary(variables));
            if let Some(ObjectType::Dictionary(root)) = self.objects.get_mut(&root_handle) {
                root.add_entry(VARIABLES, handle);
            }
            handle
        };
        let Some(ObjectType::Dictionary(variables)) = self.objects.get(&variables_handle) else {
            return false;
        };
        let packed = value.to_dxf_value().to_string();
        if let Some(handle) = variables.get(CURRENT) {
            let Some(ObjectType::DictionaryVariable(variable)) = self.objects.get_mut(&handle)
            else {
                return false;
            };
            variable.value = packed;
        } else {
            let handle = self.allocate_handle();
            let mut variable = DictionaryVariable::new(CURRENT, &packed);
            variable.handle = handle;
            variable.owner_handle = variables_handle;
            self.objects
                .insert(handle, ObjectType::DictionaryVariable(variable));
            if let Some(ObjectType::Dictionary(variables)) = self.objects.get_mut(&variables_handle)
            {
                variables.add_entry(CURRENT, handle);
            }
        }
        true
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn current_transparency_roundtrips_and_rejects_unsupported_values() {
        let mut document = CadDocument::new();
        assert_eq!(
            document.current_entity_transparency(),
            Transparency::ByLayer
        );
        assert!(document.set_current_entity_transparency(Transparency::T_30));
        assert_eq!(document.current_entity_transparency(), Transparency::T_30);
        let object_count = document.objects.len();
        assert!(!document.set_current_entity_transparency(Transparency::Explicit(231)));
        assert_eq!(document.current_entity_transparency(), Transparency::T_30);
        assert_eq!(document.objects.len(), object_count);
    }
}