do not merge - hack for exporting gridlines - each edge is a separate polyline

WIP
2024-10-31 18:15:08 +01:00 · 2024-10-31 13:09:35 +01:00
119 changed files with 530 additions and 5372 deletions
@@ -1,11 +0,0 @@
-{
-  "version": 1,
-  "isRoot": true,
-  "tools": {
-    "gitversion.tool": {
-      "version": "6.0.2",
-      "commands": ["dotnet-gitversion"],
-      "rollForward": false
-    }
-  }
-}
@@ -1,91 +0,0 @@
-# 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,7 +3,6 @@ build/
 Documents/
 ResourceObjects/
 Install/
-enc_temp_folder/
 .vs/
 .vscode/
 xcuserdata/
@@ -26,7 +25,4 @@ XCBuildData/
 *.log
 .idea
 *.mui
-*.aps
-**/obj
-**/bin
-output/
+*.aps
@@ -1,6 +0,0 @@
-workflow: GitFlow/v1
-next-version: 3.0.0
-branches:
-  release:
-    prevent-increment:
-      when-current-commit-tagged: true
@@ -13,8 +13,6 @@ 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
@@ -145,40 +143,6 @@ 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,7 +94,6 @@
  <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" />
@@ -106,7 +105,6 @@
    <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" />
@@ -152,7 +150,6 @@
    <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" />
@@ -165,7 +162,6 @@
    <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" />
@@ -178,7 +174,6 @@
    <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,9 +71,6 @@
    <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">
@@ -252,12 +249,6 @@
    <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">
@@ -432,14 +423,5 @@
    <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,8 +31,6 @@
 		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 */; };
@@ -318,13 +316,6 @@
 		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; };
@@ -557,6 +548,7 @@
 		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>"; };
@@ -976,24 +968,6 @@
 			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 = (
@@ -1030,7 +1004,6 @@
 			children = (
 				21AEF9F92CAC3897000B8681 /* ConversionResult.cpp */,
 				21AEF9F82CAC3897000B8681 /* ConversionResult.h */,
-				2199BB792CDCEA3900A4BEEC /* SendConversionResult.h */,
 				21AEF9E32CAB56E5000B8681 /* SendError.cpp */,
 				21AEF9E42CAB56E5000B8681 /* SendError.h */,
 				21AEF9EE2CAB5720000B8681 /* SendObject.cpp */,
@@ -1061,8 +1034,6 @@
 				21B67CAA2C77329800FD64FC /* GetSourceApplicationVersion.h */,
 				21A79EC52CCDA45C001754E4 /* HighlightModel.cpp */,
 				21A79EC82CCDA45C001754E4 /* HighlightModel.h */,
-				2199BB7C2CDD3FA800A4BEEC /* HighlightObjects.cpp */,
-				2199BB7D2CDD3FA800A4BEEC /* HighlightObjects.h */,
 				21384BC92CD2EE7400D4602B /* OpenUrl.cpp */,
 				21384BCC2CD2EE7400D4602B /* OpenUrl.h */,
 				21D0BDD52C935DAE0077E104 /* RemoveModel.cpp */,
@@ -1192,6 +1163,7 @@
 			isa = PBXGroup;
 			children = (
 				21D1EA4A2BF14BBC00957EAA /* Connector.grc */,
+				21D1EA4B2BF14BC700957EAA /* ConnectorFix.grc */,
 				21F69EDB2C64ED10008B6A06 /* ConnectorMenu.grc */,
 				21D1EA4C2BF14BF000957EAA /* Module-Info27.plist */,
 				21F69EFE2C66AD55008B6A06 /* SpecklePalette.grc */,
@@ -1244,7 +1216,6 @@
 				21B67CCD2C77694500FD64FC /* Connector.h */,
 				21F69F102C677BC0008B6A06 /* ConnectorResource.h */,
 				21B67CCB2C77670400FD64FC /* Database */,
-				2199BB542CDA4B1700A4BEEC /* Environment */,
 				21F69F092C677BC0008B6A06 /* Event */,
 				21F69F0E2C677BC0008B6A06 /* Interface */,
 				21D0BDD82C9387E60077E104 /* Record */,
@@ -1325,7 +1296,6 @@
 		81494D9D09DA5892006864FB /* Resource */ = {
 			isa = PBXGroup;
 			children = (
-				2199BB4E2CDA47F900A4BEEC /* Fixed */,
 				7EA5F91E157FA18400693CEA /* EN-GB */,
 			);
 			name = Resource;
@@ -1535,7 +1505,6 @@
 				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 */,
@@ -1561,7 +1530,6 @@
 				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/Environment/ConnectorProject.h"
+#include "Connector/Database/ModelCardDatabase.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::environment;
+using namespace connector::database;
 using namespace speckle::database;
 using namespace speckle::environment;
 using namespace speckle::utility;
@@ -29,6 +29,8 @@ 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)
@@ -38,18 +40,15 @@ namespace {
 		 @return The account database
 		 */
 		const AccountDatabase* getAccountDatabase() const override;
-		
-	protected:
 		/*!
-		 Make a new new project. Allows Addon subclasses to define a Project subclass with additional functions/databases
-		 @return A new project instance
+		 Get the model card database
+		 @return The model card database
 		 */
-		virtual std::shared_ptr<Project> makeProject() const override {
-			return std::dynamic_pointer_cast<Project>(std::make_shared<ConnectorProject>());
-		}
+		const ModelCardDatabase* getModelCardDatabase() const override { return &m_modelCards; }
 		
 	private:
 		mutable std::unique_ptr<AccountDatabase> m_account;
+		ModelCardDatabase m_modelCards;
 	};
 	
 		///The active addon instance
@@ -3,6 +3,10 @@

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

 namespace connector {
@@ -18,6 +22,11 @@ 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,7 +58,6 @@ enum ErrorString {
 	modelCardNotFoundID,
 	noProjectOpenID,
 	accountNotFoundID,
-	elementTypeNotConvertedID,
 };

 #endif	//CONNECTOR_RESOURCE
@@ -1,33 +0,0 @@
-#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
@@ -1,53 +0,0 @@
-#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,12 +1,10 @@
 #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;
@@ -25,10 +23,6 @@ AddModel::AddModel() : BridgeMethod{"AddModel", [&](const ModelCardEventWrapper&
 	card: The card to add
  --------------------------------------------------------------------*/
 void AddModel::run(const ModelCard& card) const {
-	auto project = connector()->getActiveProject().lock();
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return;
-	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr)
+	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr)
 		modelCardDBase->write(card);
 } //AddModel::run
@@ -8,20 +8,9 @@
 #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;

 /*--------------------------------------------------------------------
@@ -35,11 +24,10 @@ 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,7 +2,6 @@

 #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"
@@ -10,7 +9,6 @@

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

@@ -35,17 +33,14 @@ GetDocumentInfo::GetDocumentInfo() : BridgeMethod{"GetDocumentInfo", [&]() {
  --------------------------------------------------------------------*/
 std::unique_ptr<Cargo> GetDocumentInfo::run() const {
 	auto docInfo = std::make_unique<DocumentInfo>();
-	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
+	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();
 		docInfo->ID = Guid{true}.operator String();
+	}
 	return std::make_unique<WrappedValue>(std::move(docInfo));
 } //GetDocumentInfo::run
@@ -1,13 +1,15 @@
 #include "Connector/Interface/Browser/Bridge/Base/GetDocumentState.h"

+#include "Active/Serialise/CargoHold.h"
 #include "Connector/Connector.h"
-#include "Connector/Environment/ConnectorProject.h"
+#include "Connector/Record/Model/ModelCard.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;

 /*--------------------------------------------------------------------
@@ -24,11 +26,7 @@ GetDocumentState::GetDocumentState() : BridgeMethod{"GetDocumentState", [&]() {
 	return: The document model cards
  --------------------------------------------------------------------*/
 std::unique_ptr<Cargo> GetDocumentState::run() const {
-	auto project = connector()->getActiveProject().lock();
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return nullptr;
-	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr) {
+	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr) {
 		return modelCardDBase->wrapper();
 	}
 	return nullptr;
@@ -1,7 +1,6 @@
 #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"
@@ -12,7 +11,6 @@
 #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;
@@ -20,7 +18,7 @@ using namespace speckle::utility;
 /*--------------------------------------------------------------------
 	Default constructor
  --------------------------------------------------------------------*/
-HighlightModel::HighlightModel() : BridgeMethod{"HighlightModel", [&](const HighlightModelArgs& args) {
+HighlightModel::HighlightModel() : BridgeMethod{"HighlightModel", [&](const SendArgs& args) {
 		run(args);
 }} {}

@@ -31,25 +29,27 @@ HighlightModel::HighlightModel() : BridgeMethod{"HighlightModel", [&](const High
 	modelCardID: The ID of the target model card
  --------------------------------------------------------------------*/
 void HighlightModel::run(const String& modelCardID) const {
-	auto project = connector()->getActiveProject().lock();
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return;
-		//Find the specified model card
-	auto modelCardDatabase = connectorProject->getModelCardDatabase();
+	// Find the specified model card
+	auto modelCardDatabase = connector()->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)
-			return; // TODO: is this OK? should this throw?
+		if (!project) {
+			// TODO: is this OK? should this throw?
+			return;
+		}
+
 		auto elementDatabase = project->getElementDatabase();
 		elementDatabase->clearSelection();
 		elementDatabase->setSelection(modelCardSelection);
 	}
+
 } //HighlightModel::run
@@ -3,19 +3,22 @@

 #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 HighlightModelArgs = speckle::interfac::browser::bridge::JSArgType<StringHold>;
+	using SendArgs = 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<HighlightModelArgs, void> {
+	class HighlightModel : public speckle::interfac::browser::bridge::BridgeMethod<SendArgs, void> {
 	public:

 		// MARK: - Constructors
@@ -1,40 +0,0 @@
-#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
@@ -1,42 +0,0 @@
-#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,16 +1,22 @@
 #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::environment;
+using namespace connector::database;
 using namespace connector::record;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;

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

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

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

 #include <array>
@@ -13,30 +12,14 @@ 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"},
-	};
-
-		///Conversion status enumerator names
-	std::array statusName{
-		"success",
-		"warning",
-		"info",
-		"error",
+		Identity{"modelCardId"},
 	};

 }
@@ -52,12 +35,8 @@ bool ConversionResult::fillInventory(active::serialise::Inventory& inventory) co
 	using enum Entry::Type;
 	inventory.merge(Inventory{
 		{
-			{ 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() },
+			{ fieldID[errorID], errorID, element },
+			{ fieldID[cardID], cardID, element },
 		},
 	}.withType(&typeid(ConversionResult)));
 	return true;
@@ -76,46 +55,11 @@ 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<PackageWrap>(*error);
+			return std::make_unique<ValueWrap<String>>(message);
+		case cardID:
+			return std::make_unique<ValueWrap<String>>(modelCardID);
 		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,42 +1,47 @@
-#ifndef CONNECTOR_INTERFACE_BRIDGE_CONVERSION_RESULT
-#define CONNECTOR_INTERFACE_BRIDGE_CONVERSION_RESULT
+#ifndef CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
+#define CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT

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

 namespace connector::interfac::browser::bridge {
 	
 	/*!
-	 The result of a conversion process (BIM records to/from Speckle)
+	 A send error to return to the JS in the event of an error
 	 */
-	class ConversionResult : public active::serialise::Package {
+	class ConversionResult final : public active::serialise::Package {
 	public:
-		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
+		enum class Status {
+			success = 1,
+			info,
+			warning,
+			error,
 		};
 				
 		// MARK: - Constructors
 		
 		/*!
-			Default constructor
+			Constructor
+			@param errMess The error message
+			@param card The ID of the model card associated with the wrror
 		*/
-		ConversionResult() {}
+		ConversionResult(const speckle::utility::String& errMess, const speckle::utility::String& card) : message{errMess}, modelCardID{card} {}
 				
 		// 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)
@@ -58,60 +63,6 @@ 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);
 }

-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
+#endif	//CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
@@ -1,49 +0,0 @@
-#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,16 +12,14 @@ namespace {
 	
 		///Serialisation fields
 	enum FieldIndex {
-		messageID,
+		errorID,
 		cardID,
-		stackID,
 	};

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

 }
@@ -37,9 +35,8 @@ bool SendError::fillInventory(active::serialise::Inventory& inventory) const {
 	using enum Entry::Type;
 	inventory.merge(Inventory{
 		{
-			{ 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
+			{ fieldID[errorID], errorID, element },
+			{ fieldID[cardID], cardID, element },
 		},
 	}.withType(&typeid(SendError)));
 	return true;
@@ -58,12 +55,10 @@ Cargo::Unique SendError::getCargo(const active::serialise::Inventory::Item& item
 		return nullptr;
 	using namespace active::serialise;
 	switch (item.index) {
-		case messageID:
+		case errorID:
 			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,8 +32,6 @@ 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,14 +1,12 @@
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendObject.h"

-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
 #include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
-#include "Connector/Record/Collection/ProjectCollection.h"
+#include "Active/Serialise/Item/Wrapper/ValueWrap.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;

@@ -69,19 +67,3 @@ 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,7 +3,6 @@

 #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"

@@ -45,20 +44,15 @@ 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,6 +1,5 @@
 #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"

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

 		///Serialisation field IDs
@@ -39,7 +37,6 @@ namespace {
 		Identity{"accountId"},
 		Identity{"message"},
 		Identity{"sendObject"},
-		Identity{"sendConversionResults"},
 	};
 	
 }
@@ -50,11 +47,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


@@ -77,7 +74,6 @@ 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;
@@ -112,9 +108,6 @@ 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/SendConversionResult.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/ConversionResult.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)
-		mutable std::vector<SendConversionResult> sendConversionResults;
+		std::vector<ConversionResult> sendConversionResults;
 			///The commit content
 		SendObject sendObject;

@@ -5,30 +5,25 @@
 #include "Connector/Connector.h"
 #include "Connector/ConnectorResource.h"
 #include "Connector/Database/ModelCardDatabase.h"
-#include "Connector/Environment/ConnectorProject.h"
-#include "Connector/Interface/Browser/Bridge/Send/Arg/SendConversionResult.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.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;

@@ -46,20 +41,8 @@ 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 = connectorProject->getModelCardDatabase();
+	auto modelCardDatabase = connector()->getModelCardDatabase();
 	auto modelCard = modelCardDatabase->getCard(modelCardID);
 	if (!modelCard) {
 		getBridge()->sendEvent("setModelError",
@@ -74,23 +57,26 @@ void Send::run(const String& modelCardID) const {
 					std::make_unique<SendError>(connector()->getLocalString(errorString, accountNotFoundID), modelCardID));
 		return;
 	}
-		//Get the selected elements from the modelcard
+		//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
 	auto elementDatabase = project->getElementDatabase();
-	ElementIDList selected{};
-	if (auto senderCard = dynamic_cast<SenderModelCard*>(modelCard.get())) {
-		selected = senderCard->getFilter().getElementIDs();
+	auto selected = elementDatabase->getSelection();
+	if (selected.empty()) {
+		getBridge()->sendEvent("setModelError",
+					std::make_unique<SendError>(connector()->getLocalString(errorString, noSelectedModelItemsID), modelCardID));
+		return;
 	}
 		//Build a collection from the selected elements
-	auto collection = std::make_unique<ProjectCollection>(project, modelCard->getID());
+	auto collection = std::make_unique<ProjectCollection>(project);
 	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,7 +5,6 @@
 #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"
@@ -17,7 +16,6 @@
 #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;
@@ -32,6 +30,22 @@ 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


@@ -50,13 +64,9 @@ bool SendBridge::handle(const ElementEvent& event) {
 			m_changedElements.clear();
 			break;
 		case end: {
-			auto project = connector()->getActiveProject().lock();
-			auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-			if (!connectorProject)
-				return false;
-			auto modelCardDatabase = connectorProject->getModelCardDatabase();
+			auto modelCardDatabase = connector()->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())) {
@@ -83,5 +93,5 @@ bool SendBridge::handle(const ElementEvent& event) {
 		default:
 		  break;
 	}
-	return false;
+	return true;
 } //SendBridge::handle
@@ -17,8 +17,6 @@
 #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>
@@ -110,9 +108,7 @@ ConnectorPalette::ConnectorPalette() {
 	return: The subscription list (an empty list will put the subscriber into a suspended state)
  --------------------------------------------------------------------*/
 ConnectorPalette::Subscription ConnectorPalette::subscription() const {
-	auto result = ProjectSubscriber::subscription();
-	result.insert(toggleConnectorPaletteID);
-	return result;
+	return { {toggleConnectorPaletteID} };
 } //ConnectorPalette::subscription


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

@@ -265,8 +228,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
@@ -319,10 +282,18 @@ 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,11 +2,10 @@
 #define CONNECTOR_CONNECTOR_PALETTE

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

 namespace connector {
 	
-	class ConnectorPalette : public speckle::event::ProjectSubscriber {
+	class ConnectorPalette : public active::event::Subscriber {
 	public:
 		/*!
 		 Default constructor
@@ -33,13 +32,6 @@ 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,8 +12,6 @@
 #include "Speckle/Record/Attribute/Finish.h"
 #include "Speckle/Record/Element/Element.h"

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


@@ -123,14 +115,15 @@ 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::addFinishProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) {
+bool ProjectCollection::addMaterialProxy(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::addFinishProxy
+} //ProjectCollection::addMaterialProxy


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


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

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

 #include <stack>

@@ -26,7 +25,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, public speckle::serialise::ConversionReporter {
+	class ProjectCollection : public RecordCollection, public speckle::serialise::FinishCollector {
 	public:
 		
 		// MARK: - Types
@@ -38,9 +37,8 @@ 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, const speckle::database::RecordID& modelCardID);
+		ProjectCollection(speckle::environment::Project::Shared project);
 		ProjectCollection(const ProjectCollection&) = delete;
 		/*!
 		 Destructor
@@ -71,14 +69,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 addFinishProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) override;
+		bool addMaterialProxy(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 addFinishProxy(const speckle::record::attribute::Finish& finish, const speckle::database::BIMRecordID& objectID) override;
+		bool addMaterialProxy(const speckle::record::attribute::Finish& finish, const speckle::database::BIMRecordID& objectID) override;
 		
 		// MARK: - Serialisation
 		
@@ -11,6 +11,5 @@
 #include "Speckle.grc.rc2"

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

 1	ICON	LOADONCALL MOVEABLE IMPURE  ACAP.ico
@@ -1,10 +0,0 @@
-
-#ifdef macintosh
-'GICN' 32500  "Speckle menu icon" {
-	"32500Mac"
-}
-#else
-'GICN' 32500  "Speckle menu icon" {
-	"32500Win"
-}
-#endif
@@ -1,5 +0,0 @@
-<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>
@@ -1,5 +0,0 @@
-<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,5 +9,4 @@
 /* [  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^32500"
+	/*[ 1]*/	"Speckle Connector^E3^EL^ES^ED^EE^EI^EW^ET^"
 }


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

 		///Element database storage declaration
-	class BIMElementDatabase::Store : public Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID,
-			BIMRecordID, BIMRecordID, ElementStorage::TableType> {
-		using base = Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID, ElementStorage::TableType>;
+	class BIMElementDatabase::Store : public Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID> {
+		using base = Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID>;
 		using base::base;
 	};
 	
@@ -76,48 +75,6 @@ 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
 
@@ -144,27 +101,10 @@ 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)
  --------------------------------------------------------------------*/
@@ -177,14 +117,10 @@ 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(std::optional<BIMRecordID> tableID,
-												std::optional<BIMRecordID> documentID) const {
-	return m_store->getObjects(tableID, documentID);
+Vector<Element> BIMElementDatabase::getElements() const {
+	return m_store->getObjects();
 } //BIMElementDatabase::getElements


@@ -2,7 +2,6 @@
 #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"
@@ -20,7 +19,7 @@ namespace speckle::database {
 	/*!
 	 Database of model elements relating to a specific project
 	 */
-	class BIMElementDatabase : public ElementStorage {
+	class BIMElementDatabase {
 	public:

 		// MARK: - Constructors
@@ -37,27 +36,6 @@ 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
@@ -71,15 +49,6 @@ 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
@@ -97,12 +66,9 @@ 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(std::optional<BIMRecordID> tableID = std::nullopt,
-																		std::optional<BIMRecordID> documentID = std::nullopt) const;
+		active::container::Vector<record::element::Element> getElements() 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
 		 */
-		virtual BIMLink getBIMLink() const { return BIMLink{BIMLink::base{m_applicationID, m_applicationTableID}}; }
+		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,7 +34,6 @@ namespace speckle::database {
 		using Attribute = record::attribute::Attribute;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
-		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constructors
 		
@@ -52,15 +51,6 @@ 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
@@ -74,7 +64,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,12 +16,6 @@
 #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"

@@ -41,24 +35,14 @@ 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{};
-		if (tableID == primary2DViewID)
-			dbaseInfo.typeID = APIWind_FloorPlanID;
-		else if (tableID == primary3DViewID)
-			dbaseInfo.typeID = APIWind_3DModelID;
-		else
-			dbaseInfo.databaseUnId.elemSetId = tableID;
+		API_DatabaseInfo dbaseInfo;
+		dbaseInfo.databaseUnId.elemSetId = tableID;
 		if (auto err = ACAPI_Window_GetDatabaseInfo(&dbaseInfo); err == NoError)
 			return dbaseInfo;
 		return std::nullopt;
@@ -72,7 +56,7 @@ namespace {
 	 */
 	bool setActiveTable(const BIMRecordID& tableID) {
 		if (!tableID)
-			return false;	//Null guid doesn't point to anything
+			return false;	//Null guid doens't point to anything
 		if (auto activeTable = ArchicadElementDBaseEngine::getActiveTable(); activeTable && *activeTable == tableID)
 			return true;
 		auto dbaseInfo = getTableInfo(tableID);
@@ -98,22 +82,6 @@ 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);
 		}
@@ -128,34 +96,12 @@ namespace {
 std::optional<BIMRecordID> ArchicadElementDBaseEngine::getActiveTable() {
 	API_WindowInfo dbaseInfo;
 	active::utility::Memory::erase(dbaseInfo);
-	if (auto err = ACAPI_Database_GetCurrentDatabase(&dbaseInfo); err == NoError) {
-		if (dbaseInfo.typeID == APIWind_FloorPlanID)
-			return primary2DViewID;
-		else if (dbaseInfo.typeID == APIWind_3DModelID)
-			return primary3DViewID;
+	if (auto err = ACAPI_Database_GetCurrentDatabase(&dbaseInfo); err == NoError)
 		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
 
@@ -198,73 +144,6 @@ 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
 
@@ -332,19 +211,7 @@ active::container::Vector<Element> ArchicadElementDBaseEngine::getObjects(std::o
 																					  std::optional<BIMRecordID> documentID) const {
 	if (tableID)
 		setActiveTable(*tableID);
-	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;
+	return {}; //TODO: Implement
 } //ArchicadElementDBaseEngine::getObjects


@@ -4,7 +4,6 @@
 #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"
@@ -18,17 +17,16 @@ 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 ElementStorage,
-			public active::database::DBaseEngine<record::element::Element, BIMRecordID, BIMRecordID, BIMRecordID, ElementStorage::TableType>  {
+	class ArchicadElementDBaseEngine : public ArchicadDBaseCore,
+			public active::database::DBaseEngine<record::element::Element, BIMRecordID, BIMRecordID, BIMRecordID>  {
 	public:
 		
 		// MARK: - Types
 		
 		using base = active::database::DBaseEngine<record::element::Element, BIMRecordID, BIMRecordID, BIMRecordID>;
 		using Element = record::element::Element;
-		using Filter = ElementStorage::Filter;
+		using Filter = base::Filter;
 		using Outline = base::Outline;
-		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constants
 		
@@ -55,11 +53,6 @@ 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
@@ -73,31 +66,6 @@ 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
@@ -111,7 +79,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,7 +29,6 @@ namespace speckle::database {
 		using Group = record::property::Group;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
-		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constructors
 		
@@ -47,15 +46,6 @@ 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
@@ -69,7 +59,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,7 +30,6 @@ namespace speckle::database {
 		using Template = record::property::Template;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
-		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constructors
 		
@@ -48,15 +47,6 @@ 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
@@ -76,7 +66,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,7 +46,6 @@ 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
@@ -60,15 +59,6 @@ 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
@@ -82,7 +72,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;
 		/*!
@@ -181,10 +171,8 @@ namespace speckle::database {
 			//Read the data stored in the document
 		auto storedData = readStore();
 		m_cache = std::make_unique<Cache>();
-		if (!storedData) {
-			m_cache->setID(speckle::utility::Guid{true}.operator speckle::utility::String()); //Needs an ID - substitute for the Speckle 'document ID'
+		if (!storedData)
 			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);
@@ -1,29 +0,0 @@
-#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,7 +2,6 @@

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

 #include <limits>

@@ -19,14 +18,6 @@ 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; }
-	};
-
-	
 }

 /*--------------------------------------------------------------------
@@ -130,8 +121,6 @@ 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)
 		 */
-		virtual std::weak_ptr<Project> getActiveProject() const;
+		std::weak_ptr<Project> getActiveProject() const;
 		/*!
 		 Get the session index
 		 @return The session index (non-recursive entries into the add-on)
@@ -1,5 +1,4 @@
 #include "Speckle/Environment/Host.h"
-#include "Active/Utility/Memory.h"

 #ifdef ARCHICAD
 #include "DG.h"
@@ -22,26 +21,6 @@ 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,12 +20,6 @@ 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
 		 */
-		virtual ~Project();
+		~Project();
 		
 		// MARK: - Functions (const)
 		
@@ -31,8 +31,7 @@ namespace {
 		switch (elemType->notifID)
 		{
 			case APINotifyElement_New: {
-				// POC: Put this back once we decide to use Object Tracking
-				// ACAPI_Element_AttachObserver(elemType->elemHead.guid);
+				ACAPI_Element_AttachObserver(elemType->elemHead.guid);
 				addon()->publishExternal(ElementEvent{newElem, ElementID{elemType->elemHead.guid}});
 			} break;
 			case APINotifyElement_Change: {
@@ -5,7 +5,6 @@
 #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>

@@ -46,15 +45,7 @@ std::unique_ptr<WrappedResultArg> GetCallResult::getResult(const WrappedResultAr
 	if (!item)
 		return nullptr;
 	String 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";
-	}
+	JSONTransport().send(std::forward<Cargo&&>(*item), Identity{}, jsonOutput);
 	record::element::ModelElement::resetCache();
 	return std::make_unique<WrappedResultArg>(jsonOutput);
 } //GetCallResult::getResult
@@ -1,101 +0,0 @@
-#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
@@ -1,80 +0,0 @@
-#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,7 +1,6 @@
 #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"
@@ -20,6 +19,10 @@ namespace {
 		vertexID,
 		faceID,
 		colorID,
+		pointID,
+		closedID,
+		lengthID,
+		areaID,
 	};

 		///Serialisation field IDs
@@ -27,6 +30,10 @@ namespace {
 		Identity{"vertices"},
 		Identity{"faces"},
 		Identity{"colors"},
+		Identity{"value"},
+		Identity{"closed"},
+		Identity{"length"},
+		Identity{"area"},
 	};

 }
@@ -54,6 +61,13 @@ void Mesh::appendFace(const std::vector<double>& vertices) {
 	return: True if the package has added items to the inventory
  --------------------------------------------------------------------*/
 bool Mesh::fillInventory(Inventory& inventory) const {
+	if (isPolyline)
+		return fillInventoryPolyline(inventory);
+	else
+		return fillInventoryMesh(inventory);
+} //Mesh::fillInventory
+
+bool Mesh::fillInventoryMesh(Inventory& inventory) const {
 	using enum Entry::Type;
 	inventory.merge(Inventory{
 		{
@@ -61,9 +75,22 @@ bool Mesh::fillInventory(Inventory& inventory) const {
 			{ fieldID[faceID], faceID, element },
 			{ fieldID[colorID], colorID, element },
 		},
-	}.withType(&typeid(Mesh)));
+		}.withType(&typeid(Mesh)));
 	return base::fillInventory(inventory);
-} //Mesh::fillInventory
+}
+
+bool Mesh::fillInventoryPolyline(Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[pointID], pointID, element },
+			{ fieldID[closedID], closedID, element },
+			{ fieldID[lengthID], lengthID, element },
+			{ fieldID[areaID], areaID, element },
+		},
+		}.withType(&typeid(Mesh)));
+	return base::fillInventory(inventory);
+}


 /*--------------------------------------------------------------------
@@ -74,20 +101,46 @@ bool Mesh::fillInventory(Inventory& inventory) const {
 	return: The requested cargo (nullptr on failure)
  --------------------------------------------------------------------*/
 Cargo::Unique Mesh::getCargo(const Inventory::Item& item) const {
+	if (isPolyline)
+		return getCargoPolyline(item);
+	else
+		return getCargoMesh(item);
+	
+} //Mesh::getCargo
+
+Cargo::Unique Mesh::getCargoMesh(const Inventory::Item& item) const {
 	if (item.ownerType != &typeid(Mesh))
 		return base::getCargo(item);
 	using namespace active::serialise;
 	switch (item.index) {
 	case vertexID:
-			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:
-			return std::make_unique<ContainerWrap<std::vector<int>>>(m_colors);
-		default:
-			return nullptr;	//Requested an unknown index
+		return std::make_unique<ContainerWrap<std::vector<double>>>(m_vertices);
+	case faceID:
+		return std::make_unique<ContainerWrap<std::vector<int>>>(m_faces);
+	case colorID:
+		return std::make_unique<ContainerWrap<std::vector<int>>>(m_colors);
+	default:
+		return nullptr;	//Requested an unknown index
 	}
-} //Mesh::getCargo
+}
+
+Cargo::Unique Mesh::getCargoPolyline(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(Mesh))
+		return base::getCargo(item);
+	using namespace active::serialise;
+	switch (item.index) {
+	case pointID:
+		return std::make_unique<ContainerWrap<std::vector<double>>>(m_points);
+	case closedID:
+		return std::make_unique<ValueWrap<bool>>(isClosed);
+	case lengthID:
+		return std::make_unique<ValueWrap<double>>(length);
+	case areaID:
+		return std::make_unique<ValueWrap<double>>(area);
+	default:
+		return nullptr;	//Requested an unknown index
+	}
+}


 /*--------------------------------------------------------------------
@@ -99,6 +152,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->addFinishProxy(m_finish, getBIMID());
+			collector->addMaterialProxy(m_finish, getBIMID());
 	}
 } //Mesh::useManagement
@@ -43,6 +43,10 @@ namespace speckle::primitive {
 		Mesh(std::vector<double>&& vertices, std::vector<int>&& faces, std::vector<int>&& colors, const record::attribute::Finish& finish,
 				active::measure::LengthType unit = active::measure::LengthType::metre) :
 				base{utility::Guid{true}, utility::Guid{}, unit}, m_vertices{std::move(vertices)}, m_faces{std::move(faces)}, m_colors{std::move(colors)}, m_finish{finish} {}
+
+		Mesh(std::vector<double>&& points, const record::attribute::Finish& finish,
+			active::measure::LengthType unit = active::measure::LengthType::metre) :
+			base{ utility::Guid{true}, utility::Guid{}, unit }, m_points{ std::move(points) }, m_finish{ finish } {}
 		
 		// MARK: - Functions (const)
 		
@@ -50,7 +54,13 @@ namespace speckle::primitive {
 		 Get the speckle type identifier
 		 @return The speckle type (relevant objects should override as required)
 		 */
-		speckle::utility::String getSpeckleType() const override { return "Objects.Geometry.Mesh"; }
+		speckle::utility::String getSpeckleType() const override 
+		{ 
+			if (isPolyline)
+				return "Objects.Geometry.Polyline";
+			else
+				return "Objects.Geometry.Mesh";
+		}

 		/*!
 		 Append a single face to the Mesh given by the vertices
@@ -66,23 +76,35 @@ namespace speckle::primitive {
 		 @return True if the package has added items to the inventory
 		 */
 		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		bool fillInventoryMesh(active::serialise::Inventory& inventory) const;
+		bool fillInventoryPolyline(active::serialise::Inventory& inventory) const;
 		/*!
 		 Get the specified cargo
 		 @param item The inventory item to retrieve
 		 @return The requested cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		active::serialise::Cargo::Unique getCargoMesh(const active::serialise::Inventory::Item& item) const;
+		active::serialise::Cargo::Unique getCargoPolyline(const active::serialise::Inventory::Item& item) const;
 		/*!
 		 Use a manager in (de)serialisation processes
 		 @param management The management to use
 		 */
 		void useManagement(active::serialise::Management* management) const override;
+
+		void setToPolyline() { isPolyline = true; }
 		
 	private:
 		std::vector<double> m_vertices;
+		std::vector<double> m_points;
 		std::vector<int> m_faces;
 		std::vector<int> m_colors;
 		record::attribute::Finish m_finish;
+
+		bool isPolyline = false;
+		bool isClosed = false;
+		double length = 2.0;
+		double area = 0.0;
 	};
 	
 }
@@ -1,196 +0,0 @@
-#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
@@ -1,143 +0,0 @@
-#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,8 +1,15 @@
 #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;
@@ -17,11 +24,12 @@ namespace speckle::record::element {
 		friend class Beam;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{elem.beam} {}
+		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) } {}
 #endif

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

 }
@@ -83,7 +91,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

 /*--------------------------------------------------------------------
@@ -92,7 +100,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,17 +1,21 @@
 #include "Speckle/Record/Element/BeamSegment.h"

-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.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"

 #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>
@@ -24,10 +28,11 @@ namespace speckle::record::element {
 		friend class BeamSegment;

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

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

@@ -97,46 +102,6 @@ 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
@@ -144,7 +109,7 @@ ModelElement::SpatialMeasure BeamSegment::getSpatialMeasure() const {
 	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


@@ -154,7 +119,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,21 +64,6 @@ 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,8 +1,15 @@
 #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;
@@ -17,11 +24,12 @@ namespace speckle::record::element {
 		friend class Column;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{elem.column} {}
+		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) } {}
 #endif

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

 }
@@ -83,7 +91,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

 /*--------------------------------------------------------------------
@@ -92,7 +100,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,17 +1,21 @@
 #include "Speckle/Record/Element/ColumnSegment.h"

-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.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"

 #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>
@@ -24,10 +28,11 @@ namespace speckle::record::element {
 		friend class ColumnSegment;

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

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

@@ -97,46 +102,6 @@ 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
@@ -144,7 +109,7 @@ ModelElement::SpatialMeasure ColumnSegment::getSpatialMeasure() const {
 	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


@@ -154,7 +119,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,21 +64,6 @@ 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,6 +1,15 @@
 #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,120 +1,24 @@
 #include "Speckle/Record/Element/Element.h"

-#include "Active/Serialise/CargoHold.h"
-#include "Active/Serialise/Management/Management.h"
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.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/UserCancel.h"
+#include "Speckle/Utility/Guid.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
@@ -171,42 +75,17 @@ Storey::Option Element::getStorey() const {


 /*--------------------------------------------------------------------
-	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
+	Get the element type name, e.g. "Wall", "Roof" etc

 	return: The type name
  --------------------------------------------------------------------*/
-String Element::getLocalisedTypeName() const {
+String Element::getTypeName() 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


@@ -218,12 +97,6 @@ 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

@@ -236,15 +109,7 @@ bool Element::fillInventory(Inventory& inventory) const {
 	return: The requested cargo (nullptr on failure)
  --------------------------------------------------------------------*/
 Cargo::Unique Element::getCargo(const Inventory::Item& item) const {
-    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
-    }
+		return base::getCargo(item);
 } //Element::getCargo


@@ -256,22 +121,6 @@ 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,12 +62,7 @@ namespace speckle::record::element {
 		// MARK: - Functions (const)

 		/*!
-		 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
+		 Get the elmeent type name, e.g. "Wall", "Roof" etc
 		 @return The type name
 		 */
 		virtual speckle::utility::String getTypeName() const;
@@ -76,11 +71,6 @@ 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
@@ -117,11 +107,6 @@ 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,6 +1,15 @@
 #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;
@@ -15,11 +24,12 @@ namespace speckle::record::element {
 		friend class GenericDrawingElement;

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

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

 }
@@ -65,7 +75,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

 /*--------------------------------------------------------------------
@@ -74,7 +84,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,6 +1,15 @@
 #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;
@@ -15,11 +24,12 @@ namespace speckle::record::element {
 		friend class GenericModelElement;

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

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

 }
@@ -65,7 +75,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

 /*--------------------------------------------------------------------
@@ -74,7 +84,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

@@ -1,164 +0,0 @@
-#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
@@ -1,120 +0,0 @@
-#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,12 +1,13 @@
 #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/BIMMemory.h"
+#include "Speckle/Utility/Guid.h"

 #ifdef ARCHICAD
 #include <exp.h>
@@ -16,6 +17,7 @@
 #include <ModelElement.hpp>
 #include <ModelMaterial.hpp>
 #include <ModelMeshBody.hpp>
+#include <ModelEdge.hpp>
 #include <Sight.hpp>
 #endif

@@ -25,13 +27,14 @@ 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;

 #include <array>
 #include <memory>

+#include <stack>
+
 namespace speckle::record::element {

 	class ModelElement::Data {
@@ -78,7 +81,6 @@ 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;
 	
 }
@@ -88,96 +90,76 @@ 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 getPartIDs(T* parts, std::set<API_Guid>& partIDs) {
-		GSSize nSubElements = BMGetPtrSize(reinterpret_cast<GSPtr>(parts)) / sizeof(T);
+	void getSubElementIds(T* ptr, std::set<API_Guid>& subIds)
+	{
+		GSSize nSubElements = BMGetPtrSize(reinterpret_cast<GSPtr>(ptr)) / sizeof(T);
 		for (Int32 idx = 0; idx < nSubElements; ++idx)
-			partIDs.insert(parts[idx].head.guid);
+			subIds.insert(ptr[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);

-				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;
+	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);
 		}
-		return partIDs;
+
+		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;
 	}
 #endif
 	
@@ -254,52 +236,6 @@ 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

@@ -307,6 +243,8 @@ MaterialQuantityList ModelElement::getMaterialQuantities() const {
  --------------------------------------------------------------------*/
 ModelElement::Body* ModelElement::getBody() const {
 #ifdef ARCHICAD
+	ModelerAPI::Material tmpmat{};
+
 	if (m_data && m_data->m_cache)
 		return m_data->m_cache.get();
 	void* dummy = nullptr;
@@ -324,18 +262,13 @@ ModelElement::Body* ModelElement::getBody() const {
 	auto elementBody = new ModelElement::Body();
 	// Map to collect meshes per material name
 	std::unordered_map<String, primitive::Mesh> materialMeshMap;
-
-	std::unique_ptr<Memo> memo;
-	loadMemo(APIMemoMask_All, memo);
-
-    auto partIDs = collectPartIDs(getHead().guid, getHead().type.typeID, *memo);
-	memo.reset();
+    auto subIds = collectSubIds(getHead().guid);
 	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 (partIDs.find(apiGuid) == partIDs.end())
+		if (subIds.find(apiGuid) == subIds.end())
 			continue;
 		Int32 nBodies = elem.GetTessellatedBodyCount();
 		ModelerAPI::Material material{};
@@ -343,6 +276,52 @@ ModelElement::Body* ModelElement::getBody() const {
 			ModelerAPI::MeshBody body{};
 			elem.GetTessellatedBody(bodyIndex, &body);
 			Int32 polyCount = body.GetPolygonCount();
+
+			if (polyCount == 0)
+			{
+				std::vector<int> vertexIndices;
+				
+				Int32 edgeCount = body.GetEdgeCount();
+				ModelerAPI::Edge edge{};
+				for (Int32 edgeIndex = 1; edgeIndex <= edgeCount; ++edgeIndex)
+				{
+					body.GetEdge(edgeIndex, &edge);
+					vertexIndices.push_back(edge.GetVertexIndex1());
+					vertexIndices.push_back(edge.GetVertexIndex2());
+				}
+				vertexIndices.push_back(edge.GetVertexIndex2());
+				vertexIndices.push_back(edge.GetVertexIndex2());
+
+				for (int i = 0; i < vertexIndices.size(); i += 2) {
+					ModelerAPI::Vertex v1{};
+					ModelerAPI::Vertex v2{};
+					body.GetVertex(vertexIndices[i], &v1);
+					body.GetVertex(vertexIndices[i + 1], &v2);
+
+					std::vector<double> points{};
+
+					points.push_back(v1.x);
+					points.push_back(v1.y);
+					points.push_back(v1.z);
+
+					points.push_back(v2.x);
+					points.push_back(v2.y);
+					points.push_back(v2.z);
+
+					points.push_back(v2.x);
+					points.push_back(v2.y);
+					points.push_back(v2.z);
+
+					record::attribute::Finish f(tmpmat);
+					primitive::Mesh mesh(std::move(points), f);
+					mesh.setToPolyline();
+					elementBody->push_back(mesh);
+
+					points.clear();
+				}
+			}
+
+
 			for (Int32 polyIndex = 1; polyIndex <= polyCount; ++polyIndex) {
 				ModelerAPI::Polygon polygon{};
 				body.GetPolygon(polyIndex, &polygon);
@@ -353,6 +332,8 @@ ModelElement::Body* ModelElement::getBody() const {
 				if (faceFinish == nullptr) {
 					ModelerAPI::Material material{};
 					polygon.GetMaterial(&material);
+					///
+					tmpmat = material;
 					Finish finish{material};
 					faceFinish = ModelElement::cacheFinish(finishID, finish);
 				}
@@ -380,6 +361,13 @@ ModelElement::Body* ModelElement::getBody() const {
 	}
 	for (auto& [materialName, mesh] : materialMeshMap)
 		elementBody->push_back(std::move(mesh));
+
+	/*std::vector<double> points = {0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0};
+	record::attribute::Finish f(tmpmat);
+	primitive::Mesh mesh(std::move(points), f);
+	mesh.setToPolyline();
+	elementBody->push_back(mesh);*/
+
 	m_data = std::make_unique<Data>();
 	m_data->m_cache.reset(elementBody);
 	return m_data->m_cache.get();
@@ -399,7 +387,6 @@ bool ModelElement::fillInventory(Inventory& inventory) const {
 	inventory.merge(Inventory{
 		{
 			{ fieldID[bodyID], bodyID, element },
-			{ fieldID[materialQuantsID], materialQuantsID, element },
 			{ fieldID[propertyID], propertyID, element },
 		},
 	}.withType(&typeid(ModelElement)));
@@ -421,15 +408,11 @@ 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}};
-			return nullptr;
-		case materialQuantsID:
-			if (auto quants = getMaterialQuantities(); !quants.empty())
-				return Cargo::Unique{new CargoHold<ContainerWrap<MaterialQuantityList>, MaterialQuantityList>{quants}};
-			return nullptr;
+				return Cargo::Unique{ new active::serialise::ContainerWrap{*body} };
+			else
+				return nullptr;
 		case propertyID:
-			return nullptr;
-			//return std::make_unique<PropertiedWrapper>(*this);
+			return std::make_unique<PropertiedWrapper>(*this);
 		default:
 			return nullptr;	//Requested an unknown index
 	}
@@ -1,15 +1,13 @@
 #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/Quants/MaterialQuantity.h"
+#include "Speckle/Record/Element/Element.h"
 #include "Speckle/Record/Property/Propertied.h"

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

 namespace speckle::record::element {
@@ -31,23 +29,8 @@ 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: - Static functions
+		// MARK: - Constructors
 		
 		/*!
 		 Get a mesh finish from the cache
@@ -96,26 +79,6 @@ 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)
@@ -1,164 +0,0 @@
-#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
@@ -1,120 +0,0 @@
-#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
@@ -1,78 +0,0 @@
-#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
@@ -1,95 +0,0 @@
-#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
@@ -1,68 +0,0 @@
-#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
@@ -1,47 +0,0 @@
-#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
@@ -1,86 +0,0 @@
-#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
@@ -1,97 +0,0 @@
-#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
@@ -1,176 +0,0 @@
-#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
@@ -1,125 +0,0 @@
-#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
@@ -1,30 +0,0 @@
-#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
@@ -1,82 +0,0 @@
-#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
@@ -1,113 +0,0 @@
-#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
@@ -1,164 +0,0 @@
-#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
@@ -1,120 +0,0 @@
-#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
@@ -1,176 +0,0 @@
-#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
@@ -1,125 +0,0 @@
-#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
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
David Kekesi	e9d669c4dd	do not merge - hack for exporting gridlines - each edge is a separate polyline	2024-10-31 18:15:08 +01:00
David Kekesi	e4e31314d6	WIP	2024-10-31 13:09:35 +01:00