Revision Clouds - new annotation type

Short demonstration - https://github.com/IfcOpenShell/IfcOpenShell/assets/9417531/90c9b458-0bae-40a2-9eee-d748e57c24a3

Curently it doesn't have any special representation in viewport and it doesn't have any customisable parameters.

You might get come across error "Revision cloud edges must form just 1 polygon" - it means your edges either don't form any polygon or form 2 or more, both cases are not supported.

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

@@ -0,0 +1,57 @@
+name: ci-ifctester-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 * *"
+  push:
+    paths:
+      - '.github/workflows/ci-ifctester-pypi.yml'
+
+
+env:
+  major: 0
+  minor: 0
+  name: ifcopenshell
+
+jobs:
+  activate:
+    runs-on: ubuntu-latest
+    if: |
+      github.repository == 'IfcOpenShell/IfcOpenShell'
+    steps:
+    - name: Set env
+      run: echo ok go
+
+  build:
+    needs: activate
+    name: ${{ matrix.config.name }}-${{ matrix.pyver }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - 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')"
+      - name: Compile
+        run: |
+          pip install build
+          cd src/ifctester &&
+          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/ifctester/dist

.gitignore

@@ -86,6 +86,8 @@ src/blenderbim/blenderbim/libs
 
 # blenderbim test temp files
 src/blenderbim/test/files/temp
+src/blenderbim/drawings
+src/blenderbim/layouts
 
 # ifcopenshell swig and compiled files
 src/ifcopenshell-python/ifcopenshell/_ifcopenshell_wrapper.so

conda/meta.yaml

@@ -24,7 +24,7 @@ requirements:
   host:
     - python
     - boost-cpp
-    - occt
+    - occt ==7.7.0
     - libxml2
     - cgal-cpp
     - hdf5
@@ -32,11 +32,12 @@ requirements:
     - gmp  # [unix]
     - mpir  # [win]
     - nlohmann_json
+    - zlib
 
   run:
     - python
     - boost-cpp
-    - {{ pin_compatible('occt', max_pin='x.x.x') }}
+    - occt ==7.7.0
     - libxml2
     - cgal-cpp
     - hdf5
@@ -44,6 +45,7 @@ requirements:
     - gmp  # [unix]
     - mpir  # [win]
     - nlohmann_json
+    - zlib
 
 test:
   imports:

src/blenderbim/Makefile

@@ -664,6 +664,13 @@ endif
 	cp -r dist/working/bpypolyskel-master/bpypolyskel dist/blenderbim/libs/site/packages/
 	rm -rf dist/working
 
+	# Required for Desktop icon and file association
+	cp -r blenderbim/libs/desktop dist/blenderbim/libs/
+
+	# Remove dependencies also bundled with Blender
+	rm -rf dist/blenderbim/libs/site/packages/numpy
+	rm -rf dist/blenderbim/libs/site/packages/numpy.libs
+
 	cd dist/blenderbim && $(SED) "s/999999/$(VERSION)/" __init__.py
 	cd dist && zip -r blenderbim-$(VERSION)-$(PYVERSION)-$(PLATFORM).zip ./*
 	rm -rf dist/blenderbim

src/blenderbim/blenderbim/__init__.py

@@ -34,7 +34,8 @@ bl_info = {
 if sys.modules.get("bpy", None):
     # Process *.pth in /libs/site/packages to setup globally importable modules
     # This is 3 levels deep as required by the static RPATH of ../../ from dependencies taken from Anaconda
-    site.addsitedir(os.path.join(os.path.dirname(os.path.realpath(__file__)), "libs", "site", "packages"))
+    # site.addsitedir(os.path.join(os.path.dirname(os.path.realpath(__file__)), "libs", "site", "packages"))
+    sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "libs", "site", "packages"))
 
     import blenderbim.bim
 

src/blenderbim/blenderbim/bim/__init__.py

@@ -95,6 +95,8 @@ classes = [
     operator.SelectIfcFile,
     operator.ReloadSelectedIfcFile,
     operator.SelectSchemaDir,
+    operator.FileAssociate,
+    operator.FileUnassociate,
     operator.SelectURIAttribute,
     operator.EditBlenderCollection,
     operator.BIM_OT_open_webbrowser,

src/blenderbim/blenderbim/bim/data/assets/shading_styles.json

@@ -0,0 +1,755 @@
+{
+    "Technical": {
+        "render_type": "VIEWPORT",
+        "raster_style": {
+            "bpy.data.worlds[0].color": [
+                1.0,
+                1.0,
+                1.0
+            ],
+            "scene.render.bake_bias": 0.0010000000474974513,
+            "scene.render.bake_margin": 16,
+            "scene.render.bake_margin_type": "ADJACENT_FACES",
+            "scene.render.bake_samples": 256,
+            "scene.render.bake_type": "NORMALS",
+            "scene.render.bake_user_scale": 0.0,
+            "scene.render.border_max_x": 1.0,
+            "scene.render.border_max_y": 1.0,
+            "scene.render.border_min_x": 0.0,
+            "scene.render.border_min_y": 0.0,
+            "scene.render.dither_intensity": 1.0,
+            "scene.render.engine": "BLENDER_WORKBENCH",
+            "scene.render.film_transparent": false,
+            "scene.render.filter_size": 1.5,
+            "scene.render.fps": 24,
+            "scene.render.fps_base": 1.0,
+            "scene.render.frame_map_new": 100,
+            "scene.render.frame_map_old": 100,
+            "scene.render.hair_subdiv": 0,
+            "scene.render.hair_type": "STRAND",
+            "scene.render.line_thickness": 1.0,
+            "scene.render.line_thickness_mode": "ABSOLUTE",
+            "scene.render.metadata_input": "SCENE",
+            "scene.render.motion_blur_shutter": 0.5,
+            "scene.render.pixel_aspect_x": 1.0,
+            "scene.render.pixel_aspect_y": 1.0,
+            "scene.render.preview_pixel_size": "AUTO",
+            "scene.render.resolution_percentage": 100,
+            "scene.render.resolution_x": 1000,
+            "scene.render.resolution_y": 1000,
+            "scene.render.sequencer_gl_preview": "SOLID",
+            "scene.render.simplify_child_particles": 1.0,
+            "scene.render.simplify_child_particles_render": 1.0,
+            "scene.render.simplify_gpencil": false,
+            "scene.render.simplify_gpencil_antialiasing": true,
+            "scene.render.simplify_gpencil_modifier": true,
+            "scene.render.simplify_gpencil_onplay": false,
+            "scene.render.simplify_gpencil_shader_fx": true,
+            "scene.render.simplify_gpencil_tint": true,
+            "scene.render.simplify_gpencil_view_fill": true,
+            "scene.render.simplify_shadows": 1.0,
+            "scene.render.simplify_shadows_render": 1.0,
+            "scene.render.simplify_subdivision": 6,
+            "scene.render.simplify_subdivision_render": 6,
+            "scene.render.simplify_volumes": 1.0,
+            "scene.render.stamp_font_size": 12,
+            "scene.render.stamp_note_text": "",
+            "scene.render.threads": 20,
+            "scene.render.threads_mode": "AUTO",
+            "scene.render.use_bake_clear": true,
+            "scene.render.use_bake_lores_mesh": false,
+            "scene.render.use_bake_multires": false,
+            "scene.render.use_bake_selected_to_active": false,
+            "scene.render.use_bake_user_scale": false,
+            "scene.render.use_border": false,
+            "scene.render.use_compositing": true,
+            "scene.render.use_crop_to_border": false,
+            "scene.render.use_file_extension": true,
+            "scene.render.use_freestyle": false,
+            "scene.render.use_high_quality_normals": false,
+            "scene.render.use_lock_interface": false,
+            "scene.render.use_motion_blur": false,
+            "scene.render.use_multiview": false,
+            "scene.render.use_overwrite": true,
+            "scene.render.use_persistent_data": false,
+            "scene.render.use_placeholder": false,
+            "scene.render.use_render_cache": false,
+            "scene.render.use_sequencer": true,
+            "scene.render.use_sequencer_override_scene_strip": false,
+            "scene.render.use_simplify": false,
+            "scene.render.use_single_layer": false,
+            "scene.render.use_stamp": false,
+            "scene.render.use_stamp_camera": true,
+            "scene.render.use_stamp_date": true,
+            "scene.render.use_stamp_filename": true,
+            "scene.render.use_stamp_frame": true,
+            "scene.render.use_stamp_frame_range": false,
+            "scene.render.use_stamp_hostname": false,
+            "scene.render.use_stamp_labels": true,
+            "scene.render.use_stamp_lens": false,
+            "scene.render.use_stamp_marker": false,
+            "scene.render.use_stamp_memory": false,
+            "scene.render.use_stamp_note": false,
+            "scene.render.use_stamp_render_time": true,
+            "scene.render.use_stamp_scene": true,
+            "scene.render.use_stamp_sequencer_strip": false,
+            "scene.render.use_stamp_time": true,
+            "scene.render.views_format": "STEREO_3D",
+            "scene.view_settings.exposure": 0.0,
+            "scene.view_settings.gamma": 1.0,
+            "scene.view_settings.look": "None",
+            "scene.view_settings.use_curve_mapping": false,
+            "scene.view_settings.view_transform": "Standard",
+            "scene.display.shading.aov_name": "",
+            "scene.display.shading.background_color": [
+                0.0,
+                0.0,
+                0.0
+            ],
+            "scene.display.shading.background_type": "THEME",
+            "scene.display.shading.cavity_ridge_factor": 1.0,
+            "scene.display.shading.cavity_type": "BOTH",
+            "scene.display.shading.cavity_valley_factor": 1.0,
+            "scene.display.shading.color_type": "SINGLE",
+            "scene.display.shading.curvature_ridge_factor": 1.0,
+            "scene.display.shading.curvature_valley_factor": 1.0,
+            "scene.display.shading.light": "FLAT",
+            "scene.display.shading.object_outline_color": [
+                0.0,
+                0.0,
+                0.0
+            ],
+            "scene.display.shading.render_pass": "COMBINED",
+            "scene.display.shading.shadow_intensity": 0.5,
+            "scene.display.shading.show_backface_culling": false,
+            "scene.display.shading.show_cavity": false,
+            "scene.display.shading.show_object_outline": true,
+            "scene.display.shading.show_shadows": false,
+            "scene.display.shading.show_specular_highlight": true,
+            "scene.display.shading.show_xray": false,
+            "scene.display.shading.show_xray_wireframe": false,
+            "scene.display.shading.single_color": [
+                1.0,
+                1.0,
+                1.0
+            ],
+            "scene.display.shading.studio_light": "Default",
+            "scene.display.shading.studiolight_background_alpha": 0.0,
+            "scene.display.shading.studiolight_background_blur": 0.0,
+            "scene.display.shading.studiolight_intensity": 0.0,
+            "scene.display.shading.studiolight_rotate_z": 0.0,
+            "scene.display.shading.type": "SOLID",
+            "scene.display.shading.use_compositor": "DISABLED",
+            "scene.display.shading.use_dof": false,
+            "scene.display.shading.use_scene_lights": false,
+            "scene.display.shading.use_scene_lights_render": false,
+            "scene.display.shading.use_scene_world": false,
+            "scene.display.shading.use_scene_world_render": false,
+            "scene.display.shading.use_studiolight_view_rotation": true,
+            "scene.display.shading.use_world_space_lighting": false,
+            "scene.display.shading.wireframe_color_type": "MATERIAL",
+            "scene.display.shading.xray_alpha": 0.5,
+            "scene.display.shading.xray_alpha_wireframe": 0.0,
+            "scene.display.light_direction": [
+                0.5,
+                0.5,
+                0.5
+            ],
+            "scene.display.matcap_ssao_attenuation": 1.0,
+            "scene.display.matcap_ssao_distance": 0.20000000298023224,
+            "scene.display.matcap_ssao_samples": 16,
+            "scene.display.render_aa": "8",
+            "scene.display.shadow_focus": 0.0,
+            "scene.display.shadow_shift": 0.10000000149011612,
+            "scene.display.viewport_aa": "FXAA",
+            "space.overlay.backwire_opacity": 0.5,
+            "space.overlay.bone_wire_alpha": 1.0,
+            "space.overlay.display_handle": "SELECTED",
+            "space.overlay.fade_inactive_alpha": 0.4000000059604645,
+            "space.overlay.gpencil_fade_layer": 0.5,
+            "space.overlay.gpencil_fade_objects": 0.5,
+            "space.overlay.gpencil_grid_opacity": 0.5,
+            "space.overlay.gpencil_vertex_paint_opacity": 1.0,
+            "space.overlay.grid_lines": 16,
+            "space.overlay.grid_scale": 1.0,
+            "space.overlay.grid_subdivisions": 10,
+            "space.overlay.normals_constant_screen_size": 7.0,
+            "space.overlay.normals_length": 0.10000000149011612,
+            "space.overlay.sculpt_curves_cage_opacity": 0.5,
+            "space.overlay.sculpt_mode_face_sets_opacity": 1.0,
+            "space.overlay.sculpt_mode_mask_opacity": 0.75,
+            "space.overlay.show_annotation": true,
+            "space.overlay.show_axis_x": false,
+            "space.overlay.show_axis_y": false,
+            "space.overlay.show_axis_z": false,
+            "space.overlay.show_bones": true,
+            "space.overlay.show_cursor": true,
+            "space.overlay.show_curve_normals": false,
+            "space.overlay.show_edge_bevel_weight": true,
+            "space.overlay.show_edge_crease": true,
+            "space.overlay.show_edge_seams": true,
+            "space.overlay.show_edge_sharp": true,
+            "space.overlay.show_edges": false,
+            "space.overlay.show_extra_edge_angle": false,
+            "space.overlay.show_extra_edge_length": false,
+            "space.overlay.show_extra_face_angle": false,
+            "space.overlay.show_extra_face_area": false,
+            "space.overlay.show_extra_indices": false,
+            "space.overlay.show_extras": true,
+            "space.overlay.show_face_center": false,
+            "space.overlay.show_face_normals": false,
+            "space.overlay.show_face_orientation": false,
+            "space.overlay.show_faces": true,
+            "space.overlay.show_fade_inactive": false,
+            "space.overlay.show_floor": false,
+            "space.overlay.show_freestyle_edge_marks": true,
+            "space.overlay.show_freestyle_face_marks": true,
+            "space.overlay.show_look_dev": false,
+            "space.overlay.show_motion_paths": true,
+            "space.overlay.show_object_origins": false,
+            "space.overlay.show_object_origins_all": false,
+            "space.overlay.show_occlude_wire": false,
+            "space.overlay.show_onion_skins": false,
+            "space.overlay.show_ortho_grid": true,
+            "space.overlay.show_outline_selected": true,
+            "space.overlay.show_overlays": true,
+            "space.overlay.show_paint_wire": false,
+            "space.overlay.show_relationship_lines": false,
+            "space.overlay.show_sculpt_curves_cage": true,
+            "space.overlay.show_sculpt_face_sets": true,
+            "space.overlay.show_sculpt_mask": true,
+            "space.overlay.show_split_normals": false,
+            "space.overlay.show_stats": false,
+            "space.overlay.show_statvis": false,
+            "space.overlay.show_text": true,
+            "space.overlay.show_vertex_normals": false,
+            "space.overlay.show_viewer_attribute": true,
+            "space.overlay.show_weight": false,
+            "space.overlay.show_wireframes": true,
+            "space.overlay.show_wpaint_contours": false,
+            "space.overlay.show_xray_bone": false,
+            "space.overlay.texture_paint_mode_opacity": 1.0,
+            "space.overlay.use_debug_freeze_view_culling": false,
+            "space.overlay.use_gpencil_canvas_xray": false,
+            "space.overlay.use_gpencil_edit_lines": true,
+            "space.overlay.use_gpencil_fade_gp_objects": false,
+            "space.overlay.use_gpencil_fade_layers": false,
+            "space.overlay.use_gpencil_fade_objects": false,
+            "space.overlay.use_gpencil_grid": false,
+            "space.overlay.use_gpencil_multiedit_line_only": false,
+            "space.overlay.use_gpencil_onion_skin": false,
+            "space.overlay.use_gpencil_show_directions": false,
+            "space.overlay.use_gpencil_show_material_name": false,
+            "space.overlay.use_normals_constant_screen_size": false,
+            "space.overlay.vertex_opacity": 1.0,
+            "space.overlay.vertex_paint_mode_opacity": 1.0,
+            "space.overlay.viewer_attribute_opacity": 1.0,
+            "space.overlay.weight_paint_mode_opacity": 1.0,
+            "space.overlay.wireframe_opacity": 1.0,
+            "space.overlay.wireframe_threshold": 0.0,
+            "space.overlay.xray_alpha_bone": 0.0
+        }
+    },
+    "Shaded": {
+        "render_type": "VIEWPORT",
+        "raster_style": {
+            "bpy.data.worlds[0].color": [
+                1.0,
+                1.0,
+                1.0
+            ],
+            "scene.render.bake_bias": 0.0010000000474974513,
+            "scene.render.bake_margin": 16,
+            "scene.render.bake_margin_type": "ADJACENT_FACES",
+            "scene.render.bake_samples": 256,
+            "scene.render.bake_type": "NORMALS",
+            "scene.render.bake_user_scale": 0.0,
+            "scene.render.border_max_x": 1.0,
+            "scene.render.border_max_y": 1.0,
+            "scene.render.border_min_x": 0.0,
+            "scene.render.border_min_y": 0.0,
+            "scene.render.dither_intensity": 1.0,
+            "scene.render.engine": "BLENDER_WORKBENCH",
+            "scene.render.film_transparent": false,
+            "scene.render.filter_size": 1.5,
+            "scene.render.fps": 24,
+            "scene.render.fps_base": 1.0,
+            "scene.render.frame_map_new": 100,
+            "scene.render.frame_map_old": 100,
+            "scene.render.hair_subdiv": 0,
+            "scene.render.hair_type": "STRAND",
+            "scene.render.line_thickness": 1.0,
+            "scene.render.line_thickness_mode": "ABSOLUTE",
+            "scene.render.metadata_input": "SCENE",
+            "scene.render.motion_blur_shutter": 0.5,
+            "scene.render.pixel_aspect_x": 1.0,
+            "scene.render.pixel_aspect_y": 1.0,
+            "scene.render.preview_pixel_size": "AUTO",
+            "scene.render.resolution_percentage": 100,
+            "scene.render.resolution_x": 1000,
+            "scene.render.resolution_y": 1000,
+            "scene.render.sequencer_gl_preview": "SOLID",
+            "scene.render.simplify_child_particles": 1.0,
+            "scene.render.simplify_child_particles_render": 1.0,
+            "scene.render.simplify_gpencil": false,
+            "scene.render.simplify_gpencil_antialiasing": true,
+            "scene.render.simplify_gpencil_modifier": true,
+            "scene.render.simplify_gpencil_onplay": false,
+            "scene.render.simplify_gpencil_shader_fx": true,
+            "scene.render.simplify_gpencil_tint": true,
+            "scene.render.simplify_gpencil_view_fill": true,
+            "scene.render.simplify_shadows": 1.0,
+            "scene.render.simplify_shadows_render": 1.0,
+            "scene.render.simplify_subdivision": 6,
+            "scene.render.simplify_subdivision_render": 6,
+            "scene.render.simplify_volumes": 1.0,
+            "scene.render.stamp_font_size": 12,
+            "scene.render.stamp_note_text": "",
+            "scene.render.threads": 20,
+            "scene.render.threads_mode": "AUTO",
+            "scene.render.use_bake_clear": true,
+            "scene.render.use_bake_lores_mesh": false,
+            "scene.render.use_bake_multires": false,
+            "scene.render.use_bake_selected_to_active": false,
+            "scene.render.use_bake_user_scale": false,
+            "scene.render.use_border": false,
+            "scene.render.use_compositing": true,
+            "scene.render.use_crop_to_border": false,
+            "scene.render.use_file_extension": true,
+            "scene.render.use_freestyle": false,
+            "scene.render.use_high_quality_normals": false,
+            "scene.render.use_lock_interface": false,
+            "scene.render.use_motion_blur": false,
+            "scene.render.use_multiview": false,
+            "scene.render.use_overwrite": true,
+            "scene.render.use_persistent_data": false,
+            "scene.render.use_placeholder": false,
+            "scene.render.use_render_cache": false,
+            "scene.render.use_sequencer": true,
+            "scene.render.use_sequencer_override_scene_strip": false,
+            "scene.render.use_simplify": false,
+            "scene.render.use_single_layer": false,
+            "scene.render.use_stamp": false,
+            "scene.render.use_stamp_camera": true,
+            "scene.render.use_stamp_date": true,
+            "scene.render.use_stamp_filename": true,
+            "scene.render.use_stamp_frame": true,
+            "scene.render.use_stamp_frame_range": false,
+            "scene.render.use_stamp_hostname": false,
+            "scene.render.use_stamp_labels": true,
+            "scene.render.use_stamp_lens": false,
+            "scene.render.use_stamp_marker": false,
+            "scene.render.use_stamp_memory": false,
+            "scene.render.use_stamp_note": false,
+            "scene.render.use_stamp_render_time": true,
+            "scene.render.use_stamp_scene": true,
+            "scene.render.use_stamp_sequencer_strip": false,
+            "scene.render.use_stamp_time": true,
+            "scene.render.views_format": "STEREO_3D",
+            "scene.view_settings.exposure": 0.0,
+            "scene.view_settings.gamma": 1.0,
+            "scene.view_settings.look": "None",
+            "scene.view_settings.use_curve_mapping": false,
+            "scene.view_settings.view_transform": "Standard",
+            "scene.display.shading.aov_name": "",
+            "scene.display.shading.background_color": [
+                0.0,
+                0.0,
+                0.0
+            ],
+            "scene.display.shading.background_type": "THEME",
+            "scene.display.shading.cavity_ridge_factor": 1.0,
+            "scene.display.shading.cavity_type": "BOTH",
+            "scene.display.shading.cavity_valley_factor": 1.0,
+            "scene.display.shading.color_type": "MATERIAL",
+            "scene.display.shading.curvature_ridge_factor": 1.0,
+            "scene.display.shading.curvature_valley_factor": 1.0,
+            "scene.display.shading.light": "STUDIO",
+            "scene.display.shading.object_outline_color": [
+                0.0,
+                0.0,
+                0.0
+            ],
+            "scene.display.shading.render_pass": "COMBINED",
+            "scene.display.shading.shadow_intensity": 0.5,
+            "scene.display.shading.show_backface_culling": false,
+            "scene.display.shading.show_cavity": true,
+            "scene.display.shading.show_object_outline": true,
+            "scene.display.shading.show_shadows": true,
+            "scene.display.shading.show_specular_highlight": true,
+            "scene.display.shading.show_xray": false,
+            "scene.display.shading.show_xray_wireframe": false,
+            "scene.display.shading.single_color": [
+                1.0,
+                1.0,
+                1.0
+            ],
+            "scene.display.shading.studio_light": "Default",
+            "scene.display.shading.studiolight_background_alpha": 0.0,
+            "scene.display.shading.studiolight_background_blur": 0.0,
+            "scene.display.shading.studiolight_intensity": 0.0,
+            "scene.display.shading.studiolight_rotate_z": 0.0,
+            "scene.display.shading.type": "SOLID",
+            "scene.display.shading.use_compositor": "DISABLED",
+            "scene.display.shading.use_dof": false,
+            "scene.display.shading.use_scene_lights": false,
+            "scene.display.shading.use_scene_lights_render": false,
+            "scene.display.shading.use_scene_world": false,
+            "scene.display.shading.use_scene_world_render": false,
+            "scene.display.shading.use_studiolight_view_rotation": true,
+            "scene.display.shading.use_world_space_lighting": false,
+            "scene.display.shading.wireframe_color_type": "MATERIAL",
+            "scene.display.shading.xray_alpha": 0.5,
+            "scene.display.shading.xray_alpha_wireframe": 0.0,
+            "scene.display.light_direction": [
+                0.5,
+                0.5,
+                0.5
+            ],
+            "scene.display.matcap_ssao_attenuation": 1.0,
+            "scene.display.matcap_ssao_distance": 0.20000000298023224,
+            "scene.display.matcap_ssao_samples": 16,
+            "scene.display.render_aa": "8",
+            "scene.display.shadow_focus": 0.0,
+            "scene.display.shadow_shift": 0.10000000149011612,
+            "scene.display.viewport_aa": "FXAA",
+            "space.overlay.backwire_opacity": 0.5,
+            "space.overlay.bone_wire_alpha": 1.0,
+            "space.overlay.display_handle": "SELECTED",
+            "space.overlay.fade_inactive_alpha": 0.4000000059604645,
+            "space.overlay.gpencil_fade_layer": 0.5,
+            "space.overlay.gpencil_fade_objects": 0.5,
+            "space.overlay.gpencil_grid_opacity": 0.5,
+            "space.overlay.gpencil_vertex_paint_opacity": 1.0,
+            "space.overlay.grid_lines": 16,
+            "space.overlay.grid_scale": 1.0,
+            "space.overlay.grid_subdivisions": 10,
+            "space.overlay.normals_constant_screen_size": 7.0,
+            "space.overlay.normals_length": 0.10000000149011612,
+            "space.overlay.sculpt_curves_cage_opacity": 0.5,
+            "space.overlay.sculpt_mode_face_sets_opacity": 1.0,
+            "space.overlay.sculpt_mode_mask_opacity": 0.75,
+            "space.overlay.show_annotation": true,
+            "space.overlay.show_axis_x": false,
+            "space.overlay.show_axis_y": false,
+            "space.overlay.show_axis_z": false,
+            "space.overlay.show_bones": true,
+            "space.overlay.show_cursor": true,
+            "space.overlay.show_curve_normals": false,
+            "space.overlay.show_edge_bevel_weight": true,
+            "space.overlay.show_edge_crease": true,
+            "space.overlay.show_edge_seams": true,
+            "space.overlay.show_edge_sharp": true,
+            "space.overlay.show_edges": false,
+            "space.overlay.show_extra_edge_angle": false,
+            "space.overlay.show_extra_edge_length": false,
+            "space.overlay.show_extra_face_angle": false,
+            "space.overlay.show_extra_face_area": false,
+            "space.overlay.show_extra_indices": false,
+            "space.overlay.show_extras": true,
+            "space.overlay.show_face_center": false,
+            "space.overlay.show_face_normals": false,
+            "space.overlay.show_face_orientation": false,
+            "space.overlay.show_faces": true,
+            "space.overlay.show_fade_inactive": false,
+            "space.overlay.show_floor": false,
+            "space.overlay.show_freestyle_edge_marks": true,
+            "space.overlay.show_freestyle_face_marks": true,
+            "space.overlay.show_look_dev": false,
+            "space.overlay.show_motion_paths": true,
+            "space.overlay.show_object_origins": false,
+            "space.overlay.show_object_origins_all": false,
+            "space.overlay.show_occlude_wire": false,
+            "space.overlay.show_onion_skins": false,
+            "space.overlay.show_ortho_grid": true,
+            "space.overlay.show_outline_selected": true,
+            "space.overlay.show_overlays": true,
+            "space.overlay.show_paint_wire": false,
+            "space.overlay.show_relationship_lines": false,
+            "space.overlay.show_sculpt_curves_cage": true,
+            "space.overlay.show_sculpt_face_sets": true,
+            "space.overlay.show_sculpt_mask": true,
+            "space.overlay.show_split_normals": false,
+            "space.overlay.show_stats": false,
+            "space.overlay.show_statvis": false,
+            "space.overlay.show_text": true,
+            "space.overlay.show_vertex_normals": false,
+            "space.overlay.show_viewer_attribute": true,
+            "space.overlay.show_weight": false,
+            "space.overlay.show_wireframes": false,
+            "space.overlay.show_wpaint_contours": false,
+            "space.overlay.show_xray_bone": false,
+            "space.overlay.texture_paint_mode_opacity": 1.0,
+            "space.overlay.use_debug_freeze_view_culling": false,
+            "space.overlay.use_gpencil_canvas_xray": false,
+            "space.overlay.use_gpencil_edit_lines": true,
+            "space.overlay.use_gpencil_fade_gp_objects": false,
+            "space.overlay.use_gpencil_fade_layers": false,
+            "space.overlay.use_gpencil_fade_objects": false,
+            "space.overlay.use_gpencil_grid": false,
+            "space.overlay.use_gpencil_multiedit_line_only": false,
+            "space.overlay.use_gpencil_onion_skin": false,
+            "space.overlay.use_gpencil_show_directions": false,
+            "space.overlay.use_gpencil_show_material_name": false,
+            "space.overlay.use_normals_constant_screen_size": false,
+            "space.overlay.vertex_opacity": 1.0,
+            "space.overlay.vertex_paint_mode_opacity": 1.0,
+            "space.overlay.viewer_attribute_opacity": 1.0,
+            "space.overlay.weight_paint_mode_opacity": 1.0,
+            "space.overlay.wireframe_opacity": 1.0,
+            "space.overlay.wireframe_threshold": 0.0,
+            "space.overlay.xray_alpha_bone": 0.0
+        }
+    },
+    "Blender Default": {
+        "render_type": "VIEWPORT",
+        "raster_style": {
+            "bpy.data.worlds[0].color": [
+                0.05087608844041824,
+                0.05087608844041824,
+                0.05087608844041824
+            ],
+            "scene.render.bake_bias": 0.0010000000474974513,
+            "scene.render.bake_margin": 16,
+            "scene.render.bake_margin_type": "ADJACENT_FACES",
+            "scene.render.bake_samples": 256,
+            "scene.render.bake_type": "NORMALS",
+            "scene.render.bake_user_scale": 0.0,
+            "scene.render.border_max_x": 1.0,
+            "scene.render.border_max_y": 1.0,
+            "scene.render.border_min_x": 0.0,
+            "scene.render.border_min_y": 0.0,
+            "scene.render.dither_intensity": 1.0,
+            "scene.render.engine": "BLENDER_EEVEE",
+            "scene.render.film_transparent": false,
+            "scene.render.filter_size": 1.5,
+            "scene.render.fps": 24,
+            "scene.render.fps_base": 1.0,
+            "scene.render.frame_map_new": 100,
+            "scene.render.frame_map_old": 100,
+            "scene.render.hair_subdiv": 0,
+            "scene.render.hair_type": "STRAND",
+            "scene.render.line_thickness": 1.0,
+            "scene.render.line_thickness_mode": "ABSOLUTE",
+            "scene.render.metadata_input": "SCENE",
+            "scene.render.motion_blur_shutter": 0.5,
+            "scene.render.pixel_aspect_x": 1.0,
+            "scene.render.pixel_aspect_y": 1.0,
+            "scene.render.preview_pixel_size": "AUTO",
+            "scene.render.resolution_percentage": 100,
+            "scene.render.resolution_x": 1000,
+            "scene.render.resolution_y": 1000,
+            "scene.render.sequencer_gl_preview": "SOLID",
+            "scene.render.simplify_child_particles": 1.0,
+            "scene.render.simplify_child_particles_render": 1.0,
+            "scene.render.simplify_gpencil": false,
+            "scene.render.simplify_gpencil_antialiasing": true,
+            "scene.render.simplify_gpencil_modifier": true,
+            "scene.render.simplify_gpencil_onplay": false,
+            "scene.render.simplify_gpencil_shader_fx": true,
+            "scene.render.simplify_gpencil_tint": true,
+            "scene.render.simplify_gpencil_view_fill": true,
+            "scene.render.simplify_shadows": 1.0,
+            "scene.render.simplify_shadows_render": 1.0,
+            "scene.render.simplify_subdivision": 6,
+            "scene.render.simplify_subdivision_render": 6,
+            "scene.render.simplify_volumes": 1.0,
+            "scene.render.stamp_font_size": 12,
+            "scene.render.stamp_note_text": "",
+            "scene.render.threads": 20,
+            "scene.render.threads_mode": "AUTO",
+            "scene.render.use_bake_clear": true,
+            "scene.render.use_bake_lores_mesh": false,
+            "scene.render.use_bake_multires": false,
+            "scene.render.use_bake_selected_to_active": false,
+            "scene.render.use_bake_user_scale": false,
+            "scene.render.use_border": false,
+            "scene.render.use_compositing": true,
+            "scene.render.use_crop_to_border": false,
+            "scene.render.use_file_extension": true,
+            "scene.render.use_freestyle": false,
+            "scene.render.use_high_quality_normals": false,
+            "scene.render.use_lock_interface": false,
+            "scene.render.use_motion_blur": false,
+            "scene.render.use_multiview": false,
+            "scene.render.use_overwrite": true,
+            "scene.render.use_persistent_data": false,
+            "scene.render.use_placeholder": false,
+            "scene.render.use_render_cache": false,
+            "scene.render.use_sequencer": true,
+            "scene.render.use_sequencer_override_scene_strip": false,
+            "scene.render.use_simplify": false,
+            "scene.render.use_single_layer": false,
+            "scene.render.use_stamp": false,
+            "scene.render.use_stamp_camera": true,
+            "scene.render.use_stamp_date": true,
+            "scene.render.use_stamp_filename": true,
+            "scene.render.use_stamp_frame": true,
+            "scene.render.use_stamp_frame_range": false,
+            "scene.render.use_stamp_hostname": false,
+            "scene.render.use_stamp_labels": true,
+            "scene.render.use_stamp_lens": false,
+            "scene.render.use_stamp_marker": false,
+            "scene.render.use_stamp_memory": false,
+            "scene.render.use_stamp_note": false,
+            "scene.render.use_stamp_render_time": true,
+            "scene.render.use_stamp_scene": true,
+            "scene.render.use_stamp_sequencer_strip": false,
+            "scene.render.use_stamp_time": true,
+            "scene.render.views_format": "STEREO_3D",
+            "scene.view_settings.exposure": 0.0,
+            "scene.view_settings.gamma": 1.0,
+            "scene.view_settings.look": "None",
+            "scene.view_settings.use_curve_mapping": false,
+            "scene.view_settings.view_transform": "Filmic",
+            "scene.display.shading.aov_name": "",
+            "scene.display.shading.background_color": [
+                0.0,
+                0.0,
+                0.0
+            ],
+            "scene.display.shading.background_type": "THEME",
+            "scene.display.shading.cavity_ridge_factor": 1.0,
+            "scene.display.shading.cavity_type": "WORLD",
+            "scene.display.shading.cavity_valley_factor": 1.0,
+            "scene.display.shading.color_type": "MATERIAL",
+            "scene.display.shading.curvature_ridge_factor": 0.0,
+            "scene.display.shading.curvature_valley_factor": 0.0,
+            "scene.display.shading.light": "STUDIO",
+            "scene.display.shading.object_outline_color": [
+                0.0,
+                0.0,
+                0.0
+            ],
+            "scene.display.shading.render_pass": "COMBINED",
+            "scene.display.shading.shadow_intensity": 0.5,
+            "scene.display.shading.show_backface_culling": false,
+            "scene.display.shading.show_cavity": false,
+            "scene.display.shading.show_object_outline": false,
+            "scene.display.shading.show_shadows": false,
+            "scene.display.shading.show_specular_highlight": true,
+            "scene.display.shading.show_xray": false,
+            "scene.display.shading.show_xray_wireframe": false,
+            "scene.display.shading.single_color": [
+                0.800000011920929,
+                0.800000011920929,
+                0.800000011920929
+            ],
+            "scene.display.shading.studio_light": "Default",
+            "scene.display.shading.studiolight_background_alpha": 0.0,
+            "scene.display.shading.studiolight_background_blur": 0.0,
+            "scene.display.shading.studiolight_intensity": 0.0,
+            "scene.display.shading.studiolight_rotate_z": 0.0,
+            "scene.display.shading.type": "SOLID",
+            "scene.display.shading.use_compositor": "DISABLED",
+            "scene.display.shading.use_dof": false,
+            "scene.display.shading.use_scene_lights": false,
+            "scene.display.shading.use_scene_lights_render": false,
+            "scene.display.shading.use_scene_world": false,
+            "scene.display.shading.use_scene_world_render": false,
+            "scene.display.shading.use_studiolight_view_rotation": true,
+            "scene.display.shading.use_world_space_lighting": false,
+            "scene.display.shading.wireframe_color_type": "MATERIAL",
+            "scene.display.shading.xray_alpha": 0.5,
+            "scene.display.shading.xray_alpha_wireframe": 0.0,
+            "scene.display.light_direction": [
+                0.5773502588272095,
+                0.5773502588272095,
+                0.5773502588272095
+            ],
+            "scene.display.matcap_ssao_attenuation": 1.0,
+            "scene.display.matcap_ssao_distance": 0.20000000298023224,
+            "scene.display.matcap_ssao_samples": 16,
+            "scene.display.render_aa": "8",
+            "scene.display.shadow_focus": 0.0,
+            "scene.display.shadow_shift": 0.10000000149011612,
+            "scene.display.viewport_aa": "FXAA",
+            "space.overlay.backwire_opacity": 0.5,
+            "space.overlay.bone_wire_alpha": 1.0,
+            "space.overlay.display_handle": "SELECTED",
+            "space.overlay.fade_inactive_alpha": 0.4000000059604645,
+            "space.overlay.gpencil_fade_layer": 0.5,
+            "space.overlay.gpencil_fade_objects": 0.5,
+            "space.overlay.gpencil_grid_opacity": 0.5,
+            "space.overlay.gpencil_vertex_paint_opacity": 1.0,
+            "space.overlay.grid_lines": 16,
+            "space.overlay.grid_scale": 1.0,
+            "space.overlay.grid_subdivisions": 10,
+            "space.overlay.normals_constant_screen_size": 7.0,
+            "space.overlay.normals_length": 0.10000000149011612,
+            "space.overlay.sculpt_curves_cage_opacity": 0.5,
+            "space.overlay.sculpt_mode_face_sets_opacity": 1.0,
+            "space.overlay.sculpt_mode_mask_opacity": 0.75,
+            "space.overlay.show_annotation": true,
+            "space.overlay.show_axis_x": true,
+            "space.overlay.show_axis_y": true,
+            "space.overlay.show_axis_z": false,
+            "space.overlay.show_bones": true,
+            "space.overlay.show_cursor": true,
+            "space.overlay.show_curve_normals": false,
+            "space.overlay.show_edge_bevel_weight": true,
+            "space.overlay.show_edge_crease": true,
+            "space.overlay.show_edge_seams": true,
+            "space.overlay.show_edge_sharp": true,
+            "space.overlay.show_edges": false,
+            "space.overlay.show_extra_edge_angle": false,
+            "space.overlay.show_extra_edge_length": false,
+            "space.overlay.show_extra_face_angle": false,
+            "space.overlay.show_extra_face_area": false,
+            "space.overlay.show_extra_indices": false,
+            "space.overlay.show_extras": true,
+            "space.overlay.show_face_center": false,
+            "space.overlay.show_face_normals": false,
+            "space.overlay.show_face_orientation": false,
+            "space.overlay.show_faces": true,
+            "space.overlay.show_fade_inactive": false,
+            "space.overlay.show_floor": true,
+            "space.overlay.show_freestyle_edge_marks": true,
+            "space.overlay.show_freestyle_face_marks": true,
+            "space.overlay.show_look_dev": false,
+            "space.overlay.show_motion_paths": true,
+            "space.overlay.show_object_origins": true,
+            "space.overlay.show_object_origins_all": false,
+            "space.overlay.show_occlude_wire": false,
+            "space.overlay.show_onion_skins": false,
+            "space.overlay.show_ortho_grid": true,
+            "space.overlay.show_outline_selected": true,
+            "space.overlay.show_overlays": true,
+            "space.overlay.show_paint_wire": false,
+            "space.overlay.show_relationship_lines": true,
+            "space.overlay.show_sculpt_curves_cage": true,
+            "space.overlay.show_sculpt_face_sets": true,
+            "space.overlay.show_sculpt_mask": true,
+            "space.overlay.show_split_normals": false,
+            "space.overlay.show_stats": false,
+            "space.overlay.show_statvis": false,
+            "space.overlay.show_text": true,
+            "space.overlay.show_vertex_normals": false,
+            "space.overlay.show_viewer_attribute": true,
+            "space.overlay.show_weight": false,
+            "space.overlay.show_wireframes": false,
+            "space.overlay.show_wpaint_contours": false,
+            "space.overlay.show_xray_bone": false,
+            "space.overlay.texture_paint_mode_opacity": 1.0,
+            "space.overlay.use_debug_freeze_view_culling": false,
+            "space.overlay.use_gpencil_canvas_xray": false,
+            "space.overlay.use_gpencil_edit_lines": true,
+            "space.overlay.use_gpencil_fade_gp_objects": false,
+            "space.overlay.use_gpencil_fade_layers": false,
+            "space.overlay.use_gpencil_fade_objects": false,
+            "space.overlay.use_gpencil_grid": false,
+            "space.overlay.use_gpencil_multiedit_line_only": false,
+            "space.overlay.use_gpencil_onion_skin": false,
+            "space.overlay.use_gpencil_show_directions": false,
+            "space.overlay.use_gpencil_show_material_name": false,
+            "space.overlay.use_normals_constant_screen_size": false,
+            "space.overlay.vertex_opacity": 1.0,
+            "space.overlay.vertex_paint_mode_opacity": 1.0,
+            "space.overlay.viewer_attribute_opacity": 1.0,
+            "space.overlay.weight_paint_mode_opacity": 1.0,
+            "space.overlay.wireframe_opacity": 1.0,
+            "space.overlay.wireframe_threshold": 1.0,
+            "space.overlay.xray_alpha_bone": 0.0
+        }
+    }
+}

src/blenderbim/blenderbim/bim/data/gantt/index.mustache

@@ -1,67 +1,55 @@
 <link href="jsgantt.css" rel="stylesheet" type="text/css"/>
+<link href="../../module/sequence/gantt/main.css" rel="stylesheet" type="text/css"/>
 <script src="jsgantt.js" type="text/javascript"></script>
-<style>
-.gtaskcellwkend,
-.gtaskcellcurrent,
-.gminorheadingwkend {
-  background-color: #e1e1e1;
-}
-
-.gitemhighlight td {
-  background-color: #ffdaaa;
-}
-
-.gtaskblue {
-  background: #4281A4;
-}
-
-.gtaskred {
-  background: #C1666B;
-}
-
-.gtaskgreen {
-  background: #48A9A6;
-}
-
-.gtaskyellow {
-  background: #D4B483;
-}
-
-.gmainleft {
-  overflow: visible;
-  flex: 0 1 auto;
-}
-
-</style>
-<a href="#print" id="print">Print Mode</a>
-<div style="position:relative" class="gantt" id="GanttChartDIV"></div>
-<script type="text/javascript">
-var g = new JSGantt.GanttChart(document.getElementById('GanttChartDIV'), 'day');
-g.setOptions({
-    vCaptionType: 'Caption',  // Set to Show Caption : None,Caption,Resource,Duration,Complete,
-    vQuarterColWidth: 36,
-    vDateTaskDisplayFormat: 'day dd month yyyy', // Shown in tool tip box
-    vDayMajorDateDisplayFormat: 'mon yyyy - Week ww',// Set format to dates in the "Major" header of the "Day" view
-    vWeekMinorDateDisplayFormat: 'dd mon', // Set format to display dates in the "Minor" header of the "Week" view
-    vLang: 'en',
-    vShowTaskInfoLink: 1, // Show link in tool tip (0/1)
-    vShowEndWeekDate: 0,  // Show/Hide the date for the last day of the week in header for daily
-    vUseSingleCell: 10000, // Set the threshold cell per table row (Helps performance for large data.
-    vFormatArr: ['Day', 'Week', 'Month', 'Quarter'], // Even with setUseSingleCell using Hour format on such a large chart can cause issues in some browsers,
-    vShowRes: false, // Disable the resource column.
-    vShowComp: false, // Disable the completion column.
-    vShowDur: false, // Disable the duration column, because jsgantt doesn't calculate durations the way we want.
-    vAdditionalHeaders: {ifcduration: {title: 'Duration'}},
-    vUseToolTip: false, // Disable tooltips.
-    vTotalHeight: 900,
-});
-document.getElementById('print').addEventListener('click', function() {
-    g.setTotalHeight("");
-    g.Draw();
-});
-var json_data = `
-{{{json_data}}}
-`;
-JSGantt.parseJSONString(json_data, g);
-g.Draw();
+<script type="text/javascript" src="../../module/sequence/gantt/index.js"></script>
+<script>
+var json_data = `{{{json_data}}}`;
 </script>
+
+<div id="options" class="no-print">
+  <h4>Choose a language:
+  <select id="lang" class="sweet_button" onchange="set_language(event)">
+    <option value='cn'>Chinese (cn)</option>
+    <option value='cs'>Czech (cs)</option>
+    <option value='nl'>Dutch (Standard)</option>
+    <option value='en' selected>English (en)</option>
+    <option value='fr'>French (fr)</option>
+    <option value='de'>German (de)</option>
+    <option value='hu'>Hungarian (hu)</option>
+    <option value='id'>Indonesian (id)</option>
+    <option value='it'>Italian (it)</option>
+    <option value='ja'>Japanese (ja)</option>
+    <option value='pt'>Portuguese (pt)</option>
+    <option value='ru'>Russian (ru)</option>
+    <option value='es'>Spanish (es)</option>
+    <option value='sv'>Swedish (sv)</option>
+    <option value='tr'>Turkish (tr)</option>
+  </select>
+  </h4>
+
+  <br>
+</div>
+<div class="top-right no-print" id="print_options">
+  <select class="sweet_button" id="print_page_size">
+    <option value="210,297">A4 Portrait</option>
+    <option value="297,210">A4 Landscape</option>
+    <option value="297,420">A3 Portrait</option>
+    <option value="420,297">A3 Landscape</option>
+    <option value="420,594">A2 Portrait</option>
+    <option value="594,420">A2 Landscape</option>
+    <option value="594,841">A1 Portrait</option>
+    <option value="841,594">A1 Landscape</option>
+    <option value="841,1189">A0 Portrait</option>
+    <option value="1189,841">A0 Landscape</option>
+  </select>
+</div>
+
+<div id="schedule-data" class="no-print"></div>
+<div id="schedule-header" style=""></div>
+<div style="position:relative" class="gantt" id="GanttChartDIV"></div>
+
+<script>
+var data = `{{{data}}}`;
+setupPage(data);
+create_gantt_chart(json_data)
+</script>

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

@@ -5,7 +5,7 @@ FILE_NAME('EPset_Drawing.ifc','2020-01-01T00:00:00',(),(),'EPset_Drawing','EPset
 FILE_SCHEMA(('IFC4'));
 ENDSEC;
 DATA;
-#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation',(#2,#3,#4,#5,#6,#7,#8,#9,#10,#11,#12,#13,#14,#15,#16,#17,#18,#19));
+#1=IFCPROPERTYSETTEMPLATE('2JhNIvqZrFnAgxfhK0XVQX',$,'EPset_Drawing','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation',(#2,#3,#4,#5,#6,#7,#8,#9,#10,#11,#12,#13,#14,#15,#16,#17,#18,#19,#20,#21));
 #2=IFCSIMPLEPROPERTYTEMPLATE('23JavTMk98ZxXhrUEnjAcf',$,'TargetView','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #3=IFCSIMPLEPROPERTYTEMPLATE('1yVWUt5H9DAOuu0OaMMLpe',$,'Scale','The scale of this drawing represented as a numerator and denominator, such as 1/100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #4=IFCSIMPLEPROPERTYTEMPLATE('3gsuPBtU93b8f0gg1pjkq6',$,'HumanScale','The scale of this drawing in human readable format, such as 1:100',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -24,5 +24,7 @@ DATA;
 #17=IFCSIMPLEPROPERTYTEMPLATE('38uAtrp9nD_901NO42zd$7',$,'ImperialPrecision','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #18=IFCSIMPLEPROPERTYTEMPLATE('1MX0uffTL6TOvtvEJpxFmk',$,'DecimalPlaces','',.P_SINGLEVALUE.,'IfcInteger',$,$,$,$,$,.READWRITE.);
 #19=IFCSIMPLEPROPERTYTEMPLATE('0joEq0Rd10cxweEh0NeHT6',$,'JoinCriteria','Comma separated selection keys which determine what cut objects are to be joined.',.P_SINGLEVALUE.,'IfcText',$,$,$,$,$,.READWRITE.);
+#20=IFCSIMPLEPROPERTYTEMPLATE('0nYMT3OSj5gArVniCWZRtv',$,'ShadingStyles','',.P_SINGLEVALUE.,'IfcURIReference',$,$,$,$,$,.READWRITE.);
+#21=IFCSIMPLEPROPERTYTEMPLATE('3VWG22eZXBdQwdKlzMeVQH',$,'CurrentShadingStyle','',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 ENDSEC;
 END-ISO-10303-21;

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

@@ -18,7 +18,7 @@ DATA;
 #11=IFCSIMPLEPROPERTYTEMPLATE('1DtsPn5a9FG8$zXHDDMavY',$,'ShowEndArrow','Display end arrow.',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
 #12=IFCSIMPLEPROPERTYTEMPLATE('2$6U0mLI9AiPRWeBabdY3u',$,'EndArrowSymbol','Custom symbol for the end of the section marker arrow. Need to make sure it''s present in "symbols.svg".',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #13=IFCSIMPLEPROPERTYTEMPLATE('1naFqntIL7igCY7hCaE7kq',$,'HasConnectedSectionLine','Connect or disconnect section markers with line (by default = True).',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
-#14=IFCPROPERTYSETTEMPLATE('3V8oZ8YRD3_O7uR5vcUleS',$,'BBIM_Documentation','',.PSET_OCCURRENCEDRIVEN.,'IfcProject',(#15,#16,#17,#18,#19,#20,#21,#22));
+#14=IFCPROPERTYSETTEMPLATE('3V8oZ8YRD3_O7uR5vcUleS',$,'BBIM_Documentation','',.PSET_OCCURRENCEDRIVEN.,'IfcProject',(#15,#16,#17,#18,#19,#20,#21,#22,#23));
 #15=IFCSIMPLEPROPERTYTEMPLATE('0ulAhgk3v9qfGlDILauR6J',$,'SheetsDir','Default sheets directory',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #16=IFCSIMPLEPROPERTYTEMPLATE('2yvlVKiQXASucfH40deCvu',$,'LayoutsDir','Default layouts directory',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #17=IFCSIMPLEPROPERTYTEMPLATE('2kXZqXicL3jRwsOnLM_0ho',$,'TitleblocksDir','Default titleblocks directory',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
@@ -27,8 +27,12 @@ DATA;
 #20=IFCSIMPLEPROPERTYTEMPLATE('23tejOrxj859R_eCRp1AFP',$,'MarkersPath','Default markers SVG',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #21=IFCSIMPLEPROPERTYTEMPLATE('1UDakJ5_f7kBhggNSW4$h5',$,'SymbolsPath','Default symbols SVG',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
 #22=IFCSIMPLEPROPERTYTEMPLATE('0d53LEtgLDQxnv__NfgH7i',$,'PatternsPath','Default patterns SVG',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
-#23=IFCPROPERTYSETTEMPLATE('0I9merLinF5Ap$aZwaclgm',$,'BBIM_Dimension','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#24,#25));
-#24=IFCSIMPLEPROPERTYTEMPLATE('1rL2AbQsXD8RbpoWH5pYOV',$,'ShowDescriptionOnly','Hide the measurement values and show only annotation description',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
-#25=IFCSIMPLEPROPERTYTEMPLATE('0SVyOfB0rC2xNfdRYf3XvY',$,'SuppressZeroInches','Suppress 0 inch values in dimension annotation text (for example: 12'' - 0" -> 12'')',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#23=IFCSIMPLEPROPERTYTEMPLATE('26qFNMv7nCHgU6Jd7Anga5',$,'ShadingStylesPath','Default shading styles',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
+#24=IFCPROPERTYSETTEMPLATE('0I9merLinF5Ap$aZwaclgm',$,'BBIM_Dimension','',.PSET_OCCURRENCEDRIVEN.,'IfcAnnotation,IfcTypeProduct',(#25,#26,#27,#28));
+#25=IFCSIMPLEPROPERTYTEMPLATE('1rL2AbQsXD8RbpoWH5pYOV',$,'ShowDescriptionOnly','Hide the measurement values and show only annotation description',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#26=IFCSIMPLEPROPERTYTEMPLATE('0SVyOfB0rC2xNfdRYf3XvY',$,'SuppressZeroInches','Suppress 0 inch values in dimension annotation text (for example: 12'' - 0" -> 12'')',.P_SINGLEVALUE.,'IfcBoolean',$,$,$,$,$,.READWRITE.);
+#27=IFCSIMPLEPROPERTYTEMPLATE('2bUmj458PBqPAtUoI3MXsb',$,'TextPrefix','Text to add before annotation measurement value',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
+#28=IFCSIMPLEPROPERTYTEMPLATE('0bnzttUb9BPuN597uNTXOE',$,'TextSuffix','Text to add after annotation measurement value',.P_SINGLEVALUE.,'IfcLabel',$,$,$,$,$,.READWRITE.);
+
 ENDSEC;
 END-ISO-10303-21;

src/blenderbim/blenderbim/bim/handler.py

@@ -22,11 +22,12 @@ import addon_utils
 import ifcopenshell.api.owner.settings
 import blenderbim.tool as tool
 import blenderbim.core.owner as core_owner
-from blenderbim.bim.module.drawing.prop import RasterStyleProperty
 from bpy.app.handlers import persistent
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.owner.prop import get_user_person, get_user_organisation
 from blenderbim.bim.module.model.data import AuthoringData
+from mathutils import Vector
+from math import cos, degrees
 
 
 global_subscription_owner = object()
@@ -99,6 +100,53 @@ def color_callback(obj, data):
 
 def active_object_callback():
     refresh_ui_data()
+    update_bim_tool_props()
+
+
+def update_bim_tool_props():
+    """update BIM Tools props (such as extrusion_depth, length and x_angle) when active object changes"""
+    obj = bpy.context.active_object
+
+    # bunch of checks to see if we're in a valid state
+    if not obj:
+        return
+    mode = bpy.context.mode
+    current_tool = bpy.context.workspace.tools.from_space_view3d_mode(mode).idname
+    if current_tool != "bim.bim_tool":
+        return
+    element = tool.Ifc.get_entity(obj)
+    if not element:
+        return
+    representation = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
+    if not representation:
+        return
+    extrusion = tool.Model.get_extrusion(representation)
+    if not extrusion:
+        return
+
+    def get_x_angle(extrusion):
+        x, y, z = extrusion.ExtrudedDirection.DirectionRatios
+        x_angle = Vector((0, 1)).angle_signed(Vector((y, z)))
+        return x_angle
+
+    si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+    props = bpy.context.scene.BIMModelProperties
+    if not AuthoringData.is_loaded:
+        AuthoringData.load()
+
+    if AuthoringData.data["active_material_usage"] == "LAYER2":
+        x_angle = get_x_angle(extrusion)
+        axis = tool.Model.get_wall_axis(obj)["reference"]
+        props.extrusion_depth = extrusion.Depth * si_conversion * cos(x_angle)
+        props.length = (axis[1] - axis[0]).length
+        props.x_angle = x_angle
+
+    elif AuthoringData.data["active_material_usage"] == "LAYER3":
+        x_angle = get_x_angle(extrusion)
+        props.x_angle = x_angle
+
+    elif AuthoringData.data["active_material_usage"] == "PROFILE":
+        props.extrusion_depth = extrusion.Depth * si_conversion
 
 
 def active_material_index_callback(obj, data):
@@ -233,73 +281,4 @@ def setDefaultProperties(scene):
     )
     ifcopenshell.api.owner.settings.get_user = lambda ifc: core_owner.get_user(tool.Owner)
     ifcopenshell.api.owner.settings.get_application = get_application
-    # TODO: Move to drawing module
-    if len(bpy.context.scene.DocProperties.drawing_styles) == 0:
-        drawing_style = bpy.context.scene.DocProperties.drawing_styles.add()
-        drawing_style.name = "Blender Default"
-        drawing_style.render_type = "DEFAULT"
-        bpy.ops.bim.save_drawing_style(index="0")
-
-        drawing_style = bpy.context.scene.DocProperties.drawing_styles.add()
-        drawing_style.name = "Technical"
-        drawing_style.render_type = "VIEWPORT"
-        drawing_style.raster_style = json.dumps(
-            {
-                RasterStyleProperty.WORLD_COLOR.value: (1, 1, 1),
-                RasterStyleProperty.RENDER_ENGINE.value: "BLENDER_WORKBENCH",
-                RasterStyleProperty.RENDER_TRANSPARENT.value: False,
-                RasterStyleProperty.SHADING_SHOW_OBJECT_OUTLINE.value: True,
-                RasterStyleProperty.SHADING_SHOW_CAVITY.value: False,
-                RasterStyleProperty.SHADING_CAVITY_TYPE.value: "BOTH",
-                RasterStyleProperty.SHADING_CURVATURE_RIDGE_FACTOR.value: 1,
-                RasterStyleProperty.SHADING_CURVATURE_VALLEY_FACTOR.value: 1,
-                RasterStyleProperty.VIEW_TRANSFORM.value: "Standard",
-                RasterStyleProperty.SHADING_LIGHT.value: "FLAT",
-                RasterStyleProperty.SHADING_COLOR_TYPE.value: "SINGLE",
-                RasterStyleProperty.SHADING_SINGLE_COLOR.value: (1, 1, 1),
-                RasterStyleProperty.SHADING_SHOW_SHADOWS.value: False,
-                RasterStyleProperty.SHADING_SHADOW_INTENSITY.value: 0.5,
-                RasterStyleProperty.DISPLAY_LIGHT_DIRECTION.value: (0.5, 0.5, 0.5),
-                RasterStyleProperty.VIEW_USE_CURVE_MAPPING.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_WIREFRAMES.value: True,
-                RasterStyleProperty.OVERLAY_WIREFRAME_THRESHOLD.value: 0,
-                RasterStyleProperty.OVERLAY_SHOW_FLOOR.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_AXIS_X.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_AXIS_Y.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_AXIS_Z.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_OBJECT_ORIGINS.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_RELATIONSHIP_LINES.value: False,
-            }
-        )
-        drawing_style = bpy.context.scene.DocProperties.drawing_styles.add()
-        drawing_style.name = "Shaded"
-        drawing_style.render_type = "VIEWPORT"
-        drawing_style.raster_style = json.dumps(
-            {
-                RasterStyleProperty.WORLD_COLOR.value: (1, 1, 1),
-                RasterStyleProperty.RENDER_ENGINE.value: "BLENDER_WORKBENCH",
-                RasterStyleProperty.RENDER_TRANSPARENT.value: False,
-                RasterStyleProperty.SHADING_SHOW_OBJECT_OUTLINE.value: True,
-                RasterStyleProperty.SHADING_SHOW_CAVITY.value: True,
-                RasterStyleProperty.SHADING_CAVITY_TYPE.value: "BOTH",
-                RasterStyleProperty.SHADING_CURVATURE_RIDGE_FACTOR.value: 1,
-                RasterStyleProperty.SHADING_CURVATURE_VALLEY_FACTOR.value: 1,
-                RasterStyleProperty.VIEW_TRANSFORM.value: "Standard",
-                RasterStyleProperty.SHADING_LIGHT.value: "STUDIO",
-                RasterStyleProperty.SHADING_COLOR_TYPE.value: "MATERIAL",
-                RasterStyleProperty.SHADING_SINGLE_COLOR.value: (1, 1, 1),
-                RasterStyleProperty.SHADING_SHOW_SHADOWS.value: True,
-                RasterStyleProperty.SHADING_SHADOW_INTENSITY.value: 0.5,
-                RasterStyleProperty.DISPLAY_LIGHT_DIRECTION.value: (0.5, 0.5, 0.5),
-                RasterStyleProperty.VIEW_USE_CURVE_MAPPING.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_WIREFRAMES.value: False,
-                RasterStyleProperty.OVERLAY_WIREFRAME_THRESHOLD.value: 0,
-                RasterStyleProperty.OVERLAY_SHOW_FLOOR.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_AXIS_X.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_AXIS_Y.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_AXIS_Z.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_OBJECT_ORIGINS.value: False,
-                RasterStyleProperty.OVERLAY_SHOW_RELATIONSHIP_LINES.value: False,
-            }
-        )
-        AuthoringData.type_thumbnails = {}
+    AuthoringData.type_thumbnails = {}

src/blenderbim/blenderbim/bim/import_ifc.py

@@ -36,7 +36,7 @@ import ifcopenshell.util.geolocation
 import blenderbim.tool as tool
 from itertools import chain, accumulate
 from blenderbim.bim.ifc import IfcStore
-from blenderbim.bim.module.drawing.prop import get_diagram_scales
+from blenderbim.bim.module.drawing.prop import ANNOTATION_TYPES_DATA
 
 
 class FileCopy(threading.Thread):
@@ -178,6 +178,11 @@ class IfcImporter:
         self.settings.set_deflection_tolerance(self.ifc_import_settings.deflection_tolerance)
         self.settings.set_angular_tolerance(self.ifc_import_settings.angular_tolerance)
         self.settings.set(self.settings.STRICT_TOLERANCE, True)
+        self.settings_curve = ifcopenshell.geom.settings()
+        self.settings_curve.set_deflection_tolerance(self.ifc_import_settings.deflection_tolerance)
+        self.settings_curve.set_angular_tolerance(self.ifc_import_settings.angular_tolerance)
+        self.settings_curve.set(self.settings_curve.STRICT_TOLERANCE, True)
+        self.settings_curve.set(self.settings_curve.INCLUDE_CURVES, True)
         self.settings_native = ifcopenshell.geom.settings()
         self.settings_native.set(self.settings_native.INCLUDE_CURVES, True)
         self.settings_2d = ifcopenshell.geom.settings()
@@ -376,7 +381,7 @@ class IfcImporter:
         representations = self.get_transformed_body_representations(element.Representation.Representations)
 
         # Single swept disk solids (e.g. rebar) are better natively represented as beveled curves
-        if self.is_native_swept_disk_solid(representations):
+        if self.is_native_swept_disk_solid(element, representations):
             self.native_data[element.GlobalId] = {
                 "representations": representations,
                 "representation": self.get_body_representation(element.Representation.Representations),
@@ -404,7 +409,11 @@ class IfcImporter:
             }
             return True
 
-    def is_native_swept_disk_solid(self, representations):
+    def is_native_swept_disk_solid(self, element, representations):
+        # detect BBIM Railings to represent them with meshes and not curves
+        if tool.Pset.get_element_pset(element, "BBIM_Railing"):
+            return False
+
         for representation in representations:
             items = representation["raw"].Items or []  # Be forgiving of invalid IFCs because Revit :(
             if len(items) == 1 and items[0].is_a("IfcSweptDiskSolid"):
@@ -683,28 +692,31 @@ class IfcImporter:
 
     def create_generic_elements(self, elements):
         # Based on my experience in viewing BIM models, representations are prioritised as follows:
-        # 1. 3D Body, 2. 2D Plans, 3. Point clouds, 4. No representation
-        # If an element has a representation that doesn't follow 1, 2, or 3, it will not show by default.
+        # 1. 3D Body, 2. 2D Body, 3. 2D Plans / annotations, 4. Point clouds, 5. No representation
+        # If an element has a representation that doesn't follow 1, 2, 3, or 4, it will not show by default.
         # The user can load them later if they want to view them.
         products = self.create_products(elements)
         elements -= products
-        products = self.create_curve_products(elements)
+        products = self.create_products(elements, settings=self.settings_curve)
+        elements -= products
+        products = self.create_products(elements, settings=self.settings_2d)
         elements -= products
         products = self.create_pointclouds(elements)
         elements -= products
         for element in elements:
             self.create_product(element)
 
-    def create_products(self, products):
+    def create_products(self, products, settings=None):
+        if settings is None:
+            settings = self.settings
+
         results = set()
         if not products:
             return results
         if self.ifc_import_settings.should_use_cpu_multiprocessing:
-            iterator = ifcopenshell.geom.iterator(
-                self.settings, self.file, multiprocessing.cpu_count(), include=products
-            )
+            iterator = ifcopenshell.geom.iterator(settings, self.file, multiprocessing.cpu_count(), include=products)
         else:
-            iterator = ifcopenshell.geom.iterator(self.settings, self.file, include=products)
+            iterator = ifcopenshell.geom.iterator(settings, self.file, include=products)
         if self.ifc_import_settings.should_cache:
             cache = IfcStore.get_cache()
             if cache:
@@ -771,10 +783,10 @@ class IfcImporter:
         self.structural_collection.children.link(self.structural_connection_collection)
         self.project["blender"].children.link(self.structural_collection)
 
-        self.create_curve_products(self.file.by_type("IfcStructuralCurveMember"))
-        self.create_curve_products(self.file.by_type("IfcStructuralCurveConnection"))
-        self.create_curve_products(self.file.by_type("IfcStructuralSurfaceMember"))
-        self.create_curve_products(self.file.by_type("IfcStructuralSurfaceConnection"))
+        self.create_products(self.file.by_type("IfcStructuralCurveMember"), settings=self.settings_2d)
+        self.create_products(self.file.by_type("IfcStructuralCurveConnection"), settings=self.settings_2d)
+        self.create_products(self.file.by_type("IfcStructuralSurfaceMember"), settings=self.settings_2d)
+        self.create_products(self.file.by_type("IfcStructuralSurfaceConnection"), settings=self.settings_2d)
         self.create_structural_point_connections()
 
     def create_structural_point_connections(self):
@@ -862,40 +874,6 @@ class IfcImporter:
         self.link_element(product, obj)
         return product
 
-    def create_curve_products(self, products):
-        results = set()
-        if not products:
-            return results
-        if self.ifc_import_settings.should_use_cpu_multiprocessing:
-            iterator = ifcopenshell.geom.iterator(
-                self.settings_2d, self.file, multiprocessing.cpu_count(), include=products
-            )
-        else:
-            iterator = ifcopenshell.geom.iterator(self.settings_2d, self.file, include=products)
-        if self.ifc_import_settings.should_cache:
-            cache = IfcStore.get_cache()
-            if cache:
-                iterator.set_cache(cache)
-        valid_file = iterator.initialize()
-        if not valid_file:
-            return results
-        checkpoint = time.time()
-        total = 0
-        while True:
-            total += 1
-            if total % 250 == 0:
-                print("{} elements processed in {:.2f}s ...".format(total, time.time() - checkpoint))
-                checkpoint = time.time()
-            shape = iterator.get()
-            if shape:
-                product = self.file.by_id(shape.id)
-                self.create_product(product, shape)
-                results.add(product)
-            if not iterator.next():
-                break
-        print("Done creating geometry")
-        return results
-
     def create_product(self, element, shape=None, mesh=None):
         if element is None:
             return
@@ -1333,14 +1311,20 @@ class IfcImporter:
                         bpy.context.scene.unit_settings.length_unit = "FEET"
             elif unit.is_a("IfcNamedUnit") and unit.UnitType == "AREAUNIT":
                 name = unit.Name if unit.is_a("IfcSIUnit") else unit.Name.lower()
-                bpy.context.scene.BIMProperties.area_unit = "{}{}".format(
-                    unit.Prefix + "/" if hasattr(unit, "Prefix") and unit.Prefix else "", name
-                )
+                try:
+                    bpy.context.scene.BIMProperties.area_unit = "{}{}".format(
+                        unit.Prefix + "/" if hasattr(unit, "Prefix") and unit.Prefix else "", name
+                    )
+                except:  # Probably an invalid unit.
+                    bpy.context.scene.BIMProperties.area_unit = "SQUARE_METRE"
             elif unit.is_a("IfcNamedUnit") and unit.UnitType == "VOLUMEUNIT":
                 name = unit.Name if unit.is_a("IfcSIUnit") else unit.Name.lower()
-                bpy.context.scene.BIMProperties.volume_unit = "{}{}".format(
-                    unit.Prefix + "/" if hasattr(unit, "Prefix") and unit.Prefix else "", name
-                )
+                try:
+                    bpy.context.scene.BIMProperties.volume_unit = "{}{}".format(
+                        unit.Prefix + "/" if hasattr(unit, "Prefix") and unit.Prefix else "", name
+                    )
+                except:  # Probably an invalid unit.
+                    bpy.context.scene.BIMProperties.volume_unit = "CUBIC_METRE"
 
     def create_project(self):
         project = self.file.by_type("IfcProject")[0]
@@ -1731,14 +1715,8 @@ class IfcImporter:
             bpy.context.scene.collection.objects.link(obj)
 
     def is_curve_annotation(self, element):
-        return element.ObjectType in [
-            "DIMENSION",
-            "EQUAL_DIMENSION",
-            "PLAN_LEVEL",
-            "SECTION_LEVEL",
-            "STAIR_ARROW",
-            "TEXT_LEADER",
-        ]
+        object_type = element.ObjectType
+        return object_type in ANNOTATION_TYPES_DATA and ANNOTATION_TYPES_DATA[object_type][3] == "curve"
 
     def get_drawing_group(self, element):
         for rel in element.HasAssignments or []:

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

@@ -43,13 +43,22 @@ class BIM_OT_assign_object(bpy.types.Operator, Operator):
     related_object: bpy.props.IntProperty()
 
     def _execute(self, context):
-        core.assign_object(
-            tool.Ifc,
-            tool.Aggregate,
-            tool.Collector,
-            relating_obj=tool.Ifc.get_object(tool.Ifc.get().by_id(self.relating_object)),
-            related_obj=tool.Ifc.get_object(tool.Ifc.get().by_id(self.related_object)),
-        )
+        for obj in bpy.context.selected_objects:
+            element = tool.Ifc.get_entity(obj)
+            if not element:
+                continue
+            relating_obj = tool.Ifc.get_object(tool.Ifc.get().by_id(self.relating_object))
+            result = core.assign_object(
+                tool.Ifc,
+                tool.Aggregate,
+                tool.Collector,
+                relating_obj=relating_obj,
+                related_obj=obj,
+            )
+            if not result:
+                self.report({"ERROR"}, f"Objects {relating_obj} and {obj} cannot be aggregated")
+
+        return {"FINISHED"}
 
 
 class BIM_OT_unassign_object(bpy.types.Operator, Operator):

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

@@ -60,6 +60,8 @@ class EnableEditingAttributes(bpy.types.Operator):
                 new.data_type = "string"
                 new.ifc_class = data["type"]
                 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]"
 
         blenderbim.bim.helper.import_attributes2(
             tool.Ifc.get().by_id(oprops.ifc_definition_id), props.attributes, callback=callback

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

@@ -20,28 +20,37 @@ import bpy
 from . import ui, operator, prop
 
 classes = (
+    operator.AddBoundary,
     operator.ColourByRelatedBuildingElement,
     operator.DisableEditingBoundary,
+    operator.DisableEditingBoundaryGeometry,
     operator.EditBoundaryAttributes,
+    operator.EditBoundaryGeometry,
     operator.EnableEditingBoundary,
+    operator.EnableEditingBoundaryGeometry,
+    operator.HideBoundaries,
+    operator.LoadBoundary,
     operator.LoadProjectSpaceBoundaries,
     operator.LoadSpaceBoundaries,
-    operator.LoadBoundary,
-    operator.SelectRelatedElementBoundaries,
     operator.SelectProjectBoundaries,
+    operator.SelectRelatedElementBoundaries,
     operator.SelectRelatedElementTypeBoundaries,
     operator.SelectSpaceBoundaries,
+    operator.ShowBoundaries,
     operator.UpdateBoundaryGeometry,
     ui.BIM_PT_Boundary,
     ui.BIM_PT_SceneBoundaries,
     ui.BIM_PT_SpaceBoundaries,
     prop.BIMBoundaryProperties,
+    prop.BIMObjectBoundaryProperties,
 )
 
 
 def register():
-    bpy.types.Object.bim_boundary_properties = bpy.props.PointerProperty(type=prop.BIMBoundaryProperties)
+    bpy.types.Scene.BIMBoundaryProperties = bpy.props.PointerProperty(type=prop.BIMBoundaryProperties)
+    bpy.types.Object.bim_boundary_properties = bpy.props.PointerProperty(type=prop.BIMObjectBoundaryProperties)
 
 
 def unregister():
+    del bpy.types.Scene.BIMBoundaryProperties
     del bpy.types.Object.bim_boundary_properties

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

@@ -0,0 +1,112 @@
+# BlenderBIM Add-on - OpenBIM Blender Add-on
+# Copyright (C) 2023 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 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
+
+
+class BoundaryDecorator:
+    installed = None
+
+    @classmethod
+    def install(cls, context):
+        if cls.installed:
+            cls.uninstall()
+        handler = cls()
+        cls.installed = SpaceView3D.draw_handler_add(handler, (context,), "WINDOW", "POST_VIEW")
+
+    @classmethod
+    def uninstall(cls):
+        try:
+            SpaceView3D.draw_handler_remove(cls.installed, "WINDOW")
+        except ValueError:
+            pass
+        cls.installed = None
+
+    def draw_batch(self, shader_type, content_pos, color, indices=None):
+        shader = self.line_shader if shader_type == "LINES" else self.shader
+        batch = batch_for_shader(shader, shader_type, {"pos": content_pos}, indices=indices)
+        shader.uniform_float("color", color)
+        batch.draw(shader)
+
+    def __call__(self, context):
+        self.addon_prefs = context.preferences.addons["blenderbim"].preferences
+        selected_elements_color = self.addon_prefs.decorator_color_selected
+        unselected_elements_color = self.addon_prefs.decorator_color_unselected
+        special_elements_color = self.addon_prefs.decorator_color_special
+
+        def transparent_color(color, alpha=0.1):
+            color = [i for i in color]
+            color[3] = alpha
+            return color
+
+        gpu.state.point_size_set(6)
+        gpu.state.blend_set("ALPHA")
+
+        self.line_shader = gpu.shader.from_builtin("3D_POLYLINE_UNIFORM_COLOR")
+        self.line_shader.bind()  # required to be able to change uniforms of the shader
+        # POLYLINE_UNIFORM_COLOR specific uniforms
+        self.line_shader.uniform_float("viewportSize", (context.region.width, context.region.height))
+        self.line_shader.uniform_float("lineWidth", 2.0)
+
+        # general shader
+        self.shader = gpu.shader.from_builtin("3D_UNIFORM_COLOR")
+
+        selected_vertices = []
+        selected_edges = []
+        selected_tris = []
+        unselected_vertices = []
+        unselected_edges = []
+        unselected_tris = []
+
+        for boundary in context.scene.BIMBoundaryProperties.boundaries:
+            obj = boundary.obj
+            if not obj or not obj.data:  # A boundary may not have data if it has no connection geometry
+                continue
+
+            if obj.mode == "EDIT":
+                continue  # A profile decorator or something else is used here.
+            else:
+                bm = bmesh.new()
+                bm.from_mesh(obj.data)
+                obj.data.calc_loop_triangles()
+
+                if obj.select_get():
+                    offset = len(selected_vertices)
+                    selected_vertices.extend([tuple(obj.matrix_world @ v.co) for v in bm.verts])
+                    selected_edges.extend([tuple([v.index + offset for v in e.verts]) for e in bm.edges])
+                    selected_tris.extend([tuple([i + offset for i in t.vertices]) for t in obj.data.loop_triangles])
+                else:
+                    offset = len(unselected_vertices)
+                    unselected_vertices.extend([tuple(obj.matrix_world @ v.co) for v in bm.verts])
+                    unselected_edges.extend([tuple([v.index + offset for v in e.verts]) for e in bm.edges])
+                    unselected_tris.extend([tuple([i + offset for i in t.vertices]) for t in obj.data.loop_triangles])
+
+            if obj.mode != "EDIT":
+                bm.free()
+
+        if unselected_edges:
+            self.draw_batch("LINES", unselected_vertices, special_elements_color, unselected_edges)
+            self.draw_batch("TRIS", unselected_vertices, transparent_color(special_elements_color), unselected_tris)
+        if selected_edges:
+            self.draw_batch("LINES", selected_vertices, selected_elements_color, selected_edges)
+            self.draw_batch("TRIS", selected_vertices, transparent_color(selected_elements_color), selected_tris)

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

@@ -18,14 +18,23 @@
 
 import bpy
 import bmesh
-import mathutils
 import logging
+import shapely
+import mathutils
+import numpy as np
 import ifcopenshell.api
-import ifcopenshell.util.placement
 import ifcopenshell.util.unit
+import ifcopenshell.util.shape
+import ifcopenshell.util.element
+import ifcopenshell.util.placement
+import ifcopenshell.util.representation
 import blenderbim.tool as tool
-from blenderbim.bim.ifc import IfcStore
 import blenderbim.bim.import_ifc as import_ifc
+from math import pi, inf
+from mathutils import Vector, Matrix
+from blenderbim.bim.ifc import IfcStore
+from blenderbim.bim.module.model.decorator import ProfileDecorator
+from blenderbim.bim.module.boundary.decorator import BoundaryDecorator
 
 
 def get_boundaries_collection(blender_space):
@@ -38,6 +47,20 @@ def get_boundaries_collection(blender_space):
     return boundaries_collection
 
 
+def disable_editing_boundary_geometry(context):
+    ProfileDecorator.uninstall()
+    bpy.ops.object.mode_set(mode="OBJECT")
+
+    obj = context.active_object
+    element = tool.Ifc.get_entity(obj)
+
+    old_mesh = obj.data
+    loader = Loader()
+    obj.data = loader.create_mesh(element)
+    tool.Geometry.delete_data(old_mesh)
+    return {"FINISHED"}
+
+
 class Loader:
     def __init__(self):
         self.ifc_file = None
@@ -376,3 +399,357 @@ class UpdateBoundaryGeometry(bpy.types.Operator):
         settings = tool.Boundary.get_assign_connection_geometry_settings(context.active_object)
         ifcopenshell.api.run("boundary.assign_connection_geometry", tool.Ifc.get(), **settings)
         return {"FINISHED"}
+
+
+class EnableEditingBoundaryGeometry(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.enable_editing_boundary_geometry"
+    bl_label = "Enable Editing Boundary Geometry"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        return context.selected_objects
+
+    def _execute(self, context):
+        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        obj = context.active_object
+        element = tool.Ifc.get_entity(obj)
+
+        if element.ConnectionGeometry.is_a("IfcConnectionSurfaceGeometry"):
+            surface = element.ConnectionGeometry.SurfaceOnRelatingElement
+            tool.Model.import_surface(surface, obj)
+
+        bpy.ops.object.mode_set(mode="EDIT")
+        ProfileDecorator.install(context, exit_edit_mode_callback=lambda: disable_editing_boundary_geometry(context))
+        if not bpy.app.background:
+            bpy.ops.wm.tool_set_by_id(tool.Blender.get_viewport_context(), name="bim.cad_tool")
+        return {"FINISHED"}
+
+
+class EditBoundaryGeometry(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.edit_boundary_geometry"
+    bl_label = "Edit Boundary Geometry"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        ProfileDecorator.uninstall()
+        bpy.ops.object.mode_set(mode="OBJECT")
+
+        obj = context.active_object
+        element = tool.Ifc.get_entity(obj)
+
+        if element.ConnectionGeometry.is_a("IfcConnectionSurfaceGeometry"):
+            surface = tool.Model.export_surface(obj)
+
+            if not surface:
+
+                def msg(self, context):
+                    self.layout.label(text="INVALID PROFILE")
+
+                bpy.context.window_manager.popup_menu(msg, title="Error", icon="ERROR")
+                ProfileDecorator.install(
+                    context, exit_edit_mode_callback=lambda: disable_editing_boundary_geometry(context)
+                )
+                bpy.ops.object.mode_set(mode="EDIT")
+                return
+
+            old_surface = element.ConnectionGeometry.SurfaceOnRelatingElement
+            for inverse in tool.Ifc.get().get_inverse(old_surface):
+                ifcopenshell.util.element.replace_attribute(inverse, old_surface, surface)
+            ifcopenshell.util.element.remove_deep2(tool.Ifc.get(), old_surface)
+
+            old_mesh = obj.data
+            loader = Loader()
+            obj.data = loader.create_mesh(element)
+            tool.Geometry.delete_data(old_mesh)
+
+
+class DisableEditingBoundaryGeometry(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.disable_editing_boundary_geometry"
+    bl_label = "Disable Editing Boundary Geometry"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        return context.selected_objects
+
+    def _execute(self, context):
+        return disable_editing_boundary_geometry(context)
+
+
+class ShowBoundaries(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.show_boundaries"
+    bl_label = "Show Boundaries"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        props = bpy.context.scene.BIMBoundaryProperties
+        loader = Loader()
+        for obj in context.selected_objects:
+            element = tool.Ifc.get_entity(obj)
+            if not element or not getattr(element, "BoundedBy", None):
+                continue
+            if tool.Ifc.is_moved(obj):
+                blenderbim.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
+            element = tool.Ifc.get_entity(obj)
+            for rel in element.BoundedBy or []:
+                boundary_obj = loader.load_boundary(rel, obj)
+                tool.Boundary.decorate_boundary(boundary_obj)
+        BoundaryDecorator.install(bpy.context)
+        return {"FINISHED"}
+
+
+class HideBoundaries(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.hide_boundaries"
+    bl_label = "Hide Boundaries"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        to_delete = set()
+        spaces = set()
+        for obj in context.selected_objects:
+            element = tool.Ifc.get_entity(obj)
+            if not element:
+                continue
+            if element.is_a("IfcSpace"):
+                spaces.add(element)
+            elif element.is_a("IfcRelSpaceBoundary"):
+                spaces.add(element.RelatingSpace)
+
+        for element in spaces:
+            for boundary in element.BoundedBy or []:
+                boundary_obj = tool.Ifc.get_object(boundary)
+                if boundary_obj:
+                    to_delete.add(boundary_obj)
+        for boundary_obj in to_delete:
+            tool.Ifc.unlink(obj=boundary_obj)
+            bpy.data.objects.remove(boundary_obj)
+        context.scene.BIMBoundaryProperties.boundaries.clear()
+        return {"FINISHED"}
+
+
+class AddBoundary(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.add_boundary"
+    bl_label = "Add Boundary"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        relating_space = None
+        related_building_element = None
+        relating_space_obj = None
+        related_building_element_obj = None
+
+        objs = context.selected_objects
+        if len(objs) == 2:
+            # The user may select two objects, a space and its related building element
+            for obj in objs:
+                element = tool.Ifc.get_entity(obj)
+                if not element:
+                    continue
+                if element.is_a("IfcSpace"):
+                    relating_space = element
+                    relating_space_obj = obj
+                else:
+                    related_building_element = element
+                    related_building_element_obj = obj
+        elif len(objs) == 1:
+            # Optionally the user may select just the space, and the building element shall be auto-detected
+
+            def msg(self, context):
+                self.layout.label(text="NO ACTIVE STOREY")
+
+            element = tool.Ifc.get_entity(objs[0])
+            if element.is_a("IfcSpace"):
+                relating_space = element
+                relating_space_obj = objs[0]
+
+            target = bpy.context.scene.cursor.location
+
+            collection = context.view_layer.active_layer_collection.collection
+            collection_obj = bpy.data.objects.get(collection.name)
+            if not collection_obj:
+                bpy.context.window_manager.popup_menu(msg, title="Error", icon="ERROR")
+                return
+            spatial_element = tool.Ifc.get_entity(collection_obj)
+            if not spatial_element:
+                bpy.context.window_manager.popup_menu(msg, title="Error", icon="ERROR")
+                return
+
+            for subelement in ifcopenshell.util.element.get_decomposition(spatial_element):
+                if not (subelement.is_a("IfcWall") or subelement.is_a("IfcSlab")):
+                    continue
+                obj = tool.Ifc.get_object(subelement)
+                if obj:
+                    raycast = obj.closest_point_on_mesh(obj.matrix_world.inverted() @ target, distance=0.1)
+                    if raycast[0]:
+                        related_building_element = subelement
+                        related_building_element_obj = obj
+                        break
+
+        if not relating_space or not related_building_element:
+            return
+
+        bm = bmesh.new()
+        bm.from_mesh(relating_space_obj.data)
+        bmesh.ops.dissolve_limit(bm, angle_limit=pi * 2 / 360, verts=bm.verts, edges=bm.edges)
+
+        target_distance = inf
+        target_face = None
+        for face in bm.faces:
+            centroid = relating_space_obj.matrix_world @ face.calc_center_median()
+            raycast = related_building_element_obj.closest_point_on_mesh(
+                related_building_element_obj.matrix_world.inverted() @ centroid, distance=1
+            )
+            if raycast[0]:
+                distance = (related_building_element_obj.matrix_world @ raycast[1] - centroid).length
+                if distance < target_distance:
+                    target_face = face
+                    target_distance = distance
+
+        if not target_face:
+            return
+
+        parent_boundary = tool.Ifc.run("root.create_entity", ifc_class=context.scene.BIMModelProperties.boundary_class)
+
+        # Is this right? Or should I use loop?
+        target_face_verts = [v.co.copy() for v in target_face.verts]
+        target_face_matrix = self.get_face_matrix(*[v.copy() for v in target_face_verts[0:3]])
+        target_face_matrix_i = target_face_matrix.inverted()
+
+        target_face_polygon = shapely.Polygon([tuple((target_face_matrix_i @ v).xy) for v in target_face_verts])
+
+        related_building_element_polygon = self.get_flattened_polygon(
+            related_building_element, relating_space_obj, target_face_matrix_i
+        )
+
+        gross_boundary_polygon = target_face_polygon.intersection(related_building_element_polygon)
+
+        if type(gross_boundary_polygon) == shapely.GeometryCollection:
+            for geom in gross_boundary_polygon.geoms:
+                if type(geom) == shapely.Polygon:
+                    gross_boundary_polygon = geom
+                    break
+
+        # The gross boundary polygon may not be a true gross boundary since it
+        # may have openings already removed, such as in IFC4 Reference View. So
+        # we cheat by using the exterior boundary to mean "gross". Later, we
+        # can use this to check whether or not the opening is relevant to our
+        # space.
+        exterior_boundary_polygon = shapely.Polygon(gross_boundary_polygon.exterior.coords)
+
+        net_boundary_polygon = shapely.Polygon(gross_boundary_polygon)
+
+        inner_boundaries = []
+
+        for rel in getattr(related_building_element, "HasOpenings", []):
+            opening = rel.RelatedOpeningElement
+            filling = None
+            if opening.HasFillings:
+                filling = opening.HasFillings[0].RelatedBuildingElement
+
+            opening_polygon = self.get_flattened_polygon(opening, relating_space_obj, target_face_matrix_i)
+
+            net_boundary_polygon = net_boundary_polygon.difference(opening_polygon)
+            # Only openings that are projected onto our exterior boundary are relevant.
+            if opening_polygon.intersection(exterior_boundary_polygon).area == 0:
+                continue
+
+            connection_geometry = self.create_connection_geometry_from_polygon(opening_polygon, target_face_matrix)
+            boundary = tool.Ifc.run("root.create_entity", ifc_class=context.scene.BIMModelProperties.boundary_class)
+            boundary.RelatingSpace = relating_space
+            boundary.RelatedBuildingElement = filling or related_building_element
+            boundary.ConnectionGeometry = connection_geometry
+            boundary.PhysicalOrVirtualBoundary = "PHYSICAL" if filling else "VIRTUAL"
+            boundary.InternalOrExternalBoundary = "INTERNAL"
+
+            if boundary.is_a("IfcRelSpaceBoundary2ndLevel"):
+                boundary.ParentBoundary = parent_boundary
+
+        connection_geometry = self.create_connection_geometry_from_polygon(net_boundary_polygon, target_face_matrix)
+        parent_boundary.RelatingSpace = relating_space
+        parent_boundary.RelatedBuildingElement = related_building_element
+        parent_boundary.ConnectionGeometry = connection_geometry
+        parent_boundary.PhysicalOrVirtualBoundary = "PHYSICAL"
+        parent_boundary.InternalOrExternalBoundary = "INTERNAL"
+
+        bpy.ops.bim.show_boundaries()
+        obj = tool.Ifc.get_object(parent_boundary)
+        obj.select_set(True)
+
+    def get_face_matrix(self, p1, p2, p3):
+        edge1 = p2 - p1
+        edge2 = p3 - p1
+        normal = edge1.cross(edge2)
+        z_axis = normal.normalized()
+        x_axis = p2 - p1
+        x_axis.normalize()
+        y_axis = z_axis.cross(x_axis)
+
+        mat = Matrix()
+        mat.col[0][:3] = x_axis
+        mat.col[1][:3] = y_axis
+        mat.col[2][:3] = z_axis
+        mat.col[3][:3] = p1
+
+        return mat
+
+    def get_flattened_polygon(self, element, relating_space_obj, target_face_matrix_i):
+        obj = tool.Ifc.get_object(element)
+        if obj and tool.Ifc.is_moved(obj):
+            blenderbim.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
+
+        space_matrix_i = relating_space_obj.matrix_world.inverted()
+
+        settings = ifcopenshell.geom.settings()
+        if not element.is_a("IfcOpeningElement"):
+            settings.set(settings.DISABLE_OPENING_SUBTRACTIONS, True)
+        settings.set(settings.STRICT_TOLERANCE, True)
+        # geometry = ifcopenshell.geom.create_shape(settings, body)
+        shape = ifcopenshell.geom.create_shape(settings, element)
+        m = shape.transformation.matrix.data
+        mat = 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]))
+        verts = [space_matrix_i @ mat @ Vector(v) for v in ifcopenshell.util.shape.get_vertices(shape.geometry)]
+        faces = ifcopenshell.util.shape.get_faces(shape.geometry)
+        polygons = []
+        for face in faces:
+            polygon = shapely.Polygon([tuple((target_face_matrix_i @ verts[vi]).xy) for vi in face])
+            polygons.append(polygon)
+        return shapely.ops.unary_union(polygons)
+
+    def create_connection_geometry_from_polygon(self, polygon, target_face_matrix):
+        surface = self.export_surface(polygon, target_face_matrix)
+        return tool.Ifc.get().createIfcConnectionSurfaceGeometry(surface)
+
+    def export_surface(self, polygon, target_face_matrix):
+        x_axis = target_face_matrix.col[0][:3]
+        z_axis = target_face_matrix.col[2][:3]
+        p1 = target_face_matrix.col[3][:3]
+
+        self.unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        tool.Model.unit_scale = self.unit_scale
+
+        surface = tool.Ifc.get().createIfcCurveBoundedPlane()
+        surface.BasisSurface = tool.Ifc.get().createIfcPlane(tool.Ifc.get().createIfcAxis2Placement3D(
+            tool.Ifc.get().createIfcCartesianPoint([o / self.unit_scale for o in p1]),
+            tool.Ifc.get().createIfcDirection([float(o) for o in z_axis]),
+            tool.Ifc.get().createIfcDirection([float(o) for o in x_axis]),
+        ))
+
+        if tool.Ifc.get().schema != "IFC2X3":
+            points = [tool.Model.convert_si_to_unit(list(co)) for co in polygon.exterior.coords]
+            point_list = tool.Ifc.get().createIfcCartesianPointList2D(points)
+            outer_boundary = tool.Ifc.get().createIfcIndexedPolyCurve(point_list, None, False)
+
+            inner_boundaries = []
+            for interior in polygon.interiors:
+                points = [tool.Model.convert_si_to_unit(list(co)) for co in interior.coords]
+                point_list = tool.Ifc.get().createIfcCartesianPointList2D(points)
+                inner_boundaries.append(tool.Ifc.get().createIfcIndexedPolyCurve(point_list, None, False))
+        else:
+            pass # TODO
+
+        surface.OuterBoundary = outer_boundary
+        surface.InnerBoundaries = inner_boundaries
+
+        return surface

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

@@ -18,6 +18,7 @@
 
 import bpy
 from bpy.types import PropertyGroup
+from blenderbim.bim.prop import ObjProperty
 from bpy.props import (
     PointerProperty,
     StringProperty,
@@ -52,9 +53,13 @@ def element_filter(self, object):
     return False
 
 
-class BIMBoundaryProperties(PropertyGroup):
+class BIMObjectBoundaryProperties(PropertyGroup):
     is_editing: BoolProperty(name="Is Editing")
     relating_space: PointerProperty(name="RelatingSpace", type=bpy.types.Object, poll=space_filter)
     related_building_element: PointerProperty(name="RelatedBuildingElement", type=bpy.types.Object, poll=element_filter)
     parent_boundary: PointerProperty(name="ParentBoundary", type=bpy.types.Object, poll=boundary_filter)
     corresponding_boundary: PointerProperty(name="CorrespondingBoundary", type=bpy.types.Object, poll=boundary_filter)
+
+
+class BIMBoundaryProperties(PropertyGroup):
+    boundaries: bpy.props.CollectionProperty(type=ObjProperty)

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

@@ -46,7 +46,7 @@ class CadTool(WorkSpaceTool):
         ("bim.cad_hotkey", {"type": "X", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_X")]}),
     )
 
-    def draw_settings(context, layout, tool):
+    def draw_settings(context, layout, workspace_tool):
         obj = context.active_object
         if not obj or not obj.data:
             return
@@ -54,14 +54,19 @@ class CadTool(WorkSpaceTool):
             row = layout.row(align=True)
             row.label(text="", icon="EVENT_SHIFT")
             row.label(text="", icon="EVENT_Q")
-            if obj.BIMObjectProperties.ifc_definition_id:
-                row.operator("bim.edit_extrusion_profile", text="Save Profile")
-                row.operator("bim.align_view_to_profile", text="", icon="AXIS_FRONT")
-                row.operator("bim.disable_editing_extrusion_profile", text="", icon="CANCEL")
-            else:
-                row.operator("bim.edit_arbitrary_profile", text="Save Profile")
-                row.operator("bim.align_view_to_profile", text="", icon="AXIS_FRONT")
-                row.operator("bim.disable_editing_arbitrary_profile", text="", icon="CANCEL")
+            element = tool.Ifc.get_entity(obj)
+            if element:
+                if element.is_a("IfcProfileDef"):
+                    row.operator("bim.edit_arbitrary_profile", text="Save Profile")
+                    row.operator("bim.align_view_to_profile", text="", icon="AXIS_FRONT")
+                    row.operator("bim.disable_editing_arbitrary_profile", text="", icon="CANCEL")
+                elif element.is_a("IfcRelSpaceBoundary"):
+                    row.operator("bim.edit_boundary_geometry", text="Save Profile")
+                    row.operator("bim.disable_editing_boundary_geometry", text="", icon="CANCEL")
+                else:
+                    row.operator("bim.edit_extrusion_profile", text="Save Profile")
+                    row.operator("bim.align_view_to_profile", text="", icon="AXIS_FRONT")
+                    row.operator("bim.disable_editing_extrusion_profile", text="", icon="CANCEL")
 
             row = layout.row(align=True)
             row.label(text="", icon="EVENT_SHIFT")
@@ -255,28 +260,30 @@ class CadHotkey(bpy.types.Operator):
         bpy.ops.bim.cad_offset(distance=self.props.distance)
 
     def hotkey_S_Q(self):
-        if tool.Ifc.get_entity(bpy.context.active_object):
-            if bpy.context.active_object.data.BIMMeshProperties.subshape_type == "PROFILE":
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if bpy.context.active_object.data.BIMMeshProperties.subshape_type == "PROFILE":
+            if element.is_a("IfcProfileDef"):
+                bpy.ops.bim.edit_arbitrary_profile()
+            elif element.is_a("IfcRelSpaceBoundary"):
+                bpy.ops.bim.edit_boundary_geometry()
+            else:
                 bpy.ops.bim.edit_extrusion_profile()
-            elif bpy.context.active_object.data.BIMMeshProperties.subshape_type == "AXIS":
-                bpy.ops.bim.edit_extrusion_axis()
+        elif bpy.context.active_object.data.BIMMeshProperties.subshape_type == "AXIS":
+            bpy.ops.bim.edit_extrusion_axis()
 
-            elif (
-                (RailingData.is_loaded or not RailingData.load())
-                and RailingData.data["parameters"]
-                and bpy.context.active_object.BIMRailingProperties.is_editing_path
-            ):
-                bpy.ops.bim.finish_editing_railing_path()
+        elif (
+            (RailingData.is_loaded or not RailingData.load())
+            and RailingData.data["parameters"]
+            and bpy.context.active_object.BIMRailingProperties.is_editing_path
+        ):
+            bpy.ops.bim.finish_editing_railing_path()
 
-            elif (
-                (RoofData.is_loaded or not RoofData.load())
-                and RoofData.data["parameters"]
-                and bpy.context.active_object.BIMRoofProperties.is_editing_path
-            ):
-                bpy.ops.bim.finish_editing_roof_path()
-
-        else:
-            bpy.ops.bim.edit_arbitrary_profile()
+        elif (
+            (RoofData.is_loaded or not RoofData.load())
+            and RoofData.data["parameters"]
+            and bpy.context.active_object.BIMRoofProperties.is_editing_path
+        ):
+            bpy.ops.bim.finish_editing_roof_path()
 
     def hotkey_S_R(self):
         if self.is_profile():

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

@@ -76,6 +76,7 @@ classes = (
     operator.LoadCostItemTaskQuantities,
     operator.LoadCostItemResourceQuantities,
     operator.ChangeParentCostItem,
+    operator.CopyCostItem,
     prop.CostItem,
     prop.CostItemQuantity,
     prop.CostItemType,

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

@@ -97,10 +97,9 @@ class AddSummaryCostItem(bpy.types.Operator, tool.Ifc.Operator):
     bl_label = "Add Cost Item"
     bl_options = {"REGISTER", "UNDO"}
     bl_description = "Add a summary cost item"
-    cost_schedule: bpy.props.IntProperty()
 
     def _execute(self, context):
-        core.add_summary_cost_item(tool.Ifc, tool.Cost, cost_schedule=tool.Ifc.get().by_id(self.cost_schedule))
+        core.add_summary_cost_item(tool.Ifc, tool.Cost, cost_schedule=tool.Cost.get_active_cost_schedule())
 
 
 class AddCostItem(bpy.types.Operator, tool.Ifc.Operator):
@@ -114,6 +113,16 @@ class AddCostItem(bpy.types.Operator, tool.Ifc.Operator):
         core.add_cost_item(tool.Ifc, tool.Cost, cost_item=tool.Ifc.get().by_id(self.cost_item))
 
 
+class CopyCostItem(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.copy_cost_item"
+    bl_label = "Copy Cost Item"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Copy a cost item"
+
+    def _execute(self, context):
+        core.copy_cost_item(tool.Ifc, tool.Cost)
+
+
 class ExpandCostItem(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.expand_cost_item"
     bl_label = "Expand Cost Item"
@@ -214,8 +223,9 @@ class UnassignCostItemType(bpy.types.Operator, tool.Ifc.Operator):
         core.unassign_cost_item_type(
             tool.Ifc,
             tool.Cost,
-            self.cost_item,
-            products=[tool.Ifc.get().by_id(self.related_object)] if self.related_object else [],
+            tool.Spatial,
+            cost_item=tool.Ifc.get().by_id(self.cost_item),
+            product_types=[tool.Ifc.get().by_id(self.related_object)] if self.related_object else [],
         )
         return {"FINISHED"}
 
@@ -491,7 +501,7 @@ class AddCostColumn(bpy.types.Operator):
     bl_options = {"REGISTER", "UNDO"}
     name: bpy.props.StringProperty()
 
-    def _execute(self, context):
+    def execute(self, context):
         core.add_cost_column(tool.Cost, self.name)
         return {"FINISHED"}
 
@@ -619,10 +629,12 @@ class ExportCostSchedules(bpy.types.Operator):
     bl_label = "Export Cost Schedule"
     bl_options = {"REGISTER", "UNDO"}
     bl_description = "Export a cost schedule to a CSV, XSLX OR ODS file"
+    cost_schedule: bpy.props.IntProperty()
     format: bpy.props.EnumProperty("Format", items=(("CSV", "CSV", ""), ("XLSX", "XLSX", ""), ("ODS", "ODS", "")))
 
     def execute(self, context):
-        core.export_cost_schedules(tool.Cost, format=self.format)
+        cost_schedule = tool.Ifc.get().by_id(self.cost_schedule) if self.cost_schedule else None
+        core.export_cost_schedules(tool.Cost, format=self.format, cost_schedule=cost_schedule)
         return {"FINISHED"}
 
     def invoke(self, context, event):
@@ -667,7 +679,9 @@ class LoadProductCostItems(bpy.types.Operator):
         return True
 
     def execute(self, context):
-        core.load_product_cost_items(tool.Cost, product=tool.Ifc.get().by_id(context.active_object.BIMObjectProperties.ifc_definition_id))
+        core.load_product_cost_items(
+            tool.Cost, product=tool.Ifc.get().by_id(context.active_object.BIMObjectProperties.ifc_definition_id)
+        )
         return {"FINISHED"}
 
 

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

@@ -137,7 +137,7 @@ class CostItemType(PropertyGroup):
 
 def update_cost_item_parent(self, context):
     cost_item = tool.Cost.get_highlighted_cost_item()
-    tool.Cost.toggle_cost_item_parent(cost_item=cost_item)
+    tool.Cost.toggle_cost_item_parent_change(cost_item=cost_item)
 
 
 def update_active_cost_item_elements(self, context):
@@ -213,3 +213,4 @@ class BIMCostProperties(PropertyGroup):
         name="Show Nested Tasks", default=False, update=update_active_cost_item_resources
     )
     change_cost_item_parent: BoolProperty(name="Change Cost Item Parent", default=False, update=update_cost_item_parent)
+    show_cost_item_operators: BoolProperty(name="Show Cost Item Operators", default=False)

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

@@ -43,43 +43,54 @@ class BIM_PT_cost_schedules(Panel):
 
         self.props = context.scene.BIMCostProperties
         row = self.layout.row()
-        if CostSchedulesData.data["total_cost_schedules"]:
-            row.label(text=f"{CostSchedulesData.data['total_cost_schedules']} Cost Schedules Found", icon="TEXT")
-            row.operator("bim.export_cost_schedules", text="Export as spreadsheet", icon="EXPORT")
-        else:
-            row.label(text="No Cost Schedules Found found.", icon="COMMUNITY")
-
-        row = self.layout.row()
-        row.prop(self.props, "cost_schedule_predefined_types")
-        row.operator("bim.add_cost_schedule", icon="ADD", text="Add new")
+        if not self.props.active_cost_schedule_id:
+            if CostSchedulesData.data["total_cost_schedules"]:
+                row.label(text=f"{CostSchedulesData.data['total_cost_schedules']} Cost Schedules Found", icon="TEXT")
+                row.operator("bim.export_cost_schedules", text="Export as spreadsheet", icon="EXPORT")
+            else:
+                row.label(text="No Cost Schedules Found found.", icon="COMMUNITY")
+            row = self.layout.row()
+            row.prop(self.props, "cost_schedule_predefined_types")
+            row.operator("bim.add_cost_schedule", icon="ADD", text="Add")
 
         for schedule in CostSchedulesData.data["schedules"]:
             self.draw_cost_schedule_ui(schedule)
 
     def draw_cost_schedule_ui(self, cost_schedule):
         row = self.layout.row(align=True)
-        row.label(text=cost_schedule["name"], icon="LINENUMBERS_ON")
-
         if self.props.active_cost_schedule_id and self.props.active_cost_schedule_id == cost_schedule["id"]:
-            op = row.operator("bim.select_cost_schedule_products", icon="RESTRICT_SELECT_OFF", text="Assigned")
+            row.label(text="Currently editing: {}".format(cost_schedule["name"]), icon="LINENUMBERS_ON")
+            grid = self.layout.grid_flow(columns=2, even_columns=True)
+            col = grid.column()
+            row1 = col.row(align=True)
+            row1.alignment = "LEFT"
+            row1.label(text="Schedule tools")
+            row1 = col.row(align=True)
+            row1.alignment = "RIGHT"
+            row1.operator("bim.export_cost_schedules", text="Export", icon="EXPORT").cost_schedule = cost_schedule["id"]
+            row2 = col.row(align=True)
+            row2.alignment = "RIGHT"
+            op = row2.operator("bim.select_cost_schedule_products", icon="RESTRICT_SELECT_OFF", text="Assigned")
             op.cost_schedule = cost_schedule["id"]
-            row.operator("bim.select_unassigned_products", icon="RESTRICT_SELECT_OFF", text="Unassigned")
+            row2.operator("bim.select_unassigned_products", icon="RESTRICT_SELECT_OFF", text="Unassigned")
 
-            row.prop(self.props, "should_show_column_ui", text="", icon="SHORTDISPLAY")
+            col = grid.column()
+            row1 = col.row(align=True)
+            row1.alignment = "LEFT"
+            row1.label(text="Settings")
+            row1 = col.row(align=True)
+            row1.alignment = "RIGHT"
+            row1.prop(self.props, "should_show_column_ui", text="Schedule Columns", icon="SHORTDISPLAY")
             if self.props.is_editing == "COST_SCHEDULE_ATTRIBUTES":
                 row.operator("bim.edit_cost_schedule", text="", icon="CHECKMARK")
-            elif self.props.is_editing == "COST_ITEMS":
-                row.operator("bim.add_summary_cost_item", text="", icon="ADD").cost_schedule = cost_schedule["id"]
-            row.operator("bim.disable_editing_cost_schedule", text="", icon="CANCEL")
-        elif self.props.active_cost_schedule_id:
-            row.operator("bim.remove_cost_schedule", text="", icon="X").cost_schedule = cost_schedule["id"]
+            row.operator("bim.disable_editing_cost_schedule", text="Disable Editing", icon="CANCEL")
         else:
+            row.label(text=cost_schedule["name"], icon="LINENUMBERS_ON")
             row.operator("bim.enable_editing_cost_items", text="", icon="OUTLINER").cost_schedule = cost_schedule["id"]
             row.operator(
                 "bim.enable_editing_cost_schedule_attributes", text="", icon="GREASEPENCIL"
             ).cost_schedule = cost_schedule["id"]
             row.operator("bim.remove_cost_schedule", text="", icon="X").cost_schedule = cost_schedule["id"]
-
         if self.props.active_cost_schedule_id == cost_schedule["id"]:
             if self.props.is_editing == "COST_SCHEDULE_ATTRIBUTES":
                 self.draw_editable_cost_schedule_ui()
@@ -101,30 +112,39 @@ class BIM_PT_cost_schedules(Panel):
         row = self.layout.row(align=True)
         row.alignment = "RIGHT"
         ifc_definition_id = None
+        row = self.layout.row(align=True)
+        row.label(text="Cost Item Tools")
+        row = self.layout.row(align=True)
+        row.alignment = "RIGHT"
+        row.operator("bim.add_summary_cost_item", text="Add Summary Cost", icon="ADD")
+        row.operator("bim.expand_all_tasks", text="Expand All")
+        row.operator("bim.contract_all_tasks", text="Contract All")
+        row = self.layout.row(align=True)
+        row.alignment = "RIGHT"
         if self.props.cost_items and self.props.active_cost_item_index < len(self.props.cost_items):
             ifc_definition_id = self.props.cost_items[self.props.active_cost_item_index].ifc_definition_id
         if ifc_definition_id:
-            row.prop(self.props, "change_cost_item_parent", text="", icon="LINKED")
-            row.prop(self.props, "enable_reorder", text="", icon="SORTALPHA")
-            if not CostSchedulesData.data["is_editing_rates"]:
-                op = row.operator("bim.enable_editing_cost_item_quantities", text="", icon="PROPERTIES")
+            row.prop(self.props, "show_cost_item_operators", text="Edit", icon="DOWNARROW_HLT")
+            row.operator("bim.add_cost_item", text="Add", icon="ADD").cost_item = ifc_definition_id
+            row.operator("bim.copy_cost_item", text="Copy", icon="ADD")
+            row.operator("bim.remove_cost_item", text="Delete", icon="X").cost_item = ifc_definition_id
+            if self.props.show_cost_item_operators:
+                row = self.layout.row(align=True)
+                row.alignment = "RIGHT"
+                row.prop(self.props, "change_cost_item_parent", text="", icon="LINKED")
+                row.prop(self.props, "enable_reorder", text="", icon="SORTALPHA")
+                if not CostSchedulesData.data["is_editing_rates"]:
+                    op = row.operator("bim.enable_editing_cost_item_quantities", text="", icon="PROPERTIES")
+                    op.cost_item = ifc_definition_id
+                op = row.operator("bim.enable_editing_cost_item_values", text="", icon="DISC")
                 op.cost_item = ifc_definition_id
-
-            op = row.operator("bim.enable_editing_cost_item_values", text="", icon="DISC")
-            op.cost_item = ifc_definition_id
-
-            row.operator("bim.add_cost_item", text="", icon="ADD").cost_item = ifc_definition_id
-
-            if self.props.active_cost_item_id == ifc_definition_id:
-                if self.props.cost_item_editing_type == "ATTRIBUTES":
-                    row.operator("bim.edit_cost_item", text="", icon="CHECKMARK")
-                row.operator("bim.disable_editing_cost_item", text="", icon="CANCEL")
-            else:
-                op = row.operator("bim.enable_editing_cost_item_attributes", text="", icon="GREASEPENCIL")
-                op.cost_item = ifc_definition_id
-
-            row.operator("bim.remove_cost_item", text="", icon="X").cost_item = ifc_definition_id
-
+                if self.props.active_cost_item_id == ifc_definition_id:
+                    if self.props.cost_item_editing_type == "ATTRIBUTES":
+                        row.operator("bim.edit_cost_item", text="", icon="CHECKMARK")
+                    row.operator("bim.disable_editing_cost_item", text="", icon="CANCEL")
+                else:
+                    op = row.operator("bim.enable_editing_cost_item_attributes", text="", icon="GREASEPENCIL")
+                    op.cost_item = ifc_definition_id
         self.layout.template_list(
             "BIM_UL_cost_items",
             "",
@@ -594,7 +614,7 @@ class BIM_UL_cost_items_trait:
         layout.label(text=text)
 
     def draw_uom_column(self, layout, cost_item):
-        layout.label(text=cost_item["UnitBasisUnitSymbol"] or "?" if cost_item["UnitBasisValueComponent"] else "-")
+        layout.label(text=cost_item["UnitBasisUnitSymbol"] or "-" if cost_item["UnitBasisValueComponent"] else "-")
 
     def draw_order_operator(self, row, ifc_definition_id, cost_item):
         if cost_item["NestingIndex"] is not None:
@@ -608,7 +628,14 @@ class BIM_UL_cost_items_trait:
                 op.new_index = cost_item["NestingIndex"] - 1
 
     def draw_total_quantity_column(self, layout, cost_item):
-        layout.label(text="{0:.2f}".format(cost_item["TotalCostQuantity"]) + f" {cost_item['UnitSymbol'] or '?'}")
+        layout.label(text="{0:.2f}".format(cost_item["TotalCostQuantity"]) + f" {cost_item['UnitSymbol'] or '-'}")
+        # if cost_item["DerivedTotalCostQuantity"] not in [None, 0]:
+        #     layout.label(text="{0:.2f}".format(cost_item["DerivedTotalCostQuantity"]) + f" {cost_item['DerivedUnitSymbol'] or '-'}")
+        # else:
+        #     if cost_item["TotalCostQuantity"] == 0:
+        #         layout.label(text="-")
+        #     else:
+        #         layout.label(text="{0:.2f}".format(cost_item["TotalCostQuantity"]) + f" {cost_item['UnitSymbol'] or '-'}")
 
 
 class BIM_UL_cost_items(BIM_UL_cost_items_trait, UIList):
@@ -691,9 +718,7 @@ class BIM_PT_Costing_Tools(Panel):
     def draw(self, context):
         self.props = context.scene.BIMCostProperties
         row = self.layout.row()
-        row.operator(
-            "bim.load_product_cost_items", icon="FILE_REFRESH"
-        )
+        row.operator("bim.load_product_cost_items", icon="FILE_REFRESH")
         row = self.layout.row()
         row.template_list(
             "BIM_UL_product_cost_items",

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

@@ -31,6 +31,7 @@ from blenderbim.bim.handler import purge_module_data
 class AddCsvAttribute(bpy.types.Operator):
     bl_idname = "bim.add_csv_attribute"
     bl_label = "Add CSV Attribute"
+    bl_description = "Add a new IFC Attribute to the CSV export"
     bl_options = {"REGISTER", "UNDO"}
 
     def execute(self, context):
@@ -52,6 +53,7 @@ class RemoveCsvAttribute(bpy.types.Operator):
 class RemoveAllCsvAttributes(bpy.types.Operator):
     bl_idname = "bim.remove_all_csv_attributes"
     bl_label = "Remove all CSV Attributes"
+    bl_description = "Remove all IFC Attributes from the CSV export"
     bl_options = {"REGISTER", "UNDO"}
 
     def execute(self, context):
@@ -61,20 +63,25 @@ class RemoveAllCsvAttributes(bpy.types.Operator):
 
 class ImportCsvAttributes(bpy.types.Operator):
     bl_idname = "bim.import_csv_attributes"
-    bl_label = "Import CSV Attributes"
+    bl_label = "Import CSV Template"
+    bl_description = "Import a json template for CSV export"
     bl_options = {"REGISTER", "UNDO"}
     filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})
     filepath: bpy.props.StringProperty(subtype="FILE_PATH")
 
     def execute(self, context):
-        csv_attributes = context.scene.CsvProperties.csv_attributes
-        csv_attributes.clear()
+        csv_props = context.scene.CsvProperties
         csv_json = json.load(open(self.filepath))
-        i = 0
-        for attribute in csv_json:
-            csv_attributes.add()
-            csv_attributes[i].name = attribute
-            i += 1
+
+        expression = csv_json.get("expression", "")
+        if expression:
+            csv_props.ifc_selector = expression
+
+        attributes = csv_json.get("attributes", [])
+        if attributes:
+            csv_props.csv_attributes.clear()
+            for attribute in attributes:
+                csv_props.csv_attributes.add().name = attribute
 
         return {"FINISHED"}
 
@@ -85,19 +92,30 @@ class ImportCsvAttributes(bpy.types.Operator):
 
 class ExportCsvAttributes(bpy.types.Operator):
     bl_idname = "bim.export_csv_attributes"
-    bl_label = "Export CSV Attributes"
+    bl_label = "Export CSV Template"
     bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Save a json template for CSV export"
     filename_ext = ".json"
     filter_glob: bpy.props.StringProperty(default="*.json", options={"HIDDEN"})
     filepath: bpy.props.StringProperty(subtype="FILE_PATH")
 
     def execute(self, context):
-        csv_attributes = []
-        with open(self.filepath, "w") as outfile:
-            for attribute in context.scene.CsvProperties.csv_attributes:
-                csv_attributes.append(attribute.name)
+        csv_props = context.scene.CsvProperties
 
-            json.dump(csv_attributes, outfile)
+        csv_template = {}
+        expression = csv_props.ifc_selector
+        if expression:
+            csv_template["expression"] = expression
+
+        csv_attributes = []
+        for attribute in csv_props.csv_attributes:
+            attribute_name = attribute.name
+            csv_attributes.append(attribute_name)
+        if csv_attributes:
+            csv_template["attributes"] = csv_attributes
+
+        with open(self.filepath, "w") as outfile:
+            json.dump(csv_template, outfile)
 
         return {"FINISHED"}
 

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

@@ -49,27 +49,18 @@ class BIM_PT_ifccsv(Panel):
         row.operator("bim.eyedrop_ifccsv", icon="EYEDROPPER", text="")
         layout.separator()
 
-        row = layout.row()
-        split = row.split(factor=0.7)
-        c = split.column()
-        c.operator("bim.add_csv_attribute")
-        c = split.column()
-        c.operator("bim.import_csv_attributes", icon="IMPORT", text="Load Template")
+        row = layout.row(align=True)
+        row.operator("bim.add_csv_attribute", icon="ADD")
+        row.operator("bim.remove_all_csv_attributes", icon="CANCEL")
+        row = layout.row(align=True)
+        row.operator("bim.import_csv_attributes", icon="IMPORT")
+        row.operator("bim.export_csv_attributes", icon="EXPORT")
 
         for index, attribute in enumerate(props.csv_attributes):
             row = layout.row(align=True)
             row.prop(attribute, "name", text="")
             row.operator("bim.remove_csv_attribute", icon="X", text="").index = index
 
-        if props.csv_attributes:
-            row = layout.row()
-            row.label()
-            row.operator("bim.remove_all_csv_attributes", icon="CANCEL", text="")
-            row = layout.row()
-            row.operator("bim.export_csv_attributes", icon="EXPORT", text="Create Template")
-
-        layout.separator()
-
         row = layout.row(align=True)
         row.prop(props, "csv_delimiter")
 
@@ -78,7 +69,7 @@ class BIM_PT_ifccsv(Panel):
             row.prop(props, "csv_custom_delimiter")
 
         row = layout.row()
-        split = row.split(factor=0.7)
+        split = row.split(factor=0.5)
         c = split.column()
         c.operator("bim.export_ifccsv", icon="EXPORT")
         c = split.column()

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

@@ -61,11 +61,13 @@ classes = (
     operator.RemoveDrawingStyle,
     operator.RemoveDrawingStyleAttribute,
     operator.RemoveSchedule,
+    operator.ReloadDrawingStyles,
     operator.RemoveSheet,
     operator.RemoveTextLiteral,
     operator.SelectAllDrawings,
     operator.ResizeText,
     operator.SaveDrawingStyle,
+    operator.SaveDrawingStylesData,
     operator.SelectAssignedProduct,
     operator.SelectDocIfcFile,
     prop.Variable,

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

@@ -20,6 +20,7 @@ import bpy
 import os
 import blenderbim.tool as tool
 from mathutils import Vector
+import bmesh
 
 
 class Annotator:
@@ -94,7 +95,7 @@ class Annotator:
         return obj
 
     @staticmethod
-    def add_plane_to_annotation(obj):
+    def add_plane_to_annotation(obj, remove_face=False):
         # default order = bot left, top left, bot right, top right
         # therefore we redefine the order
         face_verts = [0, 2, 3, 1]
@@ -104,7 +105,9 @@ class Annotator:
         bm = tool.Blender.get_bmesh_for_mesh(obj.data, clean=True)
         new_verts = [bm.verts.new(v) for v in verts_local]
 
-        bm.faces.new([new_verts[i] for i in face_verts])
+        face = bm.faces.new([new_verts[i] for i in face_verts])
+        if remove_face:
+            bmesh.ops.delete(bm, geom=[face], context="FACES_ONLY")
         tool.Blender.apply_bmesh(obj.data, bm, obj)
         return obj
 

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

@@ -32,6 +32,7 @@ def refresh():
     AnnotationData.is_loaded = False
     DecoratorData.data = {}
     DecoratorData.cut_cache = {}
+    DecoratorData.layerset_cache = {}
 
 
 class ProductAssignmentsData:
@@ -102,6 +103,7 @@ class DrawingsData:
             "has_saved_ifc": cls.has_saved_ifc(),
             "total_drawings": cls.total_drawings(),
             "location_hint": cls.location_hint(),
+            "active_drawing_pset_data": cls.active_drawing_pset_data(),
         }
         cls.is_loaded = True
 
@@ -123,6 +125,15 @@ class DrawingsData:
             return results
         return [(h.upper(), h, "") for h in ["North", "South", "East", "West"]]
 
+    @classmethod
+    def active_drawing_pset_data(cls):
+        ifc_file = tool.Ifc.get()
+        drawing_id = bpy.context.scene.DocProperties.active_drawing_id
+        if drawing_id == 0:
+            return {}
+        drawing = ifc_file.by_id(bpy.context.scene.DocProperties.active_drawing_id)
+        return ifcopenshell.util.element.get_pset(drawing, "EPset_Drawing")
+
 
 class SchedulesData:
     data = {}
@@ -155,6 +166,7 @@ class DecoratorData:
     # stores 1 type of data per object
     data = {}
     cut_cache = {}
+    layerset_cache = {}
 
     # used by Ifc Annotations with ObjectType = "BATTING"
     @classmethod
@@ -226,18 +238,21 @@ class DecoratorData:
 
         props = obj.BIMTextProperties
         # getting font size
-        classes = ifcopenshell.util.element.get_pset(element, "EPset_Annotation", "Classes")
+        pset_data = ifcopenshell.util.element.get_pset(element, "EPset_Annotation") or {}
         # use `regular` as default
-        if classes:
-            classes_split = classes.split()
-            # prioritize smaller font sizes just like in svg
-            font_size_type = next(
-                (font_size_type for font_size_type in FONT_SIZES if font_size_type in classes_split), "regular"
-            )
-        else:
-            font_size_type = "regular"
+
+        # get font size
+        classes = pset_data.get("Classes", None) or "regular"
+        classes_split = classes.split()
+        # prioritize smaller font sizes just like in svg
+        font_size_type = next(
+            (font_size_type for font_size_type in FONT_SIZES if font_size_type in classes_split), "regular"
+        )
         font_size = FONT_SIZES[font_size_type]
 
+        # get symbol
+        symbol = pset_data.get("Symbol", None)
+
         # other attributes
         props_literals = props.literals
         props_literals_n = len(props.literals)
@@ -255,7 +270,7 @@ class DecoratorData:
 
             literals_data.append(literal_data)
 
-        text_data = {"Literals": literals_data, "FontSize": font_size}
+        text_data = {"Literals": literals_data, "FontSize": font_size, "Symbol": symbol}
         cls.data[obj.name] = text_data
         return text_data
 
@@ -279,11 +294,15 @@ class DecoratorData:
         pset_data = ifcopenshell.util.element.get_pset(element, "BBIM_Dimension") or {}
         show_description_only = pset_data.get("ShowDescriptionOnly", False)
         suppress_zero_inches = pset_data.get("SuppressZeroInches", False)
+        text_prefix = pset_data.get("TextPrefix", "")
+        text_suffix = pset_data.get("TextSuffix", "")
 
         dimension_data = {
             "dimension_style": dimension_style,
             "show_description_only": show_description_only,
             "suppress_zero_inches": suppress_zero_inches,
+            "text_prefix": text_prefix,
+            "text_suffix": text_suffix,
         }
         cls.data[obj.name] = dimension_data
         return dimension_data

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

@@ -23,7 +23,7 @@ from bpy import types
 from mathutils import Vector
 from mathutils import geometry
 from bpy_extras import view3d_utils
-from blenderbim.bim.module.drawing.shaders import DotsGizmoShader, ExtrusionGuidesShader, BaseLinesShader
+from blenderbim.bim.module.drawing.shaders import DotsGizmoShader, ExtrusionGuidesShader
 from ifcopenshell.util.unit import si_conversions
 
 
@@ -251,11 +251,12 @@ X3DISC = (
 class CustomGizmo:
     # FIXME: highliting/selection doesnt work
     def draw_very_custom_shape(self, ctx, custom_shape, select_id=None):
-        # similar to draw_custom_shape
-        shape, batch, shader = custom_shape
+        # create shader and batch
+        shader_wrapper, batch = custom_shape
+        shader = shader_wrapper.get_shader()
 
+        # setup params
         shader.bind()
-
         if select_id is not None:
             gpu.select.load_id(select_id)
         else:
@@ -264,13 +265,17 @@ class CustomGizmo:
             else:
                 color = (*self.color, self.alpha)
             shader.uniform_float("color", color)
-            shape.glenable()
+            shader_wrapper.glenable()
+        shader_wrapper.uniform_region(ctx)
 
-        shape.uniform_region(ctx)
-        # shader.uniform_float('modelMatrix', self.matrix_world)
+        # using `with` block to make sure matrix multiplication
+        # won't affect other shaders
         with gpu.matrix.push_pop():
-            gpu.matrix.multiply_matrix(self.matrix_world)
-            batch.draw()
+            # using matrix_world seems to be unaffected by matrix_offset
+            # therefore we use basis @ offset
+            matrix = self.matrix_basis @ self.matrix_offset
+            gpu.matrix.multiply_matrix(matrix)
+            batch.draw(shader)
 
         gpu.state.blend_set("NONE")
 
@@ -360,6 +365,7 @@ class UglyDotGizmo(OffsetHandle, types.Gizmo):
         self.draw_custom_shape(self.custom_shape, select_id=select_id)
 
 
+# TODO: dead code?
 class DotGizmo(CustomGizmo, OffsetHandle, types.Gizmo):
     """Single dot viewport-aligned"""
 
@@ -389,10 +395,6 @@ class DotGizmo(CustomGizmo, OffsetHandle, types.Gizmo):
         self.refresh()
         self.draw_very_custom_shape(ctx, self.custom_shape, select_id=select_id)
 
-    # doesn't get called
-    # def test_select(self, ctx, location):
-    #     pass
-
 
 class ExtrusionGuidesGizmo(CustomGizmo, types.Gizmo):
     """Extrusion guides
@@ -407,19 +409,25 @@ class ExtrusionGuidesGizmo(CustomGizmo, types.Gizmo):
     __slots__ = ("scale_value", "custom_shape")
 
     def setup(self):
-        shader = ExtrusionGuidesShader()
-        self.custom_shape = shader, shader.batch(pos=((0, 0, 0), (0, 0, 1))), shader.prog
-        self.use_draw_scale = False
-
-    def refresh(self):
-        depth = self.target_get_value("depth") / self.scale_value
-        self.matrix_offset.col[2][2] = depth  # z-scaled
+        """setup `custom_shape`"""
+        shader_wrapper = ExtrusionGuidesShader()
+        verts = [Vector((0, 0, 0)), Vector((0, 0, 1))]
+        verts, edges = shader_wrapper.process_geometry(verts)
+        self.custom_shape = shader_wrapper, shader_wrapper.batch(
+            pos=verts,
+            indices=edges,
+        )
 
     def draw(self, ctx):
         self.refresh()
         self.draw_very_custom_shape(ctx, self.custom_shape)
 
+    def refresh(self):
+        depth = self.target_get_value("depth") / self.scale_value
+        self.matrix_offset.col[2][2] = depth  # z-scaled
 
+
+# TODO: dead code?
 class DimensionLabelGizmo(types.Gizmo):
     """Text label for a dimension"""
 
@@ -486,6 +494,7 @@ class ExtrusionWidget(types.GizmoGroup):
         theme = ctx.preferences.themes[0].user_interface
         scale_value = self.get_scale_value(ctx.scene.unit_settings.system, ctx.scene.unit_settings.length_unit)
 
+        # setup handle
         gz = self.handle = self.gizmos.new("BIM_GT_uglydot_3d")
         gz.matrix_basis = basis
         gz.scale_basis = 0.1
@@ -496,6 +505,7 @@ class ExtrusionWidget(types.GizmoGroup):
         gz.target_set_prop("offset", prop, "value")
         gz.scale_value = scale_value
 
+        # setup guides
         gz = self.guides = self.gizmos.new("BIM_GT_extrusion_guides")
         gz.matrix_basis = basis
         gz.color = gz.color_highlight = tuple(theme.gizmo_secondary)

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

@@ -154,13 +154,14 @@ def format_distance(
         # Separate ft and inches
         # Unless Inches are the specified Length Unit
         if unit_length != "INCHES":
-            feet = math.floor(decInches / inPerFoot)
+            feet = int(decInches / inPerFoot)  # remove decimal
             decInches -= feet * inPerFoot
         else:
             feet = 0
 
         # Separate Fractional Inches
-        inches = math.floor(decInches)
+        decInches = abs(decInches)  # ignore the sign for inches
+        inches = math.floor(decInches)  # remove decimal
         if inches != 0:
             frac = round(base * (decInches - inches))
         else:

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

@@ -41,12 +41,12 @@ import blenderbim.bim.module.drawing.sheeter as sheeter
 import blenderbim.bim.module.drawing.scheduler as scheduler
 import blenderbim.bim.module.drawing.helper as helper
 from blenderbim.bim.module.drawing.decoration import CutDecorator
-from blenderbim.bim.module.drawing.data import DecoratorData
+from blenderbim.bim.module.drawing.data import DecoratorData, DrawingsData
 import blenderbim.bim.export_ifc
 from lxml import etree
-from mathutils import Vector
+from mathutils import Vector, Color
 from timeit import default_timer as timer
-from blenderbim.bim.module.drawing.prop import RasterStyleProperty, Literal
+from blenderbim.bim.module.drawing.prop import RasterStyleProperty, Literal, RASTER_STYLE_PROPERTIES_EXCLUDE
 from blenderbim.bim.ifc import IfcStore
 from pathlib import Path
 
@@ -189,7 +189,7 @@ class CreateDrawing(bpy.types.Operator):
                     self.cprops = self.camera.data.BIMCameraProperties
                     self.drawing_name = self.file.by_id(drawing_id).Name
                     self.metadata = tool.Drawing.get_drawing_metadata(self.camera_element)
-                    self.get_scale()
+                    self.get_scale(context)
                     if self.cprops.update_representation(self.camera):
                         bpy.ops.bim.update_representation(obj=self.camera.name, ifc_representation_class="")
 
@@ -486,6 +486,14 @@ class CreateDrawing(bpy.types.Operator):
         results = self.svg_buffer.get_value()
 
         root = etree.fromstring(results)
+
+        group = root.find("{http://www.w3.org/2000/svg}g")
+        if not group:
+            with open(svg_path, "wb") as svg:
+                svg.write(etree.tostring(root))
+
+            return svg_path
+
         self.move_projection_to_bottom(root)
         self.merge_linework_and_add_metadata(root)
 
@@ -620,7 +628,6 @@ class CreateDrawing(bpy.types.Operator):
 
                     # Loop over the cell paths
                     for pi, p in enumerate(g2.getElementsByTagName("path")):
-
                         d = p.getAttribute("d")
                         coords = [co[1:].split(",") for co in d.split() if co[1:]]
                         polygon = shapely.Polygon(coords)
@@ -829,6 +836,10 @@ class CreateDrawing(bpy.types.Operator):
         ifc = tool.Ifc.get()
         for el in root.findall(".//{http://www.w3.org/2000/svg}g[@{http://www.ifcopenshell.org/ns}guid]"):
             element = ifc.by_guid(el.get("{http://www.ifcopenshell.org/ns}guid"))
+            # Architectural convention only merges these objects. E.g. pipe segments and fittings shouldn't merge.
+            if not element.is_a("IfcWall") and not element.is_a("IfcSlab"):
+                continue
+
             classes = self.get_svg_classes(element)
             classes.append("cut")
 
@@ -865,7 +876,11 @@ class CreateDrawing(bpy.types.Operator):
                 if is_closed_polygon:
                     el.getparent().remove(el)
 
-            merged_polygons = shapely.ops.unary_union(polygons)
+            try:
+                merged_polygons = shapely.ops.unary_union(polygons)
+            except:
+                print("Warning. Portions of the merge failed. Please report a bug!", polygons)
+                merged_polygons = polygons
 
             if type(merged_polygons) == shapely.MultiPolygon:
                 merged_polygons = merged_polygons.geoms
@@ -923,13 +938,49 @@ class CreateDrawing(bpy.types.Operator):
 
         return svg_path
 
-    def get_scale(self):
-        if self.camera.data.BIMCameraProperties.diagram_scale == "CUSTOM":
-            self.human_scale, fraction = self.camera.data.BIMCameraProperties.custom_diagram_scale.split("|")
-        else:
-            self.human_scale, fraction = self.camera.data.BIMCameraProperties.diagram_scale.split("|")
+    def get_scale(self, context):
+        camera_props = self.camera.data.BIMCameraProperties
+        if camera_props.diagram_scale == "CUSTOM":
+            if context.scene.unit_settings.system == "IMPERIAL":
+                if (
+                    camera_props.custom_diagram_scale_input1[-1] == "'"
+                    or camera_props.custom_diagram_scale_input1[-1] == '"'
+                ):
+                    camera_props.custom_diagram_scale_input1 = camera_props.custom_diagram_scale_input1[:-1]
+                if camera_props.custom_diagram_scale_input2[-1] == "'":
+                    camera_props.custom_diagram_scale_input2 = camera_props.custom_diagram_scale_input2[:-1]
+                if (
+                    camera_props.custom_diagram_scale_input2[1:] == "'-0\""
+                    or camera_props.custom_diagram_scale_input2[1:] == "' 0\""
+                ):
+                    camera_props.custom_diagram_scale_input2 = camera_props.custom_diagram_scale_input2[0]
+                if "/" in camera_props.custom_diagram_scale_input1:
+                    if " " in camera_props.custom_diagram_scale_input1:
+                        n1, n2 = camera_props.custom_diagram_scale_input1.split(" ")
+                        n2_1, n2_2 = n2.split("/")
+                        numerator = int(n1) + (int(n2_1) / int(n2_2))
+                    elif "-" in camera_props.custom_diagram_scale_input1:
+                        n1, n2 = camera_props.custom_diagram_scale_input1.split("-")
+                        n2_1, n2_2 = n2.split("/")
+                        numerator = int(n1) + (int(n2_1) / int(n2_2))
+                    else:
+                        n1, n2 = camera_props.custom_diagram_scale_input1.split("/")
+                        numerator = int(n1) / int(n2)
+                else:
+                    numerator = 1
+                denominator = (int(camera_props.custom_diagram_scale_input2) / numerator) * 12
+                scale = "1" + "/" + str(denominator)
+                human_scale = camera_props.custom_diagram_scale_input1 + "=" + camera_props.custom_diagram_scale_input2
+            else:
+                scale = camera_props.custom_diagram_scale_input1 + "/" + camera_props.custom_diagram_scale_input2
+                human_scale = camera_props.custom_diagram_scale_input1 + ":" + camera_props.custom_diagram_scale_input2
 
-        if self.camera.data.BIMCameraProperties.is_nts:
+            camera_props.custom_diagram_scale = human_scale + "|" + scale
+            self.human_scale, fraction = camera_props.custom_diagram_scale.split("|")
+        else:
+            self.human_scale, fraction = camera_props.diagram_scale.split("|")
+
+        if camera_props.is_nts:
             self.human_scale = "NTS"
 
         numerator, denominator = fraction.split("/")
@@ -1004,12 +1055,14 @@ class AddSheet(bpy.types.Operator, Operator):
 
 class OpenSheet(bpy.types.Operator, Operator):
     bl_idname = "bim.open_sheet"
-    bl_label = "Open Sheet"
+    bl_label = "Open Sheet Layout"
     bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context):
         self.props = context.scene.DocProperties
         sheet = tool.Ifc.get().by_id(self.props.sheets[self.props.active_sheet_index].ifc_definition_id)
+        sheet_builder = sheeter.SheetBuilder()
+        sheet_builder.update_sheet_drawing_sizes(sheet)
         core.open_sheet(tool.Drawing, sheet=sheet)
 
 
@@ -1026,7 +1079,7 @@ class AddDrawingToSheet(bpy.types.Operator, Operator):
     def _execute(self, context):
         props = context.scene.DocProperties
         active_drawing = props.drawings[props.active_drawing_index]
-        active_sheet = props.sheets[props.active_sheet_index]
+        active_sheet = tool.Drawing.get_active_sheet(context)
         drawing = tool.Ifc.get().by_id(active_drawing.ifc_definition_id)
         drawing_reference = tool.Drawing.get_drawing_document(drawing)
 
@@ -1085,6 +1138,7 @@ class RemoveDrawingFromSheet(bpy.types.Operator, Operator):
 class CreateSheets(bpy.types.Operator, Operator):
     bl_idname = "bim.create_sheets"
     bl_label = "Create Sheets"
+    bl_description = "Build a sheet from the sheet layout"
     bl_options = {"REGISTER", "UNDO"}
 
     @classmethod
@@ -1121,7 +1175,7 @@ class CreateSheets(bpy.types.Operator, Operator):
                 has_sheet_reference = True
             elif reference.Description == "RASTER":
                 if reference.Location in raster_references:
-                    del raster_references[reference.Location]
+                    raster_references.remove(reference.Location)
                 else:
                     tool.Ifc.run("document.remove_reference", reference=reference)
 
@@ -1245,9 +1299,13 @@ class ActivateModel(bpy.types.Operator):
     bl_description = "Activates the model view"
 
     def execute(self, context):
+        dprops = bpy.context.scene.DocProperties
+        dprops.active_drawing_id = 0
+
         CutDecorator.uninstall()
 
-        bpy.ops.object.hide_view_clear()
+        if not bpy.app.background:
+            bpy.ops.object.hide_view_clear()
 
         subcontext = ifcopenshell.util.representation.get_context(tool.Ifc.get(), "Model", "Body", "MODEL_VIEW")
 
@@ -1285,12 +1343,18 @@ class ActivateDrawing(bpy.types.Operator):
 
     def execute(self, context):
         drawing = tool.Ifc.get().by_id(self.drawing)
+        dprops = bpy.context.scene.DocProperties
         core.activate_drawing_view(tool.Ifc, tool.Drawing, drawing=drawing)
-        bpy.context.scene.DocProperties.active_drawing_id = self.drawing
+        dprops.active_drawing_id = self.drawing
+        # reset DrawingsData to reload_drawing_styles work correctly
+        DrawingsData.is_loaded = False
+        dprops.drawing_styles.clear()
         if ifcopenshell.util.element.get_pset(drawing, "EPset_Drawing", "HasUnderlay"):
+            bpy.ops.bim.reload_drawing_styles()
             bpy.ops.bim.activate_drawing_style()
         core.sync_references(tool.Ifc, tool.Collector, tool.Drawing, drawing=tool.Ifc.get().by_id(self.drawing))
         CutDecorator.install(context)
+        tool.Drawing.show_decorations()
         return {"FINISHED"}
 
 
@@ -1351,24 +1415,88 @@ class RemoveDrawing(bpy.types.Operator, Operator):
         else:
             drawings = [tool.Ifc.get().by_id(self.drawing)]
 
-        print("Removing drawings: {}".format([d for d in drawings]))
+        removed_drawings = [drawing.id() for drawing in drawings]
 
         for drawing in drawings:
             core.remove_drawing(tool.Ifc, tool.Drawing, drawing=drawing)
 
 
-class AddDrawingStyle(bpy.types.Operator):
+class ReloadDrawingStyles(bpy.types.Operator):
+    bl_idname = "bim.reload_drawing_styles"
+    bl_label = "Reload Drawing Styles"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Reload drawing styles for the active camera"
+
+    def execute(self, context):
+        if not DrawingsData.is_loaded:
+            DrawingsData.load()
+        drawing_pset_data = DrawingsData.data["active_drawing_pset_data"]
+        camera_props = context.active_object.data.BIMCameraProperties
+
+        # added this part as a temporary fallback
+        # TODO: should remove it a bit later when projects get more accommodated
+        # with saving shadingstyles to ifc and separate json file
+        if "ShadingStyles" not in drawing_pset_data:
+            ifc_file = tool.Ifc.get()
+            pset = ifc_file.by_id(drawing_pset_data["id"])
+            edit_properties = {
+                "ShadingStyles": (
+                    shading_styles_path := tool.Drawing.get_default_drawing_resource_path("ShadingStyles")
+                ),
+                "CurrentShadingStyle": tool.Drawing.get_default_shading_style(),
+            }
+            ifcopenshell.api.run("pset.edit_pset", ifc_file, pset=pset, properties=edit_properties)
+            tool.Drawing.setup_shading_styles_path(shading_styles_path)
+
+            DrawingsData.load()
+            drawing_pset_data = DrawingsData.data["active_drawing_pset_data"]
+
+        if "ShadingStyles" not in drawing_pset_data:
+            self.report({"ERROR"}, "Could not find shading styles path in EPset_Drawing.ShadingStyles.")
+            return {"CANCELLED"}
+
+        rel_path = drawing_pset_data["ShadingStyles"]
+        current_style = drawing_pset_data.get("CurrentShadingStyle", None)
+
+        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"}
+
+        with open(json_path, "r") as fi:
+            shading_styles_json = json.load(fi)
+
+        drawing_styles = context.scene.DocProperties.drawing_styles
+        drawing_styles.clear()
+        styles = [style for style in shading_styles_json]
+        for style_name in styles:
+            style_data = shading_styles_json[style_name]
+            drawing_style = drawing_styles.add()
+            drawing_style["name"] = style_name  # setting as attribute to avoid triggering setter
+            drawing_style.render_type = style_data["render_type"]
+            drawing_style.raster_style = json.dumps(style_data["raster_style"])
+
+        if current_style is not None:
+            camera_props.active_drawing_style_index = styles.index(current_style)
+
+        return {"FINISHED"}
+
+
+class AddDrawingStyle(bpy.types.Operator, Operator):
     bl_idname = "bim.add_drawing_style"
     bl_label = "Add Drawing Style"
     bl_options = {"REGISTER", "UNDO"}
 
     def execute(self, context):
-        new = context.scene.DocProperties.drawing_styles.add()
-        new.name = "New Drawing Style"
+        drawing_styles = context.scene.DocProperties.drawing_styles
+        new = drawing_styles.add()
+        # drawing style is saved to ifc on rename
+        new.name = tool.Blender.ensure_unique_name("New Drawing Style", drawing_styles)
+        context.scene.camera.data.BIMCameraProperties.active_drawing_style_index = len(drawing_styles) - 1
         return {"FINISHED"}
 
 
-class RemoveDrawingStyle(bpy.types.Operator):
+class RemoveDrawingStyle(bpy.types.Operator, Operator):
     bl_idname = "bim.remove_drawing_style"
     bl_label = "Remove Drawing Style"
     bl_options = {"REGISTER", "UNDO"}
@@ -1376,13 +1504,17 @@ class RemoveDrawingStyle(bpy.types.Operator):
 
     def execute(self, context):
         context.scene.DocProperties.drawing_styles.remove(self.index)
+        context.scene.camera.data.BIMCameraProperties.active_drawing_style_index = max(self.index - 1, 0)
+        bpy.ops.bim.save_drawing_styles_data()
         return {"FINISHED"}
 
 
-class SaveDrawingStyle(bpy.types.Operator):
+class SaveDrawingStyle(bpy.types.Operator, Operator):
     bl_idname = "bim.save_drawing_style"
     bl_label = "Save Drawing Style"
     bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Save current render setting to currently selected drawing style. Also resaves styles data to IFC"
+
     index: bpy.props.StringProperty()
     # TODO: check undo redo
 
@@ -1390,19 +1522,46 @@ class SaveDrawingStyle(bpy.types.Operator):
         space = self.get_view_3d(context)  # Do not remove. It is used later in eval
         scene = context.scene
         style = {}
-        for prop in RasterStyleProperty:
-            value = eval(prop.value)
+        eval_namespace = {
+            'context': context,
+            'scene': scene,
+            'space': space
+        }
+
+        def add_prop_to_style(prop_path, context, scene, space):
+            value = eval(prop_path)
             if not isinstance(value, str):
                 try:
                     value = tuple(value)
                 except TypeError:
                     pass
-            style[prop.value] = value
+            style[prop_path] = value
+
+        for prop in RasterStyleProperty:
+            if prop.name.startswith("EVAL_PROP"):
+                prop_path = prop.value
+                add_prop_to_style(prop_path, **eval_namespace)
+            else:
+                props_source_path = prop.value
+                props_source = eval(props_source_path)
+                for prop_name in dir(props_source):
+                    if prop_name.startswith("__"): 
+                        continue 
+
+                    prop_path = f"{props_source_path}.{prop_name}"
+                    prop_value = eval(prop_path)
+                    if not isinstance(prop_value, (int, float, bool, str, Color, Vector)) or props_source.is_property_readonly(prop_name) or prop_path in RASTER_STYLE_PROPERTIES_EXCLUDE:
+                        continue
+
+                    add_prop_to_style(prop_path, **eval_namespace)
+
         if self.index:
             index = int(self.index)
         else:
             index = context.active_object.data.BIMCameraProperties.active_drawing_style_index
         scene.DocProperties.drawing_styles[index].raster_style = json.dumps(style)
+
+        bpy.ops.bim.save_drawing_styles_data()
         return {"FINISHED"}
 
     def get_view_3d(self, context):
@@ -1415,19 +1574,84 @@ class SaveDrawingStyle(bpy.types.Operator):
                 return space
 
 
-class ActivateDrawingStyle(bpy.types.Operator):
+class SaveDrawingStylesData(bpy.types.Operator, Operator):
+    bl_idname = "bim.save_drawing_styles_data"
+    bl_label = "Save Drawing Styles Data"
+    bl_options = {"REGISTER", "UNDO"}
+
+    skip_updating_current_style: bpy.props.BoolProperty(default=False)
+    rename_style: bpy.props.BoolProperty(default=False)
+    rename_style_from: bpy.props.StringProperty(default="")
+    rename_style_to: bpy.props.StringProperty(default="")
+
+    def execute(self, context):
+        if not DrawingsData.is_loaded:
+            DrawingsData.load()
+        drawing_pset_data = DrawingsData.data["active_drawing_pset_data"]
+        drawing_styles = context.scene.DocProperties.drawing_styles
+
+        rel_path = drawing_pset_data["ShadingStyles"]
+        current_style = drawing_pset_data.get("CurrentShadingStyle", None)
+        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"}
+
+        styles_data = {}
+        for style in drawing_styles:
+            style_data = {"render_type": style.render_type, "raster_style": json.loads(style.raster_style)}
+            styles_data[style.name] = style_data
+
+        with open(json_path, "w") as fo:
+            json.dump(styles_data, fo, indent=4)
+
+        # TODO: currently it doesn't update current style for the other drawings
+        # handling case when current style is not present in styles saved in ifc
+        if not self.skip_updating_current_style and current_style not in styles_data and current_style is not None:
+            # style was renamed
+            if self.rename_style and current_style == self.rename_style_from:
+                new_style_name = self.rename_style_to
+
+            # style was removed
+            else:
+                new_style_name = None
+
+            ifc_file = tool.Ifc.get()
+            drawing = ifc_file.by_id(context.scene.DocProperties.active_drawing_id)
+            pset = tool.Pset.get_element_pset(drawing, "EPset_Drawing")
+            ifcopenshell.api.run(
+                "pset.edit_pset", ifc_file, pset=pset, properties={"CurrentShadingStyle": new_style_name}
+            )
+            blenderbim.bim.handler.refresh_ui_data()
+
+        return {"FINISHED"}
+
+
+class ActivateDrawingStyle(bpy.types.Operator, Operator):
     bl_idname = "bim.activate_drawing_style"
     bl_label = "Activate Drawing Style"
     bl_options = {"REGISTER", "UNDO"}
 
     def execute(self, context):
         scene = context.scene
-        if scene.camera.data.BIMCameraProperties.active_drawing_style_index < len(scene.DocProperties.drawing_styles):
-            self.drawing_style = scene.DocProperties.drawing_styles[
-                scene.camera.data.BIMCameraProperties.active_drawing_style_index
-            ]
-            self.set_raster_style(context)
-            self.set_query(context)
+        ifc_file = tool.Ifc.get()
+        active_drawing_style_index = scene.camera.data.BIMCameraProperties.active_drawing_style_index
+
+        if active_drawing_style_index >= len(scene.DocProperties.drawing_styles):
+            self.report({"ERROR"}, "Could not find active drawing style")
+            return {"CANCELLED"}
+
+        self.drawing_style = scene.DocProperties.drawing_styles[active_drawing_style_index]
+
+        self.set_raster_style(context)
+        self.set_query(context)
+
+        drawing = ifc_file.by_id(scene.DocProperties.active_drawing_id)
+        pset = tool.Pset.get_element_pset(drawing, "EPset_Drawing")
+        ifcopenshell.api.run(
+            "pset.edit_pset", ifc_file, pset=pset, properties={"CurrentShadingStyle": self.drawing_style.name}
+        )
+        blenderbim.bim.handler.refresh_ui_data()
         return {"FINISHED"}
 
     def set_raster_style(self, context):
@@ -1512,7 +1736,10 @@ class AddSchedule(bpy.types.Operator, Operator):
             ifc_path = tool.Ifc.get_path()
             if os.path.isfile(ifc_path):
                 ifc_path = os.path.dirname(ifc_path)
-            filepath = os.path.relpath(filepath, ifc_path)
+
+            # taking into account different drives on windows
+            if Path(filepath).drive == Path(ifc_path).drive:
+                filepath = os.path.relpath(filepath, ifc_path)
         core.add_schedule(
             tool.Ifc,
             tool.Drawing,
@@ -1566,7 +1793,7 @@ class AddScheduleToSheet(bpy.types.Operator, Operator):
     def _execute(self, context):
         props = context.scene.DocProperties
         active_schedule = props.schedules[props.active_schedule_index]
-        active_sheet = props.sheets[props.active_sheet_index]
+        active_sheet = tool.Drawing.get_active_sheet(context)
         schedule = tool.Ifc.get().by_id(active_schedule.ifc_definition_id)
         if tool.Ifc.get_schema() == "IFC2X3":
             schedule_location = tool.Drawing.get_path_with_ext(schedule.DocumentReferences[0].Location, "svg")
@@ -1607,6 +1834,7 @@ class AddScheduleToSheet(bpy.types.Operator, Operator):
         tool.Drawing.import_sheets()
 
 
+# TODO: dead code - drawing style attributes are never used?
 class AddDrawingStyleAttribute(bpy.types.Operator):
     bl_idname = "bim.add_drawing_style_attribute"
     bl_label = "Add Drawing Style Attribute"
@@ -1618,6 +1846,7 @@ class AddDrawingStyleAttribute(bpy.types.Operator):
         return {"FINISHED"}
 
 
+# TODO: dead code - drawing style attributes are never used?
 class RemoveDrawingStyleAttribute(bpy.types.Operator):
     bl_idname = "bim.remove_drawing_style_attribute"
     bl_label = "Remove Drawing Style Attribute"

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

@@ -156,6 +156,21 @@ def update_drawing_name(self, context):
     core.update_drawing_name(tool.Ifc, tool.Drawing, drawing=drawing, name=self.name)
 
 
+def get_drawing_style_name(self):
+    """needed to make `set_drawing_style_name` work"""
+    return self.get("name", "")
+
+
+def set_drawing_style_name(self, new_value):
+    """ensure the name is unique"""
+    scene = bpy.context.scene
+    drawing_styles = [s.name for s in scene.DocProperties.drawing_styles if s.name != self.name]
+    new_value = tool.Blender.ensure_unique_name(new_value, drawing_styles)
+    old_value = self.name
+    self["name"] = new_value
+    bpy.ops.bim.save_drawing_styles_data(rename_style=True, rename_style_from=old_value, rename_style_to=new_value)
+
+
 def update_schedule_name(self, context):
     schedule = tool.Ifc.get().by_id(self.ifc_definition_id)
     core.update_schedule_name(tool.Ifc, tool.Drawing, schedule=schedule, name=self.name)
@@ -163,6 +178,10 @@ def update_schedule_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):
+        bpy.ops.bim.reload_drawing_styles()
+        bpy.ops.bim.activate_drawing_style()
 
 
 def update_has_linework(self, context):
@@ -201,6 +220,9 @@ def toggleDecorations(self, context):
         # TODO: design a proper text variable templating renderer
         collection = context.scene.camera.users_collection[0]
         for obj in collection.objects:
+            element = tool.Ifc.get_entity(obj)
+            if not element or not tool.Drawing.is_annotation_object_type(element, ["TEXT", "TEXT_LEADER"]):
+                continue
             tool.Drawing.update_text_value(obj)
         refresh_drawing_data()
         decoration.DecorationsHandler.install(context)
@@ -236,8 +258,8 @@ class Sheet(PropertyGroup):
 
 
 class DrawingStyle(PropertyGroup):
-    name: StringProperty(name="Name")
-    raster_style: StringProperty(name="Raster Style")
+    name: StringProperty(name="Name", get=get_drawing_style_name, set=set_drawing_style_name)
+    raster_style: StringProperty(name="Raster Style", default="{}")
     render_type: EnumProperty(
         items=[
             ("NONE", "None", ""),
@@ -253,30 +275,20 @@ class DrawingStyle(PropertyGroup):
 
 
 class RasterStyleProperty(enum.Enum):
-    WORLD_COLOR = "bpy.data.worlds[0].color"
-    RENDER_ENGINE = "scene.render.engine"
-    RENDER_TRANSPARENT = "scene.render.film_transparent"
-    VIEW_TRANSFORM = "scene.view_settings.view_transform"
-    SHADING_SHOW_OBJECT_OUTLINE = "scene.display.shading.show_object_outline"
-    SHADING_SHOW_CAVITY = "scene.display.shading.show_cavity"
-    SHADING_CAVITY_TYPE = "scene.display.shading.cavity_type"
-    SHADING_CURVATURE_RIDGE_FACTOR = "scene.display.shading.curvature_ridge_factor"
-    SHADING_CURVATURE_VALLEY_FACTOR = "scene.display.shading.curvature_valley_factor"
-    SHADING_LIGHT = "scene.display.shading.light"
-    SHADING_COLOR_TYPE = "scene.display.shading.color_type"
-    SHADING_SINGLE_COLOR = "scene.display.shading.single_color"
-    SHADING_SHOW_SHADOWS = "scene.display.shading.show_shadows"
-    SHADING_SHADOW_INTENSITY = "scene.display.shading.shadow_intensity"
-    DISPLAY_LIGHT_DIRECTION = "scene.display.light_direction"
-    VIEW_USE_CURVE_MAPPING = "scene.view_settings.use_curve_mapping"
-    OVERLAY_SHOW_WIREFRAMES = "space.overlay.show_wireframes"
-    OVERLAY_WIREFRAME_THRESHOLD = "space.overlay.wireframe_threshold"
-    OVERLAY_SHOW_FLOOR = "space.overlay.show_floor"
-    OVERLAY_SHOW_AXIS_X = "space.overlay.show_axis_x"
-    OVERLAY_SHOW_AXIS_Y = "space.overlay.show_axis_y"
-    OVERLAY_SHOW_AXIS_Z = "space.overlay.show_axis_z"
-    OVERLAY_SHOW_OBJECT_ORIGINS = "space.overlay.show_object_origins"
-    OVERLAY_SHOW_RELATIONSHIP_LINES = "space.overlay.show_relationship_lines"
+    # EVAL_PROP_ props will be evaluated explicitly
+    EVAL_PROP_WORLD_COLOR = "bpy.data.worlds[0].color"
+
+    # those props attributes used as a source for shading style properties
+    RENDER = "scene.render"
+    VIEW_SETTINGS = "scene.view_settings"
+    SHADING = "scene.display.shading"
+    DISPLAY = "scene.display"
+    OVERLAY = "space.overlay"
+
+
+RASTER_STYLE_PROPERTIES_EXCLUDE = (
+    "scene.render.filepath",
+)
 
 
 class DocProperties(PropertyGroup):
@@ -312,9 +324,6 @@ class DocProperties(PropertyGroup):
     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)
-    decorations_colour: FloatVectorProperty(
-        name="Decorations Colour", subtype="COLOR", default=(1, 1, 1, 1), min=0.0, max=1.0, size=4
-    )
     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(
@@ -327,6 +336,10 @@ class DocProperties(PropertyGroup):
     markers_path: StringProperty(default=os.path.join("drawings", "assets", "markers.svg"), name="Default Markers")
     symbols_path: StringProperty(default=os.path.join("drawings", "assets", "symbols.svg"), name="Default Symbols")
     patterns_path: StringProperty(default=os.path.join("drawings", "assets", "patterns.svg"), name="Default Patterns")
+    shadingstyles_path: StringProperty(
+        default=os.path.join("drawings", "assets", "shading_styles.json"), name="Default Shading Styles"
+    )
+    shadingstyle_default: StringProperty(default="Blender Default", name="Default Shading Style")
 
 
 class BIMCameraProperties(PropertyGroup):
@@ -339,6 +352,8 @@ class BIMCameraProperties(PropertyGroup):
     view_name: StringProperty(name="View Name")
     diagram_scale: EnumProperty(items=get_diagram_scales, name="Drawing Scale", update=update_diagram_scale)
     custom_diagram_scale: StringProperty(name="Custom Scale", update=update_diagram_scale)
+    custom_diagram_scale_input1: StringProperty(name="Custom Scale Input 1", update=update_diagram_scale)
+    custom_diagram_scale_input2: StringProperty(name="Custom Scale Input 2", update=update_diagram_scale)
     raster_x: IntProperty(name="Raster X", default=1000)
     raster_y: IntProperty(name="Raster Y", default=1000)
     is_nts: BoolProperty(name="Is NTS")
@@ -471,6 +486,7 @@ ANNOTATION_TYPES_DATA = {
     "BREAKLINE":     ("Breakline",        "", "FCURVE", "mesh"),
     "LINEWORK":      ("Line",             "", "MESH_MONKEY", "mesh"),
     "BATTING":       ("Batting",          "Add batting annotation.\nThickness could be changed through Thickness property of BBIM_Batting property set", "FORCE_FORCE", "mesh"),
+    "REVISION_CLOUD":("Revision Cloud",   "Add revision cloud", "VOLUME_DATA", "mesh"),
     "FILL_AREA":     ("Fill Area",        "", "NODE_TEXTURE", "mesh"),
     "FALL":          ("Fall",             "", "SORT_ASC", "curve"),
 }

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

@@ -16,12 +16,41 @@
 # 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 blenderbim.bim.module.drawing.svgwriter import SvgWriter
 import svgwrite
 
-from odf.opendocument import load
+from odf.opendocument import load as load_ods
 from odf.table import Table, TableRow, TableColumn, TableCell
 from odf.text import P
 from odf.style import Style
+from textwrap import wrap
+from pathlib import Path
+import string
+
+FONT_SIZE = 4.13
+FONT_WIDTH = lambda size: size * 0.45
+FONT_SIZE_PT = 12
+FONT_FAMILY = "OpenGost Type B TT"
+DEBUG = False
+
+
+def col2num(col):
+    """convert letter column index to number:
+    `"A" -> 1`, `"AA" -> 27``
+    """
+    num = 0
+    for c in col:
+        if c in string.ascii_letters:
+            num = num * 26 + (ord(c.upper()) - ord("A")) + 1
+    return num
+
+
+def a1_to_rc(cell):
+    """convert cell index from A1 format to RC: `"A1" -> (0,0)`"""
+    column_letter = cell.strip(string.digits)
+    col_number = col2num(column_letter) - 1
+    row_number = int(cell[len(column_letter) :]) - 1
+    return row_number, col_number
 
 
 class Scheduler:
@@ -33,69 +62,328 @@ class Scheduler:
         )
         self.padding = 1
         self.margin = 1
-        doc = load(infile)
+        doc = load_ods(infile)
+
+        # useful for debugging ods
+        if DEBUG:
+            import xml.dom.minidom
+
+            path = Path(infile)
+            dom = xml.dom.minidom.parseString(doc.xml())
+            pretty_xml = dom.toprettyxml()
+
+            with open(path.with_suffix(".xml"), "w") as fo:
+                fo.write(pretty_xml)
+
         styles = {}
-        for style in doc.getElementsByType(Style):
-            name = style.getAttribute("name")
-            if not style.firstChild:
+        for cell_style in doc.getElementsByType(Style):
+            name = cell_style.getAttribute("name")
+            styles[name] = {}
+
+            # NOTE: there are also styles that inherit from parent styles that we do not process atm
+            if not cell_style.firstChild:
                 continue
-            styles[name] = {key[1]: value for key, value in style.firstChild.attributes.items()}
+
+            if cell_style.firstChild.tagName in ["style:table-column-properties", "style:table-row-properties"]:
+                style_children = [cell_style.firstChild]
+            else:
+                # for style:table-cell-properties we need to collect also text and paragraph properties
+                style_children = cell_style.childNodes
+
+            for child in style_children:
+                child_params = {key[1]: value for key, value in child.attributes.items()}
+                styles[name].update(child_params)
 
         table = doc.getElementsByType(Table)[0]
+
+        # related styles stored as a list of tuples:
+        # [(child, parent), ...]
+        related_styles = []
+
+        # collect columns width
         column_widths = []
+        column_styles = []
         for col in table.getElementsByType(TableColumn):
             style_name = col.getAttribute("stylename")
-            repeat = col.getAttribute("numbercolumnsrepeated")
-            repeat = int(repeat) if repeat else 1
-            for i in range(0, repeat):
+            col_repeat = col.getAttribute("numbercolumnsrepeated")
+            col_repeat = int(col_repeat) if col_repeat else 1
+            for i in range(col_repeat):
                 if not style_name or "column-width" not in styles[style_name]:
-                    column_widths.append(50)
+                    column_width = 50
                 else:
-                    column_widths.append(self.convert_to_mm(styles[style_name]["column-width"]))
+                    column_width = self.convert_to_mm(styles[style_name]["column-width"])
+                column_styles.append(style_name)
+                column_widths.append(column_width)
+            cell_style = col.getAttribute("defaultcellstylename")
+            if cell_style:
+                related_styles.append((style_name, cell_style))
 
+        # collect rows height
+        row_heights = []
+        # TODO: never used yet because unsure about priority for row styles
+        # over column styles or vice versa
+        row_styles = []
+
+        for col in table.getElementsByType(TableRow):
+            style_name = col.getAttribute("stylename")
+            row_repeat = col.getAttribute("numberrowsrepeated")
+            row_repeat = int(row_repeat) if row_repeat else 1
+            for i in range(row_repeat):
+                if not style_name or "row-height" not in styles[style_name]:
+                    row_height = 6
+                else:
+                    row_height = self.convert_to_mm(styles[style_name]["row-height"])
+                row_styles.append(style_name)
+                row_heights.append(row_height)
+            cell_style = col.getAttribute("defaultcellstylename")
+            if cell_style:
+                related_styles.append((style_name, cell_style))
+
+        while len(related_styles) > 0:
+            # unzip related styles to children and parents
+            children, parents = zip(*related_styles)
+            independent_styles = set(parents) - set(children)
+            for relation in related_styles[:]:
+                child, parent = relation
+                if parent in independent_styles:
+                    child_style = styles[child]
+                    styles[child] = styles[parent] | child_style
+                    related_styles.remove(relation)
+
+        # TODO: multiple print ranges? 😔
+        print_range = table.getAttribute("printranges")
+        if print_range:
+            min_rc, max_rc = [a1_to_rc(cell.rsplit(".", 1)[1]) for cell in print_range.split(":")]
+        else:
+            # fallback if print range is not defined
+            n_rows = len(row_heights)
+            n_cols = len(column_widths)
+            n_cells = len(row_heights) * len(column_widths)
+            cells_limit = 10000
+            if n_cells >= cells_limit:
+                raise Exception(
+                    f"You were about to build a very big table with number of cells more than {cells_limit}.\n"
+                    f"In fact it is {n_rows} rows x {n_cols} cols = {n_cells} cells \n"
+                    "and the operation was stopped to prevent system freeze.\n"
+                    "Please define print range in .ods file to proceede\n"
+                    "(needed to make sure printed table will have reasonable size)."
+                )
+
+            min_rc, max_rc = (0, 0), (1048576, 16384)
+        min_row, min_col = min_rc
+        max_row, max_col = max_rc
+
+        # draw table
         y = self.margin
-        for tri, tr in enumerate(table.getElementsByType(TableRow)):
-            x = self.margin
-            height = 6
-            tdi = 0
-            for td in tr.getElementsByType(TableCell):
-                repeat = td.getAttribute("numbercolumnsrepeated")
-                repeat = int(repeat) if repeat else 1
-                for i in range(0, repeat):
-                    width = column_widths[tdi]
-                    self.svg.add(
-                        self.svg.rect(
-                            insert=(x, y),
-                            size=(width, height),
-                            style="fill: #ffffff; stroke-width:.125; stroke: #000000;",
+        tri = 0
+        stop_iterating_over_rows = False
+        # TODO: row spans support?
+        for tr in table.getElementsByType(TableRow):
+            if stop_iterating_over_rows:
+                break
+
+            row_repeat = tr.getAttribute("numberrowsrepeated")
+            row_repeat = int(row_repeat) if row_repeat else 1
+
+            for i_row_repeat in range(row_repeat):
+                if tri < min_row:
+                    tri += 1
+                    continue
+                elif tri > max_row:
+                    stop_iterating_over_rows = True
+                    break
+
+                x = self.margin
+                height = row_heights[tri]
+                tdi = 0
+                stop_iterating_over_columns = False
+
+                for td in tr.getElementsByType(TableCell):
+                    if stop_iterating_over_columns:
+                        break
+
+                    column_span = td.getAttribute("numbercolumnsspanned")
+                    column_span = int(column_span) if column_span else 1
+
+                    col_repeat = td.getAttribute("numbercolumnsrepeated")
+                    col_repeat = int(col_repeat) if col_repeat else 1
+
+                    # figuring text alignment
+                    cell_style = self.get_style(td.getAttribute("stylename"), styles)
+
+                    # drawing cells and text
+                    for i_col_repeat in range(col_repeat):
+                        start_tdi = tdi
+                        end_tdi = tdi + int(column_span) - 1
+                        # if the entire span is beyond print range => continue
+                        # if only part then keeping that part
+                        if start_tdi < min_col:
+                            if end_tdi < min_col:
+                                tdi += column_span
+                                continue
+                            else:
+                                start_tdi = min_col
+
+                        # stop if start column is beyond print range
+                        if start_tdi > max_col:
+                            stop_iterating_over_columns = True
+                            break
+
+                        # making sure last column won't go beyond the print range
+                        if end_tdi > max_col:
+                            end_tdi = max_col
+
+                        width = sum(column_widths[start_tdi : end_tdi + 1])
+
+                        self.svg.add(
+                            self.svg.rect(
+                                insert=(x, y),
+                                size=(width, height),
+                                style="fill: #ffffff; stroke-width:.125; stroke: #000000;",
+                            )
                         )
-                    )
-                    value = td.getElementsByType(P)
-                    if value:
-                        self.add_text(value[0], x + self.padding, y + self.padding)
-                    x += width
-                    tdi += 1
-            y += height
-        total_width = sum(column_widths) + (self.margin * 2)
+                        p_tags = td.getElementsByType(P)
+
+                        col_style = self.get_style(column_styles[tdi], styles)
+                        final_cell_style = cell_style or col_style
+                        box_alignment = self.get_box_alignment(final_cell_style)
+                        wrap_text = final_cell_style.get("wrap-option", None) == "wrap"
+                        bold_text = final_cell_style.get("font-weight", None) == "bold"
+                        italic_text = final_cell_style.get("font-style", None) == "italic"
+                        # NOTE: very naive since we're scaling text proportionally
+                        font_size = (
+                            float(final_cell_style.get("font-size", f"{FONT_SIZE_PT}pt")[:-2])
+                            / FONT_SIZE_PT
+                            * FONT_SIZE
+                        )
+
+                        if p_tags:
+                            # figuring text position based on alignment
+                            text_position = [0.0, 0.0]
+                            if box_alignment.endswith("left"):
+                                text_position[0] = x + self.padding
+                            elif box_alignment.endswith("middle") or box_alignment == "center":
+                                text_position[0] = x + width / 2
+                            elif box_alignment.endswith("right"):
+                                text_position[0] = x + width - self.padding
+
+                            if box_alignment.startswith("top"):
+                                text_position[1] = y + self.padding
+                            elif box_alignment.startswith("middle") or box_alignment == "center":
+                                text_position[1] = y + height / 2
+                            elif box_alignment.startswith("bottom"):
+                                text_position[1] = y + height - self.padding
+
+                            self.add_text(
+                                p_tags,
+                                *text_position,
+                                font_size=font_size,
+                                box_alignment=box_alignment,
+                                wrap_text=wrap_text,
+                                cell_width=width,
+                                bold=bold_text,
+                                italic=italic_text,
+                            )
+                        x += width
+                        tdi += column_span
+
+                tri += 1
+                y += height
+
+        total_width = x + self.margin
+        total_height = y + self.margin
         self.svg["width"] = "{}mm".format(total_width)
-        self.svg["height"] = "{}mm".format(y)
-        self.svg["viewBox"] = "0 0 {} {}".format(total_width, y)
+        self.svg["height"] = "{}mm".format(total_height)
+        self.svg["viewBox"] = "0 0 {} {}".format(total_width, total_height)
         self.svg.save(pretty=True)
 
-    def add_text(self, text, x, y):
-        self.svg.add(
-            self.svg.text(
-                str(text).upper(),
-                insert=tuple((x, y)),
-                **{
-                    "font-size": 4.13,
-                    "font-family": "OpenGost Type B TT",
-                    "text-anchor": "start",
-                    "alignment-baseline": "baseline",
-                    "dominant-baseline": "hanging",
-                }
-            )
-        )
+    def get_style(self, style_name, styles):
+        style = styles[style_name] if style_name else {}
+        return style
+
+    def get_box_alignment(self, style):
+        if style and "vertical-align" in style and style["vertical-align"] != "automatic":
+            vertical_align = style["vertical-align"]
+        else:
+            vertical_align = "bottom"
+
+        alignment_translation = {
+            "center": "middle",
+            "end": "right",
+            "start": "left",
+        }
+
+        if style and "text-align" in style and style["text-align"] != "automatic":
+            horizontal_align = style["text-align"]
+            horizontal_align = alignment_translation.get(horizontal_align, horizontal_align)
+        else:
+            horizontal_align = "left"
+
+        if vertical_align == "middle" and horizontal_align == "middle":
+            box_alignment = "center"
+        else:
+            box_alignment = f"{vertical_align}-{horizontal_align}"
+
+        return box_alignment
+
+    def add_text(
+        self,
+        p_tags,
+        x,
+        y,
+        font_size,
+        box_alignment="bottom-left",
+        wrap_text=False,
+        cell_width=100,
+        bold=False,
+        italic=False,
+    ):
+        """
+        Adds text to svg.
+
+        Args:
+            p_tags: list of cell's P tags from odt file
+            box_alignment: alignment of text in box
+            wrap_text: if True, text will be wrapped to fit in cell
+            cell_width: width of cell, used for wrapping text
+        """
+        text_lines = [str(p).upper() for p in p_tags]
+        box_alignment_params = SvgWriter.get_box_alignment_parameters(box_alignment)
+        text_params = {
+            "font-size": font_size,
+            "font-family": FONT_FAMILY,
+        }
+        if bold:
+            text_params["font-weight"] = "bold"
+        if italic:
+            text_params["font-style"] = "italic"
+
+        if len(text_lines) == 1 and not wrap_text:
+            text_params.update(box_alignment_params)
+            text_tag = self.svg.text(text_lines[0], insert=(x, y), **(text_params))
+            self.svg.add(text_tag)
+            return
+
+        text_tag = self.svg.text("", **(text_params | {"font-size": "0"} | box_alignment_params))
+
+        # TODO: should be done in less naive way
+        # without using magic number for FONT_WIDTH
+        # currently it might not work for all fonts and font sizes
+        if wrap_text:
+            wrapped_lines = []
+            for line in text_lines:
+                wrapped_line = wrap(line, width=int(cell_width // FONT_WIDTH(font_size)), break_long_words=False)
+                wrapped_lines.extend(wrapped_line)
+        else:
+            wrapped_lines = text_lines
+
+        for line_number, text_line in enumerate(wrapped_lines[::-1]):
+            # position has to be inserted at tspan to avoid x offset between tspans
+            tspan = self.svg.tspan(text_line, insert=(x, y), **text_params)
+            # doing it here and not in tspan constructor because constructor adds unnecessary spaces
+            tspan.update({"dy": f"-{line_number}em"})
+            text_tag.add(tspan)
+        self.svg.add(text_tag)
 
     def convert_to_mm(self, value):
         # XSL is what defines the units of measurements in ODF

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

@@ -16,9 +16,23 @@
 # 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 gpu.types import GPUShader
 from gpu_extras.batch import batch_for_shader
 import gpu
+from mathutils import Vector
+
+
+# NOTES:
+# Since Metal doesn't support geometry shaders we stick to builtin shaders
+# and generate all geometry data in python before passing it to the shader.
+# This way was considered to be the most reliable atm.
+# More: https://blender.stackexchange.com/questions/291674/migrating-geometry-shaders-to-metal
+#
+# BGL deprecation:
+# since `bgl` is deprecated, creating smoothing lines became tricky
+# Notes for creating shaders with smoothed lines:
+# in geom shader - use triangle_strip, DEFAULT_SETUP, do_edge_verts or do_vertex to emit vertices
+# in frag shader - use lineWidth uniform, smoothline flaot in, smoothing shader code from base shader
+# mind the vertex limit since emitting vertices for smoothed lines produces twice as much vertices
 
 
 BASE_DEF_GLSL = """
@@ -29,12 +43,6 @@ BASE_DEF_GLSL = """
 #define lineSmooth true
 """
 
-# since `bgl` is deprecated, creating smoothing lines became tricky
-# Notes for creating shaders with smoothed lines:
-# in geom shader - use triangle_strip, DEFAULT_SETUP, do_edge_verts or do_vertex to emit vertices
-# in frag shader - use lineWidth uniform, smoothline flaot in, smoothing shader code from base shader
-# mind the vertex limit since emitting vertices for smoothed lines produces twice as much vertices
-
 BASE_LIB_GLSL = """
 // TODO: redefine as macor instead
 uniform vec2 winsize;
@@ -160,12 +168,11 @@ void do_vertex_util(vec4 pos, vec2 ofs)
 
 // geometry utils
 void triangle_head(in vec4 side, in vec4 dir, in float length, in float width, in float radius, out vec4 head[5]) {
-    vec4 nose = side * length;
-    vec4 ear = dir * width;
+    // TODO: radius is unnecessary?
     head[0] = side * -radius;
-    head[1] = nose * -.5;
-    head[2] = vec4(0) + ear;
-    head[3] = nose * .5;
+    head[1] = side * length * -.5;
+    head[2] = dir * width;
+    head[3] = side * length * .5;
     head[4] = side * radius;
 }
 
@@ -189,6 +196,22 @@ void do_circle_head(vec4 pos_w, vec4 head[CIRCLE_SEGS]) {
 """
 
 
+def add_verts_sequence(verts, start_i, output_verts, output_edges, closed=False):
+    """Add sequence of verts to output lists, returns next vertex index"""
+    for i, v in enumerate(verts[:-1], start_i):
+        output_verts.append(v)
+        output_edges.append((i, i + 1))
+    output_verts.append(verts[-1])
+    if closed:
+        output_edges.append((i + 1, start_i))
+    return i + 2
+
+
+def add_offsets(v, offsets):
+    """returns list of verts with offsets added"""
+    return [v + offset for offset in offsets]
+
+
 class BaseShader:
     """Wrapper for GPUShader
     To use for viewport decorations with geometry generated on GPU side.
@@ -265,48 +288,49 @@ class BaseShader:
     """
 
     def __init__(self):
-        # NB: libcode arg doesn't work
-        # TODO: rename to .shader
-        self.prog = GPUShader(
-            vertexcode=self.VERT_GLSL,
-            fragcode=self.FRAG_GLSL,
-            geocode=self.LIB_GLSL + self.GEOM_GLSL,
-            defines=self.DEF_GLSL,
-        )
+        # 3D_POLYLINE_UNIFORM_COLOR is good for smoothed lines since `bgl.enable(GL_LINE_SMOOTH)` is deprecated
+        self.line_shader = gpu.shader.from_builtin("3D_POLYLINE_UNIFORM_COLOR")
+        self.base_shader = gpu.shader.from_builtin("3D_UNIFORM_COLOR")
+
+    def get_shader(self):
+        """Returns shader for this type"""
+        return self.line_shader if self.TYPE == "LINES" else self.base_shader
 
     def batch(self, indices=None, **data):
         """Returns automatic GPUBatch filled with provided parameters"""
-        batch = batch_for_shader(self.prog, self.TYPE, data, indices=indices)
-        batch.program_set(self.prog)
+        shader = self.get_shader()
+        batch = batch_for_shader(shader, self.TYPE, data, indices=indices)
         return batch
 
     def bind(self):
-        self.prog.bind()
+        """need to bind shader before changing it's uniforms"""
+        shader = self.get_shader()
+        shader.bind()
+        return shader
 
     def glenable(self):
         gpu.state.blend_set("ALPHA")
         gpu.state.depth_test_set("LESS_EQUAL")
 
     def uniform_region(self, ctx):
+        shader = self.bind()
+
         region = ctx.region
         region3d = ctx.region_data
 
         uniform_floats = {
-            "viewMatrix": region3d.perspective_matrix,
-            "winsize": (region.width, region.height),
+            "ModelViewProjectionMatrix": region3d.perspective_matrix,
+            # POLYLINE_UNIFORM_COLOR specific uniforms
+            "viewportSize": (region.width, region.height),
             "lineWidth": 2.5,
         }
 
         for name, value in uniform_floats.items():
-            try:
-                self.prog.uniform_float(name, value)
-                # TODO: shouldn't just try'n'catch them
-                # because they may indicate errors in code
-            except ValueError:  # unused uniform
-                pass
+            shader.uniform_float(name, value)
 
 
-# TODO: add smoothing if this shades is going to be used
+# TODO: add smoothing if this shader is going to be used
+# TODO: dead code?
 class BaseLinesShader(BaseShader):
     """Draws line segments with gaps around vertices at endpoints"""
 
@@ -429,37 +453,24 @@ class ExtrusionGuidesShader(GizmoShader):
 
     TYPE = "LINES"
 
-    DEF_GLSL = (
-        BaseShader.DEF_GLSL
-        + """
-    #define CROSS_SIZE .5
-    """
-    )
+    def process_geometry(self, verts):
+        CROSS_SIZE = 0.5
 
-    GEOM_GLSL = """
-    uniform mat4 ModelViewProjectionMatrix;
+        p0, p1 = verts
+        bx = Vector((1, 0, 0)) * CROSS_SIZE
+        by = Vector((0, 1, 0)) * CROSS_SIZE
 
-    layout(lines) in;
-    layout(triangle_strip, max_vertices=MAX_POINTS) out;
+        output_verts = []
+        output_edges = []
+        out_kwargs = {
+            "output_verts": output_verts,
+            "output_edges": output_edges,
+        }
 
-    void main() {
-        // default setup for macro to work
-        vec2 EDGE_DIR;
+        start_i = 0
+        start_i = add_verts_sequence(add_offsets(p0, [-bx, bx]), start_i, **out_kwargs)
+        start_i = add_verts_sequence(add_offsets(p0, [-by, by]), start_i, **out_kwargs)
+        start_i = add_verts_sequence(add_offsets(p1, [-bx, bx]), start_i, **out_kwargs)
+        start_i = add_verts_sequence(add_offsets(p1, [-by, by]), start_i, **out_kwargs)
 
-        vec4 p0 = gl_in[0].gl_Position, p1 = gl_in[1].gl_Position;
-        do_edge_verts(p0, p1);
-        EndPrimitive();
-
-        vec4 bx = ModelViewProjectionMatrix[0] * CROSS_SIZE;
-        vec4 by = ModelViewProjectionMatrix[1] * CROSS_SIZE;
-
-        do_edge_verts(p0 - bx, p0 + bx);
-        EndPrimitive();
-        do_edge_verts(p0 - by, p0 + by);
-        EndPrimitive();
-        do_edge_verts(p1 - bx, p1 + bx);
-        EndPrimitive();
-        do_edge_verts(p1 - by, p1 + by);
-        EndPrimitive();
-    }
-    """
+        return output_verts, output_edges

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

@@ -27,6 +27,10 @@ import xml.etree.ElementTree as ET
 import blenderbim.tool as tool
 import ifcopenshell.util.geolocation
 from xml.dom import minidom
+from mathutils import Vector
+
+VIEW_TITLE_OFFSET_Y = 5
+DEFAULT_POSITION = Vector((30, 30))
 
 
 class SheetBuilder:
@@ -99,25 +103,69 @@ class SheetBuilder:
         view_width = self.convert_to_mm(view_root.attrib.get("width"))
         view_height = self.convert_to_mm(view_root.attrib.get("height"))
 
+        # add background
         if os.path.isfile(underlay_path):
             background = ET.SubElement(view, "image")
             background.attrib["data-type"] = "background"
             background.attrib["xlink:href"] = os.path.relpath(underlay_path, layout_dir)
-            background.attrib["x"] = "30"
-            background.attrib["y"] = "30"
+            background.attrib["x"] = str(DEFAULT_POSITION.x)
+            background.attrib["y"] = str(DEFAULT_POSITION.y)
             background.attrib["width"] = str(view_width)
             background.attrib["height"] = str(view_height)
 
+        # add foreground
         if os.path.isfile(drawing_path):
             foreground = ET.SubElement(view, "image")
             foreground.attrib["data-type"] = "foreground"
             foreground.attrib["xlink:href"] = os.path.relpath(drawing_path, layout_dir)
-            foreground.attrib["x"] = "30"
-            foreground.attrib["y"] = "30"
+            foreground.attrib["x"] = str(DEFAULT_POSITION.x)
+            foreground.attrib["y"] = str(DEFAULT_POSITION.y)
             foreground.attrib["width"] = str(view_width)
             foreground.attrib["height"] = str(view_height)
 
-        self.add_view_title(30, view_height + 35, view, layout_dir)
+        self.add_view_title(
+            DEFAULT_POSITION.x, view_height + DEFAULT_POSITION.y + VIEW_TITLE_OFFSET_Y, view, layout_dir
+        )
+        layout_tree.write(layout_path)
+
+    def update_sheet_drawing_sizes(self, sheet):
+        ET.register_namespace("", "http://www.w3.org/2000/svg")
+        SVG = "{http://www.w3.org/2000/svg}"
+
+        layout_path = tool.Drawing.get_document_uri(sheet, "LAYOUT")
+        layout_tree = ET.parse(layout_path)
+        layout_root = layout_tree.getroot()
+        ifc_file = tool.Ifc.get()
+
+        # iterate over all drawings in the sheet
+        drawings_views = layout_root.findall(f'{SVG}g[@data-type="drawing"]')
+
+        for drawing_view in drawings_views:
+            # find drawing in ifc file to get the drawing dimensions
+            drawing = ifc_file.by_guid(drawing_view.attrib.get("data-drawing"))
+            drawing_path = tool.Drawing.get_document_uri(tool.Drawing.get_drawing_reference(drawing))
+            drawing_tree = ET.parse(drawing_path)
+            drawing_root = drawing_tree.getroot()
+            view_width = self.convert_to_mm(drawing_root.attrib.get("width"))
+            view_height = self.convert_to_mm(drawing_root.attrib.get("height"))
+
+            foreground = drawing_view.find(f'.//{SVG}image[@data-type="foreground"]')
+            height = float(foreground.attrib["height"])
+            width = float(foreground.attrib["width"])
+            readjust = Vector((width - view_width, height - view_height)) / 2
+
+            for image in drawing_view.findall(f"{SVG}image"):
+                x = float(image.attrib["x"])
+                y = float(image.attrib["y"])
+                if image.attrib["data-type"] == "view-title":
+                    image.attrib["x"] = str(x - readjust.x)
+                    image.attrib["y"] = str(y - readjust.y)
+                else:
+                    image.attrib["x"] = str(x + readjust.x)
+                    image.attrib["y"] = str(y + readjust.y)
+                    image.attrib["width"] = str(view_width)
+                    image.attrib["height"] = str(view_height)
+
         layout_tree.write(layout_path)
 
     def remove_drawing(self, reference, sheet):
@@ -161,12 +209,14 @@ class SheetBuilder:
         foreground = ET.SubElement(view, "image")
         foreground.attrib["data-type"] = "table"
         foreground.attrib["xlink:href"] = os.path.relpath(view_path, layout_dir)
-        foreground.attrib["x"] = "30"
-        foreground.attrib["y"] = "30"
+        foreground.attrib["x"] = str(DEFAULT_POSITION.x)
+        foreground.attrib["y"] = str(DEFAULT_POSITION.y)
         foreground.attrib["width"] = str(view_width)
         foreground.attrib["height"] = str(view_height)
 
-        self.add_view_title(30, view_height + 35, view, layout_dir)
+        self.add_view_title(
+            DEFAULT_POSITION.x, view_height + DEFAULT_POSITION.y + VIEW_TITLE_OFFSET_Y, view, layout_dir
+        )
         layout_tree.write(layout_path)
 
     def add_view_title(self, x, y, parent, layout_dir):

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

@@ -225,17 +225,24 @@ class SvgWriter:
                 )
             )
             # TODO: allow metric to be configurable
-            rl = (matrix_world @ points[0].co.xyz).z
+            rl_value = (matrix_world @ points[0].co.xyz).z
             if bpy.context.scene.unit_settings.system == "IMPERIAL":
-                rl = helper.format_distance(rl, precision=self.precision, decimal_places=self.decimal_places)
+                rl = helper.format_distance(rl_value, precision=self.precision, decimal_places=self.decimal_places)
             else:
                 unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-                rl /= unit_scale
+                rl = rl_value / unit_scale
                 rl = ifcopenshell.util.geolocation.auto_z2e(tool.Ifc.get(), rl)
                 rl *= unit_scale
                 rl = "{:.3f}m".format(rl)
-            text_style = self.get_box_alignment_parameters("bottom-left")
-            self.svg.add(self.svg.text(f"RL +{rl}", insert=tuple(text_position), class_="SECTIONLEVEL", **text_style))
+            text_style = SvgWriter.get_box_alignment_parameters("bottom-left")
+            self.svg.add(
+                self.svg.text(
+                    "RL {}{}".format("" if rl_value < 0 else "+", rl),
+                    insert=tuple(text_position),
+                    class_="SECTIONLEVEL",
+                    **text_style,
+                )
+            )
             if tag:
                 self.svg.add(self.svg.text(tag, insert=(text_position[0], text_position[1] - 5), **text_style))
 
@@ -263,7 +270,7 @@ class SvgWriter:
                     "UP",
                     insert=tuple(text_position),
                     class_="STAIR",
-                    **self.get_box_alignment_parameters("center"),
+                    **SvgWriter.get_box_alignment_parameters("center"),
                 )
             )
 
@@ -287,7 +294,7 @@ class SvgWriter:
             )
             line["stroke-dasharray"] = "12.5, 3, 3, 3"
             axis_tag = tool.Ifc.get_entity(obj).Name
-            text_style = self.get_box_alignment_parameters("center")
+            text_style = SvgWriter.get_box_alignment_parameters("center")
             self.svg.add(
                 self.svg.text(
                     axis_tag,
@@ -396,8 +403,7 @@ class SvgWriter:
                 self.svg.line(start=start * self.svg_scale, end=end * self.svg_scale, class_=" ".join(classes))
             )
 
-        # BATTING ANNOTATIONS
-        if predefined_type == "BATTING":
+        def draw_batting_annotation():
             v0_global = matrix_world @ obj.data.vertices[0].co.xyz
             v1_global = matrix_world @ obj.data.vertices[1].co.xyz
             v0 = self.project_point_onto_camera(v0_global)
@@ -463,7 +469,94 @@ class SvgWriter:
             )
             self.svg.add(self.svg.polyline(points=points, class_=" ".join(classes), style=polyline_style))
 
-        elif predefined_type == "SECTION":
+        def draw_revision_cloud_annotation():
+            segment_width = 15.0
+            base_height = 1
+            width = 5
+
+            def get_svg_half_circle(height, width):
+                cp0 = f"0,-{height}"
+                cp1 = f"{width},-{height}"
+                end_point = f"{width},0"
+                circle = f"c{cp0} {cp1} {end_point}"
+                return circle
+
+            def get_revision_pattern(base_offset):
+                pattern = f"m{base_offset.x},{base_offset.y}"
+                pattern += " " + get_svg_half_circle(2 * base_height, width)
+                pattern += " " + get_svg_half_circle(2.5 * base_height, width)
+                pattern += " " + get_svg_half_circle(1.5 * base_height, width)
+                return pattern
+
+            def get_scale(size, direction):
+                vector = direction * size
+                shrinked_vector = size // segment_width * segment_width * direction
+                scale = [1 if vector[i] == 0 else vector[i] / shrinked_vector[i] for i in range(2)]
+                return "scale(%f, %f)" % (scale[0], scale[1])
+
+            def poly_to_edges(poly):
+                edges = []
+                n_verts = len(poly)
+                lats_index = n_verts - 1
+                for i in range(len(poly)):
+                    edge = [poly[i], (poly[i + 1]) if i != lats_index else poly[0]]
+                    edges.append(edge)
+                return edges
+
+            element = tool.Ifc.get_entity(obj)
+            safe_offset_x = 2.0
+            marker_width = segment_width + safe_offset_x * 2
+            market_height = 15.0
+            ref_y = 5.0
+            revision_pattern = get_revision_pattern(Vector([safe_offset_x, ref_y]))
+
+            bm = tool.Blender.get_bmesh_for_mesh(obj.data).copy()
+            bmesh.ops.contextual_create(bm, geom=bm.edges[:])
+            faces = bm.faces[:]
+            assert len(faces) == 1, "Revision cloud edges must form just 1 polygon"
+
+            # ensure clockwise order of polygon verts
+            # given default blender counter-clockwise order
+            polygon = faces[0]
+            if polygon.normal.z > 0:
+                polygon.normal_flip()
+
+            marker_id = f"revision-cloud-{element.GlobalId}"
+            svg_path = self.svg.path(style="fill: none; stroke:red; stroke-width:0.20", d=revision_pattern)
+            marker = self.svg.marker(
+                markerUnits="userSpaceOnUse",
+                insert=(safe_offset_x, ref_y),
+                size=(marker_width, market_height),
+                orient="auto",
+                id=marker_id,
+            )
+            marker.add(svg_path)
+            self.svg.add(marker)
+
+            for v0, v1 in poly_to_edges(polygon.verts):
+                v0_global = matrix_world @ v0.co.xyz
+                v1_global = matrix_world @ v1.co.xyz
+                v0 = self.project_point_onto_camera(v0_global)
+                v1 = self.project_point_onto_camera(v1_global)
+                start_svg = Vector(((x_offset + v0.x), (y_offset - v0.y))) * self.svg_scale
+                end_svg = Vector(((x_offset + v1.x), (y_offset - v1.y))) * self.svg_scale
+
+                pattern_edge = end_svg - start_svg
+                pattern_dir = pattern_edge.normalized()
+                pattern_length = pattern_edge.length
+
+                segments = int(pattern_length // segment_width)
+                pattern_dir_step = pattern_dir * segment_width
+                points = [pattern_dir_step * i for i in range(segments)]
+
+                polyline_style = f"marker: url(#{marker_id}); stroke: none;"
+                polyline_transform = f"translate({start_svg.x}, {start_svg.y}) {get_scale(pattern_length, pattern_dir)}"
+                polyline = self.svg.polyline(
+                    points=points, class_=" ".join(classes), style=polyline_style, transform=polyline_transform
+                )
+                self.svg.add(polyline)
+
+        def draw_section_annotation():
             display_data = DecoratorData.get_section_markers_display_data(obj)
             connect_markers = display_data["connect_markers"]
 
@@ -504,6 +597,12 @@ class SvgWriter:
                             )
                         )
 
+        if predefined_type == "BATTING":
+            draw_batting_annotation()
+        elif predefined_type == "REVISIONCLOUD":
+            draw_revision_cloud_annotation()
+        elif predefined_type == "SECTION":
+            draw_section_annotation()
         else:
             for edge in obj.data.edges:
                 draw_simple_edge_annotation(*edge.vertices[:])
@@ -557,7 +656,7 @@ class SvgWriter:
 
                     reference_id, sheet_id = self.get_reference_and_sheet_id_from_annotation(tool.Ifc.get_entity(obj))
                     text_position = symbol_position_svg
-                    text_style = self.get_box_alignment_parameters("center")
+                    text_style = SvgWriter.get_box_alignment_parameters("center")
                     self.svg.add(
                         self.svg.text(
                             reference_id,
@@ -590,7 +689,7 @@ class SvgWriter:
 
         reference_id, sheet_id = self.get_reference_and_sheet_id_from_annotation(tool.Ifc.get_entity(obj))
         text_position = symbol_position_svg
-        text_style = self.get_box_alignment_parameters("center")
+        text_style = SvgWriter.get_box_alignment_parameters("center")
         self.svg.add(
             self.svg.text(
                 reference_id, insert=(text_position[0], text_position[1] - 2.5), class_="ELEVATION", **text_style
@@ -617,7 +716,8 @@ class SvgWriter:
                 return (reference_id, sheet_id)
         return ("-", "-")
 
-    def get_box_alignment_parameters(self, box_alignment):
+    @staticmethod
+    def get_box_alignment_parameters(box_alignment):
         """Convenience method to get svg parameters for text alignment
         in a readable way.
 
@@ -664,6 +764,7 @@ class SvgWriter:
         text_position = self.project_point_onto_camera(position)
         text_position = Vector(((x_offset + text_position.x), (y_offset - text_position.y)))
         text_position_svg = text_position * self.svg_scale
+        text_position_svg_str = ", ".join(map(str, text_position_svg))
 
         def get_basis_vector(matrix, i=0):
             """returns basis vector for i in world space, unaffected by object scale"""
@@ -673,13 +774,18 @@ class SvgWriter:
         text_dir = (self.camera.matrix_world.inverted().to_quaternion() @ text_dir_world_x_axis).to_2d().normalized()
         angle = math.degrees(-text_dir.angle_signed(Vector((1, 0))))
 
-        transform = "rotate({}, {}, {})".format(angle, *text_position_svg)
         classes = self.get_attribute_classes(text_obj)
         classes_str = " ".join(classes)
 
         symbol = tool.Drawing.get_annotation_symbol(element)
         template_text_fields = []
-        if symbol:
+        if not symbol:
+            text_transform = f"translate({text_position_svg_str}) rotate({angle})"
+        else:
+            # NOTE: for now we assume that scale is uniform
+            symbol_transform = f"translate({text_position_svg_str}) rotate({angle}) scale({text_obj.scale.x})"
+            text_transform = symbol_transform
+
             symbol_svg = self.find_xml_symbol_by_id(symbol)
             if symbol_svg:
                 symbol_xml = symbol_svg.get_xml()
@@ -687,7 +793,7 @@ class SvgWriter:
                 # if there is a symbol with template text fields
                 # then we just populate it's fields with the data from text literals
                 if template_text_fields:
-                    symbol_xml.attrib["transform"] = f"translate({', '.join(map(str, text_position_svg))})"
+                    symbol_xml.attrib["transform"] = symbol_transform
                     symbol_xml.attrib.pop("id")
                     # note: zip makes sure that we iterate over the shortest list
                     for field, text_literal in zip(template_text_fields, text_literals):
@@ -697,7 +803,7 @@ class SvgWriter:
                     return None
 
             if not symbol_svg or not template_text_fields:
-                self.svg.add(self.svg.use(f"#{symbol}", insert=text_position_svg))
+                self.svg.add(self.svg.use(f"#{symbol}", transform=symbol_transform))
 
         for text_literal in text_literals:
             # after pretty indentation some redundant spaces can occur in svg tags
@@ -707,7 +813,7 @@ class SvgWriter:
 
             text = tool.Drawing.replace_text_literal_variables(text_literal.Literal, product)
             attribs = {
-                "transform": transform,
+                "transform": text_transform,
                 "style": "font-size: 0;",
             }
 
@@ -715,7 +821,7 @@ class SvgWriter:
                 text_tag = self.svg.text(
                     "",
                     **(attribs | {"filter": "url(#fill-background)"}) if add_fill_bg else attribs,
-                    **self.get_box_alignment_parameters(text_literal.BoxAlignment),
+                    **SvgWriter.get_box_alignment_parameters(text_literal.BoxAlignment),
                 )
                 self.svg.add(text_tag)
 
@@ -723,7 +829,9 @@ class SvgWriter:
 
                 for line_number, text_line in enumerate(text_lines):
                     # position has to be inserted at tspan to avoid x offset between tspans
-                    tspan = self.svg.tspan(text_line, class_=classes_str, insert=text_position_svg)
+                    # note that tspan doesn't support using `transform` attribute
+                    # so we use (0,0) position because tspan is already offseted by text transform
+                    tspan = self.svg.tspan(text_line, class_=classes_str, insert=(0, 0))
                     # doing it here and not in tspan constructor because constructor adds unnecessary spaces
                     tspan.update({"dy": f"{line_number}em"})
                     text_tag.add(tspan)
@@ -732,7 +840,6 @@ class SvgWriter:
                 add_text_tag(True)
             add_text_tag(False)
 
-
     def draw_break_annotations(self, obj):
         x_offset = self.raw_width / 2
         y_offset = self.raw_height / 2
@@ -779,21 +886,21 @@ class SvgWriter:
                 )
             )
             # TODO: allow metric to be configurable
-            rl = (matrix_world @ points[0].co).z
+            rl_value = (matrix_world @ points[0].co).z
             if bpy.context.scene.unit_settings.system == "IMPERIAL":
-                rl = helper.format_distance(rl, precision=self.precision, decimal_places=self.decimal_places)
+                rl = helper.format_distance(rl_value, precision=self.precision, decimal_places=self.decimal_places)
             else:
                 unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-                rl /= unit_scale
+                rl = rl_value / unit_scale
                 rl = ifcopenshell.util.geolocation.auto_z2e(tool.Ifc.get(), rl)
                 rl *= unit_scale
                 rl = "{:.3f}m".format(rl)
 
             box_alignment = "bottom-left" if projected_points[0].x <= projected_points[-1].x else "bottom-right"
-            text_style = self.get_box_alignment_parameters(box_alignment)
+            text_style = SvgWriter.get_box_alignment_parameters(box_alignment)
             self.svg.add(
                 self.svg.text(
-                    "RL +{}".format(rl),
+                    "RL {}{}".format("" if rl_value < 0 else "+", rl),
                     insert=tuple(text_position),
                     class_="PLANLEVEL",
                     **text_style,
@@ -912,7 +1019,7 @@ class SvgWriter:
         text_offset = (text_position - center_position).xy.normalized() * 5
         text_position += text_offset
 
-        text_style = self.get_box_alignment_parameters("center")
+        text_style = SvgWriter.get_box_alignment_parameters("center")
         angle_text = abs(round(math.degrees(angle), 3))
         if is_reflex:
             angle_text = 360 - angle_text
@@ -973,7 +1080,7 @@ class SvgWriter:
             )
             text_position += text_offset
 
-            text_style = self.get_box_alignment_parameters("center")
+            text_style = SvgWriter.get_box_alignment_parameters("center")
             radius = (points[-1].co - points[-2].co).length
             radius = helper.format_distance(radius, precision=self.precision, decimal_places=self.decimal_places)
             tag = element.Description or f"R{radius}"
@@ -1046,7 +1153,7 @@ class SvgWriter:
             )
             text_position += text_offset
 
-            text_style = self.get_box_alignment_parameters("center")
+            text_style = SvgWriter.get_box_alignment_parameters("center")
             self.svg.add(self.svg.text(tag, insert=tuple(text_position), class_="RADIUS", **text_style))
 
     def draw_diameter_annotations(self, obj):
@@ -1071,6 +1178,8 @@ class SvgWriter:
                     text_format=lambda x: "D" + x,
                     show_description_only=dimension_data["show_description_only"],
                     suppress_zero_inches=dimension_data["suppress_zero_inches"],
+                    text_prefix=dimension_data["text_prefix"],
+                    text_suffix=dimension_data["text_suffix"],
                 )
 
     def draw_dimension_annotations(self, obj):
@@ -1092,6 +1201,8 @@ class SvgWriter:
                     dimension_text=dimension_text,
                     show_description_only=dimension_data["show_description_only"],
                     suppress_zero_inches=dimension_data["suppress_zero_inches"],
+                    text_prefix=dimension_data["text_prefix"],
+                    text_suffix=dimension_data["text_suffix"],
                 )
 
     def draw_measureit_arch_dimension_annotations(self):
@@ -1115,6 +1226,8 @@ class SvgWriter:
         text_format=lambda x: x,
         show_description_only=False,
         suppress_zero_inches=False,
+        text_prefix="",
+        text_suffix="",
     ):
         offset = Vector([self.raw_width, self.raw_height]) / 2
         v0 = self.project_point_onto_camera(v0_global)
@@ -1135,27 +1248,86 @@ class SvgWriter:
 
         # if annotation can't fit offset text to the right of marker
         text_position = mid if sheet_dimension > 5 else (end + (3 * vector.normalized()))
-        rotation = math.degrees(vector.angle_signed(Vector((1, 0))))
+        angle = math.degrees(vector.angle_signed(Vector((1, 0))))
 
         line = self.svg.line(start=start, end=end, class_=" ".join(classes))
         self.svg.add(line)
 
-        def create_text_tag(text, text_position, box_alignment):
-            text_kwargs = {"transform": "rotate({} {} {})".format(rotation, text_position.x, text_position.y)}
+        if not show_description_only:
+            text = f"{text_prefix}{str(dimension)}{text_suffix}"
+            text_tag = self.create_text_tag(
+                text,
+                text_position + perpendicular,
+                angle,
+                "bottom-middle",
+                "DIMENSION",
+                text_format=text_format,
+                multiline=True,
+                multiline_to_bottom=False,
+            )
+            self.svg.add(text_tag)
+            if dimension_text:
+                text_tag = self.create_text_tag(
+                    dimension_text,
+                    text_position - perpendicular,
+                    angle,
+                    "top-middle",
+                    "DIMENSION",
+                    text_format=text_format,
+                    multiline=True,
+                    multiline_to_bottom=True,
+                )
+                self.svg.add(text_tag)
+
+        elif show_description_only and dimension_text:
+            text_tag = self.create_text_tag(
+                dimension_text,
+                text_position + perpendicular,
+                angle,
+                "bottom-middle",
+                "DIMENSION",
+                text_format=text_format,
+                multiline=True,
+                multiline_to_bottom=False,
+            )
+            self.svg.add(text_tag)
+
+    def create_text_tag(
+        self,
+        text,
+        text_position,
+        angle,
+        box_alignment,
+        class_str,
+        text_format=lambda x: x,
+        multiline=False,
+        multiline_to_bottom=False,
+    ):
+        if not multiline:
+            text_kwargs = {"transform": "rotate({} {} {})".format(angle, text_position.x, text_position.y)}
             return self.svg.text(
                 text_format(text),
                 insert=text_position,
-                class_="DIMENSION",
-                **(text_kwargs | self.get_box_alignment_parameters(box_alignment)),
+                class_=class_str,
+                **(text_kwargs | SvgWriter.get_box_alignment_parameters(box_alignment)),
             )
 
-        if not show_description_only:
-            self.svg.add(create_text_tag(str(dimension), text_position + perpendicular, "bottom-middle"))
-            if dimension_text:
-                self.svg.add(create_text_tag(dimension_text, text_position - perpendicular, "top-middle"))
+        text_position_svg_str = ", ".join(map(str, text_position))
+        text_transform = f"translate({text_position_svg_str}) rotate({angle})"
+        text_kwargs = {
+            "transform": text_transform,
+            "style": "font-size: 0;",
+        }
 
-        elif show_description_only and dimension_text:
-            self.svg.add(create_text_tag(dimension_text, text_position + perpendicular, "bottom-middle"))
+        text_tag = self.svg.text("", **text_kwargs, **SvgWriter.get_box_alignment_parameters(box_alignment))
+        text_lines = text.replace("\\n", "\n").split("\n")
+        text_lines = text_lines if multiline_to_bottom else text_lines[::-1]
+
+        for line_number, text_line in enumerate(text_lines):
+            tspan = self.svg.tspan(text_format(text_line), class_=class_str, insert=(0, 0))
+            tspan.update({"dy": f"{line_number if multiline_to_bottom else -line_number}em"})
+            text_tag.add(tspan)
+        return text_tag
 
     def project_point_onto_camera(self, point):
         # TODO is this needlessly complex?

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

@@ -27,6 +27,7 @@ from blenderbim.bim.module.drawing.data import (
     DrawingsData,
     DecoratorData,
 )
+from blenderbim.bim.module.drawing.prop import ANNOTATION_TYPES_DATA
 
 
 class BIM_PT_camera(Panel):
@@ -84,8 +85,14 @@ class BIM_PT_camera(Panel):
         row = layout.row()
         row.prop(props, "diagram_scale")
         if props.diagram_scale == "CUSTOM":
-            row = layout.row()
-            row.prop(props, "custom_diagram_scale")
+            row = layout.row(align=True)
+            row.prop(props, "custom_diagram_scale_input1", text="Custom Scale")
+            if context.scene.unit_settings.system == "IMPERIAL":
+                separator = "         ="
+            else:
+                separator = "         :"
+            row.label(text=separator)
+            row.prop(props, "custom_diagram_scale_input2", text="")
 
         row = layout.row(align=True)
         row.operator("bim.create_drawing", text="Create Drawing", icon="OUTPUT")
@@ -111,38 +118,53 @@ class BIM_PT_drawing_underlay(Panel):
         layout.use_property_split = True
         dprops = context.scene.DocProperties
         props = context.active_object.data.BIMCameraProperties
+        drawing_index_is_valid = props.active_drawing_style_index < len(dprops.drawing_styles)
+
+        if not DrawingsData.is_loaded:
+            DrawingsData.load()
+        drawing_pset_data = DrawingsData.data["active_drawing_pset_data"]
 
         row = layout.row(align=True)
-        row.operator("bim.add_drawing_style")
+        current_shading_style = drawing_pset_data.get("CurrentShadingStyle", None)
+        if current_shading_style is None:
+            row.label(text="Current style is not set.")
+        else:
+            row.label(text="Current Shading Style:")
+            row.label(text=current_shading_style)
+        row.operator("bim.add_drawing_style", icon="ADD", text="")
+        if drawing_index_is_valid:
+            row.operator("bim.remove_drawing_style", icon="X", text="").index = props.active_drawing_style_index
+        row.operator("bim.reload_drawing_styles", icon="FILE_REFRESH", text="")
 
-        if dprops.drawing_styles:
-            layout.template_list("BIM_UL_generic", "", dprops, "drawing_styles", props, "active_drawing_style_index")
+        if not dprops.drawing_styles:
+            return
+        layout.template_list("BIM_UL_generic", "", dprops, "drawing_styles", props, "active_drawing_style_index")
 
-            if props.active_drawing_style_index < len(dprops.drawing_styles):
-                drawing_style = dprops.drawing_styles[props.active_drawing_style_index]
+        if not drawing_index_is_valid:
+            return
+        drawing_style = dprops.drawing_styles[props.active_drawing_style_index]
 
-                row = layout.row(align=True)
-                row.prop(drawing_style, "name")
-                row.operator("bim.remove_drawing_style", icon="X", text="").index = props.active_drawing_style_index
+        row = layout.row(align=True)
+        row.prop(drawing_style, "name")
 
-                row = layout.row()
-                row.prop(drawing_style, "render_type")
-                row = layout.row(align=True)
-                row.prop(drawing_style, "include_query")
-                row = layout.row(align=True)
-                row.prop(drawing_style, "exclude_query")
+        row = layout.row()
+        row.prop(drawing_style, "render_type")
+        row = layout.row(align=True)
+        row.prop(drawing_style, "include_query")
+        row = layout.row(align=True)
+        row.prop(drawing_style, "exclude_query")
 
-                row = layout.row()
-                row.operator("bim.add_drawing_style_attribute")
+        row = layout.row()
+        row.operator("bim.add_drawing_style_attribute")
 
-                for index, attribute in enumerate(drawing_style.attributes):
-                    row = layout.row(align=True)
-                    row.prop(attribute, "name", text="")
-                    row.operator("bim.remove_drawing_style_attribute", icon="X", text="").index = index
+        for index, attribute in enumerate(drawing_style.attributes):
+            row = layout.row(align=True)
+            row.prop(attribute, "name", text="")
+            row.operator("bim.remove_drawing_style_attribute", icon="X", text="").index = index
 
-                row = layout.row(align=True)
-                row.operator("bim.save_drawing_style")
-                row.operator("bim.activate_drawing_style")
+        row = layout.row(align=True)
+        row.operator("bim.save_drawing_style")
+        row.operator("bim.activate_drawing_style")
 
 
 class BIM_PT_drawings(Panel):
@@ -450,55 +472,55 @@ class BIM_PT_annotation_utilities(Panel):
         row = layout.row(align=True)
         op = row.operator("bim.add_annotation", text="Dimension", icon="FIXED_SIZE")
         op.object_type = "DIMENSION"
-        op.data_type = "curve"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
         op = row.operator("bim.add_annotation", text="Angle", icon="DRIVER_ROTATIONAL_DIFFERENCE")
         op.object_type = "ANGLE"
-        op.data_type = "curve"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
 
         row = layout.row(align=True)
         op = row.operator("bim.add_annotation", text="Radius", icon="FORWARD")
         op.object_type = "RADIUS"
-        op.data_type = "curve"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
         op = row.operator("bim.add_annotation", text="Diameter", icon="ARROW_LEFTRIGHT")
         op.object_type = "DIAMETER"
-        op.data_type = "curve"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
 
         row = layout.row(align=True)
         op = row.operator("bim.add_annotation", text="Text", icon="SMALL_CAPS")
         op.object_type = "TEXT"
-        op.data_type = "empty"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
         op = row.operator("bim.add_annotation", text="Leader", icon="TRACKING_BACKWARDS")
         op.object_type = "TEXT_LEADER"
-        op.data_type = "curve"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
 
         row = layout.row(align=True)
         op = row.operator("bim.add_annotation", text="Stair Arrow", icon="SCREEN_BACK")
         op.object_type = "STAIR_ARROW"
-        op.data_type = "curve"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
         op = row.operator("bim.add_annotation", text="Hidden", icon="CON_TRACKTO")
         op.object_type = "HIDDEN_LINE"
-        op.data_type = "mesh"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
 
         row = layout.row(align=True)
         op = row.operator("bim.add_annotation", text="Level (Plan)", icon="SORTBYEXT")
         op.object_type = "PLAN_LEVEL"
-        op.data_type = "curve"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
         op = row.operator("bim.add_annotation", text="Level (Section)", icon="TRIA_DOWN")
         op.object_type = "SECTION_LEVEL"
-        op.data_type = "curve"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
 
         row = layout.row(align=True)
         op = row.operator("bim.add_annotation", text="Breakline", icon="FCURVE")
         op.object_type = "BREAKLINE"
-        op.data_type = "mesh"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
         op = row.operator("bim.add_annotation", text="Line", icon="MESH_MONKEY")
         op.object_type = "LINEWORK"
-        op.data_type = "mesh"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
 
         row = layout.row(align=True)
         op = row.operator("bim.add_annotation", text="Batting", icon="FORCE_FORCE")
         op.object_type = "BATTING"
-        op.data_type = "mesh"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
         op.description = "Add batting annotation.\nThickness could be changed through Thickness property of BBIM_Batting property set"
         op = row.operator("bim.add_annotation", text="Fill Area", icon="NODE_TEXTURE")
         op.object_type = "FILL_AREA"
@@ -506,7 +528,10 @@ class BIM_PT_annotation_utilities(Panel):
         row = layout.row(align=True)
         op = row.operator("bim.add_annotation", text="Fall", icon="SORT_ASC")
         op.object_type = "FALL"
-        op.data_type = "curve"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
+        op = row.operator("bim.add_annotation", text="Revision", icon="VOLUME_DATA")
+        op.object_type = "REVISION_CLOUD"
+        op.data_type = tool.Drawing.get_annotation_data_type(op.object_type)
 
         row = layout.row(align=True)
         row.prop(self.props, "should_draw_decorations", text="Viewport Annotations")

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

@@ -108,7 +108,7 @@ def create_annotation_type(context):
     tool.Drawing.ensure_annotation_in_drawing_plane(obj)
 
     drawing = tool.Ifc.get_entity(context.scene.camera)
-    ifc_context = tool.Drawing.get_annotation_context(tool.Drawing.get_drawing_target_view(drawing))
+    ifc_context = tool.Drawing.get_annotation_context(tool.Drawing.get_drawing_target_view(drawing), object_type)
 
     element = tool.Drawing.run_root_assign_class(
         obj=obj,
@@ -133,7 +133,7 @@ def create_annotation_occurence(context):
     drawing = tool.Ifc.get_entity(context.scene.camera)
     obj = tool.Drawing.create_annotation_object(drawing, object_type)
     obj.name = relating_type.Name
-    ifc_context = tool.Drawing.get_annotation_context(tool.Drawing.get_drawing_target_view(drawing))
+    ifc_context = tool.Drawing.get_annotation_context(tool.Drawing.get_drawing_target_view(drawing), object_type)
     relating_type_repr = tool.Drawing.get_annotation_representation(relating_type)
     element = tool.Drawing.run_root_assign_class(
         obj=obj,
@@ -179,8 +179,7 @@ class AnnotationToolUI:
 
         if context.active_object and context.selected_objects:
             cls.draw_edit_object_interface(context)
-        elif not context.selected_objects:
-            cls.draw_create_object_interface()
+        cls.draw_create_object_interface()
 
     @classmethod
     def draw_create_object_interface(cls):

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

@@ -38,7 +38,7 @@ class Helper:
         bm = bmesh.new()
         bm.from_mesh(mesh)
         bmesh.ops.dissolve_limit(bm, angle_limit=pi / 180 * 1, verts=bm.verts, edges=bm.edges)
-        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.001)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
 
         bm.faces.ensure_lookup_table()
         face = None
@@ -62,7 +62,7 @@ class Helper:
         bm = bmesh.new()
         bm.from_mesh(mesh)
         bmesh.ops.dissolve_limit(bm, angle_limit=pi / 180 * 1, verts=bm.verts, edges=bm.edges)
-        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.001)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
 
         bm.faces.ensure_lookup_table()
         potential_faces = []
@@ -90,7 +90,7 @@ class Helper:
         bm = bmesh.new()
         bm.from_mesh(mesh)
         bmesh.ops.dissolve_limit(bm, angle_limit=pi / 180 * 1, verts=bm.verts, edges=bm.edges)
-        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.001)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
 
         bm.faces.ensure_lookup_table()
         potential_faces = []
@@ -292,7 +292,7 @@ class Helper:
         bm = bmesh.new()
         bm.from_mesh(mesh)
         bmesh.ops.dissolve_limit(bm, angle_limit=pi / 180 * 1, verts=bm.verts, edges=bm.edges)
-        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.001)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
 
         bm.faces.ensure_lookup_table()
         potential_faces = []
@@ -389,7 +389,7 @@ class Helper:
         bm = bmesh.new()
         bm.from_mesh(mesh)
         bmesh.ops.dissolve_limit(bm, angle_limit=pi / 180 * 1, verts=bm.verts, edges=bm.edges)
-        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.001)
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=0.0001)
 
         bm.faces.ensure_lookup_table()
         faces = bm.faces

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

@@ -199,6 +199,13 @@ class UpdateRepresentation(bpy.types.Operator, Operator):
         old_representation = self.file.by_id(obj.data.BIMMeshProperties.ifc_definition_id)
         context_of_items = old_representation.ContextOfItems
 
+        # TODO: remove this code a bit later
+        # added this as a fallback for easier transition some annotation types to 3d
+        # if they were create before as 2d
+        element = tool.Ifc.get_entity(obj)
+        if tool.Drawing.is_annotation_object_type(element, ("FALL", "SECTION_LEVEL", "PLAN_LEVEL")):
+            context_of_items = tool.Drawing.get_annotation_context("MODEL_VIEW")
+
         gprop = context.scene.BIMGeoreferenceProperties
         coordinate_offset = None
         if gprop.has_blender_offset and obj.BIMObjectProperties.blender_offset_type == "CARTESIAN_POINT":
@@ -527,6 +534,8 @@ class OverrideDuplicateMove(bpy.types.Operator):
                     array_pset = tool.Ifc.get().by_id(array_pset["id"])
                     ifcopenshell.api.run("pset.remove_pset", tool.Ifc.get(), product=new, pset=array_pset)
                 old_to_new[tool.Ifc.get_entity(obj)] = [new]
+                if new.is_a("IfcRelSpaceBoundary"):
+                    tool.Boundary.decorate_boundary(new_obj)
         # Recreate decompositions
         tool.Root.recreate_decompositions(relationships, old_to_new)
         blenderbim.bim.handler.purge_module_data()
@@ -720,6 +729,11 @@ class OverrideModeSetEdit(bpy.types.Operator):
 
         if context.active_object:
             context.active_object.select_set(True)
+
+            element = tool.Ifc.get_entity(context.active_object)
+            if element and element.is_a("IfcRelSpaceBoundary"):
+                return bpy.ops.bim.enable_editing_boundary_geometry()
+
         for obj in objs:
             if not obj:
                 continue
@@ -834,6 +848,11 @@ class OverrideModeSetObject(bpy.types.Operator):
         if not tool.Ifc.get():
             return {"FINISHED"}
 
+        if context.active_object:
+            element = tool.Ifc.get_entity(context.active_object)
+            if element and element.is_a("IfcRelSpaceBoundary"):
+                return bpy.ops.bim.edit_boundary_geometry()
+
         objs = context.selected_objects or [context.active_object]
 
         self.edited_objs = []

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

@@ -21,14 +21,19 @@ from . import ui, prop, operator
 
 classes = (
     operator.AddFileToRepo,
+    operator.AddTag,
+    operator.CloneRepo,
     operator.CommitChanges,
     operator.CreateRepo,
     operator.DiscardUncommitted,
     operator.DisplayRevision,
     operator.DisplayUncommitted,
+    operator.Fetch,
     operator.Merge,
+    operator.Push,
     operator.RefreshGit,
     operator.SwitchRevision,
+    prop.IfcGitTag,
     prop.IfcGitListItem,
     prop.IfcGitProperties,
     ui.IFCGIT_PT_panel,

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

@@ -19,7 +19,10 @@ class IfcGitData:
     def load(cls):
         cls.data = {
             "repo": cls.repo(),
+            "remotes": cls.remotes(),
             "branch_names": cls.branch_names(),
+            "remote_names": cls.remote_names(),
+            "remote_urls": cls.remote_urls(),
             "path_ifc": cls.path_ifc(),
             "branches_by_hexsha": cls.branches_by_hexsha(),
             "tags_by_hexsha": cls.tags_by_hexsha(),
@@ -42,10 +45,28 @@ class IfcGitData:
                 return tool.IfcGit.repo_from_path(path_ifc)
         return None
 
+    @classmethod
+    def remotes(cls):
+        if cls.repo():
+            return cls.repo().remotes
+        return None
+
     @classmethod
     def branch_names(cls):
         return []
 
+    @classmethod
+    def remote_names(cls):
+        return []
+
+    @classmethod
+    def remote_urls(cls):
+        result = {}
+        if cls.repo():
+            for remote in cls.repo().remotes:
+                result[remote.name] = remote.url
+        return result
+
     @classmethod
     def path_ifc(cls):
         path_ifc = tool.Ifc.get_path()

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

@@ -57,6 +57,33 @@ class AddFileToRepo(bpy.types.Operator):
         return {"FINISHED"}
 
 
+class CloneRepo(bpy.types.Operator):
+    """Clone a remote Git repository"""
+
+    bl_label = "Clone repository"
+    bl_idname = "ifcgit.clone_repo"
+    bl_options = {"REGISTER"}
+
+    @classmethod
+    def poll(cls, context):
+        props = context.scene.IfcGitProperties
+        if (
+            props.remote_url
+            and props.local_folder
+            and os.path.isdir(props.local_folder)
+            and not os.listdir(props.local_folder)
+        ):
+            return True
+        return False
+
+    def execute(self, context):
+
+        props = context.scene.IfcGitProperties
+        core.clone_repo(tool.IfcGit, props.remote_url, props.local_folder, self)
+        refresh()
+        return {"FINISHED"}
+
+
 class DiscardUncommitted(bpy.types.Operator):
     """Discard saved changes and update to HEAD"""
 
@@ -88,7 +115,7 @@ class CommitChanges(bpy.types.Operator):
             repo
             and repo.head.is_detached
             and (
-                not tool.is_valid_ref_format(props.new_branch_name)
+                not tool.IfcGit.is_valid_ref_format(props.new_branch_name)
                 or props.new_branch_name in [branch.name for branch in repo.branches]
             )
         ):
@@ -107,6 +134,33 @@ class CommitChanges(bpy.types.Operator):
         return {"FINISHED"}
 
 
+class AddTag(bpy.types.Operator):
+    """Tag selected revision"""
+
+    bl_label = "Tag selected revision"
+    bl_idname = "ifcgit.add_tag"
+    bl_options = {"REGISTER"}
+
+    @classmethod
+    def poll(cls, context):
+        props = context.scene.IfcGitProperties
+        repo = IfcGitData.data["repo"]
+        if repo and (
+            not tool.IfcGit.is_valid_ref_format(props.new_tag_name)
+            or props.new_tag_name in [tag.name for tag in repo.tags]
+        ):
+            return False
+        return True
+
+    def execute(self, context):
+
+        repo = IfcGitData.data["repo"]
+        core.add_tag(tool.IfcGit, repo)
+        bpy.ops.ifcgit.refresh()
+        refresh()
+        return {"FINISHED"}
+
+
 class RefreshGit(bpy.types.Operator):
     """Refresh revision list"""
 
@@ -192,3 +246,35 @@ class Merge(bpy.types.Operator):
             return {"FINISHED"}
         else:
             return {"CANCELLED"}
+
+
+class Push(bpy.types.Operator):
+    """Pushes the working branch to selected remote"""
+
+    bl_label = "Push working branch"
+    bl_idname = "ifcgit.push"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+
+        props = context.scene.IfcGitProperties
+        repo = IfcGitData.data["repo"]
+        remote = repo.remotes[props.select_remote]
+        remote.push(refspec=IfcGitData.data["repo"].active_branch.name)
+        return {"FINISHED"}
+
+
+class Fetch(bpy.types.Operator):
+    """Fetches from the selected remote"""
+
+    bl_label = "Fetch from remote"
+    bl_idname = "ifcgit.fetch"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+
+        props = context.scene.IfcGitProperties
+        repo = IfcGitData.data["repo"]
+        remote = repo.remotes[props.select_remote]
+        remote.fetch()
+        return {"FINISHED"}

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

@@ -21,9 +21,25 @@ def git_branches(self, context):
         IfcGitData.data["branch_names"].remove("main")
         IfcGitData.data["branch_names"] = ["main"] + IfcGitData.data["branch_names"]
 
+    if IfcGitData.data["remotes"]:
+        props = context.scene.IfcGitProperties
+        IfcGitData.data["branch_names"] += [r.name for r in IfcGitData.data["remotes"][props.select_remote].refs]
+
     return [(myname, myname, myname) for myname in IfcGitData.data["branch_names"]]
 
 
+def git_remotes(self, context):
+    """remotes enum"""
+
+    IfcGitData.data["remote_names"] = sorted([remote.name for remote in IfcGitData.data["remotes"]])
+
+    if "origin" in IfcGitData.data["remote_names"]:
+        IfcGitData.data["remote_names"].remove("origin")
+        IfcGitData.data["remote_names"] = ["origin"] + IfcGitData.data["remote_names"]
+
+    return [(myname, myname, myname) for myname in IfcGitData.data["remote_names"]]
+
+
 def update_revlist(self, context):
     """wrapper to trigger update of the revision list"""
 
@@ -32,6 +48,19 @@ def update_revlist(self, context):
     props.commit_index = 0
 
 
+class IfcGitTag(PropertyGroup):
+    """Properties of a Git tag"""
+
+    name: StringProperty(
+        name="Tag name",
+        default="",
+    )
+    message: StringProperty(
+        name="Tag message",
+        default="",
+    )
+
+
 class IfcGitListItem(PropertyGroup):
     """Group of properties representing an item in the list."""
 
@@ -45,6 +74,19 @@ class IfcGitListItem(PropertyGroup):
         description="does this commit reference our ifc file",
         default=False,
     )
+    author_name: StringProperty(
+        name="Author Name",
+        default="",
+    )
+    author_email: StringProperty(
+        name="Author Email",
+        default="",
+    )
+    message: StringProperty(
+        name="Commit Message",
+        default="",
+    )
+    tags: CollectionProperty(type=IfcGitTag, name="List of revision tags")
 
 
 class IfcGitProperties(PropertyGroup):
@@ -61,7 +103,29 @@ class IfcGitProperties(PropertyGroup):
         description="A short name used to refer to this branch",
         default="",
     )
+    new_tag_name: StringProperty(
+        name="New tag name",
+        description="A short name used to refer to this tag",
+        default="",
+    )
+    new_tag_message: StringProperty(
+        name="Tag message (optional)",
+        description="An optional human readable description of this tag",
+        default="",
+    )
+    remote_url: StringProperty(
+        name="Git URL",
+        description="A URL pointing to a Git repository",
+        default="",
+    )
+    local_folder: StringProperty(
+        name="Local folder",
+        description="A local Git repository path",
+        default="",
+        subtype="DIR_PATH",
+    )
     display_branch: EnumProperty(items=git_branches, update=update_revlist)
+    select_remote: EnumProperty(items=git_remotes)
     ifcgit_filter: EnumProperty(
         items=[
             ("all", "All", "All revisions"),

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

@@ -54,6 +54,16 @@ class IFCGIT_PT_panel(bpy.types.Panel):
         else:
             row.label(text="No Git repository found", icon="SYSTEM")
             row.label(text="No IFC project saved", icon="FILE")
+
+            box = layout.box()
+            row = box.row()
+            row.label(text="Clone a remote Git repository")
+            row = box.row()
+            row.prop(props, "remote_url")
+            row = box.row()
+            row.prop(props, "local_folder")
+            row = box.row()
+            row.operator("ifcgit.clone_repo", icon="IMPORT")
             return
 
         is_dirty = IfcGitData.data["is_dirty"]
@@ -119,7 +129,6 @@ class IFCGIT_PT_panel(bpy.types.Panel):
             return
 
         item = props.ifcgit_commits[props.commit_index]
-        commit = IfcGitData.data["commit"]
         if not item.relevant:
             row = layout.row()
             row.label(text="Revision unrelated to current IFC project", icon="ERROR")
@@ -127,11 +136,40 @@ class IFCGIT_PT_panel(bpy.types.Panel):
         box = layout.box()
         column = box.column(align=True)
         row = column.row()
-        row.label(text=commit.hexsha)
+        row.label(text=item.hexsha)
         row = column.row()
-        row.label(text=commit.author.name + " <" + commit.author.email + ">")
+        row.label(text=item.author_name + " <" + item.author_email + ">")
         row = column.row()
-        row.label(text=commit.message)
+        row.label(text=item.message)
+
+        for tag in item.tags:
+            box = layout.box()
+            item = box.row()
+            column = item.column(align=True)
+            row = column.row()
+            row.label(text=tag.name)
+            if tag.message:
+                row = column.row()
+                row.label(text=tag.message)
+            # TODO
+            # item.operator("ifcgit.delete_tag", icon="PANEL_CLOSE")
+
+        box = layout.box()
+        row = box.row()
+        row.prop(props, "new_tag_name")
+        row = box.row()
+        row.prop(props, "new_tag_message")
+        row = box.row()
+        row.operator("ifcgit.add_tag", icon="GREASEPENCIL")
+
+        if IfcGitData.data["remotes"]:
+            row = layout.row()
+            row.prop(props, "select_remote", text="Select remote")
+            urls = IfcGitData.data["remote_urls"]
+            row.label(text=urls[props.select_remote])
+            row = layout.row()
+            row.operator("ifcgit.push", icon="EXPERIMENTAL")
+            row.operator("ifcgit.fetch", icon="IMPORT")
 
 
 class COMMIT_UL_List(bpy.types.UIList):

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

@@ -31,13 +31,16 @@ classes = (
     operator.ContractMaterialCategory,
     operator.CopyMaterial,
     operator.DisableEditingAssignedMaterial,
+    operator.DisableEditingMaterial,
+    operator.DisableEditingMaterials,
     operator.DisableEditingMaterialSetItem,
     operator.DisableEditingMaterialSetItemProfile,
-    operator.DisableEditingMaterials,
     operator.EditAssignedMaterial,
+    operator.EditMaterial,
     operator.EditMaterialSetItem,
     operator.EditMaterialSetItemProfile,
     operator.EnableEditingAssignedMaterial,
+    operator.EnableEditingMaterial,
     operator.EnableEditingMaterialSetItem,
     operator.EnableEditingMaterialSetItemProfile,
     operator.ExpandMaterialCategory,

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

@@ -59,6 +59,36 @@ class SelectByMaterial(bpy.types.Operator, tool.Ifc.Operator):
         core.select_by_material(tool.Material, material=tool.Ifc.get().by_id(self.material))
 
 
+class EnableEditingMaterial(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.enable_editing_material"
+    bl_label = "Enable Editing Material"
+    bl_options = {"REGISTER", "UNDO"}
+    material: bpy.props.IntProperty()
+
+    def _execute(self, context):
+        core.enable_editing_material(tool.Material, material=tool.Ifc.get().by_id(self.material))
+
+
+class EditMaterial(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.edit_material"
+    bl_label = "Edit Material"
+    bl_options = {"REGISTER", "UNDO"}
+    material: bpy.props.IntProperty()
+
+    def _execute(self, context):
+        core.edit_material(tool.Ifc, tool.Material, material=tool.Ifc.get().by_id(self.material))
+
+
+class DisableEditingMaterial(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.disable_editing_material"
+    bl_label = "Disable Editing Material"
+    bl_options = {"REGISTER", "UNDO"}
+    material: bpy.props.IntProperty()
+
+    def _execute(self, context):
+        core.disable_editing_material(tool.Material)
+
+
 class AssignParameterizedProfile(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.assign_parameterized_profile"
     bl_label = "Assign Parameterized Profile"
@@ -159,17 +189,23 @@ class AssignMaterial(bpy.types.Operator, tool.Ifc.Operator):
                 material=material,
             )
             assigned_material = ifcopenshell.util.element.get_material(element)
-            if assigned_material.is_a("IfcMaterialLayerSet"):
-                if not assigned_material.MaterialLayers:
+            if assigned_material.is_a() in ("IfcMaterialLayerSet", "IfcMaterialLayerSetUsage"):
+                if assigned_material.is_a("IfcMaterialLayerSet"):
+                    layer_set = assigned_material
+                else:
+                    layer_set = assigned_material.ForLayerSet
+
+                if not layer_set.MaterialLayers:
                     unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
                     layer = ifcopenshell.api.run(
                         "material.add_layer",
                         tool.Ifc.get(),
-                        layer_set=assigned_material,
-                        material=tool.Ifc.get().by_type("IfcMaterial")[0],
+                        layer_set=layer_set,
+                        material=material,
                     )
                     thickness = 0.1  # Arbitrary metric thickness for now
                     layer.LayerThickness = thickness / unit_scale
+
             elif assigned_material.is_a("IfcMaterialProfileSet"):
                 if not assigned_material.MaterialProfiles:
                     named_profiles = [p for p in tool.Ifc.get().by_type("IfcProfileDef") if p.ProfileName]
@@ -294,7 +330,7 @@ class AddLayer(bpy.types.Operator, tool.Ifc.Operator):
     def _execute(self, context):
         obj = bpy.data.objects.get(self.obj) if self.obj else context.active_object
         self.file = IfcStore.get_file()
-        ifcopenshell.api.run(
+        layer = ifcopenshell.api.run(
             "material.add_layer",
             self.file,
             **{
@@ -303,6 +339,10 @@ class AddLayer(bpy.types.Operator, tool.Ifc.Operator):
             },
         )
 
+        unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        thickness = 0.1 # Arbitrary metric thickness for now
+        layer.LayerThickness = thickness / unit_scale
+
 
 class ReorderMaterialSetItem(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.reorder_material_set_item"
@@ -338,7 +378,10 @@ class RemoveLayer(bpy.types.Operator, tool.Ifc.Operator):
     def _execute(self, context):
         for inverse in tool.Ifc.get().get_inverse(tool.Ifc.get().by_id(self.layer)):
             if inverse.is_a("IfcMaterialLayerSet") and len(inverse.MaterialLayers) == 1:
-                return
+                self.report(
+                    {"ERROR"}, "Cannot remove material layer - IfcMaterialLayerSet should alawys have atleast 1 layer"
+                )
+                return {"ERROR"}
         ifcopenshell.api.run("material.remove_layer", tool.Ifc.get(), layer=tool.Ifc.get().by_id(self.layer))
 
 

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

@@ -131,6 +131,9 @@ class BIMMaterialProperties(PropertyGroup):
     materials: CollectionProperty(name="Materials", type=Material)
     active_material_index: IntProperty(name="Active Material Index")
     profiles: EnumProperty(items=get_profiles, name="Profiles")
+    active_material_id: IntProperty(name="Active Material ID")
+    material_attributes: CollectionProperty(name="Material Attributes", type=Attribute)
+    editing_material_type = StringProperty(name="Editing Material Type")
 
 
 class BIMObjectMaterialProperties(PropertyGroup):

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

@@ -57,13 +57,21 @@ class BIM_PT_materials(Panel):
         row.alignment = "RIGHT"
 
         if self.props.material_type == "IfcMaterial":
-            row.operator("bim.add_material", text="", icon="ADD")
             if self.props.materials and self.props.active_material_index < len(self.props.materials):
                 material = self.props.materials[self.props.active_material_index]
                 if material.ifc_definition_id:
-                    op = row.operator("bim.select_by_material", text="", icon="RESTRICT_SELECT_OFF")
-                    op.material = material.ifc_definition_id
-                    row.operator("bim.remove_material", text="", icon="X").material = material.ifc_definition_id
+                    if self.props.active_material_id:
+                        row.operator("bim.edit_material", text="", icon="CHECKMARK").material = material.ifc_definition_id
+                        row.operator("bim.disable_editing_material", text="", icon="CANCEL").material = material.ifc_definition_id
+                        self.draw_editable_material_attributes_ui()
+                    else:
+                        row.operator("bim.add_material", text="", icon="ADD")
+                        op = row.operator("bim.select_by_material", text="", icon="RESTRICT_SELECT_OFF")
+                        op.material = material.ifc_definition_id
+                        row.operator("bim.enable_editing_material", text="", icon="GREASEPENCIL").material = material.ifc_definition_id
+                        row.operator("bim.remove_material", text="", icon="X").material = material.ifc_definition_id
+            else:
+                row.operator("bim.add_material", text="", icon="ADD")
         else:
             row.operator("bim.add_material_set", text="", icon="ADD").set_type = self.props.material_type
             if self.props.materials and self.props.active_material_index < len(self.props.materials):
@@ -76,6 +84,9 @@ class BIM_PT_materials(Panel):
         self.layout.template_list("BIM_UL_materials", "", self.props, "materials", self.props, "active_material_index")
 
 
+    def draw_editable_material_attributes_ui(self):
+        blenderbim.bim.helper.draw_attributes(self.props.material_attributes, self.layout)
+
 class BIM_PT_material(Panel):
     bl_label = "IFC Material"
     bl_idname = "BIM_PT_material"
@@ -144,7 +155,12 @@ class BIM_PT_object_material(Panel):
 
         row = self.layout.row(align=True)
         prop_with_search(row, self.props, "material_type", text="")
-        if self.props.material_type == "IfcMaterial" or self.props.material_type == "IfcMaterialList":
+        if self.props.material_type in (
+            "IfcMaterial",
+            "IfcMaterialList",
+            "IfcMaterialLayerSet",
+            "IfcMaterialLayerSetUsage",
+        ):
             prop_with_search(row, self.props, "material", text="")
         row.operator("bim.assign_material", icon="ADD", text="")
 

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

@@ -96,6 +96,7 @@ classes = (
     slab.ResetVertex,
     slab.SetArcIndex,
     space.GenerateSpace,
+    space.GenerateSpacesFromWalls,
     prop.BIMModelProperties,
     prop.BIMArrayProperties,
     prop.BIMStairProperties,
@@ -125,6 +126,7 @@ classes = (
     pie.OpenPieClass,
     pie.PieUpdateContainer,
     pie.PieAddOpening,
+    pie.PieAssignObjectAggregation,
     pie.VIEW3D_MT_PIE_bim,
     pie.VIEW3D_MT_PIE_bim_class,
     sverchok_modifier.CreateNewSverchokGraph,

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

@@ -86,9 +86,10 @@ class EnableEditingArray(bpy.types.Operator, tool.Ifc.Operator):
         data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Array", "Data"))[self.item]
         props = obj.BIMArrayProperties
         props.count = data["count"]
-        props.x = data["x"]
-        props.y = data["y"]
-        props.z = data["z"]
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
+        props.x = data["x"] * si_conversion
+        props.y = data["y"] * si_conversion
+        props.z = data["z"] * si_conversion
         props.use_local_space = data.get("use_local_space", False)
         props.sync_children = data.get("sync_children", False)
         props.method = data.get("method", "OFFSET")
@@ -106,15 +107,16 @@ class EditArray(bpy.types.Operator, tool.Ifc.Operator):
         obj = context.active_object
         element = tool.Ifc.get_entity(obj)
         props = obj.BIMArrayProperties
+        si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
 
         pset = ifcopenshell.util.element.get_pset(element, "BBIM_Array")
         data = json.loads(pset["Data"])
         data[self.item] = {
             "children": data[self.item]["children"],
             "count": props.count,
-            "x": props.x,
-            "y": props.y,
-            "z": props.z,
+            "x": props.x / si_conversion,
+            "y": props.y / si_conversion,
+            "z": props.z / si_conversion,
             "use_local_space": props.use_local_space,
             "sync_children": props.sync_children,
             "method": props.method,
@@ -187,6 +189,7 @@ class SelectArrayParent(bpy.types.Operator):
             obj.select_set(True)
         return {"FINISHED"}
 
+
 class Input3DCursorXArray(bpy.types.Operator):
     bl_idname = "bim.input_cursor_x_array"
     bl_label = "Get 3d Cursor X Input for Array"
@@ -202,6 +205,7 @@ class Input3DCursorXArray(bpy.types.Operator):
             props.x = cursor.location.x - obj.location.x
         return {"FINISHED"}
 
+
 class Input3DCursorYArray(bpy.types.Operator):
     bl_idname = "bim.input_cursor_y_array"
     bl_label = "Get 3d Cursor Y Input for Array"
@@ -217,6 +221,7 @@ class Input3DCursorYArray(bpy.types.Operator):
             props.y = cursor.location.y - obj.location.y
         return {"FINISHED"}
 
+
 class Input3DCursorZArray(bpy.types.Operator):
     bl_idname = "bim.input_cursor_z_array"
     bl_label = "Get 3d Cursor Z Input for Array"

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

@@ -59,9 +59,19 @@ class AuthoringData:
         cls.data["type_thumbnail"] = cls.type_thumbnail()
         cls.data["is_voidable_element"] = cls.is_voidable_element()
         cls.data["has_visible_openings"] = cls.has_visible_openings()
+        cls.data["has_visible_boundaries"] = cls.has_visible_boundaries()
         cls.data["active_class"] = cls.active_class()
         cls.data["active_material_usage"] = cls.active_material_usage()
         cls.data["active_representation_type"] = cls.active_representation_type()
+        cls.data["boundary_class"] = cls.boundary_class()
+
+    @classmethod
+    def boundary_class(cls):
+        declaration = tool.Ifc.schema().declaration_by_name("IfcRelSpaceBoundary")
+        declarations = ifcopenshell.util.schema.get_subtypes(declaration)
+        names = [d.name() for d in declarations]
+        version = tool.Ifc.get_schema()
+        return [(c, c, get_entity_doc(version, c).get("description", "")) for c in sorted(names)]
 
     @classmethod
     def type_class(cls):
@@ -69,7 +79,10 @@ class AuthoringData:
         declarations = ifcopenshell.util.schema.get_subtypes(declaration)
         names = [d.name() for d in declarations]
 
-        declaration = tool.Ifc.schema().declaration_by_name("IfcSpatialElementType")
+        if tool.Ifc.get_schema() == "IFC2X3":
+            declaration = tool.Ifc.schema().declaration_by_name("IfcSpatialStructureElementType")
+        else:
+            declaration = tool.Ifc.schema().declaration_by_name("IfcSpatialElementType")
         declarations = ifcopenshell.util.schema.get_subtypes(declaration)
         names.extend([d.name() for d in declarations])
 
@@ -161,6 +174,17 @@ class AuthoringData:
                     return True
         return False
 
+    @classmethod
+    def has_visible_boundaries(cls):
+        element = tool.Ifc.get_entity(bpy.context.active_object)
+        if element:
+            if element.is_a("IfcRelSpaceBoundary"):
+                return True
+            for boundary in getattr(element, "BoundedBy", []):
+                if tool.Ifc.get_object(boundary):
+                    return True
+        return False
+
     @classmethod
     def active_class(cls):
         element = tool.Ifc.get_entity(bpy.context.active_object)
@@ -177,7 +201,7 @@ class AuthoringData:
     def active_representation_type(cls):
         if bpy.context.active_object:
             representation = tool.Geometry.get_active_representation(bpy.context.active_object)
-            if representation:
+            if representation and representation.is_a("IfcShapeRepresentation"):
                 return representation.RepresentationType
 
     @classmethod

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

@@ -82,14 +82,14 @@ class ProfileDecorator:
         bmesh.ops.triangulate(traingulated_bm, faces=traingulated_bm.faces)
 
         face_indices = [[v.index for v in f.verts] for f in traingulated_bm.faces]
-        faces_color = transparent_color(self.model_props.decorator_color_special)
+        faces_color = transparent_color(self.addon_prefs.decorator_color_special)
         self.draw_batch("TRIS", vertices_coords, faces_color, face_indices)
 
     def __call__(self, context, get_custom_bmesh=None, draw_faces=False, exit_edit_mode_callback=None):
-        self.model_props = context.scene.BIMModelProperties
-        selected_elements_color = self.model_props.decorator_color_selected
-        unselected_elements_color = self.model_props.decorator_color_unselected
-        special_elements_color = self.model_props.decorator_color_special
+        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
 
         obj = context.active_object
 
@@ -214,8 +214,8 @@ class ProfileDecorator:
 
         self.draw_batch("POINTS", unselected_vertices, transparent_color(unselected_elements_color, 0.5))
         self.draw_batch("POINTS", error_vertices, ERROR_ELEMENTS_COLOR)
-        self.draw_batch("POINTS", special_vertices, self.model_props.decorator_color_special)
-        self.draw_batch("POINTS", selected_vertices, self.model_props.decorator_color_selected)
+        self.draw_batch("POINTS", special_vertices, special_elements_color)
+        self.draw_batch("POINTS", selected_vertices, selected_elements_color)
 
         # Draw arcs
         arc_centroids = []

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

@@ -657,7 +657,7 @@ class ShowOpenings(Operator, tool.Ifc.Operator):
         props = bpy.context.scene.BIMModelProperties
         for obj in context.selected_objects:
             element = tool.Ifc.get_entity(obj)
-            if not element:
+            if not element or not getattr(element, "HasOpenings", None):
                 continue
             if tool.Ifc.is_moved(obj):
                 blenderbim.core.geometry.edit_object_placement(tool.Ifc, tool.Geometry, tool.Surveyor, obj=obj)
@@ -682,7 +682,6 @@ class HideOpenings(Operator, tool.Ifc.Operator):
     bl_options = {"REGISTER", "UNDO"}
 
     def _execute(self, context):
-        props = bpy.context.scene.BIMModelProperties
         to_delete = set()
         for obj in context.selected_objects:
             element = tool.Ifc.get_entity(obj)
@@ -694,7 +693,7 @@ class HideOpenings(Operator, tool.Ifc.Operator):
                 if opening_obj:
                     to_delete.add(opening_obj)
         for opening_obj in to_delete:
-            tool.Ifc.unlink(element=opening, obj=opening_obj)
+            tool.Ifc.unlink(obj=opening_obj)
             bpy.data.objects.remove(opening_obj)
         tool.Model.clear_scene_openings()
         return {"FINISHED"}
@@ -793,10 +792,10 @@ class DecorationsHandler:
         batch.draw(shader)
 
     def __call__(self, context):
-        self.model_props = context.scene.BIMModelProperties
-        selected_elements_color = self.model_props.decorator_color_selected
-        unselected_elements_color = self.model_props.decorator_color_unselected
-        special_elements_color = self.model_props.decorator_color_special
+        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
 
         def transparent_color(color, alpha=0.1):
             color = [i for i in color]

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

@@ -19,6 +19,7 @@
 import bpy
 import blenderbim.tool as tool
 import blenderbim.core.spatial
+import blenderbim.core.aggregate
 from blenderbim.bim.ifc import IfcStore
 
 
@@ -75,6 +76,22 @@ class PieUpdateContainer(bpy.types.Operator):
                     break
         return {"FINISHED"}
 
+class PieAssignObjectAggregation(bpy.types.Operator,tool.Ifc.Operator):
+    bl_idname = "bim.pie_assign_object_aggregation"
+    bl_label = "Assign Parts to Active Object"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        for obj in context.selected_objects:
+            if obj == context.active_object:
+                continue
+            blenderbim.core.aggregate.assign_object(
+                tool.Ifc,
+                tool.Aggregate,
+                tool.Collector,
+                relating_obj=context.active_object,
+                related_obj=obj,
+            )
 
 class VIEW3D_MT_PIE_bim(bpy.types.Menu):
     bl_label = "Geometry"
@@ -86,6 +103,7 @@ class VIEW3D_MT_PIE_bim(bpy.types.Menu):
         pie.operator("bim.pie_add_opening")
         pie.operator("bim.pie_update_container")
         pie.operator("bim.open_pie_class", text="Assign IFC Class")
+        pie.operator("bim.pie_assign_object_aggregation", text ="Assign Aggregation")
 
 
 class VIEW3D_MT_PIE_bim_class(bpy.types.Menu):

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

@@ -37,12 +37,6 @@ from . import prop
 import json
 
 
-def select_and_activate_single_object(context, obj):
-    bpy.ops.object.select_all(action="DESELECT")
-    context.view_layer.objects.active = obj
-    obj.select_set(True)
-
-
 class AddEmptyType(bpy.types.Operator, AddObjectHelper):
     bl_idname = "bim.add_empty_type"
     bl_label = "Add Empty Type"
@@ -52,7 +46,7 @@ class AddEmptyType(bpy.types.Operator, AddObjectHelper):
         obj = bpy.data.objects.new("TYPEX", None)
         context.scene.collection.objects.link(obj)
         context.scene.BIMRootProperties.ifc_product = "IfcElementType"
-        select_and_activate_single_object(context, obj)
+        tool.Blender.select_and_activate_single_object(context, obj)
         return {"FINISHED"}
 
 
@@ -97,7 +91,7 @@ class AddConstrTypeInstance(bpy.types.Operator):
                 return {"FINISHED"}
         elif material and material.is_a("IfcMaterialLayerSet"):
             if self.generate_layered_element(ifc_class, relating_type):
-                select_and_activate_single_object(context, context.selected_objects[-1])
+                tool.Blender.select_and_activate_single_object(context, context.selected_objects[-1])
                 return {"FINISHED"}
         if relating_type.is_a("IfcFlowSegmentType") and not relating_type.RepresentationMaps:
             if mep.MepGenerator(relating_type).generate():
@@ -179,7 +173,7 @@ class AddConstrTypeInstance(bpy.types.Operator):
         if ifc_class == "IfcDoorType" and len(context.selected_objects) >= 1:
             pass
         else:
-            select_and_activate_single_object(context, obj)
+            tool.Blender.select_and_activate_single_object(context, obj)
         return {"FINISHED"}
 
     @staticmethod

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

@@ -54,7 +54,7 @@ class DumbProfileGenerator:
         props = bpy.context.scene.BIMModelProperties
         self.collection = bpy.context.view_layer.active_layer_collection.collection
         self.collection_obj = bpy.data.objects.get(self.collection.name)
-        self.depth = props.extrusion_depth * self.unit_scale
+        self.depth = props.extrusion_depth
         self.rotation = 0
         self.location = Vector((0, 0, 0))
         self.cardinal_point = int(bpy.context.scene.BIMModelProperties.cardinal_point)

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

@@ -37,6 +37,12 @@ def get_type_class(self, context):
     return AuthoringData.data["type_class"]
 
 
+def get_boundary_class(self, context):
+    if not AuthoringData.is_loaded:
+        AuthoringData.load()
+    return AuthoringData.data["boundary_class"]
+
+
 def get_relating_type_id(self, context):
     if not AuthoringData.is_loaded:
         AuthoringData.load()
@@ -51,7 +57,7 @@ def get_type_predefined_type(self, context):
 
 def update_ifc_class(self, context):
     bpy.ops.bim.load_type_thumbnails(ifc_class=self.ifc_class)
-    AuthoringData.data["relating_type_id"] = AuthoringData.relating_types()
+    AuthoringData.data["relating_type_id"] = AuthoringData.relating_type_id()
     AuthoringData.data["type_thumbnail"] = AuthoringData.type_thumbnail()
 
 
@@ -76,7 +82,7 @@ def update_type_page(self, context):
 class BIMModelProperties(PropertyGroup):
     ifc_class: bpy.props.EnumProperty(items=get_ifc_class, name="Construction Class", update=update_ifc_class)
     relating_type_id: bpy.props.EnumProperty(
-        items=get_relating_type_id, name="Construction Type", update=update_relating_type_id
+        items=get_relating_type_id, name="Relating Type", update=update_relating_type_id
     )
     icon_id: bpy.props.IntProperty()
     updating: bpy.props.BoolProperty(default=False)
@@ -120,7 +126,7 @@ class BIMModelProperties(PropertyGroup):
     z: bpy.props.FloatProperty(name="Z", default=0.5)
     rl1: bpy.props.FloatProperty(name="RL", default=1)  # Used for things like walls, doors, flooring, skirting, etc
     rl2: bpy.props.FloatProperty(name="RL", default=1)  # Used for things like windows, other hosted furniture
-    x_angle: bpy.props.FloatProperty(name="X Angle", default=0)
+    x_angle: bpy.props.FloatProperty(name="X Angle", default=0, subtype="ANGLE")
     type_page: bpy.props.IntProperty(name="Type Page", default=1, update=update_type_page)
     type_template: bpy.props.EnumProperty(
         items=(
@@ -141,33 +147,7 @@ class BIMModelProperties(PropertyGroup):
     type_class: bpy.props.EnumProperty(items=get_type_class, name="IFC Class", update=update_type_class)
     type_predefined_type: bpy.props.EnumProperty(items=get_type_predefined_type, name="Predefined Type", default=None)
     type_name: bpy.props.StringProperty(name="Name", default="TYPEX")
-    decorator_color_selected: bpy.props.FloatVectorProperty(
-        name="Selected Elements Color",
-        subtype="COLOR",
-        default=(0.545, 0.863, 0, 1),  # green
-        min=0.0,
-        max=1.0,
-        size=4,
-        description="Color of selected verts/edges (used in profile editing mode)",
-    )
-    decorator_color_unselected: bpy.props.FloatVectorProperty(
-        name="Not Selected Elements Color",
-        subtype="COLOR",
-        default=(1, 1, 1, 1),  # green
-        min=0.0,
-        max=1.0,
-        size=4,
-        description="Color of not selected verts/edges (used in profile editing mode)",
-    )
-    decorator_color_special: bpy.props.FloatVectorProperty(
-        name="Special Elements Color",
-        subtype="COLOR",
-        default=(0.157, 0.565, 1, 1),  # blue
-        min=0.0,
-        max=1.0,
-        size=4,
-        description="Color of special selected verts/edges (openings, preview verts/edges in roof editing, verts with arcs/circles in profile editing)",
-    )
+    boundary_class: bpy.props.EnumProperty(items=get_boundary_class, name="Boundary Class")
 
 
 class BIMArrayProperties(PropertyGroup):
@@ -175,9 +155,9 @@ class BIMArrayProperties(PropertyGroup):
         default=-1, description="Currently edited array index. -1 if not in array editing mode."
     )
     count: bpy.props.IntProperty(name="Count", default=0, min=0)
-    x: bpy.props.FloatProperty(name="X", default=0)
-    y: bpy.props.FloatProperty(name="Y", default=0)
-    z: bpy.props.FloatProperty(name="Z", default=0)
+    x: bpy.props.FloatProperty(name="X", default=0, subtype="DISTANCE")
+    y: bpy.props.FloatProperty(name="Y", default=0, subtype="DISTANCE")
+    z: bpy.props.FloatProperty(name="Z", default=0, subtype="DISTANCE")
     use_local_space: bpy.props.BoolProperty(
         name="Use Local Space",
         description="Use local space for array items offset instead of world space",
@@ -196,6 +176,7 @@ class BIMArrayProperties(PropertyGroup):
 
 
 class BIMStairProperties(PropertyGroup):
+    non_si_units_props = ("is_editing", "number_of_treads", "has_top_nib", "stair_type")
     stair_types = (
         ("CONCRETE", "Concrete", ""),
         ("WOOD/STEEL", "Wood / Steel", ""),
@@ -204,17 +185,17 @@ class BIMStairProperties(PropertyGroup):
 
     stair_added_previously: bpy.props.BoolProperty(default=False)
     is_editing: bpy.props.IntProperty(default=-1)
-    width: bpy.props.FloatProperty(name="Width", default=1.2, soft_min=0.01)
-    height: bpy.props.FloatProperty(name="Height", default=1.0, soft_min=0.01)
+    width: bpy.props.FloatProperty(name="Width", default=1.2, soft_min=0.01, subtype="DISTANCE")
+    height: bpy.props.FloatProperty(name="Height", default=1.0, soft_min=0.01, subtype="DISTANCE")
     number_of_treads: bpy.props.IntProperty(name="Number of treads", default=6, soft_min=1)
-    tread_depth: bpy.props.FloatProperty(name="Tread Depth", default=0.25, soft_min=0.01)
-    tread_run: bpy.props.FloatProperty(name="Tread Run", default=0.3, soft_min=0.01)
-    base_slab_depth: bpy.props.FloatProperty(name="Base slab depth", default=0.25, soft_min=0)
-    top_slab_depth: bpy.props.FloatProperty(name="Top slab depth", default=0.25, soft_min=0)
+    tread_depth: bpy.props.FloatProperty(name="Tread Depth", default=0.25, soft_min=0.01, subtype="DISTANCE")
+    tread_run: bpy.props.FloatProperty(name="Tread Run", default=0.3, soft_min=0.01, subtype="DISTANCE")
+    base_slab_depth: bpy.props.FloatProperty(name="Base slab depth", default=0.25, soft_min=0, subtype="DISTANCE")
+    top_slab_depth: bpy.props.FloatProperty(name="Top slab depth", default=0.25, soft_min=0, subtype="DISTANCE")
     has_top_nib: bpy.props.BoolProperty(name="Has top nib", default=True)
     stair_type: bpy.props.EnumProperty(name="Stair type", items=stair_types, default="CONCRETE")
 
-    def get_props_kwargs(self):
+    def get_props_kwargs(self, convert_to_project_units=False):
         stair_kwargs = {
             "stair_type": self.stair_type,
             "width": self.width,
@@ -224,27 +205,34 @@ class BIMStairProperties(PropertyGroup):
         }
 
         if self.stair_type == "CONCRETE":
-            stair_kwargs.update(
-                {
-                    "base_slab_depth": self.base_slab_depth,
-                    "top_slab_depth": self.top_slab_depth,
-                    "has_top_nib": self.has_top_nib,
-                    "tread_depth": self.tread_depth,
-                }
-            )
-            return stair_kwargs
+            concrete_props = {
+                "base_slab_depth": self.base_slab_depth,
+                "top_slab_depth": self.top_slab_depth,
+                "has_top_nib": self.has_top_nib,
+                "tread_depth": self.tread_depth,
+            }
+            stair_kwargs.update(concrete_props)
 
         elif self.stair_type == "WOOD/STEEL":
-            stair_kwargs.update(
-                {
-                    "tread_depth": self.tread_depth,
-                }
-            )
-            return stair_kwargs
+            wood_steel_props = {
+                "tread_depth": self.tread_depth,
+            }
+            stair_kwargs.update(wood_steel_props)
 
         elif self.stair_type == "GENERIC":
+            pass
+
+        if not convert_to_project_units:
             return stair_kwargs
 
+        stair_kwargs = tool.Model.convert_data_to_project_units(stair_kwargs, self.non_si_units_props)
+        return stair_kwargs
+
+    def set_props_kwargs_from_ifc_data(self, kwargs):
+        kwargs = tool.Model.convert_data_to_si_units(kwargs, self.non_si_units_props)
+        for prop_name in kwargs:
+            setattr(self, prop_name, kwargs[prop_name])
+
 
 class BIMSverchokProperties(PropertyGroup):
     node_group: bpy.props.PointerProperty(name="Node Group", type=NodeTree)
@@ -252,15 +240,13 @@ class BIMSverchokProperties(PropertyGroup):
 
 def window_type_prop_update(self, context):
     number_of_panels, panels_data = self.window_types_panels[self.window_type]
-
-    si_coversion = 1.0 / ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-    panels_data = [[v * si_coversion for v in data] for data in panels_data]
     self.first_mullion_offset, self.second_mullion_offset = panels_data[0]
     self.first_transom_offset, self.second_transom_offset = panels_data[1]
 
 
 # default prop values are in mm and converted later
 class BIMWindowProperties(PropertyGroup):
+    non_si_units_props = ("is_editing", "window_type", "window_added_previously")
     window_types = (
         ("SINGLE_PANEL", "SINGLE_PANEL", ""),
         ("DOUBLE_PANEL_HORIZONTAL", "DOUBLE_PANEL_HORIZONTAL", ""),
@@ -293,50 +279,63 @@ class BIMWindowProperties(PropertyGroup):
     window_type: bpy.props.EnumProperty(
         name="Window Type", items=window_types, default="SINGLE_PANEL", update=window_type_prop_update
     )
-    overall_height: bpy.props.FloatProperty(name="Overall Height", default=0.9)
-    overall_width: bpy.props.FloatProperty(name="Overall Width", default=0.6)
+    overall_height: bpy.props.FloatProperty(name="Overall Height", default=0.9, subtype="DISTANCE")
+    overall_width: bpy.props.FloatProperty(name="Overall Width", default=0.6, subtype="DISTANCE")
 
     # lining properties
-    lining_depth: bpy.props.FloatProperty(name="Lining Depth", default=0.050)
-    lining_thickness: bpy.props.FloatProperty(name="Lining Thickness", default=0.050)
-    lining_offset: bpy.props.FloatProperty(name="Lining Offset", default=0.050)
-    lining_to_panel_offset_x: bpy.props.FloatProperty(name="Lining to Panel Offset X", default=0.025)
-    lining_to_panel_offset_y: bpy.props.FloatProperty(name="Lining to Panel Offset Y", default=0.025)
-    mullion_thickness: bpy.props.FloatProperty(name="Mullion Thickness", default=0.050)
+    lining_depth: bpy.props.FloatProperty(name="Lining Depth", default=0.050, subtype="DISTANCE")
+    lining_thickness: bpy.props.FloatProperty(name="Lining Thickness", default=0.050, subtype="DISTANCE")
+    lining_offset: bpy.props.FloatProperty(name="Lining Offset", default=0.050, subtype="DISTANCE")
+    lining_to_panel_offset_x: bpy.props.FloatProperty(
+        name="Lining to Panel Offset X", default=0.025, subtype="DISTANCE"
+    )
+    lining_to_panel_offset_y: bpy.props.FloatProperty(
+        name="Lining to Panel Offset Y", default=0.025, subtype="DISTANCE"
+    )
+    mullion_thickness: bpy.props.FloatProperty(name="Mullion Thickness", default=0.050, subtype="DISTANCE")
     first_mullion_offset: bpy.props.FloatProperty(
         name="First Mullion Offset",
         description="Distance from the first lining to the first mullion center",
         default=0.3,
+        subtype="DISTANCE",
     )
     second_mullion_offset: bpy.props.FloatProperty(
         name="Second Mullion Offset",
         description="Distance from the first lining to the second mullion center",
         default=0.45,
+        subtype="DISTANCE",
     )
-    transom_thickness: bpy.props.FloatProperty(name="Transom Thickness", default=0.050)
+    transom_thickness: bpy.props.FloatProperty(name="Transom Thickness", default=0.050, subtype="DISTANCE")
     first_transom_offset: bpy.props.FloatProperty(
         name="First Transom Offset",
         description="Distance from the first lining to the first transom center",
         default=0.3,
+        subtype="DISTANCE",
     )
     second_transom_offset: bpy.props.FloatProperty(
         name="Second Transom Offset",
         description="Distance from the first lining to the second transom center",
         default=0.6,
+        subtype="DISTANCE",
     )
 
     # panel properties
-    frame_depth: bpy.props.FloatVectorProperty(name="Frame Depth", size=3, default=[0.035] * 3)
-    frame_thickness: bpy.props.FloatVectorProperty(name="Frame Thickness", size=3, default=[0.035] * 3)
+    frame_depth: bpy.props.FloatVectorProperty(name="Frame Depth", size=3, default=[0.035] * 3, subtype="TRANSLATION")
+    frame_thickness: bpy.props.FloatVectorProperty(
+        name="Frame Thickness", size=3, default=[0.035] * 3, subtype="TRANSLATION"
+    )
 
-    def get_general_kwargs(self):
-        return {
+    def get_general_kwargs(self, convert_to_project_units=False):
+        kwargs = {
             "window_type": self.window_type,
             "overall_height": self.overall_height,
             "overall_width": self.overall_width,
         }
+        if not convert_to_project_units:
+            return kwargs
+        return tool.Model.convert_data_to_project_units(kwargs, ["window_type"])
 
-    def get_lining_kwargs(self):
+    def get_lining_kwargs(self, convert_to_project_units=False):
         kwargs = {
             "lining_depth": self.lining_depth,
             "lining_thickness": self.lining_thickness,
@@ -373,13 +372,23 @@ class BIMWindowProperties(PropertyGroup):
         if self.window_type in ("TRIPLE_PANEL_HORIZONTAL",):
             kwargs["second_transom_offset"] = self.second_transom_offset
 
-        return kwargs
+        if not convert_to_project_units:
+            return kwargs
+        return tool.Model.convert_data_to_project_units(kwargs)
 
-    def get_panel_kwargs(self):
-        return {
+    def get_panel_kwargs(self, convert_to_project_units=False):
+        kwargs = {
             "frame_depth": self.frame_depth,
             "frame_thickness": self.frame_thickness,
         }
+        if not convert_to_project_units:
+            return kwargs
+        return tool.Model.convert_data_to_project_units(kwargs)
+
+    def set_props_kwargs_from_ifc_data(self, kwargs):
+        kwargs = tool.Model.convert_data_to_si_units(kwargs, self.non_si_units_props)
+        for prop_name in kwargs:
+            setattr(self, prop_name, kwargs[prop_name])
 
 
 class BIMDoorProperties(PropertyGroup):
@@ -499,12 +508,12 @@ class BIMRailingProperties(PropertyGroup):
         ("WALL_MOUNTED_HANDRAIL", "WALL_MOUNTED_HANDRAIL", ""),
     )
     cap_types = (
-        ("none", "none", ""),
+        ("TO_END_POST_AND_FLOOR", "TO_END_POST_AND_FLOOR", ""),
+        ("TO_END_POST", "TO_END_POST", ""),
+        ("TO_FLOOR", "TO_FLOOR", ""),
+        ("TO_WALL", "TO_WALL", ""),
         ("180", "180", ""),
-        ("to_wall", "to_wall", ""),
-        ("to_floor", "to_floor", ""),
-        ("to_end_post", "to_end_post", ""),
-        ("to_end_post_and_floor", "to_end_post_and_floor", ""),
+        ("NONE", "NONE", ""),
     )
 
     railing_added_previously: bpy.props.BoolProperty(default=False)

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

@@ -87,11 +87,29 @@ class GenerateHippedRoof(bpy.types.Operator, tool.Ifc.Operator):
             return {"CANCELLED"}
 
         bm = tool.Blender.get_bmesh_for_mesh(obj.data)
+        op_status, error_message = is_valid_roof_footprint(bm)
+        if error_message:
+            self.report(op_status, error_message)
+            return {"CANCELLED"}
+
         generate_hiped_roof_bmesh(bm, self.mode, self.height, self.angle)
         tool.Blender.apply_bmesh(obj.data, bm)
         return {"FINISHED"}
 
 
+def is_valid_roof_footprint(bm):
+    # should be bmesh to support edit mode
+    bm.verts.ensure_lookup_table()
+    base_z = bm.verts[0].co.z
+    all_verts_same_level = all([float_is_zero(v.co.z - base_z) for v in bm.verts[1:]])
+    if not all_verts_same_level:
+        return (
+            {"ERROR"},
+            "\nAll roof footprint vertices should have same Z-level.\nCurrently Z-level doesn't completely match",
+        )
+    return ({"FINISHED"}, "")
+
+
 def generate_hiped_roof_bmesh(bm, mode="ANGLE", height=1.0, angle=pi / 18, mutate_current_bmesh=True):
     """return bmesh with gable roof geometry
 
@@ -448,18 +466,30 @@ class AddRoof(bpy.types.Operator, tool.Ifc.Operator):
         if not props.roof_added_previously:
             convert_property_group_from_si(props, skip_props=NON_SI_ROOF_PROPS)
 
+        # rejecting original roof shape to be safe
+        # taking into account only it's bounding box dimensions
+        if obj.dimensions.x == 0 or obj.dimensions.y == 0:
+            min_x, min_y = -5, -5
+            max_x, max_y = 5, 5
+            min_z = 0
+        else:
+            bbox = tool.Blender.get_object_bounding_box(obj)
+            min_x = bbox["min_x"]
+            min_y = bbox["min_y"]
+            max_x = bbox["max_x"]
+            max_y = bbox["max_y"]
+            min_z = bbox["min_z"]
+
         roof_data = props.get_general_kwargs()
-        path_data = get_path_data(obj)
-        if not path_data:
-            path_data = {
-                "edges": [[0, 1], [1, 2], [2, 3], [3, 0]],
-                "verts": [
-                    Vector([-5.0, -5.0, 0.0]) / si_conversion,
-                    Vector([-5.0, 5.0, 0.0]) / si_conversion,
-                    Vector([5.0, 5.0, 0.0]) / si_conversion,
-                    Vector([5.0, -5.0, 0.0]) / si_conversion,
-                ],
-            }
+        path_data = {
+            "edges": [[0, 1], [1, 2], [2, 3], [3, 0]],
+            "verts": [
+                Vector([min_x, min_y, min_z]) / si_conversion,
+                Vector([min_x, max_y, min_z]) / si_conversion,
+                Vector([max_x, max_y, min_z]) / si_conversion,
+                Vector([max_x, min_y, min_z]) / si_conversion,
+            ],
+        }
         roof_data["path_data"] = path_data
 
         update_bbim_roof_pset(element, roof_data)
@@ -572,6 +602,11 @@ class EnableEditingRoofPath(bpy.types.Operator, tool.Ifc.Operator):
             # copying to make sure not to mutate the edit mode bmesh
             bm = tool.Blender.get_bmesh_for_mesh(obj.data)
             main_bm = bm.copy()
+            op_status, error_message = is_valid_roof_footprint(main_bm)
+            if error_message:
+                print("Error: %s" % error_message)
+                return main_bm
+
             main_bm.edges.layers.int.new("BBIM_preview")
 
             si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
@@ -625,6 +660,12 @@ class FinishEditingRoofPath(bpy.types.Operator, tool.Ifc.Operator):
         element = tool.Ifc.get_entity(obj)
         props = obj.BIMRoofProperties
 
+        bm = tool.Blender.get_bmesh_for_mesh(obj.data)
+        op_status, error_message = is_valid_roof_footprint(bm)
+        if error_message:
+            self.report(op_status, error_message)
+            return {"CANCELLED"}
+
         roof_data = props.get_general_kwargs()
         path_data = get_path_data(obj)
         roof_data["path_data"] = path_data
@@ -634,6 +675,7 @@ class FinishEditingRoofPath(bpy.types.Operator, tool.Ifc.Operator):
         update_bbim_roof_pset(element, roof_data)
         refresh()  # RoofData has to be updated before run update_roof_modifier_bmesh
         update_roof_modifier_bmesh(context)
+
         update_roof_modifier_ifc_data(context)
         if bpy.context.object.mode == "EDIT":
             bpy.ops.object.mode_set(mode="OBJECT")

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

@@ -139,7 +139,7 @@ class DumbSlabGenerator:
         self.length = 3
         self.rotation = 0
         self.location = Vector((0, 0, 0))
-        self.x_angle = 0 if tool.Cad.is_x(props.x_angle, 0, tolerance=0.001) else radians(props.x_angle)
+        self.x_angle = 0 if tool.Cad.is_x(props.x_angle, 0, tolerance=0.001) else props.x_angle
         return self.derive_from_cursor()
 
     def derive_from_cursor(self):
@@ -274,7 +274,7 @@ class DumbSlabPlaner:
                 extrusion.Depth = thickness
             else:
                 props = bpy.context.scene.BIMModelProperties
-                x_angle = 0 if tool.Cad.is_x(props.x_angle, 0, tolerance=0.001) else radians(props.x_angle)
+                x_angle = 0 if tool.Cad.is_x(props.x_angle, 0, tolerance=0.001) else props.x_angle
                 new_rep = ifcopenshell.api.run(
                     "geometry.add_slab_representation",
                     tool.Ifc.get(),
@@ -299,7 +299,7 @@ class DumbSlabPlaner:
                 return
         else:
             props = bpy.context.scene.BIMModelProperties
-            x_angle = 0 if tool.Cad.is_x(props.x_angle, 0, tolerance=0.001) else radians(props.x_angle)
+            x_angle = 0 if tool.Cad.is_x(props.x_angle, 0, tolerance=0.001) else props.x_angle
             representation = ifcopenshell.api.run(
                 "geometry.add_slab_representation",
                 tool.Ifc.get(),

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

@@ -26,12 +26,20 @@ import blenderbim.tool as tool
 import blenderbim.core.type
 from math import pi
 from mathutils import Vector, Matrix
+from shapely import Polygon
 
 
 class GenerateSpace(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.generate_space"
     bl_label = "Generate Space"
     bl_options = {"REGISTER"}
+    bl_description = "Create a space from the cursor position. Move the cursor position into the desired position, select the right space collection and run the operator"
+
+    @classmethod
+    def poll(cls, context):
+        collection = context.view_layer.active_layer_collection.collection
+        collection_obj = bpy.data.objects.get(collection.name)
+        return tool.Ifc.get_entity(collection_obj)
 
     def _execute(self, context):
         # This only works based on a 2D plan only considering the standard
@@ -65,8 +73,13 @@ class GenerateSpace(bpy.types.Operator, tool.Ifc.Operator):
         element = None
         if bpy.context.selected_objects and active_obj:
             element = tool.Ifc.get_entity(active_obj)
-            x, y, z = active_obj.matrix_world.translation.xyz
             mat = active_obj.matrix_world
+            local_bbox_center = 0.125 * sum((Vector(b) for b in active_obj.bound_box), Vector())
+            global_bbox_center = mat @ local_bbox_center
+            x = global_bbox_center.x
+            y = global_bbox_center.y
+            z = (mat @ Vector(active_obj.bound_box[0])).z
+
             h = active_obj.dimensions.z
         else:
             x, y = context.scene.cursor.location.xy
@@ -166,3 +179,177 @@ class GenerateSpace(bpy.types.Operator, tool.Ifc.Operator):
                 (obj.matrix_world @ Vector((max_x, max_y, 0.0))).to_2d(),
             ],
         }
+
+
+class GenerateSpacesFromWalls(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.generate_spaces_from_walls"
+    bl_label = "Generate Spaces From Walls"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Generate spaces from selected walls. The active object must be a wall."
+
+    @classmethod
+    def poll(cls, context):
+        active_obj = bpy.context.active_object
+        element = tool.Ifc.get_entity(active_obj)
+        if element:
+            return context.selected_objects and element.is_a("IfcWall")
+
+    def _execute(self, context):
+        # This only works based on a 2D plan only considering the standard
+        # walls (i.e. prismatic) in the active object storey.
+        # In order to run, the active objct must be a wall and
+        # have to be selected walls
+        props = context.scene.BIMModelProperties
+        active_obj = bpy.context.active_object
+
+        if not active_obj:
+            self.report({'ERROR'}, "No active object. Please select a wall")
+            return
+
+        element = None
+        element = tool.Ifc.get_entity(active_obj)
+        if element:
+            if not element.is_a("IfcWall"):
+                self.report({'ERROR'}, "The active object is not a wall. Please select a wall.")
+                return
+
+        collection = active_obj.users_collection[0]
+        collection_obj = bpy.data.objects.get(collection.name)
+        if not collection_obj:
+            self.report({'ERROR'}, "No collection found. Please insert one.")
+            return
+
+        spatial_element = tool.Ifc.get_entity(collection_obj)
+        if not spatial_element:
+            self.report({'ERROR'}, "The collection hasn't an ifc space entity. Please provide one.")
+            return
+
+        if not bpy.context.selected_objects:
+            self.report({'ERROR'}, "No selected objects found. Please select walls.")
+            return
+
+        x, y, z = active_obj.matrix_world.translation.xyz
+        mat = active_obj.matrix_world
+        h = active_obj.dimensions.z
+        selected_objects = bpy.context.selected_objects
+
+        boundary_elements = self.get_boundary_elements(selected_objects)
+
+        polys = self.get_polygons(boundary_elements)
+
+        converted_tolerance = self.get_converted_tolerance(tolerance = 0.03)
+
+        union = shapely.ops.unary_union(polys).buffer(converted_tolerance, cap_style = 2, join_style = 2)
+
+        i=0
+        for linear_ring in union.interiors:
+            poly = Polygon(linear_ring)
+            poly = poly.buffer(converted_tolerance, single_sided=True, cap_style = 2, join_style = 2)
+
+            bm = self.get_bmesh_from_polygon(poly, mat, h)
+
+            name = "Space" + str(i)
+            mesh = bpy.data.meshes.new(name = name)
+            bm.to_mesh(mesh)
+            bm.free()
+
+            obj = bpy.data.objects.new(name, mesh)
+            obj.matrix_world = mat
+
+            self.set_obj_origin_to_bboxcenter(obj)
+
+            collection.objects.link(obj)
+
+            bpy.ops.bim.assign_class(obj=obj.name, ifc_class="IfcSpace")
+            i+=1
+
+        return {"FINISHED"}
+
+
+    def get_boundary_elements(self, selected_objects):
+        boundary_elements = []
+        for obj in selected_objects:
+            subelement = tool.Ifc.get_entity(obj)
+            if subelement.is_a("IfcWall"):
+                boundary_elements.append(subelement)
+        return boundary_elements
+
+    def get_polygons(self, boundary_elements):
+        polys = []
+        for boundary_element in boundary_elements:
+            obj = tool.Ifc.get_object(boundary_element)
+            if not obj:
+                continue
+            points = []
+            base = self.get_obj_base_points(obj)
+            for index in ["low_left", "low_right", "high_right", "high_left"]:
+                point = base[index]
+                points.append(point)
+
+            polys.append(Polygon(points))
+        return polys
+
+    def get_obj_base_points(self, obj):
+        x_values = [(obj.matrix_world @ Vector(v)).x for v in obj.bound_box]
+        y_values = [(obj.matrix_world @ Vector(v)).y for v in obj.bound_box]
+        return {
+            "low_left": (x_values[0], y_values[0]),
+            "high_left": (x_values[3], y_values[3]),
+            "low_right": (x_values[4], y_values[4]),
+            "high_right": (x_values[7], y_values[7]),
+        }
+
+    def get_converted_tolerance(self, tolerance):
+        model = tool.Ifc.get()
+        project_unit = ifcopenshell.util.unit.get_project_unit(model, "LENGTHUNIT")
+        prefix=getattr(project_unit, "Prefix", None)
+
+        converted_tolerance = ifcopenshell.util.unit.convert(
+                                                        value = tolerance,
+                                                        from_prefix = None,
+                                                        from_unit = "METRE",
+                                                        to_prefix = prefix,
+                                                        to_unit = project_unit.Name,
+                                                        )
+        return tolerance
+
+    def get_bmesh_from_polygon(self, poly, mat, h):
+        bm = bmesh.new()
+        bm.verts.index_update()
+        bm.edges.index_update()
+
+        mat_invert = mat.inverted()
+
+        new_verts = [bm.verts.new(mat_invert @ Vector([v[0], v[1], 0])) for v in poly.exterior.coords[0:-1]]
+        [bm.edges.new((new_verts[i], new_verts[i + 1])) for i in range(len(new_verts) - 1)]
+        bm.edges.new((new_verts[len(new_verts) - 1], new_verts[0]))
+
+        bm.verts.index_update()
+        bm.edges.index_update()
+
+        bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-5)
+        bmesh.ops.triangle_fill(bm, edges=bm.edges)
+        bmesh.ops.dissolve_limit(bm, angle_limit=pi / 180 * 5, verts=bm.verts, edges=bm.edges)
+
+        extrusion = bmesh.ops.extrude_face_region(bm, geom=bm.faces)
+        extruded_verts = [g for g in extrusion["geom"] if isinstance(g, bmesh.types.BMVert)]
+        bmesh.ops.translate(bm, vec=[0.0, 0.0, h], verts=extruded_verts)
+
+        bmesh.ops.recalc_face_normals(bm, faces = bm.faces)
+
+        return bm
+
+    def set_obj_origin_to_bboxcenter(self, obj):
+        mat = obj.matrix_world
+        inverted = mat.inverted()
+        local_bbox_center = 0.125 * sum((Vector(b) for b in obj.bound_box), Vector())
+        global_bbox_center = mat @ local_bbox_center
+
+        oldLoc = obj.location
+        newLoc = global_bbox_center
+        diff = newLoc - oldLoc
+        for vert in obj.data.vertices:
+            aux_vector = mat @ vert.co
+            aux_vector = aux_vector - diff
+            vert.co = inverted @ aux_vector
+        obj.location = newLoc

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

@@ -18,7 +18,7 @@
 
 import bpy
 from bpy.types import Operator
-from bpy.props import FloatProperty, IntProperty, BoolProperty
+from bpy.props import FloatProperty, IntProperty
 from bpy_extras.object_utils import AddObjectHelper, object_data_add
 
 import bmesh
@@ -28,7 +28,6 @@ import ifcopenshell
 from ifcopenshell.util.shape_builder import V, ShapeBuilder
 import blenderbim
 import blenderbim.tool as tool
-from blenderbim.bim.helper import convert_property_group_from_si
 
 from mathutils import Vector
 from pprint import pprint
@@ -214,14 +213,6 @@ def generate_stair_2d_profile(
 def update_stair_modifier(context):
     obj = context.active_object
     props_kwargs = obj.BIMStairProperties.get_props_kwargs()
-
-    si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
-    for prop_name in props_kwargs:
-        if prop_name in ("is_editing", "number_of_treads", "has_top_nib", "stair_type"):
-            continue
-        prop_value = props_kwargs[prop_name]
-        props_kwargs[prop_name] = prop_value * si_conversion
-
     vertices, edges, faces = generate_stair_2d_profile(**props_kwargs)
 
     obj = context.object
@@ -360,14 +351,7 @@ class AddStair(bpy.types.Operator, tool.Ifc.Operator):
             self.report({"ERROR"}, "Object has to be IfcStairFlight/IfcStairFlightType to add a stair.")
             return {"CANCELLED"}
 
-        # need to make sure all default props will have correct units
-        if not props.stair_added_previously:
-            convert_property_group_from_si(
-                props,
-                skip_props=("stair_added_previously", "is_editing", "number_of_treads", "has_top_nib", "stair_type"),
-            )
-
-        stair_data = props.get_props_kwargs()
+        stair_data = props.get_props_kwargs(convert_to_project_units=True)
         pset = tool.Pset.get_element_pset(element, "BBIM_Stair")
         if not pset:
             pset = ifcopenshell.api.run("pset.add_pset", ifc_file, product=element, name="BBIM_Stair")
@@ -393,8 +377,7 @@ class CancelEditingStair(bpy.types.Operator, tool.Ifc.Operator):
         data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Stair", "Data"))
         props = obj.BIMStairProperties
         # restore previous settings since editing was canceled
-        for prop_name in data:
-            setattr(props, prop_name, data[prop_name])
+        props.set_props_kwargs_from_ifc_data(data)
         update_stair_modifier(context)
 
         props.is_editing = -1
@@ -412,7 +395,7 @@ class FinishEditingStair(bpy.types.Operator, tool.Ifc.Operator):
         element = tool.Ifc.get_entity(obj)
         props = obj.BIMStairProperties
 
-        data = props.get_props_kwargs()
+        data = props.get_props_kwargs(convert_to_project_units=True)
         props.is_editing = -1
         update_stair_modifier(context)
 
@@ -436,15 +419,7 @@ class EnableEditingStair(bpy.types.Operator, tool.Ifc.Operator):
         element = tool.Ifc.get_entity(obj)
         data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Stair", "Data"))
         # required since we could load pset from .ifc and BIMStairProperties won't be set
-        for prop_name in data:
-            setattr(props, prop_name, data[prop_name])
-
-        # need to make sure all props that weren't used before
-        # will have correct units
-        skip_props = ("stair_added_previously", "is_editing", "number_of_treads", "has_top_nib", "stair_type")
-        skip_props += tuple(data.keys())
-        convert_property_group_from_si(props, skip_props=skip_props)
-
+        props.set_props_kwargs_from_ifc_data(data)
         props.is_editing = 1
         return {"FINISHED"}
 

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

@@ -117,7 +117,7 @@ class LaunchTypeManager(bpy.types.Operator):
 
             op = row.operator("bim.select_type", icon="OBJECT_DATA", text="")
             op.relating_type = relating_type["id"]
-            op = row.operator("bim.duplicate_type", icon="COPYDOWN", text="")
+            op = row.operator("bim.duplicate_type", icon="DUPLICATE", text="")
             op.element = relating_type["id"]
             op = row.operator("bim.remove_type", icon="X", text="")
             op.element = relating_type["id"]
@@ -132,9 +132,9 @@ class BIM_PT_authoring(Panel):
 
     def draw(self, context):
         row = self.layout.row(align=True)
-        row.operator("bim.align_wall", icon="ANCHOR_TOP", text="Ext.").align_type = "EXTERIOR"
-        row.operator("bim.align_wall", icon="ANCHOR_CENTER", text="C/L").align_type = "CENTERLINE"
-        row.operator("bim.align_wall", icon="ANCHOR_BOTTOM", text="Int.").align_type = "INTERIOR"
+        row.operator("bim.generate_space")
+        row = self.layout.row(align=True)
+        row.operator("bim.generate_spaces_from_walls")
 
 
 class BIM_PT_array(bpy.types.Panel):

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

@@ -240,7 +240,7 @@ class ChangeExtrusionXAngle(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.change_extrusion_x_angle"
     bl_label = "Change Extrusion X Angle"
     bl_options = {"REGISTER", "UNDO"}
-    x_angle: bpy.props.FloatProperty()
+    x_angle: bpy.props.FloatProperty(name="X Angle", default=0, subtype="ANGLE")
 
     @classmethod
     def poll(cls, context):
@@ -249,7 +249,7 @@ class ChangeExtrusionXAngle(bpy.types.Operator, tool.Ifc.Operator):
     def _execute(self, context):
         layer2_objs = []
         other_objs = []
-        x_angle = radians(self.x_angle)
+        x_angle = self.x_angle
         unit_scale = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
         for obj in context.selected_objects:
             element = tool.Ifc.get_entity(obj)
@@ -436,11 +436,11 @@ class DumbWallGenerator:
         self.collection = bpy.context.view_layer.active_layer_collection.collection
         self.collection_obj = bpy.data.objects.get(self.collection.name)
         self.width = self.layers["thickness"]
-        self.height = props.extrusion_depth * self.unit_scale
-        self.length = props.length * self.unit_scale
+        self.height = props.extrusion_depth
+        self.length = props.length
         self.rotation = 0.0
         self.location = Vector((0, 0, 0))
-        self.x_angle = 0 if tool.Cad.is_x(props.x_angle, 0, tolerance=0.001) else radians(props.x_angle)
+        self.x_angle = 0 if tool.Cad.is_x(props.x_angle, 0, tolerance=0.001) else props.x_angle
 
         return self.derive_from_cursor()
 

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

@@ -27,11 +27,7 @@ import blenderbim.core.root
 import blenderbim.core.geometry
 from ifcopenshell.api.geometry.add_window_representation import DEFAULT_PANEL_SCHEMAS
 from ifcopenshell.util.shape_builder import V
-from bpy.types import Operator
-from bpy.props import FloatProperty, IntProperty, BoolProperty
 from bmesh.types import BMVert
-from blenderbim.bim.helper import convert_property_group_from_si
-from blenderbim.bim.ifc import IfcStore
 from mathutils import Vector
 
 
@@ -105,31 +101,32 @@ def update_window_modifier_representation(context):
     element = tool.Ifc.get_entity(obj)
     props = obj.BIMWindowProperties
     ifc_file = tool.Ifc.get()
+    si_conversion = ifcopenshell.util.unit.calculate_unit_scale(ifc_file)
 
     representation_data = {
         "partition_type": props.window_type,
-        "overall_height": props.overall_height,
-        "overall_width": props.overall_width,
+        "overall_height": props.overall_height / si_conversion,
+        "overall_width": props.overall_width / si_conversion,
         "lining_properties": {
-            "LiningDepth": props.lining_depth,
-            "LiningThickness": props.lining_thickness,
-            "LiningOffset": props.lining_offset,
-            "LiningToPanelOffsetX": props.lining_to_panel_offset_x,
-            "LiningToPanelOffsetY": props.lining_to_panel_offset_y,
-            "MullionThickness": props.mullion_thickness,
-            "FirstMullionOffset": props.first_mullion_offset,
-            "SecondMullionOffset": props.second_mullion_offset,
-            "TransomThickness": props.transom_thickness,
-            "FirstTransomOffset": props.first_transom_offset,
-            "SecondTransomOffset": props.second_transom_offset,
+            "LiningDepth": props.lining_depth / si_conversion,
+            "LiningThickness": props.lining_thickness / si_conversion,
+            "LiningOffset": props.lining_offset / si_conversion,
+            "LiningToPanelOffsetX": props.lining_to_panel_offset_x / si_conversion,
+            "LiningToPanelOffsetY": props.lining_to_panel_offset_y / si_conversion,
+            "MullionThickness": props.mullion_thickness / si_conversion,
+            "FirstMullionOffset": props.first_mullion_offset / si_conversion,
+            "SecondMullionOffset": props.second_mullion_offset / si_conversion,
+            "TransomThickness": props.transom_thickness / si_conversion,
+            "FirstTransomOffset": props.first_transom_offset / si_conversion,
+            "SecondTransomOffset": props.second_transom_offset / si_conversion,
         },
         "panel_properties": [],
     }
     number_of_panels, panels_data = props.window_types_panels[props.window_type]
     for panel_i in range(number_of_panels):
         panel_data = {
-            "FrameDepth": props.frame_depth[panel_i],
-            "FrameThickness": props.frame_thickness[panel_i],
+            "FrameDepth": props.frame_depth[panel_i] / si_conversion,
+            "FrameThickness": props.frame_thickness[panel_i] / si_conversion,
         }
         representation_data["panel_properties"].append(panel_data)
 
@@ -175,10 +172,10 @@ def update_window_modifier_representation(context):
     # occurences attributes
     occurences = tool.Ifc.get_all_element_occurences(element)
     for occurence in occurences:
-        occurence.OverallWidth = props.overall_width
-        occurence.OverallHeight = props.overall_height
+        occurence.OverallWidth = props.overall_width / si_conversion
+        occurence.OverallHeight = props.overall_height / si_conversion
 
-    update_simple_openings(element, props.overall_width, props.overall_height)
+    update_simple_openings(element, props.overall_width / si_conversion, props.overall_height / si_conversion)
 
 
 def create_bm_window_frame(bm, size: Vector, thickness: list, position: Vector = V(0, 0, 0).freeze()):
@@ -291,27 +288,26 @@ def create_bm_window(
 def update_window_modifier_bmesh(context):
     obj = context.object
     props = obj.BIMWindowProperties
-    si_conversion = ifcopenshell.util.unit.calculate_unit_scale(tool.Ifc.get())
     panel_schema = DEFAULT_PANEL_SCHEMAS[props.window_type]
     accumulated_height = [0] * len(panel_schema[0])
     built_panels = []
 
-    overall_width = props.overall_width * si_conversion
-    lining_depth = props.lining_depth * si_conversion
-    overall_height = props.overall_height * si_conversion
-    lining_to_panel_offset_x = props.lining_to_panel_offset_x * si_conversion
-    lining_to_panel_offset_y = props.lining_to_panel_offset_y * si_conversion
-    lining_thickness = props.lining_thickness * si_conversion
-    lining_offset = props.lining_offset * si_conversion
+    overall_width = props.overall_width
+    lining_depth = props.lining_depth
+    overall_height = props.overall_height
+    lining_to_panel_offset_x = props.lining_to_panel_offset_x
+    lining_to_panel_offset_y = props.lining_to_panel_offset_y
+    lining_thickness = props.lining_thickness
+    lining_offset = props.lining_offset
 
-    mullion_thickness = props.mullion_thickness * si_conversion / 2
-    first_mullion_offset = props.first_mullion_offset * si_conversion
-    second_mullion_offset = props.second_mullion_offset * si_conversion
-    transom_thickness = props.transom_thickness * si_conversion / 2
-    first_transom_offset = props.first_transom_offset * si_conversion
-    second_transom_offset = props.second_transom_offset * si_conversion
+    mullion_thickness = props.mullion_thickness / 2
+    first_mullion_offset = props.first_mullion_offset
+    second_mullion_offset = props.second_mullion_offset
+    transom_thickness = props.transom_thickness / 2
+    first_transom_offset = props.first_transom_offset
+    second_transom_offset = props.second_transom_offset
 
-    glass_thickness = 0.01 * si_conversion
+    glass_thickness = 0.01
 
     bm = bmesh.new()
     panel_schema = list(reversed(panel_schema))
@@ -349,8 +345,8 @@ def update_window_modifier_bmesh(context):
                 accumulated_width += panel_width
                 continue
 
-            frame_depth = props.frame_depth[panel_i] * si_conversion
-            frame_thickness = props.frame_thickness[panel_i] * si_conversion
+            frame_depth = props.frame_depth[panel_i]
+            frame_thickness = props.frame_thickness[panel_i]
 
             # add window
             window_lining_size = V(
@@ -456,13 +452,9 @@ class AddWindow(bpy.types.Operator, tool.Ifc.Operator):
             self.report({"ERROR"}, "Object has to be IfcWindow/IfcWindowType type to add a window.")
             return {"CANCELLED"}
 
-        # need to make sure all default props will have correct units
-        if not props.window_added_previously:
-            convert_property_group_from_si(props, skip_props=("is_editing", "window_type", "window_added_previously"))
-
-        window_data = props.get_general_kwargs()
-        lining_props = props.get_lining_kwargs()
-        panel_props = props.get_panel_kwargs()
+        window_data = props.get_general_kwargs(convert_to_project_units=True)
+        lining_props = props.get_lining_kwargs(convert_to_project_units=True)
+        panel_props = props.get_panel_kwargs(convert_to_project_units=True)
 
         window_data["lining_properties"] = lining_props
         window_data["panel_properties"] = panel_props
@@ -490,8 +482,7 @@ class CancelEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
         element = tool.Ifc.get_entity(obj)
         data = json.loads(ifcopenshell.util.element.get_pset(element, "BBIM_Window", "Data"))
         props = obj.BIMWindowProperties
-        for prop_name in data:
-            setattr(props, prop_name, data[prop_name])
+        props.set_props_kwargs_from_ifc_data(data)
 
         body = ifcopenshell.util.representation.get_representation(element, "Model", "Body", "MODEL_VIEW")
         blenderbim.core.geometry.switch_representation(
@@ -518,9 +509,9 @@ class FinishEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
         element = tool.Ifc.get_entity(obj)
         props = obj.BIMWindowProperties
 
-        window_data = props.get_general_kwargs()
-        lining_props = props.get_lining_kwargs()
-        panel_props = props.get_panel_kwargs()
+        window_data = props.get_general_kwargs(convert_to_project_units=True)
+        lining_props = props.get_lining_kwargs(convert_to_project_units=True)
+        panel_props = props.get_panel_kwargs(convert_to_project_units=True)
 
         window_data["lining_properties"] = lining_props
         window_data["panel_properties"] = panel_props
@@ -549,14 +540,7 @@ class EnableEditingWindow(bpy.types.Operator, tool.Ifc.Operator):
         data.update(data.pop("panel_properties"))
 
         # required since we could load pset from .ifc and BIMWindowProperties won't be set
-        for prop_name in data:
-            setattr(props, prop_name, data[prop_name])
-
-        # need to make sure all props that weren't used before
-        # will have correct units
-        skip_props = ("is_editing", "window_type", "window_added_previously")
-        skip_props += tuple(data.keys())
-        convert_property_group_from_si(props, skip_props=skip_props)
+        props.set_props_kwargs_from_ifc_data(data)
 
         props.is_editing = 1
         return {"FINISHED"}

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

@@ -44,6 +44,7 @@ class BimTool(WorkSpaceTool):
         # ("mesh.add_wall", {"type": 'LEFTMOUSE', "value": 'PRESS'}, {"properties": []}),
         # ("bim.sync_modeling", {"type": 'MOUSEMOVE', "value": 'ANY'}, {"properties": []}),
         ("bim.hotkey", {"type": "A", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_A")]}),
+        ("bim.hotkey", {"type": "B", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_B")]}),
         ("bim.hotkey", {"type": "C", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_C")]}),
         ("bim.hotkey", {"type": "E", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_E")]}),
         ("bim.hotkey", {"type": "F", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_F")]}),
@@ -57,6 +58,7 @@ class BimTool(WorkSpaceTool):
         ("bim.hotkey", {"type": "V", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_V")]}),
         ("bim.hotkey", {"type": "X", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_X")]}),
         ("bim.hotkey", {"type": "Y", "value": "PRESS", "shift": True}, {"properties": [("hotkey", "S_Y")]}),
+        ("bim.hotkey", {"type": "B", "value": "PRESS", "alt": True}, {"properties": [("hotkey", "A_B")]}),
         ("bim.hotkey", {"type": "D", "value": "PRESS", "alt": True}, {"properties": [("hotkey", "A_D")]}),
         ("bim.hotkey", {"type": "E", "value": "PRESS", "alt": True}, {"properties": [("hotkey", "A_E")]}),
         ("bim.hotkey", {"type": "O", "value": "PRESS", "alt": True}, {"properties": [("hotkey", "A_O")]}),
@@ -180,6 +182,7 @@ class BimToolUI:
             row.prop(data=cls.props, property="x_angle", text="X Angle")
             op = row.operator("bim.change_extrusion_x_angle", icon="FILE_REFRESH", text="")
             op.x_angle = cls.props.x_angle
+            
         elif AuthoringData.data["active_material_usage"] == "PROFILE":
             row = cls.layout.row(align=True)
             row.prop(data=cls.props, property="cardinal_point", text="Axis")
@@ -267,6 +270,12 @@ class BimToolUI:
             else:
                 row.operator("bim.show_openings", icon="HIDE_OFF", text="")
 
+        row = cls.layout.row(align=True)
+        row.label(text="", icon="EVENT_SHIFT")
+        row.label(text="", icon="EVENT_B")
+        row.prop(cls.props, "boundary_class", text="")
+        row.operator("bim.add_boundary", text="Add Boundary")
+
         cls.layout.row(align=True).label(text="Align")
         add_layout_hotkey_operator(cls.layout, "Align Exterior", "S_X", "")
         add_layout_hotkey_operator(cls.layout, "Align Centerline", "S_C", "")
@@ -274,11 +283,9 @@ class BimToolUI:
         add_layout_hotkey_operator(cls.layout, "Mirror", "S_M", bpy.ops.bim.mirror_elements.__doc__)
 
         cls.layout.row(align=True).label(text="Mode")
-        add_layout_hotkey_operator(cls.layout, "Void", "A_O", "Show / edit openings")
-        row = cls.layout.row(align=True)
-        row.label(text="", icon="EVENT_ALT")
-        row.label(text="", icon="EVENT_D")
-        row.operator("bim.hotkey", text="Decomposition").hotkey = "A_D"
+        add_layout_hotkey_operator(cls.layout, "Void", "A_O", "Toggle openings")
+        add_layout_hotkey_operator(cls.layout, "Decomposition", "A_D", "Select decomposition")
+        add_layout_hotkey_operator(cls.layout, "Boundaries", "A_B", "Toggle boundaries")
 
     @classmethod
     def draw_header_interface(cls):
@@ -316,15 +323,15 @@ class BimToolUI:
     def draw_basic_bim_tool_interface(cls):
         cls.draw_type_selection_interface()
 
-        if cls.props.ifc_class:
-            box = cls.layout.box()
-            if AuthoringData.data["type_thumbnail"]:
-                box.template_icon(icon_value=AuthoringData.data["type_thumbnail"], scale=5)
-            else:
-                op = box.operator("bim.load_type_thumbnails", text="Load Thumbnails", icon="FILE_REFRESH")
-                op.ifc_class = cls.props.ifc_class
-
         if AuthoringData.data["ifc_classes"]:
+            if cls.props.ifc_class:
+                box = cls.layout.box()
+                if AuthoringData.data["type_thumbnail"]:
+                    box.template_icon(icon_value=AuthoringData.data["type_thumbnail"], scale=5)
+                else:
+                    op = box.operator("bim.load_type_thumbnails", text="Load Thumbnails", icon="FILE_REFRESH")
+                    op.ifc_class = cls.props.ifc_class
+
             row = cls.layout.row(align=True)
             row.label(text="", icon="EVENT_SHIFT")
             row.label(text="", icon="EVENT_A")
@@ -571,6 +578,9 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
         elif self.active_material_usage == "PROFILE":
             bpy.ops.bim.extend_profile(join_type="V")
 
+    def hotkey_S_B(self):
+        bpy.ops.bim.add_boundary()
+
     def hotkey_S_O(self):
         if len(bpy.context.selected_objects) == 2:
             bpy.ops.bim.add_opening()
@@ -581,6 +591,14 @@ class Hotkey(bpy.types.Operator, tool.Ifc.Operator):
             self.props.y = self.y
             self.props.z = self.z
 
+    def hotkey_A_B(self):
+        if not bpy.context.selected_objects:
+            return
+        if AuthoringData.data["has_visible_boundaries"]:
+            bpy.ops.bim.hide_boundaries()
+        else:
+            bpy.ops.bim.show_boundaries()
+
     def hotkey_A_D(self):
         if not bpy.context.selected_objects:
             return

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

@@ -136,6 +136,7 @@ class EnableEditingArbitraryProfile(bpy.types.Operator, tool.Ifc.Operator):
         props = context.scene.BIMProfileProperties
         profile = tool.Ifc.get().by_id(props.active_profile_id)
         obj = tool.Model.import_profile(profile)
+        tool.Ifc.link(profile, obj)
         bpy.context.scene.collection.objects.link(obj)
         bpy.context.view_layer.objects.active = obj
         bpy.ops.object.mode_set(mode="EDIT")

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

@@ -49,9 +49,12 @@ classes = (
     operator.DisableEditingResourceCostValue,
     operator.CalculateResourceWork,
     operator.ImportResources,
+    operator.EditProductivityData,
     prop.Resource,
     prop.BIMResourceProperties,
     prop.BIMResourceTreeProperties,
+    prop.ISODuration,
+    prop.BIMResourceProductivity,
     ui.BIM_PT_resources,
     ui.BIM_UL_resources,
 )
@@ -60,8 +63,10 @@ classes = (
 def register():
     bpy.types.Scene.BIMResourceProperties = bpy.props.PointerProperty(type=prop.BIMResourceProperties)
     bpy.types.Scene.BIMResourceTreeProperties = bpy.props.PointerProperty(type=prop.BIMResourceTreeProperties)
+    bpy.types.Scene.BIMResourceProductivity = bpy.props.PointerProperty(type=prop.BIMResourceProductivity)
 
 
 def unregister():
     del bpy.types.Scene.BIMResourceProperties
     del bpy.types.Scene.BIMResourceTreeProperties
+    del bpy.types.Scene.BIMResourceProductivity

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

@@ -52,9 +52,25 @@ class ResourceData:
             if resource.BaseQuantity:
                 base_quantity = resource.BaseQuantity.get_info()
                 del base_quantity["Unit"]
-            results[resource.id()] = {"type": resource.is_a(), "BaseQuantity": base_quantity}
+            results[resource.id()] = {
+                "type": resource.is_a(),
+                "BaseQuantity": base_quantity,
+            }
+            if resource.is_a() in ["IfcLaborResource", "IfcConstructionEquipmentResource"]:
+                results[resource.id()]["Productivity"] = {}
+                productivity = cls.get_productivity(resource)
+                if productivity:
+                    results[resource.id()]["Productivity"] = {
+                        "QuantityProduced": ifcopenshell.util.resource.get_quantity_produced(productivity),
+                        "TimeConsumed": ifcopenshell.util.resource.get_unit_consumed(productivity),
+                        "QuantityProducedName": ifcopenshell.util.resource.get_quantity_produced_name(productivity),
+                    }
         return results
 
+    @classmethod
+    def get_productivity(cls, resource):
+        return ifcopenshell.util.resource.get_productivity(resource, should_inherit=False)
+
     @classmethod
     def cost_values(cls):
         results = []

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

@@ -346,3 +346,13 @@ class ImportResources(bpy.types.Operator, tool.Ifc.Operator, ImportHelper):
 
     def _execute(self, context):
         core.import_resources(tool.Resource, file_path=self.filepath)
+
+
+class EditProductivityData(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.edit_productivity_data"
+    bl_description = "Apply"
+    bl_label = "Edit Productivity"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def _execute(self, context):
+        core.edit_productivity_pset(tool.Ifc, tool.Resource)

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

@@ -18,7 +18,9 @@
 
 import bpy
 import ifcopenshell.api
+import ifcopenshell.util.resource
 from blenderbim.bim.ifc import IfcStore
+import blenderbim.tool as tool
 import blenderbim.bim.module.pset.data
 from blenderbim.bim.prop import StrProperty, Attribute
 from bpy.types import PropertyGroup
@@ -44,13 +46,12 @@ def purge():
 
 def updateResourceName(self, context):
     props = context.scene.BIMResourceProperties
-    if not props.is_resource_update_enabled or self.name == "Unnamed":
+    if not props.is_resource_update_enabled:
         return
-    self.file = IfcStore.get_file()
-    ifcopenshell.api.run(
+    tool.Ifc.run(
         "resource.edit_resource",
-        self.file,
-        **{"resource": self.file.by_id(self.ifc_definition_id), "attributes": {"Name": self.name}},
+        resource=tool.Ifc.get().by_id(self.ifc_definition_id),
+        attributes={"Name": self.name},
     )
     if props.active_resource_id == self.ifc_definition_id:
         attribute = props.resource_attributes.get("Name")
@@ -71,12 +72,42 @@ def get_quantity_types(self, context):
 
 def update_active_resource_index(self, context):
     blenderbim.bim.module.pset.data.refresh()
+    if self.should_show_productivity:
+        tool.Resource.load_productivity_data()
+
+
+def updateResourceUsage(self, context):
+    props = context.scene.BIMResourceProperties
+    if not props.is_resource_update_enabled:
+        return
+
+    if self.schedule_usage == "":
+        return
+    resource = tool.Ifc.get().by_id(self.ifc_definition_id)
+    if not resource.Usage:
+        tool.Ifc.run(
+            "resource.add_resource_time",
+            resource=resource,
+        )
+    resource.Usage.ScheduleUsage = self.schedule_usage
+    blenderbim.bim.module.pset.data.refresh()
+    tool.Resource.load_resource_properties()
+
+
+class ISODuration(PropertyGroup):
+    name: StringProperty(name="Name")
+    years: IntProperty(name="Years", default=0)
+    months: IntProperty(name="Months", default=0)
+    days: IntProperty(name="Days", default=0)
+    hours: IntProperty(name="Hours", default=0)
+    minutes: IntProperty(name="Minutes", default=0)
+    seconds: IntProperty(name="Seconds", default=0)
 
 
 class Resource(PropertyGroup):
     name: StringProperty(name="Name", update=updateResourceName)
     ifc_definition_id: IntProperty(name="IFC Definition ID")
-    schedule_usage: FloatProperty(name="Schedule Usage")
+    schedule_usage: FloatProperty(name="Schedule Usage", update=updateResourceUsage)
     has_children: BoolProperty(name="Has Children")
     is_expanded: BoolProperty(name="Is Expanded")
     level_index: IntProperty(name="Level Index")
@@ -113,3 +144,11 @@ class BIMResourceProperties(PropertyGroup):
     quantity_types: EnumProperty(items=get_quantity_types, name="Quantity Types")
     is_editing_quantity: BoolProperty(name="Is Editing Quantity")
     quantity_attributes: CollectionProperty(name="Quantity Attributes", type=Attribute)
+    should_show_productivity: BoolProperty(name="Edit Productivity", update=update_active_resource_index)
+
+
+class BIMResourceProductivity(PropertyGroup):
+    ifc_definition_id: IntProperty(name="IFC Definition ID")
+    quantity_consumed: CollectionProperty(name="Duration", type=ISODuration)
+    quantity_produced: FloatProperty(name="Quantity Produced")
+    quantity_produced_name: StringProperty(name="Quantity Produced Name")

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

@@ -65,7 +65,11 @@ class BIM_PT_resources(Panel):
             self.props,
             "active_resource_index",
         )
-
+        row = self.layout.row(align=True)
+        row.alignment = "RIGHT"
+        row.prop(self.props, "should_show_productivity", icon="RECOVER_LAST")
+        if self.props.should_show_productivity:
+            self.draw_productivity_ui(context)
         if self.props.active_resource_id and self.props.editing_resource_type == "ATTRIBUTES":
             self.draw_editable_resource_attributes_ui()
         elif self.props.active_resource_id and self.props.editing_resource_type == "QUANTITY":
@@ -75,6 +79,45 @@ class BIM_PT_resources(Panel):
         elif self.props.active_resource_id and self.props.editing_resource_type == "USAGE":
             self.draw_editable_resource_time_attributes_ui()
 
+    def draw_productivity_ui(self, context):
+        total_resources = len(self.tprops.resources)
+        if not total_resources or self.props.active_resource_index >= total_resources:
+            return
+
+        ifc_definition_id = self.tprops.resources[self.props.active_resource_index].ifc_definition_id
+        resource = ResourceData.data["resources"][ifc_definition_id]
+
+        if not resource["type"] in ["IfcConstructionEquipmentResource", "IfcLaborResource"]:
+            row = self.layout.row(align=True)
+            row.label(text="Resource type cannot have productivity data", icon="ERROR")
+            return
+
+        self.productivity_props = context.scene.BIMResourceProductivity
+
+        if resource["Productivity"]:
+            produtivitiy_rate_message = "Current Rate: {}/{}".format(
+                resource["Productivity"]["QuantityProduced"], resource["Productivity"]["TimeConsumed"]
+            )
+            row = self.layout.row()
+            row.alignment = "LEFT"
+            row.label(text=produtivitiy_rate_message, icon="ARMATURE_DATA")
+        else:
+            row = self.layout.row(align=True)
+            row.alignment = "LEFT"
+            produtivitiy_rate_message = "No productivity data found"
+            row.label(text=produtivitiy_rate_message, icon="ARMATURE_DATA")
+
+        row = self.layout.row(align=True)
+        row.alignment = "RIGHT"
+        row.prop(self.productivity_props, "quantity_produced", text="Quantity Produced")
+        row.prop(self.productivity_props, "quantity_produced_name", text="Quantity Name")
+        row = self.layout.row()
+        row.alignment = "RIGHT"
+        self.draw_duration_property(self.productivity_props.quantity_consumed, row)
+        row = self.layout.row()
+        row.alignment = "RIGHT"
+        row.operator("bim.edit_productivity_data", text="Apply", icon="CHECKMARK")
+
     def draw_resource_operators(self):
         row = self.layout.row(align=True)
         op = row.operator("bim.add_resource", text="Add SubContract", icon="TEXT")
@@ -111,8 +154,9 @@ class BIM_PT_resources(Panel):
 
         if not self.props.active_resource_id:
             if resource["type"] in ["IfcLaborResource", "IfcConstructionEquipmentResource"]:
-                op = row.operator("bim.calculate_resource_work", text="", icon="TEMP")
-                op.resource = ifc_definition_id
+                if resource["Productivity"]:
+                    op = row.operator("bim.calculate_resource_work", text="", icon="TEMP")
+                    op.resource = ifc_definition_id
                 row.operator("bim.enable_editing_resource_time", text="", icon="TIME").resource = ifc_definition_id
             op = row.operator("bim.enable_editing_resource_base_quantity", text="", icon="PROPERTIES")
             op.resource = ifc_definition_id
@@ -204,10 +248,20 @@ class BIM_PT_resources(Panel):
             op.parent = parent_id
             op.cost_value = cost_value_id
 
+    def draw_duration_property(self, duration_props, layout):
+        for duration_prop in duration_props:
+            if duration_prop.name == "BaseQuantityConsumed":
+                layout.label(text=duration_prop.name)
+                layout.prop(duration_prop, "years", text="Y")
+                layout.prop(duration_prop, "months", text="M")
+                layout.prop(duration_prop, "days", text="D")
+                layout.prop(duration_prop, "hours", text="H")
+                layout.prop(duration_prop, "minutes", text="Min")
+                layout.prop(duration_prop, "seconds", text="S")
+
 
 class BIM_UL_resources(UIList):
     def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
-        resource = ResourceData.data["resources"][item.ifc_definition_id]
         icon_map = {
             "IfcSubContractResource": "TEXT",
             "IfcCrewResource": "COMMUNITY",
@@ -217,6 +271,7 @@ class BIM_UL_resources(UIList):
             "IfcConstructionProductResource": "PACKAGE",
         }
         if item:
+            resource = ResourceData.data["resources"][item.ifc_definition_id]
             props = context.scene.BIMResourceProperties
             row = layout.row(align=True)
             for i in range(0, item.level_index):

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

@@ -97,8 +97,11 @@ classes = (
     operator.RemoveWorkPlan,
     operator.RemoveWorkSchedule,
     operator.RemoveWorkTime,
+    operator.ReorderTask,
     operator.SelectTaskRelatedProducts,
     operator.SelectTaskRelatedInputs,
+    operator.SelectWorkScheduleProducts,
+    operator.SelectUnassignedWorkScheduleProducts,
     operator.SetTaskSortColumn,
     operator.SetupDefaultTaskColumns,
     operator.UnassignLagTime,
@@ -114,6 +117,7 @@ classes = (
     operator.DisableEditingTaskAnimationColors,
     operator.LoadProductTasks,
     operator.HighlightTask,
+    operator.CreateBaseline,
     prop.WorkPlan,
     prop.BIMWorkPlanProperties,
     prop.Task,

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

@@ -19,12 +19,15 @@
 import bpy
 import blenderbim.tool as tool
 import ifcopenshell
+from ifcopenshell.util.doc import get_predefined_type_doc
+import ifcopenshell.util.date as dateutil
 
 
 def refresh():
     SequenceData.is_loaded = False
     WorkPlansData.is_loaded = False
     TaskICOMData.is_loaded = False
+    WorkScheduleData.is_loaded = False
 
 
 class SequenceData:
@@ -34,6 +37,7 @@ class SequenceData:
     @classmethod
     def load(cls):
         cls.data = {
+            "predefined_types": cls.get_work_schedule_types(),
             "has_work_plans": cls.has_work_plans(),
             "has_work_schedules": cls.has_work_schedules(),
             "has_work_calendars": cls.has_work_calendars(),
@@ -221,8 +225,66 @@ class SequenceData:
                 if rel.is_a("IfcRelAssignsToControl") and rel.RelatingControl:
                     if rel.RelatingControl.is_a("IfcWorkCalendar"):
                         data["HasAssignmentsWorkCalendar"].append(rel.RelatingControl.id())
+            data["NestingIndex"] = None
+            for rel in task.Nests or []:
+                data["NestingIndex"] = rel.RelatedObjects.index(task)
             cls.data["tasks"][task.id()] = data
 
+    @classmethod
+    def get_work_schedule_types(cls):
+        results = []
+        declaration = tool.Ifc().schema().declaration_by_name("IfcWorkSchedule")
+        version = tool.Ifc.get_schema()
+        for attribute in declaration.attributes():
+            if attribute.name() == "PredefinedType":
+                results.extend(
+                    [
+                        (e, e, get_predefined_type_doc(version, "IfcWorkSchedule", e))
+                        for e in attribute.type_of_attribute().declared_type().enumeration_items()
+                    ]
+                )
+                break
+        return results
+
+
+class WorkScheduleData:
+    data = {}
+    is_loaded = False
+
+    @classmethod
+    def load(cls):
+        cls.data = {
+            "can_have_baselines": cls.can_have_baselines(),
+            "active_work_schedule_baselines": cls.active_work_schedule_baselines(),
+        }
+        cls.is_loaded = True
+
+    @classmethod
+    def can_have_baselines(cls):
+        if not bpy.context.scene.BIMWorkScheduleProperties.active_work_schedule_id:
+            return False
+        return (
+            tool.Ifc.get().by_id(bpy.context.scene.BIMWorkScheduleProperties.active_work_schedule_id).PredefinedType
+            == "PLANNED"
+        )
+
+    @classmethod
+    def active_work_schedule_baselines(cls):
+        results = []
+        if not bpy.context.scene.BIMWorkScheduleProperties.active_work_schedule_id:
+            return []
+        for rel in tool.Ifc.get().by_id(bpy.context.scene.BIMWorkScheduleProperties.active_work_schedule_id).Declares:
+            for work_schedule in rel.RelatedObjects:
+                if work_schedule.PredefinedType == "BASELINE":
+                    results.append(
+                        {
+                            "id": work_schedule.id(),
+                            "name": work_schedule.Name or "Unnamed",
+                            "date": str(dateutil.ifc2datetime(work_schedule.CreationDate)),
+                        }
+                    )
+        return results
+
 
 class WorkPlansData:
     data = {}

src/blenderbim/blenderbim/bim/module/sequence/gantt/index.js

@@ -0,0 +1,112 @@
+let g;
+
+function create_gantt_chart(json_data) {
+    g = new JSGantt.GanttChart(document.getElementById('GanttChartDIV'), 'week');
+    g.setOptions({
+        vCaptionType: 'Caption',  // Set to Show Caption : None,Caption,Resource,Duration,Complete,
+        vQuarterColWidth: 36,
+        vDateTaskDisplayFormat: 'day dd month yyyy', // Shown in tool tip box
+        vDayMajorDateDisplayFormat: 'mon yyyy - Week ww',// Set format to dates in the "Major" header of the "Day" view
+        vWeekMinorDateDisplayFormat: 'dd mon', // Set format to display dates in the "Minor" header of the "Week" view
+        vLang: "en",
+        vShowTaskInfoLink: 1, // Show link in tool tip (0/1)
+        vShowEndWeekDate: 0,  // Show/Hide the date for the last day of the week in header for daily
+        vUseSingleCell: 10000, // Set the threshold cell per table row (Helps performance for large data.
+        vFormatArr: ['Day', 'Week', 'Month', 'Quarter'], // Even with setUseSingleCell using Hour format on such a large chart can cause issues in some browsers,
+        vShowRes: true, // Disable the resource column.
+        vShowComp: false, // Disable the completion column.
+        vShowDur: false, // Disable the duration column, because jsgantt doesn't calculate durations the way we want.
+        vAdditionalHeaders: {ifcduration: {title: 'Duration'}, "resourceUsage": {title: 'Resource Usage'}},
+        vUseToolTip: true, // Disable tooltips.
+        vTooltipTemplate: generateTooltip,
+        vTotalHeight: 900,
+    });
+    JSGantt.parseJSONString(json_data, g);
+    g.Draw();
+}
+
+function set_language(e){
+    lang = e && e.target ? e.target.value : "en";
+    g.setOptions({
+        vLang: lang,
+    });
+    g.Draw();
+}
+
+function generateTooltip(task) {
+    var dataObject = task.getDataObject();
+    var numberResources = dataObject.resourceUsage ? dataObject.resourceUsage : "NULL"; ;
+    return `
+    <dl>
+        <dt>Name:</dt><dd>{{pName}}</dd>
+        <dt>Start:</dt><dd>{{pStart}}</dd>
+        <dt>End:</dt><dd>{{pEnd}}</dd>
+        <dt>Duration:</dt><dd>${dataObject.ifcduration}</dd>
+        <dt>Number of Resources:</dt><dd>${numberResources}</dd>
+        <dt>Resources:</dt><dd>{{pRes}}</dd>
+    </dl>
+    `;
+}
+
+function draw_table(json_object){
+    let table = document.createElement("table");
+    table.classList.add("table-description");
+    for (let key in json_object){
+        let row = document.createElement("tr");
+        let key_cell = document.createElement("td");
+        let key_text = document.createTextNode(key);
+        key_cell.appendChild(key_text);
+        row.appendChild(key_cell);
+        let value_cell = document.createElement("td");
+        let value_text = document.createTextNode(json_object[key]);
+        value_cell.appendChild(value_text);
+        row.appendChild(value_cell);
+        table.appendChild(row);
+    }
+    return table;
+}
+
+function setupPage(workScheduleData){
+    workScheduleData = JSON.parse(workScheduleData);
+    let print_button = document.createElement("button");
+    print_button.id = "print-schedule";
+    print_button.innerHTML = "Print";
+    print_button.addEventListener("click", function(){
+        g.setTotalHeight("");
+        g.Draw();
+        var values = document.getElementById("print_page_size").value.split(",")
+        let css = 
+            "@media print {\n        @page {\n          size: " + values[0] + "mm " + values[1] + "mm;\n        }\n";
+        g.printChart(values[0], values[1], css);
+        g.setTotalHeight(900);
+        g.Draw();
+    });
+    document.getElementById("print_options").appendChild(print_button);
+
+    let table = draw_table(workScheduleData)
+    document.getElementById("schedule-data").appendChild(table);
+    table.style.display = "none";
+    let toggle_button = document.createElement("button");
+    toggle_button.id = "toggle-table";
+    toggle_button.innerHTML = "Show Schedule Information";
+    toggle_button.onclick = function(){
+        if (table.style.display === "none"){
+            table.style.display = "table";
+            toggle_button.innerHTML = "Hide Schedule Information";
+        } else {
+            toggle_button.innerHTML = "Show Schedule Information";
+            table.style.display = "none";
+        }
+    }
+    document.getElementById("options").appendChild(toggle_button);
+
+    let schedule_name = document.createElement("h2");
+    let schedule_name_string = document.createTextNode("Schedule: " + workScheduleData.Name);
+    schedule_name.appendChild(schedule_name_string);
+    document.getElementById("schedule-header").appendChild(schedule_name);
+
+    let creation_date = document.createElement("h2");
+    let creation_date_string = document.createTextNode("Created: " + new Date(workScheduleData.CreationDate).toLocaleDateString());
+    creation_date.appendChild(creation_date_string);
+    document.getElementById("schedule-header").appendChild(creation_date);
+}

src/blenderbim/blenderbim/bim/module/sequence/gantt/main.css

@@ -0,0 +1,172 @@
+.gtaskcellwkend,
+.gtaskcellcurrent,
+.gminorheadingwkend {
+  background-color: #e1e1e1;
+}
+
+.gitemhighlight td {
+  background-color: #ffdaaa;
+}
+
+.gtaskblue {
+  background: #4281A4;
+}
+
+.gtaskred {
+  background: #C1666B;
+}
+
+.gtaskgreen {
+  background: #48A9A6;
+}
+
+.gtaskyellow {
+  background: #D4B483;
+}
+
+.gname.ggroupitem {
+  background-color: #4c92ec;
+  font-weight: bold;
+}
+
+.gtaskcellwkend,
+.gtaskcellcurrent,
+.gminorheadingwkend {
+  background-color: #e1e1e1;
+}
+
+.gitemhighlight td {
+  background-color: #ffdaaa;
+}
+
+.gtaskblue {
+  background: #4281A4;
+}
+
+.gtaskred {
+  background: #C1666B;
+}
+
+.gtaskgreen {
+  background: #48A9A6;
+}
+
+.gtaskyellow {
+  background: #D4B483;
+}
+
+.gmainleft {
+  resize: horizontal;
+  height:100%;
+  /* flex: 0 1 auto; */
+}
+
+.gmainright {
+  height:100%;
+  overflow: auto;
+  font-size: 1.5rem;
+}
+
+.gcaption {
+  /* github style header 3 */
+  font-size: 0.75rem;
+  font-weight: 200;
+  line-height: 1.25;
+  color: black;
+}
+
+.gchartgrid {
+  background-color: transparent;
+  height: fit-content;
+}
+
+.gchartcontainer {
+  border: 1px solid #e1e1e1;
+  height: fit-content;
+}
+
+@media print {
+  .no-print {
+    display: none;
+  }
+}
+
+button, .sweet_button {
+  border: none;
+  background-color: #ffffff;
+  color: black;
+  padding: 0.5rem 1rem;
+  text-align: center;
+  text-decoration: none;
+  display: inline-block;
+  font-size: 1rem;
+  margin: 0.25rem 0.5rem;
+  cursor: pointer;
+  border-radius: 0.25rem;
+  /* add shadow */
+  box-shadow: 0 0 0.7rem rgba(95, 95, 95, 0.4);
+}
+
+h1 {
+  font-size: 2rem;
+  font-weight: 500;
+  line-height: 1.25;
+  color: black;
+  margin: 0.5rem;
+}
+h2 {
+  font-size: 1.5rem;
+  font-weight: 500;
+  line-height: 1.25;
+  color: black;
+  margin: 0.5rem;
+}
+
+h4 {
+  font-size: 1.2rem;
+  font-weight: 500;
+  line-height: 1.25;
+  color: black;
+  margin: 0.5rem;
+}
+
+.table-description {
+/* create a github style table similar to a wild car */
+  margin-bottom: 1rem;
+  width : 50%;
+  background-color: transparent;
+  border-collapse: collapse;
+  border-spacing: 0;
+  border-color: grey;
+  border: 1px solid #e1e1e1;
+  border-radius: 0.25rem;
+  box-shadow: 0 0 0.7rem rgba(95, 95, 95, 0.4);
+  text-align: center;
+}
+
+.table-description tr {
+  display: table-row;
+  vertical-align: inherit;
+  border-color: inherit;
+  border-bottom: 1px solid #e1e1e1;
+}
+
+.table-description thead {
+  display: table-header-group;
+  vertical-align: middle;
+  border-color: inherit;
+  background-color: #95A5A6;
+}
+
+.top-right {
+  position: absolute;
+  top: 8px;
+  right: 16px;
+}
+
+#schedule-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 1rem;
+}

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

@@ -18,7 +18,7 @@
 
 import isodate
 from dateutil import parser
-import ifcopenshell.util.date as ifcdateutils
+import ifcopenshell.util.date
 from datetime import timedelta
 
 
@@ -33,11 +33,7 @@ def parse_datetime(value):
 
 
 def parse_duration(value):
-    try:
-        return isodate.parse_duration(value)
-    except:
-        return None
-
+    return ifcopenshell.util.date.parse_duration(value)
 
 def canonicalise_time(time):
     if not time:
@@ -48,7 +44,7 @@ def canonicalise_time(time):
 def parse_duration_as_blender_props(dt, simplify=True):
     if simplify:
         if isinstance(dt, str):
-            dt = ifcdateutils.ifc2datetime(dt)
+            dt = ifcopenshell.util.date.ifc2datetime(dt)
 
         seconds = getattr(dt, "seconds", 0)
         hours, seconds = divmod(seconds, 3600)
@@ -66,10 +62,12 @@ def parse_duration_as_blender_props(dt, simplify=True):
         }
 
 
-def simplify_duration(durations_attributes, duration_type, prop_name):
-    for item in durations_attributes:
-        if item.name == prop_name:
-            duration_props = item
+def blender_props_to_iso_duration(durations_attributes, duration_type, prop_name):
+    duration_props = None
+    for collection in durations_attributes:
+        if collection.name == prop_name:
+            duration_props = collection
+            break
     if duration_props and not duration_type or duration_type == "ELAPSEDTIME":
         duration_string = "P{}Y{}M{}DT{}H{}M{}S".format(
             duration_props.years if duration_props.years else 0,
@@ -79,7 +77,7 @@ def simplify_duration(durations_attributes, duration_type, prop_name):
             duration_props.minutes if duration_props.minutes else 0,
             duration_props.seconds if duration_props.seconds else 0,
         )
-        duration_object = ifcdateutils.ifc2datetime(duration_string)
+        duration_object = ifcopenshell.util.date.ifc2datetime(duration_string)
     elif duration_props and duration_type == "WORKTIME":
         years = (duration_props.years * 365 * 24 * 60 * 60) if duration_props.years else 0
         months = (duration_props.months * 30 * 24 * 60 * 60) if duration_props.months else 0
@@ -96,6 +94,8 @@ def simplify_duration(durations_attributes, duration_type, prop_name):
         extra_days, seconds_left = divmod(total_seconds, calendar_seconds_per_day)
         total_days = days_subtotal + extra_days
         duration_object = timedelta(days=total_days, seconds=seconds_left)
+    else:
+        return None
     if duration_object:
         total_days = int(duration_object.days)
         seconds_left = int(duration_object.seconds)
@@ -113,12 +113,21 @@ def simplify_duration(durations_attributes, duration_type, prop_name):
 
         hours, seconds = divmod(seconds_left, 3600)
         minutes, seconds = divmod(seconds, 60)
-
-        return "P{}Y{}M{}DT{}H{}M{}S".format(
-            int(years),
-            int(months),
-            int(days),
-            int(hours),
-            int(minutes),
-            int(seconds),
-        )
+        if years > 0 or months > 0 or total_days > 0 or hours > 0 or minutes > 0 or seconds > 0:
+            duration_string = "P"
+            duration_string += "{}Y".format(int(years)) if years > 0 else ""
+            duration_string += "{}M".format(int(months)) if months > 0 else ""
+            duration_string += "{}D".format(int(total_days)) if total_days > 0 else ""
+            if hours > 0 or minutes > 0 or seconds > 0:
+                duration_string += "T"
+                if hours > 0:
+                    duration_string += "{}H".format(int(hours))
+                if minutes > 0:
+                    duration_string += "{}M".format(int(minutes))
+                if seconds > 0:
+                    duration_string += "{}S".format(int(seconds))
+            return duration_string
+        else:
+            return None
+    else:
+        return None

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

@@ -168,15 +168,14 @@ class EnableEditingWorkSchedule(bpy.types.Operator):
         return {"FINISHED"}
 
 
-class EnableEditingWorkScheduleTasks(bpy.types.Operator):
+class EnableEditingWorkScheduleTasks(bpy.types.Operator, tool.Ifc.Operator):
     bl_idname = "bim.enable_editing_work_schedule_tasks"
     bl_label = "Enable Editing Work Schedule Tasks"
     bl_options = {"REGISTER", "UNDO"}
     work_schedule: bpy.props.IntProperty()
 
-    def execute(self, context):
+    def _execute(self, context):
         core.enable_editing_work_schedule_tasks(tool.Sequence, work_schedule=tool.Ifc.get().by_id(self.work_schedule))
-        return {"FINISHED"}
 
 
 class LoadTaskProperties(bpy.types.Operator):
@@ -275,13 +274,13 @@ class EditTaskTime(bpy.types.Operator, tool.Ifc.Operator):
 
 
 class EnableEditingTask(bpy.types.Operator):
-    bl_idname = "bim.enable_editing_task"
-    bl_label = "Enable Editing Task"
+    bl_idname = "bim.enable_editing_task_attributes"
+    bl_label = "Enable Editing Task Attributes"
     bl_options = {"REGISTER", "UNDO"}
     task: bpy.props.IntProperty()
 
     def execute(self, context):
-        core.enable_editing_task(tool.Sequence, task=tool.Ifc.get().by_id(self.task))
+        core.enable_editing_task_attributes(tool.Sequence, task=tool.Ifc.get().by_id(self.task))
         return {"FINISHED"}
 
 
@@ -1295,7 +1294,7 @@ class CopyTask(bpy.types.Operator, tool.Ifc.Operator):
 
 
 class LoadProductTasks(bpy.types.Operator):
-    bl_idname = "bim.load_product_tasks"
+    bl_idname = "bim.load_product_related_tasks"
     bl_label = "Load Product Tasks"
     bl_options = {"REGISTER", "UNDO"}
 
@@ -1310,7 +1309,7 @@ class LoadProductTasks(bpy.types.Operator):
         return True
 
     def execute(self, context):
-        core.load_product_tasks(
+        core.load_product_related_tasks(
             tool.Sequence, product=tool.Ifc.get().by_id(context.active_object.BIMObjectProperties.ifc_definition_id)
         )
         return {"FINISHED"}
@@ -1327,3 +1326,66 @@ class HighlightTask(bpy.types.Operator):
         if isinstance(r, str):
             self.report({"WARNING"}, r)
         return {"FINISHED"}
+
+
+class SelectWorkScheduleProducts(bpy.types.Operator):
+    bl_idname = "bim.select_work_schedule_products"
+    bl_label = "Select Work Schedule Products"
+    bl_options = {"REGISTER", "UNDO"}
+    work_schedule: bpy.props.IntProperty()
+
+    def execute(self, context):
+        r = core.select_work_schedule_products(
+            tool.Sequence, tool.Spatial, work_schedule=tool.Ifc.get().by_id(self.work_schedule)
+        )
+        if isinstance(r, str):
+            self.report({"WARNING"}, r)
+        return {"FINISHED"}
+
+
+class SelectUnassignedWorkScheduleProducts(bpy.types.Operator):
+    bl_idname = "bim.select_unassigned_work_schedule_products"
+    bl_label = "Select Unassigned Work Schedule Products"
+    bl_options = {"REGISTER", "UNDO"}
+    work_schedule: bpy.props.IntProperty()
+
+    def execute(self, context):
+        r = core.select_unassigned_work_schedule_products(tool.Ifc, tool.Sequence, tool.Spatial)
+        if isinstance(r, str):
+            self.report({"WARNING"}, r)
+        return {"FINISHED"}
+
+
+class ReorderTask(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.reorder_task_nesting"
+    bl_label = "Reorder Nesting"
+    bl_options = {"REGISTER", "UNDO"}
+    new_index: bpy.props.IntProperty()
+    task: bpy.props.IntProperty()
+
+    def _execute(self, context):
+        r = core.reorder_task_nesting(
+            tool.Ifc, tool.Sequence, task=tool.Ifc.get().by_id(self.task), new_index=self.new_index
+        )
+        if isinstance(r, str):
+            self.report({"WARNING"}, r)
+
+
+class CreateBaseline(bpy.types.Operator, tool.Ifc.Operator):
+    bl_idname = "bim.create_baseline"
+    bl_label = "Create Schedule Baseline"
+    bl_options = {"REGISTER", "UNDO"}
+    work_schedule: bpy.props.IntProperty()
+    name: bpy.props.StringProperty()
+
+    def _execute(self, context):
+        core.create_baseline(
+            tool.Ifc, tool.Sequence, work_schedule=tool.Ifc.get().by_id(self.work_schedule), name=self.name
+        )
+
+    def draw(self, context):
+        layout = self.layout
+        layout.prop(self, "name", text="Baseline Name")
+
+    def invoke(self, context, event):
+        return context.window_manager.invoke_props_dialog(self)

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

@@ -20,6 +20,8 @@ import bpy
 import isodate
 import ifcopenshell.api
 import ifcopenshell.util.attribute
+import blenderbim.tool as tool
+import blenderbim.core.sequence as core
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.module.sequence.data import SequenceData
 import blenderbim.bim.module.pset.data
@@ -37,7 +39,6 @@ from bpy.props import (
     CollectionProperty,
 )
 
-
 taskcolumns_enum = []
 tasktimecolumns_enum = []
 
@@ -108,7 +109,7 @@ def updateTaskName(self, context):
     props = context.scene.BIMWorkScheduleProperties
     if not props.is_task_update_enabled or self.name == "Unnamed":
         return
-    self.file = IfcStore.get_file()
+    self.file = tool.Ifc.get()
     ifcopenshell.api.run(
         "sequence.edit_task",
         self.file,
@@ -124,7 +125,7 @@ def updateTaskIdentification(self, context):
     props = context.scene.BIMWorkScheduleProperties
     if not props.is_task_update_enabled or self.identification == "XXX":
         return
-    self.file = IfcStore.get_file()
+    self.file = tool.Ifc.get()
     ifcopenshell.api.run(
         "sequence.edit_task",
         self.file,
@@ -160,7 +161,7 @@ def updateTaskTimeDateTime(self, context, startfinish):
     if startfinish_value == "-":
         return
 
-    self.file = IfcStore.get_file()
+    self.file = tool.Ifc.get()
 
     try:
         startfinish_datetime = parser.isoparse(startfinish_value)
@@ -202,32 +203,32 @@ def updateTaskDuration(self, context):
     if self.duration == "-":
         return
 
-    try:
-        isodate.parse_duration(self.duration),
-    except:
+    duration = ifcopenshell.util.date.parse_duration(self.duration)
+    if not duration:
         self.duration = "-"
         return
 
-    self.file = IfcStore.get_file()
+    self.file = tool.Ifc.get()
     task = self.file.by_id(self.ifc_definition_id)
     if task.TaskTime:
         task_time = task.TaskTime
     else:
         task_time = ifcopenshell.api.run("sequence.add_task_time", self.file, task=task)
-        SequenceData.load()
     ifcopenshell.api.run(
         "sequence.edit_task_time",
         self.file,
-        **{"task_time": task_time, "attributes": {"ScheduleDuration": self.duration}},
+        **{"task_time": task_time, "attributes": {"ScheduleDuration": duration}},
     )
     SequenceData.load()
-    if props.active_task_id == self.ifc_definition_id:
-        attribute = props.task_time_attributes.get("Duration")
-        if attribute:
-            attribute.string_value = self.duration
     bpy.ops.bim.load_task_properties()
 
 
+def get_schedule_predefined_types(self, context):
+    if not SequenceData.is_loaded:
+        SequenceData.load()
+    return SequenceData.data["predefined_types"]
+
+
 def update_visualisation_start(self, context):
     update_visualisation_start_finish(self, context, "visualisation_start")
 
@@ -278,6 +279,14 @@ def update_color_progress(self, context):
         color[2] = color_progress.b
 
 
+def update_sort_reversed(self, context):
+    if context.scene.BIMWorkScheduleProperties.active_work_schedule_id:
+        core.load_task_tree(
+            tool.Sequence,
+            work_schedule=tool.Ifc.get().by_id(context.scene.BIMWorkScheduleProperties.active_work_schedule_id),
+        )
+
+
 class Task(PropertyGroup):
     name: StringProperty(name="Name", update=updateTaskName)
     identification: StringProperty(name="Identification", update=updateTaskIdentification)
@@ -335,6 +344,9 @@ class ISODuration(PropertyGroup):
 
 
 class BIMWorkScheduleProperties(PropertyGroup):
+    work_schedule_predefined_types: EnumProperty(
+        items=get_schedule_predefined_types, name="Predefined Type", default=None
+    )
     durations_attributes: CollectionProperty(name="Durations Attributes", type=ISODuration)
     work_calendars: EnumProperty(items=getWorkCalendars, name="Work Calendars")
     work_schedule_attributes: CollectionProperty(name="Work Schedule Attributes", type=Attribute)
@@ -346,12 +358,13 @@ class BIMWorkScheduleProperties(PropertyGroup):
     active_task_id: IntProperty(name="Active Task Id")
     task_attributes: CollectionProperty(name="Task Attributes", type=Attribute)
     should_show_visualisation_ui: BoolProperty(name="Should Show Visualisation UI", default=False)
-    should_show_bar_visual_option: BoolProperty(name="Should Show Settings UI", default=False)
+    should_show_task_bar_selection: BoolProperty(name="Add to task bar", default=False)
+    should_show_snapshot_ui: BoolProperty(name="Should Show Snapshot UI", default=False)
     should_show_column_ui: BoolProperty(name="Should Show Column UI", default=False)
     columns: CollectionProperty(name="Columns", type=Attribute)
     active_column_index: IntProperty(name="Active Column Index")
     sort_column: StringProperty(name="Sort Column")
-    is_sort_reversed: BoolProperty(name="Is Sort Reversed")
+    is_sort_reversed: BoolProperty(name="Is Sort Reversed", update=update_sort_reversed)
     column_types: EnumProperty(
         items=[
             ("IfcTask", "IfcTask", ""),
@@ -404,6 +417,10 @@ class BIMWorkScheduleProperties(PropertyGroup):
     product_output_tasks: CollectionProperty(name="Product Task Outputs", type=TaskProduct)
     active_product_output_task_index: IntProperty(name="Active Product Output Task Index")
     active_product_input_task_index: IntProperty(name="Active Product Input Task Index")
+    enable_reorder: BoolProperty(name="Enable Reorder", default=False)
+    show_task_operators: BoolProperty(name="Show Task Options", default=True)
+    should_show_schedule_baseline_ui: BoolProperty(name="Baselines", default=False)
+    filter_by_active_schedule: BoolProperty(name="Filter By Active Schedule", default=False)
 
 
 class BIMTaskTreeProperties(PropertyGroup):
@@ -501,3 +518,4 @@ class BIMAnimationProperties(PropertyGroup):
         description="color picker",
         update=update_color_progress,
     )
+    should_show_task_bar_options: BoolProperty(name="Show Task Bar Options", default=False)

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

@@ -21,7 +21,7 @@ import blenderbim.bim.helper
 from bpy.types import Panel, UIList
 from blenderbim.bim.ifc import IfcStore
 from blenderbim.bim.helper import draw_attributes
-from blenderbim.bim.module.sequence.data import WorkPlansData, SequenceData, TaskICOMData
+from blenderbim.bim.module.sequence.data import WorkPlansData, WorkScheduleData, SequenceData, TaskICOMData
 
 
 class BIM_PT_work_plans(Panel):
@@ -113,55 +113,101 @@ class BIM_PT_work_schedules(Panel):
     def draw(self, context):
         if not SequenceData.is_loaded:
             SequenceData.load()
+        if not WorkScheduleData.is_loaded:
+            WorkScheduleData.load()
         self.props = context.scene.BIMWorkScheduleProperties
         self.tprops = context.scene.BIMTaskTreeProperties
         self.animation_props = context.scene.BIMAnimationProperties
 
-        row = self.layout.row()
-        if SequenceData.data["has_work_schedules"]:
-            row.label(
-                text="{} Work Schedules Found".format(SequenceData.data["number_of_work_schedules_loaded"]),
-                icon="TEXT",
-            )
-        else:
-            row.label(text="No Work Schedules found.", icon="TEXT")
-        row.operator("bim.add_work_schedule", text="", icon="ADD")
+        if not self.props.active_work_schedule_id:
+            row = self.layout.row()
+            if SequenceData.data["has_work_schedules"]:
+                row.label(
+                    text="{} Work Schedules Found".format(SequenceData.data["number_of_work_schedules_loaded"]),
+                    icon="TEXT",
+                )
+            else:
+                row.label(text="No Work Schedules found.", icon="TEXT")
+            row = self.layout.row(align=True)
+            row.alignment = "RIGHT"
+            row.prop(self.props, "work_schedule_predefined_types")
+            row.operator("bim.add_work_schedule", text="Add new", icon="ADD")
 
         for work_schedule_id, work_schedule in SequenceData.data["work_schedules"].items():
+
             self.draw_work_schedule_ui(work_schedule_id, work_schedule)
 
     def draw_work_schedule_ui(self, work_schedule_id, work_schedule):
-        row = self.layout.row(align=True)
-        row.label(text=work_schedule["Name"] or "Unnamed", icon="LINENUMBERS_ON")
+        if not work_schedule["PredefinedType"] == "BASELINE":
+            row = self.layout.row(align=True)
+            row.label(text=work_schedule["Name"] or "Unnamed", icon="LINENUMBERS_ON")
+            if self.props.active_work_schedule_id == work_schedule_id:
+                if self.props.editing_type == "WORK_SCHEDULE":
+                    row.operator("bim.edit_work_schedule", text="", icon="CHECKMARK")
+                elif self.props.editing_type == "TASKS":
+                    grid = self.layout.grid_flow(columns=2, even_columns=True)
 
-        if self.props.active_work_schedule_id == work_schedule_id:
-            if self.props.editing_type == "WORK_SCHEDULE":
-                row.operator("bim.edit_work_schedule", text="", icon="CHECKMARK")
-            elif self.props.editing_type == "TASKS":
-                row.prop(self.props, "should_show_column_ui", text="", icon="SHORTDISPLAY")
-                row.prop(self.props, "should_show_visualisation_ui", text="", icon="CAMERA_STEREO")
-                row.operator("bim.generate_gantt_chart", text="", icon="NLA").work_schedule = work_schedule_id
-                row.operator("bim.recalculate_schedule", text="", icon="FILE_REFRESH").work_schedule = work_schedule_id
-                row.operator("bim.add_summary_task", text="", icon="ADD").work_schedule = work_schedule_id
-            row.operator("bim.disable_editing_work_schedule", text="", icon="CANCEL")
-        else:
-            row.operator(
-                "bim.enable_editing_work_schedule_tasks", text="", icon="ACTION"
-            ).work_schedule = work_schedule_id
-            row.operator(
-                "bim.enable_editing_work_schedule", text="", icon="GREASEPENCIL"
-            ).work_schedule = work_schedule_id
-            row.operator("bim.remove_work_schedule", text="", icon="X").work_schedule = work_schedule_id
+                    col = grid.column()
+                    row1 = col.row(align=True)
+                    row1.alignment = "LEFT"
+                    row1.label(text="Schedule tools")
+                    row1 = col.row(align=True)
+                    row1.alignment = "RIGHT"
+                    row1.operator(
+                        "bim.generate_gantt_chart", text="Generate Gantt", icon="NLA"
+                    ).work_schedule = work_schedule_id
+                    row1.operator(
+                        "bim.recalculate_schedule", text="Re-calculate Schedule", icon="FILE_REFRESH"
+                    ).work_schedule = work_schedule_id
+                    row2 = col.row(align=True)
+                    row2.alignment = "RIGHT"
+                    row2.operator(
+                        "bim.select_work_schedule_products", text="Select Assigned", icon="RESTRICT_SELECT_OFF"
+                    ).work_schedule = work_schedule_id
+                    row2.operator(
+                        "bim.select_unassigned_work_schedule_products",
+                        text="Select Unassigned",
+                        icon="RESTRICT_SELECT_OFF",
+                    ).work_schedule = work_schedule_id
+                    if WorkScheduleData.data["can_have_baselines"]:
+                        row3 = col.row()
+                        row3.alignment = "RIGHT"
+                        row3.prop(self.props, "should_show_schedule_baseline_ui", icon="RESTRICT_INSTANCED_OFF")
+                    col = grid.column()
+                    row1 = col.row(align=True)
+                    row1.alignment = "LEFT"
+                    row1.label(text="Settings")
+                    row1 = col.row(align=True)
+                    row1.alignment = "RIGHT"
+                    row1.prop(self.props, "should_show_column_ui", text="Schedule Columns", icon="SHORTDISPLAY")
+                    row2 = col.row(align=True)
+                    row2.prop(
+                        self.props, "should_show_visualisation_ui", text="Animation Options", icon="CAMERA_STEREO"
+                    )
+                    row2.prop(self.props, "should_show_snapshot_ui", text="Snapshot Options", icon="CAMERA_STEREO")
+                row.operator("bim.disable_editing_work_schedule", text="Disable editing", icon="CANCEL")
+            else:
+                row.operator(
+                    "bim.enable_editing_work_schedule_tasks", text="", icon="ACTION"
+                ).work_schedule = work_schedule_id
+                row.operator(
+                    "bim.enable_editing_work_schedule", text="", icon="GREASEPENCIL"
+                ).work_schedule = work_schedule_id
+                row.operator("bim.remove_work_schedule", text="", icon="X").work_schedule = work_schedule_id
 
-        if self.props.active_work_schedule_id == work_schedule_id:
-            if self.props.editing_type == "WORK_SCHEDULE":
-                self.draw_editable_work_schedule_ui()
-            elif self.props.editing_type == "TASKS":
-                if self.props.should_show_column_ui:
+            if self.props.active_work_schedule_id == work_schedule_id:
+                if self.props.editing_type == "WORK_SCHEDULE":
+                    self.draw_editable_work_schedule_ui()
+                elif self.props.editing_type == "TASKS":
+                    self.draw_baseline_ui(work_schedule_id)
                     self.draw_column_ui()
-                if self.props.should_show_visualisation_ui:
-                    self.draw_visualisation_ui()
-                self.draw_editable_task_ui(work_schedule_id)
+                    if self.props.should_show_visualisation_ui:
+                        self.draw_visualisation_ui()
+                    if self.props.should_show_snapshot_ui:
+                        self.draw_snapshot_ui()
+                    self.draw_editable_task_ui(work_schedule_id)
+        else:
+            self.draw_readonly_work_schedule_ui(work_schedule_id)
 
     def draw_task_operators(self):
         row = self.layout.row(align=True)
@@ -178,18 +224,30 @@ class BIM_PT_work_schedules(Panel):
                     row.operator("bim.edit_task", text="", icon="CHECKMARK")
                 row.operator("bim.disable_editing_task", text="", icon="CANCEL")
             else:
-                row.prop(self.props, "should_show_bar_visual_option", text="", icon="NLA_PUSHDOWN")
-                row.operator("bim.enable_editing_task_sequence", text="", icon="TRACKING").task = ifc_definition_id
-                row.operator("bim.enable_editing_task_time", text="", icon="TIME").task = ifc_definition_id
-                row.operator("bim.enable_editing_task_calendar", text="", icon="VIEW_ORTHO").task = ifc_definition_id
-                row.operator("bim.enable_editing_task", text="", icon="GREASEPENCIL").task = ifc_definition_id
-                row.operator("bim.add_task", text="", icon="ADD").task = ifc_definition_id
-                row.operator("bim.duplicate_task", text="", icon="DUPLICATE").task = ifc_definition_id
-                row.operator("bim.remove_task", text="", icon="X").task = ifc_definition_id
+                row.prop(self.props, "show_task_operators", text="Edit", icon="GREASEPENCIL")
+                if self.props.show_task_operators:
+                    row2 = self.layout.row(align=True)
+                    row2.alignment = "RIGHT"
+
+                    row2.prop(self.props, "enable_reorder", text="", icon="SORTALPHA")
+                    row2.operator("bim.enable_editing_task_sequence", text="", icon="TRACKING").task = ifc_definition_id
+                    row2.operator("bim.enable_editing_task_time", text="", icon="TIME").task = ifc_definition_id
+                    row2.operator(
+                        "bim.enable_editing_task_calendar", text="", icon="VIEW_ORTHO"
+                    ).task = ifc_definition_id
+                    row2.operator(
+                        "bim.enable_editing_task_attributes", text="", icon="GREASEPENCIL"
+                    ).task = ifc_definition_id
+                row.operator("bim.add_task", text="Add", icon="ADD").task = ifc_definition_id
+                row.operator("bim.duplicate_task", text="Copy", icon="DUPLICATE").task = ifc_definition_id
+                row.operator("bim.remove_task", text="Delete", icon="X").task = ifc_definition_id
 
     def draw_column_ui(self):
-        row = self.layout.row(align=True)
-        row.operator("bim.setup_default_task_columns", text="Show Default Columns", icon="ANCHOR_BOTTOM")
+        if not self.props.should_show_column_ui:
+            return
+        row = self.layout.row()
+        row.operator("bim.setup_default_task_columns", text="Add Default Columns", icon="ANCHOR_BOTTOM")
+        row.alignment = "RIGHT"
         row = self.layout.row(align=True)
         row.prop(self.props, "column_types", text="")
         column_type = self.props.column_types
@@ -226,7 +284,7 @@ class BIM_PT_work_schedules(Panel):
         op.work_schedule = self.props.active_work_schedule_id
 
         row = self.layout.row(align=True)
-        row.label(text="Animation Options")
+        row.label(text="Speed Settings")
         row = self.layout.row(align=True)
         row.prop(self.props, "speed_types", text="")
         if self.props.speed_types == "FRAME_SPEED":
@@ -237,21 +295,50 @@ class BIM_PT_work_schedules(Panel):
             row.prop(self.props, "speed_real_duration", text="")
         elif self.props.speed_types == "MULTIPLIER_SPEED":
             row.prop(self.props, "speed_multiplier", text="")
+        row = self.layout.row(align=True)
+        row.label(text="Display Settings")
+        row = self.layout.row(align=True)
         if not self.animation_props.is_editing:
             op = row.operator(
-                "bim.enable_editing_task_animation_colors", text="Customize Animation Colors", icon="SEQUENCE_COLOR_04"
+                "bim.enable_editing_task_animation_colors", text="Customize Object Colors", icon="SEQUENCE_COLOR_04"
             )
         else:
             op = row.operator(
-                "bim.disable_editing_task_animation_colors", text="Hide Animation Colors", icon="SEQUENCE_COLOR_01"
+                "bim.disable_editing_task_animation_colors", text="Hide Object Colors", icon="SEQUENCE_COLOR_01"
             )
 
+        row.prop(self.animation_props, "should_show_task_bar_options", text="Task Bar", icon="NLA_PUSHDOWN")
+        if self.animation_props.should_show_task_bar_options:
+            row = self.layout.row()
+            row.label(text="Task Bar Options", icon="NLA_PUSHDOWN")
+            row.alignment = "LEFT"
+            row = self.layout.row(align=True)
+            row.prop(self.props, "should_show_task_bar_selection", text="Enable Selection", icon="NLA_PUSHDOWN")
+            row.operator("bim.add_task_bars", text="Generate bars", icon="NLA_PUSHDOWN")
+
+            grid = self.layout.grid_flow(columns=2, even_columns=True)
+            # Column1
+            col = grid.column()
+
+            row = col.row(align=True)
+            row.prop(self.animation_props, "color_progress")
+
+            row = col.row(align=True)
+            row.prop(self.animation_props, "color_full")
+
         if self.animation_props.is_editing:
             self.draw_visualisation_settings_ui()
 
-        row = self.layout.row()
+        row = self.layout.row(align=True)
         op = row.operator("bim.visualise_work_schedule_date_range", text="Create Animation", icon="OUTLINER_OB_CAMERA")
         op.work_schedule = self.props.active_work_schedule_id
+
+    def draw_snapshot_ui(self):
+        row = self.layout.row(align=True)
+        row.label(text="Create Construction Snapshot:")
+        row = self.layout.row(align=True)
+        op = row.operator("bim.datepicker", text=self.props.visualisation_start or "Date", icon="REW")
+        op.target_prop = "BIMWorkScheduleProperties.visualisation_start"
         op = row.operator("bim.visualise_work_schedule_date", text="Create SnapShot", icon="RESTRICT_RENDER_OFF")
         op.work_schedule = self.props.active_work_schedule_id
 
@@ -286,6 +373,14 @@ class BIM_PT_work_schedules(Panel):
         draw_attributes(self.props.work_schedule_attributes, self.layout)
 
     def draw_editable_task_ui(self, work_schedule_id):
+        row = self.layout.row(align=True)
+        row.label(text="Task Tools")
+        row = self.layout.row(align=True)
+        row.alignment = "RIGHT"
+        row.operator("bim.add_summary_task", text="Add Summary Task", icon="ADD").work_schedule = work_schedule_id
+        row.operator("bim.expand_all_tasks", text="Expand All")
+        row.operator("bim.contract_all_tasks", text="Contract All")
+        row = self.layout.row(align=True)
         self.draw_task_operators()
         self.layout.template_list(
             "BIM_UL_tasks",
@@ -295,9 +390,6 @@ class BIM_PT_work_schedules(Panel):
             self.props,
             "active_task_index",
         )
-        row = self.layout.row()
-        row.operator("bim.expand_all_tasks", text="Expand All")
-        row.operator("bim.contract_all_tasks", text="Contract All")
         if self.props.active_task_id and self.props.editing_task_type == "ATTRIBUTES":
             self.draw_editable_task_attributes_ui()
         elif self.props.active_task_id and self.props.editing_task_type == "CALENDAR":
@@ -347,6 +439,11 @@ class BIM_PT_work_schedules(Panel):
                 op.lag_time = sequence["TimeLag"]
             op = row.operator("bim.enable_editing_sequence_attributes", text="Edit Sequence", icon="GREASEPENCIL")
             op.sequence = sequence["id"]
+            if process_type == "RelatingProcess":
+                op = row.operator("bim.unassign_predecessor", text="", icon="X")
+            elif process_type == "RelatedProcess":
+                op = row.operator("bim.unassign_successor", text="", icon="X")
+            op.task = task["id"]
 
     def draw_editable_sequence_attributes_ui(self):
         blenderbim.bim.helper.draw_attributes(self.props.sequence_attributes, self.layout)
@@ -381,6 +478,52 @@ class BIM_PT_work_schedules(Panel):
     def draw_editable_task_time_attributes_ui(self):
         blenderbim.bim.helper.draw_attributes(self.props.task_time_attributes, self.layout)
 
+    def draw_baseline_ui(self, work_schedule_id):
+        if not self.props.should_show_schedule_baseline_ui:
+            return
+        row3 = self.layout.row()
+        row3.alignment = "RIGHT"
+        row3.operator("bim.create_baseline", text="Add Baseline", icon="ADD").work_schedule = work_schedule_id
+        if WorkScheduleData.data["active_work_schedule_baselines"]:
+            for baseline in WorkScheduleData.data["active_work_schedule_baselines"]:
+                baseline_row = self.layout.row()
+                baseline_row.alignment = "RIGHT"
+                baseline_row.label(
+                    text="{} @ {}".format(baseline["name"], baseline["date"]), icon="RESTRICT_INSTANCED_OFF"
+                )
+                baseline_row.operator("bim.generate_gantt_chart", text="Compare", icon="NLA").work_schedule = baseline[
+                    "id"
+                ]
+                baseline_row.operator(
+                    "bim.enable_editing_work_schedule_tasks", text="", icon="ACTION"
+                ).work_schedule = baseline["id"]
+                baseline_row.operator("bim.remove_work_schedule", text="", icon="X").work_schedule = baseline["id"]
+
+    def draw_readonly_work_schedule_ui(self, work_schedule_id):
+        if self.props.active_work_schedule_id == work_schedule_id:
+            row = self.layout.row()
+            row.alignment = "RIGHT"
+            row.operator("bim.disable_editing_work_schedule", text="Disable editing", icon="CANCEL")
+            grid = self.layout.grid_flow(columns=2, even_columns=True)
+            col = grid.column()
+            row1 = col.row(align=True)
+            row1.alignment = "LEFT"
+            row1.label(text="Settings")
+            row1 = col.row(align=True)
+            row1.alignment = "RIGHT"
+            row1.prop(self.props, "should_show_column_ui", text="Schedule Columns", icon="SHORTDISPLAY")
+            row2 = col.row(align=True)
+            if self.props.editing_type == "TASKS":
+                self.draw_column_ui()
+                self.layout.template_list(
+                    "BIM_UL_tasks",
+                    "",
+                    self.tprops,
+                    "tasks",
+                    self.props,
+                    "active_task_index",
+                )
+
 
 class BIM_PT_task_icom(Panel):
     bl_label = "IFC Task ICOM"
@@ -430,7 +573,7 @@ class BIM_PT_task_icom(Panel):
                 input_id = self.props.task_inputs[self.props.active_task_input_index].ifc_definition_id
                 op.related_object = input_id
 
-        op = row2.operator("bim.select_task_related_inputs", icon="RESTRICT_SELECT_OFF", text="")
+        op = row2.operator("bim.select_task_related_inputs", icon="RESTRICT_SELECT_OFF", text="Select")
         op.task = task.ifc_definition_id
 
         row2 = col.row()
@@ -519,7 +662,7 @@ class BIM_UL_task_resources(UIList):
         if item:
             row = layout.row(align=True)
             row.prop(item, "name", emboss=False, text="")
-            row.prop(item, "schedule_usage", emboss=False, text="")
+            row.label(text=str(item.schedule_usage))
 
 
 class BIM_UL_animation_colors(UIList):
@@ -583,7 +726,7 @@ class BIM_UL_tasks(UIList):
                     text="",
                     emboss=False,
                 )
-            if self.props.should_show_bar_visual_option:
+            if self.props.should_show_task_bar_selection:
                 row.prop(
                     item,
                     "has_bar_visual",
@@ -591,6 +734,8 @@ class BIM_UL_tasks(UIList):
                     text="",
                     emboss=False,
                 )
+            if self.props.enable_reorder:
+                self.draw_order_operator(row, item.ifc_definition_id)
             if self.props.active_task_id:
                 if self.props.editing_task_type == "SEQUENCE" and self.props.active_task_id != item.ifc_definition_id:
                     if item.is_predecessor:
@@ -605,6 +750,18 @@ class BIM_UL_tasks(UIList):
                         op = row.operator("bim.assign_successor", text="", icon="TRACKING_FORWARDS", emboss=False)
                     op.task = item.ifc_definition_id
 
+    def draw_order_operator(self, row, ifc_definition_id):
+        task = SequenceData.data["tasks"][ifc_definition_id]
+        if task["NestingIndex"] is not None:
+            if task["NestingIndex"] == 0:
+                op = row.operator("bim.reorder_task_nesting", icon="TRIA_DOWN", text="")
+                op.task = ifc_definition_id
+                op.new_index = task["NestingIndex"] + 1
+            elif task["NestingIndex"] > 0:
+                op = row.operator("bim.reorder_task_nesting", icon="TRIA_UP", text="")
+                op.task = ifc_definition_id
+                op.new_index = task["NestingIndex"] - 1
+
     def draw_hierarchy(self, row, item):
         for i in range(0, item.level_index):
             row.label(text="", icon="BLANK1")
@@ -825,8 +982,8 @@ class BIM_PT_4D_Tools(Panel):
     def draw(self, context):
         self.props = context.scene.BIMWorkScheduleProperties
         row = self.layout.row()
-        row.operator("bim.load_product_tasks", text="Load Tasks", icon="FILE_REFRESH")
-
+        row.operator("bim.load_product_related_tasks", text="Load Tasks", icon="FILE_REFRESH")
+        row.prop(self.props, "filter_by_active_schedule", text="Filter by Active Schedule")
         grid = self.layout.grid_flow(columns=2, even_columns=True)
         col1 = grid.column()
         col1.label(text="Product Input Tasks")

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

@@ -51,7 +51,6 @@ class AssignType(bpy.types.Operator, Operator):
         )
         for obj in related_objects:
             core.assign_type(tool.Ifc, tool.Type, element=tool.Ifc.get_entity(obj), type=type)
-            oprops = obj.BIMObjectProperties
 
 
 class UnassignType(bpy.types.Operator):
@@ -118,6 +117,7 @@ class EnableEditingType(bpy.types.Operator):
 
     def execute(self, context):
         context.active_object.BIMTypeProperties.is_editing_type = True
+        context.active_object.BIMTypeProperties.relating_type_object = None
         return {"FINISHED"}
 
 
@@ -143,8 +143,12 @@ class SelectType(bpy.types.Operator):
         element = tool.Ifc.get().by_id(self.relating_type)
         obj = tool.Ifc.get_object(element)
         if obj:
-            context.view_layer.objects.active = obj
-            obj.select_set(True)
+            if obj in context.selectable_objects:
+                tool.Blender.select_and_activate_single_object(context, obj)
+            else:
+                self.report({"INFO"}, "Type object can't be selected : It may be hidden or in an excluded collection.")
+        context.scene.BIMModelProperties.ifc_class = element.is_a()
+        context.scene.BIMModelProperties.relating_type_id = str(self.relating_type)
         return {"FINISHED"}
 
 
@@ -177,10 +181,17 @@ class SelectTypeObjects(bpy.types.Operator):
     def execute(self, context):
         self.file = IfcStore.get_file()
         relating_type = bpy.data.objects.get(self.relating_type) if self.relating_type else context.active_object
+        at_least_one_selectable_typed_object = False
         for element in ifcopenshell.util.element.get_types(tool.Ifc.get_entity(relating_type)):
             obj = tool.Ifc.get_object(element)
-            if obj:
+            if obj and obj in context.selectable_objects:
                 obj.select_set(True)
+                at_least_one_selectable_typed_object = True
+        if at_least_one_selectable_typed_object:
+            context.active_object.select_set(False)
+            context.view_layer.objects.active = context.selected_objects[0]
+        else:
+            self.report({"INFO"}, "Typed objects can't be selected : They may be hidden or in an excluded collection.")
         return {"FINISHED"}
 
 
@@ -451,6 +462,12 @@ class DuplicateType(bpy.types.Operator, tool.Ifc.Operator):
         new = blenderbim.core.root.copy_class(tool.Ifc, tool.Collector, tool.Geometry, tool.Root, obj=new_obj)
         new.Name += " Copy"
         bpy.ops.bim.load_type_thumbnails(ifc_class=new.is_a())
+        if obj in context.selectable_objects:
+            tool.Blender.select_and_activate_single_object(context, new_obj)
+        else:
+            self.report({"INFO"}, "Type object can't be selected : It may be hidden or in an excluded collection.")
+        context.scene.BIMModelProperties.ifc_class = new.is_a()
+        context.scene.BIMModelProperties.relating_type_id = str(new_obj.BIMObjectProperties.ifc_definition_id)
         return {"FINISHED"}
 
 

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

@@ -21,6 +21,7 @@ import ifcopenshell.util.type
 from blenderbim.bim.module.type.data import TypeData
 from blenderbim.bim.prop import StrProperty, Attribute
 from blenderbim.bim.ifc import IfcStore
+import blenderbim.tool as tool
 from bpy.types import PropertyGroup
 from bpy.props import (
     PointerProperty,
@@ -50,9 +51,42 @@ def update_relating_type_class(self, context):
     TypeData.is_loaded = False
 
 
+def update_relating_type_from_object(self, context):
+    if self.relating_type_object is None:
+        return
+    element = tool.Ifc.get_entity(self.relating_type_object)
+    if not element:
+        return
+    element_type = ifcopenshell.util.element.get_type(element)
+    if not element_type:
+        return
+    self.relating_type = str(element_type.id())
+    bpy.ops.bim.assign_type()
+
+
+def is_object_class_applicable(self, obj):
+    if not TypeData.is_loaded:
+        TypeData.load()
+    element = tool.Ifc.get_entity(obj)
+    if not element:
+        return
+    element_type = ifcopenshell.util.element.get_type(element)
+    if element_type is None:
+        return False
+    return str(element_type.is_a()) in (r_t_c[0] for r_t_c in TypeData.data["relating_type_classes"])
+
+
 class BIMTypeProperties(PropertyGroup):
     is_editing_type: BoolProperty(name="Is Editing Type")
     relating_type_class: EnumProperty(
-        items=get_relating_type_class, name="Relating Type Class", update=update_relating_type_class
+        items=get_relating_type_class,
+        name="Relating Type Class",
+        update=update_relating_type_class,
     )
     relating_type: EnumProperty(items=get_relating_type, name="Relating Type")
+    relating_type_object: PointerProperty(
+        type=bpy.types.Object,
+        name="Copy Class",
+        update=update_relating_type_from_object,
+        poll=is_object_class_applicable,
+    )

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

@@ -59,24 +59,31 @@ class BIM_PT_type(Panel):
         oprops = context.active_object.BIMObjectProperties
         row = self.layout.row(align=True)
         row.label(text=f"{TypeData.data['total_instances']} Typed Objects")
-        row.operator("bim.select_type_objects", icon="RESTRICT_SELECT_OFF", text="")
+        select_type_objects_row = row.row(align=True)
+        select_type_objects_row.operator("bim.select_type_objects", icon="RESTRICT_SELECT_OFF", text="")
+        select_type_objects_row.enabled = int(TypeData.data["total_instances"]) > 0
+        op = row.operator("bim.duplicate_type", icon="DUPLICATE", text="")
+        op.element = context.active_object.BIMObjectProperties.ifc_definition_id
 
     def draw_product_ui(self, context):
+        layout = self.layout
         props = context.active_object.BIMTypeProperties
         oprops = context.active_object.BIMObjectProperties
 
         if props.is_editing_type:
-            row = self.layout.row(align=True)
+            row = layout.row(align=True)
+            row_object = layout.row(align=True)
 
             row.prop(props, "relating_type_class", text="")
             if type_prop.get_relating_type(None, context):
                 prop_with_search(row, props, "relating_type", text="")
                 row.operator("bim.assign_type", icon="CHECKMARK", text="")
+                row_object.prop(props, "relating_type_object", icon="COPYDOWN")
             else:
                 row.label(text="No Types Found")
             row.operator("bim.disable_editing_type", icon="CANCEL", text="")
         else:
-            row = self.layout.row(align=True)
+            row = layout.row(align=True)
             if TypeData.data["relating_type"]:
                 row.label(text=TypeData.data["relating_type"]["name"])
                 op = row.operator("bim.select_type", icon="OBJECT_DATA", text="")

src/blenderbim/blenderbim/bim/operator.py

@@ -22,6 +22,9 @@ import json
 import time
 import logging
 import textwrap
+import shutil
+import platform
+import subprocess
 import tempfile
 import webbrowser
 import ifcopenshell
@@ -148,6 +151,126 @@ class SelectSchemaDir(bpy.types.Operator):
         return {"RUNNING_MODAL"}
 
 
+class FileAssociate(bpy.types.Operator):
+    bl_idname = "bim.file_associate"
+    bl_label = "Associate BlenderBIM with *.ifc files"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Creates a Desktop launcher and associates it with IFC files"
+
+    @classmethod
+    def poll(cls, context):
+        if platform.system() == "Linux":
+            return True
+        # TODO Windows and Darwin
+        # https://stackoverflow.com/questions/1082889/how-to-change-filetype-association-in-the-registry
+        return False
+
+    def execute(self, context):
+        src_dir = os.path.join(os.path.dirname(__file__), "../libs/desktop")
+        binary_path = bpy.app.binary_path
+        if platform.system() == "Linux":
+            destdir = os.path.join(os.environ["HOME"], ".local")
+            self.install_desktop_linux(src_dir=src_dir, destdir=destdir, binary_path=binary_path)
+        return {"FINISHED"}
+
+    def install_desktop_linux(self, src_dir=None, destdir="/tmp", binary_path="/usr/bin/blender"):
+        """Creates linux file assocations and launcher icon"""
+
+        for rel_path in (
+            "bin",
+            "share/icons/hicolor/128x128/apps",
+            "share/icons/hicolor/128x128/mimetypes",
+            "share/applications",
+            "share/mime/packages",
+        ):
+            os.makedirs(os.path.join(destdir, rel_path), exist_ok=True)
+
+        shutil.copy(
+            os.path.join(src_dir, "blenderbim.png"),
+            os.path.join(destdir, "share/icons/hicolor/128x128/apps"),
+        )
+        shutil.copy(
+            os.path.join(src_dir, "blenderbim.desktop"),
+            os.path.join(destdir, "share/applications"),
+        )
+        shutil.copy(
+            os.path.join(src_dir, "blenderbim.xml"),
+            os.path.join(destdir, "share/mime/packages"),
+        )
+        shutil.copyfile(
+            os.path.join(src_dir, "x-ifc_128x128.png"),
+            os.path.join(destdir, "share/icons/hicolor/128x128/mimetypes", "x-ifc.png"),
+        )
+
+        # copy and rewrite wrapper script
+        with open(os.path.join(src_dir, "blenderbim"), "r") as wrapper_template:
+            filedata = wrapper_template.read()
+            filedata = filedata.replace("#BLENDER_EXE=/opt/blender-3.3/blender", 'BLENDER_EXE="' + binary_path + '"')
+        with open(os.path.join(destdir, "bin", "blenderbim"), "w") as wrapper:
+            wrapper.write(filedata)
+
+        os.chmod(os.path.join(destdir, "bin", "blenderbim"), 0o755)
+
+        self.refresh_system_linux(destdir=destdir)
+
+    def refresh_system_linux(self, destdir="/tmp"):
+        """Attempt to update mime and desktop databases"""
+        try:
+            subprocess.call(["update-mime-database", os.path.join(destdir, "share/mime")])
+        except:
+            pass
+        try:
+            subprocess.call(["update-desktop-database", os.path.join(destdir, "share/applications")])
+        except:
+            pass
+
+
+class FileUnassociate(bpy.types.Operator):
+    bl_idname = "bim.file_unassociate"
+    bl_label = "Remove BlenderBIM *.ifc association"
+    bl_options = {"REGISTER", "UNDO"}
+    bl_description = "Removes Desktop launcher and unassociates it with IFC files"
+
+    @classmethod
+    def poll(cls, context):
+        if platform.system() == "Linux":
+            return True
+        return False
+
+    def execute(self, context):
+        if platform.system() == "Linux":
+            destdir = os.path.join(os.environ["HOME"], ".local")
+            self.uninstall_desktop_linux(destdir=destdir)
+        return {"FINISHED"}
+
+    def uninstall_desktop_linux(self, destdir="/tmp"):
+        """Removes linux file assocations and launcher icon"""
+        for rel_path in (
+            "share/icons/hicolor/128x128/apps/blenderbim.png",
+            "share/icons/hicolor/128x128/mimetypes/x-ifc.png",
+            "share/applications/blenderbim.desktop",
+            "share/mime/packages/blenderbim.xml",
+            "bin/blenderbim",
+        ):
+            try:
+                os.remove(os.path.join(destdir, rel_path))
+            except:
+                pass
+
+        self.refresh_system_linux(destdir=destdir)
+
+    def refresh_system_linux(self, destdir="/tmp"):
+        """Attempt to update mime and desktop databases"""
+        try:
+            subprocess.call(["update-mime-database", os.path.join(destdir, "share/mime")])
+        except:
+            pass
+        try:
+            subprocess.call(["update-desktop-database", os.path.join(destdir, "share/applications")])
+        except:
+            pass
+
+
 class OpenUpstream(bpy.types.Operator):
     bl_idname = "bim.open_upstream"
     bl_label = "Open Upstream Reference"

src/blenderbim/blenderbim/bim/ui.py

@@ -120,6 +120,36 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         name="Should Make A Cha-Ching Sound When Project Costs Updates", default=False
     )
     lock_grids_on_import: BoolProperty(name="Should Lock Grids By Default", default=True)
+    decorations_colour: bpy.props.FloatVectorProperty(
+        name="Decorations Colour", subtype="COLOR", default=(1, 1, 1, 1), min=0.0, max=1.0, size=4
+    )
+    decorator_color_selected: bpy.props.FloatVectorProperty(
+        name="Selected Elements Color",
+        subtype="COLOR",
+        default=(0.545, 0.863, 0, 1),  # green
+        min=0.0,
+        max=1.0,
+        size=4,
+        description="Color of selected verts/edges (used in profile editing mode)",
+    )
+    decorator_color_unselected: bpy.props.FloatVectorProperty(
+        name="Not Selected Elements Color",
+        subtype="COLOR",
+        default=(1, 1, 1, 1),  # white
+        min=0.0,
+        max=1.0,
+        size=4,
+        description="Color of not selected verts/edges (used in profile editing mode)",
+    )
+    decorator_color_special: bpy.props.FloatVectorProperty(
+        name="Special Elements Color",
+        subtype="COLOR",
+        default=(0.157, 0.565, 1, 1),  # blue
+        min=0.0,
+        max=1.0,
+        size=4,
+        description="Color of special selected verts/edges (openings, preview verts/edges in roof editing, verts with arcs/circles in profile editing)",
+    )
 
     def draw(self, context):
         layout = self.layout
@@ -145,6 +175,9 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         row.operator("bim.open_upstream", text="Visit Wiki").page = "wiki"
         row.operator("bim.open_upstream", text="Visit Community").page = "community"
         row = layout.row()
+        row.operator("bim.file_associate", icon="LOCKVIEW_ON")
+        row.operator("bim.file_unassociate", icon="LOCKVIEW_OFF")
+        row = layout.row()
         row.prop(self, "svg2pdf_command")
         row = layout.row()
         row.prop(self, "svg2dxf_command")
@@ -172,13 +205,13 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         row.prop(context.scene.BIMModelProperties, "occurrence_name_function")
 
         row = self.layout.row()
-        row.prop(context.scene.DocProperties, "decorations_colour")
+        row.prop(self, "decorations_colour")
         row = self.layout.row()
-        row.prop(context.scene.BIMModelProperties, "decorator_color_selected")
+        row.prop(self, "decorator_color_selected")
         row = self.layout.row()
-        row.prop(context.scene.BIMModelProperties, "decorator_color_unselected")
+        row.prop(self, "decorator_color_unselected")
         row = self.layout.row()
-        row.prop(context.scene.BIMModelProperties, "decorator_color_special")
+        row.prop(self, "decorator_color_special")
 
         row = self.layout.row(align=True)
         row.prop(context.scene.BIMProperties, "schema_dir")
@@ -204,6 +237,10 @@ class BIM_ADDON_preferences(bpy.types.AddonPreferences):
         row.prop(context.scene.DocProperties, "symbols_path")
         row = self.layout.row(align=True)
         row.prop(context.scene.DocProperties, "patterns_path")
+        row = self.layout.row(align=True)
+        row.prop(context.scene.DocProperties, "shadingstyles_path")
+        row = self.layout.row(align=True)
+        row.prop(context.scene.DocProperties, "shadingstyle_default")
 
         row = layout.row()
         row.operator("bim.configure_visibility")

src/blenderbim/blenderbim/core/cost.py

@@ -20,16 +20,19 @@ def enable_editing_cost_schedule_attributes(cost, cost_schedule):
     cost.load_cost_schedule_attributes(cost_schedule)
     cost.enable_editing_cost_schedule_attributes(cost_schedule)
 
+
 def enable_editing_cost_items(cost, cost_schedule):
     cost.enable_editing_cost_items(cost_schedule)
     cost.load_cost_schedule_tree()
     cost.play_sound()
 
+
 def add_summary_cost_item(ifc, cost, cost_schedule):
     ifc.run("cost.add_cost_item", cost_schedule=cost_schedule)
     cost.load_cost_schedule_tree()
     # cost.play_sound()
 
+
 def add_cost_item(ifc, cost, cost_item):
     ifc.run("cost.add_cost_item", cost_item=cost_item)
     cost.load_cost_schedule_tree()
@@ -127,7 +130,7 @@ def assign_cost_value(ifc, cost_item, cost_rate):
     ifc.run("cost.assign_cost_value", cost_item=cost_item, cost_rate=cost_rate)
 
 def load_schedule_of_rates(cost, schedule_of_rates):
-    cost.load_schedule_of_rates(schedule_of_rates)
+    cost.load_schedule_of_rates_tree(schedule_of_rates)
 
 def unassign_cost_item_quantity(ifc, cost, cost_item, products):
     ifc.run("cost.unassign_cost_item_quantity", cost_item=cost_item, products=products)
@@ -175,53 +178,67 @@ def enable_editing_cost_item_value(cost, cost_value):
 def disable_editing_cost_item_value(cost):
     cost.disable_editing_cost_item_value()
 
+
 def enable_editing_cost_item_value_formula(cost, cost_value):
     cost.load_cost_item_value_formula_attributes(cost_value)
     cost.enable_editing_cost_item_value_formula(cost_value)
 
+
 def edit_cost_item_value_formula(ifc, cost, cost_value):
     formula = cost.get_cost_item_value_formula()
     ifc.run("cost.edit_cost_value_formula", cost_value=cost_value, formula=formula)
     cost.disable_editing_cost_item_value()
 
+
 def edit_cost_value(ifc, cost, cost_value):
     attributes = cost.get_cost_value_attributes()
     ifc.run("cost.edit_cost_value", cost_value=cost_value, attributes=attributes)
     cost.disable_editing_cost_item_value()
-    #cost.load_cost_item_values(cost.get_active_cost_item())
+    #cost.load_cost_item_values(cost.get_highlighted_cost_item())
+
 
 def copy_cost_item_values(ifc, cost, source, destination):
     ifc.run("cost.copy_cost_item_values", source=source, destination=destination)
 
+
 def select_cost_item_products(cost, spatial, cost_item):
     is_deep = cost.show_nested_cost_item_elements()
     products = cost.get_cost_item_products(cost_item, is_deep)
     spatial.select_products(products)
 
+
 def select_cost_schedule_products(cost, spatial, cost_schedule):
     products = cost.get_cost_schedule_products(cost_schedule)
     spatial.select_products(products)
 
+
 def import_cost_schedule_csv(cost, file_path, is_schedule_of_rates):
     cost.import_cost_schedule_csv(file_path, is_schedule_of_rates)
 
+
 def add_cost_column(cost, name):
     cost.add_cost_column(name)
 
+
 def remove_cost_column(cost, name):
     cost.remove_cost_column(name)
 
+
 def expand_cost_item_rate(cost, cost_item):
     cost.expand_cost_item_rate(cost_item)
 
+
 def contract_cost_item_rate(cost, cost_item):
     cost.contract_cost_item_rate(cost_item)
 
+
 def calculate_cost_item_resource_value(ifc, cost_item):
     ifc.run("cost.calculate_cost_item_resource_value", cost_item=cost_item)
 
-def export_cost_schedules(cost, format):
-    cost.export_cost_schedules(format)
+
+def export_cost_schedules(cost, format, cost_schedule=None):
+    cost.export_cost_schedules(format, cost_schedule)
+
 
 def clear_cost_item_assignments(ifc, cost, cost_item, related_object_type):
     products = cost.get_cost_item_assignments(cost_item, filter_by_type=related_object_type)
@@ -230,16 +247,19 @@ def clear_cost_item_assignments(ifc, cost, cost_item, related_object_type):
     cost.load_cost_item_quantity_assignments(cost_item, related_object_type=related_object_type)
     cost.load_cost_schedule_tree()
 
+
 def select_unassigned_products(ifc, cost, spatial):
-    spatial.deselect_all()
+    spatial.deselect_objects()
     products = ifc.get().by_type("IfcElement")
     cost_schedule = cost.get_active_cost_schedule()
     selection = [product for product in products if not cost.has_cost_assignments(product, cost_schedule)]
     spatial.select_products(selection)
 
+
 def load_product_cost_items(cost, product):
     cost.load_product_cost_items(product)
 
+
 def highlight_product_cost_item(spatial, cost, cost_item):
     cost_schedule = cost.get_cost_schedule(cost_item)
     is_cost_schedule_active = cost.is_cost_schedule_active(cost_schedule)
@@ -248,8 +268,6 @@ def highlight_product_cost_item(spatial, cost, cost_item):
     else:
         return "Cost schedule is not active"
 
-def toggle_cost_item_parent(cost, cost_item):
-    cost.toggle_cost_item_parent(cost_item)
 
 def change_parent_cost_item(ifc, cost, new_parent):
     cost_item = cost.get_active_cost_item()
@@ -258,4 +276,11 @@ def change_parent_cost_item(ifc, cost, new_parent):
     if cost_item :
         ifc.run("nest.change_nest", item=cost_item, new_parent=new_parent)
         cost.disable_editing_cost_item_parent()
-        cost.load_cost_schedule_tree()
+        cost.load_cost_schedule_tree()
+
+def copy_cost_item(ifc, cost):
+    cost_item = cost.get_highlighted_cost_item()
+    if cost_item:
+        cost_item = ifc.run("cost.copy_cost_item", cost_item=cost_item)
+        cost.disable_editing_cost_item_parent()
+        cost.load_cost_schedule_tree()

src/blenderbim/blenderbim/core/drawing.py

@@ -28,8 +28,8 @@ def disable_editing_text(drawing, obj=None):
 
 def edit_text(drawing, obj=None):
     drawing.synchronise_ifc_and_text_attributes(obj)
-    drawing.update_text_value(obj)
     drawing.update_text_size_pset(obj)
+    drawing.update_text_value(obj)
     drawing.disable_editing_text(obj)
 
 
@@ -104,9 +104,7 @@ def remove_sheet(ifc, drawing, sheet=None):
 
 
 def rename_sheet(ifc, drawing, sheet=None, identification=None, name=None):
-    ifc.run(
-        "document.edit_information", information=sheet, attributes={"Identification": identification, "Name": name}
-    )
+    ifc.run("document.edit_information", information=sheet, attributes={"Identification": identification, "Name": name})
     for reference in drawing.get_document_references(sheet):
         description = drawing.get_reference_description(reference)
         if description == "SHEET":
@@ -198,7 +196,9 @@ def add_drawing(ifc, collector, drawing, target_view=None, location_hint=None):
         human_scale = "1:100"
     else:
         scale = "1/96"
-        human_scale = "1/8\"=1'-0\""
+        human_scale = '1/8"=1\'-0"'
+
+    shading_styles_path = drawing.get_default_drawing_resource_path("ShadingStyles")
     ifc.run(
         "pset.edit_pset",
         pset=pset,
@@ -214,8 +214,11 @@ def add_drawing(ifc, collector, drawing, target_view=None, location_hint=None):
             "Markers": drawing.get_default_drawing_resource_path("Markers"),
             "Symbols": drawing.get_default_drawing_resource_path("Symbols"),
             "Patterns": drawing.get_default_drawing_resource_path("Patterns"),
+            "ShadingStyles": (shading_styles_path := drawing.get_default_drawing_resource_path("ShadingStyles")),
+            "CurrentShadingStyle": drawing.get_default_shading_style(),
         },
     )
+    drawing.setup_shading_styles_path(shading_styles_path)
     information = ifc.run("document.add_information")
     uri = drawing.get_default_drawing_path(drawing_name)
     reference = ifc.run("document.add_reference", information=information)
@@ -267,6 +270,9 @@ def duplicate_drawing(ifc, drawing_tool, drawing=None, should_duplicate_annotati
 
 
 def remove_drawing(ifc, drawing_tool, drawing=None):
+    if drawing_tool.is_active_drawing(drawing):
+        drawing_tool.run_drawing_activate_model()
+
     collection = drawing_tool.get_drawing_collection(drawing)
     if collection:
         drawing_tool.delete_collection(collection)
@@ -312,17 +318,19 @@ def update_drawing_name(ifc, drawing_tool, drawing=None, name=None):
         if drawing_tool.does_file_exist(resolved_old_location):
             drawing_tool.move_file(resolved_old_location, ifc.resolve_uri(new_location))
 
-    for reference in drawing_tool.get_references_with_location(old_location):
-        ifc.run("document.edit_reference", reference=reference, attributes={"Location": new_location})
-        sheet = drawing_tool.get_reference_document(reference)
-        if not sheet:
-            uri = ifc.resolve_uri(drawing_tool.get_document_uri(sheet, "LAYOUT"))
-            if drawing_tool.does_file_exist(uri):
-                drawing_tool.update_embedded_svg_location(uri, old_location, new_location)
+        for reference in drawing_tool.get_references_with_location(old_location):
+            ifc.run("document.edit_reference", reference=reference, attributes={"Location": new_location})
+            sheet = drawing_tool.get_reference_document(reference)
+            if sheet:
+                uri = ifc.resolve_uri(drawing_tool.get_document_uri(sheet, "LAYOUT"))
+                if drawing_tool.does_file_exist(uri):
+                    drawing_tool.update_embedded_svg_location(uri, old_location, new_location)
 
 
 def add_annotation(ifc, collector, drawing_tool, drawing=None, object_type=None):
-    context = drawing_tool.get_annotation_context(target_view := drawing_tool.get_drawing_target_view(drawing))
+    context = drawing_tool.get_annotation_context(
+        target_view := drawing_tool.get_drawing_target_view(drawing), object_type
+    )
     if not context:
         return f"No annotation context Annotation/{target_view} for drawing"
 

src/blenderbim/blenderbim/core/ifcgit.py

@@ -10,6 +10,15 @@ def add_file(ifcgit, ifc):
     ifcgit.add_file_to_repo(repo, path_ifc)
 
 
+def clone_repo(ifcgit, remote_url, local_folder, operator):
+    repo = ifcgit.clone_repo(remote_url, local_folder)
+    if not repo:
+        operator.report({"ERROR"}, "Clone failed")
+        return
+    operator.report({"INFO"}, "Repository cloned")
+    ifcgit.load_anyifc(repo)
+
+
 def discard_uncomitted(ifcgit, ifc):
     path_ifc = ifc.get_path()
     # NOTE this is calling the git binary in a subprocess
@@ -25,11 +34,12 @@ def commit_changes(ifcgit, ifc, repo, context):
         ifcgit.create_new_branch()
 
 
+def add_tag(ifcgit, repo):
+    ifcgit.add_tag(repo)
+
+
 def refresh_revision_list(ifcgit, repo, ifc):
-    ifcgit.clear_commits_list()
-    path_ifc = ifc.get_path()
-    lookup = ifcgit.tags_by_hexsha(repo)
-    ifcgit.get_commits_list(path_ifc, lookup)
+    ifcgit.refresh_revision_list(ifc.get_path())
 
 
 def colourise_revision(ifcgit, context):
@@ -54,6 +64,7 @@ def switch_revision(ifcgit, ifc):
     path_ifc = ifc.get_path()
     ifcgit.switch_to_revision_item()
     ifcgit.load_project(path_ifc)
+    ifcgit.refresh_revision_list(path_ifc)
 
 
 def merge_branch(ifcgit, ifc, operator):

src/blenderbim/blenderbim/core/material.py

@@ -72,3 +72,18 @@ def disable_editing_materials(material):
 
 def select_by_material(material_tool, material=None):
     material_tool.select_elements(material_tool.get_elements_by_material(material))
+
+def enable_editing_material(material_tool, material):
+    material_tool.load_material_attributes(material)
+    material_tool.enable_editing_material(material)
+
+def edit_material(ifc, material_tool, material):
+    attributes = material_tool.get_material_attributes()
+    ifc.run("material.edit_material", material=material, attributes=attributes)
+    material_tool.disable_editing_material()
+    material_type = material_tool.get_active_material_type()
+    material_tool.import_material_definitions(material_type)
+    material_tool.enable_editing_materials()
+
+def disable_editing_material(material_tool):
+    material_tool.disable_editing_material()

src/blenderbim/blenderbim/core/project.py

@@ -56,6 +56,9 @@ def create_project(ifc, project, schema=None, template=None):
     project.run_context_add_context(
         context_type="Model", context_identifier="Annotation", target_view="MODEL_VIEW", parent=model
     )
+    project.run_context_add_context(
+        context_type="Model", context_identifier="Annotation", target_view="PLAN_VIEW", parent=model
+    )
     project.run_context_add_context(
         context_type="Model", context_identifier="Profile", target_view="ELEVATION_VIEW", parent=model
     )

src/blenderbim/blenderbim/core/resource.py

@@ -170,3 +170,15 @@ def unassign_resource(ifc, spatial, resource=None, products=None):
         products = spatial.get_selected_products()
     for product in products:
         ifc.run("resource.unassign_resource", relating_resource=resource, related_object=product)
+
+
+def edit_productivity_pset(ifc, resource_tool):
+    resource = resource_tool.get_highlighted_resource()
+    if resource is None:
+        return
+    productivity = resource_tool.get_productivity(resource)
+    if productivity:
+        pset = ifc.get().by_id(productivity["id"])
+    else:
+        pset = ifc.run("pset.add_pset", product=resource, name="EPset_Productivity")
+    ifc.run("pset.edit_pset", pset=pset, properties=resource_tool.get_productivity_attributes())

src/blenderbim/blenderbim/core/root.py

@@ -21,6 +21,10 @@ def copy_class(ifc, collector, geometry, root, obj=None):
     element = ifc.get_entity(obj)
     if not element:
         return
+    if root.is_element_a(element, "IfcRelSpaceBoundary"):
+        new = ifc.run("boundary.copy_boundary", boundary=element)
+        ifc.link(new, obj)
+        return new
     representation = root.get_object_representation(obj)
     new = ifc.run("root.copy_class", product=element)
     ifc.link(new, obj)
@@ -38,7 +42,7 @@ def copy_class(ifc, collector, geometry, root, obj=None):
             geometry.link(new_representation, data)
         root.assign_body_styles(new, obj)
     collector.assign(obj)
-    if root.is_opening_element(new):
+    if root.is_element_a(new, "IfcOpeningElement"):
         root.add_tracked_opening(obj)
     return new
 

src/blenderbim/blenderbim/core/sequence.py

@@ -74,47 +74,47 @@ def enable_editing_work_schedule(sequence, work_schedule=None):
 
 def enable_editing_work_schedule_tasks(sequence, work_schedule=None):
     sequence.enable_editing_work_schedule_tasks(work_schedule)
-    sequence.create_task_tree(work_schedule)
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
 
 
-def create_task_tree(sequence, work_schedule):
-    sequence.create_task_tree(work_schedule)
+def load_task_tree(sequence, work_schedule):
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
 
 
 def expand_task(sequence, task=None):
     sequence.expand_task(task)
     work_schedule = sequence.get_active_work_schedule()
-    sequence.create_task_tree(work_schedule)
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
 
 
 def expand_all_tasks(sequence):
     sequence.expand_all_tasks()
     work_schedule = sequence.get_active_work_schedule()
-    sequence.create_task_tree(work_schedule)
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
 
 
 def contract_task(sequence, task=None):
     sequence.contract_task(task)
     work_schedule = sequence.get_active_work_schedule()
-    sequence.create_task_tree(work_schedule)
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
 
 
 def contract_all_tasks(sequence):
     sequence.contract_all_tasks()
     work_schedule = sequence.get_active_work_schedule()
-    sequence.create_task_tree(work_schedule)
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
 
 
 def remove_task(ifc, sequence, task=None):
     ifc.run("sequence.remove_task", task=task)
     work_schedule = sequence.get_active_work_schedule()
-    sequence.create_task_tree(work_schedule)
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
     sequence.disable_selecting_deleted_task()
 
@@ -129,22 +129,26 @@ def disable_editing_work_schedule(sequence):
 
 def add_summary_task(ifc, sequence, work_schedule=None):
     ifc.run("sequence.add_task", work_schedule=work_schedule)
-    sequence.create_task_tree(work_schedule)
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
 
 
 def add_task(ifc, sequence, parent_task=None):
     ifc.run("sequence.add_task", parent_task=parent_task)
     work_schedule = sequence.get_active_work_schedule()
-    sequence.create_task_tree(work_schedule)
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
 
 
 def enable_editing_task(sequence, task=None):
-    sequence.load_task_attributes(task)
     sequence.enable_editing_task(task)
 
 
+def enable_editing_task_attributes(sequence, task=None):
+    sequence.load_task_attributes(task)
+    sequence.enable_editing_task_attributes(task)
+
+
 def edit_task(ifc, sequence, task=None):
     attributes = sequence.get_task_attributes()
     ifc.run("sequence.edit_task", task=task, attributes=attributes)
@@ -165,7 +169,7 @@ def copy_task_attribute(ifc, sequence, attribute_name=None):
 def duplicate_task(ifc, sequence, task=None):
     ifc.run("sequence.duplicate_task", task=task)
     work_schedule = sequence.get_active_work_schedule()
-    sequence.create_task_tree(work_schedule)
+    sequence.load_task_tree(work_schedule)
     sequence.load_task_properties()
 
 
@@ -245,7 +249,10 @@ def unassign_input_products(ifc, sequence, spatial, task=None, products=None):
 def assign_resource(ifc, sequence, task=None):
     resource = sequence.get_selected_resource()
     sub_resource = ifc.run(
-        "resource.add_resource", parent_resource=resource, ifc_class=resource.is_a(), name=resource.Name
+        "resource.add_resource",
+        parent_resource=resource,
+        ifc_class=resource.is_a(),
+        name="{}/{}".format(resource.Name or "Unnamed", task.Name or ""),
     )
     ifc.run("sequence.assign_process", relating_process=task, related_object=sub_resource)
     resources = sequence.get_task_resources(task)
@@ -430,13 +437,30 @@ def select_task_inputs(sequence, spatial, task=None):
     spatial.select_products(products=sequence.get_task_inputs(task))
 
 
+def select_work_schedule_products(sequence, spatial, work_schedule=None):
+    products = sequence.get_work_schedule_products(work_schedule)
+    spatial.select_products(products)
+
+
+def select_unassigned_work_schedule_products(ifc, sequence, spatial):
+    spatial.deselect_objects()
+    products = ifc.get().by_type("IfcElement")
+    work_schedule = sequence.get_active_work_schedule()
+    schedule_products = sequence.get_work_schedule_products(work_schedule)
+    selection = [product for product in products if product not in schedule_products]
+    spatial.select_products(selection)
+
+
 def recalculate_schedule(ifc, work_schedule=None):
     ifc.run("sequence.recalculate_schedule", work_schedule=work_schedule)
 
 
 def add_task_column(sequence, column_type=None, name=None, data_type=None):
     sequence.add_task_column(column_type, name, data_type)
-
+    work_schedule = sequence.get_active_work_schedule()
+    if work_schedule:
+        sequence.load_task_tree(work_schedule)
+        sequence.load_task_properties()
 
 def remove_task_column(sequence, name=None):
     sequence.remove_task_column(name)
@@ -444,13 +468,16 @@ def remove_task_column(sequence, name=None):
 
 def set_task_sort_column(sequence, column=None):
     sequence.set_task_sort_column(column)
-
+    work_schedule = sequence.get_active_work_schedule()
+    if work_schedule:
+        sequence.load_task_tree(work_schedule)
+        sequence.load_task_properties()
 
 def calculate_task_duration(ifc, sequence, task=None):
     ifc.run("sequence.calculate_task_duration", task=task)
     work_schedule = sequence.get_active_work_schedule()
     if work_schedule:
-        sequence.create_task_tree(work_schedule)
+        sequence.load_task_tree(work_schedule)
         sequence.load_task_properties()
 
 
@@ -459,6 +486,8 @@ def highlight_task(sequence, task=None):
     is_work_schedule_active = sequence.is_work_schedule_active(work_schedule)
     if is_work_schedule_active:
         sequence.highlight_task(task)
+    else:
+        return "Work schedule is not active"
 
 
 def highlight_product_related_task(sequence, spatial, product_type=None):
@@ -520,7 +549,30 @@ def visualise_work_schedule_date(sequence, work_schedule=None):
 
 def generate_gantt_chart(sequence, work_schedule):
     json = sequence.create_tasks_json(work_schedule)
-    sequence.generate_gantt_browser_chart(json)
+    sequence.generate_gantt_browser_chart(json, work_schedule)
 
-def load_product_tasks(sequence, product=None):
-    sequence.load_product_tasks(product)
+
+def load_product_related_tasks(sequence, product=None):
+    filter_by_schedule = sequence.is_filter_by_active_schedule()
+    if filter_by_schedule:
+        work_schedule = sequence.get_active_work_schedule()
+        task_inputs, task_ouputs = sequence.get_tasks_for_product(product, work_schedule)
+    else:
+        task_inputs, task_ouputs = sequence.get_tasks_for_product(product)
+    sequence.load_product_related_tasks(task_inputs, task_ouputs)
+
+
+def reorder_task_nesting(ifc, sequence, task, new_index):
+    is_sorting_enabled = sequence.is_sorting_enabled()
+    is_sort_reversed = sequence.is_sort_reversed()
+    if is_sorting_enabled or is_sort_reversed:
+        return "Remove manual sorting"
+    else:
+        ifc.run("nest.reorder_nesting", item=task, new_index=new_index)
+        work_schedule = sequence.get_active_work_schedule()
+        sequence.load_task_tree(work_schedule)
+        sequence.load_task_properties()
+
+
+def create_baseline(ifc, sequence, work_schedule, name):
+    ifc.run("sequence.create_baseline", work_schedule=work_schedule, name=name)

src/blenderbim/blenderbim/core/tool.py

@@ -165,8 +165,7 @@ class Cost:
     def expand_cost_item_rate(cls, cost_item): pass
     def expand_cost_item(cls, cost_item): pass
     def expand_cost_items(cls): pass
-    def export_cost_schedules(cls, format): pass
-    def export_cost_schedules(cls, format): pass
+    def export_cost_schedules(cls, format, cost_schedule): pass
     def format_unit(cls, unit): pass
     def get_active_cost_item(cls): pass
     def get_active_cost_schedule(cls): pass
@@ -269,12 +268,13 @@ class Drawing:
     def generate_drawing_matrix(cls, target_view, location_hint): pass
     def generate_drawing_name(cls, target_view, location_hint): pass
     def generate_sheet_identification(cls): pass
-    def get_annotation_context(cls, target_view): pass
+    def get_annotation_context(cls, target_view, object_type=None): pass
     def get_assigned_product(cls, element): pass
     def get_body_context(cls): pass
     def get_default_drawing_path(cls, name): pass
     def get_default_drawing_resource_path(cls, resource): pass
     def get_default_layout_path(cls, identification, name): pass
+    def get_default_shading_style(cls): pass
     def get_default_sheet_path(cls, identification, name): pass
     def get_default_sheet_path(cls, identification, name): pass
     def get_default_titleblock_path(cls, name): pass
@@ -292,6 +292,7 @@ class Drawing:
     def get_reference_description(cls, reference): pass
     def get_reference_document(cls, reference): pass
     def get_reference_location(cls, reference): pass
+    def get_references_with_location(cls, location): pass
     def get_text_literal(cls, obj): pass
     def get_unit_system(cls): pass
     def import_assigned_product(cls, obj): pass
@@ -299,20 +300,24 @@ class Drawing:
     def import_schedules(cls): pass
     def import_sheets(cls): pass
     def import_text_attributes(cls, obj): pass
+    def is_active_drawing(cls, drawing): pass
     def is_camera_orthographic(cls): pass
     def is_drawing_active(cls): pass
     def move_file(cls, src, dest): pass
     def open_spreadsheet(cls, uri): pass
     def open_svg(cls, filepath): pass
     def remove_literal_from_annotation(cls, obj, literal): pass
+    def run_drawing_activate_model(cls): pass
     def run_root_assign_class(cls, obj=None, ifc_class=None, predefined_type=None, should_add_representation=True, context=None, ifc_representation_class=None): pass
     def select_assigned_product(cls, drawing): pass
     def set_drawing_collection_name(cls, group, collection): pass
     def set_name(cls, element, name): pass
     def setup_annotation_object(cls, obj, object_type): pass
+    def setup_shading_styles_path(cls, resource_path): pass
     def show_decorations(cls): pass
     def sync_object_placement(cls, obj): pass
     def synchronise_ifc_and_text_attributes(cls, obj): pass
+    def update_embedded_svg_location(cls, uri, old_location, new_location): pass
     def update_text_size_pset(cls, obj): pass
     def update_text_value(cls, obj): pass
 
@@ -428,14 +433,19 @@ class Loader:
 class Material:
     def add_default_material_object(cls): pass
     def delete_object(cls, obj): pass
+    def disable_editing_material(cls): pass
     def disable_editing_materials(cls): pass
+    def enable_editing_material(cls, material): pass
     def enable_editing_materials(cls): pass
     def get_active_material_type(cls): pass
+    def get_active_material_type(cls): pass
     def get_elements_by_material(cls, material): pass
+    def get_material_attributes(cls): pass
     def get_name(cls, obj): pass
     def import_material_definitions(cls, material_type): pass
     def is_editing_materials(cls): pass
     def is_material_used_in_sets(cls, material): pass
+    def load_material_attributes(cls, material): pass
     def select_elements(cls, elements): pass
 
 
@@ -562,32 +572,37 @@ class Qto:
 
 @interface
 class Resource:
-    def load_resources(cls): pass
-    def load_resource_properties(cls): pass
+    def clear_productivity_data(cls, props): pass
+    def contract_resource(cls, resource): pass
+    def disable_editing_resource_cost_value(cls): pass
+    def disable_editing_resource_quantity(cls): pass
     def disable_editing_resource(cls): pass
     def disable_resource_editing_ui(cls): pass
-    def load_resource_attributes(cls, resource): pass
-    def enable_editing_resource(cls, resource): pass
-    def get_resource_attributes(cls): pass
-    def enable_editing_resource_time(cls, resource): pass
-    def get_resource_time(cls, resource): pass
-    def load_resource_time_attributes(cls, resource_time): pass
-    def get_resource_time_attributes(cls): pass
-    def enable_editing_resource_costs(cls, resource): pass
-    def disable_editing_resource_cost_value(cls): pass
-    def enable_editing_resource_cost_value_formula(cls, cost_value): pass
-    def load_cost_value_attributes(cls, cost_value): pass
+    def edit_productivity_pset(cls, resource, attributes): pass
     def enable_editing_cost_value_attributes(cls, cost_value): pass
-    def get_resource_cost_value_formula(cls): pass
-    def get_resource_cost_value_attributes(cls): pass
     def enable_editing_resource_base_quantity(cls, resource): pass
+    def enable_editing_resource_cost_value_formula(cls, cost_value): pass
+    def enable_editing_resource_costs(cls, resource): pass
     def enable_editing_resource_quantity(cls, resource_quantity): pass
-    def disable_editing_resource_quantity(cls): pass
-    def get_resource_quantity_attributes(cls): pass
+    def enable_editing_resource_time(cls, resource): pass
+    def enable_editing_resource(cls, resource): pass
     def expand_resource(cls, resource): pass
-    def contract_resource(cls, resource): pass
+    def get_highlighted_resource(cls): pass
+    def get_productivity_attributes(cls): pass
+    def get_productivity(cls, resource, should_inherit): pass
+    def get_resource_attributes(cls): pass
+    def get_resource_cost_value_attributes(cls): pass
+    def get_resource_cost_value_formula(cls): pass
+    def get_resource_quantity_attributes(cls): pass
+    def get_resource_time_attributes(cls): pass
+    def get_resource_time(cls, resource): pass
     def import_resources(cls, file_path): pass
-
+    def load_cost_value_attributes(cls, cost_value): pass
+    def load_productivity_data(cls): pass
+    def load_resource_attributes(cls, resource): pass
+    def load_resource_properties(cls): pass
+    def load_resource_time_attributes(cls, resource_time): pass
+    def load_resources(cls): pass
 
 @interface
 class Root:
@@ -601,7 +616,7 @@ class Root:
     def get_object_name(cls, obj): pass
     def get_object_representation(cls, obj): pass
     def get_representation_context(cls, representation): pass
-    def is_opening_element(cls, element): pass
+    def is_element_a(cls, element, ifc_class): pass
     def link_object_data(cls, source_obj, destination_obj): pass
     def recreate_decompositions(cls, relationships, old_to_new): pass
     def run_geometry_add_representation(cls, obj=None, context=None, ifc_representation_class=None, profile_set_usage=None): pass
@@ -619,11 +634,23 @@ class Search:
 @interface
 class Sequence:
     def add_task_column(cls, column_type, name, data_type): pass
+    def add_text_animation_handler(cls, settings): pass
+    def animate_consumption(cls, obj, start_frame, product_frame, color, animation_type): pass
+    def animate_creation(cls, obj, start_frame, product_frame, color): pass
+    def animate_destruction(cls, obj, start_frame, color, animation_type): pass
+    def animate_input(cls, obj, start_frame, product_frame, animation_type): pass
+    def animate_movement_from(cls, obj, start_frame, color, animation_type): pass
+    def animate_movement_to(cls, obj, start_frame, product_frame, color): pass
+    def animate_objects(cls, settings, frames, clear_previous, animation_type): pass
+    def animate_operation(cls, obj, start_frame, product_frame, color): pass
+    def animate_output(cls, obj, start_frame, product_frame): pass
+    def clear_object_animation(cls, obj): pass
+    def clear_objects_animation(cls, include_blender_objects): pass
     def contract_all_tasks(cls): pass
     def contract_task(cls, task): pass
     def create_bars(cls, tasks): pass
-    def create_bars(cls, tasks):pass
-    def create_task_tree(cls, work_schedule): pass
+    def create_new_task_json(cls, task, json, type_map=None): pass
+    def create_tasks_json(cls, work_schedule=None): pass
     def disable_editing_rel_sequence(cls): pass
     def disable_editing_task_animation_colors(cls): pass
     def disable_editing_task_time(cls): pass
@@ -637,10 +664,10 @@ class Sequence:
     def enable_editing_rel_sequence_attributes(cls, rel_sequence): pass
     def enable_editing_sequence_lag_time(cls, rel_sequence): pass
     def enable_editing_task_animation_colors(cls): pass
+    def enable_editing_task_attributes(cls, task): pass
     def enable_editing_task_calendar(cls, task): pass
     def enable_editing_task_sequence(cls, task): pass
     def enable_editing_task_time(cls, task): pass
-    def enable_editing_task(cls, task): pass
     def enable_editing_work_calendar_times(cls, work_calendar): pass
     def enable_editing_work_calendar(cls, work_calendar): pass
     def enable_editing_work_plan_schedules(cls, work_plan): pass
@@ -651,11 +678,13 @@ class Sequence:
     def expand_all_tasks(cls): pass
     def expand_task(cls, task): pass
     def find_related_input_tasks(cls, product): pass
-    def find_related_output_tasks(cls, column): pass
     def find_related_output_tasks(cls, product): pass
+    def generate_gantt_browser_chart(cls, task_json): pass
     def get_active_task(cls): pass
     def get_active_work_schedule(cls): pass
     def get_animation_bar_tasks(cls): pass
+    def get_animation_product_frames(cls, work_schedule, settings): pass
+    def get_animation_settings(cls): pass
     def get_checked_tasks(cls): pass
     def get_direct_nested_tasks(cls, task):pass
     def get_direct_task_outputs(cls, task): pass
@@ -665,7 +694,6 @@ class Sequence:
     def get_recurrence_pattern_attributes(cls, recurrence_pattern): pass
     def get_recurrence_pattern_times(cls): pass
     def get_rel_sequence_attributes(cls): pass
-
     def get_selected_resource(cls): pass
     def get_start_date(cls): pass
     def get_task_attribute_value(cls, attribute_name): pass
@@ -675,15 +703,20 @@ class Sequence:
     def get_task_resources(cls, task):pass
     def get_task_time_attributes(cls): pass
     def get_task_time(cls, task): pass
+    def get_tasks_for_product(cls, product, work_schedule): pass
     def get_work_calendar_attributes(cls): pass
     def get_work_plan_attributes(cls): pass
     def get_work_schedule_attributes(cls): pass
+    def get_work_schedule_products(cls, work_schedule): pass
     def get_work_schedule(cls, task): pass
     def get_work_time_attributes(cls): pass
     def guess_date_range(cls, work_schedule): pass
+    def has_task_assignments(cls, product, cost_schedule=None): pass
     def highlight_task(cls, task): pass
+    def is_filter_by_active_schedule(cls): pass
     def is_work_schedule_active(cls, work_schedule): pass
     def load_lag_time_attributes(cls, lag_time): pass
+    def load_product_related_tasks(cls, product): pass
     def load_rel_sequence_attributes(cls, rel_sequence): pass
     def load_resources(cls): pass
     def load_task_animation_colors(cls): pass
@@ -693,6 +726,7 @@ class Sequence:
     def load_task_properties(cls, task): pass
     def load_task_resources(cls,resources): pass
     def load_task_time_attributes(cls, task_time): pass
+    def load_task_tree(cls, work_schedule): pass
     def load_work_calendar_attributes(cls, work_calendar): pass
     def load_work_plan_attributes(cls, work_plan): pass
     def load_work_schedule_attributes(cls, work_schedule): pass
@@ -707,6 +741,7 @@ class Sequence:
     def show_snapshot(cls, product_states): pass
     def update_visualisation_date(cls, start_date, finish_date): pass
 
+
 @interface
 class Spatial:
     def can_contain(cls, structure_obj, element_obj): pass
@@ -825,7 +860,7 @@ class Unit:
     def enable_editing_units(cls): pass
     def export_unit_attributes(cls): pass
     def get_scene_unit_name(cls, unit_type): pass
-    def get_scene_unit_si_prefix(cls): pass
+    def get_scene_unit_si_prefix(cls, unit_type): pass
     def import_unit_attributes(cls, unit): pass
     def import_units(cls): pass
     def is_scene_unit_metric(cls): pass

src/blenderbim/blenderbim/core/unit.py

@@ -18,19 +18,17 @@
 
 
 def assign_scene_units(ifc, unit):
-    length_name = unit.get_scene_unit_name("length")
-    area_name = unit.get_scene_unit_name("area")
-    volume_name = unit.get_scene_unit_name("volume")
-
     if unit.is_scene_unit_metric():
-        prefix = unit.get_scene_unit_si_prefix()
+        prefix = unit.get_scene_unit_si_prefix("LENGTHUNIT")
         lengthunit = ifc.run("unit.add_si_unit", unit_type="LENGTHUNIT", prefix=prefix)
+        prefix = unit.get_scene_unit_si_prefix("AREAUNIT")
         areaunit = ifc.run("unit.add_si_unit", unit_type="AREAUNIT", prefix=prefix)
+        prefix = unit.get_scene_unit_si_prefix("VOLUMEUNIT")
         volumeunit = ifc.run("unit.add_si_unit", unit_type="VOLUMEUNIT", prefix=prefix)
     else:
-        lengthunit = ifc.run("unit.add_conversion_based_unit", name=length_name)
-        areaunit = ifc.run("unit.add_conversion_based_unit", name=area_name)
-        volumeunit = ifc.run("unit.add_conversion_based_unit", name=volume_name)
+        lengthunit = ifc.run("unit.add_conversion_based_unit", name=unit.get_scene_unit_name("LENGTHUNIT"))
+        areaunit = ifc.run("unit.add_conversion_based_unit", name=unit.get_scene_unit_name("AREAUNIT"))
+        volumeunit = ifc.run("unit.add_conversion_based_unit", name=unit.get_scene_unit_name("VOLUMEUNIT"))
 
     planeangleunit = ifc.run("unit.add_conversion_based_unit", name="degree")
 

src/blenderbim/blenderbim/libs/desktop/Makefile

@@ -9,8 +9,8 @@ install :
 	${DESTDIR}/share/icons/hicolor/128x128/mimetypes \
 	${DESTDIR}/share/applications \
 	${DESTDIR}/share/mime/packages
-	cp blenderbim.sh ${DESTDIR}/bin/
-	chmod +x ${DESTDIR}/bin/blenderbim.sh
+	cp blenderbim ${DESTDIR}/bin/
+	chmod +x ${DESTDIR}/bin/blenderbim
 	cp blenderbim.png ${DESTDIR}/share/icons/hicolor/128x128/apps/
 	cp blenderbim.desktop ${DESTDIR}/share/applications/
 	cp blenderbim.xml ${DESTDIR}/share/mime/packages/
@@ -20,7 +20,7 @@ install :
 
 uninstall :
 	rm -f \
-	${DESTDIR}/bin/blenderbim.sh \
+	${DESTDIR}/bin/blenderbim \
 	${DESTDIR}/share/icons/hicolor/128x128/apps/blenderbim.png \
 	${DESTDIR}/share/applications/blenderbim.desktop \
 	${DESTDIR}/share/mime/packages/blenderbim.xml \

src/blenderbim/blenderbim/libs/desktop/README.md

@@ -15,7 +15,7 @@ configure associations and icons for a single user by running `make`:
 Test by running the wrapper script directly, this should launch BlenderBIM with
 an empty IFC project:
 
-  blenderbim.sh
+  blenderbim
 
 This `Makefile` installs files to `~/.local` by default, to install to an
 alternative location, set `DESTDIR`:

src/blenderbim/blenderbim/libs/desktop/blenderbim

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+# Wrapper script to launch BlenderBIM.
+
+# If the `blender` executable can't be found in your PATH environment, set
+# BLENDER_EXE to the location of your preferred `blender` executable.
+
+#BLENDER_EXE=/opt/blender-3.3/blender
+
+: ${BLENDER_EXE:=blender}
+
+if [[ $# -eq 1 && -f "$@" ]]; then
+    "${BLENDER_EXE}" --python-expr 'import bpy; bpy.data.batch_remove(bpy.data.objects); bpy.ops.outliner.orphans_purge(do_local_ids=True, do_linked_ids=True, do_recursive=True); bpy.ops.bim.load_project(filepath="'"$@"'")'
+else
+    "${BLENDER_EXE}" --python-expr 'import bpy; bpy.data.batch_remove(bpy.data.objects); bpy.ops.outliner.orphans_purge(do_local_ids=True, do_linked_ids=True, do_recursive=True); bpy.ops.bim.create_project()'
+fi;

src/blenderbim/blenderbim/libs/desktop/blenderbim.desktop

@@ -1,7 +1,7 @@
 [Desktop Entry]
 Type=Application
 Terminal=false
-Exec=blenderbim.sh %f
+Exec=blenderbim %f
 Name=BlenderBIM
 Icon=blenderbim
 X-Desktop-File-Install-Version=0.26