checkout v0.7.0 -- src/ifcgeom_schema_agnostic/IfcGeomRepresentation.cpp

Reinclude missing max_protrusions_
Merge remote-tracking branch 'origin/v0.7.0' into feature-clash2
2026-08-08 17:01:40 +00:00 · 2024-03-26 15:13:15 +01:00 · 2024-03-26 23:04:32 +11:00 · 2024-03-26 11:21:45 +01:00 · 2024-03-26 11:00:16 +01:00 · 2024-03-06 21:44:43 +01:00
921 changed files with 28784 additions and 43450 deletions
@@ -16,7 +16,7 @@ jobs:
    - run: echo ok go

  build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    needs: activate
    steps:
    - uses: actions/checkout@v2
@@ -80,7 +80,7 @@ jobs:
        path: build/assets/Ifc*

  deliver:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    needs: build
    name: Docker Build, Tag, Push

@@ -39,7 +39,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        pyver: [py39, py310, py311, py312]
+        pyver: [py39, py310, py311]
        config:
          - {
            name: "Windows Build",
@@ -1,48 +0,0 @@
-name: ci-bsdd-pypi
-
-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: "0 0 18 * *"
-  workflow_dispatch:
-
-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
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
-        with:
-          python-version: '3.11' # Version range or exact version of a Python version to use, using SemVer's version range syntax
-      - name: Compile
-        run: |
-          pip install build
-          cd src/bsdd &&
-          make dist
-      - name: Publish a Python distribution to PyPI
-        uses: ortega2247/pypi-upload-action@master
-        with:
-          user: __token__
-          password: ${{ secrets.PYPI_API_TOKEN }}
-          packages_dir: src/bsdd/dist
@@ -1,48 +0,0 @@
-name: ci-ifcclash-pypi
-
-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: "0 0 18 * *"
-  workflow_dispatch:
-
-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
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
-        with:
-          python-version: '3.11' # Version range or exact version of a Python version to use, using SemVer's version range syntax
-      - name: Compile
-        run: |
-          pip install build
-          cd src/ifcclash &&
-          make dist
-      - name: Publish a Python distribution to PyPI
-        uses: ortega2247/pypi-upload-action@master
-        with:
-          user: __token__
-          password: ${{ secrets.PYPI_API_TOKEN }}
-          packages_dir: src/ifcclash/dist
@@ -1,48 +0,0 @@
-name: ci-ifccsv-pypi
-
-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: "0 0 18 * *"
-  workflow_dispatch:
-
-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
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
-        with:
-          python-version: '3.11' # Version range or exact version of a Python version to use, using SemVer's version range syntax
-      - name: Compile
-        run: |
-          pip install build
-          cd src/ifccsv &&
-          make dist
-      - name: Publish a Python distribution to PyPI
-        uses: ortega2247/pypi-upload-action@master
-        with:
-          user: __token__
-          password: ${{ secrets.PYPI_API_TOKEN }}
-          packages_dir: src/ifccsv/dist
@@ -1,7 +1,6 @@
 name: ci-ifcopenshell-pypi

 on:
-  workflow_dispatch:
  schedule:
    #         ┌───────────── minute (0 - 59)
    #         │  ┌───────────── hour (0 - 23)
@@ -36,7 +35,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        pyver: [py39, py310, py311, py312]
+        pyver: [py36, py37, py38, py39, py310, py311]
        config:
          - {
            name: "Windows Build",
@@ -58,7 +57,7 @@ jobs:
      - uses: actions/checkout@v2
      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
        with:
-          python-version: '3.11' # Version range or exact version of a Python version to use, using SemVer's version range syntax
+          python-version: '3.10' # 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
@@ -1,48 +0,0 @@
-name: ci-ifcpatch-pypi
-
-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: "0 0 18 * *"
-  workflow_dispatch:
-
-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
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
-        with:
-          python-version: '3.11' # Version range or exact version of a Python version to use, using SemVer's version range syntax
-      - name: Compile
-        run: |
-          pip install build
-          cd src/ifcpatch &&
-          make dist
-      - name: Publish a Python distribution to PyPI
-        uses: ortega2247/pypi-upload-action@master
-        with:
-          user: __token__
-          password: ${{ secrets.PYPI_API_TOKEN }}
-          packages_dir: src/ifcpatch/dist
@@ -1,53 +0,0 @@
-name: Publish-ifcsverchok
-
-on:
-  push:
-    paths:
-      - '.github/workflows/ci-ifcsverchok-build.yml'
-      - 'src/ifcsverchok/*'
-    branches:
-      - v0.7.0
-
-env:
-  major: 0
-  minor: 0
-  name: ifcsverchok
-
-jobs:
-  activate:
-    runs-on: ubuntu-latest
-    if: |
-      github.repository == 'IfcOpenShell/IfcOpenShell'
-    steps:
-    - name: Set env
-      run: echo ok go
-
-  build:
-    needs: activate
-    name: ifcsverchok
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
-        with:
-          architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
-          python-version: '3.11'
-      - run: echo ${{ env.DATE }}
-      - name: Get current date
-        id: date
-        run: echo "::set-output name=date::$(date +'%y%m%d')"
-      - name: Compile
-        run: |
-          cd src/ifcsverchok
-          make dist
-      - name: Upload Zip file to release
-        uses: svenstaro/upload-release-action@v2
-        with:
-          repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: src/ifcsverchok/dist/ifcsverchok-${{steps.date.outputs.date}}.zip
-          asset_name: ifcsverchok-${{steps.date.outputs.date}}.zip
-          tag: "ifcsverchok-${{steps.date.outputs.date}}"
-          overwrite: true
-          body: "ifcsverchok build for ${{steps.date.outputs.date}}"
@@ -9,6 +9,9 @@ on:
    #         │  │ │ │ ┌───────────── day of the week (0 - 6 or SUN-SAT)
    #         *  * * * *
    - cron: "0 0 18 * *"
+  push:
+    paths:
+      - '.github/workflows/ci-ifctester-pypi.yml'
  workflow_dispatch:

 env:
@@ -27,6 +30,7 @@ jobs:

  build:
    needs: activate
+    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
@@ -34,7 +38,12 @@ jobs:
      - uses: actions/checkout@v2
      - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
        with:
-          python-version: '3.11' # Version range or exact version of a Python version to use, using SemVer's version range syntax
+          python-version: '3.10' # 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
@@ -46,7 +46,7 @@ jobs:
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
-          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil shapely
+          pip install xmlschema xsdata numpy lxml pytest isodate lark networkx tabulate python-dateutil
          pip install src/bcf --no-deps
          pip install https://github.com/Andrej730/aud/archive/refs/heads/master-reduced-size.zip

@@ -90,7 +90,7 @@ jobs:
               -DPYTHON_INCLUDE_DIR:PATH=${{ env.pythonLocation }}/include/python3.11 \
               -DPYTHON_LIBRARY:FILEPATH=${{ env.pythonLocation }}/lib/libpython3.11.so \
               -DCOLLADA_SUPPORT=Off \
-               "-DSCHEMA_VERSIONS=2x3;4;4x3;4x3_add1;4x3_add2" \
+               "-DSCHEMA_VERSIONS=2x3;4;4x3_add1" \
               -DGLTF_SUPPORT=On \
               -DJSON_INCLUDE_DIR=/usr/include \
               -DCGAL_INCLUDE_DIR=/usr/include \
@@ -18,14 +18,14 @@ and many other libraries, CLI apps, and more. Support is also provided for auxil
 For more information, see:

 * [IfcOpenShell Website](http://ifcopenshell.org)
-* [IfcOpenShell Documentation](https://docs.ifcopenshell.org)
-  * [IfcOpenShell C++ Installation](https://docs.ifcopenshell.org/ifcopenshell/installation.html)
-  * [IfcOpenShell Python Installation](https://docs.ifcopenshell.org/ifcopenshell-python/installation.html)
-  * [IfcOpenShell Python Hello World Tutorial](https://docs.ifcopenshell.org/ifcopenshell-python/hello_world.html)
+* [IfcOpenShell Documentation](http://blenderbim.org/docs-python)
+  * [IfcOpenShell C++ Installation](https://blenderbim.org/docs-python/ifcopenshell/installation.html)
+  * [IfcOpenShell Python Installation](https://blenderbim.org/docs-python/ifcopenshell-python/installation.html)
+  * [IfcOpenShell Python Hello World Tutorial](https://blenderbim.org/docs-python/ifcopenshell-python/hello_world.html)
 * [BlenderBIM Add-on Website](https://blenderbim.org)
-* [BlenderBIM Add-on Documentation](https://docs.blenderbim.org/index.html)
-  * [Add-on Installation](https://docs.blenderbim.org/users/installation.html)
-  * [Exploring an IFC model](https://docs.blenderbim.org/users/exploring_an_ifc_model.html)
+* [BlenderBIM Add-on Documentation](http://blenderbim.org/docs)
+  * [Add-on Installation](https://blenderbim.org/docs/users/installation.html)
+  * [Exploring an IFC model](https://blenderbim.org/docs/users/exploring_an_ifc_model.html)

 | Service                                         | Status                                                                                                                                       |
 | ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -12,7 +12,7 @@ RUN apt-get -y update && apt-get -y install unzip curl
 # Install AWS Lambda runtime interface client
 RUN pip install --target ${FUNCTION_DIR} awslambdaric

-# Set the IfcOpenShell build version (check available builds at: https://docs.ifcopenshell.org/ifcopenshell-python/installation.html)
+# Set the IfcOpenShell build version (check available builds at: https://blenderbim.org/docs-python/ifcopenshell-python/installation.html)
 ARG IFC_OPENSHELL_BUILD="39-v0.7.0-476ab50"

 # Download and extract IfcOpenShell
@@ -15,7 +15,7 @@
    <licenseUrl>https://github.com/IfcOpenShell/IfcOpenShell/blob/v0.7.0/COPYING</licenseUrl>
    <requireLicenseAcceptance>true</requireLicenseAcceptance>
    <projectSourceUrl>https://github.com/IfcOpenShell/IfcOpenShell</projectSourceUrl>
-    <docsUrl>https://docs.blenderbim.org/</docsUrl>
+    <docsUrl>https://blenderbim.org/docs/</docsUrl>
    <!--<mailingListUrl></mailingListUrl>-->
    <bugTrackerUrl>https://github.com/IfcOpenShell/IfcOpenShell/issues</bugTrackerUrl>
    <tags>blender bim blenderbim ifc python opensource foss</tags>
@@ -36,9 +36,7 @@ if(NOT CMAKE_BUILD_TYPE)
 endif()

 # use extra version to make pre-release using eg semver
-if(NOT DEFINED EXTRA_VERSION)
-    set(EXTRA_VERSION "-alpha.3")
-endif()
+set(EXTRA_VERSION "-alpha.3")

 option(MINIMAL_BUILD "The build is to make a minimal version of IFC converter from OCCT into IFC." OFF)
 option(WASM_BUILD "Build a WebAssembly binary." OFF)
@@ -1149,10 +1147,9 @@ endif()

 # Packaging
 list(APPEND CPACK_SOURCE_IGNORE_FILES
-    "/\\\\.git"
-    "/build/"
+    .git
+    .gitignore
 )
-set(CPACK_SOURCE_INSTALLED_DIRECTORIES "${CMAKE_SOURCE_DIR}/..;/")
 set(CPACK_PACKAGE_NAME "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}")
 set(CPACK_SOURCE_PACKAGE_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION}${EXTRA_VERSION}")
 SET(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}${EXTRA_VERSION}-${CMAKE_SYSTEM_NAME}")
@@ -13,7 +13,7 @@ readme = "README.md"
 requires-python = ">=3.8"
 keywords = ["IFC", "BCF", "BIM"]
 dependencies = [
-    "xsdata>=24.4",
+    "xsdata",
    "numpy",
    "ifcopenshell",
 ]
@@ -10,14 +10,14 @@ from xsdata.formats.dataclass.serializers.config import SerializerConfig
 def build_xml_parser(context: Optional[XmlContext] = None) -> XmlParser:
    """Return a parser for an XML file."""
    parser = XmlParser(context=context or XmlContext())
-    parser.register_namespace(ns_map=parser.ns_map, prefix="xs", uri="http://www.w3.org/2001/XMLSchema")
+    parser.register_namespace("xs", "http://www.w3.org/2001/XMLSchema")
    return parser


 def build_serializer(context: Optional[XmlContext] = None) -> XmlSerializer:
    """Return a serializer for an XML file."""
    return XmlSerializer(
-        config=SerializerConfig(indent="  "),
+        config=SerializerConfig(pretty_print=True),
        context=context or XmlContext(),
    )

@@ -36,9 +36,8 @@ class AbstractXmlParserSerializer(Protocol):
            xml: The XML file as bytes.
            clazz: The class to parse to.
        """
-        ...

-    def serialize(self, obj: object, ns_map: Optional[dict[str, str]] = None) -> str:
+    def serialize(self, obj: T, ns_map: Optional[dict[str, str]] = None) -> str:
        """
        Serialize an object to XML.

@@ -49,7 +48,6 @@ class AbstractXmlParserSerializer(Protocol):
        Returns:
            The XML as string.
        """
-        ...


 class XmlParserSerializer:
@@ -70,7 +68,7 @@ class XmlParserSerializer:
        """
        return self.parser.from_bytes(xml, clazz)

-    def serialize(self, obj: object, ns_map: Optional[dict[Optional[str], str]] = None) -> str:
+    def serialize(self, obj: T, ns_map: Optional[dict[str, str]] = None) -> str:
        """
        Serialize an object to XML.

@@ -81,5 +79,5 @@ class XmlParserSerializer:
        Returns:
            The XML as string.
        """
-        ns_map = ns_map or self.parser.ns_map or {"xs": "http://www.w3.org/2001/XMLSchema"}
+        ns_map = ns_map or {"xs": "http://www.w3.org/2001/XMLSchema"}
        return self.serializer.render(obj, ns_map)
@@ -55,28 +55,70 @@ PYLIBDIR:=python3.11
 PYNUMBER:=311
 PYPI_VERSION:=3.11
 endif
-ifeq ($(PYVERSION), py312)
-PYLIBDIR:=python3.12
-PYNUMBER:=312
-PYPI_VERSION:=3.12
-endif

 ifeq ($(PLATFORM), linux)
 PYPI_PLATFORM:=--platform manylinux_2_17_x86_64
+LXML_ARCH:=manylinux_2_28_x86_64
+SHAPELY_ARCH:=manylinux_2_17_x86_64.manylinux2014_x86_64
+PILLOW_ARCH:=manylinux_2_28_x86_64
 endif

 ifeq ($(PLATFORM), macos)
-PYPI_PLATFORM:=--platform macosx_10_10_x86_64
+PYPI_PLATFORM:=--platform macosx_10_9_x86_64
+SHAPELY_ARCH:=macosx_10_9_x86_64
+PILLOW_ARCH:=macosx_10_10_x86_64
+ifeq ($(PYVERSION), py39)
+LXML_ARCH:=macosx_11_0_x86_64
+endif
+ifeq ($(PYVERSION), py310)
+LXML_ARCH:=macosx_11_0_x86_64
+endif
+ifeq ($(PYVERSION), py311)
+LXML_ARCH:=macosx_11_0_universal2
+endif
 endif

 ifeq ($(PLATFORM), macosm1)
 PYPI_PLATFORM:=--platform macosx_11_0_arm64
+LXML_ARCH:=macosx_11_0_universal2
+SHAPELY_ARCH:=macosx_11_0_arm64
+PILLOW_ARCH:=macosx_11_0_arm64
 endif

 ifeq ($(PLATFORM), win)
 PYPI_PLATFORM:=--platform win_amd64
+LXML_ARCH:=win_amd64
+SHAPELY_ARCH:=win_amd64
+PILLOW_ARCH:=win_amd64
 endif

+LXML_NAME:=lxml
+LXML_VER:=4.9.4
+SHAPELY_NAME:=shapely
+SHAPELY_VER:=2.0.2
+PILLOW_NAME:=pillow
+PILLOW_PKG_NAME:=Pillow
+PILLOW_VER:=9.5.0
+SHAPELY_URL:=https://files.pythonhosted.org/packages/cp$(PYNUMBER)/s/$(SHAPELY_NAME)/$(SHAPELY_NAME)-$(SHAPELY_VER)-cp$(PYNUMBER)-cp$(PYNUMBER)-$(SHAPELY_ARCH).whl
+PILLOW_URL:=https://files.pythonhosted.org/packages/cp$(PYNUMBER)/p/$(PILLOW_NAME)/$(PILLOW_PKG_NAME)-$(PILLOW_VER)-cp$(PYNUMBER)-cp$(PYNUMBER)-$(PILLOW_ARCH).whl
+
+ifeq ($(PLATFORM), macosm1)
+ifeq ($(PYVERSION), py39)
+LXML_URL:=https://anaconda.org/conda-forge/lxml/4.9.1/download/osx-arm64/lxml-4.9.1-py39h0520ce3_1.tar.bz2
+endif
+ifeq ($(PYVERSION), py310)
+LXML_URL:=https://anaconda.org/conda-forge/lxml/4.9.1/download/osx-arm64/lxml-4.9.1-py310h02f21da_0.tar.bz2
+endif
+ifeq ($(PYVERSION), py311)
+LXML_URL:=https://anaconda.org/conda-forge/lxml/4.9.1/download/osx-arm64/lxml-4.9.1-py311h246f609_1.tar.bz2
+endif
+else
+LXML_URL:=https://files.pythonhosted.org/packages/cp$(PYNUMBER)/l/$(LXML_NAME)/$(LXML_NAME)-$(LXML_VER)-cp$(PYNUMBER)-cp$(PYNUMBER)-$(LXML_ARCH).whl
+endif
+$(info $$LXML_URL is [${LXML_URL}])
+$(info $$SHAPELY_URL is [${SHAPELY_URL}])
+$(info $$PILLOW_URL is [${PILLOW_URL}])
+
 .PHONY: bump
 bump:
 	cd . && $(SED) "s/$(OLD)/$(NEW)/" Makefile
@@ -95,7 +137,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-c7830e9-$(PLATFORM)64.zip
+	cd dist/working && wget https://s3.amazonaws.com/ifcopenshell-builds/ifcopenshell-python-$(PYNUMBER)-v0.7.0-e38eafd-$(PLATFORM)64.zip
 	cd dist/working && unzip ifcopenshell-python*
 	cp -r dist/working/ifcopenshell dist/blenderbim/libs/site/packages/

@@ -109,10 +151,8 @@ endif
 	cd dist/working && wget https://github.com/IfcOpenShell/IfcOpenShell/archive/v0.7.0.zip
 	cd dist/working && unzip v0.7.0.zip
 	# IfcOpenBot sometimes lags behind, so we hotfix the Python utilities
-	rm -rf dist/blenderbim/libs/site/packages/ifcopenshell/util/
-	rm -rf dist/blenderbim/libs/site/packages/ifcopenshell/api/
-	cp -r dist/working/IfcOpenShell-0.7.0/src/ifcopenshell-python/ifcopenshell/util dist/blenderbim/libs/site/packages/ifcopenshell/
-	cp -r dist/working/IfcOpenShell-0.7.0/src/ifcopenshell-python/ifcopenshell/api dist/blenderbim/libs/site/packages/ifcopenshell/
+	cp -r dist/working/IfcOpenShell-0.7.0/src/ifcopenshell-python/ifcopenshell/util/* dist/blenderbim/libs/site/packages/ifcopenshell/util/
+	cp -r dist/working/IfcOpenShell-0.7.0/src/ifcopenshell-python/ifcopenshell/api/* dist/blenderbim/libs/site/packages/ifcopenshell/api/
 	cp dist/working/IfcOpenShell-0.7.0/src/ifcopenshell-python/ifcopenshell/*.py dist/blenderbim/libs/site/packages/ifcopenshell/
 	cp dist/working/IfcOpenShell-0.7.0/src/ifcopenshell-python/ifcopenshell/express/rule_executor.py dist/blenderbim/libs/site/packages/ifcopenshell/express/
 	# Provides bcf functionality
@@ -150,6 +190,49 @@ endif
 	cp -r dist/working/site-packages/git dist/blenderbim/libs/site/packages/
 	rm -rf dist/working

+	# Provides Mustache templating in construction documentation
+	# TODO: remove this dependency, it seems overkill and we seem to get by with str replaces
+	mkdir dist/working
+	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.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
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/79/e8/7eb2ba188eda14a4b47e33b51f3b4978985f4116655c699bcd18c79279b5/svgwrite-1.3.1.zip
+	cd dist/working && unzip svgwrite*
+	cp -r dist/working/svgwrite-1.3.1/svgwrite dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Provides fuzzy date parsing for construction sequencing
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/be/ed/5bbc91f03fa4c839c4c7360375da77f9659af5f7086b7a7bdda65771c8e0/python-dateutil-2.8.1.tar.gz
+	cd dist/working && tar -xzvf python-dateutil*
+	cp -r dist/working/python-dateutil-2.8.1/dateutil dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Provides duration parsing for construction sequencing
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/b1/80/fb8c13a4cd38eb5021dc3741a9e588e4d1de88d895c1910c6fc8a08b7a70/isodate-0.6.0.tar.gz
+	cd dist/working && tar -xzvf isodate*
+	cp -r dist/working/isodate-0.6.0/src/isodate dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Provides networkx graph analysis for project dependency calculations
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/b0/21/adfbf6168631e28577e4af9eb9f26d75fe72b2bb1d33762a5f2c425e6c2a/networkx-2.5.1.tar.gz
+	cd dist/working && tar -xzvf networkx*
+	cp -r dist/working/networkx-2.5.1/networkx dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Required by networkx
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/4f/51/15a4f6b8154d292e130e5e566c730d8ec6c9802563d58760666f1818ba58/decorator-5.0.9.tar.gz
+	cd dist/working && tar -xzvf decorator*
+	cp -r dist/working/decorator-5.0.9/src/decorator.py dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
 	# Provides audio playback for costing
 	mkdir -p dist/working
 	git clone https://github.com/Andrej730/aud.git --branch master-reduced-size --depth 1 dist/working/aud
@@ -164,6 +247,107 @@ endif
 	cp dist/working/jsgantt* dist/blenderbim/bim/data/gantt/
 	rm -rf dist/working

+	# Required by IFCDiff
+	mkdir dist/working
+	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
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/00/55/ce2cbc6d64034b30cad81a29ba61bdba456f190f5e83c09831304bf68d6b/jsonpickle-1.2.tar.gz
+	cd dist/working && tar -xzvf jsonpickle*
+	cp -r dist/working/jsonpickle-1.2/jsonpickle dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Required by deepdiff
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/a3/b7/d4d69641cbe707a45c23b190f2d717466ba5accc4c70b5f7a8a450387895/ordered-set-3.1.1.tar.gz
+	cd dist/working && tar -xzvf ordered-set*
+	cp -r dist/working/ordered-set-3.1.1/ordered_set.py dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Required by lark
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/00/32/8076fa13e832bb4dcff379f18f228e5a53412be0631808b9ca2610c0f566/pyparsing-2.4.5.tar.gz
+	cd dist/working && tar -xzvf pyparsing*
+	cp -r dist/working/pyparsing-2.4.5/pyparsing.py dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Required by bcf
+	mkdir dist/working
+	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-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/ad/c7/17c9d16320d8e2cfdb27d2fd298b5e8f7a3f211025b0c1bc7a39a85bd690/xsdata-22.11.tar.gz
+	cd dist/working && tar -xzvf xsdata*
+	cp -r dist/working/xsdata-22.11/xsdata dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Required by bcf
+	mkdir dist/working
+	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-3.0.2/elementpath dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Required by bcf
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/21/9f/b251f7f8a76dec1d6651be194dfba8fb8d7781d10ab3987190de8391d08e/six-1.14.0.tar.gz
+	cd dist/working && tar -xzvf six*
+	cp -r dist/working/six-1.14.0/six.py dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Required by IFCCSV and ifcopenshell.util.selector
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/18/4d/8d522136c37d9e1ea74062b41b8d5e1318ebf45063ae46ce72ed60af223b/lark-parser-0.8.5.tar.gz
+	cd dist/working && tar -xzvf lark-parser*
+	cp -r dist/working/lark-parser-0.8.5/lark dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Required by IFC4D
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/b0/bb/9c4dddd3ca173cb56241cfb2eddfae24690dc676d357ac4cab17d0a36d9d/PyP6Xer-1.13.0.tar.gz
+	cd dist/working && tar -xzvf PyP6Xer*
+	cp -r dist/working/PyP6Xer-1.13.0/xerparser dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
+	# Required by QTOCalculator
+	mkdir dist/working
+	cd dist/working && wget $(SHAPELY_URL)
+	cd dist/working && cp *.whl shapely.zip && unzip shapely.zip
+	cp -r dist/working/shapely dist/blenderbim/libs/site/packages/
+ifeq ($(PLATFORM), win)
+	cp -r dist/working/shapely.libs dist/blenderbim/libs/site/packages/
+endif
+ifeq ($(PLATFORM), linux)
+	cp -r dist/working/shapely.libs dist/blenderbim/libs/site/packages/
+endif
+	rm -rf dist/working
+
+	# Required by the BIM tool thumbnail generator
+	mkdir dist/working
+	cd dist/working && wget $(PILLOW_URL)
+	cd dist/working && cp *.whl pillow.zip && unzip pillow.zip
+	cp -r dist/working/PIL dist/blenderbim/libs/site/packages/
+ifeq ($(PLATFORM), linux)
+	cp -r dist/working/Pillow.libs dist/blenderbim/libs/site/packages/
+endif
+	rm -rf dist/working
+
+	# Required by xerparser and IFC4D
+	# TODO: remove this dependency. It's only used to show a progress bar.
+	mkdir dist/working
+	cd dist/working && wget https://files.pythonhosted.org/packages/9f/7b/76c4e5ef1a1b528fcaada4133f972e77d33c252831676cf414119ca6093d/tqdm-4.50.0.tar.gz
+	cd dist/working && tar -xzvf tqdm*
+	cp -r dist/working/tqdm-4.50.0/tqdm dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+
 	mkdir dist/working
 	cd dist/working && $(PYTHON) -m venv env
 	cd dist/working && mkdir site-packages
@@ -178,36 +362,7 @@ endif
 	# Provides express rule validation for ifcopenshell.validate
 	cd dist/working && . env/bin/activate && $(PIP) install pytest --target=./site-packages
 	# Provides Brickschema functionality
-	cd dist/working && . env/bin/activate && $(PIP) install "brickschema[persistence]==0.7.6a2" --target=./site-packages
-	# Required for SVG to DXF conversion
-	cd dist/working && . env/bin/activate && $(PIP) install ezdxf --target=./site-packages
-	# Required by bcf
-	cd dist/working && . env/bin/activate && $(PIP) install xsdata --target=./site-packages
-	cd dist/working && . env/bin/activate && $(PIP) install xmlschema --target=./site-packages
-	cd dist/working && . env/bin/activate && $(PIP) install elementpath --target=./site-packages
-	cd dist/working && . env/bin/activate && $(PIP) install six --target=./site-packages
-	# Required by drawing module
-	cd dist/working && . env/bin/activate && $(PIP) install lxml $(PYPI_PLATFORM) --python-version $(PYPI_VERSION) --implementation $(PYPI_IMP) --only-binary=:all: --target=./site-packages
-	# Required by qto and drawing module
-	cd dist/working && . env/bin/activate && $(PIP) install shapely $(PYPI_PLATFORM) --python-version $(PYPI_VERSION) --implementation $(PYPI_IMP) --only-binary=:all: --target=./site-packages
-	# Required by the BIM type manager thumbnail generator
-	cd dist/working && . env/bin/activate && $(PIP) install pillow $(PYPI_PLATFORM) --python-version $(PYPI_VERSION) --implementation $(PYPI_IMP) --only-binary=:all: --target=./site-packages
-	# Provides mustache templating in construction docs and web UI data
-	cd dist/working && . env/bin/activate && $(PIP) install pystache --target=./site-packages
-	# Provides SVG export in construction documentation
-	cd dist/working && . env/bin/activate && $(PIP) install svgwrite --target=./site-packages
-	# Provides fuzzy date parsing for construction sequencing
-	cd dist/working && . env/bin/activate && $(PIP) install python-dateutil --target=./site-packages
-	# Provides duration parsing for construction sequencing
-	cd dist/working && . env/bin/activate && $(PIP) install isodate --target=./site-packages
-	# Provides networkx graph analysis for project dependency calculations
-	cd dist/working && . env/bin/activate && $(PIP) install networkx --target=./site-packages
-	# Required by IFCDiff
-	cd dist/working && . env/bin/activate && $(PIP) install deepdiff --target=./site-packages
-	# Required by IFCCSV and ifcopenshell.util.selector
-	cd dist/working && . env/bin/activate && $(PIP) install lark --target=./site-packages
-	# Required by IFC4D
-	cd dist/working && . env/bin/activate && $(PIP) install PyP6Xer --target=./site-packages
+	cd dist/working && . env/bin/activate && $(PIP) install brickschema[persistence] --target=./site-packages
 	cp -r dist/working/site-packages/* dist/blenderbim/libs/site/packages/
 	rm -rf dist/working

@@ -226,6 +381,24 @@ endif
 	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
+ifeq ($(PLATFORM), macosm1)
+	# No wheels available for MacOS M1, but turns out this Anaconda build works
+	mkdir dist/working
+	cd dist/working && wget $(LXML_URL)
+	cd dist/working && tar -xf lxml*
+	cp -r dist/working/lib/$(PYLIBDIR)/site-packages/lxml dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+else
+	# Wheels are preferred for other OSes. A first attempt at using Anaconda
+	# builds for everything shows it breaks on windows. See #2422.
+	mkdir dist/working
+	cd dist/working && wget $(LXML_URL)
+	cd dist/working && cp *.whl lxml.zip && unzip lxml.zip
+	cp -r dist/working/lxml dist/blenderbim/libs/site/packages/
+	rm -rf dist/working
+endif
+
 	# Required by behave
 	mkdir dist/working
 	cd dist/working && wget https://files.pythonhosted.org/packages/f4/65/220bb4075fddb09d5b3ea2c1c1fa66c1c72be9361ec187aab50fa161e576/parse-1.15.0.tar.gz
@@ -257,7 +430,7 @@ endif
 	# Required by brickschema
 	# This is a bit of a dodgy one, it should be provided by setuptools which Blender doesn't ship.
 	mkdir dist/working
-	cd dist/working && wget https://github.com/IfcOpenShell/IfcOpenShell/raw/v0.7.0/src/blenderbim/scripts/pkg_resources.tar.gz
+	cd dist/working && wget https://blenderbim.org/builds/pkg_resources.tar.gz
 	cd dist/working && tar -xzvf pkg_resources*
 	cd dist/working/ && cp -r pkg_resources ../blenderbim/libs/site/packages/
 	rm -rf dist/working
@@ -18,21 +18,7 @@

 import os
 import sys
-
-# Ensure we don't try to import bpy or blenderbim.bim
-# to support running core tests.
-# We assume if bpy was never loaded in current python session
-# then we're not in Blender. It's still possible to use
-# bpy in core and core tests for annotations using TYPE_CHECKING.
-IN_BLENDER = sys.modules.get("bpy", None)
-if IN_BLENDER:
-    import bpy
-import platform
-import traceback
-import subprocess
-import webbrowser
-import addon_utils
-from collections import deque
+import site

 bl_info = {
    "name": "BlenderBIM",
@@ -41,168 +27,21 @@ bl_info = {
    "blender": (3, 1, 0),
    "version": (0, 0, 999999),
    "location": "File Menu, Scene Properties Tab. See documentation for more.",
-    "doc_url": "https://docs.blenderbim.org/",
+    "doc_url": "https://blenderbim.org/docs",
    "tracker_url": "https://github.com/IfcOpenShell/IfcOpenShell/issues",
    "category": "System",
 }

-last_error = None
-last_actions: deque = deque(maxlen=10)
-
-
-def get_debug_info():
-    version = ".".join(
-        [
-            str(x)
-            for x in [
-                addon.bl_info.get("version", (-1, -1, -1))
-                for addon in addon_utils.modules()
-                if addon.bl_info["name"] == "BlenderBIM"
-            ][0]
-        ]
-    )
-    return {
-        "os": platform.system(),
-        "os_version": platform.version(),
-        "python_version": platform.python_version(),
-        "architecture": platform.architecture(),
-        "machine": platform.machine(),
-        "processor": platform.processor(),
-        "blender_version": bpy.app.version_string,
-        "blenderbim_version": version,
-        "last_actions": last_actions,
-        "last_error": last_error,
-    }
-
-
-def format_debug_info(info: dict):
-    last_actions = ""
-    for action in info["last_actions"]:
-        last_actions += f"\n# {action['type']}: {action['name']}"
-        if settings := action.get("settings"):
-            last_actions += f"\n>>> {settings}"
-    info["last_actions"] = last_actions
-    text = "\n".join(f"{k}: {v}" for k, v in info.items())
-    return text.strip()
-
-
-if IN_BLENDER:
+if sys.modules.get("bpy", None):
    # Process *.pth in /libs/site/packages to setup globally importable modules
    # This is 3 levels deep as required by the static RPATH of ../../ from dependencies taken from Anaconda
    # site.addsitedir(os.path.join(os.path.dirname(os.path.realpath(__file__)), "libs", "site", "packages"))
    sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "libs", "site", "packages"))

-    try:
-        import blenderbim.bim
-        import ifcopenshell.api
+    import blenderbim.bim

-        def log_api(usecase_path, ifc_file, settings):
-            last_actions.append(
-                {
-                    "type": "ifcopenshell.api",
-                    "name": usecase_path,
-                    "settings": ifcopenshell.api.serialise_settings(settings),
-                }
-            )
+    def register():
+        blenderbim.bim.register()

-        ifcopenshell.api.add_pre_listener("*", "action_logger", log_api)
-
-        def register():
-            blenderbim.bim.register()
-
-        def unregister():
-            blenderbim.bim.unregister()
-
-    except:
-        last_error = traceback.format_exc()
-
-        print(last_error)
-        print(format_debug_info(get_debug_info()))
-        print("\nFATAL ERROR: Unable to load the BlenderBIM Add-on")
-
-        class BIM_PT_fatal_error(bpy.types.Panel):
-            bl_label = "BlenderBIM Fatal Error"
-            bl_idname = "SCENE_PT_error_message"
-            bl_space_type = "PROPERTIES"
-            bl_region_type = "WINDOW"
-            bl_context = "scene"
-
-            def draw(self, context):
-                info = get_debug_info()
-
-                layout = self.layout
-                layout.alert = True
-                layout.label(text="BlenderBIM could not load.", icon="ERROR")
-                if info["os"] == "Windows":
-                    layout.operator("wm.console_toggle", text="View the console for full logs.", icon="CONSOLE")
-                else:
-                    layout.label(text="View the console for full logs.", icon="CONSOLE")
-                box = layout.box()
-                py = ".".join(info["python_version"].split(".")[0:2])
-                b3d = ".".join(info["blender_version"].split(".")[0:2])
-                box.label(text=f"Blender {b3d} {info['os']} {info['machine']}", icon="BLENDER")
-                box.label(text=f"Python {py} BBIM {info['blenderbim_version']}", icon="SCRIPTPLUGINS")
-                layout.operator("bim.copy_debug_information", text="Copy Error Message To Clipboard")
-                op = layout.operator("bim.open_uri", text="How Can I Fix This?")
-                op.uri = "https://docs.blenderbim.org/users/troubleshooting.html#installation-issues"
-
-                layout.label(text="Try Reinstalling:", icon="IMPORT")
-                op = layout.operator("bim.open_uri", text="Re-download Add-on")
-                bbim_date = info["blenderbim_version"].split(".")[-1]
-                py_tag = py.replace(".", "")
-                if "Linux" in info["os"]:
-                    os = "linux"
-                elif "Darwin" in info["os"]:
-                    if "arm64" in info["machine"]:
-                        os = "macosm1"
-                    else:
-                        os = "macos"
-                else:
-                    os = "win"
-                op.uri = f"https://github.com/IfcOpenShell/IfcOpenShell/releases/download/blenderbim-{bbim_date}/blenderbim-{bbim_date}-py{py_tag}-{os}.zip"
-
-        class OpenUri(bpy.types.Operator):
-            bl_idname = "bim.open_uri"
-            bl_label = "Open URI"
-            uri: bpy.props.StringProperty()
-
-            def execute(self, context):
-                webbrowser.open(self.uri)
-                return {"FINISHED"}
-
-        class CopyDebugInformation(bpy.types.Operator):
-            bl_idname = "bim.copy_debug_information"
-            bl_label = "Copy Debug Information"
-            bl_description = "Copies debugging information to your clipboard for use in bugreports"
-
-            def execute(self, context):
-                info = format_debug_info(get_debug_info())
-                context.window_manager.clipboard = info
-                return {"FINISHED"}
-
-        class HiddenPanel:
-            @classmethod
-            def false_poll(cls, context):
-                return False
-
-        def register():
-            # Only show our error panel and nothing else in the scene tab
-            for item_name in dir(bpy.types):
-                item = getattr(bpy.types, item_name)
-                if not hasattr(item, "bl_rna") or not isinstance(item.bl_rna, bpy.types.Panel):
-                    continue
-                if getattr(item, "bl_context", None) != "scene":
-                    continue
-
-                # Reregister scene panel with a new poll to hide it
-                item.poll = HiddenPanel.false_poll
-                bpy.utils.unregister_class(item)
-                bpy.utils.register_class(item)
-            bpy.utils.register_class(BIM_PT_fatal_error)
-            bpy.utils.register_class(CopyDebugInformation)
-            bpy.utils.register_class(OpenUri)
-
-        def unregister():
-            bpy.utils.unregister_class(OpenUri)
-            bpy.utils.unregister_class(CopyDebugInformation)
-            bpy.utils.unregister_class(BIM_PT_fatal_error)
+    def unregister():
+        blenderbim.bim.unregister()
@@ -17,13 +17,12 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import os
+from pathlib import Path
 import bpy
 import bpy.utils.previews
 import blenderbim
 import importlib
-from pathlib import Path
 from . import handler, ui, prop, operator, helper
-from typing import Callable, Union

 try:
    from blenderbim.translations import translations_dict
@@ -97,13 +96,10 @@ for name in modules.keys():
 classes = [
    operator.AddIfcFile,
    operator.BIM_OT_add_section_plane,
-    operator.BIM_OT_delete_object,
    operator.BIM_OT_open_webbrowser,
    operator.BIM_OT_remove_section_plane,
-    operator.BIM_OT_select_object,
    operator.BIM_OT_show_description,
    operator.ClippingPlaneCutWithCappings,
-    operator.CloseError,
    operator.EditBlenderCollection,
    operator.FileAssociate,
    operator.FileUnassociate,
@@ -134,7 +130,6 @@ classes = [
    prop.BIMMeshProperties,
    prop.BIMFacet,
    prop.BIMFilterGroup,
-    ui.BIM_UL_clipping_plane,
    ui.BIM_UL_generic,
    ui.BIM_UL_topics,
    ui.BIM_ADDON_preferences,
@@ -142,7 +137,6 @@ classes = [
    ui.BIM_PT_tabs,
    # Project overview
    ui.BIM_PT_tab_project_info,
-    ui.BIM_PT_tab_spatial_decomposition,
    ui.BIM_PT_tab_project_setup,
    ui.BIM_PT_tab_geometry,
    ui.BIM_PT_tab_stakeholders,
@@ -155,10 +149,9 @@ classes = [
    ui.BIM_PT_tab_representations,
    ui.BIM_PT_tab_geometric_relationships,
    ui.BIM_PT_tab_parametric_geometry,
-    ui.BIM_PT_tab_object_materials,
+    ui.BIM_PT_tab_profiles,
    ui.BIM_PT_tab_materials,
    ui.BIM_PT_tab_styles,
-    ui.BIM_PT_tab_profiles,
    # Drawings and documents
    ui.BIM_PT_tab_sheets,
    ui.BIM_PT_tab_drawings,
@@ -171,7 +164,6 @@ classes = [
    ui.BIM_PT_tab_structural,
    # Construction scheduling
    ui.BIM_PT_tab_status,
-    ui.BIM_PT_tab_qto,
    ui.BIM_PT_tab_resources,
    ui.BIM_PT_tab_cost,
    ui.BIM_PT_tab_sequence,
@@ -195,7 +187,7 @@ addon_keymaps = []
 icons = None
 is_registering = False
 last_commit_hash = "8888888"
-original_scene_panels_polls: dict[bpy.types.Panel, Union[Callable, None]] = dict()
+overridden_scene_panels = dict()


 def on_register(scene):
@@ -303,10 +295,10 @@ def unregister():
            km.keymap_items.remove(kmi)
    addon_keymaps.clear()

-    import blenderbim.tool as tool
-
-    # use tuple() as method will be removing keys from dict
-    for panel in tuple(original_scene_panels_polls.keys()):
-        tool.Blender.remove_scene_panel_override(panel)
+    for panel in tuple(overridden_scene_panels.keys()):
+        original_panel, override_panel = overridden_scene_panels[panel]
+        bpy.utils.unregister_class(override_panel)
+        bpy.utils.register_class(original_panel)
+        del overridden_scene_panels[panel]

    bpy.app.translations.unregister("blenderbim")
@@ -1,45 +0,0 @@
-/*
- * 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/>.
- */
-
-/**
- * You may copy this `schedule.css` template alongside your input schedule
- * document with the same filename. For example if you have a schedule called
- * `door_types.ods`, you can create a `door_types.css` in the same folder to
- * style that schedule.
- */
-
-/**
- * If you specify a font size in CSS, such as text { font-size: 5; }, all fonts
- * will be overriden to match that size.
- *
- * If your CSS, ODS, XLSX does not specify a font size, the variables below
- * will specify the default font size.
- *
- * If your ODS, XLSX does specify a font size, they will scale linearly based
- * on the variables below.
- */
-
-:root {
-    --font-size-pt: 12;
-    --font-size-px: 4.13;
-    --font-width: 0.45;
-}
-
-text, tspan { /* 2.5mm */ fill: black; stroke: none; font-family: 'OpenGost Type B TT', 'DejaVu Sans Condensed', 'Liberation Sans', 'Arial Narrow', 'Arial'; }
@@ -5,7 +5,7 @@ FILE_NAME('EPset_Drawing.ifc','2020-01-01T00:00:00',(),(),'EPset_Drawing','EPset
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation/DRAWING',(#2,#3,#4,#5,#6,#7,#8,#9,#10,#11,#12,#13,#14,#15,#16,#17,#18,#19,#20,#21,#22,#23));
+#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation',(#2,#3,#4,#5,#6,#7,#8,#9,#10,#11,#12,#13,#14,#15,#16,#17,#18,#19,#20,#21,#22,#23));
 #2=IFCSIMPLEPROPERTYTEMPLATE('23JavTMk98ZxXhrUEnjAcf',$,'TargetView','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('1yVWUt5H9DAOuu0OaMMLpe',$,'Scale','The scale of this drawing represented as a numerator and denominator, such as 1/100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #4=IFCSIMPLEPROPERTYTEMPLATE('3gsuPBtU93b8f0gg1pjkq6',$,'HumanScale','The scale of this drawing in human readable format, such as 1:100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -5,7 +5,6 @@ FILE_NAME('EQto_BodyGeometryValidation.ifc','2020-01-01T00:00:00',(),(),'EQto_Bo
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-/* This quantity set is Qto_BodyGeometryValidation backport from IFC4X3 to support IFC4. */
 #1=IFCPROPERTYSETTEMPLATE('2KS9su6r517uLXTGKwwDdn',$,'EQto_BodyGeometryValidation','Quantities supplied for validating the correct interpretation of the body shape representation at import. In case of multiple representation items, the quantities are summed for each of the items (irrespective of any overlap). Choosing a suitable tolerance value for comparing the supplied numbers to the numbers calculated from the reconstructed geometry is at the discretion of the importing application.',.QTO_OCCURRENCEDRIVEN.,'IfcProduct',(#2,#3,#4,#5,#6,#7));
 #2=IFCSIMPLEPROPERTYTEMPLATE('3iCdOOLRjCwQ_HRTB41Xh8',$,'GrossSurfaceArea','Total gross area of the object, normally generated as perimeter * length + 2 * cross section area. It is the sum of OuterSurfaceArea + (2 x CrossSectionArea) and shall only be given, if the OuterSurfaceArea and CrossSectionArea cannot be established separately.\X2\000A000A\X0\Total gross surface area of the element before applying product-level geometric features such as openings and projections.',.Q_AREA.,$,$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('0juemEqF5889vg7HwR87Fv',$,'NetSurfaceArea','Net surface area of the object, normally generated as perimeter * length + 2 * cross section area taking into account possible processing features (cut-out''s, etc.) or openings and recesses.\X2\000A000A\X0\Total net surface area of the element after applying product-level geometric features such as openings and projections.',.Q_AREA.,$,$,$,$,$,$,.READWRITE.);
@@ -5,20 +5,20 @@ FILE_NAME('Psets_BBIM_Annotation.ifc','2020-01-01T00:00:00',(),(),'Psets_BBIM_An
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROPERTYSETTEMPLATE('3VuPUwdCD2Qx3XDDRs0R1N',$,'EPset_Annotation','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation,IfcTypeProduct',(#2,#3,#4));
+#1=IFCPROPERTYSETTEMPLATE('3VuPUwdCD2Qx3XDDRs0R1N',$,'EPset_Annotation','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#2,#3,#4));
 #2=IFCSIMPLEPROPERTYTEMPLATE('2P7JN79n96Q9pElZ83LKe4',$,'ZIndex','',.P_SINGLEVALUE.,'IfcInteger',$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('1Wpx_r2xj1_9w5JpI0QRJy',$,'Symbol','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #4=IFCSIMPLEPROPERTYTEMPLATE('3q0oxMUKP47vZ4jnyG$dDb',$,'Classes','Classes separarated by spaces that end up in classes for this element in svg. Can be used to specify the text font size: small - 1.8mm; regular - 2.5mm; large - 3.5mm; header - 5mm; title - 7mm. By default regular size is used.',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
-#5=IFCPROPERTYSETTEMPLATE('0iKwujnQL9IevVQato8f7Z',$,'BBIM_Batting','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation/BATTING,IfcTypeProduct',(#6,#7));
+#5=IFCPROPERTYSETTEMPLATE('0iKwujnQL9IevVQato8f7Z',$,'BBIM_Batting','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#6,#7));
 #6=IFCSIMPLEPROPERTYTEMPLATE('0t2LEesGT1QRQtrIZUAR8L',$,'Thickness','Batting thickness',.P_SINGLEVALUE.,'IfcPositiveLengthMeasure',$,$,$,$,$,.READWRITE.);
 #7=IFCSIMPLEPROPERTYTEMPLATE('082PndS6v2kBOiJoSboMnh',$,'Reverse pattern direction','Reverse batting pattern (swap starting and ending points)',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
-#8=IFCPROPERTYSETTEMPLATE('1Dx2EiZnP67xotInXpwz90',$,'BBIM_Section','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation/SECTION,IfcTypeProduct',(#9,#10,#11,#12,#13));
+#8=IFCPROPERTYSETTEMPLATE('1Dx2EiZnP67xotInXpwz90',$,'BBIM_Section','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#9,#10,#11,#12,#13));
 #9=IFCSIMPLEPROPERTYTEMPLATE('2a_9s8spHDc9dZHtgg71XL',$,'ShowStartArrow','Display start arrow.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 #10=IFCSIMPLEPROPERTYTEMPLATE('3i6SH_GbT7zhKea$wVE56A',$,'StartArrowSymbol','Custom symbol for the start of the section marker arrow. Need to make sure it''s present in "symbols.svg".',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #11=IFCSIMPLEPROPERTYTEMPLATE('1DtsPn5a9FG8$zXHDDMavY',$,'ShowEndArrow','Display end arrow.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 #12=IFCSIMPLEPROPERTYTEMPLATE('2$6U0mLI9AiPRWeBabdY3u',$,'EndArrowSymbol','Custom symbol for the end of the section marker arrow. Need to make sure it''s present in "symbols.svg".',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #13=IFCSIMPLEPROPERTYTEMPLATE('1naFqntIL7igCY7hCaE7kq',$,'HasConnectedSectionLine','Connect or disconnect section markers with line (by default = True).',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
-#14=IFCPROPERTYSETTEMPLATE('3V8oZ8YRD3_O7uR5vcUleS',$,'BBIM_Documentation','',.PSET_TYPEDRIVENOVERRIDE.,'IfcProject',(#15,#16,#17,#18,#19,#20,#21,#22,#23));
+#14=IFCPROPERTYSETTEMPLATE('3V8oZ8YRD3_O7uR5vcUleS',$,'BBIM_Documentation','',.PSET_OCCURRENCEDRIVEN.,'IfcProject',(#15,#16,#17,#18,#19,#20,#21,#22,#23));
 #15=IFCSIMPLEPROPERTYTEMPLATE('0ulAhgk3v9qfGlDILauR6J',$,'SheetsDir','Default sheets directory',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #16=IFCSIMPLEPROPERTYTEMPLATE('2yvlVKiQXASucfH40deCvu',$,'LayoutsDir','Default layouts directory',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #17=IFCSIMPLEPROPERTYTEMPLATE('2kXZqXicL3jRwsOnLM_0ho',$,'TitleblocksDir','Default titleblocks directory',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -28,7 +28,7 @@ DATA;
 #21=IFCSIMPLEPROPERTYTEMPLATE('1UDakJ5_f7kBhggNSW4$h5',$,'SymbolsPath','Default symbols SVG',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #22=IFCSIMPLEPROPERTYTEMPLATE('0d53LEtgLDQxnv__NfgH7i',$,'PatternsPath','Default patterns SVG',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #23=IFCSIMPLEPROPERTYTEMPLATE('26qFNMv7nCHgU6Jd7Anga5',$,'ShadingStylesPath','Default shading styles',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
-#24=IFCPROPERTYSETTEMPLATE('0I9merLinF5Ap$aZwaclgm',$,'BBIM_Dimension','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation/DIMENSION,IfcTypeProduct',(#25,#26,#27,#28));
+#24=IFCPROPERTYSETTEMPLATE('0I9merLinF5Ap$aZwaclgm',$,'BBIM_Dimension','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#25,#26,#27,#28));
 #25=IFCSIMPLEPROPERTYTEMPLATE('1rL2AbQsXD8RbpoWH5pYOV',$,'ShowDescriptionOnly','Hide the measurement values and show only annotation description',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 #26=IFCSIMPLEPROPERTYTEMPLATE('0SVyOfB0rC2xNfdRYf3XvY',$,'SuppressZeroInches','Suppress 0 inch values in dimension annotation text (for example: 12'' - 0" -> 12'')',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 #27=IFCSIMPLEPROPERTYTEMPLATE('2bUmj458PBqPAtUoI3MXsb',$,'TextPrefix','Text to add before annotation measurement value',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -16,7 +16,6 @@
 # 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 __future__ import annotations
 import os
 import bpy
 import json
@@ -36,8 +35,6 @@ import blenderbim.core.spatial
 import blenderbim.core.style
 from blenderbim.bim.ifc import IfcStore
 from mathutils import Vector
-from typing import Union
-from logging import Logger


 class IfcExporter:
@@ -89,8 +86,8 @@ class IfcExporter:
            self.get_application_name(), tool.Blender.get_blenderbim_version()
        )

-    def sync_all_objects(self, skip_unlinking=False) -> list[ifcopenshell.entity_instance]:
-        results: list[ifcopenshell.entity_instance] = []
+    def sync_all_objects(self):
+        results = []
        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(self.file)
        for ifc_definition_id in list(IfcStore.id_map.keys()):
            obj = IfcStore.id_map[ifc_definition_id]
@@ -99,21 +96,19 @@ class IfcExporter:
                    continue
                if obj.library:
                    continue
-                tool.Collector.sync(obj, skip_unlinking)
+                tool.Collector.sync(obj)
                result = self.sync_object_placement(obj)
                if result:
                    results.append(result)
                result = self.sync_object_material(obj)
-                # TODO: sync_object_material always returns None
-                # so it's never really appended
                if result:
                    results.append(result)
            except ReferenceError:
                pass  # The object is likely deleted
        return results

-    def sync_edited_objects(self) -> list[ifcopenshell.entity_instance]:
-        results: list[ifcopenshell.entity_instance] = []
+    def sync_edited_objects(self):
+        results = []
        for obj in IfcStore.edited_objs.copy():
            if not obj:
                continue
@@ -131,7 +126,7 @@ class IfcExporter:
        IfcStore.edited_objs.clear()
        return results

-    def sync_object_material(self, obj: bpy.types.Object) -> None:
+    def sync_object_material(self, obj):
        if not obj.data or not isinstance(obj.data, bpy.types.Mesh):
            return
        if not self.has_changed_materials(obj):
@@ -142,10 +137,11 @@ class IfcExporter:
        checksum = obj.data.BIMMeshProperties.material_checksum
        return checksum != str([s.id() for s in tool.Geometry.get_styles(obj) if s])

-    def sync_object_placement(self, obj: bpy.types.Object) -> Union[ifcopenshell.entity_instance, None]:
+    def sync_object_placement(self, obj):
        element = self.file.by_id(obj.BIMObjectProperties.ifc_definition_id)
        if not tool.Ifc.is_moved(obj):
            return
+        blender_matrix = np.array(obj.matrix_world)
        if (obj.scale - Vector((1.0, 1.0, 1.0))).length > 1e-4:
            bpy.ops.bim.update_representation(obj=obj.name)
            return element
@@ -156,7 +152,7 @@ class IfcExporter:
        blenderbim.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
        return element

-    def sync_grid_axis_object_placement(self, obj: bpy.types.Object, element: ifcopenshell.entity_instance) -> None:
+    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)
        if grid_obj:
@@ -165,10 +161,10 @@ class IfcExporter:
                bpy.ops.bim.update_representation(obj=obj.name)
        tool.Geometry.record_object_position(obj)

-    def get_application_name(self) -> str:
+    def get_application_name(self):
        return "BlenderBIM"

-    def get_application_version(self) -> str:
+    def get_application_version(self):
        version = ".".join(
            [
                str(x)
@@ -186,13 +182,11 @@ class IfcExporter:

 class IfcExportSettings:
    def __init__(self):
-        self.logger: Logger = None
-        self.output_file: str = None
-        self.json_version: str = None
-        self.json_compact: bool = None
+        self.logger = None
+        self.output_file = None

    @staticmethod
-    def factory(context: bpy.types.Context, output_file: str, logger: Logger) -> IfcExportSettings:
+    def factory(context, output_file, logger):
        settings = IfcExportSettings()
        settings.output_file = output_file
        settings.logger = logger
@@ -31,7 +31,6 @@ from blenderbim.bim.module.model.data import AuthoringData
 from blenderbim.bim.module.model.workspace import LIST_OF_TOOLS, TOOLS_TO_CLASSES_MAP
 from mathutils import Vector
 from math import cos, degrees
-from typing import Union


 cwd = os.path.dirname(os.path.realpath(__file__))
@@ -192,8 +191,6 @@ def refresh_ui_data():
    if isinstance(tool.Ifc.get(), ifcopenshell.sqlite):
        tool.Ifc.get().clear_cache()

-    bpy.context.scene.DocProperties.should_draw_decorations = bpy.context.scene.DocProperties.should_draw_decorations
-

@persistent
 def loadIfcStore(scene):
@@ -223,7 +220,7 @@ def redo_post(scene):
    tool.Ifc.rebuild_element_maps()


-def get_application(ifc: ifcopenshell.file) -> ifcopenshell.entity_instance:
+def get_application(ifc):
    # TODO: cache this for even faster application retrieval. It honestly makes a difference on long scripts.
    version = get_application_version()
    for element in ifc.by_type("IfcApplication"):
@@ -238,20 +235,7 @@ def get_application(ifc: ifcopenshell.file) -> ifcopenshell.entity_instance:
    )


-def get_user(ifc: ifcopenshell.file) -> Union[ifcopenshell.entity_instance, None]:
-    # TODO: cache this for even faster application retrieval. It honestly makes a difference on long scripts.
-    if pao := next(iter(ifc.by_type("IfcPersonAndOrganization")), None):
-        return pao
-    elif ifc.schema == "IFC2X3":
-        if (person := next(iter(ifc.by_type("IfcPerson")), None)) is None:
-            person = tool.Ifc.run("owner.add_person")
-        if (organization := next(iter(ifc.by_type("IfcOrganization")), None)) is None:
-            organization = tool.Ifc.run("owner.add_organisation")
-        pao = tool.Ifc.run("owner.add_person_and_organisation", person=person, organisation=organization)
-        return pao
-
-
-def get_application_version() -> str:
+def get_application_version():
    return ".".join(
        [
            str(x)
@@ -270,6 +254,60 @@ def viewport_shading_changed_callback(area):
        bpy.context.scene.BIMStylesProperties.active_style_type = "External"


+@classmethod
+def poll_check_blender_tab(cls, context):
+    return tool.Blender.is_tab(context, "BLENDER")
+
+
+def get_override_scene_panel(panel_name):
+    original_panel = getattr(bpy.types, panel_name)
+
+    override_panel = type(f"Override_{panel_name}", (original_panel,), {})
+    override_panel.bl_idname = f"{panel_name}_override"
+
+    # some blender panel depend on other and register_class will throw an error
+    # if we won't override their `bl_parent_id`
+    bl_parent_id = getattr(override_panel, "bl_parent_id", None)
+    if bl_parent_id is not None:
+        override_panel.bl_parent_id = f"{bl_parent_id}_override"
+
+    # override poll method
+    poll = getattr(override_panel, "poll", None)
+    if poll is None:
+        override_panel.poll = poll_check_blender_tab
+    else:
+
+        @classmethod
+        def wrapped_poll(cls, context):
+            return super(override_panel, cls).poll(context) and poll_check_blender_tab.__func__(cls, context)
+
+        override_panel.poll = wrapped_poll
+
+    return override_panel
+
+
+# TODO: possibly override scene panels from other addons too?
+# list can be updated from
+# https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_ui/properties_scene.py#L421
+OVERRIDE_SCENE_PANELS = (
+    "SCENE_PT_scene",
+    "SCENE_PT_unit",
+    "SCENE_PT_physics",
+    "SCENE_PT_rigid_body_world",
+    "SCENE_PT_rigid_body_world_settings",
+    "SCENE_PT_rigid_body_cache",
+    "SCENE_PT_rigid_body_field_weights",
+    "SCENE_PT_audio",
+    "SCENE_PT_keying_sets",
+    "SCENE_PT_custom_props",
+    # after SCENE_PT_keying_sets
+    "SCENE_PT_keying_set_paths",
+    "SCENE_PT_keyframing_settings",
+)
+if bpy.app.version >= (4, 0):
+    OVERRIDE_SCENE_PANELS += ("SCENE_PT_simulation",)
+
+
@persistent
 def load_post(scene):
    global global_subscription_owner
@@ -292,7 +330,7 @@ def load_post(scene):
                key=key, owner=global_subscription_owner, args=(area,), notify=viewport_shading_changed_callback
            )

-    ifcopenshell.api.owner.settings.get_user = get_user
+    ifcopenshell.api.owner.settings.get_user = lambda ifc: core_owner.get_user(tool.Owner)
    ifcopenshell.api.owner.settings.get_application = get_application
    AuthoringData.type_thumbnails = {}

@@ -301,16 +339,19 @@ def load_post(scene):

    if bpy.context.preferences.addons["blenderbim"].preferences.should_setup_workspace:
        if "BIM" in bpy.data.workspaces:
-            if bpy.context.preferences.addons["blenderbim"].preferences.activate_workspace:
-                bpy.context.window.workspace = bpy.data.workspaces["BIM"]
+            bpy.context.window.workspace = bpy.data.workspaces["BIM"]
        else:
            bpy.ops.workspace.append_activate(idname="BIM", filepath=os.path.join(cwd, "data", "workspace.blend"))

-    # To improve usability for new users, we hijack the scene properties
-    # tab. We override default scene properties panels with our own poll
-    # to hide them unless the user has chosen to view Blender properties.
-    for panel in tool.Blender.get_scene_panels_list():
-        if panel in blenderbim.bim.original_scene_panels_polls:
-            continue
-        tool.Blender.override_scene_panel(panel)
+        # To improve usability for new users, we hijack the scene properties
+        # tab. We override default scene properties panels with our own poll
+        # to hide them unless the user has chosen to view Blender properties.
+        for panel in OVERRIDE_SCENE_PANELS:
+            if panel in blenderbim.bim.overridden_scene_panels:
+                continue
+            override_panel = get_override_scene_panel(panel)
+            original_panel = getattr(bpy.types, panel)
+            bpy.utils.register_class(override_panel)
+            bpy.utils.unregister_class(original_panel)
+            blenderbim.bim.overridden_scene_panels[panel] = (original_panel, override_panel)
    tool.Blender.setup_tabs()
@@ -29,7 +29,6 @@ from mathutils import geometry
 from mathutils import Vector
 import blenderbim.tool as tool
 from blenderbim.bim.ifc import IfcStore
-from typing import Optional, Callable, Any, Union


 def draw_attributes(props, layout, copy_operator=None, popup_active_attribute=None):
@@ -76,10 +75,6 @@ def draw_attribute(attribute, layout, copy_operator=None):
        op.data_path = attribute.path_from_id("string_value")
    if attribute.is_optional:
        layout.prop(attribute, "is_null", icon="RADIOBUT_OFF" if attribute.is_null else "RADIOBUT_ON", text="")
-
-    if attribute.name == "GlobalId":
-        layout.operator("bim.generate_global_id", icon="FILE_REFRESH", text="")
-
    if copy_operator:
        op = layout.operator(f"{copy_operator}", text="", icon="COPYDOWN")
        op.name = attribute.name
@@ -91,11 +86,7 @@ def import_attributes(ifc_class, props, data, callback=None):


 # A more elegant attribute importer signature, intended to supersede import_attributes
-def import_attributes2(
-    element: Union[str, ifcopenshell.entity_instance],
-    props: bpy.types.PropertyGroup,
-    callback: Optional[Callable] = None,
-) -> None:
+def import_attributes2(element, props, callback=None):
    if isinstance(element, str):
        attributes = tool.Ifc.schema().declaration_by_name(element).as_entity().all_attributes()
        info = {a.name(): None for a in attributes}
@@ -125,7 +116,7 @@ def import_attribute(attribute, props, data, callback=None):
    elif is_handled_by_callback is False:
        props.remove(len(props) - 1)
    elif data_type == "string":
-        new.string_value = "" if new.is_null else str(data[attribute.name()]).replace("\n", "\\n")
+        new.string_value = "" if new.is_null else str(data[attribute.name()])
        if attribute.type_of_attribute().declared_type().name() == "IfcURIReference":
            new.is_uri = True
    elif data_type == "boolean":
@@ -187,7 +178,7 @@ def add_attribute_description(attribute_blender, attribute_ifc=None):
        attribute_blender.description = description


-def export_attributes(props, callback: Optional[Callable] = None) -> dict[str, Any]:
+def export_attributes(props, callback=None):
    attributes = {}
    for prop in props:
        is_handled_by_callback = callback(attributes, prop) if callback else False
@@ -225,6 +216,15 @@ def get_enum_items(data, prop_name, context=None):
    return items


+# 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)
+
+
 def convert_property_group_from_si(property_group, skip_props=()):
    """Method converts property group values from si to current ifc project units

@@ -271,9 +271,6 @@ def draw_filter(layout, filter_groups, data, module):
        op.type = sprops.facet
        op.index = i
        op.module = module
-        op = row.operator("bim.remove_filter_group", text="", icon="X")
-        op.index = i
-        op.module = module

        for j, ifc_filter in enumerate(filter_group.filters):
            if ifc_filter.type == "entity":
@@ -304,9 +301,6 @@ def draw_filter(layout, filter_groups, data, module):
            elif ifc_filter.type == "group":
                row = box.row(align=True)
                row.prop(ifc_filter, "value", text="", icon="OUTLINER_COLLECTION")
-            elif ifc_filter.type == "parent":
-                row = box.row(align=True)
-                row.prop(ifc_filter, "value", text="", icon="FILE_PARENT")
            elif ifc_filter.type == "query":
                row = box.row(align=True)
                row.prop(ifc_filter, "name", text="", icon="POINTCLOUD_DATA")
@@ -323,6 +317,11 @@ def draw_filter(layout, filter_groups, data, module):
            op.index = j
            op.module = module

+        row = box.row()
+        op = row.operator("bim.remove_filter_group", icon="X")
+        op.index = i
+        op.module = module
+

 # TODO this should move into ifcopenshell.util

@@ -19,15 +19,12 @@
 import os
 import bpy
 import uuid
-import shutil
 import hashlib
 import zipfile
 import tempfile
-import traceback
 import ifcopenshell
 import ifcopenshell.geom
 import ifcopenshell.ifcopenshell_wrapper
-import blenderbim
 import blenderbim.bim.handler
 import blenderbim.tool as tool
 from pathlib import Path
@@ -40,19 +37,19 @@ IFC_CONNECTED_TYPE = Union[bpy.types.Material, bpy.types.Object]

 class IfcStore:
    path: str = ""
-    file: Optional[ifcopenshell.file] = None
-    schema: Optional[ifcopenshell.ifcopenshell_wrapper.schema_definition] = None
-    cache: Optional[ifcopenshell.ifcopenshell_wrapper.HdfSerializer] = None
-    cache_path: Optional[str] = None
+    file: ifcopenshell.file = None
+    schema: ifcopenshell.ifcopenshell_wrapper.schema_definition = None
+    cache: ifcopenshell.ifcopenshell_wrapper.HdfSerializer = None
+    cache_path: str = None
    id_map: dict[int, IFC_CONNECTED_TYPE] = {}
    guid_map: dict[str, IFC_CONNECTED_TYPE] = {}
    edited_objs: Set[bpy.types.Object] = set()
    pset_template_path: str = ""
-    pset_template_file: Optional[ifcopenshell.file] = None
+    pset_template_file: ifcopenshell.file = None
    classification_path: str = ""
-    classification_file: Optional[ifcopenshell.file] = None
+    classification_file: ifcopenshell.file = None
    library_path: str = ""
-    library_file: Optional[ifcopenshell.file] = None
+    library_file: ifcopenshell.file = None
    current_transaction = ""
    last_transaction = ""
    history = []
@@ -122,13 +119,7 @@ class IfcStore:
        ifc_hash = hashlib.md5(ifc_key.encode("utf-8")).hexdigest()
        new_cache_path = os.path.join(bpy.context.scene.BIMProperties.data_dir, "cache", f"{ifc_hash}.h5")
        IfcStore.cache = None
-        try:
-            shutil.move(IfcStore.cache_path, new_cache_path)
-        except PermissionError:
-            try:
-                shutil.copy2(IfcStore.cache_path, new_cache_path)
-            except PermissionError:
-                pass  # Well we tried. No cache for you!
+        os.replace(IfcStore.cache_path, new_cache_path)
        IfcStore.get_cache()

    @staticmethod
@@ -222,7 +213,7 @@ class IfcStore:
        elif existing_obj:
            try:
                existing_obj.name
-                IfcStore.unlink_element(element=element, obj=existing_obj)
+                IfcStore.unlink_element(obj=existing_obj)
            except:
                pass
        IfcStore.id_map[element.id()] = obj
@@ -338,7 +329,6 @@ class IfcStore:

    @staticmethod
    def execute_ifc_operator(operator: bpy.types.Operator, context: bpy.types.Context, is_invoke=False):
-        blenderbim.last_actions.append({"type": "operator", "name": operator.bl_idname})
        bpy.context.scene.BIMProperties.is_dirty = True
        is_top_level_operator = not bool(IfcStore.current_transaction)

@@ -353,14 +343,10 @@ class IfcStore:
        else:
            operator.transaction_key = IfcStore.current_transaction

-        try:
-            if is_invoke:
-                result = getattr(operator, "_invoke")(context, None)
-            else:
-                result = getattr(operator, "_execute")(context)
-        except:
-            blenderbim.last_error = traceback.format_exc()
-            raise
+        if is_invoke:
+            result = getattr(operator, "_invoke")(context, None)
+        else:
+            result = getattr(operator, "_execute")(context)

        if is_top_level_operator:
            if tool.Ifc.get():
@@ -26,7 +26,6 @@ import bmesh
 import logging
 import mathutils
 import numpy as np
-import numpy.typing as npt
 import multiprocessing
 import ifcopenshell
 import ifcopenshell.geom
@@ -35,9 +34,7 @@ import ifcopenshell.util.element
 import ifcopenshell.util.geolocation
 import ifcopenshell.util.placement
 import ifcopenshell.util.representation
-import ifcopenshell.util.shape
 import blenderbim.tool as tool
-import blenderbim.core.spatial
 import ifcopenshell.ifcopenshell_wrapper as ifcopenshell_wrapper
 from itertools import chain, accumulate
 from blenderbim.bim.ifc import IfcStore, IFC_CONNECTED_TYPE
@@ -202,7 +199,7 @@ class MaterialCreator:


 class IfcImporter:
-    def __init__(self, ifc_import_settings: IfcImportSettings):
+    def __init__(self, ifc_import_settings):
        self.ifc_import_settings = ifc_import_settings
        self.diff = None
        self.file: ifcopenshell.file = None
@@ -301,27 +298,25 @@ class IfcImporter:
        if self.ifc_import_settings.should_setup_viewport_camera:
            self.setup_viewport_camera()
        self.setup_arrays()
-        self.profile_code("Setup arrays")
-        blenderbim.core.spatial.import_spatial_decomposition(tool.Spatial)
        self.update_progress(100)
        bpy.context.window_manager.progress_end()

-    def is_element_far_away(self, element: ifcopenshell.entity_instance) -> bool:
+    def is_element_far_away(self, element):
        try:
            placement = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement)
            point = placement[:, 3][0:3]
            return self.is_point_far_away(point, is_meters=False)
        except:
-            return False
+            pass

-    def is_point_far_away(
-        self, point: Union[ifcopenshell.entity_instance, npt.NDArray[np.float64]], is_meters: bool = True
-    ) -> bool:
+    def is_point_far_away(self, point, is_meters=True):
        # Locations greater than 1km are not considered "small sites" according to the georeferencing guide
        # 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 = getattr(point, "Coordinates", point)
+        coords = point
+        if hasattr(point, "Coordinates"):
+            coords = point.Coordinates
        return abs(coords[0]) > limit or abs(coords[1]) > limit or abs(coords[2]) > limit

    def process_context_filter(self):
@@ -435,7 +430,7 @@ class IfcImporter:
        self.annotations = set([a for a in self.file.by_type("IfcAnnotation")])
        self.annotations -= drawing_annotations

-        self.elements = [e for e in self.elements if not e.is_a("IfcFeatureElement") or e.is_a("IfcSurfaceFeature")]
+        self.elements = [e for e in self.elements if not e.is_a("IfcFeatureElement")]
        if self.ifc_import_settings.is_coordinating:
            self.elements = [e for e in self.elements if e.Representation]

@@ -606,14 +601,9 @@ class IfcImporter:
        return products

    def predict_dense_mesh(self):
-        if self.ifc_import_settings.should_use_native_meshes:
-            return
-
        threshold = 10000  # Just from experience.

-        # The check for CfsFaces/Faces/CoordIndex accommodates invalid data from Cadwork
-        # 0 IfcClosedShell.CfsFaces
-        faces = [len(faces) for e in self.file.by_type("IfcClosedShell") if (faces := e[0])]
+        faces = [len(e.CfsFaces) for e in self.file.by_type("IfcClosedShell")]
        if faces and max(faces) > threshold:
            self.ifc_import_settings.should_use_native_meshes = True
            return
@@ -621,14 +611,12 @@ class IfcImporter:
        if self.file.schema == "IFC2X3":
            return

-        # 2 IfcPolygonalFaceSet.Faces
-        faces = [len(faces) for e in self.file.by_type("IfcPolygonalFaceSet") if (faces := e[2])]
+        faces = [len(e.Faces) for e in self.file.by_type("IfcPolygonalFaceSet")]
        if faces and max(faces) > threshold:
            self.ifc_import_settings.should_use_native_meshes = True
            return

-        # 3 IfcTriangulatedFaceSet.CoordIndex
-        faces = [len(index) for e in self.file.by_type("IfcTriangulatedFaceSet") if (index := e[3])]
+        faces = [len(e.CoordIndex) for e in self.file.by_type("IfcTriangulatedFaceSet")]
        if faces and max(faces) > threshold:
            self.ifc_import_settings.should_use_native_meshes = True

@@ -686,7 +674,7 @@ class IfcImporter:
        props.blender_orthogonal_height = str(offset_point[2])
        props.has_blender_offset = True

-    def get_offset_point(self) -> Union[npt.NDArray[np.float64], None]:
+    def get_offset_point(self):
        elements_checked = 0
        # If more than these elements aren't far away, the file probably isn't absolutely positioned
        element_checking_threshold = 10
@@ -709,19 +697,17 @@ class IfcImporter:
            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 = mat @ np.array(
+            point = np.array(
                (
-                    shape.geometry.verts[0],
-                    shape.geometry.verts[1],
-                    shape.geometry.verts[2],
+                    shape.geometry.verts[0] / self.unit_scale,
+                    shape.geometry.verts[1] / self.unit_scale,
+                    shape.geometry.verts[2] / self.unit_scale,
                    0.0,
                )
            )
-            point = point / self.unit_scale
-            if self.is_point_far_away(point, is_meters=False):
-                return point
+            return mat @ point

-    def does_element_likely_have_geometry_far_away(self, element: ifcopenshell.entity_instance) -> bool:
+    def does_element_likely_have_geometry_far_away(self, element):
        for representation in element.Representation.Representations:
            items = []
            for item in representation.Items:
@@ -738,14 +724,13 @@ class IfcImporter:
                    if subelement.is_a("IfcCartesianPoint"):
                        if len(subelement.Coordinates) == 3 and self.is_point_far_away(subelement, is_meters=False):
                            return True
-        return False

-    def apply_blender_offset_to_matrix_world(self, obj: bpy.types.Object, matrix: np.ndarray) -> mathutils.Matrix:
+    def apply_blender_offset_to_matrix_world(self, obj, matrix):
        props = bpy.context.scene.BIMGeoreferenceProperties
        if props.has_blender_offset:
            if obj.data and obj.data.get("has_cartesian_point_offset", None):
                obj.BIMObjectProperties.blender_offset_type = "CARTESIAN_POINT"
-            elif self.is_point_far_away((matrix[:3, 3])):
+            elif self.is_point_far_away((matrix[0, 3], matrix[1, 3], matrix[2, 3])):
                obj.BIMObjectProperties.blender_offset_type = "OBJECT_PLACEMENT"
                matrix = ifcopenshell.util.geolocation.global2local(
                    matrix,
@@ -758,9 +743,7 @@ class IfcImporter:

        return mathutils.Matrix(matrix.tolist())

-    def find_decomposed_ifc_class(
-        self, element: ifcopenshell.entity_instance, ifc_class: str
-    ) -> Union[ifcopenshell.entity_instance, None]:
+    def find_decomposed_ifc_class(self, element, ifc_class):
        if element.is_a(ifc_class):
            return element
        rel_aggregates = element.IsDecomposedBy
@@ -874,10 +857,7 @@ class IfcImporter:
        print("Done creating geometry")

    def create_spatial_elements(self) -> None:
-        if bpy.context.preferences.addons["blenderbim"].preferences.spatial_elements_unselectable:
-            self.create_generic_elements(self.spatial_elements, unselectable=True)
-        else:
-            self.create_generic_elements(self.spatial_elements, unselectable=False)
+        self.create_generic_elements(self.spatial_elements, unselectable=True)

    def create_elements(self) -> None:
        self.create_generic_elements(self.elements)
@@ -969,9 +949,7 @@ class IfcImporter:
            self.create_product(element, mesh=mesh)

    def create_products(
-        self,
-        products: set[ifcopenshell.entity_instance],
-        settings: Optional[ifcopenshell.geom.main.settings] = None,
+        self, products, settings: Optional[ifcopenshell.geom.main.settings] = None
    ) -> set[ifcopenshell.entity_instance]:
        results = set()
        if not products:
@@ -1186,9 +1164,6 @@ class IfcImporter:

        return obj

-    def load_existing_meshes(self) -> None:
-        self.meshes.update({m.name: m for m in bpy.data.meshes})
-
    def get_representation_item_material_name(self, item):
        if not item.StyledByItem:
            return
@@ -1510,10 +1485,7 @@ class IfcImporter:
            # Occurs when reloading a project
            pass
        project_collection = bpy.context.view_layer.layer_collection.children[self.project["blender"].name]
-        types_collection = project_collection.children[self.type_collection.name]
-        types_collection.hide_viewport = False
-        for obj in types_collection.collection.objects:  # turn off all objects inside Types collection.
-            obj.hide_set(True)
+        project_collection.children[self.type_collection.name].hide_viewport = True

    def clean_mesh(self):
        obj = None
@@ -1648,34 +1620,30 @@ class IfcImporter:
        if self.ifc_import_settings.has_filter:
            rel_aggregates = set()
            for element in self.elements:
-                if decomposed_by := element.IsDecomposedBy:
-                    rel_aggregates.add(decomposed_by[0])
-                elif decomposes := element.Decomposes:
-                    rel_aggregates.add(decomposes[0])
-                elif nested_by := getattr(element, "IsNestedBy", []):  # IFC2X3 does not have IsNestedBy
-                    if next((e for e in nested_by[0].RelatedObjects if not e.is_a("IfcPort")), None):
-                        rel_aggregates.add(nested_by[0])
-                elif nests := getattr(element, "Nests", []):
-                    rel_aggregates.add(nests[0])
-                elif element.is_a("IfcSurfaceFeature") and self.file.schema == "IFC4X3":
-                    rel_aggregates.add(element.AdheresToElement[0])
+                if element.IsDecomposedBy:
+                    rel_aggregates.add(element.IsDecomposedBy[0])
+                elif element.Decomposes:
+                    rel_aggregates.add(element.Decomposes[0])
+                elif getattr(element, "IsNestedBy", []):  # IFC2X3 does not have IsNestedBy
+                    if [e for e in element.IsNestedBy[0].RelatedObjects if not e.is_a("IfcPort")]:
+                        rel_aggregates.add(element.IsNestedBy[0])
+                elif getattr(element, "Nests", []):
+                    rel_aggregates.add(element.Nests[0])
        else:
            rel_aggregates = [
                r
                for r in self.file.by_type("IfcRelAggregates")
-                if (relating_obj := r.RelatingObject).is_a("IfcElement") or relating_obj.is_a("IfcElementType")
+                if r.RelatingObject.is_a("IfcElement") or r.RelatingObject.is_a("IfcElementType")
            ] + [
                r
                for r in self.file.by_type("IfcRelNests")
                if (
-                    (relating_obj := r.RelatingObject).is_a("IfcElement")
-                    or relating_obj.is_a("IfcElementType")
-                    or (relating_obj.is_a("IfcPositioningElement") and not relating_obj.is_a("IfcGrid"))
+                    r.RelatingObject.is_a("IfcElement")
+                    or r.RelatingObject.is_a("IfcElementType")
+                    or (r.RelatingObject.is_a("IfcPositioningElement") and not r.RelatingObject.is_a("IfcGrid"))
                )
                and [e for e in r.RelatedObjects if not e.is_a("IfcPort")]
            ]
-            if self.file.schema == "IFC4X3":
-                rel_aggregates += [r for r in self.file.by_type("IfcRelAdheresToElement")]

        if len(rel_aggregates) > 10000:
            # More than 10,000 collections makes Blender unhappy
@@ -1685,9 +1653,7 @@ class IfcImporter:

        aggregates: dict[str, dict] = {}
        for rel_aggregate in rel_aggregates:
-            element: ifcopenshell.entity_instance = getattr(rel_aggregate, "RelatingObject", None) or getattr(
-                rel_aggregate, "RelatingElement"
-            )
+            element: ifcopenshell.entity_instance = rel_aggregate.RelatingObject
            collection = bpy.data.collections.new(tool.Loader.get_name(element))
            aggregates[element.GlobalId] = {"element": element, "collection": collection}
            self.collections[element.GlobalId] = collection
@@ -1704,20 +1670,19 @@ class IfcImporter:
            if aggregate["element"].is_a("IfcElementType"):
                self.type_collection.children.link(aggregate["collection"])
                continue
-            self.project["blender"].children.link(aggregate["collection"])

-    def create_materials(self) -> None:
+    def create_materials(self):
        for material in self.file.by_type("IfcMaterial"):
            self.create_material(material)

-    def create_material(self, material: ifcopenshell.entity_instance) -> bpy.types.Material:
+    def create_material(self, material):
        blender_material = bpy.data.materials.new(material.Name)
        self.link_element(material, blender_material)
        self.material_creator.materials[material.id()] = blender_material
        blender_material.use_fake_user = True
        return blender_material

-    def create_styles(self) -> None:
+    def create_styles(self):
        parsed_styles = set()

        for material_definition_representation in self.file.by_type("IfcMaterialDefinitionRepresentation"):
@@ -1789,9 +1754,6 @@ class IfcImporter:
        elif getattr(element, "Nests", None) and not element.is_a("IfcPort"):
            nest = ifcopenshell.util.element.get_nest(element)
            return self.collections[nest.GlobalId].objects.link(obj)
-        elif element.is_a("IfcSurfaceFeature") and self.file.schema == "IFC4X3":
-            adherend = element.AdheresToElement[0].RelatingElement
-            return self.collections[adherend.GlobalId].objects.link(obj)

        return self.place_object_in_spatial_decomposition_collection(element, obj)

@@ -1841,7 +1803,7 @@ class IfcImporter:
            if rel.is_a("IfcRelAssignsToGroup") and rel.RelatingGroup.ObjectType == "DRAWING":
                return rel.RelatingGroup

-    def get_element_matrix(self, element: ifcopenshell.entity_instance) -> np.ndarray:
+    def get_element_matrix(self, element: ifcopenshell.entity_instance) -> np.array:
        if isinstance(element, ifcopenshell.sqlite_entity):
            result = self.geometry_cache["shapes"][element.id()]["matrix"]
        else:
@@ -1924,7 +1886,11 @@ class IfcImporter:
                and geometry.verts
                and self.is_point_far_away((geometry.verts[0], geometry.verts[1], geometry.verts[2]))
            ):
-                offset_point = np.array(
+                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),
@@ -1932,15 +1898,8 @@ class IfcImporter:
                        0.0,
                    )
                )
-                if geometry != shape:
-                    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) @ offset_point
                verts = [None] * len(geometry.verts)
                for i in range(0, len(geometry.verts), 3):
-                    # Note: this enh2xyz call is crazy slow.
                    verts[i], verts[i + 1], verts[i + 2] = ifcopenshell.util.geolocation.enh2xyz(
                        geometry.verts[i],
                        geometry.verts[i + 1],
@@ -1966,9 +1925,7 @@ class IfcImporter:

                # See bug 3546
                # ios_edges holds true edges that aren't triangulated.
-                #
-                # we do `.tolist()` because Blender can't assign `np.int32` to it's custom attributes
-                mesh["ios_edges"] = list(set(tuple(e) for e in ifcopenshell.util.shape.get_edges(geometry).tolist()))
+                mesh["ios_edges"] = list(set(tuple(e) for e in ifcopenshell.util.shape.get_edges(geometry)))

                mesh.vertices.add(num_vertices)
                mesh.vertices.foreach_set("co", verts)
@@ -1995,14 +1952,14 @@ class IfcImporter:

            print(traceback.format_exc())

-    def a2p(self, o: mathutils.Vector, z: mathutils.Vector, x: mathutils.Vector) -> mathutils.Matrix:
+    def a2p(self, o, z, x):
        y = z.cross(x)
        r = mathutils.Matrix((x, y, z, o))
        r.resize_4x4()
        r.transpose()
        return r

-    def get_axis2placement(self, plc: ifcopenshell.entity_instance) -> mathutils.Matrix:
+    def get_axis2placement(self, plc):
        if plc.is_a("IfcAxis2Placement3D"):
            z = mathutils.Vector(plc.Axis.DirectionRatios if plc.Axis else (0, 0, 1))
            x = mathutils.Vector(plc.RefDirection.DirectionRatios if plc.RefDirection else (1, 0, 0))
@@ -2022,7 +1979,7 @@ class IfcImporter:
        o = plc.LocalOrigin.Coordinates
        return self.a2p(o, z, x)

-    def get_local_placement(self, plc: Optional[ifcopenshell.entity_instance] = None) -> mathutils.Matrix:
+    def get_local_placement(self, plc):
        if plc is None:
            return mathutils.Matrix()
        if plc.PlacementRelTo is None:
@@ -2037,11 +1994,11 @@ class IfcImporter:
                bpy.context.scene.BIMRootProperties.contexts = str(subcontext.id())
                break

-    def link_element(self, element: ifcopenshell.entity_instance, obj: IFC_CONNECTED_TYPE) -> None:
+    def link_element(self, element, obj):
        self.added_data[element.id()] = obj
        tool.Ifc.link(element, obj)

-    def set_matrix_world(self, obj: bpy.types.Object, matrix_world: mathutils.Matrix) -> None:
+    def set_matrix_world(self, obj, matrix_world):
        obj.matrix_world = matrix_world
        tool.Geometry.record_object_position(obj)

@@ -2064,7 +2021,7 @@ class IfcImporter:

 class IfcImportSettings:
    def __init__(self):
-        self.logger: logging.Logger = None
+        self.logger = None
        self.input_file = None
        self.diff_file = None
        self.should_use_cpu_multiprocessing = True
@@ -36,6 +36,7 @@ class AggregateData:
            "relating_object_label": cls.get_relating_object_label(),
            "has_related_objects": cls.has_related_objects(),
            "total_parts": cls.total_parts(),
+            "ifc_class": cls.ifc_class(),
            "total_linked_aggregate": cls.total_linked_aggregate(),
        }
        cls.is_loaded = True
@@ -67,6 +68,12 @@ class AggregateData:
    def has_related_objects(cls) -> bool:
        return bool(cls.get_related_objects())

+    @classmethod
+    def ifc_class(cls) -> str:
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if element:
+            return element.is_a()
+
    @classmethod
    def total_linked_aggregate(cls):
        element = tool.Ifc.get_entity(bpy.context.active_object)
@@ -40,39 +40,36 @@ class BIM_OT_aggregate_assign_object(bpy.types.Operator, Operator):
    bl_label = "Assign Object To Aggregation"
    bl_options = {"REGISTER", "UNDO"}
    relating_object: bpy.props.IntProperty()
-    related_object: bpy.props.IntProperty()

    def _execute(self, context):
        relating_obj = None
        if self.relating_object:
-            relating_obj = tool.Ifc.get_object(tool.Ifc.get().by_id(self.relating_object))
-        elif self.related_object:
-            aggregate = ifcopenshell.util.element.get_aggregate(tool.Ifc.get().by_id(self.related_object))
-            if aggregate:
-                relating_obj = tool.Ifc.get_object(aggregate)
+            element = tool.Ifc.get().by_id(self.relating_object)
+            if element.IsDecomposedBy:
+                relating_obj = tool.Ifc.get_object(element)
+            else:
+                assembly = element.Decomposes[0].RelatingObject
+                relating_obj = tool.Ifc.get_object(assembly)
        elif context.active_object:
            relating_obj = context.active_object
        if not relating_obj:
            return

-        for obj in tool.Blender.get_selected_objects():
+        for obj in bpy.context.selected_objects:
            if obj == relating_obj:
                continue
            element = tool.Ifc.get_entity(obj)
            if not element:
                continue
-            try:
-                core.assign_object(
-                    tool.Ifc,
-                    tool.Aggregate,
-                    tool.Collector,
-                    relating_obj=relating_obj,
-                    related_obj=obj,
-                )
-            except core.IncompatibleAggregateError:
-                self.report({"ERROR"}, f"Cannot aggregate {obj.name} to {relating_obj.name}")
-            except core.AggregateRepresentationError:
-                self.report({"ERROR"}, f"Cannot aggregate to {relating_obj.name} with a body representation")
+            result = core.assign_object(
+                tool.Ifc,
+                tool.Aggregate,
+                tool.Collector,
+                relating_obj=relating_obj,
+                related_obj=obj,
+            )
+            if not result:
+                self.report({"ERROR"}, f" Cannot aggregate {obj.name} to {relating_obj.name}")


 class BIM_OT_aggregate_unassign_object(bpy.types.Operator, Operator):
@@ -99,13 +96,12 @@ class BIM_OT_aggregate_unassign_object(bpy.types.Operator, Operator):
            )

            # Removes Pset related to Linked Aggregates
-            if not element.is_a('IfcElementAssembly'):
-                pset = ifcopenshell.util.element.get_pset(element, 'BBIM_Linked_Aggregate')
-                if pset:
-                    pset = tool.Ifc.get().by_id(pset["id"])
-                    ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), product=element, pset=pset)
+            pset = ifcopenshell.util.element.get_pset(element, "BBIM_Linked_Aggregate")
+            if pset:
+                pset = tool.Ifc.get().by_id(pset["id"])
+                ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), pset=pset)
+

-              
 class BIM_OT_enable_editing_aggregate(bpy.types.Operator, Operator):
    """Enable editing aggregation relationship"""

@@ -136,7 +132,6 @@ class BIM_OT_add_aggregate(bpy.types.Operator, tool.Ifc.Operator):
    bl_options = {"REGISTER", "UNDO"}
    obj: bpy.props.StringProperty()
    ifc_class: bpy.props.StringProperty(name="IFC Class", default="IfcElementAssembly")
-    aggregate_name: bpy.props.StringProperty(name="Name", default="Default_Name")

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)
@@ -144,15 +139,13 @@ class BIM_OT_add_aggregate(bpy.types.Operator, tool.Ifc.Operator):
    def draw(self, context):
        row = self.layout
        row.prop(self, "ifc_class")
-        row = self.layout
-        row.prop(self, "aggregate_name")

    def _execute(self, context):
        try:
            ifc_class = tool.Ifc.schema().declaration_by_name(self.ifc_class).name()
        except:
            return
-        aggregate = self.create_aggregate(context, ifc_class, self.aggregate_name)
+        aggregate = self.create_aggregate(context, ifc_class)

        for obj in context.selected_objects:
            element = tool.Ifc.get_entity(obj)
@@ -180,8 +173,8 @@ class BIM_OT_add_aggregate(bpy.types.Operator, tool.Ifc.Operator):
                )
            core.assign_object(tool.Ifc, tool.Aggregate, tool.Collector, relating_obj=aggregate, related_obj=obj)

-    def create_aggregate(self, context, ifc_class, aggregate_name):
-        aggregate = bpy.data.objects.new(aggregate_name, None)
+    def create_aggregate(self, context, ifc_class):
+        aggregate = bpy.data.objects.new("Assembly", None)
        aggregate.location = context.scene.cursor.location
        bpy.ops.bim.assign_class(obj=aggregate.name, ifc_class=ifc_class)
        return aggregate
@@ -197,17 +190,12 @@ class BIM_OT_select_parts(bpy.types.Operator):

    def execute(self, context):
        self.file = IfcStore.get_file()
-        # obj = bpy.data.objects.get(self.obj) or context.active_object
-
-        for obj in context.selected_objects:
-            parts = ifcopenshell.util.element.get_parts(tool.Ifc.get_entity(obj))
-            if parts:
-                parts_objs = set(tool.Ifc.get_object(part) for part in parts)
-                selectable_parts_objs = set(context.selectable_objects).intersection(parts_objs)
-                for selectable_part_obj in selectable_parts_objs:
-                    selectable_part_obj.select_set(True)
-            else:
-                obj.select_set(False)
+        obj = bpy.data.objects.get(self.obj) or context.active_object
+        parts = ifcopenshell.util.element.get_parts(tool.Ifc.get_entity(obj))
+        parts_objs = set(tool.Ifc.get_object(part) for part in parts)
+        selectable_parts_objs = set(context.selectable_objects).intersection(parts_objs)
+        for selectable_part_obj in selectable_parts_objs:
+            selectable_part_obj.select_set(True)
        return {"FINISHED"}


@@ -229,43 +217,18 @@ class BIM_OT_select_aggregate(bpy.types.Operator):

    def execute(self, context):
        self.file = IfcStore.get_file()
-
-        # obj = bpy.data.objects.get(self.obj) or context.active_object
-        # aggregate = ifcopenshell.util.element.get_aggregate(tool.Ifc.get_entity(obj))
-        # aggregate_obj = tool.Ifc.get_object(aggregate)
-        
-        all_parts = []
-        for obj in context.selected_objects:
-            element = tool.Ifc.get_entity(obj)
-            if element:
-                aggregate = ifcopenshell.util.element.get_aggregate(element)
-                if aggregate:
-                    all_parts.append(aggregate)
-                    obj.select_set(False)
-                else:
-                    pass
-            if not element:
-                obj.select_set(False)
-        
+        obj = bpy.data.objects.get(self.obj) or context.active_object
+        aggregate = ifcopenshell.util.element.get_aggregate(tool.Ifc.get_entity(obj))
+        aggregate_obj = tool.Ifc.get_object(aggregate)
        if self.select_parts:
-            all_objs = []
-            for part in all_parts:
-                if part.IsDecomposedBy:
-                    for subpart in part.IsDecomposedBy[0].RelatedObjects:
-                        all_parts.append(subpart)
-                all_objs.append(part)
-
-            for element in all_objs:
-                obj = tool.Ifc.get_object(element)
-                if obj:
-                    obj.select_set(True)
-
-        else:
-            for aggregate_element in all_parts:
-                aggregate_obj = tool.Ifc.get_object(aggregate_element)
-                aggregate_obj.select_set(True)
-                bpy.context.view_layer.objects.active = aggregate_obj      
-
+            bpy.ops.bim.select_parts(obj=aggregate_obj.name)
+        if aggregate_obj in context.selectable_objects:
+            tool.Blender.set_objects_selection(
+                context,
+                aggregate_obj,
+                [aggregate_obj],
+                clear_previous_selection=not self.select_parts,
+            )
        return {"FINISHED"}


@@ -275,23 +238,23 @@ class BIM_OT_add_part_to_object(bpy.types.Operator, Operator):
    bl_options = {"REGISTER", "UNDO"}
    part_class: bpy.props.StringProperty(name="Class", options={"HIDDEN"})
    part_name: bpy.props.StringProperty(name="Name")
-    element: bpy.props.IntProperty(options={"HIDDEN"})
+    obj: bpy.props.StringProperty(options={"HIDDEN"})

    def invoke(self, context, event):
        self.part_name = "My " + self.part_class.lstrip("Ifc")
        return context.window_manager.invoke_props_dialog(self)

    def _execute(self, context):
+        obj = bpy.data.objects.get(self.obj) or context.active_object
        core.add_part_to_object(
            tool.Ifc,
            tool.Aggregate,
            tool.Collector,
            tool.Blender,
-            obj=tool.Ifc.get_object(tool.Ifc.get().by_id(self.element)) if self.element else context.active_object,
+            obj=obj,
            part_class=self.part_class,
            part_name=self.part_name,
        )
-        tool.Spatial.load_container_manager()


 class BIM_OT_break_link_to_other_aggregates(bpy.types.Operator, Operator):
@@ -320,7 +283,7 @@ class BIM_OT_break_link_to_other_aggregates(bpy.types.Operator, Operator):
            if r.is_a("IfcRelAssignsToGroup")
            if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
        ]
-        tool.Ifc.run("group.unassign_group", group=linked_aggregate_group[0], products=[aggregate])
+        tool.Ifc.run("group.unassign_group", group=linked_aggregate_group[0], product=aggregate)

        return {"FINISHED"}

@@ -329,51 +292,28 @@ class BIM_OT_select_linked_aggregates(bpy.types.Operator, Operator):
    bl_idname = "bim.select_linked_aggregates"
    bl_label = "Select linked aggregates"
    bl_options = {"REGISTER", "UNDO"}
-    select_parts: bpy.props.BoolProperty(default=False)
-
-    @classmethod
-    def description(cls, context, properties):
-        if properties.select_parts:
-            return "Select all aggregates, subaggregates and all their parts"
-        else:
-            return "Select all aggregates"

    def _execute(self, context):
-        
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        aggregate = ifcopenshell.util.element.get_aggregate(element)
+        if not aggregate:
+            return []
+        if not element:
+            return []
+
+        linked_aggregate_group = [
+            r.RelatingGroup
+            for r in getattr(aggregate, "HasAssignments", []) or []
+            if r.is_a("IfcRelAssignsToGroup")
+            if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
+        ]
+
        for obj in context.selected_objects:
            obj.select_set(False)
-            element = tool.Ifc.get_entity(obj)
-            aggregate = ifcopenshell.util.element.get_aggregate(element)
-            if not aggregate:
-                continue
-            if not element:
-                continue

-            linked_aggregate_group = [
-                r.RelatingGroup
-                for r in getattr(aggregate, "HasAssignments", []) or []
-                if r.is_a("IfcRelAssignsToGroup")
-                if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
-            ]
-
-            group_rel = linked_aggregate_group[0].IsGroupedBy or []
-            for group_link in group_rel:
-                parts = list(group_link.RelatedObjects)
-                if self.select_parts:
-                    parts_objs = []
-                    for part in parts:
-                        if part.IsDecomposedBy:
-                            for subpart in part.IsDecomposedBy[0].RelatedObjects:
-                                parts.append(subpart)
-                        parts_objs.append(part)
-
-                    for element in parts_objs:
-                        obj = tool.Ifc.get_object(element)
-                        if obj:
-                            obj.select_set(True)
-                else:
-                    for element in parts:
-                        obj = tool.Ifc.get_object(element)
-                        obj.select_set(True)
+        for rel in linked_aggregate_group[0].IsGroupedBy or []:
+            for element in rel.RelatedObjects:
+                obj = tool.Ifc.get_object(element)
+                obj.select_set(True)

        return {"FINISHED"}
@@ -34,27 +34,15 @@ from bpy.props import (

 def update_relating_object(self, context):
    def message(self, context):
-        self.layout.label(text="Please select a valid IFC Element")
+        self.layout.label(text="Please select a valid Ifc Element")

-    if self.relating_object:
-        self.related_object = None
-        if not self.relating_object.BIMObjectProperties.ifc_definition_id:
-            context.window_manager.popup_menu(message, title="Invalid Element Selected", icon="INFO")
-            self.relating_object = None
-
-
-def update_related_object(self, context):
-    def message(self, context):
-        self.layout.label(text="Please select a valid IFC Element")
-
-    if self.related_object:
+    if self.relating_object is None:
+        return
+    if not self.relating_object.BIMObjectProperties.ifc_definition_id:
+        context.window_manager.popup_menu(message, title="Invalid Element Selected", icon="INFO")
        self.relating_object = None
-        if not self.related_object.BIMObjectProperties.ifc_definition_id:
-            context.window_manager.popup_menu(message, title="Invalid Element Selected", icon="INFO")
-            self.related_object = None


 class BIMObjectAggregateProperties(PropertyGroup):
    is_editing: BoolProperty(name="Is Editing")
-    relating_object: PointerProperty(name="Relating Whole", type=bpy.types.Object, update=update_relating_object)
-    related_object: PointerProperty(name="Related Part", type=bpy.types.Object, update=update_related_object)
+    relating_object: PointerProperty(name="Aggregate", type=bpy.types.Object, update=update_relating_object)
@@ -20,7 +20,6 @@ from bpy.types import Panel
 from blenderbim.bim.module.aggregate.data import AggregateData
 from blenderbim.bim.module.group.data import GroupsData, ObjectGroupsData
 from blenderbim.bim.ifc import IfcStore
-import blenderbim.tool as tool


 class BIM_PT_aggregate(Panel):
@@ -53,21 +52,12 @@ class BIM_PT_aggregate(Panel):
        props = context.active_object.BIMObjectAggregateProperties

        if props.is_editing:
-            row = layout.row()
-            row.prop(props, "relating_object", text="Whole")
-            row = layout.row()
-            row.prop(props, "related_object", text="Or Part")
            row = layout.row(align=True)
-            col = row.column(align=True)
-            if not props.relating_object and not props.related_object:
-                col.enabled = False
-            op = col.operator("bim.aggregate_assign_object", icon="CHECKMARK")
+            row.prop(props, "relating_object", text="")
            if props.relating_object:
+                op = row.operator("bim.aggregate_assign_object", icon="CHECKMARK", text="")
                op.relating_object = props.relating_object.BIMObjectProperties.ifc_definition_id
-            elif props.related_object:
-                op.related_object = props.related_object.BIMObjectProperties.ifc_definition_id
            row.operator("bim.disable_editing_aggregate", icon="CANCEL", text="")
-            return
        else:
            row = layout.row(align=True)
            if AggregateData.data["has_relating_object"]:
@@ -82,7 +72,7 @@ class BIM_PT_aggregate(Panel):
                row.operator("bim.add_aggregate", icon="ADD", text="")
                op = row.operator("bim.aggregate_unassign_object", icon="X", text="")
            else:
-                row.label(text="No Whole Relationship Found", icon="TRIA_UP")
+                row.label(text="No Aggregate", icon="TRIA_UP")
                row.operator("bim.enable_editing_aggregate", icon="GREASEPENCIL", text="")
                row.operator("bim.add_aggregate", icon="ADD", text="")

@@ -99,6 +89,19 @@ class BIM_PT_aggregate(Panel):
            op = row.operator("bim.select_parts", icon="RESTRICT_SELECT_OFF", text="")
            op.obj = context.active_object.name

+        ifc_class = AggregateData.data["ifc_class"]
+        part_class = ""
+        if ifc_class == "IfcBuilding":
+            part_class = "IfcBuildingStorey"
+        elif ifc_class == "IfcSite":
+            part_class = "IfcBuilding"
+        elif ifc_class == "IfcProject":
+            part_class = "IfcSite"
+        if part_class != "":
+            op = layout.operator("bim.add_part_to_object", text="Add " + part_class.lstrip("Ifc"))
+            op.part_class = part_class
+            op.obj = context.active_object.name
+            
            
 class BIM_PT_linked_aggregate(Panel):
    bl_label = "Linked Aggregates"
@@ -128,29 +131,19 @@ class BIM_PT_linked_aggregate(Panel):
        if not AggregateData.is_loaded:
            AggregateData.load()

-        obj = context.active_object
-        element = tool.Ifc.get_entity(obj)
-        props = obj.BIMObjectAggregateProperties
+        props = context.active_object.BIMObjectAggregateProperties
        row = layout.row(align=True)
-
-
-        if element.Decomposes:
-            Number_Linked_Aggregates = AggregateData.data['total_linked_aggregate']
-            if not Number_Linked_Aggregates:
-                row.label(text="Not a Linked Aggregate")
-            else:
-                row.label(text=f"{Number_Linked_Aggregates} Linked Aggregates")
-            op = row.operator("bim.duplicate_linked_aggregate_to_3d_cursor", text="", icon="DUPLICATE")
-            if type(Number_Linked_Aggregates) is int:
-                if Number_Linked_Aggregates > 0:
-                    op = row.operator("bim.select_linked_aggregates", text="", icon="OUTLINER_DATA_POINTCLOUD")
-                    op.select_parts = False
-                    op = row.operator("bim.select_linked_aggregates", text="", icon="OUTLINER_OB_POINTCLOUD")
-                    op.select_parts = True
-                    row.operator("bim.refresh_linked_aggregate", text="", icon="FILE_REFRESH")
-                    op = row.operator("bim.break_link_to_other_aggregates", text="", icon="X")
+        row.label(text="Advanced Users Only", icon="ERROR")
+        row = layout.row(align=True)
+        
+        if type(AggregateData.data['total_linked_aggregate']) is int:
+            if AggregateData.data['total_linked_aggregate'] > 0:
+                row.label(text=f"{AggregateData.data['total_linked_aggregate']} Linked Aggregates")
+                row.operator("bim.select_linked_aggregates", text="", icon="RESTRICT_SELECT_OFF")
+                row.operator("bim.refresh_linked_aggregate", text="", icon="FILE_REFRESH")
+                op = row.operator("bim.break_link_to_other_aggregates", text="", icon="X")
        else:
-            row.label(text="Not an Aggregate")
+            row.label(text="No Linked Aggregates")
            
        

@@ -27,12 +27,15 @@ classes = (
    operator.CopyAttributeToSelection,
    prop.BIMAttributeProperties,
    ui.BIM_PT_object_attributes,
+    ui.BIM_PT_material_attributes,
 )


 def register():
    bpy.types.Object.BIMAttributeProperties = bpy.props.PointerProperty(type=prop.BIMAttributeProperties)
+    bpy.types.Material.BIMAttributeProperties = bpy.props.PointerProperty(type=prop.BIMAttributeProperties)


 def unregister():
    del bpy.types.Object.BIMAttributeProperties
+    del bpy.types.Material.BIMAttributeProperties
@@ -23,6 +23,7 @@ import blenderbim.tool as tool

 def refresh():
    AttributesData.is_loaded = False
+    MaterialAttributesData.is_loaded = False


 class AttributesData:
@@ -50,3 +51,28 @@ class AttributesData:
                key = "STEP ID"
            results.append({"name": key, "value": str(value)})
        return results
+
+
+class MaterialAttributesData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.data = {"ifc_definition_id": cls.ifc_definition_id(), "attributes": cls.attributes()}
+        cls.is_loaded = True
+
+    @classmethod
+    def ifc_definition_id(cls):
+        return bpy.context.active_object.active_material.BIMObjectProperties.ifc_definition_id
+
+    @classmethod
+    def attributes(cls):
+        results = []
+        element = tool.Ifc.get_entity(bpy.context.active_object.active_material)
+        data = element.get_info()
+        for key, value in data.items():
+            if value is None or isinstance(value, ifcopenshell.entity_instance) or key in ["id", "type"]:
+                continue
+            results.append({"name": key, "value": str(value)})
+        return results
@@ -20,7 +20,6 @@ import bpy
 import json
 import ifcopenshell
 import ifcopenshell.api
-import ifcopenshell.guid
 import blenderbim.bim.helper
 import blenderbim.bim.handler
 import blenderbim.tool as tool
@@ -40,22 +39,18 @@ class EnableEditingAttributes(bpy.types.Operator):
    bl_label = "Enable Editing Attributes"
    bl_options = {"REGISTER", "UNDO"}
    obj: bpy.props.StringProperty()
+    obj_type: bpy.props.StringProperty()

    def execute(self, context):
        self.file = IfcStore.get_file()
-        obj = bpy.data.objects.get(self.obj)
+        if self.obj_type == "Object":
+            obj = bpy.data.objects.get(self.obj)
+        elif self.obj_type == "Material":
+            obj = bpy.data.materials.get(self.obj)
+        oprops = obj.BIMObjectProperties
        props = obj.BIMAttributeProperties
        props.attributes.clear()

-        element = tool.Ifc.get_entity(obj)
-        has_inherited_predefined_type = False
-        if not element.is_a("IfcTypeObject") and (element_type := ifcopenshell.util.element.get_type(element)):
-            # Allow for None due to https://github.com/buildingSMART/IFC4.3.x-development/issues/818
-            has_inherited_predefined_type = ifcopenshell.util.element.get_predefined_type(element_type) not in (
-                "NOTDEFINED",
-                None,
-            )
-
        def callback(name, prop, data):
            if name in ("RefLatitude", "RefLongitude"):
                new = props.attributes.add()
@@ -67,11 +62,10 @@ class EnableEditingAttributes(bpy.types.Operator):
                new.string_value = "" if new.is_null else json.dumps(data[name])
                blenderbim.bim.helper.add_attribute_description(new)
                new.description += " The degrees, minutes and seconds should follow this format : [12,34,56]"
-            if name in ("PredefinedType", "ObjectType") and has_inherited_predefined_type:
-                props.attributes.remove(len(props.attributes) - 1)
-                return True

-        blenderbim.bim.helper.import_attributes2(element, props.attributes, callback=callback)
+        blenderbim.bim.helper.import_attributes2(
+            tool.Ifc.get().by_id(oprops.ifc_definition_id), props.attributes, callback=callback
+        )
        props.is_editing_attributes = True
        return {"FINISHED"}

@@ -81,9 +75,13 @@ class DisableEditingAttributes(bpy.types.Operator):
    bl_label = "Disable Editing Attributes"
    bl_options = {"REGISTER", "UNDO"}
    obj: bpy.props.StringProperty()
+    obj_type: bpy.props.StringProperty()

    def execute(self, context):
-        obj = bpy.data.objects.get(self.obj)
+        if self.obj_type == "Object":
+            obj = bpy.data.objects.get(self.obj)
+        elif self.obj_type == "Material":
+            obj = bpy.data.materials.get(self.obj)
        props = obj.BIMAttributeProperties
        props.is_editing_attributes = False
        return {"FINISHED"}
@@ -94,10 +92,14 @@ class EditAttributes(bpy.types.Operator, Operator):
    bl_label = "Edit Attributes"
    bl_options = {"REGISTER", "UNDO"}
    obj: bpy.props.StringProperty()
+    obj_type: bpy.props.StringProperty()

    def _execute(self, context):
        self.file = IfcStore.get_file()
-        obj = bpy.data.objects.get(self.obj)
+        if self.obj_type == "Object":
+            obj = bpy.data.objects.get(self.obj)
+        elif self.obj_type == "Material":
+            obj = bpy.data.materials.get(self.obj)
        props = obj.BIMAttributeProperties
        product = tool.Ifc.get_entity(obj)

@@ -114,50 +116,24 @@ class EditAttributes(bpy.types.Operator, Operator):

        attributes = blenderbim.bim.helper.export_attributes(props.attributes, callback=callback)
        ifcopenshell.api.run("attribute.edit_attributes", self.file, product=product, attributes=attributes)
-        bpy.ops.bim.disable_editing_attributes(obj=obj.name)
+        bpy.ops.bim.disable_editing_attributes(obj=obj.name, obj_type=self.obj_type)
        return {"FINISHED"}


-class GenerateGlobalId(bpy.types.Operator, Operator):
+class GenerateGlobalId(bpy.types.Operator):
    bl_idname = "bim.generate_global_id"
    bl_label = "Regenerate GlobalId"
-    bl_description = "Regenerate GlobalId\n\nSHIFT+CLICK to regenerate GlobalIds for all selected objects"
    bl_options = {"REGISTER", "UNDO"}

-    use_selected: bpy.props.BoolProperty(name="Use All Selected Objects", default=False, options={"SKIP_SAVE"})
-
-    def invoke(self, context, event):
-        # using all selected objects on shift+click
-        # make sure to use SKIP_SAVE on property, otherwise it might get stuck
-        if event.type == "LEFTMOUSE" and event.shift:
-            self.use_selected = True
-        return self.execute(context)
-
-    def _execute(self, context):
-        if self.use_selected:
-            for obj in context.selected_objects:
-                element = tool.Ifc.get_entity(obj)
-                if not element or not element.is_a("IfcRoot"):
-                    continue
-                element.GlobalId = ifcopenshell.guid.new()
-
-        obj = context.active_object
-        if not obj or not obj.BIMAttributeProperties.is_editing_attributes:
-            return {"FINISHED"}
-
-        props = obj.BIMAttributeProperties
-        element = tool.Ifc.get_entity(obj)
-
-        if not element.is_a("IfcRoot"):
-            return {"FINISHED"}
-
-        if self.use_selected and obj in context.selected_objects:
-            # guid value was already regenerated, just update the ui prop
-            guid_value = element.GlobalId
+    def execute(self, context):
+        index = context.active_object.BIMAttributeProperties.attributes.find("GlobalId")
+        if index >= 0:
+            global_id = context.active_object.BIMAttributeProperties.attributes[index]
        else:
-            guid_value = ifcopenshell.guid.new()
-
-        props.attributes["GlobalId"].string_value = guid_value
+            global_id = context.active_object.BIMAttributeProperties.attributes.add()
+        global_id.name = "GlobalId"
+        global_id.data_type = "string"
+        global_id.string_value = ifcopenshell.guid.new()
        return {"FINISHED"}


@@ -19,34 +19,34 @@
 import blenderbim.bim.helper
 from bpy.types import Panel
 from blenderbim.bim.ifc import IfcStore
-from blenderbim.bim.module.attribute.data import AttributesData
+from blenderbim.bim.module.attribute.data import AttributesData, MaterialAttributesData


-def draw_ui(context, layout, attributes):
-    obj = context.active_object
+def draw_ui(context, layout, obj_type, attributes):
+    obj = context.active_object if obj_type == "Object" else context.active_object.active_material
    oprops = obj.BIMObjectProperties
    props = obj.BIMAttributeProperties

    if props.is_editing_attributes:
        row = layout.row(align=True)
        op = row.operator("bim.edit_attributes", icon="CHECKMARK", text="Save Attributes")
+        op.obj_type = obj_type
        op.obj = obj.name
        op = row.operator("bim.disable_editing_attributes", icon="CANCEL", text="")
+        op.obj_type = obj_type
        op.obj = obj.name

        blenderbim.bim.helper.draw_attributes(props.attributes, layout, copy_operator="bim.copy_attribute_to_selection")
    else:
        row = layout.row()
        op = row.operator("bim.enable_editing_attributes", icon="GREASEPENCIL", text="Edit")
+        op.obj_type = obj_type
        op.obj = obj.name

        for attribute in attributes:
            row = layout.row(align=True)
            row.label(text=attribute["name"])
-            # row.label(text=attribute["value"])
-            op = row.operator("bim.select_similar", text=attribute["value"], icon="NONE", emboss=False)
-            op.key = attribute['name']
-            
+            row.label(text=attribute["value"])

    # TODO: reimplement, see #1222
    # if "IfcSite/" in context.active_object.name or "IfcBuilding/" in context.active_object.name:
@@ -72,4 +72,32 @@ class BIM_PT_object_attributes(Panel):
    def draw(self, context):
        if not AttributesData.is_loaded:
            AttributesData.load()
-        draw_ui(context, self.layout, AttributesData.data["attributes"])
+        draw_ui(context, self.layout, "Object", AttributesData.data["attributes"])
+
+
+class BIM_PT_material_attributes(Panel):
+    bl_label = "Material Attributes"
+    bl_idname = "BIM_PT_material_attributes"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "material"
+
+    @classmethod
+    def poll(cls, context):
+        if not IfcStore.get_file():
+            return False
+        try:
+            return bool(context.active_object.active_material.BIMObjectProperties.ifc_definition_id)
+        except:
+            return False
+
+    def draw(self, context):
+        if not MaterialAttributesData.is_loaded:
+            MaterialAttributesData.load()
+        elif (
+            context.active_object.active_material.BIMObjectProperties.ifc_definition_id
+            != MaterialAttributesData.data["ifc_definition_id"]
+        ):
+            MaterialAttributesData.load()
+
+        draw_ui(context, self.layout, "Material", MaterialAttributesData.data["attributes"])
@@ -938,7 +938,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.visualization_info.components.visibility.exceptions.component or []}
+        exception_global_ids = {v.ifc_guid for v in viewpoint.visualization_info.components.visibility.exceptions or []}

        if viewpoint.visualization_info.components.visibility.default_visibility:
            old = context.area.type
@@ -958,13 +958,11 @@ class ActivateBcfViewpoint(bpy.types.Operator):
            if objs:
                old = context.area.type
                context.area.type = "VIEW_3D"
-                bpy.ops.object.hide_view_clear()
                context_override = {}
                context_override["object"] = context_override["active_object"] = objs[0]
                context_override["selected_objects"] = context_override["selected_editable_objects"] = objs
                with context.temp_override(**context_override):
                    bpy.ops.object.hide_view_set(unselected=True)
-                    bpy.data.objects["Viewpoint"].hide_set(False)
                context.area.type = old

        if viewpoint.visualization_info.components.view_setup_hints:
@@ -1002,7 +1000,6 @@ class ActivateBcfViewpoint(bpy.types.Operator):
            obj = IfcStore.get_element(global_id)
            if obj:
                obj.select_set(True)
-                obj.hide_set(False)

    def set_colours(self, viewpoint):
        global_id_colours = {}
@@ -20,7 +20,6 @@ import bpy
 import bmesh
 import logging
 import shapely
-import shapely.ops
 import mathutils
 import numpy as np
 import multiprocessing
@@ -24,10 +24,10 @@ from math import pi

 class BIMCadProperties(PropertyGroup):
    resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
-    radius: bpy.props.FloatProperty(name="Radius", default=0.1, subtype="DISTANCE")
-    distance: bpy.props.FloatProperty(name="Distance", default=0.1, subtype="DISTANCE")
-    x: bpy.props.FloatProperty(name="X", default=0.2, subtype="DISTANCE")
-    y: bpy.props.FloatProperty(name="Y", default=0.1, subtype="DISTANCE")
+    radius: bpy.props.FloatProperty(name="Radius", default=0.1)
+    distance: bpy.props.FloatProperty(name="Distance", default=0.1)
+    x: bpy.props.FloatProperty(name="X", default=0.2)
+    y: bpy.props.FloatProperty(name="Y", default=0.1)
    gable_roof_edge_angle: bpy.props.FloatProperty(
        name="Gable Roof Edge Angle", default=pi / 2, soft_min=0, soft_max=pi / 2, subtype="ANGLE"
    )
@@ -20,7 +20,6 @@ import os
 import bpy
 import blenderbim.tool as tool
 import blenderbim.bim.module.type.prop as type_prop
-import ifcopenshell.util.unit
 from bpy.types import WorkSpaceTool
 from blenderbim.bim.module.model.data import AuthoringData, RailingData, RoofData

@@ -240,9 +239,8 @@ class CadHotkey(bpy.types.Operator):
                row.prop(props, "resolution")

    def hotkey_S_C(self):
-        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
        if self.is_profile():
-            bpy.ops.bim.add_ifccircle(radius=self.props.radius / si_conversion)
+            bpy.ops.bim.add_ifccircle(radius=self.props.radius)
        else:
            bpy.ops.bim.cad_arc_from_2_points()

@@ -250,15 +248,13 @@ class CadHotkey(bpy.types.Operator):
        bpy.ops.bim.cad_trim_extend()

    def hotkey_S_F(self):
-        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
        if self.is_profile():
-            bpy.ops.bim.add_ifcarcindex_fillet(radius=self.props.radius / si_conversion)
+            bpy.ops.bim.add_ifcarcindex_fillet(radius=self.props.radius)
        else:
-            bpy.ops.bim.cad_fillet(resolution=self.props.resolution, radius=self.props.radius / si_conversion)
+            bpy.ops.bim.cad_fillet(resolution=self.props.resolution, radius=self.props.radius)

    def hotkey_S_O(self):
-        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-        bpy.ops.bim.cad_offset(distance=self.props.distance / si_conversion)
+        bpy.ops.bim.cad_offset(distance=self.props.distance)

    def hotkey_S_Q(self):
        element = tool.Ifc.get_entity(bpy.context.active_object)
@@ -274,8 +270,7 @@ class CadHotkey(bpy.types.Operator):

    def hotkey_S_R(self):
        if self.is_profile():
-            si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-            bpy.ops.bim.add_rectangle(x=self.props.x / si_conversion, y=self.props.y / si_conversion)
+            bpy.ops.bim.add_rectangle(x=self.props.x, y=self.props.y)
        elif (
            (RoofData.is_loaded or not RoofData.load())
            and RoofData.data["pset_data"]
@@ -17,36 +17,138 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import bpy
-import json
-import ifcopenshell.util.element
+import ifcopenshell
+import ifcopenshell.util.date
+import ifcopenshell.util.classification
 import blenderbim.tool as tool
+from blenderbim.bim.ifc import IfcStore


 def refresh():
-    ClashData.is_loaded = False
+    ClassificationsData.is_loaded = False
+    ClassificationReferencesData.is_loaded = False
+    MaterialClassificationsData.is_loaded = False
+    CostClassificationsData.is_loaded = False


-class ClashData:
+class ClassificationsData:
    data = {}
    is_loaded = False

    @classmethod
    def load(cls):
        cls.is_loaded = True
-        cls.data = {}
-        cls.data["saved_searches"] = cls.saved_searches()
+        cls.data["has_classification_file"] = cls.has_classification_file()
+        cls.data["classifications"] = cls.classifications()
+        cls.data["available_classifications"] = cls.available_classifications()

    @classmethod
-    def saved_searches(cls):
-        if not tool.Ifc.get():
-            return []
-        groups = tool.Ifc.get().by_type("IfcGroup")
+    def has_classification_file(cls):
+        return bool(IfcStore.classification_file)
+
+    @classmethod
+    def classifications(cls):
        results = []
-        for group in groups:
-            try:
-                data = json.loads(group.Description)
-                if isinstance(data, dict) and data.get("type", None) == "BBIM_Search" and data.get("query", None):
-                    results.append(group)
-            except:
-                pass
-        return [(str(g.id()), g.Name or "Unnamed", "") for g in sorted(results, key=lambda x: x.Name or "Unnamed")]
+        for element in tool.Ifc.get().by_type("IfcClassification"):
+            data = element.get_info()
+            if tool.Ifc.get().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 active_classification_library(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
+        if name in [e.Name for e in tool.Ifc.get().by_type("IfcClassification")]:
+            return name
+
+    @classmethod
+    def classifications(cls):
+        return [(str(e.id()), 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["active_classification_library"] = cls.active_classification_library()
+        cls.data["classifications"] = cls.classifications()
+        cls.data["object_type"] = "OBJECT"
+
+    @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["active_classification_library"] = cls.active_classification_library()
+        cls.data["classifications"] = cls.classifications()
+        cls.data["object_type"] = "MATERIAL"
+
+    @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["active_classification_library"] = cls.active_classification_library()
+        cls.data["classifications"] = cls.classifications()
+        cls.data["object_type"] = "COST"
+
+    @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
@@ -16,37 +16,31 @@
 # 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 blf
 import gpu
 import bmesh
 import blenderbim.tool as tool
 from bpy.types import SpaceView3D
 from mathutils import Vector
 from gpu_extras.batch import batch_for_shader
-from bpy_extras.view3d_utils import location_3d_to_region_2d


 class ClashDecorator:
-    is_installed = False
-    handlers = []
+    installed = None

    @classmethod
    def install(cls, context):
-        if cls.is_installed:
+        if cls.installed:
            cls.uninstall()
        handler = cls()
-        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
-        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_geometry, (context,), "WINDOW", "POST_VIEW"))
-        cls.is_installed = True
+        cls.installed = SpaceView3D.draw_handler_add(handler, (context,), "WINDOW", "POST_VIEW")

    @classmethod
    def uninstall(cls):
-        for handler in cls.handlers:
-            try:
-                SpaceView3D.draw_handler_remove(handler, "WINDOW")
-            except ValueError:
-                pass
-        cls.is_installed = False
+        try:
+            SpaceView3D.draw_handler_remove(cls.installed, "WINDOW")
+        except ValueError:
+            pass
+        cls.installed = None

    def draw_batch(self, shader_type, content_pos, color, indices=None):
        shader = self.line_shader if shader_type == "LINES" else self.shader
@@ -54,27 +48,7 @@ class ClashDecorator:
        shader.uniform_float("color", color)
        batch.draw(shader)

-    def draw_text(self, context):
-        self.addon_prefs = context.preferences.addons["blenderbim"].preferences
-        selected_elements_color = self.addon_prefs.decorator_color_selected
-        unselected_elements_color = self.addon_prefs.decorator_color_unselected
-        special_elements_color = self.addon_prefs.decorator_color_special
-
-        text = context.scene.BIMClashProperties.active_clash_text
-        p = context.scene.BIMClashProperties.p1.lerp(context.scene.BIMClashProperties.p2, 0.5)
-
-        font_id = 0
-        blf.size(font_id, 12)
-        coords_2d = location_3d_to_region_2d(context.region, context.region_data, p)
-        color = self.addon_prefs.decorations_colour
-        blf.color(font_id, *color)
-        if coords_2d:
-            w, h = blf.dimensions(font_id, text)
-            coords_2d -= Vector((w * .5, 0))
-            blf.position(font_id, coords_2d[0], coords_2d[1], 0)
-            blf.draw(font_id, text)  # Set your text here
-
-    def draw_geometry(self, context):
+    def __call__(self, context):
        self.addon_prefs = context.preferences.addons["blenderbim"].preferences
        selected_elements_color = self.addon_prefs.decorator_color_selected
        unselected_elements_color = self.addon_prefs.decorator_color_unselected
@@ -69,7 +69,6 @@ class ImportClashSets(bpy.types.Operator):

    def execute(self, context):
        tool.Clash.load_clash_sets(self.filepath)
-        context.scene.BIMClashProperties.clash_sets.clear()
        for clash_set in tool.Clash.get_clash_sets():
            new = context.scene.BIMClashProperties.clash_sets.add()
            new.name = clash_set["name"]
@@ -86,14 +85,14 @@ class ImportClashSets(bpy.types.Operator):
                new_source = new.a.add()
                new_source.name = clash_source["file"]
                if "selector" in clash_source:
-                    tool.Search.import_filter_query(clash_source["selector"], new_source.filter_groups)
+                    new_source.selector = clash_source["selector"]
                    new_source.mode = clash_source["mode"]
            if "b" in clash_set and clash_set["b"]:
                for clash_source in clash_set["b"]:
                    new_source = new.b.add()
                    new_source.name = clash_source["file"]
                    if "selector" in clash_source:
-                        tool.Search.import_filter_query(clash_source["selector"], new_source.filter_groups)
+                        new_source.selector = clash_source["selector"]
                        new_source.mode = clash_source["mode"]
        tool.Clash.import_active_clashes()
        return {"FINISHED"}
@@ -209,11 +208,8 @@ class ExecuteIfcClash(bpy.types.Operator):

    def invoke(self, context, event):
        _, extension = os.path.splitext(self.filepath)
-        if extension != ".bcf":
-            self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".json")
-        # TODO Temporarily until BCF support comes back
-        # if extension != ".json":
-        #     self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".bcf")
+        if extension != ".json":
+            self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".bcf")
        WindowManager = context.window_manager
        WindowManager.fileselect_add(self)
        return {"RUNNING_MODAL"}
@@ -224,9 +220,6 @@ class ExecuteIfcClash(bpy.types.Operator):
        self.props = context.scene.BIMClashProperties

        _, extension = os.path.splitext(self.filepath)
-        if extension != ".bcf":
-            self.filepath = bpy.path.ensure_ext(self.filepath, ".json")
-        # TODO Temporarily until BCF support comes back
        if extension != ".json":
            self.filepath = bpy.path.ensure_ext(self.filepath, ".bcf")

@@ -283,7 +276,14 @@ class ExecuteIfcClash(bpy.types.Operator):

        if extension == ".json":
            tool.Clash.load_clash_sets(self.filepath)
-            tool.Clash.import_active_clashes()
+            result = tool.Clash.get_clash_set(self.props.active_clash_set.name)
+            for clash in result["clashes"].values():
+                blender_clash = self.props.active_clash_set.clashes.add()
+                blender_clash.a_global_id = clash["a_global_id"]
+                blender_clash.b_global_id = clash["b_global_id"]
+                blender_clash.a_name = "{}/{}".format(clash["a_ifc_class"], clash["a_name"])
+                blender_clash.b_name = "{}/{}".format(clash["b_ifc_class"], clash["b_name"])
+                blender_clash.status = False if not "status" in clash.keys() else clash["status"]
        return {"FINISHED"}


@@ -379,7 +379,6 @@ class SelectClash(bpy.types.Operator):
        tool.Clash.look_at(target, target + Vector((5, 5, 5)))
        self.props.p1 = clash["p1"]
        self.props.p2 = clash["p2"]
-        self.props.active_clash_text = clash["type"].title() + " " + str(round(clash["distance"] * 1000)) + "mm"
        return {"FINISHED"}


@@ -17,7 +17,7 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import bpy
-from blenderbim.bim.prop import StrProperty, Attribute, BIMFilterGroup
+from blenderbim.bim.prop import StrProperty, Attribute
 from bpy.types import PropertyGroup
 from bpy.props import (
    PointerProperty,
@@ -33,12 +33,11 @@ from bpy.props import (

 class ClashSource(PropertyGroup):
    name: StringProperty(name="File")
-    filter_groups: CollectionProperty(type=BIMFilterGroup, name="Filter Groups")
+    selector: StringProperty(name="Selector")
    mode: EnumProperty(
        items=[
-            ("a", "All Elements", "All elements will be used for clashing"),
-            ("i", "Include", "Only the selected elements are included for clashing"),
-            ("e", "Exclude", "All elements except the selected elements are included for clashing"),
+            ("i", "Include", "Only the selected objects are included for clashing"),
+            ("e", "Exclude", "All objects except the selected objects are included for clashing"),
        ],
        name="Mode",
    )
@@ -98,7 +97,6 @@ class BIMClashProperties(PropertyGroup):
    )
    p1: FloatVectorProperty(name="P1", default=(0.0, 0.0, 0.0), subtype="XYZ")
    p2: FloatVectorProperty(name="P2", default=(0.0, 0.0, 0.0), subtype="XYZ")
-    active_clash_text: StringProperty(name="Active Clash Text")

    @property
    def active_clash_set(self):
@@ -17,9 +17,7 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import bpy
-import blenderbim.bim.helper
 from bpy.types import Panel
-from blenderbim.bim.module.clash.data import ClashData


 class BIM_PT_ifcclash(Panel):
@@ -32,9 +30,6 @@ class BIM_PT_ifcclash(Panel):
    bl_parent_id = "BIM_PT_tab_clash_detection"

    def draw(self, context):
-        if not ClashData.is_loaded:
-            ClashData.load()
-
        layout = self.layout

        scene = context.scene
@@ -83,7 +78,6 @@ class BIM_PT_ifcclash(Panel):
        for index, source in enumerate(clash_set.a):
            row = layout.row(align=True)
            row.prop(source, "name", text="")
-            row.prop(source, "mode", text="")
            op = row.operator("bim.select_clash_source", icon="FILE_FOLDER", text="")
            op.index = index
            op.group = "a"
@@ -91,10 +85,9 @@ class BIM_PT_ifcclash(Panel):
            op.index = index
            op.group = "a"

-            if source.mode != "a":
-                blenderbim.bim.helper.draw_filter(
-                    layout, source.filter_groups, ClashData, f"clash_{props.active_clash_set_index}_a_{index}"
-                )
+            row = layout.row(align=True)
+            row.prop(source, "mode", text="")
+            row.prop(source, "selector", text="")

        row = layout.row(align=True)
        row.label(text="Group B:", icon="OUTLINER_OB_POINTCLOUD")
@@ -103,7 +96,6 @@ class BIM_PT_ifcclash(Panel):
        for index, source in enumerate(clash_set.b):
            row = layout.row(align=True)
            row.prop(source, "name", text="")
-            row.prop(source, "mode", text="")
            op = row.operator("bim.select_clash_source", icon="FILE_FOLDER", text="")
            op.index = index
            op.group = "b"
@@ -111,10 +103,9 @@ class BIM_PT_ifcclash(Panel):
            op.index = index
            op.group = "b"

-            if source.mode != "a":
-                blenderbim.bim.helper.draw_filter(
-                    layout, source.filter_groups, ClashData, f"clash_{props.active_clash_set_index}_b_{index}"
-                )
+            row = layout.row(align=True)
+            row.prop(source, "mode", text="")
+            row.prop(source, "selector", text="")

        row = layout.row()
        row.prop(props, "should_create_clash_snapshots")
@@ -54,11 +54,11 @@ classes = (

 def register():
    bpy.types.Scene.BIMClassificationProperties = bpy.props.PointerProperty(type=prop.BIMClassificationProperties)
-    bpy.types.Scene.BIMClassificationReferenceProperties = bpy.props.PointerProperty(
+    bpy.types.Object.BIMClassificationReferenceProperties = bpy.props.PointerProperty(
        type=prop.BIMClassificationReferenceProperties
    )


 def unregister():
    del bpy.types.Scene.BIMClassificationProperties
-    del bpy.types.Scene.BIMClassificationReferenceProperties
+    del bpy.types.Object.BIMClassificationReferenceProperties
@@ -88,7 +88,7 @@ class ClassificationReferencesData(ReferencesData):
        cls.data["references"] = cls.references()
        cls.data["active_classification_library"] = cls.active_classification_library()
        cls.data["classifications"] = cls.classifications()
-        cls.data["object_type"] = "Object"
+        cls.data["object_type"] = "OBJECT"

    @classmethod
    def references(cls):
@@ -112,21 +112,17 @@ class MaterialClassificationsData(ReferencesData):
        cls.data["references"] = cls.references()
        cls.data["active_classification_library"] = cls.active_classification_library()
        cls.data["classifications"] = cls.classifications()
-        cls.data["object_type"] = "Material"
+        cls.data["object_type"] = "MATERIAL"

    @classmethod
    def references(cls):
        results = []
-
-        props = bpy.context.scene.BIMMaterialProperties
-        if props.materials and props.active_material_index < len(props.materials):
-            material = props.materials[props.active_material_index]
-            if material.ifc_definition_id:
-                element = tool.Ifc.get().by_id(material.ifc_definition_id)
-                for reference in ifcopenshell.util.classification.get_references(element):
-                    data = reference.get_info()
-                    del data["ReferencedSource"]
-                    results.append(data)
+        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


@@ -140,7 +136,7 @@ class CostClassificationsData(ReferencesData):
        cls.data["references"] = cls.references()
        cls.data["active_classification_library"] = cls.active_classification_library()
        cls.data["classifications"] = cls.classifications()
-        cls.data["object_type"] = "Cost"
+        cls.data["object_type"] = "COST"

    @classmethod
    def references(cls):
@@ -20,8 +20,6 @@ import bpy
 import json
 import ifcopenshell
 import ifcopenshell.api
-import ifcopenshell.util.classification
-import ifcopenshell.util.element
 import blenderbim.tool as tool
 import blenderbim.bim.helper
 from blenderbim.bim.ifc import IfcStore
@@ -77,37 +75,26 @@ class AddManualClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_manual_classification_reference"
    bl_label = "Add Manual Classification Reference"
    bl_options = {"REGISTER", "UNDO"}
-    obj: bpy.props.StringProperty()
    obj_type: bpy.props.StringProperty()

    def _execute(self, context):
-        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.BIMClassificationReferenceProperties
+        obj = context.active_object
+        props = obj.BIMClassificationReferenceProperties
        attributes = blenderbim.bim.helper.export_attributes(props.reference_attributes)
-        products = [
-            tool.Ifc.get().by_id(ifc_definition_id)
-            for obj in objects
-            if (ifc_definition_id := tool.Blender.get_obj_ifc_definition_id(obj, self.obj_type, context))
-        ]
-        if products:
-            classification = tool.Ifc.get().by_id(int(props.classifications))
-            reference = ifcopenshell.api.run(
-                "classification.add_reference",
-                tool.Ifc.get(),
-                products=products,
-                classification=classification,
-                identification="X",
-                name="Unnamed",
-            )
-            ifcopenshell.api.run(
-                "classification.edit_reference", tool.Ifc.get(), reference=reference, attributes=attributes
-            )
+        product = tool.Ifc.get_entity(obj)
+        # TODO: refactor and support material and cost item classifications
+        classification = tool.Ifc.get().by_id(int(props.classifications))
+        reference = ifcopenshell.api.run(
+            "classification.add_reference",
+            tool.Ifc.get(),
+            product=product,
+            classification=classification,
+            identification="X",
+            name="Unnamed",
+        )
+        ifcopenshell.api.run(
+            "classification.edit_reference", tool.Ifc.get(), reference=reference, attributes=attributes
+        )
        props.is_adding = False


@@ -161,7 +148,8 @@ class EnableAddingManualClassificationReference(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}

    def execute(self, context):
-        props = context.scene.BIMClassificationReferenceProperties
+        obj = context.active_object
+        props = obj.BIMClassificationReferenceProperties
        props.is_adding = True
        props.reference_attributes.clear()
        blenderbim.bim.helper.import_attributes2("IfcClassificationReference", props.reference_attributes)
@@ -174,7 +162,8 @@ class DisableAddingManualClassificationReference(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}

    def execute(self, context):
-        props = context.scene.BIMClassificationReferenceProperties
+        obj = context.active_object
+        props = obj.BIMClassificationReferenceProperties
        props.is_adding = False
        return {"FINISHED"}

@@ -218,10 +207,6 @@ class DisableEditingClassification(bpy.types.Operator):
 class RemoveClassification(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.remove_classification"
    bl_label = "Remove Classification"
-    bl_description = (
-        "The classification and all of its relationships, children references, "
-        "and relationships between objects and child references will be completely removed from a project"
-    )
    bl_options = {"REGISTER", "UNDO"}
    classification: bpy.props.IntProperty()

@@ -266,7 +251,8 @@ class EnableEditingClassificationReference(bpy.types.Operator):
    obj: bpy.props.StringProperty()

    def execute(self, context):
-        props = context.scene.BIMClassificationReferenceProperties
+        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
+        props = obj.BIMClassificationReferenceProperties
        props.reference_attributes.clear()
        blenderbim.bim.helper.import_attributes2(tool.Ifc.get().by_id(self.reference), props.reference_attributes)
        props.active_reference_id = self.reference
@@ -280,7 +266,8 @@ class DisableEditingClassificationReference(bpy.types.Operator):
    obj: bpy.props.StringProperty()

    def execute(self, context):
-        context.scene.BIMClassificationReferenceProperties.active_reference_id = 0
+        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
+        obj.BIMClassificationReferenceProperties.active_reference_id = 0
        return {"FINISHED"}


@@ -305,7 +292,6 @@ class RemoveClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
        active_reference = tool.Ifc.get().by_id(self.reference)
        identification = active_reference[1]

-        elements_by_references: dict[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]] = {}
        for obj in objects:
            ifc_definition_id = tool.Blender.get_obj_ifc_definition_id(obj, self.obj_type, context)
            element = tool.Ifc.get().by_id(ifc_definition_id)
@@ -314,16 +300,12 @@ class RemoveClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
                if (identification and reference[1] == identification) or (
                    not identification and reference == active_reference
                ):
-                    elements_by_references.setdefault(reference, []).append(element)
-
-        if elements_by_references:
-            for reference, products in elements_by_references.items():
-                ifcopenshell.api.run(
-                    "classification.remove_reference",
-                    tool.Ifc.get(),
-                    reference=reference,
-                    products=products,
-                )
+                    ifcopenshell.api.run(
+                        "classification.remove_reference",
+                        tool.Ifc.get(),
+                        reference=reference,
+                        product=element,
+                    )


 class EditClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
@@ -333,7 +315,8 @@ class EditClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
    obj: bpy.props.StringProperty()

    def _execute(self, context):
-        props = context.scene.BIMClassificationReferenceProperties
+        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
+        props = obj.BIMClassificationReferenceProperties
        attributes = {}
        for attribute in props.reference_attributes:
            if attribute.is_null:
@@ -374,17 +357,15 @@ class AddClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
                classification = element
                break

-        products = [
-            tool.Ifc.get().by_id(ifc_definition_id)
-            for obj in objects
-            if (ifc_definition_id := tool.Blender.get_obj_ifc_definition_id(obj, self.obj_type, context))
-        ]
-        if products:
+        for obj in objects:
+            ifc_definition_id = tool.Blender.get_obj_ifc_definition_id(obj, self.obj_type, context)
+            if not ifc_definition_id:
+                continue
            ifcopenshell.api.run(
                "classification.add_reference",
                tool.Ifc.get(),
                reference=IfcStore.classification_file.by_id(self.reference),
-                products=products,
+                product=tool.Ifc.get().by_id(ifc_definition_id),
                classification=classification,
            )

@@ -432,7 +413,7 @@ class AddClassificationReferenceFromBSDD(bpy.types.Operator, tool.Ifc.Operator):
            reference = ifcopenshell.api.run(
                "classification.add_reference",
                tool.Ifc.get(),
-                products=[element],
+                product=element,
                classification=classification,
                identification=bsdd_classification.reference_code,
                name=bsdd_classification.name,
@@ -118,9 +118,10 @@ class BIM_PT_classifications(Panel):
 class ReferenceUI:
    def draw_ui(self, context):
        obj = context.active_object
+        self.oprops = obj.BIMObjectProperties
        self.sprops = context.scene.BIMClassificationProperties
        self.bprops = context.scene.BIMBSDDProperties
-        self.props = context.scene.BIMClassificationReferenceProperties
+        self.props = obj.BIMClassificationReferenceProperties
        self.file = IfcStore.get_file()

        self.draw_add_ui(context)
@@ -154,7 +155,7 @@ class ReferenceUI:
            blenderbim.bim.helper.draw_attributes(self.props.reference_attributes, self.layout)
            row = self.layout.row(align=True)
            op = row.operator("bim.add_manual_classification_reference", text="Save", icon="CHECKMARK")
-            op.obj_type = self.data.data["object_type"]
+            op.type = self.data.data["object_type"]
            row.operator("bim.disable_adding_manual_classification_reference", text="", icon="CANCEL")
        else:
            row = self.layout.row()
@@ -294,31 +295,28 @@ class BIM_PT_material_classifications(Panel, ReferenceUI):
    bl_options = {"DEFAULT_CLOSED"}
    bl_space_type = "PROPERTIES"
    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_materials"
+    bl_context = "material"

    @classmethod
    def poll(cls, context):
        if not tool.Ifc.get():
            return False
-        props = context.scene.BIMMaterialProperties
-        if props.materials and props.active_material_index < len(props.materials):
-            material = props.materials[props.active_material_index]
-            if material.ifc_definition_id:
-                return True
-        return False
+        try:
+            return bool(context.active_object.active_material.BIMObjectProperties.ifc_definition_id)
+        except:
+            return False

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


 class BIM_PT_cost_classifications(Panel, ReferenceUI):
-    bl_label = "Cost Item Classifications"
+    bl_label = "Cost Classifications"
    bl_idname = "BIM_PT_cost_classifications"
    bl_options = {"DEFAULT_CLOSED"}
    bl_space_type = "PROPERTIES"
@@ -114,7 +114,7 @@ class EditObjective(bpy.types.Operator):
        ifcopenshell.api.run(
            "constraint.edit_objective",
            self.file,
-            **{"objective": self.file.by_id(props.active_constraint_id), "attributes": attributes},
+            **{"objective": self.file.by_id(props.active_constraint_id), "attributes": attributes}
        )
        bpy.ops.bim.load_objectives()
        return {"FINISHED"}
@@ -179,17 +179,19 @@ class AssignConstraint(bpy.types.Operator):
        return IfcStore.execute_ifc_operator(self, context)

    def _execute(self, context):
-        self.file = tool.Ifc.get()
+        self.file = IfcStore.get_file()
        objs = [bpy.data.objects.get(self.obj)] if self.obj else context.selected_objects
-        products = [self.file.by_id(obj_id) for obj in objs if (obj_id := obj.BIMObjectProperties.ifc_definition_id)]
-        if products:
+        for obj in objs:
+            obj_id = obj.BIMObjectProperties.ifc_definition_id
+            if not obj_id:
+                continue
            ifcopenshell.api.run(
                "constraint.assign_constraint",
                self.file,
                **{
-                    "products": products,
+                    "product": self.file.by_id(obj_id),
                    "constraint": self.file.by_id(self.constraint),
-                },
+                }
            )
        return {"FINISHED"}

@@ -205,16 +207,18 @@ class UnassignConstraint(bpy.types.Operator):
        return IfcStore.execute_ifc_operator(self, context)

    def _execute(self, context):
-        self.file = tool.Ifc.get()
+        self.file = IfcStore.get_file()
        objs = [bpy.data.objects.get(self.obj)] if self.obj else context.selected_objects
-        products = [self.file.by_id(obj_id) for obj in objs if (obj_id := obj.BIMObjectProperties.ifc_definition_id)]
-        if products:
+        for obj in objs:
+            obj_id = obj.BIMObjectProperties.ifc_definition_id
+            if not obj_id:
+                continue
            ifcopenshell.api.run(
                "constraint.unassign_constraint",
                self.file,
                **{
-                    "products": products,
+                    "product": self.file.by_id(obj_id),
                    "constraint": self.file.by_id(self.constraint),
-                },
+                }
            )
        return {"FINISHED"}
@@ -53,10 +53,6 @@ class AddContext(bpy.types.Operator, Operator):
 class RemoveContext(bpy.types.Operator, Operator):
    bl_idname = "bim.remove_context"
    bl_label = "Remove Context"
-    bl_description = (
-        "Remove representation context. Any representation geometry that is assigned to the context is also removed. "
-        "If a context is removed, then any subcontexts are also removed"
-    )
    bl_options = {"REGISTER", "UNDO"}
    context: bpy.props.IntProperty()

@@ -82,7 +82,6 @@ classes = (
    prop.CostItem,
    prop.CostItemQuantity,
    prop.CostItemType,
-    prop.ScheduleColumn,
    prop.BIMCostProperties,
    ui.BIM_PT_cost_schedules,
    ui.BIM_PT_cost_item_quantities,
@@ -19,13 +19,10 @@
 import bpy
 import ifcopenshell
 import ifcopenshell.util.cost
-import ifcopenshell.util.date
 import ifcopenshell.util.element
-import ifcopenshell.util.unit
 import blenderbim.tool as tool
 import blenderbim.bim.schema
 from ifcopenshell.util.doc import get_entity_doc, get_predefined_type_doc
-from typing import Any


 def refresh():
@@ -37,7 +34,6 @@ def refresh():
 class CostSchedulesData:
    data = {}
    is_loaded = False
-    _cost_values: dict[int, dict[str, Any]]

    @classmethod
    def load(cls):
@@ -140,7 +136,7 @@ class CostSchedulesData:
                data["UnitBasisUnitSymbol"] = "U"
            if cost_value.Category == "*":
                is_sum = True
-        cost_quantity = 1 if data["TotalCostQuantity"] is None else data["TotalCostQuantity"]
+        cost_quantity = data["TotalCostQuantity"] or 1
        if has_unit_basis:
            data["TotalCost"] = data["TotalAppliedValue"] * cost_quantity / data["UnitBasisValueComponent"]
        else:
@@ -159,7 +155,6 @@ class CostSchedulesData:
        data["UnitSymbol"] = "-"
        if cost_item.CostQuantities:
            quantity = cost_item.CostQuantities[0]
-            data["QuantityType"] = quantity.is_a()
            unit = ifcopenshell.util.unit.get_property_unit(quantity, tool.Ifc.get())
            if unit:
                data["UnitSymbol"] = ifcopenshell.util.unit.get_unit_symbol(unit)
@@ -198,16 +193,10 @@ class CostSchedulesData:
        #             data["DerivedUnitSymbol"] = "?"
        #         print("Total Cost", data["DerivedTotalCostQuantity"], cost_item.Name)

-    # TODO: dead code?
    @classmethod
-    def _get_object_quantities(
-        cls, cost_item: ifcopenshell.entity_instance, element: ifcopenshell.entity_instance
-    ) -> list[int]:
+    def _get_object_quantities(cls, cost_item, element):
        if not element.is_a("IfcObject"):
            return []
-        cost_quantities = cost_item.CostQuantities
-        if not cost_quantities:
-            return []
        results = []
        for relationship in element.IsDefinedBy:
            if not relationship.is_a("IfcRelDefinesByProperties"):
@@ -216,7 +205,7 @@ class CostSchedulesData:
            if not qto.is_a("IfcElementQuantity"):
                continue
            for prop in qto.Quantities:
-                if prop in cost_quantities:
+                if prop in cost_item.CostQuantities or []:
                    results.append(prop.id())
        return results

@@ -73,7 +73,7 @@ class RemoveCostSchedule(bpy.types.Operator, tool.Ifc.Operator):
    cost_schedule: bpy.props.IntProperty()

    def _execute(self, context):
-        core.remove_cost_schedule(tool.Ifc, tool.Cost, cost_schedule=tool.Ifc.get().by_id(self.cost_schedule))
+        core.remove_cost_schedule(tool.Ifc, cost_schedule=tool.Ifc.get().by_id(self.cost_schedule))


 class EnableEditingCostSchedule(bpy.types.Operator):
@@ -223,40 +223,36 @@ class EditCostItem(bpy.types.Operator, tool.Ifc.Operator):

 class AssignCostItemType(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.assign_cost_item_type"
-    bl_label = "Assign Cost Item To Product Types"
-    bl_description = "Assign cost item to currently selected or active product types"
+    bl_label = "Assign Cost Item Type Product"
    bl_options = {"REGISTER", "UNDO"}
    cost_item: bpy.props.IntProperty()
    prop_name: bpy.props.StringProperty()

    def _execute(self, context):
-        product_types = core.assign_cost_item_type(
+        core.assign_cost_item_type(
            tool.Ifc,
            tool.Cost,
            tool.Spatial,
            cost_item=tool.Ifc.get().by_id(self.cost_item),
            prop_name=self.prop_name,  # TODO: REVIEW PROP_NAME USABILITY
        )
-        self.report({"INFO"}, f"Cost item was assigned to {len(product_types)} product types.")


 class UnassignCostItemType(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.unassign_cost_item_type"
    bl_label = "Unassign Cost Item Type"
-    bl_description = "Unassign cost item from currently selected or active product types"
    bl_options = {"REGISTER", "UNDO"}
    cost_item: bpy.props.IntProperty()
    related_object: bpy.props.IntProperty()

    def _execute(self, context):
-        product_types = core.unassign_cost_item_type(
+        core.unassign_cost_item_type(
            tool.Ifc,
            tool.Cost,
            tool.Spatial,
            cost_item=tool.Ifc.get().by_id(self.cost_item),
-            product_types=[tool.Ifc.get().by_id(self.related_object)] if self.related_object else None,
+            product_types=[tool.Ifc.get().by_id(self.related_object)] if self.related_object else [],
        )
-        self.report({"INFO"}, f"Cost item was unassigned from {len(product_types)} product types.")
        return {"FINISHED"}


@@ -291,11 +287,9 @@ class UnassignCostItemQuantity(bpy.types.Operator, tool.Ifc.Operator):
            tool.Ifc,
            tool.Cost,
            cost_item=tool.Ifc.get().by_id(self.cost_item),
-            products=(
-                [tool.Ifc.get().by_id(self.related_object)]
-                if self.related_object
-                else tool.Spatial.get_selected_products()
-            ),
+            products=[tool.Ifc.get().by_id(self.related_object)]
+            if self.related_object
+            else tool.Spatial.get_selected_products(),
        )


@@ -515,7 +509,7 @@ class SelectCostScheduleProducts(bpy.types.Operator):


 class ImportCostScheduleCsv(bpy.types.Operator, ImportHelper, tool.Ifc.Operator):
-    bl_idname = "bim.import_cost_schedule_csv"
+    bl_idname = "import_cost_schedule_csv.bim"
    bl_label = "Import Cost Schedule CSV"
    bl_options = {"REGISTER", "UNDO"}
    filename_ext = ".csv"
@@ -533,13 +527,6 @@ class AddCostColumn(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}
    name: bpy.props.StringProperty()

-    @classmethod
-    def poll(cls, context):
-        if not context.scene.BIMCostProperties.cost_column:
-            cls.poll_message_set("Cost column name is empty")
-            return False
-        return True
-
    def execute(self, context):
        core.add_cost_column(tool.Cost, self.name)
        return {"FINISHED"}
@@ -551,7 +538,7 @@ class RemoveCostColumn(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}
    name: bpy.props.StringProperty()

-    def execute(self, context):
+    def _execute(self, context):
        core.remove_cost_column(tool.Cost, self.name)
        return {"FINISHED"}

@@ -669,17 +656,13 @@ class ExportCostSchedules(bpy.types.Operator):
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Export a cost schedule to a CSV, XSLX OR ODS file"
    cost_schedule: bpy.props.IntProperty()
-    format: bpy.props.EnumProperty(name="Format", items=(("CSV", "CSV", ""), ("XLSX", "XLSX", ""), ("ODS", "ODS", "")))
-    directory: bpy.props.StringProperty(subtype="FILE_PATH")
-    filter_folder: bpy.props.BoolProperty(
-        name="Filter Folders",
-        default=True,
-    )
+    format: bpy.props.EnumProperty("Format", items=(("CSV", "CSV", ""), ("XLSX", "XLSX", ""), ("ODS", "ODS", "")))
+    filepath: bpy.props.StringProperty(subtype="FILE_PATH")

    def execute(self, context):
        cost_schedule = tool.Ifc.get().by_id(self.cost_schedule) if self.cost_schedule else None
        r = core.export_cost_schedules(
-            tool.Cost, filepath=self.directory, format=self.format, cost_schedule=cost_schedule
+            tool.Cost, filepath=self.filepath, format=self.format, cost_schedule=cost_schedule
        )
        if isinstance(r, str):
            self.report({"ERROR"}, r)
@@ -693,7 +676,6 @@ class ExportCostSchedules(bpy.types.Operator):
    def draw(self, context):
        self.layout.label(text="Choose a format")
        self.layout.prop(self, "format")
-        self.layout.label(text="Select a directory.")


 class ClearCostItemAssignments(bpy.types.Operator, tool.Ifc.Operator):
@@ -175,10 +175,6 @@ def update_active_cost_item_resources(self, context):
    bpy.ops.bim.load_cost_item_resource_quantities()


-class ScheduleColumn(PropertyGroup):
-    schedule_id: IntProperty()
-
-
 class BIMCostProperties(PropertyGroup):
    cost_schedule_predefined_types: EnumProperty(
        items=get_schedule_predefined_types, name="Predefined Type", default=None
@@ -214,14 +210,9 @@ class BIMCostProperties(PropertyGroup):
    cost_value_attributes: CollectionProperty(name="Cost Value Attributes", type=Attribute)
    cost_value_formula: StringProperty(name="Cost Value Formula")
    cost_column: StringProperty(name="Cost Column")
-    should_show_column_ui: BoolProperty(
-        name="Should Show Column UI",
-        description="Display UI for adding cost schedule columns, column names represent a category for cost item values",
-        default=False,
-    )
+    should_show_column_ui: BoolProperty(name="Should Show Column UI", default=False)
    should_show_currency_ui: BoolProperty(name="Should Show Currency UI", default=False)
-    columns: CollectionProperty(name="Active Schedule Columns", type=StrProperty)
-    columns_storage: CollectionProperty(name="Columns", type=ScheduleColumn)
+    columns: CollectionProperty(name="Columns", type=StrProperty)
    active_column_index: IntProperty(name="Active Column Index")
    cost_item_products: CollectionProperty(name="Cost Item Products", type=CostItemQuantity)
    active_cost_item_product_index: IntProperty(name="Active Cost Item Product Index")
@@ -21,7 +21,6 @@ import blenderbim.bim.module.cost.prop as CostProp
 from bpy.types import Panel, UIList
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.cost.data import CostSchedulesData
-from typing import Any


 class BIM_PT_cost_schedules(Panel):
@@ -54,7 +53,7 @@ class BIM_PT_cost_schedules(Panel):
                row.label(text="No Cost Schedules found.", icon="TEXT")

            row.operator("bim.add_cost_schedule", icon="ADD", text="")
-            row.operator("bim.import_cost_schedule_csv",icon="IMPORT",text="")
+            row.operator("import_cost_schedule_csv.bim",icon="IMPORT",text="")

        for schedule in CostSchedulesData.data["schedules"]:
            self.draw_cost_schedule_ui(schedule)
@@ -179,33 +178,24 @@ class BIM_PT_cost_schedules(Panel):
            "active_cost_item_index",
        )
        if self.props.active_cost_item_id:
-            cost_item = CostSchedulesData.data["cost_items"][ifc_definition_id]
            if self.props.cost_item_editing_type == "ATTRIBUTES":
                self.draw_editable_cost_item_attributes_ui()
            elif self.props.cost_item_editing_type == "QUANTITIES":
-                self.draw_editable_cost_item_quantities_ui(cost_item)
+                self.draw_editable_cost_item_quantities_ui()
            elif self.props.cost_item_editing_type == "VALUES":
                self.draw_editable_cost_item_values_ui()

    def draw_editable_cost_item_attributes_ui(self):
        blenderbim.bim.helper.draw_attributes(self.props.cost_item_attributes, self.layout)

-    def draw_editable_cost_item_quantities_ui(self, cost_item: dict[str, Any]):
-        quantities = CostSchedulesData.data["cost_quantities"]
+    def draw_editable_cost_item_quantities_ui(self):
        row = self.layout.row(align=True)
-        # In IFC, all quantities of IfcCostTime should have 1 type.
-        if quantities:
-            quantity_class = cost_item["QuantityType"]
-            row.label(text=quantity_class)
-        else:
-            row.prop(self.props, "quantity_types", text="")
-            quantity_class = self.props.quantity_types
-
+        row.prop(self.props, "quantity_types", text="")
        op = row.operator("bim.add_cost_item_quantity", text="", icon="ADD")
        op.cost_item = self.props.active_cost_item_id
-        op.ifc_class = quantity_class
+        op.ifc_class = self.props.quantity_types

-        for quantity in quantities:
+        for quantity in CostSchedulesData.data["cost_quantities"]:
            row = self.layout.row(align=True)
            row.label(text=quantity["name"])
            row.label(text=quantity["value"])
@@ -644,7 +634,7 @@ class BIM_UL_cost_items_trait:
        layout.label(text=cost_item["UnitBasisUnitSymbol"])

    def draw_total_quantity_column(self, layout, cost_item):
-        if cost_item["TotalCostQuantity"] is not None:
+        if cost_item["TotalCostQuantity"]:
            label = "{0:.2f}".format(cost_item["TotalCostQuantity"]) + f" {cost_item['UnitSymbol'] or '-'}"
            layout.label(text=label)
        else:
@@ -755,11 +745,9 @@ class BIM_UL_product_cost_items(UIList):
 class BIM_PT_Costing_Tools(Panel):
    bl_label = "5D Tools"
    bl_idname = "BIM_PT_Costing_Tools"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_tab_cost"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "UI"
+    bl_category = "4D/5D Toolkit"

    def draw(self, context):
        self.props = context.scene.BIMCostProperties
@@ -29,9 +29,13 @@ def register():
    if not bpy.app.background:
        bpy.utils.register_tool(workspace.CoveringTool, after={"bim.structural_tool"}, separator=False, group=False)
    bpy.types.Scene.BIMCoveringProperties = bpy.props.PointerProperty(type=prop.BIMCoveringProperties)
+#    bpy.types.Object.BIMObjectSpatialProperties = bpy.props.PointerProperty(type=prop.BIMObjectSpatialProperties)
+#    bpy.types.Scene.BIMSpatialManagerProperties = bpy.props.PointerProperty(type=prop.BIMSpatialManagerProperties)


 def unregister():
    if not bpy.app.background:
        bpy.utils.unregister_tool(workspace.CoveringTool)
    del bpy.types.Scene.BIMCoveringProperties
+#    del bpy.types.Object.BIMObjectSpatialProperties
+#    del bpy.types.Scene.BIMSpatialManagerProperties
@@ -107,88 +107,59 @@ class CoveringToolUI:
 #                elif element and bpy.context.selected_objects and element.is_a("IfcSpace"):
 #                    op. = row.operator("bim.add_istance_flooring_from_spaces"):

-#            if (type_material_usage == "IfcMaterialLayerSet" and
-#                not bpy.context.selected_objects):
-#                row = cls.layout.row(align=True)
-#                row.label(text="", icon="EVENT_SHIFT")
-#                row.label(text="", icon="EVENT_A")
-#                if tool.Ifc.get_entity(collection_obj):
-#                    if AuthoringData.data["predefined_type"] == "FLOORING":
-#                        op = row.operator("bim.add_instance_flooring_covering_from_cursor")
-#                    elif AuthoringData.data["predefined_type"] == "CEILING":
-#                        op = row.operator("bim.add_instance_ceiling_covering_from_cursor")
-#                    else:
-#                        op = row.operator("bim.add_constr_type_instance", text="Add")
-#                        op.from_invoke = True
-#                        if cls.props.relating_type_id.isnumeric():
-#                            op.relating_type_id = int(cls.props.relating_type_id)
-#
-#                else:
-#                    op = row.operator("bim.add_constr_type_instance", text="Add")
-#                    op.from_invoke = True
-#                    if cls.props.relating_type_id.isnumeric():
-#                        op.relating_type_id = int(cls.props.relating_type_id)
-#
-#            elif (AuthoringData.data["predefined_type"] == "FLOORING" and
-#                type_material_usage == "IfcMaterialLayerSet" and
-#                element and
-#                bpy.context.selected_objects and
-#                element.is_a("IfcWall")):
-#                    row = cls.layout.row(align=True)
-#                    row.label(text="", icon="EVENT_SHIFT")
-#                    row.label(text="", icon="EVENT_A")
-#                    op = row.operator("bim.add_instance_flooring_coverings_from_walls")
-#
-#            elif (AuthoringData.data["predefined_type"] == "CEILING" and
-#                type_material_usage == "IfcMaterialLayerSet" and
-#                element and
-#                bpy.context.selected_objects and
-#                element.is_a("IfcWall")):
-#                    row = cls.layout.row(align=True)
-#                    row.label(text="", icon="EVENT_SHIFT")
-#                    row.label(text="", icon="EVENT_A")
-#                    op = row.operator("bim.add_instance_ceiling_coverings_from_walls")
-#
-#            elif (element and
-#                  bpy.context.selected_objects and
-#                  element.is_a("IfcCovering") and
-##                  AuthoringData.data["predefined_type"] == "FLOORING" and
-#                  AuthoringData.data["active_material_usage"] == "LAYER3"):
-#                row = cls.layout.row(align=True)
-#                row.label(text="", icon="EVENT_SHIFT")
-#                row.label(text="", icon="EVENT_G")
-#                op = row.operator("bim.regen_selected_covering_object")
+            if (type_material_usage == "IfcMaterialLayerSet" and
+                not bpy.context.selected_objects):
+                row = cls.layout.row(align=True)
+                row.label(text="", icon="EVENT_SHIFT")
+                row.label(text="", icon="EVENT_A")
+                if tool.Ifc.get_entity(collection_obj):
+                    if AuthoringData.data["predefined_type"] == "FLOORING":
+                        op = row.operator("bim.add_instance_flooring_covering_from_cursor")
+                    elif AuthoringData.data["predefined_type"] == "CEILING":
+                        op = row.operator("bim.add_instance_ceiling_covering_from_cursor")
+                    else:
+                        op = row.operator("bim.add_constr_type_instance", text="Add")
+                        op.from_invoke = True
+                        if cls.props.relating_type_id.isnumeric():
+                            op.relating_type_id = int(cls.props.relating_type_id)
+
+                else:
+                    op = row.operator("bim.add_constr_type_instance", text="Add")
+                    op.from_invoke = True
+                    if cls.props.relating_type_id.isnumeric():
+                        op.relating_type_id = int(cls.props.relating_type_id)
+
+            elif (AuthoringData.data["predefined_type"] == "FLOORING" and
+                type_material_usage == "IfcMaterialLayerSet" and
+                element and
+                bpy.context.selected_objects and
+                element.is_a("IfcWall")):
+                    row = cls.layout.row(align=True)
+                    row.label(text="", icon="EVENT_SHIFT")
+                    row.label(text="", icon="EVENT_A")
+                    op = row.operator("bim.add_instance_flooring_coverings_from_walls")
+
+            elif (AuthoringData.data["predefined_type"] == "CEILING" and
+                type_material_usage == "IfcMaterialLayerSet" and
+                element and
+                bpy.context.selected_objects and
+                element.is_a("IfcWall")):
+                    row = cls.layout.row(align=True)
+                    row.label(text="", icon="EVENT_SHIFT")
+                    row.label(text="", icon="EVENT_A")
+                    op = row.operator("bim.add_instance_ceiling_coverings_from_walls")
+
+            elif (element and
+                  bpy.context.selected_objects and
+                  element.is_a("IfcCovering") and
+#                  AuthoringData.data["predefined_type"] == "FLOORING" and
+                  AuthoringData.data["active_material_usage"] == "LAYER3"):
+                row = cls.layout.row(align=True)
+                row.label(text="", icon="EVENT_SHIFT")
+                row.label(text="", icon="EVENT_G")
+                op = row.operator("bim.regen_selected_covering_object")


-            row = cls.layout.row(align=True)
-            row.label(text="", icon="EVENT_SHIFT")
-            row.label(text="", icon="EVENT_A")
-            op = row.operator("bim.add_constr_type_instance", text="Add")
-
-            row = cls.layout.row(align=True)
-            row.label(text="", icon="EVENT_SHIFT")
-            row.label(text="", icon="EVENT_A")
-            op = row.operator("bim.add_instance_flooring_covering_from_cursor")
-
-            row = cls.layout.row(align=True)
-            row.label(text="", icon="EVENT_SHIFT")
-            row.label(text="", icon="EVENT_A")
-            op = row.operator("bim.add_instance_ceiling_covering_from_cursor")
-
-            row = cls.layout.row(align=True)
-            row.label(text="", icon="EVENT_SHIFT")
-            row.label(text="", icon="EVENT_A")
-            op = row.operator("bim.add_instance_flooring_coverings_from_walls")
-
-            row = cls.layout.row(align=True)
-            row.label(text="", icon="EVENT_SHIFT")
-            row.label(text="", icon="EVENT_A")
-            op = row.operator("bim.add_instance_ceiling_coverings_from_walls")
-
-            row = cls.layout.row(align=True)
-            row.label(text="", icon="EVENT_SHIFT")
-            row.label(text="", icon="EVENT_G")
-            op = row.operator("bim.regen_selected_covering_object")

 #            elif AuthoringData.data["predefined_type"] == "CEILING":
 #                row = cls.layout.row(align=True)
@@ -203,14 +174,14 @@ class CoveringToolUI:
 #                    op.from_invoke = True
 #                    if cls.props.relating_type_id.isnumeric():
 #                        op.relating_type_id = int(cls.props.relating_type_id)
-#            else:
-#                row = cls.layout.row(align=True)
-#                row.label(text="", icon="EVENT_SHIFT")
-#                row.label(text="", icon="EVENT_A")
-#                op = row.operator("bim.add_constr_type_instance", text="Add")
-#                op.from_invoke = True
-#                if cls.props.relating_type_id.isnumeric():
-#                    op.relating_type_id = int(cls.props.relating_type_id)
+            else:
+                row = cls.layout.row(align=True)
+                row.label(text="", icon="EVENT_SHIFT")
+                row.label(text="", icon="EVENT_A")
+                op = row.operator("bim.add_constr_type_instance", text="Add")
+                op.from_invoke = True
+                if cls.props.relating_type_id.isnumeric():
+                    op.relating_type_id = int(cls.props.relating_type_id)

    @classmethod
    def draw_type_selection_interface(cls):
@@ -23,7 +23,6 @@ import ifccsv
 import logging
 import tempfile
 import ifcopenshell
-import ifcopenshell.util.selector
 import blenderbim.tool as tool
 import blenderbim.bim.module.drawing.scheduler as scheduler
 from blenderbim.bim.ifc import IfcStore
@@ -73,7 +72,7 @@ class ReorderCsvAttribute(bpy.types.Operator):
    def execute(self, context):
        old = context.scene.CsvProperties.csv_attributes[self.old_index]
        new = context.scene.CsvProperties.csv_attributes[self.new_index]
-        props = ["name", "header", "sort", "group", "varies_value", "summary", "formatting"]
+        props = ["name", "header", "sort", "group", "varies_value", "summary"]
        for prop in props:
            value = getattr(new, prop)
            setattr(new, prop, getattr(old, prop))
@@ -247,7 +246,6 @@ class ExportIfcCsv(bpy.types.Operator):
        if props.format != "csv" and props.should_generate_svg:
            schedule_creator = scheduler.Scheduler()
            schedule_creator.schedule(self.filepath, tool.Drawing.get_path_with_ext(self.filepath, "svg"))
-        self.report({"INFO"}, f"Data is exported to {props.format.upper()}.")
        return {"FINISHED"}


@@ -287,7 +285,6 @@ class ImportIfcCsv(bpy.types.Operator):
        if not props.should_load_from_memory:
            ifc_file.write(props.csv_ifc_file)
        refresh_ui_data()
-        self.report({"INFO"}, "Data is imported to IFC.")
        return {"FINISHED"}


@@ -24,7 +24,6 @@ classes = (
    operator.CopyDebugInformation,
    operator.CreateAllShapes,
    operator.CreateShapeFromStepId,
-    operator.DebugActiveDrawing,
    operator.InspectFromObject,
    operator.InspectFromStepId,
    operator.OverrideDisplayType,
@@ -35,6 +34,7 @@ classes = (
    operator.PrintUnusedElementStats,
    operator.ProfileImportIFC,
    operator.PurgeHdf5Cache,
+    operator.PurgeIfcLinks,
    operator.PurgeUnusedElementsByClass,
    operator.RewindInspector,
    operator.SelectExpressFile,
@@ -20,30 +20,49 @@ import os
 import sys
 import bpy
 import time
-import random
 import logging
 import platform
 import subprocess
+import addon_utils
 import ifcopenshell
-import ifcopenshell.api
-import ifcopenshell.util.element
 import ifcopenshell.util.placement
 import ifcopenshell.util.representation
 import blenderbim.tool as tool
 import blenderbim.core.debug as core
 import blenderbim.bim.handler
 import blenderbim.bim.import_ifc as import_ifc
-from blenderbim import get_debug_info, format_debug_info
+import blenderbim.tool as tool
 from blenderbim.bim.ifc import IfcStore


 class CopyDebugInformation(bpy.types.Operator):
    bl_idname = "bim.copy_debug_information"
    bl_label = "Copy Debug Information"
-    bl_description = "Copies debugging information to your clipboard for use in bug reports"
+    bl_description = "Copies debugging information to your clipboard for use in bugreports"

    def execute(self, context):
-        info = get_debug_info()
+        version = ".".join(
+            [
+                str(x)
+                for x in [
+                    addon.bl_info.get("version", (-1, -1, -1))
+                    for addon in addon_utils.modules()
+                    if addon.bl_info["name"] == "BlenderBIM"
+                ][0]
+            ]
+        )
+        info = {
+            "os": platform.system(),
+            "os_version": platform.version(),
+            "python_version": platform.python_version(),
+            "architecture": platform.architecture(),
+            "machine": platform.machine(),
+            "processor": platform.processor(),
+            "blender_version": bpy.app.version_string,
+            "blenderbim_version": version,
+            "ifc": False,
+        }
+
        if tool.Ifc.get():
            info.update(
                {
@@ -54,15 +73,17 @@ class CopyDebugInformation(bpy.types.Operator):
                }
            )

-        text = format_debug_info(info)
+        # Format it in a readable way
+        text = "\n".join(f"{k}: {v}" for k, v in info.items())
+        print(text)

-        text_with_backticks = f"```\n{text}\n```"
-
-        print("-" * 80)
-        print(text_with_backticks)
-        print("-" * 80)
-
-        context.window_manager.clipboard = text_with_backticks
+        if platform.system() == "Windows":
+            command = "echo | set /p nul=" + text.strip()
+        elif platform.system() == "Darwin":  # for MacOS
+            command = 'printf "' + text.strip().replace("\n", "\\n").replace('"', "") + '" | pbcopy'
+        else:  # Linux
+            command = 'printf "' + text.strip().replace("\n", "\\n").replace('"', "") + '" | xclip -selection clipboard'
+        subprocess.run(command, shell=True, check=True)
        return {"FINISHED"}


@@ -80,11 +101,10 @@ class PrintIfcFile(bpy.types.Operator):
        return {"FINISHED"}


-class ConvertToBlender(bpy.types.Operator):
-    bl_idname = "bim.convert_to_blender"
-    bl_label = "Convert To Blender File"
-    bl_description = "Removes all IFC data and revert to basic Blender objects.\nWarning : Cannot be undone."
-    bl_options = {"REGISTER", "UNDO"}
+class PurgeIfcLinks(bpy.types.Operator):
+    bl_idname = "bim.purge_ifc_links"
+    bl_label = "Purge IFC Links"
+    bl_description = "Purge all definitions and references from the file.\nWarning : Cannot be undone."

    def execute(self, context):
        for obj in bpy.data.objects:
@@ -93,8 +113,7 @@ class ConvertToBlender(bpy.types.Operator):
                if obj.data:
                    obj.data.BIMMeshProperties.ifc_definition_id = 0
        for material in bpy.data.materials:
-            material.BIMObjectProperties.ifc_definition_id = 0
-            material.BIMMaterialProperties.ifc_style_id = 0
+            material.BIMMaterialProperties.ifc_style_id = False
        context.scene.BIMProperties.ifc_file = ""
        context.scene.BIMDebugProperties.attributes.clear()
        IfcStore.purge()
@@ -102,6 +121,26 @@ class ConvertToBlender(bpy.types.Operator):
        return {"FINISHED"}


+class ConvertToBlender(bpy.types.Operator):
+    bl_idname = "bim.convert_to_blender"
+    bl_label = "Convert To Blender File"
+    bl_description = "Removes all IFC data, and converts the file to a simple Blender file."
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        for o in bpy.data.objects:
+            if o.type in {"MESH", "EMPTY"}:
+                o.BIMObjectProperties.ifc_definition_id = 0
+                if o.data:
+                    o.data.BIMMeshProperties.ifc_definition_id = 0
+        for m in bpy.data.materials:
+            m.BIMMaterialProperties.ifc_style_id = False
+        bpy.context.scene.BIMProperties.ifc_file = ""
+        IfcStore.purge()
+        blenderbim.bim.handler.refresh_ui_data()
+        return {"FINISHED"}
+
+
 class ValidateIfcFile(bpy.types.Operator):
    bl_idname = "bim.validate_ifc_file"
    bl_label = "Validate IFC File"
@@ -621,104 +660,3 @@ class PipInstall(bpy.types.Operator):
            ]
        )
        return {"FINISHED"}
-
-
-class DebugActiveDrawing(bpy.types.Operator):
-    bl_idname = "bim.debug_active_drawing"
-    bl_label = "Search Active Drawing For Failing Elements"
-    bl_description = (
-        "Will iterate over all visible drawing's objects, trying to narrow down the list of possible failing objects"
-    )
-
-    def execute(self, context: bpy.types.Context):
-        props = context.scene.DocProperties
-        drawing_item = props.drawings[props.active_drawing_index]
-        drawing = tool.Ifc.get().by_id(drawing_item.ifc_definition_id)
-
-        GREEN = "\033[92m"
-        CYAN = "\033[96m"
-        END = "\033[0m"
-        ATTEMPS = 10
-
-        # run create drawing with sync for once
-        # to make sure everything is actually in sync
-        try:
-            bpy.ops.bim.create_drawing(sync=True)
-        except:
-            pass
-        else:
-            self.report({"INFO"}, "No errors creating drawing, nothing to investigate.")
-            return {"FINISHED"}
-
-        all_elements = [e for obj in context.visible_objects if (e := tool.Ifc.get_entity(obj))]
-        all_elements = set(all_elements)
-
-        original_exclude = ifcopenshell.util.element.get_pset(drawing, "EPset_Drawing", "Exclude")
-        pset = tool.Pset.get_element_pset(drawing, "EPset_Drawing")
-
-        def drawing_fails_to_load(chunk_to_include: set) -> bool:
-            current_elements = all_elements - chunk_to_include
-            excluded_guids = ", ".join([e.GlobalId for e in current_elements if hasattr(e, "GlobalId")])
-            tool.Ifc.run("pset.edit_pset", pset=pset, properties={"Exclude": f"{original_exclude}, {excluded_guids}"})
-
-            try:
-                bpy.ops.bim.create_drawing(sync=False)
-                result = False
-            except Exception as e:
-                # print(e)
-                result = True
-
-            tool.Ifc.run("pset.edit_pset", pset=pset, properties={"Exclude": original_exclude})
-            return result
-
-        def test_elements(elements: list[ifcopenshell.entity_instance], attempts: int = ATTEMPS) -> None:
-            print(f"{CYAN}processing {len(elements)} elements{END}")
-            if not elements:
-                print(f"Empty list of elements, will stop...")
-                return
-
-            n_elements = len(elements)
-            middle = int(n_elements / 2)
-            chunk1, chunk2 = elements[:middle], elements[middle:]
-            test_chunk_1 = drawing_fails_to_load(set(chunk1))
-            test_chunk_2 = drawing_fails_to_load(set(chunk2))
-
-            if (
-                # both chunks do not fail anymore
-                (not test_chunk_1 and not test_chunk_2)
-                # or we have 1 element chunk that is still failing
-                or (test_chunk_1 and not chunk2)
-                or (test_chunk_2 and not chunk1)
-            ):
-                if attempts == 0 or n_elements in (1, 2):
-                    print(f"{GREEN}Couldn't narrow it down any further.{END}")
-                    print(f"It's some of the {n_elements} elements:")
-                    print(elements)
-
-                    print("Let's test excluding them...")
-                    for element in elements:
-                        test = drawing_fails_to_load(all_elements - {element})
-                        if test:
-                            print(f"{CYAN}Excluding element didn't fixed the drawing: {END}")
-                            print(element)
-                        else:
-                            print(f"{GREEN}Excluding element fixed the drawing: {END}")
-                            print(element)
-                else:
-                    print(f"{CYAN}Will try to reshuffle elements and try again, attempt {ATTEMPS-attempts+1}/{ATTEMPS}")
-                    attempts -= 1
-                    random.shuffle(elements)
-                    test_elements(elements, attempts)
-                return
-
-            # if chunk fails we need to investigate it further
-            if test_chunk_1:
-                test_elements(chunk1)
-
-            if test_chunk_2:
-                test_elements(chunk2)
-
-        test_elements(list(all_elements))
-
-        self.report({"INFO"}, "See system console for the results")
-        return {"FINISHED"}
@@ -60,6 +60,9 @@ class BIM_PT_debug(Panel):
        row = layout.row()
        row.operator("bim.purge_hdf5_cache")

+        row = layout.row()
+        row.operator("bim.purge_ifc_links")
+
        row = layout.row()
        row.operator("bim.update_representation", text="Manually Save Representation")

@@ -72,9 +75,6 @@ class BIM_PT_debug(Panel):
        row = layout.row()
        row.operator("bim.profile_import_ifc")

-        row = layout.row()
-        row.operator("bim.debug_active_drawing")
-
        row = layout.split(factor=0.5, align=True)
        row.operator("bim.create_shape_from_step_id").should_include_curves = False
        row.operator("bim.create_shape_from_step_id", text="", icon="IPO_ELASTIC").should_include_curves = True
@@ -38,7 +38,6 @@ class DiffData:
        cls.data["total_deleted"] = cls.total_deleted()
        cls.data["total_changed"] = cls.total_changed()
        cls.data["changes"] = cls.changes()
-        cls.data["saved_searches"] = cls.saved_searches()
        cls.is_loaded = True

    @classmethod
@@ -85,18 +84,3 @@ class DiffData:
        elif element.GlobalId in diff["deleted"]:
            changes["Deleted"] = True
        return changes
-
-    @classmethod
-    def saved_searches(cls):
-        if not tool.Ifc.get():
-            return []
-        groups = tool.Ifc.get().by_type("IfcGroup")
-        results = []
-        for group in groups:
-            try:
-                data = json.loads(group.Description)
-                if isinstance(data, dict) and data.get("type", None) == "BBIM_Search" and data.get("query", None):
-                    results.append(group)
-            except:
-                pass
-        return [(str(g.id()), g.Name or "Unnamed", "") for g in sorted(results, key=lambda x: x.Name or "Unnamed")]
@@ -135,7 +135,6 @@ class ExecuteIfcDiff(bpy.types.Operator):
    bl_label = "Execute IFC Diff"
    filename_ext = ".json"
    filepath: bpy.props.StringProperty(subtype="FILE_PATH")
-    filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})

    def invoke(self, context, event):
        self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".json")
@@ -163,7 +162,7 @@ class ExecuteIfcDiff(bpy.types.Operator):
            new = ifcopenshell.open(self.props.new_file)

        relationships = [r.relationship for r in self.props.diff_relationships]
-        query = tool.Search.export_filter_query(self.props.filter_groups) or None
+        query = self.props.diff_filter_elements

        ifc_diff = ifcdiff.IfcDiff(old, new, relationships=relationships, filter_elements=query)
        ifc_diff.diff()
@@ -17,7 +17,7 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import bpy
-from blenderbim.bim.prop import StrProperty, BIMFilterGroup
+from blenderbim.bim.prop import StrProperty
 from blenderbim.bim.module.diff.data import DiffData
 from bpy.types import PropertyGroup
 from bpy.props import (
@@ -48,7 +48,7 @@ class DiffProperties(PropertyGroup):
    old_file: StringProperty(default="", name="Old IFC File")
    new_file: StringProperty(default="", name="New IFC File")
    diff_relationships: CollectionProperty(type=Relationships, name="Relationships")
-    filter_groups: CollectionProperty(type=BIMFilterGroup, name="Filter Groups")
+    diff_filter_elements: StringProperty(default="", name="Filter")
    should_load_changed_elements: BoolProperty(name="Load Changed Elements", default=True)
    active_file: EnumProperty(
        items=[
@@ -19,8 +19,8 @@
 from bpy.types import Panel
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.diff.data import DiffData
-import blenderbim.bim.helper
 import blenderbim.tool as tool
+import json


 class BIM_PT_diff(Panel):
@@ -93,7 +93,9 @@ class BIM_PT_diff(Panel):
            remove.collection = "diff_relationships"
            remove.index = index

-        blenderbim.bim.helper.draw_filter(self.layout, props.filter_groups, DiffData, "diff")
+        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")
@@ -41,7 +41,6 @@ classes = (
    operator.CleanWireframes,
    operator.ContractSheet,
    operator.ContractTargetView,
-    operator.ConvertSVGToDXF,
    operator.CreateDrawing,
    operator.CreateSheets,
    operator.DisableAddAnnotationType,
@@ -127,7 +126,7 @@ def register():
    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.load_post)
+    bpy.app.handlers.load_post.append(handler.toggleDecorationsOnLoad)
    bpy.app.handlers.depsgraph_update_pre.append(handler.depsgraph_update_pre_handler)
    bpy.types.VIEW3D_MT_image_add.append(ui.add_object_button)

@@ -141,6 +140,6 @@ def unregister():
    del bpy.types.Object.BIMAssignedProductProperties
    del bpy.types.Object.BIMTextProperties
    del bpy.types.TextCurve.BIMTextProperties
-    bpy.app.handlers.load_post.remove(handler.load_post)
+    bpy.app.handlers.load_post.remove(handler.toggleDecorationsOnLoad)
    bpy.app.handlers.depsgraph_update_pre.remove(handler.depsgraph_update_pre_handler)
    bpy.types.VIEW3D_MT_image_add.remove(ui.add_object_button)
@@ -159,7 +159,9 @@ class BaseDecorator:
    objecttype = "NOTDEFINED"

    def __init__(self):
-        self.font_id = 0 # 0 is the default font
+        self.font_id = blf.load(
+            os.path.join(bpy.context.scene.BIMProperties.data_dir, "fonts", "OpenGost Type B TT.ttf")
+        )

        # POLYLINE_UNIFORM_COLOR is good for smoothed lines since `bgl.enable(GL_LINE_SMOOTH)` is deprecated
        self.line_shader = gpu.shader.from_builtin("POLYLINE_UNIFORM_COLOR")
@@ -402,6 +404,7 @@ class BaseDecorator:
                line_no += 1 if multiline_to_bottom else -1
            return

+        # 0 is the default font, but we're fancier than that
        font_id = self.font_id

        color = context.preferences.addons["blenderbim"].preferences.decorations_colour
@@ -415,14 +418,12 @@ class BaseDecorator:
        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.get_camera_width_mm()
-        # magic_font_scale's default of (0.004118616) is a magic constant number I visually discovered to get the right number.
+        # 0.004118616 is a magic constant number I visually discovered to get the right number.
        # In particular it works only for the OpenGOST font and produces a 2.5mm font size.
        # It probably should be dynamically calculated using system.dpi or something.
        # font_size = 16 <-- this is a good default
        # TODO: need to synchronize it better with svg
-
-        magic_font_scale = bpy.context.scene.DocProperties.magic_font_scale
-        font_size_px = int(magic_font_scale * mm_to_px) * font_size_mm / 2.5
+        font_size_px = int(0.004118616 * mm_to_px) * font_size_mm / 2.5
        pos = pos - line_no * font_size_px * rotation_matrix[1]

        blf.size(font_id, font_size_px)
@@ -605,7 +606,7 @@ class BaseDecorator:
        for literal_data in literals_data:
            box_alignment = literal_data["BoxAlignment"]

-            for line in literal_data["CurrentValue"].split("\n"):
+            for line in literal_data["CurrentValue"].split("\\n"):
                self.draw_label(
                    context,
                    line,
@@ -2013,13 +2014,6 @@ class DecorationsHandler:
        for object_type in ("SLOPE_ANGLE", "SLOPE_FRACTION", "SLOPE_PERCENT"):
            self.decorators[object_type] = self.decorators["FALL"]
        self.decorators["MULTI_SYMBOL"] = self.decorators["SYMBOL"]
-        if drawing_font := bpy.context.scene.DocProperties.drawing_font:
-            drawing_font_path = os.path.join(bpy.context.scene.BIMProperties.data_dir, "fonts", drawing_font)
-            if os.path.exists(drawing_font_path):
-                font_id = blf.load(drawing_font_path)
-                for decorator in self.decorators.values():
-                    decorator.font_id = font_id
-

    def get_objects_and_decorators(self, collection):
        # TODO: do it in data instead of the handler for performance?
@@ -23,7 +23,7 @@ from bpy.app.handlers import persistent


@persistent
-def load_post(*args):
+def toggleDecorationsOnLoad(*args):
    if bpy.context.scene.DocProperties.should_draw_decorations:
        decoration.DecorationsHandler.install(bpy.context)
    else:
@@ -188,6 +188,7 @@ def format_distance(
                feet += 1
                inches = 0

+
        if not isArea:
            add_inches = bool(inches) or not suppress_zero_inches
            tx_dist = ""
@@ -298,9 +299,7 @@ def parse_diagram_scale(camera):
    return float(numerator) / float(denominator)


-def ortho_view_frame(
-    camera: bpy.types.Camera, margin: float = 0.015
-) -> tuple[float, float, float, float, float, float]:
+def ortho_view_frame(camera, margin=0.015):
    """Calculates 2d bounding box of camera view area.

    Similar to `bpy.types.Camera.view_frame`
@@ -29,8 +29,6 @@ import subprocess
 import numpy as np
 import multiprocessing
 import ifcopenshell
-import ifcopenshell.api
-import ifcopenshell.ifcopenshell_wrapper
 import ifcopenshell.geom
 import ifcopenshell.util.selector
 import ifcopenshell.util.representation
@@ -46,7 +44,7 @@ import blenderbim.bim.module.drawing.helper as helper
 import blenderbim.bim.export_ifc
 from blenderbim.bim.module.drawing.decoration import CutDecorator
 from blenderbim.bim.module.drawing.data import DecoratorData, DrawingsData
-from typing import NamedTuple, List, Union, Optional
+from typing import NamedTuple, List
 from lxml import etree
 from mathutils import Vector, Color, Matrix
 from timeit import default_timer as timer
@@ -201,11 +199,6 @@ class CreateDrawing(bpy.types.Operator):
        + "SHIFT+CLICK to print all selected drawings"
    )
    print_all: bpy.props.BoolProperty(name="Print All", default=False, options={"SKIP_SAVE"})
-    sync: bpy.props.BoolProperty(
-        name="Sync Before Creating Drawing",
-        description="Could save some time if you're sure IFC and current Blender session are already in sync",
-        default=True,
-    )

    @classmethod
    def poll(cls, context):
@@ -221,15 +214,13 @@ class CreateDrawing(bpy.types.Operator):
    def execute(self, context):
        self.props = context.scene.DocProperties

-        active_drawing_id = context.scene.camera.BIMObjectProperties.ifc_definition_id
        if self.print_all:
-            original_drawing_id = active_drawing_id
+            original_drawing_id = self.props.active_drawing_id
            drawings_to_print = [d.ifc_definition_id for d in self.props.drawings if d.is_selected and d.is_drawing]
        else:
-            drawings_to_print = [active_drawing_id]
+            drawings_to_print = [self.props.active_drawing_id]

-        for drawing_i, drawing_id in enumerate(drawings_to_print):
-            self.drawing_index = drawing_i
+        for drawing_id in drawings_to_print:
            if self.print_all:
                bpy.ops.bim.activate_drawing(drawing=drawing_id, camera_view_point=False)

@@ -344,13 +335,6 @@ class CreateDrawing(bpy.types.Operator):
        if not ifcopenshell.util.element.get_pset(self.drawing, "EPset_Drawing", "HasUnderlay"):
            return
        svg_path = self.get_svg_path(cache_type="underlay")
-        if os.path.isfile(svg_path) and self.props.should_use_underlay_cache:
-            return svg_path
-
-        visible_object_names = {obj.name for obj in bpy.context.visible_objects}
-        for obj in bpy.context.view_layer.objects:
-            obj.hide_render = obj.name not in visible_object_names
-
        context.scene.render.filepath = svg_path[0:-4] + ".png"
        drawing_style = context.scene.DocProperties.drawing_styles[self.cprops.active_drawing_style_index]

@@ -461,14 +445,8 @@ class CreateDrawing(bpy.types.Operator):
        return LineworkContexts(body_contexts, annotation_contexts)

    def serialize_contexts_elements(
-        self,
-        ifc: ifcopenshell.file,
-        tree: ifcopenshell.geom.tree,
-        contexts: LineworkContexts,
-        context_type: str,
-        drawing_elements: set[ifcopenshell.entity_instance],
-        target_view: str,
-    ) -> None:
+        self, ifc, tree: ifcopenshell.geom.tree, contexts: LineworkContexts, context_type, drawing_elements, target_view
+    ):
        drawing_elements = drawing_elements.copy()
        contexts = getattr(contexts, context_type)
        for context in contexts:
@@ -494,24 +472,20 @@ class CreateDrawing(bpy.types.Operator):
                    tree.add_element(elem)
                drawing_elements -= processed

-    def generate_linework(self, context: bpy.types.Context) -> Union[str, None]:
+    def generate_linework(self, context):
        if not ifcopenshell.util.element.get_pset(self.drawing, "EPset_Drawing", "HasLinework"):
            return
        svg_path = self.get_svg_path(cache_type="linework")
        if os.path.isfile(svg_path) and self.props.should_use_linework_cache:
            return svg_path

-        # in case of printing multiple drawings we need to sync just once
-        if self.sync and self.drawing_index == 0:
-            with profile("sync"):
-                # All very hackish whilst prototyping
-                exporter = blenderbim.bim.export_ifc.IfcExporter(None)
-                exporter.file = tool.Ifc.get()
-                invalidated_elements = exporter.sync_all_objects(skip_unlinking=True)
-                invalidated_elements += exporter.sync_edited_objects()
-                invalidated_guids = [e.GlobalId for e in invalidated_elements if hasattr(e, "GlobalId")]
-                cache = IfcStore.get_cache()
-                [cache.remove(guid) for guid in invalidated_guids]
+        with profile("sync"):
+            # All very hackish whilst prototyping
+            exporter = blenderbim.bim.export_ifc.IfcExporter(None)
+            exporter.file = tool.Ifc.get()
+            invalidated_elements = exporter.sync_all_objects()
+            invalidated_elements += exporter.sync_edited_objects()
+            invalidated_guids = [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()
@@ -530,35 +504,29 @@ class CreateDrawing(bpy.types.Operator):

        files = {context.scene.BIMProperties.ifc_file: tool.Ifc.get()}

-        for link in context.scene.BIMProjectProperties.links:
-            if link.name not in IfcStore.session_files:
-                IfcStore.session_files[link.name] = ifcopenshell.open(link.name)
-            files[link.name] = IfcStore.session_files[link.name]
-
-        target_view = ifcopenshell.util.element.get_psets(self.camera_element)["EPset_Drawing"]["TargetView"]
-        self.setup_serialiser(target_view)
-
-        tree = ifcopenshell.geom.tree()
-        tree.enable_face_styles(True)
-
        for ifc_path, ifc in files.items():
            # Don't use draw.main() just whilst we're prototyping and experimenting
-            # TODO: hash paths are never used
            ifc_hash = hashlib.md5(ifc_path.encode("utf-8")).hexdigest()
            ifc_cache_path = os.path.join(context.scene.BIMProperties.data_dir, "cache", f"{ifc_hash}.h5")

-            self.serialiser.setFile(ifc)
-            drawing_elements = tool.Drawing.get_drawing_elements(self.camera_element, ifc_file=ifc)
-
            # Get all representation contexts to see what we're dealing with.
            # Drawings only draw bodies and annotations (and facetation, due to a Revit bug).
            # A drawing prioritises a target view context first, followed by a model view context as a fallback.
            # Specifically for PLAN_VIEW and REFLECTED_PLAN_VIEW, any Plan context is also prioritised.
+            target_view = ifcopenshell.util.element.get_psets(self.camera_element)["EPset_Drawing"]["TargetView"]
            contexts = self.get_linework_contexts(ifc, target_view)
+            drawing_elements = tool.Drawing.get_drawing_elements(self.camera_element)
+
+            self.setup_serialiser(ifc, target_view)
+            cache = IfcStore.get_cache()
+            [cache.remove(guid) for guid in invalidated_guids]
+            tree = ifcopenshell.geom.tree()
+            tree.enable_face_styles(True)
+
            self.serialize_contexts_elements(ifc, tree, contexts, "body", drawing_elements, target_view)
            self.serialize_contexts_elements(ifc, tree, contexts, "annotation", drawing_elements, target_view)

-            if tool.Ifc.get() == ifc and self.camera_element not in drawing_elements:
+            if self.camera_element not in drawing_elements:
                with profile("Camera element"):
                    # The camera must always be included, regardless of any include/exclude filters.
                    geom_settings = ifcopenshell.geom.settings(DISABLE_TRIANGULATION=True, STRICT_TOLERANCE=True)
@@ -873,12 +841,13 @@ class CreateDrawing(bpy.types.Operator):

        return svg_path

-    def setup_serialiser(self, target_view):
+    def setup_serialiser(self, ifc, target_view):
        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)
        self.serialiser.setWithoutStoreys(True)
        self.serialiser.setPolygonal(True)
        self.serialiser.setUseHlrPoly(True)
@@ -942,18 +911,6 @@ class CreateDrawing(bpy.types.Operator):
        self.is_manifold_cache[obj.data.name] = True
        return True

-    def get_element_by_guid(self, guid):
-        try:
-            return tool.Ifc.get().by_guid(guid)
-        except:
-            for link in bpy.context.scene.BIMProjectProperties.links:
-                if link.name not in IfcStore.session_files:
-                    IfcStore.session_files[link.name] = ifcopenshell.open(link.name)
-                try:
-                    return IfcStore.session_files[link.name].by_guid(guid)
-                except:
-                    continue
-
    def merge_linework_and_add_metadata(self, root):
        join_criteria = ifcopenshell.util.element.get_pset(self.camera_element, "EPset_Drawing", "JoinCriteria")
        if join_criteria:
@@ -968,7 +925,7 @@ class CreateDrawing(bpy.types.Operator):

        ifc = tool.Ifc.get()
        for el in root.findall(".//{http://www.w3.org/2000/svg}g[@{http://www.ifcopenshell.org/ns}guid]"):
-            element = self.get_element_by_guid(el.get("{http://www.ifcopenshell.org/ns}guid"))
+            element = ifc.by_guid(el.get("{http://www.ifcopenshell.org/ns}guid"))

            if "projection" in el.get("class", "").split():
                classes = self.get_svg_classes(element)
@@ -981,10 +938,6 @@ class CreateDrawing(bpy.types.Operator):
                el.set("class", " ".join(classes))

            obj = tool.Ifc.get_object(element)
-
-            if not obj: # This is a linked model object. For now, do nothing.
-                continue
-
            if not self.is_manifold(obj):
                continue

@@ -1162,14 +1115,14 @@ class CreateDrawing(bpy.types.Operator):
                    continue
                return space

-    def get_material_name(self, element: ifcopenshell.entity_instance) -> str:
+    def get_material_name(self, element):
        if hasattr(element, "Name") and element.Name:
            return element.Name
        elif hasattr(element, "LayerSetName") and element.LayerSetName:
            return element.LayerSetName
        return "mat-" + str(element.id())

-    def get_svg_path(self, cache_type: Optional[str] = None) -> str:
+    def get_svg_path(self, cache_type=None):
        drawing_path = tool.Drawing.get_document_uri(self.camera_document)
        drawings_dir = os.path.dirname(drawing_path)

@@ -1266,14 +1219,12 @@ class AddDrawingToSheet(bpy.types.Operator, Operator):
            return

        reference = tool.Ifc.run("document.add_reference", information=sheet)
-        attributes = tool.Drawing.generate_reference_attributes(
-            reference,
-            Identification=str(
-                len([r for r in references if tool.Drawing.get_reference_description(r) in ("DRAWING", "SCHEDULE")]) + 1
-            ),
-            Location=drawing_reference.Location,
-            Description="DRAWING",
-        )
+        id_attr = "ItemReference" if tool.Ifc.get_schema() == "IFC2X3" else "Identification"
+        attributes = {
+            id_attr: str(len([r for r in references if r.Description in ("DRAWING", "SCHEDULE")]) + 1),
+            "Location": drawing_reference.Location,
+            "Description": "DRAWING",
+        }
        tool.Ifc.run("document.edit_reference", reference=reference, attributes=attributes)
        sheet_builder = sheeter.SheetBuilder()
        sheet_builder.data_dir = context.scene.BIMProperties.data_dir
@@ -1341,10 +1292,9 @@ class CreateSheets(bpy.types.Operator, Operator):

        has_sheet_reference = False
        for reference in tool.Drawing.get_document_references(sheet):
-            reference_description = tool.Drawing.get_reference_description(reference)
-            if reference_description == "SHEET":
+            if reference.Description == "SHEET":
                has_sheet_reference = True
-            elif reference_description == "RASTER":
+            elif reference.Description == "RASTER":
                if reference.Location in raster_references:
                    raster_references.remove(reference.Location)
                else:
@@ -1355,9 +1305,7 @@ class CreateSheets(bpy.types.Operator, Operator):
            tool.Ifc.run(
                "document.edit_reference",
                reference=reference,
-                attributes=tool.Drawing.generate_reference_attributes(
-                    reference, Location=tool.Ifc.get_relative_uri(svg), Description="SHEET"
-                ),
+                attributes={"Location": tool.Ifc.get_relative_uri(svg), "Description": "SHEET"},
            )

        for raster_reference in raster_references:
@@ -1365,9 +1313,7 @@ class CreateSheets(bpy.types.Operator, Operator):
            tool.Ifc.run(
                "document.edit_reference",
                reference=reference,
-                attributes=tool.Drawing.generate_reference_attributes(
-                    reference, Location=tool.Ifc.get_relative_uri(raster_reference), Description="RASTER"
-                ),
+                attributes={"Location": tool.Ifc.get_relative_uri(raster_reference), "Description": "RASTER"},
            )

        svg2pdf_command = context.preferences.addons["blenderbim"].preferences.svg2pdf_command
@@ -1476,19 +1422,13 @@ class ActivateModel(bpy.types.Operator):

        CutDecorator.uninstall()

-        # save current visibility statuses for Views and Types collections
-        visibility_status: dict[bpy.types.Object, bool] = {}
-        for col in bpy.data.collections["Views"].children:
-            for obj in col.objects:
-                visibility_status[obj] = obj.hide_get()
-        for obj in bpy.data.collections["Types"].objects:
-            visibility_status[obj] = obj.hide_get()
-
        if not bpy.app.background:
            with context.temp_override(**tool.Blender.get_viewport_context()):
                bpy.ops.object.hide_view_clear()
                bpy.ops.bim.activate_status_filters()

+        subcontext = ifcopenshell.util.representation.get_context(tool.Ifc.get(), "Model", "Body", "MODEL_VIEW")
+
        for obj in context.visible_objects:
            element = tool.Ifc.get_entity(obj)
            if not element:
@@ -1506,11 +1446,6 @@ class ActivateModel(bpy.types.Operator):
                        is_global=True,
                        should_sync_changes_first=True,
                    )
-
-        # restore visibility after hide_view_clear()
-        for obj, hide_status in visibility_status.items():
-            obj.hide_set(hide_status)
-
        tool.Blender.update_viewport()
        return {"FINISHED"}

@@ -1519,48 +1454,40 @@ class ActivateDrawing(bpy.types.Operator):
    bl_idname = "bim.activate_drawing"
    bl_label = "Activate Drawing"
    bl_options = {"REGISTER", "UNDO"}
-    bl_description = "Activates the selected drawing view.\n\n" + "ALT+CLICK to keep the viewport position.\n\n" + "SHIFT+CLICK activiate drawing without turning objects on/off."
+    bl_description = "Activates the selected drawing view.\n\n" + "ALT+CLICK to keep the viewport position"

    drawing: bpy.props.IntProperty()
    camera_view_point: bpy.props.BoolProperty(name="Camera View Point", default=True, options={"SKIP_SAVE"})
-    switch_camera_only: bpy.props.BoolProperty(name="Only Changes Camera View", default=False, options={"SKIP_SAVE"})

    def invoke(self, context, event):
        # keep the viewport position on alt+click
        # make sure to use SKIP_SAVE on property, otherwise it might get stuck
        if event.type == "LEFTMOUSE" and event.alt:
            self.camera_view_point = False
-        # Only activates the camera view on alt+shift.  Does not turn on/off objects in scene
-        if event.type == "LEFTMOUSE" and event.shift:
-            self.switch_camera_only = True
        return self.execute(context)

    def execute(self, context):
        drawing = tool.Ifc.get().by_id(self.drawing)
        dprops = bpy.context.scene.DocProperties
-        camera = tool.Drawing.import_drawing(drawing)

-        if self.switch_camera_only:
-            tool.Blender.activate_camera(camera)
-        else:
-            if not self.camera_view_point:
-                viewport_position = tool.Blender.get_viewport_position()
+        if not self.camera_view_point:
+            viewport_position = tool.Blender.get_viewport_position()

+        core.activate_drawing_view(tool.Ifc, tool.Drawing, drawing=drawing)

+        if not self.camera_view_point:
+            tool.Blender.set_viewport_position(viewport_position)

-            if not self.camera_view_point:
-                tool.Blender.set_viewport_position(viewport_position)
-
-            dprops.active_drawing_id = self.drawing
-            # reset DrawingsData to reload_drawing_styles work correctly
-            DrawingsData.is_loaded = False
-            dprops.drawing_styles.clear()
-            if ifcopenshell.util.element.get_pset(drawing, "EPset_Drawing", "HasUnderlay"):
-                bpy.ops.bim.reload_drawing_styles()
-                bpy.ops.bim.activate_drawing_style()
-            core.sync_references(tool.Ifc, tool.Collector, tool.Drawing, drawing=tool.Ifc.get().by_id(self.drawing))
-            CutDecorator.install(context)
-            tool.Drawing.show_decorations()
+        dprops.active_drawing_id = self.drawing
+        # reset DrawingsData to reload_drawing_styles work correctly
+        DrawingsData.is_loaded = False
+        dprops.drawing_styles.clear()
+        if ifcopenshell.util.element.get_pset(drawing, "EPset_Drawing", "HasUnderlay"):
+            bpy.ops.bim.reload_drawing_styles()
+            bpy.ops.bim.activate_drawing_style()
+        core.sync_references(tool.Ifc, tool.Collector, tool.Drawing, drawing=tool.Ifc.get().by_id(self.drawing))
+        CutDecorator.install(context)
+        tool.Drawing.show_decorations()
        return {"FINISHED"}


@@ -1640,7 +1567,7 @@ class ReloadDrawingStyles(bpy.types.Operator):
        if not DrawingsData.is_loaded:
            DrawingsData.load()
        drawing_pset_data = DrawingsData.data["active_drawing_pset_data"]
-        camera_props = context.scene.camera.data.BIMCameraProperties
+        camera_props = context.active_object.data.BIMCameraProperties

        # added this part as a temporary fallback
        # TODO: should remove it a bit later when projects get more accommodated
@@ -1669,14 +1596,8 @@ class ReloadDrawingStyles(bpy.types.Operator):

        json_path = Path(tool.Ifc.resolve_uri(rel_path))
        if not json_path.exists():
-            ootb_resource = Path(context.scene.BIMProperties.data_dir) / "assets" / "shading_styles.json"
-            print(
-                f"WARNING. Couldn't find shading_styles for the drawing by the path: {json_path}. "
-                f"Default BBIM resource will be copied from {ootb_resource}"
-            )
-            if ootb_resource.exists():
-                os.makedirs(json_path.parent, exist_ok=True)
-                shutil.copy(ootb_resource, json_path)
+            self.report({"ERROR"}, "Shading styles file not found: {}".format(json_path))
+            return {"CANCELLED"}

        with open(json_path, "r") as fi:
            shading_styles_json = json.load(fi)
@@ -2039,14 +1960,12 @@ class AddScheduleToSheet(bpy.types.Operator, Operator):
            return

        reference = tool.Ifc.run("document.add_reference", information=sheet)
-        attributes = tool.Drawing.generate_reference_attributes(
-            reference,
-            Identification=str(
-                len([r for r in references if tool.Drawing.get_reference_description(r) in ("DRAWING", "SCHEDULE")]) + 1
-            ),
-            Location=schedule_location,
-            Description="SCHEDULE",
-        )
+        id_attr = "ItemReference" if tool.Ifc.get_schema() == "IFC2X3" else "Identification"
+        attributes = {
+            id_attr: str(len([r for r in references if r.Description in ("DRAWING", "SCHEDULE")]) + 1),
+            "Location": schedule_location,
+            "Description": "SCHEDULE",
+        }
        tool.Ifc.run("document.edit_reference", reference=reference, attributes=attributes)

        sheet_builder = sheeter.SheetBuilder()
@@ -2095,15 +2014,12 @@ class AddReferenceToSheet(bpy.types.Operator, Operator):
            return

        reference = tool.Ifc.run("document.add_reference", information=sheet)
-        attributes = tool.Drawing.generate_reference_attributes(
-            reference,
-            Identification=str(
-                len([r for r in references if tool.Drawing.get_reference_description(r) in ("DRAWING", "REFERENCE")])
-                + 1
-            ),
-            Location=extref_location,
-            Description="REFERENCE",
-        )
+        id_attr = "ItemReference" if tool.Ifc.get_schema() == "IFC2X3" else "Identification"
+        attributes = {
+            id_attr: str(len([r for r in references if r.Description in ("DRAWING", "REFERENCE")]) + 1),
+            "Location": extref_location,
+            "Description": "REFERENCE",
+        }
        tool.Ifc.run("document.edit_reference", reference=reference, attributes=attributes)

        sheet_builder = sheeter.SheetBuilder()
@@ -2429,7 +2345,6 @@ class LoadSheets(bpy.types.Operator, Operator):
            if not filepath.is_file():
                sheet_name = f"{sheet_prop.identification} - {sheet_prop.name}"
                sheets_not_found.append(f'"{sheet_name}" - {document_uri}')
-                core.regenerate_sheet(tool.Drawing, sheet)

        if sheets_not_found:
            self.report({"ERROR"}, "Some sheets svg files are missing:\n" + "\n".join(sheets_not_found))
@@ -2448,8 +2363,8 @@ class EditSheet(bpy.types.Operator, Operator):
        if sheet.is_a("IfcDocumentInformation"):
            self.document_type = "SHEET"
            self.name = sheet.Name
-            self.identification = sheet.DocumentId if tool.Ifc.get_schema() == "IFC2X3" else sheet.Identification
-        elif sheet.is_a("IfcDocumentReference") and tool.Drawing.get_reference_description(sheet) == "TITLEBLOCK":
+            self.identification = sheet.Identification
+        elif sheet.is_a("IfcDocumentReference") and sheet.Description == "TITLEBLOCK":
            self.document_type = "TITLEBLOCK"
        else:
            self.document_type = "EMBEDDED"
@@ -2475,7 +2390,7 @@ class EditSheet(bpy.types.Operator, Operator):
        if self.document_type == "SHEET":
            core.rename_sheet(tool.Ifc, tool.Drawing, sheet=sheet, identification=self.identification, name=self.name)
        elif self.document_type == "EMBEDDED":
-            core.rename_reference(tool.Ifc, tool.Drawing, reference=sheet, identification=self.identification)
+            core.rename_reference(tool.Ifc, reference=sheet, identification=self.identification)
        elif self.document_type == "TITLEBLOCK":
            titleblock = self.props.titleblock
            reference = sheet
@@ -2627,16 +2542,8 @@ class EnableEditingElementFilter(bpy.types.Operator, Operator):

    def _execute(self, context):
        obj = bpy.context.scene.camera
-        if not obj:
-            return
-        obj.data.BIMCameraProperties.filter_mode = self.filter_mode
-        element = tool.Ifc.get_entity(obj)
-        if query := ifcopenshell.util.element.get_pset(element, "EPset_Drawing", self.filter_mode.title()):
-            filter_groups = tool.Search.get_filter_groups(f"drawing_{self.filter_mode.lower()}")
-            try:
-                tool.Search.import_filter_query(query, filter_groups)
-            except:
-                pass
+        if obj:
+            obj.data.BIMCameraProperties.filter_mode = self.filter_mode


 class EditElementFilter(bpy.types.Operator, Operator):
@@ -2778,50 +2685,3 @@ class AddReferenceImage(bpy.types.Operator, Operator):
        )
        tool.Style.reload_material_from_ifc(material)
        tool.Geometry.record_object_materials(obj)
-
-
-class ConvertSVGToDXF(bpy.types.Operator):
-    bl_idname = "bim.convert_svg_to_dxf"
-    bl_label = "Convert SVG to DXF"
-    bl_options = {"REGISTER", "UNDO"}
-    view: bpy.props.StringProperty()
-    bl_description = "Convert current drawing's .svg to .dxf.\n\nSHIFT+CLICK to convert all selected drawings"
-    convert_all: bpy.props.BoolProperty(name="Convert All", default=False, options={"SKIP_SAVE"})
-
-    def invoke(self, context, event):
-        # convert all drawings on shift+click
-        # make sure to use SKIP_SAVE on property, otherwise it might get stuck
-        if event.type == "LEFTMOUSE" and event.shift:
-            self.open_all = True
-        return self.execute(context)
-
-    def execute(self, context):
-        if self.convert_all:
-            drawings = [
-                tool.Ifc.get().by_id(d.ifc_definition_id) for d in context.scene.DocProperties.drawings if d.is_selected
-            ]
-        else:
-            drawings = [tool.Ifc.get().by_id(context.scene.DocProperties.drawings.get(self.view).ifc_definition_id)]
-
-        drawing_uris: list[Path] = []
-        drawings_not_found: list[str] = []
-
-        for drawing in drawings:
-            drawing_uri = tool.Drawing.get_document_uri(tool.Drawing.get_drawing_document(drawing))
-            if drawing_uri is None or not os.path.exists(drawing_uri):
-                drawings_not_found.append(drawing.Name)
-            else:
-                drawing_uris.append(Path(drawing_uri))
-
-        if drawings_not_found:
-            msg = "Some drawings .svg files were not found, need to print them first: \n{}.".format(
-                "\n".join(drawings_not_found)
-            )
-            self.report({"ERROR"}, msg)
-            return {"CANCELLED"}
-
-        for drawing_uri in drawing_uris:
-            tool.Drawing.convert_svg_to_dxf(drawing_uri, drawing_uri.with_suffix(".dxf"))
-
-        self.report({"INFO"}, f"{len(drawing_uris)} drawings were converted to .dxf.")
-        return {"FINISHED"}
@@ -66,11 +66,6 @@ def get_location_hint(self, context):


 def update_diagram_scale(self, context):
-    if not context.scene.camera or context.scene.camera.data != self.id_data:
-        return
-    element = tool.Ifc.get_entity(context.scene.camera)
-    if not element:
-        return
    try:
        element = (
            tool.Ifc.get()
@@ -92,11 +87,6 @@ def update_diagram_scale(self, context):


 def update_is_nts(self, context):
-    if not context.scene.camera or context.scene.camera.data != self.id_data:
-        return
-    element = tool.Ifc.get_entity(context.scene.camera)
-    if not element:
-        return
    try:
        element = (
            tool.Ifc.get()
@@ -204,7 +194,7 @@ def update_document_name(self, context):
 def update_has_underlay(self, context):
    update_layer(self, context, "HasUnderlay", self.has_underlay)
    # making sure that camera is active
-    if self.has_underlay and (context.scene.camera and context.scene.camera.data == self.id_data):
+    if self.has_underlay and (context.active_object and context.active_object.data == self.id_data):
        bpy.ops.bim.reload_drawing_styles()
        bpy.ops.bim.activate_drawing_style()

@@ -218,12 +208,10 @@ def update_has_annotation(self, context):


 def update_layer(self, context, name, value):
-    if not context.scene.camera or context.scene.camera.data != self.id_data:
-        return
-    element = tool.Ifc.get_entity(context.scene.camera)
+    element = tool.Ifc.get_entity(context.active_object)
    if not element:
        return
-    pset = ifcopenshell.util.element.get_pset(element, "EPset_Drawing")
+    pset = ifcopenshell.util.element.get_psets(element).get("EPset_Drawing")
    if pset:
        pset = tool.Ifc.get().by_id(pset["id"])
    else:
@@ -241,8 +229,9 @@ def update_titleblocks(self, context):
    SheetsData.data["titleblocks"] = SheetsData.titleblocks()


-def update_should_draw_decorations(self, context):
-    if self.should_draw_decorations:
+def toggleDecorations(self, context):
+    toggle = self.should_draw_decorations
+    if toggle:
        # TODO: design a proper text variable templating renderer
        collection = context.scene.camera.BIMObjectProperties.collection
        for obj in collection.objects:
@@ -315,7 +304,9 @@ class RasterStyleProperty(enum.Enum):
    SPACE_SHADING = "space.shading"


-RASTER_STYLE_PROPERTIES_EXCLUDE = ("scene.render.filepath",)
+RASTER_STYLE_PROPERTIES_EXCLUDE = (
+    "scene.render.filepath",
+)


 class DocProperties(PropertyGroup):
@@ -352,7 +343,7 @@ class DocProperties(PropertyGroup):
    active_sheet_index: IntProperty(name="Active Sheet Index")
    ifc_files: CollectionProperty(name="IFCs", type=StrProperty)
    drawing_styles: CollectionProperty(name="Drawing Styles", type=DrawingStyle)
-    should_draw_decorations: BoolProperty(name="Should Draw Decorations", update=update_should_draw_decorations)
+    should_draw_decorations: BoolProperty(name="Should Draw Decorations", update=toggleDecorations)
    sheets_dir: StringProperty(default=os.path.join("sheets") + os.path.sep, name="Default Sheets Directory")
    layouts_dir: StringProperty(default=os.path.join("layouts") + os.path.sep, name="Default Layouts Directory")
    titleblocks_dir: StringProperty(
@@ -369,8 +360,6 @@ class DocProperties(PropertyGroup):
        default=os.path.join("drawings", "assets", "shading_styles.json"), name="Default Shading Styles"
    )
    shadingstyle_default: StringProperty(default="Blender Default", name="Default Shading Style")
-    drawing_font: StringProperty(default="OpenGost Type B TT.ttf", name="Drawing Font")
-    magic_font_scale: bpy.props.FloatProperty(default=0.004118616, name="Font Scale Factor")


 class BIMCameraProperties(PropertyGroup):
@@ -16,21 +16,22 @@
 # 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 re
-import bpy
-import string
+from blenderbim.bim.module.drawing.svgwriter import SvgWriter
 import svgwrite
 import openpyxl

-from blenderbim.bim.module.drawing.svgwriter import SvgWriter
 from odf.opendocument import load as load_ods
 from odf.table import Table, TableRow, TableColumn, TableCell
 from odf.text import P
 from odf.style import Style
 from textwrap import wrap
 from pathlib import Path
+import string

+FONT_SIZE = 4.13
+FONT_WIDTH = lambda size: size * 0.45
+FONT_SIZE_PT = 12
+FONT_FAMILY = "OpenGost Type B TT"
 DEBUG = False


@@ -62,29 +63,11 @@ class Scheduler:
        )
        self.padding = 1
        self.margin = 1
-
-        self.parse_css(infile)
        if infile.endswith("ods"):
            self.schedule_ods(infile, outfile)
        elif infile.endswith("xlsx"):
            self.schedule_xlsx(infile, outfile)

-    def parse_css(self, infile):
-        stylesheet_path = os.path.splitext(infile)[0] + ".css"
-        if not os.path.exists(stylesheet_path):
-            stylesheet_path = os.path.join(bpy.context.scene.BIMProperties.data_dir, "assets", "schedule.css")
-        with open(stylesheet_path, "r") as stylesheet:
-            css = stylesheet.read()
-
-        matches = re.search("--font-size-pt:\s*([0-9.]+);", css)
-        self.font_size_pt = float(matches.groups()[0]) if matches else 12  # Default to 12pt
-        matches = re.search("--font-size-px:\s*([0-9.]+);", css)
-        self.font_size_px = float(matches.groups()[0]) if matches else 4.13  # Magic number 4.13px ~= 12pt
-        matches = re.search("--font-width:\s*([0-9.]+);", css)
-        self.font_width = float(matches.groups()[0]) if matches else 0.45  # A magic number for OpenGost
-
-        self.svg.defs.add(self.svg.style(css))
-
    def schedule_xlsx(self, infile, outfile):
        workbook = openpyxl.open(infile, data_only=True)
        sheet = workbook.active
@@ -161,8 +144,8 @@ class Scheduler:
                    x += unmerged_width
                    continue

-                font_size = cell.font.size or self.font_size_pt  # 12pt default
-                font_size = font_size / self.font_size_pt * self.font_size_px  # Magic?
+                font_size = cell.font.size or 11  # 11pt default
+                font_size = font_size / FONT_SIZE_PT * FONT_SIZE  # Magic?

                text_position = [0.0, 0.0]
                if cell.alignment.horizontal == "left":
@@ -441,9 +424,9 @@ class Scheduler:
                        italic_text = final_cell_style.get("font-style", None) == "italic"
                        # NOTE: very naive since we're scaling text proportionally
                        font_size = (
-                            float(final_cell_style.get("font-size", f"{self.font_size_pt}pt")[:-2])
-                            / self.font_size_pt
-                            * self.font_size_px
+                            float(final_cell_style.get("font-size", f"{FONT_SIZE_PT}pt")[:-2])
+                            / FONT_SIZE_PT
+                            * FONT_SIZE
                        )

                        if p_tags:
@@ -540,7 +523,10 @@ class Scheduler:
        """
        text_lines = [str(p) for p in p_tags]
        box_alignment_params = SvgWriter.get_box_alignment_parameters(box_alignment)
-        text_params = {"font-size": font_size}
+        text_params = {
+            "font-size": font_size,
+            "font-family": FONT_FAMILY,
+        }
        if bold:
            text_params["font-weight"] = "bold"
        if italic:
@@ -560,13 +546,13 @@ class Scheduler:

        text_tag = self.svg.text("", **(text_params | {"font-size": "0"} | box_alignment_params))

-        # TODO: Should be done without using magic number for self.font_width 
+        # TODO: should be done in less naive way
+        # without using magic number for FONT_WIDTH
+        # currently it might not work for all fonts and font sizes
        if wrap_text:
            wrapped_lines = []
            for line in text_lines:
-                wrapped_line = wrap(
-                    line, width=int(cell_width // (font_size * self.font_width)), break_long_words=False
-                )
+                wrapped_line = wrap(line, width=int(cell_width // FONT_WIDTH(font_size)), break_long_words=False)
                wrapped_lines.extend(wrapped_line)
        else:
            wrapped_lines = text_lines
@@ -41,7 +41,7 @@ class SheetBuilder:
        self.data_dir = None
        self.scale = "NTS"

-    def create(self, layout_path: str, titleblock_name: str) -> None:
+    def create(self, layout_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"
@@ -76,12 +76,7 @@ class SheetBuilder:
        with open(layout_path, "w") as f:
            f.write(minidom.parseString(ET.tostring(root)).toprettyxml(indent="    "))

-    def add_drawing(
-        self,
-        reference: ifcopenshell.entity_instance,
-        drawing: ifcopenshell.entity_instance,
-        sheet: ifcopenshell.entity_instance,
-    ) -> None:
+    def add_drawing(self, reference, drawing, sheet):
        filename = drawing.Name
        layout_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
        layout_dir = os.path.dirname(layout_path)
@@ -136,7 +131,7 @@ class SheetBuilder:
        )
        layout_tree.write(layout_path)

-    def update_sheet_drawing_sizes(self, sheet: ifcopenshell.entity_instance) -> None:
+    def update_sheet_drawing_sizes(self, sheet):
        ET.register_namespace("", "http://www.w3.org/2000/svg")

        layout_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
@@ -176,7 +171,7 @@ class SheetBuilder:

        layout_tree.write(layout_path)

-    def remove_drawing(self, reference: ifcopenshell.entity_instance, sheet: ifcopenshell.entity_instance) -> None:
+    def remove_drawing(self, reference, sheet):
        ET.register_namespace("", "http://www.w3.org/2000/svg")

        layout_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
@@ -192,12 +187,7 @@ class SheetBuilder:

        layout_tree.write(layout_path)

-    def add_document(
-        self,
-        reference: ifcopenshell.entity_instance,
-        document: ifcopenshell.entity_instance,
-        sheet: ifcopenshell.entity_instance,
-    ) -> None:
+    def add_document(self, reference, document, sheet):
        view_path = tool.Drawing.get_path_with_ext(tool.Drawing.get_document_uri(document), "svg")
        if not os.path.exists(view_path):
            tool.Drawing.create_svg_document(document)
@@ -234,7 +224,7 @@ class SheetBuilder:
        )
        layout_tree.write(layout_path)

-    def add_view_title(self, x: float, y: float, parent: ET.Element, layout_dir: str) -> None:
+    def add_view_title(self, x, y, parent, layout_dir):
        title_path = os.path.join(layout_dir, "assets", "view-title.svg")
        os.makedirs(os.path.dirname(title_path), exist_ok=True)
        if not os.path.exists(title_path):
@@ -251,7 +241,7 @@ class SheetBuilder:
        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: ifcopenshell.entity_instance) -> dict:
+    def build(self, sheet):
        self.references = {"SHEET": None, "RASTER": []}

        layout_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
@@ -282,7 +272,7 @@ class SheetBuilder:

        return self.references

-    def build_titleblock(self, root: ET.Element, sheet: ifcopenshell.entity_instance) -> None:
+    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]
        g = self.parse_embedded_svg(image, sheet.get_info())
@@ -295,7 +285,7 @@ class SheetBuilder:
        titleblock.append(g)
        titleblock.remove(image)

-    def ensure_drawing_unique_styles(self, svg: ET.Element, drawing_id: int) -> ET.Element:
+    def ensure_drawing_unique_styles(self, svg, drawing_id):
        """ensures all drawing's classes and ids will be unique for the whole sheet
        by adding `drawing_id` based prefix
        """
@@ -323,7 +313,7 @@ class SheetBuilder:
                brackets_level -= 1
            text += l

-        def replace_urls(text: str) -> str:
+        def replace_urls(text):
            """replace urls `url(#marker)` with `url(#prefix-marker)`
            since `url(#marker.prefix)` doesn't seem to work
            """
@@ -353,7 +343,7 @@ class SheetBuilder:

        return svg

-    def build_drawings(self, root: ET.Element, sheet: ifcopenshell.entity_instance):
+    def build_drawings(self, root, sheet):
        for view in root.findall('{http://www.w3.org/2000/svg}g[@data-type="drawing"]'):
            drawing_id = int(view.attrib["data-id"])
            try:
@@ -400,7 +390,7 @@ class SheetBuilder:
            for image in images:
                view.remove(image)

-    def build_documents(self, root: ET.Element, sheet: ifcopenshell.entity_instance) -> None:
+    def build_documents(self, root, sheet):
        schedules = root.findall('{http://www.w3.org/2000/svg}g[@data-type="schedule"]')
        references = root.findall('{http://www.w3.org/2000/svg}g[@data-type="reference"]')
        documents = schedules + references
@@ -437,10 +427,10 @@ class SheetBuilder:
            for image in images:
                view.remove(image)

-    def get_href(self, element: ET.Element) -> str:
-        return urllib.parse.unquote(element.attrib.get("{http://www.w3.org/1999/xlink}href")).replace("\\", "/")
+    def get_href(self, element):
+        return urllib.parse.unquote(element.attrib.get("{http://www.w3.org/1999/xlink}href")).replace('\\','/')

-    def parse_embedded_svg(self, image: ET.Element, data: dict) -> ET.Element:
+    def parse_embedded_svg(self, image, data):
        group = ET.Element("g")
        group.attrib["transform"] = "translate({},{})".format(
            self.convert_to_mm(image.attrib.get("x")), self.convert_to_mm(image.attrib.get("y"))
@@ -476,7 +466,7 @@ class SheetBuilder:
            group.append(child)
        return group

-    def change_titleblock(self, sheet: ifcopenshell.entity_instance, titleblock_name: str) -> None:
+    def change_titleblock(self, sheet, titleblock_name):
        ootb_titleblock_path = os.path.join(self.data_dir, "templates", "titleblocks", titleblock_name + ".svg")
        titleblock_path = tool.Drawing.get_default_titleblock_path(titleblock_name)
        sheet_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
@@ -509,7 +499,7 @@ class SheetBuilder:

        sheet_tree.write(sheet_path)

-    def convert_to_mm(self, value: str) -> float:
+    def convert_to_mm(self, value):
        # CSS is what defines these possibilities
        # https://www.w3.org/TR/SVG/refs.html#ref-css-values-3
        # https://www.w3.org/TR/css-values-3/#absolute-lengths
@@ -530,5 +520,5 @@ class SheetBuilder:
            return float(value[0:-2]) * (1 / 96) * 2.54 * 10
        return float(value)

-    def mm_to_px(self, value: float) -> float:
+    def mm_to_px(self, value):
        return (value / 25.4) * 96
@@ -22,6 +22,7 @@ import bpy
 import math
 import bmesh
 import shutil
+import pystache
 import mathutils
 import xml.etree.ElementTree as ET
 import svgwrite
@@ -92,7 +93,7 @@ class SvgWriter:

    def setup_drawing_resource_paths(self, element):
        pset = ifcopenshell.util.element.get_pset(element, "EPset_Drawing")
-        for resource in ("Stylesheet", "Markers", "Symbols", "Patterns", "ShadingStyles"):
+        for resource in ("Stylesheet", "Markers", "Symbols", "Patterns"):
            resource_path = pset.get(resource)
            if not resource_path:
                self.resource_paths[resource] = None
@@ -718,15 +719,14 @@ class SvgWriter:
            self.svg.text(sheet_id, insert=(text_position[0], text_position[1] + 2.5), class_="ELEVATION", **text_style)
        )

-    def get_reference_and_sheet_id_from_annotation(self, element: ifcopenshell.entity_instance) -> tuple[str, str]:
+    def get_reference_and_sheet_id_from_annotation(self, element):
        reference_id = "-"
        sheet_id = "-"
        drawing = tool.Drawing.get_annotation_element(element)
        reference = tool.Drawing.get_drawing_reference(drawing)
        if reference:
            for sheet_reference in tool.Ifc.get().by_type("IfcDocumentReference"):
-                reference_description = tool.Drawing.get_reference_description(sheet_reference)
-                if reference_description != "DRAWING" or sheet_reference.Location != reference.Location:
+                if sheet_reference.Description != "DRAWING" or sheet_reference.Location != reference.Location:
                    continue
                sheet = tool.Drawing.get_reference_document(sheet_reference)
                if sheet:
@@ -268,11 +268,6 @@ class BIM_PT_drawings(Panel):
                col = row.column()
                col.alignment = "RIGHT"

-                convert_to_dxf = row.row(align=True)
-                op = convert_to_dxf.operator("bim.convert_svg_to_dxf", text="", icon="IMAGE_DATA")
-                op.view = active_drawing.name
-                convert_to_dxf.enabled = active_drawing.ifc_definition_id > 0
-
                op = row.operator("bim.select_all_drawings", icon="SELECT_SUBTRACT", text="")

                open_drawing_button = row.row(align=True)
@@ -22,20 +22,13 @@ from . import ui, prop, operator
 classes = (
    operator.AddRepresentation,
    operator.CopyRepresentation,
-    operator.DisableEditingRepresentationItemShapeAspect,
-    operator.DisableEditingRepresentationItemStyle,
    operator.DisableEditingRepresentationItems,
-    operator.DuplicateLinkedAggregateTo3dCursor,
-    operator.DuplicateMoveLinkedAggregate,
-    operator.DuplicateMoveLinkedAggregateMacro,
    operator.EditObjectPlacement,
-    operator.EditRepresentationItemShapeAspect,
-    operator.EditRepresentationItemStyle,
-    operator.EnableEditingRepresentationItemShapeAspect,
-    operator.EnableEditingRepresentationItemStyle,
    operator.EnableEditingRepresentationItems,
    operator.FlipObject,
    operator.GetRepresentationIfcParameters,
+    operator.DuplicateMoveLinkedAggregate,
+    operator.DuplicateMoveLinkedAggregateMacro,
    operator.OverrideDelete,
    operator.OverrideDuplicateMove,
    operator.OverrideDuplicateMoveLinked,
@@ -52,13 +45,19 @@ classes = (
    operator.RefreshLinkedAggregate,
    operator.RemoveConnection,
    operator.RemoveRepresentation,
-    operator.RemoveRepresentationItem,
-    operator.RemoveRepresentationItemFromShapeAspect,
    operator.SelectConnection,
    operator.SwitchRepresentation,
-    operator.UnassignRepresentationItemStyle,
    operator.UpdateParametricRepresentation,
    operator.UpdateRepresentation,
+    operator.RemoveRepresentationItem,
+    operator.EnableEditingRepresentationItemStyle,
+    operator.EditRepresentationItemStyle,
+    operator.DisableEditingRepresentationItemStyle,
+    operator.UnassignRepresentationItemStyle,
+    operator.EnableEditingRepresentationItemShapeAspect,
+    operator.EditRepresentationItemShapeAspect,
+    operator.DisableEditingRepresentationItemShapeAspect,
+    operator.RemoveRepresentationItemFromShapeAspect,
    prop.RepresentationItem,
    prop.ShapeAspect,
    prop.BIMObjectGeometryProperties,
@@ -120,7 +119,6 @@ def register():

        km = wm.keyconfigs.addon.keymaps.new(name="Mesh", space_type="EMPTY")
        kmi = km.keymap_items.new("bim.override_mode_set_object", "TAB", "PRESS")
-        kmi.properties.should_save = True
        addon_keymaps.append((km, kmi))
        kmi = km.keymap_items.new("wm.call_menu", "P", "PRESS")
        kmi.properties.name = ui.BIM_MT_hotkey_separate.bl_idname
@@ -17,7 +17,6 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.

 import bpy
-import ifcopenshell.util.element
 import blenderbim.tool as tool
 import ifcopenshell.util.placement
 from mathutils import Vector
@@ -223,7 +222,7 @@ class ConnectionsData:
    @classmethod
    def is_connection_realization(cls):
        element = tool.Ifc.get_entity(bpy.context.active_object)
-        connections = getattr(element, "IsConnectionRealization", None)
+        connections = element.IsConnectionRealization
        if not connections:
            return

@@ -21,14 +21,12 @@ import bmesh
 import mathutils
 import ifcopenshell
 import ifcopenshell.util.unit
-import blenderbim.tool as tool
 from math import pi, pow
 from mathutils import Vector, Matrix, geometry
-from typing import Union


 class Helper:
-    def __init__(self, file: ifcopenshell.file):
+    def __init__(self, file):
        self.file = file
        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(self.file)

@@ -36,7 +34,7 @@ class Helper:
    # edge that shares a single vertex only with that face to find the extrusion
    # edge. A face with the normal facing down is prioritised. A limited
    # dissolve ensure that faces are quads and not tris.
-    def auto_detect_rectangle_profile_extruded_area_solid(self, mesh: bpy.types.Mesh) -> dict:
+    def auto_detect_rectangle_profile_extruded_area_solid(self, mesh):
        bm = bmesh.new()
        bm.from_mesh(mesh)
        bmesh.ops.dissolve_limit(bm, angle_limit=pi / 180 * 1, verts=bm.verts, edges=bm.edges)
@@ -117,9 +115,7 @@ class Helper:

        return {"profile": profile, "extrusion": extrusion}

-    def auto_detect_arbitrary_profile_with_voids(
-        self, obj: bpy.types.Object, mesh: bpy.types.Mesh
-    ) -> Union[tuple, dict]:
+    def auto_detect_arbitrary_profile_with_voids(self, obj, mesh):
        groups = {"IFCARCINDEX": [], "IFCCIRCLE": []}
        for i, group in enumerate(obj.vertex_groups):
            if "IFCARCINDEX" in group.name:
@@ -142,31 +138,28 @@ class Helper:
            total_groups = 0
            is_circle = False
            for group_type, group_indices in groups.items():
-                if not group_indices:
-                    continue
-                is_special, group_index = tool.Blender.bmesh_check_vertex_in_groups(vert, deform_layer, group_indices)
-                if not is_special:
-                    continue
-                if group_type == "IFCCIRCLE":
-                    is_circle = True
-                group_verts[group_type].setdefault(group_index, 0)
-                group_verts[group_type][group_index] += 1
-                total_groups += 0
+                for group_index in group_indices:
+                    if group_index in vert[deform_layer]:
+                        if group_type == "IFCCIRCLE":
+                            is_circle = True
+                        group_verts[group_type].setdefault(group_index, 0)
+                        group_verts[group_type][group_index] += 1
+                        total_groups += 0
            if total_groups > 1:  # A vert can only belong to one group
                return (False, "AMBIGUOUS_SPECIAL_VERTEX")
            elif is_circle:
-                pass  # Circles are allowed to be unclosed
+                pass # Circles are allowed to be unclosed
            elif total_groups == 0 and len(vert.link_edges) != 2:  # Unclosed loop or forked loop
                return (False, "UNCLOSED_LOOP")

        for group_type, group_counts in group_verts.items():
            if group_type == "IFCARCINDEX":
                for group_count in group_counts.values():
-                    if group_count != 3:  # Each arc needs 3 verts
+                    if group_count != 3: # Each arc needs 3 verts
                        return (False, "3POINT_ARC")
            elif group_type == "IFCCIRCLE":
                for group_count in group_counts.values():
-                    if group_count != 2:  # Each circle needs 2 verts
+                    if group_count != 2: # Each circle needs 2 verts
                        return (False, "CIRCLE")

        loop_edges = set(bm.edges)
@@ -276,7 +269,7 @@ class Helper:
        inner_loops.remove(outer_loop)

        # Copy vectors to prevent random data mangling after bmesh is freed.
-        points = [v.co.copy() for v in bm.verts]
+        points = [Vector(list(v.co)) for v in bm.verts]

        bm.to_mesh(mesh)
        mesh.update()
@@ -538,7 +531,7 @@ class Helper:
        )
        position = None
        if self.file.schema == "IFC2X3":
-            position = self.file.createIfcAxis2Placement2D(self.file.createIfcCartesianPoint([0.0, 0.0]))
+            position = self.file.createIfcAxis2Placement2D(self.file.createIfcCartesianPoint([0.0, 0.0, 0.0]))
        curve = self.file.createIfcRectangleProfileDef("AREA", None, position, xdim, ydim)
        return {"curve_ucs": curve_ucs, "curve": curve}

@@ -28,7 +28,6 @@ import ifcopenshell.util.element
 import ifcopenshell.util.representation
 import ifcopenshell.util.placement
 import ifcopenshell.api
-import blenderbim.core.geometry
 import blenderbim.core.geometry as core
 import blenderbim.core.aggregate
 import blenderbim.core.style
@@ -40,7 +39,6 @@ from mathutils import Vector, Matrix
 from time import time
 from blenderbim.bim.ifc import IfcStore
 from ifcopenshell.util.shape_builder import ShapeBuilder
-from typing import Any


 class Operator:
@@ -138,23 +136,19 @@ class AddRepresentation(bpy.types.Operator, Operator):
                "for Profile - 2D bounding box by local XZ axes.\n"
                "For other contexts - bounding box is 3d.",
            ),
-            ("OBJECT", "From Object", "Copies geometry from another object"),
-            ("PROJECT", "Full Representation", "Reuses the current representation"),
+            ("PROJECT", "Full Representation", ""),
        ],
        name="Representation Conversion Method",
    )

    def _execute(self, context):
        obj = context.active_object
-        props = context.scene.BIMGeometryProperties
-        oprops = obj.BIMGeometryProperties
-        ifc_context = int(oprops.contexts or "0") or None
+        props = obj.BIMGeometryProperties
+        ifc_context = int(props.contexts or "0") or None
        if not ifc_context:
            return
        ifc_context = tool.Ifc.get().by_id(ifc_context)

-        original_data = obj.data
-
        if self.representation_conversion_method == "OUTLINE":
            if ifc_context.ContextType == "Plan":
                data = tool.Geometry.generate_outline_mesh(obj, axis="+Z")
@@ -171,31 +165,17 @@ class AddRepresentation(bpy.types.Operator, Operator):
            else:
                data = tool.Geometry.generate_3d_box_mesh(obj)
            tool.Geometry.change_object_data(obj, data, is_global=True)
-        elif (
-            self.representation_conversion_method == "OBJECT"
-            and props.representation_from_object
-            and props.representation_from_object.data
-        ):
-            data = tool.Geometry.duplicate_object_data(props.representation_from_object)
-            tool.Geometry.change_object_data(obj, data, is_global=True)

-        try:
-            core.add_representation(
-                tool.Ifc,
-                tool.Geometry,
-                tool.Style,
-                tool.Surveyor,
-                obj=obj,
-                context=ifc_context,
-                ifc_representation_class=None,
-                profile_set_usage=None,
-            )
-        except core.IncompatibleRepresentationError:
-            if obj.data != original_data:
-                tool.Geometry.change_object_data(obj, original_data, is_global=True)
-                bpy.data.meshes.remove(data)
-            self.report({"ERROR"}, "No compatible representation for the context could be created.")
-            return {"CANCELLED"}
+        core.add_representation(
+            tool.Ifc,
+            tool.Geometry,
+            tool.Style,
+            tool.Surveyor,
+            obj=obj,
+            context=ifc_context,
+            ifc_representation_class=None,
+            profile_set_usage=None,
+        )

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)
@@ -203,9 +183,6 @@ class AddRepresentation(bpy.types.Operator, Operator):
    def draw(self, context):
        row = self.layout.row()
        row.prop(self, "representation_conversion_method", text="")
-        if self.representation_conversion_method == "OBJECT":
-            row = self.layout.row()
-            row.prop(context.scene.BIMGeometryProperties, "representation_from_object", text="")


 class SelectConnection(bpy.types.Operator, Operator):
@@ -238,13 +215,6 @@ class SwitchRepresentation(bpy.types.Operator, Operator):
    disable_opening_subtractions: bpy.props.BoolProperty()
    should_switch_all_meshes: bpy.props.BoolProperty()

-    @classmethod
-    def poll(cls, context):
-        if context.active_object.mode == "OBJECT":
-            return True
-        cls.poll_message_set("Only available in OBJECT mode - Press TAB in the viewport")
-        return False
-
    def _execute(self, context):
        target_representation = tool.Ifc.get().by_id(self.ifc_definition_id)
        target = target_representation.ContextOfItems
@@ -253,8 +223,6 @@ class SwitchRepresentation(bpy.types.Operator, Operator):
            element = tool.Ifc.get_entity(obj)
            if not element:
                continue
-            if not obj.mode == "OBJECT":
-                continue
            if obj == context.active_object:
                representation = target_representation
            else:
@@ -356,8 +324,8 @@ class UpdateRepresentation(bpy.types.Operator, Operator):
                # We are explicitly casting to a tessellation, so remove all parametric materials.
                element_type = ifcopenshell.util.element.get_type(product)
                if element_type:  # Some invalid IFCs use material sets without a type.
-                    ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), products=[element_type])
-                ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), products=[product])
+                    ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), product=element_type)
+                ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), product=product)
            else:
                # These objects are parametrically based on an axis and should not be modified as a mesh
                return
@@ -402,11 +370,7 @@ class UpdateRepresentation(bpy.types.Operator, Operator):
            representation_data["profile_set_usage"] = tool.Geometry.get_profile_set_usage(product)
            representation_data["text_literal"] = tool.Geometry.get_text_literal(old_representation)

-        # TODO: replace with core.add_representation?
        new_representation = ifcopenshell.api.run("geometry.add_representation", self.file, **representation_data)
-        if new_representation is None:
-            self.report({"ERROR"}, "Error creating representation for Blender object.")
-            return {"CANCELLED"}

        if tool.Geometry.is_body_representation(new_representation):
            [
@@ -574,8 +538,6 @@ class OverrideDelete(bpy.types.Operator):
        row.prop(self, "is_batch", text="Enable Faster Deletion")

    def _execute(self, context):
-        start_time = time()
-
        if self.is_batch:
            ifcopenshell.util.element.batch_remove_deep2(tool.Ifc.get())

@@ -600,11 +562,6 @@ class OverrideDelete(bpy.types.Operator):
            IfcStore.add_transaction_operation(self)
        # Required otherwise gizmos are still visible
        context.view_layer.objects.active = None
-
-        operator_time = time() - start_time
-        if operator_time > 10:
-            self.report({"INFO"}, "IFC Delete was finished in {:.2f} seconds".format(operator_time))
-
        return {"FINISHED"}

    def rollback(self, data):
@@ -715,10 +672,6 @@ class OverrideOutlinerDelete(bpy.types.Operator):
            else:
                bpy.data.objects.remove(obj)
        for collection in collections_to_delete:
-            # Removing an aggregate object would also remove it's collection
-            # making the collection data-block invalid.
-            if not tool.Blender.is_valid_data_block(collection):
-                continue
            bpy.data.collections.remove(collection)
        if self.is_batch:
            old_file = tool.Ifc.get()
@@ -730,7 +683,7 @@ class OverrideOutlinerDelete(bpy.types.Operator):
            IfcStore.add_transaction_operation(self)
        return {"FINISHED"}

-    def get_collection_objects_and_children(self, collection: bpy.types.Collection) -> dict[str, Any]:
+    def get_collection_objects_and_children(self, collection):
        objects = set()
        children = set()
        queue = [collection]
@@ -890,7 +843,7 @@ class OverrideDuplicateMove(bpy.types.Operator):

        # Recreate decompositions
        tool.Root.recreate_decompositions(decomposition_relationships, old_to_new)
-        OverrideDuplicateMove.remove_linked_aggregate_data(old_to_new)
+        OverrideDuplicateMove.handle_linked_aggregates(old_to_new)
        blenderbim.bim.handler.refresh_ui_data()
        return old_to_new

@@ -943,21 +896,25 @@ class OverrideDuplicateMove(bpy.types.Operator):
                if entity in old_to_new.keys():
                    core.remove_connection(tool.Geometry, connection=connection)

-    def remove_linked_aggregate_data(old_to_new):
+    @staticmethod
+    def handle_linked_aggregates(old_to_new):
        for old, new in old_to_new.items():
            pset = ifcopenshell.util.element.get_pset(new[0], "BBIM_Linked_Aggregate")
            if pset:
-                pset = tool.Ifc.get().by_id(pset["id"])
-                ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), product=new[0],pset=pset)
-
-            if new[0].is_a("IfcElementAssembly"):
-                linked_aggregate_group = [
-                    r.RelatingGroup
-                    for r in getattr(new[0], "HasAssignments", []) or []
-                    if r.is_a("IfcRelAssignsToGroup")
-                    if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
-                ]
-                tool.Ifc.run("group.unassign_group", group=linked_aggregate_group[0], products=[new[0]])
+                old_aggregate = ifcopenshell.util.element.get_aggregate(old)
+                new_aggregate = ifcopenshell.util.element.get_aggregate(new[0])
+                if old_aggregate == new_aggregate:
+                    parts = ifcopenshell.util.element.get_parts(new_aggregate)
+                    if parts:
+                        index = DuplicateMoveLinkedAggregate.get_max_index(parts)
+                        index += 1
+                        pset = tool.Ifc.get().by_id(pset['id'])
+                        ifcopenshell.api.run(
+                            "pset.edit_pset",
+                            tool.Ifc.get(),
+                            pset=pset,
+                            properties={"Index": index},
+                        )


 class OverrideDuplicateMoveLinkedMacro(bpy.types.Macro):
@@ -983,15 +940,14 @@ class OverrideDuplicateMoveLinked(bpy.types.Operator):


 class DuplicateMoveLinkedAggregateMacro(bpy.types.Macro):
-    bl_description = "Create and move a new linked aggregate"
    bl_idname = "bim.object_duplicate_move_linked_aggregate_macro"
-    bl_label = "IFC Duplicate and Move Linked Aggregate"
+    bl_label = "IFC Duplicate Linked Aggregate"
    bl_options = {"REGISTER", "UNDO"}


 class DuplicateMoveLinkedAggregate(bpy.types.Operator):
    bl_idname = "bim.object_duplicate_move_linked_aggregate"
-    bl_label = "IFC Duplicate and Move Linked Aggregate"
+    bl_label = "IFC Duplicate Linked Aggregate"
    bl_options = {"REGISTER", "UNDO"}
    is_interactive: bpy.props.BoolProperty(name="Is Interactive", default=True)

@@ -1006,7 +962,7 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
        return DuplicateMoveLinkedAggregate.execute_ifc_duplicate_linked_aggregate_operator(self, context)

    @staticmethod
-    def execute_ifc_duplicate_linked_aggregate_operator(self, context, location_from_3d_cursor=False):
+    def execute_ifc_duplicate_linked_aggregate_operator(self, context):
        self.new_active_obj = None
        self.group_name = "BBIM_Linked_Aggregate"
        self.pset_name = "BBIM_Linked_Aggregate"
@@ -1018,33 +974,34 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
            obj.select_set(True)
            parts = ifcopenshell.util.element.get_parts(element)
            if parts:
-                index = get_max_index(parts)
+                index = DuplicateMoveLinkedAggregate.get_max_index(parts)
                add_linked_aggregate_pset(element, index)
-                index += 1
+                index +=1
                for part in parts:
                    if part.is_a("IfcElementAssembly"):
                        select_objects_and_add_data(part)
                    else:
-                        index = add_linked_aggregate_pset(part, index)
-                        # index += 1
-
+                        add_linked_aggregate_pset(part, index)
+                        index += 1
+                        
                    obj = tool.Ifc.get_object(part)
                    obj.select_set(True)
-
+                    
+                    
        def add_linked_aggregate_pset(part, index):
            pset = ifcopenshell.util.element.get_pset(part, self.pset_name)
-
+        
            if not pset:
-                pset = ifcopenshell.api.run("pset.add_pset", tool.Ifc.get(), product=part, name=self.pset_name)
-
+                pset = ifcopenshell.api.run(
+                    "pset.add_pset", tool.Ifc.get(), product=part, name=self.pset_name
+                )
+            
                ifcopenshell.api.run(
                    "pset.edit_pset",
                    tool.Ifc.get(),
                    pset=pset,
                    properties={"Index": index},
                )
-
-                index += 1
            else:
                pass

@@ -1060,7 +1017,7 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
            if self.group_name in product_groups_name:
                return

-            linked_aggregate_group = ifcopenshell.api.run("group.add_group", tool.Ifc.get(), name=self.group_name)
+            linked_aggregate_group = ifcopenshell.api.run("group.add_group", tool.Ifc.get(), Name=self.group_name)
            ifcopenshell.api.run("group.assign_group", tool.Ifc.get(), products=[element], group=linked_aggregate_group)

        def custom_incremental_naming_for_element_assembly(old_to_new):
@@ -1072,63 +1029,21 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
                        if r.is_a("IfcRelAssignsToGroup")
                        if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
                    ][0]
-
+                
                    number = len(group_elements) - 1
                    number = f"{number:02d}"
                    new_obj = tool.Ifc.get_object(new[0])
-                    pattern1 = r"_\d"
+                    pattern1 = r'_\d'
                    if re.findall(pattern1, new_obj.name):
                        split_name = new_obj.name.split("_")
                        new_obj.name = split_name[0] + "_" + number
                        continue
-                    pattern2 = r"\.\d{3}"
+                    pattern2 = r'\.\d{3}'
                    if re.findall(pattern2, new_obj.name):
                        split_name = new_obj.name.split(".")
                        new_obj.name = split_name[0] + "_" + number

-        def get_max_index(parts):
-            psets = [ifcopenshell.util.element.get_pset(p, "BBIM_Linked_Aggregate") for p in parts]
-            index = [i["Index"] for i in psets if i]
-            if len(index) > 0:
-                index = max(index)
-                return index
-            else:
-                return 0
-
-        def copy_linked_aggregate_data(old_to_new):
-            for old, new in old_to_new.items():
-                pset = ifcopenshell.util.element.get_pset(old, "BBIM_Linked_Aggregate")
-                if pset:
-                    new_pset = ifcopenshell.api.run(
-                        "pset.add_pset", tool.Ifc.get(), product=new[0], name=self.pset_name
-                    )
-
-                    ifcopenshell.api.run(
-                        "pset.edit_pset",
-                        tool.Ifc.get(),
-                        pset=new_pset,
-                        properties={"Index": pset["Index"]},
-                    )
-
-                if new[0].is_a("IfcElementAssembly"):
-                    linked_aggregate_group = [
-                        r.RelatingGroup
-                        for r in getattr(old, "HasAssignments", []) or []
-                        if r.is_a("IfcRelAssignsToGroup")
-                        if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
-                    ]
-                    tool.Ifc.run("group.assign_group", group=linked_aggregate_group[0], products=new)
-
-        def get_location_from_3d_cursor(old_to_new, aggregate):
-            base_obj = tool.Ifc.get_object(aggregate)
-            base_obj_location = base_obj.location.copy()
-
-            for new in old_to_new.values():
-                new_obj = tool.Ifc.get_object(new[0])
-                location_diff = new_obj.location - base_obj_location
-                new_obj.location = context.scene.cursor.location + location_diff
-
-
+             
        if len(context.selected_objects) != 1:
            return {"FINISHED"}

@@ -1149,34 +1064,29 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):

        old_to_new = OverrideDuplicateMove.execute_ifc_duplicate_operator(self, context, linked=True)

-        tool.Root.recreate_aggregate(old_to_new)
-
-        copy_linked_aggregate_data(old_to_new)
-
        custom_incremental_naming_for_element_assembly(old_to_new)
-
-        if location_from_3d_cursor:
-            get_location_from_3d_cursor(old_to_new, selected_element)
+        
+        # Recreate aggregate relationship
+        for old in old_to_new.keys():
+            if old.is_a("IfcElementAssembly"):
+                tool.Root.recreate_aggregate(old_to_new)

        blenderbim.bim.handler.refresh_ui_data()

        return old_to_new

+    
+    @staticmethod
+    def get_max_index(parts):
+        psets = [ifcopenshell.util.element.get_pset(p, "BBIM_Linked_Aggregate") for p in parts]
+        index = [i['Index'] for i in psets if i]
+        if len(index) > 0:
+            index = max(index)
+            return index
+        else:
+            return 0
+        

-class DuplicateLinkedAggregateTo3dCursor(bpy.types.Operator):
-    bl_idname = "bim.duplicate_linked_aggregate_to_3d_cursor"
-    bl_label = "IFC Duplicate Linked Aggregate to 3d Cursor"
-    bl_options = {"REGISTER", "UNDO"}
-
-    @classmethod
-    def poll(cls, context):
-        return len(context.selected_objects) > 0
-
-    def execute(self, context):
-        return OverrideDuplicateMove.execute_duplicate_operator(self, context, linked=False)
-
-    def _execute(self, context):
-        return DuplicateMoveLinkedAggregate.execute_ifc_duplicate_linked_aggregate_operator(self, context, location_from_3d_cursor=True)

 class RefreshLinkedAggregate(bpy.types.Operator):
    bl_idname = "bim.refresh_linked_aggregate"
@@ -1224,9 +1134,9 @@ class RefreshLinkedAggregate(bpy.types.Operator):
            original_names[group] = {}

            pset = ifcopenshell.util.element.get_pset(element, self.pset_name)
-            index = pset["Index"]
+            index = pset['Index']                    
            original_names[group][index] = tool.Ifc.get_object(element).name
-
+            
            parts = ifcopenshell.util.element.get_parts(element)
            if parts:
                for part in parts:
@@ -1234,22 +1144,20 @@ class RefreshLinkedAggregate(bpy.types.Operator):
                        original_names | get_original_names(part)
                    else:
                        try:
-                            pset = ifcopenshell.util.element.get_pset(part, self.pset_name)
+                          pset = ifcopenshell.util.element.get_pset(part, self.pset_name)
                        except:
-                            continue
-                        index = pset["Index"]
+                          continue
+                        index = pset['Index']                    
                        original_names[group][index] = tool.Ifc.get_object(part).name
-
+                    
            return original_names

        def set_original_name(obj, original_names):
            element = tool.Ifc.get_entity(obj)
            aggregate = ifcopenshell.util.element.get_aggregate(element)
-            if ifcopenshell.util.element.get_parts(
-                element
-            ):  # if element has parts it means it is the base of and aggregate or sub-aggregate
+            if ifcopenshell.util.element.get_parts(element): # if element has parts it means it is the base of and aggregate or sub-aggregate
                aggregate = element
-
+                
            group = [
                r.RelatingGroup
                for r in getattr(aggregate, "HasAssignments", []) or []
@@ -1258,16 +1166,18 @@ class RefreshLinkedAggregate(bpy.types.Operator):
            ]
            if not group:
                return
-
+            
            group = group[0].id()
-
+                
            pset = ifcopenshell.util.element.get_pset(element, self.pset_name)
-            index = pset["Index"]
-
+            index = pset['Index']
+            
            try:
                obj.name = original_names[group][index]
            except:
                return
+            
+            

        def get_element_assembly(element):
            if element.is_a("IfcElementAssembly"):
@@ -1310,22 +1220,6 @@ class RefreshLinkedAggregate(bpy.types.Operator):

            return list(set(linked_aggregate_groups)), selected_parents

-        def get_original_matrix(element, base_instance):
-            selected_obj = tool.Ifc.get_object(base_instance)
-            selected_matrix = selected_obj.matrix_world
-            object_duplicate = tool.Ifc.get_object(element)
-            duplicate_matrix = object_duplicate.matrix_world.decompose()
-
-            return selected_matrix, duplicate_matrix
-
-        def set_new_matrix(selected_matrix, duplicate_matrix, old_to_new):
-            for old, new in old_to_new.items():
-                new_obj = tool.Ifc.get_object(new[0])
-                new_base_matrix = Matrix.LocRotScale(*duplicate_matrix)
-                matrix_diff = Matrix.inverted(selected_matrix) @ new_obj.matrix_world
-                new_obj_matrix = new_base_matrix @ matrix_diff
-                new_obj.matrix_world = new_obj_matrix
-
        active_element = tool.Ifc.get_entity(context.active_object)
        if not active_element:
            self.report({"INFO"}, "Object has no Ifc metadata.")
@@ -1365,10 +1259,13 @@ class RefreshLinkedAggregate(bpy.types.Operator):

                element_aggregate = ifcopenshell.util.element.get_aggregate(element)

-                selected_matrix, duplicate_matrix = get_original_matrix(element, base_instance)
-
+                selected_obj = tool.Ifc.get_object(base_instance)
+                selected_matrix = selected_obj.matrix_world
+                object_duplicate = tool.Ifc.get_object(element)
+                duplicate_matrix = object_duplicate.matrix_world.decompose()
+                
                original_names = get_original_names(element)
-
+                
                delete_objects(element)

                for obj in context.selected_objects:
@@ -1377,26 +1274,30 @@ class RefreshLinkedAggregate(bpy.types.Operator):
                tool.Ifc.get_object(base_instance).select_set(True)

                old_to_new = DuplicateMoveLinkedAggregate.execute_ifc_duplicate_linked_aggregate_operator(self, context)
-
-                set_new_matrix(selected_matrix, duplicate_matrix, old_to_new)
-
+                for old, new in old_to_new.items():
+                    new_obj = tool.Ifc.get_object(new[0])
+                    new_base_matrix = Matrix.LocRotScale(*duplicate_matrix)
+                    matrix_diff = Matrix.inverted(selected_matrix) @ new_obj.matrix_world
+                    new_obj_matrix = new_base_matrix @ matrix_diff
+                    new_obj.matrix_world = new_obj_matrix
+                    
                for old, new in old_to_new.items():
                    if element_aggregate and new[0].is_a("IfcElementAssembly"):
                        new_aggregate = ifcopenshell.util.element.get_aggregate(new[0])

                        if not new_aggregate:
                            blenderbim.core.aggregate.assign_object(
-                                tool.Ifc,
-                                tool.Aggregate,
-                                tool.Collector,
-                                relating_obj=tool.Ifc.get_object(element_aggregate),
-                                related_obj=tool.Ifc.get_object(new[0]),
-                            )
-
+                                                        tool.Ifc,
+                                                        tool.Aggregate,
+                                                        tool.Collector,
+                                                        relating_obj=tool.Ifc.get_object(element_aggregate),
+                                                        related_obj=tool.Ifc.get_object(new[0]),
+                                                    )
+                
                for old, new in old_to_new.items():
                    new_obj = tool.Ifc.get_object(new[0])
                    set_original_name(new_obj, original_names)
-
+                        
        blenderbim.bim.handler.refresh_ui_data()

        operator_time = time() - refresh_start_time
@@ -1510,13 +1411,14 @@ class OverridePasteBuffer(bpy.types.Operator):

    def execute(self, context):
        bpy.ops.view3d.pastebuffer()
-        for obj in context.selected_objects:
-            # Pasted objects may come from another Blender session, or even
-            # from the same session where the original object has since
-            # been deleted. As the source element may not exist, paste will
-            # always unlink the element. If you want to duplicate an
-            # element, use the duplicate commands.
-            tool.Root.unlink_object(obj)
+        if IfcStore.get_file():
+            for obj in context.selected_objects:
+                # Pasted objects may come from another Blender session, or even
+                # from the same session where the original object has since
+                # been deleted. As the source element may not exist, paste will
+                # always unlink the element. If you want to duplicate an
+                # element, use the duplicate commands.
+                tool.Root.unlink_object(obj)
        return {"FINISHED"}


@@ -1543,9 +1445,7 @@ class OverrideModeSetEdit(bpy.types.Operator):
        for obj in selected_objs:
            if not obj:
                continue
-            obj_supports_edit_mode, message = tool.Blender.object_supports_edit_mode(obj)
-            if not obj_supports_edit_mode:
-                self.report({"INFO"}, message)
+            if not obj.data:
                obj.select_set(False)
                continue
            element = tool.Ifc.get_entity(obj)
@@ -1689,11 +1589,20 @@ class OverrideModeSetObject(bpy.types.Operator):
            apply_openings=True,
        )

+    def draw(self, context):
+        if self.is_valid:
+            row = self.layout.row()
+            row.prop(self, "should_save")
+        else:
+            row = self.layout.row()
+            row.label(text="No Geometry Found: Object will revert to previous state.")
+
    def invoke(self, context, event):
        return IfcStore.execute_ifc_operator(self, context, is_invoke=True)

    def _invoke(self, context, event):
        self.is_valid = True
+        self.should_save = True

        bpy.ops.object.mode_set(mode="EDIT", toggle=True)

@@ -1755,6 +1664,8 @@ class OverrideModeSetObject(bpy.types.Operator):
                else:
                    tool.Ifc.finish_edit(obj)

+        if self.edited_objs:
+            return context.window_manager.invoke_props_dialog(self)
        return self.execute(context)


@@ -138,4 +138,3 @@ class BIMGeometryProperties(PropertyGroup):
        name="IFC Interaction Mode",
        update=update_mode,
    )
-    representation_from_object: PointerProperty(type=bpy.types.Object)
@@ -34,8 +34,6 @@ from blenderbim.bim.module.layer.data import LayersData

 def mode_menu(self, context):
    row = self.layout.row(align=True)
-    if context.scene.BIMGeometryProperties.mode == "EDIT":
-        row.operator("bim.override_mode_set_object", icon="CANCEL", text="Discard Changes").should_save = False
    row.prop(context.scene.BIMGeometryProperties, "mode", text="", icon_value=blenderbim.bim.icons["IFC"].icon_id)


@@ -214,7 +212,7 @@ class BIM_PT_representation_items(Panel):
        if props.is_editing_item_style:
            # NOTE: we currently support 1 item having just 1 style
            # when IfcStyledItem can actually have multiple styles
-            prop_with_search(row, props, "representation_item_style", icon="SHADING_RENDERED", text="")
+            row.prop(props, "representation_item_style", icon="SHADING_RENDERED", text="")
            row.operator("bim.edit_representation_item_style", icon="CHECKMARK", text="")
            row.operator("bim.disable_editing_representation_item_style", icon="CANCEL", text="")
        else:
@@ -212,7 +212,7 @@ class UnassignGroup(bpy.types.Operator, tool.Ifc.Operator):
                "group.unassign_group",
                self.file,
                **{
-                    "products": [self.file.by_id(product.BIMObjectProperties.ifc_definition_id)],
+                    "product": self.file.by_id(product.BIMObjectProperties.ifc_definition_id),
                    "group": self.file.by_id(self.group),
                }
            )
@@ -247,11 +247,9 @@ class IFCGIT_PT_revision_inspector(bpy.types.Panel):
    bl_idname = "IFCGIT_PT_revision_inspector"
    bl_label = "Git History"
    bl_options = {"DEFAULT_CLOSED"}
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_parent_id = "IFCGIT_PT_panel"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "UI"
+    bl_category = "BlenderBIM"

    def draw(self, context):

@@ -151,10 +151,7 @@ class AssignPresentationLayer(bpy.types.Operator):
        ifcopenshell.api.run(
            "layer.assign_layer",
            self.file,
-            **{
-                "items": [self.file.by_id(item.BIMMeshProperties.ifc_definition_id)],
-                "layer": self.file.by_id(self.layer),
-            }
+            **{"item": self.file.by_id(item.BIMMeshProperties.ifc_definition_id), "layer": self.file.by_id(self.layer)}
        )
        return {"FINISHED"}

@@ -176,10 +173,7 @@ class UnassignPresentationLayer(bpy.types.Operator):
        ifcopenshell.api.run(
            "layer.unassign_layer",
            self.file,
-            **{
-                "items": [self.file.by_id(item.BIMMeshProperties.ifc_definition_id)],
-                "layer": self.file.by_id(self.layer),
-            }
+            **{"item": self.file.by_id(item.BIMMeshProperties.ifc_definition_id), "layer": self.file.by_id(self.layer)}
        )
        return {"FINISHED"}

@@ -24,12 +24,12 @@ classes = (
    operator.AddLayer,
    operator.AddListItem,
    operator.AddMaterial,
-    operator.DuplicateMaterial,
    operator.AddMaterialSet,
    operator.AddProfile,
    operator.AssignMaterial,
    operator.AssignParameterizedProfile,
    operator.ContractMaterialCategory,
+    operator.CopyMaterial,
    operator.DisableEditingAssignedMaterial,
    operator.DisableEditingMaterial,
    operator.DisableEditingMaterialSetItem,
@@ -63,6 +63,7 @@ classes = (
    prop.BIMMaterialProperties,
    prop.BIMObjectMaterialProperties,
    ui.BIM_PT_materials,
+    ui.BIM_PT_material,
    ui.BIM_PT_object_material,
    ui.BIM_UL_materials,
 )
@@ -19,7 +19,6 @@
 import os
 import bpy
 import ifcopenshell
-import ifcopenshell.util.element
 import ifcopenshell.util.doc
 import ifcopenshell.util.schema
 import blenderbim.tool as tool
@@ -36,17 +35,31 @@ class MaterialsData:

    @classmethod
    def load(cls):
+        cls.data = {
+            "total_materials": cls.total_materials(),
+            "material_types": cls.material_types(),
+            "profiles": cls.profiles(),
+            "styles": cls.styles(),
+            "contexts": cls.contexts(),
+            "active_styles": cls.active_styles(),
+        }
        cls.is_loaded = True
-        cls.data["material_types"] = cls.material_types()
-        cls.data["total_materials"] = cls.total_materials()
-        cls.data["profiles"] = cls.profiles()
-        cls.data["styles"] = cls.styles()
-        cls.data["contexts"] = cls.contexts()
-        cls.data["active_styles"] = cls.active_styles()

    @classmethod
    def total_materials(cls):
-        return len(tool.Ifc.get().by_type(bpy.context.scene.BIMMaterialProperties.material_type))
+        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"))
+            + len(tool.Ifc.get().by_type("IfcMaterialLayerSet"))
+            + len(tool.Ifc.get().by_type("IfcMaterialProfileSet"))
+            + len(tool.Ifc.get().by_type("IfcMaterialList"))
+        )

    @classmethod
    def material_types(cls):
@@ -153,9 +166,6 @@ class ObjectMaterialData:
        cls.data["type_material"] = cls.type_material()
        cls.data["material_type"] = cls.material_type()
        cls.data["active_material_constituents"] = cls.active_material_constituents()
-        # after material_name and type_material
-        cls.data["is_type_material_overridden"] = cls.is_type_material_overridden()
-
        cls.is_loaded = True

    @classmethod
@@ -284,7 +294,8 @@ class ObjectMaterialData:

    @classmethod
    def material_name(cls):
-        material = cls.material
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        material = ifcopenshell.util.element.get_material(element)
        if material:
            return getattr(material, "Name", None) or "Unnamed"

@@ -328,18 +339,3 @@ class ObjectMaterialData:
        if not cls.material or not material.is_a("IfcMaterialConstituentSet"):
            return []
        return [m.Name for m in material.MaterialConstituents if m.Name]
-
-    @classmethod
-    def is_type_material_overridden(cls) -> bool:
-        if not cls.data["type_material"]:
-            return False
-
-        # try to avoid accessing ifc
-        if cls.data["material_name"] != cls.data["type_material"]:
-            return True
-
-        # in theory material can be overridden by the same material
-        # so we check occurrence material explicitly
-        element = tool.Ifc.get_entity(bpy.context.active_object)
-        occurrence_material = ifcopenshell.util.element.get_material(element, should_inherit=False)
-        return bool(occurrence_material)
@@ -118,10 +118,8 @@ class AddMaterial(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_material"
    bl_label = "Add Material"
    bl_options = {"REGISTER", "UNDO"}
-    obj: bpy.props.StringProperty(name="Material Name")
+    obj: bpy.props.StringProperty()
    name: bpy.props.StringProperty(default="Default")
-    category: bpy.props.StringProperty(default="")
-    description: bpy.props.StringProperty(default="")

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)
@@ -129,41 +127,13 @@ class AddMaterial(bpy.types.Operator, tool.Ifc.Operator):
    def draw(self, context):
        row = self.layout
        row.prop(self, "name", text="Name")
-        row = self.layout
-        row.prop(self, "description", text="Description")
-        row = self.layout
-        row.prop(self, "category", text="Category")

    def _execute(self, context):
        obj = bpy.data.materials.get(self.obj) if self.obj else None
-        core.add_material(tool.Ifc, tool.Material, tool.Style, obj=obj, name=self.name, category=self.category, description=self.description)
+        core.add_material(tool.Ifc, tool.Material, tool.Style, obj=obj, name=self.name)
        material_prop_purge()


-class DuplicateMaterial(bpy.types.Operator, tool.Ifc.Operator):
-    bl_idname = "bim.duplicate_material"
-    bl_label = "Diplicate Material"
-    bl_options = {"REGISTER", "UNDO"}
-    material: bpy.props.IntProperty(name="Material ID")
-
-    def _execute(self, context):
-        material = tool.Ifc.get().by_id(self.material)
-        new = tool.Ifc.run("material.copy_material", material=material)
-
-        blender_material = tool.Ifc.get_object(material)
-        new_blender = blender_material.copy()
-        new_blender.use_fake_user = True
-        tool.Ifc.link(new, new_blender)
-
-        if not new.is_a("IfcMaterialList"):
-            name = new[0] + " Copy"
-            new[0] = name
-            new_blender.name = name
-
-        material_prop_purge()
-        bpy.ops.bim.load_materials()
-
-
 class AddMaterialSet(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_material_set"
    bl_label = "Add Material Set"
@@ -202,10 +172,9 @@ class UnlinkMaterial(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.unlink_material"
    bl_label = "Unlink Material"
    bl_options = {"REGISTER", "UNDO"}
-    material: bpy.props.IntProperty(name="Material ID")

    def _execute(self, context):
-        core.unlink_material(tool.Ifc, obj=tool.Ifc.get_object(tool.Ifc.get().by_id(self.material)))
+        core.unlink_material(tool.Ifc, obj=context.active_object.active_material)


 class AssignMaterial(bpy.types.Operator, tool.Ifc.Operator):
@@ -562,7 +531,6 @@ class EnableEditingMaterialSetItemProfile(bpy.types.Operator):
    def execute(self, context):
        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
        self.props = obj.BIMObjectMaterialProperties
-        self.props.active_material_set_item_id = self.material_set_item
        self.props.material_set_item_profile_attributes.clear()
        profile = tool.Ifc.get().by_id(self.material_set_item).Profile
        blenderbim.bim.helper.import_attributes2(profile, self.props.material_set_item_profile_attributes)
@@ -578,7 +546,6 @@ class DisableEditingMaterialSetItemProfile(bpy.types.Operator):
    def execute(self, context):
        obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
        self.props = obj.BIMObjectMaterialProperties
-        self.props.active_material_set_item_id = 0
        self.props.material_set_item_profile_attributes.clear()
        return {"FINISHED"}

@@ -596,7 +563,6 @@ class EditMaterialSetItemProfile(bpy.types.Operator, tool.Ifc.Operator):
        attributes = blenderbim.bim.helper.export_attributes(self.props.material_set_item_profile_attributes)
        profile = tool.Ifc.get().by_id(self.material_set_item).Profile
        ifcopenshell.api.run("profile.edit_profile", tool.Ifc.get(), profile=profile, attributes=attributes)
-        self.props.active_material_set_item_id = 0
        self.props.material_set_item_profile_attributes.clear()
        model_profile.DumbProfileRegenerator().regenerate_from_profile_def(profile)

@@ -700,31 +666,45 @@ class EditMaterialSetItem(bpy.types.Operator, tool.Ifc.Operator):
        bpy.ops.bim.disable_editing_material_set_item(obj=obj.name)


+class CopyMaterial(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.copy_material"
+    bl_label = "Copy Material"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        blender_material = context.active_object.active_material
+        material = tool.Ifc.get_entity(blender_material)
+
+        if tool.Ifc.has_changed_shading(blender_material):
+            blenderbim.core.style.update_style_colours(tool.Ifc, tool.Style, obj=blender_material)
+
+        copied_material = ifcopenshell.api.run("material.copy_material", tool.Ifc.get(), material=material)
+        copied_blender_material = blender_material.copy()
+        copied_style = self.get_style(copied_material)
+        tool.Ifc.link(copied_material, copied_blender_material)
+        if copied_style:
+            tool.Ifc.link(copied_style, copied_blender_material)
+        context.active_object.active_material = copied_blender_material
+
+    def get_style(self, material):
+        for material_representation in material.HasRepresentation:
+            for representation in material_representation.Representations:
+                for item in representation.Items:
+                    for style in item.Styles:
+                        if style.is_a("IfcSurfaceStyle"):
+                            return style
+
+
 class ExpandMaterialCategory(bpy.types.Operator):
    bl_idname = "bim.expand_material_category"
    bl_label = "Expand Material Category"
-    bl_description = "SHIFT+CLICK to expand all material categories"
    bl_options = {"REGISTER", "UNDO"}
    category: bpy.props.StringProperty()
-    expand_all: bpy.props.BoolProperty(name="Expand All", default=False, options={"SKIP_SAVE"})
-
-    def invoke(self, context, event):
-        # Expanding all categories on shift+click.
-        # Make sure to use SKIP_SAVE on property, otherwise it might get stuck.
-        if event.type == "LEFTMOUSE" and event.shift:
-            self.expand_all = True
-        return self.execute(context)

    def execute(self, context):
        props = context.scene.BIMMaterialProperties
-        for index, category in [
-            (i, c)
-            for i, c in enumerate(props.materials)
-            if c.is_category and (self.expand_all or c.name == self.category)
-        ]:
+        for category in [c for c in props.materials if c.is_category and c.name == self.category]:
            category.is_expanded = True
-            if category.name == self.category:
-                props.active_material_index = index
        core.load_materials(tool.Material, props.material_type)
        return {"FINISHED"}

@@ -732,28 +712,13 @@ class ExpandMaterialCategory(bpy.types.Operator):
 class ContractMaterialCategory(bpy.types.Operator):
    bl_idname = "bim.contract_material_category"
    bl_label = "Contract Material Category"
-    bl_description = "SHIFT+CLICK to contract all material categories"
    bl_options = {"REGISTER", "UNDO"}
    category: bpy.props.StringProperty()
-    contract_all: bpy.props.BoolProperty(name="Contract All", default=False, options={"SKIP_SAVE"})
-
-    def invoke(self, context, event):
-        # Contracting all categories on shift+click.
-        # Make sure to use SKIP_SAVE on property, otherwise it might get stuck.
-        if event.type == "LEFTMOUSE" and event.shift:
-            self.contract_all = True
-        return self.execute(context)

    def execute(self, context):
        props = context.scene.BIMMaterialProperties
-        for index, category in [
-            (i, c)
-            for i, c in enumerate(props.materials)
-            if c.is_category and (self.contract_all or c.name == self.category)
-        ]:
+        for category in [c for c in props.materials if c.is_category and c.name == self.category]:
            category.is_expanded = False
-            if category.name == self.category:
-                props.active_material_index = index
        core.load_materials(tool.Material, props.material_type)
        return {"FINISHED"}

@@ -97,10 +97,6 @@ def get_material_types(self, context):
    return MaterialsData.data["material_types"]


-def update_material_type(self, context):
-    MaterialsData.data["total_materials"] = MaterialsData.total_materials()
-
-
 def get_profiles(self, context):
    if not MaterialsData.is_loaded:
        MaterialsData.load()
@@ -123,14 +119,14 @@ 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=False)
+    is_expanded: BoolProperty(name="Is Expanded", default=True)
    has_style: BoolProperty(name="Has Style", default=True)
    total_elements: IntProperty(name="Total Elements")


 class BIMMaterialProperties(PropertyGroup):
    is_editing: BoolProperty(name="Is Editing", default=False)
-    material_type: EnumProperty(items=get_material_types, update=update_material_type, name="Material Type")
+    material_type: EnumProperty(items=get_material_types, name="Material Type")
    materials: CollectionProperty(name="Materials", type=Material)
    active_material_index: IntProperty(name="Active Material Index")
    profiles: EnumProperty(items=get_profiles, name="Profiles")
@@ -45,7 +45,7 @@ class BIM_PT_materials(Panel):
        self.props = context.scene.BIMMaterialProperties

        row = self.layout.row(align=True)
-        row.label(text=f"{MaterialsData.data['total_materials']} Materials", icon="NODE_MATERIAL")
+        row.label(text="{} Materials".format(MaterialsData.data["total_materials"]), icon="NODE_MATERIAL")
        if self.props.is_editing:
            row.operator("bim.disable_editing_materials", text="", icon="CANCEL")
        else:
@@ -61,16 +61,12 @@ class BIM_PT_materials(Panel):
            if self.props.materials and self.props.active_material_index < len(self.props.materials):
                material = self.props.materials[self.props.active_material_index]
                if material.ifc_definition_id:
-                    op = row.operator("bim.duplicate_material", text="", icon="DUPLICATE")
-                    op.material = material.ifc_definition_id
                    op = row.operator("bim.select_by_material", text="", icon="RESTRICT_SELECT_OFF")
                    op.material = material.ifc_definition_id
                    op = row.operator("bim.enable_editing_material", text="", icon="GREASEPENCIL")
                    op.material = material.ifc_definition_id
                    op = row.operator("bim.enable_editing_material_style", text="", icon="SHADING_RENDERED")
                    op.material = material.ifc_definition_id
-                    op = row.operator("bim.unlink_material", icon="UNLINKED", text="")
-                    op.material = material.ifc_definition_id
                    row.operator("bim.remove_material", text="", icon="X").material = material.ifc_definition_id

            self.draw_editing_ui()
@@ -110,20 +106,42 @@ class BIM_PT_materials(Panel):
        elif self.props.editing_material_type == "STYLE":
            row = self.layout.row(align=True)
            row.prop(self.props, "contexts", text="")
-            prop_with_search(row, self.props, "styles", text="")
+            row.prop(self.props, "styles", text="")
            row = self.layout.row(align=True)
            row.operator("bim.edit_material_style", text="Assign Style", icon="CHECKMARK")
            row.operator("bim.disable_editing_material", text="", icon="CANCEL")


+class BIM_PT_material(Panel):
+    bl_label = "Material"
+    bl_idname = "BIM_PT_material"
+    bl_space_type = "PROPERTIES"
+    bl_region_type = "WINDOW"
+    bl_context = "material"
+
+    @classmethod
+    def poll(cls, context):
+        return IfcStore.get_file() and context.active_object and context.active_object.active_material
+
+    def draw(self, context):
+        row = self.layout.row(align=True)
+        material_id = context.active_object.active_material.BIMObjectProperties.ifc_definition_id
+        if bool(material_id):
+            row.operator("bim.remove_material", icon="X", text="Remove IFC Material").material = material_id
+            row.operator("bim.copy_material", icon="DUPLICATE", text="")
+            row.operator("bim.unlink_material", icon="UNLINKED", text="")
+        else:
+            op = row.operator("bim.add_material", icon="ADD", text="Create IFC Material")
+            op.obj = context.active_object.active_material.name
+
+
 class BIM_PT_object_material(Panel):
    bl_label = "Object Material"
    bl_idname = "BIM_PT_object_material"
    bl_space_type = "PROPERTIES"
    bl_region_type = "WINDOW"
    bl_context = "scene"
-    bl_parent_id = "BIM_PT_tab_object_materials"
-    bl_options = {"HIDE_HEADER"}
+    bl_parent_id = "BIM_PT_tab_materials"

    @classmethod
    def poll(cls, context):
@@ -157,13 +175,7 @@ class BIM_PT_object_material(Panel):

        if ObjectMaterialData.data["type_material"]:
            row = self.layout.row(align=True)
-            if ObjectMaterialData.data["is_type_material_overridden"]:
-                row.label(
-                    text=f"Inherited Material Is Occurrence Overridden",
-                    icon="CON_CHILDOF",
-                )
-            else:
-                row.label(text="Inherited Material: " + ObjectMaterialData.data["type_material"], icon="CON_CHILDOF")
+            row.label(text="Inherited Material: " + ObjectMaterialData.data["type_material"], icon="FILE_PARENT")

        if ObjectMaterialData.data["material_class"]:
            return self.draw_material_ui()
@@ -228,7 +240,7 @@ class BIM_PT_object_material(Panel):

        total_items = len(ObjectMaterialData.data["set_items"])
        for index, set_item in enumerate(ObjectMaterialData.data["set_items"]):
-            if len(self.props.material_set_item_profile_attributes) and self.props.active_material_set_item_id == set_item["id"]:
+            if len(self.props.material_set_item_profile_attributes):
                self.draw_editable_set_item_profile_ui(set_item)
            elif self.props.active_material_set_item_id == set_item["id"]:
                self.draw_editable_set_item_ui(set_item)
@@ -343,7 +355,7 @@ class BIM_UL_materials(UIList):
                    row.operator(
                        "bim.expand_material_category", text="", emboss=False, icon="DISCLOSURE_TRI_RIGHT"
                    ).category = item.name
-                row.label(text=item.name)
+                row.label(text=item.name or "Uncategorised")
            else:
                row.label(text="", icon="BLANK1")
                row.label(text=item.name, icon="MATERIAL")
@@ -23,7 +23,6 @@ import blenderbim.bim.handler
 import blenderbim.tool as tool
 import blenderbim.core.misc as core
 import blenderbim.core.geometry as core_geometry
-import blenderbim.core.root
 from blenderbim.bim.ifc import IfcStore
 from mathutils import Vector, Matrix, Euler

@@ -135,10 +134,6 @@ class ResizeToStorey(bpy.types.Operator, Operator):
 class SplitAlongEdge(bpy.types.Operator, Operator):
    bl_idname = "bim.split_along_edge"
    bl_label = "Split Along Edge"
-    bl_description = (
-        "Active object is considered to be a cutting object."
-        "Will unassign element from a type if type has a representation."
-    )
    bl_options = {"REGISTER", "UNDO"}

    @classmethod
@@ -149,25 +144,16 @@ class SplitAlongEdge(bpy.types.Operator, Operator):
        cutter = context.active_object
        objs = [o for o in context.selected_objects if o != cutter]

-        objs_to_cut = []
        # Splitting only works on meshes
        for obj in objs:
            # You cannot split meshes if the representation is mapped.
            element = tool.Ifc.get_entity(obj)
-            if not element:
-                continue
+            if element:
+                relating_type = tool.Root.get_element_type(element)
+                if relating_type and tool.Root.does_type_have_representations(relating_type):
+                    bpy.ops.bim.unassign_type(related_object=obj.name)

-            relating_type = tool.Root.get_element_type(element)
-            if relating_type and tool.Root.does_type_have_representations(relating_type):
-                bpy.ops.bim.unassign_type(related_object=obj.name)
-
-            # refresh representation
            representation = tool.Geometry.get_active_representation(obj)
-
-            # skip empty objects that might get in the way
-            if not representation:
-                continue
-
            core_geometry.switch_representation(
                tool.Ifc,
                tool.Geometry,
@@ -182,13 +168,11 @@ class SplitAlongEdge(bpy.types.Operator, Operator):
            if not tool.Geometry.is_meshlike(representation):
                bpy.ops.bim.update_representation(obj=obj.name, ifc_representation_class="IfcTessellatedFaceSet")

-            objs_to_cut.append(obj)
-
-        new_objs = tool.Misc.split_objects_with_cutter(objs_to_cut, cutter)
+        new_objs = tool.Misc.split_objects_with_cutter(objs, cutter)
        for obj in new_objs:
            blenderbim.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=obj)
            bpy.ops.bim.update_representation(obj=obj.name)
-        for obj in objs_to_cut:
+        for obj in objs:
            bpy.ops.bim.update_representation(obj=obj.name)

            representation = tool.Geometry.get_active_representation(obj)
@@ -203,8 +187,6 @@ class SplitAlongEdge(bpy.types.Operator, Operator):
                apply_openings=True,
            )

-        self.report({"INFO"}, f"Splitting finished, {len(new_objs)} new objects created.")
-

 class GetConnectedSystemElements(bpy.types.Operator, Operator):
    bl_idname = "bim.get_connected_system_elements"
@@ -22,11 +22,10 @@ import bpy
 class BIM_PT_misc_utilities(bpy.types.Panel):
    bl_idname = "BIM_PT_misc_utilities"
    bl_label = "Miscellaneous"
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "output"
    bl_options = {"DEFAULT_CLOSED"}
-    bl_parent_id = "BIM_PT_tab_sandbox"
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "UI"
+    bl_category = "BlenderBIM"

    def draw(self, context):
        layout = self.layout
@@ -83,17 +83,8 @@ class EnableEditingArray(bpy.types.Operator, tool.Ifc.Operator):
    def _execute(self, context):
        obj = context.active_object
        element = tool.Ifc.get_entity(obj)
+        data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Array", "Data"))[self.item]
        props = obj.BIMArrayProperties
-        
-        relating_obj = props.relating_array_object
-        
-        if relating_obj:
-            element = tool.Ifc.get_entity(relating_obj)
-            parent_globalid = ifcopenshell.util.element.get_pset(element, "BBIM_Array", "Parent")
-            parent_element = tool.Ifc.get().by_guid(parent_globalid)
-            data = json.loads(ifcopenshell.util.element.get_pset(parent_element, "BBIM_Array", "Data"))[self.item]
-        else:
-            data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Array", "Data"))[self.item]
        props.count = data["count"]
        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
        props.x = data["x"] * si_conversion
@@ -102,9 +93,7 @@ class EnableEditingArray(bpy.types.Operator, tool.Ifc.Operator):
        props.use_local_space = data.get("use_local_space", False)
        props.sync_children = data.get("sync_children", False)
        props.method = data.get("method", "OFFSET")
-        
        props.is_editing = self.item
-        
        return {"FINISHED"}


@@ -148,10 +137,6 @@ class EditArray(bpy.types.Operator, tool.Ifc.Operator):

        tool.Blender.Modifier.Array.set_children_lock_state(element, self.item, True)
        tool.Blender.Modifier.Array.constrain_children_to_parent(element)
-
-        #clears the relating_array_object so it doesn't show again next time
-        props.relating_array_object = None
-        
        return {"FINISHED"}


@@ -208,7 +193,7 @@ class RemoveArray(bpy.types.Operator, tool.Ifc.Operator):

        pset = tool.Ifc.get().by_id(pset["id"])
        if len(data) == 1:
-            ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), product=element, pset=pset)
+            ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), pset=pset)
        else:
            del data[self.item]
            data = tool.Ifc.get().createIfcText(json.dumps(data))
@@ -32,9 +32,7 @@ class AddInstanceFlooringCoveringFromCursor(bpy.types.Operator, tool.Ifc.Operato
    def poll(cls, context):
        collection = context.view_layer.active_layer_collection.collection
        collection_obj = collection.BIMCollectionProperties.obj
-        relating_type_id = int(bpy.data.scenes["Scene"].BIMModelProperties.relating_type_id)
-        relating_type = ifcopenshell.util.element.get_predefined_type(tool.Ifc.get().by_id(relating_type_id))
-        return tool.Ifc.get_entity(collection_obj) and relating_type == "FLOORING"
+        return tool.Ifc.get_entity(collection_obj)

    def _execute(self, context):

@@ -63,9 +61,7 @@ class AddInstanceCeilingCoveringFromCursor(bpy.types.Operator, tool.Ifc.Operator
    def poll(cls, context):
        collection = context.view_layer.active_layer_collection.collection
        collection_obj = collection.BIMCollectionProperties.obj
-        relating_type_id = int(bpy.data.scenes["Scene"].BIMModelProperties.relating_type_id)
-        relating_type = ifcopenshell.util.element.get_predefined_type(tool.Ifc.get().by_id(relating_type_id))
-        return tool.Ifc.get_entity(collection_obj) and relating_type == "CEILING"
+        return tool.Ifc.get_entity(collection_obj)

    def _execute(self, context):

@@ -120,11 +116,9 @@ class AddInstanceFlooringCoveringsFromWalls(bpy.types.Operator, tool.Ifc.Operato
    def poll(cls, context):
        active_obj = bpy.context.active_object
        element = tool.Ifc.get_entity(active_obj)
-        relating_type_id = int(bpy.data.scenes["Scene"].BIMModelProperties.relating_type_id)
-        relating_type = ifcopenshell.util.element.get_predefined_type(tool.Ifc.get().by_id(relating_type_id))
        if element:
            if element.is_a("IfcWall") and tool.Model.get_usage_type(element) == "LAYER2":
-                return context.selected_objects and relating_type == "FLOORING"
+                return context.selected_objects

    def _execute(self, context):
        # This only works based on a 2D plan only considering the standard
@@ -153,7 +147,7 @@ class AddInstanceFlooringCoveringsFromWalls(bpy.types.Operator, tool.Ifc.Operato

 class AddInstanceCeilingCoveringsFromWalls(bpy.types.Operator, tool.Ifc.Operator):
    bl_idname = "bim.add_instance_ceiling_coverings_from_walls"
-    bl_label = "Add Ceiling From Walls"
+    bl_label = "Add Ceilings From Walls"
    bl_options = {"REGISTER", "UNDO"}
    bl_description = "Add instance ceiling coverings from selected walls. The active object must be a wall and layered vertically"

@@ -161,11 +155,9 @@ class AddInstanceCeilingCoveringsFromWalls(bpy.types.Operator, tool.Ifc.Operator
    def poll(cls, context):
        active_obj = bpy.context.active_object
        element = tool.Ifc.get_entity(active_obj)
-        relating_type_id = int(bpy.data.scenes["Scene"].BIMModelProperties.relating_type_id)
-        relating_type = ifcopenshell.util.element.get_predefined_type(tool.Ifc.get().by_id(relating_type_id))
        if element:
            if element.is_a("IfcWall") and tool.Model.get_usage_type(element) == "LAYER2":
-                return context.selected_objects and relating_type == "CEILING"
+                return context.selected_objects

    def _execute(self, context):
        # This only works based on a 2D plan only considering the standard
@@ -53,7 +53,7 @@ class AuthoringData:
        cls.data["ifc_element_type"] = cls.ifc_element_type
        cls.data["ifc_classes"] = cls.ifc_classes()
        cls.data["relating_type_id"] = cls.relating_type_id()  # only after .ifc_classes()
-        cls.data["predefined_type"] = cls.predefined_type() # only after .relating_type_id()
+        cls.data["predefined_type"] = cls.predefined_type()
        cls.data["type_class"] = cls.type_class()

        # only after .type_class()
@@ -121,10 +121,9 @@ class AuthoringData:
    def type_thumbnail(cls):
        if not cls.data["relating_type_id"]:
            return 0
-        relating_type_id = tool.Blender.get_enum_safe(cls.props, "relating_type_id")
-        if relating_type_id is None:
+        if not tool.Blender.enum_property_has_valid_index(cls.props, "relating_type_id", cls.data["relating_type_id"]):
            return 0
-        element = tool.Ifc.get().by_id(int(relating_type_id))
+        element = tool.Ifc.get().by_id(int(cls.props.relating_type_id))
        return cls.type_thumbnails.get(element.id(), None) or 0

    @classmethod
@@ -252,8 +251,8 @@ class AuthoringData:

    @classmethod
    def predefined_type(cls):
-        relating_type_id = tool.Blender.get_enum_safe(cls.props, "relating_type_id")
-        if relating_type_id is None:
+        relating_type_id = cls.props.relating_type_id
+        if not relating_type_id:
            return
        relating_type = tool.Ifc.get().by_id(int(relating_type_id))
        if not hasattr(relating_type, "PredefinedType"):
@@ -23,7 +23,6 @@ from math import sin, cos, radians
 from bpy.types import SpaceView3D
 from mathutils import Vector, Matrix
 from gpu_extras.batch import batch_for_shader
-from typing import Union


 ERROR_ELEMENTS_COLOR = (1, 0.2, 0.322, 1)  # RED
@@ -36,6 +35,15 @@ def transparent_color(color, alpha=0.1):
    return color


+def bm_check_vertex_in_groups(vertex, deform_layer, groups):
+    """returns tuple boolean (whether vertex is in any of the groups)
+    and related group index"""
+    for group_index in vertex[deform_layer].keys():
+        if group_index in groups:
+            return True, group_index
+    return False, None
+
+
 class ProfileDecorator:
    installed = None

@@ -140,12 +148,12 @@ class ProfileDecorator:
            # deform_layer is None if there are no verts assigned to vertex groups
            # even if there are vertex groups in the obj.vertex_groups
            if deform_layer:
-                is_arc, group_index = tool.Blender.bmesh_check_vertex_in_groups(vertex, deform_layer, arc_groups)
+                is_arc, group_index = bm_check_vertex_in_groups(vertex, deform_layer, arc_groups)
                if is_arc:
                    arcs.setdefault(group_index, []).append(vertex)
                    special_vertex_indices[vertex.index] = group_index

-                is_circle, group_index = tool.Blender.bmesh_check_vertex_in_groups(vertex, deform_layer, circle_groups)
+                is_circle, group_index = bm_check_vertex_in_groups(vertex, deform_layer, circle_groups)
                if is_circle:
                    circles.setdefault(group_index, []).append(vertex)
                    special_vertex_indices[vertex.index] = group_index
@@ -22,24 +22,20 @@ import bmesh
 from bmesh.types import BMVert, BMFace

 import ifcopenshell
-import ifcopenshell.api
-import ifcopenshell.util.element
-import ifcopenshell.util.representation
 from ifcopenshell.util.shape_builder import V
 import blenderbim
 import blenderbim.tool as tool
-import blenderbim.core.geometry
 import blenderbim.core.geometry as core
-import blenderbim.core.root
-from blenderbim.bim.module.model.window import create_bm_window, create_bm_box
+from blenderbim.bim.module.model.window import create_bm_window, create_bm_box, update_simple_openings

 from mathutils import Vector, Matrix
+from pprint import pprint

 import json
 import collections


-def update_door_modifier_representation(context: bpy.types.Context, obj: bpy.types.Object) -> None:
+def update_door_modifier_representation(context, obj):
    props = obj.BIMDoorProperties
    element = tool.Ifc.get_entity(obj)
    ifc_file = tool.Ifc.get()
@@ -163,7 +159,7 @@ def update_door_modifier_representation(context: bpy.types.Context, obj: bpy.typ
        occurrence.OverallWidth = props.overall_width / si_conversion
        occurrence.OverallHeight = props.overall_height / si_conversion

-    tool.Model.update_simple_openings(element)
+    update_simple_openings(element, props.overall_width / si_conversion, props.overall_height / si_conversion)


 # TODO: move it out to tools
@@ -648,6 +644,6 @@ class RemoveDoor(bpy.types.Operator, tool.Ifc.Operator):
        obj.BIMDoorProperties.is_editing = False

        pset = tool.Pset.get_element_pset(element, "BBIM_Door")
-        ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), product=element, pset=pset)
+        ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), pset=pset)

        return {"FINISHED"}
@@ -542,7 +542,7 @@ class MEPGenerator:
            ifc_representation_class=None,
        )

-        rel = ifcopenshell.api.run("material.assign_material", ifc_file, products=[element], type="IfcMaterialProfileSet")
+        rel = ifcopenshell.api.run("material.assign_material", ifc_file, product=element, type="IfcMaterialProfileSet")
        profile_set = rel.RelatingMaterial
        material_profile = ifcopenshell.api.run(
            "material.add_profile", ifc_file, profile_set=profile_set, material=material
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Thomas Krijnen	e4cebd4e5d	checkout v0.7.0 -- src/ifcgeom_schema_agnostic/IfcGeomRepresentation.cpp	2024-03-26 15:13:15 +01:00
Dion Moult	394807f1df	Reinclude missing max_protrusions_	2024-03-26 23:04:32 +11:00
Thomas Krijnen	8eeb429ec1	Merge remote-tracking branch 'origin/v0.7.0' into feature-clash2	2024-03-26 11:21:45 +01:00
Thomas Krijnen	1c9189f5f8	Fix is_manifold(), sorry :(	2024-03-26 11:00:16 +01:00
Thomas Krijnen	796760a064	Integrate @Moult's add_element(TriangulationElement*)	2024-03-06 21:44:43 +01:00
Dion Moult	f65da3d016	Clash detection features	2024-02-29 17:17:59 +11:00