Qt6 Migration: Complete migration with DDS/RTI support and build validation

Major Changes:
- Merged latest Qt5 devel content from dlbo (292 files changed, 7 new dirs)
- Consolidated forward-declarations and include folders
- Removed unneeded modules per Niklas' repo check list

Build System Fixes:
- Fixed CMake VERSION_GREATER syntax in ParticipantManagement/CMakeLists.txt
- Added VLC packages (libvlc-dev, vlc-plugin-base) to docker_build.sh
- Added PostgreSQL dev packages (libpq-dev, postgresql-server-dev-all) to Dockerfile
- Fixed locale warnings (ANSI_X3.4-1968 → C.UTF-8)
- Fixed ArcGIS SDK path warnings when BUILD_ARCGIS=OFF

Code Generation Fixes:
- Fixed IDL enum collisions (PortType→CorePortType/DdsutPortType, PdmEventType)
- Fixed Grantlee template svc_translation.cpp.grantlee:
  - Changed {{ idl_enum.name }}_def:: to {{ idl_enum.name }}::
  - Fixed .underlying() calls for C++11 scoped enums (enum class)
- Removed generated files from repo (moc_*, *_dtc.h, *_ftc.h)

Validation:
- BUILD_RTI=ON: SUCCESS
- BUILD_RTI=OFF: SUCCESS
- C++17 standard maintained for RTI 7.7 compatibility
- Ubuntu 26.04 Docker environment verified

Remaining Warnings (expected):
- BgViewer, KDChart, KDReports, Poppler-Qt6 not found (optional features)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

qt5-before/dlbo/Lts/Tools/ArAssetsV2/src/Functions.ts

@@ -0,0 +1,163 @@
+import { Helpers, _, MOBILE } from "./Helpers";
+
+export module Functions {
+
+	//#region private
+	async function checkForPort(ip: string): Promise<number> {
+		return new Promise<number>(async (resolve, reject) => {
+			new Helpers.WebSocketRequest(
+				ip,
+				JSON.stringify({
+					type: "servicePortsInformationRequest",
+					uuid: Helpers.GenUuid()
+				})
+			)
+				.GetResponseAsync()
+				.then(response => {
+					for (let p of JSON.parse(response).data[0].services) {
+						if (p.nameAbbrevation === "ism") {
+							return resolve(p.ports[0].number);
+						}
+					}
+					return reject();
+				})
+				.catch(() => {
+					return reject();
+				});
+		});
+	}
+
+	async function retrieveDataIp(tryLocalhostFirst: boolean): Promise<string> {
+		return new Promise<string>((resolve, reject) => {
+			const localhost: string = "ws://localhost";
+			const defaultIp: string = "ws://192.168.133.140";
+			const portToCheck: number = 7300;
+			if (tryLocalhostFirst) {
+				checkForPort(`${localhost}:${portToCheck}`)
+					.then(port => {
+						return resolve(`${localhost}:${port}`);
+					})
+					.catch(() =>
+						checkForPort(`${defaultIp}:${portToCheck}`)
+							.then(port => {
+								return resolve(`${defaultIp}:${port}`);
+							})
+							.catch(() => {
+								return reject();
+							})
+					);
+			} else {
+				checkForPort(`${defaultIp}:${portToCheck}`)
+					.then(port => resolve(`${defaultIp}:${port}`))
+					.catch(() =>
+						checkForPort(`${localhost}:${portToCheck}`)
+							.then(port => {
+								return resolve(`${localhost}:${port}`);
+							})
+							.catch(() => {
+								return reject();
+							})
+					);
+			}
+		});
+	}
+
+	async function loadData(ip: string): Promise<any> {
+		return new Promise<any>((resolve, reject) => {
+			new Helpers.WebSocketRequest(
+				ip,
+				JSON.stringify({
+					type: "getEssentials",
+					uuid: Helpers.GenUuid()
+				})
+			)
+				.GetResponseAsync()
+				.then(data => resolve(JSON.parse(data).data))
+				.catch(() => {
+					return reject();
+				});
+		});
+	}
+
+	async function manualLoadData(): Promise<any> {
+		return new Promise<any>(async (resolve, reject) => {
+			let data: any;
+			let serverIp: string = "ws://192.168.133.140:2080";
+			do {
+				serverIp = prompt(
+					"Unable to load data automatically. Please enter ip:",
+					serverIp
+				) as string;
+				try {
+					data = await loadData(serverIp);
+				} catch {
+					continue;
+				}
+			} while (_(data));
+			webSocketIp = serverIp;
+			return resolve(data);
+		});
+	}
+
+	function storeInCache(key: string, value: any): void {
+		window.localStorage.setItem(key, escape(JSON.stringify(value)));
+	}
+
+	function retrieveFromCache(key: string): any | never {
+		let value = window.localStorage.getItem(key);
+		if (!_(value)) return JSON.parse(unescape(value as string));
+		else throw new Error();
+	}
+	//#endregion
+
+	/**
+	 * Tries to load the data automatically from the websocket,
+	 * then from cache, then from the user. Always caches the
+	 * response.
+	 */
+	export async function GetData(): Promise<any> {
+		return new Promise<any>(async (resolve, reject) => {
+			var data: any;
+			try {
+				let serverIp = await retrieveDataIp(!MOBILE);
+				data = await loadData(serverIp);
+				webSocketIp = serverIp;
+			} catch {
+				try {
+					data = retrieveFromCache("data");
+				} catch {
+					data = await manualLoadData();
+				}
+			} finally {
+				storeInCache("data", data);
+				return resolve(data);
+			}
+		});
+	}
+
+	var webSocketIp: string | null = null;
+
+	export async function GetMountedAssetIp(Id: number): Promise<string> {
+		return new Promise<string>(async (resolve, reject) => {
+			if (_(webSocketIp)) return reject();
+			try {
+				let ip: string = JSON.parse(
+					await new Helpers.WebSocketRequest(
+						webSocketIp as string,
+						JSON.stringify({
+							type: "getAssetState",
+							uuid: Helpers.GenUuid(),
+							data: {
+								assetId: Id
+							}
+						})
+					).GetResponseAsync()
+				).data.ipAddr;
+				if (!_(ip)) return resolve(`http://${ip}/`);
+				else return reject();
+			} catch {
+				return reject();
+			}
+		});
+	}
+}