Fix #2413 . Bug where multiple tasks may accidentally override animation keyframes.

Prototype connection-aware wall extension and T-joints
wrapper is a bash script not a sh script
2026-08-09 09:21:46 +00:00 · 2022-09-16 11:53:25 +10:00 · 2022-09-15 22:44:06 +10:00 · 2022-09-15 07:42:00 +01:00 · 2022-09-15 10:46:52 +10:00 · 2022-09-15 10:44:43 +10:00
781 changed files with 144291 additions and 24359 deletions
@@ -0,0 +1,98 @@
+name: Publish-blenderbim-chocolatey package
+
+on:
+  schedule:
+    #         ┌───────────── minute (0 - 59)
+    #         │  ┌───────────── hour (0 - 23)
+    #         │  │ ┌───────────── day of the month (1 - 31)
+    #         │  │ │ ┌───────────── month (1 - 12 or JAN-DEC)
+    #         │  │ │ │ ┌───────────── day of the week (0 - 6 or SUN-SAT)
+    #         *  * * * *
+    - cron: "55 23 * * *" # 5min before utc midnight
+
+env:
+  major: 0
+  minor: 0
+  name: blenderbim
+  choco_version: 1.1.0
+  CHOCO_TOKEN:   ${{ secrets.CHOCO_TOKEN }}
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Set env
+      run: echo ok go
+
+  build:
+    needs: activate
+    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pyver: [py310]
+        config:
+          - {
+            name: "Windows Build",
+            short_name: win,
+          }
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
+        with:
+          python-version: '3.7.7' # Version range or exact version of a Python version to use, using SemVer's version range syntax
+          architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
+      - run: echo ${{ env.DATE }}
+
+      - name: Check in published releases if we should do a choco release
+        id: do_choco
+        run: |
+          echo "::set-output name=choco_release::$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --do_choco_release?)"
+
+      - name: Compile
+        if: ${{steps.do_choco.outputs.choco_release}} == 'do_choco_release'
+        run: |
+          target_os=${{ matrix.config.short_name }} &&
+          pyver=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --pyver?) &&
+          cp -r src/blenderbim src/blenderbim_$target_os_$pyver &&
+          cd src/blenderbim_$target_os_$pyver &&
+          make dist PLATFORM=$target_os PYVERSION=$pyver
+
+      - name: Fill chocolatey scripts on win with latest blender python
+        if: ${{steps.do_choco.outputs.choco_release}} == 'do_choco_release'
+        run: |
+          today_non_iso="$(date +'%y%m%d' | tr -d '\n')" &&
+          target_os=${{ matrix.config.short_name }} &&
+          latest_blender_python_version_maj_min=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --latest_blender_python_version_maj_min?) &&
+          echo "latest_blender_python_version_maj_min?: $latest_blender_python_version_maj_min" &&
+          pyver=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --pyver?) &&
+          export latest_blender_version_maj_min=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --latest_blender_release_maj_min?) &&
+          export latest_blender_version_maj_min_pat=$(python3 /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/check_repo_infos.py --latest_blender_release_maj_min_pat?) &&
+          echo   latest_blender_version_maj_min_pat?: $latest_blender_version_maj_min_pat &&
+          export blenderbim_build_version="${{ env.major }}.${{ env.minor }}.$today_non_iso" &&
+          export url_blenderbim_py310_win_zip="https://github.com/IfcOpenShell/IfcOpenShell/releases/download/blenderbim-$today_non_iso/blenderbim-$today_non_iso-$pyver-$target_os.zip" &&
+          export sha256sum_blenderbim_py310_win_zip=$( sha256sum src/blenderbim_$target_os_$pyver/dist/blenderbim-$today_non_iso-$pyver-$target_os.zip  --tag | cut -d ' ' -f 4  | tr -d '\n') &&
+          echo   sha256sum_blenderbim_py310_win_zip: $sha256sum_blenderbim_py310_win_zip &&
+          python3 choco/blenderbim/fill_dynamic_parameters.py &&
+          echo __build choco with mono &&
+          wget "https://github.com/chocolatey/choco/archive/refs/tags/$choco_version.tar.gz" --quiet &&
+          tar -xzf "$choco_version.tar.gz" &&
+          cd choco-$choco_version &&
+          chmod +x build.sh zip.sh &&
+          ./build.sh &&
+          cp -r build_output/chocolatey /opt/chocolatey &&
+          cd /home/runner/work/IfcOpenShell/IfcOpenShell/choco/blenderbim/ &&
+          echo __choco pack &&
+          mono /opt/chocolatey/choco.exe --version &&
+          mono /opt/chocolatey/choco.exe pack --allow-unofficial &&
+          echo __choco set apiKey &&
+          mono /opt/chocolatey/choco.exe setapikey --key="$CHOCO_TOKEN" --source="https://push.chocolatey.org/" --allow-unofficial # &&
+          echo __choco push &&
+          mono /opt/chocolatey/choco.exe push --source="https://push.chocolatey.org/" --key="$CHOCO_TOKEN" --allow-unofficial --verbose
+
+      - name: Inform user about not packaging
+        if: ${{steps.do_choco.outputs.choco_release}} != 'do_choco_release'
+        run: |
+          echo "no releases found today ${{ env.DATE }}, therefore choco packaging is skipped."
+
@@ -3,8 +3,18 @@ name: Publish-blenderbim-multiplatform
 on:
  push:
    paths:
-      - 'src/blenderbim/**'
      - '.github/workflows/ci-blenderbim-matrix.yml'
+      - 'src/blenderbim/**'
+      - 'src/ifcopenshell-python/ifcopenshell/**'
+      - 'src/bcf/src/bcf/**'
+      - 'src/ifcclash/ifcclash/**'
+      - 'src/ifccobie/**'
+      - 'src/ifcdiff/**'
+      - 'src/ifccsv/**'
+      - 'src/ifcpatch/ifcpatch/**'
+      - 'src/ifc4d/ifc4d/**'
+      - 'src/ifc5d/ifc5d/**'
+      - 'src/ifccityjson/**'
    branches:
      - v0.7.0

@@ -0,0 +1,64 @@
+name: ci-ifcopenshell-conda-daily
+
+on:
+  workflow_run:
+    workflows: ["ci"]
+    types:
+      - completed
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+      - name: Set env
+        run: echo ok go
+
+  test:
+    name: ${{ matrix.platform.distver }}-${{ matrix.pyver.name }}
+    needs: activate
+    runs-on: ${{ matrix.platform.distver }}
+    defaults:
+      run:
+        shell: bash -l {0}
+    strategy:
+      fail-fast: false
+      matrix:
+        pyver: [
+          { name: py39, distver: '3.9' },
+          { name: py310, distver: '3.10'}
+        ]
+        platform: [
+          { name: Windows, distver: windows-2022, upload: 'true' },
+          { name: Windows, distver: windows-2019, upload: 'false' },
+          { name: Linux, distver: ubuntu-20.04,  upload: 'false' },
+          { name: Linux, distver: ubuntu-18.04,  upload: 'true' },
+          { name: macOS, distver: macos-11, upload: 'true' },
+          { name: macOS, distver: macos-10.15, upload: 'false' }
+        ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Download MacOSX SDK
+        if: ${{ matrix.platform.name == 'macOS' }}
+        run: |
+          curl -o MacOSX10.13.sdk.tar.xz -L https://github.com/phracker/MacOSX-SDKs/releases/download/11.3/MacOSX10.13.sdk.tar.xz && \
+          tar xf MacOSX10.13.sdk.tar.xz && \
+          sudo mv -v MacOSX10.13.sdk /opt/ && \
+          ls /opt/
+      - uses: seanmiddleditch/gha-setup-ninja@master
+      - uses: conda-incubator/setup-miniconda@v2  # https://github.com/conda-incubator/setup-miniconda
+        with:
+          activate-environment: conda-build
+          python-version: ${{ matrix.pyver.distver }}
+          environment-file: conda/environment.yml
+      - name: build, test and upload ifcopenshell
+        if: ${{ matrix.platform.upload == 'true' }}
+        run: |
+          conda-build . --python ${{ matrix.pyver.distver }} -c conda-forge --token ${{ secrets.ANACONDA_TOKEN }} --user ifcopenshell --no-remove-work-dir
+      - name: build & test ifcopenshell
+        if: ${{ matrix.platform.upload == 'false' }}
+        run: |
+          conda-build . --python ${{ matrix.pyver.distver }} -c conda-forge --no-remove-work-dir
@@ -0,0 +1,67 @@
+name: Publish-ifcopenshell-multiplatform
+
+on:
+  push:
+    paths:
+      - '.github/workflows/ci-ifcopenshell-pypi.yml'
+      - 'src/ifcopenshell-python/ifcopenshell/**'
+    branches:
+      - v0.7.0
+
+env:
+  major: 0
+  minor: 0
+  name: ifcopenshell
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+    - name: Set env
+      run: echo ok go
+
+  build:
+    needs: activate
+    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        pyver: [py36, py37, py38, py39, py310]
+        config:
+          - {
+            name: "Windows Build",
+            short_name: win,
+          }
+          - {
+            name: "Linux Build",
+            short_name: linux
+          }
+          - {
+            name: "MacOS Build",
+            short_name: macos
+          }
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
+        with:
+          python-version: '3.7.7' # Version range or exact version of a Python version to use, using SemVer's version range syntax
+          architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
+      - run: echo ${{ env.DATE }}
+      - name: Get current date
+        id: date
+        run: echo "::set-output name=date::$(date +'%y%m%d')"
+      - name: Compile
+        run: |
+          pip install build
+          cp -r src/ifcopenshell-python src/ifcopenshell-python_${{ matrix.config.short_name }}_${{ matrix.pyver }} &&
+          cd src/ifcopenshell-python_${{ matrix.config.short_name }}_${{ matrix.pyver }} &&
+          make dist PLATFORM=${{ matrix.config.short_name }} PYVERSION=${{ matrix.pyver }}
+      - name: Publish a Python distribution to PyPI
+        uses: ortega2247/pypi-upload-action@master
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          packages_dir: src/ifcopenshell-python_${{ matrix.config.short_name }}_${{ matrix.pyver }}/dist
@@ -0,0 +1,95 @@
+name: ci_py_only
+
+on:
+  push:
+    paths:
+      - 'src/**'
+      - 'test/**'
+      - 'conda/**'
+      - 'cmake/**'
+      - '.github/workflows/ci_py_only.yml'
+  pull_request:
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell' &&
+      !contains(github.event.head_commit.message, 'skip ci')
+    steps:
+      - run: echo ok go
+
+  build:
+    runs-on: ubuntu-20.04
+    needs: activate
+    steps:
+      - uses: actions/checkout@v2
+        with:
+            submodules: recursive
+      - name: Install C++ dependencies
+        run: |
+          sudo apt update
+          sudo apt-get install --no-install-recommends \
+          git cmake gcc g++ \
+          libboost-date-time-dev \
+          libboost-filesystem-dev \
+          libboost-iostreams-dev \
+          libboost-program-options-dev \
+          libboost-regex-dev \
+          libboost-system-dev \
+          libboost-thread-dev \
+          python3-all-dev python3-pip \
+          swig libpcre3-dev libxml2-dev \
+          libtbb-dev nlohmann-json3-dev \
+          libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+          libhdf5-dev libcgal-dev
+          
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1
+
+      - name: Build ifcopenshell
+        run: |
+          mkdir build && cd build
+          cmake \
+               -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+               -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+               -DCMAKE_BUILD_TYPE=Release \
+               -DCMAKE_PREFIX_PATH=/usr \
+               -DCMAKE_SYSTEM_PREFIX_PATH=/usr \
+               -DOCC_INCLUDE_DIR=/usr/include/opencascade \
+               -DOCC_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 \
+               -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
+               -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
+               -DCOLLADA_SUPPORT=Off \
+               "-DSCHEMA_VERSIONS=2x3;4" \
+               -DBUILD_CONVERT=Off \
+               -DGLTF_SUPPORT=On \
+               -DJSON_INCLUDE_DIR=/usr/include \
+               -DCGAL_INCLUDE_DIR=/usr/include \
+               -DGMP_INCLUDE_DIR=/usr/include \
+               -DMPFR_INCLUDE_DIR=/usr/include \
+               -DGMP_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DMPFR_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+               -DHDF5_INCLUDE_DIR=/usr/include/hdf5/serial \
+             ../cmake
+          sudo make -j $(nproc)
+          sudo make install
+
+      - name: Install Python dependencies
+        run: |
+          sudo /usr/bin/python -m pip install -U pip
+          sudo /usr/bin/python -m pip install xmlschema numpy lxml
+          sudo /usr/bin/python -m pip install src/bcf
+          sudo /usr/bin/python -m pip install pytest
+          sudo /usr/bin/python -m pip install isodate
+          sudo /usr/bin/python -m pip install lark
+          sudo /usr/bin/python -m pip install networkx
+
+      - name: Test
+        run: |
+          cd test
+          sudo /usr/bin/python tests.py
+          cd ../src/ifcopenshell-python
+          mv ifcopenshell ifcopenshell-local # Force testing on installed module
+          make test
@@ -3,8 +3,19 @@ name: ci
 on:
  push:
    paths:
-      - 'src/**'
-      - 'test/**'
+      - 'src/ifcblender/**'
+      - 'src/ifcconvert/**'
+      - 'src/ifcgeom/**'
+      - 'src/ifcgeom_schema_agnostic/**'
+      - 'src/ifcgeomserver/**'
+      - 'src/ifcjni/**'
+      - 'src/ifcmax/**'
+      - 'src/ifcopenshell-python/**'
+      - '!src/ifcopenshell-python/docs/**'
+      - 'src/ifcparse/**'
+      - 'src/ifcwrap/**'
+      - 'src/qtviewer/**'
+      - 'src/serializers/**'
      - 'conda/**'
      - 'cmake/**'
      - '.github/workflows/ci.yml'
@@ -62,7 +73,7 @@ jobs:
               -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
               -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
               -DCOLLADA_SUPPORT=Off \
-               "-DSCHEMA_VERSIONS=2x3;4" \
+               "-DSCHEMA_VERSIONS=2x3;4;4x3" \
               -DGLTF_SUPPORT=On \
               -DJSON_INCLUDE_DIR=/usr/include \
               -DCGAL_INCLUDE_DIR=/usr/include \
@@ -83,6 +94,7 @@ jobs:
          sudo /usr/bin/python -m pip install pytest
          sudo /usr/bin/python -m pip install isodate
          sudo /usr/bin/python -m pip install lark
+          sudo /usr/bin/python -m pip install networkx

      - name: Test
        run: |
@@ -18,14 +18,24 @@ jobs:
      - name: Checkout
        uses: actions/checkout@v2
        with:
-          lfs: true
-      - 
-        name: Update ubuntu
+          submodules: recursive
+      - name: Install C++ dependencies
        run: |
          sudo apt update
-          sudo apt-get install git cmake gcc g++ libboost1.67-all-dev python3-all-dev swig libpcre3-dev libxml2-dev
-          sudo apt-get install libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
-          libhdf5-dev
+          sudo apt-get install --no-install-recommends \
+          git cmake gcc g++ \
+          libboost-date-time-dev \
+          libboost-filesystem-dev \
+          libboost-iostreams-dev \
+          libboost-program-options-dev \
+          libboost-regex-dev \
+          libboost-system-dev \
+          libboost-thread-dev \
+          python3-all-dev python3-pip \
+          swig libpcre3-dev libxml2-dev \
+          libtbb-dev nlohmann-json3-dev \
+          libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+          libhdf5-dev libcgal-dev opencollada-dev
          
      - name: Build
        env:
@@ -44,10 +54,18 @@ jobs:
           -DPYTHON_EXECUTABLE:FILEPATH=/usr/bin/python3 \
           -DPYTHON_INCLUDE_DIR:PATH=/usr/include/python3.8 \
           -DPYTHON_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libpython3.8.so \
-           -DCOLLADA_SUPPORT=Off \
           -DLIBXML2_INCLUDE_DIR=/usr/include/libxml2 \
           -DLIBXML2_LIBRARIES=/usr/lib/x86_64-linux-gnu/libxml2.so \
+           -DGLTF_SUPPORT=On \
+           -DJSON_INCLUDE_DIR=/usr/include \
+           -DCGAL_INCLUDE_DIR=/usr/include \
+           -DGMP_INCLUDE_DIR=/usr/include \
+           -DMPFR_INCLUDE_DIR=/usr/include \
+           -DGMP_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
+           -DMPFR_LIBRARY_DIR=/usr/lib/x86_64-linux-gnu \
           -DHDF5_INCLUDE_DIR=/usr/include/hdf5/serial \
+           -DOPENCOLLADA_INCLUDE_DIR=/usr/include/opencollada \
+           -DOPENCOLLADA_LIBRARY_DIR=/usr/lib/opencollada/ \
           ../cmake
          make -j $(nproc)
          make install
@@ -5,6 +5,15 @@
 /_installed-vs*-x*/
 /build/

+# output directories
+/cmake/out/
+/docs/out/
+/src/examples/out/
+/src/ifcmax/out/
+/src/ifcwrap/out/
+/src/qtviewer/out/
+
+
 /win/BuildDepsCache*.txt
 # IfcExpressParser residue
 /src/ifcexpressparser/express_parser.py
@@ -13,6 +22,7 @@ __pycache__
 *.py.bak
 # Visual Studio Code files
 .vscode
+.vs
 # PyCharm files
 .idea

@@ -57,3 +67,9 @@ htmlcov

 # Blender
 *.blend1
+
+# Sphinx
+_build/
+
+# IDS Docs
+src/ifcopenshell-python/test/build
@@ -8,9 +8,6 @@
 [submodule "src/svgfill"]
 	path = src/svgfill
 	url = https://github.com/IfcOpenShell/svgfill
-[submodule "src/ifcopenshell-python/ifcopenshell/Sample-BIM-Files"]
-	path = src/ifcopenshell-python/ifcopenshell/Sample-BIM-Files
-	url = https://github.com/atomczak/Sample-BIM-Files
 [submodule "src/ifcopenshell-python/test/Sample-BIM-Files"]
 	path = src/ifcopenshell-python/test/Sample-BIM-Files
-	url = https://github.com/atomczak/Sample-BIM-Files
+	url = https://github.com/IfcOpenShell/ids-test-files
@@ -23,9 +23,11 @@ RUN echo "deb http://archive.ubuntu.com/ubuntu focal-proposed main restricted" |
    echo "deb http://archive.ubuntu.com/ubuntu focal-proposed multiverse" |  tee -a /etc/apt/sources.list; \
    apt-get -qq update; \
    apt-get -y install tzdata dos2unix rsync; \
-    apt-get -y install python3 libxml2 liboce-foundation11 liboce-modeling11 liboce-ocaf11 liboce-visualization11 \
-                     liboce-ocaf-lite11 libpython3.8 libboost-system1.67.0 libboost-program-options1.67.0 \
-                    libboost-regex1.67.0 libboost-thread1.67.0 libboost-date-time1.67.0; \
+    apt-get -y install python3 libxml2 libpython3.8 \
+                    libboost-all-dev \
+                    libocct-foundation-dev libocct-modeling-algorithms-dev libocct-modeling-data-dev \
+                    libocct-ocaf-dev libocct-visualization-dev libocct-data-exchange-dev \
+                    libhdf5-serial-dev ; \
    rm -rf /var/lib/apt/lists/* ; 

 COPY . /home/IfcOpenShell/
@@ -9,12 +9,20 @@ For more information, see
 * [http://ifcopenshell.org](http://ifcopenshell.org)  
 * [http://academy.ifcopenshell.org](http://academy.ifcopenshell.org)

-[![Build Status](https://travis-ci.org/IfcOpenShell/IfcOpenShell.svg?branch=v0.6.0)](https://travis-ci.org/IfcOpenShell/IfcOpenShell)
+| Service                                         | Status                                                                                                                                       |
+| ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| Anaconda Daily Build                            | [![Anaconda-Server Badge](https://img.shields.io/conda/vn/ifcopenshell/ifcopenshell)](https://anaconda.org/ifcopenshell/ifcopenshell)        |
+| Anaconda v0.7.0 Stable                          | [![Anaconda-Server Badge](https://img.shields.io/conda/vn/conda-forge/ifcopenshell)](https://anaconda.org/conda-forge/ifcopenshell)          |
+| PyPi Daily Build                                | [![PyPi Badge](https://img.shields.io/pypi/v/ifcopenshell-python)](https://pypi.org/project/ifcopenshell-python/)                            |
+| ArchLinux AUR Package                           | [![AUR Badge](https://img.shields.io/aur/version/ifcopenshell-git)](https://aur.archlinux.org/packages/ifcopenshell-git)                     |
+| BlenderBIM Add-on Chocolatey (under moderation) | [![Chocolatey Badge](https://img.shields.io/chocolatey/v/blenderbim-nightly)](https://community.chocolatey.org/packages/blenderbim-nightly/) |
+| Sponsor development on OpenCollective           | [![Financial Contributors](https://opencollective.com/opensourcebim/tiers/badge.svg)](https://opencollective.com/opensourcebim/)             |
+| Docker hub                                      | [![Docker Pulls](https://img.shields.io/docker/pulls/aecgeeks/ifcopenshell)](https://hub.docker.com/r/aecgeeks/ifcopenshell)                 |

 Prerequisites
 -------------
 * Git
-* CMake (2.6 or newer)
+* CMake (3.1.3 or newer)
 * Windows: [Visual Studio] 2008 to 2019 (2022 not yet supported by dependency CMake) with C++ toolset (or [Visual C++ Build Tools]) or [MSYS2] + MinGW
 * *nix: GCC 4.7 or newer, or Clang (any version)

@@ -23,7 +31,7 @@ Dependencies
 * [Boost](http://www.boost.org/)
 * [Open Cascade](https://dev.opencascade.org/) - *optional*, but required for building IfcGeom
  ([official](https://dev.opencascade.org/release), "OCCT", or [community edition](https://github.com/tpaviot/oce), "OCE")  
-  For converting IFC representation items into BRep solids and tesselated meshes
+  For converting IFC representation items into BRep solids and tessellated meshes
 * [OpenCOLLADA](https://github.com/khronosGroup/OpenCOLLADA/) - *optional*  
  For IfcConvert to be able to write tessellated Collada (.dae) files
 * [SWIG](http://www.swig.org/) and [Python](https://www.python.org/) - *optional*  
@@ -87,7 +95,7 @@ The following instructions are for Ubuntu, modify as required for other operatin
 can be experimented with and studied for pointers for other operating systems, but note that this script is not currently
 meant to be used for a typical IfcOpenShell workspace setup.

-Note 1: It is recommeded to use OCCT for IfcOpenShell. You could use OCE as well, but sometimes it may lag behind OCCT and 
+Note 1: It is recommended to use OCCT for IfcOpenShell. You could use OCE as well, but sometimes it may lag behind OCCT and 
 therefore not compile with the latest IfcOpenShell.

 Note 2: where `make -j` is written, add a number roughly equal to the amount of CPU cores + 1.
@@ -161,28 +169,40 @@ If all worked out correctly you can now use IfcOpenShell. See the examples below
 **1)** Install all dependencies using [Homebrew](https://brew.sh/)

 ```{shell}
-$ brew install boost swig cmake ftgl cgal gmp libaec opencascade
+$ brew install boost cmake python3 cgal ftgl gmp libaec opencascade swig hdf5 zlib
+# homebrew automatically links most libraries, except some keg-only ones
+$ brew link zlib --force
 ```

 **2)** Clone the git repo and its submodules
 ```{shell}
 $ git clone --recurse-submodules https://github.com/IfcOpenShell/IfcOpenShell.git 
 ```
-**3)** Build IfcOpenShell with flags for Homebrew dependencies (```/usr/local/```)
+**3)** Build IfcOpenShell with flags for Homebrew dependencies: (``/usr/local/``) for Intel machines with x84_64 architecture,
+(``/opt/homebrew/``) for Apple Silicon processors with arm64 architecture.
 ```{shell}
 $ cd /path/to/IfcOpenShell
 $ mkdir build && cd build
-$ cmake ../cmake -DOCC_LIBRARY_DIR=/usr/local/lib/ \
-      -DOCC_INCLUDE_DIR=/usr/local/include/opencascade/ \
-      -DCOLLADA_SUPPORT=0 \
-      -DCGAL_INCLUDE_DIR=/usr/local/include/ \
-      -DGMP_LIBRARY_DIR=/usr/local/lib/ \
-      -DMPFR_LIBRARY_DIR=/usr/local/lib/
-      
-$ make -j -lboost_options
+# set library flags
+$ export LDFLAGS="$LDFLAGS -Wl,-flat_namespace,-undefined,suppress"
+$ cmake ../cmake
+    -DPYTHON_EXECUTABLE=/opt/homebrew/bin/python3.10 \
+    -DPYTHON_LIBRARY=/opt/homebrew/opt/python@3.10/Frameworks/Python.framework/Versions/3.10/lib/libpython3.10.dylib \
+    -DPYTHON_INCLUDE_DIR=/opt/homebrew/opt/python@3.10/Frameworks/Python.framework/Versions/3.10/include/python3.10/ \
+    -DOCC_LIBRARY_DIR=/opt/homebrew/lib/ \
+    -DOCC_INCLUDE_DIR=/opt/homebrew/include/opencascade/ \
+    -DCGAL_INCLUDE_DIR=/opt/homebrew/include/ \
+    -DGMP_LIBRARY_DIR=/opt/homebrew/lib/ \
+    -DMPFR_LIBRARY_DIR=/opt/homebrew/lib/ \
+    -DHDF5_LIBRARY_DIR=/opt/homebrew/lib/ \
+    -DHDF5_INCLUDE_DIR=/opt/homebrew/include/ \
+    -DCOLLADA_SUPPORT=0
+# `sysctl -n hw.ncpu` returns the number of cpu cores on macOS
+$ make -j$(sysctl -n hw.ncpu)
 ```

-Note: Make sure to compile using XCode, rather than a ```brew``` installed C/C++ compiler.
+Note: Make sure to compile using the XCode provided Apple Clang compiler, installed with `xcode-select --install
+`, rather than a ```brew``` installed C/C++ compiler.

 Installing IfcOpenShell with Conda
 ----------------------------------
@@ -271,35 +291,35 @@ Also available are a series of utilities that are based on or related to IfcOpen

 Those marked with an asterisk are part of IfcOpenShell.

-Name | License
--- | ---
-bcf | LGPL-3.0-or-later
-blenderbim | GPL-3.0-or-later
-bsdd | LGPL-3.0-or-later
-ifc2ca | LGPL-3.0-or-later
-ifc4d | LGPL-3.0-or-later
-ifc5d | LGPL-3.0-or-later
-ifcbimtester | LGPL-3.0-or-later
-ifcblender | LGPL-3.0-or-later\*
-ifccityjson | LGPL-3.0-or-later
-ifcclash | LGPL-3.0-or-later
-ifccobie | LGPL-3.0-or-later
-ifcconvert | LGPL-3.0-or-later\*
-ifccsv | LGPL-3.0-or-later
-ifcdiff | LGPL-3.0-or-later
-ifcfm | LGPL-3.0-or-later
-ifcgeom | LGPL-3.0-or-later\*
-ifcgeom\_schema\_agnostic | LGPL-3.0-or-later\*
-ifcgeomserver | LGPL-3.0-or-later\*
-ifcjni | LGPL-3.0-or-later\*
-ifcmax | LGPL-3.0-or-later\*
-ifcopenshell-python | LGPL-3.0-or-later\*
-ifcparse | LGPL-3.0-or-later\*
-ifcpatch | LGPL-3.0-or-later
-ifcsverchok | GPL-3.0-or-later
-ifcwrap | LGPL-3.0-or-later\*
-qtviewer | LGPL-3.0-or-later\*
-serializers | LGPL-3.0-or-later\*
+| Name                      | License             |
+| ------------------------- | ------------------- |
+| bcf                       | LGPL-3.0-or-later   |
+| blenderbim                | GPL-3.0-or-later    |
+| bsdd                      | LGPL-3.0-or-later   |
+| ifc2ca                    | LGPL-3.0-or-later   |
+| ifc4d                     | LGPL-3.0-or-later   |
+| ifc5d                     | LGPL-3.0-or-later   |
+| ifcbimtester              | LGPL-3.0-or-later   |
+| ifcblender                | LGPL-3.0-or-later\* |
+| ifccityjson               | LGPL-3.0-or-later   |
+| ifcclash                  | LGPL-3.0-or-later   |
+| ifccobie                  | LGPL-3.0-or-later   |
+| ifcconvert                | LGPL-3.0-or-later\* |
+| ifccsv                    | LGPL-3.0-or-later   |
+| ifcdiff                   | LGPL-3.0-or-later   |
+| ifcfm                     | LGPL-3.0-or-later   |
+| ifcgeom                   | LGPL-3.0-or-later\* |
+| ifcgeom\_schema\_agnostic | LGPL-3.0-or-later\* |
+| ifcgeomserver             | LGPL-3.0-or-later\* |
+| ifcjni                    | LGPL-3.0-or-later\* |
+| ifcmax                    | LGPL-3.0-or-later\* |
+| ifcopenshell-python       | LGPL-3.0-or-later\* |
+| ifcparse                  | LGPL-3.0-or-later\* |
+| ifcpatch                  | LGPL-3.0-or-later   |
+| ifcsverchok               | GPL-3.0-or-later    |
+| ifcwrap                   | LGPL-3.0-or-later\* |
+| qtviewer                  | LGPL-3.0-or-later\* |
+| serializers               | LGPL-3.0-or-later\* |

 [LGPL]: https://github.com/IfcOpenShell/IfcOpenShell/tree/master/COPYING.LESSER "LGPL-3.0-or-later"
 [IFC]: https://technical.buildingsmart.org/standards/ifc/ "IFC"
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Do not remove this test for UTF-8: if “Ω” doesn’t appear as greek uppercase omega letter enclosed in quotation marks, you should use an editor that supports UTF-8, not this one. -->
+<package xmlns="http://schemas.microsoft.com/packaging/2015/06/nuspec.xsd">
+  <metadata>
+    <id>blenderbim-nightly</id>
+    <version>blenderbim_build_version</version>
+    <packageSourceUrl>https://github.com/IfcOpenShell/IfcOpenShell</packageSourceUrl>
+    <owners>fbpyr</owners>
+    <!-- == SOFTWARE SPECIFIC SECTION == -->
+    <title>BlenderBIM install nightly</title>
+    <authors>Dion Moult and many more, see: https://github.com/IfcOpenShell/IfcOpenShell/graphs/contributors</authors>
+    <projectUrl>https://github.com/IfcOpenShell/IfcOpenShell</projectUrl>
+    <iconUrl>https://rawcdn.githack.com/fbpyr/IfcOpenShell/9662598ad4a7e4b6cd8980e430d07263835d0eda/choco/blenderbim/blenderbim.png</iconUrl>
+    <!-- <copyright>Year Software Vendor</copyright> -->
+    <licenseUrl>https://github.com/IfcOpenShell/IfcOpenShell/blob/v0.7.0/COPYING</licenseUrl>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <projectSourceUrl>https://github.com/IfcOpenShell/IfcOpenShell</projectSourceUrl>
+    <docsUrl>https://blenderbim.org/docs/</docsUrl>
+    <!--<mailingListUrl></mailingListUrl>-->
+    <bugTrackerUrl>https://github.com/IfcOpenShell/IfcOpenShell/issues</bugTrackerUrl>
+    <tags>blender bim blenderbim python opensource foss</tags>
+    <summary>opensource bim</summary>
+    <description>opensource bim addon for blender</description>
+    <!-- <releaseNotes>__REPLACE_OR_REMOVE__MarkDown_Okay</releaseNotes> -->
+
+    <dependencies>
+      <dependency id="blender" version="latest_blender_version_maj_min_pat" />
+      <dependency id="7zip"    version="22.1"/>
+    </dependencies>
+  </metadata>
+  <files>
+    <file src="tools\**" target="tools" />
+  </files>
+</package>
@@ -0,0 +1,79 @@
+import datetime
+import re
+import sys
+from urllib import request
+
+
+def request_repo_info(url: str):
+    req  = request.Request(url)
+    resp = request.urlopen(req)
+    if not resp.status == 200:
+        print(f"[ERROR] could not contact server: {url}")
+        quit(1)
+    return resp
+
+
+if sys.argv[1] == "--do_choco_release?":
+    now = datetime.datetime.now()
+    blenderbim_date = now.strftime("%y%m%d")
+    url = "https://github.com/IfcOpenShell/IfcOpenShell/releases/latest"
+    resp = request_repo_info(url)
+    if blenderbim_date in resp.url:
+        print("do_choco_release", end="")
+
+
+elif sys.argv[1] == "--latest_blender_release_maj_min_pat?":
+    re_blender_version_min_maj_pat = r"Latest Version.+<span>Blender (\d+\.\d+\.\d+)</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj_pat, html_txt)
+    if found:
+        print(found[0], end="")
+
+
+elif sys.argv[1] == "--latest_blender_release_maj_min?":
+    re_blender_version_min_maj = r"Latest Version.+<span>Blender (\d+\.\d+)\..+</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj, html_txt)
+    if found:
+        print(found[0], end="")
+
+
+elif sys.argv[1] == "--latest_blender_python_version_maj_min?":
+    # get latest blender version first
+    re_blender_version_min_maj_pat = r"Latest Version.+<span>Blender (\d+\.\d+\.\d+)</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj_pat, html_txt)
+    if found:
+        latest_blender_version_tag = f"v{found[0]}"
+        re_blender_python_version_maj_min = r"SET\(PYTHON_VERSION (\d+.\d+) "
+        url = f"https://raw.githubusercontent.com/blender/blender/{latest_blender_version_tag}/build_files/cmake/Modules/FindPythonLibsUnix.cmake"
+        resp = request_repo_info(url)
+        html_txt = str(resp.read())
+        found = re.findall(re_blender_python_version_maj_min, html_txt)
+        if found:
+            print(found[0], end="")
+
+
+elif sys.argv[1] == "--pyver?":
+    # get latest blender version first
+    re_blender_version_min_maj_pat = r"Latest Version.+<span>Blender (\d+\.\d+\.\d+)</span>"
+    url = "https://community.chocolatey.org/packages/blender"
+    resp = request_repo_info(url)
+    html_txt = str(resp.read())
+    found = re.findall(re_blender_version_min_maj_pat, html_txt)
+    if found:
+        latest_blender_version_tag = f"v{found[0]}"
+        re_blender_python_version_maj_min = r"SET\(PYTHON_VERSION (\d+.\d+) "
+        url = f"https://raw.githubusercontent.com/blender/blender/{latest_blender_version_tag}/build_files/cmake/Modules/FindPythonLibsUnix.cmake"
+        resp = request_repo_info(url)
+        html_txt = str(resp.read())
+        found = re.findall(re_blender_python_version_maj_min, html_txt)
+        if found:
+            print(f"py{found[0].replace('.', '')}", end="")
+
@@ -0,0 +1,49 @@
+import os
+from pathlib import Path
+
+
+print("[INFO] inserting dynamic chocolatey package parameters")
+HERE_DIR = Path(__file__).parent.absolute()
+# print(f"[INFO] HERE_DIR: {HERE_DIR}")
+
+topics = {
+    "spec": {
+        "path": HERE_DIR / "blenderbim.nuspec",
+        "env_vars": {
+            "latest_blender_version_maj_min_pat",
+            "blenderbim_build_version",
+        },
+    },
+    "install": {
+        "path": HERE_DIR / "tools" / "chocolateyinstall.ps1",
+        "env_vars": {
+            "url_blenderbim_py310_win_zip",
+            "sha256sum_blenderbim_py310_win_zip",
+            "latest_blender_version_maj_min",
+        },
+    },
+    "uninstall": {
+        "path": HERE_DIR / "tools" / "chocolateyuninstall.ps1",
+        "env_vars": {
+            "latest_blender_version_maj_min",
+        },
+    },
+}
+
+for topic, info in topics.items():
+    print(f"[INFO] {topic}:")
+    for env_var_name in info["env_vars"]:
+        print(f"[INFO] {env_var_name} exists?: {os.environ[env_var_name]}")
+
+    with open(info["path"], encoding="utf-8") as txt:
+        content = txt.read()
+
+    for env_var_name in info["env_vars"]:
+        # print(f"[INFO] replace: {env_var_name}")
+        content = content.replace(env_var_name, os.environ[env_var_name])
+
+    with open(info["path"], "w", encoding="utf-8") as txt:
+        txt.write(content)
+        print(f"[INFO] written: {info['path']}")
+
+print("[INFO] inserting dynamic chocolatey package parameters successful")
@@ -0,0 +1,11 @@
+$processName      = "blender"
+$blenderIsRunning = Get-Process -Name $processName -ErrorAction SilentlyContinue
+
+if($blenderIsRunning -eq $null) {
+    echo "Blender is not running ready for next action."
+}
+else {
+    Write-Warning "$processName is still running - installer cannot safely proceed to next action."
+    Write-Warning "Please retry after closing all running blender applications."
+    exit 1
+}
@@ -0,0 +1,29 @@
+$ErrorActionPreference = 'Stop'
+
+$url64          = 'url_blenderbim_py310_win_zip'
+$checksum64     = 'sha256sum_blenderbim_py310_win_zip'
+$checksumType64 = 'sha256'
+
+$appDataUserDir  = [System.Environment]::GetEnvironmentVariable('appdata')
+$unzipTargetDir  = "$appDataUserDir\Blender Foundation\Blender\latest_blender_version_maj_min\scripts\addons"
+
+$chocoBaseDir    = [System.Environment]::GetEnvironmentVariable('ChocolateyInstall')
+$addonEnable     = "$chocoBaseDir\lib\blenderbim\tools\enable_blenderbim_addon.py"
+
+$programFilesDir = [System.Environment]::GetEnvironmentVariable('ProgramFiles')
+$blenderExePath  = "$env:ProgramFiles\Blender Foundation\Blender latest_blender_version_maj_min\blender.exe"
+
+$processName      = "blender"
+$blenderIsRunning = Get-Process -Name $processName -ErrorAction SilentlyContinue
+
+
+if($blenderIsRunning -eq $null) {
+    echo "attempting to install blenderbim."
+    Install-ChocolateyZipPackage -PackageName $env:ChocolateyPackageName -Url64 $url64 -Checksum64 $checksum64 -checksumType $checksumType64 -UnzipLocation $unzipTargetDir
+    Start-Process -FilePath  $blenderExePath -ArgumentList "-b", "-y", "--python", "$addonEnable"
+}
+else {
+    Write-Warning "$processName is still running - blenderbim cannot be safely installed."
+    Write-Warning "Please retry after closing all running blender applications."
+    exit 1
+}
@@ -0,0 +1,22 @@
+$appDataUserDir = [System.Environment]::GetEnvironmentVariable('appdata')
+$unzippedDir = "$appDataUserDir\Blender Foundation\Blender\latest_blender_version_maj_min\scripts\addons\blenderbim"
+
+$chocoBaseDir    = [System.Environment]::GetEnvironmentVariable('ChocolateyInstall')
+$addonDisable     = "$chocoBaseDir\lib\blenderbim\tools\disable_blenderbim_addon.py"
+
+$programFilesDir = [System.Environment]::GetEnvironmentVariable('ProgramFiles')
+$blenderExePath  = "$env:ProgramFiles\Blender Foundation\Blender latest_blender_version_maj_min\blender.exe"
+
+$processName      = "blender"
+$blenderIsRunning = Get-Process -Name $processName -ErrorAction SilentlyContinue
+
+if($blenderIsRunning -eq $null) {
+    echo "attempting to uninstall blenderbim."
+    Start-Process -FilePath $blenderExePath -ArgumentList "-b", "-y", "--python", "$addonDisable"
+    Remove-Item -LiteralPath $unzippedDir -Force -Recurse
+}
+else {
+    Write-Warning "$processName is still running - blenderbim cannot be safely uninstalled."
+    Write-Warning "Please retry after closing all running blender applications."
+    exit 1
+}
@@ -0,0 +1,8 @@
+import bpy
+
+
+bpy.ops.preferences.addon_disable(module='blenderbim')
+bpy.ops.wm.save_userpref()
+
+print("disabled blenderbim addon successfully.")
+
@@ -0,0 +1,8 @@
+import bpy
+
+
+bpy.ops.preferences.addon_enable(module='blenderbim')
+bpy.ops.wm.save_userpref()
+
+print("enabled blenderbim addon successfully.")
+
@@ -38,7 +38,7 @@ MESSAGE(STATUS "Autodesk 3ds Max SDK found at ${max_sdk}")
 set(HAS_MAX TRUE)
 endif()
 endforeach()
-
+OPTION(MINIMAL_BUILD "The build is to make a minimal version of IFC converter from OCCT into IFC." OFF)
 OPTION(COLLADA_SUPPORT "Build IfcConvert with COLLADA support (requires OpenCOLLADA)." ON)
 OPTION(IFCXML_SUPPORT "Build IfcParse with ifcXML support (requires libxml2)." ON)
 OPTION(ENABLE_BUILD_OPTIMIZATIONS "Enable certain compiler and linker optimizations on RelWithDebInfo and Release builds." OFF)
@@ -53,6 +53,7 @@ OPTION(HDF5_SUPPORT "Enable HDF5 support (requires HDF5, zlib)" ON)
 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(BUILD_SHARED_LIBS "Build IfcParse and IfcGeom as shared libs (SO/DLL)." OFF)
+OPTION(MSVC_PARALLEL_BUILD "Multi-threaded compilation in Microsoft Visual Studio (/MP)" OFF)
 if (${HAS_MAX})
 OPTION(BUILD_IFCMAX "Build IfcMax, a 3ds Max plug-in, Windows-only." OFF)
 endif()
@@ -66,8 +67,12 @@ IF(NOT CMAKE_BUILD_TYPE)
 	SET(CMAKE_BUILD_TYPE "Release")
 ENDIF()

-# TODO QtViewer is deprecated ATM as it uses the 0.4 API
-# OPTION(BUILD_QTVIEWER "Build IfcOpenShell Qt GUI Viewer (requires Qt 4 framework)." OFF)
+if(MSVC AND MSVC_PARALLEL_BUILD)
+	add_definitions("/MP")
+endif()
+
+# QtViewer requires Qt5
+OPTION(BUILD_QTVIEWER "Build IfcOpenShell Qt GUI Viewer" OFF)
 include(GNUInstallDirs)
 if((BUILD_CONVERT OR BUILD_GEOMSERVER OR BUILD_IFCPYTHON) AND (NOT BUILD_IFCGEOM))
    message(STATUS "'IfcGeom' is required with current outputs")
@@ -121,6 +126,7 @@ ENDMACRO()

 UNIFY_ENVVARS_AND_CACHE(OCC_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(OCC_LIBRARY_DIR)
+if (NOT MINIMAL_BUILD)
 UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(OPENCOLLADA_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(LIBXML2_INCLUDE_DIR)
@@ -130,17 +136,20 @@ UNIFY_ENVVARS_AND_CACHE(PYTHON_EXECUTABLE)
 UNIFY_ENVVARS_AND_CACHE(HDF5_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(HDF5_LIBRARIES)
+endif()
 UNIFY_ENVVARS_AND_CACHE(BOOST_ROOT)
 UNIFY_ENVVARS_AND_CACHE(BOOST_LIBRARYDIR)

+if (NOT MINIMAL_BUILD)
 UNIFY_ENVVARS_AND_CACHE(CGAL_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(CGAL_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(GMP_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(GMP_LIBRARY_DIR)
 UNIFY_ENVVARS_AND_CACHE(MPFR_INCLUDE_DIR)
 UNIFY_ENVVARS_AND_CACHE(MPFR_LIBRARY_DIR)
+endif()

-if (GLTF_SUPPORT AND BUILD_CONVERT)
+if (NOT MINIMAL_BUILD AND GLTF_SUPPORT AND BUILD_CONVERT)
 UNIFY_ENVVARS_AND_CACHE(JSON_INCLUDE_DIR)
 FIND_FILE(json_hpp "json.hpp" ${JSON_INCLUDE_DIR}/nlohmann)
 IF(json_hpp)
@@ -201,10 +210,12 @@ if(USE_MMAP)
    add_definitions(-DUSE_MMAP)
 endif()

+if (NOT MINIMAL_BUILD)
 # libxml2 is required for IFCXML (optional) and SVGFILL (mandatory)
-find_package(LibXml2 REQUIRED)
+  find_package(LibXml2 REQUIRED)
+endif()

-if (IFCXML_SUPPORT)
+if (NOT MINIMAL_BUILD AND IFCXML_SUPPORT)
    add_definitions(-DWITH_IFCXML)
 	set(SWIG_DEFINES ${SWIG_DEFINES} -DWITH_IFCXML)
 endif()
@@ -346,7 +357,7 @@ endif()

 endif(BUILD_IFCGEOM)

-IF(COLLADA_SUPPORT)
+IF(NOT MINIMAL_BUILD AND COLLADA_SUPPORT)
 	# Find OpenCOLLADA
 	IF("${OPENCOLLADA_INCLUDE_DIR}" STREQUAL "")
 		MESSAGE(STATUS "No OpenCOLLADA include directory specified")
@@ -426,7 +437,7 @@ IF(COLLADA_SUPPORT)
 	ENDIF()
 ENDIF()

-if(HDF5_SUPPORT)
+if(NOT MINIMAL_BUILD AND HDF5_SUPPORT)
    IF("${HDF5_INCLUDE_DIR}" STREQUAL "")
 		MESSAGE(STATUS "No HDF5 include directory specified")
 	ElSE()
@@ -441,30 +452,60 @@ if(HDF5_SUPPORT)

    if (HDF5_LIBRARY_DIR)
    	# result of the HDF5 ctest package
-    	
-        if (WIN32)
-        	set(zlib_post lib)
-        	set(lib_ext lib)
-        else()
-        	set(lib_ext a)
+        # Find zlib using cmake find_library. How should this be implemented?
+        # FIND_LIBRARY(NAMES z libz libz_debug PATHS ... NO_DEFAULT_PATH)
+
+
+        if ("$ENV{CONDA_BUILD}" STREQUAL "")
+            # result of the HDF5 ctest package
+
+            if (WIN32)
+                set(zlib_post lib)
+                set(lib_ext lib)
+            else()
+                set(lib_ext a)
+            endif()
+
+            if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
+                set(debug_postfix "_debug")
+            endif()
+
+            SET(HDF5_LIBRARIES
+                    "${HDF5_LIBRARY_DIR}/libhdf5_cpp${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libhdf5${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libz${zlib_post}${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libsz${debug_postfix}.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libaec${debug_postfix}.${lib_ext}"
+                    )
+
+        ELSE()
+            MESSAGE(STATUS "Packaging hdf5 and zlib for conda distribution")
+            if (WIN32)
+                # Windows
+                set(zlib_post zlib)
+                set(lib_ext lib)
+            elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+                # macOS
+                set(zlib_post libz)
+                set(lib_ext dylib)
+            else()
+                # linux
+                set(zlib_post libz)
+                set(lib_ext so)
+            endif()
+
+            SET(HDF5_LIBRARIES
+                    "${HDF5_LIBRARY_DIR}/libhdf5_cpp.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/libhdf5.${lib_ext}"
+                    "${HDF5_LIBRARY_DIR}/${zlib_post}.${lib_ext}"
+                    )
        endif()

-	if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-		set(debug_postfix "_debug")
-	endif() 
-        
-        SET(HDF5_LIBRARIES 
-            "${HDF5_LIBRARY_DIR}/libhdf5_cpp${debug_postfix}.${lib_ext}"
-            "${HDF5_LIBRARY_DIR}/libhdf5${debug_postfix}.${lib_ext}"
-            "${HDF5_LIBRARY_DIR}/libz${zlib_post}${debug_postfix}.${lib_ext}"
-            "${HDF5_LIBRARY_DIR}/libsz${debug_postfix}.${lib_ext}"
-            "${HDF5_LIBRARY_DIR}/libaec${debug_postfix}.${lib_ext}"
-        )
    endif()
-    
+
    if (NOT HDF5_LIBRARIES)
    	# debian default
-    	
+
        SET(HDF5_LIBRARIES
            /usr/lib/x86_64-linux-gnu/hdf5/serial/libhdf5_cpp.so
            /usr/lib/x86_64-linux-gnu/hdf5/serial/libhdf5.so
@@ -579,13 +620,16 @@ function(files_for_ifc_version IFC_VERSION RESULT_NAME)
 endfunction()

 if(NOT SCHEMA_VERSIONS)
-    set(SCHEMA_VERSIONS "2x3" "4" "4x1" "4x2" "4x3_rc1" "4x3_rc2" "4x3_rc3" "4x3_rc4")
+    set(SCHEMA_VERSIONS "2x3" "4" "4x1" "4x2" "4x3_rc1" "4x3_rc2" "4x3_rc3" "4x3_rc4" "4x3")
 endif()

 foreach(s ${SCHEMA_VERSIONS})
 	add_definitions(-DHAS_SCHEMA_${s})
 endforeach()

+string(REPLACE ";" ")(" schema_version_seq "(${SCHEMA_VERSIONS})")
+ADD_DEFINITIONS(-DSCHEMA_SEQ=${schema_version_seq})
+
 if(COMPILE_SCHEMA)
 	# @todo, this appears to be untested at the moment

@@ -655,7 +699,7 @@ if (BUILD_IFCGEOM)
 	endforeach()
 	set(IFCOPENSHELL_LIBRARIES ${IFCOPENSHELL_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES} IfcGeom ${IFCGEOM_SCHEMA_LIBRARIES})
 endif()
-if (BUILD_CONVERT)
+if (BUILD_CONVERT OR BUILD_IFCPYTHON)
 	foreach(s ${SCHEMA_VERSIONS})
 		set(SERIALIZER_SCHEMA_LIBRARIES ${SERIALIZER_SCHEMA_LIBRARIES} Serializers_ifc${s})
 	endforeach()
@@ -728,7 +772,7 @@ TARGET_LINK_LIBRARIES(IfcGeom IfcParse ${IFCGEOM_SCHEMA_LIBRARIES} ${CMAKE_THREA

 endif(BUILD_IFCGEOM)

-if (BUILD_CONVERT)
+if (BUILD_CONVERT OR BUILD_IFCPYTHON)

 # Serializers
 file(GLOB SERIALIZERS_H_FILES ../src/serializers/*.h)
@@ -749,6 +793,10 @@ set_target_properties(Serializers PROPERTIES COMPILE_FLAGS "-DIFC_GEOM_EXPORTS $

 TARGET_LINK_LIBRARIES(Serializers ${SERIALIZER_SCHEMA_LIBRARIES} ${OPENCOLLADA_LIBRARIES})

+endif(BUILD_CONVERT or BUILD_IFCPYTHON)
+
+if (BUILD_CONVERT)
+
 # IfcConvert
 file(GLOB IFCCONVERT_CPP_FILES ../src/ifcconvert/*.cpp)
 file(GLOB IFCCONVERT_H_FILES ../src/ifcconvert/*.h)
@@ -774,7 +822,7 @@ INSTALL(TARGETS IfcConvert
 endif(BUILD_CONVERT)

 # IfcGeomServer
-if(BUILD_GEOMSERVER)
+if(NOT MINIMAL_BUILD AND BUILD_GEOMSERVER)

 file(GLOB CPP_FILES ../src/ifcgeomserver/*.cpp)
 file(GLOB H_FILES ../src/ifcgeomserver/*.h)
@@ -805,7 +853,8 @@ if (GIT_FOUND)
 	)
 	string(REPLACE "\n" ";" git_branch_list "${git_branches}")
 	foreach(git_branch_candidate IN ITEMS ${git_branch_list})
-		string(STRIP "${git_branch_candidate}" 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$")
 			set(git_branch ${git_branch_candidate_2})
 		endif()
@@ -828,7 +877,7 @@ IF(BUILD_DOCUMENTATION)
 	ADD_SUBDIRECTORY(../docs docs)
 ENDIF()

-IF(BUILD_IFCPYTHON)
+IF(NOT MINIMAL_BUILD AND BUILD_IFCPYTHON)
 	ADD_SUBDIRECTORY(../src/ifcwrap ifcwrap)
 ENDIF()

@@ -836,11 +885,12 @@ IF(BUILD_EXAMPLES)
 	ADD_SUBDIRECTORY(../src/examples examples)
 ENDIF()

-IF(BUILD_IFCMAX)
+IF(NOT MINIMAL_BUILD AND BUILD_IFCMAX)
 	ADD_SUBDIRECTORY(../src/ifcmax ifcmax)
 ENDIF()
-
+if (NOT MINIMAL_BUILD)
 ADD_SUBDIRECTORY(../src/svgfill svgfill)
+endif()

 # CMake installation targets
 INSTALL(FILES ${IFCPARSE_H_FILES}
@@ -885,6 +935,9 @@ INSTALL(FILES  ${SERIALIZERS_S_FILES}
 )
 endif()

+IF(BUILD_QTVIEWER)
+    ADD_SUBDIRECTORY(../src/qtviewer qtviewer)
+endif()

 list(APPEND CPACK_SOURCE_IGNORE_FILES
  .git
@@ -909,12 +962,12 @@ set(CPACK_SOURCE_GENERATOR "TGZ")

 FOREACH(COMPONENT IN ITEMS ${BOOST_COMPONENTS})
    string(REPLACE "_" "-" COMP ${COMPONENT})
-    set(BOOST_DEPS "${BOOST_DEPS}, libboost-${COMP}1.67.0")
+    set(BOOST_DEPS "${BOOST_DEPS}, libboost-${COMP}-dev")
 endforeach(COMPONENT)

 set(CPACK_DEBIAN_PACKAGE_NAME "${PROJECT_NAME}")
 set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_CONTACT}")
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "python3, libxml2, liboce-foundation11, liboce-modeling11, liboce-ocaf11, liboce-visualization11, liboce-ocaf-lite11, libpython3.8 ${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.8 ${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")
@@ -0,0 +1,11 @@
+compile:
+	conda activate conda-build && conda-build -c conda-forge . --keep-old-work --python 3.10.4
+
+debug:
+	conda activate conda-build && conda-debug -c conda-forge . --python 3.10.4
+
+install:
+	conda env create -f environment.yml
+
+update:
+	conda env update -n conda-build --file environment.yml --prune
@@ -1,29 +1,42 @@
 mkdir build && cd build

-REM Remove dot from PY_VER for use in library name
-REM From https://github.com/tpaviot/pythonocc-core/blob/master/ci/conda/bld.bat
 set MY_PY_VER=%PY_VER:.=%
+set LIBXML2="%LIBRARY_PREFIX%/lib/libxml2.lib"

-cmake -G "NMake Makefiles" ^
- -DCMAKE_INSTALL_PREFIX="%LIBRARY_PREFIX%" ^
- -DCMAKE_BUILD_TYPE=Release ^
- -DCMAKE_PREFIX_PATH="%LIBRARY_PREFIX%" ^
- -DCMAKE_SYSTEM_PREFIX_PATH="%LIBRARY_PREFIX%" ^
- -DPYTHON_EXECUTABLE="%PYTHON%" ^
- -DPYTHON_INCLUDE_DIR="%PREFIX%"/include ^
- -DPYTHON_LIBRARY="%PREFIX%"/libs/python%MY_PY_VER%.lib ^
- -DBOOST_LIBRARYDIR="%LIBRARY_PREFIX%\lib" ^
- -DBOOST_INCLUDEDIR="%LIBRARY_PREFIX%\include" ^
- -DOCC_INCLUDE_DIR="%LIBRARY_PREFIX%\include\oce" ^
- -DOCC_LIBRARY_DIR="%LIBRARY_PREFIX%\lib" ^
- -DCOLLADA_SUPPORT=Off ^
- -DBUILD_EXAMPLES=Off ^
- -DBUILD_GEOMSERVER=Off ^
- -DBUILD_CONVERT=Off ^
- ../cmake
- 
+cmake -G "Ninja" ^
+ -D CMAKE_BUILD_TYPE:STRING=Release ^
+ -D CMAKE_INSTALL_PREFIX:FILEPATH="%LIBRARY_PREFIX%" ^
+ -D CMAKE_PREFIX_PATH:FILEPATH="%LIBRARY_PREFIX%" ^
+ -D CMAKE_SYSTEM_PREFIX_PATH:FILEPATH="%LIBRARY_PREFIX%" ^
+ -D OCC_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include\opencascade" ^
+ -D OCC_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D CGAL_INCLUDE_DIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
+ -D GMP_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D MPFR_LIBRARY_DIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D COLLADA_SUPPORT=OFF ^
+ -D HDF5_SUPPORT=ON ^
+ -D HDF5_INCLUDE_DIR="%LIBRARY_PREFIX%\include" ^
+ -D HDF5_LIBRARY_DIR="%LIBRARY_PREFIX%\lib" ^
+ -D JSON_INCLUDE_DIR="%LIBRARY_PREFIX%\include" ^
+ -D PYTHON_INCLUDE_DIR=%PREFIX%\include ^
+ -D PYTHON_EXECUTABLE:FILEPATH=%PREFIX%\python.exe ^
+ -D PYTHON_LIBRARY:FILEPATH="%PREFIX%"\libs/python%MY_PY_VER%.lib ^
+ -D BUILD_IFCPYTHON=ON ^
+ -D BUILD_IFCGEOM=ON ^
+ -D COLLADA_SUPPORT:BOOL=OFF ^
+ -D BUILD_EXAMPLES:BOOL=OFF ^
+ -D BUILD_GEOMSERVER:BOOL=OFF ^
+ -D GLTF_SUPPORT:BOOL=ON ^
+ -D BUILD_CONVERT:BOOL=ON ^
+ -D BUILD_IFCMAX:BOOL=OFF ^
+ -D IFCXML_SUPPORT:BOOL=ON ^
+ -D BOOST_LIBRARYDIR:FILEPATH="%LIBRARY_PREFIX%\lib" ^
+ -D BOOST_INCLUDEDIR:FILEPATH="%LIBRARY_PREFIX%\include" ^
+ -D BOOST_USE_STATIC_LIBS:BOOL=OFF ^
+ %SRC_DIR%/cmake
 if errorlevel 1 exit 1

-cmake --build . --target INSTALL --config Release
+:: Build and install
+cmake --build . -- install

 if errorlevel 1 exit 1
@@ -1,34 +1,44 @@
-# From https://github.com/tpaviot/pythonocc-core/blob/master/ci/conda/build.sh
-if [ "$PY3K" == "1" ]; then
-    MY_PY_VER="${PY_VER}m"
-else
-    MY_PY_VER="${PY_VER}"
+#!/bin/bash
+
+declare -a CMAKE_PLATFORM_FLAGS
+
+if [[ ${HOST} =~ .*linux.* ]]; then
+    CMAKE_PLATFORM_FLAGS+=(-DCMAKE_TOOLCHAIN_FILE=$RECIPE_DIR/cross-linux.cmake)
 fi

 if [ `uname` == Darwin ]; then
-    PY_LIB="libpython${MY_PY_VER}.dylib"
-    export   CFLAGS="$CFLAGS   -Wl,-flat_namespace,-undefined,suppress"
-    export CXXFLAGS="$CXXFLAGS -Wl,-flat_namespace,-undefined,suppress"
-    export  LDFLAGS="$LDFLAGS  -Wl,-flat_namespace,-undefined,suppress"
-else
-    PY_LIB="libpython${MY_PY_VER}.so"
+  export CFLAGS="$CFLAGS   -Wl,-flat_namespace,-undefined,suppress"
+  export CXXFLAGS="$CXXFLAGS -Wl,-flat_namespace,-undefined,suppress"
+  export LDFLAGS="$LDFLAGS  -Wl,-flat_namespace,-undefined,suppress"
 fi

-mkdir build && cd build
-
-cmake \
- -DCMAKE_INSTALL_PREFIX=$PREFIX \
+cmake -G Ninja \
 -DCMAKE_BUILD_TYPE=Release \
+ -DCMAKE_INSTALL_PREFIX=$PREFIX \
+  ${CMAKE_PLATFORM_FLAGS[@]} \
 -DCMAKE_PREFIX_PATH=$PREFIX \
 -DCMAKE_SYSTEM_PREFIX_PATH=$PREFIX \
- -DOCC_INCLUDE_DIR=$PREFIX/include/oce \
- -DOCC_LIBRARY_DIR=$PREFIX/lib \
 -DPYTHON_EXECUTABLE:FILEPATH=$PYTHON \
- -DPYTHON_INCLUDE_DIR:PATH=$PREFIX/include/python$MY_PY_VER \
- -DPYTHON_LIBRARY:FILEPATH=$PREFIX/lib/${PY_LIB} \
- -DCOLLADA_SUPPORT=Off \
- ../cmake
+ -DGMP_LIBRARY_DIR=$PREFIX/lib \
+ -DMPFR_LIBRARY_DIR=$PREFIX/lib \
+ -DOCC_INCLUDE_DIR=$PREFIX/include/opencascade \
+ -DOCC_LIBRARY_DIR=$PREFIX/lib \
+ -DHDF5_SUPPORT:BOOL=ON \
+ -DHDF5_INCLUDE_DIR=$PREFIX/include \
+ -DHDF5_LIBRARY_DIR=$PREFIX/lib \
+ -DJSON_INCLUDE_DIR=$PREFIX/include \
+ -DCGAL_INCLUDE_DIR=$PREFIX/include \
+ -DCOLLADA_SUPPORT=0 \
+ -DBUILD_EXAMPLES:BOOL=OFF \
+ -DIFCXML_SUPPORT:BOOL=ON \
+ -DGLTF_SUPPORT:BOOL=ON \
+ -DBUILD_CONVERT:BOOL=ON \
+ -DBUILD_IFCPYTHON:BOOL=ON \
+ -DBUILD_IFCGEOM:BOOL=ON \
+ -DBUILD_GEOMSERVER:BOOL=OFF \
+ -DBOOST_USE_STATIC_LIBS:BOOL=OFF \
+ ./cmake

-make -j$CPU_COUNT _ifcopenshell_wrapper
-cd ifcwrap
-make install/local
+ninja
+
+ninja install
@@ -0,0 +1,2 @@
+CONDA_BUILD_SYSROOT:
+  - /opt/MacOSX10.13.sdk       # [osx]
@@ -0,0 +1,16 @@
+# this one is important
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_PLATFORM Linux)
+
+# specify the cross compiler
+set(CMAKE_C_COMPILER $ENV{CC})
+set(CMAKE_CXX_COMPILER $ENV{CXX})
+
+# where is the target environment
+set(CMAKE_FIND_ROOT_PATH $ENV{PREFIX} $ENV{BUILD_PREFIX}/$ENV{HOST}/sysroot)
+
+# search for programs in the build host directories
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# for libraries and headers in the target directories
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
@@ -0,0 +1,14 @@
+name: conda-build
+channels:
+  - conda-forge
+dependencies:
+  - conda-build
+  - conda-verify
+  - anaconda-client
+  - ninja
+  - doxygen
+  - ripgrep
+  - pip
+  - pip:
+      - --extra-index-url https://lief.s3-website.fr-par.scw.cloud/latest
+      - lief==0.13.0.dev0
@@ -1,42 +1,77 @@
+{% set name = "ifcopenshell" %}
+{% set version = "0.7.0" %}
+{% set occt_version = "7.6.2" %}
+{% set cgal_cpp_version = "5.3" %}
+{% set hdf5_version = "1.12.1" %}
+
 package:
-  name: ifcopenshell
-  version: "0.6.0a1"
+  name: {{ name }}
+  version: {{ version }}

 source:
-  git_rev: "v0.6.0a1"
-  git_url: https://github.com/IfcOpenShell/IfcOpenShell
+  path: ..

 build:
-  number: 0
-  features:
-    - vc9     # [win and py27]
-    - vc10    # [win and py34]
-    - vc14    # [win and py35]
-    - vc14    # [win and py36]
+  binary_relocation: false [osx]

 requirements:
  build:
-    - gcc     # [osx]
-    - make
-    - python
-    - oce ==0.18.3
+    - {{ compiler('c') }}
+    - {{ compiler('cxx') }}
+    - ninja >=1.10.2
    - cmake
-    - swig >=3.0.9
-    - libboost
-    - icu
-    - xmlschema
-    - lxml
-    - numpy
-  run:
-    - libgcc  # [osx]
+    - swig >=4.0.2
+
+  host:
    - python
-    - oce ==0.18.3
-    - libboost
-    - icu
-    - xmlschema
-    - lxml
+    - occt >={{ occt_version }}
+    - hdf5 >={{ hdf5_version }}
+    - cgal-cpp >={{ cgal_cpp_version }}
+    - nlohmann_json
+    - libxml2
+
+  run:
+    - python
+    - occt >={{ occt_version }}
+    - cgal-cpp >={{ cgal_cpp_version }}
+    - hdf5 >={{ hdf5_version }}
+    - lark-parser
+    - deepdiff
+    - requests
+    - nlohmann_json
+    - isodate
+    - numpy >=1.17
+
+test:
+  imports:
+    - ifcopenshell
+  requires:
+    - pytest
+    - pytest-cov
    - numpy
-    
+    - lxml
+    - isodate
+    - lark
+    - networkx
+    - xmlschema
+  #source_files:
+  #  - src/ifcopenshell-python/test/api
+  #  - src/ifcopenshell-python/test/util
+  #  - src/ifcopenshell-python/test/bootstrap.py
+  #  - src/ifcopenshell-python/test/test_file.py
+  #  - src/ifcopenshell-python/test/test_wall_opening.py
+  #  - src/ifcopenshell-python/test/__init__.py
+  #commands:
+  #  #- pip install bcf-client
+  #  - cd ../src/ifcopenshell-python/test && pytest -p no:pytest-blender
+
 about:
  home: http://ifcopenshell.org
-  license: LGPL
+  license: LGPL-3.0-or-later
+  license_file: COPYING
+  summary: 'IfcOpenShell is a library to support the IFC file format'
+  description: |
+    IfcOpenShell is an open source (LGPL) software library for 
+    working with the Industry Foundation Classes (IFC) file format.
+  doc_url: http://ifcopenshell.org/
+  dev_url: https://github.com/IfcOpenShell/IfcOpenShell
@@ -72,7 +72,7 @@ PROJECT_NAME = "IfcOpenShell"
 USE_CURRENT_PYTHON_VERSION = os.getenv("USE_CURRENT_PYTHON_VERSION")
 ADD_COMMIT_SHA = os.getenv("ADD_COMMIT_SHA")

-PYTHON_VERSIONS = ["3.6.14", "3.7.12", "3.8.12", "3.9.7", "3.10.0"]
+PYTHON_VERSIONS = ["3.6.14", "3.7.13", "3.8.13", "3.9.11", "3.10.3"]
 JSON_VERSION = "v3.6.1"
 OCE_VERSION = "0.18.3"
 OCCT_VERSION = "7.5.3"
@@ -83,8 +83,8 @@ SWIG_VERSION = "4.0.2"
 OPENCOLLADA_VERSION = "v1.6.68"
 HDF5_VERSION = "1.12.1"

-GMP_VERSION = "6.1.2"
-MPFR_VERSION = "3.1.5" # latest is 4.1.0
+GMP_VERSION = "6.2.1"
+MPFR_VERSION = "3.1.6" # latest is 4.1.0
 CGAL_VERSION = "5.3"

 # binaries
@@ -263,6 +263,11 @@ def run(cmds, cwd=None):

    return stdout.strip()

+if platform.system() == "Darwin":
+    if run(["sw_vers", "-productVersion"]) >= "11.":
+        # Apparently not supported
+        PYTHON_VERSIONS = [pv for pv in PYTHON_VERSIONS if tuple(map(int, pv.split("."))) >= (3, 7)]
+
 BOOST_VERSION_UNDERSCORE = BOOST_VERSION.replace(".", "_")

 OCE_LOCATION = f"https://github.com/tpaviot/oce/archive/OCE-{OCE_VERSION}.tar.gz"
@@ -508,7 +513,7 @@ if USE_OCCT and "occ" in targets:
            "-DBUILD_MODULE_Draw=0",
            "-DBUILD_RELEASE_DISABLE_EXCEPTIONS=Off"
        ],
-        download_url = "https://git.dev.opencascade.org/repos/occt.git",
+        download_url = "https://github.com/Open-Cascade-SAS/OCCT",
        download_name = "occt",
        download_tool=download_tool_git,
        patch=None if OCCT_VERSION >= "7.4" else "./patches/occt/enable-exception-handling.patch",
@@ -577,7 +582,7 @@ if "python" in targets and not USE_CURRENT_PYTHON_VERSION:
    # with the system python because of some threading initialization
    PYTHON_CONFIGURE_ARGS = []
    if platform.system() == "Darwin":
-        PYTHON_CONFIGURE_ARGS = ["--disable-static", "--enable-shared"]
+        PYTHON_CONFIGURE_ARGS = ["--enable-shared"]

    for PYTHON_VERSION in PYTHON_VERSIONS:
        try:
@@ -646,7 +646,7 @@ class BcfXml:
    def get_comments(self, guid):
        comments = {}
        data = self._read_xml(os.path.join(guid, "markup.bcf"), "markup.xsd")
-        if "Comments" not in data["Topics"]:
+        if "Comments" not in data["Topic"]:
            return comments

        for item in data["Topic"]["Comments"].get("Comment", []):
@@ -16,6 +16,24 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

+PYTHON:=python
+PATCH:=patch
+SED:=sed -i
+ifeq ($(OS),Windows_NT)
+HOSTOS:=win
+else
+UNAME_S:=$(shell uname -s)
+ifeq ($(UNAME_S),Linux)
+HOSTOS:=linux
+endif
+ifeq ($(UNAME_S),Darwin)
+HOSTOS:=macos
+PYTHON:=python3
+PATCH:=patch -d
+SED:=sed -i '' -e
+endif
+endif
+
 VERSION:=`date '+%y%m%d'`
 PYVERSION:=py37

@@ -115,7 +133,7 @@ endif
 	cp -r blenderbim/* dist/blenderbim/

 	# Provides IfcOpenShell Python functionality
-	cd dist/working && wget https://s3.amazonaws.com/ifcopenshell-builds/ifcopenshell-python-$(PYNUMBER)-v0.7.0-883b8a5-$(PLATFORM)64.zip
+	cd dist/working && wget https://s3.amazonaws.com/ifcopenshell-builds/ifcopenshell-python-$(PYNUMBER)-v0.7.0-dc67287-$(PLATFORM)64.zip
 	cd dist/working && unzip ifcopenshell-python*
 	cp -r dist/working/ifcopenshell dist/blenderbim/libs/site/packages/

@@ -138,11 +156,13 @@ endif
 	# Provides IFCClash functionality
 	cp -r dist/working/IfcOpenShell-0.7.0/src/ifcclash/ifcclash dist/blenderbim/libs/site/packages/
 	# Provides BIMTester functionality
-	cd dist/working && python -m venv env
+	cd dist/working && $(PYTHON) -m venv env
 	cd dist/working && . env/bin/activate && pip install pybabel
 	cd dist/working && . env/bin/activate && pip install babel
 	cd dist/working && . env/bin/activate && ./env/bin/pybabel compile -d ./IfcOpenShell-0.7.0/src/ifcbimtester/bimtester/locale/
 	cp -r dist/working/IfcOpenShell-0.7.0/src/ifcbimtester/bimtester dist/blenderbim/libs/site/packages/
+	# Provides IFCTester functionality
+	cp -r dist/working/IfcOpenShell-0.7.0/src/ifctester/ifctester dist/blenderbim/libs/site/packages/
 	# Provides IFCCOBie functionality
 	cp -r dist/working/IfcOpenShell-0.7.0/src/ifccobie/* dist/blenderbim/libs/site/packages/
 	# Provides IFCDiff functionality
@@ -161,9 +181,9 @@ endif

 	# Provides Mustache templating in construction documentation
 	mkdir dist/working
-	cd dist/working && wget https://files.pythonhosted.org/packages/d6/fd/eb8c212053addd941cc90baac307c00ac246ac3fce7166b86434c6eae963/pystache-0.5.4.tar.gz
+	cd dist/working && wget https://files.pythonhosted.org/packages/3f/e7/8750ba6c6101d6aa5ceeb20c013adf2c6f3554a12c71d75654b468404bfa/pystache-0.6.0.tar.gz
 	cd dist/working && tar -xzvf pystache*
-	cd dist/working/pystache-0.5.4/ && python setup.py build && cp -r build/lib/pystache ../../blenderbim/libs/site/packages/
+	cd dist/working/pystache-0.6.0/ && $(PYTHON) setup.py build && cp -r build/lib/pystache ../../blenderbim/libs/site/packages/
 	rm -rf dist/working

 	# Provides SVG export in construction documentation
@@ -210,9 +230,9 @@ endif

 	# Required by IFCDiff
 	mkdir dist/working
-	cd dist/working && wget https://github.com/Moult/deepdiff/archive/master.zip
-	cd dist/working && unzip master.zip
-	cp -r dist/working/deepdiff-master/deepdiff dist/blenderbim/libs/site/packages/
+	cd dist/working && wget https://files.pythonhosted.org/packages/0f/ca/caead2949fbb824c7142e3774fa841aa853bb4d4331b440da8c8514dfc6f/deepdiff-5.8.1.tar.gz
+	cd dist/working && tar -xzvf deepdiff*
+	cp -r dist/working/deepdiff-5.8.1/deepdiff dist/blenderbim/libs/site/packages/
 	rm -rf dist/working

 	# Required by deepdiff
@@ -238,16 +258,16 @@ endif

 	# Required by bcf
 	mkdir dist/working
-	cd dist/working && wget https://files.pythonhosted.org/packages/bb/41/ad9ce53bb978b68af8ae415293cafc89b165b8ad55a593725299dca76729/xmlschema-1.1.1.tar.gz
+	cd dist/working && wget https://files.pythonhosted.org/packages/5b/ef/f97c3e1a7efa00e989a793fe15297214fc95ad7d9e3810586bd08ce9f0f3/xmlschema-2.0.2.tar.gz
 	cd dist/working && tar -xzvf xmlschema*
-	cp -r dist/working/xmlschema-1.1.1/xmlschema dist/blenderbim/libs/site/packages/
+	cp -r dist/working/xmlschema-2.0.2/xmlschema dist/blenderbim/libs/site/packages/
 	rm -rf dist/working

 	# Required by bcf
 	mkdir dist/working
-	cd dist/working && wget https://files.pythonhosted.org/packages/12/f9/f9960222d5274944b01391749e55e4dcdf28d8f0c108b64ac931ceff6fdb/elementpath-1.4.3.tar.gz
+	cd dist/working && wget https://files.pythonhosted.org/packages/11/bc/5afb61dd5d863e5cf77cd952445c50c17e65953405986f19e97e4389692a/elementpath-3.0.2.tar.gz
 	cd dist/working && tar -xzvf elementpath*
-	cp -r dist/working/elementpath-1.4.3/elementpath dist/blenderbim/libs/site/packages/
+	cp -r dist/working/elementpath-3.0.2/elementpath dist/blenderbim/libs/site/packages/
 	rm -rf dist/working

 	# Required by bcf
@@ -281,7 +301,7 @@ endif

 	# Required by IFCCityJSON
 	mkdir dist/working
-	cd dist/working && python -m venv env
+	cd dist/working && $(PYTHON) -m venv env
 	cd dist/working && mkdir site-packages
 	cd dist/working && . env/bin/activate && pip install cjio --target=./site-packages
 	cd dist/working/site-packages/ && rm -r *dist-info*
@@ -389,8 +409,11 @@ endif
 	# See bug #1294
 	cd dist/working/ && wget https://raw.githubusercontent.com/IfcOpenShell/IfcOpenShell/v0.7.0/src/ifcbimtester/patch/model_core.patch
 	cd dist/working/ && wget https://raw.githubusercontent.com/IfcOpenShell/IfcOpenShell/v0.7.0/src/ifcbimtester/patch/runner_util.patch
-	cd dist/working/ && patch ../blenderbim/libs/site/packages/behave/model_core.py < model_core.patch
-	cd dist/working/ && patch ../blenderbim/libs/site/packages/behave/runner_util.py < runner_util.patch
+	cd dist/working/ && $(PATCH) ../blenderbim/libs/site/packages/behave/model_core.py < model_core.patch
+	cd dist/working/ && $(PATCH) ../blenderbim/libs/site/packages/behave/runner_util.py < runner_util.patch
+	# See bug #2159
+	cd dist/working/ && wget https://raw.githubusercontent.com/IfcOpenShell/IfcOpenShell/v0.7.0/src/ifcbimtester/patch/junit.patch
+	cd dist/working/ && $(PATCH) ../blenderbim/libs/site/packages/behave/reporter/junit.py < junit.patch
 	rm -rf dist/working

 	# Required by ids - uh, not any more, but I'm trying it out in the drawing module
@@ -470,14 +493,14 @@ endif
 	cp -r dist/working/IFC2JSON_python-master/file_converters/ifcjson dist/blenderbim/libs/site/packages/
 	rm -rf dist/working

-	# Provides OpenLCA fucntionality
+	# Provides OpenLCA functionality
 	mkdir dist/working
 	cd dist/working && wget https://files.pythonhosted.org/packages/85/33/f91b96e9e8608ff65a003b692e8a9cdd60f2178f60617e5b1d21334c009c/olca-ipc-0.0.10.tar.gz
 	cd dist/working && tar -xzvf olca-ipc*
 	cd dist/working/olca-ipc-0.0.10/ && cp -r olca ../../blenderbim/libs/site/packages/
 	rm -rf dist/working

-	# Provides Brickschema fucntionality
+	# Provides Brickschema functionality
 	mkdir dist/working
 	cd dist/working && wget https://files.pythonhosted.org/packages/ca/37/8309da9a72407d2f5eb5489c197ac3cfe96ee3ccba1902d2a0ecc7843f92/brickschema-0.5.1.tar.gz
 	cd dist/working && tar -xzvf brickschema*
@@ -518,7 +541,7 @@ endif
 	cd dist/working/ && cp -r pkg_resources ../blenderbim/libs/site/packages/
 	rm -rf dist/working

-	cd dist/blenderbim && sed -i "s/999999/$(VERSION)/" __init__.py
+	cd dist/blenderbim && $(SED) "s/999999/$(VERSION)/" __init__.py
 	cd dist && zip -r blenderbim-$(VERSION)-$(PYVERSION)-$(PLATFORM).zip ./*
 	rm -rf dist/blenderbim

@@ -534,11 +557,19 @@ test-core:

 .PHONY: test-bim
 test-bim:
+ifndef MODULE
 	pytest test/bim
+else
+	pytest test/bim -m "$(MODULE)" ./ --maxfail=1
+endif

 .PHONY: test-tool
 test-tool:
+ifndef MODULE
 	pytest test/tool
+else
+	pytest test/tool/test_$(MODULE).py
+endif

 .PHONY: qa
 qa:
@@ -27,6 +27,7 @@ modules = {
    "root": None,
    "unit": None,
    "model": None,
+    "cad": None,
    "georeference": None,
    "context": None,
    "drawing": None,
@@ -61,6 +62,7 @@ modules = {
    "clash": None,
    "lca": None,
    "csv": None,
+    "tester": None,
    "bimtester": None,
    "diff": None,
    "patch": None,
@@ -91,7 +93,9 @@ classes = [
    operator.SelectIfcFile,
    operator.SelectSchemaDir,
    operator.SelectURIAttribute,
+    operator.EditBlenderCollection,
    prop.StrProperty,
+    operator.BIM_OT_enum_property_search,  # /!\ Register AFTER prop.StrProperty
    prop.ObjProperty,
    prop.Attribute,
    prop.ModuleVisibility,
@@ -130,7 +134,8 @@ for mod in modules.values():

 def on_register(scene):
    handler.setDefaultProperties(scene)
-    bpy.app.handlers.depsgraph_update_post.remove(on_register)
+    if not bpy.app.background:
+        bpy.app.handlers.depsgraph_update_post.remove(on_register)


 def register():
@@ -38,7 +38,7 @@
 <script type="text/javascript">
 var g = new JSGantt.GanttChart(document.getElementById('GanttChartDIV'), 'day');
 g.setOptions({
-    vCaptionType: 'Complete',  // Set to Show Caption : None,Caption,Resource,Duration,Complete,
+    vCaptionType: 'Caption',  // Set to Show Caption : None,Caption,Resource,Duration,Complete,
    vQuarterColWidth: 36,
    vDateTaskDisplayFormat: 'day dd month yyyy', // Shown in tool tip box
    vDayMajorDateDisplayFormat: 'mon yyyy - Week ww',// Set format to dates in the "Major" header of the "Day" view
@@ -50,6 +50,8 @@ g.setOptions({
    vFormatArr: ['Day', 'Week', 'Month', 'Quarter'], // Even with setUseSingleCell using Hour format on such a large chart can cause issues in some browsers,
    vShowRes: false, // Disable the resource column.
    vShowComp: false, // Disable the completion column.
+    vShowDur: false, // Disable the duration column, because jsgantt doesn't calculate durations the way we want.
+    vAdditionalHeaders: {ifcduration: {title: 'Duration'}},
    vUseToolTip: false, // Disable tooltips.
    vTotalHeight: 900,
 });
@@ -0,0 +1,13 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION((),'2;1');
+FILE_NAME('EPset_Annotation.ifc','2020-01-01T00:00:00',(),(),'EPset_Annotation','EPset_Annotation',$);
+FILE_SCHEMA(('IFC4'));
+ENDSEC;
+DATA;
+#1=IFCPROPERTYSETTEMPLATE('3VuPUwdCD2Qx3XDDRs0R1N',$,'EPset_Annotation','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation',(#2,#3));
+#2=IFCSIMPLEPROPERTYTEMPLATE('2P7JN79n96Q9pElZ83LKe4',$,'ZIndex','',.P_SINGLEVALUE.,'IfcInteger',$,$,$,$,$,.READWRITE.);
+#3=IFCSIMPLEPROPERTYTEMPLATE('1Wpx_r2xj1_9w5JpI0QRJy',$,'Symbol','',.P_ENUMERATEDVALUE.,'IfcLabel',$,#4,$,$,$,.READWRITE.);
+#4=IFCPROPERTYENUMERATION('Symbol',(IFCLABEL('rectangle-tag'), IFCLABEL('door-tag')),$);
+ENDSEC;
+END-ISO-10303-21;
@@ -0,0 +1,24 @@
+ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION((),'2;1');
+FILE_NAME('EPset_Drawing.ifc','2020-01-01T00:00:00',(),(),'EPset_Drawing','EPset_Drawing',$);
+FILE_SCHEMA(('IFC4'));
+ENDSEC;
+DATA;
+#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation',(#2,#3,#4,#5,#6,#7,#8,#9,#10,#11,#12,#13,#14,#15));
+#2=IFCSIMPLEPROPERTYTEMPLATE('23JavTMk98ZxXhrUEnjAcf',$,'TargetView','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
+#3=IFCSIMPLEPROPERTYTEMPLATE('1yVWUt5H9DAOuu0OaMMLpe',$,'Scale','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
+#4=IFCSIMPLEPROPERTYTEMPLATE('3gsuPBtU93b8f0gg1pjkq6',$,'HumanScale','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
+#5=IFCSIMPLEPROPERTYTEMPLATE('0AK5C2UpL4$eaac2LszAx$',$,'HasUnderlay','',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#6=IFCSIMPLEPROPERTYTEMPLATE('2j2ZEZR8X5tONm7kli5hM6',$,'HasLinework','',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#7=IFCSIMPLEPROPERTYTEMPLATE('1ttChRysH9UuEX2FeMj5Hu',$,'HasAnnotation','',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#8=IFCSIMPLEPROPERTYTEMPLATE('2NPPxuABv1huDTVh32TFgw',$,'GlobalReferencing','',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#9=IFCSIMPLEPROPERTYTEMPLATE('10hT_1zrzEbRRKMXYAWvtD',$,'Metadata','',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
+#10=IFCSIMPLEPROPERTYTEMPLATE('3Z0BXPSG5CWgtI33ioV7aj',$,'Include','',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
+#11=IFCSIMPLEPROPERTYTEMPLATE('1RVts_g3PAw98PJA2yL3bO',$,'Exclude','',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
+#12=IFCSIMPLEPROPERTYTEMPLATE('0c1$8NpYDEaBiJrj16jHIo',$,'Stylesheet','',.P_SINGLEVALUE.,'IfcURIReference',$,$,$,$,$,.READWRITE.);
+#13=IFCSIMPLEPROPERTYTEMPLATE('3mRF52q81FQB$h4oTh7M45',$,'Markers','',.P_SINGLEVALUE.,'IfcURIReference',$,$,$,$,$,.READWRITE.);
+#14=IFCSIMPLEPROPERTYTEMPLATE('1rhr_0N3LDtuORcEJP0KXM',$,'Symbols','',.P_SINGLEVALUE.,'IfcURIReference',$,$,$,$,$,.READWRITE.);
+#15=IFCSIMPLEPROPERTYTEMPLATE('2sHDBuW7P4TROy$hL2w7ct',$,'Patterns','',.P_SINGLEVALUE.,'IfcURIReference',$,$,$,$,$,.READWRITE.);
+ENDSEC;
+END-ISO-10303-21;
@@ -23,12 +23,27 @@ text { fill: black; stroke: none; }
 .cut { fill: black; stroke: black; stroke-linecap: 'round'; stroke-width: 0.35; fill-rule: evenodd; }
 .projection { fill: white; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; }
 .annotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; }
-.hidden { stroke-dasharray: 3, 2; }
-.solid {}
-.leader { marker-end: url(#leader-marker); }
-.stair { marker-start: url(#stair-marker-start); marker-end: url(#stair-marker-end); }
-.break { fill: white; }
-.breakline { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; marker-mid: url(#breakline-marker); }
+.IfcAnnotation { fill: none; stroke: black; stroke-linecap: 'round'; stroke-width: 0.25; }
+.PredefinedType-LINEWORK { stroke: black; stroke-width: 0.25; }
+.PredefinedType-BACKGROUND { stroke: black; stroke-width: 0.18; }
+.PredefinedType-GRID { marker-start: url(#grid-marker); marker-end: url(#grid-marker); }
+.PredefinedType-SECTION { stroke-dasharray: 12.5, 3, 3, 3; }
+.PredefinedType-SECTIONLEVEL { marker-start: url(#section-level-marker); stroke-dasharray: 12.5, 3, 3, 3; }
+.PredefinedType-PLANLEVEL { marker-end: url(#plan-level-marker); }
+.PredefinedType-DIMENSION { marker-start: url(#dimension-marker-start); marker-end: url(#dimension-marker-end); }
+.PredefinedType-ANGLE { marker-start: url(#angle-marker-start); marker-end: url(#angle-marker-end); }
+.PredefinedType-RADIUS { marker-end: url(#radius-marker-end); }
+.PredefinedType-DIAMETER { marker-start: url(#diameter-marker-start); marker-end: url(#diameter-marker-end); }
+.PredefinedType-HIDDENLINE { stroke-dasharray: 3, 2; }
+.PredefinedType-STAIRARROW { marker-start: url(#stair-marker-start); marker-end: url(#stair-marker-end); }
+.PredefinedType-BOUNDARY { fill: none; stroke: red; stroke-width: 1; stroke-dasharray: 12, 4, 3, 4, 3, 4; }
+.PredefinedType-BATTING { marker-start: url(#batting); stroke: none; }
+.PredefinedType-SEALANT { fill: url(#crosshatch1); stroke-width: 0.25; }
+.PredefinedType-FILLAREA { fill: white; stroke: none; }
+.PredefinedType-BREAKLINE { fill: none; stroke: black; stroke-width: 0.25; marker-mid: url(#breakline-marker); }
+.PredefinedType-TEXT { fill: black; stroke: none; }
+path.PredefinedType-TEXTLEADER { marker-end: url(#leader-marker); }
+text.PredefinedType-TEXTLEADER { fill: black; stroke: none; }
 .material-blank { fill: white; }
 .material-diagonal1 { fill: url(#diagonal1); }
 .material-diagonal2 { fill: url(#diagonal2); }
@@ -44,5 +59,9 @@ text { fill: black; stroke: none; }
 .material-honeycomb { fill: url(#honeycomb); }
 .material-sand { fill: url(#sand); }
 .material-concrete { fill: url(#concrete); stroke-width: 0.5; }
-.material-boundary { fill: none; stroke: red; stroke-width: 1; stroke-dasharray: 12,4,3,4,3,4; }
 .IfcSpace { fill: none; stroke: none; }
+.PredefinedType-STUD { stroke: black; stroke-width: 1; }
+.PredefinedType-WOOD { fill: url(#wood); stroke: black; stroke-width: 0.5; }
+.PredefinedType-STEEL { fill: url(#steel); stroke: black; stroke-width: 0.5; }
+.PredefinedType-CONCRETE { fill: url(#concrete); stroke: black; stroke-width: 0.5; }
+.PredefinedType-PLASTERBOARD { fill: url(#sand); stroke: black; stroke-width: 0.25; }
@@ -1,5 +1,9 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <svg baseProfile="full" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:ev="http://www.w3.org/2001/xml-events" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <marker id="batting" markerHeight="10" markerWidth="4" orient="auto" refX="0" refY="5" markerUnits="userSpaceOnUse">
+        <!-- Tip: https://svg-path-visualizer.netlify.app/ -->
+        <path style="fill: none; stroke:black; stroke-width:0.18" d="M 0 2 A 2 2 0 0 1 4 2 L 2 8 M 0 2 L 2 8 A 2 2 0 0 0 4 10 M 2 8 A 2 2 0 0 1 0 10" />
+    </marker>
    <marker id="eng-dimension-marker-start" markerHeight="14" markerWidth="11" orient="auto" refX="1" refY="7">
        <g>
            <path d="M 11 3.5 L 11 10.5 L 1 7" class="annotation" style="fill:black;" />
@@ -12,6 +16,35 @@
            <path d="M 10 0 L 10 14" class="annotation" style="stroke-width:1;" />
        </g>
    </marker>
+    <marker id="radius-marker-end" markerHeight="14" markerWidth="11" orient="auto" refX="10" refY="7">
+        <g>
+            <path d="M 0 3.5 L 0 10.5 L 10 7" class="annotation" style="fill:black;" />
+        </g>
+    </marker>
+    <marker id="angle-marker-start" markerHeight="14" markerWidth="11" orient="auto" refX="1" refY="7">
+        <g>
+            <path d="M 11 3.5 L 11 10.5 L 1 7" class="annotation" style="fill:black;" />
+            <path d="M 1 0 L 1 14" class="annotation" style="stroke-width:1;" />
+        </g>
+    </marker>
+    <marker id="angle-marker-end" markerHeight="14" markerWidth="11" orient="auto" refX="10" refY="7">
+        <g>
+            <path d="M 0 3.5 L 0 10.5 L 10 7" class="annotation" style="fill:black;" />
+            <path d="M 10 0 L 10 14" class="annotation" style="stroke-width:1;" />
+        </g>
+    </marker>
+    <marker id="diameter-marker-start" markerHeight="14" markerWidth="11" orient="auto" refX="1" refY="7">
+        <g>
+            <path d="M 11 3.5 L 11 10.5 L 1 7" class="annotation" style="fill:black;" />
+            <path d="M 1 0 L 1 14" class="annotation" style="stroke-width:1;" />
+        </g>
+    </marker>
+    <marker id="diameter-marker-end" markerHeight="14" markerWidth="11" orient="auto" refX="10" refY="7">
+        <g>
+            <path d="M 0 3.5 L 0 10.5 L 10 7" class="annotation" style="fill:black;" />
+            <path d="M 10 0 L 10 14" class="annotation" style="stroke-width:1;" />
+        </g>
+    </marker>
    <marker id="dimension-marker-start" markerHeight="30" markerWidth="20" refX="10" refY="15" orient="auto">
        <g>
            <path d="M 0 15 L 20 15" class="annotation" style="stroke-width:1;" />
@@ -53,7 +86,7 @@
            <path d="M 0 1 L 90 1" class="annotation" style="stroke-width:1;" />
        </g>
    </marker>
-    <marker id="breakline-marker" markerHeight="20" markerWidth="15" refX="7.5" refY="10">
+    <marker id="breakline-marker" markerHeight="20" markerWidth="15" refX="7.5" refY="10" orient="auto">
        <g>
            <path d="M 0 10 L 5 20 L 7.5 10" class="annotation" style="stroke-width:1; fill: white;" />
            <path d="M 7.5 10 L 10 0 L 15 10" class="annotation" style="stroke-width:1; fill: white;" />
@@ -3,6 +3,10 @@
 <pattern id="demolish" width="1" height="1" patternTransform="rotate(45 0 0)" patternUnits="userSpaceOnUse">
    <line x1="0" y1="0" x2="0" y2="1" style="stroke:red; stroke-width:0.25" />
 </pattern>
+<pattern id="steel" width="3" height="1" patternTransform="rotate(45 0 0)" patternUnits="userSpaceOnUse">
+    <line x1="0" y1="0" x2="0" y2="1" style="stroke:black; stroke-width:0.25" />
+    <line x1="1" y1="0" x2="1" y2="1" style="stroke:black; stroke-width:0.25" />
+</pattern>
 <pattern id="diagonal1" width="1" height="1" patternTransform="rotate(45 0 0)" patternUnits="userSpaceOnUse">
    <line x1="0" y1="0" x2="0" y2="1" style="stroke:black; stroke-width:0.25" />
 </pattern>
@@ -80,6 +84,9 @@
    <path d="M 1.25,2.165 L 2.5,4.33 L 5,4.33 L 6.25,2.165 L 5,0 L 2.5,0 L 1.25,2.165" style="stroke:black;stroke-width:0.25;stroke-linecap:round;fill:none" />
    <path d="M 6.25,2.165 L 7.5,2.165" style="stroke:black;stroke-width:0.25;stroke-linecap:round" />
 </pattern>
+<pattern id="wood" width="50" height="50" patternUnits="userSpaceOnUse">
+    <path style="fill:none; stroke: black; stroke-width:0.25;" d="M 49.649999,1.3460737 A 69.019995,69.019995 0 0 0 48.653938,0.34999949 M 49.649999,4.9389583 A 66.554994,66.554994 0 0 0 45.06105,0.34999949 M 49.649999,8.6983527 A 64.089999,64.089999 0 0 0 41.301656,0.34999949 M 49.649999,12.675003 A 61.624998,61.624998 0 0 0 37.325,0.34999949 M 49.649999,16.948067 A 59.159997,59.159997 0 0 0 33.05192,0.34999949 M 49.649999,21.652972 A 56.694997,56.694997 0 0 0 28.347017,0.34999949 M 49.649999,27.057906 A 54.229999,54.229999 0 0 0 22.942096,0.34999949 M 49.649999,33.866298 A 51.764998,51.764998 0 0 0 16.1337,0.34999949 M 49.649999,49.649989 A 49.299997,49.299997 0 0 0 0.34999949,0.34999949 M 47.185,49.649989 A 46.834999,46.834999 0 0 0 0.34999949,2.8149951 M 44.72,49.649989 A 44.369998,44.369998 0 0 0 0.34999949,5.2799906 M 42.254999,49.649989 A 41.904997,41.904997 0 0 0 0.34999949,7.7450123 M 39.790001,49.649989 A 39.439999,39.439999 0 0 0 0.34999949,10.210008 M 37.325,49.649989 A 36.974998,36.974998 0 0 0 0.34999949,12.675003 M 34.859999,49.649989 A 34.509998,34.509998 0 0 0 0.34999949,15.139998 M 32.395001,49.649989 A 32.044999,32.044999 0 0 0 0.34999949,17.604994 M 29.93,49.649989 A 29.579999,29.579999 0 0 0 0.34999949,20.069989 M 27.465,49.649989 A 27.114998,27.114998 0 0 0 0.34999949,22.535011 M 24.999997,49.649989 A 24.649999,24.649999 0 0 0 0.34999949,25.000007 M 22.534998,49.649989 A 22.184999,22.184999 0 0 0 0.34999949,27.465003 M 20.069998,49.649989 A 19.719999,19.719999 0 0 0 0.34999949,29.929999 M 17.604998,49.649989 A 17.254999,17.254999 0 0 0 0.34999949,32.394994 M 15.139998,49.649989 A 14.789999,14.789999 0 0 0 0.34999949,34.85999 M 12.674999,49.649989 A 12.325,12.325 0 0 0 0.34999949,37.325011 M 10.209999,49.649989 A 9.8599994,9.8599994 0 0 0 0.34999949,39.790007 M 7.7449994,49.649989 A 7.3949999,7.3949999 0 0 0 0.34999949,42.255002 M 5.2799992,49.649989 A 4.9299997,4.9299997 0 0 0 0.34999949,44.719998 M 2.8149995,49.649989 A 2.4649999,2.4649999 0 0 0 0.34999949,47.184993 M 0.34999949,49.649989 H 3.8010003 M 0.34999949,49.649989 H 3.8010003 M 0.34999949,49.649989 H 3.8010003" />
+</pattern>
 <pattern id="sand" width="50" height="50" patternUnits="userSpaceOnUse">
    <path style="fill: white;" d="M 0 0 50 0 50 50 0 50" />
    <path
@@ -5,6 +5,20 @@
    </g>
    <g id="door-tag">
        <circle cy="1.75" r="5" fill="white" stroke="black" style="stroke-width: 0.25;" />
-        <line x1="-5" y1="1.75" x2="5" y2="1.75" style="stroke:black; stroke-width: 0.25;" />
+        <line x1="-5" y1="1.75" x2="5" y2="1.75" style="stroke: black; stroke-width: 0.25;" />
+    </g>
+    <g id="elevation-arrow">
+        <path style="fill: black;" d="M -7.07106 0 0 -7.07106 7.07106 0" />
+    </g>
+    <g id="elevation-tag">
+        <circle r="5" fill="white" stroke="black" style="stroke-width: 0.25;" />
+        <line x1="-5" y1="0" x2="5" y2="0" style="stroke: black; stroke-width: 0.25;" />
+    </g>
+    <g id="section-arrow">
+        <path style="fill: black;" d="M -7.07106 0 0 -7.07106 7.07106 0" />
+    </g>
+    <g id="section-tag">
+        <circle r="5" fill="white" stroke="black" style="stroke-width: 0.25;" />
+        <line x1="-5" y1="0" x2="5" y2="0" style="stroke: black; stroke-width: 0.25;" />
    </g>
 </svg>
@@ -173,7 +173,7 @@
         style="stroke-width:0.999999px"
         y="1036.1166"
         x="3030.9653"
-         id="tspan2527">{{revision}}</tspan></text>
+         id="tspan2527">{{Revision}}</tspan></text>
    <text
       xml:space="preserve"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:13.3918px;line-height:125%;font-family:'OpenGost Type B TT';-inkscape-font-specification:'OpenGost Type B TT';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.999999px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
@@ -183,7 +183,7 @@
         id="tspan2531"
         x="2804.7021"
         y="1036.1166"
-         style="stroke-width:0.999999px">{{number}}</tspan></text>
+         style="stroke-width:0.999999px">{{Identification}} - {{Name}}</tspan></text>
  </g>
  <g
     transform="matrix(0.26458333,0,0,0.26458334,-3.180917e-5,297.00003)"
@@ -169,7 +169,7 @@
       style="stroke-width:0.264583px"
       y="397.13919"
       x="554.94287"
-       id="tspan2527">{{revision}}</tspan></text>
+       id="tspan2527">{{Revision}}</tspan></text>
  <text
     xml:space="preserve"
     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.54325px;line-height:125%;font-family:'OpenGost Type B TT';-inkscape-font-specification:'OpenGost Type B TT';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal;text-align:start;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.264583px;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
@@ -179,7 +179,7 @@
       id="tspan2531"
       x="495.07742"
       y="397.13919"
-       style="stroke-width:0.264583px">{{number}}</tspan></text>
+       style="stroke-width:0.264583px">{{Identification}} - {{Name}}</tspan></text>
  <g
     style="stroke-width:3.77953"
     id="g90669"
@@ -172,7 +172,7 @@
         id="tspan2527"
         x="544.94287"
         y="284.13919"
-         style="stroke-width:0.264583px">{{revision}}</tspan></text>
+         style="stroke-width:0.264583px">{{Revision}}</tspan></text>
    <text
       id="text2533"
       y="284.13919"
@@ -182,7 +182,7 @@
         style="stroke-width:0.264583px"
         y="284.13919"
         x="485.07742"
-         id="tspan2531">{{number}}</tspan></text>
+         id="tspan2531">{{Identification}} - {{Name}}</tspan></text>
  </g>
  <g
     style="stroke-width:3.77953"
@@ -70,7 +70,7 @@
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.96055365px;font-family:'OpenGost Type B TT';-inkscape-font-specification:'OpenGost Type B TT';text-align:center;text-anchor:middle;stroke-width:0.26458332px"
         y="103.10933"
         x="32.822662"
-         id="tspan857">{{no}}</tspan></text>
+         id="tspan857">{{Identification}}</tspan></text>
    <text
       xml:space="preserve"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:17.71626091px;line-height:125%;font-family:Arial;-inkscape-font-specification:Arial;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458329px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
@@ -80,7 +80,7 @@
         id="tspan861"
         x="39.12896"
         y="100.19173"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.54325247px;font-family:'OpenGost Type B TT';-inkscape-font-specification:'OpenGost Type B TT';text-align:start;text-anchor:start;stroke-width:0.26458329px">{{name}}</tspan></text>
+         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.54325247px;font-family:'OpenGost Type B TT';-inkscape-font-specification:'OpenGost Type B TT';text-align:start;text-anchor:start;stroke-width:0.26458329px">{{Name}}</tspan></text>
    <text
       id="text867"
       y="105.0553"
@@ -90,6 +90,6 @@
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.54325247px;font-family:'OpenGost Type B TT';-inkscape-font-specification:'OpenGost Type B TT';text-align:start;text-anchor:start;stroke-width:0.26458332px"
         y="105.0553"
         x="39.285267"
-         id="tspan865">{{scale}}</tspan></text>
+         id="tspan865">{{Scale}}</tspan></text>
  </g>
 </svg>
@@ -48,7 +48,7 @@ class IfcExporter:
            self.sync_deletions()
            self.sync_all_objects()
            self.sync_edited_objects()
-        extension = self.ifc_export_settings.output_file.split(".")[-1]
+        extension = self.ifc_export_settings.output_file.split(".")[-1].lower()
        if extension == "ifczip":
            with tempfile.TemporaryDirectory() as unzipped_path:
                filename, ext = os.path.splitext(os.path.basename(self.ifc_export_settings.output_file))
@@ -97,6 +97,7 @@ class IfcExporter:
            except:
                continue
            ifcopenshell.api.run("root.remove_product", self.file, **{"product": product})
+        IfcStore.deleted_ids.clear()
        return results

    def sync_all_objects(self):
@@ -148,7 +149,7 @@ class IfcExporter:
        return checksum != str([s.id() for s in tool.Geometry.get_styles(obj) if s])

    def sync_object_placement(self, obj):
-        if not self.has_object_moved(obj):
+        if not tool.Ifc.is_moved(obj):
            return
        blender_matrix = np.array(obj.matrix_world)
        element = self.file.by_id(obj.BIMObjectProperties.ifc_definition_id)
@@ -162,17 +163,6 @@ class IfcExporter:
        blenderbim.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
        return element

-    def has_object_moved(self, obj):
-        if not obj.BIMObjectProperties.location_checksum:
-            return True  # Let's be conservative
-        loc_check = np.frombuffer(eval(obj.BIMObjectProperties.location_checksum))
-        rot_check = np.frombuffer(eval(obj.BIMObjectProperties.rotation_checksum))
-        loc_real = np.array(obj.matrix_world.translation).flatten()
-        rot_real = np.array(obj.matrix_world.to_3x3()).flatten()
-        if np.allclose(loc_check, loc_real, atol=1e-4) and np.allclose(rot_check, rot_real, atol=1e-2):
-            return False
-        return True
-
    def sync_grid_axis_object_placement(self, obj, element):
        grid = (element.PartOfU or element.PartOfV or element.PartOfW)[0]
        grid_obj = tool.Ifc.get_object(grid)
@@ -26,9 +26,7 @@ from blenderbim.bim.module.drawing.prop import RasterStyleProperty
 from bpy.app.handlers import persistent
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.owner.prop import get_user_person, get_user_organisation
-from ifcopenshell.api.attribute.data import Data as AttributeData
 from ifcopenshell.api.material.data import Data as MaterialData
-from ifcopenshell.api.style.data import Data as StyleData
 from ifcopenshell.api.type.data import Data as TypeData


@@ -68,11 +66,10 @@ def name_callback(obj, data):
    if isinstance(obj, bpy.types.Material):
        if obj.BIMObjectProperties.ifc_definition_id:
            IfcStore.get_file().by_id(obj.BIMObjectProperties.ifc_definition_id).Name = obj.name
-            AttributeData.load(IfcStore.get_file(), obj.BIMObjectProperties.ifc_definition_id)
            MaterialData.load_materials()
        if obj.BIMMaterialProperties.ifc_style_id:
            IfcStore.get_file().by_id(obj.BIMMaterialProperties.ifc_style_id).Name = obj.name
-            StyleData.load(IfcStore.get_file(), obj.BIMMaterialProperties.ifc_style_id)
+        refresh_ui_data()
        return

    if not obj.BIMObjectProperties.ifc_definition_id or "/" not in obj.name:
@@ -96,7 +93,7 @@ def name_callback(obj, data):
    if element.is_a("IfcTypeProduct"):
        TypeData.purge()
    element.Name = "/".join(obj.name.split("/")[1:])
-    AttributeData.load(IfcStore.get_file(), obj.BIMObjectProperties.ifc_definition_id)
+    refresh_ui_data()


 def color_callback(obj, data):
@@ -160,12 +157,12 @@ def loadIfcStore(scene):
    if not IfcStore.get_file():
        return
    IfcStore.get_schema()
-    IfcStore.reload_linked_elements()
+    IfcStore.relink_all_objects()


@persistent
 def undo_pre(scene):
-    IfcStore.update_undo_redo_stack_objects()
+    IfcStore.track_undo_redo_stack_object_map()


@persistent
@@ -174,13 +171,13 @@ def undo_post(scene):
        IfcStore.last_transaction = bpy.context.scene.BIMProperties.last_transaction
        IfcStore.undo()
        purge_module_data()
-    IfcStore.update_undo_redo_stack_objects()
-    IfcStore.reload_linked_elements(objects=[bpy.data.objects.get(o) for o in IfcStore.undo_redo_stack_objects])
+    IfcStore.track_undo_redo_stack_selected_objects()
+    IfcStore.reload_undo_redo_stack_objects()


@persistent
 def redo_pre(scene):
-    IfcStore.update_undo_redo_stack_objects()
+    IfcStore.track_undo_redo_stack_object_map()


@persistent
@@ -189,8 +186,8 @@ def redo_post(scene):
        IfcStore.last_transaction = bpy.context.scene.BIMProperties.last_transaction
        IfcStore.redo()
        purge_module_data()
-    IfcStore.update_undo_redo_stack_objects()
-    IfcStore.reload_linked_elements(objects=[bpy.data.objects.get(o) for o in IfcStore.undo_redo_stack_objects])
+    IfcStore.track_undo_redo_stack_selected_objects()
+    IfcStore.reload_undo_redo_stack_objects()


@persistent
@@ -16,6 +16,7 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

+# from datetime import date
 import bpy
 import json
 import math
@@ -38,11 +39,19 @@ def draw_attribute(attribute, layout, copy_operator=None):
    if not value_name:
        layout.label(text=attribute.name)
        return
-    layout.prop(
-        attribute,
-        value_name,
-        text=attribute.name,
-    )
+    if value_name == "enum_value":
+        prop_with_search(layout, attribute, "enum_value", text=attribute.name)
+    else:
+        layout.prop(
+            attribute,
+            value_name,
+            text=attribute.name,
+        )
+    if "ScheduleDuration" in attribute.name:
+        layout.prop(bpy.context.scene.BIMDuration, "duration_days", text="D")
+        layout.prop(bpy.context.scene.BIMDuration, "duration_hours", text="H")
+        layout.prop(bpy.context.scene.BIMDuration, "duration_minutes", text="M")
+
    if attribute.is_optional:
        layout.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
    if copy_operator:
@@ -75,6 +84,7 @@ def import_attribute(attribute, props, data, callback=None):
    new.is_optional = attribute.optional()
    new.data_type = data_type if isinstance(data_type, str) else ""
    is_handled_by_callback = callback(attribute.name(), new, data) if callback else None
+
    if is_handled_by_callback:
        pass  # Our job is done
    elif is_handled_by_callback is False:
@@ -105,6 +115,64 @@ def export_attributes(props, callback=None):
    return attributes


+def prop_with_search(layout, data, prop_name, **kwargs):
+    # kwargs are layout.prop arguments (text, icon, etc.)
+    row = layout.row(align=True)
+    # Magick courtesy of https://blender.stackexchange.com/a/203443/86891
+    row.context_pointer_set(name="data", data=data)
+    row.prop(data, prop_name, **kwargs)
+    op = row.operator("bim.enum_property_search", text="", icon="VIEWZOOM")
+    op.prop_name = prop_name
+
+
+def get_enum_items(data, prop_name, context):
+    # Retrieve items from a dynamic EnumProperty, which is otherwise not supported
+    # Or throws an error in the console when the items callback returns an empty list
+    # See https://blender.stackexchange.com/q/215781/86891
+    prop = data.__annotations__[prop_name]
+    items = prop.keywords.get("items")
+    if items is None:
+        return
+    if not isinstance(items, (list, tuple)):
+        # items are retrieved through a callback, not a static list :
+        items = items(data, context)
+    return items
+
+
+def get_obj_ifc_definition_id(context, obj, obj_type):
+    if obj_type == "Object":
+        return bpy.data.objects.get(obj).BIMObjectProperties.ifc_definition_id
+    elif obj_type == "Material":
+        return bpy.data.materials.get(obj).BIMObjectProperties.ifc_definition_id
+    elif obj_type == "Task":
+        return context.scene.BIMTaskTreeProperties.tasks[
+            context.scene.BIMWorkScheduleProperties.active_task_index
+        ].ifc_definition_id
+    elif obj_type == "Cost":
+        return context.scene.BIMCostProperties.cost_items[
+            context.scene.BIMCostProperties.active_cost_item_index
+        ].ifc_definition_id
+    elif obj_type == "Resource":
+        return context.scene.BIMResourceTreeProperties.resources[
+            context.scene.BIMResourceProperties.active_resource_index
+        ].ifc_definition_id
+    elif obj_type == "Profile":
+        return context.scene.BIMProfileProperties.profiles[
+            context.scene.BIMProfileProperties.active_profile_index
+        ].ifc_definition_id
+    elif obj_type == "WorkSchedule":
+        return context.scene.BIMWorkScheduleProperties.active_work_schedule_id
+
+
+# hack to close popup
+# https://blender.stackexchange.com/a/202576/130742
+def close_operator_panel(event):
+    x, y = event.mouse_x, event.mouse_y
+    bpy.context.window.cursor_warp(10, 10)
+    move_back = lambda: bpy.context.window.cursor_warp(x, y)
+    bpy.app.timers.register(move_back, first_interval=0.01)
+
+
 class IfcHeaderExtractor:
    def __init__(self, filepath: str):
        self.filepath = filepath
@@ -39,15 +39,18 @@ class IfcStore:
    edited_objs = set()
    pset_template_path = ""
    pset_template_file = None
+    classification_path = ""
+    classification_file = None
    library_path = ""
    library_file = None
    element_listeners = set()
    undo_redo_stack_objects = set()
+    undo_redo_stack_object_names = {}
    current_transaction = ""
    last_transaction = ""
    history = []
    future = []
-    schema_identifiers = ["IFC4", "IFC2X3"]
+    schema_identifiers = ["IFC4", "IFC2X3", "IFC4X3"]

    @staticmethod
    def purge():
@@ -64,7 +67,10 @@ class IfcStore:
        IfcStore.pset_template_file = None
        IfcStore.library_path = ""
        IfcStore.library_file = None
-        IfcStore.schema_identifiers = ["IFC4", "IFC2X3"]
+        IfcStore.last_transaction = ""
+        IfcStore.history = []
+        IfcStore.future = []
+        IfcStore.schema_identifiers = ["IFC4", "IFC2X3", "IFC4X3"]

    @staticmethod
    def get_file():
@@ -86,6 +92,7 @@ class IfcStore:
            ifc_hash = hashlib.md5(ifc_key.encode("utf-8")).hexdigest()
            IfcStore.cache_path = os.path.join(bpy.context.scene.BIMProperties.data_dir, "cache", f"{ifc_hash}.h5")
            cache_settings = ifcopenshell.geom.settings()
+            cache_settings.set(cache_settings.STRICT_TOLERANCE, True)
            try:
                IfcStore.cache = ifcopenshell.geom.serializers.hdf5(IfcStore.cache_path, cache_settings)
            except:
@@ -146,14 +153,32 @@ class IfcStore:
        IfcStore.element_listeners.add(callback)

    @staticmethod
-    def update_undo_redo_stack_objects():
+    def track_undo_redo_stack_object_map():
+        """Keeps track of currently mapped object names, typically during undo and redo
+
+        When any Blender object is stored outside a Blender PointerProperty, such as
+        in a regular Python list, there is the likely probability that the object
+        will be invalidated when undo or redo occurs. Object invalidation seems to
+        occur whenever an object is affected during an operation.
+
+        For example, if an operator deletes a modifier on o1, then o1 will be invalidated.
+        """
+        for key, value in IfcStore.id_map.items():
+            try:
+                IfcStore.undo_redo_stack_object_names[key] = value.name
+            except:
+                continue
+
+    @staticmethod
+    def track_undo_redo_stack_selected_objects():
        """Keeps track of selected object names, typically during undo and redo

        When any Blender object is stored outside a Blender PointerProperty, such as
        in a regular Python list, there is the likely probability that the object
        will be invalidated when undo or redo occurs. Object invalidation seems to
-        only occur for selected objects either pre/post undo/redo event, including
-        selected objects for consecutive undo/redos, and all children.
+        occur for selected objects either pre/post undo/redo event, including
+        selected objects for consecutive undo/redos, and all children. This is
+        important because selected objects are often deleted from the scene.

        So if I first select o1, then o2, then o3, then press undo, o3 will be
        invalidated. If instead I press undo twice, o3 and o2 will be invalidated.
@@ -168,14 +193,23 @@ class IfcStore:
        IfcStore.undo_redo_stack_objects |= objects

    @staticmethod
-    def reload_linked_elements(objects=None):
+    def reload_undo_redo_stack_objects():
+        """Reloads any invalidated objects after undo or redo
+
+        After an undo or redo operation, objects may have been invalidated in
+        our id_map and guid_map. Invalidated objects are typically those that
+        have been manipulated or deleted. This checks the cache of mapped and
+        selected objects prior to the operation and ensures that if the object
+        is invalidated, they are reloaded based on the object name that was
+        tracked prior to the undo / redo.
+        """
        file = IfcStore.get_file()
        if not file:
            return
-        if objects is None:
-            objects = bpy.data.objects

-        for obj in objects:
+        # First, reload objects that were selected or active
+        for name in IfcStore.undo_redo_stack_objects:
+            obj = bpy.data.objects.get(name)
            if not obj:
                continue
            if not obj.BIMObjectProperties.ifc_definition_id:
@@ -186,6 +220,44 @@ class IfcStore:
                data["guid"] = element.GlobalId
            IfcStore.commit_link_element(data)

+        # Scan for any straggling invalidated objects which were indirectly affected and reload them too.
+        for key, value in IfcStore.id_map.items():
+            try:
+                value.name
+            except:
+                obj = bpy.data.objects.get(IfcStore.undo_redo_stack_object_names[key])
+                if not obj or not obj.BIMObjectProperties.ifc_definition_id:
+                    continue
+                element = file.by_id(obj.BIMObjectProperties.ifc_definition_id)
+                data = {"id": element.id(), "obj": obj.name}
+                if hasattr(element, "GlobalId"):
+                    data["guid"] = element.GlobalId
+                IfcStore.commit_link_element(data)
+
+    @staticmethod
+    def relink_all_objects():
+        if not IfcStore.get_file():
+            return
+        for obj in bpy.data.objects:
+            IfcStore.relink_object(obj)
+        for obj in bpy.data.materials:
+            IfcStore.relink_object(obj)
+
+    @staticmethod
+    def relink_object(obj):
+        if not obj:
+            return
+        if obj.BIMObjectProperties.ifc_definition_id:
+            element = IfcStore.get_file().by_id(obj.BIMObjectProperties.ifc_definition_id)
+            data = {"id": element.id(), "obj": obj.name}
+            if hasattr(element, "GlobalId"):
+                data["guid"] = element.GlobalId
+            IfcStore.commit_link_element(data)
+        if hasattr(obj, "BIMMaterialProperties") and obj.BIMMaterialProperties.ifc_style_id:
+            element = IfcStore.get_file().by_id(obj.BIMMaterialProperties.ifc_style_id)
+            data = {"id": element.id(), "obj": obj.name}
+            IfcStore.commit_link_element(data)
+
    @staticmethod
    def delete_element(element):
        IfcStore.deleted_ids.add(element.id())
@@ -239,6 +311,8 @@ class IfcStore:
    @staticmethod
    def commit_link_element(data):
        obj = bpy.data.objects.get(data["obj"])
+        if not obj:
+            obj = bpy.data.materials.get(data["obj"])
        IfcStore.id_map[data["id"]] = obj
        if "guid" in data:
            IfcStore.guid_map[data["guid"]] = obj
@@ -311,6 +385,7 @@ class IfcStore:
    @staticmethod
    def begin_transaction(operator):
        IfcStore.undo_redo_stack_objects = set()
+        IfcStore.undo_redo_stack_object_names = {}
        IfcStore.current_transaction = str(uuid.uuid4())
        operator.transaction_key = IfcStore.current_transaction

@@ -121,7 +121,14 @@ class MaterialCreator:
    def parse_representation_item(self, item):
        if not item.StyledByItem:
            return
-        style_ids = [e.id() for e in self.ifc_importer.file.traverse(item.StyledByItem[0]) if e.is_a("IfcSurfaceStyle")]
+        style_ids = []
+        styles = list(item.StyledByItem[0].Styles)
+        while styles:
+            style = styles.pop()
+            if style.is_a("IfcSurfaceStyle"):
+                style_ids.append(style.id())
+            elif style.is_a("IfcPresentationStyleAssignment"):
+                styles.extend(style.Styles)
        if not style_ids:
            return
        for style_id in style_ids:
@@ -163,12 +170,12 @@ class IfcImporter:
        self.settings = ifcopenshell.geom.settings()
        self.settings.set_deflection_tolerance(self.ifc_import_settings.deflection_tolerance)
        self.settings.set_angular_tolerance(self.ifc_import_settings.angular_tolerance)
-        # See https://github.com/IfcOpenShell/IfcOpenShell/issues/2053
-        # self.settings.set(self.settings.STRICT_TOLERANCE, True)
+        self.settings.set(self.settings.STRICT_TOLERANCE, True)
        self.settings_native = ifcopenshell.geom.settings()
        self.settings_native.set(self.settings_native.INCLUDE_CURVES, True)
        self.settings_2d = ifcopenshell.geom.settings()
        self.settings_2d.set(self.settings_2d.INCLUDE_CURVES, True)
+        self.settings_2d.set(self.settings.STRICT_TOLERANCE, True)
        self.project = None
        self.collections = {}
        self.elements = set()
@@ -237,24 +244,19 @@ class IfcImporter:
        self.profile_code("Create spatial elements")
        self.create_structural_items()
        self.profile_code("Create structural items")
-        self.create_type_products()
-        self.profile_code("Create type products")
+        if not self.ifc_import_settings.is_coordinating:
+            self.create_element_types()
+            self.profile_code("Create element types")
        self.place_objects_in_collections()
        self.profile_code("Place objects in collections")
-        if self.ifc_import_settings.should_merge_by_class:
-            self.merge_by_class()
-            self.profile_code("Merging by class")
-        elif self.ifc_import_settings.should_merge_by_material:
-            self.merge_by_material()
-            self.profile_code("Merging by material")
-        if self.ifc_import_settings.should_merge_materials_by_colour or len(self.material_creator.materials) > 300:
-            self.merge_materials_by_colour()
-            self.profile_code("Merging by colour")
        self.add_project_to_scene()
        self.profile_code("Add project to scene")
        if self.ifc_import_settings.should_clean_mesh and len(self.file.by_type("IfcElement")) < 1000:
            self.clean_mesh()
            self.profile_code("Mesh cleaning")
+        if self.ifc_import_settings.should_merge_materials_by_colour or len(self.material_creator.materials) > 300:
+            self.merge_materials_by_colour()
+            self.profile_code("Merging by colour")
        self.set_default_context()
        self.profile_code("Setting default context")
        self.update_progress(100)
@@ -270,7 +272,9 @@ class IfcImporter:

    def is_point_far_away(self, point, is_meters=True):
        # Locations greater than 1km are not considered "small sites" according to the georeferencing guide
-        limit = 1000 if is_meters else (1000 / self.unit_scale)
+        # Users can configure this if they have to handle larger sites but beware of surveying precision
+        limit = self.ifc_import_settings.distance_limit
+        limit = limit if is_meters else (limit / self.unit_scale)
        coords = point
        if hasattr(point, "Coordinates"):
            coords = point.Coordinates
@@ -305,14 +309,29 @@ class IfcImporter:
            self.settings_2d.set_context_ids(self.plan_contexts)

    def process_element_filter(self):
+        offset = self.ifc_import_settings.element_offset
+        offset_limit = offset + self.ifc_import_settings.element_limit
+
        if self.ifc_import_settings.has_filter:
-            self.elements = set(self.ifc_import_settings.elements)
+            self.elements = self.ifc_import_settings.elements
+            if isinstance(self.elements, set):
+                self.elements = list(self.elements)
            # TODO: enable filtering for annotations
            self.annotations = set(self.file.by_type("IfcAnnotation"))
        else:
-            self.elements = set(self.file.by_type("IfcElement"))
+            self.elements = self.file.by_type("IfcElement")
            self.annotations = set(self.file.by_type("IfcAnnotation"))

+        if self.ifc_import_settings.is_coordinating:
+            self.elements = [e for e in self.elements if e.Representation and not e.is_a("IfcFeatureElement")]
+
+        self.elements = set(self.elements[offset:offset_limit])
+
+        if self.ifc_import_settings.has_filter or offset or offset_limit < len(self.elements):
+            self.element_types = set([ifcopenshell.util.element.get_type(e) for e in self.elements])
+        else:
+            self.element_types = set(self.file.by_type("IfcElementType"))
+
        if self.ifc_import_settings.has_filter and self.ifc_import_settings.should_filter_spatial_elements:
            self.spatial_elements = self.get_spatial_elements_filtered_by_elements(self.elements)
        else:
@@ -355,21 +374,38 @@ class IfcImporter:
                "type": "IfcSweptDiskSolid",
            }
            return True
+
+        if not self.ifc_import_settings.should_use_native_meshes:
+            return False  # Performance improvements only occur on edge cases currently
+
        # FacetedBreps (without voids) are meshes. See #841.
-        # Commented out as seems currently too slow.
-        # if self.is_native_faceted_brep(representations):
-        #    self.native_data[element.GlobalId] = {
-        #        "representations": representations,
-        #        "representation": self.get_body_representation(element.Representation.Representations),
-        #        "type": "IfcFacetedBrep",
-        #    }
-        #    return True
+        if self.is_native_faceted_brep(representations):
+            self.native_data[element.GlobalId] = {
+                "representations": representations,
+                "representation": self.get_body_representation(element.Representation.Representations),
+                "type": "IfcFacetedBrep",
+            }
+            return True
+
+        if self.is_native_face_based_surface_model(representations):
+            self.native_data[element.GlobalId] = {
+                "representations": representations,
+                "representation": self.get_body_representation(element.Representation.Representations),
+                "type": "IfcFaceBasedSurfaceModel",
+            }
+            return True

    def is_native_swept_disk_solid(self, representations):
        for representation in representations:
            items = representation["raw"].Items or []  # Be forgiving of invalid IFCs because Revit :(
            if len(items) == 1 and items[0].is_a("IfcSweptDiskSolid"):
                return True
+            elif (
+                items[0].is_a("IfcSweptDiskSolid")
+                and len({i.is_a() for i in items}) == 1
+                and len({i.Radius for i in items}) == 1
+            ):
+                return True
        return False

    def is_native_faceted_brep(self, representations):
@@ -379,6 +415,13 @@ class IfcImporter:
                    return False
        return True

+    def is_native_face_based_surface_model(self, representations):
+        for representation in representations:
+            for i in representation["raw"].Items:
+                if i.is_a() != "IfcFaceBasedSurfaceModel":
+                    return False
+        return True
+
    def get_products_from_shape_representation(self, element):
        products = [pr.ShapeOfProduct[0] for pr in element.OfProductRepresentation]
        for rep_map in element.RepresentationMap:
@@ -392,6 +435,8 @@ class IfcImporter:
        props = bpy.context.scene.BIMGeoreferenceProperties
        if props.has_blender_offset:
            return
+        if self.ifc_import_settings.false_origin:
+            return self.set_manual_blender_offset()
        if self.file.schema == "IFC2X3":
            project = self.file.by_type("IfcProject")[0]
        else:
@@ -404,6 +449,13 @@ class IfcImporter:
            return self.guess_georeferencing(building)
        return self.guess_absolute_coordinate()

+    def set_manual_blender_offset(self):
+        props = bpy.context.scene.BIMGeoreferenceProperties
+        props.blender_eastings = str(self.ifc_import_settings.false_origin[0])
+        props.blender_northings = str(self.ifc_import_settings.false_origin[1])
+        props.blender_orthogonal_height = str(self.ifc_import_settings.false_origin[2])
+        props.has_blender_offset = True
+
    def guess_georeferencing(self, element):
        if not element.ObjectPlacement or not element.ObjectPlacement.is_a("IfcLocalPlacement"):
            return
@@ -420,10 +472,12 @@ class IfcImporter:
        props.has_blender_offset = True

    def guess_absolute_coordinate(self):
-        # Civil BIM applications like to work in absolute coordinates, where the ObjectPlacement is 0,0,0 but each
-        # individual coordinate of the shape representation is in absolute values.
+        # Civil BIM applications like to work in absolute coordinates, where the
+        # ObjectPlacement is usually 0,0,0 (but not always, so we'll need to
+        # check for the actual transformation) but each individual coordinate of
+        # the shape representation is in absolute values.
        offset_point = self.get_offset_point()
-        if not offset_point:
+        if offset_point is None:
            return
        props = bpy.context.scene.BIMGeoreferenceProperties
        props.blender_eastings = str(offset_point[0])
@@ -433,34 +487,41 @@ class IfcImporter:

    def get_offset_point(self):
        elements_checked = 0
-        # If more than these points aren't far away, the file probably isn't absolutely positioned
-        element_checking_threshold = 100
-        if self.file.schema == "IFC2X3":
-            # IFC2X3 does not have IfcCartesianPointList3D
-            point_lists = []
-        else:
-            point_lists = self.file.by_type("IfcCartesianPointList3D")
-        for point_list in point_lists:
-            elements_checked += 1
-            if elements_checked > element_checking_threshold:
-                return
-            for i, point in enumerate(point_list.CoordList):
-                if len(point) == 3 and self.is_point_far_away(point, is_meters=False):
-                    return point
-
-        for point in self.file.by_type("IfcCartesianPoint"):
-            is_used_in_placement = False
-            for inverse in self.file.get_inverse(point):
-                if inverse.is_a("IfcAxis2Placement3D"):
-                    is_used_in_placement = True
-                    break
-            if is_used_in_placement:
+        # If more than these elements aren't far away, the file probably isn't absolutely positioned
+        element_checking_threshold = 10
+        for element in self.file.by_type("IfcElement"):
+            if not element.Representation:
                continue
            elements_checked += 1
            if elements_checked > element_checking_threshold:
                return
-            if len(point.Coordinates) == 3 and self.is_point_far_away(point, is_meters=False):
-                return point.Coordinates
+            if not self.does_element_likely_have_geometry_far_away(element):
+                continue
+            shape = ifcopenshell.geom.create_shape(self.settings, element)
+            m = shape.transformation.matrix.data
+            mat = np.array(
+                ([m[0], m[3], m[6], m[9]], [m[1], m[4], m[7], m[10]], [m[2], m[5], m[8], m[11]], [0, 0, 0, 1])
+            )
+            point = np.array(
+                (
+                    shape.geometry.verts[0] / self.unit_scale,
+                    shape.geometry.verts[1] / self.unit_scale,
+                    shape.geometry.verts[2] / self.unit_scale,
+                    0.0,
+                )
+            )
+            return mat @ point
+
+    def does_element_likely_have_geometry_far_away(self, element):
+        for representation in element.Representation.Representations:
+            for subelement in self.file.traverse(representation):
+                if subelement.is_a("IfcCartesianPointList3D"):
+                    for point in subelement.CoordList:
+                        if len(point) == 3 and self.is_point_far_away(point, is_meters=False):
+                            return True
+                if subelement.is_a("IfcCartesianPoint"):
+                    if len(subelement.Coordinates) == 3 and self.is_point_far_away(subelement, is_meters=False):
+                        return True

    def apply_blender_offset_to_matrix_world(self, obj, matrix):
        props = bpy.context.scene.BIMGeoreferenceProperties
@@ -478,11 +539,6 @@ class IfcImporter:
                    float(props.blender_x_axis_ordinate),
                )

-        if self.ifc_import_settings.should_offset_model:
-            matrix[0, 3] += self.ifc_import_settings.model_offset_coordinates[0]
-            matrix[1, 3] += self.ifc_import_settings.model_offset_coordinates[1]
-            matrix[2, 3] += self.ifc_import_settings.model_offset_coordinates[2]
-
        return mathutils.Matrix(matrix.tolist())

    def find_decomposed_ifc_class(self, element, ifc_class):
@@ -506,6 +562,9 @@ class IfcImporter:
            if grid.Representation:
                shape = ifcopenshell.geom.create_shape(self.settings_2d, grid)
            grid_obj = self.create_product(grid, shape)
+            if bpy.context.preferences.addons["blenderbim"].preferences.lock_grids_on_import:
+                grid_obj.lock_location = (True, True, True)
+                grid_obj.lock_rotation = (True, True, True)
            collection = bpy.data.collections.new(self.get_name(grid))
            u_axes = bpy.data.collections.new("UAxes")
            collection.children.link(u_axes)
@@ -523,23 +582,20 @@ class IfcImporter:
            shape = ifcopenshell.geom.create_shape(self.settings_2d, axis.AxisCurve)
            mesh = self.create_mesh(axis, shape)
            obj = bpy.data.objects.new(f"IfcGridAxis/{axis.AxisTag}", mesh)
+            if bpy.context.preferences.addons["blenderbim"].preferences.lock_grids_on_import:
+                obj.lock_location = (True, True, True)
+                obj.lock_rotation = (True, True, True)
            self.link_element(axis, obj)
            self.set_matrix_world(obj, grid_obj.matrix_world)
            grid_collection.objects.link(obj)

-    def create_type_products(self):
-        # TODO allow filtering of spatial elements too
-        if self.ifc_import_settings.has_filter:
-            type_products = set([ifcopenshell.util.element.get_type(e) for e in self.elements])
-        else:
-            type_products = self.file.by_type("IfcTypeProduct")
-
-        for type_product in type_products:
-            if not type_product:
+    def create_element_types(self):
+        for element_type in self.element_types:
+            if not element_type:
                continue
-            self.create_type_product(type_product)
+            self.create_element_type(element_type)

-    def create_type_product(self, element):
+    def create_element_type(self, element):
        self.ifc_import_settings.logger.info("Creating object %s", element)
        representation_map = self.get_type_product_body_representation_map(element)
        mesh = None
@@ -573,13 +629,20 @@ class IfcImporter:
                return representation_map

    def create_native_elements(self):
-        total = 0
+        progress = 0
        checkpoint = time.time()
+        total = len(self.native_elements)
        for element in self.native_elements:
-            total += 1
-            if total % 250 == 0:
-                print("{} elements processed in {:.2f}s ...".format(total, time.time() - checkpoint))
+            progress += 1
+            if progress % 250 == 0:
+                percent = round(progress / total * 100)
+                print(
+                    "{} / {} ({}%) elements processed in {:.2f}s ...".format(
+                        progress, total, percent, time.time() - checkpoint
+                    )
+                )
                checkpoint = time.time()
+                self.incrementally_merge_objects()
            native_data = self.native_data[element.GlobalId]
            representation = native_data["representation"]
            if not representation:
@@ -592,6 +655,8 @@ class IfcImporter:
                    mesh = self.create_native_swept_disk_solid(element, mesh_name)
                elif native_data["type"] == "IfcFacetedBrep":
                    mesh = self.create_native_faceted_brep(element, mesh_name)
+                elif native_data["type"] == "IfcFaceBasedSurfaceModel":
+                    mesh = self.create_native_faceted_brep(element, mesh_name)
                mesh.BIMMeshProperties.ifc_definition_id = representation.id()
                mesh.name = mesh_name
                self.meshes[mesh_name] = mesh
@@ -631,26 +696,32 @@ class IfcImporter:
            )
        else:
            iterator = ifcopenshell.geom.iterator(self.settings, self.file, include=products)
-        cache = IfcStore.get_cache()
-        if cache:
-            iterator.set_cache(cache)
+        if self.ifc_import_settings.should_cache:
+            cache = IfcStore.get_cache()
+            if cache:
+                iterator.set_cache(cache)
        valid_file = iterator.initialize()
        if not valid_file:
            return results
        checkpoint = time.time()
-        total = 0
+        progress = 0
+        total = len(products)
        start_progress = self.progress
        progress_range = 85 - start_progress
        while True:
-            total += 1
-            if total % 250 == 0:
+            progress += 1
+            if progress % 250 == 0:
+                percent_created = round(progress / total * 100)
+                percent_preprocessed = iterator.progress()
+                percent_average = (percent_created + percent_preprocessed) / 2
                print(
-                    "{} ({}%) elements processed in {:.2f}s ...".format(
-                        total, iterator.progress(), time.time() - checkpoint
+                    "{} / {} ({}% created, {}% preprocessed) elements processed in {:.2f}s ...".format(
+                        progress, total, percent_created, percent_preprocessed, time.time() - checkpoint
                    )
                )
                checkpoint = time.time()
-                self.update_progress((iterator.progress() / 100 * progress_range) + start_progress)
+                self.update_progress((percent_average / 100 * progress_range) + start_progress)
+                self.incrementally_merge_objects()
            shape = iterator.get()
            if shape:
                product = self.file.by_id(shape.guid)
@@ -669,6 +740,19 @@ class IfcImporter:
        print("Done creating geometry")
        return results

+    def incrementally_merge_objects(self):
+        if not self.ifc_import_settings.is_coordinating:
+            return
+        if self.ifc_import_settings.merge_mode == "IFC_CLASS":
+            self.merge_by_class()
+            self.profile_code("Merging by class")
+        elif self.ifc_import_settings.merge_mode == "IFC_TYPE":
+            self.merge_by_type()
+            self.profile_code("Merging by type")
+        elif self.ifc_import_settings.merge_mode == "MATERIAL":
+            self.merge_by_material()
+            self.profile_code("Merging by material")
+
    def create_structural_items(self):
        # Create structural collections
        self.structural_member_collection = bpy.data.collections.new("Members")
@@ -779,9 +863,10 @@ class IfcImporter:
            )
        else:
            iterator = ifcopenshell.geom.iterator(self.settings_2d, self.file, include=products)
-        cache = IfcStore.get_cache()
-        if cache:
-            iterator.set_cache(cache)
+        if self.ifc_import_settings.should_cache:
+            cache = IfcStore.get_cache()
+            if cache:
+                iterator.set_cache(cache)
        valid_file = iterator.initialize()
        if not valid_file:
            return results
@@ -795,7 +880,7 @@ class IfcImporter:
            shape = iterator.get()
            if shape:
                product = self.file.by_id(shape.guid)
-                self.create_product(self.file.by_id(shape.guid), shape)
+                self.create_product(product, shape)
                results.add(product)
            if not iterator.next():
                break
@@ -813,7 +898,7 @@ class IfcImporter:
        elif element.is_a("IfcAnnotation") and element.ObjectType == "DRAWING":
            mesh = self.create_camera(element, shape)
            self.link_mesh(shape, mesh)
-        elif element.is_a("IfcAnnotation") and self.is_curve_annotation(element):
+        elif element.is_a("IfcAnnotation") and self.is_curve_annotation(element) and shape:
            mesh = self.create_curve(element, shape)
            self.link_mesh(shape, mesh)
        elif shape:
@@ -852,8 +937,13 @@ class IfcImporter:
    def get_representation_item_material_name(self, item):
        if not item.StyledByItem:
            return
-        style_ids = [e.id() for e in self.file.traverse(item.StyledByItem[0]) if e.is_a("IfcSurfaceStyle")]
-        return style_ids[0] if style_ids else None
+        styles = list(item.StyledByItem[0].Styles)
+        while styles:
+            style = styles.pop()
+            if style.is_a("IfcSurfaceStyle"):
+                return style.id()
+            elif style.is_a("IfcPresentationStyleAssignment"):
+                styles.extend(style.Styles)

    def create_native_faceted_brep(self, element, mesh_name):
        # TODO: georeferencing?
@@ -902,22 +992,32 @@ class IfcImporter:
            self.convert_representation(item.MappingSource.MappedRepresentation)
        elif item.is_a() == "IfcFacetedBrep":
            self.convert_representation_item_faceted_brep(item)
+        elif item.is_a() == "IfcFaceBasedSurfaceModel":
+            self.convert_representation_item_face_based_surface_model(item)
+
+    def convert_representation_item_face_based_surface_model(self, item):
+        mesh = item.get_info_2(recursive=True)
+        for face_set in mesh["FbsmFaces"]:
+            self.convert_representation_item_face_set(item, face_set)

    def convert_representation_item_faceted_brep(self, item):
+        mesh = item.get_info_2(recursive=True)
+        return self.convert_representation_item_face_set(item, mesh["Outer"])
+
+    def convert_representation_item_face_set(self, item, mesh):
        # On a few occasions, we flatten a list. This seems to be the most efficient way to do it.
        # https://stackoverflow.com/questions/20112776/how-do-i-flatten-a-list-of-lists-nested-lists
-        mesh = item.get_info_2(recursive=True)

        # For huge face sets it might be better to do a "flatmap" instead of sum()
        # bounds = sum((f["Bounds"] for f in mesh["Outer"]["CfsFaces"] if len(f["Bounds"]) == 1), ())
-        bounds = tuple(chain.from_iterable(f["Bounds"] for f in mesh["Outer"]["CfsFaces"] if len(f["Bounds"]) == 1))
+        bounds = tuple(chain.from_iterable(f["Bounds"] for f in mesh["CfsFaces"] if len(f["Bounds"]) == 1))
        # Here are some untested alternatives, are they faster?
        # bounds = tuple((f["Bounds"] for f in mesh["Outer"]["CfsFaces"] if len(f["Bounds"]) == 1))[0]
        # bounds = chain.from_iterable(f["Bounds"] for f in mesh["Outer"]["CfsFaces"] if len(f["Bounds"]) == 1)

        polygons = [[(p["id"], p["Coordinates"]) for p in b["Bound"]["Polygon"]] for b in bounds]

-        for face in mesh["Outer"]["CfsFaces"]:
+        for face in mesh["CfsFaces"]:
            # Blender cannot handle faces with holes.
            if len(face["Bounds"]) > 1:
                inner_bounds = []
@@ -1015,6 +1115,7 @@ class IfcImporter:
                    polyline.points[-1].co = representation["matrix"] @ mathutils.Vector(v2)

        curve.bevel_depth = self.unit_scale * item.Radius
+        curve.use_fill_caps = True
        return curve

    def create_native_annotation(self, element, mesh_name):
@@ -1047,33 +1148,74 @@ class IfcImporter:

    def merge_by_class(self):
        merge_set = {}
-        for obj in self.added_data.values():
-            if not isinstance(obj, bpy.types.Object):
+        id_set = {}
+        for ifc_definition_id, obj in self.added_data.items():
+            if not isinstance(obj, bpy.types.Object) or not obj.data:
                continue
-            if "/" not in obj.name or "IfcRelAggregates" in obj.users_collection[0].name:
+            element = self.file.by_id(ifc_definition_id)
+            if not element.is_a("IfcElement"):
                continue
-            merge_set.setdefault(obj.name.split("/")[0], []).append(obj)
-        self.merge_objects(merge_set)
+            merge_set.setdefault(element.is_a(), []).append(obj)
+            id_set.setdefault(element.is_a(), []).append(ifc_definition_id)
+        self.merge_objects(merge_set, id_set)
+
+    def merge_by_type(self):
+        merge_set = {}
+        id_set = {}
+        for ifc_definition_id, obj in self.added_data.items():
+            if not isinstance(obj, bpy.types.Object) or not obj.data:
+                continue
+            element = self.file.by_id(ifc_definition_id)
+            if not element.is_a("IfcElement"):
+                continue
+            element_type = ifcopenshell.util.element.get_type(element)
+            if not element_type:
+                continue
+            merge_key = str(element_type.id()) + "-" + element_type.Name or "Unnamed"
+            merge_set.setdefault(merge_key, []).append(obj)
+            id_set.setdefault(merge_key, []).append(ifc_definition_id)
+        self.merge_objects(merge_set, id_set)

    def merge_by_material(self):
        merge_set = {}
-        for obj in self.added_data.values():
-            if not isinstance(obj, bpy.types.Object):
+        id_set = {}
+        for ifc_definition_id, obj in self.added_data.items():
+            if not isinstance(obj, bpy.types.Object) or not obj.data:
                continue
-            if "/" not in obj.name or "IfcRelAggregates" in obj.users_collection[0].name:
+            element = self.file.by_id(ifc_definition_id)
+            if not element.is_a("IfcElement"):
                continue
-            if not obj.material_slots:
-                merge_set.setdefault("no-material", []).append(obj)
-            else:
-                merge_set.setdefault(obj.material_slots[0].name, []).append(obj)
-        self.merge_objects(merge_set)
+            merge_key = obj.material_slots[0].name if obj.material_slots else "no-material"
+            merge_set.setdefault(merge_key, []).append(obj)
+            id_set.setdefault(merge_key, []).append(ifc_definition_id)
+        self.merge_objects(merge_set, id_set)

-    def merge_objects(self, merge_set):
-        for ifc_class, objs in merge_set.items():
-            context_override = {}
-            context_override["object"] = context_override["active_object"] = objs[0]
-            context_override["selected_objects"] = context_override["selected_editable_objects"] = objs
-            bpy.ops.object.join(context_override)
+    def merge_objects(self, merge_set, id_set):
+        total_objs = sum([len(o) for o in merge_set.values()])
+        cumulative_total = 0
+        merge_set = {k: v for k, v in sorted(merge_set.items(), key=lambda i: len(i[1]), reverse=True)}
+        for group_name, objs in merge_set.items():
+            total_group_objs = len(objs)
+            if total_group_objs < 10:
+                continue
+            merge_potential = total_objs - cumulative_total
+            if merge_potential < 250:
+                print("Merge target achieved")
+                return
+            cumulative_total += total_group_objs
+            print(f"Merging {total_group_objs} objects, {merge_potential} potentially remaining -", group_name)
+            try:
+                target = objs[0]
+                target.data = target.data.copy()
+                context_override = {}
+                context_override["object"] = context_override["active_object"] = target
+                context_override["selected_objects"] = context_override["selected_editable_objects"] = objs
+                bpy.ops.object.join(context_override)
+                target.data.name += "-merge"
+                for ifc_definition_id in id_set[group_name][1:]:
+                    del self.added_data[ifc_definition_id]
+            except:
+                print("Merge failed")

    def merge_materials_by_colour(self):
        cleaned_materials = {}
@@ -1283,11 +1425,18 @@ class IfcImporter:

        for material_definition_representation in self.file.by_type("IfcMaterialDefinitionRepresentation"):
            material = material_definition_representation.RepresentedMaterial
+            blender_material = self.material_creator.materials[material.id()]
            for representation in material_definition_representation.Representations:
-                for style in [e for e in self.file.traverse(representation) if e.is_a("IfcSurfaceStyle")]:
-                    blender_material = self.material_creator.materials[material.id()]
-                    self.create_style(style, blender_material)
-                    parsed_styles.add(style.id())
+                styles = []
+                for styled_item in representation.Items:
+                    styles.extend(styled_item.Styles)
+                while styles:
+                    style = styles.pop()
+                    if style.is_a("IfcSurfaceStyle"):
+                        self.create_style(style, blender_material)
+                        parsed_styles.add(style.id())
+                    elif style.is_a("IfcPresentationStyleAssignment"):
+                        styles.extend(style.Styles)

        for style in self.file.by_type("IfcSurfaceStyle"):
            if style.id() in parsed_styles:
@@ -1299,10 +1448,7 @@ class IfcImporter:
            name = style.Name or str(style.id())
            blender_material = bpy.data.materials.new(name)

-        old_definition_id = blender_material.BIMObjectProperties.ifc_definition_id
-        if not old_definition_id:
-            self.link_element(style, blender_material)
-        blender_material.BIMObjectProperties.ifc_definition_id = old_definition_id
+        self.link_element(style, blender_material)

        blender_material.BIMMaterialProperties.ifc_style_id = style.id()
        self.material_creator.styles[style.id()] = blender_material
@@ -1356,12 +1502,12 @@ class IfcImporter:
        elif surface_style.ReflectanceMethod == "FLAT":
            blender_material.use_nodes = True

-            output = {n.type: n for n in self.settings["material"].node_tree.nodes}.get("OUTPUT_MATERIAL", None)
+            output = {n.type: n for n in blender_material.node_tree.nodes}.get("OUTPUT_MATERIAL", None)
            bsdf = blender_material.node_tree.nodes["Principled BSDF"]

            mix = blender_material.node_tree.nodes.new(type="ShaderNodeMixShader")
            mix.location = bsdf.location
-            blender_material.node_tree.links.new(lightpath.outputs[0], output.inputs["Surface"])
+            blender_material.node_tree.links.new(mix.outputs[0], output.inputs["Surface"])

            blender_material.node_tree.nodes.remove(bsdf)

@@ -1513,9 +1659,10 @@ class IfcImporter:
            return self.structural_member_collection.objects.link(obj)
        elif element.is_a("IfcStructuralConnection"):
            return self.structural_connection_collection.objects.link(obj)
-        elif element.is_a("IfcAnnotation") and self.is_drawing_annotation(element):
-            group = [r for r in element.HasAssignments if r.is_a("IfcRelAssignsToGroup")][0].RelatingGroup
-            return self.collections[group.GlobalId].objects.link(obj)
+        elif element.is_a("IfcAnnotation"):
+            group = self.get_drawing_group(element)
+            if group:
+                return self.collections[group.GlobalId].objects.link(obj)

        container = ifcopenshell.util.element.get_container(element)
        if container:
@@ -1535,28 +1682,16 @@ class IfcImporter:
        return element.ObjectType in [
            "DIMENSION",
            "EQUAL_DIMENSION",
-            "MISC",
            "PLAN_LEVEL",
            "SECTION_LEVEL",
            "STAIR_ARROW",
            "TEXT_LEADER",
        ]

-    def is_drawing_annotation(self, element):
-        return element.ObjectType in [
-            "BREAKLINE",
-            "DIMENSION",
-            "DRAWING",
-            "EQUAL_DIMENSION",
-            "GRID",
-            "HIDDEN_LINE",
-            "MISC",
-            "PLAN_LEVEL",
-            "SECTION_LEVEL",
-            "STAIR_ARROW",
-            "TEXT",
-            "TEXT_LEADER",
-        ]
+    def get_drawing_group(self, element):
+        for rel in element.HasAssignments or []:
+            if rel.is_a("IfcRelAssignsToGroup"):
+                return rel.RelatingGroup

    def get_element_matrix(self, element):
        result = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement)
@@ -1682,6 +1817,12 @@ class IfcImporter:
                else:
                    camera.BIMCameraProperties.diagram_scale = "CUSTOM"
                    camera.BIMCameraProperties.custom_diagram_scale = pset["Scale"]
+            if "HasUnderlay" in pset:
+                camera.BIMCameraProperties.has_underlay = pset["HasUnderlay"]
+            if "HasLinework" in pset:
+                camera.BIMCameraProperties.has_linework = pset["HasLinework"]
+            if "HasAnnotation" in pset:
+                camera.BIMCameraProperties.has_annotation = pset["HasAnnotation"]
        return camera

    def create_curve(self, element, shape):
@@ -1724,15 +1865,27 @@ class IfcImporter:
                and geometry.verts
                and self.is_point_far_away((geometry.verts[0], geometry.verts[1], geometry.verts[2]))
            ):
+                m = shape.transformation.matrix.data
+                mat = np.array(
+                    ([m[0], m[3], m[6], m[9]], [m[1], m[4], m[7], m[10]], [m[2], m[5], m[8], m[11]], [0, 0, 0, 1])
+                )
+                offset_point = np.linalg.inv(mat) @ np.array(
+                    (
+                        float(props.blender_eastings),
+                        float(props.blender_northings),
+                        float(props.blender_orthogonal_height),
+                        0.0,
+                    )
+                )
                verts = [None] * len(geometry.verts)
                for i in range(0, len(geometry.verts), 3):
                    verts[i], verts[i + 1], verts[i + 2] = ifcopenshell.util.geolocation.enh2xyz(
                        geometry.verts[i],
                        geometry.verts[i + 1],
                        geometry.verts[i + 2],
-                        float(props.blender_eastings) * self.unit_scale,
-                        float(props.blender_northings) * self.unit_scale,
-                        float(props.blender_orthogonal_height) * self.unit_scale,
+                        offset_point[0] * self.unit_scale,
+                        offset_point[1] * self.unit_scale,
+                        offset_point[2] * self.unit_scale,
                        float(props.blender_x_axis_abscissa),
                        float(props.blender_x_axis_ordinate),
                    )
@@ -1841,14 +1994,18 @@ class IfcImportSettings:
        self.input_file = None
        self.diff_file = None
        self.should_use_cpu_multiprocessing = True
-        self.should_merge_by_class = False
-        self.should_merge_by_material = False
+        self.merge_mode = None
        self.should_merge_materials_by_colour = False
+        self.should_use_native_meshes = False
        self.should_clean_mesh = True
+        self.should_cache = True
+        self.is_coordinating = True
        self.deflection_tolerance = 0.001
        self.angular_tolerance = 0.5
-        self.should_offset_model = False
-        self.model_offset_coordinates = (0, 0, 0)
+        self.distance_limit = 1000
+        self.false_origin = None
+        self.element_offset = 0
+        self.element_limit = 30000
        self.has_filter = None
        self.should_filter_spatial_elements = True
        self.elements = set()
@@ -1866,16 +2023,18 @@ class IfcImportSettings:
        settings.diff_file = scene_diff.diff_json_file
        settings.collection_mode = props.collection_mode
        settings.should_use_cpu_multiprocessing = props.should_use_cpu_multiprocessing
-        settings.should_merge_by_class = props.should_merge_by_class
-        settings.should_merge_by_material = props.should_merge_by_material
+        settings.merge_mode = props.merge_mode
        settings.should_merge_materials_by_colour = props.should_merge_materials_by_colour
+        settings.should_use_native_meshes = props.should_use_native_meshes
        settings.should_clean_mesh = props.should_clean_mesh
+        settings.should_cache = props.should_cache
+        settings.is_coordinating = props.is_coordinating
        settings.deflection_tolerance = props.deflection_tolerance
        settings.angular_tolerance = props.angular_tolerance
-        settings.should_offset_model = props.should_offset_model
-        settings.model_offset_coordinates = (
-            [float(o) for o in props.model_offset_coordinates.split(",")]
-            if props.model_offset_coordinates
-            else (0, 0, 0)
-        )
+        settings.distance_limit = props.distance_limit
+        settings.false_origin = [float(o) for o in props.false_origin.split(",")] if props.false_origin else None
+        if settings.false_origin == [0, 0, 0]:
+            settings.false_origin = None
+        settings.element_offset = props.element_offset
+        settings.element_limit = props.element_limit
        return settings
@@ -768,6 +768,8 @@ class ActivateBcfViewpoint(bpy.types.Operator):
        bcfxml = bcfstore.BcfStore.get_bcfxml()
        props = context.scene.BCFProperties
        blender_topic = props.active_topic
+        if blender_topic is None:
+            return False
        topic = bcfxml.topics[blender_topic.name]
        return topic.viewpoints

@@ -880,7 +882,7 @@ class ActivateBcfViewpoint(bpy.types.Operator):
        # Operators with context overrides are used because they are
        # significantly faster than looping through all objects

-        exception_global_ids = [v.ifc_guid for v in viewpoint.components.visibility.exceptions]
+        exception_global_ids = {v.ifc_guid for v in viewpoint.components.visibility.exceptions}

        if viewpoint.components.visibility.default_visibility:
            old = context.area.type
@@ -95,7 +95,7 @@ def getBcfViewpoints(self, context, force_update=False):
        props = context.scene.BCFProperties
        bcfxml = bcfstore.BcfStore.get_bcfxml()
        topic = props.active_topic
-        viewpoints = bcfxml.get_viewpoints(topic.name)
+        viewpoints = bcfxml.get_viewpoints(topic.name) if topic else {}
        bcfviewpoints_enum.extend([(v, f"Viewpoint {i+1}", "") for i, v in enumerate(viewpoints.keys())])
    return bcfviewpoints_enum

@@ -62,7 +62,7 @@ def refreshScenarios(self, context):


 class BimTesterProperties(PropertyGroup):
-    feature: StringProperty(default="", name="Feature / IDS", update=refreshScenarios)
+    feature: StringProperty(default="", name="Feature", update=refreshScenarios)
    steps: StringProperty(default="", name="Custom Steps")
    ifc_file: StringProperty(default="", name="IFC File")
    audit_ifc_class: EnumProperty(items=get_ifc_classes, name="Audit Class")
@@ -26,7 +26,7 @@ import blenderbim.bim.import_ifc as import_ifc


 def get_boundaries_collection(blender_space):
-    space_collection = bpy.data.collections.get(blender_space.name)
+    space_collection = bpy.data.collections.get(blender_space.name, blender_space.users_collection[0])
    collection_name = f"Boundaries/{blender_space.BIMObjectProperties.ifc_definition_id}"
    boundaries_collection = space_collection.children.get(collection_name)
    if not boundaries_collection:
@@ -49,7 +49,7 @@ class Loader:
        if not boundary.ConnectionGeometry:
            return None
        surface = boundary.ConnectionGeometry.SurfaceOnRelatingElement
-        # workaround for unvalid geometry provided by Revit. See https://github.com/IfcOpenShell/IfcOpenShell/issues/635#issuecomment-770366838
+        # workaround for invalid geometry provided by Revit. See https://github.com/IfcOpenShell/IfcOpenShell/issues/635#issuecomment-770366838
        if surface.is_a("IfcCurveBoundedPlane") and not getattr(surface, "InnerBoundaries", None):
            surface.InnerBoundaries = ()
        shape = ifcopenshell.geom.create_shape(self.settings, surface)
@@ -18,6 +18,7 @@

 import blenderbim.tool as tool
 from bpy.types import Panel, UIList
+from blenderbim.bim.helper import prop_with_search
 from blenderbim.bim.module.brick.data import BrickschemaData, BrickschemaReferencesData


@@ -48,7 +49,8 @@ class BIM_PT_brickschema(Panel):
        row.operator("bim.close_brick_project", text="", icon="CANCEL")

        row = self.layout.row(align=True)
-        row.prop(self.props, "namespace", text="")
+        prop_with_search(row, self.props, "namespace", text="")
+        prop_with_search(row, self.props, "brick_equipment_class", text="")
        row.prop(self.props, "brick_equipment_class", text="")
        row.operator("bim.add_brick", text="", icon="ADD")

@@ -101,7 +103,7 @@ class BIM_PT_ifc_brickschema_references(Panel):
            return

        row = self.layout.row(align=True)
-        row.prop(self.props, "libraries")
+        prop_with_search(row, self.props, "libraries")
        row.operator("bim.convert_brick_project", text="", icon="ADD")

        row = self.layout.row(align=True)
@@ -0,0 +1,39 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on 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.
+#
+# BlenderBIM Add-on 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 BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import bpy
+from . import operator, workspace
+
+classes = (
+    operator.CadArcFrom2Points,
+    operator.CadArcFrom3Points,
+    operator.CadFillet,
+    operator.CadMitre,
+    operator.CadTrimExtend,
+    workspace.CadHotkey,
+)
+
+
+def register():
+    if not bpy.app.background:
+        bpy.utils.register_tool(workspace.CadTool, after={"builtin.transform"}, separator=True, group=True)
+
+
+def unregister():
+    if not bpy.app.background:
+        bpy.utils.unregister_tool(workspace.CadTool)
@@ -0,0 +1,345 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on 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.
+#
+# BlenderBIM Add-on 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 BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import bpy
+import math
+import bmesh
+import mathutils
+import bpy_extras
+import blenderbim.tool as tool
+
+messages = {
+    "SHARED_VERTEX": "Shared Vertex, no intersection possible",
+    "PARALLEL_EDGES": "Edges Parallel, no intersection possible",
+    "NON_PLANAR_EDGES": "Non Planar Edges, no clean intersection point",
+}
+
+
+class CadTrimExtend(bpy.types.Operator):
+    bl_idname = "bim.cad_trim_extend"
+    bl_label = "CAD Trim / Extend"
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return bool(obj) and obj.type == "MESH"
+
+    def cancel_message(self, msg):
+        print(msg)
+        self.report({"WARNING"}, msg)
+        return {"CANCELLED"}
+
+    def execute(self, context):
+        # final attempt to enter unfragmented bm/mesh
+        # ghastly, but what can I do? it works with these
+        # fails without.
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        obj = context.active_object
+        me = obj.data
+
+        bm = bmesh.from_edit_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+
+        edges = [e for e in bm.edges if e.select and not e.hide]
+
+        if len(edges) == 2:
+            message = tool.Cad.do_vtx_if_appropriate(bm, edges, mode="T")
+            if isinstance(message, set):
+                msg = messages.get(message.pop())
+                return self.cancel_message(msg)
+            bm = message
+        else:
+            return self.cancel_message("select two edges!")
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(me, loop_triangles=True)
+
+        return {"FINISHED"}
+
+
+class CadMitre(bpy.types.Operator):
+    bl_idname = "bim.cad_mitre"
+    bl_label = "CAD Mitre"
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return bool(obj) and obj.type == "MESH"
+
+    def cancel_message(self, msg):
+        print(msg)
+        self.report({"WARNING"}, msg)
+        return {"CANCELLED"}
+
+    def execute(self, context):
+        # final attempt to enter unfragmented bm/mesh
+        # ghastly, but what can I do? it works with these
+        # fails without.
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        obj = context.active_object
+        me = obj.data
+
+        bm = bmesh.from_edit_mesh(me)
+        bm.verts.ensure_lookup_table()
+        bm.edges.ensure_lookup_table()
+
+        edges = [e for e in bm.edges if e.select and not e.hide]
+
+        if len(edges) == 2:
+            message = tool.Cad.do_vtx_if_appropriate(bm, edges, mode="V")
+            if isinstance(message, set):
+                msg = messages.get(message.pop())
+                return self.cancel_message(msg)
+            bm = message
+        else:
+            return self.cancel_message("select two edges!")
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(me, loop_triangles=True)
+
+        return {"FINISHED"}
+
+
+class CadFillet(bpy.types.Operator):
+    bl_idname = "bim.cad_fillet"
+    bl_label = "CAD Fillet"
+    bl_options = {"REGISTER", "UNDO"}
+    resolution: bpy.props.IntProperty(name="Arc Resolution", min=0, default=1)
+    radius: bpy.props.FloatProperty(name="Radius", default=0.1)
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return obj and obj.type == "MESH" and context.mode == "EDIT_MESH"
+
+    def draw(self, context):
+        layout = self.layout
+        for prop in self.__class__.__annotations__.keys():
+            layout.prop(self, prop)
+
+    def execute(self, context):
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        obj = bpy.context.active_object
+        cursor = obj.matrix_world.inverted() @ bpy.context.scene.cursor.location
+        mesh = obj.data
+        bm = bmesh.from_edit_mesh(mesh)
+        selected_edges = [e for e in bm.edges if e.select]
+        if len(selected_edges) != 2:
+            return {"CANCELLED"}
+
+        # Assume the user has selected two edges sharing a vert, but merge verts
+        # just in case the vertex is coincident but not shared.
+        all_verts = list(set(selected_edges[0].verts) | set(selected_edges[1].verts))
+        bmesh.ops.remove_doubles(bm, verts=all_verts, dist=1e-4)
+
+        # Subdivide one of the edges to give us an extra vert to play with
+        # without damaging any faces that already exist.
+        cut = bmesh.ops.bisect_edges(bm, edges=[selected_edges[1]], cuts=1)
+        bm.edges.index_update()
+        bmesh.update_edit_mesh(mesh)
+
+        is_wire = selected_edges[0].is_wire
+
+        # Recover the original intention of the selected edges after our bisect operation
+        cut_edges = cut["geom_split"][1:]
+        selected_edges = [e for e in bm.edges if e.select and e not in cut_edges]
+        if set(selected_edges[0].verts) & set(cut_edges[0].verts):
+            selected_edges.append(cut_edges[0])
+        elif set(selected_edges[0].verts) & set(cut_edges[1].verts):
+            selected_edges.append(cut_edges[1])
+
+        # Calculate the distance to slide each edge to make space for the fillet arc
+        shared_vert = list(set(selected_edges[0].verts) & set(selected_edges[1].verts))[0]
+        v1 = selected_edges[0].other_vert(shared_vert)
+        v2 = selected_edges[1].other_vert(shared_vert)
+        dir1 = (v1.co - shared_vert.co).normalized()
+        dir2 = (v2.co - shared_vert.co).normalized()
+        edge_angle = dir1.angle(dir2)
+        slide_distance = self.radius / math.tan(edge_angle / 2)
+
+        angle = math.pi - edge_angle
+        fillet_v1 = shared_vert.co + (dir1 * slide_distance)
+        fillet_v2 = shared_vert.co + (dir2 * slide_distance)
+
+        normal = mathutils.geometry.normal([v1.co, shared_vert.co, v2.co])
+
+        center = mathutils.geometry.intersect_line_line(
+            fillet_v1, fillet_v1 + normal.cross(dir1), fillet_v2, fillet_v2 + normal.cross(dir2)
+        )[0]
+
+        v = bm.verts.new(fillet_v1)
+        steps = self.resolution * 4 if self.resolution else 1
+        spin = bmesh.ops.spin(bm, geom=[v], axis=normal, cent=center, steps=steps, angle=angle)
+
+        bmesh.ops.pointmerge(bm, verts=[shared_vert, v], merge_co=v.co)
+        bmesh.ops.pointmerge(bm, verts=[v2, spin["geom_last"][0]], merge_co=spin["geom_last"][0].co)
+
+        # If faces are involved, then the chamfer edge protects existing faces from the newly created fillet.
+        # If no faces are involved, we delete the chamfer edge.
+        if is_wire:
+            chamfer_edge = [e for e in bm.edges if shared_vert in e.verts and v2 in e.verts][0]
+            bm.edges.remove(chamfer_edge)
+
+        bmesh.update_edit_mesh(mesh)
+        mesh.update()
+        bm.free()
+        return {"FINISHED"}
+
+
+class CadArcFrom2Points(bpy.types.Operator):
+    bl_idname = "bim.cad_arc_from_2_points"
+    bl_label = "CAD Arc from 2 Points"
+    bl_options = {"REGISTER", "UNDO"}
+    resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
+    should_flip: bpy.props.BoolProperty(name="Flip", description="Flip arc", default=False)
+
+    def draw(self, context):
+        layout = self.layout
+        for prop in self.__class__.__annotations__.keys():
+            layout.prop(self, prop)
+
+    def execute(self, context):
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        if bpy.context.mode != "EDIT_MESH":
+            return {"CANCELLED"}
+        obj = bpy.context.active_object
+        region = bpy.context.region
+        region_3d = bpy.context.area.spaces.active.region_3d
+        cursor = bpy.context.scene.cursor.location
+        center = bpy_extras.view3d_utils.location_3d_to_region_2d(region, region_3d, cursor)
+        if not center:
+            return {"CANCELLED"}
+        mesh = obj.data
+        mw = obj.matrix_world
+        bm = bmesh.from_edit_mesh(mesh)
+        selected_verts = [v for v in bm.verts if v.select]
+        if len(selected_verts) != 2:
+            return {"CANCELLED"}
+        v1 = bpy_extras.view3d_utils.location_3d_to_region_2d(region, region_3d, mw @ selected_verts[0].co)
+        v2 = bpy_extras.view3d_utils.location_3d_to_region_2d(region, region_3d, mw @ selected_verts[1].co)
+        l1 = v1 - center
+        l2 = v2 - center
+        angle = l1.angle_signed(l2)
+
+        if self.should_flip:
+            if angle > 0:
+                angle = -((math.pi * 2) - angle)
+            else:
+                angle = (math.pi * 2) + angle
+
+        v = selected_verts[0]
+        bm.verts.remove(selected_verts[1])
+        axis = region_3d.view_rotation @ mathutils.Vector((0, 0, 1))
+        bmesh.ops.spin(
+            bm,
+            geom=[v],
+            axis=mw.inverted().to_quaternion() @ axis,
+            cent=mw.inverted() @ cursor,
+            steps=self.resolution * 4,
+            angle=-angle,
+        )
+        bmesh.update_edit_mesh(mesh)
+        mesh.update()
+        return {"FINISHED"}
+
+
+class CadArcFrom3Points(bpy.types.Operator):
+    bl_idname = "bim.cad_arc_from_3_points"
+    bl_label = "CAD Arc from 3 Points"
+    bl_options = {"REGISTER", "UNDO"}
+    resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
+    only_recalculate_center: bpy.props.BoolProperty(name="Only Recalculate Center", default=False)
+
+    @classmethod
+    def poll(cls, context):
+        obj = context.active_object
+        return obj and obj.type == "MESH" and context.mode == "EDIT_MESH"
+
+    def draw(self, context):
+        layout = self.layout
+        for prop in self.__class__.__annotations__.keys():
+            layout.prop(self, prop)
+
+    def execute(self, context):
+        bpy.ops.object.mode_set(mode="OBJECT")
+        bpy.ops.object.mode_set(mode="EDIT")
+
+        if bpy.context.mode != "EDIT_MESH":
+            return {"CANCELLED"}
+
+        obj = bpy.context.edit_object
+        mesh = obj.data
+        bm = bmesh.from_edit_mesh(mesh)
+
+        selected_verts = [v for v in bm.verts if v.select]
+        if len(selected_verts) != 3:
+            return {"CANCELLED"}
+        pts = [v.co for v in selected_verts]
+        center = tool.Cad.get_center_of_arc(pts, obj)
+        if not center:
+            return {"CANCELLED"}
+
+        bpy.context.scene.cursor.location = center
+        if self.only_recalculate_center:
+            return {"FINISHED"}
+
+        center = obj.matrix_world.inverted() @ center
+
+        def get_distance_to_other_points(vert):
+            other_verts = [v for v in selected_verts if v != vert]
+            total_vector = mathutils.Vector((0, 0, 0))
+            for other_vert in other_verts:
+                total_vector += other_vert.co - vert.co
+            return total_vector.length
+
+        # For three selected points that represent a start, end, and point on an
+        # arc, the start and end verts can be identified by being furthest away
+        # from the other 2 points.
+        arc_end_verts = sorted(selected_verts, key=get_distance_to_other_points)[-2:]
+        normal = mathutils.geometry.normal(pts)
+
+        dir1 = (arc_end_verts[0].co - center).normalized()
+        dir2 = (arc_end_verts[1].co - center).normalized()
+
+        # Let's get the matrix that represents the coordinate system of the arc.
+        # This matrix allows us to get 2D vectors for calculating the signed arc angle.
+        z = normal
+        x = (arc_end_verts[0].co - center).normalized()
+        y = z.cross(x)
+        arc_matrix = mathutils.Matrix([x, y, z]).transposed().to_4x4()
+
+        dir1 = ((arc_matrix.inverted() @ arc_end_verts[0].co) - (arc_matrix.inverted() @ center)).normalized()
+        dir2 = ((arc_matrix.inverted() @ arc_end_verts[1].co) - (arc_matrix.inverted() @ center)).normalized()
+        angle = dir1.xy.angle_signed(dir2.xy)
+
+        v = arc_end_verts[0]
+        bmesh.ops.spin(bm, geom=[v], axis=normal, cent=center, steps=self.resolution * 4, angle=-angle)
+        bmesh.update_edit_mesh(mesh)
+        mesh.update()
+        return {"FINISHED"}
@@ -0,0 +1,93 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on 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.
+#
+# BlenderBIM Add-on 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 BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import bpy
+import blenderbim.bim.module.type.prop as type_prop
+from bpy.types import WorkSpaceTool
+from blenderbim.bim.ifc import IfcStore
+from blenderbim.bim.module.model.data import AuthoringData
+
+
+class CadTool(WorkSpaceTool):
+    bl_space_type = "VIEW_3D"
+    bl_context_mode = "EDIT_MESH"
+
+    bl_idname = "bim.cad_tool"
+    bl_label = "CAD Tool"
+    bl_description = "Gives you CAD authoring related superpowers"
+    bl_icon = os.path.join(os.path.dirname(__file__), "ops.authoring.cad")
+    bl_widget = None
+    # https://docs.blender.org/api/current/bpy.types.KeyMapItems.html
+    bl_keymap = (
+        ("bim.cad_hotkey", {"type": "E", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_E")]}),
+        ("bim.cad_hotkey", {"type": "T", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_T")]}),
+        ("bim.cad_fillet", {"type": "F", "value": "PRESS", "shift": True}, {"properties": []}),
+        # Enable Mesh Tools add-on to get this amazing tool
+        ("mesh.offset_edges", {"type": "O", "value": "PRESS", "shift": True}, {"properties": []}),
+        ("bim.cad_arc_from_2_points", {"type": "C", "value": "PRESS", "shift": True}, {"properties": []}),
+        ("bim.cad_arc_from_3_points", {"type": "V", "value": "PRESS", "shift": True}, {"properties": []}),
+    )
+
+    def draw_settings(context, layout, tool):
+        row = layout.row(align=True)
+        row.label(text="", icon="EVENT_SHIFT")
+        row.label(text="Extend", icon="EVENT_E")
+
+        row = layout.row(align=True)
+        row.label(text="", icon="EVENT_SHIFT")
+        row.label(text="Mitre", icon="EVENT_T")
+
+        row = layout.row(align=True)
+        row.label(text="", icon="EVENT_SHIFT")
+        row.label(text="Fillet", icon="EVENT_F")
+
+        row = layout.row(align=True)
+        row.label(text="", icon="EVENT_SHIFT")
+        row.label(text="Offset", icon="EVENT_O")
+
+        row = layout.row(align=True)
+        row.label(text="", icon="EVENT_SHIFT")
+        row.label(text="2-Point Arc", icon="EVENT_C")
+
+        row = layout.row(align=True)
+        row.label(text="", icon="EVENT_SHIFT")
+        row.label(text="3-Point Arc", icon="EVENT_V")
+
+
+class CadHotkey(bpy.types.Operator):
+    bl_idname = "bim.cad_hotkey"
+    bl_label = "CAD Hotkey"
+    bl_options = {"REGISTER", "UNDO"}
+    hotkey: bpy.props.StringProperty()
+
+    def execute(self, context):
+        self.props = context.scene.BIMModelProperties
+        self.has_ifc_class = True
+        try:
+            self.has_ifc_class = bool(self.props.ifc_class)
+        except:
+            pass
+        getattr(self, f"hotkey_{self.hotkey}")()
+        return {"FINISHED"}
+
+    def hotkey_S_E(self):
+        bpy.ops.bim.cad_trim_extend()
+
+    def hotkey_S_T(self):
+        bpy.ops.bim.cad_mitre()
@@ -20,23 +20,26 @@ import bpy
 from . import ui, prop, operator

 classes = (
-    operator.LoadClassificationLibrary,
    operator.AddClassification,
-    operator.RemoveClassification,
-    operator.EnableEditingClassification,
-    operator.DisableEditingClassification,
-    operator.EditClassification,
-    operator.RemoveClassificationReference,
-    operator.EnableEditingClassificationReference,
-    operator.DisableEditingClassificationReference,
-    operator.EditClassificationReference,
    operator.AddClassificationReference,
    operator.ChangeClassificationLevel,
+    operator.DisableEditingClassification,
+    operator.DisableEditingClassificationReference,
+    operator.DisableEditingClassificationReferences,
+    operator.EditClassification,
+    operator.EditClassificationReference,
+    operator.EnableEditingClassification,
+    operator.EnableEditingClassificationReference,
+    operator.LoadClassificationLibrary,
+    operator.RemoveClassification,
+    operator.RemoveClassificationReference,
    prop.ClassificationReference,
    prop.BIMClassificationProperties,
    prop.BIMClassificationReferenceProperties,
    ui.BIM_PT_classifications,
    ui.BIM_PT_classification_references,
+    ui.BIM_PT_material_classifications,
+    ui.BIM_PT_cost_classifications,
    ui.BIM_UL_classifications,
 )

@@ -0,0 +1,141 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on 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.
+#
+# BlenderBIM Add-on 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 BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import bpy
+import ifcopenshell
+import ifcopenshell.util.date
+import ifcopenshell.util.classification
+import blenderbim.tool as tool
+from blenderbim.bim.ifc import IfcStore
+
+
+def refresh():
+    ClassificationsData.is_loaded = False
+    ClassificationReferencesData.is_loaded = False
+    MaterialClassificationsData.is_loaded = False
+    CostClassificationsData.is_loaded = False
+
+
+class ClassificationsData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.is_loaded = True
+        cls.data["has_classification_file"] = cls.has_classification_file()
+        cls.data["classifications"] = cls.classifications()
+        cls.data["available_classifications"] = cls.available_classifications()
+
+    @classmethod
+    def has_classification_file(cls):
+        return bool(IfcStore.classification_file)
+
+    @classmethod
+    def classifications(cls):
+        results = []
+        for element in tool.Ifc.get().by_type("IfcClassification"):
+            data = element.get_info()
+            if IfcStore.classification_file.schema == "IFC2X3" and element.EditionDate:
+                data["EditionDate"] = ifcopenshell.util.date.ifc2datetime(data["EditionDate"])
+            results.append(data)
+        return results
+
+    @classmethod
+    def available_classifications(cls):
+        if not IfcStore.classification_file:
+            return []
+        return [(str(e.id()), e.Name, "") for e in IfcStore.classification_file.by_type("IfcClassification")]
+
+
+class ReferencesData:
+    @classmethod
+    def is_available_classification_added(cls):
+        if not IfcStore.classification_file or not IfcStore.classification_file.by_type("IfcClassification"):
+            return False
+        props = bpy.context.scene.BIMClassificationProperties
+        name = IfcStore.classification_file.by_id(int(props.available_classifications)).Name
+        return name in [e.Name for e in tool.Ifc.get().by_type("IfcClassification")]
+
+
+class ClassificationReferencesData(ReferencesData):
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.is_loaded = True
+        cls.data["references"] = cls.references()
+        cls.data["is_available_classification_added"] = cls.is_available_classification_added()
+
+    @classmethod
+    def references(cls):
+        results = []
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if element:
+            for reference in ifcopenshell.util.classification.get_references(element):
+                data = reference.get_info()
+                del data["ReferencedSource"]
+                results.append(data)
+        return results
+
+
+class MaterialClassificationsData(ReferencesData):
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.is_loaded = True
+        cls.data["references"] = cls.references()
+        cls.data["is_available_classification_added"] = cls.is_available_classification_added()
+
+    @classmethod
+    def references(cls):
+        results = []
+        element = tool.Ifc.get_entity(bpy.context.active_object.active_material)
+        if element:
+            for reference in ifcopenshell.util.classification.get_references(element):
+                data = reference.get_info()
+                del data["ReferencedSource"]
+                results.append(data)
+        return results
+
+
+class CostClassificationsData(ReferencesData):
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.is_loaded = True
+        cls.data["references"] = cls.references()
+        cls.data["is_available_classification_added"] = cls.is_available_classification_added()
+
+    @classmethod
+    def references(cls):
+        results = []
+        element = tool.Ifc.get().by_id(bpy.context.scene.BIMCostProperties.cost_items[
+            bpy.context.scene.BIMCostProperties.active_cost_item_index
+        ].ifc_definition_id)
+        if element:
+            for reference in ifcopenshell.util.classification.get_references(element):
+                data = reference.get_info()
+                del data["ReferencedSource"]
+                results.append(data)
+        return results
@@ -1,5 +1,5 @@
 # BlenderBIM Add-on - OpenBIM Blender Add-on
-# Copyright (C) 2020, 2021 Dion Moult <dion@thinkmoult.com>
+# Copyright (C) 2020-2022 Dion Moult <dion@thinkmoult.com>
 #
 # This file is part of BlenderBIM Add-on.
 #
@@ -18,46 +18,40 @@

 import bpy
 import json
+import ifcopenshell
 import ifcopenshell.api
+import blenderbim.tool as tool
+import blenderbim.bim.helper
 from blenderbim.bim.ifc import IfcStore
-from ifcopenshell.api.classification.data import Data
-from blenderbim.bim.module.classification.prop import getClassifications, getReferences


-class LoadClassificationLibrary(bpy.types.Operator):
+class LoadClassificationLibrary(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.load_classification_library"
    bl_label = "Load Classification Library"
    filename_ext = ".ifc"
    filter_glob: bpy.props.StringProperty(default="*.ifc;*.ifczip;*.ifcxml", options={"HIDDEN"})
    filepath: bpy.props.StringProperty(subtype="FILE_PATH")

-    def execute(self, context):
-        Data.load_library(self.filepath)
-        getClassifications(self, context)
-        return {"FINISHED"}
-
    def invoke(self, context, event):
        context.window_manager.fileselect_add(self)
        return {"RUNNING_MODAL"}

+    def _execute(self, context):
+        IfcStore.classification_file = ifcopenshell.open(self.filepath)

-class AddClassification(bpy.types.Operator):
+
+class AddClassification(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_classification"
    bl_label = "Add Classification"
    bl_options = {"REGISTER", "UNDO"}

-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
    def _execute(self, context):
        props = context.scene.BIMClassificationProperties
        ifcopenshell.api.run(
            "classification.add_classification",
-            IfcStore.get_file(),
-            **{"classification": Data.library_file.by_id(int(props.available_classifications))},
+            tool.Ifc.get(),
+            classification=IfcStore.classification_file.by_id(int(props.available_classifications)),
        )
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}


 class EnableEditingClassification(bpy.types.Operator):
@@ -67,19 +61,21 @@ class EnableEditingClassification(bpy.types.Operator):
    classification: bpy.props.IntProperty()

    def execute(self, context):
+        def callback(name, prop, data):
+            if name == "ReferenceTokens":
+                new = bpy.context.scene.BIMGeoreferenceProperties.projected_crs.add()
+                new.name = name
+                new.data_type = "string"
+                new.is_null = data[name] is None
+                new.is_optional = True
+                new.string_value = "" if new.is_null else json.dumps(data[name])
+                return True
+
        props = context.scene.BIMClassificationProperties
        props.classification_attributes.clear()
-        classification_data = Data.classifications[self.classification]
-        for attribute in IfcStore.get_schema().declaration_by_name("IfcClassification").all_attributes():
-            new = props.classification_attributes.add()
-            new.name = attribute.name()
-            new.is_null = classification_data[attribute.name()] is None
-            new.is_optional = attribute.optional()
-            new.data_type = "string"
-            if attribute.name() == "ReferenceTokens":
-                new.string_value = "" if new.is_null else json.dumps(classification_data[attribute.name()])
-            else:
-                new.string_value = "" if new.is_null else classification_data[attribute.name()]
+        blenderbim.bim.helper.import_attributes2(
+            tool.Ifc.get().by_id(self.classification), props.classification_attributes, callback
+        )
        props.active_classification_id = self.classification
        return {"FINISHED"}

@@ -94,34 +90,26 @@ class DisableEditingClassification(bpy.types.Operator):
        return {"FINISHED"}


-class RemoveClassification(bpy.types.Operator):
+class RemoveClassification(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.remove_classification"
    bl_label = "Remove Classification"
    bl_options = {"REGISTER", "UNDO"}
    classification: bpy.props.IntProperty()

-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
    def _execute(self, context):
        self.file = IfcStore.get_file()
        ifcopenshell.api.run(
            "classification.remove_classification",
-            self.file,
-            **{"classification": self.file.by_id(self.classification)},
+            tool.Ifc.get(),
+            classification=self.file.by_id(self.classification),
        )
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}


-class EditClassification(bpy.types.Operator):
+class EditClassification(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.edit_classification"
    bl_label = "Edit Classification"
    bl_options = {"REGISTER", "UNDO"}

-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
    def _execute(self, context):
        props = context.scene.BIMClassificationProperties
        attributes = {}
@@ -138,9 +126,7 @@ class EditClassification(bpy.types.Operator):
            self.file,
            **{"classification": self.file.by_id(props.active_classification_id), "attributes": attributes},
        )
-        Data.load(IfcStore.get_file())
        bpy.ops.bim.disable_editing_classification()
-        return {"FINISHED"}


 class EnableEditingClassificationReference(bpy.types.Operator):
@@ -154,16 +140,7 @@ class EnableEditingClassificationReference(bpy.types.Operator):
        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
        props = obj.BIMClassificationReferenceProperties
        props.reference_attributes.clear()
-        reference_data = Data.references[self.reference]
-        for attribute in IfcStore.get_schema().declaration_by_name("IfcClassificationReference").all_attributes():
-            if attribute.name() == "ReferencedSource":
-                continue
-            new = props.reference_attributes.add()
-            new.name = attribute.name()
-            new.is_null = reference_data[attribute.name()] is None
-            new.is_optional = attribute.optional()
-            new.data_type = "string"
-            new.string_value = "" if new.is_null else reference_data[attribute.name()]
+        blenderbim.bim.helper.import_attributes2(tool.Ifc.get().by_id(self.reference), props.reference_attributes)
        props.active_reference_id = self.reference
        return {"FINISHED"}

@@ -180,41 +157,47 @@ class DisableEditingClassificationReference(bpy.types.Operator):
        return {"FINISHED"}


-class RemoveClassificationReference(bpy.types.Operator):
+class RemoveClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.remove_classification_reference"
    bl_label = "Remove Classification Reference"
    bl_options = {"REGISTER", "UNDO"}
    reference: bpy.props.IntProperty()
    obj: bpy.props.StringProperty()
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
+    obj_type: bpy.props.StringProperty()

    def _execute(self, context):
        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
-        self.file = IfcStore.get_file()
-        ifcopenshell.api.run(
-            "classification.remove_reference",
-            self.file,
-            **{
-                "reference": self.file.by_id(self.reference),
-                "product": self.file.by_id(obj.BIMObjectProperties.ifc_definition_id),
-            },
-        )
-        Data.load(IfcStore.get_file(), obj.BIMObjectProperties.ifc_definition_id)
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
+        if self.obj_type == "Object":
+            if context.selected_objects:
+                objects = [o.name for o in context.selected_objects]
+            else:
+                objects = [context.active_object.name]
+        else:
+            objects = [self.obj]
+
+        identification = tool.Ifc.get().by_id(self.reference)[0]
+
+        for obj in objects:
+            ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, obj, self.obj_type)
+            element = tool.Ifc.get().by_id(ifc_definition_id)
+            references = ifcopenshell.util.classification.get_references(element, should_inherit=False)
+            for reference in references:
+                if reference[0] == identification:
+                    ifcopenshell.api.run(
+                        "classification.remove_reference",
+                        tool.Ifc.get(),
+                        reference=reference,
+                        product=element,
+                    )
+                    break


-class EditClassificationReference(bpy.types.Operator):
+class EditClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.edit_classification_reference"
    bl_label = "Edit Classification Reference"
    bl_options = {"REGISTER", "UNDO"}
    obj: bpy.props.StringProperty()

-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
    def _execute(self, context):
        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
        props = obj.BIMClassificationReferenceProperties
@@ -228,48 +211,47 @@ class EditClassificationReference(bpy.types.Operator):
        ifcopenshell.api.run(
            "classification.edit_reference",
            self.file,
-            **{"reference": self.file.by_id(props.active_reference_id), "attributes": attributes},
+            reference=self.file.by_id(props.active_reference_id),
+            attributes=attributes,
        )
-        Data.load(IfcStore.get_file())
        bpy.ops.bim.disable_editing_classification_reference()
-        return {"FINISHED"}


-class AddClassificationReference(bpy.types.Operator):
+class AddClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_classification_reference"
    bl_label = "Add Classification Reference"
    bl_options = {"REGISTER", "UNDO"}
    reference: bpy.props.IntProperty()
    obj: bpy.props.StringProperty()
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
+    obj_type: bpy.props.StringProperty()

    def _execute(self, context):
-        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
-        self.file = IfcStore.get_file()
-
-        classification = None
-
+        if self.obj_type == "Object":
+            if context.selected_objects:
+                objects = [o.name for o in context.selected_objects]
+            else:
+                objects = [context.active_object.name]
+        else:
+            objects = [self.obj]
        props = context.scene.BIMClassificationProperties
-        classification_name = Data.library_classifications[int(props.available_classifications)]
-        for classification_id, classification in Data.classifications.items():
-            if classification["Name"] == classification_name:
-                classification = self.file.by_id(classification_id)
+        classification = None
+        classification_name = IfcStore.classification_file.by_id(int(props.available_classifications)).Name
+        for element in tool.Ifc.get().by_type("IfcClassification"):
+            if element.Name == classification_name:
+                classification = element
                break

-        ifcopenshell.api.run(
-            "classification.add_reference",
-            self.file,
-            **{
-                "reference": Data.library_file.by_id(self.reference),
-                "product": self.file.by_id(obj.BIMObjectProperties.ifc_definition_id),
-                "classification": classification,
-            },
-        )
-        Data.load(IfcStore.get_file(), obj.BIMObjectProperties.ifc_definition_id)
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
+        for obj in objects:
+            ifc_definition_id = blenderbim.bim.helper.get_obj_ifc_definition_id(context, obj, self.obj_type)
+            if not ifc_definition_id:
+                continue
+            ifcopenshell.api.run(
+                "classification.add_reference",
+                tool.Ifc.get(),
+                reference=IfcStore.classification_file.by_id(self.reference),
+                product=tool.Ifc.get().by_id(ifc_definition_id),
+                classification=classification,
+            )


 class ChangeClassificationLevel(bpy.types.Operator):
@@ -279,5 +261,28 @@ class ChangeClassificationLevel(bpy.types.Operator):
    parent_id: bpy.props.IntProperty()

    def execute(self, context):
-        getReferences(self, context, parent_id=self.parent_id)
+        props = context.scene.BIMClassificationProperties
+        props.available_library_references.clear()
+        for reference in IfcStore.classification_file.by_id(self.parent_id).HasReferences:
+            new = props.available_library_references.add()
+            new.identification = reference.Identification or ""
+            new.name = reference.Name or ""
+            new.ifc_definition_id = reference.id()
+            new.has_references = bool(reference.HasReferences)
+            new.referenced_source
+        if reference.ReferencedSource.is_a("IfcClassificationReference"):
+            props.active_library_referenced_source = reference.ReferencedSource.ReferencedSource.id()
+        else:
+            props.active_library_referenced_source = 0
+        return {"FINISHED"}
+
+
+class DisableEditingClassificationReferences(bpy.types.Operator):
+    bl_idname = "bim.disable_editing_classification_references"
+    bl_label = "Disable Editing Classification References"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        props = context.scene.BIMClassificationProperties
+        props.available_library_references.clear()
        return {"FINISHED"}
@@ -17,8 +17,9 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import bpy
+from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.prop import StrProperty, Attribute
-from ifcopenshell.api.classification.data import Data
+from blenderbim.bim.module.classification.data import ClassificationsData
 from bpy.types import PropertyGroup
 from bpy.props import (
    PointerProperty,
@@ -31,42 +32,11 @@ from bpy.props import (
    CollectionProperty,
 )

-classification_enum = []

-
-def purge():
-    global classification_enum
-    classification_enum = []
-
-
-def getClassifications(self, context):
-    global classification_enum
-    if len(classification_enum) < 1:
-        classification_enum.clear()
-        classification_enum.extend([(str(i), n, "") for i, n in Data.library_classifications.items()])
-        if classification_enum:
-            getReferences(self, context, parent_id=int(classification_enum[0][0]))
-    return classification_enum
-
-
-def updateClassification(self, context):
-    getReferences(self, context, parent_id=int(self.available_classifications))
-
-
-def getReferences(self, context, parent_id=None):
-    props = context.scene.BIMClassificationProperties
-    props.available_library_references.clear()
-    for reference in Data.library_file.by_id(parent_id).HasReferences:
-        new = props.available_library_references.add()
-        new.identification = reference.Identification or ""
-        new.name = reference.Name or ""
-        new.ifc_definition_id = reference.id()
-        new.has_references = bool(reference.HasReferences)
-        new.referenced_source
-    if reference.ReferencedSource.is_a("IfcClassificationReference"):
-        props.active_library_referenced_source = reference.ReferencedSource.ReferencedSource.id()
-    else:
-        props.active_library_referenced_source = 0
+def get_available_classifications(self, context):
+    if not ClassificationsData.is_loaded:
+        ClassificationsData.load()
+    return ClassificationsData.data["available_classifications"]


 class ClassificationReference(PropertyGroup):
@@ -78,9 +48,7 @@ class ClassificationReference(PropertyGroup):


 class BIMClassificationProperties(PropertyGroup):
-    available_classifications: EnumProperty(
-        items=getClassifications, name="Available Classifications", update=updateClassification
-    )
+    available_classifications: EnumProperty(items=get_available_classifications, name="Available Classifications")
    classification_attributes: CollectionProperty(name="Classification Attributes", type=Attribute)
    active_classification_id: IntProperty(name="Active Classification Id")
    available_library_references: CollectionProperty(name="Available Library References", type=ClassificationReference)
@@ -16,10 +16,17 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

+import blenderbim.bim.helper
+import blenderbim.tool as tool
 import blenderbim.bim.module.classification.prop as classification_prop
 from bpy.types import Panel, UIList
 from blenderbim.bim.ifc import IfcStore
-from ifcopenshell.api.classification.data import Data
+from blenderbim.bim.module.classification.data import (
+    ClassificationsData,
+    ClassificationReferencesData,
+    MaterialClassificationsData,
+    CostClassificationsData,
+)


 class BIM_PT_classifications(Panel):
@@ -33,15 +40,15 @@ class BIM_PT_classifications(Panel):

    @classmethod
    def poll(cls, context):
-        return IfcStore.get_file()
+        return tool.Ifc.get()

    def draw(self, context):
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
+        if not ClassificationsData.is_loaded:
+            ClassificationsData.load()

        self.props = context.scene.BIMClassificationProperties

-        if Data.library_file:
+        if ClassificationsData.data["has_classification_file"]:
            row = self.layout.row(align=True)
            row.prop(self.props, "available_classifications", text="")
            row.operator("bim.load_classification_library", text="", icon="IMPORT")
@@ -51,36 +58,100 @@ class BIM_PT_classifications(Panel):
            row.label(text="No Active Classification Library")
            row.operator("bim.load_classification_library", text="", icon="IMPORT")

-        for classification_id, classification in Data.classifications.items():
-            if self.props.active_classification_id == classification_id:
-                self.draw_editable_ui(classification)
+        for classification in ClassificationsData.data["classifications"]:
+            if self.props.active_classification_id == classification["id"]:
+                self.draw_editable_ui()
            else:
-                self.draw_ui(classification_id, classification)
+                self.draw_ui(classification)

-    def draw_editable_ui(self, classification):
+    def draw_editable_ui(self):
        row = self.layout.row(align=True)
-        row.prop(self.props.classification_attributes.get("Name"), "string_value", text="", icon="ASSET_MANAGER")
-        row.operator("bim.edit_classification", text="", icon="CHECKMARK")
+        row.operator("bim.edit_classification", text="Save changes", icon="CHECKMARK")
        row.operator("bim.disable_editing_classification", text="", icon="CANCEL")
+        blenderbim.bim.helper.draw_attributes(self.props.classification_attributes, self.layout)

-        for attribute in self.props.classification_attributes:
-            if attribute.name == "Name":
-                continue
-            row = self.layout.row(align=True)
-            row.prop(attribute, "string_value", text=attribute.name)
-            if attribute.is_optional:
-                row.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
-
-    def draw_ui(self, classification_id, classification):
+    def draw_ui(self, classification):
        row = self.layout.row(align=True)
        row.label(text=classification["Name"], icon="ASSET_MANAGER")
        if not self.props.active_classification_id:
            op = row.operator("bim.enable_editing_classification", text="", icon="GREASEPENCIL")
-            op.classification = classification_id
-        row.operator("bim.remove_classification", text="", icon="X").classification = classification_id
+            op.classification = classification["id"]
+        row.operator("bim.remove_classification", text="", icon="X").classification = classification["id"]


-class BIM_PT_classification_references(Panel):
+class ReferenceUI:
+    def draw_ui(self, context):
+        obj = context.active_object
+        self.oprops = obj.BIMObjectProperties
+        self.sprops = context.scene.BIMClassificationProperties
+        self.props = obj.BIMClassificationReferenceProperties
+        self.file = IfcStore.get_file()
+
+        self.draw_add_ui(context)
+
+        if not self.data.data["references"]:
+            row = self.layout.row(align=True)
+            row.label(text="No References")
+
+        for reference in self.data.data["references"]:
+            if self.props.active_reference_id == reference["id"]:
+                self.draw_editable_ui()
+            else:
+                self.draw_reference_ui(reference)
+
+    def draw_add_ui(self, context):
+        if not self.data.data["is_available_classification_added"]:
+            return
+        row = self.layout.row(align=True)
+        row.prop(self.sprops, "available_classifications", text="")
+        if not self.sprops.available_library_references:
+            op = row.operator("bim.change_classification_level", text="", icon="IMPORT")
+            op.parent_id = int(self.sprops.available_classifications)
+            return
+        if self.sprops.active_library_referenced_source:
+            op = row.operator("bim.change_classification_level", text="", icon="FRAME_PREV")
+            op.parent_id = self.sprops.active_library_referenced_source
+        if self.sprops.active_library_reference_index < len(self.sprops.available_library_references):
+            op = row.operator("bim.add_classification_reference", text="", icon="ADD")
+            op.obj = self.obj
+            op.obj_type = self.obj_type
+            op.reference = self.sprops.available_library_references[
+                self.sprops.active_library_reference_index
+            ].ifc_definition_id
+        row.operator("bim.disable_editing_classification_references", text="", icon="CANCEL")
+        self.layout.template_list(
+            "BIM_UL_classifications",
+            "",
+            self.sprops,
+            "available_library_references",
+            self.sprops,
+            "active_library_reference_index",
+        )
+
+    def draw_editable_ui(self):
+        row = self.layout.row(align=True)
+        row.operator("bim.edit_classification_reference", text="Save changes", icon="CHECKMARK")
+        row.operator("bim.disable_editing_classification_reference", text="", icon="CANCEL")
+        blenderbim.bim.helper.draw_attributes(self.props.reference_attributes, self.layout)
+
+    def draw_reference_ui(self, reference):
+        row = self.layout.row(align=True)
+        if self.file.schema == "IFC2X3":
+            name = reference["ItemReference"] or "No Identification"
+        else:
+            name = reference["Identification"] or "No Identification"
+        row.label(text=name, icon="ASSET_MANAGER")
+        row.label(text=reference["Name"] or "")
+        if not self.props.active_reference_id:
+            op = row.operator("bim.enable_editing_classification_reference", text="", icon="GREASEPENCIL")
+            op.reference = reference["id"]
+        op = row.operator("bim.remove_classification_reference", text="", icon="X")
+        op.reference = reference["id"]
+        op.obj = self.obj
+        op.obj_type = self.obj_type
+
+
+class BIM_PT_classification_references(Panel, ReferenceUI):
    bl_label = "IFC Classification References"
    bl_idname = "BIM_PT_classification_references"
    bl_options = {"DEFAULT_CLOSED"}
@@ -93,85 +164,65 @@ class BIM_PT_classification_references(Panel):
    def poll(cls, context):
        if not context.active_object:
            return False
-        if not IfcStore.get_element(context.active_object.BIMObjectProperties.ifc_definition_id):
-            return False
-        return bool(context.active_object.BIMObjectProperties.ifc_definition_id)
+        return bool(tool.Ifc.get_entity(context.active_object))

    def draw(self, context):
-        obj = context.active_object
-        self.oprops = obj.BIMObjectProperties
-        self.sprops = context.scene.BIMClassificationProperties
-        self.props = obj.BIMClassificationReferenceProperties
-        self.file = IfcStore.get_file()
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
-        if self.oprops.ifc_definition_id not in Data.products:
-            Data.load(IfcStore.get_file(), self.oprops.ifc_definition_id)
+        if not ClassificationReferencesData.is_loaded:
+            ClassificationReferencesData.load()
+        self.data = ClassificationReferencesData
+        self.obj = context.active_object.name
+        self.obj_type = "Object"
+        self.draw_ui(context)

-        self.draw_add_ui(context)

-        reference_ids = Data.products[self.oprops.ifc_definition_id]
-        if not reference_ids:
-            row = self.layout.row(align=True)
-            row.label(text="No References")
+class BIM_PT_material_classifications(Panel, ReferenceUI):
+    bl_label = "IFC Material Classifications"
+    bl_idname = "BIM_PT_material_classifications"
+    bl_options = {"DEFAULT_CLOSED"}
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "material"

-        for reference_id in reference_ids:
-            reference = Data.references[reference_id]
-            if self.props.active_reference_id == reference_id:
-                self.draw_editable_ui(reference)
-            else:
-                self.draw_ui(reference_id, reference)
+    @classmethod
+    def poll(cls, context):
+        if not tool.Ifc.get():
+            return False
+        try:
+            return bool(context.active_object.active_material.BIMObjectProperties.ifc_definition_id)
+        except:
+            return False

-    def draw_add_ui(self, context):
-        if not classification_prop.getClassifications(self.sprops, context):
-            return
+    def draw(self, context):
+        if not MaterialClassificationsData.is_loaded:
+            MaterialClassificationsData.load()
+        self.data = MaterialClassificationsData
+        self.obj = context.active_object.active_material.name
+        self.obj_type = "Material"
+        self.draw_ui(context)

-        name = Data.library_classifications[int(self.sprops.available_classifications)]
-        if name in [c["Name"] for c in Data.classifications.values()]:
-            row = self.layout.row(align=True)
-            row.prop(self.sprops, "available_classifications", text="")
-            if self.sprops.active_library_referenced_source:
-                op = row.operator("bim.change_classification_level", text="", icon="FRAME_PREV")
-                op.parent_id = self.sprops.active_library_referenced_source
-            op = row.operator("bim.add_classification_reference", text="", icon="ADD")
-            op.reference = self.sprops.available_library_references[
-                self.sprops.active_library_reference_index
-            ].ifc_definition_id
-            self.layout.template_list(
-                "BIM_UL_classifications",
-                "",
-                self.sprops,
-                "available_library_references",
-                self.sprops,
-                "active_library_reference_index",
-            )

-    def draw_editable_ui(self, reference):
-        row = self.layout.row(align=True)
-        row.prop(self.props.reference_attributes.get("Name"), "string_value", text="", icon="ASSET_MANAGER")
-        row.operator("bim.edit_classification_reference", text="", icon="CHECKMARK")
-        row.operator("bim.disable_editing_classification_reference", text="", icon="CANCEL")
+class BIM_PT_cost_classifications(Panel, ReferenceUI):
+    bl_label = "IFC Cost Classifications"
+    bl_idname = "BIM_PT_cost_classifications"
+    bl_options = {"DEFAULT_CLOSED"}
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "scene"
+    bl_parent_id = "BIM_PT_cost_schedules"

-        for attribute in self.props.reference_attributes:
-            if attribute.name == "Name":
-                continue
-            row = self.layout.row(align=True)
-            row.prop(attribute, "string_value", text=attribute.name)
-            if attribute.is_optional:
-                row.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
+    @classmethod
+    def poll(cls, context):
+        if not tool.Ifc.get():
+            return False
+        return bool(context.scene.BIMCostProperties.cost_items)

-    def draw_ui(self, reference_id, reference):
-        row = self.layout.row(align=True)
-        if self.file.schema == "IFC2X3":
-            name = reference["ItemReference"] or "No Identification"
-        else:
-            name = reference["Identification"] or "No Identification"
-        row.label(text=name, icon="ASSET_MANAGER")
-        row.label(text=reference["Name"] or "")
-        if not self.props.active_reference_id:
-            op = row.operator("bim.enable_editing_classification_reference", text="", icon="GREASEPENCIL")
-            op.reference = reference_id
-        row.operator("bim.remove_classification_reference", text="", icon="X").reference = reference_id
+    def draw(self, context):
+        if not CostClassificationsData.is_loaded:
+            CostClassificationsData.load()
+        self.data = CostClassificationsData
+        self.obj = ""
+        self.obj_type = "Cost"
+        self.draw_ui(context)


 class BIM_UL_classifications(UIList):
@@ -64,8 +64,8 @@ class BIM_PT_context(bpy.types.Panel):
                row.operator("bim.remove_context", icon="X", text="").context = ifc_context["id"]

            row = box.row(align=True)
-            row.prop(props, "subcontexts", text="")
-            row.prop(props, "target_views", text="")
+            blenderbim.bim.helper.prop_with_search(row, props, "subcontexts", text="")
+            blenderbim.bim.helper.prop_with_search(row, props, "target_views", text="")
            op = row.operator("bim.add_context", icon="ADD", text="")
            op.context_type = ifc_context["context_type"]
            op.context_identifier = props.subcontexts
@@ -27,7 +27,7 @@ from blenderbim.bim.ifc import IfcStore
 from bpy_extras.io_utils import ImportHelper
 from ifcopenshell.api.cost.data import Data
 from ifcopenshell.api.unit.data import Data as UnitData
-from ifcopenshell.api.resource.data import Data as ResourceData
+from blenderbim.bim.module.resource.data import ResourceData


 class AddCostSchedule(bpy.types.Operator):
@@ -604,7 +604,7 @@ class AddCostValue(bpy.types.Operator):
        value = ifcopenshell.api.run("cost.add_cost_value", self.file, parent=parent)
        ifcopenshell.api.run("cost.edit_cost_value", self.file, cost_value=value, attributes=attributes)
        if parent.is_a("IfcConstructionResource"):
-            ResourceData.load(self.file)
+            ResourceData.load()
        else:
            Data.load(self.file)
        return {"FINISHED"}
@@ -630,7 +630,7 @@ class RemoveCostItemValue(bpy.types.Operator):
            cost_value=self.file.by_id(self.cost_value),
        )
        if parent.is_a("IfcConstructionResource"):
-            ResourceData.load(self.file)
+            ResourceData.load()
        else:
            Data.load(self.file)
        return {"FINISHED"}
@@ -923,24 +923,26 @@ class LoadCostItemQuantities(bpy.types.Operator):
    def execute(self, context):
        self.props = context.scene.BIMCostProperties
        self.file = IfcStore.get_file()
+        Data.load(self.file)
        self.props.cost_item_products.clear()
        self.props.cost_item_processes.clear()
        self.props.cost_item_resources.clear()
-        ifc_definition_id = self.props.cost_items[self.props.active_cost_item_index].ifc_definition_id
-        for control_id, quantity_ids in Data.cost_items[ifc_definition_id]["Controls"].items():
-            related_object = self.file.by_id(control_id)
-            if related_object.is_a("IfcProduct"):
-                new = self.props.cost_item_products.add()
-            elif related_object.is_a("IfcProcess"):
-                new = self.props.cost_item_processes.add()
-            elif related_object.is_a("IfcResource"):
-                new = self.props.cost_item_resources.add()
-            new.ifc_definition_id = control_id
-            new.name = related_object.Name or "Unnamed"
-            total_quantity = 0
-            for quantity_id in quantity_ids:
-                total_quantity += self.file.by_id(quantity_id)[3]
-            new.total_quantity = total_quantity
+        if self.props.cost_items:
+            ifc_definition_id = self.props.cost_items[self.props.active_cost_item_index].ifc_definition_id
+            for control_id, quantity_ids in Data.cost_items[ifc_definition_id]["Controls"].items() or {}:
+                related_object = self.file.by_id(control_id)
+                if related_object.is_a("IfcProduct"):
+                    new = self.props.cost_item_products.add()
+                elif related_object.is_a("IfcProcess"):
+                    new = self.props.cost_item_processes.add()
+                elif related_object.is_a("IfcResource"):
+                    new = self.props.cost_item_resources.add()
+                new.ifc_definition_id = control_id
+                new.name = related_object.Name or "Unnamed"
+                total_quantity = 0
+                for quantity_id in quantity_ids:
+                    total_quantity += self.file.by_id(quantity_id)[3]
+                new.total_quantity = total_quantity
        return {"FINISHED"}


@@ -19,6 +19,7 @@
 import bpy
 import ifcopenshell.api
 from blenderbim.bim.ifc import IfcStore
+from blenderbim.bim.module.classification.data import CostClassificationsData
 from ifcopenshell.api.cost.data import Data
 from ifcopenshell.api.pset.data import Data as PsetData
 from blenderbim.bim.prop import StrProperty, Attribute
@@ -164,6 +165,7 @@ def update_active_cost_item_index(self, context):
        bpy.ops.bim.load_cost_item_types()
    else:
        bpy.ops.bim.load_cost_item_quantities()
+    CostClassificationsData.load()


 def update_cost_item_identification(self, context):
@@ -343,6 +343,11 @@ class BIM_PT_cost_item_quantities(Panel):
        return False

    def draw(self, context):
+        if not Data.is_loaded:
+            Data.load(IfcStore.get_file())
+
+        if not UnitData.is_loaded:
+            UnitData.load(IfcStore.get_file())
        self.props = context.scene.BIMCostProperties

        cost_item = self.props.cost_items[self.props.active_cost_item_index]
@@ -112,6 +112,7 @@ class CreateAllShapes(bpy.types.Operator):
    def execute(self, context):
        self.file = IfcStore.get_file()
        elements = self.file.by_type("IfcElement") + self.file.by_type("IfcSpace")
+
        total = len(elements)
        settings = ifcopenshell.geom.settings()
        failures = []
@@ -25,6 +25,7 @@ classes = (
    operator.SelectDiffOldFile,
    operator.SelectDiffNewFile,
    operator.ExecuteIfcDiff,
+    prop.Relationships,
    prop.DiffProperties,
    ui.BIM_PT_diff,
 )
@@ -0,0 +1,86 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on 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.
+#
+# BlenderBIM Add-on 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 BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import bpy
+import json
+import blenderbim.tool as tool
+
+
+def refresh():
+    DiffData.is_loaded = False
+
+
+class DiffData:
+    data = {}
+    is_loaded = False
+    diff_json_file = None
+    diff = None
+
+    @classmethod
+    def load(cls):
+        cls.data["diff_json"] = cls.diff_json()
+        cls.data["total_added"] = cls.total_added()
+        cls.data["total_deleted"] = cls.total_deleted()
+        cls.data["total_changed"] = cls.total_changed()
+        cls.data["changes"] = cls.changes()
+        cls.is_loaded = True
+
+    @classmethod
+    def diff_json(cls):
+        props = bpy.context.scene.DiffProperties
+        if not props.diff_json_file:
+            cls.diff = None
+            return
+        if props.diff_json_file != cls.diff_json_file:
+            cls.diff_json_file = props.diff_json_file
+            with open(props.diff_json_file, "r") as file:
+                cls.diff = json.load(file)
+        return cls.diff
+
+    @classmethod
+    def total_added(cls):
+        diff = cls.diff_json()
+        if diff:
+            return len(diff["added"])
+
+    @classmethod
+    def total_deleted(cls):
+        diff = cls.diff_json()
+        if diff:
+            return len(diff["deleted"])
+
+    @classmethod
+    def total_changed(cls):
+        diff = cls.diff_json()
+        if diff:
+            return len(diff["changed"].keys())
+
+    @classmethod
+    def changes(cls):
+        diff = cls.diff_json()
+        if not diff:
+            return {}
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if not element or not hasattr(element, "GlobalId"):
+            return {}
+        changes = {k.upper().replace("_", " "): str(v) for k, v in diff["changed"].get(element.GlobalId, {}).items()}
+        if element.GlobalId in diff["added"]:
+            changes["Added"] = True
+        elif element.GlobalId in diff["deleted"]:
+            changes["Deleted"] = True
+        return changes
@@ -17,10 +17,11 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import bpy
+import json
 import ifccsv
 import ifcopenshell
-import json
-from blenderbim.bim.ifc import IfcStore
+import blenderbim.bim.handler
+import blenderbim.tool as tool


 class SelectDiffJsonFile(bpy.types.Operator):
@@ -28,6 +29,7 @@ class SelectDiffJsonFile(bpy.types.Operator):
    bl_label = "Select Diff JSON File"
    bl_options = {"REGISTER", "UNDO"}
    filepath: bpy.props.StringProperty(subtype="FILE_PATH")
+    filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})

    def execute(self, context):
        context.scene.DiffProperties.diff_json_file = self.filepath
@@ -44,21 +46,23 @@ class VisualiseDiff(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}

    def execute(self, context):
-        # ifc_file = IfcStore.get_file() # In case we get from Store
-        ifc_file = ifcopenshell.open(context.scene.DiffProperties.diff_new_file)  # for Now refer to the new file
+        ifc_file = tool.Ifc.get()
        with open(context.scene.DiffProperties.diff_json_file, "r") as file:
            diff = json.load(file)
        for obj in context.visible_objects:
-            obj.color = (1.0, 1.0, 1.0, 0.2)
-            global_id = ifc_file.by_id(obj.BIMObjectProperties.ifc_definition_id).GlobalId
+            obj.color = (1.0, 1.0, 1.0, 1.0)
+            element = tool.Ifc.get_entity(obj)
+            if not element:
+                continue
+            global_id = getattr(element, "GlobalId", None)
            if not global_id:
                continue
            if global_id in diff["deleted"]:
-                obj.color = (1.0, 0.0, 0.0, 0.2)
+                obj.color = (1.0, 0.0, 0.0, 1.0)
            elif global_id in diff["added"]:
-                obj.color = (0.0, 1.0, 0.0, 0.2)
+                obj.color = (0.0, 1.0, 0.0, 1.0)
            elif global_id in diff["changed"]:
-                obj.color = (0.0, 0.0, 1.0, 0.2)
+                obj.color = (0.0, 0.0, 1.0, 1.0)
        area = next(area for area in context.screen.areas if area.type == "VIEW_3D")
        area.spaces[0].shading.color_type = "OBJECT"
        return {"FINISHED"}
@@ -69,9 +73,10 @@ class SelectDiffOldFile(bpy.types.Operator):
    bl_label = "Select Diff Old File"
    bl_options = {"REGISTER", "UNDO"}
    filepath: bpy.props.StringProperty(subtype="FILE_PATH")
+    filter_glob: bpy.props.StringProperty(default="*.ifc", options={"HIDDEN"})

    def execute(self, context):
-        context.scene.DiffProperties.diff_old_file = self.filepath
+        context.scene.DiffProperties.old_file = self.filepath
        return {"FINISHED"}

    def invoke(self, context, event):
@@ -84,9 +89,10 @@ class SelectDiffNewFile(bpy.types.Operator):
    bl_label = "Select Diff New File"
    bl_options = {"REGISTER", "UNDO"}
    filepath: bpy.props.StringProperty(subtype="FILE_PATH")
+    filter_glob: bpy.props.StringProperty(default="*.ifc", options={"HIDDEN"})

    def execute(self, context):
-        context.scene.DiffProperties.diff_new_file = self.filepath
+        context.scene.DiffProperties.new_file = self.filepath
        return {"FINISHED"}

    def invoke(self, context, event):
@@ -110,12 +116,14 @@ class ExecuteIfcDiff(bpy.types.Operator):
        import ifcdiff

        ifc_diff = ifcdiff.IfcDiff(
-            context.scene.DiffProperties.diff_old_file,
-            context.scene.DiffProperties.diff_new_file,
+            context.scene.DiffProperties.old_file,
+            context.scene.DiffProperties.new_file,
            self.filepath,
-            context.scene.DiffProperties.diff_relationships.split(),
+            [r.relationship for r in context.scene.DiffProperties.diff_relationships],
+            context.scene.DiffProperties.diff_filter_elements,
        )
        ifc_diff.diff()
        ifc_diff.export()
        context.scene.DiffProperties.diff_json_file = self.filepath
+        blenderbim.bim.handler.refresh_ui_data()
        return {"FINISHED"}
@@ -18,6 +18,7 @@

 import bpy
 from blenderbim.bim.prop import StrProperty
+from blenderbim.bim.module.diff.data import DiffData
 from bpy.types import PropertyGroup
 from bpy.props import (
    PointerProperty,
@@ -31,8 +32,20 @@ from bpy.props import (
 )


+def update_diff_json_file(self, context):
+    DiffData.data["diff_json"] = DiffData.diff_json()
+
+
+class Relationships(PropertyGroup):
+    relationship: EnumProperty(
+        name="Relationship",
+        items=[(r, r.capitalize(), r) for r in ["type", "property", "container", "aggregate", "classification"]],
+    )
+
+
 class DiffProperties(PropertyGroup):
-    diff_json_file: StringProperty(default="", name="Diff JSON File")
-    diff_old_file: StringProperty(default="", name="Diff Old IFC File")
-    diff_new_file: StringProperty(default="", name="Diff New IFC File")
-    diff_relationships: StringProperty(default="", name="Diff Relationships")
+    diff_json_file: StringProperty(default="", name="JSON Output", update=update_diff_json_file)
+    old_file: StringProperty(default="", name="Old IFC File")
+    new_file: StringProperty(default="", name="New IFC File")
+    diff_relationships: CollectionProperty(type=Relationships, name="Relationships")
+    diff_filter_elements: StringProperty(default="", name="Filter")
@@ -18,6 +18,9 @@

 from bpy.types import Panel
 from blenderbim.bim.ifc import IfcStore
+from blenderbim.bim.module.diff.data import DiffData
+import blenderbim.tool as tool
+import json


 class BIM_PT_diff(Panel):
@@ -30,30 +33,70 @@ class BIM_PT_diff(Panel):
    bl_parent_id = "BIM_PT_quality_control"

    def draw(self, context):
+        if not DiffData.is_loaded:
+            DiffData.load()
+
        layout = self.layout
        layout.use_property_split = True

        scene = context.scene
-        bim_properties = scene.DiffProperties
+        props = scene.DiffProperties

        layout.label(text="IFC Diff Setup:")

        row = layout.row(align=True)
-        row.prop(bim_properties, "diff_old_file")
+        row.prop(props, "old_file")
        row.operator("bim.select_diff_old_file", icon="FILE_FOLDER", text="")

        row = layout.row(align=True)
-        row.prop(bim_properties, "diff_new_file")
+        row.prop(props, "new_file")
        row.operator("bim.select_diff_new_file", icon="FILE_FOLDER", text="")

        row = layout.row(align=True)
-        row.prop(bim_properties, "diff_relationships")
+        row.prop(props, "diff_relationships")
+        row.context_pointer_set("bim_prop_group", props)
+        add = row.operator("bim.edit_blender_collection", icon="ADD", text="")
+        add.option = "add"
+        add.collection = "diff_relationships"
+
+        for index, r in enumerate(props.diff_relationships):
+            row = layout.row(align=True)
+            row.context_pointer_set("bim_prop_group", props)
+            row.prop(r, "relationship", text=" ")
+            remove = row.operator("bim.edit_blender_collection", icon="REMOVE", text="")
+            remove.option = "remove"
+            remove.collection = "diff_relationships"
+            remove.index = index
+
+        row = layout.row(align=True)
+        row.prop(props, "diff_filter_elements")
+        row.operator("bim.ifc_selector", icon="FILTER", text="")

        row = layout.row()
        row.operator("bim.execute_ifc_diff")

-        # TODO: show if there ifc diff operation is sucessful
        row = layout.row(align=True)
-        row.prop(bim_properties, "diff_json_file")
+        row.prop(props, "diff_json_file")
        row.operator("bim.select_diff_json_file", icon="FILE_FOLDER", text="")
        row.operator("bim.visualise_diff", icon="HIDE_OFF", text="")
+
+        if DiffData.data["diff_json"]:
+            row = layout.row()
+            row.alignment = "CENTER"
+            row.label(text=f"{DiffData.data['total_added']} added")
+            row.label(text=f"{DiffData.data['total_deleted']} deleted")
+            row.label(text=f"{DiffData.data['total_changed']} changed")
+
+        if DiffData.data["changes"]:
+            box = layout.box()
+            row = box.row()
+            row.label(text="Active Object Changes:")
+            for key, value in DiffData.data["changes"].items():
+                row = box.row()
+                if key == "Added":
+                    icon = "ADD"
+                elif key == "Deleted":
+                    icon = "X"
+                else:
+                    icon = "GREASEPENCIL"
+                row.label(text=key, icon=icon)
@@ -33,24 +33,29 @@ classes = (
    operator.AddSheet,
    operator.BuildSchedule,
    operator.CleanWireframes,
+    operator.ContractSheet,
    operator.CopyGrid,
    operator.CreateDrawing,
    operator.CreateSheets,
+    operator.DisableEditingAssignedProduct,
    operator.DisableEditingDrawings,
+    operator.DisableEditingSchedules,
    operator.DisableEditingSheets,
    operator.DisableEditingText,
-    operator.DisableEditingTextProduct,
+    operator.EditAssignedProduct,
    operator.EditText,
-    operator.EditTextProduct,
    operator.EditVectorStyle,
+    operator.EnableEditingAssignedProduct,
    operator.EnableEditingText,
-    operator.EnableEditingTextProduct,
-    operator.GenerateReferences,
+    operator.ExpandSheet,
    operator.LoadDrawings,
+    operator.LoadSchedules,
    operator.LoadSheets,
+    operator.OpenSchedule,
    operator.OpenSheet,
    operator.OpenView,
    operator.RemoveDrawing,
+    operator.RemoveDrawingFromSheet,
    operator.RemoveDrawingStyle,
    operator.RemoveDrawingStyleAttribute,
    operator.RemoveSchedule,
@@ -58,7 +63,6 @@ classes = (
    operator.ResizeText,
    operator.SaveDrawingStyle,
    operator.SelectDocIfcFile,
-    operator.SelectScheduleFile,
    prop.Variable,
    prop.Drawing,
    prop.Schedule,
@@ -67,12 +71,14 @@ classes = (
    prop.DocProperties,
    prop.BIMCameraProperties,
    prop.BIMTextProperties,
+    prop.BIMAssignedProductProperties,
    ui.BIM_PT_camera,
    ui.BIM_PT_drawing_underlay,
    ui.BIM_PT_annotation_utilities,
    ui.BIM_PT_sheets,
    ui.BIM_PT_drawings,
    ui.BIM_PT_schedules,
+    ui.BIM_PT_product_assignments,
    ui.BIM_PT_text,
    ui.BIM_UL_drawinglist,
    ui.BIM_UL_sheets,
@@ -87,6 +93,7 @@ classes = (
 def register():
    bpy.types.Scene.DocProperties = bpy.props.PointerProperty(type=prop.DocProperties)
    bpy.types.Camera.BIMCameraProperties = bpy.props.PointerProperty(type=prop.BIMCameraProperties)
+    bpy.types.Object.BIMAssignedProductProperties = bpy.props.PointerProperty(type=prop.BIMAssignedProductProperties)
    bpy.types.Object.BIMTextProperties = bpy.props.PointerProperty(type=prop.BIMTextProperties)
    bpy.types.TextCurve.BIMTextProperties = bpy.props.PointerProperty(type=prop.BIMTextProperties)
    bpy.app.handlers.load_post.append(handler.toggleDecorationsOnLoad)
@@ -96,6 +103,8 @@ def register():
 def unregister():
    del bpy.types.Scene.DocProperties
    del bpy.types.Camera.BIMCameraProperties
+    del bpy.types.Object.BIMAssignedProductProperties
+    del bpy.types.Object.BIMTextProperties
    del bpy.types.TextCurve.BIMTextProperties
    bpy.app.handlers.load_post.remove(handler.toggleDecorationsOnLoad)
    bpy.app.handlers.depsgraph_update_pre.remove(handler.depsgraph_update_pre_handler)
@@ -151,23 +151,32 @@ class Annotator:
        return obj

    @staticmethod
-    def get_annotation_obj(object_type, data_type):
-        collection = bpy.context.scene.camera.users_collection[0]
+    def get_annotation_obj(drawing, object_type, data_type):
+        camera = tool.Ifc.get_object(drawing)
+        co1, _, _, _ = Annotator.get_placeholder_coords(camera)
+        matrix_world = camera.matrix_world.copy()
+        matrix_world[0][3] = co1.x
+        matrix_world[1][3] = co1.y
+        matrix_world[2][3] = co1.z
+        collection = camera.users_collection[0]
        if object_type == "TEXT":
            obj = bpy.data.objects.new(object_type, None)
+            obj.matrix_world = matrix_world
            collection.objects.link(obj)
            return obj
-        elif object_type == "TEXT_LEADER":
+        elif object_type in ("TEXT_LEADER", "SECTION_LEVEL"):
            data = bpy.data.curves.new(object_type, type="CURVE")
            data.dimensions = "3D"
            data.resolution_u = 2
            obj = bpy.data.objects.new(object_type, data)
+            obj.matrix_world = matrix_world
            collection.objects.link(obj)
            return obj
-        for obj in collection.objects:
-            element = tool.Ifc.get_entity(obj)
-            if element and element.ObjectType == object_type:
-                return obj
+        if object_type != "ANGLE":
+            for obj in collection.objects:
+                element = tool.Ifc.get_entity(obj)
+                if element and element.ObjectType == object_type:
+                    return obj
        if data_type == "mesh":
            data = bpy.data.meshes.new(object_type)
        elif data_type == "curve":
@@ -175,12 +184,14 @@ class Annotator:
            data.dimensions = "3D"
            data.resolution_u = 2
        obj = bpy.data.objects.new(object_type, data)
+        obj.matrix_world = matrix_world
        collection.objects.link(obj)
        return obj

    @staticmethod
-    def get_placeholder_coords():
-        camera = bpy.context.scene.camera
+    def get_placeholder_coords(camera=None):
+        if not camera:
+            camera = bpy.context.scene.camera
        z_offset = camera.matrix_world.to_quaternion() @ Vector((0, 0, -1))
        if bpy.context.scene.render.resolution_x > bpy.context.scene.render.resolution_y:
            y = (
@@ -22,18 +22,40 @@ import blenderbim.tool as tool


 def refresh():
+    ProductAssignmentsData.is_loaded = False
    TextData.is_loaded = False
    SheetsData.is_loaded = False
+    SchedulesData.is_loaded = False
    DrawingsData.is_loaded = False


+class ProductAssignmentsData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.data = {"relating_product": cls.relating_product()}
+        cls.is_loaded = True
+
+    @classmethod
+    def relating_product(cls):
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if not element or not element.is_a("IfcAnnotation"):
+            return
+        for rel in element.HasAssignments:
+            if rel.is_a("IfcRelAssignsToProduct"):
+                name = rel.RelatingProduct.Name or "Unnamed"
+                return f"{rel.RelatingProduct.is_a()}/{name}"
+
+
 class TextData:
    data = {}
    is_loaded = False

    @classmethod
    def load(cls):
-        cls.data = {"attributes": cls.attributes(), "relating_product": cls.relating_product()}
+        cls.data = {"attributes": cls.attributes()}
        cls.is_loaded = True

    @classmethod
@@ -48,15 +70,6 @@ class TextData:
            {"name": "BoxAlignment", "value": text_literal.BoxAlignment},
        ]

-    @classmethod
-    def relating_product(cls):
-        element = tool.Ifc.get_entity(bpy.context.active_object)
-        if not element or not element.is_a("IfcAnnotation") or element.ObjectType not in ["TEXT", "TEXT_LEADER"]:
-            return
-        for rel in element.HasAssignments:
-            if rel.is_a("IfcRelAssignsToProduct"):
-                return rel.RelatingProduct.Name or "Unnamed"
-

 class SheetsData:
    data = {}
@@ -94,3 +107,17 @@ class DrawingsData:
            )
            return results
        return [(h.upper(), h, "") for h in ["North", "South", "East", "West"]]
+
+
+class SchedulesData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.data = {"total_schedules": cls.total_schedules()}
+        cls.is_loaded = True
+
+    @classmethod
+    def total_schedules(cls):
+        return len([d for d in tool.Ifc.get().by_type("IfcDocumentInformation") if d.Scope == "SCHEDULE"])
@@ -40,7 +40,7 @@ class BaseDecorator:

    DEF_GLSL = """
        #define PI 3.141592653589793
-        #define MAX_POINTS 32
+        #define MAX_POINTS 64
        #define CIRCLE_SEGS 12
    """

@@ -170,12 +170,32 @@ class BaseDecorator:
        returns: iterable of blender objects
        """
        results = []
+        decoration_presets = (
+            "DIMENSION",
+            "TEXT_LEADER",
+            "STAIR_ARROW",
+            "HIDDEN_LINE",
+            "PLAN_LEVEL",
+            "SECTION_LEVEL",
+            "BREAKLINE",
+            "GRID",
+            "ELEVATION",
+            "SECTION",
+            "TEXT",
+        )
        for obj in collection.all_objects:
            element = tool.Ifc.get_entity(obj)
            if not element:
                continue
-            if element.is_a("IfcAnnotation") and element.ObjectType == self.objecttype:
-                results.append(obj)
+            if element.is_a("IfcAnnotation"):
+                if element.ObjectType == self.objecttype:
+                    results.append(obj)
+                elif (
+                    self.objecttype == "MISC"
+                    and element.ObjectType not in decoration_presets
+                    and isinstance(obj.data, bpy.types.Mesh)
+                ):
+                    results.append(obj)
        return results

    def get_path_geom(self, obj, topo=True):
@@ -247,7 +267,7 @@ class BaseDecorator:
        """perform actual drawing stuff"""
        raise NotImplementedError()

-    def draw_lines(self, context, obj, vertices, indices, topology=None):
+    def draw_lines(self, context, obj, vertices, indices, topology=None, is_scale_dependant=True):
        region = context.region
        region3d = context.region_data
        color = context.scene.DocProperties.decorations_colour
@@ -277,14 +297,15 @@ class BaseDecorator:
        self.shader.uniform_float("winsize", (region.width, region.height))
        self.shader.uniform_float("color", color)

-        # Horrific prototype code
-        factor = self.camera_zoom_to_factor(context.space_data.region_3d.view_camera_zoom)
-        camera_width_px = factor * context.region.width
-        mm_to_px = camera_width_px / self.camera_width_mm
-        # 0.00025 is a magic constant number I visually discovered to get the right number.
-        # It probably should be dynamically calculated using system.dpi or something.
-        viewport_drawing_scale = 0.00025 * mm_to_px
-        self.shader.uniform_float("viewportDrawingScale", viewport_drawing_scale)
+        if is_scale_dependant:
+            # Horrific prototype code
+            factor = self.camera_zoom_to_factor(context.space_data.region_3d.view_camera_zoom)
+            camera_width_px = factor * context.region.width
+            mm_to_px = camera_width_px / self.camera_width_mm
+            # 0.00025 is a magic constant number I visually discovered to get the right number.
+            # It probably should be dynamically calculated using system.dpi or something.
+            viewport_drawing_scale = 0.00025 * mm_to_px
+            self.shader.uniform_float("viewportDrawingScale", viewport_drawing_scale)

        batch.draw(self.shader)

@@ -357,11 +378,11 @@ class BaseDecorator:
            elif "/" in precision:
                precision = int(precision.split("/")[1])
        elif unit_system == "METRIC":
-            precision = 3
+            precision = 4
        else:
            return

-        return bpy.utils.units.to_string(unit_system, "LENGTH", value, precision=precision, split_unit=True)
+        return bpy.utils.units.to_string(unit_system, "LENGTH", value, precision=precision)


 class DimensionDecorator(BaseDecorator):
@@ -459,27 +480,8 @@ class DimensionDecorator(BaseDecorator):
            self.draw_label(context, text, p0 + (dir) * 0.5, dir)


-class EqualityDecorator(DimensionDecorator):
-    """Decorator for equality objects
-    - outlines each segment
-    - augments with arrows on both sides
-    - puts 'EQ' label
-    """
-
-    objecttype = "EQUAL_DIMENSION"
-
-    def draw_labels(self, context, obj, vertices, indices):
-        region = context.region
-        region3d = context.region_data
-        for i0, i1 in indices:
-            v0 = Vector(vertices[i0])
-            v1 = Vector(vertices[i1])
-            p0 = location_3d_to_region_2d(region, region3d, v0)
-            p1 = location_3d_to_region_2d(region, region3d, v1)
-            dir = p1 - p0
-            if dir.length < 1:
-                continue
-            self.draw_label(context, "EQ", p0 + (dir) * 0.5, dir)
+class DiameterDecorator(DimensionDecorator):
+    objecttype = "DIAMETER"


 class LeaderDecorator(BaseDecorator):
@@ -568,6 +570,98 @@ class LeaderDecorator(BaseDecorator):
        self.draw_label(context, obj.BIMTextProperties.value, pos, dir, gap=0, center=False, vcenter=False)


+class RadiusDecorator(BaseDecorator):
+    """Decorating text with arrows
+    - head point with arrow
+    """
+
+    objecttype = "RADIUS"
+
+    DEF_GLSL = (
+        BaseDecorator.DEF_GLSL
+        + """
+        #define ARROW_ANGLE PI / 12.0
+        #define ARROW_SIZE 16.0
+    """
+    )
+
+    GEOM_GLSL = """
+    uniform vec2 winsize;
+    uniform float viewportDrawingScale;
+
+    layout(lines) in;
+    layout(line_strip, max_vertices=MAX_POINTS) out;
+    in uint type[];
+
+    void main() {
+        vec4 clip2win = matCLIP2WIN();
+        vec4 win2clip = matWIN2CLIP();
+
+        vec4 p0 = gl_in[0].gl_Position, p1 = gl_in[1].gl_Position;
+        uint t0 = type[0], t1 = type[1];
+
+        vec4 p0w = CLIP2WIN(p0), p1w = CLIP2WIN(p1);
+        vec4 edge = p1w - p0w, dir = normalize(edge);
+        vec4 gap1 = vec4(0);
+
+        vec4 p;
+
+        // end edge arrow for last segment
+        if (t1 == 2u) {
+            vec4 head[3];
+            arrow_head(dir, viewportDrawingScale * ARROW_SIZE, ARROW_ANGLE, head);
+
+            gl_Position = p1;
+            EmitVertex();
+            p = p1w - head[1];
+            gl_Position = WIN2CLIP(p);
+            EmitVertex();
+            p = p1w - head[2];
+            gl_Position = WIN2CLIP(p);
+            EmitVertex();
+            gl_Position = p1;
+            EmitVertex();
+            EndPrimitive();
+
+            gap1 = dir * viewportDrawingScale * ARROW_SIZE;
+        }
+
+        // stem, adjusted for and arrow
+        gl_Position = p0;
+        EmitVertex();
+        p = p1w - gap1;
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        EndPrimitive();
+    }
+    """
+
+    def get_spline_end(self, obj):
+        spline = obj.data.splines[0]
+        spline_points = spline.bezier_points if spline.bezier_points else spline.points
+        if not spline_points:
+            return Vector((0, 0, 0))
+        return obj.matrix_world @ spline_points[0].co
+
+    def decorate(self, context, obj):
+        verts, idxs, topo = self.get_path_geom(obj)
+        self.draw_lines(context, obj, verts, idxs, topo)
+        self.draw_labels(context, obj)
+
+    def draw_labels(self, context, obj):
+        region = context.region
+        region3d = context.region_data
+        dir = Vector((1, 0))
+        pos = location_3d_to_region_2d(region, region3d, self.get_spline_end(obj))
+
+        spline = obj.data.splines[0]
+        spline_points = spline.bezier_points if spline.bezier_points else spline.points
+        if spline_points:
+            length = (spline_points[-1].co - spline_points[-2].co).length
+            text = self.format_value(context, length)
+            self.draw_label(context, text, pos, dir, gap=0, center=False, vcenter=False)
+
+
 class StairDecorator(BaseDecorator):
    """Decorating stairs
    - head point with arrow
@@ -671,6 +765,7 @@ class HiddenDecorator(BaseDecorator):

    GEOM_GLSL = """
    uniform vec2 winsize;
+    uniform float viewportDrawingScale;

    layout(lines) in;
    layout(line_strip, max_vertices=MAX_POINTS) out;
@@ -725,10 +820,61 @@ class HiddenDecorator(BaseDecorator):
        self.draw_lines(context, obj, verts, idxs)


-class MiscDecorator(HiddenDecorator):
+class MiscDecorator(BaseDecorator):
    objecttype = "MISC"

-    FRAG_GLSL = BaseDecorator.FRAG_GLSL
+    GEOM_GLSL = """
+    uniform vec2 winsize;
+    uniform float viewportDrawingScale;
+
+    layout(lines) in;
+    layout(line_strip, max_vertices=MAX_POINTS) out;
+
+    out float dist; // distance from starging point along segment
+
+    void main() {
+        vec4 clip2win = matCLIP2WIN();
+        vec4 win2clip = matWIN2CLIP();
+
+        vec4 p0 = gl_in[0].gl_Position, p1 = gl_in[1].gl_Position;
+
+        vec4 p0w = CLIP2WIN(p0), p1w = CLIP2WIN(p1);
+        vec4 edge = p1w - p0w, dir = normalize(edge);
+        vec4 gap = dir * 1;
+
+        vec4 p;
+
+        // NB: something should be used to affect position, otherwise compiler eliminates winsize
+
+        dist = 0;
+        p = p0w + gap;
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        dist = length(edge);
+        p = p1w - gap;
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        EndPrimitive();
+    }
+    """
+
+    FRAG_GLSL = """
+    uniform vec4 color;
+    in vec2 gl_FragCoord;
+    in float dist;
+    out vec4 fragColor;
+
+    void main() {
+        fragColor = color;
+    }
+    """
+
+    def decorate(self, context, obj):
+        if obj.data.is_editmode:
+            verts, idxs = self.get_editmesh_geom(obj)
+        else:
+            verts, idxs = self.get_mesh_geom(obj)
+        self.draw_lines(context, obj, verts, idxs, is_scale_dependant=False)


 class LevelDecorator(BaseDecorator):
@@ -923,7 +1069,7 @@ class SectionLevelDecorator(LevelDecorator):


 class BreakDecorator(BaseDecorator):
-    """Decorator for dimension objects
+    """Decorator for breakline objects
    - first edge of a mesh with zigzag thingy in the middle

    Uses first two vertices in verts list.
@@ -990,21 +1136,10 @@ class BreakDecorator(BaseDecorator):

    def decorate(self, context, obj):
        if obj.data.is_editmode:
-            verts = self.get_editmesh_geom(obj)
+            verts, idxs = self.get_editmesh_geom(obj)
        else:
-            verts = self.get_mesh_geom(obj)
-        self.draw_lines(context, obj, verts, [(0, 1)])
-
-    def get_mesh_geom(self, obj):
-        # first vertices only
-        vertices = [obj.matrix_world @ obj.data.vertices[i].co for i in (0, 1)]
-        return vertices
-
-    def get_editmesh_geom(self, obj):
-        # first vertices only
-        mesh = bmesh.from_edit_mesh(obj.data)
-        vertices = [obj.matrix_world @ v.co for v in mesh.edges[0].verts]
-        return vertices
+            verts, idxs = self.get_mesh_geom(obj)
+        self.draw_lines(context, obj, verts, idxs)


 class GridDecorator(BaseDecorator):
@@ -1125,15 +1260,15 @@ class GridDecorator(BaseDecorator):
        self.draw_label(context, text, p1, dir, vcenter=True, gap=0)


-class SectionViewDecorator(LevelDecorator):
-    objecttype = "SECTION"
+class ElevationDecorator(LevelDecorator):
+    objecttype = "ELEVATION"

    DEF_GLSL = (
        BaseDecorator.DEF_GLSL
        + """
        #define CIRCLE_SIZE 8.0
-        #define TRIANGLE_L 32.0
-        #define TRIANGLE_W 16.0
+        #define TRIANGLE_L 22.63
+        #define TRIANGLE_W 11.31
    """
    )

@@ -1144,12 +1279,14 @@ class SectionViewDecorator(LevelDecorator):
    layout(lines) in;
    layout(line_strip, max_vertices=MAX_POINTS) out;

-    void triangle_head(in vec4 dir, in vec4 side, in float length, in float width, out vec4 head[3]) {
-        vec4 nose = dir * length;
-        vec4 ear = side * width;
-        head[0] = vec4(0);
-        head[1] = nose * .5 + ear;
-        head[2] = nose;
+    void triangle_head(in vec4 side, in vec4 dir, in float length, in float width, in float radius, out vec4 head[5]) {
+        vec4 nose = side * length;
+        vec4 ear = dir * width;
+        head[0] = side * -radius;
+        head[1] = nose * -.5;
+        head[2] = vec4(0) + ear;
+        head[3] = nose * .5;
+        head[4] = side * radius;
    }

    void main() {
@@ -1160,75 +1297,205 @@ class SectionViewDecorator(LevelDecorator):

        vec4 p0w = CLIP2WIN(p0), p1w = CLIP2WIN(p1);
        vec4 edge = p1w - p0w, dir = normalize(edge);
-        vec4 gap = dir * viewportDrawingScale * TRIANGLE_L * .5;
        vec4 side = vec4(cross(vec3(dir.xy, 0), vec3(0, 0, 1)).xy, 0, 0);
        vec4 p;

        vec4 head[CIRCLE_SEGS];
        circle_head(viewportDrawingScale * CIRCLE_SIZE, head);

-        vec4 head3[3];
+        vec4 head5[5];

        // start edge circle
        for(int i=0; i<CIRCLE_SEGS; i++) {
-            p = p0w + gap + head[i];
+            p = p0w + head[i];
            gl_Position = WIN2CLIP(p);
            EmitVertex();
        }
-        p = p0w + gap + head[0];
+        p = p0w + head[0];
        gl_Position = WIN2CLIP(p);
        EmitVertex();
        EndPrimitive();

-        // start edge triangle
-        triangle_head(dir, -side, viewportDrawingScale * TRIANGLE_L, viewportDrawingScale * TRIANGLE_W, head3);
-        p = p0w + head3[0];
+        // edge triangle
+        triangle_head(side, dir, viewportDrawingScale * TRIANGLE_L, viewportDrawingScale * TRIANGLE_W, viewportDrawingScale * CIRCLE_SIZE, head5);
+        p = p0w + head5[0];
        gl_Position = WIN2CLIP(p);
        EmitVertex();
-        p = p0w + head3[1];
+        p = p0w + head5[1];
        gl_Position = WIN2CLIP(p);
        EmitVertex();
-        p = p0w + head3[2];
+        p = p0w + head5[2];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p0w + head5[3];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p0w + head5[4];
        gl_Position = WIN2CLIP(p);
        EmitVertex();
        EndPrimitive();

-        // end edge circle
-        for(int i=0; i<CIRCLE_SEGS; i++) {
-            p = p1w - gap + head[i];
-            gl_Position = WIN2CLIP(p);
-            EmitVertex();
-        }
-        p = p1w - gap + head[0];
+        // reference divider
+        p = p0w + normalize(vec4(-1, 0, 0, 0)) * viewportDrawingScale * CIRCLE_SIZE;
        gl_Position = WIN2CLIP(p);
        EmitVertex();
-        EndPrimitive();
-
-        // end edge triangle
-        triangle_head(-dir, -side, viewportDrawingScale * TRIANGLE_L, viewportDrawingScale * TRIANGLE_W, head3);
-        p = p1w + head3[0];
+        p = p0w + normalize(vec4(1, 0, 0, 0)) * viewportDrawingScale * CIRCLE_SIZE;
        gl_Position = WIN2CLIP(p);
        EmitVertex();
-        p = p1w + head3[1];
-        gl_Position = WIN2CLIP(p);
-        EmitVertex();
-        p = p1w + head3[2];
-        gl_Position = WIN2CLIP(p);
-        EmitVertex();
-        EndPrimitive();
-
-        // stem
-        gl_Position = p0;
-        EmitVertex();
-        gl_Position = p1;
-        EmitVertex();
        EndPrimitive();
    }
    """

    def decorate(self, context, obj):
-        verts, _, _ = self.get_path_geom(obj, topo=False)
-        self.draw_lines(context, obj, verts, [(0, 1)])
+        center = obj.matrix_world.translation
+        v1 = obj.matrix_world @ Vector((0, 0, 0))
+        v2 = obj.matrix_world @ Vector((0, 0, -1))
+        self.draw_lines(context, obj, [v1, v2], [(0, 1)])
+
+
+class SectionDecorator(LevelDecorator):
+    objecttype = "SECTION"
+
+    DEF_GLSL = (
+        BaseDecorator.DEF_GLSL
+        + """
+        #define CIRCLE_SIZE 8.0
+        #define TRIANGLE_L 22.63
+        #define TRIANGLE_W 11.31
+    """
+    )
+
+    GEOM_GLSL = """
+    uniform vec2 winsize;
+    uniform float viewportDrawingScale;
+
+    layout(lines) in;
+    layout(line_strip, max_vertices=MAX_POINTS) out;
+
+    void triangle_head(in vec4 side, in vec4 dir, in float length, in float width, in float radius, out vec4 head[5]) {
+        vec4 nose = side * length;
+        vec4 ear = dir * width;
+        head[0] = side * -radius;
+        head[1] = nose * -.5;
+        head[2] = vec4(0) + ear;
+        head[3] = nose * .5;
+        head[4] = side * radius;
+    }
+
+    void main() {
+        vec4 clip2win = matCLIP2WIN();
+        vec4 win2clip = matWIN2CLIP();
+
+        vec4 p0 = gl_in[0].gl_Position, p1 = gl_in[1].gl_Position;
+
+        vec4 p0w = CLIP2WIN(p0), p1w = CLIP2WIN(p1);
+        vec4 edge = p1w - p0w, side = normalize(edge);
+        vec4 gap = side * viewportDrawingScale * CIRCLE_SIZE;
+        vec4 dir = vec4(cross(vec3(side.xy, 0), vec3(0, 0, 1)).xy, 0, 0);
+        vec4 p;
+
+        vec4 head[CIRCLE_SEGS];
+        circle_head(viewportDrawingScale * CIRCLE_SIZE, head);
+
+        vec4 head5[5];
+
+        // start edge circle
+        for(int i=0; i<CIRCLE_SEGS; i++) {
+            p = p0w + head[i];
+            gl_Position = WIN2CLIP(p);
+            EmitVertex();
+        }
+        p = p0w + head[0];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        EndPrimitive();
+
+        // start edge triangle
+        triangle_head(side, dir, viewportDrawingScale * TRIANGLE_L, viewportDrawingScale * TRIANGLE_W, viewportDrawingScale * CIRCLE_SIZE, head5);
+        p = p0w + head5[0];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p0w + head5[1];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p0w + head5[2];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p0w + head5[3];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p0w + head5[4];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        EndPrimitive();
+
+        // start reference divider
+        p = p0w + normalize(vec4(-1, 0, 0, 0)) * viewportDrawingScale * CIRCLE_SIZE;
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p0w + normalize(vec4(1, 0, 0, 0)) * viewportDrawingScale * CIRCLE_SIZE;
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        EndPrimitive();
+
+        // end edge circle
+        for(int i=0; i<CIRCLE_SEGS; i++) {
+            p = p1w - head[i];
+            gl_Position = WIN2CLIP(p);
+            EmitVertex();
+        }
+        p = p1w - head[0];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        EndPrimitive();
+
+        // end edge triangle
+        triangle_head(side, dir, viewportDrawingScale * TRIANGLE_L, viewportDrawingScale * TRIANGLE_W, viewportDrawingScale * CIRCLE_SIZE, head5);
+        p = p1w + head5[0];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p1w + head5[1];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p1w + head5[2];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p1w + head5[3];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p1w + head5[4];
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        EndPrimitive();
+
+        // end reference divider
+        p = p1w + normalize(vec4(-1, 0, 0, 0)) * viewportDrawingScale * CIRCLE_SIZE;
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p1w + normalize(vec4(1, 0, 0, 0)) * viewportDrawingScale * CIRCLE_SIZE;
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        EndPrimitive();
+
+        // stem
+        p = p0w + gap;
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        p = p1w - gap;
+        gl_Position = WIN2CLIP(p);
+        EmitVertex();
+        EndPrimitive();
+    }
+    """
+
+    def decorate(self, context, obj):
+        if obj.data.is_editmode:
+            verts, idxs = self.get_editmesh_geom(obj)
+        else:
+            verts, idxs = self.get_mesh_geom(obj)
+        vert_map = {v.freeze(): (obj.matrix_world.inverted() @ v).x for v in verts}
+        verts = sorted(verts, key=lambda v: vert_map[v], reverse=True)
+        self.draw_lines(context, obj, verts, idxs)


 class TextDecorator(BaseDecorator):
@@ -1318,16 +1585,18 @@ class TextDecorator(BaseDecorator):
 class DecorationsHandler:
    decorators_classes = [
        DimensionDecorator,
-        EqualityDecorator,
        GridDecorator,
        HiddenDecorator,
        LeaderDecorator,
+        RadiusDecorator,
+        DiameterDecorator,
        MiscDecorator,
        PlanLevelDecorator,
        SectionLevelDecorator,
        StairDecorator,
        BreakDecorator,
-        SectionViewDecorator,
+        SectionDecorator,
+        ElevationDecorator,
        TextDecorator,
    ]

@@ -317,7 +317,7 @@ class OffsetHandle:
        base = Vector((0, 0, 0))
        axis = Vector((0, 0, 1))

-        # projecttion of the arrow to a plane, perpendicular to view ray
+        # projection of the arrow to a plane, perpendicular to view ray
        axis_proj = axis - ray_norm * axis.dot(ray_norm)

        # intersection of the axis with the plane through view origin perpendicular to the arrow projection
@@ -88,17 +88,17 @@ class BoundingBox:
    def intersect(self, bb):
        retVal = False
        if self.vertex != None and bb.vertex != None:
-            # check all the faces of this object for a seperation axis
+            # check all the faces of this object for a separation axis
            for i, f in enumerate(self.face):
                d = f.normal
                if self.whichSide(bb.vertex, d, f.vertex[0]) > 0:
-                    return False  # all the vertexes are on the +ve side of the face
+                    return False  # all the vertices are on the +ve side of the face

            # now do it again for the other objects faces
            for i, f in enumerate(bb.face):
                d = f.normal
                if self.whichSide(self.vertex, d, f.vertex[0]) > 0:
-                    return False  # all the vertexes are on the +ve side of the face
+                    return False  # all the vertices are on the +ve side of the face

            # do edge checks
            for e1 in self.edge:
@@ -139,7 +139,7 @@ def format_distance(value, isArea=False, hide_units=True):

    value *= scaleFactor

-    # Imperial Formating
+    # Imperial Formatting
    if unit_system == "IMPERIAL":
        precision = bpy.context.scene.BIMProperties.imperial_precision
        if precision == "NONE":
@@ -152,7 +152,7 @@ def format_distance(value, isArea=False, hide_units=True):
        base = int(precision)
        decInches = value * toInches

-        # Seperate ft and inches
+        # Separate ft and inches
        # Unless Inches are the specified Length Unit
        if unit_length != "INCHES":
            feet = math.floor(decInches / inPerFoot)
@@ -160,7 +160,7 @@ def format_distance(value, isArea=False, hide_units=True):
        else:
            feet = 0

-        # Seperate Fractional Inches
+        # Separate Fractional Inches
        inches = math.floor(decInches)
        if inches != 0:
            frac = round(base * (decInches - inches))
@@ -202,7 +202,7 @@ def format_distance(value, isArea=False, hide_units=True):
        else:
            tx_dist = str("%1.3f" % (value * toInches / inPerFoot)) + " sq. ft."

-    # METRIC FORMATING
+    # METRIC FORMATTING
    elif unit_system == "METRIC":
        precision = bpy.context.scene.BIMProperties.metric_precision
        if precision != 0:
@@ -260,14 +260,11 @@ def format_distance(value, isArea=False, hide_units=True):
 def get_active_drawing(scene):
    """Get active drawing collection and camera"""
    props = scene.DocProperties
-    if props.active_drawing_index is None or len(props.drawings) == 0:
-        return None, None
    try:
-        drawing = props.active_drawing
-        camera = tool.Ifc.get_object(tool.Ifc.get().by_id(drawing.ifc_definition_id))
+        camera = tool.Ifc.get_object(tool.Ifc.get().by_id(props.active_drawing_id))
        return camera.users_collection[0], camera
-    except (KeyError, IndexError):
-        raise RuntimeError("missing drawing collection")
+    except:
+        return None, None


 def get_project_collection(scene):
@@ -40,7 +40,8 @@ import blenderbim.bim.module.drawing.scheduler as scheduler
 import blenderbim.bim.module.drawing.helper as helper
 import blenderbim.bim.export_ifc
 from lxml import etree
-from mathutils import Vector, Matrix, Euler, geometry
+from mathutils import Vector
+from timeit import default_timer as timer
 from blenderbim.bim.module.drawing.prop import RasterStyleProperty
 from blenderbim.bim.ifc import IfcStore
 from ifcopenshell.api.group.data import Data as GroupData
@@ -49,11 +50,26 @@ from ifcopenshell.api.pset.data import Data as PsetData
 cwd = os.path.dirname(os.path.realpath(__file__))


+class profile:
+    """
+    A python context manager timing utility
+    """
+
+    def __init__(self, task):
+        self.task = task
+
+    def __enter__(self):
+        self.start = timer()
+
+    def __exit__(self, *args):
+        print(self.task, timer() - self.start)
+
+
 def open_with_user_command(user_command, path):
    if user_command:
        commands = eval(user_command)
        for command in commands:
-            subprocess.run(command)
+            subprocess.Popen(command)
    else:
        webbrowser.open("file://" + path)

@@ -82,6 +98,11 @@ class AddDrawing(bpy.types.Operator, Operator):
            target_view=self.props.target_view,
            location_hint=hint,
        )
+        try:
+            drawing = tool.Ifc.get().by_id(self.props.active_drawing_id)
+            core.sync_references(tool.Ifc, tool.Collector, tool.Drawing, drawing=drawing)
+        except:
+            pass


 class CreateDrawing(bpy.types.Operator):
@@ -110,52 +131,75 @@ class CreateDrawing(bpy.types.Operator):
        self.camera = context.scene.camera
        self.camera_element = tool.Ifc.get_entity(self.camera)
        self.file = IfcStore.get_file()
-        self.time = None
-        start = time.time()
-        self.profile_code("Start drawing generation process")
-        self.props = context.scene.DocProperties
-        self.drawing_name = self.file.by_id(self.camera.BIMObjectProperties.ifc_definition_id).Name
-        self.get_scale()
-        if self.camera.data.BIMCameraProperties.update_representation(self.camera):
-            bpy.ops.bim.update_representation(obj=self.camera.name, ifc_representation_class="")
-        underlay_svg = self.generate_underlay(context)
-        self.profile_code("Generate underlay")
-        linework_svg = self.generate_linework(context)
-        self.profile_code("Generate linework")
-        annotation_svg = self.generate_annotation(context)
-        self.profile_code("Generate annotation")
-        svg_path = self.combine_svgs(context, underlay_svg, linework_svg, annotation_svg)
-        self.profile_code("Combine SVG layers")
+
+        with profile("Drawing generation process"):
+
+            with profile("Initialize drawing generation process"):
+                self.props = context.scene.DocProperties
+                self.cprops = self.camera.data.BIMCameraProperties
+                self.drawing_name = self.file.by_id(self.camera.BIMObjectProperties.ifc_definition_id).Name
+                self.get_scale()
+                if self.cprops.update_representation(self.camera):
+                    bpy.ops.bim.update_representation(obj=self.camera.name, ifc_representation_class="")
+
+                self.svg_writer = svgwriter.SvgWriter()
+                self.svg_writer.human_scale = self.human_scale
+                self.svg_writer.scale = self.scale
+                self.svg_writer.data_dir = context.scene.BIMProperties.data_dir
+                self.svg_writer.camera = self.camera
+                self.svg_writer.camera_width, self.svg_writer.camera_height = self.get_camera_dimensions()
+                self.svg_writer.camera_projection = tuple(self.camera.matrix_world.to_quaternion() @ Vector((0, 0, -1)))
+
+            with profile("Generate underlay"):
+                underlay_svg = self.generate_underlay(context)
+
+            with profile("Generate linework"):
+                linework_svg = self.generate_linework(context)
+
+            with profile("Generate annotation"):
+                annotation_svg = self.generate_annotation(context)
+
+            with profile("Combine SVG layers"):
+                svg_path = self.combine_svgs(context, underlay_svg, linework_svg, annotation_svg)
+
        open_with_user_command(context.preferences.addons["blenderbim"].preferences.svg_command, svg_path)
-        print("Total Time: {:.2f}".format(time.time() - start))
+
        return {"FINISHED"}

-    def profile_code(self, message):
-        if not self.time:
-            self.time = time.time()
-        print("{} :: {:.2f}".format(message, time.time() - self.time))
-        self.time = time.time()
+    def get_camera_dimensions(self):
+        render = bpy.context.scene.render
+        if self.is_landscape(render):
+            width = self.camera.data.ortho_scale
+            height = width / render.resolution_x * render.resolution_y
+        else:
+            height = self.camera.data.ortho_scale
+            width = height / render.resolution_y * render.resolution_x
+        return width, height

    def combine_svgs(self, context, underlay, linework, annotation):
        # Hacky :)
        svg_path = os.path.join(context.scene.BIMProperties.data_dir, "diagrams", self.drawing_name + ".svg")
        with open(svg_path, "w") as outfile:
-            has_boilerplate = False
+            pset = ifcopenshell.util.element.get_psets(self.camera_element)["EPset_Drawing"]
+            self.svg_writer.create_blank_svg(svg_path).define_boilerplate(
+                pset.get("Stylesheet"), pset.get("Markers"), pset.get("Symbols"), pset.get("Patterns")
+            )
+            boilerplate = self.svg_writer.svg.tostring()
+            outfile.write(boilerplate.replace("</svg>", ""))
            if underlay:
                with open(underlay) as infile:
-                    for line in infile:
-                        if "<svg " in line:
-                            line = line.replace('">', '" xmlns:ifc="http://www.ifcopenshell.org/ns">')
-                        if "</svg>" in line:
+                    for i, line in enumerate(infile):
+                        if i < 2:
+                            continue
+                        elif "</svg>" in line:
                            continue
                        outfile.write(line)
                shutil.copyfile(underlay[0:-4] + ".png", svg_path[0:-4] + "-underlay.png")
-                has_boilerplate = True
            if linework:
                with open(linework) as infile:
                    should_skip = False
                    for i, line in enumerate(infile):
-                        if has_boilerplate and i == 0:
+                        if i == 0:
                            continue
                        if "</svg>" in line:
                            continue
@@ -168,11 +212,10 @@ class CreateDrawing(bpy.types.Operator):
                        elif should_skip:
                            continue
                        outfile.write(line)
-                has_boilerplate = True
            if annotation:
                with open(annotation) as infile:
                    for i, line in enumerate(infile):
-                        if has_boilerplate and i in [0, 1]:
+                        if i < 2:
                            continue
                        if "</svg>" in line:
                            continue
@@ -181,13 +224,11 @@ class CreateDrawing(bpy.types.Operator):
        return svg_path

    def generate_underlay(self, context):
-        if not self.props.has_underlay:
+        if not self.cprops.has_underlay:
            return
        svg_path = os.path.join(context.scene.BIMProperties.data_dir, "cache", self.drawing_name + "-underlay.svg")
        context.scene.render.filepath = svg_path[0:-4] + ".png"
-        drawing_style = context.scene.DocProperties.drawing_styles[
-            self.camera.data.BIMCameraProperties.active_drawing_style_index
-        ]
+        drawing_style = context.scene.DocProperties.drawing_styles[self.cprops.active_drawing_style_index]

        if drawing_style.render_type == "DEFAULT":
            bpy.ops.render.render(write_still=True)
@@ -219,41 +260,24 @@ class CreateDrawing(bpy.types.Operator):
            for name, value in previous_visibility.items():
                bpy.data.objects[name].hide_set(value)

-        svg_writer = svgwriter.SvgWriter()
-        render = context.scene.render
-        if self.is_landscape(render):
-            width = self.camera.data.ortho_scale
-            height = width / render.resolution_x * render.resolution_y
-        else:
-            height = self.camera.data.ortho_scale
-            width = height / render.resolution_y * render.resolution_x
-        svg_writer.human_scale = self.human_scale
-        svg_writer.scale = self.scale
-        svg_writer.output = svg_path
-        svg_writer.data_dir = context.scene.BIMProperties.data_dir
-        svg_writer.vector_style = drawing_style.vector_style
-        svg_writer.camera = self.camera
-        svg_writer.camera_width = width
-        svg_writer.camera_height = height
-        svg_writer.camera_projection = tuple(self.camera.matrix_world.to_quaternion() @ Vector((0, 0, -1)))
-        svg_writer.background_image = context.scene.render.filepath
-        svg_writer.write("underlay")
+        self.svg_writer.create_blank_svg(svg_path).draw_underlay(context.scene.render.filepath).save()
        return svg_path

    def generate_linework(self, context):
-        if not self.props.has_linework:
+        if not self.cprops.has_linework:
            return
        svg_path = os.path.join(context.scene.BIMProperties.data_dir, "cache", self.drawing_name + "-linework.svg")
        if os.path.isfile(svg_path) and self.props.should_use_linework_cache:
            return svg_path

-        # All very hackish whilst prototyping
-        exporter = blenderbim.bim.export_ifc.IfcExporter(None)
-        exporter.file = tool.Ifc.get()
-        invalidated_guids = exporter.sync_deletions()
-        invalidated_elements = exporter.sync_all_objects()
-        invalidated_elements += exporter.sync_edited_objects()
-        [invalidated_guids.append(e.GlobalId) for e in invalidated_elements if hasattr(e, "GlobalId")]
+        with profile("sync"):
+            # All very hackish whilst prototyping
+            exporter = blenderbim.bim.export_ifc.IfcExporter(None)
+            exporter.file = tool.Ifc.get()
+            invalidated_guids = exporter.sync_deletions()
+            invalidated_elements = exporter.sync_all_objects()
+            invalidated_elements += exporter.sync_edited_objects()
+            [invalidated_guids.append(e.GlobalId) for e in invalidated_elements if hasattr(e, "GlobalId")]

        # If we have already calculated it in the SVG in the past, don't recalculate
        edited_guids = set()
@@ -298,54 +322,59 @@ class CreateDrawing(bpy.types.Operator):
                    body_contexts.append(rep_context.id())
                    continue

-            elements = set(ifc.by_type("IfcElement")) - set(ifc.by_type("IfcOpeningElement"))
+            elements = tool.Drawing.get_drawing_elements(self.camera_element)

            self.setup_serialiser(ifc)
-            cache_settings = ifcopenshell.geom.settings(DISABLE_TRIANGULATION=True)
            cache = IfcStore.get_cache()
            [cache.remove(guid) for guid in invalidated_guids]

-            if target_view_contexts and elements:
-                geom_settings = ifcopenshell.geom.settings(DISABLE_TRIANGULATION=True, INCLUDE_CURVES=True)
-                geom_settings.set_context_ids(target_view_contexts)
-                it = ifcopenshell.geom.iterator(geom_settings, ifc, multiprocessing.cpu_count(), include=elements)
-                it.set_cache(cache)
-                processed = set()
-                for elem in self.yield_from_iterator(it):
-                    processed.add(ifc.by_id(elem.id))
-                    self.serialiser.write(elem)
-                elements -= processed
+            with profile("Processing target view context"):
+                if target_view_contexts and elements:
+                    geom_settings = ifcopenshell.geom.settings(
+                        DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True, INCLUDE_CURVES=True
+                    )
+                    geom_settings.set_context_ids(target_view_contexts)
+                    it = ifcopenshell.geom.iterator(geom_settings, ifc, multiprocessing.cpu_count(), include=elements)
+                    it.set_cache(cache)
+                    processed = set()
+                    for elem in self.yield_from_iterator(it):
+                        processed.add(ifc.by_id(elem.id))
+                        self.serialiser.write(elem)
+                    elements -= processed

-            if body_contexts and elements:
-                geom_settings = ifcopenshell.geom.settings(
-                    DISABLE_TRIANGULATION=True,
-                )
-                geom_settings.set_context_ids(body_contexts)
-                it = ifcopenshell.geom.iterator(geom_settings, ifc, multiprocessing.cpu_count(), include=elements)
-                it.set_cache(cache)
+            with profile("Processing body context"):
+                if body_contexts and elements:
+                    geom_settings = ifcopenshell.geom.settings(DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True)
+                    geom_settings.set_context_ids(body_contexts)
+                    it = ifcopenshell.geom.iterator(geom_settings, ifc, multiprocessing.cpu_count(), include=elements)
+                    it.set_cache(cache)
+                    for elem in self.yield_from_iterator(it):
+                        self.serialiser.write(elem)
+
+            with profile("Camera element"):
+                # @todo tfk: is this needed?
+                geom_settings = ifcopenshell.geom.settings(DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True)
+                it = ifcopenshell.geom.iterator(geom_settings, ifc, include=[self.camera_element])
                for elem in self.yield_from_iterator(it):
                    self.serialiser.write(elem)

-            geom_settings = ifcopenshell.geom.settings(
-                DISABLE_TRIANGULATION=True,
-            )
-            it = ifcopenshell.geom.iterator(geom_settings, ifc, include=[self.camera_element])
-            for elem in self.yield_from_iterator(it):
-                self.serialiser.write(elem)
-
-        self.serialiser.finalize()
+        with profile("Finalizing"):
+            self.serialiser.finalize()
        results = self.svg_buffer.get_value()

-        root = etree.fromstring(results)
-        self.enrich_linework_with_metadata(root)
-        self.move_projection_to_bottom(root)
-        with open(svg_path, "wb") as svg:
-            svg.write(etree.tostring(root))
+        with profile("Post processing"):
+            root = etree.fromstring(results)
+            self.enrich_linework_with_metadata(root)
+            self.move_projection_to_bottom(root)
+            with open(svg_path, "wb") as svg:
+                svg.write(etree.tostring(root))

        return svg_path

    def setup_serialiser(self, ifc):
-        self.svg_settings = ifcopenshell.geom.settings(DISABLE_TRIANGULATION=True, INCLUDE_CURVES=True)
+        self.svg_settings = ifcopenshell.geom.settings(
+            DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True, INCLUDE_CURVES=True
+        )
        self.svg_buffer = ifcopenshell.geom.serializers.buffer()
        self.serialiser = ifcopenshell.geom.serializers.svg(self.svg_buffer, self.svg_settings)
        self.serialiser.setFile(ifc)
@@ -406,74 +435,19 @@ class CreateDrawing(bpy.types.Operator):
        return re.sub("[^0-9a-zA-Z]+", "", name)

    def generate_annotation(self, context):
-        if not self.props.has_annotation:
+        if not self.cprops.has_annotation:
            return
        svg_path = os.path.join(context.scene.BIMProperties.data_dir, "cache", self.drawing_name + "-annotation.svg")
        if os.path.isfile(svg_path) and self.props.should_use_annotation_cache:
            return svg_path

-        camera = self.camera
-        svg_writer = svgwriter.SvgWriter()
+        elements = tool.Drawing.get_group_elements(tool.Drawing.get_drawing_group(self.camera_element))
+        annotations = sorted(elements, key=lambda a: tool.Drawing.get_annotation_z_index(a))

-        drawing_style = context.scene.DocProperties.drawing_styles[
-            camera.data.BIMCameraProperties.active_drawing_style_index
-        ]
+        self.svg_writer.metadata = tool.Drawing.get_drawing_metadata(self.camera_element)
+        self.svg_writer.create_blank_svg(svg_path).draw_annotations(annotations).save()

-        render = context.scene.render
-        if self.is_landscape(render):
-            width = camera.data.ortho_scale
-            height = width / render.resolution_x * render.resolution_y
-        else:
-            height = camera.data.ortho_scale
-            width = height / render.resolution_y * render.resolution_x
-
-        svg_writer.human_scale = self.human_scale
-        svg_writer.scale = self.scale
-        svg_writer.output = svg_path
-        svg_writer.data_dir = context.scene.BIMProperties.data_dir
-        svg_writer.vector_style = drawing_style.vector_style
-        svg_writer.camera = camera
-        svg_writer.camera_width = width
-        svg_writer.camera_height = height
-        svg_writer.camera_projection = tuple(camera.matrix_world.to_quaternion() @ Vector((0, 0, -1)))
-
-        for obj in camera.users_collection[0].objects:
-            if "IfcAnnotation/" not in obj.name:
-                continue
-            element = tool.Ifc.get_entity(obj)
-            if element.ObjectType == "GRID":
-                svg_writer.annotations.setdefault("grid_objs", []).append(obj)
-            elif obj.type == "CAMERA":
-                continue
-            elif element.ObjectType == "TEXT_LEADER":
-                svg_writer.annotations.setdefault("leader_objs", []).append(obj)
-            elif element.ObjectType == "STAIR_ARROW":
-                svg_writer.annotations["stair_obj"] = obj
-            elif element.ObjectType == "EQUAL_DIMENSION":
-                svg_writer.annotations.setdefault("equal_objs", []).append(obj)
-            elif element.ObjectType == "DIMENSION":
-                svg_writer.annotations.setdefault("dimension_objs", []).append(obj)
-            elif element.ObjectType == "BREAKLINE":
-                svg_writer.annotations["break_obj"] = obj
-            elif element.ObjectType == "HIDDEN_LINE":
-                svg_writer.annotations.setdefault("hidden_objs", []).append((obj, obj.data))
-            elif element.ObjectType == "SOLID_LINE":
-                svg_writer.annotations.setdefault("solid_objs", []).append((obj, obj.data))
-            elif element.ObjectType == "PLAN_LEVEL":
-                svg_writer.annotations.setdefault("plan_level_objs", []).append(obj)
-            elif element.ObjectType == "SECTION_LEVEL":
-                svg_writer.annotations["section_level_obj"] = obj
-            elif element.ObjectType == "TEXT":
-                svg_writer.annotations.setdefault("text_objs", []).append(obj)
-            elif element.ObjectType == "MISC":
-                svg_writer.annotations.setdefault("misc_objs", []).append(obj)
-
-        svg_writer.annotations["attributes"] = [a.name for a in drawing_style.attributes]
-        # TODO: This was the old 2D annotation box checking system, prepare to deprecate
-        svg_writer.annotations["annotation_objs"] = []
-
-        svg_writer.write("annotation")
-        return svg_writer.output
+        return svg_path

    def get_scale(self):
        if self.camera.data.BIMCameraProperties.diagram_scale == "CUSTOM":
@@ -535,8 +509,11 @@ class AddAnnotation(bpy.types.Operator, Operator):
    def _execute(self, context):
        drawing = tool.Ifc.get_entity(context.scene.camera)
        if not drawing:
+            self.report({"WARNING"}, "Not a BIM camera")
            return
-        core.add_annotation(tool.Ifc, tool.Collector, tool.Drawing, drawing=drawing, object_type=self.object_type)
+        r = core.add_annotation(tool.Ifc, tool.Collector, tool.Drawing, drawing=drawing, object_type=self.object_type)
+        if isinstance(r, str):
+            self.report({"WARNING"}, r)


 class AddSheet(bpy.types.Operator, Operator):
@@ -563,7 +540,6 @@ class AddDrawingToSheet(bpy.types.Operator):
    bl_idname = "bim.add_drawing_to_sheet"
    bl_label = "Add Drawing To Sheet"
    bl_options = {"REGISTER", "UNDO"}
-    # TODO: check undo redo

    @classmethod
    def poll(cls, context):
@@ -572,9 +548,69 @@ class AddDrawingToSheet(bpy.types.Operator):

    def execute(self, context):
        props = context.scene.DocProperties
+        active_drawing = props.drawings[props.active_drawing_index]
+        active_sheet = props.sheets[props.active_sheet_index]
+        drawing = tool.Ifc.get().by_id(active_drawing.ifc_definition_id)
+        sheet = tool.Ifc.get().by_id(active_sheet.ifc_definition_id)
+        if not sheet.is_a("IfcDocumentInformation"):
+            return {"FINISHED"}
+
+        if tool.Ifc.get_schema() == "IFC2X3":
+            references = sheet.DocumentReferences or []
+        else:
+            references = sheet.HasDocumentReferences or []
+
+        has_drawing = False
+        for reference in references:
+            if tool.Ifc.get_schema() == "IFC2X3":
+                element = [r for r in tool.Ifc.by_type("IfcRelAssociatesDocument") if r.RelatingDocument == reference][
+                    0
+                ].RelatedObjects[0]
+            else:
+                element = reference.DocumentRefForObjects[0].RelatedObjects[0]
+            if element == drawing:
+                has_drawing = True
+                break
+
+        if has_drawing:
+            return {"FINISHED"}
+
+        reference = tool.Ifc.run("document.add_reference", information=sheet)
+        if tool.Ifc.get_schema() == "IFC2X3":
+            attributes = {"ItemReference": str(len(sheet.DocumentReferences or []))}
+        else:
+            attributes = {"Identification": str(len(sheet.HasDocumentReferences or []))}
+        tool.Ifc.run("document.edit_reference", reference=reference, attributes=attributes)
+        tool.Ifc.run("document.assign_document", product=drawing, document=reference)
        sheet_builder = sheeter.SheetBuilder()
        sheet_builder.data_dir = context.scene.BIMProperties.data_dir
-        sheet_builder.add_drawing(props.active_drawing.name, props.active_sheet.name)
+        sheet_builder.add_drawing(reference, drawing, sheet)
+
+        tool.Drawing.import_sheets()
+        return {"FINISHED"}
+
+
+class RemoveDrawingFromSheet(bpy.types.Operator):
+    bl_idname = "bim.remove_drawing_from_sheet"
+    bl_label = "Remove Drawing From Sheet"
+    bl_options = {"REGISTER", "UNDO"}
+    reference: bpy.props.IntProperty()
+
+    def execute(self, context):
+        reference = tool.Ifc.get().by_id(self.reference)
+        sheet = tool.Drawing.get_reference_document(reference)
+
+        sheet_builder = sheeter.SheetBuilder()
+        sheet_builder.data_dir = context.scene.BIMProperties.data_dir
+        sheet_builder.remove_drawing(reference, sheet)
+
+        drawing = tool.Drawing.get_reference_element(reference)
+        if drawing:
+            tool.Ifc.run("document.unassign_document", product=drawing, document=reference)
+
+        tool.Ifc.run("document.remove_reference", reference=reference)
+
+        tool.Drawing.import_sheets()
        return {"FINISHED"}


@@ -590,10 +626,16 @@ class CreateSheets(bpy.types.Operator):
    def execute(self, context):
        scene = context.scene
        props = scene.DocProperties
-        name = props.active_sheet.name
+        active_sheet = props.sheets[props.active_sheet_index]
+        sheet = tool.Ifc.get().by_id(active_sheet.ifc_definition_id)
+
+        if not sheet.is_a("IfcDocumentInformation"):
+            return {"FINISHED"}
+
+        name = os.path.splitext(os.path.basename(tool.Drawing.get_document_uri(sheet)))[0]
        sheet_builder = sheeter.SheetBuilder()
        sheet_builder.data_dir = scene.BIMProperties.data_dir
-        sheet_builder.build(name)
+        sheet_builder.build(sheet)

        svg2pdf_command = context.preferences.addons["blenderbim"].preferences.svg2pdf_command
        svg2dxf_command = context.preferences.addons["blenderbim"].preferences.svg2dxf_command
@@ -677,6 +719,7 @@ class ActivateView(bpy.types.Operator):

                    project_collection.children["Views"].children[camera.users_collection[0].name].hide_viewport = False
        bpy.data.collections.get(camera.users_collection[0].name).hide_render = False
+        bpy.context.scene.DocProperties.active_drawing_id = self.drawing
        bpy.ops.bim.activate_drawing_style()
        core.sync_references(tool.Ifc, tool.Collector, tool.Drawing, drawing=tool.Ifc.get().by_id(self.drawing))
        return {"FINISHED"}
@@ -699,68 +742,6 @@ class SelectDocIfcFile(bpy.types.Operator):
        return {"RUNNING_MODAL"}


-class GenerateReferences(bpy.types.Operator):
-    bl_idname = "bim.generate_references"
-    bl_label = "Generate References"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        self.camera = context.scene.camera
-        self.filter_potential_references()
-        if self.camera.data.BIMCameraProperties.target_view == "PLAN_VIEW":
-            self.generate_grids()
-        if self.camera.data.BIMCameraProperties.target_view == "ELEVATION_VIEW":
-            self.generate_grids()
-            self.generate_levels(context)
-        if self.camera.data.BIMCameraProperties.target_view == "SECTION_VIEW":
-            self.generate_grids()
-            self.generate_levels(context)
-        return {"FINISHED"}
-
-    def filter_potential_references(self):
-        for name in ["grids", "levels"]:
-            setattr(self, name, [])
-        for obj in bpy.data.objects:
-            if "IfcGridAxis/" in obj.name:
-                self.grids.append(obj)
-            if "IfcBuildingStorey/" in obj.name:
-                self.levels.append(obj)
-
-    def generate_grids(self):
-        # TODO
-        pass
-
-    def generate_levels(self, context):
-        if self.camera.data.BIMCameraProperties.raster_x > self.camera.data.BIMCameraProperties.raster_y:
-            width = self.camera.data.ortho_scale
-            height = (
-                width / self.camera.data.BIMCameraProperties.raster_x * self.camera.data.BIMCameraProperties.raster_y
-            )
-        else:
-            height = self.camera.data.ortho_scale
-            width = (
-                height / self.camera.data.BIMCameraProperties.raster_y * self.camera.data.BIMCameraProperties.raster_x
-            )
-        level_obj = annotation.Annotator.get_annotation_obj("Section Level", "curve", context)
-
-        width_in_mm = width * 1000
-        real_world_width_in_mm = width_in_mm * scale
-        offset_in_mm = 20
-        offset_percentage = offset_in_mm / real_world_width_in_mm
-
-        for obj in self.levels:
-            projection = self.project_point_onto_camera(obj.location)
-            co1 = self.camera.matrix_world @ Vector((width / 2 - (offset_percentage * width), projection[1], -1))
-            co2 = self.camera.matrix_world @ Vector((-(width / 2), projection[1], -1))
-            annotation.Annotator.add_line_to_annotation(level_obj, context, co1, co2)
-
-    def project_point_onto_camera(self, point):
-        projection = self.camera.matrix_world.to_quaternion() @ Vector((0, 0, -1))
-        return self.camera.matrix_world.inverted() @ geometry.intersect_line_plane(
-            point.xyz, point.xyz - projection, self.camera.location, projection
-        )
-
-
 class ResizeText(bpy.types.Operator):
    bl_idname = "bim.resize_text"
    bl_label = "Resize Text"
@@ -778,12 +759,10 @@ class RemoveDrawing(bpy.types.Operator, Operator):
    bl_idname = "bim.remove_drawing"
    bl_label = "Remove Drawing"
    bl_options = {"REGISTER", "UNDO"}
-    index: bpy.props.IntProperty()
+    drawing: bpy.props.IntProperty()

    def _execute(self, context):
-        props = context.scene.DocProperties
-        drawing = tool.Ifc.get().by_id(props.drawings[self.index].ifc_definition_id)
-        core.remove_drawing(tool.Ifc, tool.Drawing, drawing=drawing)
+        core.remove_drawing(tool.Ifc, tool.Drawing, drawing=tool.Ifc.get().by_id(self.drawing))


 class AddDrawingStyle(bpy.types.Operator):
@@ -936,71 +915,62 @@ class RemoveSheet(bpy.types.Operator, Operator):
    bl_idname = "bim.remove_sheet"
    bl_label = "Remove Sheet"
    bl_options = {"REGISTER", "UNDO"}
-    index: bpy.props.IntProperty()
+    sheet: bpy.props.IntProperty()

    def _execute(self, context):
-        self.props = context.scene.DocProperties
-        sheet = tool.Ifc.get().by_id(self.props.sheets[self.props.active_sheet_index].ifc_definition_id)
-        core.remove_sheet(tool.Ifc, tool.Drawing, sheet=sheet)
+        core.remove_sheet(tool.Ifc, tool.Drawing, sheet=tool.Ifc.get().by_id(self.sheet))


-class AddSchedule(bpy.types.Operator):
+class AddSchedule(bpy.types.Operator, Operator):
    bl_idname = "bim.add_schedule"
    bl_label = "Add Schedule"
    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        new = context.scene.DocProperties.schedules.add()
-        new.name = "SCHEDULE {}".format(len(context.scene.DocProperties.schedules))
-        return {"FINISHED"}
-
-
-class RemoveSchedule(bpy.types.Operator):
-    bl_idname = "bim.remove_schedule"
-    bl_label = "Remove Schedule"
-    bl_options = {"REGISTER", "UNDO"}
-    index: bpy.props.IntProperty()
-
-    def execute(self, context):
-        props = context.scene.DocProperties
-        props.schedules.remove(self.index)
-        return {"FINISHED"}
-
-
-class SelectScheduleFile(bpy.types.Operator):
-    bl_idname = "bim.select_schedule_file"
-    bl_label = "Select Documentation IFC File"
-    bl_options = {"REGISTER", "UNDO"}
    filepath: bpy.props.StringProperty(subtype="FILE_PATH")
-    filter_glob: bpy.props.StringProperty(default="*.ods", options={"HIDDEN"})
-    index: bpy.props.IntProperty()
+    filter_glob: bpy.props.StringProperty(default="*.ods;*.xls;*.xlsx", options={"HIDDEN"})
+    use_relative_path: bpy.props.BoolProperty(name="Use Relative Path", default=False)

-    def execute(self, context):
-        props = context.scene.DocProperties
-        props.active_schedule.file = self.filepath
-        return {"FINISHED"}
+    def _execute(self, context):
+        filepath = self.filepath
+        if self.use_relative_path:
+            filepath = os.path.relpath(filepath, bpy.path.abspath("//"))
+        core.add_schedule(
+            tool.Ifc,
+            tool.Drawing,
+            uri=filepath,
+        )

    def invoke(self, context, event):
        context.window_manager.fileselect_add(self)
        return {"RUNNING_MODAL"}


-class BuildSchedule(bpy.types.Operator):
+class RemoveSchedule(bpy.types.Operator, Operator):
+    bl_idname = "bim.remove_schedule"
+    bl_label = "Remove Schedule"
+    bl_options = {"REGISTER", "UNDO"}
+    schedule: bpy.props.IntProperty()
+
+    def _execute(self, context):
+        core.remove_schedule(tool.Ifc, tool.Drawing, schedule=tool.Ifc.get().by_id(self.schedule))
+
+
+class OpenSchedule(bpy.types.Operator, Operator):
+    bl_idname = "bim.open_schedule"
+    bl_label = "Open Schedule"
+    bl_options = {"REGISTER", "UNDO"}
+    schedule: bpy.props.IntProperty()
+
+    def _execute(self, context):
+        core.open_schedule(tool.Drawing, schedule=tool.Ifc.get().by_id(self.schedule))
+
+
+class BuildSchedule(bpy.types.Operator, Operator):
    bl_idname = "bim.build_schedule"
    bl_label = "Build Schedule"
+    schedule: bpy.props.IntProperty()

-    @classmethod
-    def poll(cls, context):
-        return context.scene.DocProperties.active_schedule.file
-
-    def execute(self, context):
-        props = context.scene.DocProperties
-        schedule = props.active_schedule
-        schedule_creator = scheduler.Scheduler()
-        outfile = os.path.join(context.scene.BIMProperties.data_dir, "schedules", schedule.name + ".svg")
-        schedule_creator.schedule(schedule.file, outfile)
-        open_with_user_command(context.preferences.addons["blenderbim"].preferences.svg_command, outfile)
-        return {"FINISHED"}
+    def _execute(self, context):
+        core.build_schedule(tool.Drawing, schedule=tool.Ifc.get().by_id(self.schedule))


 class AddScheduleToSheet(bpy.types.Operator):
@@ -1016,9 +986,40 @@ class AddScheduleToSheet(bpy.types.Operator):

    def execute(self, context):
        props = context.scene.DocProperties
+        active_schedule = props.schedules[props.active_schedule_index]
+        active_sheet = props.sheets[props.active_sheet_index]
+        schedule = tool.Ifc.get().by_id(active_schedule.ifc_definition_id)
+        sheet = tool.Ifc.get().by_id(active_sheet.ifc_definition_id)
+        if not sheet.is_a("IfcDocumentInformation"):
+            return {"FINISHED"}
+
+        if tool.Ifc.get_schema() == "IFC2X3":
+            references = sheet.DocumentReferences or []
+        else:
+            references = sheet.HasDocumentReferences or []
+
+        has_schedule = False
+        for reference in references:
+            if reference.Location == tool.Drawing.get_schedule_location(schedule):
+                has_schedule = True
+                break
+
+        if has_schedule:
+            return {"FINISHED"}
+
+        reference = tool.Ifc.run("document.add_reference", information=sheet)
+        if tool.Ifc.get_schema() == "IFC2X3":
+            attributes = {"ItemReference": str(len(sheet.DocumentReferences or []))}
+        else:
+            attributes = {"Identification": str(len(sheet.HasDocumentReferences or []))}
+        attributes["Location"] = tool.Drawing.get_schedule_location(schedule)
+        tool.Ifc.run("document.edit_reference", reference=reference, attributes=attributes)
+
        sheet_builder = sheeter.SheetBuilder()
        sheet_builder.data_dir = context.scene.BIMProperties.data_dir
-        sheet_builder.add_schedule(props.active_schedule.name, props.active_sheet.name)
+        sheet_builder.add_schedule(reference, schedule, sheet)
+
+        tool.Drawing.import_sheets()
        return {"FINISHED"}


@@ -1194,7 +1195,7 @@ class AddSectionsAnnotations(bpy.types.Operator):
        ]

        def sideview(cam):
-            # leftmost and righmost points of camera view area, local coords
+            # leftmost and rightmost points of camera view area, local coords
            xmin, xmax, _, _, _, _ = helper.ortho_view_frame(cam.data, margin=0)
            proj = camera.matrix_world.inverted() @ cam.matrix_world
            p_l = proj @ Vector((xmin, 0, 0))
@@ -1252,34 +1253,34 @@ class DisableEditingText(bpy.types.Operator, Operator):
        core.disable_editing_text(tool.Drawing, obj=context.active_object)


-class EditTextProduct(bpy.types.Operator, Operator):
-    bl_idname = "bim.edit_text_product"
+class EditAssignedProduct(bpy.types.Operator, Operator):
+    bl_idname = "bim.edit_assigned_product"
    bl_label = "Edit Text Product"
    bl_options = {"REGISTER", "UNDO"}

    def _execute(self, context):
        product = None
-        if context.active_object.BIMTextProperties.relating_product:
-            product = tool.Ifc.get_entity(context.active_object.BIMTextProperties.relating_product)
-        core.edit_text_product(tool.Ifc, tool.Drawing, obj=context.active_object, product=product)
+        if context.active_object.BIMAssignedProductProperties.relating_product:
+            product = tool.Ifc.get_entity(context.active_object.BIMAssignedProductProperties.relating_product)
+        core.edit_assigned_product(tool.Ifc, tool.Drawing, obj=context.active_object, product=product)


-class EnableEditingTextProduct(bpy.types.Operator, Operator):
-    bl_idname = "bim.enable_editing_text_product"
+class EnableEditingAssignedProduct(bpy.types.Operator, Operator):
+    bl_idname = "bim.enable_editing_assigned_product"
    bl_label = "Enable Editing Text Product"
    bl_options = {"REGISTER", "UNDO"}

    def _execute(self, context):
-        core.enable_editing_text_product(tool.Drawing, obj=context.active_object)
+        core.enable_editing_assigned_product(tool.Drawing, obj=context.active_object)


-class DisableEditingTextProduct(bpy.types.Operator, Operator):
-    bl_idname = "bim.disable_editing_text_product"
+class DisableEditingAssignedProduct(bpy.types.Operator, Operator):
+    bl_idname = "bim.disable_editing_assigned_product"
    bl_label = "Disable Editing Text Product"
    bl_options = {"REGISTER", "UNDO"}

    def _execute(self, context):
-        core.disable_editing_text_product(tool.Drawing, obj=context.active_object)
+        core.disable_editing_assigned_product(tool.Drawing, obj=context.active_object)


 class LoadSheets(bpy.types.Operator, Operator):
@@ -1300,6 +1301,24 @@ class DisableEditingSheets(bpy.types.Operator, Operator):
        core.disable_editing_sheets(tool.Drawing)


+class LoadSchedules(bpy.types.Operator, Operator):
+    bl_idname = "bim.load_schedules"
+    bl_label = "Load Schedules"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        core.load_schedules(tool.Drawing)
+
+
+class DisableEditingSchedules(bpy.types.Operator, Operator):
+    bl_idname = "bim.disable_editing_schedules"
+    bl_label = "Disable Editing Text Product"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        core.disable_editing_schedules(tool.Drawing)
+
+
 class LoadDrawings(bpy.types.Operator, Operator):
    bl_idname = "bim.load_drawings"
    bl_label = "Load Drawings"
@@ -1316,3 +1335,31 @@ class DisableEditingDrawings(bpy.types.Operator, Operator):

    def _execute(self, context):
        core.disable_editing_drawings(tool.Drawing)
+
+
+class ExpandSheet(bpy.types.Operator):
+    bl_idname = "bim.expand_sheet"
+    bl_label = "Expand Sheet"
+    bl_options = {"REGISTER", "UNDO"}
+    sheet: bpy.props.IntProperty()
+
+    def execute(self, context):
+        props = context.scene.DocProperties
+        for sheet in [s for s in props.sheets if s.ifc_definition_id == self.sheet]:
+            sheet.is_expanded = True
+        core.load_sheets(tool.Drawing)
+        return {"FINISHED"}
+
+
+class ContractSheet(bpy.types.Operator):
+    bl_idname = "bim.contract_sheet"
+    bl_label = "Contract Sheet"
+    bl_options = {"REGISTER", "UNDO"}
+    sheet: bpy.props.IntProperty()
+
+    def execute(self, context):
+        props = context.scene.DocProperties
+        for sheet in [s for s in props.sheets if s.ifc_definition_id == self.sheet]:
+            sheet.is_expanded = False
+        core.load_sheets(tool.Drawing)
+        return {"FINISHED"}
@@ -72,8 +72,10 @@ def update_diagram_scale(self, context):
    scale = self.diagram_scale
    if scale == "CUSTOM":
        scale = self.custom_diagram_scale
-    scale = scale.split("|")[1]
-    element = tool.Ifc.get_entity(context.scene.camera)
+    if "|" not in scale:
+        return
+    human_scale, scale = scale.split("|")
+    element = tool.Ifc.get_entity(context.active_object)
    if not element:
        return
    pset = ifcopenshell.util.element.get_psets(element).get("EPset_Drawing")
@@ -81,7 +83,9 @@ def update_diagram_scale(self, context):
        pset = tool.Ifc.get().by_id(pset["id"])
    else:
        pset = ifcopenshell.api.run("pset.add_pset", tool.Ifc.get(), product=element, name="EPset_Drawing")
-    ifcopenshell.api.run("pset.edit_pset", tool.Ifc.get(), pset=pset, properties={"Scale": scale})
+    ifcopenshell.api.run(
+        "pset.edit_pset", tool.Ifc.get(), pset=pset, properties={"Scale": scale, "HumanScale": human_scale}
+    )


 def get_diagram_scales(self, context):
@@ -95,7 +99,8 @@ def get_diagram_scales(self, context):
            diagram_scales_enum = [
                ("CUSTOM", "Custom", ""),
                ("1'=1'-0\"|1/1", "1'=1'-0\"", ""),
-                ('6"=1\'-0"|1/6', '6"=1\'-0"', ""),
+                ('6"=1\'-0"|1/2', '6"=1\'-0"', ""),
+                ('3"=1\'-0"|1/4', '3"=1\'-0"', ""),
                ('1-1/2"=1\'-0"|1/8', '1-1/2"=1\'-0"', ""),
                ('1"=1\'-0"|1/12', '1"=1\'-0"', ""),
                ('3/4"=1\'-0"|1/16', '3/4"=1\'-0"', ""),
@@ -149,6 +154,35 @@ def update_drawing_name(self, context):
    core.update_drawing_name(tool.Ifc, tool.Drawing, drawing=drawing, name=self.name)


+def update_schedule_name(self, context):
+    schedule = tool.Ifc.get().by_id(self.ifc_definition_id)
+    core.update_schedule_name(tool.Ifc, tool.Drawing, schedule=schedule, name=self.name)
+
+
+def update_has_underlay(self, context):
+    update_layer(self, context, "HasUnderlay", self.has_underlay)
+
+
+def update_has_linework(self, context):
+    update_layer(self, context, "HasLinework", self.has_linework)
+
+
+def update_has_annotation(self, context):
+    update_layer(self, context, "HasAnnotation", self.has_annotation)
+
+
+def update_layer(self, context, name, value):
+    element = tool.Ifc.get_entity(context.active_object)
+    if not element:
+        return
+    pset = ifcopenshell.util.element.get_psets(element).get("EPset_Drawing")
+    if pset:
+        pset = tool.Ifc.get().by_id(pset["id"])
+    else:
+        pset = ifcopenshell.api.run("pset.add_pset", tool.Ifc.get(), product=element, name="EPset_Drawing")
+    ifcopenshell.api.run("pset.edit_pset", tool.Ifc.get(), pset=pset, properties={name: value})
+
+
 def getTitleblocks(self, context):
    global titleblocks_enum
    if len(titleblocks_enum) < 1:
@@ -203,8 +237,9 @@ class Drawing(PropertyGroup):


 class Schedule(PropertyGroup):
-    name: StringProperty(name="Name")
-    file: StringProperty(name="File")
+    ifc_definition_id: IntProperty(name="IFC Definition ID")
+    name: StringProperty(name="Name", update=update_schedule_name)
+    identification: StringProperty(name="Identification")


 class Sheet(PropertyGroup):
@@ -221,8 +256,9 @@ class Sheet(PropertyGroup):
    ifc_definition_id: IntProperty(name="IFC Definition ID")
    identification: StringProperty(name="Identification")
    name: StringProperty(name="Name", get=get_name, set=set_name)
-    drawings: CollectionProperty(name="Drawings", type=Drawing)
-    active_drawing_index: IntProperty(name="Active Drawing Index")
+    is_sheet: BoolProperty(name="Is Sheet", default=False)
+    reference_type: StringProperty(name="Reference Type")
+    is_expanded: BoolProperty(name="Is Expanded", default=False)


 class DrawingStyle(PropertyGroup):
@@ -271,14 +307,12 @@ class RasterStyleProperty(enum.Enum):


 class DocProperties(PropertyGroup):
-    has_underlay: BoolProperty(name="Underlay", default=False)
-    has_linework: BoolProperty(name="Linework", default=True)
-    has_annotation: BoolProperty(name="Annotation", default=True)
    should_use_underlay_cache: BoolProperty(name="Use Underlay Cache", default=False)
    should_use_linework_cache: BoolProperty(name="Use Linework Cache", default=False)
    should_use_annotation_cache: BoolProperty(name="Use Annotation Cache", default=False)
    should_extract: BoolProperty(name="Should Extract", default=True)
    is_editing_drawings: BoolProperty(name="Is Editing Drawings", default=False)
+    is_editing_schedules: BoolProperty(name="Is Editing Schedules", default=False)
    target_view: EnumProperty(
        items=[
            ("PLAN_VIEW", "Plan", ""),
@@ -293,6 +327,7 @@ class DocProperties(PropertyGroup):
    )
    location_hint: EnumProperty(items=get_location_hint, name="Location Hint")
    drawings: CollectionProperty(name="Drawings", type=Drawing)
+    active_drawing_id: IntProperty(name="Active Drawing Id")
    active_drawing_index: IntProperty(name="Active Drawing Index")
    current_drawing_index: IntProperty(name="Current Drawing Index")
    schedules: CollectionProperty(name="Schedules", type=Schedule)
@@ -308,20 +343,11 @@ class DocProperties(PropertyGroup):
        name="Decorations Colour", subtype="COLOR", default=(1, 1, 1, 1), min=0.0, max=1.0, size=4
    )

-    @property
-    def active_schedule(self):
-        return self.schedules[self.active_schedule_index]
-
-    @property
-    def active_drawing(self):
-        return self.drawings[self.active_drawing_index]
-
-    @property
-    def active_sheet(self):
-        return self.sheets[self.active_sheet_index]
-

 class BIMCameraProperties(PropertyGroup):
+    has_underlay: BoolProperty(name="Underlay", default=False, update=update_has_underlay)
+    has_linework: BoolProperty(name="Linework", default=True, update=update_has_linework)
+    has_annotation: BoolProperty(name="Annotation", default=True, update=update_has_annotation)
    representation: StringProperty(name="Representation")
    view_name: StringProperty(name="View Name")
    diagram_scale: EnumProperty(items=get_diagram_scales, name="Drawing Scale", update=update_diagram_scale)
@@ -329,19 +355,6 @@ class BIMCameraProperties(PropertyGroup):
    raster_x: IntProperty(name="Raster X", default=1000)
    raster_y: IntProperty(name="Raster Y", default=1000)
    is_nts: BoolProperty(name="Is NTS")
-    cut_objects: EnumProperty(
-        items=[
-            (
-                ".IfcWall|.IfcSlab|.IfcCurtainWall|.IfcStair|.IfcStairFlight|.IfcColumn|.IfcBeam|.IfcMember|.IfcCovering|.IfcSpace",
-                "Overall Plan / Section",
-                "",
-            ),
-            (".IfcElement", "Detail Drawing", ""),
-            ("CUSTOM", "Custom", ""),
-        ],
-        name="Cut Objects",
-    )
-    cut_objects_custom: StringProperty(name="Custom Cut")
    active_drawing_style_index: IntProperty(name="Active Drawing Style Index")

    # For now, this JSON dump are all the parameters that determine a camera's "Block representation"
@@ -364,7 +377,6 @@ class BIMCameraProperties(PropertyGroup):

 class BIMTextProperties(PropertyGroup):
    is_editing: BoolProperty(name="Is Editing", default=False)
-    is_editing_product: BoolProperty(name="Is Editing Product", default=False)
    attributes: CollectionProperty(name="Attributes", type=Attribute)
    value: StringProperty(name="Value", default="TEXT")
    font_size: EnumProperty(
@@ -379,13 +391,8 @@ class BIMTextProperties(PropertyGroup):
        update=refreshFontSize,
        name="Font Size",
    )
-    symbol: EnumProperty(
-        items=[
-            ("None", "None", ""),
-            ("rectangle-tag", "Rectangle Tag", ""),
-            ("door-tag", "Door Tag", ""),
-        ],
-        update=refreshFontSize,
-        name="Symbol",
-    )
+
+
+class BIMAssignedProductProperties(PropertyGroup):
+    is_editing_product: BoolProperty(name="Is Editing Product", default=False)
    relating_product: PointerProperty(name="Relating Product", type=bpy.types.Object)
@@ -16,11 +16,12 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

-import xml.etree.ElementTree as ET
-import urllib.parse
-import pystache
-import ntpath
 import os
+import ntpath
+import pystache
+import urllib.parse
+import xml.etree.ElementTree as ET
+import blenderbim.tool as tool
 from shutil import copy
 from xml.dom import minidom

@@ -30,8 +31,7 @@ class SheetBuilder:
        self.data_dir = None
        self.scale = "NTS"

-    def create(self, name, titleblock_name):
-        sheet_path = os.path.join(self.data_dir, "sheets", f"{name}.svg")
+    def create(self, sheet_path, titleblock_name):
        root = ET.Element("svg")
        root.attrib["xmlns"] = "http://www.w3.org/2000/svg"
        root.attrib["xmlns:xlink"] = "http://www.w3.org/1999/xlink"
@@ -59,11 +59,16 @@ class SheetBuilder:
        with open(sheet_path, "w") as f:
            f.write(minidom.parseString(ET.tostring(root)).toprettyxml(indent="    "))

-    def add_drawing(self, view_name, sheet_name):
-        sheet_path = os.path.join(self.data_dir, "sheets", sheet_name + ".svg")
-        view_path = os.path.join(self.data_dir, "diagrams", view_name + ".svg")
+    def add_drawing(self, reference, drawing, sheet):
+        filename = drawing.Name
+        sheet_name = os.path.splitext(os.path.basename(tool.Drawing.get_document_uri(sheet)))[0]
+        sheet_dir = os.path.join(self.data_dir, "sheets")
+        drawing_dir = os.path.join(self.data_dir, "diagrams")
+        sheet_path = os.path.join(sheet_dir, sheet_name + ".svg")
+        drawing_path = os.path.join(drawing_dir, filename + ".svg")
+        underlay_path = os.path.join(drawing_dir, filename + "-underlay.png")

-        if not os.path.isfile(view_path):
+        if not os.path.isfile(sheet_path):
            raise FileNotFoundError

        ET.register_namespace("", "http://www.w3.org/2000/svg")
@@ -72,7 +77,7 @@ class SheetBuilder:
        sheet_tree = ET.parse(sheet_path)
        sheet_root = sheet_tree.getroot()

-        view_tree = ET.parse(view_path)
+        view_tree = ET.parse(drawing_path)
        view_root = view_tree.getroot()

        # The view is placed into a group with a background image element.
@@ -80,29 +85,50 @@ class SheetBuilder:
        # here to accommodate browsers which do not nest images.
        view = ET.SubElement(sheet_root, "g")
        view.attrib["data-type"] = "drawing"
+        view.attrib["data-id"] = str(reference.id())
+        view.attrib["data-drawing"] = drawing.GlobalId
        view_width = self.convert_to_mm(view_root.attrib.get("width"))
        view_height = self.convert_to_mm(view_root.attrib.get("height"))

-        background = ET.SubElement(view, "image")
-        background.attrib["xlink:href"] = "../diagrams/{}.png".format(view_name)
-        background.attrib["x"] = "30"
-        background.attrib["y"] = "30"
-        background.attrib["width"] = str(view_width)
-        background.attrib["height"] = str(view_height)
+        if os.path.isfile(underlay_path):
+            background = ET.SubElement(view, "image")
+            background.attrib["data-type"] = "background"
+            background.attrib["xlink:href"] = os.path.relpath(underlay_path, sheet_dir)
+            background.attrib["x"] = "30"
+            background.attrib["y"] = "30"
+            background.attrib["width"] = str(view_width)
+            background.attrib["height"] = str(view_height)

-        foreground = ET.SubElement(view, "image")
-        foreground.attrib["xlink:href"] = "../diagrams/{}.svg".format(view_name)
-        foreground.attrib["x"] = "30"
-        foreground.attrib["y"] = "30"
-        foreground.attrib["width"] = str(view_width)
-        foreground.attrib["height"] = str(view_height)
+        if os.path.isfile(drawing_path):
+            foreground = ET.SubElement(view, "image")
+            foreground.attrib["data-type"] = "foreground"
+            foreground.attrib["xlink:href"] = os.path.relpath(drawing_path, sheet_dir)
+            foreground.attrib["x"] = "30"
+            foreground.attrib["y"] = "30"
+            foreground.attrib["width"] = str(view_width)
+            foreground.attrib["height"] = str(view_height)

        self.add_view_title(30, view_height + 35, view)
        sheet_tree.write(sheet_path)

-    def add_schedule(self, schedule_name, sheet_name):
-        sheet_path = os.path.join(self.data_dir, "sheets", sheet_name + ".svg")
-        view_path = os.path.join(self.data_dir, "schedules", schedule_name + ".svg")
+    def remove_drawing(self, reference, sheet):
+        ET.register_namespace("", "http://www.w3.org/2000/svg")
+
+        sheet_path = tool.Drawing.get_document_uri(sheet)
+        sheet_tree = ET.parse(sheet_path)
+        sheet_root = sheet_tree.getroot()
+
+        for g in sheet_root.findall("{http://www.w3.org/2000/svg}g"):
+            if g.attrib.get("data-id") == str(reference.id()):
+                sheet_root.remove(g)
+                break
+
+        sheet_tree.write(sheet_path)
+
+    def add_schedule(self, reference, schedule, sheet):
+        view_path = tool.Drawing.get_document_uri(schedule)
+        schedule_name = os.path.splitext(os.path.basename(view_path))[0]
+        sheet_path = tool.Drawing.get_document_uri(sheet)

        ET.register_namespace("", "http://www.w3.org/2000/svg")
        ET.register_namespace("xlink", "http://www.w3.org/1999/xlink")
@@ -115,30 +141,35 @@ class SheetBuilder:
        view_width = self.convert_to_mm(view_root.attrib.get("width"))
        view_height = self.convert_to_mm(view_root.attrib.get("height"))

-        group = ET.SubElement(sheet_root, "g")
-        group.attrib["data-type"] = "schedule"
+        view = ET.SubElement(sheet_root, "g")
+        view.attrib["data-type"] = "schedule"
+        view.attrib["data-id"] = str(reference.id())
+        view.attrib["data-schedule"] = str(schedule.id())

-        foreground = ET.SubElement(group, "image")
+        foreground = ET.SubElement(view, "image")
+        foreground.attrib["data-type"] = "table"
        foreground.attrib["xlink:href"] = "../schedules/{}.svg".format(schedule_name)
        foreground.attrib["x"] = "30"
        foreground.attrib["y"] = "30"
        foreground.attrib["width"] = str(view_width)
        foreground.attrib["height"] = str(view_height)

-        self.add_view_title(30, view_height + 35, group)
+        self.add_view_title(30, view_height + 35, view)
        sheet_tree.write(sheet_path)

    def add_view_title(self, x, y, parent):
        title_tree = ET.parse(os.path.join(self.data_dir, "templates", "view-title.svg"))
        title_root = title_tree.getroot()
        title = ET.SubElement(parent, "image")
+        title.attrib["data-type"] = "view-title"
        title.attrib["xlink:href"] = "../templates/view-title.svg"
        title.attrib["x"] = str(x)
        title.attrib["y"] = str(y)
        title.attrib["width"] = str(self.convert_to_mm(title_root.attrib.get("width")))
        title.attrib["height"] = str(self.convert_to_mm(title_root.attrib.get("height")))

-    def build(self, sheet_name):
+    def build(self, sheet):
+        sheet_name = os.path.splitext(os.path.basename(tool.Drawing.get_document_uri(sheet)))[0]
        os.makedirs(os.path.join(self.data_dir, "build", sheet_name), exist_ok=True)

        sheet_path = os.path.join(self.data_dir, "sheets", f"{sheet_name}.svg")
@@ -149,68 +180,86 @@ class SheetBuilder:
        tree = ET.parse(sheet_path)
        root = tree.getroot()

-        titleblock = root.findall('{http://www.w3.org/2000/svg}g[@data-type="titleblock"]')[0]
-        image = titleblock.findall("{http://www.w3.org/2000/svg}image")[0]
-        titleblock.append(self.parse_embedded_svg(image, {"number": sheet_name, "revision": "A"}))
-        titleblock.remove(image)
-
-        self.group_number = 1
-        self.build_drawings(root.findall('{http://www.w3.org/2000/svg}g[@data-type="drawing"]'), sheet_name)
-        self.build_schedules(root.findall('{http://www.w3.org/2000/svg}g[@data-type="schedule"]'))
+        self.build_titleblock(root, sheet)
+        self.build_drawings(root, sheet)
+        self.build_schedules(root)

        with open(os.path.join(self.data_dir, "build", sheet_name, f"{sheet_name}.svg"), "wb") as output:
            tree.write(output)

-    def build_drawings(self, drawings, sheet_name):
-        for view in drawings:
+    def build_titleblock(self, root, sheet):
+        titleblock = root.findall('{http://www.w3.org/2000/svg}g[@data-type="titleblock"]')[0]
+        image = titleblock.findall("{http://www.w3.org/2000/svg}image")[0]
+        titleblock.append(self.parse_embedded_svg(image, sheet.get_info()))
+        titleblock.remove(image)
+
+    def build_drawings(self, root, sheet):
+        sheet_name = os.path.splitext(os.path.basename(tool.Drawing.get_document_uri(sheet)))[0]
+
+        for view in root.findall('{http://www.w3.org/2000/svg}g[@data-type="drawing"]'):
+            reference = tool.Ifc.get().by_id(int(view.attrib["data-id"]))
+            drawing = tool.Ifc.get().by_id(view.attrib["data-drawing"])
+
            images = view.findall("{http://www.w3.org/2000/svg}image")
-            background = images[0]
-            foreground = images[1]
-            view_title = images[2]
-            self.scale = "NTS"

-            # Add foreground
-            view.append(self.parse_embedded_svg(foreground, {}))
+            background = None
+            foreground = None
+            view_title = None

-            # Add background
-            background_path = os.path.join(self.data_dir, "sheets", self.get_href(background))
+            for image in images:
+                if image.attrib["data-type"] == "background":
+                    background = image
+                elif image.attrib["data-type"] == "foreground":
+                    foreground = image
+                elif image.attrib["data-type"] == "view-title":
+                    view_title = image

-            copy(background_path, os.path.join(self.data_dir, "build", sheet_name))
+            if foreground is not None:
+                view.append(self.parse_embedded_svg(foreground, {}))

-            # Add view title
-            foreground_path = self.get_href(foreground)
-            view.append(
-                self.parse_embedded_svg(
-                    view_title,
-                    {"no": self.group_number, "name": ntpath.basename(foreground_path)[0:-4], "scale": self.scale},
-                )
-            )
+            if background is not None:
+                background_path = os.path.join(self.data_dir, "sheets", self.get_href(background))
+                copy(background_path, os.path.join(self.data_dir, "build", sheet_name))
+
+            if view_title is not None:
+                foreground_path = self.get_href(foreground)
+                data = reference.get_info()
+                if not data["Name"]:
+                    data["Name"] = ntpath.basename(foreground_path)[0:-4]
+                data["Scale"] = tool.Drawing.get_drawing_human_scale(drawing)
+                view.append(self.parse_embedded_svg(view_title, data))

            for image in images:
                view.remove(image)

-            self.group_number += 1
+    def build_schedules(self, root):
+        for view in root.findall('{http://www.w3.org/2000/svg}g[@data-type="schedule"]'):
+            reference = tool.Ifc.get().by_id(int(view.attrib["data-id"]))
+            schedule = tool.Ifc.get().by_id(int(view.attrib["data-schedule"]))

-    def build_schedules(self, schedules):
-        for group in schedules:
-            images = group.findall("{http://www.w3.org/2000/svg}image")
-            schedule = images[0]
-            group_title = images[1]
-            self.scale = "NTS"
+            images = view.findall("{http://www.w3.org/2000/svg}image")

-            group.append(self.parse_embedded_svg(schedule, {}))
-
-            path = self.get_href(schedule)
-            group.append(
-                self.parse_embedded_svg(
-                    group_title, {"no": self.group_number, "name": ntpath.basename(path)[0:-4], "scale": self.scale}
-                )
-            )
+            table = None
+            view_title = None

            for image in images:
-                group.remove(image)
+                if image.attrib["data-type"] == "table":
+                    table = image
+                elif image.attrib["data-type"] == "view-title":
+                    view_title = image

-            self.group_number += 1
+            if table is not None:
+                view.append(self.parse_embedded_svg(table, {}))
+
+            if view_title is not None:
+                path = self.get_href(table)
+                data = reference.get_info()
+                if not data["Name"]:
+                    data["Name"] = schedule.Name or "Unnamed"
+                view.append(self.parse_embedded_svg(view_title, data))
+
+            for image in images:
+                view.remove(image)

    def get_href(self, element):
        return urllib.parse.unquote(element.attrib.get("{http://www.w3.org/1999/xlink}href"))
@@ -20,7 +20,7 @@ import bpy
 import blenderbim.bim.helper
 import blenderbim.tool as tool
 from bpy.types import Panel
-from blenderbim.bim.module.drawing.data import TextData, SheetsData, DrawingsData
+from blenderbim.bim.module.drawing.data import ProductAssignmentsData, TextData, SheetsData, SchedulesData, DrawingsData


 class BIM_PT_camera(Panel):
@@ -47,13 +47,13 @@ class BIM_PT_camera(Panel):

        col = layout.column(align=True)
        row = col.row(align=True)
-        row.prop(dprops, "has_underlay", icon="OUTLINER_OB_IMAGE")
+        row.prop(props, "has_underlay", icon="OUTLINER_OB_IMAGE")
        row.prop(dprops, "should_use_underlay_cache", text="", icon="FILE_REFRESH")
        row = col.row(align=True)
-        row.prop(dprops, "has_linework", icon="IMAGE_DATA")
+        row.prop(props, "has_linework", icon="IMAGE_DATA")
        row.prop(dprops, "should_use_linework_cache", text="", icon="FILE_REFRESH")
        row = col.row(align=True)
-        row.prop(dprops, "has_annotation", icon="MOD_EDGESPLIT")
+        row.prop(props, "has_annotation", icon="MOD_EDGESPLIT")
        row.prop(dprops, "should_use_annotation_cache", text="", icon="FILE_REFRESH")

        row = layout.row()
@@ -62,17 +62,9 @@ class BIM_PT_camera(Panel):
        row = layout.row()
        row.prop(props, "is_nts")

-        row = layout.row()
-        row.operator("bim.generate_references")
        row = layout.row()
        row.operator("bim.resize_text")

-        row = layout.row()
-        row.prop(props, "cut_objects")
-        if props.cut_objects == "CUSTOM":
-            row = layout.row()
-            row.prop(props, "cut_objects_custom")
-
        row = layout.row()
        row.prop(props, "raster_x")
        row = layout.row()
@@ -152,6 +144,10 @@ class BIM_PT_drawings(Panel):
    bl_region_type = "UI"
    bl_category = "BIM Documentation"

+    @classmethod
+    def poll(cls, context):
+        return tool.Ifc.get()
+
    def draw(self, context):
        if not DrawingsData.is_loaded:
            DrawingsData.load()
@@ -172,14 +168,15 @@ class BIM_PT_drawings(Panel):

        if self.props.drawings:
            if self.props.active_drawing_index < len(self.props.drawings):
+                active_drawing = self.props.drawings[self.props.active_drawing_index]
                row = self.layout.row(align=True)
                row.alignment = "RIGHT"
                op = row.operator("bim.open_view", icon="URL", text="")
-                op.view = self.props.active_drawing.name
+                op.view = active_drawing.name
                op = row.operator("bim.activate_view", icon="OUTLINER_OB_CAMERA", text="")
-                op.drawing = self.props.active_drawing.ifc_definition_id
+                op.drawing = active_drawing.ifc_definition_id
                row.operator("bim.create_drawing", text="", icon="OUTPUT")
-                row.operator("bim.remove_drawing", icon="X", text="").index = self.props.active_drawing_index
+                row.operator("bim.remove_drawing", icon="X", text="").drawing = active_drawing.ifc_definition_id
            self.layout.template_list(
                "BIM_UL_drawinglist", "", self.props, "drawings", self.props, "active_drawing_index"
            )
@@ -202,23 +199,40 @@ class BIM_PT_schedules(Panel):
    bl_region_type = "UI"
    bl_category = "BIM Documentation"

+    @classmethod
+    def poll(cls, context):
+        return tool.Ifc.get()
+
    def draw(self, context):
-        layout = self.layout
-        layout.use_property_split = True
-        props = context.scene.DocProperties
+        if not SchedulesData.is_loaded:
+            SchedulesData.load()

-        row = layout.row(align=True)
-        row.operator("bim.add_schedule")
+        self.props = context.scene.DocProperties

-        if props.schedules:
-            row.operator("bim.build_schedule", icon="LINENUMBERS_ON", text="")
-            row.operator("bim.remove_schedule", icon="X", text="").index = props.active_schedule_index
+        if not self.props.is_editing_schedules:
+            row = self.layout.row(align=True)
+            row.label(text=f"{SchedulesData.data['total_schedules']} Schedules Found", icon="LONGDISPLAY")
+            row.operator("bim.load_schedules", text="", icon="IMPORT")
+            return

-            layout.template_list("BIM_UL_generic", "", props, "schedules", props, "active_schedule_index")
+        row = self.layout.row(align=True)
+        row.operator("bim.add_schedule", icon="ADD")
+        row.operator("bim.disable_editing_schedules", text="", icon="CANCEL")

-            row = layout.row()
-            row.prop(props.active_schedule, "file")
-            row.operator("bim.select_schedule_file", icon="FILE_FOLDER", text="")
+        if self.props.schedules:
+            if self.props.active_schedule_index < len(self.props.schedules):
+                active_schedule = self.props.schedules[self.props.active_schedule_index]
+                row = self.layout.row(align=True)
+                row.alignment = "RIGHT"
+                row.operator("bim.open_schedule", icon="URL", text="").schedule = active_schedule.ifc_definition_id
+                row.operator(
+                    "bim.build_schedule", icon="LINENUMBERS_ON", text=""
+                ).schedule = active_schedule.ifc_definition_id
+                row.operator("bim.remove_schedule", icon="X", text="").schedule = active_schedule.ifc_definition_id
+
+            self.layout.template_list(
+                "BIM_UL_generic", "", self.props, "schedules", self.props, "active_schedule_index"
+            )


 class BIM_PT_sheets(Panel):
@@ -228,6 +242,10 @@ class BIM_PT_sheets(Panel):
    bl_region_type = "UI"
    bl_category = "BIM Documentation"

+    @classmethod
+    def poll(cls, context):
+        return tool.Ifc.get()
+
    def draw(self, context):
        if not SheetsData.is_loaded:
            SheetsData.load()
@@ -245,18 +263,56 @@ class BIM_PT_sheets(Panel):
        row.operator("bim.add_sheet", text="", icon="ADD")
        row.operator("bim.disable_editing_sheets", text="", icon="CANCEL")

-        if self.props.sheets:
+        if self.props.sheets and self.props.active_sheet_index < len(self.props.sheets):
+            active_sheet = self.props.sheets[self.props.active_sheet_index]
            row = self.layout.row(align=True)
            row.alignment = "RIGHT"
            row.operator("bim.open_sheet", icon="URL", text="")
            row.operator("bim.add_drawing_to_sheet", icon="IMAGE_PLANE", text="")
            row.operator("bim.add_schedule_to_sheet", icon="PRESET_NEW", text="")
            row.operator("bim.create_sheets", icon="FILE_REFRESH", text="")
-            row.operator("bim.remove_sheet", icon="X", text="").index = self.props.active_sheet_index
+            if active_sheet.is_sheet:
+                row.operator("bim.remove_sheet", icon="X", text="").sheet = active_sheet.ifc_definition_id
+            else:
+                op = row.operator("bim.remove_drawing_from_sheet", icon="X", text="")
+                op.reference = active_sheet.ifc_definition_id

        self.layout.template_list("BIM_UL_sheets", "", self.props, "sheets", self.props, "active_sheet_index")


+class BIM_PT_product_assignments(Panel):
+    bl_label = "IFC Product Assignments"
+    bl_idname = "BIM_PT_product_assignments"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "object"
+
+    @classmethod
+    def poll(cls, context):
+        if not tool.Ifc.get() or not context.active_object:
+            return
+        element = tool.Ifc.get_entity(context.active_object)
+        if not element:
+            return
+        return element.is_a("IfcAnnotation")
+
+    def draw(self, context):
+        if not ProductAssignmentsData.is_loaded:
+            ProductAssignmentsData.load()
+
+        props = context.active_object.BIMAssignedProductProperties
+
+        if props.is_editing_product:
+            row = self.layout.row(align=True)
+            row.prop(props, "relating_product", text="")
+            row.operator("bim.edit_assigned_product", icon="CHECKMARK", text="")
+            row.operator("bim.disable_editing_assigned_product", icon="CANCEL", text="")
+        else:
+            row = self.layout.row(align=True)
+            row.label(text=ProductAssignmentsData.data["relating_product"] or "No Relating Product", icon="OBJECT_DATA")
+            row.operator("bim.enable_editing_assigned_product", icon="GREASEPENCIL", text="")
+
+
 class BIM_PT_text(Panel):
    bl_label = "IFC Text"
    bl_idname = "BIM_PT_text"
@@ -293,16 +349,6 @@ class BIM_PT_text(Panel):
                row.label(text=attribute["name"])
                row.label(text=attribute["value"])

-        if props.is_editing_product:
-            row = self.layout.row(align=True)
-            row.prop(props, "relating_product", text="")
-            row.operator("bim.edit_text_product", icon="CHECKMARK", text="")
-            row.operator("bim.disable_editing_text_product", icon="CANCEL", text="")
-        else:
-            row = self.layout.row(align=True)
-            row.label(text=TextData.data["relating_product"] or "No Relating Product", icon="OBJECT_DATA")
-            row.operator("bim.enable_editing_text_product", icon="GREASEPENCIL", text="")
-
        row = self.layout.row()
        row.prop(props, "font_size")
        row = self.layout.row()
@@ -322,11 +368,19 @@ class BIM_PT_annotation_utilities(Panel):
        self.props = context.scene.DocProperties

        row = layout.row(align=True)
-        op = row.operator("bim.add_annotation", text="Dim", icon="ARROW_LEFTRIGHT")
+        op = row.operator("bim.add_annotation", text="Dimension", icon="FIXED_SIZE")
        op.object_type = "DIMENSION"
        op.data_type = "curve"
-        op = row.operator("bim.add_annotation", text="Dim (Eq)", icon="ARROW_LEFTRIGHT")
-        op.object_type = "EQUAL_DIMENSION"
+        op = row.operator("bim.add_annotation", text="Angle", icon="DRIVER_ROTATIONAL_DIFFERENCE")
+        op.object_type = "ANGLE"
+        op.data_type = "mesh"
+
+        row = layout.row(align=True)
+        op = row.operator("bim.add_annotation", text="Radius", icon="FORWARD")
+        op.object_type = "RADIUS"
+        op.data_type = "curve"
+        op = row.operator("bim.add_annotation", text="Diameter", icon="ARROW_LEFTRIGHT")
+        op.object_type = "DIAMETER"
        op.data_type = "curve"

        row = layout.row(align=True)
@@ -357,10 +411,14 @@ class BIM_PT_annotation_utilities(Panel):
        op = row.operator("bim.add_annotation", text="Breakline", icon="FCURVE")
        op.object_type = "BREAKLINE"
        op.data_type = "mesh"
-        op = row.operator("bim.add_annotation", text="Misc", icon="MESH_MONKEY")
-        op.object_type = "MISC"
+        op = row.operator("bim.add_annotation", text="Line", icon="MESH_MONKEY")
+        op.object_type = "LINEWORK"
        op.data_type = "mesh"

+        row = layout.row(align=True)
+        op = row.operator("bim.add_annotation", text="Fill Area", icon="NODE_TEXTURE")
+        op.object_type = "FILL_AREA"
+
        row = layout.row(align=True)
        row.prop(self.props, "should_draw_decorations", text="Viewport Annotations")

@@ -387,9 +445,24 @@ class BIM_UL_sheets(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
        if item:
            row = layout.row(align=True)
-            split1 = row.split(factor=0.2)
-            split1.label(text=item.identification or "X")
-            split2 = split1.split(factor=0.8)
-            split2.label(text=item.name or "Unnamed")
+
+            if item.is_sheet:
+                if item.is_expanded:
+                    row.operator(
+                        "bim.contract_sheet", text="", emboss=False, icon="DISCLOSURE_TRI_DOWN"
+                    ).sheet = item.ifc_definition_id
+                else:
+                    row.operator(
+                        "bim.expand_sheet", text="", emboss=False, icon="DISCLOSURE_TRI_RIGHT"
+                    ).sheet = item.ifc_definition_id
+            else:
+                row.label(text="", icon="BLANK1")
+                if item.reference_type == "DRAWING":
+                    row.label(text="", icon="IMAGE_DATA")
+                elif item.reference_type == "SCHEDULE":
+                    row.label(text="", icon="LONGDISPLAY")
+
+            name = "{} - {}".format(item.identification or "X", item.name or "Unnamed")
+            row.label(text=name)
        else:
            layout.label(text="", translate=False)
@@ -130,10 +130,6 @@ class UpdateRepresentation(bpy.types.Operator):
    obj: bpy.props.StringProperty()
    ifc_representation_class: bpy.props.StringProperty()

-    @classmethod
-    def poll(cls, context):
-        return context.active_object.mode == "OBJECT"
-
    def execute(self, context):
        return IfcStore.execute_ifc_operator(self, context)

@@ -141,6 +137,10 @@ class UpdateRepresentation(bpy.types.Operator):
        if not ContextData.is_loaded:
            ContextData.load(IfcStore.get_file())

+        if context.active_object and context.active_object.mode != "OBJECT":
+            # Ensure mode is object to prevent invalid mesh data causing CTD
+            bpy.ops.object.mode_set(mode="OBJECT", toggle=False)
+
        objs = [bpy.data.objects.get(self.obj)] if self.obj else context.selected_objects
        self.file = IfcStore.get_file()

@@ -157,6 +157,9 @@ class UpdateRepresentation(bpy.types.Operator):
    def update_obj_mesh_representation(self, context, obj):
        product = self.file.by_id(obj.BIMObjectProperties.ifc_definition_id)

+        if not product.is_a("IfcGridAxis"):
+            tool.Geometry.clear_cache(product)
+
        if product.is_a("IfcGridAxis"):
            ifcopenshell.api.run("grid.create_axis_curve", self.file, **{"axis_curve": obj, "grid_axis": product})
            return
@@ -203,25 +206,17 @@ class UpdateRepresentation(bpy.types.Operator):

        new_representation = ifcopenshell.api.run("geometry.add_representation", self.file, **representation_data)

-        [
-            blenderbim.core.style.add_style(tool.Ifc, tool.Style, obj=s.material)
-            for s in obj.material_slots
-            if s.material and not s.material.BIMMaterialProperties.ifc_style_id
-        ]
-
-        if isinstance(obj.data, bpy.types.Mesh) and len(obj.data.polygons):
+        if tool.Geometry.is_body_representation(new_representation):
+            [
+                tool.Geometry.run_style_add_style(obj=mat)
+                for mat in tool.Geometry.get_object_materials_without_styles(obj)
+            ]
            ifcopenshell.api.run(
                "style.assign_representation_styles",
                self.file,
-                **{
-                    "shape_representation": new_representation,
-                    "styles": [
-                        self.file.by_id(s.material.BIMMaterialProperties.ifc_style_id)
-                        for s in obj.material_slots
-                        if s.material
-                    ],
-                    "should_use_presentation_style_assignment": context.scene.BIMGeometryProperties.should_use_presentation_style_assignment,
-                },
+                shape_representation=new_representation,
+                styles=tool.Geometry.get_styles(obj),
+                should_use_presentation_style_assignment=context.scene.BIMGeometryProperties.should_use_presentation_style_assignment,
            )
            tool.Geometry.record_object_materials(obj)

@@ -245,7 +240,7 @@ class UpdateParametricRepresentation(bpy.types.Operator):

    @classmethod
    def poll(cls, context):
-        return context.active_object.mode == "OBJECT"
+        return context.active_object and context.active_object.mode == "OBJECT"

    def execute(self, context):
        self.file = IfcStore.get_file()
@@ -329,8 +324,8 @@ class CopyRepresentation(bpy.types.Operator, Operator):

 class OverrideDeleteTrait:
    def delete_ifc_object(self, obj):
-        if obj.BIMObjectProperties.ifc_definition_id:
-            element = IfcStore.get_file().by_id(obj.BIMObjectProperties.ifc_definition_id)
+        element = tool.Ifc.get_entity(obj)
+        if element:
            IfcStore.delete_element(element)
            if getattr(element, "FillsVoids", None):
                self.remove_filling(element)
@@ -339,9 +334,12 @@ class OverrideDeleteTrait:
                    self.remove_filling(rel.RelatedBuildingElement)
                if element.VoidsElements:
                    self.delete_opening_element(element)
-            elif getattr(element, "HasOpenings", None):
-                for rel in element.HasOpenings:
-                    self.delete_opening_element(rel.RelatedOpeningElement)
+            else:
+                if getattr(element, "HasOpenings", None):
+                    for rel in element.HasOpenings:
+                        self.delete_opening_element(rel.RelatedOpeningElement)
+                for port in ifcopenshell.util.system.get_ports(element):
+                    self.remove_port(port)

    def delete_opening_element(self, element):
        obj = IfcStore.get_element(element.VoidsElements[0].RelatingBuildingElement.id())
@@ -351,6 +349,9 @@ class OverrideDeleteTrait:
        obj = IfcStore.get_element(element.id())
        bpy.ops.bim.remove_filling(obj=obj.name)

+    def remove_port(self, port):
+        blenderbim.core.system.remove_port(tool.Ifc, tool.System, port=port)
+

 class OverrideDelete(bpy.types.Operator, OverrideDeleteTrait):
    bl_idname = "object.delete"
@@ -19,6 +19,7 @@
 import bpy
 from bpy.types import Panel
 from blenderbim.bim.ifc import IfcStore
+from blenderbim.bim.helper import prop_with_search
 from blenderbim.bim.module.geometry.data import RepresentationsData, DerivedPlacementsData


@@ -50,7 +51,7 @@ class BIM_PT_representations(Panel):
            layout.label(text="No representations found")

        row = layout.row(align=True)
-        row.prop(context.scene.BIMRootProperties, "contexts", text="")
+        prop_with_search(row, context.scene.BIMRootProperties, "contexts", text="")
        row.operator("bim.add_representation", icon="ADD", text="")

        for representation in RepresentationsData.data["representations"]:
@@ -0,0 +1,123 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2022 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on 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.
+#
+# BlenderBIM Add-on 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 BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import bpy
+import ifcopenshell.util.geolocation
+import blenderbim.tool as tool
+
+
+def refresh():
+    GeoreferenceData.is_loaded = False
+
+
+class GeoreferenceData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.data["blender_derived_angle"] = cls.blender_derived_angle()
+        cls.data["map_conversion"] = cls.map_conversion()
+        cls.data["map_derived_angle"] = cls.map_derived_angle()
+        cls.data["projected_crs"] = cls.projected_crs()
+        cls.data["true_north"] = cls.true_north()
+        cls.data["true_derived_angle"] = cls.true_derived_angle()
+        cls.is_loaded = True
+
+    @classmethod
+    def blender_derived_angle(cls):
+        props = bpy.context.scene.BIMGeoreferenceProperties
+        if props.has_blender_offset:
+            return str(
+                round(
+                    ifcopenshell.util.geolocation.xaxis2angle(
+                        float(props.blender_x_axis_abscissa), float(props.blender_x_axis_ordinate)
+                    ),
+                    3,
+                )
+            )
+
+    @classmethod
+    def map_conversion(cls):
+        if tool.Ifc.get_schema() == "IFC2X3":
+            return {}
+
+        for context in tool.Ifc.get().by_type("IfcGeometricRepresentationContext", include_subtypes=False):
+            if context.HasCoordinateOperation:
+                map_conversion = context.HasCoordinateOperation[0].get_info()
+                del map_conversion["id"]
+                del map_conversion["type"]
+                del map_conversion["SourceCRS"]
+                del map_conversion["TargetCRS"]
+                return map_conversion
+        return {}
+
+    @classmethod
+    def map_derived_angle(cls):
+        if (
+            cls.data["map_conversion"]
+            and cls.data["map_conversion"]["XAxisAbscissa"] is not None
+            and cls.data["map_conversion"]["XAxisOrdinate"] is not None
+        ):
+            return str(
+                round(
+                    ifcopenshell.util.geolocation.xaxis2angle(
+                        cls.data["map_conversion"]["XAxisAbscissa"], cls.data["map_conversion"]["XAxisOrdinate"]
+                    ),
+                    3,
+                )
+            )
+        return ""
+
+    @classmethod
+    def projected_crs(cls):
+        if tool.Ifc.get_schema() == "IFC2X3":
+            return {}
+
+        for context in tool.Ifc.get().by_type("IfcGeometricRepresentationContext", include_subtypes=False):
+            if context.HasCoordinateOperation:
+                projected_crs = context.HasCoordinateOperation[0].TargetCRS.get_info()
+                del projected_crs["id"]
+                del projected_crs["type"]
+                if projected_crs["MapUnit"]:
+                    unit = projected_crs["MapUnit"]
+                    projected_crs["MapUnit"] = (getattr(unit, "Prefix", "") or "") + unit.Name
+                return projected_crs
+        return {}
+
+    @classmethod
+    def true_north(cls):
+        ifc = tool.Ifc.get()
+        true_north = {}
+
+        if ifc.schema == "IFC2X3":
+            return
+
+        for context in ifc.by_type("IfcGeometricRepresentationContext", include_subtypes=False):
+            if not context.TrueNorth:
+                continue
+            true_north = context.TrueNorth.DirectionRatios
+            break
+
+        return true_north
+
+    @classmethod
+    def true_derived_angle(cls):
+        if cls.data["true_north"]:
+            return str(round(ifcopenshell.util.geolocation.yaxis2angle(*cls.data["true_north"][0:2]), 3))
@@ -17,345 +17,157 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import bpy
-import json
-import ifcopenshell
-import ifcopenshell.util.unit
-import ifcopenshell.util.attribute
-import ifcopenshell.api
-import blenderbim.bim.helper
-from blenderbim.bim.ifc import IfcStore
-from ifcopenshell.api.georeference.data import Data
-from ifcopenshell.api.unit.data import Data as UnitData
-from math import radians, degrees, atan, tan, cos, sin
+
+import blenderbim.tool as tool
+import blenderbim.core.georeference as core


-class EnableEditingGeoreferencing(bpy.types.Operator):
-    bl_idname = "bim.enable_editing_georeferencing"
-    bl_label = "Enable Editing Georeferencing"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        self.file = IfcStore.get_file()
-        props = context.scene.BIMGeoreferenceProperties
-        self.props = props
-
-        props.projected_crs.clear()
-
-        blenderbim.bim.helper.import_attributes(
-            "IfcProjectedCRS", props.projected_crs, Data.projected_crs, self.import_projected_crs_attributes
-        )
-
-        props.map_conversion.clear()
-        blenderbim.bim.helper.import_attributes(
-            "IfcMapConversion", props.map_conversion, Data.map_conversion, self.import_map_conversion_attributes
-        )
-
-        props.has_true_north = bool(Data.true_north)
-        if Data.true_north:
-            props.true_north_abscissa = str(Data.true_north[0])
-            props.true_north_ordinate = str(Data.true_north[1])
-
-        props.is_editing = True
-        return {"FINISHED"}
-
-    def import_projected_crs_attributes(self, name, prop, data):
-        if name == "MapUnit":
-            new = self.props.projected_crs.add()
-            new.name = name
-            new.data_type = "enum"
-            new.is_null = data[name] is None
-            new.is_optional = True
-            new.enum_items = json.dumps(
-                {u["id"]: u["Name"] for u in UnitData.units.values() if u["UnitType"] == "LENGTHUNIT"}
-            )
-            if data["MapUnit"]:
-                new.enum_value = str(data["MapUnit"]["id"])
-            return True
-
-    def import_map_conversion_attributes(self, name, prop, data):
-        if name not in ["SourceCRS", "TargetCRS"]:
-            # Enforce a string data type to prevent data loss in single-precision Blender props
-            prop.data_type = "string"
-            prop.string_value = "" if prop.is_null else str(data[name])
-            return True
-
-
-class DisableEditingGeoreferencing(bpy.types.Operator):
-    bl_idname = "bim.disable_editing_georeferencing"
-    bl_label = "Disable Editing Georeferencing"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        props = context.scene.BIMGeoreferenceProperties
-        props.is_editing = False
-        return {"FINISHED"}
-
-
-class EditGeoreferencing(bpy.types.Operator):
-    bl_idname = "bim.edit_georeferencing"
-    bl_label = "Edit Georeferencing"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
-    def _execute(self, context):
-        self.file = IfcStore.get_file()
-        props = context.scene.BIMGeoreferenceProperties
-
-        projected_crs = blenderbim.bim.helper.export_attributes(props.projected_crs, self.export_crs_attributes)
-        map_conversion = blenderbim.bim.helper.export_attributes(props.map_conversion, self.export_map_attributes)
-
-        true_north = None
-        if props.has_true_north:
-            try:
-                true_north = [float(props.true_north_abscissa), float(props.true_north_ordinate)]
-            except ValueError:
-                self.report({"ERROR"}, "True North Abscissa and Ordinate expect a number")
-
-        ifcopenshell.api.run(
-            "georeference.edit_georeferencing",
-            self.file,
-            **{
-                "map_conversion": map_conversion,
-                "projected_crs": projected_crs,
-                "true_north": true_north,
-            }
-        )
-        Data.load(self.file)
-        bpy.ops.bim.disable_editing_georeferencing()
-        return {"FINISHED"}
-
-    def export_map_attributes(self, attributes, prop):
-        if not prop.is_null and prop.data_type == "string":
-            # We store our floats as string to prevent single precision data loss
-            attributes[prop.name] = float(prop.string_value)
-            return True
-
-    def export_crs_attributes(self, attributes, prop):
-        if not prop.is_null and prop.name == "MapUnit":
-            attributes[prop.name] = self.file.by_id(int(prop.enum_value))
-            return True
-
-
-class SetBlenderGridNorth(bpy.types.Operator):
-    bl_idname = "bim.set_blender_grid_north"
-    bl_label = "Set Blender Grid North"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        context.scene.sun_pos_properties.north_offset = -radians(
-            ifcopenshell.util.geolocation.xaxis2angle(
-                float(context.scene.BIMGeoreferenceProperties.map_conversion.get("XAxisAbscissa").string_value),
-                float(context.scene.BIMGeoreferenceProperties.map_conversion.get("XAxisOrdinate").string_value),
-            )
-        )
-        return {"FINISHED"}
-
-
-class SetIfcGridNorth(bpy.types.Operator):
-    bl_idname = "bim.set_ifc_grid_north"
-    bl_label = "Set IFC Grid North"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        x_angle = -context.scene.sun_pos_properties.north_offset
-        context.scene.BIMGeoreferenceProperties.map_conversion.get("XAxisAbscissa").string_value = str(cos(x_angle))
-        context.scene.BIMGeoreferenceProperties.map_conversion.get("XAxisOrdinate").string_value = str(sin(x_angle))
-        return {"FINISHED"}
-
-
-class SetBlenderTrueNorth(bpy.types.Operator):
-    bl_idname = "bim.set_blender_true_north"
-    bl_label = "Set Blender True North"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        context.scene.sun_pos_properties.north_offset = -radians(
-            ifcopenshell.util.geolocation.yaxis2angle(
-                float(context.scene.BIMGeoreferenceProperties.true_north_abscissa),
-                float(context.scene.BIMGeoreferenceProperties.true_north_ordinate),
-            )
-        )
-        return {"FINISHED"}
-
-
-class SetIfcTrueNorth(bpy.types.Operator):
-    bl_idname = "bim.set_ifc_true_north"
-    bl_label = "Set IFC True North"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        y_angle = -context.scene.sun_pos_properties.north_offset + radians(90)
-        context.scene.BIMGeoreferenceProperties.true_north_abscissa = str(cos(y_angle))
-        context.scene.BIMGeoreferenceProperties.true_north_ordinate = str(sin(y_angle))
-        return {"FINISHED"}
-
-
-class RemoveGeoreferencing(bpy.types.Operator):
-    bl_idname = "bim.remove_georeferencing"
-    bl_label = "Remove Georeferencing"
-    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
-
-    def _execute(self, context):
-        ifcopenshell.api.run("georeference.remove_georeferencing", IfcStore.get_file())
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
-
-
-class AddGeoreferencing(bpy.types.Operator):
+class AddGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_georeferencing"
    bl_label = "Add Georeferencing"
    bl_options = {"REGISTER", "UNDO"}
-
-    def execute(self, context):
-        return IfcStore.execute_ifc_operator(self, context)
+    bl_description = "Add a new georeference"

    def _execute(self, context):
-        ifcopenshell.api.run("georeference.add_georeferencing", IfcStore.get_file())
-        Data.load(IfcStore.get_file())
-        return {"FINISHED"}
+        core.add_georeferencing(tool.Ifc)


-class ConvertLocalToGlobal(bpy.types.Operator):
-    bl_idname = "bim.convert_local_to_global"
-    bl_label = "Convert Local To Global"
+class EnableEditingGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.enable_editing_georeferencing"
+    bl_label = "Enable Editing Georeferencing"
    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Enable editing georeferencing"

-    @classmethod
-    def poll(cls, context):
-        file = IfcStore.get_file()
-        props = context.scene.BIMGeoreferenceProperties
-        return file and props.coordinate_input.count(",") == 2
-
-    def execute(self, context):
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
-        props = context.scene.BIMGeoreferenceProperties
-        x, y, z = [float(co) for co in props.coordinate_input.split(",")]
-
-        if props.has_blender_offset:
-            results = ifcopenshell.util.geolocation.xyz2enh(
-                x,
-                y,
-                z,
-                float(props.blender_eastings),
-                float(props.blender_northings),
-                float(props.blender_orthogonal_height),
-                float(props.blender_x_axis_abscissa),
-                float(props.blender_x_axis_ordinate),
-                1.0,
-            )
-            x, y, z = results
-
-        # TODO: what if the project CRS units and the project units are different?
-
-        if Data.map_conversion:
-            results = ifcopenshell.util.geolocation.xyz2enh(
-                x,
-                y,
-                z,
-                Data.map_conversion["Eastings"],
-                Data.map_conversion["Northings"],
-                Data.map_conversion["OrthogonalHeight"],
-                Data.map_conversion.get("XAxisAbscissa", 1.0),
-                Data.map_conversion.get("XAxisOrdinate", 0.0),
-                Data.map_conversion.get("Scale", 1.0),
-            )
-        else:
-            results = (x, y, z)
-
-        props.coordinate_output = ",".join([str(r) for r in results])
-        context.scene.cursor.location = results
-        return {"FINISHED"}
+    def _execute(self, context):
+        core.enable_editing_georeferencing(tool.Georeference)


-class ConvertGlobalToLocal(bpy.types.Operator):
-    bl_idname = "bim.convert_global_to_local"
-    bl_label = "Convert Global To Local"
+class RemoveGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.remove_georeferencing"
+    bl_label = "Remove Georeferencing"
    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Remove the georeferencing"

-    @classmethod
-    def poll(cls, context):
-        file = IfcStore.get_file()
-        props = context.scene.BIMGeoreferenceProperties
-        return file and file.by_type("IfcUnitAssignment") and props.coordinate_input.count(",") == 2
-
-    def execute(self, context):
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
-        props = context.scene.BIMGeoreferenceProperties
-        x, y, z = [float(co) for co in props.coordinate_input.split(",")]
-
-        if Data.map_conversion:
-            results = ifcopenshell.util.geolocation.enh2xyz(
-                x,
-                y,
-                z,
-                Data.map_conversion["Eastings"],
-                Data.map_conversion["Northings"],
-                Data.map_conversion["OrthogonalHeight"],
-                Data.map_conversion.get("XAxisAbscissa", 1.0),
-                Data.map_conversion.get("XAxisOrdinate", 0.0),
-                Data.map_conversion.get("Scale", 1.0),
-            )
-        else:
-            results = (x, y, z)
-
-        if props.has_blender_offset:
-            results = ifcopenshell.util.geolocation.enh2xyz(
-                results[0],
-                results[1],
-                results[2],
-                float(props.blender_eastings),
-                float(props.blender_northings),
-                float(props.blender_orthogonal_height),
-                float(props.blender_x_axis_abscissa),
-                float(props.blender_x_axis_ordinate),
-                1.0,
-            )
-
-        props.coordinate_output = ",".join([str(r) for r in results])
-
-        scale = ifcopenshell.util.unit.calculate_unit_scale(IfcStore.get_file())
-        context.scene.cursor.location = [o * scale for o in results]
-        return {"FINISHED"}
+    def _execute(self, context):
+        core.remove_georeferencing(tool.Ifc)


-class GetCursorLocation(bpy.types.Operator):
+class EditGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.edit_georeferencing"
+    bl_label = "Edit Georeferencing"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Edit the georeferencing"
+
+    def _execute(self, context):
+        core.edit_georeferencing(tool.Ifc, tool.Georeference)
+
+
+class DisableEditingGeoreferencing(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.disable_editing_georeferencing"
+    bl_label = "Disable Editing Georeferencing"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Close editing panel"
+
+    def _execute(self, context):
+        core.disable_editing_georeferencing(tool.Georeference)
+
+
+class SetIfcGridNorth(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.set_ifc_grid_north"
+    bl_label = "Set IFC Grid North"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Set IFC grid north"
+
+    def _execute(self, context):
+        core.set_ifc_grid_north(tool.Georeference)
+
+
+class SetBlenderGridNorth(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.set_blender_grid_north"
+    bl_label = "Set Blender Grid North"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Set Blender grid north"
+
+    def _execute(self, context):
+        core.set_blender_grid_north(tool.Georeference)
+
+
+class GetCursorLocation(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.get_cursor_location"
    bl_label = "Get Cursor Location"
    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Insert the current cursor coordinates"

    @classmethod
    def poll(cls, context):
-        file = IfcStore.get_file()
-        return file and file.by_type("IfcUnitAssignment")
+        return tool.Ifc.get()

-    def execute(self, context):
-        props = context.scene.BIMGeoreferenceProperties
-        scale = ifcopenshell.util.unit.calculate_unit_scale(IfcStore.get_file())
-        project_coordinates = [o / scale for o in context.scene.cursor.location]
-        props.coordinate_input = ",".join([str(o) for o in project_coordinates])
-        return {"FINISHED"}
+    def _execute(self, context):
+        core.get_cursor_location(tool.Georeference)


-class SetCursorLocation(bpy.types.Operator):
+class SetCursorLocation(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.set_cursor_location"
    bl_label = "Set Cursor Location"
    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Move curson location to the specified coordinates"

    @classmethod
    def poll(cls, context):
-        file = IfcStore.get_file()
        props = context.scene.BIMGeoreferenceProperties
-        return file and file.by_type("IfcUnitAssignment") and props.coordinate_output.count(",") == 2
+        return tool.Ifc.get() and props.coordinate_output.count(",") == 2

-    def execute(self, context):
+    def _execute(self, context):
+        core.set_cursor_location(tool.Georeference)
+
+
+class SetIfcTrueNorth(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.set_ifc_true_north"
+    bl_label = "Set IFC True North"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Set IFC True north"
+
+    def _execute(self, context):
+        core.set_ifc_true_north(tool.Georeference)
+
+
+class SetBlenderTrueNorth(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.set_blender_true_north"
+    bl_label = "Set Blender True North"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Set Blender true north"
+
+    def _execute(self, context):
+        core.set_blender_true_north(tool.Georeference)
+
+
+class ConvertLocalToGlobal(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.convert_local_to_global"
+    bl_label = "Convert Local To Global"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Convert local coordinate to global coordinate"
+
+    @classmethod
+    def poll(cls, context):
+        file = tool.Ifc.get()
        props = context.scene.BIMGeoreferenceProperties
-        scale = ifcopenshell.util.unit.calculate_unit_scale(IfcStore.get_file())
-        context.scene.cursor.location = [float(co) * scale for co in props.coordinate_output.split(",")]
-        return {"FINISHED"}
+        return file and props.coordinate_input.count(",") == 2
+
+    def _execute(self, context):
+        core.convert_local_to_global(tool.Georeference)
+
+
+class ConvertGlobalToLocal(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.convert_global_to_local"
+    bl_label = "Convert Global To Local"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Convert global coordinate to local coordinate"
+
+    @classmethod
+    def poll(cls, context):
+        file = tool.Ifc.get()
+        props = context.scene.BIMGeoreferenceProperties
+        return file and file.by_type("IfcUnitAssignment") and props.coordinate_input.count(",") == 2
+
+    def _execute(self, context):
+        core.convert_global_to_local(tool.Georeference)
@@ -16,11 +16,10 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

-import ifcopenshell.util.geolocation
+import blenderbim.tool as tool
 from bpy.types import Panel
-from ifcopenshell.api.georeference.data import Data
-from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.helper import draw_attributes, draw_attribute
+from blenderbim.bim.module.georeference.data import GeoreferenceData


 class BIM_PT_gis(Panel):
@@ -32,16 +31,13 @@ class BIM_PT_gis(Panel):
    bl_context = "scene"
    bl_parent_id = "BIM_PT_geometry"

-    @classmethod
-    def poll(cls, context):
-        return IfcStore.get_file()
-
    def draw(self, context):
        self.layout.use_property_split = True
        self.layout.use_property_decorate = False
        props = context.scene.BIMGeoreferenceProperties
-        if not Data.is_loaded:
-            Data.load(IfcStore.get_file())
+
+        if not GeoreferenceData.is_loaded:
+            GeoreferenceData.load()

        if props.is_editing:
            return self.draw_editable_ui(context)
@@ -82,10 +78,10 @@ class BIM_PT_gis(Panel):
    def draw_ui(self, context):
        props = context.scene.BIMGeoreferenceProperties

-        if not Data.projected_crs:
+        if not GeoreferenceData.data["projected_crs"]:
            row = self.layout.row(align=True)
            row.label(text="Not Georeferenced")
-            if IfcStore.get_file().schema != "IFC2X3":
+            if tool.Ifc.get_schema != "IFC2X3":
                row.operator("bim.add_georeferencing", icon="ADD", text="")

        if props.has_blender_offset:
@@ -109,43 +105,27 @@ class BIM_PT_gis(Panel):
            row.label(text=props.blender_x_axis_ordinate)
            row = self.layout.row(align=True)
            row.label(text="Derived Grid North")
-            row.label(
-                text=str(
-                    round(
-                        ifcopenshell.util.geolocation.xaxis2angle(
-                            float(props.blender_x_axis_abscissa), float(props.blender_x_axis_ordinate)
-                        ),
-                        3,
-                    )
-                )
-            )
-        elif IfcStore.get_file().schema == "IFC2X3":
-            row = self.layout.row()
-            row.label(text="Not Georeferenced")
+            row.label(text=GeoreferenceData.data["blender_derived_angle"])

-        if Data.projected_crs:
+        if GeoreferenceData.data["projected_crs"]:
            row = self.layout.row(align=True)
            row.label(text="Projected CRS", icon="WORLD")
            row.operator("bim.enable_editing_georeferencing", icon="GREASEPENCIL", text="")
            row.operator("bim.remove_georeferencing", icon="X", text="")

-        for key, value in Data.projected_crs.items():
-            if key == "id" or key == "type" or not value:
+        for key, value in GeoreferenceData.data["projected_crs"].items():
+            if not value:
                continue
-            if key == "MapUnit":
-                unit_value = value.get("Prefix", "") or ""
-                unit_value += value["Name"]
-                value = unit_value
            row = self.layout.row(align=True)
            row.label(text=key)
            row.label(text=str(value))

-        if Data.map_conversion:
+        if GeoreferenceData.data["map_conversion"]:
            row = self.layout.row(align=True)
            row.label(text="Map Conversion", icon="GRID")

-        for key, value in Data.map_conversion.items():
-            if key == "id" or key == "type" or key == "SourceCRS" or key == "TargetCRS" or value is None:
+        for key, value in GeoreferenceData.data["map_conversion"].items():
+            if value is None:
                continue
            row = self.layout.row(align=True)
            row.label(text=key)
@@ -153,26 +133,17 @@ class BIM_PT_gis(Panel):
            if key == "XAxisOrdinate":
                row = self.layout.row(align=True)
                row.label(text="Derived Angle")
-                row.label(
-                    text=str(
-                        round(
-                            ifcopenshell.util.geolocation.xaxis2angle(
-                                Data.map_conversion["XAxisAbscissa"], Data.map_conversion["XAxisOrdinate"]
-                            ),
-                            3,
-                        )
-                    )
-                )
+                row.label(text=GeoreferenceData.data["map_derived_angle"])

-        if Data.true_north:
+        if GeoreferenceData.data["true_north"]:
            row = self.layout.row()
            row.label(text="True North", icon="LIGHT_SUN")
            row = self.layout.row(align=True)
            row.label(text="Vector")
-            row.label(text=str(Data.true_north[0:2])[1:-1])
+            row.label(text=str(GeoreferenceData.data["true_north"][0:2])[1:-1])
            row = self.layout.row(align=True)
            row.label(text="Derived Angle")
-            row.label(text=str(round(ifcopenshell.util.geolocation.yaxis2angle(*Data.true_north[0:2]), 3)))
+            row.label(text=GeoreferenceData.data["true_derived_angle"])


 class BIM_PT_gis_utilities(Panel):
@@ -20,17 +20,20 @@ import bpy
 from . import ui, prop, operator

 classes = (
-    operator.LoadGroups,
-    operator.DisableGroupEditingUI,
    operator.AddGroup,
-    operator.EditGroup,
-    operator.RemoveGroup,
-    operator.ToggleAssigningGroup,
    operator.AssignGroup,
-    operator.UnassignGroup,
-    operator.EnableEditingGroup,
    operator.DisableEditingGroup,
+    operator.DisableGroupEditingUI,
+    operator.EditGroup,
+    operator.EnableEditingGroup,
+    operator.LoadGroups,
+    operator.RemoveGroup,
    operator.SelectGroupProducts,
+    operator.ToggleAssigningGroup,
+    operator.ToggleGroup,
+    operator.UnassignGroup,
+    operator.UpdateGroup,
+    prop.ExpandedGroups,
    prop.Group,
    prop.BIMGroupProperties,
    ui.BIM_PT_groups,
@@ -42,7 +45,9 @@ classes = (

 def register():
    bpy.types.Scene.BIMGroupProperties = bpy.props.PointerProperty(type=prop.BIMGroupProperties)
+    bpy.types.Scene.ExpandedGroups = bpy.props.PointerProperty(type=prop.ExpandedGroups)


 def unregister():
    del bpy.types.Scene.BIMGroupProperties
+    del bpy.types.Scene.ExpandedGroups
@@ -20,24 +20,89 @@ import bpy
 import ifcopenshell.util.attribute
 import ifcopenshell.api
 import blenderbim.bim.helper
+import blenderbim.tool as tool
 from blenderbim.bim.ifc import IfcStore
 from ifcopenshell.api.group.data import Data
+from ifcopenshell.util.selector import Selector
+import json


 class LoadGroups(bpy.types.Operator):
    bl_idname = "bim.load_groups"
    bl_label = "Load Groups"
    bl_options = {"REGISTER", "UNDO"}
+    is_refresh: bpy.props.BoolProperty(default=False)

    def execute(self, context):
-        props = context.scene.BIMGroupProperties
-        props.groups.clear()
+        self.props = context.scene.BIMGroupProperties
+        self.expanded_groups = json.loads(context.scene.ExpandedGroups.json_string)
+        self.props.groups.clear()
+        self.ifc = IfcStore.get_file()
+        if not self.is_refresh:
+            context.scene.ExpandedGroups.json_string = "{}"
+
        for ifc_definition_id, group in Data.groups.items():
-            new = props.groups.add()
-            new.ifc_definition_id = ifc_definition_id
-            new.name = group["Name"]
-        props.is_editing = True
+            if not group["HasAssignments"]:
+                new = self.props.groups.add()
+                new.ifc_definition_id = ifc_definition_id
+                new.name = group["Name"]
+                new.selection_query = group["Description"].split("*selector*")[1] if group["Description"] else ""
+                new.tree_depth = 0
+
+                if group["IsGroupedBy"]:
+                    #  assumes 1:1 cardinality, will need to be updated to reflect IFC4 changes
+                    # where the cardinality is 0:? - vulevukusej
+                    sub_groups = [g for g in group["IsGroupedBy"][0].RelatedObjects if g.is_a("IfcGroup")]
+                    new.has_children = True if len(sub_groups) != 0 else False
+
+                if self.is_refresh:
+                    self.recursively_load_sub_groups(ifc_definition_id, new)
+
+        self.props.is_editing = True
        bpy.ops.bim.disable_editing_group()
+        Data.load(IfcStore.get_file())
+        return {"FINISHED"}
+
+    def recursively_load_sub_groups(self, ifc_definition_id, parent):
+        sub_groups = [
+            k for k, v in Data.products.items() if self.ifc.by_id(k).is_a("IfcGroup") and ifc_definition_id in v
+        ]
+        if str(ifc_definition_id) not in self.expanded_groups or sub_groups == []:
+            return
+        else:
+            parent.is_expanded = True
+            parent.has_children = True
+            for group in sub_groups:
+                new = self.props.groups.add()
+                new.ifc_definition_id = group
+                new.name = Data.groups[group]["Name"]
+                new.selection_query = (
+                    Data.groups[group]["Description"].split("*selector*")[1]
+                    if Data.groups[group]["Description"]
+                    else ""
+                )
+                new.has_children = True if len(Data.groups[group]["IsGroupedBy"]) != 0 else False
+                new.tree_depth = parent.tree_depth + 1
+                self.recursively_load_sub_groups(new.ifc_definition_id, new)
+
+
+class ToggleGroup(bpy.types.Operator):
+    bl_idname = "bim.toggle_group"
+    bl_label = "Toggle Group"
+    bl_options = {"REGISTER", "UNDO"}
+    ifc_definition_id: bpy.props.IntProperty()
+    index: bpy.props.IntProperty()
+    option: bpy.props.StringProperty(name="Expand or Collapse")
+
+    def execute(self, context):
+        context.scene.BIMGroupProperties.groups[self.index].is_expanded = True if self.option == "Expand" else False
+        json_string = json.loads(context.scene.ExpandedGroups.json_string)
+        if self.option == "Expand":
+            json_string.setdefault(str(self.ifc_definition_id), None)
+        else:
+            json_string.pop(str(self.ifc_definition_id), None)
+        context.scene.ExpandedGroups.json_string = json.dumps(json_string)
+        bpy.ops.bim.load_groups(is_refresh=True)
        return {"FINISHED"}


@@ -54,17 +119,21 @@ class DisableGroupEditingUI(bpy.types.Operator):

 class AddGroup(bpy.types.Operator):
    bl_idname = "bim.add_group"
-    bl_label = "Add Group"
+    bl_label = "Add New Group"
    bl_options = {"REGISTER", "UNDO"}
+    group: bpy.props.IntProperty()

    def execute(self, context):
        return IfcStore.execute_ifc_operator(self, context)

    def _execute(self, context):
-        result = ifcopenshell.api.run("group.add_group", IfcStore.get_file())
-        Data.load(IfcStore.get_file())
-        bpy.ops.bim.load_groups()
-        bpy.ops.bim.enable_editing_group(group=result.id())
+        result = ifcopenshell.api.run("group.add_group", tool.Ifc.get())
+        if self.group:
+            ifcopenshell.api.run(
+                "group.assign_group", tool.Ifc.get(), products=[result], group=tool.Ifc.get().by_id(self.group)
+            )
+        Data.load(tool.Ifc.get())
+        bpy.ops.bim.load_groups(is_refresh=True)
        return {"FINISHED"}


@@ -72,6 +141,7 @@ class EditGroup(bpy.types.Operator):
    bl_idname = "bim.edit_group"
    bl_label = "Edit Group"
    bl_options = {"REGISTER", "UNDO"}
+    copy_from_selector: bpy.props.BoolProperty(name="Copy from Selector", default=False)

    def execute(self, context):
        return IfcStore.execute_ifc_operator(self, context)
@@ -84,12 +154,16 @@ class EditGroup(bpy.types.Operator):
                attributes[attribute.name] = None
            else:
                attributes[attribute.name] = attribute.string_value
+
+        if self.copy_from_selector:
+            attributes["Description"] = context.scene.IFCSelector.selection_query
+
        self.file = IfcStore.get_file()
        ifcopenshell.api.run(
            "group.edit_group", self.file, **{"group": self.file.by_id(props.active_group_id), "attributes": attributes}
        )
        Data.load(IfcStore.get_file())
-        bpy.ops.bim.load_groups()
+        bpy.ops.bim.load_groups(is_refresh=True)
        return {"FINISHED"}


@@ -107,7 +181,7 @@ class RemoveGroup(bpy.types.Operator):
        self.file = IfcStore.get_file()
        ifcopenshell.api.run("group.remove_group", self.file, **{"group": self.file.by_id(self.group)})
        Data.load(IfcStore.get_file())
-        bpy.ops.bim.load_groups()
+        bpy.ops.bim.load_groups(is_refresh=True)
        return {"FINISHED"}


@@ -120,9 +194,7 @@ class EnableEditingGroup(bpy.types.Operator):
    def execute(self, context):
        props = context.scene.BIMGroupProperties
        props.group_attributes.clear()
-
        blenderbim.bim.helper.import_attributes("IfcGroup", props.group_attributes, Data.groups[self.group])
-
        props.active_group_id = self.group
        return {"FINISHED"}

@@ -166,10 +238,8 @@ class AssignGroup(bpy.types.Operator):
            ifcopenshell.api.run(
                "group.assign_group",
                self.file,
-                **{
-                    "product": self.file.by_id(product.BIMObjectProperties.ifc_definition_id),
-                    "group": self.file.by_id(self.group),
-                }
+                products=[self.file.by_id(product.BIMObjectProperties.ifc_definition_id)],
+                group=self.file.by_id(self.group),
            )
        Data.load(self.file)
        return {"FINISHED"}
@@ -219,3 +289,32 @@ class SelectGroupProducts(bpy.types.Operator):
            if self.group in product_groups:
                obj.select_set(True)
        return {"FINISHED"}
+
+
+class UpdateGroup(bpy.types.Operator):
+    bl_idname = "bim.update_group"
+    bl_label = "Update Group"
+    bl_options = {"REGISTER", "UNDO"}
+    query: bpy.props.StringProperty()
+    group_id: bpy.props.IntProperty()
+
+    def execute(self, context):
+        return IfcStore.execute_ifc_operator(self, context)
+
+    def _execute(self, context):
+        self.file = IfcStore.get_file()
+        group = self.file.by_id(self.group_id)
+        query = self.query
+
+        new_products = Selector.parse(self.file, query)
+        ifcopenshell.api.run(
+            "group.update_group_products",
+            self.file,
+            **{
+                "group": group,
+                "products": new_products,
+            }
+        )
+        Data.load(IfcStore.get_file())
+        bpy.ops.bim.load_groups(is_refresh=True)
+        return {"FINISHED"}
@@ -18,7 +18,10 @@

 import bpy
 from blenderbim.bim.prop import StrProperty, Attribute
+from blenderbim.bim.helper import import_attributes
+from ifcopenshell.api.group.data import Data
 from bpy.types import PropertyGroup
+import json
 from bpy.props import (
    PointerProperty,
    StringProperty,
@@ -31,9 +34,17 @@ from bpy.props import (
 )


+class ExpandedGroups(StrProperty):
+    json_string: StringProperty(name="JSON String", default="{}")
+
+
 class Group(PropertyGroup):
    name: StringProperty(name="Name")
    ifc_definition_id: IntProperty(name="IFC Definition ID")
+    selection_query: StringProperty(name="Selection Query")
+    is_expanded: BoolProperty(name="Is Expanded", default=False)
+    has_children: BoolProperty(name="Has Children", default=False)
+    tree_depth: IntProperty(name="Tree Depth")


 class BIMGroupProperties(PropertyGroup):
@@ -40,9 +40,9 @@ class BIM_PT_groups(Panel):
        self.props = context.scene.BIMGroupProperties

        row = self.layout.row(align=True)
-        row.label(text="{} Groups Found".format(len(Data.groups)), icon="OUTLINER")
+        row.label(text=f"{len(Data.groups)} Groups Found", icon="OUTLINER")
        if self.props.is_editing:
-            row.operator("bim.add_group", text="", icon="ADD")
+            row.operator("bim.add_group", text="", icon="ADD").group = 0
            row.operator("bim.disable_group_editing_ui", text="", icon="CANCEL")
        else:
            row.operator("bim.load_groups", text="", icon="GREASEPENCIL")
@@ -115,10 +115,22 @@ class BIM_PT_object_groups(Panel):


 class BIM_UL_groups(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        if item:
            row = layout.row(align=True)
-            row.label(text=item.name)
+            for i in range(0, item.tree_depth):
+                row.label(text="", icon="BLANK1")
+            if item.has_children:
+                op = row.operator(
+                    "bim.toggle_group", icon="TRIA_DOWN" if item.is_expanded else "TRIA_RIGHT", text="", emboss=False
+                )
+                op.ifc_definition_id = item.ifc_definition_id
+                op.index = index
+                op.option = "Collapse" if item.is_expanded else "Expand"
+            else:
+                row.label(text="", icon="BLANK1")
+
+            row.label(text=f"*{item.name}") if item.selection_query != "" else row.label(text=item.name)
            group_id = item.ifc_definition_id
            if context.scene.BIMGroupProperties.active_group_id == group_id:
                op = row.operator("bim.select_group_products", text="", icon="RESTRICT_SELECT_OFF")
@@ -128,21 +140,46 @@ class BIM_UL_groups(UIList):
            elif context.scene.BIMGroupProperties.active_group_id:
                op = row.operator("bim.select_group_products", text="", icon="RESTRICT_SELECT_OFF")
                op.group = group_id
+                op = row.operator("bim.add_group", text="", icon="ADD")
+                op.group = group_id
                op = row.operator("bim.remove_group", text="", icon="X")
                op.group = group_id
+                if item.selection_query != "":
+                    op = row.operator("bim.update_group", text="", icon="FILE_REFRESH")
+                    op.group_id = item.ifc_definition_id
+                    op.query = item.selection_query
            else:
                op = row.operator("bim.select_group_products", text="", icon="RESTRICT_SELECT_OFF")
                op.group = group_id
                op = row.operator("bim.enable_editing_group", text="", icon="GREASEPENCIL")
                op.group = group_id
+                op = row.operator("bim.add_group", text="", icon="ADD")
+                op.group = group_id
                op = row.operator("bim.remove_group", text="", icon="X")
                op.group = group_id
+                if item.selection_query != "":
+                    op = row.operator("bim.update_group", text="", icon="FILE_REFRESH")
+                    op.group_id = item.ifc_definition_id
+                    op.query = item.selection_query


 class BIM_UL_object_groups(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        if item:
            row = layout.row(align=True)
+            for i in range(0, item.tree_depth):
+                row.label(text="", icon="BLANK1")
+            if item.has_children:
+                op = row.operator(
+                    "bim.toggle_group", icon="TRIA_DOWN" if item.is_expanded else "TRIA_RIGHT", text="", emboss=False
+                )
+                op.ifc_definition_id = item.ifc_definition_id
+                op.index = index
+                op.option = "Collapse" if item.is_expanded else "Expand"
+            else:
+                row.label(text="", icon="BLANK1")
            row.label(text=item.name)
+            op = row.operator("bim.remove_group", text="", icon="X")
+            op.group = item.ifc_definition_id
            op = row.operator("bim.assign_group", text="", icon="ADD")
            op.group = item.ifc_definition_id
@@ -28,6 +28,7 @@ classes = (
    operator.AddProfile,
    operator.AssignMaterial,
    operator.AssignParameterizedProfile,
+    operator.ContractMaterialCategory,
    operator.CopyMaterial,
    operator.DisableEditingAssignedMaterial,
    operator.DisableEditingMaterialSetItem,
@@ -36,6 +37,7 @@ classes = (
    operator.EditMaterialSetItem,
    operator.EnableEditingAssignedMaterial,
    operator.EnableEditingMaterialSetItem,
+    operator.ExpandMaterialCategory,
    operator.LoadMaterials,
    operator.RemoveConstituent,
    operator.RemoveLayer,
@@ -44,6 +46,7 @@ classes = (
    operator.RemoveMaterialSet,
    operator.RemoveProfile,
    operator.ReorderMaterialSetItem,
+    operator.SelectByMaterial,
    operator.UnassignMaterial,
    operator.UnlinkMaterial,
    prop.Material,
@@ -25,6 +25,7 @@ import blenderbim.tool as tool

 def refresh():
    MaterialsData.is_loaded = False
+    ObjectMaterialData.is_loaded = False


 class MaterialsData:
@@ -41,6 +42,12 @@ class MaterialsData:

    @classmethod
    def total_materials(cls):
+        if tool.Ifc.get_schema() == "IFC2X3":
+            return (
+                len(tool.Ifc.get().by_type("IfcMaterial"))
+                + len(tool.Ifc.get().by_type("IfcMaterialLayerSet"))
+                + len(tool.Ifc.get().by_type("IfcMaterialList"))
+            )
        return (
            len(tool.Ifc.get().by_type("IfcMaterial"))
            + len(tool.Ifc.get().by_type("IfcMaterialConstituentSet"))
@@ -61,3 +68,36 @@ class MaterialsData:
        if tool.Ifc.get_schema() == "IFC2X3":
            material_types = ["IfcMaterial", "IfcMaterialLayerSet", "IfcMaterialList"]
        return [(m, m, "") for m in material_types]
+
+
+class ObjectMaterialData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.data = {
+            "materials": cls.materials(),
+            "type_material": cls.type_material(),
+        }
+        cls.is_loaded = True
+
+    @classmethod
+    def materials(cls):
+        return sorted(
+            [(str(m.id()), m.Name or "Unnamed", "") for m in tool.Ifc.get().by_type("IfcMaterial")], key=lambda x: x[1]
+        )
+
+    @classmethod
+    def type_material(cls):
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        element_type = ifcopenshell.util.element.get_type(element)
+        if element_type and element_type != element:
+            material = ifcopenshell.util.element.get_material(element_type)
+            if not material:
+                return
+            if material.is_a() in ("IfcMaterialLayerSetUsage", "IfcMaterialLayerSet"):
+                name_attr = "LayerSetName"
+            else:
+                name_attr = "Name"
+            return getattr(material, name_attr, "Unnamed") or "Unnamed"
@@ -49,6 +49,16 @@ class DisableEditingMaterials(bpy.types.Operator, tool.Ifc.Operator):
        core.disable_editing_materials(tool.Material)


+class SelectByMaterial(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.select_by_material"
+    bl_label = "Select By Material"
+    bl_options = {"REGISTER", "UNDO"}
+    material: bpy.props.IntProperty()
+
+    def _execute(self, context):
+        core.select_by_material(tool.Material, material=tool.Ifc.get().by_id(self.material))
+
+
 class AssignParameterizedProfile(bpy.types.Operator):
    bl_idname = "bim.assign_parameterized_profile"
    bl_label = "Assign Parameterized Profile"
@@ -768,3 +778,31 @@ class CopyMaterial(bpy.types.Operator):
        if material.id() in object_material_ids:
            return
        obj.data.materials.append(IfcStore.get_element(material.id()))
+
+
+class ExpandMaterialCategory(bpy.types.Operator):
+    bl_idname = "bim.expand_material_category"
+    bl_label = "Expand Material Category"
+    bl_options = {"REGISTER", "UNDO"}
+    category: bpy.props.StringProperty()
+
+    def execute(self, context):
+        props = context.scene.BIMMaterialProperties
+        for category in [c for c in props.materials if c.is_category and c.name == self.category]:
+            category.is_expanded = True
+        core.load_materials(tool.Material, props.material_type)
+        return {"FINISHED"}
+
+
+class ContractMaterialCategory(bpy.types.Operator):
+    bl_idname = "bim.contract_material_category"
+    bl_label = "Contract Material Category"
+    bl_options = {"REGISTER", "UNDO"}
+    category: bpy.props.StringProperty()
+
+    def execute(self, context):
+        props = context.scene.BIMMaterialProperties
+        for category in [c for c in props.materials if c.is_category and c.name == self.category]:
+            category.is_expanded = False
+        core.load_materials(tool.Material, props.material_type)
+        return {"FINISHED"}
@@ -18,7 +18,7 @@

 import bpy
 from ifcopenshell.api.material.data import Data
-from blenderbim.bim.module.material.data import MaterialsData
+from blenderbim.bim.module.material.data import MaterialsData, ObjectMaterialData
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.prop import StrProperty, Attribute
 from bpy.types import PropertyGroup
@@ -33,18 +33,15 @@ from bpy.props import (
    CollectionProperty,
 )

-materials_enum = []
 materialtypes_enum = []
 profileclasses_enum = []
 parameterizedprofileclasses_enum = []


 def purge():
-    global materials_enum
    global materialtypes_enum
    global profileclasses_enum
    global parameterizedprofileclasses_enum
-    materials_enum = []
    materialtypes_enum = []
    profileclasses_enum = []
    parameterizedprofileclasses_enum = []
@@ -78,12 +75,10 @@ def getParameterizedProfileClasses(self, context):
    return parameterizedprofileclasses_enum


-def getMaterials(self, context):
-    global materials_enum
-    if len(materials_enum) == 0 and IfcStore.get_file():
-        materials_enum.clear()
-        materials_enum = [(str(m_id), m["Name"], "") for m_id, m in Data.materials.items()]
-    return materials_enum
+def get_materials(self, context):
+    if not ObjectMaterialData.is_loaded:
+        ObjectMaterialData.load()
+    return ObjectMaterialData.data["materials"]


 def getMaterialTypes(self, context):
@@ -114,6 +109,8 @@ def get_material_types(self, context):
 class Material(PropertyGroup):
    name: StringProperty(name="Name")
    ifc_definition_id: IntProperty(name="IFC Definition ID")
+    is_category: BoolProperty(name="Is Category", default=False)
+    is_expanded: BoolProperty(name="Is Expanded", default=True)
    total_elements: IntProperty(name="Total Elements")


@@ -126,7 +123,7 @@ class BIMMaterialProperties(PropertyGroup):

 class BIMObjectMaterialProperties(PropertyGroup):
    material_type: EnumProperty(items=getMaterialTypes, name="Material Type")
-    material: EnumProperty(items=getMaterials, name="Material")
+    material: EnumProperty(items=get_materials, name="Material")
    is_editing: BoolProperty(name="Is Editing", default=False)
    material_set_usage_attributes: CollectionProperty(name="Material Set Usage Attributes", type=Attribute)
    material_set_attributes: CollectionProperty(name="Material Set Attributes", type=Attribute)
@@ -135,7 +132,7 @@ class BIMObjectMaterialProperties(PropertyGroup):
    material_set_item_profile_attributes: CollectionProperty(
        name="Material Set Item Profile Attributes", type=Attribute
    )
-    material_set_item_material: EnumProperty(items=getMaterials, name="Material")
+    material_set_item_material: EnumProperty(items=get_materials, name="Material")
    profile_classes: EnumProperty(items=getProfileClasses, name="Profile Classes")
    parameterized_profile_classes: EnumProperty(
        items=getParameterizedProfileClasses, name="Parameterized Profile Classes"
@@ -22,7 +22,8 @@ from ifcopenshell.api.material.data import Data
 from ifcopenshell.api.profile.data import Data as ProfileData
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.helper import draw_attributes
-from blenderbim.bim.module.material.data import MaterialsData
+from blenderbim.bim.helper import prop_with_search
+from blenderbim.bim.module.material.data import MaterialsData, ObjectMaterialData


 class BIM_PT_materials(Panel):
@@ -50,7 +51,7 @@ class BIM_PT_materials(Panel):
            row.operator("bim.disable_editing_materials", text="", icon="CANCEL")
        else:
            row = self.layout.row(align=True)
-            row.prop(self.props, "material_type", text="")
+            prop_with_search(row, self.props, "material_type", text="")
            row.operator("bim.load_materials", text="", icon="IMPORT")
            return

@@ -61,12 +62,18 @@ class BIM_PT_materials(Panel):
            row.operator("bim.add_material", text="", icon="ADD")
            if self.props.materials and self.props.active_material_index < len(self.props.materials):
                material = self.props.materials[self.props.active_material_index]
-                row.operator("bim.remove_material", text="", icon="X").material = material.ifc_definition_id
+                if material.ifc_definition_id:
+                    op = row.operator("bim.select_by_material", text="", icon="RESTRICT_SELECT_OFF")
+                    op.material = material.ifc_definition_id
+                    row.operator("bim.remove_material", text="", icon="X").material = material.ifc_definition_id
        else:
            row.operator("bim.add_material_set", text="", icon="ADD").set_type = self.props.material_type
            if self.props.materials and self.props.active_material_index < len(self.props.materials):
                material = self.props.materials[self.props.active_material_index]
-                row.operator("bim.remove_material_set", text="", icon="X").material = material.ifc_definition_id
+                if material.ifc_definition_id:
+                    op = row.operator("bim.select_by_material", text="", icon="RESTRICT_SELECT_OFF")
+                    op.material = material.ifc_definition_id
+                    row.operator("bim.remove_material_set", text="", icon="X").material = material.ifc_definition_id

        self.layout.template_list("BIM_UL_materials", "", self.props, "materials", self.props, "active_material_index")

@@ -115,6 +122,9 @@ class BIM_PT_object_material(Panel):
        return True

    def draw(self, context):
+        if not ObjectMaterialData.is_loaded:
+            ObjectMaterialData.load()
+
        self.file = IfcStore.get_file()
        self.oprops = context.active_object.BIMObjectProperties
        self.props = context.active_object.BIMObjectMaterialProperties
@@ -126,12 +136,16 @@ class BIM_PT_object_material(Panel):
            ProfileData.load(self.file)
        self.product_data = Data.products[self.oprops.ifc_definition_id]

-        if not Data.materials:
+        if not ObjectMaterialData.data["materials"]:
            row = self.layout.row(align=True)
            row.label(text="No Materials Available")
            row.operator("bim.add_material", icon="ADD", text="").obj = ""
            return

+        if ObjectMaterialData.data["type_material"]:
+            row = self.layout.row(align=True)
+            row.label(text="Inherited Material: " + ObjectMaterialData.data["type_material"], icon="FILE_PARENT")
+
        if self.product_data:
            if self.product_data["type"] == "IfcMaterialConstituentSet":
                self.material_set_id = self.product_data["id"]
@@ -175,9 +189,9 @@ class BIM_PT_object_material(Panel):
            return self.draw_material_ui()

        row = self.layout.row(align=True)
-        row.prop(self.props, "material_type", text="")
+        prop_with_search(row, self.props, "material_type", text="")
        if self.props.material_type == "IfcMaterial" or self.props.material_type == "IfcMaterialList":
-            row.prop(self.props, "material", text="")
+            prop_with_search(row, self.props, "material", text="")
        row.operator("bim.assign_material", icon="ADD", text="")

    def draw_material_ui(self):
@@ -207,8 +221,7 @@ class BIM_PT_object_material(Panel):
        return self.draw_read_only_single_ui()

    def draw_editable_single_ui(self):
-        row = self.layout.row(align=True)
-        row.prop(self.props, "material", text="")
+        prop_with_search(self.layout, self.props, "material", text="")

    def draw_read_only_single_ui(self):
        material = Data.materials[self.product_data["id"]]
@@ -229,7 +242,7 @@ class BIM_PT_object_material(Panel):
            row.prop(attribute, "string_value", text=attribute.name)
            row.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
        row = self.layout.row(align=True)
-        row.prop(self.props, "material", text="")
+        prop_with_search(row, self.props, "material", text="")

        op = row.operator(f"bim.add_{self.set_item_name}", icon="ADD", text="")
        setattr(op, f"{self.set_item_name}_set", self.material_set_id)
@@ -388,7 +401,21 @@ class BIM_UL_materials(UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
        if item:
            row = layout.row(align=True)
-            row.label(text=item.name)
-            row2 = row.row()
-            row2.alignment = "RIGHT"
-            row2.label(text=str(item.total_elements))
+
+            if item.is_category:
+                if item.is_expanded:
+                    row.operator(
+                        "bim.contract_material_category", text="", emboss=False, icon="DISCLOSURE_TRI_DOWN"
+                    ).category = item.name
+                else:
+                    row.operator(
+                        "bim.expand_material_category", text="", emboss=False, icon="DISCLOSURE_TRI_RIGHT"
+                    ).category = item.name
+                row.label(text=item.name or "Uncategorised")
+            else:
+                row.label(text="", icon="BLANK1")
+                row.label(text=item.name, icon="MATERIAL")
+
+                row2 = row.row()
+                row2.alignment = "RIGHT"
+                row2.label(text=str(item.total_elements))
@@ -17,11 +17,12 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import bpy
-from . import handler, prop, ui, grid, product, wall, slab, stair, opening, pie, workspace
+from . import handler, prop, ui, grid, product, wall, slab, stair, opening, pie, workspace, profile

 classes = (
    product.AddEmptyType,
-    product.AddTypeInstance,
+    product.AddConstrTypeInstance,
+    product.DisplayConstrTypes,
    product.AlignProduct,
    product.DynamicallyVoidProduct,
    workspace.Hotkey,
@@ -29,11 +30,14 @@ classes = (
    wall.AlignWall,
    wall.FlipWall,
    wall.SplitWall,
+    wall.WallPrototypeVTX,
    opening.AddElementOpening,
    profile.ExtendProfile,
    prop.BIMModelProperties,
+    prop.ConstrTypeInfo,
    ui.BIM_PT_authoring,
-    ui.BIM_PT_authoring_architectural,
+    ui.DisplayConstrTypesUI,
+    ui.HelpConstrTypes,
    grid.BIM_OT_add_object,
    stair.BIM_OT_add_object,
    opening.BIM_OT_add_object,
@@ -51,6 +55,7 @@ def register():
    if not bpy.app.background:
        bpy.utils.register_tool(workspace.BimTool, after={"builtin.scale_cage"}, separator=True, group=True)
    bpy.types.Scene.BIMModelProperties = bpy.props.PointerProperty(type=prop.BIMModelProperties)
+    bpy.types.Scene.ConstrTypeInfo = bpy.props.CollectionProperty(type=prop.ConstrTypeInfo)
    bpy.types.VIEW3D_MT_mesh_add.append(grid.add_object_button)
    bpy.types.VIEW3D_MT_mesh_add.append(stair.add_object_button)
    bpy.types.VIEW3D_MT_mesh_add.append(opening.add_object_button)
@@ -68,6 +73,7 @@ def unregister():
    if not bpy.app.background:
        bpy.utils.unregister_tool(workspace.BimTool)
    del bpy.types.Scene.BIMModelProperties
+    del bpy.types.Scene.ConstrTypeInfo
    bpy.app.handlers.load_post.remove(handler.load_post)
    bpy.types.VIEW3D_MT_mesh_add.remove(grid.add_object_button)
    bpy.types.VIEW3D_MT_mesh_add.remove(stair.add_object_button)
@@ -16,8 +16,14 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

+import functools
 import bpy
 import blenderbim.tool as tool
+from blenderbim.bim.ifc import IfcStore
+
+
+preview_icon_ids = {}
+attempts = 0


 def refresh():
@@ -31,10 +37,29 @@ class AuthoringData:
    @classmethod
    def load(cls):
        cls.is_loaded = True
-        cls.data = {
-            "ifc_classes": cls.ifc_classes(),
-            "relating_types": cls.relating_types(),
-        }
+        if not hasattr(cls, "data"):
+            cls.data = {}
+        cls.props = bpy.context.scene.BIMModelProperties
+        cls.load_ifc_classes()
+        cls.load_relating_types()
+        cls.load_relating_types_browser()
+        cls.load_preview_constr_types()
+
+    @classmethod
+    def load_ifc_classes(cls):
+        cls.data["ifc_classes"] = cls.ifc_classes()
+
+    @classmethod
+    def load_relating_types(cls):
+        cls.data["relating_types_ids"] = cls.relating_types()
+
+    @classmethod
+    def load_relating_types_browser(cls):
+        cls.data["relating_types_ids_browser"] = cls.relating_types_browser()
+
+    @classmethod
+    def load_preview_constr_types(cls):
+        cls.data["preview_constr_types"] = preview_icon_ids

    @classmethod
    def ifc_classes(cls):
@@ -49,16 +74,135 @@ class AuthoringData:
        return results

    @classmethod
-    def relating_types(cls):
-        ifc_classes = cls.ifc_classes()
+    def constr_class_entities(cls, ifc_class=None):
+        ifc_classes = cls.data["ifc_classes"]
        if not ifc_classes:
            return []
        results = []
-        ifc_class = bpy.context.scene.BIMModelProperties.ifc_class
+        if ifc_class is None:
+            ifc_class = cls.props.ifc_class
        if not ifc_class and ifc_classes:
            ifc_class = ifc_classes[0][0]
        if ifc_class:
-            elements = [(str(e.id()), e.Name, "") for e in tool.Ifc.get().by_type(ifc_class)]
-            results.extend(sorted(elements, key=lambda s: s[1]))
+            elements = sorted(tool.Ifc.get().by_type(ifc_class), key=lambda s: s.Name)
+            results.extend(elements)
            return results
        return []
+
+    @classmethod
+    def relating_types(cls, ifc_class=None):
+        return [(str(e.id()), e.Name, e.Description or "") for e in cls.constr_class_entities(ifc_class=ifc_class)]
+
+    @classmethod
+    def relating_types_browser(cls):
+        return cls.relating_types(ifc_class=cls.props.ifc_class_browser)
+
+    @staticmethod
+    def new_relating_type_info(ifc_class):
+        relating_type_info = bpy.context.scene.ConstrTypeInfo.add()
+        relating_type_info.name = ifc_class
+        return relating_type_info
+
+    @classmethod
+    def assetize_constr_class(cls, ifc_class=None):
+        selected_ifc_class = cls.props.ifc_class
+        selected_relating_type_id = cls.props.relating_type_id
+        if ifc_class is None:
+            ifc_class = cls.props.ifc_class_browser
+        relating_type_info = cls.relating_type_info(ifc_class)
+        _ = cls.new_relating_type_info(ifc_class) if relating_type_info is None else relating_type_info
+        constr_class_occurrences = cls.constr_class_entities(ifc_class)
+        preview_constr_types = cls.data["preview_constr_types"]
+        for constr_class_entity in constr_class_occurrences:
+
+            ### handle asset regeneration when library entity is updated ¿?
+            if (
+                ifc_class not in preview_constr_types
+                or str(constr_class_entity.id()) not in preview_constr_types[ifc_class]
+            ):
+                obj = tool.Ifc.get_object(constr_class_entity)
+                cls.assetize_object(obj, ifc_class, constr_class_entity)
+        relating_type_info = cls.relating_type_info(ifc_class)
+        relating_type_info.fully_loaded = True
+        cls.props.updating = True
+        cls.props.ifc_class = selected_ifc_class
+        cls.props.relating_type_id = selected_relating_type_id
+        cls.props.updating = False
+
+    @classmethod
+    def assetize_object(cls, obj, ifc_class, ifc_class_entity, from_selection=False):
+        relating_type_id = ifc_class_entity.id()
+        to_be_deleted = False
+        if obj.type == "EMPTY":
+            kwargs = {}
+            if not from_selection:
+                kwargs.update({"ifc_class": ifc_class, "relating_type_id": relating_type_id})
+            new_obj = cls.new_relating_type(**kwargs)
+            if new_obj is not None:
+                to_be_deleted = True
+                obj = new_obj
+        obj.asset_mark()
+        obj.asset_generate_preview()
+        icon_id = obj.preview.icon_id
+        if ifc_class not in cls.data["preview_constr_types"]:
+            cls.data["preview_constr_types"][ifc_class] = {}
+        cls.data["preview_constr_types"][ifc_class][str(relating_type_id)] = {"icon_id": icon_id, "object": obj}
+        if to_be_deleted:
+            element = tool.Ifc.get_entity(obj)
+            if element:
+                tool.Ifc.delete(element)
+            tool.Ifc.unlink(obj=obj)
+            # We do not delete the object from the scene, as that breaks Blender's asset system.
+            # Instead, we only "hide" it by unlinking it from all collections.
+            for collection in obj.users_collection:
+                collection.objects.unlink(obj)
+
+    @classmethod
+    def assetize_relating_type_from_selection(cls, browser=False):
+        ifc_class = cls.props.ifc_class_browser if browser else cls.props.ifc_class
+        relating_type_id = cls.props.relating_type_id_browser if browser else cls.props.relating_type_id
+        constr_class_occurrences = cls.constr_class_entities(ifc_class=ifc_class)
+        constr_class_occurrences = [
+            entity for entity in constr_class_occurrences if entity.id() == int(relating_type_id)
+        ]
+        if len(constr_class_occurrences) == 0:
+            return False
+        constr_class_entity = constr_class_occurrences[0]
+        obj = tool.Ifc.get_object(constr_class_entity)
+        if obj is None:
+            return False
+        cls.assetize_object(obj, ifc_class, constr_class_entity, from_selection=True)
+        return True
+
+    @staticmethod
+    def relating_type_info(ifc_class):
+        relating_type_infos = [element for element in bpy.context.scene.ConstrTypeInfo if element.name == ifc_class]
+        return None if len(relating_type_infos) == 0 else relating_type_infos[0]
+
+    @classmethod
+    def new_relating_type(cls, ifc_class=None, relating_type_id=None):
+        if ifc_class is None:
+            bpy.ops.bim.add_constr_type_instance(
+                ifc_class=cls.props.ifc_class, relating_type_id=int(cls.props.relating_type_id)
+            )
+        else:
+            cls.props.updating = True
+            cls.props.ifc_class = ifc_class
+            cls.props.relating_type_id = str(relating_type_id)
+            cls.props.updating = False
+            bpy.ops.bim.add_constr_type_instance()
+        return bpy.context.selected_objects[-1]
+
+    @staticmethod
+    def relating_type_name_by_id(ifc_class, relating_type_id):
+        file = IfcStore.get_file()
+        try:
+            constr_class_entity = file.by_id(int(relating_type_id))
+        except (RuntimeError, ValueError):
+            return None
+        return constr_class_entity.Name if constr_class_entity.is_a() == ifc_class else None
+
+    @classmethod
+    def relating_type_id_by_name(cls, ifc_class, relating_type):
+        relating_types = [ct[0] for ct in cls.relating_types(ifc_class=ifc_class) if ct[1] == relating_type]
+        return None if len(relating_types) == 0 else relating_types[0]
@@ -27,6 +27,7 @@ from bpy.app.handlers import persistent
@persistent
 def load_post(*args):
    ifcopenshell.api.add_pre_listener("attribute.edit_attributes", "BlenderBIM.Root.SyncName", root.sync_name)
+    ifcopenshell.api.add_pre_listener("style.edit_presentation_style", "BlenderBIM.Root.SyncStyleName", root.sync_name)

    ifcopenshell.api.add_post_listener(
        "geometry.add_representation", "BlenderBIM.Product.GenerateBox", product.generate_box
--- a/Show More
+++ b/Show More