use develop branch of ActiveLib

Merge remote-tracking branch 'origin/develop' into alan/ci-start
ConversionReporter incremented incorrecrt field when records skipped
2024-11-11 10:26:02 +01:00 · 2024-11-11 10:04:24 +01:00 · 2024-11-08 16:31:49 +00:00 · 2024-11-08 16:02:42 +00:00 · 2024-11-08 15:13:55 +00:00 · 2024-11-08 09:51:01 +00:00
118 changed files with 5362 additions and 384 deletions
@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "gitversion.tool": {
+      "version": "6.0.2",
+      "commands": ["dotnet-gitversion"],
+      "rollForward": false
+    }
+  }
+}
@@ -0,0 +1,91 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: MSBuild
+
+on:
+  push:
+    branches: ["main", "develop", "release/*", "alan/*"] # Continuous delivery on every long-lived branch
+    tags: ["v3.*"] # Manual delivery on every 3.x tag
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: windows-latest
+    outputs:
+      version: ${{ steps.set-version.outputs.version }}
+      file_version: ${{ steps.set-info-version.outputs.file_version }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          path: speckle-cpp-connectors
+          fetch-depth: 0
+      - uses: actions/checkout@v4
+        with:
+          repository: r-wessel/ActiveLib
+          path: ActiveLib
+          ref: develop
+
+      - name: Download zip file
+        run: |
+          New-Item -ItemType Directory -Path "Archicad 27" -Force
+          Invoke-WebRequest -Uri "https://github.com/GRAPHISOFT/archicad-api-devkit/releases/download/27.3001/API.Development.Kit.WIN.27.3001.zip" -OutFile "file.zip"
+
+      - name: Extract zip file to Archicad 27 folder
+        run: |
+          Add-Type -AssemblyName System.IO.Compression.FileSystem
+          [System.IO.Compression.ZipFile]::ExtractToDirectory("file.zip", "Archicad 27")
+
+      - name: Add MSBuild to PATH
+        uses: microsoft/setup-msbuild@v2
+
+      - name: ⚒️ Run GitVersion
+        working-directory: speckle-cpp-connectors
+        run: ./build.ps1 build-server-version
+
+      - name: Build
+        working-directory: speckle-cpp-connectors
+        run: ./build.ps1
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: output-${{ env.GitVersion_FullSemVer }}
+          path: speckle-cpp-connectors/output/*.zip
+          retention-days: 1
+
+      - id: set-version
+        name: Set version to output
+        run: echo "version=${{ env.GitVersion_FullSemVer }}" >> "$Env:GITHUB_OUTPUT"
+
+      - id: set-info-version
+        name: Set file version to output
+        run: echo "file_version=${{ env.GitVersion_AssemblySemVer}}" >> "$Env:GITHUB_OUTPUT" # version will be retrieved from tag?
+  deploy-installers:
+    runs-on: ubuntu-latest
+    needs: build
+    env:
+      IS_TAG_BUILD: ${{ github.ref_type == 'tag' }}
+      IS_RELEASE_BRANCH: true
+    steps:
+      - name: 🔫 Trigger Build Installers
+        uses: ALEEF02/workflow-dispatch@v3.0.0
+        continue-on-error: true
+        with:
+          workflow: build-cpp-installers
+          repo: specklesystems/connector-installers
+          token: ${{ secrets.CONNECTORS_GH_TOKEN }}
+          inputs: '{ "run_id": "${{ github.run_id }}", "version": "${{ needs.build.outputs.version }}", "file_version": "${{needs.build.outputs.file_version}}", "public_release": ${{ env.IS_TAG_BUILD }}, "store_artifacts": ${{ env.IS_RELEASE_BRANCH }} }'
+          ref: main
+          wait-for-completion: true
+          wait-for-completion-interval: 10s
+          wait-for-completion-timeout: 10m
+          display-workflow-run-url: true
+          display-workflow-run-url-interval: 10s
+
+      - uses: geekyeggo/delete-artifact@v5
+        with:
+          name: output-*
@@ -3,6 +3,7 @@ build/
 Documents/
 ResourceObjects/
 Install/
+enc_temp_folder/
 .vs/
 .vscode/
 xcuserdata/
@@ -25,4 +26,7 @@ XCBuildData/
 *.log
 .idea
 *.mui
-*.aps
+*.aps
+**/obj
+**/bin
+output/
@@ -0,0 +1,6 @@
+workflow: GitFlow/v1
+next-version: 3.0.0
+branches:
+  release:
+    prevent-increment:
+      when-current-commit-tagged: true
@@ -13,6 +13,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ActiveLib17", "..\..\Active
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SpeckleLib17", "..\SpeckleLib\SpeckleLib17.vcxproj", "{942743B7-B3CB-4F91-BE46-28937F5E3FD1}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Build", "..\ci-build\Build.csproj", "{702DE13A-1CCF-485D-A50D-846F645F07D3}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug16|x64 = Debug16|x64
@@ -143,6 +145,40 @@ Global
 		{942743B7-B3CB-4F91-BE46-28937F5E3FD1}.ReleaseVS2022|x64.Build.0 = ReleaseAC27|x64
 		{942743B7-B3CB-4F91-BE46-28937F5E3FD1}.ReleaseVS2022|x86.ActiveCfg = ReleaseAC27|Win32
 		{942743B7-B3CB-4F91-BE46-28937F5E3FD1}.ReleaseVS2022|x86.Build.0 = ReleaseAC27|Win32
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Debug16|x64.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Debug16|x64.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Debug16|x86.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Debug16|x86.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Debug17|x64.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Debug17|x64.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Debug17|x86.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Debug17|x86.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.DebugAC27|x64.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.DebugAC27|x86.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.DebugAC27|x86.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.DebugVS2022|x64.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.DebugVS2022|x64.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.DebugVS2022|x86.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.DebugVS2022|x86.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Release16|x64.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Release16|x64.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Release16|x86.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Release16|x86.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Release17|x64.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Release17|x64.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Release17|x86.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.Release17|x86.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseAC27|x86.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseAC27|x86.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseVS2019|x64.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseVS2019|x64.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseVS2019|x86.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseVS2019|x86.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseVS2022|x64.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseVS2022|x64.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseVS2022|x86.ActiveCfg = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseVS2022|x86.Build.0 = Debug|Any CPU
+		{702DE13A-1CCF-485D-A50D-846F645F07D3}.ReleaseAC27|x64.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -94,6 +94,7 @@
  <ItemGroup>
    <ClCompile Include="Connector\Connector.cpp" />
    <ClCompile Include="Connector\Database\ModelCardDatabase.cpp" />
+    <ClCompile Include="Connector\Environment\ConnectorProject.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Account\AccountBridge.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Account\GetAccounts.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\AddModel.cpp" />
@@ -105,6 +106,7 @@
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\GetSourceApplicationName.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\GetSourceApplicationVersion.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\HighlightModel.cpp" />
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\HighlightObjects.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\OpenUrl.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\RemoveModel.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\UpdateModel.cpp" />
@@ -150,6 +152,7 @@
    <ClInclude Include="Connector\ConnectorResource.h" />
    <ClInclude Include="Connector\Database\Identity\RecordID.h" />
    <ClInclude Include="Connector\Database\ModelCardDatabase.h" />
+    <ClInclude Include="Connector\Environment\ConnectorProject.h" />
    <ClInclude Include="Connector\Event\ConnectorEventID.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Account\AccountBridge.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Account\GetAccounts.h" />
@@ -162,6 +165,7 @@
    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\GetSourceApplicationName.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\GetSourceApplicationVersion.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\HighlightModel.h" />
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\HighlightObjects.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\OpenUrl.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\RemoveModel.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\UpdateModel.h" />
@@ -174,6 +178,7 @@
    <ClInclude Include="Connector\Interface\Browser\Bridge\Selection\GetSelection.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Selection\SelectionBridge.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\ConversionResult.h" />
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendConversionResult.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendError.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendObject.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendViaBrowserArgs.h" />
@@ -71,6 +71,9 @@
    <Filter Include="Connector\Interface\Browser\Bridge\Selection\Arg">
      <UniqueIdentifier>{8bb3df60-affe-4b66-8d78-f1b98e6ba8df}</UniqueIdentifier>
    </Filter>
+    <Filter Include="Connector\Environment">
+      <UniqueIdentifier>{1d9a10c3-cac6-4b15-afb9-f117b99b3a24}</UniqueIdentifier>
+    </Filter>
  </ItemGroup>
  <ItemGroup>
    <None Include="RFIX.win\Connector.rc2">
@@ -249,6 +252,12 @@
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\OpenUrl.cpp">
      <Filter>Connector\Interface\Browser\Bridge\Base</Filter>
    </ClCompile>
+    <ClCompile Include="Connector\Environment\ConnectorProject.cpp">
+      <Filter>Connector\Environment</Filter>
+    </ClCompile>
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\HighlightObjects.cpp">
+      <Filter>Connector\Interface\Browser\Bridge\Base</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Connector\ConnectorResource.h">
@@ -423,5 +432,14 @@
    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\OpenUrl.h">
      <Filter>Connector\Interface\Browser\Bridge\Base</Filter>
    </ClInclude>
+    <ClInclude Include="Connector\Environment\ConnectorProject.h">
+      <Filter>Connector\Environment</Filter>
+    </ClInclude>
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendConversionResult.h">
+      <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
+    </ClInclude>
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\HighlightObjects.h">
+      <Filter>Connector\Interface\Browser\Bridge\Base</Filter>
+    </ClInclude>
  </ItemGroup>
 </Project>
@@ -31,6 +31,8 @@
 		215F08372C95808B00CD343B /* ReceiverModelCard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08362C95808B00CD343B /* ReceiverModelCard.cpp */; };
 		215F08462C9633A800CD343B /* EverythingSendFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08452C9633A800CD343B /* EverythingSendFilter.cpp */; };
 		2192460D2CA3469D00CF5703 /* ProjectCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2192460B2CA3469D00CF5703 /* ProjectCollection.cpp */; };
+		2199BB552CDA4B1700A4BEEC /* ConnectorProject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2199BB522CDA4B1700A4BEEC /* ConnectorProject.cpp */; };
+		2199BB7E2CDD3FA800A4BEEC /* HighlightObjects.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2199BB7C2CDD3FA800A4BEEC /* HighlightObjects.cpp */; };
 		219F30422C769283009834E9 /* ConfigTests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219F30402C769282009834E9 /* ConfigTests.cpp */; };
 		21A0FB982CB723240023F24E /* FinishProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21A0FB942CB723240023F24E /* FinishProxy.cpp */; };
 		21A79EC92CCDA45C001754E4 /* HighlightModel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21A79EC52CCDA45C001754E4 /* HighlightModel.cpp */; };
@@ -316,6 +318,13 @@
 		2192460B2CA3469D00CF5703 /* ProjectCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProjectCollection.cpp; sourceTree = "<group>"; };
 		2192460C2CA3469D00CF5703 /* ProjectCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ProjectCollection.h; sourceTree = "<group>"; };
 		219388682C4E5DE2002A0180 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
+		2199BB512CDA481A00A4BEEC /* ConnectorFix.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = ConnectorFix.grc; path = RFIX/ConnectorFix.grc; sourceTree = "<group>"; };
+		2199BB522CDA4B1700A4BEEC /* ConnectorProject.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ConnectorProject.cpp; sourceTree = "<group>"; };
+		2199BB532CDA4B1700A4BEEC /* ConnectorProject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ConnectorProject.h; sourceTree = "<group>"; };
+		2199BB5C2CDA93CE00A4BEEC /* ConnectorImagesFix.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = ConnectorImagesFix.grc; path = RFIX/ConnectorImagesFix.grc; sourceTree = "<group>"; };
+		2199BB792CDCEA3900A4BEEC /* SendConversionResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SendConversionResult.h; sourceTree = "<group>"; };
+		2199BB7C2CDD3FA800A4BEEC /* HighlightObjects.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HighlightObjects.cpp; sourceTree = "<group>"; };
+		2199BB7D2CDD3FA800A4BEEC /* HighlightObjects.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HighlightObjects.h; sourceTree = "<group>"; };
 		219F30352C768F0A009834E9 /* Connector-AC27-Test.bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "Connector-AC27-Test.bundle"; sourceTree = BUILT_PRODUCTS_DIR; };
 		219F30402C769282009834E9 /* ConfigTests.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 4; path = ConfigTests.cpp; sourceTree = "<group>"; };
 		219F30432C7693B6009834E9 /* Connector-AC27-Debug.xctestplan */ = {isa = PBXFileReference; lastKnownFileType = text; path = "Connector-AC27-Debug.xctestplan"; sourceTree = SOURCE_ROOT; };
@@ -548,7 +557,6 @@
 		21D1E9AC2BF14AF200957EAA /* TeamworkProductVersion.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = TeamworkProductVersion.framework; path = "../Archicad 27/Support/Frameworks/TeamworkProductVersion.framework"; sourceTree = "<group>"; };
 		21D1EA452BF14B0700957EAA /* VWMM.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = VWMM.framework; path = "../Vectorworks 2024/SDKLib/LibMac/Release/VWMM.framework"; sourceTree = "<group>"; };
 		21D1EA4A2BF14BBC00957EAA /* Connector.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = Connector.grc; path = RINT/Connector.grc; sourceTree = "<group>"; };
-		21D1EA4B2BF14BC700957EAA /* ConnectorFix.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = ConnectorFix.grc; path = RFIX/ConnectorFix.grc; sourceTree = "<group>"; };
 		21D1EA4C2BF14BF000957EAA /* Module-Info27.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = "Module-Info27.plist"; path = "RINT.Archicad/EN-GB/Module-Info27.plist"; sourceTree = "<group>"; };
 		21F69EC62C64C035008B6A06 /* SpeckleLib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = SpeckleLib.xcodeproj; path = ../SpeckleLib/SpeckleLib.xcodeproj; sourceTree = "<group>"; };
 		21F69EDB2C64ED10008B6A06 /* ConnectorMenu.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = ConnectorMenu.grc; path = RINT/ConnectorMenu.grc; sourceTree = "<group>"; };
@@ -968,6 +976,24 @@
 			path = Identity;
 			sourceTree = "<group>";
 		};
+		2199BB4E2CDA47F900A4BEEC /* Fixed */ = {
+			isa = PBXGroup;
+			children = (
+				2199BB512CDA481A00A4BEEC /* ConnectorFix.grc */,
+				2199BB5C2CDA93CE00A4BEEC /* ConnectorImagesFix.grc */,
+			);
+			name = Fixed;
+			sourceTree = "<group>";
+		};
+		2199BB542CDA4B1700A4BEEC /* Environment */ = {
+			isa = PBXGroup;
+			children = (
+				2199BB522CDA4B1700A4BEEC /* ConnectorProject.cpp */,
+				2199BB532CDA4B1700A4BEEC /* ConnectorProject.h */,
+			);
+			path = Environment;
+			sourceTree = "<group>";
+		};
 		219F30412C769282009834E9 /* ConnectorTests */ = {
 			isa = PBXGroup;
 			children = (
@@ -1004,6 +1030,7 @@
 			children = (
 				21AEF9F92CAC3897000B8681 /* ConversionResult.cpp */,
 				21AEF9F82CAC3897000B8681 /* ConversionResult.h */,
+				2199BB792CDCEA3900A4BEEC /* SendConversionResult.h */,
 				21AEF9E32CAB56E5000B8681 /* SendError.cpp */,
 				21AEF9E42CAB56E5000B8681 /* SendError.h */,
 				21AEF9EE2CAB5720000B8681 /* SendObject.cpp */,
@@ -1034,6 +1061,8 @@
 				21B67CAA2C77329800FD64FC /* GetSourceApplicationVersion.h */,
 				21A79EC52CCDA45C001754E4 /* HighlightModel.cpp */,
 				21A79EC82CCDA45C001754E4 /* HighlightModel.h */,
+				2199BB7C2CDD3FA800A4BEEC /* HighlightObjects.cpp */,
+				2199BB7D2CDD3FA800A4BEEC /* HighlightObjects.h */,
 				21384BC92CD2EE7400D4602B /* OpenUrl.cpp */,
 				21384BCC2CD2EE7400D4602B /* OpenUrl.h */,
 				21D0BDD52C935DAE0077E104 /* RemoveModel.cpp */,
@@ -1163,7 +1192,6 @@
 			isa = PBXGroup;
 			children = (
 				21D1EA4A2BF14BBC00957EAA /* Connector.grc */,
-				21D1EA4B2BF14BC700957EAA /* ConnectorFix.grc */,
 				21F69EDB2C64ED10008B6A06 /* ConnectorMenu.grc */,
 				21D1EA4C2BF14BF000957EAA /* Module-Info27.plist */,
 				21F69EFE2C66AD55008B6A06 /* SpecklePalette.grc */,
@@ -1216,6 +1244,7 @@
 				21B67CCD2C77694500FD64FC /* Connector.h */,
 				21F69F102C677BC0008B6A06 /* ConnectorResource.h */,
 				21B67CCB2C77670400FD64FC /* Database */,
+				2199BB542CDA4B1700A4BEEC /* Environment */,
 				21F69F092C677BC0008B6A06 /* Event */,
 				21F69F0E2C677BC0008B6A06 /* Interface */,
 				21D0BDD82C9387E60077E104 /* Record */,
@@ -1296,6 +1325,7 @@
 		81494D9D09DA5892006864FB /* Resource */ = {
 			isa = PBXGroup;
 			children = (
+				2199BB4E2CDA47F900A4BEEC /* Fixed */,
 				7EA5F91E157FA18400693CEA /* EN-GB */,
 			);
 			name = Resource;
@@ -1505,6 +1535,7 @@
 				21B67CAE2C77329800FD64FC /* GetSourceApplicationVersion.cpp in Sources */,
 				21A0FB982CB723240023F24E /* FinishProxy.cpp in Sources */,
 				21B67CC32C77649F00FD64FC /* GetDocumentState.cpp in Sources */,
+				2199BB7E2CDD3FA800A4BEEC /* HighlightObjects.cpp in Sources */,
 				21D0BD602C89BFEA0077E104 /* SendBridge.cpp in Sources */,
 				21D0BD972C8F13F30077E104 /* GetSendFilters.cpp in Sources */,
 				21B67CAC2C77329800FD64FC /* BaseBridge.cpp in Sources */,
@@ -1530,6 +1561,7 @@
 				215F08372C95808B00CD343B /* ReceiverModelCard.cpp in Sources */,
 				21D0BDD72C935DAE0077E104 /* RemoveModel.cpp in Sources */,
 				21A890BC2CC15C540087E732 /* SelectionInfo.cpp in Sources */,
+				2199BB552CDA4B1700A4BEEC /* ConnectorProject.cpp in Sources */,
 				21AEF9EF2CAB5720000B8681 /* SendObject.cpp in Sources */,
 				21384BCD2CD2EE7400D4602B /* OpenUrl.cpp in Sources */,
 				21B67CDC2C78C88000FD64FC /* SayHi.cpp in Sources */,
@@ -1,7 +1,7 @@
 #include "Active/File/Directory.h"
 #include "ConnectorResource.h"
 #include "Connector/Connector.h"
-#include "Connector/Database/ModelCardDatabase.h"
+#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Interface/ConnectorMenu.h"
 #include "Connector/Interface/ConnectorPalette.h"
 #include "Speckle/Database/AccountDatabase.h"
@@ -11,7 +11,7 @@
 using namespace active::file;
 using namespace active::environment;
 using namespace connector;
-using namespace connector::database;
+using namespace connector::environment;
 using namespace speckle::database;
 using namespace speckle::environment;
 using namespace speckle::utility;
@@ -29,8 +29,6 @@ namespace {
 		ConnectorInstance(const String& name) : ConnectorAddon{name} {
 			add<ConnectorMenu>();
 			add<ConnectorPalette>();
-				//The connector 'owns' the model card database, so the publisher list should only hold a weak reference
-			addWeak(m_modelCards.getSubscription());
 		}
 		
 		// MARK: Functions (const)
@@ -40,15 +38,18 @@ namespace {
 		 @return The account database
 		 */
 		const AccountDatabase* getAccountDatabase() const override;
+		
+	protected:
 		/*!
-		 Get the model card database
-		 @return The model card database
+		 Make a new new project. Allows Addon subclasses to define a Project subclass with additional functions/databases
+		 @return A new project instance
 		 */
-		const ModelCardDatabase* getModelCardDatabase() const override { return &m_modelCards; }
+		virtual std::shared_ptr<Project> makeProject() const override {
+			return std::dynamic_pointer_cast<Project>(std::make_shared<ConnectorProject>());
+		}
 		
 	private:
 		mutable std::unique_ptr<AccountDatabase> m_account;
-		ModelCardDatabase m_modelCards;
 	};
 	
 		///The active addon instance
@@ -3,10 +3,6 @@

 namespace speckle::database {
 	class AccountDatabase;
-	class BIMElementDatabase;
-}
-namespace connector::database {
-	class ModelCardDatabase;
 }

 namespace connector {
@@ -22,11 +18,6 @@ namespace connector {
 		 @return The account database
 		 */
 		const virtual speckle::database::AccountDatabase* getAccountDatabase() const = 0;
-		/*!
-		 Get the model card database
-		 @return The model card database
-		 */
-		const virtual database::ModelCardDatabase* getModelCardDatabase() const = 0;
 		
 	protected:
 		/*!
@@ -58,6 +58,7 @@ enum ErrorString {
 	modelCardNotFoundID,
 	noProjectOpenID,
 	accountNotFoundID,
+	elementTypeNotConvertedID,
 };

 #endif	//CONNECTOR_RESOURCE
@@ -0,0 +1,33 @@
+#include "Connector/Environment/ConnectorProject.h"
+
+#include "Connector/Connector.h"
+#include "Connector/Database/ModelCardDatabase.h"
+
+using namespace active::event;
+using namespace connector::database;
+using namespace connector::environment;
+using namespace speckle::utility;
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+ConnectorProject::ConnectorProject() {
+	m_modelCards = std::make_shared<ModelCardDatabase>();
+	connector()->addWeak(m_modelCards->getSubscription());
+}
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+ConnectorProject::~ConnectorProject() {}
+
+
+/*--------------------------------------------------------------------
+	Get the model card database
+ 
+	return; The model card database
+  --------------------------------------------------------------------*/
+const ModelCardDatabase* ConnectorProject::getModelCardDatabase() const {
+	return m_modelCards.get();
+} //ConnectorProject::getModelCardDatabase
@@ -0,0 +1,53 @@
+#ifndef CONNECTOR_ENVIRONMENT_CONNECTOR_PROJECT
+#define CONNECTOR_ENVIRONMENT_CONNECTOR_PROJECT
+
+#include "Speckle/Environment/Project.h"
+
+namespace connector::database {
+	class ModelCardDatabase;
+}
+
+namespace connector::environment {
+	
+	/*!
+	 A BIM project contained Speckle connector data, e.g. a model card database
+	*/
+	class ConnectorProject : public speckle::environment::Project {
+	public:
+
+		// MARK: - Types
+		
+			///Shared pointer
+		using Shared = std::shared_ptr<ConnectorProject>;
+			///Weak pointer
+		using Weak = std::weak_ptr<ConnectorProject>;
+
+		// MARK: - Constructors
+		
+		/*!
+		 Default constructor
+		 */
+		ConnectorProject();
+		
+		ConnectorProject(const ConnectorProject&) = delete;
+		/*!
+		 Destructor
+		 */
+		~ConnectorProject();
+		
+		// MARK: - Functions (const)
+		
+		/*!
+		 Get the model card database
+		 @return The model card database
+		 */
+		const connector::database::ModelCardDatabase* getModelCardDatabase() const;
+		
+	private:
+			///The model card database
+		std::shared_ptr<connector::database::ModelCardDatabase> m_modelCards;
+	};
+
+}
+
+#endif	//CONNECTOR_ENVIRONMENT_CONNECTOR_PROJECT
@@ -1,10 +1,12 @@
 #include "Connector/Interface/Browser/Bridge/Base/AddModel.h"

 #include "Connector/Connector.h"
+#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Database/ModelCardDatabase.h"

 using namespace active::container;
 using namespace active::serialise;
+using namespace connector::environment;
 using namespace connector::record;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;
@@ -23,6 +25,10 @@ AddModel::AddModel() : BridgeMethod{"AddModel", [&](const ModelCardEventWrapper&
 	card: The card to add
  --------------------------------------------------------------------*/
 void AddModel::run(const ModelCard& card) const {
-	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr)
+	auto project = connector()->getActiveProject().lock();
+	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
+	if (!connectorProject)
+		return;
+	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr)
 		modelCardDBase->write(card);
 } //AddModel::run
@@ -8,9 +8,20 @@
 #include "Connector/Interface/Browser/Bridge/Base/RemoveModel.h"
 #include "Connector/Interface/Browser/Bridge/Base/UpdateModel.h"
 #include "Connector/Interface/Browser/Bridge/Base/HighlightModel.h"
+#include "Connector/Interface/Browser/Bridge/Base/HighlightObjects.h"
 #include "Connector/Interface/Browser/Bridge/Base/OpenUrl.h"
 #include "Speckle/Event/Type/ProjectEvent.h"

+#include "Speckle/Environment/Project.h"
+#include "Speckle/Record/Element/Element.h"
+#include "Connector/Connector.h"
+#include "Connector/ConnectorResource.h"
+#include "Speckle/Database/Identity/RecordID.h"
+#include "Speckle/Database/BIMElementDatabase.h"
+#include "Connector/Record/Model/SenderModelCard.h"
+#include "Connector/Record/Model/Filter/SendFilter.h"
+#include "Connector/Database/ModelCardDatabase.h"
+
 using namespace connector::interfac::browser::bridge;

 /*--------------------------------------------------------------------
@@ -24,10 +35,11 @@ BaseBridge::BaseBridge() : BrowserBridge{"baseBinding"} {
 	addMethod<GetDocumentState>();
 	addMethod<GetSourceApplicationName>();
 	addMethod<GetSourceApplicationVersion>();
+	addMethod<HighlightModel>();
+	addMethod<HighlightObjects>();
+	addMethod<OpenUrl>();
 	addMethod<RemoveModel>();
 	addMethod<UpdateModel>();
-	addMethod<HighlightModel>();
-	addMethod<OpenUrl>();
 } //BaseBridge::BaseBridge

 /*--------------------------------------------------------------------
@@ -2,6 +2,7 @@

 #include "Active/Serialise/CargoHold.h"
 #include "Connector/Connector.h"
+#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Database/ModelCardDatabase.h"
 #include "Connector/Interface/Browser/Bridge/Base/Arg/DocumentInfo.h"
 #include "Speckle/Environment/Project.h"
@@ -9,6 +10,7 @@

 using namespace active::container;
 using namespace active::serialise;
+using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;

@@ -33,14 +35,17 @@ GetDocumentInfo::GetDocumentInfo() : BridgeMethod{"GetDocumentInfo", [&]() {
  --------------------------------------------------------------------*/
 std::unique_ptr<Cargo> GetDocumentInfo::run() const {
 	auto docInfo = std::make_unique<DocumentInfo>();
-	if (auto project = connector()->getActiveProject().lock(); project) {
-		auto info = project->getInfo();
-		docInfo->name = info.name;
-		if (info.path)
-			docInfo->location = *info.path;
-		if (auto cardDatabase = connector()->getModelCardDatabase(); cardDatabase != nullptr)
-			docInfo->ID = cardDatabase->getStoreID();
+	auto project = connector()->getActiveProject().lock();
+	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
+	if (!connectorProject)
+		return nullptr;
+	auto info = connectorProject->getInfo();
+	docInfo->name = info.name;
+	if (info.path)
+		docInfo->location = *info.path;
+	if (auto cardDatabase = connectorProject->getModelCardDatabase(); cardDatabase != nullptr)
+		docInfo->ID = cardDatabase->getStoreID();
+	else
 		docInfo->ID = Guid{true}.operator String();
-	}
 	return std::make_unique<WrappedValue>(std::move(docInfo));
 } //GetDocumentInfo::run
@@ -1,15 +1,13 @@
 #include "Connector/Interface/Browser/Bridge/Base/GetDocumentState.h"

-#include "Active/Serialise/CargoHold.h"
 #include "Connector/Connector.h"
-#include "Connector/Record/Model/ModelCard.h"
+#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Database/ModelCardDatabase.h"

 using namespace active::container;
 using namespace active::serialise;
+using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
-using namespace connector::database;
-using namespace connector::record;
 using namespace speckle::utility;

 /*--------------------------------------------------------------------
@@ -26,7 +24,11 @@ GetDocumentState::GetDocumentState() : BridgeMethod{"GetDocumentState", [&]() {
 	return: The document model cards
  --------------------------------------------------------------------*/
 std::unique_ptr<Cargo> GetDocumentState::run() const {
-	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr) {
+	auto project = connector()->getActiveProject().lock();
+	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
+	if (!connectorProject)
+		return nullptr;
+	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr) {
 		return modelCardDBase->wrapper();
 	}
 	return nullptr;
@@ -1,6 +1,7 @@
 #include "Connector/Interface/Browser/Bridge/Base/HighlightModel.h"
 #include "Connector/Connector.h"
 #include "Connector/ConnectorResource.h"
+#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Database/ModelCardDatabase.h"
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.h"
 #include "Connector/Record/Model/SenderModelCard.h"
@@ -11,6 +12,7 @@
 #include "Speckle/Environment/Project.h"

 using namespace speckle::record::element;
+using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
 using namespace connector::record;
 using namespace speckle::utility;
@@ -18,7 +20,7 @@ using namespace speckle::utility;
 /*--------------------------------------------------------------------
 	Default constructor
  --------------------------------------------------------------------*/
-HighlightModel::HighlightModel() : BridgeMethod{"HighlightModel", [&](const SendArgs& args) {
+HighlightModel::HighlightModel() : BridgeMethod{"HighlightModel", [&](const HighlightModelArgs& args) {
 		run(args);
 }} {}

@@ -29,27 +31,25 @@ HighlightModel::HighlightModel() : BridgeMethod{"HighlightModel", [&](const Send
 	modelCardID: The ID of the target model card
  --------------------------------------------------------------------*/
 void HighlightModel::run(const String& modelCardID) const {
-	// Find the specified model card
-	auto modelCardDatabase = connector()->getModelCardDatabase();
+	auto project = connector()->getActiveProject().lock();
+	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
+	if (!connectorProject)
+		return;
+		//Find the specified model card
+	auto modelCardDatabase = connectorProject->getModelCardDatabase();
 	auto modelCard = modelCardDatabase->getCard(modelCardID);
 	if (!modelCard) {
 		getBridge()->sendEvent("setModelError",
 					std::make_unique<SendError>(connector()->getLocalString(errorString, modelCardNotFoundID), modelCardID));
 		return;
 	}
-	
 	if (auto senderCard = dynamic_cast<SenderModelCard*>(modelCard.get())) {
 		auto modelCardSelection = senderCard->getFilter().getElementIDs();
-
 		auto project = connector()->getActiveProject().lock();
-		if (!project) {
-			// TODO: is this OK? should this throw?
-			return;
-		}
-
+		if (!project)
+			return; // TODO: is this OK? should this throw?
 		auto elementDatabase = project->getElementDatabase();
 		elementDatabase->clearSelection();
 		elementDatabase->setSelection(modelCardSelection);
 	}
-
 } //HighlightModel::run
@@ -3,22 +3,19 @@

 #include "Active/Serialise/CargoHold.h"
 #include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Connector/Interface/Browser/Bridge/Config/Arg/ConnectorConfig.h"
 #include "Speckle/Interface/Browser/Bridge/BridgeMethod.h"

 namespace connector::interfac::browser::bridge {
 	
-	class ConnectorConfig;
-	
 		///Argument parameter for a string
 	using StringHold = active::serialise::CargoHold<active::serialise::ValueWrap<speckle::utility::String>, speckle::utility::String>;
 		///Argument type for this method
-	using SendArgs = speckle::interfac::browser::bridge::JSArgType<StringHold>;
+	using HighlightModelArgs = speckle::interfac::browser::bridge::JSArgType<StringHold>;

 	/*!
 	 JS Function class to highlight elements from the selected model card in the open document
 	*/
-	class HighlightModel : public speckle::interfac::browser::bridge::BridgeMethod<SendArgs, void> {
+	class HighlightModel : public speckle::interfac::browser::bridge::BridgeMethod<HighlightModelArgs, void> {
 	public:

 		// MARK: - Constructors
@@ -0,0 +1,40 @@
+#include "Connector/Interface/Browser/Bridge/Base/HighlightObjects.h"
+
+#include "Connector/Connector.h"
+#include "Connector/Environment/ConnectorProject.h"
+#include "Speckle/Database/BIMElementDatabase.h"
+#include "Speckle/Environment/Project.h"
+
+using namespace connector::environment;
+using namespace connector::interfac::browser::bridge;
+using namespace speckle::database;
+using namespace speckle::utility;
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+HighlightObjects::HighlightObjects() : BridgeMethod{"HighlightObjects", [&](const HighlightObjectArgs& args) {
+		run(args);
+}} {}
+
+
+/*--------------------------------------------------------------------
+	Highlight specified objects
+
+	objectIDs: List of object IDs to be highlighted
+  --------------------------------------------------------------------*/
+void HighlightObjects::run(const StringList& objectIDs) const {
+	BIMLinkList objectSelection;
+	for (const auto& text : objectIDs)
+		if (Guid guid{text}; !guid.empty())
+			objectSelection.emplace_back(guid);
+	if (objectSelection.empty())
+		return;
+	auto project = connector()->getActiveProject().lock();
+	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
+	if (!connectorProject)
+		return;
+	auto elementDatabase = project->getElementDatabase();
+	elementDatabase->clearSelection();
+	elementDatabase->setSelection(objectSelection);
+} //HighlightObjects::run
@@ -0,0 +1,42 @@
+#ifndef CONNECTOR_INTERFACE_BRIDGE_HIGHLIGHT_OBJECTS
+#define CONNECTOR_INTERFACE_BRIDGE_HIGHLIGHT_OBJECTS
+
+#include "Active/Serialise/CargoHold.h"
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Speckle/Interface/Browser/Bridge/BridgeMethod.h"
+
+namespace connector::interfac::browser::bridge {
+	
+		///List of strings
+	using StringList = std::vector<active::utility::String>;
+		///Argument parameter for a string
+	using StringListHold = active::serialise::CargoHold<active::serialise::ContainerWrap<StringList>, StringList>;
+		///Argument type for this method
+	using HighlightObjectArgs = speckle::interfac::browser::bridge::JSArgType<StringListHold>;
+
+	/*!
+	 JS Function class to highlight objects using passed application IDs
+	*/
+	class HighlightObjects : public speckle::interfac::browser::bridge::BridgeMethod<HighlightObjectArgs, void> {
+	public:
+
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 */
+		HighlightObjects();
+
+		// MARK: - Functions (const)
+		
+		/*!
+		 Highlight specified objects
+		 @param objectIDs List of object IDs to be highlighted
+		 */
+		void run(const StringList& objectIDs) const;
+	};
+
+}
+
+#endif	//CONNECTOR_INTERFACE_BRIDGE_HIGHLIGHT_OBJECTS
@@ -1,22 +1,16 @@
 #include "Connector/Interface/Browser/Bridge/Base/RemoveModel.h"

 #include "Connector/Connector.h"
+#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Database/ModelCardDatabase.h"
-#include "Connector/Interface/Browser/Bridge/Base/Arg/DocumentInfo.h"

 using namespace active::container;
 using namespace active::serialise;
-using namespace connector::database;
+using namespace connector::environment;
 using namespace connector::record;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;

-namespace {
-	
-	using WrappedValue = active::serialise::CargoHold<PackageWrap, DocumentInfo>;
-
-}
-
 /*--------------------------------------------------------------------
 	Default constructor
  --------------------------------------------------------------------*/
@@ -31,6 +25,10 @@ RemoveModel::RemoveModel() : BridgeMethod{"RemoveModel", [&](const ModelCardEven
 	card: The card to add
  --------------------------------------------------------------------*/
 void RemoveModel::run(const ModelCard& card) const {
-	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr)
+	auto project = connector()->getActiveProject().lock();
+	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
+	if (!connectorProject)
+		return;
+	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr)
 		modelCardDBase->erase(card.getID());
 } //RemoveModel::run
@@ -2,11 +2,12 @@

 #include "Connector/Connector.h"
 #include "Connector/Database/ModelCardDatabase.h"
+#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Interface/Browser/Bridge/Base/Arg/DocumentInfo.h"

 using namespace active::container;
 using namespace active::serialise;
-using namespace connector::database;
+using namespace connector::environment;
 using namespace connector::record;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;
@@ -31,6 +32,10 @@ UpdateModel::UpdateModel() : BridgeMethod{"UpdateModel", [&](const ModelCardEven
 	card: The card to update
  --------------------------------------------------------------------*/
 void UpdateModel::run(const ModelCard& card) const {
-	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr)
+	auto project = connector()->getActiveProject().lock();
+	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
+	if (!connectorProject)
+		return;
+	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr)
 		modelCardDBase->write(card);
 } //UpdateModel::run
@@ -1,5 +1,6 @@
 #include "Connector/Interface/Browser/Bridge/Send/Arg/ConversionResult.h"

+#include "Active/Serialise/CargoHold.h"
 #include "Active/Serialise/Item/Wrapper/ValueWrap.h"

 #include <array>
@@ -12,14 +13,30 @@ namespace {
 	
 		///Serialisation fields
 	enum FieldIndex {
+		statusID,
+		srcID,
+		srcTypeID,
+		resID,
+		resTypeID,
 		errorID,
-		cardID,
 	};

 		///Serialisation field IDs
 	static std::array fieldID = {
+		Identity{"status"},
+		Identity{"sourceId"},
+		Identity{"sourceType"},
+		Identity{"resultId"},
+		Identity{"resultType"},
 		Identity{"error"},
-		Identity{"modelCardId"},
+	};
+
+		///Conversion status enumerator names
+	std::array statusName{
+		"success",
+		"warning",
+		"info",
+		"error",
 	};

 }
@@ -35,8 +52,12 @@ bool ConversionResult::fillInventory(active::serialise::Inventory& inventory) co
 	using enum Entry::Type;
 	inventory.merge(Inventory{
 		{
-			{ fieldID[errorID], errorID, element },
-			{ fieldID[cardID], cardID, element },
+			{ fieldID[statusID], statusID, element },
+			{ fieldID[srcID], srcID, element, !sourceID.empty() },
+			{ fieldID[srcTypeID], srcTypeID, element, !sourceType.empty() },
+			{ fieldID[resID], resID, element, !resultID.empty() },
+			{ fieldID[resTypeID], resTypeID, element, !resultType.empty() },
+			{ fieldID[errorID], errorID, element, error.operator bool() },
 		},
 	}.withType(&typeid(ConversionResult)));
 	return true;
@@ -55,11 +76,46 @@ Cargo::Unique ConversionResult::getCargo(const active::serialise::Inventory::Ite
 		return nullptr;
 	using namespace active::serialise;
 	switch (item.index) {
+		case statusID:
+			return Cargo::Unique{new CargoHold<ValueWrap<uint16_t>, uint16_t>(static_cast<uint16_t>(status))};
+		case srcID:
+			return std::make_unique<ValueWrap<String>>(sourceID);
+		case srcTypeID:
+			return std::make_unique<ValueWrap<String>>(sourceType);
+		case resID:
+			return std::make_unique<ValueWrap<String>>(resultID);
+		case resTypeID:
+			return std::make_unique<ValueWrap<String>>(resultType);
 		case errorID:
-			return std::make_unique<ValueWrap<String>>(message);
-		case cardID:
-			return std::make_unique<ValueWrap<String>>(modelCardID);
+			return std::make_unique<PackageWrap>(*error);
 		default:
 			return nullptr;	//Requested an unknown index
 	}
 } //ConversionResult::getCargo
+
+
+/*--------------------------------------------------------------------
+	Get a conversion status enumerator from text
+ 
+	text; The incoming text
+ 
+	return: The equivalent conversion status (nullopt on failure)
+  --------------------------------------------------------------------*/
+std::optional<ConversionResult::Status> connector::interfac::browser::bridge::toConversionStatus(const String& text) {
+	for (auto i = 0; i < statusName.size(); ++i)
+		if (text == statusName[i])
+			return static_cast<ConversionResult::Status>(i + 1);
+	return std::nullopt;
+} //active::geometry::toAnchor2D
+
+
+/*--------------------------------------------------------------------
+	Get the text for a conversion status value
+ 
+	status: The incoming status
+ 
+	return: The conversion status as text
+  --------------------------------------------------------------------*/
+String connector::interfac::browser::bridge::fromConversionStatus(ConversionResult::Status status) {
+	return statusName.at(static_cast<size_t>(status) - 1);
+} //active::geometry::fromAnchor2D
@@ -1,47 +1,42 @@
-#ifndef CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
-#define CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
+#ifndef CONNECTOR_INTERFACE_BRIDGE_CONVERSION_RESULT
+#define CONNECTOR_INTERFACE_BRIDGE_CONVERSION_RESULT

-#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Package.h"
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.h"
 #include "Speckle/Utility/String.h"

 namespace connector::interfac::browser::bridge {
 	
 	/*!
-	 A send error to return to the JS in the event of an error
+	 The result of a conversion process (BIM records to/from Speckle)
 	 */
-	class ConversionResult final : public active::serialise::Package {
+	class ConversionResult : public active::serialise::Package {
 	public:
-		enum class Status {
-			success = 1,
-			info,
-			warning,
-			error,
+		enum class Status : uint16_t {
+			success = 1, ///<The conversion was successful
+			info,	///<Not in use yet, maybe later as discussed
+			warning,	///<Not in use yet, maybe later as discussed
+			error,	///<An error occurred during conversion
 		};
 				
 		// MARK: - Constructors
 		
 		/*!
-			Constructor
-			@param errMess The error message
-			@param card The ID of the model card associated with the wrror
+			Default constructor
 		*/
-		ConversionResult(const speckle::utility::String& errMess, const speckle::utility::String& card) : message{errMess}, modelCardID{card} {}
+		ConversionResult() {}
 				
 		// MARK: - Public variables
 		
-			///The error message
-		speckle::utility::String message;
-			///The ID of the model card associated with the data
-		speckle::utility::String modelCardID;
 			///The element conversion status
 		Status status = Status::info;
 			///For receive conversion reports, this is the id of the speckle object. For send, it's the host app object id.
-		speckle::utility::String sourceId;
+		speckle::utility::String sourceID;
 			///For receive conversion reports, this is the type of the speckle object. For send, it's the host app object type.
 		speckle::utility::String sourceType;
 			///For receive conversion reports, this is the id of the host app object. For send, it's the speckle object id.
-		speckle::utility::String resultId;
+		speckle::utility::String resultID;
 			///For receive conversion reports, this is the type of the host app object. For send, it's the speckle object type.
 		speckle::utility::String resultType;
 			///The exception (nullopt = no exception)
@@ -63,6 +58,60 @@ namespace connector::interfac::browser::bridge {
 		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
 	};

+	/*!
+	 Get a conversion status enumerator from text
+	 @param text The incoming text
+	 @return The equivalent conversion status (nullopt on failure)
+	 */
+	std::optional<ConversionResult::Status> toConversionStatus(const speckle::utility::String& text);
+	/*!
+	 Get the text for a conversion status value
+	 @param status The incoming status
+	 @return The conversion status as text
+	 */
+	speckle::utility::String fromConversionStatus(ConversionResult::Status status);
 }

-#endif	//CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
+namespace active::serialise {
+
+	/*!
+	 Import the object from the specified string (specialisation for bool)
+	 @param source The string to read
+	 @return True if the data was successfully read
+	 */
+	template<> inline
+	bool ValueWrap<connector::interfac::browser::bridge::ConversionResult::Status>::read(const utility::String& source) {
+		auto converted = connector::interfac::browser::bridge::toConversionStatus(source);
+		if (!converted)
+			return false;
+		base::get() = *converted;
+		return true;
+	} //ValueWrap<bool>::read
+	
+
+	/*!
+	 Import the object from the specified string (specialisation for bool)
+	 @param source The string to read
+	 @return True if the data was successfully read
+	 */
+	template<> inline
+	bool ValueWrap<std::optional<connector::interfac::browser::bridge::ConversionResult::Status>>::read(const utility::String& source) {
+		auto converted = connector::interfac::browser::bridge::toConversionStatus(source);
+		base::get() = converted;
+		return converted.operator bool();
+	} //ValueWrap<bool>::read
+
+	
+	/*!
+	 Export the object to the specified string (specialisation for bool)
+	 @param dest The string to write the data to
+	 @return True if the data was successfully written
+	 */
+	template<> inline
+	bool ValueWrap<connector::interfac::browser::bridge::ConversionResult::Status>::write(utility::String& dest) const {
+		dest = connector::interfac::browser::bridge::fromConversionStatus(get());
+		return true;
+	} //ValueWrap<bool>::write
+}
+
+#endif	//CONNECTOR_INTERFACE_BRIDGE_CONVERSION_RESULT
@@ -0,0 +1,49 @@
+#ifndef CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
+#define CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
+
+#include "Connector/Interface/Browser/Bridge/Send/Arg/ConversionResult.h"
+#include "Speckle/Serialise/Collection/ConversionReporter.h"
+
+namespace connector::interfac::browser::bridge {
+	
+	/*!
+	 A result from converting a record to Speckle
+	 */
+	class SendConversionResult : public ConversionResult {
+	public:
+				
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 @param stat The send/conversion status of the target record
+		 @param srcID The record application ID
+		 @param srcType The record application type name
+		 @param err An optional error report
+		 */
+		SendConversionResult(Status stat, speckle::utility::String srcID, speckle::utility::String srcType, SendError::Option err = std::nullopt) {
+			status = stat;
+			sourceID = srcID;
+			sourceType = srcType;
+			error = err;
+		}
+		/*!
+		 Constructor
+		 @param stat The send/conversion status of the target record
+		 @param srcID The record application ID
+		 @param srcType The record application type name
+		 @param err An optional error report
+		 */
+		SendConversionResult(const speckle::database::BIMRecordID& srcID, const speckle::serialise::ConversionReporter::Data& data) {
+			status = data.status == speckle::serialise::ConversionReporter::Data::Status::success ?
+					ConversionResult::Status::success : ConversionResult::Status::error;
+			sourceID = srcID.operator speckle::utility::String();
+			sourceType = data.typeName;
+			if (!data.message.empty())
+				error = SendError{data.message};
+		}
+	};
+
+}
+
+#endif	//CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
@@ -12,14 +12,16 @@ namespace {
 	
 		///Serialisation fields
 	enum FieldIndex {
-		errorID,
+		messageID,
 		cardID,
+		stackID,
 	};

 		///Serialisation field IDs
 	static std::array fieldID = {
-		Identity{"error"},
+		Identity{"message"},
 		Identity{"modelCardId"},
+		Identity{"stackTrace"},
 	};

 }
@@ -35,8 +37,9 @@ bool SendError::fillInventory(active::serialise::Inventory& inventory) const {
 	using enum Entry::Type;
 	inventory.merge(Inventory{
 		{
-			{ fieldID[errorID], errorID, element },
-			{ fieldID[cardID], cardID, element },
+			{ fieldID[messageID], messageID, element },
+			{ fieldID[cardID], cardID, element, !modelCardID.empty() },
+			{ fieldID[stackID], stackID, element, modelCardID.empty() },	//Field not included when a model card is sent
 		},
 	}.withType(&typeid(SendError)));
 	return true;
@@ -55,10 +58,12 @@ Cargo::Unique SendError::getCargo(const active::serialise::Inventory::Item& item
 		return nullptr;
 	using namespace active::serialise;
 	switch (item.index) {
-		case errorID:
+		case messageID:
 			return std::make_unique<ValueWrap<String>>(message);
 		case cardID:
 			return std::make_unique<ValueWrap<String>>(modelCardID);
+		case stackID:
+			return std::make_unique<ValueWrap<String>>(stackTrace);
 		default:
 			return nullptr;	//Requested an unknown index
 	}
@@ -24,7 +24,7 @@ namespace connector::interfac::browser::bridge {
 			@param errMess The error message
 			@param card The ID of the model card associated with the wrror
 		*/
-		SendError(const speckle::utility::String& errMess, const speckle::utility::String& card) : message{errMess}, modelCardID{card} {}
+		SendError(const speckle::utility::String& errMess, const speckle::utility::String& card = {}) : message{errMess}, modelCardID{card} {}
 				
 		// MARK: - Public variables
 		
@@ -32,6 +32,8 @@ namespace connector::interfac::browser::bridge {
 		speckle::utility::String message;
 			///The ID of the model card associated with the data
 		speckle::utility::String modelCardID;
+			///The error stack trace
+		speckle::utility::String stackTrace;

 		// MARK: - Serialisation
 		
@@ -1,12 +1,14 @@
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendObject.h"

-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
 #include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Connector/Record/Collection/ProjectCollection.h"

 #include <array>

 using namespace active::serialise;
 using namespace connector::interfac::browser::bridge;
+using namespace connector::record;
 using namespace speckle::serialise;
 using namespace speckle::utility;

@@ -67,3 +69,19 @@ Cargo::Unique SendObject::getCargo(const active::serialise::Inventory::Item& ite
 			return nullptr;	//Requested an unknown index
 	}
 } //SendObject::getCargo
+
+
+/*--------------------------------------------------------------------
+	Get the conversion results from the send object serialisation
+ 
+	return: The serialisation conversion results
+  --------------------------------------------------------------------*/
+std::vector<SendConversionResult> SendObject::getConversionResults() const {
+	std::vector<SendConversionResult> convertResults;
+	auto collection = dynamic_cast<const ProjectCollection*>(m_object.get());
+	if (collection == nullptr)
+		return convertResults;
+	for (const auto& item : collection->getLog())
+		convertResults.emplace_back(SendConversionResult{item.first, item.second});
+	return convertResults;
+} //SendObject::getConversionResults
@@ -3,6 +3,7 @@

 #include "Active/Serialise/CargoHold.h"
 #include "Connector/Interface/Browser/Bridge/Config/Arg/ConnectorConfig.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendConversionResult.h"
 #include "Speckle/Database/Content/Record.h"
 #include "Speckle/Interface/Browser/Bridge/BridgeMethod.h"

@@ -44,15 +45,20 @@ namespace connector::interfac::browser::bridge {
 		 */
 		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
 		/*!
-			Use a manager in (de)serialisation processes
-			@param management The management to use
-		*/
+		 Use a manager in (de)serialisation processes
+		 @param management The management to use
+		 */
 		void useManagement(active::serialise::Management* management) const override { m_object->useManagement(management); }
 		/*!
-			Get the cargo management
-			@return The active management
-		*/
+		 Get the cargo management
+		 @return The active management
+		 */
 		active::serialise::Management* management() const override { return m_object->management(); }
+		/*!
+		 Get the conversion results from the send object serialisation
+		 @return The serialisation conversion results
+		 */
+		std::vector<SendConversionResult> getConversionResults() const;
 		
 	private:
 			///The object to send
@@ -1,5 +1,6 @@
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendViaBrowserArgs.h"

+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
 #include "Connector/Record/Model/ModelCard.h"
 #include "Speckle/Record/Credentials/Account.h"

@@ -25,6 +26,7 @@ namespace {
 		accID,
 		messageID,
 		sendObjectID,
+		convResultID,
 	};

 		///Serialisation field IDs
@@ -37,6 +39,7 @@ namespace {
 		Identity{"accountId"},
 		Identity{"message"},
 		Identity{"sendObject"},
+		Identity{"sendConversionResults"},
 	};
 	
 }
@@ -47,11 +50,11 @@ namespace {
 	modelCard: The model card to populate into the send info for the browser
 	account: The account linked to the send
 	object: The object to be sent
+	results: The conversion results (reporting any conversion errors etc)
  --------------------------------------------------------------------*/
 SendViaBrowserArgs::SendViaBrowserArgs(const ModelCard& modelCard, const Account& account, SendObject&& object) :
 		modelCardID(modelCard.getID()), projectID(modelCard.getProjectID()), modelID(modelCard.getModelID()), token{account.getToken()},
 		serverURL{account.getServerURL()}, accountID{account.getID()}, sendObject{std::move(object)} {
-	
 } //SendViaBrowserArgs::SendViaBrowserArgs


@@ -74,6 +77,7 @@ bool SendViaBrowserArgs::fillInventory(active::serialise::Inventory& inventory)
 			{ fieldID[accID], accID, element },
 			{ fieldID[messageID], messageID, element },
 			{ fieldID[sendObjectID], sendObjectID, element },
+			{ fieldID[convResultID], convResultID, element },
 		},
 	}.withType(&typeid(SendViaBrowserArgs)));
 	return true;
@@ -108,6 +112,9 @@ Cargo::Unique SendViaBrowserArgs::getCargo(const active::serialise::Inventory::I
 			return std::make_unique<StringWrap>(message);
 		case sendObjectID:
 			return std::make_unique<PackageWrap>(sendObject);
+		case convResultID:
+			sendConversionResults = sendObject.getConversionResults();
+			return Cargo::Unique{new ContainerWrap{sendConversionResults}};
 		default:
 			return nullptr;	//Requested an unknown index
 	}
@@ -3,7 +3,7 @@

 #include "Active/Serialise/Package/Package.h"
 #include "Active/Utility/String.h"
-#include "Connector/Interface/Browser/Bridge/Send/Arg/ConversionResult.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendConversionResult.h"
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendObject.h"
 #include "Speckle/Database/Identity/RecordID.h"

@@ -54,7 +54,7 @@ namespace connector::interfac::browser::bridge {
 			///The send message
 		speckle::utility::String message;	//TODO: Clarify what this is used for
 			///The conversion report (summarising the conversion results on an element-by-element basis)
-		std::vector<ConversionResult> sendConversionResults;
+		mutable std::vector<SendConversionResult> sendConversionResults;
 			///The commit content
 		SendObject sendObject;

@@ -5,25 +5,30 @@
 #include "Connector/Connector.h"
 #include "Connector/ConnectorResource.h"
 #include "Connector/Database/ModelCardDatabase.h"
-#include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.h"
+#include "Connector/Environment/ConnectorProject.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendConversionResult.h"
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendViaBrowserArgs.h"
 #include "Connector/Record/Collection/ProjectCollection.h"
+#include "Connector/Record/Model/SenderModelCard.h"
+#include "Connector/Record/Model/Filter/SendFilter.h"
 #include "Speckle/Database/AccountDatabase.h"
+#include "Speckle/Database/BIMElementDatabase.h"
 #include "Speckle/Database/Content/BIMRecord.h"
+#include "Speckle/Environment/Project.h"
+#include "Speckle/Environment/Host.h"
 #include "Speckle/Interface/Browser/Bridge/BrowserBridge.h"
 #include "Speckle/Record/Credentials/Account.h"
+#include "Speckle/Record/Element/Element.h"
 #include "Speckle/Serialise/Detached/Storage/DetachedMemoryStore.h"
 #include "Speckle/Utility/Exception.h"

-#include "Speckle/Database/BIMElementDatabase.h"
-#include "Speckle/Environment/Project.h"
-#include "Speckle/Record/Element/Element.h"
-using namespace speckle::record::element;
-
 using namespace active::serialise;
+using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
 using namespace connector::record;
 using namespace speckle::database;
+using namespace speckle::environment;
+using namespace speckle::record::element;
 using namespace speckle::serialise;
 using namespace speckle::utility;

@@ -41,8 +46,20 @@ Send::Send() : BridgeMethod{"Send", [&](const SendArgs& args) {
 	modelCardID: The ID of the model card identifying the objects to send
  --------------------------------------------------------------------*/
 void Send::run(const String& modelCardID) const {
+		//We can currently only send from the 3D model view
+	host()->makeModelViewActive(true);
+		//Get the active project
+	auto project = connector()->getActiveProject().lock();
+	if (!project) {
+		getBridge()->sendEvent("setModelError",
+					std::make_unique<SendError>(connector()->getLocalString(errorString, noProjectOpenID), modelCardID));
+		return;
+	}
+	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
+	if (!connectorProject)
+		return;
 		//Find the specified model card
-	auto modelCardDatabase = connector()->getModelCardDatabase();
+	auto modelCardDatabase = connectorProject->getModelCardDatabase();
 	auto modelCard = modelCardDatabase->getCard(modelCardID);
 	if (!modelCard) {
 		getBridge()->sendEvent("setModelError",
@@ -57,26 +74,23 @@ void Send::run(const String& modelCardID) const {
 					std::make_unique<SendError>(connector()->getLocalString(errorString, accountNotFoundID), modelCardID));
 		return;
 	}
-		//Get the active project
-	auto project = connector()->getActiveProject().lock();
-	if (!project) {
-		getBridge()->sendEvent("setModelError",
-					std::make_unique<SendError>(connector()->getLocalString(errorString, noProjectOpenID), modelCardID));
-		return;
-	}
-		//Get the selected elements
+		//Get the selected elements from the modelcard
 	auto elementDatabase = project->getElementDatabase();
-	auto selected = elementDatabase->getSelection();
-	if (selected.empty()) {
-		getBridge()->sendEvent("setModelError",
-					std::make_unique<SendError>(connector()->getLocalString(errorString, noSelectedModelItemsID), modelCardID));
-		return;
+	ElementIDList selected{};
+	if (auto senderCard = dynamic_cast<SenderModelCard*>(modelCard.get())) {
+		selected = senderCard->getFilter().getElementIDs();
 	}
 		//Build a collection from the selected elements
-	auto collection = std::make_unique<ProjectCollection>(project);
+	auto collection = std::make_unique<ProjectCollection>(project, modelCard->getID());
 	for (const auto& link : selected) {
 		if (auto element = elementDatabase->getElement(link); element)
 			collection->addElement(*element);
+		else {
+				//Report failure to convert element
+			collection->logRecord(link, {ConversionReporter::Data::Status::failure, String{}, String{},
+					connector()->getLocalString(errorString, elementTypeNotConvertedID)}, false);
+			collection->incrementSkippedRecords();
+		}
 	}
 		//Send the collected information
 	auto result = std::make_unique<SendViaBrowserArgs>(*modelCard, *account, SendObject{std::move(collection)});
@@ -5,6 +5,7 @@
 #include "Connector/Connector.h"
 #include "Connector/ConnectorResource.h"
 #include "Connector/Database/ModelCardDatabase.h"
+#include "Connector/Environment/ConnectorProject.h"
 #include "Speckle/Event/Type/ElementEvent.h"
 #include "Speckle/Record/Element/Element.h"
 #include "Speckle/Database/BIMElementDatabase.h"
@@ -16,6 +17,7 @@
 #include "Connector/Record/Model/Filter/SendFilter.h"

 using namespace speckle::database;
+using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;
 using namespace speckle::event;
@@ -30,22 +32,6 @@ SendBridge::SendBridge() : BrowserBridge{"sendBinding"} {
 	addMethod<GetSendFilters>();
 	addMethod<GetSendSettings>();
 	addMethod<Send>();
-
-	// POC: do we have a better place to attach observer to elements?
-#ifdef ARCHICAD
-	auto project = connector()->getActiveProject().lock();
-	if (!project) {
-		// TODO: is this OK? should this throw?
-		return;
-	}
-
-	auto elementDatabase = project->getElementDatabase();
-	auto elements = elementDatabase->getElements();
-	ElementIDList elementIds;
-	for (const auto& id : elementIds) {
-		ACAPI_Element_AttachObserver(id);
-	}
-#endif
 } //SendBridge::SendBridge


@@ -64,9 +50,13 @@ bool SendBridge::handle(const ElementEvent& event) {
 			m_changedElements.clear();
 			break;
 		case end: {
-			auto modelCardDatabase = connector()->getModelCardDatabase();
+			auto project = connector()->getActiveProject().lock();
+			auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
+			if (!connectorProject)
+				return false;
+			auto modelCardDatabase = connectorProject->getModelCardDatabase();
 			auto modelCards = modelCardDatabase->getCards();
-			// POC: this is probably not efficient, should test, review and refactor it
+				// POC: this is probably not efficient, should test, review and refactor it
 			RecordIDList expiredModelCardIds;
 			for (const auto& modelCard : modelCards) {
 				if (auto senderCard = dynamic_cast<SenderModelCard*>(modelCard.get())) {
@@ -93,5 +83,5 @@ bool SendBridge::handle(const ElementEvent& event) {
 		default:
 		  break;
 	}
-	return true;
+	return false;
 } //SendBridge::handle
@@ -17,6 +17,8 @@
 #include "Speckle/Event/Type/MenuEvent.h"
 #include "Speckle/Interface/Browser/JSPortal.h"

+#include "Speckle/Event/Type/ProjectEvent.h"
+
 #include <ACAPinc.h>
 #include <DGModule.hpp>
 #include <DGBrowser.hpp>
@@ -108,7 +110,9 @@ ConnectorPalette::ConnectorPalette() {
 	return: The subscription list (an empty list will put the subscriber into a suspended state)
  --------------------------------------------------------------------*/
 ConnectorPalette::Subscription ConnectorPalette::subscription() const {
-	return { {toggleConnectorPaletteID} };
+	auto result = ProjectSubscriber::subscription();
+	result.insert(toggleConnectorPaletteID);
+	return result;
 } //ConnectorPalette::subscription


@@ -130,16 +134,49 @@ bool ConnectorPalette::start() {
 	return: True if the event should be closed
  --------------------------------------------------------------------*/
 bool ConnectorPalette::receive(const active::event::Event& event) {
-	if (BrowserPalette::HasInstance() && BrowserPalette::GetInstance().IsVisible()) {
-		BrowserPalette::GetInstance().Hide ();
-	} else {
-		if (!BrowserPalette::HasInstance())
-			BrowserPalette::CreateInstance();
-		BrowserPalette::GetInstance().Show();
+	if (event == toggleConnectorPaletteID) {
+		if (BrowserPalette::HasInstance() && BrowserPalette::GetInstance().IsVisible()) {
+			BrowserPalette::GetInstance().Hide();
+		}
+		else {
+			if (!BrowserPalette::HasInstance())
+				BrowserPalette::CreateInstance();
+			BrowserPalette::GetInstance().Show();
+		}
+		return true;
 	}
-	return true;
+
+	return ProjectSubscriber::receive(event);
+	
 } //ConnectorPalette::receive

+/*--------------------------------------------------------------------
+	Handle a project event
+
+	event: The project event
+
+	return: True if the event should be closed
+ --------------------------------------------------------------------*/
+bool ConnectorPalette::handle(const speckle::event::ProjectEvent& event) {
+	using enum speckle::event::ProjectEvent::Type;
+	switch (event.getType()) {
+	case open: {
+		if (BrowserPalette::HasInstance() && !BrowserPalette::GetInstance().IsVisible()) {
+			BrowserPalette::GetInstance().Show();
+			BrowserPalette::GetInstance().EnableItems();
+		}
+	} break;
+	case close: {
+		if (BrowserPalette::HasInstance() && BrowserPalette::GetInstance().IsVisible()) {
+			BrowserPalette::GetInstance().Hide();
+		}
+	} break;
+	default:
+		break;
+	}
+	return false;
+} //ConnectorPalette::handle
+

 	//NB: Following is placeholder from GS example code - will be refactored to better suit our purposes

@@ -228,8 +265,8 @@ void BrowserPalette::Hide() {

 void BrowserPalette::InitBrowserControl() {
 #ifdef TESTING_MODE
-	browser->LoadURL("https://deploy-preview-3180--boisterous-douhua-e3cefb.netlify.app/");
 	//browser->LoadURL("https://boisterous-douhua-e3cefb.netlify.app/test");
+	browser->LoadURL("https://boisterous-douhua-e3cefb.netlify.app");
 #else
 	browser->LoadURL("https://boisterous-douhua-e3cefb.netlify.app/");
 #endif
@@ -282,18 +319,10 @@ GSErrCode __ACENV_CALL	BrowserPalette::PaletteControlCallBack(Int32, API_Palette
 			break;

 		case APIPalMsg_HidePalette_End:
-			if(HasInstance() && !GetInstance().IsVisible())
+			if (HasInstance() && !GetInstance().IsVisible())
+			{
 				GetInstance().Show();
-			break;
-
-		case APIPalMsg_DisableItems_Begin:
-			if(HasInstance() && GetInstance().IsVisible())
-				GetInstance().DisableItems();
-			break;
-
-		case APIPalMsg_DisableItems_End:
-			if(HasInstance() && GetInstance().IsVisible())
-				GetInstance().EnableItems();
+			}
 			break;

 		case APIPalMsg_IsPaletteVisible:
@@ -2,10 +2,11 @@
 #define CONNECTOR_CONNECTOR_PALETTE

 #include "Active/Event/Subscriber.h"
+#include "Speckle/Event/Subscriber/ProjectSubscriber.h"

 namespace connector {
 	
-	class ConnectorPalette : public active::event::Subscriber {
+	class ConnectorPalette : public speckle::event::ProjectSubscriber {
 	public:
 		/*!
 		 Default constructor
@@ -32,6 +33,13 @@ namespace connector {
 			@return True if the event should be closed
 		*/
 		bool receive(const active::event::Event& event) override;
+	protected:
+		/*!
+		 Handle the project events
+		 @param event The project event
+		 @return True if the event should be closed
+		 */
+		bool handle(const speckle::event::ProjectEvent& event) override;
 	};
 	
 }
@@ -12,6 +12,8 @@
 #include "Speckle/Record/Attribute/Finish.h"
 #include "Speckle/Record/Element/Element.h"

+#include <limits>
+
 #ifdef ARCHICAD
 #include <ACAPinc.h>
 #include <ModelMaterial.hpp>
@@ -49,9 +51,12 @@ namespace {
 	Constructor
 
 	project: The source project
+	modelCardID: The model card ID for the send operation
  --------------------------------------------------------------------*/
-ProjectCollection::ProjectCollection(speckle::environment::Project::Shared project) : base{project->getInfo().name, project},
-		m_management{std::make_unique<Management>()} {
+ProjectCollection::ProjectCollection(speckle::environment::Project::Shared project, const RecordID& modelCardID) :
+	base{project->getInfo().name, project}, ConversionReporter{modelCardID}, m_management {
+	std::make_unique<Management>()
+} {
 	m_management->push_back(this);
 	m_finishes = std::make_unique<FinishCache>();
 	base::useManagement(m_management.get());
@@ -103,7 +108,10 @@ bool ProjectCollection::addElement(const speckle::record::element::Element& elem
 	RecordCollection* collection = this;
 	for (const auto& childName : collectionNames)
 		collection = collection->getChild(childName);
-	return collection->addIndex(BIMIndex{element.getBIMID(), element.getTableID()});
+	if (!collection->addIndex(BIMIndex{element.getBIMID(), element.getTableID()}))
+		return false;
+	incrementProjectedRecords();
+	return true;
 } //ProjectCollection::addElement


@@ -115,15 +123,14 @@ bool ProjectCollection::addElement(const speckle::record::element::Element& elem
 
 	return: True if the material proxy was added (false typically means the record already exists)
  --------------------------------------------------------------------*/
-bool ProjectCollection::addMaterialProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) {
+bool ProjectCollection::addFinishProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) {
 	auto iter = m_finishProxies.find(materialIndex);
 	if (iter == m_finishProxies.end())
 		iter = m_finishProxies.insert({materialIndex, {}}).first;
 	return iter->second.insert(objectID).second;
-} //ProjectCollection::addMaterialProxy
+} //ProjectCollection::addFinishProxy


-#ifdef ARCHICAD
 /*--------------------------------------------------------------------
 	Add a ModelerAPI material to the collection (NB: These are not persistent so need to be captured by this method)
 
@@ -132,13 +139,12 @@ bool ProjectCollection::addMaterialProxy(const speckle::database::BIMIndex& mate
 
 	return: True if the material proxy was added (false typically means the record already exists)
  --------------------------------------------------------------------*/
-bool ProjectCollection::addMaterialProxy(const Finish& finish, const speckle::database::BIMRecordID& objectID) {
+bool ProjectCollection::addFinishProxy(const Finish& finish, const speckle::database::BIMRecordID& objectID) {
 	auto iter = m_finishes->find(finish.getBIMID());
 	if (iter == m_finishes->end())
 		iter = m_finishes->insert({finish.getBIMID(), finish}).first;
-	return addMaterialProxy(speckle::database::BIMIndex{finish.getBIMID()}, objectID);
-} //ProjectCollection::addMaterialProxy
-#endif
+	return addFinishProxy(speckle::database::BIMIndex{finish.getBIMID()}, objectID);
+} //ProjectCollection::addFinishProxy


 /*--------------------------------------------------------------------
@@ -153,7 +159,7 @@ bool ProjectCollection::fillInventory(active::serialise::Inventory& inventory) c
 	base::fillInventory(inventory);
 	inventory.merge(Inventory{
 		{
-			{ Identity{fieldID[finishProxyID]}, finishProxyID, 100, std::nullopt },
+			{ Identity{fieldID[finishProxyID]}, finishProxyID, std::numeric_limits<size_t>::max(), std::nullopt },
 		},
 	}.withType(&typeid(ProjectCollection)));
 	return true;
@@ -3,6 +3,7 @@

 #include "Connector/Record/Collection/RecordCollection.h"
 #include "Speckle/Serialise/Collection/FinishCollector.h"
+#include "Speckle/Serialise/Collection/ConversionReporter.h"

 #include <stack>

@@ -25,7 +26,7 @@ namespace connector::record {
 	 - Other attributes, e.g. materials
 	 Add all this supplementary data to the root container as required
 	 */
-	class ProjectCollection : public RecordCollection, public speckle::serialise::FinishCollector {
+	class ProjectCollection : public RecordCollection, public speckle::serialise::FinishCollector, public speckle::serialise::ConversionReporter {
 	public:
 		
 		// MARK: - Types
@@ -37,8 +38,9 @@ namespace connector::record {
 		/*!
 		 Constructor
 		 @param project The source project
+		 @param modelCardID The model card ID for the send operation
 		 */
-		ProjectCollection(speckle::environment::Project::Shared project);
+		ProjectCollection(speckle::environment::Project::Shared project, const speckle::database::RecordID& modelCardID);
 		ProjectCollection(const ProjectCollection&) = delete;
 		/*!
 		 Destructor
@@ -69,14 +71,14 @@ namespace connector::record {
 		 @param objectID The object the material is applied to
 		 @return True if the material proxy was added (false typically means the record already exists)
 		 */
-		bool addMaterialProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) override;
+		bool addFinishProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) override;
 		/*!
 		 Add a ModelerAPI material to the collection (NB: These are not persistent so need to be captured by this method)
 		 @param finish A finish
 		 @param objectID The object the material is applied to
 		 @return True if the material proxy was added (false typically means the record already exists)
 		 */
-		bool addMaterialProxy(const speckle::record::attribute::Finish& finish, const speckle::database::BIMRecordID& objectID) override;
+		bool addFinishProxy(const speckle::record::attribute::Finish& finish, const speckle::database::BIMRecordID& objectID) override;
 		
 		// MARK: - Serialisation
 		
@@ -11,5 +11,6 @@
 #include "Speckle.grc.rc2"

 #include "ConnectorFix.grc.rc2"
+#include "ConnectorImagesFix.grc.rc2"

 1	ICON	LOADONCALL MOVEABLE IMPURE  ACAP.ico
@@ -0,0 +1,10 @@
+
+#ifdef macintosh
+'GICN' 32500  "Speckle menu icon" {
+	"32500Mac"
+}
+#else
+'GICN' 32500  "Speckle menu icon" {
+	"32500Win"
+}
+#endif
@@ -0,0 +1,5 @@
+<svg width="52" height="52" viewBox="0 0 52 52" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M9 10L2 4V44L9 50V10Z" stroke="black" stroke-width="3" stroke-linejoin="round"/>
+<path d="M43 2L2 4L9 10L50 8L43 2Z" stroke="black" stroke-width="3" stroke-linejoin="round"/>
+<path d="M50 8L9 10V50L50 48V8Z" stroke="black" stroke-width="3" stroke-linejoin="round"/>
+</svg>
@@ -0,0 +1,5 @@
+<svg width="48" height="48" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7 8L0 2V42L7 48V8Z" fill="#313BCF"/>
+<path d="M41 0L0 2L7 8L48 6L41 0Z" fill="#7BBCFF"/>
+<path d="M48 6L7 8V48L48 46V6Z" fill="#047EFB"/>
+</svg>
@@ -9,4 +9,5 @@
 /* [  2] */		"The specified model card cannot be found. Try another card or create a new one"
 /* [  3] */		"Please open a project first"
 /* [  4] */		"The specified Speckle account cannot be found. Check that you have logged into your Speckle account with the Speckle Manager"
+/* [  5] */		"Unsupported conversion"
 }
@@ -1,5 +1,5 @@
 'STR#' 32500  "Connector Menu" {
-	/*[ 1]*/	"Speckle Connector^E3^EL^ES^ED^EE^EI^EW^ET^"
+	/*[ 1]*/	"Speckle Connector^E3^EL^ES^ED^EE^EI^EW^ET^32500"
 }


@@ -1,4 +1,5 @@
 'STR#' 32700 "Speckle Title strings" {
 /* [  1] */		"Untitled"
 /* [  2] */		"Unknown"
+/* [  3] */		"Converting elements"
 }
@@ -33,8 +33,9 @@ namespace speckle::database {
 	};

 		///Element database storage declaration
-	class BIMElementDatabase::Store : public Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID> {
-		using base = Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID>;
+	class BIMElementDatabase::Store : public Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID,
+			BIMRecordID, BIMRecordID, ElementStorage::TableType> {
+		using base = Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID, ElementStorage::TableType>;
 		using base::base;
 	};
 	
@@ -75,6 +76,48 @@ BIMElementDatabase::BIMElementDatabase() {
 BIMElementDatabase::~BIMElementDatabase() {}


+/*--------------------------------------------------------------------
+	Get the available element tables
+ 
+	targetType: An optional filtr for table type to retrieve, e.g. get all sections (nullopt = all table types)
+ 
+	return: A list of available tables
+  --------------------------------------------------------------------*/
+BIMRecordIDList BIMElementDatabase::getTables(std::optional<TableType> targetType) const {
+	return m_engine->getTables(targetType);
+} //BIMElementDatabase::getTables
+
+
+/*--------------------------------------------------------------------
+	Get the default dbase table
+ 
+	return: The default dbase table (nullopt if no table is available)
+  --------------------------------------------------------------------*/
+std::optional<BIMRecordID> BIMElementDatabase::getDefaultTable() const {
+	return m_engine->getDefaultTable();
+} //BIMElementDatabase::getDefaultTable
+
+
+/*--------------------------------------------------------------------
+	Set the default dbase table
+ 
+	tableID: The new default dbase table
+  --------------------------------------------------------------------*/
+void BIMElementDatabase::setDefaultTable(const BIMRecordID& tableID) const {
+	m_engine->setDefaultTable(tableID);
+} //BIMElementDatabase::setDefaultTable
+
+
+/*--------------------------------------------------------------------
+	Bring the view of this database to the front (i.e. so the user sees it)
+ 
+	tableID: The ID of the table to bring to the front
+  --------------------------------------------------------------------*/
+void BIMElementDatabase::bringViewToFront(BIMRecordID tableID) const {
+	m_engine->bringViewToFront(tableID);
+} //BIMElementDatabase::bringViewToFront
+
+
 /*--------------------------------------------------------------------
 	Get the current user element selection
 
@@ -101,10 +144,27 @@ void BIMElementDatabase::clearSelection() const {
 } //BIMElementDatabase::clearSelection


+/*--------------------------------------------------------------------
+	Find a filtered list of objects
+ 
+	filter: The object filter (nullptr = find all objects)
+	tableID: Optional table ID (defaults to the first table)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
+ 
+	return: A list containing IDs of found elements (empty if none found)
+  --------------------------------------------------------------------*/
+BIMRecordIDList BIMElementDatabase::findElements(const Filter& filter, std::optional<BIMRecordID> tableID,
+														  std::optional<BIMRecordID> documentID) const {
+	return m_engine->findObjects(filter, tableID, documentID);
+} //BIMElementDatabase::findElements
+
+
 /*--------------------------------------------------------------------
 	Get a specified element
 
 	elementID: The ID of the target element
+	tableID: Optional table ID (defaults to the first table)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
 
 	return: The requested element (nullptr on failure)
  --------------------------------------------------------------------*/
@@ -117,10 +177,14 @@ Element::Unique BIMElementDatabase::getElement(const BIMRecordID& elementID, std
 /*--------------------------------------------------------------------
 	Get all elements
 
+	tableID: Optional table ID (defaults to the first table)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
+ 
 	return: All the elements
  --------------------------------------------------------------------*/
-Vector<Element> BIMElementDatabase::getElements() const {
-	return m_store->getObjects();
+Vector<Element> BIMElementDatabase::getElements(std::optional<BIMRecordID> tableID,
+												std::optional<BIMRecordID> documentID) const {
+	return m_store->getObjects(tableID, documentID);
 } //BIMElementDatabase::getElements


@@ -2,6 +2,7 @@
 #define CONNECTOR_DATABASE_BIM_ELEMENT_DATABASE

 #include "Speckle/Database/Identity/BIMLink.h"
+#include "Speckle/Database/Storage/Element/ElementStorage.h"
 #include "Speckle/Record/Element/Element.h"
 #include "Speckle/Record/Element/Interface/Part.h"
 #include "Speckle/Utility/Guid.h"
@@ -19,7 +20,7 @@ namespace speckle::database {
 	/*!
 	 Database of model elements relating to a specific project
 	 */
-	class BIMElementDatabase {
+	class BIMElementDatabase : public ElementStorage {
 	public:

 		// MARK: - Constructors
@@ -36,6 +37,27 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
+		/*!
+		 Get the available element tables
+		 @param targetType An optional filtr for table type to retrieve, e.g. get all sections (nullopt = all table types)
+		 @return A set of available tables
+		 */
+		BIMRecordIDList getTables(std::optional<TableType> targetType) const;
+		/*!
+		 Get the default dbase table
+		 @return The default dbase table (nullopt if no table is available)
+		 */
+		std::optional<BIMRecordID> getDefaultTable() const;
+		/*!
+		 Set the default dbase table
+		 @param tableID The new default dbase table
+		 */
+		void setDefaultTable(const BIMRecordID& tableID) const;
+		/*!
+		 Bring the view of this database to the front (i.e. so the user sees it)
+		 @param tableID The ID of the table to bring to the front
+		 */
+		void bringViewToFront(BIMRecordID tableID) const;
 		/*!
 		 Get the current user element selection
 		 @return A list of selected element IDs
@@ -49,6 +71,15 @@ namespace speckle::database {
 		 Clear the element selection
 		 */
 		void clearSelection() const;
+		/*!
+		 Find a filtered list of objects
+		 @param filter The object filter (nullptr = find all objects)
+		 @param tableID Optional table ID (defaults to the first table)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return A list containing IDs of found elements (empty if none found)
+		 */
+		BIMRecordIDList findElements(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
+											  std::optional<BIMRecordID> documentID = std::nullopt) const;
 		/*!
 		 Get a specified element
 		 @param elementID The ID of the target element
@@ -66,9 +97,12 @@ namespace speckle::database {
 		std::unique_ptr<record::element::Element> getElement(const BIMLink& link) const { return getElement(link, link.tableID, link.docID); }
 		/*!
 		 Get all model elements
+		 @param tableID Optional table ID (defaults to the first table)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
 		 @return All the elements
 		 */
-		active::container::Vector<record::element::Element> getElements() const;
+		active::container::Vector<record::element::Element> getElements(std::optional<BIMRecordID> tableID = std::nullopt,
+																		std::optional<BIMRecordID> documentID = std::nullopt) const;
 		/*!
 		 Get memo memo (supplementary) data for a specified element
 		 @param elementID The of the source element
@@ -62,7 +62,7 @@ namespace speckle::database {
 		 Get a link to the BIM record
 		 @return The BIM record link
 		 */
-		BIMLink getBIMLink() const { return BIMLink{ BIMLink::base	{m_applicationID, m_applicationTableID} }; }
+		virtual BIMLink getBIMLink() const { return BIMLink{BIMLink::base{m_applicationID, m_applicationTableID}}; }
 		/*!
 		 Get the record unit type
 		 @return The record unit type (nullopt if the record has no applicable unit type)
@@ -34,6 +34,7 @@ namespace speckle::database {
 		using Attribute = record::attribute::Attribute;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
+		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constructors
 		
@@ -51,6 +52,15 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
+		/*!
+		 Find a filtered list of objects
+		 @param filter The object filter (nullptr = find all objects)
+		 @param tableID Optional table ID (defaults to the first table)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return A list containing IDs of found elements (empty if none found)
+		 */
+		virtual ObjIDList findObjects(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
+									  std::optional<BIMRecordID> documentID = std::nullopt) const override { return {}; }	//Implement when required
 		/*!
 		 Get an object by ID
 		 @param objID The object ID
@@ -64,7 +74,7 @@ namespace speckle::database {
 		 @param objID The object ID
 		 @param tableID Optional table ID (defaults to the floor plan)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return: The requested wrapped cargo (nullptr on failure)
+		 @return The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
@@ -16,6 +16,12 @@
 #include "Speckle/Record/Element/Beam.h"
 #include "Speckle/Record/Element/BeamSegment.h"
 #include "Speckle/Record/Element/Memo.h"
+#include "Speckle/Record/Element/MeshElem.h"
+#include "Speckle/Record/Element/Morph.h"
+#include "Speckle/Record/Element/Roof.h"
+#include "Speckle/Record/Element/Shell.h"
+#include "Speckle/Record/Element/Slab.h"
+#include "Speckle/Record/Element/Wall.h"
 #include "Speckle/Utility/Guid.h"
 #include "Speckle/Utility/String.h"

@@ -35,14 +41,24 @@ using enum ArchicadDBaseCore::Status;

 namespace {
 	
+		//ID for the floor plan view
+	static const Guid primary2DViewID{String{"ddad27c0-c17b-4ad3-b76b-53d1e176d5ef"}};
+		//ID for the 3D view
+	static const Guid primary3DViewID{String{"ec368939-fb7d-4d8c-bc88-6d29806d9212"}};
+
 	/*!
 	 Get information about a specified Archicad table
 	 @param tableID The ID of the target table
 	 @return The requested table info (nullopt on failure)
 	 */
 	std::optional<API_DatabaseInfo> getTableInfo(const BIMRecordID& tableID) {
-		API_DatabaseInfo dbaseInfo;
-		dbaseInfo.databaseUnId.elemSetId = tableID;
+		API_DatabaseInfo dbaseInfo{};
+		if (tableID == primary2DViewID)
+			dbaseInfo.typeID = APIWind_FloorPlanID;
+		else if (tableID == primary3DViewID)
+			dbaseInfo.typeID = APIWind_3DModelID;
+		else
+			dbaseInfo.databaseUnId.elemSetId = tableID;
 		if (auto err = ACAPI_Window_GetDatabaseInfo(&dbaseInfo); err == NoError)
 			return dbaseInfo;
 		return std::nullopt;
@@ -56,7 +72,7 @@ namespace {
 	 */
 	bool setActiveTable(const BIMRecordID& tableID) {
 		if (!tableID)
-			return false;	//Null guid doens't point to anything
+			return false;	//Null guid doesn't point to anything
 		if (auto activeTable = ArchicadElementDBaseEngine::getActiveTable(); activeTable && *activeTable == tableID)
 			return true;
 		auto dbaseInfo = getTableInfo(tableID);
@@ -82,6 +98,22 @@ namespace {
 				return std::make_unique<Beam>(elementData, tableID);
 			case API_BeamSegmentID:
 				return std::make_unique<BeamSegment>(elementData, tableID);
+			case API_MeshID:
+				return std::make_unique<Mesh>(elementData, tableID);
+			case API_MorphID:
+				return std::make_unique<Morph>(elementData, tableID);
+			case API_RoofID:
+				return std::make_unique<Roof>(elementData, tableID);
+			case API_ShellID:
+				return std::make_unique<Shell>(elementData, tableID);
+			case API_SlabID:
+				return std::make_unique<Slab>(elementData, tableID);
+			case API_WallID:
+				return std::make_unique<Wall>(elementData, tableID);
+			case API_ObjectID:
+				// POC: change this case once we are ready to convert Grid Elements
+				if (elementData.header.type.variationID == APIVarId_GridElement)
+					return nullptr;
 			default:
 				return std::make_unique<GenericModelElement>(elementData, tableID);
 		}
@@ -96,12 +128,34 @@ namespace {
 std::optional<BIMRecordID> ArchicadElementDBaseEngine::getActiveTable() {
 	API_WindowInfo dbaseInfo;
 	active::utility::Memory::erase(dbaseInfo);
-	if (auto err = ACAPI_Database_GetCurrentDatabase(&dbaseInfo); err == NoError)
+	if (auto err = ACAPI_Database_GetCurrentDatabase(&dbaseInfo); err == NoError) {
+		if (dbaseInfo.typeID == APIWind_FloorPlanID)
+			return primary2DViewID;
+		else if (dbaseInfo.typeID == APIWind_3DModelID)
+			return primary3DViewID;
 		return dbaseInfo.databaseUnId.elemSetId;
+	}
 	return std::nullopt;
 } //ArchicadElementDBaseEngine::getActiveTable


+/*--------------------------------------------------------------------
+	Bring the view of this database to the front (i.e. so the user sees it)
+ 
+	tableID: The ID of the table to bring to the front
+  --------------------------------------------------------------------*/
+void ArchicadElementDBaseEngine::bringViewToFront(BIMRecordID tableID) const {
+	auto dbaseInfo = getTableInfo(tableID);
+	if (!dbaseInfo)
+		return;
+	API_WindowInfo windowInfo{};
+	windowInfo.typeID = dbaseInfo->typeID;
+	if ((windowInfo.typeID != APIWind_FloorPlanID) && (windowInfo.typeID != APIWind_3DModelID))
+		windowInfo.databaseUnId = dbaseInfo->databaseUnId;
+	ACAPI_Window_ChangeWindow(&windowInfo);
+} //ArchicadElementDBaseEngine::bringViewToFront
+
+
 /*--------------------------------------------------------------------
 	Get the current user element selection
 
@@ -144,6 +198,73 @@ void ArchicadElementDBaseEngine::clearSelection() const {
 } //ArchicadElementDBaseEngine::clearSelection


+/*--------------------------------------------------------------------
+	Get the available dbase tables
+ 
+	targetType: An optional filtr for table type/group to retrieve
+ 
+	return: A list of available tables
+  --------------------------------------------------------------------*/
+ArchicadElementDBaseEngine::TableIDList ArchicadElementDBaseEngine::getTables(std::optional<TableType> targetType) const {
+	using enum ElementStorage::TableType;
+	TableIDList result;
+	if (!targetType || (targetType == primary2D))
+		result.insert(primary2DViewID);
+	if (!targetType || (targetType == primary3D))
+		result.insert(primary3DViewID);
+	return result;
+} //ArchicadElementDBaseEngine::getTables
+
+
+/*--------------------------------------------------------------------
+	Get the default dbase table
+ 
+	return: The default dbase table (nullopt if no table is available)
+  --------------------------------------------------------------------*/
+std::optional<BIMRecordID> ArchicadElementDBaseEngine::getDefaultTable() const {
+	return ArchicadElementDBaseEngine::getActiveTable();
+} //ArchicadElementDBaseEngine::getDefaultTable
+
+
+/*--------------------------------------------------------------------
+	Set the default dbase table
+ 
+	tableID: The new default dbase table
+  --------------------------------------------------------------------*/
+void ArchicadElementDBaseEngine::setDefaultTable(const BIMRecordID& tableID) const {
+	setActiveTable(tableID);
+} //ArchicadElementDBaseEngine::setDefaultTable
+
+
+/*--------------------------------------------------------------------
+	Find a filtered list of objects
+ 
+	filter: The object filter (nullptr = find all objects)
+	tableID: Optional table ID (defaults to the first table)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
+ 
+	return: A list containing IDs of found elements (empty if none found)
+  --------------------------------------------------------------------*/
+BIMRecordIDList ArchicadElementDBaseEngine::findObjects(const Filter& filter, std::optional<BIMRecordID> tableID,
+																		 std::optional<BIMRecordID> documentID) const {
+		//Switch to the target table (when specified). Otherwise the currently active table will be used
+	if (tableID)
+		setActiveTable(*tableID);
+		//First check for no filter (in which case we return all objects)
+	if (filter == nullptr) {
+		GS::Array<API_Guid> found;
+		if ((ACAPI_Element_GetElemList({}, &found) != NoError) || found.IsEmpty())
+			return {};
+		BIMRecordIDList result;
+		for (const auto& item : found)
+			result.insert(item);
+		return result;
+	}
+		//Implement other filtering as required - ideally identify characteristics supported by API, e.g. filter by type/renovation etc
+	return {};
+} //ArchicadElementDBaseEngine::findObjects
+
+
 /*--------------------------------------------------------------------
 	Get an object by index
 
@@ -211,7 +332,19 @@ active::container::Vector<Element> ArchicadElementDBaseEngine::getObjects(std::o
 																					  std::optional<BIMRecordID> documentID) const {
 	if (tableID)
 		setActiveTable(*tableID);
-	return {}; //TODO: Implement
+	else {			
+			//Use the active table if none is specified
+		tableID = getActiveTable();
+		if (!tableID)
+			return {};
+	}
+		//Retrieve the element objects to build the result
+	active::container::Vector<Element> result;
+	auto objectIDs = findObjects();
+	for (const auto& ID : objectIDs)
+		if (auto element = getObject(ID, tableID); element)
+			result.emplace_back(std::move(element));
+	return result;
 } //ArchicadElementDBaseEngine::getObjects


@@ -4,6 +4,7 @@
 #include "Active/Database/Storage/DBaseEngine.h"
 #include "Active/Serialise/UnboxedTransport.h"
 #include "Speckle/Database/Storage/ArchicadDBase/ArchicadDBaseCore.h"
+#include "Speckle/Database/Storage/Element/ElementStorage.h"
 #include "Speckle/Database/Identity/BIMLink.h"
 #include "Speckle/Record/Element/Element.h"
 #include "Speckle/Utility/Guid.h"
@@ -17,16 +18,17 @@ namespace speckle::database {
 	/*!
 	 A database engine to read/write elements in an Archicad project database (local file or cloud-based)
 	 */
-	class ArchicadElementDBaseEngine : public ArchicadDBaseCore,
-			public active::database::DBaseEngine<record::element::Element, BIMRecordID, BIMRecordID, BIMRecordID>  {
+	class ArchicadElementDBaseEngine : public ArchicadDBaseCore, public ElementStorage,
+			public active::database::DBaseEngine<record::element::Element, BIMRecordID, BIMRecordID, BIMRecordID, ElementStorage::TableType>  {
 	public:
 		
 		// MARK: - Types
 		
 		using base = active::database::DBaseEngine<record::element::Element, BIMRecordID, BIMRecordID, BIMRecordID>;
 		using Element = record::element::Element;
-		using Filter = base::Filter;
+		using Filter = ElementStorage::Filter;
 		using Outline = base::Outline;
+		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constants
 		
@@ -53,6 +55,11 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
+		/*!
+		 Bring the view of this database to the front (i.e. so the user sees it)
+		 @param tableID The ID of the table to bring to the front
+		 */
+		void bringViewToFront(BIMRecordID tableID) const;
 		/*!
 		 Get the current user element selection
 		 @return A list of selected element IDs
@@ -66,6 +73,31 @@ namespace speckle::database {
 		 Clear the element selection
 		 */
 		void clearSelection() const;
+		/*!
+		 Get the available dbase tables
+		 @param targetType An optional filtr for table type/group to retrieve
+		 @return A list of available tables
+		 */
+		TableIDList getTables(std::optional<TableType> targetType) const override;
+		/*!
+		 Get the default dbase table
+		 @return The default dbase table (nullopt if no table is available)
+		 */
+		std::optional<BIMRecordID> getDefaultTable() const;
+		/*!
+		 Set the default dbase table
+		 @param tableID The new default dbase table
+		 */
+		void setDefaultTable(const BIMRecordID& tableID) const;
+		/*!
+		 Find a filtered list of objects
+		 @param filter The object filter (nullptr = find all objects)
+		 @param tableID Optional table ID (defaults to the first table)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return A list containing IDs of found elements (empty if none found)
+		 */
+		virtual BIMRecordIDList findObjects(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
+									  std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
 		 Get an object by index
 		 @param objID The object ID
@@ -79,7 +111,7 @@ namespace speckle::database {
 		 @param objID The object ID
 		 @param tableID Optional table ID (defaults to the floor plan)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return: The requested wrapped cargo (nullptr on failure)
+		 @return The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
@@ -29,6 +29,7 @@ namespace speckle::database {
 		using Group = record::property::Group;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
+		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constructors
 		
@@ -46,6 +47,15 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
+		/*!
+		 Find a filtered list of objects
+		 @param filter The object filter (nullptr = find all objects)
+		 @param tableID Optional table ID (defaults to the first table)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return A list containing IDs of found elements (empty if none found)
+		 */
+		virtual ObjIDList findObjects(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
+									  std::optional<BIMRecordID> documentID = std::nullopt) const override { return {}; }	//Implement when required
 		/*!
 		 Get an object by ID
 		 @param objID The object ID
@@ -59,7 +69,7 @@ namespace speckle::database {
 		 @param objID The object ID
 		 @param tableID Optional table ID (default selected based on record type)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return: The requested wrapped cargo (nullptr on failure)
+		 @return The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
@@ -30,6 +30,7 @@ namespace speckle::database {
 		using Template = record::property::Template;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
+		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constructors
 		
@@ -47,6 +48,15 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
+		/*!
+		 Find a filtered list of objects
+		 @param filter The object filter (nullptr = find all objects)
+		 @param tableID Optional table ID (defaults to the first table)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return A list containing IDs of found elements (empty if none found)
+		 */
+		virtual ObjIDList findObjects(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
+									  std::optional<BIMRecordID> documentID = std::nullopt) const override { return {}; }	//Implement when required
 		/*!
 		 Find all property templates linked to specified classifications
 		 @param classifications The classifications
@@ -66,7 +76,7 @@ namespace speckle::database {
 		 @param objID The object ID
 		 @param tableID Optional table ID (default selected based on record type)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return: The requested wrapped cargo (nullptr on failure)
+		 @return The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
@@ -46,6 +46,7 @@ namespace speckle::database {
 		using base = active::database::DBaseEngine<Obj, ObjID, RecordID, RecordID>;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
+		using ObjIDList = base::ObjIDList;
 		using Cache = active::database::RecordCache<Obj, ObjWrapper, ObjID, RecordID, RecordID>;
 		
 		// MARK: - Constructors
@@ -59,6 +60,15 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
+		/*!
+		 Find a filtered list of objects
+		 @param filter The object filter (nullptr = find all objects)
+		 @param tableID Optional table ID (defaults to the first table)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return A list containing IDs of found elements (empty if none found)
+		 */
+		virtual ObjIDList findObjects(const Filter& filter = nullptr, std::optional<RecordID> tableID = std::nullopt,
+									  std::optional<RecordID> documentID = std::nullopt) const override { return {}; }	//Implement when required
 		/*!
 		 Get an object by index
 		 @param ID The object ID
@@ -72,7 +82,7 @@ namespace speckle::database {
 		 @param ID The object ID
 		 @param tableID Optional table ID (defaults to the first table)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return: The requested wrapped cargo (nullptr on failure)
+		 @return The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const ObjID& objID, std::optional<RecordID> tableID = std::nullopt, std::optional<RecordID> documentID = std::nullopt) const override;
 		/*!
@@ -171,8 +181,10 @@ namespace speckle::database {
 			//Read the data stored in the document
 		auto storedData = readStore();
 		m_cache = std::make_unique<Cache>();
-		if (!storedData)
+		if (!storedData) {
+			m_cache->setID(speckle::utility::Guid{true}.operator speckle::utility::String()); //Needs an ID - substitute for the Speckle 'document ID'
 			return m_cache.get();	//Return an empty container if there's no data
+		}
 			//Import the document data into the record cache
 		if constexpr (std::is_same_v<ObjWrapper, Obj>)
 			Transport().receive(std::forward<active::serialise::Cargo&&>(*m_cache), active::serialise::Identity{}, storedData);
@@ -0,0 +1,29 @@
+#ifndef SPECKLE_DATABASE_ELEMENT_STORAGE
+#define SPECKLE_DATABASE_ELEMENT_STORAGE
+
+#include "Speckle/Record/Element/Element.h"
+
+namespace speckle::database {
+	
+	/*!
+	 Fundamental concepts for element storage
+	 */
+	class ElementStorage {
+	public:
+		
+		// MARK: - Types
+		
+			///Element storage table types
+		enum class TableType {
+			primary2D,
+			primary3D,
+			section,
+			elevation,
+		};
+			///Element filter
+		using Filter = std::function<bool(const record::element::Element&)>;
+	};
+	
+}
+
+#endif	//SPECKLE_DATABASE_ELEMENT_STORAGE
@@ -2,6 +2,7 @@

 #include "Speckle/Environment/Project.h"
 #include "Speckle/Event/Type/ProjectEvent.h"
+#include "Speckle/Event/Subscriber/ProjectSubscriber.h"

 #include <limits>

@@ -18,6 +19,14 @@ namespace {
 		//An object representing the active addon
 	Addon* m_addonInstance = nullptr;

+		///An instance of this class is used to force project notifications to be issued from the moment the add-on is launched
+	class DummyProjectSubscriber : public ProjectSubscriber {
+	public:
+		bool start() override { return ProjectSubscriber::start(); }
+		bool handle(const ProjectEvent& event) override { return false; }
+	};
+
+	
 }

 /*--------------------------------------------------------------------
@@ -121,6 +130,8 @@ bool Addon::attach() {
 	return: True if the participant is able to continue
  --------------------------------------------------------------------*/
 bool Addon::start() {
+		//Force project notifications to be published
+	DummyProjectSubscriber().start();
 		//Add add-on functionality as required
 	return App::start();
 } //Addon::start
@@ -40,7 +40,7 @@ namespace speckle::environment {
 		 Get the active project
 		 @return The active project (nullptr = no open project)
 		 */
-		std::weak_ptr<Project> getActiveProject() const;
+		virtual std::weak_ptr<Project> getActiveProject() const;
 		/*!
 		 Get the session index
 		 @return The session index (non-recursive entries into the add-on)
@@ -1,4 +1,5 @@
 #include "Speckle/Environment/Host.h"
+#include "Active/Utility/Memory.h"

 #ifdef ARCHICAD
 #include "DG.h"
@@ -21,6 +22,26 @@ Host::Host() {
 } //Host::Host


+/*--------------------------------------------------------------------
+	Switch to the model view
+ 
+	isSelectionOnly: True to display just the selected elements
+ 
+ 	return: True if the model view is active
+ --------------------------------------------------------------------*/
+bool Host::makeModelViewActive(bool isSelectionOnly) const {
+#ifdef ARCHICAD
+	API_WindowInfo windowInfo;
+	active::utility::Memory::erase(windowInfo);
+	if ((ACAPI_Window_GetCurrentWindow(&windowInfo) == NoError) && (windowInfo.typeID == APIWind_3DModelID))
+		return true;
+	if (isSelectionOnly)
+		return (ACAPI_View_ShowSelectionIn3D() == NoError);
+	return (ACAPI_View_ShowAllIn3D() == NoError);
+#endif
+} //Host::makeModelViewActive
+
+
 /*--------------------------------------------------------------------
 	Display an alert dialog
 
@@ -20,6 +20,12 @@ namespace speckle::environment {

 		// MARK: Functions (const)
 		
+		/*!
+		 Switch to the model view
+		 @param isSelectionOnly True to display just the selected elements
+ 		 @return True if the model view is active
+		*/
+		bool makeModelViewActive(bool isSelectionOnly = false) const;
 		/*!
 		 Display an alert dialog
 		 @param message The alert message
@@ -48,7 +48,7 @@ namespace speckle::environment {
 		/*!
 		 Destructor
 		 */
-		~Project();
+		virtual ~Project();
 		
 		// MARK: - Functions (const)
 		
@@ -31,7 +31,8 @@ namespace {
 		switch (elemType->notifID)
 		{
 			case APINotifyElement_New: {
-				ACAPI_Element_AttachObserver(elemType->elemHead.guid);
+				// POC: Put this back once we decide to use Object Tracking
+				// ACAPI_Element_AttachObserver(elemType->elemHead.guid);
 				addon()->publishExternal(ElementEvent{newElem, ElementID{elemType->elemHead.guid}});
 			} break;
 			case APINotifyElement_Change: {
@@ -5,6 +5,7 @@
 #include "Active/Utility/BufferOut.h"
 #include "Speckle/Interface/Browser/Bridge/BrowserBridge.h"
 #include "Speckle/Record/Element/ModelElement.h"
+#include "Speckle/Utility/UserCancel.h"

 #include <utility>

@@ -45,7 +46,15 @@ std::unique_ptr<WrappedResultArg> GetCallResult::getResult(const WrappedResultAr
 	if (!item)
 		return nullptr;
 	String jsonOutput;
-	JSONTransport().send(std::forward<Cargo&&>(*item), Identity{}, jsonOutput);
+	try {
+		JSONTransport().send(std::forward<Cargo&&>(*item), Identity{}, jsonOutput);
+	} catch(const UserCancel& userCancel) {
+			//If the user cancels and we have a model card ID, notify the JS UI that the operation is cancelled
+		if (userCancel.getModelCardID())
+			getBridge()->sendEvent("triggerCancelSend",
+								   std::make_unique<CargoHold<ValueWrap<String>, String>>(String{*userCancel.getModelCardID()}));
+		jsonOutput = "null";
+	}
 	record::element::ModelElement::resetCache();
 	return std::make_unique<WrappedResultArg>(jsonOutput);
 } //GetCallResult::getResult
@@ -0,0 +1,101 @@
+#include "Speckle/Interface/Component/Progress.h"
+
+#include <mutex>
+
+#ifdef ARCHICAD
+#include "ACAPI_Interface.h"
+#endif
+
+using namespace speckle::interfac;
+using namespace speckle::utility;
+
+namespace {
+	
+		///The progress class instance - a weak reference is held so the object is released when active users complete
+	std::weak_ptr<Progress> m_instance;
+		///Mutex controlling management of the progress instance
+	std::mutex m_mutex;
+	
+}
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Progress::~Progress() {
+#ifdef ARCHICAD
+	ACAPI_ProcessWindow_CloseProcessWindow();
+#endif
+} //Progress::~Progress
+
+
+/*--------------------------------------------------------------------
+	Get a progress component instance
+ 
+	title: The process title, i.e. for the overall operation. Ignored if an instance is already in operation
+	stages: The number of stages for completing the overall operation. Ignored if an instance is already in operation
+ 
+	return: The progress instance - can be an active progress component if it has already been started (nullptr on failure)
+  --------------------------------------------------------------------*/
+Progress::Shared Progress::getInstance(const String& title, size_t stages) {
+	const std::lock_guard<std::mutex> lock(m_mutex);
+	if (auto instance = m_instance.lock(); instance)
+		return instance;
+#ifdef ARCHICAD
+	GS::UniString gsTitle{title};
+	auto phases = static_cast<Int32>(stages);
+	if (ACAPI_ProcessWindow_InitProcessWindow(&gsTitle, &phases) != NoError)
+		return nullptr;
+#endif
+	auto result = Progress::Shared{new Progress};
+	m_instance = result;
+	return result;
+} //Progress::getInstance
+
+
+/*--------------------------------------------------------------------
+	Addition with assignment
+ 
+	toAdd: The number of steps to add to the progress of the current stage
+  --------------------------------------------------------------------*/
+void Progress::operator+= (size_t toAdd) {
+#ifdef ARCHICAD
+	auto incVal = static_cast<Int32>(toAdd);
+	ACAPI_ProcessWindow_IncProcessValue(&incVal);
+#endif
+} //Progress::operator+=
+
+
+/*--------------------------------------------------------------------
+	Increment operator (increment the the progress of the current stage)
+  --------------------------------------------------------------------*/
+void Progress::operator++ () {
+	operator+=(1);
+} //Progress::operator++
+
+
+/*--------------------------------------------------------------------
+	Start the next stage
+ 
+	title: The stage title
+	stepCount: The number of steps in this stage
+	showPercentage: True to estimate/display the process completion percentage
+  --------------------------------------------------------------------*/
+void Progress::startStage(const String& title, size_t stepCount, bool showPercentage) {
+#ifdef ARCHICAD
+	GS::UniString gsTitle{title};
+	auto maxVal = static_cast<Int32>(stepCount);
+	ACAPI_ProcessWindow_SetNextProcessPhase(&gsTitle, &maxVal, &showPercentage);
+#endif
+} //Progress::startStage
+
+
+/*--------------------------------------------------------------------
+	Determine if the process has been cancelled, e.g. the user cancelling
+ 
+	return: True if the process has been cancelled
+  --------------------------------------------------------------------*/
+bool Progress::isCancelled() {
+#ifdef ARCHICAD
+	return (ACAPI_ProcessWindow_IsProcessCanceled() != NoError);
+#endif
+} //Progress::isCancelled
@@ -0,0 +1,80 @@
+#ifndef SPECKLE_INTERFACE_PROGRESS
+#define SPECKLE_INTERFACE_PROGRESS
+
+#include "Speckle/Utility/String.h"
+
+#include <memory>
+
+namespace speckle::interfac {
+	
+	/*!
+	 Interface component to provide progress feedback during some long process to the user, e.g. a progress meter
+	 
+	 The structure of this component is intended for a host-wide singleton, i.e. a modal process that locks out other processes, rather than
+	 simply (say) a progress bar as a component in a dialog/palette. This reflects the behaviour of Archicad but may be adapted to other
+	 hosts
+	 */
+	class Progress {
+	public:
+
+		// MARK: - Types
+		
+			///Shared pointer
+		using Shared = std::shared_ptr<Progress>;
+
+		// MARK: - Constructors
+		
+		Progress(const Progress&) = delete;
+		/*!
+		 Destructor
+		 */
+		~Progress();
+
+		/*!
+		 Get a progress component instance
+		 @param title The process title, i.e. for the overall operation. Ignored if an instance is already in operation
+		 @param stages The number of stages for completing the overall operation. Ignored if an instance is already in operation
+		 @return The progress instance - can be an active progress component if it has already been started (nullptr on failure)
+		 */
+		static Shared getInstance(const utility::String& title = {}, size_t stages = 1);
+		
+		// MARK: - Operators
+		
+		/*!
+		 Addition with assignment
+		 @param toAdd The number of steps to add to the progress of the current stage
+		 */
+		void operator+= (size_t toAdd);
+		/*!
+		 Increment operator (increment the the progress of the current stage)
+		 */
+		void operator++ ();
+		
+		// MARK: - Functions (const)
+
+		/*!
+		 Determine if the process has been cancelled, e.g. the user cancelling
+		 @return True if the process has been cancelled
+		 */
+		bool isCancelled();
+		
+		// MARK: - Functions (mutating)
+
+		/*!
+		 Start the next stage
+		 @param title The stage title
+		 @param stepCount The number of steps in this stage
+		 @param showPercentage True to estimate/display the process completion percentage
+		 */
+		void startStage(const utility::String& title, size_t stepCount, bool showPercentage = true);
+		
+	private:
+		/*!
+		 Default constructor
+		 */
+		Progress() {}
+	};
+	
+}
+
+#endif	//SPECKLE_INTERFACE_PROGRESS
@@ -1,6 +1,7 @@
 #include "Speckle/Primitive/Mesh/Mesh.h"

 #include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Item/Wrapper/FastDoubleWrap.h"
 #include "Active/Serialise/Package/Wrapper/PackageWrap.h"
 #include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
 #include "Active/Serialise/Inventory/Identity.h"
@@ -78,7 +79,7 @@ Cargo::Unique Mesh::getCargo(const Inventory::Item& item) const {
 	using namespace active::serialise;
 	switch (item.index) {
 	case vertexID:
-			return std::make_unique<ContainerWrap<std::vector<double>>>(m_vertices);
+			return std::make_unique<ContainerWrap<std::vector<double>, FastDoubleWrap>>(m_vertices);
 		case faceID:
 			return std::make_unique<ContainerWrap<std::vector<int>>>(m_faces);
 		case colorID:
@@ -98,6 +99,6 @@ void Mesh::useManagement(Management* management) const {
 		//NB: This object only exists to populate the finish collection - it doesn't carry any serialisable content
 	if (management != nullptr) {
 		if (auto collector = management->get<FinishCollector>(); collector != nullptr)
-			collector->addMaterialProxy(m_finish, getBIMID());
+			collector->addFinishProxy(m_finish, getBIMID());
 	}
 } //Mesh::useManagement
@@ -0,0 +1,196 @@
+#include "Speckle/Record/Attribute/Material.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Management/Management.h"
+#include "Active/Serialise/CargoHold.h"
+#include "Active/Utility/BufferOut.h"
+#include "Speckle/Serialise/Collection/FinishCollector.h"
+#include "Speckle/Serialise/Types/ArchicadRGB.h"
+#include "Speckle/Utility/Guid.h"
+
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::record::attribute;
+using namespace speckle::serialise;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace speckle::record::attribute {
+	
+		///Internal representation of a rendered finish on a 3D body, i.e. the surface colour/texture etc.
+	class Material::Data {
+	public:
+#ifdef ARCHICAD
+		/*!
+		 Constructor from Archicad material
+		 @param attr An Archicad attribute
+		 */
+		Data(const API_Attribute& attr) : root{attr.buildingMaterial} {
+		}
+		
+			///Archicad representation of a building material
+		API_BuildingMaterialType root;
+#endif
+	};
+	
+}
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		thermConductID,
+			//TODO: Add other fields as required
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"thermalConductivity"},
+			//TODO: Add other fields as required
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Material::Material() {
+} //Material::Material
+
+
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	ID: The attribute ID
+  --------------------------------------------------------------------*/
+Material::Material(const database::BIMRecordID& ID) : base{ID, Material::table} {
+} //Material::Material
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	attrData: Archicad attribute data
+	tableID: The ID of the parent table
+  --------------------------------------------------------------------*/
+Material::Material(const API_Attribute& attrData, const BIMRecordID& tableID) : base{attrData.header.guid, Material::table} {
+	m_data = std::make_unique<Data>(attrData);
+	setUnit(std::nullopt);	//Finishes have no unit
+}
+#endif
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+ 
+ 	source: The object to copy
+  --------------------------------------------------------------------*/
+Material::Material(const Material& source) : base{source} {
+	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
+} //Material::Material
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Material::~Material() {}
+
+
+/*--------------------------------------------------------------------
+	Assignment operator
+ 
+	source: The object to assign
+ 
+	return: A reference to this
+  --------------------------------------------------------------------*/
+Material& Material::operator=(const Material& source) {
+	if (this != &source) {
+		base::operator=(source);
+		m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
+	}
+	return *this;
+} //Material::operator=
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the (immutable) API attribute header data
+ 
+	return: The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+const API_Attr_Head& Material::getHead() const {
+	confirmData();
+	return m_data->root.head;
+} //Material::getHead
+
+
+/*--------------------------------------------------------------------
+	Get the (mutable) API attribute header data
+ 
+	return: The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+API_Attr_Head& Material::getHead() {
+	confirmData();
+	return m_data->root.head;
+} //Material::getHead
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+ 
+	inventory: The inventory to receive the package items
+ 
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Material::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[thermConductID], thermConductID, element },
+		},
+	}.withType(&typeid(Material)));
+	return base::fillInventory(inventory);
+} //Material::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Material::getCargo(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(Material))
+		return base::getCargo(item);
+	confirmData();
+	using namespace active::serialise;
+	switch (item.index) {
+		case thermConductID:
+			return std::make_unique<DoubleWrap>(m_data->root.thermalConductivity);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //Material::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Material::setDefault() {
+	m_data->root = {};
+} //Material::setDefault
+
+
+/*--------------------------------------------------------------------
+	Confirm the internal data, either loading from the BIM application or setting a default
+  --------------------------------------------------------------------*/
+void Material::confirmData() const {
+	if (m_data)
+		return;
+	m_data = std::make_unique<Data>(getData());
+} //Material::confirmData
@@ -0,0 +1,143 @@
+#ifndef SPECKLE_RECORD_ATTRIBUTE_MATERIAL
+#define SPECKLE_RECORD_ATTRIBUTE_MATERIAL
+
+#include "Speckle/Record/Attribute/Attribute.h"
+
+#ifdef ARCHICAD
+namespace ModelerAPI {
+	class Material;
+}
+#endif
+
+namespace speckle::record::attribute {
+	
+	/*!
+	 Class to represent the construction material of a building element, e.g. concrete, timber, glass, stone etc
+	 
+	 Note the difference with a Finish (which is only applied to the surface).
+	 In Archicad this attribute is represented by `API_BuildingMaterialType`
+	 */
+	class Material : public Attribute {
+	public:
+
+		// MARK: - Types
+		
+		using base = Attribute;
+			///Unique pointer
+		using Unique = std::unique_ptr<Material>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Material>;
+			///Optional
+		using Option = std::optional<Material>;
+		
+		// MARK: - Constants
+		
+#ifdef ARCHICAD
+			///The finishes table identifier
+		static constexpr active::utility::Guid table{active::utility::Guid::fromInt(API_BuildingMaterialID)};
+#endif
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Material();
+		/*!
+		 Constructor
+		 @param ID The attribute ID
+		 */
+		Material(const database::BIMRecordID& ID);
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param attrData Archicad attribute data
+		 @param tableID The ID of the parent table
+		 */
+		Material(const API_Attribute& attrData, const database::BIMRecordID& tableID);
+#endif
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Material(const Material& source);
+		/*!
+		 Destructor
+		 */
+		~Material();
+
+		/*!
+		 Object cloning
+		 @return A clone of this object
+		 */
+		Material* clonePtr() const override { return new Material{*this}; }
+		
+		// MARK: - Operators
+		
+		/*!
+		 Assignment operator
+		 @param source The object to assign
+		 @return A reference to this
+		 */
+		Material& operator=(const Material& source);
+
+		// MARK: - Functions (const)
+
+		/*!
+		 Get the speckle type identifier
+		 @return The speckle type (relevant objects should override as required)
+		 */
+		speckle::utility::String getSpeckleType() const override { return "Objects.Other.Material"; }
+#ifdef ARCHICAD
+		/*!
+		 Get the (immutable) API attribute header data
+		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		const API_Attr_Head& getHead() const override;
+#endif
+		
+		// MARK: - Functions (mutating)
+
+#ifdef ARCHICAD
+		/*!
+		 Get the (mutable) API attribute header data
+		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		API_Attr_Head& getHead() override;
+#endif
+
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+		
+	private:
+		/*!
+		 Confirm the internal data, either loading from the BIM application or setting a default
+		 */
+		void confirmData() const;
+		
+		class Data;
+			///The attribute data - mutable to support lazy loading
+		mutable std::unique_ptr<Data> m_data;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ATTRIBUTE_MATERIAL
@@ -1,15 +1,8 @@
 #include "Speckle/Record/Element/Beam.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
 #include "Active/Serialise/Package/Wrapper/PackageWrap.h"
-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
-#include "Speckle/Environment/Addon.h"
-#include "Speckle/Primitive/Mesh/Mesh.h"
-#include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/Guid.h"

 using namespace active::serialise;
-using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -24,12 +17,11 @@ namespace speckle::record::element {
 		friend class Beam;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{ std::make_unique<API_BeamType>(elem.beam) } {}
-		Data(const Data& source) : root{ std::make_unique<API_BeamType>(*source.root) } {}
+		Data(const API_Element& elem) : root{elem.beam} {}
 #endif

 	private:
-		std::unique_ptr<API_BeamType> root;
+		API_BeamType root;
 	};

 }
@@ -91,7 +83,7 @@ Beam::~Beam() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& Beam::getHead() const {
-	return m_data->root->head;
+	return m_data->root.head;
 } //Beam::getHead

 /*--------------------------------------------------------------------
@@ -100,7 +92,7 @@ const API_Elem_Head& Beam::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& Beam::getHead() {
-	return m_data->root->head;
+	return m_data->root.head;
 } //Beam::getHead


@@ -1,21 +1,17 @@
 #include "Speckle/Record/Element/BeamSegment.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
-#include "Speckle/Environment/Addon.h"
-#include "Speckle/Primitive/Mesh/Mesh.h"
-#include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/Guid.h"
+#include "Speckle/Record/Element/Quants/Surveyor.h"
+#include "Speckle/Record/Element/Setting/Conversion.h"
+#include "Speckle/Utility/BIMMemory.h"

 #ifdef ARCHICAD
 #include <ACAPinc.h>
 #endif

 using namespace active::serialise;
-using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
+using namespace speckle::record::element::quants;
 using namespace speckle::utility;

 #include <array>
@@ -28,11 +24,10 @@ namespace speckle::record::element {
 		friend class BeamSegment;

 #ifdef ARCHICAD
-		Data(const API_BeamSegmentType& seg) : root{ std::make_unique<API_BeamSegmentType>(seg) } {}
-		Data(const Data& source) : root{ std::make_unique<API_BeamSegmentType>(*source.root) } {}
+		Data(const API_BeamSegmentType& seg) : root{seg} {}

 	private:
-		std::unique_ptr<API_BeamSegmentType> root;
+		API_BeamSegmentType root;
 #endif
 	};

@@ -102,6 +97,46 @@ BeamSegment::BeamSegment(BeamSegment&& source) noexcept : base{source} {
 BeamSegment::~BeamSegment() {}


+/*--------------------------------------------------------------------
+	Get the composition of materials in the element
+ 
+	return: The material composition (element with ordered material composition should override)
+  --------------------------------------------------------------------*/
+ModelElement::Composition BeamSegment::getComposition() const {
+#ifdef ARCHICAD
+	return convert(m_data->root.assemblySegmentData.modelElemStructureType);
+#endif
+} //BeamSegment::getComposition
+
+
+/*--------------------------------------------------------------------
+	Get the element material (applicable to elements with a single, homogenous material)
+ 
+	return: The element material (nullopt if not applicable to the element)
+  --------------------------------------------------------------------*/
+std::optional<Material> BeamSegment::getMaterial() const {
+#ifdef ARCHICAD
+	return Material{Guid{Guid::fromInt(m_data->root.assemblySegmentData.buildingMaterial.GenerateHashValue())}};
+#endif
+} //BeamSegment::getMaterial
+
+
+/*--------------------------------------------------------------------
+	Get a spatial measurement from this element (area/volume, as used for material quantities)
+ 
+	return: The element measurement (empty if unavailable)
+  --------------------------------------------------------------------*/
+ModelElement::SpatialMeasure BeamSegment::getSpatialMeasure() const {
+#ifdef ARCHICAD
+	Surveyor surveyor;
+	BIMMemory::setMask(&surveyor.elementMask().beamSegment.rightSurface);
+	BIMMemory::setMask(&surveyor.elementMask().beamSegment.volume);
+	surveyor.measure(getBIMLink());
+	return SpatialMeasure{surveyor.quantity().beamSegment.rightSurface, surveyor.quantity().beamSegment.volume};
+#endif
+} //BeamSegment::getSpatialMeasure
+
+
 #ifdef ARCHICAD
 /*--------------------------------------------------------------------
 	Get the (immutable) API element header data
@@ -109,7 +144,7 @@ BeamSegment::~BeamSegment() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& BeamSegment::getHead() const {
-	return m_data->root->head;
+	return m_data->root.head;
 } //BeamSegment::getHead


@@ -119,7 +154,7 @@ const API_Elem_Head& BeamSegment::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& BeamSegment::getHead() {
-	return m_data->root->head;
+	return m_data->root.head;
 } //BeamSegment::getHead
 #endif

@@ -64,6 +64,21 @@ namespace speckle::record::element {

 		// MARK: - Functions (const)

+		/*!
+		 Get the composition of materials in the element
+		 @return The material composition (element with ordered material composition should override)
+		 */
+		Composition getComposition() const override;
+		/*!
+		 Get the element material (applicable to elements with a single, homogenous material)
+		 @return The element material (nullopt if not applicable to the element)
+		 */
+		std::optional<record::attribute::Material> getMaterial() const override;
+		/*!
+		 Get a spatial measurement from this element (area/volume, as used for material quantities)
+		 @return The element measurement (empty if unavailable)
+		 */
+		SpatialMeasure getSpatialMeasure() const override;
 #ifdef ARCHICAD
 		/*!
 		 Get the (immutable) API element header data
@@ -1,15 +1,8 @@
 #include "Speckle/Record/Element/Column.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
 #include "Active/Serialise/Package/Wrapper/PackageWrap.h"
-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
-#include "Speckle/Environment/Addon.h"
-#include "Speckle/Primitive/Mesh/Mesh.h"
-#include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/Guid.h"

 using namespace active::serialise;
-using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -24,12 +17,11 @@ namespace speckle::record::element {
 		friend class Column;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{ std::make_unique<API_ColumnType>(elem.column) } {}
-		Data(const Data& source) : root{ std::make_unique<API_ColumnType>(*source.root) } {}
+		Data(const API_Element& elem) : root{elem.column} {}
 #endif

 	private:
-		std::unique_ptr<API_ColumnType> root;
+		API_ColumnType root;
 	};

 }
@@ -91,7 +83,7 @@ Column::~Column() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& Column::getHead() const {
-	return m_data->root->head;
+	return m_data->root.head;
 } //Column::getHead

 /*--------------------------------------------------------------------
@@ -100,7 +92,7 @@ const API_Elem_Head& Column::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& Column::getHead() {
-	return m_data->root->head;
+	return m_data->root.head;
 } //Column::getHead


@@ -1,21 +1,17 @@
 #include "Speckle/Record/Element/ColumnSegment.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
-#include "Speckle/Environment/Addon.h"
-#include "Speckle/Primitive/Mesh/Mesh.h"
-#include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/Guid.h"
+#include "Speckle/Record/Element/Quants/Surveyor.h"
+#include "Speckle/Record/Element/Setting/Conversion.h"
+#include "Speckle/Utility/BIMMemory.h"

 #ifdef ARCHICAD
 #include <ACAPinc.h>
 #endif

 using namespace active::serialise;
-using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
+using namespace speckle::record::element::quants;
 using namespace speckle::utility;

 #include <array>
@@ -28,11 +24,10 @@ namespace speckle::record::element {
 		friend class ColumnSegment;

 #ifdef ARCHICAD
-		Data(const API_ColumnSegmentType& seg) : root{ std::make_unique<API_ColumnSegmentType>(seg) } {}
-		Data(const Data& source) : root{ std::make_unique<API_ColumnSegmentType>(*source.root) } {}
+		Data(const API_ColumnSegmentType& seg) : root{seg} {}

 	private:
-		std::unique_ptr<API_ColumnSegmentType> root;
+		API_ColumnSegmentType root;
 #endif
 	};

@@ -102,6 +97,46 @@ ColumnSegment::ColumnSegment(ColumnSegment&& source) noexcept : base{source} {
 ColumnSegment::~ColumnSegment() {}


+/*--------------------------------------------------------------------
+	Get the composition of materials in the element
+ 
+	return: The material composition (element with ordered material composition should override)
+  --------------------------------------------------------------------*/
+ModelElement::Composition ColumnSegment::getComposition() const {
+#ifdef ARCHICAD
+	return convert(m_data->root.assemblySegmentData.modelElemStructureType);
+#endif
+} //ColumnSegment::getComposition
+
+
+/*--------------------------------------------------------------------
+	Get the element material (applicable to elements with a single, homogenous material)
+ 
+	return: The element material (nullopt if not applicable to the element)
+  --------------------------------------------------------------------*/
+std::optional<Material> ColumnSegment::getMaterial() const {
+#ifdef ARCHICAD
+	return Material{Guid{Guid::fromInt(m_data->root.assemblySegmentData.buildingMaterial.GenerateHashValue())}};
+#endif
+} //ColumnSegment::getMaterial
+
+
+/*--------------------------------------------------------------------
+	Get a spatial measurement from this element (area/volume, as used for material quantities)
+ 
+	return: The element measurement (empty if unavailable)
+  --------------------------------------------------------------------*/
+ModelElement::SpatialMeasure ColumnSegment::getSpatialMeasure() const {
+#ifdef ARCHICAD
+	Surveyor surveyor;
+	BIMMemory::setMask(&surveyor.elementMask().columnSegment.coreNetSurface);
+	BIMMemory::setMask(&surveyor.elementMask().columnSegment.volume);
+	surveyor.measure(getBIMLink());
+	return SpatialMeasure{surveyor.quantity().columnSegment.coreNetSurface, surveyor.quantity().columnSegment.volume};
+#endif
+} //ColumnSegment::getSpatialMeasure
+
+
 #ifdef ARCHICAD
 /*--------------------------------------------------------------------
 	Get the (immutable) API element header data
@@ -109,7 +144,7 @@ ColumnSegment::~ColumnSegment() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& ColumnSegment::getHead() const {
-	return m_data->root->head;
+	return m_data->root.head;
 } //ColumnSegment::getHead


@@ -119,7 +154,7 @@ const API_Elem_Head& ColumnSegment::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& ColumnSegment::getHead() {
-	return m_data->root->head;
+	return m_data->root.head;
 } //ColumnSegment::getHead
 #endif

@@ -64,6 +64,21 @@ namespace speckle::record::element {

 		// MARK: - Functions (const)

+		/*!
+		 Get the composition of materials in the element
+		 @return The material composition (element with ordered material composition should override)
+		 */
+		Composition getComposition() const override;
+		/*!
+		 Get the element material (applicable to elements with a single, homogenous material)
+		 @return The element material (nullopt if not applicable to the element)
+		 */
+		std::optional<record::attribute::Material> getMaterial() const override;
+		/*!
+		 Get a spatial measurement from this element (area/volume, as used for material quantities)
+		 @return The element measurement (empty if unavailable)
+		 */
+		SpatialMeasure getSpatialMeasure() const override;
 #ifdef ARCHICAD
 		/*!
 		 Get the (immutable) API element header data
@@ -1,15 +1,6 @@
 #include "Speckle/Record/Element/DrawingElement.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
-#include "Speckle/Environment/Addon.h"
-#include "Speckle/Primitive/Mesh/Mesh.h"
-#include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/Guid.h"
-
 using namespace active::serialise;
-using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -1,24 +1,120 @@
 #include "Speckle/Record/Element/Element.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Active/Serialise/CargoHold.h"
+#include "Active/Serialise/Management/Management.h"
 #include "Speckle/Database/BIMElementDatabase.h"
 #include "Speckle/Environment/Addon.h"
 #include "Speckle/Environment/Project.h"
-#include "Speckle/Primitive/Mesh/Mesh.h"
 #include "Speckle/Record/Element/Memo.h"
+#include "Speckle/Record/Element/Setting/TypeSetting.h"
+#include "Speckle/Serialise/Collection/ConversionReporter.h"
 #include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/Guid.h"
+#include "Speckle/Utility/UserCancel.h"

 using namespace active::serialise;
+using namespace speckle::database;
 using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
+using namespace speckle::serialise;
 using namespace speckle::utility;

 #include <array>
 #include <memory>
+#include <string>
+
+namespace {
+    ///Serialisation fields
+    enum FieldIndex {
+        applicationTypeD,
+    };
+
+    ///Serialisation field IDs
+    static std::array fieldID = {
+        Identity{"applicationType"},
+    };
+
+#ifdef ARCHICAD
+    String GetElemTypeName(API_ElemTypeID elemTypeID) {
+        switch (elemTypeID) {
+        case API_WallID: return "Wall";
+        case API_ColumnID: return "Column";
+        case API_BeamID: return "Beam";
+        case API_WindowID: return "Window";
+        case API_DoorID: return "Door";
+        case API_ObjectID: return "Object";
+        case API_LampID: return "Lamp";
+        case API_SlabID: return "Slab";
+        case API_RoofID: return "Roof";
+        case API_MeshID: return "Mesh";
+        case API_DimensionID: return "Dimension";
+        case API_RadialDimensionID: return "RadialDimension";
+        case API_LevelDimensionID: return "LevelDimension";
+        case API_AngleDimensionID: return "AngleDimension";
+        case API_TextID: return "Text";
+        case API_LabelID: return "Label";
+        case API_ZoneID: return "Zone";
+        case API_HatchID: return "Hatch";
+        case API_LineID: return "Line";
+        case API_PolyLineID: return "PolyLine";
+        case API_ArcID: return "Arc";
+        case API_CircleID: return "Circle";
+        case API_SplineID: return "Spline";
+        case API_HotspotID: return "Hotspot";
+        case API_CutPlaneID: return "CutPlane";
+        case API_CameraID: return "Camera";
+        case API_CamSetID: return "CamSet";
+        case API_GroupID: return "Group";
+        case API_SectElemID: return "SectElem";
+        case API_DrawingID: return "Drawing";
+        case API_PictureID: return "Picture";
+        case API_DetailID: return "Detail";
+        case API_ElevationID: return "Elevation";
+        case API_InteriorElevationID: return "InteriorElevation";
+        case API_WorksheetID: return "Worksheet";
+        case API_HotlinkID: return "Hotlink";
+        case API_CurtainWallID: return "CurtainWall";
+        case API_CurtainWallSegmentID: return "CurtainWallSegment";
+        case API_CurtainWallFrameID: return "CurtainWallFrame";
+        case API_CurtainWallPanelID: return "CurtainWallPanel";
+        case API_CurtainWallJunctionID: return "CurtainWallJunction";
+        case API_CurtainWallAccessoryID: return "CurtainWallAccessory";
+        case API_ShellID: return "Shell";
+        case API_SkylightID: return "Skylight";
+        case API_MorphID: return "Morph";
+        case API_ChangeMarkerID: return "ChangeMarker";
+        case API_StairID: return "Stair";
+        case API_RiserID: return "Riser";
+        case API_TreadID: return "Tread";
+        case API_StairStructureID: return "StairStructure";
+        case API_RailingID: return "Railing";
+        case API_RailingToprailID: return "RailingToprail";
+        case API_RailingHandrailID: return "RailingHandrail";
+        case API_RailingRailID: return "RailingRail";
+        case API_RailingPostID: return "RailingPost";
+        case API_RailingInnerPostID: return "RailingInnerPost";
+        case API_RailingBalusterID: return "RailingBaluster";
+        case API_RailingPanelID: return "RailingPanel";
+        case API_RailingSegmentID: return "RailingSegment";
+        case API_RailingNodeID: return "RailingNode";
+        case API_RailingBalusterSetID: return "RailingBalusterSet";
+        case API_RailingPatternID: return "RailingPattern";
+        case API_RailingToprailEndID: return "RailingToprailEnd";
+        case API_RailingHandrailEndID: return "RailingHandrailEnd";
+        case API_RailingRailEndID: return "RailingRailEnd";
+        case API_RailingToprailConnectionID: return "RailingToprailConnection";
+        case API_RailingHandrailConnectionID: return "RailingHandrailConnection";
+        case API_RailingRailConnectionID: return "RailingRailConnection";
+        case API_RailingEndFinishID: return "RailingEndFinish";
+        case API_BeamSegmentID: return "BeamSegment";
+        case API_ColumnSegmentID: return "ColumnSegment";
+        case API_OpeningID: return "Opening";
+        case API_ExternalElemID: return "ExternalElem";
+        default: return "UnknownElemType";
+        }
+    }
+#endif
+}

 /*--------------------------------------------------------------------
 	Default constructor
@@ -75,17 +171,42 @@ Storey::Option Element::getStorey() const {


 /*--------------------------------------------------------------------
-	Get the element type name, e.g. "Wall", "Roof" etc
+	Get a link to the BIM record
+ 
+	return: The BIM record link
+  --------------------------------------------------------------------*/
+BIMLink Element::getBIMLink() const {
+	auto result = base::getBIMLink();
+#ifdef ARCHICAD
+	result.emplace_back(std::make_unique<TypeSetting>(getHead()));
+#endif
+	return result;
+} //Element::getLink
+
+
+/*--------------------------------------------------------------------
+	Get the localised element type name, e.g. "Wall", "Roof" etc

 	return: The type name
  --------------------------------------------------------------------*/
-String Element::getTypeName() const {
+String Element::getLocalisedTypeName() const {
 #ifdef ARCHICAD
 	GS::UniString typeName;
 	if (auto err = ACAPI_Element_GetElemTypeName(getHead().type, typeName); err != NoError)
 		return addon()->getLocalString(titleStringLib, unknownElementTypeID);
 	return typeName;
 #endif
+} //Element::getLocalisedTypeName
+
+
+/*--------------------------------------------------------------------
+	Get the element type name, e.g. "Wall", "Roof" etc
+
+	return: The type name
+  --------------------------------------------------------------------*/
+#include "Speckle/Environment/Platform.h"
+String Element::getTypeName() const {
+    return GetElemTypeName(getHead().type.typeID);
 } //Element::getTypeName


@@ -97,6 +218,12 @@ String Element::getTypeName() const {
 	return: True if the package has added items to the inventory
  --------------------------------------------------------------------*/
 bool Element::fillInventory(Inventory& inventory) const {
+    using enum Entry::Type;
+    inventory.merge(Inventory{
+        {
+            { fieldID[applicationTypeD], applicationTypeD, element },
+        },
+        }.withType(&typeid(Element)));
 	return base::fillInventory(inventory);
 } //Element::fillInventory

@@ -109,7 +236,15 @@ bool Element::fillInventory(Inventory& inventory) const {
 	return: The requested cargo (nullptr on failure)
  --------------------------------------------------------------------*/
 Cargo::Unique Element::getCargo(const Inventory::Item& item) const {
-		return base::getCargo(item);
+    if (item.ownerType != &typeid(Element))
+        return base::getCargo(item);
+    using namespace active::serialise;
+    switch (item.index) {
+        case applicationTypeD:
+            return Cargo::Unique{ new CargoHold<ValueWrap<String>, String>{ getTypeName() } };
+        default:
+            return nullptr;	//Requested an unknown index
+    }
 } //Element::getCargo


@@ -121,6 +256,22 @@ void Element::setDefault() {
 } //Element::setDefault


+/*--------------------------------------------------------------------
+	Use a manager in (de)serialisation processes
+ 
+	management: The management to use
+  --------------------------------------------------------------------*/
+void Element::useManagement(Management* management) const {
+	if (management != nullptr) {
+			//If a conversion report is collected, add this record to the report (also updates progress display in the UI)
+		if (auto reporter = management->get<ConversionReporter>(); reporter != nullptr) {
+			if (!reporter->logRecord(getBIMID(), {ConversionReporter::Data::Status::success, getTypeName(), getSpeckleType()}))
+				throw UserCancel{reporter->getModelCardID()};
+		}
+	}
+} //Element::useManagement
+
+
 /*--------------------------------------------------------------------
 	Load the element memo structure (elements must override according to requirements)
 
@@ -62,7 +62,12 @@ namespace speckle::record::element {
 		// MARK: - Functions (const)

 		/*!
-		 Get the elmeent type name, e.g. "Wall", "Roof" etc
+		 Get the localised element type name, e.g. "Wall", "Roof" etc
+		 @return The type name
+		 */
+		virtual speckle::utility::String getLocalisedTypeName() const;
+		/*!
+		 Get the element type name, e.g. "Wall", "Roof" etc
 		 @return The type name
 		 */
 		virtual speckle::utility::String getTypeName() const;
@@ -71,6 +76,11 @@ namespace speckle::record::element {
 		 @return The element storey (nullopt if the element isn't linked to a storey)
 		 */
 		virtual attribute::Storey::Option getStorey() const;
+		/*!
+		 Get a link to the BIM record
+		 @return The BIM record link
+		 */
+		database::BIMLink getBIMLink() const override;
 #ifdef ARCHICAD
 		/*!
 		 Get the (immutable) API element header data
@@ -107,6 +117,11 @@ namespace speckle::record::element {
 		 Set to the default package content
 		 */
 		void setDefault() override;
+		/*!
+		 Use a manager in (de)serialisation processes
+		 @param management The management to use
+		 */
+		void useManagement(active::serialise::Management* management) const override;
 		
 	protected:
 		/*!
@@ -1,15 +1,6 @@
 #include "Speckle/Record/Element/GenericDrawingElement.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
-#include "Speckle/Environment/Addon.h"
-#include "Speckle/Primitive/Mesh/Mesh.h"
-#include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/Guid.h"
-
 using namespace active::serialise;
-using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -24,12 +15,11 @@ namespace speckle::record::element {
 		friend class GenericDrawingElement;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{ std::make_unique<API_Element>(elem) } {}
-		Data(const Data& source) : root{ std::make_unique<API_Element>(*source.root) } {}
+		Data(const API_Element& elem) : root{elem} {}
 #endif

 	private:
-		std::unique_ptr<API_Element> root;
+		API_Element root;
 	};

 }
@@ -75,7 +65,7 @@ GenericDrawingElement::~GenericDrawingElement() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& GenericDrawingElement::getHead() const {
-	return m_data->root->header;
+	return m_data->root.header;
 } //GenericDrawingElement::getHead

 /*--------------------------------------------------------------------
@@ -84,7 +74,7 @@ const API_Elem_Head& GenericDrawingElement::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& GenericDrawingElement::getHead() {
-	return m_data->root->header;
+	return m_data->root.header;
 } //GenericDrawingElement::getHead
 #endif

@@ -1,15 +1,6 @@
 #include "Speckle/Record/Element/GenericModelElement.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
-#include "Speckle/Environment/Addon.h"
-#include "Speckle/Primitive/Mesh/Mesh.h"
-#include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/Guid.h"
-
 using namespace active::serialise;
-using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -24,12 +15,11 @@ namespace speckle::record::element {
 		friend class GenericModelElement;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{ std::make_unique<API_Element>(elem) } {}
-		Data(const Data& source) : root{ std::make_unique<API_Element>(*source.root) } {}
+		Data(const API_Element& elem) : root{elem} {}
 #endif

 	private:
-		std::unique_ptr<API_Element> root;
+		API_Element root;
 	};

 }
@@ -75,7 +65,7 @@ GenericModelElement::~GenericModelElement() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& GenericModelElement::getHead() const {
-	return m_data->root->header;
+	return m_data->root.header;
 } //GenericModelElement::getHead

 /*--------------------------------------------------------------------
@@ -84,7 +74,7 @@ const API_Elem_Head& GenericModelElement::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& GenericModelElement::getHead() {
-	return m_data->root->header;
+	return m_data->root.header;
 } //GenericModelElement::getHead
 #endif

@@ -0,0 +1,164 @@
+#include "Speckle/Record/Element/MeshElem.h"
+
+#include "Speckle/Record/Element/Quants/Surveyor.h"
+#include "Speckle/Record/Element/Setting/Conversion.h"
+#include "Speckle/Utility/BIMMemory.h"
+
+#ifdef ARCHICAD
+#include <ACAPinc.h>
+#endif
+
+using namespace active::serialise;
+using namespace speckle::record::attribute;
+using namespace speckle::record::element;
+using namespace speckle::record::element::quants;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace speckle::record::element {
+
+	class Mesh::Data {
+	public:
+		friend class Mesh;
+
+#ifdef ARCHICAD
+		Data(const API_MeshType& seg) : root{seg} {}
+
+	private:
+		API_MeshType root;
+#endif
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Mesh::Mesh() {
+} //Mesh::Mesh
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Constructor
+
+	elemData: Archicad element data
+	tableID: The element table ID (AC database, e.g. floor plan, 3D)
+  --------------------------------------------------------------------*/
+Mesh::Mesh(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
+	m_data = std::make_unique<Data>(elemData.mesh);
+} //Mesh::Mesh
+#endif
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+
+	source: The object to copy
+  --------------------------------------------------------------------*/
+Mesh::Mesh(const Mesh& source) : base{ source } {
+	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
+} //Mesh::Mesh
+
+
+/*--------------------------------------------------------------------
+	Move constructor
+
+	source: The object to move
+  --------------------------------------------------------------------*/
+Mesh::Mesh(Mesh&& source) noexcept : base{source} {
+	m_data = std::move(source.m_data);
+} //Mesh::Mesh
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Mesh::~Mesh() {}
+
+
+/*--------------------------------------------------------------------
+	Get the element material (applicable to elements with a single, homogenous material)
+ 
+	return: The element material (nullopt if not applicable to the element)
+  --------------------------------------------------------------------*/
+std::optional<Material> Mesh::getMaterial() const {
+#ifdef ARCHICAD
+	return Material{Guid{Guid::fromInt(m_data->root.buildingMaterial.GenerateHashValue())}};
+#endif
+} //Mesh::getMaterial
+
+
+/*--------------------------------------------------------------------
+	Get a spatial measurement from this element (area/volume, as used for material quantities)
+ 
+	return: The element measurement (empty if unavailable)
+  --------------------------------------------------------------------*/
+ModelElement::SpatialMeasure Mesh::getSpatialMeasure() const {
+#ifdef ARCHICAD
+	Surveyor surveyor;
+	BIMMemory::setMask(&surveyor.elementMask().mesh.topSurface);
+	BIMMemory::setMask(&surveyor.elementMask().mesh.volume);
+	surveyor.measure(getBIMLink());
+	return SpatialMeasure{surveyor.quantity().mesh.topSurface, surveyor.quantity().mesh.volume};
+#endif
+} //Mesh::getSpatialMeasure
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the (immutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+const API_Elem_Head& Mesh::getHead() const {
+	return m_data->root.head;
+} //Mesh::getHead
+
+
+/*--------------------------------------------------------------------
+	Get the (mutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+API_Elem_Head& Mesh::getHead() {
+	return m_data->root.head;
+} //Mesh::getHead
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+
+	inventory: The inventory to receive the package items
+
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Mesh::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+		//TODO: Implement other fields as required
+	return base::fillInventory(inventory);
+} //Mesh::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+
+	item: The inventory item to retrieve
+
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Mesh::getCargo(const Inventory::Item& item) const {
+		//TODO: Implement other fields as required
+	return base::getCargo(item);
+} //Mesh::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Mesh::setDefault() {
+	m_data.reset();
+} //Mesh::setDefault
@@ -0,0 +1,120 @@
+#ifndef SPECKLE_RECORD_ELEMENT_MESH
+#define SPECKLE_RECORD_ELEMENT_MESH
+
+#include "Speckle/Record/Element/ModelElement.h"
+#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
+
+namespace speckle::record::element {
+	
+	/*!
+	 BIM mesh class
+	 */
+	class Mesh : public ModelElement {
+	public:
+
+		// MARK: - Types
+		
+		using base = ModelElement;
+			///Unique pointer
+		using Unique = std::unique_ptr<Mesh>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Mesh>;
+			///Optional
+		using Option = std::optional<Mesh>;
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Mesh();
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param elemData Archicad element data
+		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
+		 */
+		Mesh(const API_Element& elemData, const speckle::utility::Guid& tableID);
+#endif
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Mesh(const Mesh& source);
+		/*!
+		 Move constructor
+		 @param source The object to move
+		 */
+		Mesh(Mesh&& source) noexcept;
+		/*!
+		 Destructor
+		 */
+		~Mesh();
+
+		/*!
+		 Object cloning
+		 @return A clone of this object
+		 */
+		Mesh* clonePtr() const override { return new Mesh{*this}; }
+
+
+		// MARK: - Functions (const)
+
+		/*!
+		 Get the element material (applicable to elements with a single, homogenous material)
+		 @return The element material (nullopt if not applicable to the element)
+		 */
+		std::optional<record::attribute::Material> getMaterial() const override;
+		/*!
+		 Get a spatial measurement from this element (area/volume, as used for material quantities)
+		 @return The element measurement (empty if unavailable)
+		 */
+		SpatialMeasure getSpatialMeasure() const override;
+#ifdef ARCHICAD
+		/*!
+		 Get the (immutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		const API_Elem_Head& getHead() const override;
+#endif
+		
+		// MARK: - Functions (mutating)
+
+#ifdef ARCHICAD
+		/*!
+		 Get the (mutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		API_Elem_Head& getHead() override;
+#endif
+
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+		
+	private:
+		class Data;
+			///The beam data
+		std::unique_ptr<Data> m_data;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT_MESH
@@ -1,13 +1,12 @@
 #include "Speckle/Record/Element/ModelElement.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
 #include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
 #include "Speckle/Environment/Addon.h"
 #include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/Record/Element/Memo.h"
 #include "Speckle/Record/Property/Wrapper/PropertiedWrapper.h"
 #include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/Guid.h"
+#include "Speckle/Utility/BIMMemory.h"

 #ifdef ARCHICAD
 #include <exp.h>
@@ -26,6 +25,7 @@ using namespace speckle::database;
 using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
+using namespace speckle::record::element::quants;
 using namespace speckle::record::property;
 using namespace speckle::utility;

@@ -78,6 +78,7 @@ namespace speckle::record::element {

 	};
 	
+		///Allocation for the ModelElement finishes cache (used because repeated API access is very slow)
 	std::unique_ptr<ModelElement::FinishCache> ModelElement::m_finishCache;
 	
 }
@@ -87,76 +88,96 @@ namespace {
 	///Serialisation fields
 	enum FieldIndex {
 		bodyID,
+		materialQuantsID,
 		propertyID,
 	};

 	///Serialisation field IDs
 	static std::array fieldID = {
 		Identity{"displayValue"},
+		Identity{"materialQuantities"},
 		Identity{"properties"},
 	};
 	
 #ifdef ARCHICAD
+	/*!
+	 Collect the IDs of individual parts from an assembly (e.g. stair, curtain wall)
+	 @param parts A pointer to the assembly parts
+	 @param partIDs The assembly part IDs
+	 */
 	template<typename T>
-	void getSubElementIds(T* ptr, std::set<API_Guid>& subIds)
-	{
-		GSSize nSubElements = BMGetPtrSize(reinterpret_cast<GSPtr>(ptr)) / sizeof(T);
+	void getPartIDs(T* parts, std::set<API_Guid>& partIDs) {
+		GSSize nSubElements = BMGetPtrSize(reinterpret_cast<GSPtr>(parts)) / sizeof(T);
 		for (Int32 idx = 0; idx < nSubElements; ++idx)
-			subIds.insert(ptr[idx].head.guid);
+			partIDs.insert(parts[idx].head.guid);
 	}
+	
+	
+	/*!
+	 Measure material quantities from the composite materials of a specified element
+	 @param guid The ID of the element to measure
+	 @param elementQuantity Quantities extracted from the target element (out)
+	 @param extendedQuantity Optional extended quantities calculated for some element types
+	 @param quantityMask Mask to determine which quantities are required (minimise calculation time)
+	 */
+	void measureQuantities(const API_Guid& guid, API_ElementQuantity& elementQuantity,
+								  API_Quantities& extendedQuantity, const API_QuantitiesMask& quantityMask) {
+		extendedQuantity.elements = &elementQuantity;
+		GS::Array<API_ElemPartQuantity> elementPartQuantities;
+		API_QuantityPar quantityParameters{};
+		quantityParameters.minOpeningSize = Eps;
+		ACAPI_Element_GetQuantities(guid, &quantityParameters, &extendedQuantity, &quantityMask);
+	} //measureQuantities
+	
+	
+	/*!
+	 Collect the IDs of individual parts from an element (e.g. stair, curtain wall)
+	 @param elemId The element to collect part IDs from
+	 @param typeID The element type identifier
+	 @param memo The element memo data
+	 */
+	std::set<API_Guid> collectPartIDs(const API_Guid& elemId, API_ElemTypeID typeID, const Memo& memo) {
+		std::set<API_Guid> partIDs{};
+		partIDs.insert(elemId);
+		if (!memo)
+			return partIDs;
+		switch (typeID) {
+			case API_StairID:
+				getPartIDs(memo.root()->stairRisers, partIDs);
+				getPartIDs(memo.root()->stairTreads, partIDs);
+				getPartIDs(memo.root()->stairStructures, partIDs);
+				break;
+			case API_RailingID:
+				getPartIDs(memo.root()->railingSegments, partIDs);
+				getPartIDs(memo.root()->railingPatterns, partIDs);
+				getPartIDs(memo.root()->railingRails, partIDs);
+				getPartIDs(memo.root()->railingHandrails, partIDs);
+				getPartIDs(memo.root()->railingToprails, partIDs);
+				getPartIDs(memo.root()->railingBalusterSets, partIDs);
+				getPartIDs(memo.root()->railingBalusters, partIDs);
+				getPartIDs(memo.root()->railingPanels, partIDs);
+				getPartIDs(memo.root()->railingInnerPosts, partIDs);

-	std::set<API_Guid> collectSubIds(API_Guid elemId)
-	{
-		API_Element	elem{};
-		elem.header.guid = elemId;
-		ACAPI_Element_Get(&elem);
-		API_ElementMemo memo{};
-		ACAPI_Element_GetMemo(elemId, &memo);
-
-		std::set<API_Guid> subIds{};
-		subIds.insert(elemId);
-
-		if (elem.header.type.typeID == API_StairID)
-		{
-			getSubElementIds(memo.stairRisers, subIds);
-			getSubElementIds(memo.stairTreads, subIds);
-			getSubElementIds(memo.stairStructures, subIds);
+				getPartIDs(memo.root()->railingNodes, partIDs);
+				getPartIDs(memo.root()->railingRailConnections, partIDs);
+				getPartIDs(memo.root()->railingHandrailConnections, partIDs);
+				getPartIDs(memo.root()->railingToprailConnections, partIDs);
+				getPartIDs(memo.root()->railingPosts, partIDs);
+				getPartIDs(memo.root()->railingRailEnds, partIDs);
+				getPartIDs(memo.root()->railingHandrailEnds, partIDs);
+				getPartIDs(memo.root()->railingToprailEnds, partIDs);
+				break;
+			case API_CurtainWallID:
+				getPartIDs(memo.root()->cWallSegments, partIDs);
+				getPartIDs(memo.root()->cWallFrames, partIDs);
+				getPartIDs(memo.root()->cWallPanels, partIDs);
+				getPartIDs(memo.root()->cWallJunctions, partIDs);
+				getPartIDs(memo.root()->cWallAccessories, partIDs);
+				break;
+			default:
+				break;
 		}
-
-		if (elem.header.type.typeID == API_RailingID)
-		{
-			// segments
-			getSubElementIds(memo.railingSegments, subIds);
-			getSubElementIds(memo.railingPatterns, subIds);
-			getSubElementIds(memo.railingRails, subIds);
-			getSubElementIds(memo.railingHandrails, subIds);
-			getSubElementIds(memo.railingToprails, subIds);
-			getSubElementIds(memo.railingBalusterSets, subIds);
-			getSubElementIds(memo.railingBalusters, subIds);
-			getSubElementIds(memo.railingPanels, subIds);
-			getSubElementIds(memo.railingInnerPosts, subIds);
-
-			// nodes
-			getSubElementIds(memo.railingNodes, subIds);
-			getSubElementIds(memo.railingRailConnections, subIds);
-			getSubElementIds(memo.railingHandrailConnections, subIds);
-			getSubElementIds(memo.railingToprailConnections, subIds);
-			getSubElementIds(memo.railingPosts, subIds);
-			getSubElementIds(memo.railingRailEnds, subIds);
-			getSubElementIds(memo.railingHandrailEnds, subIds);
-			getSubElementIds(memo.railingToprailEnds, subIds);
-		}
-
-		if (elem.header.type.typeID == API_CurtainWallID)
-		{
-			getSubElementIds(memo.cWallSegments, subIds);
-			getSubElementIds(memo.cWallFrames, subIds);
-			getSubElementIds(memo.cWallPanels, subIds);
-			getSubElementIds(memo.cWallJunctions, subIds);
-			getSubElementIds(memo.cWallAccessories, subIds);
-		}
-
-		return subIds;
+		return partIDs;
 	}
 #endif
 	
@@ -233,6 +254,52 @@ void ModelElement::resetCache() {
 } //ModelElement::resetCache


+/*--------------------------------------------------------------------
+	Get material quantities measured from this element
+ 
+	return: An list of material quantities
+  --------------------------------------------------------------------*/
+MaterialQuantityList ModelElement::getMaterialQuantities() const {
+	using enum Composition;
+	MaterialQuantityList result;
+	switch (getComposition()) {
+		case unordered: {
+				//Get the material and spatial measurements
+			auto material = getMaterial();
+			if (!material)
+				return result;
+			auto spatialMeasure = getSpatialMeasure();
+			if (!spatialMeasure)
+				return result;
+				//Create a material quantity from the quantity takeoff
+			result.push_back({material->getBIMID(), spatialMeasure.area, spatialMeasure.volume});
+			break;
+		}
+		case skinned: {
+#ifdef ARCHICAD
+			API_ElementQuantity elementQuantity{};
+			API_Quantities extendedQuantity{};
+			GS::Array<API_CompositeQuantity> compositeQuantity{};
+			extendedQuantity.composites = &compositeQuantity;
+			API_QuantitiesMask quantityMask{};
+				//Set the appropriate masks for composite material volume/area quantity takeoffs
+			BIMMemory::setMask(&quantityMask.composites.buildMatIndices);
+			BIMMemory::setMask(&quantityMask.composites.volumes);
+			BIMMemory::setMask(&quantityMask.composites.projectedArea);
+			measureQuantities(getHead().guid, elementQuantity, extendedQuantity, quantityMask);
+				//Create material quantities from the quantity takeoff (one oer skin in the composite structure)
+			for (auto& skinQuant : compositeQuantity)
+				result.push_back({Guid{Guid::fromInt(skinQuant.buildMatIndices.GenerateHashValue())}, skinQuant.projectedArea, skinQuant.volumes});
+#endif
+			break;
+		}
+		case profiled:
+			break;
+	}
+	return result;
+} //ModelElement::getMaterialQuantities
+
+
 /*--------------------------------------------------------------------
 	Get the element body as a list of faces or Meshes

@@ -257,13 +324,18 @@ ModelElement::Body* ModelElement::getBody() const {
 	auto elementBody = new ModelElement::Body();
 	// Map to collect meshes per material name
 	std::unordered_map<String, primitive::Mesh> materialMeshMap;
-    auto subIds = collectSubIds(getHead().guid);
+
+	std::unique_ptr<Memo> memo;
+	loadMemo(APIMemoMask_All, memo);
+
+    auto partIDs = collectPartIDs(getHead().guid, getHead().type.typeID, *memo);
+	memo.reset();
 	Int32 nElements = acModel.GetElementCount();
 	for (Int32 iElement = 1; iElement <= nElements; iElement++) {
 		ModelerAPI::Element elem{};
 		acModel.GetElement(iElement, &elem);
 		API_Guid apiGuid{GSGuid2APIGuid(elem.GetElemGuid())};
-		if (subIds.find(apiGuid) == subIds.end())
+		if (partIDs.find(apiGuid) == partIDs.end())
 			continue;
 		Int32 nBodies = elem.GetTessellatedBodyCount();
 		ModelerAPI::Material material{};
@@ -327,6 +399,7 @@ bool ModelElement::fillInventory(Inventory& inventory) const {
 	inventory.merge(Inventory{
 		{
 			{ fieldID[bodyID], bodyID, element },
+			{ fieldID[materialQuantsID], materialQuantsID, element },
 			{ fieldID[propertyID], propertyID, element },
 		},
 	}.withType(&typeid(ModelElement)));
@@ -348,11 +421,15 @@ Cargo::Unique ModelElement::getCargo(const Inventory::Item& item) const {
 	switch (item.index) {
 		case bodyID:
 			if (auto body = getBody(); body != nullptr)
-				return Cargo::Unique{ new active::serialise::ContainerWrap{*body} };
-			else
-				return nullptr;
+				return Cargo::Unique{new active::serialise::ContainerWrap{*body}};
+			return nullptr;
+		case materialQuantsID:
+			if (auto quants = getMaterialQuantities(); !quants.empty())
+				return Cargo::Unique{new CargoHold<ContainerWrap<MaterialQuantityList>, MaterialQuantityList>{quants}};
+			return nullptr;
 		case propertyID:
-			return std::make_unique<PropertiedWrapper>(*this);
+			return nullptr;
+			//return std::make_unique<PropertiedWrapper>(*this);
 		default:
 			return nullptr;	//Requested an unknown index
 	}
@@ -1,13 +1,15 @@
 #ifndef SPECKLE_RECORD_MODEL_ELEMENT
 #define SPECKLE_RECORD_MODEL_ELEMENT

+#include "Speckle/Record/Attribute/Material.h"
 #include "Speckle/Record/Classification/Classified.h"
 #include "Speckle/Record/Element/Element.h"
-#include "Speckle/Record/Element/Element.h"
+#include "Speckle/Record/Element/Quants/MaterialQuantity.h"
 #include "Speckle/Record/Property/Propertied.h"

 namespace speckle::record::attribute {
 	class Finish;
+	class Material;
 }

 namespace speckle::record::element {
@@ -29,8 +31,23 @@ namespace speckle::record::element {
 		using Option = std::optional<ModelElement>;
 			///A model element 3D body primitive
 		using Body = std::vector<primitive::Mesh>;
+			//Material composition
+		enum class Composition {
+			unordered,	///<Element is composed of materials with no fixed relationship
+			skinned,	///<Element is composed of layered materials 'skins', e.g. brick/air/insulation/block in a wall
+			profiled,	///<Element is composed of materials extruded through a profile along a space-curve, e.g. window frames
+		};
+			///Model element spatial measurements
+		struct SpatialMeasure {
+				///Element area
+			double area = 0.0;
+				///Element volume
+			double volume = 0.0;
+				///True if either a volume or area has been measured
+			operator bool() const { return active::math::isGreaterZero(area) || active::math::isGreaterZero(volume); }
+		};
 		
-		// MARK: - Constructors
+		// MARK: - Static functions
 		
 		/*!
 		 Get a mesh finish from the cache
@@ -79,6 +96,26 @@ namespace speckle::record::element {

 		// MARK: - Functions (const)

+		/*!
+		 Get the composition of materials in the element
+		 @return The material composition (element with ordered material composition should override)
+		 */
+		virtual Composition getComposition() const { return Composition::unordered; }
+		/*!
+		 Get the element material (applicable to elements with a single, homogenous material)
+		 @return The element material (nullopt if not applicable to the element)
+		 */
+		virtual std::optional<record::attribute::Material> getMaterial() const { return std::nullopt; }
+		/*!
+		 Get a spatial measurement from this element (area/volume, as used for material quantities)
+		 @return The element measurement (empty if unavailable)
+		 */
+		virtual SpatialMeasure getSpatialMeasure() const { return SpatialMeasure{}; }
+		/*!
+		 Get material quantities measured from this element
+		 @return An list of material quantities
+		 */
+		quants::MaterialQuantityList getMaterialQuantities() const;
 		/*!
 		 Get the element body
 		 @return An array of meshes from the element body (nullptr if no body data is available)
@@ -0,0 +1,164 @@
+#include "Speckle/Record/Element/Morph.h"
+
+#include "Speckle/Record/Element/Quants/Surveyor.h"
+#include "Speckle/Record/Element/Setting/Conversion.h"
+#include "Speckle/Utility/BIMMemory.h"
+
+#ifdef ARCHICAD
+#include <ACAPinc.h>
+#endif
+
+using namespace active::serialise;
+using namespace speckle::record::attribute;
+using namespace speckle::record::element;
+using namespace speckle::record::element::quants;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace speckle::record::element {
+
+	class Morph::Data {
+	public:
+		friend class Morph;
+
+#ifdef ARCHICAD
+		Data(const API_MorphType& seg) : root{seg} {}
+
+	private:
+		API_MorphType root;
+#endif
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Morph::Morph() {
+} //Morph::Morph
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Constructor
+
+	elemData: Archicad element data
+	tableID: The element table ID (AC database, e.g. floor plan, 3D)
+  --------------------------------------------------------------------*/
+Morph::Morph(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
+	m_data = std::make_unique<Data>(elemData.morph);
+} //Morph::Morph
+#endif
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+
+	source: The object to copy
+  --------------------------------------------------------------------*/
+Morph::Morph(const Morph& source) : base{ source } {
+	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
+} //Morph::Morph
+
+
+/*--------------------------------------------------------------------
+	Move constructor
+
+	source: The object to move
+  --------------------------------------------------------------------*/
+Morph::Morph(Morph&& source) noexcept : base{source} {
+	m_data = std::move(source.m_data);
+} //Morph::Morph
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Morph::~Morph() {}
+
+
+/*--------------------------------------------------------------------
+	Get the element material (applicable to elements with a single, homogenous material)
+ 
+	return: The element material (nullopt if not applicable to the element)
+  --------------------------------------------------------------------*/
+std::optional<Material> Morph::getMaterial() const {
+#ifdef ARCHICAD
+	return Material{Guid{Guid::fromInt(m_data->root.buildingMaterial.GenerateHashValue())}};
+#endif
+} //Morph::getMaterial
+
+
+/*--------------------------------------------------------------------
+	Get a spatial measurement from this element (area/volume, as used for material quantities)
+ 
+	return: The element measurement (empty if unavailable)
+  --------------------------------------------------------------------*/
+ModelElement::SpatialMeasure Morph::getSpatialMeasure() const {
+#ifdef ARCHICAD
+	Surveyor surveyor;
+	BIMMemory::setMask(&surveyor.elementMask().morph.surface);
+	BIMMemory::setMask(&surveyor.elementMask().morph.volume);
+	surveyor.measure(getBIMLink());
+	return SpatialMeasure{surveyor.quantity().morph.surface, surveyor.quantity().morph.volume};
+#endif
+} //Morph::getSpatialMeasure
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the (immutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+const API_Elem_Head& Morph::getHead() const {
+	return m_data->root.head;
+} //Morph::getHead
+
+
+/*--------------------------------------------------------------------
+	Get the (mutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+API_Elem_Head& Morph::getHead() {
+	return m_data->root.head;
+} //Morph::getHead
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+
+	inventory: The inventory to receive the package items
+
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Morph::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+		//TODO: Implement other fields as required
+	return base::fillInventory(inventory);
+} //Morph::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+
+	item: The inventory item to retrieve
+
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Morph::getCargo(const Inventory::Item& item) const {
+		//TODO: Implement other fields as required
+	return base::getCargo(item);
+} //Morph::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Morph::setDefault() {
+	m_data.reset();
+} //Morph::setDefault
@@ -0,0 +1,120 @@
+#ifndef SPECKLE_RECORD_ELEMENT_MORPH
+#define SPECKLE_RECORD_ELEMENT_MORPH
+
+#include "Speckle/Record/Element/ModelElement.h"
+#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
+
+namespace speckle::record::element {
+	
+	/*!
+	 BIM morph class
+	 */
+	class Morph : public ModelElement {
+	public:
+
+		// MARK: - Types
+		
+		using base = ModelElement;
+			///Unique pointer
+		using Unique = std::unique_ptr<Morph>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Morph>;
+			///Optional
+		using Option = std::optional<Morph>;
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Morph();
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param elemData Archicad element data
+		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
+		 */
+		Morph(const API_Element& elemData, const speckle::utility::Guid& tableID);
+#endif
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Morph(const Morph& source);
+		/*!
+		 Move constructor
+		 @param source The object to move
+		 */
+		Morph(Morph&& source) noexcept;
+		/*!
+		 Destructor
+		 */
+		~Morph();
+
+		/*!
+		 Object cloning
+		 @return A clone of this object
+		 */
+		Morph* clonePtr() const override { return new Morph{*this}; }
+
+
+		// MARK: - Functions (const)
+
+		/*!
+		 Get the element material (applicable to elements with a single, homogenous material)
+		 @return The element material (nullopt if not applicable to the element)
+		 */
+		std::optional<record::attribute::Material> getMaterial() const override;
+		/*!
+		 Get a spatial measurement from this element (area/volume, as used for material quantities)
+		 @return The element measurement (empty if unavailable)
+		 */
+		SpatialMeasure getSpatialMeasure() const override;
+#ifdef ARCHICAD
+		/*!
+		 Get the (immutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		const API_Elem_Head& getHead() const override;
+#endif
+		
+		// MARK: - Functions (mutating)
+
+#ifdef ARCHICAD
+		/*!
+		 Get the (mutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		API_Elem_Head& getHead() override;
+#endif
+
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+		
+	private:
+		class Data;
+			///The beam data
+		std::unique_ptr<Data> m_data;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT_MORPH
@@ -0,0 +1,78 @@
+#include "Speckle/Record/Element/Quants/MaterialQuantity.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueOptionWrap.h"
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Speckle/Record/Attribute/Material.h"
+#include "Speckle/Record/Element/Quants/MaterialWrap.h"
+#include "Speckle/Serialise/Types/Units/LengthUnit.h"
+
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::record::attribute;
+using namespace speckle::record::element::quants;
+
+namespace {
+
+	///Serialisation fields
+	enum FieldIndex {
+		areaID,
+		volumeID,
+		unitID,
+		matID,
+	};
+
+	///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"area"},
+		Identity{"volume"},
+		Identity{"units"},
+		Identity{"material"},
+	};
+	
+}
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the cargo items
+ 
+	inventory: The inventory to receive the cargo items
+ 
+	return: True if items have been added to the inventory
+  --------------------------------------------------------------------*/
+bool MaterialQuantity::fillInventory(active::serialise::Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[areaID], areaID, element },
+			{ fieldID[volumeID], volumeID, element },
+			{ fieldID[unitID], unitID, element },
+			{ fieldID[matID], matID, element },
+		},
+	}.withType(&typeid(MaterialQuantity)));
+	return true;
+} //MaterialQuantity::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique MaterialQuantity::getCargo(const active::serialise::Inventory::Item& item) const {
+	if (item.ownerType != &typeid(MaterialQuantity))
+		return nullptr;
+	using namespace active::serialise;
+	switch (item.index) {
+		case areaID:
+			return std::make_unique<ValueWrap<double>>(m_area);
+		case volumeID:
+			return std::make_unique<ValueWrap<double>>(m_volume);
+		case unitID:
+			return std::make_unique<ValueOptionWrap<active::measure::LengthType>>(m_unit);
+		case matID:
+			return std::make_unique<MaterialWrap>(m_materialID);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //MaterialQuantity::getCargo
@@ -0,0 +1,95 @@
+#ifndef SPECKLE_RECORD_ELEMENT_MATERIAL_QUANTITY
+#define SPECKLE_RECORD_ELEMENT_MATERIAL_QUANTITY
+
+#include "Active/Serialise/Package/Package.h"
+#include "Active/Setting/Values/Measurement/Units/LengthUnit.h"
+#include "Speckle/Database/Identity/BIMRecordID.h"
+
+namespace speckle::record::element::quants {
+	
+	/*!
+	 Measured material quantities extracted from an element
+	 
+	 This object pairs a material (BuildingMaterial in Archicad) with measurements of surface are ands volume (pssibly more in future).
+	 An element may be constructed of many materials, e.g. the skins of a wall, in which case the quants extracted from the element will
+	 be an array of MaterialQuantity.
+	 */
+	class MaterialQuantity final : public active::serialise::Package {
+	public:
+
+		// MARK: - Types
+		
+			///Unique pointer
+		using Unique = std::unique_ptr<MaterialQuantity>;
+			///Shared pointer
+		using Shared = std::shared_ptr<MaterialQuantity>;
+			///Optional
+		using Option = std::optional<MaterialQuantity>;
+
+		// MARK: - Constructors
+		
+		/*!
+		 Default constructor
+		 */
+		MaterialQuantity() {}
+		/*!
+		 Constructor
+		 @param materialID The ID of the measured material record
+		 @param area The measured surface area (see notes on member variable)
+		 @param volume The measured volume of the material
+		 */
+		MaterialQuantity(const database::BIMRecordID& materialID, double area = 0.0, double volume = 0.0) :
+				m_materialID{materialID}, m_area{area}, m_volume{volume} {}
+
+		// MARK: - Functions (const)
+		
+		/*!
+		 Get the ID of the measured material
+		 @return The material record ID (in the BIM attribute database)
+		 */
+		const database::BIMRecordID& getMaterialID() const { return m_materialID; }
+		/*!
+		 Get the measure surface area of the material
+		 @return The material surface area
+		 */
+		double getArea() const { return m_area; }
+		/*!
+		 Get the measure volume of the material
+		 @return The material volume
+		 */
+		double getVolume() const { return m_volume; }
+
+		// MARK: - Functions (mutating)
+
+		
+		//MARK: - Serialisation
+
+		/*!
+			Fill an inventory with the cargo items
+			@param inventory The inventory to receive the cargo items
+			@return True if items have been added to the inventory
+		*/
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+			Get the specified cargo
+			@param item The inventory item to retrieve
+			@return The requested cargo (nullptr on failure)
+		*/
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		
+	private:
+			///Surface area of the material. Total surface area for basic elements, area of the primary face for 'skinned' elements, e.g. slab top
+		double m_area = 0.0;
+			///Volume of the material
+		double m_volume = 0.0;
+			///The BIM record unit of length measurement
+		std::optional<active::measure::LengthType> m_unit = active::measure::LengthType::metre;
+			///ID of the measured building material
+		database::BIMRecordID m_materialID;
+	};
+	
+	using MaterialQuantityList = std::vector<MaterialQuantity>;
+
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT_MATERIAL_QUANTITY
@@ -0,0 +1,68 @@
+#include "Speckle/Record/Element/Quants/MaterialWrap.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Speckle/Record/Attribute/Material.h"
+
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::record::attribute;
+using namespace speckle::record::element::quants;
+using namespace speckle::utility;
+
+namespace {
+
+	///Serialisation fields
+	enum FieldIndex {
+		nameID,
+	};
+
+	///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"name"},
+	};
+	
+}
+
+/*--------------------------------------------------------------------
+	Constructor
+  --------------------------------------------------------------------*/
+MaterialWrap::MaterialWrap(const BIMRecordID& materialID) : m_name{Material{materialID}.getName()} {
+} //MaterialWrap::MaterialWrap
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the cargo items
+ 
+	inventory: The inventory to receive the cargo items
+ 
+	return: True if items have been added to the inventory
+  --------------------------------------------------------------------*/
+bool MaterialWrap::fillInventory(active::serialise::Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[nameID], nameID, element },
+		},
+	}.withType(&typeid(MaterialWrap)));
+	return true;
+} //MaterialWrap::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique MaterialWrap::getCargo(const active::serialise::Inventory::Item& item) const {
+	if (item.ownerType != &typeid(MaterialWrap))
+		return nullptr;
+	using namespace active::serialise;
+	switch (item.index) {
+		case nameID:
+			return std::make_unique<ValueWrap<String>>(m_name);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //MaterialWrap::getCargo
@@ -0,0 +1,47 @@
+#ifndef SPECKLE_RECORD_ELEMENT_MATERIAL_WRAP
+#define SPECKLE_RECORD_ELEMENT_MATERIAL_WRAP
+
+#include "Active/Serialise/Package/Package.h"
+#include "Speckle/Database/Identity/BIMRecordID.h"
+
+namespace speckle::record::element::quants {
+	
+	/*!
+	 Wrapper for a material exported with a quantity
+	 
+	 NB: This wrapper primarily exports the material name. In future this might be linked to a material proxy, in which case this simple wrapper
+	 will become a MaterialProxy
+	 */
+	class MaterialWrap final : public active::serialise::Package {
+	public:
+
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 */
+		MaterialWrap(const database::BIMRecordID& materialID);
+		
+		//MARK: - Serialisation
+
+		/*!
+			Fill an inventory with the cargo items
+			@param inventory The inventory to receive the cargo items
+			@return True if items have been added to the inventory
+		*/
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+			Get the specified cargo
+			@param item The inventory item to retrieve
+			@return The requested cargo (nullptr on failure)
+		*/
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		
+	private:
+			///The wrapped material name
+		utility::String m_name;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT_MATERIAL_WRAP
@@ -0,0 +1,86 @@
+#include "Speckle/Record/Element/Quants/Surveyor.h"
+
+#include "Active/Utility/Memory.h"
+#include "Speckle/Record/Element/Setting/TypeSetting.h"
+
+using namespace active::math;
+using namespace speckle::database;
+using namespace speckle::record::element::quants;
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Surveyor::Surveyor() {
+#ifdef ARCHICAD
+	active::utility::Memory::erase(m_quantity);
+	active::utility::Memory::erase(m_mask);
+	m_extendedQuantity.elements = &m_quantity;
+	m_extendedQuantity.composites = &m_composites;
+#endif
+} //Surveyor::Surveyor
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+	
+	source: The object to copy
+  --------------------------------------------------------------------*/
+Surveyor::Surveyor(const Surveyor& source) : m_quantity(source.m_quantity), m_mask(source.m_mask), m_composites{source.m_composites} {
+#ifdef ARCHICAD
+	m_extendedQuantity.elements = &m_quantity;
+	m_extendedQuantity.composites = &m_composites;
+#endif
+} //Surveyor::Surveyor
+
+
+/*--------------------------------------------------------------------
+	Assignment operator
+	
+	source: The object to copy
+  --------------------------------------------------------------------*/
+Surveyor& Surveyor::operator= (const Surveyor& source) {
+	if (this != &source) {
+#ifdef ARCHICAD
+		m_quantity = source.m_quantity;
+		m_mask = source.m_mask;
+		m_composites = source.m_composites;
+		m_extendedQuantity.elements = &m_quantity;
+		m_extendedQuantity.composites = &m_composites;
+#endif
+	}
+	return *this;
+} //Surveyor::operator=
+
+
+/*--------------------------------------------------------------------
+	Measure quantities from a specified element
+ 
+	elementLink: Link to the target element
+ 
+	return: True if measurements were successfully taken
+  --------------------------------------------------------------------*/
+bool Surveyor::measure(const BIMLink& elementLink) {
+	bool result = false;
+#ifdef ARCHICAD
+	API_QuantityPar quantParams;
+	active::utility::Memory::erase(quantParams);
+	active::utility::Memory::erase(m_quantity);
+	GS::Array<API_ElemPartQuantity> elemPartQuantities;
+	bool isPartQuantities = false;
+	if (auto typeSetting = elementLink.find<TypeSetting>(TypeSetting::ID); typeSetting != nullptr)
+		isPartQuantities = (typeSetting->type == API_MorphID);
+	m_extendedQuantity.elemPartQuantities = isPartQuantities ? &elemPartQuantities : nullptr;
+	quantParams.minOpeningSize = eps;
+	m_composites.Clear();
+	result = (ACAPI_Element_GetQuantities(elementLink, &quantParams, &m_extendedQuantity, &m_mask) == NoError);
+	if (isPartQuantities) {
+		if (result && (elemPartQuantities.GetSize() > 0)) {
+			m_quantity.morph.baseLevel = elemPartQuantities[0].quantity.morph.baseLevel;
+			m_quantity.morph.baseHeight = elemPartQuantities[0].quantity.morph.baseHeight;
+			m_quantity.morph.wholeHeight = elemPartQuantities[0].quantity.morph.wholeHeight;
+		}
+		m_extendedQuantity.elemPartQuantities = nullptr;
+	}
+#endif
+	return result;
+} //Surveyor::measure
@@ -0,0 +1,97 @@
+#ifndef SPECKLE_RECORD_ELEMENT_QUANTS_SURVEYOR
+#define SPECKLE_RECORD_ELEMENT_QUANTS_SURVEYOR
+
+#include "Speckle/Database/Identity/BIMLink.h"
+
+#ifdef ARCHICAD
+#include "APIdefs_Elements.h"
+#endif
+
+namespace speckle::record::element::quants {
+	
+	/*!
+	 A utility class to measure element quantities
+	 */
+	class Surveyor {
+	public:
+		/*!
+		 Default constructor
+		 */
+		Surveyor();
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Surveyor(const Surveyor& source);
+		
+		
+		/*!
+		 Assignment operator
+		 @param source The object to copy
+		 @return A reference to this
+		 */
+		Surveyor& operator= (const Surveyor& source);
+
+#ifdef ARCHICAD
+		/*!
+		 Get the quantity measurement values
+		 @return The quantity valuse
+		 */
+		API_ElementQuantity& quantity()	{ return m_quantity; }
+		/*!
+		 Get the mask specifying the values to measure
+		 @return The quantity mask
+		 */
+		API_QuantitiesMask& mask()	{ return m_mask; }
+		/*!
+		 Get the mask specifying the element values to measure
+		 @return The element quantity mask
+		 */
+		API_ElementQuantityMask& elementMask() { return mask().elements; }
+		/*!
+		 Get the mask specifying the composite values to measure
+		 @return The composite quantity mask
+		 */
+		API_CompositeQuantityMask& compositeMask() { return mask().composites; }
+#endif
+		/*!
+		 Measure quantities from a specified element
+		 @param elementLink Link to the target element
+		 @return True if measurements were successfully taken
+		 */
+		bool measure(const database::BIMLink& elementLink);
+		
+#ifdef ARCHICAD
+		/*!
+		 Get the quantity measurement values
+		 @return The quantity valuse
+		 */
+		const API_ElementQuantity& quantity() const	{ return m_quantity; }
+		/*!
+		 Get the mask specifying the values to measure
+		 @return The quantity mask
+		 */
+		const API_QuantitiesMask& mask() const	{ return m_mask; }
+		/*!
+		 Get the mask specifying the composite values to measure
+		 @return The composite quantity mask
+		 */
+		const GS::Array<API_CompositeQuantity>& composites() const { return m_composites; }
+#endif
+		
+	private:
+#ifdef ARCHICAD
+			///Archicad quantity measurement values
+		API_ElementQuantity m_quantity;
+			///Mask specifying the values to measure
+		API_QuantitiesMask m_mask;
+			///Optional additional values to measure, e.g. composite skins, assembly parts etc
+		API_Quantities m_extendedQuantity;
+			///Measurements taken from copmposite skins, e.g. the construction layers of a roof/wall
+		GS::Array<API_CompositeQuantity> m_composites;
+#endif
+	};
+	
+}
+
+#endif //SPECKLE_RECORD_ELEMENT_QUANTS_SURVEYOR
@@ -0,0 +1,176 @@
+#include "Speckle/Record/Element/Roof.h"
+
+#include "Speckle/Record/Element/Quants/Surveyor.h"
+#include "Speckle/Record/Element/Setting/Conversion.h"
+#include "Speckle/Utility/BIMMemory.h"
+
+#ifdef ARCHICAD
+#include <ACAPinc.h>
+#endif
+
+using namespace active::serialise;
+using namespace speckle::record::attribute;
+using namespace speckle::record::element;
+using namespace speckle::record::element::quants;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace speckle::record::element {
+
+	class Roof::Data {
+	public:
+		friend class Roof;
+
+#ifdef ARCHICAD
+		Data(const API_RoofType& seg) : root{seg} {}
+
+	private:
+		API_RoofType root;
+#endif
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Roof::Roof() {
+} //Roof::Roof
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Constructor
+
+	elemData: Archicad element data
+	tableID: The element table ID (AC database, e.g. floor plan, 3D)
+  --------------------------------------------------------------------*/
+Roof::Roof(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
+	m_data = std::make_unique<Data>(elemData.roof);
+} //Roof::Roof
+#endif
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+
+	source: The object to copy
+  --------------------------------------------------------------------*/
+Roof::Roof(const Roof& source) : base{ source } {
+	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
+} //Roof::Roof
+
+
+/*--------------------------------------------------------------------
+	Move constructor
+
+	source: The object to move
+  --------------------------------------------------------------------*/
+Roof::Roof(Roof&& source) noexcept : base{source} {
+	m_data = std::move(source.m_data);
+} //Roof::Roof
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Roof::~Roof() {}
+
+
+/*--------------------------------------------------------------------
+	Get the composition of materials in the element
+ 
+	return: The material composition (element with ordered material composition should override)
+  --------------------------------------------------------------------*/
+ModelElement::Composition Roof::getComposition() const {
+#ifdef ARCHICAD
+	return convert(m_data->root.shellBase.modelElemStructureType);
+#endif
+} //Roof::getComposition
+
+
+/*--------------------------------------------------------------------
+	Get the element material (applicable to elements with a single, homogenous material)
+ 
+	return: The element material (nullopt if not applicable to the element)
+  --------------------------------------------------------------------*/
+std::optional<Material> Roof::getMaterial() const {
+#ifdef ARCHICAD
+	return Material{Guid{Guid::fromInt(m_data->root.shellBase.buildingMaterial.GenerateHashValue())}};
+#endif
+} //Roof::getMaterial
+
+
+/*--------------------------------------------------------------------
+	Get a spatial measurement from this element (area/volume, as used for material quantities)
+ 
+	return: The element measurement (empty if unavailable)
+  --------------------------------------------------------------------*/
+ModelElement::SpatialMeasure Roof::getSpatialMeasure() const {
+#ifdef ARCHICAD
+	Surveyor surveyor;
+	BIMMemory::setMask(&surveyor.elementMask().roof.topSurface);
+	BIMMemory::setMask(&surveyor.elementMask().roof.volume);
+	surveyor.measure(getBIMLink());
+	return SpatialMeasure{surveyor.quantity().roof.topSurface, surveyor.quantity().roof.volume};
+#endif
+} //Roof::getSpatialMeasure
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the (immutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+const API_Elem_Head& Roof::getHead() const {
+	return m_data->root.head;
+} //Roof::getHead
+
+
+/*--------------------------------------------------------------------
+	Get the (mutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+API_Elem_Head& Roof::getHead() {
+	return m_data->root.head;
+} //Roof::getHead
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+
+	inventory: The inventory to receive the package items
+
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Roof::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+		//TODO: Implement other fields as required
+	return base::fillInventory(inventory);
+} //Roof::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+
+	item: The inventory item to retrieve
+
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Roof::getCargo(const Inventory::Item& item) const {
+		//TODO: Implement other fields as required
+	return base::getCargo(item);
+} //Roof::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Roof::setDefault() {
+	m_data.reset();
+} //Roof::setDefault
@@ -0,0 +1,125 @@
+#ifndef SPECKLE_RECORD_ELEMENT_ROOF
+#define SPECKLE_RECORD_ELEMENT_ROOF
+
+#include "Speckle/Record/Element/ModelElement.h"
+#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
+
+namespace speckle::record::element {
+	
+	/*!
+	 BIM roof class
+	 */
+	class Roof : public ModelElement {
+	public:
+
+		// MARK: - Types
+		
+		using base = ModelElement;
+			///Unique pointer
+		using Unique = std::unique_ptr<Roof>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Roof>;
+			///Optional
+		using Option = std::optional<Roof>;
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Roof();
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param elemData Archicad element data
+		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
+		 */
+		Roof(const API_Element& elemData, const speckle::utility::Guid& tableID);
+#endif
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Roof(const Roof& source);
+		/*!
+		 Move constructor
+		 @param source The object to move
+		 */
+		Roof(Roof&& source) noexcept;
+		/*!
+		 Destructor
+		 */
+		~Roof();
+
+		/*!
+		 Object cloning
+		 @return A clone of this object
+		 */
+		Roof* clonePtr() const override { return new Roof{*this}; }
+
+
+		// MARK: - Functions (const)
+
+		/*!
+		 Get the composition of materials in the element
+		 @return The material composition (element with ordered material composition should override)
+		 */
+		Composition getComposition() const override;
+		/*!
+		 Get the element material (applicable to elements with a single, homogenous material)
+		 @return The element material (nullopt if not applicable to the element)
+		 */
+		std::optional<record::attribute::Material> getMaterial() const override;
+		/*!
+		 Get a spatial measurement from this element (area/volume, as used for material quantities)
+		 @return The element measurement (empty if unavailable)
+		 */
+		SpatialMeasure getSpatialMeasure() const override;
+#ifdef ARCHICAD
+		/*!
+		 Get the (immutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		const API_Elem_Head& getHead() const override;
+#endif
+		
+		// MARK: - Functions (mutating)
+
+#ifdef ARCHICAD
+		/*!
+		 Get the (mutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		API_Elem_Head& getHead() override;
+#endif
+
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+		
+	private:
+		class Data;
+			///The beam data
+		std::unique_ptr<Data> m_data;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT_ROOF
@@ -0,0 +1,30 @@
+#ifndef SPECKLE_RECORD_ELEMENT_CONVERSION
+#define SPECKLE_RECORD_ELEMENT_CONVERSION
+
+#include "Speckle/Record/Element/ModelElement.h"
+
+#ifdef ARCHICAD
+#include "APIdefs_Elements.h"
+#endif
+
+namespace speckle::record::element {
+
+#ifdef ARCHICAD
+	/*!
+	 Convert an Archicad structure type to an element composition
+	 */
+	inline ModelElement::Composition convert(API_ModelElemStructureType structType) {
+		switch (structType) {
+			case API_CompositeStructure:
+				return ModelElement::Composition::skinned;
+			case API_ProfileStructure:
+				return ModelElement::Composition::profiled;
+			default:
+				return ModelElement::Composition::unordered;
+		}
+	}
+#endif
+	
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT_CONVERSION
@@ -0,0 +1,82 @@
+#include "Speckle/Record/Element/Setting/TypeSetting.h"
+
+using namespace speckle::record::element;
+
+/*--------------------------------------------------------------------
+	Equality operator
+ 
+	ref: The value to compare
+ 
+	return: True if the values are identical
+  --------------------------------------------------------------------*/
+bool TypeSetting::operator==(const BIMIdentity& ref) const {
+	return type == ref;
+} //TypeSetting::operator==
+
+
+/*--------------------------------------------------------------------
+	Equality operator
+ 
+	ref: The value to compare
+ 
+	return: True if the values are identical
+  --------------------------------------------------------------------*/
+bool TypeSetting::operator==(const Setting& ref) const {
+	if (auto refType = dynamic_cast<const TypeSetting*>(&ref); refType != nullptr)
+		return type == refType->type;
+	return false;
+} //TypeSetting::operator==
+
+
+/*--------------------------------------------------------------------
+	Less-than operator
+ 
+	@param ref The value to compare
+	@return True if this is less than ref
+  --------------------------------------------------------------------*/
+bool TypeSetting::operator<(const Setting& ref) const {
+	auto refType = dynamic_cast<const TypeSetting*>(&ref);
+	if (refType == nullptr)
+		return true;
+#ifdef ARCHICAD
+	if (type.typeID < refType->type.typeID)
+		return true;
+	if (type.typeID == refType->type.typeID) {
+		if (type.variationID < refType->type.variationID)
+			return true;
+		if (type.variationID == refType->type.variationID)
+			return (type.classID < refType->type.classID);
+	}
+	return false;
+#endif
+} //TypeSetting::operator==
+
+
+/*--------------------------------------------------------------------
+	Assignment operator
+	@param source The object to copy
+	@return A reference to this
+  --------------------------------------------------------------------*/
+TypeSetting& TypeSetting::operator=(const Setting& source) {
+	if (auto refType = dynamic_cast<const TypeSetting*>(&source); refType != nullptr)
+		type = refType->type;
+	return *this;
+} //TypeSetting::operator==
+
+
+/*--------------------------------------------------------------------
+	///True if the setting is empty
+  --------------------------------------------------------------------*/
+bool TypeSetting::empty() const {
+#ifdef ARCHICAD
+	return type.typeID == API_ZombieElemID;
+#endif
+} //TypeSetting::operator==
+
+
+/*--------------------------------------------------------------------
+	Clear the setting (remove any values)
+  --------------------------------------------------------------------*/
+void TypeSetting::clear() {
+	type = BIMIdentity{};
+} //TypeSetting::clear
@@ -0,0 +1,113 @@
+#ifndef SPECKLE_RECORD_ELEMENT_TYPE_SETTING
+#define SPECKLE_RECORD_ELEMENT_TYPE_SETTING
+
+#include "Active/Setting/Setting.h"
+
+#ifdef ARCHICAD
+#include "APIdefs_Elements.h"
+#endif
+
+namespace speckle::record::element {
+
+		///Setting identifying an element type
+	class TypeSetting : public active::setting::Setting {
+	public:
+		
+		// MARK: - Types
+		
+		using base = active::setting::Setting;
+			///BIM platform-specific typoe identifier
+#ifdef ARCHICAD
+		using BIMIdentity = API_ElemType;
+#endif
+			///Unique pointer
+		using Unique = std::unique_ptr<TypeSetting>;
+			///Shared pointer
+		using Shared = std::shared_ptr<TypeSetting>;
+			///Optional
+		using Option = std::optional<TypeSetting>;
+		
+		// MARK: - Constants
+		
+		static const inline active::utility::NameID ID{active::utility::String{"element type"}};
+		
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 @param identifier A BIM element type identifier
+		 */
+		TypeSetting(const BIMIdentity& identifier = BIMIdentity{}) : base{ID}, type{identifier}	{}
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param head An Archicad element header
+		 */
+		TypeSetting(const API_Elem_Head& head) : base{ID}, type{head.type}	{}
+#endif
+
+		/*!
+		 Clone method
+		 @return A clone of this object
+		 */
+		virtual TypeSetting* clonePtr() const override { return new TypeSetting{*this}; }
+
+		// MARK: - Public variables
+		
+			///Platform-specific type identifier
+		BIMIdentity type;
+		
+		// MARK: Operators
+		
+		/*!
+		 Equality operator
+		 @param ref The value to compare
+		 @return True if the values are identical
+		 */
+		bool operator==(const BIMIdentity& ref) const;
+		/*!
+		 Equality operator
+		 @param ref The value to compare
+		 @return True if the values are identical
+		 */
+		bool operator==(const Setting& ref) const override;
+		/*!
+		 Less-than operator
+		 @param ref The value to compare
+		 @return True if this is less than ref
+		 */
+		bool operator<(const Setting& ref) const override;
+		/*!
+		 Assignment operator
+		 @param source The object to copy
+		 @return A reference to this
+		 */
+		TypeSetting& operator=(const Setting& source) override;
+		/*!
+		 Conversion operator
+		 @return True if the setting is not empty
+		 */
+		operator bool() const { return !empty(); }
+
+		// MARK: - Functions (const)
+		
+		/*!
+		 True if the setting is empty
+		 */
+		bool empty() const override;
+
+		// MARK: Functions (mutating)
+		
+		/*!
+		 Clear the setting (remove any values)
+		 */
+		void clear() override;
+		/*!
+		 Assign a default to the setting
+		 */
+		void setDefault() override { clear(); }
+	};
+	
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT_TYPE_SETTING
@@ -0,0 +1,164 @@
+#include "Speckle/Record/Element/Shell.h"
+
+#include "Speckle/Record/Element/Quants/Surveyor.h"
+#include "Speckle/Record/Element/Setting/Conversion.h"
+#include "Speckle/Utility/BIMMemory.h"
+
+#ifdef ARCHICAD
+#include <ACAPinc.h>
+#endif
+
+using namespace active::serialise;
+using namespace speckle::record::attribute;
+using namespace speckle::record::element;
+using namespace speckle::record::element::quants;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace speckle::record::element {
+
+	class Shell::Data {
+	public:
+		friend class Shell;
+
+#ifdef ARCHICAD
+		Data(const API_ShellType& seg) : root{seg} {}
+
+	private:
+		API_ShellType root;
+#endif
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Shell::Shell() {
+} //Shell::Shell
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Constructor
+
+	elemData: Archicad element data
+	tableID: The element table ID (AC database, e.g. floor plan, 3D)
+  --------------------------------------------------------------------*/
+Shell::Shell(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
+	m_data = std::make_unique<Data>(elemData.shell);
+} //Shell::Shell
+#endif
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+
+	source: The object to copy
+  --------------------------------------------------------------------*/
+Shell::Shell(const Shell& source) : base{ source } {
+	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
+} //Shell::Shell
+
+
+/*--------------------------------------------------------------------
+	Move constructor
+
+	source: The object to move
+  --------------------------------------------------------------------*/
+Shell::Shell(Shell&& source) noexcept : base{source} {
+	m_data = std::move(source.m_data);
+} //Shell::Shell
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Shell::~Shell() {}
+
+
+/*--------------------------------------------------------------------
+	Get the element material (applicable to elements with a single, homogenous material)
+ 
+	return: The element material (nullopt if not applicable to the element)
+  --------------------------------------------------------------------*/
+std::optional<Material> Shell::getMaterial() const {
+#ifdef ARCHICAD
+	return Material{Guid{Guid::fromInt(m_data->root.shellBase.buildingMaterial.GenerateHashValue())}};
+#endif
+} //Shell::getMaterial
+
+
+/*--------------------------------------------------------------------
+	Get a spatial measurement from this element (area/volume, as used for material quantities)
+ 
+	return: The element measurement (empty if unavailable)
+  --------------------------------------------------------------------*/
+ModelElement::SpatialMeasure Shell::getSpatialMeasure() const {
+#ifdef ARCHICAD
+	Surveyor surveyor;
+	BIMMemory::setMask(&surveyor.elementMask().shell.referenceSurface);
+	BIMMemory::setMask(&surveyor.elementMask().shell.volume);
+	surveyor.measure(getBIMLink());
+	return SpatialMeasure{surveyor.quantity().shell.referenceSurface, surveyor.quantity().shell.volume};
+#endif
+} //Shell::getSpatialMeasure
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the (immutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+const API_Elem_Head& Shell::getHead() const {
+	return m_data->root.head;
+} //Shell::getHead
+
+
+/*--------------------------------------------------------------------
+	Get the (mutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+API_Elem_Head& Shell::getHead() {
+	return m_data->root.head;
+} //Shell::getHead
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+
+	inventory: The inventory to receive the package items
+
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Shell::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+		//TODO: Implement other fields as required
+	return base::fillInventory(inventory);
+} //Shell::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+
+	item: The inventory item to retrieve
+
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Shell::getCargo(const Inventory::Item& item) const {
+		//TODO: Implement other fields as required
+	return base::getCargo(item);
+} //Shell::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Shell::setDefault() {
+	m_data.reset();
+} //Shell::setDefault
@@ -0,0 +1,120 @@
+#ifndef SPECKLE_RECORD_ELEMENT_SHELL
+#define SPECKLE_RECORD_ELEMENT_SHELL
+
+#include "Speckle/Record/Element/ModelElement.h"
+#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
+
+namespace speckle::record::element {
+	
+	/*!
+	 BIM shell class
+	 */
+	class Shell : public ModelElement {
+	public:
+
+		// MARK: - Types
+		
+		using base = ModelElement;
+			///Unique pointer
+		using Unique = std::unique_ptr<Shell>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Shell>;
+			///Optional
+		using Option = std::optional<Shell>;
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Shell();
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param elemData Archicad element data
+		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
+		 */
+		Shell(const API_Element& elemData, const speckle::utility::Guid& tableID);
+#endif
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Shell(const Shell& source);
+		/*!
+		 Move constructor
+		 @param source The object to move
+		 */
+		Shell(Shell&& source) noexcept;
+		/*!
+		 Destructor
+		 */
+		~Shell();
+
+		/*!
+		 Object cloning
+		 @return A clone of this object
+		 */
+		Shell* clonePtr() const override { return new Shell{*this}; }
+
+
+		// MARK: - Functions (const)
+
+		/*!
+		 Get the element material (applicable to elements with a single, homogenous material)
+		 @return The element material (nullopt if not applicable to the element)
+		 */
+		std::optional<record::attribute::Material> getMaterial() const override;
+		/*!
+		 Get a spatial measurement from this element (area/volume, as used for material quantities)
+		 @return The element measurement (empty if unavailable)
+		 */
+		SpatialMeasure getSpatialMeasure() const override;
+#ifdef ARCHICAD
+		/*!
+		 Get the (immutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		const API_Elem_Head& getHead() const override;
+#endif
+		
+		// MARK: - Functions (mutating)
+
+#ifdef ARCHICAD
+		/*!
+		 Get the (mutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		API_Elem_Head& getHead() override;
+#endif
+
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+		
+	private:
+		class Data;
+			///The beam data
+		std::unique_ptr<Data> m_data;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT_SHELL
@@ -0,0 +1,176 @@
+#include "Speckle/Record/Element/Slab.h"
+
+#include "Speckle/Record/Element/Quants/Surveyor.h"
+#include "Speckle/Record/Element/Setting/Conversion.h"
+#include "Speckle/Utility/BIMMemory.h"
+
+#ifdef ARCHICAD
+#include <ACAPinc.h>
+#endif
+
+using namespace active::serialise;
+using namespace speckle::record::attribute;
+using namespace speckle::record::element;
+using namespace speckle::record::element::quants;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace speckle::record::element {
+
+	class Slab::Data {
+	public:
+		friend class Slab;
+
+#ifdef ARCHICAD
+		Data(const API_SlabType& seg) : root{seg} {}
+
+	private:
+		API_SlabType root;
+#endif
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Slab::Slab() {
+} //Slab::Slab
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Constructor
+
+	elemData: Archicad element data
+	tableID: The element table ID (AC database, e.g. floor plan, 3D)
+  --------------------------------------------------------------------*/
+Slab::Slab(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
+	m_data = std::make_unique<Data>(elemData.slab);
+} //Slab::Slab
+#endif
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+
+	source: The object to copy
+  --------------------------------------------------------------------*/
+Slab::Slab(const Slab& source) : base{ source } {
+	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
+} //Slab::Slab
+
+
+/*--------------------------------------------------------------------
+	Move constructor
+
+	source: The object to move
+  --------------------------------------------------------------------*/
+Slab::Slab(Slab&& source) noexcept : base{source} {
+	m_data = std::move(source.m_data);
+} //Slab::Slab
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Slab::~Slab() {}
+
+
+/*--------------------------------------------------------------------
+	Get the composition of materials in the element
+ 
+	return: The material composition (element with ordered material composition should override)
+  --------------------------------------------------------------------*/
+ModelElement::Composition Slab::getComposition() const {
+#ifdef ARCHICAD
+	return convert(m_data->root.modelElemStructureType);
+#endif
+} //Slab::getComposition
+
+
+/*--------------------------------------------------------------------
+	Get the element material (applicable to elements with a single, homogenous material)
+ 
+	return: The element material (nullopt if not applicable to the element)
+  --------------------------------------------------------------------*/
+std::optional<Material> Slab::getMaterial() const {
+#ifdef ARCHICAD
+	return Material{Guid{Guid::fromInt(m_data->root.buildingMaterial.GenerateHashValue())}};
+#endif
+} //Slab::getMaterial
+
+
+/*--------------------------------------------------------------------
+	Get a spatial measurement from this element (area/volume, as used for material quantities)
+ 
+	return: The element measurement (empty if unavailable)
+  --------------------------------------------------------------------*/
+ModelElement::SpatialMeasure Slab::getSpatialMeasure() const {
+#ifdef ARCHICAD
+	Surveyor surveyor;
+	BIMMemory::setMask(&surveyor.elementMask().slab.topSurface);
+	BIMMemory::setMask(&surveyor.elementMask().slab.volume);
+	surveyor.measure(getBIMLink());
+	return SpatialMeasure{surveyor.quantity().slab.topSurface, surveyor.quantity().slab.volume};
+#endif
+} //Slab::getSpatialMeasure
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the (immutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+const API_Elem_Head& Slab::getHead() const {
+	return m_data->root.head;
+} //Slab::getHead
+
+
+/*--------------------------------------------------------------------
+	Get the (mutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+API_Elem_Head& Slab::getHead() {
+	return m_data->root.head;
+} //Slab::getHead
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+
+	inventory: The inventory to receive the package items
+
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Slab::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+		//TODO: Implement other fields as required
+	return base::fillInventory(inventory);
+} //Slab::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+
+	item: The inventory item to retrieve
+
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Slab::getCargo(const Inventory::Item& item) const {
+		//TODO: Implement other fields as required
+	return base::getCargo(item);
+} //Slab::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Slab::setDefault() {
+	m_data.reset();
+} //Slab::setDefault
@@ -0,0 +1,125 @@
+#ifndef SPECKLE_RECORD_ELEMENT_SLAB
+#define SPECKLE_RECORD_ELEMENT_SLAB
+
+#include "Speckle/Record/Element/ModelElement.h"
+#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
+
+namespace speckle::record::element {
+	
+	/*!
+	 BIM slab class
+	 */
+	class Slab : public ModelElement {
+	public:
+
+		// MARK: - Types
+		
+		using base = ModelElement;
+			///Unique pointer
+		using Unique = std::unique_ptr<Slab>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Slab>;
+			///Optional
+		using Option = std::optional<Slab>;
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Slab();
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param elemData Archicad element data
+		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
+		 */
+		Slab(const API_Element& elemData, const speckle::utility::Guid& tableID);
+#endif
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Slab(const Slab& source);
+		/*!
+		 Move constructor
+		 @param source The object to move
+		 */
+		Slab(Slab&& source) noexcept;
+		/*!
+		 Destructor
+		 */
+		~Slab();
+
+		/*!
+		 Object cloning
+		 @return A clone of this object
+		 */
+		Slab* clonePtr() const override { return new Slab{*this}; }
+
+
+		// MARK: - Functions (const)
+
+		/*!
+		 Get the composition of materials in the element
+		 @return The material composition (element with ordered material composition should override)
+		 */
+		Composition getComposition() const override;
+		/*!
+		 Get the element material (applicable to elements with a single, homogenous material)
+		 @return The element material (nullopt if not applicable to the element)
+		 */
+		std::optional<record::attribute::Material> getMaterial() const override;
+		/*!
+		 Get a spatial measurement from this element (area/volume, as used for material quantities)
+		 @return The element measurement (empty if unavailable)
+		 */
+		SpatialMeasure getSpatialMeasure() const override;
+#ifdef ARCHICAD
+		/*!
+		 Get the (immutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		const API_Elem_Head& getHead() const override;
+#endif
+		
+		// MARK: - Functions (mutating)
+
+#ifdef ARCHICAD
+		/*!
+		 Get the (mutable) API element header data
+		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+		 */
+		API_Elem_Head& getHead() override;
+#endif
+
+		// MARK: - Serialisation
+		
+		/*!
+		 Fill an inventory with the package items
+		 @param inventory The inventory to receive the package items
+		 @return True if the package has added items to the inventory
+		 */
+		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		/*!
+		 Get the specified cargo
+		 @param item The inventory item to retrieve
+		 @return The requested cargo (nullptr on failure)
+		 */
+		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+		
+	private:
+		class Data;
+			///The beam data
+		std::unique_ptr<Data> m_data;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT_SLAB
@@ -0,0 +1,176 @@
+#include "Speckle/Record/Element/Wall.h"
+
+#include "Speckle/Record/Element/Quants/Surveyor.h"
+#include "Speckle/Record/Element/Setting/Conversion.h"
+#include "Speckle/Utility/BIMMemory.h"
+
+#ifdef ARCHICAD
+#include <ACAPinc.h>
+#endif
+
+using namespace active::serialise;
+using namespace speckle::record::attribute;
+using namespace speckle::record::element;
+using namespace speckle::record::element::quants;
+using namespace speckle::utility;
+
+#include <array>
+#include <memory>
+
+namespace speckle::record::element {
+
+	class Wall::Data {
+	public:
+		friend class Wall;
+
+#ifdef ARCHICAD
+		Data(const API_WallType& seg) : root{seg} {}
+
+	private:
+		API_WallType root;
+#endif
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Wall::Wall() {
+} //Wall::Wall
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Constructor
+
+	elemData: Archicad element data
+	tableID: The element table ID (AC database, e.g. floor plan, 3D)
+  --------------------------------------------------------------------*/
+Wall::Wall(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
+	m_data = std::make_unique<Data>(elemData.wall);
+} //Wall::Wall
+#endif
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+
+	source: The object to copy
+  --------------------------------------------------------------------*/
+Wall::Wall(const Wall& source) : base{ source } {
+	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
+} //Wall::Wall
+
+
+/*--------------------------------------------------------------------
+	Move constructor
+
+	source: The object to move
+  --------------------------------------------------------------------*/
+Wall::Wall(Wall&& source) noexcept : base{source} {
+	m_data = std::move(source.m_data);
+} //Wall::Wall
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Wall::~Wall() {}
+
+
+/*--------------------------------------------------------------------
+	Get the composition of materials in the element
+ 
+	return: The material composition (element with ordered material composition should override)
+  --------------------------------------------------------------------*/
+ModelElement::Composition Wall::getComposition() const {
+#ifdef ARCHICAD
+	return convert(m_data->root.modelElemStructureType);
+#endif
+} //Wall::getComposition
+
+
+/*--------------------------------------------------------------------
+	Get the element material (applicable to elements with a single, homogenous material)
+ 
+	return: The element material (nullopt if not applicable to the element)
+  --------------------------------------------------------------------*/
+std::optional<Material> Wall::getMaterial() const {
+#ifdef ARCHICAD
+	return Material{Guid{Guid::fromInt(m_data->root.buildingMaterial.GenerateHashValue())}};
+#endif
+} //Wall::getMaterial
+
+
+/*--------------------------------------------------------------------
+	Get a spatial measurement from this element (area/volume, as used for material quantities)
+ 
+	return: The element measurement (empty if unavailable)
+  --------------------------------------------------------------------*/
+ModelElement::SpatialMeasure Wall::getSpatialMeasure() const {
+#ifdef ARCHICAD
+	Surveyor surveyor;
+	BIMMemory::setMask(&surveyor.elementMask().wall.surface1);
+	BIMMemory::setMask(&surveyor.elementMask().wall.volume);
+	surveyor.measure(getBIMLink());
+	return SpatialMeasure{surveyor.quantity().wall.surface1, surveyor.quantity().wall.volume};
+#endif
+} //Wall::getSpatialMeasure
+
+
+#ifdef ARCHICAD
+/*--------------------------------------------------------------------
+	Get the (immutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+const API_Elem_Head& Wall::getHead() const {
+	return m_data->root.head;
+} //Wall::getHead
+
+
+/*--------------------------------------------------------------------
+	Get the (mutable) API element header data
+
+	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
+  --------------------------------------------------------------------*/
+API_Elem_Head& Wall::getHead() {
+	return m_data->root.head;
+} //Wall::getHead
+#endif
+
+
+/*--------------------------------------------------------------------
+	Fill an inventory with the package items
+
+	inventory: The inventory to receive the package items
+
+	return: True if the package has added items to the inventory
+  --------------------------------------------------------------------*/
+bool Wall::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+		//TODO: Implement other fields as required
+	return base::fillInventory(inventory);
+} //Wall::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+
+	item: The inventory item to retrieve
+
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique Wall::getCargo(const Inventory::Item& item) const {
+		//TODO: Implement other fields as required
+	return base::getCargo(item);
+} //Wall::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Wall::setDefault() {
+	m_data.reset();
+} //Wall::setDefault
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alan Rynne	84b234f26b	use `develop` branch of ActiveLib MSBuild / build (push) Has been cancelled Details MSBuild / deploy-installers (push) Has been cancelled Details	2024-11-11 10:26:02 +01:00
Alan Rynne	b71728086c	Merge remote-tracking branch 'origin/develop' into alan/ci-start	2024-11-11 10:04:24 +01:00
Ralph Wessel	79570b4070	ConversionReporter incremented incorrecrt field when records skipped	2024-11-08 16:31:49 +00:00
Ralph Wessel	e974b360c1	Updated VS projects Set model card ID in projectCollection object at start of Send	2024-11-08 16:02:42 +00:00
Ralph Wessel	ca52be3c48	Clickling cancel during Send emits "triggerCancelSend" event in JS UI	2024-11-08 15:13:55 +00:00
Ralph Wessel	38a5254b30	docs	2024-11-08 09:51:01 +00:00
Ralph Wessel	37e04368ed	Updated VS projects	2024-11-08 09:28:33 +00:00
Ralph Wessel	7ffdc289d0	Added BaseBridge::HighlightObjects	2024-11-08 08:49:36 +00:00
Ralph Wessel	09b7ae77d5	Don't send call stack when a model card id is passed in SendError	2024-11-07 18:26:01 +00:00
Ralph Wessel	73df695458	Fixed SendError message tag and add stackTrace even when empty	2024-11-07 18:20:52 +00:00
Ralph Wessel	03dd5e5f5d	Really added error message for unsupported conversions	2024-11-07 18:02:20 +00:00
Ralph Wessel	d2dde18fdb	Added error message for unsupported conversions	2024-11-07 17:55:09 +00:00
Ralph Wessel	8c12621772	Can't retrieve type names for unsupported elements	2024-11-07 17:54:12 +00:00
Ralph Wessel	c0d42b8316	Updated VS projects	2024-11-07 17:39:37 +00:00
Ralph Wessel	a38e44f2ea	Conversion report log added to send argument Added SendConversionResult	2024-11-07 17:36:39 +00:00
Ralph Wessel	5d0e8d3ae4	Updated Progress component to hold a weak reference	2024-11-07 11:55:31 +00:00
Ralph Wessel	de0c645f5b	Updated VS projects	2024-11-07 11:41:53 +00:00
Ralph Wessel	218a67d92d	Added collection of conversion outcomes during send Added progress display in UI (with ability to cancel)	2024-11-07 11:37:54 +00:00
Ralph Wessel	d6b76cfd56	Merge pull request #19 from specklesystems/david/get_element_type getting element type string from actual element type typeID	2024-11-07 11:34:36 +00:00
David Kekesi	45ccebc710	cleanup	2024-11-07 12:34:07 +01:00
David Kekesi	b7c1f75d6a	getting element type string from actual element type typeID	2024-11-07 12:31:37 +01:00
Ralph Wessel	c51b67318d	Merge pull request #18 from specklesystems/david/disable_grid_elements disabled sending grid elements	2024-11-07 10:09:20 +00:00
David Kekesi	a330baf5da	cleanup	2024-11-07 11:08:56 +01:00
David Kekesi	ea103f3849	disabled sending grid elements, disabled element change subscription on new element event	2024-11-07 11:05:16 +01:00
Ralph Wessel	664fdaf39a	Merge pull request #17 from specklesystems/david/cnx-716-documentless-state-in-archicad cnx 716 documentless state in archicad	2024-11-06 19:35:38 +00:00
David Kekesi	a6f15e9a53	review comments fixed	2024-11-06 20:34:46 +01:00
David Kekesi	0e0dc7da2d	switching to 3D window before send operation implemented	2024-11-06 20:24:03 +01:00
Ralph Wessel	cdd4df09ca	Added setDefaultTable and getDefaultTable for BIMElementDatabase	2024-11-06 19:18:37 +00:00
David Kekesi	e612ed1192	attaching observer to all elements is too slow, commented out for now	2024-11-06 20:18:36 +01:00
David Kekesi	ed75c2110c	Merge branch 'develop' into david/cnx-716-documentless-state-in-archicad	2024-11-06 19:44:40 +01:00
David Kekesi	96759f7e9e	very slow in a 3D view - attaching element observers to all elements	2024-11-06 19:43:01 +01:00
Ralph Wessel	902ddcc8f1	Updated VS projects	2024-11-06 18:11:45 +00:00
Ralph Wessel	b62201cf95	BIMElementDatabase::getTables and bringToFront added BIMElementDatabase::getElements allows a target table to be specified	2024-11-06 18:03:26 +00:00
Ralph Wessel	4e60d95ce9	DocumentID is now generated, saved and recalled using ModelCardDatabase	2024-11-06 16:25:13 +00:00
Ralph Wessel	03ad5a80af	Merge branch 'develop' of https://github.com/specklesystems/speckle-cpp-connectors into develop	2024-11-06 13:06:38 +00:00
Ralph Wessel	fbbf559e83	ConnectorProject should add its model card database to the add-on as a subscriber in order to receive document events, e.g. merge	2024-11-06 13:06:25 +00:00
David Kekesi	da457a3438	subscribing all elements to element events	2024-11-06 11:51:29 +01:00
Ralph Wessel	767e379ff3	Updated Windows resources	2024-11-05 19:05:30 +00:00
Ralph Wessel	08c15c87a2	Updated menu icons	2024-11-05 18:50:14 +00:00
Ralph Wessel	1827323712	Added Speckle menu icon	2024-11-05 18:30:17 +00:00
Ralph Wessel	653824c498	Updated VS projects GetDocumentInfo returns null if no project open	2024-11-05 17:01:51 +00:00
Ralph Wessel	0dc823785d	Removed test code from ConnectorPalette	2024-11-05 16:37:27 +00:00
Ralph Wessel	bacdbc4d61	Added ConnectorProject as a container for ModelCardDatabase Moved ownership of ModelCardDatabase from Addon to ConnectorProject Tools requiring access to the model card database now need to check for an open project first and then obtain the database from it (prevents attempts to access model cards when no project is open)	2024-11-05 16:34:49 +00:00
Alan Rynne	0343ac95ca	fix: Stop tracking output apx	2024-11-05 15:04:08 +00:00
Alan Rynne	53589d7ea0	fix: CI triggers and delete artifacts	2024-11-05 12:27:18 +00:00
Alan Rynne	98c6ac7c9e	fix: Modified CI trigger actions	2024-11-05 12:24:50 +00:00
Alan Rynne	6d0cc1f7e6	fix: File_version and correct env for powershell	2024-11-05 12:14:51 +00:00
Alan Rynne	077a74b2a3	fix: Use file_version not file-version	2024-11-05 12:01:51 +00:00
Ralph Wessel	ef989ad8c7	Merge pull request #16 from specklesystems/david/cnx-720-no-objects-were-found-to-convert-please-update-your-publish cnx 720 no objects were found to convert please update your publish	2024-11-05 11:53:44 +00:00
David Kekesi	8d8934657c	get the selected element ids from the modelcard instead of the application during a send operation	2024-11-05 12:46:14 +01:00
Alan Rynne	f019c88b27	fix: Export file version and use for installer trigger	2024-11-05 11:39:38 +00:00
Ralph Wessel	d7a95fd37c	Added BIMElementDatabase::findObjects	2024-11-05 11:25:33 +00:00
Alan Rynne	246b9099c4	fix: Use bulid output version instead of fake	2024-11-05 11:21:13 +00:00
Ralph Wessel	74d4871fbd	Added ArchicadElementDBaseEngine::find Implemented ArchicadElementDBaseEngine::getObjects	2024-11-05 11:15:53 +00:00
Alan Rynne	2f83e01f66	feat: Add gitversion config	2024-11-05 11:11:51 +00:00
Alan Rynne	9e126e3dbf	run gitversion as separate ci step	2024-11-05 11:10:06 +00:00
Alan Rynne	c646129244	fix: Fetch with 0 depth for gitversion	2024-11-05 11:04:41 +00:00
Alan Rynne	29e786574c	feat: Adds gitversion step	2024-11-05 11:01:56 +00:00
Ralph Wessel	f634f158f9	Use FastDoubleWrap for serialising Mesh vertices	2024-11-05 08:33:53 +00:00
Ralph Wessel	48988fbe53	Updated VS projects Renamed Element/Mesh.cpp for VS compilation	2024-11-01 23:25:49 +00:00
Ralph Wessel	2c0d53c186	Added materials quants for mesh, morph, roof, shell, slab and wall	2024-11-01 22:57:47 +00:00
Ralph Wessel	51370ababc	Updated VS projects	2024-11-01 22:56:39 +00:00
Ralph Wessel	8132eec03e	Material quantities add, implement for column and beam segments Added Material class Renamed variables for finishes from "material" to "finish" Fixed major memory leak in ModelElement::getBody Updated element BIMLink to include a type identifier	2024-11-01 17:01:56 +00:00
Alan Rynne	86373c01c9	fix: final deploy test	2024-10-31 14:30:17 +01:00
Alan Rynne	718c673845	fix: Archicad zipping for deployment	2024-10-31 13:27:18 +01:00
Alan Rynne	af8eb2c817	fix: Correct zipping path and print zip info	2024-10-31 12:04:54 +01:00
Alan Rynne	0d2d8028a2	fix: Refactor zip logic to be extendable	2024-10-31 11:20:40 +01:00
Alan Rynne	bed2cf9d42	fix: Use right path to find zip files	2024-10-31 10:59:20 +01:00
Alan Rynne	5e4bcf48d6	chore: Remove unnecessary restore step	2024-10-31 10:54:39 +01:00
Alan Rynne	59549e1065	fix: Use right path for zip file	2024-10-31 10:50:26 +01:00
Alan Rynne	16bbfae097	feat: Testing Bullseye pipeline	2024-10-31 10:39:10 +01:00
Alan Rynne	326cb80f89	use main for deploy	2024-10-30 15:17:55 +01:00
Alan Rynne	787b2aa6e8	try with hash?	2024-10-30 13:22:49 +01:00
Alan Rynne	7d29bad9b5	test: try with yaml	2024-10-30 13:17:27 +01:00
Alan Rynne	ba193c9dda	test: Try with new name	2024-10-30 13:10:45 +01:00
Alan Rynne	794658ed9c	feat: Add deploy step	2024-10-30 10:40:46 +01:00
Alan Rynne	141c503e81	upload APX to verify it's there	2024-10-29 16:15:22 +01:00
Alan Rynne	319bc2826c	fix build path	2024-10-29 16:09:56 +01:00
Alan Rynne	dee45512a1	fix: nested checkouts	2024-10-29 16:09:39 +01:00
Alan Rynne	ce18804c95	fix: Use relative paths	2024-10-29 16:08:02 +01:00
Alan Rynne	2cfb66a872	run on the correct working directory	2024-10-29 16:05:31 +01:00
Alan Rynne	ed59150363	download and extract archicad dev kit	2024-10-29 15:59:40 +01:00
Alan Rynne	5715148cdd	msbuild version	2024-10-29 15:50:06 +01:00
Alan Rynne	2f534e3fd0	build only connector	2024-10-29 15:49:00 +01:00
Alan Rynne	dd0cb8feb8	feat: Initial CI commit	2024-10-29 15:45:17 +01:00