Interface mockup 17

Adds VisibilityState, a CPU-only sibling to SelectionState.  It owns
the canonical hidden-id set plus a flat per-object_id byte vector that
the cull's hot path queries inline (bounds check + byte load + compare
per surviving instance).  Hidden elements never reach the visible[]
SSBO so they don't draw or pick — matching Blender/CAD convention.

ViewportWindow registers every streamed and sidecar-cached object_id
with the new state, resets it on clearScene, and connects the changed
signal to invalidate cached cull state.  Three convenience verbs:
hideSelectedElements (union into hidden), isolateSelectedElements
(replace hidden with live-object_ids minus selection, skipping
model-hidden models so element-hide doesn't pile on top of model-hide),
and showAllElements (clears the override; model-hidden models stay
hidden, per the user's spec).

Bound in the View menu: H hide, Shift+H isolate, Alt+H show all.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

.github/scripts/publish-bonsai-releases.py

@@ -1,95 +0,0 @@
-#!/usr/bin/env -S uv run
-# /// script
-# dependencies = [
-#     "PyGithub",
-#     "requests",
-# ]
-# ///
-
-import os
-from pathlib import Path
-
-import requests
-from github import Github
-from github.GitReleaseAsset import GitReleaseAsset
-
-EXTENSION_ID = "bonsai"
-CURRENT_PYTHON_VERSION = "py313"
-CURRENT_PLATFORMS = ["linux-x64", "macos-arm64", "windows-x64"]
-
-
-def publish_asset(asset: GitReleaseAsset, token: str, repo_root: Path) -> None:
-    """
-    Publish an asset to Blender Extensions.
-    Reference: https://extensions.blender.org/api/v1/swagger
-    """
-    temp_path = repo_root / asset.name
-
-    response = requests.get(asset.browser_download_url)
-    response.raise_for_status()
-    temp_path.write_bytes(response.content)
-
-    url = f"https://extensions.blender.org/api/v1/extensions/{EXTENSION_ID}/versions/upload/"
-    headers = {"Authorization": f"Bearer {token}"}
-
-    files = {"version_file": temp_path.read_bytes()}
-    response = requests.post(url, headers=headers, files=files)
-    response.raise_for_status()
-
-    temp_path.unlink()
-
-    print(f"✓ Published {asset.name}")
-
-
-def main() -> None:
-    token = os.getenv("BLENDER_EXTENSIONS_TOKEN")
-    if not token:
-        raise Exception("BLENDER_EXTENSIONS_TOKEN environment variable not set")
-
-    # Get the repository root
-    repo_root = Path(__file__).parent.parent.parent
-
-    # Read VERSION file
-    version_file = repo_root / "VERSION"
-    version = version_file.read_text().strip()
-
-    print(f"Current VERSION: {version}")
-
-    tag_name = f"bonsai-{version}"
-
-    # Get release from GitHub
-    gh = Github()
-    gh_repo = gh.get_repo("IfcOpenShell/IfcOpenShell")
-    release = gh_repo.get_release(tag_name)
-
-    assets = release.get_assets()
-
-    asset_platform_map: dict[str, tuple[GitReleaseAsset, str]] = {}
-    for asset in assets:
-        if CURRENT_PYTHON_VERSION not in asset.name:
-            continue
-        for platform in CURRENT_PLATFORMS:
-            if platform in asset.name:
-                asset_platform_map[asset.name] = (asset, platform)
-                break
-
-    if len(asset_platform_map) != len(CURRENT_PLATFORMS):
-        found_platforms = {platform for _, (_, platform) in asset_platform_map.items()}
-        missing_platforms = set(CURRENT_PLATFORMS) - found_platforms
-        raise Exception(
-            f"Expected {len(CURRENT_PLATFORMS)} assets but found {len(asset_platform_map)}. "
-            f"Missing: {', '.join(sorted(missing_platforms))}"
-        )
-
-    print("\nRelease assets:")
-    for asset_name in sorted(asset_platform_map.keys()):
-        print(f"- {asset_name}")
-
-    # https://extensions.blender.org/api/v1/swagger
-    print("\nPublishing assets to Blender Extensions:")
-    for asset_name, (asset, platform) in asset_platform_map.items():
-        publish_asset(asset, token, repo_root)
-
-
-if __name__ == "__main__":
-    main()

.github/workflows/build_osx.yml

@@ -53,7 +53,7 @@ jobs:
           python ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: mac-${{ matrix.arch }}
 
@@ -110,7 +110,20 @@ jobs:
         run: |
           VERSION=v`cat VERSION`
           cd ./build/`uname`/*/10.15/install/ifcopenshell
-          mkdir ~/output
+          mkdir -p ~/output
+          install_root="$PWD"
+
+          stage_runtime_payload() {
+              dest="$1"
+              while IFS= read -r runtime_file; do
+                  cp -L "$runtime_file" "$dest/"
+              done < <(
+                  for runtime_dir in "$install_root/bin" "$install_root/lib" "$install_root/lib64"; do
+                      [ -d "$runtime_dir" ] || continue
+                      find "$runtime_dir" -type f \( -name "*.so" -o -name "*.so.*" -o -name "*.dylib" -o -name "*.dll" \)
+                  done
+              )
+          }
 
           ls -d python-* | while read py_version; do
               postfix=`echo ${py_version: -1} | sed s/[0-9]//`
@@ -125,18 +138,25 @@ jobs:
               fi
               [ -d ifcopenshell/__pycache__ ] && rm -rf ifcopenshell/__pycache__
               find ifcopenshell -name "*.pyc" -delete
-              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-macos${{ matrix.oldarch }}64.zip ifcopenshell/*
+              stage_runtime_payload ifcopenshell
+              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-macos${{ matrix.oldarch }}64.zip ifcopenshell
               mv *.zip ~/output
               popd > /dev/null
           done
 
-          cd bin
-          rm *.zip || true
-          ls | while read exe; do
-              zip -qq -r ${exe}-${VERSION}-${GITHUB_SHA:0:7}-macos${{ matrix.oldarch }}64.zip $exe
+          rm -f "$install_root"/bin/*.zip
+          find "$install_root/bin" -maxdepth 1 -type f -perm /111 ! -name "*.zip" ! -name "*.so" ! -name "*.so.*" ! -name "*.dylib" ! -name "*.dll" | while read exe_path; do
+              exe=`basename "$exe_path"`
+              package_dir="$install_root/.package-${exe}"
+              rm -rf "$package_dir"
+              mkdir -p "$package_dir"
+              cp "$exe_path" "$package_dir/"
+              stage_runtime_payload "$package_dir"
+              pushd "$package_dir" > /dev/null
+              zip -qq -r "$HOME/output/${exe}-${VERSION}-${GITHUB_SHA:0:7}-macos${{ matrix.oldarch }}64.zip" .
+              popd > /dev/null
+              rm -rf "$package_dir"
           done
-          mv *.zip ~/output
-          cd ..
 
       - name: Configure AWS credentials
         uses: aws-actions/configure-aws-credentials@v6

.github/workflows/build_pyodide.yml

@@ -29,7 +29,7 @@ jobs:
           python ../IfcOpenShell/nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: ubuntu-22.04-${{ runner.arch }}
 

.github/workflows/build_rocky.yml

@@ -9,13 +9,6 @@ jobs:
     container: rockylinux:9
 
     steps:
-      - name: Set up uv
-        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
-
-      - name: Install Python
-        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
-        run: uv python install
-
       - name: Install Dependencies
         run: |
           dnf update -y
@@ -24,6 +17,7 @@ jobs:
                          sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel      \
                          readline-devel ncurses-devel libffi-devel libuuid-devel git-lfs \
                          findutils xz byacc
+          python3 -m pip install typing_extensions
           git config --global --add safe.directory '*'
 
       - name: Install aws cli
@@ -51,10 +45,10 @@ jobs:
       - name: Unpack Dependencies
         run: |
           cd build
-          uv run ../nix/cache_dependencies.py unpack
+          python3 ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: ubuntu-22.04-${{ runner.arch }}-rockylinux9
 
@@ -62,7 +56,7 @@ jobs:
         shell: bash
         run: |
           set -o pipefail
-          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
+          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release python3 ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
 
       - name: Upload Build Logs
         if: always()
@@ -77,7 +71,7 @@ jobs:
       - name: Pack Dependencies
         run: |
           cd build
-          uv run ../nix/cache_dependencies.py pack
+          python3 ../nix/cache_dependencies.py pack
 
       - name: Commit and Push Changes to Build Repository
         run: |
@@ -92,7 +86,20 @@ jobs:
         run: |
           VERSION=v`cat VERSION`
           cd ./build/`uname`/*/install/ifcopenshell
-          mkdir ~/output
+          mkdir -p ~/output
+          install_root="$PWD"
+
+          stage_runtime_payload() {
+              dest="$1"
+              while IFS= read -r runtime_file; do
+                  cp -L "$runtime_file" "$dest/"
+              done < <(
+                  for runtime_dir in "$install_root/bin" "$install_root/lib" "$install_root/lib64"; do
+                      [ -d "$runtime_dir" ] || continue
+                      find "$runtime_dir" -type f \( -name "*.so" -o -name "*.so.*" -o -name "*.dylib" -o -name "*.dll" \)
+                  done
+              )
+          }
 
           ls -d python-* | while read py_version; do
               postfix=`echo ${py_version: -1} | sed s/[0-9]//`
@@ -107,18 +114,24 @@ jobs:
               fi
               [ -d ifcopenshell/__pycache__ ] && rm -rf ifcopenshell/__pycache__
               find ifcopenshell -name "*.pyc" -delete
-              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip ifcopenshell/*
+              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip ifcopenshell
               mv *.zip ~/output
               popd > /dev/null
           done
 
-          cd bin
-          rm *.zip || true
-          ls | while read exe; do
-              zip -qq -r ${exe}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip $exe
+          rm -f "$install_root"/bin/*.zip
+          find "$install_root/bin" -maxdepth 1 -type f -perm /111 ! -name "*.zip" ! -name "*.so" ! -name "*.so.*" ! -name "*.dylib" ! -name "*.dll" | while read exe_path; do
+              exe=`basename "$exe_path"`
+              package_dir="$install_root/.package-${exe}"
+              rm -rf "$package_dir"
+              mkdir -p "$package_dir"
+              cp "$exe_path" "$package_dir/"
+              stage_runtime_payload "$package_dir"
+              pushd "$package_dir" > /dev/null
+              zip -qq -r "$HOME/output/${exe}-${VERSION}-${GITHUB_SHA:0:7}-linux64.zip" .
+              popd > /dev/null
+              rm -rf "$package_dir"
           done
-          mv *.zip ~/output
-          cd ..
 
       - name: Configure AWS credentials
         uses: aws-actions/configure-aws-credentials@v6

.github/workflows/build_rocky_arm.yml

@@ -9,13 +9,6 @@ jobs:
     container: arm64v8/rockylinux:9
 
     steps:
-      - name: Set up uv
-        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
-
-      - name: Install Python
-        # Installs latest Python version so it's preferred by uv over Rocky's system Python.
-        run: uv python install
-
       - name: Install Dependencies
         run: |
           dnf update -y
@@ -24,6 +17,7 @@ jobs:
                          sqlite-devel bzip2-devel zlib-devel openssl-devel xz-devel      \
                          readline-devel ncurses-devel libffi-devel libuuid-devel git-lfs \
                          findutils xz byacc
+          python3 -m pip install typing_extensions
           git config --global --add safe.directory '*'
 
       - name: Install aws cli
@@ -51,10 +45,10 @@ jobs:
       - name: Unpack Dependencies
         run: |
           cd build
-          uv run ../nix/cache_dependencies.py unpack
+          python3 ../nix/cache_dependencies.py unpack
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: ubuntu-22.04-${{ runner.arch }}-rockylinux9
 
@@ -62,7 +56,7 @@ jobs:
         shell: bash
         run: |
           set -o pipefail
-          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release uv run ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
+          CXXFLAGS="-O3" CFLAGS="-O3 ${DARWIN_C_SOURCE}" ADD_COMMIT_SHA=1 BUILD_CFG=Release python3 ./nix/build-all.py -v --diskcleanup 2>&1 | tee build.log
 
       - name: Upload Build Logs
         if: always()
@@ -77,7 +71,7 @@ jobs:
       - name: Pack Dependencies
         run: |
           cd build
-          uv run ../nix/cache_dependencies.py pack
+          python3 ../nix/cache_dependencies.py pack
 
       - name: Commit and Push Changes to Build Repository
         run: |
@@ -92,7 +86,20 @@ jobs:
         run: |
           VERSION=v`cat VERSION`
           cd ./build/`uname`/*/install/ifcopenshell
-          mkdir ~/output
+          mkdir -p ~/output
+          install_root="$PWD"
+
+          stage_runtime_payload() {
+              dest="$1"
+              while IFS= read -r runtime_file; do
+                  cp -L "$runtime_file" "$dest/"
+              done < <(
+                  for runtime_dir in "$install_root/bin" "$install_root/lib" "$install_root/lib64"; do
+                      [ -d "$runtime_dir" ] || continue
+                      find "$runtime_dir" -type f \( -name "*.so" -o -name "*.so.*" -o -name "*.dylib" -o -name "*.dll" \)
+                  done
+              )
+          }
 
           ls -d python-* | while read py_version; do
               postfix=`echo ${py_version: -1} | sed s/[0-9]//`
@@ -107,18 +114,25 @@ jobs:
               fi
               [ -d ifcopenshell/__pycache__ ] && rm -rf ifcopenshell/__pycache__
               find ifcopenshell -name "*.pyc" -delete
-              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linuxarm64.zip ifcopenshell/*
+              stage_runtime_payload ifcopenshell
+              zip -r -qq ifcopenshell-${py_version_major}-${VERSION}-${GITHUB_SHA:0:7}-linuxarm64.zip ifcopenshell
               mv *.zip ~/output
               popd > /dev/null
           done
 
-          cd bin
-          rm *.zip || true
-          ls | while read exe; do
-              zip -qq -r ${exe}-${VERSION}-${GITHUB_SHA:0:7}-linuxarm64.zip $exe
+          rm -f "$install_root"/bin/*.zip
+          find "$install_root/bin" -maxdepth 1 -type f -perm /111 ! -name "*.zip" ! -name "*.so" ! -name "*.so.*" ! -name "*.dylib" ! -name "*.dll" | while read exe_path; do
+              exe=`basename "$exe_path"`
+              package_dir="$install_root/.package-${exe}"
+              rm -rf "$package_dir"
+              mkdir -p "$package_dir"
+              cp "$exe_path" "$package_dir/"
+              stage_runtime_payload "$package_dir"
+              pushd "$package_dir" > /dev/null
+              zip -qq -r "$HOME/output/${exe}-${VERSION}-${GITHUB_SHA:0:7}-linuxarm64.zip" .
+              popd > /dev/null
+              rm -rf "$package_dir"
           done
-          mv *.zip ~/output
-          cd ..
 
       - name: Configure AWS credentials
         uses: aws-actions/configure-aws-credentials@v6

.github/workflows/build_win.yml

@@ -52,7 +52,7 @@ jobs:
           }
 
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: win-${{ matrix.arch }}
           # Windows ccache needs ~1GB
@@ -68,6 +68,64 @@ jobs:
           cd win
           python build-all-win.py
 
+      - name: Repack .zip Archives With Runtime Plugins
+        shell: powershell
+        run: |
+          $version = (Get-Content VERSION | Select-Object -First 1).Trim()
+          $sha = $env:GITHUB_SHA.Substring(0, 7)
+          $outputDir = Join-Path $env:USERPROFILE "output"
+          $installDir = Get-ChildItem -Path . -Directory | Where-Object { $_.Name -like "_installed*" } | Select-Object -First 1
+          if (-not $installDir) {
+            throw "Install directory not found."
+          }
+
+          $runtimeFiles = @()
+          foreach ($runtimeDir in @((Join-Path $installDir.FullName "bin"), (Join-Path $installDir.FullName "lib"))) {
+            if (Test-Path $runtimeDir) {
+              $runtimeFiles += Get-ChildItem -Path $runtimeDir -Recurse -File | Where-Object { $_.Extension -ieq ".dll" }
+            }
+          }
+          $runtimeFiles = $runtimeFiles | Sort-Object FullName -Unique
+
+          Get-ChildItem -Path $outputDir -Filter *.zip -ErrorAction SilentlyContinue | Remove-Item -Force
+
+          $binDir = Join-Path $installDir.FullName "bin"
+          foreach ($exe in Get-ChildItem -Path $binDir -File -Filter *.exe) {
+            $stageDir = Join-Path $env:RUNNER_TEMP ("package-" + $exe.BaseName)
+            Remove-Item -Path $stageDir -Recurse -Force -ErrorAction SilentlyContinue
+            New-Item -ItemType Directory -Path $stageDir | Out-Null
+            Copy-Item -Path $exe.FullName -Destination $stageDir
+            foreach ($runtimeFile in $runtimeFiles) {
+              Copy-Item -Path $runtimeFile.FullName -Destination $stageDir -Force
+            }
+            $zipPath = Join-Path $outputDir ("{0}-v{1}-{2}-win64.zip" -f $exe.BaseName, $version, $sha)
+            Compress-Archive -Path (Join-Path $stageDir '*') -DestinationPath $zipPath -Force
+          }
+
+          $depsRoot = Join-Path (Get-Location) "_deps"
+          if (Test-Path $depsRoot) {
+            foreach ($pythonRoot in Get-ChildItem -Path $depsRoot -Directory | Where-Object { $_.Name -like "python.*" }) {
+              $pythonVersion = $pythonRoot.Name.Substring("python.".Length)
+              $pythonVersionMajorMinor = ($pythonVersion.Split(".")[0..1] -join "")
+              $sitePackages = Join-Path $pythonRoot.FullName "tools\\Lib\\site-packages"
+              $packagePath = Join-Path $sitePackages "ifcopenshell"
+              if (!(Test-Path $packagePath)) {
+                continue
+              }
+              Get-ChildItem -Path $packagePath -Recurse -Filter *.pyc -ErrorAction SilentlyContinue | Remove-Item -Force
+              foreach ($runtimeFile in $runtimeFiles) {
+                Copy-Item -Path $runtimeFile.FullName -Destination $packagePath -Force
+              }
+              $zipPath = Join-Path $outputDir ("ifcopenshell-python-{0}-v{1}-{2}-win64.zip" -f $pythonVersionMajorMinor, $version, $sha)
+              Push-Location $sitePackages
+              try {
+                Compress-Archive -Path "ifcopenshell" -DestinationPath $zipPath -Force
+              } finally {
+                Pop-Location
+              }
+            }
+          }
+
       - name: Pack Dependencies
         run: |
           cd ${{ matrix.deps_dir }}

.github/workflows/ci-ifcopenshell-docker.yml

@@ -35,7 +35,7 @@ jobs:
 
     -
       name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2.23
+      uses: hendrikmuhs/ccache-action@v1.2.22
 
     - 
       name: Build ifcopenshell

.github/workflows/ci-lint.yaml

@@ -30,7 +30,7 @@ jobs:
           uv tool install ruff
           uv tool install black
           uv tool install poethepoet
-          uv tool install ty==0.0.34
+          uv tool install ty
 
       # black doesn't catch all syntax errors, so we check them explicitly.
       - name: Check syntax errors
@@ -95,7 +95,8 @@ jobs:
             echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
           }
 
-          run_check poe ruff
+          run_check poe ruff-main
+          run_check poe ruff-old
 
           exit $ERROR
         continue-on-error: true

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely pyparsing
+          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely
           pip install src/bcf --no-deps
           pip install pytest-xdist==3.8.0
 
@@ -79,7 +79,7 @@ jobs:
           libhdf5-dev libcgal-dev libeigen3-dev
           
       - name: ccache
-        uses: hendrikmuhs/ccache-action@v1.2.23
+        uses: hendrikmuhs/ccache-action@v1.2.22
         with:
           key: ubuntu-22.04-${{ runner.arch }}
 

.github/workflows/publish-bonsai-releases.yml

@@ -1,16 +0,0 @@
-name: Publish Bonsai Releases
-
-on:
-  workflow_dispatch:
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: astral-sh/setup-uv@v7
-
-      - run: uv run .github/scripts/publish-bonsai-releases.py
-        env:
-          BLENDER_EXTENSIONS_TOKEN: ${{ secrets.BLENDER_EXTENSIONS_TOKEN }}

build.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+set -e
+
+mkdir -p build && cd build
+
+cmake ../cmake \
+  -G Ninja \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DPython_EXECUTABLE=/home/dion/Projects/env/bin/python3.11 \
+  -DPython_INCLUDE_DIR=/usr/include/python3.11 \
+  -DBUILD_IFCPYTHON=ON \
+  -DBUILD_IFCGEOM=ON \
+  -DBUILD_CONVERT=ON \
+  -DBUILD_GEOMSERVER=OFF \
+  -DBUILD_EXAMPLES=OFF \
+  -DWITH_OPENCASCADE=ON \
+  -DWITH_CGAL=ON \
+  -DWITH_MANIFOLD=ON \
+  -DHDF5_SUPPORT=OFF \
+  -DGLTF_SUPPORT=ON \
+  -DIFCXML_SUPPORT=OFF \
+  -DCOLLADA_SUPPORT=OFF \
+  -DSCHEMA_VERSIONS="2x3;4;4x3_add2" \
+  -DOCC_INCLUDE_DIR=/usr/include/opencascade \
+  -DOCC_LIBRARY_DIR=/usr/lib64/opencascade
+
+ninja
+
+cp ifcwrap/_ifcopenshell_wrapper*.so ifcwrap/ifcopenshell_wrapper.py \
+   ../src/ifcopenshell-python/ifcopenshell/

cmake/CMakeLists.txt

@@ -18,28 +18,19 @@
 ################################################################################
 
 cmake_minimum_required(VERSION 3.21)
-if(NOT DEFINED CMAKE_CXX_STANDARD)
+if (NOT DEFINED CMAKE_CXX_STANDARD)
     set(CMAKE_CXX_STANDARD 17)
 endif()
-if(CMAKE_CXX_STANDARD LESS 17)
+if (CMAKE_CXX_STANDARD LESS 17)
     message(FATAL_ERROR "C++17 or newer is required.")
 endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON) # not necessary, but encouraged
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-if(VERSION_OVERRIDE)
-    file(READ "../VERSION" "RELEASE_VERSION_")
-    string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
-    message(STATUS "Detected version '${RELEASE_VERSION}'")
-else()
-    set(RELEASE_VERSION "0.8.0")
-endif()
-
 add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
 
 if(POLICY CMP0141) # 3.25+
-    # Has to be set before `project` to take effect.
-    cmake_policy(SET CMP0141 NEW) # Support for `CMAKE_MSVC_DEBUG_INFORMATION_FORMAT`.
+  cmake_policy(SET CMP0141 NEW) # Support for `CMAKE_MSVC_DEBUG_INFORMATION_FORMAT`.
 endif()
 if(POLICY CMP0144) # 3.27
     cmake_policy(SET CMP0144 NEW) # find_package() uses upper-case <PACKAGENAME>_ROOT variables.
@@ -48,8 +39,6 @@ if(POLICY CMP0167) # 3.30
     cmake_policy(SET CMP0167 OLD)
 endif()
 
-project(IfcOpenShell VERSION ${RELEASE_VERSION})
-
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release")
 endif()
@@ -65,64 +54,59 @@ endif()
 option(MINIMAL_BUILD "The build is to make a minimal version of IFC converter from OCCT into IFC." OFF)
 option(WASM_BUILD "Build a WebAssembly binary." OFF)
 
-option(
-    ENABLE_BUILD_OPTIMIZATIONS
-    "Enable certain compiler and linker optimizations on RelWithDebInfo and Release builds."
-    OFF
-)
-option(BUILD_SHARED_LIBS "Build IfcParse and IfcGeom as shared libs (SO/DLL)." OFF)
+option(ENABLE_BUILD_OPTIMIZATIONS "Enable certain compiler and linker optimizations on RelWithDebInfo and Release builds." OFF)
+option(BUILD_SHARED_LIBS "Build IfcOpenShell as shared libraries (required)." ON)
 option(MSVC_PARALLEL_BUILD "Multi-threaded compilation in Microsoft Visual Studio (/MP)" OFF)
 option(USE_VLD "Use Visual Leak Detector for debugging memory leaks, MSVC-only." OFF)
 option(USE_MMAP "Adds a command line options to parse IFC files from memory mapped files using Boost.Iostreams" OFF)
 option(NO_WARN "Disable all warnings" OFF)
+option(CREATE_BUNDLE "Copy .so files and don't create RPATHS or SOVERSION symlinks" )
 
 option(BUILD_IFCGEOM "Build IfcGeom." ON)
 option(BUILD_IFCPYTHON "Build IfcPython." ON)
+option(BUILD_IFCPARSE_EXPERIMENTAL_WRAPPER "Build the experimental Clang-generated ifcparse Python wrapper." OFF)
 option(BUILD_CONVERT "Build IfcConvert executable." ON)
 option(BUILD_DOCUMENTATION "Build IfcOpenShell Documentation." OFF)
-option(BUILD_EXAMPLES "Build example applications." OFF)
+option(BUILD_EXAMPLES "Build example applications." ON)
 option(BUILD_GEOMSERVER "Build IfcGeomServer executable (Open CASCADE is required)." ON)
 option(BUILD_IFCMAX "Build IfcMax, a 3ds Max plug-in, Windows-only." OFF)
 option(BUILD_QTVIEWER "Build IfcOpenShell Qt GUI Viewer" OFF) # QtViewer requires Qt6
+option(BUILD_IFCVIEWER "Build IfcViewer, a high-performance IFC viewer" OFF) # Requires Qt6 + OpenGL 4.5
+option(BUILD_IFCVIEWER_TESTS "Build unit tests for IfcViewer (fetches Catch2 v3)" OFF)
 option(BUILD_PACKAGE "" OFF)
-# Most users probably need just common schemas,
-# but we're keeping it `OFF` by default to avoid disruption
-# (e.g. all Python distribution would need to adapt this option to be set).
-option(
-    BUILD_ONLY_COMMON_SCHEMAS
-    "Build only common IFC schemas (2x3, 4, 4x3_add2). By default all schemas will be built."
-    OFF
-)
-option(SCHEMA_VERSIONS "Explicitly specify schemas to build." "")
 
 option(WITH_OPENCASCADE "Enable geometry interpretation using Open CASCADE" ON)
 option(WITH_CGAL "Enable geometry interpretation using CGAL" ON)
+option(WITH_MANIFOLD "Enable geometry interpretation using Manifold" OFF)
 option(COLLADA_SUPPORT "Build IfcConvert with COLLADA support (requires OpenCOLLADA)." ON)
 option(GLTF_SUPPORT "Build IfcConvert with glTF support (requires json.hpp)." OFF)
 option(HDF5_SUPPORT "Enable HDF5 support (requires HDF5, zlib)" ON)
 option(WITH_PROJ "Enable output of Earth-Centered Earth-Fixed glTF output using the PROJ library" OFF)
-option(IFCXML_SUPPORT "Build IfcParse with ifcXML support (requires libxml2)." ON)
 option(USD_SUPPORT "Build IfcConvert with USD support (requires pixar's USD library)." OFF)
-option(WITH_RELATIONSHIP_VALIDATION "Build IfcConvert with option to validate geometrical relationships." OFF)
 option(WITH_ROCKSDB "Support a RocksDB key-value store as a file backend in IfcOpenShell" OFF)
 option(WITH_ZSTD "Use Zstd compression in RocksDB writes" OFF)
 
 option(USERSPACE_PYTHON_PREFIX "Installs IfcPython for the current user only instead of system-wide." OFF)
 option(USE_DEBUG_PYTHON "Use debug binaries when building Debug IfcPython on Windows." OFF)
 option(ADD_COMMIT_SHA "Add commit sha and branch in version number, requires git" OFF)
-option(
-    VERSION_OVERRIDE
-    "Override the version defined in buildinfo.cpp with the file VERSION in the repository root"
-    OFF
-)
-option(USE_CCACHE "Enable use of ccache if it's available from PATH." ON)
+option(VERSION_OVERRIDE "Override the version defined in buildinfo.cpp with the file VERSION in the repository root" OFF)
 
-set(PYTHON_MODULE_INSTALL_DIR
-    ""
-    CACHE PATH
+set(
+    PYTHON_MODULE_INSTALL_DIR
+    "" CACHE PATH
     "Directory to install IfcPython package to. By default package is installed in found Python's site-packages."
 )
 
+if (VERSION_OVERRIDE)
+    file(READ "../VERSION" "RELEASE_VERSION_")
+    string(STRIP "${RELEASE_VERSION_}" RELEASE_VERSION)
+    message(STATUS "Detected version '${RELEASE_VERSION}'")
+else()
+    set(RELEASE_VERSION "0.8.0")
+endif()
+
+project(IfcOpenShell VERSION ${RELEASE_VERSION})
+
 # Make sure CMake modules in this project are found first
 list(PREPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR})
 
@@ -134,17 +118,20 @@ if(MINIMAL_BUILD)
     set(COLLADA_SUPPORT OFF)
     set(GLTF_SUPPORT OFF)
     set(HDF5_SUPPORT OFF)
-    set(IFCXML_SUPPORT OFF)
     set(USD_SUPPORT OFF)
 endif()
 
-if((BUILD_CONVERT OR BUILD_GEOMSERVER OR BUILD_IFCPYTHON) AND (NOT BUILD_IFCGEOM))
+if(NOT BUILD_SHARED_LIBS)
+    message(FATAL_ERROR "BUILD_SHARED_LIBS=OFF is not supported. Configure with -DBUILD_SHARED_LIBS=ON.")
+endif()
+
+if((BUILD_CONVERT OR BUILD_GEOMSERVER OR BUILD_IFCPYTHON) AND(NOT BUILD_IFCGEOM))
     message(STATUS "'IfcGeom' is required with current outputs")
     set(BUILD_IFCGEOM ON)
 endif()
 
 find_program(CCACHE_FOUND ccache)
-if(USE_CCACHE AND CCACHE_FOUND)
+if(CCACHE_FOUND)
     message(STATUS "`ccache` is found, using it as a compiler launcher.")
     set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_FOUND}")
     if(MSVC)
@@ -153,15 +140,17 @@ if(USE_CCACHE AND CCACHE_FOUND)
         set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<$<CONFIG:Debug,RelWithDebInfo>:Embedded>")
         # Not needed for Ninja.
         if(CMAKE_GENERATOR MATCHES "Visual Studio")
-            file(COPY_FILE ${CCACHE_FOUND} ${CMAKE_BINARY_DIR}/cl.exe ONLY_IF_DIFFERENT)
-            set(CMAKE_VS_GLOBALS "CLToolExe=cl.exe" "CLToolPath=${CMAKE_BINARY_DIR}" "UseMultiToolTask=true")
+            file(COPY_FILE
+                ${CCACHE_FOUND} ${CMAKE_BINARY_DIR}/cl.exe
+                ONLY_IF_DIFFERENT)
+            set(CMAKE_VS_GLOBALS
+                "CLToolExe=cl.exe"
+                "CLToolPath=${CMAKE_BINARY_DIR}"
+                "UseMultiToolTask=true"
+            )
         endif()
     endif()
 endif()
-mark_as_advanced(CCACHE_FOUND)
-
-# Variable to accumulate swig definitions from various submodules.
-set(SWIG_DEFINES "")
 
 if(MSVC AND MSVC_PARALLEL_BUILD)
     add_definitions("/MP")
@@ -177,28 +166,23 @@ endif()
 
 include(GNUInstallDirs)
 
-set(IFCOPENSHELL_EXPORT_TARGETS "${PROJECT_NAME}Targets")
-
-# On Windows Release and Debug binaries are not compatible.
-# So we add a postfix to avoid issues and allow release and debug installations to coexist.
-if(WIN32)
-    set(CMAKE_DEBUG_POSTFIX "_d")
+if(NOT INCLUDEDIR)
+    set(INCLUDEDIR include)
 endif()
+if(NOT IS_ABSOLUTE ${INCLUDEDIR})
+    set(INCLUDEDIR ${CMAKE_INSTALL_INCLUDEDIR})
+endif()
+message(STATUS "INCLUDEDIR: ${INCLUDEDIR}")
 
-if(BUILD_SHARED_LIBS)
-    add_definitions(-DIFC_SHARED_BUILD)
-    if(MSVC)
-        message(
-            WARNING
-            "Building DLLs against the static VC run-time. This is not recommended if the DLLs are to be redistributed."
-        )
-        # C4521: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
-        # There will be couple hundreds of these so suppress them away, https://msdn.microsoft.com/en-us/library/esew7y1w.aspx
-        add_definitions(-wd4251)
-    endif()
+if(MSVC)
+    message(WARNING "Building DLLs against the static VC run-time. This is not recommended if the DLLs are to be redistributed.")
+    # C4521: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
+    # There will be couple hundreds of these so suppress them away, https://msdn.microsoft.com/en-us/library/esew7y1w.aspx
+    add_definitions(-wd4251)
 endif()
 
 UNIFY_ENVVARS_AND_CACHE(BOOST_ROOT)
+UNIFY_ENVVARS_AND_CACHE(BOOST_LIBRARYDIR)
 
 if(NOT MINIMAL_BUILD)
     UNIFY_ENVVARS_AND_CACHE(PYTHON_INCLUDE_DIR)
@@ -214,71 +198,75 @@ foreach(option_flag IN LISTS option_flags)
     convert_env_var_to_bool("${option_flag}")
 endforeach()
 
+if(WITH_CGAL)
+    find_package(CGAL REQUIRED)
+    set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_CGAL)
+    list(APPEND GEOMETRY_KERNELS cgal)
+endif()
+
 if(BUILD_IFCGEOM AND WITH_OPENCASCADE)
     find_package(OpenCASCADE REQUIRED)
-    add_definitions(-DIFOPSH_WITH_OPENCASCADE)
+    # Map OpenCASCADE_LIBRARIES variable from OpenCASCADEConfig.cmake to OpenCASCADE_LIBRARIES used by kernel generic cmake file
+    set(OpenCASCADE_LIBRARIES ${OpenCASCADE_LIBRARIES})
     set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_OPENCASCADE)
     list(APPEND GEOMETRY_KERNELS opencascade)
 endif()
 
-set(GLTF_LIBRARIES "")
+message(STATUS "BUILD_IFCGEOM WITH_MANIFOLD: ${BUILD_IFCGEOM} ${WITH_MANIFOLD}")
+
+if(BUILD_IFCGEOM AND WITH_MANIFOLD)
+    find_package(manifold CONFIG REQUIRED)
+    if(TARGET manifold::manifold)
+        set(MANIFOLD_LIBRARIES manifold::manifold)
+    elseif(TARGET manifold)
+        set(MANIFOLD_LIBRARIES manifold)
+    else()
+        message(FATAL_ERROR "Unable to determine manifold target")
+    endif()
+    list(APPEND GEOMETRY_KERNELS manifold)
+endif()
+
+if(BUILD_IFCGEOM)
+    list(APPEND GEOMETRY_KERNELS passthrough)
+endif()
+
 if(GLTF_SUPPORT)
     find_package(nlohmann_json REQUIRED)
-    set(GLTF_LIBRARIES nlohmann_json::nlohmann_json)
-    add_definitions(-DWITH_GLTF)
-    set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_GLTF)
 endif()
 
 # Add USD support to serializers
-set(USD_LIBRARIES "")
 if(USD_SUPPORT)
     find_package(USD REQUIRED)
-    set(USD_LIBRARIES pxr::USD)
 endif(USD_SUPPORT)
 
-set(ROCKSDB_LIBRARIES "")
-if(WITH_ROCKSDB)
+if (WITH_ROCKSDB)
     # Temporaily mess with CMAKE_FIND_PACKAGE_PREFER_CONFIG to help RocksDB
     # find it's zstd dependency on Windows.
     # Only do it on Windows, otherwise it might create problems as
     # findzstd and zstd-config target names do not match.
-    # https://github.com/facebook/rocksdb/pull/13975
     if(WIN32)
         set(TEMP CMAKE_FIND_PACKAGE_PREFER_CONFIG)
         set(CMAKE_FIND_PACKAGE_PREFER_CONFIG TRUE)
     endif()
     find_package(RocksDB CONFIG REQUIRED)
-    mark_as_advanced(RocksDB_DIR)
     if(WIN32)
         set(CMAKE_FIND_PACKAGE_PREFER_CONFIG ${TEMP})
     endif()
 
     message(STATUS "RocksDB: found at '${RocksDB_DIR}'.")
-    add_library(IFCOPENSHELL_RocksDB INTERFACE)
-    set(ROCKSDB_LIBRARIES "IFCOPENSHELL_RocksDB")
-    target_compile_definitions(IFCOPENSHELL_RocksDB INTERFACE IFOPSH_WITH_ROCKSDB)
-    set(SWIG_DEFINES ${SWIG_DEFINES} -DIFOPSH_WITH_ROCKSDB)
-    # Shared binaries for `rocksdb` only support limited API (only `c.h`), but we use `db.h` API.
-    # So rocksdb supported only as a static library.
-    # See https://github.com/facebook/rocksdb/issues/981.
-    target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE RocksDB::rocksdb)
 
-    if(WITH_ZSTD)
+    if (WITH_ZSTD)
         # @todo do we actually need the zstd include dir or rather just pass
         # the libzstd.a along with the rocksdb library when needed and feature
         # detect based on rocksdb API?
         find_package(zstd CONFIG REQUIRED)
-        mark_as_advanced(zstd_DIR)
         message(STATUS "zstd: found at '${zstd_DIR}'.")
-        target_link_libraries(IFCOPENSHELL_RocksDB INTERFACE zstd::libzstd_static)
     endif()
-
-    install(TARGETS IFCOPENSHELL_RocksDB EXPORT ${IFCOPENSHELL_EXPORT_TARGETS})
 endif()
 
 # Find Boost: On win32 the (hardcoded) default is to use static libraries and
 # runtime, when doing running conda-build we pick what conda prepared for us.
-if(WIN32 AND NOT DEFINED ENV{CONDA_BUILD})
+if(WIN32 AND("$ENV{CONDA_BUILD}" STREQUAL ""))
     set(Boost_USE_STATIC_LIBS ON)
     set(Boost_USE_STATIC_RUNTIME OFF)
     set(Boost_USE_MULTITHREADED ON)
@@ -309,14 +297,8 @@ if(WASM_BUILD)
 else()
     # @todo review this, shouldn't this be all possible header-only now?
     # ... or rewritten using C++17 features?
-    set(BOOST_COMPONENTS
-        system
-        program_options
-        regex
-        thread
-        date_time
-        iostreams
-    )
+    # set(BOOST_COMPONENTS system program_options regex thread date_time iostreams)
+    set(BOOST_COMPONENTS program_options regex thread date_time iostreams)
 endif()
 
 if(USE_MMAP)
@@ -326,17 +308,6 @@ if(USE_MMAP)
     else()
         set(BOOST_COMPONENTS ${BOOST_COMPONENTS} iostreams)
     endif()
-
-    add_definitions(-DUSE_MMAP)
-endif()
-
-# Handle CGAL after Boost settings are set, since CGAL will use them too.
-# Do `find_package(Boost)` only after this, to make sure `FindBoost` finds correct components.
-# Otherwise it will find components needed for CGAL and we might some libraries.
-if(WITH_CGAL)
-    find_package(CGAL REQUIRED)
-    set(CGAL_LIBRARIES IFCOPENSHELL_CGAL)
-    list(APPEND GEOMETRY_KERNELS cgal)
 endif()
 
 find_package(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
@@ -345,15 +316,10 @@ message(STATUS "Boost libraries found in ${Boost_LIBRARY_DIRS}")
 
 if(COLLADA_SUPPORT)
     find_package(OpenCOLLADA REQUIRED)
-    add_definitions(-DWITH_OPENCOLLADA)
 endif()
 
 if(HDF5_SUPPORT)
     find_package(HDF5 REQUIRED COMPONENTS C CXX)
-    set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} hdf5::hdf5_cpp)
-
-    add_definitions(-DWITH_HDF5)
-    set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_HDF5)
 endif(HDF5_SUPPORT)
 
 if(ENABLE_BUILD_OPTIMIZATIONS)
@@ -368,20 +334,12 @@ if(ENABLE_BUILD_OPTIMIZATIONS)
 
         # Linker
         # /OPT:REF enables also /OPT:ICF and disables INCREMENTAL
-        set(LINKER_FLAGS_RELEASE "/LTCG /OPT:REF")
-        # /OPT:NOICF is recommended when /DEBUG is used (http://msdn.microsoft.com/en-us/library/xe4t6fc1.aspx)
-        set(LINKER_FLAGS_RELWITHDEBINFO "/DEBUG /OPT:NOICF")
+        set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF")
 
-        set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELEASE}")
-        set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
-            "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELWITHDEBINFO}"
-        )
-        set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELEASE}")
-        set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELWITHDEBINFO}")
-        set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELEASE}")
-        set(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
-            "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} ${LINKER_FLAGS_RELWITHDEBINFO}"
-        )
+        # /OPT:NOICF is recommended when /DEBUG is used (http://msdn.microsoft.com/en-us/library/xe4t6fc1.aspx)
+        set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:NOICF")
+        set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF")
+        set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG /OPT:NOICF")
     else()
         # GCC-like: Release should use O3 but RelWithDebInfo 02 so enforce 03. Anything other useful that could be added here?
         set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
@@ -430,7 +388,7 @@ if(MSVC)
     endif()
 
     # Enforce standards-conformance on VS > 2015, older Boost versions fail to compile with this
-    if(MSVC_VERSION GREATER 1900 AND (Boost_MAJOR_VERSION GREATER 1 OR Boost_MINOR_VERSION GREATER 66))
+    if(MSVC_VERSION GREATER 1900 AND(Boost_MAJOR_VERSION GREATER 1 OR Boost_MINOR_VERSION GREATER 66))
         add_definitions(-permissive-)
     endif()
 
@@ -449,11 +407,11 @@ if(MSVC)
     #     endforeach()
     # endif()
 
-    add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)
-    # See #5158.
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.40)
-        add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
-    endif()
+	add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)
+	# See #5158.
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.40)
+		add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
+	endif()
 else()
     add_definitions(-Wall -Wextra)
 
@@ -463,10 +421,7 @@ else()
         add_definitions(-Wno-maybe-uninitialized)
     endif()
 
-    if(
-        CMAKE_CXX_COMPILER_ID MATCHES "GNU"
-        AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 9.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 9.0)
-    )
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 9.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 9.0))
         # OpenCascade spews a lot of deprecated-copy warnings
         add_definitions(-Wno-deprecated-copy)
     endif()
@@ -477,45 +432,35 @@ else()
     endif()
 endif(MSVC)
 
-include_directories(${OPENCOLLADA_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ${HDF5_INCLUDE_DIR})
+include_directories(${INCLUDE_DIRECTORIES}
+	${Boost_INCLUDE_DIRS} ${HDF5_INCLUDE_DIR}
+    ${CGAL_INCLUDE_DIR} ${GMP_INCLUDE_DIR} ${MPFR_INCLUDE_DIR}
+)
 
 if(NOT SCHEMA_VERSIONS)
-    # `WASM_BUILD` - super arbitrarily try to keep size down at least a little bit
-    if(BUILD_ONLY_COMMON_SCHEMAS OR WASM_BUILD)
+    if(WASM_BUILD)
+        # super arbitrarily try to keep size down at least a little bit
         set(SCHEMA_VERSIONS "2x3" "4" "4x3_add2")
     else()
-        set(SCHEMA_VERSIONS
-            "2x3"
-            "4"
-            "4x1"
-            "4x2"
-            "4x3"
-            "4x3_tc1"
-            "4x3_add1"
-            "4x3_add2"
-        )
+        set(SCHEMA_VERSIONS "2x3" "4" "4x1" "4x2" "4x3" "4x3_tc1" "4x3_add1" "4x3_add2")
     endif()
 endif()
 
 message(STATUS "IFC SCHEMA_VERSIONS that will be used for the build: ${SCHEMA_VERSIONS}.")
 
-set(SCHEMA_DEFINITIONS "")
 foreach(schema ${SCHEMA_VERSIONS})
-    list(APPEND SCHEMA_DEFINITIONS "-DHAS_SCHEMA_${schema}")
+    add_definitions(-DHAS_SCHEMA_${schema})
 endforeach()
 
 string(REPLACE ";" ")(" schema_version_seq "(${SCHEMA_VERSIONS})")
-list(APPEND SCHEMA_DEFINITIONS "-DSCHEMA_SEQ=${schema_version_seq}")
+add_definitions(-DSCHEMA_SEQ=${schema_version_seq})
 
 if(COMPILE_SCHEMA)
     # @todo, this appears to be untested at the moment
     find_package(PythonInterp)
 
     if(NOT PYTHONINTERP_FOUND)
-        message(
-            FATAL_ERROR
-            "A Python interpreter is necessary when COMPILE_SCHEMA is enabled. Disable COMPILE_SCHEMA or fix Python paths to proceed."
-        )
+        message(FATAL_ERROR "A Python interpreter is necessary when COMPILE_SCHEMA is enabled. Disable COMPILE_SCHEMA or fix Python paths to proceed.")
     endif()
 
     set(IFC_RELEASE_NOT_USED ${SCHEMA_VERSIONS})
@@ -535,10 +480,7 @@ if(COMPILE_SCHEMA)
 
     if("${PYPARSING_FOUND}" STREQUAL "-1")
         message(STATUS "Installing pyparsing")
-        execute_process(
-            COMMAND ${PYTHON_EXECUTABLE} -m pip "install" --user pyparsing
-            RESULT_VARIABLE SUCCESS
-        )
+        execute_process(COMMAND ${PYTHON_EXECUTABLE} -m pip "install" --user pyparsing RESULT_VARIABLE SUCCESS)
 
         if(NOT "${SUCCESS}" STREQUAL "0")
             execute_process(COMMAND pip "install" --user pyparsing RESULT_VARIABLE SUCCESS)
@@ -553,23 +495,19 @@ if(COMPILE_SCHEMA)
 
     # Bootstrap the parser
     message(STATUS "Compiling schema, this will take a while...")
-    execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} bootstrap.py express.bnf
+    execute_process(COMMAND ${PYTHON_EXECUTABLE} bootstrap.py express.bnf
         WORKING_DIRECTORY ../src/ifcexpressparser
         OUTPUT_FILE express_parser.py
-        RESULT_VARIABLE SUCCESS
-    )
+        RESULT_VARIABLE SUCCESS)
 
     if(NOT "${SUCCESS}" STREQUAL "0")
         message(FATAL_ERROR "Failed to bootstrap parser. Make sure pyparsing is installed")
     endif()
 
     # Generate code
-    execute_process(
-        COMMAND ${PYTHON_EXECUTABLE} ../ifcexpressparser/express_parser.py ../../${COMPILE_SCHEMA}
+    execute_process(COMMAND ${PYTHON_EXECUTABLE} ../ifcexpressparser/express_parser.py ../../${COMPILE_SCHEMA}
         WORKING_DIRECTORY ../src/ifcparse
-        OUTPUT_VARIABLE COMPILED_SCHEMA_NAME
-    )
+        OUTPUT_VARIABLE COMPILED_SCHEMA_NAME)
 
     # Prevent the schema that had just been compiled from being excluded
     foreach(schema ${SCHEMA_VERSIONS})
@@ -584,16 +522,39 @@ if(NOT Boost_VERSION LESS 105800)
     add_definitions(-DBOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE)
 endif()
 
+add_subdirectory(../src/plugin plugin)
+
 add_subdirectory(../src/ifcparse ifcparse)
 set(IFCOPENSHELL_LIBRARIES IfcParse)
 
+if(BUILD_IFCPARSE_EXPERIMENTAL_WRAPPER)
+    add_subdirectory(../src/wrappergen wrappergen)
+endif()
+
 if(BUILD_IFCGEOM)
+    # CGAL::CGAL target already has dependencies resolved.
+    if(WITH_CGAL AND CGAL_DIR)
+        set(CGAL_LIBRARIES CGAL::CGAL)
+        message(STATUS "Using found CGAL package at '${CGAL_DIR}'")
+    elseif(WITH_CGAL AND NOT CGAL_DIR)
+        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)
+        if(NOT libGMP)
+            message(FATAL_ERROR "Unable to find GMP library files, aborting")
+        endif()
+        if(NOT libMPFR)
+            message(FATAL_ERROR "Unable to find MPFR library files, aborting")
+        endif()
+
+        list(APPEND CGAL_LIBRARIES "${libMPFR}")
+        list(APPEND CGAL_LIBRARIES "${libGMP}")
+    endif()
+
     add_subdirectory(../src/ifcgeom ifcgeom)
 endif(BUILD_IFCGEOM)
 
 if(BUILD_CONVERT OR BUILD_IFCPYTHON)
     add_subdirectory(../src/serializers serializers)
-    set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} ${SERIALIZER_SCHEMA_LIBRARIES})
 endif(BUILD_CONVERT OR BUILD_IFCPYTHON)
 
 if(BUILD_CONVERT)
@@ -613,8 +574,8 @@ if(ADD_COMMIT_SHA)
     endif()
 
     if(GIT_FOUND)
-        if(VERSION_OVERRIDE)
-            set(git_branch ${RELEASE_VERSION})
+        if (VERSION_OVERRIDE)
+            set (git_branch ${RELEASE_VERSION})
         else()
             message("git found: ${GIT_EXECUTABLE} with version ${GIT_VERSION_STRING}")
             execute_process(
@@ -626,8 +587,8 @@ if(ADD_COMMIT_SHA)
             string(REPLACE "\n" ";" git_branch_list "${git_branches}")
 
             foreach(git_branch_candidate IN ITEMS ${git_branch_list})
-                string(REPLACE "*" "" git_branch_candidate_temp "${git_branch_candidate}")
-                string(STRIP "${git_branch_candidate_temp}" git_branch_candidate_2)
+		        string(REPLACE "*" "" git_branch_candidate_temp "${git_branch_candidate}")
+		        string(STRIP "${git_branch_candidate_temp}" git_branch_candidate_2)
                 if(NOT git_branch_candidate_2 MATCHES "^HEAD$")
                     string(REPLACE "/" ";" git_branch_candidate_2_list "${git_branch_candidate_2}")
                     list(GET git_branch_candidate_2_list -1 git_branch)
@@ -645,13 +606,13 @@ if(ADD_COMMIT_SHA)
         message(STATUS "IfcOpenShell branch: \"${git_branch}\"")
         message(STATUS "IfcOpenShell commit: \"${git_sha}\"")
 
-        if("${git_branch}" STREQUAL "" OR "${git_sha}" STREQUAL "")
+        if ("${git_branch}" STREQUAL "" OR "${git_sha}" STREQUAL "")
             message(FATAL_ERROR "Unable to determine commit sha and/or branch")
         endif()
 
-        target_compile_definitions(
-            IfcParse
-            PRIVATE -DIFCOPENSHELL_BRANCH=${git_branch} -DIFCOPENSHELL_COMMIT=${git_sha}
+        target_compile_definitions(IfcParse PRIVATE
+            -DIFCOPENSHELL_BRANCH=${git_branch}
+            -DIFCOPENSHELL_COMMIT=${git_sha}
         )
     endif()
 endif(ADD_COMMIT_SHA)
@@ -669,10 +630,6 @@ if(BUILD_DOCUMENTATION)
     add_subdirectory(../docs docs)
 endif()
 
-if(BUILD_IFCPYTHON)
-    add_subdirectory(../src/ifcwrap ifcwrap)
-endif()
-
 if(BUILD_EXAMPLES)
     add_subdirectory(../src/examples examples)
 endif()
@@ -685,32 +642,82 @@ if(BUILD_IFCPYTHON AND WITH_CGAL)
     add_subdirectory(../src/svgfill svgfill)
 endif()
 
+if(BUILD_IFCPYTHON)
+    add_subdirectory(../src/ifcwrap ifcwrap)
+endif()
+
 if(BUILD_QTVIEWER)
     add_subdirectory(../src/qtviewer qtviewer)
 endif()
 
+if(BUILD_IFCGEOM)
+    # install(FILES ${IFCGEOM_H_FILES}
+    #     DESTINATION ${INCLUDEDIR}/ifcgeom
+    # )
+
+    install(FILES ${SCHEMA_AGNOSTIC_H_FILES}
+        DESTINATION ${INCLUDEDIR}/ifcgeom
+    )
+
+    file(GLOB SERIALIZATION_H_FILES ../src/ifcgeom/serialization/*.h)
+    install(FILES ${SERIALIZATION_H_FILES}
+        DESTINATION ${INCLUDEDIR}/ifcgeom/serialization
+    )
+
+    foreach(kernel ${GEOMETRY_KERNELS})
+        file(GLOB IFCGEOM_H_FILES ../src/ifcgeom/kernels/${kernel}/*.h)
+         install(FILES ${IFCGEOM_H_FILES}
+            DESTINATION ${INCLUDEDIR}/ifcgeom/kernels/${kernel}
+        )
+    endforeach()
+
+    install(TARGETS ${IFCGEOM_SCHEMA_LIBRARIES} ${kernel_libraries} IfcGeom)
+endif(BUILD_IFCGEOM)
+if(BUILD_IFCVIEWER)
+    if(BUILD_IFCVIEWER_TESTS)
+        # Catch2 v3 — fetched on demand. Test option is OFF by default so the
+        # default build remains offline-capable.
+        include(FetchContent)
+        FetchContent_Declare(
+            Catch2
+            GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+            GIT_TAG        v3.5.4
+            GIT_SHALLOW    TRUE
+        )
+        FetchContent_MakeAvailable(Catch2)
+        list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
+        include(CTest)
+        include(Catch)
+        enable_testing()
+    endif()
+
+    add_subdirectory(../src/ifcviewer ifcviewer)
+    add_subdirectory(../src/ifcviewer-minimal ifcviewer-minimal)
+    add_subdirectory(../src/ifcviewer-full ifcviewer-full)
+endif()
+
 # Cmake uninstall target
 if(NOT TARGET uninstall)
     configure_file(
         "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
         "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
-        IMMEDIATE
-        @ONLY
-    )
+        IMMEDIATE @ONLY)
 
-    add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+    add_custom_target(uninstall
+        COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
 endif()
 
 # Packaging
-list(APPEND CPACK_SOURCE_IGNORE_FILES "/\\\\.git" "/build/" "/.pytest_cache/" "/__pycache__/")
+list(APPEND CPACK_SOURCE_IGNORE_FILES
+    "/\\\\.git"
+    "/build/"
+    "/.pytest_cache/"
+    "/__pycache__/"
+)
 set(CPACK_SOURCE_INSTALLED_DIRECTORIES "${CMAKE_SOURCE_DIR}/..;/")
-set(CPACK_PACKAGE_NAME
-    "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}"
-)
+set(CPACK_PACKAGE_NAME "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}")
 set(CPACK_SOURCE_PACKAGE_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION}${EXTRA_VERSION}")
-set(CPACK_PACKAGE_FILE_NAME
-    "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}-${CMAKE_SYSTEM_NAME}"
-)
+SET(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}-${CMAKE_SYSTEM_NAME}")
 set(CPACK_PACKAGE_DIRECTORY "${PROJECT_BINARY_DIR}/assets")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "IfcOpenShell")
 set(CPACK_PACKAGE_DESCRIPTION "IfcOpenShell.")
@@ -723,7 +730,6 @@ set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
 set(CPACK_GENERATOR "TGZ;DEB")
 set(CPACK_SOURCE_GENERATOR "TGZ")
 
-set(BOOST_DEPS "")
 foreach(COMPONENT IN ITEMS ${BOOST_COMPONENTS})
     string(REPLACE "_" "-" COMP ${COMPONENT})
     set(BOOST_DEPS "${BOOST_DEPS}, libboost-${COMP}-dev")
@@ -731,19 +737,13 @@ endforeach(COMPONENT)
 
 set(CPACK_DEBIAN_PACKAGE_NAME "${PROJECT_NAME}")
 set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_CONTACT}")
-set(CPACK_DEBIAN_PACKAGE_DEPENDS
-    "python3, libxml2, libocct-foundation-dev, libocct-modeling-algorithms-dev, libocct-modeling-data-dev, libocct-ocaf-dev, libocct-visualization-dev, libocct-data-exchange-dev, libhdf5-serial-dev, libpython3-dev, python3-pytest ${BOOST_DEPS}"
-)
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "python3, libxml2, libocct-foundation-dev, libocct-modeling-algorithms-dev, libocct-modeling-data-dev, libocct-ocaf-dev, libocct-visualization-dev, libocct-data-exchange-dev, libhdf5-serial-dev, libpython3-dev, python3-pytest ${BOOST_DEPS}")
 set(CPACK_DEBIAN_PACKAGE_DESCRIPTION_SUMMARY "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
 set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION}")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
 set(CPACK_DEBIAN_PACKAGE_SECTION "science")
-set(CPACK_DEBIAN_PACKAGE_VERSION
-    "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}${EXTRA_VERSION}"
-)
+set(CPACK_DEBIAN_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}${EXTRA_VERSION}")
 set(CPACK_DEBIAN_ARCHITECTURE "${CMAKE_SYSTEM_PROCESSOR}")
 # set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/cmake/debian/postinst")
 
 include(CPack)
-
-include(package_export.cmake)

cmake/FindOpenCOLLADA.cmake

@@ -139,7 +139,8 @@ if(NOT OpenCOLLADA_DIR)
     endif()
 endif(NOT OpenCOLLADA_DIR)
 
-if(OPENCOLLADA_FOUND)
-    add_definitions(-DWITH_OPENCOLLADA)
-    set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_OPENCOLLADA)
+if(OPENCOLLADA_FOUND AND NOT TARGET OpenCOLLADA::OpenCOLLADA)
+    add_library(OpenCOLLADA::OpenCOLLADA INTERFACE IMPORTED)
+    target_include_directories(OpenCOLLADA::OpenCOLLADA INTERFACE ${OPENCOLLADA_INCLUDE_DIRS})
+    target_link_libraries(OpenCOLLADA::OpenCOLLADA INTERFACE ${OPENCOLLADA_LIBRARIES})
 endif()

cmake/FindPROJ.cmake

@@ -6,7 +6,7 @@
 # Input variables could also be provided as environment variables.
 #
 # Output targets:
-# - `PROJ::proj`
+# - `proj::proj`
 #
 
 # To avoid cyclic calls to this file
@@ -34,10 +34,12 @@ if((NOT PROJ_INCLUDE_DIR AND NOT PROJ_LIBRARIES))
             message(FATAL_ERROR "Unable to find PROJ libraries in: ${PROJ_LIBRARY_DIR}")
         endif()
 
-        add_library(PROJ::proj INTERFACE IMPORTED)
-        target_include_directories(PROJ::proj INTERFACE "${PROJ_INCLUDE_DIR}")
-        target_link_libraries(PROJ::proj INTERFACE ${PROJ_LIBRARIES})
-        target_link_directories(PROJ::proj INTERFACE "${PROJ_LIBRARY}")
+        if(NOT TARGET proj::proj)
+            add_library(proj::proj INTERFACE IMPORTED)
+            target_include_directories(proj::proj INTERFACE "${PROJ_INCLUDE_DIR}")
+            target_link_libraries(proj::proj INTERFACE ${PROJ_LIBRARIES})
+            target_link_directories(proj::proj INTERFACE "${PROJ_LIBRARY}")
+        endif()
     endif()
 else()
     find_library(PROJ_LIBRARY NAMES proj PATHS ${PROJ_LIBRARY_DIR})
@@ -50,7 +52,11 @@ else()
 
     set(PROJ_INCLUDE_DIR ${PROJ_INCLUDE_DIR} CACHE FILEPATH "PROJ header files")
     message(STATUS "Looking for PROJ include files in: ${PROJ_INCLUDE_DIR}")
-    include_directories(${PROJ_INCLUDE_DIR})
+    if(NOT TARGET proj::proj)
+        add_library(proj::proj INTERFACE IMPORTED)
+        target_include_directories(proj::proj INTERFACE "${PROJ_INCLUDE_DIR}")
+        target_link_libraries(proj::proj INTERFACE ${PROJ_LIBRARIES})
+    endif()
 endif()
 
 list(PREPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR})

cmake/FindUSD.cmake

@@ -64,7 +64,6 @@ set(USD_LIBRARIES
 find_library(USD_LIBRARY NAMES ${USD_LIBRARIES} PATHS ${USD_LIBRARY_DIR})
 if(USD_LIBRARY)
     message(STATUS "USD libraries ${USD_LIBRARIES} found in: ${USD_LIBRARY_DIR}")
-    link_directories(${USD_LIBRARY_DIR})
 else()
     message(FATAL_ERROR "Unable to find USD libraries in: ${USD_LIBRARY_DIR}")
 endif()
@@ -82,5 +81,3 @@ if(MSVC)
 endif()
 
 target_compile_definitions(pxr::USD INTERFACE PXR_STATIC WITH_USD)
-
-set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_USD)

conda/build.bat

@@ -37,7 +37,6 @@ cmake -G "Ninja" ^
  -D GLTF_SUPPORT:BOOL=ON ^
  -D BUILD_CONVERT:BOOL=ON ^
  -D BUILD_IFCMAX:BOOL=OFF ^
- -D IFCXML_SUPPORT:BOOL=ON ^
  -D Boost_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
  -D Boost_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
  -D Boost_USE_STATIC_LIBS:BOOL=OFF ^

conda/build.sh

@@ -34,7 +34,6 @@ cmake ${CMAKE_ARGS} -G Ninja \
  -DEIGEN_DIR:FILEPATH=$PREFIX/include/eigen3 \
  -DCOLLADA_SUPPORT:BOOL=OFF \
  -DBUILD_EXAMPLES:BOOL=OFF \
- -DIFCXML_SUPPORT:BOOL=ON \
  -DGLTF_SUPPORT:BOOL=ON \
  -DBUILD_CONVERT:BOOL=ON \
  -DBUILD_IFCPYTHON:BOOL=ON \

findings.md

@@ -0,0 +1,317 @@
+# Build fix: remove `boost_system` from CMake components
+
+`Boost.System` became header-only in Boost 1.69. Boost 1.90.0 no longer ships a compiled library or CMake config for it, so `find_package(Boost REQUIRED COMPONENTS system ...)` fails.
+
+## Fix
+
+`cmake/CMakeLists.txt`:
+
+```diff
+-    set(BOOST_COMPONENTS system program_options regex thread date_time iostreams)
++    set(BOOST_COMPONENTS program_options regex thread date_time iostreams)
+```
+
+The headers are still available; no linking is needed.
+
+# Build fix: add `template` keyword for dependent template member calls
+
+Calling a template member function through a dependent expression (e.g. `storage->has_attribute_value<T>(...)` where `storage`'s type depends on a template parameter) requires the `template` keyword to disambiguate from a less-than comparison.
+
+## Error
+
+```
+src/ifcparse/IfcParse.cpp:1856:67: error: expected primary-expression before '>' token
+ 1856 |                     if (storage->has_attribute_value<express::Base>(attr_index)) {
+      |                                                                   ^
+```
+
+Six identical errors at lines 1856, 1865, 1896, 1905, 1934, 1943.
+
+## Fix
+
+`src/ifcparse/IfcParse.cpp`:
+
+```diff
+-storage->has_attribute_value<express::Base>(attr_index)
++storage->template has_attribute_value<express::Base>(attr_index)
+
+-storage->has_attribute_value<Blank>(attr_index)
++storage->template has_attribute_value<Blank>(attr_index)
+```
+
+Applied at all six call sites in `in_memory_file_storage::read_from_stream`.
+
+# Linker fix: missing explicit template instantiations for `InstanceStreamer`
+
+`InstanceStreamer` is a class template with methods defined in `IfcParse.cpp`, not the header. Without explicit instantiations, the linker can't find the symbols when the SWIG wrapper loads.
+
+## Error
+
+```
+ImportError: undefined symbol: _ZN8IfcParse16InstanceStreamerINS_10FileReaderINS_14FullBufferImplEEEEC1EPS3_PNS_7IfcFileE
+  (IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(FileReader<FullBufferImpl>*, IfcFile*))
+```
+
+## Fix
+
+Cannot use `template class InstanceStreamer<...>` because some constructors have `static_assert` guards that reject certain reader types. Instead, instantiate each member function individually per reader type, only including the constructors valid for that type.
+
+`src/ifcparse/IfcParse.cpp` (after the last `InstanceStreamer` method definition):
+
+```cpp
+// FullBufferImpl
+template IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(IfcParse::IfcFile*);
+template IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(const std::string&, bool, IfcParse::IfcFile*);
+template IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(void*, int, IfcParse::IfcFile*);
+template IfcParse::InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(FileReader<FullBufferImpl>*, IfcParse::IfcFile*);
+// ... plus ensure_header, initialize_header, hasSemicolon, semicolonCount,
+//     pushPage, bypassTypes, readInstance
+
+// PushedSequentialImpl — same pattern, different valid constructors
+
+// MMapFileReader (ifdef USE_MMAP) — same pattern
+```
+
+# Linker fix: `FullBufferImpl` missing buffer constructor
+
+SWIG's `stream_from_string` calls `InstanceStreamer<FileReader<FullBufferImpl>>(void*, int, IfcFile*)`, but the `(void*, int)` constructor previously hit a `static_assert` for `FullBufferImpl` — it only allowed `PushedSequentialImpl`.
+
+## Error
+
+```
+ImportError: undefined symbol: _ZN8IfcParse16InstanceStreamerINS_10FileReaderINS_14FullBufferImplEEEEC1EPviPNS_7IfcFileE
+  (InstanceStreamer<FileReader<FullBufferImpl>>::InstanceStreamer(void*, int, IfcFile*))
+```
+
+## Fix
+
+Three changes to make `FullBufferImpl` support buffer-based and default construction:
+
+`src/ifcparse/FileReader.h` — add buffer constructor to `FullBufferImpl`:
+
+```diff
+ class IFC_PARSE_API FullBufferImpl {
+ public:
+     explicit FullBufferImpl(const std::string& fn);
++    FullBufferImpl(void* data, size_t length);
+```
+
+`src/ifcparse/FileReader.h` — add `FileReader(void*, size_t)` forwarding constructor:
+
+```diff
++    FileReader(void* data, size_t length)
++        : cursor_(0) {
++        if constexpr (std::is_same_v<Impl, FullBufferImpl>) {
++            impl_ = std::make_shared<Impl>(data, length);
++        } else {
++            static_assert(...);
++        }
++    }
+```
+
+`src/ifcparse/FileReader.cpp` — implement the constructor:
+
+```cpp
+FullBufferImpl::FullBufferImpl(void* data, size_t length)
+    : buf_(static_cast<char*>(data), static_cast<char*>(data) + length)
+    , size_(length) {
+}
+```
+
+`src/ifcparse/IfcParse.cpp` — extend the two `InstanceStreamer` constructors to accept `FullBufferImpl`:
+
+```diff
+ // InstanceStreamer(IfcFile*):
++    } else if constexpr (std::is_same_v<Reader, FileReader<FullBufferImpl>>) {
++        owned_stream_ = std::make_unique<Reader>(nullptr, (size_t)0);
+
+ // InstanceStreamer(void*, int, IfcFile*):
++    } else if constexpr (std::is_same_v<Reader, FileReader<FullBufferImpl>>) {
++        owned_stream_ = std::make_unique<Reader>(data, (size_t)length);
+```
+
+# Runtime fix: segfault in `parse_context::push()` due to vector reallocation
+
+`parse_context_pool` stores nodes in a `std::vector<parse_context>`. During parsing, `load()` takes a `parse_context&` parameter and calls `context.push()`, which calls `pool_->make()`. If the pool's vector reallocates (via `emplace_back`), all existing references into the vector — including the `context` reference held by the caller — become dangling. Subsequent access through the dangling reference causes a segfault.
+
+Triggered by larger IFC files (e.g. `ISSUE_159_kleine_Wohnung_R22.ifc`, 9.5 MB) that cause enough pool growth to trigger reallocation.
+
+## Error
+
+```
+Thread 1 received signal SIGSEGV, Segmentation fault.
+0x... in IfcParse::parse_context::push()
+  #1  in_memory_file_storage::load(...)   // context& is dangling after reallocation
+  #2  in_memory_file_storage::load(...)   // parent call
+  #3  InstanceStreamer::readInstance()
+```
+
+## Fix
+
+`src/ifcparse/storage.h` — change the pool container from `std::vector` to `std::deque`, which does not invalidate references on `push_back`/`emplace_back`:
+
+```diff
++#include <deque>
+
+ struct parse_context_pool {
+-    std::vector<parse_context> nodes_;
++    std::deque<parse_context> nodes_;
+```
+
+# Runtime fix: `express::Base` comparison operators throw on null/expired instances
+
+`express::Base::operator<` and `operator==` called `data()`, which throws `std::runtime_error("Trying to access deleted instance reference")` when the internal `weak_ptr` is expired. A default-constructed `express::Base` (the value-type equivalent of a null pointer) always has an expired `weak_ptr`.
+
+## Why this model triggers it
+
+The bug requires two conditions to coincide:
+
+1. A representation is shared by **more than one product** (via `IfcRepresentationMap` / `IfcMappedItem`).
+2. At least one of those products has **no material association**, so `get_single_material_association()` returns `express::Base{}` (the null equivalent).
+
+In `advanced_model.ifc`, Body representations like `#449` (Body/Brep) have a single `IfcRepresentationMap` (`#453`) with 13 `IfcMappedItem` usages, meaning 13 products share the geometry. Some of those products (e.g. `IfcFlowTerminal` instances) have no `IfcRelAssociatesMaterial`, so `get_single_material_association` returns `express::Base{}`.
+
+Smaller or simpler models don't hit this because either:
+- Every representation maps to only 1 product → `reuse_ok_` short-circuits at `products.size() == 1` before reaching the material check.
+- Every product has a material association → no null `express::Base` is ever inserted into the set.
+
+## Exact call sequence
+
+```
+Iterator::initialize()
+  try {
+    mapping::get_representations(reps, filters_)
+      addRepresentationsFromDefaultContexts(representations)
+        → collects reps from subcontexts in order:
+          Axis (#115): 143 reps
+          Body (#117): 7550 reps
+          FootPrint (#119): 12 reps
+
+      for (auto representation : representations):
+
+        ── Axis reps (indices 0–142) ──────────────────────────
+        products_represented_by(rep, rmap)
+          → OfProductRepresentation: 1 product each
+        filter_products(products, filters)   → 1 product
+        reuse_ok_(ifcproducts)
+          → products.size() == 1 → return true  ← SHORT-CIRCUIT, no material check
+        representation_mapped_to(rep)        → null (no MappedItem)
+        → task created.  143 tasks accumulated.
+
+        ── First Body rep #449 (Body/Brep) ────────────────────
+        products_represented_by(#449, rmap)
+          → OfProductRepresentation: empty
+          → RepresentationMap: 1 map (#453)
+          → MapUsage: 13 MappedItems → traces through to 13 IfcProducts
+        filter_products(products, filters)   → 13 products
+        reuse_ok_(ifcproducts)               ← CRASH HERE
+          → products.size() == 1?  NO (13 products)
+          → for each product:
+              find_openings(product)          → OK
+              get_single_material_association(product)
+                → some products have no IfcRelAssociatesMaterial
+                → returns express::Base{}     (expired weak_ptr)
+              associated_single_materials.insert(result)
+                → std::set::insert calls operator<
+                → operator< calls data()
+                → data() calls data_.lock() → expired → THROWS
+                  "Trying to access deleted instance reference"
+
+  } catch (const std::exception& e) {
+    Logger::Error(e)       ← exception caught here, get_representations aborted
+  }
+
+  → reps contains only the 143 Axis tasks created before the throw
+  → all 143 Axis reps have Curve2D geometry → map(representation) returns null
+  → no valid elements produced → initialize() returns false
+```
+
+In the old pointer-based code, `reuse_ok_` used `std::set<const IfcUtil::IfcBaseEntity*>` and `get_single_material_association` returned `nullptr`. Inserting `nullptr` into a `std::set<T*>` is a plain pointer comparison — no dereference, no throw. The refactoring to `std::set<express::Base>` changed the comparison from pointer comparison to `express::Base::operator<`, which unconditionally dereferences through `data()`.
+
+## Error
+
+```
+[Error] Trying to access deleted instance reference
+[Notice] Created 143 tasks for 143 products    ← only Axis reps; all Body reps lost
+initialize() returned: False
+```
+
+## Fix
+
+`src/ifcparse/express.h` — use `weak_ptr::lock().get()` instead of `data()` so that expired pointers compare as `nullptr` (matching old raw-pointer semantics):
+
+```diff
+     bool operator<(const Base& other) const {
+-        return data() < other.data();
++        auto a = data_.lock();
++        auto b = other.data_.lock();
++        return a.get() < b.get();
+     }
+
+     bool operator==(const Base& other) const {
+-        return data() == other.data();
++        auto a = data_.lock();
++        auto b = other.data_.lock();
++        return a.get() == b.get();
+     }
+```
+
+# Runtime fix: `entity_instance` missing `get_inverse` due to SWIG `%rename` collision
+
+Accessing inverse attributes (e.g. `element.IsDecomposedBy`) on any entity raises `AttributeError: entity instance of type 'IFC2X3.IfcProject' has no attribute 'get_inverse'`.
+
+## Why
+
+`entity_instance_mixin.__getattr__` (line 106 of `entity_instance.py`) calls `self.get_inverse(name)` when it detects an inverse attribute. Since the mixin inherits into the SWIG-generated `entity_instance` class (via the `object = custom_base` hack in `IfcParseWrapper.i:936`), `self.get_inverse` must resolve to a method on the SWIG class.
+
+However, `IfcParseWrapper.i:70` has a global rename:
+
+```
+%rename("get_inverses_by_declaration") get_inverse;
+```
+
+This was intended for `ifcopenshell::file::get_inverse` (which takes an entity + declaration and returns instances by reference), but SWIG `%rename` is global — it also renames the `%extend express::Base` method `get_inverse(const std::string& a)` at line 551. So the Python-side `entity_instance` class exposes the method as `get_inverses_by_declaration`, not `get_inverse`.
+
+The old code (`v0.8.0`) didn't hit this because `__getattr__` called `self.wrapped_data.get_inverse(name)` on an inner `ifcopenshell_wrapper.entity_instance` object — but in that old layout, the inner object was constructed differently and the rename didn't apply the same way (or the method had a different path). In the new mixin approach, `self` **is** the SWIG object, so the rename is directly visible.
+
+## Fix
+
+`src/ifcwrap/IfcParseWrapper.i` — override the global rename specifically for `express::Base::get_inverse`, restoring the original name on entity instances:
+
+```diff
++%rename("get_inverse") express::Base::get_inverse;
+ %rename("get_inverses_by_declaration") get_inverse;
+```
+
+Add this line **before** the global rename (or anywhere before the `%extend express::Base` block). This scoped rename takes precedence for `express::Base`, so:
+- `entity_instance.get_inverse(name)` works as the mixin expects
+- `file.get_inverses_by_declaration(...)` keeps its intended name
+
+## Python-side workaround
+
+`entity_instance.py:106` — call the method by its SWIG-renamed name:
+
+```diff
+-            vs = self.get_inverse(name)
++            vs = self.get_inverses_by_declaration(name)
+```
+
+# Runtime fix: `entity_instance` class no longer importable from `entity_instance` module
+
+The class rename from `entity_instance` to `entity_instance_mixin` broke external code that does `from ifcopenshell.entity_instance import entity_instance`.
+
+## Error
+
+```
+ImportError: cannot import name 'entity_instance' from 'ifcopenshell.entity_instance'
+```
+
+Triggered at import time via `ifcopenshell.util.pset` (and likely other modules).
+
+## Fix
+
+`src/ifcopenshell-python/ifcopenshell/entity_instance.py` — add a backwards-compatible alias at the bottom of the module:
+
+```python
+entity_instance = entity_instance_mixin
+```

nix/build-all.py

@@ -1,6 +1,4 @@
 #!/usr/bin/python
-# /// script
-# ///
 ###############################################################################
 #                                                                             #
 # This file is part of IfcOpenShell.                                          #
@@ -126,9 +124,16 @@ ssl._create_default_https_context = ssl._create_unverified_context
 import time
 from collections.abc import Generator, Sequence
 from pathlib import Path
-from typing import Literal, Union
 from urllib.request import urlretrieve
 
+try:
+    from typing import Literal, Union
+except:
+    # python 3.6 compatibility for rocky 8
+    from typing import Union
+
+    from typing_extensions import Literal
+
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 ch = logging.StreamHandler()
@@ -157,6 +162,8 @@ USD_VERSION = "23.05"
 TBB_VERSION = "2021.9.0"
 ROCKSDB_VERSION = "9.11.2"
 ZSTD_VERSION = "1.5.7"
+MANIFOLD_VERSION = "3.2.1"
+
 # binaries
 cp = "cp"
 bash = "bash"
@@ -325,7 +332,7 @@ cecho(""" - IFC Schemas to compile. If not provided, fallback to default provide
 
 dependency_tree: "dict[str, tuple[str, ...]]" = {
     "IfcParse": ("boost", "libxml2", "hdf5", "rocksdb"),
-    "IfcGeom": ("IfcParse", "occ", "json", "cgal", "eigen", "OpenCOLLADA"),
+    "IfcGeom": ("IfcParse", "occ", "manifold", "json", "cgal", "eigen", "OpenCOLLADA"),
     "IfcConvert": ("IfcGeom",),
     "OpenCOLLADA": ("libxml2", "pcre"),
     "IfcGeomServer": ("IfcGeom",),
@@ -342,6 +349,7 @@ dependency_tree: "dict[str, tuple[str, ...]]" = {
     "eigen": (),
     "rocksdb": ("zstd",),
     "zstd": (),
+    "manifold": (),
     # 'usd': ('boost', 'oneTBB')
 }
 
@@ -578,6 +586,11 @@ def run_cmake(arg1, cmake_args: "list[str]", cmake_dir: Union[str, None] = None,
             ]
         )
 
+    if not any("BUILD_SHARED_LIBS" in f for f in cmake_args):
+        cmake_flags.append(
+            f"-DBUILD_SHARED_LIBS={OFF_ON[not BUILD_STATIC]}",
+        )
+
     run(
         [
             *wasm,
@@ -586,7 +599,6 @@ def run_cmake(arg1, cmake_args: "list[str]", cmake_dir: Union[str, None] = None,
             *cmake_flags,
             *cmake_args,
             f"-DCMAKE_BUILD_TYPE={BUILD_CFG}",
-            f"-DBUILD_SHARED_LIBS={OFF_ON[not BUILD_STATIC]}",
             f"-DCMAKE_SHARED_LINKER_FLAGS={os.environ['LDFLAGS']}",
         ],
         cwd=cwd,
@@ -989,6 +1001,29 @@ elif "occ" in targets:
         download_name=f"OCE-{OCE_VERSION}.tar.gz",
     )
 
+if "manifold" in targets:
+    dependency_name = f"manifold-{MANIFOLD_VERSION}"
+    build_dependency(
+        name=dependency_name,
+        mode="cmake",
+        build_tool_args=[
+            f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/{dependency_name}",
+            "-DMANIFOLD_PAR=OFF",
+            "-DMANIFOLD_CROSS_SECTION=OFF",
+            "-DMANIFOLD_PYBIND=OFF",
+            "-DMANIFOLD_JSBIND=OFF",
+            "-DMANIFOLD_CBIND=OFF",
+            "-DMANIFOLD_TEST=OFF",
+            "-DMANIFOLD_EXPORT=OFF",
+            "-DMANIFOLD_DOWNLOADS=OFF",
+            *MAC_CROSS_COMPILE_INTEL_ARGS,
+        ],
+        download_url="https://github.com/elalish/manifold.git",
+        download_name="manifold",
+        download_tool=download_tool_git,
+        revision=f"v{MANIFOLD_VERSION}",
+    )
+
 if "libxml2" in targets:
     OLD_CC = ""
     if MAC_CROSS_COMPILE_INTEL:
@@ -1299,16 +1334,17 @@ if os.environ.get("NO_CLEAN", "").lower() not in {"1", "on", "true"}:
     if os.path.exists(IFCOS_DIR):
         shutil.rmtree(IFCOS_DIR)
 os.makedirs(IFCOS_DIR, exist_ok=True)
-executables_dir = os.path.join(IFCOS_DIR, "executables")
-os.makedirs(executables_dir, exist_ok=True)
+ifcos_build_dir = os.path.join(IFCOS_DIR, "build")
+os.makedirs(ifcos_build_dir, exist_ok=True)
 
 
 cmake_args = [
     "-DUSE_MMAP=OFF",
     "-DBUILD_EXAMPLES=OFF",
-    "-DBUILD_SHARED_LIBS=" + OFF_ON[not BUILD_STATIC],
+    "-DBUILD_SHARED_LIBS=ON",
     "-DGLTF_SUPPORT=ON",
     "-DBoost_NO_BOOST_CMAKE=On",
+    "-DCREATE_BUNDLE=On",
     "-DADD_COMMIT_SHA=" + ("On" if ADD_COMMIT_SHA else "Off"),
     "-DVERSION_OVERRIDE=" + ("On" if ADD_COMMIT_SHA else "Off"),
     *MAC_CROSS_COMPILE_INTEL_ARGS,
@@ -1358,6 +1394,10 @@ elif "occ" in targets:
     occ_library_dir = f"{DEPS_DIR}/install/oce-{OCE_VERSION}/lib"
     cmake_args.extend(["-DOCC_INCLUDE_DIR=" + occ_include_dir, "-DOCC_LIBRARY_DIR=" + occ_library_dir])
 
+if "manifold" in targets:
+    cmake_args_prefix_path.append(f"{DEPS_DIR}/install/manifold-{MANIFOLD_VERSION}")
+    cmake_args.append("-DWITH_MANIFOLD=On")
+
 if "OpenCOLLADA" in targets:
     # pcre is a dependency of OpenCOLLADA, but since we `find_package`,
     # we don't need to add it explicitly here as cmake will find it from the config.
@@ -1403,40 +1443,33 @@ if "rocksdb" in targets:
 if "swig" in targets:
     cmake_args_prefix_path.append(f"{DEPS_DIR}/install/swig-{SWIG_VERSION}")
 
+ifcos_build_args = [
+    f"-DBUILD_IFCGEOM={OFF_ON['IfcGeom' in targets]}",
+    f"-DBUILD_GEOMSERVER={OFF_ON['IfcGeomServer' in targets]}",
+    f"-DBUILD_CONVERT={OFF_ON['IfcConvert' in targets]}",
+    f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/ifcopenshell",
+]
+
 if not WASM and (not explicit_targets or {"IfcGeom", "IfcConvert", "IfcGeomServer"} & set(explicit_targets)):
     logger.info("\rConfiguring executables...")
 
     exec_args = [
-        f"-DBUILD_IFCGEOM={OFF_ON['IfcGeom' in targets]}",
-        f"-DBUILD_GEOMSERVER={OFF_ON['IfcGeomServer' in targets]}",
-        f"-DBUILD_CONVERT={OFF_ON['IfcConvert' in targets]}",
+        *ifcos_build_args,
         f"-DBUILD_IFCPYTHON=OFF",
-        f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/ifcopenshell",
     ]
 
-    run_cmake("", exec_args + cmake_args + get_cmake_args_prefix_path(), cmake_dir=CMAKE_DIR, cwd=executables_dir)
+    run_cmake("", exec_args + cmake_args + get_cmake_args_prefix_path(), cmake_dir=CMAKE_DIR, cwd=ifcos_build_dir)
 
     logger.info("\rBuilding executables...   ")
 
-    run([make, f"-j{IFCOS_NUM_BUILD_PROCS}", "VERBOSE=1"], cwd=executables_dir)
-    run([make, "install/strip" if BUILD_CFG == "Release" else "install"], cwd=executables_dir)
+    run([make, f"-j{IFCOS_NUM_BUILD_PROCS}", "VERBOSE=1"], cwd=ifcos_build_dir)
+    run([make, "install/strip" if BUILD_CFG == "Release" else "install"], cwd=ifcos_build_dir)
 
 if "IfcOpenShell-Python" in targets:
-    # On OSX the actual Python library is not linked against.
-    ADDITIONAL_ARGS = ""
+    wrapper_ldflags = ""
     if platform.system() == "Darwin":
-        ADDITIONAL_ARGS = "-Wl,-undefined,dynamic_lookup"
-
-    # NOTE: We don't use `CXXFLAGS` for wrappers, so wrapper is compiled with different flags
-    # (e.g. ` -fdata-sections` is missing, which is set by default for executables)
-    # So cache doesn't match and running build-all.py builds most of ifcopenshell libraries twice.
-    os.environ["CPPFLAGS"] = f"{CXXFLAGS_MINIMAL} {ADDITIONAL_ARGS}"
-    os.environ["CXXFLAGS"] = f"{CXXFLAGS_MINIMAL} {ADDITIONAL_ARGS}"
-    os.environ["CFLAGS"] = f"{CFLAGS_MINIMAL} {ADDITIONAL_ARGS}"
-    os.environ["LDFLAGS"] = f"{LDFLAGS} {ADDITIONAL_ARGS}"
-
-    python_dir = os.path.join(IFCOS_DIR, "pythonwrapper")
-    os.makedirs(python_dir, exist_ok=True)
+        # On OSX the actual Python library is not linked against.
+        wrapper_ldflags = "-Wl,-undefined,dynamic_lookup"
 
     def compile_python_wrapper(
         python_version: str,
@@ -1451,10 +1484,6 @@ if "IfcOpenShell-Python" in targets:
 
         logger.info(f"\rConfiguring python {python_version} wrapper...")
 
-        cache_path = os.path.join(python_dir, "CMakeCache.txt")
-        if os.path.exists(cache_path):
-            os.remove(cache_path)
-
         if python_path:
             # We couldn't just prefix PATH and have to provide all variables explicitly,
             # see ifcwrap/cmake for the details.
@@ -1468,27 +1497,38 @@ if "IfcOpenShell-Python" in targets:
             )
 
         assert python_include
-        run_cmake(
-            "",
-            cmake_args
-            + get_cmake_args_prefix_path()
-            + [
-                *([f"-DPYTHON_EXECUTABLE={python_executable}"] if python_executable else []),
-                # Needed because pyodide is expecting setup.py to be in the root.
-                *([f"-DPYTHON_MODULE_INSTALL_DIR={REPO_PATH}"] * WASM),
-                f"-DPYTHON_INCLUDE_DIR={python_include}",
-                f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/ifcopenshell/tmp",
-                "-DUSERSPACE_PYTHON_PREFIX="
-                + ["Off", "On"][os.environ.get("PYTHON_USER_SITE", "").lower() in {"1", "on", "true"}],
-            ],
-            cmake_dir=CMAKE_DIR,
-            cwd=python_dir,
-        )
+        old_ldflags = os.environ["LDFLAGS"]
+        if wrapper_ldflags:
+            os.environ["LDFLAGS"] = f"{old_ldflags} {wrapper_ldflags}"
+
+        try:
+            run_cmake(
+                "",
+                ifcos_build_args
+                + [
+                    "-DBUILD_IFCPYTHON=ON",
+                ]
+                + cmake_args
+                + get_cmake_args_prefix_path()
+                + [
+                    *([f"-DPYTHON_EXECUTABLE={python_executable}"] if python_executable else []),
+                    # Needed because pyodide is expecting setup.py to be in the root.
+                    *([f"-DPYTHON_MODULE_INSTALL_DIR={REPO_PATH}"] * WASM),
+                    f"-DPYTHON_INCLUDE_DIR={python_include}",
+                    f"-DCMAKE_INSTALL_PREFIX={DEPS_DIR}/install/ifcopenshell/tmp",
+                    "-DUSERSPACE_PYTHON_PREFIX="
+                    + ["Off", "On"][os.environ.get("PYTHON_USER_SITE", "").lower() in {"1", "on", "true"}],
+                ],
+                cmake_dir=CMAKE_DIR,
+                cwd=ifcos_build_dir,
+            )
+        finally:
+            os.environ["LDFLAGS"] = old_ldflags
 
         logger.info(f"\rBuilding python {python_version} wrapper...   ")
 
-        run([make, f"-j{IFCOS_NUM_BUILD_PROCS}", "ifcopenshell_wrapper", "VERBOSE=1"], cwd=python_dir)
-        run([make, "install/local"], cwd=os.path.join(python_dir, "ifcwrap"))
+        run([make, f"-j{IFCOS_NUM_BUILD_PROCS}", "ifcopenshell_wrapper", "VERBOSE=1"], cwd=ifcos_build_dir)
+        run([make, "install/local"], cwd=os.path.join(ifcos_build_dir, "ifcwrap"))
 
         if python_executable:
             run([python_executable, "-m", "ensurepip"])

nix/cache_dependencies.py

@@ -1,5 +1,3 @@
-# /// script
-# ///
 """
 Cache built dependencies for builds.
 

pyodide/build_pyodide.sh

@@ -1,11 +1,6 @@
 #!/usr/bin/bash
 set -ex
 
-PYODIDE_VERSION=0.29.3
-PYODIDE_BUILD_VERSION=0.33.0
-PYODIDE_XBUILDENV_ROOT="${HOME}/.cache/.pyodide-xbuildenv-${PYODIDE_BUILD_VERSION}"
-PYODIDE_XBUILDENV="${PYODIDE_XBUILDENV_ROOT}/${PYODIDE_VERSION}"
-
 # Script is assuming that it will be possible to execute it multiple times
 # therefore we're clearing venv each time and ignoring existing 'emsdk' folder.
 
@@ -16,15 +11,14 @@ source .venv/bin/activate
 
 # Install pyodide cross build environment.
 # Instructions: https://pyodide.org/en/stable/development/building-packages.html
-uv pip install "pyodide-build==${PYODIDE_BUILD_VERSION}"
+uv pip install pyodide-build
 # `uv run` is required, so xbuildenv would skip using `pip`.
-uv run pyodide xbuildenv install "${PYODIDE_VERSION}"
+uv run pyodide xbuildenv install
 uv run pyodide xbuildenv install-emscripten
 
-EMSDK_ROOT="${PYODIDE_XBUILDENV}/emsdk"
-source "${EMSDK_ROOT}/emsdk_env.sh"
+EMSDK_ROOT=$(pyodide config get emscripten_dir)
+source ${EMSDK_ROOT}/emsdk_env.sh
 which emcc
-emcc --version
 
 mkdir -p packages/ifcopenshell
 VERSION=`cat IfcOpenShell/VERSION`

pyproject.toml

@@ -3,9 +3,9 @@ name = "IfcOpenShell"
 version = "0.0.0"
 dependencies = [
     "black==26.3.1",
-    "ruff==0.15.12",
+    "ruff==0.15.9",
     "poethepoet",
-    "ty==0.0.32",
+    "ty==0.0.29",
     "gersemi==0.26.1",
 ]
 
@@ -215,7 +215,10 @@ exclude = [
 
 [tool.poe.tasks]
 
-ruff = "ruff check"
+ruff-main = "ruff check --extend-exclude nix/build-all.py"
+# It's actually Python 3.6, but ruff only supports 3.7+, but it should do.
+ruff-old = "ruff check nix/build-all.py --target-version py37"
+ruff.sequence = ["ruff-main", "ruff-old"]
 
 black = "black ."
 
@@ -235,7 +238,7 @@ ty-venv-ios.sequence = [
     {cmd = "uv pip install -r src/ifcopenshell-python/type-check-requirements.txt --python=src/ifcopenshell-python/.venv"},
 ]
 
-format.sequence = ["black", "ruff"]
+format.sequence = ["black", "ruff-main", "ruff-old"]
 
 cmake-format = "gersemi . --in-place"
 

src/bcf/bcf/v2/visinfo.py

@@ -316,7 +316,7 @@ def build_viewpoint(element: entity_instance) -> mdl.VisualizationInfo:
     Returns:
         The BCF viewpoint definition.
     """
-    ifc_file = element.wrapped_data.file
+    ifc_file = element.file
     unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
     elem_placement = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement)
     elem_placement[:3, 3] *= unit_scale

src/bcf/bcf/v3/visinfo.py

@@ -316,7 +316,7 @@ def build_viewpoint(element: entity_instance) -> mdl.VisualizationInfo:
     Returns:
         The BCF viewpoint definition.
     """
-    ifc_file = element.wrapped_data.file
+    ifc_file = element.file
     unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
     elem_placement = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement)
     elem_placement[:3, 3] *= unit_scale

src/bonsai/Makefile

@@ -17,8 +17,8 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
 SHELL := sh
-PYTHON:=python3
-PIP:=pip3
+PYTHON:=python3.11
+PIP:=pip3.11
 PATCH:=patch
 SED:=sed -i
 VENV_ACTIVATE:=bin/activate

src/bonsai/bonsai/bim/__init__.py

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import importlib
 import os
@@ -29,18 +27,6 @@ from bpy_extras.io_utils import ExportHelper, ImportHelper
 
 from . import handler, operator, prop, ui
 
-
-def _parametric_gizmo_preference_classes() -> list[type]:
-    """Resolves the registry-driven ``GizmoPreferences<X>`` classes for the
-    ``classes`` list below. ``import bonsai.tool`` is kept local to surface
-    the load-order constraint: it relies on ``from . import handler, …``
-    above having primed the
-    ``tool/ifc.py → bim/ifc.py → bim/handler.py → bonsai.tool`` cycle."""
-    import bonsai.tool as tool
-
-    return tool.Parametric.iter_gizmo_preference_classes(ui)
-
-
 try:
     from bonsai.translations import translations_dict
 except ImportError:
@@ -171,10 +157,9 @@ classes = [
     ui.BIM_UL_tab_visibilities,
     ui.BIM_UL_panel_visibilities,
     ui.DocPreferences,
-    # Per-parametric-type ``GizmoPreferences<Name>`` classes — must register
-    # before ``ui.GizmoPreferences`` which holds the matching PointerProperty
-    # fields. Driven by ``tool.Parametric.EDIT_TYPES``.
-    *_parametric_gizmo_preference_classes(),
+    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

src/bonsai/bonsai/bim/data/fonts/LICENSE

@@ -1,96 +0,0 @@
-Copyright (c) 2011-2012, Nikita Volchenkov (<nikitavolchenkov@gmail.com>),
-with Reserved Font Name OpenGost Type B.
-
-Copyright (c) 2012, Valek Filippov (<frob@gnome.org>).
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-
------------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
------------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.

src/bonsai/bonsai/bim/handler.py

@@ -15,12 +15,11 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import os
 import weakref
 from collections.abc import Callable
+from math import cos
 from typing import Union
 
 import bpy
@@ -32,7 +31,6 @@ from bpy.app.handlers import persistent
 from mathutils import Vector
 
 import bonsai.bim
-import bonsai.core.model as core_model
 import bonsai.tool as tool
 from bonsai.bim.ifc import IfcStore
 from bonsai.bim.module.aggregate.decorator import AggregateDecorator
@@ -135,32 +133,14 @@ def update_bim_tool_props():
 
             if is_annotation_tool and (object_type := tool.Drawing.get_annotation_type_object_type(element_type)):
                 aprops.object_type = object_type
-                try:
-                    aprops.relating_type_id = str(element_type.id())
-                except TypeError:
-                    # EnumProperty items are rebuilt asynchronously when ifc_class changes;
-                    # this assignment can race a stale item list. Skipping is harmless —
-                    # the UI will resync on the next active_object_callback.
-                    pass
+                aprops.relating_type_id = str(element_type.id())
                 return
 
             if is_bim_tool:
                 props.ifc_class = element_type.is_a()
 
-            # Only assign when the target enum is the one that lists this type — otherwise
-            # we hit `enum "<id>" not found in (...)` if the user selects an element of a
-            # different class than the workspace tool was built for (e.g. selecting a wall
-            # while the door tool is active).
-            tool_class_match = TOOLS_TO_CLASSES_MAP.get(current_tool.idname) == element_type.is_a()
-            bim_tool_class_match = is_bim_tool and props.ifc_class == element_type.is_a()
-            if bim_tool_class_match or tool_class_match:
-                try:
-                    props.relating_type_id = str(element_type.id())
-                except TypeError:
-                    # Defensive: the enum item list can lag behind ifc_class assignment
-                    # above. Skipping leaves the panel briefly out of sync rather than
-                    # crashing the handler (which Blender re-fires on every selection).
-                    pass
+            if is_bim_tool or TOOLS_TO_CLASSES_MAP.get(current_tool.idname) == element_type.is_a():
+                props.relating_type_id = str(element_type.id())
 
     if is_annotation_tool:
         return
@@ -185,9 +165,7 @@ def update_bim_tool_props():
     if AuthoringData.data["active_material_usage"] == "LAYER2":
         x_angle = get_x_angle(extrusion)
         axis = tool.Model.get_wall_axis(obj)["reference"]
-        props.extrusion_depth = core_model.vertical_height_from_extrusion_depth(
-            extrusion.Depth * si_conversion, x_angle
-        )
+        props.extrusion_depth = abs(extrusion.Depth * si_conversion * cos(x_angle))
         props.length = (axis[1] - axis[0]).length
         props.x_angle = x_angle
 

src/bonsai/bonsai/bim/helper.py

@@ -187,7 +187,7 @@ def import_attributes(
         info = {a.name(): None for a in attributes}
         info["type"] = element
     else:
-        assert (entity := element.wrapped_data.declaration().as_entity())
+        assert (entity := element.declaration().as_entity())
         attributes = entity.all_attributes()
         info = element.get_info()
     for attribute in attributes:

src/bonsai/bonsai/bim/ifc.py

@@ -514,7 +514,6 @@ class IfcStore:
                     BrickStore.end_transaction()
                 IfcStore.end_transaction(operator)
                 bonsai.bim.handler.refresh_ui_data()
-                tool.Parametric.refresh_post_commit()
 
                 if method == "MODAL":
                     cls.modal_in_progress = False

src/bonsai/bonsai/bim/module/cost/data.py

@@ -206,7 +206,7 @@ class CostSchedulesData:
                 data["UnitSymbol"] = ifcopenshell.util.unit.get_unit_symbol(unit)
             if quantity.is_a("IfcPhysicalSimpleQuantity"):
                 measure_class = (
-                    quantity.wrapped_data.declaration()
+                    quantity.declaration()
                     .as_entity()
                     .attribute_by_index(3)
                     .type_of_attribute()

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

@@ -90,7 +90,7 @@ class PrintIfcFile(bpy.types.Operator):
         return tool.Ifc.get()
 
     def execute(self, context):
-        print(tool.Ifc.get().wrapped_data.to_string())
+        print(tool.Ifc.get().to_string())
         return {"FINISHED"}
 
 

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

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import bpy
 
@@ -145,14 +143,6 @@ classes = (
     gizmos.GizmoCancel,
     gizmos.GizmoPlus,
     gizmos.GizmoMinus,
-    gizmos.GizmoMerge,
-    gizmos.GizmoSplit,
-    gizmos.GizmoExtend,
-    gizmos.GizmoExtendVertical,
-    gizmos.GizmoOffsetExterior,
-    gizmos.GizmoOffsetCenter,
-    gizmos.GizmoOffsetInterior,
-    gizmos.GizmoAddOpening,
     gizmos.GizmoCycle,
     # Drawing-specific gizmos
     gizmos.UglyDotGizmo,

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

@@ -16,8 +16,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 """
 Gizmo infrastructure for parametric BIM element editing.
@@ -513,7 +511,6 @@ class DimensionTextRenderer:
         color: tuple[float, float, float],
         offset_sign: int = 1,
         alignment: TextAlignment | str = TextAlignment.CENTER,
-        display_text: str | None = None,
     ) -> None:
         """Draw formatted dimension value text at the given screen position.
 
@@ -525,20 +522,15 @@ class DimensionTextRenderer:
             color: Text color (r, g, b)
             offset_sign: 1 for above/right, -1 for below/left
             alignment: TextAlignment enum value
-            display_text: Pre-formatted label. If provided, used verbatim instead of
-                formatting `value`.
         """
         # Normalize string to enum for comparison
         if isinstance(alignment, str):
             alignment = TextAlignment(alignment)
 
-        if display_text is not None:
-            text = display_text
-        else:
-            is_negative = value < 0
-            text = tool.Unit.format_distance(abs(value))
-            if is_negative:
-                text = "-" + text
+        is_negative = value < 0
+        text = tool.Unit.format_distance(abs(value))
+        if is_negative:
+            text = "-" + text
 
         font_id = 0
         font_size = tool.Blender.scale_font_size(self.VALUE_FONT_SIZE)
@@ -803,7 +795,6 @@ class DimensionRenderer:
         text_alignment: TextAlignment = TextAlignment.CENTER,
         prop_name: str | None = None,
         display_value: float | None = None,
-        display_text: str | None = None,
     ) -> None:
         """Draw complete dimension graphics in screen space.
 
@@ -825,8 +816,6 @@ class DimensionRenderer:
             text_alignment: TextAlignment enum for text positioning
             prop_name: Property name for tooltip (shown when highlighted)
             display_value: Value to display as text (can be negative); uses dimension_length if None
-            display_text: Pre-formatted label string. If provided, used verbatim instead of
-                formatting `display_value` via tool.Unit.format_distance.
         """
         if dimension_length < 0:
             return
@@ -946,14 +935,7 @@ class DimensionRenderer:
                 )
                 text_color = highlight_color if is_highlight else color
                 DimensionTextRenderer.get_instance().draw_value_text(
-                    context,
-                    center_screen,
-                    perpendicular,
-                    text_value,
-                    text_color,
-                    text_offset_sign,
-                    text_alignment,
-                    display_text,
+                    context, center_screen, perpendicular, text_value, text_color, text_offset_sign, text_alignment
                 )
 
             if is_highlight and prop_name:
@@ -1139,13 +1121,6 @@ class DimensionGizmoConfig:
             If provided, eliminates need for get_dimension_matrix_{attr_name} method.
             The returned Vector is the local-space position where the gizmo origin
             will be placed. Combined with axis to create the full transformation matrix.
-        text_formatter: Optional function(props, value) -> str for the dimension label.
-            Receives the props bag and the post-`compute_value` display value
-            (i.e. the same number `apply_value` consumes during drag — for the
-            wall slope gizmo this is the displacement, NOT the underlying
-            `x_angle`). The raw underlying attribute is accessible as
-            `getattr(props, attr_name)`. If None, falls back to the default
-            `tool.Unit.format_distance(abs(value))` with negative-sign handling.
     """
 
     attr_name: str
@@ -1163,7 +1138,6 @@ class DimensionGizmoConfig:
     apply_value: Callable[[Any, float], None] | None = None
     visibility_condition: Callable[[Any], bool] | None = None
     matrix_position: Callable[[Any], "Vector"] | None = None  # Optional: function(props) -> Vector position
-    text_formatter: Callable[[Any, float], str] | None = None  # Optional: function(props, value) -> label text
 
     def __post_init__(self):
         # Validate attr_name
@@ -1602,78 +1576,6 @@ def get_billboard_rotation(context: bpy.types.Context) -> Matrix:
     return rv3d.view_matrix.to_3x3().transposed().to_4x4()
 
 
-def billboarded_at(world_pos: Vector, billboard_rot: Matrix, scale: float = 0.5) -> Matrix:
-    """Compose the standard icon ``matrix_basis``: translate to ``world_pos``, billboard
-    to the camera, then uniformly scale. Replaces the repeated
-    ``Matrix.Translation(...) @ billboard_rot @ Matrix.Scale(scale, 4)`` pattern."""
-    return Matrix.Translation(world_pos) @ billboard_rot @ Matrix.Scale(scale, 4)
-
-
-def setup_icon_gizmo(
-    gizmo_group: bpy.types.GizmoGroup,
-    gizmo_type: str,
-    color: tuple[float, float, float],
-    highlight_color: tuple[float, float, float],
-    operator: str,
-    alpha: float = 0.8,
-) -> bpy.types.Gizmo:
-    """Create and configure a stand-alone icon gizmo with the Bonsai defaults
-    (no draw-scale, fixed alpha, click-to-operator). Use this from any
-    ``GizmoGroup.setup`` to avoid hand-rolling the same five property assignments."""
-    gizmo = gizmo_group.gizmos.new(gizmo_type)
-    gizmo.use_draw_scale = False
-    gizmo.color = color
-    gizmo.color_highlight = highlight_color
-    gizmo.alpha = alpha
-    gizmo.target_set_operator(operator)
-    return gizmo
-
-
-# --- Tris geometry helpers ----------------------------------------------------
-# Shared by the icon ``bpy.types.Gizmo`` subclasses defined later in this module.
-# Each gizmo declares a flat ``tris`` tuple of (x, y, z) vertices grouped into
-# triangles of 3; these helpers compose tris from primitives so the per-gizmo
-# definitions stay small and visually readable.
-
-
-def rect_tris(x0: float, y0: float, x1: float, y1: float) -> tuple[tuple[float, float, float], ...]:
-    """Two triangles forming an axis-aligned rectangle from ``(x0, y0)`` to ``(x1, y1)``,
-    in the Z=0 plane (the convention for icon gizmos)."""
-    return (
-        (x0, y0, 0.0),
-        (x0, y1, 0.0),
-        (x1, y1, 0.0),
-        (x0, y0, 0.0),
-        (x1, y1, 0.0),
-        (x1, y0, 0.0),
-    )
-
-
-def swap_xy_tris(
-    tris: tuple[tuple[float, float, float], ...],
-) -> tuple[tuple[float, float, float], ...]:
-    """Reflect a ``tris`` tuple across the Y=X diagonal — useful when a "vertical"
-    sibling of a "horizontal" icon should otherwise be a literal copy."""
-    return tuple((y, x, z) for x, y, z in tris)
-
-
-class TrisGizmoMixin:
-    """Mixin for stand-alone ``bpy.types.Gizmo`` classes whose only behaviour is
-    drawing a static ``tris`` triangle tuple. Subclasses set the class-level
-    ``tris`` and ``bl_idname`` attributes; the mixin supplies ``setup`` / ``draw`` /
-    ``draw_select``. Use only with gizmos that have no per-instance state beyond
-    ``custom_shape``."""
-
-    def setup(self) -> None:
-        self.custom_shape = self.new_custom_shape("TRIS", self.tris)
-
-    def draw(self, context: bpy.types.Context) -> None:
-        self.draw_custom_shape(self.custom_shape)
-
-    def draw_select(self, context: bpy.types.Context, select_id: int) -> None:
-        self.draw_custom_shape(self.custom_shape, select_id=select_id)
-
-
 def get_camera_direction(context: bpy.types.Context, position: Vector) -> Vector | None:
     """Get normalized direction from position towards camera."""
     rv3d = context.region_data
@@ -3140,145 +3042,6 @@ class GizmoMinus(bpy.types.Gizmo):
         self.draw_custom_shape(self.custom_shape, select_id=select_id)
 
 
-class GizmoMerge(TrisGizmoMixin, bpy.types.Gizmo):
-    """Two arrows pointing inward toward each other — conveys joining/merging elements."""
-
-    bl_idname = "VIEW3D_GT_merge"
-
-    __slots__ = ("custom_shape",)
-
-    # Two solid triangles pointing toward the center on the horizontal axis,
-    # plus two thin tails behind each tip to make them read as arrows rather than
-    # standalone triangles.
-    tris = (
-        # Left arrowhead pointing right (tip at x≈-0.05).
-        (-0.35, -0.20, 0.0),
-        (-0.35, 0.20, 0.0),
-        (-0.05, 0.0, 0.0),
-        # Left tail behind the arrowhead.
-        *rect_tris(-0.45, -0.06, -0.30, 0.06),
-        # Right arrowhead pointing left (tip at x≈0.05).
-        (0.35, -0.20, 0.0),
-        (0.35, 0.20, 0.0),
-        (0.05, 0.0, 0.0),
-        # Right tail behind the arrowhead.
-        *rect_tris(0.30, -0.06, 0.45, 0.06),
-    )
-
-
-class GizmoSplit(TrisGizmoMixin, bpy.types.Gizmo):
-    """Two arrows pointing outward away from each other — conveys splitting/cutting
-    one element into two. Visual inverse of `GizmoMerge`."""
-
-    bl_idname = "VIEW3D_GT_split"
-
-    __slots__ = ("custom_shape",)
-
-    # Two solid triangles pointing OUTWARD on the horizontal axis (tips at x=±0.35),
-    # with tails extending toward the centerline. The tails meet at center to form a
-    # short horizontal bar, suggesting the split point itself.
-    tris = (
-        # Left arrowhead pointing left (tip at x=-0.35).
-        (-0.05, -0.20, 0.0),
-        (-0.05, 0.20, 0.0),
-        (-0.35, 0.0, 0.0),
-        # Left tail extending toward the right (away from the tip, toward center).
-        *rect_tris(-0.05, -0.06, 0.10, 0.06),
-        # Right arrowhead pointing right (tip at x=0.35).
-        (0.05, -0.20, 0.0),
-        (0.05, 0.20, 0.0),
-        (0.35, 0.0, 0.0),
-        # Right tail extending toward the left.
-        *rect_tris(-0.10, -0.06, 0.05, 0.06),
-    )
-
-
-class GizmoExtend(TrisGizmoMixin, bpy.types.Gizmo):
-    """An arrow pointing into a vertical bar — conveys extending an element to a target
-    line (e.g. extending a wall to the 3D cursor)."""
-
-    bl_idname = "VIEW3D_GT_extend"
-
-    __slots__ = ("custom_shape",)
-
-    # Layout: thick vertical bar at the right edge (the "target") with a horizontal
-    # arrow pointing into it from the left.
-    tris = (
-        # Vertical target bar (x = 0.25 to 0.35, full height).
-        *rect_tris(0.25, -0.30, 0.35, 0.30),
-        # Arrowhead pointing right toward the bar (tip at x=0.20).
-        (-0.05, -0.18, 0.0),
-        (-0.05, 0.18, 0.0),
-        (0.20, 0.0, 0.0),
-        # Tail extending leftward from the arrowhead base.
-        *rect_tris(-0.35, -0.06, -0.05, 0.06),
-    )
-
-
-class GizmoExtendVertical(TrisGizmoMixin, bpy.types.Gizmo):
-    """Vertical sibling of `GizmoExtend` — arrow pointing UP into a horizontal
-    bar. Conveys extending an element's height to a target Z."""
-
-    bl_idname = "VIEW3D_GT_extend_vertical"
-
-    __slots__ = ("custom_shape",)
-
-    # Mechanically derived from GizmoExtend by reflecting across Y=X.
-    tris = swap_xy_tris(GizmoExtend.tris)
-
-
-def _offset_baseline_tris(mark_x: float) -> tuple[tuple[float, float, float], ...]:
-    """Shared geometry for the three offset-baseline icons: a horizontal "wall
-    section" bar with a vertical mark at ``mark_x`` indicating where the reference
-    axis sits within the wall thickness. Matches the visual convention used in the
-    Bonsai N-panel's wall Align row."""
-    return rect_tris(-0.25, -0.07, 0.25, 0.07) + rect_tris(mark_x - 0.04, -0.22, mark_x + 0.04, 0.22)
-
-
-class GizmoOffsetExterior(TrisGizmoMixin, bpy.types.Gizmo):
-    """Wall offset baseline indicator — reference axis at the exterior face (left mark)."""
-
-    bl_idname = "VIEW3D_GT_offset_exterior"
-    __slots__ = ("custom_shape",)
-    tris = _offset_baseline_tris(-0.24)
-
-
-class GizmoOffsetCenter(TrisGizmoMixin, bpy.types.Gizmo):
-    """Wall offset baseline indicator — reference axis at the centreline (middle mark)."""
-
-    bl_idname = "VIEW3D_GT_offset_center"
-    __slots__ = ("custom_shape",)
-    tris = _offset_baseline_tris(0.0)
-
-
-class GizmoOffsetInterior(TrisGizmoMixin, bpy.types.Gizmo):
-    """Wall offset baseline indicator — reference axis at the interior face (right mark)."""
-
-    bl_idname = "VIEW3D_GT_offset_interior"
-    __slots__ = ("custom_shape",)
-    tris = _offset_baseline_tris(0.24)
-
-
-class GizmoAddOpening(TrisGizmoMixin, bpy.types.Gizmo):
-    """A rectangular frame (square outline with a hole in the middle) — conveys adding an
-    opening (window/door/void) to a wall."""
-
-    bl_idname = "VIEW3D_GT_add_opening"
-
-    __slots__ = ("custom_shape",)
-
-    # Outer 0.40 × 0.40 square with a 0.25 × 0.25 inner hole, drawn as four bars
-    # forming a frame, plus a small "+" in the inner hole to convey "add".
-    tris = (
-        *rect_tris(-0.20, 0.125, 0.20, 0.20),  # Top bar
-        *rect_tris(-0.20, -0.20, 0.20, -0.125),  # Bottom bar
-        *rect_tris(-0.20, -0.125, -0.125, 0.125),  # Left bar
-        *rect_tris(0.125, -0.125, 0.20, 0.125),  # Right bar
-        *rect_tris(-0.07, -0.015, 0.07, 0.015),  # "+" horizontal stroke
-        *rect_tris(-0.015, -0.07, 0.015, 0.07),  # "+" vertical stroke
-    )
-
-
 def _generate_circular_arrow_tris() -> tuple[tuple[float, float, float], ...]:
     """Generate circular arrow geometry covering ~300 degrees."""
     triangles = []
@@ -3658,7 +3421,6 @@ class GizmoDimension(GizmoMovable):
         "_original_value",  # Original property value before interaction
         "_click_offset",  # Offset from dimension tip to click position (for snap correction)
         "show_extension_lines",  # Whether to show extension lines at dimension endpoints
-        "text_formatter",  # Optional (props, value) -> str to override the default dimension label
     )
 
     ARROW_SIZE = 10
@@ -3717,16 +3479,6 @@ class GizmoDimension(GizmoMovable):
         start_world = self.matrix_basis.translation.copy()
         end_world = start_world + axis_world * self._dimension_length
 
-        display_value = getattr(self, "_display_value", self._dimension_length)
-        text_formatter = getattr(self, "text_formatter", None)
-        gizmo_group = getattr(self, "gizmo_group", None)
-        display_text: str | None = None
-        if text_formatter is not None and gizmo_group is not None:
-            obj = bpy.context.active_object
-            props = gizmo_group.get_props(obj) if obj is not None else None
-            if props is not None:
-                display_text = text_formatter(props, display_value)
-
         DimensionRenderer.get_instance().draw(
             context=context,
             start_world=start_world,
@@ -3744,8 +3496,7 @@ class GizmoDimension(GizmoMovable):
             text_offset_sign=getattr(self, "text_offset_sign", 1),
             text_alignment=getattr(self, "text_alignment", TextAlignment.CENTER),
             prop_name=getattr(self, "prop_name", None),
-            display_value=display_value,
-            display_text=display_text,
+            display_value=getattr(self, "_display_value", self._dimension_length),
         )
 
     def _calculate_screen_endpoints(self, context: bpy.types.Context) -> tuple[Vector, Vector, Vector, float] | None:
@@ -3864,11 +3615,6 @@ class GizmoDimension(GizmoMovable):
         self._display_value = max(-10000.0, min(length, 10000.0))
         # Clamp to valid range (0 to 10000 meters is reasonable for BIM) for drawing
         self._dimension_length = max(0.0, min(abs(length), 10000.0))
-        # Smaller dimensions win selection when hit regions overlap: a long gizmo's
-        # hit box fully contains a nested short one's, so without a bias the long
-        # one wins and the short one is unreachable. The long one stays clickable
-        # at its exposed ends regardless of bias.
-        self.select_bias = -self._dimension_length
 
     def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set:
         """Initialize dimension gizmo interaction with click-position tracking.
@@ -4167,59 +3913,6 @@ class CycleTypeMixin:
         return {"FINISHED"}
 
 
-class BillboardingGizmoGroupMixin:
-    """Mixin for standalone ``bpy.types.GizmoGroup`` classes whose icons must billboard
-    (face the camera) and re-position every frame.
-
-    Blender calls ``GizmoGroup.refresh()`` only on state-change events (selection,
-    property change, dependency update) — not on camera rotation. A gizmo group that
-    only sets ``matrix_basis`` in ``refresh()`` will appear to "freeze" its rotation
-    at the camera angle in effect when it was last refreshed; orbiting the camera
-    leaves the icon facing the wrong way.
-
-    ``draw_prepare()`` *is* called every redraw, so the fix is to run the same
-    positioning code from both events. Rather than overriding ``refresh()`` and
-    ``draw_prepare()`` in every gizmo group that has this need, subclass this mixin
-    and implement a single ``position_gizmos(context)`` method.
-
-    Usage::
-
-        class MyGizmoGroup(bpy.types.GizmoGroup, BillboardingGizmoGroupMixin):
-            bl_idname = "..."
-            ...
-            def setup(self, context):
-                ...
-            def position_gizmos(self, context):
-                # set matrix_basis on every gizmo here, using get_billboard_rotation
-                # for any icon that should face the camera.
-                ...
-
-    ``position_gizmos`` should be idempotent — it's called twice when a state change
-    coincides with a redraw (once via ``refresh``, once via ``draw_prepare``)."""
-
-    def refresh(self, context: bpy.types.Context) -> None:
-        self.position_gizmos(context)
-
-    def draw_prepare(self, context: bpy.types.Context) -> None:
-        self.position_gizmos(context)
-
-    def setup_icon_gizmo(
-        self,
-        gizmo_type: str,
-        color: tuple[float, float, float],
-        highlight_color: tuple[float, float, float],
-        operator: str,
-        alpha: float = 0.8,
-    ) -> bpy.types.Gizmo:
-        """Convenience wrapper over `setup_icon_gizmo` for subclasses."""
-        return setup_icon_gizmo(self, gizmo_type, color, highlight_color, operator, alpha)
-
-    def position_gizmos(self, context: bpy.types.Context) -> None:
-        raise NotImplementedError(
-            f"{type(self).__name__} must implement position_gizmos(context) when using BillboardingGizmoGroupMixin."
-        )
-
-
 class BaseParametricGizmoGroup:
     """Base mixin for parametric element gizmo groups (doors, windows, stairs, etc.).
 
@@ -4436,32 +4129,6 @@ class BaseParametricGizmoGroup:
             return width + (self.GIZMO_OFFSET if use_offset else 0)
         return -self.GIZMO_OFFSET if use_offset else 0
 
-    @staticmethod
-    def get_camera_facing_outer_y(
-        viewing_from_negative_y: bool,
-        near_y: float,
-        far_y: float,
-        gizmo_offset: float = 0.0,
-    ) -> float:
-        """Y coordinate just outside the camera-facing face of an element.
-
-        Generalises `get_y_position_for_view` for elements whose near face
-        isn't at the local origin. ``near_y`` is the local-Y of the -Y face;
-        ``far_y`` is the local-Y of the +Y face. Returns the Y just *outside* the
-        face the camera is currently looking at, pushed by ``gizmo_offset`` (use
-        ``cls.GIZMO_OFFSET`` for the standard handle gap).
-
-        Suits walls (``near_y = props.offset``, ``far_y = props.offset + props.thickness``)
-        and any other element whose section sits inside a non-zero Y band. Stair /
-        door / window can also call this once their callers pass explicit near/far
-        instead of the implicit ``width_attr`` pattern, eliminating
-        ``get_y_position_for_view``, ``get_lining_y_position_for_view`` etc. as
-        wrappers around the same shape — but they're left intact for now to avoid
-        churning code paths that already work."""
-        if viewing_from_negative_y:
-            return near_y - gizmo_offset
-        return far_y + gizmo_offset
-
     def get_icon_y_for_view(self, props, viewing_from_negative_y: bool) -> float:
         """Get Y position for editing icons based on view direction.
 
@@ -4557,13 +4224,13 @@ class BaseParametricGizmoGroup:
         """
         return 0.0
 
-    def _update_view_dependent_dimensions(self, context: bpy.types.Context, mw: Matrix, props) -> None:  # noqa: ARG002
+    def _update_view_dependent_dimensions(self, context: bpy.types.Context, mw: Matrix, props) -> None:
         """Update overall_width, overall_height, and lining_offset based on view direction.
 
         This base implementation handles the common pattern for door/window gizmos.
         Subclasses can override get_casing_offset() to customize behavior.
         """
-        viewing_from_negative_y, viewing_from_negative_x = self._frame_view_dir
+        viewing_from_negative_y, viewing_from_negative_x = self.get_local_view_direction(context, mw)
         y_pos = self.get_lining_y_position_for_view(props, viewing_from_negative_y)
 
         self.set_dimension_gizmo_position("overall_width", mw, Vector((0, y_pos, -self.GIZMO_OFFSET)), (1, 0, 0))
@@ -4642,15 +4309,21 @@ class BaseParametricGizmoGroup:
 
     @classmethod
     def poll(cls, context) -> bool:
+        prefs = tool.Blender.get_addon_preferences()
+        if not prefs.gizmos.draw_gizmos_in_3d_viewport:
+            return False
+
         obj = tool.Blender.get_active_object(is_selected=True)
-        if obj is None:
-            return False
-        if not tool.Blender.get_addon_preferences().gizmos.draw_gizmos_in_3d_viewport:
+        if not obj:
             return False
+
         if len(tool.Blender.get_selected_objects()) != 1:
             return False
+
         element = tool.Ifc.get_entity(obj)
-        return bool(element) and cls.is_element_type(element)
+        if not element or not cls.is_element_type(element):
+            return False
+        return True
 
     def setup(self, context: bpy.types.Context) -> None:
         """Template method for gizmo setup.
@@ -4670,19 +4343,6 @@ class BaseParametricGizmoGroup:
         """
         pass
 
-    # Frame-scoped caches primed at the top of ``refresh()`` and ``draw_prepare()``.
-    # Every per-frame helper — preferences access, view-direction lookup, billboard
-    # rotation — reads these instead of re-deriving the same values, since each
-    # gizmo group ends up needing them 2–5× per frame across its position helpers.
-    _frame_prefs: Any = None
-    _frame_view_dir: tuple[bool, bool] | None = None
-    _frame_billboard_rot: "Matrix | None" = None
-
-    def _prime_frame_caches(self, context: bpy.types.Context, mw: "Matrix") -> None:
-        self._frame_prefs = tool.Blender.get_addon_preferences()
-        self._frame_view_dir = self.get_local_view_direction(context, mw)
-        self._frame_billboard_rot = get_billboard_rotation(context)
-
     def refresh(self, context: bpy.types.Context) -> None:
         """Template method for gizmo refresh.
 
@@ -4697,7 +4357,6 @@ class BaseParametricGizmoGroup:
 
         props = self.get_props(obj)
         mw = obj.matrix_world
-        self._prime_frame_caches(context, mw)
         self.update_editing_gizmos(context, mw, props)
         self.update_dimension_gizmos(mw, props)
         self._refresh_element_specific(context, mw, props)
@@ -4705,10 +4364,8 @@ class BaseParametricGizmoGroup:
     def _refresh_element_specific(self, context: bpy.types.Context, mw: "Matrix", props) -> None:  # noqa: ARG002
         """Override for element-specific refresh logic.
 
-        Called from both refresh() (on state change) and draw_prepare() (per frame),
-        so any override must be idempotent and cheap. Use this to re-position or
-        re-billboard element-specific gizmos (door swing arcs, stair lock/+/- icons,
-        wall cursor icons, etc.).
+        Called after update_editing_gizmos and update_dimension_gizmos.
+        Examples: door swing gizmos, stair lock/tread/plus/minus gizmos.
         """
         pass
 
@@ -4728,11 +4385,10 @@ class BaseParametricGizmoGroup:
             return getattr(tool.Model, self.props_getter)(obj)
         raise NotImplementedError("Subclass must define props_getter or override get_props()")
 
-    def get_addon_prefs(self):
-        """Return the addon preferences struct. Inside ``refresh`` / ``draw_prepare``
-        the frame cache is hit; outside (e.g. ``setup``) we fall through to a fresh
-        lookup so callers don't have to know which call path they're on."""
-        return self._frame_prefs if self._frame_prefs is not None else tool.Blender.get_addon_preferences()
+    @staticmethod
+    def get_addon_prefs():
+        """Get addon preferences (cached accessor)."""
+        return tool.Blender.get_addon_preferences()
 
     def get_decoration_colors(self) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
         """Get default and highlight colors from preferences.
@@ -4851,8 +4507,8 @@ class BaseParametricGizmoGroup:
             scale: Gizmo scale factor (default 0.5)
         """
         if gz := self.get_gizmo_if_visible(gizmo_name):
-            world_pos = mw @ Vector((x, y, z))
-            gz.matrix_basis = billboarded_at(world_pos, billboard_rot, scale)
+            local_transform = Matrix.Translation(Vector((x, y, z))) @ billboard_rot @ Matrix.Scale(scale, 4)
+            gz.matrix_basis = mw @ local_transform
 
     def set_dimension_gizmo_position(
         self,
@@ -4938,12 +4594,28 @@ class BaseParametricGizmoGroup:
     ) -> bpy.types.Gizmo:
         """Create and configure an icon gizmo with standard settings.
 
-        Thin wrapper over `setup_icon_gizmo` that defaults ``highlight_color``
-        to the addon-prefs selection color via ``get_decoration_colors``.
+        Reduces boilerplate in setup_editing_gizmos.
+
+        Args:
+            gizmo_type: Blender gizmo type identifier (e.g., "VIEW3D_GT_pen")
+            color: RGB color tuple
+            operator: Operator to invoke on click
+            highlight_color: Optional highlight color (defaults to prefs selection color)
+            alpha: Gizmo alpha (default 0.8)
+
+        Returns:
+            Configured gizmo instance.
         """
         if highlight_color is None:
             _, highlight_color = self.get_decoration_colors()
-        return setup_icon_gizmo(self, gizmo_type, color, highlight_color, operator, alpha)
+
+        gizmo = self.gizmos.new(gizmo_type)
+        gizmo.use_draw_scale = False
+        gizmo.color = color
+        gizmo.color_highlight = highlight_color
+        gizmo.alpha = alpha
+        gizmo.target_set_operator(operator)
+        return gizmo
 
     def setup_editing_gizmos(self, context: bpy.types.Context) -> None:
         default_color, highlight_color = self.get_decoration_colors()
@@ -5024,7 +4696,6 @@ class BaseParametricGizmoGroup:
             gizmo.delta_scale = config.delta_scale
             gizmo.prop_name = config.prop_name  # Auto-derived in __post_init__
             gizmo.gizmo_group = self
-            gizmo.text_formatter = config.text_formatter
             gizmo.color = self.get_color_from_name(config.color)
             gizmo.color_highlight = highlight_color
             gizmo.alpha = 1.0
@@ -5052,9 +4723,10 @@ class BaseParametricGizmoGroup:
 
             gizmo.hide = False
 
-            # Priority: config.matrix_position > get_dimension_matrix_* method > Identity.
+            # Priority: config.matrix_position > get_dimension_matrix_* method > Identity
             if config.matrix_position:
-                base_matrix = self.compose_gizmo_matrix(config.matrix_position(props), config.axis)
+                position = config.matrix_position(props)
+                base_matrix = self.compose_gizmo_matrix(position, config.axis)
             else:
                 matrix_method = getattr(self, f"get_dimension_matrix_{config.attr_name}", None)
                 base_matrix = matrix_method(props) if matrix_method else Matrix.Identity(4)
@@ -5086,7 +4758,7 @@ class BaseParametricGizmoGroup:
         """
         return (0.0, 0.0)
 
-    def get_icon_y_offset(self, context: bpy.types.Context, mw: Matrix) -> float:  # noqa: ARG002
+    def get_icon_y_offset(self, context: bpy.types.Context, mw: Matrix) -> float:
         """Get Y offset for icons based on view direction.
 
         Uses get_icon_y_extent() to determine how far to offset icons based on
@@ -5102,7 +4774,8 @@ class BaseParametricGizmoGroup:
         props = self.get_props(obj)
         positive_extent, negative_extent = self.get_icon_y_extent(props)
 
-        if self._frame_view_dir[0]:
+        viewing_from_negative_y, _ = self.get_local_view_direction(context, mw)
+        if viewing_from_negative_y:
             return -negative_extent
         return positive_extent
 
@@ -5110,40 +4783,34 @@ class BaseParametricGizmoGroup:
         """Update editing icon gizmo positions to billboard toward camera."""
         icon_z = self.get_element_height(props) + self.ICON_Z_OFFSET
         icon_y = self.get_icon_y_offset(context, mw)
-        billboard_rot = self._frame_billboard_rot
-        # set_icon_gizmo_position no-ops on hidden gizmos (via get_gizmo_if_visible),
-        # so the hide flag must be set first; that gates whether the matrix is written.
+        billboard_rot = get_billboard_rotation(context)
+
+        # This ensures icons face camera regardless of object rotation
+        local_pos_validate = Vector((self.ICON_VALIDATE_X, icon_y, icon_z))
+        world_pos_validate = mw @ local_pos_validate
+
+        icon_matrix_base = Matrix.Translation(world_pos_validate) @ billboard_rot @ Matrix.Scale(0.5, 4)
+
         if props.is_editing:
             self.pen_gizmo.hide = True
             self.validate_gizmo.hide = self.is_gizmo_hidden_by_modal(self.validate_gizmo)
-            self.set_icon_gizmo_position(
-                "validate_gizmo", mw=mw, x=self.ICON_VALIDATE_X, y=icon_y, z=icon_z, billboard_rot=billboard_rot
-            )
+            self.validate_gizmo.matrix_basis = icon_matrix_base
+
             self.cancel_gizmo.hide = self.is_gizmo_hidden_by_modal(self.cancel_gizmo)
-            self.set_icon_gizmo_position(
-                "cancel_gizmo",
-                mw=mw,
-                x=self.ICON_VALIDATE_X + self.ICON_CANCEL_X,
-                y=icon_y,
-                z=icon_z,
-                billboard_rot=billboard_rot,
-            )
+            local_pos_cancel = Vector((self.ICON_VALIDATE_X + self.ICON_CANCEL_X, icon_y, icon_z))
+            world_pos_cancel = mw @ local_pos_cancel
+            self.cancel_gizmo.matrix_basis = Matrix.Translation(world_pos_cancel) @ billboard_rot @ Matrix.Scale(0.5, 4)
+
             if self.cycle_type_operator:
                 self.cycle_gizmo.hide = self.is_gizmo_hidden_by_modal(self.cycle_gizmo)
-                self.set_icon_gizmo_position(
-                    "cycle_gizmo",
-                    mw=mw,
-                    x=self.ICON_VALIDATE_X + self.ICON_CYCLE_X,
-                    y=icon_y,
-                    z=icon_z,
-                    billboard_rot=billboard_rot,
-                    scale=0.30,
+                local_pos_cycle = Vector((self.ICON_VALIDATE_X + self.ICON_CYCLE_X, icon_y, icon_z))
+                world_pos_cycle = mw @ local_pos_cycle
+                self.cycle_gizmo.matrix_basis = (
+                    Matrix.Translation(world_pos_cycle) @ billboard_rot @ Matrix.Scale(0.30, 4)
                 )
         else:
             self.pen_gizmo.hide = self.is_gizmo_hidden_by_modal(self.pen_gizmo)
-            self.set_icon_gizmo_position(
-                "pen_gizmo", mw=mw, x=self.ICON_VALIDATE_X, y=icon_y, z=icon_z, billboard_rot=billboard_rot
-            )
+            self.pen_gizmo.matrix_basis = icon_matrix_base
             self.validate_gizmo.hide = True
             self.cancel_gizmo.hide = True
             if self.cycle_type_operator:
@@ -5152,26 +4819,16 @@ class BaseParametricGizmoGroup:
     def draw_prepare(self, context: bpy.types.Context) -> None:
         """Called before drawing - updates gizmos to face camera.
 
-        This method updates editing gizmos, dimension gizmos, and element-specific
-        gizmos. Subclasses can override _update_dimension_gizmo_positions() to
-        customize dimension gizmo positioning, and _refresh_element_specific() to
-        re-billboard element-specific gizmos per frame.
+        This method updates editing gizmos and dimension gizmos.
+        Subclasses can override _update_dimension_gizmo_positions() to customize
+        dimension gizmo positioning based on view direction.
         """
         obj = context.active_object
         if not obj:
             return
         props = self.get_props(obj)
         mw = obj.matrix_world
-        self._prime_frame_caches(context, mw)
         self.update_editing_gizmos(context, mw, props)
-        # `update_dimension_gizmos` flips the dimension gizmos' `hide` flag
-        # based on `props.is_editing` + per-config visibility conditions.
-        # `refresh()` already calls it, but `refresh()` only fires on depsgraph
-        # events — a `finish_editing_*` operator that toggles `is_editing` to
-        # False without mutating IFC (e.g. wall no-op commit, cancel) does not
-        # trigger a depsgraph update, so without this call the dimension gizmos
-        # would stay visible until the next user input.
-        self.update_dimension_gizmos(mw, props)
 
         self._update_dimension_gizmo_positions(context, mw, props)
 
@@ -5179,8 +4836,6 @@ class BaseParametricGizmoGroup:
         for _, gizmo in self.iter_visible_dimension_gizmos():
             gizmo.draw_prepare(context)
 
-        self._refresh_element_specific(context, mw, props)
-
     def _update_dimension_gizmo_positions(
         self, context: bpy.types.Context, mw: "Matrix", props  # noqa: ARG002
     ) -> None:

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

@@ -313,7 +313,7 @@ def format_distance(
             if not feet and not add_inches:
                 tx_dist += str(feet) + "'"
 
-            if not feet and add_inches and unit_length != "INCHES":
+            if not feet and add_inches:
                 if value < 0:
                     tx_dist += "-0' - "
                 else:

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

@@ -790,7 +790,7 @@ def lock_error_message(name: str) -> str:
 
 
 def calc_delete_is_batch(ifc_file: ifcopenshell.file, context: bpy.types.Context) -> bool:
-    total_elements = len(tool.Ifc.get().wrapped_data.entity_names())
+    total_elements = len(tool.Ifc.get().entity_names())
     total_polygons = sum([len(o.data.polygons) for o in context.selected_objects if o.type == "MESH"])
     # These numbers are a bit arbitrary, but basically batching is only
     # really necessary on large models and large geometry removals.
@@ -1183,7 +1183,7 @@ class OverrideDuplicateMove(bpy.types.Operator):
         operator: bpy.types.Operator, context: bpy.types.Context, linked: bool = False
     ) -> set["rna_enums.OperatorReturnItems"]:
         # Deep magick from the dawn of time
-        if tool.Ifc.get() and tool.Model.has_selected_ifc_objects(include_active=False):
+        if tool.Ifc.get():
             IfcStore.execute_ifc_operator(operator, context)
             return {"FINISHED"}
 
@@ -1287,11 +1287,6 @@ class OverrideDuplicateMove(bpy.types.Operator):
                             if part_obj:
                                 all_objects_to_select.add(part_obj)
 
-        # Non-IFC duplicates aren't tracked in old_to_new but are left selected by duplicate_ifc_objects
-        all_objects_to_select.update(
-            obj for obj in context.selected_objects if not tool.Ifc.get_entity(obj)
-        )
-
         # Deselect everything first
         bpy.ops.object.select_all(action="DESELECT")
 

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

@@ -630,7 +630,7 @@ class EditAssignedMaterial(bpy.types.Operator, tool.Ifc.Operator):
                     slab.DumbSlabPlaner().regenerate_from_layer_set(layer_set)
 
             if material_set_usage.is_a("IfcMaterialProfileSetUsage"):
-                if "CardinalPoint" in attributes and attributes["CardinalPoint"] is not None:
+                if "CardinalPoint" in attributes:
                     attributes["CardinalPoint"] = int(attributes["CardinalPoint"])
                 ifcopenshell.api.material.edit_profile_usage(
                     self.file,

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

@@ -15,15 +15,11 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 from typing import NamedTuple
 
 import bpy
 
-import bonsai.tool as tool
-
 from . import (
     array,
     covering,
@@ -74,33 +70,18 @@ classes = (
     workspace.BIM_MT_add_representation_item,
     wall.AddWallsFromSlab,
     wall.AlignWall,
-    wall.CancelEditingWall,
     wall.ChangeExtrusionDepth,
     wall.ChangeExtrusionXAngle,
     wall.ChangeLayerLength,
-    wall.CycleWallOffset,
     wall.DrawPolylineWall,
-    wall.EnableEditingWall,
-    wall.ExtendWallHeightToCursor,
     wall.ExtendWallsToUnderside,
-    wall.RegenerateWallToUnderside,
     wall.ExtendWallsToWall,
     wall.ExtendWallsToPolylinePoint,
-    wall.ExtendWallToCursor,
-    wall.FinishEditingWall,
     wall.FlipWall,
-    wall.GizmoWallAddOpening,
-    wall.GizmoWallEdition,
-    wall.GizmoWallExtendVertically,
-    wall.GizmoWallJoinIntersection,
-    wall.JoinWallsIntersection,
     wall.MergeWall,
     wall.OffsetWalls,
     wall.RecalculateWall,
-    wall.RotateWall90,
     wall.SplitWall,
-    wall.SplitWallAtCursor,
-    wall.ToggleWallOpenings,
     wall.UnjoinWalls,
     opening.AddBoolean,
     opening.CloneOpening,
@@ -159,12 +140,10 @@ classes = (
     prop.BIMDoorProperties,
     prop.BIMRailingProperties,
     prop.BIMRoofProperties,
-    prop.BIMWallProperties,
     prop.BIMPolylineProperties,
     prop.BIMExternalParametricGeometryProperties,
     ui.BIM_PT_array,
     ui.BIM_PT_stair,
-    ui.BIM_PT_wall,
     ui.BIM_PT_sverchok,
     ui.BIM_PT_window,
     ui.BIM_PT_door,
@@ -285,10 +264,12 @@ def register():
     bpy.types.Scene.BIMModelProperties = bpy.props.PointerProperty(type=prop.BIMModelProperties)
     bpy.types.Scene.BIMPolylineProperties = bpy.props.PointerProperty(type=prop.BIMPolylineProperties)
     bpy.types.Object.BIMArrayProperties = bpy.props.PointerProperty(type=prop.BIMArrayProperties)
+    bpy.types.Object.BIMStairProperties = bpy.props.PointerProperty(type=prop.BIMStairProperties)
     bpy.types.Object.BIMSverchokProperties = bpy.props.PointerProperty(type=prop.BIMSverchokProperties)
-    # Per-parametric-type ``BIM<Name>Properties`` PointerProperties — driven by
-    # ``tool.Parametric.EDIT_TYPES``; adding a registry entry is the single touchpoint.
-    tool.Parametric.register_object_properties(prop)
+    bpy.types.Object.BIMWindowProperties = bpy.props.PointerProperty(type=prop.BIMWindowProperties)
+    bpy.types.Object.BIMDoorProperties = bpy.props.PointerProperty(type=prop.BIMDoorProperties)
+    bpy.types.Object.BIMRailingProperties = bpy.props.PointerProperty(type=prop.BIMRailingProperties)
+    bpy.types.Object.BIMRoofProperties = bpy.props.PointerProperty(type=prop.BIMRoofProperties)
     bpy.types.Object.BIMExternalParametricGeometryProperties = bpy.props.PointerProperty(
         type=prop.BIMExternalParametricGeometryProperties
     )
@@ -307,8 +288,12 @@ def unregister():
     del bpy.types.Scene.BIMModelProperties
     del bpy.types.Scene.BIMPolylineProperties
     del bpy.types.Object.BIMArrayProperties
+    del bpy.types.Object.BIMStairProperties
     del bpy.types.Object.BIMSverchokProperties
-    tool.Parametric.unregister_object_properties()
+    del bpy.types.Object.BIMWindowProperties
+    del bpy.types.Object.BIMDoorProperties
+    del bpy.types.Object.BIMRailingProperties
+    del bpy.types.Object.BIMRoofProperties
     del bpy.types.Object.BIMExternalParametricGeometryProperties
 
     bpy.app.handlers.load_post.remove(handler.load_post)

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

@@ -38,7 +38,6 @@ import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
 from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
 from bonsai.bim.module.model.window import create_bm_box, create_bm_window
-from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin
 
 if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import BIMDoorProperties
@@ -567,58 +566,103 @@ class AddDoor(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class _DoorEditMixin(FeatureModifierEditMixin):
-    """Type-specific hooks for door parametric-edit operators. Multi-object —
-    iterates ``tool.Blender.get_selected_objects()`` so a finish/cancel applies
-    to every selected door at once."""
-
-    pset_name = "BBIM_Door"
-
-    @classmethod
-    def _iter_targets(cls, context: bpy.types.Context) -> list[bpy.types.Object]:
-        return tool.Blender.get_selected_objects()
-
-    @classmethod
-    def _is_element_type(cls, element):
-        return tool.Blender.Modifier.is_door(element)
-
-    @classmethod
-    def _get_props(cls, obj: bpy.types.Object):
-        return tool.Model.get_door_props(obj)
-
-    @classmethod
-    def _update_modifier_representation(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        update_door_modifier_representation(obj)
-
-
-class CancelEditingDoor(_DoorEditMixin, 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 _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cancel_targets(context)
+    def cancel_editing_door_on_object(self, obj: bpy.types.Object) -> None:
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        if not tool.Blender.Modifier.is_door(element):
+            return
+        props = tool.Model.get_door_props(obj)
+        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Door", "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+
+        # restore previous settings since editing was canceled
+        props.set_props_kwargs_from_ifc_data(data)
+
+        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+        core.switch_representation(
+            tool.Ifc,
+            tool.Geometry,
+            obj=obj,
+            representation=body,
+        )
+
+        props.is_editing = False
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:  # noqa: ARG002
+        for obj in tool.Blender.get_selected_objects():
+            self.cancel_editing_door_on_object(obj)
+        return {"FINISHED"}
 
 
-class FinishEditingDoor(_DoorEditMixin, 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 _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._finish_targets(context)
+    def finish_editing_door_on_object(self, obj: bpy.types.Object) -> None:
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        if not tool.Blender.Modifier.is_door(element):
+            return
+        props = tool.Model.get_door_props(obj)
+
+        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)
+
+        door_data["lining_properties"] = lining_props
+        door_data["panel_properties"] = panel_props
+
+        props.is_editing = False
+
+        update_door_modifier_representation(obj)
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type:
+            tool.Model.mark_thumbnail_for_update(element_type)
+
+        pset = tool.Pset.get_element_pset(element, "BBIM_Door")
+        door_data = tool.Ifc.get().createIfcText(json.dumps(door_data, default=list))
+        ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": door_data})
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:  # noqa: ARG002
+        for obj in tool.Blender.get_selected_objects():
+            self.finish_editing_door_on_object(obj)
+        return {"FINISHED"}
 
 
-class EnableEditingDoor(_DoorEditMixin, 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 _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._enable_targets(context)
+    def edit_door_on_obj(self, obj: bpy.types.Object) -> None:
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        if not tool.Blender.Modifier.is_door(element):
+            return
+        props = tool.Model.get_door_props(obj)
+        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Door", "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+        data.update(tool.Model.get_constituents_props_data(element))
+
+        # required since we could load pset from .ifc and BIMDoorProperties won't be set
+        props.set_props_kwargs_from_ifc_data(data)
+        props.is_editing = True
+
+    def _execute(self, context: bpy.types.Context) -> set[str]:  # noqa: ARG002
+        for obj in tool.Blender.get_selected_objects():
+            self.edit_door_on_obj(obj)
+        return {"FINISHED"}
 
 
 class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
@@ -895,7 +939,7 @@ class GizmoDoorEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
 
     def update_swing_gizmos(self, mw: Matrix, props: "BIMDoorProperties") -> None:
         """Update swing gizmo position and color based on editing state."""
-        prefs = self.get_addon_prefs()
+        prefs = tool.Blender.get_addon_preferences()
         door_gizmo_prefs = prefs.gizmos.door
 
         door_type_visible = self.update_gizmo_visibility(

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

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import math
 from collections.abc import Callable
@@ -195,32 +193,6 @@ def update_stair(self: "BIMStairProperties", context: bpy.types.Context) -> None
         _get_updater("stair", "regenerate_stair_mesh")(obj)
 
 
-def update_wall(self: "BIMWallProperties", context: bpy.types.Context) -> None:
-    """Regenerate wall mesh preview when property changes. Does NOT touch IFC."""
-    obj = context.active_object
-    if obj and self.is_editing:
-        _get_updater("wall", "regenerate_wall_mesh_from_props")(obj)
-
-
-def update_wall_offset_baseline(self: "BIMWallProperties", context: bpy.types.Context) -> None:
-    """Recompute the preview-only ``offset`` when the draft baseline cycles. Does not touch IFC.
-
-    ``offset`` itself has no ``update`` callback on purpose — adding one would make
-    every baseline cycle rebuild the bmesh twice (once via offset's callback, once
-    explicitly below)."""
-    obj = context.active_object
-    if not (obj and self.is_editing):
-        return
-    t = self.thickness
-    if self.desired_offset_baseline == "CENTER":
-        self.offset = -t / 2
-    elif self.desired_offset_baseline == "INTERIOR":
-        self.offset = -t
-    else:  # EXTERIOR
-        self.offset = 0.0
-    _get_updater("wall", "regenerate_wall_mesh_from_props")(obj)
-
-
 def update_railing(self: "BIMRailingProperties", context: bpy.types.Context) -> None:
     """Regenerate railing mesh when property changes."""
     if self.is_editing:
@@ -1659,118 +1631,6 @@ class BIMRoofProperties(PropertyGroup):
             setattr(target_props, prop_name, prop_value)
 
 
-class BIMWallProperties(PropertyGroup):
-    """Transient draft state for parametric wall gizmo editing.
-
-    Populated from IFC on `bim.enable_editing_wall`, mutated by gizmo drags during edit
-    (preview only — no IFC writes), and either committed by `bim.finish_editing_wall`
-    or discarded by `bim.cancel_editing_wall`.
-
-    The `snap_*` fields are the values captured on enable; `finish_editing_wall` compares
-    current vs snap to skip unchanged params and guarantee a no-op session leaves the
-    IFC file byte-identical.
-    """
-
-    is_editing: bpy.props.BoolProperty(
-        default=False,
-        description="True while wall parametric edit mode is active.",
-    )
-    mesh_dirty: bpy.props.BoolProperty(
-        default=False,
-        options={"HIDDEN", "SKIP_SAVE"},
-        description=(
-            "True while the visible mesh is the preview box; cleared once the real "
-            "IFC-derived geometry is restored (on commit or cancel)."
-        ),
-    )
-    length: bpy.props.FloatProperty(
-        name="Length",
-        default=1.0,
-        min=0.01,
-        subtype="DISTANCE",
-        update=update_wall,
-        description="Wall length along its reference axis (preview value; committed on finish).",
-    )
-    height: bpy.props.FloatProperty(
-        name="Height",
-        default=3.0,
-        min=0.01,
-        subtype="DISTANCE",
-        update=update_wall,
-        description="Wall vertical height (preview value; committed on finish).",
-    )
-    x_angle: bpy.props.FloatProperty(
-        name="Slope (X Angle)",
-        default=0.0,
-        soft_min=-math.pi / 3,
-        soft_max=math.pi / 3,
-        subtype="ANGLE",
-        update=update_wall,
-        description="Slope angle: tilt of the wall's top face along +Y (preview value; committed on finish).",
-    )
-    thickness: bpy.props.FloatProperty(
-        name="Thickness",
-        default=0.2,
-        min=0.001,
-        subtype="DISTANCE",
-        description="Wall thickness captured from IFC at edit-enable; not gizmo-bound.",
-    )
-    offset: bpy.props.FloatProperty(
-        name="Offset",
-        default=0.0,
-        subtype="DISTANCE",
-        description="Layer-set offset captured from IFC at edit-enable; driven by desired_offset_baseline.",
-    )
-    desired_offset_baseline: bpy.props.EnumProperty(
-        items=[
-            ("EXTERIOR", "Exterior", "Reference axis at the exterior face"),
-            ("CENTER", "Center", "Reference axis at the wall centreline"),
-            ("INTERIOR", "Interior", "Reference axis at the interior face"),
-        ],
-        name="Desired Offset Baseline",
-        default="CENTER",
-        update=update_wall_offset_baseline,
-        description="Which face of the wall the reference axis aligns to (preview value; committed on finish).",
-    )
-    anchor_x: bpy.props.FloatProperty(
-        default=0.0,
-        subtype="DISTANCE",
-        description="Local-X of the wall's axis polyline start, so the preview box lands where the IFC mesh does.",
-    )
-
-    snap_length: bpy.props.FloatProperty(description="Snapshot of length at edit-enable; commit skips no-op writes.")
-    snap_height: bpy.props.FloatProperty(description="Snapshot of height at edit-enable; commit skips no-op writes.")
-    snap_thickness: bpy.props.FloatProperty(
-        description="Snapshot of thickness at edit-enable; commit skips no-op writes."
-    )
-    snap_offset: bpy.props.FloatProperty(description="Snapshot of offset at edit-enable; commit skips no-op writes.")
-    snap_x_angle: bpy.props.FloatProperty(
-        subtype="ANGLE",
-        description="Snapshot of x_angle at edit-enable; commit skips no-op writes.",
-    )
-    snap_offset_baseline: bpy.props.StringProperty(
-        default="",
-        description="Snapshot of desired_offset_baseline at edit-enable; commit skips no-op writes.",
-    )
-
-    if TYPE_CHECKING:
-        is_editing: bool
-        mesh_dirty: bool
-        length: float
-        height: float
-        x_angle: float
-        thickness: float
-        offset: float
-        desired_offset_baseline: Literal["EXTERIOR", "CENTER", "INTERIOR"]
-        anchor_x: float
-        snap_length: float
-        snap_height: float
-        snap_thickness: float
-        snap_offset: float
-        snap_x_angle: float
-        snap_offset_baseline: str
-
-
 class SnapMousePoint(PropertyGroup):
     x: bpy.props.FloatProperty(name="X")
     y: bpy.props.FloatProperty(name="Y")

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

@@ -34,7 +34,6 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.model.data import RailingData, refresh
 from bonsai.bim.module.model.decorator import ProfileDecorator
-from bonsai.bim.parametric_lifecycle import PathPreservingEditMixin
 
 # reference:
 # https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcRailing.htm
@@ -407,65 +406,66 @@ class CopyRailingParameters(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class _RailingEditMixin(PathPreservingEditMixin):
-    """Type-specific hooks for railing parametric-edit operators. Single-object
-    (active_object). ``path_data`` is preserved through the edit; the separate
-    ``Enable/Finish/CancelEditingRailingPath`` operators handle path editing."""
-
-    pset_name = "BBIM_Railing"
-
-    @classmethod
-    def _is_element_type(cls, element):
-        return tool.Blender.Modifier.is_railing(element)
-
-    @classmethod
-    def _get_props(cls, obj: bpy.types.Object):
-        return tool.Model.get_railing_props(obj)
-
-    @classmethod
-    def _post_load_data(cls, data: dict) -> dict:
-        # BIMRailingProperties.path_data is a StringProperty holding JSON.
-        data["path_data"] = json.dumps(data["path_data"])
-        return data
-
-    @classmethod
-    def _update_pset(cls, element, data: dict) -> None:
-        update_bbim_railing_pset(element, data)
-
-    @classmethod
-    def _update_modifier_ifc_data(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        update_railing_modifier_ifc_data(context)
-
-    @classmethod
-    def _update_modifier_bmesh(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        update_railing_modifier_bmesh(context)
-
-
-class EnableEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class EnableEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.enable_editing_railing"
     bl_label = "Enable Editing Railing"
-    bl_options = {"REGISTER", "UNDO"}
+    bl_options = {"REGISTER"}
 
     def _execute(self, context):
-        return self._enable_targets(context)
+        obj = context.active_object
+        assert obj
+        props = tool.Model.get_railing_props(obj)
+        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Railing")["data_dict"]
+        data["path_data"] = json.dumps(data["path_data"])
+
+        # required since we could load pset from .ifc and BIMRailingProperties won't be set
+        props.set_props_kwargs_from_ifc_data(data)
+
+        props.is_editing = True
+        return {"FINISHED"}
 
 
-class CancelEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class CancelEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.cancel_editing_railing"
     bl_label = "Cancel Editing Railing"
-    bl_options = {"REGISTER", "UNDO"}
+    bl_options = {"REGISTER"}
 
     def _execute(self, context):
-        return self._cancel_targets(context)
+        obj = context.active_object
+        assert obj
+        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Railing")["data_dict"]
+        props = tool.Model.get_railing_props(obj)
+
+        # restore previous settings since editing was canceled
+        props.set_props_kwargs_from_ifc_data(data)
+        update_railing_modifier_bmesh(context)
+
+        props.is_editing = False
+        return {"FINISHED"}
 
 
-class FinishEditingRailing(_RailingEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class FinishEditingRailing(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.finish_editing_railing"
     bl_label = "Finish Editing Railing"
-    bl_options = {"REGISTER", "UNDO"}
+    bl_options = {"REGISTER"}
 
     def _execute(self, context):
-        return self._finish_targets(context)
+        obj = context.active_object
+        assert obj
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        props = tool.Model.get_railing_props(obj)
+
+        pset_data = tool.Model.get_modeling_bbim_pset_data(bpy.context.active_object, "BBIM_Railing")
+        path_data = pset_data["data_dict"]["path_data"]
+
+        railing_data = props.get_general_kwargs(convert_to_project_units=True)
+        railing_data["path_data"] = path_data
+        props.is_editing = False
+
+        update_bbim_railing_pset(element, railing_data)
+        update_railing_modifier_ifc_data(context)
+        return {"FINISHED"}
 
 
 class FlipRailingPathOrder(bpy.types.Operator, tool.Ifc.Operator):

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

@@ -34,7 +34,6 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.model.data import RoofData, refresh
 from bonsai.bim.module.model.decorator import ProfileDecorator
-from bonsai.bim.parametric_lifecycle import PathPreservingEditMixin
 
 # reference:
 # https://ifc43-docs.standards.buildingsmart.org/IFC/RELEASE/IFC4x3/HTML/lexical/IfcRoof.htm
@@ -609,59 +608,61 @@ class AddRoof(bpy.types.Operator, tool.Ifc.Operator):
         tool.Model.add_body_representation(obj)
 
 
-class _RoofEditMixin(PathPreservingEditMixin):
-    """Type-specific hooks for roof parametric-edit operators. Single-object
-    (active_object). ``path_data`` is preserved through the edit; the separate
-    ``Enable/Finish/CancelEditingRoofPath`` operators handle path editing."""
-
-    pset_name = "BBIM_Roof"
-
-    @classmethod
-    def _is_element_type(cls, element):
-        return tool.Blender.Modifier.is_roof(element)
-
-    @classmethod
-    def _get_props(cls, obj: bpy.types.Object):
-        return tool.Model.get_roof_props(obj)
-
-    @classmethod
-    def _update_pset(cls, element, data: dict) -> None:
-        update_bbim_roof_pset(element, data)
-
-    @classmethod
-    def _update_modifier_ifc_data(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        update_roof_modifier_ifc_data(context)
-
-    @classmethod
-    def _update_modifier_bmesh(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        update_roof_modifier_bmesh(obj)
-
-
-class EnableEditingRoof(_RoofEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class EnableEditingRoof(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.enable_editing_roof"
     bl_label = "Enable Editing Roof"
-    bl_options = {"REGISTER", "UNDO"}
+    bl_options = {"REGISTER"}
 
     def _execute(self, context):
-        return self._enable_targets(context)
+        obj = context.active_object
+        assert obj
+        props = tool.Model.get_roof_props(obj)
+        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Roof")["data_dict"]
+        # required since we could load pset from .ifc and BIMRoofProperties won't be set
+        props.set_props_kwargs_from_ifc_data(data)
+        props.is_editing = True
+        return {"FINISHED"}
 
 
-class CancelEditingRoof(_RoofEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class CancelEditingRoof(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.cancel_editing_roof"
     bl_label = "Cancel Editing Roof"
-    bl_options = {"REGISTER", "UNDO"}
+    bl_options = {"REGISTER"}
 
     def _execute(self, context):
-        return self._cancel_targets(context)
+        obj = context.active_object
+        assert obj
+        data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Roof")["data_dict"]
+        props = tool.Model.get_roof_props(obj)
+
+        # restore previous settings since editing was canceled
+        props.set_props_kwargs_from_ifc_data(data)
+        update_roof_modifier_bmesh(obj)
+
+        props.is_editing = False
+        return {"FINISHED"}
 
 
-class FinishEditingRoof(_RoofEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class FinishEditingRoof(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.finish_editing_roof"
     bl_label = "Finish Editing Roof"
-    bl_options = {"REGISTER", "UNDO"}
+    bl_options = {"REGISTER"}
 
     def _execute(self, context):
-        return self._finish_targets(context)
+        obj = context.active_object
+        element = tool.Ifc.get_entity(obj)
+        props = tool.Model.get_roof_props(obj)
+
+        pset_data = tool.Model.get_modeling_bbim_pset_data(obj, "BBIM_Roof")
+        path_data = pset_data["data_dict"]["path_data"]
+
+        roof_data = props.get_general_kwargs(convert_to_project_units=True)
+        roof_data["path_data"] = path_data
+        props.is_editing = False
+
+        update_bbim_roof_pset(element, roof_data)
+        update_roof_modifier_ifc_data(context)
+        return {"FINISHED"}
 
 
 class EnableEditingRoofPath(bpy.types.Operator, tool.Ifc.Operator):

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

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import json
 
@@ -264,6 +262,7 @@ class FinishEditingStair(bpy.types.Operator, tool.Ifc.Operator):
 
         # Use the special method that includes custom_tread_lock for IFC storage
         data = props.get_props_kwargs_for_ifc_export(convert_to_project_units=True)
+        props.is_editing = False
         regenerate_stair_mesh(obj)
         tool.Model.add_body_representation(obj)
 
@@ -273,7 +272,6 @@ class FinishEditingStair(bpy.types.Operator, tool.Ifc.Operator):
 
         # update IfcStairFlight properties
         update_ifc_stair_props(obj)
-        props.is_editing = False
         return {"FINISHED"}
 
 
@@ -610,23 +608,29 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
             "VIEW3D_GT_minus", self.COLOR_RED, "bim.adjust_stair_treads", increment=-1
         )
 
-    def _refresh_element_specific(
-        self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties"  # noqa: ARG002
-    ) -> None:
-        """Update stair-specific lock and tread count gizmos. Lock positioning is
-        handled per-frame in the dimension-positioning hook."""
-        self.update_lock_gizmo(props)
+    def _refresh_element_specific(self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties") -> None:
+        """Update stair-specific lock and tread count gizmos."""
+        billboard_rot = gizmo.get_billboard_rotation(context)
+        self.update_lock_gizmo(mw, props, billboard_rot)
         self.update_tread_lock_gizmo(props)
         self.update_tread_count_gizmos(props)
 
-    def update_lock_gizmo(self, props: "BIMStairProperties") -> None:
-        """Update lock gizmo color and visibility. Positioning is handled
-        per-frame by the dimension-positioning hook."""
+    def update_lock_gizmo(self, mw: Matrix, props: "BIMStairProperties", billboard_rot: Matrix) -> None:
+        """Update lock gizmo visibility, color, and position."""
         gizmo_prefs = self.get_gizmo_prefs()
         if not self.update_gizmo_visibility(self.lock_gizmo, props.is_editing, gizmo_prefs.lock):
-            return  # Hidden, skip color update
+            return  # Hidden, skip positioning
+
         self.lock_gizmo.color = self.COLOR_RED if props.total_length_lock else self.COLOR_GREEN
 
+        total_run = props.get_total_run()
+        local_transform = (
+            Matrix.Translation(Vector((total_run + self.ICON_Z_OFFSET, -self.GIZMO_OFFSET, -self.GIZMO_OFFSET)))
+            @ billboard_rot
+            @ Matrix.Scale(self.EDITING_ICON_SCALE, 4)
+        )
+        self.lock_gizmo.matrix_basis = mw @ local_transform
+
     def update_tread_lock_gizmo(self, props: "BIMStairProperties") -> None:
         """Update visibility of tread lock gizmo. Positioning is handled in _update_editing_icon_positions."""
         if not hasattr(self, "tread_lock_gizmo"):
@@ -646,11 +650,11 @@ class GizmoStairEdition(bpy.types.GizmoGroup, gizmo.BaseParametricGizmoGroup):
         )
 
     def _update_dimension_gizmo_positions(
-        self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties"  # noqa: ARG002
+        self, context: bpy.types.Context, mw: Matrix, props: "BIMStairProperties"
     ) -> None:
         """Update dimension gizmo positions based on camera view direction."""
-        viewing_from_negative_y, viewing_from_negative_x = self._frame_view_dir
-        billboard_rot = self._frame_billboard_rot
+        viewing_from_negative_y, viewing_from_negative_x = self.get_local_view_direction(context, mw)
+        billboard_rot = gizmo.get_billboard_rotation(context)
         total_run = props.get_total_run()
         riser_height = props.get_riser_height()
 

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

@@ -338,36 +338,6 @@ class BIM_PT_stair(bpy.types.Panel):
             row.operator("bim.add_stair", icon="ADD", text="")
 
 
-class BIM_PT_wall(bpy.types.Panel):
-    bl_label = "Wall"
-    bl_idname = "BIM_PT_wall"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_parent_id = "BIM_PT_tab_parametric_geometry"
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.active_object
-        if not obj:
-            return False
-        element = tool.Ifc.get_entity(obj)
-        return bool(element) and tool.Blender.Modifier.is_wall(element)
-
-    def draw(self, context):
-        obj = context.active_object
-        if obj is None:
-            return
-        props = tool.Model.get_wall_props(obj)
-        row = self.layout.row(align=True)
-        if props.is_editing:
-            row.operator("bim.finish_editing_wall", icon="CHECKMARK", text="Finish Editing")
-            row.operator("bim.cancel_editing_wall", icon="CANCEL", text="")
-        else:
-            row.operator("bim.enable_editing_wall", icon="GREASEPENCIL", text="Edit Wall")
-
-
 class BIM_PT_sverchok(bpy.types.Panel):
     bl_label = "Sverchok"
     bl_idname = "BIM_PT_sverchok"

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

@@ -39,7 +39,6 @@ import bonsai.core.root
 import bonsai.tool as tool
 from bonsai.bim.module.drawing import gizmos as gizmo
 from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
-from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin
 
 if TYPE_CHECKING:
     from bonsai.bim.module.model.prop import BIMWindowProperties
@@ -483,53 +482,90 @@ class AddWindow(bpy.types.Operator, tool.Ifc.Operator):
         return {"FINISHED"}
 
 
-class _WindowEditMixin(FeatureModifierEditMixin):
-    """Type-specific hooks for window parametric-edit operators. Single-object
-    by design (window edits target the active object only)."""
-
-    pset_name = "BBIM_Window"
-
-    @classmethod
-    def _is_element_type(cls, element):
-        return tool.Blender.Modifier.is_window(element)
-
-    @classmethod
-    def _get_props(cls, obj: bpy.types.Object):
-        return tool.Model.get_window_props(obj)
-
-    @classmethod
-    def _update_modifier_representation(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        update_window_modifier_representation(context)
-
-
-class CancelEditingWindow(_WindowEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class CancelEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.cancel_editing_window"
     bl_label = "Cancel Editing Window"
     bl_description = "Cancel editing and revert window parameters to their previous values"
-    bl_options = {"REGISTER", "UNDO"}
+    bl_options = {"REGISTER"}
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._cancel_targets(context)
+        obj = context.active_object
+        assert obj
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Window", "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+        props = tool.Model.get_window_props(obj)
+        props.set_props_kwargs_from_ifc_data(data)
+
+        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+        bonsai.core.geometry.switch_representation(
+            tool.Ifc,
+            tool.Geometry,
+            obj=obj,
+            representation=body,
+        )
+
+        props.is_editing = False
+        return {"FINISHED"}
 
 
-class FinishEditingWindow(_WindowEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class FinishEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.finish_editing_window"
     bl_label = "Finish Editing Window"
     bl_description = "Apply changes and finish editing window parameters"
-    bl_options = {"REGISTER", "UNDO"}
+    bl_options = {"REGISTER"}
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._finish_targets(context)
+        obj = context.active_object
+        assert obj
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        props = tool.Model.get_window_props(obj)
+
+        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)
+
+        window_data["lining_properties"] = lining_props
+        window_data["panel_properties"] = panel_props
+
+        props.is_editing = False
+
+        update_window_modifier_representation(context)
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type:
+            tool.Model.mark_thumbnail_for_update(element_type)
+
+        pset = tool.Pset.get_element_pset(element, "BBIM_Window")
+        window_data = tool.Ifc.get().createIfcText(json.dumps(window_data, default=list))
+        ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": window_data})
+        return {"FINISHED"}
 
 
-class EnableEditingWindow(_WindowEditMixin, bpy.types.Operator, tool.Ifc.Operator):
+class EnableEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.enable_editing_window"
     bl_label = "Enable Editing Window"
     bl_description = "Enter edit mode to modify window parameters interactively"
-    bl_options = {"REGISTER", "UNDO"}
+    bl_options = {"REGISTER"}
 
     def _execute(self, context: bpy.types.Context) -> set[str]:
-        return self._enable_targets(context)
+        obj = context.active_object
+        assert obj
+        props = tool.Model.get_window_props(obj)
+        element = tool.Ifc.get_entity(obj)
+        assert element
+        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Window", "Data"))
+        data.update(data.pop("lining_properties"))
+        data.update(data.pop("panel_properties"))
+        data.update(tool.Model.get_constituents_props_data(element))
+
+        # required since we could load pset from .ifc and BIMWindowProperties won't be set
+        props.set_props_kwargs_from_ifc_data(data)
+
+        props.is_editing = True
+        return {"FINISHED"}
 
 
 class RemoveWindow(bpy.types.Operator, tool.Ifc.Operator):

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

@@ -1300,15 +1300,9 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
                 bpy.ops.bim.generate_space()
             return
         if self.active_material_usage == "LAYER2":
-            if element and tool.Model.has_underside_connection(element):
-                bpy.ops.bim.regenerate_wall_to_underside()
-            else:
-                bpy.ops.bim.recalculate_wall()
+            bpy.ops.bim.recalculate_wall()
         elif self.active_material_usage == "LAYER3":
             bpy.ops.bim.recalculate_slab()
-            wall_objs = tool.Model.get_connected_wall_objs(element)
-            if wall_objs:
-                core.regenerate_wall_to_underside(tool.Ifc, tool.Geometry, tool.Model, wall_objs)
         elif tool.System.get_ports(element):
             bpy.ops.bim.regenerate_distribution_element()
         elif self.active_material_usage == "PROFILE":

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

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import datetime
 import json
@@ -1905,11 +1903,11 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
 
         self.use_relative_path = tool.Project.get_project_props().use_relative_project_path
         props = tool.Blender.get_bim_props()
-        filepath = props.ifc_file
-        if not filepath or self.should_save_as:
-            return ExportHelper.invoke(self, context, event)
-        self.filepath = str(tool.Blender.ensure_blender_path_is_abs(Path(filepath)))
-        return self.execute(context)
+        if (filepath := props.ifc_file) and not self.should_save_as:
+            self.filepath = str(tool.Blender.ensure_blender_path_is_abs(Path(filepath)))
+            return self.execute(context)
+
+        return ExportHelper.invoke(self, context, event)
 
     def check(self, context):
         # ExportHelper is automatically adjusting suffix to `filename_ext`.
@@ -1935,16 +1933,6 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
         return {"FINISHED"}
 
     def _execute(self, context):
-        committed, failed_commits = tool.Parametric.commit_pending_edits()
-        # Suffix is appended to the IFC save-success report below so the auto-commit
-        # info isn't immediately overwritten by the success message in Blender's
-        # status bar (only the latest self.report({"INFO"}, ...) sticks).
-        commit_suffix = f" (auto-committed {committed} pending parametric edit(s))" if committed else ""
-        if failed_commits:
-            names = ", ".join(o.name for o in failed_commits)
-            msg = f"Auto-commit failed for {len(failed_commits)} object(s): {names}"
-            print(f"Bonsai: {msg} (their drafts are NOT saved to the IFC file).")
-            self.report({"ERROR"}, msg)
         start = time.time()
         logger = logging.getLogger("ExportIFC")
         path_log = tool.Blender.get_data_dir_path("process.log")
@@ -2013,7 +2001,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
                     blendmetadata_path = output_file + suffix
                 self.report(
                     {"INFO"},
-                    f'IFC Project "{os.path.basename(output_file)}" And Metadata File Saved to: {os.path.basename(blendmetadata_path)}{commit_suffix}',
+                    f'IFC Project "{os.path.basename(output_file)}" And Metadata File Saved to: {os.path.basename(blendmetadata_path)}',
                 )
             except Exception as e:
                 self.report({"ERROR"}, f"Failed to save blend metadata file: {e}")
@@ -2023,7 +2011,7 @@ class ExportIFC(bpy.types.Operator, ExportHelper):
                 bpy.ops.wm.save_mainfile(filepath=bpy.data.filepath)
             self.report(
                 {"INFO"},
-                f'IFC Project "{os.path.basename(output_file)}" {"" if not save_blend_file else "And Current Blend File Are"} Saved{commit_suffix}',
+                f'IFC Project "{os.path.basename(output_file)}" {"" if not save_blend_file else "And Current Blend File Are"} Saved',
             )
 
         bonsai.bim.handler.refresh_ui_data()

src/bonsai/bonsai/bim/module/search/data.py

@@ -95,7 +95,7 @@ class ColourByPropertyData:
         element = tool.Ifc.get_entity(obj)
         if not element:
             return default
-        keys = [a.name() for a in element.wrapped_data.declaration().as_entity().all_attributes()]
+        keys = [a.name() for a in element.declaration().as_entity().all_attributes()]
         psets = ifcopenshell.util.element.get_psets(element)
         for pset, properties in psets.items():
             if pset.endswith("Common"):
@@ -126,7 +126,7 @@ class SelectSimilarData:
         element = tool.Ifc.get_entity(obj)
         if not element:
             return []
-        keys = [a.name() for a in element.wrapped_data.declaration().as_entity().all_attributes()]
+        keys = [a.name() for a in element.declaration().as_entity().all_attributes()]
         psets = ifcopenshell.util.element.get_psets(element, psets_only=True)
         for pset, properties in psets.items():
             if pset.endswith("Common"):

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

@@ -118,19 +118,6 @@ def update_shader_graph(self: Union["Texture", "BIMStylesProperties"], context:
     tool.Loader.create_surface_style_with_textures(material, shading_data, textures_data)
 
 
-def _make_clear_null_updater(null_prop: str):
-    def _update(self: "BIMStylesProperties", context: bpy.types.Context) -> None:
-        self[null_prop] = False
-        update_shader_graph(self, context)
-
-    return _update
-
-
-update_diffuse_colour = _make_clear_null_updater("is_diffuse_colour_null")
-update_specular_colour = _make_clear_null_updater("is_specular_colour_null")
-update_specular_highlight_value = _make_clear_null_updater("is_specular_highlight_null")
-
-
 UV_MODES = [
     ("UV", "UV", _("Actual UV data presented on the geometry")),
     ("Generated", "Generated", _("Automatically-generated UV from the vertex positions of the mesh")),
@@ -234,29 +221,24 @@ class BIMStylesProperties(PropertyGroup):
     transparency: bpy.props.FloatProperty(
         name="Transparency", default=0.0, min=0.0, max=1.0, update=update_shader_graph
     )
-    is_diffuse_colour_null: BoolProperty(name="Is Null", update=update_shader_graph)
+    # TODO: do something on null?
+    is_diffuse_colour_null: BoolProperty(name="Is Null")
     diffuse_colour_class: EnumProperty(
         items=[(x, x, "") for x in get_args(ColourClass)],
         name="Diffuse Colour Class",
-        update=update_diffuse_colour,
+        update=update_shader_graph,
     )
     diffuse_colour: bpy.props.FloatVectorProperty(
-        name="Diffuse Colour",
-        subtype="COLOR",
-        default=(1, 1, 1),
-        min=0.0,
-        max=1.0,
-        size=3,
-        update=update_diffuse_colour,
+        name="Diffuse Colour", subtype="COLOR", default=(1, 1, 1), min=0.0, max=1.0, size=3, update=update_shader_graph
     )
     diffuse_colour_ratio: bpy.props.FloatProperty(
-        name="Diffuse Ratio", default=0.0, min=0.0, max=1.0, update=update_diffuse_colour
+        name="Diffuse Ratio", default=0.0, min=0.0, max=1.0, update=update_shader_graph
     )
-    is_specular_colour_null: BoolProperty(name="Is Null", update=update_shader_graph)
+    is_specular_colour_null: BoolProperty(name="Is Null")
     specular_colour_class: EnumProperty(
         items=[(x, x, "") for x in get_args(ColourClass)],
         name="Specular Colour Class",
-        update=update_specular_colour,
+        update=update_shader_graph,
         default="IfcNormalisedRatioMeasure",
     )
     specular_colour: bpy.props.FloatVectorProperty(
@@ -266,7 +248,7 @@ class BIMStylesProperties(PropertyGroup):
         min=0.0,
         max=1.0,
         size=3,
-        update=update_specular_colour,
+        update=update_shader_graph,
     )
     specular_colour_ratio: bpy.props.FloatProperty(
         name="Specular Ratio",
@@ -274,16 +256,16 @@ class BIMStylesProperties(PropertyGroup):
         default=0.0,
         min=0.0,
         max=1.0,
-        update=update_specular_colour,
+        update=update_shader_graph,
     )
-    is_specular_highlight_null: BoolProperty(name="Is Null", update=update_shader_graph)
+    is_specular_highlight_null: BoolProperty(name="Is Null")
     specular_highlight: bpy.props.FloatProperty(
         name="Specular Highlight",
         description="Used as Roughness value in PHYSICAL Reflectance Method",
         default=0.0,
         min=0.0,
         max=1.0,
-        update=update_specular_highlight_value,
+        update=update_shader_graph,
     )
     reflectance_method: EnumProperty(
         name="Reflectance Method",

src/bonsai/bonsai/bim/parametric_lifecycle.py

@@ -1,297 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Shared Enable / Finish / Cancel lifecycle mixins for parametric-edit operators.
-
-Two mixins fit the parametric-edit triads in ``bim/module/model/``:
-
-`FeatureModifierEditMixin`
-    Door, Window — BBIM_<Type> pset with nested ``lining_properties`` /
-    ``panel_properties``; Finish calls ``update_<type>_modifier_representation``
-    via ``ifcopenshell.api.feature``; Cancel restores via ``switch_representation``.
-
-`PathPreservingEditMixin`
-    Railing, Roof — BBIM_<Type> pset whose ``path_data`` is preserved through
-    edit (only general kwargs are user-editable); Finish calls
-    ``update_<type>_modifier_bmesh`` / ``update_<type>_modifier_ifc_data``;
-    Cancel re-reads the pset and rebuilds the bmesh preview.
-
-Stair and Wall stay standalone — their lifecycles diverge in ways that don't
-fit either mixin without optional escape hatches (Stair has a unique
-``update_ifc_stair_props`` post-Finish step + a separate ``get_props_kwargs_for_ifc_export``;
-Wall is validation-first, snapshot-driven, no preview regen in operators).
-
-This module sits separately from `bonsai.tool.Parametric` (the registry +
-auto-commit) because it imports ``bonsai.tool`` freely, while the registry
-itself must stay light — ``tool/blender.py`` consumes the registry at module load."""
-
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING, ClassVar
-
-import bpy
-import ifcopenshell.api.pset
-import ifcopenshell.util.element
-import ifcopenshell.util.representation
-
-import bonsai.core.geometry
-import bonsai.tool as tool
-
-if TYPE_CHECKING:
-    from ifcopenshell import entity_instance
-
-
-class _ParametricEditMixinBase:
-    """Common scaffolding for parametric edit-triad mixins.
-
-    Each per-type subclass provides four hooks:
-
-        ``pset_name``: BBIM_<Type> pset identifier
-        ``_is_element_type(element)``: IFC element predicate
-        ``_get_props(obj)``: PropertyGroup accessor
-        ``_iter_targets(context)``: list of objects to act on (default: ``[active_object]``)
-
-    Operator subclasses call one of ``_enable_targets`` / ``_finish_targets`` /
-    ``_cancel_targets`` from their ``_execute`` method."""
-
-    pset_name: ClassVar[str]
-
-    @classmethod
-    def _iter_targets(cls, context: bpy.types.Context) -> list[bpy.types.Object]:
-        obj = context.active_object
-        return [obj] if obj else []
-
-    @classmethod
-    def _is_element_type(cls, element: entity_instance) -> bool:
-        raise NotImplementedError
-
-    @classmethod
-    def _get_props(cls, obj: bpy.types.Object):
-        raise NotImplementedError
-
-    @classmethod
-    def _resolve(cls, obj: bpy.types.Object):
-        """Look up ``(element, props)`` for ``obj`` if it matches this type, else None.
-
-        Common predicate guard for every lifecycle method — collapses the
-        ``element = tool.Ifc.get_entity(obj); assert element; if not is_<type>(element): return``
-        triplet into one call."""
-        element = tool.Ifc.get_entity(obj)
-        if not element or not cls._is_element_type(element):
-            return None
-        return element, cls._get_props(obj)
-
-
-class FeatureModifierEditMixin(_ParametricEditMixinBase):
-    """Lifecycle for door- and window-style parametric modifier operators.
-
-    Enable:
-        Read BBIM_<Type> pset JSON → unwrap ``lining_properties`` and
-        ``panel_properties`` → merge constituents data → set draft props →
-        ``is_editing = True``.
-
-    Finish:
-        Gather ``general / lining / panel`` kwargs (project units) → nest →
-        ``is_editing = False`` → call ``_update_modifier_representation`` →
-        mark thumbnail → write back to BBIM_<Type> pset via
-        ``ifcopenshell.api.pset.edit_pset``.
-
-    Cancel:
-        Read BBIM_<Type> pset JSON → unwrap → restore draft props →
-        ``switch_representation`` to the Body representation →
-        ``is_editing = False``."""
-
-    @classmethod
-    def _update_modifier_representation(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        """Hook: call the per-type ``update_<type>_modifier_representation``.
-
-        Door's helper takes ``obj``; window's takes ``context``. The hook lets
-        each subclass forward to its existing helper without unifying signatures."""
-        raise NotImplementedError
-
-    @classmethod
-    def _enable_one(cls, obj: bpy.types.Object) -> None:
-        resolved = cls._resolve(obj)
-        if resolved is None:
-            return
-        element, props = resolved
-        data = json.loads(ifcopenshell.util.element.get_pset(element, cls.pset_name, "Data"))
-        data.update(data.pop("lining_properties"))
-        data.update(data.pop("panel_properties"))
-        data.update(tool.Model.get_constituents_props_data(element))
-        # required since the pset can be loaded from .ifc and the PropertyGroup
-        # would otherwise still hold its default values
-        props.set_props_kwargs_from_ifc_data(data)
-        props.is_editing = True
-
-    @classmethod
-    def _finish_one(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        resolved = cls._resolve(obj)
-        if resolved is None:
-            return
-        element, props = resolved
-        data = props.get_general_kwargs(convert_to_project_units=True)
-        data["lining_properties"] = props.get_lining_kwargs(convert_to_project_units=True)
-        data["panel_properties"] = props.get_panel_kwargs(convert_to_project_units=True)
-        cls._update_modifier_representation(obj, context)
-        element_type = ifcopenshell.util.element.get_type(element)
-        if element_type:
-            tool.Model.mark_thumbnail_for_update(element_type)
-        pset = tool.Pset.get_element_pset(element, cls.pset_name)
-        data_text = tool.Ifc.get().createIfcText(json.dumps(data, default=list))
-        ifcopenshell.api.pset.edit_pset(tool.Ifc.get(), pset=pset, properties={"Data": data_text})
-        # Set only on success: if any IFC op above raised, the user's draft survives for retry.
-        props.is_editing = False
-
-    @classmethod
-    def _cancel_one(cls, obj: bpy.types.Object) -> None:
-        resolved = cls._resolve(obj)
-        if resolved is None:
-            return
-        element, props = resolved
-        data = json.loads(ifcopenshell.util.element.get_pset(element, cls.pset_name, "Data"))
-        data.update(data.pop("lining_properties"))
-        data.update(data.pop("panel_properties"))
-        props.set_props_kwargs_from_ifc_data(data)
-        body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
-        bonsai.core.geometry.switch_representation(tool.Ifc, tool.Geometry, obj=obj, representation=body)
-        props.is_editing = False
-
-    def _enable_targets(self, context: bpy.types.Context) -> set[str]:
-        for obj in self._iter_targets(context):
-            self._enable_one(obj)
-        return {"FINISHED"}
-
-    def _finish_targets(self, context: bpy.types.Context) -> set[str]:
-        for obj in self._iter_targets(context):
-            self._finish_one(obj, context)
-        return {"FINISHED"}
-
-    def _cancel_targets(self, context: bpy.types.Context) -> set[str]:
-        for obj in self._iter_targets(context):
-            self._cancel_one(obj)
-        return {"FINISHED"}
-
-
-class PathPreservingEditMixin(_ParametricEditMixinBase):
-    """Lifecycle for railing- and roof-style parametric modifier operators.
-
-    Distinctive: ``path_data`` is part of the BBIM_<Type> pset but is **not**
-    user-editable through this triad — it survives the edit untouched, only
-    general kwargs are diffed. (Path editing has its own separate operator
-    pair, ``Enable/Finish/CancelEditing<Type>Path``, out of scope here.)
-
-    Enable:
-        Fetch pset data via ``tool.Model.get_modeling_bbim_pset_data`` → set
-        draft props → ``is_editing = True``. The subclass post-load hook
-        lets railing JSON-serialise ``path_data`` for the PropertyGroup
-        string field.
-
-    Finish:
-        Read fresh pset → keep ``path_data`` → gather ``general`` kwargs
-        (project units) → reassemble → ``is_editing = False`` → call
-        ``_update_pset`` (per-type pset writer) → call ``_update_modifier_ifc_data``
-        (per-type geometry commit).
-
-    Cancel:
-        Read fresh pset → restore draft props → call
-        ``_update_modifier_bmesh`` (per-type bmesh preview) →
-        ``is_editing = False``."""
-
-    @classmethod
-    def _post_load_data(cls, data: dict) -> dict:
-        """Hook: optionally transform the pset data dict after loading and before
-        passing to ``set_props_kwargs_from_ifc_data``. Default: pass-through.
-
-        Railing overrides to JSON-serialise ``path_data`` (its
-        BIMRailingProperties.path_data is a ``StringProperty`` holding JSON)."""
-        return data
-
-    @classmethod
-    def _update_pset(cls, element: entity_instance, data: dict) -> None:
-        """Hook: per-type pset writer (``update_bbim_<type>_pset``)."""
-        raise NotImplementedError
-
-    @classmethod
-    def _update_modifier_ifc_data(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        """Hook: per-type ``update_<type>_modifier_ifc_data`` — commits the
-        modified geometry to IFC. Signature accepts ``(obj, context)`` so
-        subclasses can forward either argument to their existing helper."""
-        raise NotImplementedError
-
-    @classmethod
-    def _update_modifier_bmesh(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        """Hook: per-type ``update_<type>_modifier_bmesh`` — rebuilds the
-        bmesh preview to match the current draft props (used by Cancel)."""
-        raise NotImplementedError
-
-    @classmethod
-    def _enable_one(cls, obj: bpy.types.Object) -> None:
-        resolved = cls._resolve(obj)
-        if resolved is None:
-            return
-        _element, props = resolved
-        data = tool.Model.get_modeling_bbim_pset_data(obj, cls.pset_name)["data_dict"]
-        data = cls._post_load_data(data)
-        props.set_props_kwargs_from_ifc_data(data)
-        props.is_editing = True
-
-    @classmethod
-    def _finish_one(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        resolved = cls._resolve(obj)
-        if resolved is None:
-            return
-        element, props = resolved
-        pset_data = tool.Model.get_modeling_bbim_pset_data(obj, cls.pset_name)
-        path_data = pset_data["data_dict"]["path_data"]
-        data = props.get_general_kwargs(convert_to_project_units=True)
-        data["path_data"] = path_data
-        cls._update_pset(element, data)
-        cls._update_modifier_ifc_data(obj, context)
-        # Set only on success: if any IFC op above raised, the user's draft survives for retry.
-        props.is_editing = False
-
-    @classmethod
-    def _cancel_one(cls, obj: bpy.types.Object, context: bpy.types.Context) -> None:
-        resolved = cls._resolve(obj)
-        if resolved is None:
-            return
-        _element, props = resolved
-        data = tool.Model.get_modeling_bbim_pset_data(obj, cls.pset_name)["data_dict"]
-        data = cls._post_load_data(data)
-        props.set_props_kwargs_from_ifc_data(data)
-        cls._update_modifier_bmesh(obj, context)
-        props.is_editing = False
-
-    def _enable_targets(self, context: bpy.types.Context) -> set[str]:
-        for obj in self._iter_targets(context):
-            self._enable_one(obj)
-        return {"FINISHED"}
-
-    def _finish_targets(self, context: bpy.types.Context) -> set[str]:
-        for obj in self._iter_targets(context):
-            self._finish_one(obj, context)
-        return {"FINISHED"}
-
-    def _cancel_targets(self, context: bpy.types.Context) -> set[str]:
-        for obj in self._iter_targets(context):
-            self._cancel_one(obj, context)
-        return {"FINISHED"}

src/bonsai/bonsai/bim/ui.py

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 import os
 import platform
@@ -382,76 +380,6 @@ class GizmoPreferencesStair(bpy.types.PropertyGroup):
         cycle: bool
 
 
-class GizmoPreferencesWall(bpy.types.PropertyGroup):
-    """Property group for wall gizmo visibility settings."""
-
-    length: BoolProperty(
-        name="Length",
-        default=True,
-        description="Show the length dimension gizmo along the wall axis.",
-    )
-    height: BoolProperty(
-        name="Height",
-        default=True,
-        description="Show the height dimension gizmo at the wall's start endpoint.",
-    )
-    height_end: BoolProperty(
-        name="Height (far end, walls > 5m)",
-        default=True,
-        description=(
-            "Show a second height gizmo at the wall's far end so long walls don't "
-            "require panning to reach the handle."
-        ),
-    )
-    x_angle: BoolProperty(
-        name="Slope",
-        default=True,
-        description="Show the slope gizmo at the wall top measuring horizontal displacement of the top face.",
-    )
-    cycle: BoolProperty(
-        name="Cycle Offset Baseline",
-        default=True,
-        description="Show the baseline-state icon (Exterior / Centreline / Interior) in the editing icon row.",
-    )
-    scissors: BoolProperty(
-        name="Split at cursor",
-        default=True,
-        description="Show the split icon at the 3D cursor when it lies within the wall's length range.",
-    )
-    extend: BoolProperty(
-        name="Extend length to cursor X",
-        default=True,
-        description="Show the extend-length icon at the 3D cursor's projected wall-axis X.",
-    )
-    extend_height: BoolProperty(
-        name="Extend height to cursor Z",
-        default=True,
-        description="Show the extend-height icon at the 3D cursor's Z, on the wall axis.",
-    )
-    rotate: BoolProperty(
-        name="Rotate 90°",
-        default=True,
-        description="Show the rotate-90 icon in the editing icon row (rotates the wall around its Z axis).",
-    )
-    toggle_openings: BoolProperty(
-        name="Toggle Openings",
-        default=True,
-        description="Show the toggle-openings icon next to the pen (toggles opening fill visibility in the viewport).",
-    )
-
-    if TYPE_CHECKING:
-        length: bool
-        height: bool
-        height_end: bool
-        x_angle: bool
-        cycle: bool
-        scissors: bool
-        extend: bool
-        extend_height: bool
-        rotate: bool
-        toggle_openings: bool
-
-
 class GizmoPreferences(bpy.types.PropertyGroup):
     """Property group for all gizmo visibility settings."""
 
@@ -463,14 +391,12 @@ class GizmoPreferences(bpy.types.PropertyGroup):
     door: bpy.props.PointerProperty(type=GizmoPreferencesDoor)
     window: bpy.props.PointerProperty(type=GizmoPreferencesWindow)
     stair: bpy.props.PointerProperty(type=GizmoPreferencesStair)
-    wall: bpy.props.PointerProperty(type=GizmoPreferencesWall)
 
     if TYPE_CHECKING:
         draw_gizmos_in_3d_viewport: bool
         door: GizmoPreferencesDoor
         window: GizmoPreferencesWindow
         stair: GizmoPreferencesStair
-        wall: GizmoPreferencesWall
 
 
 class DocPreferences(bpy.types.PropertyGroup):
@@ -923,56 +849,49 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         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)
-        bonsai.bim.helper.draw_expandable_panel(box, context, "Parametric Wall", self.draw_wall_gizmo_parameters)
-
-    def _draw_parametric_gizmo_parameters(
-        self,
-        layout: bpy.types.UILayout,
-        gizmo_pg: bpy.types.PropertyGroup,
-        dimension_gizmo_class: type,
-        special_gizmo_names: frozenset[str] = frozenset(),
-    ) -> None:
-        """Draw the per-element gizmo visibility toggles. Surfaces every annotation
-        on ``gizmo_pg`` that either maps to one of ``dimension_gizmo_class``'s
-        dimension gizmos or is named in ``special_gizmo_names`` (non-dimension icons
-        like baseline cycle, scissors, rotate, …)."""
-        visible_names = {p.attr_name for p in dimension_gizmo_class.dimension_gizmo_props} | special_gizmo_names
-        try:
-            annotations = gizmo_pg.__annotations__
-        except AttributeError:
-            annotations = type(gizmo_pg).__annotations__
-        for prop in annotations:
-            if prop in visible_names:
-                layout.prop(gizmo_pg, prop)
 
     def draw_door_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
         from bonsai.bim.module.model.door import GizmoDoorEdition
 
-        self._draw_parametric_gizmo_parameters(
-            layout, self.gizmos.door, GizmoDoorEdition, frozenset({"swing_arc", "flip_arc"})
-        )
+        door_gizmos = self.gizmos.door
+        gizmo_prop_names = {p.attr_name for p in GizmoDoorEdition.dimension_gizmo_props}
+        # Add special gizmos not in dimension_gizmo_props
+        gizmo_prop_names.update(("swing_arc", "flip_arc"))
+        try:
+            annotations = door_gizmos.__annotations__
+        except AttributeError:
+            annotations = type(door_gizmos).__annotations__
+        for prop in 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
 
-        self._draw_parametric_gizmo_parameters(layout, self.gizmos.window, GizmoWindowEdition)
+        window_gizmos = self.gizmos.window
+        gizmo_prop_names = {p.attr_name for p in GizmoWindowEdition.dimension_gizmo_props}
+        try:
+            annotations = window_gizmos.__annotations__
+        except AttributeError:
+            annotations = type(window_gizmos).__annotations__
+        for prop in 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
 
-        self._draw_parametric_gizmo_parameters(
-            layout, self.gizmos.stair, GizmoStairEdition, frozenset({"lock", "plus", "minus", "cycle"})
-        )
-
-    def draw_wall_gizmo_parameters(self, layout: bpy.types.UILayout, context: bpy.types.Context) -> None:
-        from bonsai.bim.module.model.wall import GizmoWallEdition
-
-        self._draw_parametric_gizmo_parameters(
-            layout,
-            self.gizmos.wall,
-            GizmoWallEdition,
-            frozenset({"cycle", "scissors", "extend", "extend_height", "rotate", "toggle_openings"}),
-        )
+        stair_gizmos = self.gizmos.stair
+        gizmo_prop_names = {p.attr_name for p in GizmoStairEdition.dimension_gizmo_props}
+        # Add special gizmos not in dimension_gizmo_props
+        special_gizmo_names = {"lock", "plus", "minus", "cycle"}
+        try:
+            annotations = stair_gizmos.__annotations__
+        except AttributeError:
+            annotations = type(stair_gizmos).__annotations__
+        for prop in 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")

src/bonsai/bonsai/core/model.py

@@ -15,12 +15,9 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 from __future__ import annotations
 
-import math
 from typing import TYPE_CHECKING, Literal, Optional
 
 if TYPE_CHECKING:
@@ -143,73 +140,23 @@ def align_objects(
     model.align_objects(reference_obj, objs, align_type)
 
 
-def regenerate_wall_to_underside(
-    ifc: type[tool.Ifc],
-    geometry: type[tool.Geometry],
-    model: type[tool.Model],
-    wall_objs: list[bpy.types.Object],
-) -> None:
-    """Re-clip walls to their connected underside objects after the slab has moved."""
-    clipped_objs = []
-    for obj in wall_objs:
-        wall = ifc.get_entity(obj)
-        slab_objs = model.get_connected_slab_objs(wall)
-        if not slab_objs:
-            continue
-        if ifc.is_moved(obj):
-            geometry.run_edit_object_placement(obj=obj)
-        # Sync each slab's Blender mesh to its current IFC representation before
-        # reading face geometry, so a changed profile is picked up correctly.
-        model.reload_body_representation(slab_objs)
-        model.remove_wall_to_underside_booleans(wall)
-        for slab_obj in slab_objs:
-            clip = model.get_slab_clipping_bmesh(slab_obj)
-            if clip:
-                model.clip_wall_to_slab(wall, clip)
-        clipped_objs.append(obj)
-    if clipped_objs:
-        model.reload_body_representation(clipped_objs)
-
-
 def extend_wall_to_slab(
     ifc: type[tool.Ifc],
     geometry: type[tool.Geometry],
     model: type[tool.Model],
-    slab_objs: list[bpy.types.Object],
+    slab_obj: bpy.types.Object,
     wall_objs: list[bpy.types.Object],
 ) -> None:
-    # If any wall is currently in item mode, exit it before modifying the
-    # representation. Leaving stale item objects around causes delete_ifc_item
-    # to later remove the extrusion (or other pre-boolean items) from inside
-    # the boolean chain, corrupting the IFC model.
-    geom_props = geometry.get_geometry_props()
-    if geom_props.representation_obj in wall_objs:
-        geometry.disable_item_mode()
-    clipped_walls = []
+    if not (clip := model.get_slab_clipping_bmesh(slab_obj)):
+        return  # Nothing to clip?
+    slab = ifc.get_entity(slab_obj)
     for obj in wall_objs:
         if ifc.is_moved(obj):
             geometry.run_edit_object_placement(obj=obj)
         wall = ifc.get_entity(obj)
-        # Merge previously connected slabs with newly requested ones so that
-        # re-running the operator never produces duplicate booleans and never
-        # silently discards clips that were applied in an earlier call.
-        existing = model.get_connected_slab_objs(wall)
-        seen = {id(s) for s in existing}
-        all_slab_objs = list(existing) + [s for s in slab_objs if id(s) not in seen]
-        # Remove stale booleans once, then re-clip against the full set.
-        model.remove_wall_to_underside_booleans(wall)
-        did_clip = False
-        for slab_obj in all_slab_objs:
-            clip = model.get_slab_clipping_bmesh(slab_obj)
-            if not clip:
-                continue
-            model.clip_wall_to_slab(wall, clip)
-            model.connect_wall_to_slab(wall, ifc.get_entity(slab_obj))
-            did_clip = True
-        if did_clip:
-            clipped_walls.append(obj)
-    if clipped_walls:
-        model.reload_body_representation(clipped_walls)
+        model.clip_wall_to_slab(wall, clip)
+        model.connect_wall_to_slab(wall, slab)
+    model.reload_body_representation(wall_objs)
 
 
 class RequireTwoWallsError(Exception):
@@ -226,141 +173,3 @@ class RequireAtLeastTwoElements(Exception):
 
 class RequireLayeredElement(Exception):
     pass
-
-
-# --- Wall geometry math (pure) ------------------------------------------------
-# Tuple in / tuple out so these helpers run under ``pytest test/core/`` without
-# ``bpy`` or ``mathutils``. Callers convert ``mathutils.Vector`` at the boundary.
-
-
-def baseline_from_offset(offset: float, thickness: float, tolerance: float = 0.001) -> str:
-    """Classify a numeric layer offset as EXTERIOR / CENTER / INTERIOR.
-
-    Mirrors the math in ``tool.Model.offset_wall`` for both POSITIVE and NEGATIVE
-    direction_sense walls. Returns the closest canonical baseline; falls back to
-    ``"CENTER"`` when nothing is within ``tolerance``."""
-    candidates = (
-        ("EXTERIOR", 0.0),
-        ("CENTER", -thickness / 2),
-        ("INTERIOR", -thickness),
-        ("EXTERIOR", thickness),
-        ("CENTER", thickness / 2),
-        ("INTERIOR", 0.0),
-    )
-    best = min(candidates, key=lambda c: abs(offset - c[1]))
-    return best[0] if abs(offset - best[1]) < tolerance else "CENTER"
-
-
-def project_axis_intersection(
-    seg_a: tuple[tuple[float, float, float], tuple[float, float, float]],
-    seg_b: tuple[tuple[float, float, float], tuple[float, float, float]],
-    parallel_threshold: float,
-) -> Optional[tuple[float, float, float]]:
-    """Compute the 2D (X,Y plane) intersection of two world-space axis segments.
-
-    Each segment is a pair of 3-tuples. Returns the intersection as a 3-tuple
-    (Z is the average of the four input Zs, for visual placement) or ``None`` if
-    the segments are parallel within ``parallel_threshold`` (a dot-product magnitude
-    threshold — e.g. ``cos(2°) ≈ 0.9994`` treats walls within 2° of parallel as parallel)."""
-    p1, p2 = seg_a
-    p3, p4 = seg_b
-    d1x, d1y = p2[0] - p1[0], p2[1] - p1[1]
-    d2x, d2y = p4[0] - p3[0], p4[1] - p3[1]
-    d1_len = (d1x * d1x + d1y * d1y) ** 0.5
-    d2_len = (d2x * d2x + d2y * d2y) ** 0.5
-    if d1_len < 1e-9 or d2_len < 1e-9:
-        return None
-    dot = (d1x * d2x + d1y * d2y) / (d1_len * d2_len)
-    if abs(dot) >= parallel_threshold:
-        return None
-    denom = d1x * d2y - d1y * d2x
-    if abs(denom) < 1e-9:
-        return None
-    t = ((p3[0] - p1[0]) * d2y - (p3[1] - p1[1]) * d2x) / denom
-    ix = p1[0] + t * d1x
-    iy = p1[1] + t * d1y
-    iz = (p1[2] + p2[2] + p3[2] + p4[2]) / 4
-    return (ix, iy, iz)
-
-
-def displacement_from_x_angle(height: float, x_angle: float) -> float:
-    """Top-edge horizontal displacement for a wall of given vertical ``height`` and
-    slope ``x_angle`` (radians). Drives the slope dimension gizmo's display value.
-
-    Inverse of :func:`x_angle_from_displacement`."""
-    return height * math.tan(x_angle)
-
-
-def x_angle_from_displacement(height: float, displacement: float) -> float:
-    """Recover slope ``x_angle`` (radians) from a top-edge horizontal displacement.
-
-    ``height`` is clamped to ``max(height, 1e-6)`` so vertical walls of effectively
-    zero height map cleanly to ``±π/2`` via ``atan2`` rather than dividing by zero.
-
-    Inverse of :func:`displacement_from_x_angle`."""
-    return math.atan2(displacement, max(height, 1e-6))
-
-
-def vertical_height_from_extrusion_depth(extrusion_depth: float, x_angle: float) -> float:
-    """Vertical height of a wall given its slanted extrusion depth and slope.
-
-    ``IfcExtrudedAreaSolid.Depth`` measures along the (possibly slanted) extrusion
-    direction. The vertical height the user thinks of is ``depth * cos(x_angle)``.
-    Unit-agnostic: the result is in the same units as ``extrusion_depth``."""
-    return extrusion_depth * abs(math.cos(x_angle))
-
-
-def are_axes_collinear(
-    seg_a: tuple[tuple[float, float, float], tuple[float, float, float]],
-    seg_b: tuple[tuple[float, float, float], tuple[float, float, float]],
-    parallel_threshold: float = 0.9994,
-    line_tolerance: float = 0.05,
-) -> bool:
-    """True if both axis segments lie on the same infinite line in plan.
-
-    Two conditions: directions must be (anti-)parallel within ``parallel_threshold``
-    (``cos(2°) ≈ 0.9994``), AND any endpoint of B must lie on A's infinite line
-    within ``line_tolerance``. Plan-only (Z ignored) — two parallel walls at
-    different elevations are still considered collinear because the merge operator
-    handles Z resolution itself.
-
-    Used by the wall-join gizmo's state machine: collinear pair → Merge icon at the
-    boundary, perpendicular pair → Join icon at the intersection."""
-    d1x, d1y = seg_a[1][0] - seg_a[0][0], seg_a[1][1] - seg_a[0][1]
-    d2x, d2y = seg_b[1][0] - seg_b[0][0], seg_b[1][1] - seg_b[0][1]
-    d1_len = (d1x * d1x + d1y * d1y) ** 0.5
-    d2_len = (d2x * d2x + d2y * d2y) ** 0.5
-    if d1_len < 1e-9 or d2_len < 1e-9:
-        return False
-    if abs((d1x * d2x + d1y * d2y) / (d1_len * d2_len)) < parallel_threshold:
-        return False
-    # Project seg_b[0] onto the infinite line through seg_a; the perpendicular
-    # distance to the original point tells us how far off the line B sits.
-    nx, ny = d1x / d1_len, d1y / d1_len
-    dx, dy = seg_b[0][0] - seg_a[0][0], seg_b[0][1] - seg_a[0][1]
-    t = dx * nx + dy * ny
-    proj_x = seg_a[0][0] + nx * t
-    proj_y = seg_a[0][1] + ny * t
-    perp_x = seg_b[0][0] - proj_x
-    perp_y = seg_b[0][1] - proj_y
-    return (perp_x * perp_x + perp_y * perp_y) ** 0.5 < line_tolerance
-
-
-def closest_endpoint_midpoint(
-    seg_a: tuple[tuple[float, float, float], tuple[float, float, float]],
-    seg_b: tuple[tuple[float, float, float], tuple[float, float, float]],
-) -> tuple[float, float, float]:
-    """Midpoint of the closest pair of endpoints between two segments.
-
-    For walls that meet end-to-end this is the shared corner; for walls with a
-    small gap it's the midpoint of the gap. Either way it's the user-meaningful
-    "boundary" where a merge would graft the two segments together."""
-    endpoints_a = (seg_a[0], seg_a[1])
-    endpoints_b = (seg_b[0], seg_b[1])
-
-    def _distance_sq(p: tuple[float, float, float], q: tuple[float, float, float]) -> float:
-        return (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2 + (p[2] - q[2]) ** 2
-
-    closest_pair = min(((a, b) for a in endpoints_a for b in endpoints_b), key=lambda pair: _distance_sq(*pair))
-    a, b = closest_pair
-    return ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2)

src/bonsai/bonsai/core/tool.py

@@ -668,9 +668,6 @@ class Model:
     def export_profile(cls, obj, position=None): pass
     def generate_occurrence_name(cls, element_type, ifc_class): pass
     def get_extrusion(cls, representation): pass
-    def get_connected_slab_objs(cls, wall): pass
-    def get_connected_wall_objs(cls, slab): pass
-    def has_underside_connection(cls, element): pass
     def get_manual_booleans(cls, element): pass
     def get_material_layer_parameters(cls, element): pass
     def get_slab_clipping_bmesh(cls, obj): pass
@@ -686,7 +683,6 @@ class Model:
     def regenerate_profile(cls, obj): pass
     def regenerate_slab(cls, obj): pass
     def reload_body_representation(cls, obj_or_objects): pass
-    def remove_wall_to_underside_booleans(cls, wall): pass
     def replace_object_ifc_representation(cls, ifc_file, ifc_context, obj, new_representation): pass
 
 
@@ -780,12 +776,6 @@ class Profile:
     def get_profile(cls, element): pass
 
 
-@interface
-class Parametric:
-    def get_geom_generation(cls) -> int: pass
-    def refresh_post_commit(cls) -> None: pass
-
-
 @interface
 class Pset:
     def add_proposed_property(cls, name, value, props): pass

src/bonsai/bonsai/tool/__init__.py

@@ -51,7 +51,6 @@ from bonsai.tool.misc import Misc
 from bonsai.tool.model import Model
 from bonsai.tool.nest import Nest
 from bonsai.tool.owner import Owner
-from bonsai.tool.parametric import Parametric
 from bonsai.tool.patch import Patch
 from bonsai.tool.polyline import Polyline
 from bonsai.tool.profile import Profile

src/bonsai/bonsai/tool/blender.py

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 from __future__ import annotations
 
@@ -57,12 +55,12 @@ from mathutils import Matrix, Vector
 import bonsai.bim
 import bonsai.core.tool
 import bonsai.tool as tool
+from bonsai.bim.ifc import IFC_CONNECTED_TYPE
 
 if TYPE_CHECKING:
     import bpy.stub_internal.rna_enums as rna_enums
     from sun_position.properties import SunPosProperties
 
-    from bonsai.bim.ifc import IFC_CONNECTED_TYPE
     from bonsai.bim.module.attribute.prop import BIMAttributeProperties
     from bonsai.bim.module.constraint.prop import (
         BIMConstraintProperties,
@@ -1139,18 +1137,20 @@ class Blender(bonsai.core.tool.Blender):
 
             :return: True if an action was taken, False otherwise
             """
-            # roof and railing both finalize then drop into path-edit mode — handle
-            # them before the generic finish dispatch so the path transition runs.
             if cls.is_roof(element):
-                if (feature := tool.Parametric.find_by_name("roof")) and feature.is_editing(obj):
-                    tool.Parametric.run_bim_op(feature.finish_op)
+                if cls.is_editing_roof_parameters(obj):
+                    bpy.ops.bim.finish_editing_roof()
                 bpy.ops.bim.enable_editing_roof_path()
             elif cls.is_railing(element):
-                if (feature := tool.Parametric.find_by_name("railing")) and feature.is_editing(obj):
-                    tool.Parametric.run_bim_op(feature.finish_op)
+                if cls.is_editing_railing_parameters(obj):
+                    bpy.ops.bim.finish_editing_railing()
                 bpy.ops.bim.enable_editing_railing_path()
-            elif feature := tool.Parametric.is_object_editing(obj):
-                tool.Parametric.run_bim_op(feature.finish_op)
+            elif cls.is_editing_stair_parameters(obj):
+                bpy.ops.bim.finish_editing_stair()
+            elif cls.is_editing_door_parameters(obj):
+                bpy.ops.bim.finish_editing_door()
+            elif cls.is_editing_window_parameters(obj):
+                bpy.ops.bim.finish_editing_window()
             else:
                 return False
             return True
@@ -1161,13 +1161,20 @@ class Blender(bonsai.core.tool.Blender):
 
             :return: True if an action was taken, False otherwise
             """
-            # Path-edit modes are distinct from parametric draft modes; handle them first.
             if cls.is_editing_railing_path(obj):
                 bpy.ops.bim.cancel_editing_railing_path()
             elif cls.is_editing_roof_path(obj):
                 bpy.ops.bim.cancel_editing_roof_path()
-            elif feature := tool.Parametric.is_object_editing(obj):
-                tool.Parametric.run_bim_op(feature.cancel_op)
+            elif cls.is_editing_railing_parameters(obj):
+                bpy.ops.bim.cancel_editing_railing()
+            elif cls.is_editing_door_parameters(obj):
+                bpy.ops.bim.cancel_editing_door()
+            elif cls.is_editing_window_parameters(obj):
+                bpy.ops.bim.cancel_editing_window()
+            elif cls.is_editing_roof_parameters(obj):
+                bpy.ops.bim.cancel_editing_roof()
+            elif cls.is_editing_stair_parameters(obj):
+                bpy.ops.bim.cancel_editing_stair()
             else:
                 return False
             return True
@@ -1214,17 +1221,6 @@ class Blender(bonsai.core.tool.Blender):
         def is_stair(cls, element: entity_instance) -> bool:
             return tool.Pset.get_element_pset(element, "BBIM_Stair")
 
-        @classmethod
-        def is_wall(cls, element: entity_instance) -> bool:
-            """A wall is editable by the parametric gizmo if it is an IfcWall with LAYER2 usage.
-
-            Unlike doors/windows/stairs, walls do not carry a proprietary BBIM_Wall pset —
-            their parametric state lives in standard IFC (axis polyline, IfcMaterialLayerSetUsage,
-            IfcExtrudedAreaSolid). Any LAYER2 wall qualifies."""
-            if not element.is_a("IfcWall"):
-                return False
-            return tool.Model.get_usage_type(element) == "LAYER2"
-
         @classmethod
         def is_editing_railing_path(cls, obj: bpy.types.Object):
             props = tool.Model.get_railing_props(obj)
@@ -1235,10 +1231,34 @@ class Blender(bonsai.core.tool.Blender):
             props = tool.Model.get_roof_props(obj)
             return props.is_editing_path
 
+        @classmethod
+        def is_editing_railing_parameters(cls, obj: bpy.types.Object) -> bool:
+            props = tool.Model.get_railing_props(obj)
+            return props.is_editing
+
+        @classmethod
+        def is_editing_roof_parameters(cls, obj: bpy.types.Object) -> bool:
+            props = tool.Model.get_roof_props(obj)
+            return props.is_editing
+
+        @classmethod
+        def is_editing_window_parameters(cls, obj: bpy.types.Object) -> bool:
+            props = tool.Model.get_window_props(obj)
+            return props.is_editing
+
+        @classmethod
+        def is_editing_door_parameters(cls, obj: bpy.types.Object) -> bool:
+            props = tool.Model.get_door_props(obj)
+            return props.is_editing
+
+        @classmethod
+        def is_editing_stair_parameters(cls, obj: bpy.types.Object) -> bool:
+            props = tool.Model.get_stair_props(obj)
+            return props.is_editing
+
         @classmethod
         def is_modifier_with_non_editable_path(cls, element: entity_instance) -> bool:
-            feature = tool.Parametric.find_for_element(element)
-            return bool(feature and feature.has_non_editable_path)
+            return cls.is_stair(element) or cls.is_door(element) or cls.is_window(element)
 
         class Array:
             @classmethod

src/bonsai/bonsai/tool/cost.py

@@ -987,8 +987,7 @@ class Cost(bonsai.core.tool.Cost):
     def disable_editing_cost_item_parent(cls) -> None:
         props = cls.get_cost_props()
         props.active_cost_item_id = 0
-        if props.change_cost_item_parent == True:
-            props.change_cost_item_parent = False
+        props.change_cost_item_parent = False
 
     @classmethod
     def load_cost_item_quantities(cls, cost_item: Optional[ifcopenshell.entity_instance] = None) -> None:

src/bonsai/bonsai/tool/drawing.py

@@ -1756,10 +1756,6 @@ class Drawing(bonsai.core.tool.Drawing):
             # For section/elevation views, elevate the segment vertically
             if not (points := helper.elevate_segment(bounds, [v1, v2])):
                 return
-        elif target_view == "MODEL_VIEW":
-            # For model views, clip to XY bounds and keep Z (3D line at true elevation)
-            if not (points := helper.clip_segment(bounds, [v1, v2])):
-                return
         else:
             return
 

src/bonsai/bonsai/tool/geometry.py

@@ -225,13 +225,7 @@ class Geometry(bonsai.core.tool.Geometry):
                 break
         mesh = obj.data
         assert isinstance(mesh, bpy.types.Mesh)
-        item_id = tool.Geometry.get_mesh_props(mesh).ifc_definition_id
-        try:
-            item = tool.Ifc.get().by_id(item_id)
-        except RuntimeError:
-            # Entity already deleted (e.g. removed as part of a sibling boolean collapse).
-            bpy.data.objects.remove(obj)
-            return
+        item = tool.Ifc.get().by_id(tool.Geometry.get_mesh_props(mesh).ifc_definition_id)
         rep_obj = props.representation_obj
         assert (rep_obj := props.representation_obj) and (rep_element := tool.Ifc.get_entity(rep_obj))
         cls.remove_representation_item(item, rep_element)
@@ -1099,16 +1093,11 @@ class Geometry(bonsai.core.tool.Geometry):
     @classmethod
     def get_representation_item(cls, obj: bpy.types.Object) -> Union[ifcopenshell.entity_instance, None]:
         data = obj.data
-        if not isinstance(data, Geometry.TYPES_WITH_MESH_PROPERTIES):
-            return None
-        ifc_id = tool.Geometry.get_mesh_props(data).ifc_definition_id
-        if not ifc_id:
-            return None
-        try:
-            item = tool.Ifc.get().by_id(ifc_id)
-        except RuntimeError:
-            return None
-        if item.is_a("IfcRepresentationItem"):
+        if (
+            isinstance(data, Geometry.TYPES_WITH_MESH_PROPERTIES)
+            and (ifc_id := tool.Geometry.get_mesh_props(data).ifc_definition_id)
+            and ((item := tool.Ifc.get().by_id(ifc_id)).is_a("IfcRepresentationItem"))
+        ):
             return item
         return None
 
@@ -1221,8 +1210,6 @@ class Geometry(bonsai.core.tool.Geometry):
         cls, representation: ifcopenshell.entity_instance
     ) -> ifcopenshell.entity_instance:
         if representation.RepresentationType == "MappedRepresentation":
-            if not representation.Items:
-                return representation
             return cls.resolve_mapped_representation(representation.Items[0].MappingSource.MappedRepresentation)
         return representation
 
@@ -1822,7 +1809,7 @@ class Geometry(bonsai.core.tool.Geometry):
         item = tool.Ifc.get().by_id(props.ifc_definition_id)
         allowed_attributes = [
             a.name()
-            for a in item.wrapped_data.declaration().as_entity().all_attributes()
+            for a in item.declaration().as_entity().all_attributes()
             if a.type_of_attribute()._is("IfcLengthMeasure")
         ]
 

src/bonsai/bonsai/tool/model.py

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 from __future__ import annotations
 
@@ -79,7 +77,6 @@ if TYPE_CHECKING:
         BIMRoofProperties,
         BIMStairProperties,
         BIMSverchokProperties,
-        BIMWallProperties,
         BIMWindowProperties,
     )
 
@@ -101,10 +98,6 @@ class Model(bonsai.core.tool.Model):
     def get_stair_props(cls, obj: bpy.types.Object) -> BIMStairProperties:
         return obj.BIMStairProperties  # pyright: ignore[reportAttributeAccessIssue]
 
-    @classmethod
-    def get_wall_props(cls, obj: bpy.types.Object) -> BIMWallProperties:
-        return obj.BIMWallProperties  # pyright: ignore[reportAttributeAccessIssue]
-
     @classmethod
     def get_roof_props(cls, obj: bpy.types.Object) -> BIMRoofProperties:
         return obj.BIMRoofProperties  # pyright: ignore[reportAttributeAccessIssue]
@@ -319,8 +312,6 @@ class Model(bonsai.core.tool.Model):
     @classmethod
     def get_extrusion(cls, representation: ifcopenshell.entity_instance) -> Union[ifcopenshell.entity_instance, None]:
         """Return first found IfcExtrudedAreaSolid"""
-        if not representation.Items:
-            return None
         item = representation.Items[0]
         while True:
             if item.is_a("IfcExtrudedAreaSolid"):
@@ -813,57 +804,6 @@ class Model(bonsai.core.tool.Model):
                 items.append(item.FirstOperand)
         return booleans
 
-    @classmethod
-    def get_connected_slab_objs(cls, wall: ifcopenshell.entity_instance) -> list[bpy.types.Object]:
-        """Return Blender objects for slabs connected to wall via IfcRelConnectsElements(TOP)."""
-        result = []
-        for rel in wall.ConnectedFrom:
-            if rel.is_a("IfcRelConnectsElements") and rel.Description == "TOP":
-                slab_obj = tool.Ifc.get_object(rel.RelatingElement)
-                if slab_obj:
-                    result.append(slab_obj)
-        return result
-
-    @classmethod
-    def get_connected_wall_objs(cls, slab: ifcopenshell.entity_instance) -> list[bpy.types.Object]:
-        """Return Blender objects for LAYER2 walls connected to slab via IfcRelConnectsElements(TOP)."""
-        result = []
-        for rel in slab.ConnectedTo:
-            if rel.is_a("IfcRelConnectsElements") and rel.Description == "TOP":
-                wall_obj = tool.Ifc.get_object(rel.RelatedElement)
-                if wall_obj:
-                    result.append(wall_obj)
-        return result
-
-    @classmethod
-    def has_underside_connection(cls, element: ifcopenshell.entity_instance) -> bool:
-        """Return True if element has an IfcRelConnectsElements(TOP) relationship."""
-        return any(rel.is_a("IfcRelConnectsElements") and rel.Description == "TOP" for rel in element.ConnectedFrom)
-
-    @classmethod
-    def remove_wall_to_underside_booleans(cls, wall: ifcopenshell.entity_instance) -> None:
-        """Remove all IfcBooleanResult items previously added by extend_walls_to_underside."""
-        manual_booleans = cls.get_manual_booleans(wall)
-        if not manual_booleans:
-            return
-        ifc_file = tool.Ifc.get()
-        for b in manual_booleans:
-            sec = b.SecondOperand
-            if sec is None:
-                # The IfcPolygonalFaceSet was already deleted externally.  Splice the
-                # orphaned IfcBooleanResult out of the chain so the representation stays valid.
-                parents = list(ifc_file.get_inverse(b))
-                for parent in parents:
-                    if parent.is_a("IfcBooleanResult") and parent.FirstOperand == b:
-                        parent.FirstOperand = b.FirstOperand
-                    elif parent.is_a("IfcShapeRepresentation"):
-                        new_items = tuple((set(parent.Items) - {b}) | {b.FirstOperand})
-                        parent.Items = new_items
-                cls.unmark_manual_booleans(wall, [b.id()])
-                ifc_file.remove(b)
-            elif sec.is_a("IfcTessellatedFaceSet"):
-                tool.Geometry.remove_representation_item(sec, wall)
-
     @classmethod
     def get_manual_booleans(
         cls, element: ifcopenshell.entity_instance, representation: Optional[ifcopenshell.entity_instance] = None
@@ -876,8 +816,7 @@ class Model(bonsai.core.tool.Model):
             representation = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
             if not representation:
                 return []
-        all_chain_booleans = cls.get_booleans(element, representation)
-        booleans = [b for b in all_chain_booleans if b.id() in boolean_ids]
+        booleans = [b for b in cls.get_booleans(element, representation) if b.id() in boolean_ids]
         return booleans
 
     @classmethod
@@ -1366,8 +1305,8 @@ class Model(bonsai.core.tool.Model):
         return [obj for obj in tool.Blender.get_selected_objects() if tool.Ifc.get_entity(obj)]
 
     @classmethod
-    def has_selected_ifc_objects(cls, include_active: bool = True) -> bool:
-        return any(tool.Ifc.get_entity(obj) for obj in tool.Blender.get_selected_objects(include_active=include_active))
+    def has_selected_ifc_objects(cls) -> bool:
+        return any(tool.Ifc.get_entity(obj) for obj in tool.Blender.get_selected_objects())
 
     @classmethod
     def get_selected_mesh_objects(cls) -> list[bpy.types.Object]:
@@ -2440,15 +2379,12 @@ class Model(bonsai.core.tool.Model):
         clipping_bm = bmesh.new()
         vertex_map = {}
 
-        kept = 0
         for face in bm.faces:
             face.normal_update()
             normal = face.normal.to_4d()
             normal.w = 0
-            world_normal_z = (obj.matrix_world @ normal).z
-            if world_normal_z >= -0.5:
+            if (obj.matrix_world @ normal).z >= -0.5:
                 continue
-            kept += 1
             new_verts = []
             for vert in face.verts:
                 if not (new_vert := vertex_map.get(vert.index, None)):
@@ -2461,7 +2397,6 @@ class Model(bonsai.core.tool.Model):
             return
 
         bmesh.ops.recalc_face_normals(clipping_bm, faces=clipping_bm.faces)
-        clipping_bm.faces.ensure_lookup_table()
         return clipping_bm  # clipping_bm is in project units
 
     @classmethod
@@ -2475,53 +2410,17 @@ class Model(bonsai.core.tool.Model):
         min_z = min(zs)
         max_z = max(zs)
 
-        ifc_file = tool.Ifc.get()
-        builder = ifcopenshell.util.shape_builder.ShapeBuilder(ifc_file)
+        operand = None
+        if (z := max_z - min_z) and not np.isclose(z, 0.0):
+            builder = ifcopenshell.util.shape_builder.ShapeBuilder(tool.Ifc.get())
 
-        # Build one IfcPolygonalFaceSet clip solid per clipping face.
-        # Each solid uses a rectangle on the slope plane rather than the exact face
-        # footprint.  The original approach (exact footprint) caused a kissing-solid /
-        # boundary-coincidence bug when the operator is called twice for a ridge roof: the
-        # two slope solids share an exact ridge edge, and OCCT produces spurious extra
-        # vertices.  Extending each solid slightly past the ridge (by margin) creates a
-        # volumetric overlap instead of a kissing boundary — OCCT handles overlapping
-        # DIFFERENCE operands correctly.
-        margin = 1.0  # project units past the face edge — enough to ensure overlap at ridge
-        operands = []
-        for face in bm.faces:
-            face.normal_update()
-            normal = Vector(face.normal).normalized()
+            result = bmesh.ops.extrude_face_region(bm, geom=bm.faces)
+            extruded_verts = [elem for elem in result["geom"] if isinstance(elem, bmesh.types.BMVert)]
+            bmesh.ops.translate(bm, verts=extruded_verts, vec=(0, 0, z))
 
-            # Orthonormal basis spanning the slope plane.
-            ref = Vector((0, 0, 1)) if abs(normal.z) < 0.9 else Vector((1, 0, 0))
-            tangent1 = normal.cross(ref).normalized()
-            tangent2 = normal.cross(tangent1).normalized()
-
-            centroid = sum((v.co for v in face.verts), Vector()) / len(face.verts)
-
-            # Tight bounding rectangle in slope-plane coords, plus a small margin.
-            t1_coords = [(v.co - centroid).dot(tangent1) for v in face.verts]
-            t2_coords = [(v.co - centroid).dot(tangent2) for v in face.verts]
-            half1 = max(abs(c) for c in t1_coords) + margin
-            half2 = max(abs(c) for c in t2_coords) + margin
-
-            # Rectangle on the slope plane, extruded upward in wall-local Z.
-            clip_bm = bmesh.new()
-            v0 = clip_bm.verts.new(centroid + half1 * tangent1 + half2 * tangent2)
-            v1 = clip_bm.verts.new(centroid - half1 * tangent1 + half2 * tangent2)
-            v2 = clip_bm.verts.new(centroid - half1 * tangent1 - half2 * tangent2)
-            v3 = clip_bm.verts.new(centroid + half1 * tangent1 - half2 * tangent2)
-            bottom_face = clip_bm.faces.new([v0, v1, v2, v3])
-            result = bmesh.ops.extrude_face_region(clip_bm, geom=[bottom_face])
-            top_verts = [e for e in result["geom"] if isinstance(e, bmesh.types.BMVert)]
-            bmesh.ops.translate(clip_bm, verts=top_verts, vec=Vector((0, 0, max_z - min_z)))
-            clip_bm.verts.ensure_lookup_table()
-
-            clip_verts = [v.co for v in clip_bm.verts]
-            clip_faces = [[v.index for v in f.verts] for f in clip_bm.faces]
-            operand = builder.mesh(clip_verts, clip_faces)
-            clip_bm.free()
-            operands.append(operand)
+            verts = [v.co for v in bm.verts]
+            faces = [[v.index for v in p.verts] for p in bm.faces]
+            operand = builder.mesh(verts, faces)
 
         for extrusion in ifcopenshell.util.shape.get_base_extrusions(wall) or []:
             if extrusion.Position:
@@ -2538,9 +2437,9 @@ class Model(bonsai.core.tool.Model):
 
             extrusion.Depth = max_z / direction[2]
 
-            if operands:
+            if operand:
                 booleans = ifcopenshell.api.geometry.add_boolean(
-                    ifc_file, first_item=extrusion, second_items=operands
+                    tool.Ifc.get(), first_item=extrusion, second_items=[operand]
                 )
                 tool.Model.mark_manual_booleans(wall, booleans)
 

src/bonsai/bonsai/tool/parametric.py

@@ -1,460 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Registry + save-time auto-commit for parametric draft edits.
-
-Single source of truth: adding a new parametric element type is one entry in
-`Parametric.EDIT_TYPES`. Every consumer — save-time auto-commit, the
-finish/cancel chains in ``tool.Blender.Modifier``, the ``PointerProperty``
-attachment in ``bim/module/model/__init__.py``, and the per-type
-``GizmoPreferences<X>`` registration in ``bim/__init__.py`` — derives the
-class names, operator ``bl_idname``s, and predicates from the registry entry's
-short ``name`` token.
-
-Lives in ``tool/`` so both ``tool/`` (e.g. ``tool/blender.py``) and ``bim/``
-modules can consume it without crossing the layer boundary. The orchestration
-helpers (``commit_object_draft``, ``commit_pending_edits``) call
-``bpy.ops.bim.*`` operators by name, which is runtime dispatch through Blender
-rather than a Python import of ``bim/``.
-
-----------------------------------------------------------------------
-How to add a new parametric object
-----------------------------------------------------------------------
-
-End-to-end walkthrough for wiring a new IFC element type (e.g. ``IfcSlab``)
-into the gizmo-driven parametric edit framework. Numbered steps are
-**required** unless flagged OPTIONAL. Keep this section in sync with the
-implementation files it references — if a step's example code stops matching
-the real registration site, the step is out of date.
-
-STEP 1 — Add the registry entry (this file)
-    Append to `Parametric.EDIT_TYPES`::
-
-        ParametricObject("slab", has_non_editable_path=False),
-
-    The ``name`` token drives every derived identifier:
-    ``BIMSlabProperties``, ``bim.enable_editing_slab`` /
-    ``bim.finish_editing_slab`` / ``bim.cancel_editing_slab``, and the
-    ``slab`` field on ``GizmoPreferences``. Set ``has_non_editable_path=True``
-    if the modifier exposes no user-editable path (cf. door, window, stair).
-
-STEP 2 — Define the ``PropertyGroup`` (``bim/module/model/prop.py``)
-    Class name **must** be ``BIM<Name>Properties`` — capitalisation matches
-    `ParametricObject.props_attr`::
-
-        class BIMSlabProperties(bpy.types.PropertyGroup):
-            is_editing: BoolProperty(...)
-            # ... per-type draft fields, snapshots, mesh_dirty, etc. ...
-
-    The ``is_editing`` flag is the single field every consumer of the registry
-    expects.
-
-STEP 3 — Register the PropertyGroup class
-    Add it to the ``classes`` tuple in ``bim/module/model/__init__.py`` (near
-    the existing ``prop.BIM<X>Properties`` entries). The
-    ``bpy.types.Object.BIMSlabProperties`` attachment is automatic —
-    `Parametric.register_object_properties` loops the registry.
-
-STEP 4 — Implement the Enable / Finish / Cancel triad
-    In ``bim/module/model/slab.py``, define three ``bpy.types.Operator``
-    subclasses with the canonical ``bl_idname``\\s:
-
-        - ``EnableEditingSlab``  → ``bl_idname = "bim.enable_editing_slab"``
-        - ``FinishEditingSlab``  → ``bl_idname = "bim.finish_editing_slab"``
-        - ``CancelEditingSlab``  → ``bl_idname = "bim.cancel_editing_slab"``
-
-    **First, check if your new type fits one of the existing lifecycle
-    shapes** in `bonsai.bim.parametric_lifecycle`. If it does, inherit
-    the matching mixin and the triad collapses to ~25 lines total:
-
-        - ``FeatureModifierEditMixin`` — BBIM_<Type> pset with nested
-          ``lining_properties`` / ``panel_properties``; Finish via
-          ``update_<type>_modifier_representation`` →
-          ``ifcopenshell.api.feature``; Cancel via
-          ``switch_representation`` to the Body rep. Reference samples:
-          door (multi-object) and window (single-object).
-
-        - ``PathPreservingEditMixin`` — BBIM_<Type> pset whose ``path_data``
-          is preserved through edit; Finish via per-type
-          ``update_bbim_<type>_pset`` + ``update_<type>_modifier_ifc_data``;
-          Cancel rebuilds the bmesh preview. Reference samples: railing, roof.
-
-    If neither shape fits (the type needs validation-first lifecycle, an
-    explicit snapshot, delegate-to-sub-operators Finish, or a unique
-    post-Finish step) implement the triad standalone — see ``wall.py``
-    (validation/snapshot/delegate) or ``stair.py`` (raw pset JSON +
-    ``update_ifc_stair_props``) as references. Register all three in the
-    module's ``classes`` tuple.
-
-STEP 5 — Implement the gizmo group (same file)
-    Subclass ``BaseParametricGizmoGroup`` from
-    ``bim/module/drawing/gizmos.py``::
-
-        class GizmoSlabEdition(bpy.types.GizmoGroup, BaseParametricGizmoGroup):
-            bl_idname = "OBJECT_GGT_bim_slab_edition"
-
-            @classmethod
-            def is_element_type(cls, element):
-                return tool.Blender.Modifier.is_slab(element)
-
-            dimension_gizmo_props = [DimensionGizmoConfig(...)]
-
-    Register it in the ``classes`` tuple. The classmethod makes
-    ``tool.Blender.Modifier.is_slab(element)`` testable via the gizmo's
-    ``poll()``.
-
-STEP 6 — Add the element-type predicate (``tool/blender.py``)
-    Inside the ``Blender.Modifier`` class, alongside ``is_door`` / ``is_wall``::
-
-        @classmethod
-        def is_slab(cls, element: entity_instance) -> bool:
-            return tool.Pset.get_element_pset(element, "BBIM_Slab")
-
-    The method name **must** be ``is_<name>`` to match
-    `ParametricObject.name` — `Parametric.find_for_element`
-    looks it up by string.
-
-STEP 7 — OPTIONAL: typed property accessor (``tool/model.py``)
-    Convenience helper for call sites that statically know the IFC type::
-
-        @classmethod
-        def get_slab_props(cls, obj) -> BIMSlabProperties:
-            return obj.BIMSlabProperties
-
-    Call sites that work generically (registry-driven) can use
-    ``getattr(obj, feature.props_attr)`` directly and skip this step.
-
-STEP 8 — OPTIONAL: gizmo visibility preferences (``bim/ui.py``)
-    For per-gizmo show/hide toggles, define::
-
-        class GizmoPreferencesSlab(bpy.types.PropertyGroup):
-            length: BoolProperty(name="Length", default=True, ...)
-            # ... one BoolProperty per gizmo ...
-
-    Then add a matching field on ``GizmoPreferences``::
-
-        slab: bpy.props.PointerProperty(type=GizmoPreferencesSlab)
-
-    Do **not** add ``GizmoPreferencesSlab`` to the ``classes`` list in
-    ``bim/__init__.py`` — the registry-driven discovery in this module finds
-    it by name (``GizmoPreferences`` + capitalised registry token) and
-    registers it automatically.
-
-STEP 9 — OPTIONAL: pure geometry helpers (``core/model.py``)
-    Per-type math (collinearity checks, slope/displacement conversions,
-    intersection helpers) lives here. The hard rule: no ``bpy`` /
-    ``ifcopenshell`` imports at module load — wrap them in
-    ``if TYPE_CHECKING:`` blocks only. Lets the helpers be unit-tested
-    headless via ``pytest test/core/``.
-
-STEP 10 — Verify
-    From ``src/bonsai/``::
-
-        ruff check .
-        black --check .
-        pytest test/core/ -x -q
-        blender -b -P runpytest.py -- test/bim/ -x -q -m model
-
-    The Blender-backed lane runs a registry smoke test that iterates the
-    EDIT_TYPES list and asserts each entry's enable/finish/cancel operator
-    resolves to a registered ``bpy.ops.bim.*``, that ``bpy.types.Object``
-    carries the matching ``BIM<Name>Properties`` attribute, and that the
-    ``is_<name>`` predicate exists on ``tool.Blender.Modifier``. Forget any
-    of the steps above and that test fails with a precise pointer at
-    what's missing.
-
-    Then manually in Blender:
-
-    1. Enable Bonsai → create an instance of the new IFC type.
-    2. Run ``bim.enable_editing_<name>`` → confirm the gizmo group polls in
-       and the dimension handles appear.
-    3. Modify a draft field, save the file → confirm auto-commit fires
-       (watch the console for the ``parametric_commit`` log line).
-    4. Disable + re-enable the addon → no ``bpy_struct: unknown property
-       type`` errors in the console (validates the register/unregister
-       symmetry driven by the registry)."""
-
-from __future__ import annotations
-
-import re
-import traceback
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional
-
-import bpy
-
-import bonsai.core.tool
-import bonsai.tool as tool
-
-if TYPE_CHECKING:
-    from ifcopenshell import entity_instance
-
-
-# ``name`` must be a single ASCII lowercase token starting with a letter:
-# ``str.capitalize()`` only handles single-word names cleanly, so a compound
-# token like ``"curtain_wall"`` would derive ``"BIMCurtain_wallProperties"`` —
-# off the Bonsai naming convention and silently broken.
-_VALID_NAME_RE = re.compile(r"^[a-z][a-z0-9]*$")
-
-
-@dataclass(frozen=True)
-class ParametricObject:
-    """One parametric element type's draft + enable + finish + cancel triad.
-
-    The short ``name`` token ("door", "window", "stair", "railing", "roof",
-    "wall", …) drives every derived identifier: the ``BIM<Name>Properties``
-    attribute on ``bpy.types.Object`` and the ``bim.enable_editing_<name>`` /
-    ``bim.finish_editing_<name>`` / ``bim.cancel_editing_<name>`` operator
-    ``bl_idname``s. The ``name`` is validated at construction time — a
-    multi-word IFC type would silently mis-derive through
-    ``str.capitalize()`` and breaks the single-token assumption.
-
-    ``has_non_editable_path`` flags element types whose modifier exposes no
-    user-editable path (door, window, stair).
-
-    The paired runtime predicate ``tool.Blender.Modifier.is_<name>(element)``
-    is part of the registry contract: it MUST be **total** — accept any
-    IFC entity and return a boolean, never raise. The registry iterates
-    every predicate against the active element on save; a raising predicate
-    propagates upward and breaks the save path for *all* parametric types,
-    not just its own."""
-
-    name: str
-    has_non_editable_path: bool = False
-
-    def __post_init__(self) -> None:
-        if not _VALID_NAME_RE.match(self.name):
-            raise ValueError(
-                f"ParametricObject name {self.name!r} must be a single ASCII lowercase "
-                f"token matching {_VALID_NAME_RE.pattern!r}. ``str.capitalize()`` only "
-                f"handles single-word names — compound IFC types need an explicit "
-                f"naming override (not yet supported)."
-            )
-
-    @property
-    def props_attr(self) -> str:
-        return f"BIM{self.name.capitalize()}Properties"
-
-    @property
-    def enable_op(self) -> str:
-        return f"bim.enable_editing_{self.name}"
-
-    @property
-    def finish_op(self) -> str:
-        return f"bim.finish_editing_{self.name}"
-
-    @property
-    def cancel_op(self) -> str:
-        return f"bim.cancel_editing_{self.name}"
-
-    def is_editing(self, obj: bpy.types.Object) -> bool:
-        props = getattr(obj, self.props_attr, None)
-        return bool(props and getattr(props, "is_editing", False))
-
-
-class Parametric(bonsai.core.tool.Parametric):
-    EDIT_TYPES: list[ParametricObject] = [
-        ParametricObject("door", has_non_editable_path=True),
-        ParametricObject("window", has_non_editable_path=True),
-        ParametricObject("stair", has_non_editable_path=True),
-        ParametricObject("railing"),
-        ParametricObject("roof"),
-        ParametricObject("wall"),
-    ]
-
-    _geom_generation: int = 0
-
-    @classmethod
-    def get_geom_generation(cls) -> int:
-        return cls._geom_generation
-
-    @classmethod
-    def refresh_post_commit(cls) -> None:
-        """Post-commit hook for ``tool.Ifc.Operator``: re-syncs scene-level
-        ``BIMModelProperties`` (workspace tool header H/L/A fields) from current
-        IFC state and bumps the geometry generation counter so per-gizmo-group
-        caches keyed off it drop their stale entries on the next draw.
-
-        Why this exists: ``update_bim_tool_props`` was historically only wired
-        to the active-object msgbus, so in-place IFC mutations on the current
-        selection (S_E, C_E, change_extrusion_*, …) left the header showing
-        stale values until the user changed selection. Same shape of bug for
-        the wall gizmo cache: ``GizmoGroup.refresh()`` only fires on Blender's
-        own state-change events, not on every ``bpy.ops.bim.*`` mutation.
-
-        Cheap when nothing parametric is active — ``update_bim_tool_props``
-        early-returns when no Bonsai workspace tool is selected or the active
-        object isn't an IFC element."""
-        import bonsai.bim.handler  # late import: bim.handler imports tool.*
-
-        cls._geom_generation += 1
-        bonsai.bim.handler.update_bim_tool_props()
-        screen = getattr(bpy.context, "screen", None)
-        if screen is not None:
-            for area in screen.areas:
-                if area.type == "VIEW_3D":
-                    area.tag_redraw()
-
-    @classmethod
-    def find_by_name(cls, name: str) -> Optional[ParametricObject]:
-        return next((f for f in cls.EDIT_TYPES if f.name == name), None)
-
-    @classmethod
-    def find_for_element(cls, element: entity_instance) -> Optional[ParametricObject]:
-        """Return the registry entry whose IFC type predicate matches ``element``.
-
-        The per-type predicate lives at ``tool.Blender.Modifier.is_<name>``;
-        resolved here by attribute lookup at call time, which avoids a
-        ``tool.parametric`` ↔ ``tool.blender`` import cycle."""
-        for feature in cls.EDIT_TYPES:
-            predicate = getattr(tool.Blender.Modifier, f"is_{feature.name}", None)
-            if predicate is not None and predicate(element):
-                return feature
-        return None
-
-    @classmethod
-    def is_object_editing(cls, obj: bpy.types.Object) -> Optional[ParametricObject]:
-        for feature in cls.EDIT_TYPES:
-            if feature.is_editing(obj):
-                return feature
-        return None
-
-    @classmethod
-    def get_pending_edits(cls) -> list[tuple[bpy.types.Object, str]]:
-        """``(object, finish_operator_bl_idname)`` pairs for every object with
-        an in-progress parametric draft. The first registry match per object wins."""
-        return [(obj, feature.finish_op) for obj in bpy.data.objects if (feature := cls.is_object_editing(obj))]
-
-    @classmethod
-    def run_bim_op(cls, bl_idname: str) -> None:
-        """Invoke a ``bim.*`` operator by its ``bl_idname``.
-
-        Constraint enforced via ``assert``: the operator MUST be a
-        ``tool.Ifc.Operator`` subclass — its transaction wrap is what
-        makes the IFC mutation undo-aware. Direct ``bpy.ops.bim.*`` invocation
-        of a non-``Ifc.Operator`` would mutate IFC outside Bonsai's
-        transaction system."""
-        verb = bl_idname.removeprefix("bim.")
-        op_cls = getattr(bpy.types, f"BIM_OT_{verb}", None)
-        assert op_cls is not None and issubclass(
-            op_cls, tool.Ifc.Operator
-        ), f"{bl_idname!r} must be a registered tool.Ifc.Operator subclass for undo-safe IFC mutation"
-        getattr(bpy.ops.bim, verb)()
-
-    @classmethod
-    def commit_object_draft(cls, obj: bpy.types.Object, finish_op: str) -> bool:
-        """Run ``finish_op`` scoped to ``obj`` alone. Returns True on success, False if
-        the operator raised (with traceback printed to the console).
-
-        Both ``temp_override`` and ``view_layer.objects.active`` are set:
-        ``temp_override`` does not rebind ``objects.active``, and some finish
-        operators read it directly."""
-        view_layer = bpy.context.view_layer
-        original_active = view_layer.objects.active
-        try:
-            with bpy.context.temp_override(active_object=obj, selected_objects=[obj]):
-                view_layer.objects.active = obj
-                try:
-                    cls.run_bim_op(finish_op)
-                    return True
-                except Exception as e:
-                    print(f"Bonsai: commit of {obj.name!r} via {finish_op} failed: {e}")
-                    traceback.print_exc()
-                    return False
-        finally:
-            view_layer.objects.active = original_active
-
-    @classmethod
-    def commit_pending_edits(cls) -> tuple[int, list[bpy.types.Object]]:
-        """Run each pending draft's finish operator scoped to its object.
-
-        A per-object failure does not abort the loop — remaining drafts still
-        flush, otherwise the auto-commit would ship the exact silent-desync
-        it exists to prevent.
-
-        Each finish op wraps its own IFC transaction, so N pending drafts
-        produce N+1 undo entries (one per commit, plus the save). Ctrl+Z
-        walks back through commits individually — intentional, each commit
-        is reversible on its own."""
-        committed = 0
-        failed: list[bpy.types.Object] = []
-        for obj, finish_op in cls.get_pending_edits():
-            if cls.commit_object_draft(obj, finish_op):
-                committed += 1
-            else:
-                failed.append(obj)
-        return committed, failed
-
-    @classmethod
-    def commit_pending_edits_for_selection(
-        cls, names: Optional[tuple[str, ...]] = None
-    ) -> tuple[int, list[bpy.types.Object]]:
-        """Selection-scoped variant of `commit_pending_edits`. ``names``
-        filters which registry entries to consider — e.g. ``("wall",)`` to commit
-        only wall drafts among selected objects; ``None`` considers every type.
-
-        Used by multi-object operators (``bim.unjoin_walls``, ``bim.merge_wall``,
-        ``bim.extend_walls_to_wall`` etc.) that must run against committed IFC
-        state — running them with a wall whose draft hasn't been flushed leaves
-        stale gizmos pointing at obsolete IFC numbers."""
-        committed = 0
-        failed: list[bpy.types.Object] = []
-        for obj in tool.Blender.get_selected_objects():
-            feature = cls.is_object_editing(obj)
-            if feature is None:
-                continue
-            if names is not None and feature.name not in names:
-                continue
-            if cls.commit_object_draft(obj, feature.finish_op):
-                committed += 1
-            else:
-                failed.append(obj)
-        return committed, failed
-
-    @classmethod
-    def register_object_properties(cls, prop_module) -> None:
-        """Attach ``bpy.types.Object.BIM<Name>Properties`` for every registered
-        parametric type, looking up the matching ``PropertyGroup`` class on
-        ``prop_module``. Skips entries whose ``PropertyGroup`` class is absent."""
-        for feature in cls.EDIT_TYPES:
-            prop_cls = getattr(prop_module, feature.props_attr, None)
-            if prop_cls is None:
-                continue
-            setattr(bpy.types.Object, feature.props_attr, bpy.props.PointerProperty(type=prop_cls))
-
-    @classmethod
-    def unregister_object_properties(cls) -> None:
-        for feature in cls.EDIT_TYPES:
-            if hasattr(bpy.types.Object, feature.props_attr):
-                delattr(bpy.types.Object, feature.props_attr)
-
-    @classmethod
-    def iter_gizmo_preference_classes(cls, ui_module) -> list[type]:
-        """``GizmoPreferences<Name>`` classes that exist on ``ui_module`` for
-        every registry entry. Order matches `EDIT_TYPES`. Used by
-        ``bim/__init__.py`` to inject the per-type ``GizmoPreferences<X>``
-        classes at the correct point — before ``ui.GizmoPreferences``, which
-        references them via ``PointerProperty``."""
-        out: list[type] = []
-        for feature in cls.EDIT_TYPES:
-            gpref = getattr(ui_module, f"GizmoPreferences{feature.name.capitalize()}", None)
-            if gpref is not None:
-                out.append(gpref)
-        return out

src/bonsai/bonsai/tool/style.py

@@ -203,11 +203,6 @@ class Style(bonsai.core.tool.Style):
 
         available_props = props.bl_rna.properties.keys()
         for prop_blender, prop_ifc in STYLE_PROPS_MAP.items():
-            null_prop_name = f"is_{prop_blender}_null"
-            if null_prop_name in available_props and getattr(props, null_prop_name):
-                surface_style_data[prop_ifc] = None
-                continue
-
             class_prop_name = f"{prop_blender}_class"
 
             # get detailed color properties if available

src/bonsai/docs/guides/authoring/basic_modeling/creating_walls.rst

@@ -51,62 +51,6 @@ To use these tools:
 2. Use the appropriate shortcut or select the tool from the top bar.
 3. Follow the on-screen prompts or adjust parameters as needed.
 
-Interactive Parametric Editing
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Selected walls expose an in-viewport parametric edit mode that mirrors the door /
-window / stair pen-icon UI:
-
-1. Select a single wall. A pen (Edit Wall) icon appears next to the wall in the
-   3D viewport, and a matching ``Edit Wall`` button is available in the
-   ``Parametric Geometry`` tab of the N panel.
-2. Click the pen icon (or the panel button) to enter edit mode. Dimension
-   gizmos for length, height, slope (x-angle) and the layer offset baseline
-   appear around the wall.
-3. Drag any handle to update the value. Dragging only modifies the in-progress
-   draft — the IFC file is not touched until you commit, so dragging a length
-   handle through many intermediate values produces zero extra IFC entities.
-4. Click the green ✓ icon to commit; click the red ✗ to discard. Pressing the
-   ✓ icon on a wall that hasn't been dragged is a true byte-identical no-op —
-   the IFC file is unchanged.
-
-While editing, additional gizmos surface based on context:
-
-- **Cycle Baseline**: cycles the layer offset baseline (Exterior → Centreline →
-  Interior). Shift+click cycles in reverse.
-- **3D-cursor scissors**: appears when the 3D cursor sits on the wall axis;
-  clicking splits the wall at the cursor's projected X.
-- **3D-cursor extend (horizontal)**: appears when the 3D cursor sits beyond the
-  wall axis; clicking extends the wall to the cursor's projected X.
-- **3D-cursor extend (vertical)**: appears when the 3D cursor sits above /
-  below the wall; clicking extends the wall's height to the cursor's Z.
-- **Rotate 90°**: rotates the wall around its Z axis.
-- **Show / hide openings**: toggles opening fill visibility (doors and windows).
-
-When two walls are selected, the gizmo switches to a state-aware icon at their
-common point:
-
-- Already joined → an Unjoin icon at the shared corner.
-- Collinear (same axis line) → a Merge icon at the boundary midpoint.
-- Joinable corner → a Join icon at the floor + an Extend-To-Wall icon at the
-  active wall's top.
-
-When a wall and a slab (LAYER3 element) are selected, an Extend-Vertically icon
-appears at the wall's origin / slab elevation; clicking dispatches
-``bim.extend_walls_to_underside``.
-
-When a wall and a non-wall, non-slab object are selected, an Add-Opening icon
-appears above the wall at the other object's projected X.
-
-Auto-commit on save
-~~~~~~~~~~~~~~~~~~~
-
-Pressing Ctrl+S (or running ``bim.save_project``) while any wall is mid-edit
-flushes every pending parametric draft first — the same Apply-Wall-Edits the ✓
-icon performs, scoped per wall. The IFC saved on disk reflects the values the
-user dragged, not the snapshot taken when edit mode was entered. Each commit
-produces its own undo entry, so Ctrl+Z walks back through commits individually.
-
 Aligning Walls
 ^^^^^^^^^^^^^^
 

src/bonsai/docs/guides/development/maintenance.rst

@@ -61,8 +61,6 @@ When Blender ships with a new Python version:
      - What to update
    * - ``.github/workflows/ci-lint.yaml``
      - ``MIN_BLENDER_PY_VERSION``
-   * - ``.github/scripts/publish-bonsai-releases.py``
-     - ``CURRENT_PYTHON_VERSION``
    * - ``src/bonsai/Makefile``
      - ``SUPPORTED_PYVERSIONS``
    * - ``src/bonsai/scripts/dev_environment.py``
@@ -75,18 +73,6 @@ Notes:
 
 - Typically all packages are released at once using the same version schema
 - The ``README.md`` badges can serve as a visual reference for what versions have been released
-- Corrective Release (if needed after a standard release):
-
-  - Create a new branch from the release tag (e.g., from the ``ifcopenshell-0.8.5`` tag)
-  - Update ``VERSION`` with the ``-post1`` suffix (e.g., ``0.8.5-post1``, **not** ``.post1``)
-  - The hyphen is required for semantic versioning compliance; Blender will not process ``.post1`` suffixes correctly
-  - Follow the standard release process for the corrective version
-
-- Multiple Blender Python Versions:
-
-  - Blender does not allow multiple builds for the same platform with different Python versions (e.g., cannot have both ``bonsai_py311-0.8.5-windows-x64.zip`` and ``bonsai_py313-0.8.5-windows-x64.zip``)
-  - Workaround: publish different Python versions as different extension versions (e.g., py313 as ``0.8.5`` and py311 as ``0.8.5-post1``)
-  - Set the maximum Blender version on the Blender extensions platform UI to prevent conflicts (e.g., set max version ``5.1.0`` for ``0.8.5-post1``, which restricts it to versions below 5.1.0)
 
 Things to update:
 
@@ -110,13 +96,10 @@ Things to update:
 - ``.github/workflows/ci-ifcsverchok.yml`` - release ifcsverchok Blender add-on in GitHub releases
 - ``.github/workflows/ci-ifctester-pypi.yml`` - release `ifctester <https://pypi.org/project/ifctester/>`_ to PyPI
 - ``.github/workflows/ci-pyodide-wasm-release.yml`` - release pyodide wasm wheel to `wasm-wheels <https://github.com/IfcOpenShell/wasm-wheels>`_
-- ``.github/workflows/publish-bonsai-releases.yml`` - publish Bonsai Blender extension to `Blender extensions platform <https://extensions.blender.org/add-ons/bonsai/>`_
-
-  - ❗ Requires ``BLENDER_EXTENSIONS_TOKEN`` secret to be set - ❗ not yet configured
-
+- Release Bonsai Blender extension - zip files from ci-bonsai.yml releases should be uploaded manually to `Blender extensions platform <https://extensions.blender.org/add-ons/bonsai/>`_
 - Publishing documentation and websites (see `website <https://github.com/IfcOpenShell/website>`_ repository):
 
   - `ifcopenshell-docs.yml` - builds and publishes IfcOpenShell documentation to `docs.ifcopenshell.org <https://docs.ifcopenshell.org>`_ (`ifcopenshell_org_docs <https://github.com/IfcOpenShell/ifcopenshell_org_docs>`_ repo)
   - `bonsai-docs.yml` - builds and publishes Bonsai documentation to `docs.bonsaibim.org <https://docs.bonsaibim.org>`_ (`bonsaibim_org_docs <https://github.com/IfcOpenShell/bonsaibim_org_docs>`_ repo)
-  - `publish-websites.yml` - publishes `bonsaibim.org <https://bonsaibim.org>`_ (`bonsaibim_org_static_html <https://github.com/IfcOpenShell/bonsaibim_org_static_html>`_ repo) and `ifcopenshell.org <https://ifcopenshell.org>`_ (`ifcopenshell_org_static_html <https://github.com/IfcOpenShell/ifcopenshell_org_static_html>`_ repo)
+  - `main.yml` - publishes `bonsaibim.org <https://bonsaibim.org>`_ (`bonsaibim_org_static_html <https://github.com/IfcOpenShell/bonsaibim_org_static_html>`_ repo) and `ifcopenshell.org <https://ifcopenshell.org>`_ (`ifcopenshell_org_static_html <https://github.com/IfcOpenShell/ifcopenshell_org_static_html>`_ repo)
 - ``VERSION`` to the release version - **UPDATE THIS LAST** as all workflows above typically depend on it to set the version correctly

src/bonsai/docs/reference/project_overview/project_info.rst

@@ -58,7 +58,7 @@ Fields
     Class** based on the IFC Schema version.
 
 **Unit System**
-  Choose between metric and imperial units of measurement when creating a project. Project data is stored in this Unit System and displayed according to e.g. Length Unit, Area Unit, Volume Unit. Properly changing the Unit System after project creation requires conversion. See `Blender Manual : Scene Properties : Units <https://docs.blender.org/manual/en/latest/scene_layout/scene/properties.html#units>`_ for a description of changing the display units e.g. from Feet to Adaptive (enable Separate Units option) for Feet-and-Inches.
+  Choose between metric and imperial units of measurement when creating a project.
 
 **Length Unit**
   Depending on the unit system, choose the default unit to be used for all length measurements. Lengths are used for moving objects around in the 3D scene, as well as lengths, widths, height, and depth quantity take-off data.

src/bonsai/runpytest.py

@@ -17,46 +17,18 @@
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Requires pytest installed under blender.
+Requires pytest installed under blender
 
-Usage:
-    blender -b -P runpytest.py -- ARGS
-
-Alternative (when the calling shell strips or reorders the ``--`` separator
-before it reaches Blender — observed with some PowerShell / wrapper-script
-invocations on Windows): pass the same pytest args via the
-``BONSAI_TEST_ARGS`` environment variable as a single shell-quoted string
-and invoke without ``--``::
-
-    $env:BONSAI_TEST_ARGS = "test/bim/ -x -q"
-    blender -b -P runpytest.py
+Usage: `blender -b -P runpytest.py -- ARGS`
 """
 
-import os
-import shlex
 import sys
 
 import pytest
 
 argv = [__file__]
 
-env_args = os.environ.get("BONSAI_TEST_ARGS", "")
-if env_args:
-    # POSIX-style quoting works on all three OSes — env var values are
-    # literal strings (no shell evaluation when Python reads them), and
-    # POSIX quoting (``'foo "bar baz" qux'`` → three tokens, quotes stripped)
-    # matches what most docs and examples use.
-    argv += shlex.split(env_args)
-    # On the env-var path the args never appear in Blender's argv at all,
-    # so any pytest plugin that reads ``sys.argv`` directly (instead of
-    # going through pytest's API) would otherwise see only Blender's own
-    # ``-b -P runpytest.py`` and miss the test args entirely. Shadow argv
-    # so those plugins see the pytest-shaped view they expect.
-    sys.argv = list(argv)
-elif "--" in sys.argv:
-    # The traditional path: Blender forwards everything after ``--`` to the
-    # script via ``sys.argv``. ``sys.argv`` is deliberately left as Blender
-    # set it — pre-existing behavior, preserved.
+if "--" in sys.argv:
     i = sys.argv.index("--")
     argv += sys.argv[i + 1 :]
 

src/bonsai/test/bim/feature/geometry.feature

@@ -285,32 +285,6 @@ Scenario: Override duplicate move - without active IFC data
     Then the object "Cube" exists
     And the object "Cube.001" exists
 
-Scenario: Override duplicate move - non-IFC objects inside an IFC project
-    Given an empty IFC project
-    And I add a cube
-    And the object "Cube" is selected
-    When I duplicate the selected objects
-    Then the object "Cube" exists
-    And the object "Cube.001" exists
-    And the object "Cube.001" is selected
-
-Scenario: Override duplicate move - mixed IFC and non-IFC selection
-    Given an empty IFC project
-    And I add a cube
-    And the object "Cube" is selected
-    And I look at the "Class" panel
-    And I set the "Products" property to "IfcElement"
-    And I set the "Class" property to "IfcWall"
-    And I click "Assign IFC Class"
-    And I add a cube
-    And the object "IfcWall/Cube" is selected
-    And additionally the object "Cube" is selected
-    When I duplicate the selected objects
-    Then the object "IfcWall/Cube.001" exists
-    And the object "IfcWall/Cube.001" is selected
-    And the object "Cube.001" exists
-    And the object "Cube.001" is selected
-
 Scenario: Override duplicate move - with active IFC data
     Given an empty IFC project
     And I add a cube

src/bonsai/test/bim/feature/model.feature

@@ -673,129 +673,6 @@ Scenario: Create door type based on door modifier, add an occurrence of it and e
     And I press "bim.finish_editing_door()"
     Then nothing happens
 
-Scenario: Saving with a door mid-edit auto-commits the draft value to the IFC pset
-    Given an empty IFC project
-    And I trigger "Add Element"
-    And I set the "Class" property to "IfcDoorType"
-    And I set the "Predefined Type" property to "DOOR"
-    And I set the "Representation" property to "Door"
-    When I click "OK"
-    And I press "bim.add_occurrence"
-    And I press "bim.enable_editing_door()"
-    And I set "active_object.BIMDoorProperties.overall_height" to "2.5"
-    Then "active_object.BIMDoorProperties.is_editing" is "True"
-    When I press "bim.save_project(filepath='{temp_project_path}', should_save_as=True)"
-    Then "active_object.BIMDoorProperties.is_editing" is "False"
-    And the variable "saved_height" is "__import__('json').loads(ifcopenshell.util.element.get_pset({ifc}.by_type('IfcDoor')[0], 'BBIM_Door', 'Data'))['overall_height']"
-    And the variable "saved_height" equals "2.5"
-
-Scenario: Saving with no parametric edits in progress leaves the door pset unchanged
-    Given an empty IFC project
-    And I trigger "Add Element"
-    And I set the "Class" property to "IfcDoorType"
-    And I set the "Predefined Type" property to "DOOR"
-    And I set the "Representation" property to "Door"
-    When I click "OK"
-    And I press "bim.add_occurrence"
-    And the variable "pre_save_height" is "__import__('json').loads(ifcopenshell.util.element.get_pset({ifc}.by_type('IfcDoor')[0], 'BBIM_Door', 'Data'))['overall_height']"
-    When I press "bim.save_project(filepath='{temp_project_path}', should_save_as=True)"
-    Then the variable "post_save_height" is "__import__('json').loads(ifcopenshell.util.element.get_pset({ifc}.by_type('IfcDoor')[0], 'BBIM_Door', 'Data'))['overall_height']"
-    And the variable "post_save_height" equals "{pre_save_height}"
-
-Scenario: Saving with a wall mid-edit auto-commits the draft to IFC
-    Given an empty IFC project
-    And I add a cube
-    And the object "Cube" is selected
-    And I set "scene.BIMRootProperties.ifc_product" to "IfcElementType"
-    And I set "scene.BIMRootProperties.ifc_class" to "IfcWallType"
-    And I press "bim.assign_class"
-    And I set "scene.BIMModelProperties.ifc_class" to "IfcWallType"
-    And the variable "cube" is "{ifc}.by_type('IfcWallType')[0].id()"
-    And I set "scene.BIMModelProperties.relating_type_id" to "{cube}"
-    And I press "bim.add_occurrence"
-    And the object "IfcWall/Wall" is selected
-    And I press "bim.enable_editing_wall()"
-    Then "active_object.BIMWallProperties.is_editing" is "True"
-    When I press "bim.save_project(filepath='{temp_project_path}', should_save_as=True)"
-    Then "active_object.BIMWallProperties.is_editing" is "False"
-
-Scenario: Enabling and finishing a wall edit with no drag is a no-op
-    Given an empty IFC project
-    And I add a cube
-    And the object "Cube" is selected
-    And I set "scene.BIMRootProperties.ifc_product" to "IfcElementType"
-    And I set "scene.BIMRootProperties.ifc_class" to "IfcWallType"
-    And I press "bim.assign_class"
-    And I set "scene.BIMModelProperties.ifc_class" to "IfcWallType"
-    And the variable "cube" is "{ifc}.by_type('IfcWallType')[0].id()"
-    And I set "scene.BIMModelProperties.relating_type_id" to "{cube}"
-    And I press "bim.add_occurrence"
-    And the object "IfcWall/Wall" is selected
-    And the variable "entity_count_before" is "len(list({ifc}))"
-    When I press "bim.enable_editing_wall()"
-    And I press "bim.finish_editing_wall()"
-    Then "active_object.BIMWallProperties.is_editing" is "False"
-    And "len(list({ifc}))" is "{entity_count_before}"
-
-Scenario: Cancelling a wall edit clears is_editing
-    Given an empty IFC project
-    And I add a cube
-    And the object "Cube" is selected
-    And I set "scene.BIMRootProperties.ifc_product" to "IfcElementType"
-    And I set "scene.BIMRootProperties.ifc_class" to "IfcWallType"
-    And I press "bim.assign_class"
-    And I set "scene.BIMModelProperties.ifc_class" to "IfcWallType"
-    And the variable "cube" is "{ifc}.by_type('IfcWallType')[0].id()"
-    And I set "scene.BIMModelProperties.relating_type_id" to "{cube}"
-    And I press "bim.add_occurrence"
-    And the object "IfcWall/Wall" is selected
-    And I press "bim.enable_editing_wall()"
-    When I press "bim.cancel_editing_wall()"
-    Then "active_object.BIMWallProperties.is_editing" is "False"
-
-Scenario: Wall parametric edit works on IFC2X3 projects
-    Given an empty IFC2X3 project
-    And I add a cube
-    And the object "Cube" is selected
-    And I set "scene.BIMRootProperties.ifc_product" to "IfcElementType"
-    And I set "scene.BIMRootProperties.ifc_class" to "IfcWallType"
-    And I press "bim.assign_class"
-    And I set "scene.BIMModelProperties.ifc_class" to "IfcWallType"
-    And the variable "cube" is "{ifc}.by_type('IfcWallType')[0].id()"
-    And I set "scene.BIMModelProperties.relating_type_id" to "{cube}"
-    And I press "bim.add_occurrence"
-    And the object "IfcWall/Wall" is selected
-    When I press "bim.enable_editing_wall()"
-    Then "active_object.BIMWallProperties.is_editing" is "True"
-    When I press "bim.finish_editing_wall()"
-    Then "active_object.BIMWallProperties.is_editing" is "False"
-
-Scenario: Rotate a wall 90° via bim.rotate_wall_90
-    Given an empty IFC project
-    And I load the demo construction library
-    And I set "scene.BIMModelProperties.ifc_class" to "IfcWallType"
-    And the variable "element_type" is "[e for e in {ifc}.by_type('IfcWallType') if e.Name == 'WAL100'][0].id()"
-    And I set "scene.BIMModelProperties.relating_type_id" to "{element_type}"
-    And I press "bim.add_occurrence"
-    And the object "IfcWall/Wall" is selected
-    When I press "bim.rotate_wall_90()"
-    Then the object "IfcWall/Wall" dimensions are "1,0.1,3"
-    And the object "IfcWall/Wall" bottom left corner is at "0,0,0"
-    And the object "IfcWall/Wall" top right corner is at "-0.1,1,3"
-
-Scenario: Splitting a wall with another wall mid-edit commits the pending edit first
-    Given an empty IFC project
-    And I load the demo construction library
-    And I set "scene.BIMModelProperties.ifc_class" to "IfcWallType"
-    And the variable "element_type" is "[e for e in {ifc}.by_type('IfcWallType') if e.Name == 'WAL100'][0].id()"
-    And I set "scene.BIMModelProperties.relating_type_id" to "{element_type}"
-    And I press "bim.add_occurrence"
-    And the object "IfcWall/Wall" is selected
-    And I press "bim.enable_editing_wall()"
-    Then "active_object.BIMWallProperties.is_editing" is "True"
-    When I press "bim.split_wall()"
-    Then "active_object.BIMWallProperties.is_editing" is "False"
-
 Scenario: Create a door, undo and create a new door
     Given an empty IFC project
     And I prepare to undo

src/bonsai/test/bim/module/drawing/test_dimension_gizmo_priority.py

@@ -1,100 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Regression guard: overlapping distance gizmos must let the smaller one win.
-
-When two ``GizmoDimension`` instances overlap on screen (e.g. a short dimension
-nested inside a longer one along the same axis), the longer one's hit box fully
-contains the shorter one's. Without a depth bias the longer one wins the GPU
-select tie-break and the shorter one becomes unreachable.
-
-``GizmoDimension.set_dimension_length`` writes ``select_bias = -dimension_length``
-so the smaller one writes a higher (less-negative) bias and wins. The longer one
-stays clickable at its exposed ends regardless of bias.
-
-We call ``set_dimension_length`` as an unbound method on a ``SimpleNamespace``
-fake ``self``. Its body only *writes* attributes (``_display_value``,
-``_dimension_length``, ``select_bias``), so it doesn't need a real
-``bpy.types.Gizmo`` instance — those only exist inside a registered
-``GizmoGroup`` and aren't constructible in a headless test."""
-
-import types
-from types import SimpleNamespace
-
-import bpy
-import pytest
-
-from bonsai.bim.module.drawing.gizmos import GizmoDimension
-
-pytestmark = pytest.mark.drawing
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    if not isinstance(bpy, types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-def test_smaller_dimension_wins_select_bias():
-    small = SimpleNamespace()
-    large = SimpleNamespace()
-    GizmoDimension.set_dimension_length(small, 0.077)
-    GizmoDimension.set_dimension_length(large, 0.109)
-    assert small.select_bias > large.select_bias
-
-
-@pytest.mark.parametrize(
-    "lengths",
-    [
-        [0.0, 0.05, 0.077, 0.109, 1.0, 5.0, 10.0],
-        [0.001, 0.5, 2.5, 100.0, 9999.0],
-    ],
-)
-def test_select_bias_is_non_increasing_in_length(lengths):
-    """A monotonic mapping is all Blender's GPU select needs to break the tie."""
-    biases = []
-    for length in lengths:
-        gizmo = SimpleNamespace()
-        GizmoDimension.set_dimension_length(gizmo, length)
-        biases.append(gizmo.select_bias)
-    for prev, curr in zip(biases, biases[1:]):
-        assert prev >= curr, f"select_bias must be non-increasing in length, got {biases}"
-
-
-def test_negative_length_uses_absolute_value_for_bias():
-    """Negative dimension values (e.g. inverted angles) clamp to abs() for hit-box scaling;
-    select_bias follows the same clamped magnitude so signed-direction gizmos still
-    obey the smaller-wins rule against their positive-sided peers."""
-    positive = SimpleNamespace()
-    negative = SimpleNamespace()
-    GizmoDimension.set_dimension_length(positive, 0.5)
-    GizmoDimension.set_dimension_length(negative, -0.5)
-    assert positive.select_bias == negative.select_bias
-
-
-def test_nan_and_inf_length_falls_back_to_zero_bias():
-    """Invalid inputs are coerced to 0.0 before the bias is written, so a malformed
-    update can't push a gizmo arbitrarily far forward or backward in the select buffer."""
-    import math
-
-    for bad in (math.nan, math.inf, -math.inf, "not a number"):
-        gizmo = SimpleNamespace()
-        GizmoDimension.set_dimension_length(gizmo, bad)
-        assert gizmo.select_bias == 0.0

src/bonsai/test/bim/module/drawing/test_gizmos.py

@@ -1,54 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-import types
-from types import SimpleNamespace
-
-import bpy
-import pytest
-
-from bonsai.bim.module.drawing.gizmos import DimensionGizmoConfig
-
-pytestmark = pytest.mark.drawing
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    if not isinstance(bpy, types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-def test_text_formatter_defaults_to_none():
-    config = DimensionGizmoConfig(attr_name="length", axis=(1, 0, 0))
-    assert config.text_formatter is None
-
-
-def test_text_formatter_field_stores_callable():
-    formatter = lambda props, value: f"{value:.2f}m"  # noqa: E731
-    config = DimensionGizmoConfig(attr_name="length", axis=(1, 0, 0), text_formatter=formatter)
-    assert config.text_formatter is not None
-    assert callable(config.text_formatter)
-
-
-def test_text_formatter_receives_props_and_value():
-    formatter = lambda props, value: f"{props.label}={value}"  # noqa: E731
-    config = DimensionGizmoConfig(attr_name="length", axis=(1, 0, 0), text_formatter=formatter)
-    props = SimpleNamespace(label="L")
-    assert config.text_formatter(props, 3.14) == "L=3.14"

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

@@ -1,19 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.

src/bonsai/test/bim/module/model/test_stair_gizmos.py

@@ -1,135 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Regression guard for the stair icon billboard fix.
-
-Before the fix, ``set_icon_gizmo_position`` in ``bim.module.drawing.gizmos``
-composed ``mw @ (Translation @ billboard_rot @ Scale)``, which applied the
-stair's world rotation on top of the billboard rotation. The result was
-icons (validate / cancel / lock / +/- / cycle / tread_lock) drawn edge-on
-to the camera for any stair rotated in plan — effectively unclickable.
-
-The fix routes through ``billboarded_at(world_pos, billboard_rot, scale)``,
-which computes ``Translation(world_pos) @ billboard_rot @ Scale`` — the
-object's rotation is folded into the translation only, never the rotation."""
-
-import math
-import types
-
-import bpy
-import pytest
-
-pytestmark = pytest.mark.model
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    if not isinstance(bpy, types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-def _rotation_close(a, b, tol: float = 1e-6) -> bool:
-    for row_a, row_b in zip(a, b):
-        for va, vb in zip(row_a, row_b):
-            if abs(va - vb) > tol:
-                return False
-    return True
-
-
-@pytest.mark.parametrize("angle_deg", [0, 30, 45, 90, 135, 217])
-def test_billboarded_at_rotation_is_pure_billboard(angle_deg):
-    """Object rotation must not leak into the gizmo's rotation part."""
-    from mathutils import Matrix, Vector
-
-    from bonsai.bim.module.drawing.gizmos import billboarded_at
-
-    mw = Matrix.Rotation(math.radians(angle_deg), 4, "Z") @ Matrix.Translation((3, 4, 5))
-    billboard_rot = Matrix.Rotation(math.radians(30), 4, "X")
-
-    world_pos = mw @ Vector((1, 0, 2))
-    result = billboarded_at(world_pos, billboard_rot, scale=0.5)
-
-    # The rotation part of result, after stripping the 0.5 uniform scale,
-    # must equal billboard_rot — no contribution from mw's rotation.
-    rotation_part = result.to_3x3() * 2.0
-    assert _rotation_close(rotation_part.to_4x4(), billboard_rot)
-
-
-def test_billboarded_at_translation_is_world_pos():
-    """Translation lands exactly at the world-space target."""
-    from mathutils import Matrix, Vector
-
-    from bonsai.bim.module.drawing.gizmos import billboarded_at
-
-    world_pos = Vector((1.23, 4.56, 7.89))
-    result = billboarded_at(world_pos, Matrix.Identity(4), scale=0.5)
-    assert (result.translation - world_pos).length < 1e-6
-
-
-def test_set_icon_gizmo_position_does_not_apply_object_rotation():
-    """End-to-end: the helper used by every stair icon (and shared with all
-    parametric gizmo groups) must produce a matrix whose rotation part is
-    billboard_rot, not mw_rotation @ billboard_rot. This is the exact bug
-    that left stair icons edge-on to the camera."""
-    from mathutils import Matrix, Vector
-
-    from bonsai.bim.module.drawing.gizmos import (
-        BaseParametricGizmoGroup,
-        billboarded_at,
-    )
-
-    # Same inputs as the real call site (stair.py:747-765), but we drive the
-    # helper directly so we don't need a registered GizmoGroup. We bind a
-    # stand-in `get_gizmo_if_visible` that returns a tiny mock; the helper's
-    # observable output is the matrix_basis it assigns.
-    captured = {}
-
-    class _GizmoStub:
-        matrix_basis = Matrix.Identity(4)
-
-    stub = _GizmoStub()
-
-    def _fake_get(name):
-        captured["name"] = name
-        return stub
-
-    # Bind the helper to a throwaway instance so `self.get_gizmo_if_visible`
-    # resolves to our stub without registering a real GizmoGroup with Blender.
-    fake_self = types.SimpleNamespace(get_gizmo_if_visible=_fake_get)
-    mw = Matrix.Rotation(math.radians(45), 4, "Z") @ Matrix.Translation((3, 4, 5))
-    billboard_rot = Matrix.Rotation(math.radians(30), 4, "X")
-    local_pos = Vector((1, 0, 2))
-    BaseParametricGizmoGroup.set_icon_gizmo_position(
-        fake_self,
-        "validate_gizmo",
-        mw=mw,
-        x=local_pos.x,
-        y=local_pos.y,
-        z=local_pos.z,
-        billboard_rot=billboard_rot,
-        scale=0.5,
-    )
-
-    expected = billboarded_at(mw @ local_pos, billboard_rot, 0.5)
-
-    assert captured["name"] == "validate_gizmo"
-    for row_a, row_b in zip(stub.matrix_basis, expected):
-        for va, vb in zip(row_a, row_b):
-            assert abs(va - vb) < 1e-6

src/bonsai/test/bim/module/model/test_wall_gizmos.py

@@ -1,181 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Unit tests for the poll() preconditions of wall billboarding gizmo groups.
-
-These tests patch ``tool.Blender`` / ``tool.Ifc`` / ``tool.Model`` so the poll
-logic can be exercised without a real IFC fixture. Each test pins one of the
-gates ``poll()`` walks, so any silent regression in the gate order or in the
-LAYER3-active / LAYER2-other contract is caught by a dedicated assertion."""
-
-import types
-from types import SimpleNamespace
-from unittest.mock import patch
-
-import bpy
-import pytest
-
-pytestmark = pytest.mark.wall
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    if not isinstance(bpy, types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-def _make_context(active, selected):
-    """Build a minimal ``context`` stub with the two attributes ``poll()`` reads."""
-    return SimpleNamespace(active_object=active, selected_objects=list(selected))
-
-
-def _patch_tools(prefs_on, selected, active_element, other_element, active_usage, other_usage):
-    """Return a stack of patches that simulate one selection / IFC state for poll().
-
-    ``prefs.gizmos.draw_gizmos_in_3d_viewport`` is the top-level toggle. The
-    selection set, the IFC entity lookup, and the usage-type lookup are stubbed
-    so the test only depends on the predicate ordering in poll()."""
-    prefs = SimpleNamespace(gizmos=SimpleNamespace(draw_gizmos_in_3d_viewport=prefs_on))
-
-    entity_map = {}
-    usage_map = {}
-    # active_element/other_element are matched by object identity from the selected set
-    if len(selected) == 2:
-        entity_map[id(selected[0])] = active_element
-        entity_map[id(selected[1])] = other_element
-        usage_map[id(active_element)] = active_usage
-        usage_map[id(other_element)] = other_usage
-
-    def get_entity(obj):
-        return entity_map.get(id(obj))
-
-    def get_usage_type(element):
-        return usage_map.get(id(element))
-
-    from bonsai import tool
-
-    return [
-        patch.object(tool.Blender, "get_addon_preferences", return_value=prefs),
-        patch.object(tool.Blender, "get_selected_objects", return_value=set(selected)),
-        patch.object(tool.Ifc, "get_entity", side_effect=get_entity),
-        patch.object(tool.Model, "get_usage_type", side_effect=get_usage_type),
-    ]
-
-
-def _run_poll(prefs_on, active_is_in_selected, len_override, active_usage, other_usage, active_has_entity=True):
-    from bonsai.bim.module.model.wall import GizmoWallExtendVertically
-
-    slab_obj = object()
-    wall_obj = object()
-    active = slab_obj if active_is_in_selected else object()
-    if len_override is None:
-        selected = [slab_obj, wall_obj]
-    else:
-        selected = [object() for _ in range(len_override)]
-        if active_is_in_selected and selected:
-            active = selected[0]
-
-    slab_element = object() if active_has_entity else None
-    wall_element = object()
-
-    patches = _patch_tools(prefs_on, selected, slab_element, wall_element, active_usage, other_usage)
-    for p in patches:
-        p.start()
-    try:
-        return GizmoWallExtendVertically.poll(_make_context(active, selected))
-    finally:
-        for p in patches:
-            p.stop()
-
-
-def test_poll_accepts_layer3_active_with_layer2_other():
-    assert (
-        _run_poll(
-            prefs_on=True, active_is_in_selected=True, len_override=None, active_usage="LAYER3", other_usage="LAYER2"
-        )
-        is True
-    )
-
-
-def test_poll_rejects_when_gizmo_toggle_off():
-    assert (
-        _run_poll(
-            prefs_on=False, active_is_in_selected=True, len_override=None, active_usage="LAYER3", other_usage="LAYER2"
-        )
-        is False
-    )
-
-
-def test_poll_rejects_when_selection_count_is_not_two():
-    assert (
-        _run_poll(
-            prefs_on=True, active_is_in_selected=True, len_override=3, active_usage="LAYER3", other_usage="LAYER2"
-        )
-        is False
-    )
-    assert (
-        _run_poll(
-            prefs_on=True, active_is_in_selected=True, len_override=1, active_usage="LAYER3", other_usage="LAYER2"
-        )
-        is False
-    )
-
-
-def test_poll_rejects_when_active_has_no_ifc_entity():
-    assert (
-        _run_poll(
-            prefs_on=True,
-            active_is_in_selected=True,
-            len_override=None,
-            active_usage="LAYER3",
-            other_usage="LAYER2",
-            active_has_entity=False,
-        )
-        is False
-    )
-
-
-def test_poll_rejects_when_active_is_not_layer3():
-    # A LAYER2 active (wall) must NOT trigger this gizmo — the wall-join gizmo
-    # owns that case, and extend_walls_to_underside expects the slab to be active.
-    assert (
-        _run_poll(
-            prefs_on=True, active_is_in_selected=True, len_override=None, active_usage="LAYER2", other_usage="LAYER2"
-        )
-        is False
-    )
-    # Active with no usage at all (generic mesh, e.g. an opening blocker) is also rejected.
-    assert (
-        _run_poll(prefs_on=True, active_is_in_selected=True, len_override=None, active_usage=None, other_usage="LAYER2")
-        is False
-    )
-
-
-def test_poll_rejects_when_other_is_not_layer2_wall():
-    assert (
-        _run_poll(
-            prefs_on=True, active_is_in_selected=True, len_override=None, active_usage="LAYER3", other_usage="LAYER3"
-        )
-        is False
-    )
-    assert (
-        _run_poll(prefs_on=True, active_is_in_selected=True, len_override=None, active_usage="LAYER3", other_usage=None)
-        is False
-    )

src/bonsai/test/bim/module/model/test_wall_header_refresh.py

@@ -1,87 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Regression tests for the post-IFC-commit refresh path that re-syncs the
-workspace tool header (``BIMModelProperties``) and invalidates the per-wall
-gizmo geometry cache.
-
-Bug repro before the fix: hotkey operators that edited the active wall in
-place (``bpy.ops.bim.hotkey(hotkey="S_E")`` / ``"C_E"``) mutated IFC but never
-fired ``active_object_callback`` (no selection change), so the header H/L/A
-fields and the gizmo cache both kept showing stale values. ``refresh_ui_data``
-ran, but it never resynced ``BIMModelProperties`` and never invalidated the
-per-gizmo-group geometry cache. The fix wires both refreshes through
-``tool.Parametric.refresh_post_commit`` and calls it from every
-``tool.Ifc.Operator`` epilogue."""
-
-import types
-from unittest.mock import patch
-
-import bpy
-import pytest
-
-pytestmark = pytest.mark.wall
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    if not isinstance(bpy, types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-def test_refresh_post_commit_bumps_generation_and_resyncs_header():
-    """``refresh_post_commit`` must bump the generation counter and call
-    ``update_bim_tool_props`` so the workspace tool header re-syncs from IFC."""
-    import bonsai.bim.handler as handler
-    from bonsai import tool
-
-    before = tool.Parametric.get_geom_generation()
-    with patch.object(handler, "update_bim_tool_props") as mock_resync:
-        tool.Parametric.refresh_post_commit()
-    assert tool.Parametric.get_geom_generation() == before + 1
-    mock_resync.assert_called_once()
-
-
-def test_geom_generation_invalidates_wall_geom_cache():
-    """Bumping the generation must cause ``_get_wall_geom_cached`` to drop its
-    stored entries on the next read, even when the same gizmo group instance
-    and the same wall object are reused (the case Blender's
-    ``GizmoGroup.refresh()`` does not cover)."""
-    from bonsai import tool
-    from bonsai.bim.module.model import wall as wall_mod
-
-    class _FakeGroup:
-        pass
-
-    group = _FakeGroup()
-    fake_obj = types.SimpleNamespace(name="Wall/W001")
-    sentinel_a = {"length": 1.0, "height": 2.0, "x_angle": 0.0}
-    sentinel_b = {"length": 1.5, "height": 2.5, "x_angle": 0.0}
-
-    with patch.object(wall_mod, "_read_wall_geometry", side_effect=[sentinel_a, sentinel_b]):
-        first = wall_mod._get_wall_geom_cached(group, fake_obj)
-        assert first is sentinel_a
-        # Same call without a generation bump must hit the cache (no extra read).
-        assert wall_mod._get_wall_geom_cached(group, fake_obj) is sentinel_a
-        # Simulate an IFC commit: generation advances, cache must drop.
-        tool.Parametric._geom_generation += 1
-        second = wall_mod._get_wall_geom_cached(group, fake_obj)
-        assert second is sentinel_b
-        assert second is not first

src/bonsai/test/bim/test_feature.py

@@ -15,8 +15,6 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was modified with the assistance of an AI coding tool.
 
 from __future__ import annotations
 
@@ -1133,17 +1131,6 @@ def the_variable_key_is_value(key, value):
     variables[key] = eval(replace_variables(value))
 
 
-@then(parsers.parse('the variable "{key}" equals "{value}"'))
-def the_variable_key_equals_value(key, value):
-    assert key in variables, f'Variable "{key}" was never set'
-    expected = eval(replace_variables(value))
-    actual = variables[key]
-    if isinstance(actual, float) and isinstance(expected, float):
-        assert abs(actual - expected) < 1e-5, f'Variable "{key}" is {actual!r}, expected {expected!r}'
-    else:
-        assert actual == expected, f'Variable "{key}" is {actual!r}, expected {expected!r}'
-
-
 @then("nothing happens")
 def nothing_happens():
     pass

src/bonsai/test/bim/test_parametric_lifecycle.py

@@ -1,409 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Unit coverage for the shared parametric-edit lifecycle mixins.
-
-``bonsai.bim.parametric_lifecycle`` is the load-bearing path for 4 of 6
-parametric features (door, window, railing, roof). The registry smoke test
-elsewhere verifies operators are wired up; the mixins' own state-transition
-contracts are tested here.
-
-The mixins are exercised through minimal in-test subclasses that supply the
-abstract hooks (``_is_element_type``, ``_get_props``, etc.). All ``tool.*`` and
-``ifcopenshell.*`` references at the module top of ``parametric_lifecycle`` are
-patched at the module attribute (not the source module) so each test sees
-isolated mock state."""
-
-import json
-from typing import ClassVar
-from unittest import mock
-
-import pytest
-
-pytestmark = pytest.mark.model
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    import types as _types
-
-    import bpy
-
-    if not isinstance(bpy, _types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-class _FakeProps:
-    """Stand-in for ``BIM<Name>Properties`` — records what was set so tests can
-    assert state transitions without instantiating real PropertyGroups."""
-
-    def __init__(self):
-        self.is_editing = False
-        self.last_kwargs = None
-        self.general = {"width": 1000}
-        self.lining = {"thickness": 50}
-        self.panel = {"material": "wood"}
-
-    def set_props_kwargs_from_ifc_data(self, data):
-        self.last_kwargs = dict(data)
-
-    def get_general_kwargs(self, convert_to_project_units=True):
-        return dict(self.general)
-
-    def get_lining_kwargs(self, convert_to_project_units=True):
-        return dict(self.lining)
-
-    def get_panel_kwargs(self, convert_to_project_units=True):
-        return dict(self.panel)
-
-
-def _make_obj(props):
-    obj = mock.Mock()
-    obj.props = props
-    obj.name = "TestObj"
-    return obj
-
-
-def _make_pset_text(general, lining, panel):
-    payload = {"lining_properties": lining, "panel_properties": panel, **general}
-    return json.dumps(payload)
-
-
-# ----------------------------------------------------------------------
-# FeatureModifierEditMixin (door/window pattern)
-# ----------------------------------------------------------------------
-
-
-def _door_mixin_cls(match=True, raise_on_update=False):
-    from bonsai.bim.parametric_lifecycle import FeatureModifierEditMixin
-
-    raised = raise_on_update
-
-    class _TestDoorMixin(FeatureModifierEditMixin):
-        pset_name: ClassVar[str] = "BBIM_Door"
-        representations_called: ClassVar[list] = []
-
-        @classmethod
-        def _is_element_type(cls, element):
-            return match
-
-        @classmethod
-        def _get_props(cls, obj):
-            return obj.props
-
-        @classmethod
-        def _update_modifier_representation(cls, obj, context):
-            cls.representations_called.append(obj)
-            if raised:
-                raise RuntimeError("simulated representation failure")
-
-    return _TestDoorMixin
-
-
-@pytest.fixture
-def patched_tool_and_ifc():
-    """Patch ``tool`` and ``ifcopenshell.*`` references on the lifecycle module.
-
-    Yields ``(mock_tool, mock_ifc_util_element, mock_ifc_api_pset,
-    mock_ifc_util_rep, mock_core_geometry)`` so tests can configure return
-    values and assert call args."""
-    target = "bonsai.bim.parametric_lifecycle"
-    with mock.patch(f"{target}.tool") as mock_tool, mock.patch(f"{target}.ifcopenshell") as mock_ifc, mock.patch(
-        f"{target}.bonsai"
-    ) as mock_bonsai:
-        # Element returned by tool.Ifc.get_entity is reused across mocks.
-        element = mock.Mock(name="entity")
-        mock_tool.Ifc.get_entity.return_value = element
-        mock_tool.Ifc.get.return_value = mock.Mock(name="ifc_file")
-        mock_tool.Model.get_constituents_props_data.return_value = {"materials": []}
-        mock_tool.Pset.get_element_pset.return_value = mock.Mock(name="pset")
-        mock_ifc.util.element.get_type.return_value = None  # skip thumbnail mark
-        yield {
-            "tool": mock_tool,
-            "ifc": mock_ifc,
-            "bonsai": mock_bonsai,
-            "element": element,
-        }
-
-
-def test_feature_modifier_enable_one_sets_is_editing_and_loads_kwargs(patched_tool_and_ifc):
-    props = _FakeProps()
-    obj = _make_obj(props)
-    patched_tool_and_ifc["ifc"].util.element.get_pset.return_value = _make_pset_text(
-        {"width": 1234}, {"thickness": 50}, {"material": "wood"}
-    )
-
-    cls = _door_mixin_cls(match=True)
-    cls._enable_one(obj)
-
-    assert props.is_editing is True
-    assert props.last_kwargs is not None
-    assert props.last_kwargs["width"] == 1234
-    assert props.last_kwargs["thickness"] == 50
-    assert props.last_kwargs["material"] == "wood"
-    assert "materials" in props.last_kwargs  # from get_constituents_props_data
-
-
-def test_feature_modifier_enable_one_noop_when_element_not_match(patched_tool_and_ifc):
-    props = _FakeProps()
-    obj = _make_obj(props)
-
-    cls = _door_mixin_cls(match=False)
-    cls._enable_one(obj)
-
-    assert props.is_editing is False
-    assert props.last_kwargs is None
-    # get_pset must not be called when _is_element_type returns False — the
-    # _resolve guard short-circuits before reading pset data.
-    patched_tool_and_ifc["ifc"].util.element.get_pset.assert_not_called()
-
-
-def test_feature_modifier_enable_one_noop_when_no_entity(patched_tool_and_ifc):
-    """tool.Ifc.get_entity returning None must short-circuit before predicate runs."""
-    props = _FakeProps()
-    obj = _make_obj(props)
-    patched_tool_and_ifc["tool"].Ifc.get_entity.return_value = None
-
-    cls = _door_mixin_cls(match=True)
-    cls._enable_one(obj)
-
-    assert props.is_editing is False
-
-
-def test_feature_modifier_finish_one_clears_is_editing_and_writes_pset(patched_tool_and_ifc):
-    props = _FakeProps()
-    props.is_editing = True
-    obj = _make_obj(props)
-    ctx = mock.Mock(name="context")
-
-    cls = _door_mixin_cls(match=True)
-    cls._finish_one(obj, ctx)
-
-    assert props.is_editing is False
-    assert obj in cls.representations_called
-    # edit_pset is called exactly once; properties key is "Data" wrapping JSON.
-    patched_tool_and_ifc["ifc"].api.pset.edit_pset.assert_called_once()
-    kwargs = patched_tool_and_ifc["ifc"].api.pset.edit_pset.call_args.kwargs
-    assert "properties" in kwargs and "Data" in kwargs["properties"]
-
-
-def test_feature_modifier_finish_one_exception_leaves_draft_in_progress(patched_tool_and_ifc):
-    """If _update_modifier_representation raises, is_editing must stay True
-    so the user's draft survives for retry. This is the contract called out
-    in parametric_lifecycle.py:161 — set is_editing=False only on success."""
-    props = _FakeProps()
-    props.is_editing = True
-    obj = _make_obj(props)
-    ctx = mock.Mock(name="context")
-
-    cls = _door_mixin_cls(match=True, raise_on_update=True)
-    with pytest.raises(RuntimeError, match="simulated representation failure"):
-        cls._finish_one(obj, ctx)
-
-    assert props.is_editing is True  # draft survives
-
-
-def test_feature_modifier_cancel_one_restores_and_clears_is_editing(patched_tool_and_ifc):
-    props = _FakeProps()
-    props.is_editing = True
-    obj = _make_obj(props)
-    patched_tool_and_ifc["ifc"].util.element.get_pset.return_value = _make_pset_text(
-        {"width": 900}, {"thickness": 60}, {"material": "steel"}
-    )
-
-    cls = _door_mixin_cls(match=True)
-    cls._cancel_one(obj)
-
-    assert props.is_editing is False
-    assert props.last_kwargs is not None and props.last_kwargs["width"] == 900
-    # switch_representation must be called via bonsai.core.geometry.
-    patched_tool_and_ifc["bonsai"].core.geometry.switch_representation.assert_called_once()
-
-
-def test_feature_modifier_targets_loop_uses_iter_targets(patched_tool_and_ifc):
-    """_enable_targets / _finish_targets / _cancel_targets iterate
-    _iter_targets — default is [active_object]; subclasses can override."""
-    props_a, props_b = _FakeProps(), _FakeProps()
-    obj_a, obj_b = _make_obj(props_a), _make_obj(props_b)
-    patched_tool_and_ifc["ifc"].util.element.get_pset.return_value = _make_pset_text(
-        {"width": 1000}, {"thickness": 50}, {"material": "wood"}
-    )
-
-    cls = _door_mixin_cls(match=True)
-    cls._iter_targets = classmethod(lambda c, ctx: [obj_a, obj_b])
-
-    result = cls()._enable_targets(mock.Mock())
-
-    assert result == {"FINISHED"}
-    assert props_a.is_editing is True
-    assert props_b.is_editing is True
-
-
-# ----------------------------------------------------------------------
-# PathPreservingEditMixin (railing/roof pattern)
-# ----------------------------------------------------------------------
-
-
-class _FakePathProps:
-    """Stand-in for railing/roof properties — get_general_kwargs only (no lining/panel)."""
-
-    def __init__(self):
-        self.is_editing = False
-        self.last_kwargs = None
-        self.general = {"width": 200, "thickness": 10}
-
-    def set_props_kwargs_from_ifc_data(self, data):
-        self.last_kwargs = dict(data)
-
-    def get_general_kwargs(self, convert_to_project_units=True):
-        return dict(self.general)
-
-
-def _path_mixin_cls(match=True):
-    from bonsai.bim.parametric_lifecycle import PathPreservingEditMixin
-
-    class _TestPathMixin(PathPreservingEditMixin):
-        pset_name: ClassVar[str] = "BBIM_Railing"
-        pset_updates: ClassVar[list] = []
-        ifc_data_updates: ClassVar[list] = []
-        bmesh_updates: ClassVar[list] = []
-
-        @classmethod
-        def _is_element_type(cls, element):
-            return match
-
-        @classmethod
-        def _get_props(cls, obj):
-            return obj.props
-
-        @classmethod
-        def _update_pset(cls, element, data):
-            cls.pset_updates.append((element, data))
-
-        @classmethod
-        def _update_modifier_ifc_data(cls, obj, context):
-            cls.ifc_data_updates.append(obj)
-
-        @classmethod
-        def _update_modifier_bmesh(cls, obj, context):
-            cls.bmesh_updates.append(obj)
-
-    return _TestPathMixin
-
-
-def test_path_preserving_enable_one_sets_is_editing(patched_tool_and_ifc):
-    props = _FakePathProps()
-    obj = _make_obj(props)
-    patched_tool_and_ifc["tool"].Model.get_modeling_bbim_pset_data.return_value = {
-        "data_dict": {"width": 250, "path_data": {"points": [[0, 0], [1, 0]]}}
-    }
-
-    cls = _path_mixin_cls(match=True)
-    cls._enable_one(obj)
-
-    assert props.is_editing is True
-    assert props.last_kwargs is not None
-    assert props.last_kwargs["width"] == 250
-    # path_data passes through (default _post_load_data is pass-through)
-    assert props.last_kwargs["path_data"] == {"points": [[0, 0], [1, 0]]}
-
-
-def test_path_preserving_finish_one_preserves_path_data_and_clears_is_editing(patched_tool_and_ifc):
-    props = _FakePathProps()
-    props.is_editing = True
-    obj = _make_obj(props)
-    ctx = mock.Mock(name="context")
-    sentinel_path = {"points": [[5, 5], [9, 9]], "edges": [[0, 1]]}
-    patched_tool_and_ifc["tool"].Model.get_modeling_bbim_pset_data.return_value = {
-        "data_dict": {"path_data": sentinel_path}
-    }
-
-    cls = _path_mixin_cls(match=True)
-    cls._finish_one(obj, ctx)
-
-    assert props.is_editing is False
-    assert cls.pset_updates, "_update_pset must be called on Finish"
-    assert cls.pset_updates[-1][1]["path_data"] is sentinel_path  # preserved by reference
-    assert obj in cls.ifc_data_updates
-
-
-def test_path_preserving_cancel_one_calls_update_modifier_bmesh(patched_tool_and_ifc):
-    props = _FakePathProps()
-    props.is_editing = True
-    obj = _make_obj(props)
-    ctx = mock.Mock(name="context")
-    patched_tool_and_ifc["tool"].Model.get_modeling_bbim_pset_data.return_value = {
-        "data_dict": {"width": 250, "path_data": {"points": []}}
-    }
-
-    cls = _path_mixin_cls(match=True)
-    cls._cancel_one(obj, ctx)
-
-    assert props.is_editing is False
-    assert obj in cls.bmesh_updates
-
-
-def test_path_preserving_enable_one_post_load_data_hook_runs(patched_tool_and_ifc):
-    """Railing overrides _post_load_data to JSON-serialise path_data —
-    confirm the hook is honoured (here we drop a sentinel key)."""
-    props = _FakePathProps()
-    obj = _make_obj(props)
-    patched_tool_and_ifc["tool"].Model.get_modeling_bbim_pset_data.return_value = {
-        "data_dict": {"width": 250, "extra": "drop_me"}
-    }
-
-    cls = _path_mixin_cls(match=True)
-    cls._post_load_data = classmethod(lambda c, data: {k: v for k, v in data.items() if k != "extra"})
-    cls._enable_one(obj)
-
-    assert "extra" not in props.last_kwargs
-
-
-# ----------------------------------------------------------------------
-# _ParametricEditMixinBase._resolve guard
-# ----------------------------------------------------------------------
-
-
-def test_resolve_returns_none_when_obj_has_no_entity(patched_tool_and_ifc):
-    cls = _door_mixin_cls(match=True)
-    patched_tool_and_ifc["tool"].Ifc.get_entity.return_value = None
-    obj = _make_obj(_FakeProps())
-
-    assert cls._resolve(obj) is None
-
-
-def test_resolve_returns_none_when_element_type_mismatch(patched_tool_and_ifc):
-    cls = _door_mixin_cls(match=False)
-    obj = _make_obj(_FakeProps())
-
-    assert cls._resolve(obj) is None
-
-
-def test_resolve_returns_tuple_when_match(patched_tool_and_ifc):
-    cls = _door_mixin_cls(match=True)
-    props = _FakeProps()
-    obj = _make_obj(props)
-
-    resolved = cls._resolve(obj)
-
-    assert resolved is not None
-    element, returned_props = resolved
-    assert element is patched_tool_and_ifc["element"]
-    assert returned_props is props

src/bonsai/test/bim/test_parametric_registry.py

@@ -1,157 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Registration smoke test for `tool.Parametric.EDIT_TYPES`.
-
-The registry is the single source of truth for which parametric element types
-exist. Every consumer (auto-commit on save, finish/cancel chains, the
-``PointerProperty`` attachment, the ``GizmoPreferences<X>`` registration) derives
-identifiers from each entry's short ``name`` token. Forget any downstream
-registration and the silent-desync the framework exists to prevent will ship.
-
-These tests pin the registry-to-runtime contract: for every entry the operator
-``bl_idname``s resolve to registered ``bpy.ops.bim.*`` callables, the
-``PropertyGroup`` class is attached to ``bpy.types.Object``, and the per-type
-predicate exists on `tool.Blender.Modifier`."""
-
-import types
-
-import bpy
-import pytest
-
-pytestmark = pytest.mark.model
-
-
-@pytest.fixture(autouse=True)
-def _require_real_bpy():
-    if not isinstance(bpy, types.ModuleType) or hasattr(bpy, "_mock_name"):
-        pytest.skip("requires real Blender (bpy is mocked or absent)")
-
-
-@pytest.fixture
-def registry():
-    from bonsai import tool
-
-    return tool.Parametric.EDIT_TYPES
-
-
-def test_registry_is_non_empty(registry):
-    assert len(registry) >= 1
-
-
-def test_every_entry_has_enable_op_registered(registry):
-    missing = [e.enable_op for e in registry if not hasattr(bpy.ops.bim, e.enable_op.removeprefix("bim."))]
-    assert not missing, f"Missing enable operators: {missing}"
-
-
-def test_every_entry_has_finish_op_registered(registry):
-    missing = [e.finish_op for e in registry if not hasattr(bpy.ops.bim, e.finish_op.removeprefix("bim."))]
-    assert not missing, f"Missing finish operators: {missing}"
-
-
-def test_every_entry_has_cancel_op_registered(registry):
-    missing = [e.cancel_op for e in registry if not hasattr(bpy.ops.bim, e.cancel_op.removeprefix("bim."))]
-    assert not missing, f"Missing cancel operators: {missing}"
-
-
-def test_every_entry_has_property_group_attached(registry):
-    # ``register_object_properties`` runs at addon enable; if any entry's
-    # PropertyGroup class is missing on prop module the attribute is skipped.
-    missing = [e.props_attr for e in registry if not hasattr(bpy.types.Object, e.props_attr)]
-    assert not missing, (
-        f"bpy.types.Object missing attributes: {missing} — "
-        f"verify the matching PropertyGroup classes exist in bim.module.model.prop"
-    )
-
-
-def test_every_entry_has_modifier_predicate(registry):
-    from bonsai import tool
-
-    missing = [e.name for e in registry if getattr(tool.Blender.Modifier, f"is_{e.name}", None) is None]
-    assert not missing, f"tool.Blender.Modifier missing is_<name> predicates: {missing}"
-
-
-def test_every_predicate_does_not_raise_on_non_matching_element(registry):
-    """Each ``is_<name>`` predicate must be **total**: accept any IFC entity
-    and return a truthy/falsy value, never raise.
-
-    The registry iterates every predicate against the active IFC element on
-    save; a raising predicate (e.g. ``AttributeError`` from a missing pset
-    accessor when handed a non-matching element type) propagates upward and
-    breaks the save path for *all* parametric types, not just its own.
-    This test probes each predicate with an ``IfcAnnotation`` (an element
-    that carries none of the BBIM_<Type> psets the predicates look up) and
-    asserts the call does not raise. Falsy returns are acceptable — the
-    registry treats them as 'no match'. What's forbidden is raising."""
-    import ifcopenshell
-
-    from bonsai import tool
-
-    probe = ifcopenshell.file(schema="IFC4").create_entity("IfcAnnotation")
-
-    raised = []
-    for feature in registry:
-        predicate = getattr(tool.Blender.Modifier, f"is_{feature.name}", None)
-        if predicate is None:
-            continue
-        try:
-            predicate(probe)
-        except Exception as e:
-            raised.append((feature.name, type(e).__name__, str(e)))
-    assert not raised, (
-        f"is_<name> predicates raised on a non-matching IfcAnnotation: {raised}. "
-        f"Predicates must be total — return bool, never raise. Add an "
-        f"`if not element.is_a('IfcXxx'): return False` short-circuit or guard the pset lookup."
-    )
-
-
-def test_gizmo_preferences_attached_when_class_exists(registry):
-    """For every registry entry whose ``GizmoPreferences<Name>`` class exists in
-    ``bonsai.bim.ui``, the matching sub-PointerProperty must be declared on
-    ``ui.GizmoPreferences`` under the registry entry's ``name`` token.
-
-    Catches the silent-skip behaviour of the registry-driven gizmo-prefs
-    discovery: a typo in the class name or a dropped registration would
-    otherwise produce a missing sub-panel at runtime with no error.
-    Entries without a ``GizmoPreferences<Name>`` class are allowed — not
-    every parametric type ships gizmo prefs.
-
-    Checks ``__annotations__`` rather than ``hasattr`` because Blender's
-    PropertyGroup syntax (``field: bpy.props.PointerProperty(...)``) is an
-    annotation-only assignment — the attribute only materialises on the
-    class after Blender's metaclass installs the bpy_struct descriptor,
-    which depends on registration timing. Reading ``__annotations__``
-    pins the source-level contract independently of when register() ran."""
-    from bonsai.bim import ui
-
-    annotations = getattr(ui.GizmoPreferences, "__annotations__", {})
-    missing = []
-    for feature in registry:
-        prefs_class_name = f"GizmoPreferences{feature.name.capitalize()}"
-        if not hasattr(ui, prefs_class_name):
-            continue
-        if feature.name not in annotations:
-            missing.append((feature.name, prefs_class_name))
-    assert not missing, (
-        f"ui.GizmoPreferences missing sub-PointerProperty field(s) for: {missing} — "
-        f"each registered ``GizmoPreferences<Name>`` class must have a matching "
-        f"``<name>: PointerProperty(type=GizmoPreferences<Name>)`` field on "
-        f"``ui.GizmoPreferences``"
-    )

src/bonsai/test/core/test_model.py

@@ -1,243 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2026
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-#
-# This file was generated with the assistance of an AI coding tool.
-
-"""Tests for pure-Python math helpers in bonsai.core.model used by the wall gizmo system.
-
-These run in the core lane (``pytest test/core/``) — no Blender, no IFC file. The
-helpers under test live in ``bonsai/core/model.py`` and are deliberately pure (tuple
-in, tuple out) so they're exercisable without ``mathutils`` or ``bpy``."""
-
-import math
-
-import pytest
-
-import bonsai.core.model as subject
-
-
-class TestBaselineFromOffset:
-    THICKNESS = 0.2
-
-    def test_positive_direction_exterior(self):
-        assert subject.baseline_from_offset(0.0, self.THICKNESS) == "EXTERIOR"
-
-    def test_positive_direction_center(self):
-        assert subject.baseline_from_offset(-self.THICKNESS / 2, self.THICKNESS) == "CENTER"
-
-    def test_positive_direction_interior(self):
-        assert subject.baseline_from_offset(-self.THICKNESS, self.THICKNESS) == "INTERIOR"
-
-    def test_negative_direction_exterior(self):
-        assert subject.baseline_from_offset(self.THICKNESS, self.THICKNESS) == "EXTERIOR"
-
-    def test_negative_direction_center(self):
-        assert subject.baseline_from_offset(self.THICKNESS / 2, self.THICKNESS) == "CENTER"
-
-    def test_negative_direction_interior(self):
-        assert subject.baseline_from_offset(0.0, self.THICKNESS) == "EXTERIOR"
-
-    def test_within_tolerance_still_matches(self):
-        # A 0.5mm jitter on a 200mm wall should still classify cleanly.
-        assert subject.baseline_from_offset(-self.THICKNESS / 2 + 0.0005, self.THICKNESS) == "CENTER"
-
-    def test_outside_tolerance_falls_back_to_center(self):
-        # 50mm offset on a 200mm wall — not a canonical position.
-        assert subject.baseline_from_offset(0.05, self.THICKNESS) == "CENTER"
-
-
-class TestProjectAxisIntersection:
-    PARALLEL_THRESHOLD = 0.9994  # cos(2°)
-
-    def test_perpendicular_walls_meet_at_corner(self):
-        # Wall A along +X from origin; wall B along +Y from (5, 0, 0).
-        # Axes meet exactly at (5, 0).
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((5.0, 0.0, 0.0), (5.0, 3.0, 0.0))
-        result = subject.project_axis_intersection(seg_a, seg_b, self.PARALLEL_THRESHOLD)
-        assert result is not None
-        assert result[0] == pytest.approx(5.0)
-        assert result[1] == pytest.approx(0.0)
-
-    def test_offset_walls_intersect_at_extrapolated_point(self):
-        # Wall A: y=0 from x=1 to x=6.
-        # Wall B: x=0 from y=1 to y=4.
-        # Infinite-line intersection at (0, 0).
-        seg_a = ((1.0, 0.0, 0.0), (6.0, 0.0, 0.0))
-        seg_b = ((0.0, 1.0, 0.0), (0.0, 4.0, 0.0))
-        result = subject.project_axis_intersection(seg_a, seg_b, self.PARALLEL_THRESHOLD)
-        assert result is not None
-        assert result[0] == pytest.approx(0.0)
-        assert result[1] == pytest.approx(0.0)
-
-    def test_parallel_walls_return_none(self):
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((0.0, 1.0, 0.0), (5.0, 1.0, 0.0))
-        assert subject.project_axis_intersection(seg_a, seg_b, self.PARALLEL_THRESHOLD) is None
-
-    def test_anti_parallel_walls_return_none(self):
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((5.0, 1.0, 0.0), (0.0, 1.0, 0.0))  # opposite direction
-        assert subject.project_axis_intersection(seg_a, seg_b, self.PARALLEL_THRESHOLD) is None
-
-    def test_nearly_parallel_walls_return_none(self):
-        # 1° off parallel — within the ~2° dead-band.
-        angle = math.radians(1)
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((0.0, 1.0, 0.0), (5.0 * math.cos(angle), 1.0 + 5.0 * math.sin(angle), 0.0))
-        assert subject.project_axis_intersection(seg_a, seg_b, self.PARALLEL_THRESHOLD) is None
-
-    def test_zero_length_segment_returns_none(self):
-        seg_a = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0))
-        seg_b = ((0.0, 0.0, 0.0), (1.0, 1.0, 0.0))
-        assert subject.project_axis_intersection(seg_a, seg_b, self.PARALLEL_THRESHOLD) is None
-
-    def test_intersection_z_is_average_of_endpoint_zs(self):
-        # Walls at different elevations; the icon-placement Z should be the average.
-        seg_a = ((0.0, 0.0, 1.0), (5.0, 0.0, 1.0))  # at z=1
-        seg_b = ((5.0, 0.0, 3.0), (5.0, 3.0, 3.0))  # at z=3
-        result = subject.project_axis_intersection(seg_a, seg_b, self.PARALLEL_THRESHOLD)
-        assert result is not None
-        assert result[2] == pytest.approx(2.0)
-
-
-class TestSlopeRoundTrip:
-    def test_zero_angle_zero_displacement(self):
-        assert subject.displacement_from_x_angle(3.0, 0.0) == pytest.approx(0.0)
-        assert subject.x_angle_from_displacement(3.0, 0.0) == pytest.approx(0.0)
-
-    def test_positive_angle_positive_displacement(self):
-        # 30° slope on a 3m wall → top moves ~1.732m in +Y.
-        displacement = subject.displacement_from_x_angle(3.0, math.radians(30))
-        assert displacement == pytest.approx(3.0 * math.tan(math.radians(30)))
-
-    def test_negative_angle_negative_displacement(self):
-        displacement = subject.displacement_from_x_angle(3.0, math.radians(-15))
-        assert displacement < 0
-
-    def test_round_trip_preserves_angle(self):
-        # Drag-to-angle-to-drag preserves the original.
-        original_angle = math.radians(20)
-        displacement = subject.displacement_from_x_angle(3.0, original_angle)
-        recovered = subject.x_angle_from_displacement(3.0, displacement)
-        assert recovered == pytest.approx(original_angle, abs=1e-9)
-
-    def test_round_trip_handles_zero_height(self):
-        # Walls of effectively zero height should not divide-by-zero.
-        recovered = subject.x_angle_from_displacement(0.0, 1.0)
-        assert recovered == pytest.approx(math.pi / 2, abs=1e-3)
-
-
-class TestAreAxesCollinear:
-    PARALLEL_THRESHOLD = 0.9994
-    LINE_TOLERANCE = 0.05
-
-    def test_end_to_end_walls_along_x_are_collinear(self):
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((5.0, 0.0, 0.0), (10.0, 0.0, 0.0))
-        assert subject.are_axes_collinear(seg_a, seg_b, self.PARALLEL_THRESHOLD, self.LINE_TOLERANCE)
-
-    def test_separated_collinear_walls_with_gap(self):
-        # Walls with a 1m gap between them — still on the same line.
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((6.0, 0.0, 0.0), (10.0, 0.0, 0.0))
-        assert subject.are_axes_collinear(seg_a, seg_b, self.PARALLEL_THRESHOLD, self.LINE_TOLERANCE)
-
-    def test_perpendicular_walls_are_not_collinear(self):
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((0.0, 0.0, 0.0), (0.0, 5.0, 0.0))
-        assert not subject.are_axes_collinear(seg_a, seg_b, self.PARALLEL_THRESHOLD, self.LINE_TOLERANCE)
-
-    def test_parallel_walls_offset_perpendicular_are_not_collinear(self):
-        # Two parallel walls 1m apart — same direction but not the same line.
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((0.0, 1.0, 0.0), (5.0, 1.0, 0.0))
-        assert not subject.are_axes_collinear(seg_a, seg_b, self.PARALLEL_THRESHOLD, self.LINE_TOLERANCE)
-
-    def test_anti_parallel_collinear_walls(self):
-        # Reversed direction on the same line still counts as collinear.
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((10.0, 0.0, 0.0), (6.0, 0.0, 0.0))
-        assert subject.are_axes_collinear(seg_a, seg_b, self.PARALLEL_THRESHOLD, self.LINE_TOLERANCE)
-
-    def test_z_is_ignored_for_plan_collinearity(self):
-        # Walls on different floors are still considered collinear in plan.
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((5.0, 0.0, 3.0), (10.0, 0.0, 3.0))
-        assert subject.are_axes_collinear(seg_a, seg_b, self.PARALLEL_THRESHOLD, self.LINE_TOLERANCE)
-
-    def test_zero_length_segment_is_not_collinear(self):
-        seg_a = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0))
-        seg_b = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        assert not subject.are_axes_collinear(seg_a, seg_b, self.PARALLEL_THRESHOLD, self.LINE_TOLERANCE)
-
-    def test_slightly_off_line_within_tolerance(self):
-        # 2cm perpendicular offset — still within the 5cm tolerance.
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((5.0, 0.02, 0.0), (10.0, 0.02, 0.0))
-        assert subject.are_axes_collinear(seg_a, seg_b, self.PARALLEL_THRESHOLD, self.LINE_TOLERANCE)
-
-    def test_too_far_off_line_fails_tolerance(self):
-        # 10cm perpendicular offset — outside the 5cm tolerance.
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((5.0, 0.10, 0.0), (10.0, 0.10, 0.0))
-        assert not subject.are_axes_collinear(seg_a, seg_b, self.PARALLEL_THRESHOLD, self.LINE_TOLERANCE)
-
-
-class TestClosestEndpointMidpoint:
-    def test_end_to_end_walls_midpoint_is_the_shared_corner(self):
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((5.0, 0.0, 0.0), (10.0, 0.0, 0.0))
-        result = subject.closest_endpoint_midpoint(seg_a, seg_b)
-        assert result == (pytest.approx(5.0), pytest.approx(0.0), pytest.approx(0.0))
-
-    def test_walls_with_gap_midpoint_is_in_the_gap(self):
-        # Wall A ends at x=5; wall B starts at x=7. Boundary midpoint is at x=6.
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((7.0, 0.0, 0.0), (12.0, 0.0, 0.0))
-        result = subject.closest_endpoint_midpoint(seg_a, seg_b)
-        assert result == (pytest.approx(6.0), pytest.approx(0.0), pytest.approx(0.0))
-
-    def test_perpendicular_walls_midpoint_is_between_nearest_endpoints(self):
-        # Wall A's +X endpoint (5,0,0) and wall B's origin (5,0,0) → midpoint at (5,0,0).
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((5.0, 0.0, 0.0), (5.0, 3.0, 0.0))
-        result = subject.closest_endpoint_midpoint(seg_a, seg_b)
-        assert result == (pytest.approx(5.0), pytest.approx(0.0), pytest.approx(0.0))
-
-    def test_z_averaged_when_walls_at_different_elevations(self):
-        seg_a = ((0.0, 0.0, 0.0), (5.0, 0.0, 0.0))
-        seg_b = ((5.0, 0.0, 3.0), (10.0, 0.0, 3.0))
-        result = subject.closest_endpoint_midpoint(seg_a, seg_b)
-        # Closest pair: (5,0,0) and (5,0,3); midpoint Z = 1.5.
-        assert result[2] == pytest.approx(1.5)
-
-
-class TestVerticalHeightFromExtrusionDepth:
-    def test_vertical_wall_returns_depth_unchanged(self):
-        assert subject.vertical_height_from_extrusion_depth(3.0, 0.0) == pytest.approx(3.0)
-
-    def test_30_degree_slope(self):
-        # cos(30°) ≈ 0.866 → vertical height of a 3m slanted extrusion ≈ 2.598m.
-        result = subject.vertical_height_from_extrusion_depth(3.0, math.radians(30))
-        assert result == pytest.approx(3.0 * math.cos(math.radians(30)))
-
-    def test_negative_angle_yields_same_magnitude(self):
-        positive = subject.vertical_height_from_extrusion_depth(3.0, math.radians(30))
-        negative = subject.vertical_height_from_extrusion_depth(3.0, math.radians(-30))
-        assert positive == pytest.approx(negative)

src/bonsai/test/tool/test_cost.py

@@ -1,45 +0,0 @@
-# Bonsai - OpenBIM Blender Add-on
-# Copyright (C) 2021 Dion Moult <dion@thinkmoult.com>
-#
-# This file is part of Bonsai.
-#
-# Bonsai is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Bonsai 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
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Bonsai.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import ifcopenshell.api.cost
-
-import bonsai.core.tool
-import bonsai.tool as tool
-import test.bim.bootstrap
-from bonsai.tool.cost import Cost as subject
-from test.bim.bootstrap import NewFile
-
-
-class TestImplementsTool(NewFile):
-    def test_run(self):
-        assert isinstance(subject(), bonsai.core.tool.Cost)
-
-
-class TestDisableEditingCostItemParent(NewFile):
-    def test_avoid_recursion_error(newfile, monkeypatch):
-        class DummyProps:
-            def __init__(self):
-                self.change_cost_item_parent = None
-                self.active_cost_item_id = 5
-
-        props = DummyProps()
-        monkeypatch.setattr("bonsai.tool.Cost.get_cost_props", lambda: props)
-        subject.disable_editing_cost_item_parent()
-        assert props.active_cost_item_id == 0
-        assert props.change_cost_item_parent is not False

src/common.mk

@@ -1,7 +1,7 @@
 SHELL := sh
 IS_STABLE:=FALSE
-PYTHON:=python3
-PIP:=pip3
+PYTHON:=python3.11
+PIP:=pip3.11
 VERSION:=$(shell cat ../../VERSION)
 VERSION_DATE:=$(shell date '+%y%m%d')
 SED:=sed -i

src/examples/IfcAdvancedHouse.cpp

@@ -39,12 +39,11 @@
 #include <Standard_Version.hxx>
 
 #define IfcSchema Ifc2x3
-#include "ifcparse/macros.h"
-#include "ifcparse/Ifc2x3.h"
-#include "ifcparse/IfcBaseClass.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/macros.h"
+#include "../ifcparse/schemas/Ifc2x3.h"
+#include "../ifcparse/hierarchy_helper.h"
 
-#include "ifcgeom/Serialization/Serialization.h"
+#include "../ifcgeom/Serialization/Serialization.h"
 
 #if USE_VLD
 #include <vld.h>
@@ -57,18 +56,18 @@ void createGroundShape(TopoDS_Shape& shape);
 
 int main() {
 
-	// The IfcHierarchyHelper is a subclass of the regular IfcFile that provides several
+	// The hierarchy_helper is a subclass of the regular file that provides several
 	// convenience functions for working with geometry in IFC files.
-	IfcHierarchyHelper<IfcSchema> file;
-	file.header().file_name()->setname("IfcAdvancedHouse.ifc");
+	hierarchy_helper<IfcSchema> file;
+	file.header().file_name().setname("IfcAdvancedHouse.ifc");
 
-	IfcSchema::IfcBuilding* building = file.addBuilding();
+	auto building = file.addBuilding();
 	// By adding a building, a hierarchy has been automatically created that consists of the following
 	// structure: IfcProject > IfcSite > IfcBuilding
 
 	// Lateron changing the name of the IfcProject can be done by obtaining a reference to the 
 	// project, which has been created automatically.
-	file.getSingle<IfcSchema::IfcProject>()->setName("IfcAdvancedHouse"s);
+	file.getSingle<IfcSchema::IfcProject>().setName("IfcAdvancedHouse"s);
 
 	// To demonstrate the ability to serialize arbitrary opencascade solids a building envelope is
 	// constructed by applying boolean operations. Naturally, in IFC, building elements should be 
@@ -91,13 +90,13 @@ int main() {
 	// IfcFacetedBRep. If it would not be a polyhedron, serialise() can only be successful when linked
 	// to the IFC4 model and with `advanced` set to `true` which introduces IfcAdvancedFace. It would
 	// return `0` otherwise.
-	IfcSchema::IfcProductDefinitionShape* building_shape = IfcGeom::serialise(STRINGIFY(IfcSchema), building_shell, false)->as<IfcSchema::IfcProductDefinitionShape>();
+	auto building_shape = IfcGeom::serialise(file, building_shell, false).as<IfcSchema::IfcProductDefinitionShape>();
 	
-	file.addEntity(building_shape);
-	IfcSchema::IfcRepresentation* rep = *building_shape->Representations()->begin();
+	file.add_entity(building_shape);
+	auto rep = building_shape.Representations().begin();
 	rep->setContextOfItems(file.getRepresentationContext("model"));
 
-	building->setRepresentation(building_shape);
+	building.setRepresentation(building_shape);
 
 	// A pale white colour is assigned to the building.
 	setSurfaceColour(file, building_shape, 0.75, 0.73, 0.68);
@@ -107,18 +106,18 @@ int main() {
 	TopoDS_Shape shape;
 	createGroundShape(shape);
 
-	auto ground_representation = IfcGeom::serialise(STRINGIFY(IfcSchema), shape, true);
+	auto ground_representation = IfcGeom::serialise(file, shape, true);
 	if (!ground_representation) {
-		ground_representation = IfcGeom::tesselate(STRINGIFY(IfcSchema), shape, 100.);
+        ground_representation = IfcGeom::tesselate(file, shape, 100.);
 	}
-	file.getSingle<IfcSchema::IfcSite>()->setRepresentation(ground_representation->as<IfcSchema::IfcProductDefinitionShape>());
+	file.getSingle<IfcSchema::IfcSite>().setRepresentation(ground_representation.as<IfcSchema::IfcProductDefinitionShape>());
 	
-	IfcSchema::IfcRepresentation::list::ptr ground_reps = file.getSingle<IfcSchema::IfcSite>()->Representation()->Representations();
-	for (IfcSchema::IfcRepresentation::list::it it = ground_reps->begin(); it != ground_reps->end(); ++it) {
-		(*it)->setContextOfItems(file.getRepresentationContext("Model"));
+	auto ground_reps = file.getSingle<IfcSchema::IfcSite>().Representation().Representations();
+	for (auto& rep : ground_reps) {
+		rep.setContextOfItems(file.getRepresentationContext("Model"));
 	}
-	file.addEntity(ground_representation);
-	setSurfaceColour(file, ground_representation->as<IfcSchema::IfcProductDefinitionShape>(), 0.15, 0.25, 0.05);
+	file.add_entity(ground_representation);
+	setSurfaceColour(file, ground_representation.as<IfcSchema::IfcProductDefinitionShape>(), 0.15, 0.25, 0.05);
 
     /*
     // Note that IFC lacks elementary surfaces that STEP does have, such as spherical_surface.

src/examples/IfcAlignment.cpp

@@ -30,8 +30,8 @@
 // Disable warnings coming from IfcOpenShell
 #pragma warning(disable : 4018 4267 4250 4984 4985)
 
-#include "ifcparse/Ifc4x3_add2.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/Ifc4x3_add2.h"
+#include "../ifcparse/hierarchy_helper.h"
 
 #include <boost/math/constants/constants.hpp>
 #include <fstream>
@@ -43,37 +43,49 @@ double to_radian(double deg) { return PI * deg / 180; }
 
 // performs basic project setup including created the IfcProject object
 // and initializing the project units to FEET
-Schema::IfcProject* setup_project(IfcHierarchyHelper<Schema>& file) {
+Schema::IfcProject setup_project(hierarchy_helper<Schema>& file) {
     std::vector<std::string> file_description;
     file_description.push_back("ViewDefinition[Alignment-basedReferenceView]");
-    file.header().file_description()->setdescription(file_description);
+    file.header().file_description().setdescription(file_description);
 
     auto project = file.addProject();
-    project->setName(std::string("FHWA Bridge Geometry Manual Example Alignment"));
-    project->setDescription(std::string("C++ Example"));
+    project.setName("FHWA Bridge Geometry Manual Example Alignment");
+    project.setDescription("C++ Example");
 
     // set up project units for feet
     // the call to file.addProject() sets up length units as millimeter.
-    auto units_in_context = project->UnitsInContext();
-    auto units = units_in_context->Units();
-    auto begin = units->begin();
+    auto units_in_context = project.UnitsInContext();
+    auto units = units_in_context.Units();
+    auto begin = units.begin();
     auto iter = begin;
-    auto end = units->end();
+    auto end = units.end();
     for (; iter != end; iter++) {
-        auto unit = *iter;
-        if (unit->as<Schema::IfcSIUnit>() && unit->as<Schema::IfcSIUnit>()->UnitType() == Schema::IfcUnitEnum::IfcUnit_LENGTHUNIT) {
-            auto dimensions = new Schema::IfcDimensionalExponents(1, 0, 0, 0, 0, 0, 0);
-            file.addEntity(dimensions);
+        auto& unit = *iter;
+        if (unit.as<Schema::IfcSIUnit>() && unit.as<Schema::IfcSIUnit>().UnitType() == Schema::IfcUnitEnum::IfcUnit_LENGTHUNIT) {
+            auto dimensions = file.create<Schema::IfcDimensionalExponents>();
+            dimensions.setLengthExponent(1);
+            dimensions.setMassExponent(0);
+            dimensions.setTimeExponent(0);
+            dimensions.setElectricCurrentExponent(0);
+            dimensions.setThermodynamicTemperatureExponent(0);
+            dimensions.setAmountOfSubstanceExponent(0);
+            dimensions.setLuminousIntensityExponent(0);
+            
+            auto conversion_factor = file.create<Schema::IfcMeasureWithUnit>();
+            auto length = file.create<Schema::IfcLengthMeasure>();
+            length.set_attribute_value(0, 304.80);
+            conversion_factor.setValueComponent(length);
+            conversion_factor.setUnitComponent(unit);
 
-            auto conversion_factor = new Schema::IfcMeasureWithUnit(new Schema::IfcLengthMeasure(304.80), unit->as<Schema::IfcSIUnit>());
-            file.addEntity(conversion_factor);
-
-            auto conversion_based_unit = new Schema::IfcConversionBasedUnit(dimensions, Schema::IfcUnitEnum::IfcUnit_LENGTHUNIT, "FEET", conversion_factor);
-            file.addEntity(conversion_based_unit);
-
-            units->remove(unit);                // remove the millimeter unit
-            units->push(conversion_based_unit); // add the feet unit
-            units_in_context->setUnits(units);  // update the UnitsInContext
+            auto conversion_based_unit = file.create<Schema::IfcConversionBasedUnit>();
+            conversion_based_unit.setDimensions(dimensions);
+            conversion_based_unit.setUnitType(Schema::IfcUnitEnum::IfcUnit_LENGTHUNIT);
+            conversion_based_unit.setName("FEET");
+            conversion_based_unit.setConversionFactor(conversion_factor);
+            
+            units.erase(std::remove(units.begin(), units.end(), unit)); // remove the millimeter unit
+            units.push_back(conversion_based_unit); // add the feet unit
+            units_in_context.setUnits(units);  // update the UnitsInContext
 
             break; // Done!, the length unit was found, so break out of the loop
         }
@@ -83,135 +95,198 @@ Schema::IfcProject* setup_project(IfcHierarchyHelper<Schema>& file) {
 }
 
 // creates geometry and business logic segments for horizontal alignment tangent runs
-std::pair<typename Schema::IfcCurveSegment*, typename Schema::IfcAlignmentSegment*> create_tangent(typename Schema::IfcCartesianPoint* p, double dir, double length) {
+std::pair<typename Schema::IfcCurveSegment, typename Schema::IfcAlignmentSegment> create_tangent(hierarchy_helper<Schema>& file, const typename Schema::IfcCartesianPoint& p, double dir, double length) {
     // geometry
-    auto parent_curve = new Schema::IfcLine(
-        new Schema::IfcCartesianPoint(std::vector<double>({0, 0})),
-        new Schema::IfcVector(new Schema::IfcDirection(std::vector<double>{1.0, 0.0}), 1.0));
+    auto parent_curve = file.create<Schema::IfcLine>();
+    parent_curve.setPnt(file.addDoublet<Schema::IfcCartesianPoint>(0.0, 0.0));
+    auto vec = file.create<Schema::IfcVector>();
+    vec.setOrientation(file.addDoublet<Schema::IfcDirection>(1.0, 0.0));
+    vec.setMagnitude(1.0);
+    parent_curve.setDir(vec);
 
-    auto curve_segment = new Schema::IfcCurveSegment(
-        Schema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT,
-        new Schema::IfcAxis2Placement2D(p, new Schema::IfcDirection(std::vector<double>{cos(dir), sin(dir)})),
-        new Schema::IfcLengthMeasure(0.0), // start
-        new Schema::IfcLengthMeasure(length),
-        parent_curve);
+    auto place = file.create<Schema::IfcAxis2Placement2D>();
+    place.setLocation(p);
+    place.setRefDirection(file.addDoublet<Schema::IfcDirection>(cos(dir), sin(dir)));
+
+    auto curve_segment = file.create<Schema::IfcCurveSegment>();
+    curve_segment.setTransition(Schema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT);
+    curve_segment.setPlacement(place);
+    curve_segment.setSegmentStart(file.addValue<Schema::IfcLengthMeasure>(0.0));
+    curve_segment.setSegmentLength(file.addValue<Schema::IfcLengthMeasure>(length));
+    curve_segment.setParentCurve(parent_curve);
 
     // business logic
-    auto design_parameters = new Schema::IfcAlignmentHorizontalSegment(
-        boost::none, boost::none, p, dir, 0.0, 0.0, length, boost::none, Schema::IfcAlignmentHorizontalSegmentTypeEnum::IfcAlignmentHorizontalSegmentType_LINE);
+    auto design_parameters = file.create<Schema::IfcAlignmentHorizontalSegment>();
+    design_parameters.setStartPoint(p);
+    design_parameters.setStartDirection(dir);
+    design_parameters.setStartRadiusOfCurvature(0.0);
+    design_parameters.setEndRadiusOfCurvature(0.0);
+    design_parameters.setSegmentLength(length);
+    design_parameters.setPredefinedType(Schema::IfcAlignmentHorizontalSegmentTypeEnum::IfcAlignmentHorizontalSegmentType_LINE);
 
-    auto alignment_segment = new Schema::IfcAlignmentSegment(
-        IfcParse::IfcGlobalId(), nullptr, boost::none, boost::none, boost::none, nullptr, nullptr, design_parameters);
+    auto alignment_segment = file.create<Schema::IfcAlignmentSegment>();
+    alignment_segment.setGlobalId(ifcopenshell::global_id());
+    alignment_segment.setDesignParameters(design_parameters);
 
     return {curve_segment, alignment_segment};
 }
 
 // creates geometry and business logic segments for horizontal alignment horizonal curves
-std::pair<typename Schema::IfcCurveSegment*, typename Schema::IfcAlignmentSegment*> create_hcurve(typename Schema::IfcCartesianPoint* pc, double dir, double radius, double lc) {
+std::pair<typename Schema::IfcCurveSegment, typename Schema::IfcAlignmentSegment> create_hcurve(hierarchy_helper<Schema>& file, const typename Schema::IfcCartesianPoint& pc, double dir, double radius, double lc) {
     // geometry
     double sign = radius / fabs(radius);
-    auto parent_curve = new Schema::IfcCircle(
-        new Schema::IfcAxis2Placement2D(new Schema::IfcCartesianPoint(std::vector<double>({0, 0})), new Schema::IfcDirection(std::vector<double>{1, 0})),
-        fabs(radius));
+    auto place = file.create<Schema::IfcAxis2Placement2D>();
+    place.setLocation(file.addDoublet<Schema::IfcCartesianPoint>(0.0, 0.0));
+    place.setRefDirection(file.addDoublet<Schema::IfcDirection>(1.0, 0.0));
+    auto parent_curve = file.create<Schema::IfcCircle>();
+    parent_curve.setPosition(place);
+    parent_curve.setRadius(fabs(radius));
 
-    auto curve_segment = new Schema::IfcCurveSegment(
-        Schema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT,
-        new Schema::IfcAxis2Placement2D(pc, new Schema::IfcDirection(std::vector<double>{cos(dir), sin(dir)})),
-        new Schema::IfcLengthMeasure(0.0),
-        new Schema::IfcLengthMeasure(sign * lc),
-        parent_curve);
+    auto place2 = file.create<Schema::IfcAxis2Placement2D>();
+    place2.setLocation(pc);
+    place2.setRefDirection(file.addDoublet<Schema::IfcDirection>(cos(dir), sin(dir)));
+
+    auto curve_segment = file.create<Schema::IfcCurveSegment>();
+    curve_segment.setTransition(Schema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT);
+    curve_segment.setPlacement(place2);
+    curve_segment.setSegmentStart(file.addValue<Schema::IfcLengthMeasure>(0.0));
+    curve_segment.setSegmentLength(file.addValue<Schema::IfcLengthMeasure>(sign * lc));
+    curve_segment.setParentCurve(parent_curve);
 
     // business logic
-    auto design_parameters = new Schema::IfcAlignmentHorizontalSegment(boost::none, boost::none, pc, dir, radius, radius, lc, boost::none, Schema::IfcAlignmentHorizontalSegmentTypeEnum::IfcAlignmentHorizontalSegmentType_CIRCULARARC);
-    auto alignment_segment = new Schema::IfcAlignmentSegment(IfcParse::IfcGlobalId(), nullptr, boost::none, boost::none, boost::none, nullptr, nullptr, design_parameters);
+    auto design_parameters = file.create<Schema::IfcAlignmentHorizontalSegment>();
+    design_parameters.setStartPoint(pc);
+    design_parameters.setStartDirection(dir);
+    design_parameters.setStartRadiusOfCurvature(radius);
+    design_parameters.setEndRadiusOfCurvature(radius);
+    design_parameters.setSegmentLength(lc);
+    design_parameters.setPredefinedType(Schema::IfcAlignmentHorizontalSegmentTypeEnum::IfcAlignmentHorizontalSegmentType_CIRCULARARC);
+
+    auto alignment_segment = file.create<Schema::IfcAlignmentSegment>();
+    alignment_segment.setGlobalId(ifcopenshell::global_id());
+    alignment_segment.setDesignParameters(design_parameters);
 
     return {curve_segment, alignment_segment};
 }
 
 // creates geometry and business logic segments for vertical profile gradient runs
-std::pair<typename Schema::IfcCurveSegment*, typename Schema::IfcAlignmentSegment*> create_gradient(typename Schema::IfcCartesianPoint* p, double slope, double length) {
+std::pair<typename Schema::IfcCurveSegment, typename Schema::IfcAlignmentSegment> create_gradient(hierarchy_helper<Schema>& file, const typename Schema::IfcCartesianPoint& p, double slope, double length) {
     // geometry
-    auto parent_curve = new Schema::IfcLine(
-        new Schema::IfcCartesianPoint(std::vector<double>({0, 0})),
-        new Schema::IfcVector(new Schema::IfcDirection(std::vector<double>{1, 0}), 1.0));
+    auto parent_curve = file.create<Schema::IfcLine>();
+    parent_curve.setPnt(file.addDoublet<Schema::IfcCartesianPoint>(0.0, 0.0));
+    auto vec = file.create<Schema::IfcVector>();
+    vec.setOrientation(file.addDoublet<Schema::IfcDirection>(1.0, 0.0));
+    vec.setMagnitude(1.0);
+    parent_curve.setDir(vec);
 
-    auto curve_segment = new Schema::IfcCurveSegment(
-        Schema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT,
-        new Schema::IfcAxis2Placement2D(p, new Schema::IfcDirection(std::vector<double>{sqrt(1 - slope * slope), slope})),
-        new Schema::IfcLengthMeasure(0.0), // start
-        new Schema::IfcLengthMeasure(length),
-        parent_curve);
+    auto place2 = file.create<Schema::IfcAxis2Placement2D>();
+    place2.setLocation(p);
+    place2.setRefDirection(file.addDoublet<Schema::IfcDirection>(sqrt(1 - slope * slope), slope));
+
+    auto curve_segment = file.create<Schema::IfcCurveSegment>();
+    curve_segment.setTransition(Schema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT);
+    curve_segment.setPlacement(place2);
+    curve_segment.setSegmentStart(file.addValue<Schema::IfcLengthMeasure>(0.0));
+    curve_segment.setSegmentLength(file.addValue<Schema::IfcLengthMeasure>(length));
+    curve_segment.setParentCurve(parent_curve);
 
     // business logic
-    auto design_parameters = new Schema::IfcAlignmentVerticalSegment(boost::none, boost::none, p->Coordinates()[0], length, p->Coordinates()[1], slope, slope, boost::none, Schema::IfcAlignmentVerticalSegmentTypeEnum::IfcAlignmentVerticalSegmentType_CONSTANTGRADIENT);
-    auto alignment_segment = new Schema::IfcAlignmentSegment(IfcParse::IfcGlobalId(), nullptr, boost::none, boost::none, boost::none, nullptr, nullptr, design_parameters);
+    auto design_parameters = file.create<Schema::IfcAlignmentVerticalSegment>();
+    design_parameters.setStartDistAlong(p.Coordinates()[0]);
+    design_parameters.setHorizontalLength(length);
+    design_parameters.setStartHeight(p.Coordinates()[1]);
+    design_parameters.setStartGradient(slope);
+    design_parameters.setEndGradient(slope);
+    design_parameters.setPredefinedType(Schema::IfcAlignmentVerticalSegmentTypeEnum::IfcAlignmentVerticalSegmentType_CONSTANTGRADIENT);
+
+    auto alignment_segment = file.create<Schema::IfcAlignmentSegment>();
+    alignment_segment.setGlobalId(ifcopenshell::global_id());
+    alignment_segment.setDesignParameters(design_parameters);
 
     return {curve_segment, alignment_segment};
 }
 
 // creates geometry and business logic segments for vertical profile parabolic vertical curves
-std::pair<typename Schema::IfcCurveSegment*, typename Schema::IfcAlignmentSegment*> create_vcurve(typename Schema::IfcCartesianPoint* p, double start_slope, double end_slope, double length) {
+std::pair<typename Schema::IfcCurveSegment, typename Schema::IfcAlignmentSegment> create_vcurve(hierarchy_helper<Schema>& file, const typename Schema::IfcCartesianPoint& p, double start_slope, double end_slope, double length) {
     // geometry
-    double A = p->Coordinates()[1];
+    double A = p.Coordinates()[1];
     double B = start_slope;
     double C = (end_slope - start_slope) / (2 * length);
 
-    auto parent_curve = new Schema::IfcPolynomialCurve(
-        new Schema::IfcAxis2Placement2D(new Schema::IfcCartesianPoint(std::vector<double>{0.0, 0.0}), new Schema::IfcDirection(std::vector<double>{1.0, 0.0})),
-        std::vector<double>{0.0, 1.0},
-        std::vector<double>{A, B, C},
-        boost::none);
+    auto place = file.create<Schema::IfcAxis2Placement2D>();
+    place.setLocation(file.addDoublet<Schema::IfcCartesianPoint>(0.0, 0.0));
+    place.setRefDirection(file.addDoublet<Schema::IfcDirection>(1.0, 0.0));
 
-    auto curve_segment = new Schema::IfcCurveSegment(
-        Schema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT,
-        new Schema::IfcAxis2Placement2D(p, new Schema::IfcDirection(std::vector<double>{sqrt(1 - start_slope * start_slope), start_slope})),
-        new Schema::IfcLengthMeasure(0.0),
-        new Schema::IfcLengthMeasure(length),
-        parent_curve);
+    auto parent_curve = file.create<Schema::IfcPolynomialCurve>();
+    parent_curve.setPosition(place);
+    parent_curve.setCoefficientsX(std::vector<double>{0.0, 1.0});
+    parent_curve.setCoefficientsY(std::vector<double>{A, B, C});
+
+    auto place2 = file.create<Schema::IfcAxis2Placement2D>();
+    place2.setLocation(p);
+    place2.setRefDirection(file.addDoublet<Schema::IfcDirection>(sqrt(1 - start_slope * start_slope), start_slope));
+
+    auto curve_segment = file.create<Schema::IfcCurveSegment>();
+    curve_segment.setTransition(Schema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT);
+    curve_segment.setPlacement(place2);
+    curve_segment.setSegmentStart(file.addValue<Schema::IfcLengthMeasure>(0.0));
+    curve_segment.setSegmentLength(file.addValue<Schema::IfcLengthMeasure>(length));
+    curve_segment.setParentCurve(parent_curve);
 
     // business logic
     double k = (end_slope - start_slope) / length;
-    auto design_parameters = new Schema::IfcAlignmentVerticalSegment(boost::none, boost::none, p->Coordinates()[0], length, p->Coordinates()[1], start_slope, end_slope, 1 / k, Schema::IfcAlignmentVerticalSegmentTypeEnum::IfcAlignmentVerticalSegmentType_PARABOLICARC);
-    auto alignment_segment = new Schema::IfcAlignmentSegment(IfcParse::IfcGlobalId(), nullptr, boost::none, boost::none, boost::none, nullptr, nullptr, design_parameters);
+
+    auto design_parameters = file.create<Schema::IfcAlignmentVerticalSegment>();
+    design_parameters.setStartDistAlong(p.Coordinates()[0]);
+    design_parameters.setHorizontalLength(length);
+    design_parameters.setStartHeight(p.Coordinates()[1]);
+    design_parameters.setStartGradient(start_slope);
+    design_parameters.setEndGradient(end_slope);
+    design_parameters.setRadiusOfCurvature(1 / k);
+    design_parameters.setPredefinedType(Schema::IfcAlignmentVerticalSegmentTypeEnum::IfcAlignmentVerticalSegmentType_PARABOLICARC);
+
+    auto alignment_segment = file.create<Schema::IfcAlignmentSegment>();
+    alignment_segment.setGlobalId(ifcopenshell::global_id());
+    alignment_segment.setDesignParameters(design_parameters);
 
     return {curve_segment, alignment_segment};
 }
 
 // creates representations for each IfcAlignmentSegment per CT 4.1.7.1.1.4
 // https://standards.buildingsmart.org/IFC/RELEASE/IFC4_3/HTML/concepts/Product_Shape/Product_Geometric_Representation/Alignment_Geometry/Alignment_Geometry_-_Segments/content.html
-void create_segment_representations(IfcHierarchyHelper<Schema>& file, Schema::IfcLocalPlacement* global_placement, Schema::IfcGeometricRepresentationSubContext* segment_axis_subcontext, typename aggregate_of<typename Schema::IfcSegment>::ptr curve_segments, typename aggregate_of<typename Schema::IfcObjectDefinition>::ptr segments) {
-    auto cs_iter = curve_segments->begin();
-    auto s_iter = segments->begin();
-    for (; cs_iter != curve_segments->end(); cs_iter++, s_iter++) {
-        auto curve_segment = *cs_iter;
-        auto alignment_segment = (*s_iter)->as<Schema::IfcAlignmentSegment>();
+void create_segment_representations(hierarchy_helper<Schema>& file, const Schema::IfcLocalPlacement& global_placement, const Schema::IfcGeometricRepresentationSubContext& segment_axis_subcontext, std::vector<Schema::IfcSegment>& curve_segments, std::vector<Schema::IfcObjectDefinition>& segments) {
+    auto cs_iter = curve_segments.begin();
+    auto s_iter = segments.begin();
+    for (; cs_iter != curve_segments.end(); cs_iter++, s_iter++) {
+        auto& curve_segment = *cs_iter;
+        auto alignment_segment = (*s_iter).as<Schema::IfcAlignmentSegment>();
 
-        typename aggregate_of<typename Schema::IfcRepresentationItem>::ptr representation_items(new aggregate_of<typename Schema::IfcRepresentationItem>());
-        representation_items->push(curve_segment);
+        auto axis_representation = file.create<Schema::IfcShapeRepresentation>();
+        axis_representation.setContextOfItems(segment_axis_subcontext);
+        axis_representation.setRepresentationIdentifier("Axis");
+        axis_representation.setRepresentationType("Segment");
+        axis_representation.setItems({curve_segment});
 
-        auto axis_representation = new Schema::IfcShapeRepresentation(segment_axis_subcontext, std::string("Axis"), std::string("Segment"), representation_items);
-        file.addEntity(axis_representation);
+        auto product = file.create<Schema::IfcProductDefinitionShape>();
+        product.setRepresentations({axis_representation});
 
-        typename aggregate_of<typename Schema::IfcRepresentation>::ptr representations(new aggregate_of<typename Schema::IfcRepresentation>());
-        representations->push(axis_representation);
-
-        auto product = new Schema::IfcProductDefinitionShape(boost::none, boost::none, representations);
-        file.addEntity(product);
-
-        alignment_segment->setObjectPlacement(global_placement);
-        alignment_segment->setRepresentation(product);
+        alignment_segment.setObjectPlacement(global_placement);
+        alignment_segment.setRepresentation(product);
     }
 }
 
 int main() {
-    IfcHierarchyHelper<Schema> file;
+    hierarchy_helper<Schema> file;
 
     auto project = setup_project(file);
 
     auto geometric_representation_context = file.getRepresentationContext(std::string("Model")); // creates the representation context if it doesn't already exist
 
-    auto axis_model_representation_subcontext = new Schema::IfcGeometricRepresentationSubContext(std::string("Axis"), std::string("Model"), geometric_representation_context, boost::none, Schema::IfcGeometricProjectionEnum::IfcGeometricProjection_MODEL_VIEW, boost::none);
-    file.addEntity(axis_model_representation_subcontext);
+    auto axis_model_representation_subcontext = file.create<Schema::IfcGeometricRepresentationSubContext>();
+    axis_model_representation_subcontext.setContextIdentifier("Axis");
+    axis_model_representation_subcontext.setContextType("Model");
+    axis_model_representation_subcontext.setParentContext(geometric_representation_context);
+    axis_model_representation_subcontext.setTargetView(Schema::IfcGeometricProjectionEnum::IfcGeometricProjection_MODEL_VIEW);
 
     auto global_placement = file.addLocalPlacement();
 
@@ -251,86 +326,91 @@ int main() {
     double angle_4 = to_radian(289.0395);
 
     // create containers to store the curve segments
-    typename aggregate_of<typename Schema::IfcSegment>::ptr horizontal_curve_segments(new aggregate_of<typename Schema::IfcSegment>());             // geometry
-    typename aggregate_of<typename Schema::IfcObjectDefinition>::ptr horizontal_segments(new aggregate_of<typename Schema::IfcObjectDefinition>()); // business logic
+    std::vector<Schema::IfcSegment> horizontal_curve_segments;    // geometry
+    std::vector<Schema::IfcObjectDefinition> horizontal_segments; // business logic
 
     //
     // Build the horizontal alignment segments
     //
 
     // POB to PC1
-    auto curve_segment_1 = create_tangent(pob, angle_1, run_1);
-    horizontal_curve_segments->push(curve_segment_1.first);
-    horizontal_segments->push(curve_segment_1.second);
+    auto curve_segment_1 = create_tangent(file, pob, angle_1, run_1);
+    horizontal_curve_segments.push_back(curve_segment_1.first);
+    horizontal_segments.push_back(curve_segment_1.second);
 
     // Curve 1
-    auto curve_segment_2 = create_hcurve(pc1, angle_1, rc_1, lc_1);
-    horizontal_curve_segments->push(curve_segment_2.first);
-    horizontal_segments->push(curve_segment_2.second);
+    auto curve_segment_2 = create_hcurve(file, pc1, angle_1, rc_1, lc_1);
+    horizontal_curve_segments.push_back(curve_segment_2.first);
+    horizontal_segments.push_back(curve_segment_2.second);
 
     // PT1 to PC2
-    auto curve_segment_3 = create_tangent(pt1, angle_2, run_2);
-    horizontal_curve_segments->push(curve_segment_3.first);
-    horizontal_segments->push(curve_segment_3.second);
+    auto curve_segment_3 = create_tangent(file, pt1, angle_2, run_2);
+    horizontal_curve_segments.push_back(curve_segment_3.first);
+    horizontal_segments.push_back(curve_segment_3.second);
 
     // Curve 2
-    auto curve_segment_4 = create_hcurve(pc2, angle_2, rc_2, lc_2);
-    horizontal_curve_segments->push(curve_segment_4.first);
-    horizontal_segments->push(curve_segment_4.second);
+    auto curve_segment_4 = create_hcurve(file, pc2, angle_2, rc_2, lc_2);
+    horizontal_curve_segments.push_back(curve_segment_4.first);
+    horizontal_segments.push_back(curve_segment_4.second);
 
     // PT2 to PC3
-    auto curve_segment_5 = create_tangent(pt2, angle_3, run_3);
-    horizontal_curve_segments->push(curve_segment_5.first);
-    horizontal_segments->push(curve_segment_5.second);
+    auto curve_segment_5 = create_tangent(file, pt2, angle_3, run_3);
+    horizontal_curve_segments.push_back(curve_segment_5.first);
+    horizontal_segments.push_back(curve_segment_5.second);
 
     // Curve 3
-    auto curve_segment_6 = create_hcurve(pc3, angle_3, rc_3, lc_3);
-    horizontal_curve_segments->push(curve_segment_6.first);
-    horizontal_segments->push(curve_segment_6.second);
+    auto curve_segment_6 = create_hcurve(file, pc3, angle_3, rc_3, lc_3);
+    horizontal_curve_segments.push_back(curve_segment_6.first);
+    horizontal_segments.push_back(curve_segment_6.second);
 
     // PT3 to POE
-    auto curve_segment_7 = create_tangent(pt3, angle_4, run_4);
-    horizontal_curve_segments->push(curve_segment_7.first);
-    horizontal_segments->push(curve_segment_7.second);
+    auto curve_segment_7 = create_tangent(file, pt3, angle_4, run_4);
+    horizontal_curve_segments.push_back(curve_segment_7.first);
+    horizontal_segments.push_back(curve_segment_7.second);
 
     // Zero-length terminator segment
-    auto terminator_segment = create_tangent(poe, angle_4, 0.0);
-    terminator_segment.first->setTransition(Schema::IfcTransitionCode::IfcTransitionCode_DISCONTINUOUS);
-    horizontal_curve_segments->push(terminator_segment.first);
-    horizontal_segments->push(terminator_segment.second);
+    auto terminator_segment = create_tangent(file, poe, angle_4, 0.0);
+    terminator_segment.first.setTransition(Schema::IfcTransitionCode::IfcTransitionCode_DISCONTINUOUS);
+    horizontal_curve_segments.push_back(terminator_segment.first);
+    horizontal_segments.push_back(terminator_segment.second);
 
     //
     // Create the horizontal alignment (IfcAlignmentHorizontal) and nest alignment segments
     //
-    auto horizontal_alignment = new Schema::IfcAlignmentHorizontal(IfcParse::IfcGlobalId(), nullptr, std::string("Horizontal Alignment"), boost::none, boost::none, nullptr, nullptr);
-    file.addEntity(horizontal_alignment);
-
-    auto nests_horizontal_segments = new Schema::IfcRelNests(IfcParse::IfcGlobalId(), nullptr, boost::none, std::string("Nests horizontal alignment segments with horizontal alignment"), horizontal_alignment, horizontal_segments);
-    file.addEntity(nests_horizontal_segments);
+    auto horizontal_alignment = file.create<Schema::IfcAlignmentHorizontal>();
+    horizontal_alignment.setGlobalId(ifcopenshell::global_id());
+    horizontal_alignment.setName("Example Alignment");
 
+    auto nests_horizontal_segments = file.create<Schema::IfcRelNests>();
+    nests_horizontal_segments.setGlobalId(ifcopenshell::global_id());
+    nests_horizontal_segments.setName("Nests horizontal alignment segments with horizontal alignment");
+    nests_horizontal_segments.setRelatingObject(horizontal_alignment);
+    nests_horizontal_segments.setRelatedObjects(horizontal_segments);
+    
     //
     // Create plan view footprint model representation for the horizontal alignment
     //
 
     // start by defining a composite curve composed of the horizonal curve segments
-    auto composite_curve = new Schema::IfcCompositeCurve(horizontal_curve_segments, false /*not self-intersecting*/);
-    file.addEntity(composite_curve);
-
-    // the composite curve is a representation item
-    typename aggregate_of<typename Schema::IfcRepresentationItem>::ptr alignment_representation_items(new aggregate_of<typename Schema::IfcRepresentationItem>());
-    alignment_representation_items->push(composite_curve);
+    auto composite_curve = file.create<Schema::IfcCompositeCurve>();
+    composite_curve.setSegments(horizontal_curve_segments);
+    composite_curve.setSelfIntersect(false);
 
     // create the footprint representation
-    auto footprint_shape_representation = new Schema::IfcShapeRepresentation(axis_model_representation_subcontext, std::string("FootPrint"), std::string("Curve2D"), alignment_representation_items);
-    file.addEntity(footprint_shape_representation);
-
+    auto footprint_shape_representation = file.create<Schema::IfcShapeRepresentation>();
+    footprint_shape_representation.setContextOfItems(axis_model_representation_subcontext);
+    footprint_shape_representation.setRepresentationIdentifier("Footprint");
+    footprint_shape_representation.setRepresentationType("Curve2D");
+    // the composite curve is a representation item
+    footprint_shape_representation.setItems({composite_curve});
+    
     //
     // Define vertical profile segments
     //
 
     // create containers to store the curve segments
-    typename aggregate_of<typename Schema::IfcSegment>::ptr vertical_curve_segments(new aggregate_of<typename Schema::IfcSegment>());             // geometry
-    typename aggregate_of<typename Schema::IfcObjectDefinition>::ptr vertical_segments(new aggregate_of<typename Schema::IfcObjectDefinition>()); // business logic
+    std::vector<Schema::IfcSegment> vertical_curve_segments;    // geometry
+    std::vector<Schema::IfcObjectDefinition> vertical_segments; // business logic
 
     // define key profile points
     auto vpob = file.addDoublet<Schema::IfcCartesianPoint>(0.0, 100.0);     // beginning
@@ -349,80 +429,86 @@ int main() {
     //
 
     // Grade start to VPC1
-    auto vertical_profile_segment_1 = create_gradient(vpob, 1.75 / 100, 1200);
-    vertical_curve_segments->push(vertical_profile_segment_1.first);
-    vertical_segments->push(vertical_profile_segment_1.second);
+    auto vertical_profile_segment_1 = create_gradient(file, vpob, 1.75 / 100, 1200);
+    vertical_curve_segments.push_back(vertical_profile_segment_1.first);
+    vertical_segments.push_back(vertical_profile_segment_1.second);
 
     // Vertical Curve 1
-    auto vertical_profile_segment_2 = create_vcurve(vpc1, 1.75 / 100, -1.0 / 100, 1600);
-    vertical_curve_segments->push(vertical_profile_segment_2.first);
-    vertical_segments->push(vertical_profile_segment_2.second);
+    auto vertical_profile_segment_2 = create_vcurve(file, vpc1, 1.75 / 100, -1.0 / 100, 1600);
+    vertical_curve_segments.push_back(vertical_profile_segment_2.first);
+    vertical_segments.push_back(vertical_profile_segment_2.second);
 
     // Grade VPT1 to VPC2
-    auto vertical_profile_segment_3 = create_gradient(vpt1, -1.0 / 100, 1600);
-    vertical_curve_segments->push(vertical_profile_segment_3.first);
-    vertical_segments->push(vertical_profile_segment_3.second);
+    auto vertical_profile_segment_3 = create_gradient(file, vpt1, -1.0 / 100, 1600);
+    vertical_curve_segments.push_back(vertical_profile_segment_3.first);
+    vertical_segments.push_back(vertical_profile_segment_3.second);
 
     // Vertical Curve 2
-    auto vertical_profile_segment_4 = create_vcurve(vpc2, -1.0 / 100, 2.0 / 100, 1200);
-    vertical_curve_segments->push(vertical_profile_segment_4.first);
-    vertical_segments->push(vertical_profile_segment_4.second);
+    auto vertical_profile_segment_4 = create_vcurve(file, vpc2, -1.0 / 100, 2.0 / 100, 1200);
+    vertical_curve_segments.push_back(vertical_profile_segment_4.first);
+    vertical_segments.push_back(vertical_profile_segment_4.second);
 
     // Grade PVT2 to VPC3
-    auto vertical_profile_segment_5 = create_gradient(vpt2, 2.0 / 100, 800);
-    vertical_curve_segments->push(vertical_profile_segment_5.first);
-    vertical_segments->push(vertical_profile_segment_5.second);
+    auto vertical_profile_segment_5 = create_gradient(file, vpt2, 2.0 / 100, 800);
+    vertical_curve_segments.push_back(vertical_profile_segment_5.first);
+    vertical_segments.push_back(vertical_profile_segment_5.second);
 
     // Vertical Curve 3
-    auto vertical_profile_segment_6 = create_vcurve(vpc3, 2.0 / 100, -2.0 / 100, 2000);
-    vertical_curve_segments->push(vertical_profile_segment_6.first);
-    vertical_segments->push(vertical_profile_segment_6.second);
+    auto vertical_profile_segment_6 = create_vcurve(file, vpc3, 2.0 / 100, -2.0 / 100, 2000);
+    vertical_curve_segments.push_back(vertical_profile_segment_6.first);
+    vertical_segments.push_back(vertical_profile_segment_6.second);
 
     // Grade PVT3 to VPC4
-    auto vertical_profile_segment_7 = create_gradient(vpt3, -2.0 / 100, 1000);
-    vertical_curve_segments->push(vertical_profile_segment_7.first);
-    vertical_segments->push(vertical_profile_segment_7.second);
+    auto vertical_profile_segment_7 = create_gradient(file, vpt3, -2.0 / 100, 1000);
+    vertical_curve_segments.push_back(vertical_profile_segment_7.first);
+    vertical_segments.push_back(vertical_profile_segment_7.second);
 
     // Vertical Curve 4
-    auto vertical_profile_segment_8 = create_vcurve(vpc4, -2.0 / 100, -0.5 / 100, 800);
-    vertical_curve_segments->push(vertical_profile_segment_8.first);
-    vertical_segments->push(vertical_profile_segment_8.second);
+    auto vertical_profile_segment_8 = create_vcurve(file, vpc4, -2.0 / 100, -0.5 / 100, 800);
+    vertical_curve_segments.push_back(vertical_profile_segment_8.first);
+    vertical_segments.push_back(vertical_profile_segment_8.second);
 
     // Grade VPT4 to End
-    auto vertical_profile_segment_9 = create_gradient(vpt4, -0.5 / 100, 2600);
-    vertical_curve_segments->push(vertical_profile_segment_9.first);
-    vertical_segments->push(vertical_profile_segment_9.second);
+    auto vertical_profile_segment_9 = create_gradient(file, vpt4, -0.5 / 100, 2600);
+    vertical_curve_segments.push_back(vertical_profile_segment_9.first);
+    vertical_segments.push_back(vertical_profile_segment_9.second);
 
     // Zero-length terminator
-    auto vertical_terminator_segment = create_gradient(vpoe, -0.5 / 100, 0.0);
-    vertical_terminator_segment.first->setTransition(Schema::IfcTransitionCode::IfcTransitionCode_DISCONTINUOUS);
-    vertical_curve_segments->push(vertical_terminator_segment.first);
-    vertical_segments->push(vertical_terminator_segment.second);
+    auto vertical_terminator_segment = create_gradient(file, vpoe, -0.5 / 100, 0.0);
+    vertical_terminator_segment.first.setTransition(Schema::IfcTransitionCode::IfcTransitionCode_DISCONTINUOUS);
+    vertical_curve_segments.push_back(vertical_terminator_segment.first);
+    vertical_segments.push_back(vertical_terminator_segment.second);
 
     //
     // Create the vertical alignment (IfcAlignmentVertical) and nest alignment segments
     //
-    auto vertical_profile = new Schema::IfcAlignmentVertical(IfcParse::IfcGlobalId(), nullptr, std::string("Vertical Alignment"), boost::none, boost::none, nullptr, nullptr);
-    file.addEntity(vertical_profile);
+    auto vertical_profile = file.create<Schema::IfcAlignmentVertical>();
+    vertical_profile.setGlobalId(ifcopenshell::global_id());
+    vertical_profile.setName("Example Vertical Profile");
 
-    auto nests_vertical_segments = new Schema::IfcRelNests(IfcParse::IfcGlobalId(), nullptr, boost::none, std::string("Nests vertical alignment segments with vertical alignment"), vertical_profile, vertical_segments);
-    file.addEntity(nests_vertical_segments);
+    auto nests_vertical_segments = file.create<Schema::IfcRelNests>();
+    nests_vertical_segments.setGlobalId(ifcopenshell::global_id());
+    nests_vertical_segments.setName("Nests vertical alignment segments with vertical profile");
+    nests_vertical_segments.setRelatingObject(vertical_profile);
+    nests_vertical_segments.setRelatedObjects(vertical_segments);
 
     //
     // Create profile view axis model representation for the vertical profile
     //
 
     // start by defining a gradient curve composed of the vertical curve segments and associated with the horizontal composite curve
-    auto gradient_curve = new Schema::IfcGradientCurve(vertical_curve_segments, false, composite_curve, nullptr);
-    file.addEntity(gradient_curve);
-
-    // the gradient curve is a representation item
-    typename aggregate_of<typename Schema::IfcRepresentationItem>::ptr profile_representation_items(new aggregate_of<typename Schema::IfcRepresentationItem>());
-    profile_representation_items->push(gradient_curve);
+    auto gradient_curve = file.create<Schema::IfcGradientCurve>();
+    gradient_curve.setSegments(vertical_curve_segments);
+    gradient_curve.setSelfIntersect(false);
+    gradient_curve.setBaseCurve(composite_curve);
 
     // create the axis representation
-    auto axis3d_shape_representation = new Schema::IfcShapeRepresentation(axis_model_representation_subcontext, std::string("Axis"), std::string("Curve3D"), profile_representation_items);
-    file.addEntity(axis3d_shape_representation);
+    auto axis3d_shape_representation = file.create<Schema::IfcShapeRepresentation>();
+    axis3d_shape_representation.setContextOfItems(axis_model_representation_subcontext);
+    axis3d_shape_representation.setRepresentationIdentifier("Axis");
+    axis3d_shape_representation.setRepresentationType("Curve3D");
+    // the gradient curve is a representation item
+    axis3d_shape_representation.setItems({gradient_curve});
 
     // create axis representations for each segment
     create_segment_representations(file, global_placement, axis_model_representation_subcontext, horizontal_curve_segments, horizontal_segments);
@@ -432,38 +518,39 @@ int main() {
     // Create the IfcAlignment
     //
 
-    // the alignment has two representations, a plan view footprint and a 3d curve
-    typename aggregate_of<typename Schema::IfcRepresentation>::ptr alignment_representations(new aggregate_of<typename Schema::IfcRepresentation>());
-    alignment_representations->push(footprint_shape_representation); // 2D footprint
-    alignment_representations->push(axis3d_shape_representation);    // 3D curve
-
     // create the alignment product definition
-    auto alignment_product = new Schema::IfcProductDefinitionShape(std::string("Alignment Product Definition Shape"), boost::none, alignment_representations);
+    auto alignment_product = file.create<Schema::IfcProductDefinitionShape>();
+    alignment_product.setName("Alignment Product Definition Shape");
+    // the alignment has two representations, a plan view footprint and a 3d curve
+    alignment_product.setRepresentations({footprint_shape_representation, axis3d_shape_representation});
 
     // create the alignment
-    auto alignment = new Schema::IfcAlignment(IfcParse::IfcGlobalId(), nullptr, std::string("Example Alignment"), boost::none, boost::none, global_placement, alignment_product, boost::none);
-    file.addEntity(alignment);
+    auto alignment = file.create<Schema::IfcAlignment>();
+    alignment.setGlobalId(ifcopenshell::global_id());
+    alignment.setName("Example Alignment");
+    alignment.setObjectPlacement(global_placement);
+    alignment.setRepresentation(alignment_product);
 
     // Nest the IfcAlignmentHorizontal and IfcAlignmentVertical with the IfcAlignment to complete the business logic
     // 4.1.4.4.1 Alignments nest horizontal and vertical layouts
     // https://standards.buildingsmart.org/IFC/RELEASE/IFC4_3/HTML/concepts/Object_Composition/Nesting/Alignment_Layouts/content.html
-    typename aggregate_of<typename Schema::IfcObjectDefinition>::ptr alignment_layout_list(new aggregate_of<typename Schema::IfcObjectDefinition>());
-    alignment_layout_list->push(horizontal_alignment);
-    alignment_layout_list->push(vertical_profile);
-
-    auto nests_alignment_layouts = new Schema::IfcRelNests(IfcParse::IfcGlobalId(), nullptr, std::string("Nest horizontal and vertical alignment layouts with the alignment"), boost::none, alignment, alignment_layout_list);
-    file.addEntity(nests_alignment_layouts);
-
+    auto nests_alignment_layouts = file.create<Schema::IfcRelNests>();
+    nests_alignment_layouts.setGlobalId(ifcopenshell::global_id());
+    nests_alignment_layouts.setName("Nest horizontal and vertical alignment layouts with the alignment");
+    nests_alignment_layouts.setRelatingObject(alignment);
+    nests_alignment_layouts.setRelatedObjects({horizontal_alignment, vertical_profile});
+    
     // Define the relationship with the project
 
     // IFC 4.1.4.1.1 "Every IfcAlignment must be related to IfcProject using the IfcRelAggregates relationship"
     // https://standards.buildingsmart.org/IFC/RELEASE/IFC4_3/HTML/concepts/Object_Composition/Aggregation/Alignment_Aggregation_To_Project/content.html
     // IfcProject <-> IfcRelAggregates <-> IfcAlignment
-    typename aggregate_of<typename Schema::IfcObjectDefinition>::ptr list_of_alignments_in_project(new aggregate_of<typename Schema::IfcObjectDefinition>());
-    list_of_alignments_in_project->push(alignment);
-    auto aggregate_alignments_with_project = new Schema::IfcRelAggregates(IfcParse::IfcGlobalId(), nullptr, std::string("Alignments in project"), boost::none, project, list_of_alignments_in_project);
-    file.addEntity(aggregate_alignments_with_project);
-
+    auto aggregate_alignments_with_project = file.create<Schema::IfcRelAggregates>();
+    aggregate_alignments_with_project.setGlobalId(ifcopenshell::global_id());
+    aggregate_alignments_with_project.setName("Alignments in project");
+    aggregate_alignments_with_project.setRelatingObject(project);
+    aggregate_alignments_with_project.setRelatedObjects({alignment});
+    
     // Define the spatial structure of the alignment with respect to the site
 
     // IFC 4.1.5.1 alignment is referenced in spatial structure of an IfcSpatialElement. In this case IfcSite is the highest level IfcSpatialElement
@@ -471,24 +558,26 @@ int main() {
     // IfcSite <-> IfcRelReferencedInSpatialStructure <-> IfcAlignment
     // This means IfcAlignment is not part of the IfcSite (it is not an aggregate component) but instead IfcAlignment is used within
     // the IfcSite by reference. This implies an IfcAlignment can traverse many IfcSite instances within an IfcProject
-    typename Schema::IfcSpatialReferenceSelect::list::ptr list_alignments_referenced_in_site(new Schema::IfcSpatialReferenceSelect::list);
-    list_alignments_referenced_in_site->push(alignment);
+    std::vector<Schema::IfcSpatialReferenceSelect> list_alignments_referenced_in_site{alignment};
 
     // this alignment traverse 3 bridge sites.
     for (int i = 1; i <= 3; i++) {
         std::ostringstream os;
         os << "Site of Bridge " << i;
-        auto site = file.addSite(project, nullptr);
-        site->setName(os.str());
+        auto site = file.addSite(project);
+        site.setName(os.str());
 
         std::ostringstream description;
         description << "Alignments referenced into the spatial structure of Bridge Site " << i;
 
-        auto rel_referenced_in_spatial_structure = new Schema::IfcRelReferencedInSpatialStructure(IfcParse::IfcGlobalId(), nullptr, boost::none, description.str(), list_alignments_referenced_in_site, site);
-        file.addEntity(rel_referenced_in_spatial_structure);
+        auto rel_referenced_in_spatial_structure = file.create<Schema::IfcRelReferencedInSpatialStructure>();
+        rel_referenced_in_spatial_structure.setGlobalId(ifcopenshell::global_id());
+        rel_referenced_in_spatial_structure.setDescription(description.str());
+        rel_referenced_in_spatial_structure.setRelatedElements(list_alignments_referenced_in_site);
+        rel_referenced_in_spatial_structure.setRelatingStructure(site);
     }
 
     // That's it - save the model to a file
-    std::ofstream ofs("IfcAlignment.ifc");
+    std::ofstream ofs("FHWA_Bridge_Geometry_Alignment_Example.ifc");
     ofs << file;
 }

src/examples/IfcOpenHouse.cpp

@@ -36,12 +36,11 @@
 #include <Precision.hxx>
 
 #define IfcSchema Ifc2x3
-#include "ifcparse/macros.h"
-#include "ifcparse/Ifc2x3.h"
-#include "ifcparse/IfcBaseClass.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/macros.h"
+#include "../ifcparse/schemas/Ifc2x3.h"
+#include "../ifcparse/hierarchy_helper.h"
 
-#include "ifcgeom/Serialization/Serialization.h"
+#include "../ifcgeom/Serialization/Serialization.h"
 
 #if USE_VLD
 #include <vld.h>
@@ -50,7 +49,7 @@
 using namespace std::string_literals;
 
 // Some convenience typedefs and definitions. 
-typedef IfcParse::IfcGlobalId guid;
+typedef ifcopenshell::global_id guid;
 typedef std::pair<double, double> XY;
 boost::none_t const null = boost::none;
 
@@ -59,235 +58,276 @@ void createGroundShape(TopoDS_Shape& shape);
 
 int main() {
 
-	// The IfcHierarchyHelper is a subclass of the regular IfcFile that provides several
-	// convenience functions for working with geometry in IFC files.
-	IfcHierarchyHelper<IfcSchema> file;
-	file.header().file_name()->setname("IfcOpenHouse.ifc");
+    // The hierarchy_helper is a subclass of the regular file that provides several
+    // convenience functions for working with geometry in IFC files.
+    hierarchy_helper<IfcSchema> file;
+    file.header().file_name().setname("IfcOpenHouse.ifc");
 
-	// Start by adding a wall to the file, initially leaving most attributes blank.
-	IfcSchema::IfcWallStandardCase* south_wall = new IfcSchema::IfcWallStandardCase(
-		guid(), 			// GlobalId
-		0, 					// OwnerHistory
-		"South wall"s,	 	// Name
-		null, 				// Description
-		null, 				// ObjectType
-		0, 					// ObjectPlacement
-		0, 					// Representation
-		null				// Tag
+    // Start by adding a wall to the file, initially leaving most attributes blank.
+    auto south_wall = file.create<IfcSchema::IfcWallStandardCase>();
+    south_wall.setGlobalId(guid());
+    south_wall.setName("South wall");
 #ifdef USE_IFC4
-		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
+    south_wall.setPredefinedType(IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD);
 #endif
-	);
-	file.addBuildingProduct(south_wall);
+    file.addBuildingProduct(south_wall);
 
-	// By adding a wall, a hierarchy has been automatically created that consists of the following
-	// structure: IfcProject > IfcSite > IfcBuilding > IfcBuildingStorey > IfcWall
+    // By adding a wall, a hierarchy has been automatically created that consists of the following
+    // structure: IfcProject > IfcSite > IfcBuilding > IfcBuildingStorey > IfcWall
 
-	// Lateron changing the name of the IfcProject can be done by obtaining a reference to the 
-	// project, which has been created automatically.
-	file.getSingle<IfcSchema::IfcProject>()->setName("IfcOpenHouse"s);
+    // Lateron changing the name of the IfcProject can be done by obtaining a reference to the
+    // project, which has been created automatically.
+    file.getSingle<IfcSchema::IfcProject>().setName("IfcOpenHouse"s);
 
-	// An IfcOwnerHistory has been initialized as well, which should be assigned to the wall.
-	south_wall->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    // An IfcOwnerHistory has been initialized as well, which should be assigned to the wall.
+    south_wall.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
 
-	// The wall will be shaped as a box, with the dimensions specified in millimeters. The resulting
-	// product definition will consist of both a body representation as well as an axis representation
-	// that runs over the centerline of the box in the X-axis.
-	IfcSchema::IfcProductDefinitionShape* south_wall_shape = file.addAxisBox(10000, 360, 3000);
+    // The wall will be shaped as a box, with the dimensions specified in millimeters. The resulting
+    // product definition will consist of both a body representation as well as an axis representation
+    // that runs over the centerline of the box in the X-axis.
+    auto south_wall_shape = file.addAxisBox(10000, 360, 3000);
 
-	// Obtain a reference to the placement of the IfcBuildingStorey in order to create a hierarchy
-	// of placements for the products
-	IfcSchema::IfcObjectPlacement* storey_placement = file.getSingle<IfcSchema::IfcBuildingStorey>()->ObjectPlacement();
+    // Obtain a reference to the placement of the IfcBuildingStorey in order to create a hierarchy
+    // of placements for the products
+    auto storey_placement = file.getSingle<IfcSchema::IfcBuildingStorey>().ObjectPlacement();
 
-	// The shape has to be assigned to the representation of the wall and is placed at the origin
-	// of the coordinate system.
-	south_wall->setRepresentation(south_wall_shape);
-	south_wall->setObjectPlacement(file.addLocalPlacement(storey_placement));
+    // The shape has to be assigned to the representation of the wall and is placed at the origin
+    // of the coordinate system.
+    south_wall.setRepresentation(south_wall_shape);
+    south_wall.setObjectPlacement(file.addLocalPlacement(storey_placement));
 
-	// A pale white colour is assigned to the wall.
-	IfcSchema::IfcPresentationStyleAssignment* wall_colour = setSurfaceColour(file, south_wall_shape, 0.75, 0.73, 0.68);
+    // A pale white colour is assigned to the wall.
+    auto wall_colour = setSurfaceColour(file, south_wall_shape, 0.75, 0.73, 0.68);
 
-	// Now create a footing for the wall to rest on.
-	IfcSchema::IfcFooting* footing = new IfcSchema::IfcFooting(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		"Footing"s, null, null, 0, 0, null, IfcSchema::IfcFootingTypeEnum::IfcFootingType_STRIP_FOOTING);
+    // Now create a footing for the wall to rest on.
+    auto footing = file.create<IfcSchema::IfcFooting>();
+    footing.setGlobalId(guid());
+    footing.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    footing.setName("Footing");
+    footing.setPredefinedType(IfcSchema::IfcFootingTypeEnum::IfcFootingType_STRIP_FOOTING);
 
-	file.addBuildingProduct(footing);
+    file.addBuildingProduct(footing);
 
-	// The footing will span the entire floor plan of our building. The IfcRepresentationContext is
-	// something that has been created automatically as well, but representations could have been 
-	// assigned to a specific context, for example to add a two dimensional plan representation as well.
-	footing->setRepresentation(file.addBox(10100, 5460, 2000));
-	footing->setObjectPlacement(file.addLocalPlacement(storey_placement, 0, 2500, -2000));
-	// The footing will have a dark gray colour
-	IfcSchema::IfcPresentationStyleAssignment* footing_colour = setSurfaceColour(file,footing->Representation(), 0.26, 0.22, 0.18);
+    // The footing will span the entire floor plan of our building. The IfcRepresentationContext is
+    // something that has been created automatically as well, but representations could have been
+    // assigned to a specific context, for example to add a two dimensional plan representation as well.
+    footing.setRepresentation(file.addBox(10100, 5460, 2000));
+    footing.setObjectPlacement(file.addLocalPlacement(storey_placement, 0, 2500, -2000));
+    // The footing will have a dark gray colour
+    auto footing_colour = setSurfaceColour(file, footing.Representation(), 0.26, 0.22, 0.18);
 
-	// IFC has two ways to apply boolean operations to geometry. IfcBooleanResults are commonly used 
-	// to clip geometry to a surface, for example to a slanted roof. For openings that are filled 
-	// with another element, for example a door or a window, an IfcOpeningElement is used instead.
+    // IFC has two ways to apply boolean operations to geometry. IfcBooleanResults are commonly used
+    // to clip geometry to a surface, for example to a slanted roof. For openings that are filled
+    // with another element, for example a door or a window, an IfcOpeningElement is used instead.
 
-	// An opening element is created with rectangular geometry:
-	IfcSchema::IfcOpeningElement* west_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(south_wall->ObjectPlacement(), -2500, 0, 400),
-		file.addBox(6000, 3630, 1600), null
+    // An opening element is created with rectangular geometry:
+    auto west_opening = file.create<IfcSchema::IfcOpeningElement>();
+    west_opening.setGlobalId(guid());
+    west_opening.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    west_opening.setObjectPlacement(file.addLocalPlacement(south_wall.ObjectPlacement(), -2500, 0, 400));
+    west_opening.setRepresentation(file.addBox(6000, 3630, 1600));
 #ifdef USE_IFC4
-		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
+    west_opening.setPredefinedType(IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING);
 #endif
-	);
-	file.addEntity(west_opening);
 
-	// Relate the opening element to the wall.
-	IfcSchema::IfcRelVoidsElement* void_element = new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, south_wall, west_opening);
-	file.addEntity(void_element);
+    // Relate the opening element to the wall.
+    auto void_element = file.create<IfcSchema::IfcRelVoidsElement>();
+    void_element.setGlobalId(guid());
+    void_element.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    void_element.setRelatingBuildingElement(south_wall);
+    void_element.setRelatedOpeningElement(west_opening);
 
-	// Now create an additional opening
-	IfcSchema::IfcOpeningElement* south_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(storey_placement, 3000, 0, 400),
-		file.addBox(1860, 3000, 1600), null
+    // Now create an additional opening
+    auto south_opening = file.create<IfcSchema::IfcOpeningElement>();
+    south_opening.setGlobalId(guid());
+    south_opening.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    south_opening.setObjectPlacement(file.addLocalPlacement(storey_placement, 3000, 0, 400));
+    south_opening.setRepresentation(file.addBox(1860, 3000, 1600));
 #ifdef USE_IFC4
-		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
+    south_opening.setPredefinedType(IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING);
 #endif
-	);
-	file.addEntity(south_opening);
-	file.addEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, south_wall, south_opening));
-	
-	// Create a roof element that will consist of two slabs:
-	IfcSchema::IfcRoof* roof = new IfcSchema::IfcRoof(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), "Roof"s, null, null,
-		file.addLocalPlacement(storey_placement), 0, null, IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
 
-	// The roof geometry is slanted 45 degrees by specifying a direction for the box extrusion
-	IfcSchema::IfcShapeRepresentation* roof_rep = file.addEmptyRepresentation();
-	file.addBox(roof_rep, 10200, 360, sqrt(2.0*2900*2900), 0, file.addPlacement3d(0, 0, 0, 0, 1, 0),
-		file.addTriplet<IfcSchema::IfcDirection>(0, -sqrt(0.5), sqrt(0.5)));
+    // Relate the opening element to the wall.
+    auto void_element2 = file.create<IfcSchema::IfcRelVoidsElement>();
+    void_element2.setGlobalId(guid());
+    void_element2.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    void_element2.setRelatingBuildingElement(south_wall);
+    void_element2.setRelatedOpeningElement(south_opening);
 
-	// CV-2x3-144: Roofs are aggregates and shall have at least one contained element and no own geometry
-	IfcSchema::IfcSlab* south_roof_part = new IfcSchema::IfcSlab(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), "South roof"s, 
-		null, null, 0, 0, null, IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);
-	
-	// The geometry is instantiated by using IfcMappedItems. This way geometry definitions can
-	// be reused while maintaining the cardinality constraint that the ShapeOfProduct relation
-	// imposes on the IfcProductDefinitionShape. Note that this constrained is lifted in IFC4.
-	south_roof_part->setRepresentation(file.addMappedItem(roof_rep));
-	south_roof_part->setObjectPlacement(file.addLocalPlacement(roof->ObjectPlacement(), 0, -400, 2700));
-	
-	// The same roof geometry is re-used on the north side of the roof, by inverting the X-axis of
-	// the local placement the roof is rotated 180 degrees around the Z-axis
-	IfcSchema::IfcSlab* north_roof_part = new IfcSchema::IfcSlab(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), "North roof"s,
-		null, null, 0, 0, null, IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);
-	north_roof_part->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
-	north_roof_part->setRepresentation(file.addMappedItem(roof_rep));
-	north_roof_part->setObjectPlacement(file.addLocalPlacement(roof->ObjectPlacement(), 0, 5400, 2700, 0, 0, 1, -1, 0, 0));
-	
-	IfcSchema::IfcObjectDefinition::list::ptr roof_parts(new IfcSchema::IfcObjectDefinition::list);
-	roof_parts->push(south_roof_part);
-	roof_parts->push(north_roof_part);
-	IfcSchema::IfcRelDecomposes* roof_decomposition = new IfcSchema::IfcRelAggregates(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-			null, null, roof, roof_parts);
-	file.addEntity(roof_decomposition);
-
-	file.addBuildingProduct(south_roof_part);
-	file.addBuildingProduct(north_roof_part);
-	file.addBuildingProduct(roof);
-
-	setSurfaceColour(file, roof_rep, 0.24, 0.08, 0.04);
-
-	// Copy the south wall to the north
-	IfcSchema::IfcWallStandardCase* north_wall = new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), "North wall"s,
-		null, null, file.addLocalPlacement(storey_placement, 0, 5000, 0), file.addAxisBox(10000, 360, 3000), null
+    // Create a roof element that will consist of two slabs:
+    auto roof = file.create<IfcSchema::IfcRoof>();
+    roof.setGlobalId(guid());
+    roof.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    roof.setName("Roof");
+    roof.setObjectPlacement(file.addLocalPlacement(storey_placement));
 #ifdef USE_IFC4
-		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
-#endif	
-	);
-	file.addBuildingProduct(north_wall);
-	setSurfaceColour(file,north_wall->Representation(), wall_colour);
+    roof.setPredefinedType(IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
+#else
+    roof.setShapeType(IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
+#endif
 
-	// Two identical representations are created for the two remaining walls. Mapped items
-	// are not used, because it is not allowed by the standard for wall body representations.
-	// MappedItems are not allowed for Axis representations as per CV-2x3-161
-	IfcSchema::IfcProductDefinitionShape* clipped_wall_body_reps[2];
-	for (int i = 0; i < 2; ++i) {
-		IfcSchema::IfcShapeRepresentation* body = file.addEmptyRepresentation();
-		file.addBox(body, 5000, 360, 6000);
-		// The wall geometry is clipped using two IfcHalfSpaceSolids, created from an 
-		// 'axis 3d placement' that specifies the plane against which the geometry is clipped.
-		file.clipRepresentation(body, file.addPlacement3d(-2500, 0, 3000, -1, 0, 1), false);
-		file.clipRepresentation(body, file.addPlacement3d(2500, 0, 3000, 1, 0, 1), false);
-		setSurfaceColour(file, body, wall_colour);
+    // The roof geometry is slanted 45 degrees by specifying a direction for the box extrusion
+    auto roof_rep = file.addEmptyRepresentation();
+    file.addBox(roof_rep, 10200, 360, sqrt(2.0 * 2900 * 2900), IfcSchema::IfcAxis2Placement2D{}, file.addPlacement3d(0, 0, 0, 0, 1, 0), file.addTriplet<IfcSchema::IfcDirection>(0, -sqrt(0.5), sqrt(0.5)));
 
-		IfcSchema::IfcShapeRepresentation* axis = file.addEmptyRepresentation("Axis", "Curve2D");
-		file.addAxis(axis, 5000);
+    // CV-2x3-144: Roofs are aggregates and shall have at least one contained element and no own geometry
+    auto south_roof_part = file.create<IfcSchema::IfcSlab>();
+    south_roof_part.setGlobalId(guid());
+    south_roof_part.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    south_roof_part.setName("South roof");
+    south_roof_part.setPredefinedType(IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);
 
-		IfcSchema::IfcRepresentation::list::ptr reps(new IfcSchema::IfcRepresentation::list);
-		reps->push(body);
-		reps->push(axis);
-		clipped_wall_body_reps[i] = new IfcSchema::IfcProductDefinitionShape(null, null, reps);
-	}
+    // The geometry is instantiated by using IfcMappedItems. This way geometry definitions can
+    // be reused while maintaining the cardinality constraint that the ShapeOfProduct relation
+    // imposes on the IfcProductDefinitionShape. Note that this constrained is lifted in IFC4.
+    south_roof_part.setRepresentation(file.addMappedItem(roof_rep));
+    south_roof_part.setObjectPlacement(file.addLocalPlacement(roof.ObjectPlacement(), 0, -400, 2700));
 
-	// Now create a wall on the east of the building, again starting with just a box shape
-	IfcSchema::IfcWallStandardCase* east_wall = new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		"East wall"s, null, null, file.addLocalPlacement(storey_placement, 4820, 2500, 0, 0, 0, 1, 0, 1, 0), clipped_wall_body_reps[0], null
+    // The same roof geometry is re-used on the north side of the roof, by inverting the X-axis of
+    // the local placement the roof is rotated 180 degrees around the Z-axis
+    auto north_roof_part = file.create<IfcSchema::IfcSlab>();
+    north_roof_part.setGlobalId(guid());
+    north_roof_part.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    north_roof_part.setName("North roof");
+    north_roof_part.setPredefinedType(IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);
+
+    north_roof_part.setRepresentation(file.addMappedItem(roof_rep));
+    north_roof_part.setObjectPlacement(file.addLocalPlacement(roof.ObjectPlacement(), 0, 5400, 2700, 0, 0, 1, -1, 0, 0));
+
+    {
+        auto rel = file.create<IfcSchema::IfcRelAggregates>();
+        rel.setGlobalId(guid());
+        rel.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+        rel.setRelatingObject(roof);
+        rel.setRelatedObjects({south_roof_part, north_roof_part});
+    }
+
+    file.addBuildingProduct(south_roof_part);
+    file.addBuildingProduct(north_roof_part);
+    file.addBuildingProduct(roof);
+
+    setSurfaceColour(file, roof_rep, 0.24, 0.08, 0.04);
+
+    // Copy the south wall to the north
+    auto north_wall = file.create<IfcSchema::IfcWallStandardCase>();
+    north_wall.setGlobalId(guid());
+    north_wall.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    north_wall.setName("North wall");
+    north_wall.setObjectPlacement(file.addLocalPlacement(storey_placement, 0, 5000, 0));
+    north_wall.setRepresentation(file.addAxisBox(10000, 360, 3000));
 #ifdef USE_IFC4
-		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
-#endif	
-	);
-	file.addBuildingProduct(east_wall);
+    north_wall.setPredefinedType(IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD);
+#endif
 
-	// The east wall is copied to the west location of the house
-	IfcSchema::IfcWallStandardCase* west_wall = new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		"West wall"s, null, null, file.addLocalPlacement(storey_placement, -4820, 2500, 0, 0, 0, 1, 0, -1, 0), clipped_wall_body_reps[1], null
+    file.addBuildingProduct(north_wall);
+    setSurfaceColour(file, north_wall.Representation(), wall_colour);
+
+    // Two identical representations are created for the two remaining walls. Mapped items
+    // are not used, because it is not allowed by the standard for wall body representations.
+    // MappedItems are not allowed for Axis representations as per CV-2x3-161
+    IfcSchema::IfcProductDefinitionShape clipped_wall_body_reps[2];
+    for (int i = 0; i < 2; ++i) {
+        auto body = file.addEmptyRepresentation();
+        file.addBox(body, 5000, 360, 6000);
+        // The wall geometry is clipped using two IfcHalfSpaceSolids, created from an
+        // 'axis 3d placement' that specifies the plane against which the geometry is clipped.
+        file.clipRepresentation(body, file.addPlacement3d(-2500, 0, 3000, -1, 0, 1), false);
+        file.clipRepresentation(body, file.addPlacement3d(2500, 0, 3000, 1, 0, 1), false);
+        setSurfaceColour(file, body, wall_colour);
+
+        auto axis = file.addEmptyRepresentation("Axis", "Curve2D");
+        file.addAxis(axis, 5000);
+
+        clipped_wall_body_reps[i] = file.create<IfcSchema::IfcProductDefinitionShape>();
+        clipped_wall_body_reps[i].setRepresentations({body, axis});
+    }
+
+    // Now create a wall on the east of the building, again starting with just a box shape
+    auto east_wall = file.create<IfcSchema::IfcWallStandardCase>();
+    east_wall.setGlobalId(guid());
+    east_wall.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    east_wall.setName("East wall");
+    east_wall.setObjectPlacement(file.addLocalPlacement(storey_placement, 4820, 2500, 0, 0, 0, 1, 0, 1, 0));
+    east_wall.setRepresentation(clipped_wall_body_reps[0]);
 #ifdef USE_IFC4
-		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
-#endif	
-	);
-	file.addBuildingProduct(west_wall);
+    east_wall.setPredefinedType(IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD);
+#endif
 
-	// The west wall is assigned an opening element we created for the south wall, opening elements are
-	// not shared across building elements, even if they share the same representation. Hence, the east
-	// wall will not feature this opening.
-	// NB: an Opening Element can only be used to create a single void within a single Element, as per:
-	// http://www.buildingsmart-tech.org/ifc/IFC2x3/TC1/html/ifcproductextension/lexical/ifcfeatureelementsubtraction.htm
+    file.addBuildingProduct(east_wall);
 
-	// Not all viewers support opening elements with mapped representations, hence an exact copy of the
-	// same subtraction box is instantiated for the otherwise identical opening element.
-	IfcSchema::IfcOpeningElement* west_opening_copy = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(west_wall->ObjectPlacement(), 2500, -2500+4820, 400, 0, 0, 1, 0, 1, 0),
-		file.addBox(6000, 3630, 1600), null
+    // The east wall is copied to the west location of the house
+    auto west_wall = file.create<IfcSchema::IfcWallStandardCase>();
+    west_wall.setGlobalId(guid());
+    west_wall.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    west_wall.setName("West wall");
+    west_wall.setObjectPlacement(file.addLocalPlacement(storey_placement, -4820, 2500, 0, 0, 0, 1, 0, -1, 0));
+    west_wall.setRepresentation(clipped_wall_body_reps[1]);
 #ifdef USE_IFC4
-		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
-#endif	
-	);
-	file.addEntity(west_opening_copy);
-	file.addEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, west_wall, west_opening_copy));
-	
+    west_wall.setPredefinedType(IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD);
+#endif
+
+    file.addBuildingProduct(west_wall);
+
+    // The west wall is assigned an opening element we created for the south wall, opening elements are
+    // not shared across building elements, even if they share the same representation. Hence, the east
+    // wall will not feature this opening.
+    // NB: an Opening Element can only be used to create a single void within a single Element, as per:
+    // http://www.buildingsmart-tech.org/ifc/IFC2x3/TC1/html/ifcproductextension/lexical/ifcfeatureelementsubtraction.htm
+
+    // Not all viewers support opening elements with mapped representations, hence an exact copy of the
+    // same subtraction box is instantiated for the otherwise identical opening element.
+    auto west_opening_copy = file.create<IfcSchema::IfcOpeningElement>();
+    west_opening_copy.setGlobalId(guid());
+    west_opening_copy.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    west_opening_copy.setObjectPlacement(file.addLocalPlacement(west_wall.ObjectPlacement(), 2500, -2500 + 4820, 400, 0, 0, 1, 0, 1, 0));
+    west_opening_copy.setRepresentation(file.addBox(6000, 3630, 1600));
+#ifdef USE_IFC4
+    west_opening_copy.setPredefinedType(IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING);
+#endif
+
+    {
+        auto rel = file.create<IfcSchema::IfcRelVoidsElement>();
+        rel.setGlobalId(guid());
+        rel.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+        rel.setRelatingBuildingElement(west_wall);
+        rel.setRelatedOpeningElement(west_opening_copy);
+    }
+
 	// Up until now we have only used simple extrusions for the creation of the geometry. For the 
 	// ground mesh of the IfcSite we will use a Nurbs surface created in Open Cascade. The surface 
 	// will be tessellated using the deflection specified.
 	TopoDS_Shape shape;
 	createGroundShape(shape);
-	IfcSchema::IfcProductDefinitionShape* ground_representation = IfcGeom::tesselate(STRINGIFY(IfcSchema), shape, 100.)->as<IfcSchema::IfcProductDefinitionShape>();
-	file.getSingle<IfcSchema::IfcSite>()->setRepresentation(ground_representation);
+	auto ground_representation = IfcGeom::tesselate(file, shape, 100.).as<IfcSchema::IfcProductDefinitionShape>();
+	file.getSingle<IfcSchema::IfcSite>().setRepresentation(ground_representation);
 
 	GProp_GProps prop;
 	BRepGProp::SurfaceProperties(shape, prop);
 	const double site_area = prop.Mass() / 1000 / 1000;
 
-	IfcSchema::IfcProperty::list::ptr properties(new IfcSchema::IfcProperty::list);
-	properties->push(new IfcSchema::IfcPropertySingleValue("TotalArea", null, new IfcSchema::IfcAreaMeasure(site_area), 0));
-	IfcSchema::IfcPropertySet* pset = new IfcSchema::IfcPropertySet(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), "Pset_SiteCommon"s, null, properties);
-#ifdef USE_IFC4	
-	IfcSchema::IfcObjectDefinition::list::ptr related_objs(new IfcSchema::IfcObjectDefinition::list);
-#else
-	IfcSchema::IfcObject::list::ptr related_objs(new IfcSchema::IfcObject::list);
-#endif
-	related_objs->push(file.getSingle<IfcSchema::IfcSite>());
-	IfcSchema::IfcRelDefinesByProperties* site_prop = new IfcSchema::IfcRelDefinesByProperties(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, related_objs, pset);
-	file.addEntity(site_prop);
+    auto total_area = file.create<IfcSchema::IfcPropertySingleValue>();
+    total_area.setName("TotalArea");
+    auto area = file.create<IfcSchema::IfcAreaMeasure>();
+    area.set_attribute_value(0, site_area);
+    total_area.setNominalValue(area);
 
-	IfcSchema::IfcRepresentation::list::ptr ground_reps = file.getSingle<IfcSchema::IfcSite>()->Representation()->Representations();
-	for (IfcSchema::IfcRepresentation::list::it it = ground_reps->begin(); it != ground_reps->end(); ++it) {
-		(*it)->setContextOfItems(file.getRepresentationContext("Model"));
+	auto pset = file.create<IfcSchema::IfcPropertySet>();
+    pset.setGlobalId(guid());
+    pset.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    pset.setName("Pset_SiteCommon");
+    pset.setHasProperties({total_area});
+
+	auto site_prop = file.create<IfcSchema::IfcRelDefinesByProperties>();
+    site_prop.setGlobalId(guid());
+    site_prop.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    site_prop.setRelatedObjects({file.getSingle<IfcSchema::IfcSite>()});
+    site_prop.setRelatingPropertyDefinition(pset);
+	
+	auto ground_reps = file.getSingle<IfcSchema::IfcSite>().Representation().Representations();
+    for (auto& rep : ground_reps) {
+        rep.setContextOfItems(file.getRepresentationContext("Model"));
 	}
-	file.addEntity(ground_representation);
+	file.add_entity(ground_representation);
 	setSurfaceColour(file,ground_representation, 0.15, 0.25, 0.05);
 
 	// According to the Ifc2x3 schema an IfcWallStandardCase needs to have an IfcMaterialLayerSet
@@ -297,58 +337,28 @@ int main() {
 	// Some BIM authoring applications, such as Autodesk Revit, ignore the geometrical representation
 	// by and large and construct native walls using the layer thickness and reference line offset 
 	// provided here.
-#ifdef USE_IFC4
-	IfcSchema::IfcMaterial* material = new IfcSchema::IfcMaterial("Brick", null, null);
-#else
-	IfcSchema::IfcMaterial* material = new IfcSchema::IfcMaterial("Brick");
-#endif
-	IfcSchema::IfcMaterialLayer* layer = new IfcSchema::IfcMaterialLayer(
-		material, 
-		360, 
-		null
-#ifdef USE_IFC4
-		, null
-		, null 
-		, null
-		, null
-#endif
-	);
-	IfcSchema::IfcMaterialLayer::list::ptr layers (new aggregate_of<IfcSchema::IfcMaterialLayer>());
-	layers->push(layer);
-	IfcSchema::IfcMaterialLayerSet* layer_set = new IfcSchema::IfcMaterialLayerSet(
-		layers, 
-		"Wall"s
-#ifdef USE_IFC4
-		, null
-#endif
-	);
-	IfcSchema::IfcMaterialLayerSetUsage* layer_usage = new IfcSchema::IfcMaterialLayerSetUsage(
-		layer_set,
-		IfcSchema::IfcLayerSetDirectionEnum::IfcLayerSetDirection_AXIS2,
-		IfcSchema::IfcDirectionSenseEnum::IfcDirectionSense_POSITIVE,
-		-180
-#ifdef USE_IFC4
-		, null
-#endif
-	);
+    auto material = file.create<IfcSchema::IfcMaterial>();
+    material.setName("Brick");
 
-	IfcSchema::IfcRelAssociatesMaterial* associates_material = new IfcSchema::IfcRelAssociatesMaterial(
-		guid(),
-		file.getSingle<IfcSchema::IfcOwnerHistory>(), 
-		null, 
-		null,
-#ifdef USE_IFC4
-		file.instances_by_type<IfcSchema::IfcWallStandardCase>()->as<IfcSchema::IfcDefinitionSelect>(),
-#else
-		file.instances_by_type<IfcSchema::IfcWallStandardCase>()->as<IfcSchema::IfcRoot>(),
-#endif
-		layer_usage);
+	auto layer = file.create<IfcSchema::IfcMaterialLayer>();
+    layer.setMaterial(material);
+    layer.setLayerThickness(360);
 
-	file.addEntity(material);
-	file.addEntity(layer);
-	file.addEntity(layer_set);	
-	file.addEntity(layer_usage);
-	file.addEntity(associates_material);
+	auto layer_set = file.create<IfcSchema::IfcMaterialLayerSet>();
+    layer_set.setMaterialLayers({layer});
+    layer_set.setLayerSetName("Wall");
+
+	auto layer_usage = file.create<IfcSchema::IfcMaterialLayerSetUsage>();
+    layer_usage.setForLayerSet(layer_set);
+	layer_usage.setDirectionSense(IfcSchema::IfcDirectionSenseEnum::IfcDirectionSense_POSITIVE);
+	layer_usage.setLayerSetDirection(IfcSchema::IfcLayerSetDirectionEnum::IfcLayerSetDirection_AXIS1);
+    layer_usage.setOffsetFromReferenceLine(-180);
+
+	auto associates_material = file.create<IfcSchema::IfcRelAssociatesMaterial>();
+    associates_material.setGlobalId(guid());
+	associates_material.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+	associates_material.setRelatedObjects({south_wall, north_wall, east_wall, west_wall});
+    associates_material.setRelatingMaterial(layer_usage);
 
 	// In addition, another common way to represent geometry in IFC files is to use extrusions of
 	// planar areas bounded by a polygon.
@@ -359,55 +369,88 @@ int main() {
 	stair_points.push_back(XY(500, 200));
 	stair_points.push_back(XY(500, 400));
 	stair_points.push_back(XY(  0, 400));
-	IfcSchema::IfcStairFlight* stair = new IfcSchema::IfcStairFlight(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(storey_placement, 5050, 1000, 0, 0, 1, 0, 1, 0, 0),
-		file.addExtrudedPolyline(stair_points, 1200), null, 2, 2, 0.2, 0.25
+    auto stair = file.create<IfcSchema::IfcStairFlight>();
+    stair.setGlobalId(guid());
+    stair.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    stair.setObjectPlacement(file.addLocalPlacement(storey_placement, 5050, 1000, 0, 0, 1, 0, 1, 0, 0));
+    stair.setRepresentation(file.addExtrudedPolyline(stair_points, 1200));
 #ifdef USE_IFC4
-		, IfcSchema::IfcStairFlightTypeEnum::IfcStairFlightType_STRAIGHT
+    stair.setNumberOfRisers(2);
+#else
+    stair.setNumberOfRiser(2);
+#endif
+    stair.setNumberOfTreads(2);
+    stair.setRiserHeight(0.2);
+    stair.setTreadLength(0.25);
+#ifdef USE_IFC4
+    stair.setPredefinedType(IfcSchema::IfcStairFlightTypeEnum::IfcStairFlightType_STRAIGHT);
 #endif
-	);
 
 	file.addBuildingProduct(stair);
-	setSurfaceColour(file, stair->Representation(), footing_colour);
+	setSurfaceColour(file, stair.Representation(), footing_colour);
 
-	IfcSchema::IfcOpeningElement* door_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(storey_placement, 5000-180, 2500-900, 0), file.addBox(1000, 1000, 2200), null
+	auto door_opening = file.create<IfcSchema::IfcOpeningElement>();
+    door_opening.setGlobalId(guid());
+    door_opening.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    door_opening.setObjectPlacement(file.addLocalPlacement(storey_placement, 5000 - 180, 2500 - 900, 0));
+    door_opening.setRepresentation(file.addBox(1000, 1000, 2200));
 #ifdef USE_IFC4
-		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
-#endif	
-	);
-	file.addEntity(door_opening);
-	file.addEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, east_wall, door_opening));
+    door_opening.setPredefinedType(IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING);
+#endif
+
+    auto rel3 = file.create<IfcSchema::IfcRelVoidsElement>();
+    rel3.setGlobalId(guid());
+    rel3.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    rel3.setRelatingBuildingElement(east_wall);
+    rel3.setRelatedOpeningElement(door_opening);
 
 	// A single shape representation can contain multiple representiation items. This way a product
 	// can be a composition of multiple solids. The following door will be composed of four boxes
 	// which constitute the door and its frame.
-	IfcSchema::IfcDoor* door = new IfcSchema::IfcDoor(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, null,
-		file.addLocalPlacement(storey_placement, 4800, 1600, 0, 0, 0, 1, 0, 1, 0), 0, null, 2200, 1000
+    auto door = file.create<IfcSchema::IfcDoor>();
+    door.setGlobalId(guid());
+    door.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    door.setObjectPlacement(file.addLocalPlacement(storey_placement, 4800, 1600, 0, 0, 0, 1, 0, 1, 0));
+    door.setOverallWidth(1000);
+    door.setOverallHeight(2200);
 #ifdef USE_IFC4
-		, IfcSchema::IfcDoorTypeEnum::IfcDoorType_DOOR
-		, IfcSchema::IfcDoorTypeOperationEnum::IfcDoorTypeOperation_SINGLE_SWING_LEFT
-		, null
+    door.setPredefinedType(IfcSchema::IfcDoorTypeEnum::IfcDoorType_DOOR);
+    door.setOperationType(IfcSchema::IfcDoorTypeOperationEnum::IfcDoorTypeOperation_SINGLE_SWING_LEFT);
 #endif
-	);
-	door->setRepresentation(file.addBox(80, 80, 2120, 0, file.addPlacement3d(460, 0, 0)));
-	IfcSchema::IfcRepresentation::list::ptr door_representations = door->Representation()->Representations();
-	IfcSchema::IfcShapeRepresentation* door_body = 0;
-	for (IfcSchema::IfcRepresentation::list::it i = door_representations->begin(); i != door_representations->end(); ++i) {
-		IfcSchema::IfcRepresentation* rep = *i;
-		if (rep->declaration().is(IfcSchema::IfcShapeRepresentation::Class()) && rep->RepresentationIdentifier().get_value_or("") == "Body") {
-			door_body = (IfcSchema::IfcShapeRepresentation*) rep;
+
+    door.setRepresentation(file.addBox(80, 80, 2120, IfcSchema::IfcAxis2Placement2D{}, file.addPlacement3d(460, 0, 0)));
+    
+    auto door_representations = door.Representation().Representations();
+    IfcSchema::IfcShapeRepresentation door_body;
+	for (auto& rep : door_representations) {
+		if (rep.declaration().is(IfcSchema::IfcShapeRepresentation::Class()) && rep.RepresentationIdentifier().value_or("") == "Body") {
+            door_body = rep.as<IfcSchema::IfcShapeRepresentation>();
 		}
 	}
-	file.addBox(door_body,  80, 80, 2120, 0, file.addPlacement3d(-460, 0,   0));
-	file.addBox(door_body, 1000, 80,  80, 0, file.addPlacement3d(   0, 0, 2120));
+
+	file.addBox(door_body,  80, 80, 2120, IfcSchema::IfcAxis2Placement2D{}, file.addPlacement3d(-460, 0,   0));
+	file.addBox(door_body, 1000, 80,  80, IfcSchema::IfcAxis2Placement2D{}, file.addPlacement3d(   0, 0, 2120));
 	file.addBox(door_body, 860, 30, 2120);
 	file.addBuildingProduct(door);
-	setSurfaceColour(file, door->Representation(), 0.9, 0.9, 0.9);
-	file.addEntity(new IfcSchema::IfcRelFillsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, door_opening, door));
 
-	IfcSchema::IfcDoorStyle* door_style = new IfcSchema::IfcDoorStyle(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), "Door type"s, null, null, null, null, null,
-		IfcSchema::IfcDoorStyleOperationEnum::IfcDoorStyleOperation_SINGLE_SWING_LEFT, IfcSchema::IfcDoorStyleConstructionEnum::IfcDoorStyleConstruction_WOOD, false, false);
+	setSurfaceColour(file, door.Representation(), 0.9, 0.9, 0.9);
+    {
+        auto rel = file.create<IfcSchema::IfcRelFillsElement>();
+        rel.setGlobalId(guid());
+        rel.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+        rel.setRelatingOpeningElement(door_opening);
+        rel.setRelatedBuildingElement(door);
+    }
+
+	auto door_style = file.create<IfcSchema::IfcDoorStyle>();
+    door_style.setGlobalId(guid());
+    door_style.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+    door_style.setName("Door type");
+    door_style.setOperationType(IfcSchema::IfcDoorStyleOperationEnum::IfcDoorStyleOperation_SINGLE_SWING_LEFT);
+    door_style.setConstructionType(IfcSchema::IfcDoorStyleConstructionEnum::IfcDoorStyleConstruction_WOOD);
+    door_style.setParameterTakesPrecedence(false);
+    door_style.setSizeable(false);
+
 	// NOTE: typing by IfcDoorStyle will cause validation errors in IFC4+ but it's allowed for backwards compatibility
 	// better to use IfcDoorType in the actual use case
 	file.addRelatedObject<IfcSchema::IfcRelDefinesByType>(door_style, door);
@@ -423,23 +466,23 @@ int main() {
 	// Therefore the OverallWidth and OverallHeight of the window attributes will need to
 	// match the bounding box of the representation. Furthermore, the window placement needs
 	// to align with the lowerleft corner of the constituent parts.
-	IfcSchema::IfcShapeRepresentation::list::ptr frame_representations(new IfcSchema::IfcShapeRepresentation::list);
+    std::vector<IfcSchema::IfcShapeRepresentation> frame_representations;
 	
-	IfcSchema::IfcShapeRepresentation* horizontal_bar = file.addEmptyRepresentation();
-	IfcSchema::IfcShapeRepresentation* vertical_bar = file.addEmptyRepresentation();
+	auto horizontal_bar = file.addEmptyRepresentation();
+	auto vertical_bar = file.addEmptyRepresentation();
 	file.addBox(horizontal_bar, 1860, 90, 90);
 	file.addBox(vertical_bar, 90, 90, 1420);
 
-	frame_representations->push(horizontal_bar);
-	frame_representations->push(horizontal_bar); // Add another reference to the horizontal bar created above
-	frame_representations->push(vertical_bar);
-	frame_representations->push(vertical_bar); // Add another reference to the vertical bar created above
+	frame_representations.push_back(horizontal_bar);
+	frame_representations.push_back(horizontal_bar); // Add another reference to the horizontal bar created above
+	frame_representations.push_back(vertical_bar);
+	frame_representations.push_back(vertical_bar); // Add another reference to the vertical bar created above
 
 	// The beams all have the same surface style assigned
-	IfcSchema::IfcPresentationStyleAssignment* frame_style = 0;
-	for (IfcSchema::IfcShapeRepresentation::list::it i = frame_representations->begin(); i != frame_representations->end(); i += 2) {
+    IfcSchema::IfcPresentationStyleAssignment frame_style;
+	for (auto i = frame_representations.begin(); i != frame_representations.end(); i += 2) {
 		if (frame_style) {
-			setSurfaceColour(file,*i, frame_style);
+			setSurfaceColour(file, *i, frame_style);
 		} else {
 			frame_style = setSurfaceColour(file,*i, 0.5, 0.4, 0.3);
 		}
@@ -448,73 +491,80 @@ int main() {
 
 	// This window will be placed at five locations within the building. A list of placements is 
 	// created and is iterated over to create all window instances.
-	IfcSchema::IfcLocalPlacement::list::ptr window_placements (new IfcSchema::IfcLocalPlacement::list);
-	window_placements->push(file.addLocalPlacement(storey_placement, 2*-1770-430-930,   -45, 400));
-	window_placements->push(file.addLocalPlacement(storey_placement,   -1770-430-930,   -45, 400));
-	window_placements->push(file.addLocalPlacement(storey_placement,        -430-930,   -45, 400));
-	window_placements->push(file.addLocalPlacement(storey_placement,        3000-930,   -45, 400));
-	window_placements->push(file.addLocalPlacement(storey_placement, -4855+45, 885-930, 400, 0, 0, 1, 0, 1, 0));
+    std::vector<IfcSchema::IfcLocalPlacement> window_placements;
+	window_placements.push_back(file.addLocalPlacement(storey_placement, 2*-1770-430-930,   -45, 400));
+	window_placements.push_back(file.addLocalPlacement(storey_placement,   -1770-430-930,   -45, 400));
+	window_placements.push_back(file.addLocalPlacement(storey_placement,        -430-930,   -45, 400));
+	window_placements.push_back(file.addLocalPlacement(storey_placement,        3000-930,   -45, 400));
+	window_placements.push_back(file.addLocalPlacement(storey_placement, -4855+45, 885-930, 400, 0, 0, 1, 0, 1, 0));
 	
-	for (IfcSchema::IfcLocalPlacement::list::it it = window_placements->begin(); it != window_placements->end(); ++it) {
-		
-		// Create the window at the current location
-		IfcSchema::IfcLocalPlacement* place = *it;
-		IfcSchema::IfcWindow* window = new IfcSchema::IfcWindow(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-			null, null, null, place, 0, null, 1600, 1860
+	for (auto& place : window_placements) {
+        auto window = file.create<IfcSchema::IfcWindow>();
+        window.setGlobalId(guid());
+        window.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+        window.setObjectPlacement(place);
+        window.setOverallWidth(1860);
+        window.setOverallHeight(1600);
 #ifdef USE_IFC4
-			, IfcSchema::IfcWindowTypeEnum::IfcWindowType_WINDOW
-			, IfcSchema::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioning_SINGLE_PANEL
-			, null
+        window.setPredefinedType(IfcSchema::IfcWindowTypeEnum::IfcWindowType_WINDOW);
+        window.setPartitioningType(IfcSchema::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioning_SINGLE_PANEL);
 #endif
-	);
-		file.addBuildingProduct(window);		
+        file.addBuildingProduct(window);		
 
 		// Initialize a list of parts for the window to be composed of
-		IfcSchema::IfcObjectDefinition::list::ptr window_parts(new aggregate_of<IfcSchema::IfcObjectDefinition>());
+        std::vector<IfcSchema::IfcObjectDefinition> window_parts;
 
 		// The placements for the beams are not shared across the different windows because every
 		// beam is placed relative to its parent window entity.
-		IfcSchema::IfcLocalPlacement::list::ptr frame_placements (new aggregate_of<IfcSchema::IfcLocalPlacement>());
-		frame_placements->push(file.addLocalPlacement(storey_placement,  930,45));
-		frame_placements->push(file.addLocalPlacement(storey_placement,  930, 45, 1510));
-		frame_placements->push(file.addLocalPlacement(storey_placement, -885+930, 45,  90));
-		frame_placements->push(file.addLocalPlacement(storey_placement,  885+930, 45,  90));
+        std::vector<IfcSchema::IfcLocalPlacement> frame_placements;
+		frame_placements.push_back(file.addLocalPlacement(storey_placement,  930,45));
+		frame_placements.push_back(file.addLocalPlacement(storey_placement,  930, 45, 1510));
+		frame_placements.push_back(file.addLocalPlacement(storey_placement, -885+930, 45,  90));
+		frame_placements.push_back(file.addLocalPlacement(storey_placement,  885+930, 45,  90));
 		
 		// Now iterate over the placements and representations of the beam and add them to list of parts
-		IfcSchema::IfcLocalPlacement::list::it frame_placement;
-		IfcSchema::IfcShapeRepresentation::list::it frame_representation;
-		for (frame_placement = frame_placements->begin(), frame_representation = frame_representations->begin();
-			frame_placement != frame_placements->end() && frame_representation != frame_representations->end();
+        std::vector<IfcSchema::IfcLocalPlacement>::const_iterator frame_placement;
+        std::vector<IfcSchema::IfcShapeRepresentation>::const_iterator frame_representation;
+		for (frame_placement = frame_placements.begin(), frame_representation = frame_representations.begin();
+			frame_placement != frame_placements.end() && frame_representation != frame_representations.end();
 			++frame_placement, ++frame_representation)
 		{
-			IfcSchema::IfcMember* frame_part = new IfcSchema::IfcMember(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-				null, null, null, *frame_placement, file.addMappedItem(*frame_representation), null
+            auto frame_part = file.create<IfcSchema::IfcMember>();
+            frame_part.setGlobalId(guid());
+            frame_part.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+            frame_part.setObjectPlacement(*frame_placement);
+            frame_part.setRepresentation(file.addMappedItem(*frame_representation));
 #ifdef USE_IFC4
-				, IfcSchema::IfcMemberTypeEnum::IfcMemberType_MULLION
+            frame_part.setPredefinedType(IfcSchema::IfcMemberTypeEnum::IfcMemberType_MULLION);
 #endif
-			);
-			file.addEntity(frame_part);
-			window_parts->push(frame_part);
+			window_parts.push_back(frame_part);
 			file.relatePlacements(window, frame_part);
 		}
 
 		// Add the glass plate to the list of parts
-		IfcSchema::IfcPlate* glass_part = new IfcSchema::IfcPlate(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null,
-			null, null, file.addLocalPlacement(storey_placement, 930, 45, 90), file.addBox(1680, 10, 1420), null
+        auto glass_part = file.create<IfcSchema::IfcPlate>();
+        glass_part.setGlobalId(guid());
+        glass_part.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+        glass_part.setObjectPlacement(file.addLocalPlacement(storey_placement, 930, 45, 90));
+        glass_part.setRepresentation(file.addBox(1860, 10, 1420));
 #ifdef USE_IFC4
-			, IfcSchema::IfcPlateTypeEnum::IfcPlateType_SHEET
+        glass_part.setPredefinedType(IfcSchema::IfcPlateTypeEnum::IfcPlateType_SHEET);
 #endif
-		);
-		file.addEntity(glass_part);
-		window_parts->push(glass_part);
+
+        window_parts.push_back(glass_part);
 		file.relatePlacements(window, glass_part);
-		setSurfaceColour(file,glass_part->Representation(), 0.6, 0.7, 0.75, 0.1);
+		setSurfaceColour(file, glass_part.Representation(), 0.6, 0.7, 0.75, 0.1);
 		
 		// Now create a decomposition relation between the window and the parts. Most viewers and authoring
 		// tools will consider the window a single entity that can be selected as a whole.
-		IfcSchema::IfcRelDecomposes* decomposition = new IfcSchema::IfcRelAggregates(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-			null, null, window, window_parts);
-		file.addEntity(decomposition);		
+        {
+
+            auto rel = file.create<IfcSchema::IfcRelAggregates>();
+            rel.setGlobalId(guid());
+            rel.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+            rel.setRelatingObject(window);
+            rel.setRelatedObjects(window_parts);
+        }
 	}
 
 	// Finally create a file stream for our output and write the IFC file to it.

src/examples/IfcParseExamples.cpp

@@ -1,4 +1,4 @@
-/********************************************************************************
+/********************************************************************************
  *                                                                              *
  * This file is part of IfcOpenShell.                                           *
  *                                                                              *
@@ -20,9 +20,9 @@
 // TODO: Multiple schemas
 #define IfcSchema Ifc2x3
 
-#include "ifcparse/IfcFile.h"
-#include "ifcparse/IfcLogger.h"
-#include "ifcparse/Ifc2x3.h"
+#include "../ifcparse/file.h"
+#include "../ifcparse/logger.h"
+#include "../ifcparse/schemas/Ifc2x3.h"
 
 #include <boost/preprocessor/stringize.hpp>
 #include <boost/preprocessor/seq/for_each.hpp>
@@ -47,7 +47,7 @@ static_assert(false, "A boost preprocessor sequence of schema identifiers is nee
 // for and then overflow into an existing empty include file.
 
 #define INCLUDE_SCHEMA(n) \
-	BOOST_PP_IIF(BOOST_PP_GREATER(BOOST_PP_SEQ_SIZE(SCHEMA_SEQ), n), BOOST_PP_STRINGIZE(../ifcparse/BOOST_PP_CAT(Ifc,BOOST_PP_SEQ_ELEM(BOOST_PP_MIN(n, BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_BACK(SCHEMA_SEQ))),SCHEMA_SEQ)).h), "../ifcgeom/empty.h")
+	BOOST_PP_IIF(BOOST_PP_GREATER(BOOST_PP_SEQ_SIZE(SCHEMA_SEQ), n), BOOST_PP_STRINGIZE(../ifcparse/schemas/BOOST_PP_CAT(Ifc,BOOST_PP_SEQ_ELEM(BOOST_PP_MIN(n, BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_POP_BACK(SCHEMA_SEQ))),SCHEMA_SEQ)).h), "../ifcgeom/empty.h")
 
 #include INCLUDE_SCHEMA(0)
 #include INCLUDE_SCHEMA(1)
@@ -80,7 +80,7 @@ struct is_ifc4_or_higher<T, std::void_t<decltype(T::IfcMaterialDefinition)>> : s
 
 typedef std::map<std::string, std::map<std::string, std::string>> element_properties;
 
-std::string format_string(const AttributeValue& argument) {
+std::string format_string(const attribute_value& argument) {
 	// Argument is a runtime tagged variant for the various data types in a IFC model,
 	// in this particular case we only care about flattening it to a string.
 	// @todo mostly duplicated from XmlSerializer.cpp
@@ -89,21 +89,21 @@ std::string format_string(const AttributeValue& argument) {
 	}
 	auto argument_type = argument.type();
 	switch (argument_type) {
-	case IfcUtil::Argument_BOOL: {
+	case ifcopenshell::Argument_BOOL: {
 		const bool b = argument;
 		return b ? "true" : "false";
 	}
-	case IfcUtil::Argument_DOUBLE: {
+	case ifcopenshell::Argument_DOUBLE: {
 		const double d = argument;
 		std::stringstream stream;
 		stream << std::setprecision(std::numeric_limits< double >::max_digits10) << d;
 		return stream.str();
 		break; }
-	case IfcUtil::Argument_STRING:
-	case IfcUtil::Argument_ENUMERATION: {
+	case ifcopenshell::Argument_STRING:
+	case ifcopenshell::Argument_ENUMERATION: {
 		return static_cast<std::string>(argument);
 		break; }
-	case IfcUtil::Argument_INT: {
+	case ifcopenshell::Argument_INT: {
 		const int v = argument;
 		std::stringstream stream;
 		stream << v;
@@ -114,44 +114,42 @@ std::string format_string(const AttributeValue& argument) {
 }
 
 template <typename Schema, typename T>
-void process_pset(element_properties& props, const T* inst) {
+void process_pset(element_properties& props, const T& inst) {
 	// Process an individual Property or Quantity set.
-	if (auto pset = inst->template as<typename Schema::IfcPropertySet>()) {
-		if (!pset->Name()) {
+	if (auto pset = inst.template as<typename Schema::IfcPropertySet>()) {
+		if (!pset.Name()) {
 			return;
 		}
-		auto ps = pset->HasProperties();
-		for (auto it = ps->begin(); it != ps->end(); ++it) {
-			auto& p = *it;
-			if (auto singleval = p->template as<typename Schema::IfcPropertySingleValue>()) {
+		auto ps = pset.HasProperties();
+		for (auto& p : ps) {
+			if (auto singleval = p.template as<typename Schema::IfcPropertySingleValue>()) {
 				std::string propname, propvalue;
 				if constexpr (is_ifc4_or_higher<Schema>::value) {
-					if (!singleval->Name()) {
+					if (!singleval.Name()) {
 						continue;
 					}
-					propname = *singleval->Name();
+					propname = *singleval.Name();
 				}
 				if constexpr (!is_ifc4_or_higher<Schema>::value) {
-					propname = singleval->Name();
+					propname = singleval.Name();
 				}
-				if (!singleval->NominalValue()) {
+				if (!singleval.NominalValue()) {
 					propvalue = "-";
 				} else {
-					props[*pset->Name()][propname] = format_string(singleval->NominalValue()->template as<IfcUtil::IfcBaseClass>()->get_attribute_value(0));
+					props[*pset.Name()][propname] = format_string(singleval.NominalValue().concrete().get_attribute_value(0));
 				}
 			}
 		}
 	}
-	if (auto qset = inst->template as<typename Schema::IfcElementQuantity>()) {
-		if (!qset->Name()) {
+	if (auto qset = inst.template as<typename Schema::IfcElementQuantity>()) {
+		if (!qset.Name()) {
 			return;
 		}
-		auto qs = qset->Quantities();
-		for (auto it = qs->begin(); it != qs->end(); ++it) {
-			auto& q = *it;
-			if (q->template as<typename Schema::IfcPhysicalSimpleQuantity>() && q->get_attribute_value(3).type() == IfcUtil::Argument_DOUBLE) {
-				double v = q->get_attribute_value(3);
-				props[*qset->Name()][q->Name()] = std::to_string(v);
+		auto qs = qset.Quantities();
+		for (auto& q : qs) {
+			if (q.template as<typename Schema::IfcPhysicalSimpleQuantity>() && q.get_attribute_value(3).type() == ifcopenshell::Argument_DOUBLE) {
+				double v = q.get_attribute_value(3);
+				props[*qset.Name()][q.Name()] = std::to_string(v);
 			}
 		}
 	}
@@ -163,49 +161,44 @@ void process_pset(element_properties& props, const T* inst) {
 }
 
 template <typename Schema>
-void get_psets_s(element_properties& props, const typename Schema::IfcObjectDefinition* inst) {
+void get_psets_s(element_properties& props, const typename Schema::IfcObjectDefinition& inst) {
 	// Extracts the property definitions for an IFC instance. 
-	if (auto tyob = inst->template as<typename Schema::IfcTypeObject>()) {
-		if (tyob->HasPropertySets()) {
-			auto defs = *tyob->HasPropertySets();
-			for (auto it = defs->begin(); it != defs->end(); ++it) {
-				auto& def = *it;
+	if (auto tyob = inst.template as<typename Schema::IfcTypeObject>()) {
+		if (tyob.HasPropertySets()) {
+			auto defs = *tyob.HasPropertySets();
+			for (auto& def : defs) {
 				process_pset<Schema>(props, def);
 			}
 		}
 	}
 	if constexpr (is_ifc4_or_higher<Schema>::value) {
-		if (auto mdef = inst->template as<typename Schema::IfcMaterialDefinition>()) {
-			auto defs = mdef->HasProperties();
-			for (auto it = defs->begin(); it != defs->end(); ++it) {
-				auto& def = *it;
+		if (auto mdef = inst.template as<typename Schema::IfcMaterialDefinition>()) {
+			auto defs = mdef.HasProperties();
+			for (auto& def : defs) {
 				process_pset<Schema>(props, def);
 			}
 		}
-		if (auto pdef = inst->template as<typename Schema::IfcProfileDef>()) {
+		if (auto pdef = inst.template as<typename Schema::IfcProfileDef>()) {
 			auto defs = pdef->HasProperties();
-			for (auto it = defs->begin(); it != defs->end(); ++it) {
-				auto& def = *it;
+			for (auto& def : defs) {
 				process_pset<Schema>(props, def);
 			}
 		}
 	}
-	if (auto ob = inst->template as<typename Schema::IfcObject>()) {
+	if (auto ob = inst.template as<typename Schema::IfcObject>()) {
 		if constexpr (is_ifc4_or_higher<Schema>::value) {
-			auto rels = ob->IsTypedBy();
-			for (auto it = rels->begin(); it != rels->end(); ++it) {
-				auto& rel = *it;
+			auto rels = ob.IsTypedBy();
+			for (auto& rel : rels) {
 				get_psets_s<Schema>(props, rel->RelatingType());
 			}
 		}
 		{
-			auto rels = ob->IsDefinedBy();
-			for (auto it = rels->begin(); it != rels->end(); ++it) {
-				auto& rel = *it;
-				if (auto bytype = rel->template as<typename Schema::IfcRelDefinesByType>()) {
-					get_psets_s<Schema>(props, bytype->RelatingType());
-				} else if (auto byprops = rel->template as<typename Schema::IfcRelDefinesByProperties>()) {
-					process_pset<Schema>(props, byprops->RelatingPropertyDefinition());
+			auto rels = ob.IsDefinedBy();
+			for (auto& rel : rels) {
+				if (auto bytype = rel.template as<typename Schema::IfcRelDefinesByType>()) {
+					get_psets_s<Schema>(props, bytype.RelatingType());
+				} else if (auto byprops = rel.template as<typename Schema::IfcRelDefinesByProperties>()) {
+					process_pset<Schema>(props, byprops.RelatingPropertyDefinition());
 				}
 			}
 		}
@@ -220,10 +213,10 @@ void get_psets_s(element_properties& props, const typename Schema::IfcObjectDefi
 #define GENERATE_LITERAL_STRING(elem) "Ifc" # elem
 
 #define TEST_AND_DISPATCH(r, data, elem) \
-	if (strcasecmp(schema_name, GENERATE_LITERAL_STRING(elem)) == 0) { get_psets_s<EXPAND_AND_CONCATENATE(elem)>(props, inst->as<EXPAND_AND_CONCATENATE(elem)::IfcObjectDefinition>()); }
+	if (strcasecmp(schema_name, GENERATE_LITERAL_STRING(elem)) == 0) { get_psets_s<EXPAND_AND_CONCATENATE(elem)>(props, inst.as<EXPAND_AND_CONCATENATE(elem)::IfcObjectDefinition>()); }
 
-void get_psets(element_properties& props, const IfcUtil::IfcBaseClass* inst) {
-	auto schema_name = inst->declaration().schema()->name().c_str();
+void get_psets(element_properties& props, const express::Base& inst) {
+	auto schema_name = inst.declaration().schema()->name().c_str();
 	BOOST_PP_SEQ_FOR_EACH(TEST_AND_DISPATCH, , SCHEMA_SEQ)
 }
 
@@ -234,10 +227,10 @@ int main(int argc, char** argv) {
     }
     
     // Redirect the output (both progress and log) to stdout
-    Logger::SetOutput(&std::cout, &std::cout);
+    logger::set_output(&std::cout, &std::cout);
 
     // Parse the IFC file provided in argv[1]
-    IfcParse::IfcFile file(argv[1]);
+    ifcopenshell::file file(argv[1]);
     if (!file.good()) {
         std::cout << "Unable to parse .ifc file" << std::endl;
         return 1;
@@ -259,19 +252,17 @@ int main(int argc, char** argv) {
     // we need to cast them to IfcWindows. Since these properties
     // are optional we need to make sure the properties are
     // defined for the window in question before accessing them.
-	IfcSchema::IfcBuildingElement::list::ptr elements = file.instances_by_type<IfcSchema::IfcBuildingElement>();
+	auto elements = file.instances_by_type<IfcSchema::IfcBuildingElement>();
 
-    std::cout << "Found " << elements->size() << " elements in " << argv[1] << ":" << std::endl;
+    std::cout << "Found " << elements.size() << " elements in " << argv[1] << ":" << std::endl;
 
-    for (auto it = elements->begin(); it != elements->end(); ++it) {
-        const auto* element = *it;
-		element->toString(std::cout);
+    for (auto& element : elements) {
+		element.to_string(std::cout);
 		std::cout << std::endl;
 
-        const IfcSchema::IfcWindow* window;
-        if ((window = element->as<IfcSchema::IfcWindow>()) != 0) {
-            if (window->OverallWidth() && window->OverallHeight()) {
-                const double area = *window->OverallWidth() * *window->OverallHeight();
+        if (auto window = element.as<IfcSchema::IfcWindow>()) {
+            if (window.OverallWidth() && window.OverallHeight()) {
+                const double area = *window.OverallWidth() * *window.OverallHeight();
                 std::cout << "The area of this window is " << area << std::endl;
             }
         }

src/examples/IfcSimplifiedAlignment.cpp

@@ -30,8 +30,8 @@
 // Disable warnings coming from IfcOpenShell
 #pragma warning(disable : 4018 4267 4250 4984 4985)
 
-#include "ifcparse/Ifc4x3_add2.h"
-#include "ifcparse/IfcAlignmentHelper.h"
+#include "../ifcparse/Ifc4x3_add2.h"
+#include "../ifcparse/alignment_helper.h"
 
 #include <fstream>
 
@@ -39,37 +39,49 @@
 
 // performs basic project setup including created the IfcProject object
 // and initializing the project units to FEET
-Schema::IfcProject* setup_project(IfcHierarchyHelper<Schema>& file) {
+Schema::IfcProject setup_project(hierarchy_helper<Schema>& file) {
     std::vector<std::string> file_description;
     file_description.push_back("ViewDefinition[Alignment-basedReferenceView]");
-    file.header().file_description()->setdescription(file_description);
+    file.header().file_description().setdescription(file_description);
 
     auto project = file.addProject();
-    project->setName(std::string("FHWA Bridge Geometry Manual Example Alignment"));
-    project->setDescription(std::string("C++ Example - Simplified"));
+    project.setName(std::string("FHWA Bridge Geometry Manual Example Alignment"));
+    project.setDescription(std::string("C++ Example - Simplified"));
 
     // set up project units for feet
     // the call to file.addProject() sets up length units as millimeter.
-    auto units_in_context = project->UnitsInContext();
-    auto units = units_in_context->Units();
-    auto begin = units->begin();
+    auto units_in_context = project.UnitsInContext();
+    auto units = units_in_context.Units();
+    auto begin = units.begin();
     auto iter = begin;
-    auto end = units->end();
+    auto end = units.end();
     for (; iter != end; iter++) {
         auto unit = *iter;
-        if (unit->as<Schema::IfcSIUnit>() && unit->as<Schema::IfcSIUnit>()->UnitType() == Schema::IfcUnitEnum::IfcUnit_LENGTHUNIT) {
-            auto dimensions = new Schema::IfcDimensionalExponents(1, 0, 0, 0, 0, 0, 0);
-            file.addEntity(dimensions);
+        if (unit.as<Schema::IfcSIUnit>() && unit.as<Schema::IfcSIUnit>().UnitType() == Schema::IfcUnitEnum::IfcUnit_LENGTHUNIT) {
+            auto dimensions = file.create<Schema::IfcDimensionalExponents>();
+            dimensions.setLengthExponent(1);
+            dimensions.setMassExponent(0);
+            dimensions.setTimeExponent(0);
+            dimensions.setElectricCurrentExponent(0);
+            dimensions.setThermodynamicTemperatureExponent(0);
+            dimensions.setAmountOfSubstanceExponent(0);
+            dimensions.setLuminousIntensityExponent(0);
 
-            auto conversion_factor = new Schema::IfcMeasureWithUnit(new Schema::IfcLengthMeasure(304.80), unit->as<Schema::IfcSIUnit>());
-            file.addEntity(conversion_factor);
+            auto conversion_factor = file.create<Schema::IfcMeasureWithUnit>();
+            auto length = file.create<Schema::IfcLengthMeasure>();
+            length.set_attribute_value(0, 304.80);
+            conversion_factor.setValueComponent(length);
+            conversion_factor.setUnitComponent(unit);
 
-            auto conversion_based_unit = new Schema::IfcConversionBasedUnit(dimensions, Schema::IfcUnitEnum::IfcUnit_LENGTHUNIT, "FEET", conversion_factor);
-            file.addEntity(conversion_based_unit);
+            auto conversion_based_unit = file.create<Schema::IfcConversionBasedUnit>();
+            conversion_based_unit.setDimensions(dimensions);
+            conversion_based_unit.setUnitType(Schema::IfcUnitEnum::IfcUnit_LENGTHUNIT);
+            conversion_based_unit.setName("FEET");
+            conversion_based_unit.setConversionFactor(conversion_factor);
 
-            units->remove(unit);                // remove the millimeter unit
-            units->push(conversion_based_unit); // add the feet unit
-            units_in_context->setUnits(units);  // update the UnitsInContext
+            units.erase(std::remove(units.begin(), units.end(), unit)); // remove the millimeter unit
+            units.push_back(conversion_based_unit);                     // add the feet unit
+            units_in_context.setUnits(units);                           // update the UnitsInContext
 
             break; // Done!, the length unit was found, so break out of the loop
         }
@@ -79,7 +91,7 @@ Schema::IfcProject* setup_project(IfcHierarchyHelper<Schema>& file) {
 }
 
 int main() {
-    IfcHierarchyHelper<Schema> file;
+    hierarchy_helper<Schema> file;
 
     auto project = setup_project(file);
 
@@ -129,10 +141,11 @@ int main() {
     // IFC 4.1.4.1.1 "Every IfcAlignment must be related to IfcProject using the IfcRelAggregates relationship"
     // https://standards.buildingsmart.org/IFC/RELEASE/IFC4_3/HTML/concepts/Object_Composition/Aggregation/Alignment_Aggregation_To_Project/content.html
     // IfcProject <-> IfcRelAggregates <-> IfcAlignment
-    typename aggregate_of<typename Schema::IfcObjectDefinition>::ptr list_of_alignments_in_project(new aggregate_of<typename Schema::IfcObjectDefinition>());
-    list_of_alignments_in_project->push(alignment);
-    auto aggregate_alignments_with_project = new Schema::IfcRelAggregates(IfcParse::IfcGlobalId(), nullptr, std::string("Alignments in project"), boost::none, project, list_of_alignments_in_project);
-    file.addEntity(aggregate_alignments_with_project);
+    auto aggregate_alignments_with_project = file.create<Schema::IfcRelAggregates>();
+    aggregate_alignments_with_project.setGlobalId(ifcopenshell::global_id());
+    aggregate_alignments_with_project.setName("Alignments in project");
+    aggregate_alignments_with_project.setRelatingObject(project);
+    aggregate_alignments_with_project.setRelatedObjects({alignment});
 
     // Define the spatial structure of the alignment with respect to the site
 
@@ -141,24 +154,24 @@ int main() {
     // IfcSite <-> IfcRelReferencedInSpatialStructure <-> IfcAlignment
     // This means IfcAlignment is not part of the IfcSite (it is not an aggregate component) but instead IfcAlignment is used within
     // the IfcSite by reference. This implies an IfcAlignment can traverse many IfcSite instances within an IfcProject
-    typename Schema::IfcSpatialReferenceSelect::list::ptr list_alignments_referenced_in_site(new Schema::IfcSpatialReferenceSelect::list);
-    list_alignments_referenced_in_site->push(alignment);
-
     // Complete the model by creating sites for the 3 bridges
     for (int i = 1; i <= 3; i++) {
         std::ostringstream os;
         os << "Site of Bridge " << i;
-        auto site = file.addSite(project, nullptr);
-        site->setName(os.str());
+        auto site = file.addSite(project);
+        site.setName(os.str());
 
         std::ostringstream description;
         description << "Alignments referenced into the spatial structure of Bridge Site " << i;
 
-        auto rel_referenced_in_spatial_structure = new Schema::IfcRelReferencedInSpatialStructure(IfcParse::IfcGlobalId(), nullptr, boost::none, description.str(), list_alignments_referenced_in_site, site);
-        file.addEntity(rel_referenced_in_spatial_structure);
+        auto rel_referenced_in_spatial_structure = file.create<Schema::IfcRelReferencedInSpatialStructure>();
+        rel_referenced_in_spatial_structure.setGlobalId(ifcopenshell::global_id());
+        rel_referenced_in_spatial_structure.setDescription(description.str());
+        rel_referenced_in_spatial_structure.setRelatedElements(std::vector<Schema::IfcSpatialReferenceSelect>{alignment});
+        rel_referenced_in_spatial_structure.setRelatingStructure(site);
     }
 
     // That's it - save the model to a file
-    std::ofstream ofs("IfcSimplifiedAlignment.ifc");
+    std::ofstream ofs("FHWA_Bridge_Geometry_Alignment_Example_Simplified.ifc");
     ofs << file;
 }

src/examples/arbitrary_open_profile_def.cpp

@@ -28,16 +28,15 @@
 #include <iostream>
 #include <fstream>
 
-#define IfcSchema Ifc4
-#include "ifcparse/Ifc4.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/schemas/Ifc2x3.h"
+#include "../ifcparse/hierarchy_helper.h"
 
 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
+typedef ifcopenshell::global_id guid;
 boost::none_t const null = boost::none;
 static int i = 0;
 
-void create_product_from_item(IfcHierarchyHelper<IfcSchema>& file, IfcSchema::IfcRepresentationItem* item, const std::string& s) {
+void create_product_from_item(hierarchy_helper& file, IfcSchema::IfcRepresentationItem* item, const std::string& s) {
 	IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
 		guid(), 0, S("product"), null, null, 0, 0, null, null);
 	file.addBuildingProduct(product);
@@ -50,8 +49,8 @@ void create_product_from_item(IfcHierarchyHelper<IfcSchema>& file, IfcSchema::If
 	items->push(item);
 
 	if (s == "GeometricSet") {
-        IfcSchema::IfcGeometricSet* set = new IfcSchema::IfcGeometricSet(items->as<IfcSchema::IfcGeometricSetSelect>());
-		file.addEntity(set);
+		IfcSchema::IfcGeometricSet* set = new IfcSchema::IfcGeometricSet(items->generalize());
+		file.add_entity(set);
 		items = IfcSchema::IfcRepresentationItem::list::ptr(new IfcSchema::IfcRepresentationItem::list());
 		items->push(set);
 	}
@@ -61,55 +60,55 @@ void create_product_from_item(IfcHierarchyHelper<IfcSchema>& file, IfcSchema::If
 	reps->push(rep);
 
 	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
-	file.addEntity(rep);
-	file.addEntity(shape);
+	file.add_entity(rep);
+	file.add_entity(shape);
 		
 	product->setRepresentation(shape);
 }
 
-void create_surfaces_from_profile(IfcHierarchyHelper<IfcSchema>& file, IfcSchema::IfcProfileDef* profile) {
+void create_surfaces_from_profile(hierarchy_helper& file, IfcSchema::IfcProfileDef* profile) {
 	IfcSchema::IfcSurfaceOfLinearExtrusion* extrusion = new IfcSchema::IfcSurfaceOfLinearExtrusion(profile, file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 100.);
-	file.addEntity(extrusion);
+	file.add_entity(extrusion);
 
 	IfcSchema::IfcAxis1Placement* ax1 = new IfcSchema::IfcAxis1Placement(file.addTriplet<IfcSchema::IfcCartesianPoint>(0,100,0), file.addTriplet<IfcSchema::IfcDirection>(1,0,0));
 	IfcSchema::IfcSurfaceOfRevolution* revolution = new IfcSchema::IfcSurfaceOfRevolution(profile, file.addPlacement3d(), ax1);
-	file.addEntity(ax1);
-	file.addEntity(revolution);
+	file.add_entity(ax1);
+	file.add_entity(revolution);
 
 	create_product_from_item(file, extrusion, "GeometricSet");
 	create_product_from_item(file, revolution, "GeometricSet");
 }
 
-void create_solids_from_profile(IfcHierarchyHelper<IfcSchema>& file, IfcSchema::IfcProfileDef* profile) {
+void create_solids_from_profile(hierarchy_helper& file, IfcSchema::IfcProfileDef* profile) {
 	IfcSchema::IfcExtrudedAreaSolid* extrusion = new IfcSchema::IfcExtrudedAreaSolid(profile, file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 100.);
-	file.addEntity(extrusion);
+	file.add_entity(extrusion);
 
 	IfcSchema::IfcAxis1Placement* ax1 = new IfcSchema::IfcAxis1Placement(file.addTriplet<IfcSchema::IfcCartesianPoint>(0,100,0), file.addTriplet<IfcSchema::IfcDirection>(1,0,0));
 	IfcSchema::IfcRevolvedAreaSolid* revolution1 = new IfcSchema::IfcRevolvedAreaSolid(profile, file.addPlacement3d(), ax1, 360.);
 	IfcSchema::IfcRevolvedAreaSolid* revolution2 = new IfcSchema::IfcRevolvedAreaSolid(profile, file.addPlacement3d(), ax1, 90.);
-	file.addEntity(ax1);
-	file.addEntity(revolution1);
-	file.addEntity(revolution2);
+	file.add_entity(ax1);
+	file.add_entity(revolution1);
+	file.add_entity(revolution2);
 
 	create_product_from_item(file, extrusion, "SweptSolid");
 	create_product_from_item(file, revolution1, "SweptSolid");
 	create_product_from_item(file, revolution2, "SweptSolid");
 }
 
-void create_products_from_curve(IfcHierarchyHelper<IfcSchema>& file, IfcSchema::IfcBoundedCurve* curve) {
+void create_products_from_curve(hierarchy_helper& file, IfcSchema::IfcBoundedCurve* curve) {
 	IfcSchema::IfcArbitraryOpenProfileDef* open = new IfcSchema::IfcArbitraryOpenProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_CURVE, null, curve);
 	IfcSchema::IfcCenterLineProfileDef* center_line = new IfcSchema::IfcCenterLineProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, null, curve, 10.);
-	file.addEntity(open);
-	file.addEntity(center_line);
+	file.add_entity(open);
+	file.add_entity(center_line);
 
 	create_surfaces_from_profile(file, open);
 	create_solids_from_profile(file, center_line);
 }
 
 int main(int argc, char** argv) {
-	const char filename[] = "arbitrary_open_profile_def.ifc";
-	IfcHierarchyHelper<IfcSchema> file;
-	file.header().file_name()->setname(filename);
+	const char filename[] = "IfcArbitraryOpenProfileDef.ifc";
+	hierarchy_helper file;
+	file.header().file_name().name(filename);
 
 	double coords1[] = {-50.0, 0.0};
 	double coords2[] = { 50.0, 0.0};
@@ -118,24 +117,23 @@ int main(int argc, char** argv) {
 	points->push(new IfcSchema::IfcCartesianPoint(std::vector<double>(coords2, coords2+2)));
 	file.addEntities(points->generalize());
 	IfcSchema::IfcPolyline* poly = new IfcSchema::IfcPolyline(points);
-	file.addEntity(poly);
+	file.add_entity(poly);
 
 	create_products_from_curve(file, poly);
 
 	IfcSchema::IfcEllipse* ellipse = new IfcSchema::IfcEllipse(file.addPlacement2d(), 50., 25.);
-	file.addEntity(ellipse);
-    aggregate_of_instance::ptr trim1(new aggregate_of_instance);
-    aggregate_of_instance::ptr trim2(new aggregate_of_instance);
+	file.add_entity(ellipse);
+	IfcEntityList::ptr trim1(new IfcEntityList);
+	IfcEntityList::ptr trim2(new IfcEntityList);
 	trim1->push(new IfcSchema::IfcParameterValue(  0.));
 	trim2->push(new IfcSchema::IfcParameterValue(180.));
-    IfcSchema::IfcTrimmedCurve* trim = new IfcSchema::IfcTrimmedCurve(ellipse, trim1->as<IfcSchema::IfcTrimmingSelect>(), trim2->as<IfcSchema::IfcTrimmingSelect>(), true, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	file.addEntity(trim);
+	IfcSchema::IfcTrimmedCurve* trim = new IfcSchema::IfcTrimmedCurve(ellipse, trim1, trim2, true, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
+	file.add_entity(trim);
 
 	create_products_from_curve(file, trim);
 
-    using namespace std::string_literals;
-	file.getSingle<IfcSchema::IfcProject>()->setName("arbitrary_open_profile_def"s);
+	file.getSingle<Ifc2x3::IfcProject>()->setName("IfcArbitraryOpenProfileDef");
 
 	std::ofstream f(filename);
 	f << file;
-}
+}

src/examples/composite_profile_def.cpp

@@ -27,18 +27,18 @@
 #include <iostream>
 #include <fstream>
 
-#define IfcSchema Ifc2x3
-#include "ifcparse/Ifc2x3.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/schemas/Ifc2x3.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/hierarchy_helper.h"
 
 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
+typedef ifcopenshell::global_id guid;
 boost::none_t const null = boost::none;
 
 int main(int argc, char** argv) {
-	const char filename[] = "composite_profile_def.ifc";
-	IfcHierarchyHelper<IfcSchema> file;
-	file.header().file_name()->setname(filename);
+	const char filename[] = "IfcCompositeProfileDef.ifc";
+	hierarchy_helper file;
+	file.header().file_name().name(filename);
 
 	double coords1[] = {100.0, 0.0};
 	double coords2[] = {200.0, 0.0};
@@ -65,11 +65,11 @@ int main(int argc, char** argv) {
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, file.addPlacement2d(80.),    50.0,    25.0,     5.0,    10.0,     2.0,    null);
 
-	file.addEntity(p2);
-	file.addEntity(p3);
+	file.add_entity(p2);
+	file.add_entity(p3);
 	
-	file.addEntity(transform1);
-	file.addEntity(transform2);
+	file.add_entity(transform1);
+	file.add_entity(transform2);
 	
 	IfcSchema::IfcDerivedProfileDef* p5 = new IfcSchema::IfcDerivedProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, null, p2, transform1, null);
 	IfcSchema::IfcDerivedProfileDef* p6 = new IfcSchema::IfcDerivedProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, null, p3, transform2, null);
@@ -95,8 +95,8 @@ int main(int argc, char** argv) {
 	IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(composite,
 		file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 20.0);
 
-	file.addEntity(composite);
-	file.addEntity(solid);
+	file.add_entity(composite);
+	file.add_entity(solid);
 		
 	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list());
 	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list());
@@ -107,13 +107,12 @@ int main(int argc, char** argv) {
 	reps->push(rep);
 
 	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
-	file.addEntity(rep);
-	file.addEntity(shape);
+	file.add_entity(rep);
+	file.add_entity(shape);
 		
 	product->setRepresentation(shape);
 
-	using namespace std::string_literals;
-	file.getSingle<IfcSchema::IfcProject>()->setName("composite_profile_def"s);
+	file.getSingle<IfcSchema::IfcProject>()->setName("IfcCompositeProfileDef");
 
 	std::ofstream f(filename);
 	f << file;

src/examples/csg_primitive.cpp

@@ -27,12 +27,12 @@
 #include <iostream>
 #include <fstream>
 
-#define IfcSchema Ifc2x3
-#include "ifcparse/Ifc2x3.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/schemas/Ifc2x3.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/hierarchy_helper.h"
 
 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
+typedef ifcopenshell::global_id guid;
 boost::none_t const null = boost::none;
 
 class Node {
@@ -101,7 +101,7 @@ public:
 		return operate(OP_INTERSECT, p);
 	}
 
-	IfcSchema::IfcRepresentationItem* serialize(IfcHierarchyHelper<IfcSchema>& file) const {
+	IfcSchema::IfcRepresentationItem* serialize(hierarchy_helper& file) const {
 		IfcSchema::IfcRepresentationItem* my;
 		if (op == OP_TERMINAL) {
 			IfcSchema::IfcAxis2Placement3D* place = file.addPlacement3d(x,y,z,zx,zy,zz,xx,xy,xz);
@@ -117,7 +117,7 @@ public:
 				my = new IfcSchema::IfcRightCircularCone(place, b, a);
 			}
 		} else {
-			IfcSchema::IfcBooleanOperator o = IfcSchema::IfcBooleanOperator::IfcBooleanOperator_UNION;
+			IfcSchema::IfcBooleanOperator::IfcBooleanOperator o;
 			if (op == OP_ADD) {
 				o = IfcSchema::IfcBooleanOperator::IfcBooleanOperator_UNION;
 			} else if (op == OP_SUBTRACT) {
@@ -125,17 +125,17 @@ public:
 			} else if (op == OP_INTERSECT) {
 				o = IfcSchema::IfcBooleanOperator::IfcBooleanOperator_INTERSECTION;
 			}
-			my = new IfcSchema::IfcBooleanResult(o, left->serialize(file)->as<IfcSchema::IfcBooleanOperand>(), right->serialize(file)->as<IfcSchema::IfcBooleanOperand>());
+			my = new IfcSchema::IfcBooleanResult(o, left->serialize(file), right->serialize(file));
 		}
-		file.addEntity(my);
+		file.add_entity(my);
 		return my;
 	}
 };
 
 int main(int argc, char** argv) {
-	const char filename[] = "csg_primitive.ifc";
-	IfcHierarchyHelper<IfcSchema> file;
-	file.header().file_name()->setname(filename);
+	const char filename[] = "IfcCsgPrimitive.ifc";
+	hierarchy_helper file;
+	file.header().file_name().name(filename);
 
 	IfcSchema::IfcRepresentationItem* csg1 = Node::Box(8000.,6000.,3000.).subtract(
 		Node::Box(7600.,5600.,2800.).move(200.,200.,200.)
@@ -181,13 +181,12 @@ int main(int argc, char** argv) {
 	reps->push(rep);
 
 	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(null, null, reps);
-	file.addEntity(rep);
-	file.addEntity(shape);
+	file.add_entity(rep);
+	file.add_entity(shape);
 		
 	product->setRepresentation(shape);
 
-	using namespace std::string_literals;
-	file.getSingle<IfcSchema::IfcProject>()->setName("csg_primitive"s);
+	file.getSingle<IfcSchema::IfcProject>()->setName("IfcCompositeProfileDef");
 
 	std::ofstream f(filename);
 	f << file;

src/examples/ellipse_pies.cpp

@@ -27,12 +27,12 @@
 #include <iostream>
 #include <fstream>
 
-#define IfcSchema Ifc2x3
-#include "ifcparse/Ifc2x3.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/schemas/Ifc2x3.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/hierarchy_helper.h"
 
 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
+typedef ifcopenshell::global_id guid;
 boost::none_t const null = boost::none;
 
 typedef struct {
@@ -44,7 +44,7 @@ typedef struct {
 
 static int i = 0;
 
-void create_testcase_for(IfcHierarchyHelper<IfcSchema>& file, const EllipsePie& pie, IfcSchema::IfcTrimmingPreference pref) {
+void create_testcase_for(hierarchy_helper& file, const EllipsePie& pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference pref) {
 	const double deg = 1. / 180. * 3.141592653;
 	double flt1[] = {0.                      , 0.                      };
 	double flt2[] = {pie.r1 * cos(pie.t1*deg), pie.r2 * sin(pie.t1*deg)};
@@ -66,24 +66,24 @@ void create_testcase_for(IfcHierarchyHelper<IfcSchema>& file, const EllipsePie&
 
 	
 	Ifc2x3::IfcEllipse* ellipse = new Ifc2x3::IfcEllipse(file.addPlacement2d(), pie.r1, pie.r2);
-	file.addEntity(ellipse);
-	aggregate_of_instance::ptr trim1(new aggregate_of_instance);
-    aggregate_of_instance::ptr trim2(new aggregate_of_instance);
-	if (pref == IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER) {
+	file.add_entity(ellipse);
+	IfcEntityList::ptr trim1(new IfcEntityList);
+	IfcEntityList::ptr trim2(new IfcEntityList);
+	if (pref == Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER) {
 		trim1->push(new Ifc2x3::IfcParameterValue(pie.t1));
 		trim2->push(new Ifc2x3::IfcParameterValue(pie.t2));
 	} else {
 		trim1->push(p2);
 		trim2->push(p3);
 	}
-	Ifc2x3::IfcTrimmedCurve* trim = new Ifc2x3::IfcTrimmedCurve(ellipse, trim1->as<IfcSchema::IfcTrimmingSelect>(), trim2->as<IfcSchema::IfcTrimmingSelect>(), true, pref);
-	file.addEntity(trim);
+	Ifc2x3::IfcTrimmedCurve* trim = new Ifc2x3::IfcTrimmedCurve(ellipse, trim1, trim2, true, pref);
+	file.add_entity(trim);
 	
 	Ifc2x3::IfcCompositeCurveSegment::list::ptr segments(new Ifc2x3::IfcCompositeCurveSegment::list());
 	Ifc2x3::IfcCompositeCurveSegment* s2 = new Ifc2x3::IfcCompositeCurveSegment(Ifc2x3::IfcTransitionCode::IfcTransitionCode_CONTINUOUS, true, trim);
 	
 	Ifc2x3::IfcPolyline* poly = new Ifc2x3::IfcPolyline(points);	
-	file.addEntity(poly);
+	file.add_entity(poly);
 	Ifc2x3::IfcCompositeCurveSegment* s1 = new Ifc2x3::IfcCompositeCurveSegment(Ifc2x3::IfcTransitionCode::IfcTransitionCode_CONTINUOUS, true, poly);
 	segments->push(s1);
 	
@@ -92,8 +92,8 @@ void create_testcase_for(IfcHierarchyHelper<IfcSchema>& file, const EllipsePie&
 	
 	Ifc2x3::IfcCompositeCurve* ccurve = new Ifc2x3::IfcCompositeCurve(segments, false);
 	Ifc2x3::IfcArbitraryClosedProfileDef* profile = new Ifc2x3::IfcArbitraryClosedProfileDef(Ifc2x3::IfcProfileTypeEnum::IfcProfileType_AREA, null, ccurve);
-	file.addEntity(ccurve);
-	file.addEntity(profile);
+	file.add_entity(ccurve);
+	file.add_entity(profile);
 
 	IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
 		guid(), 0, S("profile"), null, null, 0, 0, null, null);
@@ -105,7 +105,7 @@ void create_testcase_for(IfcHierarchyHelper<IfcSchema>& file, const EllipsePie&
 	IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(profile,
 		file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 20.0);
 
-	file.addEntity(solid);
+	file.add_entity(solid);
 		
 	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list());
 	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list());
@@ -116,33 +116,33 @@ void create_testcase_for(IfcHierarchyHelper<IfcSchema>& file, const EllipsePie&
 	reps->push(rep);
 
 	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
-	file.addEntity(rep);
-	file.addEntity(shape);
+	file.add_entity(rep);
+	file.add_entity(shape);
 		
 	product->setRepresentation(shape);
 }
 
 int main(int argc, char** argv) {
 	const std::string filename = "ellipse_pies.ifc";
-	IfcHierarchyHelper<IfcSchema> file;
+	hierarchy_helper file;
 	{ EllipsePie pie = {80., 50.,  0., 150.};
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
 	{ EllipsePie pie = {80,  50., 30., 300.};
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
 	{ EllipsePie pie = {80,  50., 300., 30.};
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
 	{ EllipsePie pie = {50., 80.,  0., 150.};
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
 	{ EllipsePie pie = {50,  80., 30., 300.};
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
 	{ EllipsePie pie = {50,  80., 300., 30.};
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	create_testcase_for(file, pie, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
+	create_testcase_for(file, pie, Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);}
 	std::ofstream f(filename.c_str());
 	f << file;
 }

src/examples/faces.cpp

@@ -22,19 +22,18 @@
  * Example that generates various forms of IfcFace                              *
  *                                                                              *
  ********************************************************************************/
-#include <fstream>
 
-#define IfcSchema Ifc2x3
-#include "ifcparse/Ifc2x3.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/schemas/Ifc2x3.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/hierarchy_helper.h"
 
 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = boost::none;
+typedef ifcopenshell::global_id guid;
+boost::none_t const null = (static_cast<boost::none_t>(0));
 
 static int x = 0;
 
-void create_testcase(IfcHierarchyHelper<IfcSchema>& file, IfcSchema::IfcFace* face, const std::string& name) {
+void create_testcase(hierarchy_helper& file, IfcSchema::IfcFace* face, const std::string& name) {
 	IfcSchema::IfcFace::list::ptr faces(new IfcSchema::IfcFace::list);
 	faces->push(face);
 	IfcSchema::IfcOpenShell* shell = new IfcSchema::IfcOpenShell(faces);
@@ -58,14 +57,14 @@ void create_testcase(IfcHierarchyHelper<IfcSchema>& file, IfcSchema::IfcFace* fa
 		file.getRepresentationContext("Model"), S("Body"), S("SurfaceModel"), items);
 	reps->push(rep);
 
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
-	file.addEntity(shape);
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
+	file.add_entity(shape);
 		
 	product->setRepresentation(shape);
 }
 
 int main(int argc, char** argv) {
-	IfcHierarchyHelper<IfcSchema> file;
+	hierarchy_helper file;
 	{ 
 		IfcSchema::IfcCartesianPoint::list::ptr points (new IfcSchema::IfcCartesianPoint::list);
 		points->push(file.addTriplet<IfcSchema::IfcCartesianPoint>(-400, -400, 0));
@@ -193,7 +192,7 @@ int main(int argc, char** argv) {
 		IfcSchema::IfcCartesianPoint::list::ptr trim2(new IfcSchema::IfcCartesianPoint::list);
 		trim1->push(point1);
 		trim2->push(point2);
-		IfcSchema::IfcTrimmedCurve* trimmed_curve = new IfcSchema::IfcTrimmedCurve(circle, trim1->generalize()->as<IfcSchema::IfcTrimmingSelect>(), trim2->generalize()->as<IfcSchema::IfcTrimmingSelect>(), true, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);
+		IfcSchema::IfcTrimmedCurve* trimmed_curve = new IfcSchema::IfcTrimmedCurve(circle, trim1->generalize(), trim2->generalize(), true, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN);
 		IfcSchema::IfcArbitraryOpenProfileDef* profile = new IfcSchema::IfcArbitraryOpenProfileDef(IfcSchema::IfcProfileTypeEnum::IfcProfileType_CURVE, boost::none, trimmed_curve);
 		IfcSchema::IfcAxis1Placement* place = new IfcSchema::IfcAxis1Placement(file.addTriplet<IfcSchema::IfcCartesianPoint>(0., 0., 0.), file.addTriplet<IfcSchema::IfcDirection>(1., 0., 0.));
 		IfcSchema::IfcSurfaceOfRevolution* surface = new IfcSchema::IfcSurfaceOfRevolution(profile, file.addPlacement3d(), place);
@@ -201,8 +200,8 @@ int main(int argc, char** argv) {
 		IfcSchema::IfcFace* face = new IfcSchema::IfcFaceSurface(bounds, surface, true);
 		create_testcase(file, face, "face surface");
 	}
-	const char filename[] = "faces.ifc";
-	file.header().file_name()->setname(filename);
-	std::ofstream f(filename);
+	const std::string filename = "faces.ifc";
+	file.header().file_name().name(filename);
+	std::ofstream f(filename.c_str());
 	f << file;
-}
+}

src/examples/ifc_curve_rebar.cpp

@@ -27,24 +27,22 @@
 #include <string>
 #include <fstream>
 
-#define IfcSchema Ifc2x3
-#include "ifcparse/Ifc2x3.h"
-#include "ifcparse/IfcHierarchyHelper.h"
-
-#include <boost/math/constants/constants.hpp>
-const static double PI = boost::math::constants::pi<double>();
+#include "ifcparse\Ifc2x3.h"
+#include "ifcparse\IfcUtil.h"
+#include "ifcparse\hierarchy_helper.h"
+#include "ifcgeom\IfcGeom.h"
 
 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
+typedef ifcopenshell::global_id guid;
 boost::none_t const null = boost::none;
 
-void create_curve_rebar(IfcHierarchyHelper<IfcSchema>& file)
+void create_curve_rebar(hierarchy_helper& file)
 {
 	int dia = 24;
 	int R = 3 * dia;
 	int length = 12 * dia;
 
-	double crossSectionarea = PI * dia * dia / 4;
+	double crossSectionarea = M_PI * (dia / 2) * 2;
 	IfcSchema::IfcReinforcingBar* rebar = new IfcSchema::IfcReinforcingBar(
 		guid(), 0, S("test"), null,
 		null, 0, 0,
@@ -73,32 +71,31 @@ void create_curve_rebar(IfcHierarchyHelper<IfcSchema>& file)
 	points1->push(p2);
 	file.addEntities(points1->generalize());
 	IfcSchema::IfcPolyline* poly1 = new IfcSchema::IfcPolyline(points1);
-	file.addEntity(poly1);
+	file.add_entity(poly1);
 
 	IfcSchema::IfcCompositeCurveSegment* segment1 = new IfcSchema::IfcCompositeCurveSegment(IfcSchema::IfcTransitionCode::IfcTransitionCode_CONTINUOUS, true, poly1);
-	file.addEntity(segment1);
+	file.add_entity(segment1);
 	segments->push(segment1);
 
 	/*second segment - arc */
 	IfcSchema::IfcAxis2Placement3D* axis1 = new IfcSchema::IfcAxis2Placement3D(p3, file.addTriplet<IfcSchema::IfcDirection>(1, 0, 0), file.addTriplet<IfcSchema::IfcDirection>(0, 1, 0));
-	file.addEntity(axis1);
+	file.add_entity(axis1);
 	IfcSchema::IfcCircle* circle = new IfcSchema::IfcCircle(axis1, R);
-	file.addEntity(circle);
+	file.add_entity(circle);
+
+	IfcEntityList::ptr trim1(new IfcEntityList);
+	IfcEntityList::ptr trim2(new IfcEntityList);
 
-	IfcSchema::IfcTrimmingSelect::list::ptr trim1(new IfcSchema::IfcTrimmingSelect::list);
-    IfcSchema::IfcTrimmingSelect::list::ptr trim2(new IfcSchema::IfcTrimmingSelect::list);
-	
 	trim1->push(new IfcSchema::IfcParameterValue(180));
 	trim1->push(p2);
 
 	trim2->push(new IfcSchema::IfcParameterValue(270));
 	trim2->push(p4);
-	
 	IfcSchema::IfcTrimmedCurve* trimmed_curve = new IfcSchema::IfcTrimmedCurve(circle, trim1, trim2, false, IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_PARAMETER);
-	file.addEntity(trimmed_curve);
+	file.add_entity(trimmed_curve);
 
 	IfcSchema::IfcCompositeCurveSegment* segment2 = new IfcSchema::IfcCompositeCurveSegment(IfcSchema::IfcTransitionCode::IfcTransitionCode_CONTSAMEGRADIENT, false, trimmed_curve);
-	file.addEntity(segment2);
+	file.add_entity(segment2);
 	segments->push(segment2);
 
 	/*third segment - line */
@@ -107,14 +104,14 @@ void create_curve_rebar(IfcHierarchyHelper<IfcSchema>& file)
 	points2->push(p5);
 	file.addEntities(points2->generalize());
 	IfcSchema::IfcPolyline* poly2 = new IfcSchema::IfcPolyline(points2);
-	file.addEntity(poly2);
+	file.add_entity(poly2);
 
 	IfcSchema::IfcCompositeCurveSegment* segment3 = new IfcSchema::IfcCompositeCurveSegment(IfcSchema::IfcTransitionCode::IfcTransitionCode_CONTINUOUS, true, poly2);
-	file.addEntity(segment3);
+	file.add_entity(segment3);
 	segments->push(segment3);
 
 	IfcSchema::IfcCompositeCurve* curve = new IfcSchema::IfcCompositeCurve(segments, false);
-	file.addEntity(curve);
+	file.add_entity(curve);
 
 	IfcSchema::IfcSweptDiskSolid* solid = new IfcSchema::IfcSweptDiskSolid(curve, dia / 2, null, 0, 1);
 
@@ -126,7 +123,7 @@ void create_curve_rebar(IfcHierarchyHelper<IfcSchema>& file)
 	reps->push(rep);
 
 	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(null, null, reps);
-	file.addEntity(shape);
+	file.add_entity(shape);
 
 	rebar->setRepresentation(shape);
 
@@ -136,8 +133,8 @@ void create_curve_rebar(IfcHierarchyHelper<IfcSchema>& file)
 
 int main()
 {
-	IfcHierarchyHelper<IfcSchema> file;
-	file.header().file_name()->setname("ifc_curve_rebar.ifc");
+	hierarchy_helper file;
+	file.header().file_name().name("ifc_curve_rebar.ifc");
 	create_curve_rebar(file);
 	std::ofstream f("ifc_curve_rebar.ifc");
 	f << file;

src/examples/profiles.cpp

@@ -27,21 +27,21 @@
 #include <iostream>
 #include <fstream>
 
-#define IfcSchema Ifc2x3
-#include "ifcparse/Ifc2x3.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/schemas/Ifc2x3.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/hierarchy_helper.h"
 
 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = boost::none;
+typedef IfcWrite::IfcGuidHelper guid;
+boost::none_t const null = (static_cast<boost::none_t>(0));
 
 void create_testcase_for(IfcSchema::IfcProfileDef::list::ptr profiles) {
 	IfcSchema::IfcProfileDef* profile = *profiles->begin();
-	const std::string& profile_type = profile->declaration().name();
+	const std::string profile_type = IfcSchema::Type::ToString(profile->type());
 	const std::string filename = profile_type + ".ifc";
 	
-	IfcHierarchyHelper<IfcSchema> file;
-	file.header().file_name()->setname(filename);
+	hierarchy_helper file;
+	file.filename(filename);
 	
 	int i = 0;
 	for (IfcSchema::IfcProfileDef::list::it it = profiles->begin(); it != profiles->end(); ++it, ++i) {
@@ -54,15 +54,15 @@ void create_testcase_for(IfcSchema::IfcProfileDef::list::ptr profiles) {
 
 		product->setObjectPlacement(file.addLocalPlacement(0, 100. * i));
 
-		if (profile->declaration().is(IfcSchema::IfcParameterizedProfileDef::Class())) {
+		if (profile->is(IfcSchema::Type::IfcParameterizedProfileDef)) {
 			((IfcSchema::IfcParameterizedProfileDef*) profile)->setPosition(file.addPlacement2d());
 		}
 
 		IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(profile,
 			file.addPlacement3d(), file.addTriplet<IfcSchema::IfcDirection>(0, 0, 1), 20.0);
 
-		file.addEntity(profile);
-		file.addEntity(solid);
+		file.add_entity(profile);
+		file.add_entity(solid);
 		
 		IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list);
 		IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list);
@@ -72,9 +72,9 @@ void create_testcase_for(IfcSchema::IfcProfileDef::list::ptr profiles) {
 			file.getSingle<IfcSchema::IfcRepresentationContext>(), S("Body"), S("SweptSolid"), items);
 		reps->push(rep);
 
-		IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(null, null, reps);
-		file.addEntity(rep);
-		file.addEntity(shape);
+		IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
+		file.add_entity(rep);
+		file.add_entity(shape);
 		
 		product->setRepresentation(shape);
 	}
@@ -84,123 +84,122 @@ void create_testcase_for(IfcSchema::IfcProfileDef::list::ptr profiles) {
 }
 
 int main(int argc, char** argv) {
-    IfcSchema::get_schema();  // Ensure schema is initialized
 	{ IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcUShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcUShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null,    null,    null));
-	profiles->push(new IfcSchema::IfcUShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcUShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,     2.0,     2.0,    null,    null));
-	profiles->push(new IfcSchema::IfcUShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcUShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null,     4.0,    null));
-	profiles->push(new IfcSchema::IfcUShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcUShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,     1.0,     3.0,     6.0,    null));
 	create_testcase_for(profiles); }
 	
     { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcTShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcTShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null,    null,    null,    null,    null));
-	profiles->push(new IfcSchema::IfcTShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcTShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,     2.0,     2.0,     2.0,    null,    null,    null));
-	profiles->push(new IfcSchema::IfcTShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcTShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null,    null,     2.0,     2.0,    null));
-	profiles->push(new IfcSchema::IfcTShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcTShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,     3.0,     2.0,     1.0,     2.0,     2.0,    null));
 	create_testcase_for(profiles); }
 	
     { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcZShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcZShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,    null,    null));
-	profiles->push(new IfcSchema::IfcZShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcZShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     5.0,     2.0,     2.0));
 	create_testcase_for(profiles); }
 	
     { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcEllipseProfileDef(
+	profiles->push(new Ifc2x3::IfcEllipseProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    25.0,    15.0));
-	profiles->push(new IfcSchema::IfcEllipseProfileDef(
+	profiles->push(new Ifc2x3::IfcEllipseProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    15.0,    25.0));
 	create_testcase_for(profiles); }
 	
     { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcIShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcIShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    25.0,    50.0,     5.0,     5.0,    null));
-	profiles->push(new IfcSchema::IfcIShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcIShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    25.0,    50.0,     5.0,     5.0,     2.0));
-	profiles->push(new IfcSchema::IfcAsymmetricIShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcAsymmetricIShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    25.0,    50.0,     5.0,     5.0,     2.0, 20.0, 10.0, 5.0, null));
 	create_testcase_for(profiles); }
 
     { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcLShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcLShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     null,    null,    null,    null,    null));
-	profiles->push(new IfcSchema::IfcLShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcLShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     2.0,      2.0,    null,    null,    null));
-	profiles->push(new IfcSchema::IfcLShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcLShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     null,    null,     2.0,    null,    null));
-	profiles->push(new IfcSchema::IfcLShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcLShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,      1.0,     2.0,     2.0,    null,    null));
 	create_testcase_for(profiles); }
 	
     { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcCShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcCShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,    10.0,    null,    null));
-	profiles->push(new IfcSchema::IfcCShapeProfileDef(
+	profiles->push(new Ifc2x3::IfcCShapeProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,    10.0,     2.0,    null));
 	create_testcase_for(profiles); }
 
     { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcCircleProfileDef(
+	profiles->push(new Ifc2x3::IfcCircleProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    25.0));
-	profiles->push(new IfcSchema::IfcCircleHollowProfileDef(
+	profiles->push(new Ifc2x3::IfcCircleHollowProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    25.0,     5.0));
 	create_testcase_for(profiles); }
 	
     { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcRectangleProfileDef(
+	profiles->push(new Ifc2x3::IfcRectangleProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0));
-	profiles->push(new IfcSchema::IfcRoundedRectangleProfileDef(
+	profiles->push(new Ifc2x3::IfcRoundedRectangleProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0));
-	profiles->push(new IfcSchema::IfcRectangleHollowProfileDef(
+	profiles->push(new Ifc2x3::IfcRectangleHollowProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,    null,    null));
-	profiles->push(new IfcSchema::IfcRectangleHollowProfileDef(
+	profiles->push(new Ifc2x3::IfcRectangleHollowProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    25.0,     5.0,     2.0,     4.0));
 	create_testcase_for(profiles); }
 	
     { IfcSchema::IfcProfileDef::list::ptr profiles (new IfcSchema::IfcProfileDef::list);
-	profiles->push(new IfcSchema::IfcTrapeziumProfileDef(
+	profiles->push(new Ifc2x3::IfcTrapeziumProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    30.0,    25.0,     0.0));
-	profiles->push(new IfcSchema::IfcTrapeziumProfileDef(
+	profiles->push(new Ifc2x3::IfcTrapeziumProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    60.0,    25.0,   -20.0));
-	profiles->push(new IfcSchema::IfcTrapeziumProfileDef(
+	profiles->push(new Ifc2x3::IfcTrapeziumProfileDef(
 		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA,
 		null, 0,    50.0,    10.0,    25.0,    30.0));
 	create_testcase_for(profiles); }

src/examples/triangulated_faceset.cpp

@@ -23,19 +23,15 @@
  *                                                                              *
  ********************************************************************************/
 
-#include <iostream>
-#include <fstream>
-#include <optional>
-
-#define IfcSchema Ifc4
-#include "ifcparse/Ifc4.h"
-#include "ifcparse/IfcHierarchyHelper.h"
+#include "../ifcparse/schemas/Ifc4.h"
+#include "../ifcparse/hierarchy_helper.h"
 
 #include "suzanne_geometry.h"
 
+#include <fstream>
+
 typedef std::string S;
-typedef IfcParse::IfcGlobalId guid;
-boost::none_t const null = boost::none;
+typedef ifcopenshell::global_id guid;
 
 template <typename T>
 std::vector< std::vector<T> > create_vector_from_array(const T* arr, unsigned size) {
@@ -54,36 +50,31 @@ std::vector< std::vector<T> > create_vector_from_array(const T* arr, unsigned si
 }
 
 int main(int argc, char** argv) {
-	IfcHierarchyHelper<IfcSchema> file;
+    hierarchy_helper<Ifc4> file;
 
-	IfcSchema::IfcBuildingElementProxy* product = new IfcSchema::IfcBuildingElementProxy(
-		guid(), 0, S("Blender's Suzanne"), null, null, 0, 0, null, null);
+	Ifc4::IfcBuildingElementProxy product = file.create<Ifc4::IfcBuildingElementProxy>().initialize(
+        guid(), std::nullopt, S("Blender's Suzanne"), std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt);
 	file.addBuildingProduct(product);
-	product->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
+	product.setOwnerHistory(file.getSingle<Ifc4::IfcOwnerHistory>());
 
-	product->setObjectPlacement(file.addLocalPlacement());
-
-	IfcSchema::IfcRepresentation::list::ptr reps (new IfcSchema::IfcRepresentation::list);
-	IfcSchema::IfcRepresentationItem::list::ptr items (new IfcSchema::IfcRepresentationItem::list);
+	product.setObjectPlacement(file.addLocalPlacement());
 
 	std::vector< std::vector< double > > vertices_vector = create_vector_from_array(vertices, sizeof(vertices) / sizeof(vertices[0]));
 	std::vector< std::vector< int > > indices_vector = create_vector_from_array(indices, sizeof(indices) / sizeof(indices[0]));
 
-	IfcSchema::IfcCartesianPointList3D* coordinates = new IfcSchema::IfcCartesianPointList3D(vertices_vector);	
-	IfcSchema::IfcTriangulatedFaceSet* faceset = new IfcSchema::IfcTriangulatedFaceSet(coordinates, null, null, indices_vector, null);
+	Ifc4::IfcCartesianPointList3D coordinates = file.create<Ifc4::IfcCartesianPointList3D>().initialize(vertices_vector);	
+	Ifc4::IfcTriangulatedFaceSet faceset = file.create<Ifc4::IfcTriangulatedFaceSet>().initialize(coordinates, std::nullopt, std::nullopt, indices_vector, std::nullopt);
 		
-	items->push(faceset);
-	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
-		file.getRepresentationContext("Model"), S("Body"), S("SurfaceModel"), items);
-	reps->push(rep);
+	Ifc4::IfcShapeRepresentation rep = file.create<Ifc4::IfcShapeRepresentation>().initialize(
+        file.getRepresentationContext("Model"), "Body", "SurfaceModel", {faceset});
 
-	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(boost::none, boost::none, reps);
-	file.addEntity(shape);
+	Ifc4::IfcProductDefinitionShape shape = file.create<Ifc4::IfcProductDefinitionShape>().initialize(std::nullopt, std::nullopt, {rep});
+	file.add_entity(shape);
 		
-	product->setRepresentation(shape);
+	product.setRepresentation(shape);
 
-	const std::string filename = "triangulated_faceset.ifc";
-	file.header().file_name()->setname(filename);
-	std::ofstream f(filename);
+	const std::string filename = "tesselated_faceset.ifc";
+	file.header().file_name().setname(filename);
+	std::ofstream f(filename.c_str());
 	f << file;
 }

src/exterior-shell-extractor/main.py

@@ -457,7 +457,7 @@ class context:
 
         for f in self.fs:
             if kwargs.keys() == {'include'}:
-                kwargs2 = {'include': [e for e in kwargs['include'] if e.wrapped_data.file == f]}
+                kwargs2 = {'include': [e for e in kwargs['include'] if e.file == f]}
             else:
                 kwargs2 = kwargs
             it = ifcopenshell.geom.iterator(s, f, geometry_library="cgal", **kwargs2)

src/ifc5d/ifc5d/IFC4X3QtoBaseQuantitiesBlender.json

@@ -237,7 +237,7 @@
                     "Area": "get_net_side_area",
                     "Height": "get_height",
                     "Perimeter": "get_rectangular_perimeter",
-                    "Width": "get_x"
+                    "Width": "get_length"
                 }
             },
             "IfcDuctFitting + IfcDuctFittingType": {

src/ifc5d/ifc5d/ifc2json.py

@@ -168,7 +168,7 @@ class ifc5D2json:
                 data["UnitSymbol"] = ifcopenshell.util.unit.get_unit_symbol(unit)
             if quantity.is_a("IfcPhysicalSimpleQuantity"):
                 measure_class = (
-                    quantity.wrapped_data.declaration()
+                    quantity.declaration()
                     .as_entity()
                     .attribute_by_index(3)
                     .type_of_attribute()

src/ifcchat/ifc_worker.js

@@ -29,7 +29,16 @@ async function ensurePyodide() {
         const micropip = pyodide.pyimport("micropip");
         micropip.install("python-dateutil")
         
-        const wheelUrl = "https://ifcopenshell.github.io/wasm-wheels/ifcopenshell-0.8.5-cp313-cp313-pyodide_2025_0_wasm32.whl";
+        // Detect python minor version (3.12 vs 3.13) and pick a matching wheel.
+        const pyVer = pyodide.runPython(`
+import sys
+f"{sys.version_info.major}.{sys.version_info.minor}"
+    `);
+
+        const wheelUrl =
+            pyVer === "3.13"
+                ? "https://ifcopenshell.github.io/wasm-wheels/ifcopenshell-0.8.3+34a1bc6-cp313-cp313-emscripten_4_0_9_wasm32.whl"
+                : "https://ifcopenshell.github.io/wasm-wheels/ifcopenshell-0.8.2+d50e806-cp312-cp312-emscripten_3_1_58_wasm32.whl";
 
         await micropip.install(wheelUrl);
 

src/ifcconvert/CMakeLists.txt

@@ -1,27 +1,26 @@
 # IfcConvert
-if(WITH_RELATIONSHIP_VALIDATION)
-    file(GLOB IFCCONVERT_CPP_FILES *.cpp)
-    file(GLOB IFCCONVERT_H_FILES *.h)
-else()
-    file(GLOB IFCCONVERT_CPP_FILES IfcConvert.cpp)
-    file(GLOB IFCCONVERT_H_FILES)
-endif()
-set(IFCCONVERT_FILES ${IFCCONVERT_CPP_FILES} ${IFCCONVERT_H_FILES})
-add_executable(IfcConvert ${IFCCONVERT_FILES})
+add_executable(IfcConvert IfcConvert.cpp)
 
-target_link_libraries(
-    IfcConvert
-    PRIVATE
-        IfcGeom
-        IfcParse
-        Serializers
-        ${kernel_libraries}
-        ${OpenCASCADE_LIBRARIES}
-        ${Boost_LIBRARIES}
-        ${HDF5_LIBRARIES}
-        ${USD_LIBRARIES}
-        ${CGAL_LIBRARIES}
-        ${GLTF_LIBRARIES}
+target_link_libraries(IfcConvert PRIVATE IfcGeom IfcParse ${Boost_LIBRARIES})
+if(kernel_libraries OR mapping_libraries OR geometry_serializer_libraries OR document_serializer_libraries)
+    add_dependencies(IfcConvert ${kernel_libraries} ${mapping_libraries} ${geometry_serializer_libraries} ${document_serializer_libraries})
+endif()
+
+set(_plugin_targets
+    ${kernel_libraries}
+    ${mapping_libraries}
+    ${geometry_serializer_libraries}
+    ${document_serializer_libraries}
 )
 
-install(TARGETS IfcConvert EXPORT ${IFCOPENSHELL_EXPORT_TARGETS})
+set(_plugin_paths "")
+foreach(t IN LISTS _plugin_targets)
+    string(APPEND _plugin_paths ";$<TARGET_FILE_DIR:${t}>")
+endforeach()
+
+set_target_properties(IfcConvert PROPERTIES
+    VS_DEBUGGER_ENVIRONMENT
+        "PATH=%PATH%;$<JOIN:$<TARGET_RUNTIME_DLL_DIRS:IfcConvert>,;>;${_plugin_paths}"
+)
+
+install(TARGETS IfcConvert)

src/ifcconvert/validate_space_boundaries.cpp

@@ -18,29 +18,29 @@ typedef CGAL::AABB_traits<Kernel_, Primitive> Traits;
 typedef CGAL::AABB_tree<Traits> Tree;
 typedef Tree::Point_and_primitive_id Point_and_primitive_id;
 
-void fix_spaceboundaries(IfcParse::IfcFile& f, bool no_progress, bool quiet, bool stderr_progress) {
+void fix_spaceboundaries(ifcopenshell::file& f, bool no_progress, bool quiet, bool stderr_progress) {
 	intersection_validator v(f, { "IfcWall", "IfcSpace", "IfcSlab", "IfcCovering" }, 1.e-5, no_progress, quiet, stderr_progress);
 
 	auto rels = f.instances_by_type("IfcRelSpaceBoundary");
 
-	std::map<std::pair<const IfcUtil::IfcBaseClass*, const IfcUtil::IfcBaseClass*>, const IfcUtil::IfcBaseClass*> rel_by_space_elem;
+	std::map<std::pair<const ifcopenshell::IfcBaseClass*, const ifcopenshell::IfcBaseClass*>, const ifcopenshell::IfcBaseClass*> rel_by_space_elem;
 
 
 	if (rels) {
-		std::for_each(rels->begin(), rels->end(), [&rel_by_space_elem](const IfcUtil::IfcBaseClass* rel) {
-			auto x = ((IfcUtil::IfcBaseEntity*)rel)->get_value<IfcUtil::IfcBaseClass*>("RelatingSpace");
+		std::for_each(rels->begin(), rels->end(), [&rel_by_space_elem](const ifcopenshell::IfcBaseClass* rel) {
+			auto x = ((ifcopenshell::IfcBaseEntity*)rel)->get_value<ifcopenshell::IfcBaseClass*>("RelatingSpace");
 			try {
-				auto y = ((IfcUtil::IfcBaseEntity*)rel)->get_value<IfcUtil::IfcBaseClass*>("RelatedBuildingElement");
+				auto y = ((ifcopenshell::IfcBaseEntity*)rel)->get_value<ifcopenshell::IfcBaseClass*>("RelatedBuildingElement");
 				rel_by_space_elem.insert({ { x,y }, rel });
-			} catch (IfcParse::IfcException&) {
+			} catch (ifcopenshell::exception&) {
 				// RelatedBuildingElement can be NULL
 			}
 		});
 	}
 
-	std::set<const IfcUtil::IfcBaseClass*> rels_encounted;
+	std::set<const ifcopenshell::IfcBaseClass*> rels_encounted;
 
-	IfcParse::IfcFile f2("boundaries-triangulated.ifc");
+	ifcopenshell::file f2("boundaries-triangulated.ifc");
 	if (!f2.good()) {
 		return;
 	}
@@ -59,7 +59,7 @@ void fix_spaceboundaries(IfcParse::IfcFile& f, bool no_progress, bool quiet, boo
 	std::map<std::set<std::string>, std::vector<Kernel_::Point_3>> elem_to_space_boundary_coords;
 
 	for (auto& i : *f2.instances_by_type("IfcProduct")) {
-		auto n = ((IfcUtil::IfcBaseEntity*)i)->get_value<std::string>("Name");
+		auto n = ((ifcopenshell::IfcBaseEntity*)i)->get_value<std::string>("Name");
 		auto g1 = n.substr(0, 22);
 		auto g2 = n.substr(23);
 		auto item = c.mapping()->map(i);
@@ -83,7 +83,7 @@ void fix_spaceboundaries(IfcParse::IfcFile& f, bool no_progress, bool quiet, boo
 
 	v([&rel_by_space_elem, &elem_to_space_boundary_coords, &guid_pairs_visited](const intersection_validator::Box& a, const intersection_validator::Box& b) {
 		std::ostringstream ss;
-		// ss << id_map[a.id()]->first->data().toString() << "x" << id_map[b.id()]->first->data().toString() << std::endl;
+		// ss << id_map[a.id()]->first->data().to_string() << "x" << id_map[b.id()]->first->data().to_string() << std::endl;
 		// auto x = id_map[a.id()]->second * id_map[b.id()]->second;
 
 		auto A = a.handle()->first;
@@ -103,7 +103,7 @@ void fix_spaceboundaries(IfcParse::IfcFile& f, bool no_progress, bool quiet, boo
 			return;
 		}
 
-		ss << a.handle()->first->data().toString() << "x" << a.handle()->first->data().toString() << std::endl;
+		ss << a.handle()->first->data().to_string() << "x" << a.handle()->first->data().to_string() << std::endl;
 		auto x = a.handle()->second * b.handle()->second;
 
 		if (x.is_empty()) {
@@ -128,7 +128,7 @@ void fix_spaceboundaries(IfcParse::IfcFile& f, bool no_progress, bool quiet, boo
 		auto itelem = elem_to_space_boundary_coords.find({ Aguid, Bguid });
 
 		if (itelem == elem_to_space_boundary_coords.end()) {
-			Logger::Error("Missing space boundary relationship " + Aguid + " " + Bguid);
+			logger::error("Missing space boundary relationship " + Aguid + " " + Bguid);
 			return;
 		}
 
@@ -141,7 +141,7 @@ void fix_spaceboundaries(IfcParse::IfcFile& f, bool no_progress, bool quiet, boo
 		bool valid = *std::max_element(distances.begin(), distances.end()) < 0.4;
 
 		if (!valid) {
-			Logger::Error("Wrong connection geometry " + Aguid + " " + Bguid);
+			logger::error("Wrong connection geometry " + Aguid + " " + Bguid);
 		}
 
 		/*{
@@ -174,11 +174,11 @@ void fix_spaceboundaries(IfcParse::IfcFile& f, bool no_progress, bool quiet, boo
 	};
 
 	for (auto& i : *f2.instances_by_type("IfcProduct")) {
-		auto n = ((IfcUtil::IfcBaseEntity*)i)->get_value<std::string>("Name");
+		auto n = ((ifcopenshell::IfcBaseEntity*)i)->get_value<std::string>("Name");
 		auto g1 = n.substr(0, 22);
 		auto g2 = n.substr(23);
 		if (is_wall_space_or_slab(g1) && is_wall_space_or_slab(g2) && guid_pairs_visited.find({ g1, g2 }) == guid_pairs_visited.end()) {
-			Logger::Error("Space boundary for non-bounding geometry " + g1 + " " + g2);
+			logger::error("Space boundary for non-bounding geometry " + g1 + " " + g2);
 		}
 	}
 }