mention IfcSverchok in docs

The issue was related to the sheet names - Excel prohibits some symbols in the names and it doesn't allow sheet name to be longer than 31 symbols. If sheet names doesn't match this criteria then Excel says file appears to be corrupted - when file open data itself is not really corrupted besides the spreadsheet names that failed the criteria.

.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                                                                                                                                       |
 | ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |

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-e38eafd-$(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/
 
@@ -362,7 +362,9 @@ endif
 	# Provides express rule validation for ifcopenshell.validate
 	cd dist/working && . env/bin/activate && $(PIP) install pytest --target=./site-packages
 	# Provides Brickschema functionality
-	cd dist/working && . env/bin/activate && $(PIP) install brickschema[persistence] --target=./site-packages
+	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 +432,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

@@ -27,7 +27,7 @@ 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",
 }

src/blenderbim/blenderbim/bim/__init__.py

@@ -23,6 +23,7 @@ import bpy.utils.previews
 import blenderbim
 import importlib
 from . import handler, ui, prop, operator, helper
+from typing import Callable, Union
 
 try:
     from blenderbim.translations import translations_dict
@@ -96,8 +97,10 @@ for name in modules.keys():
 classes = [
     operator.AddIfcFile,
     operator.BIM_OT_add_section_plane,
+    operator.BIM_OT_delete_object,
     operator.BIM_OT_open_webbrowser,
     operator.BIM_OT_remove_section_plane,
+    operator.BIM_OT_select_object,
     operator.BIM_OT_show_description,
     operator.ClippingPlaneCutWithCappings,
     operator.EditBlenderCollection,
@@ -130,6 +133,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 +191,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 +299,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/export_ifc.py

@@ -35,6 +35,7 @@ import blenderbim.core.spatial
 import blenderbim.core.style
 from blenderbim.bim.ifc import IfcStore
 from mathutils import Vector
+from typing import Union
 
 
 class IfcExporter:
@@ -86,8 +87,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 +97,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 +129,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 +140,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 +154,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:

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):
@@ -254,60 +257,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
@@ -343,15 +292,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
@@ -271,6 +276,9 @@ def draw_filter(layout, filter_groups, data, module):
         op.type = sprops.facet
         op.index = i
         op.module = module
+        op = row.operator("bim.remove_filter_group", text="", icon="X")
+        op.index = i
+        op.module = module
 
         for j, ifc_filter in enumerate(filter_group.filters):
             if ifc_filter.type == "entity":
@@ -317,11 +325,6 @@ def draw_filter(layout, filter_groups, data, module):
             op.index = j
             op.module = module
 
-        row = box.row()
-        op = row.operator("bim.remove_filter_group", icon="X")
-        op.index = i
-        op.module = module
-
 
 # TODO this should move into ifcopenshell.util
 

src/blenderbim/blenderbim/bim/import_ifc.py

@@ -1164,6 +1164,9 @@ class IfcImporter:
 
         return obj
 
+    def load_existing_meshes(self) -> None:
+        self.meshes.update({m.name: m for m in bpy.data.meshes})
+
     def get_representation_item_material_name(self, item):
         if not item.StyledByItem:
             return

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

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

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

@@ -47,10 +47,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 +70,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 +129,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/cad/prop.py

@@ -24,10 +24,10 @@ from math import pi
 
 class BIMCadProperties(PropertyGroup):
     resolution: bpy.props.IntProperty(name="Arc Resolution", min=1, default=1)
-    radius: bpy.props.FloatProperty(name="Radius", default=0.1)
-    distance: bpy.props.FloatProperty(name="Distance", default=0.1)
-    x: bpy.props.FloatProperty(name="X", default=0.2)
-    y: bpy.props.FloatProperty(name="Y", default=0.1)
+    radius: bpy.props.FloatProperty(name="Radius", default=0.1, subtype="DISTANCE")
+    distance: bpy.props.FloatProperty(name="Distance", default=0.1, subtype="DISTANCE")
+    x: bpy.props.FloatProperty(name="X", default=0.2, subtype="DISTANCE")
+    y: bpy.props.FloatProperty(name="Y", default=0.1, subtype="DISTANCE")
     gable_roof_edge_angle: bpy.props.FloatProperty(
         name="Gable Roof Edge Angle", default=pi / 2, soft_min=0, soft_max=pi / 2, subtype="ANGLE"
     )

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

@@ -20,6 +20,7 @@ import os
 import bpy
 import blenderbim.tool as tool
 import blenderbim.bim.module.type.prop as type_prop
+import ifcopenshell.util.unit
 from bpy.types import WorkSpaceTool
 from blenderbim.bim.module.model.data import AuthoringData, RailingData, RoofData
 
@@ -239,8 +240,9 @@ class CadHotkey(bpy.types.Operator):
                 row.prop(props, "resolution")
 
     def hotkey_S_C(self):
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
         if self.is_profile():
-            bpy.ops.bim.add_ifccircle(radius=self.props.radius)
+            bpy.ops.bim.add_ifccircle(radius=self.props.radius / si_conversion)
         else:
             bpy.ops.bim.cad_arc_from_2_points()
 
@@ -248,13 +250,15 @@ class CadHotkey(bpy.types.Operator):
         bpy.ops.bim.cad_trim_extend()
 
     def hotkey_S_F(self):
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
         if self.is_profile():
-            bpy.ops.bim.add_ifcarcindex_fillet(radius=self.props.radius)
+            bpy.ops.bim.add_ifcarcindex_fillet(radius=self.props.radius / si_conversion)
         else:
-            bpy.ops.bim.cad_fillet(resolution=self.props.resolution, radius=self.props.radius)
+            bpy.ops.bim.cad_fillet(resolution=self.props.resolution, radius=self.props.radius / si_conversion)
 
     def hotkey_S_O(self):
-        bpy.ops.bim.cad_offset(distance=self.props.distance)
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        bpy.ops.bim.cad_offset(distance=self.props.distance / si_conversion)
 
     def hotkey_S_Q(self):
         element = tool.Ifc.get_entity(bpy.context.active_object)
@@ -270,7 +274,8 @@ class CadHotkey(bpy.types.Operator):
 
     def hotkey_S_R(self):
         if self.is_profile():
-            bpy.ops.bim.add_rectangle(x=self.props.x, y=self.props.y)
+            si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+            bpy.ops.bim.add_rectangle(x=self.props.x / si_conversion, y=self.props.y / si_conversion)
         elif (
             (RoofData.is_loaded or not RoofData.load())
             and RoofData.data["pset_data"]

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/decorator.py

@@ -16,31 +16,37 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
+import blf
 import gpu
 import bmesh
 import blenderbim.tool as tool
 from bpy.types import SpaceView3D
 from mathutils import Vector
 from gpu_extras.batch import batch_for_shader
+from bpy_extras.view3d_utils import location_3d_to_region_2d
 
 
 class ClashDecorator:
-    installed = None
+    is_installed = False
+    handlers = []
 
     @classmethod
     def install(cls, context):
-        if cls.installed:
+        if cls.is_installed:
             cls.uninstall()
         handler = cls()
-        cls.installed = SpaceView3D.draw_handler_add(handler, (context,), "WINDOW", "POST_VIEW")
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_text, (context,), "WINDOW", "POST_PIXEL"))
+        cls.handlers.append(SpaceView3D.draw_handler_add(handler.draw_geometry, (context,), "WINDOW", "POST_VIEW"))
+        cls.is_installed = True
 
     @classmethod
     def uninstall(cls):
-        try:
-            SpaceView3D.draw_handler_remove(cls.installed, "WINDOW")
-        except ValueError:
-            pass
-        cls.installed = None
+        for handler in cls.handlers:
+            try:
+                SpaceView3D.draw_handler_remove(handler, "WINDOW")
+            except ValueError:
+                pass
+        cls.is_installed = False
 
     def draw_batch(self, shader_type, content_pos, color, indices=None):
         shader = self.line_shader if shader_type == "LINES" else self.shader
@@ -48,7 +54,27 @@ class ClashDecorator:
         shader.uniform_float("color", color)
         batch.draw(shader)
 
-    def __call__(self, context):
+    def draw_text(self, context):
+        self.addon_prefs = context.preferences.addons["blenderbim"].preferences
+        selected_elements_color = self.addon_prefs.decorator_color_selected
+        unselected_elements_color = self.addon_prefs.decorator_color_unselected
+        special_elements_color = self.addon_prefs.decorator_color_special
+
+        text = context.scene.BIMClashProperties.active_clash_text
+        p = context.scene.BIMClashProperties.p1.lerp(context.scene.BIMClashProperties.p2, 0.5)
+
+        font_id = 0
+        blf.size(font_id, 12)
+        coords_2d = location_3d_to_region_2d(context.region, context.region_data, p)
+        color = self.addon_prefs.decorations_colour
+        blf.color(font_id, *color)
+        if coords_2d:
+            w, h = blf.dimensions(font_id, text)
+            coords_2d -= Vector((w * .5, 0))
+            blf.position(font_id, coords_2d[0], coords_2d[1], 0)
+            blf.draw(font_id, text)  # Set your text here
+
+    def draw_geometry(self, context):
         self.addon_prefs = context.preferences.addons["blenderbim"].preferences
         selected_elements_color = self.addon_prefs.decorator_color_selected
         unselected_elements_color = self.addon_prefs.decorator_color_unselected

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

@@ -69,6 +69,7 @@ class ImportClashSets(bpy.types.Operator):
 
     def execute(self, context):
         tool.Clash.load_clash_sets(self.filepath)
+        context.scene.BIMClashProperties.clash_sets.clear()
         for clash_set in tool.Clash.get_clash_sets():
             new = context.scene.BIMClashProperties.clash_sets.add()
             new.name = clash_set["name"]
@@ -85,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"}
@@ -208,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"}
@@ -220,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")
 
@@ -276,14 +283,7 @@ class ExecuteIfcClash(bpy.types.Operator):
 
         if extension == ".json":
             tool.Clash.load_clash_sets(self.filepath)
-            result = tool.Clash.get_clash_set(self.props.active_clash_set.name)
-            for clash in result["clashes"].values():
-                blender_clash = self.props.active_clash_set.clashes.add()
-                blender_clash.a_global_id = clash["a_global_id"]
-                blender_clash.b_global_id = clash["b_global_id"]
-                blender_clash.a_name = "{}/{}".format(clash["a_ifc_class"], clash["a_name"])
-                blender_clash.b_name = "{}/{}".format(clash["b_ifc_class"], clash["b_name"])
-                blender_clash.status = False if not "status" in clash.keys() else clash["status"]
+            tool.Clash.import_active_clashes()
         return {"FINISHED"}
 
 
@@ -379,6 +379,7 @@ class SelectClash(bpy.types.Operator):
         tool.Clash.look_at(target, target + Vector((5, 5, 5)))
         self.props.p1 = clash["p1"]
         self.props.p2 = clash["p2"]
+        self.props.active_clash_text = clash["type"].title() + " " + str(round(clash["distance"] * 1000)) + "mm"
         return {"FINISHED"}
 
 

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",
     )
@@ -97,6 +98,7 @@ class BIMClashProperties(PropertyGroup):
     )
     p1: FloatVectorProperty(name="P1", default=(0.0, 0.0, 0.0), subtype="XYZ")
     p2: FloatVectorProperty(name="P2", default=(0.0, 0.0, 0.0), subtype="XYZ")
+    active_clash_text: StringProperty(name="Active Clash Text")
 
     @property
     def active_clash_set(self):

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",
@@ -292,6 +294,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 +303,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 +364,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 +423,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/debug/__init__.py

@@ -24,6 +24,7 @@ classes = (
     operator.CopyDebugInformation,
     operator.CreateAllShapes,
     operator.CreateShapeFromStepId,
+    operator.DebugActiveDrawing,
     operator.InspectFromObject,
     operator.InspectFromStepId,
     operator.OverrideDisplayType,

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

@@ -20,11 +20,14 @@ 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
@@ -660,3 +663,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

@@ -75,6 +75,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/helper.py

@@ -188,7 +188,6 @@ def format_distance(
                 feet += 1
                 inches = 0
 
-
         if not isArea:
             add_inches = bool(inches) or not suppress_zero_inches
             tx_dist = ""
@@ -299,7 +298,9 @@ def parse_diagram_scale(camera):
     return float(numerator) / float(denominator)
 
 
-def ortho_view_frame(camera, margin=0.015):
+def ortho_view_frame(
+    camera: bpy.types.Camera, margin: float = 0.015
+) -> tuple[float, float, float, float, float, float]:
     """Calculates 2d bounding box of camera view area.
 
     Similar to `bpy.types.Camera.view_frame`

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

@@ -44,7 +44,7 @@ import blenderbim.bim.module.drawing.helper as helper
 import blenderbim.bim.export_ifc
 from blenderbim.bim.module.drawing.decoration import CutDecorator
 from blenderbim.bim.module.drawing.data import DecoratorData, DrawingsData
-from typing import NamedTuple, List
+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 +199,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):
@@ -220,7 +225,8 @@ class CreateDrawing(bpy.types.Operator):
         else:
             drawings_to_print = [self.props.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 +341,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 +458,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 +491,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 +529,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 +542,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 +1137,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)
 
@@ -1596,8 +1618,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)
@@ -2542,8 +2570,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 +2721,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/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/helper.py

@@ -21,12 +21,14 @@ import bmesh
 import mathutils
 import ifcopenshell
 import ifcopenshell.util.unit
+import blenderbim.tool as tool
 from math import pi, pow
 from mathutils import Vector, Matrix, geometry
+from typing import Union
 
 
 class Helper:
-    def __init__(self, file):
+    def __init__(self, file: ifcopenshell.file):
         self.file = file
         self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(self.file)
 
@@ -34,7 +36,7 @@ class Helper:
     # edge that shares a single vertex only with that face to find the extrusion
     # edge. A face with the normal facing down is prioritised. A limited
     # dissolve ensure that faces are quads and not tris.
-    def auto_detect_rectangle_profile_extruded_area_solid(self, mesh):
+    def auto_detect_rectangle_profile_extruded_area_solid(self, mesh: bpy.types.Mesh) -> dict:
         bm = bmesh.new()
         bm.from_mesh(mesh)
         bmesh.ops.dissolve_limit(bm, angle_limit=pi / 180 * 1, verts=bm.verts, edges=bm.edges)
@@ -115,7 +117,9 @@ class Helper:
 
         return {"profile": profile, "extrusion": extrusion}
 
-    def auto_detect_arbitrary_profile_with_voids(self, obj, mesh):
+    def auto_detect_arbitrary_profile_with_voids(
+        self, obj: bpy.types.Object, mesh: bpy.types.Mesh
+    ) -> Union[tuple, dict]:
         groups = {"IFCARCINDEX": [], "IFCCIRCLE": []}
         for i, group in enumerate(obj.vertex_groups):
             if "IFCARCINDEX" in group.name:
@@ -138,28 +142,31 @@ class Helper:
             total_groups = 0
             is_circle = False
             for group_type, group_indices in groups.items():
-                for group_index in group_indices:
-                    if group_index in vert[deform_layer]:
-                        if group_type == "IFCCIRCLE":
-                            is_circle = True
-                        group_verts[group_type].setdefault(group_index, 0)
-                        group_verts[group_type][group_index] += 1
-                        total_groups += 0
+                if not group_indices:
+                    continue
+                is_special, group_index = tool.Blender.bmesh_check_vertex_in_groups(vert, deform_layer, group_indices)
+                if not is_special:
+                    continue
+                if group_type == "IFCCIRCLE":
+                    is_circle = True
+                group_verts[group_type].setdefault(group_index, 0)
+                group_verts[group_type][group_index] += 1
+                total_groups += 0
             if total_groups > 1:  # A vert can only belong to one group
                 return (False, "AMBIGUOUS_SPECIAL_VERTEX")
             elif is_circle:
-                pass # Circles are allowed to be unclosed
+                pass  # Circles are allowed to be unclosed
             elif total_groups == 0 and len(vert.link_edges) != 2:  # Unclosed loop or forked loop
                 return (False, "UNCLOSED_LOOP")
 
         for group_type, group_counts in group_verts.items():
             if group_type == "IFCARCINDEX":
                 for group_count in group_counts.values():
-                    if group_count != 3: # Each arc needs 3 verts
+                    if group_count != 3:  # Each arc needs 3 verts
                         return (False, "3POINT_ARC")
             elif group_type == "IFCCIRCLE":
                 for group_count in group_counts.values():
-                    if group_count != 2: # Each circle needs 2 verts
+                    if group_count != 2:  # Each circle needs 2 verts
                         return (False, "CIRCLE")
 
         loop_edges = set(bm.edges)
@@ -269,7 +276,7 @@ class Helper:
         inner_loops.remove(outer_loop)
 
         # Copy vectors to prevent random data mangling after bmesh is freed.
-        points = [Vector(list(v.co)) for v in bm.verts]
+        points = [v.co.copy() for v in bm.verts]
 
         bm.to_mesh(mesh)
         mesh.update()

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

@@ -324,8 +324,8 @@ class UpdateRepresentation(bpy.types.Operator, Operator):
                 # We are explicitly casting to a tessellation, so remove all parametric materials.
                 element_type = ifcopenshell.util.element.get_type(product)
                 if element_type:  # Some invalid IFCs use material sets without a type.
-                    ifcopenshell.api.run("material.unassign_material", tool.Ifc.get(), 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
@@ -908,7 +908,7 @@ class OverrideDuplicateMove(bpy.types.Operator):
                     if parts:
                         index = DuplicateMoveLinkedAggregate.get_max_index(parts)
                         index += 1
-                        pset = tool.Ifc.get().by_id(pset['id'])
+                        pset = tool.Ifc.get().by_id(pset["id"])
                         ifcopenshell.api.run(
                             "pset.edit_pset",
                             tool.Ifc.get(),
@@ -976,26 +976,23 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
             if parts:
                 index = DuplicateMoveLinkedAggregate.get_max_index(parts)
                 add_linked_aggregate_pset(element, index)
-                index +=1
+                index += 1
                 for part in parts:
                     if part.is_a("IfcElementAssembly"):
                         select_objects_and_add_data(part)
                     else:
                         add_linked_aggregate_pset(part, index)
                         index += 1
-                        
+
                     obj = tool.Ifc.get_object(part)
                     obj.select_set(True)
-                    
-                    
+
         def add_linked_aggregate_pset(part, index):
             pset = ifcopenshell.util.element.get_pset(part, self.pset_name)
-        
+
             if not pset:
-                pset = ifcopenshell.api.run(
-                    "pset.add_pset", tool.Ifc.get(), product=part, name=self.pset_name
-                )
-            
+                pset = ifcopenshell.api.run("pset.add_pset", tool.Ifc.get(), product=part, name=self.pset_name)
+
                 ifcopenshell.api.run(
                     "pset.edit_pset",
                     tool.Ifc.get(),
@@ -1018,7 +1015,9 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
                 return
 
             linked_aggregate_group = ifcopenshell.api.run("group.add_group", tool.Ifc.get(), Name=self.group_name)
-            ifcopenshell.api.run("group.assign_group", tool.Ifc.get(), products=[element], group=linked_aggregate_group)
+            ifcopenshell.api.run(
+                "group.assign_group", tool.Ifc.get(), products=[element], group=linked_aggregate_group
+            )
 
         def custom_incremental_naming_for_element_assembly(old_to_new):
             for new in old_to_new.values():
@@ -1029,21 +1028,20 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
                         if r.is_a("IfcRelAssignsToGroup")
                         if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
                     ][0]
-                
+
                     number = len(group_elements) - 1
                     number = f"{number:02d}"
                     new_obj = tool.Ifc.get_object(new[0])
-                    pattern1 = r'_\d'
+                    pattern1 = r"_\d"
                     if re.findall(pattern1, new_obj.name):
                         split_name = new_obj.name.split("_")
                         new_obj.name = split_name[0] + "_" + number
                         continue
-                    pattern2 = r'\.\d{3}'
+                    pattern2 = r"\.\d{3}"
                     if re.findall(pattern2, new_obj.name):
                         split_name = new_obj.name.split(".")
                         new_obj.name = split_name[0] + "_" + number
 
-             
         if len(context.selected_objects) != 1:
             return {"FINISHED"}
 
@@ -1065,7 +1063,7 @@ 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)
-        
+
         # Recreate aggregate relationship
         for old in old_to_new.keys():
             if old.is_a("IfcElementAssembly"):
@@ -1075,17 +1073,15 @@ class DuplicateMoveLinkedAggregate(bpy.types.Operator):
 
         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]
+        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):
@@ -1134,9 +1130,9 @@ class RefreshLinkedAggregate(bpy.types.Operator):
             original_names[group] = {}
 
             pset = ifcopenshell.util.element.get_pset(element, self.pset_name)
-            index = pset['Index']                    
+            index = pset["Index"]
             original_names[group][index] = tool.Ifc.get_object(element).name
-            
+
             parts = ifcopenshell.util.element.get_parts(element)
             if parts:
                 for part in parts:
@@ -1144,20 +1140,22 @@ class RefreshLinkedAggregate(bpy.types.Operator):
                         original_names | get_original_names(part)
                     else:
                         try:
-                          pset = ifcopenshell.util.element.get_pset(part, self.pset_name)
+                            pset = ifcopenshell.util.element.get_pset(part, self.pset_name)
                         except:
-                          continue
-                        index = pset['Index']                    
+                            continue
+                        index = pset["Index"]
                         original_names[group][index] = tool.Ifc.get_object(part).name
-                    
+
             return original_names
 
         def set_original_name(obj, original_names):
             element = tool.Ifc.get_entity(obj)
             aggregate = ifcopenshell.util.element.get_aggregate(element)
-            if ifcopenshell.util.element.get_parts(element): # if element has parts it means it is the base of and aggregate or sub-aggregate
+            if ifcopenshell.util.element.get_parts(
+                element
+            ):  # if element has parts it means it is the base of and aggregate or sub-aggregate
                 aggregate = element
-                
+
             group = [
                 r.RelatingGroup
                 for r in getattr(aggregate, "HasAssignments", []) or []
@@ -1166,18 +1164,16 @@ class RefreshLinkedAggregate(bpy.types.Operator):
             ]
             if not group:
                 return
-            
+
             group = group[0].id()
-                
+
             pset = ifcopenshell.util.element.get_pset(element, self.pset_name)
-            index = pset['Index']
-            
+            index = pset["Index"]
+
             try:
                 obj.name = original_names[group][index]
             except:
                 return
-            
-            
 
         def get_element_assembly(element):
             if element.is_a("IfcElementAssembly"):
@@ -1263,9 +1259,9 @@ class RefreshLinkedAggregate(bpy.types.Operator):
                 selected_matrix = selected_obj.matrix_world
                 object_duplicate = tool.Ifc.get_object(element)
                 duplicate_matrix = object_duplicate.matrix_world.decompose()
-                
+
                 original_names = get_original_names(element)
-                
+
                 delete_objects(element)
 
                 for obj in context.selected_objects:
@@ -1273,31 +1269,33 @@ 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)
+                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
-                    
+
                 for old, new in old_to_new.items():
                     if element_aggregate and new[0].is_a("IfcElementAssembly"):
                         new_aggregate = ifcopenshell.util.element.get_aggregate(new[0])
 
                         if not new_aggregate:
                             blenderbim.core.aggregate.assign_object(
-                                                        tool.Ifc,
-                                                        tool.Aggregate,
-                                                        tool.Collector,
-                                                        relating_obj=tool.Ifc.get_object(element_aggregate),
-                                                        related_obj=tool.Ifc.get_object(new[0]),
-                                                    )
-                
+                                tool.Ifc,
+                                tool.Aggregate,
+                                tool.Collector,
+                                relating_obj=tool.Ifc.get_object(element_aggregate),
+                                related_obj=tool.Ifc.get_object(new[0]),
+                            )
+
                 for old, new in old_to_new.items():
                     new_obj = tool.Ifc.get_object(new[0])
                     set_original_name(new_obj, original_names)
-                        
+
         blenderbim.bim.handler.refresh_ui_data()
 
         operator_time = time() - refresh_start_time
@@ -1445,7 +1443,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/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/operator.py

@@ -118,7 +118,7 @@ class AddMaterial(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.add_material"
     bl_label = "Add Material"
     bl_options = {"REGISTER", "UNDO"}
-    obj: bpy.props.StringProperty()
+    obj: bpy.props.StringProperty(name="Material Name")
     name: bpy.props.StringProperty(default="Default")
 
     def invoke(self, context, event):

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

@@ -175,7 +175,7 @@ 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")
+            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/decorator.py

@@ -23,6 +23,7 @@ from math import sin, cos, radians
 from bpy.types import SpaceView3D
 from mathutils import Vector, Matrix
 from gpu_extras.batch import batch_for_shader
+from typing import Union
 
 
 ERROR_ELEMENTS_COLOR = (1, 0.2, 0.322, 1)  # RED
@@ -35,15 +36,6 @@ def transparent_color(color, alpha=0.1):
     return color
 
 
-def bm_check_vertex_in_groups(vertex, deform_layer, groups):
-    """returns tuple boolean (whether vertex is in any of the groups)
-    and related group index"""
-    for group_index in vertex[deform_layer].keys():
-        if group_index in groups:
-            return True, group_index
-    return False, None
-
-
 class ProfileDecorator:
     installed = None
 
@@ -148,12 +140,12 @@ class ProfileDecorator:
             # deform_layer is None if there are no verts assigned to vertex groups
             # even if there are vertex groups in the obj.vertex_groups
             if deform_layer:
-                is_arc, group_index = bm_check_vertex_in_groups(vertex, deform_layer, arc_groups)
+                is_arc, group_index = tool.Blender.bmesh_check_vertex_in_groups(vertex, deform_layer, arc_groups)
                 if is_arc:
                     arcs.setdefault(group_index, []).append(vertex)
                     special_vertex_indices[vertex.index] = group_index
 
-                is_circle, group_index = bm_check_vertex_in_groups(vertex, deform_layer, circle_groups)
+                is_circle, group_index = tool.Blender.bmesh_check_vertex_in_groups(vertex, deform_layer, circle_groups)
                 if is_circle:
                     circles.setdefault(group_index, []).append(vertex)
                     special_vertex_indices[vertex.index] = group_index

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
@@ -273,7 +277,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 +301,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):
@@ -510,7 +515,7 @@ def ensure_material_assigned(usecase_path, ifc_file, settings):
     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"):
@@ -546,7 +551,7 @@ def ensure_material_assigned(usecase_path, ifc_file, settings):
 
 
 def ensure_material_unassigned(usecase_path, ifc_file, settings):
-    elements = [settings["product"]]
+    elements = settings["products"]
     if elements[0].is_a("IfcElementType"):
         elements.extend(ifcopenshell.util.element.get_types(elements[0]))
     for element in elements:

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/slab.py

@@ -20,17 +20,22 @@ import bpy
 import json
 import bmesh
 import ifcopenshell
-import ifcopenshell.util.type
-import ifcopenshell.util.unit
+import ifcopenshell.api
 import ifcopenshell.util.element
+import ifcopenshell.util.placement
+import ifcopenshell.util.representation
+import ifcopenshell.util.unit
+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):
@@ -110,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):
@@ -173,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(
@@ -246,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:
@@ -698,9 +714,7 @@ class EditExtrusionProfile(bpy.types.Operator, tool.Ifc.Operator):
         new_footprint = ifcopenshell.api.run(
             "geometry.add_footprint_representation", tool.Ifc.get(), context=footprint_context, curves=curves
         )
-        old_footprint = ifcopenshell.util.representation.get_representation(
-            element, "Plan", "FootPrint", "SKETCH_VIEW"
-        )
+        old_footprint = ifcopenshell.util.representation.get_representation(element, "Plan", "FootPrint", "SKETCH_VIEW")
         if old_footprint:
             for inverse in tool.Ifc.get().get_inverse(old_footprint):
                 ifcopenshell.util.element.replace_attribute(inverse, old_footprint, new_footprint)

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

@@ -54,8 +54,10 @@ 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"]
-            props.type_class = ifc_class
-            bpy.ops.bim.load_type_thumbnails(ifc_class=ifc_class, offset=0, limit=9)
+        else:
+            ifc_class = AuthoringData.data["ifc_element_type"]
+        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)
 
     def draw(self, context):

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

@@ -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")

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

@@ -113,6 +113,10 @@ class CreateProject(bpy.types.Operator):
         if tool.Blender.is_default_scene():
             for obj in bpy.data.objects:
                 bpy.data.objects.remove(obj)
+            for mesh in bpy.data.meshes:
+                bpy.data.meshes.remove(mesh)
+            for mat in bpy.data.materials:
+                bpy.data.materials.remove(mat)
         core.create_project(tool.Ifc, tool.Project, schema=props.export_schema, template=template)
         tool.Blender.register_toolbar()
 
@@ -856,7 +860,10 @@ class LinkIfc(bpy.types.Operator):
                 continue
             new = context.scene.BIMProjectProperties.links.add()
             if self.use_relative_path:
-                filepath = os.path.relpath(filepath, bpy.path.abspath("//")).replace("\\", "/")
+                try:
+                    filepath = os.path.relpath(filepath, bpy.path.abspath("//")).replace("\\", "/")
+                except:
+                    pass  # Perhaps on another drive or something
             new.name = filepath
             bpy.ops.bim.load_link(filepath=filepath, false_origin=self.false_origin)
         print(f"Finished linking {len(files)} IFCs", time.time() - start)
@@ -1287,6 +1294,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)
@@ -1322,6 +1331,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)
@@ -1442,7 +1454,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:
@@ -1905,32 +1920,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)]
 
@@ -1941,20 +1956,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"}
 
@@ -1976,11 +1991,11 @@ 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"}

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

@@ -25,8 +25,16 @@ from shapely.geometry import Polygon
 from shapely.ops import unary_union
 import blenderbim.tool as tool
 import ifcopenshell
+import ifcopenshell.geom
+import ifcopenshell.util.element
 from blenderbim.bim.module.pset.calc_quantity_function_mapper import mapper
 import blenderbim.bim
+from typing import Literal, Union, Optional
+
+
+AxisType = Literal["x", "y", "z"]
+VectorTuple = tuple[float, float, float]
+QuanityTypes = Literal["Q_LENGTH", "Q_AREA", "Q_VOLUME"]
 
 
 class QtoCalculator:
@@ -45,7 +53,7 @@ class QtoCalculator:
                 else:
                     self.mapping_dict[key][item] = None
 
-    def calculate_quantity(self, qto_name, quantity_name, obj):
+    def calculate_quantity(self, qto_name: str, quantity_name: str, obj: bpy.types.Object) -> float:
         """calculates the value of the quantity in the project units"""
         string = "self.mapping_dict[qto_name][quantity_name](obj"
         if isinstance(mapper[qto_name][quantity_name], dict):
@@ -54,11 +62,13 @@ class QtoCalculator:
             args = ""
         string += args
         string += ")"
-        value = eval(string)
+        value: float = eval(string)
 
         return tool.Qto.convert_to_project_units(value, qto_name, quantity_name) or value
 
-    def guess_quantity(self, prop_name, alternative_prop_names, obj):
+    def guess_quantity(
+        self, prop_name: str, alternative_prop_names: list[str], obj: bpy.types.Object
+    ) -> Union[float, None]:
         """guess the value of the quantity by name, returns the value in the project units"""
         prop_name = prop_name.lower()
         alternative_prop_names = [p.lower() for p in alternative_prop_names]
@@ -89,7 +99,7 @@ class QtoCalculator:
         if value is None:
             return
 
-        unit_type_keywords = {
+        unit_type_keywords: dict[str, QuanityTypes] = {
             "length": "Q_LENGTH",
             "width": "Q_LENGTH",
             "height": "Q_LENGTH",
@@ -102,10 +112,10 @@ class QtoCalculator:
         unit_type = next(unit_type_keywords[k] for k in unit_type_keywords if k in prop_name)
         return tool.Qto.convert_to_project_units(value, quantity_type=unit_type) or value
 
-    def get_units(self, o, vg_index):
+    def get_units(self, o: bpy.types.Object, vg_index: int) -> int:
         return len([v for v in o.data.vertices if vg_index in [g.group for g in v.groups]])
 
-    def get_linear_length(self, o):
+    def get_linear_length(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the length of the longest edge of the object bounding box
 
         :param blender-object o: Blender Object
@@ -116,7 +126,7 @@ class QtoCalculator:
         z = (Vector(o.bound_box[1]) - Vector(o.bound_box[0])).length
         return max(x, y, z)
 
-    def get_length(self, o, vg_index=None, main_axis: str = ""):
+    def get_length(self, o: bpy.types.Object, vg_index: Optional[int] = None, main_axis: str = "") -> float:
         if vg_index is None:
             x = (Vector(o.bound_box[4]) - Vector(o.bound_box[0])).length
             y = (Vector(o.bound_box[3]) - Vector(o.bound_box[0])).length
@@ -141,23 +151,23 @@ class QtoCalculator:
             length += self.get_edge_distance(o, e)
         return length
 
-    def get_stair_length(self, obj):
+    def get_stair_length(self, obj: bpy.types.Object) -> float:
         length = self.get_length(obj)
         height = self.get_height(obj)
         stair_length = math.sqrt(pow(length, 2) + pow(height, 2))
         return stair_length
 
-    def get_net_stair_area(self, obj):
+    def get_net_stair_area(self, obj: bpy.types.Object) -> float:
         OBB_obj = self.get_OBB_object(obj)
         OBB_net_footprint_area = self.get_net_footprint_area(OBB_obj)
         return OBB_net_footprint_area
 
-    def get_gross_stair_area(self, obj):
+    def get_gross_stair_area(self, obj: bpy.types.Object) -> float:
         OBB_obj = self.get_OBB_object(obj)
         OBB_gross_footprint_area = self.get_gross_footprint_area(OBB_obj)
         return OBB_gross_footprint_area
 
-    def get_parametric_axis(self, obj):
+    def get_parametric_axis(self, obj: bpy.types.Object) -> Literal["AXIS2", "AXIS3", None]:
         relating_type = ifcopenshell.util.element.get_type(tool.Ifc.get_entity(obj))
         if relating_type:
             parametric = ifcopenshell.util.element.get_psets(relating_type).get("EPset_Parametric")
@@ -172,7 +182,7 @@ class QtoCalculator:
                     return None
         return None
 
-    def get_covering_gross_area(self, obj):
+    def get_covering_gross_area(self, obj: bpy.types.Object) -> float:
         get_parametric_axis = self.get_parametric_axis(obj)
         if not get_parametric_axis:
             return self.get_gross_footprint_area(obj)
@@ -181,7 +191,7 @@ class QtoCalculator:
         elif get_parametric_axis == "AXIS3":
             return self.get_gross_footprint_area(obj)
 
-    def get_covering_net_area(self, obj):
+    def get_covering_net_area(self, obj: bpy.types.Object) -> float:
         get_parametric_axis = self.get_parametric_axis(obj)
         if not get_parametric_axis:
             return self.get_net_footprint_area(obj)
@@ -190,7 +200,7 @@ class QtoCalculator:
         elif get_parametric_axis == "AXIS3":
             return self.get_net_footprint_area(obj)
 
-    def get_covering_width(self, obj):
+    def get_covering_width(self, obj: bpy.types.Object) -> float:
         get_parametric_axis = self.get_parametric_axis(obj)
         if not get_parametric_axis:
             return self.get_height(obj)
@@ -199,7 +209,7 @@ class QtoCalculator:
         elif get_parametric_axis == "AXIS3":
             return self.get_height(obj)
 
-    def get_width(self, o):
+    def get_width(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the width of the object bounding box
 
         :param blender-object o: blender object
@@ -209,7 +219,7 @@ class QtoCalculator:
         y = (Vector(o.bound_box[3]) - Vector(o.bound_box[0])).length
         return min(x, y)
 
-    def get_height(self, o):
+    def get_height(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the height of the object bounding box
 
         :param blender-object o: blender object
@@ -217,64 +227,77 @@ class QtoCalculator:
         """
         return (Vector(o.bound_box[1]) - Vector(o.bound_box[0])).length
 
-    def get_opening_height(self, obj):
+    def get_opening_height(self, obj: bpy.types.Object) -> float:
         if self.is_opening_horizontal(obj):
             return self.get_width(obj)
         else:
             return self.get_height(obj)
 
-    def get_opening_depth(self, obj):
+    def get_opening_depth(self, obj: bpy.types.Object) -> float:
         if self.is_opening_horizontal(obj):
             return self.get_height(obj)
         else:
             return self.get_width(obj)
 
-    def get_opening_mapping_area(self, obj):
+    def get_opening_mapping_area(self, obj: bpy.types.Object) -> float:
         if self.is_opening_horizontal(obj):
             return self.get_net_footprint_area(obj)
         else:
             return self.get_net_side_area(obj)
 
-    def get_finish_ceiling_height(self, obj):
-        space_height = self.get_height(obj)
+    def get_finish_ceiling_height(self, obj: bpy.types.Object) -> float:
         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_finish_floor_height(self, obj):
+    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)
 
-    def get_ceiling_height(self, 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):
+    def get_net_perimeter(self, o: bpy.types.Object) -> float:
         parsed_edges = []
         shared_edges = []
         perimeter = 0
@@ -289,7 +312,7 @@ class QtoCalculator:
             perimeter -= self.get_edge_key_distance(o, edge_key)
         return perimeter
 
-    def get_gross_perimeter(self, o):
+    def get_gross_perimeter(self, o: bpy.types.Object) -> float:
         element = tool.Ifc.get_entity(o)
         mesh = self.get_gross_element_mesh(element)
         gross_obj = bpy.data.objects.new("GrossObj", mesh)
@@ -297,15 +320,15 @@ class QtoCalculator:
         self.delete_obj(gross_obj)
         return gross_perimeter
 
-    def get_space_net_perimeter(self, obj):
+    def get_space_net_perimeter(self, obj: bpy.types.Object) -> float:
         pass
 
-    def get_rectangular_perimeter(self, obj):
+    def get_rectangular_perimeter(self, obj: bpy.types.Object) -> float:
         length = self.get_length(obj, main_axis="x")
         height = self.get_height(obj)
         return (length + height) * 2
 
-    def get_lowest_polygons(self, o):
+    def get_lowest_polygons(self, o: bpy.types.Object) -> list[bpy.types.MeshPolygon]:
         lowest_polygons = []
         lowest_z = None
         for polygon in o.data.polygons:
@@ -321,7 +344,7 @@ class QtoCalculator:
                 lowest_z = z
         return lowest_polygons
 
-    def get_highest_polygons(self, o):
+    def get_highest_polygons(self, o: bpy.types.Object) -> list[bpy.types.MeshPolygon]:
         highest_polygons = []
         highest_z = None
         for polygon in o.data.polygons:
@@ -337,13 +360,13 @@ class QtoCalculator:
                 highest_z = z
         return highest_polygons
 
-    def get_edge_key_distance(self, obj, edge_key):
+    def get_edge_key_distance(self, obj: bpy.types.Object, edge_key: tuple[int, int]) -> float:
         return (obj.data.vertices[edge_key[1]].co - obj.data.vertices[edge_key[0]].co).length
 
-    def get_edge_distance(self, obj, edge):
+    def get_edge_distance(self, obj: bpy.types.Object, edge: bpy.types.MeshEdge) -> float:
         return (obj.data.vertices[edge.vertices[1]].co - obj.data.vertices[edge.vertices[0]].co).length
 
-    def get_net_floor_area(self, obj):
+    def get_net_floor_area(self, obj: bpy.types.Object) -> float:
         decompositions = self.get_obj_decompositions(obj)
         if not decompositions:
             return self.get_gross_footprint_area(obj)
@@ -359,7 +382,7 @@ class QtoCalculator:
 
         return total_net_floor_area
 
-    def get_gross_ceiling_area(self, obj):
+    def get_gross_ceiling_area(self, obj: bpy.types.Object) -> float:
         decompositions = self.get_obj_decompositions(obj)
         if not decompositions:
             return self.get_gross_top_area(obj)
@@ -367,15 +390,15 @@ 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)
 
         return total_gross_ceiling_area
 
-    def get_net_ceiling_area(self, obj):
+    def get_net_ceiling_area(self, obj: bpy.types.Object) -> float:
         decompositions = self.get_obj_decompositions(obj)
         if not decompositions:
             return self.get_net_top_area(obj)
@@ -383,19 +406,19 @@ 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)
 
         return total_net_ceiling_area
 
-    def get_space_net_volume(self, obj):
+    def get_space_net_volume(self, obj: bpy.types.Object) -> float:
         decompositions = self.get_obj_decompositions(obj)
         if not decompositions:
             return self.get_gross_volume(obj)
@@ -410,7 +433,7 @@ class QtoCalculator:
 
         return total_space_net_volume
 
-    def get_net_footprint_area(self, o):
+    def get_net_footprint_area(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the area of the footprint of the object, excluding any holes
 
         :param blender-object o: blender object
@@ -421,7 +444,7 @@ class QtoCalculator:
             area += polygon.area
         return area
 
-    def get_gross_footprint_area(self, o):
+    def get_gross_footprint_area(self, o: bpy.types.Object) -> float:
         """_summary_: Returns the area of the footprint of the object, without related opening and excluding any holes
 
         :param blender-object o: blender object
@@ -437,7 +460,7 @@ class QtoCalculator:
         self.delete_mesh(mesh)
         return gross_footprint_area
 
-    def get_net_roofprint_area(self, o):
+    def get_net_roofprint_area(self, o: bpy.types.Object) -> float:
         # Is roofprint the right word? Couldn't think of anything better - vulevukusej
         """_summary_: Returns the area of the net roofprint of the object, excluding any holes
 
@@ -449,7 +472,7 @@ class QtoCalculator:
             area += polygon.area
         return area
 
-    def get_side_area(self, o):
+    def get_side_area(self, o: bpy.types.Object) -> float:
         # There are a few dumb options for this, but this seems the dumbest
         # until I get more practical experience on what works best.
         x = (Vector(o.bound_box[4]) - Vector(o.bound_box[0])).length
@@ -457,8 +480,7 @@ class QtoCalculator:
         z = (Vector(o.bound_box[1]) - Vector(o.bound_box[0])).length
         return max(x * z, y * z)
 
-    def get_cross_section_area(self, obj):
-        element = tool.Ifc.get_entity(obj)
+    def get_cross_section_area(self, obj: bpy.types.Object) -> float:
         representation = tool.Ifc.get().by_id(obj.data.BIMMeshProperties.ifc_definition_id)
         item = representation.Items[0]
         while True:
@@ -474,7 +496,7 @@ class QtoCalculator:
                 return area
         # TODO handle other types of sections, and then fall back to mesh parsing
 
-    def get_gross_surface_area(self, o, vg_index=None):
+    def get_gross_surface_area(self, o: bpy.types.Object, vg_index: Optional[int] = None) -> float:
         if vg_index is None:
             if not self.has_openings(o):
                 return self.get_net_surface_area(o)
@@ -492,29 +514,29 @@ class QtoCalculator:
                 area += polygon.area
         return area
 
-    def get_net_surface_area(self, obj):
+    def get_net_surface_area(self, obj: bpy.types.Object) -> float:
         return self.get_mesh_area(obj.data)
 
-    def get_mesh_area(self, mesh):
+    def get_mesh_area(self, mesh: bpy.types.Mesh) -> float:
         area = 0
         for polygon in mesh.polygons:
             area += polygon.area
         return area
 
-    def is_polygon_in_vg(self, polygon, vertices_in_vg):
+    def is_polygon_in_vg(self, polygon: bpy.types.MeshPolygon, vertices_in_vg: list[bpy.types.MeshVertex]) -> bool:
         for v in polygon.vertices:
             if v not in vertices_in_vg:
                 return False
         return True
 
-    def get_net_volume(self, o):
+    def get_net_volume(self, o: bpy.types.Object) -> float:
         o_mesh = bmesh.new()
         o_mesh.from_mesh(o.data)
         volume = o_mesh.calc_volume()
         o_mesh.free()
         return volume
 
-    def get_gross_volume(self, o):
+    def get_gross_volume(self, o: bpy.types.Object) -> float:
         if not self.has_openings(o):
             return self.get_net_volume(o)
 
@@ -529,16 +551,18 @@ class QtoCalculator:
 
         return gross_volume
 
-    def has_openings(self, obj):
+    def has_openings(
+        self, obj: bpy.types.Object
+    ) -> Union[ifcopenshell.entity_instance, list[ifcopenshell.entity_instance]]:
         element = tool.Ifc.get_entity(obj)
         return element and getattr(element, "HasOpenings", [])
 
-    def get_obj_decompositions(self, obj):
+    def get_obj_decompositions(self, obj: bpy.types.Object) -> list[ifcopenshell.entity_instance]:
         element = tool.Ifc.get_entity(obj)
         decompositions = ifcopenshell.util.element.get_decomposition(element)
         return decompositions
 
-    def get_gross_weight(self, obj):
+    def get_gross_weight(self, obj: bpy.types.Object) -> Union[float, None]:
         obj_mass_density = self.get_obj_mass_density(obj)
         if not obj_mass_density:
             return
@@ -546,7 +570,7 @@ class QtoCalculator:
         gross_weight = obj_mass_density * gross_volume
         return gross_weight
 
-    def get_net_weight(self, obj):
+    def get_net_weight(self, obj: bpy.types.Object) -> Union[float, None]:
         obj_mass_density = self.get_obj_mass_density(obj)
         if not obj_mass_density:
             return
@@ -554,7 +578,7 @@ class QtoCalculator:
         net_weight = obj_mass_density * net_volume
         return net_weight
 
-    def get_obj_mass_density(self, obj):
+    def get_obj_mass_density(self, obj: bpy.types.Object) -> Union[float, None]:
         entity = tool.Ifc.get_entity(obj)
         material = ifcopenshell.util.element.get_material(entity)
         if material is None:
@@ -629,7 +653,7 @@ class QtoCalculator:
     #         volume += v1.dot(v2.cross(v3)) / 6.0
     # return volume
 
-    def get_opening_type(self, opening, obj):
+    def get_opening_type(self, opening: bpy.types.Object, obj: bpy.types.Object) -> Literal["OPENING", "RECESS"]:
         """_summary_: Returns the opening type - OPENING / RECESS
 
         :param blender-object opening: blender opening object
@@ -649,14 +673,22 @@ class QtoCalculator:
         return "OPENING" if ray_intersections % 2 == 0 else "RECESS"
 
     def get_opening_area(
-        self, obj, angle_z1: int = 45, angle_z2: int = 135, min_area: int = 0, ignore_recesses: bool = False
-    ):
+        self,
+        obj: bpy.types.Object,
+        angle_z1: int = 45,
+        angle_z2: int = 135,
+        min_area: int = 0,
+        ignore_recesses: bool = False,
+    ) -> float:
         """_summary_: Returns the lateral area of the openings in the object.
 
         :param obj: blender object
-        :param int angle_z1: Angle measured from the positive z-axis to the normal-vector of the opening area. Openings with a normal_vector lower than this value will be ignored, defaults to 45
-        :param int angle_z2: Angle measured from the positive z-axis to the normal-vector of the opening area. Openings with a normal_vector greater than this value will be ignored,defaults to 135
-        :param float min_area: Minimum opening area to consider.  Values lower than this will be ignored, defaults to 0
+        :param int angle_z1: Angle measured from the positive z-axis to the normal-vector of the opening area.
+            Openings with a normal_vector lower than this value will be ignored, defaults to 45
+        :param int angle_z2: Angle measured from the positive z-axis to the normal-vector of the opening area.
+            Openings with a normal_vector greater than this value will be ignored,defaults to 135
+        :param float min_area: Minimum opening area to consider.  Values lower than this will be ignored,
+            defaults to 0
         :param bool ignore_recesses: Toggle whether recess areas should be considered, defaults to False
         :return float: Opening Area
         """
@@ -702,14 +734,14 @@ class QtoCalculator:
 
     def get_lateral_area(
         self,
-        obj,
+        obj: bpy.types.Object,
         subtract_openings: bool = True,
         exclude_end_areas: bool = False,
         exclude_side_areas: bool = False,
         angle_z1: int = 45,
         angle_z2: int = 135,
         main_axis: str = "",
-    ):
+    ) -> float:
         """_summary_
 
         :param blender-object obj: blender object, bpy.types.Object
@@ -760,7 +792,7 @@ class QtoCalculator:
             area += polygon.area
         return area + total_opening_area
 
-    def get_gross_side_area(self, obj):
+    def get_gross_side_area(self, obj: bpy.types.Object) -> float:
         if not self.has_openings(obj):
             return self.get_net_side_area(obj)
 
@@ -768,15 +800,15 @@ class QtoCalculator:
 
         return gross_side_area
 
-    def get_net_side_area(self, obj):
+    def get_net_side_area(self, obj: bpy.types.Object) -> float:
         net_side_area = self.get_lateral_area(obj, exclude_end_areas=True, main_axis="x") / 2
         return net_side_area
 
-    def get_outer_surface_area(self, obj):
+    def get_outer_surface_area(self, obj: bpy.types.Object) -> float:
         outer_surface_area = self.get_lateral_area(obj, exclude_end_areas=True, angle_z1=0, angle_z2=360)
         return outer_surface_area
 
-    def get_end_area(self, obj):
+    def get_end_area(self, obj: bpy.types.Object) -> float:
         element = tool.Ifc.get_entity(obj)
         gross_mesh = self.get_gross_element_mesh(element)
         gross_obj = bpy.data.objects.new("MyObject", gross_mesh)
@@ -790,7 +822,7 @@ class QtoCalculator:
 
         return end_area
 
-    def get_gross_top_area(self, obj, angle: int = 45):
+    def get_gross_top_area(self, obj: bpy.types.Object, angle: int = 45) -> float:
         """_summary_: Returns the gross top area of the object.
 
         :param blender-object obj: blender object
@@ -827,12 +859,14 @@ class QtoCalculator:
         return area + opening_area
 
     # curently net top area is larger then projected area, because its taking into account internal polygons, or window sills
-    def get_net_top_area(self, obj, angle: int = 45, ignore_internal: bool = True):
+    def get_net_top_area(self, obj: bpy.types.Object, angle: int = 45, ignore_internal: bool = True) -> float:
         """_summary_: Returns the net top area of the object.
 
         :param blender-object obj: blender object
-        :param int angle: Angle measured from the positive z-axis to the normal-vector of the area. Values lower than this will be ignored, defaults to 45
-        :param bool ignore_internal: Toggle whether internal areas should be subtracted (Like window sills), defaults to True
+        :param int angle: Angle measured from the positive z-axis to the normal-vector of the area.
+            Values lower than this will be ignored, defaults to 45
+        :param bool ignore_internal: Toggle whether internal areas should be subtracted (Like window sills),
+            defaults to True
         :return float: Net Top Area
         """
         z_axis = (0, 0, 1)
@@ -852,11 +886,11 @@ class QtoCalculator:
 
         return area
 
-    def get_projected_area(self, obj, projection_axis: str = "z", is_gross: bool = True):
+    def get_projected_area(self, obj, projection_axis: AxisType = "z", is_gross: bool = True) -> float:
         """_summary_: Returns the projected area of the object.
 
         :param blender-object obj: blender object
-        :param str projection_axis: Axis to project the area onto. Can be "X", "Y" or "Z"
+        :param str projection_axis: Axis to project the area onto. Can be "x", "y" or "z"
         :param bool is_gross: if True, the projected area will include openings, if False, the projected area will exclude openings
         :return float: Projected Area
         """
@@ -891,7 +925,7 @@ class QtoCalculator:
             return projected_polygon.area + void_area
         return projected_polygon.area
 
-    def get_OBB_object(self, obj):
+    def get_OBB_object(self, obj: bpy.types.Object) -> bpy.types.Object:
         """_summary_: Returns the Oriented-Bounding-Box (OBB) of the object.
 
         :param blender-object obj: Blender Object
@@ -932,7 +966,7 @@ class QtoCalculator:
 
         return new_OBB_object
 
-    def get_AABB_object(self, obj):
+    def get_AABB_object(self, obj: bpy.types.Object) -> bpy.types.Object:
         """_summary_: Returns the Axis-Aligned-Bounding-Box (AABB) of the object.
 
         :param blender-object obj: Blender Object
@@ -988,12 +1022,12 @@ class QtoCalculator:
 
     def get_bisected_obj(
         self,
-        obj,
-        plane_co_pos,
-        plane_no_pos,
-        plane_co_neg,
-        plane_no_neg,
-    ):
+        obj: bpy.types.Object,
+        plane_co_pos: VectorTuple,
+        plane_no_pos: VectorTuple,
+        plane_co_neg: VectorTuple,
+        plane_no_neg: VectorTuple,
+    ) -> bpy.types.Object:
         """_summary_: Returns the object bisected by two planes.
 
         :param blender-object obj: Blender Object
@@ -1031,11 +1065,12 @@ class QtoCalculator:
 
         return bis_obj
 
-    def get_total_contact_area(self, obj, class_filter: str = ["IfcElement"]):
+    def get_total_contact_area(self, obj: bpy.types.Object, class_filter: list[str] = ["IfcElement"]) -> float:
         """_summary_: Returns the total contact area of the object with other objects.
 
         :param blender-object obj: Blender Object
-        :param list [] class_filter: A list of classes used to filter the objects to be considered for the calculation. Example: ["IfcWall"] or ["IfcWall", "IfcSlab"]
+        :param list [] class_filter: A list of classes used to filter the objects
+            to be considered for the calculation. Example: ["IfcWall"] or ["IfcWall", "IfcSlab"]
         :return float: Total contact area of the object with other objects.
         """
         total_contact_area = 0
@@ -1046,11 +1081,12 @@ class QtoCalculator:
 
         return total_contact_area
 
-    def get_touching_objects(self, obj, class_filter):
+    def get_touching_objects(self, obj: bpy.types.Object, class_filter: list[str]) -> list[bpy.types.Object]:
         """_summary_: Returns a list of objects that are touching the object.
 
         :param blender-object obj: Blender Object
-        :param list [] class_filter: A list of classes used to filter the objects to be considered for the calculation. Example: ["IfcWall"] or ["IfcWall", "IfcSlab"]
+        :param list [] class_filter: A list of classes used to filter the objects
+            to be considered for the calculation. Example: ["IfcWall"] or ["IfcWall", "IfcSlab"]
         :return list: List of touching objects
         """
         # rotate the object ever so slightly, otherwise bvhtree.overlap won't work properly.  https://blender.stackexchange.com/a/275244/130742
@@ -1094,7 +1130,7 @@ class QtoCalculator:
 
         return touching_objects
 
-    def get_contact_area(self, object1, object2):
+    def get_contact_area(self, object1: bpy.types.Object, object2: bpy.types.Object) -> float:
         """_summary_: Returns the contact area between two objects.
 
         :param blender-object obj: Blender Object
@@ -1109,7 +1145,13 @@ class QtoCalculator:
                 total_area += self.get_intersection_between_polygons(object1, poly1, object2, poly2)
         return total_area
 
-    def get_intersection_between_polygons(self, object1, poly1, object2, poly2):
+    def get_intersection_between_polygons(
+        self,
+        object1: bpy.types.Object,
+        poly1: bpy.types.MeshPolygon,
+        object2: bpy.types.Object,
+        poly2: bpy.types.MeshPolygon,
+    ) -> float:
         """_summary_: Returns the intersection between two polygons.
 
         :param blender-object object1: Blender Object
@@ -1152,7 +1194,9 @@ class QtoCalculator:
             # TopologicalError - Generated Geometry might be invalid
             return 0
 
-    def create_shapely_polygon(self, obj, polygon, trans_matrix):
+    def create_shapely_polygon(
+        self, obj: bpy.types.Object, polygon: bpy.types.MeshPolygon, trans_matrix: Matrix
+    ) -> Polygon:
         """_summary_: Create a shapely polygon
 
         :param blender-object obj: Blender Object
@@ -1171,12 +1215,14 @@ class QtoCalculator:
             polygon_tuples.append((x, y))
         return Polygon(polygon_tuples)
 
-    def get_gross_element_mesh(self, element):
+    def get_gross_element_mesh(self, element: ifcopenshell.entity_instance) -> bpy.types.Mesh:
         settings = ifcopenshell.geom.settings()
         settings.set(settings.DISABLE_OPENING_SUBTRACTIONS, True)
         return self.create_mesh_from_shape(element, settings)
 
-    def create_mesh_from_shape(self, element, settings=None):
+    def create_mesh_from_shape(
+        self, element: ifcopenshell.entity_instance, settings: Optional[ifcopenshell.geom.settings] = None
+    ) -> bpy.types.Mesh:
         if settings is None:
             settings = ifcopenshell.geom.settings()
         shape = ifcopenshell.geom.create_shape(settings, element)
@@ -1203,12 +1249,12 @@ class QtoCalculator:
         mesh.update()
         return mesh
 
-    def get_bmesh_from_mesh(self, mesh):
+    def get_bmesh_from_mesh(self, mesh: bpy.types.Mesh) -> bmesh.types.BMesh:
         bm = bmesh.new()
         bm.from_mesh(mesh)
         return bm
 
-    def get_object_main_axis(self, o):
+    def get_object_main_axis(self, o: bpy.types.Object) -> AxisType:
         """_summary_: Returns the main object axis. Useful for profile-defined objects.
 
         :param blender-object o: Blender Object
@@ -1227,18 +1273,18 @@ class QtoCalculator:
         else:
             return "x"
 
-    def is_opening_horizontal(self, o):
+    def is_opening_horizontal(self, o: bpy.types.Object) -> bool:
         x = (Vector(o.bound_box[4]) - Vector(o.bound_box[0])).length
         y = (Vector(o.bound_box[3]) - Vector(o.bound_box[0])).length
         z = (Vector(o.bound_box[1]) - Vector(o.bound_box[0])).length
 
         return z < x and z < y
 
-    def delete_mesh(self, mesh):
+    def delete_mesh(self, mesh: bpy.types.Mesh) -> None:
         mesh.user_clear()
         bpy.data.meshes.remove(mesh)
 
-    def delete_obj(self, obj):
+    def delete_obj(self, obj: bpy.types.Object) -> None:
         bpy.data.objects.remove(obj, do_unlink=True)
 
 

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/__init__.py

@@ -34,6 +34,7 @@ classes = (
     operator.RemovePropTemplate,
     operator.RemovePsetTemplate,
     operator.RemovePsetTemplateFile,
+    operator.SavePsetTemplateFile,
     prop.PsetTemplate,
     prop.EnumerationValues,
     prop.PropTemplate,

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)

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

@@ -215,7 +215,7 @@ class UnlinkObject(bpy.types.Operator):
     bl_idname = "bim.unlink_object"
     bl_label = "Unlink Object"
     bl_options = {"REGISTER", "UNDO"}
-    obj: bpy.props.StringProperty()
+    obj: bpy.props.StringProperty(name="Object Name")
     should_delete: bpy.props.BoolProperty(name="Delete IFC Element", default=True)
 
     def execute(self, context):
@@ -227,6 +227,7 @@ class UnlinkObject(bpy.types.Operator):
         else:
             objects = context.selected_objects
 
+        objects: list[bpy.types.Object]
         for obj in objects:
             was_active_object = obj == context.active_object
 
@@ -242,6 +243,27 @@ class UnlinkObject(bpy.types.Operator):
                 if obj.data:
                     obj_copy.data = obj.data.copy()
 
+                    # prevent unlinking materials that might be used elsewhere
+                    replacements: dict[bpy.types.Material, bpy.types.Material] = dict()
+                    for material_slot in obj_copy.material_slots:
+                        material = material_slot.material
+                        if material is None:
+                            continue
+
+                        if material in replacements:
+                            material_replacement = replacements[material]
+
+                        # no need to copy non-ifc materials as unlinking won't do anything to them
+                        elif tool.Ifc.get_entity(material) is None and tool.Style.get_style(material) is None:
+                            replacements[material] = material
+                            continue
+
+                        else:
+                            material_replacement = material.copy()
+                            replacements[material] = material_replacement
+
+                        material_slot.material = material_replacement
+
                 tool.Geometry.delete_ifc_object(obj)
 
                 obj = obj_copy

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

@@ -235,7 +235,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 +271,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 +355,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 +384,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 +628,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/operator.py

@@ -330,16 +330,21 @@ class ActivateExternalStyle(bpy.types.Operator, tool.Ifc.Operator):
         style_path = Path(tool.Ifc.resolve_uri(external_style.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)

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

@@ -259,7 +259,7 @@ def update_shading_style(self, context):
             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 - "):
+                if str(error).startswith("Error: Error loading external style for "):
                     return
                 raise error
 

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
@@ -282,7 +283,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 +361,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/operator.py

@@ -357,7 +357,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 +936,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

@@ -127,6 +127,40 @@ 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.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:
+            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):
@@ -432,7 +466,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 +475,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)
 

src/blenderbim/blenderbim/core/brick.py

@@ -74,7 +74,7 @@ def assign_brick_reference(ifc, brick, element=None, library=None, brick_uri=Non
     if not reference:
         reference = ifc.run("library.add_reference", library=library)
         ifc.run("library.edit_reference", reference=reference, attributes=brick.export_brick_attributes(brick_uri))
-    ifc.run("library.assign_reference", product=element, reference=reference)
+    ifc.run("library.assign_reference", products=[element], reference=reference)
     project = brick.get_brickifc_project()
     if not project:
         project = brick.add_brickifc_project(brick.get_namespace(brick_uri))

src/blenderbim/blenderbim/core/covering.py

@@ -47,7 +47,6 @@ def add_instance_flooring_covering_from_cursor(ifc, spatial, model, Type, geomet
     obj = spatial.get_named_obj_from_mesh(name, mesh)
 
     spatial.set_obj_origin_to_cursor_position(obj)
-#    spatial.traslate_obj_to_z_location(obj, z)
     spatial.link_obj_to_active_collection(obj)
     points = spatial.get_2d_vertices_from_obj(obj)
     points = spatial.get_scaled_2d_vertices(points)
@@ -153,7 +152,7 @@ def add_instance_flooring_coverings_from_walls(ifc, spatial, collector, geometry
         spatial.regen_obj_representation(ifc, geometry, obj, body)
 
 def add_instance_ceiling_coverings_from_walls(ifc, spatial, collector, geometry, covering):
-    z = covering.get_z_from_ceiling_height()
+    z = covering.get_z_from_ceiling_height() + spatial.get_active_obj_z()
     union = spatial.get_union_shape_from_selected_objects()
     for i, linear_ring in enumerate(union.interiors):
         poly = spatial.get_buffered_poly_from_linear_ring(linear_ring)

src/blenderbim/blenderbim/core/document.py

@@ -109,8 +109,8 @@ def remove_document(ifc, document_tool, document=None):
 
 
 def assign_document(ifc, product=None, document=None):
-    ifc.run("document.assign_document", product=product, document=document)
+    ifc.run("document.assign_document", products=[product], document=document)
 
 
 def unassign_document(ifc, product=None, document=None):
-    ifc.run("document.unassign_document", product=product, document=document)
+    ifc.run("document.unassign_document", products=[product], document=document)

src/blenderbim/blenderbim/core/drawing.py

@@ -241,7 +241,7 @@ def add_drawing(ifc, collector, drawing, target_view=None, location_hint=None):
         attributes = {"Identification": "X", "Name": drawing_name, "Scope": "DRAWING"}
     ifc.run("document.edit_information", information=information, attributes=attributes)
     ifc.run("document.edit_reference", reference=reference, attributes={"Location": uri})
-    ifc.run("document.assign_document", product=element, document=reference)
+    ifc.run("document.assign_document", products=[element], document=reference)
     drawing.import_drawings()
 
 
@@ -251,7 +251,7 @@ def duplicate_drawing(ifc, drawing_tool, drawing=None, should_duplicate_annotati
     drawing_tool.copy_representation(drawing, new_drawing)
     drawing_tool.set_name(new_drawing, drawing_name)
     group = drawing_tool.get_drawing_group(new_drawing)
-    ifc.run("group.unassign_group", group=group, product=new_drawing)
+    ifc.run("group.unassign_group", group=group, products=[new_drawing])
     new_group = ifc.run("group.add_group")
     ifc.run("group.edit_group", group=new_group, attributes={"Name": drawing_name, "ObjectType": "DRAWING"})
     ifc.run("group.assign_group", group=new_group, products=[new_drawing])
@@ -261,11 +261,11 @@ def duplicate_drawing(ifc, drawing_tool, drawing=None, should_duplicate_annotati
                 continue
             new_annotation = ifc.run("root.copy_class", product=annotation)
             drawing_tool.copy_representation(annotation, new_annotation)
-            ifc.run("group.unassign_group", group=group, product=new_annotation)
+            ifc.run("group.unassign_group", group=group, products=[new_annotation])
             ifc.run("group.assign_group", group=new_group, products=[new_annotation])
 
     old_reference = drawing_tool.get_drawing_document(new_drawing)
-    ifc.run("document.unassign_document", product=new_drawing, document=old_reference)
+    ifc.run("document.unassign_document", products=[new_drawing], document=old_reference)
 
     information = ifc.run("document.add_information")
     uri = drawing_tool.get_default_drawing_path(drawing_name)
@@ -276,7 +276,7 @@ def duplicate_drawing(ifc, drawing_tool, drawing=None, should_duplicate_annotati
         attributes = {"Identification": "X", "Name": drawing_name, "Scope": "DRAWING"}
     ifc.run("document.edit_information", information=information, attributes=attributes)
     ifc.run("document.edit_reference", reference=reference, attributes={"Location": uri})
-    ifc.run("document.assign_document", product=new_drawing, document=reference)
+    ifc.run("document.assign_document", products=[new_drawing], document=reference)
 
     drawing_tool.import_drawings()
     return new_drawing
@@ -388,13 +388,13 @@ def sync_references(ifc, collector, drawing_tool, drawing=None):
         should_delete_existing_annotation = False
         should_create_annotation = False
 
+        # remove annotation only if the reference object was changed
+        # otherwise we rely on the existing annotation
         if annotation:
             if reference_obj and (ifc.is_moved(reference_obj) or ifc.is_edited(reference_obj)):
                 should_delete_existing_annotation = True
-            elif not reference_obj:
-                should_delete_existing_annotation = True
 
-        if reference_obj and (should_delete_existing_annotation or not annotation):
+        if should_delete_existing_annotation or not annotation:
             should_create_annotation = True
 
         if should_delete_existing_annotation:

src/blenderbim/blenderbim/core/geometry.py

@@ -16,10 +16,17 @@
 # You should have received a copy of the GNU General Public License
 # along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
 
-import blenderbim.core.style
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+import blenderbim.core.tool as tool
+
+if TYPE_CHECKING:
+    import bpy
 
 
-def edit_object_placement(ifc, geometry, surveyor, obj=None):
+def edit_object_placement(
+    ifc: tool.Ifc, geometry: tool.Geometry, surveyor: tool.Surveyor, obj: Optional[bpy.types.Object] = None
+) -> None:
     element = ifc.get_entity(obj)
     if not element:
         return
@@ -192,23 +199,25 @@ def select_connection(geometry, connection=None):
 def remove_connection(geometry, connection=None):
     geometry.remove_connection(connection)
 
+
 def get_similar_openings(ifc, opening):
     model = ifc.get()
     all_openings = model.by_type("IfcOpeningElement")
     similar_openings = [o for o in all_openings if o.ObjectPlacement == opening.ObjectPlacement and o != opening]
     return similar_openings
 
+
 def get_similar_openings_building_objs(ifc, similar_openings):
     building_objs = []
     for similar_opening in similar_openings:
         building_objs.append(ifc.get_object(similar_opening.VoidsElements[0].RelatingBuildingElement))
     return building_objs
 
-def edit_similar_opening_placement(geometry, opening = None, similar_openings = None):
+
+def edit_similar_opening_placement(geometry, opening=None, similar_openings=None):
     if not opening or not similar_openings:
         return
     for similar_opening in similar_openings:
         old_placement = similar_opening.ObjectPlacement
         similar_opening.ObjectPlacement = opening.ObjectPlacement
         geometry.delete_opening_object_placement(old_placement)
-

src/blenderbim/blenderbim/core/library.py

@@ -83,8 +83,8 @@ def edit_library_reference(ifc, library):
 
 
 def assign_library_reference(ifc, obj=None, reference=None):
-    ifc.run("library.assign_reference", product=ifc.get_entity(obj), reference=reference)
+    ifc.run("library.assign_reference", products=[ifc.get_entity(obj)], reference=reference)
 
 
 def unassign_library_reference(ifc, obj=None, reference=None):
-    ifc.run("library.unassign_reference", product=ifc.get_entity(obj), reference=reference)
+    ifc.run("library.unassign_reference", products=[ifc.get_entity(obj)], reference=reference)

src/blenderbim/blenderbim/core/material.py

@@ -102,7 +102,7 @@ def assign_material(ifc, material_tool, material_type, objects):
         element = ifc.get_entity(obj)
         if not element:
             continue
-        ifc.run("material.assign_material", product=element, type=material_type, material=material)
+        ifc.run("material.assign_material", products=[element], type=material_type, material=material)
         assigned_material = material_tool.get_material(element)
         if material_tool.is_a_material_set(assigned_material):
             material_tool.add_material_to_set(material_set=assigned_material, material=material)
@@ -116,12 +116,12 @@ def unassign_material(ifc, material_tool, objects):
             inherited_material = material_tool.get_material(element, should_inherit=True)
             if material and "Usage" in material.is_a():
                 element_type = material_tool.get_type(element)
-                ifc.run("material.unassign_material", product=element_type)
+                ifc.run("material.unassign_material", products=[element_type])
             elif not material and inherited_material:
                 element_type = material_tool.get_type(element)
-                ifc.run("material.unassign_material", product=element_type)
+                ifc.run("material.unassign_material", products=[element_type])
             elif material:
-                ifc.run("material.unassign_material", product=element)
+                ifc.run("material.unassign_material", products=[element])
 
 
 def patch_non_parametric_mep_segment(ifc, material_tool, profile_tool, obj):

src/blenderbim/blenderbim/core/nest.py

@@ -29,7 +29,9 @@ def assign_object(ifc, nest, collector, relating_obj=None, related_obj=None):
     if not nest.can_nest(relating_obj, related_obj):
         return
     rel = ifc.run(
-        "nest.assign_object", related_object=ifc.get_entity(related_obj), relating_object=ifc.get_entity(relating_obj)
+        "nest.assign_object",
+        related_objects=[ifc.get_entity(related_obj)],
+        relating_object=ifc.get_entity(relating_obj),
     )
     collector.assign(relating_obj)
     collector.assign(related_obj)
@@ -45,9 +47,9 @@ def unassign_object(ifc, nest, collector, relating_obj=None, related_obj=None):
         if related_element:
             relating_obj = ifc.get_object(relating_element)
     if relating_obj:
-        ifc.run("nest.unassign_object", related_object=related_element)
+        ifc.run("nest.unassign_object", related_objects=[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)
 

src/blenderbim/blenderbim/core/resource.py

@@ -195,7 +195,7 @@ def add_usage_constraint(ifc, resource_tool, resource=None, reference_path=None)
         },
     )
     ifc.run("constraint.add_metric_reference", metric=metric, reference_path=reference_path)
-    ifc.run("constraint.assign_constraint", product=resource, constraint=objective)
+    ifc.run("constraint.assign_constraint", products=[resource], constraint=objective)
 
 
 def remove_usage_constraint(ifc, resource_tool, resource, reference_path):
@@ -206,7 +206,7 @@ def remove_usage_constraint(ifc, resource_tool, resource, reference_path):
             reference = resource_tool.get_metric_reference(metric, is_deep=True)
             if reference == reference_path:
                 ifc.run("constraint.remove_metric", metric=metric)
-                ifc.run("constraint.unassign_constraint", product=resource, constraint=constraint)
+                ifc.run("constraint.unassign_constraint", products=[resource], constraint=constraint)
                 ifc.run("constraint.remove_constraint", constraint=constraint)
 
 

src/blenderbim/blenderbim/core/sequence.py

@@ -61,11 +61,11 @@ def remove_work_schedule(ifc, work_schedule=None):
 
 def assign_work_schedule(ifc, work_plan=None, work_schedule=None):
     if work_schedule:
-        return ifc.run("aggregate.assign_object", relating_object=work_plan, product=work_schedule)
+        return ifc.run("aggregate.assign_object", relating_object=work_plan, products=[work_schedule])
 
 
 def unassign_work_schedule(ifc, work_schedule=None):
-    ifc.run("aggregate.unassign_object", product=work_schedule)
+    ifc.run("aggregate.unassign_object", products=[work_schedule])
 
 
 def enable_editing_work_schedule(sequence, work_schedule=None):

src/blenderbim/blenderbim/core/spatial.py

@@ -16,23 +16,47 @@
 # 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
+from typing import TYPE_CHECKING, Optional, Union
+import blenderbim.core.tool as tool
 
-def reference_structure(ifc, spatial, structure=None, element=None):
+if TYPE_CHECKING:
+    import bpy
+    import ifcopenshell
+
+
+def reference_structure(
+    ifc: tool.Ifc,
+    spatial: tool.Spatial,
+    structure: Optional[ifcopenshell.entity_instance] = None,
+    element: Optional[ifcopenshell.entity_instance] = None,
+) -> Union[ifcopenshell.entity_instance, None]:
     if spatial.can_reference(structure, element):
-        return ifc.run("spatial.reference_structure", product=element, relating_structure=structure)
+        return ifc.run("spatial.reference_structure", products=[element], relating_structure=structure)
 
 
-def dereference_structure(ifc, spatial, structure=None, element=None):
+def dereference_structure(
+    ifc: tool.Ifc,
+    spatial: tool.Spatial,
+    structure: Optional[ifcopenshell.entity_instance] = None,
+    element: Optional[ifcopenshell.entity_instance] = None,
+) -> None:
     if spatial.can_reference(structure, element):
-        return ifc.run("spatial.dereference_structure", product=element, relating_structure=structure)
+        return ifc.run("spatial.dereference_structure", products=[element], relating_structure=structure)
 
 
-def assign_container(ifc, collector, spatial, structure_obj=None, element_obj=None):
+def assign_container(
+    ifc: tool.Ifc,
+    collector: tool.Collector,
+    spatial: tool.Spatial,
+    structure_obj: Optional[bpy.types.Object] = None,
+    element_obj: Optional[bpy.types.Object] = None,
+) -> Union[ifcopenshell.entity_instance, None]:
     if not spatial.can_contain(structure_obj, element_obj):
         return
     rel = ifc.run(
         "spatial.assign_container",
-        product=ifc.get_entity(element_obj),
+        products=[ifc.get_entity(element_obj)],
         relating_structure=ifc.get_entity(structure_obj),
     )
     spatial.disable_editing(element_obj)
@@ -54,7 +78,7 @@ def change_spatial_level(spatial, parent=None):
 
 
 def remove_container(ifc, collector, obj=None):
-    ifc.run("spatial.remove_container", product=ifc.get_entity(obj))
+    ifc.run("spatial.unassign_container", products=[ifc.get_entity(obj)])
     collector.assign(obj)
 
 
@@ -126,7 +150,7 @@ def select_decomposed_elements(spatial):
         spatial.select_products(spatial.get_decomposed_elements(container))
 
 
-#HERE STARTS SPATIAL TOOL
+# HERE STARTS SPATIAL TOOL
 def generate_space(ifc, spatial, model, Type):
     active_obj = spatial.get_active_obj()
     selected_objects = spatial.get_selected_objects()
@@ -140,21 +164,20 @@ def generate_space(ifc, spatial, model, Type):
             relating_type = None
 
     if selected_objects and active_obj:
-        x, y, z, h, mat = spatial.get_x_y_z_h_mat_from_active_obj(active_obj) ##mat
+        x, y, z, h, mat = spatial.get_x_y_z_h_mat_from_active_obj(active_obj)  ##mat
         element = ifc.get_entity(active_obj)
 
     else:
-        x, y, z, h, mat = spatial.get_x_y_z_h_mat_from_cursor() ##mat
-
+        x, y, z, h, mat = spatial.get_x_y_z_h_mat_from_cursor()  ##mat
 
     space_polygon = spatial.get_space_polygon_from_context_visible_objects(x, y)
 
     if not space_polygon:
         return
 
-    bm = spatial.get_bmesh_from_polygon(space_polygon, h=h) ##mat
+    bm = spatial.get_bmesh_from_polygon(space_polygon, h=h)  ##mat
 
-    mesh = spatial.get_named_mesh_from_bmesh(name = "Space", bmesh = bm)
+    mesh = spatial.get_named_mesh_from_bmesh(name="Space", bmesh=bm)
 
     if element and element.is_a("IfcSpace"):
         mesh = spatial.get_transformed_mesh_from_local_to_global(mesh)
@@ -175,6 +198,7 @@ def generate_space(ifc, spatial, model, Type):
         if relating_type:
             spatial.assign_relating_type_to_element(ifc, Type, element, relating_type)
 
+
 def generate_spaces_from_walls(ifc, spatial, collector):
     z = spatial.get_active_obj_z()
     h = spatial.get_active_obj_height()
@@ -188,7 +212,7 @@ def generate_spaces_from_walls(ifc, spatial, collector):
 
         name = "Space" + str(i)
 
-        obj = spatial.get_named_obj_from_bmesh(name, bmesh = bm)
+        obj = spatial.get_named_obj_from_bmesh(name, bmesh=bm)
 
         spatial.set_obj_origin_to_bboxcenter(obj)
         spatial.traslate_obj_to_z_location(obj, z)
@@ -206,6 +230,7 @@ def toggle_space_visibility(ifc, spatial):
         return
     spatial.toggle_spaces_visibility_wired_and_textured(spaces)
 
+
 def toggle_hide_spaces(ifc, spatial):
     model = ifc.get()
     spaces = model.by_type("IfcSpace")

src/blenderbim/blenderbim/core/system.py

@@ -55,11 +55,11 @@ def disable_editing_system(system):
 
 
 def assign_system(ifc, system=None, product=None):
-    ifc.run("system.assign_system", product=product, system=system)
+    ifc.run("system.assign_system", products=[product], system=system)
 
 
 def unassign_system(ifc, system=None, product=None):
-    ifc.run("system.unassign_system", product=product, system=system)
+    ifc.run("system.unassign_system", products=[product], system=system)
 
 
 def select_system_products(system_tool, system=None):

src/blenderbim/blenderbim/core/tool.py

@@ -153,6 +153,17 @@ class Bsdd:
     def should_load_preview_domains(cls): pass
 
 
+@interface
+class Clash:
+    def export_clash_sets(cls): pass
+    def get_clash(cls, clash_set, a_global_id, b_global_id): pass
+    def get_clash_set(cls, name): pass
+    def get_clash_sets(cls): pass
+    def import_active_clashes(cls): pass
+    def load_clash_sets(cls, fn): pass
+    def look_at(cls, target, location): pass
+
+
 @interface
 class Collector:
     def assign(cls, obj): pass
@@ -508,7 +519,7 @@ class Misc:
 class Model:
     def convert_si_to_unit(cls, value): pass
     def convert_unit_to_si(cls, value): pass
-    def export_curve(cls, position, edge_indices, points=None): pass
+    def export_curve(cls, position, edge_indices): pass
     def export_points(cls, position, indices): pass
     def export_profile(cls, obj, position=None): pass
     def generate_occurrence_name(cls, element_type, ifc_class): pass

src/blenderbim/blenderbim/core/type.py

@@ -20,7 +20,7 @@ import blenderbim.core.geometry
 
 
 def assign_type(ifc, type_tool, element=None, type=None):
-    ifc.run("type.assign_type", related_object=element, relating_type=type)
+    ifc.run("type.assign_type", related_objects=[element], relating_type=type)
     obj = ifc.get_object(element)
     if type_tool.has_material_usage(element):
         pass # for now, representation regeneration handled by API listeners

src/blenderbim/blenderbim/tool/__init__.py

@@ -22,6 +22,7 @@ from blenderbim.tool.boundary import Boundary
 from blenderbim.tool.brick import Brick
 from blenderbim.tool.bsdd import Bsdd
 from blenderbim.tool.cad import Cad
+from blenderbim.tool.clash import Clash
 from blenderbim.tool.collector import Collector
 from blenderbim.tool.context import Context
 from blenderbim.tool.debug import Debug

src/blenderbim/blenderbim/tool/blender.py

@@ -569,6 +569,18 @@ class Blender(blenderbim.core.tool.Blender):
 
         return bm_a
 
+    @classmethod
+    def bmesh_check_vertex_in_groups(
+        cls, vertex: bmesh.types.BMVert, deform_layer: bmesh.types.BMLayerItem, groups: list[int]
+    ) -> Union[tuple[Literal[True], int], tuple[Literal[False], None]]:
+        """returns tuple boolean (whether vertex is in any of the groups) and related group index"""
+        for group_index in vertex[deform_layer].keys():
+            # ignore vertex groups assignments produced by edge subdivision near arcs
+            # they usually have weight = 0.5
+            if group_index in groups and vertex[deform_layer][group_index] == 1.0:
+                return True, group_index
+        return False, None
+
     @classmethod
     def toggle_edit_mode(cls, context: bpy.types.Context) -> set:
         ao = context.active_object
@@ -677,6 +689,14 @@ class Blender(blenderbim.core.tool.Blender):
 
         return collections_mapping
 
+    @classmethod
+    def object_supports_edit_mode(cls, obj):
+        if not obj.data:
+            return False, "Can't Edit Empty Object"
+        if obj in bpy.context.scene.BIMProjectProperties.clipping_planes_objs:
+            return False, "Can't Edit Clipping Plane Geometry"
+        return True, ""
+
     class Modifier:
         @classmethod
         def is_eligible_for_railing_modifier(cls, obj):
@@ -778,8 +798,7 @@ class Blender(blenderbim.core.tool.Blender):
             @classmethod
             def get_modifiers_data(cls, parent_element):
                 array_pset = ifcopenshell.util.element.get_pset(parent_element, "BBIM_Array")
-                for modifier_data in json.loads(array_pset["Data"]):
-                    yield modifier_data
+                yield from json.loads(array_pset["Data"])
 
             @classmethod
             def get_children_objects(cls, modifier_data):
@@ -826,7 +845,9 @@ class Blender(blenderbim.core.tool.Blender):
             bpy.utils.register_tool(ws_model.PipeTool, after={"bim.duct_tool"}, separator=False, group=False)
             bpy.utils.register_tool(ws_model.BimTool, after={"bim.pipe_tool"}, separator=False, group=False)
             bpy.utils.register_tool(ws_drawing.AnnotationTool, after={"bim.bim_tool"}, separator=True, group=False)
-            bpy.utils.register_tool(ws_spatial.SpatialTool, after={"bim.annotation_tool"}, separator=False, group=False)
+            bpy.utils.register_tool(
+                ws_spatial.SpatialTool, after={"bim.annotation_tool"}, separator=False, group=False
+            )
             bpy.utils.register_tool(
                 ws_structural.StructuralTool, after={"bim.spatial_tool"}, separator=False, group=False
             )
@@ -863,3 +884,105 @@ class Blender(blenderbim.core.tool.Blender):
             bpy.utils.unregister_tool(ws_covering.CoveringTool)
         except:
             pass
+
+    @classmethod
+    def get_scene_panels_list(cls) -> tuple[bpy.types.Panel, ...]:
+        # example default blender scene panels can be found in
+        # https://projects.blender.org/blender/blender/src/branch/main/scripts/startup/bl_ui/properties_scene.py#L421
+        scene_panels: list[str] = []
+        panels_to_parents: dict[str, str] = dict()
+        for item_name in dir(bpy.types):
+            item = getattr(bpy.types, item_name)
+            # filter only panels
+            if not hasattr(item, "bl_rna") or not isinstance(item.bl_rna, bpy.types.Panel):
+                continue
+            # ignore bbim panels
+            if item.__module__.startswith("blenderbim"):
+                continue
+            # filter scene panels
+            if getattr(item, "bl_context", None) != "scene":
+                continue
+            scene_panels.append(item_name)
+            parent_panel = getattr(item, "bl_parent_id", None)
+            if parent_panel is not None:
+                panels_to_parents[item_name] = parent_panel
+
+        scene_panels = cls.sort_panels_for_register(scene_panels, panels_to_parents)
+        final_panels = [getattr(bpy.types, p) for p in scene_panels]
+        return tuple(final_panels)
+
+    @classmethod
+    def sort_panels_for_register(cls, items: list[str], items_to_parents: dict[str, str]) -> list[str]:
+        """sort panels ensuring parents panels will be registered first
+        as otherwise we'll get errors unregistering them all and registering child panel"""
+        final_items = []
+        unsorted = items.copy()
+
+        # first, add items without parents
+        for item in unsorted[:]:
+            if item not in items_to_parents:
+                final_items.append(item)
+                unsorted.remove(item)
+
+        # store children for each parent
+        children: dict[str, list[str]] = dict()
+        for item in items_to_parents:
+            children.setdefault(items_to_parents[item], []).append(item)
+
+        # add children recursively, ensuring parents are added first
+        keep_looking = True
+        while keep_looking:
+            keep_looking = False
+            for item in list(children.keys()):
+                # check if parent panel was already added
+                if item not in final_items:
+                    continue
+                final_items.extend(children[item])
+                del children[item]
+                keep_looking = True
+
+        assert set(items) == set(final_items), "Sorted list doesn't match original"
+        return final_items
+
+    @classmethod
+    def override_scene_panel(cls, original_panel: bpy.types.Panel) -> None:
+        @classmethod
+        def poll_check_blender_tab(cls, context):
+            return tool.Blender.is_tab(context, "BLENDER")
+
+        polls = blenderbim.bim.original_scene_panels_polls
+
+        # override poll method
+        if not hasattr(original_panel, "poll"):
+            polls[original_panel] = None
+            original_panel.poll = poll_check_blender_tab
+        else:
+            polls[original_panel] = original_panel.poll
+
+            @classmethod
+            def wrapped_poll(cls, context):
+                return polls[cls](context) and poll_check_blender_tab.__func__(cls, context)
+
+            original_panel.poll = wrapped_poll
+
+        # reregister to activate new poll
+        bpy.utils.unregister_class(original_panel)
+        bpy.utils.register_class(original_panel)
+
+    @classmethod
+    def remove_scene_panel_override(cls, panel: bpy.types.Panel) -> None:
+        polls = blenderbim.bim.original_scene_panels_polls
+
+        poll = polls[panel]
+        if poll is None:
+            del panel.poll
+        else:
+            panel.poll = poll
+
+        # panel might be already unregistered during blender exit
+        # or if it's addon was disabled
+        if panel.is_registered:
+            # reregister to activate new poll
+            bpy.utils.unregister_class(panel)
+            bpy.utils.register_class(panel)
+        del polls[panel]

src/blenderbim/blenderbim/tool/clash.py

@@ -0,0 +1,117 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2024 Dion Moult <dion@thinkmoult.com>
+#
+# This file is part of BlenderBIM Add-on.
+#
+# BlenderBIM Add-on is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# BlenderBIM Add-on is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with BlenderBIM Add-on.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import bpy
+import json
+import ifcopenshell
+import blenderbim.core.tool
+import blenderbim.tool as tool
+from contextlib import contextmanager
+from mathutils import Vector
+
+
+class Clash(blenderbim.core.tool.Clash):
+
+    @classmethod
+    def export_clash_sets(cls):
+        clash_sets = []
+        for clash_set in bpy.context.scene.BIMClashProperties.clash_sets:
+            a = []
+            b = []
+            for ab in ["a", "b"]:
+                for data in getattr(clash_set, ab):
+                    clash_source = {"file": data.name}
+                    query = tool.Search.export_filter_query(data.filter_groups)
+                    if query and data.mode != "a":
+                        clash_source["selector"] = query
+                        clash_source["mode"] = data.mode
+                    if ab == "a":
+                        a.append(clash_source)
+                    elif ab == "b":
+                        b.append(clash_source)
+            clash_set_data = {"name": clash_set.name, "mode": clash_set.mode, "a": a, "b": b}
+            if clash_set.mode == "intersection":
+                clash_set_data["tolerance"] = clash_set.tolerance
+                clash_set_data["check_all"] = clash_set.check_all
+            elif clash_set.mode == "collision":
+                clash_set_data["allow_touching"] = clash_set.allow_touching
+            elif clash_set.mode == "clearance":
+                clash_set_data["clearance"] = clash_set.clearance
+                clash_set_data["check_all"] = clash_set.check_all
+            clash_sets.append(clash_set_data)
+        return clash_sets
+
+    @classmethod
+    def get_clash(cls, clash_set, a_global_id, b_global_id):
+        clashes = clash_set.get("clashes", None)
+        if not clashes:
+            return
+        return clashes.get(f"{a_global_id}-{b_global_id}", None)
+
+    @classmethod
+    def get_clash_set(cls, name):
+        for clash_set in ClashStore.clash_sets:
+            if clash_set["name"] == name:
+                return clash_set
+
+    @classmethod
+    def get_clash_sets(cls):
+        return ClashStore.clash_sets
+
+    @classmethod
+    def import_active_clashes(cls):
+        clash_set = bpy.context.scene.BIMClashProperties.active_clash_set
+        if not clash_set:
+            return
+        clash_set.clashes.clear()
+        result = tool.Clash.get_clash_set(clash_set.name)
+        for clash in sorted(result.get("clashes", {}).values(), key=lambda x: x["distance"]):
+            blender_clash = clash_set.clashes.add()
+            blender_clash.a_global_id = clash["a_global_id"]
+            blender_clash.b_global_id = clash["b_global_id"]
+            blender_clash.a_name = "{}/{}".format(clash["a_ifc_class"], clash["a_name"])
+            blender_clash.b_name = "{}/{}".format(clash["b_ifc_class"], clash["b_name"])
+            blender_clash.status = False if not "status" in clash.keys() else clash["status"]
+
+    @classmethod
+    def load_clash_sets(cls, fn):
+        with open(fn) as f:
+            ClashStore.clash_sets = json.load(f)
+
+    @classmethod
+    def look_at(cls, target, location):
+        camera_location = location
+        area = next(area for area in bpy.context.screen.areas if area.type == "VIEW_3D")
+        region = next(region for region in area.regions if region.type == "WINDOW")
+        space = next(space for space in area.spaces if space.type == "VIEW_3D")
+        override = {"area": area, "region": region, "space_data": space}
+        space.region_3d.view_location = target
+        space.region_3d.view_rotation = Vector((camera_location - target)).to_track_quat("Z", "Y")
+        space.region_3d.view_distance = (camera_location - target).length
+        space.shading.show_xray = True
+
+
+class ClashStore:
+    clash_sets = None
+    path = None
+
+    @staticmethod
+    def purge():
+        ClashStore.clash_sets = None
+        ClashStore.path = None

src/blenderbim/blenderbim/tool/collector.py

@@ -20,13 +20,24 @@ import bpy
 import ifcopenshell.util.element
 
 import blenderbim.core.tool
+import blenderbim.core.spatial
+import blenderbim.core.aggregate
 import blenderbim.tool as tool
 from typing import Union
 
 
 class Collector(blenderbim.core.tool.Collector):
     @classmethod
-    def sync(cls, obj: bpy.types.Object) -> None:
+    def sync(cls, obj: bpy.types.Object, skip_unlinking=False) -> None:
+        """Sync object IFC state (assigned containter / aggregate) with the collection it's currently in.
+
+        Then subsequently run `Collector.assign` (if state has changed)
+        to link them to collections / unlink from anything unrelated collections.
+
+        If `skip_unlinking` is `True` then method won't try to assign parent object
+        if it's already assigned in IFC saving some time.
+        But it has a downside not unlinking object from unrelated collections.
+        """
         # This is the reverse of assign. It reads the Blender collection and figures out its IFC hierarchy
         element = tool.Ifc.get_entity(obj)
 
@@ -41,37 +52,41 @@ class Collector(blenderbim.core.tool.Collector):
         if not obj.users_collection:
             return
 
-        object_collection = None
-        collection_collection = None
-
-        object_collection = cls._get_own_collection(element, obj)
-        if object_collection:
-            collection_collection = cls._get_collection(element, obj)
-        else:
-            object_collection = cls._get_collection(element, obj)
+        # create related collections
+        cls._get_own_collection(element, obj)
+        cls._get_collection(element, obj)
 
         parent_collection = None
 
         for collection in obj.users_collection:
             if parent_collection:
                 break
+            # skip Types and non-BIM collections
             if not collection.BIMCollectionProperties.obj:
                 continue
+            # for objects that own collections we search for the first parent collection
             if collection.BIMCollectionProperties.obj == obj:
+                collection_name = collection.name
                 for bpy_collection in bpy.data.collections:
-                    if bpy_collection.children.find(collection.name) != -1:
+                    if bpy_collection.children.get(collection_name) and bpy_collection.BIMCollectionProperties.obj:
                         parent_collection = bpy_collection
+                        parent_obj = bpy_collection.BIMCollectionProperties.obj
+                        break
             else:
                 parent_collection = collection
+                parent_obj = collection.BIMCollectionProperties.obj
 
         if not parent_collection:
             return
 
-        parent_obj = parent_collection.BIMCollectionProperties.obj
-        if not parent_obj:
-            return
-
         parent = tool.Ifc.get_entity(parent_obj)
+        if skip_unlinking:
+            previous_parent = ifcopenshell.util.element.get_container(
+                element, should_get_direct=True
+            ) or ifcopenshell.util.element.get_aggregate(element)
+            if parent == previous_parent:
+                return
+
         if parent:
             # This is lazy, but works. One of these will succeed, the other will fail silently.
             blenderbim.core.spatial.assign_container(
@@ -86,6 +101,8 @@ class Collector(blenderbim.core.tool.Collector):
 
     @classmethod
     def assign(cls, obj: bpy.types.Object) -> None:
+        """link object and it's owned collection to the proper collection
+        and unlink them from any other"""
         element = tool.Ifc.get_entity(obj)
 
         object_collection = None
@@ -97,12 +114,17 @@ class Collector(blenderbim.core.tool.Collector):
         else:
             object_collection = cls._get_collection(element, obj)
 
+        # NOTE: calling `obj.users_collection` is expensive in large projects
+        # since it's iterating over all collections under the hood
+
+        # ensure object is linked only to object_collection
         if obj.users_collection != (object_collection,):
             for collection in obj.users_collection:
                 collection.objects.unlink(obj)
             if object_collection is not None:
                 object_collection.objects.link(obj)
 
+        # ensure object_collection is linked only to collection_collection
         if collection_collection and collection_collection.children.find(object_collection.name) == -1:
             if bpy.context.scene.collection.children.find(object_collection.name) != -1:
                 bpy.context.scene.collection.children.unlink(object_collection)
@@ -119,6 +141,7 @@ class Collector(blenderbim.core.tool.Collector):
     def _get_own_collection(
         cls, element: ifcopenshell.entity_instance, obj: bpy.types.Object
     ) -> Union[bpy.types.Collection, None]:
+        """get or create own collection for the element if it's neccessary for it's type"""
         if element.is_a("IfcProject"):
             return cls._create_own_collection(obj)
 
@@ -145,10 +168,8 @@ class Collector(blenderbim.core.tool.Collector):
             grid_obj = tool.Ifc.get_object(grid)
             if grid_obj:
                 grid_col = cls._get_own_collection(grid, grid_obj)
-                axes_col = [c for c in grid_col.children if axes in c.name]
-                if axes_col:
-                    return axes_col[0]
-                return bpy.data.collections.new(axes)
+                axes_col = next((c for c in grid_col.children if axes in c.name), None)
+                return axes_col or bpy.data.collections.new(axes)
 
         if element.is_a("IfcAnnotation") and element.ObjectType == "DRAWING":
             return cls._create_own_collection(obj)
@@ -163,11 +184,12 @@ class Collector(blenderbim.core.tool.Collector):
             return cls._create_own_collection(obj)
 
         if getattr(element, "IsNestedBy", None):
-            if [e for e in element.IsNestedBy[0].RelatedObjects if not e.is_a("IfcPort")]:
+            if any(e for e in element.IsNestedBy[0].RelatedObjects if not e.is_a("IfcPort")):
                 return cls._create_own_collection(obj)
 
     @classmethod
     def _get_collection(cls, element: ifcopenshell.entity_instance, obj: bpy.types.Object) -> bpy.types.Collection:
+        """get or create collection for the element based on it's type"""
         if element.is_a("IfcTypeObject"):
             return cls._create_project_child_collection("Types")
 
@@ -230,12 +252,11 @@ class Collector(blenderbim.core.tool.Collector):
 
         project_obj = tool.Ifc.get_object(tool.Ifc.get().by_type("IfcProject")[0])
         if project_obj:
-            collection = bpy.data.collections.get(project_obj.name)
-            if collection:
-                return collection
+            return project_obj.BIMObjectProperties.collection
 
     @classmethod
     def _create_project_child_collection(cls, name: str) -> bpy.types.Collection:
+        """get or create new collection inside project"""
         collection = bpy.data.collections.get(name)
         if not collection:
             collection = bpy.data.collections.new(name)
@@ -246,6 +267,7 @@ class Collector(blenderbim.core.tool.Collector):
 
     @classmethod
     def _create_own_collection(cls, obj: bpy.types.Object) -> bpy.types.Collection:
+        """get or create own collection for the element"""
         if obj.BIMObjectProperties.collection:
             return obj.BIMObjectProperties.collection
         collection = bpy.data.collections.new(obj.name)

src/blenderbim/blenderbim/tool/drawing.py

@@ -18,6 +18,7 @@
 
 import os
 import re
+import collections
 import bpy
 import math
 import json
@@ -27,27 +28,31 @@ import shutil
 import logging
 import shapely
 import platform
-from shapely.ops import unary_union
 import mathutils
 import subprocess
 import numpy as np
 import blenderbim.core.tool
 import blenderbim.core.geometry
 import blenderbim.tool as tool
+import ifcopenshell.api
+import ifcopenshell.geom
 import ifcopenshell.util.representation
 import ifcopenshell.util.element
 import ifcopenshell.util.selector
+import blenderbim.bim.import_ifc
 import blenderbim.bim.module.drawing.sheeter as sheeter
 import blenderbim.bim.module.drawing.scheduler as scheduler
 import blenderbim.bim.module.drawing.annotation as annotation
 import blenderbim.bim.module.drawing.helper as helper
+import blenderbim.core.root
+from shapely.ops import unary_union
 from blenderbim.bim.module.drawing.data import FONT_SIZES, DecoratorData
 from blenderbim.bim.module.drawing.prop import get_diagram_scales, BOX_ALIGNMENT_POSITIONS, ANNOTATION_TYPES_DATA
 from lxml import etree
-from mathutils import Vector
+from mathutils import Vector, Matrix
 from fractions import Fraction
-import collections
-from typing import Optional, Union
+from typing import Optional, Union, Iterable, Any
+from pathlib import Path
 
 
 class Drawing(blenderbim.core.tool.Drawing):
@@ -247,7 +252,7 @@ class Drawing(blenderbim.core.tool.Drawing):
         bpy.data.collections.remove(collection, do_unlink=True)
 
     @classmethod
-    def delete_drawing_elements(cls, elements):
+    def delete_drawing_elements(cls, elements: Iterable[ifcopenshell.entity_instance]) -> None:
         for element in elements:
             obj = tool.Ifc.get_object(element)
             ifcopenshell.api.run("root.remove_product", tool.Ifc.get(), product=element)
@@ -258,7 +263,7 @@ class Drawing(blenderbim.core.tool.Drawing):
                     tool.Blender.remove_data_block(obj_data)
 
     @classmethod
-    def delete_object(cls, obj):
+    def delete_object(cls, obj: bpy.types.Object) -> None:
         bpy.data.objects.remove(obj)
 
     @classmethod
@@ -337,7 +342,7 @@ class Drawing(blenderbim.core.tool.Drawing):
         return identification
 
     @classmethod
-    def export_text_literal_attributes(cls, obj):
+    def export_text_literal_attributes(cls, obj: bpy.types.Object) -> list[dict[str, Any]]:
         literals = []
         for literal_props in obj.BIMTextProperties.literals:
             literal_data = blenderbim.bim.helper.export_attributes(literal_props.attributes)
@@ -345,7 +350,9 @@ class Drawing(blenderbim.core.tool.Drawing):
         return literals
 
     @classmethod
-    def create_annotation_context(cls, target_view, object_type=None):
+    def create_annotation_context(
+        cls, target_view: str, object_type: Optional[str] = None
+    ) -> ifcopenshell.entity_instance:
         # checking PLAN target view and annotation type that doesn't require 3d
         if target_view in ("PLAN_VIEW", "REFLECTED_PLAN_VIEW") and object_type not in (
             "FALL",
@@ -366,7 +373,9 @@ class Drawing(blenderbim.core.tool.Drawing):
         )
 
     @classmethod
-    def get_annotation_context(cls, target_view, object_type=None):
+    def get_annotation_context(
+        cls, target_view: str, object_type: Optional[str] = None
+    ) -> Union[ifcopenshell.entity_instance, None]:
         # checking PLAN target view and annotation type that doesn't require 3d
         if target_view in ("PLAN_VIEW", "REFLECTED_PLAN_VIEW") and object_type not in (
             "FALL",
@@ -381,7 +390,9 @@ class Drawing(blenderbim.core.tool.Drawing):
         return ifcopenshell.util.representation.get_context(tool.Ifc.get(), "Model", "Body", "MODEL_VIEW")
 
     @classmethod
-    def get_document_uri(cls, document, description=None):
+    def get_document_uri(
+        cls, document: ifcopenshell.entity_instance, description: Optional[str] = None
+    ) -> Union[str, None]:
         if getattr(document, "Location", None):
             if os.path.isabs(document.Location):
                 return document.Location
@@ -426,7 +437,7 @@ class Drawing(blenderbim.core.tool.Drawing):
                 return rel.RelatingGroup
 
     @classmethod
-    def get_drawing_document(cls, drawing):
+    def get_drawing_document(cls, drawing: ifcopenshell.entity_instance) -> ifcopenshell.entity_instance:
         for rel in drawing.HasAssociations:
             if rel.is_a("IfcRelAssociatesDocument"):
                 return rel.RelatingDocument
@@ -587,13 +598,13 @@ class Drawing(blenderbim.core.tool.Drawing):
         return ifc_literal
 
     @classmethod
-    def get_assigned_product(cls, element):
+    def get_assigned_product(cls, element: ifcopenshell.entity_instance) -> Union[ifcopenshell.entity_instance, None]:
         for rel in element.HasAssignments:
             if rel.is_a("IfcRelAssignsToProduct"):
                 return rel.RelatingProduct
 
     @classmethod
-    def import_annotations_in_group(cls, group):
+    def import_annotations_in_group(cls, group: ifcopenshell.entity_instance) -> None:
         elements = set(
             [e for e in cls.get_group_elements(group) if e.is_a("IfcAnnotation") and e.ObjectType != "DRAWING"]
         )
@@ -603,6 +614,7 @@ class Drawing(blenderbim.core.tool.Drawing):
         ifc_importer.file = tool.Ifc.get()
         ifc_importer.calculate_unit_scale()
         ifc_importer.process_context_filter()
+        ifc_importer.load_existing_meshes()
         ifc_importer.material_creator.load_existing_materials()
         ifc_importer.create_generic_elements(elements)
         for obj in ifc_importer.added_data.values():
@@ -612,7 +624,7 @@ class Drawing(blenderbim.core.tool.Drawing):
     # but BIMCameraProperties are only synced with EPsetDrawing at drawing import
     # therefore camera props can differ from pset if the user changed them from pset.
     @classmethod
-    def import_drawing(cls, drawing):
+    def import_drawing(cls, drawing: ifcopenshell.entity_instance) -> bpy.types.Object:
         settings = ifcopenshell.geom.settings()
         settings.set(settings.STRICT_TOLERANCE, True)
 
@@ -659,8 +671,40 @@ class Drawing(blenderbim.core.tool.Drawing):
 
             camera.angle = fov
 
-        psets = ifcopenshell.util.element.get_psets(drawing)
-        pset = psets.get("EPset_Drawing")
+        tool.Loader.link_mesh(shape, camera)
+
+        obj = bpy.data.objects.new(tool.Loader.get_name(drawing), camera)
+        cls.import_camera_props(drawing, obj)
+        tool.Ifc.link(drawing, obj)
+
+        m = shape.transformation.matrix.data
+        mat = mathutils.Matrix(
+            ([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])
+        )
+        obj.matrix_world = mat
+
+        if cls.get_drawing_target_view(drawing) == "REFLECTED_PLAN_VIEW":
+            obj.matrix_world[1][1] *= -1
+
+        tool.Geometry.record_object_position(obj)
+        tool.Collector.assign(obj)
+
+        return obj
+
+    @classmethod
+    def import_camera_props(cls, drawing, obj):
+        # Temporarily clear the definition id to prevent prop update callbacks to IFC.
+        ifc_definition_id = obj.BIMObjectProperties.ifc_definition_id
+        obj.BIMObjectProperties.ifc_definition_id = 0
+
+        camera = obj.data
+        camera.BIMCameraProperties.has_underlay = False
+        camera.BIMCameraProperties.has_linework = True
+        camera.BIMCameraProperties.has_annotation = True
+        camera.BIMCameraProperties.target_view = "PLAN_VIEW"
+        camera.BIMCameraProperties.is_nts = False
+
+        pset = ifcopenshell.util.element.get_pset(drawing, "EPset_Drawing")
         if pset:
             if "TargetView" in pset:
                 camera.BIMCameraProperties.target_view = pset["TargetView"]
@@ -687,24 +731,7 @@ class Drawing(blenderbim.core.tool.Drawing):
             if "IsNTS" in pset:
                 camera.BIMCameraProperties.is_nts = bool(pset["IsNTS"])
 
-        tool.Loader.link_mesh(shape, camera)
-
-        obj = bpy.data.objects.new(tool.Loader.get_name(drawing), camera)
-        tool.Ifc.link(drawing, obj)
-
-        m = shape.transformation.matrix.data
-        mat = mathutils.Matrix(
-            ([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])
-        )
-        obj.matrix_world = mat
-
-        if cls.get_drawing_target_view(drawing) == "REFLECTED_PLAN_VIEW":
-            obj.matrix_world[1][1] *= -1
-
-        tool.Geometry.record_object_position(obj)
-        tool.Collector.assign(obj)
-
-        return obj
+        obj.BIMObjectProperties.ifc_definition_id = ifc_definition_id
 
     @classmethod
     def import_drawings(cls):
@@ -736,10 +763,10 @@ class Drawing(blenderbim.core.tool.Drawing):
 
             for drawing in sorted(drawings, key=lambda x: x.Name or "Unnamed"):
                 new = props.drawings.add()
-                new.ifc_definition_id = drawing.id()
                 new.name = drawing.Name or "Unnamed"
                 new.is_selected = current_drawings_selection.get(drawing.id(), True)
                 new.is_drawing = True
+                new.ifc_definition_id = drawing.id()  # Last, to prevent unnecessary prop callbacks
 
     @classmethod
     def import_documents(cls, document_type):
@@ -865,7 +892,7 @@ class Drawing(blenderbim.core.tool.Drawing):
         should_add_representation=True,
         context=None,
         ifc_representation_class=None,
-    ):
+    ) -> Union[ifcopenshell.entity_instance, None]:
         return blenderbim.core.root.assign_class(
             tool.Ifc,
             tool.Collector,
@@ -1051,7 +1078,9 @@ class Drawing(blenderbim.core.tool.Drawing):
                 shutil.copy(ootb_resource, resource_path)
 
     @classmethod
-    def get_potential_reference_elements(cls, drawing):
+    def get_potential_reference_elements(
+        cls, drawing: ifcopenshell.entity_instance
+    ) -> list[ifcopenshell.entity_instance]:
         elements = []
         existing_references = cls.get_group_elements(cls.get_drawing_group(drawing))
         for element in tool.Ifc.get().by_type("IfcAnnotation"):
@@ -1072,7 +1101,9 @@ class Drawing(blenderbim.core.tool.Drawing):
         return elements
 
     @classmethod
-    def get_drawing_reference_annotation(cls, drawing, reference_element):
+    def get_drawing_reference_annotation(
+        cls, drawing: ifcopenshell.entity_instance, reference_element: ifcopenshell.entity_instance
+    ) -> Union[ifcopenshell.entity_instance, bool, None]:
         if drawing == reference_element:
             return True
         for element in cls.get_group_elements(cls.get_drawing_group(drawing)):
@@ -1088,26 +1119,49 @@ class Drawing(blenderbim.core.tool.Drawing):
                             return element
 
     @classmethod
-    def generate_reference_annotation(cls, drawing, reference_element, context):
+    def generate_reference_annotation(
+        cls,
+        drawing: ifcopenshell.entity_instance,
+        reference_element: ifcopenshell.entity_instance,
+        context: ifcopenshell.entity_instance,
+    ) -> ifcopenshell.entity_instance:
         if reference_element.is_a("IfcGridAxis"):
             return cls.generate_grid_axis_reference_annotation(drawing, reference_element, context)
+
         elif reference_element.is_a("IfcAnnotation") and reference_element.ObjectType == "DRAWING":
-            psets = ifcopenshell.util.element.get_psets(reference_element)
-            target_view = psets.get("EPset_Drawing", {}).get("TargetView", None)
+
+            def ensure_referenced_drawing_obj_exists(drawing: ifcopenshell.entity_instance):
+                obj = tool.Ifc.get_object(drawing)
+                if obj is None:
+                    obj = cls.import_drawing(drawing)
+                    # there is no need for other drawing annotations in that case
+                    # but we import them anyway so we won't break that drawing activation
+                    cls.import_annotations_in_group(cls.get_drawing_group(drawing))
+                    tool.Blender.get_layer_collection(obj.users_collection[0]).hide_viewport = True
+
+            target_view = ifcopenshell.util.element.get_pset(reference_element, "EPset_Drawing", "TargetView")
             if target_view == "ELEVATION_VIEW":
+                ensure_referenced_drawing_obj_exists(reference_element)
                 return cls.generate_elevation_reference_annotation(drawing, reference_element, context)
             elif target_view == "SECTION_VIEW":
+                ensure_referenced_drawing_obj_exists(reference_element)
                 return cls.generate_section_reference_annotation(drawing, reference_element, context)
+
         elif reference_element.is_a("IfcBuildingStorey"):
             return cls.generate_storey_annotation(drawing, reference_element, context)
 
     @classmethod
-    def generate_storey_annotation(cls, drawing, reference_element, context):
+    def generate_storey_annotation(
+        cls,
+        drawing: ifcopenshell.entity_instance,
+        reference_element: ifcopenshell.entity_instance,
+        context: ifcopenshell.entity_instance,
+    ) -> ifcopenshell.entity_instance:
         camera = tool.Ifc.get_object(drawing)
         bounds = helper.ortho_view_frame(camera.data) if camera.data.type == "ORTHO" else None
         reference_obj = tool.Ifc.get_object(reference_element)
 
-        def to_camera_coords(camera, reference_obj):
+        def to_camera_coords(camera: bpy.types.Object, reference_obj: bpy.types.Object) -> Matrix:
             mat = reference_obj.matrix_world.copy()
             xyz = camera.matrix_world.inverted() @ reference_obj.matrix_world.translation
             xyz[2] = 0
@@ -1162,13 +1216,18 @@ class Drawing(blenderbim.core.tool.Drawing):
         return element
 
     @classmethod
-    def generate_section_reference_annotation(cls, drawing, reference_element, context):
+    def generate_section_reference_annotation(
+        cls,
+        drawing: ifcopenshell.entity_instance,
+        reference_element: ifcopenshell.entity_instance,
+        context: ifcopenshell.entity_instance,
+    ) -> ifcopenshell.entity_instance:
         reference_obj = tool.Ifc.get_object(reference_element)
         reference_obj.matrix_world
         camera = tool.Ifc.get_object(drawing)
         bounds = helper.ortho_view_frame(camera.data) if camera.data.type == "ORTHO" else None
 
-        def to_camera_coords(camera, reference_obj):
+        def to_camera_coords(camera: bpy.types.Object, reference_obj: bpy.types.Object) -> Matrix:
             mat = reference_obj.matrix_world.copy()
             xyz = camera.matrix_world.inverted() @ reference_obj.matrix_world.translation
             xyz[2] = 0
@@ -1179,7 +1238,9 @@ class Drawing(blenderbim.core.tool.Drawing):
             mat.translation += annotation_offset
             return mat
 
-        def clip_to_camera_boundary(mesh, bounds):
+        def clip_to_camera_boundary(
+            mesh: bpy.types.Mesh, bounds: tuple[float, float, float, float, float, float]
+        ) -> Union[bpy.types.Mesh, None]:
             mesh.verts.ensure_lookup_table()
             points = [v.co for v in mesh.verts[0:2]]
             points = helper.clip_segment(bounds, points)
@@ -1240,12 +1301,17 @@ class Drawing(blenderbim.core.tool.Drawing):
             return element
 
     @classmethod
-    def generate_elevation_reference_annotation(cls, drawing, reference_element, context):
+    def generate_elevation_reference_annotation(
+        cls,
+        drawing: ifcopenshell.entity_instance,
+        reference_element: ifcopenshell.entity_instance,
+        context: ifcopenshell.entity_instance,
+    ) -> ifcopenshell.entity_instance:
         reference_obj = tool.Ifc.get_object(reference_element)
         reference_obj.matrix_world
         camera = tool.Ifc.get_object(drawing)
 
-        def to_camera_coords(camera, reference_obj):
+        def to_camera_coords(camera: bpy.types.Object, reference_obj: bpy.types.Object) -> Matrix:
             mat = reference_obj.matrix_world.copy()
             xyz = camera.matrix_world.inverted() @ reference_obj.matrix_world.translation
             xyz[2] = 0
@@ -1272,7 +1338,12 @@ class Drawing(blenderbim.core.tool.Drawing):
             return element
 
     @classmethod
-    def generate_grid_axis_reference_annotation(cls, drawing, reference_element, context):
+    def generate_grid_axis_reference_annotation(
+        cls,
+        drawing: ifcopenshell.entity_instance,
+        reference_element: ifcopenshell.entity_instance,
+        context: ifcopenshell.entity_instance,
+    ) -> ifcopenshell.entity_instance:
         target_view = tool.Drawing.get_drawing_target_view(drawing)
 
         camera = tool.Ifc.get_object(drawing)
@@ -1300,7 +1371,7 @@ class Drawing(blenderbim.core.tool.Drawing):
             mesh.to_mesh(obj.data)
             return obj
 
-        def to_camera_coords(obj, mesh):
+        def to_camera_coords(obj: bpy.types.Object, mesh: bpy.types.Mesh) -> tuple[bpy.types.Object, bpy.types.Mesh]:
             mesh.transform(camera.matrix_world.inverted() @ obj.matrix_world)
             obj.matrix_world = camera.matrix_world
             annotation_offset = mathutils.Vector((0, 0, -camera.data.clip_start - 0.05))
@@ -1357,7 +1428,7 @@ class Drawing(blenderbim.core.tool.Drawing):
         return element
 
     @classmethod
-    def is_perpendicular(cls, a, b):
+    def is_perpendicular(cls, a: bpy.types.Object, b: bpy.types.Object) -> bool:
         axes = [mathutils.Vector((1, 0, 0)), mathutils.Vector((0, 1, 0)), mathutils.Vector((0, 0, 1))]
         a_quaternion = a.matrix_world.to_quaternion()
         b_quaternion = b.matrix_world.to_quaternion()
@@ -1367,7 +1438,7 @@ class Drawing(blenderbim.core.tool.Drawing):
         return False
 
     @classmethod
-    def get_camera_block(cls, obj):
+    def get_camera_block(cls, obj: bpy.types.Object) -> dict:
         raster_x = obj.data.BIMCameraProperties.raster_x
         raster_y = obj.data.BIMCameraProperties.raster_y
 
@@ -1400,7 +1471,7 @@ class Drawing(blenderbim.core.tool.Drawing):
         return {"verts": verts, "faces": faces}
 
     @classmethod
-    def is_intersecting(cls, a, b):
+    def is_intersecting(cls, a: bpy.types.Object, b: bpy.types.Object) -> bool:
         a_block = cls.get_camera_block(a)
         a_tree = mathutils.bvhtree.BVHTree.FromPolygons(a_block["verts"], a_block["faces"])
         b_block = cls.get_camera_block(b)
@@ -1408,7 +1479,7 @@ class Drawing(blenderbim.core.tool.Drawing):
         return bool(a_tree.overlap(b_tree))
 
     @classmethod
-    def replace_text_literal_variables(cls, text, product):
+    def replace_text_literal_variables(cls, text: str, product: Optional[ifcopenshell.entity_instance] = None) -> str:
         if not product:
             return text
 
@@ -1622,7 +1693,7 @@ class Drawing(blenderbim.core.tool.Drawing):
         bpy.ops.bim.activate_model()
 
     @classmethod
-    def activate_drawing(cls, camera):
+    def activate_drawing(cls, camera: bpy.types.Object) -> None:
         area = tool.Blender.get_view3d_area()
         is_local_view = area.spaces[0].local_view is not None
         if is_local_view:
@@ -1662,15 +1733,6 @@ class Drawing(blenderbim.core.tool.Drawing):
         filtered_elements = cls.get_drawing_elements(drawing) | cls.get_drawing_spaces(drawing)
         filtered_elements.add(drawing)
 
-        # hide non-filtered elemenets
-        for view_layer_object in bpy.context.view_layer.objects:
-            element = tool.Ifc.get_entity(view_layer_object)
-            if not element or element.is_a("IfcTypeProduct"):
-                continue
-            hide = element not in filtered_elements
-            view_layer_object.hide_set(hide)
-            view_layer_object.hide_render = hide
-
         subcontexts: list[ifcopenshell.entity_instance] = []
         target_view = cls.get_drawing_target_view(drawing)
 
@@ -1704,8 +1766,13 @@ class Drawing(blenderbim.core.tool.Drawing):
             if subcontext:
                 subcontexts.append(context_filter)
 
+        # Hide everything first, then selectively show. This is significantly faster.
+        with bpy.context.temp_override(area=next(a for a in bpy.context.screen.areas if a.type == "VIEW_3D")):
+            bpy.ops.object.hide_view_set(unselected=False)
+            bpy.ops.object.hide_view_set(unselected=True)
 
         # switch representations and hide elements without representations
+        element_obj_names = set()
         for element in filtered_elements:
             obj = tool.Ifc.get_object(element)
             current_representation = tool.Geometry.get_active_representation(obj)
@@ -1734,11 +1801,18 @@ class Drawing(blenderbim.core.tool.Drawing):
                     has_context = True
                     break
 
-            # don't hide IfcAnnotations as some of them might exist without representations
-            # e.g. with ObjectType = SYMBOL
-            if not has_context and not element.is_a("IfcAnnotation"):
-                obj.hide_set(True)
-                obj.hide_render = True
+            # Don't hide IfcAnnotations as some of them might exist without representations
+            if has_context or element.is_a("IfcAnnotation"):
+                element_obj_names.add(obj.name)
+
+        # Note that render visibility is only set on drawing generation time for speed.
+        [
+            obj.hide_set(False)  # Show the object
+            for obj in bpy.context.view_layer.objects
+            if obj.name in element_obj_names or not tool.Ifc.get_entity(obj)
+        ]
+
+        cls.import_camera_props(drawing, camera)
 
     @classmethod
     def get_elements_in_camera_view(
@@ -1943,3 +2017,60 @@ class Drawing(blenderbim.core.tool.Drawing):
             rotate180z = mathutils.Matrix.Rotation(math.radians(180.0), 4, "Z")
             return mathutils.Matrix.Translation(location) @ rotation.to_matrix().to_4x4() @ rotate180z
         return mathutils.Matrix.Translation(location) @ rotation.to_matrix().to_4x4()
+
+    @classmethod
+    def convert_svg_to_dxf(cls, svg_filepath: Path, dxf_filepath: Path) -> None:
+        import ezdxf
+        import xml.etree.ElementTree as ET
+
+        SVG = "{http://www.w3.org/2000/svg}"
+        IFC = "{http://www.ifcopenshell.org/ns}"
+
+        doc = ezdxf.new("R2010")
+        msp = doc.modelspace()
+        svg = ET.parse(svg_filepath).getroot()
+
+        def finalize_dxf():
+            doc.saveas(dxf_filepath)
+
+        drawing = svg.findall(f"{SVG}g[@{IFC}name]")
+        if not drawing:
+            finalize_dxf()
+            return
+        drawing = drawing[0]
+
+        NUMBER = r"-?\d+\.?\d+"
+        COORD = rf"{NUMBER},{NUMBER}"
+        POLYLINE_PATTERN = rf"M{COORD} (?:L{COORD} ?)+Z? ?"
+        MULTI_POLYLINE_PATTERN = rf"^({POLYLINE_PATTERN})+$"
+
+        for element_g in drawing.findall(f"{SVG}g"):
+            paths = element_g.findall(f"{SVG}path")
+
+            for path in paths:
+                path = path.attrib["d"]
+
+                if not re.match(MULTI_POLYLINE_PATTERN, path):
+                    # print(f'Path "{path}" doesn\'t match expected pattern {MULTI_POLYLINE_PATTERN}')
+                    continue
+
+                for polyline_path in re.findall(POLYLINE_PATTERN, path):
+                    points = re.findall(rf"{NUMBER}", polyline_path)
+                    points = [float(p) for p in points]
+                    POINT_SIZE = 2
+
+                    grouped_points = []
+                    for i in range(0, len(points), POINT_SIZE):
+                        point = points[i : i + POINT_SIZE]
+                        point[1] *= -1
+                        grouped_points.append(point)
+                    points = grouped_points
+
+                    # Z marks closed polylines
+                    is_closed_polyline = polyline_path.rstrip().endswith("Z")
+                    if is_closed_polyline or len(points) > 2:
+                        msp.add_lwpolyline(points, close=is_closed_polyline)
+                    else:  # LINE
+                        msp.add_line(*points)
+
+        finalize_dxf()

src/blenderbim/blenderbim/tool/geometry.py

@@ -32,7 +32,7 @@ import blenderbim.bim.import_ifc
 from math import radians, pi
 from mathutils import Vector, Matrix
 from blenderbim.bim.ifc import IfcStore
-from typing import List, Union
+from typing import Union
 
 
 class Geometry(blenderbim.core.tool.Geometry):
@@ -91,6 +91,17 @@ class Geometry(blenderbim.core.tool.Geometry):
         if element.is_a("IfcRelSpaceBoundary"):
             ifcopenshell.api.run("boundary.remove_boundary", tool.Ifc.get(), boundary=element)
             return bpy.data.objects.remove(obj)
+        if element.is_a("IfcGridAxis"):
+            is_last_axis = False
+            # Deleting the last W axis is OK
+            if ((grid := element.PartOfU) and len(grid[0].UAxes) == 1) or (
+                (grid := element.PartOfV) and len(grid[0].VAxes) == 1
+            ):
+                is_last_axis = True
+            if is_last_axis:
+                return
+            ifcopenshell.api.run("grid.remove_grid_axis", tool.Ifc.get(), axis=element)
+            return bpy.data.objects.remove(obj)
 
         collection = obj.BIMObjectProperties.collection
         if collection:
@@ -889,7 +900,7 @@ class Geometry(blenderbim.core.tool.Geometry):
                         return inverse
 
     @classmethod
-    def get_shape_aspect_styles(cls, element, shape_aspect, representation_item) -> List[ifcopenshell.entity_instance]:
+    def get_shape_aspect_styles(cls, element, shape_aspect, representation_item) -> list[ifcopenshell.entity_instance]:
         """update `representation_item` style based on styles connected to the `shape_aspect`
         through material constituents with the same name
         """