removed unnecessary code

Co-authored-by: Bruno Perdigão <57102715+brunoperdigao@users.noreply.github.com>

.github/workflows/cd.yml

@@ -16,7 +16,7 @@ jobs:
     - run: echo ok go
 
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: activate
     steps:
     - uses: actions/checkout@v2
@@ -80,7 +80,7 @@ jobs:
         path: build/assets/Ifc*
 
   deliver:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     needs: build
     name: Docker Build, Tag, Push
 

.github/workflows/ci-bsdd-pypi.yaml

@@ -0,0 +1,48 @@
+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

.github/workflows/ci-ifcclash-pypi.yaml

@@ -0,0 +1,48 @@
+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

.github/workflows/ci-ifccsv-pypi.yaml

@@ -0,0 +1,48 @@
+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

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

@@ -1,6 +1,7 @@
 name: ci-ifcopenshell-pypi
 
 on:
+  workflow_dispatch:
   schedule:
     #         ┌───────────── minute (0 - 59)
     #         │  ┌───────────── hour (0 - 23)
@@ -35,7 +36,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        pyver: [py36, py37, py38, py39, py310, py311]
+        pyver: [py39, py310, py311, py312]
         config:
           - {
             name: "Windows Build",
@@ -57,7 +58,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
         with:
-          python-version: '3.10' # Version range or exact version of a Python version to use, using SemVer's version range syntax
+          python-version: '3.11' # 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

.github/workflows/ci-ifcpatch-pypi.yaml

@@ -0,0 +1,48 @@
+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

.github/workflows/ci-ifcsverchok-build.yml

@@ -0,0 +1,53 @@
+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}}"

.github/workflows/ci-ifctester-pypi.yml

@@ -9,9 +9,6 @@ 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:
@@ -30,7 +27,6 @@ jobs:
 
   build:
     needs: activate
-    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
@@ -38,12 +34,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-python@v2 # https://github.com/actions/setup-python
         with:
-          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')"
+          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

README.md

@@ -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](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)
+* [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)
 * [BlenderBIM Add-on Website](https://blenderbim.org)
-* [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)
+* [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)
 
 | Service                                         | Status                                                                                                                                       |
 | ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |

aws/lambda/Dockerfile

@@ -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://blenderbim.org/docs-python/ifcopenshell-python/installation.html)
+# Set the IfcOpenShell build version (check available builds at: https://docs.ifcopenshell.org/ifcopenshell-python/installation.html)
 ARG IFC_OPENSHELL_BUILD="39-v0.7.0-476ab50"
 
 # Download and extract IfcOpenShell

choco/blenderbim/blenderbim.nuspec

@@ -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://blenderbim.org/docs/</docsUrl>
+    <docsUrl>https://docs.blenderbim.org/</docsUrl>
     <!--<mailingListUrl></mailingListUrl>-->
     <bugTrackerUrl>https://github.com/IfcOpenShell/IfcOpenShell/issues</bugTrackerUrl>
     <tags>blender bim blenderbim ifc python opensource foss</tags>

src/blenderbim/Makefile

@@ -137,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-9838698-$(PLATFORM)64.zip
+	cd dist/working && wget https://s3.amazonaws.com/ifcopenshell-builds/ifcopenshell-python-$(PYNUMBER)-v0.7.0-f7c03db-$(PLATFORM)64.zip
 	cd dist/working && unzip ifcopenshell-python*
 	cp -r dist/working/ifcopenshell dist/blenderbim/libs/site/packages/
 
@@ -151,8 +151,10 @@ 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
-	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/
+	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 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
@@ -363,6 +365,8 @@ endif
 	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
 	cp -r dist/working/site-packages/* dist/blenderbim/libs/site/packages/
 	rm -rf dist/working
 
@@ -430,7 +434,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://blenderbim.org/builds/pkg_resources.tar.gz
+	cd dist/working && wget https://github.com/IfcOpenShell/IfcOpenShell/raw/v0.7.0/src/blenderbim/scripts/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

src/blenderbim/blenderbim/__init__.py

@@ -18,7 +18,13 @@
 
 import os
 import sys
-import site
+import bpy
+import platform
+import traceback
+import subprocess
+import webbrowser
+import addon_utils
+from collections import deque
 
 bl_info = {
     "name": "BlenderBIM",
@@ -27,21 +33,155 @@ bl_info = {
     "blender": (3, 1, 0),
     "version": (0, 0, 999999),
     "location": "File Menu, Scene Properties Tab. See documentation for more.",
-    "doc_url": "https://blenderbim.org/docs",
+    "doc_url": "https://docs.blenderbim.org/",
     "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 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"))
 
-    import blenderbim.bim
+    try:
+        import blenderbim.bim
+        import ifcopenshell.api
 
-    def register():
-        blenderbim.bim.register()
+        def log_api(usecase_path, ifc_file, settings):
+            last_actions.append(
+                {
+                    "type": "ifcopenshell.api",
+                    "name": usecase_path,
+                    "settings": ifcopenshell.api.serialise_settings(settings),
+                }
+            )
 
-    def unregister():
-        blenderbim.bim.unregister()
+        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):
+                layout = self.layout
+                layout.label(text="BlenderBIM could not load.", icon="ERROR")
+                layout.label(text="View the console for full logs.", icon="CONSOLE")
+                box = layout.box()
+                info = get_debug_info()
+                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"
+
+        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())
+
+                if platform.system() == "Windows":
+                    command = "echo | set /p nul=" + info
+                elif platform.system() == "Darwin":  # for MacOS
+                    command = 'printf "' + info.replace("\n", "\\n").replace('"', "") + '" | pbcopy'
+                else:  # Linux
+                    command = 'printf "' + info.replace("\n", "\\n").replace('"', "") + '" | xclip -selection clipboard'
+                subprocess.run(command, shell=True, check=True)
+                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)

src/blenderbim/blenderbim/bim/__init__.py

@@ -17,12 +17,13 @@
 # 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
@@ -96,10 +97,13 @@ 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,
@@ -130,6 +134,7 @@ classes = [
     prop.BIMMeshProperties,
     prop.BIMFacet,
     prop.BIMFilterGroup,
+    ui.BIM_UL_clipping_plane,
     ui.BIM_UL_generic,
     ui.BIM_UL_topics,
     ui.BIM_ADDON_preferences,
@@ -187,7 +192,7 @@ addon_keymaps = []
 icons = None
 is_registering = False
 last_commit_hash = "8888888"
-overridden_scene_panels = dict()
+original_scene_panels_polls: dict[bpy.types.Panel, Union[Callable, None]] = dict()
 
 
 def on_register(scene):
@@ -295,10 +300,10 @@ def unregister():
             km.keymap_items.remove(kmi)
     addon_keymaps.clear()
 
-    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]
+    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)
 
     bpy.app.translations.unregister("blenderbim")

src/blenderbim/blenderbim/bim/data/pset/EPset_Drawing.ifc

@@ -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',(#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/DRAWING',(#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.);

src/blenderbim/blenderbim/bim/data/pset/Psets_BBIM_Annotation.ifc

@@ -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_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#2,#3,#4));
+#1=IFCPROPERTYSETTEMPLATE('3VuPUwdCD2Qx3XDDRs0R1N',$,'EPset_Annotation','',.PSET_TYPEDRIVENOVERRIDE.,'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_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#6,#7));
+#5=IFCPROPERTYSETTEMPLATE('0iKwujnQL9IevVQato8f7Z',$,'BBIM_Batting','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation/BATTING,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_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#9,#10,#11,#12,#13));
+#8=IFCPROPERTYSETTEMPLATE('1Dx2EiZnP67xotInXpwz90',$,'BBIM_Section','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation/SECTION,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_OCCURRENCEDRIVEN.,'IfcProject',(#15,#16,#17,#18,#19,#20,#21,#22,#23));
+#14=IFCPROPERTYSETTEMPLATE('3V8oZ8YRD3_O7uR5vcUleS',$,'BBIM_Documentation','',.PSET_TYPEDRIVENOVERRIDE.,'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_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#25,#26,#27,#28));
+#24=IFCPROPERTYSETTEMPLATE('0I9merLinF5Ap$aZwaclgm',$,'BBIM_Dimension','',.PSET_TYPEDRIVENOVERRIDE.,'IfcAnnotation/DIMENSION,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.);

src/blenderbim/blenderbim/bim/export_ifc.py

@@ -16,6 +16,7 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
+from __future__ import annotations
 import os
 import bpy
 import json
@@ -35,6 +36,8 @@ 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:
@@ -86,8 +89,8 @@ class IfcExporter:
             self.get_application_name(), tool.Blender.get_blenderbim_version()
         )
 
-    def sync_all_objects(self):
-        results = []
+    def sync_all_objects(self, skip_unlinking=False) -> list[ifcopenshell.entity_instance]:
+        results: list[ifcopenshell.entity_instance] = []
         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]
@@ -96,19 +99,21 @@ class IfcExporter:
                     continue
                 if obj.library:
                     continue
-                tool.Collector.sync(obj)
+                tool.Collector.sync(obj, skip_unlinking)
                 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):
-        results = []
+    def sync_edited_objects(self) -> list[ifcopenshell.entity_instance]:
+        results: list[ifcopenshell.entity_instance] = []
         for obj in IfcStore.edited_objs.copy():
             if not obj:
                 continue
@@ -126,7 +131,7 @@ class IfcExporter:
         IfcStore.edited_objs.clear()
         return results
 
-    def sync_object_material(self, obj):
+    def sync_object_material(self, obj: bpy.types.Object) -> None:
         if not obj.data or not isinstance(obj.data, bpy.types.Mesh):
             return
         if not self.has_changed_materials(obj):
@@ -137,11 +142,10 @@ 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):
+    def sync_object_placement(self, obj: bpy.types.Object) -> Union[ifcopenshell.entity_instance, None]:
         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
@@ -152,7 +156,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, element):
+    def sync_grid_axis_object_placement(self, obj: bpy.types.Object, element: ifcopenshell.entity_instance) -> None:
         grid = (element.PartOfU or element.PartOfV or element.PartOfW)[0]
         grid_obj = tool.Ifc.get_object(grid)
         if grid_obj:
@@ -161,10 +165,10 @@ class IfcExporter:
                 bpy.ops.bim.update_representation(obj=obj.name)
         tool.Geometry.record_object_position(obj)
 
-    def get_application_name(self):
+    def get_application_name(self) -> str:
         return "BlenderBIM"
 
-    def get_application_version(self):
+    def get_application_version(self) -> str:
         version = ".".join(
             [
                 str(x)
@@ -182,11 +186,13 @@ class IfcExporter:
 
 class IfcExportSettings:
     def __init__(self):
-        self.logger = None
-        self.output_file = None
+        self.logger: Logger = None
+        self.output_file: str = None
+        self.json_version: str = None
+        self.json_compact: bool = None
 
     @staticmethod
-    def factory(context, output_file, logger):
+    def factory(context: bpy.types.Context, output_file: str, logger: Logger) -> IfcExportSettings:
         settings = IfcExportSettings()
         settings.output_file = output_file
         settings.logger = logger

src/blenderbim/blenderbim/bim/handler.py

@@ -31,6 +31,7 @@ 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__))
@@ -191,6 +192,8 @@ 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):
@@ -220,7 +223,7 @@ def redo_post(scene):
     tool.Ifc.rebuild_element_maps()
 
 
-def get_application(ifc):
+def get_application(ifc: ifcopenshell.file) -> ifcopenshell.entity_instance:
     # 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"):
@@ -235,7 +238,20 @@ def get_application(ifc):
     )
 
 
-def get_application_version():
+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:
     return ".".join(
         [
             str(x)
@@ -254,60 +270,6 @@ 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
@@ -330,7 +292,7 @@ def load_post(scene):
                 key=key, owner=global_subscription_owner, args=(area,), notify=viewport_shading_changed_callback
             )
 
-    ifcopenshell.api.owner.settings.get_user = lambda ifc: core_owner.get_user(tool.Owner)
+    ifcopenshell.api.owner.settings.get_user = get_user
     ifcopenshell.api.owner.settings.get_application = get_application
     AuthoringData.type_thumbnails = {}
 
@@ -343,15 +305,11 @@ def load_post(scene):
         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 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)
+    # 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)
     tool.Blender.setup_tabs()

src/blenderbim/blenderbim/bim/helper.py

@@ -29,6 +29,7 @@ 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
 
 
 def draw_attributes(props, layout, copy_operator=None, popup_active_attribute=None):
@@ -75,6 +76,10 @@ 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
@@ -116,7 +121,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()])
+        new.string_value = "" if new.is_null else str(data[attribute.name()]).replace("\n", "\\n")
         if attribute.type_of_attribute().declared_type().name() == "IfcURIReference":
             new.is_uri = True
     elif data_type == "boolean":
@@ -178,7 +183,7 @@ def add_attribute_description(attribute_blender, attribute_ifc=None):
         attribute_blender.description = description
 
 
-def export_attributes(props, callback=None):
+def export_attributes(props, callback: Optional[Callable] = None) -> dict[str, Any]:
     attributes = {}
     for prop in props:
         is_handled_by_callback = callback(attributes, prop) if callback else False
@@ -321,7 +326,6 @@ def draw_filter(layout, filter_groups, data, module):
             op.module = module
 
 
-
 # TODO this should move into ifcopenshell.util
 
 

src/blenderbim/blenderbim/bim/ifc.py

@@ -19,12 +19,15 @@
 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
@@ -37,19 +40,19 @@ IFC_CONNECTED_TYPE = Union[bpy.types.Material, bpy.types.Object]
 
 class IfcStore:
     path: str = ""
-    file: ifcopenshell.file = None
-    schema: ifcopenshell.ifcopenshell_wrapper.schema_definition = None
-    cache: ifcopenshell.ifcopenshell_wrapper.HdfSerializer = None
-    cache_path: str = None
+    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
     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: ifcopenshell.file = None
+    pset_template_file: Optional[ifcopenshell.file] = None
     classification_path: str = ""
-    classification_file: ifcopenshell.file = None
+    classification_file: Optional[ifcopenshell.file] = None
     library_path: str = ""
-    library_file: ifcopenshell.file = None
+    library_file: Optional[ifcopenshell.file] = None
     current_transaction = ""
     last_transaction = ""
     history = []
@@ -119,7 +122,13 @@ 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
-        os.replace(IfcStore.cache_path, new_cache_path)
+        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!
         IfcStore.get_cache()
 
     @staticmethod
@@ -329,6 +338,7 @@ 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)
 
@@ -343,10 +353,14 @@ class IfcStore:
         else:
             operator.transaction_key = IfcStore.current_transaction
 
-        if is_invoke:
-            result = getattr(operator, "_invoke")(context, None)
-        else:
-            result = getattr(operator, "_execute")(context)
+        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_top_level_operator:
             if tool.Ifc.get():

src/blenderbim/blenderbim/bim/import_ifc.py

@@ -34,6 +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 ifcopenshell.ifcopenshell_wrapper as ifcopenshell_wrapper
 from itertools import chain, accumulate
@@ -199,7 +200,7 @@ class MaterialCreator:
 
 
 class IfcImporter:
-    def __init__(self, ifc_import_settings):
+    def __init__(self, ifc_import_settings: IfcImportSettings):
         self.ifc_import_settings = ifc_import_settings
         self.diff = None
         self.file: ifcopenshell.file = None
@@ -298,6 +299,7 @@ class IfcImporter:
         if self.ifc_import_settings.should_setup_viewport_camera:
             self.setup_viewport_camera()
         self.setup_arrays()
+        self.profile_code("Setup arrays")
         self.update_progress(100)
         bpy.context.window_manager.progress_end()
 
@@ -430,7 +432,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")]
+        self.elements = [e for e in self.elements if not e.is_a("IfcFeatureElement") or e.is_a("IfcSurfaceFeature")]
         if self.ifc_import_settings.is_coordinating:
             self.elements = [e for e in self.elements if e.Representation]
 
@@ -601,6 +603,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.
 
         faces = [len(e.CfsFaces) for e in self.file.by_type("IfcClosedShell")]
@@ -697,15 +702,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 = np.array(
+            point = mat @ np.array(
                 (
-                    shape.geometry.verts[0] / self.unit_scale,
-                    shape.geometry.verts[1] / self.unit_scale,
-                    shape.geometry.verts[2] / self.unit_scale,
+                    shape.geometry.verts[0],
+                    shape.geometry.verts[1],
+                    shape.geometry.verts[2],
                     0.0,
                 )
             )
-            return mat @ point
+            point = point / self.unit_scale
+            if self.is_point_far_away(point, is_meters=False):
+                return point
 
     def does_element_likely_have_geometry_far_away(self, element):
         for representation in element.Representation.Representations:
@@ -725,7 +732,7 @@ class IfcImporter:
                         if len(subelement.Coordinates) == 3 and self.is_point_far_away(subelement, is_meters=False):
                             return True
 
-    def apply_blender_offset_to_matrix_world(self, obj, matrix):
+    def apply_blender_offset_to_matrix_world(self, obj: bpy.types.Object, matrix: np.ndarray) -> mathutils.Matrix:
         props = bpy.context.scene.BIMGeoreferenceProperties
         if props.has_blender_offset:
             if obj.data and obj.data.get("has_cartesian_point_offset", None):
@@ -857,7 +864,10 @@ class IfcImporter:
         print("Done creating geometry")
 
     def create_spatial_elements(self) -> None:
-        self.create_generic_elements(self.spatial_elements, unselectable=True)
+        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)
 
     def create_elements(self) -> None:
         self.create_generic_elements(self.elements)
@@ -949,7 +959,9 @@ class IfcImporter:
             self.create_product(element, mesh=mesh)
 
     def create_products(
-        self, products, settings: Optional[ifcopenshell.geom.main.settings] = None
+        self,
+        products: set[ifcopenshell.entity_instance],
+        settings: Optional[ifcopenshell.geom.main.settings] = None,
     ) -> set[ifcopenshell.entity_instance]:
         results = set()
         if not products:
@@ -1488,7 +1500,10 @@ class IfcImporter:
             # Occurs when reloading a project
             pass
         project_collection = bpy.context.view_layer.layer_collection.children[self.project["blender"].name]
-        project_collection.children[self.type_collection.name].hide_viewport = True
+        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)
 
     def clean_mesh(self):
         obj = None
@@ -1623,30 +1638,34 @@ class IfcImporter:
         if self.ifc_import_settings.has_filter:
             rel_aggregates = set()
             for element in self.elements:
-                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])
+                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])
         else:
             rel_aggregates = [
                 r
                 for r in self.file.by_type("IfcRelAggregates")
-                if r.RelatingObject.is_a("IfcElement") or r.RelatingObject.is_a("IfcElementType")
+                if (relating_obj := r.RelatingObject).is_a("IfcElement") or relating_obj.is_a("IfcElementType")
             ] + [
                 r
                 for r in self.file.by_type("IfcRelNests")
                 if (
-                    r.RelatingObject.is_a("IfcElement")
-                    or r.RelatingObject.is_a("IfcElementType")
-                    or (r.RelatingObject.is_a("IfcPositioningElement") and not r.RelatingObject.is_a("IfcGrid"))
+                    (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"))
                 )
                 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
@@ -1656,7 +1675,9 @@ class IfcImporter:
 
         aggregates: dict[str, dict] = {}
         for rel_aggregate in rel_aggregates:
-            element: ifcopenshell.entity_instance = rel_aggregate.RelatingObject
+            element: ifcopenshell.entity_instance = getattr(rel_aggregate, "RelatingObject", None) or getattr(
+                rel_aggregate, "RelatingElement"
+            )
             collection = bpy.data.collections.new(tool.Loader.get_name(element))
             aggregates[element.GlobalId] = {"element": element, "collection": collection}
             self.collections[element.GlobalId] = collection
@@ -1757,6 +1778,9 @@ 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)
 
@@ -1806,7 +1830,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.array:
+    def get_element_matrix(self, element: ifcopenshell.entity_instance) -> np.ndarray:
         if isinstance(element, ifcopenshell.sqlite_entity):
             result = self.geometry_cache["shapes"][element.id()]["matrix"]
         else:
@@ -1889,11 +1913,7 @@ class IfcImporter:
                 and geometry.verts
                 and self.is_point_far_away((geometry.verts[0], geometry.verts[1], geometry.verts[2]))
             ):
-                m = shape.transformation.matrix.data
-                mat = np.array(
-                    ([m[0], m[3], m[6], m[9]], [m[1], m[4], m[7], m[10]], [m[2], m[5], m[8], m[11]], [0, 0, 0, 1])
-                )
-                offset_point = np.linalg.inv(mat) @ np.array(
+                offset_point = np.array(
                     (
                         float(props.blender_eastings),
                         float(props.blender_northings),
@@ -1901,8 +1921,15 @@ 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],
@@ -1928,7 +1955,9 @@ class IfcImporter:
 
                 # See bug 3546
                 # ios_edges holds true edges that aren't triangulated.
-                mesh["ios_edges"] = list(set(tuple(e) for e in ifcopenshell.util.shape.get_edges(geometry)))
+                #
+                # 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.vertices.add(num_vertices)
                 mesh.vertices.foreach_set("co", verts)
@@ -1955,14 +1984,14 @@ class IfcImporter:
 
             print(traceback.format_exc())
 
-    def a2p(self, o, z, x):
+    def a2p(self, o: mathutils.Vector, z: mathutils.Vector, x: mathutils.Vector) -> mathutils.Matrix:
         y = z.cross(x)
         r = mathutils.Matrix((x, y, z, o))
         r.resize_4x4()
         r.transpose()
         return r
 
-    def get_axis2placement(self, plc):
+    def get_axis2placement(self, plc: ifcopenshell.entity_instance) -> mathutils.Matrix:
         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))
@@ -1982,7 +2011,7 @@ class IfcImporter:
         o = plc.LocalOrigin.Coordinates
         return self.a2p(o, z, x)
 
-    def get_local_placement(self, plc):
+    def get_local_placement(self, plc: Optional[ifcopenshell.entity_instance] = None) -> mathutils.Matrix:
         if plc is None:
             return mathutils.Matrix()
         if plc.PlacementRelTo is None:
@@ -1997,11 +2026,11 @@ class IfcImporter:
                 bpy.context.scene.BIMRootProperties.contexts = str(subcontext.id())
                 break
 
-    def link_element(self, element, obj):
+    def link_element(self, element: ifcopenshell.entity_instance, obj: IFC_CONNECTED_TYPE) -> None:
         self.added_data[element.id()] = obj
         tool.Ifc.link(element, obj)
 
-    def set_matrix_world(self, obj, matrix_world):
+    def set_matrix_world(self, obj: bpy.types.Object, matrix_world: mathutils.Matrix) -> None:
         obj.matrix_world = matrix_world
         tool.Geometry.record_object_position(obj)
 
@@ -2024,7 +2053,7 @@ class IfcImporter:
 
 class IfcImportSettings:
     def __init__(self):
-        self.logger = None
+        self.logger: logging.Logger = None
         self.input_file = None
         self.diff_file = None
         self.should_use_cpu_multiprocessing = True

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

@@ -96,12 +96,13 @@ class BIM_OT_aggregate_unassign_object(bpy.types.Operator, Operator):
             )
 
             # Removes Pset related to Linked Aggregates
-            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)
-
+            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(), pset=pset)
 
+              
 class BIM_OT_enable_editing_aggregate(bpy.types.Operator, Operator):
     """Enable editing aggregation relationship"""
 
@@ -132,6 +133,7 @@ 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)
@@ -139,13 +141,15 @@ 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)
+        aggregate = self.create_aggregate(context, ifc_class, self.aggregate_name)
 
         for obj in context.selected_objects:
             element = tool.Ifc.get_entity(obj)
@@ -173,8 +177,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 = bpy.data.objects.new("Assembly", None)
+    def create_aggregate(self, context, ifc_class, aggregate_name):
+        aggregate = bpy.data.objects.new(aggregate_name, None)
         aggregate.location = context.scene.cursor.location
         bpy.ops.bim.assign_class(obj=aggregate.name, ifc_class=ifc_class)
         return aggregate
@@ -190,12 +194,17 @@ 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
-        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)
+        # 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)
         return {"FINISHED"}
 
 
@@ -217,18 +226,43 @@ 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)
+
+        # 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)
+        
         if self.select_parts:
-            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,
-            )
+            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      
+
         return {"FINISHED"}
 
 
@@ -283,7 +317,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], product=aggregate)
+        tool.Ifc.run("group.unassign_group", group=linked_aggregate_group[0], products=[aggregate])
 
         return {"FINISHED"}
 
@@ -292,28 +326,51 @@ 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
 
-        for rel in linked_aggregate_group[0].IsGroupedBy or []:
-            for element in rel.RelatedObjects:
-                obj = tool.Ifc.get_object(element)
-                obj.select_set(True)
+            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)
 
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/aggregate/ui.py

@@ -20,6 +20,7 @@ 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):
@@ -72,7 +73,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 Aggregate", icon="TRIA_UP")
+                row.label(text="No Whole relation defined", icon="TRIA_UP")
                 row.operator("bim.enable_editing_aggregate", icon="GREASEPENCIL", text="")
                 row.operator("bim.add_aggregate", icon="ADD", text="")
 
@@ -131,19 +132,29 @@ class BIM_PT_linked_aggregate(Panel):
         if not AggregateData.is_loaded:
             AggregateData.load()
 
-        props = context.active_object.BIMObjectAggregateProperties
+        obj = context.active_object
+        element = tool.Ifc.get_entity(obj)
+        props = obj.BIMObjectAggregateProperties
         row = layout.row(align=True)
-        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")
+
+
+        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.object_duplicate_move_linked_aggregate", 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")
         else:
-            row.label(text="No Linked Aggregates")
+            row.label(text="Not an Aggregate")
             
         
 

src/blenderbim/blenderbim/bim/module/attribute/operator.py

@@ -20,6 +20,7 @@ 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
@@ -47,10 +48,18 @@ class EnableEditingAttributes(bpy.types.Operator):
             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()
@@ -62,10 +71,11 @@ 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(
-            tool.Ifc.get().by_id(oprops.ifc_definition_id), props.attributes, callback=callback
-        )
+        blenderbim.bim.helper.import_attributes2(element, props.attributes, callback=callback)
         props.is_editing_attributes = True
         return {"FINISHED"}
 
@@ -120,20 +130,46 @@ class EditAttributes(bpy.types.Operator, Operator):
         return {"FINISHED"}
 
 
-class GenerateGlobalId(bpy.types.Operator):
+class GenerateGlobalId(bpy.types.Operator, 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"}
 
-    def execute(self, context):
-        index = context.active_object.BIMAttributeProperties.attributes.find("GlobalId")
-        if index >= 0:
-            global_id = context.active_object.BIMAttributeProperties.attributes[index]
+    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
         else:
-            global_id = context.active_object.BIMAttributeProperties.attributes.add()
-        global_id.name = "GlobalId"
-        global_id.data_type = "string"
-        global_id.string_value = ifcopenshell.guid.new()
+            guid_value = ifcopenshell.guid.new()
+
+        props.attributes["GlobalId"].string_value = guid_value
         return {"FINISHED"}
 
 

src/blenderbim/blenderbim/bim/module/boundary/operator.py

@@ -20,6 +20,7 @@ import bpy
 import bmesh
 import logging
 import shapely
+import shapely.ops
 import mathutils
 import numpy as np
 import multiprocessing

src/blenderbim/blenderbim/bim/module/clash/data.py

@@ -17,138 +17,36 @@
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
-import ifcopenshell
-import ifcopenshell.util.date
-import ifcopenshell.util.classification
+import json
+import ifcopenshell.util.element
 import blenderbim.tool as tool
-from blenderbim.bim.ifc import IfcStore
 
 
 def refresh():
-    ClassificationsData.is_loaded = False
-    ClassificationReferencesData.is_loaded = False
-    MaterialClassificationsData.is_loaded = False
-    CostClassificationsData.is_loaded = False
+    ClashData.is_loaded = False
 
 
-class ClassificationsData:
+class ClashData:
     data = {}
     is_loaded = False
 
     @classmethod
     def load(cls):
         cls.is_loaded = True
-        cls.data["has_classification_file"] = cls.has_classification_file()
-        cls.data["classifications"] = cls.classifications()
-        cls.data["available_classifications"] = cls.available_classifications()
+        cls.data = {}
+        cls.data["saved_searches"] = cls.saved_searches()
 
     @classmethod
-    def has_classification_file(cls):
-        return bool(IfcStore.classification_file)
-
-    @classmethod
-    def classifications(cls):
-        results = []
-        for element in tool.Ifc.get().by_type("IfcClassification"):
-            data = element.get_info()
-            if 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:
+    def saved_searches(cls):
+        if not tool.Ifc.get():
             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):
+        groups = tool.Ifc.get().by_type("IfcGroup")
         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
+        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")]

src/blenderbim/blenderbim/bim/module/clash/operator.py

@@ -86,14 +86,14 @@ class ImportClashSets(bpy.types.Operator):
                 new_source = new.a.add()
                 new_source.name = clash_source["file"]
                 if "selector" in clash_source:
-                    new_source.selector = clash_source["selector"]
+                    tool.Search.import_filter_query(clash_source["selector"], new_source.filter_groups)
                     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:
-                        new_source.selector = clash_source["selector"]
+                        tool.Search.import_filter_query(clash_source["selector"], new_source.filter_groups)
                         new_source.mode = clash_source["mode"]
         tool.Clash.import_active_clashes()
         return {"FINISHED"}
@@ -209,8 +209,11 @@ class ExecuteIfcClash(bpy.types.Operator):
 
     def invoke(self, context, event):
         _, extension = os.path.splitext(self.filepath)
-        if extension != ".json":
-            self.filepath = bpy.path.ensure_ext(bpy.data.filepath, ".bcf")
+        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")
         WindowManager = context.window_manager
         WindowManager.fileselect_add(self)
         return {"RUNNING_MODAL"}
@@ -221,6 +224,9 @@ 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")
 

src/blenderbim/blenderbim/bim/module/clash/prop.py

@@ -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
+from blenderbim.bim.prop import StrProperty, Attribute, BIMFilterGroup
 from bpy.types import PropertyGroup
 from bpy.props import (
     PointerProperty,
@@ -33,11 +33,12 @@ from bpy.props import (
 
 class ClashSource(PropertyGroup):
     name: StringProperty(name="File")
-    selector: StringProperty(name="Selector")
+    filter_groups: CollectionProperty(type=BIMFilterGroup, name="Filter Groups")
     mode: EnumProperty(
         items=[
-            ("i", "Include", "Only the selected objects are included for clashing"),
-            ("e", "Exclude", "All objects except the selected objects are included for clashing"),
+            ("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"),
         ],
         name="Mode",
     )

src/blenderbim/blenderbim/bim/module/clash/ui.py

@@ -17,7 +17,9 @@
 # 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):
@@ -30,6 +32,9 @@ 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
@@ -78,6 +83,7 @@ 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"
@@ -85,9 +91,10 @@ class BIM_PT_ifcclash(Panel):
             op.index = index
             op.group = "a"
 
-            row = layout.row(align=True)
-            row.prop(source, "mode", text="")
-            row.prop(source, "selector", text="")
+            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.label(text="Group B:", icon="OUTLINER_OB_POINTCLOUD")
@@ -96,6 +103,7 @@ 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"
@@ -103,9 +111,10 @@ class BIM_PT_ifcclash(Panel):
             op.index = index
             op.group = "b"
 
-            row = layout.row(align=True)
-            row.prop(source, "mode", text="")
-            row.prop(source, "selector", text="")
+            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()
         row.prop(props, "should_create_clash_snapshots")

src/blenderbim/blenderbim/bim/module/classification/operator.py

@@ -20,6 +20,8 @@ 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
@@ -87,7 +89,7 @@ class AddManualClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
         reference = ifcopenshell.api.run(
             "classification.add_reference",
             tool.Ifc.get(),
-            product=product,
+            products=[product],
             classification=classification,
             identification="X",
             name="Unnamed",
@@ -207,6 +209,10 @@ 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()
 
@@ -292,6 +298,7 @@ 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)
@@ -300,12 +307,16 @@ class RemoveClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
                 if (identification and reference[1] == identification) or (
                     not identification and reference == active_reference
                 ):
-                    ifcopenshell.api.run(
-                        "classification.remove_reference",
-                        tool.Ifc.get(),
-                        reference=reference,
-                        product=element,
-                    )
+                    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,
+                )
 
 
 class EditClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
@@ -357,15 +368,18 @@ class AddClassificationReference(bpy.types.Operator, tool.Ifc.Operator):
                 classification = element
                 break
 
-        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
+        ifc_file = tool.Ifc.get()
+        products = [
+            ifc_file.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:
             ifcopenshell.api.run(
                 "classification.add_reference",
                 tool.Ifc.get(),
                 reference=IfcStore.classification_file.by_id(self.reference),
-                product=tool.Ifc.get().by_id(ifc_definition_id),
+                products=products,
                 classification=classification,
             )
 
@@ -413,7 +427,7 @@ class AddClassificationReferenceFromBSDD(bpy.types.Operator, tool.Ifc.Operator):
             reference = ifcopenshell.api.run(
                 "classification.add_reference",
                 tool.Ifc.get(),
-                product=element,
+                products=[element],
                 classification=classification,
                 identification=bsdd_classification.reference_code,
                 name=bsdd_classification.name,

src/blenderbim/blenderbim/bim/module/constraint/operator.py

@@ -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,19 +179,17 @@ class AssignConstraint(bpy.types.Operator):
         return IfcStore.execute_ifc_operator(self, context)
 
     def _execute(self, context):
-        self.file = IfcStore.get_file()
+        self.file = tool.Ifc.get()
         objs = [bpy.data.objects.get(self.obj)] if self.obj else context.selected_objects
-        for obj in objs:
-            obj_id = obj.BIMObjectProperties.ifc_definition_id
-            if not obj_id:
-                continue
+        products = [self.file.by_id(obj_id) for obj in objs if (obj_id := obj.BIMObjectProperties.ifc_definition_id)]
+        if products:
             ifcopenshell.api.run(
                 "constraint.assign_constraint",
                 self.file,
                 **{
-                    "product": self.file.by_id(obj_id),
+                    "products": products,
                     "constraint": self.file.by_id(self.constraint),
-                }
+                },
             )
         return {"FINISHED"}
 
@@ -207,18 +205,16 @@ class UnassignConstraint(bpy.types.Operator):
         return IfcStore.execute_ifc_operator(self, context)
 
     def _execute(self, context):
-        self.file = IfcStore.get_file()
+        self.file = tool.Ifc.get()
         objs = [bpy.data.objects.get(self.obj)] if self.obj else context.selected_objects
-        for obj in objs:
-            obj_id = obj.BIMObjectProperties.ifc_definition_id
-            if not obj_id:
-                continue
+        products = [self.file.by_id(obj_id) for obj in objs if (obj_id := obj.BIMObjectProperties.ifc_definition_id)]
+        if products:
             ifcopenshell.api.run(
                 "constraint.unassign_constraint",
                 self.file,
                 **{
-                    "product": self.file.by_id(obj_id),
+                    "products": products,
                     "constraint": self.file.by_id(self.constraint),
-                }
+                },
             )
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/context/operator.py

@@ -53,6 +53,10 @@ 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()
 

src/blenderbim/blenderbim/bim/module/covering/workspace.py

@@ -107,59 +107,88 @@ 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)
@@ -174,14 +203,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):

src/blenderbim/blenderbim/bim/module/csv/operator.py

@@ -72,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"]
+        props = ["name", "header", "sort", "group", "varies_value", "summary", "formatting"]
         for prop in props:
             value = getattr(new, prop)
             setattr(new, prop, getattr(old, prop))
@@ -246,6 +246,7 @@ 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"}
 
 
@@ -285,6 +286,7 @@ 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"}
 
 

src/blenderbim/blenderbim/bim/module/debug/__init__.py

@@ -24,6 +24,7 @@ classes = (
     operator.CopyDebugInformation,
     operator.CreateAllShapes,
     operator.CreateShapeFromStepId,
+    operator.DebugActiveDrawing,
     operator.InspectFromObject,
     operator.InspectFromStepId,
     operator.OverrideDisplayType,
@@ -34,7 +35,6 @@ classes = (
     operator.PrintUnusedElementStats,
     operator.ProfileImportIFC,
     operator.PurgeHdf5Cache,
-    operator.PurgeIfcLinks,
     operator.PurgeUnusedElementsByClass,
     operator.RewindInspector,
     operator.SelectExpressFile,

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

@@ -20,18 +20,20 @@ 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
-import blenderbim.tool as tool
+from blenderbim import get_debug_info, format_debug_info
 from blenderbim.bim.ifc import IfcStore
 
 
@@ -41,28 +43,7 @@ class CopyDebugInformation(bpy.types.Operator):
     bl_description = "Copies debugging information to your clipboard for use in bugreports"
 
     def execute(self, context):
-        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,
-        }
-
+        info = get_debug_info()
         if tool.Ifc.get():
             info.update(
                 {
@@ -73,16 +54,18 @@ class CopyDebugInformation(bpy.types.Operator):
                 }
             )
 
-        # Format it in a readable way
-        text = "\n".join(f"{k}: {v}" for k, v in info.items())
+        text = format_debug_info(info)
+
+        print("-" * 80)
         print(text)
+        print("-" * 80)
 
         if platform.system() == "Windows":
-            command = "echo | set /p nul=" + text.strip()
+            command = "echo | set /p nul=" + text
         elif platform.system() == "Darwin":  # for MacOS
-            command = 'printf "' + text.strip().replace("\n", "\\n").replace('"', "") + '" | pbcopy'
+            command = 'printf "' + text.replace("\n", "\\n").replace('"', "") + '" | pbcopy'
         else:  # Linux
-            command = 'printf "' + text.strip().replace("\n", "\\n").replace('"', "") + '" | xclip -selection clipboard'
+            command = 'printf "' + text.replace("\n", "\\n").replace('"', "") + '" | xclip -selection clipboard'
         subprocess.run(command, shell=True, check=True)
         return {"FINISHED"}
 
@@ -101,10 +84,11 @@ class PrintIfcFile(bpy.types.Operator):
         return {"FINISHED"}
 
 
-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."
+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"}
 
     def execute(self, context):
         for obj in bpy.data.objects:
@@ -121,26 +105,6 @@ class PurgeIfcLinks(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"
@@ -660,3 +624,104 @@ 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"}

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

@@ -60,9 +60,6 @@ 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")
 
@@ -75,6 +72,9 @@ 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

src/blenderbim/blenderbim/bim/module/diff/data.py

@@ -38,6 +38,7 @@ 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
@@ -84,3 +85,18 @@ 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")]

src/blenderbim/blenderbim/bim/module/diff/operator.py

@@ -135,6 +135,7 @@ 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")
@@ -162,7 +163,7 @@ class ExecuteIfcDiff(bpy.types.Operator):
             new = ifcopenshell.open(self.props.new_file)
 
         relationships = [r.relationship for r in self.props.diff_relationships]
-        query = self.props.diff_filter_elements
+        query = tool.Search.export_filter_query(self.props.filter_groups) or None
 
         ifc_diff = ifcdiff.IfcDiff(old, new, relationships=relationships, filter_elements=query)
         ifc_diff.diff()

src/blenderbim/blenderbim/bim/module/diff/prop.py

@@ -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
+from blenderbim.bim.prop import StrProperty, BIMFilterGroup
 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")
-    diff_filter_elements: StringProperty(default="", name="Filter")
+    filter_groups: CollectionProperty(type=BIMFilterGroup, name="Filter Groups")
     should_load_changed_elements: BoolProperty(name="Load Changed Elements", default=True)
     active_file: EnumProperty(
         items=[

src/blenderbim/blenderbim/bim/module/diff/ui.py

@@ -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,9 +93,7 @@ class BIM_PT_diff(Panel):
             remove.collection = "diff_relationships"
             remove.index = index
 
-        row = layout.row(align=True)
-        row.prop(props, "diff_filter_elements")
-        row.operator("bim.ifc_selector", icon="FILTER", text="")
+        blenderbim.bim.helper.draw_filter(self.layout, props.filter_groups, DiffData, "diff")
 
         row = layout.row()
         row.operator("bim.execute_ifc_diff")

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

@@ -41,6 +41,7 @@ classes = (
     operator.CleanWireframes,
     operator.ContractSheet,
     operator.ContractTargetView,
+    operator.ConvertSVGToDXF,
     operator.CreateDrawing,
     operator.CreateSheets,
     operator.DisableAddAnnotationType,
@@ -126,7 +127,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.toggleDecorationsOnLoad)
+    bpy.app.handlers.load_post.append(handler.load_post)
     bpy.app.handlers.depsgraph_update_pre.append(handler.depsgraph_update_pre_handler)
     bpy.types.VIEW3D_MT_image_add.append(ui.add_object_button)
 
@@ -140,6 +141,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.toggleDecorationsOnLoad)
+    bpy.app.handlers.load_post.remove(handler.load_post)
     bpy.app.handlers.depsgraph_update_pre.remove(handler.depsgraph_update_pre_handler)
     bpy.types.VIEW3D_MT_image_add.remove(ui.add_object_button)

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

@@ -606,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,

src/blenderbim/blenderbim/bim/module/drawing/handler.py

@@ -23,7 +23,7 @@ from bpy.app.handlers import persistent
 
 
 @persistent
-def toggleDecorationsOnLoad(*args):
+def load_post(*args):
     if bpy.context.scene.DocProperties.should_draw_decorations:
         decoration.DecorationsHandler.install(bpy.context)
     else:

src/blenderbim/blenderbim/bim/module/drawing/operator.py

@@ -29,6 +29,7 @@ import subprocess
 import numpy as np
 import multiprocessing
 import ifcopenshell
+import ifcopenshell.ifcopenshell_wrapper
 import ifcopenshell.geom
 import ifcopenshell.util.selector
 import ifcopenshell.util.representation
@@ -44,7 +45,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
+from typing import NamedTuple, List, Union, Optional
 from lxml import etree
 from mathutils import Vector, Color, Matrix
 from timeit import default_timer as timer
@@ -199,6 +200,11 @@ 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):
@@ -214,13 +220,15 @@ 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 = self.props.active_drawing_id
+            original_drawing_id = 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 = [self.props.active_drawing_id]
+            drawings_to_print = [active_drawing_id]
 
-        for drawing_id in drawings_to_print:
+        for drawing_i, drawing_id in enumerate(drawings_to_print):
+            self.drawing_index = drawing_i
             if self.print_all:
                 bpy.ops.bim.activate_drawing(drawing=drawing_id, camera_view_point=False)
 
@@ -335,6 +343,13 @@ 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]
 
@@ -445,8 +460,14 @@ class CreateDrawing(bpy.types.Operator):
         return LineworkContexts(body_contexts, annotation_contexts)
 
     def serialize_contexts_elements(
-        self, ifc, tree: ifcopenshell.geom.tree, contexts: LineworkContexts, context_type, drawing_elements, target_view
-    ):
+        self,
+        ifc: ifcopenshell.file,
+        tree: ifcopenshell.geom.tree,
+        contexts: LineworkContexts,
+        context_type: str,
+        drawing_elements: set[ifcopenshell.entity_instance],
+        target_view: str,
+    ) -> None:
         drawing_elements = drawing_elements.copy()
         contexts = getattr(contexts, context_type)
         for context in contexts:
@@ -472,20 +493,24 @@ class CreateDrawing(bpy.types.Operator):
                     tree.add_element(elem)
                 drawing_elements -= processed
 
-    def generate_linework(self, context):
+    def generate_linework(self, context: bpy.types.Context) -> Union[str, None]:
         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
 
-        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")]
+        # 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]
 
         # If we have already calculated it in the SVG in the past, don't recalculate
         edited_guids = set()
@@ -506,6 +531,7 @@ class CreateDrawing(bpy.types.Operator):
 
         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")
 
@@ -518,8 +544,6 @@ class CreateDrawing(bpy.types.Operator):
             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)
 
@@ -1115,14 +1139,14 @@ class CreateDrawing(bpy.types.Operator):
                     continue
                 return space
 
-    def get_material_name(self, element):
+    def get_material_name(self, element: ifcopenshell.entity_instance) -> str:
         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=None):
+    def get_svg_path(self, cache_type: Optional[str] = None) -> str:
         drawing_path = tool.Drawing.get_document_uri(self.camera_document)
         drawings_dir = os.path.dirname(drawing_path)
 
@@ -1219,12 +1243,14 @@ class AddDrawingToSheet(bpy.types.Operator, Operator):
             return
 
         reference = tool.Ifc.run("document.add_reference", information=sheet)
-        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",
-        }
+        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",
+        )
         tool.Ifc.run("document.edit_reference", reference=reference, attributes=attributes)
         sheet_builder = sheeter.SheetBuilder()
         sheet_builder.data_dir = context.scene.BIMProperties.data_dir
@@ -1292,9 +1318,10 @@ class CreateSheets(bpy.types.Operator, Operator):
 
         has_sheet_reference = False
         for reference in tool.Drawing.get_document_references(sheet):
-            if reference.Description == "SHEET":
+            reference_description = tool.Drawing.get_reference_description(reference)
+            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:
@@ -1305,7 +1332,9 @@ class CreateSheets(bpy.types.Operator, Operator):
             tool.Ifc.run(
                 "document.edit_reference",
                 reference=reference,
-                attributes={"Location": tool.Ifc.get_relative_uri(svg), "Description": "SHEET"},
+                attributes=tool.Drawing.generate_reference_attributes(
+                    reference, Location=tool.Ifc.get_relative_uri(svg), Description="SHEET"
+                ),
             )
 
         for raster_reference in raster_references:
@@ -1313,7 +1342,9 @@ class CreateSheets(bpy.types.Operator, Operator):
             tool.Ifc.run(
                 "document.edit_reference",
                 reference=reference,
-                attributes={"Location": tool.Ifc.get_relative_uri(raster_reference), "Description": "RASTER"},
+                attributes=tool.Drawing.generate_reference_attributes(
+                    reference, Location=tool.Ifc.get_relative_uri(raster_reference), Description="RASTER"
+                ),
             )
 
         svg2pdf_command = context.preferences.addons["blenderbim"].preferences.svg2pdf_command
@@ -1422,13 +1453,19 @@ 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:
@@ -1446,6 +1483,11 @@ 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"}
 
@@ -1473,7 +1515,14 @@ class ActivateDrawing(bpy.types.Operator):
         if not self.camera_view_point:
             viewport_position = tool.Blender.get_viewport_position()
 
-        core.activate_drawing_view(tool.Ifc, tool.Drawing, drawing=drawing)
+        try:
+            core.activate_drawing_view(tool.Ifc, tool.Blender, tool.Drawing, drawing=drawing)
+        except core.CameraNotAvailableError:
+            self.report(
+                {"ERROR"},
+                "The drawing view is not available. Ensure you have not excluded it in the active view layer.",
+            )
+            return {"CANCELLED"}
 
         if not self.camera_view_point:
             tool.Blender.set_viewport_position(viewport_position)
@@ -1596,8 +1645,14 @@ class ReloadDrawingStyles(bpy.types.Operator):
 
         json_path = Path(tool.Ifc.resolve_uri(rel_path))
         if not json_path.exists():
-            self.report({"ERROR"}, "Shading styles file not found: {}".format(json_path))
-            return {"CANCELLED"}
+            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)
 
         with open(json_path, "r") as fi:
             shading_styles_json = json.load(fi)
@@ -1960,12 +2015,14 @@ class AddScheduleToSheet(bpy.types.Operator, Operator):
             return
 
         reference = tool.Ifc.run("document.add_reference", information=sheet)
-        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",
-        }
+        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",
+        )
         tool.Ifc.run("document.edit_reference", reference=reference, attributes=attributes)
 
         sheet_builder = sheeter.SheetBuilder()
@@ -2014,12 +2071,15 @@ class AddReferenceToSheet(bpy.types.Operator, Operator):
             return
 
         reference = tool.Ifc.run("document.add_reference", information=sheet)
-        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",
-        }
+        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",
+        )
         tool.Ifc.run("document.edit_reference", reference=reference, attributes=attributes)
 
         sheet_builder = sheeter.SheetBuilder()
@@ -2345,6 +2405,7 @@ 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))
@@ -2363,8 +2424,8 @@ class EditSheet(bpy.types.Operator, Operator):
         if sheet.is_a("IfcDocumentInformation"):
             self.document_type = "SHEET"
             self.name = sheet.Name
-            self.identification = sheet.Identification
-        elif sheet.is_a("IfcDocumentReference") and sheet.Description == "TITLEBLOCK":
+            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.document_type = "TITLEBLOCK"
         else:
             self.document_type = "EMBEDDED"
@@ -2390,7 +2451,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, reference=sheet, identification=self.identification)
+            core.rename_reference(tool.Ifc, tool.Drawing, reference=sheet, identification=self.identification)
         elif self.document_type == "TITLEBLOCK":
             titleblock = self.props.titleblock
             reference = sheet
@@ -2542,8 +2603,16 @@ class EnableEditingElementFilter(bpy.types.Operator, Operator):
 
     def _execute(self, context):
         obj = bpy.context.scene.camera
-        if obj:
-            obj.data.BIMCameraProperties.filter_mode = self.filter_mode
+        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
 
 
 class EditElementFilter(bpy.types.Operator, Operator):
@@ -2685,3 +2754,50 @@ 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"}

src/blenderbim/blenderbim/bim/module/drawing/prop.py

@@ -66,6 +66,11 @@ 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()
@@ -87,6 +92,11 @@ 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()
@@ -194,7 +204,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.active_object and context.active_object.data == self.id_data):
+    if self.has_underlay and (context.scene.camera and context.scene.camera.data == self.id_data):
         bpy.ops.bim.reload_drawing_styles()
         bpy.ops.bim.activate_drawing_style()
 
@@ -208,10 +218,12 @@ def update_has_annotation(self, context):
 
 
 def update_layer(self, context, name, value):
-    element = tool.Ifc.get_entity(context.active_object)
+    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
-    pset = ifcopenshell.util.element.get_psets(element).get("EPset_Drawing")
+    pset = ifcopenshell.util.element.get_pset(element, "EPset_Drawing")
     if pset:
         pset = tool.Ifc.get().by_id(pset["id"])
     else:
@@ -229,9 +241,8 @@ def update_titleblocks(self, context):
     SheetsData.data["titleblocks"] = SheetsData.titleblocks()
 
 
-def toggleDecorations(self, context):
-    toggle = self.should_draw_decorations
-    if toggle:
+def update_should_draw_decorations(self, context):
+    if self.should_draw_decorations:
         # TODO: design a proper text variable templating renderer
         collection = context.scene.camera.BIMObjectProperties.collection
         for obj in collection.objects:
@@ -343,7 +354,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=toggleDecorations)
+    should_draw_decorations: BoolProperty(name="Should Draw Decorations", update=update_should_draw_decorations)
     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(

src/blenderbim/blenderbim/bim/module/drawing/sheeter.py

@@ -41,7 +41,7 @@ class SheetBuilder:
         self.data_dir = None
         self.scale = "NTS"
 
-    def create(self, layout_path, titleblock_name):
+    def create(self, layout_path: str, titleblock_name: str) -> None:
         root = ET.Element("svg")
         root.attrib["xmlns"] = "http://www.w3.org/2000/svg"
         root.attrib["xmlns:xlink"] = "http://www.w3.org/1999/xlink"
@@ -76,7 +76,12 @@ class SheetBuilder:
         with open(layout_path, "w") as f:
             f.write(minidom.parseString(ET.tostring(root)).toprettyxml(indent="    "))
 
-    def add_drawing(self, reference, drawing, sheet):
+    def add_drawing(
+        self,
+        reference: ifcopenshell.entity_instance,
+        drawing: ifcopenshell.entity_instance,
+        sheet: ifcopenshell.entity_instance,
+    ) -> None:
         filename = drawing.Name
         layout_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
         layout_dir = os.path.dirname(layout_path)
@@ -131,7 +136,7 @@ class SheetBuilder:
         )
         layout_tree.write(layout_path)
 
-    def update_sheet_drawing_sizes(self, sheet):
+    def update_sheet_drawing_sizes(self, sheet: ifcopenshell.entity_instance) -> None:
         ET.register_namespace("", "http://www.w3.org/2000/svg")
 
         layout_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
@@ -171,7 +176,7 @@ class SheetBuilder:
 
         layout_tree.write(layout_path)
 
-    def remove_drawing(self, reference, sheet):
+    def remove_drawing(self, reference: ifcopenshell.entity_instance, sheet: ifcopenshell.entity_instance) -> None:
         ET.register_namespace("", "http://www.w3.org/2000/svg")
 
         layout_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
@@ -187,7 +192,12 @@ class SheetBuilder:
 
         layout_tree.write(layout_path)
 
-    def add_document(self, reference, document, sheet):
+    def add_document(
+        self,
+        reference: ifcopenshell.entity_instance,
+        document: ifcopenshell.entity_instance,
+        sheet: ifcopenshell.entity_instance,
+    ) -> None:
         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)
@@ -224,7 +234,7 @@ class SheetBuilder:
         )
         layout_tree.write(layout_path)
 
-    def add_view_title(self, x, y, parent, layout_dir):
+    def add_view_title(self, x: float, y: float, parent: ET.Element, layout_dir: str) -> None:
         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):
@@ -241,7 +251,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):
+    def build(self, sheet: ifcopenshell.entity_instance) -> dict:
         self.references = {"SHEET": None, "RASTER": []}
 
         layout_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
@@ -272,7 +282,7 @@ class SheetBuilder:
 
         return self.references
 
-    def build_titleblock(self, root, sheet):
+    def build_titleblock(self, root: ET.Element, sheet: ifcopenshell.entity_instance) -> None:
         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())
@@ -285,7 +295,7 @@ class SheetBuilder:
         titleblock.append(g)
         titleblock.remove(image)
 
-    def ensure_drawing_unique_styles(self, svg, drawing_id):
+    def ensure_drawing_unique_styles(self, svg: ET.Element, drawing_id: int) -> ET.Element:
         """ensures all drawing's classes and ids will be unique for the whole sheet
         by adding `drawing_id` based prefix
         """
@@ -313,7 +323,7 @@ class SheetBuilder:
                 brackets_level -= 1
             text += l
 
-        def replace_urls(text):
+        def replace_urls(text: str) -> str:
             """replace urls `url(#marker)` with `url(#prefix-marker)`
             since `url(#marker.prefix)` doesn't seem to work
             """
@@ -343,7 +353,7 @@ class SheetBuilder:
 
         return svg
 
-    def build_drawings(self, root, sheet):
+    def build_drawings(self, root: ET.Element, sheet: ifcopenshell.entity_instance):
         for view in root.findall('{http://www.w3.org/2000/svg}g[@data-type="drawing"]'):
             drawing_id = int(view.attrib["data-id"])
             try:
@@ -390,7 +400,7 @@ class SheetBuilder:
             for image in images:
                 view.remove(image)
 
-    def build_documents(self, root, sheet):
+    def build_documents(self, root: ET.Element, sheet: ifcopenshell.entity_instance) -> None:
         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
@@ -427,10 +437,10 @@ class SheetBuilder:
             for image in images:
                 view.remove(image)
 
-    def get_href(self, element):
-        return urllib.parse.unquote(element.attrib.get("{http://www.w3.org/1999/xlink}href")).replace('\\','/')
+    def get_href(self, element: ET.Element) -> str:
+        return urllib.parse.unquote(element.attrib.get("{http://www.w3.org/1999/xlink}href")).replace("\\", "/")
 
-    def parse_embedded_svg(self, image, data):
+    def parse_embedded_svg(self, image: ET.Element, data: dict) -> ET.Element:
         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"))
@@ -466,7 +476,7 @@ class SheetBuilder:
             group.append(child)
         return group
 
-    def change_titleblock(self, sheet, titleblock_name):
+    def change_titleblock(self, sheet: ifcopenshell.entity_instance, titleblock_name: str) -> None:
         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")
@@ -499,7 +509,7 @@ class SheetBuilder:
 
         sheet_tree.write(sheet_path)
 
-    def convert_to_mm(self, value):
+    def convert_to_mm(self, value: str) -> float:
         # 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
@@ -520,5 +530,5 @@ class SheetBuilder:
             return float(value[0:-2]) * (1 / 96) * 2.54 * 10
         return float(value)
 
-    def mm_to_px(self, value):
+    def mm_to_px(self, value: float) -> float:
         return (value / 25.4) * 96

src/blenderbim/blenderbim/bim/module/drawing/svgwriter.py

@@ -93,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"):
+        for resource in ("Stylesheet", "Markers", "Symbols", "Patterns", "ShadingStyles"):
             resource_path = pset.get(resource)
             if not resource_path:
                 self.resource_paths[resource] = None
@@ -719,14 +719,15 @@ 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):
+    def get_reference_and_sheet_id_from_annotation(self, element: ifcopenshell.entity_instance) -> tuple[str, str]:
         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"):
-                if sheet_reference.Description != "DRAWING" or sheet_reference.Location != reference.Location:
+                reference_description = tool.Drawing.get_reference_description(sheet_reference)
+                if reference_description != "DRAWING" or sheet_reference.Location != reference.Location:
                     continue
                 sheet = tool.Drawing.get_reference_document(sheet_reference)
                 if sheet:

src/blenderbim/blenderbim/bim/module/drawing/ui.py

@@ -268,6 +268,11 @@ 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)

src/blenderbim/blenderbim/bim/module/geometry/data.py

@@ -17,6 +17,7 @@
 # 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
@@ -222,7 +223,7 @@ class ConnectionsData:
     @classmethod
     def is_connection_realization(cls):
         element = tool.Ifc.get_entity(bpy.context.active_object)
-        connections = element.IsConnectionRealization
+        connections = getattr(element, "IsConnectionRealization", None)
         if not connections:
             return
 

src/blenderbim/blenderbim/bim/module/geometry/helper.py

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

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

@@ -136,19 +136,23 @@ class AddRepresentation(bpy.types.Operator, Operator):
                 "for Profile - 2D bounding box by local XZ axes.\n"
                 "For other contexts - bounding box is 3d.",
             ),
-            ("PROJECT", "Full Representation", ""),
+            ("OBJECT", "From Object", "Copies geometry from another object"),
+            ("PROJECT", "Full Representation", "Reuses the current representation"),
         ],
         name="Representation Conversion Method",
     )
 
     def _execute(self, context):
         obj = context.active_object
-        props = obj.BIMGeometryProperties
-        ifc_context = int(props.contexts or "0") or None
+        props = context.scene.BIMGeometryProperties
+        oprops = obj.BIMGeometryProperties
+        ifc_context = int(oprops.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")
@@ -165,17 +169,31 @@ 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)
 
-        core.add_representation(
-            tool.Ifc,
-            tool.Geometry,
-            tool.Style,
-            tool.Surveyor,
-            obj=obj,
-            context=ifc_context,
-            ifc_representation_class=None,
-            profile_set_usage=None,
-        )
+        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"}
 
     def invoke(self, context, event):
         return context.window_manager.invoke_props_dialog(self)
@@ -183,6 +201,9 @@ 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):
@@ -215,6 +236,13 @@ 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
@@ -223,6 +251,8 @@ 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:
@@ -324,8 +354,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(), product=element_type)
-                ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), product=product)
+                    ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), products=[element_type])
+                ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), products=[product])
             else:
                 # These objects are parametrically based on an axis and should not be modified as a mesh
                 return
@@ -538,6 +568,8 @@ 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())
 
@@ -562,6 +594,11 @@ 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):
@@ -843,7 +880,7 @@ class OverrideDuplicateMove(bpy.types.Operator):
 
         # Recreate decompositions
         tool.Root.recreate_decompositions(decomposition_relationships, old_to_new)
-        OverrideDuplicateMove.handle_linked_aggregates(old_to_new)
+        OverrideDuplicateMove.remove_linked_aggregate_data(old_to_new)
         blenderbim.bim.handler.refresh_ui_data()
         return old_to_new
 
@@ -896,25 +933,21 @@ class OverrideDuplicateMove(bpy.types.Operator):
                 if entity in old_to_new.keys():
                     core.remove_connection(tool.Geometry, connection=connection)
 
-    @staticmethod
-    def handle_linked_aggregates(old_to_new):
+    def remove_linked_aggregate_data(old_to_new):
         for old, new in old_to_new.items():
             pset = ifcopenshell.util.element.get_pset(new[0], "BBIM_Linked_Aggregate")
             if pset:
-                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},
-                        )
+                pset = tool.Ifc.get().by_id(pset["id"])
+                ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), 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]])
 
 
 class OverrideDuplicateMoveLinkedMacro(bpy.types.Macro):
@@ -940,6 +973,7 @@ class OverrideDuplicateMoveLinked(bpy.types.Operator):
 
 
 class DuplicateMoveLinkedAggregateMacro(bpy.types.Macro):
+    bl_description = "Create a new linked aggregate"
     bl_idname = "bim.object_duplicate_move_linked_aggregate_macro"
     bl_label = "IFC Duplicate Linked Aggregate"
     bl_options = {"REGISTER", "UNDO"}
@@ -974,15 +1008,15 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
             obj.select_set(True)
             parts = ifcopenshell.util.element.get_parts(element)
             if parts:
-                index = DuplicateMoveLinkedAggregate.get_max_index(parts)
+                index = get_max_index(parts)
                 add_linked_aggregate_pset(element, index)
                 index += 1
                 for part in parts:
                     if part.is_a("IfcElementAssembly"):
                         select_objects_and_add_data(part)
                     else:
-                        add_linked_aggregate_pset(part, index)
-                        index += 1
+                        index = add_linked_aggregate_pset(part, index)
+                        # index += 1
 
                     obj = tool.Ifc.get_object(part)
                     obj.select_set(True)
@@ -999,6 +1033,8 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
                     pset=pset,
                     properties={"Index": index},
                 )
+
+                index += 1
             else:
                 pass
 
@@ -1040,6 +1076,39 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
                         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)
+
         if len(context.selected_objects) != 1:
             return {"FINISHED"}
 
@@ -1060,27 +1129,16 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
 
         old_to_new = OverrideDuplicateMove.execute_ifc_duplicate_operator(self, context, linked=True)
 
-        custom_incremental_naming_for_element_assembly(old_to_new)
+        tool.Root.recreate_aggregate(old_to_new)
 
-        # Recreate aggregate relationship
-        for old in old_to_new.keys():
-            if old.is_a("IfcElementAssembly"):
-                tool.Root.recreate_aggregate(old_to_new)
+        copy_linked_aggregate_data(old_to_new)
+
+        custom_incremental_naming_for_element_assembly(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 RefreshLinkedAggregate(bpy.types.Operator):
     bl_idname = "bim.refresh_linked_aggregate"
@@ -1214,6 +1272,22 @@ 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.")
@@ -1253,10 +1327,7 @@ class RefreshLinkedAggregate(bpy.types.Operator):
 
                 element_aggregate = ifcopenshell.util.element.get_aggregate(element)
 
-                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()
+                selected_matrix, duplicate_matrix = get_original_matrix(element, base_instance)
 
                 original_names = get_original_names(element)
 
@@ -1268,12 +1339,8 @@ 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)
-                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
+
+                set_new_matrix(selected_matrix, duplicate_matrix, old_to_new)
 
                 for old, new in old_to_new.items():
                     if element_aggregate and new[0].is_a("IfcElementAssembly"):
@@ -1405,14 +1472,13 @@ class OverridePasteBuffer(bpy.types.Operator):
 
     def execute(self, context):
         bpy.ops.view3d.pastebuffer()
-        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)
+        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"}
 
 
@@ -1439,7 +1505,9 @@ class OverrideModeSetEdit(bpy.types.Operator):
         for obj in selected_objs:
             if not obj:
                 continue
-            if not obj.data:
+            obj_supports_edit_mode, message = tool.Blender.object_supports_edit_mode(obj)
+            if not obj_supports_edit_mode:
+                self.report({"INFO"}, message)
                 obj.select_set(False)
                 continue
             element = tool.Ifc.get_entity(obj)

src/blenderbim/blenderbim/bim/module/geometry/prop.py

@@ -138,3 +138,4 @@ class BIMGeometryProperties(PropertyGroup):
         name="IFC Interaction Mode",
         update=update_mode,
     )
+    representation_from_object: PointerProperty(type=bpy.types.Object)

src/blenderbim/blenderbim/bim/module/geometry/ui.py

@@ -212,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
-            row.prop(props, "representation_item_style", icon="SHADING_RENDERED", text="")
+            prop_with_search(row, 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:

src/blenderbim/blenderbim/bim/module/group/operator.py

@@ -212,7 +212,7 @@ class UnassignGroup(bpy.types.Operator, tool.Ifc.Operator):
                 "group.unassign_group",
                 self.file,
                 **{
-                    "product": self.file.by_id(product.BIMObjectProperties.ifc_definition_id),
+                    "products": [self.file.by_id(product.BIMObjectProperties.ifc_definition_id)],
                     "group": self.file.by_id(self.group),
                 }
             )

src/blenderbim/blenderbim/bim/module/layer/operator.py

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

src/blenderbim/blenderbim/bim/module/material/__init__.py

@@ -24,6 +24,7 @@ classes = (
     operator.AddLayer,
     operator.AddListItem,
     operator.AddMaterial,
+    operator.DuplicateMaterial,
     operator.AddMaterialSet,
     operator.AddProfile,
     operator.AssignMaterial,

src/blenderbim/blenderbim/bim/module/material/data.py

@@ -19,6 +19,7 @@
 import os
 import bpy
 import ifcopenshell
+import ifcopenshell.util.element
 import ifcopenshell.util.doc
 import ifcopenshell.util.schema
 import blenderbim.tool as tool
@@ -166,6 +167,9 @@ 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
@@ -294,8 +298,7 @@ class ObjectMaterialData:
 
     @classmethod
     def material_name(cls):
-        element = tool.Ifc.get_entity(bpy.context.active_object)
-        material = ifcopenshell.util.element.get_material(element)
+        material = cls.material
         if material:
             return getattr(material, "Name", None) or "Unnamed"
 
@@ -339,3 +342,18 @@ 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)

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

@@ -134,6 +134,19 @@ class AddMaterial(bpy.types.Operator, tool.Ifc.Operator):
         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):
+        ifc_file = tool.Ifc.get()
+        tool.Material.duplicate_material(ifc_file.by_id(self.material))
+        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"

src/blenderbim/blenderbim/bim/module/material/ui.py

@@ -61,6 +61,8 @@ 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")
@@ -175,7 +177,13 @@ class BIM_PT_object_material(Panel):
 
         if ObjectMaterialData.data["type_material"]:
             row = self.layout.row(align=True)
-            row.label(text="Inherited Material: " + ObjectMaterialData.data["type_material"], icon="FILE_PARENT")
+            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")
 
         if ObjectMaterialData.data["material_class"]:
             return self.draw_material_ui()

src/blenderbim/blenderbim/bim/module/model/array.py

@@ -83,8 +83,17 @@ 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
@@ -93,7 +102,9 @@ 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"}
 
 
@@ -137,6 +148,10 @@ 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"}
 
 

src/blenderbim/blenderbim/bim/module/model/covering.py

@@ -32,7 +32,9 @@ 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
-        return tool.Ifc.get_entity(collection_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"
 
     def _execute(self, context):
 
@@ -61,7 +63,9 @@ 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
-        return tool.Ifc.get_entity(collection_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"
 
     def _execute(self, context):
 
@@ -116,9 +120,11 @@ 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
+                return context.selected_objects and relating_type == "FLOORING"
 
     def _execute(self, context):
         # This only works based on a 2D plan only considering the standard
@@ -147,7 +153,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 Ceilings From Walls"
+    bl_label = "Add Ceiling 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"
 
@@ -155,9 +161,11 @@ 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
+                return context.selected_objects and relating_type == "CEILING"
 
     def _execute(self, context):
         # This only works based on a 2D plan only considering the standard

src/blenderbim/blenderbim/bim/module/model/mep.py

@@ -542,7 +542,7 @@ class MEPGenerator:
             ifc_representation_class=None,
         )
 
-        rel = ifcopenshell.api.run("material.assign_material", ifc_file, product=element, type="IfcMaterialProfileSet")
+        rel = ifcopenshell.api.run("material.assign_material", ifc_file, products=[element], type="IfcMaterialProfileSet")
         profile_set = rel.RelatingMaterial
         material_profile = ifcopenshell.api.run(
             "material.add_profile", ifc_file, profile_set=profile_set, material=material

src/blenderbim/blenderbim/bim/module/model/opening.py

@@ -24,10 +24,14 @@ import shapely
 import logging
 import numpy as np
 import ifcopenshell
+import ifcopenshell.api
+import ifcopenshell.geom
 import ifcopenshell.util.shape
 import ifcopenshell.util.element
 import ifcopenshell.util.shape_builder
+import ifcopenshell.util.placement
 import ifcopenshell.util.representation
+import ifcopenshell.util.unit
 import blenderbim.tool as tool
 import blenderbim.core.geometry
 import blenderbim.bim.import_ifc as import_ifc
@@ -107,7 +111,7 @@ class FilledOpeningGenerator:
                 # Equivalent to "side Z" for a wall axis, so that stuff like skylights appear on the top.
                 local_position_on_voided_obj.z = layers["offset"] + layers["thickness"]
                 new_matrix.translation.xyz = voided_obj.matrix_world @ local_position_on_voided_obj
-                rotation_matrix = Matrix.Rotation(radians(-90), 4, 'X')
+                rotation_matrix = Matrix.Rotation(radians(-90), 4, "X")
                 new_matrix @= rotation_matrix
 
             filling_obj.matrix_world = new_matrix
@@ -184,7 +188,13 @@ class FilledOpeningGenerator:
                 )
 
     def regenerate_from_type(self, usecase_path, ifc_file, settings):
-        filling = settings["related_object"]
+        relating_type = settings["relating_type"]
+
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object)
+
+    def _regenerate_from_type(self, related_object: ifcopenshell.entity_instance) -> None:
+        filling = related_object
         if not getattr(filling, "FillsVoids", None):
             return
 

src/blenderbim/blenderbim/bim/module/model/product.py

@@ -25,9 +25,13 @@ import ifcopenshell.util.system
 import ifcopenshell.util.element
 import ifcopenshell.util.placement
 import ifcopenshell.util.representation
+import ifcopenshell.util.type
+import ifcopenshell.util.unit
 import blenderbim.tool as tool
+import blenderbim.core.aggregate
 import blenderbim.core.type
 import blenderbim.core.geometry
+import blenderbim.core.spatial
 from . import wall, slab, profile, mep
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.model.data import AuthoringData
@@ -35,6 +39,7 @@ from mathutils import Vector, Matrix
 from bpy_extras.object_utils import AddObjectHelper
 from . import prop
 import json
+from typing import Any, Union
 
 
 class EnableAddType(bpy.types.Operator, tool.Ifc.Operator):
@@ -273,7 +278,7 @@ class AddConstrTypeInstance(bpy.types.Operator):
             obj.location[2] = collection_obj.location[2] + bpy.context.scene.BIMModelProperties.rl2
 
     @staticmethod
-    def generate_layered_element(ifc_class, relating_type):
+    def generate_layered_element(ifc_class: str, relating_type: ifcopenshell.entity_instance) -> bool:
         layer_set_direction = None
 
         parametric = ifcopenshell.util.element.get_psets(relating_type).get("EPset_Parametric")
@@ -297,6 +302,7 @@ class AddConstrTypeInstance(bpy.types.Operator):
             material = ifcopenshell.util.element.get_material(tool.Ifc.get_entity(obj))
             material.LayerSetDirection = layer_set_direction
             return True
+        return False
 
 
 class ChangeTypePage(bpy.types.Operator, tool.Ifc.Operator):
@@ -506,11 +512,11 @@ def regenerate_profile_usage(usecase_path, ifc_file, settings):
             )
 
 
-def ensure_material_assigned(usecase_path, ifc_file, settings):
+def ensure_material_assigned(usecase_path: str, ifc_file: ifcopenshell.file, settings: dict[str, Any]) -> None:
     if usecase_path == "material.assign_material":
         if not settings.get("material", None):
             return
-        elements = [settings["product"]]
+        elements = settings["products"]
     else:
         elements = []
         for rel in ifc_file.by_type("IfcRelAssociatesMaterial"):
@@ -519,53 +525,76 @@ def ensure_material_assigned(usecase_path, ifc_file, settings):
             ]:
                 elements.extend(rel.RelatedObjects)
 
-    for element in elements:
-        obj = IfcStore.get_element(element.GlobalId)
-        if not obj or not obj.data:
-            continue
-
-        element_material = ifcopenshell.util.element.get_material(element)
-        material = [m for m in ifc_file.traverse(element_material) if m.is_a("IfcMaterial")]
-
-        object_material_ids = [
-            om.BIMObjectProperties.ifc_definition_id
-            for om in obj.data.materials
-            if om is not None and om.BIMObjectProperties.ifc_definition_id
-        ]
-
-        if material and material[0].id() in object_material_ids:
-            continue
-
-        if len(obj.data.materials) == 1:
-            obj.data.materials.clear()
-
-        if not material:
-            continue
-
-        obj.data.materials.append(IfcStore.get_element(material[0].id()))
+    update_blender_ifc_materials(elements)
 
 
-def ensure_material_unassigned(usecase_path, ifc_file, settings):
-    elements = [settings["product"]]
+def ensure_material_unassigned(usecase_path: str, ifc_file: ifcopenshell.file, settings: dict[str, Any]) -> None:
+    elements = settings["products"]
     if elements[0].is_a("IfcElementType"):
         elements.extend(ifcopenshell.util.element.get_types(elements[0]))
+    update_blender_ifc_materials(elements)
+
+
+def update_blender_ifc_materials(elements: list[ifcopenshell.entity_instance]) -> None:
+    """update mesh blender materials that have ifc material connected to them
+    by replacing them with `blender_material`"""
+    # since different elements can share meshes (e.g. occurrecnes without openings)
+    # we need to make sure not to affect them accidentally
+    meshes_users: dict[bpy.types.Mesh, set[bpy.types.Object]] = dict()
+    for obj in bpy.data.objects:
+        if not obj.data:
+            continue
+        meshes_users.setdefault(obj.data, set()).add(obj)
+
+    objects: set[bpy.types.Object] = set()
     for element in elements:
-        obj = tool.Ifc.get_object(element)
+        obj: bpy.types.Object = tool.Ifc.get_object(element)
         if not obj or not obj.data:
             continue
-        element_material = ifcopenshell.util.element.get_material(element)
-        if element_material:
+        objects.add(obj)
+
+    meshes: set[bpy.types.Mesh] = {obj.data for obj in objects}
+
+    for mesh in meshes:
+        mesh_users = meshes_users[mesh]
+        if not mesh_users.issubset(objects):
             continue
-        to_remove = []
-        for i, slot in enumerate(obj.material_slots):
-            if not slot.material:
+
+        # NOTE: we need `obj` as removing materials and appending them to `mesh.materials`
+        # will mess up mesh faces material indices
+
+        # NOTE: we make an assumption here that all mesh users
+        # have the same material - they either inherit it from the type
+        # or type doesn't have a material.
+        #
+        # If we add option to UI to add materials overriding type materials
+        # then this assumption won't be safe anymore
+
+        obj = next(iter(mesh_users))
+        element = tool.Ifc.get_entity(obj)
+        current_material = ifcopenshell.util.element.get_material(element)
+        if current_material:
+            current_material = tool.Ifc.get_object(current_material)
+
+        material_replaced = False
+
+        for material_slot in obj.material_slots:
+            material = material_slot.material
+            if material is None:
                 continue
-            material = tool.Ifc.get_entity(slot.material)
-            if material:
-                to_remove.append(i)
-        total_removed = 0
-        for i in to_remove:
-            obj.active_material_index = i - total_removed
-            with bpy.context.temp_override(object=obj):
-                bpy.ops.object.material_slot_remove()
-            total_removed += 1
+            ifc_material = tool.Ifc.get_entity(material)
+            # it's blender material for style, so ignore it
+            if not ifc_material:
+                continue
+            if ifc_material == current_material:
+                continue
+            material_slot.material = current_material
+            material_replaced = True
+
+        if not material_replaced and current_material:
+            mesh.materials.append(current_material)
+
+        # clear empty slots
+        for i, material in reversed(list(enumerate(mesh.materials[:]))):
+            if material is None:
+                mesh.materials.pop(index=i)

src/blenderbim/blenderbim/bim/module/model/profile.py

@@ -21,14 +21,18 @@ import copy
 import bmesh
 import mathutils.geometry
 import ifcopenshell
+import ifcopenshell.api
 import ifcopenshell.util.type
 import ifcopenshell.util.unit
 import ifcopenshell.util.element
+import ifcopenshell.util.placement
+import ifcopenshell.util.representation
 import blenderbim.bim.handler
 import blenderbim.tool as tool
 import blenderbim.core.type
 import blenderbim.core.geometry
 import blenderbim.core.material
+import blenderbim.core.root
 from math import pi, degrees, inf
 from mathutils import Vector, Matrix, Quaternion
 from blenderbim.bim.module.geometry.helper import Helper
@@ -92,7 +96,7 @@ class DumbProfileGenerator:
             should_add_representation=False,
             context=self.body_context,
         )
-        ifcopenshell.api.run("type.assign_type", self.file, related_object=element, relating_type=self.relating_type)
+        ifcopenshell.api.run("type.assign_type", self.file, related_objects=[element], relating_type=self.relating_type)
 
         material = ifcopenshell.util.element.get_material(element)
         material.CardinalPoint = self.cardinal_point
@@ -207,12 +211,19 @@ class DumbProfileRegenerator:
         return results
 
     def regenerate_from_type(self, usecase_path, ifc_file, settings):
-        obj = tool.Ifc.get_object(settings["related_object"])
-        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
-            return
-        new_material = ifcopenshell.util.element.get_material(settings["relating_type"])
+        relating_type = settings["relating_type"]
+
+        new_material = ifcopenshell.util.element.get_material(relating_type)
         if not new_material or not new_material.is_a("IfcMaterialProfileSet"):
             return
+
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object)
+
+    def _regenerate_from_type(self, related_object: ifcopenshell.entity_instance) -> None:
+        obj = tool.Ifc.get_object(related_object)
+        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
+            return
         DumbProfileRecalculator().recalculate([obj])
 
 

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

@@ -87,6 +87,21 @@ def update_type_page(self, context):
     AuthoringData.data["paginated_relating_types"] = AuthoringData.paginated_relating_types()
 
 
+def update_relating_array_from_object(self, context):
+    bpy.ops.bim.enable_editing_array(item=self.is_editing)
+    return
+
+
+def is_object_array_applicable(self, obj):
+    element = tool.Ifc.get_entity(obj)
+    if not element:
+        return False
+    return ifcopenshell.util.element.get_pset(element, "BBIM_Array")
+
+
+
+
+
 class BIMModelProperties(PropertyGroup):
     ifc_class: bpy.props.EnumProperty(items=get_ifc_class, name="Construction Class", update=update_ifc_class)
     relating_type_id: bpy.props.EnumProperty(
@@ -203,6 +218,14 @@ class BIMArrayProperties(PropertyGroup):
         description="Regenerate all children based on the parent object",
         default=False,
     )
+    relating_array_object: bpy.props.PointerProperty(
+        type=bpy.types.Object,
+        name="Copy Array Properties",
+        update=update_relating_array_from_object,
+        poll=is_object_array_applicable,
+    )
+
+
 
 
 class BIMStairProperties(PropertyGroup):

src/blenderbim/blenderbim/bim/module/model/slab.py

@@ -29,11 +29,13 @@ import ifcopenshell.util.type
 import blenderbim.bim.handler
 import blenderbim.core.type
 import blenderbim.core.geometry
+import blenderbim.core.root
 import blenderbim.tool as tool
 from math import radians
 from mathutils import Vector, Matrix
 from blenderbim.bim.module.geometry.helper import Helper
 from blenderbim.bim.module.model.decorator import ProfileDecorator
+from typing import Optional
 
 
 def calculate_quantities(usecase_path, ifc_file, settings):
@@ -113,7 +115,7 @@ def calculate_quantities(usecase_path, ifc_file, settings):
 
 
 class DumbSlabGenerator:
-    def __init__(self, relating_type):
+    def __init__(self, relating_type: ifcopenshell.entity_instance):
         self.relating_type = relating_type
 
     def generate(self):
@@ -176,7 +178,7 @@ class DumbSlabGenerator:
             should_add_representation=False,
             context=self.body_context,
         )
-        ifcopenshell.api.run("type.assign_type", self.file, related_object=element, relating_type=self.relating_type)
+        ifcopenshell.api.run("type.assign_type", self.file, related_objects=[element], relating_type=self.relating_type)
 
         blenderbim.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
         representation = ifcopenshell.api.run(
@@ -249,27 +251,38 @@ class DumbSlabPlaner:
                             self.change_thickness(element, total_thickness)
 
     def regenerate_from_type(self, usecase_path, ifc_file, settings):
-        obj = tool.Ifc.get_object(settings["related_object"])
-        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
-            return
-        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
-        new_material = ifcopenshell.util.element.get_material(settings["relating_type"])
+        relating_type = settings["relating_type"]
+
+        new_material = ifcopenshell.util.element.get_material(relating_type)
         if not new_material or not new_material.is_a("IfcMaterialLayerSet"):
             return
+
         parametric = ifcopenshell.util.element.get_psets(settings["relating_type"]).get("EPset_Parametric")
         layer_set_direction = None
         if parametric:
             layer_set_direction = parametric.get("LayerSetDirection", layer_set_direction)
         new_thickness = sum([l.LayerThickness for l in new_material.MaterialLayers])
-        material = ifcopenshell.util.element.get_material(settings["related_object"])
+
+        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object, layer_set_direction, new_thickness)
+
+    def _regenerate_from_type(
+        self, related_object: ifcopenshell.entity_instance, layer_set_direction: Optional[str], new_thickness: float
+    ) -> None:
+        obj = tool.Ifc.get_object(related_object)
+        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
+            return
+
+        material = ifcopenshell.util.element.get_material(related_object)
         if not material or not material.is_a("IfcMaterialLayerSetUsage"):
             return
         if layer_set_direction:
             material.LayerSetDirection = layer_set_direction
         if material.LayerSetDirection == "AXIS3":
-            self.change_thickness(settings["related_object"], new_thickness)
+            self.change_thickness(related_object, new_thickness)
 
-    def change_thickness(self, element, thickness):
+    def change_thickness(self, element: ifcopenshell.entity_instance, thickness: float) -> None:
         body_context = ifcopenshell.util.representation.get_context(tool.Ifc.get(), "Model", "Body", "MODEL_VIEW")
         obj = tool.Ifc.get_object(element)
         if not obj:

src/blenderbim/blenderbim/bim/module/model/space.py

@@ -27,7 +27,7 @@ import blenderbim.core.type
 
 class GenerateSpace(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.generate_space"
-    bl_label = "Generate Space"
+    bl_label = "Generate Space from Cursor"
     bl_options = {"REGISTER"}
     bl_description = (
         "Create a space from the cursor position. "
@@ -35,30 +35,34 @@ class GenerateSpace(bpy.types.Operator, tool.Ifc.Operator):
         "select the right space collection and run the operator"
     )
 
-    @classmethod
-    def poll(cls, context):
-        collection = context.view_layer.active_layer_collection.collection
-        collection_obj = collection.BIMCollectionProperties.obj
-        active_obj = context.active_object
-        element = tool.Ifc.get_entity(active_obj)
-        return tool.Ifc.get_entity(collection_obj) and not element.is_a("IfcWall")
+#    @classmethod
+#    def poll(cls, context):
+#        print(context)
+#        collection = context.view_layer.active_layer_collection.collection
+#        collection_obj = collection.BIMCollectionProperties.obj
+#        active_obj = context.active_object
+#        element = tool.Ifc.get_entity(active_obj)
+#        return tool.Ifc.get_entity(collection_obj) and not element.is_a("IfcWall")
 
     def _execute(self, context):
         # This works as a 2.5 extruded polygon based on a cutting plane. Note
         # that rooms exclude walls (i.e. not to wall midpoint or exterior /
         # exterior edge.
 
-        def msg(self, context):
-            self.layout.label(text="NO ACTIVE STOREY")
+        def msg_no_collection(self, context):
+            self.layout.label(text="NO ACTIVE COLLECTION. PLEASE SELECT A SPATIAL COLLECTION OBJECT OR A WALL")
+
+        def msg_no_active_storey(self, context):
+            self.layout.label(text="NO ACTIVE STOREY. PLEASE SELECT A SPATIAL COLLECTION OBJECT")
 
         collection = context.view_layer.active_layer_collection.collection
         collection_obj = collection.BIMCollectionProperties.obj
         if not collection_obj:
-            context.window_manager.popup_menu(msg, title="Error", icon="ERROR")
+            context.window_manager.popup_menu(msg_no_collection, title="Error", icon="ERROR")
             return
         spatial_element = tool.Ifc.get_entity(collection_obj)
-        if not spatial_element:
-            context.window_manager.popup_menu(msg, title="Error", icon="ERROR")
+        if not spatial_element or not spatial_element.is_a("IfcBuildingStorey"):
+            context.window_manager.popup_menu(msg_no_active_storey, title="Error", icon="ERROR")
             return
 
         core.generate_space(tool.Ifc, tool.Spatial, tool.Model, tool.Type)
@@ -70,12 +74,12 @@ class GenerateSpacesFromWalls(bpy.types.Operator, tool.Ifc.Operator):
     bl_options = {"REGISTER", "UNDO"}
     bl_description = "Generate spaces from selected walls. The active object must be a wall"
 
-    @classmethod
-    def poll(cls, context):
-        active_obj = context.active_object
-        element = tool.Ifc.get_entity(active_obj)
-        if element:
-            return context.selected_objects and element.is_a("IfcWall")
+#    @classmethod
+#    def poll(cls, context):
+#        active_obj = context.active_object
+#        element = tool.Ifc.get_entity(active_obj)
+#        if element:
+#            return context.selected_objects and element.is_a("IfcWall")
 
     def _execute(self, context):
         # This only works based on a 2D plan only considering the standard
@@ -87,19 +91,30 @@ class GenerateSpacesFromWalls(bpy.types.Operator, tool.Ifc.Operator):
         element = tool.Ifc.get_entity(active_obj)
         container = tool.Spatial.get_container(element)
 
+        def msg_no_active_object(self, context):
+            self.layout.label(text="No active object. Please select a wall")
+        def msg_no_active_wall(self, context):
+            self.layout.label(text="The active object is not a wall. Please select a wall.")
+        def msg_no_container(self, context):
+            self.layout.label(text="The wall is not contained. Please the selected wall in a building container")
+        def msg_no_selected_objects(self, context):
+            self.layout.label(text="No selected objects found. Please select walls.")
+
         if not active_obj:
-            self.report({"ERROR"}, "No active object. Please select a wall")
+            context.window_manager.popup_menu(msg_no_active_object, title="Error", icon="ERROR")
             return
 
         element = tool.Ifc.get_entity(active_obj)
         if element and not element.is_a("IfcWall"):
-            return self.report({"ERROR"}, "The active object is not a wall. Please select a wall.")
+            context.window_manager.popup_menu(msg_no_active_wall, title="Error", icon="ERROR")
+            return
 
         if not container:
-            self.report({"ERROR"}, "The wall is not contained.")
+            context.window_manager.popup_menu(msg_no_container, title="Error", icon="ERROR")
+            return
 
         if not context.selected_objects:
-            self.report({"ERROR"}, "No selected objects found. Please select walls.")
+            context.window_manager.popup_menu(msg_no_selected_objects, title="Error", icon="ERROR")
             return
 
         core.generate_spaces_from_walls(tool.Ifc, tool.Spatial, tool.Collector)

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

@@ -54,6 +54,11 @@ class LaunchTypeManager(bpy.types.Operator):
         props.type_page = 1
         if get_ifc_class(None, context):
             ifc_class = props.ifc_class or AuthoringData.data["ifc_element_type"]
+        else:
+            ifc_class = AuthoringData.data["ifc_element_type"]
+
+        # will be None if project has no types
+        if ifc_class is not None:
             props.type_class = ifc_class
             bpy.ops.bim.load_type_thumbnails(ifc_class=ifc_class, offset=0, limit=9)
         return context.window_manager.invoke_popup(self, width=550)
@@ -218,6 +223,8 @@ class BIM_PT_array(bpy.types.Panel):
                     row = col.row(align=True)
                     row.prop(props, "z")
                     row.operator("bim.input_cursor_z_array", icon="CURSOR", text="")
+                    row = col.row(align=True)
+                    row.prop(props, "relating_array_object", icon="COPYDOWN")
                 else:
                     row = box.row(align=True)
                     name = f"{array['count']} Items ({array.get('method', 'OFFSET').capitalize()})"

src/blenderbim/blenderbim/bim/module/model/wall.py

@@ -24,7 +24,9 @@ import ifcopenshell
 import ifcopenshell.api
 import ifcopenshell.util.unit
 import ifcopenshell.util.element
+import ifcopenshell.util.placement
 import ifcopenshell.util.representation
+import ifcopenshell.util.type
 import mathutils.geometry
 import blenderbim.bim.handler
 import blenderbim.core.type
@@ -35,6 +37,7 @@ from blenderbim.bim.ifc import IfcStore
 from math import pi, sin, cos, degrees, radians
 from mathutils import Vector, Matrix
 from blenderbim.bim.module.model.opening import FilledOpeningGenerator
+from typing import Optional
 
 
 class JoinWall(bpy.types.Operator, tool.Ifc.Operator):
@@ -555,7 +558,10 @@ class DumbWallGenerator:
                 for face in sibling_obj.data.polygons:
                     normal = (sibling_obj.matrix_world.to_quaternion() @ face.normal).normalized()
                     face_center = sibling_obj.matrix_world @ face.center
-                    if normal.z != 0 or abs(mathutils.geometry.distance_point_to_plane(self.location, face_center, normal)) > 0.01:
+                    if (
+                        normal.z != 0
+                        or abs(mathutils.geometry.distance_point_to_plane(self.location, face_center, normal)) > 0.01
+                    ):
                         continue
 
                     rotation = math.atan2(normal[1], normal[0])
@@ -603,7 +609,7 @@ class DumbWallGenerator:
             should_add_representation=False,
             context=self.body_context,
         )
-        ifcopenshell.api.run("type.assign_type", self.file, related_object=element, relating_type=self.relating_type)
+        ifcopenshell.api.run("type.assign_type", self.file, related_objects=[element], relating_type=self.relating_type)
         if self.axis_context:
             representation = ifcopenshell.api.run(
                 "geometry.add_axis_representation",
@@ -724,18 +730,29 @@ class DumbWallPlaner:
         DumbWallRecalculator().recalculate([w for w in set(walls) if w])
 
     def regenerate_from_type(self, usecase_path, ifc_file, settings):
-        obj = tool.Ifc.get_object(settings["related_object"])
-        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
-            return
-        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
-        new_material = ifcopenshell.util.element.get_material(settings["relating_type"])
+        relating_type = settings["relating_type"]
+
+        new_material = ifcopenshell.util.element.get_material(relating_type)
         if not new_material or not new_material.is_a("IfcMaterialLayerSet"):
             return
-        parametric = ifcopenshell.util.element.get_psets(settings["relating_type"]).get("EPset_Parametric")
+
+        parametric = ifcopenshell.util.element.get_psets(relating_type).get("EPset_Parametric")
         layer_set_direction = None
         if parametric:
             layer_set_direction = parametric.get("LayerSetDirection", layer_set_direction)
-        material = ifcopenshell.util.element.get_material(settings["related_object"])
+
+        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
+        for related_object in settings["related_objects"]:
+            self._regenerate_from_type(related_object, layer_set_direction)
+
+    def _regenerate_from_type(
+        self, related_object: ifcopenshell.entity_instance, layer_set_direction: Optional[str]
+    ) -> None:
+        obj = tool.Ifc.get_object(related_object)
+        if not obj or not obj.data or not obj.data.BIMMeshProperties.ifc_definition_id:
+            return
+
+        material = ifcopenshell.util.element.get_material(related_object)
         if not material or not material.is_a("IfcMaterialLayerSetUsage"):
             return
         if layer_set_direction:
@@ -854,11 +871,11 @@ class DumbWallJoiner:
             if (location_on_base - location).length < (location_on_side - location).length:
                 axis_offset = location_on_side - location_on_base
                 offset_from_axis = location_on_base - location
-                opening_matrix.translation = (location_on_base - axis_offset - offset_from_axis)
+                opening_matrix.translation = location_on_base - axis_offset - offset_from_axis
             else:
                 axis_offset = location_on_side - location_on_base
                 offset_from_axis = location_on_side - location
-                opening_matrix.translation = (location_on_side - axis_offset - offset_from_axis)
+                opening_matrix.translation = location_on_side - axis_offset - offset_from_axis
             opening_matrixes[opening] = opening_matrix
 
             for filling in [r.RelatedBuildingElement for r in opening.HasFillings]:
@@ -871,11 +888,11 @@ class DumbWallJoiner:
                 if (location_on_base - location).length < (location_on_side - location).length:
                     axis_offset = location_on_side - location_on_base
                     offset_from_axis = location_on_base - location
-                    filling_matrix.translation = (location_on_base - axis_offset - offset_from_axis)
+                    filling_matrix.translation = location_on_base - axis_offset - offset_from_axis
                 else:
                     axis_offset = location_on_side - location_on_base
                     offset_from_axis = location_on_side - location
-                    filling_matrix.translation = (location_on_side - axis_offset - offset_from_axis)
+                    filling_matrix.translation = location_on_side - axis_offset - offset_from_axis
                 filling_matrixes[filling] = filling_matrix
 
         self.recreate_wall(element1, wall1, axis1["reference"], axis1["reference"])
@@ -1120,13 +1137,8 @@ class DumbWallJoiner:
                 other = tool.Ifc.get_object(rel.RelatedElement)
                 if connection not in ["ATPATH", "NOTDEFINED"]:
                     self.join(
-                        obj,
-                        other,
-                        connection,
-                        rel.RelatedConnectionType,
-                        is_relating=True,
-                        description=rel.Description
-                  )
+                        obj, other, connection, rel.RelatedConnectionType, is_relating=True, description=rel.Description
+                    )
         for rel in element.ConnectedFrom:
             if rel.is_a("IfcRelConnectsPathElements"):
                 connection = rel.RelatedConnectionType

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

@@ -378,6 +378,7 @@ class BimToolUI:
             op.depth = cls.props.extrusion_depth
 
             add_layout_hotkey_operator(cls.layout, "Extend", "S_E", "")
+            add_layout_hotkey_operator(cls.layout, "Flip", "S_F", bpy.ops.bim.flip_object.__doc__)
 
             if AuthoringData.data["active_class"] in (
                 "IfcCableCarrierSegment",
@@ -385,8 +386,8 @@ class BimToolUI:
                 "IfcDuctSegment",
                 "IfcPipeSegment",
             ):
-                add_layout_hotkey_operator(cls.layout, "Add Fitting", "S_F", "")
 
+                add_layout_hotkey_operator(cls.layout, "Add Fitting", "S_Y", "")
                 if context.region.type != "TOOL_HEADER":
                     cls.layout.operator("bim.mep_add_bend")
                     cls.layout.operator("bim.mep_add_transition")
@@ -394,7 +395,6 @@ class BimToolUI:
 
             else:
                 add_layout_hotkey_operator(cls.layout, "Edit Axis", "A_E", "")
-                add_layout_hotkey_operator(cls.layout, "Flip", "S_F", bpy.ops.bim.flip_object.__doc__)
                 add_layout_hotkey_operator(cls.layout, "Butt", "S_T", "")
                 add_layout_hotkey_operator(cls.layout, "Mitre", "S_Y", "")
                 add_layout_hotkey_operator(cls.layout, "Rotate 90", "S_R", bpy.ops.bim.rotate_90.__doc__)
@@ -522,11 +522,12 @@ class BimToolUI:
                 row.label(text=f"No {AuthoringData.data['ifc_element_type']} Found", icon="ERROR")
                 row = cls.layout.row()
                 row.prop(cls.props, "type_name")
-                row = cls.layout.row()
+                row = cls.layout.row(align=True)
                 op = row.operator(
                     "bim.add_default_type", icon="ADD", text=f"Add {AuthoringData.data['ifc_element_type']}"
                 )
                 op.ifc_element_type = AuthoringData.data["ifc_element_type"]
+                row.operator("bim.launch_type_manager", icon=tool.Blender.TYPE_MANAGER_ICON, text="")
             else:
                 row.label(text="No Element Types Found", icon="ERROR")
                 row.operator("bim.launch_type_manager", icon=tool.Blender.TYPE_MANAGER_ICON, text="Launch Type Manager")
@@ -718,10 +719,9 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
             bpy.ops.bim.flip_wall()
         elif self.active_class in ("IfcWindow", "IfcWindowStandardCase", "IfcDoor", "IfcDoorStandardCase"):
             bpy.ops.bim.flip_fill()
-        elif self.active_class in ("IfcBeam", "IfcColumn"):
+        elif self.active_material_usage == "PROFILE":
             bpy.ops.bim.flip_object(flip_local_axes="XZ")
-        elif self.active_class in ("IfcDuctSegment", "IfcPipeSegment", "IfcCableCarrierSegment", "IfcCableSegment"):
-            bpy.ops.bim.fit_flow_segments()
+
 
     def hotkey_S_G(self):
         obj = bpy.context.active_object
@@ -807,9 +807,12 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
             return
         if self.active_material_usage == "LAYER2":
             bpy.ops.bim.join_wall(join_type="V")
+        elif self.active_class in ("IfcDuctSegment", "IfcPipeSegment", "IfcCableCarrierSegment", "IfcCableSegment"):
+            bpy.ops.bim.fit_flow_segments()
         elif self.active_material_usage == "PROFILE":
             bpy.ops.bim.extend_profile(join_type="V")
 
+
     def hotkey_S_B(self):
         bpy.ops.bim.add_boundary()
 

src/blenderbim/blenderbim/bim/module/profile/__init__.py

@@ -21,6 +21,7 @@ from . import ui, prop, operator, data
 
 classes = (
     operator.AddProfileDef,
+    operator.DuplicateProfileDef,
     operator.DisableEditingArbitraryProfile,
     operator.DisableEditingProfile,
     operator.DisableProfileEditingUI,

src/blenderbim/blenderbim/bim/module/profile/operator.py

@@ -66,9 +66,15 @@ class RemoveProfileDef(bpy.types.Operator, tool.Ifc.Operator):
     profile: bpy.props.IntProperty()
 
     def _execute(self, context):
+        props = context.scene.BIMProfileProperties
+        current_index = props.active_profile_index
         ifcopenshell.api.run("profile.remove_profile", tool.Ifc.get(), profile=tool.Ifc.get().by_id(self.profile))
         bpy.ops.bim.load_profiles()
 
+        # preserve selected index if possible
+        if props.profiles:
+            props.active_profile_index = min(current_index, len(props.profiles) - 1)
+
 
 class EnableEditingProfile(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.enable_editing_profile"
@@ -126,6 +132,27 @@ class AddProfileDef(bpy.types.Operator, tool.Ifc.Operator):
         bpy.ops.bim.load_profiles()
 
 
+class DuplicateProfileDef(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.duplicate_profile_def"
+    bl_label = "Duplicate Profile"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        props = context.scene.BIMProfileProperties
+        if len(props.profiles) > props.active_profile_index:
+            return True
+        cls.poll_message_set("No profile selected to duplicate.")
+        return False
+
+    def _execute(self, context):
+        props = context.scene.BIMProfileProperties
+        ifc_file = tool.Ifc.get()
+        profile = ifc_file.by_id(props.profiles[props.active_profile_index].ifc_definition_id)
+        tool.Profile.duplicate_profile(profile)
+        bpy.ops.bim.load_profiles()
+
+
 class EnableEditingArbitraryProfile(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.enable_editing_arbitrary_profile"
     bl_label = "Enable Editing Arbitrary Profile"

src/blenderbim/blenderbim/bim/module/profile/ui.py

@@ -70,6 +70,7 @@ class BIM_PT_profiles(Panel):
         row = self.layout.row(align=True)
         row.prop(self.props, "profile_classes", text="")
         row.operator("bim.add_profile_def", text="", icon="ADD")
+        row.operator("bim.duplicate_profile_def", icon="DUPLICATE", text="")
 
         self.layout.template_list(
             "BIM_UL_profiles",

src/blenderbim/blenderbim/bim/module/project/__init__.py

@@ -25,6 +25,8 @@ classes = (
     operator.AppendLibraryElement,
     operator.AppendLibraryElementByQuery,
     operator.AssignLibraryDeclaration,
+    operator.BIM_OT_load_clipping_planes,
+    operator.BIM_OT_save_clipping_planes,
     operator.ChangeLibraryElement,
     operator.CreateClippingPlane,
     operator.CreateProject,

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

@@ -21,6 +21,7 @@ import bpy
 import time
 import logging
 import tempfile
+import traceback
 import subprocess
 import numpy as np
 import ifcopenshell
@@ -39,12 +40,15 @@ from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.ui import IFCFileSelector
 from blenderbim.bim import import_ifc
 from blenderbim.bim import export_ifc
+from collections import defaultdict
+import json
 from math import radians
 from pathlib import Path
 from mathutils import Vector, Matrix
 from bpy.app.handlers import persistent
 from blenderbim.bim.module.project.data import LinksData
 from blenderbim.bim.module.project.decorator import ProjectDecorator, ClippingPlaneDecorator
+from typing import Union
 
 
 class NewProject(bpy.types.Operator):
@@ -299,7 +303,7 @@ class AssignLibraryDeclaration(bpy.types.Operator):
         ifcopenshell.api.run(
             "project.assign_declaration",
             self.file,
-            definition=self.file.by_id(self.definition),
+            definitions=[self.file.by_id(self.definition)],
             relating_context=self.file.by_type("IfcProjectLibrary")[0],
         )
         element_name = self.props.active_library_element
@@ -335,7 +339,7 @@ class UnassignLibraryDeclaration(bpy.types.Operator):
         ifcopenshell.api.run(
             "project.unassign_declaration",
             self.file,
-            definition=self.file.by_id(self.definition),
+            definitions=[self.file.by_id(self.definition)],
             relating_context=self.file.by_type("IfcProjectLibrary")[0],
         )
         element_name = self.props.active_library_element
@@ -671,19 +675,23 @@ class LoadProject(bpy.types.Operator, IFCFileSelector):
             return self.finish_loading_project(context)
 
     def finish_loading_project(self, context):
-        if not self.is_existing_ifc_file():
-            return {"FINISHED"}
+        try:
+            if not self.is_existing_ifc_file():
+                return {"FINISHED"}
 
-        if tool.Blender.is_default_scene():
-            for obj in bpy.data.objects:
-                bpy.data.objects.remove(obj)
+            if tool.Blender.is_default_scene():
+                for obj in bpy.data.objects:
+                    bpy.data.objects.remove(obj)
 
-        context.scene.BIMProperties.ifc_file = self.get_filepath()
-        context.scene.BIMProjectProperties.is_loading = True
-        context.scene.BIMProjectProperties.total_elements = len(tool.Ifc.get().by_type("IfcElement"))
-        tool.Blender.register_toolbar()
-        if not self.is_advanced:
-            bpy.ops.bim.load_project_elements()
+            context.scene.BIMProperties.ifc_file = self.get_filepath()
+            context.scene.BIMProjectProperties.is_loading = True
+            context.scene.BIMProjectProperties.total_elements = len(tool.Ifc.get().by_type("IfcElement"))
+            tool.Blender.register_toolbar()
+            if not self.is_advanced:
+                bpy.ops.bim.load_project_elements()
+        except:
+            blenderbim.last_error = traceback.format_exc()
+            raise
         return {"FINISHED"}
 
     def invoke(self, context, event):
@@ -865,7 +873,16 @@ class LinkIfc(bpy.types.Operator):
                 except:
                     pass  # Perhaps on another drive or something
             new.name = filepath
-            bpy.ops.bim.load_link(filepath=filepath, false_origin=self.false_origin)
+            status = bpy.ops.bim.load_link(filepath=filepath, false_origin=self.false_origin)
+            if status == {"CANCELLED"}:
+                error_msg = (
+                    f'Error processing IFC file "{self.filepath}" '
+                    "was critical and blend file either wasn't saved or wasn't updated. "
+                    "See logs above in system console for details."
+                )
+                print(error_msg)
+                self.report({"ERROR"}, error_msg)
+                return {"FINISHED"}
         print(f"Finished linking {len(files)} IFCs", time.time() - start)
         return {"FINISHED"}
 
@@ -944,10 +961,12 @@ class LoadLink(bpy.types.Operator):
         if self.filepath.lower().endswith(".blend"):
             self.link_blend(filepath)
         elif self.filepath.lower().endswith(".ifc"):
-            self.link_ifc()
+            status = self.link_ifc()
+            if status:
+                return status
         return {"FINISHED"}
 
-    def link_blend(self, filepath):
+    def link_blend(self, filepath: str) -> None:
         with bpy.data.libraries.load(filepath, link=True) as (data_from, data_to):
             data_to.scenes = data_from.scenes
         for scene in bpy.data.scenes:
@@ -960,7 +979,7 @@ class LoadLink(bpy.types.Operator):
         link = bpy.context.scene.BIMProjectProperties.links.get(self.filepath)
         link.is_loaded = True
 
-    def link_ifc(self):
+    def link_ifc(self) -> Union[set[str], None]:
         blend_filepath = self.filepath + ".cache.blend"
         h5_filepath = self.filepath + ".cache.h5"
 
@@ -980,11 +999,14 @@ except Exception as e:
     exit(1)
             """
 
+            t = time.time()
             with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
                 temp_file.write(code)
             run = subprocess.run([bpy.app.binary_path, "-b", "--python", temp_file.name, "--python-exit-code", "1"])
             if run.returncode == 1:
                 print("An error occurred while processing your IFC.")
+                if not os.path.exists(blend_filepath) or os.stat(blend_filepath).st_mtime < t:
+                    return {"CANCELLED"}
 
         self.link_blend(blend_filepath)
 
@@ -1294,6 +1316,8 @@ class LoadLinkedProject(bpy.types.Operator):
                     if len(shape.geometry.faces) > 1000 and self.is_local(shape):  # 333 tris
                         self.process_occurrence(shape)
                         if not iterator.next():
+                            if not chunked_verts:
+                                break
                             mats = np.concatenate(chunked_materials)
                             midx = np.concatenate(chunked_material_ids)
                             mats, mapping = np.unique(mats, axis=0, return_inverse=True)
@@ -1329,6 +1353,9 @@ class LoadLinkedProject(bpy.types.Operator):
 
                     ms = np.vstack([default_mat, np.frombuffer(shape.geometry.colors_buffer).reshape((-1, 4))])
                     mi = np.frombuffer(shape.geometry.material_ids_buffer, dtype=np.int32)
+                    for geom_material_idx, geom_material in enumerate(shape.geometry.materials):
+                        if not geom_material.has_diffuse:
+                            ms[geom_material_idx + 1] = (0.8, 0.8, 0.8, 1)
                     chunked_materials.append(ms)
                     chunked_material_ids.append(mi + material_offset + 1)
                     material_offset += len(ms)
@@ -1449,7 +1476,10 @@ class LoadLinkedProject(bpy.types.Operator):
                 alpha = 1.0
                 if material.has_transparency and material.transparency > 0:
                     alpha = 1.0 - material.transparency
-                diffuse = material.diffuse + (alpha,)
+                if material.has_diffuse:
+                    diffuse = material.diffuse + (alpha,)
+                else:
+                    diffuse = (0.8, 0.8, 0.8, 1)  # Blender's default material
                 material_name = f"{diffuse[0]}-{diffuse[1]}-{diffuse[2]}-{diffuse[3]}"
                 blender_mat = self.blender_mats.get(material_name, None)
                 if not blender_mat:
@@ -1912,32 +1942,32 @@ class CreateClippingPlane(bpy.types.Operator):
     bl_label = "Create Clipping Plane"
     bl_options = {"REGISTER", "UNDO"}
 
-    @classmethod
-    def poll(cls, context):
-        return context.area.type == "VIEW_3D"
-
     def execute(self, context):
         from bpy_extras.view3d_utils import region_2d_to_vector_3d, region_2d_to_origin_3d
 
         # Clean up deleted planes
 
-        if len(bpy.context.scene.BIMProjectProperties.clipping_planes) > 5:
+        if len(context.scene.BIMProjectProperties.clipping_planes) > 5:
             self.report({"INFO"}, "Maximum of six clipping planes allowed.")
             return {"FINISHED"}
 
-        for area in bpy.context.screen.areas:
+        for area in context.screen.areas:
             if area.type == "VIEW_3D":
                 area.tag_redraw()
 
         region = context.region
         rv3d = context.region_data
-        coord = (self.mouse_x, self.mouse_y)
-        origin = region_2d_to_origin_3d(region, rv3d, coord)
-        direction = region_2d_to_vector_3d(region, rv3d, coord)
-        hit, location, normal, face_index, obj, matrix = self.ray_cast(context, origin, direction)
-        if not hit:
-            self.report({"INFO"}, "No object found.")
-            return {"FINISHED"}
+        if rv3d:  # Called from a 3D viewport
+            coord = (self.mouse_x, self.mouse_y)
+            origin = region_2d_to_origin_3d(region, rv3d, coord)
+            direction = region_2d_to_vector_3d(region, rv3d, coord)
+            hit, location, normal, face_index, obj, matrix = self.ray_cast(context, origin, direction)
+            if not hit:
+                self.report({"INFO"}, "No object found.")
+                return {"FINISHED"}
+        else:  # Not Called from a 3D viewport
+            location = (0, 0, 1)
+            normal = (0, 0, 1)
 
         vertices = [(-0.5, -0.5, 0), (0.5, -0.5, 0), (0.5, 0.5, 0), (-0.5, 0.5, 0)]
 
@@ -1948,20 +1978,20 @@ class CreateClippingPlane(bpy.types.Operator):
         mesh.update()
 
         plane_obj = bpy.data.objects.new("ClippingPlane", mesh)
-        bpy.context.collection.objects.link(plane_obj)
+        context.collection.objects.link(plane_obj)
         z_axis = Vector((0, 0, 1))
         rotation_matrix = z_axis.rotation_difference(normal).to_matrix().to_4x4()
         plane_obj.matrix_world = rotation_matrix
         plane_obj.matrix_world.translation = location
 
-        bpy.context.scene.cursor.location = location
+        context.scene.cursor.location = location
 
-        new = bpy.context.scene.BIMProjectProperties.clipping_planes.add()
+        new = context.scene.BIMProjectProperties.clipping_planes.add()
         new.obj = plane_obj
 
         tool.Blender.set_active_object(plane_obj)
 
-        ClippingPlaneDecorator.install(bpy.context)
+        ClippingPlaneDecorator.install(context)
         bpy.ops.bim.refresh_clipping_planes("INVOKE_DEFAULT")
         return {"FINISHED"}
 
@@ -1983,11 +2013,69 @@ class FlipClippingPlane(bpy.types.Operator):
 
     @classmethod
     def poll(cls, context):
-        return context.area.type == "VIEW_3D"
+        return context.active_object
 
     def execute(self, context):
-        obj = bpy.context.active_object
-        if obj in [cp.obj for cp in bpy.context.scene.BIMProjectProperties.clipping_planes]:
+        obj = context.active_object
+        if obj in context.scene.BIMProjectProperties.clipping_planes_objs:
             obj.rotation_euler[0] += radians(180)
-            bpy.context.view_layer.update()
+            context.view_layer.update()
+        return {"FINISHED"}
+
+
+CLIPPING_PLANES_FILE_NAME = "ClippingPlanes.json"  # TODO un-hardcode :=
+
+
+class BIM_OT_save_clipping_planes(bpy.types.Operator):
+    bl_idname = "bim.save_clipping_planes"
+    bl_label = "Save Clipping Planes"
+    bl_description = "Save Clipping Planes to Disk"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if IfcStore.path:
+            return context.scene.BIMProjectProperties.clipping_planes
+        cls.poll_message_set("Please Save The IFC File")
+
+    def execute(self, context):
+        clipping_planes_to_serialize = defaultdict(dict)
+        clipping_planes = context.scene.BIMProjectProperties.clipping_planes
+        for clipping_plane in clipping_planes:
+            obj = clipping_plane.obj
+            name = obj.name
+            clipping_planes_to_serialize[name]["location"] = obj.location[0:3]
+            clipping_planes_to_serialize[name]["rotation"] = obj.rotation_euler[0:3]
+        with open(Path(IfcStore.path).with_name(CLIPPING_PLANES_FILE_NAME), "w") as file:
+            json.dump(clipping_planes_to_serialize, file, indent=4)
+        return {"FINISHED"}
+
+
+class BIM_OT_load_clipping_planes(bpy.types.Operator):
+    bl_idname = "bim.load_clipping_planes"
+    bl_label = "Load Clipping Planes"
+    bl_description = "Load Clipping Planes from Disk"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if filepath := IfcStore.path:
+            if Path(filepath).with_name(CLIPPING_PLANES_FILE_NAME).exists():
+                return True
+            else:
+                cls.poll_message_set(f"No Clipping Planes File in Folder {filepath}")
+        else:
+            cls.poll_message_set("Please Save The IFC File")
+
+    def execute(self, context):
+        bpy.data.batch_remove(context.scene.BIMProjectProperties.clipping_planes_objs)
+        context.scene.BIMProjectProperties.clipping_planes.clear()
+        with open(Path(IfcStore.path).with_name(CLIPPING_PLANES_FILE_NAME), "r") as file:
+            clipping_planes_dict = json.load(file)
+        for name, values in clipping_planes_dict.items():
+            bpy.ops.bim.create_clipping_plane()
+            obj = context.scene.BIMProjectProperties.clipping_planes_objs[-1]
+            obj.name = name
+            obj.location = values["location"]
+            obj.rotation_euler = values["rotation"]
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/project/prop.py

@@ -187,6 +187,11 @@ class BIMProjectProperties(PropertyGroup):
     use_relative_project_path: BoolProperty(name="Use Relative Project Path", default=False)
     queried_obj: bpy.props.PointerProperty(type=bpy.types.Object)
     clipping_planes: bpy.props.CollectionProperty(type=ObjProperty)
+    clipping_planes_active: bpy.props.IntProperty(min=0, default=0, max=5)
+
+    @property
+    def clipping_planes_objs(self):
+        return list({cp.obj for cp in self.clipping_planes if cp.obj})
 
     def get_library_element_index(self, lib_element):
         return next((i for i in range(len(self.library_elements)) if self.library_elements[i] == lib_element))

src/blenderbim/blenderbim/bim/module/pset/data.py

@@ -69,6 +69,7 @@ class ObjectPsetsData(Data):
     @classmethod
     def load(cls):
         cls.data = {
+            "is_occurrence": cls.is_occurrence(),
             "psets": cls.psetqtos(tool.Ifc.get_entity(bpy.context.active_object), psets_only=True),
             "inherited_psets": cls.inherited_psets(),
             "pset_name": cls.pset_name(),
@@ -76,6 +77,10 @@ class ObjectPsetsData(Data):
         }
         cls.is_loaded = True
 
+    @classmethod
+    def is_occurrence(cls):
+        return not tool.Ifc.get_entity(bpy.context.active_object).is_a("IfcTypeObject")
+
     @classmethod
     def inherited_psets(cls):
         element = tool.Ifc.get_entity(bpy.context.active_object)
@@ -126,11 +131,16 @@ class ObjectQtosData(Data):
     @classmethod
     def load(cls):
         cls.data = {
+            "is_occurrence": cls.is_occurrence(),
             "qtos": cls.psetqtos(tool.Ifc.get_entity(bpy.context.active_object), qtos_only=True),
             "inherited_qsets": cls.inherited_qsets(),
         }
         cls.is_loaded = True
 
+    @classmethod
+    def is_occurrence(cls):
+        return not tool.Ifc.get_entity(bpy.context.active_object).is_a("IfcTypeObject")
+
     @classmethod
     def inherited_qsets(cls):
         element = tool.Ifc.get_entity(bpy.context.active_object)

src/blenderbim/blenderbim/bim/module/pset/qto_calculator.py

@@ -246,43 +246,56 @@ class QtoCalculator:
             return self.get_net_side_area(obj)
 
     def get_finish_ceiling_height(self, obj: bpy.types.Object) -> float:
-        space_height = self.get_height(obj)
         floor_height = self.get_finish_floor_height(obj)
         ceiling_height = self.get_ceiling_height(obj)
-        finish_ceiling_height = space_height - floor_height - ceiling_height
+        finish_ceiling_height = ceiling_height - floor_height
         return finish_ceiling_height
 
+    def get_max_global_z(self, obj: bpy.types.Object) -> float:
+        z_values = [(obj.matrix_world @ Vector(co))[2] for co in obj.bound_box]
+        return max(z_values)
+
+    def get_min_global_z(self, obj: bpy.types.Object) -> float:
+        z_values = [(obj.matrix_world @ Vector(co))[2] for co in obj.bound_box]
+        return min(z_values)
+
     def get_finish_floor_height(self, obj: bpy.types.Object) -> float:
+        space_min_z_value = self.get_min_global_z(obj)
+        space_max_z_value = self.get_max_global_z(obj)
+
         element = tool.Ifc.get_entity(obj)
         decompositions = ifcopenshell.util.element.get_decomposition(element)
-        finish_floor_height = 0
+        flooring_max_z_value = space_min_z_value
         for decomposition in decompositions:
             if (
-                decomposition.get_info()["PredefinedType"] == "FLOORING"
-                and decomposition.get_info()["type"] == "IfcCovering"
+                decomposition.is_a() == "IfcCovering"
+                and ifcopenshell.util.element.get_predefined_type(decomposition) == "FLOORING"
             ):
-                floor_obj = tool.Ifc.get_object(decomposition)
-                new_finish_floor_height = self.get_height(floor_obj)
-                if new_finish_floor_height > finish_floor_height:
-                    finish_floor_height = new_finish_floor_height
+                flooring_obj = tool.Ifc.get_object(decomposition)
+                flooring_z_value = self.get_max_global_z(flooring_obj)
+                if flooring_z_value > space_min_z_value:
+                    flooring_max_z_value = flooring_z_value
 
-        return finish_floor_height
+        return flooring_max_z_value - space_min_z_value
 
     def get_ceiling_height(self, obj: bpy.types.Object) -> float:
+        space_min_z_value = self.get_min_global_z(obj)
+        space_max_z_value = self.get_max_global_z(obj)
+
         element = tool.Ifc.get_entity(obj)
         decompositions = ifcopenshell.util.element.get_decomposition(element)
-        finish_ceiling_height = 0
+        ceiling_min_z_value = space_max_z_value
         for decomposition in decompositions:
             if (
-                decomposition.get_info()["PredefinedType"] == "CEILING"
-                and decomposition.get_info()["type"] == "IfcCovering"
+                decomposition.is_a() == "IfcCovering"
+                and ifcopenshell.util.element.get_predefined_type(decomposition) == "CEILING"
             ):
                 ceiling_obj = tool.Ifc.get_object(decomposition)
-                new_finish_ceiling_height = self.get_height(ceiling_obj)
-                if new_finish_ceiling_height > finish_ceiling_height:
-                    finish_ceiling_height = new_finish_ceiling_height
+                ceiling_z_value = self.get_min_global_z(ceiling_obj)
+                if ceiling_z_value < space_max_z_value:
+                    ceiling_min_z_value = ceiling_z_value
 
-        return finish_ceiling_height
+        return ceiling_min_z_value - space_min_z_value
 
     def get_net_perimeter(self, o: bpy.types.Object) -> float:
         parsed_edges = []
@@ -377,9 +390,9 @@ class QtoCalculator:
         total_gross_ceiling_area = 0
 
         for decomposition in decompositions:
-            decomposition_type = decomposition.get_info()["type"]
-            decomposition_predefined_type = decomposition.get_info()["PredefinedType"]
-            if decomposition_type == "IfcCovering" and decomposition_predefined_type == "CEILING":
+            decomposition_class = decomposition.is_a()
+            decomposition_predefined_type = ifcopenshell.util.element.get_predefined_type(decomposition)
+            if decomposition_class == "IfcCovering" and decomposition_predefined_type == "CEILING":
                 decomposition_obj = tool.Ifc.get_object(decomposition)
                 total_gross_ceiling_area += self.get_gross_footprint_area(decomposition_obj)
 
@@ -393,13 +406,13 @@ class QtoCalculator:
         total_net_ceiling_area = 0
 
         for decomposition in decompositions:
-            decomposition_type = decomposition.get_info()["type"]
-            decomposition_predefined_type = decomposition.get_info()["PredefinedType"]
-            if decomposition_type == "IfcCovering" and decomposition_predefined_type == "CEILING":
+            decomposition_class = decomposition.is_a()
+            decomposition_predefined_type = ifcopenshell.util.element.get_predefined_type(decomposition)
+            if decomposition_class == "IfcCovering" and decomposition_predefined_type == "CEILING":
                 decomposition_obj = tool.Ifc.get_object(decomposition)
                 total_net_ceiling_area += self.get_net_footprint_area(decomposition_obj)
 
-            if decomposition_type == "IfcWall" or decomposition_type == "IfcColumn":
+            if decomposition_class == "IfcWall" or decomposition_class == "IfcColumn":
                 decomposition_obj = tool.Ifc.get_object(decomposition)
                 total_net_ceiling_area -= self.get_net_roofprint_area(decomposition_obj)
 

src/blenderbim/blenderbim/bim/module/pset/ui.py

@@ -90,7 +90,7 @@ def get_active_pset_obj_name(context, obj_type):
     return ""
 
 
-def draw_psetqto_ui(context, pset_id, pset, props, layout, obj_type):
+def draw_psetqto_ui(context, pset_id, pset, props, layout, obj_type, allow_removing=True):
     box = layout.box()
     row = box.row(align=True)
     if "is_expanded" not in pset:
@@ -114,16 +114,20 @@ def draw_psetqto_ui(context, pset_id, pset, props, layout, obj_type):
         op.pset_id = pset_id
         op.obj = obj_name
         op.obj_type = obj_type
-        op = row.operator("bim.remove_pset", icon="X", text="")
+        remove_pset_row = row.row(align=True)
+        op = remove_pset_row.operator("bim.remove_pset", icon="X", text="")
         op.pset_id = pset_id
         op.obj = obj_name
         op.obj_type = obj_type
+        remove_pset_row.enabled = allow_removing
     elif props.active_pset_id != pset_id:
         row.label(text=pset["Name"], icon="COPY_ID")
-        op = row.operator("bim.remove_pset", icon="X", text="")
+        remove_pset_row = row.row(align=True)
+        op = remove_pset_row.operator("bim.remove_pset", icon="X", text="")
         op.pset_id = pset_id
         op.obj = obj_name
         op.obj_type = obj_type
+        remove_pset_row.enabled = allow_removing
     if pset["is_expanded"]:
         if props.active_pset_id == pset_id:
             for prop in props.properties:
@@ -204,14 +208,17 @@ class BIM_PT_object_psets(Panel):
             draw_psetqto_ui(context, 0, {}, props, self.layout, "Object")
 
         if ObjectPsetsData.data["psets"]:
-            self.layout.label(text="Instance:")
+            if ObjectPsetsData.data["is_occurrence"]:
+                self.layout.label(text="Occurrence Properties:")
+            else:
+                self.layout.label(text="Type Properties:")
             for pset in ObjectPsetsData.data["psets"]:
                 draw_psetqto_ui(context, pset["id"], pset, props, self.layout, "Object")
 
         if ObjectPsetsData.data["inherited_psets"]:
-            self.layout.label(text="Type:")
+            self.layout.label(text="Inherited Type Properties:", icon="CON_CHILDOF")
             for pset in ObjectPsetsData.data["inherited_psets"]:
-                draw_psetqto_ui(context, pset["id"], pset, props, self.layout, "Object")
+                draw_psetqto_ui(context, pset["id"], pset, props, self.layout, "Object", allow_removing=False)
 
 
 class BIM_PT_object_qtos(Panel):
@@ -246,16 +253,19 @@ class BIM_PT_object_qtos(Panel):
 
         if not props.active_pset_id and props.active_pset_name and props.active_pset_type == "QTO":
             draw_psetqto_ui(context, 0, {}, props, self.layout, "Object")
-        
+
         if ObjectQtosData.data["qtos"]:
-            self.layout.label(text="Instance:")
+            if ObjectQtosData.data["is_occurrence"]:
+                self.layout.label(text="Occurrence Quantities:")
+            else:
+                self.layout.label(text="Type Quantities:")
             for qto in ObjectQtosData.data["qtos"]:
                 draw_psetqto_ui(context, qto["id"], qto, props, self.layout, "Object")
 
         if ObjectQtosData.data["inherited_qsets"]:
-            self.layout.label(text="Type:")
+            self.layout.label(text="Inherited Type Quantities:", icon="CON_CHILDOF")
             for qset in ObjectQtosData.data["inherited_qsets"]:
-                draw_psetqto_ui(context, qset["id"], qset, props, self.layout, "Object")
+                draw_psetqto_ui(context, qset["id"], qset, props, self.layout, "Object", allow_removing=False)
 
 
 class BIM_PT_material_psets(Panel):

src/blenderbim/blenderbim/bim/module/pset_template/operator.py

@@ -268,7 +268,6 @@ class RemovePropTemplate(bpy.types.Operator, Operator):
     prop_template: bpy.props.IntProperty()
 
     def _execute(self, context):
-        props = context.scene.BIMPsetTemplateProperties
         ifcopenshell.api.run(
             "pset_template.remove_prop_template",
             IfcStore.pset_template_file,
@@ -287,21 +286,21 @@ class EditPropTemplate(bpy.types.Operator, Operator):
     def _execute(self, context):
         props = context.scene.BIMPsetTemplateProperties
         if props.active_prop_template.template_type == "P_ENUMERATEDVALUE":
-            enumerator = self.generate_prop_enum(props)
+            data_type = props.active_prop_template.get_value_name()
+            prop = props.active_prop_template
+            enumerators = [getattr(ev, data_type) for ev in prop.enum_values]
         else:
-            enumerator = None
+            enumerators = None
         ifcopenshell.api.run(
             "pset_template.edit_prop_template",
             IfcStore.pset_template_file,
-            **{
-                "prop_template": IfcStore.pset_template_file.by_id(props.active_prop_template_id),
-                "attributes": {
-                    "Name": props.active_prop_template.name,
-                    "Description": props.active_prop_template.description,
-                    "PrimaryMeasureType": props.active_prop_template.primary_measure_type,
-                    "TemplateType": props.active_prop_template.template_type,
-                    "Enumerators": enumerator,
-                },
+            prop_template=IfcStore.pset_template_file.by_id(props.active_prop_template_id),
+            attributes={
+                "Name": props.active_prop_template.name,
+                "Description": props.active_prop_template.description,
+                "PrimaryMeasureType": props.active_prop_template.primary_measure_type,
+                "TemplateType": props.active_prop_template.template_type,
+                "Enumerators": enumerators,
             }
         )
         bpy.ops.bim.disable_editing_prop_template()
@@ -309,18 +308,3 @@ class EditPropTemplate(bpy.types.Operator, Operator):
         blenderbim.bim.handler.refresh_ui_data()
         if tool.Ifc.get():
             blenderbim.bim.schema.reload(tool.Ifc.get().schema)
-
-    # TODO -This will need to go into the
-    # api code at some point - vulevukusej
-    def generate_prop_enum(self, props):
-        self.file = IfcStore.pset_template_file
-        data_type = props.active_prop_template.get_value_name()
-        prop = props.active_prop_template
-        prop_enum = self.file.create_entity(
-            "IFCPROPERTYENUMERATION",
-            Name=prop.name,
-            EnumerationValues=tuple(
-                self.file.create_entity(prop.primary_measure_type, getattr(ev, data_type)) for ev in prop.enum_values
-            ),
-        )
-        return prop_enum

src/blenderbim/blenderbim/bim/module/root/data.py

@@ -42,6 +42,7 @@ class IfcClassData:
         cls.data["contexts"] = cls.contexts()
         cls.data["has_entity"] = cls.has_entity()
         cls.data["name"] = cls.name()
+        cls.data["has_inherited_predefined_type"] = cls.has_inherited_predefined_type()
         cls.data["ifc_class"] = cls.ifc_class()
         cls.data["ifc_predefined_types"] = cls.ifc_predefined_types()
         cls.data["can_reassign_class"] = cls.can_reassign_class()
@@ -162,6 +163,16 @@ class IfcClassData:
             name += f"[{predefined_type}]"
         return name
 
+    @classmethod
+    def has_inherited_predefined_type(cls):
+        element = tool.Ifc.get_entity(bpy.context.view_layer.objects.active)
+        if not element:
+            return
+        if element_type := ifcopenshell.util.element.get_type(element):
+            # Allow for None due to https://github.com/buildingSMART/IFC4.3.x-development/issues/818
+            return ifcopenshell.util.element.get_predefined_type(element_type) not in ("NOTDEFINED", None)
+        return False
+
     @classmethod
     def ifc_class(cls):
         element = tool.Ifc.get_entity(bpy.context.view_layer.objects.active)
@@ -174,6 +185,8 @@ class IfcClassData:
         if element:
             if element.is_a("IfcOpeningElement") or element.is_a("IfcOpeningStandardCase"):
                 return False
+            if element.is_a() in ("IfcWindowStyle", "IfcDoorStyle"): #see https://github.com/IfcOpenShell/IfcOpenShell/issues/4622#issuecomment-2095676368
+                return True
             for product in cls.ifc_products():
                 if element.is_a(product[0]):
                     return True

src/blenderbim/blenderbim/bim/module/root/ui.py

@@ -61,7 +61,10 @@ class BIM_PT_class(Panel):
                 self.layout.prop(context.scene.BIMRootProperties, "relating_class_object", icon="COPYDOWN")
             else:
                 row = self.layout.row(align=True)
-                row.label(text=IfcClassData.data["name"])
+                row.label(
+                    text=IfcClassData.data["name"],
+                    icon="CON_CHILDOF" if IfcClassData.data["has_inherited_predefined_type"] else "NONE",
+                )
                 row.operator("bim.select_ifc_class", text="", icon="RESTRICT_SELECT_OFF")
                 row.operator("bim.unlink_object", icon="UNLINKED", text="")
                 if IfcClassData.data["can_reassign_class"]:

src/blenderbim/blenderbim/bim/module/search/__init__.py

@@ -24,21 +24,15 @@ classes = (
     operator.ActivateIfcClassFilter,
     operator.AddFilter,
     operator.AddFilterGroup,
-    operator.AddToIfcGroup,
     operator.ColourByProperty,
     operator.EditFilterQuery,
-    operator.FilterModelElements,
-    operator.IfcSelector,
     operator.LoadColourscheme,
-    operator.LoadQuery,
     operator.LoadSearch,
-    operator.OpenQueryLibrary,
     operator.RemoveFilter,
     operator.RemoveFilterGroup,
     operator.ResetObjectColours,
     operator.SaveColourscheme,
     operator.SaveSearch,
-    operator.SaveSelectorQuery,
     operator.Search,
     operator.SelectByProperty,
     operator.SelectFilterElements,
@@ -51,11 +45,6 @@ classes = (
     prop.BIMFilterClasses,
     prop.BIMFilterBuildingStoreys,
     prop.BIMSearchProperties,
-    prop.SearchCollection,
-    prop.SearchQueryFilter,
-    prop.SearchQuery,
-    prop.SearchQueryGroup,
-    prop.IfcSelectorProperties,
     ui.BIM_PT_search,
     ui.BIM_PT_filter,
     ui.BIM_PT_colour_by_property,
@@ -63,15 +52,12 @@ classes = (
     ui.BIM_UL_colourscheme,
     ui.BIM_UL_ifc_class_filter,
     ui.BIM_UL_ifc_building_storey_filter,
-    ui.BIM_PT_IFCSelector,
 )
 
 
 def register():
     bpy.types.Scene.BIMSearchProperties = bpy.props.PointerProperty(type=prop.BIMSearchProperties)
-    bpy.types.Scene.IfcSelectorProperties = bpy.props.PointerProperty(type=prop.IfcSelectorProperties)
 
 
 def unregister():
     del bpy.types.Scene.BIMSearchProperties
-    del bpy.types.Scene.IfcSelectorProperties

src/blenderbim/blenderbim/bim/module/search/operator.py

@@ -20,6 +20,7 @@ import re
 import bpy
 import json
 import ifcopenshell
+import ifcopenshell.guid
 import ifcopenshell.util.element
 import ifcopenshell.util.selector
 from ifcopenshell.util.selector import Selector
@@ -235,7 +236,7 @@ class LoadSearch(Operator, tool.Ifc.Operator):
     def _execute(self, context):
         filter_groups = tool.Search.get_filter_groups(self.module)
         group = tool.Ifc.get().by_id(int(context.scene.BIMSearchProperties.saved_searches))
-        query = tool.Search.import_filter_query(tool.Search.get_group_query(group), filter_groups)
+        tool.Search.import_filter_query(tool.Search.get_group_query(group), filter_groups)
 
     def draw(self, context):
         props = context.scene.BIMSearchProperties
@@ -271,25 +272,29 @@ class ColourByProperty(Operator):
         colourscheme = {}
 
         if len(props.colourscheme):
-            colourscheme = {cs.name: cs.colour[0:3] for cs in props.colourscheme}
+            colourscheme = {cs.name: {"colour": cs.colour[0:3], "total": 0} for cs in props.colourscheme}
 
         for obj in context.visible_objects:
             element = tool.Ifc.get_entity(obj)
             if not element:
                 continue
             value = str(ifcopenshell.util.selector.get_element_value(element, query))
-            if value not in colourscheme:
-                colourscheme[value] = next(colours)[0:3]
-            obj.color = (*colourscheme[value], 1)
+            if value in colourscheme:
+                colourscheme[value]["total"] += 1
+            else:
+                colourscheme[value] = {"colour": next(colours)[0:3], "total": 1}
+            obj.color = (*colourscheme[value]["colour"], 1)
         areas = [a for a in context.screen.areas if a.type == "VIEW_3D"]
         if areas:
             areas[0].spaces[0].shading.color_type = "OBJECT"
 
         props.colourscheme.clear()
-        for value, colour in colourscheme.items():
+        for value in sorted(colourscheme.keys()):
+            data = colourscheme[value]
             new = props.colourscheme.add()
             new.name = str(value)
-            new.colour = colour[0:3]
+            new.total = data["total"]
+            new.colour = data["colour"][0:3]
         return {"FINISHED"}
 
     def store_state(self, context):
@@ -351,16 +356,16 @@ class SaveColourscheme(Operator, tool.Ifc.Operator):
         query = props.colourscheme_query
 
         group = [g for g in tool.Ifc.get().by_type("IfcGroup") if g.Name == self.name]
-        coulour_scheme = {cs.name: cs.colour[0:3] for cs in props.colourscheme}
+        colourscheme = {cs.name: {"colour": cs.colour[0:3], "total": cs.total} for cs in props.colourscheme}
         if group:
             group = group[0]
             description = json.loads(group.Description)
-            description["colourscheme"] = coulour_scheme
+            description["colourscheme"] = colourscheme
             description["colourscheme_query"] = query
             group.Description = json.dumps(description)
         else:
             description = json.dumps(
-                {"type": "BBIM_Search", "colourscheme": coulour_scheme, "colourscheme_query": query}
+                {"type": "BBIM_Search", "colourscheme": colourscheme, "colourscheme_query": query}
             )
             group = ifcopenshell.api.run("group.add_group", tool.Ifc.get(), Name=self.name, Description=description)
 
@@ -380,10 +385,11 @@ class LoadColourscheme(Operator, tool.Ifc.Operator):
         description = json.loads(group.Description)
         props.colourscheme_query = description.get("colourscheme_query")
         props.colourscheme.clear()
-        for name, colour in description.get("colourscheme", {}).items():
+        for name, data in description.get("colourscheme", {}).items():
             new = props.colourscheme.add()
             new.name = name
-            new.colour = colour
+            new.total = data["total"]
+            new.colour = data["colour"]
 
     def draw(self, context):
         props = context.scene.BIMSearchProperties
@@ -623,223 +629,6 @@ class ShowAllElements(Operator):
         return {"FINISHED"}
 
 
-class FilterModelElements(Operator):
-    """Filter model elements based on selection"""
-
-    bl_idname = "bim.filter_model_elements"
-    bl_label = "Filter Model Elements"
-    option: StringProperty("select|isolate|hide")
-
-    def execute(self, context):
-        selection_props = context.scene.IfcSelectorProperties
-        selection = (
-            selection_props.selector_query_syntax
-            if selection_props.manual_override
-            else self.add_groups(selection_props)
-        )
-        selection_props.selector_query_syntax = selection
-        r = core.search(tool.Search, tool.Spatial, query=selection, action=self.option)
-        if isinstance(r, str):
-            self.report({"WARNING"}, r)
-        return {"FINISHED"}
-
-    def add_groups(self, selector: str) -> str:
-        selection = ""
-        for group_index, group in enumerate(selector.groups):
-            if group_index != 0:
-                selection += " | "
-            selection += "(" if len(selector.groups) > 1 else ""
-            selection = self.add_queries(selection, group)
-
-            selection += ")" if len(selector.groups) > 1 else ""
-        return selection
-
-    def add_queries(self, selection: str, group: str) -> str:
-        for query_index, query in enumerate(group.queries):
-            if query_index != 0:
-                selection += " & " if query.and_or == "and" else " | "
-
-            if query.selector == "IFC Class":
-                active_option = query.active_option.split(": ")[1]
-                selection += f".{active_option}"
-                selection = self.add_filters(selection, query)
-
-            elif query.selector == "GlobalId":
-                selection += f"#{query.value}"
-
-            elif query.selector == "IfcElementType":
-                index = int(query.active_sub_option.split(":")[0])
-                selection += f"* #{query.sub_options[index].global_id}"
-
-            elif query.selector == "IfcSpatialElement":
-                index = int(query.active_sub_option.split(":")[0])
-                selection += f"@ #{query.sub_options[index].global_id}"
-        return selection
-
-    def add_filters(self, selection: str, query: str) -> str:
-        for f_index, f in enumerate(query.filters):
-            if f_index != 0:
-                selection += " & " if f.and_or == "and" else " | "
-                selection += f".{query.active_option}"
-
-            if f.value in ("True", "False"):
-                value = f.value
-            elif f.value.isnumeric() and str(float(f.value))[0] == f.value[0]:
-                value = f.value
-            else:
-                value = f'"{f.value}"'
-
-            selection += "["
-
-            if f.selector == "IfcPropertySet":
-                selection += f'{f.active_option.split(": ")[1]}.{f.active_sub_option.split(": ")[1]} {"!" if f.negation else ""}{f.comparison} {value}'
-            elif f.selector == "Attribute":
-                # we're using the prop_search functionality in blender which returns the index of the option.  Sometimes the user can override this and enter a value that doesn't exist in the list.  In this case there is no index and we need to handle it. @vulevukusej
-                pattern = re.compile(r"^[0-9]+:")
-                match = pattern.search(f.active_option)
-                selection += f'{f.active_option.split(": ")[1] if match else f.active_option} {"!" if f.negation else ""}{f.comparison} {value}'
-            selection += "]"
-        return selection
-
-
-# This needs to be moved into ui code, I know ;) - vulevukusej
-class IfcSelector(Operator):
-    """Select elements in model with IFC Selector"""
-
-    bl_idname = "bim.ifc_selector"
-    bl_label = "Select elements with IFC Selector"
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self, width=800)
-
-    @classmethod
-    def poll(cls, context):
-        return IfcStore.get_file()
-
-    def execute(self, context):
-        return {"FINISHED"}
-
-    def draw(self, context):
-        from . import ui
-
-        ui.IfcSelectorUI.draw(context, self.layout)
-
-
-class SaveSelectorQuery(Operator):
-    bl_idname = "bim.save_selector_query"
-    bl_label = "Save Selector Query"
-    save_name: StringProperty()
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_props_dialog(self, width=400)
-
-    def draw(self, context):
-        layout = self.layout
-        layout.prop(self, "save_name")
-
-    def execute(self, context):
-        ifc_selector = context.scene.IfcSelectorProperties
-        new = ifc_selector.query_library.add()
-        new.name = self.save_name
-        new.query = ifc_selector.selector_query_syntax
-        return {"FINISHED"}
-
-
-class OpenQueryLibrary(Operator):
-    """Open Query Library"""
-
-    bl_idname = "bim.open_query_library"
-    bl_label = "Open Query Library"
-
-    def invoke(self, context, event):
-        return context.window_manager.invoke_popup(self, width=400)
-
-    def draw(self, context):
-        layout = self.layout
-        ifc_selector = context.scene.IfcSelectorProperties
-
-        for index, query in enumerate(ifc_selector.query_library):
-            row = layout.row(align=True)
-            row.prop(query, "query", text=query.name)
-            op = row.operator("bim.load_query", icon="SORT_ASC", text="")
-            op.index = index
-
-            row.context_pointer_set(name="bim_prop_group", data=ifc_selector)
-            op = row.operator("bim.edit_blender_collection", icon="REMOVE", text="")
-            op.option = "remove"
-            op.collection = "query_library"
-            op.index = index
-
-    def execute(self, context):
-        return {"FINISHED"}
-
-
-class LoadQuery(Operator):
-    bl_idname = "bim.load_query"
-    bl_label = "Load Query"
-    index: IntProperty()
-
-    def invoke(self, context, event):
-        close_operator_panel(event)
-        return self.execute(context)
-
-    def execute(self, context):
-        ifc_selector = context.scene.IfcSelectorProperties
-        ifc_selector.selector_query_syntax = ifc_selector.query_library[self.index].query
-        return {"FINISHED"}
-
-
-class AddToIfcGroup(Operator):
-    bl_idname = "bim.add_to_ifc_group"
-    bl_label = "Add to IFC Group"
-    group_name: StringProperty(name="Group Name")
-
-    def invoke(self, context, event):
-        bpy.ops.bim.load_groups()
-        return context.window_manager.invoke_props_dialog(self, width=400)
-
-    def draw(self, context):
-        self.props = context.scene.BIMGroupProperties
-        row = self.layout.row()
-        row.operator("bim.add_group")
-
-        self.layout.template_list(
-            "BIM_UL_groups",
-            "",
-            self.props,
-            "groups",
-            self.props,
-            "active_group_index",
-        )
-
-        if self.props.active_group_id:
-            for attribute in self.props.group_attributes:
-                if attribute.name in ["Name", "Description"]:
-                    row = self.layout.row(align=True)
-                    row.prop(attribute, "string_value", text=attribute.name)
-
-    def execute(self, context):
-        active_group_index = self.props.active_group_index
-        ifc_definition_id = self.props.groups[active_group_index].ifc_definition_id
-
-        bpy.ops.bim.enable_editing_group(group=ifc_definition_id)
-
-        selector_query_syntax = context.scene.IfcSelectorProperties.selector_query_syntax
-
-        for attribute in self.props.group_attributes:
-            if attribute.name == "Description":
-                if "*selector*" not in attribute.string_value:
-                    attribute.string_value += f" *selector*{selector_query_syntax}*selector*"
-                else:
-                    new_description = attribute.string_value.split("*selector*")
-                    new_description[1] = selector_query_syntax
-                    attribute.string_value = "*selector*".join(new_description)
-
-        bpy.ops.bim.edit_group()
-        bpy.ops.bim.disable_group_editing_ui()
-        return {"FINISHED"}
-
-
 class SelectSimilar(Operator, tool.Ifc.Operator):
     bl_idname = "bim.select_similar"
     bl_label = "Select Similar"

src/blenderbim/blenderbim/bim/module/search/prop.py

@@ -78,7 +78,7 @@ def update_is_container_selected(self, context):
     else:
         for obj in context.selected_objects:
             container = tool.Spatial.get_container(tool.Ifc.get_entity(obj))
-            if (container and container.Name == self.name) or (not container and self.name== "None"):
+            if (container and container.Name == self.name) or (not container and self.name == "None"):
                 obj.select_set(False)
                 new = self.unselected_objects.add()
                 new.obj = obj
@@ -100,6 +100,7 @@ class BIMFilterBuildingStoreys(PropertyGroup):
 
 class BIMColour(PropertyGroup):
     name: StringProperty(name="Name")
+    total: IntProperty(name="Total")
     colour: FloatVectorProperty(name="Colour", subtype="COLOR", default=(1, 0, 0), min=0.0, max=1.0)
 
 
@@ -138,139 +139,3 @@ def get_classes(self, ifc_product):
     declarations = util.schema.get_subtypes(declaration)
     names = [d.name() for d in declarations]
     return [(c, c, "") for c in sorted(names)]
-
-
-def load_sub_options(self, context):
-    if self.selector not in ["IfcClass"]:
-        self.load_option = "sub_options"
-        load_selection_options(self, context)
-
-
-def load_selection_options(self, context):
-    ifc = IfcStore.file
-    load_option = self.load_option
-    op = getattr(self, load_option)
-    op.clear()
-    options = []
-
-    if load_option == "options":
-        self.sub_options.clear()
-        if self.selector == "IFC Class":
-            options = get_classes(self, "IfcElement")
-            options.append(("IfcSpace", "IfcSpace", ""))
-        elif self.selector == "IfcSpatialElement":
-            options = get_classes(self, "IfcSpatialElement")
-        elif self.selector == "IfcElementType":
-            options = get_classes(self, "IfcElementType")
-        elif self.selector == "GlobalId":
-            return
-        elif self.selector == "IfcPropertySet":
-            psets = Selector.parse(ifc, ".IfcPropertySet")
-            options = set([o.Name for o in psets])
-        elif self.selector == "Attribute":
-            attributes = ["GlobalId", "Name", "Description", "ObjectType", "Tag", "PredefinedType"]
-            for a in attributes:
-                options.append((a, a, ""))
-
-    elif load_option == "sub_options":
-        if self.selector in ["IfcSpatialElement", "IfcElementType"]:
-            active_option = self.active_option.split(": ")[1]
-            options = Selector.parse(ifc, f".{active_option}")
-
-        elif self.selector == "IfcPropertySet":
-            options = set()
-            active_pset = self.active_option.split(": ")[1]
-            psets_in_file = Selector.parse(ifc, f'.IfcPropertySet[Name="{active_pset}"]')
-            for pset in psets_in_file:
-                for prop in pset.HasProperties:
-                    options.add(prop.Name)
-
-    for index, option in enumerate(options):
-        new = op.add()
-        if self.selector in ["IfcSpatialElement", "IfcElementType"]:
-            if self.load_option == "sub_options":
-                new.name = f"{index}: {option.Name}"
-                new.global_id = option.GlobalId
-            else:
-                new.name = f"{index}: {option[0]}"
-        elif self.selector == "IfcPropertySet":
-            new.name = f"{index}: {option}"
-        else:
-            new.name = f"{index}: {option[0]}"
-    self.load_option = "options"
-
-
-def load_spatial_elements(self, context):
-    ifc = IfcStore.file
-    col_items = Selector.parse(ifc, f".{self.selected_spatial_element}")
-    collection = getattr(self, "sub_spatial_elements", None)
-    collection.clear()
-    for index, c in enumerate(col_items):
-        new = collection.add()
-        new.name = f"{index}-{c.Name}"
-
-
-class SearchCollection(PropertyGroup):
-    name: StringProperty()
-    long_name: StringProperty()
-    global_id: StringProperty()
-    query: StringProperty()
-
-
-class IfcSelector:
-    and_or: EnumProperty(
-        items=[(i, i, i) for i in ["and", "or"]],
-    )
-    negation: BoolProperty(name="not")
-    comparison: EnumProperty(
-        items=[
-            ("=", "equal to", ""),
-            ("*=", "contains", ""),
-            (">=", "greater than or equal to", ""),
-            ("<=", "lesser than or equal to", ""),
-            (">", "greater than", ""),
-            ("<", "less than", ""),
-        ],
-    )
-    load_option: StringProperty(
-        default="options", description="controls whether or not options or sub_options are loaded"
-    )
-    options: CollectionProperty(type=SearchCollection)
-    active_option: StringProperty(update=load_sub_options)
-    sub_options: CollectionProperty(type=SearchCollection)
-    active_sub_option: StringProperty()
-    value: StringProperty(description="generic 'value' that can be used in multiple scenarios")
-
-
-class SearchQueryFilter(PropertyGroup, IfcSelector):
-    selector: EnumProperty(
-        items=[(i, i, i) for i in ["-", "IfcPropertySet", "Attribute"]],
-        name="Filter selection by",
-        update=load_selection_options,
-        default="-",
-    )
-
-
-class SearchQuery(PropertyGroup, IfcSelector):
-    filters: CollectionProperty(type=SearchQueryFilter)
-    selector: EnumProperty(
-        items=[(i, i, i) for i in ["-", "IFC Class", "IfcSpatialElement", "IfcElementType", "GlobalId"]],
-        name="Selector type",
-        update=load_selection_options,
-        default="-",
-    )
-
-
-class SearchQueryGroup(PropertyGroup, IfcSelector):
-    queries: CollectionProperty(type=SearchQuery)
-
-
-class IfcSelectorProperties(PropertyGroup, IfcSelector):
-    groups: CollectionProperty(type=SearchQueryGroup)
-    selector_query_syntax: StringProperty()
-
-    query_library: CollectionProperty(type=SearchCollection)
-    active_query: StringProperty()
-
-    active_query: StringProperty()
-    manual_override: BoolProperty(default=False, description="Toggle to allow manual typing of query-syntax")

src/blenderbim/blenderbim/bim/module/search/ui.py

@@ -125,7 +125,7 @@ class BIM_UL_colourscheme(bpy.types.UIList):
         if not item:
             return
         row = layout.row(align=True)
-        row.label(text=item.name)
+        row.label(text=f"{item.name} ({item.total})")
         row.prop(item, "colour", text="")
 
 
@@ -159,153 +159,3 @@ class BIM_UL_ifc_building_storey_filter(bpy.types.UIList):
         split = split.column()
         split.scale_x = 0.5
         split.label(text=str(item.total))
-
-
-class BIM_PT_IFCSelector(Panel):
-    bl_label = "Selector"
-    bl_idname = "BIM_PT_ifc_selector"
-    bl_options = {"DEFAULT_CLOSED"}
-    bl_space_type = "PROPERTIES"
-    bl_region_type = "WINDOW"
-    bl_context = "scene"
-    bl_parent_id = "BIM_PT_tab_sandbox"
-
-    def draw(self, context):
-        layout = self.layout
-        layout.operator("bim.ifc_selector")
-
-
-# this doesn't inherit from Panel since it's just a class to abstract away UI code from the IfcSelector Operator
-class IfcSelectorUI:
-    @classmethod
-    def draw(self, context, layout):
-        ifc_selector = context.scene.IfcSelectorProperties
-        row = layout.row()
-
-        row.context_pointer_set(name="bim_prop_group", data=ifc_selector)
-        op = row.operator("bim.edit_blender_collection", text="Add selection group")
-        op.option = "add"
-        op.collection = "groups"
-        layout.separator()
-
-        self.draw_query_group_ui(self, ifc_selector, layout)
-
-        if len(ifc_selector.groups) != 0:
-            row = layout.row(align=True)
-            row.prop(ifc_selector, "selector_query_syntax", text="Query Syntax")
-            row.prop(ifc_selector, "manual_override", text="")
-
-            select = row.operator("bim.filter_model_elements", text="", icon="RESTRICT_SELECT_OFF")
-            select.option = "select"
-            isolate = row.operator("bim.filter_model_elements", text="", icon="ZOOM_SELECTED")
-            isolate.option = "isolate"
-            hide = row.operator("bim.filter_model_elements", text="", icon="HIDE_ON")
-            hide.option = "hide"
-            unhide = row.operator("bim.filter_model_elements", text="", icon="HIDE_OFF")
-            unhide.option = "unhide"
-
-            row = layout.row(align=True)
-            row.alignment = "CENTER"
-            row.operator("bim.save_selector_query", text="Save Query")
-            op = row.operator("bim.open_query_library", text="Load Query")
-            row.operator("bim.add_to_ifc_group", text="Add to IFC Group")
-
-            row = layout.row(align=True)
-            row.operator("bim.show_scene_elements", text="Show All Elements", icon="HIDE_OFF")
-
-    def draw_query_group_ui(self, ifc_selector, layout):
-        for index, group in enumerate(ifc_selector.groups):
-            row = layout.row()
-            row.alignment = "CENTER"
-            row.label(text="or") if index != 0 else None
-
-            box = layout.box()
-            row = box.row(align=True)
-            row.alignment = "CENTER"
-            row.label(text=f"Group #{str(index+1)}")
-            row.context_pointer_set(name="bim_prop_group", data=group)
-            op = row.operator("bim.edit_blender_collection", text="Add query", icon="PLUS")
-            op.option = "add"
-            op.collection = "queries"
-
-            row.context_pointer_set(name="bim_prop_group", data=ifc_selector)
-            op = row.operator("bim.edit_blender_collection", text="Remove selection group")
-            op.option = "remove"
-            op.collection = "groups"
-            op.index = index
-
-            self.draw_query_ui(self, group, box)
-
-    def draw_query_ui(self, group, box):
-        for index, query in enumerate(group.queries):
-            row = box.row()
-            row.alignment = "LEFT"
-
-            row.prop(query, "and_or", text="") if index != 0 else None
-            if query.and_or == "or":
-                row = box.row()
-                row.alignment = "LEFT"
-            row.prop(query, "selector", text="")
-
-            if query.selector in ["IFC Class", "IfcSpatialElement", "IfcElementType"]:
-                row.label(text="Equals")
-                row.prop_search(query, "active_option", query, "options", text="")
-                row.prop_search(query, "active_sub_option", query, "sub_options", text="") if len(
-                    query.sub_options
-                ) != 0 else None
-                self.draw_filter_ui(self, box, query)
-
-            elif query.selector in ["GlobalId", "Attribute"]:
-                row.prop(query, "negation", text="")
-                row.prop(query, "comparison", text="")
-                row.prop(query, "value", text="")
-
-            row.context_pointer_set(name="bim_prop_group", data=group)
-            op = row.operator("bim.edit_blender_collection", icon="REMOVE", text="")
-            op.option = "remove"
-            op.collection = "queries"
-            op.index = index
-
-            row.context_pointer_set(name="bim_prop_group", data=query)
-            op = (
-                row.operator("bim.edit_blender_collection", text="Add filter")
-                if query.selector == "IFC Class"
-                else None
-            )
-            if op:
-                op.option = "add"
-                op.collection = "filters"
-
-    def draw_filter_ui(self, box, query):
-        for filter_index, f in enumerate(query.filters):
-            row = box.row()
-            row.alignment = "LEFT"
-            row.label(text="  ↪")
-            row.prop(f, "and_or", text="") if filter_index != 0 else None
-            if f.and_or == "or":
-                row = box.row()
-                row.alignment = "LEFT"
-                row.label(text="  ↪")
-            row.prop(f, "selector", text="")
-
-            if f.selector == "Attribute":
-                row.prop_search(f, "active_option", f, "options", text="", results_are_suggestions=True)
-                row.prop(
-                    f,
-                    "negation",
-                )
-                row.prop(f, "comparison", text="")
-                row.prop(f, "value", text="")
-
-            elif f.selector == "IfcPropertySet":
-                row.prop_search(f, "active_option", f, "options", text="")
-                row.prop_search(f, "active_sub_option", f, "sub_options", text="")
-                row.prop(f, "negation")
-                row.prop(f, "comparison", text="")
-                row.prop(f, "value", text="")
-
-            row.context_pointer_set(name="bim_prop_group", data=query)
-            op = row.operator("bim.edit_blender_collection", icon="REMOVE", text="")
-            op.option = "remove"
-            op.collection = "filters"
-            op.index = filter_index

src/blenderbim/blenderbim/bim/module/structural/operator.py

@@ -473,7 +473,7 @@ class AssignStructuralLoadCase(bpy.types.Operator, tool.Ifc.Operator):
             self.file,
             **{
                 "relating_object": self.file.by_id(self.work_plan),
-                "product": self.file.by_id(self.load_case),
+                "products": [self.file.by_id(self.load_case)],
             },
         )
         return {"FINISHED"}
@@ -492,7 +492,7 @@ class UnassignStructuralLoadCase(bpy.types.Operator, tool.Ifc.Operator):
             self.file,
             **{
                 "relating_object": self.file.by_id(self.work_plan),
-                "product": self.file.by_id(self.load_case),
+                "products": [self.file.by_id(self.load_case)],
             },
         )
         return {"FINISHED"}

src/blenderbim/blenderbim/bim/module/style/__init__.py

@@ -30,6 +30,7 @@ classes = (
     operator.DisableAddingPresentationStyle,
     operator.DisableEditingStyle,
     operator.DisableEditingStyles,
+    operator.DuplicateStyle,
     operator.EditStyle,
     operator.EditSurfaceStyle,
     operator.EnableAddingPresentationStyle,

src/blenderbim/blenderbim/bim/module/style/operator.py

@@ -23,6 +23,7 @@ import blenderbim.bim.handler
 import blenderbim.tool as tool
 import blenderbim.core.style as core
 import ifcopenshell.util.representation
+from blenderbim.bim.module.style.prop import switch_shading
 from pathlib import Path
 from mathutils import Vector
 
@@ -126,6 +127,10 @@ class DisableEditingStyle(bpy.types.Operator, tool.Ifc.Operator):
         tool.Style.reload_material_from_ifc(material)
         props.is_editing_style = 0
 
+        # restore selected style type
+        material = tool.Ifc.get_object(style)
+        material.BIMStyleProperties.active_style_type = material.BIMStyleProperties.active_style_type
+
 
 class EditStyle(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.edit_style"
@@ -246,14 +251,15 @@ class BrowseExternalStyle(bpy.types.Operator):
     )
 
     def invoke(self, context, event):
-        external_style = None
+        style_elements = None
         if self.active_surface_style_id:
             style = tool.Ifc.get().by_id(self.active_surface_style_id)
-            external_style = tool.Style.get_style_elements(style).get("IfcExternallyDefinedSurfaceStyle", None)
+            style_elements = tool.Style.get_style_elements(style)
 
         # automatically select previously selected external style in file browser
         # if it exists in the file
-        if external_style and self.filepath == "":
+        if style_elements and self.filepath == "" and tool.Style.has_blender_external_style(style_elements):
+            external_style = style_elements["IfcExternallyDefinedSurfaceStyle"]
             style_path = Path(tool.Ifc.resolve_uri(external_style.Location))
             self.directory = str(style_path.parent)
             self.filepath = str(style_path)
@@ -310,6 +316,9 @@ class BrowseExternalStyle(bpy.types.Operator):
         attributes["Location"].string_value = filepath
         attributes["Identification"].string_value = f"{self.data_block_type}/{self.data_block}"
         attributes["Name"].string_value = self.data_block
+
+        style = tool.Ifc.get().by_id(self.active_surface_style_id)
+        bpy.ops.bim.activate_external_style(material_name=tool.Ifc.get_object(style).name)
         return {"FINISHED"}
 
 
@@ -325,21 +334,35 @@ class ActivateExternalStyle(bpy.types.Operator, tool.Ifc.Operator):
             material = context.active_object.active_material
         else:
             material = bpy.data.materials[self.material_name]
-        external_style = tool.Style.get_style_elements(material)["IfcExternallyDefinedSurfaceStyle"]
-        data_block_type, data_block = external_style.Identification.split("/")
-        style_path = Path(tool.Ifc.resolve_uri(external_style.Location))
+
+        props = context.scene.BIMStylesProperties
+        if props.is_editing:
+            location = props.external_style_attributes["Location"].string_value
+            identification = props.external_style_attributes["Identification"].string_value
+        else:
+            external_style = tool.Style.get_style_elements(material)["IfcExternallyDefinedSurfaceStyle"]
+            location = external_style.Location
+            identification = external_style.Identification
+
+        data_block_type, data_block = identification.split("/")
+        style_path = Path(tool.Ifc.resolve_uri(location))
 
         if style_path.suffix != ".blend":
-            self.report({"ERROR"}, f"Error loading external style - only Blender external styles are supported")
+            self.report(
+                {"ERROR"},
+                f'Error loading external style for "{material.name}" - only Blender external styles are supported',
+            )
             return {"CANCELLED"}
 
         if not style_path.exists():
-            self.report({"ERROR"}, f"Error loading external style - cannot find file: '{style_path}'")
+            self.report(
+                {"ERROR"}, f"Error loading external style for \"{material.name}\" - cannot find file: '{style_path}'"
+            )
             return {"CANCELLED"}
 
         db = tool.Blender.append_data_block(str(style_path), data_block_type, data_block)
         if not db["data_block"]:
-            self.report({"ERROR"}, f"Error loading external style - {db['msg']}")
+            self.report({"ERROR"}, f"Error loading external style for \"{material.name}\" - {db['msg']}")
             return {"CANCELLED"}
 
         self.copy_material_attributes(db["data_block"], material)
@@ -488,6 +511,22 @@ class EnableAddingPresentationStyle(bpy.types.Operator, tool.Ifc.Operator):
         props.is_adding = True
 
 
+class DuplicateStyle(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.duplicate_style"
+    bl_label = "Duplicate Style"
+    bl_options = {"REGISTER", "UNDO"}
+
+    style: bpy.props.IntProperty(name="Style ID")
+
+    def _execute(self, context):
+        style_type = context.scene.BIMStylesProperties.style_type
+        ifc_file = tool.Ifc.get()
+        style = ifc_file.by_id(self.style)
+        tool.Style.duplicate_style(style)
+        bpy.ops.bim.disable_editing_styles()
+        bpy.ops.bim.load_styles(style_type=style_type)
+
+
 class DisableAddingPresentationStyle(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.disable_adding_presentation_style"
     bl_label = "Disable Add Presentation Style"
@@ -566,7 +605,8 @@ class EnableEditingSurfaceStyle(bpy.types.Operator, tool.Ifc.Operator):
         props.is_editing_class = self.ifc_class
         tool.Style.set_surface_style_props()
 
-        surface_style = tool.Style.get_style_elements(style).get(self.ifc_class, None)
+        style_elements = tool.Style.get_style_elements(style)
+        surface_style = style_elements.get(self.ifc_class, None)
         attributes = tool.Style.get_style_ui_props_attributes(self.ifc_class)
 
         # lighting style require special handling since Attribute doesn't support colors
@@ -586,6 +626,17 @@ class EnableEditingSurfaceStyle(bpy.types.Operator, tool.Ifc.Operator):
             attributes.clear()
             blenderbim.bim.helper.import_attributes2(surface_style or self.ifc_class, attributes, callback)
 
+        material = tool.Ifc.get_object(style)
+        active_style_type = material.BIMStyleProperties.active_style_type
+        if self.ifc_class == "IfcExternallyDefinedSurfaceStyle" and active_style_type != "External":
+            if tool.Style.has_blender_external_style(style_elements):
+                switch_shading(material, "External")
+        elif (
+            self.ifc_class in ("IfcSurfaceStyleShading", "IfcSurfaceStyleRendering", "IfcSurfaceStyleWithTextures")
+            and active_style_type != "Shading"
+        ):
+            switch_shading(material, "Shading")
+
 
 class EditSurfaceStyle(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.edit_surface_style"
@@ -610,6 +661,10 @@ class EditSurfaceStyle(bpy.types.Operator, tool.Ifc.Operator):
         self.props.is_editing_style = 0
         core.load_styles(tool.Style, style_type=self.props.style_type)
 
+        # restore selected style type
+        material = tool.Ifc.get_object(self.style)
+        material.BIMStyleProperties.active_style_type = material.BIMStyleProperties.active_style_type
+
     def edit_existing_style(self):
         material = tool.Ifc.get_object(self.style)
         if self.surface_style.is_a() == "IfcSurfaceStyleShading":

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

@@ -33,6 +33,8 @@ from bpy.props import (
 )
 
 import gettext
+from typing import Literal
+
 
 _ = gettext.gettext
 
@@ -251,19 +253,15 @@ class BIMStylesProperties(PropertyGroup):
     )
 
 
-def update_shading_style(self, context):
-    blender_material = self.id_data
-    style_elements = tool.Style.get_style_elements(blender_material)
-    if self.active_style_type == "External":
-        if tool.Style.has_blender_external_style(style_elements):
-            try:
-                bpy.ops.bim.activate_external_style(material_name=blender_material.name)
-            except RuntimeError as error:
-                if str(error).startswith("Error: Error loading external style - "):
-                    return
-                raise error
-
-    elif self.active_style_type == "Shading":
+def switch_shading(blender_material: bpy.types.Material, style_type: Literal["External", "Shading"]) -> None:
+    if style_type == "External":
+        try:
+            bpy.ops.bim.activate_external_style(material_name=blender_material.name)
+        except RuntimeError as error:
+            if str(error).startswith("Error: Error loading external style for "):
+                return
+            raise error
+    elif style_type == "Shading":
         style_elements = tool.Style.get_style_elements(blender_material)
         rendering_style = None
         texture_style = None
@@ -279,6 +277,16 @@ def update_shading_style(self, context):
 
         if rendering_style and texture_style:
             tool.Loader.create_surface_style_with_textures(blender_material, rendering_style, texture_style)
+
+
+def update_shading_style(self, context):
+    blender_material = self.id_data
+    style_elements = tool.Style.get_style_elements(blender_material)
+    if self.active_style_type == "External":
+        if tool.Style.has_blender_external_style(style_elements):
+            switch_shading(blender_material, self.active_style_type)
+    elif self.active_style_type == "Shading":
+        switch_shading(blender_material, self.active_style_type)
     tool.Style.record_shading(blender_material)
 
 

src/blenderbim/blenderbim/bim/module/style/ui.py

@@ -44,19 +44,33 @@ class BIM_PT_styles(Panel):
 
         self.props = context.scene.BIMStylesProperties
 
-        if self.props.is_editing:
-            row = self.layout.row(align=True)
-            row.label(text="{} {}s".format(len(self.props.styles), self.props.style_type), icon="SHADING_RENDERED")
-            if not self.props.is_adding:
-                row.operator("bim.enable_adding_presentation_style", text="", icon="ADD")
-            row.operator("bim.disable_editing_styles", text="", icon="CANCEL")
-        else:
+        if not self.props.is_editing:
             row = self.layout.row(align=True)
             row.label(text="{} Styles".format(StylesData.data["total_styles"]), icon="SHADING_RENDERED")
             blenderbim.bim.helper.prop_with_search(row, self.props, "style_type", text="")
             row.operator("bim.load_styles", text="", icon="IMPORT").style_type = self.props.style_type
             return
 
+        active_style = self.props.styles and self.props.active_style_index < len(self.props.styles)
+        row = self.layout.row(align=True)
+        row.label(text="{} {}s".format(len(self.props.styles), self.props.style_type), icon="SHADING_RENDERED")
+        row.operator("bim.disable_editing_styles", text="", icon="CANCEL")
+
+        row = self.layout.row(align=True)
+        row.alignment = "RIGHT"
+        if not self.props.is_adding:
+            row.operator("bim.enable_adding_presentation_style", text="", icon="ADD")
+        if active_style:
+            style = self.props.styles[self.props.active_style_index]
+            material_name = StylesData.data["styles_to_blender_material_names"][self.props.active_style_index]
+            material = bpy.data.materials[material_name]
+
+            row.operator("bim.duplicate_style", text="", icon="DUPLICATE").style = style.ifc_definition_id
+            row.operator("bim.select_by_style", text="", icon="RESTRICT_SELECT_OFF").style = style.ifc_definition_id
+            op = row.operator("bim.enable_editing_style", text="", icon="GREASEPENCIL")
+            op.style = style.ifc_definition_id
+            row.operator("bim.remove_style", text="", icon="X").style = style.ifc_definition_id
+
         self.layout.template_list("BIM_UL_styles", "", self.props, "styles", self.props, "active_style_index")
 
         # adding a new IfcSurfaceStyle
@@ -77,17 +91,7 @@ class BIM_PT_styles(Panel):
             row.operator("bim.disable_adding_presentation_style", text="", icon="CANCEL")
 
         # style ui tools
-        if self.props.styles and self.props.active_style_index < len(self.props.styles):
-            row = self.layout.row(align=True)
-            style = self.props.styles[self.props.active_style_index]
-            material_name = StylesData.data["styles_to_blender_material_names"][self.props.active_style_index]
-            material = bpy.data.materials[material_name]
-
-            op = row.operator("bim.enable_editing_style", text="Edit Style", icon="GREASEPENCIL")
-            op.style = style.ifc_definition_id
-            row.operator("bim.select_by_style", text="", icon="RESTRICT_SELECT_OFF").style = style.ifc_definition_id
-            row.operator("bim.remove_style", text="", icon="X").style = style.ifc_definition_id
-
+        if active_style:
             row = self.layout.row(align=True)
             row.prop(material.BIMStyleProperties, "active_style_type", icon="SHADING_RENDERED", text="")
             op = row.operator("bim.update_current_style", icon="FILE_REFRESH", text="")

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

@@ -20,6 +20,7 @@ import bpy
 import bmesh
 import ifcopenshell.util.element
 import ifcopenshell.util.schema
+import ifcopenshell.util.representation
 import ifcopenshell.util.type
 import ifcopenshell.api
 import blenderbim.tool as tool
@@ -77,7 +78,7 @@ class UnassignType(bpy.types.Operator):
             element = tool.Ifc.get_entity(obj)
             if not element or element.is_a("IfcElementType"):
                 continue
-            ifcopenshell.api.run("type.unassign_type", self.file, related_object=element)
+            ifcopenshell.api.run("type.unassign_type", self.file, related_objects=[element])
 
             active_representation = tool.Geometry.get_active_representation(obj)
             active_context = active_representation.ContextOfItems
@@ -145,23 +146,51 @@ class SelectType(bpy.types.Operator):
     relating_type: bpy.props.IntProperty()
 
     def execute(self, context):
-        element = tool.Ifc.get().by_id(self.relating_type)
-        obj = tool.Ifc.get_object(element)
-        if obj:
-            try:
-                tool.Blender.select_and_activate_single_object(context, obj)
-            except:
-                self.report({"INFO"}, "Type object is hidden.")
-        # IfcTypeProducts are only used for annotations and not part of the model interface.
-        if element.is_a() != "IfcTypeProduct":
-            try:
-                context.scene.BIMModelProperties.ifc_class = element.is_a()
-                context.scene.BIMModelProperties.relating_type_id = str(self.relating_type)
-            except:
-                # Potentially our BIM Tool is filtered to a specific element.
-                pass
+
+        if self.relating_type: #if operator button sends a relating_type, the iterator only selects this one type
+            element = tool.Ifc.get().by_id(self.relating_type)
+            obj = tool.Ifc.get_object(element)
+            selected_objs = [obj]
+        else:    #else, the iterator selects all the types of all the selected objects
+            selected_objs = context.selected_objects
+            active_obj = context.active_object
+            selected_objs.append(active_obj) #update selected_objs so the active_obj is at the end of the list
+        
+        last_relating_type_obj = None
+        types_collection_in_view_layer = self.find_collection_in_ifcproject(context, collection_name = "Types")
+        types_collection_in_view_layer.hide_viewport = False
+        types_collection = bpy.data.collections.get("Types")
+        for type_obj in types_collection.objects:
+            type_obj.hide_set(True)
+        for obj in selected_objs:
+            element = tool.Ifc.get_entity(obj)
+            relating_type = ifcopenshell.util.element.get_type(element)
+            if relating_type:
+                relating_type_obj = tool.Ifc.get_object(relating_type)
+                if relating_type_obj:
+                    if relating_type_obj.hide_get():  
+                        relating_type_obj.hide_set(False)  
+                    relating_type_obj.select_set(True)  
+                    last_relating_type_obj = relating_type_obj
+            if not element.is_a("IfcTypeObject"): 
+                obj.select_set(False)
+
+        context.view_layer.objects.active = last_relating_type_obj #makes the active_obj's type the active object
+
         return {"FINISHED"}
 
+    def find_collection_in_ifcproject(self, context, collection_name):
+
+        ifc_project_collection = None
+        for child in context.view_layer.layer_collection.children:
+            if "IfcProject" in child.name:
+                ifc_project_collection = child
+                break
+        
+        if ifc_project_collection:
+            collection_in_view_layer = ifc_project_collection.children.get(collection_name)
+            return collection_in_view_layer
+
 
 class SelectSimilarType(bpy.types.Operator):
     bl_idname = "bim.select_similar_type"
@@ -282,7 +311,7 @@ class AddType(bpy.types.Operator, tool.Ifc.Operator):
             else:
                 material = self.add_default_material()
             rel = ifcopenshell.api.run(
-                "material.assign_material", ifc_file, product=element, type="IfcMaterialLayerSet"
+                "material.assign_material", ifc_file, products=[element], type="IfcMaterialLayerSet"
             )
             layer_set = rel.RelatingMaterial
             layer = ifcopenshell.api.run("material.add_layer", ifc_file, layer_set=layer_set, material=material)
@@ -360,7 +389,7 @@ class AddType(bpy.types.Operator, tool.Ifc.Operator):
                     )
 
             rel = ifcopenshell.api.run(
-                "material.assign_material", ifc_file, product=element, type="IfcMaterialProfileSet"
+                "material.assign_material", ifc_file, products=[element], type="IfcMaterialProfileSet"
             )
             profile_set = rel.RelatingMaterial
             material_profile = ifcopenshell.api.run(

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

@@ -88,7 +88,7 @@ class BIM_PT_type(Panel):
             if TypeData.data["relating_type"]:
                 row.label(text=TypeData.data["relating_type"]["name"])
                 op = row.operator("bim.select_type", icon="OBJECT_DATA", text="")
-                op.relating_type = TypeData.data["relating_type"]["id"]
+                op.relating_type = 0 #will only select the relating types of only the selected objects 
                 row.operator("bim.select_similar_type", icon="RESTRICT_SELECT_OFF", text="")
                 row.operator("bim.enable_editing_type", icon="GREASEPENCIL", text="")
                 row.operator("bim.unassign_type", icon="X", text="")

src/blenderbim/blenderbim/bim/operator.py

@@ -90,6 +90,15 @@ class OpenUri(bpy.types.Operator):
         return {"FINISHED"}
 
 
+class CloseError(bpy.types.Operator):
+    bl_idname = "bim.close_error"
+    bl_label = "Close Error"
+
+    def execute(self, context):
+        blenderbim.last_error = None
+        return {"FINISHED"}
+
+
 class SelectURIAttribute(bpy.types.Operator):
     bl_idname = "bim.select_uri_attribute"
     bl_label = "Select URI Attribute"
@@ -357,7 +366,7 @@ class OpenUpstream(bpy.types.Operator):
         if self.page == "home":
             webbrowser.open("https://blenderbim.org/")
         elif self.page == "docs":
-            webbrowser.open("https://blenderbim.org/docs/")
+            webbrowser.open("https://docs.blenderbim.org/")
         elif self.page == "wiki":
             webbrowser.open("https://wiki.osarch.org/index.php?title=Category:BlenderBIM_Add-on")
         elif self.page == "community":
@@ -936,6 +945,31 @@ class BIM_OT_enum_property_search(bpy.types.Operator):
                         )
 
 
+class BIM_OT_select_object(bpy.types.Operator):
+    bl_idname = "bim.select_object"
+    bl_label = "Select Object"
+    bl_options = {"REGISTER", "UNDO"}
+    obj_name: bpy.props.StringProperty(description="Object Name To Select")
+
+    def execute(self, context):
+        obj = bpy.data.objects[self.obj_name]
+        tool.Blender.set_objects_selection(context, obj, [obj], clear_previous_selection=True)
+        return {"FINISHED"}
+
+
+class BIM_OT_delete_object(bpy.types.Operator):
+    bl_idname = "bim.delete_object"
+    bl_label = "Delete Object"
+    bl_options = {"REGISTER", "UNDO"}
+    obj_name: bpy.props.StringProperty(description="Object Name To Delete")
+
+    def execute(self, context):
+        obj = bpy.data.objects[self.obj_name]
+        with context.temp_override(selected_objects=[obj], active_object=obj):
+            bpy.ops.bim.override_object_delete(is_batch=False)
+        return {"FINISHED"}
+
+
 class EditBlenderCollection(bpy.types.Operator):
     bl_idname = "bim.edit_blender_collection"
     bl_label = "Add or Remove Blender Collection Item"

src/blenderbim/blenderbim/bim/prop.py

@@ -273,6 +273,8 @@ class Attribute(PropertyGroup):
     def get_value(self):
         if self.is_optional and self.is_null:
             return None
+        if self.data_type == "string":
+            return self.string_value.replace("\\n", "\n")
         return getattr(self, str(self.get_value_name()), None)
 
     def get_value_default(self):

src/blenderbim/blenderbim/bim/ui.py

@@ -29,8 +29,9 @@ from ifcopenshell.util.doc import (
     get_attribute_doc,
 )
 from . import ifc
-import blenderbim.tool as tool
+from blenderbim import get_debug_info
 import blenderbim.bim
+import blenderbim.tool as tool
 from blenderbim.bim.helper import IfcHeaderExtractor
 from blenderbim.bim.prop import Attribute
 
@@ -127,6 +128,42 @@ class BIM_PT_section_with_cappings(Panel):
         row.operator("bim.clipping_plane_cut_with_cappings", icon="XRAY", text="Cut")
         row.operator("bim.revert_clipping_plane_cut", icon="FILE_REFRESH", text="Revert Cut")
 
+        props = context.scene.BIMProjectProperties
+        box = layout.box()
+        header = box.row(align=True)
+        header.label(text="Clipping Planes")
+        header.operator("bim.save_clipping_planes", text="", icon="EXPORT")
+        header.operator("bim.load_clipping_planes", text="", icon="IMPORT")
+        header.operator("bim.create_clipping_plane", text="", icon="ADD")
+
+        box.template_list(
+            "BIM_UL_clipping_plane",
+            "",
+            props,
+            "clipping_planes",
+            props,
+            "clipping_planes_active",
+        )
+
+        if props.clipping_planes_active < len(props.clipping_planes):
+            active_clipping_plane_obj = props.clipping_planes[props.clipping_planes_active].obj
+            box.prop(active_clipping_plane_obj, "location")
+            box.prop(active_clipping_plane_obj, "rotation_euler")
+
+
+class BIM_UL_clipping_plane(bpy.types.UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
+        if item and item.obj:
+            obj = item.obj
+            row = layout.row(align=True)
+            row.prop(obj, "name", text="", emboss=False)
+            row.operator("bim.select_object", text="", icon="RESTRICT_SELECT_OFF").obj_name = obj.name
+            row.context_pointer_set("active_object", obj)
+            row.operator("bim.flip_clipping_plane", text="", icon="PASTEFLIPDOWN")
+            row.operator("bim.delete_object", text="", icon="TRASH").obj_name = obj.name
+        else:
+            layout.label(text="", translate=False)
+
 
 class BIM_UL_generic(bpy.types.UIList):
     def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
@@ -168,6 +205,7 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         name="Should Make A Cha-Ching Sound When Project Costs Updates", default=False
     )
     lock_grids_on_import: BoolProperty(name="Should Lock Grids By Default", default=True)
+    spatial_elements_unselectable: BoolProperty(name="Should Make Spatial Elements Unselectable By Default", default=True)
     decorations_colour: bpy.props.FloatVectorProperty(
         name="Decorations Colour", subtype="COLOR", default=(1, 1, 1, 1), min=0.0, max=1.0, size=4
     )
@@ -249,6 +287,10 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         row.prop(self, "should_play_chaching_sound")
         row = layout.row()
         row.prop(self, "lock_grids_on_import")
+        row = layout.row()
+        row.prop(self, "spatial_elements_unselectable")
+
+
 
         row = layout.row()
         row.prop(context.scene.BIMProjectProperties, "should_disable_undo_on_save")
@@ -361,6 +403,17 @@ class BIM_PT_tabs(Panel):
 
             row = self.layout.row(align=True)
             row.prop(aprops, "tab", text="")
+
+            if blenderbim.last_error:
+                box = self.layout.box()
+                row = box.row(align=True)
+                row.label(text="BlenderBIM experienced an error :(", icon="ERROR")
+                row.operator("bim.close_error", text="", icon="CANCEL")
+                box.label(text="View the console for full logs.", icon="CONSOLE")
+                box.operator("bim.copy_debug_information", text="Copy Error Message To Clipboard")
+                op = box.operator("bim.open_uri", text="How Can I Fix This?")
+                op.uri = "https://docs.blenderbim.org/users/troubleshooting.html"
+
         except:
             pass  # Prior to load_post, we may not have any area properties setup
 
@@ -432,7 +485,7 @@ class BIM_PT_tab_grouping_and_filtering(Panel):
     bl_space_type = "PROPERTIES"
     bl_region_type = "WINDOW"
     bl_context = "scene"
-    bl_options = {"DEFAULT_CLOSED"}
+    bl_options = {"DEFAULT_CLOSED","HEADER_LAYOUT_EXPAND"}
 
     @classmethod
     def poll(cls, context):
@@ -441,6 +494,13 @@ class BIM_PT_tab_grouping_and_filtering(Panel):
     def draw(self, context):
         pass
 
+    def draw_header(self, context):
+        # Draws help button on the right
+        row = self.layout.row(align=True)
+        row.label(text="")  # empty text occupies the left of the row
+        row.operator("bim.open_uri", text="", icon="HELP").uri = \
+            "https://docs.ifcopenshell.org/ifcopenshell-python/selector_syntax.html"
+
 
 class BIM_PT_tab_geometry(Panel):
     bl_label = "Geometry"

src/blenderbim/blenderbim/core/aggregate.py

@@ -29,7 +29,7 @@ def assign_object(ifc, aggregator, collector, relating_obj=None, related_obj=Non
     if not aggregator.can_aggregate(relating_obj, related_obj):
         return
     rel = ifc.run(
-        "aggregate.assign_object", product=ifc.get_entity(related_obj), relating_object=ifc.get_entity(relating_obj)
+        "aggregate.assign_object", products=[ifc.get_entity(related_obj)], relating_object=ifc.get_entity(relating_obj)
     )
     collector.assign(relating_obj)
     collector.assign(related_obj)
@@ -45,9 +45,9 @@ def unassign_object(ifc, aggregate, collector, relating_obj=None, related_obj=No
         if related_element:
             relating_obj = ifc.get_object(relating_element)
     if relating_obj:
-        ifc.run("aggregate.unassign_object", product=related_element)
+        ifc.run("aggregate.unassign_object", products=[related_element])
         if container:
-            ifc.run("spatial.assign_container", product=related_element, relating_structure=container)
+            ifc.run("spatial.assign_container", products=[related_element], relating_structure=container)
         collector.assign(relating_obj)
         collector.assign(related_obj)