Fix #6334: Preserve annotation vertex order during subdivision to prevent arrow/text flip

Add dialog to DuplicateType operator allowing users to set name, description,
and optionally assign the active object to the duplicated type. Add duplicate
button to product UI in type panel with auto-assignment enabled by default.

VERSION

@@ -1 +1 @@
-0.8.4
+0.8.5

cmake/CMakeLists.txt

@@ -200,26 +200,11 @@ endif()
 
 UNIFY_ENVVARS_AND_CACHE(BOOST_ROOT)
 UNIFY_ENVVARS_AND_CACHE(BOOST_LIBRARYDIR)
-UNIFY_ENVVARS_AND_CACHE(EIGEN_DIR)
 
 if(NOT MINIMAL_BUILD)
-    UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_INCLUDE_DIR)
-    UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_LIBRARY_DIR)
-    UNIFY_ENVVARS_AND_CACHE(LIBXML2_INCLUDE_DIR)
-    UNIFY_ENVVARS_AND_CACHE(LIBXML2_LIBRARIES)
-    UNIFY_ENVVARS_AND_CACHE(PCRE_LIBRARY_DIR)
     UNIFY_ENVVARS_AND_CACHE(PYTHON_INCLUDE_DIR)
     UNIFY_ENVVARS_AND_CACHE(PYTHON_LIBRARY)
     UNIFY_ENVVARS_AND_CACHE(PYTHON_EXECUTABLE)
-    UNIFY_ENVVARS_AND_CACHE(HDF5_INCLUDE_DIR)
-    UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARY_DIR)
-    UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARIES)
-    UNIFY_ENVVARS_AND_CACHE(CGAL_INCLUDE_DIR)
-    UNIFY_ENVVARS_AND_CACHE(CGAL_LIBRARY_DIR)
-    UNIFY_ENVVARS_AND_CACHE(GMP_INCLUDE_DIR)
-    UNIFY_ENVVARS_AND_CACHE(GMP_LIBRARY_DIR)
-    UNIFY_ENVVARS_AND_CACHE(MPFR_INCLUDE_DIR)
-    UNIFY_ENVVARS_AND_CACHE(MPFR_LIBRARY_DIR)
 endif()
 
 # Get a list of all OPTION flags from the CMakeLists.txt
@@ -230,49 +215,13 @@ foreach(option_flag IN LISTS option_flags)
     convert_env_var_to_bool("${option_flag}")
 endforeach()
 
-set(CMAKE_FIND_ROOT_PATH_BACKUP "${CMAKE_FIND_ROOT_PATH}")
-
-macro(clear_wasm_sysroot)
-if(WASM_BUILD)
-    # when using the nix/build-all.py build script we should not
-    # look into the sysroot for most of the dependencies but rather
-    # in the designated build/ folder created by the script.
-    set(CMAKE_FIND_ROOT_PATH "")
-endif()
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER)
-endmacro()
-
-macro(restore_wasm_sysroot)
-if(WASM_BUILD)
-    # reset to use sysroot
-    set(CMAKE_FIND_ROOT_PATH "${CMAKE_FIND_ROOT_PATH_BACKUP}")
-endif()
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-endmacro()
-
 if(WITH_CGAL)
-    if(NOT CGAL_INCLUDE_DIR)
-	# CGAL is not respecting default Boost_USE_STATIC_LIBS value
-	# and sometiems it's getting in the way.
-	if(NOT DEFINED Boost_USE_STATIC_LIBS)
-		set(CGAL_Boost_USE_STATIC_LIBS OFF)
-	else()
-		set(CGAL_Boost_USE_STATIC_LIBS "${Boost_USE_STATIC_LIBS}")
-	endif()
     find_package(CGAL REQUIRED)
-        if(NOT CGAL_DIR)
-            message(
-                FATAL_ERROR
-                "CGAL_SUPPORT enabled, but CGAL_INCLUDE_DIR wasn't provided and CGAL package couldn't be found."
-            )
-        endif()
-        message(STATUS "CGAL: found config at '${CGAL_DIR}'.")
+    if(TARGET CGAL::CGAL)
         link_libraries(CGAL::CGAL)
     endif()
-
     add_definitions(-DIFOPSH_WITH_CGAL)
     set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_CGAL)
-
     list(APPEND GEOMETRY_KERNELS cgal)
 endif()
 
@@ -294,9 +243,7 @@ if(GLTF_SUPPORT)
     endif()
 
     if(NOT nlohmann_json_DIR)
-        clear_wasm_sysroot()
         find_path(json_header_path "nlohmann/json.hpp" HINTS ${JSON_INCLUDE_DIR})
-        restore_wasm_sysroot()
         set(JSON_INCLUDE_DIR ${json_header_path})
 
         if(json_header_path)
@@ -394,19 +341,15 @@ if(USE_MMAP)
     add_definitions(-DUSE_MMAP)
 endif()
 
-clear_wasm_sysroot()
 find_package(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
-restore_wasm_sysroot()
 message(STATUS "Boost include files found in ${Boost_INCLUDE_DIRS}")
 message(STATUS "Boost libraries found in ${Boost_LIBRARY_DIRS}")
 
 if(NOT MINIMAL_BUILD)
     # libxml2 is required for IFCXML (optional) and SVGFILL (mandatory)
-    clear_wasm_sysroot()
     if(IFCXML_SUPPORT)
         find_package(LibXml2 REQUIRED)
     endif()
-    restore_wasm_sysroot()
 endif()
 
 if(IFCXML_SUPPORT)
@@ -415,114 +358,15 @@ if(IFCXML_SUPPORT)
 endif()
 
 if(BUILD_IFCGEOM)
-    if(MSVC AND NOT LibXml2_DIR)
-        add_debug_variants(LIBXML2_LIBRARIES "${LIBXML2_LIBRARIES}" d)
-    endif()
-
     # Open CASCADE
     if(WITH_OPENCASCADE)
         find_package(OpenCASCADE REQUIRED)
     endif(WITH_OPENCASCADE)
 endif(BUILD_IFCGEOM)
 
-if(COLLADA_SUPPORT AND (NOT OPENCOLLADA_INCLUDE_DIR AND NOT OPENCOLLADA_LIBRARY_DIR))
-    # If package is found, automatically sets
-    # OPENCOLLADA_INCLUDE_DIRS and OPENCOLLADA_LIBRARIES (list of targets, not paths).
-    find_package(OpenCOLLADA CONFIG)
-    if(OpenCOLLADA_DIR)
-        message(STATUS "Found OpenCOLLADA: '${OpenCOLLADA_DIR}'.")
-        set(OPENCOLLADA_FOUND TRUE)
-    else()
-        message(STATUS "OpenCOLLADA package not found, falling back to manual search.")
-    endif()
+if(COLLADA_SUPPORT)
+    find_package(OpenCOLLADA REQUIRED)
 endif()
-if(COLLADA_SUPPORT AND NOT OpenCOLLADA_DIR)
-    # Find OpenCOLLADA
-    if("${OPENCOLLADA_INCLUDE_DIR}" STREQUAL "")
-        message(STATUS "No OpenCOLLADA include directory specified")
-        set(OPENCOLLADA_INCLUDE_DIR "/usr/include/opencollada" CACHE FILEPATH "OpenCOLLADA header files")
-    else()
-        set(OPENCOLLADA_INCLUDE_DIR "${OPENCOLLADA_INCLUDE_DIR}" CACHE FILEPATH "OpenCOLLADA header files")
-    endif()
-
-    if("${OPENCOLLADA_LIBRARY_DIR}" STREQUAL "")
-        message(STATUS "No OpenCOLLADA library directory specified")
-        find_library(OPENCOLLADA_FRAMEWORK_LIB NAMES OpenCOLLADAFramework
-            PATHS /usr/lib64/opencollada /usr/lib/opencollada /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib)
-        get_filename_component(OPENCOLLADA_LIBRARY_DIR ${OPENCOLLADA_FRAMEWORK_LIB} PATH)
-    endif()
-
-    find_library(OpenCOLLADAFramework NAMES OpenCOLLADAFramework OpenCOLLADAFrameworkd PATHS ${OPENCOLLADA_LIBRARY_DIR} NO_DEFAULT_PATH)
-
-    if(OpenCOLLADAFramework)
-        message(STATUS "OpenCOLLADA library files found")
-    else()
-        message(FATAL_ERROR "COLLADA_SUPPORT enabled, but unable to find OpenCOLLADA libraries. "
-            "Disable COLLADA_SUPPORT or fix OpenCOLLADA paths to proceed.")
-    endif()
-
-    set(OPENCOLLADA_LIBRARY_DIR "${OPENCOLLADA_LIBRARY_DIR}" CACHE FILEPATH "OpenCOLLADA library files")
-
-    set(OPENCOLLADA_INCLUDE_DIRS "${OPENCOLLADA_INCLUDE_DIR}/COLLADABaseUtils" "${OPENCOLLADA_INCLUDE_DIR}/COLLADAStreamWriter")
-
-    find_file(COLLADASWStreamWriter_h "COLLADASWStreamWriter.h" ${OPENCOLLADA_INCLUDE_DIRS})
-
-    if(COLLADASWStreamWriter_h)
-        message(STATUS "OpenCOLLADA header files found")
-        set(OPENCOLLADA_FOUND TRUE)
-
-        set(OPENCOLLADA_LIBRARY_NAMES
-            GeneratedSaxParser MathMLSolver OpenCOLLADABaseUtils OpenCOLLADAFramework OpenCOLLADASaxFrameworkLoader
-            OpenCOLLADAStreamWriter UTF buffer ftoa
-        )
-
-        # Use the found OpenCOLLADAFramework as a template for all other OpenCOLLADA libraries
-        foreach(lib ${OPENCOLLADA_LIBRARY_NAMES})
-            # Make sure we'll handle the Windows/MSVC debug postfix convention too.
-            string(REPLACE OpenCOLLADAFrameworkd "${lib}" lib_path "${OpenCOLLADAFramework}")
-            string(REPLACE OpenCOLLADAFramework "${lib}" lib_path "${lib_path}")
-            list(APPEND OPENCOLLADA_LIBRARIES "${lib_path}")
-        endforeach()
-
-        if("${PCRE_LIBRARY_DIR}" STREQUAL "")
-            if(WIN32)
-                find_library(pcre_library NAMES pcre pcred PATHS ${OPENCOLLADA_LIBRARY_DIR} NO_DEFAULT_PATH)
-            else()
-                find_library(pcre_library NAMES pcre PATHS ${OPENCOLLADA_LIBRARY_DIR})
-            endif()
-
-            get_filename_component(PCRE_LIBRARY_DIR ${pcre_library} PATH)
-        else()
-            find_library(pcre_library NAMES pcre pcred PATHS ${PCRE_LIBRARY_DIR} NO_DEFAULT_PATH)
-        endif()
-
-        if(pcre_library)
-            set(OPENCOLLADA_LIBRARY_DIR ${OPENCOLLADA_LIBRARY_DIR} ${PCRE_LIBRARY_DIR})
-
-            if(MSVC)
-                # Add release lib regardless whether release or debug found. Debug version will be appended below.
-                list(APPEND OPENCOLLADA_LIBRARIES "${PCRE_LIBRARY_DIR}/pcre.lib")
-            else()
-                list(APPEND OPENCOLLADA_LIBRARIES "${pcre_library}")
-            endif()
-        else()
-            message(FATAL_ERROR "COLLADA_SUPPORT enabled, but unable to find PCRE. "
-                "Disable COLLADA_SUPPORT or fix PCRE_LIBRARY_DIR path to proceed.")
-        endif()
-
-        if(MSVC)
-            add_debug_variants(OPENCOLLADA_LIBRARIES "${OPENCOLLADA_LIBRARIES}" d)
-        endif()
-    else()
-        message(FATAL_ERROR "COLLADA_SUPPORT enabled, but unable to find OpenCOLLADA headers. "
-            "Disable COLLADA_SUPPORT or fix OpenCOLLADA paths to proceed.")
-    endif()
-endif(COLLADA_SUPPORT AND NOT OpenCOLLADA_DIR)
-if(COLLADA_SUPPORT AND OPENCOLLADA_FOUND)
-    add_definitions(-DWITH_OPENCOLLADA)
-    set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_OPENCOLLADA)
-endif()
-
 
 if(HDF5_SUPPORT)
     find_package(HDF5 REQUIRED COMPONENTS C CXX)
@@ -642,25 +486,12 @@ else()
 endif(MSVC)
 
 
-# Ensure other dependencies are provided.
-if(NOT EXISTS "${EIGEN_DIR}")
-    find_package(Eigen3 CONFIG)
-    if(Eigen3_DIR)
-        message(STATUS "Eigen3: found config at '${Eigen3_DIR}'.")
-    else()
-        message(
-            FATAL_ERROR
-            "EIGEN_DIR is not provided or provided folder doesn't exist (current value: '${EIGEN_DIR}'). "
-            "Also couldn't find Eigen3 as a package."
-        )
-    endif()
-    link_libraries(Eigen3::Eigen)
-endif()
+find_package(Eigen3 REQUIRED)
+link_libraries(Eigen3::Eigen)
 
-
-include_directories(${INCLUDE_DIRECTORIES} ${OCC_INCLUDE_DIR} ${OPENCOLLADA_INCLUDE_DIRS}
-	${Boost_INCLUDE_DIRS} ${LIBXML2_INCLUDE_DIR} ${JSON_INCLUDE_DIR} ${HDF5_INCLUDE_DIRS}
-    ${EIGEN_DIR} ${CGAL_INCLUDE_DIR} ${GMP_INCLUDE_DIR} ${MPFR_INCLUDE_DIR} ${USD_INCLUDE_DIR}
+include_directories(${INCLUDE_DIRECTORIES} ${OPENCOLLADA_INCLUDE_DIRS}
+	${Boost_INCLUDE_DIRS} ${LIBXML2_INCLUDE_DIR} ${JSON_INCLUDE_DIR} ${HDF5_INCLUDE_DIR}
+    ${CGAL_INCLUDE_DIR} ${GMP_INCLUDE_DIR} ${MPFR_INCLUDE_DIR} ${USD_INCLUDE_DIR}
     ${TBB_INCLUDE_DIR}
 )
 
@@ -764,13 +595,13 @@ if(BUILD_CONVERT OR BUILD_IFCPYTHON)
         foreach(schema ${SCHEMA_VERSIONS})
             set(GEOM_SERIALIZER_SCHEMA_LIBRARIES ${GEOM_SERIALIZER_SCHEMA_LIBRARIES} GeometrySerializers_ifc${schema})
 
-            add_library(geometry_serializer_ifc${schema} STATIC ../src/ifcgeom/Serialization/schema/Serialization.cpp)
+            add_library(geometry_serializer_ifc${schema} OBJECT ../src/ifcgeom/Serialization/schema/Serialization.cpp)
             set_target_properties(geometry_serializer_ifc${schema} PROPERTIES COMPILE_FLAGS "-DIFC_GEOMSERIALIZATION_EXPORTS -DIfcSchema=Ifc${schema}")
             target_link_libraries(geometry_serializer_ifc${schema} ${OpenCASCADE_LIBRARIES})
             list(APPEND geometry_serializer_libraries geometry_serializer_ifc${schema})
         endforeach()
 
-        add_library(geometry_serializer STATIC ../src/ifcgeom/Serialization/Serialization.h ../src/ifcgeom/Serialization/Serialization.cpp)
+        add_library(geometry_serializer OBJECT ../src/ifcgeom/Serialization/Serialization.h ../src/ifcgeom/Serialization/Serialization.cpp)
         set_target_properties(geometry_serializer PROPERTIES COMPILE_FLAGS "-DIFC_GEOMSERIALIZATION_EXPORTS")
         target_link_libraries(geometry_serializer ${geometry_serializer_libraries} IfcParse)
         set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} geometry_serializer ${geometry_serializer_libraries})
@@ -783,10 +614,8 @@ if(BUILD_IFCGEOM)
         set(CGAL_LIBRARIES CGAL::CGAL)
         message(STATUS "Using found CGAL package at '${CGAL_DIR}'")
     elseif(WITH_CGAL AND NOT CGAL_DIR)
-	clear_wasm_sysroot()
         find_library(libGMP NAMES gmp mpir PATHS ${GMP_LIBRARY_DIR} NO_DEFAULT_PATH)
         find_library(libMPFR NAMES mpfr PATHS ${MPFR_LIBRARY_DIR} NO_DEFAULT_PATH)
-	restore_wasm_sysroot()
         if(NOT libGMP)
             message(FATAL_ERROR "Unable to find GMP library files, aborting")
         endif()
@@ -807,12 +636,9 @@ if(BUILD_IFCGEOM)
         file(GLOB IFCGEOM_CPP_FILES ../src/ifcgeom/mapping/*.cpp)
         set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES} ${IFCGEOM_I_FILES})
 
-        add_library(geometry_mapping_ifc${schema} STATIC ${IFCGEOM_FILES})
+        add_library(geometry_mapping_ifc${schema} OBJECT ${IFCGEOM_FILES})
         set_target_properties(geometry_mapping_ifc${schema} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${schema}")
         target_link_libraries(geometry_mapping_ifc${schema} IfcParse)
-        if (NOT BUILD_SHARED_LIBS)
-            target_link_libraries(geometry_mapping_ifc${schema} IfcGeom)
-        endif()
         list(APPEND mapping_libraries geometry_mapping_ifc${schema})
     endforeach()
 
@@ -828,7 +654,7 @@ if(BUILD_IFCGEOM)
         find_package(Threads)
     endif()
 
-    target_link_libraries(IfcGeom IfcParse ${mapping_libraries} ${CMAKE_THREAD_LIBS_INIT})
+    target_link_libraries(IfcGeom IfcParse ${mapping_libraries} ${CMAKE_THREAD_LIBS_INIT} ${OpenCASCADE_LIBRARIES})
 
 endif(BUILD_IFCGEOM)
 

cmake/FindCGAL.cmake

@@ -0,0 +1,42 @@
+#
+# Input variables:
+# - `CGAL_INCLUDE_DIR`
+# - `CGAL_LIBRARY_DIR`
+# - `GMP_INCLUDE_DIR`
+# - `GMP_LIBRARY_DIR`
+# - `MPFR_INCLUDE_DIR`
+# - `MPFR_LIBRARY_DIR`
+# If input variables are not specified, try to find HDF5 config.
+# Input variables could also be provided as environment variables.
+#
+# Output variables:
+# - `CGAL_INCLUDE_DIR`
+#
+
+UNIFY_ENVVARS_AND_CACHE(CGAL_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(CGAL_LIBRARY_DIR)
+UNIFY_ENVVARS_AND_CACHE(GMP_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(GMP_LIBRARY_DIR)
+UNIFY_ENVVARS_AND_CACHE(MPFR_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(MPFR_LIBRARY_DIR)
+
+if(NOT CGAL_INCLUDE_DIR)
+    # CGAL is not respecting default Boost_USE_STATIC_LIBS value
+    # and sometiems it's getting in the way.
+    if(NOT DEFINED Boost_USE_STATIC_LIBS)
+        set(CGAL_Boost_USE_STATIC_LIBS OFF)
+    else()
+        set(CGAL_Boost_USE_STATIC_LIBS "${Boost_USE_STATIC_LIBS}")
+    endif()
+    find_package(CGAL CONFIG REQUIRED)
+    if(NOT CGAL_DIR)
+        message(
+            FATAL_ERROR
+            "CGAL_SUPPORT enabled, but CGAL_INCLUDE_DIR wasn't provided and CGAL package couldn't be found."
+        )
+    endif()
+    message(STATUS "CGAL: found config at '${CGAL_DIR}'.")
+endif()
+
+add_definitions(-DIFOPSH_WITH_CGAL)
+set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_CGAL)

cmake/FindEigen3.cmake

@@ -0,0 +1,27 @@
+#
+# Input variables:
+# - `EIGEN_DIR`
+# If input variables are not specified, try to find Eigen3 config.
+# Input variables could also be provided as environment variables.
+#
+# Output targets:
+# - `Eigen3::Eigen`
+
+UNIFY_ENVVARS_AND_CACHE(EIGEN_DIR)
+
+if(EXISTS "${EIGEN_DIR}")
+    # Mimic Eigen3Config.cmake target.
+    add_library(Eigen3::Eigen INTERFACE IMPORTED)
+    target_include_directories(Eigen3::Eigen INTERFACE "${EIGEN_DIR}")
+else()
+    find_package(Eigen3 CONFIG)
+    if(Eigen3_DIR)
+        message(STATUS "Eigen3: found config at '${Eigen3_DIR}'.")
+    else()
+        message(
+            FATAL_ERROR
+            "EIGEN_DIR is not provided or provided folder doesn't exist (current value: '${EIGEN_DIR}'). "
+            "Also couldn't find Eigen3 as a package."
+        )
+    endif()
+endif()

cmake/FindHDF5.cmake

@@ -1,3 +1,21 @@
+#
+# Input variables:
+# - `HDF5_INCLUDE_DIR`
+# - `HDF5_LIBRARY_DIR`
+# - `HDF5_LIBRARIES`
+# If input variables are not specified, try to find HDF5 config.
+# Input variables could also be provided as environment variables.
+#
+# Output variables:
+# - `HDF5_INCLUDE_DIR`
+# - `HDF5_LIBRARY_DIR`
+# - `HDF5_LIBRARIES`
+#
+
+UNIFY_ENVVARS_AND_CACHE(HDF5_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARY_DIR)
+UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARIES)
+
 # To avoid cyclic calls to this file
 list(REMOVE_ITEM CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR})
 

cmake/FindLibXml2.cmake

@@ -13,12 +13,13 @@
 # To avoid cyclic calls to this file
 list(REMOVE_ITEM CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR})
 
+UNIFY_ENVVARS_AND_CACHE(LIBXML2_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(LIBXML2_LIBRARIES)
+
 if((NOT LIBXML2_INCLUDE_DIR AND NOT LIBXML2_LIBRARIES))
     # First try config mode (probably works with vcpkg, Conan, macOS brew installs, but not on ubuntu 22.04)
     # CONFIG is provided using root path, so no need to clear sysroot here.
-    restore_wasm_sysroot()
     find_package(LibXml2 QUIET CONFIG)
-    clear_wasm_sysroot()
 
     if(NOT LibXml2_FOUND)
         # Fallback to CMake's builtin FindLibXml2 module (works on Ubuntu)
@@ -40,5 +41,9 @@ else()
     find_package(LibXml2 REQUIRED)
 endif()
 
+if(MSVC AND NOT LibXml2_DIR)
+    add_debug_variants(LIBXML2_LIBRARIES "${LIBXML2_LIBRARIES}" d)
+endif()
+
 # Restore module path.
 list(PREPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR})

cmake/FindOpenCASCADE.cmake

@@ -5,9 +5,7 @@
 # If input variables are not specified, try to find OpenCASCADE config.
 # Input variables could also be provided as environment variables.
 #
-# Output variables:
-# - `OCC_INCLUDE_DIR`
-# - `OCC_LIBRARY_DIR`
+# Output variables
 # - `OpenCASCADE_LIBRARIES`
 #
 
@@ -24,6 +22,23 @@ if(OCC_LIBRARY_DIR)
     message(STATUS "Looking for Open CASCADE library files in: ${OCC_LIBRARY_DIR}")
 endif()
 
+
+if(NOT OCC_INCLUDE_DIR AND NOT OCC_LIBRARY_DIR)
+    # OCE is not supported for find_package, because it's using a different name (`oce`)
+    # and also has an odd directory structure (install/lib/oce-0.18/*.cmake).
+    # find_package creates variables:
+    # - `OpenCASCADE_INCLUDE_DIR`
+    # - `OpenCASCADE_LIBRARIES`
+
+    # OpenCASCADE may be built with VTK support. Try to find VTK first to avoid
+    # CMake errors when OpenCASCADE's config references VTK targets.
+    find_package(VTK QUIET)
+
+    find_package(OpenCASCADE CONFIG REQUIRED)
+    message(STATUS "Found OpenCASCADE config: ${OpenCASCADE_DIR}")
+    return()
+endif()
+
 # No specific paths specified, try to find package.
 if(OCC_INCLUDE_DIR AND OCC_LIBRARY_DIR)
     message(
@@ -45,23 +60,6 @@ if(OCC_INCLUDE_DIR AND OCC_LIBRARY_DIR)
     )
     string(REGEX MATCH "[0-9]+" OCC_MAINT ${OCC_MAINT})
     set(OCC_VERSION_STRING "${OCC_MAJOR}.${OCC_MINOR}.${OCC_MAINT}")
-elseif(NOT OCC_INCLUDE_DIR AND NOT OCC_LIBRARY_DIR)
-    # OCE is not supported for find_package, because it's using a different name (`oce`)
-    # and also has an odd directory structure (install/lib/oce-0.18/*.cmake).
-    find_package(OpenCASCADE CONFIG REQUIRED)
-    set(OCC_INCLUDE_DIR ${OpenCASCADE_INCLUDE_DIR})
-    # Do not use OpenCASCADE_LIBRARY_DIR for OCC_LIBRARY_DIR - check target property explicitly.
-    # On Windows there is a case with OpenCASCADE_LIBRARY_DIR points to `lib` folder,
-    # while TKernel is actually in `libi`.
-    get_target_property(TKERNEL_LIB_PATH TKernel LOCATION)
-    get_filename_component(OCC_LIBRARY_DIR "${TKERNEL_LIB_PATH}" DIRECTORY)
-    set(OCC_VERSION_STRING ${OpenCASCADE_VERSION})
-    message(
-        STATUS
-        "Found Open CASCADE package at '${OpenCASCADE_DIR}', "
-        "deducing from it OCC_INCLUDE_DIR: '${OCC_INCLUDE_DIR}' "
-        "and OCC_LIBRARY_DIR: '${OCC_LIBRARY_DIR}'."
-    )
 else()
     message(
         FATAL_ERROR
@@ -88,9 +86,7 @@ else(OCC_VERSION_STRING VERSION_LESS 7.8.0)
     list(APPEND OpenCASCADE_LIBRARIES TKDESTEP TKDEIGES)
 endif(OCC_VERSION_STRING VERSION_LESS 7.8.0)
 
-clear_wasm_sysroot()
 find_library(libTKernel NAMES TKernel TKerneld PATHS ${OCC_LIBRARY_DIR} NO_DEFAULT_PATH)
-restore_wasm_sysroot()
 
 if(libTKernel)
     message(STATUS "Required Open Cascade Library files found")
@@ -101,15 +97,6 @@ else()
     )
 endif()
 
-# Use the found libTKernel as a template for all other OCC libraries
-# TODO Extract this into macro/function
-foreach(lib ${OpenCASCADE_LIBRARIES})
-    # Make sure we'll handle the Windows/MSVC debug postfix convention too.
-    string(REPLACE TKerneld "${lib}" lib_path "${libTKernel}")
-    string(REPLACE TKernel "${lib}" lib_path "${lib_path}")
-    list(APPEND OpenCASCADE_LIBRARIES "${lib_path}")
-endforeach()
-
 if(MSVC)
     add_definitions(-DHAVE_NO_DLL)
     add_debug_variants(OpenCASCADE_LIBRARIES "${OpenCASCADE_LIBRARIES}" d)
@@ -149,3 +136,9 @@ if(OCCT_STATIC)
         set(OpenCASCADE_LIBRARIES ${OpenCASCADE_LIBRARIES} "dl")
     endif()
 endif()
+
+add_library(OpenCASCADE_INTERFACE INTERFACE IMPORTED)
+target_include_directories(OpenCASCADE_INTERFACE INTERFACE "${OCC_INCLUDE_DIR}")
+target_link_libraries(OpenCASCADE_INTERFACE INTERFACE ${OpenCASCADE_LIBRARIES})
+target_link_directories(OpenCASCADE_INTERFACE INTERFACE "${OCC_LIBRARY_DIR}")
+set(OpenCASCADE_LIBRARIES OpenCASCADE_INTERFACE)

cmake/FindOpenCOLLADA.cmake

@@ -0,0 +1,118 @@
+
+#
+# Input variables:
+# - `OPENCOLLADA_INCLUDE_DIR`
+# - `OPENCOLLADA_LIBRARY_DIR`
+# - `PCRE_LIBRARY_DIR`
+# If input variables are not specified, try to find OpenCOLLADA config.
+# Input variables could also be provided as environment variables.
+#
+# Output variables:
+# - `OPENCOLLADA_INCLUDE_DIR`
+# - `OPENCOLLADA_LIBRARY_DIR`
+# - `OPENCOLLADA_LIBRARIES`
+#
+
+UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_INCLUDE_DIR)
+UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_LIBRARY_DIR)
+UNIFY_ENVVARS_AND_CACHE(PCRE_LIBRARY_DIR)
+
+if(NOT OPENCOLLADA_INCLUDE_DIR AND NOT OPENCOLLADA_LIBRARY_DIR)
+    # If package is found, automatically sets
+    # OPENCOLLADA_INCLUDE_DIRS and OPENCOLLADA_LIBRARIES (list of targets, not paths).
+    find_package(OpenCOLLADA CONFIG)
+    if(OpenCOLLADA_DIR)
+        message(STATUS "Found OpenCOLLADA: '${OpenCOLLADA_DIR}'.")
+        set(OPENCOLLADA_FOUND TRUE)
+    else()
+        message(STATUS "OpenCOLLADA package not found, falling back to manual search.")
+    endif()
+endif()
+
+if(NOT OpenCOLLADA_DIR)
+    # Find OpenCOLLADA
+    if("${OPENCOLLADA_INCLUDE_DIR}" STREQUAL "")
+        message(STATUS "No OpenCOLLADA include directory specified")
+        set(OPENCOLLADA_INCLUDE_DIR "/usr/include/opencollada" CACHE FILEPATH "OpenCOLLADA header files")
+    else()
+        set(OPENCOLLADA_INCLUDE_DIR "${OPENCOLLADA_INCLUDE_DIR}" CACHE FILEPATH "OpenCOLLADA header files")
+    endif()
+
+    if("${OPENCOLLADA_LIBRARY_DIR}" STREQUAL "")
+        message(STATUS "No OpenCOLLADA library directory specified")
+        find_library(OPENCOLLADA_FRAMEWORK_LIB NAMES OpenCOLLADAFramework
+            PATHS /usr/lib64/opencollada /usr/lib/opencollada /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib)
+        get_filename_component(OPENCOLLADA_LIBRARY_DIR ${OPENCOLLADA_FRAMEWORK_LIB} PATH)
+    endif()
+
+    find_library(OpenCOLLADAFramework NAMES OpenCOLLADAFramework OpenCOLLADAFrameworkd PATHS ${OPENCOLLADA_LIBRARY_DIR} NO_DEFAULT_PATH)
+
+    if(OpenCOLLADAFramework)
+        message(STATUS "OpenCOLLADA library files found")
+    else()
+        message(FATAL_ERROR "COLLADA_SUPPORT enabled, but unable to find OpenCOLLADA libraries. "
+            "Disable COLLADA_SUPPORT or fix OpenCOLLADA paths to proceed.")
+    endif()
+
+    set(OPENCOLLADA_LIBRARY_DIR "${OPENCOLLADA_LIBRARY_DIR}" CACHE FILEPATH "OpenCOLLADA library files")
+
+    set(OPENCOLLADA_INCLUDE_DIRS "${OPENCOLLADA_INCLUDE_DIR}/COLLADABaseUtils" "${OPENCOLLADA_INCLUDE_DIR}/COLLADAStreamWriter")
+
+    find_file(COLLADASWStreamWriter_h "COLLADASWStreamWriter.h" ${OPENCOLLADA_INCLUDE_DIRS})
+
+    if(COLLADASWStreamWriter_h)
+        message(STATUS "OpenCOLLADA header files found")
+        set(OPENCOLLADA_FOUND TRUE)
+
+        set(OPENCOLLADA_LIBRARY_NAMES
+            GeneratedSaxParser MathMLSolver OpenCOLLADABaseUtils OpenCOLLADAFramework OpenCOLLADASaxFrameworkLoader
+            OpenCOLLADAStreamWriter UTF buffer ftoa
+        )
+
+        # Use the found OpenCOLLADAFramework as a template for all other OpenCOLLADA libraries
+        foreach(lib ${OPENCOLLADA_LIBRARY_NAMES})
+            # Make sure we'll handle the Windows/MSVC debug postfix convention too.
+            string(REPLACE OpenCOLLADAFrameworkd "${lib}" lib_path "${OpenCOLLADAFramework}")
+            string(REPLACE OpenCOLLADAFramework "${lib}" lib_path "${lib_path}")
+            list(APPEND OPENCOLLADA_LIBRARIES "${lib_path}")
+        endforeach()
+
+        if("${PCRE_LIBRARY_DIR}" STREQUAL "")
+            if(WIN32)
+                find_library(pcre_library NAMES pcre pcred PATHS ${OPENCOLLADA_LIBRARY_DIR} NO_DEFAULT_PATH)
+            else()
+                find_library(pcre_library NAMES pcre PATHS ${OPENCOLLADA_LIBRARY_DIR})
+            endif()
+
+            get_filename_component(PCRE_LIBRARY_DIR ${pcre_library} PATH)
+        else()
+            find_library(pcre_library NAMES pcre pcred PATHS ${PCRE_LIBRARY_DIR} NO_DEFAULT_PATH)
+        endif()
+
+        if(pcre_library)
+            set(OPENCOLLADA_LIBRARY_DIR ${OPENCOLLADA_LIBRARY_DIR} ${PCRE_LIBRARY_DIR})
+
+            if(MSVC)
+                # Add release lib regardless whether release or debug found. Debug version will be appended below.
+                list(APPEND OPENCOLLADA_LIBRARIES "${PCRE_LIBRARY_DIR}/pcre.lib")
+            else()
+                list(APPEND OPENCOLLADA_LIBRARIES "${pcre_library}")
+            endif()
+        else()
+            message(FATAL_ERROR "COLLADA_SUPPORT enabled, but unable to find PCRE. "
+                "Disable COLLADA_SUPPORT or fix PCRE_LIBRARY_DIR path to proceed.")
+        endif()
+
+        if(MSVC)
+            add_debug_variants(OPENCOLLADA_LIBRARIES "${OPENCOLLADA_LIBRARIES}" d)
+        endif()
+    else()
+        message(FATAL_ERROR "COLLADA_SUPPORT enabled, but unable to find OpenCOLLADA headers. "
+            "Disable COLLADA_SUPPORT or fix OpenCOLLADA paths to proceed.")
+    endif()
+endif(NOT OpenCOLLADA_DIR)
+
+if(OPENCOLLADA_FOUND)
+    add_definitions(-DWITH_OPENCOLLADA)
+    set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_OPENCOLLADA)
+endif()

nix/build-all.py

@@ -243,7 +243,9 @@ if WASM:
     # Pyodide still in transition from `FLAGS` to `FLAGS_INIT`.
     # `FLAGS_INIT` allow us to provide flags using environment variables
     # and providing `FLAGS` directly would break pyodide toolchain.
-    WASM_CMAKE_IS_USING_INIT_VARS = get_pyodide_build_version() >= (0, 30, 8)
+    # NOTE: changes in pyodide-build currently got postponed:
+    # https://github.com/pyodide/pyodide-build/pull/249
+    WASM_CMAKE_IS_USING_INIT_VARS = get_pyodide_build_version() >= (99, 0, 0)
 
     # pyodide provide empty `CXXFLAGS`, leading to issues using C++ files compiled with `-fexceptions`
     # which is used by OCCT.

src/bonsai/bonsai/__init__.py

@@ -98,7 +98,7 @@ def initialize_bbim_semver():
 def get_debug_info():
     bbim_version = bbim_semver["version"]
 
-    return {
+    debug_info = {
         "os": platform.system(),
         "os_version": platform.version(),
         "python_version": platform.python_version(),
@@ -113,6 +113,25 @@ def get_debug_info():
         "last_error": last_error,
     }
 
+    # Add .blend file save information
+    if bpy.data.is_saved:
+        debug_info["blend_file_path"] = bpy.data.filepath
+        debug_info["blend_file_dirty"] = bpy.data.is_dirty
+    else:
+        debug_info["blend_file_path"] = "Not saved"
+        debug_info["blend_file_dirty"] = "N/A"
+
+    # Add IFC file information
+    bim_props = tool.Blender.get_bim_props()
+    if bim_props.ifc_file:
+        debug_info["ifc_file_path"] = bim_props.ifc_file
+        debug_info["ifc_is_dirty"] = bim_props.is_dirty
+    else:
+        debug_info["ifc_file_path"] = "No IFC loaded"
+        debug_info["ifc_is_dirty"] = "N/A"
+
+    return debug_info
+
 
 def format_debug_info(info: dict):
     last_actions = ""

src/bonsai/bonsai/bim/__init__.py

@@ -21,7 +21,7 @@ import bpy
 import bpy.utils.previews
 import importlib
 from bpy_extras.io_utils import ImportHelper, ExportHelper
-from . import handler, ui, prop, operator
+from . import handler, ui, prop, operator, gizmo
 from typing import Union
 from collections.abc import Callable
 
@@ -148,7 +148,11 @@ classes = [
     ui.BIM_UL_clipping_plane,
     ui.BIM_UL_generic,
     ui.DocPreferences,
-    ui.BIM_ADDON_preferences,
+    ui.GizmoPreferencesDoor,  # Register before GizmoPreferences
+    ui.GizmoPreferencesWindow,  # Register before GizmoPreferences
+    ui.GizmoPreferencesStair,  # Register before GizmoPreferences
+    ui.GizmoPreferences,
+    # ui.DefaultParameters and ui.BIM_ADDON_preferences are registered separately after modules (see late_classes below)
     # Tabs panel
     ui.BIM_PT_tabs,
     # Project overview
@@ -202,6 +206,19 @@ classes = [
     ui.BIM_PT_section_with_cappings,
     ui.BIM_PT_decorators_overlay,
     ui.BIM_PT_snappping,
+    # Gizmos
+    gizmo.BIM_OT_gizmo_value_input,
+    gizmo.GizmoArrow,
+    gizmo.GizmoArrow2D,
+    gizmo.GizmoCone,
+    gizmo.GizmoLock,
+    gizmo.GizmoArc,
+    gizmo.GizmoPen,
+    gizmo.GizmoValidate,
+    gizmo.GizmoCancel,
+    gizmo.GizmoPlus,
+    gizmo.GizmoMinus,
+    gizmo.GizmoCycle,
 ]
 
 for mod in modules.values():
@@ -225,14 +242,33 @@ def on_register(scene):
     is_registering = False
 
 
-def register():
-    for cls in classes:
+# Classes that need to be registered after modules (due to cross-module dependencies)
+late_classes = (
+    ui.DefaultParameters,  # Register before BIM_ADDON_preferences
+    ui.BIM_ADDON_preferences,
+)
+
+
+def register_classes(classes_to_register):
+    for cls in classes_to_register:
         # Prevent crashes in Blender 4.4.0, see #6420.
         if issubclass(cls, (ImportHelper, ExportHelper)):
             assert getattr(cls, "bl_description", "") or cls.__doc__, cls
 
         bpy.utils.register_class(cls)
 
+
+def unregister_classes(classes_to_unregister):
+    for cls in reversed(classes_to_unregister):
+        if getattr(cls, "is_registered", None) is None:
+            bpy.utils.unregister_class(cls)
+        elif cls.is_registered:
+            bpy.utils.unregister_class(cls)
+
+
+def register():
+    register_classes(classes)
+
     bpy.app.handlers.depsgraph_update_post.append(on_register)
     bpy.app.handlers.undo_post.append(handler.undo_post)
     bpy.app.handlers.redo_post.append(handler.redo_post)
@@ -256,6 +292,9 @@ def register():
     for mod in modules.values():
         mod.register()
 
+    # Delay registering classes that depend on module classes
+    register_classes(late_classes)
+
     wm = bpy.context.window_manager
     if wm.keyconfigs.addon:
         km = wm.keyconfigs.addon.keymaps.new(name="Window", space_type="EMPTY")
@@ -287,11 +326,7 @@ def unregister():
 
     bpy.utils.previews.remove(icons)
 
-    for cls in reversed(classes):
-        if getattr(cls, "is_registered", None) is None:
-            bpy.utils.unregister_class(cls)
-        elif cls.is_registered:
-            bpy.utils.unregister_class(cls)
+    unregister_classes(classes)
 
     bpy.app.handlers.load_post.remove(handler.load_post)
     bpy.app.handlers.load_post.remove(handler.loadIfcStore)
@@ -306,6 +341,9 @@ def unregister():
         bpy.types.UI_MT_button_context_menu.remove(ui.draw_custom_context_menu)
     bpy.types.STATUSBAR_HT_header.remove(ui.draw_statusbar)
 
+    # Unregister late classes before modules
+    unregister_classes(late_classes)
+
     for mod in reversed(list(modules.values())):
         mod.unregister()
 

src/bonsai/bonsai/bim/module/aggregate/operator.py

@@ -127,6 +127,10 @@ class BIM_OT_aggregate_unassign_object(bpy.types.Operator, tool.Ifc.Operator):
         # Second pass: delete aggregates that now have no parts
         deleted_aggregates = []
         for aggregate in aggregates_to_check:
+            # Skip spatial elements - they should not be deleted even if empty
+            if aggregate.is_a("IfcSpatialElement"):
+                continue
+
             related_objects = ifcopenshell.util.element.get_parts(aggregate)
             if len(related_objects) == 0:
                 aggregate_name = aggregate.Name or f"{aggregate.is_a()} #{aggregate.id()}"

src/bonsai/bonsai/bim/module/debug/ui.py

@@ -109,23 +109,6 @@ class BIM_PT_debug(Panel):
         row.prop(props, "display_type", text="")
         row.operator("bim.override_display_type").display = props.display_type
 
-        layout.operator("bim.purge_unused_representations")
-
-        row = layout.row(align=True)
-        row.prop(props, "ifc_class_purge", text="")
-        row.operator("bim.purge_unused_elements_by_class", text="Purge Orphaned", icon="TRASH")
-        row.operator("bim.print_unused_elements_stats", text="", icon="INFO")
-
-        if context.active_object and (data := context.active_object.data):
-            mprops = tool.Geometry.get_mesh_props(data)
-            row = layout.row()
-            row.operator("bim.get_representation_ifc_parameters")
-            for index, ifc_parameter in enumerate(mprops.ifc_parameters):
-                row = layout.row(align=True)
-                row.prop(ifc_parameter, "name", text="")
-                row.prop(ifc_parameter, "value", text="")
-                row.operator("bim.update_parametric_representation", icon="FILE_REFRESH", text="").index = index
-
         layout.label(text="Inspector:")
 
         row = layout.row(align=True)

src/bonsai/bonsai/bim/module/drawing/decoration.py

@@ -489,7 +489,7 @@ class BaseDecorator:
         self.draw_label(context, text=text, line_no=line_number_start, multiline=True, **draw_label_kwargs)
 
     @cache
-    def format_value(self, context, value, custom_unit=None):
+    def format_value(self, context, value, suppress_zero_inches=False, custom_unit=None, in_unit_length=False):
         drawing_pset_data = DrawingsData.data["active_drawing_pset_data"]
         precision = drawing_pset_data.get("MetricPrecision", None)
         if not precision:
@@ -500,8 +500,9 @@ class BaseDecorator:
             value,
             precision=precision,
             decimal_places=decimal_places,
-            suppress_zero_inches=True,
+            suppress_zero_inches=suppress_zero_inches,
             custom_unit=custom_unit,
+            in_unit_length=in_unit_length,
         )
 
     def draw_asterisk(self, context: bpy.types.Context, pos: Vector, rotation: float = 0.0, scale: float = 1.0) -> None:
@@ -743,7 +744,12 @@ class DimensionDecorator(BaseDecorator):
 
             if not show_description_only:
                 length = (v1 - v0).length
-                text = self.format_value(context, length, custom_unit=dimension_data["custom_unit"])
+                text = self.format_value(
+                    context,
+                    length,
+                    suppress_zero_inches=dimension_data["suppress_zero_inches"],
+                    custom_unit=dimension_data["custom_unit"],
+                )
                 if isinstance(self, DiameterDecorator):
                     text = "D" + text
                 text = text_prefix + text + text_suffix
@@ -1198,7 +1204,11 @@ class PlanLevelDecorator(BaseDecorator):
                 abs_z = verts[0].z
                 z = helper.get_relative_z(obj, element, abs_z)
 
-                rl = self.format_value(context, z)
+                # Z is in meters (Blender world space), convert to project units (feet)
+                unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+                z = z / unit_scale  # Convert meters to feet
+
+                rl = self.format_value(context, z, in_unit_length=True)
                 text = "{}{}".format("" if z < 0 else "+", rl)
                 return text
 
@@ -1271,7 +1281,11 @@ class SectionLevelDecorator(BaseDecorator):
 
             def get_text():
                 z = verts[0].z
-                rl = self.format_value(context, z)
+                # Z is in meters (Blender world space), convert to project units (feet)
+                unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+                z = z / unit_scale  # Convert meters to feet
+
+                rl = self.format_value(context, z, in_unit_length=True)
                 text = "RL {}{}".format("" if z < 0 else "+", rl)
                 return text
 
@@ -1739,13 +1753,27 @@ class CutDecorator:
             self.cache_camera_matrix()
             return True  # Let's be conservative
         obj = bpy.context.scene.camera
-        loc_check = np.frombuffer(eval(DecoratorData.camera_location_checksum), dtype=np.float32)
-        loc_real = np.array(obj.matrix_world.translation).flatten()
+
+        # Handle both old float64 and new float32 checksums for version compatibility
+        loc_checksum_bytes = eval(DecoratorData.camera_location_checksum)
+        if len(loc_checksum_bytes) == 24:  # Old format: 3 * 8 bytes (float64)
+            loc_check = np.frombuffer(loc_checksum_bytes, dtype=np.float64).astype(np.float32)
+        else:  # New format: 3 * 4 bytes (float32)
+            loc_check = np.frombuffer(loc_checksum_bytes, dtype=np.float32)
+
+        loc_real = np.array(obj.matrix_world.translation, dtype=np.float32).flatten()
         if not np.allclose(loc_check, loc_real, atol=1e-4):  # 0.1 mm
             self.cache_camera_matrix()
             return True
-        rot_check = np.frombuffer(eval(DecoratorData.camera_rotation_checksum), dtype=np.float32).reshape(3, 3)
-        rot_real = np.array(obj.matrix_world.to_3x3())
+
+        # Handle both old float64 and new float32 checksums for version compatibility
+        rot_checksum_bytes = eval(DecoratorData.camera_rotation_checksum)
+        if len(rot_checksum_bytes) == 72:  # Old format: 9 * 8 bytes (float64)
+            rot_check = np.frombuffer(rot_checksum_bytes, dtype=np.float64).astype(np.float32).reshape(3, 3)
+        else:  # New format: 9 * 4 bytes (float32)
+            rot_check = np.frombuffer(rot_checksum_bytes, dtype=np.float32).reshape(3, 3)
+
+        rot_real = np.array(obj.matrix_world.to_3x3(), dtype=np.float32)
         rot_dot = np.dot(rot_check, rot_real.T)
         angle_rad = np.arccos(np.clip((np.trace(rot_dot) - 1) / 2, -1, 1))
         if angle_rad > 0.0017453292519943296:  # 0.1 degrees

src/bonsai/bonsai/bim/module/drawing/helper.py

@@ -122,6 +122,45 @@ class BoundingBox:
         return retVal
 
 
+def find_best_precision(fractional_inches, max_precision=256, base_tolerance=0.0001):
+    """
+    Find the simplest fraction denominator that accurately represents the value.
+    Uses a sliding tolerance - smaller denominators get more tolerance.
+
+    :param fractional_inches: The fractional part of inches (0.0 to 1.0)
+    :param max_precision: Maximum denominator to try (256 for imperial)
+    :param base_tolerance: Base tolerance in inches (very strict)
+    :return: Best denominator (power of 2: 2, 4, 8, 16, 32, 64, 128, 256)
+    """
+    if abs(fractional_inches) < 0.00001:
+        return 1  # No fraction needed
+
+    # Try denominators from coarsest to finest: 2, 4, 8, 16, 32, 64, 128, 256
+    for exp in range(1, 9):  # 2^1 to 2^8
+        denom = 2**exp
+        if denom > max_precision:
+            break
+
+        # Find nearest numerator for this denominator
+        numer = round(fractional_inches * denom)
+
+        # Skip if numerator is 0
+        if numer == 0:
+            continue
+
+        # Check if this fraction is close enough
+        fraction_value = numer / denom
+        error = abs(fraction_value - fractional_inches)
+
+        # Very strict tolerance - only simplify if it's a near-perfect match
+        # This keeps 3/256 as 3/256, but allows floating point errors to be cleaned up
+        if error < base_tolerance:
+            return denom
+
+    # If no simpler fraction works, use max precision
+    return max_precision
+
+
 # This function stolen from https://github.com/kevancress/MeasureIt_ARCH/blob/dcf607ce0896aa2284463c6b4ae9cd023fc54cbe/measureit_arch_baseclass.py
 # MeasureIt-ARCH is GPL-v3
 def format_distance(
@@ -187,14 +226,18 @@ def format_distance(
             if unit_length == "INCHES":
                 toInches = 1
             if unit_length == "FEET":
-                toInches = 11.9999
+                toInches = 12
         else:
             toInches = 39.3700787401574887
-        inPerFoot = 11.9999
+        inPerFoot = 12.0
 
         if isArea:
             toInches = 1550
-            inPerFoot = 143.999
+            inPerFoot = 144
+
+        decInches = value * toInches
+        decFeet = decInches / 12
+
         if not precision:
             precision = 256
         elif precision == "1":
@@ -203,8 +246,6 @@ def format_distance(
             precision = int(precision.split("/")[1])
 
         base = int(precision)
-        decInches = value * toInches
-        decFeet = decInches / 12
 
         # Separate ft and inches
         # Unless Inches are the specified Length Unit or unit_fraction is False
@@ -220,20 +261,33 @@ def format_distance(
         # Separate Fractional Inches
         decInches = abs(decInches)  # ignore the sign for inches
         inches = math.floor(decInches)  # remove decimal
-        if inches != 0:
-            frac = round(base * (decInches - inches))
+
+        # Clean up floating point errors
+        fractional_inches = decInches - inches
+        tolerance = 0.01  # About 1/100 of an inch
+
+        # If the fractional part is very small, treat it as zero
+        if fractional_inches < tolerance:
+            frac = 0
+        # If very close to the next whole inch, round up
+        elif fractional_inches > (1.0 - tolerance):
+            frac = 0
+            inches += 1
         else:
-            frac = round(base * (decInches))
+            # Calculate fraction normally
+            if inches != 0:
+                frac = round(base * fractional_inches)
+            else:
+                frac = round(base * fractional_inches)
 
         # Set proper numerator and denominator
         if frac != base:
-            numcycles = int(math.log2(base))
-            for i in range(numcycles):
-                if frac % 2 == 0:
-                    frac = int(frac / 2)
-                    base = int(base / 2)
-                else:
-                    break
+            # Simplify using GCD
+            from math import gcd
+
+            divisor = gcd(int(frac), int(base))
+            frac = int(frac / divisor)
+            base = int(base / divisor)
         else:
             frac = 0
             inches += 1
@@ -252,31 +306,46 @@ def format_distance(
             frac = None
         if not isArea:
             add_inches = bool(inches) or not suppress_zero_inches or (inches == 0 and frac)
+
             tx_dist = ""
             if feet:
                 tx_dist += str(feet) + "'"
             if not feet and not add_inches:
                 tx_dist += str(feet) + "'"
-            if feet and add_inches:
+
+            # Add "0' - " when we have inches but no feet
+            # But only add " - " separator if we actually have inches to show
+            if not feet and add_inches:
+                tx_dist += "0' - "
+            elif feet and add_inches:
                 tx_dist += " - "
+
             if not feet and value < 0:
                 tx_dist += "-"
             if add_inches:
-                if feet == 0 and inches == 0:
-                    pass
+                if feet == 0 and inches == 0 and not frac:
+                    # Special case: exactly zero, show "0"
+                    tx_dist += "0"
+                elif feet == 0 and inches == 0:
+                    pass  # Has fraction, will be added below
                 else:
                     tx_dist += str(inches)
             if add_inches and frac:
                 if feet == 0 and inches == 0:
-                    pass
+                    pass  # Has fraction, will be added below
                 else:
                     tx_dist += " "
             if frac:
                 tx_dist += str(frac) + "/" + str(base)
             if add_inches or frac:
-                tx_dist += '"'
+                # Only add inch symbol if we actually added inch content
+                if inches > 0 or frac > 0 or feet == 0:
+                    tx_dist += '"'
+
             if precision == "12" and unit_system == "IMPERIAL":
                 tx_dist = str(round(decFeet)) + "'"
+            if tx_dist == '"':
+                tx_dist = "0' - 0\""
         else:
             fmt = "%1.3f"
             sq_feet = round(value * toInches / inPerFoot, 4)

src/bonsai/bonsai/bim/module/geometry/operator.py

@@ -975,6 +975,10 @@ class OverrideDelete(bpy.types.Operator):
             except:
                 continue
 
+            # Skip spatial elements - they should not be deleted even if empty
+            if aggregate.is_a("IfcSpatialElement"):
+                continue
+
             related_objects = ifcopenshell.util.element.get_parts(aggregate)
             if len(related_objects) == 0:
                 aggregate_name = aggregate.Name or f"{aggregate.is_a()} #{aggregate.id()}"
@@ -2405,6 +2409,14 @@ class OverrideModeSetObject(bpy.types.Operator, tool.Ifc.Operator):
         props = tool.Geometry.get_geometry_props()
         item = tool.Geometry.get_active_representation(obj)
         assert item
+        
+        # Fix vertex order for annotation items
+        rep_obj = props.representation_obj
+        if rep_obj:
+            element = tool.Ifc.get_entity(rep_obj)
+            if element and self._is_annotation_object(element):
+                tool.Geometry.ensure_annotation_vertex_order(obj)
+        
         if tool.Geometry.is_meshlike_item(item):
             if tool.Geometry.is_geometric_data(obj.data) and (
                 item.is_a("IfcVertex") or item.is_a("IfcEdge") or obj.data.polygons
@@ -2544,6 +2556,31 @@ class OverrideModeSetObject(bpy.types.Operator, tool.Ifc.Operator):
             props.mode = "EDIT"
         props.is_changing_mode = False
 
+    def _is_annotation_object(self, element: ifcopenshell.entity_instance) -> bool:
+        """Check if element is an annotation object that needs vertex order preservation."""
+        if not element.is_a("IfcAnnotation"):
+            return False
+        
+        # Object types that have semantic vertex order (arrow direction, text position)
+        annotation_types_with_order = {
+            "TEXT_LEADER",
+            "DIMENSION",
+            "RADIUS", 
+            "DIAMETER",
+            "ANGLE",
+            "FALL",
+            "SLOPE_ANGLE",
+            "SLOPE_FRACTION",
+            "SLOPE_PERCENT",
+            "STAIR_ARROW",
+            "PLAN_LEVEL",
+            "SECTION_LEVEL",
+            "SECTION",
+            "ELEVATION",
+        }
+        
+        return element.ObjectType in annotation_types_with_order
+
 
 class DirectProfileEdit(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.direct_profile_edit"
@@ -3370,6 +3407,17 @@ class ImportRepresentationItems(bpy.types.Operator, tool.Ifc.Operator):
 
         tool.Root.reload_item_decorator()
 
+        element = tool.Ifc.get_entity(obj)
+        if element and element.is_a("IfcAnnotation") and element.ObjectType in {
+            "TEXT_LEADER", "DIMENSION", "RADIUS", "DIAMETER", "ANGLE",
+            "FALL", "SLOPE_ANGLE", "SLOPE_FRACTION", "SLOPE_PERCENT",
+            "STAIR_ARROW", "PLAN_LEVEL", "SECTION_LEVEL", "SECTION", "ELEVATION"
+        }:
+            for item_obj_data in props.item_objs:
+                item_obj = item_obj_data.obj
+                if item_obj and isinstance(item_obj.data, bpy.types.Mesh) and item_obj.data.vertices:
+                    item_obj.data["bonsai_first_vert_co"] = item_obj.data.vertices[0].co[:]
+
 
 class UpdateItemAttributes(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.update_item_attributes"

src/bonsai/bonsai/bim/module/model/__init__.py

@@ -161,6 +161,10 @@ classes = (
     stair.FinishEditingStair,
     stair.EnableEditingStair,
     stair.RemoveStair,
+    stair.ToggleStairTotalLengthLock,
+    stair.AdjustStairTreads,
+    stair.CycleStairType,
+    stair.GizmoStairEdition,
     sverchok_modifier.CreateNewSverchokGraph,
     sverchok_modifier.UpdateDataFromSverchok,
     sverchok_modifier.DeleteSverchokGraph,
@@ -172,12 +176,17 @@ classes = (
     window.FinishEditingWindow,
     window.EnableEditingWindow,
     window.RemoveWindow,
+    window.CycleWindowType,
+    window.GizmoWindowEdition,
     door.BIM_OT_add_door,
     door.AddDoor,
     door.CancelEditingDoor,
     door.FinishEditingDoor,
     door.EnableEditingDoor,
     door.RemoveDoor,
+    door.ToggleDoorSwing,
+    door.CycleDoorType,
+    door.GizmoDoorEdition,
     railing.BIM_OT_add_railing,
     railing.CopyRailingParameters,
     railing.AddRailing,

src/bonsai/bonsai/bim/module/model/door.py

@@ -33,13 +33,15 @@ import bonsai.core.geometry
 import bonsai.core.geometry as core
 import bonsai.core.root
 from bonsai.bim.module.model.window import create_bm_window, create_bm_box
+from bonsai.bim import gizmo
+from bonsai.bim.gizmo import GizmoPropConfig
 
 from mathutils import Vector, Matrix
-from typing import Union, Any, Optional
 
 import json
 import collections
 import collections.abc
+from typing import get_args
 
 V_ = tool.Blender.V_
 
@@ -192,8 +194,8 @@ def bm_mirror(
 def create_bm_extruded_profile(
     bm: bmesh.types.BMesh,
     points: list[Vector],
-    edges: Optional[list[tuple[int, int]]] = None,
-    faces: Optional[list[list[int]]] = None,
+    edges: list[tuple[int, int]] | None = None,
+    faces: list[list[int]] | None = None,
     position: Vector = V_(0, 0, 0).freeze(),
     magnitude: float = 1.0,
     extrusion_vector: Vector = V_(0, 0, 1).freeze(),
@@ -278,7 +280,7 @@ def create_bm_door_lining(
     new_faces = [bm.faces.new([new_verts[vi] for vi in face[1]]) for face in faces]
 
     extruded = bmesh.ops.extrude_face_region(bm, geom=new_faces)
-    extrusion_vector = Vector((0, 1, 0)) * depth
+    extrusion_vector = V_(0, 1, 0) * depth
     translate_verts = [v for v in extruded["geom"] if isinstance(v, bmesh.types.BMVert)]
     bmesh.ops.translate(bm, vec=extrusion_vector, verts=translate_verts)
 
@@ -291,6 +293,8 @@ def update_door_modifier_bmesh(context: bpy.types.Context) -> None:
     obj = context.active_object
     assert obj
     props = tool.Model.get_door_props(obj)
+    if not props.is_editing:
+        return
 
     overall_width = props.overall_width
     overall_height = props.overall_height
@@ -408,7 +412,10 @@ def update_door_modifier_bmesh(context: bpy.types.Context) -> None:
 
         if door_swing_type == "LEFT":
             bm_mirror(
-                bm, door_handle_verts, mirror_axes=V_(1, 0, 0), mirror_point=panel_position + V_(panel_size.x / 2, 0, 0)
+                bm,
+                door_handle_verts,
+                mirror_axes=V_(1, 0, 0),
+                mirror_point=panel_position + V_(panel_size.x / 2, 0, 0),
             )
 
         door_handle_mirrored_verts = bm_mirror(
@@ -467,6 +474,7 @@ def update_door_modifier_bmesh(context: bpy.types.Context) -> None:
     lining_offset_verts = lining_verts + door_verts + window_lining_verts + frame_verts + glass_verts
     bmesh.ops.translate(bm, vec=V_(0, lining_offset, 0), verts=lining_offset_verts)
     bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
+    bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
 
     if bpy.context.active_object.mode == "EDIT":
         bmesh.update_edit_mesh(obj.data)
@@ -482,10 +490,10 @@ class BIM_OT_add_door(bpy.types.Operator, tool.Ifc.Operator):
     bl_options = {"REGISTER", "UNDO"}
 
     @classmethod
-    def poll(cls, context):
+    def poll(cls, context: bpy.types.Context) -> bool:
         return tool.Ifc.get() and context.mode == "OBJECT"
 
-    def _execute(self, context):
+    def _execute(self, context: bpy.types.Context) -> set[str]:
         ifc_file = tool.Ifc.get()
         if not ifc_file:
             self.report({"ERROR"}, "You need to start IFC project first to create a door.")
@@ -528,6 +536,8 @@ class AddDoor(bpy.types.Operator, tool.Ifc.Operator):
         assert element
         props = tool.Model.get_door_props(obj)
 
+        tool.Blender.get_addon_preferences().default_parameters.door.copy_to(props)
+
         door_data = props.get_general_kwargs(convert_to_project_units=True)
         lining_props = props.get_lining_kwargs(convert_to_project_units=True)
         panel_props = props.get_panel_kwargs(convert_to_project_units=True)
@@ -546,7 +556,7 @@ class AddDoor(bpy.types.Operator, tool.Ifc.Operator):
         )
         update_door_modifier_representation(obj)
 
-    def _execute(self, context):
+    def _execute(self, context: bpy.types.Context) -> set[str]:
         for obj in tool.Blender.get_selected_objects():
             if not tool.Blender.Modifier.is_eligible_for_door_modifier(obj):
                 continue
@@ -557,6 +567,7 @@ class AddDoor(bpy.types.Operator, tool.Ifc.Operator):
 class CancelEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.cancel_editing_door"
     bl_label = "Cancel Editing Door on Selected Objects"
+    bl_description = "Cancel editing and revert door parameters to their previous values"
     bl_options = {"REGISTER", "UNDO"}
 
     def cancel_editing_door_on_object(self, obj: bpy.types.Object) -> None:
@@ -591,6 +602,7 @@ class CancelEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
 class FinishEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.finish_editing_door"
     bl_label = "Finish Editing Door on Selected Objects"
+    bl_description = "Apply changes and finish editing door parameters"
     bl_options = {"REGISTER", "UNDO"}
 
     def finish_editing_door_on_object(self, obj):
@@ -627,6 +639,7 @@ class FinishEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
 class EnableEditingDoor(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.enable_editing_door"
     bl_label = "Enable Editing Door on Selected Objects"
+    bl_description = "Enter edit mode to modify door parameters interactively"
     bl_options = {"REGISTER", "UNDO"}
 
     def edit_door_on_obj(self, obj):
@@ -670,3 +683,290 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
         for obj in tool.Blender.get_selected_objects():
             self.remove_door_on_object(obj)
         return {"FINISHED"}
+
+
+class ToggleDoorSwing(bpy.types.Operator, tool.Ifc.Operator):
+    """Toggle door swing direction and optionally flip door geometry.
+
+    Shift+Click (when flip_geometry=True): Flip geometry only without changing door direction"""
+
+    bl_idname = "bim.toggle_door_swing"
+    bl_label = "Toggle Door Swing"
+    bl_options = {"REGISTER", "UNDO"}
+
+    flip_geometry: bpy.props.BoolProperty(name="Flip Geometry", default=False)
+    flip_local_axes: bpy.props.EnumProperty(
+        name="Flip Local Axes", items=(("XY", "XY", ""), ("YZ", "YZ", ""), ("XZ", "XZ", "")), default="XY"
+    )
+    skip_direction_change: bpy.props.BoolProperty(
+        name="Skip Direction Change", default=False, options={"HIDDEN", "SKIP_SAVE"}
+    )
+
+    def invoke(self, context, event):
+        self.skip_direction_change = event.shift
+        return self.execute(context)
+
+    def _toggle_swing_direction(self, obj: bpy.types.Object) -> bool:
+        """Toggle door swing direction between LEFT and RIGHT."""
+        props = tool.Model.get_door_props(obj)
+        current_type = props.door_type
+
+        if "LEFT" in current_type:
+            props.door_type = current_type.replace("LEFT", "RIGHT")
+            return True
+        elif "RIGHT" in current_type:
+            props.door_type = current_type.replace("RIGHT", "LEFT")
+            return True
+        return False
+
+    def _execute(self, context):
+        obj = tool.Blender.get_active_object()
+        if not obj:
+            return {"CANCELLED"}
+
+        element = tool.Ifc.get_entity(obj)
+        if not element:
+            return {"CANCELLED"}
+
+        is_door = tool.Blender.Modifier.is_door(element)
+
+        if self.flip_geometry:
+            tool.Geometry.flip_object(obj, self.flip_local_axes)
+            if not self.skip_direction_change and is_door:
+                self._toggle_swing_direction(obj)
+        elif is_door:
+            self._toggle_swing_direction(obj)
+        else:
+            return {"CANCELLED"}
+
+        return {"FINISHED"}
+
+
+class CycleDoorType(bpy.types.Operator, tool.Ifc.Operator):
+    """Cycle through available door types. Shift+click to cycle in reverse."""
+
+    bl_idname = "bim.cycle_door_type"
+    bl_label = "Cycle Door Type"
+    bl_options = {"REGISTER", "UNDO"}
+
+    reverse: bpy.props.BoolProperty(name="Reverse", default=False, options={"HIDDEN", "SKIP_SAVE"})
+
+    def invoke(self, context, event):
+        self.reverse = event.shift
+        return self.execute(context)
+
+    def _execute(self, context):
+        obj = tool.Blender.get_active_object()
+        if not obj:
+            return {"CANCELLED"}
+
+        element = tool.Ifc.get_entity(obj)
+        if not element or not tool.Blender.Modifier.is_door(element):
+            return {"CANCELLED"}
+
+        props = tool.Model.get_door_props(obj)
+        door_types = get_args(tool.Model.DoorType)
+        current_index = door_types.index(props.door_type) if props.door_type in door_types else 0
+        direction = -1 if self.reverse else 1
+        next_index = (current_index + direction) % len(door_types)
+        props.door_type = door_types[next_index]
+
+        return {"FINISHED"}
+
+
+class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
+    bl_idname = "OBJECT_GGT_bim_door_edition"
+    bl_label = "Door Editing Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    enable_editing_operator = "bim.enable_editing_door"
+    finish_editing_operator = "bim.finish_editing_door"
+    cancel_editing_operator = "bim.cancel_editing_door"
+    cycle_type_operator = "bim.cycle_door_type"
+
+    gizmo_props = [
+        GizmoPropConfig("overall_height", (0, 0, 1)),
+        GizmoPropConfig("overall_width", (1, 0, 0)),
+        GizmoPropConfig("threshold_thickness", (0, 0, 1)),
+        GizmoPropConfig("threshold_depth", (0, 1, 0)),
+        GizmoPropConfig("lining_depth", (0, 1, 0)),
+        GizmoPropConfig("lining_thickness", (-1, 0, 0)),
+        GizmoPropConfig("transom_offset", (0, 0, 1)),
+        GizmoPropConfig("transom_thickness", (0, 0, 1)),
+        GizmoPropConfig("casing_thickness", (-1, 0, 0)),
+        GizmoPropConfig("casing_depth", (0, 1, 0)),
+    ]
+
+    @classmethod
+    def is_element_type(cls, element) -> bool:
+        return tool.Blender.Modifier.is_door(element)
+
+    def get_props(self, obj):
+        return tool.Model.get_door_props(obj)
+
+    def get_gizmo_prefs(self):
+        prefs = tool.Blender.get_addon_preferences()
+        return prefs.gizmos.door
+
+    def should_hide_gizmo(self, attr_name, props):
+        """Door-specific visibility rules for gizmos."""
+        if not props.is_editing:
+            return True
+        if attr_name == "threshold_depth" and props.threshold_thickness == 0.0:
+            return True
+        if attr_name == "transom_offset" and props.transom_thickness == 0.0:
+            return True
+        if attr_name == "casing_thickness" and props.lining_offset != 0.0:
+            return True
+        if attr_name == "casing_depth" and (props.lining_offset != 0.0 or props.casing_thickness == 0.0):
+            return True
+        return False
+
+    def get_gizmo_matrix_overall_height(self, props):
+        translation = Matrix.Translation(V_(props.overall_width - 0.05, props.lining_offset, props.overall_height))
+        rotation = self.get_axis_rotation_matrix((0, 0, 1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_overall_width(self, props):
+        translation = Matrix.Translation(V_(props.overall_width, props.lining_offset, props.overall_height - 0.05))
+        rotation = self.get_axis_rotation_matrix((1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_threshold_thickness(self, props):
+        translation = Matrix.Translation(
+            V_(
+                props.overall_width / 2,
+                props.threshold_offset + props.threshold_depth / 2 + props.lining_offset,
+                props.threshold_thickness,
+            )
+        )
+        rotation = self.get_axis_rotation_matrix((0, 0, 1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_threshold_depth(self, props):
+        translation = Matrix.Translation(
+            V_(props.overall_width / 2, props.threshold_depth + props.lining_offset, props.threshold_thickness / 2)
+        )
+        rotation = self.get_axis_rotation_matrix((0, 1, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_lining_depth(self, props):
+        translation = Matrix.Translation(
+            V_(props.overall_width / 2, props.lining_depth + props.lining_offset, props.overall_height)
+        )
+        rotation = self.get_axis_rotation_matrix((0, 1, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_lining_thickness(self, props):
+        translation = Matrix.Translation(
+            V_(props.overall_width - props.lining_thickness, props.lining_depth / 2, props.overall_height / 2)
+        )
+        rotation = self.get_axis_rotation_matrix((-1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_transom_offset(self, props):
+        # Position at the bottom of the transom (transom extends upward from offset)
+        translation = Matrix.Translation(
+            V_(props.overall_width / 2, props.lining_offset, props.transom_offset)
+        )
+        rotation = self.get_axis_rotation_matrix((0, 0, 1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_transom_thickness(self, props):
+        # Position at the top of the transom (offset + thickness)
+        translation = Matrix.Translation(
+            V_(props.overall_width / 2, props.lining_offset, props.transom_offset + props.transom_thickness)
+        )
+        rotation = self.get_axis_rotation_matrix((0, 0, 1))
+        return translation @ rotation
+
+    @staticmethod
+    def _get_casing_gizmo_base_position(props) -> tuple[float, float, float]:
+        """Get common base position for casing gizmos."""
+        x = -props.casing_thickness + props.lining_thickness
+        y_base = props.lining_depth + props.lining_offset
+        z = props.overall_height / 2
+        return x, y_base, z
+
+    def get_gizmo_matrix_casing_thickness(self, props):
+        x, y_base, z = self._get_casing_gizmo_base_position(props)
+        translation = Matrix.Translation(V_(x, y_base + props.casing_depth / 2, z))
+        rotation = self.get_axis_rotation_matrix((-1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_casing_depth(self, props):
+        x, y_base, z = self._get_casing_gizmo_base_position(props)
+        translation = Matrix.Translation(V_(x, y_base + props.casing_depth, z))
+        rotation = self.get_axis_rotation_matrix((0, 1, 0))
+        return translation @ rotation
+
+    def setup(self, context):
+        # Use base class methods for common gizmos
+        self.setup_property_gizmos(context)
+        self.setup_editing_gizmos(context)
+
+        # Door-specific: swing arc gizmos
+        prefs = tool.Blender.get_addon_preferences()
+        highlight_color = prefs.decorator_color_selected[:3]
+        inactive_color = prefs.decorator_color_background[:3]
+        special_color = prefs.decorator_color_special[:3]
+
+        self.gizmo_door_type = self.gizmos.new("VIEW3D_GT_arc")
+        self.gizmo_door_type.use_draw_scale = False
+        self.gizmo_door_type.color = special_color
+        self.gizmo_door_type.alpha = 0.5
+        self.gizmo_door_type.color_highlight = highlight_color
+        self.gizmo_door_type.prop_path = "BIMDoorProperties.door_type"
+        op = self.gizmo_door_type.target_set_operator("bim.toggle_door_swing")
+        op.flip_geometry = False
+
+        # Flip arc gizmo - mirrors the swing arc along X axis, flips door and toggles direction when clicked
+        self.gizmo_flip_arc = self.gizmos.new("VIEW3D_GT_arc")
+        self.gizmo_flip_arc.use_draw_scale = False
+        self.gizmo_flip_arc.color = inactive_color
+        self.gizmo_flip_arc.alpha = 0.5
+        self.gizmo_flip_arc.color_highlight = highlight_color
+        self.gizmo_flip_arc.prop_path = "BIMDoorProperties.door_type"
+        op = self.gizmo_flip_arc.target_set_operator("bim.toggle_door_swing")
+        op.flip_geometry = True
+        op.flip_local_axes = "XY"
+
+    def refresh(self, context):
+        obj = context.active_object
+        if not obj:
+            return
+
+        props = self.get_props(obj)
+        mw = obj.matrix_world
+        self.update_property_gizmos(mw, props)
+        self.update_swing_gizmos(mw, props)
+        self.update_editing_gizmos(context, mw, props)
+
+    def update_swing_gizmos(self, mw, props):
+        """Update swing gizmo position and color based on editing state."""
+        prefs = tool.Blender.get_addon_preferences()
+        door_gizmo_prefs = prefs.gizmos.door
+
+        self.gizmo_door_type.hide = not props.is_editing or not door_gizmo_prefs.swing_arc
+        self.gizmo_flip_arc.hide = not props.is_editing or not door_gizmo_prefs.flip_arc
+
+        # If both are hidden, no need to calculate transforms
+        if self.gizmo_door_type.hide and self.gizmo_flip_arc.hide:
+            return
+
+        # Calculate base swing transformation (common to both arcs)
+        swing_x_offset = props.overall_width if "RIGHT" in props.door_type else 0.0
+        base_swing_transform = Matrix.Translation(V_(swing_x_offset, props.lining_offset, 0)) @ Matrix.Scale(
+            props.overall_width, 4
+        )
+
+        if not self.gizmo_door_type.hide:
+            self.gizmo_door_type.matrix_basis = mw @ base_swing_transform
+            self.gizmo_door_type.color = prefs.decorations_colour[:3]
+
+        if not self.gizmo_flip_arc.hide:
+            # Mirror the flip arc along Y axis to show the opposite swing direction
+            mirror_y = Matrix.Scale(-1, 4, (0, 1, 0))
+            self.gizmo_flip_arc.matrix_basis = mw @ base_swing_transform @ mirror_y

src/bonsai/bonsai/bim/module/model/prop.py

@@ -217,7 +217,12 @@ class BIMModelProperties(PropertyGroup):
     rl3: bpy.props.FloatProperty(name="RL", default=1, subtype="DISTANCE", description="Z offset for space calculation")
     type_page: bpy.props.IntProperty(name="Type Page", default=1, min=1, update=update_type_page)
     x_angle: bpy.props.FloatProperty(
-        name="X Angle", default=0, subtype="ANGLE", min=math.radians(-180), max=math.radians(180), update=update_x_angle
+        name="X Angle",
+        default=0,
+        subtype="ANGLE",
+        min=math.radians(-180),
+        max=math.radians(180),
+        update=update_x_angle,
     )
     type_name: bpy.props.StringProperty(name="Name", default="TYPEX")
     boundary_class: bpy.props.EnumProperty(items=get_boundary_class, name="Boundary Class")
@@ -645,6 +650,15 @@ class BIMStairProperties(PropertyGroup):
         for prop_name in kwargs:
             setattr(self, prop_name, kwargs[prop_name])
 
+    def copy_to(self, target_props: "BIMStairProperties") -> None:
+        """Copy preset values to target stair properties."""
+        target_props.custom_tread_lock = self.custom_tread_lock
+        for prop_name, prop_value in self.get_props_kwargs().items():
+            # Skip custom_first_last_tread_run if it contains None values (when lock is enabled)
+            if prop_name == "custom_first_last_tread_run" and None in prop_value:
+                continue
+            setattr(target_props, prop_name, prop_value)
+
 
 class BIMSverchokProperties(PropertyGroup):
     node_group: bpy.props.PointerProperty(name="Node Group", type=NodeTree)
@@ -657,19 +671,6 @@ def window_type_prop_update(self, context):
     update_window(self, context)
 
 
-WindowType = Literal[
-    "SINGLE_PANEL",
-    "DOUBLE_PANEL_HORIZONTAL",
-    "DOUBLE_PANEL_VERTICAL",
-    "TRIPLE_PANEL_BOTTOM",
-    "TRIPLE_PANEL_TOP",
-    "TRIPLE_PANEL_LEFT",
-    "TRIPLE_PANEL_RIGHT",
-    "TRIPLE_PANEL_HORIZONTAL",
-    "TRIPLE_PANEL_VERTICAL",
-]
-
-
 # default prop values are in mm and converted later
 class BIMWindowProperties(PropertyGroup):
     non_si_units_props = (
@@ -698,7 +699,7 @@ class BIMWindowProperties(PropertyGroup):
     is_editing: bpy.props.BoolProperty(default=False)
     window_type: bpy.props.EnumProperty(
         name="Window Type",
-        items=[(i, i, "") for i in get_args(WindowType)],
+        items=[(i, i, "") for i in get_args(tool.Model.WindowType)],
         default="SINGLE_PANEL",
         update=window_type_prop_update,
     )
@@ -708,9 +709,11 @@ class BIMWindowProperties(PropertyGroup):
     overall_width: bpy.props.FloatProperty(name="Overall Width", default=0.6, subtype="DISTANCE", update=update_window)
 
     # lining properties
-    lining_depth: bpy.props.FloatProperty(name="Lining Depth", default=0.050, subtype="DISTANCE", update=update_window)
+    lining_depth: bpy.props.FloatProperty(
+        name="Lining Depth", default=0.050, min=0.001, subtype="DISTANCE", update=update_window
+    )
     lining_thickness: bpy.props.FloatProperty(
-        name="Lining Thickness", default=0.050, subtype="DISTANCE", update=update_window
+        name="Lining Thickness", default=0.050, min=0.001, subtype="DISTANCE", update=update_window
     )
     lining_offset: bpy.props.FloatProperty(
         name="Lining Offset", default=0.050, subtype="DISTANCE", update=update_window
@@ -739,12 +742,13 @@ class BIMWindowProperties(PropertyGroup):
         update=update_window,
     )
     transom_thickness: bpy.props.FloatProperty(
-        name="Transom Thickness", default=0.050, subtype="DISTANCE", update=update_window
+        name="Transom Thickness", default=0.050, min=0.001, subtype="DISTANCE", update=update_window
     )
     first_transom_offset: bpy.props.FloatProperty(
         name="First Transom Offset",
         description="Distance from the first lining to the first transom center",
         default=0.3,
+        min=0.001,
         subtype="DISTANCE",
         update=update_window,
     )
@@ -771,7 +775,7 @@ class BIMWindowProperties(PropertyGroup):
 
     if TYPE_CHECKING:
         is_editing: bool
-        window_type: WindowType
+        window_type: tool.Model.WindowType
         overall_height: float
         overall_width: float
         lining_depth: float
@@ -805,7 +809,7 @@ class BIMWindowProperties(PropertyGroup):
         return tool.Model.convert_data_to_project_units(kwargs, ["window_type"])
 
     def get_lining_kwargs(
-        self, window_type: Optional[WindowType] = None, convert_to_project_units: bool = False
+        self, window_type: Optional[tool.Model.WindowType] = None, convert_to_project_units: bool = False
     ) -> dict[str, Any]:
         if not window_type:
             window_type = self.window_type
@@ -863,17 +867,13 @@ class BIMWindowProperties(PropertyGroup):
         for prop_name in kwargs:
             setattr(self, prop_name, kwargs[prop_name])
 
-
-DoorType = Literal[
-    "SINGLE_SWING_LEFT",
-    "SINGLE_SWING_RIGHT",
-    "DOUBLE_SWING_LEFT",
-    "DOUBLE_SWING_RIGHT",
-    "DOUBLE_DOOR_SINGLE_SWING",
-    "SLIDING_TO_LEFT",
-    "SLIDING_TO_RIGHT",
-    "DOUBLE_DOOR_SLIDING",
-]
+    def copy_to(self, target_props: "BIMWindowProperties") -> None:
+        """Copy preset values to target window properties, excluding materials."""
+        exclude_props = {"lining_material", "framing_material", "glazing_material"}
+        for kwargs_dict in (self.get_general_kwargs(), self.get_lining_kwargs(), self.get_panel_kwargs()):
+            for prop_name, prop_value in kwargs_dict.items():
+                if prop_name not in exclude_props:
+                    setattr(target_props, prop_name, prop_value)
 
 
 class BIMDoorProperties(PropertyGroup):
@@ -888,17 +888,39 @@ class BIMDoorProperties(PropertyGroup):
     is_editing: bpy.props.BoolProperty(default=False)
     door_type: bpy.props.EnumProperty(
         name="Door Operation Type",
-        items=tuple((i, i, "") for i in get_args(DoorType)),
+        items=tuple((i, i, "") for i in get_args(tool.Model.DoorType)),
         default="SINGLE_SWING_LEFT",
         update=update_door,
     )
-    overall_height: bpy.props.FloatProperty(name="Overall Height", default=2.0, subtype="DISTANCE", update=update_door)
-    overall_width: bpy.props.FloatProperty(name="Overall Width", default=0.9, subtype="DISTANCE", update=update_door)
+    overall_height: bpy.props.FloatProperty(
+        name="Overall Height",
+        default=2.0,
+        min=0,
+        subtype="DISTANCE",
+        update=update_door,
+    )
+    overall_width: bpy.props.FloatProperty(
+        name="Overall Width",
+        default=0.9,
+        min=0,
+        subtype="DISTANCE",
+        update=update_door,
+    )
 
     # lining properties
-    lining_depth: bpy.props.FloatProperty(name="Lining Depth", default=0.050, subtype="DISTANCE", update=update_door)
+    lining_depth: bpy.props.FloatProperty(
+        name="Lining Depth",
+        default=0.050,
+        min=0.001,
+        subtype="DISTANCE",
+        update=update_door,
+    )
     lining_thickness: bpy.props.FloatProperty(
-        name="Lining Thickness", default=0.050, subtype="DISTANCE", update=update_door
+        name="Lining Thickness",
+        default=0.050,
+        min=0.001,
+        subtype="DISTANCE",
+        update=update_door,
     )
     lining_offset: bpy.props.FloatProperty(
         name="Lining Offset",
@@ -920,6 +942,7 @@ class BIMDoorProperties(PropertyGroup):
         name="Transom Thickness",
         description="Set values > 0 to add a transom.\n" "`0.050 mm` is good as default value",
         default=0.000,
+        min=0,
         subtype="DISTANCE",
         update=update_door,
     )
@@ -927,6 +950,7 @@ class BIMDoorProperties(PropertyGroup):
         name="Transom Offset",
         description="Distance from the bottom door opening to the beginning of the transom (unlike windows)",
         default=1.525,
+        min=0,
         subtype="DISTANCE",
         update=update_door,
     )
@@ -935,20 +959,32 @@ class BIMDoorProperties(PropertyGroup):
         name="Casing Thickness",
         description="Set values > 0 and LiningOffset = 0 to add a casing.",
         default=0.075,
+        min=0,
+        subtype="DISTANCE",
+        update=update_door,
+    )
+    casing_depth: bpy.props.FloatProperty(
+        name="Casing Depth",
+        default=0.005,
+        min=0.001,
         subtype="DISTANCE",
         update=update_door,
     )
-    casing_depth: bpy.props.FloatProperty(name="Casing Depth", default=0.005, subtype="DISTANCE", update=update_door)
 
     threshold_thickness: bpy.props.FloatProperty(
         name="Threshold Thickness",
         description="Set values > 0 to add a threshold.",
         default=0.025,
+        min=0,
         subtype="DISTANCE",
         update=update_door,
     )
     threshold_depth: bpy.props.FloatProperty(
-        name="Threshold Depth", default=0.1, subtype="DISTANCE", update=update_door
+        name="Threshold Depth",
+        default=0.1,
+        min=0.001,
+        subtype="DISTANCE",
+        update=update_door,
     )
     threshold_offset: bpy.props.FloatProperty(
         name="Threshold Offset",
@@ -959,7 +995,13 @@ class BIMDoorProperties(PropertyGroup):
     )
 
     # panel properties
-    panel_depth: bpy.props.FloatProperty(name="Panel Depth", default=0.035, subtype="DISTANCE", update=update_door)
+    panel_depth: bpy.props.FloatProperty(
+        name="Panel Depth",
+        default=0.035,
+        min=0,
+        subtype="DISTANCE",
+        update=update_door,
+    )
     panel_width_ratio: bpy.props.FloatProperty(
         name="Panel Width Ratio",
         description="Width of this panel, given as ratio " "relative to the total clear opening width of the door",
@@ -969,10 +1011,18 @@ class BIMDoorProperties(PropertyGroup):
         update=update_door,
     )
     frame_thickness: bpy.props.FloatProperty(
-        name="Window Frame Thickness", default=0.035, subtype="DISTANCE", update=update_door
+        name="Window Frame Thickness",
+        default=0.035,
+        min=0,
+        subtype="DISTANCE",
+        update=update_door,
     )
     frame_depth: bpy.props.FloatProperty(
-        name="Window Frame Depth", default=0.035, subtype="DISTANCE", update=update_door
+        name="Window Frame Depth",
+        default=0.035,
+        min=0,
+        subtype="DISTANCE",
+        update=update_door,
     )
 
     # Material properties
@@ -982,7 +1032,7 @@ class BIMDoorProperties(PropertyGroup):
 
     if TYPE_CHECKING:
         is_editing: bool
-        door_type: DoorType
+        door_type: tool.Model.DoorType
         overall_height: float
         overall_width: float
 
@@ -1080,6 +1130,14 @@ class BIMDoorProperties(PropertyGroup):
         for prop_name in kwargs:
             setattr(self, prop_name, kwargs[prop_name])
 
+    def copy_to(self, target_props: "BIMDoorProperties") -> None:
+        """Copy properties to target door properties, excluding materials."""
+        exclude_props = {"lining_material", "framing_material", "glazing_material"}
+        for kwargs_dict in (self.get_general_kwargs(), self.get_lining_kwargs(), self.get_panel_kwargs()):
+            for prop_name, prop_value in kwargs_dict.items():
+                if prop_name not in exclude_props:
+                    setattr(target_props, prop_name, prop_value)
+
 
 RailingType = Literal["FRAMELESS_PANEL", "WALL_MOUNTED_HANDRAIL"]
 CapType = Literal["TO_END_POST_AND_FLOOR", "TO_END_POST", "TO_FLOOR", "TO_WALL", "180", "NONE"]
@@ -1179,6 +1237,11 @@ class BIMRailingProperties(PropertyGroup):
         for prop_name in kwargs:
             setattr(self, prop_name, kwargs[prop_name])
 
+    def copy_to(self, target_props: "BIMRailingProperties") -> None:
+        """Copy preset values to target railing properties."""
+        for prop_name, prop_value in self.get_general_kwargs().items():
+            setattr(target_props, prop_name, prop_value)
+
 
 def to_angle(percentage: float) -> float:
     return math.atan(percentage / 100)
@@ -1281,6 +1344,11 @@ class BIMRoofProperties(PropertyGroup):
         for prop_name in kwargs:
             setattr(self, prop_name, kwargs[prop_name])
 
+    def copy_to(self, target_props: "BIMRoofProperties") -> None:
+        """Copy preset values to target roof properties."""
+        for prop_name, prop_value in self.get_general_kwargs().items():
+            setattr(target_props, prop_name, prop_value)
+
 
 class SnapMousePoint(PropertyGroup):
     x: bpy.props.FloatProperty(name="X")

src/bonsai/bonsai/bim/module/model/railing.py

@@ -106,6 +106,13 @@ def update_railing_modifier_ifc_data(context: bpy.types.Context) -> None:
         model_representation = ifcopenshell.api.geometry.add_railing_representation(ifc_file, **representation_data)
         tool.Model.replace_object_ifc_representation(body, obj, model_representation)
 
+        # recalculate normals to ensure correct shading
+        mesh = obj.data
+        if isinstance(mesh, bpy.types.Mesh):
+            bm = tool.Blender.get_bmesh_for_mesh(mesh, clean=False)
+            bmesh.ops.recalc_face_normals(bm, faces=bm.faces[:])
+            tool.Blender.apply_bmesh(mesh, bm)
+
     elif props.railing_type == "FRAMELESS_PANEL":
         tool.Model.add_body_representation(obj)
 
@@ -335,6 +342,8 @@ class AddRailing(bpy.types.Operator, tool.Ifc.Operator):
         props = tool.Model.get_railing_props(obj)
         si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
 
+        tool.Blender.get_addon_preferences().default_parameters.railing.copy_to(props)
+
         railing_data = props.get_general_kwargs(convert_to_project_units=True)
         path_data = get_path_data(obj)
 

src/bonsai/bonsai/bim/module/model/roof.py

@@ -570,6 +570,8 @@ class AddRoof(bpy.types.Operator, tool.Ifc.Operator):
         props = tool.Model.get_roof_props(obj)
         si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
 
+        tool.Blender.get_addon_preferences().default_parameters.roof.copy_to(props)
+
         # rejecting original roof shape to be safe
         # taking into account only it's bounding box dimensions
         if obj.dimensions.x == 0 or obj.dimensions.y == 0:

src/bonsai/bonsai/bim/module/model/stair.py

@@ -19,6 +19,7 @@
 import bpy
 import json
 import bmesh
+import math
 import ifcopenshell
 import ifcopenshell.api.pset
 import ifcopenshell.util.element
@@ -26,11 +27,14 @@ import ifcopenshell.util.representation
 import ifcopenshell.util.unit
 import bonsai.core.root
 import bonsai.tool as tool
-from mathutils import Vector
+from bonsai.bim import gizmo
+from bonsai.bim.gizmo import GizmoPropConfig
+from mathutils import Vector, Matrix
 from bmesh.types import BMVert
 from bpy.types import Operator
 from bpy.props import FloatProperty, IntProperty
 from bpy_extras.object_utils import AddObjectHelper, object_data_add
+from typing import get_args
 
 
 def regenerate_stair_mesh(obj: bpy.types.Object) -> None:
@@ -188,6 +192,8 @@ class AddStair(bpy.types.Operator, tool.Ifc.Operator):
         props = tool.Model.get_stair_props(obj)
         ifc_file = tool.Ifc.get()
 
+        tool.Blender.get_addon_preferences().default_parameters.stair.copy_to(props)
+
         # Use the special method that includes custom_tread_lock for IFC storage
         stair_data = props.get_props_kwargs_for_ifc_export(convert_to_project_units=True)
         pset = tool.Pset.get_element_pset(element, "BBIM_Stair")
@@ -291,3 +297,388 @@ class RemoveStair(bpy.types.Operator, tool.Ifc.Operator):
         ifcopenshell.api.pset.remove_pset(tool.Ifc.get(), product=element, pset=pset)
 
         return {"FINISHED"}
+
+
+class ToggleStairTotalLengthLock(bpy.types.Operator):
+    """Toggle the total length lock for stair editing"""
+
+    bl_idname = "bim.toggle_stair_total_length_lock"
+    bl_label = "Toggle Stair Total Length Lock"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        obj = context.active_object
+        if not obj:
+            return {"CANCELLED"}
+
+        props = tool.Model.get_stair_props(obj)
+        props.total_length_lock = not props.total_length_lock
+
+        return {"FINISHED"}
+
+
+class AdjustStairTreads(bpy.types.Operator):
+    """Adjust the number of treads"""
+
+    bl_idname = "bim.adjust_stair_treads"
+    bl_label = "Adjust Stair Treads"
+    bl_options = {"REGISTER", "UNDO"}
+
+    increment: IntProperty(name="Increment", default=1)
+
+    def execute(self, context):
+        obj = context.active_object
+        if not obj:
+            return {"CANCELLED"}
+
+        props = tool.Model.get_stair_props(obj)
+        new_value = props.number_of_treads + self.increment
+        if new_value >= 1:
+            props.number_of_treads = new_value
+
+        return {"FINISHED"}
+
+
+class CycleStairType(bpy.types.Operator):
+    """Cycle through stair types. Shift+click to cycle in reverse."""
+
+    bl_idname = "bim.cycle_stair_type"
+    bl_label = "Cycle Stair Type"
+    bl_options = {"REGISTER", "UNDO"}
+
+    reverse: bpy.props.BoolProperty(name="Reverse", default=False, options={"HIDDEN", "SKIP_SAVE"})
+
+    def invoke(self, context, event):
+        self.reverse = event.shift
+        return self.execute(context)
+
+    def execute(self, context):
+        obj = context.active_object
+        if not obj:
+            return {"CANCELLED"}
+
+        props = tool.Model.get_stair_props(obj)
+        stair_types = get_args(tool.Model.StairType)
+        current_idx = stair_types.index(props.stair_type) if props.stair_type in stair_types else 0
+        direction = -1 if self.reverse else 1
+        props.stair_type = stair_types[(current_idx + direction) % len(stair_types)]
+
+        return {"FINISHED"}
+
+
+class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
+    bl_idname = "OBJECT_GGT_bim_stair_edition"
+    bl_label = "Stair Editing Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    # Gizmo layout offsets (meters)
+    GIZMO_X_OFFSET = 0.5  # Horizontal offset from stair end
+    GIZMO_PLUS_X_OFFSET = 0.25  # Additional X offset for plus button
+    GIZMO_MINUS_X_OFFSET = 0.5  # Additional X offset for minus button
+    GIZMO_BUTTON_Z_OFFSET = 0.15  # Vertical offset for +/- buttons above lock
+    GIZMO_CYCLE_Z_OFFSET = 0.5  # Vertical offset for cycle gizmo above lock
+
+    enable_editing_operator = "bim.enable_editing_stair"
+    finish_editing_operator = "bim.finish_editing_stair"
+    cancel_editing_operator = "bim.cancel_editing_stair"
+
+    gizmo_props = [
+        GizmoPropConfig("width", (0, 1, 0)),
+        GizmoPropConfig("height", (0, 0, 1)),
+        GizmoPropConfig("tread_run", (1, 0, 0)),
+        GizmoPropConfig("tread_depth", (0, 0, -1)),
+        GizmoPropConfig("nosing_length", (-1, 0, 0)),
+        GizmoPropConfig("nosing_depth", (0, 0, -1)),
+        GizmoPropConfig("total_length_target", (1, 0, 0)),
+        GizmoPropConfig("base_slab_depth", (0, 0, -1)),
+        GizmoPropConfig("top_slab_depth", (0, 0, -1)),
+    ]
+
+    @classmethod
+    def is_element_type(cls, element) -> bool:
+        return tool.Blender.Modifier.is_stair(element)
+
+    def get_props(self, obj):
+        return tool.Model.get_stair_props(obj)
+
+    def get_gizmo_prefs(self):
+        prefs = tool.Blender.get_addon_preferences()
+        return prefs.gizmos.stair
+
+    def should_hide_gizmo(self, attr_name, props):
+        """Stair-specific visibility rules for gizmos."""
+        if not props.is_editing:
+            return True
+        # Hide concrete-specific gizmos for non-concrete stairs
+        if attr_name in ("base_slab_depth", "top_slab_depth") and props.stair_type != "CONCRETE":
+            return True
+        # Hide tread_depth for generic stairs (has no tread geometry)
+        if attr_name == "tread_depth" and props.stair_type == "GENERIC":
+            return True
+        # Hide nosing_depth when nosing_length is 0 or for Wood/Steel stair types
+        if attr_name == "nosing_depth" and (props.nosing_length == 0.0 or props.stair_type == "WOOD/STEEL"):
+            return True
+        return False
+
+    @staticmethod
+    def _get_stair_total_run(props) -> float:
+        """Calculate the total horizontal run of the stair."""
+        return props.tread_run * props.number_of_treads
+
+    @staticmethod
+    def _get_first_riser_height(props) -> float:
+        """Calculate the height of the first riser."""
+        return props.height / (props.number_of_treads + 1)
+
+    def get_gizmo_matrix_width(self, props):
+        translation = Matrix.Translation(Vector((0, props.width, 0)))
+        rotation = self.get_axis_rotation_matrix((0, 1, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_width_top(self, props):
+        """Position for the secondary width gizmo at the top of the stairs."""
+        total_run = self._get_stair_total_run(props)
+        translation = Matrix.Translation(Vector((total_run, props.width, props.height)))
+        rotation = self.get_axis_rotation_matrix((0, 1, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_height(self, props):
+        total_run = self._get_stair_total_run(props)
+        translation = Matrix.Translation(Vector((total_run, props.width / 2, props.height)))
+        rotation = self.get_axis_rotation_matrix((0, 0, 1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_tread_run(self, props):
+        riser_height = self._get_first_riser_height(props)
+        translation = Matrix.Translation(Vector((props.tread_run, props.width / 2, riser_height)))
+        rotation = self.get_axis_rotation_matrix((1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_tread_depth(self, props):
+        riser_height = self._get_first_riser_height(props)
+        translation = Matrix.Translation(
+            Vector((props.tread_run / 2, props.width / 2, riser_height - props.tread_depth))
+        )
+        rotation = self.get_axis_rotation_matrix((0, 0, -1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_nosing_length(self, props):
+        riser_height = self._get_first_riser_height(props)
+        translation = Matrix.Translation(Vector((-props.nosing_length, props.width / 2, riser_height)))
+        rotation = self.get_axis_rotation_matrix((-1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_nosing_depth(self, props):
+        riser_height = self._get_first_riser_height(props)
+        translation = Matrix.Translation(
+            Vector((-props.nosing_length, props.width / 2, riser_height - props.nosing_depth))
+        )
+        rotation = self.get_axis_rotation_matrix((0, 0, -1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_total_length_target(self, props):
+        translation = Matrix.Translation(Vector((props.total_length_target, props.width / 2, props.height)))
+        rotation = self.get_axis_rotation_matrix((1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_base_slab_depth(self, props):
+        translation = Matrix.Translation(Vector((0, props.width / 2, -props.base_slab_depth)))
+        rotation = self.get_axis_rotation_matrix((0, 0, -1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_top_slab_depth(self, props):
+        total_run = self._get_stair_total_run(props)
+        translation = Matrix.Translation(Vector((total_run, props.width / 2, props.height - props.top_slab_depth)))
+        rotation = self.get_axis_rotation_matrix((0, 0, -1))
+        return translation @ rotation
+
+    def setup(self, context):
+        self.setup_property_gizmos(context)
+        self.setup_editing_gizmos(context)
+
+        # Stair-specific gizmos
+        prefs = tool.Blender.get_addon_preferences()
+        highlight_color = prefs.decorator_color_selected[:3]
+
+        # Secondary width gizmo at the top of the stairs (linked to same width property)
+        self.gizmo_width_top = self.gizmos.new("BIM_GT_gizmo_arrow_2d")
+
+        def make_width_get():
+            def move_get():
+                obj = bpy.context.active_object
+                if not obj:
+                    return 0.0
+                props = self.get_props(obj)
+                return props.width
+            return move_get
+
+        def make_width_set():
+            def move_set(value):
+                obj = bpy.context.active_object
+                if not obj:
+                    return
+                props = self.get_props(obj)
+                props.width = max(0.0, value)
+            return move_set
+
+        self.gizmo_width_top.move_get_cb = make_width_get()
+        self.gizmo_width_top.move_set_cb = make_width_set()
+        self.gizmo_width_top.axis = Vector((0, 1, 0))
+        self.gizmo_width_top.local_axis = Vector((0, 1, 0))
+        self.gizmo_width_top.invert_delta = False
+        self.gizmo_width_top.delta_scale = 1.0
+        self.gizmo_width_top.prop_name = "Width"
+        self.gizmo_width_top.gizmo_group = self
+        self.gizmo_width_top.color = self.COLOR_GREEN
+        self.gizmo_width_top.color_highlight = highlight_color
+        self.gizmo_width_top.alpha = 0.99
+        self.gizmo_width_top.use_draw_modal = True
+        self.gizmo_width_top.use_draw_scale = True
+
+        # Total length lock gizmo
+        self.lock_gizmo = self.gizmos.new("VIEW3D_GT_lock")
+        self.lock_gizmo.use_draw_scale = False
+        self.lock_gizmo.color = self.COLOR_BLUE
+        self.lock_gizmo.color_highlight = highlight_color
+        self.lock_gizmo.alpha = 0.8
+        self.lock_gizmo.prop_path = "BIMStairProperties.total_length_lock"
+        self.lock_gizmo.target_set_operator("bim.toggle_stair_total_length_lock")
+
+        # Plus gizmo for increasing treads
+        self.plus_gizmo = self.gizmos.new("VIEW3D_GT_plus")
+        self.plus_gizmo.use_draw_scale = False
+        self.plus_gizmo.color = self.COLOR_GREEN
+        self.plus_gizmo.color_highlight = highlight_color
+        self.plus_gizmo.alpha = 0.8
+        op = self.plus_gizmo.target_set_operator("bim.adjust_stair_treads")
+        op.increment = 1
+
+        # Minus gizmo for decreasing treads
+        self.minus_gizmo = self.gizmos.new("VIEW3D_GT_minus")
+        self.minus_gizmo.use_draw_scale = False
+        self.minus_gizmo.color = self.COLOR_RED
+        self.minus_gizmo.color_highlight = highlight_color
+        self.minus_gizmo.alpha = 0.8
+        op = self.minus_gizmo.target_set_operator("bim.adjust_stair_treads")
+        op.increment = -1
+
+        # Cycle gizmo for stair type
+        default_color = prefs.decorations_colour[:3]
+        self.cycle_gizmo = self.gizmos.new("VIEW3D_GT_cycle")
+        self.cycle_gizmo.use_draw_scale = False
+        self.cycle_gizmo.color = default_color
+        self.cycle_gizmo.color_highlight = highlight_color
+        self.cycle_gizmo.alpha = 0.8
+        self.cycle_gizmo.target_set_operator("bim.cycle_stair_type")
+
+    def refresh(self, context):
+        obj = context.active_object
+        if not obj:
+            return
+
+        props = self.get_props(obj)
+        mw = obj.matrix_world
+        billboard_rot = gizmo.get_billboard_rotation(context)
+        self.update_property_gizmos(mw, props)
+        self.update_editing_gizmos(context, mw, props)
+        self.update_width_top_gizmo(mw, props)
+        self.update_lock_gizmo(mw, props, billboard_rot)
+        self.update_tread_count_gizmos(mw, props, billboard_rot)
+        self.update_cycle_gizmo(mw, props, billboard_rot)
+
+    def update_width_top_gizmo(self, mw, props):
+        """Update the secondary width gizmo at the top of the stairs."""
+        gizmo_prefs = self.get_gizmo_prefs()
+        # Use same visibility as the main width gizmo
+        self.gizmo_width_top.hide = not props.is_editing or not getattr(gizmo_prefs, "width", True)
+
+        if self.gizmo_width_top.hide:
+            return
+
+        self.gizmo_width_top.matrix_basis = mw @ self.get_gizmo_matrix_width_top(props)
+        self.gizmo_width_top.matrix_offset = Matrix.Scale(self.ARROW_SCALE, 4)
+
+    def update_lock_gizmo(self, mw, props, billboard_rot):
+        gizmo_prefs = self.get_gizmo_prefs()
+        self.lock_gizmo.hide = not props.is_editing or not gizmo_prefs.lock
+
+        if self.lock_gizmo.hide:
+            return
+
+        self.lock_gizmo.color = self.COLOR_RED if props.total_length_lock else self.COLOR_GREEN
+
+        total_run = self._get_stair_total_run(props)
+        lock_x = total_run + props.tread_run + self.GIZMO_X_OFFSET
+        local_transform = (
+            Matrix.Translation(Vector((lock_x, props.width / 2, props.height)))
+            @ billboard_rot
+            @ Matrix.Scale(0.2, 4)
+        )
+        self.lock_gizmo.matrix_basis = mw @ local_transform
+
+    def update_tread_count_gizmos(self, mw, props, billboard_rot):
+        gizmo_prefs = self.get_gizmo_prefs()
+
+        self.plus_gizmo.hide = not props.is_editing or not gizmo_prefs.plus
+        self.minus_gizmo.hide = not props.is_editing or props.number_of_treads <= 1 or not gizmo_prefs.minus
+
+        if self.plus_gizmo.hide and self.minus_gizmo.hide:
+            return
+
+        total_run = self._get_stair_total_run(props)
+        base_x = total_run + props.tread_run + self.GIZMO_X_OFFSET
+
+        if not self.plus_gizmo.hide:
+            plus_local_transform = (
+                Matrix.Translation(Vector((
+                    base_x + self.GIZMO_PLUS_X_OFFSET,
+                    props.width / 2,
+                    props.height + self.GIZMO_BUTTON_Z_OFFSET
+                )))
+                @ billboard_rot
+                @ Matrix.Scale(0.2, 4)
+            )
+            self.plus_gizmo.matrix_basis = mw @ plus_local_transform
+
+        if not self.minus_gizmo.hide:
+            minus_local_transform = (
+                Matrix.Translation(Vector((
+                    base_x + self.GIZMO_MINUS_X_OFFSET,
+                    props.width / 2,
+                    props.height + self.GIZMO_BUTTON_Z_OFFSET
+                )))
+                @ billboard_rot
+                @ Matrix.Scale(0.2, 4)
+            )
+            self.minus_gizmo.matrix_basis = mw @ minus_local_transform
+
+    def update_cycle_gizmo(self, mw, props, billboard_rot):
+        gizmo_prefs = self.get_gizmo_prefs()
+        self.cycle_gizmo.hide = not props.is_editing or not gizmo_prefs.cycle
+
+        if self.cycle_gizmo.hide:
+            return
+
+        total_run = self._get_stair_total_run(props)
+        cycle_x = total_run + props.tread_run + self.GIZMO_X_OFFSET
+        local_transform = (
+            Matrix.Translation(Vector((
+                cycle_x,
+                props.width / 2,
+                props.height + self.GIZMO_CYCLE_Z_OFFSET
+            )))
+            @ billboard_rot
+            @ Matrix.Scale(0.2, 4)
+        )
+        self.cycle_gizmo.matrix_basis = mw @ local_transform
+
+    def draw_prepare(self, context):
+        """Called before drawing - updates gizmos to face camera."""
+        # Call base class implementation
+        super().draw_prepare(context)
+
+        # Also update the secondary width gizmo to face camera
+        if hasattr(self, "gizmo_width_top") and not self.gizmo_width_top.hide:
+            self.gizmo_width_top.draw_prepare(context)

src/bonsai/bonsai/bim/module/model/ui.py

@@ -305,48 +305,9 @@ class BIM_PT_stair(bpy.types.Panel):
                 row.operator("bim.finish_editing_stair", icon="CHECKMARK", text="Finish Editing")
                 row.operator("bim.cancel_editing_stair", icon="CANCEL", text="")
                 row = self.layout.row(align=True)
-                for prop_name in props.get_props_kwargs():
-                    # Skip custom_tread_lock as it's handled with custom_first_last_tread_run
-                    if prop_name == "custom_tread_lock":
-                        continue
 
-                    prop_value = getattr(props, prop_name)
+                draw_stair_properties(self.layout, props)
 
-                    # Special handling for custom_first_last_tread_run
-                    if prop_name == "custom_first_last_tread_run":
-                        # Draw the lock toggle
-                        row_lock = self.layout.row(align=True)
-                        lock_text = (
-                            "Lock First/Last Treads" if not props.custom_tread_lock else "Unlock First/Last Treads"
-                        )
-                        row_lock.prop(
-                            props,
-                            "custom_tread_lock",
-                            text=lock_text,
-                            icon="LOCKED" if props.custom_tread_lock else "UNLOCKED",
-                        )
-
-                        # Only show the custom values input if unlocked
-                        if not props.custom_tread_lock:
-                            prop_readable_name = props.bl_rna.properties[prop_name].name
-                            self.layout.label(text=f"{prop_readable_name}:")
-                            self.layout.prop(props, prop_name, text="")
-                    elif isinstance(prop_value, Iterable) and not isinstance(prop_value, str):
-                        prop_readable_name = props.bl_rna.properties[prop_name].name
-                        self.layout.label(text=f"{prop_readable_name}:")
-                        self.layout.prop(props, prop_name, text="")
-                    else:
-                        self.layout.prop(props, prop_name)
-
-                    if prop_name == "height":  # Weak but we just want to insert this inside props drawing
-                        row_length = self.layout.row(align=True)
-                        row_length.prop(props, "total_length_target")
-                        row_length.prop(
-                            props,
-                            "total_length_lock",
-                            text="",
-                            icon="LOCKED" if props.total_length_lock else "UNLOCKED",
-                        )
                 regenerate_stair_mesh(obj)
             else:
                 calculated_params = StairData.data["calculated_params"]
@@ -440,39 +401,11 @@ class BIM_PT_window(bpy.types.Panel):
             row.label(text="Window parameters", icon="OUTLINER_OB_LATTICE")
 
             if props.is_editing:
-                number_of_panels, panels_data = props.window_types_panels[props.window_type]
                 row = self.layout.row(align=True)
                 row.operator("bim.finish_editing_window", icon="CHECKMARK", text="Finish Editing")
                 row.operator("bim.cancel_editing_window", icon="CANCEL", text="")
 
-                general_props = props.get_general_kwargs()
-                for prop in general_props:
-                    self.layout.prop(props, prop)
-
-                lining_props = props.get_lining_kwargs()
-                self.layout.label(text="Lining properties")
-                for prop in lining_props:
-                    self.layout.prop(props, prop)
-
-                panel_props = props.get_panel_kwargs()
-                self.layout.label(text="Panel properties")
-
-                panel_box = self.layout.box()
-                row = panel_box.row()
-                cols = [row.column(align=True) for i in range(number_of_panels + 1)]
-
-                cols[0].label(text="")
-
-                for panel_i in range(number_of_panels):
-                    r = cols[panel_i + 1].row()
-                    r.alignment = "CENTER"
-                    r.label(text=f"#{panel_i}")
-                    r = cols[panel_i + 1].row()
-
-                for prop in panel_props:
-                    cols[0].label(text=f"{props.bl_rna.properties[prop].name}")
-                    for panel_i in range(number_of_panels):
-                        cols[panel_i + 1].prop(props, prop, index=panel_i, text="")
+                draw_window_properties(self.layout, props)
 
                 self.layout.use_property_split = True
                 self.layout.label(text="Material Properties")
@@ -560,19 +493,7 @@ class BIM_PT_door(bpy.types.Panel):
                 row.operator("bim.finish_editing_door", icon="CHECKMARK", text="Finish Editing")
                 row.operator("bim.cancel_editing_door", icon="CANCEL", text="")
 
-                general_props = props.get_general_kwargs()
-                for prop in general_props:
-                    self.layout.prop(props, prop)
-
-                lining_props = props.get_lining_kwargs()
-                self.layout.label(text="Lining Properties")
-                for prop in lining_props:
-                    self.layout.prop(props, prop)
-
-                panel_props = props.get_panel_kwargs()
-                self.layout.label(text="Panel Properties")
-                for prop in panel_props:
-                    self.layout.prop(props, prop)
+                draw_door_properties(self.layout, props)
 
                 self.layout.use_property_split = True
                 self.layout.label(text="Material Properties")
@@ -643,14 +564,7 @@ class BIM_PT_railing(bpy.types.Panel):
                 row.operator("bim.finish_editing_railing", icon="CHECKMARK", text="Finish Editing")
                 row.operator("bim.cancel_editing_railing", icon="CANCEL", text="")
 
-                general_props = props.get_general_kwargs()
-                for prop in general_props:
-                    if prop == "support_spacing" and props.use_manual_supports:
-                        row = self.layout.row()
-                        row.prop(props, prop)
-                        row.active = False
-                        continue
-                    self.layout.prop(props, prop)
+                draw_railing_properties(self.layout, props)
 
                 update_railing_modifier_bmesh(context)
 
@@ -708,9 +622,7 @@ class BIM_PT_roof(bpy.types.Panel):
                 row.operator("bim.finish_editing_roof", icon="CHECKMARK", text="Finish Editing")
                 row.operator("bim.cancel_editing_roof", icon="CANCEL", text="")
 
-                general_props = props.get_general_kwargs()
-                for prop in general_props:
-                    self.layout.prop(props, prop)
+                draw_roof_properties(self.layout, props)
 
                 update_roof_modifier_bmesh(obj)
             elif props.is_editing_path:
@@ -776,6 +688,126 @@ class BIM_PT_external_parametric_geometry(bpy.types.Panel):
                 row.prop(input, "default_value", text=input.name)
 
 
+def draw_door_properties(layout: bpy.types.UILayout, props: bpy.types.PropertyGroup) -> None:
+    """Draw door properties UI (shared between properties panel and preferences)."""
+    # General properties
+    general_props = props.get_general_kwargs()
+    for prop in general_props:
+        layout.prop(props, prop)
+
+    # Lining properties
+    layout.label(text="Lining Properties")
+    lining_props = props.get_lining_kwargs()
+    for prop in lining_props:
+        layout.prop(props, prop)
+
+    # Panel properties
+    layout.label(text="Panel Properties")
+    panel_props = props.get_panel_kwargs()
+    for prop in panel_props:
+        layout.prop(props, prop)
+
+
+def draw_window_properties(layout: bpy.types.UILayout, props: bpy.types.PropertyGroup) -> None:
+    """Draw window properties UI (shared between properties panel and preferences)."""
+    number_of_panels, panels_data = props.window_types_panels[props.window_type]
+
+    # General and lining properties
+    general_props = props.get_general_kwargs()
+    for prop in general_props:
+        layout.prop(props, prop)
+
+    layout.label(text="Lining Properties")
+    lining_props = props.get_lining_kwargs()
+    for prop in lining_props:
+        layout.prop(props, prop)
+
+    # Panel properties (special layout for multiple panels)
+    panel_props = props.get_panel_kwargs()
+    layout.label(text="Panel Properties")
+
+    panel_box = layout.box()
+    row = panel_box.row()
+    cols = [row.column(align=True) for i in range(number_of_panels + 1)]
+
+    cols[0].label(text="")
+
+    for panel_i in range(number_of_panels):
+        r = cols[panel_i + 1].row()
+        r.alignment = "CENTER"
+        r.label(text=f"#{panel_i}")
+        r = cols[panel_i + 1].row()
+
+    for prop in panel_props:
+        cols[0].label(text=f"{props.bl_rna.properties[prop].name}")
+        for panel_i in range(number_of_panels):
+            cols[panel_i + 1].prop(props, prop, index=panel_i, text="")
+
+
+def draw_railing_properties(layout: bpy.types.UILayout, props: bpy.types.PropertyGroup) -> None:
+    """Draw railing properties UI (shared between properties panel and preferences)."""
+    general_props = props.get_general_kwargs()
+    for prop in general_props:
+        if prop == "support_spacing" and props.use_manual_supports:
+            row = layout.row()
+            row.prop(props, prop)
+            row.active = False
+            continue
+        layout.prop(props, prop)
+
+
+def draw_roof_properties(layout: bpy.types.UILayout, props: bpy.types.PropertyGroup) -> None:
+    """Draw roof properties UI (shared between properties panel and preferences)."""
+    # General properties
+    general_props = props.get_general_kwargs()
+    for prop in general_props:
+        layout.prop(props, prop)
+
+
+def draw_stair_properties(layout: bpy.types.UILayout, props: bpy.types.PropertyGroup) -> None:
+    """Draw stair properties UI (shared between properties panel and preferences)."""
+    for prop_name in props.get_props_kwargs():
+        # Skip custom_tread_lock as it's handled with custom_first_last_tread_run
+        if prop_name == "custom_tread_lock":
+            continue
+
+        prop_value = getattr(props, prop_name)
+
+        # Special handling for custom_first_last_tread_run
+        if prop_name == "custom_first_last_tread_run":
+            # Draw the lock toggle
+            row_lock = layout.row(align=True)
+            lock_text = "Lock First/Last Treads" if not props.custom_tread_lock else "Unlock First/Last Treads"
+            row_lock.prop(
+                props,
+                "custom_tread_lock",
+                text=lock_text,
+                icon="LOCKED" if props.custom_tread_lock else "UNLOCKED",
+            )
+
+            # Only show the custom values input if unlocked
+            if not props.custom_tread_lock:
+                prop_readable_name = props.bl_rna.properties[prop_name].name
+                layout.label(text=f"{prop_readable_name}:")
+                layout.prop(props, prop_name, text="")
+        elif isinstance(prop_value, Iterable) and not isinstance(prop_value, str):
+            prop_readable_name = props.bl_rna.properties[prop_name].name
+            layout.label(text=f"{prop_readable_name}:")
+            layout.prop(props, prop_name, text="")
+        else:
+            layout.prop(props, prop_name)
+
+        if prop_name == "height":  # Weak but we just want to insert this inside props drawing
+            row_length = layout.row(align=True)
+            row_length.prop(props, "total_length_target")
+            row_length.prop(
+                props,
+                "total_length_lock",
+                text="",
+                icon="LOCKED" if props.total_length_lock else "UNLOCKED",
+            )
+
+
 def add_menu(self: bpy.types.Menu, context: bpy.types.Context) -> None:
     self.layout.operator_context = "INVOKE_REGION_WIN"
     self.layout.operator("bim.add_element", icon_value=bonsai.bim.icons["IFC"].icon_id, text="IFC Element")

src/bonsai/bonsai/bim/module/model/window.py

@@ -28,6 +28,8 @@ import ifcopenshell.api.pset
 import bonsai.tool as tool
 import bonsai.core.root
 import bonsai.core.geometry
+from bonsai.bim import gizmo
+from bonsai.bim.gizmo import GizmoPropConfig
 from ifcopenshell.api.geometry.add_window_representation import DEFAULT_PANEL_SCHEMAS
 import ifcopenshell.api
 import ifcopenshell.api.material
@@ -36,8 +38,8 @@ import ifcopenshell.util.representation
 import ifcopenshell.util.shape_builder
 import ifcopenshell.util.unit
 from bmesh.types import BMVert
-from mathutils import Vector
-from typing import Optional, Union
+from mathutils import Vector, Matrix
+from typing import get_args
 
 V_ = tool.Blender.V_
 
@@ -139,7 +141,7 @@ def update_window_modifier_representation(context: bpy.types.Context) -> None:
 
 
 def create_bm_window_frame(
-    bm: bmesh.types.BMesh, size: Vector, thickness: Union[float, list[float]], position: Vector = V_(0, 0, 0).freeze()
+    bm: bmesh.types.BMesh, size: Vector, thickness: float | list[float], position: Vector = V_(0, 0, 0).freeze()
 ) -> list[bmesh.types.BMVert]:
     """`thickness` of the profile is defined as list in the following order:
     `(LEFT, TOP, RIGHT, BOTTOM)`
@@ -226,7 +228,7 @@ def create_bm_window(
     frame_thickness: float,
     glass_thickness: float,
     position: Vector,
-    x_offsets: Optional[list] = None,
+    x_offsets: list | None = None,
 ) -> tuple[list[bmesh.types.BMVert], list[bmesh.types.BMVert], list[bmesh.types.BMVert]]:
     """`lining_thickness` and `x_offsets` are expected to be defined as a list,
     similarly to `create_bm_window_frame` `thickness` argument"""
@@ -258,6 +260,9 @@ def update_window_modifier_bmesh(context: bpy.types.Context) -> None:
     obj = context.active_object
     assert obj
     props = tool.Model.get_window_props(obj)
+    if not props.is_editing:
+        return
+
     panel_schema = DEFAULT_PANEL_SCHEMAS[props.window_type]
     accumulated_height = [0] * len(panel_schema[0])
     built_panels = []
@@ -388,6 +393,7 @@ def update_window_modifier_bmesh(context: bpy.types.Context) -> None:
 
     bmesh.ops.translate(bm, vec=V_(0, lining_offset, 0), verts=bm.verts)
     bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
+    bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
 
     if bpy.context.active_object.mode == "EDIT":
         bmesh.update_edit_mesh(obj.data)
@@ -451,6 +457,8 @@ class AddWindow(bpy.types.Operator, tool.Ifc.Operator):
         assert element
         props = tool.Model.get_window_props(obj)
 
+        tool.Blender.get_addon_preferences().default_parameters.window.copy_to(props)
+
         window_data = props.get_general_kwargs(convert_to_project_units=True)
         lining_props = props.get_lining_kwargs(convert_to_project_units=True)
         panel_props = props.get_panel_kwargs(convert_to_project_units=True)
@@ -570,3 +578,229 @@ class RemoveWindow(bpy.types.Operator, tool.Ifc.Operator):
         ifcopenshell.api.pset.remove_pset(tool.Ifc.get(), product=element, pset=pset)
 
         return {"FINISHED"}
+
+
+class CycleWindowType(bpy.types.Operator, tool.Ifc.Operator):
+    """Cycle through available window types."""
+
+    bl_idname = "bim.cycle_window_type"
+    bl_label = "Cycle Window Type"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        obj = tool.Blender.get_active_object()
+        if not obj:
+            return {"CANCELLED"}
+
+        element = tool.Ifc.get_entity(obj)
+        if not element or not tool.Blender.Modifier.is_window(element):
+            return {"CANCELLED"}
+
+        props = tool.Model.get_window_props(obj)
+        window_types = list(get_args(tool.Model.WindowType))
+        current_index = window_types.index(props.window_type) if props.window_type in window_types else 0
+        next_index = (current_index + 1) % len(window_types)
+        props.window_type = window_types[next_index]
+
+        return {"FINISHED"}
+
+
+class GizmoWindowEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
+    bl_idname = "OBJECT_GGT_bim_window_edition"
+    bl_label = "Window Editing Gizmo"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "WINDOW"
+    bl_options = {"3D", "PERSISTENT"}
+
+    enable_editing_operator = "bim.enable_editing_window"
+    finish_editing_operator = "bim.finish_editing_window"
+    cancel_editing_operator = "bim.cancel_editing_window"
+    cycle_type_operator = "bim.cycle_window_type"
+
+    gizmo_props = [
+        GizmoPropConfig("overall_height", (0, 0, 1)),
+        GizmoPropConfig("overall_width", (1, 0, 0)),
+        GizmoPropConfig("lining_depth", (0, 1, 0)),
+        GizmoPropConfig("lining_thickness", (1, 0, 0)),
+        GizmoPropConfig("lining_to_panel_offset_x", (1, 0, 0)),
+        GizmoPropConfig("lining_to_panel_offset_y", (0, 1, 0)),
+        GizmoPropConfig("mullion_thickness", (1, 0, 0), delta_scale=2.0),
+        GizmoPropConfig("first_mullion_offset", (1, 0, 0)),
+        GizmoPropConfig("second_mullion_offset", (1, 0, 0)),
+        GizmoPropConfig("transom_thickness", (0, 0, 1), delta_scale=2.0),
+        GizmoPropConfig("first_transom_offset", (0, 0, 1)),
+        GizmoPropConfig("second_transom_offset", (0, 0, 1)),
+    ]
+
+    @classmethod
+    def is_element_type(cls, element) -> bool:
+        return tool.Blender.Modifier.is_window(element)
+
+    def get_props(self, obj):
+        return tool.Model.get_window_props(obj)
+
+    def get_gizmo_prefs(self):
+        prefs = tool.Blender.get_addon_preferences()
+        return prefs.gizmos.window
+
+    def should_hide_gizmo(self, attr_name, props):
+        """Window-specific visibility rules for gizmos."""
+        if not props.is_editing:
+            return True
+
+        has_mullion = self._has_mullion(props)
+        has_second_mullion = self._has_second_mullion(props)
+        has_transom = self._has_transom(props)
+        has_second_transom = self._has_second_transom(props)
+
+        if attr_name == "mullion_thickness" and not has_mullion:
+            return True
+        if attr_name == "first_mullion_offset" and not has_mullion:
+            return True
+        if attr_name == "second_mullion_offset" and not has_second_mullion:
+            return True
+        if attr_name == "transom_thickness" and not has_transom:
+            return True
+        if attr_name == "first_transom_offset" and not has_transom:
+            return True
+        if attr_name == "second_transom_offset" and not has_second_transom:
+            return True
+        return False
+
+    def get_gizmo_matrix_overall_height(self, props):
+        translation = Matrix.Translation(V_(props.overall_width - 0.05, props.lining_offset, props.overall_height))
+        rotation = self.get_axis_rotation_matrix((0, 0, 1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_overall_width(self, props):
+        translation = Matrix.Translation(V_(props.overall_width, props.lining_offset, props.overall_height - 0.05))
+        rotation = self.get_axis_rotation_matrix((1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_lining_depth(self, props):
+        translation = Matrix.Translation(
+            V_(props.overall_width / 2, props.lining_depth + props.lining_offset, props.overall_height)
+        )
+        rotation = self.get_axis_rotation_matrix((0, 1, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_lining_thickness(self, props):
+        translation = Matrix.Translation(
+            V_(props.lining_thickness, props.lining_depth / 2 + props.lining_offset, props.overall_height / 2)
+        )
+        rotation = self.get_axis_rotation_matrix((1, 0, 0))
+        return translation @ rotation
+
+    @staticmethod
+    def _get_lining_to_panel_offset_y_full(props) -> float:
+        """Get the full Y offset for lining-to-panel positioning."""
+        return (props.lining_depth - props.frame_depth[0]) + props.lining_to_panel_offset_y
+
+    def get_gizmo_matrix_lining_to_panel_offset_x(self, props):
+        y_full = self._get_lining_to_panel_offset_y_full(props)
+        translation = Matrix.Translation(
+            V_(props.lining_to_panel_offset_x, y_full + props.lining_offset, props.lining_thickness)
+        )
+        rotation = self.get_axis_rotation_matrix((1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_lining_to_panel_offset_y(self, props):
+        y_full = self._get_lining_to_panel_offset_y_full(props)
+        translation = Matrix.Translation(
+            V_(
+                props.lining_to_panel_offset_x,
+                y_full + props.frame_depth[0] + props.lining_offset,
+                props.lining_thickness,
+            )
+        )
+        rotation = self.get_axis_rotation_matrix((0, 1, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_mullion_thickness(self, props):
+        # Position at the right edge of the mullion (offset + thickness/2) so gizmo movement matches property 1:1
+        translation = Matrix.Translation(
+            V_(props.first_mullion_offset + props.mullion_thickness / 2, props.lining_offset, props.overall_height / 2)
+        )
+        rotation = self.get_axis_rotation_matrix((1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_first_mullion_offset(self, props):
+        # Position at the left edge of the mullion (offset - thickness/2)
+        translation = Matrix.Translation(
+            V_(props.first_mullion_offset - props.mullion_thickness / 2, props.lining_offset, props.overall_height / 2)
+        )
+        rotation = self.get_axis_rotation_matrix((1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_second_mullion_offset(self, props):
+        translation = Matrix.Translation(V_(props.second_mullion_offset, props.lining_offset, props.overall_height / 2))
+        rotation = self.get_axis_rotation_matrix((1, 0, 0))
+        return translation @ rotation
+
+    def get_gizmo_matrix_transom_thickness(self, props):
+        # Position at the top edge of the transom (offset + thickness/2) so gizmo movement matches property 1:1
+        translation = Matrix.Translation(
+            V_(props.overall_width / 2, props.lining_offset, props.first_transom_offset + props.transom_thickness / 2)
+        )
+        rotation = self.get_axis_rotation_matrix((0, 0, 1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_first_transom_offset(self, props):
+        # Position at the bottom edge of the transom (offset - thickness/2)
+        translation = Matrix.Translation(
+            V_(props.overall_width / 2, props.lining_offset, props.first_transom_offset - props.transom_thickness / 2)
+        )
+        rotation = self.get_axis_rotation_matrix((0, 0, 1))
+        return translation @ rotation
+
+    def get_gizmo_matrix_second_transom_offset(self, props):
+        translation = Matrix.Translation(V_(props.overall_width / 2, props.lining_offset, props.second_transom_offset))
+        rotation = self.get_axis_rotation_matrix((0, 0, 1))
+        return translation @ rotation
+
+    def _has_mullion(self, props):
+        """Check if the window type uses mullions (vertical dividers)."""
+        window_type = props.window_type
+        return window_type in (
+            "DOUBLE_PANEL_VERTICAL",
+            "TRIPLE_PANEL_BOTTOM",
+            "TRIPLE_PANEL_TOP",
+            "TRIPLE_PANEL_LEFT",
+            "TRIPLE_PANEL_RIGHT",
+            "TRIPLE_PANEL_VERTICAL",
+        )
+
+    def _has_second_mullion(self, props):
+        """Check if the window type uses a second mullion."""
+        return props.window_type == "TRIPLE_PANEL_VERTICAL"
+
+    def _has_transom(self, props):
+        """Check if the window type uses transoms (horizontal dividers)."""
+        window_type = props.window_type
+        return window_type in (
+            "DOUBLE_PANEL_HORIZONTAL",
+            "TRIPLE_PANEL_BOTTOM",
+            "TRIPLE_PANEL_TOP",
+            "TRIPLE_PANEL_LEFT",
+            "TRIPLE_PANEL_RIGHT",
+            "TRIPLE_PANEL_HORIZONTAL",
+        )
+
+    def _has_second_transom(self, props):
+        """Check if the window type uses a second transom."""
+        return props.window_type == "TRIPLE_PANEL_HORIZONTAL"
+
+    def setup(self, context):
+        # Use base class methods for common gizmos
+        self.setup_property_gizmos(context)
+        self.setup_editing_gizmos(context)
+
+    def refresh(self, context):
+        obj = context.active_object
+        if not obj:
+            return
+
+        props = self.get_props(obj)
+        mw = obj.matrix_world
+        self.update_property_gizmos(mw, props)
+        self.update_editing_gizmos(context, mw, props)

src/bonsai/bonsai/bim/module/project/ui.py

@@ -635,6 +635,7 @@ class BIM_PT_purge(Panel):
     bl_parent_id = "BIM_PT_tab_quality_control"
 
     def draw(self, context):
+        props = tool.Debug.get_debug_props()
         layout = self.layout
         layout.operator("bim.purge_unused_objects", text="Purge Unused Profiles").object_type = "PROFILE"
         layout.operator("bim.purge_unused_objects", text="Purge Unused Types").object_type = "TYPE"
@@ -655,3 +656,23 @@ class BIM_PT_purge(Panel):
             row.operator("bim.purge_unused_objects", text="Purge Unused").object_type = object_type
             merge_op = row.operator("bim.merge_identical_objects", text="Merge Identical")
             merge_op.object_type = object_type
+
+        layout.operator("bim.purge_unused_representations")
+
+        row = layout.row(align=True)
+        row.prop(props, "ifc_class_purge", text="")
+        row.operator("bim.purge_unused_elements_by_class", text="Purge Orphaned", icon="TRASH")
+        row.operator("bim.print_unused_elements_stats", text="", icon="INFO")
+
+        if context.active_object and (data := context.active_object.data):
+            mprops = tool.Geometry.get_mesh_props(data)
+            row = layout.row()
+            row.operator("bim.get_representation_ifc_parameters")
+            for index, ifc_parameter in enumerate(mprops.ifc_parameters):
+                row = layout.row(align=True)
+                row.prop(ifc_parameter, "name", text="")
+                row.prop(ifc_parameter, "value", text="")
+                row.operator("bim.update_parametric_representation", icon="FILE_REFRESH", text="").index = index
+
+
+

src/bonsai/bonsai/bim/module/spatial/prop.py

@@ -36,6 +36,7 @@ import bonsai.core.geometry
 import ifcopenshell
 import ifcopenshell.api.attribute
 import ifcopenshell.util.unit
+from bonsai.tool.unit import parse_distance_string
 from typing import TYPE_CHECKING, Union, Literal
 
 
@@ -48,18 +49,46 @@ def get_subelement_class(
 
 
 def update_elevation(self: "BIMContainer", context: bpy.types.Context) -> None:
-    try:
-        elevation = float(self.elevation)
-        if self.elevation != str(elevation):
-            self.elevation = str(elevation)
-            return
-    except:
-        elevation = 0
+    # Try to parse the input string with unit support first
+    is_valid, parsed_elevation = parse_distance_string(self.elevation, use_project_unit=True)
+
+    if is_valid:
+        elevation = parsed_elevation
+
+        # Format the string if it needs normalization:
+        # - Plain numbers (no units): "4" → "4' - 0""
+        # - Missing symbols: "5'3" → "5' - 3""
+        # - Inconsistent formatting: "5' 3 3/256" → "5' - 3 3/256""
+        input_str = self.elevation.strip()
+
+        # Check if input needs formatting (has feet/inch symbols or is plain number)
+        needs_formatting = (
+            input_str.replace(".", "").replace("-", "").replace(" ", "").replace("/", "").isdigit()  # Plain number
+            or "'" in input_str  # Has feet symbol
+            or '"' in input_str  # Has inch symbol
+            or " " in input_str.replace(" - ", "")  # Has spaces (but not the formatted " - ")
+        )
+
+        # Only format if the current string doesn't match our standard format
+        if needs_formatting:
+            formatted = tool.Unit.format_distance(elevation)
+            if self.elevation != formatted:
+                self.elevation = formatted
+                return
+    else:
+        # Fall back to direct float conversion for backward compatibility
+        try:
+            elevation = float(self.elevation)
+        except Exception as e:
+            print(f"Elevation parsing failed for '{self.elevation}': {e}")
+            elevation = 0
+
+    # Update the object's position in the 3D scene
     if ifc_definition_id := self.ifc_definition_id:
         entity = tool.Ifc.get().by_id(ifc_definition_id)
         if obj := tool.Ifc.get_object(entity):
-            unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-            obj.matrix_world[2][3] = elevation * unit_scale
+            # elevation is already in meters, set it directly
+            obj.matrix_world[2][3] = elevation
             bonsai.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj)
 
 

src/bonsai/bonsai/bim/module/spatial/ui.py

@@ -277,7 +277,7 @@ class BIM_UL_containers_manager(UIList):
         if item:
             row = layout.row(align=True)
             icon = self.icon_by_class.get(item.ifc_class, "META_PLANE")
-            split = row.split(factor=0.85)
+            split = row.split(factor=0.8)
             if item.long_name:
                 split2 = split.split(factor=0.7)
                 row = split2.row(align=True)

src/bonsai/bonsai/bim/module/type/operator.py

@@ -322,6 +322,15 @@ class DuplicateType(bpy.types.Operator, tool.Ifc.Operator):
     bl_label = "Duplicate Type"
     bl_options = {"REGISTER", "UNDO"}
     element: bpy.props.IntProperty()
+    name: bpy.props.StringProperty(name="Name")
+    description: bpy.props.StringProperty(name="Description")
+    assign_selected_objects: bpy.props.BoolProperty(default=False)
+
+    if TYPE_CHECKING:
+        element: int
+        name: str
+        description: str
+        assign_selected_objects: bool
 
     def _execute(self, context):
         element = tool.Ifc.get().by_id(self.element)
@@ -332,8 +341,25 @@ class DuplicateType(bpy.types.Operator, tool.Ifc.Operator):
         if obj.data:
             new_obj.data = obj.data.copy()
         new = bonsai.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
-        new.Name += " Copy"
+        
+        # Apply the name and description from the dialog
+        new.Name = self.name
+        if self.description:
+            new.Description = self.description
+        
         bpy.ops.bim.load_type_thumbnails()
+        
+        # Assign selected objects to the new type if requested
+        if self.assign_selected_objects:
+            selected_objects = tool.Blender.get_selected_objects()
+            prefs = tool.Blender.get_addon_preferences()
+            for selected_obj in selected_objects:
+                selected_element = tool.Ifc.get_entity(selected_obj)
+                if selected_element and selected_element.is_a("IfcObject"):
+                    core.assign_type(tool.Ifc, tool.Type, element=selected_element, type=new)
+                    if prefs.occurrence_name_style == "TYPE":
+                        selected_obj.name = tool.Model.generate_occurrence_name(new, selected_element.is_a())
+        
         if obj in context.selectable_objects:
             tool.Blender.select_and_activate_single_object(context, new_obj)
         else:
@@ -347,3 +373,17 @@ class DuplicateType(bpy.types.Operator, tool.Ifc.Operator):
             props.ifc_class = new.is_a()
             props.relating_type_id = str(tool.Blender.get_ifc_definition_id(new_obj))
         return {"FINISHED"}
+
+    def invoke(self, context, event):
+        element = tool.Ifc.get().by_id(self.element)
+        self.name = (element.Name or "Unnamed") + " Copy"
+        self.description = element.Description or ""
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context):
+        self.layout.prop(self, "name")
+        self.layout.prop(self, "description")
+        selected_objects = tool.Blender.get_selected_objects()
+        ifc_objects = [obj for obj in selected_objects if tool.Ifc.get_entity(obj) and tool.Ifc.get_entity(obj).is_a("IfcObject")]
+        if ifc_objects:
+            self.layout.prop(self, "assign_selected_objects", text=f"Assign {len(ifc_objects)} Selected Object(s) to New Type")

src/bonsai/bonsai/bim/module/type/ui.py

@@ -96,6 +96,10 @@ class BIM_PT_type(Panel):
                 op = row.operator("bim.select_type", icon="OBJECT_DATA", text="")
                 op.relating_type = 0  # will only select the relating types of only the selected objects
                 row.operator("bim.select_similar_type", icon="RESTRICT_SELECT_OFF", text="")
+                # Add duplicate button here with assign_selected_objects enabled
+                op = row.operator("bim.duplicate_type", icon="DUPLICATE", text="")
+                op.element = TypeData.data["relating_type"]["id"]
+                op.assign_selected_objects = True
                 row.operator("bim.enable_editing_type", icon="GREASEPENCIL", text="")
                 row.operator("bim.unassign_type", icon="X", text="")
             else:

src/bonsai/bonsai/bim/module/void/operator.py

@@ -102,6 +102,19 @@ class AddOpening(bpy.types.Operator, tool.Ifc.Operator):
             element_had_openings = tool.Geometry.has_openings(voided_element)
             body_context = ifcopenshell.util.representation.get_context(tool.Ifc.get(), "Model", "Body")
             if not element2:
+                # Apply scale transformation for vanilla Blender objects before creating IFC representation
+                # This ensures the opening geometry matches the visual scale of the object
+                if tool.Geometry.is_scaled(obj2):
+                    if obj2.data:
+                        # Make mesh data single-user if it's shared
+                        if obj2.data.users > 1:
+                            obj2.data = obj2.data.copy()
+                        context_override = {}
+                        context_override["object"] = context_override["active_object"] = obj2
+                        context_override["selected_objects"] = context_override["selected_editable_objects"] = [obj2]
+                        with bpy.context.temp_override(**context_override):
+                            bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
+
                 element2 = bonsai.core.root.assign_class(
                     tool.Ifc,
                     tool.Collector,

src/bonsai/bonsai/bim/ui.py

@@ -38,6 +38,20 @@ from ifcopenshell.util.file import IfcHeaderExtractor
 from bonsai.bim.prop import Attribute
 from bonsai.bim.module.bsdd.prop import BIMBSDDProperties, BSDDProperty
 from bonsai.bim.module.pset.prop import IfcProperty
+from bonsai.bim.module.model.prop import (
+    BIMDoorProperties,
+    BIMWindowProperties,
+    BIMRailingProperties,
+    BIMRoofProperties,
+    BIMStairProperties,
+)
+from bonsai.bim.module.model.ui import (
+    draw_door_properties,
+    draw_window_properties,
+    draw_railing_properties,
+    draw_roof_properties,
+    draw_stair_properties,
+)
 from typing import Optional, TYPE_CHECKING, Literal
 from natsort import natsorted
 import textwrap
@@ -228,6 +242,120 @@ class BIM_UL_generic(bpy.types.UIList):
             layout.label(text="", translate=False)
 
 
+class GizmoPreferencesDoor(bpy.types.PropertyGroup):
+    """Property group for door gizmo visibility settings."""
+
+    overall_height: BoolProperty(name="Overall Height", default=True)
+    overall_width: BoolProperty(name="Overall Width", default=True)
+    threshold_thickness: BoolProperty(name="Threshold Thickness", default=True)
+    threshold_depth: BoolProperty(name="Threshold Depth", default=True)
+    lining_depth: BoolProperty(name="Lining Depth", default=True)
+    lining_thickness: BoolProperty(name="Lining Thickness", default=True)
+    transom_offset: BoolProperty(name="Transom Offset", default=True)
+    transom_thickness: BoolProperty(name="Transom Thickness", default=True)
+    casing_thickness: BoolProperty(name="Casing Thickness", default=True)
+    casing_depth: BoolProperty(name="Casing Depth", default=True)
+    swing_arc: BoolProperty(name="Swing Arc", default=True, description="Show door swing direction arc")
+    flip_arc: BoolProperty(name="Flip Arc", default=True, description="Show flip door orientation arc")
+
+    if TYPE_CHECKING:
+        overall_height: bool
+        overall_width: bool
+        threshold_thickness: bool
+        threshold_depth: bool
+        lining_depth: bool
+        lining_thickness: bool
+        transom_offset: bool
+        transom_thickness: bool
+        casing_thickness: bool
+        casing_depth: bool
+        swing_arc: bool
+        flip_arc: bool
+
+
+class GizmoPreferencesWindow(bpy.types.PropertyGroup):
+    """Property group for window gizmo visibility settings."""
+
+    overall_height: BoolProperty(name="Overall Height", default=True)
+    overall_width: BoolProperty(name="Overall Width", default=True)
+    lining_depth: BoolProperty(name="Lining Depth", default=True)
+    lining_thickness: BoolProperty(name="Lining Thickness", default=True)
+    lining_to_panel_offset_x: BoolProperty(name="Lining to Panel Offset X", default=True)
+    lining_to_panel_offset_y: BoolProperty(name="Lining to Panel Offset Y", default=True)
+    mullion_thickness: BoolProperty(name="Mullion Thickness", default=True)
+    first_mullion_offset: BoolProperty(name="First Mullion Offset", default=True)
+    second_mullion_offset: BoolProperty(name="Second Mullion Offset", default=True)
+    transom_thickness: BoolProperty(name="Transom Thickness", default=True)
+    first_transom_offset: BoolProperty(name="First Transom Offset", default=True)
+    second_transom_offset: BoolProperty(name="Second Transom Offset", default=True)
+
+    if TYPE_CHECKING:
+        overall_height: bool
+        overall_width: bool
+        lining_depth: bool
+        lining_thickness: bool
+        lining_to_panel_offset_x: bool
+        lining_to_panel_offset_y: bool
+        mullion_thickness: bool
+        first_mullion_offset: bool
+        second_mullion_offset: bool
+        transom_thickness: bool
+        first_transom_offset: bool
+        second_transom_offset: bool
+
+
+class GizmoPreferencesStair(bpy.types.PropertyGroup):
+    """Property group for stair gizmo visibility settings."""
+
+    width: BoolProperty(name="Width", default=True)
+    height: BoolProperty(name="Height", default=True)
+    tread_run: BoolProperty(name="Tread Run", default=True)
+    tread_depth: BoolProperty(name="Tread Depth", default=True)
+    nosing_length: BoolProperty(name="Nosing Length", default=True)
+    nosing_depth: BoolProperty(name="Nosing Depth", default=True)
+    total_length_target: BoolProperty(name="Total Length Target", default=True)
+    base_slab_depth: BoolProperty(name="Base Slab Depth", default=True)
+    top_slab_depth: BoolProperty(name="Top Slab Depth", default=True)
+    lock: BoolProperty(name="Total Length Lock", default=True)
+    plus: BoolProperty(name="Add Tread (+)", default=True)
+    minus: BoolProperty(name="Remove Tread (-)", default=True)
+    cycle: BoolProperty(name="Cycle Stair Type", default=True)
+
+    if TYPE_CHECKING:
+        width: bool
+        height: bool
+        tread_run: bool
+        tread_depth: bool
+        nosing_length: bool
+        nosing_depth: bool
+        total_length_target: bool
+        base_slab_depth: bool
+        top_slab_depth: bool
+        lock: bool
+        plus: bool
+        minus: bool
+        cycle: bool
+
+
+class GizmoPreferences(bpy.types.PropertyGroup):
+    """Property group for all gizmo visibility settings."""
+
+    draw_gizmos_in_3d_viewport: BoolProperty(
+        name="Draw Gizmos In 3D Viewport",
+        default=True,
+        description="Show interactive gizmos in the 3D viewport for parametric elements",
+    )
+    door: bpy.props.PointerProperty(type=GizmoPreferencesDoor)
+    window: bpy.props.PointerProperty(type=GizmoPreferencesWindow)
+    stair: bpy.props.PointerProperty(type=GizmoPreferencesStair)
+
+    if TYPE_CHECKING:
+        draw_gizmos_in_3d_viewport: bool
+        door: GizmoPreferencesDoor
+        window: GizmoPreferencesWindow
+        stair: GizmoPreferencesStair
+
+
 class DocPreferences(bpy.types.PropertyGroup):
     sheets_dir: StringProperty(
         default=os.path.join("sheets") + os.path.sep,
@@ -320,6 +448,14 @@ class DocPreferences(bpy.types.PropertyGroup):
         classes_no_cut: str
 
 
+class DefaultParameters(bpy.types.PropertyGroup):
+    door: bpy.props.PointerProperty(type=BIMDoorProperties)
+    window: bpy.props.PointerProperty(type=BIMWindowProperties)
+    railing: bpy.props.PointerProperty(type=BIMRailingProperties)
+    roof: bpy.props.PointerProperty(type=BIMRoofProperties)
+    stair: bpy.props.PointerProperty(type=BIMStairProperties)
+
+
 class BIM_ADDON_preferences(bpy.types.AddonPreferences):
     bl_idname = tool.Blender.get_blender_addon_package_name()
     svg2pdf_command: StringProperty(
@@ -493,6 +629,7 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         name="Occurrence Name Function",
         description="Code that will be evaluated to generate occurrence name for CUSTOM occurrence name style",
     )
+    gizmos: bpy.props.PointerProperty(type=GizmoPreferences)
 
     def update_data_dir(self, context: bpy.types.Context) -> None:
         import bonsai.bim.schema
@@ -523,6 +660,11 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         subtype="DIR_PATH",
     )
     doc: bpy.props.PointerProperty(type=DocPreferences)
+    default_parameters: bpy.props.PointerProperty(
+        type=DefaultParameters,
+        name="Default Parameters",
+        description="Default parameters for BIM elements",
+    )
 
     if TYPE_CHECKING:
         svg2pdf_command: str
@@ -553,10 +695,12 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         should_always_cache: bool
         occurrence_name_style: Literal["CLASS", "TYPE", "CUSTOM"]
         occurrence_name_function: str
+        gizmos: GizmoPreferences
         data_dir: str
         cache_dir: str
         pset_dir: str
         doc: DocPreferences
+        default_parameters: DefaultParameters
 
     def draw(self, context: bpy.types.Context) -> None:
         layout = self.layout
@@ -599,10 +743,61 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         layout.prop(self, "should_use_snap")
         layout.prop(self, "should_play_chaching_sound")
 
+        layout.prop(self.gizmos, "draw_gizmos_in_3d_viewport")
+        if self.gizmos.draw_gizmos_in_3d_viewport:
+            bonsai.bim.helper.draw_expandable_panel(
+                layout,
+                context,
+                "Gizmos Parameters",
+                self.draw_gizmo_parameters,
+            )
+
+    def draw_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
+        layout.label(text="Toggle visibility of gizmos in editing mode")
+        box = layout.box()
+        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Door", self.draw_door_gizmo_parameters)
+        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Window", self.draw_window_gizmo_parameters)
+        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Stair", self.draw_stair_gizmo_parameters)
+
+    def draw_door_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
+        from bonsai.bim.module.model.door import GizmoDoorEdition
+
+        door_gizmos = self.gizmos.door
+        gizmo_prop_names = {p.attr_name for p in GizmoDoorEdition.gizmo_props}
+        gizmo_prop_names.update(("swing_arc", "flip_arc"))
+        for prop in door_gizmos.__annotations__:
+            if prop in gizmo_prop_names:
+                layout.prop(door_gizmos, prop)
+
+    def draw_window_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
+        from bonsai.bim.module.model.window import GizmoWindowEdition
+
+        window_gizmos = self.gizmos.window
+        gizmo_prop_names = {p.attr_name for p in GizmoWindowEdition.gizmo_props}
+        for prop in window_gizmos.__annotations__:
+            if prop in gizmo_prop_names:
+                layout.prop(window_gizmos, prop)
+
+    def draw_stair_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
+        from bonsai.bim.module.model.stair import GizmoStairEdition
+
+        stair_gizmos = self.gizmos.stair
+        gizmo_prop_names = {p.attr_name for p in GizmoStairEdition.gizmo_props}
+        special_gizmo_names = {"lock", "plus", "minus"}
+        for prop in stair_gizmos.__annotations__:
+            if prop in gizmo_prop_names or prop in special_gizmo_names:
+                layout.prop(stair_gizmos, prop)
+
     def draw_model_settings(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         layout.prop(self, "occurrence_name_style")
         if self.occurrence_name_style == "CUSTOM":
             layout.prop(self, "occurrence_name_function")
+        bonsai.bim.helper.draw_expandable_panel(
+            layout,
+            context,
+            "Default Parameters",
+            self.draw_default_parameters,
+        )
 
     def draw_directories(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         layout.prop(self, "data_dir")
@@ -639,6 +834,39 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         layout.row().prop(self, "decorator_color_error")
         layout.row().prop(self, "decorator_color_background")
 
+    def draw_default_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
+        box = layout.box()
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Door",
+            lambda _layout, _context: draw_door_properties(_layout, self.default_parameters.door),
+        )
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Window",
+            lambda _layout, _context: draw_window_properties(_layout, self.default_parameters.window),
+        )
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Railing",
+            lambda _layout, _context: draw_railing_properties(_layout, self.default_parameters.railing),
+        )
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Roof",
+            lambda _layout, _context: draw_roof_properties(_layout, self.default_parameters.roof),
+        )
+        bonsai.bim.helper.draw_expandable_panel(
+            box,
+            context,
+            "Stair",
+            lambda _layout, _context: draw_stair_properties(_layout, self.default_parameters.stair),
+        )
+
     def draw_other_settings(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         layout.prop(self, "opening_focus_opacity")
         layout.prop(self, "should_disable_undo_on_save")

src/bonsai/bonsai/tool/drawing.py

@@ -1625,7 +1625,12 @@ class Drawing(bonsai.core.tool.Drawing):
 
         xmin, xmax, ymin, ymax = helper.ortho_view_frame(camera.data)[:4]
         rl = ifcopenshell.util.placement.get_local_placement(storey.ObjectPlacement)[2][3]
-        y = (camera.matrix_world.inverted() @ Vector((0.0, 0.0, rl))).y
+
+        # Convert RL from project units (feet) to meters for Blender world space
+        unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        rl_meters = rl * unit_scale
+
+        y = (camera.matrix_world.inverted() @ Vector((0.0, 0.0, rl_meters))).y
         if y < ymin or y > ymax:
             return
 

src/bonsai/bonsai/tool/geometry.py

@@ -1904,6 +1904,17 @@ class Geometry(bonsai.core.tool.Geometry):
                 obj.data.transform(transformation_i)
             cls.record_object_position(obj)
 
+        # ADD THIS AT THE END - Store initial vertex order for annotations
+        if rep_obj and (element := tool.Ifc.get_entity(rep_obj)):
+            if element.is_a("IfcAnnotation") and element.ObjectType in {
+                "TEXT_LEADER", "DIMENSION", "RADIUS", "DIAMETER", "ANGLE",
+                "FALL", "SLOPE_ANGLE", "SLOPE_FRACTION", "SLOPE_PERCENT",
+                "STAIR_ARROW", "PLAN_LEVEL", "SECTION_LEVEL", "SECTION", "ELEVATION"
+            }:
+                # Store the initial first vertex position
+                if isinstance(obj.data, bpy.types.Mesh) and obj.data.vertices:
+                    obj.data["bonsai_first_vert_co"] = obj.data.vertices[0].co[:]
+
     @classmethod
     def disable_item_mode(cls) -> None:
         props = tool.Geometry.get_geometry_props()
@@ -2096,6 +2107,7 @@ class Geometry(bonsai.core.tool.Geometry):
         decomposition_relationships = tool.Root.get_decomposition_relationships(objects_to_duplicate)
         connection_relationships = tool.Root.get_connection_relationships(objects_to_duplicate)
         old_to_new: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]] = {}
+        old_obj_name_to_new_obj_name: dict[str, str] = {}
 
         for obj in objects_to_duplicate:
             element = tool.Ifc.get_entity(obj)
@@ -2147,6 +2159,7 @@ class Geometry(bonsai.core.tool.Geometry):
                 collection.objects.link(new_obj)
             obj.select_set(False)
             new_obj.select_set(True)
+            old_obj_name_to_new_obj_name[obj.name] = new_obj.name
 
             if not element:
                 continue
@@ -2179,6 +2192,19 @@ class Geometry(bonsai.core.tool.Geometry):
                 if new.is_a("IfcRelSpaceBoundary"):
                     tool.Boundary.decorate_boundary(new_obj)
 
+        # Remap Blender parent relationships for duplicated objects
+        for old_obj_name, new_obj_name in old_obj_name_to_new_obj_name.items():
+            new_obj = bpy.data.objects.get(new_obj_name)
+            if new_obj and new_obj.parent and new_obj.parent.name in old_obj_name_to_new_obj_name:
+                # Store world matrix before reparenting to preserve transform
+                world_matrix = new_obj.matrix_world.copy()
+                new_parent_name = old_obj_name_to_new_obj_name[new_obj.parent.name]
+                new_parent = bpy.data.objects.get(new_parent_name)
+                if new_parent:
+                    new_obj.parent = new_parent
+                    # Restore world transform by setting matrix_world
+                    new_obj.matrix_world = world_matrix
+
         # Recreate aggregate relationship
         for old in old_to_new.keys():
             if old.is_a("IfcElementAssembly"):
@@ -2325,3 +2351,94 @@ class Geometry(bonsai.core.tool.Geometry):
                 continue
             objects.add(obj)
         return objects
+
+    @classmethod
+    def ensure_annotation_vertex_order(cls, obj: bpy.types.Object) -> None:
+        """
+        Ensure vertices form a continuous path from start to end.
+        Uses the original first vertex position as a reference point.
+        """
+        mesh = obj.data
+        if not isinstance(mesh, bpy.types.Mesh):
+            return
+        
+        # Get the original first vertex position from custom properties
+        if "bonsai_first_vert_co" in mesh:
+            original_first_co = Vector(mesh["bonsai_first_vert_co"])
+        else:
+            # Store it for next time
+            if mesh.vertices:
+                original_first_co = Vector(mesh.vertices[0].co)
+                mesh["bonsai_first_vert_co"] = original_first_co[:]
+            else:
+                return
+        
+        bm = bmesh.new()
+        bm.from_mesh(mesh)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+        
+        if len(bm.verts) == 0:
+            bm.free()
+            return
+        
+        # Find endpoints (vertices with only one connected edge)
+        endpoints = [v for v in bm.verts if len(v.link_edges) == 1]
+        
+        # Choose the endpoint closest to the original first vertex position
+        if len(endpoints) == 0:
+            # Closed loop - pick any vertex as start
+            start_vert = bm.verts[0]
+        elif len(endpoints) == 1:
+            # Single endpoint
+            start_vert = endpoints[0]
+        else:
+            # Choose endpoint closest to where the original first vertex was
+            start_vert = min(endpoints, key=lambda v: (v.co - original_first_co).length)
+        
+        # Build ordered vertex list by following edges
+        ordered_verts = [start_vert]
+        current_vert = start_vert
+        visited_edges = set()
+        
+        while True:
+            # Find next unvisited edge
+            next_edge = None
+            for edge in current_vert.link_edges:
+                if edge not in visited_edges:
+                    next_edge = edge
+                    break
+            
+            if not next_edge:
+                break
+            
+            visited_edges.add(next_edge)
+            next_vert = next_edge.other_vert(current_vert)
+            
+            # Avoid going back on ourselves
+            if next_vert not in ordered_verts:
+                ordered_verts.append(next_vert)
+            
+            current_vert = next_vert
+        
+        # Store vertex coordinates in the correct order
+        new_verts_co = [v.co.copy() for v in ordered_verts]
+        
+        # Update the stored first vertex position to the new first vertex
+        mesh["bonsai_first_vert_co"] = new_verts_co[0][:]
+        
+        # Clear and rebuild mesh with correct vertex order
+        bm.clear()
+        
+        # Create new vertices in order
+        new_verts = [bm.verts.new(co) for co in new_verts_co]
+        bm.verts.ensure_lookup_table()
+        
+        # Create edges connecting consecutive vertices
+        for i in range(len(new_verts) - 1):
+            bm.edges.new([new_verts[i], new_verts[i + 1]])
+        
+        # Write back to mesh
+        bm.to_mesh(mesh)
+        bm.free()
+        mesh.update()

src/bonsai/bonsai/tool/ifc.py

@@ -110,12 +110,26 @@ class Ifc(bonsai.core.tool.Ifc):
         oprops = tool.Blender.get_object_bim_props(obj)
         if not oprops.location_checksum:
             return True  # Let's be conservative
-        loc_check = np.frombuffer(eval(oprops.location_checksum), dtype=np.float32)
-        loc_real = np.array(obj.matrix_world.translation).flatten()
+
+        # Handle both old float64 and new float32 checksums for version compatibility
+        loc_checksum_bytes = eval(oprops.location_checksum)
+        if len(loc_checksum_bytes) == 24:  # Old format: 3 * 8 bytes (float64)
+            loc_check = np.frombuffer(loc_checksum_bytes, dtype=np.float64).astype(np.float32)
+        else:  # New format: 3 * 4 bytes (float32)
+            loc_check = np.frombuffer(loc_checksum_bytes, dtype=np.float32)
+
+        loc_real = np.array(obj.matrix_world.translation, dtype=np.float32).flatten()
         if not np.allclose(loc_check, loc_real, atol=1e-4):  # 0.1 mm
             return True
-        rot_check = np.frombuffer(eval(oprops.rotation_checksum), dtype=np.float32).reshape(3, 3)
-        rot_real = np.array(obj.matrix_world.to_3x3())
+
+        # Handle both old float64 and new float32 checksums for version compatibility
+        rot_checksum_bytes = eval(oprops.rotation_checksum)
+        if len(rot_checksum_bytes) == 72:  # Old format: 9 * 8 bytes (float64)
+            rot_check = np.frombuffer(rot_checksum_bytes, dtype=np.float64).astype(np.float32).reshape(3, 3)
+        else:  # New format: 9 * 4 bytes (float32)
+            rot_check = np.frombuffer(rot_checksum_bytes, dtype=np.float32).reshape(3, 3)
+
+        rot_real = np.array(obj.matrix_world.to_3x3(), dtype=np.float32)
         rot_dot = np.dot(rot_check, rot_real.T)
         angle_rad = np.arccos(np.clip((np.trace(rot_dot) - 1) / 2, -1, 1))
         if angle_rad > 0.0017453292519943296:  # 0.1 degrees

src/bonsai/bonsai/tool/model.py

@@ -1401,6 +1401,29 @@ class Model(bonsai.core.tool.Model):
 
     StairType = Literal["CONCRETE", "WOOD/STEEL", "GENERIC"]
 
+    DoorType = Literal[
+        "SINGLE_SWING_LEFT",
+        "SINGLE_SWING_RIGHT",
+        "DOUBLE_SWING_LEFT",
+        "DOUBLE_SWING_RIGHT",
+        "DOUBLE_DOOR_SINGLE_SWING",
+        "SLIDING_TO_LEFT",
+        "SLIDING_TO_RIGHT",
+        "DOUBLE_DOOR_SLIDING",
+    ]
+
+    WindowType = Literal[
+        "SINGLE_PANEL",
+        "DOUBLE_PANEL_HORIZONTAL",
+        "DOUBLE_PANEL_VERTICAL",
+        "TRIPLE_PANEL_BOTTOM",
+        "TRIPLE_PANEL_TOP",
+        "TRIPLE_PANEL_LEFT",
+        "TRIPLE_PANEL_RIGHT",
+        "TRIPLE_PANEL_HORIZONTAL",
+        "TRIPLE_PANEL_VERTICAL",
+    ]
+
     @classmethod
     def generate_stair_2d_profile(
         cls,

src/bonsai/bonsai/tool/spatial.py

@@ -496,7 +496,9 @@ class Spatial(bonsai.core.tool.Spatial):
         new.long_name = element.LongName or ""
         if not element.is_a("IfcProject"):
             elevation = ifcopenshell.util.placement.get_storey_elevation(element)
-            new["elevation"] = tool.Unit.format_value(elevation)
+            unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+            elevation_in_meters = elevation * unit_scale
+            new.elevation = tool.Unit.format_distance(elevation_in_meters)
         new.is_expanded = element.id() not in cls.contracted_containers
         new.level_index = level_index
         children = ifcopenshell.util.element.get_parts(element)

src/bonsai/bonsai/tool/unit.py

@@ -24,15 +24,274 @@ import ifcopenshell
 import bonsai.bim.helper
 import bonsai.core.tool
 import bonsai.tool as tool
+from lark import Lark, Transformer
 from typing import Union, Literal, Any, TYPE_CHECKING, assert_never
 
 if TYPE_CHECKING:
     from bonsai.bim.module.unit.prop import BIMUnitProperties
 
 
+def parse_distance_string(input_string: str, use_project_unit: bool = True) -> tuple[bool, float]:
+    """
+    Parse a distance string with optional unit suffixes and convert to meters.
+
+    This function parses distance inputs with units (e.g., "5m", "10ft", "3.5cm")
+    and converts them to meters (SI units) for use in IFC models.
+
+    Supports:
+    - Metric units: mm, cm, dm, m
+    - Imperial units: ft/feet ('), in/inches (")
+    - Arithmetic expressions: +, -, *, /
+    - Fractions for imperial units (e.g., 1/2")
+    - Formula mode: values starting with "="
+
+    :param input_string: The string to parse (e.g., "5m", "10ft", "10'6\"", "3.5cm", "12in")
+    :param use_project_unit: If True, uses project unit scale; if False, uses Blender unit scale
+    :return: Tuple (is_valid, value_in_meters) where is_valid indicates successful parsing
+             and value_in_meters is the converted value in meters
+
+    Examples:
+        >>> parse_distance_string("5m")
+        (True, 5.0)
+        >>> parse_distance_string("30cm")
+        (True, 0.3)
+        >>> parse_distance_string("10ft")
+        (True, 3.048)
+        >>> parse_distance_string("12in")
+        (True, 0.3048)
+        >>> parse_distance_string("5'6\"")
+        (True, 1.6764)
+        >>> parse_distance_string("invalid")
+        (False, 0.0)
+    """
+
+    grammar_imperial = r"""
+    start: (FORMULA dim expr) | dim
+    dim: imperial
+
+    FORMULA: "="
+
+    imperial: feet_inches | feet_only | inches_only | plain_number
+    feet_only: NUMBER (FEET_SYM | FEET_TEXT)
+    inches_only: inch_value (INCH_SYM | INCH_TEXT)
+    feet_inches: NUMBER (FEET_SYM | FEET_TEXT) DASH? inch_value (INCH_SYM | INCH_TEXT)?
+    plain_number: NUMBER
+
+    inch_value: NUMBER fraction | fraction | NUMBER
+
+    fraction: NUMBER "/" NUMBER
+
+    expr: (ADD | SUB) dim | (MUL | DIV) NUMBER
+
+    NUMBER: /-?(?:\d+\.?\d*|\.\d+)/
+    FEET_SYM: "'"
+    FEET_TEXT: "ft"
+    INCH_SYM: "\""
+    INCH_TEXT: "in"
+    DASH: "-"
+    ADD: "+"
+    SUB: "-"
+    MUL: "*"
+    DIV: "/"
+
+    %ignore " "
+    """
+
+    grammar_metric = r"""
+    start: FORMULA? dim expr?
+    dim: metric
+
+    FORMULA: "="
+
+    metric: NUMBER (MM | CM | DM | M | DEG)?
+
+    expr: (ADD | SUB | MUL | DIV) dim
+
+    NUMBER: /-?(?:\d+\.?\d*|\.\d+)/
+    MM: "mm"
+    CM: "cm"
+    DM: "dm"
+    M: "m"
+    DEG: "°"
+    ADD: "+"
+    SUB: "-"
+    MUL: "*"
+    DIV: "/"
+
+    %ignore " "
+    """
+
+    class InputTransform(Transformer):
+        def NUMBER(self, n):
+            return float(n)
+
+        def fraction(self, numbers):
+            return numbers[0] / numbers[1]
+
+        def inch_value(self, args):
+            # Can be: NUMBER fraction, fraction, or NUMBER
+            if len(args) == 2:
+                # NUMBER fraction (e.g., "9 1/64")
+                return args[0] + args[1]
+            else:
+                # Just fraction or just NUMBER
+                return args[0]
+
+        def plain_number(self, args):
+            # A plain number in imperial context is assumed to be feet
+            feet = args[0]
+            # Convert feet to meters (1 foot = 0.3048 meters)
+            return feet * 0.3048
+
+        def feet_only(self, args):
+            # args[0] is the number of feet, args[1] is the unit token (we can ignore it)
+            feet = args[0]
+            # Convert feet to meters (1 foot = 0.3048 meters)
+            return feet * 0.3048
+
+        def inches_only(self, args):
+            # args[0] is the inch_value, args[1] is the unit token
+            inches = args[0]
+            # Convert inches to meters (1 inch = 0.0254 meters)
+            return inches * 0.0254
+
+        def feet_inches(self, args):
+            # Extract feet and inches values
+            feet = args[0]
+            # Find the inch_value (it's a number, not a token)
+            inches = None
+            for arg in args[1:]:
+                if isinstance(arg, (int, float)):
+                    inches = arg
+                    break
+            if inches is None:
+                inches = 0
+            # Convert to meters
+            total_meters = (feet * 0.3048) + (inches * 0.0254)
+            return total_meters
+
+        def imperial(self, args):
+            # Just return the value from the sub-rule (feet_only, inches_only, or feet_inches)
+            return args[0]
+
+        def metric(self, args):
+            # args[0] is the NUMBER, args[1] if present is the unit
+            value = args[0]
+            if len(args) > 1:
+                unit = str(args[1])
+                # Convert to meters based on unit
+                if unit == "mm":
+                    value = value / 1000.0
+                elif unit == "cm":
+                    value = value / 100.0
+                elif unit == "dm":
+                    value = value / 10.0
+                elif unit == "m":
+                    value = value  # already in meters
+                elif unit == "°":
+                    value = value  # degrees, pass through
+            # If no unit specified, assume it's already in the project's unit system
+            return value
+
+        def dim(self, args):
+            return args[0]
+
+        def expr(self, args):
+            op = args[0]
+            value = float(args[1])
+            if op == "+":
+                return lambda x: x + value
+            elif op == "-":
+                return lambda x: x - value
+            elif op == "*":
+                return lambda x: x * value
+            elif op == "/":
+                return lambda x: x / value
+
+        def FORMULA(self, args):
+            return args[0]
+
+        def start(self, args):
+            i = 0
+            if args[0] == "=":
+                i += 1
+            else:
+                if len(args) > 1:
+                    raise ValueError("Invalid input.")
+            dimension = args[i]
+            if len(args) > i + 1:
+                expression = args[i + 1]
+                return expression(dimension)
+            else:
+                return dimension
+
+    try:
+        # Determine unit scale
+        if use_project_unit and tool.Ifc.get():
+            unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        else:
+            unit_scale = tool.Blender.get_unit_scale()
+
+        # Try to parse with the project's default grammar first
+        if bpy.context.scene.unit_settings.system == "IMPERIAL":
+            primary_parser = Lark(grammar_imperial)
+            fallback_parser = Lark(grammar_metric)
+        else:
+            primary_parser = Lark(grammar_metric)
+            fallback_parser = Lark(grammar_imperial)
+
+        # Try parsing with primary grammar
+        parse_tree = None
+        try:
+            parse_tree = primary_parser.parse(input_string)
+        except Exception as e:
+            # If primary fails, try fallback grammar (allows metric in imperial projects and vice versa)
+            try:
+                parse_tree = fallback_parser.parse(input_string)
+            except Exception as e2:
+                pass
+
+        if parse_tree is None:
+            return False, 0.0
+
+        # Transform the parse tree to get the numeric result
+        transformer = InputTransform()
+        result = transformer.transform(parse_tree)
+        result = round(result, 6)
+
+        return True, result
+
+    except Exception as e:
+        return False, 0.0
+
+
 class Unit(bonsai.core.tool.Unit):
     UNIT_TYPE = Literal["LENGTHUNIT", "AREAUNIT", "VOLUMEUNIT"]
 
+    @staticmethod
+    def format_distance(meters: float, use_imperial: bool = None, **kwargs) -> str:
+        """
+        Format a distance value in meters to a string in the project's unit system.
+
+        :param meters: The distance value in meters
+        :param use_imperial: If True, format as imperial; if False, format as metric; if None, auto-detect from scene
+        :param kwargs: Additional arguments to pass to the underlying format_distance function
+                    (hide_units, precision, decimal_places, etc.)
+        :return: Formatted string with units
+        """
+        # Import the comprehensive format_distance from the helper module
+        from bonsai.bim.module.drawing import helper
+
+        # The comprehensive function expects value in scene units, not meters
+        # So we pass meters directly since it handles unit conversion internally
+        return helper.format_distance(
+            meters,
+            hide_units=kwargs.get("hide_units", False),
+            precision=kwargs.get("precision"),
+            decimal_places=kwargs.get("decimal_places"),
+            **kwargs,
+        )
+
     @classmethod
     def get_unit_props(cls) -> BIMUnitProperties:
         return bpy.context.scene.BIMUnitProperties

src/bsdd/bsdd_json.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from pydantic import BaseModel
 from .type_hints import *
 from typing import Optional, Literal
 from datetime import datetime

src/bsdd/type_hints.py

@@ -1,6 +1,4 @@
-from typing import Literal, Annotated
-from datetime import datetime
-from pydantic import BeforeValidator
+from typing import Literal
 
 
 COUNTRY_CODE = Literal[

src/ifc5d/Ex1 - BoQ without query.csv

@@ -0,0 +1,10 @@
+Index,Identification,Name,Unit,Value,Quantity
+1,E.01,Walls,m3,,
+2,E.01.01,Ground floor walls,m3,100,42
+2,E.01.02,First floor walls,m3,200,35
+1,A.02,Paintings,m2,,
+2,A.03,Paintings with water,m2,,
+3,B.05,White paintings,m2,25,45
+3,B.06,Colored paintings,m2,32,33
+2,C-01,Paintings with machine,m2,17,133
+2,C-02,Decorated paintings,m2,40,8

src/ifc5d/Ex2 - SoR.csv

@@ -0,0 +1,7 @@
+Index,Identification,Name,Unit,Value,Quantity
+1,A,Group A,,,
+2,A.02,Paintings,m2,20,1
+2,A.03,Paintings with water,m2,23,1
+1,C,Group C,,,
+2,C-01,Paintings with machine,m2,32,1
+2,C-02,Decorated paintings,m2,40,2

src/ifc5d/Ex3 - BoQ with query.csv

@@ -0,0 +1,10 @@
+Index,Identification,Name,Unit,Value,Quantity,Query,Property
+1,E.01,Walls,m3,,,,
+2,E.01.01,Ground floor walls,m3,100,,"IfcWall, location=""Ground Floor""",GrossVolume
+2,E.01.02,First floor walls,m3,200,,"IfcWall, location=""First Floor""",GrossVolume
+1,A.02,Paintings,m2,,,,
+2,A.03,Paintings with water,m2,,,,
+3,B.05,White paintings,m2,25,45,,
+3,B.06,Colored paintings,m2,32,33,,
+2,C-01,Paintings with machine,m2,17,133,,
+2,C-02,Decorated paintings,m2,40,8,,

src/ifc5d/Ex4 - BoQ with description.csv

@@ -0,0 +1,10 @@
+Index,Identification,Name,Unit,Value,Quantity,Description
+1,E.01,Walls,m3,,,
+2,E.01.01,Ground floor walls,m3,100,42,"Semi-solid blocks of plain-faced common brick, with an apparent density (excluding holes) of 800 kg/m³; minor drilling 45%; apparent thermal conductivity 0.21 W/mK; characteristic mechanical strength parallel to the holes greater than or equal to 10 N/mm2, perpendicular to the holes greater than or equal to 2N/mm2"
+2,E.01.02,First floor walls,m3,200,35,"Semi-solid blocks of plain-faced common brick, with an apparent density (excluding holes) of 800 kg/m³; minor drilling 45%; apparent thermal conductivity 0.21 W/mK; characteristic mechanical strength parallel to the holes greater than or equal to 10 N/mm2, perpendicular to the holes greater than or equal to 2N/mm2"
+1,A.02,Painting,m2,,,"Painting with washable water-based wall paint for indoor/outdoor. The price includes and compensates the costs for the supply of paint, any scaffolding up to a maximum height of 4 m from the support surface, the costs for the protection of furniture, fixed systems or the protection of floors, the cleaning of the surfaces to be treated through the use of rags or net purposes in order to remove residues that can be easily removed. The cost of occasional and partial grouting of surfaces, in order to eliminate any small scratches, including sanding of the grouted parts, is also to be considered included and compensated. For 2 coats with brush or roller."
+2,A.03,Washable painting,m2,,,"Supply and installation of washable tempera paint for interiors and exteriors. The price includes and compensates for the costs of supplying the paint, any scaffolding up to a maximum height of 4 meters from the support surface, the costs of protecting furnishings, fixed installations, or floors, and cleaning the surfaces to be treated using rags or clean brushes to remove easily removable residues. On previously prepared plaster. Apply two coats with a brush or roller. (Tempera colors from the color chart)."
+3,B.05,White paintings,m2,25,45,
+3,B.06,Colored paintings,m2,32,33,
+2,C-01,External painting,m2,17,133,"Painting with plastic coating. The price includes and compensates for the costs of supplying the paint, any scaffolding up to a maximum height of 4 meters from the support surface, the costs of protecting furnishings, fixed systems, or floors, and cleaning the surfaces to be treated using rags or clean brushes to remove easily removable residues. On already prepared plaster. For 2 coats (interior textured finish)."
+2,C-02,Decorated paintings,m2,40,8,

src/ifc5d/Ex5 - SoR_with_description.csv

@@ -0,0 +1,7 @@
+Index,Identification,Name,Unit,Value,Quantity,Description
+1,A,Group A,,,,
+2,A.02,Paintings,m2,20,1,Paint made by the best painter in the world
+2,A.03,Paintings with water,m2,23,1,
+1,C,Group C,,,,
+2,C-01,Paintings with machine,m2,32,1,Best painting in the world painted with the best painted machine accordingly with ISO9001
+2,C-02,Decorated paintings,m2,40,2,

src/ifc5d/Ex6 - BoQ with categories.csv

@@ -0,0 +1,10 @@
+Index,Identification,Name,Unit,Material,Labor,Quantity
+1,E.01,Walls,m3,,,
+2,E.01.01,Ground floor walls,m3,55,45,42
+2,E.01.02,First floor walls,m3,120,80,35
+1,A.02,Painting,m2,,,
+2,A.03,Washable painting,m2,,,
+3,B.05,White paintings,m2,,,45
+3,B.06,Colored paintings,m2,,,33
+2,C-01,External painting,m2,,,133
+2,C-02,Decorated paintings,m2,,,8

src/ifc5d/Ex7 - BoQ with Rates.csv

@@ -0,0 +1,10 @@
+Index,Identification,Name,Unit,Value,Quantity,RateSchedule,RateID
+1,E.01,Walls,m3,,,,
+2,E.01.01,Ground floor walls,m3,100,42,,
+2,E.01.02,First floor walls,m3,200,35,,
+1,A.02,Paintings,m2,,,,
+2,A.03,Paintings with water,m2,,,,
+3,B.05,White paintings,m2,,45,Ex2 - SoR,A.03
+3,B.06,Colored paintings,m2,32,33,,
+2,C-01,Paintings with machine,m2,17,133,,
+2,C-02,Decorated paintings,m2,40,8,,

src/ifc5d/README.md

@@ -32,6 +32,13 @@ csv2ifc.execute()
 ```
 
 See example files as a CSV file format reference:
+- Ex1 - BoQ without query.csv (a simple Bill of Quantities)
+- Ex2 - SoR.csv (a simple Schedule of Rates)
+- Ex3 - BoQ with query.csv (a simple BoQ with the query function)
+- Ex4 - BoQ with description.csv (a simple BoQ with description column)
+- Ex5 - SoR_with_description.csv (a simple SoR with description column)
+- Ex6 - BoQ with categories.csv (a simple BoQ with categories columns)
+- Ex7 - BoQ with Rates.csv (a simple BoQ that connect to an existing SoR. It needs an already loaded SoR.)
 - `sample_cost_schedule_house_FR.csv` / `.ods`
 - `schedule.csv`, `rates.csv` (schedule of rates example)
 
@@ -124,4 +131,4 @@ path = "directory/cost_schedule"
 writer = Ifc5DOdsWriter(file=file, output=path)
 writer.write()
 
-```
+```

src/ifcconvert/CMakeLists.txt

@@ -14,4 +14,8 @@ if(WITH_RELATIONSHIP_VALIDATION)
     set_property(TARGET IfcConvert APPEND_STRING PROPERTY COMPILE_FLAGS " -DWITH_RELATIONSHIP_VALIDATION")
 endif()
 
-install(TARGETS IfcConvert)
+install(TARGETS IfcConvert
+    ARCHIVE DESTINATION ${LIBDIR}
+    RUNTIME DESTINATION ${BINDIR}
+    LIBRARY DESTINATION ${LIBDIR}
+)

src/ifcgeom/kernels/CMakeLists.txt

@@ -4,29 +4,34 @@ foreach(kernel ${GEOMETRY_KERNELS})
     file(GLOB IFCGEOM_CPP_FILES ${kernel}/*.cpp)
     set(IFCGEOM_FILES ${IFCGEOM_CPP_FILES} ${IFCGEOM_H_FILES})
 
-    add_library(geometry_kernel_${kernel} OBJECT ${IFCGEOM_FILES})
-    set_property(TARGET geometry_kernel_${kernel} APPEND PROPERTY COMPILE_FLAGS "-DIFC_GEOM_EXPORTS")
-    list(APPEND kernel_libraries geometry_kernel_${kernel})
-    target_link_libraries(geometry_kernel_${kernel} ${${KERNEL_UPPER}_LIBRARIES})
+    set(KERNEL_TARGET "geometry_kernel_${kernel}")
 
-    install(TARGETS geometry_kernel_${kernel}
+    add_library(${KERNEL_TARGET} OBJECT ${IFCGEOM_FILES})
+    set_property(TARGET ${KERNEL_TARGET} APPEND PROPERTY COMPILE_FLAGS "-DIFC_GEOM_EXPORTS")
+    list(APPEND kernel_libraries ${KERNEL_TARGET})
+    target_link_libraries(${KERNEL_TARGET} ${${KERNEL_UPPER}_LIBRARIES})
+
+    install(TARGETS ${KERNEL_TARGET}
         ARCHIVE DESTINATION ${LIBDIR}
         LIBRARY DESTINATION ${LIBDIR}
         RUNTIME DESTINATION ${BINDIR}
     )
 
     if(${kernel} STREQUAL "cgal")
-        set_property(TARGET geometry_kernel_${kernel} APPEND_STRING PROPERTY COMPILE_FLAGS " -DCGAL_HAS_THREADS")
+        set_property(TARGET ${KERNEL_TARGET} APPEND_STRING PROPERTY COMPILE_FLAGS " -DCGAL_HAS_THREADS")
 
-        add_library(geometry_kernel_${kernel}_simple OBJECT ${IFCGEOM_FILES})
-        set_target_properties(geometry_kernel_${kernel}_simple PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIFOPSH_SIMPLE_KERNEL -DCGAL_HAS_THREADS")
-        list(APPEND kernel_libraries geometry_kernel_${kernel}_simple)
-        target_link_libraries(geometry_kernel_${kernel}_simple ${${KERNEL_UPPER}_LIBRARIES} Eigen3::Eigen)
-        install(TARGETS geometry_kernel_${kernel}_simple
+        set(KERNEL_TARGET_SIMPLE "${KERNEL_TARGET}_simple")
+        add_library(${KERNEL_TARGET_SIMPLE} OBJECT ${IFCGEOM_FILES})
+        set_target_properties(${KERNEL_TARGET_SIMPLE} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIFOPSH_SIMPLE_KERNEL -DCGAL_HAS_THREADS")
+        list(APPEND kernel_libraries ${KERNEL_TARGET_SIMPLE})
+        target_link_libraries(${KERNEL_TARGET_SIMPLE} ${${KERNEL_UPPER}_LIBRARIES} Eigen3::Eigen)
+        install(TARGETS ${KERNEL_TARGET_SIMPLE}
             ARCHIVE DESTINATION ${LIBDIR}
             LIBRARY DESTINATION ${LIBDIR}
             RUNTIME DESTINATION ${BINDIR}
         )
+    elseif(${kernel} STREQUAL "opencascade")
+        target_link_libraries(${KERNEL_TARGET} ${OpenCASCADE_LIBRARIES})
     endif()
 
     install(FILES ${IFCGEOM_H_FILES}

src/ifcgeom/kernels/ifc_geomlibrary_api.h

@@ -22,7 +22,7 @@
 
 #ifdef IFC_SHARED_BUILD
 #ifdef _WIN32
-#ifdef IFC_GEOMLIBRARY_EXPORTS
+#ifdef IFC_GEOM_EXPORTS
 #define IFC_GEOMLIBRARY_API __declspec(dllexport)
 #else
 #define IFC_GEOMLIBRARY_API __declspec(dllimport)

src/ifcgeomserver/CMakeLists.txt

@@ -5,4 +5,8 @@ set(SOURCE_FILES ${CPP_FILES})
 add_executable(IfcGeomServer ${SOURCE_FILES})
 target_link_libraries(IfcGeomServer IfcGeom ${kernel_libraries} ${OpenCASCADE_LIBRARIES})
 
-install(TARGETS IfcGeomServer)
+install(TARGETS IfcGeomServer
+    ARCHIVE DESTINATION ${LIBDIR}
+    LIBRARY DESTINATION ${LIBDIR}
+    RUNTIME DESTINATION ${BINDIR}
+)

src/ifcmax/CMakeLists.txt

@@ -35,12 +35,12 @@ if(HAS_MAX)
 
         message(STATUS "Building IFCMax library for Autodesk 3ds Max SDK ${max_year}")
 
-        include_directories(${INCLUDE_DIRECTORIES} ${OCC_INCLUDE_DIR} ${OPENCOLLADA_INCLUDE_DIRS} ${ICU_INCLUDE_DIR}
+        include_directories(${INCLUDE_DIRECTORIES} ${OPENCOLLADA_INCLUDE_DIRS} ${ICU_INCLUDE_DIR}
             ${Boost_INCLUDE_DIRS} ${max_sdk}/include
         )
 
         # All recent versions of 3ds Max (2014 and newer) are 64-bit only so assume lib/x64 directory
-        link_directories(${LINK_DIRECTORIES} ${IfcOpenShell_BINARY_DIR} ${OCC_LIBRARY_DIR} ${OPENCOLLADA_LIBRARY_DIR}
+        link_directories(${LINK_DIRECTORIES} ${IfcOpenShell_BINARY_DIR} ${OPENCOLLADA_LIBRARY_DIR}
             ${ICU_LIBRARY_DIR} ${Boost_LIBRARY_DIRS} ${max_sdk}/lib/x64/Release
         )
 
@@ -79,7 +79,11 @@ if(HAS_MAX)
 
         set_target_properties(IfcMax_${max_year} PROPERTIES SUFFIX ".dli")
 
-        install(TARGETS IfcMax_${max_year} RUNTIME DESTINATION ${BINDIR})
+        install(TARGETS IfcMax_${max_year}
+            ARCHIVE DESTINATION ${LIBDIR}
+            LIBRARY DESTINATION ${LIBDIR}
+            RUNTIME DESTINATION ${BINDIR}
+        )
     endforeach()
 else()
     message(STATUS "Autodesk 3ds Max SDK not found, is required to build IFCMax.")

src/ifcopenshell-python/docs/conf.py

@@ -103,7 +103,13 @@ autoapi_dirs = [
 # autoapi_dirs = ['../../bcf/bcf', '../../bsdd', '../../ifccsv', '../../ifcdiff', '../../ifcpatch/ifcpatch', '../../ifctester/ifctester']
 
 # These are auto-generated based on the IFC schema, so exclude them
-autoapi_ignore = ["*ifcopenshell/express/rules*"]
+# Temporarily ignore bsdd files until they are packaged properly in the wheel.
+autoapi_ignore = [
+    "*ifcopenshell/express/rules*",
+    "*bsdd/bsdd_json.py",
+    "*bsdd/type_hints.py",
+    "*bsdd/yml_to_classes.py",
+]
 
 # Custom autoapi templates to make it easier to read our docs
 autoapi_template_dir = "_autoapi_templates"

src/ifcopenshell-python/ifcopenshell/util/element.py

@@ -35,6 +35,9 @@ MATERIAL_TYPE = Literal[
     "IfcMaterialList",
 ]
 
+PrioritisedLayer = namedtuple("PrioritisedLayer", "priority material thickness")
+PrioritisedProfile = namedtuple("PrioritisedProfile", "priority material profile")
+
 
 def get_pset(
     element: ifcopenshell.entity_instance,
@@ -1845,3 +1848,48 @@ def has_openings(element: ifcopenshell.entity_instance) -> bool:
     :return: True if element has openings.
     """
     return bool(next(get_openings(element), False))
+
+
+def get_material_layers(element: ifcopenshell.entity_instance) -> list[PrioritisedLayer]:
+    """
+    Retrieves all material layers assigned to an element.
+    :param element: The IFC element
+    :return: A list of IfcMaterialLayer entities
+
+    Example:
+    .. code:: python
+        element = ifcopenshell.by_type("IfcWall")[0]
+        material_layers = ifcopenshell.util.element.get_material_layers(element)
+    """
+    material = ifcopenshell.util.element.get_material(element, should_skip_usage=True)
+    if not material or not material.is_a("IfcMaterialLayerSet"):
+        return []
+    return [
+        PrioritisedLayer(getattr(layer, "Priority", 0) or 0, layer.Material, layer.LayerThickness)
+        for layer in material.MaterialLayers
+    ]
+
+
+def get_material_profiles(element: ifcopenshell.entity_instance) -> list[PrioritisedProfile]:
+    """
+    Retrieves all material profiles assigned to an element.
+
+    :param element: The IFC element
+    :return: A list of IfcMaterialProfile entities
+
+    Example:
+
+    .. code:: python
+
+        element = ifcopenshell.by_type("IfcBeam")[0]
+        material_profiles = ifcopenshell.util.element.get_material_profiles(element)
+    """
+    material = ifcopenshell.util.element.get_material(element, should_skip_usage=True)
+    if not material or not material.is_a("IfcMaterialProfileSet"):
+        return []
+    return [
+        PrioritisedProfile(
+            getattr(material_profile, "Priority", 0) or 0, material_profile.Material, material_profile.Profile
+        )
+        for material_profile in material.MaterialProfiles
+    ]

src/ifcopenshell-python/ifcopenshell/util/unit.py

@@ -773,8 +773,9 @@ def format_length(
             if output_unit == "foot":
                 return f"{feet}' - {whole} {remainder}/{frac.denominator}\""
             return f'{(feet * 12) + whole} {remainder}/{frac.denominator}"'
+        # When we have a proper fraction (numerator < denominator), show "0 frac"
         if output_unit == "foot":
-            return f"{feet}' - {frac.numerator}/{frac.denominator}\""
+            return f"{feet}' - 0 {frac.numerator}/{frac.denominator}\""
         return f'{feet * 12} {frac.numerator}/{frac.denominator}"'
     elif unit_system == "metric":
         rounded_val = round(value / precision) * precision

src/ifcparse/IfcFile.cpp

@@ -705,6 +705,7 @@ std::optional<std::tuple<size_t, const IfcParse::declaration*, IfcEntityInstance
                 entity_type = schema_->declaration_by_name(TokenFunc::asStringRef(token_stream_[2]));
             } catch (const IfcException& ex) {
                 Logger::Message(Logger::LOG_ERROR, std::string(ex.what()) + " at offset " + std::to_string(token_stream_[2].startPos));
+                current_id = 0;
                 goto advance;
             }
 

src/ifcparse/IfcParse.cpp

@@ -1607,6 +1607,11 @@ void IfcParse::impl::in_memory_file_storage::read_from_stream(IfcParse::FileRead
 	// Move the storage of simple type instances so that they are retained during the lifetime of the file
     read_simple_type_instances = streamer.stealInstances();
 
+    // Set file ownership on simple type instances, so that when adding them to other files, proper copies are created
+    for (auto& inst : read_simple_type_instances) {
+        inst->file_ = file;
+    }
+
     Logger::Status("\rDone scanning file   ");
 
     delete tokens;

src/serializers/CMakeLists.txt

@@ -17,9 +17,13 @@ if(WITH_PROJ)
     target_link_libraries(Serializers PRIVATE proj::proj)
 endif()
 
-target_link_libraries(Serializers ${SERIALIZER_SCHEMA_LIBRARIES} ${OPENCOLLADA_LIBRARIES} ${USD_LIBRARIES} IfcGeom ${OPENCASCADE_LIBRARIES} ${kernel_libraries} IfcParse)
+target_link_libraries(Serializers PRIVATE ${SERIALIZER_SCHEMA_LIBRARIES} ${OPENCOLLADA_LIBRARIES} ${USD_LIBRARIES} IfcGeom ${OPENCASCADE_LIBRARIES} ${kernel_libraries} IfcParse)
 
-install(TARGETS Serializers)
+install(TARGETS Serializers
+    ARCHIVE DESTINATION ${LIBDIR}
+    RUNTIME DESTINATION ${BINDIR}
+    LIBRARY DESTINATION ${LIBDIR}
+)
 
 install(FILES ${SERIALIZERS_H_FILES}
     DESTINATION ${INCLUDEDIR}/serializers/

src/serializers/JsonSerializer.cpp

@@ -1,3 +1,24 @@
+/********************************************************************************
+*                                                                              *
+* This file is part of IfcOpenShell.                                           *
+*                                                                              *
+* IfcOpenShell is free software: you can redistribute it and/or modify         *
+* it under the terms of the Lesser GNU General Public License as published by  *
+* the Free Software Foundation, either version 3.0 of the License, or          *
+* (at your option) any later version.                                          *
+*                                                                              *
+* IfcOpenShell is distributed in the hope that it will be useful,              *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+* Lesser GNU General Public License for more details.                          *
+*                                                                              *
+* You should have received a copy of the Lesser GNU General Public License     *
+* along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+*                                                                              *
+********************************************************************************/
+
+#ifdef WITH_GLTF
+
 #include "JsonSerializer.h"
 
 #include <boost/algorithm/string/case_conv.hpp>
@@ -40,3 +61,5 @@ JsonSerializerFactory::Factory& JsonSerializerFactory::implementations() {
     static JsonSerializerFactory::Factory impl;
     return impl;
 }
+
+#endif

src/serializers/schema_dependent/CMakeLists.txt

@@ -3,7 +3,7 @@ file(GLOB SERIALIZERS_S_CPP_FILES *.cpp)
 set(SERIALIZERS_S_FILES ${SERIALIZERS_S_H_FILES} ${SERIALIZERS_S_CPP_FILES})
 
 foreach(schema ${SCHEMA_VERSIONS})
-    add_library(Serializers_ifc${schema} STATIC ${SERIALIZERS_S_FILES})
+    add_library(Serializers_ifc${schema} OBJECT ${SERIALIZERS_S_FILES})
     set(SERIALIZER_SCHEMA_LIBRARIES ${SERIALIZER_SCHEMA_LIBRARIES} Serializers_ifc${schema})
     set_target_properties(Serializers_ifc${schema} PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS -DIfcSchema=Ifc${schema}")
     if(WASM_BUILD)
@@ -12,8 +12,12 @@ foreach(schema ${SCHEMA_VERSIONS})
         target_link_libraries(Serializers_ifc${schema} IfcGeom ${OPENCASCADE_LIBRARIES} ${HDF5_LIBRARIES})
     endif()
 
-    install(TARGETS Serializers_ifc${schema})
+    install(TARGETS Serializers_ifc${schema}
+        ARCHIVE DESTINATION ${LIBDIR}
+        RUNTIME DESTINATION ${BINDIR}
+        LIBRARY DESTINATION ${LIBDIR}
+    )
 endforeach()
 
 
-set(SERIALIZER_SCHEMA_LIBRARIES ${SERIALIZER_SCHEMA_LIBRARIES} PARENT_SCOPE)
+set(SERIALIZER_SCHEMA_LIBRARIES ${SERIALIZER_SCHEMA_LIBRARIES} PARENT_SCOPE)

win/build-all.cmd

@@ -23,7 +23,7 @@
 :: Usage example for doing an optimized vs2015-x64 build with debug information and using IFC 4:
 :: > build-all.cmd vs2015-x64 RelWithDebInfo -DUSE_IFC4=1 -DENABLE_BUILD_OPTIMIZATIONS=1
 
-@echo off
+@if not defined ECHO_ON ( echo off )
 
 setlocal EnableDelayedExpansion
 

win/build-deps.cmd

@@ -24,7 +24,7 @@
 :: Example usage (all arguments are optional):
 :: build-deps.cmd vs2022-x64 RelWithDebInfo Build
 
-@echo off
+@if not defined ECHO_ON ( echo off )
 echo.
 
 for %%Q in ("%~dp0\.") DO set "batpath=%%~fQ"
@@ -274,7 +274,7 @@ call :DownloadFile https://download.osgeo.org/proj/proj-9.2.1.zip "%DEPS_DIR%" p
 IF NOT %ERRORLEVEL%==0 GOTO :Error
 call :ExtractArchive proj-9.2.1.zip "%DEPS_DIR%" "%DEPS_DIR%\proj-9.2.1"
 IF NOT %ERRORLEVEL%==0 GOTO :Error
-cd "%DEPENDENCY_DIR%"
+pushd "%DEPENDENCY_DIR%"
 call :RunCMake -DCMAKE_INSTALL_PREFIX="%INSTALL_DIR%\proj-9.2.1" ^
     -DSQLITE3_INCLUDE_DIR=%INSTALL_DIR%\sqlite3\include ^
     -DSQLITE3_LIBRARY=%INSTALL_DIR%\sqlite3\lib\sqlite3.lib ^
@@ -286,6 +286,7 @@ call :BuildSolution "%DEPENDENCY_DIR%\%BUILD_DIR%\PROJ.sln" %BUILD_CFG%
 IF NOT %ERRORLEVEL%==0 GOTO :Error
 call :InstallCMakeProject "%DEPENDENCY_DIR%\%BUILD_DIR%" %BUILD_CFG%
 IF NOT %ERRORLEVEL%==0 GOTO :Error
+popd
 
 
 :mpir
@@ -299,7 +300,7 @@ set DEPENDENCY_NAME=mpir
 set DEPENDENCY_DIR=%DEPS_DIR%\mpir
 call :GitCloneAndCheckoutRevision https://github.com/BrianGladman/mpir.git "%DEPENDENCY_DIR%"
 IF NOT %ERRORLEVEL%==0 GOTO :Error
-cd "%DEPENDENCY_DIR%"
+pushd "%DEPENDENCY_DIR%"
 git reset --hard
 git clean -fdx
 REM There probably need to be quotes here around the filename
@@ -316,6 +317,7 @@ IF NOT %ERRORLEVEL%==0 GOTO :Error
 IF NOT EXIST "%INSTALL_DIR%\mpir". mkdir "%INSTALL_DIR%\mpir"
 copy ..\..\lib\%VS_PLATFORM%\%DEBUG_OR_RELEASE%\* "%INSTALL_DIR%\mpir"
 IF NOT %ERRORLEVEL%==0 GOTO :Error
+popd
 
 :mpfr
 
@@ -328,7 +330,7 @@ set DEPENDENCY_NAME=mpfr
 set DEPENDENCY_DIR=%DEPS_DIR%\mpfr
 call :GitCloneAndCheckoutRevision https://github.com/aothms/mpfr.git "%DEPENDENCY_DIR%" 2ebbe10fd029a480cf6e8a64c493afa9f3654251
 IF NOT %ERRORLEVEL%==0 GOTO :Error
-cd "%DEPENDENCY_DIR%"
+pushd "%DEPENDENCY_DIR%"
 git reset --hard
 powershell -c "get-content %~dp0patches\mpfr.patch | %%{$_ -replace \"sdk\",\"%UCRTVersion%\"} | %%{$_ -replace \"fn\",\"lib_mpfr\"}" | git apply --unidiff-zero --ignore-whitespace
 IF NOT %ERRORLEVEL%==0 GOTO :Error
@@ -349,12 +351,12 @@ IF NOT EXIST lib\%VS_PLATFORM%\%DEBUG_OR_RELEASE%\mpfr.lib GOTO :Error
 IF NOT EXIST "%INSTALL_DIR%\mpfr". mkdir "%INSTALL_DIR%\mpfr"
 copy lib\%VS_PLATFORM%\%DEBUG_OR_RELEASE%\* "%INSTALL_DIR%\mpfr"
 IF NOT %ERRORLEVEL%==0 GOTO :Error
+popd
 
 :HDF5
 
 set DEPENDENCY_NAME=hdf5
 set DEPENDENCY_DIR=%DEPS_DIR%\hdf5-%HDF5_VERSION%
-cd "%DEPENDENCY_DIR%"
 set HDF5_CMAKE_ZIP=hdf5-%HDF5_VERSION%.zip
 set HDF5_INSTALL_NAME=HDF5-%HDF5_VERSION%-win%ARCH_BITS%
 
@@ -370,7 +372,7 @@ call :DownloadFile ^
 IF NOT %ERRORLEVEL%==0 GOTO :Error
 call :ExtractArchive %HDF5_CMAKE_ZIP% "%DEPS_DIR%" "%DEPS_DIR%\hdf5-%HDF5_VERSION%"
 IF NOT %ERRORLEVEL%==0 GOTO :Error
-ren "%DEPS_DIR%\hdf5-hdf5-%HDF5_VERSION%" "hdf5-%HDF5_VERSION%"
+if exist "%DEPS_DIR%\hdf5-hdf5-%HDF5_VERSION%" ren "%DEPS_DIR%\hdf5-hdf5-%HDF5_VERSION%" "hdf5-%HDF5_VERSION%"
 pushd "%DEPENDENCY_DIR%"
 call :RunCMake -DCMAKE_INSTALL_PREFIX="%INSTALL_DIR%\%HDF5_INSTALL_NAME%" ^
                -DHDF5_ENABLE_Z_LIB_SUPPORT=OFF -DBUILD_TESTING=OFF ^
@@ -424,7 +426,7 @@ set BOOST_LIBS=--with-system --with-regex --with-thread --with-program_options -
 :: NOTE Boost is fast to build with limited set of libraries so build it always.
 cd "%DEPENDENCY_DIR%"
 call cecho.cmd 0 13 "Building %DEPENDENCY_NAME% %BOOST_LIBS% Please be patient, this will take a while."
-IF EXIST "%DEPENDENCY_DIR%\bin.v2\project-cache.jam" del "%DEPS_DIR%\boost\bin.v2\project-cache.jam"
+IF EXIST "%DEPENDENCY_DIR%\bin.v2\project-cache.jam" del "%DEPENDENCY_DIR%\bin.v2\project-cache.jam"
 
 call .\b2 toolset=%BOOST_TOOLSET% runtime-link=shared address-model=%ARCH_BITS% --abbreviate-paths -j%IFCOS_NUM_BUILD_PROCS% ^
     variant=%DEBUG_OR_RELEASE_LOWERCASE% %BOOST_WIN_API% %BOOST_LIBS% stage --stagedir=%DEPENDENCY_INSTALL_DIR%
@@ -482,12 +484,13 @@ IF EXIST "%INSTALL_DIR%\opencascade-%OCCT_VERSION%" (
 :: OCCT has many dependencies but FreeType is the only mandatory
 set DEPENDENCY_NAME=FreeType
 set DEPENDENCY_DIR=%DEPS_DIR%\freetype-2.7.1
-set FREETYPE_ZIP=ft271.zip
+set FREETYPE_ZIP=VER-2-7-1.zip
 cd "%DEPS_DIR%"
-call :DownloadFile https://download-mirror.savannah.gnu.org/releases/freetype/ft271.zip "%DEPS_DIR%" %FREETYPE_ZIP%
+call :DownloadFile https://github.com/freetype/freetype/archive/refs/tags/%FREETYPE_ZIP% "%DEPS_DIR%" %FREETYPE_ZIP%
 if not %ERRORLEVEL%==0 goto :Error
 call :ExtractArchive %FREETYPE_ZIP% "%DEPS_DIR%" "%DEPENDENCY_DIR%"
 if not %ERRORLEVEL%==0 goto :Error
+if exist "%DEPS_DIR%\freetype-VER-2-7-1" ren "%DEPS_DIR%\freetype-VER-2-7-1" "freetype-2.7.1"
 cd "%DEPENDENCY_DIR%"
 :: NOTE FreeType is built as a static library by default
 call :RunCMake -DCMAKE_INSTALL_PREFIX="%INSTALL_DIR%\freetype"
@@ -714,6 +717,10 @@ call :RunCMake -DCMAKE_INSTALL_PREFIX="%INSTALL_DIR%\rocksdb" ^
                -DROCKSDB_INSTALL_ON_WINDOWS=On ^
                -DFAIL_ON_WARNINGS=Off ^
                -DWITH_TESTS=OFF ^
+               -DWITH_TOOLS=OFF ^
+               -DWITH_BENCHMARK_TOOLS=OFF ^
+               -DWITH_CORE_TOOLS=OFF ^
+               -DROCKSDB_BUILD_SHARED=OFF ^
                -DWITH_ZSTD=On ^
                -DPORTABLE=1
 IF NOT %ERRORLEVEL%==0 GOTO :Error
@@ -812,8 +819,8 @@ if not exist "%~3". (
 ) else (
     call cecho.cmd 0 13 "%DEPENDENCY_NAME% already downloaded. Skipping."
 )
-set LAST_ACTION=DownloadFile '%DEPENDENCY_NAME%'.
 set RET=%ERRORLEVEL%
+set LAST_ACTION=DownloadFile '%DEPENDENCY_NAME%'.
 popd
 exit /b %RET%
 
@@ -826,8 +833,9 @@ if not exist "%~3". (
 ) else (
     call cecho.cmd 0 13 "%DEPENDENCY_NAME% already extracted into %~3. Skipping."
 )
+set RET=%ERRORLEVEL%
 set LAST_ACTION=ExtractArchive '%DEPENDENCY_NAME%'.
-exit /b %ERRORLEVEL%
+exit /b %RET%
 
 :: GitCloneOrPullRepository - Clones or pulls (if repository already cloned) a Git repository
 :: Params: %1 gitUrl, %2 destDir
@@ -837,7 +845,7 @@ if not exist "%~2". (
     call cecho.cmd 0 13 "Cloning %DEPENDENCY_NAME% into %~2."
     pushd "%DEPS_DIR%"
     call git clone %1 %2
-    set RET=%ERRORLEVEL%
+    set RET=!ERRORLEVEL!
 ) else (
     call cecho.cmd 0 13 "%DEPENDENCY_NAME% already cloned. Pulling latest changes."
     git reset --hard
@@ -856,8 +864,8 @@ if not exist "%~2". (
     call cecho.cmd 0 13 "Cloning %DEPENDENCY_NAME% into %~2."
     pushd "%DEPS_DIR%"
     call git clone %1 %2
-    set RET=%ERRORLEVEL%
-    if not "%RET%"=="0" exit /b %RET%
+    set RET=!ERRORLEVEL!
+    if not "!RET!"=="0" exit /b !RET!
     popd
 ) else (
     call cecho.cmd 0 13 "%DEPENDENCY_NAME% already cloned."
@@ -953,3 +961,4 @@ echo   - https://msdn.microsoft.com/en-us/library/ms229859(v=vs.110).aspx
 echo.
 echo NB: This script needs to be ran from the directory directly containing it.
 echo.
+

win/build-ifcopenshell.bat

@@ -21,7 +21,7 @@
 :: a deduced generator will be used for %1 and BUILD_CFG_DEFAULT for %2 (both set in vs-cfg.cmd)
 :: Possible extra parameters are passed for the MSBuild call.
 
-@echo off
+@if not defined ECHO_ON ( echo off )
 set PROJECT_NAME=IfcOpenShell
 echo.
 

win/build-type-cfg.cmd

@@ -20,7 +20,7 @@
 :: This script initializes various CMake build configuration type related variables.
 :: This batch file expects CMake build configuration type as %1.
 
-@echo off
+@if not defined ECHO_ON ( echo off )
 
 :: Set up variables depending on the used build configuration type.
 set BUILD_CFG=%1

win/install-ifcopenshell.bat

@@ -21,7 +21,7 @@
 :: a deduced generator will be used for %1 and BUILD_CFG_DEFAULT for %2 (both set in vs-cfg.cmd)
 :: Possible extra parameters are passed for the MSBuild call.
 
-@echo off
+@if not defined ECHO_ON ( echo off )
 set PROJECT_NAME=IfcOpenShell
 echo.
 

win/run-cmake.bat

@@ -17,7 +17,7 @@
 ::                                                                             ::
 :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
-@echo off
+@if not defined ECHO_ON ( echo off )
 echo.
 
 set PROJECT_NAME=IfcOpenShell
@@ -110,6 +110,8 @@ set GMP_INCLUDE_DIR=%INSTALL_DIR%\mpir
 set GMP_LIBRARY_DIR=%INSTALL_DIR%\mpir
 set MPFR_INCLUDE_DIR=%INSTALL_DIR%\mpfr
 set MPFR_LIBRARY_DIR=%INSTALL_DIR%\mpfr
+:: We don't install Eigen currently,
+:: so there's no Eigen3config.cmake and therefore we provide path explicitly.
 set EIGEN_DIR=%INSTALL_DIR%\Eigen
 set USD_INCLUDE_DIR=%INSTALL_DIR%\usd\include
 set USD_LIBRARY_DIR=%INSTALL_DIR%\usd\lib

win/set-python-to-path.bat

@@ -19,7 +19,7 @@
 
 :: Pass x86 or x64 as %1, if not specified x64 assumed.
 
-@echo off
+@if not defined ECHO_ON ( echo off )
 set TARGET_ARCH=%1
 if "%TARGET_ARCH%"=="" set TARGET_ARCH=x64
 if not exist "%~dp0BuildDepsCache-%TARGET_ARCH%.txt". (

win/utils/cecho.cmd

@@ -1,3 +1,4 @@
+:: Don't check for `ECHO_ON` or it will get too verbose without any benefit.
 @echo off
 setlocal ENABLEDELAYEDEXPANSION
 
@@ -38,5 +39,6 @@ if defined BGC (
 
 echo|set /p="!STYLE!!TEXT!!ESC![0m"
 echo.
+if defined ECHO_ON ( echo on )
 endlocal
 exit /b 0

win/vs-cfg.cmd

@@ -36,7 +36,7 @@
 ::
 :: NOTE: The delayed environment variable expansion needs to be enabled before calling this.
 
-@echo off
+@if not defined ECHO_ON ( echo off )
 
 set GENERATOR=%1