#![allow(non_snake_case)]
use std::collections::{BTreeMap, HashMap};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, OnceLock};
use ferrocad_core::{application, canonical_name, format as doc_format, parse_unit, prop_status, status_from_name, status_names, Document as CoreDocument, DocumentFormat, ExtensionData, ExtensionValue, Matrix4, ObjectId, Placement, Property, Quantity, Rotation, StringHasher, StringId, TypeId, Unit, Vector3};
use pyo3::exceptions::{
PyAttributeError, PyIndexError, PyNotImplementedError, PyRuntimeError, PyTypeError, PyValueError,
};
use pyo3::prelude::*;
use pyo3::types::{PyAny, PyAnyMethods, PyBool, PyBytes, PyDict, PyDictMethods, PyTuple, PyType};
use pyo3::IntoPyObjectExt;
static OBSERVERS: OnceLock<Mutex<Vec<Py<PyAny>>>> = OnceLock::new();
static OBJECT_CACHE: OnceLock<Mutex<HashMap<(usize, ObjectId), Py<PyDocumentObject>>>> = OnceLock::new();
static DOCUMENTS: OnceLock<Mutex<BTreeMap<String, Py<PyDocument>>>> = OnceLock::new();
fn documents() -> &'static Mutex<BTreeMap<String, Py<PyDocument>>> {
DOCUMENTS.get_or_init(|| Mutex::new(BTreeMap::new()))
}
fn observers() -> &'static Mutex<Vec<Py<PyAny>>> {
OBSERVERS.get_or_init(|| Mutex::new(Vec::new()))
}
fn object_cache() -> &'static Mutex<HashMap<(usize, ObjectId), Py<PyDocumentObject>>> {
OBJECT_CACHE.get_or_init(|| Mutex::new(HashMap::new()))
}
fn doc_key(doc: &Py<PyDocument>) -> usize {
doc.as_ptr() as usize
}
fn get_or_create_object(
py: Python<'_>,
doc: &Py<PyDocument>,
inner: &Arc<Mutex<CoreDocument>>,
id: ObjectId,
) -> Py<PyDocumentObject> {
let key = (doc_key(doc), id);
if let Some(existing) = object_cache().lock().unwrap().get(&key) {
return existing.clone_ref(py);
}
let obj = Py::new(
py,
PyDocumentObject {
doc: doc.clone_ref(py),
inner: Arc::clone(inner),
id,
view: Mutex::new(None),
},
)
.unwrap();
object_cache().lock().unwrap().insert(key, obj.clone_ref(py));
obj
}
fn forget_object(doc: &Py<PyDocument>, id: ObjectId) {
object_cache().lock().unwrap().remove(&(doc_key(doc), id));
}
fn deleted_object_error(attr: &str) -> PyErr {
pyo3::exceptions::PyReferenceError::new_err(format!(
"Cannot access attribute '{attr}' of deleted object"
))
}
fn property_change_error(error: String) -> PyErr {
match error.strip_prefix(ferrocad_core::object_registry::ATTRIBUTE_REJECTION_PREFIX) {
Some(message) => PyAttributeError::new_err(message.to_string()),
None => PyValueError::new_err(error),
}
}
fn object_is_attached(inner: &Arc<Mutex<CoreDocument>>, id: ObjectId) -> bool {
inner.lock().unwrap().object(id).is_some()
}
fn type_parent(type_id: &str) -> Option<&'static str> {
Some(match type_id {
"App::DocumentObject" => return None,
"App::GeoFeature" => "App::DocumentObject",
"App::Feature" => "App::GeoFeature",
"App::FeaturePython" => "App::Feature",
"App::DocumentObjectGroup" => "App::DocumentObject",
"App::DocumentObjectGroupPython" => "App::DocumentObjectGroup",
"App::Part" => "App::GeoFeature",
"App::Link" | "App::LinkGroup" | "App::LinkList" | "App::LinkElement" => {
"App::DocumentObject"
}
"App::Origin" | "App::Plane" | "App::Line" | "App::Point" => "App::DocumentObject",
"Part::Feature" => "App::GeoFeature",
"Part::FeaturePython" => "Part::Feature",
"Part::Part2DObject" => "Part::Feature",
"Part::Part2DObjectPython" => "Part::Part2DObject",
"PartDesign::Body" => "Part::Feature",
"Sketcher::SketchObject" => "Part::Part2DObject",
other if other.starts_with("Part::") => "Part::Feature",
other if other.starts_with("App::FeatureTest") => "App::Feature",
other if other.starts_with("App::") => "App::DocumentObject",
_ => return None,
})
}
fn type_is_derived_from(type_id: &str, target: &str) -> bool {
let mut current = type_id;
for _ in 0..16 {
if current == target {
return true;
}
match type_parent(current) {
Some(parent) => current = parent,
None => return false,
}
}
false
}
fn forget_document(doc: &Py<PyDocument>) {
let key = doc_key(doc);
object_cache().lock().unwrap().retain(|(d, _), _| *d != key);
}
fn observer_snapshot(py: Python<'_>) -> Vec<Py<PyAny>> {
observers()
.lock()
.unwrap()
.iter()
.map(|o| o.clone_ref(py))
.collect()
}
fn fire_doc(slot: &str, doc: &Bound<'_, PyDocument>, extra: Option<&Bound<'_, PyAny>>) {
let py = doc.py();
for ob in observer_snapshot(py) {
let ob = ob.bind(py);
if let Ok(m) = ob.getattr(slot) {
let _ = match extra {
Some(e) => m.call1((doc, e)),
None => m.call1((doc,)),
};
}
}
}
fn fire_obj(slot: &str, obj: &Bound<'_, PyDocumentObject>, extra: Option<&Bound<'_, PyAny>>) {
let py = obj.py();
for ob in observer_snapshot(py) {
let ob = ob.bind(py);
if let Ok(m) = ob.getattr(slot) {
let _ = match extra {
Some(e) => m.call1((obj, e)),
None => m.call1((obj,)),
};
}
}
}
fn fire_doc_str(slot: &str, doc: &Bound<'_, PyDocument>, extra: &str) {
let py = doc.py();
let e = extra.into_py_any(py).unwrap().into_bound(py);
fire_doc(slot, doc, Some(&e));
}
fn fire_obj_str(slot: &str, obj: &Bound<'_, PyDocumentObject>, extra: &str) {
let py = obj.py();
let e = extra.into_py_any(py).unwrap().into_bound(py);
fire_obj(slot, obj, Some(&e));
}
pub type ExtensionToPython = fn(Python<'_>, &dyn ExtensionData) -> Option<PyObject>;
pub type PythonToExtension = fn(&Bound<'_, PyAny>) -> Option<ExtensionValue>;
type ExtensionConverters = Vec<(String, ExtensionToPython, PythonToExtension)>;
fn extension_converters() -> &'static Mutex<ExtensionConverters> {
static CONVERTERS: OnceLock<Mutex<ExtensionConverters>> = OnceLock::new();
CONVERTERS.get_or_init(|| Mutex::new(Vec::new()))
}
pub fn register_extension_converter(
type_name: &str,
to_python: ExtensionToPython,
to_extension: PythonToExtension,
) {
let mut converters = extension_converters().lock().unwrap();
converters.retain(|(name, _, _)| name != type_name);
converters.push((type_name.to_string(), to_python, to_extension));
}
fn extension_to_py(py: Python<'_>, value: &ExtensionValue) -> PyObject {
let converter = extension_converters()
.lock()
.unwrap()
.iter()
.find(|(name, _, _)| name == value.type_name())
.map(|(_, to_python, _)| *to_python);
converter
.and_then(|to_python| to_python(py, value.data()))
.unwrap_or_else(|| py.None())
}
fn extension_from_py(value: &Bound<'_, PyAny>) -> Option<ExtensionValue> {
let converters: Vec<PythonToExtension> = extension_converters()
.lock()
.unwrap()
.iter()
.map(|(_, _, to_extension)| *to_extension)
.collect();
converters.iter().find_map(|to_extension| to_extension(value))
}
fn extension_from_py_for(type_name: &str, value: &Bound<'_, PyAny>) -> Option<ExtensionValue> {
let converter = extension_converters()
.lock()
.unwrap()
.iter()
.find(|(name, _, _)| name == type_name)
.map(|(_, _, to_extension)| *to_extension)?;
converter(value)
}
pub type SubElementToPython = fn(Python<'_>, &dyn ExtensionData, &str) -> Option<PyObject>;
type SubElementResolvers = Vec<(String, SubElementToPython)>;
fn sub_element_resolvers() -> &'static Mutex<SubElementResolvers> {
static RESOLVERS: OnceLock<Mutex<SubElementResolvers>> = OnceLock::new();
RESOLVERS.get_or_init(|| Mutex::new(Vec::new()))
}
pub fn register_sub_element_resolver(type_name: &str, resolver: SubElementToPython) {
let mut resolvers = sub_element_resolvers().lock().unwrap();
resolvers.retain(|(name, _)| name != type_name);
resolvers.push((type_name.to_string(), resolver));
}
fn sub_element_to_py(py: Python<'_>, value: &ExtensionValue, name: &str) -> Option<PyObject> {
let resolver = sub_element_resolvers()
.lock()
.unwrap()
.iter()
.find(|(type_name, _)| type_name == value.type_name())
.map(|(_, resolver)| *resolver)?;
resolver(py, value.data(), name)
}
pub type ExtensionProvider =
fn(&mut ferrocad_core::Document, ferrocad_core::ObjectId) -> bool;
pub type ExtensionMethod = fn(
&mut ferrocad_core::Document,
ferrocad_core::ObjectId,
&str,
&pyo3::Bound<'_, pyo3::PyAny>,
) -> pyo3::PyResult<pyo3::PyObject>;
type ProviderEntry = (String, ExtensionProvider);
type MethodEntry = (String, String, ExtensionMethod);
fn extension_providers() -> &'static Mutex<Vec<ProviderEntry>> {
static PROVIDERS: OnceLock<Mutex<Vec<ProviderEntry>>> = OnceLock::new();
PROVIDERS.get_or_init(|| Mutex::new(Vec::new()))
}
fn extension_methods() -> &'static Mutex<Vec<MethodEntry>> {
static METHODS: OnceLock<Mutex<Vec<MethodEntry>>> = OnceLock::new();
METHODS.get_or_init(|| Mutex::new(Vec::new()))
}
pub fn register_extension_provider(extension: &'static str, provider: ExtensionProvider) {
let mut providers = extension_providers().lock().unwrap();
providers.retain(|(name, _)| name != extension);
providers.push((extension.to_string(), provider));
}
pub fn register_extension_method(
extension: &'static str,
method: &'static str,
f: ExtensionMethod,
) {
let mut methods = extension_methods().lock().unwrap();
methods.retain(|(ext, name, _)| !(ext == extension && name == method));
methods.push((extension.to_string(), method.to_string(), f));
}
fn extension_provider(extension: &str) -> Option<ExtensionProvider> {
extension_providers()
.lock()
.unwrap()
.iter()
.find(|(name, _)| name == extension)
.map(|(_, provider)| *provider)
}
fn extension_method_for(
doc: &CoreDocument,
id: ObjectId,
name: &str,
) -> Option<(String, ExtensionMethod)> {
let extensions: Vec<String> = doc
.object(id)
.map(|object| object.extensions.iter().cloned().collect())
.unwrap_or_default();
let methods = extension_methods().lock().unwrap();
for extension in &extensions {
if let Some((ext, _, method)) = methods
.iter()
.find(|(ext, method, _)| ext == extension && method == name)
{
return Some((ext.clone(), *method));
}
}
None
}
fn call_extension_method(
slf: &Bound<'_, PyDocumentObject>,
method: &str,
args: &Bound<'_, PyAny>,
) -> PyResult<PyObject> {
let (inner, id) = {
let this = slf.borrow();
(Arc::clone(&this.inner), this.id)
};
let found = {
let doc = inner.lock().unwrap();
extension_method_for(&doc, id, method)
};
let Some((_extension, f)) = found else {
let type_id = inner
.lock()
.unwrap()
.object(id)
.map(|object| object.type_id.clone())
.unwrap_or_default();
return Err(PyAttributeError::new_err(format!(
"'{type_id}' object has no attribute '{method}'"
)));
};
let mut doc = inner.lock().unwrap();
f(&mut doc, id, method, args)
}
fn pickle_b64(py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<String> {
let pickle = py.import("pickle")?;
let base64 = py.import("base64")?;
let data = pickle.call_method1("dumps", (value,))?;
let encoded = base64.call_method1("b64encode", (data,))?;
encoded.call_method0("decode")?.extract()
}
fn unpickle_b64<'py>(py: Python<'py>, data: &str) -> PyResult<Bound<'py, PyAny>> {
let pickle = py.import("pickle")?;
let base64 = py.import("base64")?;
let raw = base64.call_method1("b64decode", (data,))?;
pickle.call_method1("loads", (raw,))
}
fn capture_object_state(py: Python<'_>, obj: &Bound<'_, PyDocumentObject>) -> Option<String> {
let dict = obj.getattr("__dict__").ok()?.downcast_into::<PyDict>().ok()?;
if dict.is_empty() {
return None;
}
let payload = PyDict::new(py);
let attrs = PyDict::new(py);
for (k, v) in dict.iter() {
if k.extract::<String>().map(|s| s == "Proxy").unwrap_or(false) {
continue;
}
let _ = attrs.set_item(k, v);
}
let _ = payload.set_item("attrs", &attrs);
if let Ok(Some(proxy)) = dict.get_item("Proxy") {
if !proxy.is_none() {
let info = PyDict::new(py);
let module: String = proxy
.getattr("__module__")
.and_then(|m| m.extract())
.unwrap_or_default();
let class: String = proxy
.get_type()
.name()
.and_then(|n| n.extract())
.unwrap_or_default();
let data = if proxy.hasattr("dumps").unwrap_or(false) {
proxy.call_method0("dumps")
} else {
proxy.getattr("__dict__")
}
.unwrap_or_else(|_| py.None().into_bound(py));
let _ = info.set_item("module", module);
let _ = info.set_item("class", class);
let _ = info.set_item("data", data);
let _ = payload.set_item("proxy", info);
}
}
pickle_b64(py, payload.as_any()).ok()
}
#[derive(Debug, PartialEq, Eq)]
enum ProxyRestore {
Absent,
Installed,
Failed(String),
}
fn apply_object_state(
py: Python<'_>,
obj: &Bound<'_, PyDocumentObject>,
state: &str,
) -> PyResult<ProxyRestore> {
let payload = unpickle_b64(py, state)?;
let payload = payload.downcast::<PyDict>()?;
if let Ok(Some(attrs)) = payload.get_item("attrs") {
if let Ok(attrs) = attrs.downcast_into::<PyDict>() {
let dict = obj.getattr("__dict__")?.downcast_into::<PyDict>()?;
for (k, v) in attrs.iter() {
dict.set_item(k, v)?;
}
}
}
let Some(proxy_info) = payload.get_item("proxy")? else {
return Ok(ProxyRestore::Absent);
};
let info = proxy_info.downcast_into::<PyDict>()?;
let module: String = info
.get_item("module")?
.and_then(|m| m.extract().ok())
.unwrap_or_default();
let class: String = info
.get_item("class")?
.and_then(|m| m.extract().ok())
.unwrap_or_default();
let data = info
.get_item("data")?
.unwrap_or_else(|| py.None().into_bound(py));
if module.is_empty() || class.is_empty() {
return Ok(ProxyRestore::Failed(
"the persisted proxy names no module/class".to_string(),
));
}
let sys = py.import("sys")?;
let modules = sys.getattr("modules")?.downcast_into::<PyDict>()?;
let module_obj = match modules.get_item(&module)? {
Some(m) => m,
None => py
.import("importlib")?
.call_method1("import_module", (&module,))?,
};
let cls = match module_obj.getattr(class.as_str()) {
Ok(cls) => cls,
Err(_) => {
return Ok(ProxyRestore::Failed(format!(
"the persisted proxy class '{module}.{class}' is not available"
)))
}
};
let proxy = cls.getattr("__new__")?.call1((&cls,))?;
if proxy.hasattr("loads")? {
proxy.call_method1("loads", (data,))?;
} else if let Ok(d) = data.downcast::<PyDict>() {
let pd = proxy.getattr("__dict__")?.downcast_into::<PyDict>()?;
for (k, v) in d.iter() {
pd.set_item(k, v)?;
}
}
obj.setattr("Proxy", proxy)?;
Ok(ProxyRestore::Installed)
}
fn capture_all_python_states(
py: Python<'_>,
doc_py: &Py<PyDocument>,
inner: &Arc<Mutex<CoreDocument>>,
) {
let ids = inner.lock().unwrap().object_ids();
let mut states: Vec<(ObjectId, Option<String>)> = Vec::new();
for id in ids {
let obj = get_or_create_object(py, doc_py, inner, id);
states.push((id, capture_object_state(py, obj.bind(py))));
}
let mut doc = inner.lock().unwrap();
for (id, state) in states {
if let Some(o) = doc.object_mut(id) {
o.python_state = state;
}
}
}
fn apply_all_python_states(py: Python<'_>, doc_py: &Py<PyDocument>, inner: &Arc<Mutex<CoreDocument>>) {
let states: Vec<(ObjectId, String)> = {
let doc = inner.lock().unwrap();
doc.object_ids()
.into_iter()
.filter_map(|id| {
doc.object(id)
.and_then(|o| o.python_state.clone())
.map(|s| (id, s))
})
.collect()
};
for (id, state) in states {
let obj = get_or_create_object(py, doc_py, inner, id);
let outcome = apply_object_state(py, obj.bind(py), &state);
let problem = match outcome {
Ok(ProxyRestore::Failed(reason)) => Some(reason),
Ok(_) => None,
Err(error) => Some(error.value(py).to_string()),
};
if let Some(reason) = problem {
inner.lock().unwrap().mark_invalid_with(
id,
format!("the Python proxy could not be restored: {reason}"),
);
}
}
}
fn notify_document_restored(py: Python<'_>, doc_py: &Py<PyDocument>, inner: &Arc<Mutex<CoreDocument>>) {
let ids = inner.lock().unwrap().object_ids();
for id in ids {
let obj = get_or_create_object(py, doc_py, inner, id);
let obj = obj.bind(py);
if object_proxy(obj).is_some() {
call_proxy_method(obj, "onDocumentRestored", None);
}
}
}
fn object_proxy(obj: &Bound<'_, PyDocumentObject>) -> Option<Py<PyAny>> {
let dict = obj.getattr("__dict__").ok()?.downcast_into::<PyDict>().ok()?;
match dict.get_item("Proxy") {
Ok(Some(proxy)) if !proxy.is_none() => Some(proxy.unbind()),
_ => None,
}
}
fn call_proxy_method(obj: &Bound<'_, PyDocumentObject>, method: &str, prop: Option<&str>) {
let py = obj.py();
let Some(proxy) = object_proxy(obj) else {
return;
};
let proxy = proxy.bind(py);
let Ok(method) = proxy.getattr(method) else {
return;
};
let _ = match prop {
Some(prop) => method.call1((obj, prop)),
None => method.call1((obj,)),
};
}
fn run_python_execute(
py: Python<'_>,
doc_py: &Py<PyDocument>,
inner: &Arc<Mutex<CoreDocument>>,
id: ObjectId,
) {
let obj = get_or_create_object(py, doc_py, inner, id);
let obj = obj.bind(py);
let Some(proxy) = object_proxy(obj) else {
let mut doc = inner.lock().unwrap();
doc.purge_touched(id);
doc.mark_invalid_with(id, "the feature has no Python proxy to execute");
return;
};
let result = proxy.bind(py).call_method1("execute", (obj,));
{
let mut doc = inner.lock().unwrap();
doc.purge_touched(id);
for dependent in doc.dependents(id) {
doc.enforce_recompute(dependent);
}
}
if let Err(error) = result {
let message = error.value(py).to_string();
inner
.lock()
.unwrap()
.mark_invalid_with(id, format!("proxy.execute failed: {message}"));
}
}
#[pyclass(name = "Unit", module = "ferrocad")]
#[derive(Clone, Copy)]
struct PyUnit {
inner: Unit,
}
#[pymethods]
impl PyUnit {
#[new]
fn new(symbol: &str) -> PyResult<Self> {
match Unit::parse(symbol) {
Some(u) => Ok(Self { inner: u }),
None => Err(PyValueError::new_err(format!("unknown unit '{symbol}'"))),
}
}
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
match other.extract::<PyRef<'_, PyUnit>>() {
Ok(o) => {
self.inner.sig == o.inner.sig
&& (self.inner.scale - o.inner.scale).abs() < 1e-12
}
Err(_) => false,
}
}
fn __repr__(&self) -> String {
let name = canonical_name(self.inner.sig);
if name.is_empty() {
"1".to_string()
} else {
name
}
}
}
#[pyclass(name = "Quantity", module = "ferrocad")]
#[derive(Clone)]
struct PyQuantity {
inner: Quantity,
}
#[pymethods]
impl PyQuantity {
#[new]
#[pyo3(signature = (*args))]
fn new(args: &Bound<'_, PyTuple>) -> PyResult<Self> {
let q = match args.len() {
0 => Quantity::dimensionless(0.0),
1 => {
let a = args.get_item(0)?;
if let Ok(q) = a.extract::<PyRef<'_, PyQuantity>>() {
q.inner
} else if let Ok(s) = a.extract::<String>() {
s.parse().map_err(PyValueError::new_err)?
} else if let Ok(v) = a.extract::<f64>() {
Quantity::dimensionless(v)
} else {
return Err(PyTypeError::new_err(
"Quantity() expects a string, number, or Quantity",
));
}
}
2 => {
let value: f64 = args.get_item(0)?.extract()?;
let second = args.get_item(1)?;
let u = if let Ok(unit) = second.extract::<PyRef<'_, PyUnit>>() {
unit.inner
} else if let Ok(symbol) = second.extract::<String>() {
Unit::parse(&symbol).ok_or_else(|| {
PyValueError::new_err(format!("unknown unit '{symbol}'"))
})?
} else {
return Err(PyTypeError::new_err(
"Quantity() second argument must be a unit string or a Unit",
));
};
Quantity::new(value, u)
}
_ => {
return Err(PyTypeError::new_err(
"Quantity() takes 0, 1, or 2 arguments",
))
}
};
Ok(Self { inner: q })
}
#[getter]
fn Value(&self) -> f64 {
self.inner.value()
}
#[getter]
fn UserString(&self) -> String {
self.inner.user_string()
}
#[getter]
fn Unit(&self) -> PyUnit {
PyUnit { inner: self.inner.unit() }
}
#[getter]
fn Format(&self, py: Python<'_>) -> PyObject {
pyo3::types::PyDict::new(py).into_py_any(py).unwrap()
}
#[setter]
fn set_Format(&self, _value: &Bound<'_, PyAny>) {}
fn getValueAs(&self, unit: &str) -> PyResult<PyQuantity> {
let u = parse_unit(unit)
.ok_or_else(|| PyValueError::new_err(format!("unknown unit '{unit}'")))?;
if u.sig != self.inner.sig() {
return Err(PyValueError::new_err("incompatible unit for getValueAs"));
}
Ok(PyQuantity { inner: self.inner.in_unit(u) })
}
fn toStr(&self) -> String {
self.inner.user_string()
}
fn value_mm(&self) -> f64 {
self.inner.canonical_value()
}
fn value_in(&self, unit: &str) -> PyResult<f64> {
let u = Unit::parse(unit)
.ok_or_else(|| PyValueError::new_err(format!("unknown unit '{unit}'")))?;
Ok(self.inner.value_in(u))
}
fn __add__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyQuantity> {
let o = other
.extract::<PyRef<'_, PyQuantity>>()
.map_err(|_| PyTypeError::new_err("can only add Quantity to Quantity"))?;
Ok(PyQuantity { inner: self.inner.add(&o.inner).map_err(PyValueError::new_err)? })
}
fn __sub__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyQuantity> {
let o = other
.extract::<PyRef<'_, PyQuantity>>()
.map_err(|_| PyTypeError::new_err("can only subtract Quantity from Quantity"))?;
Ok(PyQuantity { inner: self.inner.sub(&o.inner).map_err(PyValueError::new_err)? })
}
fn __mul__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyQuantity> {
let o = other
.extract::<PyRef<'_, PyQuantity>>()
.map_err(|_| PyTypeError::new_err("can only multiply Quantity by Quantity"))?;
Ok(PyQuantity { inner: self.inner.mul(&o.inner) })
}
fn __truediv__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyQuantity> {
let o = other
.extract::<PyRef<'_, PyQuantity>>()
.map_err(|_| PyTypeError::new_err("can only divide Quantity by Quantity"))?;
Ok(PyQuantity { inner: self.inner.div(&o.inner) })
}
fn __pow__(&self, e: i32, _modulo: Option<&Bound<'_, PyAny>>) -> PyQuantity {
PyQuantity { inner: self.inner.powi(e) }
}
fn __neg__(&self) -> PyQuantity {
PyQuantity { inner: self.inner.neg() }
}
fn __float__(&self) -> f64 {
self.inner.value()
}
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
match other.extract::<PyRef<'_, PyQuantity>>() {
Ok(o) => self.inner == o.inner,
Err(_) => false,
}
}
fn __repr__(&self) -> String {
self.inner.to_string()
}
}
fn property_to_py(py: Python<'_>, value: &Property) -> PyObject {
match value {
Property::String(s) => s.clone().into_py_any(py).unwrap(),
Property::Float(f) => (*f).into_py_any(py).unwrap(),
Property::Bool(b) => (*b).into_py_any(py).unwrap(),
Property::Integer(i) => (*i).into_py_any(py).unwrap(),
Property::Quantity(q) => PyQuantity { inner: *q }.into_py_any(py).unwrap(),
Property::FloatList(v) => v.clone().into_py_any(py).unwrap(),
Property::IntegerList(v) => v.clone().into_py_any(py).unwrap(),
Property::StringList(v) => v.clone().into_py_any(py).unwrap(),
Property::BoolList(v) => v.clone().into_py_any(py).unwrap(),
Property::Vector(v) => PyVector::fresh(*v).into_py_any(py).unwrap(),
Property::VectorList(v) => v
.iter()
.map(|x| PyVector::fresh(*x).into_py_any(py).unwrap())
.collect::<Vec<_>>()
.into_py_any(py)
.unwrap(),
Property::Placement(p) => PyPlacement::fresh(*p).into_py_any(py).unwrap(),
Property::PlacementList(v) => v
.iter()
.map(|x| PyPlacement::fresh(*x).into_py_any(py).unwrap())
.collect::<Vec<_>>()
.into_py_any(py)
.unwrap(),
Property::Rotation(r) => PyRotation::fresh(*r, None).into_py_any(py).unwrap(),
Property::RotationList(v) => v
.iter()
.map(|x| PyRotation::fresh(*x, None).into_py_any(py).unwrap())
.collect::<Vec<_>>()
.into_py_any(py)
.unwrap(),
Property::Matrix(m) => PyMatrix { inner: *m }.into_py_any(py).unwrap(),
Property::Link(s) => s.clone().into_py_any(py).unwrap(),
Property::LinkList(v) => v.clone().into_py_any(py).unwrap(),
Property::LinkSub(s, subs) => {
let obj = if s.is_empty() { py.None() } else { s.clone().into_py_any(py).unwrap() };
(obj, subs.clone()).into_py_any(py).unwrap()
}
Property::LinkSubList(entries) => entries
.iter()
.map(|(name, subs)| {
let subs = PyTuple::new(py, subs.iter().map(String::as_str)).unwrap();
(name.clone(), subs).into_py_any(py).unwrap()
})
.collect::<Vec<_>>()
.into_py_any(py)
.unwrap(),
Property::ColorList(v) => v
.iter()
.map(|c| (c[0], c[1], c[2], c[3]))
.collect::<Vec<_>>()
.into_py_any(py)
.unwrap(),
Property::PythonObject(s) => {
if s.is_empty() {
py.None()
} else {
unpickle_b64(py, s)
.unwrap_or_else(|_| py.None().into_bound(py))
.unbind()
}
}
Property::FileIncluded(s) => s.clone().into_py_any(py).unwrap(),
Property::IntPairList(v) => v
.iter()
.map(|p| *p)
.collect::<Vec<_>>()
.into_py_any(py)
.unwrap(),
Property::Enumeration(choices, idx) => choices
.get(*idx)
.cloned()
.unwrap_or_default()
.into_py_any(py)
.unwrap(),
Property::IntegerConstraint { value, .. } => (*value).into_py_any(py).unwrap(),
Property::FloatConstraint { value, .. } => (*value).into_py_any(py).unwrap(),
Property::Extension(value) => extension_to_py(py, value),
}
}
fn property_to_py_at(
py: Python<'_>,
p: &Property,
inner: &Arc<Mutex<CoreDocument>>,
id: ObjectId,
prop: &str,
) -> PyObject {
let version = inner.lock().unwrap().property_version(id, prop);
let expect_placement = match p {
Property::Placement(pl) => Some(*pl),
_ => None,
};
let view = |kind: ViewKind| GeometryView {
target: ViewTarget::Document {
inner: Arc::clone(inner),
id,
prop: prop.to_string(),
version,
},
expect_placement,
kind,
};
match p {
Property::Placement(pl) => PyPlacement {
inner: Arc::new(Mutex::new(*pl)),
view: Some(view(ViewKind::Placement)),
}
.into_py_any(py)
.unwrap(),
Property::Rotation(r) => PyRotation {
inner: *r,
axis_cache: None,
view: Some(view(ViewKind::Rotation)),
}
.into_py_any(py)
.unwrap(),
_ => property_to_py(py, p),
}
}
fn py_to_property(value: &Bound<'_, PyAny>) -> PyResult<Property> {
if let Ok(q) = value.downcast::<PyQuantity>() {
return Ok(Property::Quantity(q.borrow().inner));
}
if let Ok(v) = value.downcast::<PyVector>() {
return Ok(Property::Vector(v.borrow().inner));
}
if let Ok(p) = value.downcast::<PyPlacement>() {
return Ok(Property::Placement(p.borrow().get()));
}
if let Ok(r) = value.downcast::<PyRotation>() {
return Ok(Property::Rotation(r.borrow().inner));
}
if let Ok(m) = value.downcast::<PyMatrix>() {
return Ok(Property::Matrix(m.borrow().inner));
}
if let Ok(b) = value.extract::<bool>() {
return Ok(Property::Bool(b));
}
if let Ok(i) = value.extract::<i64>() {
return Ok(Property::Integer(i));
}
if let Ok(f) = value.extract::<f64>() {
return Ok(Property::Float(f));
}
if let Ok(s) = value.extract::<String>() {
return Ok(Property::String(s));
}
if let Ok(v) = value.extract::<Vec<bool>>() {
return Ok(Property::BoolList(v));
}
if let Ok(v) = value.extract::<Vec<i64>>() {
return Ok(Property::IntegerList(v));
}
if let Ok(v) = value.extract::<Vec<f64>>() {
return Ok(Property::FloatList(v));
}
if let Ok(v) = value.extract::<Vec<String>>() {
return Ok(Property::StringList(v));
}
if let Ok(v) = value.extract::<Vec<PyRef<'_, PyVector>>>() {
return Ok(Property::VectorList(v.iter().map(|x| x.inner).collect()));
}
if let Ok(v) = value.extract::<Vec<(f64, f64, f64)>>() {
return Ok(Property::VectorList(
v.iter().map(|(x, y, z)| Vector3::new(*x, *y, *z)).collect(),
));
}
if let Ok(v) = value.extract::<Vec<PyRef<'_, PyPlacement>>>() {
return Ok(Property::PlacementList(v.iter().map(|x| x.get()).collect()));
}
if let Ok(v) = value.extract::<Vec<PyRef<'_, PyRotation>>>() {
return Ok(Property::RotationList(v.iter().map(|x| x.inner).collect()));
}
if let Some(extension) = extension_from_py(value) {
return Ok(Property::Extension(extension));
}
Err(PyTypeError::new_err(
"unsupported property value (expected str, int, float, bool, list, Quantity, Vector, Placement, Rotation, or Matrix)",
))
}
fn apply_status(status: &mut u32, val: &Bound<'_, PyAny>) -> PyResult<()> {
if let Ok(i) = val.extract::<i64>() {
if i >= 0 {
*status |= i as u32;
} else {
*status &= !((-i) as u32);
}
return Ok(());
}
if let Ok(s) = val.extract::<String>() {
return apply_status_name(status, &s);
}
if let Ok(iter) = val.try_iter() {
for item in iter {
apply_status(status, &item?)?;
}
return Ok(());
}
Err(PyTypeError::new_err(
"property status must be an int, a str, or a sequence of either",
))
}
fn apply_status_name(status: &mut u32, name: &str) -> PyResult<()> {
let (clear, bare) = match name.strip_prefix('-') {
Some(rest) => (true, rest),
None => (false, name),
};
let bit = if bare.eq_ignore_ascii_case("immutable") {
Some(prop_status::READONLY)
} else {
status_from_name(bare)
};
match bit {
Some(bit) if clear => {
*status &= !bit;
Ok(())
}
Some(bit) => {
*status |= bit;
Ok(())
}
None => Err(PyValueError::new_err(format!(
"unknown property status '{name}'"
))),
}
}
fn copy_source_data(
obj: &PyRef<'_, PyDocumentObject>,
) -> PyResult<(String, String, String, Vec<(String, Property)>, Vec<(String, String)>)> {
let doc = obj.inner.lock().unwrap();
let o = doc
.object(obj.id)
.ok_or_else(|| PyValueError::new_err("source object no longer exists"))?;
Ok((
o.name.clone(),
o.label.clone(),
o.type_id.clone(),
o.properties.iter().map(|(k, v)| (k.clone(), v.clone())).collect(),
o.expressions.iter().map(|(k, v)| (k.clone(), v.clone())).collect(),
))
}
fn duplicate_labels(py: Python<'_>) -> bool {
py.import("FreeCAD")
.and_then(|m| m.call_method1("ParamGet", ("User parameter:BaseApp/Preferences/Document",)))
.and_then(|g| g.call_method1("GetBool", ("DuplicateLabels", false)))
.and_then(|v| v.extract::<bool>())
.unwrap_or(false)
}
fn is_extension_type(type_id: &str) -> bool {
type_id.ends_with("Extension") || type_id.ends_with("ExtensionPython")
}
fn create_origin_children(doc: &mut CoreDocument, origin_id: ObjectId) {
use std::f64::consts::FRAC_PI_2;
let children: [(&str, &str, Rotation); 6] = [
("X_Axis", "App::Line", Rotation::identity()),
("Y_Axis", "App::Line", Rotation::from_axis_angle(&Vector3::new(0.0, 0.0, 1.0), FRAC_PI_2)),
("Z_Axis", "App::Line", Rotation::from_axis_angle(&Vector3::new(0.0, 1.0, 0.0), -FRAC_PI_2)),
("XY_Plane", "App::Plane", Rotation::identity()),
("XZ_Plane", "App::Plane", Rotation::from_axis_angle(&Vector3::new(1.0, 0.0, 0.0), FRAC_PI_2)),
("YZ_Plane", "App::Plane", Rotation::from_axis_angle(&Vector3::new(0.0, 1.0, 0.0), FRAC_PI_2)),
];
let mut names = Vec::with_capacity(6);
for (base, ty, rot) in children {
let child_id = doc.add_object(base, ty);
let name = doc
.object(child_id)
.map(|o| o.name.clone())
.unwrap_or_else(|| base.to_string());
let _ = doc.set_property(
child_id,
"Placement",
Property::Placement(Placement::new(Vector3::zero(), rot)),
);
names.push(name);
}
let _ = doc.set_property(origin_id, "Group", Property::LinkList(names));
}
fn extract_vector(v: &Bound<'_, PyAny>) -> PyResult<Vector3> {
if let Ok(vec) = v.extract::<PyRef<'_, PyVector>>() {
return Ok(vec.inner);
}
if let Ok(seq) = v.extract::<Vec<f64>>() {
if seq.len() == 3 {
return Ok(Vector3::new(seq[0], seq[1], seq[2]));
}
}
Err(PyTypeError::new_err("expected a Vector or a 3-sequence"))
}
fn extract_rotation(v: &Bound<'_, PyAny>) -> PyResult<Rotation> {
if let Ok(r) = v.extract::<PyRef<'_, PyRotation>>() {
return Ok(r.inner);
}
if let Ok(seq) = v.extract::<Vec<f64>>() {
if seq.len() == 4 {
return Ok(Rotation { q: [seq[0], seq[1], seq[2], seq[3]], raw_axis: None });
}
}
Err(PyTypeError::new_err("expected a Rotation or a 4-sequence"))
}
fn py_to_link(value: &Bound<'_, PyAny>) -> PyResult<String> {
if value.is_none() {
return Ok(String::new());
}
if let Ok(o) = value.downcast::<PyDocumentObject>() {
return Ok(o.borrow().name_string());
}
if let Ok(s) = value.extract::<String>() {
return Ok(s);
}
Err(PyTypeError::new_err("Link expects a DocumentObject or a name"))
}
fn py_to_link_list(value: &Bound<'_, PyAny>) -> PyResult<Vec<String>> {
if value.is_none() {
return Ok(vec![]);
}
if let Ok(object) = value.downcast::<PyDocumentObject>() {
return Ok(vec![object.borrow().name_string()]);
}
if let Ok(v) = value.extract::<Vec<PyRef<'_, PyDocumentObject>>>() {
return Ok(v.iter().map(|o| o.name_string()).collect());
}
if let Ok(v) = value.extract::<Vec<String>>() {
return Ok(v);
}
Err(PyTypeError::new_err("LinkList expects a list of DocumentObjects"))
}
fn py_to_color_list(value: &Bound<'_, PyAny>) -> PyResult<Vec<[f64; 4]>> {
if value.is_none() {
return Ok(vec![]);
}
if let Ok(v) = value.extract::<Vec<(f64, f64, f64, f64)>>() {
return Ok(v.iter().map(|(r, g, b, a)| [*r, *g, *b, *a]).collect());
}
if let Ok(v) = value.extract::<Vec<(f64, f64, f64)>>() {
return Ok(v.iter().map(|(r, g, b)| [*r, *g, *b, 1.0]).collect());
}
Err(PyTypeError::new_err(
"ColorList expects a list of (r, g, b[, a]) tuples",
))
}
fn py_to_link_sub(value: &Bound<'_, PyAny>) -> PyResult<(String, Vec<String>)> {
if value.is_none() {
return Ok((String::new(), vec![]));
}
if let Ok(object) = value.downcast::<PyDocumentObject>() {
return Ok((object.borrow().name_string(), vec![]));
}
if let Ok(name) = value.extract::<String>() {
return Ok((name, vec![]));
}
let t = value
.downcast::<PyTuple>()
.map_err(|_| PyTypeError::new_err("LinkSub expects an (object, subnames) tuple"))?;
if t.len() != 2 {
return Err(PyTypeError::new_err("LinkSub expects a 2-tuple"));
}
let obj = t.get_item(0)?;
let subs = t.get_item(1)?;
let name = if obj.is_none() {
String::new()
} else if let Ok(o) = obj.downcast::<PyDocumentObject>() {
o.borrow().name_string()
} else {
return Err(PyTypeError::new_err(
"LinkSub object must be a DocumentObject or None",
));
};
let names: Vec<String> = if let Ok(s) = subs.extract::<String>() {
if s.is_empty() {
vec![]
} else {
vec![s]
}
} else if let Ok(v) = subs.extract::<Vec<String>>() {
v
} else {
return Err(PyTypeError::new_err(
"LinkSub subnames must be a string or a list of strings",
));
};
Ok((name, names))
}
fn py_to_link_sub_list(value: &Bound<'_, PyAny>) -> PyResult<Vec<(String, Vec<String>)>> {
if value.is_none() {
return Ok(vec![]);
}
if let Ok(object) = value.downcast::<PyDocumentObject>() {
return Ok(vec![(object.borrow().name_string(), vec![String::new()])]);
}
if let Ok(name) = value.extract::<String>() {
return Ok(vec![(name, vec![String::new()])]);
}
if let Ok(entry) = py_to_link_sub_list_entry(value) {
return Ok(vec![entry]);
}
let mut entries = Vec::new();
for item in value.try_iter().map_err(|_| {
PyTypeError::new_err(
"LinkSubList expects a list of DocumentObjects or (object, subnames) pairs",
)
})? {
entries.push(py_to_link_sub_list_entry(&item?)?);
}
Ok(entries)
}
fn py_to_link_sub_list_entry(value: &Bound<'_, PyAny>) -> PyResult<(String, Vec<String>)> {
if let Ok(object) = value.downcast::<PyDocumentObject>() {
return Ok((object.borrow().name_string(), vec![String::new()]));
}
if let Ok(name) = value.extract::<String>() {
return Ok((name, vec![String::new()]));
}
let t = if let Ok(t) = value.downcast::<PyTuple>() {
t.iter().collect::<Vec<_>>()
} else if let Ok(l) = value.downcast::<pyo3::types::PyList>() {
l.iter().collect::<Vec<_>>()
} else {
return Err(PyTypeError::new_err(
"LinkSubList entries must be DocumentObjects or (object, subnames)",
));
};
if t.len() != 2 {
return Err(PyTypeError::new_err(
"LinkSubList expects an (object, subnames) 2-tuple",
));
}
let obj = &t[0];
let subs = &t[1];
if !obj.is_none() && obj.downcast::<PyDocumentObject>().is_err() {
return Err(PyTypeError::new_err(
"LinkSubList object must be a DocumentObject or None",
));
}
let name = if obj.is_none() {
String::new()
} else {
obj.downcast::<PyDocumentObject>()
.expect("checked above")
.borrow()
.name_string()
};
let names: Vec<String> = if let Ok(s) = subs.extract::<String>() {
vec![s]
} else if let Ok(v) = subs.extract::<Vec<String>>() {
if v.is_empty() {
vec![String::new()]
} else {
v
}
} else {
return Err(PyTypeError::new_err(
"LinkSubList subnames must be a string or a list of strings",
));
};
Ok((name, names))
}
fn parse_int_pair(item: &Bound<'_, PyAny>) -> PyResult<(i64, i64)> {
if item.downcast::<pyo3::types::PyString>().is_ok() {
return Err(PyTypeError::new_err("expected an (int, int) pair"));
}
let items: Vec<Bound<'_, PyAny>> = item
.try_iter()
.map_err(|_| PyTypeError::new_err("expected an (int, int) pair"))?
.collect::<PyResult<Vec<_>>>()
.map_err(|_| PyTypeError::new_err("expected an (int, int) pair"))?;
if items.len() != 2 {
return Err(PyTypeError::new_err("expected an (int, int) pair"));
}
Ok((items[0].extract::<i64>()?, items[1].extract::<i64>()?))
}
fn py_to_int_pair_list(value: &Bound<'_, PyAny>) -> PyResult<Vec<(i64, i64)>> {
let mut out = Vec::new();
for item in value
.try_iter()
.map_err(|_| PyTypeError::new_err("expected a list of (int, int) pairs"))?
{
out.push(parse_int_pair(&item?)?);
}
Ok(out)
}
fn py_to_file_included(transient: &Path, value: &Bound<'_, PyAny>) -> PyResult<String> {
if value.is_none() {
return Ok(String::new());
}
if let Ok((source, name)) = value.extract::<(String, String)>() {
std::fs::create_dir_all(transient).map_err(|e| PyValueError::new_err(e.to_string()))?;
let dest = transient.join(&name);
std::fs::copy(&source, &dest).map_err(|e| PyValueError::new_err(e.to_string()))?;
return Ok(dest.to_string_lossy().to_string());
}
if let Ok(s) = value.extract::<String>() {
return Ok(s);
}
Err(PyTypeError::new_err(
"File expects a path or a (source, name) tuple",
))
}
fn set_instance_attr(
slf: &Bound<'_, PyDocumentObject>,
name: &str,
value: &Bound<'_, PyAny>,
) -> PyResult<()> {
let dict = slf.getattr("__dict__")?;
dict.downcast_into::<PyDict>()?.set_item(name, value)
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum ParentScope {
Plain,
Geo,
Any,
}
fn parent_of(slf: &Bound<'_, PyDocumentObject>, scope: ParentScope) -> Option<Py<PyDocumentObject>> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py = slf.borrow().doc.clone_ref(py);
let name = slf.borrow().name_string();
let found = {
let doc = inner.lock().unwrap();
doc.object_ids().into_iter().find(|id| {
let matches_scope = match scope {
ParentScope::Plain => doc.is_group_like(*id) && !doc.is_geo_group_like(*id),
ParentScope::Geo => doc.is_geo_group_like(*id),
ParentScope::Any => doc.is_group_like(*id),
};
matches_scope
&& matches!(doc.object(*id).and_then(|o| o.properties.get("Group")),
Some(Property::LinkList(links)) if links.contains(&name))
})
};
found.map(|id| get_or_create_object(py, &doc_py, &inner, id))
}
fn expression_references(source: &str, name: &str) -> bool {
let needle = format!("{name}.");
source.match_indices(&needle).any(|(i, _)| {
let boundary_before = source[..i]
.chars()
.next_back()
.map(|c| !(c.is_alphanumeric() || c == '_'))
.unwrap_or(true);
let after = &source[i + needle.len()..];
let has_prop = after
.chars()
.next()
.map(|c| c.is_alphanumeric() || c == '_')
.unwrap_or(false);
boundary_before && has_prop
})
}
fn valid_ident(s: &str) -> bool {
let mut chars = s.chars();
match chars.next() {
Some(c) if c.is_ascii_alphabetic() || c == '_' => {}
_ => return false,
}
chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
}
fn validate_namespace(ns: &str) -> PyResult<()> {
if ns.is_empty() || !ns.split('.').all(valid_ident) {
return Err(PyValueError::new_err(format!(
"invalid settings namespace '{ns}'"
)));
}
Ok(())
}
fn validate_key(key: &str) -> PyResult<()> {
if !valid_ident(key) {
return Err(PyValueError::new_err(format!("invalid setting key '{key}'")));
}
Ok(())
}
fn parse_bool(raw: &str) -> Option<bool> {
match raw.trim().to_ascii_lowercase().as_str() {
"true" | "1" => Some(true),
"false" | "0" => Some(false),
_ => None,
}
}
#[pyclass(name = "DocumentSettings", module = "ferrocad")]
struct PyDocumentSettings {
meta: Arc<Mutex<BTreeMap<String, String>>>,
namespace: String,
}
impl PyDocumentSettings {
fn full_key(&self, key: &str) -> String {
format!("{}.{}", self.namespace, key)
}
fn get_raw(&self, key: &str) -> Option<String> {
self.meta.lock().unwrap().get(&self.full_key(key)).cloned()
}
fn set_raw(&self, key: &str, value: String) {
self.meta.lock().unwrap().insert(self.full_key(key), value);
}
}
#[pymethods]
impl PyDocumentSettings {
#[pyo3(signature = (key, default=""))]
fn getString(&self, key: &str, default: &str) -> String {
self.get_raw(key).unwrap_or_else(|| default.to_string())
}
#[pyo3(signature = (key, default=0))]
fn getInt(&self, key: &str, default: i64) -> i64 {
self.get_raw(key)
.and_then(|v| v.trim().parse::<i64>().ok())
.unwrap_or(default)
}
#[pyo3(signature = (key, default=0.0))]
fn getFloat(&self, key: &str, default: f64) -> f64 {
self.get_raw(key)
.and_then(|v| v.trim().parse::<f64>().ok())
.unwrap_or(default)
}
fn getBool(&self, key: &str, default: &Bound<'_, PyAny>) -> PyResult<bool> {
if !default.is_instance_of::<PyBool>() {
return Err(PyTypeError::new_err("default must be a bool"));
}
let default: bool = default.extract()?;
Ok(self.get_raw(key).and_then(|v| parse_bool(&v)).unwrap_or(default))
}
fn setString(&self, key: &str, value: &str) -> PyResult<()> {
validate_key(key)?;
self.set_raw(key, value.to_string());
Ok(())
}
fn setInt(&self, key: &str, value: i64) -> PyResult<()> {
validate_key(key)?;
self.set_raw(key, value.to_string());
Ok(())
}
fn setFloat(&self, key: &str, value: f64) -> PyResult<()> {
validate_key(key)?;
self.set_raw(key, format!("{value}"));
Ok(())
}
fn setBool(&self, key: &str, value: &Bound<'_, PyAny>) -> PyResult<()> {
validate_key(key)?;
if !value.is_instance_of::<PyBool>() {
return Err(PyTypeError::new_err("value must be a bool"));
}
let value: bool = value.extract()?;
self.set_raw(key, if value { "true".into() } else { "false".into() });
Ok(())
}
fn remove(&self, key: &str) -> PyResult<()> {
validate_key(key)?;
self.meta.lock().unwrap().remove(&self.full_key(key));
Ok(())
}
fn keys(&self) -> Vec<String> {
let prefix = format!("{}.", self.namespace);
let mut out: Vec<String> = self
.meta
.lock()
.unwrap()
.keys()
.filter_map(|k| k.strip_prefix(&prefix))
.filter(|rest| !rest.contains('.'))
.map(|s| s.to_string())
.collect();
out.sort();
out
}
}
#[pyclass(name = "Document", module = "ferrocad")]
struct PyDocument {
name: String,
label: String,
file_name: Option<String>,
format: Option<DocumentFormat>,
auto_created: bool,
inner: Arc<Mutex<CoreDocument>>,
meta: Arc<Mutex<BTreeMap<String, String>>>,
comment: Mutex<String>,
}
#[pyclass(name = "DocumentObject", module = "ferrocad", dict)]
struct PyDocumentObject {
doc: Py<PyDocument>,
inner: Arc<Mutex<CoreDocument>>,
id: ObjectId,
view: Mutex<Option<Py<PyViewObject>>>,
}
impl PyDocumentObject {
fn name_string(&self) -> String {
self.inner
.lock()
.unwrap()
.object(self.id)
.map(|o| o.name.clone())
.unwrap_or_default()
}
}
impl PyDocument {
fn transient_dir(&self) -> PathBuf {
let mut dir = std::env::temp_dir();
dir.push(format!("FreeCAD_transient_{}", self.name));
dir
}
}
#[pymethods]
impl PyDocument {
#[new]
#[pyo3(signature = (name="Unnamed"))]
fn new(name: &str) -> Self {
Self {
name: name.to_string(),
label: name.to_string(),
file_name: None,
format: None,
auto_created: false,
inner: Arc::new(Mutex::new(CoreDocument::new())),
meta: Arc::new(Mutex::new(BTreeMap::new())),
comment: Mutex::new(String::new()),
}
}
#[getter]
fn Name(&self) -> String {
self.name.clone()
}
#[getter]
fn Label(&self) -> String {
self.label.clone()
}
#[setter]
fn set_Label(&mut self, label: String) {
self.label = label;
}
#[getter]
fn FileName(&self) -> String {
self.file_name.clone().unwrap_or_default()
}
#[getter]
fn Comment(&self) -> String {
self.comment.lock().unwrap().clone()
}
#[setter]
fn set_Comment(slf: &Bound<'_, Self>, value: String) {
fire_doc_str("slotBeforeChangeDocument", slf, "Comment");
*slf.borrow().comment.lock().unwrap() = value;
fire_doc_str("slotChangedDocument", slf, "Comment");
}
#[pyo3(signature = (r#type, name=None, objProxy=None, viewProxy=None, attach=false, viewType=None))]
fn addObject(
slf: Bound<'_, Self>,
r#type: &str,
name: Option<String>,
objProxy: Option<&Bound<'_, PyAny>>,
viewProxy: Option<&Bound<'_, PyAny>>,
attach: bool,
viewType: Option<String>,
) -> PyResult<Py<PyDocumentObject>> {
let _ = viewType;
if is_extension_type(r#type) {
return Err(PyTypeError::new_err(format!(
"'{0}' is not a document object type",
r#type
)));
}
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
let name = name.unwrap_or_default();
let dup = duplicate_labels(py);
let (id, tx) = {
let mut doc = inner.lock().unwrap();
let tx = doc.begin_transaction_if_pending();
let id = doc.add_object_with(&name, r#type, dup);
if r#type == "App::Origin" {
create_origin_children(&mut doc, id);
}
if ferrocad_core::object_registry::get(r#type).is_some()
|| r#type == "App::DocumentObjectGroupPython"
{
doc.touch(id, false);
}
(id, tx)
};
if let Some(tx) = tx {
fire_doc_str("slotOpenTransaction", &slf, &tx);
}
let obj = get_or_create_object(py, &doc_py, &inner, id);
if let Some(proxy) = objProxy {
if !proxy.is_none() {
obj.bind(py).setattr("Proxy", proxy)?;
}
}
if let Some(proxy) = viewProxy {
if !proxy.is_none() {
let bound = obj.bind(py);
let this = bound.borrow();
let view = view_object_for(py, &this)?;
drop(this);
view.bind(py).setattr("Proxy", proxy)?;
}
}
if attach {
if let Some(proxy) = objProxy {
if !proxy.is_none() && proxy.hasattr("attach").unwrap_or(false) {
proxy.call_method1("attach", (obj.bind(py),))?;
}
}
}
fire_obj("slotCreatedObject", obj.bind(py), None);
Ok(obj)
}
fn getObject(
slf: &Bound<'_, Self>,
key: &Bound<'_, PyAny>,
) -> PyResult<Option<Py<PyDocumentObject>>> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
let id = if let Ok(name) = key.extract::<String>() {
inner.lock().unwrap().get_by_name(&name)
} else if let Ok(id) = key.extract::<usize>() {
if inner.lock().unwrap().object(id).is_some() {
Some(id)
} else {
None
}
} else {
return Err(PyTypeError::new_err(
"getObject expects a name (str) or an object id (int)",
));
};
Ok(id.map(|id| get_or_create_object(py, &doc_py, &inner, id)))
}
#[getter]
fn Objects(slf: Bound<'_, Self>) -> Vec<Py<PyDocumentObject>> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc: Py<PyDocument> = slf.unbind();
let ids = inner.lock().unwrap().object_ids();
ids.into_iter()
.map(|id| get_or_create_object(py, &doc, &inner, id))
.collect()
}
#[getter]
fn CountObjects(&self) -> usize {
self.inner.lock().unwrap().object_ids().len()
}
fn removeObject(slf: &Bound<'_, Self>, name: &str) -> PyResult<()> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
let (found, tx) = {
let mut doc = inner.lock().unwrap();
let tx = doc.begin_transaction_if_pending();
match doc.get_by_name(name) {
Some(id) => {
doc.remove_object(id);
(Some(id), tx)
}
None => (None, tx),
}
};
let id = found.ok_or_else(|| {
PyValueError::new_err(format!(
"no object named '{name}' in document '{}'",
slf.borrow().name
))
})?;
if let Some(tx) = tx {
fire_doc_str("slotOpenTransaction", slf, &tx);
}
let obj = get_or_create_object(py, &doc_py, &inner, id);
forget_object(&doc_py, id);
fire_obj("slotDeletedObject", obj.bind(py), None);
Ok(())
}
#[pyo3(signature = (objs=None, force=false, mode=false))]
fn recompute(
slf: &Bound<'_, Self>,
objs: Option<&Bound<'_, PyAny>>,
force: bool,
mode: bool,
) -> PyResult<usize> {
let _ = (objs, force, mode);
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
let mut executed: Vec<ObjectId> = Vec::new();
let mut rounds = 0usize;
loop {
let pass = inner
.lock()
.unwrap()
.recompute()
.map_err(PyValueError::new_err)?;
for id in pass {
if !executed.contains(&id) {
executed.push(id);
}
}
let pending = inner.lock().unwrap().take_python_pending();
if pending.is_empty() {
break;
}
rounds += 1;
if rounds > 64 {
return Err(PyRuntimeError::new_err(
"recompute did not converge: Python proxies keep touching their objects",
));
}
for id in pending {
run_python_execute(py, &doc_py, &inner, id);
}
}
for id in &executed {
let obj = get_or_create_object(py, &doc_py, &inner, *id);
fire_obj("slotRecomputedObject", obj.bind(py), None);
}
fire_doc("slotRecomputedDocument", slf, None);
Ok(executed.len())
}
#[pyo3(signature = (name = ""))]
fn openTransaction(&self, name: &str) {
self.inner.lock().unwrap().open_transaction_named(name);
}
fn commitTransaction(slf: &Bound<'_, Self>) {
if slf.borrow().inner.lock().unwrap().commit_transaction() {
fire_doc("slotCommitTransaction", slf, None);
}
}
fn abortTransaction(slf: &Bound<'_, Self>) {
if slf.borrow().inner.lock().unwrap().abort_transaction() {
fire_doc("slotAbortTransaction", slf, None);
}
}
fn undo(slf: &Bound<'_, Self>) -> bool {
let did = slf.borrow().inner.lock().unwrap().undo();
if did {
fire_doc("slotUndoDocument", slf, None);
}
did
}
fn redo(slf: &Bound<'_, Self>) -> bool {
let did = slf.borrow().inner.lock().unwrap().redo();
if did {
fire_doc("slotRedoDocument", slf, None);
}
did
}
fn saveAs(slf: &Bound<'_, Self>, path: &str) -> PyResult<()> {
let format = DocumentFormat::from_path(path).map_err(|e| PyValueError::new_err(e.to_string()))?;
let py = slf.py();
let name = slf.borrow().name.clone();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
fire_doc_str("slotStartSaveDocument", slf, path);
capture_all_python_states(py, &doc_py, &inner);
let saved = inner.lock().unwrap().to_saved(&name);
doc_format::write(&saved, path, format).map_err(|e| PyValueError::new_err(e.to_string()))?;
{
let mut this = slf.borrow_mut();
this.file_name = Some(path.to_string());
this.format = Some(format);
}
fire_doc_str("slotFinishSaveDocument", slf, path);
Ok(())
}
fn save(slf: &Bound<'_, Self>) -> PyResult<()> {
let py = slf.py();
let (name, path, recorded) = {
let this = slf.borrow();
(this.name.clone(), this.file_name.clone(), this.format)
};
let path = path
.ok_or_else(|| PyValueError::new_err("document has no file name; use saveAs first"))?;
let format = match recorded {
Some(format) => format,
None => DocumentFormat::from_path(&path)
.map_err(|e| PyValueError::new_err(e.to_string()))?,
};
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
fire_doc_str("slotStartSaveDocument", slf, &path);
capture_all_python_states(py, &doc_py, &inner);
let saved = inner.lock().unwrap().to_saved(&name);
doc_format::write(&saved, &path, format).map_err(|e| PyValueError::new_err(e.to_string()))?;
slf.borrow_mut().format = Some(format);
fire_doc_str("slotFinishSaveDocument", slf, &path);
Ok(())
}
fn load(slf: &Bound<'_, Self>, path: &str) -> PyResult<()> {
let py = slf.py();
let (saved, format) =
doc_format::read(path).map_err(|e| PyValueError::new_err(e.to_string()))?;
let doc_py: Py<PyDocument> = slf.clone().unbind();
forget_document(&doc_py);
let mut this = slf.borrow_mut();
this.name = saved.name.clone();
this.label = saved.name.clone();
this.file_name = Some(path.to_string());
this.format = Some(format);
this.inner = Arc::new(Mutex::new(CoreDocument::from_saved(&saved)));
this.meta = Arc::new(Mutex::new(BTreeMap::new()));
drop(this);
let inner = Arc::clone(&slf.borrow().inner);
apply_all_python_states(py, &doc_py, &inner);
notify_document_restored(py, &doc_py, &inner);
Ok(())
}
#[pyo3(signature = (object, recursive=false, return_all=false))]
fn copyObject(
slf: &Bound<'_, Self>,
object: &Bound<'_, PyAny>,
recursive: bool,
return_all: bool,
) -> PyResult<PyObject> {
let _ = (recursive, return_all);
let py = slf.py();
let sources: Vec<(String, String, String, Vec<(String, Property)>, Vec<(String, String)>)> =
if let Ok(obj) = object.extract::<PyRef<'_, PyDocumentObject>>() {
vec![copy_source_data(&obj)?]
} else if let Ok(objs) = object.extract::<Vec<PyRef<'_, PyDocumentObject>>>() {
objs.iter().map(copy_source_data).collect::<PyResult<_>>()?
} else {
return Err(PyTypeError::new_err(
"copyObject expects a DocumentObject or a sequence of them",
));
};
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
let dup = duplicate_labels(py);
let mut copied: Vec<Py<PyDocumentObject>> = Vec::new();
{
let mut doc = inner.lock().unwrap();
for (name, label, type_id, props, exprs) in &sources {
let new_label = if dup { label.clone() } else { doc.unique_label(label) };
let id = doc.add_object_with(name, type_id, dup);
doc.set_label(id, &new_label);
for (k, v) in props {
let _ = doc.set_property(id, k, v.clone());
}
for (k, v) in exprs {
let _ = doc.set_expression(id, k, v);
}
copied.push(get_or_create_object(py, &doc_py, &inner, id));
}
}
if copied.len() == 1 {
Ok(copied.pop().unwrap().into_py_any(py).unwrap())
} else {
Ok(copied.into_py_any(py).unwrap())
}
}
#[getter]
fn UndoNames(&self) -> Vec<String> {
self.inner.lock().unwrap().undo_names()
}
#[getter]
fn RedoNames(&self) -> Vec<String> {
self.inner.lock().unwrap().redo_names()
}
#[getter]
fn UndoCount(&self) -> usize {
self.inner.lock().unwrap().undo_names().len()
}
#[getter]
fn RedoCount(&self) -> usize {
self.inner.lock().unwrap().redo_names().len()
}
fn clearUndos(&self) {
self.inner.lock().unwrap().clear_undos();
}
#[getter]
fn UndoMode(&self) -> i64 {
1
}
#[setter]
fn set_UndoMode(&self, _value: i64) {}
#[pyo3(signature = (id=0))]
fn getAvailableUndos(&self, id: usize) -> usize {
self.inner.lock().unwrap().available_undos(id)
}
#[pyo3(signature = (id=0))]
fn getAvailableRedos(&self, id: usize) -> usize {
self.inner.lock().unwrap().available_redos(id)
}
#[getter]
fn MemSize(&self) -> usize {
0
}
#[getter]
fn UndoRedoMemSize(&self) -> usize {
0
}
#[pyo3(signature = (Type="", Name="", Label=""))]
fn findObjects(
slf: &Bound<'_, Self>,
Type: &str,
Name: &str,
Label: &str,
) -> PyResult<Vec<Py<PyDocumentObject>>> {
if !Type.is_empty() && is_extension_type(Type) {
return Err(PyTypeError::new_err(format!(
"'{Type}' is not a document object type"
)));
}
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
let ids: Vec<ObjectId> = {
let doc = inner.lock().unwrap();
doc.object_ids()
.into_iter()
.filter(|id| {
doc.object(*id)
.map(|o| {
(Type.is_empty() || o.type_id == Type)
&& (Name.is_empty() || o.name == Name)
&& (Label.is_empty() || o.label == Label)
})
.unwrap_or(false)
})
.collect()
};
Ok(ids
.into_iter()
.map(|id| get_or_create_object(py, &doc_py, &inner, id))
.collect())
}
#[getter]
fn ActiveObject(slf: &Bound<'_, Self>) -> Option<Py<PyDocumentObject>> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let id = inner.lock().unwrap().active_object()?;
let doc: Py<PyDocument> = slf.clone().unbind();
Some(get_or_create_object(py, &doc, &inner, id))
}
fn setAutoCreated(&mut self, v: bool) {
self.auto_created = v;
}
fn isAutoCreated(&self) -> bool {
self.auto_created
}
fn getBookedTransactionID(&self) -> usize {
self.inner.lock().unwrap().booked_transaction_id()
}
#[getter]
fn TransientDir(&self) -> String {
self.transient_dir().to_string_lossy().to_string()
}
fn getTempFileName(&self, basename: &str) -> String {
let dir = self.transient_dir();
let _ = std::fs::create_dir_all(&dir);
dir.join(basename).to_string_lossy().to_string()
}
fn canWriteRecoverySnapshot(&self) -> bool {
!self.inner.lock().unwrap().is_in_transaction()
}
#[pyo3(signature = (Compression=0))]
fn dumpContent(slf: &Bound<'_, Self>, Compression: i64) -> PyResult<Py<PyBytes>> {
let _ = Compression;
let py = slf.py();
let name = slf.borrow().name.clone();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
capture_all_python_states(py, &doc_py, &inner);
let data = inner
.lock()
.unwrap()
.dump(&name)
.map_err(PyValueError::new_err)?;
Ok(PyBytes::new(py, &data).unbind())
}
fn restoreContent(slf: &Bound<'_, Self>, data: &Bound<'_, PyAny>) -> PyResult<()> {
let py = slf.py();
let bytes: Vec<u8> = data.extract()?;
let doc_py: Py<PyDocument> = slf.clone().unbind();
forget_document(&doc_py);
let inner = Arc::clone(&slf.borrow().inner);
inner
.lock()
.unwrap()
.restore_from_bytes(&bytes)
.map_err(PyValueError::new_err)?;
apply_all_python_states(py, &doc_py, &inner);
Ok(())
}
fn restore(slf: &Bound<'_, Self>) -> PyResult<()> {
let py = slf.py();
let path = slf
.borrow()
.file_name
.clone()
.ok_or_else(|| PyValueError::new_err("document has no file name"))?;
let saved = CoreDocument::load_from_file(&path).map_err(PyValueError::new_err)?;
let doc_py: Py<PyDocument> = slf.clone().unbind();
forget_document(&doc_py);
slf.borrow_mut().inner = Arc::new(Mutex::new(CoreDocument::from_saved(&saved)));
let inner = Arc::clone(&slf.borrow().inner);
apply_all_python_states(py, &doc_py, &inner);
notify_document_restored(py, &doc_py, &inner);
Ok(())
}
#[getter]
fn Meta(&self, py: Python<'_>) -> Py<PyDict> {
let dict = PyDict::new(py);
for (k, v) in self.meta.lock().unwrap().iter() {
let _ = dict.set_item(k, v);
}
dict.unbind()
}
#[setter]
fn set_Meta(&self, value: &Bound<'_, PyAny>) -> PyResult<()> {
let dict = value
.downcast::<PyDict>()
.map_err(|_| PyTypeError::new_err("Meta must be a dict"))?;
let mut meta = self.meta.lock().unwrap();
meta.clear();
for (k, v) in dict.iter() {
meta.insert(k.extract()?, v.extract()?);
}
Ok(())
}
fn settings(&self, namespace: &str) -> PyResult<PyDocumentSettings> {
validate_namespace(namespace)?;
Ok(PyDocumentSettings {
meta: Arc::clone(&self.meta),
namespace: namespace.to_string(),
})
}
#[getter]
fn RootObjects(slf: &Bound<'_, Self>) -> Vec<Py<PyDocumentObject>> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
let ids = inner.lock().unwrap().root_objects();
ids.into_iter()
.map(|id| get_or_create_object(py, &doc_py, &inner, id))
.collect()
}
#[getter]
fn TopologicalSortedObjects(slf: &Bound<'_, Self>) -> Vec<Py<PyDocumentObject>> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py: Py<PyDocument> = slf.clone().unbind();
let ids = inner.lock().unwrap().topological_sorted_objects();
ids.into_iter()
.map(|id| get_or_create_object(py, &doc_py, &inner, id))
.collect()
}
fn __getattr__(slf: &Bound<'_, Self>, name: &Bound<'_, PyAny>) -> PyResult<PyObject> {
let py = slf.py();
let name: String = name.extract()?;
if name.starts_with('_') {
return Err(PyAttributeError::new_err(name));
}
let inner = Arc::clone(&slf.borrow().inner);
let id = inner.lock().unwrap().get_by_name(&name).ok_or_else(|| {
PyAttributeError::new_err(format!("'Document' object has no attribute '{name}'"))
})?;
let doc: Py<PyDocument> = slf.clone().unbind();
Ok(get_or_create_object(py, &doc, &inner, id)
.into_py_any(py)
.unwrap())
}
}
fn is_link_type(type_id: &str) -> bool {
type_id.starts_with("App::Link") || type_id.starts_with("Part::LinkArray")
}
fn linked_object_id(doc: &CoreDocument, id: ObjectId) -> Option<ObjectId> {
let name = match doc.object(id)?.properties.get("LinkedObject")? {
Property::Link(name) | Property::LinkSub(name, _) => name,
_ => return None,
};
if name.is_empty() {
return None;
}
doc.get_by_name(name)
}
fn element_index(name: &str) -> i64 {
let trimmed = name.trim().trim_end_matches('.');
let segment = trimmed.rsplit('.').next().unwrap_or(trimmed);
let digits = segment
.strip_prefix("Element")
.or_else(|| {
segment
.rsplit("_Element")
.next()
.filter(|suffix| *suffix != segment)
})
.unwrap_or(segment);
if !digits.is_empty() && digits.bytes().all(|byte| byte.is_ascii_digit()) {
digits.parse().unwrap_or(-1)
} else {
-1
}
}
fn is_link_group_type(type_id: &str) -> bool {
matches!(type_id, "App::LinkGroup" | "App::LinkList")
}
fn element_child(doc: &CoreDocument, id: ObjectId, segment: &str) -> Option<ObjectId> {
let object = doc.object(id)?;
let names = match object.properties.get("ElementList") {
Some(Property::LinkList(names)) => names,
_ => return None,
};
if names.iter().any(|name| name == segment) {
return doc.get_by_name(segment);
}
let index = element_index(segment);
if index < 0 {
return None;
}
let position = if is_link_group_type(&object.type_id) {
usize::try_from(index.checked_sub(1)?).ok()?
} else {
index as usize
};
doc.get_by_name(names.get(position)?)
}
fn has_elements(doc: &CoreDocument, id: ObjectId) -> bool {
matches!(
doc.object(id).and_then(|object| object.properties.get("ElementList")),
Some(Property::LinkList(names)) if !names.is_empty()
)
}
fn named_child(doc: &CoreDocument, id: ObjectId, segment: &str) -> Option<ObjectId> {
let members = match doc.object(id)?.properties.get("Group") {
Some(Property::LinkList(members)) => members,
_ => return None,
};
if !members.iter().any(|name| name == segment) {
return None;
}
doc.get_by_name(segment)
}
fn placement_of(doc: &CoreDocument, id: ObjectId) -> Placement {
doc.object(id)
.and_then(|object| object.properties.get("Placement"))
.and_then(|property| match property {
Property::Placement(placement) => Some(*placement),
_ => None,
})
.unwrap_or_else(Placement::identity)
}
#[derive(Clone)]
struct ResolvedSub {
id: ObjectId,
element: Option<String>,
}
fn resolve_sub_name(doc: &CoreDocument, start: ObjectId, subname: &str) -> Option<ResolvedSub> {
let normalised = subname.trim().trim_matches('.');
if normalised.is_empty() {
return Some(ResolvedSub {
id: start,
element: None,
});
}
if let Some(id) = doc.get_by_name(normalised) {
return Some(ResolvedSub {
id,
element: None,
});
}
let mut segments: Vec<&str> = normalised.split('.').filter(|s| !s.is_empty()).collect();
if let Some(first) = segments.first().copied() {
let own = doc.object(start).map(|object| object.name.as_str()).unwrap_or("");
if first == own {
segments.remove(0);
}
}
resolve_segments(doc, start, &segments, 0)
}
fn resolve_segments(
doc: &CoreDocument,
current: ObjectId,
segments: &[&str],
depth: usize,
) -> Option<ResolvedSub> {
if segments.is_empty() {
return Some(ResolvedSub {
id: current,
element: None,
});
}
if depth > 32 {
return None;
}
let segment = segments[0];
let rest = &segments[1..];
if let Some(child) = element_child(doc, current, segment) {
if let Some(found) = resolve_segments(doc, child, rest, depth + 1) {
return Some(found);
}
}
if let Some(child) = named_child(doc, current, segment) {
if let Some(found) = resolve_segments(doc, child, rest, depth + 1) {
return Some(found);
}
}
if element_index(segment) >= 0 && has_elements(doc, current) {
return None;
}
if let Some(target) = linked_object_id(doc, current) {
if let Some(found) = resolve_segments(doc, target, segments, depth + 1) {
return Some(found);
}
}
if accepts_sub_element(doc, current, segment) {
return Some(ResolvedSub {
id: current,
element: Some(segments.join(".")),
});
}
None
}
fn accepts_sub_element(doc: &CoreDocument, current: ObjectId, segment: &str) -> bool {
match doc
.object(current)
.and_then(|object| object.properties.get("Shape"))
{
Some(Property::Extension(value)) => value.data().resolve_element_name(segment).is_ok(),
Some(_) => true,
None => false,
}
}
#[pymethods]
impl PyDocumentObject {
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
match other.extract::<PyRef<'_, PyDocumentObject>>() {
Ok(o) => self.doc.is(&o.doc) && self.id == o.id,
Err(_) => false,
}
}
fn __hash__(&self) -> u64 {
self.id as u64
}
#[getter]
fn ID(&self) -> u64 {
self.id as u64
}
#[getter]
fn Name(&self) -> PyResult<String> {
match self.inner.lock().unwrap().object(self.id) {
Some(o) => Ok(o.name.clone()),
None => Err(deleted_object_error("Name")),
}
}
#[getter]
fn Label(&self) -> PyResult<String> {
match self.inner.lock().unwrap().object(self.id) {
Some(o) => Ok(o.label.clone()),
None => Err(deleted_object_error("Label")),
}
}
#[getter]
fn TypeId(&self) -> PyResult<String> {
match self.inner.lock().unwrap().object(self.id) {
Some(o) => Ok(o.type_id.clone()),
None => Err(deleted_object_error("TypeId")),
}
}
fn isDerivedFrom(&self, type_id: &str) -> bool {
match self.inner.lock().unwrap().object(self.id) {
Some(o) => type_is_derived_from(&o.type_id, type_id),
None => false,
}
}
#[getter]
fn ViewObject(slf: PyRef<'_, Self>) -> PyResult<Py<PyViewObject>> {
if !object_is_attached(&slf.inner, slf.id) {
return Err(deleted_object_error("ViewObject"));
}
view_object_for(slf.py(), &slf)
}
#[getter]
fn MustExecute(&self) -> bool {
self.inner
.lock()
.unwrap()
.object(self.id)
.map(|o| o.must_execute)
.unwrap_or(false)
}
#[getter]
fn State(&self) -> Vec<String> {
let doc = self.inner.lock().unwrap();
match doc.object(self.id) {
Some(o) if o.invalid => vec!["Invalid".to_string(), "Touched".to_string()],
Some(o) if o.must_execute => vec!["Touched".to_string()],
_ => vec!["Up-to-date".to_string()],
}
}
#[getter]
fn Document(&self, py: Python<'_>) -> Py<PyDocument> {
self.doc.clone_ref(py)
}
#[getter]
fn PropertiesList(&self) -> Vec<String> {
self.inner
.lock()
.unwrap()
.object(self.id)
.map(|o| o.properties.names().cloned().collect())
.unwrap_or_default()
}
fn getPropertyByName(&self, name: &str) -> Option<PyObject> {
let value = {
let doc = self.inner.lock().unwrap();
doc.object(self.id)
.and_then(|o| o.properties.get(name))
.cloned()
};
value.map(|p| pyo3::Python::with_gil(|py| property_to_py(py, &p)))
}
fn setPropertyByName(slf: &Bound<'_, Self>, name: &str, value: &Bound<'_, PyAny>) -> PyResult<()> {
let property = py_to_property(value)?;
let (inner, id) = {
let this = slf.borrow();
(Arc::clone(&this.inner), this.id)
};
inner
.lock()
.unwrap()
.set_property(id, name, property)
.map_err(property_change_error)?;
call_proxy_method(slf, "onChanged", Some(name));
Ok(())
}
fn getTypeIdOfProperty(&self, name: &str) -> Option<String> {
let doc = self.inner.lock().unwrap();
doc.object(self.id)
.and_then(|o| o.properties.get(name))
.map(|p| p.type_name().to_string())
}
fn getTypeOfProperty(&self, name: &str) -> PyResult<Vec<String>> {
let doc = self.inner.lock().unwrap();
match doc.object(self.id).and_then(|o| o.properties.status(name)) {
Some(status) => Ok(status_names(status).into_iter().map(String::from).collect()),
None => Err(PyAttributeError::new_err(format!("no property '{name}'"))),
}
}
fn getGroupOfProperty(&self, name: &str) -> PyResult<String> {
let doc = self.inner.lock().unwrap();
match doc.object(self.id).and_then(|o| o.properties.group(name)) {
Some(group) => Ok(group.to_string()),
None => Err(PyAttributeError::new_err(format!("no property '{name}'"))),
}
}
fn getDocumentationOfProperty(&self, name: &str) -> PyResult<String> {
let doc = self.inner.lock().unwrap();
match doc.object(self.id).and_then(|o| o.properties.doc(name)) {
Some(doc) => Ok(doc.to_string()),
None => Err(PyAttributeError::new_err(format!("no property '{name}'"))),
}
}
fn getEnumerationsOfProperty(&self, name: &str) -> PyResult<Option<Vec<String>>> {
let doc = self.inner.lock().unwrap();
match doc.object(self.id).and_then(|o| o.properties.get(name)) {
Some(Property::Enumeration(choices, _)) => Ok(Some(choices.clone())),
Some(_) => Ok(None),
None => Err(PyAttributeError::new_err(format!("no property '{name}'"))),
}
}
#[pyo3(signature = (name=""))]
fn getPropertyStatus(&self, name: &str) -> PyResult<Vec<String>> {
if name.is_empty() {
return Ok([
"ReadOnly",
"Hidden",
"Transient",
"Output",
"NoRecompute",
"NoPersist",
"Input",
]
.into_iter()
.map(String::from)
.collect());
}
let doc = self.inner.lock().unwrap();
match doc.object(self.id).and_then(|o| o.properties.status(name)) {
Some(status) => Ok(status_names(status).into_iter().map(String::from).collect()),
None => Err(PyAttributeError::new_err(format!("no property '{name}'"))),
}
}
fn setPropertyStatus(&self, name: &str, val: &Bound<'_, PyAny>) -> PyResult<()> {
let current = {
let doc = self.inner.lock().unwrap();
doc.property_status(self.id, name)
.ok_or_else(|| PyAttributeError::new_err(format!("no property '{name}'")))?
};
let mut status = current;
apply_status(&mut status, val)?;
let mut doc = self.inner.lock().unwrap();
doc.set_property_status(self.id, name, status);
Ok(())
}
#[pyo3(signature = (type_id, name, group="", doc="", attr=0, read_only=false, hidden=false, locked=false, enum_vals=None))]
fn addProperty(
slf: &Bound<'_, Self>,
type_id: &str,
name: &str,
group: &str,
doc: &str,
attr: i64,
read_only: bool,
hidden: bool,
locked: bool,
enum_vals: Option<Vec<String>>,
) -> PyResult<Py<Self>> {
let _ = (group, doc, locked);
if name.is_empty() {
return Err(PyValueError::new_err("property name must not be empty"));
}
let base = ferrocad_core::property_types::default_for(type_id).ok_or_else(|| {
PyTypeError::new_err(format!("'{type_id}' is not a property type"))
})?;
let mut status = attr.max(0) as u32;
if read_only {
status |= prop_status::READONLY;
}
if hidden {
status |= prop_status::HIDDEN;
}
let (inner, id) = {
let this = slf.borrow();
(Arc::clone(&this.inner), this.id)
};
let default = match enum_vals {
Some(vals) => Property::Enumeration(vals, 0),
None => base,
};
inner
.lock()
.unwrap()
.add_property(id, name, default, status, group, doc)
.map_err(PyValueError::new_err)?;
fire_obj_str("slotAppendDynamicProperty", slf, name);
Ok(slf.clone().unbind())
}
#[pyo3(signature = (prop, source=None))]
fn setExpression(&self, prop: &str, source: Option<String>) -> PyResult<()> {
let mut doc = self.inner.lock().unwrap();
match source {
Some(src) => doc.set_expression(self.id, prop, &src).map_err(|e| {
if e.contains("creates a cyclic dependency") || e.starts_with("cyclic") {
PyRuntimeError::new_err(e)
} else {
PyValueError::new_err(e)
}
}),
None => {
doc.remove_expression(self.id, prop);
Ok(())
}
}
}
#[getter]
fn ExpressionEngine(&self) -> Vec<(String, Option<String>)> {
self.inner
.lock()
.unwrap()
.expressions(self.id)
.into_iter()
.map(|(k, v)| (k, Some(v)))
.collect()
}
fn evalExpression(&self, source: &str) -> PyResult<f64> {
self.inner
.lock()
.unwrap()
.eval_expression(self.id, source)
.map_err(PyValueError::new_err)
}
#[pyo3(signature = (prop=None))]
fn touch(&self, prop: Option<&str>) {
let mut doc = self.inner.lock().unwrap();
match prop {
Some("") => doc.touch(self.id, true),
_ => doc.touch(self.id, false),
}
}
fn recompute(slf: &Bound<'_, Self>) -> bool {
let py = slf.py();
let (inner, id, doc_py) = {
let this = slf.borrow();
(
Arc::clone(&this.inner),
this.id,
this.doc.clone_ref(py),
)
};
let executed = {
let mut doc = inner.lock().unwrap();
doc.take_must_execute_one(id);
let executed = doc.execute_object(id);
doc.purge_touched(id);
executed
};
if inner.lock().unwrap().take_python_pending_one(id) {
run_python_execute(py, &doc_py, &inner, id);
}
if executed {
fire_obj("slotRecomputedObject", slf, None);
}
!inner
.lock()
.unwrap()
.object(id)
.is_some_and(|object| object.invalid)
}
fn enforceRecompute(&self) {
self.inner.lock().unwrap().enforce_recompute(self.id);
}
fn purgeTouched(&self) {
self.inner.lock().unwrap().purge_touched(self.id);
}
fn getStatusString(&self) -> String {
let doc = self.inner.lock().unwrap();
match doc.object(self.id) {
Some(o) if o.invalid => match o.error.as_deref() {
Some(message) if !message.is_empty() => format!("Invalid: {message}"),
_ => "Invalid".to_string(),
},
Some(o) if o.must_execute => "Touched".to_string(),
_ => "Valid".to_string(),
}
}
fn setEditorMode(slf: &Bound<'_, Self>, prop: &str, _modes: &Bound<'_, PyAny>) {
fire_obj_str("slotChangePropertyEditor", slf, prop);
}
fn removeProperty(slf: &Bound<'_, Self>, name: &str) -> PyResult<()> {
let (inner, id) = {
let this = slf.borrow();
(Arc::clone(&this.inner), this.id)
};
if inner.lock().unwrap().remove_property(id, name) {
fire_obj_str("slotRemoveDynamicProperty", slf, name);
Ok(())
} else {
Err(PyValueError::new_err(format!(
"no property '{name}' on object"
)))
}
}
fn dumpContent(&self, py: Python<'_>) -> PyResult<Py<PyBytes>> {
let data = self
.inner
.lock()
.unwrap()
.dump_object(self.id)
.map_err(PyValueError::new_err)?;
Ok(PyBytes::new(py, &data).unbind())
}
fn restoreContent(&self, data: &Bound<'_, PyAny>) -> PyResult<()> {
let bytes: Vec<u8> = data.extract()?;
self.inner
.lock()
.unwrap()
.restore_object(self.id, &bytes)
.map_err(PyValueError::new_err)
}
#[pyo3(signature = (name, Compression=0))]
fn dumpPropertyContent(
&self,
py: Python<'_>,
name: &str,
Compression: i64,
) -> PyResult<Py<PyBytes>> {
let _ = Compression;
let data = self
.inner
.lock()
.unwrap()
.dump_property(self.id, name)
.map_err(PyValueError::new_err)?;
Ok(PyBytes::new(py, &data).unbind())
}
fn restorePropertyContent(&self, name: &str, data: &Bound<'_, PyAny>) -> PyResult<()> {
let bytes: Vec<u8> = data.extract()?;
self.inner
.lock()
.unwrap()
.restore_property(self.id, name, &bytes)
.map_err(PyValueError::new_err)
}
fn supportedProperties(&self) -> Vec<String> {
ferrocad_core::property_types::names()
}
fn addExtension(slf: &Bound<'_, Self>, name: &str) -> PyResult<()> {
let (inner, id) = {
let this = slf.borrow();
(Arc::clone(&this.inner), this.id)
};
fire_obj_str("slotBeforeAddingDynamicExtension", slf, name);
{
let mut doc = inner.lock().unwrap();
if !doc.add_extension(id, name) {
return Err(PyValueError::new_err(format!("no object {id}")));
}
if let Some(provider) = extension_provider(name) {
let _ = provider(&mut doc, id);
}
if doc.is_group_like(id)
&& doc
.object(id)
.map(|o| o.properties.get("Group").is_none())
.unwrap_or(false)
{
let _ = doc.set_property(id, "Group", Property::LinkList(vec![]));
}
}
fire_obj_str("slotAddedDynamicExtension", slf, name);
Ok(())
}
fn hasExtension(&self, name: &str) -> bool {
self.inner.lock().unwrap().has_extension(self.id, name)
}
#[pyo3(signature = (mode))]
fn changeAttacherType(slf: &Bound<'_, Self>, mode: &Bound<'_, PyAny>) -> PyResult<PyObject> {
let args = PyTuple::new(slf.py(), [mode.clone()])?;
call_extension_method(slf, "changeAttacherType", args.as_any())
}
#[pyo3(signature = (*args, **kwargs))]
fn configLinkProperty(
slf: &Bound<'_, Self>,
args: &Bound<'_, PyTuple>,
kwargs: Option<&Bound<'_, PyDict>>,
) -> PyResult<PyObject> {
let mut items: Vec<Bound<'_, PyAny>> = args.iter().collect();
if let Some(kwargs) = kwargs {
if !kwargs.is_empty() {
items.push(kwargs.clone().into_any());
}
}
let call_args = PyTuple::new(slf.py(), items)?;
call_extension_method(slf, "configLinkProperty", call_args.as_any())
}
fn removeExtension(&self, name: &str) -> PyResult<()> {
if self.inner.lock().unwrap().remove_extension(self.id, name) {
Ok(())
} else {
Err(PyValueError::new_err(format!(
"object has no extension '{name}'"
)))
}
}
fn group_members(&self, py: Python<'_>) -> Vec<Py<PyDocumentObject>> {
let inner = Arc::clone(&self.inner);
let names: Vec<String> = {
let doc = inner.lock().unwrap();
match doc.object(self.id).and_then(|o| o.properties.get("Group")) {
Some(Property::LinkList(links)) => links.clone(),
_ => return vec![],
}
};
names
.into_iter()
.filter_map(|name| {
let id = inner.lock().unwrap().get_by_name(&name)?;
Some(get_or_create_object(py, &self.doc, &inner, id))
})
.collect()
}
fn addObject(&self, other: &Bound<'_, PyAny>) -> PyResult<()> {
let other_ref: PyRef<'_, PyDocumentObject> = other
.extract()
.map_err(|_| PyTypeError::new_err("addObject expects a DocumentObject"))?;
let other_id = other_ref.id;
let other_name = other_ref.name_string();
drop(other_ref);
let mut doc = self.inner.lock().unwrap();
let type_id = doc
.object(self.id)
.map(|o| o.type_id.clone())
.unwrap_or_default();
let link_group = is_link_group_type(&type_id);
if !doc.is_group_like(self.id) && !link_group {
return Err(PyAttributeError::new_err(format!(
"'{type_id}' is not a group; add a group extension first"
)));
}
if other_id == self.id {
return Err(PyValueError::new_err("a group cannot contain itself"));
}
doc.unlink_from_groups(other_id);
let mut links = match doc.object(self.id).and_then(|o| o.properties.get("Group")) {
Some(Property::LinkList(l)) => l.clone(),
_ => vec![],
};
if !links.contains(&other_name) {
links.push(other_name);
}
doc.set_property(self.id, "Group", Property::LinkList(links))
.map_err(PyValueError::new_err)?;
if link_group {
doc.add_dependency(self.id, other_id);
}
Ok(())
}
fn removeObject(
&self,
py: Python<'_>,
other: &Bound<'_, PyAny>,
) -> PyResult<Vec<Py<PyDocumentObject>>> {
let other_ref: PyRef<'_, PyDocumentObject> = other
.extract()
.map_err(|_| PyTypeError::new_err("removeObject expects a DocumentObject"))?;
let other_id = other_ref.id;
let other_name = other_ref.name_string();
drop(other_ref);
let mut doc = self.inner.lock().unwrap();
let type_id = doc
.object(self.id)
.map(|o| o.type_id.clone())
.unwrap_or_default();
if !doc.is_group_like(self.id) && !is_link_group_type(&type_id) {
return Err(PyAttributeError::new_err(format!(
"'{type_id}' object has no attribute 'removeObject'"
)));
}
let mut links = match doc.object(self.id).and_then(|o| o.properties.get("Group")) {
Some(Property::LinkList(links)) => links.clone(),
_ => vec![],
};
let before = links.len();
links.retain(|name| name != &other_name);
if links.len() == before {
return Ok(Vec::new());
}
doc.set_property(self.id, "Group", Property::LinkList(links))
.map_err(PyValueError::new_err)?;
drop(doc);
let doc_py = self.doc.clone_ref(py);
Ok(vec![get_or_create_object(
py,
&doc_py,
&self.inner,
other_id,
)])
}
fn hasObject(&self, other: &Bound<'_, PyAny>) -> PyResult<bool> {
let other_ref: PyRef<'_, PyDocumentObject> = other
.extract()
.map_err(|_| PyTypeError::new_err("hasObject expects a DocumentObject"))?;
let name = other_ref.name_string();
drop(other_ref);
let doc = self.inner.lock().unwrap();
Ok(match doc.object(self.id).and_then(|o| o.properties.get("Group")) {
Some(Property::LinkList(links)) => links.contains(&name),
_ => false,
})
}
fn getObject(slf: &Bound<'_, Self>, name: &str) -> Option<Py<PyDocumentObject>> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py = slf.borrow().doc.clone_ref(py);
let in_group = {
let doc = inner.lock().unwrap();
match doc.object(slf.borrow().id).and_then(|o| o.properties.get("Group")) {
Some(Property::LinkList(links)) => links.iter().any(|n| n == name),
_ => false,
}
};
if !in_group {
return None;
}
let id = inner.lock().unwrap().get_by_name(name)?;
Some(get_or_create_object(py, &doc_py, &inner, id))
}
fn getParentGroup(slf: &Bound<'_, Self>) -> Option<Py<PyDocumentObject>> {
parent_of(slf, ParentScope::Plain)
}
fn getParentGeoFeatureGroup(slf: &Bound<'_, Self>) -> Option<Py<PyDocumentObject>> {
parent_of(slf, ParentScope::Geo)
}
fn getParent(slf: &Bound<'_, Self>) -> Option<Py<PyDocumentObject>> {
parent_of(slf, ParentScope::Any)
}
#[pyo3(signature = (value, subname=None))]
fn setLink(
slf: &Bound<'_, Self>,
value: &Bound<'_, PyAny>,
subname: Option<&Bound<'_, PyAny>>,
) -> PyResult<()> {
let (inner, id, type_id) = {
let this = slf.borrow();
(Arc::clone(&this.inner), this.id, {
let doc = this.inner.lock().unwrap();
doc.object(this.id)
.map(|object| object.type_id.clone())
.unwrap_or_default()
})
};
if !is_link_type(&type_id) {
return Err(PyAttributeError::new_err(format!(
"'{type_id}' object has no attribute 'setLink'"
)));
}
let name = if value.is_none() {
String::new()
} else if let Ok(object) = value.extract::<PyRef<'_, PyDocumentObject>>() {
object.name_string()
} else if let Ok(name) = value.extract::<String>() {
name
} else {
return Err(PyTypeError::new_err(
"setLink expects a DocumentObject, a name, or None",
));
};
let property = match subname {
Some(sub) if !sub.is_none() => {
let subs: Vec<String> = if let Ok(list) = sub.extract::<Vec<String>>() {
list
} else if let Ok(one) = sub.extract::<String>() {
vec![one]
} else {
return Err(PyTypeError::new_err(
"setLink's subname must be a string or a list of strings",
));
};
Property::LinkSub(name, subs)
}
_ => Property::Link(name),
};
inner
.lock()
.unwrap()
.set_property(id, "LinkedObject", property)
.map_err(PyValueError::new_err)
}
fn isLink(&self) -> bool {
self.inner
.lock()
.unwrap()
.object(self.id)
.map(|object| is_link_type(&object.type_id))
.unwrap_or(false)
}
#[pyo3(signature = (resolve=true))]
fn getLinkedObject(slf: &Bound<'_, Self>, resolve: bool) -> Option<Py<PyDocumentObject>> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py = slf.borrow().doc.clone_ref(py);
let start = slf.borrow().id;
let doc = inner.lock().unwrap();
let is_link = |id: ObjectId| {
doc.object(id)
.map(|object| is_link_type(&object.type_id))
.unwrap_or(false)
};
if !is_link(start) {
return Some(get_or_create_object(py, &doc_py, &inner, start));
}
let mut current = start;
for _ in 0..64 {
let next = linked_object_id(&doc, current)?;
if !resolve {
return Some(get_or_create_object(py, &doc_py, &inner, next));
}
if !is_link(next) {
return Some(get_or_create_object(py, &doc_py, &inner, next));
}
current = next;
}
None
}
#[staticmethod]
fn getElementIndex(name: &str) -> i64 {
element_index(name)
}
#[getter]
fn OutList(slf: &Bound<'_, Self>) -> Vec<Py<PyDocumentObject>> {
let py = slf.py();
slf.borrow().group_members(py)
}
#[getter]
fn InList(slf: &Bound<'_, Self>) -> Vec<Py<PyDocumentObject>> {
let py = slf.py();
let inner = Arc::clone(&slf.borrow().inner);
let doc_py = slf.borrow().doc.clone_ref(py);
let self_id = slf.borrow().id;
let name = slf.borrow().name_string();
let ids: Vec<ObjectId> = {
let doc = inner.lock().unwrap();
doc.object_ids()
.into_iter()
.filter(|id| {
if *id == self_id {
return false;
}
doc.object(*id)
.map(|o| {
let linked = o.properties.iter().any(|(_, p)| match p {
Property::Link(n) => n == &name,
Property::LinkList(ns) => ns.contains(&name),
Property::LinkSub(obj, _) => obj == &name,
Property::LinkSubList(entries) => {
entries.iter().any(|(obj, _)| obj == &name)
}
_ => false,
});
linked
|| o.expressions
.values()
.any(|src| expression_references(src, &name))
})
.unwrap_or(false)
})
.collect()
};
ids.into_iter()
.map(|id| get_or_create_object(py, &doc_py, &inner, id))
.collect()
}
#[pyo3(signature = (subname, retType=0, matrix=None, transform=true, depth=0))]
fn getSubObject(
slf: &Bound<'_, Self>,
subname: &Bound<'_, PyAny>,
retType: i64,
matrix: Option<&Bound<'_, PyAny>>,
transform: bool,
depth: i64,
) -> PyResult<PyObject> {
let _ = (matrix, transform, depth);
let py = slf.py();
let subs: Vec<String> = if let Ok(s) = subname.extract::<String>() {
vec![s]
} else if let Ok(seq) = subname.extract::<Vec<String>>() {
seq
} else {
return Err(PyTypeError::new_err(
"subname must be a string or a sequence of strings",
));
};
let inner = Arc::clone(&slf.borrow().inner);
let doc_py = slf.borrow().doc.clone_ref(py);
let self_id = slf.borrow().id;
struct Entry {
sub: Option<ResolvedSub>,
placement: Placement,
element_value: Option<ExtensionValue>,
}
let resolved: Vec<Entry> = {
let doc = inner.lock().unwrap();
subs.iter()
.map(|sub| match resolve_sub_name(&doc, self_id, sub) {
Some(sub) => {
let placement = placement_of(&doc, sub.id);
let element_value = sub.element.as_ref().and_then(|_| {
match doc
.object(sub.id)
.and_then(|object| object.properties.get("Shape"))
{
Some(Property::Extension(value)) => Some(value.clone()),
_ => None,
}
});
Entry {
sub: Some(sub),
placement,
element_value,
}
}
None => Entry {
sub: None,
placement: Placement::identity(),
element_value: None,
},
})
.collect()
};
let build = |entry: &Entry| -> PyObject {
let obj_py = entry
.sub
.as_ref()
.map(|sub| {
get_or_create_object(py, &doc_py, &inner, sub.id)
.into_py_any(py)
.unwrap()
})
.unwrap_or_else(|| py.None());
match retType {
0 => {
if let (Some(sub), Some(value)) = (&entry.sub, &entry.element_value) {
if let Some(element) = sub.element.as_deref() {
if let Some(element) = sub_element_to_py(py, value, element) {
return element;
}
}
}
obj_py
}
1 => obj_py,
2 => {
let mat_py = PyMatrix {
inner: entry.placement.to_matrix(),
}
.into_py_any(py)
.unwrap();
(obj_py, mat_py, py.None()).into_py_any(py).unwrap()
}
3 => PyPlacement::fresh(entry.placement).into_py_any(py).unwrap(),
4 => PyMatrix {
inner: entry.placement.to_matrix(),
}
.into_py_any(py)
.unwrap(),
_ => py.None(),
}
};
if resolved.len() == 1 {
Ok(build(&resolved[0]))
} else {
let items: Vec<PyObject> = resolved.iter().map(build).collect();
Ok(items.into_py_any(py).unwrap())
}
}
fn __getattr__(slf: &Bound<'_, Self>, name: &Bound<'_, PyAny>) -> PyResult<PyObject> {
let py = slf.py();
let name: String = name.extract()?;
if name.starts_with('_') {
return Err(PyAttributeError::new_err(name));
}
if !object_is_attached(&slf.borrow().inner, slf.borrow().id) {
return Err(deleted_object_error(&name));
}
if name == "Proxy" {
let type_id = {
let this = slf.borrow();
let doc = this.inner.lock().unwrap();
doc.object(this.id)
.map(|object| object.type_id.clone())
.unwrap_or_default()
};
if type_id.ends_with("Python") {
let dict = slf.getattr("__dict__")?;
let dict = dict.downcast_into::<PyDict>()?;
return Ok(match dict.get_item("Proxy")? {
Some(proxy) => proxy.unbind(),
None => py.None(),
});
}
}
if name == "Group" {
return Ok(slf.borrow().group_members(py).into_py_any(py).unwrap());
}
let (value, inner, doc_py, this_id) = {
let this = slf.borrow();
let doc = this.inner.lock().unwrap();
let value = doc.object(this.id).and_then(|o| o.properties.get(&name)).cloned();
(value, Arc::clone(&this.inner), this.doc.clone_ref(py), this.id)
};
match value {
Some(Property::Link(link)) => {
if link.is_empty() {
return Ok(py.None());
}
match inner.lock().unwrap().get_by_name(&link) {
Some(id) => Ok(get_or_create_object(py, &doc_py, &inner, id)
.into_py_any(py)
.unwrap()),
None => Ok(py.None()),
}
}
Some(Property::LinkList(links)) => {
let objs: Vec<Py<PyDocumentObject>> = links
.iter()
.filter_map(|n| {
let id = inner.lock().unwrap().get_by_name(n)?;
Some(get_or_create_object(py, &doc_py, &inner, id))
})
.collect();
Ok(objs.into_py_any(py).unwrap())
}
Some(Property::LinkSub(obj, subs)) => {
if obj.is_empty() && subs.is_empty() {
return Ok(py.None());
}
let obj_py = if obj.is_empty() {
py.None()
} else {
match inner.lock().unwrap().get_by_name(&obj) {
Some(id) => get_or_create_object(py, &doc_py, &inner, id)
.into_py_any(py)
.unwrap(),
None => py.None(),
}
};
Ok((obj_py, subs.clone()).into_py_any(py).unwrap())
}
Some(Property::LinkSubList(entries)) => {
let items: Vec<PyObject> = entries
.iter()
.map(|(name, subs)| {
let obj_py = if name.is_empty() {
py.None()
} else {
match inner.lock().unwrap().get_by_name(name) {
Some(id) => get_or_create_object(py, &doc_py, &inner, id)
.into_py_any(py)
.unwrap(),
None => py.None(),
}
};
let subs = PyTuple::new(py, subs.iter().map(String::as_str)).unwrap();
(obj_py, subs).into_py_any(py).unwrap()
})
.collect();
Ok(items.into_py_any(py).unwrap())
}
Some(p) => Ok(property_to_py_at(py, &p, &inner, this_id, &name)),
None => {
if extension_method_for(&inner.lock().unwrap(), this_id, &name).is_some() {
let method_inner = Arc::clone(&inner);
let method_name = name.clone();
let function = pyo3::types::PyCFunction::new_closure(
py,
None,
None,
move |args: &Bound<'_, PyTuple>,
kwargs: Option<&Bound<'_, PyDict>>| {
let mut items: Vec<Bound<'_, PyAny>> = args.iter().collect();
if let Some(kwargs) = kwargs {
if !kwargs.is_empty() {
items.push(kwargs.clone().into_any());
}
}
let call = PyTuple::new(args.py(), items)?;
let mut doc = method_inner.lock().unwrap();
let (_, f) = extension_method_for(&doc, this_id, &method_name)
.ok_or_else(|| {
PyAttributeError::new_err(format!(
"object has no attribute '{method_name}'"
))
})?;
f(&mut doc, this_id, &method_name, call.as_any())
},
)?;
return Ok(function.into_any().unbind());
}
if VIEW_PROPERTIES.contains(&name.as_str()) {
let view = {
let this = slf.borrow();
view_object_for(py, &this)
};
if let Ok(view) = view {
return Ok(view.bind(py).getattr(name.as_str())?.unbind());
}
}
let type_id = {
let this = slf.borrow();
let doc = this.inner.lock().unwrap();
doc.object(this.id).map(|o| o.type_id.clone()).unwrap_or_default()
};
Err(PyAttributeError::new_err(format!(
"'{type_id}' object has no attribute '{name}'"
)))
}
}
}
fn __setattr__(slf: &Bound<'_, Self>, name: &Bound<'_, PyAny>, value: &Bound<'_, PyAny>) -> PyResult<()> {
let name: String = name.extract()?;
if name == "Label" {
let label: String = value
.extract()
.map_err(|_| PyTypeError::new_err("Label must be a string"))?;
let (inner, id) = {
let this = slf.borrow();
(Arc::clone(&this.inner), this.id)
};
fire_obj_str("slotBeforeChangeObject", slf, "Label");
inner.lock().unwrap().set_label(id, &label);
fire_obj_str("slotChangedObject", slf, "Label");
call_proxy_method(slf, "onChanged", Some("Label"));
return Ok(());
}
if name == "Group" {
slf.borrow().set_group(value)?;
call_proxy_method(slf, "onChanged", Some("Group"));
return Ok(());
}
if name.starts_with('_') {
return set_instance_attr(slf, &name, value);
}
let existing = {
let this = slf.borrow();
let doc = this.inner.lock().unwrap();
doc.object(this.id).and_then(|o| o.properties.get(&name)).cloned()
};
let property = match existing {
Some(Property::Link(_)) => Property::Link(py_to_link(value)?),
Some(Property::LinkList(_)) => Property::LinkList(py_to_link_list(value)?),
Some(Property::LinkSub(_, _)) => {
let (obj, subs) = py_to_link_sub(value)?;
Property::LinkSub(obj, subs)
}
Some(Property::LinkSubList(_)) => {
Property::LinkSubList(py_to_link_sub_list(value)?)
}
Some(Property::StringList(_)) => match value.extract::<String>() {
Ok(s) => Property::StringList(vec![s]),
Err(_) => py_to_property(value)?,
},
Some(Property::ColorList(_)) => Property::ColorList(py_to_color_list(value)?),
Some(Property::PythonObject(_)) => Property::PythonObject(pickle_b64(slf.py(), value)?),
Some(Property::FileIncluded(_)) => {
let doc = slf.borrow().doc.clone_ref(slf.py());
let transient = doc.bind(slf.py()).borrow().transient_dir();
Property::FileIncluded(py_to_file_included(&transient, value)?)
}
Some(Property::IntPairList(existing)) => {
if let Ok(dict) = value.downcast::<PyDict>() {
let mut list = existing.clone();
for (k, v) in dict.iter() {
let idx: usize = k
.extract()
.map_err(|_| PyTypeError::new_err("index must be an int"))?;
if idx >= list.len() {
return Err(pyo3::exceptions::PyIndexError::new_err(
"index out of range",
));
}
list[idx] = parse_int_pair(&v)?;
}
Property::IntPairList(list)
} else {
Property::IntPairList(py_to_int_pair_list(value)?)
}
}
Some(Property::Enumeration(choices, _)) => {
if let Ok(s) = value.extract::<String>() {
match choices.iter().position(|c| c == &s) {
Some(i) => Property::Enumeration(choices, i),
None => {
return Err(PyValueError::new_err(format!(
"{s:?} is not part of the enumeration"
)))
}
}
} else if let Ok(i) = value.extract::<i64>() {
if i < 0 || i as usize >= choices.len() {
return Err(PyValueError::new_err("enumeration index out of range"));
}
Property::Enumeration(choices, i as usize)
} else if let Ok(list) = value.extract::<Vec<String>>() {
Property::Enumeration(list, 0)
} else {
return Err(PyTypeError::new_err(
"expected a list of strings, an index, or a value",
));
}
}
Some(Property::Float(_)) => match value.extract::<f64>() {
Ok(f) => Property::Float(f),
Err(_) => py_to_property(value)?,
},
Some(Property::Integer(_)) => match value.extract::<i64>() {
Ok(i) => Property::Integer(i),
Err(_) => py_to_property(value)?,
},
Some(Property::IntegerConstraint { min, max, step, .. }) => {
if let Ok((v, lo, hi, st)) = value.extract::<(i64, i64, i64, i64)>() {
Property::IntegerConstraint {
value: v.clamp(lo, hi),
min: lo,
max: hi,
step: st,
}
} else {
let v: i64 = value.extract().map_err(|_| {
PyTypeError::new_err("expected an int or an (int, min, max, step) tuple")
})?;
Property::IntegerConstraint { value: v.clamp(min, max), min, max, step }
}
}
Some(Property::FloatConstraint { min, max, step, .. }) => {
if let Ok((v, lo, hi, st)) =
value.extract::<(f64, f64, f64, f64)>()
{
Property::FloatConstraint {
value: v.clamp(lo, hi),
min: lo,
max: hi,
step: st,
}
} else {
let v: f64 = value.extract().map_err(|_| {
PyTypeError::new_err("expected a float or a (float, min, max, step) tuple")
})?;
Property::FloatConstraint { value: v.clamp(min, max), min, max, step }
}
}
Some(Property::Bool(_)) => match value.extract::<bool>() {
Ok(b) => Property::Bool(b),
Err(_) => py_to_property(value)?,
},
Some(Property::Extension(ext)) => {
match extension_from_py_for(ext.type_name(), value) {
Some(v) => Property::Extension(v),
None => py_to_property(value)?,
}
}
Some(Property::Quantity(existing)) => {
if let Ok(q) = value.extract::<PyRef<'_, PyQuantity>>() {
Property::Quantity(q.inner)
} else if let Ok(s) = value.extract::<String>() {
Property::Quantity(s.parse::<Quantity>().map_err(PyValueError::new_err)?)
} else if let Ok(f) = value.extract::<f64>() {
Property::Quantity(Quantity::new(f, existing.unit()))
} else {
py_to_property(value)?
}
}
Some(_) => py_to_property(value)?,
None if VIEW_PROPERTIES.contains(&name.as_str()) => {
let view = {
let this = slf.borrow();
view_object_for(slf.py(), &this)
}?;
view.bind(slf.py()).setattr(name.as_str(), value)?;
return Ok(());
}
None => return set_instance_attr(slf, &name, value),
};
let (inner, id) = {
let this = slf.borrow();
(Arc::clone(&this.inner), this.id)
};
fire_obj_str("slotBeforeChangeObject", slf, &name);
let result = inner.lock().unwrap().set_property(id, &name, property);
result.map_err(property_change_error)?;
fire_obj_str("slotChangedObject", slf, &name);
call_proxy_method(slf, "onChanged", Some(&name));
Ok(())
}
fn set_group(&self, value: &Bound<'_, PyAny>) -> PyResult<()> {
let names: Vec<String> = if let Ok(object) = value.downcast::<PyDocumentObject>() {
vec![object.borrow().name_string()]
} else if let Ok(objs) = value.extract::<Vec<PyRef<'_, PyDocumentObject>>>() {
objs.iter().map(|o| o.name_string()).collect()
} else if let Ok(names) = value.extract::<Vec<String>>() {
names
} else {
return Err(PyTypeError::new_err(
"Group expects a list of DocumentObject (or names)",
));
};
let mut doc = self.inner.lock().unwrap();
for n in &names {
if let Some(member) = doc.get_by_name(n) {
doc.unlink_from_groups(member);
}
}
let type_id = doc
.object(self.id)
.map(|object| object.type_id.clone())
.unwrap_or_default();
let members: Vec<ObjectId> = names
.iter()
.filter_map(|name| doc.get_by_name(name))
.collect();
doc.set_property(self.id, "Group", Property::LinkList(names))
.map_err(PyValueError::new_err)?;
if is_link_group_type(&type_id) {
for member in members {
if member != self.id {
doc.add_dependency(self.id, member);
}
}
}
Ok(())
}
}
#[pyclass(name = "StringHasher", module = "ferrocad")]
#[derive(Clone)]
struct PyStringHasher {
inner: StringHasher,
}
#[pymethods]
impl PyStringHasher {
#[new]
fn new() -> Self {
Self {
inner: StringHasher::new(),
}
}
fn getID(&self, arg: &Bound<'_, PyAny>) -> PyResult<PyStringID> {
if let Ok(s) = arg.extract::<String>() {
return Ok(PyStringID {
inner: self.inner.get_id(&s),
});
}
if let Ok(i) = arg.extract::<usize>() {
return self
.inner
.find_id(i)
.map(|id| PyStringID { inner: id })
.ok_or_else(|| PyValueError::new_err(format!("no StringID with value {i}")));
}
Err(PyValueError::new_err("getID expects a string or an integer"))
}
fn isSame(&self, other: &Bound<'_, PyAny>) -> PyResult<bool> {
match other.extract::<PyRef<'_, PyStringHasher>>() {
Ok(o) => Ok(self.inner.is_same(&o.inner)),
Err(_) => Err(PyTypeError::new_err("isSame expects a StringHasher")),
}
}
}
#[pyclass(name = "StringID", module = "ferrocad")]
#[derive(Clone)]
struct PyStringID {
inner: StringId,
}
#[pymethods]
impl PyStringID {
#[getter]
fn Value(&self) -> usize {
self.inner.value()
}
#[getter]
fn Data(&self) -> String {
self.inner.data()
}
fn isSame(&self, other: &Bound<'_, PyAny>) -> PyResult<bool> {
match other.extract::<PyRef<'_, PyStringID>>() {
Ok(o) => Ok(self.inner.is_same(&o.inner)),
Err(_) => Err(PyTypeError::new_err("isSame expects a StringID")),
}
}
fn __repr__(&self) -> String {
format!("<StringID {}>", self.inner.value())
}
}
#[derive(Clone)]
struct GeometryView {
target: ViewTarget,
expect_placement: Option<Placement>,
kind: ViewKind,
}
#[derive(Clone)]
enum ViewTarget {
Document {
inner: Arc<Mutex<CoreDocument>>,
id: ObjectId,
prop: String,
version: u64,
},
Hook(Arc<dyn Fn(Property) + Send + Sync>),
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum ViewKind {
Placement,
Rotation,
PlacementBase,
PlacementRotation,
}
impl GeometryView {
fn child(&self, kind: ViewKind) -> GeometryView {
GeometryView { kind, ..self.clone() }
}
fn write(&self, value: Property) {
let new = match self.kind {
ViewKind::Placement | ViewKind::Rotation => value,
ViewKind::PlacementBase | ViewKind::PlacementRotation => {
let Some(mut placement) = self.expect_placement else {
return;
};
match (self.kind, value) {
(ViewKind::PlacementBase, Property::Vector(v)) => placement.base = v,
(ViewKind::PlacementRotation, Property::Rotation(r)) => placement.rotation = r,
_ => return,
}
Property::Placement(placement)
}
};
match &self.target {
ViewTarget::Document { inner, id, prop, version } => {
let mut doc = inner.lock().unwrap();
if doc.property_version(*id, prop) != *version {
return;
}
let _ = doc.set_property(*id, prop, new);
}
ViewTarget::Hook(hook) => hook(new),
}
}
}
#[pyclass(name = "Vector", module = "ferrocad")]
#[derive(Clone)]
struct PyVector {
inner: Vector3,
view: Option<GeometryView>,
}
impl PyVector {
fn fresh(inner: Vector3) -> Self {
Self { inner, view: None }
}
fn write_back(&self) {
if let Some(view) = &self.view {
view.write(Property::Vector(self.inner));
}
}
}
#[pymethods]
impl PyVector {
#[new]
#[pyo3(signature = (*args))]
fn new(args: &Bound<'_, PyTuple>) -> PyResult<Self> {
let v = match args.len() {
0 => Vector3::zero(),
1 => {
let a = args.get_item(0)?;
if let Ok(v) = a.extract::<PyRef<'_, PyVector>>() {
v.inner
} else if let Ok(seq) = a.extract::<Vec<f64>>() {
if seq.len() != 3 {
return Err(PyValueError::new_err("Vector sequence must have 3 items"));
}
Vector3::new(seq[0], seq[1], seq[2])
} else {
return Err(PyTypeError::new_err(
"Vector() expects x,y,z, a Vector, or a 3-sequence",
));
}
}
_ => {
let x: f64 = args.get_item(0)?.extract()?;
let y: f64 = args.get_item(1)?.extract()?;
let z: f64 = if args.len() > 2 { args.get_item(2)?.extract()? } else { 0.0 };
Vector3::new(x, y, z)
}
};
Ok(Self::fresh(v))
}
#[getter]
fn x(&self) -> f64 { self.inner.x }
#[setter]
fn set_x(&mut self, v: f64) { self.inner.x = v; self.write_back(); }
#[getter]
fn y(&self) -> f64 { self.inner.y }
#[setter]
fn set_y(&mut self, v: f64) { self.inner.y = v; self.write_back(); }
#[getter]
fn z(&self) -> f64 { self.inner.z }
#[setter]
fn set_z(&mut self, v: f64) { self.inner.z = v; self.write_back(); }
#[getter]
fn Length(&self) -> f64 { self.inner.length() }
#[setter]
fn set_Length(&mut self, v: f64) {
self.inner = self.inner.normalize().scale(v);
self.write_back();
}
fn add(&self, o: PyRef<'_, PyVector>) -> PyVector { PyVector::fresh(self.inner.add(&o.inner)) }
fn sub(&self, o: PyRef<'_, PyVector>) -> PyVector { PyVector::fresh(self.inner.sub(&o.inner)) }
fn negative(&self) -> PyVector { PyVector::fresh(self.inner.neg()) }
fn dot(&self, o: PyRef<'_, PyVector>) -> f64 { self.inner.dot(&o.inner) }
fn cross(&self, o: PyRef<'_, PyVector>) -> PyVector { PyVector::fresh(self.inner.cross(&o.inner)) }
fn multiply(&mut self, factor: f64) -> PyVector {
self.inner = self.inner.scale(factor);
self.write_back();
PyVector::fresh(self.inner)
}
#[pyo3(signature = (x, y=None, z=None))]
fn scale(&mut self, x: f64, y: Option<f64>, z: Option<f64>) -> PyVector {
self.inner = match (y, z) {
(Some(y), Some(z)) => Vector3::new(
self.inner.x * x,
self.inner.y * y,
self.inner.z * z,
),
_ => self.inner.scale(x),
};
self.write_back();
PyVector::fresh(self.inner)
}
fn normalize(&mut self) -> PyVector {
self.inner = self.inner.normalize();
self.write_back();
PyVector::fresh(self.inner)
}
fn distanceToLine(&self, base: PyRef<'_, PyVector>, direction: PyRef<'_, PyVector>) -> f64 {
let offset = self.inner.sub(&base.inner);
let length = direction.inner.length();
if length == 0.0 {
offset.length()
} else {
offset.cross(&direction.inner).length() / length
}
}
fn projectToPlane(
&mut self,
base: PyRef<'_, PyVector>,
normal: PyRef<'_, PyVector>,
) -> PyVector {
let denominator = normal.inner.dot(&normal.inner);
if denominator != 0.0 {
let distance = self.inner.sub(&base.inner).dot(&normal.inner) / denominator;
self.inner = self.inner.sub(&normal.inner.scale(distance));
self.write_back();
}
PyVector::fresh(self.inner)
}
fn distanceToPoint(&self, o: PyRef<'_, PyVector>) -> f64 { self.inner.distance(&o.inner) }
fn getAngle(&self, o: PyRef<'_, PyVector>) -> f64 { self.inner.angle(&o.inner) }
fn isEqual(&self, o: PyRef<'_, PyVector>, tol: f64) -> bool { self.inner.is_equal(&o.inner, tol) }
fn __add__(&self, o: PyRef<'_, PyVector>) -> PyVector { PyVector::fresh(self.inner.add(&o.inner)) }
fn __sub__(&self, o: PyRef<'_, PyVector>) -> PyVector { PyVector::fresh(self.inner.sub(&o.inner)) }
fn __neg__(&self) -> PyVector { PyVector::fresh(self.inner.neg()) }
fn __mul__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyObject> {
let py = other.py();
if let Ok(f) = other.extract::<f64>() {
return Ok(PyVector::fresh(self.inner.scale(f)).into_py_any(py).unwrap());
}
if let Ok(o) = other.extract::<PyRef<'_, PyVector>>() {
return Ok(self.inner.dot(&o.inner).into_py_any(py).unwrap());
}
Err(PyTypeError::new_err("Vector can only multiply by a number or Vector"))
}
fn __rmul__(&self, f: f64) -> PyVector { PyVector::fresh(self.inner.scale(f)) }
fn __truediv__(&self, f: f64) -> PyVector { PyVector::fresh(self.inner.scale(1.0 / f)) }
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
match other.extract::<PyRef<'_, PyVector>>() {
Ok(o) => self.inner.is_equal(&o.inner, 1e-12),
Err(_) => false,
}
}
fn __len__(&self) -> usize { 3 }
fn __getitem__(&self, i: isize) -> PyResult<f64> {
let idx = if i < 0 { 3 + i } else { i };
match idx {
0 => Ok(self.inner.x),
1 => Ok(self.inner.y),
2 => Ok(self.inner.z),
_ => Err(pyo3::exceptions::PyIndexError::new_err("vector index out of range")),
}
}
fn __setitem__(&mut self, i: isize, v: f64) -> PyResult<()> {
let idx = if i < 0 { 3 + i } else { i };
match idx {
0 => self.inner.x = v,
1 => self.inner.y = v,
2 => self.inner.z = v,
_ => return Err(pyo3::exceptions::PyIndexError::new_err("vector index out of range")),
}
Ok(())
}
fn __repr__(&self) -> String {
format!("Vector ({}, {}, {})", self.inner.x, self.inner.y, self.inner.z)
}
}
fn format_matrix_value(value: f64) -> String {
if value == 0.0 {
return "0.0".to_string();
}
let magnitude = value.abs().log10().floor() as i32;
let decimals = (5 - magnitude).clamp(0, 17) as usize;
let mut text = format!("{value:.decimals$}");
if text.contains('.') {
while text.ends_with('0') {
text.pop();
}
if text.ends_with('.') {
text.push('0');
}
}
text
}
#[pyclass(name = "Matrix", module = "ferrocad")]
#[derive(Clone, Copy)]
struct PyMatrix {
inner: Matrix4,
}
fn parse_a_name(name: &str) -> Option<usize> {
let b = name.as_bytes();
if b.len() == 3 && b[0] == b'A' && (b'1'..=b'4').contains(&b[1]) && (b'1'..=b'4').contains(&b[2])
{
Some((b[1] - b'1') as usize * 4 + (b[2] - b'1') as usize)
} else {
None
}
}
fn extract_vec_args(args: &Bound<'_, PyTuple>) -> PyResult<Vector3> {
if args.len() == 1 {
if let Ok(v) = args.get_item(0)?.extract::<PyRef<'_, PyVector>>() {
return Ok(v.inner);
}
}
if args.len() == 3 {
return Ok(Vector3::new(
args.get_item(0)?.extract()?,
args.get_item(1)?.extract()?,
args.get_item(2)?.extract()?,
));
}
Err(PyTypeError::new_err("expected (x, y, z) or a Vector"))
}
#[pymethods]
impl PyMatrix {
#[new]
#[pyo3(signature = (*args))]
fn new(args: &Bound<'_, PyTuple>) -> PyResult<Self> {
let mut m = Matrix4::identity();
match args.len() {
0 => {}
4 => {
for i in 0..4 {
m.m[i] = args.get_item(i)?.extract()?;
}
}
12 => {
for i in 0..12 {
m.m[i] = args.get_item(i)?.extract()?;
}
m.m[12] = 0.0;
m.m[13] = 0.0;
m.m[14] = 0.0;
m.m[15] = 1.0;
}
16 => {
for i in 0..16 {
m.m[i] = args.get_item(i)?.extract()?;
}
}
_ => {
return Err(PyTypeError::new_err(
"Matrix() takes 0, 4, 12 or 16 arguments",
))
}
}
Ok(Self { inner: m })
}
#[getter]
fn A(&self) -> Vec<f64> {
self.inner.m.to_vec()
}
fn __getattr__(&self, name: &Bound<'_, PyAny>) -> PyResult<f64> {
let n: String = name.extract()?;
parse_a_name(&n)
.map(|i| self.inner.m[i])
.ok_or_else(|| PyAttributeError::new_err(n))
}
fn __setattr__(&mut self, name: &Bound<'_, PyAny>, value: f64) -> PyResult<()> {
let n: String = name.extract()?;
match parse_a_name(&n) {
Some(i) => {
self.inner.m[i] = value;
Ok(())
}
None => Err(PyAttributeError::new_err(n)),
}
}
fn setRow(&mut self, row: usize, v: PyRef<'_, PyVector>) -> PyResult<()> {
if row > 3 {
return Err(PyIndexError::new_err("row out of range"));
}
self.inner.set_row(row, v.inner);
Ok(())
}
fn setCol(&mut self, col: usize, v: PyRef<'_, PyVector>) -> PyResult<()> {
if col > 3 {
return Err(PyIndexError::new_err("col out of range"));
}
self.inner.set_col(col, v.inner);
Ok(())
}
fn row(&self, row: usize) -> PyResult<PyVector> {
if row > 3 {
return Err(PyIndexError::new_err("row out of range"));
}
Ok(PyVector::fresh(self.inner.row(row)))
}
fn col(&self, col: usize) -> PyResult<PyVector> {
if col > 3 {
return Err(PyIndexError::new_err("col out of range"));
}
Ok(PyVector::fresh(self.inner.col(col)))
}
fn diagonal(&self) -> PyVector {
PyVector::fresh(self.inner.diagonal())
}
#[pyo3(signature = (tol=0.0))]
fn isUnity(&self, tol: f64) -> bool {
self.inner.is_unity(tol)
}
fn isNull(&self) -> bool {
self.inner.is_null()
}
fn unity(&mut self) {
self.inner.unity();
}
fn nullify(&mut self) {
self.inner.nullify();
}
fn determinant(&self) -> f64 {
self.inner.determinant()
}
fn inverse(&self) -> PyResult<PyMatrix> {
self.inner
.inverse()
.map(|inner| PyMatrix { inner })
.ok_or_else(|| PyRuntimeError::new_err("matrix is singular"))
}
fn transpose(&self) -> PyMatrix {
PyMatrix { inner: self.inner.transpose() }
}
#[pyo3(signature = (tol=0.0))]
fn hasScale(&self, py: Python<'_>, tol: f64) -> PyResult<PyObject> {
let value = self.inner.has_scale(tol) as i32;
match py.import("FreeCAD") {
Ok(module) => Ok(module.getattr("ScaleType")?.call1((value,))?.into_py_any(py)?),
Err(_) => Ok(value.into_py_any(py)?),
}
}
fn decompose(&self) -> (PyMatrix, PyMatrix, PyMatrix, PyMatrix) {
let [shear, scale, rotation, mv] = self.inner.decompose();
(
PyMatrix { inner: shear },
PyMatrix { inner: scale },
PyMatrix { inner: rotation },
PyMatrix { inner: mv },
)
}
fn multiply(&self, o: PyRef<'_, PyMatrix>) -> PyMatrix {
PyMatrix { inner: self.inner.mul(&o.inner) }
}
fn multVec(&self, v: PyRef<'_, PyVector>) -> PyVector {
PyVector::fresh(self.inner.transform(&v.inner))
}
#[pyo3(name = "move", signature = (*args))]
fn move_(&mut self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
self.inner.pre_move(extract_vec_args(args)?);
Ok(())
}
#[pyo3(signature = (*args))]
fn scale(&mut self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
let s = if args.len() == 1 {
if let Ok(v) = args.get_item(0)?.extract::<PyRef<'_, PyVector>>() {
v.inner
} else {
let f: f64 = args.get_item(0)?.extract()?;
Vector3::new(f, f, f)
}
} else {
extract_vec_args(args)?
};
self.inner.pre_scale(s);
Ok(())
}
fn rotateX(&mut self, angle: f64) {
self.inner.pre_rotate(0, angle);
}
fn rotateY(&mut self, angle: f64) {
self.inner.pre_rotate(1, angle);
}
fn rotateZ(&mut self, angle: f64) {
self.inner.pre_rotate(2, angle);
}
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
match other.extract::<PyRef<'_, PyMatrix>>() {
Ok(o) => self
.inner
.m
.iter()
.zip(o.inner.m.iter())
.all(|(a, b)| (a - b).abs() <= f64::EPSILON),
Err(_) => false,
}
}
fn __mul__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyObject> {
let py = other.py();
if let Ok(f) = other.extract::<f64>() {
let mut m = self.inner.m;
for v in m.iter_mut() {
*v *= f;
}
return Ok(PyMatrix { inner: Matrix4 { m } }.into_py_any(py).unwrap());
}
if let Ok(o) = other.extract::<PyRef<'_, PyMatrix>>() {
return Ok(PyMatrix { inner: self.inner.mul(&o.inner) }.into_py_any(py).unwrap());
}
if let Ok(v) = other.extract::<PyRef<'_, PyVector>>() {
return Ok(PyVector::fresh(self.inner.transform(&v.inner)).into_py_any(py).unwrap());
}
if let Ok(r) = other.extract::<PyRef<'_, PyRotation>>() {
return Ok(PyMatrix { inner: self.inner.mul(&r.inner.to_matrix()) }
.into_py_any(py)
.unwrap());
}
if let Ok(p) = other.extract::<PyRef<'_, PyPlacement>>() {
return Ok(PyMatrix { inner: self.inner.mul(&p.get().to_matrix()) }
.into_py_any(py)
.unwrap());
}
Err(PyNotImplementedError::new_err(
"unsupported operand type(s) for *",
))
}
fn __add__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyMatrix> {
let o = other
.extract::<PyRef<'_, PyMatrix>>()
.map_err(|_| PyNotImplementedError::new_err("unsupported operand type(s) for +"))?;
let mut m = [0.0; 16];
for i in 0..16 {
m[i] = self.inner.m[i] + o.inner.m[i];
}
Ok(PyMatrix { inner: Matrix4 { m } })
}
fn __sub__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyMatrix> {
let o = other
.extract::<PyRef<'_, PyMatrix>>()
.map_err(|_| PyNotImplementedError::new_err("unsupported operand type(s) for -"))?;
let mut m = [0.0; 16];
for i in 0..16 {
m[i] = self.inner.m[i] - o.inner.m[i];
}
Ok(PyMatrix { inner: Matrix4 { m } })
}
fn __neg__(&self) -> PyMatrix {
let mut m = self.inner.m;
for v in m.iter_mut() {
*v = -*v;
}
PyMatrix { inner: Matrix4 { m } }
}
fn __pos__(&self) -> PyMatrix {
*self
}
fn __bool__(&self) -> bool {
true
}
fn __pow__(&self, e: &Bound<'_, PyAny>, _modulo: Option<&Bound<'_, PyAny>>) -> PyResult<PyMatrix> {
let e: i32 = e
.extract()
.map_err(|_| PyNotImplementedError::new_err("unsupported operand type(s) for **"))?;
if e == 0 {
return Ok(PyMatrix { inner: Matrix4::identity() });
}
let base = if e < 0 {
self.inner
.inverse()
.ok_or_else(|| PyRuntimeError::new_err("matrix is singular"))?
} else {
self.inner
};
let mut m = Matrix4::identity();
for _ in 0..e.abs() {
m = m.mul(&base);
}
Ok(PyMatrix { inner: m })
}
fn __truediv__(&self, _o: &Bound<'_, PyAny>) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __mod__(&self, _o: &Bound<'_, PyAny>) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __divmod__(&self, _o: &Bound<'_, PyAny>) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __float__(&self) -> PyResult<f64> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __int__(&self) -> PyResult<i64> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __or__(&self, _o: &Bound<'_, PyAny>) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __and__(&self, _o: &Bound<'_, PyAny>) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __xor__(&self, _o: &Bound<'_, PyAny>) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __lshift__(&self, _o: &Bound<'_, PyAny>) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __rshift__(&self, _o: &Bound<'_, PyAny>) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __invert__(&self) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __abs__(&self) -> PyResult<PyObject> {
Err(PyNotImplementedError::new_err("unsupported operand"))
}
fn __repr__(&self) -> String {
let values: Vec<String> = self
.inner
.m
.iter()
.map(|value| format_matrix_value(*value))
.collect();
format!("Matrix ([{}])", values.join(", "))
}
}
#[pyclass(name = "Rotation", module = "ferrocad")]
#[derive(Clone)]
struct PyRotation {
inner: Rotation,
axis_cache: Option<Vector3>,
view: Option<GeometryView>,
}
impl PyRotation {
fn fresh(inner: Rotation, axis_cache: Option<Vector3>) -> Self {
Self { inner, axis_cache, view: None }
}
fn write_back(&self) {
if let Some(view) = &self.view {
view.write(Property::Rotation(self.inner));
}
}
}
fn rotation_by_axes(
xdir: Vector3,
ydir: Vector3,
zdir: Vector3,
priority: &str,
) -> Result<Rotation, String> {
const TOL: f64 = 1e-7;
if priority.len() != 3 {
return Err("makeRotationByAxes: priorityOrder must have length 3".to_string());
}
let bytes = priority.as_bytes();
let mut order = [0usize; 3];
for (i, &c) in bytes.iter().enumerate() {
if !(b'X'..=b'Z').contains(&c) {
return Err(format!(
"makeRotationByAxes: {priority:?} must contain only uppercase X, Y, Z"
));
}
order[i] = (c - b'X') as usize;
}
if order[0] == order[1] || order[1] == order[2] || order[2] == order[0] {
return Err("makeRotationByAxes: not all axes are listed in priorityOrder".to_string());
}
let dirs = [xdir, ydir, zdir];
fn drop_priority(order: &mut [usize; 3], index: usize) {
match index {
0 => order.rotate_left(1),
1 => order.swap(1, 2),
_ => {}
}
}
let mut main = Vector3::zero();
for i in 0..3 {
main = dirs[order[0]];
if main.length() > TOL {
break;
}
drop_priority(&mut order, 0);
if i == 2 {
return Err("makeRotationByAxes: all directions are zero".to_string());
}
}
let main = main.normalize();
let mut hint = Vector3::zero();
for i in 0..2 {
hint = dirs[order[1]];
if hint.cross(&main).length() > TOL {
break;
}
drop_priority(&mut order, 1);
if i == 1 {
hint = Vector3::zero();
}
}
if hint.length() == 0.0 {
match order[0] {
0 => {
order[1] = 2;
order[2] = 1;
hint = Vector3::new(0.0, 0.0, 1.0);
if hint.cross(&main).length() <= TOL {
hint = Vector3::new(0.0, 1.0, 0.0);
order[1] = 1;
order[2] = 2;
}
}
1 => {
order[1] = 2;
order[2] = 0;
hint = if main.z > -TOL {
Vector3::new(0.0, 0.0, 1.0)
} else {
Vector3::new(0.0, 0.0, -1.0)
};
if hint.cross(&main).length() <= TOL {
hint = Vector3::new(1.0, 0.0, 0.0);
order[1] = 0;
order[2] = 2;
}
}
_ => {
order[1] = 1;
order[2] = 0;
hint = Vector3::new(0.0, 0.0, 1.0);
if hint.cross(&main).length() <= TOL {
hint = Vector3::new(1.0, 0.0, 0.0);
order[1] = 0;
order[2] = 1;
}
}
}
}
let hint = hint.normalize();
let last = main.cross(&hint).normalize();
let hint = last.cross(&main).normalize();
let mut finaldirs = [Vector3::zero(); 3];
finaldirs[order[0]] = main;
finaldirs[order[1]] = hint;
finaldirs[order[2]] = last;
if finaldirs[0].cross(&finaldirs[1]).dot(&finaldirs[2]) < 0.0 {
finaldirs[order[2]] = finaldirs[order[2]].neg();
}
let mut matrix = Matrix4::identity();
for i in 0..3 {
matrix.m[i] = finaldirs[i].x;
matrix.m[4 + i] = finaldirs[i].y;
matrix.m[8 + i] = finaldirs[i].z;
}
Ok(Rotation::from_matrix(&matrix))
}
#[pymethods]
impl PyRotation {
#[new]
#[pyo3(signature = (*args))]
fn new(args: &Bound<'_, PyTuple>) -> PyResult<Self> {
let inner = match args.len() {
0 => Rotation::identity(),
1 => {
let a = args.get_item(0)?;
if let Ok(r) = a.extract::<PyRef<'_, PyRotation>>() {
r.inner
} else if let Ok(m) = a.extract::<PyRef<'_, PyMatrix>>() {
Rotation::from_matrix(&m.inner)
} else {
return Err(PyTypeError::new_err(
"Rotation() expects a Rotation or a Matrix",
));
}
}
2 => {
let first = args.get_item(0)?;
let second = args.get_item(1)?;
if let (Ok(from), Ok(to)) = (
first.extract::<PyRef<'_, PyVector>>(),
second.extract::<PyRef<'_, PyVector>>(),
) {
Rotation::from_vectors(from.inner, to.inner)
} else {
let axis: PyRef<'_, PyVector> = first.extract()?;
let degree: f64 = second.extract()?;
Rotation::from_axis_angle(&axis.inner, degree.to_radians())
}
}
3 => {
let a = args.get_item(0)?;
let b = args.get_item(1)?;
let c = args.get_item(2)?;
if let (Ok(va), Ok(vb), Ok(vc)) = (
a.extract::<PyRef<'_, PyVector>>(),
b.extract::<PyRef<'_, PyVector>>(),
c.extract::<PyRef<'_, PyVector>>(),
) {
rotation_by_axes(va.inner, vb.inner, vc.inner, "ZXY")
.map_err(PyValueError::new_err)?
} else {
let yaw: f64 = a.extract()?;
let pitch: f64 = b.extract()?;
let roll: f64 = c.extract()?;
Rotation::from_euler_deg(yaw, pitch, roll)
}
}
4 => {
let a = args.get_item(0)?;
let b = args.get_item(1)?;
let c = args.get_item(2)?;
let d = args.get_item(3)?;
if let (Ok(va), Ok(vb), Ok(vc), Ok(priority)) = (
a.extract::<PyRef<'_, PyVector>>(),
b.extract::<PyRef<'_, PyVector>>(),
c.extract::<PyRef<'_, PyVector>>(),
d.extract::<String>(),
) {
rotation_by_axes(va.inner, vb.inner, vc.inner, &priority)
.map_err(PyValueError::new_err)?
} else {
let x: f64 = a.extract()?;
let y: f64 = b.extract()?;
let z: f64 = c.extract()?;
let w: f64 = d.extract()?;
Rotation { q: [w, x, y, z], raw_axis: None }
}
}
9 => {
let mut m = Matrix4::identity();
for row in 0..3 {
for column in 0..3 {
m.m[row * 4 + column] =
args.get_item(row * 3 + column)?.extract()?;
}
}
Rotation::from_matrix(&m)
}
16 => {
let mut m = Matrix4::identity();
for i in 0..16 {
m.m[i] = args.get_item(i)?.extract()?;
}
Rotation::from_matrix(&m)
}
_ => {
return Err(PyTypeError::new_err(
"Rotation() takes 0, 1, 2, 3, 4, 9 or 16 arguments",
))
}
};
Ok(Self::fresh(inner, None))
}
#[getter]
fn Angle(&self) -> f64 {
self.inner.angle()
}
#[getter]
fn Axis(&self) -> PyVector {
PyVector::fresh(self.axis_cache.unwrap_or_else(|| self.inner.axis()).normalize())
}
#[setter]
fn set_Angle(&mut self, angle: f64) {
let axis = self.axis_cache.unwrap_or_else(|| self.inner.axis());
self.inner = Rotation::from_axis_angle(&axis, angle);
self.inner.raw_axis = Some(axis);
self.write_back();
}
#[setter]
fn set_Axis(&mut self, v: &Bound<'_, PyAny>) -> PyResult<()> {
let axis = extract_vector(v)?;
let angle = self.inner.angle();
self.axis_cache = Some(axis);
self.inner = Rotation::from_axis_angle(&axis, angle);
self.inner.raw_axis = Some(axis);
self.write_back();
Ok(())
}
#[getter]
fn RawAxis(&self) -> PyVector {
PyVector::fresh(self.axis_cache.unwrap_or_else(|| self.inner.axis()))
}
#[getter]
fn Q(&self) -> (f64, f64, f64, f64) {
(self.inner.q[1], self.inner.q[2], self.inner.q[3], self.inner.q[0])
}
#[setter]
fn set_Q(&mut self, v: (f64, f64, f64, f64)) {
self.inner.q = [v.3, v.0, v.1, v.2];
self.inner.raw_axis = None;
self.axis_cache = None;
self.write_back();
}
#[getter]
fn Matrix(&self) -> PyMatrix {
PyMatrix { inner: self.inner.to_matrix() }
}
#[setter]
fn set_Matrix(&mut self, m: PyRef<'_, PyMatrix>) {
self.inner = Rotation::from_matrix(&m.inner);
self.axis_cache = None;
}
#[setter]
fn set_Axes(&mut self, value: &Bound<'_, PyAny>) -> PyResult<()> {
let a = value.get_item(0)?;
let b = value.get_item(1)?;
self.inner = Rotation::from_vectors(extract_vector(&a)?, extract_vector(&b)?);
self.axis_cache = None;
Ok(())
}
#[setter]
fn set_Yaw(&mut self, v: f64) {
let (_, p, r) = self.getYawPitchRoll();
self.inner = Rotation::from_euler_deg(v, p, r);
}
#[setter]
fn set_Pitch(&mut self, v: f64) {
let (y, _, r) = self.getYawPitchRoll();
self.inner = Rotation::from_euler_deg(y, v, r);
}
#[setter]
fn set_Roll(&mut self, v: f64) {
let (y, p, _) = self.getYawPitchRoll();
self.inner = Rotation::from_euler_deg(y, p, v);
}
fn toMatrix(&self) -> PyMatrix {
PyMatrix { inner: self.inner.to_matrix() }
}
fn multiply(&self, o: PyRef<'_, PyRotation>) -> PyRotation {
PyRotation::fresh(self.inner.multiply(&o.inner), None)
}
fn multVec(&self, v: PyRef<'_, PyVector>) -> PyVector {
PyVector::fresh(self.inner.to_matrix().transform(&v.inner))
}
fn __mul__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyObject> {
if let Ok(rotation) = other.extract::<PyRef<'_, PyRotation>>() {
return Ok(Py::new(other.py(), self.multiply(rotation))?.into_any());
}
if let Ok(vector) = other.extract::<PyRef<'_, PyVector>>() {
let rotated = self.inner.to_matrix().transform(&vector.inner);
return Ok(Py::new(other.py(), PyVector::fresh(rotated))?.into_any());
}
Err(PyTypeError::new_err(
"Rotation can only multiply a Rotation or a Vector",
))
}
fn invert(&mut self) {
self.inner = self.inner.inverse();
self.axis_cache = None;
}
fn inverse(&self) -> PyRotation {
PyRotation::fresh(self.inner.inverse(), None)
}
fn inverted(&self) -> PyRotation {
PyRotation::fresh(
self.inner.inverse(),
self.axis_cache.map(|axis| axis.neg()),
)
}
#[pyo3(signature = (o, tol=0.0))]
fn isSame(&self, o: PyRef<'_, PyRotation>, tol: f64) -> bool {
self.inner.is_same(&o.inner, tol)
}
fn setYawPitchRoll(&mut self, yaw: f64, pitch: f64, roll: f64) {
self.inner = Rotation::from_euler_deg(yaw, pitch, roll);
self.axis_cache = None;
}
fn getYawPitchRoll(&self) -> (f64, f64, f64) {
let (y, p, r) = self.inner.yaw_pitch_roll();
(y.to_degrees(), p.to_degrees(), r.to_degrees())
}
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
match other.extract::<PyRef<'_, PyRotation>>() {
Ok(o) => self.inner == o.inner,
Err(_) => false,
}
}
fn __repr__(&self) -> String {
format!("Rotation ({:?})", self.inner.q)
}
}
#[pyclass(name = "Placement", module = "ferrocad")]
#[derive(Clone)]
struct PyPlacement {
inner: Arc<Mutex<Placement>>,
view: Option<GeometryView>,
}
impl PyPlacement {
fn fresh(inner: Placement) -> Self {
Self {
inner: Arc::new(Mutex::new(inner)),
view: None,
}
}
fn get(&self) -> Placement {
*self.inner.lock().unwrap_or_else(|e| e.into_inner())
}
fn set(&self, value: Placement) {
*self.inner.lock().unwrap_or_else(|e| e.into_inner()) = value;
}
fn write_back(&self) {
if let Some(view) = &self.view {
view.write(Property::Placement(self.get()));
}
}
fn child_view(&self, kind: ViewKind) -> GeometryView {
match &self.view {
Some(view) => view.child(kind),
None => {
let cell = Arc::clone(&self.inner);
GeometryView {
target: ViewTarget::Hook(Arc::new(move |property| {
if let Property::Placement(placement) = property {
*cell.lock().unwrap_or_else(|e| e.into_inner()) = placement;
}
})),
expect_placement: Some(self.get()),
kind,
}
}
}
}
}
fn compose_placements(a: &Placement, b: &Placement) -> Placement {
Placement {
base: a.base.add(&a.rotation.to_matrix().transform(&b.base)),
rotation: a.rotation.multiply(&b.rotation),
}
}
pub fn placement_with_hook(
py: Python<'_>,
value: Placement,
on_change: Arc<dyn Fn(Placement) + Send + Sync>,
) -> PyResult<PyObject> {
let view = GeometryView {
target: ViewTarget::Hook(Arc::new(move |property| {
if let Property::Placement(placement) = property {
on_change(placement);
}
})),
expect_placement: Some(value),
kind: ViewKind::Placement,
};
PyPlacement {
inner: Arc::new(Mutex::new(value)),
view: Some(view),
}
.into_py_any(py)
}
#[pymethods]
impl PyPlacement {
#[new]
#[pyo3(signature = (base=None, rotation=None))]
fn new(base: Option<&Bound<'_, PyAny>>, rotation: Option<&Bound<'_, PyAny>>) -> PyResult<Self> {
if rotation.is_none() {
if let Some(b) = base {
if let Ok(m) = b.extract::<PyRef<'_, PyMatrix>>() {
return Ok(Self::fresh(Placement::new(
Vector3::new(m.inner.m[3], m.inner.m[7], m.inner.m[11]),
Rotation::from_matrix(&m.inner),
)));
}
}
}
let b = match base {
Some(v) => extract_vector(v)?,
None => Vector3::zero(),
};
let r = match rotation {
Some(q) => extract_rotation(q)?,
None => Rotation::identity(),
};
Ok(Self::fresh(Placement::new(b, r)))
}
fn inverse(&self) -> PyPlacement {
PyPlacement::fresh(self.get().inverse())
}
fn copy(&self) -> PyPlacement {
PyPlacement::fresh(self.get())
}
#[pyo3(signature = (center, axis, angle, comp = false))]
fn rotate(
&mut self,
center: &Bound<'_, PyAny>,
axis: &Bound<'_, PyAny>,
angle: f64,
comp: bool,
) -> PyResult<()> {
let center = extract_vector(center)?;
let axis = extract_vector(axis)?;
if axis.length() == 0.0 {
return Err(PyValueError::new_err("rotation axis must not be zero"));
}
let rotation = Rotation::from_axis_angle(&axis, angle.to_radians());
let about = Placement::new(center.sub(&rotation.to_matrix().transform(¢er)), rotation);
let current = self.get();
let new = if comp {
compose_placements(&about, ¤t)
} else {
compose_placements(¤t, &about)
};
self.set(new);
self.write_back();
Ok(())
}
fn toMatrix(&self) -> PyMatrix {
PyMatrix { inner: self.get().to_matrix() }
}
#[getter]
fn Matrix(&self) -> PyMatrix {
PyMatrix { inner: self.get().to_matrix() }
}
#[pyo3(signature = (*args))]
fn translate(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
let offset = match args.len() {
1 => extract_vector(&args.get_item(0)?)?,
3 => Vector3::new(
args.get_item(0)?.extract()?,
args.get_item(1)?.extract()?,
args.get_item(2)?.extract()?,
),
_ => {
return Err(PyTypeError::new_err(
"translate expects a vector or three floats",
));
}
};
let mut placement = self.get();
placement.base = placement.base.add(&offset);
self.set(placement);
self.write_back();
Ok(())
}
#[pyo3(signature = (o, tol=0.0))]
fn isSame(&self, o: PyRef<'_, PyPlacement>, tol: f64) -> bool {
self.get().is_same(&o.get(), tol)
}
#[getter]
fn Base(&self) -> PyVector {
let mut v = PyVector::fresh(self.get().base);
v.view = Some(self.child_view(ViewKind::PlacementBase));
v
}
#[setter]
fn set_Base(&self, v: &Bound<'_, PyAny>) -> PyResult<()> {
let mut placement = self.get();
placement.base = extract_vector(v)?;
self.set(placement);
self.write_back();
Ok(())
}
#[getter]
fn Rotation(&self) -> PyRotation {
let mut r = PyRotation::fresh(self.get().rotation, None);
r.view = Some(self.child_view(ViewKind::PlacementRotation));
r
}
#[setter]
fn set_Rotation(&self, q: &Bound<'_, PyAny>) -> PyResult<()> {
let mut placement = self.get();
placement.rotation = extract_rotation(q)?;
self.set(placement);
self.write_back();
Ok(())
}
fn __mul__(&self, o: PyRef<'_, PyPlacement>) -> PyPlacement {
PyPlacement::fresh(compose_placements(&self.get(), &o.get()))
}
fn multVec(&self, v: PyRef<'_, PyVector>) -> PyVector {
PyVector::fresh(self.get().to_matrix().transform(&v.inner))
}
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
match other.extract::<PyRef<'_, PyPlacement>>() {
Ok(o) => self.get() == o.get(),
Err(_) => false,
}
}
fn __repr__(&self) -> String {
let placement = self.get();
format!("Placement ({:?}, {:?})", placement.base, placement.rotation.q)
}
}
#[pyclass(name = "TypeId", module = "ferrocad")]
#[derive(Clone)]
struct PyTypeId {
inner: TypeId,
}
#[pymethods]
impl PyTypeId {
#[new]
fn new(name: &str) -> Self {
Self { inner: TypeId::from_name(name) }
}
#[classmethod]
fn fromName(_cls: &Bound<'_, PyType>, name: &str) -> PyTypeId {
PyTypeId { inner: TypeId::from_name(name) }
}
#[classmethod]
fn getAllDerivedFrom(_cls: &Bound<'_, PyType>, _parent: Option<&Bound<'_, PyAny>>) -> Vec<String> {
vec![]
}
#[getter]
fn Name(&self) -> String {
self.inner.name().to_string()
}
fn createInstance(&self) -> Option<PyObject> {
None
}
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
match other.extract::<PyRef<'_, PyTypeId>>() {
Ok(o) => self.inner == o.inner,
Err(_) => false,
}
}
fn __repr__(&self) -> String {
format!("TypeId({})", self.inner.name())
}
}
#[pyclass(name = "Vector2d", module = "ferrocad")]
#[derive(Clone, Copy)]
struct PyVector2d {
x: f64,
y: f64,
}
#[pymethods]
impl PyVector2d {
#[new]
#[pyo3(signature = (x=0.0, y=0.0))]
fn new(x: f64, y: f64) -> Self {
Self { x, y }
}
#[getter]
fn x(&self) -> f64 {
self.x
}
#[setter]
fn set_x(&mut self, v: f64) {
self.x = v;
}
#[getter]
fn y(&self) -> f64 {
self.y
}
#[setter]
fn set_y(&mut self, v: f64) {
self.y = v;
}
fn rotate(&mut self, angle: f64) {
let (s, c) = angle.sin_cos();
let (x, y) = (self.x, self.y);
self.x = x * c - y * s;
self.y = x * s + y * c;
}
fn __repr__(&self) -> String {
format!("Vector2d ({}, {})", self.x, self.y)
}
}
#[pyclass(name = "Material", module = "ferrocad")]
#[derive(Clone)]
struct PyMaterial {
diffuse: [f64; 4],
owner: Option<MaterialOwner>,
}
#[derive(Clone, Copy, Debug)]
enum MaterialSlot {
Appearance(usize),
Material,
}
#[derive(Clone)]
struct MaterialOwner {
inner: Arc<Mutex<CoreDocument>>,
id: ObjectId,
slot: MaterialSlot,
}
impl PyMaterial {
fn owned(color: [f64; 4], inner: Arc<Mutex<CoreDocument>>, id: ObjectId, slot: MaterialSlot) -> Self {
Self {
diffuse: color,
owner: Some(MaterialOwner { inner, id, slot }),
}
}
}
#[pymethods]
impl PyMaterial {
#[new]
fn new() -> Self {
Self {
diffuse: [0.8, 0.8, 0.8, 1.0],
owner: None,
}
}
#[getter]
fn DiffuseColor(&self) -> (f64, f64, f64, f64) {
(self.diffuse[0], self.diffuse[1], self.diffuse[2], self.diffuse[3])
}
#[setter]
fn set_DiffuseColor(&mut self, value: &Bound<'_, PyAny>) -> PyResult<()> {
let color = py_to_color(value)?;
self.diffuse = color;
if let Some(owner) = &self.owner {
update_view_state(&owner.inner, owner.id, |state| match owner.slot {
MaterialSlot::Appearance(index) => state.set_appearance_slot(index, color),
MaterialSlot::Material => state.material = Some(color),
});
}
Ok(())
}
fn __eq__(&self, other: &Bound<'_, PyAny>) -> bool {
match other.extract::<PyRef<'_, PyMaterial>>() {
Ok(o) => self.diffuse == o.diffuse,
Err(_) => false,
}
}
fn __ne__(&self, other: &Bound<'_, PyAny>) -> bool {
!self.__eq__(other)
}
}
const DISPLAY_MODES: &[&str] = &["Flat Lines", "Shaded", "Wireframe", "Points"];
const VIEW_PROPERTIES: &[&str] = &[
"Visibility",
"Transparency",
"ShapeColor",
"ShapeAppearance",
"ShapeMaterial",
"DiffuseColor",
"DisplayMode",
];
#[pyclass(name = "ViewObject", module = "ferrocad")]
struct PyViewObject {
doc: Py<PyDocument>,
inner: Arc<Mutex<CoreDocument>>,
id: ObjectId,
proxy: Mutex<Option<Py<PyAny>>>,
}
fn view_object_for(py: Python<'_>, obj: &PyDocumentObject) -> PyResult<Py<PyViewObject>> {
if let Some(view) = obj.view.lock().unwrap().as_ref() {
return Ok(view.clone_ref(py));
}
let view = Py::new(
py,
PyViewObject {
doc: obj.doc.clone_ref(py),
inner: Arc::clone(&obj.inner),
id: obj.id,
proxy: Mutex::new(None),
},
)?;
*obj.view.lock().unwrap() = Some(view.clone_ref(py));
Ok(view)
}
fn update_view_state(
inner: &Arc<Mutex<CoreDocument>>,
id: ObjectId,
apply: impl FnOnce(&mut ferrocad_core::ViewState),
) -> bool {
let mut doc = inner.lock().unwrap();
match doc.object_mut(id).and_then(|object| object.view.as_mut()) {
Some(state) => {
apply(state);
true
}
None => false,
}
}
fn is_origin_family(type_id: &str) -> bool {
matches!(type_id, "App::Origin" | "App::Plane" | "App::Line" | "App::Point")
}
fn view_preferences(py: Python<'_>) -> (i32, [f64; 4]) {
const DEFAULT_COLOR: u32 = 0xCCCC_E6FF;
let mut transparency = 0i32;
let mut color = ferrocad_core::color_from_packed(DEFAULT_COLOR, true);
if let Ok(freecad) = py.import("FreeCAD") {
if let Ok(group) =
freecad.call_method1("ParamGet", ("User parameter:BaseApp/Preferences/View",))
{
if let Ok(value) = group.call_method1("GetInt", ("DefaultShapeTransparency", 0)) {
transparency = value.extract::<i64>().unwrap_or(0).clamp(0, 100) as i32;
}
if let Ok(value) =
group.call_method1("GetUnsigned", ("DefaultShapeColor", DEFAULT_COLOR))
{
color = ferrocad_core::color_from_packed(
value.extract::<u32>().unwrap_or(DEFAULT_COLOR),
true,
);
}
}
}
(transparency, color)
}
fn py_to_color(value: &Bound<'_, PyAny>) -> PyResult<[f64; 4]> {
if let Ok((r, g, b, a)) = value.extract::<(f64, f64, f64, f64)>() {
return Ok([r, g, b, a]);
}
if let Ok((r, g, b)) = value.extract::<(f64, f64, f64)>() {
return Ok([r, g, b, 1.0]);
}
if let Ok(packed) = value.extract::<u32>() {
return Ok(ferrocad_core::color_from_packed(packed, false));
}
Err(PyTypeError::new_err(
"expected an (r, g, b[, a]) colour or a packed 0xRRGGBBAA integer",
))
}
fn py_to_material_color(value: &Bound<'_, PyAny>) -> PyResult<[f64; 4]> {
if let Ok(material) = value.extract::<PyRef<'_, PyMaterial>>() {
return Ok(material.diffuse);
}
py_to_color(value)
}
fn py_to_view_colors(value: &Bound<'_, PyAny>) -> PyResult<Vec<[f64; 4]>> {
if let Ok(material) = value.extract::<PyRef<'_, PyMaterial>>() {
return Ok(vec![material.diffuse]);
}
let iterator = value
.try_iter()
.map_err(|_| PyTypeError::new_err("expected a list of materials or colours"))?;
let mut colors = Vec::new();
for item in iterator {
let item = item?;
if let Ok(material) = item.extract::<PyRef<'_, PyMaterial>>() {
colors.push(material.diffuse);
} else {
colors.push(py_to_color(&item)?);
}
}
Ok(colors)
}
fn view_effective_color(doc: &CoreDocument, id: ObjectId) -> Option<[f64; 4]> {
let object = doc.object(id)?;
let state = object.view.as_ref()?;
if let Some(color) = state.shape_color {
return Some(color);
}
if let Some(color) = operand_color(doc, object) {
return Some(color);
}
Some(state.default_color)
}
fn operand_color(
doc: &CoreDocument,
object: &ferrocad_core::DocumentObject,
) -> Option<[f64; 4]> {
let mut common: Option<[f64; 4]> = None;
let mut any = false;
for (name, property) in object.properties.iter() {
if name == "Group" {
continue;
}
let targets: Vec<&String> = match property {
Property::Link(target) => vec![target],
Property::LinkList(targets) => targets.iter().collect(),
Property::LinkSub(target, _) => vec![target],
Property::LinkSubList(entries) => {
entries.iter().map(|(target, _)| target).collect()
}
_ => continue,
};
for target in targets {
if target.is_empty() {
continue;
}
let Some(other) = doc.get_by_name(target).and_then(|id| doc.object(id)) else {
continue;
};
let Some(explicit) = other.view.as_ref().and_then(|state| state.shape_color) else {
return None;
};
if common.is_some_and(|color| color != explicit) {
return None;
}
common = Some(explicit);
any = true;
}
}
if any {
common
} else {
None
}
}
#[pymethods]
impl PyViewObject {
#[getter]
fn Proxy(&self, py: Python<'_>) -> PyObject {
match self.proxy.lock().unwrap().as_ref() {
Some(proxy) => proxy.clone_ref(py).into_any(),
None => py.None(),
}
}
#[setter]
fn set_Proxy(&self, value: &Bound<'_, PyAny>) {
*self.proxy.lock().unwrap() = if value.is_none() {
None
} else {
Some(value.clone().unbind())
};
}
#[getter]
fn Object(&self, py: Python<'_>) -> Py<PyDocumentObject> {
get_or_create_object(py, &self.doc, &self.inner, self.id)
}
#[getter]
fn Visibility(&self, py: Python<'_>) -> PyResult<bool> {
self.ensure_state(py)?;
self.with_state(|state| state.visibility)
}
#[setter]
fn set_Visibility(&self, py: Python<'_>, value: bool) -> PyResult<()> {
self.ensure_state(py)?;
self.update(|state| state.visibility = value);
Ok(())
}
#[getter]
fn Transparency(&self, py: Python<'_>) -> PyResult<i32> {
self.ensure_state(py)?;
self.with_state(|state| state.transparency)
}
#[setter]
fn set_Transparency(&self, py: Python<'_>, value: i64) -> PyResult<()> {
self.ensure_state(py)?;
self.update(|state| state.transparency = value.clamp(0, 100) as i32);
Ok(())
}
#[getter]
fn ShapeColor(&self, py: Python<'_>) -> PyResult<(f64, f64, f64, f64)> {
self.ensure_state(py)?;
let color = self.effective_color()?;
Ok((color[0], color[1], color[2], color[3]))
}
#[setter]
fn set_ShapeColor(&self, py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<()> {
let color = py_to_material_color(value)?;
self.ensure_state(py)?;
self.update(|state| state.set_shape_color(color));
Ok(())
}
#[getter]
fn ShapeAppearance(&self, py: Python<'_>) -> PyResult<Vec<Py<PyMaterial>>> {
self.ensure_state(py)?;
let colors = self.with_state(|state| state.appearance())?;
colors
.into_iter()
.enumerate()
.map(|(index, color)| {
Py::new(
py,
PyMaterial::owned(
color,
Arc::clone(&self.inner),
self.id,
MaterialSlot::Appearance(index),
),
)
})
.collect()
}
#[setter]
fn set_ShapeAppearance(&self, py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<()> {
let colors = py_to_view_colors(value)?;
self.ensure_state(py)?;
self.update(|state| state.set_appearance(colors));
Ok(())
}
#[getter]
fn ShapeMaterial(&self, py: Python<'_>) -> PyResult<Py<PyMaterial>> {
self.ensure_state(py)?;
let color = self.with_state(|state| state.material())?;
Py::new(
py,
PyMaterial::owned(
color,
Arc::clone(&self.inner),
self.id,
MaterialSlot::Material,
),
)
}
#[setter]
fn set_ShapeMaterial(&self, py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<()> {
let color = py_to_material_color(value)?;
self.ensure_state(py)?;
self.update(|state| state.material = Some(color));
Ok(())
}
#[getter]
fn DiffuseColor(&self, py: Python<'_>) -> PyResult<Vec<(f64, f64, f64, f64)>> {
Ok(self
.diffuse_colors(py)?
.into_iter()
.map(|color| (color[0], color[1], color[2], color[3]))
.collect())
}
#[setter]
fn set_DiffuseColor(&self, py: Python<'_>, value: &Bound<'_, PyAny>) -> PyResult<()> {
let colors = py_to_view_colors(value)?;
self.ensure_state(py)?;
self.update(|state| state.diffuse_color = Some(colors));
Ok(())
}
#[getter]
fn DisplayMode(&self, py: Python<'_>) -> PyResult<String> {
self.ensure_state(py)?;
self.with_state(|state| state.display_mode.clone())
}
#[setter]
fn set_DisplayMode(&self, py: Python<'_>, value: String) -> PyResult<()> {
if !DISPLAY_MODES.contains(&value.as_str()) {
return Err(PyValueError::new_err(format!(
"'{value}' is not part of the enumeration"
)));
}
self.ensure_state(py)?;
self.update(|state| state.display_mode = value);
Ok(())
}
fn getEnumerationsOfProperty(&self, name: &str) -> PyResult<Vec<String>> {
if name == "DisplayMode" {
Ok(DISPLAY_MODES.iter().map(|mode| mode.to_string()).collect())
} else {
Err(PyAttributeError::new_err(format!("no property '{name}'")))
}
}
#[getter]
fn RootNode(&self, py: Python<'_>) -> PyResult<PyObject> {
let colors = self.diffuse_colors(py)?;
let coin = py.import("pivy.coin").map_err(|_| {
PyAttributeError::new_err(
"RootNode needs the pivy Coin bindings; the view state is still \
readable as ViewObject properties",
)
})?;
let root = coin.getattr("SoSeparator")?.call0()?;
for _ in DISPLAY_MODES.iter().take(2) {
let separator = coin.getattr("SoSeparator")?.call0()?;
let material = coin.getattr("SoMaterial")?.call0()?;
let diffuse = material.getattr("diffuseColor")?;
diffuse.call_method1("setNum", (colors.len(),))?;
for (index, color) in colors.iter().enumerate() {
diffuse.call_method1("set1Value", (index, (color[0], color[1], color[2])))?;
}
let binding = coin.getattr("SoMaterialBinding")?.call0()?;
let per_part = binding.getattr("PER_PART")?;
binding.setattr("value", per_part)?;
separator.call_method1("addChild", (&material,))?;
separator.call_method1("addChild", (&binding,))?;
root.call_method1("addChild", (&separator,))?;
}
Ok(root.unbind())
}
fn __repr__(&self) -> PyResult<String> {
let doc = self.inner.lock().unwrap();
let name = doc
.object(self.id)
.map(|object| object.name.as_str())
.unwrap_or("<deleted>");
Ok(format!("<ViewObject of {name}>"))
}
}
impl PyViewObject {
fn ensure_state(&self, py: Python<'_>) -> PyResult<()> {
let type_id = {
let doc = self.inner.lock().unwrap();
match doc.object(self.id) {
Some(object) if object.view.is_some() => return Ok(()),
Some(object) => object.type_id.clone(),
None => return Err(deleted_object_error("ViewObject")),
}
};
let (mut transparency, color) = view_preferences(py);
if is_origin_family(&type_id) {
transparency = 0;
}
let mut doc = self.inner.lock().unwrap();
if let Some(object) = doc.object_mut(self.id) {
if object.view.is_none() {
object.view = Some(ferrocad_core::ViewState::new(transparency, color));
}
}
Ok(())
}
fn with_state<R>(
&self,
read: impl FnOnce(&ferrocad_core::ViewState) -> R,
) -> PyResult<R> {
let doc = self.inner.lock().unwrap();
let state = doc
.object(self.id)
.and_then(|object| object.view.as_ref())
.ok_or_else(|| deleted_object_error("ViewObject"))?;
Ok(read(state))
}
fn update(&self, change: impl FnOnce(&mut ferrocad_core::ViewState)) {
update_view_state(&self.inner, self.id, change);
}
fn effective_color(&self) -> PyResult<[f64; 4]> {
let doc = self.inner.lock().unwrap();
view_effective_color(&doc, self.id).ok_or_else(|| deleted_object_error("ViewObject"))
}
fn face_count(&self, py: Python<'_>) -> Option<usize> {
if !object_is_attached(&self.inner, self.id) {
return None;
}
let doc = self.doc.clone_ref(py);
let object = get_or_create_object(py, &doc, &self.inner, self.id);
let object = object.bind(py);
let shape = object.getattr("Shape").ok()?;
let faces = shape.getattr("Faces").ok()?;
faces.len().ok()
}
fn diffuse_colors(&self, py: Python<'_>) -> PyResult<Vec<[f64; 4]>> {
self.ensure_state(py)?;
let (explicit, color) = {
let doc = self.inner.lock().unwrap();
let state = doc
.object(self.id)
.and_then(|object| object.view.as_ref())
.ok_or_else(|| deleted_object_error("ViewObject"))?;
(
state.diffuse_color.clone(),
view_effective_color(&doc, self.id).unwrap_or(state.default_color),
)
};
if let Some(colors) = explicit {
return Ok(colors);
}
match self.face_count(py) {
Some(count) => Ok(vec![color; count]),
None => Ok(Vec::new()),
}
}
}
#[pyclass(name = "BoundBox", module = "ferrocad")]
#[derive(Clone)]
struct PyBoundBox {
min: [f64; 3],
max: [f64; 3],
valid: bool,
}
impl PyBoundBox {
fn add_point(&mut self, p: [f64; 3]) {
if self.valid {
for i in 0..3 {
self.min[i] = self.min[i].min(p[i]);
self.max[i] = self.max[i].max(p[i]);
}
} else {
self.min = p;
self.max = p;
self.valid = true;
}
}
fn contains(&self, p: [f64; 3]) -> bool {
self.valid && (0..3).all(|i| p[i] >= self.min[i] && p[i] <= self.max[i])
}
}
#[pymethods]
impl PyBoundBox {
#[new]
#[pyo3(signature = (xmin=None, ymin=None, zmin=None, xmax=None, ymax=None, zmax=None))]
fn new(
xmin: Option<&Bound<'_, PyAny>>,
ymin: Option<f64>,
zmin: Option<f64>,
xmax: Option<f64>,
ymax: Option<f64>,
zmax: Option<f64>,
) -> PyResult<Self> {
if let Some(value) = xmin {
if let Ok(other) = value.downcast::<PyBoundBox>() {
let other = other.borrow();
return Ok(Self {
min: other.min,
max: other.max,
valid: other.valid,
});
}
}
let xmin = xmin.map(|value| value.extract::<f64>()).transpose()?;
Ok(match (xmin, ymin, zmin, xmax, ymax, zmax) {
(Some(a), Some(b), Some(c), Some(d), Some(e), Some(f)) => Self {
min: [a, b, c],
max: [d, e, f],
valid: true,
},
_ => Self {
min: [0.0; 3],
max: [0.0; 3],
valid: false,
},
})
}
fn enlarge(&mut self, amount: f64) {
if self.valid {
for i in 0..3 {
self.min[i] -= amount;
self.max[i] += amount;
}
}
}
#[getter]
fn XMin(&self) -> f64 {
self.min[0]
}
#[getter]
fn YMin(&self) -> f64 {
self.min[1]
}
#[getter]
fn ZMin(&self) -> f64 {
self.min[2]
}
#[getter]
fn XMax(&self) -> f64 {
self.max[0]
}
#[getter]
fn YMax(&self) -> f64 {
self.max[1]
}
#[getter]
fn ZMax(&self) -> f64 {
self.max[2]
}
fn setVoid(&mut self) {
self.valid = false;
}
fn isValid(&self) -> bool {
self.valid
}
#[pyo3(signature = (x, y, z))]
fn add(&mut self, x: &Bound<'_, PyAny>, y: Option<f64>, z: Option<f64>) -> PyResult<()> {
if let Ok(v) = x.extract::<PyRef<'_, PyVector>>() {
self.add_point([v.inner.x, v.inner.y, v.inner.z]);
return Ok(());
}
let x = x.extract::<f64>()?;
self.add_point([x, y.unwrap_or(0.0), z.unwrap_or(0.0)]);
Ok(())
}
#[getter]
fn XLength(&self) -> f64 {
self.max[0] - self.min[0]
}
#[getter]
fn YLength(&self) -> f64 {
self.max[1] - self.min[1]
}
#[getter]
fn ZLength(&self) -> f64 {
self.max[2] - self.min[2]
}
#[getter]
fn Center(&self) -> PyVector {
PyVector::fresh(Vector3::new(
(self.min[0] + self.max[0]) / 2.0,
(self.min[1] + self.max[1]) / 2.0,
(self.min[2] + self.max[2]) / 2.0,
))
}
fn isInside(&self, value: &Bound<'_, PyAny>) -> bool {
if let Ok(point) = value.extract::<PyRef<'_, PyVector>>() {
return self.contains([point.inner.x, point.inner.y, point.inner.z]);
}
if let Ok(other) = value.downcast::<PyBoundBox>() {
let other = other.borrow();
return self.valid
&& other.valid
&& (0..3).all(|i| other.min[i] >= self.min[i] && other.max[i] <= self.max[i]);
}
false
}
fn getIntersectionPoint(&self, point: PyRef<'_, PyVector>, direction: PyRef<'_, PyVector>) -> PyVector {
let p = point.inner;
let d = direction.inner;
let mut t = f64::INFINITY;
for i in 0..3 {
let (pi, di) = ([p.x, p.y, p.z][i], [d.x, d.y, d.z][i]);
if di.abs() > 1e-15 {
for bound in [self.min[i], self.max[i]] {
let ti = (bound - pi) / di;
if ti >= 0.0 {
t = t.min(ti);
}
}
}
}
if t.is_finite() {
PyVector::fresh(Vector3::new(p.x + t * d.x, p.y + t * d.y, p.z + t * d.z))
} else {
PyVector::fresh(p)
}
}
fn intersect(&self, other: PyRef<'_, PyBoundBox>) -> bool {
self.valid
&& other.valid
&& (0..3).all(|i| self.min[i] <= other.max[i] && self.max[i] >= other.min[i])
}
fn intersected(&self, other: PyRef<'_, PyBoundBox>) -> PyBoundBox {
let overlaps = self.valid
&& other.valid
&& (0..3).all(|i| self.min[i] <= other.max[i] && self.max[i] >= other.min[i]);
if !overlaps {
return PyBoundBox { min: [0.0; 3], max: [0.0; 3], valid: false };
}
let mut out = PyBoundBox { min: [0.0; 3], max: [0.0; 3], valid: true };
for i in 0..3 {
out.min[i] = self.min[i].max(other.min[i]);
out.max[i] = self.max[i].min(other.max[i]);
}
out
}
fn __repr__(&self) -> String {
format!("BoundBox ({:?}, {:?})", self.min, self.max)
}
}
#[pyfunction]
#[pyo3(signature = (name=None))]
fn newDocument(py: Python<'_>, name: Option<String>) -> PyResult<Py<PyDocument>> {
let (doc_name, handle) = application()
.lock()
.unwrap()
.new_document(name.as_deref());
let doc = Py::new(
py,
PyDocument {
label: doc_name.clone(),
name: doc_name.clone(),
file_name: None,
format: None,
auto_created: false,
inner: handle,
meta: Arc::new(Mutex::new(BTreeMap::new())),
comment: Mutex::new(String::new()),
},
)?;
documents().lock().unwrap().insert(doc_name, doc.clone_ref(py));
let bound = doc.bind(py);
fire_doc("slotCreatedDocument", bound, None);
fire_doc_str("slotBeforeChangeDocument", bound, "Label");
fire_doc_str("slotChangedDocument", bound, "Label");
fire_doc("slotRelabelDocument", bound, None);
Ok(doc)
}
#[pyfunction]
#[pyo3(signature = (path, hidden=false, readonly=false))]
fn openDocument(
py: Python<'_>,
path: &str,
hidden: bool,
readonly: bool,
) -> PyResult<Py<PyDocument>> {
let _ = (hidden, readonly);
let (saved, format) =
doc_format::read(path).map_err(|e| PyValueError::new_err(e.to_string()))?;
let core_doc = CoreDocument::from_saved(&saved);
let (doc_name, handle) = application()
.lock()
.unwrap()
.insert_document(&saved.name, core_doc);
let doc = Py::new(
py,
PyDocument {
name: doc_name.clone(),
label: doc_name.clone(),
file_name: Some(path.to_string()),
format: Some(format),
auto_created: false,
inner: Arc::clone(&handle),
meta: Arc::new(Mutex::new(BTreeMap::new())),
comment: Mutex::new(String::new()),
},
)?;
documents().lock().unwrap().insert(doc_name, doc.clone_ref(py));
apply_all_python_states(py, &doc, &handle);
notify_document_restored(py, &doc, &handle);
Ok(doc)
}
#[pyfunction]
fn getDocument(py: Python<'_>, name: &str) -> Option<Py<PyDocument>> {
documents().lock().unwrap().get(name).map(|doc| doc.clone_ref(py))
}
#[pyfunction]
fn listDocuments(py: Python<'_>) -> BTreeMap<String, Py<PyDocument>> {
documents()
.lock()
.unwrap()
.iter()
.map(|(name, doc)| (name.clone(), doc.clone_ref(py)))
.collect()
}
#[pyfunction]
fn closeDocument(py: Python<'_>, name: &str) -> bool {
let doc = documents().lock().unwrap().remove(name);
application().lock().unwrap().close_document(name);
match doc {
Some(doc) => {
fire_doc("slotDeletedDocument", doc.bind(py), None);
forget_document(&doc);
true
}
None => false,
}
}
#[pyfunction]
fn setActiveDocument(py: Python<'_>, name: &str) -> bool {
let changed = {
let mut app = application().lock().unwrap();
if !app.contains(name) {
return false;
}
let changed = app.active() != Some(name);
app.set_active(name);
changed
};
if changed {
let doc = documents().lock().unwrap().get(name).map(|d| d.clone_ref(py));
if let Some(doc) = doc {
fire_doc("slotActivateDocument", doc.bind(py), None);
}
}
true
}
#[pyfunction]
fn activeDocument(py: Python<'_>) -> Option<Py<PyDocument>> {
let name = application().lock().unwrap().active().map(str::to_string)?;
documents().lock().unwrap().get(&name).map(|doc| doc.clone_ref(py))
}
#[pyfunction]
fn addDocumentObserver(observer: Py<PyAny>) {
let mut obs = observers().lock().unwrap();
if !obs.iter().any(|o| o.as_ptr() == observer.as_ptr()) {
obs.push(observer);
}
}
#[pyfunction]
fn removeDocumentObserver(observer: &Bound<'_, PyAny>) {
observers()
.lock()
.unwrap()
.retain(|o| o.as_ptr() != observer.as_ptr());
}
#[pymodule]
pub fn ferrocad(m: &Bound<'_, PyModule>) -> PyResult<()> {
ferrocad_core::object_registry::set_python_executor_available(true);
m.add("__version__", env!("CARGO_PKG_VERSION"))?;
m.add_class::<PyQuantity>()?;
m.add_class::<PyUnit>()?;
m.add_class::<PyVector>()?;
m.add_class::<PyMatrix>()?;
m.add_class::<PyRotation>()?;
m.add_class::<PyPlacement>()?;
m.add_class::<PyTypeId>()?;
m.add_class::<PyVector2d>()?;
m.add_class::<PyMaterial>()?;
m.add_class::<PyBoundBox>()?;
m.add_class::<PyDocument>()?;
m.add_class::<PyDocumentObject>()?;
m.add_class::<PyViewObject>()?;
m.add_class::<PyDocumentSettings>()?;
m.add_class::<PyStringHasher>()?;
m.add_class::<PyStringID>()?;
m.add_function(wrap_pyfunction!(newDocument, m)?)?;
m.add_function(wrap_pyfunction!(openDocument, m)?)?;
m.add_function(wrap_pyfunction!(getDocument, m)?)?;
m.add_function(wrap_pyfunction!(listDocuments, m)?)?;
m.add_function(wrap_pyfunction!(closeDocument, m)?)?;
m.add_function(wrap_pyfunction!(setActiveDocument, m)?)?;
m.add_function(wrap_pyfunction!(activeDocument, m)?)?;
m.add_function(wrap_pyfunction!(addDocumentObserver, m)?)?;
m.add_function(wrap_pyfunction!(removeDocumentObserver, m)?)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use pyo3::types::PyTuple;
use std::sync::Once;
fn init_python() {
static INIT: Once = Once::new();
INIT.call_once(pyo3::prepare_freethreaded_python);
}
fn quantity_args(py: Python<'_>, second: Py<PyAny>) -> PyResult<Bound<'_, PyTuple>> {
let value: Py<PyAny> = 100.0f64.into_py_any(py)?;
PyTuple::new(py, [value, second])
}
#[test]
fn quantity_accepts_a_unit_in_second_position() {
init_python();
Python::with_gil(|py| {
let unit: Py<PyAny> = PyUnit { inner: Unit::parse("mm").unwrap() }
.into_py_any(py)
.unwrap();
let args = quantity_args(py, unit).unwrap();
let q = PyQuantity::new(&args).unwrap();
assert_eq!(q.inner, Quantity::new(100.0, Unit::parse("mm").unwrap()));
});
}
#[test]
fn quantity_still_accepts_a_unit_string_in_second_position() {
init_python();
Python::with_gil(|py| {
let symbol: Py<PyAny> = "mm".into_py_any(py).unwrap();
let args = quantity_args(py, symbol).unwrap();
let q = PyQuantity::new(&args).unwrap();
assert_eq!(q.inner, Quantity::new(100.0, Unit::parse("mm").unwrap()));
});
}
#[test]
fn quantity_rejects_a_quantity_as_the_unit() {
init_python();
Python::with_gil(|py| {
let other: Py<PyAny> = PyQuantity {
inner: Quantity::new(1.0, Unit::parse("mm").unwrap()),
}
.into_py_any(py)
.unwrap();
let args = quantity_args(py, other).unwrap();
match PyQuantity::new(&args) {
Ok(_) => panic!("a Quantity must not be accepted as the unit"),
Err(err) => assert!(
err.is_instance_of::<PyTypeError>(py),
"expected TypeError, got {err:?}"
),
}
});
}
}