diff --git a/.defaults.sh b/.defaults.sh
index 35e1abc1..be43dbc2 100755
--- a/.defaults.sh
+++ b/.defaults.sh
@@ -1,20 +1,21 @@
 # Default values for gen_cmake and gen_install
 
-default_qt_version="5.15.2"
-default_win_basePath="C:/Qt"
-default_win_arch="msvc2019"
-default_mac_basePath="/Applications/Qt"
-default_mac_arch="clang_64"
-default_linux_basePath="/usr/lib"
-default_linux_arch="$(g++ -dumpmachine)"
+# Qt defaults
+default_qt_version="6.5.2"
+default_qt_win_basePath="C:/Qt"
+default_qt_win_arch="msvc2019"
+default_qt_mac_basePath="/Applications/Qt"
+default_qt_mac_arch="clang_64"
+default_qt_linux_basePath="/usr/lib"
+default_qt_linux_arch="$(g++ -dumpmachine)"
 
 # gen_cmake defaults
 function extend_gc_fnc_defaults()
 {
-  default_VisualGenerator="Visual Studio 17 2022"
-  default_VisualToolset="v143"
-  default_VisualToolchain="x64"
-  default_VisualArch="x86"
+	default_VisualGenerator="Visual Studio 17 2022"
+	default_VisualToolset="v143"
+	default_VisualToolchain="x64"
+	default_VisualArch="x64"
   default_keyDigits=2
   default_betaTagName="-beta"
 }
@@ -25,7 +26,7 @@ function extend_gi_fnc_defaults()
   default_VisualGenerator="Visual Studio 17 2022"
   default_VisualToolset="v143"
   default_VisualToolchain="x64"
-  default_VisualArch="x86"
+  default_VisualArch="x64"
   default_keyDigits=2
   default_betaTagName="-beta"
 }
@@ -62,11 +63,11 @@ function get_default_qt_path()
 	local gdqp_result="" # Use a unique name for the result as we pass it by reference
 
 	if isWindows; then
-		build_qt_config_folder gdqp_result "${default_win_basePath}/${default_qt_version}" "${default_win_arch}" "${QtMajorVersion}"
+		build_qt_config_folder gdqp_result "${default_qt_win_basePath}/${default_qt_version}" "${default_qt_win_arch}" "${QtMajorVersion}"
 	elif isMac; then
-		build_qt_config_folder gdqp_result "${default_mac_basePath}/${default_qt_version}" "${default_mac_arch}" "${QtMajorVersion}"
+		build_qt_config_folder gdqp_result "${default_qt_mac_basePath}/${default_qt_version}" "${default_qt_mac_arch}" "${QtMajorVersion}"
 	elif isLinux; then
-		build_qt_config_folder gdqp_result "${default_linux_basePath}" "${default_linux_arch}" "${QtMajorVersion}"
+		build_qt_config_folder gdqp_result "${default_qt_linux_basePath}" "${default_qt_linux_arch}" "${QtMajorVersion}"
 	fi
 
 	_retval="${gdqp_result}"
diff --git a/3rdparty/avdecc b/3rdparty/avdecc
index c31027a4..1d68f48e 160000
--- a/3rdparty/avdecc
+++ b/3rdparty/avdecc
@@ -1 +1 @@
-Subproject commit c31027a4b8fabe06ce1789d7c4e36e12accef5dc
+Subproject commit 1d68f48e5aed9e4f0c85095fd0de645160bc7561
diff --git a/3rdparty/sparkleHelper b/3rdparty/sparkleHelper
index 2d36a28f..004b0040 160000
--- a/3rdparty/sparkleHelper
+++ b/3rdparty/sparkleHelper
@@ -1 +1 @@
-Subproject commit 2d36a28f4dd3f774ac7d716003650ee149d3c46f
+Subproject commit 004b00408319ad887ea190d261dac1e4a2a56de7
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7825599e..c6cd3103 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,46 @@ All notable changes to Hive will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2023-09-26
+### Added
+- Selection of an entity from the connection matrix (context menu)
+- [Mac Address field in entities list](https://github.com/christophe-calmejane/Hive/issues/38)
+- [ClockDomain locked state in entities list](https://github.com/christophe-calmejane/Hive/issues/133)
+- Support for JACK Inputs and JACK Outputs
+- Support for CONTROLs at non-configuration level
+- Support for CONTROL_SELECTOR type for CONTROL descriptors
+- Preliminary support for Virtual Entities modification
+- [File association to directly load ANS and AVE files](https://github.com/christophe-calmejane/Hive/issues/146)
+- New command line parameters to load ANS and AVE files
+- New icons for ANS and AVE files
+- Possibility to remove a virtual entity (DEL key in Entities list)
+- Entity Descriptor displays the current status for unsolicited notifications registration
+- [Entry in the entities list context menu to force reload a single entity](https://github.com/christophe-calmejane/Hive/issues/145)
+- [New column in entities list showing error/warning status](https://github.com/christophe-calmejane/Hive/issues/155)
+- New diagnostics for CONTROL descriptors, when the current value is out of min-max bounds
+- [Support for Dark Mode](https://github.com/christophe-calmejane/Hive/issues/39)
+- Clicking on an Entity-Entity crosspoint in the matrix expands/collapses both entities
+- Display of Entity AEM Checksum (in Entity Descriptor)
+- Detection of invalid *descriptor_counts* field in CONFIGURATION descriptor
+
+### Changed
+- Complete rework of the `entities list`
+- Updated AVDECC library to v4.0
+- Defaulting to Qt "fusion" style, can be changed with command line parameter `-style <style name>`
+
+### Fixed
+- Current selection in list of entities lost when changing the filter
+- [Network Interfaces combobox displays errors and selected interface in bold](https://github.com/christophe-calmejane/Hive/issues/128)
+- Refresh issue for ClockSource, MemoryObject, AvbInterface, AudioCluster, Control, ClockDomain, AssociationID custom names
+- Possible crash for entities with more than 1 configuration, when using full device enumration
+- Always display CONTROL descriptor even if the ControlDataType is not supported by the library
+- CONTROL values updated by the device itself didn't update properly
+- Possible crash for entities returning an out-of-bounds MemoryObject length value
+- [Files can be loaded/saved from/to UTF8 path](https://github.com/christophe-calmejane/Hive/issues/156)
+- Crash when displaying vendor specific control values
+- Opening the Dynamic Mappings editor from the matrix only showed the first STREAM_PORT, it now shows all STREAM_PORTs
+- `Clear All Dynamic Mappings` correctly clears redundant mappings for virtual entities
+
 ## [1.2.9] - 2023-01-13
 ### Added
 - Option to hide (meaningless) connections between CRF and Audio streams
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 71204c88..83205f4c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,8 +10,8 @@ cmake_minimum_required(VERSION 3.22)
 # It should have 3 digits (x.y.z) on main branch, and 4 digits (x.y.z.w) on dev and task branches. The last digit being used as beta label.
 # As soon as a new version begins, update the version number by following SemVer rules.
 # Example: 1.5.0 is the upcoming release version (main branch) of current 1.5.0.3 devel version (dev/task) which will be labelled 1.5.0-beta3
-set(HIVE_VERSION 1.2.9)
-set(AEMDUMPER_VERSION 1.1.0)
+set(HIVE_VERSION 1.3.0)
+set(AEMDUMPER_VERSION 1.3.0)
 
 ############ Override from command line "CMake -D<OPTION>=TRUE/FALSE/0/1/ON/OFF"
 
@@ -159,7 +159,7 @@ find_package(Qt${QT_MAJOR_VERSION} COMPONENTS Widgets;Network REQUIRED)
 cu_setup_project_version_variables(${HIVE_VERSION})
 
 # Set minimum OSX/iOS version
-cu_setup_apple_minimum_versions(MACOS 10.13 IOS 11)
+cu_setup_apple_minimum_versions(MACOS 11 IOS 14)
 
 ############ Define some variables
 
diff --git a/Docker/.env b/Docker/.env
index 0a798f5b..1547c999 100644
--- a/Docker/.env
+++ b/Docker/.env
@@ -2,6 +2,7 @@
 # They can be overridden by setting them in the environment of the system (or on the same command line when invoking docker-compose)
 # Use 'docker-compose config' to print the current configuration
 
-TAG=ubuntu_21.10
+TAG=ubuntu_22.04
+QT_VERSION=6.5.2
 BUILD_FOLDER=Hive
 APP=Hive
diff --git a/Docker/docker-compose.yml b/Docker/docker-compose.yml
index a608e55d..7eae6ef3 100644
--- a/Docker/docker-compose.yml
+++ b/Docker/docker-compose.yml
@@ -7,14 +7,16 @@ volumes:
 services:
   # Base builder image
   builder:
-    image: builder:${TAG}
+    image: builder:${TAG}_Qt${QT_VERSION}
     build:
       context: .
       dockerfile: dockerHelper/builders/${TAG}/Dockerfile
+      args:
+        - QT_VERSION=${QT_VERSION}
 
   # CMake configure service
   gen_cmake:
-    image: builder:${TAG}
+    image: builder:${TAG}_Qt${QT_VERSION}
     volumes:
       - ../:/home/builder/sources:ro
       - builds:/home/builder/builds
@@ -22,7 +24,7 @@ services:
 
   # Build service
   build:
-    image: builder:${TAG}
+    image: builder:${TAG}_Qt${QT_VERSION}
     volumes:
       - ../:/home/builder/sources:ro
       - builds:/home/builder/builds
@@ -30,7 +32,7 @@ services:
 
   # Shell service
   shell:
-    image: builder:${TAG}
+    image: builder:${TAG}_Qt${QT_VERSION}
     volumes:
       - ../:/home/builder/sources:ro
       - builds:/home/builder/builds
@@ -38,7 +40,7 @@ services:
 
   # Run service
   run:
-    image: builder:${TAG}
+    image: builder:${TAG}_Qt${QT_VERSION}
     volumes:
       - builds:/home/builder/builds
     entrypoint: ./${APP}
diff --git a/Docker/dockerHelper b/Docker/dockerHelper
index b71fb16b..ed8ff883 160000
--- a/Docker/dockerHelper
+++ b/Docker/dockerHelper
@@ -1 +1 @@
-Subproject commit b71fb16b3fa5dea06193271785fab09f524e2f12
+Subproject commit ed8ff883cd5a8d9a9b6c0c372bbd3fda0ada60d4
diff --git a/README.md b/README.md
index 07352170..3cc001ec 100644
--- a/README.md
+++ b/README.md
@@ -13,8 +13,8 @@ Precompiled binaries for macOS and Windows [can be found here](https://github.co
 ## Minimum requirements for compilation
 
 - CMake 3.22
-- Qt 5.15.2
-- Visual Studio 2019 16.3 (using platform toolset v142), Xcode 12, g++ 11.2.0
+- Qt 6.5.2 (although Qt 5.15.2 was supported in the past, it's no longer guaranteed to compile correctly)
+- Visual Studio 2022 17.4 (using platform toolset v143), Xcode 14, g++ 11.0
 - [Optional, for cross-compilation] Docker / Docker Compose
 
 ## Compilation
@@ -35,7 +35,7 @@ Precompiled binaries for macOS and Windows [can be found here](https://github.co
 - Requires `docker` and `docker-compose` to be installed
 - Go to the `Docker` folder
 - Build the docker builder image: _docker-compose build_
-- Generate the build solution: _docker-compose run --rm gen_cmake -debug -c Ninja -- -DBUILD_HIVE_TESTS=FALSE_
+- Generate the build solution: _docker-compose run --rm gen_cmake -debug -c Ninja -qtvers 6.5.2 -qtdir /usr/local/Qt-6.5.2/lib/cmake -- -DBUILD_HIVE_TESTS=FALSE_
  - You may change parameters to your convenience
 - Build the solution: _docker-compose run --rm build --target install_
 - If you want to run the application, you must authorize X connections to your display: _xhost local:root_
diff --git a/TODO.md b/TODO.md
index d55ed454..97e9c91f 100644
--- a/TODO.md
+++ b/TODO.md
@@ -1,6 +1,5 @@
 # TODO
 ## Global
-- Enable (via option?) Hive advertising (la_avdecc_controller has to support ADP name/group configuration, and probably partial AEM support)
 - Support multiple eth interfaces at the same time to support redundancy (Hive being connected to multiple interfaces at the same time and aggregating information on both interfaces)
   - Have to properly split dynamic/static model in Hive (not only relying on la_avdecc_controller)
   - For each descriptor that have dynamic information, find a way to display them separately in Hive
@@ -10,33 +9,16 @@
 ## Menu
 - Menu: "File/Save log..."
 
-## Entities list
-- Icons displaying the type of entity (controller, listener, talker, 3 icons max then)
-- Possiblity to copy (right click context menu?) some elements, like the entityID in the list -> already done by Qt, just have to selection row/column and ctrl-c (TODO: Explain that in some tutorial)
-
-## AEM Inspector
-- Add Strings descriptor as sub node of Locale
-- Right click menu:
-  - Export node as aemxml or another format (because aemxml is only for the static part of the AEM)
-
 ## Descriptor Inspector
 - Improve the "Connection list" for a StreamOutput
-  - Add an icon indicating the FastConnecting status
   - Move the right click menu "Clear all ghost connections" from item to the list itself, and implement it
-- Right click menu:
-  - Copy values (like all EID for ex)
 
 ## Connection Matrix
-- Right click on a connection (active or not) for which the stream format do not match:
-  - "Set listener format from talker" -> Enable this item if, for the current Talker Format, there is a compatible format available on the Listener
-  - "Set talker format from listener" -> Enable this item if, for the current Listener Format, there is a compatible format available on the Talker
 - Better display error information:
-  - When there is a connection error, we should display it wich possibly a red icon (like WrongDomain, but with a tooltip??). Including when there is a fastConnect error (talker acquired for ex.), but in this case the avdecc library should not filter errors in sniffed messages
   - When there is a "mismatch connection" error (listener thinks it's connected but is not in the connections list of the talker), maybe add a new color code?
   - Display when there is a SRP error as well
   - Maybe just use only one new color code (purple) or a new form (triangle?) for when the avdecc connection is established, but there is an error (for all cases above) that we display with a tooltip
 - Separate the connection matrix in 2 matrices, one for normal streams and one for CRF?
-- Implement colors for entities (the squares)
 - Add feature "Start all Streams" and "Stop all Streams" when right clicking on the header of a entity
 
 ## Log window
@@ -49,13 +31,6 @@
 - GroupName issue if it's set to "语语语语语语语语语语语语语语语语语语语语语|" (a value is being added at the end of the string)
 - If a Talker Stream is in Waiting status and we connect a new listener, it automatically goes into NonWaiting status because we are always sending the connection request without taking Wait flag into account
 - ProtocolInterface loaded multiple times during launch (pcap at least)
-- When there are many huge devices on the network (Tesira+Hono for ex.) and we reset the controller (reload interface), huge graphics lag (everything arrive at the same time and the mainThread is blocked). Looks like the same issue we previously had with the logger
-- Acquire Tesira and quickly select another entity that has no name for Stream in/out, cause a change in the name displayed in the inspector (no filter on onNameChanged??)
-- macOS only: ChannelMappings dialog not resizable (https://bugreports.qt.io/browse/QTBUG-41932)
-- Non redundant Talker connected to the primary stream of a redundant Listener (using riedel) causes Hive to not be able to do anything about this stream because it's "not connectable" (single stream cannot be connected to a stream of a redundant pair). Kill ghost connection do not work, neither in the matrix
-
-# Improvements
-- Display a reload controller icon in the toolbar
 
 # TO BE SORTED
 - Afficher la liste des streams formats tels qu'ils sont retournés par l'entité, et optimiser la liste dans la combobox pour aggréger les up-to avec les autres (si on a up-to 8, ne pas afficher 1, 2, 4, 6...)
diff --git a/gen_cmake.sh b/gen_cmake.sh
index ad294e34..a25b8d54 100755
--- a/gen_cmake.sh
+++ b/gen_cmake.sh
@@ -127,18 +127,18 @@ function extend_gc_fnc_precmake()
 	# Using automatic Qt detection
 	if [ $overrideQtDir -eq 0 ]; then
 		if isWindows; then
-			qtBasePath="${default_win_basePath}/${QtVersion}"
+			qtBasePath="${default_qt_win_basePath}/${QtVersion}"
 			if [ "$arch" == "x64" ]; then
-				qtArch="${default_win_arch}_64"
+				qtArch="${default_qt_win_arch}_64"
 			else
-				qtArch="${default_win_arch}"
+				qtArch="${default_qt_win_arch}"
 			fi
 		elif isMac; then
-			qtBasePath="${default_mac_basePath}/${QtVersion}"
+			qtBasePath="${default_qt_mac_basePath}/${QtVersion}"
 			if [ "${QtMajorVersion}" == "6" ] ; then
 				qtArch="macos"
 			else
-				qtArch="${default_mac_arch}"
+				qtArch="${default_qt_mac_arch}"
 			fi
 		elif isLinux; then
 			if [ "x${QT_BASE_PATH}" != "x" ]; then
@@ -149,12 +149,12 @@ function extend_gc_fnc_precmake()
 				fi
 
 				qtBasePath="${QT_BASE_PATH}/${QtVersion}"
-				qtArch="" # Maybe use default_linux_arch as well? (if yes, factorize qtArch for both QT_BASE_PATH and system wide)
+				qtArch="" # Maybe use default_qt_linux_arch as well? (if yes, factorize qtArch for both QT_BASE_PATH and system wide)
 			else
 				echo "Using system wide Qt headers and libraries."
 				echo "QT_BASE_PATH env variable can be defined to the root folder of Qt installation (where MaintenanceTool resides), or the -qtdir option. See help (-h) for more details."
-				qtBasePath="${default_linux_basePath}"
-				qtArch="${default_linux_arch}"
+				qtBasePath="${default_qt_linux_basePath}"
+				qtArch="${default_qt_linux_arch}"
 			fi
 		else
 			echo "Unsupported platform"
diff --git a/include/QtMate/flow/flowConnection.hpp b/include/QtMate/flow/flowConnection.hpp
new file mode 100644
index 00000000..d17a8ada
--- /dev/null
+++ b/include/QtMate/flow/flowConnection.hpp
@@ -0,0 +1,50 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QtMate/flow/flowLink.hpp>
+#include <QtMate/flow/flowDefs.hpp>
+
+namespace qtMate::flow
+{
+class FlowConnection : public FlowLink
+{
+public:
+	FlowConnection(QGraphicsItem* parent = nullptr);
+	virtual ~FlowConnection() override;
+
+	FlowConnectionDescriptor descriptor() const;
+
+	void setOutput(FlowOutput* output);
+	FlowOutput* output() const;
+
+	void setInput(FlowInput* input);
+	FlowInput* input() const;
+
+	void updatePath();
+
+private:
+	friend class FlowNode;
+
+	FlowOutput* _output{};
+	FlowInput* _input{};
+};
+
+} // namespace qtMate::flow
diff --git a/include/QtMate/flow/flowDefs.hpp b/include/QtMate/flow/flowDefs.hpp
new file mode 100644
index 00000000..336a208a
--- /dev/null
+++ b/include/QtMate/flow/flowDefs.hpp
@@ -0,0 +1,82 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QPair>
+#include <QString>
+#include <QVector>
+#include <QHash>
+#include <QSet>
+
+namespace qtMate::flow
+{
+using FlowNodeUid = quint64;
+using FlowSocketIndex = quint32;
+using FlowSocketType = quint32;
+using FlowSocketSlot = QPair<FlowNodeUid, FlowSocketIndex>;
+using FlowSocketSlots = QSet<FlowSocketSlot>;
+
+// source (output), sink (input)
+using FlowConnectionDescriptor = QPair<FlowSocketSlot, FlowSocketSlot>;
+using FlowConnectionDescriptors = QSet<FlowConnectionDescriptor>;
+
+inline auto constexpr InvalidFlowNodeUid = static_cast<FlowNodeUid>(-1);
+inline auto constexpr InvalidFlowSocketIndex = static_cast<FlowSocketIndex>(-1);
+inline auto constexpr InvalidFlowSocketSlot = FlowSocketSlot{ InvalidFlowNodeUid, InvalidFlowSocketIndex };
+inline auto constexpr InvalidFlowConnectionDescriptor = FlowConnectionDescriptor{ InvalidFlowSocketSlot, InvalidFlowSocketSlot };
+
+struct FlowSocketDescriptor
+{
+	QString name{};
+	FlowSocketType type{};
+};
+
+using FlowSocketDescriptors = QVector<FlowSocketDescriptor>;
+
+struct FlowNodeDescriptor
+{
+	QString name{};
+	FlowSocketDescriptors inputs{};
+	FlowSocketDescriptors outputs{};
+};
+
+using FlowNodeDescriptorMap = QHash<FlowNodeUid, FlowNodeDescriptor>;
+
+class FlowNode;
+
+class FlowSocket;
+class FlowInput;
+class FlowOutput;
+
+using FlowInputs = QVector<FlowInput*>;
+using FlowOutputs = QVector<FlowOutput*>;
+
+class FlowLink;
+using FlowLinks = QSet<FlowLink*>;
+
+class FlowConnection;
+using FlowConnections = QSet<FlowConnection*>;
+
+class FlowScene;
+class FlowSceneDelegate;
+
+class FlowView;
+
+} // namespace qtMate::flow
diff --git a/include/QtMate/graph/outputSocket.hpp b/include/QtMate/flow/flowInput.hpp
similarity index 60%
rename from include/QtMate/graph/outputSocket.hpp
rename to include/QtMate/flow/flowInput.hpp
index 3f284f0f..aa3c301e 100644
--- a/include/QtMate/graph/outputSocket.hpp
+++ b/include/QtMate/flow/flowInput.hpp
@@ -19,36 +19,36 @@
 
 #pragma once
 
-#include "socket.hpp"
-#include "connection.hpp"
+#include <QtMate/flow/flowSocket.hpp>
 
-namespace qtMate
+namespace qtMate::flow
 {
-namespace graph
-{
-class OutputSocketItem final : public SocketItem
+class FlowInput : public FlowSocket
 {
 public:
-	using SocketItem::SocketItem;
+	using FlowSocket::FlowSocket;
 
-	virtual ~OutputSocketItem();
+	virtual ~FlowInput() override;
 
+	enum
+	{
+		Type = UserType + 2
+	};
 	virtual int type() const override;
-
-	virtual void updateGeometry() override;
+	virtual QRectF boundingRect() const override;
 
 	virtual bool isConnected() const override;
+	virtual QRectF hotSpotBoundingRect() const override;
 
-	void addConnection(ConnectionItem* connection);
-	void removeConnection(ConnectionItem* connection);
+	FlowConnection* connection() const;
+	void setConnection(FlowConnection* connection);
 
-	void clearConnections();
+	void updateConnection();
 
-	ConnectionItems const& connections() const;
+	virtual void paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget = nullptr) override;
 
 private:
-	ConnectionItems _connections{};
+	FlowConnection* _connection{};
 };
 
-} // namespace graph
-} // namespace qtMate
+} // namespace qtMate::flow
diff --git a/include/QtMate/graph/inputSocket.hpp b/include/QtMate/flow/flowLink.hpp
similarity index 62%
rename from include/QtMate/graph/inputSocket.hpp
rename to include/QtMate/flow/flowLink.hpp
index ef8424e4..7bbeec39 100644
--- a/include/QtMate/graph/inputSocket.hpp
+++ b/include/QtMate/flow/flowLink.hpp
@@ -19,34 +19,25 @@
 
 #pragma once
 
-#include "socket.hpp"
+#include <QGraphicsPathItem>
 
-namespace qtMate
+namespace qtMate::flow
 {
-namespace graph
-{
-class ConnectionItem;
-class InputSocketItem final : public SocketItem
+class FlowLink : public QGraphicsPathItem
 {
 public:
-	using SocketItem::SocketItem;
-
-	virtual ~InputSocketItem();
-
-	virtual int type() const override;
+	FlowLink(QGraphicsItem* parent = nullptr);
+	virtual ~FlowLink() override;
 
-	virtual void updateGeometry() override;
+	void setStart(QPointF const& start);
+	void setStop(QPointF const& stop);
 
-	virtual bool isConnected() const override;
-
-	//
-
-	void setConnection(ConnectionItem* connection);
-	ConnectionItem* connection() const;
+private:
+	void updatePainterPath();
 
 private:
-	ConnectionItem* _connection{ nullptr };
+	QPointF _start{};
+	QPointF _stop{};
 };
 
-} // namespace graph
-} // namespace qtMate
+} // namespace qtMate::flow
diff --git a/include/QtMate/flow/flowNode.hpp b/include/QtMate/flow/flowNode.hpp
new file mode 100644
index 00000000..32b6a5d1
--- /dev/null
+++ b/include/QtMate/flow/flowNode.hpp
@@ -0,0 +1,94 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QGraphicsItem>
+#include <QVariantAnimation>
+#include <QtMate/flow/flowDefs.hpp>
+
+namespace qtMate::flow
+{
+class FlowNodeHeader;
+
+class FlowNode : public QObject, public QGraphicsItem
+{
+	Q_OBJECT
+	Q_PROPERTY(bool collapsed READ isCollapsed NOTIFY collapsedChanged);
+	Q_INTERFACES(QGraphicsItem)
+
+public:
+	FlowNode(FlowSceneDelegate* delegate, FlowNodeUid const& uid, FlowNodeDescriptor const& descriptor, QGraphicsItem* parent = nullptr);
+	virtual ~FlowNode() override;
+
+	FlowNodeUid const& uid() const;
+	QString const& name() const;
+	FlowInputs const& inputs() const;
+	FlowOutputs const& outputs() const;
+
+	bool isCollapsed() const;
+
+	FlowInput* input(FlowSocketIndex index) const;
+	FlowOutput* output(FlowSocketIndex index) const;
+
+	bool hasConnectedInput() const;
+	bool hasConnectedOutput() const;
+
+	enum
+	{
+		Type = UserType + 1
+	};
+	virtual int type() const override;
+
+	virtual QRectF boundingRect() const override;
+
+	QRectF animatedBoundingRect() const;
+	QRectF fixedBoundingRect() const;
+
+	virtual void paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget = nullptr) override;
+
+signals:
+	void collapsedChanged();
+
+protected:
+	virtual QVariant itemChange(GraphicsItemChange change, QVariant const& value) override;
+	virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event) override;
+
+private:
+	void toggleCollapsed();
+	void setCollapsed(bool collapsed);
+	void handleItemPositionHasChanged();
+	void handleItemSelectionHasChanged();
+	void updateSockets();
+
+	float collapseRatio(bool animated) const;
+
+private:
+	FlowSceneDelegate* _delegate{};
+	FlowNodeUid _uid{};
+	QString _name{};
+	FlowNodeHeader* _header{};
+	FlowInputs _inputs{};
+	FlowOutputs _outputs{};
+	bool _collapsed{};
+	float _collapseRatio{ 1.f };
+	QVariantAnimation _collapseAnimation{};
+};
+
+} // namespace qtMate::flow
diff --git a/include/QtMate/graph/socket.hpp b/include/QtMate/flow/flowOutput.hpp
similarity index 59%
rename from include/QtMate/graph/socket.hpp
rename to include/QtMate/flow/flowOutput.hpp
index d9afdac9..e0d2937a 100644
--- a/include/QtMate/graph/socket.hpp
+++ b/include/QtMate/flow/flowOutput.hpp
@@ -19,41 +19,37 @@
 
 #pragma once
 
-#include <QGraphicsItem>
+#include <QtMate/flow/flowSocket.hpp>
 
-namespace qtMate
+namespace qtMate::flow
 {
-namespace graph
-{
-class SocketItem : public QGraphicsItem
+class FlowOutput : public FlowSocket
 {
 public:
-	SocketItem(int nodeId, int index, QString const& text, QGraphicsItem* parent = nullptr);
-
-	// Associated node
-	int nodeId() const;
-	// Socket index in this node
-	int index() const;
+	using FlowSocket::FlowSocket;
 
-	QString const& text() const;
-	QSizeF size() const;
+	virtual ~FlowOutput() override;
 
-	virtual bool isConnected() const = 0;
+	enum
+	{
+		Type = UserType + 3
+	};
+	virtual int type() const override;
 	virtual QRectF boundingRect() const override;
 
-	bool isOver(QPointF const& pos) const;
+	virtual bool isConnected() const override;
+	virtual QRectF hotSpotBoundingRect() const override;
 
-protected:
-	virtual void paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget) override;
-	virtual void updateGeometry() = 0;
+	void addConnection(FlowConnection* connection);
+	void removeConnection(FlowConnection* connection);
+	FlowConnections const& connections() const;
 
-private:
-	int _nodeId{ -1 };
-	int _index{ -1 };
+	void updateConnections();
 
-	QString _text{};
-	QSize _size{};
+	virtual void paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget = nullptr) override;
+
+private:
+	FlowConnections _connections{};
 };
 
-} // namespace graph
-} // namespace qtMate
+} // namespace qtMate::flow
diff --git a/include/QtMate/flow/flowScene.hpp b/include/QtMate/flow/flowScene.hpp
new file mode 100644
index 00000000..5bad7ecb
--- /dev/null
+++ b/include/QtMate/flow/flowScene.hpp
@@ -0,0 +1,73 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QGraphicsScene>
+#include <QtMate/flow/flowDefs.hpp>
+
+namespace qtMate::flow
+{
+class FlowScene : public QGraphicsScene
+{
+	Q_OBJECT
+public:
+	FlowScene(FlowSceneDelegate* delegate, QObject* parent = nullptr);
+	virtual ~FlowScene() override;
+
+	FlowNode* createNode(FlowNodeUid const& uid, FlowNodeDescriptor const& descriptor);
+	void destroyNode(FlowNodeUid const& uid);
+
+	FlowConnection* createConnection(FlowConnectionDescriptor const& descriptor);
+	void destroyConnection(FlowConnectionDescriptor const& descriptor);
+
+	QVector<FlowNode*> nodes() const;
+	QVector<FlowConnection*> connections() const;
+
+	FlowNode* node(FlowNodeUid const& uid) const;
+
+	FlowInput* input(FlowSocketSlot const& slot) const;
+	FlowOutput* output(FlowSocketSlot const& slot) const;
+
+	FlowConnection* connection(FlowConnectionDescriptor const& descriptor) const;
+
+	// do some sanity checks before returning the value of FlowSceneDelegate::canConnect
+	bool canConnect(FlowOutput* output, FlowInput* input) const;
+	bool canConnect(FlowConnectionDescriptor const& descriptor) const;
+
+	// shortcut to FlowSceneDelegate::socketTypeColor
+	QColor socketTypeColor(FlowSocketType type) const;
+
+	std::pair<FlowOutput*, FlowInput*> sockets(FlowConnectionDescriptor const& descriptor) const;
+
+signals:
+	void nodeCreated(FlowNodeUid const& uid);
+	void nodeDestroyed(FlowNodeUid const& uid);
+	void connectionCreated(FlowConnectionDescriptor const& descriptor);
+	void connectionDestroyed(FlowConnectionDescriptor const& descriptor);
+	void layoutRequested();
+
+private:
+	FlowSceneDelegate* _delegate{};
+
+	QHash<FlowNodeUid, FlowNode*> _nodes{};
+	QHash<FlowConnectionDescriptor, FlowConnection*> _connections{};
+};
+
+} // namespace qtMate::flow
diff --git a/include/QtMate/graph/type.hpp b/include/QtMate/flow/flowSceneDelegate.hpp
similarity index 68%
rename from include/QtMate/graph/type.hpp
rename to include/QtMate/flow/flowSceneDelegate.hpp
index 1831a5b1..f845c8af 100644
--- a/include/QtMate/graph/type.hpp
+++ b/include/QtMate/flow/flowSceneDelegate.hpp
@@ -19,24 +19,18 @@
 
 #pragma once
 
-#include <QGraphicsItem>
+#include <QObject>
+#include <QtMate/flow/flowDefs.hpp>
 
-namespace qtMate
+namespace qtMate::flow
 {
-namespace graph
+class FlowSceneDelegate : public QObject
 {
-enum ItemType
-{
-	Node = QGraphicsItem::UserType + 1,
-	Input,
-	Output,
-	Connection,
-};
+public:
+	using QObject::QObject;
 
-const QColor TextColor{ "#FFFFFF" };
-const QColor NodeItemColor{ "#3C3C3C" };
-const QColor InputSocketColor{ "#2196F3" };
-const QColor OutputSocketColor{ "#4CAF50" };
+	virtual QColor socketTypeColor(FlowSocketType type) const;
+	virtual bool canConnect(FlowOutput* output, FlowInput* input) const;
+};
 
-} // namespace graph
-} // namespace qtMate
+} // namespace qtMate::flow
diff --git a/include/QtMate/flow/flowSocket.hpp b/include/QtMate/flow/flowSocket.hpp
new file mode 100644
index 00000000..28eb5945
--- /dev/null
+++ b/include/QtMate/flow/flowSocket.hpp
@@ -0,0 +1,56 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QGraphicsItem>
+#include <QtMate/flow/flowDefs.hpp>
+
+namespace qtMate::flow
+{
+class FlowSocket : public QGraphicsItem
+{
+public:
+	FlowSocket(FlowNode* node, FlowSocketIndex index, FlowSocketDescriptor const& descriptor);
+	virtual ~FlowSocket() override;
+
+	FlowNode* node() const;
+	FlowSocketIndex index() const;
+	FlowSocketDescriptor const& descriptor() const;
+	FlowSocketSlot slot() const;
+
+	QColor const& color() const;
+	void setColor(QColor const& color);
+
+	bool hit(QPointF const& scenePos) const;
+
+	QPointF hotSpotSceneCenter() const;
+
+	virtual bool isConnected() const = 0;
+	virtual QRectF hotSpotBoundingRect() const = 0;
+
+protected:
+	FlowNode* _node{};
+	FlowSocketIndex _index{};
+	FlowSocketDescriptor _descriptor{};
+
+	QColor _color{ Qt::darkGray };
+};
+
+} // namespace qtMate::flow
diff --git a/include/QtMate/flow/flowStyle.hpp b/include/QtMate/flow/flowStyle.hpp
new file mode 100644
index 00000000..8b747a6c
--- /dev/null
+++ b/include/QtMate/flow/flowStyle.hpp
@@ -0,0 +1,71 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QPainter>
+#include <QtMate/flow/flowDefs.hpp>
+
+namespace qtMate::flow
+{
+//
+inline const auto NODE_BACKGROUND_COLOR = QColor{ 0x222222 };
+inline const auto NODE_TEXT_COLOR = QColor{ 0xf4f4f4 };
+inline const auto NODE_HEADER_COLOR = QColor{ 0x272927 };
+inline const auto NODE_SELECTED_HEADER_COLOR = QColor{ 0x334f3a };
+inline const auto NODE_SOCKET_AREA_COLOR = QColor{ 0x484848 };
+inline const auto NODE_INPUT_DEFAULT_COLOR = QColor{ 0x1f80ff };
+inline const auto NODE_OUTPUT_DEFAULT_COLOR = QColor{ 0x80ff01 };
+
+//
+constexpr auto NODE_BORDER_RADIUS = 8.f;
+constexpr auto NODE_HEADER_HEIGHT = 32.f;
+constexpr auto NODE_HEADER_SEPARATOR_HEIGHT = 2.f;
+constexpr auto NODE_SOCKET_AREA_INSET_TOP = 2.f;
+constexpr auto NODE_SOCKET_AREA_INSET_BOTTOM = 2.f;
+constexpr auto NODE_LINE_HEIGHT = 32.f;
+constexpr auto NODE_SEPARATOR_THICKNESS = 2.f;
+constexpr auto NODE_WIDTH = 380.f;
+
+//
+constexpr auto NODE_PADDING = 4.f;
+
+//
+constexpr auto NODE_SOCKET_RADIUS = 8.f;
+constexpr auto NODE_SOCKET_PADDING = 4.f;
+constexpr auto NODE_SOCKET_BOUNDING_SIZE = (NODE_SOCKET_RADIUS + NODE_SOCKET_PADDING) * 2;
+
+//
+inline const auto NODE_CONNECTION_PEN = QPen{ QColor{ 0xb0bec5 }, 2.f, Qt::PenStyle::DotLine };
+
+//
+constexpr auto TopLeft = Qt::Edge::TopEdge | Qt::Edge::LeftEdge;
+constexpr auto TopRight = Qt::Edge::TopEdge | Qt::Edge::RightEdge;
+constexpr auto BottomRight = Qt::Edge::BottomEdge | Qt::Edge::RightEdge;
+constexpr auto BottomLeft = Qt::Edge::BottomEdge | Qt::Edge::LeftEdge;
+
+void drawRoundedRect(QPainter* painter, float x, float y, float width, float height, Qt::Edges const edges, float radius);
+void drawRoundedRect(QPainter* painter, QRectF const& r, Qt::Edges const edges, float radius);
+
+void drawElidedText(QPainter* painter, QRectF const& r, int flags, Qt::TextElideMode mode, QString const& text);
+
+void drawOutputHotSpot(QPainter* painter, QPointF const& hotSpot, QColor const& color, bool connected);
+void drawInputHotSpot(QPainter* painter, QPointF const& hotSpot, QColor const& color, bool connected);
+
+} // namespace qtMate::flow
diff --git a/include/QtMate/flow/flowView.hpp b/include/QtMate/flow/flowView.hpp
new file mode 100644
index 00000000..06e448d9
--- /dev/null
+++ b/include/QtMate/flow/flowView.hpp
@@ -0,0 +1,92 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QGraphicsView>
+#include <QElapsedTimer>
+#include <QVariantAnimation>
+#include <QtMate/flow/flowDefs.hpp>
+
+namespace qtMate::flow
+{
+class FlowView : public QGraphicsView
+{
+	using QGraphicsView::setScene;
+
+public:
+	FlowView(FlowScene* scene, QWidget* parent = nullptr);
+	virtual ~FlowView() override;
+
+	void animatedCenterOn(QPointF const& scenePos);
+
+protected:
+	virtual void mousePressEvent(QMouseEvent* event) override;
+	virtual void mouseMoveEvent(QMouseEvent* event) override;
+	virtual void mouseReleaseEvent(QMouseEvent* event) override;
+	virtual void wheelEvent(QWheelEvent* event) override;
+	virtual void timerEvent(QTimerEvent* event) override;
+
+private:
+	bool handleMousePressEvent(QMouseEvent* event);
+	bool handleMouseMoveEvent(QMouseEvent* event);
+	bool handleMouseReleaseEvent(QMouseEvent* event);
+	bool handleWheelEvent(QWheelEvent* event);
+	bool handleTimerEvent(QTimerEvent* event);
+
+	FlowSocket* socketAt(QPointF const& scenePos) const;
+	FlowLink* createLinkFromConnection(FlowConnection* connection);
+	bool canConnect(FlowSocket* socket) const;
+
+private:
+	FlowScene* _scene{};
+
+	QElapsedTimer _elapsedTimer{};
+	int _animationTimerId{ -1 };
+
+	QVariantAnimation* _centerOnAnimation{};
+
+	enum class ConnectionMode
+	{
+		Undefined,
+		ConnectToInput,
+		ConnectToOutput,
+		ChangeInput,
+		ChangeOutput,
+	};
+
+	// current connection mode
+	ConnectionMode _mode{ ConnectionMode::Undefined };
+
+	// this connection is used to temporarily mark a socket as connected
+	// when creating a new connection
+	QScopedPointer<FlowConnection> _tmpConnection{};
+	FlowSocketType _tmpSocketType{};
+
+	// the list of slots on the other hand of the manipulated link
+	FlowSocketSlots _slots{};
+
+	// list of existing connections
+	FlowConnections _connections{};
+
+	// list of volatile links
+	FlowLinks _links{};
+};
+
+} // namespace qtMate::flow
diff --git a/include/QtMate/graph/connection.hpp b/include/QtMate/graph/connection.hpp
deleted file mode 100644
index 480f8fd6..00000000
--- a/include/QtMate/graph/connection.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#pragma once
-
-#include <QGraphicsPathItem>
-
-#include <unordered_set>
-
-namespace qtMate
-{
-namespace graph
-{
-class InputSocketItem;
-class OutputSocketItem;
-
-class ConnectionItem : public QGraphicsPathItem
-{
-public:
-	ConnectionItem();
-	~ConnectionItem();
-
-	void setStart(QPointF const& p);
-	void setStop(QPointF const& p);
-
-	virtual int type() const override;
-
-	void connectInput(InputSocketItem* input);
-	InputSocketItem* input() const;
-	void disconnectInput();
-
-	void connectOutput(OutputSocketItem* output);
-	OutputSocketItem* output() const;
-	void disconnectOutput();
-
-	void disconnect();
-
-private:
-	virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) override;
-	void updatePath();
-
-private:
-	QPointF _start{};
-	QPointF _stop{};
-
-	InputSocketItem* _input{ nullptr };
-	OutputSocketItem* _output{ nullptr };
-};
-
-using ConnectionItems = std::unordered_set<ConnectionItem*>;
-
-} // namespace graph
-} // namespace qtMate
diff --git a/include/QtMate/graph/node.hpp b/include/QtMate/graph/node.hpp
deleted file mode 100644
index 419b9926..00000000
--- a/include/QtMate/graph/node.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#pragma once
-
-#include <QGraphicsItem>
-
-namespace qtMate
-{
-namespace graph
-{
-class InputSocketItem;
-class OutputSocketItem;
-
-class NodeItem : public QGraphicsItem
-{
-public:
-	NodeItem(int id, QString const& text, QGraphicsItem* parent = nullptr);
-
-	virtual int type() const override;
-
-	void addInput(QString const& text);
-	void addOutput(QString const& text);
-
-	InputSocketItem* inputAt(int index) const;
-	OutputSocketItem* outputAt(int index) const;
-
-	virtual QRectF boundingRect() const override;
-
-private:
-	virtual void paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget) override;
-	virtual QVariant itemChange(GraphicsItemChange change, QVariant const& value) override;
-
-	void updateGeometry();
-	void propagateChanges();
-
-private:
-	int _id{ -1 };
-	QString _text{};
-
-	float _width{ 0.f };
-	float _height{ 0.f };
-
-	QVector<InputSocketItem*> _inputs;
-	QVector<OutputSocketItem*> _outputs;
-};
-
-} // namespace graph
-} // namespace qtMate
diff --git a/include/QtMate/graph/view.hpp b/include/QtMate/graph/view.hpp
deleted file mode 100644
index 0c13f0cd..00000000
--- a/include/QtMate/graph/view.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#pragma once
-
-#include "connection.hpp"
-
-#include <QGraphicsView>
-
-#include <memory>
-
-namespace qtMate
-{
-namespace graph
-{
-enum class ConnectionDragMode
-{
-	Undefined,
-	ConnectToInput,
-	ConnectToOutput,
-	MoveToInput,
-	MoveToOutput
-};
-
-class ConnectionDragEvent
-{
-public:
-	ConnectionItems connections;
-	ConnectionDragMode mode{ ConnectionDragMode::Undefined };
-};
-
-class SocketItem;
-
-class GraphicsView : public QGraphicsView
-{
-	Q_OBJECT
-public:
-	GraphicsView(QWidget* parent = nullptr);
-
-	Q_SIGNAL void connectionCreated(ConnectionItem* connection);
-	Q_SIGNAL void connectionDeleted(ConnectionItem* connection);
-
-private:
-	virtual void mousePressEvent(QMouseEvent* event) override;
-	virtual void mouseMoveEvent(QMouseEvent* event) override;
-	virtual void mouseReleaseEvent(QMouseEvent* event) override;
-	virtual void timerEvent(QTimerEvent* event) override;
-
-private:
-	bool acceptableConnection(SocketItem* item) const;
-	SocketItem* socketAt(QPoint const& pos) const;
-
-	void startAutoScroll();
-	void stopAutoScroll();
-
-private:
-	std::unique_ptr<ConnectionDragEvent> _connectionDragEvent{};
-	int _autoScrollTimer{};
-};
-
-} // namespace graph
-} // namespace qtMate
diff --git a/include/QtMate/material/color.hpp b/include/QtMate/material/color.hpp
index ea60485b..603cd981 100644
--- a/include/QtMate/material/color.hpp
+++ b/include/QtMate/material/color.hpp
@@ -52,6 +52,8 @@ enum class Name
 	Brown,
 	Gray,
 	BlueGray,
+	Black,
+	White,
 
 	NameCount
 };
@@ -86,37 +88,78 @@ enum class Luminance
 
 // Default color shade
 static auto constexpr DefaultColor = Name::DeepPurple;
-static auto constexpr DefaultShade = Shade::Shade500;
+static auto constexpr DefaultLightShade = Shade::Shade800;
+static auto constexpr DefaultDarkShade = Shade::Shade200;
+
+// Default background luminance
+static auto constexpr DefaultBackgroundLuminance = Luminance::Light;
 
 // Return the color value for a given name + shade
 // May throw invalid_argument for non existing combinations
-QColor value(Name const name, Shade const shade = DefaultShade);
+QColor value(Name const name, Shade const shade = DefaultLightShade);
+
+// Return the foreground color based on current color scheme
+// Dark: white
+// Light: black
+QColor foregroundColor();
+
+// Return the background color based on current color scheme
+// Dark: black
+// Light: white
+QColor backgroundColor();
+
+// Return the background color name based on the given luminance
+// Dark: Name::Black
+// Light: Name::White
+Name backgroundColorName(Luminance const luminance);
+
+// Return the background color name based on current color scheme
+// Dark: Name::Black
+// Light: Name::White
+Name backgroundColorName();
 
 // Return the foreground color value for given name + shade
 // May throw invalid_argument for non existing combinations
 // Foreground value is linked to the color luminance
 // Dark: white
 // Light: black
-QColor foregroundValue(Name const name, Shade const shade = DefaultShade);
+QColor foregroundValue(Name const name, Shade const shade = DefaultLightShade);
 
 // Return the complementary color value for given name + shade
 // May throw invalid_argument for non existing combinations
-QColor complementaryValue(Name const name, Shade const shade = DefaultShade);
+QColor complementaryValue(Name const name, Shade const shade = DefaultLightShade);
 
 // Return the foreground complementary color value for given name + shade
 // May throw invalid_argument for non existing combinations
-QColor foregroundComplementaryValue(Name const name, Shade const shade = DefaultShade);
+QColor foregroundComplementaryValue(Name const name, Shade const shade = DefaultLightShade);
 
 // Return the foreground error color value for given name + shade
 // May throw invalid_argument for non existing combinations
 QColor foregroundErrorColorValue(Name const name, Shade const shade);
 
+// Return the foreground warning color value for given name + shade
+// May throw invalid_argument for non existing combinations
+QColor foregroundWarningColorValue(Name const name, Shade const shade);
+
+// Return the foreground information color value for given name + shade
+// May throw invalid_argument for non existing combinations
+QColor foregroundInformationColorValue(Name const name, Shade const shade);
+
 // Return the luminance for a given name + shade
 // May throw invalid_argument for non existing combinations
-Luminance luminance(Name const name, Shade const shade = DefaultShade);
+Luminance luminance(Name const name, Shade const shade = DefaultLightShade);
 
 // Return a brush that represents a given name + shade
-QBrush brush(Name const name, Shade const shade = DefaultShade) noexcept;
+QBrush brush(Name const name, Shade const shade = DefaultLightShade) noexcept;
+
+// Return the Shade based on the current color scheme
+Shade colorSchemeShade();
+
+// Return true if the current color scheme is dark
+bool isDarkColorScheme();
+
+// Return the default foreground color for disabled items based on the current color scheme
+QColor disabledForegroundColor();
 
 } // namespace color
 } // namespace material
diff --git a/include/QtMate/widgets/dynamicHeaderView.hpp b/include/QtMate/widgets/dynamicHeaderView.hpp
index b433ce7f..ba604b0d 100644
--- a/include/QtMate/widgets/dynamicHeaderView.hpp
+++ b/include/QtMate/widgets/dynamicHeaderView.hpp
@@ -20,6 +20,7 @@
 #pragma once
 
 #include <QHeaderView>
+#include <set>
 
 namespace qtMate
 {
@@ -31,8 +32,7 @@ class DynamicHeaderView : public QHeaderView
 public:
 	DynamicHeaderView(Qt::Orientation orientation, QWidget* parent = nullptr);
 
-	int mandatorySection() const;
-	void setMandatorySection(int mandatorySection);
+	void setMandatorySection(int const mandatorySection);
 
 	Q_SIGNAL void sectionChanged();
 
@@ -40,7 +40,7 @@ class DynamicHeaderView : public QHeaderView
 	void customContextMenuRequested(QPoint const& pos);
 
 private:
-	int _mandatorySection{ 0 };
+	std::set<int> _mandatorySections{};
 };
 
 } // namespace widgets
diff --git a/include/hive/modelsLibrary/controllerManager.hpp b/include/hive/modelsLibrary/controllerManager.hpp
index 07d77fae..62ec8cff 100644
--- a/include/hive/modelsLibrary/controllerManager.hpp
+++ b/include/hive/modelsLibrary/controllerManager.hpp
@@ -68,6 +68,7 @@ class ControllerManager : public QObject
 		SetConfigurationName,
 		SetAudioUnitName,
 		SetStreamName,
+		SetJackName,
 		SetAvbInterfaceName,
 		SetClockSourceName,
 		SetMemoryObjectName,
@@ -115,6 +116,8 @@ class ControllerManager : public QObject
 	using SetAudioUnitNameHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)>;
 	using SetStreamInputNameHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)>;
 	using SetStreamOutputNameHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)>;
+	using SetJackInputNameHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)>;
+	using SetJackOutputNameHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)>;
 	using SetAvbInterfaceNameHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)>;
 	using SetClockSourceNameHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)>;
 	using SetMemoryObjectNameHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)>;
@@ -173,6 +176,20 @@ class ControllerManager : public QObject
 	/** Deserializes a JSON file representing an entity, and loads it as a virtual ControlledEntity. */
 	virtual std::tuple<la::avdecc::jsonSerializer::DeserializationError, std::string> loadVirtualEntityFromJson(QString const& filePath, la::avdecc::entity::model::jsonSerializer::Flags const flags) noexcept = 0;
 
+	/** Re-enumerates the specified entity (physical entity only). */
+	virtual bool refreshEntity(la::avdecc::UniqueIdentifier const entityID) noexcept = 0;
+
+	/** Removes a Virtual Entity from the controller */
+	virtual bool unloadVirtualEntity(la::avdecc::UniqueIdentifier const entityID) noexcept = 0;
+
+	/** Returns the StreamFormat among the provided availableFormats, that best matches desiredStreamFormat, using clockValidator delegate callback. Returns invalid StreamFormat if none is available. */
+	virtual la::avdecc::entity::model::StreamFormat chooseBestStreamFormat(la::avdecc::entity::model::StreamFormats const& availableFormats, la::avdecc::entity::model::StreamFormat const desiredStreamFormat, std::function<bool(bool const isDesiredClockSync, bool const isAvailableClockSync)> const& clockValidator) noexcept = 0;
+
+	virtual bool isMediaClockStreamFormat(la::avdecc::entity::model::StreamFormat const streamFormat) noexcept = 0;
+
+	/** Returns a checksum of the static entity model of the given ControlledEntity for the given checksumVersion (defaults to the maximum checksum version supported by the library) */
+	virtual std::optional<std::string> computeEntityModelChecksum(la::avdecc::controller::ControlledEntity const& controlledEntity, std::uint32_t const checksumVersion = la::avdecc::controller::Controller::ChecksumVersion) noexcept = 0;
+
 	/** Enable/Disable AEM cache */
 	virtual void setEnableAemCache(bool const enable) noexcept = 0;
 
@@ -196,6 +213,7 @@ class ControllerManager : public QObject
 	virtual la::avdecc::controller::ControlledEntity::Diagnostics getDiagnostics(la::avdecc::UniqueIdentifier const entityID) const noexcept = 0;
 	virtual bool isRedundancyWarning(la::avdecc::UniqueIdentifier const entityID) const noexcept = 0;
 	virtual bool getStreamInputLatencyError(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::StreamIndex const streamIndex) const noexcept = 0;
+	virtual bool getControlValueOutOfBounds(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex) const noexcept = 0;
 
 	/* Discovery Protocol (ADP) */
 	/** Enables entity advertising with available duration included between 2-62 seconds on the specified interfaceIndex if set, otherwise on all interfaces. */
@@ -226,6 +244,8 @@ class ControllerManager : public QObject
 	virtual void setAudioUnitName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, QString const& name, BeginCommandHandler const& beginHandler = {}, SetAudioUnitNameHandler const& resultHandler = {}) noexcept = 0;
 	virtual void setStreamInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, QString const& name, BeginCommandHandler const& beginHandler = {}, SetStreamInputNameHandler const& resultHandler = {}) noexcept = 0;
 	virtual void setStreamOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, QString const& name, BeginCommandHandler const& beginHandler = {}, SetStreamOutputNameHandler const& resultHandler = {}) noexcept = 0;
+	virtual void setJackInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, QString const& name, BeginCommandHandler const& beginHandler = {}, SetJackInputNameHandler const& resultHandler = {}) noexcept = 0;
+	virtual void setJackOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, QString const& name, BeginCommandHandler const& beginHandler = {}, SetJackOutputNameHandler const& resultHandler = {}) noexcept = 0;
 	virtual void setAvbInterfaceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, QString const& name, BeginCommandHandler const& beginHandler = {}, SetAvbInterfaceNameHandler const& resultHandler = {}) noexcept = 0;
 	virtual void setClockSourceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, QString const& name, BeginCommandHandler const& beginHandler = {}, SetClockSourceNameHandler const& resultHandler = {}) noexcept = 0;
 	virtual void setMemoryObjectName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, QString const& name, BeginCommandHandler const& beginHandler = {}, SetMemoryObjectNameHandler const& resultHandler = {}) noexcept = 0;
@@ -299,6 +319,7 @@ class ControllerManager : public QObject
 	Q_SIGNAL void configurationNameChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, QString const& configurationName);
 	Q_SIGNAL void audioUnitNameChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, QString const& audioUnitName);
 	Q_SIGNAL void streamNameChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::StreamIndex const streamIndex, QString const& streamName);
+	Q_SIGNAL void jackNameChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::JackIndex const jackIndex, QString const& jackName);
 	Q_SIGNAL void avbInterfaceNameChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, QString const& avbInterfaceName);
 	Q_SIGNAL void clockSourceNameChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, QString const& clockSourceName);
 	Q_SIGNAL void memoryObjectNameChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, QString const& memoryObjectName);
@@ -349,6 +370,7 @@ class ControllerManager : public QObject
 	Q_SIGNAL void diagnosticsChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::controller::ControlledEntity::Diagnostics const& diagnostics);
 	Q_SIGNAL void redundancyWarningChanged(la::avdecc::UniqueIdentifier const entityID, bool const isRedundancyWarning);
 	Q_SIGNAL void streamInputLatencyErrorChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::StreamIndex const streamIndex, bool const isLatencyError);
+	Q_SIGNAL void controlCurrentValueOutOfBoundsChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex, bool const isValueOutOfBounds);
 };
 
 } // namespace modelsLibrary
diff --git a/include/hive/modelsLibrary/discoveredEntitiesModel.hpp b/include/hive/modelsLibrary/discoveredEntitiesModel.hpp
index 6023c1f1..4e62ea90 100644
--- a/include/hive/modelsLibrary/discoveredEntitiesModel.hpp
+++ b/include/hive/modelsLibrary/discoveredEntitiesModel.hpp
@@ -63,6 +63,13 @@ class DiscoveredEntitiesModel
 		AccessSelf = 3, /**< Device is exclusively accessed by us */
 	};
 
+	enum class ClockDomainLockedState
+	{
+		Unknown = 0, /**< Unknown state */
+		Unlocked = 1, /**< Not Locked */
+		Locked = 2, /**< Locked */
+	};
+
 	struct ExclusiveAccessInfo
 	{
 		ExclusiveAccessState state{ ExclusiveAccessState::NoAccess };
@@ -84,6 +91,12 @@ class DiscoveredEntitiesModel
 		bool isError{ false };
 	};
 
+	struct ClockDomainInfo
+	{
+		ClockDomainLockedState state{ ClockDomainLockedState::Unknown };
+		QString tooltip{ "Not reported by the entity" };
+	};
+
 	struct Entity
 	{
 		// Static information
@@ -91,10 +104,12 @@ class DiscoveredEntitiesModel
 		bool isAemSupported{ false };
 		bool hasAnyConfigurationTree{ false };
 		bool isVirtual{ false };
+		bool areUnsolicitedNotificationsSupported{ false };
 		la::avdecc::UniqueIdentifier entityModelID{};
 		std::optional<QString> firmwareVersion{};
 		std::optional<la::avdecc::entity::model::MemoryObjectIndex> firmwareUploadMemoryIndex{ std::nullopt };
 		std::optional<la::avdecc::entity::model::MilanInfo> milanInfo{};
+		std::map<la::avdecc::entity::model::AvbInterfaceIndex, la::networkInterface::MacAddress> macAddresses{};
 
 		// Dynamic information
 		QString name{}; /** Change triggers ChangedInfoFlag::Name */
@@ -106,12 +121,14 @@ class DiscoveredEntitiesModel
 		ExclusiveAccessInfo lockInfo{}; /** Change triggers ChangedInfoFlag::LockState and/or ChangedInfoFlag::LockingController */
 		std::map<la::avdecc::entity::model::AvbInterfaceIndex, GptpInfo> gptpInfo{}; /** Change triggers ChangedInfoFlag::GrandmasterID and/or ChangeInfoFlag::GPTPDomain */
 		std::optional<la::avdecc::UniqueIdentifier> associationID{}; /** Change triggers ChangedInfoFlag::AssociationID */
-		std::map<la::avdecc::entity::model::ClockDomainIndex, MediaClockReference> mediaClockReferences{}; /** Change triggers ChangedInfoFlag::MediaClockReferenceID and/or ChangedInfoFlag::MediaClockReferenceStatus */
+		std::map<la::avdecc::entity::model::ClockDomainIndex, MediaClockReference> mediaClockReferences{}; /** Change triggers ChangedInfoFlag::MediaClockReferenceID and/or ChangedInfoFlag::MediaClockReferenceName */
 		bool isIdentifying{ false }; /** Change triggers ChangedInfoFlag::Identification */
 		bool hasStatisticsError{ false }; /** Change triggers ChangedInfoFlag::StatisticsError */
 		bool hasRedundancyWarning{ false }; /** Change triggers ChangedInfoFlag::RedundancyWarning */
+		ClockDomainInfo clockDomainInfo{}; /** Change triggers ChangedInfoFlag::ClockDomainLockState */
 		std::set<la::avdecc::entity::model::StreamIndex> streamsWithErrorCounter{}; /** Change triggers ChangedInfoFlag::StreamInputCountersError */
 		std::set<la::avdecc::entity::model::StreamIndex> streamsWithLatencyError{}; /** Change triggers ChangedInfoFlag::StreamInputLatencyError */
+		std::set<la::avdecc::entity::model::ControlIndex> controlsWithOutOfBoundsValue{}; /** Change triggers ChangedInfoFlag::ControlValueOutOfBoundsError */
 	};
 
 	using Model = DiscoveredEntitiesAbstractTableModel;
@@ -121,6 +138,7 @@ class DiscoveredEntitiesModel
 
 	std::optional<std::reference_wrapper<Entity const>> entity(std::size_t const index) const noexcept;
 	std::optional<std::reference_wrapper<Entity const>> entity(la::avdecc::UniqueIdentifier const& entityID) const noexcept;
+	std::optional<std::size_t> indexOf(la::avdecc::UniqueIdentifier const& entityID) const noexcept;
 	std::size_t entitiesCount() const noexcept;
 
 private:
@@ -147,14 +165,17 @@ class DiscoveredEntitiesAbstractTableModel : public QAbstractTableModel
 		GrandmasterID = 1u << 9,
 		GPTPDomain = 1u << 10,
 		InterfaceIndex = 1u << 11,
-		AssociationID = 1u << 12,
-		MediaClockReferenceID = 1u << 13,
-		MediaClockReferenceStatus = 1u << 14,
-		Identification = 1u << 15,
-		StatisticsError = 1u << 16,
-		RedundancyWarning = 1u << 17,
-		StreamInputCountersError = 1u << 18,
-		StreamInputLatencyError = 1u << 19,
+		MacAddress = 1u << 12,
+		AssociationID = 1u << 13,
+		MediaClockReferenceID = 1u << 14,
+		MediaClockReferenceName = 1u << 15,
+		ClockDomainLockState = 1u << 16,
+		Identification = 1u << 17,
+		StatisticsError = 1u << 18,
+		RedundancyWarning = 1u << 19,
+		StreamInputCountersError = 1u << 20,
+		StreamInputLatencyError = 1u << 21,
+		ControlValueOutOfBoundsError = 1u << 22,
 	};
 	using ChangedInfoFlags = la::avdecc::utils::EnumBitfield<ChangedInfoFlag>;
 
diff --git a/include/hive/modelsLibrary/helper.hpp b/include/hive/modelsLibrary/helper.hpp
index ead2ba2d..330f1a18 100644
--- a/include/hive/modelsLibrary/helper.hpp
+++ b/include/hive/modelsLibrary/helper.hpp
@@ -21,6 +21,7 @@
 
 #include <la/avdecc/utils.hpp>
 #include <la/avdecc/controller/avdeccController.hpp>
+#include <hive/modelsLibrary/discoveredEntitiesModel.hpp>
 #include <QString>
 
 #include <sstream>
@@ -59,6 +60,7 @@ inline QString toHexQString(T const v, bool const zeroFilled = false, bool const
 QString toUpperCamelCase(std::string const& text) noexcept;
 QString getVendorName(la::avdecc::UniqueIdentifier const entityID) noexcept;
 QString uniqueIdentifierToString(la::avdecc::UniqueIdentifier const& identifier);
+QString macAddressToString(la::networkInterface::MacAddress const& macAddress);
 QString localizedString(la::avdecc::controller::ControlledEntity const& controlledEntity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::LocalizedStringReference const stringReference) noexcept;
 QString localizedString(la::avdecc::controller::ControlledEntity const& controlledEntity, la::avdecc::entity::model::LocalizedStringReference const stringReference) noexcept;
 QString configurationName(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const& node) noexcept;
@@ -66,23 +68,23 @@ QString configurationName(la::avdecc::controller::ControlledEntity const* const
 template<class NodeType>
 QString objectName(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, NodeType const& node) noexcept
 {
-	if (node.dynamicModel->objectName.empty())
+	if (node.dynamicModel.objectName.empty())
 	{
-		return localizedString(*controlledEntity, configurationIndex, node.staticModel->localizedDescription);
+		return localizedString(*controlledEntity, configurationIndex, node.staticModel.localizedDescription);
 	}
 
-	return node.dynamicModel->objectName.data();
+	return node.dynamicModel.objectName.data();
 }
 
 template<class NodeType>
 QString objectName(la::avdecc::controller::ControlledEntity const* const controlledEntity, NodeType const& node) noexcept
 {
-	if (node.dynamicModel->objectName.empty())
+	if (node.dynamicModel.objectName.empty())
 	{
-		return localizedString(*controlledEntity, node.staticModel->localizedDescription);
+		return localizedString(*controlledEntity, node.staticModel.localizedDescription);
 	}
 
-	return node.dynamicModel->objectName.data();
+	return node.dynamicModel.objectName.data();
 }
 
 bool constexpr isConnectedToTalker(la::avdecc::entity::model::StreamIdentification const& talkerStream, la::avdecc::entity::model::StreamInputConnectionInfo const& info) noexcept
@@ -97,6 +99,7 @@ bool constexpr isFastConnectingToTalker(la::avdecc::entity::model::StreamIdentif
 
 QString entityName(la::avdecc::controller::ControlledEntity const& controlledEntity) noexcept;
 QString smartEntityName(la::avdecc::controller::ControlledEntity const& controlledEntity) noexcept;
+QString smartEntityName(hive::modelsLibrary::DiscoveredEntitiesModel::Entity const& entity) noexcept;
 QString groupName(la::avdecc::controller::ControlledEntity const& controlledEntity) noexcept;
 QString outputStreamName(la::avdecc::controller::ControlledEntity const& controlledEntity, la::avdecc::entity::model::StreamIndex const streamIndex) noexcept;
 QString inputStreamName(la::avdecc::controller::ControlledEntity const& controlledEntity, la::avdecc::entity::model::StreamIndex const streamIndex) noexcept;
diff --git a/include/hive/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.hpp b/include/hive/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.hpp
index 2c0f1bf5..170758ff 100644
--- a/include/hive/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.hpp
+++ b/include/hive/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.hpp
@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include "errorItemDelegate.hpp"
+#include "errorIconItemDelegate.hpp"
 #include "imageItemDelegate.hpp"
 
 #include <QStyledItemDelegate>
@@ -33,14 +33,18 @@ class DiscoveredEntitiesTableItemDelegate : public QStyledItemDelegate
 {
 	Q_OBJECT
 public:
-	using QStyledItemDelegate::QStyledItemDelegate;
+	DiscoveredEntitiesTableItemDelegate(qtMate::material::color::Name const themeColorName = qtMate::material::color::DefaultColor, QObject* parent = nullptr) noexcept;
+
+	Q_SLOT void setThemeColorName(qtMate::material::color::Name const themeColorName);
 
 protected:
 	virtual void paint(QPainter* painter, QStyleOptionViewItem const& option, QModelIndex const& index) const override;
 
 private:
 	// Private members
-	ErrorItemDelegate _errorItemDelegate{ false };
+	qtMate::material::color::Name _themeColorName{ qtMate::material::color::DefaultColor };
+	bool _isDark{ false };
+	ErrorIconItemDelegate _errorIconItemDelegate{ false };
 	ImageItemDelegate _imageItemDelegate{ false };
 };
 
diff --git a/include/hive/widgetModelsLibrary/discoveredEntitiesTableModel.hpp b/include/hive/widgetModelsLibrary/discoveredEntitiesTableModel.hpp
index f213c7b2..849269bd 100644
--- a/include/hive/widgetModelsLibrary/discoveredEntitiesTableModel.hpp
+++ b/include/hive/widgetModelsLibrary/discoveredEntitiesTableModel.hpp
@@ -37,21 +37,24 @@ class DiscoveredEntitiesTableModel : public hive::modelsLibrary::DiscoveredEntit
 	enum class EntityDataFlag : std::uint32_t
 	{
 		All = 0u,
-		EntityLogo = 1u << 0,
-		Compatibility = 1u << 1,
-		EntityID = 1u << 2,
-		Name = 1u << 3,
-		Group = 1u << 4,
-		AcquireState = 1u << 5,
-		LockState = 1u << 6,
-		GrandmasterID = 1u << 7,
-		GPTPDomain = 1u << 8,
-		InterfaceIndex = 1u << 9,
-		AssociationID = 1u << 10,
-		EntityModelID = 1u << 11,
-		FirmwareVersion = 1u << 12,
-		MediaClockReferenceID = 1u << 13,
-		MediaClockReferenceStatus = 1u << 14,
+		EntityStatus = 1u << 0,
+		EntityLogo = 1u << 1,
+		Compatibility = 1u << 2,
+		EntityID = 1u << 3,
+		Name = 1u << 4,
+		Group = 1u << 5,
+		AcquireState = 1u << 6,
+		LockState = 1u << 7,
+		GrandmasterID = 1u << 8,
+		GPTPDomain = 1u << 9,
+		InterfaceIndex = 1u << 10,
+		MacAddress = 1u << 11,
+		AssociationID = 1u << 12,
+		EntityModelID = 1u << 13,
+		FirmwareVersion = 1u << 14,
+		MediaClockReferenceID = 1u << 15,
+		MediaClockReferenceName = 1u << 16,
+		ClockDomainLockState = 1u << 17,
 	};
 	/** List of columns to be displayed */
 	using EntityDataFlags = la::avdecc::utils::EnumBitfield<EntityDataFlag>;
@@ -60,6 +63,7 @@ class DiscoveredEntitiesTableModel : public hive::modelsLibrary::DiscoveredEntit
 
 	// Data getter
 	std::optional<std::reference_wrapper<hive::modelsLibrary::DiscoveredEntitiesModel::Entity const>> entity(int const row) const noexcept;
+	QModelIndex indexOf(la::avdecc::UniqueIdentifier const& entityID) const noexcept;
 
 private:
 	// hive::modelsLibrary::DiscoveredEntitiesAbstractTableModel overrides
diff --git a/include/hive/widgetModelsLibrary/errorIconItemDelegate.hpp b/include/hive/widgetModelsLibrary/errorIconItemDelegate.hpp
new file mode 100644
index 00000000..51642968
--- /dev/null
+++ b/include/hive/widgetModelsLibrary/errorIconItemDelegate.hpp
@@ -0,0 +1,58 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <la/avdecc/utils.hpp>
+#include <QtMate/material/color.hpp>
+
+#include <QStyledItemDelegate>
+
+namespace hive
+{
+namespace widgetModelsLibrary
+{
+// This delegate paints an small circle on each item based on the ErrorType value returned for the "QtUserRoles::WarningErrorRole"
+class ErrorIconItemDelegate : public QStyledItemDelegate
+{
+	Q_OBJECT
+public:
+	enum class ErrorType
+	{
+		None = 0,
+		Warning = 1,
+		Error = 2,
+		Information = 3,
+	};
+
+	ErrorIconItemDelegate(bool const paintBaseDelegate, qtMate::material::color::Name const themeColorName = qtMate::material::color::DefaultColor, QObject* parent = nullptr) noexcept;
+
+	Q_SLOT void setThemeColorName(qtMate::material::color::Name const themeColorName);
+
+protected:
+	virtual void paint(QPainter* painter, QStyleOptionViewItem const& option, QModelIndex const& index) const override;
+
+private:
+	// Private members
+	bool _paintBaseDelegate{ true };
+	qtMate::material::color::Name _themeColorName{ qtMate::material::color::DefaultColor };
+};
+
+} // namespace widgetModelsLibrary
+} // namespace hive
diff --git a/include/hive/widgetModelsLibrary/networkInterfacesListItemDelegate.hpp b/include/hive/widgetModelsLibrary/networkInterfacesListItemDelegate.hpp
new file mode 100644
index 00000000..307a24b7
--- /dev/null
+++ b/include/hive/widgetModelsLibrary/networkInterfacesListItemDelegate.hpp
@@ -0,0 +1,52 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "errorItemDelegate.hpp"
+#include "imageItemDelegate.hpp"
+
+#include <QStyledItemDelegate>
+
+namespace hive
+{
+namespace widgetModelsLibrary
+{
+// This delegate handles all QtUserRoles used by NetworkInterfacesListModel and can be used as global ItemDelegate
+class NetworkInterfacesListItemDelegate : public QStyledItemDelegate
+{
+	Q_OBJECT
+public:
+	NetworkInterfacesListItemDelegate(qtMate::material::color::Name const themeColorName = qtMate::material::color::DefaultColor, QObject* parent = nullptr) noexcept;
+
+	Q_SLOT void setThemeColorName(qtMate::material::color::Name const themeColorName);
+
+protected:
+	virtual void paint(QPainter* painter, QStyleOptionViewItem const& option, QModelIndex const& index) const override;
+
+private:
+	// Private members
+	qtMate::material::color::Name _themeColorName{ qtMate::material::color::DefaultColor };
+	bool _isDark{ false };
+	ErrorItemDelegate _errorItemDelegate{ false };
+	ImageItemDelegate _imageItemDelegate{ false };
+};
+
+} // namespace widgetModelsLibrary
+} // namespace hive
diff --git a/include/hive/widgetModelsLibrary/qtUserRoles.hpp b/include/hive/widgetModelsLibrary/qtUserRoles.hpp
index 2666a8d4..5a9e362c 100644
--- a/include/hive/widgetModelsLibrary/qtUserRoles.hpp
+++ b/include/hive/widgetModelsLibrary/qtUserRoles.hpp
@@ -34,7 +34,9 @@ enum class QtUserRoles : int
 	SelectedEntityRole, /**< Role used for Entity Selection representation */
 	IdentificationRole, /**< Role used for Entity Identification representation */
 	SubscribedUnsolRole, /**< Role used for Unsolicited Notifications Subscription representation */
+	UnsolSupportedRole, /**< Role used for Supported Unsolicited Notifications representation */
 	IsVirtualRole, /**< Role used for Virtual Entity representation */
+	ActiveRole, /**< Role used for active item representation */
 };
 using RolesList = QVector<int>;
 
diff --git a/installer/CMakeLists.txt b/installer/CMakeLists.txt
index ba27bf37..3033ae29 100644
--- a/installer/CMakeLists.txt
+++ b/installer/CMakeLists.txt
@@ -33,7 +33,6 @@ macro(configure_NSIS_extra_commands)
 		WriteRegDWORD SHCTX \\\"Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Uninstall\\\\${PACKAGE_INSTALL_KEY}\\\" \\\"EstimatedSize\\\" \\\"$0\\\""
 	)
 
-
 	# Install winpcap
 	set(COMPONENT_NAME_WINPCAP WinPcap)
 	install(FILES "${CU_ROOT_DIR}/installer/win32/WinPcap_4_1_3.exe" DESTINATION . CONFIGURATIONS Release COMPONENT ${COMPONENT_NAME_WINPCAP})
@@ -43,6 +42,14 @@ macro(configure_NSIS_extra_commands)
 		Delete \\\"$INSTDIR\\\\WinPcap_4_1_3.exe\\\"\n\
 		# IfErrors -1\n"
 	)
+
+	# Add file associations
+	add_installer_file_association("ave" "Hive.ave" "ATDECC Virtual Entity" "bin/${PROJECT_NAME}.exe,1" "bin/${PROJECT_NAME}.exe")
+	add_installer_file_association("ans" "Hive.ans" "ATDECC Network State" "bin/${PROJECT_NAME}.exe,2" "bin/${PROJECT_NAME}.exe")
+
+	# Refresh icons related to the file associations
+	add_installer_refresh_associations()
+
 endmacro()
 
 # Declare a function that will be called before generating the NSIS package, to include custom components
diff --git a/libs/QtMate/CMakeLists.txt b/libs/QtMate/CMakeLists.txt
index f3e6c1e4..93ce859b 100644
--- a/libs/QtMate/CMakeLists.txt
+++ b/libs/QtMate/CMakeLists.txt
@@ -18,13 +18,17 @@ set(HEADER_FILES_PUBLIC
 	${CU_ROOT_DIR}/include/QtMate/material/color.hpp
 	${CU_ROOT_DIR}/include/QtMate/material/colorPalette.hpp
 	${CU_ROOT_DIR}/include/QtMate/material/helper.hpp
-	${CU_ROOT_DIR}/include/QtMate/graph/connection.hpp
-	${CU_ROOT_DIR}/include/QtMate/graph/inputSocket.hpp
-	${CU_ROOT_DIR}/include/QtMate/graph/node.hpp
-	${CU_ROOT_DIR}/include/QtMate/graph/outputSocket.hpp
-	${CU_ROOT_DIR}/include/QtMate/graph/socket.hpp
-	${CU_ROOT_DIR}/include/QtMate/graph/type.hpp
-	${CU_ROOT_DIR}/include/QtMate/graph/view.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowConnection.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowDefs.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowInput.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowLink.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowNode.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowOutput.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowScene.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowSceneDelegate.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowSocket.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowStyle.hpp
+	${CU_ROOT_DIR}/include/QtMate/flow/flowView.hpp
 	${CU_ROOT_DIR}/include/QtMate/widgets/autoSizeLabel.hpp
 	${CU_ROOT_DIR}/include/QtMate/widgets/comboBox.hpp
 	${CU_ROOT_DIR}/include/QtMate/widgets/dynamicHeaderView.hpp
@@ -42,12 +46,16 @@ set(SOURCE_FILES_COMMON
 	material/color.cpp
 	material/colorPalette.cpp
 	material/helper.cpp
-	graph/connection.cpp
-	graph/inputSocket.cpp
-	graph/node.cpp
-	graph/outputSocket.cpp
-	graph/socket.cpp
-	graph/view.cpp
+	flow/flowConnection.cpp
+	flow/flowInput.cpp
+	flow/flowLink.cpp
+	flow/flowNode.cpp
+	flow/flowOutput.cpp
+	flow/flowScene.cpp
+	flow/flowSceneDelegate.cpp
+	flow/flowSocket.cpp
+	flow/flowStyle.cpp
+	flow/flowView.cpp
 	widgets/autoSizeLabel.cpp
 	widgets/comboBox.cpp
 	widgets/dynamicHeaderView.cpp
diff --git a/libs/QtMate/flow/flowConnection.cpp b/libs/QtMate/flow/flowConnection.cpp
new file mode 100644
index 00000000..f1584049
--- /dev/null
+++ b/libs/QtMate/flow/flowConnection.cpp
@@ -0,0 +1,109 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowConnection.hpp"
+#include "QtMate/flow/flowNode.hpp"
+#include "QtMate/flow/flowInput.hpp"
+#include "QtMate/flow/flowOutput.hpp"
+
+#include <QDebug>
+
+namespace qtMate::flow
+{
+FlowConnection::FlowConnection(QGraphicsItem* parent)
+	: FlowLink{ parent }
+{
+}
+
+FlowConnection::~FlowConnection()
+{
+	setInput(nullptr);
+	setOutput(nullptr);
+}
+
+FlowConnectionDescriptor FlowConnection::descriptor() const
+{
+	if (!_output || !_input)
+	{
+		qWarning() << "querying descriptor on invalid connection";
+		return InvalidFlowConnectionDescriptor;
+	}
+
+	return FlowConnectionDescriptor{ _output->slot(), _input->slot() };
+}
+
+void FlowConnection::setOutput(FlowOutput* output)
+{
+	if (output != _output)
+	{
+		if (_output)
+		{
+			_output->removeConnection(this);
+		}
+		_output = output;
+		if (_output)
+		{
+			_output->addConnection(this);
+		}
+	}
+
+	updatePath();
+}
+
+FlowOutput* FlowConnection::output() const
+{
+	return _output;
+}
+
+void FlowConnection::setInput(FlowInput* input)
+{
+	if (input != _input)
+	{
+		if (_input)
+		{
+			_input->setConnection(nullptr);
+		}
+		_input = input;
+		if (_input)
+		{
+			_input->setConnection(this);
+		}
+	}
+
+	updatePath();
+}
+
+FlowInput* FlowConnection::input() const
+{
+	return _input;
+}
+
+void FlowConnection::updatePath()
+{
+	if (!_output || !_input)
+	{
+		setPath({});
+		return;
+	}
+
+	setStart(_output->hotSpotSceneCenter());
+	setStop(_input->hotSpotSceneCenter());
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/flow/flowInput.cpp b/libs/QtMate/flow/flowInput.cpp
new file mode 100644
index 00000000..1998bab2
--- /dev/null
+++ b/libs/QtMate/flow/flowInput.cpp
@@ -0,0 +1,93 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowInput.hpp"
+#include "QtMate/flow/flowConnection.hpp"
+#include "QtMate/flow/flowStyle.hpp"
+
+#include <QPainter>
+
+namespace qtMate::flow
+{
+FlowInput::~FlowInput()
+{
+	if (_connection)
+	{
+		_connection->setInput(nullptr);
+		_connection = nullptr;
+	}
+}
+
+int FlowInput::type() const
+{
+	return Type;
+}
+
+QRectF FlowInput::boundingRect() const
+{
+	auto const availableWidth = parentItem()->boundingRect().width();
+	return QRectF{ 0.f, 0.f, availableWidth, NODE_LINE_HEIGHT };
+}
+
+bool FlowInput::isConnected() const
+{
+	return _connection != nullptr;
+}
+
+QRectF FlowInput::hotSpotBoundingRect() const
+{
+	auto const r = boundingRect();
+	return QRectF{ 0.f, 0.f, NODE_SOCKET_BOUNDING_SIZE, r.height() };
+}
+
+FlowConnection* FlowInput::connection() const
+{
+	return _connection;
+}
+
+void FlowInput::setConnection(FlowConnection* connection)
+{
+	if (connection != _connection)
+	{
+		_connection = connection;
+		update();
+	}
+}
+
+void FlowInput::updateConnection()
+{
+	if (_connection)
+	{
+		_connection->updatePath();
+	}
+}
+
+void FlowInput::paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget)
+{
+	auto const hotSpot = hotSpotBoundingRect().center();
+	drawInputHotSpot(painter, hotSpot, _color, isConnected());
+
+	auto const nameBoundingRect = boundingRect().adjusted(NODE_SOCKET_BOUNDING_SIZE, 0.f, 0.f, 0.f);
+
+	painter->setPen(NODE_TEXT_COLOR);
+	painter->setBrush(Qt::NoBrush);
+	drawElidedText(painter, nameBoundingRect, Qt::AlignVCenter | Qt::AlignLeft, Qt::TextElideMode::ElideMiddle, _descriptor.name);
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/flow/flowLink.cpp b/libs/QtMate/flow/flowLink.cpp
new file mode 100644
index 00000000..b6d9c206
--- /dev/null
+++ b/libs/QtMate/flow/flowLink.cpp
@@ -0,0 +1,70 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowLink.hpp"
+#include "QtMate/flow/flowStyle.hpp"
+
+#include <QPainter>
+
+namespace qtMate::flow
+{
+FlowLink::FlowLink(QGraphicsItem* parent)
+	: QGraphicsPathItem{ parent }
+{
+	setZValue(-1.f);
+	setPen(NODE_CONNECTION_PEN);
+}
+
+FlowLink::~FlowLink() = default;
+
+void FlowLink::setStart(QPointF const& start)
+{
+	_start = start;
+	updatePainterPath();
+}
+
+void FlowLink::setStop(QPointF const& stop)
+{
+	_stop = stop;
+	updatePainterPath();
+}
+
+void FlowLink::updatePainterPath()
+{
+	auto dist = _start.x() - _stop.x();
+
+	auto ratio = 0.5f;
+	auto offset = 0.f;
+
+	if (dist > 0)
+	{
+		offset = -dist;
+	}
+
+	dist = std::abs(dist);
+
+	auto const c1 = QPointF{ _start.x() + dist * ratio, _start.y() + offset };
+	auto const c2 = QPointF{ _stop.x() - dist * ratio, _stop.y() + offset };
+
+	auto painterPath = QPainterPath{ _start };
+	painterPath.cubicTo(c1, c2, _stop);
+	setPath(painterPath);
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/flow/flowNode.cpp b/libs/QtMate/flow/flowNode.cpp
new file mode 100644
index 00000000..46e7b914
--- /dev/null
+++ b/libs/QtMate/flow/flowNode.cpp
@@ -0,0 +1,350 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowNode.hpp"
+#include "QtMate/flow/flowInput.hpp"
+#include "QtMate/flow/flowOutput.hpp"
+#include "QtMate/flow/flowConnection.hpp"
+#include "QtMate/flow/flowSceneDelegate.hpp"
+#include "QtMate/flow/flowStyle.hpp"
+
+#include <QGraphicsSceneMouseEvent>
+
+namespace qtMate::flow
+{
+class FlowNodeHeader : public QGraphicsItem
+{
+public:
+	FlowNodeHeader(QString const& name, QGraphicsItem* parent = nullptr)
+		: QGraphicsItem{ parent }
+		, _name{ name }
+	{
+	}
+
+	virtual QRectF boundingRect() const override
+	{
+		return QRectF{ 0.f, 0.f, NODE_WIDTH, NODE_HEADER_HEIGHT };
+	}
+
+	virtual void paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget) override
+	{
+		auto const r = boundingRect();
+
+		painter->setPen(NODE_TEXT_COLOR);
+		painter->setBrush(Qt::NoBrush);
+		drawElidedText(painter, r, Qt::AlignCenter, Qt::ElideMiddle, _name);
+	}
+
+private:
+	QString _name{};
+};
+
+
+FlowNode::FlowNode(FlowSceneDelegate* delegate, FlowNodeUid const& uid, FlowNodeDescriptor const& descriptor, QGraphicsItem* parent)
+	: QGraphicsItem{ parent }
+	, _delegate{ delegate }
+	, _uid{ uid }
+	, _name{ descriptor.name }
+	, _header{ new FlowNodeHeader{ _name, this } }
+{
+	Q_ASSERT(_delegate && "FlowSceneDelegate is required");
+
+	setFlag(QGraphicsItem::ItemIsMovable, true);
+	setFlag(QGraphicsItem::ItemIsSelectable, true);
+	setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
+	setFlag(QGraphicsItem::ItemDoesntPropagateOpacityToChildren, true);
+	setOpacity(0.65f);
+	setAcceptHoverEvents(true);
+	setZValue(0.f);
+
+
+	for (auto const& descriptor : descriptor.inputs)
+	{
+		auto const index = static_cast<FlowSocketIndex>(_inputs.size());
+		auto* input = _inputs.emplace_back(new FlowInput{ this, index, descriptor });
+		input->setColor(_delegate->socketTypeColor(input->descriptor().type));
+	}
+
+	for (auto const& descriptor : descriptor.outputs)
+	{
+		auto const index = static_cast<FlowSocketIndex>(_outputs.size());
+		auto* output = _outputs.emplace_back(new FlowOutput{ this, index, descriptor });
+		output->setColor(_delegate->socketTypeColor(output->descriptor().type));
+	}
+
+	// collapse animation configuration
+	_collapseAnimation.setDuration(350);
+	_collapseAnimation.setStartValue(1.f);
+	_collapseAnimation.setEndValue(0.f);
+	_collapseAnimation.setEasingCurve(QEasingCurve::Type::OutQuart);
+
+	QObject::connect(&_collapseAnimation, &QVariantAnimation::valueChanged,
+		[this](QVariant const& value)
+		{
+			_collapseRatio = value.toFloat();
+			updateSockets();
+			prepareGeometryChange();
+		});
+
+	updateSockets();
+}
+
+FlowNode::~FlowNode() = default;
+
+FlowNodeUid const& FlowNode::uid() const
+{
+	return _uid;
+}
+
+QString const& FlowNode::name() const
+{
+	return _name;
+}
+
+FlowInputs const& FlowNode::inputs() const
+{
+	return _inputs;
+}
+
+FlowOutputs const& FlowNode::outputs() const
+{
+	return _outputs;
+}
+
+bool FlowNode::isCollapsed() const
+{
+	return _collapsed;
+}
+
+
+FlowInput* FlowNode::input(FlowSocketIndex index) const
+{
+	if (index < 0 || index >= _inputs.size())
+	{
+		return nullptr;
+	}
+	return _inputs[index];
+}
+
+FlowOutput* FlowNode::output(FlowSocketIndex index) const
+{
+	if (index < 0 || index >= _outputs.size())
+	{
+		return nullptr;
+	}
+	return _outputs[index];
+}
+
+bool FlowNode::hasConnectedInput() const
+{
+	for (auto* input : _inputs)
+	{
+		if (input->isConnected())
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool FlowNode::hasConnectedOutput() const
+{
+	for (auto* output : _outputs)
+	{
+		if (output->isConnected())
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+int FlowNode::type() const
+{
+	return Type;
+}
+
+QRectF FlowNode::boundingRect() const
+{
+	return animatedBoundingRect();
+}
+
+QRectF FlowNode::animatedBoundingRect() const
+{
+	auto const n = std::max(_inputs.size(), _outputs.size());
+	return QRectF{ 0.f, 0.f, NODE_WIDTH, NODE_HEADER_HEIGHT + collapseRatio(true) * (NODE_HEADER_SEPARATOR_HEIGHT + NODE_SOCKET_AREA_INSET_TOP + n * NODE_LINE_HEIGHT + NODE_SOCKET_AREA_INSET_BOTTOM) };
+}
+
+QRectF FlowNode::fixedBoundingRect() const
+{
+	auto const n = std::max(_inputs.size(), _outputs.size());
+	return QRectF{ 0.f, 0.f, NODE_WIDTH, NODE_HEADER_HEIGHT + collapseRatio(false) * (NODE_HEADER_SEPARATOR_HEIGHT + NODE_SOCKET_AREA_INSET_TOP + n * NODE_LINE_HEIGHT + NODE_SOCKET_AREA_INSET_BOTTOM) };
+}
+
+void FlowNode::paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget)
+{
+	auto const r = boundingRect();
+
+	// header
+	auto headerBoundingRect = r;
+	headerBoundingRect.setHeight(NODE_HEADER_HEIGHT);
+
+	painter->setPen(Qt::NoPen);
+
+	if (isSelected())
+	{
+		painter->setBrush(NODE_SELECTED_HEADER_COLOR);
+	}
+	else
+	{
+		painter->setBrush(NODE_HEADER_COLOR);
+	}
+
+	drawRoundedRect(painter, headerBoundingRect, TopLeft | TopRight, NODE_BORDER_RADIUS);
+
+	auto headerHotSpotColor = _delegate->socketTypeColor(0); // FIXME
+	headerHotSpotColor.setAlphaF(1.f - _collapseRatio);
+
+	// inputs
+	if (!_inputs.empty())
+	{
+		auto const inputHotSpotCenter = QRectF{ 0.f, 0.f, NODE_SOCKET_BOUNDING_SIZE, headerBoundingRect.height() }.center();
+		drawOutputHotSpot(painter, inputHotSpotCenter, headerHotSpotColor, hasConnectedInput());
+	}
+
+	// outputs
+	if (!_outputs.empty())
+	{
+		auto const outputHotSpotCenter = QRectF{ headerBoundingRect.right() - NODE_SOCKET_BOUNDING_SIZE, 0.f, NODE_SOCKET_BOUNDING_SIZE, headerBoundingRect.height() }.center();
+		drawOutputHotSpot(painter, outputHotSpotCenter, headerHotSpotColor, hasConnectedOutput());
+	}
+
+	// Draw socket area
+	auto color = NODE_SOCKET_AREA_COLOR;
+	color.setAlphaF(_collapseRatio);
+	painter->setPen(Qt::NoPen);
+	painter->setBrush(color);
+	auto socketAreaBoundingRect = r;
+	auto const socketAreaTopPosition = NODE_HEADER_HEIGHT + NODE_HEADER_SEPARATOR_HEIGHT;
+	socketAreaBoundingRect.moveTop(socketAreaTopPosition);
+	socketAreaBoundingRect.setHeight(r.height() - socketAreaTopPosition);
+	drawRoundedRect(painter, socketAreaBoundingRect, BottomLeft | BottomRight, NODE_BORDER_RADIUS);
+}
+
+QVariant FlowNode::itemChange(GraphicsItemChange change, QVariant const& value)
+{
+	if (change == GraphicsItemChange::ItemPositionHasChanged)
+	{
+		handleItemPositionHasChanged();
+	}
+	else if (change == GraphicsItemChange::ItemSelectedHasChanged)
+	{
+		handleItemSelectionHasChanged();
+	}
+
+	return QGraphicsItem::itemChange(change, value);
+}
+
+void FlowNode::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
+{
+	if (_header->contains(event->pos()))
+	{
+		toggleCollapsed();
+	}
+
+	QGraphicsItem::mouseDoubleClickEvent(event);
+}
+
+void FlowNode::toggleCollapsed()
+{
+	setCollapsed(!_collapsed);
+}
+
+void FlowNode::setCollapsed(bool collapsed)
+{
+	if (collapsed == _collapsed)
+	{
+		return;
+	}
+
+	_collapsed = collapsed;
+
+	_collapseAnimation.stop();
+	_collapseAnimation.setStartValue(_collapseRatio);
+
+	if (_collapsed)
+	{
+		_collapseAnimation.setEndValue(0.f);
+	}
+	else
+	{
+		_collapseAnimation.setEndValue(1.f);
+	}
+
+	_collapseAnimation.start(QAbstractAnimation::DeletionPolicy::KeepWhenStopped);
+
+	emit collapsedChanged();
+}
+
+void FlowNode::handleItemPositionHasChanged()
+{
+	for (auto* input : _inputs)
+	{
+		input->updateConnection();
+	}
+
+	for (auto* output : _outputs)
+	{
+		output->updateConnections();
+	}
+}
+
+void FlowNode::handleItemSelectionHasChanged()
+{
+	setZValue(isSelected() ? 1.f : 0.f);
+}
+
+void FlowNode::updateSockets()
+{
+	auto const firstSocketTopPosition = NODE_HEADER_HEIGHT + NODE_HEADER_SEPARATOR_HEIGHT + NODE_SOCKET_AREA_INSET_TOP;
+	for (auto* input : _inputs)
+	{
+		auto const index = input->index();
+		input->setPos(0, _collapseRatio * (firstSocketTopPosition + index * NODE_LINE_HEIGHT));
+		input->setOpacity(_collapseRatio);
+	}
+
+	for (auto* output : _outputs)
+	{
+		auto const index = output->index();
+		output->setPos(0, _collapseRatio * (firstSocketTopPosition + index * NODE_LINE_HEIGHT));
+		output->setOpacity(_collapseRatio);
+	}
+
+	handleItemPositionHasChanged();
+}
+
+float FlowNode::collapseRatio(bool animated) const
+{
+	return animated ? _collapseRatio : (_collapsed ? 0.f : 1.f);
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/flow/flowOutput.cpp b/libs/QtMate/flow/flowOutput.cpp
new file mode 100644
index 00000000..08333799
--- /dev/null
+++ b/libs/QtMate/flow/flowOutput.cpp
@@ -0,0 +1,104 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowOutput.hpp"
+#include "QtMate/flow/flowConnection.hpp"
+#include "QtMate/flow/flowStyle.hpp"
+
+#include <QPainter>
+
+namespace qtMate::flow
+{
+FlowOutput::~FlowOutput()
+{
+	for (auto* connection : _connections)
+	{
+		connection->setOutput(nullptr);
+	}
+	_connections.clear();
+}
+
+int FlowOutput::type() const
+{
+	return Type;
+}
+
+QRectF FlowOutput::boundingRect() const
+{
+	auto const availableWidth = parentItem()->boundingRect().width();
+	return QRectF{ 0.f, 0.f, availableWidth, NODE_LINE_HEIGHT };
+}
+
+bool FlowOutput::isConnected() const
+{
+	return !_connections.empty();
+}
+
+QRectF FlowOutput::hotSpotBoundingRect() const
+{
+	auto const r = boundingRect();
+	return QRectF{ r.right() - NODE_SOCKET_BOUNDING_SIZE, 0.f, NODE_SOCKET_BOUNDING_SIZE, r.height() };
+}
+
+void FlowOutput::addConnection(FlowConnection* connection)
+{
+	if (_connections.contains(connection))
+	{
+		return;
+	}
+	_connections.insert(connection);
+	update();
+}
+
+void FlowOutput::removeConnection(FlowConnection* connection)
+{
+	if (!_connections.contains(connection))
+	{
+		return;
+	}
+	_connections.remove(connection);
+	update();
+}
+
+FlowConnections const& FlowOutput::connections() const
+{
+	return _connections;
+}
+
+void FlowOutput::updateConnections()
+{
+	for (auto* connection : _connections)
+	{
+		connection->updatePath();
+	}
+}
+
+void FlowOutput::paint(QPainter* painter, QStyleOptionGraphicsItem const* option, QWidget* widget)
+{
+	auto const hotSpot = hotSpotBoundingRect().center();
+	drawOutputHotSpot(painter, hotSpot, _color, isConnected());
+
+	auto const nameBoundingRect = boundingRect().adjusted(0.f, 0.f, -NODE_SOCKET_BOUNDING_SIZE, 0.f);
+
+	painter->setPen(NODE_TEXT_COLOR);
+	painter->setBrush(Qt::NoBrush);
+	drawElidedText(painter, nameBoundingRect, Qt::AlignVCenter | Qt::AlignRight, Qt::TextElideMode::ElideMiddle, _descriptor.name);
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/flow/flowScene.cpp b/libs/QtMate/flow/flowScene.cpp
new file mode 100644
index 00000000..f0abcdad
--- /dev/null
+++ b/libs/QtMate/flow/flowScene.cpp
@@ -0,0 +1,278 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowScene.hpp"
+#include "QtMate/flow/flowSceneDelegate.hpp"
+#include "QtMate/flow/flowNode.hpp"
+#include "QtMate/flow/flowConnection.hpp"
+#include "QtMate/flow/flowInput.hpp"
+#include "QtMate/flow/flowOutput.hpp"
+#include "QtMate/flow/flowStyle.hpp"
+
+namespace qtMate::flow
+{
+namespace
+{
+void ancestors(FlowNode* node, QSet<FlowNode*>& set)
+{
+	for (auto* input : node->inputs())
+	{
+		if (auto* connection = input->connection())
+		{
+			if (connection->output())
+			{
+				auto* parent = connection->output()->node();
+				if (!set.contains(parent))
+				{
+					set.insert(parent);
+					ancestors(parent, set);
+				}
+			}
+		}
+	}
+}
+
+void descendants(FlowNode* node, QSet<FlowNode*>& set)
+{
+	for (auto* output : node->outputs())
+	{
+		if (output->isConnected())
+		{
+			for (auto* connection : output->connections())
+			{
+				if (connection->input())
+				{
+					auto* child = connection->input()->node();
+					if (!set.contains(child))
+					{
+						set.insert(child);
+						descendants(child, set);
+					}
+				}
+			}
+		}
+	}
+}
+
+} // namespace
+
+FlowScene::FlowScene(FlowSceneDelegate* delegate, QObject* parent)
+	: QGraphicsScene{ parent }
+	, _delegate{ delegate }
+{
+	Q_ASSERT(_delegate && "FlowSceneDelegate is required");
+}
+
+FlowScene::~FlowScene() = default;
+
+FlowNode* FlowScene::createNode(FlowNodeUid const& uid, FlowNodeDescriptor const& descriptor)
+{
+	if (_nodes.contains(uid))
+	{
+		return nullptr;
+	}
+
+	auto* node = new FlowNode{ _delegate, uid, descriptor };
+	_nodes.insert(uid, node);
+
+	addItem(node);
+
+	emit nodeCreated(uid);
+
+	connect(node, &FlowNode::collapsedChanged, this, &FlowScene::layoutRequested);
+
+	return node;
+}
+
+void FlowScene::destroyNode(FlowNodeUid const& uid)
+{
+	if (auto* node = _nodes.value(uid))
+	{
+		for (auto* input : node->inputs())
+		{
+			if (input->isConnected())
+			{
+				destroyConnection(input->connection()->descriptor());
+			}
+		}
+
+		for (auto* output : node->outputs())
+		{
+			if (output->isConnected())
+			{
+				for (auto* connection : output->connections())
+				{
+					destroyConnection(connection->descriptor());
+				}
+			}
+		}
+
+		removeItem(node);
+
+		_nodes.remove(uid);
+		delete node;
+
+		emit nodeDestroyed(uid);
+	}
+}
+
+FlowConnection* FlowScene::createConnection(FlowConnectionDescriptor const& descriptor)
+{
+	if (_connections.contains(descriptor))
+	{
+		return nullptr;
+	}
+
+	auto [source, sink] = sockets(descriptor);
+
+	if (!canConnect(source, sink))
+	{
+		qWarning() << "invalid connection";
+		return nullptr;
+	}
+
+	if (sink->isConnected())
+	{
+		destroyConnection(sink->connection()->descriptor());
+	}
+
+	auto* connection = new FlowConnection{};
+
+	connection->setPen(NODE_CONNECTION_PEN);
+	connection->setOutput(source);
+	connection->setInput(sink);
+
+	_connections.insert(descriptor, connection);
+
+	addItem(connection);
+
+	emit connectionCreated(descriptor);
+
+	return connection;
+}
+
+void FlowScene::destroyConnection(FlowConnectionDescriptor const& descriptor)
+{
+	if (auto* connection = _connections.value(descriptor))
+	{
+		removeItem(connection);
+		delete connection;
+
+		_connections.remove(descriptor);
+
+		emit connectionDestroyed(descriptor);
+	}
+}
+
+QVector<FlowNode*> FlowScene::nodes() const
+{
+	return _nodes.values();
+}
+
+QVector<FlowConnection*> FlowScene::connections() const
+{
+	return _connections.values();
+}
+
+FlowNode* FlowScene::node(FlowNodeUid const& uid) const
+{
+	return _nodes.value(uid);
+}
+
+FlowInput* FlowScene::input(FlowSocketSlot const& slot) const
+{
+	if (auto* n = node(slot.first))
+	{
+		return n->input(slot.second);
+	}
+	return nullptr;
+}
+
+FlowOutput* FlowScene::output(FlowSocketSlot const& slot) const
+{
+	if (auto* n = node(slot.first))
+	{
+		return n->output(slot.second);
+	}
+	return nullptr;
+}
+
+FlowConnection* FlowScene::connection(FlowConnectionDescriptor const& descriptor) const
+{
+	return _connections.value(descriptor);
+}
+
+bool FlowScene::canConnect(FlowOutput* output, FlowInput* input) const
+{
+	if (!output || !input)
+	{
+		return false;
+	}
+
+	if (output->node() == input->node())
+	{
+		return false;
+	}
+
+	auto outputHierarchy = QSet<FlowNode*>{};
+	ancestors(output->node(), outputHierarchy);
+	if (outputHierarchy.contains(input->node()))
+	{
+		return false;
+	}
+
+	auto inputHierarchy = QSet<FlowNode*>{};
+	descendants(input->node(), inputHierarchy);
+	if (inputHierarchy.contains(output->node()))
+	{
+		return false;
+	}
+
+	return _delegate->canConnect(output, input);
+}
+
+bool FlowScene::canConnect(FlowConnectionDescriptor const& descriptor) const
+{
+	auto [source, sink] = sockets(descriptor);
+	return canConnect(source, sink);
+}
+
+QColor FlowScene::socketTypeColor(FlowSocketType type) const
+{
+	return _delegate->socketTypeColor(type);
+}
+
+std::pair<FlowOutput*, FlowInput*> FlowScene::sockets(FlowConnectionDescriptor const& descriptor) const
+{
+	auto* source = output(descriptor.first);
+	if (!source)
+	{
+		qWarning() << "invalid source";
+	}
+
+	auto* sink = input(descriptor.second);
+	if (!sink)
+	{
+		qWarning() << "invalid sink";
+	}
+
+	return std::make_pair(source, sink);
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/flow/flowSceneDelegate.cpp b/libs/QtMate/flow/flowSceneDelegate.cpp
new file mode 100644
index 00000000..661a78a8
--- /dev/null
+++ b/libs/QtMate/flow/flowSceneDelegate.cpp
@@ -0,0 +1,37 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowSceneDelegate.hpp"
+#include "QtMate/flow/flowSocket.hpp"
+#include "QtMate/flow/flowInput.hpp"
+#include "QtMate/flow/flowOutput.hpp"
+
+namespace qtMate::flow
+{
+QColor FlowSceneDelegate::socketTypeColor(FlowSocketType type) const
+{
+	return Qt::darkGray;
+}
+
+bool FlowSceneDelegate::canConnect(FlowOutput* output, FlowInput* input) const
+{
+	return output->descriptor().type == input->descriptor().type;
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/flow/flowSocket.cpp b/libs/QtMate/flow/flowSocket.cpp
new file mode 100644
index 00000000..5f771303
--- /dev/null
+++ b/libs/QtMate/flow/flowSocket.cpp
@@ -0,0 +1,80 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowSocket.hpp"
+#include "QtMate/flow/flowNode.hpp"
+
+namespace qtMate::flow
+{
+FlowSocket::FlowSocket(FlowNode* node, FlowSocketIndex index, FlowSocketDescriptor const& descriptor)
+	: QGraphicsItem{ node }
+	, _node{ node }
+	, _index{ index }
+	, _descriptor{ descriptor }
+{
+}
+
+FlowSocket::~FlowSocket() = default;
+
+FlowNode* FlowSocket::node() const
+{
+	return _node;
+}
+
+FlowSocketIndex FlowSocket::index() const
+{
+	return _index;
+}
+
+FlowSocketDescriptor const& FlowSocket::descriptor() const
+{
+	return _descriptor;
+}
+
+FlowSocketSlot FlowSocket::slot() const
+{
+	return FlowSocketSlot{ _node->uid(), _index };
+}
+
+QColor const& FlowSocket::color() const
+{
+	return _color;
+}
+
+void FlowSocket::setColor(QColor const& color)
+{
+	if (color != _color)
+	{
+		_color = color;
+		update();
+	}
+}
+
+bool FlowSocket::hit(QPointF const& scenePos) const
+{
+	auto const localPos = mapFromScene(scenePos);
+	return boundingRect().contains(localPos);
+}
+
+QPointF FlowSocket::hotSpotSceneCenter() const
+{
+	return mapToScene(hotSpotBoundingRect().center());
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/flow/flowStyle.cpp b/libs/QtMate/flow/flowStyle.cpp
new file mode 100644
index 00000000..b4fa81cf
--- /dev/null
+++ b/libs/QtMate/flow/flowStyle.cpp
@@ -0,0 +1,136 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowStyle.hpp"
+#include "QtMate/flow/flowNode.hpp"
+
+#include <QPainter>
+#include <QPainterPath>
+
+namespace qtMate::flow
+{
+void drawRoundedRect(QPainter* painter, float x, float y, float width, float height, Qt::Edges const edges, float radius)
+{
+	QPolygonF polygon;
+
+	if (edges.testFlags(TopLeft))
+	{
+		polygon << QPointF{ x, y + radius } << QPointF{ x + radius, y + radius } << QPointF{ x + radius, y };
+	}
+	else
+	{
+		polygon << QPointF{ x, y };
+	}
+
+	if (edges.testFlags(TopRight))
+	{
+		polygon << QPointF{ x + width - radius, y } << QPointF{ x + width - radius, y + radius } << QPointF{ x + width, y + radius };
+	}
+	else
+	{
+		polygon << QPointF{ x + width, y };
+	}
+
+	if (edges.testFlags(BottomRight))
+	{
+		polygon << QPointF{ x + width, y + height - radius } << QPointF{ x + width - radius, y + height - radius } << QPointF{ x + width - radius, y + height };
+	}
+	else
+	{
+		polygon << QPointF{ x + width, y + height };
+	}
+
+	if (edges.testFlags(BottomLeft))
+	{
+		polygon << QPointF{ x + radius, y + height } << QPointF{ x + radius, y + height - radius } << QPointF{ x, y + height - radius };
+	}
+	else
+	{
+		polygon << QPointF{ x, y + height };
+	}
+
+	QPainterPath painterPath;
+	painterPath.addPolygon(polygon);
+	painter->drawPath(painterPath);
+
+	auto const d = 2 * radius;
+	auto const step = 16 * 90;
+
+	if (edges.testFlags(TopLeft))
+	{
+		painter->drawPie(x, y, d, d, step, step);
+	}
+
+	if (edges.testFlags(TopRight))
+	{
+		painter->drawPie(x + width - d, y, d, d, 4 * step, step);
+	}
+
+	if (edges.testFlags(BottomRight))
+	{
+		painter->drawPie(x + width - d, y + height - d, d, d, 3 * step, step);
+	}
+
+	if (edges.testFlags(BottomLeft))
+	{
+		painter->drawPie(x, y + height - d, d, d, 2 * step, step);
+	}
+}
+
+void drawRoundedRect(QPainter* painter, QRectF const& r, Qt::Edges const edges, float radius)
+{
+	drawRoundedRect(painter, r.x(), r.y(), r.width(), r.height(), edges, radius);
+}
+
+void drawElidedText(QPainter* painter, QRectF const& r, int flags, Qt::TextElideMode mode, QString const& text)
+{
+	auto const fontMetrics = QFontMetrics{ painter->font() };
+	auto const elidedText = fontMetrics.elidedText(text, mode, r.width(), flags);
+	painter->drawText(r, flags, elidedText);
+}
+
+void drawOutputHotSpot(QPainter* painter, QPointF const& hotSpot, QColor const& color, bool connected)
+{
+	painter->setPen(color);
+	painter->setBrush(Qt::NoBrush);
+	painter->drawEllipse(hotSpot, NODE_SOCKET_RADIUS, NODE_SOCKET_RADIUS);
+
+	if (connected)
+	{
+		painter->setPen(Qt::NoPen);
+		painter->setBrush(color);
+		painter->drawEllipse(hotSpot, NODE_SOCKET_RADIUS / 2, NODE_SOCKET_RADIUS / 2);
+	}
+}
+
+void drawInputHotSpot(QPainter* painter, QPointF const& hotSpot, QColor const& color, bool connected)
+{
+	painter->setPen(color);
+	painter->setBrush(Qt::NoBrush);
+	painter->drawEllipse(hotSpot, NODE_SOCKET_RADIUS, NODE_SOCKET_RADIUS);
+
+	if (connected)
+	{
+		painter->setPen(Qt::NoPen);
+		painter->setBrush(color);
+		painter->drawEllipse(hotSpot, NODE_SOCKET_RADIUS / 2, NODE_SOCKET_RADIUS / 2);
+	}
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/flow/flowView.cpp b/libs/QtMate/flow/flowView.cpp
new file mode 100644
index 00000000..45c1e022
--- /dev/null
+++ b/libs/QtMate/flow/flowView.cpp
@@ -0,0 +1,532 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "QtMate/flow/flowView.hpp"
+#include "QtMate/flow/flowScene.hpp"
+#include "QtMate/flow/flowNode.hpp"
+#include "QtMate/flow/flowInput.hpp"
+#include "QtMate/flow/flowOutput.hpp"
+#include "QtMate/flow/flowConnection.hpp"
+#include "QtMate/flow/flowStyle.hpp"
+
+#include <QMouseEvent>
+#include <QScrollBar>
+
+#include <optional>
+
+namespace qtMate::flow
+{
+FlowView::FlowView(FlowScene* scene, QWidget* parent)
+	: QGraphicsView{ scene, parent }
+	, _scene{ scene }
+{
+	setRenderHint(QPainter::Antialiasing);
+	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+	setDragMode(DragMode::NoDrag);
+	setRenderHint(QPainter::Antialiasing);
+	setScene(_scene);
+
+	_elapsedTimer.start();
+	_animationTimerId = startTimer(std::chrono::milliseconds{ 16 }, Qt::TimerType::CoarseTimer);
+
+	// configure animations
+	_centerOnAnimation = new QVariantAnimation{ this };
+	_centerOnAnimation->setDuration(800);
+	_centerOnAnimation->setEasingCurve(QEasingCurve::Type::OutQuart);
+	connect(_centerOnAnimation, &QVariantAnimation::valueChanged, this,
+		[this](QVariant const& value)
+		{
+			centerOn(value.toPointF());
+		});
+}
+
+FlowView::~FlowView() = default;
+
+void FlowView::animatedCenterOn(QPointF const& scenePos)
+{
+	auto const width = viewport()->width();
+	auto const height = viewport()->height();
+	auto const startValue = mapToScene(QPoint{ width / 2, height / 2 });
+	auto const endValue = scenePos;
+
+	_centerOnAnimation->stop();
+	_centerOnAnimation->setStartValue(startValue);
+	_centerOnAnimation->setEndValue(endValue);
+	_centerOnAnimation->start(QAbstractAnimation::DeletionPolicy::KeepWhenStopped);
+}
+
+void FlowView::mousePressEvent(QMouseEvent* event)
+{
+	if (!handleMousePressEvent(event))
+	{
+		QGraphicsView::mousePressEvent(event);
+	}
+}
+
+void FlowView::mouseMoveEvent(QMouseEvent* event)
+{
+	if (!handleMouseMoveEvent(event))
+	{
+		QGraphicsView::mouseMoveEvent(event);
+	}
+}
+
+void FlowView::mouseReleaseEvent(QMouseEvent* event)
+{
+	if (!handleMouseReleaseEvent(event))
+	{
+		QGraphicsView::mouseReleaseEvent(event);
+	}
+}
+
+void FlowView::wheelEvent(QWheelEvent* event)
+{
+	if (!handleWheelEvent(event))
+	{
+		QGraphicsView::wheelEvent(event);
+	}
+}
+
+void FlowView::timerEvent(QTimerEvent* event)
+{
+	if (!handleTimerEvent(event))
+	{
+		QGraphicsView::timerEvent(event);
+	}
+}
+
+bool FlowView::handleMousePressEvent(QMouseEvent* event)
+{
+	if (event->button() != Qt::LeftButton)
+	{
+		return false;
+	}
+
+	auto const scenePos = mapToScene(event->pos());
+	if (auto* socket = socketAt(scenePos))
+	{
+		// save current socket type, in order to apply the appropriate color to the links
+		_tmpSocketType = socket->descriptor().type;
+
+		// check whether we want to create or move existing connections (only applies to outputs)
+		auto const isOutputSocket = socket->type() == FlowOutput::Type;
+		auto const hasMoveModifier = event->modifiers().testFlag(Qt::ControlModifier);
+		auto const skipChange = isOutputSocket && !hasMoveModifier;
+
+		if (socket->isConnected() && !skipChange)
+		{
+			if (socket->type() == FlowInput::Type)
+			{
+				_mode = ConnectionMode::ChangeInput;
+				auto* input = qgraphicsitem_cast<FlowInput*>(socket);
+				if (auto* connection = input->connection())
+				{
+					createLinkFromConnection(connection);
+					_slots.insert(connection->output()->slot());
+				}
+			}
+			else
+			{
+				_mode = ConnectionMode::ChangeOutput;
+				auto* output = qgraphicsitem_cast<FlowOutput*>(socket);
+				for (auto* connection : output->connections())
+				{
+					createLinkFromConnection(connection);
+					_slots.insert(connection->input()->slot());
+				}
+			}
+		}
+		else
+		{
+			_tmpConnection.reset(new FlowConnection);
+			_slots.insert(socket->slot());
+
+			if (socket->type() == FlowInput::Type)
+			{
+				_mode = ConnectionMode::ConnectToOutput;
+				_tmpConnection->setInput(qgraphicsitem_cast<FlowInput*>(socket));
+			}
+			else
+			{
+				_mode = ConnectionMode::ConnectToInput;
+				_tmpConnection->setOutput(qgraphicsitem_cast<FlowOutput*>(socket));
+			}
+
+			auto* link = createLinkFromConnection(nullptr);
+			auto const pos = socket->hotSpotSceneCenter();
+			link->setStart(pos);
+			link->setStop(pos);
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+bool FlowView::handleMouseMoveEvent(QMouseEvent* event)
+{
+	if (_mode == ConnectionMode::Undefined)
+	{
+		return false;
+	}
+
+	auto const scenePos = mapToScene(event->pos());
+	switch (_mode)
+	{
+		case ConnectionMode::ChangeInput:
+		case ConnectionMode::ConnectToInput:
+			for (auto* link : _links)
+			{
+				link->setStop(scenePos);
+			}
+			break;
+		case ConnectionMode::ChangeOutput:
+		case ConnectionMode::ConnectToOutput:
+			for (auto* link : _links)
+			{
+				link->setStart(scenePos);
+			}
+			break;
+		default:
+			break;
+	}
+
+	if (auto* socket = socketAt(scenePos))
+	{
+		if (canConnect(socket))
+		{
+			setCursor(Qt::CursorShape::DragMoveCursor);
+		}
+		else
+		{
+			setCursor(Qt::CursorShape::ForbiddenCursor);
+		}
+	}
+	else
+	{
+		setCursor(Qt::CursorShape::ArrowCursor);
+	}
+
+	// if the mouse is close to an edge of the viewport, try to scroll
+	auto const margin = 20;
+	auto const step = 5;
+
+	// build an adjusted rect from the viewport
+	auto const pos = event->pos();
+	auto const rect = viewport()->geometry().adjusted(margin, margin, -2 * margin, -2 * margin);
+
+	auto dx = 0;
+	auto dy = 0;
+
+	// check if the mouse is close to the viewport borders
+	if (pos.x() <= rect.left())
+	{
+		dx -= step;
+	}
+	else if (pos.x() >= rect.right())
+	{
+		dx += step;
+	}
+
+	if (pos.y() <= rect.top())
+	{
+		dy -= step;
+	}
+	else if (pos.y() >= rect.bottom())
+	{
+		dy += step;
+	}
+
+	// apply scroll delta if any
+	horizontalScrollBar()->setValue(horizontalScrollBar()->value() + dx);
+	verticalScrollBar()->setValue(verticalScrollBar()->value() + dy);
+
+	return true;
+}
+
+bool FlowView::handleMouseReleaseEvent(QMouseEvent* event)
+{
+	if (event->button() != Qt::LeftButton)
+	{
+		return false;
+	}
+
+	if (_mode == ConnectionMode::Undefined)
+	{
+		return false;
+	}
+
+	// clear tmp connection
+	_tmpSocketType = 0;
+	_tmpConnection.reset();
+
+	// gather the list of connections that needs to be created
+	auto descriptors = FlowConnectionDescriptors{};
+	auto maybeNodeUid = std::optional<FlowNodeUid>{};
+
+	auto const scenePos = mapToScene(event->pos());
+	if (auto* socket = socketAt(scenePos))
+	{
+		maybeNodeUid = socket->node()->uid();
+		switch (_mode)
+		{
+			case ConnectionMode::ChangeInput:
+			case ConnectionMode::ConnectToInput:
+				if (socket->type() == FlowInput::Type)
+				{
+					auto* input = qgraphicsitem_cast<FlowInput*>(socket);
+					for (auto const& slot : _slots)
+					{
+						descriptors.insert({ slot, input->slot() });
+					}
+				}
+				break;
+			case ConnectionMode::ChangeOutput:
+			case ConnectionMode::ConnectToOutput:
+				if (socket->type() == FlowOutput::Type)
+				{
+					auto* output = qgraphicsitem_cast<FlowOutput*>(socket);
+					for (auto const& slot : _slots)
+					{
+						descriptors.insert({ output->slot(), slot });
+					}
+				}
+				break;
+			default:
+				break;
+		}
+	}
+
+	// sanity check, all connections must be valid, otherwise do nothing and restore previous state
+	auto const valid = std::all_of(std::begin(descriptors), std::end(descriptors),
+		[this](FlowConnectionDescriptor const& descriptor)
+		{
+			return _scene->canConnect(descriptor);
+		});
+
+	if (valid)
+	{
+		// avoid re-creating existing connections
+		for (auto* connection : _connections)
+		{
+			auto const descriptor = connection->descriptor();
+			// spotted already existing connection
+			if (descriptors.contains(descriptor))
+			{
+				// remove it from the list of connections to create
+				descriptors.remove(descriptor);
+				// reset opacity
+				connection->setOpacity(1.f);
+			}
+			else
+			{
+				_scene->destroyConnection(descriptor);
+			}
+		}
+		_connections.clear();
+
+		// create new connections
+		for (auto const& descriptor : descriptors)
+		{
+			_scene->createConnection(descriptor);
+		}
+	}
+	else
+	{
+		// reset connection opacity
+		for (auto* connection : _connections)
+		{
+			connection->setOpacity(1.f);
+		}
+		_connections.clear();
+
+		// if over a node, shake it up to notify the user of failure
+		if (maybeNodeUid)
+		{
+			auto* animation = new QVariantAnimation{ this };
+			animation->setDuration(800);
+			animation->setEasingCurve(QEasingCurve::Type::Linear);
+			animation->setKeyValueAt(0.1, QPoint{ +4, 0 });
+			animation->setKeyValueAt(0.2, QPoint{ -4, 0 });
+			animation->setKeyValueAt(0.3, QPoint{ +4, 0 });
+			animation->setKeyValueAt(0.4, QPoint{ -4, 0 });
+			animation->setKeyValueAt(0.5, QPoint{ +4, 0 });
+			animation->setKeyValueAt(0.6, QPoint{ -4, 0 });
+			animation->setKeyValueAt(0.7, QPoint{ +4, 0 });
+			animation->setKeyValueAt(0.8, QPoint{ -4, 0 });
+			animation->setKeyValueAt(0.9, QPoint{ +4, 0 });
+			animation->setKeyValueAt(1.0, QPoint{ -4, 0 });
+
+			// caution, pass the node uid and retrieve it in the lambda cause the node may have been deleted
+			connect(animation, &QVariantAnimation::valueChanged, this,
+				[this, uid = *maybeNodeUid](QVariant const& value)
+				{
+					if (auto* n = _scene->node(uid))
+					{
+						n->setPos(n->pos() + value.toPointF());
+					}
+				});
+
+			animation->start(QAbstractAnimation::DeletionPolicy::DeleteWhenStopped);
+		}
+	}
+
+	// clear state
+	qDeleteAll(_links);
+	_links.clear();
+
+	_slots.clear();
+
+	_mode = ConnectionMode::Undefined;
+
+	// reset cursor
+	setCursor(Qt::CursorShape::ArrowCursor);
+
+	return true;
+}
+
+bool FlowView::handleWheelEvent(QWheelEvent* event)
+{
+	if (event->modifiers().testFlag(Qt::KeyboardModifier::ControlModifier))
+	{
+		auto const anchor = transformationAnchor();
+		setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
+		auto const angle = event->angleDelta().y();
+		auto const factor = qPow(1.0015, angle);
+		scale(factor, factor);
+		setTransformationAnchor(anchor);
+		return true;
+	}
+
+	return false;
+}
+
+bool FlowView::handleTimerEvent(QTimerEvent* event)
+{
+	if (event->timerId() != _animationTimerId)
+	{
+		return false;
+	}
+
+	auto const offset = _elapsedTimer.elapsed() / 100.f;
+
+	auto pen = NODE_CONNECTION_PEN;
+	pen.setDashOffset(-offset);
+
+	// default color for volatile connections
+	pen.setColor(_scene->socketTypeColor(_tmpSocketType));
+	for (auto* link : _links)
+	{
+		link->setPen(pen);
+	}
+
+	for (auto* connection : _scene->connections())
+	{
+		pen.setColor(_scene->socketTypeColor(connection->output()->descriptor().type));
+		connection->setPen(pen);
+	}
+
+	return true;
+}
+
+FlowSocket* FlowView::socketAt(QPointF const& scenePos) const
+{
+	for (auto* item : _scene->items(scenePos))
+	{
+		if (auto* input = qgraphicsitem_cast<FlowInput*>(item); input && input->hit(scenePos))
+		{
+			return input;
+		}
+		else if (auto* output = qgraphicsitem_cast<FlowOutput*>(item); output && output->hit(scenePos))
+		{
+			return output;
+		}
+	}
+	return nullptr;
+}
+
+FlowLink* FlowView::createLinkFromConnection(FlowConnection* connection)
+{
+	auto* link = new FlowLink{};
+
+	if (connection)
+	{
+		link->setStart(connection->output()->hotSpotSceneCenter());
+		link->setStop(connection->input()->hotSpotSceneCenter());
+
+		_connections.insert(connection);
+		connection->setOpacity(0.2f);
+	}
+
+	_links.insert(link);
+	_scene->addItem(link);
+
+	return link;
+}
+
+bool FlowView::canConnect(FlowSocket* socket) const
+{
+	switch (_mode)
+	{
+		case ConnectionMode::ConnectToInput:
+			if (socket->type() == FlowInput::Type)
+			{
+				auto* input = qgraphicsitem_cast<FlowInput*>(socket);
+				return _scene->canConnect(_tmpConnection->output(), input);
+			}
+			break;
+		case ConnectionMode::ConnectToOutput:
+			if (socket->type() == FlowOutput::Type)
+			{
+				auto* output = qgraphicsitem_cast<FlowOutput*>(socket);
+				return _scene->canConnect(output, _tmpConnection->input());
+			}
+			break;
+		case ConnectionMode::ChangeInput:
+			if (socket->type() == FlowInput::Type)
+			{
+				auto* input = qgraphicsitem_cast<FlowInput*>(socket);
+				return std::all_of(std::begin(_connections), std::end(_connections),
+					[this, input](FlowConnection* connection)
+					{
+						return _scene->canConnect(connection->output(), input);
+					});
+			}
+			break;
+		case ConnectionMode::ChangeOutput:
+			if (socket->type() == FlowOutput::Type)
+			{
+				auto* output = qgraphicsitem_cast<FlowOutput*>(socket);
+				return std::all_of(std::begin(_connections), std::end(_connections),
+					[this, output](FlowConnection* connection)
+					{
+						return _scene->canConnect(output, connection->input());
+					});
+			}
+			break;
+		default:
+			break;
+	}
+
+	return false;
+}
+
+} // namespace qtMate::flow
diff --git a/libs/QtMate/graph/connection.cpp b/libs/QtMate/graph/connection.cpp
deleted file mode 100644
index 5b99f59b..00000000
--- a/libs/QtMate/graph/connection.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "QtMate/graph/connection.hpp"
-#include "QtMate/graph/inputSocket.hpp"
-#include "QtMate/graph/outputSocket.hpp"
-#include "QtMate/graph/type.hpp"
-
-#include <QPainter>
-
-namespace qtMate
-{
-namespace graph
-{
-ConnectionItem::ConnectionItem()
-{
-	setFlag(QGraphicsItem::ItemIsSelectable);
-	setZValue(-1);
-}
-
-ConnectionItem::~ConnectionItem()
-{
-	disconnect();
-}
-
-void ConnectionItem::setStart(QPointF const& p)
-{
-	_start = p;
-	updatePath();
-}
-
-void ConnectionItem::setStop(QPointF const& p)
-{
-	_stop = p;
-	updatePath();
-}
-
-int ConnectionItem::type() const
-{
-	return ItemType::Connection;
-}
-
-void ConnectionItem::connectInput(InputSocketItem* input)
-{
-	disconnectInput();
-	_input = input;
-	if (_input)
-	{
-		_input->setConnection(this);
-	}
-}
-
-InputSocketItem* ConnectionItem::input() const
-{
-	return _input;
-}
-
-void ConnectionItem::disconnectInput()
-{
-	if (_input)
-	{
-		_input->setConnection(nullptr);
-		_input = nullptr;
-	}
-}
-
-void ConnectionItem::connectOutput(OutputSocketItem* output)
-{
-	disconnectOutput();
-	_output = output;
-	if (_output)
-	{
-		_output->addConnection(this);
-	}
-}
-
-OutputSocketItem* ConnectionItem::output() const
-{
-	return _output;
-}
-
-void ConnectionItem::disconnectOutput()
-{
-	if (_output)
-	{
-		_output->removeConnection(this);
-		_output = nullptr;
-	}
-}
-
-void ConnectionItem::disconnect()
-{
-	disconnectInput();
-	disconnectOutput();
-}
-
-void ConnectionItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
-{
-	QPen pen;
-
-	auto const connected = _input && _output;
-	pen.setStyle(connected ? Qt::SolidLine : Qt::DotLine);
-
-	pen.setWidth(3);
-	pen.setColor(NodeItemColor);
-	painter->setPen(pen);
-	painter->drawPath(path());
-}
-
-void ConnectionItem::updatePath()
-{
-	auto dist = _start.x() - _stop.x();
-
-	auto ratio = 0.5f;
-	auto offset = 0.f;
-
-	if (dist > 0)
-	{
-		ratio = 0.9f;
-		offset = -dist;
-	}
-
-	dist = std::abs(dist);
-
-	QPointF c1(_start.x() + dist * ratio, _start.y() + offset);
-	QPointF c2(_stop.x() - dist * ratio, _stop.y() + offset);
-
-	QPainterPath path(_start);
-	path.cubicTo(c1, c2, _stop);
-	setPath(path);
-}
-
-} // namespace graph
-} // namespace qtMate
diff --git a/libs/QtMate/graph/inputSocket.cpp b/libs/QtMate/graph/inputSocket.cpp
deleted file mode 100644
index 204bdb66..00000000
--- a/libs/QtMate/graph/inputSocket.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "QtMate/graph/inputSocket.hpp"
-#include "QtMate/graph/connection.hpp"
-#include "QtMate/graph/type.hpp"
-
-namespace qtMate
-{
-namespace graph
-{
-InputSocketItem::~InputSocketItem()
-{
-	if (_connection)
-	{
-		_connection->disconnect();
-	}
-}
-
-int InputSocketItem::type() const
-{
-	return ItemType::Input;
-}
-
-void InputSocketItem::updateGeometry()
-{
-	if (_connection)
-	{
-		_connection->setStop(mapToScene(0, 0));
-	}
-}
-
-bool InputSocketItem::isConnected() const
-{
-	return _connection != nullptr;
-}
-
-void InputSocketItem::setConnection(ConnectionItem* connection)
-{
-	_connection = connection;
-	updateGeometry();
-}
-
-ConnectionItem* InputSocketItem::connection() const
-{
-	return _connection;
-}
-
-} // namespace graph
-} // namespace qtMate
diff --git a/libs/QtMate/graph/node.cpp b/libs/QtMate/graph/node.cpp
deleted file mode 100644
index 83853062..00000000
--- a/libs/QtMate/graph/node.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "QtMate/graph/node.hpp"
-#include "QtMate/graph/inputSocket.hpp"
-#include "QtMate/graph/outputSocket.hpp"
-#include "QtMate/graph/type.hpp"
-
-#include <QPainter>
-
-namespace qtMate
-{
-namespace graph
-{
-float const TITLE_HEIGHT = 20.f;
-float const PADDING = 5.f;
-
-NodeItem::NodeItem(int id, QString const& text, QGraphicsItem* parent)
-	: QGraphicsItem(parent)
-	, _id(id)
-	, _text(text)
-{
-	setAcceptHoverEvents(true);
-
-	updateGeometry();
-}
-
-int NodeItem::type() const
-{
-	return ItemType::Node;
-}
-
-void NodeItem::addInput(QString const& text)
-{
-	auto const socketIndex = static_cast<int>(_inputs.size());
-	auto* item = new InputSocketItem(_id, socketIndex, text, this);
-	_inputs.push_back(item);
-	updateGeometry();
-}
-
-void NodeItem::addOutput(QString const& text)
-{
-	auto const socketIndex = static_cast<int>(_outputs.size());
-	auto* item = new OutputSocketItem(_id, socketIndex, text, this);
-	_outputs.push_back(item);
-	updateGeometry();
-}
-
-InputSocketItem* NodeItem::inputAt(int index) const
-{
-	return _inputs.at(index);
-}
-
-OutputSocketItem* NodeItem::outputAt(int index) const
-{
-	return _outputs.at(index);
-}
-
-QRectF NodeItem::boundingRect() const
-{
-	return QRectF{ 0, 0, _width, _height };
-}
-
-void NodeItem::paint(QPainter* painter, QStyleOptionGraphicsItem const* /*option*/, QWidget* /*widget*/)
-{
-	painter->setPen(Qt::NoPen);
-	painter->setBrush(NodeItemColor);
-
-	painter->drawRoundedRect(boundingRect(), 5, 5);
-	painter->drawRect(boundingRect().adjusted(0, TITLE_HEIGHT, 0, 0));
-
-	painter->setBrush(NodeItemColor.lighter());
-	painter->drawRect(boundingRect().adjusted(PADDING / 2, TITLE_HEIGHT, -PADDING / 2, -PADDING / 2));
-
-	auto r = boundingRect().adjusted(PADDING, 0, -PADDING, 0);
-	r.setHeight(TITLE_HEIGHT);
-
-	painter->setPen(TextColor);
-	painter->drawText(r, Qt::AlignHCenter | Qt::AlignVCenter, _text, nullptr);
-}
-
-QVariant NodeItem::itemChange(GraphicsItemChange change, QVariant const& value)
-{
-	if (change == QGraphicsItem::ItemSelectedChange)
-	{
-		setZValue(value.toBool() ? 1 : 0);
-	}
-
-	if (change == QGraphicsItem::ItemPositionChange || change == QGraphicsItem::ItemPositionHasChanged)
-	{
-		propagateChanges();
-	}
-
-	return QGraphicsItem::itemChange(change, value);
-}
-
-void NodeItem::updateGeometry()
-{
-	prepareGeometryChange();
-
-	// Geometry
-
-	auto maxInputWidth{ 0 };
-	auto maxOutputWidth{ 0 };
-
-	for (auto const& input : _inputs)
-	{
-		maxInputWidth = std::max(maxInputWidth, static_cast<int>(input->boundingRect().width()));
-	}
-
-	for (auto const& output : _outputs)
-	{
-		maxOutputWidth = std::max(maxOutputWidth, static_cast<int>(output->boundingRect().width()));
-	}
-
-	QFont font;
-	QFontMetrics fm(font);
-	auto const textHeight = static_cast<float>(fm.height());
-	using QtSizeType = decltype(std::declval<decltype(_inputs)>().size());
-	auto const max = std::max(static_cast<QtSizeType>(1), std::max(_inputs.size(), _outputs.size()));
-	auto const step = textHeight + PADDING * 2;
-
-	_height = step * max;
-	_height += TITLE_HEIGHT;
-
-	_width = std::max(maxInputWidth + PADDING + maxOutputWidth, fm.horizontalAdvance(_text) + PADDING * 2);
-
-	// Input & Outputs
-
-	auto const ystart = TITLE_HEIGHT + PADDING;
-
-	auto ypos1 = ystart;
-	for (auto i = 0; i < static_cast<int>(_inputs.size()); ++i)
-	{
-		auto const size = _inputs[i]->size();
-		_inputs[i]->setPos(0, ypos1 + size.height() / 2.0);
-		ypos1 += step;
-	}
-
-	auto ypos2 = ystart;
-	for (auto i = 0; i < static_cast<int>(_outputs.size()); ++i)
-	{
-		auto const size = _outputs[i]->size();
-		_outputs[i]->setPos(boundingRect().width(), ypos2 + size.height() / 2.0);
-		ypos2 += step;
-	}
-
-	//
-
-	propagateChanges();
-}
-
-void NodeItem::propagateChanges()
-{
-	for (auto& input : _inputs)
-	{
-		input->updateGeometry();
-	}
-	for (auto& output : _outputs)
-	{
-		output->updateGeometry();
-	}
-}
-
-} // namespace graph
-} // namespace qtMate
diff --git a/libs/QtMate/graph/outputSocket.cpp b/libs/QtMate/graph/outputSocket.cpp
deleted file mode 100644
index c0d86a56..00000000
--- a/libs/QtMate/graph/outputSocket.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "QtMate/graph/outputSocket.hpp"
-#include "QtMate/graph/connection.hpp"
-#include "QtMate/graph/type.hpp"
-
-namespace qtMate
-{
-namespace graph
-{
-OutputSocketItem::~OutputSocketItem()
-{
-	clearConnections();
-}
-
-int OutputSocketItem::type() const
-{
-	return ItemType::Output;
-}
-
-void OutputSocketItem::updateGeometry()
-{
-	for (auto& connection : _connections)
-	{
-		connection->setStart(mapToScene(0, 0));
-	}
-}
-
-bool OutputSocketItem::isConnected() const
-{
-	return !_connections.empty();
-}
-
-void OutputSocketItem::addConnection(ConnectionItem* connection)
-{
-	_connections.insert(connection);
-	updateGeometry();
-}
-
-void OutputSocketItem::removeConnection(ConnectionItem* connection)
-{
-	_connections.erase(connection);
-}
-
-void OutputSocketItem::clearConnections()
-{
-	auto localConnections{ _connections };
-	for (auto& connection : localConnections)
-	{
-		connection->disconnect();
-	}
-}
-
-ConnectionItems const& OutputSocketItem::connections() const
-{
-	return _connections;
-}
-
-} // namespace graph
-} // namespace qtMate
diff --git a/libs/QtMate/graph/socket.cpp b/libs/QtMate/graph/socket.cpp
deleted file mode 100644
index 0db9ae93..00000000
--- a/libs/QtMate/graph/socket.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "QtMate/graph/socket.hpp"
-#include "QtMate/graph/type.hpp"
-
-#include <QPainter>
-
-#include <cassert>
-
-namespace qtMate
-{
-namespace graph
-{
-const float PEN_WIDTH = 1.f;
-const float CIRCLE_RADIUS = 6.f;
-const float MIN_WIDTH = 50.f;
-const float MIN_HEIGHT = 15.f;
-const float TEXT_OFFSET = 5.f;
-
-SocketItem::SocketItem(int nodeId, int index, QString const& text, QGraphicsItem* parent)
-	: QGraphicsItem(parent)
-	, _nodeId(nodeId)
-	, _index(index)
-	, _text(text)
-{
-	QFont font;
-	QFontMetrics fm(font);
-	auto const textWidth = fm.horizontalAdvance(_text);
-	auto const textHeight = fm.height();
-	auto const width = std::max(MIN_WIDTH, CIRCLE_RADIUS * 2 + TEXT_OFFSET + textWidth + PEN_WIDTH);
-	auto const height = std::max(MIN_HEIGHT, textHeight + PEN_WIDTH);
-	_size = QSize(width, height);
-}
-
-int SocketItem::nodeId() const
-{
-	return _nodeId;
-}
-
-int SocketItem::index() const
-{
-	return _index;
-}
-
-QString const& SocketItem::text() const
-{
-	return _text;
-}
-
-QSizeF SocketItem::size() const
-{
-	return _size;
-}
-
-QRectF SocketItem::boundingRect() const
-{
-	auto const s = size();
-
-	auto const x = -CIRCLE_RADIUS - PEN_WIDTH / 2.f;
-	auto const y = -s.height() / 2.f - PEN_WIDTH / 2.f;
-
-	switch (type())
-	{
-		case ItemType::Input:
-		{
-			return QRectF(QPointF(x, y), s).normalized();
-		}
-
-		case ItemType::Output:
-		{
-			return QRectF(QPointF(-s.width() - x, y), s).normalized();
-		}
-
-		default:
-			assert(true && "Invalid item type");
-			return {};
-	}
-}
-
-bool SocketItem::isOver(QPointF const& pos) const
-{
-	return pos.x() >= -CIRCLE_RADIUS && pos.x() <= CIRCLE_RADIUS && pos.y() >= -CIRCLE_RADIUS && pos.y() <= CIRCLE_RADIUS;
-}
-
-void SocketItem::paint(QPainter* painter, QStyleOptionGraphicsItem const* /*option*/, QWidget* /*widget*/)
-{
-	QPen pen;
-	pen.setWidth(2);
-	painter->setPen(NodeItemColor);
-
-	switch (type())
-	{
-		case ItemType::Input:
-		{
-			painter->setBrush(InputSocketColor);
-			break;
-		}
-		case ItemType::Output:
-		{
-			painter->setBrush(OutputSocketColor);
-			break;
-		}
-		default:
-			assert(true && "Invalid item type");
-	}
-
-	painter->drawEllipse(-CIRCLE_RADIUS, -CIRCLE_RADIUS, CIRCLE_RADIUS * 2, CIRCLE_RADIUS * 2);
-
-	if (isConnected())
-	{
-		painter->setPen(Qt::NoPen);
-		painter->setBrush(NodeItemColor);
-		painter->drawEllipse(-CIRCLE_RADIUS / 2, -CIRCLE_RADIUS / 2, CIRCLE_RADIUS, CIRCLE_RADIUS);
-	}
-
-	auto const size = 32767.f;
-
-	int flags{ 0 };
-	QPointF corner{ 0, 0 };
-
-	switch (type())
-	{
-		case ItemType::Input:
-		{
-			flags = Qt::AlignVCenter | Qt::AlignLeft;
-
-			corner.setX(CIRCLE_RADIUS + TEXT_OFFSET);
-			corner.setY(-size);
-			corner.ry() += size / 2.;
-			break;
-		}
-		case ItemType::Output:
-		{
-			flags = Qt::AlignVCenter | Qt::AlignRight;
-
-			corner.setX(-CIRCLE_RADIUS - TEXT_OFFSET);
-			corner.setY(-size);
-			corner.ry() += size / 2.;
-			corner.rx() -= size;
-			break;
-		}
-		default:
-			assert(true && "Invalid item type");
-	}
-
-	QRectF rect(corner, QSizeF{ size, size });
-
-	painter->setPen(TextColor);
-	painter->drawText(rect.adjusted(0, -2, 0, -2), flags, _text, nullptr);
-}
-
-} // namespace graph
-} // namespace qtMate
diff --git a/libs/QtMate/graph/view.cpp b/libs/QtMate/graph/view.cpp
deleted file mode 100644
index 14f1cdc2..00000000
--- a/libs/QtMate/graph/view.cpp
+++ /dev/null
@@ -1,374 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "QtMate/graph/view.hpp"
-#include "QtMate/graph/inputSocket.hpp"
-#include "QtMate/graph/outputSocket.hpp"
-#include "QtMate/graph/connection.hpp"
-#include "QtMate/graph/type.hpp"
-
-#include <QMouseEvent>
-#include <QScrollBar>
-
-namespace qtMate
-{
-namespace graph
-{
-Qt::Edges computeCloseEdges(QPoint const& p, QRect const& r, int const margin = 20)
-{
-	auto edges = Qt::Edges{};
-
-	auto const left = r.left() + margin;
-	auto const top = r.top() + margin;
-	auto const right = r.right() - margin;
-	auto const bottom = r.bottom() - margin;
-
-	if (p.x() <= left)
-	{
-		edges.setFlag(Qt::Edge::LeftEdge);
-	}
-	if (p.y() <= top)
-	{
-		edges.setFlag(Qt::Edge::TopEdge);
-	}
-	if (p.x() >= right)
-	{
-		edges.setFlag(Qt::Edge::RightEdge);
-	}
-	if (p.y() >= bottom)
-	{
-		edges.setFlag(Qt::Edge::BottomEdge);
-	}
-
-	return edges;
-}
-
-GraphicsView::GraphicsView(QWidget* parent)
-	: QGraphicsView(parent)
-{
-	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-	setResizeAnchor(NoAnchor);
-	setTransformationAnchor(AnchorUnderMouse);
-	setDragMode(QGraphicsView::ScrollHandDrag);
-	setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform);
-}
-
-void GraphicsView::mousePressEvent(QMouseEvent* event)
-{
-	auto* item = socketAt(event->pos());
-
-	if (item)
-	{
-		auto const scenePos = mapToScene(event->pos());
-		auto const itemPos = item->mapFromScene(scenePos);
-
-		if (event->button() == Qt::LeftButton)
-		{
-			viewport()->setCursor(Qt::ClosedHandCursor);
-
-			switch (item->type())
-			{
-				case ItemType::Input:
-				{
-					auto* socket = static_cast<InputSocketItem*>(item);
-					if (socket->isOver(itemPos))
-					{
-						_connectionDragEvent = std::make_unique<ConnectionDragEvent>();
-						startAutoScroll();
-
-						if (socket->isConnected())
-						{
-							auto connection = socket->connection();
-							emit connectionDeleted(connection);
-							_connectionDragEvent->mode = ConnectionDragMode::MoveToInput;
-							_connectionDragEvent->connections.insert(connection);
-							connection->setStop(scenePos);
-							connection->disconnectInput();
-						}
-						else
-						{
-							_connectionDragEvent->mode = ConnectionDragMode::ConnectToOutput;
-							auto connection = new ConnectionItem;
-							_connectionDragEvent->connections.insert(connection);
-							connection->setStart(scenePos);
-							connection->setStop(scenePos);
-							connection->connectInput(socket);
-							scene()->addItem(connection);
-						}
-						event->ignore();
-					}
-					return;
-				}
-				case ItemType::Output:
-				{
-					auto* socket = static_cast<OutputSocketItem*>(item);
-					if (socket->isOver(itemPos))
-					{
-						_connectionDragEvent = std::make_unique<ConnectionDragEvent>();
-						startAutoScroll();
-
-						if (socket->isConnected() && event->modifiers().testFlag(Qt::ControlModifier))
-						{
-							_connectionDragEvent->mode = ConnectionDragMode::MoveToOutput;
-							_connectionDragEvent->connections = socket->connections();
-							for (auto& connection : _connectionDragEvent->connections)
-							{
-								emit connectionDeleted(connection);
-
-								connection->setStart(scenePos);
-								connection->disconnectOutput();
-							}
-						}
-						else
-						{
-							_connectionDragEvent->mode = ConnectionDragMode::ConnectToInput;
-							auto connection = new ConnectionItem;
-							_connectionDragEvent->connections.insert(connection);
-							connection->setStart(scenePos);
-							connection->setStop(scenePos);
-							connection->connectOutput(socket);
-							scene()->addItem(connection);
-						}
-						event->ignore();
-					}
-					return;
-				}
-				default:
-					break;
-			}
-		}
-	}
-
-	QGraphicsView::mousePressEvent(event);
-}
-
-void GraphicsView::mouseMoveEvent(QMouseEvent* event)
-{
-	auto const scenePos = mapToScene(event->pos());
-
-	if (_connectionDragEvent && event->buttons().testFlag(Qt::LeftButton))
-	{
-		switch (_connectionDragEvent->mode)
-		{
-			case ConnectionDragMode::ConnectToInput:
-			case ConnectionDragMode::MoveToInput:
-			{
-				for (auto& connection : _connectionDragEvent->connections)
-				{
-					connection->setStop(scenePos);
-				}
-				break;
-			}
-			case ConnectionDragMode::ConnectToOutput:
-			case ConnectionDragMode::MoveToOutput:
-			{
-				for (auto& connection : _connectionDragEvent->connections)
-				{
-					connection->setStart(scenePos);
-				}
-				break;
-			}
-			default:
-				break;
-		}
-
-		auto* item = socketAt(event->pos());
-		if (item)
-		{
-			if (acceptableConnection(item))
-			{
-				viewport()->setCursor(Qt::DragMoveCursor);
-			}
-			else
-			{
-				viewport()->setCursor(Qt::ForbiddenCursor);
-			}
-		}
-		else
-		{
-			viewport()->setCursor(Qt::ClosedHandCursor);
-		}
-	}
-
-	QGraphicsView::mouseMoveEvent(event);
-}
-
-void GraphicsView::mouseReleaseEvent(QMouseEvent* event)
-{
-	viewport()->setCursor(Qt::ArrowCursor);
-
-	if (event->button() == Qt::LeftButton)
-	{
-		if (_connectionDragEvent)
-		{
-			auto item = socketAt(event->pos());
-			if (!item || !acceptableConnection(item))
-			{
-				// Invalid, delete all connections
-				for (auto& connection : _connectionDragEvent->connections)
-				{
-					delete connection;
-				}
-			}
-			else
-			{
-				switch (_connectionDragEvent->mode)
-				{
-					case ConnectionDragMode::ConnectToInput:
-					case ConnectionDragMode::MoveToInput:
-					{
-						auto* socket = static_cast<InputSocketItem*>(item);
-
-						if (auto* connection = socket->connection())
-						{
-							emit connectionDeleted(connection);
-							delete connection;
-						}
-
-						for (auto& connection : _connectionDragEvent->connections)
-						{
-							connection->connectInput(socket);
-							emit connectionCreated(connection);
-						}
-						break;
-					}
-					case ConnectionDragMode::ConnectToOutput:
-					case ConnectionDragMode::MoveToOutput:
-					{
-						auto* socket = static_cast<OutputSocketItem*>(item);
-
-						for (auto& connection : _connectionDragEvent->connections)
-						{
-							connection->connectOutput(socket);
-							emit connectionCreated(connection);
-						}
-						break;
-					}
-					default:
-						break;
-				}
-			}
-
-			stopAutoScroll();
-			_connectionDragEvent.reset();
-			event->ignore();
-			return;
-		}
-	}
-
-	QGraphicsView::mouseReleaseEvent(event);
-}
-
-void GraphicsView::timerEvent(QTimerEvent* event)
-{
-	auto const pos = mapFromGlobal(QCursor::pos());
-	auto const viewportGeometry = viewport()->geometry();
-
-	// Check if the mouse is close to an edge of the viewport
-	auto const edges = computeCloseEdges(pos, viewportGeometry, 20);
-
-	if (edges != 0)
-	{
-		// If so, scroll the contant by the distance in pixels between the mouse and the matching edge
-		auto dx = 0;
-		auto dy = 0;
-
-		if (edges.testFlag(Qt::LeftEdge))
-		{
-			dx -= std::abs(pos.x() - viewportGeometry.left());
-		}
-
-		if (edges.testFlag(Qt::RightEdge))
-		{
-			dx += pos.x() - viewportGeometry.right();
-		}
-
-		if (edges.testFlag(Qt::TopEdge))
-		{
-			dy -= std::abs(pos.y() - viewportGeometry.top());
-		}
-
-		if (edges.testFlag(Qt::BottomEdge))
-		{
-			dy += std::abs(pos.y() - viewportGeometry.bottom());
-		}
-
-		if (dx)
-		{
-			horizontalScrollBar()->setValue(horizontalScrollBar()->value() + dx);
-		}
-
-		if (dy)
-		{
-			verticalScrollBar()->setValue(verticalScrollBar()->value() + dy);
-		}
-	}
-}
-
-
-bool GraphicsView::acceptableConnection(SocketItem* item) const
-{
-	if (!item || !_connectionDragEvent)
-	{
-		return false;
-	}
-
-	switch (_connectionDragEvent->mode)
-	{
-		case ConnectionDragMode::ConnectToInput:
-		case ConnectionDragMode::MoveToInput:
-			return item->type() == ItemType::Input;
-		case ConnectionDragMode::ConnectToOutput:
-		case ConnectionDragMode::MoveToOutput:
-			return item->type() == ItemType::Output;
-		default:
-			return false;
-	}
-}
-
-SocketItem* GraphicsView::socketAt(QPoint const& pos) const
-{
-	for (auto const& item : items(pos))
-	{
-		switch (item->type())
-		{
-			case ItemType::Input:
-			case ItemType::Output:
-				return static_cast<SocketItem*>(item);
-			default:
-				break;
-		}
-	}
-
-	return nullptr;
-}
-
-void GraphicsView::startAutoScroll()
-{
-	_autoScrollTimer = startTimer(std::chrono::milliseconds{ 50 });
-}
-
-void GraphicsView::stopAutoScroll()
-{
-	killTimer(_autoScrollTimer);
-}
-
-} // namespace graph
-} // namespace qtMate
diff --git a/libs/QtMate/material/color.cpp b/libs/QtMate/material/color.cpp
index ba6ec968..ac767eb3 100644
--- a/libs/QtMate/material/color.cpp
+++ b/libs/QtMate/material/color.cpp
@@ -19,8 +19,13 @@
 
 #include "QtMate/material/color.hpp"
 
+#include <QStyleHints>
+#include <QGuiApplication>
+#include <QApplication>
+
 #include <unordered_map>
 #include <stdexcept>
+#include <mutex>
 
 namespace qtMate
 {
@@ -37,503 +42,695 @@ struct ColorData
 using ShadeMap = std::unordered_map<Shade, ColorData>;
 using ColorMap = std::unordered_map<Name, ShadeMap>;
 
-static const ColorMap g_colorMap = {
+static ColorMap g_colorMap = {
 	{ Name::Red,
 		{
-			{ Shade::Shade50, { 0xFFEBEE, Luminance::Light } },
-			{ Shade::Shade100, { 0xFFCDD2, Luminance::Light } },
-			{ Shade::Shade200, { 0xEF9A9A, Luminance::Light } },
-			{ Shade::Shade300, { 0xE57373, Luminance::Light } },
-			{ Shade::Shade400, { 0xEF5350, Luminance::Dark } },
-			{ Shade::Shade500, { 0xF44336, Luminance::Dark } },
-			{ Shade::Shade600, { 0xE53935, Luminance::Dark } },
-			{ Shade::Shade700, { 0xD32F2F, Luminance::Dark } },
-			{ Shade::Shade800, { 0xC62828, Luminance::Dark } },
-			{ Shade::Shade900, { 0xB71C1C, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xFF8A80, Luminance::Light } },
-			{ Shade::ShadeA200, { 0xFF5252, Luminance::Dark } },
-			{ Shade::ShadeA400, { 0xFF1744, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0xD50000, Luminance::Dark } },
+			{ Shade::Shade50, { 0xFFEBEE } },
+			{ Shade::Shade100, { 0xFFCDD2 } },
+			{ Shade::Shade200, { 0xEF9A9A } },
+			{ Shade::Shade300, { 0xE57373 } },
+			{ Shade::Shade400, { 0xEF5350 } },
+			{ Shade::Shade500, { 0xF44336 } },
+			{ Shade::Shade600, { 0xE53935 } },
+			{ Shade::Shade700, { 0xD32F2F } },
+			{ Shade::Shade800, { 0xC62828 } },
+			{ Shade::Shade900, { 0xB71C1C } },
+			{ Shade::ShadeA100, { 0xFF8A80 } },
+			{ Shade::ShadeA200, { 0xFF5252 } },
+			{ Shade::ShadeA400, { 0xFF1744 } },
+			{ Shade::ShadeA700, { 0xD50000 } },
 		} },
 	{ Name::Pink,
 		{
-			{ Shade::Shade50, { 0xFCE4EC, Luminance::Light } },
-			{ Shade::Shade100, { 0xF8BBD0, Luminance::Light } },
-			{ Shade::Shade200, { 0xF48FB1, Luminance::Light } },
-			{ Shade::Shade300, { 0xF06292, Luminance::Light } },
-			{ Shade::Shade400, { 0xEC407A, Luminance::Dark } },
-			{ Shade::Shade500, { 0xE91E63, Luminance::Dark } },
-			{ Shade::Shade600, { 0xD81B60, Luminance::Dark } },
-			{ Shade::Shade700, { 0xC2185B, Luminance::Dark } },
-			{ Shade::Shade800, { 0xAD1457, Luminance::Dark } },
-			{ Shade::Shade900, { 0x880E4F, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xFF80AB, Luminance::Light } },
-			{ Shade::ShadeA200, { 0xFF4081, Luminance::Dark } },
-			{ Shade::ShadeA400, { 0xF50057, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0xC51162, Luminance::Dark } },
+			{ Shade::Shade50, { 0xFCE4EC } },
+			{ Shade::Shade100, { 0xF8BBD0 } },
+			{ Shade::Shade200, { 0xF48FB1 } },
+			{ Shade::Shade300, { 0xF06292 } },
+			{ Shade::Shade400, { 0xEC407A } },
+			{ Shade::Shade500, { 0xE91E63 } },
+			{ Shade::Shade600, { 0xD81B60 } },
+			{ Shade::Shade700, { 0xC2185B } },
+			{ Shade::Shade800, { 0xAD1457 } },
+			{ Shade::Shade900, { 0x880E4F } },
+			{ Shade::ShadeA100, { 0xFF80AB } },
+			{ Shade::ShadeA200, { 0xFF4081 } },
+			{ Shade::ShadeA400, { 0xF50057 } },
+			{ Shade::ShadeA700, { 0xC51162 } },
 		} },
 	{ Name::Purple,
 		{
-			{ Shade::Shade50, { 0xF3E5F5, Luminance::Light } },
-			{ Shade::Shade100, { 0xE1BEE7, Luminance::Light } },
-			{ Shade::Shade200, { 0xCE93D8, Luminance::Light } },
-			{ Shade::Shade300, { 0xBA68C8, Luminance::Dark } },
-			{ Shade::Shade400, { 0xAB47BC, Luminance::Dark } },
-			{ Shade::Shade500, { 0x9C27B0, Luminance::Dark } },
-			{ Shade::Shade600, { 0x8E24AA, Luminance::Dark } },
-			{ Shade::Shade700, { 0x7B1FA2, Luminance::Dark } },
-			{ Shade::Shade800, { 0x6A1B9A, Luminance::Dark } },
-			{ Shade::Shade900, { 0x4A148C, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xEA80FC, Luminance::Light } },
-			{ Shade::ShadeA200, { 0xE040FB, Luminance::Dark } },
-			{ Shade::ShadeA400, { 0xD500F9, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0xAA00FF, Luminance::Dark } },
+			{ Shade::Shade50, { 0xF3E5F5 } },
+			{ Shade::Shade100, { 0xE1BEE7 } },
+			{ Shade::Shade200, { 0xCE93D8 } },
+			{ Shade::Shade300, { 0xBA68C8 } },
+			{ Shade::Shade400, { 0xAB47BC } },
+			{ Shade::Shade500, { 0x9C27B0 } },
+			{ Shade::Shade600, { 0x8E24AA } },
+			{ Shade::Shade700, { 0x7B1FA2 } },
+			{ Shade::Shade800, { 0x6A1B9A } },
+			{ Shade::Shade900, { 0x4A148C } },
+			{ Shade::ShadeA100, { 0xEA80FC } },
+			{ Shade::ShadeA200, { 0xE040FB } },
+			{ Shade::ShadeA400, { 0xD500F9 } },
+			{ Shade::ShadeA700, { 0xAA00FF } },
 		} },
 	{ Name::DeepPurple,
 		{
-			{ Shade::Shade50, { 0xEDE7F6, Luminance::Light } },
-			{ Shade::Shade100, { 0xD1C4E9, Luminance::Light } },
-			{ Shade::Shade200, { 0xB39DDB, Luminance::Light } },
-			{ Shade::Shade300, { 0x9575CD, Luminance::Dark } },
-			{ Shade::Shade400, { 0x7E57C2, Luminance::Dark } },
-			{ Shade::Shade500, { 0x673AB7, Luminance::Dark } },
-			{ Shade::Shade600, { 0x5E35B1, Luminance::Dark } },
-			{ Shade::Shade700, { 0x512DA8, Luminance::Dark } },
-			{ Shade::Shade800, { 0x4527A0, Luminance::Dark } },
-			{ Shade::Shade900, { 0x311B92, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xB388FF, Luminance::Light } },
-			{ Shade::ShadeA200, { 0x7C4DFF, Luminance::Dark } },
-			{ Shade::ShadeA400, { 0x651FFF, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0x6200EA, Luminance::Dark } },
+			{ Shade::Shade50, { 0xEDE7F6 } },
+			{ Shade::Shade100, { 0xD1C4E9 } },
+			{ Shade::Shade200, { 0xB39DDB } },
+			{ Shade::Shade300, { 0x9575CD } },
+			{ Shade::Shade400, { 0x7E57C2 } },
+			{ Shade::Shade500, { 0x673AB7 } },
+			{ Shade::Shade600, { 0x5E35B1 } },
+			{ Shade::Shade700, { 0x512DA8 } },
+			{ Shade::Shade800, { 0x4527A0 } },
+			{ Shade::Shade900, { 0x311B92 } },
+			{ Shade::ShadeA100, { 0xB388FF } },
+			{ Shade::ShadeA200, { 0x7C4DFF } },
+			{ Shade::ShadeA400, { 0x651FFF } },
+			{ Shade::ShadeA700, { 0x6200EA } },
 		} },
 	{ Name::Indigo,
 		{
-			{ Shade::Shade50, { 0xE8EAF6, Luminance::Light } },
-			{ Shade::Shade100, { 0xC5CAE9, Luminance::Light } },
-			{ Shade::Shade200, { 0x9FA8DA, Luminance::Light } },
-			{ Shade::Shade300, { 0x7986CB, Luminance::Dark } },
-			{ Shade::Shade400, { 0x5C6BC0, Luminance::Dark } },
-			{ Shade::Shade500, { 0x3F51B5, Luminance::Dark } },
-			{ Shade::Shade600, { 0x3949AB, Luminance::Dark } },
-			{ Shade::Shade700, { 0x303F9F, Luminance::Dark } },
-			{ Shade::Shade800, { 0x283593, Luminance::Dark } },
-			{ Shade::Shade900, { 0x1A237E, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0x8C9EFF, Luminance::Light } },
-			{ Shade::ShadeA200, { 0x536DFE, Luminance::Dark } },
-			{ Shade::ShadeA400, { 0x3D5AFE, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0x304FFE, Luminance::Dark } },
+			{ Shade::Shade50, { 0xE8EAF6 } },
+			{ Shade::Shade100, { 0xC5CAE9 } },
+			{ Shade::Shade200, { 0x9FA8DA } },
+			{ Shade::Shade300, { 0x7986CB } },
+			{ Shade::Shade400, { 0x5C6BC0 } },
+			{ Shade::Shade500, { 0x3F51B5 } },
+			{ Shade::Shade600, { 0x3949AB } },
+			{ Shade::Shade700, { 0x303F9F } },
+			{ Shade::Shade800, { 0x283593 } },
+			{ Shade::Shade900, { 0x1A237E } },
+			{ Shade::ShadeA100, { 0x8C9EFF } },
+			{ Shade::ShadeA200, { 0x536DFE } },
+			{ Shade::ShadeA400, { 0x3D5AFE } },
+			{ Shade::ShadeA700, { 0x304FFE } },
 		} },
 	{ Name::Blue,
 		{
-			{ Shade::Shade50, { 0xE3F2FD, Luminance::Light } },
-			{ Shade::Shade100, { 0xBBDEFB, Luminance::Light } },
-			{ Shade::Shade200, { 0x90CAF9, Luminance::Light } },
-			{ Shade::Shade300, { 0x64B5F6, Luminance::Light } },
-			{ Shade::Shade400, { 0x42A5F5, Luminance::Light } },
-			{ Shade::Shade500, { 0x2196F3, Luminance::Light } },
-			{ Shade::Shade600, { 0x1E88E5, Luminance::Dark } },
-			{ Shade::Shade700, { 0x1976D2, Luminance::Dark } },
-			{ Shade::Shade800, { 0x1565C0, Luminance::Dark } },
-			{ Shade::Shade900, { 0x0D47A1, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0x82B1FF, Luminance::Light } },
-			{ Shade::ShadeA200, { 0x448AFF, Luminance::Dark } },
-			{ Shade::ShadeA400, { 0x2979FF, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0x2962FF, Luminance::Dark } },
+			{ Shade::Shade50, { 0xE3F2FD } },
+			{ Shade::Shade100, { 0xBBDEFB } },
+			{ Shade::Shade200, { 0x90CAF9 } },
+			{ Shade::Shade300, { 0x64B5F6 } },
+			{ Shade::Shade400, { 0x42A5F5 } },
+			{ Shade::Shade500, { 0x2196F3 } },
+			{ Shade::Shade600, { 0x1E88E5 } },
+			{ Shade::Shade700, { 0x1976D2 } },
+			{ Shade::Shade800, { 0x1565C0 } },
+			{ Shade::Shade900, { 0x0D47A1 } },
+			{ Shade::ShadeA100, { 0x82B1FF } },
+			{ Shade::ShadeA200, { 0x448AFF } },
+			{ Shade::ShadeA400, { 0x2979FF } },
+			{ Shade::ShadeA700, { 0x2962FF } },
 		} },
 	{ Name::LightBlue,
 		{
-			{ Shade::Shade50, { 0xE1F5FE, Luminance::Light } },
-			{ Shade::Shade100, { 0xB3E5FC, Luminance::Light } },
-			{ Shade::Shade200, { 0x81D4FA, Luminance::Light } },
-			{ Shade::Shade300, { 0x4FC3F7, Luminance::Light } },
-			{ Shade::Shade400, { 0x29B6F6, Luminance::Light } },
-			{ Shade::Shade500, { 0x03A9F4, Luminance::Light } },
-			{ Shade::Shade600, { 0x039BE5, Luminance::Light } },
-			{ Shade::Shade700, { 0x0288D1, Luminance::Dark } },
-			{ Shade::Shade800, { 0x0277BD, Luminance::Dark } },
-			{ Shade::Shade900, { 0x01579B, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0x80D8FF, Luminance::Light } },
-			{ Shade::ShadeA200, { 0x40C4FF, Luminance::Light } },
-			{ Shade::ShadeA400, { 0x00B0FF, Luminance::Light } },
-			{ Shade::ShadeA700, { 0x0091EA, Luminance::Dark } },
+			{ Shade::Shade50, { 0xE1F5FE } },
+			{ Shade::Shade100, { 0xB3E5FC } },
+			{ Shade::Shade200, { 0x81D4FA } },
+			{ Shade::Shade300, { 0x4FC3F7 } },
+			{ Shade::Shade400, { 0x29B6F6 } },
+			{ Shade::Shade500, { 0x03A9F4 } },
+			{ Shade::Shade600, { 0x039BE5 } },
+			{ Shade::Shade700, { 0x0288D1 } },
+			{ Shade::Shade800, { 0x0277BD } },
+			{ Shade::Shade900, { 0x01579B } },
+			{ Shade::ShadeA100, { 0x80D8FF } },
+			{ Shade::ShadeA200, { 0x40C4FF } },
+			{ Shade::ShadeA400, { 0x00B0FF } },
+			{ Shade::ShadeA700, { 0x0091EA } },
 		} },
 	{ Name::Cyan,
 		{
-			{ Shade::Shade50, { 0xE0F7FA, Luminance::Light } },
-			{ Shade::Shade100, { 0xB2EBF2, Luminance::Light } },
-			{ Shade::Shade200, { 0x80DEEA, Luminance::Light } },
-			{ Shade::Shade300, { 0x4DD0E1, Luminance::Light } },
-			{ Shade::Shade400, { 0x26C6DA, Luminance::Light } },
-			{ Shade::Shade500, { 0x00BCD4, Luminance::Light } },
-			{ Shade::Shade600, { 0x00ACC1, Luminance::Light } },
-			{ Shade::Shade700, { 0x0097A7, Luminance::Dark } },
-			{ Shade::Shade800, { 0x00838F, Luminance::Dark } },
-			{ Shade::Shade900, { 0x006064, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0x84FFFF, Luminance::Light } },
-			{ Shade::ShadeA200, { 0x18FFFF, Luminance::Light } },
-			{ Shade::ShadeA400, { 0x00E5FF, Luminance::Light } },
-			{ Shade::ShadeA700, { 0x00B8D4, Luminance::Light } },
+			{ Shade::Shade50, { 0xE0F7FA } },
+			{ Shade::Shade100, { 0xB2EBF2 } },
+			{ Shade::Shade200, { 0x80DEEA } },
+			{ Shade::Shade300, { 0x4DD0E1 } },
+			{ Shade::Shade400, { 0x26C6DA } },
+			{ Shade::Shade500, { 0x00BCD4 } },
+			{ Shade::Shade600, { 0x00ACC1 } },
+			{ Shade::Shade700, { 0x0097A7 } },
+			{ Shade::Shade800, { 0x00838F } },
+			{ Shade::Shade900, { 0x006064 } },
+			{ Shade::ShadeA100, { 0x84FFFF } },
+			{ Shade::ShadeA200, { 0x18FFFF } },
+			{ Shade::ShadeA400, { 0x00E5FF } },
+			{ Shade::ShadeA700, { 0x00B8D4 } },
 		} },
 	{ Name::Teal,
 		{
-			{ Shade::Shade50, { 0xE0F2F1, Luminance::Light } },
-			{ Shade::Shade100, { 0xB2DFDB, Luminance::Light } },
-			{ Shade::Shade200, { 0x80CBC4, Luminance::Light } },
-			{ Shade::Shade300, { 0x4DB6AC, Luminance::Light } },
-			{ Shade::Shade400, { 0x26A69A, Luminance::Light } },
-			{ Shade::Shade500, { 0x009688, Luminance::Dark } },
-			{ Shade::Shade600, { 0x00897B, Luminance::Dark } },
-			{ Shade::Shade700, { 0x00796B, Luminance::Dark } },
-			{ Shade::Shade800, { 0x00695C, Luminance::Dark } },
-			{ Shade::Shade900, { 0x004D40, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xA7FFEB, Luminance::Light } },
-			{ Shade::ShadeA200, { 0x64FFDA, Luminance::Light } },
-			{ Shade::ShadeA400, { 0x1DE9B6, Luminance::Light } },
-			{ Shade::ShadeA700, { 0x00BFA5, Luminance::Light } },
+			{ Shade::Shade50, { 0xE0F2F1 } },
+			{ Shade::Shade100, { 0xB2DFDB } },
+			{ Shade::Shade200, { 0x80CBC4 } },
+			{ Shade::Shade300, { 0x4DB6AC } },
+			{ Shade::Shade400, { 0x26A69A } },
+			{ Shade::Shade500, { 0x009688 } },
+			{ Shade::Shade600, { 0x00897B } },
+			{ Shade::Shade700, { 0x00796B } },
+			{ Shade::Shade800, { 0x00695C } },
+			{ Shade::Shade900, { 0x004D40 } },
+			{ Shade::ShadeA100, { 0xA7FFEB } },
+			{ Shade::ShadeA200, { 0x64FFDA } },
+			{ Shade::ShadeA400, { 0x1DE9B6 } },
+			{ Shade::ShadeA700, { 0x00BFA5 } },
 		} },
 	{ Name::Green,
 		{
-			{ Shade::Shade50, { 0xE8F5E9, Luminance::Light } },
-			{ Shade::Shade100, { 0xC8E6C9, Luminance::Light } },
-			{ Shade::Shade200, { 0xA5D6A7, Luminance::Light } },
-			{ Shade::Shade300, { 0x81C784, Luminance::Light } },
-			{ Shade::Shade400, { 0x66BB6A, Luminance::Light } },
-			{ Shade::Shade500, { 0x4CAF50, Luminance::Light } },
-			{ Shade::Shade600, { 0x43A047, Luminance::Dark } },
-			{ Shade::Shade700, { 0x388E3C, Luminance::Dark } },
-			{ Shade::Shade800, { 0x2E7D32, Luminance::Dark } },
-			{ Shade::Shade900, { 0x1B5E20, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xB9F6CA, Luminance::Light } },
-			{ Shade::ShadeA200, { 0x69F0AE, Luminance::Light } },
-			{ Shade::ShadeA400, { 0x00E676, Luminance::Light } },
-			{ Shade::ShadeA700, { 0x00C853, Luminance::Light } },
+			{ Shade::Shade50, { 0xE8F5E9 } },
+			{ Shade::Shade100, { 0xC8E6C9 } },
+			{ Shade::Shade200, { 0xA5D6A7 } },
+			{ Shade::Shade300, { 0x81C784 } },
+			{ Shade::Shade400, { 0x66BB6A } },
+			{ Shade::Shade500, { 0x4CAF50 } },
+			{ Shade::Shade600, { 0x43A047 } },
+			{ Shade::Shade700, { 0x388E3C } },
+			{ Shade::Shade800, { 0x2E7D32 } },
+			{ Shade::Shade900, { 0x1B5E20 } },
+			{ Shade::ShadeA100, { 0xB9F6CA } },
+			{ Shade::ShadeA200, { 0x69F0AE } },
+			{ Shade::ShadeA400, { 0x00E676 } },
+			{ Shade::ShadeA700, { 0x00C853 } },
 		} },
 	{ Name::LightGreen,
 		{
-			{ Shade::Shade50, { 0xF1F8E9, Luminance::Light } },
-			{ Shade::Shade100, { 0xDCEDC8, Luminance::Light } },
-			{ Shade::Shade200, { 0xC5E1A5, Luminance::Light } },
-			{ Shade::Shade300, { 0xAED581, Luminance::Light } },
-			{ Shade::Shade400, { 0x9CCC65, Luminance::Light } },
-			{ Shade::Shade500, { 0x8BC34A, Luminance::Light } },
-			{ Shade::Shade600, { 0x7CB342, Luminance::Light } },
-			{ Shade::Shade700, { 0x689F38, Luminance::Light } },
-			{ Shade::Shade800, { 0x558B2F, Luminance::Dark } },
-			{ Shade::Shade900, { 0xC33691E, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xCCFF90, Luminance::Light } },
-			{ Shade::ShadeA200, { 0xB2FF59, Luminance::Light } },
-			{ Shade::ShadeA400, { 0x76FF03, Luminance::Light } },
-			{ Shade::ShadeA700, { 0x64DD17, Luminance::Light } },
+			{ Shade::Shade50, { 0xF1F8E9 } },
+			{ Shade::Shade100, { 0xDCEDC8 } },
+			{ Shade::Shade200, { 0xC5E1A5 } },
+			{ Shade::Shade300, { 0xAED581 } },
+			{ Shade::Shade400, { 0x9CCC65 } },
+			{ Shade::Shade500, { 0x8BC34A } },
+			{ Shade::Shade600, { 0x7CB342 } },
+			{ Shade::Shade700, { 0x689F38 } },
+			{ Shade::Shade800, { 0x558B2F } },
+			{ Shade::Shade900, { 0xC33691E } },
+			{ Shade::ShadeA100, { 0xCCFF90 } },
+			{ Shade::ShadeA200, { 0xB2FF59 } },
+			{ Shade::ShadeA400, { 0x76FF03 } },
+			{ Shade::ShadeA700, { 0x64DD17 } },
 		} },
 	{ Name::Lime,
 		{
-			{ Shade::Shade50, { 0xF9FBE7, Luminance::Light } },
-			{ Shade::Shade100, { 0xF0F4C3, Luminance::Light } },
-			{ Shade::Shade200, { 0xE6EE9C, Luminance::Light } },
-			{ Shade::Shade300, { 0xDCE775, Luminance::Light } },
-			{ Shade::Shade400, { 0xD4E157, Luminance::Light } },
-			{ Shade::Shade500, { 0xCDDC39, Luminance::Light } },
-			{ Shade::Shade600, { 0xC0CA33, Luminance::Light } },
-			{ Shade::Shade700, { 0xAFB42B, Luminance::Light } },
-			{ Shade::Shade800, { 0x9E9D24, Luminance::Light } },
-			{ Shade::Shade900, { 0x827717, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xF4FF81, Luminance::Light } },
-			{ Shade::ShadeA200, { 0xEEFF41, Luminance::Light } },
-			{ Shade::ShadeA400, { 0xC6FF00, Luminance::Light } },
-			{ Shade::ShadeA700, { 0xAEEA00, Luminance::Light } },
+			{ Shade::Shade50, { 0xF9FBE7 } },
+			{ Shade::Shade100, { 0xF0F4C3 } },
+			{ Shade::Shade200, { 0xE6EE9C } },
+			{ Shade::Shade300, { 0xDCE775 } },
+			{ Shade::Shade400, { 0xD4E157 } },
+			{ Shade::Shade500, { 0xCDDC39 } },
+			{ Shade::Shade600, { 0xC0CA33 } },
+			{ Shade::Shade700, { 0xAFB42B } },
+			{ Shade::Shade800, { 0x9E9D24 } },
+			{ Shade::Shade900, { 0x827717 } },
+			{ Shade::ShadeA100, { 0xF4FF81 } },
+			{ Shade::ShadeA200, { 0xEEFF41 } },
+			{ Shade::ShadeA400, { 0xC6FF00 } },
+			{ Shade::ShadeA700, { 0xAEEA00 } },
 		} },
 	{ Name::Yellow,
 		{
-			{ Shade::Shade50, { 0xFFFDE7, Luminance::Light } },
-			{ Shade::Shade100, { 0xFFF9C4, Luminance::Light } },
-			{ Shade::Shade200, { 0xFFF59D, Luminance::Light } },
-			{ Shade::Shade300, { 0xFFF176, Luminance::Light } },
-			{ Shade::Shade400, { 0xFFEE58, Luminance::Light } },
-			{ Shade::Shade500, { 0xFFEB3B, Luminance::Light } },
-			{ Shade::Shade600, { 0xFDD835, Luminance::Light } },
-			{ Shade::Shade700, { 0xFBC02D, Luminance::Light } },
-			{ Shade::Shade800, { 0xF9A825, Luminance::Light } },
-			{ Shade::Shade900, { 0xF57F17, Luminance::Light } },
-			{ Shade::ShadeA100, { 0xFFFF8D, Luminance::Light } },
-			{ Shade::ShadeA200, { 0xFFFF00, Luminance::Light } },
-			{ Shade::ShadeA400, { 0xFFEA00, Luminance::Light } },
-			{ Shade::ShadeA700, { 0xFFD600, Luminance::Light } },
+			{ Shade::Shade50, { 0xFFFDE7 } },
+			{ Shade::Shade100, { 0xFFF9C4 } },
+			{ Shade::Shade200, { 0xFFF59D } },
+			{ Shade::Shade300, { 0xFFF176 } },
+			{ Shade::Shade400, { 0xFFEE58 } },
+			{ Shade::Shade500, { 0xFFEB3B } },
+			{ Shade::Shade600, { 0xFDD835 } },
+			{ Shade::Shade700, { 0xFBC02D } },
+			{ Shade::Shade800, { 0xF9A825 } },
+			{ Shade::Shade900, { 0xF57F17 } },
+			{ Shade::ShadeA100, { 0xFFFF8D } },
+			{ Shade::ShadeA200, { 0xFFFF00 } },
+			{ Shade::ShadeA400, { 0xFFEA00 } },
+			{ Shade::ShadeA700, { 0xFFD600 } },
 		} },
 	{ Name::Amber,
 		{
-			{ Shade::Shade50, { 0xFFF8E1, Luminance::Light } },
-			{ Shade::Shade100, { 0xFFECB3, Luminance::Light } },
-			{ Shade::Shade200, { 0xFFE082, Luminance::Light } },
-			{ Shade::Shade300, { 0xFFD54F, Luminance::Light } },
-			{ Shade::Shade400, { 0xFFCA28, Luminance::Light } },
-			{ Shade::Shade500, { 0xFFC107, Luminance::Light } },
-			{ Shade::Shade600, { 0xFFB300, Luminance::Light } },
-			{ Shade::Shade700, { 0xFFA000, Luminance::Light } },
-			{ Shade::Shade800, { 0xFF8F00, Luminance::Light } },
-			{ Shade::Shade900, { 0xFF6F00, Luminance::Light } },
-			{ Shade::ShadeA100, { 0xFFE57F, Luminance::Light } },
-			{ Shade::ShadeA200, { 0xFFD740, Luminance::Light } },
-			{ Shade::ShadeA400, { 0xFFC400, Luminance::Light } },
-			{ Shade::ShadeA700, { 0xFFAB00, Luminance::Light } },
+			{ Shade::Shade50, { 0xFFF8E1 } },
+			{ Shade::Shade100, { 0xFFECB3 } },
+			{ Shade::Shade200, { 0xFFE082 } },
+			{ Shade::Shade300, { 0xFFD54F } },
+			{ Shade::Shade400, { 0xFFCA28 } },
+			{ Shade::Shade500, { 0xFFC107 } },
+			{ Shade::Shade600, { 0xFFB300 } },
+			{ Shade::Shade700, { 0xFFA000 } },
+			{ Shade::Shade800, { 0xFF8F00 } },
+			{ Shade::Shade900, { 0xFF6F00 } },
+			{ Shade::ShadeA100, { 0xFFE57F } },
+			{ Shade::ShadeA200, { 0xFFD740 } },
+			{ Shade::ShadeA400, { 0xFFC400 } },
+			{ Shade::ShadeA700, { 0xFFAB00 } },
 		} },
 	{ Name::Orange,
 		{
-			{ Shade::Shade50, { 0xFFF3E0, Luminance::Light } },
-			{ Shade::Shade100, { 0xFFE0B2, Luminance::Light } },
-			{ Shade::Shade200, { 0xFFCC80, Luminance::Light } },
-			{ Shade::Shade300, { 0xFFB74D, Luminance::Light } },
-			{ Shade::Shade400, { 0xFFA726, Luminance::Light } },
-			{ Shade::Shade500, { 0xFF9800, Luminance::Light } },
-			{ Shade::Shade600, { 0xFB8C00, Luminance::Light } },
-			{ Shade::Shade700, { 0xF57C00, Luminance::Light } },
-			{ Shade::Shade800, { 0xEF6C00, Luminance::Light } },
-			{ Shade::Shade900, { 0xE65100, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xFFD180, Luminance::Light } },
-			{ Shade::ShadeA200, { 0xFFAB40, Luminance::Light } },
-			{ Shade::ShadeA400, { 0xFF9100, Luminance::Light } },
-			{ Shade::ShadeA700, { 0xFF6D00, Luminance::Light } },
+			{ Shade::Shade50, { 0xFFF3E0 } },
+			{ Shade::Shade100, { 0xFFE0B2 } },
+			{ Shade::Shade200, { 0xFFCC80 } },
+			{ Shade::Shade300, { 0xFFB74D } },
+			{ Shade::Shade400, { 0xFFA726 } },
+			{ Shade::Shade500, { 0xFF9800 } },
+			{ Shade::Shade600, { 0xFB8C00 } },
+			{ Shade::Shade700, { 0xF57C00 } },
+			{ Shade::Shade800, { 0xEF6C00 } },
+			{ Shade::Shade900, { 0xE65100 } },
+			{ Shade::ShadeA100, { 0xFFD180 } },
+			{ Shade::ShadeA200, { 0xFFAB40 } },
+			{ Shade::ShadeA400, { 0xFF9100 } },
+			{ Shade::ShadeA700, { 0xFF6D00 } },
 		} },
 	{ Name::DeepOrange,
 		{
-			{ Shade::Shade50, { 0xFBE9E7, Luminance::Light } },
-			{ Shade::Shade100, { 0xFFCCBC, Luminance::Light } },
-			{ Shade::Shade200, { 0xFFAB91, Luminance::Light } },
-			{ Shade::Shade300, { 0xFF8A65, Luminance::Light } },
-			{ Shade::Shade400, { 0xFF7043, Luminance::Light } },
-			{ Shade::Shade500, { 0xFF5722, Luminance::Light } },
-			{ Shade::Shade600, { 0xF4511E, Luminance::Dark } },
-			{ Shade::Shade700, { 0xE64A19, Luminance::Dark } },
-			{ Shade::Shade800, { 0xD84315, Luminance::Dark } },
-			{ Shade::Shade900, { 0xBF360C, Luminance::Dark } },
-			{ Shade::ShadeA100, { 0xFF9E80, Luminance::Light } },
-			{ Shade::ShadeA200, { 0xFF6E40, Luminance::Light } },
-			{ Shade::ShadeA400, { 0xFF3D00, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0xDD2C00, Luminance::Dark } },
+			{ Shade::Shade50, { 0xFBE9E7 } },
+			{ Shade::Shade100, { 0xFFCCBC } },
+			{ Shade::Shade200, { 0xFFAB91 } },
+			{ Shade::Shade300, { 0xFF8A65 } },
+			{ Shade::Shade400, { 0xFF7043 } },
+			{ Shade::Shade500, { 0xFF5722 } },
+			{ Shade::Shade600, { 0xF4511E } },
+			{ Shade::Shade700, { 0xE64A19 } },
+			{ Shade::Shade800, { 0xD84315 } },
+			{ Shade::Shade900, { 0xBF360C } },
+			{ Shade::ShadeA100, { 0xFF9E80 } },
+			{ Shade::ShadeA200, { 0xFF6E40 } },
+			{ Shade::ShadeA400, { 0xFF3D00 } },
+			{ Shade::ShadeA700, { 0xDD2C00 } },
 		} },
 	{ Name::Brown,
 		{
-			{ Shade::Shade50, { 0xEFEBE9, Luminance::Light } },
-			{ Shade::Shade100, { 0xD7CCC8, Luminance::Light } },
-			{ Shade::Shade200, { 0xBCAAA4, Luminance::Light } },
-			{ Shade::Shade300, { 0xA1887F, Luminance::Dark } },
-			{ Shade::Shade400, { 0x8D6E63, Luminance::Dark } },
-			{ Shade::Shade500, { 0x795548, Luminance::Dark } },
-			{ Shade::Shade600, { 0x6D4C41, Luminance::Dark } },
-			{ Shade::Shade700, { 0x5D4037, Luminance::Dark } },
-			{ Shade::Shade800, { 0x4E342E, Luminance::Dark } },
-			{ Shade::Shade900, { 0x3E2723, Luminance::Dark } },
-			//
-			{ Shade::ShadeA100, { 0xA1887F, Luminance::Dark } },
-			{ Shade::ShadeA200, { 0x795548, Luminance::Dark } },
-			{ Shade::ShadeA400, { 0x5D4037, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0x3E2723, Luminance::Dark } },
+			{ Shade::Shade50, { 0xEFEBE9 } },
+			{ Shade::Shade100, { 0xD7CCC8 } },
+			{ Shade::Shade200, { 0xBCAAA4 } },
+			{ Shade::Shade300, { 0xA1887F } },
+			{ Shade::Shade400, { 0x8D6E63 } },
+			{ Shade::Shade500, { 0x795548 } },
+			{ Shade::Shade600, { 0x6D4C41 } },
+			{ Shade::Shade700, { 0x5D4037 } },
+			{ Shade::Shade800, { 0x4E342E } },
+			{ Shade::Shade900, { 0x3E2723 } },
+			{ Shade::ShadeA100, { 0xA1887F } },
+			{ Shade::ShadeA200, { 0x795548 } },
+			{ Shade::ShadeA400, { 0x5D4037 } },
+			{ Shade::ShadeA700, { 0x3E2723 } },
 		} },
 	{ Name::Gray,
 		{
-			{ Shade::Shade50, { 0xFAFAFA, Luminance::Light } },
-			{ Shade::Shade100, { 0xF5F5F5, Luminance::Light } },
-			{ Shade::Shade200, { 0xEEEEEE, Luminance::Light } },
-			{ Shade::Shade300, { 0xE0E0E0, Luminance::Light } },
-			{ Shade::Shade400, { 0xBDBDBD, Luminance::Light } },
-			{ Shade::Shade500, { 0x9E9E9E, Luminance::Light } },
-			{ Shade::Shade600, { 0x757575, Luminance::Dark } },
-			{ Shade::Shade700, { 0x616161, Luminance::Dark } },
-			{ Shade::Shade800, { 0x424242, Luminance::Dark } },
-			{ Shade::Shade900, { 0x212121, Luminance::Dark } },
-			//
-			{ Shade::ShadeA100, { 0xE0E0E0, Luminance::Light } },
-			{ Shade::ShadeA200, { 0x9E9E9E, Luminance::Light } },
-			{ Shade::ShadeA400, { 0x616161, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0x212121, Luminance::Dark } },
+			{ Shade::Shade50, { 0xFAFAFA } },
+			{ Shade::Shade100, { 0xF5F5F5 } },
+			{ Shade::Shade200, { 0xEEEEEE } },
+			{ Shade::Shade300, { 0xE0E0E0 } },
+			{ Shade::Shade400, { 0xBDBDBD } },
+			{ Shade::Shade500, { 0x9E9E9E } },
+			{ Shade::Shade600, { 0x757575 } },
+			{ Shade::Shade700, { 0x616161 } },
+			{ Shade::Shade800, { 0x424242 } },
+			{ Shade::Shade900, { 0x212121 } },
+			{ Shade::ShadeA100, { 0xE0E0E0 } },
+			{ Shade::ShadeA200, { 0x9E9E9E } },
+			{ Shade::ShadeA400, { 0x616161 } },
+			{ Shade::ShadeA700, { 0x212121 } },
 		} },
 	{ Name::BlueGray,
 		{
-			{ Shade::Shade50, { 0xECEFF1, Luminance::Light } },
-			{ Shade::Shade100, { 0xCFD8DC, Luminance::Light } },
-			{ Shade::Shade200, { 0xB0BEC5, Luminance::Light } },
-			{ Shade::Shade300, { 0x90A4AE, Luminance::Light } },
-			{ Shade::Shade400, { 0x78909C, Luminance::Dark } },
-			{ Shade::Shade500, { 0x607D8B, Luminance::Dark } },
-			{ Shade::Shade600, { 0x546E7A, Luminance::Dark } },
-			{ Shade::Shade700, { 0x455A64, Luminance::Dark } },
-			{ Shade::Shade800, { 0x37474F, Luminance::Dark } },
-			{ Shade::Shade900, { 0x263238, Luminance::Dark } },
-			//
-			{ Shade::ShadeA100, { 0x90A4AE, Luminance::Light } },
-			{ Shade::ShadeA200, { 0x607D8B, Luminance::Dark } },
-			{ Shade::ShadeA400, { 0x455A64, Luminance::Dark } },
-			{ Shade::ShadeA700, { 0x263238, Luminance::Dark } },
+			{ Shade::Shade50, { 0xECEFF1 } },
+			{ Shade::Shade100, { 0xCFD8DC } },
+			{ Shade::Shade200, { 0xB0BEC5 } },
+			{ Shade::Shade300, { 0x90A4AE } },
+			{ Shade::Shade400, { 0x78909C } },
+			{ Shade::Shade500, { 0x607D8B } },
+			{ Shade::Shade600, { 0x546E7A } },
+			{ Shade::Shade700, { 0x455A64 } },
+			{ Shade::Shade800, { 0x37474F } },
+			{ Shade::Shade900, { 0x263238 } },
+			{ Shade::ShadeA100, { 0x90A4AE } },
+			{ Shade::ShadeA200, { 0x607D8B } },
+			{ Shade::ShadeA400, { 0x455A64 } },
+			{ Shade::ShadeA700, { 0x263238 } },
+		} },
+	{ Name::Black,
+		{
+			{ Shade::Shade50, { "black" } },
+			{ Shade::Shade100, { "black" } },
+			{ Shade::Shade200, { "black" } },
+			{ Shade::Shade300, { "black" } },
+			{ Shade::Shade400, { "black" } },
+			{ Shade::Shade500, { "black" } },
+			{ Shade::Shade600, { "black" } },
+			{ Shade::Shade700, { "black" } },
+			{ Shade::Shade800, { "black" } },
+			{ Shade::Shade900, { "black" } },
+			{ Shade::ShadeA100, { "black" } },
+			{ Shade::ShadeA200, { "black" } },
+			{ Shade::ShadeA400, { "black" } },
+			{ Shade::ShadeA700, { "black" } },
+		} },
+	{ Name::White,
+		{
+			{ Shade::Shade50, { "white" } },
+			{ Shade::Shade100, { "white" } },
+			{ Shade::Shade200, { "white" } },
+			{ Shade::Shade300, { "white" } },
+			{ Shade::Shade400, { "white" } },
+			{ Shade::Shade500, { "white" } },
+			{ Shade::Shade600, { "white" } },
+			{ Shade::Shade700, { "white" } },
+			{ Shade::Shade800, { "white" } },
+			{ Shade::Shade900, { "white" } },
+			{ Shade::ShadeA100, { "white" } },
+			{ Shade::ShadeA200, { "white" } },
+			{ Shade::ShadeA400, { "white" } },
+			{ Shade::ShadeA700, { "white" } },
 		} },
 };
 
-static const std::unordered_map<Name, std::unordered_map<Shade, QColor>> g_errorMap = {
+using ShadeColorMap = std::unordered_map<Shade, QColor>;
+using NameShadeColorMap = std::unordered_map<Name, ShadeColorMap>;
+static const NameShadeColorMap g_errorMap = {
 	{ Name::Red,
 		{
-			{ Shade::Shade50, 0x000000 },
-			{ Shade::Shade100, 0x000000 },
-			{ Shade::Shade200, 0x000000 },
 			{ Shade::Shade300, 0x000000 },
-			{ Shade::Shade400, 0x000000 },
-			{ Shade::Shade500, 0x000000 },
 			{ Shade::Shade600, 0x000000 },
-			{ Shade::Shade700, 0x000000 },
 			{ Shade::Shade800, 0x000000 },
 			{ Shade::Shade900, 0x000000 },
-			{ Shade::ShadeA100, 0x000000 },
-			{ Shade::ShadeA200, 0x000000 },
-			{ Shade::ShadeA400, 0x000000 },
-			{ Shade::ShadeA700, 0x000000 },
 		} },
 	{ Name::Pink,
 		{
-			{ Shade::Shade50, 0x000000 },
-			{ Shade::Shade100, 0x000000 },
-			{ Shade::Shade200, 0x000000 },
 			{ Shade::Shade300, 0x000000 },
-			{ Shade::Shade400, 0x000000 },
-			{ Shade::Shade500, 0x000000 },
 			{ Shade::Shade600, 0x000000 },
-			{ Shade::Shade700, 0x000000 },
 			{ Shade::Shade800, 0x000000 },
 			{ Shade::Shade900, 0x000000 },
-			{ Shade::ShadeA100, 0x000000 },
-			{ Shade::ShadeA200, 0x000000 },
-			{ Shade::ShadeA400, 0x000000 },
-			{ Shade::ShadeA700, 0x000000 },
 		} },
 	{ Name::Purple,
 		{
 			{ Shade::Shade300, 0xEF5350 },
-			{ Shade::Shade500, 0xEF5350 },
 			{ Shade::Shade600, 0xEF5350 },
-			{ Shade::Shade900, 0xEF5350 },
+			{ Shade::Shade800, 0xE57373 },
+			{ Shade::Shade900, 0xE57373 },
 		} },
 	{ Name::DeepPurple,
 		{
 			{ Shade::Shade300, 0xEF5350 },
-			{ Shade::Shade500, 0xEF5350 },
 			{ Shade::Shade600, 0xEF5350 },
-			{ Shade::Shade900, 0xEF5350 },
+			{ Shade::Shade800, 0xE57373 },
+			{ Shade::Shade900, 0xE57373 },
 		} },
 	{ Name::Indigo,
 		{
 			{ Shade::Shade300, 0xEF5350 },
-			{ Shade::Shade500, 0xEF5350 },
 			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xEF5350 },
 			{ Shade::Shade900, 0xEF5350 },
 		} },
-	//{ Name::Blue,
-	//	{
-	//		{ Shade::Shade300, 0xD50000 },
-	//		{ Shade::Shade500, 0xD50000 },
-	//		{ Shade::Shade600, 0xD50000 },
-	//		{ Shade::Shade900, 0xD50000 },
-	//	} },
-	//{ Name::LightBlue,
-	//	{
-	//		{ Shade::Shade300, 0xD50000 },
-	//		{ Shade::Shade500, 0xD50000 },
-	//		{ Shade::Shade600, 0xD50000 },
-	//		{ Shade::Shade900, 0xD50000 },
-	//	} },
-	//{ Name::Cyan,
-	//	{
-	//		{ Shade::Shade300, 0xD50000 },
-	//		{ Shade::Shade500, 0xD50000 },
-	//		{ Shade::Shade600, 0xD50000 },
-	//		{ Shade::Shade900, 0xD50000 },
-	//	} },
+	{ Name::Blue,
+		{
+			{ Shade::Shade300, 0xEF5350 },
+			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xE57373 },
+			{ Shade::Shade900, 0xE57373 },
+		} },
+	{ Name::LightBlue,
+		{
+			{ Shade::Shade300, 0xEF5350 },
+			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xE57373 },
+			{ Shade::Shade900, 0xE57373 },
+		} },
+	{ Name::Cyan,
+		{
+			{ Shade::Shade300, 0xEF5350 },
+			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xE57373 },
+			{ Shade::Shade900, 0xE57373 },
+		} },
 	{ Name::Teal,
 		{
 			{ Shade::Shade300, 0xEF5350 },
-			{ Shade::Shade500, 0xEF5350 },
 			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xEF5350 },
+			{ Shade::Shade900, 0xEF5350 },
+		} },
+	{ Name::Green,
+		{
+			{ Shade::Shade300, 0xEF5350 },
+			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xEF5350 },
+			{ Shade::Shade900, 0xEF5350 },
+		} },
+	{ Name::LightGreen,
+		{
+			{ Shade::Shade300, 0xEF5350 },
+			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xEF5350 },
 			{ Shade::Shade900, 0xEF5350 },
 		} },
-	//{ Name::Green,
-	//	{
-	//		{ Shade::Shade300, 0xD50000 },
-	//		{ Shade::Shade500, 0xD50000 },
-	//		{ Shade::Shade600, 0xD50000 },
-	//		{ Shade::Shade900, 0xD50000 },
-	//	} },
-	//{ Name::LightGreen,
-	//	{
-	//		{ Shade::Shade300, 0xD50000 },
-	//		{ Shade::Shade500, 0xD50000 },
-	//		{ Shade::Shade600, 0xD50000 },
-	//		{ Shade::Shade900, 0xD50000 },
-	//	} },
-	//{ Name::Lime,
-	//	{
-	//		{ Shade::Shade300, 0xD50000 },
-	//		{ Shade::Shade500, 0xD50000 },
-	//		{ Shade::Shade600, 0xD50000 },
-	//		{ Shade::Shade900, 0xD50000 },
-	//	} },
-	//{ Name::Yellow,
-	//	{
-	//		{ Shade::Shade300, 0xD50000 },
-	//		{ Shade::Shade500, 0xD50000 },
-	//		{ Shade::Shade600, 0xD50000 },
-	//		{ Shade::Shade900, 0xD50000 },
-	//	} },
-	//{ Name::Amber,
-	//	{
-	//		{ Shade::Shade300, 0xD50000 },
-	//		{ Shade::Shade500, 0xD50000 },
-	//		{ Shade::Shade600, 0xD50000 },
-	//		{ Shade::Shade900, 0xD50000 },
-	//	} },
-	//{ Name::Orange,
-	//	{
-	//		{ Shade::Shade300, 0xD50000 },
-	//		{ Shade::Shade500, 0xD50000 },
-	//		{ Shade::Shade600, 0xD50000 },
-	//		{ Shade::Shade900, 0xD50000 },
-	//	} },
+	{ Name::Lime,
+		{
+			{ Shade::Shade300, 0xEF5350 },
+			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xB71C1C },
+			{ Shade::Shade900, 0xB71C1C },
+		} },
+	{ Name::Yellow,
+		{
+			{ Shade::Shade300, 0xEF5350 },
+			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xD50000 },
+			{ Shade::Shade900, 0xD50000 },
+		} },
+	{ Name::Amber,
+		{
+			{ Shade::Shade300, 0xEF5350 },
+			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xD50000 },
+			{ Shade::Shade900, 0xD50000 },
+		} },
+	{ Name::Orange,
+		{
+			{ Shade::Shade300, 0x000000 },
+			{ Shade::Shade600, 0x000000 },
+			{ Shade::Shade800, 0x000000 },
+			{ Shade::Shade900, 0x000000 },
+		} },
 	{ Name::DeepOrange,
 		{
-			{ Shade::Shade50, 0x000000 },
-			{ Shade::Shade100, 0x000000 },
-			{ Shade::Shade200, 0x000000 },
 			{ Shade::Shade300, 0x000000 },
-			{ Shade::Shade400, 0x000000 },
-			{ Shade::Shade500, 0x000000 },
 			{ Shade::Shade600, 0x000000 },
-			{ Shade::Shade700, 0x000000 },
 			{ Shade::Shade800, 0x000000 },
 			{ Shade::Shade900, 0x000000 },
-			{ Shade::ShadeA100, 0x000000 },
-			{ Shade::ShadeA200, 0x000000 },
-			{ Shade::ShadeA400, 0x000000 },
-			{ Shade::ShadeA700, 0x000000 },
 		} },
 	{ Name::Brown,
 		{
 			{ Shade::Shade300, 0xEF5350 },
-			{ Shade::Shade500, 0xEF5350 },
 			{ Shade::Shade600, 0xEF5350 },
+			{ Shade::Shade800, 0xEF5350 },
 			{ Shade::Shade900, 0xEF5350 },
 		} },
 	{ Name::Gray,
 		{
 			{ Shade::Shade300, 0xFF5252 },
-			{ Shade::Shade500, 0xFF5252 },
 			{ Shade::Shade600, 0xFF5252 },
+			{ Shade::Shade800, 0xFF5252 },
 			{ Shade::Shade900, 0xFF5252 },
 		} },
 	{ Name::BlueGray,
 		{
 			{ Shade::Shade300, 0xFF5252 },
-			{ Shade::Shade500, 0xFF5252 },
 			{ Shade::Shade600, 0xFF5252 },
+			{ Shade::Shade800, 0xFF5252 },
 			{ Shade::Shade900, 0xFF5252 },
 		} },
 };
 
+static const NameShadeColorMap g_warnMap = {
+	{ Name::Red,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+	{ Name::Pink,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+	{ Name::Purple,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+	{ Name::DeepPurple,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+	{ Name::Indigo,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+	{ Name::Blue,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+	{ Name::LightBlue,
+		{
+			{ Shade::Shade800, 0xFFA726 },
+		} },
+	{ Name::Cyan,
+		{
+			{ Shade::Shade800, 0xFFA726 },
+		} },
+	{ Name::Teal,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+	{ Name::Green,
+		{
+			{ Shade::Shade800, 0xFFA726 },
+		} },
+	{ Name::LightGreen,
+		{
+			{ Shade::Shade800, 0xFFA726 },
+		} },
+	{ Name::Lime,
+		{
+			{ Shade::Shade800, 0xFFB74D },
+		} },
+	{ Name::Yellow,
+		{
+			{ Shade::Shade800, 0xE65100 },
+		} },
+	{ Name::Amber,
+		{
+			{ Shade::Shade800, 0xE65100 },
+		} },
+	{ Name::Orange,
+		{
+			{ Shade::Shade800, 0xFFB74D },
+		} },
+	{ Name::DeepOrange,
+		{
+			{ Shade::Shade800, 0xFFB74D },
+		} },
+	{ Name::Brown,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+	{ Name::Gray,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+	{ Name::BlueGray,
+		{
+			{ Shade::Shade800, 0xFF9100 },
+		} },
+};
+
+static const NameShadeColorMap g_infoMap = {
+	{ Name::Red,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::Pink,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::Purple,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::DeepPurple,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::Indigo,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::Blue,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::LightBlue,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::Cyan,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::Teal,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::Green,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::LightGreen,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::Lime,
+		{
+			{ Shade::Shade800, 0xBBDEFB },
+		} },
+	{ Name::Yellow,
+		{
+			{ Shade::Shade800, 0x2979FF },
+		} },
+	{ Name::Amber,
+		{
+			{ Shade::Shade800, 0x2979FF },
+		} },
+	{ Name::Orange,
+		{
+			{ Shade::Shade800, 0xBBDEFB },
+		} },
+	{ Name::DeepOrange,
+		{
+			{ Shade::Shade800, 0xBBDEFB },
+		} },
+	{ Name::Brown,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::Gray,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+	{ Name::BlueGray,
+		{
+			{ Shade::Shade800, 0x90CAF9 },
+		} },
+};
+
+QColor complementary(QColor const& baseColor)
+{
+	auto const r = 255 - baseColor.red();
+	auto const g = 255 - baseColor.green();
+	auto const b = 255 - baseColor.blue();
+
+	return QColor::fromRgb(r, g, b);
+}
+
+static void buildLuminanceMap()
+{
+	for (auto& [name, shadeMap] : g_colorMap)
+	{
+		for (auto& [shade, colData] : shadeMap)
+		{
+			auto const hsl = colData.value.toHsl();
+			auto const light = hsl.lightness();
+			auto const lum = light >= 127 ? Luminance::Light : Luminance::Dark;
+			colData.luminance = lum;
+		}
+	}
+}
+
 static ShadeMap const& shadeMap(Name const name)
 {
+	// First time we're called, build the luminance map
+	static std::once_flag once;
+	std::call_once(once,
+		[]()
+		{
+			buildLuminanceMap();
+		});
+
 	auto const it = g_colorMap.find(name);
 	if (it == std::end(g_colorMap))
 	{
@@ -553,18 +750,29 @@ static ColorData const& colorData(Name const name, Shade const shade)
 	return jt->second;
 }
 
-QColor complementary(QColor const& baseColor)
+QColor value(Name const name, Shade const shade)
 {
-	auto const r = 255 - baseColor.red();
-	auto const g = 255 - baseColor.green();
-	auto const b = 255 - baseColor.blue();
+	return colorData(name, shade).value;
+}
 
-	return QColor::fromRgb(r, g, b);
+QColor foregroundColor()
+{
+	return isDarkColorScheme() ? Qt::white : Qt::black;
 }
 
-QColor value(Name const name, Shade const shade)
+QColor backgroundColor()
 {
-	return colorData(name, shade).value;
+	return isDarkColorScheme() ? Qt::black : Qt::white;
+}
+
+Name backgroundColorName(Luminance const luminance)
+{
+	return luminance == Luminance::Light ? Name::White : Name::Black;
+}
+
+Name backgroundColorName()
+{
+	return isDarkColorScheme() ? Name::Black : Name::White;
 }
 
 QColor foregroundValue(Name const name, Shade const shade)
@@ -587,7 +795,7 @@ QColor foregroundComplementaryValue(Name const name, Shade const shade)
 
 QColor foregroundErrorColorValue(Name const name, Shade const shade)
 {
-	auto errorColor = value(Name::Red, qtMate::material::color::Shade::ShadeA700);
+	auto errorColor = value(Name::Red, qtMate::material::color::Shade::Shade400);
 
 	if (auto const nameMapIt = g_errorMap.find(name); nameMapIt != g_errorMap.end())
 	{
@@ -601,6 +809,38 @@ QColor foregroundErrorColorValue(Name const name, Shade const shade)
 	return errorColor;
 }
 
+QColor foregroundWarningColorValue(Name const name, Shade const shade)
+{
+	auto errorColor = value(Name::Orange, qtMate::material::color::Shade::ShadeA700);
+
+	if (auto const nameMapIt = g_warnMap.find(name); nameMapIt != g_warnMap.end())
+	{
+		auto const& map = nameMapIt->second;
+		if (auto const shadeMapIt = map.find(shade); shadeMapIt != map.end())
+		{
+			errorColor = shadeMapIt->second;
+		}
+	}
+
+	return errorColor;
+}
+
+QColor foregroundInformationColorValue(Name const name, Shade const shade)
+{
+	auto errorColor = value(Name::Blue, qtMate::material::color::Shade::ShadeA400);
+
+	if (auto const nameMapIt = g_infoMap.find(name); nameMapIt != g_infoMap.end())
+	{
+		auto const& map = nameMapIt->second;
+		if (auto const shadeMapIt = map.find(shade); shadeMapIt != map.end())
+		{
+			errorColor = shadeMapIt->second;
+		}
+	}
+
+	return errorColor;
+}
+
 Luminance luminance(Name const name, Shade const shade)
 {
 	return colorData(name, shade).luminance;
@@ -635,6 +875,30 @@ QBrush brush(Name const name, Shade const shade) noexcept
 	return shades[shade];
 }
 
+Shade colorSchemeShade()
+{
+	return isDarkColorScheme() ? DefaultDarkShade : DefaultLightShade;
+}
+
+
+bool isDarkColorScheme()
+{
+	// First check for an application property
+	auto const prop = qApp->property("isDarkColorScheme");
+	if (prop.isValid())
+	{
+		return prop.toBool();
+	}
+
+	// If no application property, check the style hints
+	return QGuiApplication::styleHints()->colorScheme() == Qt::ColorScheme::Dark;
+}
+
+QColor disabledForegroundColor()
+{
+	return value(Name::Gray, isDarkColorScheme() ? Shade::ShadeA200 : Shade::Shade500);
+}
+
 } // namespace color
 } // namespace material
 } // namespace qtMate
diff --git a/libs/QtMate/material/colorPalette.cpp b/libs/QtMate/material/colorPalette.cpp
index 12cd7412..ff97a5c2 100644
--- a/libs/QtMate/material/colorPalette.cpp
+++ b/libs/QtMate/material/colorPalette.cpp
@@ -69,7 +69,7 @@ QPixmap pixmap(Name const name, Shade const shade)
 
 int Palette::nameCount()
 {
-	return static_cast<int>(Name::NameCount);
+	return static_cast<int>(Name::NameCount) - 2; // Remove black and white
 }
 
 int Palette::shadeCount()
@@ -131,6 +131,10 @@ QString Palette::nameToString(Name const name)
 			return "Gray";
 		case Name::BlueGray:
 			return "Blue Gray";
+		case Name::Black:
+			return "Black";
+		case Name::White:
+			return "White";
 		default:
 			assert(false);
 			return "Undefined";
diff --git a/libs/QtMate/material/helper.cpp b/libs/QtMate/material/helper.cpp
index d019c134..31c55004 100644
--- a/libs/QtMate/material/helper.cpp
+++ b/libs/QtMate/material/helper.cpp
@@ -40,7 +40,7 @@ QIcon generateIcon(QString const& what, QColor const& color)
 
 		QFont font{ "Material Icons" };
 		font.setStyleStrategy(QFont::PreferQuality);
-		font.setPointSize(size - 8);
+		font.setPointSize(size / 2);
 
 		painter.setFont(font);
 
@@ -55,7 +55,7 @@ QIcon generateIcon(QString const& what, QColor const& color)
 	for (auto const size : { 16, 32, 64, 128 })
 	{
 		icon.addPixmap(generatePixmap(size, 1));
-		//icon.addPixmap(generatePixmap(size, 2));
+		icon.addPixmap(generatePixmap(size, 2));
 	}
 
 	return icon;
diff --git a/libs/QtMate/pch.hpp b/libs/QtMate/pch.hpp
index 1fab2ac7..b4bdfd4d 100644
--- a/libs/QtMate/pch.hpp
+++ b/libs/QtMate/pch.hpp
@@ -19,24 +19,6 @@
 
 #pragma once
 
-// Public Headers
-#include "QtMate/material/color.hpp"
-#include "QtMate/material/colorPalette.hpp"
-#include "QtMate/material/helper.hpp"
-#include "QtMate/graph/connection.hpp"
-#include "QtMate/graph/inputSocket.hpp"
-#include "QtMate/graph/node.hpp"
-#include "QtMate/graph/outputSocket.hpp"
-#include "QtMate/graph/socket.hpp"
-#include "QtMate/graph/type.hpp"
-#include "QtMate/graph/view.hpp"
-#include "QtMate/widgets/comboBox.hpp"
-#include "QtMate/widgets/dynamicHeaderView.hpp"
-#include "QtMate/widgets/flatIconButton.hpp"
-#include "QtMate/widgets/tableView.hpp"
-#include "QtMate/widgets/textEntry.hpp"
-#include "QtMate/widgets/tickableMenu.hpp"
-
 // Qt Headers
 #include <QAbstractItemView>
 #include <QAbstractTableModel>
diff --git a/libs/QtMate/widgets/dynamicHeaderView.cpp b/libs/QtMate/widgets/dynamicHeaderView.cpp
index 23748e28..75d0bfa1 100644
--- a/libs/QtMate/widgets/dynamicHeaderView.cpp
+++ b/libs/QtMate/widgets/dynamicHeaderView.cpp
@@ -33,22 +33,15 @@ DynamicHeaderView::DynamicHeaderView(Qt::Orientation orientation, QWidget* paren
 	connect(this, &QHeaderView::sectionResized, this, &DynamicHeaderView::sectionChanged);
 }
 
-int DynamicHeaderView::mandatorySection() const
+void DynamicHeaderView::setMandatorySection(int const mandatorySection)
 {
-	return _mandatorySection;
-}
-
-void DynamicHeaderView::setMandatorySection(int mandatorySection)
-{
-	_mandatorySection = mandatorySection;
+	_mandatorySections.insert(mandatorySection);
 }
 
 void DynamicHeaderView::customContextMenuRequested(QPoint const& pos)
 {
 	QMenu menu;
 
-	auto const mandatorySection = qMax(0, qMin(_mandatorySection, count()));
-
 	for (auto section = 0; section < count(); ++section)
 	{
 		auto const text = model()->headerData(section, orientation(), Qt::DisplayRole).toString();
@@ -56,7 +49,8 @@ void DynamicHeaderView::customContextMenuRequested(QPoint const& pos)
 		auto* action = menu.addAction(text);
 		action->setData(section);
 		action->setCheckable(true);
-		action->setEnabled(section != mandatorySection);
+		auto const isEnabled = _mandatorySections.count(section) == 0;
+		action->setEnabled(isEnabled);
 		action->setChecked(!isSectionHidden(section));
 	}
 	menu.addSeparator();
diff --git a/libs/modelsLibrary/CMakeLists.txt b/libs/modelsLibrary/CMakeLists.txt
index aa67e763..eb34cbd9 100644
--- a/libs/modelsLibrary/CMakeLists.txt
+++ b/libs/modelsLibrary/CMakeLists.txt
@@ -48,6 +48,7 @@ set(HEADER_FILES_PUBLIC
 
 set(HEADER_FILES_COMMON
 	commandsExecutorImpl.hpp
+	virtualController.hpp
 )
 
 set(SOURCE_FILES_COMMON
@@ -57,6 +58,7 @@ set(SOURCE_FILES_COMMON
 	controllerManager.cpp
 	networkInterfacesModel.cpp
 	discoveredEntitiesModel.cpp
+	virtualController.cpp
 )
 
 if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
diff --git a/libs/modelsLibrary/controllerManager.cpp b/libs/modelsLibrary/controllerManager.cpp
index 91d34f37..a450f03c 100644
--- a/libs/modelsLibrary/controllerManager.cpp
+++ b/libs/modelsLibrary/controllerManager.cpp
@@ -18,6 +18,7 @@
 */
 
 #include "commandsExecutorImpl.hpp"
+#include "virtualController.hpp"
 #include "hive/modelsLibrary/controllerManager.hpp"
 
 #include <la/avdecc/logger.hpp>
@@ -41,7 +42,7 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 
 	class EntityDataCache
 	{
-		class InitVisitor : public la::avdecc::controller::model::EntityModelVisitor
+		class InitVisitor : public la::avdecc::controller::model::DefaultedEntityModelVisitor
 		{
 		public:
 			InitVisitor(EntityDataCache& entityCache)
@@ -50,7 +51,7 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 			}
 
 		protected:
-			// la::avdecc::controller::model::EntityModelVisitor overrides
+			// la::avdecc::controller::model::DefaultedEntityModelVisitor overrides
 			virtual void visit(la::avdecc::controller::ControlledEntity const* const entity, la::avdecc::controller::model::EntityNode const& /*node*/) noexcept override
 			{
 				// Initialize internal counter value, always setting lastClearCount to 0 (Statistics counters always start at 0 in the Controller, contrary to endpoint Counters) so that we directly see any error during enumeration
@@ -76,9 +77,9 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 			}
 			virtual void visit(la::avdecc::controller::ControlledEntity const* const /*entity*/, la::avdecc::controller::model::ConfigurationNode const* const /*parent*/, la::avdecc::controller::model::StreamInputNode const& node) noexcept override
 			{
-				if (node.dynamicModel->counters)
+				if (node.dynamicModel.counters)
 				{
-					for (auto const [flag, counter] : *node.dynamicModel->counters)
+					for (auto const [flag, counter] : *node.dynamicModel.counters)
 					{
 						// Initialize internal counter value
 						_entityCache._streamInputCounters[node.descriptorIndex][flag] = ErrorCounterInfo{ counter, counter };
@@ -90,7 +91,7 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 			EntityDataCache& _entityCache;
 		};
 
-		class ClearCounterVisitor : public la::avdecc::controller::model::EntityModelVisitor
+		class ClearCounterVisitor : public la::avdecc::controller::model::DefaultedEntityModelVisitor
 		{
 		public:
 			ClearCounterVisitor(ControllerManager& manager, EntityDataCache& entityCache)
@@ -307,11 +308,21 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 			_diagnostics = diags;
 		}
 
+		bool getControlCurrentValueOutOfBoundsError(la::avdecc::entity::model::ControlIndex const controlIndex) const noexcept
+		{
+			return _diagnostics.controlCurrentValueOutOfBounds.count(controlIndex) > 0;
+		}
+
 		bool getStreamInputLatencyError(la::avdecc::entity::model::StreamIndex const streamIndex) const noexcept
 		{
 			return _diagnostics.streamInputOverLatency.count(streamIndex) > 0;
 		}
 
+		bool getControlValueOutOfBounds(la::avdecc::entity::model::ControlIndex const controlIndex) const noexcept
+		{
+			return _diagnostics.controlCurrentValueOutOfBounds.count(controlIndex) > 0;
+		}
+
 	private:
 		struct ErrorCounterInfo
 		{
@@ -565,6 +576,14 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 	{
 		emit streamNameChanged(entity->getEntity().getEntityID(), configurationIndex, la::avdecc::entity::model::DescriptorType::StreamOutput, streamIndex, QString::fromStdString(streamName));
 	}
+	virtual void onJackInputNameChanged(la::avdecc::controller::Controller const* const /*controller*/, la::avdecc::controller::ControlledEntity const* const entity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, la::avdecc::entity::model::AvdeccFixedString const& jackName) noexcept override
+	{
+		emit jackNameChanged(entity->getEntity().getEntityID(), configurationIndex, la::avdecc::entity::model::DescriptorType::JackInput, jackIndex, QString::fromStdString(jackName));
+	}
+	virtual void onJackOutputNameChanged(la::avdecc::controller::Controller const* const /*controller*/, la::avdecc::controller::ControlledEntity const* const entity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, la::avdecc::entity::model::AvdeccFixedString const& jackName) noexcept override
+	{
+		emit jackNameChanged(entity->getEntity().getEntityID(), configurationIndex, la::avdecc::entity::model::DescriptorType::JackOutput, jackIndex, QString::fromStdString(jackName));
+	}
 	virtual void onAvbInterfaceNameChanged(la::avdecc::controller::Controller const* const /*controller*/, la::avdecc::controller::ControlledEntity const* const entity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, la::avdecc::entity::model::AvdeccFixedString const& avbInterfaceName) noexcept override
 	{
 		emit avbInterfaceNameChanged(entity->getEntity().getEntityID(), configurationIndex, avbInterfaceIndex, QString::fromStdString(avbInterfaceName));
@@ -663,8 +682,8 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 					try
 					{
 						auto const& entityNode = entity->getEntityNode();
-						auto const& streamNode = entity->getStreamInputNode(entityNode.dynamicModel->currentConfiguration, streamIndex);
-						if (streamNode.dynamicModel->connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected)
+						auto const& streamNode = entity->getStreamInputNode(entityNode.dynamicModel.currentConfiguration, streamIndex);
+						if (streamNode.dynamicModel.connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected)
 						{
 							// Only consider MediaUnlocked as an error if the stream is connected, otherwise juste ignore this
 							break;
@@ -858,6 +877,28 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 						}
 					}
 
+					// Check for ControlCurrentValueOutOfBounds state change
+					{
+						auto const oldControlsErrors = entityCache->getDiagnostics().controlCurrentValueOutOfBounds;
+
+						// Check for no longer in error (present in old but not in new)
+						for (auto const controlIndex : oldControlsErrors)
+						{
+							if (diags.controlCurrentValueOutOfBounds.count(controlIndex) == 0)
+							{
+								emit controlCurrentValueOutOfBoundsChanged(entityID, controlIndex, false);
+							}
+						}
+						// Check for newly in error (not present in old but present in new)
+						for (auto const controlIndex : diags.controlCurrentValueOutOfBounds)
+						{
+							if (oldControlsErrors.count(controlIndex) == 0)
+							{
+								emit controlCurrentValueOutOfBoundsChanged(entityID, controlIndex, true);
+							}
+						}
+					}
+
 					// Update diags cache
 					entityCache->setDiagnostics(diags);
 
@@ -882,8 +923,14 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 			destroyController();
 		}
 
+		// Create a new virtual controller
+		_virtualController = VirtualController{};
+
 		// Create a new controller and store it
-		SharedController controller = la::avdecc::controller::Controller::create(protocolInterfaceType, interfaceName.toStdString(), progID, entityModelID, preferedLocale.toStdString(), entityModel);
+		SharedController controller = la::avdecc::controller::Controller::create(protocolInterfaceType, interfaceName.toStdString(), progID, entityModelID, preferedLocale.toStdString(), entityModel, std::nullopt, &_virtualController);
+
+		_virtualController.setControllerEID(controller->getControllerEID());
+
 #if HAVE_ATOMIC_SMART_POINTERS
 		_controller = std::move(controller);
 #else // !HAVE_ATOMIC_SMART_POINTERS
@@ -1005,6 +1052,41 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 		return { la::avdecc::jsonSerializer::DeserializationError::InternalError, "Controller offline" };
 	}
 
+	virtual bool refreshEntity(la::avdecc::UniqueIdentifier const entityID) noexcept override
+	{
+		auto controller = getController();
+		if (controller)
+		{
+			return controller->refreshEntity(entityID);
+		}
+		return false;
+	}
+
+	virtual bool unloadVirtualEntity(la::avdecc::UniqueIdentifier const entityID) noexcept override
+	{
+		auto controller = getController();
+		if (controller)
+		{
+			return controller->unloadVirtualEntity(entityID);
+		}
+		return false;
+	}
+
+	virtual la::avdecc::entity::model::StreamFormat chooseBestStreamFormat(la::avdecc::entity::model::StreamFormats const& availableFormats, la::avdecc::entity::model::StreamFormat const desiredStreamFormat, std::function<bool(bool const isDesiredClockSync, bool const isAvailableClockSync)> const& clockValidator) noexcept override
+	{
+		return la::avdecc::controller::Controller::chooseBestStreamFormat(availableFormats, desiredStreamFormat, clockValidator);
+	}
+
+	virtual bool isMediaClockStreamFormat(la::avdecc::entity::model::StreamFormat const streamFormat) noexcept override
+	{
+		return la::avdecc::controller::Controller::isMediaClockStreamFormat(streamFormat);
+	}
+
+	virtual std::optional<std::string> computeEntityModelChecksum(la::avdecc::controller::ControlledEntity const& controlledEntity, std::uint32_t const checksumVersion) noexcept override
+	{
+		return la::avdecc::controller::Controller::computeEntityModelChecksum(controlledEntity, checksumVersion);
+	}
+
 	virtual void setEnableAemCache(bool const enable) noexcept override
 	{
 		_enableAemCache = enable;
@@ -1137,6 +1219,15 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 		return {};
 	}
 
+	virtual bool getControlValueOutOfBounds(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex) const noexcept override
+	{
+		if (auto* entityCache = entityCachedData(entityID))
+		{
+			return entityCache->getControlValueOutOfBounds(controlIndex);
+		}
+		return {};
+	}
+
 	/* Discovery Protocol (ADP) */
 	virtual bool enableEntityAdvertising(std::uint32_t const availableDuration, std::optional<la::avdecc::entity::model::AvbInterfaceIndex> const interfaceIndex) noexcept
 	{
@@ -1588,6 +1679,62 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 		}
 	}
 
+	virtual void setJackInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, QString const& name, BeginCommandHandler const& beginHandler, SetJackInputNameHandler const& resultHandler) noexcept override
+	{
+		auto controller = getController();
+		if (controller)
+		{
+			if (beginHandler)
+			{
+				la::avdecc::utils::invokeProtectedHandler(beginHandler, targetEntityID);
+			}
+			else
+			{
+				emit beginAecpCommand(targetEntityID, AecpCommandType::SetJackName, jackIndex);
+			}
+			controller->setJackInputName(targetEntityID, configurationIndex, jackIndex, name.toStdString(),
+				[this, targetEntityID, jackIndex, resultHandler](la::avdecc::controller::ControlledEntity const* const /*entity*/, la::avdecc::entity::ControllerEntity::AemCommandStatus const status) noexcept
+				{
+					if (resultHandler)
+					{
+						la::avdecc::utils::invokeProtectedHandler(resultHandler, targetEntityID, status);
+					}
+					else
+					{
+						emit endAecpCommand(targetEntityID, AecpCommandType::SetJackName, jackIndex, status);
+					}
+				});
+		}
+	}
+
+	virtual void setJackOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, QString const& name, BeginCommandHandler const& beginHandler, SetJackOutputNameHandler const& resultHandler) noexcept override
+	{
+		auto controller = getController();
+		if (controller)
+		{
+			if (beginHandler)
+			{
+				la::avdecc::utils::invokeProtectedHandler(beginHandler, targetEntityID);
+			}
+			else
+			{
+				emit beginAecpCommand(targetEntityID, AecpCommandType::SetJackName, jackIndex);
+			}
+			controller->setJackOutputName(targetEntityID, configurationIndex, jackIndex, name.toStdString(),
+				[this, targetEntityID, jackIndex, resultHandler](la::avdecc::controller::ControlledEntity const* const /*entity*/, la::avdecc::entity::ControllerEntity::AemCommandStatus const status) noexcept
+				{
+					if (resultHandler)
+					{
+						la::avdecc::utils::invokeProtectedHandler(resultHandler, targetEntityID, status);
+					}
+					else
+					{
+						emit endAecpCommand(targetEntityID, AecpCommandType::SetJackName, jackIndex, status);
+					}
+				});
+		}
+	}
+
 	virtual void setAvbInterfaceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, QString const& name, BeginCommandHandler const& beginHandler, SetAvbInterfaceNameHandler const& resultHandler) noexcept override
 	{
 		auto controller = getController();
@@ -2356,6 +2503,7 @@ class ControllerManagerImpl final : public ControllerManager, private la::avdecc
 	std::chrono::milliseconds _discoveryDelay{};
 	bool _enableAemCache{ false };
 	bool _fullAemEnumeration{ false };
+	VirtualController _virtualController{};
 };
 
 QString ControllerManager::typeToString(AecpCommandType const type) noexcept
@@ -2389,6 +2537,8 @@ QString ControllerManager::typeToString(AecpCommandType const type) noexcept
 			return "Set Stream Name";
 		case AecpCommandType::SetStreamInfo:
 			return "Set Stream Info";
+		case AecpCommandType::SetJackName:
+			return "Set Jack Name";
 		case AecpCommandType::SetAvbInterfaceName:
 			return "Set AVB Interface Name";
 		case AecpCommandType::SetClockSourceName:
diff --git a/libs/modelsLibrary/discoveredEntitiesModel.cpp b/libs/modelsLibrary/discoveredEntitiesModel.cpp
index fd8edb24..49f98527 100644
--- a/libs/modelsLibrary/discoveredEntitiesModel.cpp
+++ b/libs/modelsLibrary/discoveredEntitiesModel.cpp
@@ -61,6 +61,7 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::statisticsErrorCounterChanged, this, &pImpl::handleStatisticsErrorCounterChanged);
 		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::diagnosticsChanged, this, &pImpl::handleDiagnosticsChanged);
 		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::mediaClockChainChanged, this, &pImpl::handleMediaClockChainChanged);
+		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::clockDomainCountersChanged, this, &pImpl::handleClockDomainCountersChanged);
 	}
 
 	std::optional<std::reference_wrapper<Entity const>> entity(std::size_t const index) const noexcept
@@ -83,6 +84,17 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 		return {};
 	}
 
+	// Returns the entity index if found in the model
+	std::optional<std::size_t> indexOf(la::avdecc::UniqueIdentifier const& entityID) const noexcept
+	{
+		// Check if the entity is still online
+		if (auto const it = _entityRowMap.find(entityID); it != std::end(_entityRowMap))
+		{
+			return it->second;
+		}
+		return {};
+	}
+
 	std::size_t entitiesCount() const noexcept
 	{
 		return _entities.size();
@@ -382,17 +394,6 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 		return index < _entities.size();
 	}
 
-	// Returns the entity index if found in the model
-	std::optional<std::size_t> indexOf(la::avdecc::UniqueIdentifier const& entityID) const noexcept
-	{
-		// Check if the entity is still online
-		if (auto const it = _entityRowMap.find(entityID); it != std::end(_entityRowMap))
-		{
-			return it->second;
-		}
-		return {};
-	}
-
 	// Build the entityID to row map
 	void rebuildEntityRowMap() noexcept
 	{
@@ -428,12 +429,15 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 				auto firmwareUploadMemoryIndex = decltype(Entity::firmwareUploadMemoryIndex){ std::nullopt };
 				auto firmwareVersion = decltype(Entity::firmwareVersion){ std::nullopt };
 				auto mediaClockReferences = decltype(Entity::mediaClockReferences){};
+				auto clockDomainInfo = decltype(Entity::clockDomainInfo){};
 
-				// Build gptp info map
+				// Build gptp info and macAddresses maps
 				auto gptpInfo = decltype(Entity::gptpInfo){};
+				auto macAddresses = decltype(Entity::macAddresses){};
 				for (auto const& [avbInterfaceIndex, interfaceInformation] : e.getInterfacesInformation())
 				{
 					gptpInfo.insert(std::make_pair(avbInterfaceIndex, GptpInfo{ interfaceInformation.gptpGrandmasterID, interfaceInformation.gptpDomainNumber }));
+					macAddresses.insert(std::make_pair(avbInterfaceIndex, interfaceInformation.macAddress));
 				}
 
 				// Check if AEM is supported
@@ -445,37 +449,40 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 				{
 					// Get firmware version
 					auto const& entityNode = entity.getEntityNode();
-					if (entityNode.dynamicModel)
-					{
-						auto const& dynamicModel = *entityNode.dynamicModel;
+					auto const& dynamicModel = entityNode.dynamicModel;
 
-						// Get firmware version
-						firmwareVersion = dynamicModel.firmwareVersion.data();
+					// Get firmware version
+					firmwareVersion = dynamicModel.firmwareVersion.data();
 
-						if (hasAnyConfiguration)
-						{
-							auto const configurationIndex = dynamicModel.currentConfiguration;
-							auto const& configurationNode = entity.getConfigurationNode(configurationIndex);
+					if (hasAnyConfiguration)
+					{
+						auto const& configurationNode = entity.getCurrentConfigurationNode();
 
-							// Get Firmware Image MemoryIndex, if supported
-							for (auto const& [memoryObjectIndex, memoryObjectNode] : configurationNode.memoryObjects)
+						// Get Firmware Image MemoryIndex, if supported
+						for (auto const& [memoryObjectIndex, memoryObjectNode] : configurationNode.memoryObjects)
+						{
+							if (memoryObjectNode.staticModel.memoryObjectType == la::avdecc::entity::model::MemoryObjectType::FirmwareImage)
 							{
-								if (memoryObjectNode.staticModel->memoryObjectType == la::avdecc::entity::model::MemoryObjectType::FirmwareImage)
-								{
-									firmwareUploadMemoryIndex = memoryObjectIndex;
-									break;
-								}
+								firmwareUploadMemoryIndex = memoryObjectIndex;
+								break;
 							}
 						}
-					}
 
-					// Build MediaClockReferences map
-					if (hasAnyConfiguration)
-					{
-						for (auto const& [cdIndex, cdNode] : entity.getCurrentConfigurationNode().clockDomains)
+						// Build MediaClockReferences map
+						for (auto const& [cdIndex, cdNode] : configurationNode.clockDomains)
 						{
 							mediaClockReferences.insert(std::make_pair(cdIndex, computeMediaClockReference(cdNode.mediaClockChain)));
 						}
+
+						// Get ClockDomain Locked status
+						if (!configurationNode.clockDomains.empty())
+						{
+							auto const& clockDomainNode = configurationNode.clockDomains.begin()->second;
+							if (clockDomainNode.dynamicModel.counters)
+							{
+								clockDomainInfo = computeClockDomainInfo(*(clockDomainNode.dynamicModel.counters));
+							}
+						}
 					}
 				}
 
@@ -484,8 +491,8 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 				auto const diagnostics = manager.getDiagnostics(entityID);
 
 				// Build a discovered entity
-				auto discoveredEntity = Entity{ entityID, isAemSupported, hasAnyConfiguration, entity.isVirtual(), e.getEntityModelID(), firmwareVersion, firmwareUploadMemoryIndex, entity.getMilanInfo(), helper::entityName(entity), helper::groupName(entity), entity.isSubscribedToUnsolicitedNotifications(), computeProtocolCompatibility(entity.getMilanInfo(), entity.getCompatibilityFlags()), e.getEntityCapabilities(), computeExclusiveInfo(isAemSupported && hasAnyConfiguration, entity.getAcquireState(), entity.getOwningControllerID()), computeExclusiveInfo(isAemSupported && hasAnyConfiguration, entity.getLockState(), entity.getLockingControllerID()), std::move(gptpInfo), e.getAssociationID(), std::move(mediaClockReferences), entity.isIdentifying(), !statisticsCounters.empty(),
-					diagnostics.redundancyWarning, {}, diagnostics.streamInputOverLatency };
+				auto discoveredEntity = Entity{ entityID, isAemSupported, hasAnyConfiguration, entity.isVirtual(), entity.areUnsolicitedNotificationsSupported(), e.getEntityModelID(), firmwareVersion, firmwareUploadMemoryIndex, entity.getMilanInfo(), std::move(macAddresses), helper::entityName(entity), helper::groupName(entity), entity.isSubscribedToUnsolicitedNotifications(), computeProtocolCompatibility(entity.getMilanInfo(), entity.getCompatibilityFlags()), e.getEntityCapabilities(), computeExclusiveInfo(isAemSupported && hasAnyConfiguration, entity.getAcquireState(), entity.getOwningControllerID()), computeExclusiveInfo(isAemSupported && hasAnyConfiguration, entity.getLockState(), entity.getLockingControllerID()), std::move(gptpInfo), e.getAssociationID(), std::move(mediaClockReferences),
+					entity.isIdentifying(), !statisticsCounters.empty(), diagnostics.redundancyWarning, std::move(clockDomainInfo), {}, diagnostics.streamInputOverLatency, diagnostics.controlCurrentValueOutOfBounds };
 
 				// Insert at the end
 				auto const row = _model->rowCount();
@@ -723,7 +730,7 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 					data.mediaClockReferences[cdIndex] = computeMediaClockReference(mcr.mcChain);
 
 					// And notify
-					la::avdecc::utils::invokeProtectedMethod(&Model::entityInfoChanged, _model, idx, data, Model::ChangedInfoFlags{ Model::ChangedInfoFlag::MediaClockReferenceStatus });
+					la::avdecc::utils::invokeProtectedMethod(&Model::entityInfoChanged, _model, idx, data, Model::ChangedInfoFlags{ Model::ChangedInfoFlag::MediaClockReferenceName });
 				}
 			}
 		}
@@ -758,7 +765,7 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 					data.mediaClockReferences[cdIndex] = computeMediaClockReference(mcr.mcChain);
 
 					// And notify
-					la::avdecc::utils::invokeProtectedMethod(&Model::entityInfoChanged, _model, idx, data, Model::ChangedInfoFlags{ Model::ChangedInfoFlag::MediaClockReferenceStatus });
+					la::avdecc::utils::invokeProtectedMethod(&Model::entityInfoChanged, _model, idx, data, Model::ChangedInfoFlags{ Model::ChangedInfoFlag::MediaClockReferenceName });
 				}
 			}
 		}
@@ -848,9 +855,11 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 
 			auto const wasRedundancyWarning = data.hasRedundancyWarning;
 			auto const wasStreamInputLatencyError = !data.streamsWithLatencyError.empty();
+			auto const wasControlValueOutOfBounds = !data.controlsWithOutOfBoundsValue.empty();
 
 			auto nowRedundancyWarning = false;
 			auto nowStreamInputLatencyError = false;
+			auto nowControlValueOutOfBounds = false;
 
 			// Redundancy Warning
 			{
@@ -864,6 +873,12 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 				nowStreamInputLatencyError = !diagnostics.streamInputOverLatency.empty();
 			}
 
+			// Control OutOfBounds Value Error
+			{
+				data.controlsWithOutOfBoundsValue = diagnostics.controlCurrentValueOutOfBounds;
+				nowControlValueOutOfBounds = !diagnostics.controlCurrentValueOutOfBounds.empty();
+			}
+
 			// Check what changed
 			auto changedFlags = Model::ChangedInfoFlags{};
 			if (wasRedundancyWarning != nowRedundancyWarning)
@@ -874,6 +889,10 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 			{
 				changedFlags.set(Model::ChangedInfoFlag::StreamInputLatencyError);
 			}
+			if (wasControlValueOutOfBounds != nowControlValueOutOfBounds)
+			{
+				changedFlags.set(Model::ChangedInfoFlag::ControlValueOutOfBoundsError);
+			}
 
 			// Notify if something changed
 			if (!changedFlags.empty())
@@ -892,10 +911,45 @@ class DiscoveredEntitiesModel::pImpl : public QObject
 
 			data.mediaClockReferences[clockDomainIndex] = computeMediaClockReference(mcChain);
 
-			la::avdecc::utils::invokeProtectedMethod(&Model::entityInfoChanged, _model, idx, data, Model::ChangedInfoFlags{ Model::ChangedInfoFlag::MediaClockReferenceID, Model::ChangedInfoFlag::MediaClockReferenceStatus });
+			la::avdecc::utils::invokeProtectedMethod(&Model::entityInfoChanged, _model, idx, data, Model::ChangedInfoFlags{ Model::ChangedInfoFlag::MediaClockReferenceID, Model::ChangedInfoFlag::MediaClockReferenceName });
 		}
 	}
 
+	void handleClockDomainCountersChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ClockDomainIndex const /*clockDomainIndex*/, la::avdecc::entity::model::ClockDomainCounters const& counters)
+	{
+		if (auto const index = indexOf(entityID))
+		{
+			auto const idx = *index;
+			auto& data = _entities[idx];
+
+			data.clockDomainInfo = computeClockDomainInfo(counters);
+
+			la::avdecc::utils::invokeProtectedMethod(&Model::entityInfoChanged, _model, idx, data, Model::ChangedInfoFlags{ Model::ChangedInfoFlag::ClockDomainLockState });
+		}
+	}
+
+	ClockDomainInfo computeClockDomainInfo(la::avdecc::entity::model::ClockDomainCounters const& counters) noexcept
+	{
+		auto clockDomainInfo = ClockDomainInfo{ ClockDomainLockedState::Unknown };
+
+		auto const itLocked = counters.find(la::avdecc::entity::ClockDomainCounterValidFlag::Locked);
+		auto const itUnlocked = counters.find(la::avdecc::entity::ClockDomainCounterValidFlag::Unlocked);
+		if (itLocked != counters.end() && itUnlocked != counters.end())
+		{
+			if (itLocked->second > itUnlocked->second)
+			{
+				clockDomainInfo.state = ClockDomainLockedState::Locked;
+				clockDomainInfo.tooltip = QString("Clock Domain is locked on MCR");
+			}
+			else
+			{
+				clockDomainInfo.state = ClockDomainLockedState::Unlocked;
+				clockDomainInfo.tooltip = QString("Clock Domain is not locked");
+			}
+		}
+		return clockDomainInfo;
+	}
+
 	// Private Members
 	Model* _model{ nullptr };
 	std::vector<Entity> _entities{};
@@ -919,6 +973,11 @@ std::optional<std::reference_wrapper<DiscoveredEntitiesModel::Entity const>> Dis
 	return _pImpl->entity(entityID);
 }
 
+std::optional<std::size_t> DiscoveredEntitiesModel::indexOf(la::avdecc::UniqueIdentifier const& entityID) const noexcept
+{
+	return _pImpl->indexOf(entityID);
+}
+
 std::size_t DiscoveredEntitiesModel::entitiesCount() const noexcept
 {
 	return _pImpl->entitiesCount();
diff --git a/libs/modelsLibrary/helper.cpp b/libs/modelsLibrary/helper.cpp
index 57192b0c..ef841410 100644
--- a/libs/modelsLibrary/helper.cpp
+++ b/libs/modelsLibrary/helper.cpp
@@ -35,6 +35,11 @@ QString uniqueIdentifierToString(la::avdecc::UniqueIdentifier const& identifier)
 	return toHexQString(identifier.getValue(), true, true);
 }
 
+QString macAddressToString(la::networkInterface::MacAddress const& macAddress)
+{
+	return QString::fromStdString(la::networkInterface::NetworkInterfaceHelper::macAddressToString(macAddress));
+}
+
 QString configurationName(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const& node) noexcept
 {
 	return objectName(controlledEntity, node.descriptorIndex, node);
@@ -70,7 +75,7 @@ QString entityName(la::avdecc::controller::ControlledEntity const& controlledEnt
 
 		if (entity.getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported))
 		{
-			return controlledEntity.getEntityNode().dynamicModel->entityName.data();
+			return controlledEntity.getEntityNode().dynamicModel.entityName.data();
 		}
 	}
 	catch (la::avdecc::controller::ControlledEntity::Exception const&)
@@ -92,7 +97,23 @@ QString smartEntityName(la::avdecc::controller::ControlledEntity const& controll
 	name = entityName(controlledEntity);
 
 	if (name.isEmpty())
+	{
 		name = uniqueIdentifierToString(controlledEntity.getEntity().getEntityID());
+	}
+
+	return name;
+}
+
+QString smartEntityName(hive::modelsLibrary::DiscoveredEntitiesModel::Entity const& entity) noexcept
+{
+	QString name;
+
+	name = entity.name;
+
+	if (name.isEmpty())
+	{
+		name = uniqueIdentifierToString(entity.entityID);
+	}
 
 	return name;
 }
@@ -105,7 +126,7 @@ QString groupName(la::avdecc::controller::ControlledEntity const& controlledEnti
 
 		if (entity.getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported))
 		{
-			return controlledEntity.getEntityNode().dynamicModel->groupName.data();
+			return controlledEntity.getEntityNode().dynamicModel.groupName.data();
 		}
 	}
 	catch (la::avdecc::controller::ControlledEntity::Exception const&)
@@ -125,7 +146,7 @@ QString outputStreamName(la::avdecc::controller::ControlledEntity const& control
 	try
 	{
 		auto const& entityNode = controlledEntity.getEntityNode();
-		auto const& streamNode = controlledEntity.getStreamOutputNode(entityNode.dynamicModel->currentConfiguration, streamIndex);
+		auto const& streamNode = controlledEntity.getStreamOutputNode(entityNode.dynamicModel.currentConfiguration, streamIndex);
 		return objectName(&controlledEntity, streamNode);
 	}
 	catch (la::avdecc::controller::ControlledEntity::Exception const&)
@@ -145,7 +166,7 @@ QString inputStreamName(la::avdecc::controller::ControlledEntity const& controll
 	try
 	{
 		auto const& entityNode = controlledEntity.getEntityNode();
-		auto const& streamNode = controlledEntity.getStreamInputNode(entityNode.dynamicModel->currentConfiguration, streamIndex);
+		auto const& streamNode = controlledEntity.getStreamInputNode(entityNode.dynamicModel.currentConfiguration, streamIndex);
 		return objectName(&controlledEntity, streamNode);
 	}
 	catch (la::avdecc::controller::ControlledEntity::Exception const&)
diff --git a/libs/modelsLibrary/pch.hpp b/libs/modelsLibrary/pch.hpp
index 3ba1eadf..ef889a86 100644
--- a/libs/modelsLibrary/pch.hpp
+++ b/libs/modelsLibrary/pch.hpp
@@ -19,13 +19,6 @@
 
 #pragma once
 
-// Public Headers
-#include "hive/modelsLibrary/controllerManager.hpp"
-#include "hive/modelsLibrary/discoveredEntitiesModel.hpp"
-#include "hive/modelsLibrary/helper.hpp"
-#include "hive/modelsLibrary/modelsLibrary.hpp"
-#include "hive/modelsLibrary/networkInterfacesModel.hpp"
-
 // Other Headers
 #include <la/networkInterfaceHelper/networkInterfaceHelper.hpp>
 #include <la/avdecc/avdecc.hpp>
diff --git a/libs/modelsLibrary/virtualController.cpp b/libs/modelsLibrary/virtualController.cpp
new file mode 100644
index 00000000..9809849d
--- /dev/null
+++ b/libs/modelsLibrary/virtualController.cpp
@@ -0,0 +1,649 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "virtualController.hpp"
+
+#include <la/avdecc/utils.hpp>
+
+namespace hive
+{
+namespace modelsLibrary
+{
+void VirtualController::setControllerEID(la::avdecc::UniqueIdentifier const controllerEID) noexcept
+{
+	_controllerEID = controllerEID;
+}
+
+// Empty implementation of all VirtualController overridable methods
+void VirtualController::acquireEntity(la::avdecc::UniqueIdentifier const targetEntityID, bool const /*isPersistent*/, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, AcquireEntityHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotSupported, la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), descriptorType, descriptorIndex);
+}
+
+void VirtualController::releaseEntity(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, ReleaseEntityHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotSupported, la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), descriptorType, descriptorIndex);
+}
+
+void VirtualController::lockEntity(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, LockEntityHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, _controllerEID, descriptorType, descriptorIndex);
+}
+
+void VirtualController::unlockEntity(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, UnlockEntityHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), descriptorType, descriptorIndex);
+}
+
+void VirtualController::queryEntityAvailable(la::avdecc::UniqueIdentifier const targetEntityID, QueryEntityAvailableHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success);
+}
+
+void VirtualController::queryControllerAvailable(la::avdecc::UniqueIdentifier const targetEntityID, QueryControllerAvailableHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented);
+}
+
+void VirtualController::registerUnsolicitedNotifications(la::avdecc::UniqueIdentifier const targetEntityID, RegisterUnsolicitedNotificationsHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success);
+}
+
+void VirtualController::unregisterUnsolicitedNotifications(la::avdecc::UniqueIdentifier const targetEntityID, UnregisterUnsolicitedNotificationsHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success);
+}
+
+void VirtualController::readEntityDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, EntityDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyEntityDescriptor = la::avdecc::entity::model::EntityDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, s_emptyEntityDescriptor);
+}
+
+void VirtualController::readConfigurationDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, ConfigurationDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyConfigurationDescriptor = la::avdecc::entity::model::ConfigurationDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, s_emptyConfigurationDescriptor);
+}
+
+void VirtualController::readAudioUnitDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, AudioUnitDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyAudioUnitDescriptor = la::avdecc::entity::model::AudioUnitDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, audioUnitIndex, s_emptyAudioUnitDescriptor);
+}
+
+void VirtualController::readStreamInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, StreamInputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamDescriptor = la::avdecc::entity::model::StreamDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, streamIndex, s_emptyStreamDescriptor);
+}
+
+void VirtualController::readStreamOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, StreamOutputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamDescriptor = la::avdecc::entity::model::StreamDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, streamIndex, s_emptyStreamDescriptor);
+}
+
+void VirtualController::readJackInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, JackInputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyJackDescriptor = la::avdecc::entity::model::JackDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, jackIndex, s_emptyJackDescriptor);
+}
+
+void VirtualController::readJackOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, JackOutputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyJackDescriptor = la::avdecc::entity::model::JackDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, jackIndex, s_emptyJackDescriptor);
+}
+
+void VirtualController::readAvbInterfaceDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, AvbInterfaceDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyAvbInterfaceDescriptor = la::avdecc::entity::model::AvbInterfaceDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, avbInterfaceIndex, s_emptyAvbInterfaceDescriptor);
+}
+
+void VirtualController::readClockSourceDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, ClockSourceDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyClockSourceDescriptor = la::avdecc::entity::model::ClockSourceDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, clockSourceIndex, s_emptyClockSourceDescriptor);
+}
+
+void VirtualController::readMemoryObjectDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, MemoryObjectDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyMemoryObjectDescriptor = la::avdecc::entity::model::MemoryObjectDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, memoryObjectIndex, s_emptyMemoryObjectDescriptor);
+}
+
+void VirtualController::readLocaleDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::LocaleIndex const localeIndex, LocaleDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyLocaleDescriptor = la::avdecc::entity::model::LocaleDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, localeIndex, s_emptyLocaleDescriptor);
+}
+
+void VirtualController::readStringsDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StringsIndex const stringsIndex, StringsDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyStringsDescriptor = la::avdecc::entity::model::StringsDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, stringsIndex, s_emptyStringsDescriptor);
+}
+
+void VirtualController::readStreamPortInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, StreamPortInputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamPortDescriptor = la::avdecc::entity::model::StreamPortDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, streamPortIndex, s_emptyStreamPortDescriptor);
+}
+
+void VirtualController::readStreamPortOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, StreamPortOutputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamPortDescriptor = la::avdecc::entity::model::StreamPortDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, streamPortIndex, s_emptyStreamPortDescriptor);
+}
+
+void VirtualController::readExternalPortInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ExternalPortIndex const externalPortIndex, ExternalPortInputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyExternalPortDescriptor = la::avdecc::entity::model::ExternalPortDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, externalPortIndex, s_emptyExternalPortDescriptor);
+}
+
+void VirtualController::readExternalPortOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ExternalPortIndex const externalPortIndex, ExternalPortOutputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyExternalPortDescriptor = la::avdecc::entity::model::ExternalPortDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, externalPortIndex, s_emptyExternalPortDescriptor);
+}
+
+void VirtualController::readInternalPortInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::InternalPortIndex const internalPortIndex, InternalPortInputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyInternalPortDescriptor = la::avdecc::entity::model::InternalPortDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, internalPortIndex, s_emptyInternalPortDescriptor);
+}
+
+void VirtualController::readInternalPortOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::InternalPortIndex const internalPortIndex, InternalPortOutputDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyInternalPortDescriptor = la::avdecc::entity::model::InternalPortDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, internalPortIndex, s_emptyInternalPortDescriptor);
+}
+
+void VirtualController::readAudioClusterDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClusterIndex const clusterIndex, AudioClusterDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyAudioClusterDescriptor = la::avdecc::entity::model::AudioClusterDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, clusterIndex, s_emptyAudioClusterDescriptor);
+}
+
+void VirtualController::readAudioMapDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MapIndex const mapIndex, AudioMapDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyAudioMapDescriptor = la::avdecc::entity::model::AudioMapDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, mapIndex, s_emptyAudioMapDescriptor);
+}
+
+void VirtualController::readControlDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, ControlDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyControlDescriptor = la::avdecc::entity::model::ControlDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, controlIndex, s_emptyControlDescriptor);
+}
+
+void VirtualController::readClockDomainDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, ClockDomainDescriptorHandler const& handler) const noexcept
+{
+	static auto const s_emptyClockDomainDescriptor = la::avdecc::entity::model::ClockDomainDescriptor{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, clockDomainIndex, s_emptyClockDomainDescriptor);
+}
+
+void VirtualController::setConfiguration(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, SetConfigurationHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex);
+}
+
+void VirtualController::getConfiguration(la::avdecc::UniqueIdentifier const targetEntityID, GetConfigurationHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, la::avdecc::entity::model::ConfigurationIndex{ 0u });
+}
+
+void VirtualController::setStreamInputFormat(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::StreamFormat const streamFormat, SetStreamInputFormatHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamIndex, streamFormat);
+}
+
+void VirtualController::getStreamInputFormat(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamInputFormatHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamIndex, la::avdecc::entity::model::StreamFormat::getNullStreamFormat());
+}
+
+void VirtualController::setStreamOutputFormat(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::StreamFormat const streamFormat, SetStreamOutputFormatHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamIndex, streamFormat);
+}
+
+void VirtualController::getStreamOutputFormat(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamOutputFormatHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamIndex, la::avdecc::entity::model::StreamFormat::getNullStreamFormat());
+}
+
+void VirtualController::getStreamPortInputAudioMap(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::MapIndex const mapIndex, GetStreamPortInputAudioMapHandler const& handler) const noexcept
+{
+	static auto const s_emptyAudioMappings = la::avdecc::entity::model::AudioMappings{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamPortIndex, 0u, mapIndex, s_emptyAudioMappings);
+}
+
+void VirtualController::getStreamPortOutputAudioMap(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::MapIndex const mapIndex, GetStreamPortOutputAudioMapHandler const& handler) const noexcept
+{
+	static auto const s_emptyAudioMappings = la::avdecc::entity::model::AudioMappings{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamPortIndex, 0u, mapIndex, s_emptyAudioMappings);
+}
+
+void VirtualController::addStreamPortInputAudioMappings(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::AudioMappings const& mappings, AddStreamPortInputAudioMappingsHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamPortIndex, mappings);
+}
+
+void VirtualController::addStreamPortOutputAudioMappings(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::AudioMappings const& mappings, AddStreamPortOutputAudioMappingsHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamPortIndex, mappings);
+}
+
+void VirtualController::removeStreamPortInputAudioMappings(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::AudioMappings const& mappings, RemoveStreamPortInputAudioMappingsHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamPortIndex, mappings);
+}
+
+void VirtualController::removeStreamPortOutputAudioMappings(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::AudioMappings const& mappings, RemoveStreamPortOutputAudioMappingsHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamPortIndex, mappings);
+}
+
+void VirtualController::setStreamInputInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::StreamInfo const& /*info*/, SetStreamInputInfoHandler const& handler) const noexcept
+{
+	// WARNING: When implementing this, we have to return the complete actual stream info, not the one passed in.
+	static auto const s_emptyStreamInfo = la::avdecc::entity::model::StreamInfo{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamIndex, s_emptyStreamInfo);
+}
+
+void VirtualController::setStreamOutputInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::StreamInfo const& /*info*/, SetStreamOutputInfoHandler const& handler) const noexcept
+{
+	// WARNING: When implementing this, we have to return the complete actual stream info, not the one passed in.
+	static auto const s_emptyStreamInfo = la::avdecc::entity::model::StreamInfo{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamIndex, s_emptyStreamInfo);
+}
+
+void VirtualController::getStreamInputInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamInputInfoHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamInfo = la::avdecc::entity::model::StreamInfo{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamIndex, s_emptyStreamInfo);
+}
+
+void VirtualController::getStreamOutputInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamOutputInfoHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamInfo = la::avdecc::entity::model::StreamInfo{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamIndex, s_emptyStreamInfo);
+}
+
+void VirtualController::setEntityName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvdeccFixedString const& entityName, SetEntityNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, entityName);
+}
+
+void VirtualController::getEntityName(la::avdecc::UniqueIdentifier const targetEntityID, GetEntityNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyEntityName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, s_emptyEntityName);
+}
+
+void VirtualController::setEntityGroupName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvdeccFixedString const& entityGroupName, SetEntityGroupNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, entityGroupName);
+}
+
+void VirtualController::getEntityGroupName(la::avdecc::UniqueIdentifier const targetEntityID, GetEntityGroupNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyEntityGroupName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, s_emptyEntityGroupName);
+}
+
+void VirtualController::setConfigurationName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvdeccFixedString const& configurationName, SetConfigurationNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, configurationName);
+}
+
+void VirtualController::getConfigurationName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, GetConfigurationNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyConfigurationName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, s_emptyConfigurationName);
+}
+
+void VirtualController::setAudioUnitName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::AvdeccFixedString const& audioUnitName, SetAudioUnitNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, audioUnitIndex, audioUnitName);
+}
+
+void VirtualController::getAudioUnitName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, GetAudioUnitNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyAudioUnitName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, audioUnitIndex, s_emptyAudioUnitName);
+}
+
+void VirtualController::setStreamInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::AvdeccFixedString const& streamInputName, SetStreamInputNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, streamIndex, streamInputName);
+}
+
+void VirtualController::getStreamInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamInputNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, streamIndex, s_emptyStreamName);
+}
+
+void VirtualController::setStreamOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::AvdeccFixedString const& streamOutputName, SetStreamOutputNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, streamIndex, streamOutputName);
+}
+
+void VirtualController::getStreamOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamOutputNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, streamIndex, s_emptyStreamName);
+}
+
+void VirtualController::setJackInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, la::avdecc::entity::model::AvdeccFixedString const& jackInputName, SetJackInputNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, jackIndex, jackInputName);
+}
+
+void VirtualController::getJackInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, GetJackInputNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyJackName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, jackIndex, s_emptyJackName);
+}
+
+void VirtualController::setJackOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, la::avdecc::entity::model::AvdeccFixedString const& jackOutputName, SetJackOutputNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, jackIndex, jackOutputName);
+}
+
+void VirtualController::getJackOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, GetJackOutputNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyJackName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, jackIndex, s_emptyJackName);
+}
+
+void VirtualController::setAvbInterfaceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, la::avdecc::entity::model::AvdeccFixedString const& avbInterfaceName, SetAvbInterfaceNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, avbInterfaceIndex, avbInterfaceName);
+}
+
+void VirtualController::getAvbInterfaceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, GetAvbInterfaceNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyAvbInterfaceName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, avbInterfaceIndex, s_emptyAvbInterfaceName);
+}
+
+void VirtualController::setClockSourceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, la::avdecc::entity::model::AvdeccFixedString const& clockSourceName, SetClockSourceNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, clockSourceIndex, clockSourceName);
+}
+
+void VirtualController::getClockSourceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, GetClockSourceNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyClockSourceName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, clockSourceIndex, s_emptyClockSourceName);
+}
+
+void VirtualController::setMemoryObjectName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, la::avdecc::entity::model::AvdeccFixedString const& memoryObjectName, SetMemoryObjectNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, memoryObjectIndex, memoryObjectName);
+}
+
+void VirtualController::getMemoryObjectName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, GetMemoryObjectNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyMemoryObjectName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, memoryObjectIndex, s_emptyMemoryObjectName);
+}
+
+void VirtualController::setAudioClusterName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClusterIndex const audioClusterIndex, la::avdecc::entity::model::AvdeccFixedString const& audioClusterName, SetAudioClusterNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, audioClusterIndex, audioClusterName);
+}
+
+void VirtualController::getAudioClusterName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClusterIndex const audioClusterIndex, GetAudioClusterNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyAudioClusterName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, audioClusterIndex, s_emptyAudioClusterName);
+}
+
+void VirtualController::setControlName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::entity::model::AvdeccFixedString const& controlName, SetControlNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, controlIndex, controlName);
+}
+
+void VirtualController::getControlName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, GetControlNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyControlName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, controlIndex, s_emptyControlName);
+}
+
+void VirtualController::setClockDomainName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, la::avdecc::entity::model::AvdeccFixedString const& clockDomainName, SetClockDomainNameHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, clockDomainIndex, clockDomainName);
+}
+
+void VirtualController::getClockDomainName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, GetClockDomainNameHandler const& handler) const noexcept
+{
+	static auto const s_emptyClockDomainName = la::avdecc::entity::model::AvdeccFixedString{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, clockDomainIndex, s_emptyClockDomainName);
+}
+
+void VirtualController::setAssociation(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::UniqueIdentifier const associationID, SetAssociationHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, associationID);
+}
+
+void VirtualController::getAssociation(la::avdecc::UniqueIdentifier const targetEntityID, GetAssociationHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, la::avdecc::UniqueIdentifier::getNullUniqueIdentifier());
+}
+
+void VirtualController::setAudioUnitSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::SamplingRate const samplingRate, SetAudioUnitSamplingRateHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, audioUnitIndex, samplingRate);
+}
+
+void VirtualController::getAudioUnitSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, GetAudioUnitSamplingRateHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, audioUnitIndex, la::avdecc::entity::model::SamplingRate::getNullSamplingRate());
+}
+
+void VirtualController::setVideoClusterSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClusterIndex const videoClusterIndex, la::avdecc::entity::model::SamplingRate const samplingRate, SetVideoClusterSamplingRateHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, videoClusterIndex, samplingRate);
+}
+
+void VirtualController::getVideoClusterSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClusterIndex const videoClusterIndex, GetVideoClusterSamplingRateHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, videoClusterIndex, la::avdecc::entity::model::SamplingRate::getNullSamplingRate());
+}
+
+void VirtualController::setSensorClusterSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClusterIndex const sensorClusterIndex, la::avdecc::entity::model::SamplingRate const samplingRate, SetSensorClusterSamplingRateHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, sensorClusterIndex, samplingRate);
+}
+
+void VirtualController::getSensorClusterSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClusterIndex const sensorClusterIndex, GetSensorClusterSamplingRateHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, sensorClusterIndex, la::avdecc::entity::model::SamplingRate::getNullSamplingRate());
+}
+
+void VirtualController::setClockSource(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, SetClockSourceHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, clockDomainIndex, clockSourceIndex);
+}
+
+void VirtualController::getClockSource(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, GetClockSourceHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, clockDomainIndex, la::avdecc::entity::model::ClockSourceIndex{ 0u });
+}
+
+void VirtualController::setControlValues(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::entity::model::ControlValues const& /*controlValues*/, SetControlValuesHandler const& handler) const noexcept
+{
+	static auto const s_emptyControlValues = la::avdecc::MemoryBuffer{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, controlIndex, s_emptyControlValues);
+}
+
+void VirtualController::getControlValues(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ControlIndex const controlIndex, GetControlValuesHandler const& handler) const noexcept
+{
+	static auto const s_emptyControlValues = la::avdecc::MemoryBuffer{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, controlIndex, s_emptyControlValues);
+}
+
+void VirtualController::startStreamInput(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, StartStreamInputHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamIndex);
+}
+
+void VirtualController::startStreamOutput(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, StartStreamOutputHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamIndex);
+}
+
+void VirtualController::stopStreamInput(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, StopStreamInputHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamIndex);
+}
+
+void VirtualController::stopStreamOutput(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, StopStreamOutputHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, streamIndex);
+}
+
+void VirtualController::getAvbInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, GetAvbInfoHandler const& handler) const noexcept
+{
+	static auto const s_emptyAvbInfo = la::avdecc::entity::model::AvbInfo{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, avbInterfaceIndex, s_emptyAvbInfo);
+}
+
+void VirtualController::getAsPath(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, GetAsPathHandler const& handler) const noexcept
+{
+	static auto const s_emptyAsPath = la::avdecc::entity::model::AsPath{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, avbInterfaceIndex, s_emptyAsPath);
+}
+
+void VirtualController::getEntityCounters(la::avdecc::UniqueIdentifier const targetEntityID, GetEntityCountersHandler const& handler) const noexcept
+{
+	static auto const s_emptyDescriptorCounters = la::avdecc::entity::model::DescriptorCounters{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, la::avdecc::entity::EntityCounterValidFlags{}, s_emptyDescriptorCounters);
+}
+
+void VirtualController::getAvbInterfaceCounters(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, GetAvbInterfaceCountersHandler const& handler) const noexcept
+{
+	static auto const s_emptyDescriptorCounters = la::avdecc::entity::model::DescriptorCounters{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, avbInterfaceIndex, la::avdecc::entity::AvbInterfaceCounterValidFlags{}, s_emptyDescriptorCounters);
+}
+
+void VirtualController::getClockDomainCounters(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, GetClockDomainCountersHandler const& handler) const noexcept
+{
+	static auto const s_emptyDescriptorCounters = la::avdecc::entity::model::DescriptorCounters{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, clockDomainIndex, la::avdecc::entity::ClockDomainCounterValidFlags{}, s_emptyDescriptorCounters);
+}
+
+void VirtualController::getStreamInputCounters(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamInputCountersHandler const& handler) const noexcept
+{
+	static auto const s_emptyDescriptorCounters = la::avdecc::entity::model::DescriptorCounters{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamIndex, la::avdecc::entity::StreamInputCounterValidFlags{}, s_emptyDescriptorCounters);
+}
+
+void VirtualController::getStreamOutputCounters(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamOutputCountersHandler const& handler) const noexcept
+{
+	static auto const s_emptyDescriptorCounters = la::avdecc::entity::model::DescriptorCounters{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, streamIndex, la::avdecc::entity::StreamOutputCounterValidFlags{}, s_emptyDescriptorCounters);
+}
+
+void VirtualController::reboot(la::avdecc::UniqueIdentifier const targetEntityID, RebootHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented);
+}
+
+void VirtualController::rebootToFirmware(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, RebootToFirmwareHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, memoryObjectIndex);
+}
+
+void VirtualController::startOperation(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, la::avdecc::entity::model::MemoryObjectOperationType const operationType, la::avdecc::MemoryBuffer const& /*memoryBuffer*/, StartOperationHandler const& handler) const noexcept
+{
+	static auto const s_emptyMemoryBuffer = la::avdecc::MemoryBuffer{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, descriptorType, descriptorIndex, la::avdecc::entity::model::OperationID{ 0u }, operationType, s_emptyMemoryBuffer);
+}
+
+void VirtualController::abortOperation(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, la::avdecc::entity::model::OperationID const operationID, AbortOperationHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, descriptorType, descriptorIndex, operationID);
+}
+
+void VirtualController::setMemoryObjectLength(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, std::uint64_t const length, SetMemoryObjectLengthHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::Success, configurationIndex, memoryObjectIndex, length);
+}
+
+void VirtualController::getMemoryObjectLength(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, GetMemoryObjectLengthHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AemCommandStatus::NotImplemented, configurationIndex, memoryObjectIndex, std::uint64_t{ 0u });
+}
+
+void VirtualController::addressAccess(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::addressAccess::Tlvs const& /*tlvs*/, AddressAccessHandler const& handler) const noexcept
+{
+	static auto const s_emptyTlvs = la::avdecc::entity::addressAccess::Tlvs{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::AaCommandStatus::NotImplemented, s_emptyTlvs);
+}
+
+void VirtualController::getMilanInfo(la::avdecc::UniqueIdentifier const targetEntityID, GetMilanInfoHandler const& handler) const noexcept
+{
+	static auto const s_emptyMilanInfo = la::avdecc::entity::model::MilanInfo{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, targetEntityID, la::avdecc::entity::LocalEntity::MvuCommandStatus::NotImplemented, s_emptyMilanInfo);
+}
+
+void VirtualController::connectStream(la::avdecc::entity::model::StreamIdentification const& talkerStream, la::avdecc::entity::model::StreamIdentification const& listenerStream, ConnectStreamHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, talkerStream, listenerStream, std::uint16_t{ 1u }, la::avdecc::entity::ConnectionFlags{}, la::avdecc::entity::LocalEntity::ControlStatus::Success);
+}
+
+void VirtualController::disconnectStream(la::avdecc::entity::model::StreamIdentification const& talkerStream, la::avdecc::entity::model::StreamIdentification const& listenerStream, DisconnectStreamHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, talkerStream, listenerStream, std::uint16_t{ 0u }, la::avdecc::entity::ConnectionFlags{}, la::avdecc::entity::LocalEntity::ControlStatus::Success);
+}
+
+void VirtualController::disconnectTalkerStream(la::avdecc::entity::model::StreamIdentification const& talkerStream, la::avdecc::entity::model::StreamIdentification const& listenerStream, DisconnectTalkerStreamHandler const& handler) const noexcept
+{
+	la::avdecc::utils::invokeProtectedHandler(handler, this, talkerStream, listenerStream, std::uint16_t{ 0u }, la::avdecc::entity::ConnectionFlags{}, la::avdecc::entity::LocalEntity::ControlStatus::Success);
+}
+
+void VirtualController::getTalkerStreamState(la::avdecc::entity::model::StreamIdentification const& talkerStream, GetTalkerStreamStateHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamIdentification = la::avdecc::entity::model::StreamIdentification{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, talkerStream, s_emptyStreamIdentification, std::uint16_t{ 0u }, la::avdecc::entity::ConnectionFlags{}, la::avdecc::entity::LocalEntity::ControlStatus::NotSupported);
+}
+
+void VirtualController::getListenerStreamState(la::avdecc::entity::model::StreamIdentification const& listenerStream, GetListenerStreamStateHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamIdentification = la::avdecc::entity::model::StreamIdentification{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, s_emptyStreamIdentification, listenerStream, std::uint16_t{ 0u }, la::avdecc::entity::ConnectionFlags{}, la::avdecc::entity::LocalEntity::ControlStatus::NotSupported);
+}
+
+void VirtualController::getTalkerStreamConnection(la::avdecc::entity::model::StreamIdentification const& talkerStream, std::uint16_t const /*connectionIndex*/, GetTalkerStreamConnectionHandler const& handler) const noexcept
+{
+	static auto const s_emptyStreamIdentification = la::avdecc::entity::model::StreamIdentification{};
+	la::avdecc::utils::invokeProtectedHandler(handler, this, talkerStream, s_emptyStreamIdentification, std::uint16_t{ 0u }, la::avdecc::entity::ConnectionFlags{}, la::avdecc::entity::LocalEntity::ControlStatus::NotSupported);
+}
+
+} // namespace modelsLibrary
+} // namespace hive
diff --git a/libs/modelsLibrary/virtualController.hpp b/libs/modelsLibrary/virtualController.hpp
new file mode 100644
index 00000000..b61d730d
--- /dev/null
+++ b/libs/modelsLibrary/virtualController.hpp
@@ -0,0 +1,165 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <la/avdecc/internals/controllerEntity.hpp>
+
+namespace hive
+{
+namespace modelsLibrary
+{
+class VirtualController : public la::avdecc::entity::controller::Interface
+{
+public:
+	/** Constructor */
+	VirtualController() noexcept = default;
+
+	/** Set controller EID */
+	void setControllerEID(la::avdecc::UniqueIdentifier const controllerEID) noexcept;
+
+	// la::avdecc::entity::controller::Interface overrides
+	virtual void acquireEntity(la::avdecc::UniqueIdentifier const targetEntityID, bool const isPersistent, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, AcquireEntityHandler const& handler) const noexcept override;
+	virtual void releaseEntity(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, ReleaseEntityHandler const& handler) const noexcept override;
+	virtual void lockEntity(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, LockEntityHandler const& handler) const noexcept override;
+	virtual void unlockEntity(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, UnlockEntityHandler const& handler) const noexcept override;
+	virtual void queryEntityAvailable(la::avdecc::UniqueIdentifier const targetEntityID, QueryEntityAvailableHandler const& handler) const noexcept override;
+	virtual void queryControllerAvailable(la::avdecc::UniqueIdentifier const targetEntityID, QueryControllerAvailableHandler const& handler) const noexcept override;
+	virtual void registerUnsolicitedNotifications(la::avdecc::UniqueIdentifier const targetEntityID, RegisterUnsolicitedNotificationsHandler const& handler) const noexcept override;
+	virtual void unregisterUnsolicitedNotifications(la::avdecc::UniqueIdentifier const targetEntityID, UnregisterUnsolicitedNotificationsHandler const& handler) const noexcept override;
+	virtual void readEntityDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, EntityDescriptorHandler const& handler) const noexcept override;
+	virtual void readConfigurationDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, ConfigurationDescriptorHandler const& handler) const noexcept override;
+	virtual void readAudioUnitDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, AudioUnitDescriptorHandler const& handler) const noexcept override;
+	virtual void readStreamInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, StreamInputDescriptorHandler const& handler) const noexcept override;
+	virtual void readStreamOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, StreamOutputDescriptorHandler const& handler) const noexcept override;
+	virtual void readJackInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, JackInputDescriptorHandler const& handler) const noexcept override;
+	virtual void readJackOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, JackOutputDescriptorHandler const& handler) const noexcept override;
+	virtual void readAvbInterfaceDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, AvbInterfaceDescriptorHandler const& handler) const noexcept override;
+	virtual void readClockSourceDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, ClockSourceDescriptorHandler const& handler) const noexcept override;
+	virtual void readMemoryObjectDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, MemoryObjectDescriptorHandler const& handler) const noexcept override;
+	virtual void readLocaleDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::LocaleIndex const localeIndex, LocaleDescriptorHandler const& handler) const noexcept override;
+	virtual void readStringsDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StringsIndex const stringsIndex, StringsDescriptorHandler const& handler) const noexcept override;
+	virtual void readStreamPortInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, StreamPortInputDescriptorHandler const& handler) const noexcept override;
+	virtual void readStreamPortOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, StreamPortOutputDescriptorHandler const& handler) const noexcept override;
+	virtual void readExternalPortInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ExternalPortIndex const externalPortIndex, ExternalPortInputDescriptorHandler const& handler) const noexcept override;
+	virtual void readExternalPortOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ExternalPortIndex const externalPortIndex, ExternalPortOutputDescriptorHandler const& handler) const noexcept override;
+	virtual void readInternalPortInputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::InternalPortIndex const internalPortIndex, InternalPortInputDescriptorHandler const& handler) const noexcept override;
+	virtual void readInternalPortOutputDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::InternalPortIndex const internalPortIndex, InternalPortOutputDescriptorHandler const& handler) const noexcept override;
+	virtual void readAudioClusterDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClusterIndex const clusterIndex, AudioClusterDescriptorHandler const& handler) const noexcept override;
+	virtual void readAudioMapDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MapIndex const mapIndex, AudioMapDescriptorHandler const& handler) const noexcept override;
+	virtual void readControlDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, ControlDescriptorHandler const& handler) const noexcept override;
+	virtual void readClockDomainDescriptor(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, ClockDomainDescriptorHandler const& handler) const noexcept override;
+	virtual void setConfiguration(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, SetConfigurationHandler const& handler) const noexcept override;
+	virtual void getConfiguration(la::avdecc::UniqueIdentifier const targetEntityID, GetConfigurationHandler const& handler) const noexcept override;
+	virtual void setStreamInputFormat(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::StreamFormat const streamFormat, SetStreamInputFormatHandler const& handler) const noexcept override;
+	virtual void getStreamInputFormat(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamInputFormatHandler const& handler) const noexcept override;
+	virtual void setStreamOutputFormat(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::StreamFormat const streamFormat, SetStreamOutputFormatHandler const& handler) const noexcept override;
+	virtual void getStreamOutputFormat(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamOutputFormatHandler const& handler) const noexcept override;
+	virtual void getStreamPortInputAudioMap(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::MapIndex const mapIndex, GetStreamPortInputAudioMapHandler const& handler) const noexcept override;
+	virtual void getStreamPortOutputAudioMap(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::MapIndex const mapIndex, GetStreamPortOutputAudioMapHandler const& handler) const noexcept override;
+	virtual void addStreamPortInputAudioMappings(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::AudioMappings const& mappings, AddStreamPortInputAudioMappingsHandler const& handler) const noexcept override;
+	virtual void addStreamPortOutputAudioMappings(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::AudioMappings const& mappings, AddStreamPortOutputAudioMappingsHandler const& handler) const noexcept override;
+	virtual void removeStreamPortInputAudioMappings(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::AudioMappings const& mappings, RemoveStreamPortInputAudioMappingsHandler const& handler) const noexcept override;
+	virtual void removeStreamPortOutputAudioMappings(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::AudioMappings const& mappings, RemoveStreamPortOutputAudioMappingsHandler const& handler) const noexcept override;
+	virtual void setStreamInputInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::StreamInfo const& info, SetStreamInputInfoHandler const& handler) const noexcept override;
+	virtual void setStreamOutputInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::StreamInfo const& info, SetStreamOutputInfoHandler const& handler) const noexcept override;
+	virtual void getStreamInputInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamInputInfoHandler const& handler) const noexcept override;
+	virtual void getStreamOutputInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamOutputInfoHandler const& handler) const noexcept override;
+	virtual void setEntityName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvdeccFixedString const& entityName, SetEntityNameHandler const& handler) const noexcept override;
+	virtual void getEntityName(la::avdecc::UniqueIdentifier const targetEntityID, GetEntityNameHandler const& handler) const noexcept override;
+	virtual void setEntityGroupName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvdeccFixedString const& entityGroupName, SetEntityGroupNameHandler const& handler) const noexcept override;
+	virtual void getEntityGroupName(la::avdecc::UniqueIdentifier const targetEntityID, GetEntityGroupNameHandler const& handler) const noexcept override;
+	virtual void setConfigurationName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvdeccFixedString const& configurationName, SetConfigurationNameHandler const& handler) const noexcept override;
+	virtual void getConfigurationName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, GetConfigurationNameHandler const& handler) const noexcept override;
+	virtual void setAudioUnitName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::AvdeccFixedString const& audioUnitName, SetAudioUnitNameHandler const& handler) const noexcept override;
+	virtual void getAudioUnitName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, GetAudioUnitNameHandler const& handler) const noexcept override;
+	virtual void setStreamInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::AvdeccFixedString const& streamInputName, SetStreamInputNameHandler const& handler) const noexcept override;
+	virtual void getStreamInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamInputNameHandler const& handler) const noexcept override;
+	virtual void setStreamOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::AvdeccFixedString const& streamOutputName, SetStreamOutputNameHandler const& handler) const noexcept override;
+	virtual void getStreamOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamOutputNameHandler const& handler) const noexcept override;
+	virtual void setJackInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, la::avdecc::entity::model::AvdeccFixedString const& jackInputName, SetJackInputNameHandler const& handler) const noexcept override;
+	virtual void getJackInputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, GetJackInputNameHandler const& handler) const noexcept override;
+	virtual void setJackOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, la::avdecc::entity::model::AvdeccFixedString const& jackOutputName, SetJackOutputNameHandler const& handler) const noexcept override;
+	virtual void getJackOutputName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::JackIndex const jackIndex, GetJackOutputNameHandler const& handler) const noexcept override;
+	virtual void setAvbInterfaceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, la::avdecc::entity::model::AvdeccFixedString const& avbInterfaceName, SetAvbInterfaceNameHandler const& handler) const noexcept override;
+	virtual void getAvbInterfaceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, GetAvbInterfaceNameHandler const& handler) const noexcept override;
+	virtual void setClockSourceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, la::avdecc::entity::model::AvdeccFixedString const& clockSourceName, SetClockSourceNameHandler const& handler) const noexcept override;
+	virtual void getClockSourceName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, GetClockSourceNameHandler const& handler) const noexcept override;
+	virtual void setMemoryObjectName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, la::avdecc::entity::model::AvdeccFixedString const& memoryObjectName, SetMemoryObjectNameHandler const& handler) const noexcept override;
+	virtual void getMemoryObjectName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, GetMemoryObjectNameHandler const& handler) const noexcept override;
+	virtual void setAudioClusterName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClusterIndex const audioClusterIndex, la::avdecc::entity::model::AvdeccFixedString const& audioClusterName, SetAudioClusterNameHandler const& handler) const noexcept override;
+	virtual void getAudioClusterName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClusterIndex const audioClusterIndex, GetAudioClusterNameHandler const& handler) const noexcept override;
+	virtual void setControlName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::entity::model::AvdeccFixedString const& controlName, SetControlNameHandler const& handler) const noexcept override;
+	virtual void getControlName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, GetControlNameHandler const& handler) const noexcept override;
+	virtual void setClockDomainName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, la::avdecc::entity::model::AvdeccFixedString const& clockDomainName, SetClockDomainNameHandler const& handler) const noexcept override;
+	virtual void getClockDomainName(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, GetClockDomainNameHandler const& handler) const noexcept override;
+	virtual void setAssociation(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::UniqueIdentifier const associationID, SetAssociationHandler const& handler) const noexcept override;
+	virtual void getAssociation(la::avdecc::UniqueIdentifier const targetEntityID, GetAssociationHandler const& handler) const noexcept override;
+	virtual void setAudioUnitSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::SamplingRate const samplingRate, SetAudioUnitSamplingRateHandler const& handler) const noexcept override;
+	virtual void getAudioUnitSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, GetAudioUnitSamplingRateHandler const& handler) const noexcept override;
+	virtual void setVideoClusterSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClusterIndex const videoClusterIndex, la::avdecc::entity::model::SamplingRate const samplingRate, SetVideoClusterSamplingRateHandler const& handler) const noexcept override;
+	virtual void getVideoClusterSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClusterIndex const videoClusterIndex, GetVideoClusterSamplingRateHandler const& handler) const noexcept override;
+	virtual void setSensorClusterSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClusterIndex const sensorClusterIndex, la::avdecc::entity::model::SamplingRate const samplingRate, SetSensorClusterSamplingRateHandler const& handler) const noexcept override;
+	virtual void getSensorClusterSamplingRate(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClusterIndex const sensorClusterIndex, GetSensorClusterSamplingRateHandler const& handler) const noexcept override;
+	virtual void setClockSource(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, SetClockSourceHandler const& handler) const noexcept override;
+	virtual void getClockSource(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, GetClockSourceHandler const& handler) const noexcept override;
+	virtual void setControlValues(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::entity::model::ControlValues const& controlValues, SetControlValuesHandler const& handler) const noexcept override;
+	virtual void getControlValues(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ControlIndex const controlIndex, GetControlValuesHandler const& handler) const noexcept override;
+	virtual void startStreamInput(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, StartStreamInputHandler const& handler) const noexcept override;
+	virtual void startStreamOutput(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, StartStreamOutputHandler const& handler) const noexcept override;
+	virtual void stopStreamInput(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, StopStreamInputHandler const& handler) const noexcept override;
+	virtual void stopStreamOutput(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, StopStreamOutputHandler const& handler) const noexcept override;
+	virtual void getAvbInfo(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, GetAvbInfoHandler const& handler) const noexcept override;
+	virtual void getAsPath(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, GetAsPathHandler const& handler) const noexcept override;
+	virtual void getEntityCounters(la::avdecc::UniqueIdentifier const targetEntityID, GetEntityCountersHandler const& handler) const noexcept override;
+	virtual void getAvbInterfaceCounters(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, GetAvbInterfaceCountersHandler const& handler) const noexcept override;
+	virtual void getClockDomainCounters(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, GetClockDomainCountersHandler const& handler) const noexcept override;
+	virtual void getStreamInputCounters(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamInputCountersHandler const& handler) const noexcept override;
+	virtual void getStreamOutputCounters(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::StreamIndex const streamIndex, GetStreamOutputCountersHandler const& handler) const noexcept override;
+	virtual void reboot(la::avdecc::UniqueIdentifier const targetEntityID, RebootHandler const& handler) const noexcept override;
+	virtual void rebootToFirmware(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, RebootToFirmwareHandler const& handler) const noexcept override;
+	virtual void startOperation(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, la::avdecc::entity::model::MemoryObjectOperationType const operationType, la::avdecc::MemoryBuffer const& memoryBuffer, StartOperationHandler const& handler) const noexcept override;
+	virtual void abortOperation(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, la::avdecc::entity::model::OperationID const operationID, AbortOperationHandler const& handler) const noexcept override;
+	virtual void setMemoryObjectLength(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, std::uint64_t const length, SetMemoryObjectLengthHandler const& handler) const noexcept override;
+	virtual void getMemoryObjectLength(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, GetMemoryObjectLengthHandler const& handler) const noexcept override;
+	virtual void addressAccess(la::avdecc::UniqueIdentifier const targetEntityID, la::avdecc::entity::addressAccess::Tlvs const& tlvs, AddressAccessHandler const& handler) const noexcept override;
+	virtual void getMilanInfo(la::avdecc::UniqueIdentifier const targetEntityID, GetMilanInfoHandler const& handler) const noexcept override;
+	virtual void connectStream(la::avdecc::entity::model::StreamIdentification const& talkerStream, la::avdecc::entity::model::StreamIdentification const& listenerStream, ConnectStreamHandler const& handler) const noexcept override;
+	virtual void disconnectStream(la::avdecc::entity::model::StreamIdentification const& talkerStream, la::avdecc::entity::model::StreamIdentification const& listenerStream, DisconnectStreamHandler const& handler) const noexcept override;
+	virtual void disconnectTalkerStream(la::avdecc::entity::model::StreamIdentification const& talkerStream, la::avdecc::entity::model::StreamIdentification const& listenerStream, DisconnectTalkerStreamHandler const& handler) const noexcept override;
+	virtual void getTalkerStreamState(la::avdecc::entity::model::StreamIdentification const& talkerStream, GetTalkerStreamStateHandler const& handler) const noexcept override;
+	virtual void getListenerStreamState(la::avdecc::entity::model::StreamIdentification const& listenerStream, GetListenerStreamStateHandler const& handler) const noexcept override;
+	virtual void getTalkerStreamConnection(la::avdecc::entity::model::StreamIdentification const& talkerStream, std::uint16_t const connectionIndex, GetTalkerStreamConnectionHandler const& handler) const noexcept override;
+
+
+	// Defaulted compiler auto-generated methods
+	VirtualController(VirtualController const&) = default;
+	VirtualController(VirtualController&&) = default;
+	VirtualController& operator=(VirtualController const&) = default;
+	VirtualController& operator=(VirtualController&&) = default;
+
+private:
+	// Private methods
+
+	// Private members
+	la::avdecc::UniqueIdentifier _controllerEID{};
+};
+
+} // namespace modelsLibrary
+} // namespace hive
diff --git a/libs/widgetModelsLibrary/CMakeLists.txt b/libs/widgetModelsLibrary/CMakeLists.txt
index 4def4501..998b02b9 100644
--- a/libs/widgetModelsLibrary/CMakeLists.txt
+++ b/libs/widgetModelsLibrary/CMakeLists.txt
@@ -42,11 +42,13 @@ set(HEADER_FILES_PUBLIC
 	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/painterHelper.hpp
 	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/entityLogoCache.hpp
 	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/qtUserRoles.hpp
+	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/errorIconItemDelegate.hpp
 	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/errorItemDelegate.hpp
 	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/imageItemDelegate.hpp
 	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.hpp
 	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/networkInterfacesListModel.hpp
 	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/discoveredEntitiesTableModel.hpp
+	${CU_ROOT_DIR}/include/hive/widgetModelsLibrary/networkInterfacesListItemDelegate.hpp
 )
 
 set(HEADER_FILES_COMMON
@@ -56,11 +58,13 @@ set(SOURCE_FILES_COMMON
 	widgetModelsLibrary.cpp
 	painterHelper.cpp
 	entityLogoCache.cpp
+	errorIconItemDelegate.cpp
 	errorItemDelegate.cpp
 	imageItemDelegate.cpp
 	discoveredEntitiesTableItemDelegate.cpp
 	networkInterfacesListModel.cpp
 	discoveredEntitiesTableModel.cpp
+	networkInterfacesListItemDelegate.cpp
 )
 
 # Group source files
diff --git a/libs/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.cpp b/libs/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.cpp
index 848d2c82..f8dde371 100644
--- a/libs/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.cpp
+++ b/libs/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.cpp
@@ -27,37 +27,119 @@ namespace hive
 {
 namespace widgetModelsLibrary
 {
+DiscoveredEntitiesTableItemDelegate::DiscoveredEntitiesTableItemDelegate(qtMate::material::color::Name const themeColorName, QObject* parent) noexcept
+	: QStyledItemDelegate(parent)
+{
+	setThemeColorName(themeColorName);
+}
+
+void DiscoveredEntitiesTableItemDelegate::setThemeColorName(qtMate::material::color::Name const themeColorName)
+{
+	_themeColorName = themeColorName;
+	_isDark = qtMate::material::color::luminance(_themeColorName) == qtMate::material::color::Luminance::Dark;
+	_errorIconItemDelegate.setThemeColorName(themeColorName);
+	_imageItemDelegate.setThemeColorName(themeColorName);
+}
+
 void DiscoveredEntitiesTableItemDelegate::paint(QPainter* painter, QStyleOptionViewItem const& option, QModelIndex const& index) const
 {
-	// Override default options according to the model current state
+	// Options to be passed to the base class
 	auto basePainterOption = option;
 
+	// Function to be called to fill the background, if not using the base delegate
+	auto backgroundFill = std::function<void()>{};
+
 	// Clear focus state if any
 	if (basePainterOption.state & QStyle::State_HasFocus)
 	{
 		basePainterOption.state &= ~QStyle::State_HasFocus;
 	}
 
-	// Subscribed to unsol
-	auto const subscribedToUnsol = index.data(la::avdecc::utils::to_integral(QtUserRoles::SubscribedUnsolRole)).toBool();
-	if (!subscribedToUnsol)
+	auto const isSelected = basePainterOption.state & QStyle::StateFlag::State_Selected;
+	auto const isVirtual = index.data(la::avdecc::utils::to_integral(QtUserRoles::IsVirtualRole)).toBool();
+	auto const unsolSupported = index.data(la::avdecc::utils::to_integral(QtUserRoles::UnsolSupportedRole)).toBool();
+	auto const unsolSubscribed = index.data(la::avdecc::utils::to_integral(QtUserRoles::SubscribedUnsolRole)).toBool();
+
+	// Check for Virtual Entity
+	if (isVirtual)
 	{
-		if (basePainterOption.state & QStyle::StateFlag::State_Selected)
+		// Change the text color for all columns using the base painter
+		if (!isSelected)
 		{
-			auto const brush = qtMate::material::color::brush(qtMate::material::color::Name::BlueGray, qtMate::material::color::DefaultShade);
-			painter->fillRect(basePainterOption.rect, brush);
+			auto const brush = qtMate::material::color::brush(qtMate::material::color::Name::Gray, qtMate::material::color::Shade::Shade500);
+			basePainterOption.palette.setBrush(QPalette::Text, brush);
 		}
 		else
 		{
-			auto const brush = qtMate::material::color::brush(qtMate::material::color::Name::Gray, qtMate::material::color::DefaultShade);
+			// If theme is dark, it means the selected color is light, so we want to use a light gray
+			if (_isDark)
+			{
+				auto const brush = qtMate::material::color::brush(qtMate::material::color::Name::Gray, qtMate::material::color::Shade::Shade300);
+				basePainterOption.palette.setBrush(QPalette::HighlightedText, brush);
+			}
+			else
+			{
+				auto const brush = qtMate::material::color::brush(qtMate::material::color::Name::Gray, qtMate::material::color::Shade::ShadeA400);
+				basePainterOption.palette.setBrush(QPalette::HighlightedText, brush);
+			}
+		}
+	}
+
+	// Unsol not supported or not subscribed to
+	if (!unsolSupported) // Unsolicited notifications not supported
+	{
+		// Change the text font to italic for all columns using the base painter
+		basePainterOption.font.setItalic(true);
+	}
+	else if (!unsolSubscribed) // Unsolicited notifications supported, but not subscribed to
+	{
+		// Change the background pattern for all columns
+		if (!isSelected)
+		{
+			auto brush = qtMate::material::color::brush(qtMate::material::color::Name::Gray, qtMate::material::color::isDarkColorScheme() ? qtMate::material::color::Shade::Shade800 : qtMate::material::color::Shade::Shade300);
+			brush.setStyle(Qt::BrushStyle::BDiagPattern);
+			// We need to draw right away as there is no background fill when there is no selection (ie. don't use the backgroundFill function)
+			// (or just maybe I couldn't find the correct QPalette ColorRole to set in the brush, tried 'Window' but didn't work)
 			painter->fillRect(basePainterOption.rect, brush);
 		}
+		else
+		{
+			// If theme is dark, it means the text will be light, so we want to use black
+			if (_isDark)
+			{
+				auto brush = QBrush{ Qt::black, Qt::BrushStyle::BDiagPattern };
+				basePainterOption.palette.setBrush(QPalette::Highlight, brush); // Change the base painter option (will be used by the base delegate)
+				backgroundFill = [&painter, basePainterOption, brush = std::move(brush)]() // Set the background fill function
+				{
+					painter->fillRect(basePainterOption.rect, brush);
+				};
+			}
+			else
+			{
+				auto brush = qtMate::material::color::brush(qtMate::material::color::Name::Gray, qtMate::material::color::Shade::Shade400);
+				brush.setStyle(Qt::BrushStyle::BDiagPattern);
+				basePainterOption.palette.setBrush(QPalette::Highlight, brush); // Change the base painter option (will be used by the base delegate)
+				backgroundFill = [&painter, basePainterOption, brush = std::move(brush)]() // Set the background fill function
+				{
+					painter->fillRect(basePainterOption.rect, brush);
+				};
+			}
+		}
 	}
 
 	// Base painter
 	{
+		auto ignoreBase = false;
 		switch (index.column())
 		{
+			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::EntityStatus):
+			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::EntityLogo):
+			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::Compatibility):
+			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::AcquireState):
+			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::LockState):
+			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::ClockDomainLockState):
+				ignoreBase = true;
+				break;
 			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::EntityID):
 			{
 				// Check for Identification
@@ -66,29 +148,20 @@ void DiscoveredEntitiesTableItemDelegate::paint(QPainter* painter, QStyleOptionV
 				{
 					basePainterOption.font.setBold(true);
 				}
-
-				// Check for Error
-				auto const isError = index.data(la::avdecc::utils::to_integral(QtUserRoles::ErrorRole)).toBool();
-				if (isError)
-				{
-					// Right now, always use default value, as we draw on white background
-					auto const errorColorValue = qtMate::material::color::foregroundErrorColorValue(qtMate::material::color::DefaultColor, qtMate::material::color::DefaultShade);
-					basePainterOption.palette.setColor(QPalette::ColorRole::Text, errorColorValue);
-				}
 				break;
 			}
 			default:
 				break;
 		}
 
-		// Check for Virtual Entity
-		auto const isVirtual = index.data(la::avdecc::utils::to_integral(QtUserRoles::IsVirtualRole)).toBool();
-		if (isVirtual)
+		if (!ignoreBase)
 		{
-			basePainterOption.font.setItalic(true);
+			QStyledItemDelegate::paint(painter, basePainterOption, index);
+		}
+		else if (backgroundFill)
+		{
+			backgroundFill();
 		}
-
-		QStyledItemDelegate::paint(painter, basePainterOption, index);
 	}
 
 	// Image painter
@@ -99,6 +172,7 @@ void DiscoveredEntitiesTableItemDelegate::paint(QPainter* painter, QStyleOptionV
 			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::Compatibility):
 			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::AcquireState):
 			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::LockState):
+			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::ClockDomainLockState):
 				static_cast<QStyledItemDelegate const&>(_imageItemDelegate).paint(painter, option, index);
 				break;
 			default:
@@ -110,8 +184,8 @@ void DiscoveredEntitiesTableItemDelegate::paint(QPainter* painter, QStyleOptionV
 	{
 		switch (index.column())
 		{
-			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::EntityID):
-				static_cast<QStyledItemDelegate const&>(_errorItemDelegate).paint(painter, option, index);
+			case DiscoveredEntitiesTableModel::EntityDataFlags::getPosition(DiscoveredEntitiesTableModel::EntityDataFlag::EntityStatus):
+				static_cast<QStyledItemDelegate const&>(_errorIconItemDelegate).paint(painter, option, index);
 				break;
 			default:
 				break;
diff --git a/libs/widgetModelsLibrary/discoveredEntitiesTableModel.cpp b/libs/widgetModelsLibrary/discoveredEntitiesTableModel.cpp
index 42aa0716..9e12aacf 100644
--- a/libs/widgetModelsLibrary/discoveredEntitiesTableModel.cpp
+++ b/libs/widgetModelsLibrary/discoveredEntitiesTableModel.cpp
@@ -19,6 +19,7 @@
 
 #include "hive/widgetModelsLibrary/discoveredEntitiesTableModel.hpp"
 #include "hive/widgetModelsLibrary/entityLogoCache.hpp"
+#include "hive/widgetModelsLibrary/errorIconItemDelegate.hpp"
 #include "hive/widgetModelsLibrary/imageItemDelegate.hpp"
 
 #include <hive/modelsLibrary/discoveredEntitiesModel.hpp>
@@ -62,8 +63,20 @@ static std::unordered_map<modelsLibrary::DiscoveredEntitiesModel::ExclusiveAcces
 static std::unordered_map<modelsLibrary::DiscoveredEntitiesModel::ExclusiveAccessState, QImage> s_excusiveAccessStateImagesDark{
 	{ modelsLibrary::DiscoveredEntitiesModel::ExclusiveAccessState::NoAccess, QImage{ ":/unlocked.png" } },
 	{ modelsLibrary::DiscoveredEntitiesModel::ExclusiveAccessState::NotSupported, QImage{ ":/lock_not_supported.png" } },
-	{ modelsLibrary::DiscoveredEntitiesModel::ExclusiveAccessState::AccessOther, QImage{ ":/locked_by_other.png" } },
-	{ modelsLibrary::DiscoveredEntitiesModel::ExclusiveAccessState::AccessSelf, QImage{ ":/locked.png" } },
+	{ modelsLibrary::DiscoveredEntitiesModel::ExclusiveAccessState::AccessOther, QImage{ ":/locked_by_other_inv.png" } },
+	{ modelsLibrary::DiscoveredEntitiesModel::ExclusiveAccessState::AccessSelf, QImage{ ":/locked_inv.png" } },
+};
+
+static std::unordered_map<modelsLibrary::DiscoveredEntitiesModel::ClockDomainLockedState, QImage> s_clockDomainLockStateImagesLight{
+	{ modelsLibrary::DiscoveredEntitiesModel::ClockDomainLockedState::Unknown, QImage{ ":/unknown_light.png" } },
+	{ modelsLibrary::DiscoveredEntitiesModel::ClockDomainLockedState::Unlocked, QImage{ ":/unlocked.png" } },
+	{ modelsLibrary::DiscoveredEntitiesModel::ClockDomainLockedState::Locked, QImage{ ":/locked.png" } },
+};
+
+static std::unordered_map<modelsLibrary::DiscoveredEntitiesModel::ClockDomainLockedState, QImage> s_clockDomainLockStateImagesDark{
+	{ modelsLibrary::DiscoveredEntitiesModel::ClockDomainLockedState::Unknown, QImage{ ":/unknown_dark.png" } },
+	{ modelsLibrary::DiscoveredEntitiesModel::ClockDomainLockedState::Unlocked, QImage{ ":/unlocked.png" } },
+	{ modelsLibrary::DiscoveredEntitiesModel::ClockDomainLockedState::Locked, QImage{ ":/locked_inv.png" } },
 };
 
 DiscoveredEntitiesTableModel::DiscoveredEntitiesTableModel(EntityDataFlags const entityDataFlags)
@@ -78,6 +91,16 @@ std::optional<std::reference_wrapper<hive::modelsLibrary::DiscoveredEntitiesMode
 	return _model.entity(static_cast<std::size_t>(row));
 }
 
+QModelIndex DiscoveredEntitiesTableModel::indexOf(la::avdecc::UniqueIdentifier const& entityID) const noexcept
+{
+	auto const idxOpt = _model.indexOf(entityID);
+	if (idxOpt)
+	{
+		return createIndex(static_cast<int>(*idxOpt), 0);
+	}
+	return {};
+}
+
 // hive::modelsLibrary::DiscoveredEntitiesAbstractTableModel overrides
 void DiscoveredEntitiesTableModel::entityInfoChanged(std::size_t const index, hive::modelsLibrary::DiscoveredEntitiesModel::Entity const& /*entity*/, ChangedInfoFlags const changedInfoFlags) noexcept
 {
@@ -96,7 +119,7 @@ void DiscoveredEntitiesTableModel::entityInfoChanged(std::size_t const index, hi
 					if (entityDataFlag == DiscoveredEntitiesTableModel::EntityDataFlag::All)
 					{
 						auto const startIndex = createIndex(static_cast<int>(index), 0);
-						auto const endIndex = createIndex(static_cast<int>(index), columnCount());
+						auto const endIndex = createIndex(static_cast<int>(index), columnCount() - 1);
 						emit dataChanged(startIndex, endIndex, roles);
 					}
 					// Otherwise selectively refresh a single column
@@ -133,43 +156,97 @@ QVariant DiscoveredEntitiesTableModel::headerData(int section, Qt::Orientation o
 		{
 			auto const entityDataFlag = _entityDataFlags.at(section);
 
-			if (role == Qt::DisplayRole)
+			switch (role)
 			{
-				switch (entityDataFlag)
-				{
-					case EntityDataFlag::EntityLogo:
-						return "Logo";
-					case EntityDataFlag::Compatibility:
-						return "Compat";
-					case EntityDataFlag::EntityID:
-						return "Entity ID";
-					case EntityDataFlag::Name:
-						return "Name";
-					case EntityDataFlag::Group:
-						return "Group";
-					case EntityDataFlag::AcquireState:
-						return "Acquire State";
-					case EntityDataFlag::LockState:
-						return "Lock State";
-					case EntityDataFlag::GrandmasterID:
-						return "Grandmaster ID";
-					case EntityDataFlag::GPTPDomain:
-						return "gPTP Domain";
-					case EntityDataFlag::InterfaceIndex:
-						return "Interface Idx";
-					case EntityDataFlag::AssociationID:
-						return "Association ID";
-					case EntityDataFlag::EntityModelID:
-						return "Entity Model ID";
-					case EntityDataFlag::FirmwareVersion:
-						return "Firmware Version";
-					case EntityDataFlag::MediaClockReferenceID:
-						return "Media Clock Reference ID";
-					case EntityDataFlag::MediaClockReferenceStatus:
-						return "Media Clock Reference Status";
-					default:
-						break;
-				}
+				case Qt::DisplayRole:
+					switch (entityDataFlag)
+					{
+						case EntityDataFlag::EntityStatus:
+							return "Status";
+						case EntityDataFlag::EntityLogo:
+							return "Logo";
+						case EntityDataFlag::Compatibility:
+							return "Compat";
+						case EntityDataFlag::EntityID:
+							return "Entity ID";
+						case EntityDataFlag::Name:
+							return "Name";
+						case EntityDataFlag::Group:
+							return "Group";
+						case EntityDataFlag::AcquireState:
+							return "Acquire State";
+						case EntityDataFlag::LockState:
+							return "Lock State";
+						case EntityDataFlag::GrandmasterID:
+							return "Grandmaster ID";
+						case EntityDataFlag::GPTPDomain:
+							return "gPTP Domain";
+						case EntityDataFlag::InterfaceIndex:
+							return "Interface Idx";
+						case EntityDataFlag::MacAddress:
+							return "Mac Address";
+						case EntityDataFlag::AssociationID:
+							return "Association ID";
+						case EntityDataFlag::EntityModelID:
+							return "Entity Model ID";
+						case EntityDataFlag::FirmwareVersion:
+							return "Firmware Version";
+						case EntityDataFlag::MediaClockReferenceID:
+							return "MCR ID";
+						case EntityDataFlag::MediaClockReferenceName:
+							return "MCR Name";
+						case EntityDataFlag::ClockDomainLockState:
+							return "MCR Locked";
+						default:
+							break;
+					}
+					break;
+
+				case Qt::ToolTipRole:
+					switch (entityDataFlag)
+					{
+						case EntityDataFlag::EntityStatus:
+							return "Entity Status (Error/Warning/Info)";
+						case EntityDataFlag::EntityLogo:
+							return "Logo";
+						case EntityDataFlag::Compatibility:
+							return "Compat";
+						case EntityDataFlag::EntityID:
+							return "Entity ID";
+						case EntityDataFlag::Name:
+							return "Name";
+						case EntityDataFlag::Group:
+							return "Group";
+						case EntityDataFlag::AcquireState:
+							return "Acquire State";
+						case EntityDataFlag::LockState:
+							return "Lock State";
+						case EntityDataFlag::GrandmasterID:
+							return "Grandmaster ID";
+						case EntityDataFlag::GPTPDomain:
+							return "gPTP Domain";
+						case EntityDataFlag::InterfaceIndex:
+							return "Interface Idx";
+						case EntityDataFlag::MacAddress:
+							return "Mac Address";
+						case EntityDataFlag::AssociationID:
+							return "Association ID";
+						case EntityDataFlag::EntityModelID:
+							return "Entity Model ID";
+						case EntityDataFlag::FirmwareVersion:
+							return "Firmware Version";
+						case EntityDataFlag::MediaClockReferenceID:
+							return "Media Clock Reference ID";
+						case EntityDataFlag::MediaClockReferenceName:
+							return "Media Clock Reference Name";
+						case EntityDataFlag::ClockDomainLockState:
+							return "Media Clock Reference Lock State";
+						default:
+							break;
+					}
+					break;
+				default:
+					break;
 			}
 		}
 		catch (...)
@@ -180,6 +257,103 @@ QVariant DiscoveredEntitiesTableModel::headerData(int section, Qt::Orientation o
 	return {};
 }
 
+static ErrorIconItemDelegate::ErrorType getErrorType(modelsLibrary::DiscoveredEntitiesModel::Entity const& e) noexcept
+{
+	// Error
+	if (e.areUnsolicitedNotificationsSupported && !e.isSubscribedToUnsol)
+	{
+		return ErrorIconItemDelegate::ErrorType::Error;
+	}
+	if (!e.streamsWithLatencyError.empty())
+	{
+		return ErrorIconItemDelegate::ErrorType::Error;
+	}
+
+	// Warning
+	if (e.hasRedundancyWarning)
+	{
+		return ErrorIconItemDelegate::ErrorType::Warning;
+	}
+	if (!e.controlsWithOutOfBoundsValue.empty())
+	{
+		return ErrorIconItemDelegate::ErrorType::Warning;
+	}
+
+	// Information
+	if (e.hasStatisticsError || !e.streamsWithErrorCounter.empty())
+	{
+		return ErrorIconItemDelegate::ErrorType::Information;
+	}
+
+	return ErrorIconItemDelegate::ErrorType::None;
+}
+
+static QString getErrorTooltip(modelsLibrary::DiscoveredEntitiesModel::Entity const& e) noexcept
+{
+	auto const errorType = getErrorType(e);
+	auto tooltip = QStringList{};
+
+	if (e.hasStatisticsError)
+	{
+		// TODO: Split statistics error into multiple errors
+		tooltip.append("One or more statistics error");
+	}
+	if (!e.streamsWithErrorCounter.empty())
+	{
+		// Print each stream with error counter (up to 10 streams)
+		auto count = 0u;
+		for (auto const streamIndex : e.streamsWithErrorCounter)
+		{
+			tooltip.append(QString{ "Input Stream with index '%1' has counter errors" }.arg(streamIndex));
+			if (++count == 10)
+			{
+				tooltip.append("(more Input Streams with counter errors)");
+				break;
+			}
+		}
+	}
+	if (!e.streamsWithLatencyError.empty())
+	{
+		// Print each stream with latency error (up to 10 streams)
+		auto count = 0u;
+		for (auto const streamIndex : e.streamsWithLatencyError)
+		{
+			tooltip.append(QString{ "Input Stream with index '%1' has latency errors" }.arg(streamIndex));
+			if (++count == 10)
+			{
+				tooltip.append("(more Input Streams with latency errors)");
+				break;
+			}
+		}
+	}
+	if (e.hasRedundancyWarning)
+	{
+		tooltip.append("Primary and Secondary interfaces connected to the same network");
+	}
+	if (e.areUnsolicitedNotificationsSupported && !e.isSubscribedToUnsol)
+	{
+		tooltip.append("No longer getting live updates from the entity");
+	}
+	if (!e.controlsWithOutOfBoundsValue.empty())
+	{
+		// Print each control with out of bounds warning (up to 10 streams)
+		auto count = 0u;
+		for (auto const controlIndex : e.controlsWithOutOfBoundsValue)
+		{
+			tooltip.append(QString{ "Control with index '%1' has out of bounds value(s)" }.arg(controlIndex));
+			if (++count == 10)
+			{
+				tooltip.append("(more Controls with out of bounds value(s))");
+				break;
+			}
+		}
+	}
+
+
+	// Concat all lines into a single string separated by newlines
+	return tooltip.join("\n");
+}
+
 QVariant DiscoveredEntitiesTableModel::data(QModelIndex const& index, int role) const
 {
 	auto const row = static_cast<std::size_t>(index.row());
@@ -200,6 +374,8 @@ QVariant DiscoveredEntitiesTableModel::data(QModelIndex const& index, int role)
 					{
 						switch (entityDataFlag)
 						{
+							case EntityDataFlag::EntityStatus: // Return something as DisplayRole is used by the sort filter proxy model (but not actually displayed)
+								return la::avdecc::utils::to_integral(getErrorType(entity));
 							case EntityDataFlag::EntityID:
 								return hive::modelsLibrary::helper::uniqueIdentifierToString(entity.entityID);
 							case EntityDataFlag::Name:
@@ -254,6 +430,20 @@ QVariant DiscoveredEntitiesTableModel::data(QModelIndex const& index, int role)
 								}
 								return "N/A";
 							}
+							case EntityDataFlag::MacAddress:
+							{
+								auto const& macAddresses = entity.macAddresses;
+
+								if (!macAddresses.empty())
+								{
+									// Search the first valid mac address
+									for (auto const& [avbIndex, address] : macAddresses)
+									{
+										return hive::modelsLibrary::helper::macAddressToString(address);
+									}
+								}
+								return "N/A";
+							}
 							case EntityDataFlag::AssociationID:
 								return entity.associationID ? hive::modelsLibrary::helper::uniqueIdentifierToString(*entity.associationID) : "N/A";
 							case EntityDataFlag::EntityModelID:
@@ -274,7 +464,7 @@ QVariant DiscoveredEntitiesTableModel::data(QModelIndex const& index, int role)
 								}
 								return "N/A";
 							}
-							case EntityDataFlag::MediaClockReferenceStatus:
+							case EntityDataFlag::MediaClockReferenceName:
 							{
 								auto const& mediaClockReferences = entity.mediaClockReferences;
 
@@ -342,6 +532,18 @@ QVariant DiscoveredEntitiesTableModel::data(QModelIndex const& index, int role)
 									return {};
 								}
 							}
+							case EntityDataFlag::ClockDomainLockState:
+							{
+								try
+								{
+									return s_clockDomainLockStateImagesLight.at(entity.clockDomainInfo.state);
+								}
+								catch (std::out_of_range const&)
+								{
+									AVDECC_ASSERT(false, "Image missing");
+									return {};
+								}
+							}
 							default:
 								break;
 						}
@@ -396,6 +598,18 @@ QVariant DiscoveredEntitiesTableModel::data(QModelIndex const& index, int role)
 									return {};
 								}
 							}
+							case EntityDataFlag::ClockDomainLockState:
+							{
+								try
+								{
+									return s_clockDomainLockStateImagesDark.at(entity.clockDomainInfo.state);
+								}
+								catch (std::out_of_range const&)
+								{
+									AVDECC_ASSERT(false, "Image missing");
+									return {};
+								}
+							}
 							default:
 								break;
 						}
@@ -405,6 +619,10 @@ QVariant DiscoveredEntitiesTableModel::data(QModelIndex const& index, int role)
 					{
 						switch (entityDataFlag)
 						{
+							case EntityDataFlag::EntityStatus:
+							{
+								return getErrorTooltip(entity);
+							}
 							case EntityDataFlag::Compatibility:
 							{
 								switch (entity.protocolCompatibility)
@@ -462,8 +680,35 @@ QVariant DiscoveredEntitiesTableModel::data(QModelIndex const& index, int role)
 								}
 								return "Not set by the entity";
 							}
+							case EntityDataFlag::MacAddress:
+							{
+								auto const& macAddresses = entity.macAddresses;
+
+								if (!macAddresses.empty())
+								{
+									auto list = QStringList{};
+
+									for (auto const& [avbIndex, address] : macAddresses)
+									{
+										if (avbIndex == la::avdecc::entity::Entity::GlobalAvbInterfaceIndex)
+										{
+											list << QString{ "Global Mac Address: %1" }.arg(hive::modelsLibrary::helper::macAddressToString(address));
+										}
+										else
+										{
+											list << QString{ "Mac Address for index %1: %2" }.arg(avbIndex).arg(hive::modelsLibrary::helper::macAddressToString(address));
+										}
+									}
+
+									if (!list.isEmpty())
+									{
+										return list.join('\n');
+									}
+								}
+								return "Not set by the entity";
+							}
 							case EntityDataFlag::MediaClockReferenceID:
-							case EntityDataFlag::MediaClockReferenceStatus:
+							case EntityDataFlag::MediaClockReferenceName:
 							{
 								auto const& mediaClockReferences = entity.mediaClockReferences;
 
@@ -483,17 +728,21 @@ QVariant DiscoveredEntitiesTableModel::data(QModelIndex const& index, int role)
 								}
 								return "Undefined";
 							}
+							case EntityDataFlag::ClockDomainLockState:
+								return entity.clockDomainInfo.tooltip;
 							default:
 								break;
 						}
 						break;
 					}
 					case la::avdecc::utils::to_integral(QtUserRoles::ErrorRole):
-						return entity.hasStatisticsError || entity.hasRedundancyWarning || !entity.streamsWithErrorCounter.empty() || !entity.streamsWithLatencyError.empty();
+						return QVariant::fromValue(getErrorType(entity));
 					case la::avdecc::utils::to_integral(QtUserRoles::IdentificationRole):
 						return entity.isIdentifying;
 					case la::avdecc::utils::to_integral(QtUserRoles::SubscribedUnsolRole):
 						return entity.isSubscribedToUnsol;
+					case la::avdecc::utils::to_integral(QtUserRoles::UnsolSupportedRole):
+						return entity.areUnsolicitedNotificationsSupported;
 					case la::avdecc::utils::to_integral(QtUserRoles::IsVirtualRole):
 						return entity.isVirtual;
 					default:
@@ -519,7 +768,7 @@ std::optional<std::pair<DiscoveredEntitiesTableModel::EntityDataFlag, RolesList>
 		case ChangedInfoFlag::GroupName:
 			return std::make_pair(EntityDataFlag::Group, RolesList{ Qt::DisplayRole });
 		case ChangedInfoFlag::SubscribedToUnsol:
-			return std::make_pair(EntityDataFlag::All, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::SubscribedUnsolRole) });
+			return std::make_pair(EntityDataFlag::EntityStatus, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
 		case ChangedInfoFlag::Compatibility:
 			return std::make_pair(EntityDataFlag::Compatibility, RolesList{ Qt::DisplayRole });
 		case ChangedInfoFlag::EntityCapabilities:
@@ -539,22 +788,28 @@ std::optional<std::pair<DiscoveredEntitiesTableModel::EntityDataFlag, RolesList>
 			return std::make_pair(EntityDataFlag::GPTPDomain, RolesList{ Qt::DisplayRole });
 		case ChangedInfoFlag::InterfaceIndex:
 			return std::make_pair(EntityDataFlag::InterfaceIndex, RolesList{ Qt::DisplayRole });
+		case ChangedInfoFlag::MacAddress:
+			return std::make_pair(EntityDataFlag::MacAddress, RolesList{ Qt::DisplayRole });
 		case ChangedInfoFlag::AssociationID:
 			return std::make_pair(EntityDataFlag::AssociationID, RolesList{ Qt::DisplayRole });
 		case ChangedInfoFlag::MediaClockReferenceID:
 			return std::make_pair(EntityDataFlag::MediaClockReferenceID, RolesList{ Qt::DisplayRole });
-		case ChangedInfoFlag::MediaClockReferenceStatus:
-			return std::make_pair(EntityDataFlag::MediaClockReferenceStatus, RolesList{ Qt::DisplayRole });
+		case ChangedInfoFlag::MediaClockReferenceName:
+			return std::make_pair(EntityDataFlag::MediaClockReferenceName, RolesList{ Qt::DisplayRole });
+		case ChangedInfoFlag::ClockDomainLockState:
+			return std::make_pair(EntityDataFlag::ClockDomainLockState, RolesList{ Qt::DisplayRole });
 		case ChangedInfoFlag::Identification:
 			return std::make_pair(EntityDataFlag::EntityID, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::IdentificationRole) });
 		case ChangedInfoFlag::StatisticsError:
-			return std::make_pair(EntityDataFlag::EntityID, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
+			return std::make_pair(EntityDataFlag::EntityStatus, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
 		case ChangedInfoFlag::RedundancyWarning:
-			return std::make_pair(EntityDataFlag::EntityID, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
+			return std::make_pair(EntityDataFlag::EntityStatus, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
 		case ChangedInfoFlag::StreamInputCountersError:
-			return std::make_pair(EntityDataFlag::EntityID, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
+			return std::make_pair(EntityDataFlag::EntityStatus, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
 		case ChangedInfoFlag::StreamInputLatencyError:
-			return std::make_pair(EntityDataFlag::EntityID, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
+			return std::make_pair(EntityDataFlag::EntityStatus, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
+		case ChangedInfoFlag::ControlValueOutOfBoundsError:
+			return std::make_pair(EntityDataFlag::EntityStatus, RolesList{ la::avdecc::utils::to_integral(QtUserRoles::ErrorRole) });
 		default:
 			AVDECC_ASSERT(false, "Unhandled");
 			break;
diff --git a/libs/widgetModelsLibrary/entityLogoCache.cpp b/libs/widgetModelsLibrary/entityLogoCache.cpp
index 681572cf..26becc86 100644
--- a/libs/widgetModelsLibrary/entityLogoCache.cpp
+++ b/libs/widgetModelsLibrary/entityLogoCache.cpp
@@ -187,10 +187,16 @@ class EntityLogoCacheImpl : public EntityLogoCache
 				auto const& obj{ it.second };
 				auto const& model{ obj.staticModel };
 
-				if ((type == Type::Entity && model->memoryObjectType == la::avdecc::entity::model::MemoryObjectType::PngEntity) || (type == Type::Manufacturer && model->memoryObjectType == la::avdecc::entity::model::MemoryObjectType::PngManufacturer))
+				if ((type == Type::Entity && model.memoryObjectType == la::avdecc::entity::model::MemoryObjectType::PngEntity) || (type == Type::Manufacturer && model.memoryObjectType == la::avdecc::entity::model::MemoryObjectType::PngManufacturer))
 				{
 					auto const& dynamicModel{ obj.dynamicModel };
-					manager.readDeviceMemory(entityID, model->startAddress, dynamicModel->length, nullptr,
+					// Check to prevent crash for buggy devices
+					auto length = dynamicModel.length;
+					if (model.maximumLength != 0u && length > model.maximumLength)
+					{
+						length = model.maximumLength;
+					}
+					manager.readDeviceMemory(entityID, model.startAddress, length, nullptr,
 						[this, entityID, type](la::avdecc::controller::ControlledEntity const* const /*entity*/, la::avdecc::entity::ControllerEntity::AaCommandStatus const status, la::avdecc::controller::Controller::DeviceMemoryBuffer const& memoryBuffer)
 						{
 							auto image = QImage::fromData(memoryBuffer.data(), static_cast<int>(memoryBuffer.size()));
diff --git a/libs/widgetModelsLibrary/errorIconItemDelegate.cpp b/libs/widgetModelsLibrary/errorIconItemDelegate.cpp
new file mode 100644
index 00000000..7f594d06
--- /dev/null
+++ b/libs/widgetModelsLibrary/errorIconItemDelegate.cpp
@@ -0,0 +1,100 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "hive/widgetModelsLibrary/errorIconItemDelegate.hpp"
+#include "hive/widgetModelsLibrary/qtUserRoles.hpp"
+
+#include <QPainter>
+
+namespace hive
+{
+namespace widgetModelsLibrary
+{
+ErrorIconItemDelegate::ErrorIconItemDelegate(bool const paintBaseDelegate, qtMate::material::color::Name const themeColorName, QObject* parent) noexcept
+	: QStyledItemDelegate(parent)
+	, _paintBaseDelegate{ paintBaseDelegate }
+	, _themeColorName{ themeColorName }
+{
+}
+
+void ErrorIconItemDelegate::setThemeColorName(qtMate::material::color::Name const themeColorName)
+{
+	_themeColorName = themeColorName;
+}
+
+inline QRect getCenteredSquare(QRect const& rect, int const size)
+{
+	auto const x = rect.x() + (rect.width() - size) / 2;
+	auto const y = rect.y() + (rect.height() - size) / 2;
+	return QRect{ x, y, size, size };
+}
+
+void ErrorIconItemDelegate::paint(QPainter* painter, QStyleOptionViewItem const& option, QModelIndex const& index) const
+{
+	// Only paint parent if requested
+	if (_paintBaseDelegate)
+	{
+		QStyledItemDelegate::paint(painter, option, index);
+	}
+
+	painter->save();
+	auto const errorType = index.data(la::avdecc::utils::to_integral(QtUserRoles::ErrorRole)).value<ErrorType>();
+	auto const colorName = (option.state & QStyle::StateFlag::State_Selected) ? _themeColorName : qtMate::material::color::backgroundColorName();
+	auto const shade = (option.state & QStyle::StateFlag::State_Selected) ? qtMate::material::color::DefaultLightShade : qtMate::material::color::colorSchemeShade();
+
+	switch (errorType)
+	{
+		case ErrorType::Error:
+		{
+			auto font = QFont{ "Hive" };
+			font.setStyleStrategy(QFont::PreferQuality);
+			font.setPointSize(14);
+			painter->setPen(qtMate::material::color::foregroundErrorColorValue(colorName, shade));
+			painter->setFont(font);
+			painter->drawText(option.rect, Qt::AlignCenter, "error_fill");
+			break;
+		}
+		case ErrorType::Warning:
+		{
+			auto font = QFont{ "Hive" };
+			font.setStyleStrategy(QFont::PreferQuality);
+			font.setPointSize(14);
+			painter->setPen(qtMate::material::color::foregroundWarningColorValue(colorName, shade));
+			painter->setFont(font);
+			painter->drawText(option.rect, Qt::AlignCenter, "warning_fill");
+			break;
+		}
+		case ErrorType::Information:
+		{
+			auto font = QFont{ "Hive" };
+			font.setStyleStrategy(QFont::PreferQuality);
+			font.setPointSize(14);
+			painter->setPen(qtMate::material::color::foregroundInformationColorValue(colorName, shade));
+			painter->setFont(font);
+			painter->drawText(option.rect, Qt::AlignCenter, "information_fill");
+			break;
+		}
+		default:
+			break;
+	}
+	painter->restore();
+} // namespace widgetModelsLibrary
+
+} // namespace widgetModelsLibrary
+} // namespace hive
diff --git a/libs/widgetModelsLibrary/errorItemDelegate.cpp b/libs/widgetModelsLibrary/errorItemDelegate.cpp
index da864488..95d7de65 100644
--- a/libs/widgetModelsLibrary/errorItemDelegate.cpp
+++ b/libs/widgetModelsLibrary/errorItemDelegate.cpp
@@ -48,17 +48,10 @@ void ErrorItemDelegate::paint(QPainter* painter, QStyleOptionViewItem const& opt
 
 	if (index.data(la::avdecc::utils::to_integral(QtUserRoles::ErrorRole)).toBool())
 	{
-		if (option.state & QStyle::StateFlag::State_Selected)
-		{
-			painter->setPen(QPen{ qtMate::material::color::complementaryValue(_themeColorName, qtMate::material::color::Shade::Shade600), 2 });
-			painter->drawRect(option.rect.adjusted(1, 1, -1, -1));
-		}
-		else
-		{
-			//painter->setPen(qtMate::material::color::foregroundErrorColorValue(_colorName, qtMate::material::color::Shade::ShadeA700));
-			painter->setPen(qtMate::material::color::foregroundErrorColorValue(qtMate::material::color::DefaultColor, qtMate::material::color::Shade::ShadeA700)); // Right now, always use default value, as we draw on white background
-			painter->drawRect(option.rect.adjusted(0, 0, -1, -1));
-		}
+		auto const colorName = (option.state & QStyle::StateFlag::State_Selected) ? _themeColorName : qtMate::material::color::backgroundColorName();
+		auto const shade = (option.state & QStyle::StateFlag::State_Selected) ? qtMate::material::color::DefaultLightShade : qtMate::material::color::colorSchemeShade();
+		painter->setPen(qtMate::material::color::foregroundErrorColorValue(colorName, shade));
+		painter->drawRect(option.rect.adjusted(0, 0, -1, -1));
 	}
 }
 
diff --git a/libs/widgetModelsLibrary/networkInterfacesListItemDelegate.cpp b/libs/widgetModelsLibrary/networkInterfacesListItemDelegate.cpp
new file mode 100644
index 00000000..659e1da3
--- /dev/null
+++ b/libs/widgetModelsLibrary/networkInterfacesListItemDelegate.cpp
@@ -0,0 +1,84 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "hive/widgetModelsLibrary/networkInterfacesListItemDelegate.hpp"
+#include "hive/widgetModelsLibrary/networkInterfacesListModel.hpp"
+#include "hive/widgetModelsLibrary/qtUserRoles.hpp"
+
+#include <QPainter>
+#include <QAbstractItemView>
+#include <QComboBox>
+
+namespace hive
+{
+namespace widgetModelsLibrary
+{
+NetworkInterfacesListItemDelegate::NetworkInterfacesListItemDelegate(qtMate::material::color::Name const themeColorName, QObject* parent) noexcept
+	: QStyledItemDelegate(parent)
+{
+	setThemeColorName(themeColorName);
+}
+
+void NetworkInterfacesListItemDelegate::setThemeColorName(qtMate::material::color::Name const themeColorName)
+{
+	_themeColorName = themeColorName;
+	_isDark = qtMate::material::color::luminance(_themeColorName) == qtMate::material::color::Luminance::Dark;
+	_errorItemDelegate.setThemeColorName(themeColorName);
+	_imageItemDelegate.setThemeColorName(themeColorName);
+}
+
+void NetworkInterfacesListItemDelegate::paint(QPainter* painter, QStyleOptionViewItem const& option, QModelIndex const& index) const
+{
+	// Override default options according to the model current state
+	auto basePainterOption = option;
+
+	// Clear focus state if any
+	if (basePainterOption.state & QStyle::State_HasFocus)
+	{
+		basePainterOption.state &= ~QStyle::State_HasFocus;
+	}
+
+	// Base painter
+	{
+		painter->save();
+
+		if (auto* view = dynamic_cast<QAbstractItemView const*>(option.widget))
+		{
+			if (auto* parent = view->parent(); !qstrcmp("QComboBoxPrivateContainer", parent->metaObject()->className()))
+			{
+				if (auto* widget = dynamic_cast<QComboBox const*>(parent->parent()))
+				{
+					basePainterOption.font.setBold(index.row() == widget->currentIndex());
+				}
+			}
+		}
+
+		QStyledItemDelegate::paint(painter, basePainterOption, index);
+
+		painter->restore();
+	}
+
+	// Error painter
+	{
+		static_cast<QStyledItemDelegate const&>(_errorItemDelegate).paint(painter, option, index);
+	}
+}
+
+} // namespace widgetModelsLibrary
+} // namespace hive
diff --git a/libs/widgetModelsLibrary/networkInterfacesListModel.cpp b/libs/widgetModelsLibrary/networkInterfacesListModel.cpp
index 871dd944..51112392 100644
--- a/libs/widgetModelsLibrary/networkInterfacesListModel.cpp
+++ b/libs/widgetModelsLibrary/networkInterfacesListModel.cpp
@@ -24,15 +24,25 @@
 #include <QtMate/material/color.hpp>
 #include <QtMate/material/helper.hpp>
 
+#include <QStyleHints>
+#include <QGuiApplication>
+
 #include <unordered_map>
 
 namespace hive
 {
 namespace widgetModelsLibrary
 {
+static std::unordered_map<la::networkInterface::Interface::Type, QIcon> s_cachedIcons{};
+
 NetworkInterfacesListModel::NetworkInterfacesListModel(bool const addOfflineInterface) noexcept
 	: _model{ hive::modelsLibrary::NetworkInterfacesModel{ this, addOfflineInterface } }
 {
+	connect(QGuiApplication::styleHints(), &QStyleHints::colorSchemeChanged, this,
+		[](Qt::ColorScheme /*scheme*/)
+		{
+			s_cachedIcons.clear();
+		});
 }
 
 bool NetworkInterfacesListModel::isEnabled(QString const& id) const noexcept
@@ -61,10 +71,8 @@ la::networkInterface::Interface::Type NetworkInterfacesListModel::getInterfaceTy
 
 QIcon NetworkInterfacesListModel::interfaceTypeIcon(la::networkInterface::Interface::Type const type) noexcept
 {
-	static std::unordered_map<la::networkInterface::Interface::Type, QIcon> s_icon;
-
-	auto const it = s_icon.find(type);
-	if (it == std::end(s_icon))
+	auto const it = s_cachedIcons.find(type);
+	if (it == std::end(s_cachedIcons))
 	{
 		auto what = QString{};
 
@@ -85,10 +93,10 @@ QIcon NetworkInterfacesListModel::interfaceTypeIcon(la::networkInterface::Interf
 				break;
 		}
 
-		s_icon[type] = qtMate::material::helper::generateIcon(what);
+		s_cachedIcons[type] = qtMate::material::helper::generateIcon(what, qtMate::material::color::foregroundColor());
 	}
 
-	return s_icon[type];
+	return s_cachedIcons[type];
 }
 
 // hive::modelsLibrary::NetworkInterfacesAbstractListModel overrides
@@ -141,19 +149,15 @@ QVariant NetworkInterfacesListModel::data(QModelIndex const& index, int role) co
 		{
 			if (auto const optInterface = _model.networkInterface(static_cast<std::size_t>(index.row())))
 			{
+				// TODO: This should be moved to the errorItemDelegate, with isEnabled/isConnected as roles (so that we can change the color when an item is selected and in error state)
 				auto const& intfc = (*optInterface).get();
 				if (!intfc.isEnabled)
 				{
-					return qtMate::material::color::value(qtMate::material::color::Name::Gray);
+					return qtMate::material::color::disabledForegroundColor();
 				}
 				else if (!intfc.isConnected)
 				{
-					//return qtMate::material::color::foregroundErrorColorValue(colorName, qtMate::material::color::Shade::ShadeA700);
-					return qtMate::material::color::foregroundErrorColorValue(qtMate::material::color::DefaultColor, qtMate::material::color::DefaultShade); // Right now, always use default value, as we draw on white background
-				}
-				else
-				{
-					return QColor{ Qt::black };
+					return qtMate::material::color::foregroundErrorColorValue(qtMate::material::color::backgroundColorName(), qtMate::material::color::colorSchemeShade());
 				}
 			}
 			break;
diff --git a/libs/widgetModelsLibrary/pch.hpp b/libs/widgetModelsLibrary/pch.hpp
index 8f437992..bcc585cd 100644
--- a/libs/widgetModelsLibrary/pch.hpp
+++ b/libs/widgetModelsLibrary/pch.hpp
@@ -19,17 +19,6 @@
 
 #pragma once
 
-// Public Headers
-#include "hive/widgetModelsLibrary/discoveredEntitiesTableModel.hpp"
-#include "hive/widgetModelsLibrary/entityLogoCache.hpp"
-#include "hive/widgetModelsLibrary/errorItemDelegate.hpp"
-#include "hive/widgetModelsLibrary/imageItemDelegate.hpp"
-#include "hive/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.hpp"
-#include "hive/widgetModelsLibrary/networkInterfacesListModel.hpp"
-#include "hive/widgetModelsLibrary/painterHelper.hpp"
-#include "hive/widgetModelsLibrary/qtUserRoles.hpp"
-#include "hive/widgetModelsLibrary/widgetModelsLibrary.hpp"
-
 // Other Headers
 #include <QtMate/material/color.hpp>
 #include <QtMate/material/helper.hpp>
diff --git a/resources/AEMDumper.qrc b/resources/AEMDumper.qrc
index f7bccd2b..e76b4305 100644
--- a/resources/AEMDumper.qrc
+++ b/resources/AEMDumper.qrc
@@ -8,6 +8,8 @@
         <file>unlocked.png</file>
         <file>locked_by_other.png</file>
         <file>lock_not_supported.png</file>
+        <file>unknown_light.png</file>
+        <file>unknown_dark.png</file>
         <file>Milan_Compatible.png</file>
         <file>Milan_Compatible_inv.png</file>
         <file>Milan_Certified.png</file>
diff --git a/resources/Hive.ttf b/resources/Hive.ttf
index 1c2998b3..1d700254 100755
Binary files a/resources/Hive.ttf and b/resources/Hive.ttf differ
diff --git a/resources/Raw/Error.svg b/resources/Raw/Error.svg
new file mode 100644
index 00000000..2f75463c
--- /dev/null
+++ b/resources/Raw/Error.svg
@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M8 0C6.41775 0 4.87103 0.469192 3.55544 1.34824C2.23985 2.22729 1.21447 3.47672 0.608967 4.93853C0.00346633 6.40034 -0.15496 8.00887 0.153721 9.56072C0.462403 11.1126 1.22433 12.538 2.34315 13.6569C3.46197 14.7757 4.88743 15.5376 6.43928 15.8463C7.99113 16.155 9.59966 15.9965 11.0615 15.391C12.5233 14.7855 13.7727 13.7602 14.6518 12.4446C15.5308 11.129 16 9.58225 16 8C16 5.87827 15.1571 3.84344 13.6569 2.34315C12.1566 0.842855 10.1217 0 8 0ZM11.1314 11.1314C11.0389 11.2254 10.9286 11.3001 10.807 11.351C10.6853 11.402 10.5547 11.4282 10.4229 11.4282C10.291 11.4282 10.1604 11.402 10.0388 11.351C9.91711 11.3001 9.80681 11.2254 9.71429 11.1314L8.20572 9.61143C8.14914 9.56083 8.0759 9.53285 8 9.53285C7.9241 9.53285 7.85086 9.56083 7.79429 9.61143L6.28572 11.1314C6.09732 11.3185 5.84262 11.4234 5.57715 11.4234C5.31167 11.4234 5.05697 11.3185 4.86857 11.1314C4.77347 11.0397 4.69806 10.9296 4.64697 10.8078C4.59588 10.6859 4.57018 10.555 4.57143 10.4229C4.57148 10.2909 4.59778 10.1604 4.64879 10.0387C4.69981 9.91706 4.77452 9.80678 4.86857 9.71429L6.38857 8.20571C6.43918 8.14914 6.46715 8.0759 6.46715 8C6.46715 7.9241 6.43918 7.85086 6.38857 7.79429L4.86857 6.28571C4.70623 6.09307 4.6221 5.84652 4.63282 5.59482C4.64354 5.34312 4.74833 5.10461 4.92647 4.92647C5.10461 4.74833 5.34312 4.64354 5.59482 4.63281C5.84652 4.62209 6.09307 4.70623 6.28572 4.86857L7.79429 6.38857C7.85086 6.43917 7.9241 6.46715 8 6.46715C8.0759 6.46715 8.14914 6.43917 8.20572 6.38857L9.71429 4.86857C9.80404 4.76207 9.91494 4.67537 10.04 4.61396C10.165 4.55256 10.3014 4.51779 10.4405 4.51187C10.5797 4.50594 10.7186 4.52898 10.8483 4.57953C10.9781 4.63008 11.096 4.70704 11.1945 4.80552C11.293 4.90401 11.3699 5.02188 11.4205 5.15166C11.471 5.28145 11.4941 5.42031 11.4881 5.55947C11.4822 5.69862 11.4474 5.83503 11.386 5.96005C11.3246 6.08506 11.2379 6.19596 11.1314 6.28571L9.61143 7.79429C9.56083 7.85086 9.53285 7.9241 9.53285 8C9.53285 8.0759 9.56083 8.14914 9.61143 8.20571L11.1314 9.71429C11.2255 9.80678 11.3002 9.91706 11.3512 10.0387C11.4022 10.1604 11.4285 10.2909 11.4286 10.4229C11.4298 10.555 11.4041 10.6859 11.353 10.8078C11.3019 10.9296 11.2265 11.0397 11.1314 11.1314Z" fill="#FF5533"/>
+</svg>
diff --git a/resources/Raw/Hive.sfd b/resources/Raw/Hive.sfd
old mode 100755
new mode 100644
index d1a19dee..fc29cb9e
--- a/resources/Raw/Hive.sfd
+++ b/resources/Raw/Hive.sfd
@@ -22,7 +22,7 @@ OS2Version: 4
 OS2_WeightWidthSlopeOnly: 0
 OS2_UseTypoMetrics: 1
 CreationTime: 1551823031
-ModificationTime: 1643293031
+ModificationTime: 1693295518
 PfmFamily: 17
 TTFWeight: 400
 TTFWidth: 5
@@ -90,7 +90,7 @@ Grid
   Named: "left"
 EndSplineSet
 TeXData: 1 0 0 346030 173015 115343 0 1048576 115343 783286 444596 497025 792723 393216 433062 380633 303038 157286 324010 404750 52429 2506097 1059062 262144
-BeginChars: 43 43
+BeginChars: 46 46
 
 StartChar: uniE000
 Encoding: 37 57344 0
@@ -942,6 +942,7 @@ SplineSet
  253.5 379 253.5 379 254.5 379 c 128,-1,163
  255.5 379 255.5 379 255.5 379 c 2,110,-1
 EndSplineSet
+Validated: 524325
 LCarets2: 14 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 Ligature2: "'rlig' Required Ligatures in Latin lookup 0" f i r m w a r e underscore u p l o a d
 EndChar
@@ -993,6 +994,7 @@ SplineSet
  53.7526599689 484.989948187 53.7526599689 484.989948187 45.8779296875 484.669921875 c 4,39,40
  38 485 38 485 32 479 c 132,-1,25
 EndSplineSet
+Validated: 524293
 LCarets2: 11 0 0 0 0 0 0 0 0 0 0 0
 Ligature2: "'rlig' Required Ligatures in Latin lookup 0" c l e a r underscore e r r o r s
 EndChar
@@ -1051,6 +1053,7 @@ SplineSet
  50.5009765625 473.57421875 50.5009765625 473.57421875 42.2919921875 473.57421875 c 132,-1,36
  34.083984375 473.57421875 34.083984375 473.57421875 28.4140625 467.904296875 c 132,-1,37
 EndSplineSet
+Validated: 524293
 LCarets2: 17 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 Ligature2: "'rlig' Required Ligatures in Latin lookup 0" r e m o v e underscore c o n n e c t i o n s
 EndChar
@@ -1159,8 +1162,166 @@ SplineSet
  305 401 305 401 297.984375 395.169921875 c 0,154,155
  292 389 292 389 282.009765625 388.583984375 c 0,140,141
 EndSplineSet
+Validated: 524325
 LCarets2: 4 0 0 0 0
 Ligature2: "'rlig' Required Ligatures in Latin lookup 0" r a d a r
 EndChar
+
+StartChar: uniE006
+Encoding: 43 57350 43
+Width: 512
+VWidth: 0
+LayerCount: 2
+Fore
+SplineSet
+256 487 m 0,0,1
+ 350 487 350 487 419 419 c 128,-1,2
+ 488 351 488 351 487 256 c 0,3,4
+ 486 186 486 186 448 128 c 0,5,6
+ 409 69 409 69 344 43 c 0,7,8
+ 277 16 277 16 211 30 c 0,9,10
+ 142 44 142 44 93 93 c 0,11,12
+ 43 143 43 143 30 211 c 0,13,14
+ 17 280 17 280 44 344 c 0,15,16
+ 70 409 70 409 128 448 c 128,-1,17
+ 186 487 186 487 256 487 c 0,0,1
+346 166 m 0,18,19
+ 351 170 351 170 353 175 c 128,-1,20
+ 355 180 355 180 355 187 c 0,21,22
+ 355 191 355 191 353 197 c 128,-1,23
+ 351 203 351 203 346 207 c 2,24,-1
+ 303 250 l 2,25,26
+ 300 253 300 253 300 256 c 0,27,28
+ 300 260 300 260 303 262 c 2,29,-1
+ 346 306 l 2,30,31
+ 352 311 352 311 354 315 c 0,32,33
+ 355 317 355 317 356 326 c 0,34,35
+ 357 332 357 332 355 338 c 0,36,37
+ 354 340 354 340 348 348 c 0,38,39
+ 344 352 344 352 338 355 c 0,40,41
+ 331 358 331 358 327 357 c 0,42,43
+ 318 356 318 356 315 354 c 0,44,45
+ 310 351 310 351 306 346 c 2,46,-1
+ 262 303 l 2,47,48
+ 260 300 260 300 256 300 c 0,49,50
+ 253 300 253 300 250 303 c 2,51,-1
+ 207 346 l 2,52,53
+ 199 353 199 353 187 353 c 0,54,55
+ 176 353 176 353 168 345 c 0,56,57
+ 159 336 159 336 159 326 c 0,58,59
+ 159 314 159 314 166 306 c 2,60,-1
+ 210 262 l 2,61,62
+ 212 260 212 260 212 256 c 0,63,64
+ 212 253 212 253 210 250 c 2,65,-1
+ 166 207 l 2,66,67
+ 162 202 162 202 160 198 c 0,68,69
+ 158 192 158 192 158 186 c 0,70,71
+ 157 180 157 180 159 176 c 0,72,73
+ 162 169 162 169 166 166 c 0,74,75
+ 174 159 174 159 186 158 c 128,-1,76
+ 198 157 198 157 207 166 c 2,77,-1
+ 250 210 l 2,78,79
+ 253 212 253 212 256 212 c 0,80,81
+ 260 212 260 212 262 210 c 2,82,-1
+ 306 166 l 2,83,84
+ 310 162 310 162 315 160 c 128,-1,85
+ 320 158 320 158 326 158 c 0,86,87
+ 329.999033233 157.000241692 329.999033233 157.000241692 336.891601562 159.756835938 c 0,88,89
+ 340 161 340 161 346 166 c 0,18,19
+EndSplineSet
+LCarets2: 9 0 0 0 0 0 0 0 0 0
+Ligature2: "'rlig' Required Ligatures in Latin lookup 0" e r r o r underscore f i l l
+EndChar
+
+StartChar: uniE007
+Encoding: 44 57351 44
+Width: 512
+VWidth: 0
+LayerCount: 2
+Fore
+SplineSet
+481 97 m 2,0,1
+ 486 88 486 88 486 73 c 0,2,3
+ 486 60 486 60 479 49 c 128,-1,4
+ 472 38 472 38 461 32 c 128,-1,5
+ 450 26 450 26 437 26 c 2,6,-1
+ 75 26 l 2,7,8
+ 62 26 62 26 51 32 c 128,-1,9
+ 40 38 40 38 33 49 c 0,10,11
+ 27 58 27 58 26 73 c 0,12,13
+ 25 86 25 86 31 97 c 2,14,-1
+ 212 459 l 2,15,16
+ 218 472 218 472 230 479 c 128,-1,17
+ 242 486 242 486 256 486 c 128,-1,18
+ 270 486 270 486 282 479 c 128,-1,19
+ 294 472 294 472 300 459 c 2,20,-1
+ 481 97 l 2,0,1
+231 322 m 2,21,-1
+ 231 223 l 2,22,23
+ 231 212 231 212 238 206 c 0,24,25
+ 246 199 246 199 256 199 c 0,26,27
+ 265 199 265 199 273 206 c 128,-1,28
+ 281 213 281 213 281 223 c 2,29,-1
+ 281 322 l 2,30,31
+ 281 332 281 332 274 339 c 0,32,33
+ 266 347 266 347 256 347 c 128,-1,34
+ 246 347 246 347 238.5 339.5 c 128,-1,35
+ 231 332 231 332 231 322 c 2,21,-1
+256 92 m 0,36,37
+ 270 92 270 92 279 101 c 0,38,39
+ 289 111 289 111 289 125 c 0,40,41
+ 289 133 289 133 283 143 c 0,42,43
+ 278 152 278 152 269 155 c 0,44,45
+ 259 159 259 159 249 157 c 0,46,47
+ 240 155 240 155 233 148 c 128,-1,48
+ 226 141 226 141 224 131 c 128,-1,49
+ 222 121 222 121 226 112 c 0,50,51
+ 229 103 229 103 237.5 97.5 c 128,-1,52
+ 246 92 246 92 256 92 c 0,36,37
+EndSplineSet
+LCarets2: 11 0 0 0 0 0 0 0 0 0 0 0
+Ligature2: "'rlig' Required Ligatures in Latin lookup 0" w a r n i n g underscore f i l l
+EndChar
+
+StartChar: uniE008
+Encoding: 45 57352 45
+Width: 512
+VWidth: 0
+LayerCount: 2
+Fore
+SplineSet
+26 256 m 0,0,1
+ 26 353 26 353 93 419 c 0,2,3
+ 161 486 161 486 256 486 c 0,4,5
+ 353 486 353 486 419 419 c 0,6,7
+ 486 351 486 351 486 256 c 0,8,9
+ 486 159 486 159 419 93 c 0,10,11
+ 351 26 351 26 256 26 c 128,-1,12
+ 161 26 161 26 93.5 93.5 c 128,-1,13
+ 26 161 26 161 26 256 c 0,0,1
+256 326 m 0,14,15
+ 268 326 268 326 279 336 c 0,16,17
+ 289 345 289 345 289 359 c 0,18,19
+ 289 371 289 371 279 382 c 0,20,21
+ 270 392 270 392 256 392 c 0,22,23
+ 243 392 243 392 233 382 c 128,-1,24
+ 223 372 223 372 223 359 c 0,25,26
+ 223 345 223 345 232.5 335.5 c 128,-1,27
+ 242 326 242 326 256 326 c 0,14,15
+256 91 m 0,28,29
+ 269 91 269 91 279 101 c 128,-1,30
+ 289 111 289 111 289 124 c 2,31,-1
+ 289 256 l 2,32,33
+ 289 268 289 268 279 279 c 0,34,35
+ 270 289 270 289 256 289 c 0,36,37
+ 244 289 244 289 233 279 c 0,38,39
+ 223 270 223 270 223 256 c 2,40,-1
+ 223 124 l 2,41,42
+ 223 111 223 111 232.5 101 c 128,-1,43
+ 242 91 242 91 256 91 c 0,28,29
+EndSplineSet
+LCarets2: 15 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+Ligature2: "'rlig' Required Ligatures in Latin lookup 0" i n f o r m a t i o n underscore f i l l
+EndChar
 EndChars
 EndSplineFont
diff --git a/resources/Raw/Icon_ANS.png b/resources/Raw/Icon_ANS.png
new file mode 100644
index 00000000..dbfab30b
Binary files /dev/null and b/resources/Raw/Icon_ANS.png differ
diff --git a/resources/Raw/Icon_AVE.png b/resources/Raw/Icon_AVE.png
new file mode 100644
index 00000000..3db087a3
Binary files /dev/null and b/resources/Raw/Icon_AVE.png differ
diff --git a/resources/Raw/Information.svg b/resources/Raw/Information.svg
new file mode 100644
index 00000000..fa1b736a
--- /dev/null
+++ b/resources/Raw/Information.svg
@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M0 8C0 3.584 3.584 0 8 0C12.416 0 16 3.584 16 8C16 12.416 12.416 16 8 16C3.584 16 0 12.416 0 8ZM8 5.57143C7.36882 5.57143 6.85714 5.05975 6.85714 4.42857C6.85714 3.79739 7.36882 3.28571 8 3.28571C8.63118 3.28571 9.14286 3.79739 9.14286 4.42857C9.14286 5.05975 8.63118 5.57143 8 5.57143ZM8 13.7143C7.36882 13.7143 6.85714 13.2026 6.85714 12.5714V8C6.85714 7.36882 7.36882 6.85714 8 6.85714C8.63118 6.85714 9.14286 7.36882 9.14286 8V12.5714C9.14286 13.2026 8.63118 13.7143 8 13.7143Z" fill="#3399FF"/>
+</svg>
diff --git a/resources/Raw/Warning.svg b/resources/Raw/Warning.svg
new file mode 100644
index 00000000..449f7259
--- /dev/null
+++ b/resources/Raw/Warning.svg
@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M15.8143 13.5105L9.53088 0.943555C9.38818 0.659888 9.16947 0.421447 8.89915 0.254837C8.62883 0.0882269 8.31754 0 8 0C7.68246 0 7.37117 0.0882269 7.10085 0.254837C6.83053 0.421447 6.61182 0.659888 6.46912 0.943555L0.185669 13.5105C0.0528794 13.771 -0.0105702 14.0613 0.00143585 14.3534C0.0134419 14.6456 0.100499 14.9297 0.254216 15.1784C0.40999 15.4258 0.625686 15.6298 0.881315 15.7716C1.13694 15.9134 1.42423 15.9884 1.71655 15.9896H14.2835C14.5758 15.9884 14.8631 15.9134 15.1187 15.7716C15.3743 15.6298 15.59 15.4258 15.7458 15.1784C15.8995 14.9297 15.9866 14.6456 15.9986 14.3534C16.0106 14.0613 15.9471 13.771 15.8143 13.5105ZM7.14317 5.70756C7.14317 5.48031 7.23344 5.26237 7.39413 5.10168C7.55481 4.94099 7.77275 4.85072 8 4.85072C8.22725 4.85072 8.44519 4.94099 8.60587 5.10168C8.76656 5.26237 8.85683 5.48031 8.85683 5.70756V9.13489C8.85683 9.36214 8.76656 9.58008 8.60587 9.74077C8.44519 9.90145 8.22725 9.99173 8 9.99173C7.77275 9.99173 7.55481 9.90145 7.39413 9.74077C7.23344 9.58008 7.14317 9.36214 7.14317 9.13489V5.70756ZM8 13.7047C7.77405 13.7047 7.55317 13.6377 7.36529 13.5121C7.17742 13.3866 7.03099 13.2082 6.94452 12.9994C6.85805 12.7907 6.83542 12.561 6.87951 12.3394C6.92359 12.1177 7.0324 11.9142 7.19217 11.7544C7.35194 11.5946 7.55551 11.4858 7.77712 11.4417C7.99873 11.3977 8.22844 11.4203 8.43719 11.5068C8.64595 11.5932 8.82438 11.7396 8.94991 11.9275C9.07544 12.1154 9.14245 12.3363 9.14245 12.5622C9.14245 12.8652 9.02208 13.1558 8.80783 13.3701C8.59358 13.5843 8.303 13.7047 8 13.7047Z" fill="#FF9933"/>
+</svg>
diff --git a/resources/locked_by_other_inv.png b/resources/locked_by_other_inv.png
new file mode 100644
index 00000000..4e395cc2
Binary files /dev/null and b/resources/locked_by_other_inv.png differ
diff --git a/resources/locked_inv.png b/resources/locked_inv.png
new file mode 100644
index 00000000..5ccfa680
Binary files /dev/null and b/resources/locked_inv.png differ
diff --git a/resources/macOS/Icon_ANS.icns b/resources/macOS/Icon_ANS.icns
new file mode 100644
index 00000000..ca56037b
Binary files /dev/null and b/resources/macOS/Icon_ANS.icns differ
diff --git a/resources/macOS/Icon_AVE.icns b/resources/macOS/Icon_AVE.icns
new file mode 100644
index 00000000..f311e4d5
Binary files /dev/null and b/resources/macOS/Icon_AVE.icns differ
diff --git a/resources/macOS/Info.plist.in b/resources/macOS/Info.plist.in
index bf4cf297..29e4b8f3 100644
--- a/resources/macOS/Info.plist.in
+++ b/resources/macOS/Info.plist.in
@@ -30,8 +30,6 @@
 		<string>${CU_PROJECT_READABLE_COPYRIGHT}</string>
 		<key>NSHighResolutionCapable</key>
 		<true/>
-		<key>NSRequiresAquaSystemAppearance</key>
-		<true/>
 		<key>CSResourcesFileMapped</key>
 		<true/>
 		<key>CFBundleSignature</key>
@@ -40,5 +38,36 @@
 		<string>${MACOSX_BUNDLE_ICON_FILE}</string>
 		<key>SUPublicEDKey</key>
 		<string>${HIVE_DSA_PUB_KEY}</string>
+		<key>CFBundleDocumentTypes</key>
+		<array>
+			<dict>
+				<key>CFBundleTypeExtensions</key>
+				<array>
+					<string>ave</string>
+				</array>
+				<key>CFBundleTypeName</key>
+				<string>ATDECC Virtual Entity</string>
+				<key>CFBundleTypeRole</key>
+				<string>Editor</string>
+				<key>CFBundleTypeIconFile</key>
+				<string>Icon_AVE.icns</string>
+				<key>LSHandlerRank</key>
+				<string>Owner</string>
+			</dict>
+			<dict>
+				<key>CFBundleTypeExtensions</key>
+				<array>
+					<string>ans</string>
+				</array>
+				<key>CFBundleTypeName</key>
+				<string>ATDECC Network State</string>
+				<key>CFBundleTypeRole</key>
+				<string>Editor</string>
+				<key>CFBundleTypeIconFile</key>
+				<string>Icon_ANS.icns</string>
+				<key>LSHandlerRank</key>
+				<string>Owner</string>
+			</dict>
+		</array>
 	</dict>
 </plist>
diff --git a/resources/macOS/README.md b/resources/macOS/README.md
new file mode 100644
index 00000000..35279363
--- /dev/null
+++ b/resources/macOS/README.md
@@ -0,0 +1,3 @@
+### Example of how to generate the icon files
+- Get the PNG file of your icon (256 or 512)
+- Create the icns file using [image2icon by Shiny Frog](https://apps.apple.com/fr/app/image2icon/id992115977) or any other software
diff --git a/resources/main.qrc b/resources/main.qrc
index f7bccd2b..93a6eb0c 100644
--- a/resources/main.qrc
+++ b/resources/main.qrc
@@ -5,9 +5,13 @@
         <file>Logo.png</file>
         <file alias="CHANGELOG.md">../CHANGELOG.md</file>
         <file>locked.png</file>
+        <file>locked_inv.png</file>
         <file>unlocked.png</file>
         <file>locked_by_other.png</file>
+        <file>locked_by_other_inv.png</file>
         <file>lock_not_supported.png</file>
+        <file>unknown_light.png</file>
+        <file>unknown_dark.png</file>
         <file>Milan_Compatible.png</file>
         <file>Milan_Compatible_inv.png</file>
         <file>Milan_Certified.png</file>
diff --git a/resources/style.qss b/resources/style.qss
index 5ecb4551..b84710f2 100755
--- a/resources/style.qss
+++ b/resources/style.qss
@@ -1,24 +1,30 @@
 /*
-%1: base color backgound
-%2: base color foreground
-%3: connection matrix highlight color
+%1: theme color
+%2: theme foreground text color
+%3: connection matrix highlight color (central matrix, not header)
+%4: flat icon button color
+%5: theme complementary color
 */
 
 QWidget {
 	selection-background-color: %1;
 	selection-color: %2;
 }
-QAbstractItemView::item:selected {
+QComboBox QAbstractItemView::item:selected {
+	background-color: %1;
+	color: %2;
+}
+QTreeWidget::item:selected {
 	background-color: %1;
 	color: %2;
 }
 qtMate--widgets--FlatIconButton {
 	font-size: 24px;
 	border: none;
-	color: #3e3e3e;
+	color: %4;
 }
 qtMate--widgets--FlatIconButton:hover {
-	color: #262626;
+	color: %1;
 }
 qtMate--widgets--FlatIconButton:pressed {
 	margin: 2 0 0 2;
@@ -28,6 +34,27 @@ NodeTreeWidget .QListWidget {
 	margin-top: 4;
 	margin-bottom: 4;
 }
+NodeTreeWidget .QLabel {
+	margin-left: 0;
+	margin-right: 2;
+}
+QLabel#StreamConnectionLabel[isSelected=true] {
+	color: %2;
+}
+QLabel#EntityNameLabel {
+	color: grey;
+}
+QLabel#EntityNameLabel[isSelected=true] {
+	color: lightgrey;
+}
+QLabel#EntityNameLabel[isOnline=true] {
+	color: green;
+	font-weight: bold;
+}
+QLabel#EntityNameLabel[isOnline=true][isSelected=true] {
+	color: %5;
+	font-weight: bold;
+}
 QPushButton#DisconnectButton {
 	font-size: 14px;
 	color: #f44336;
@@ -36,14 +63,7 @@ QPushButton#DisconnectButton:disabled {
 	color: gray;
 }
 QPushButton#DisconnectButton:pressed {
-	color: black;
-}
-QLabel#EntityNameLabel {
-	color: grey;
-}
-QLabel#EntityNameLabel[isOnline=true] {
-	color: #4caf50;
-	font-weight: bold;
+	color: %5;
 }
 connectionMatrix--View {
 	selection-background-color: %3;
diff --git a/resources/unknown_dark.png b/resources/unknown_dark.png
new file mode 100644
index 00000000..889c3b46
Binary files /dev/null and b/resources/unknown_dark.png differ
diff --git a/resources/unknown_light.png b/resources/unknown_light.png
new file mode 100644
index 00000000..d8598e49
Binary files /dev/null and b/resources/unknown_light.png differ
diff --git a/resources/win32/Icon_ANS.ico b/resources/win32/Icon_ANS.ico
new file mode 100644
index 00000000..95f8655b
Binary files /dev/null and b/resources/win32/Icon_ANS.ico differ
diff --git a/resources/win32/Icon_AVE.ico b/resources/win32/Icon_AVE.ico
new file mode 100644
index 00000000..763ff8c7
Binary files /dev/null and b/resources/win32/Icon_AVE.ico differ
diff --git a/resources/win32/Info.rc.in b/resources/win32/Info.rc.in
index c1d46279..d058c96c 100644
--- a/resources/win32/Info.rc.in
+++ b/resources/win32/Info.rc.in
@@ -25,3 +25,5 @@ BEGIN
 END
 
 IDI_ICON1 ICON "${CU_ROOT_DIR}/resources/win32/Icon.ico"
+IDI_ICON2 ICON "${CU_ROOT_DIR}/resources/win32/Icon_AVE.ico"
+IDI_ICON3 ICON "${CU_ROOT_DIR}/resources/win32/Icon_ANS.ico"
diff --git a/resources/win32/README.md b/resources/win32/README.md
new file mode 100644
index 00000000..540eb919
--- /dev/null
+++ b/resources/win32/README.md
@@ -0,0 +1,4 @@
+### Example of how to generate the icon files
+- Get the PNG file of your icon (256 or 512)
+- Use Windows store [App Icon Generator](https://apps.microsoft.com/store/detail/app-icon-generator-icon-maker-studio/9NG751Z4T1ZG)
+- Create the ico file using [Online Icon Editor](https://redketchup.io/icon-editor)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index ece210c4..67878064 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -37,12 +37,20 @@ if(WIN32)
 	find_package(BugTrap REQUIRED)
 	set(BUGREPORTER_LINK_LIBRARIES "BugTrap")
 elseif(APPLE)
+	# Main icon
 	set(ICON_FILE Icon.icns)
 	set(ICON_PATH ${HIVE_RESOURCES_FOLDER}/macOS/${ICON_FILE})
 	set_source_files_properties(${ICON_PATH} PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
 	list(APPEND RESOURCE_FILES
 		${ICON_PATH}
 	)
+	# Add other icons
+	set_source_files_properties(${HIVE_RESOURCES_FOLDER}/macOS/Icon_AVE.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
+	set_source_files_properties(${HIVE_RESOURCES_FOLDER}/macOS/Icon_ANS.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
+	list(APPEND RESOURCE_FILES
+		${HIVE_RESOURCES_FOLDER}/macOS/Icon_AVE.icns
+		${HIVE_RESOURCES_FOLDER}/macOS/Icon_ANS.icns
+	)
 endif()
 
 set(HEADER_FILES_GENERATED
@@ -51,7 +59,6 @@ set(HEADER_FILES_GENERATED
 
 set(HEADER_FILES_COMMON
 	avdecc/mcDomainManager.hpp
-	avdecc/controllerModel.hpp
 	avdecc/channelConnectionManager.hpp
 	avdecc/helper.hpp
 	avdecc/mappingsHelper.hpp
@@ -59,6 +66,11 @@ set(HEADER_FILES_COMMON
 	avdecc/loggerModel.hpp
 	avdecc/commandChain.hpp
 	avdecc/stringValidator.hpp
+	connectionEditor/connectionEditor.hpp
+	connectionEditor/connectionWorkspace.hpp
+	connectionEditor/nodeListModel.hpp
+	connectionEditor/nodeListView.hpp
+	connectionEditor/nodeOrganizer.hpp
 	connectionMatrix/cornerWidget.hpp
 	connectionMatrix/headerView.hpp
 	connectionMatrix/itemDelegate.hpp
@@ -73,6 +85,7 @@ set(HEADER_FILES_COMMON
 	counters/streamInputCountersTreeWidgetItem.hpp
 	counters/streamOutputCountersTreeWidgetItem.hpp
 	discoveredEntities/view.hpp
+	diagnostics/controlDiagnosticsTreeWidgetItem.hpp
 	diagnostics/entityDiagnosticsTreeWidgetItem.hpp
 	diagnostics/streamInputDiagnosticsTreeWidgetItem.hpp
 	mediaClock/mediaClockManagementDialog.hpp
@@ -94,6 +107,7 @@ set(HEADER_FILES_COMMON
 	nodeTreeDynamicWidgets/streamDynamicTreeWidgetItem.hpp
 	nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.hpp
 	nodeTreeDynamicWidgets/asPathWidget.hpp
+	processHelper/processHelper.hpp
 	profiles/profiles.hpp
 	profiles/profileSelectionDialog.hpp
 	profiles/profileWidget.hpp
@@ -113,9 +127,11 @@ set(HEADER_FILES_COMMON
 	multiFirmwareUpdateDialog.hpp
 	mainWindow.hpp
 	aecpCommandComboBox.hpp
+	aecpCommandSlider.hpp
 	aecpCommandSpinBox.hpp
 	aecpCommandTextEntry.hpp
 	controlledEntityTreeWidget.hpp
+	controlledEntityTreeWidgetItemDelegate.hpp
 	entityInspector.hpp
 	mappingMatrix.hpp
 	activeNetworkInterfacesModel.hpp
@@ -125,17 +141,22 @@ set(HEADER_FILES_COMMON
 	windowsNpfHelper.hpp
 	streamFormatComboBox.hpp
 	visibilitySettings.hpp
-	listViewSelectionToMatrixModelController.hpp
+	listViewMatrixViewController.hpp
+	application.hpp
 )
 
 set(SOURCE_FILES_COMMON
 	avdecc/mcDomainManager.cpp
-	avdecc/controllerModel.cpp
 	avdecc/channelConnectionManager.cpp
 	avdecc/helper.cpp
 	avdecc/mappingsHelper.cpp
 	avdecc/loggerModel.cpp
 	avdecc/commandChain.cpp
+	connectionEditor/connectionEditor.cpp
+	connectionEditor/connectionWorkspace.cpp
+	connectionEditor/nodeListModel.cpp
+	connectionEditor/nodeListView.cpp
+	connectionEditor/nodeOrganizer.cpp
 	connectionMatrix/cornerWidget.cpp
 	connectionMatrix/legendDialog.cpp
 	connectionMatrix/headerView.cpp
@@ -150,6 +171,7 @@ set(SOURCE_FILES_COMMON
 	counters/streamInputCountersTreeWidgetItem.cpp
 	counters/streamOutputCountersTreeWidgetItem.cpp
 	discoveredEntities/view.cpp
+	diagnostics/controlDiagnosticsTreeWidgetItem.cpp
 	diagnostics/entityDiagnosticsTreeWidgetItem.cpp
 	diagnostics/streamInputDiagnosticsTreeWidgetItem.cpp
 	mediaClock/mediaClockManagementDialog.cpp
@@ -186,13 +208,16 @@ set(SOURCE_FILES_COMMON
 	mainWindow.cpp
 	settingsDialog.cpp
 	controlledEntityTreeWidget.cpp
+	controlledEntityTreeWidgetItemDelegate.cpp
 	entityInspector.cpp
+	mappingMatrix.cpp
 	activeNetworkInterfacesModel.cpp
 	networkInterfaceTypeModel.cpp
 	nodeTreeWidget.cpp
 	nodeVisitor.cpp
 	windowsNpfHelper.cpp
-	listViewSelectionToMatrixModelController.cpp
+	listViewMatrixViewController.cpp
+	application.cpp
 )
 
 set(UI_FILES_COMMON
@@ -212,17 +237,30 @@ set(SOURCE_FILES_APP
 	main.cpp
 )
 
+# OS-specific files and options
+set(OSDEP_SOURCE_FILES "")
+if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" OR CMAKE_SYSTEM_NAME STREQUAL "iOS")
+	list(APPEND OSDEP_SOURCE_FILES processHelper/processHelper_macos.mm)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+	list(APPEND OSDEP_SOURCE_FILES processHelper/processHelper_win32.cpp)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Android" OR CMAKE_SYSTEM_NAME STREQUAL "Linux")
+	list(APPEND OSDEP_SOURCE_FILES processHelper/processHelper_unix.cpp)
+else()
+	message(FATAL_ERROR "Unsupported system: ${CMAKE_SYSTEM_NAME}")
+endif()
+
 # Group source files
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "Header Files" FILES ${HEADER_FILES_COMMON})
 source_group("Header Files\\\\Generated" FILES ${HEADER_FILES_GENERATED})
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "Source Files" FILES ${SOURCE_FILES_COMMON} ${SOURCE_FILES_APP})
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "Source Files\\OS-Dep Files" FILES ${OSDEP_SOURCE_FILES})
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "UI Files" FILES ${UI_FILES_COMMON})
 source_group(TREE ${HIVE_RESOURCES_FOLDER} PREFIX "Resource Files" FILES ${RESOURCE_FILES})
 source_group("Resource Files\\\\Generated" FILES ${RESOURCE_FILES_GENERATED})
 source_group("Configure Input Files" FILES ${CONFIGURE_IN_FILES})
 
 # Define static library to be used by main application and unit tests
-add_library(${PROJECT_NAME}_static STATIC ${HEADER_FILES_COMMON} ${HEADER_FILES_GENERATED} ${SOURCE_FILES_COMMON} ${UI_FILES_COMMON} ${CONFIGURE_IN_FILES})
+add_library(${PROJECT_NAME}_static STATIC ${HEADER_FILES_COMMON} ${HEADER_FILES_GENERATED} ${SOURCE_FILES_COMMON} ${OSDEP_SOURCE_FILES} ${UI_FILES_COMMON} ${CONFIGURE_IN_FILES})
 
 # Setup common options
 cu_setup_library_options(${PROJECT_NAME}_static)
diff --git a/src/aecpCommandSlider.hpp b/src/aecpCommandSlider.hpp
new file mode 100644
index 00000000..dfbfbe5b
--- /dev/null
+++ b/src/aecpCommandSlider.hpp
@@ -0,0 +1,127 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <hive/modelsLibrary/controllerManager.hpp>
+
+#include <QSlider>
+#include <QString>
+
+#include <functional>
+#include <vector>
+#include <set>
+#include <string>
+
+template<typename DataType>
+class AecpCommandSlider : public QSlider
+{
+public:
+	using DataChangedHandler = std::function<void(DataType const& previousData, DataType const& newData)>;
+	using Data = std::set<DataType>;
+	using AecpBeginCommandHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID)>;
+	using AecpResultHandler = std::function<void(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)>;
+
+	static_assert(std::is_integral_v<DataType> && sizeof(DataType) <= 4, "AecpCommandSlider only support integral types up to 32 bits");
+
+	AecpCommandSlider(QWidget* parent = nullptr)
+		: QSlider{ Qt::Horizontal, parent }
+		, _parent{ parent }
+	{
+		// Send changes
+		connect(this, QOverload<int>::of(&QSlider::valueChanged), this,
+			[this](int value)
+			{
+				auto newData = static_cast<DataType>(value);
+				// Save previous data before it's changed
+				auto const previous = _previousData;
+				// Update to new data
+				setCurrentData(newData);
+				// If new data is different than previous one, call handler
+				if (previous != newData)
+				{
+					if (_dataChangedHandler)
+					{
+						_dataChangedHandler(previous, newData);
+					}
+				}
+			});
+	}
+
+	void setDataChangedHandler(DataChangedHandler const& handler) noexcept
+	{
+		_dataChangedHandler = handler;
+	}
+
+	virtual void setCurrentData(DataType const& data) noexcept
+	{
+		auto const lg = QSignalBlocker{ this }; // Block internal signals
+		_previousData = data;
+		setValue(static_cast<int>(data));
+	}
+
+	void setRangeAndStep(DataType const minimum, DataType const maximum, std::uint32_t const step) noexcept
+	{
+		auto const lg = QSignalBlocker{ this }; // Block internal signals
+		setRange(static_cast<int>(minimum), static_cast<int>(maximum));
+		setSingleStep(static_cast<int>(step));
+	}
+
+	DataType const& getCurrentData() const noexcept
+	{
+		return _previousData;
+	}
+
+	AecpBeginCommandHandler getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType const commandType) noexcept
+	{
+		return [this](la::avdecc::UniqueIdentifier const entityID)
+		{
+			setEnabled(false);
+		};
+	}
+
+	AecpResultHandler getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType const commandType, DataType const& previousData) noexcept
+	{
+		return [this, commandType, previousData](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)
+		{
+			QMetaObject::invokeMethod(this,
+				[this, commandType, previousData, status]()
+				{
+					if (status != la::avdecc::entity::ControllerEntity::AemCommandStatus::Success)
+					{
+						setCurrentData(previousData);
+
+						QMessageBox::warning(_parent, "", "<i>" + hive::modelsLibrary::ControllerManager::typeToString(commandType) + "</i> failed:<br>" + QString::fromStdString(la::avdecc::entity::ControllerEntity::statusToString(status)));
+					}
+					setEnabled(true);
+				});
+		};
+	}
+
+protected:
+	using QSlider::setMinimum;
+	using QSlider::setMaximum;
+	using QSlider::setRange;
+	using QSlider::setSingleStep;
+	using QSlider::valueChanged;
+	QWidget* _parent{ nullptr };
+	Data _data{};
+	DataType _previousData{};
+	DataChangedHandler _dataChangedHandler{};
+};
diff --git a/src/application.cpp b/src/application.cpp
new file mode 100644
index 00000000..15f74f37
--- /dev/null
+++ b/src/application.cpp
@@ -0,0 +1,115 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "application.hpp"
+
+#include <QGuiApplication>
+#include <QStyleHints>
+#include <QStyle>
+#include <QFileOpenEvent>
+
+HiveApplication::HiveApplication(int& argc, char** argv)
+	: QApplication(argc, argv)
+{
+	// Get the current style (before a stylesheet is applied, which will cause the name to be lost)
+	if (auto const* const style = QApplication::style(); style)
+	{
+		auto const styleName = style->name();
+		checkStyleName(styleName);
+	}
+
+	// Set color scheme based on the current system color scheme
+	setIsDarkColorScheme(QGuiApplication::styleHints()->colorScheme() == Qt::ColorScheme::Dark);
+
+	// Color Scheme changed
+	connect(QGuiApplication::styleHints(), &QStyleHints::colorSchemeChanged, this,
+		[this](Qt::ColorScheme scheme)
+		{
+			setIsDarkColorScheme(scheme == Qt::ColorScheme::Dark);
+		});
+
+	// Install the event filter to catch macOS FileOpen events
+	installEventFilter(this);
+
+	// Process the events immediately so we can catch the FileOpen event before the MainWindow is created
+	processEvents();
+
+	// Remove the event filter, the main window will install its own
+	removeEventFilter(this);
+}
+
+void HiveApplication::addFileToLoad(QString const& filePath)
+{
+	_filesToLoad.append(filePath);
+}
+
+QStringList const& HiveApplication::getFilesToLoad() const
+{
+	return _filesToLoad;
+}
+
+bool HiveApplication::isDarkColorScheme() const noexcept
+{
+	return _isDarkColorScheme;
+}
+
+bool HiveApplication::isDarkPaletteSupported() const noexcept
+{
+	return _isDarkPaletteSupported;
+}
+
+void HiveApplication::setStyleName(QString const& styleName) noexcept
+{
+	checkStyleName(styleName);
+	setIsDarkColorScheme(QGuiApplication::styleHints()->colorScheme() == Qt::ColorScheme::Dark);
+	setStyle(styleName);
+}
+
+bool HiveApplication::eventFilter(QObject* watched, QEvent* event)
+{
+	if (event->type() == QEvent::FileOpen)
+	{
+		auto const* const fileEvent = static_cast<QFileOpenEvent const*>(event);
+		addFileToLoad(fileEvent->file());
+		return true;
+	}
+	return false;
+}
+
+void HiveApplication::setIsDarkColorScheme(bool const isDarkColorScheme)
+{
+	if (_isDarkPaletteSupported)
+	{
+		_isDarkColorScheme = isDarkColorScheme;
+	}
+	else
+	{
+		_isDarkColorScheme = false;
+	}
+	setProperty("isDarkColorScheme", _isDarkColorScheme);
+}
+
+void HiveApplication::checkStyleName(QString const& styleName) noexcept
+{
+	_isDarkPaletteSupported = true;
+	if (styleName == "windowsvista")
+	{
+		_isDarkPaletteSupported = false;
+	}
+}
diff --git a/src/application.hpp b/src/application.hpp
new file mode 100644
index 00000000..82f32bf6
--- /dev/null
+++ b/src/application.hpp
@@ -0,0 +1,51 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QApplication>
+
+class HiveApplication : public QApplication
+{
+public:
+	HiveApplication(int& argc, char** argv);
+
+	void addFileToLoad(QString const& filePath);
+
+	QStringList const& getFilesToLoad() const;
+
+	bool isDarkColorScheme() const noexcept;
+
+	bool isDarkPaletteSupported() const noexcept;
+
+	void setStyleName(QString const& styleName) noexcept;
+
+private:
+	// QObject overrides
+	bool eventFilter(QObject* watched, QEvent* event) override;
+
+	// Private methods
+	void setIsDarkColorScheme(bool const isDarkColorScheme);
+	void checkStyleName(QString const& styleName) noexcept;
+
+	// Private members
+	QStringList _filesToLoad{};
+	bool _isDarkColorScheme{ false };
+	bool _isDarkPaletteSupported{ true };
+};
diff --git a/src/avdecc/channelConnectionManager.cpp b/src/avdecc/channelConnectionManager.cpp
index 68718435..140386c9 100644
--- a/src/avdecc/channelConnectionManager.cpp
+++ b/src/avdecc/channelConnectionManager.cpp
@@ -198,7 +198,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			{
 				for (auto const& redundantStreamOutput : configNode.redundantStreamOutputs)
 				{
-					if (redundantStreamOutput.second.primaryStream->descriptorIndex == streamIdentification.streamIndex)
+					if (redundantStreamOutput.second.primaryStreamIndex == streamIdentification.streamIndex)
 					{
 						return true;
 					}
@@ -228,7 +228,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			{
 				for (auto const& redundantStreamInput : configNode.redundantStreamInputs)
 				{
-					if (redundantStreamInput.second.primaryStream->descriptorIndex == streamIdentification.streamIndex)
+					if (redundantStreamInput.second.primaryStreamIndex == streamIdentification.streamIndex)
 					{
 						return true;
 					}
@@ -259,7 +259,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 				{
 					for (auto const& [virtualIndex, redundantStreamNode] : configNode.redundantStreamInputs)
 					{
-						for (auto const& [streamIndex, streamNode] : redundantStreamNode.redundantStreams)
+						for (auto const streamIndex : redundantStreamNode.redundantStreams)
 						{
 							if (streamIndex == streamIdentification.streamIndex)
 							{
@@ -299,7 +299,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 				{
 					for (auto const& [virtualIndex, redundantStreamNode] : configNode.redundantStreamOutputs)
 					{
-						for (auto const& [streamIndex, streamNode] : redundantStreamNode.redundantStreams)
+						for (auto const streamIndex : redundantStreamNode.redundantStreams)
 						{
 							if (streamIndex == streamIdentification.streamIndex)
 							{
@@ -326,7 +326,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			try
 			{
-				return controlledEntity->getRedundantStreamOutputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, virtualIndex).primaryStream->descriptorIndex;
+				return controlledEntity->getRedundantStreamOutputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, virtualIndex).primaryStreamIndex;
 			}
 			catch (la::avdecc::controller::ControlledEntity::Exception const&)
 			{
@@ -343,7 +343,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			try
 			{
-				return controlledEntity->getRedundantStreamInputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, virtualIndex).primaryStream->descriptorIndex;
+				return controlledEntity->getRedundantStreamInputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, virtualIndex).primaryStreamIndex;
 			}
 			catch (la::avdecc::controller::ControlledEntity::Exception const&)
 			{
@@ -364,15 +364,15 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			try
 			{
-				auto redundantStreamOutputNode = controlledTalkerEntity->getRedundantStreamOutputNode(controlledTalkerEntity->getCurrentConfigurationNode().descriptorIndex, talkerStreamVirtualIndex);
-				auto redundantStreamInputNode = controlledListenerEntity->getRedundantStreamInputNode(controlledTalkerEntity->getCurrentConfigurationNode().descriptorIndex, listenerStreamVirtualIndex);
+				auto const& redundantStreamOutputNode = controlledTalkerEntity->getRedundantStreamOutputNode(controlledTalkerEntity->getCurrentConfigurationNode().descriptorIndex, talkerStreamVirtualIndex);
+				auto const& redundantStreamInputNode = controlledListenerEntity->getRedundantStreamInputNode(controlledTalkerEntity->getCurrentConfigurationNode().descriptorIndex, listenerStreamVirtualIndex);
 
 				auto redundantStreamOutputsIt = redundantStreamOutputNode.redundantStreams.begin();
 				auto redundantStreamInputsIt = redundantStreamInputNode.redundantStreams.begin();
 
 				while (redundantStreamOutputsIt != redundantStreamOutputNode.redundantStreams.end() && redundantStreamInputsIt != redundantStreamInputNode.redundantStreams.end())
 				{
-					result.push_back(std::make_pair(redundantStreamOutputsIt->first, redundantStreamInputsIt->first));
+					result.push_back(std::make_pair(*redundantStreamOutputsIt, *redundantStreamInputsIt));
 
 
 					redundantStreamOutputsIt++;
@@ -397,11 +397,11 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			try
 			{
-				auto redundantStreamOutputNode = controlledTalkerEntity->getRedundantStreamOutputNode(controlledTalkerEntity->getCurrentConfigurationNode().descriptorIndex, talkerStreamVirtualIndex);
+				auto const& redundantStreamOutputNode = controlledTalkerEntity->getRedundantStreamOutputNode(controlledTalkerEntity->getCurrentConfigurationNode().descriptorIndex, talkerStreamVirtualIndex);
 				auto const& redundantOutputStreamsIt = redundantStreamOutputNode.redundantStreams.find(primaryTalkerStreamIndex);
-				if (redundantOutputStreamsIt != redundantStreamOutputNode.redundantStreams.end() && redundantOutputStreamsIt->second->staticModel->redundantStreams.size() > 0)
+				if (redundantOutputStreamsIt != redundantStreamOutputNode.redundantStreams.end())
 				{
-					result = std::make_pair(listenerStreamIndex, *redundantOutputStreamsIt->second->staticModel->redundantStreams.begin());
+					result = std::make_pair(listenerStreamIndex, *redundantOutputStreamsIt);
 				}
 			}
 			catch (la::avdecc::controller::ControlledEntity::Exception const&)
@@ -422,11 +422,11 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			try
 			{
-				auto redundantStreamInputNode = controlledListenerEntity->getRedundantStreamInputNode(controlledListenerEntity->getCurrentConfigurationNode().descriptorIndex, listenerStreamVirtualIndex);
+				auto const& redundantStreamInputNode = controlledListenerEntity->getRedundantStreamInputNode(controlledListenerEntity->getCurrentConfigurationNode().descriptorIndex, listenerStreamVirtualIndex);
 				auto const& redundantInputStreamsIt = redundantStreamInputNode.redundantStreams.find(primaryListenerStreamIndex);
-				if (redundantInputStreamsIt != redundantStreamInputNode.redundantStreams.end() && redundantInputStreamsIt->second->staticModel->redundantStreams.size() > 0)
+				if (redundantInputStreamsIt != redundantStreamInputNode.redundantStreams.end())
 				{
-					result = std::make_pair(talkerStreamIndex, *redundantInputStreamsIt->second->staticModel->redundantStreams.begin());
+					result = std::make_pair(talkerStreamIndex, *redundantInputStreamsIt);
 				}
 			}
 			catch (la::avdecc::controller::ControlledEntity::Exception const&)
@@ -456,13 +456,10 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 				auto const& configNode = controlledEntity->getCurrentConfigurationNode();
 				for (auto const& [streamIndex, streamInputNode] : configNode.streamInputs)
 				{
-					auto* streamInputDynamicModel = streamInputNode.dynamicModel;
-					if (streamInputDynamicModel)
+					auto& streamInputDynamicModel = streamInputNode.dynamicModel;
+					if (streamInputDynamicModel.connectionInfo.talkerStream.entityID == talkerEntityId)
 					{
-						if (streamInputDynamicModel->connectionInfo.talkerStream.entityID == talkerEntityId)
-						{
-							disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel->connectionInfo });
-						}
+						disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel.connectionInfo });
 					}
 				}
 			}
@@ -481,24 +478,18 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 				if (controlledEntity->getEntity().getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported) && controlledEntity->hasAnyConfiguration())
 				{
 					auto const& entityNode = controlledEntity->getEntityNode();
-					if (entityNode.dynamicModel)
-					{
-						auto const& configurationNode = controlledEntity->getConfigurationNode(entityNode.dynamicModel->currentConfiguration);
+					auto const& configurationNode = controlledEntity->getConfigurationNode(entityNode.dynamicModel.currentConfiguration);
 
-						for (auto const& audioUnitKV : configurationNode.audioUnits)
+					for (auto const& audioUnitKV : configurationNode.audioUnits)
+					{
+						for (auto const& streamPortInputKV : audioUnitKV.second.streamPortInputs)
 						{
-							for (auto const& streamPortInputKV : audioUnitKV.second.streamPortInputs)
+							auto const& listenerMappings = streamPortInputKV.second.dynamicModel.dynamicAudioMap;
+							for (auto const& listenerMapping : listenerMappings)
 							{
-								if (streamPortInputKV.second.dynamicModel)
+								if (listenerMapping.streamIndex == streamIndex && listenerMapping.streamChannel == streamChannel)
 								{
-									auto const& listenerMappings = streamPortInputKV.second.dynamicModel->dynamicAudioMap;
-									for (auto const& listenerMapping : listenerMappings)
-									{
-										if (listenerMapping.streamIndex == streamIndex && listenerMapping.streamChannel == streamChannel)
-										{
-											return std::make_pair(listenerMapping.clusterOffset, listenerMapping.clusterChannel);
-										}
-									}
+									return std::make_pair(listenerMapping.clusterOffset, listenerMapping.clusterChannel);
 								}
 							}
 						}
@@ -520,9 +511,9 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		auto redundantToPrimListenerStreamMap = std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::entity::model::StreamIndex>{}; // map of redundant stream to its associated primary stream
 		for (auto const& redundantStreamInput : targetConfigurationNode.redundantStreamInputs)
 		{
-			auto primaryStreamIndex = redundantStreamInput.second.primaryStream->descriptorIndex;
+			auto primaryStreamIndex = redundantStreamInput.second.primaryStreamIndex;
 			auto redundantStreams = std::vector<la::avdecc::entity::model::StreamIndex>{};
-			for (auto const& [redundantStreamIndex, redundantStream] : redundantStreamInput.second.redundantStreams)
+			for (auto const redundantStreamIndex : redundantStreamInput.second.redundantStreams)
 			{
 				if (redundantStreamIndex != primaryStreamIndex)
 				{
@@ -580,7 +571,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return result;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ configurationIndex };
 		try
 		{
 			configurationNode = controlledEntity->getConfigurationNode(configurationIndex);
@@ -596,16 +587,13 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		try
 		{
 			auto const& streamPortOutputNode = controlledEntity->getStreamPortOutputNode(configurationIndex, streamPortIndex);
-			auto const* const streamPortOutputDynamicModel = streamPortOutputNode.dynamicModel;
-			if (streamPortOutputDynamicModel)
-			{
-				mappings = streamPortOutputDynamicModel->dynamicAudioMap;
-			}
+			auto const& streamPortOutputDynamicModel = streamPortOutputNode.dynamicModel;
+			mappings = streamPortOutputDynamicModel.dynamicAudioMap;
 
 			// add the static mappings
 			for (auto const& audioMap : streamPortOutputNode.audioMaps)
 			{
-				mappings.insert(mappings.end(), audioMap.second.staticModel->mappings.begin(), audioMap.second.staticModel->mappings.end());
+				mappings.insert(mappings.end(), audioMap.second.staticModel.mappings.begin(), audioMap.second.staticModel.mappings.end());
 			}
 		}
 		catch (la::avdecc::controller::ControlledEntity::Exception const&)
@@ -655,162 +643,151 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 					}
 
 					auto const& targetEntityNode = targetControlledEntity->getEntityNode();
-					if (targetEntityNode.dynamicModel)
-					{
-						auto const& targetConfigurationNode = targetControlledEntity->getConfigurationNode(targetEntityNode.dynamicModel->currentConfiguration);
+					auto const& targetConfigurationNode = targetControlledEntity->getConfigurationNode(targetEntityNode.dynamicModel.currentConfiguration);
 
-						// Now collect all streams of the listener entity that was found to be connected to the sourceEntityId that is underinvestigation in this method
-						// This is done in a pair of maps - one (primary:multiRedundant) for all indices and a second map with the reverse information on which redundant stream belongs to which primary stream
-						auto const primToRedListenerStreamsRelationMaps = createPrimToRedListenerStreamsRelationMaps(targetConfigurationNode);
+					// Now collect all streams of the listener entity that was found to be connected to the sourceEntityId that is underinvestigation in this method
+					// This is done in a pair of maps - one (primary:multiRedundant) for all indices and a second map with the reverse information on which redundant stream belongs to which primary stream
+					auto const primToRedListenerStreamsRelationMaps = createPrimToRedListenerStreamsRelationMaps(targetConfigurationNode);
 
-						// find correct index of audio unit and stream port index:
-						for (auto const& listenerAudioUnitKV : targetConfigurationNode.audioUnits)
+					// find correct index of audio unit and stream port index:
+					for (auto const& listenerAudioUnitKV : targetConfigurationNode.audioUnits)
+					{
+						for (auto const& streamPortInputKV : listenerAudioUnitKV.second.streamPortInputs)
 						{
-							for (auto const& streamPortInputKV : listenerAudioUnitKV.second.streamPortInputs)
+							auto const& listenerMappings = streamPortInputKV.second.dynamicModel.dynamicAudioMap;
+							for (auto const& listenerMapping : listenerMappings)
 							{
-								if (streamPortInputKV.second.dynamicModel)
+								auto listenerClusterChannel = std::make_tuple(listenerStream.entityID, listenerMapping.clusterOffset, listenerMapping.clusterChannel);
+								if (processedListenerChannels.find(listenerClusterChannel) != processedListenerChannels.end())
+								{
+									continue;
+								}
+
+								try
 								{
-									auto const& listenerMappings = streamPortInputKV.second.dynamicModel->dynamicAudioMap;
-									for (auto const& listenerMapping : listenerMappings)
+									// the source stream channel is connected to the corresponding target stream channel.
+									if (listenerMapping.streamIndex == listenerStream.streamIndex && listenerMapping.streamChannel == sourceStreamChannel)
 									{
-										auto listenerClusterChannel = std::make_tuple(listenerStream.entityID, listenerMapping.clusterOffset, listenerMapping.clusterChannel);
-										if (processedListenerChannels.find(listenerClusterChannel) != processedListenerChannels.end())
+										auto const& primToRedundantListenerStreamsMap = primToRedListenerStreamsRelationMaps.first; // first pair element is the previously created primary:multiRedundant listener streams map
+										auto const& redundantToPrimListenerStreamMap = primToRedListenerStreamsRelationMaps.second; // second pair ele
+
+										auto connectionInformation = std::make_shared<TargetConnectionInformation>();
+
+										connectionInformation->sourceVirtualIndex = getRedundantVirtualIndexFromOutputStreamIndex(streamConnectionInfo.talkerStream);
+										connectionInformation->targetVirtualIndex = getRedundantVirtualIndexFromInputStreamIndex(listenerStream);
+
+										auto primaryListenerStreamIndex{ 0u };
+										auto primaryTalkerStreamIndex{ 0u };
+										auto primaryListenerStreamIndexIt = primToRedundantListenerStreamsMap.find(listenerMapping.streamIndex);
+										if (primaryListenerStreamIndexIt != primToRedundantListenerStreamsMap.end())
 										{
-											continue;
+											// If the listenerMapping's streamIndex is found in the keys of the map of primary listener streams,
+											// we have completed the info on established primary stream connection
+											primaryListenerStreamIndex = primaryListenerStreamIndexIt->first;
+											primaryTalkerStreamIndex = streamConnectionInfo.talkerStream.streamIndex;
 										}
-
-										try
+										else
 										{
-											// the source stream channel is connected to the corresponding target stream channel.
-											if (listenerMapping.streamIndex == listenerStream.streamIndex && listenerMapping.streamChannel == sourceStreamChannel)
+											// If the listenerMapping's streamIndex is not found in the primarys, we try to find it in the reverse redundant->primary map
+											auto streamIndex = redundantToPrimListenerStreamMap.find(listenerMapping.streamIndex);
+											if (!connectionInformation->sourceVirtualIndex)
 											{
-												auto const& primToRedundantListenerStreamsMap = primToRedListenerStreamsRelationMaps.first; // first pair element is the previously created primary:multiRedundant listener streams map
-												auto const& redundantToPrimListenerStreamMap = primToRedListenerStreamsRelationMaps.second; // second pair ele
-
-												auto connectionInformation = std::make_shared<TargetConnectionInformation>();
-
-												connectionInformation->sourceVirtualIndex = getRedundantVirtualIndexFromOutputStreamIndex(streamConnectionInfo.talkerStream);
-												connectionInformation->targetVirtualIndex = getRedundantVirtualIndexFromInputStreamIndex(listenerStream);
-
-												auto primaryListenerStreamIndex{ 0u };
-												auto primaryTalkerStreamIndex{ 0u };
-												auto primaryListenerStreamIndexIt = primToRedundantListenerStreamsMap.find(listenerMapping.streamIndex);
-												if (primaryListenerStreamIndexIt != primToRedundantListenerStreamsMap.end())
-												{
-													// If the listenerMapping's streamIndex is found in the keys of the map of primary listener streams,
-													// we have completed the info on established primary stream connection
-													primaryListenerStreamIndex = primaryListenerStreamIndexIt->first;
-													primaryTalkerStreamIndex = streamConnectionInfo.talkerStream.streamIndex;
-												}
-												else
-												{
-													// If the listenerMapping's streamIndex is not found in the primarys, we try to find it in the reverse redundant->primary map
-													auto streamIndex = redundantToPrimListenerStreamMap.find(listenerMapping.streamIndex);
-													if (!connectionInformation->sourceVirtualIndex)
-													{
-														continue;
-													}
-													else if (streamIndex != redundantToPrimListenerStreamMap.end())
-													{
-														// if we land in here the primary is not connected, but a secondary is.
-														primaryListenerStreamIndex = streamIndex->second;
-														primaryTalkerStreamIndex = controlledEntity->getRedundantStreamOutputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, *connectionInformation->sourceVirtualIndex).primaryStream->descriptorIndex;
-													}
-												}
-
-												// fill in the basics of the connection
-												connectionInformation->targetEntityId = listenerStream.entityID;
-												connectionInformation->streamChannel = sourceStreamChannel;
-												connectionInformation->sourceStreamIndex = primaryTalkerStreamIndex;
-												connectionInformation->targetStreamIndex = primaryListenerStreamIndex;
-
-												connectionInformation->targetClusterChannels.push_back(std::make_pair(listenerMapping.clusterOffset, listenerMapping.clusterChannel));
-												connectionInformation->targetAudioUnitIndex = listenerAudioUnitKV.first;
-												if (streamPortInputKV.second.staticModel)
-												{
-													connectionInformation->targetBaseCluster = streamPortInputKV.second.staticModel->baseCluster;
-												}
-												connectionInformation->targetStreamPortIndex = streamPortInputKV.first;
-												connectionInformation->isSourceRedundant = controlledEntity->getStreamOutputNode(configurationNode.descriptorIndex, sourceStream).isRedundant;
-												connectionInformation->isTargetRedundant = targetControlledEntity->getStreamInputNode(targetConfigurationNode.descriptorIndex, listenerMapping.streamIndex).isRedundant;
-
-												// prevent doubled entries for redundant connected streams
-												processedListenerChannels.insert(listenerClusterChannel);
-
-												if (connectionInformation->sourceVirtualIndex && connectionInformation->targetVirtualIndex)
-												{
-													// both redundant
-													connectionInformation->streamPairs = getRedundantStreamIndexPairs(listenerStream.entityID, *connectionInformation->sourceVirtualIndex, connectionInformation->targetEntityId, *connectionInformation->targetVirtualIndex);
-
-													// add connection to the result data
-													result->targets.push_back(connectionInformation);
-												}
-												else
-												{
-													connectionInformation->streamPairs = { std::make_pair(connectionInformation->sourceStreamIndex, connectionInformation->targetStreamIndex) };
-
-													// add connection to the result data
-													result->targets.push_back(connectionInformation);
-
-													if (connectionInformation->sourceVirtualIndex)
-													{
-														// only talker redundant - add a second connection redundantTalker->Listener to reflect that
-														auto redundantTalkerStreamPair = getRedundantTalkerStreamIndexPair(listenerStream.entityID, connectionInformation->sourceStreamIndex, *connectionInformation->sourceVirtualIndex, connectionInformation->targetEntityId, connectionInformation->targetStreamIndex);
-
-														auto secondConnectionInformation = std::make_shared<TargetConnectionInformation>();
-														secondConnectionInformation->targetEntityId = listenerStream.entityID;
-														secondConnectionInformation->streamChannel = sourceStreamChannel;
-														secondConnectionInformation->sourceStreamIndex = redundantTalkerStreamPair.first;
-														secondConnectionInformation->targetStreamIndex = redundantTalkerStreamPair.second;
-														secondConnectionInformation->streamPairs = { redundantTalkerStreamPair };
-
-														auto targetClusterChannel = getListenerClusterChannelForStreamChannel(secondConnectionInformation->targetEntityId, secondConnectionInformation->targetStreamIndex, secondConnectionInformation->streamChannel);
-														secondConnectionInformation->targetClusterChannels.push_back(targetClusterChannel);
-														secondConnectionInformation->targetAudioUnitIndex = listenerAudioUnitKV.first;
-														if (streamPortInputKV.second.staticModel)
-															secondConnectionInformation->targetBaseCluster = streamPortInputKV.second.staticModel->baseCluster;
-														secondConnectionInformation->targetStreamPortIndex = streamPortInputKV.first;
-														secondConnectionInformation->isSourceRedundant = controlledEntity->getStreamOutputNode(configurationNode.descriptorIndex, sourceStream).isRedundant;
-														secondConnectionInformation->isTargetRedundant = targetControlledEntity->getStreamInputNode(targetConfigurationNode.descriptorIndex, listenerMapping.streamIndex).isRedundant;
-
-														// add second connection to the result data
-														if (!secondConnectionInformation->isEqualTo(*connectionInformation))
-															result->targets.push_back(secondConnectionInformation);
-													}
-													else if (connectionInformation->targetVirtualIndex)
-													{
-														// only listener redundant - add a second connection Talker->redundantListener to reflect that
-														auto redundantListenerStreamPair = getRedundantListenerStreamIndexPair(listenerStream.entityID, connectionInformation->sourceStreamIndex, connectionInformation->targetEntityId, connectionInformation->targetStreamIndex, *connectionInformation->targetVirtualIndex);
-
-														auto secondConnectionInformation = std::make_shared<TargetConnectionInformation>();
-														secondConnectionInformation->targetEntityId = listenerStream.entityID;
-														secondConnectionInformation->streamChannel = sourceStreamChannel;
-														secondConnectionInformation->sourceStreamIndex = redundantListenerStreamPair.first;
-														secondConnectionInformation->targetStreamIndex = redundantListenerStreamPair.second;
-														secondConnectionInformation->streamPairs = { redundantListenerStreamPair };
-
-														auto targetClusterChannel = getListenerClusterChannelForStreamChannel(secondConnectionInformation->targetEntityId, secondConnectionInformation->targetStreamIndex, secondConnectionInformation->streamChannel);
-														secondConnectionInformation->targetClusterChannels.push_back(targetClusterChannel);
-														secondConnectionInformation->targetAudioUnitIndex = listenerAudioUnitKV.first;
-														if (streamPortInputKV.second.staticModel)
-															secondConnectionInformation->targetBaseCluster = streamPortInputKV.second.staticModel->baseCluster;
-														secondConnectionInformation->targetStreamPortIndex = streamPortInputKV.first;
-														secondConnectionInformation->isSourceRedundant = controlledEntity->getStreamOutputNode(configurationNode.descriptorIndex, sourceStream).isRedundant;
-														secondConnectionInformation->isTargetRedundant = targetControlledEntity->getStreamInputNode(targetConfigurationNode.descriptorIndex, listenerMapping.streamIndex).isRedundant;
-
-														// add second connection to the result data
-														if (!secondConnectionInformation->isEqualTo(*connectionInformation))
-															result->targets.push_back(secondConnectionInformation);
-													}
-												}
+												continue;
+											}
+											else if (streamIndex != redundantToPrimListenerStreamMap.end())
+											{
+												// if we land in here the primary is not connected, but a secondary is.
+												primaryListenerStreamIndex = streamIndex->second;
+												primaryTalkerStreamIndex = controlledEntity->getRedundantStreamOutputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, *connectionInformation->sourceVirtualIndex).primaryStreamIndex;
 											}
 										}
-										catch (la::avdecc::controller::ControlledEntity::Exception const& e)
+
+										// fill in the basics of the connection
+										connectionInformation->targetEntityId = listenerStream.entityID;
+										connectionInformation->streamChannel = sourceStreamChannel;
+										connectionInformation->sourceStreamIndex = primaryTalkerStreamIndex;
+										connectionInformation->targetStreamIndex = primaryListenerStreamIndex;
+
+										connectionInformation->targetClusterChannels.push_back(std::make_pair(listenerMapping.clusterOffset, listenerMapping.clusterChannel));
+										connectionInformation->targetAudioUnitIndex = listenerAudioUnitKV.first;
+										connectionInformation->targetBaseCluster = streamPortInputKV.second.staticModel.baseCluster;
+										connectionInformation->targetStreamPortIndex = streamPortInputKV.first;
+										connectionInformation->isSourceRedundant = controlledEntity->getStreamOutputNode(configurationNode.descriptorIndex, sourceStream).isRedundant;
+										connectionInformation->isTargetRedundant = targetControlledEntity->getStreamInputNode(targetConfigurationNode.descriptorIndex, listenerMapping.streamIndex).isRedundant;
+
+										// prevent doubled entries for redundant connected streams
+										processedListenerChannels.insert(listenerClusterChannel);
+
+										if (connectionInformation->sourceVirtualIndex && connectionInformation->targetVirtualIndex)
 										{
-											LOG_HIVE_ERROR(QString("ChannelConnectionManager::getChannelConnections threw an exception (%1). Please dump Full Network State from File menu and send the file for support.").arg(e.what()));
+											// both redundant
+											connectionInformation->streamPairs = getRedundantStreamIndexPairs(listenerStream.entityID, *connectionInformation->sourceVirtualIndex, connectionInformation->targetEntityId, *connectionInformation->targetVirtualIndex);
+
+											// add connection to the result data
+											result->targets.push_back(connectionInformation);
+										}
+										else
+										{
+											connectionInformation->streamPairs = { std::make_pair(connectionInformation->sourceStreamIndex, connectionInformation->targetStreamIndex) };
+
+											// add connection to the result data
+											result->targets.push_back(connectionInformation);
+
+											if (connectionInformation->sourceVirtualIndex)
+											{
+												// only talker redundant - add a second connection redundantTalker->Listener to reflect that
+												auto redundantTalkerStreamPair = getRedundantTalkerStreamIndexPair(listenerStream.entityID, connectionInformation->sourceStreamIndex, *connectionInformation->sourceVirtualIndex, connectionInformation->targetEntityId, connectionInformation->targetStreamIndex);
+
+												auto secondConnectionInformation = std::make_shared<TargetConnectionInformation>();
+												secondConnectionInformation->targetEntityId = listenerStream.entityID;
+												secondConnectionInformation->streamChannel = sourceStreamChannel;
+												secondConnectionInformation->sourceStreamIndex = redundantTalkerStreamPair.first;
+												secondConnectionInformation->targetStreamIndex = redundantTalkerStreamPair.second;
+												secondConnectionInformation->streamPairs = { redundantTalkerStreamPair };
+
+												auto targetClusterChannel = getListenerClusterChannelForStreamChannel(secondConnectionInformation->targetEntityId, secondConnectionInformation->targetStreamIndex, secondConnectionInformation->streamChannel);
+												secondConnectionInformation->targetClusterChannels.push_back(targetClusterChannel);
+												secondConnectionInformation->targetAudioUnitIndex = listenerAudioUnitKV.first;
+												secondConnectionInformation->targetBaseCluster = streamPortInputKV.second.staticModel.baseCluster;
+												secondConnectionInformation->targetStreamPortIndex = streamPortInputKV.first;
+												secondConnectionInformation->isSourceRedundant = controlledEntity->getStreamOutputNode(configurationNode.descriptorIndex, sourceStream).isRedundant;
+												secondConnectionInformation->isTargetRedundant = targetControlledEntity->getStreamInputNode(targetConfigurationNode.descriptorIndex, listenerMapping.streamIndex).isRedundant;
+
+												// add second connection to the result data
+												if (!secondConnectionInformation->isEqualTo(*connectionInformation))
+													result->targets.push_back(secondConnectionInformation);
+											}
+											else if (connectionInformation->targetVirtualIndex)
+											{
+												// only listener redundant - add a second connection Talker->redundantListener to reflect that
+												auto redundantListenerStreamPair = getRedundantListenerStreamIndexPair(listenerStream.entityID, connectionInformation->sourceStreamIndex, connectionInformation->targetEntityId, connectionInformation->targetStreamIndex, *connectionInformation->targetVirtualIndex);
+
+												auto secondConnectionInformation = std::make_shared<TargetConnectionInformation>();
+												secondConnectionInformation->targetEntityId = listenerStream.entityID;
+												secondConnectionInformation->streamChannel = sourceStreamChannel;
+												secondConnectionInformation->sourceStreamIndex = redundantListenerStreamPair.first;
+												secondConnectionInformation->targetStreamIndex = redundantListenerStreamPair.second;
+												secondConnectionInformation->streamPairs = { redundantListenerStreamPair };
+
+												auto targetClusterChannel = getListenerClusterChannelForStreamChannel(secondConnectionInformation->targetEntityId, secondConnectionInformation->targetStreamIndex, secondConnectionInformation->streamChannel);
+												secondConnectionInformation->targetClusterChannels.push_back(targetClusterChannel);
+												secondConnectionInformation->targetAudioUnitIndex = listenerAudioUnitKV.first;
+												secondConnectionInformation->targetBaseCluster = streamPortInputKV.second.staticModel.baseCluster;
+												secondConnectionInformation->targetStreamPortIndex = streamPortInputKV.first;
+												secondConnectionInformation->isSourceRedundant = controlledEntity->getStreamOutputNode(configurationNode.descriptorIndex, sourceStream).isRedundant;
+												secondConnectionInformation->isTargetRedundant = targetControlledEntity->getStreamInputNode(targetConfigurationNode.descriptorIndex, listenerMapping.streamIndex).isRedundant;
+
+												// add second connection to the result data
+												if (!secondConnectionInformation->isEqualTo(*connectionInformation))
+													result->targets.push_back(secondConnectionInformation);
+											}
 										}
 									}
 								}
+								catch (la::avdecc::controller::ControlledEntity::Exception const& e)
+								{
+									LOG_HIVE_ERROR(QString("ChannelConnectionManager::getChannelConnections threw an exception (%1). Please dump Full Network State from File menu and send the file for support.").arg(e.what()));
+								}
 							}
 						}
 					}
@@ -898,7 +875,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		auto const baseCluster = *sourceChannelIdentification.baseCluster;
 		auto const clusterChannel = sourceChannelIdentification.clusterChannel;
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ configurationIndex };
 		try
 		{
 			configurationNode = controlledEntity->getConfigurationNode(configurationIndex);
@@ -913,11 +890,8 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		try
 		{
 			auto const& streamPortInputNode = controlledEntity->getStreamPortInputNode(configurationIndex, streamPortIndex);
-			auto const* const streamPortInputDynamicModel = streamPortInputNode.dynamicModel;
-			if (streamPortInputDynamicModel)
-			{
-				mappings = streamPortInputDynamicModel->dynamicAudioMap;
-			}
+			auto const& streamPortInputDynamicModel = streamPortInputNode.dynamicModel;
+			mappings = streamPortInputDynamicModel.dynamicAudioMap;
 		}
 		catch (la::avdecc::controller::ControlledEntity::Exception const&)
 		{
@@ -939,132 +913,120 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		for (auto const& stream : sourceStreams)
 		{
 			auto const& streamInput = controlledEntity->getCurrentConfigurationNode().streamInputs.at(stream.first);
-			auto const* streamInputDynamicModel = streamInput.dynamicModel;
-			if (streamInputDynamicModel)
+			auto const& streamInputDynamicModel = streamInput.dynamicModel;
+			auto connectedTalker = streamInputDynamicModel.connectionInfo.talkerStream.entityID;
+			auto connectedTalkerStreamIndex = streamInputDynamicModel.connectionInfo.talkerStream.streamIndex;
+
+			auto sourceStreamChannel = stream.second;
+
+			// after getting the connected stream, resolve the underlying channels:
+			auto targetControlledEntity = manager.getControlledEntity(connectedTalker);
+
+			if (!targetControlledEntity)
 			{
-				auto connectedTalker = streamInputDynamicModel->connectionInfo.talkerStream.entityID;
-				auto connectedTalkerStreamIndex = streamInputDynamicModel->connectionInfo.talkerStream.streamIndex;
+				continue;
+			}
 
-				auto sourceStreamChannel = stream.second;
+			if (!targetControlledEntity->getEntity().getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported) || !targetControlledEntity->hasAnyConfiguration())
+			{
+				continue;
+			}
+			auto const& targetEntityNode = targetControlledEntity->getEntityNode();
+			auto const& targetConfigurationNode = targetControlledEntity->getConfigurationNode(targetEntityNode.dynamicModel.currentConfiguration);
 
-				// after getting the connected stream, resolve the underlying channels:
-				auto targetControlledEntity = manager.getControlledEntity(connectedTalker);
+			auto relevantPrimaryStreamIndexes = std::map<la::avdecc::entity::model::StreamIndex, std::vector<la::avdecc::entity::model::StreamIndex>>{};
+			auto relevantRedundantStreamIndexes = std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::entity::model::StreamIndex>{};
 
-				if (!targetControlledEntity)
+			// if the primary is not connected but the secondary is, the channel connection is still returned
+			for (auto const& redundantStreamOutput : targetConfigurationNode.redundantStreamOutputs)
+			{
+				auto primaryStreamIndex = redundantStreamOutput.second.primaryStreamIndex;
+				auto redundantStreams = std::vector<la::avdecc::entity::model::StreamIndex>{};
+				for (auto const redundantStreamIndex : redundantStreamOutput.second.redundantStreams)
 				{
-					continue;
+					if (redundantStreamIndex != primaryStreamIndex)
+					{
+						redundantStreams.push_back(redundantStreamIndex);
+						relevantRedundantStreamIndexes.emplace(redundantStreamIndex, primaryStreamIndex);
+					}
 				}
-
-				if (!targetControlledEntity->getEntity().getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported) || !targetControlledEntity->hasAnyConfiguration())
+				relevantPrimaryStreamIndexes.emplace(primaryStreamIndex, redundantStreams);
+			}
+			for (auto const& streamOutput : targetConfigurationNode.streamOutputs)
+			{
+				if (!streamOutput.second.isRedundant)
 				{
-					continue;
+					relevantPrimaryStreamIndexes.emplace(streamOutput.first, std::vector<la::avdecc::entity::model::StreamIndex>{});
 				}
-				auto const& targetEntityNode = targetControlledEntity->getEntityNode();
-				if (targetEntityNode.dynamicModel)
-				{
-					auto const& targetConfigurationNode = targetControlledEntity->getConfigurationNode(targetEntityNode.dynamicModel->currentConfiguration);
+			}
 
-					auto relevantPrimaryStreamIndexes = std::map<la::avdecc::entity::model::StreamIndex, std::vector<la::avdecc::entity::model::StreamIndex>>{};
-					auto relevantRedundantStreamIndexes = std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::entity::model::StreamIndex>{};
+			// find correct index of audio unit and stream port index:
+			for (auto const& audioUnitKV : targetConfigurationNode.audioUnits)
+			{
+				for (auto const& streamPortOutputKV : audioUnitKV.second.streamPortOutputs)
+				{
+					// get dynamic mappings
+					auto targetMappings = streamPortOutputKV.second.dynamicModel.dynamicAudioMap;
 
-					// if the primary is not connected but the secondary is, the channel connection is still returned
-					for (auto const& redundantStreamOutput : targetConfigurationNode.redundantStreamOutputs)
+					// add the static mappings
+					for (auto const& audioMap : streamPortOutputKV.second.audioMaps)
 					{
-						auto primaryStreamIndex = redundantStreamOutput.second.primaryStream->descriptorIndex;
-						auto redundantStreams = std::vector<la::avdecc::entity::model::StreamIndex>{};
-						for (auto const& [redundantStreamIndex, redundantStream] : redundantStreamOutput.second.redundantStreams)
-						{
-							if (redundantStreamIndex != primaryStreamIndex)
-							{
-								redundantStreams.push_back(redundantStreamIndex);
-								relevantRedundantStreamIndexes.emplace(redundantStreamIndex, primaryStreamIndex);
-							}
-						}
-						relevantPrimaryStreamIndexes.emplace(primaryStreamIndex, redundantStreams);
-					}
-					for (auto const& streamOutput : targetConfigurationNode.streamOutputs)
-					{
-						if (!streamOutput.second.isRedundant)
-						{
-							relevantPrimaryStreamIndexes.emplace(streamOutput.first, std::vector<la::avdecc::entity::model::StreamIndex>{});
-						}
+						targetMappings.insert(targetMappings.end(), audioMap.second.staticModel.mappings.begin(), audioMap.second.staticModel.mappings.end());
 					}
 
-					// find correct index of audio unit and stream port index:
-					for (auto const& audioUnitKV : targetConfigurationNode.audioUnits)
-					{
-						for (auto const& streamPortOutputKV : audioUnitKV.second.streamPortOutputs)
+					// iterate over mappings to find the channel connections
+					for (auto const& mapping : targetMappings)
+					{ // the source stream channel is connected to the corresponding target stream channel.
+						if (mapping.streamIndex == connectedTalkerStreamIndex && mapping.streamChannel == sourceStreamChannel)
 						{
-							if (streamPortOutputKV.second.dynamicModel)
-							{
-								// get dynamic mappings
-								auto targetMappings = streamPortOutputKV.second.dynamicModel->dynamicAudioMap;
+							la::avdecc::entity::model::StreamIdentification sourceStreamIdentification{ entityId, stream.first };
+							la::avdecc::entity::model::StreamIdentification targetStreamIdentification{ connectedTalker, connectedTalkerStreamIndex };
+
+							auto connectionInformation = std::make_shared<TargetConnectionInformation>();
+							connectionInformation->sourceVirtualIndex = getRedundantVirtualIndexFromInputStreamIndex(sourceStreamIdentification);
+							connectionInformation->targetVirtualIndex = getRedundantVirtualIndexFromOutputStreamIndex(targetStreamIdentification);
 
-								// add the static mappings
-								for (auto const& audioMap : streamPortOutputKV.second.audioMaps)
+							auto primaryListenerStreamIndex{ 0u };
+							auto primaryTalkerStreamIndex{ 0u };
+							auto primaryStreamIndexIt = relevantPrimaryStreamIndexes.find(mapping.streamIndex);
+							if (primaryStreamIndexIt != relevantPrimaryStreamIndexes.end())
+							{
+								primaryTalkerStreamIndex = primaryStreamIndexIt->first;
+								primaryListenerStreamIndex = stream.first;
+							}
+							else
+							{
+								auto streamIndex = relevantRedundantStreamIndexes.find(mapping.streamIndex);
+								if (streamIndex != relevantRedundantStreamIndexes.end() && connectionInformation->sourceVirtualIndex)
 								{
-									targetMappings.insert(targetMappings.end(), audioMap.second.staticModel->mappings.begin(), audioMap.second.staticModel->mappings.end());
+									// if we land in here the primary is not connected, but a secundary is.
+									primaryTalkerStreamIndex = streamIndex->second;
+									primaryListenerStreamIndex = controlledEntity->getRedundantStreamInputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, *connectionInformation->sourceVirtualIndex).primaryStreamIndex;
 								}
+							}
 
-								// iterate over mappings to find the channel connections
-								for (auto const& mapping : targetMappings)
-								{ // the source stream channel is connected to the corresponding target stream channel.
-									if (mapping.streamIndex == connectedTalkerStreamIndex && mapping.streamChannel == sourceStreamChannel)
-									{
-										la::avdecc::entity::model::StreamIdentification sourceStreamIdentification{ entityId, stream.first };
-										la::avdecc::entity::model::StreamIdentification targetStreamIdentification{ connectedTalker, connectedTalkerStreamIndex };
-
-										auto connectionInformation = std::make_shared<TargetConnectionInformation>();
-										connectionInformation->sourceVirtualIndex = getRedundantVirtualIndexFromInputStreamIndex(sourceStreamIdentification);
-										connectionInformation->targetVirtualIndex = getRedundantVirtualIndexFromOutputStreamIndex(targetStreamIdentification);
-
-										auto primaryListenerStreamIndex{ 0u };
-										auto primaryTalkerStreamIndex{ 0u };
-										auto primaryStreamIndexIt = relevantPrimaryStreamIndexes.find(mapping.streamIndex);
-										if (primaryStreamIndexIt != relevantPrimaryStreamIndexes.end())
-										{
-											primaryTalkerStreamIndex = primaryStreamIndexIt->first;
-											primaryListenerStreamIndex = stream.first;
-										}
-										else
-										{
-											auto streamIndex = relevantRedundantStreamIndexes.find(mapping.streamIndex);
-											if (streamIndex != relevantRedundantStreamIndexes.end() && connectionInformation->sourceVirtualIndex)
-											{
-												// if we land in here the primary is not connected, but a secundary is.
-												primaryTalkerStreamIndex = streamIndex->second;
-												primaryListenerStreamIndex = controlledEntity->getRedundantStreamInputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, *connectionInformation->sourceVirtualIndex).primaryStream->descriptorIndex;
-											}
-										}
-
-										connectionInformation->targetEntityId = connectedTalker;
-										connectionInformation->sourceStreamIndex = primaryListenerStreamIndex;
-										connectionInformation->targetStreamIndex = primaryTalkerStreamIndex;
-										if (connectionInformation->sourceVirtualIndex && connectionInformation->targetVirtualIndex)
-										{
-											// both redundant
-											connectionInformation->streamPairs = getRedundantStreamIndexPairs(connectionInformation->targetEntityId, *connectionInformation->targetVirtualIndex, entityId, *connectionInformation->sourceVirtualIndex);
-										}
-										else
-										{
-											connectionInformation->streamPairs = { std::make_pair(connectionInformation->targetStreamIndex, connectionInformation->sourceStreamIndex) };
-										}
-										connectionInformation->streamChannel = sourceStreamChannel;
-										connectionInformation->targetClusterChannels.push_back(std::make_pair(mapping.clusterOffset, mapping.clusterChannel));
-										connectionInformation->targetAudioUnitIndex = audioUnitKV.first;
-										if (streamPortOutputKV.second.staticModel)
-										{
-											connectionInformation->targetBaseCluster = streamPortOutputKV.second.staticModel->baseCluster;
-										}
-										connectionInformation->targetStreamPortIndex = streamPortOutputKV.first;
-										connectionInformation->isSourceRedundant = streamInput.isRedundant;
-										connectionInformation->isTargetRedundant = connectionInformation->targetVirtualIndex != std::nullopt;
-
-										result->targets.push_back(connectionInformation);
-										return result; // there can only ever be one channel connected on the listener side
-									}
-								}
+							connectionInformation->targetEntityId = connectedTalker;
+							connectionInformation->sourceStreamIndex = primaryListenerStreamIndex;
+							connectionInformation->targetStreamIndex = primaryTalkerStreamIndex;
+							if (connectionInformation->sourceVirtualIndex && connectionInformation->targetVirtualIndex)
+							{
+								// both redundant
+								connectionInformation->streamPairs = getRedundantStreamIndexPairs(connectionInformation->targetEntityId, *connectionInformation->targetVirtualIndex, entityId, *connectionInformation->sourceVirtualIndex);
+							}
+							else
+							{
+								connectionInformation->streamPairs = { std::make_pair(connectionInformation->targetStreamIndex, connectionInformation->sourceStreamIndex) };
 							}
+							connectionInformation->streamChannel = sourceStreamChannel;
+							connectionInformation->targetClusterChannels.push_back(std::make_pair(mapping.clusterOffset, mapping.clusterChannel));
+							connectionInformation->targetAudioUnitIndex = audioUnitKV.first;
+							connectionInformation->targetBaseCluster = streamPortOutputKV.second.staticModel.baseCluster;
+							connectionInformation->targetStreamPortIndex = streamPortOutputKV.first;
+							connectionInformation->isSourceRedundant = streamInput.isRedundant;
+							connectionInformation->isTargetRedundant = connectionInformation->targetVirtualIndex != std::nullopt;
+
+							result->targets.push_back(connectionInformation);
+							return result; // there can only ever be one channel connected on the listener side
 						}
 					}
 				}
@@ -1092,13 +1054,10 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 				auto const& configNode = controlledEntity->getCurrentConfigurationNode();
 				for (auto const& [streamIndex, streamInputNode] : configNode.streamInputs)
 				{
-					auto* streamInputDynamicModel = streamInputNode.dynamicModel;
-					if (streamInputDynamicModel)
+					auto& streamInputDynamicModel = streamInputNode.dynamicModel;
+					if (streamInputDynamicModel.connectionInfo.talkerStream.entityID == talkerEntityId)
 					{
-						if (streamInputDynamicModel->connectionInfo.talkerStream.entityID == talkerEntityId)
-						{
-							disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel->connectionInfo });
-						}
+						disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel.connectionInfo });
 					}
 				}
 			}
@@ -1114,34 +1073,41 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 	{
 		auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
 		auto controlledEntity = manager.getControlledEntity(entityId);
+		auto streams = std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>{};
 
 		if (!controlledEntity)
 		{
-			return std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>();
+			return streams;
 		}
 		if (!controlledEntity->getEntity().getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported) || !controlledEntity->hasAnyConfiguration())
 		{
-			return std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>();
+			return streams;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
 		}
 		catch (la::avdecc::controller::ControlledEntity::Exception const&)
 		{
-			return std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>();
+			return streams;
 		}
 
 		for (auto const& redundantStreamOutput : configurationNode.redundantStreamOutputs)
 		{
-			if (redundantStreamOutput.second.primaryStream->descriptorIndex == primaryStreamIndex)
+			if (redundantStreamOutput.second.primaryStreamIndex == primaryStreamIndex)
 			{
-				return redundantStreamOutput.second.redundantStreams;
+				for (auto const streamIndex : redundantStreamOutput.second.redundantStreams)
+				{
+					if (auto const streamIt = configurationNode.streamOutputs.find(streamIndex); streamIt != configurationNode.streamOutputs.end())
+					{
+						streams.insert({ streamIndex, &streamIt->second });
+					}
+				}
 			}
 		}
-		return std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>();
+		return streams;
 	}
 
 	/**
@@ -1151,34 +1117,41 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 	{
 		auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
 		auto controlledEntity = manager.getControlledEntity(entityId);
+		auto streams = std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>{};
 
 		if (!controlledEntity)
 		{
-			return std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>();
+			return streams;
 		}
 		if (!controlledEntity->getEntity().getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported) || !controlledEntity->hasAnyConfiguration())
 		{
-			return std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>();
+			return streams;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
 		}
 		catch (la::avdecc::controller::ControlledEntity::Exception const&)
 		{
-			return std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>();
+			return streams;
 		}
 
 		for (auto const& redundantStreamInput : configurationNode.redundantStreamInputs)
 		{
-			if (redundantStreamInput.second.primaryStream->descriptorIndex == primaryStreamIndex)
+			if (redundantStreamInput.second.primaryStreamIndex == primaryStreamIndex)
 			{
-				return redundantStreamInput.second.redundantStreams;
+				for (auto const streamIndex : redundantStreamInput.second.redundantStreams)
+				{
+					if (auto const streamIt = configurationNode.streamInputs.find(streamIndex); streamIt != configurationNode.streamInputs.end())
+					{
+						streams.insert({ streamIndex, &streamIt->second });
+					}
+				}
 			}
 		}
-		return std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*>();
+		return streams;
 	}
 
 
@@ -1223,7 +1196,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			auto const& streamPortOutput = controlledEntity->getStreamPortOutputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, sourceStreamPortIndex);
 			auto streamPortOutputAudioMappings = la::avdecc::entity::model::AudioMappings{};
-			if (streamPortOutput.staticModel->hasDynamicAudioMap)
+			if (streamPortOutput.staticModel.hasDynamicAudioMap)
 			{
 				streamPortOutputAudioMappings = controlledEntity->getStreamPortOutputAudioMappings(sourceStreamPortIndex);
 			}
@@ -1231,7 +1204,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			{
 				for (auto const& audioMap : streamPortOutput.audioMaps)
 				{
-					auto const& mappings = audioMap.second.staticModel->mappings;
+					auto const& mappings = audioMap.second.staticModel.mappings;
 					streamPortOutputAudioMappings.insert(streamPortOutputAudioMappings.end(), mappings.begin(), mappings.end());
 				}
 			}
@@ -1243,7 +1216,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 				{
 					for (auto const& audioMap : streamPortOutput.second.audioMaps)
 					{
-						streamPortOutputAudioMappings.insert(streamPortOutputAudioMappings.end(), audioMap.second.staticModel->mappings.begin(), audioMap.second.staticModel->mappings.end());
+						streamPortOutputAudioMappings.insert(streamPortOutputAudioMappings.end(), audioMap.second.staticModel.mappings.begin(), audioMap.second.staticModel.mappings.end());
 					}
 				}
 			}
@@ -1275,61 +1248,52 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 							continue;
 						}
 						auto const& targetEntityNode = targetControlledEntity->getEntityNode();
-						if (targetEntityNode.dynamicModel)
-						{
-							auto const& targetConfigurationNode = targetControlledEntity->getConfigurationNode(targetEntityNode.dynamicModel->currentConfiguration);
+						auto const& targetConfigurationNode = targetControlledEntity->getConfigurationNode(targetEntityNode.dynamicModel.currentConfiguration);
 
 
-							std::set<la::avdecc::entity::model::StreamIndex> relevantStreamIndexes;
-							for (auto const& redundantStreamOutput : targetConfigurationNode.redundantStreamInputs)
-							{
-								relevantStreamIndexes.insert(redundantStreamOutput.second.primaryStream->descriptorIndex);
-							}
-							for (auto const& streamOutput : targetConfigurationNode.streamInputs)
+						std::set<la::avdecc::entity::model::StreamIndex> relevantStreamIndexes;
+						for (auto const& redundantStreamOutput : targetConfigurationNode.redundantStreamInputs)
+						{
+							relevantStreamIndexes.insert(redundantStreamOutput.second.primaryStreamIndex);
+						}
+						for (auto const& streamOutput : targetConfigurationNode.streamInputs)
+						{
+							if (!streamOutput.second.isRedundant)
 							{
-								if (!streamOutput.second.isRedundant)
-								{
-									relevantStreamIndexes.insert(streamOutput.first);
-								}
+								relevantStreamIndexes.insert(streamOutput.first);
 							}
+						}
 
-							// find correct index of audio unit and stream port index:
-							for (auto const& audioUnitKV : targetConfigurationNode.audioUnits)
+						// find correct index of audio unit and stream port index:
+						for (auto const& audioUnitKV : targetConfigurationNode.audioUnits)
+						{
+							for (auto const& streamPortInputKV : audioUnitKV.second.streamPortInputs)
 							{
-								for (auto const& streamPortInputKV : audioUnitKV.second.streamPortInputs)
+								auto targetMappings = streamPortInputKV.second.dynamicModel.dynamicAudioMap;
+								for (auto const& mapping : targetMappings)
 								{
-									if (streamPortInputKV.second.dynamicModel)
+									if (relevantStreamIndexes.find(mapping.streamIndex) == relevantStreamIndexes.end())
 									{
-										auto targetMappings = streamPortInputKV.second.dynamicModel->dynamicAudioMap;
-										for (auto const& mapping : targetMappings)
-										{
-											if (relevantStreamIndexes.find(mapping.streamIndex) == relevantStreamIndexes.end())
-											{
-												//continue;
-											}
+										//continue;
+									}
 
-											// the source stream channel is connected to the corresponding target stream channel.
-											if (mapping.streamIndex == listenerStream.streamIndex && mapping.streamChannel == sourceStreamChannel)
-											{
-												auto connectionInformation = std::make_shared<TargetConnectionInformation>();
-
-												connectionInformation->targetEntityId = listenerStream.entityID;
-												connectionInformation->sourceStreamIndex = streamConnectionInfo.talkerStream.streamIndex;
-												connectionInformation->targetStreamIndex = listenerStream.streamIndex;
-												connectionInformation->isSourceRedundant = controlledEntity->getStreamOutputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, stream.first).isRedundant;
-												connectionInformation->streamChannel = sourceStreamChannel;
-												connectionInformation->targetClusterChannels.push_back(std::make_pair(mapping.clusterOffset, mapping.clusterChannel));
-												connectionInformation->targetAudioUnitIndex = audioUnitKV.first;
-
-												if (streamPortInputKV.second.staticModel)
-												{
-													connectionInformation->targetBaseCluster = streamPortInputKV.second.staticModel->baseCluster;
-												}
-												connectionInformation->targetStreamPortIndex = streamPortInputKV.first;
-												connectionInformation->isTargetRedundant = targetControlledEntity->getStreamInputNode(targetConfigurationNode.descriptorIndex, mapping.streamIndex).isRedundant;
-												result->targets.push_back(connectionInformation);
-											}
-										}
+									// the source stream channel is connected to the corresponding target stream channel.
+									if (mapping.streamIndex == listenerStream.streamIndex && mapping.streamChannel == sourceStreamChannel)
+									{
+										auto connectionInformation = std::make_shared<TargetConnectionInformation>();
+
+										connectionInformation->targetEntityId = listenerStream.entityID;
+										connectionInformation->sourceStreamIndex = streamConnectionInfo.talkerStream.streamIndex;
+										connectionInformation->targetStreamIndex = listenerStream.streamIndex;
+										connectionInformation->isSourceRedundant = controlledEntity->getStreamOutputNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, stream.first).isRedundant;
+										connectionInformation->streamChannel = sourceStreamChannel;
+										connectionInformation->targetClusterChannels.push_back(std::make_pair(mapping.clusterOffset, mapping.clusterChannel));
+										connectionInformation->targetAudioUnitIndex = audioUnitKV.first;
+
+										connectionInformation->targetBaseCluster = streamPortInputKV.second.staticModel.baseCluster;
+										connectionInformation->targetStreamPortIndex = streamPortInputKV.first;
+										connectionInformation->isTargetRedundant = targetControlledEntity->getStreamInputNode(targetConfigurationNode.descriptorIndex, mapping.streamIndex).isRedundant;
+										result->targets.push_back(connectionInformation);
 									}
 								}
 							}
@@ -1363,13 +1327,10 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 					auto const& configNode = controlledEntity->getCurrentConfigurationNode();
 					for (auto const& [streamIndex, streamInputNode] : configNode.streamInputs)
 					{
-						auto* streamInputDynamicModel = streamInputNode.dynamicModel;
-						if (streamInputDynamicModel)
+						auto& streamInputDynamicModel = streamInputNode.dynamicModel;
+						if (streamInputDynamicModel.connectionInfo.talkerStream.entityID == talkerEntityId && streamInputDynamicModel.connectionInfo.talkerStream.streamIndex == outputStreamIndex)
 						{
-							if (streamInputDynamicModel->connectionInfo.talkerStream.entityID == talkerEntityId && streamInputDynamicModel->connectionInfo.talkerStream.streamIndex == outputStreamIndex)
-							{
-								disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel->connectionInfo });
-							}
+							disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel.connectionInfo });
 						}
 					}
 				}
@@ -1699,18 +1660,10 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			{
 				auto talkerStreamIndex = streamConnection.first;
 				auto listenerStreamIndex = streamConnection.second;
-				auto const* const streamOutputDynamicModel = talkerEntity->getStreamOutputNode(talkerEntity->getCurrentConfigurationNode().descriptorIndex, talkerStreamIndex).dynamicModel;
-				if (!streamOutputDynamicModel)
-				{
-					return std::nullopt;
-				}
-				auto const* const streamInputDynamicModel = listenerEntity->getStreamInputNode(listenerEntity->getCurrentConfigurationNode().descriptorIndex, listenerStreamIndex).dynamicModel;
-				if (!streamInputDynamicModel)
-				{
-					return std::nullopt;
-				}
-				auto talkerStreamFormat = streamOutputDynamicModel->streamFormat;
-				auto listenerStreamFormat = streamInputDynamicModel->streamFormat;
+				auto const& streamOutputDynamicModel = talkerEntity->getStreamOutputNode(talkerEntity->getCurrentConfigurationNode().descriptorIndex, talkerStreamIndex).dynamicModel;
+				auto const& streamInputDynamicModel = listenerEntity->getStreamInputNode(listenerEntity->getCurrentConfigurationNode().descriptorIndex, listenerStreamIndex).dynamicModel;
+				auto talkerStreamFormat = streamOutputDynamicModel.streamFormat;
+				auto listenerStreamFormat = streamInputDynamicModel.streamFormat;
 
 				return StreamChannelInfo{ talkerStreamIndex, listenerStreamIndex, streamChannel, isStreamAlreadyConnected, reusesTalkerMapping, reusesListenerMapping, streamChannel == talkerClusterOffset, talkerStreamFormat, listenerStreamFormat };
 			}
@@ -1838,7 +1791,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 
 				for (auto const& audioMapKV : streamPortOutputKV.second.audioMaps)
 				{
-					for (auto const& mapping : audioMapKV.second.staticModel->mappings)
+					for (auto const& mapping : audioMapKV.second.staticModel.mappings)
 					{
 						if (mapping.streamIndex == talkerStreamIndex)
 						{
@@ -2557,14 +2510,11 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 					auto const& configNode = controlledEntity->getCurrentConfigurationNode();
 					for (auto const& [streamIndex, streamInputNode] : configNode.streamInputs)
 					{
-						auto* streamInputDynamicModel = streamInputNode.dynamicModel;
-						if (streamInputDynamicModel)
+						auto& streamInputDynamicModel = streamInputNode.dynamicModel;
+						auto const& talkerStream = streamInputDynamicModel.connectionInfo.talkerStream;
+						if (talkerStream.entityID == talkerEntityId && talkerStream.streamIndex == talkerStreamIndex)
 						{
-							auto const& talkerStream = streamInputDynamicModel->connectionInfo.talkerStream;
-							if (talkerStream.entityID == talkerEntityId && talkerStream.streamIndex == talkerStreamIndex)
-							{
-								disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel->connectionInfo });
-							}
+							disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel.connectionInfo });
 						}
 					}
 				}
@@ -2627,7 +2577,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return result;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -2642,7 +2592,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			for (auto const& streamPortOutput : audioUnit.second.streamPortOutputs)
 			{
 				// add dynamic mappings
-				for (auto const& mapping : streamPortOutput.second.dynamicModel->dynamicAudioMap)
+				for (auto const& mapping : streamPortOutput.second.dynamicModel.dynamicAudioMap)
 				{
 					if (mapping.streamIndex == outputStreamIndex)
 					{
@@ -2664,7 +2614,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 				// add static mappings
 				for (auto const& audioMap : streamPortOutput.second.audioMaps)
 				{
-					for (auto const& mapping : audioMap.second.staticModel->mappings)
+					for (auto const& mapping : audioMap.second.staticModel.mappings)
 					{
 						if (mapping.streamIndex == outputStreamIndex)
 						{
@@ -2708,7 +2658,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return result;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -2722,7 +2672,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			for (auto const& streamPortInput : audioUnit.second.streamPortInputs)
 			{
-				for (auto const& mapping : streamPortInput.second.dynamicModel->dynamicAudioMap)
+				for (auto const& mapping : streamPortInput.second.dynamicModel.dynamicAudioMap)
 				{
 					if (mapping.streamIndex == inputStreamIndex)
 					{
@@ -2762,7 +2712,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return result;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -2786,7 +2736,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			for (auto const& streamPortInput : audioUnit.second.streamPortInputs)
 			{
-				for (auto const& mapping : streamPortInput.second.dynamicModel->dynamicAudioMap)
+				for (auto const& mapping : streamPortInput.second.dynamicModel.dynamicAudioMap)
 				{
 					if (connectedStreamListenerIndices.find(mapping.streamIndex) != connectedStreamListenerIndices.end())
 					{
@@ -2829,7 +2779,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return result;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -2845,7 +2795,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			for (auto const& streamPortOutput : audioUnit.second.streamPortOutputs)
 			{
 				// dynamic mappings
-				for (auto const& mapping : streamPortOutput.second.dynamicModel->dynamicAudioMap)
+				for (auto const& mapping : streamPortOutput.second.dynamicModel.dynamicAudioMap)
 				{
 					if (mapping.streamIndex == outputStreamIndex)
 					{
@@ -2856,7 +2806,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 				// add static mappings
 				for (auto const& audioMap : streamPortOutput.second.audioMaps)
 				{
-					for (auto const& mapping : audioMap.second.staticModel->mappings)
+					for (auto const& mapping : audioMap.second.staticModel.mappings)
 					{
 						if (mapping.streamIndex == outputStreamIndex)
 						{
@@ -2899,7 +2849,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return result;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -2914,7 +2864,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			for (auto const& streamPortInput : audioUnit.second.streamPortInputs)
 			{
-				for (auto const& mapping : streamPortInput.second.dynamicModel->dynamicAudioMap)
+				for (auto const& mapping : streamPortInput.second.dynamicModel.dynamicAudioMap)
 				{
 					if (mapping.streamIndex == inputStreamIndex)
 					{
@@ -2952,7 +2902,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return result;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -2966,7 +2916,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			for (auto const& streamPortInput : audioUnit.second.streamPortInputs)
 			{
-				for (auto const& mapping : streamPortInput.second.dynamicModel->dynamicAudioMap)
+				for (auto const& mapping : streamPortInput.second.dynamicModel.dynamicAudioMap)
 				{
 					if (mapping.streamIndex == inputStreamIndex && mapping.streamChannel == streamChannel)
 					{
@@ -3026,7 +2976,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return result;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode talkerConfigurationNode;
+		auto talkerConfigurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledTalkerEntity->getCurrentConfigurationNode() };
 		try
 		{
 			talkerConfigurationNode = controlledTalkerEntity->getCurrentConfigurationNode();
@@ -3036,7 +2986,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return result;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode listenerConfigurationNode;
+		auto listenerConfigurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledListenerEntity->getCurrentConfigurationNode() };
 		try
 		{
 			listenerConfigurationNode = controlledListenerEntity->getCurrentConfigurationNode();
@@ -3050,7 +3000,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		// and are not in use already
 		for (auto const& streamOutputKV : talkerConfigurationNode.streamOutputs)
 		{
-			if (!supportsStreamFormat(streamOutputKV.second.staticModel->formats, la::avdecc::entity::model::StreamFormatInfo::Type::AAF))
+			if (!supportsStreamFormat(streamOutputKV.second.staticModel.formats, la::avdecc::entity::model::StreamFormatInfo::Type::AAF))
 			{
 				continue;
 			}
@@ -3066,20 +3016,17 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 					// skip secundary streams
 					continue;
 				}
-				auto const* const streamInputDymaicModel = streamInputKV.second.dynamicModel;
-				if (streamInputDymaicModel)
+				auto const& streamInputDymaicModel = streamInputKV.second.dynamicModel;
+				if (streamInputDymaicModel.connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
 				{
-					if (streamInputDymaicModel->connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
-					{
-						continue; // skip if connected or fast connecting
-					}
-					if (!supportsStreamFormat(streamInputKV.second.staticModel->formats, la::avdecc::entity::model::StreamFormatInfo::Type::AAF))
-					{
-						continue;
-					}
-
-					result.push_back(std::make_pair(streamOutputKV.first, streamInputKV.first));
+					continue; // skip if connected or fast connecting
 				}
+				if (!supportsStreamFormat(streamInputKV.second.staticModel.formats, la::avdecc::entity::model::StreamFormatInfo::Type::AAF))
+				{
+					continue;
+				}
+
+				result.push_back(std::make_pair(streamOutputKV.first, streamInputKV.first));
 			}
 		}
 
@@ -3209,7 +3156,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return std::make_pair(std::nullopt, std::nullopt);
 		}
 
-		la::avdecc::controller::model::ConfigurationNode talkerConfigurationNode;
+		auto talkerConfigurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledTalkerEntity->getCurrentConfigurationNode() };
 		try
 		{
 			talkerConfigurationNode = controlledTalkerEntity->getCurrentConfigurationNode();
@@ -3219,7 +3166,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return std::make_pair(std::nullopt, std::nullopt);
 		}
 
-		la::avdecc::controller::model::ConfigurationNode listenerConfigurationNode;
+		auto listenerConfigurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledListenerEntity->getCurrentConfigurationNode() };
 		try
 		{
 			listenerConfigurationNode = controlledListenerEntity->getCurrentConfigurationNode();
@@ -3234,7 +3181,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		std::optional<la::avdecc::entity::model::StreamFormat> resultingListenerStreamFormat{ std::nullopt };
 		std::optional<la::avdecc::entity::model::StreamFormatInfo::UniquePointer> resultingListenerStreamFormatInfo{ std::nullopt };
 
-		la::avdecc::controller::model::StreamOutputNode streamOutputNode;
+		auto streamOutputNode = la::avdecc::controller::model::StreamOutputNode{ streamOutputIndex };
 		try
 		{
 			streamOutputNode = controlledTalkerEntity->getStreamOutputNode(talkerConfigurationNode.descriptorIndex, streamOutputIndex);
@@ -3244,10 +3191,10 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return std::make_pair(std::nullopt, std::nullopt);
 		}
 
-		auto const& currentStreamOutputFormat = streamOutputNode.dynamicModel->streamFormat;
+		auto const& currentStreamOutputFormat = streamOutputNode.dynamicModel.streamFormat;
 		auto const currentStreamOutputFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(currentStreamOutputFormat);
 
-		la::avdecc::controller::model::StreamInputNode streamInputNode;
+		auto streamInputNode = la::avdecc::controller::model::StreamInputNode{ streamInputIndex };
 		try
 		{
 			streamInputNode = controlledListenerEntity->getStreamInputNode(listenerConfigurationNode.descriptorIndex, streamInputIndex);
@@ -3256,7 +3203,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 		{
 			return std::make_pair(std::nullopt, std::nullopt);
 		}
-		auto const& currentStreamInputFormat = streamInputNode.dynamicModel->streamFormat;
+		auto const& currentStreamInputFormat = streamInputNode.dynamicModel.streamFormat;
 
 		if (la::avdecc::entity::model::StreamFormatInfo::isListenerFormatCompatibleWithTalkerFormat(currentStreamInputFormat, currentStreamOutputFormat))
 		{
@@ -3266,7 +3213,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 
 		auto compatibleFormatOptions = std::vector<std::pair<la::avdecc::entity::model::StreamFormat, la::avdecc::entity::model::StreamFormat>>{};
 
-		auto const& streamOutputFormats = streamOutputNode.staticModel->formats;
+		auto const& streamOutputFormats = streamOutputNode.staticModel.formats;
 		for (auto const& streamOutputFormat : streamOutputFormats)
 		{
 			auto const streamFormatInfoTalker = la::avdecc::entity::model::StreamFormatInfo::create(streamOutputFormat);
@@ -3277,7 +3224,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			if (expectedStreamFormatType == streamFormatTypeTalker)
 			{
 				// search for fitting listener configuration.
-				auto const& streamInputFormats = streamInputNode.staticModel->formats;
+				auto const& streamInputFormats = streamInputNode.staticModel.formats;
 				for (auto const& streamInputFormat : streamInputFormats)
 				{
 					auto const streamFormatInfoListener = la::avdecc::entity::model::StreamFormatInfo::create(streamInputFormat);
@@ -3381,7 +3328,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return 0;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -3393,7 +3340,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 
 		// get the stream channel count:
 		auto const& streamNode = controlledEntity->getStreamInputNode(configurationNode.descriptorIndex, streamIndex);
-		auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode.dynamicModel->streamFormat);
+		auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode.dynamicModel.streamFormat);
 		return sfi->getChannelsCount();
 	}
 
@@ -3414,7 +3361,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 			return 0;
 		}
 
-		la::avdecc::controller::model::ConfigurationNode configurationNode;
+		auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 		try
 		{
 			configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -3426,7 +3373,7 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 
 		// get the stream channel count:
 		auto const& streamNode = controlledEntity->getStreamOutputNode(configurationNode.descriptorIndex, streamIndex);
-		auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode.dynamicModel->streamFormat);
+		auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode.dynamicModel.streamFormat);
 		return sfi->getChannelsCount();
 	}
 
@@ -3494,9 +3441,9 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 								auto const configIndex = controlledEntity->getCurrentConfigurationNode().descriptorIndex;
 								auto const& redundantListenerStreamNode = controlledEntity->getRedundantStreamInputNode(configIndex, *virtualListenerIndex);
 								bool atLeastOneConnected = false;
-								for (auto const& [streamIndex, streamNode] : redundantListenerStreamNode.redundantStreams)
+								for (auto const streamIndex : redundantListenerStreamNode.redundantStreams)
 								{
-									if (controlledEntity->getStreamInputNode(configIndex, streamIndex).dynamicModel->connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
+									if (controlledEntity->getStreamInputNode(configIndex, streamIndex).dynamicModel.connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
 									{
 										atLeastOneConnected = true;
 										break;
@@ -3554,11 +3501,8 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 								auto const configurationIndex = controlledEntity->getCurrentConfigurationNode().descriptorIndex;
 								auto const streamPortIndex = *mappingKV.second->sourceClusterChannelInfo->streamPortIndex;
 								auto const& streamPortInputNode = controlledEntity->getStreamPortInputNode(configurationIndex, streamPortIndex);
-								auto const* const streamPortInputDynamicModel = streamPortInputNode.dynamicModel;
-								if (streamPortInputDynamicModel)
-								{
-									mappings = streamPortInputDynamicModel->dynamicAudioMap;
-								}
+								auto const& streamPortInputDynamicModel = streamPortInputNode.dynamicModel;
+								mappings = streamPortInputDynamicModel.dynamicAudioMap;
 							}
 						}
 						catch (la::avdecc::controller::ControlledEntity::Exception const&)
@@ -3582,9 +3526,9 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 									auto const configIndex = controlledEntity->getCurrentConfigurationNode().descriptorIndex;
 									auto const& redundantListenerStreamNode = controlledEntity->getRedundantStreamInputNode(configIndex, *virtualListenerIndex);
 									bool atLeastOneConnected = false;
-									for (auto const& [redundantListenerStreamIndex, streamNode] : redundantListenerStreamNode.redundantStreams)
+									for (auto const redundantListenerStreamIndex : redundantListenerStreamNode.redundantStreams)
 									{
-										if (controlledEntity->getStreamInputNode(configIndex, redundantListenerStreamIndex).dynamicModel->connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
+										if (controlledEntity->getStreamInputNode(configIndex, redundantListenerStreamIndex).dynamicModel.connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
 										{
 											atLeastOneConnected = true;
 											break;
@@ -3675,10 +3619,10 @@ class ChannelConnectionManagerImpl final : public ChannelConnectionManager
 						auto currentlyConnectedEntities = std::unordered_set<la::avdecc::UniqueIdentifier, la::avdecc::UniqueIdentifier::hash>{};
 						for (auto const& streamInput : configuration.streamInputs)
 						{
-							auto* streamInputDynamicModel = streamInput.second.dynamicModel;
-							if (streamInputDynamicModel && streamInputDynamicModel->connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected)
+							auto& streamInputDynamicModel = streamInput.second.dynamicModel;
+							if (streamInputDynamicModel.connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected)
 							{
-								currentlyConnectedEntities.emplace(streamInputDynamicModel->connectionInfo.talkerStream.entityID);
+								currentlyConnectedEntities.emplace(streamInputDynamicModel.connectionInfo.talkerStream.entityID);
 							}
 						}
 
diff --git a/src/avdecc/controllerModel.cpp b/src/avdecc/controllerModel.cpp
deleted file mode 100644
index 81e71b76..00000000
--- a/src/avdecc/controllerModel.cpp
+++ /dev/null
@@ -1,1148 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#pragma message("WARNING: ControllerModel is to be replaced by the new discoveredEntitiesModel (see AEMDumper example)")
-
-#include "controllerModel.hpp"
-#include "helper.hpp"
-#include "avdecc/mcDomainManager.hpp"
-#include "settingsManager/settings.hpp"
-#include <QtMate/material/color.hpp>
-
-#include <hive/modelsLibrary/helper.hpp>
-#include <hive/modelsLibrary/controllerManager.hpp>
-#include <hive/widgetModelsLibrary/entityLogoCache.hpp>
-#include <hive/widgetModelsLibrary/qtUserRoles.hpp>
-#include <hive/widgetModelsLibrary/imageItemDelegate.hpp>
-#include <hive/widgetModelsLibrary/errorItemDelegate.hpp>
-#include <la/avdecc/utils.hpp>
-#include <la/avdecc/logger.hpp>
-
-#include <QFont>
-#include <QApplication>
-
-#include <algorithm>
-#include <array>
-#include <set>
-#include <unordered_map>
-#include <unordered_set>
-
-Q_DECLARE_METATYPE(la::avdecc::UniqueIdentifier)
-
-namespace avdecc
-{
-enum class ExclusiveAccessState
-{
-	NoAccess = 0,
-	NotSupported = 1,
-	AccessOther = 2,
-	AccessSelf = 3,
-};
-
-enum class Compatibility
-{
-	NotCompliant,
-	IEEE,
-	Milan,
-	MilanCertified,
-	MilanWarning,
-	MilanRedundant,
-	MilanCertifiedRedundant,
-	MilanWarningRedundant,
-	Misbehaving,
-};
-
-struct MediaClockInfo
-{
-	QString masterID;
-	QString masterName;
-};
-
-struct GptpInfo
-{
-	std::optional<la::avdecc::UniqueIdentifier> grandmasterID;
-	std::optional<std::uint8_t> domainNumber;
-};
-using GptpInfoPerAvbInterfaceIndex = std::map<la::avdecc::entity::model::AvbInterfaceIndex, GptpInfo>;
-
-Compatibility computeCompatibility(std::optional<la::avdecc::entity::model::MilanInfo> const& milanInfo, la::avdecc::controller::ControlledEntity::CompatibilityFlags const compatibilityFlags)
-{
-	if (compatibilityFlags.test(la::avdecc::controller::ControlledEntity::CompatibilityFlag::Misbehaving))
-	{
-		return Compatibility::Misbehaving;
-	}
-	else if (compatibilityFlags.test(la::avdecc::controller::ControlledEntity::CompatibilityFlag::Milan))
-	{
-		auto const isRedundant = milanInfo && milanInfo->featuresFlags.test(la::avdecc::entity::MilanInfoFeaturesFlag::Redundancy);
-		auto const isCertifiedV1 = milanInfo && milanInfo->certificationVersion >= 0x01000000;
-		auto const isWarning = compatibilityFlags.test(la::avdecc::controller::ControlledEntity::CompatibilityFlag::MilanWarning);
-
-		if (isWarning)
-		{
-			return isRedundant ? Compatibility::MilanWarningRedundant : Compatibility::MilanWarning;
-		}
-
-		if (isCertifiedV1)
-		{
-			return isRedundant ? Compatibility::MilanCertifiedRedundant : Compatibility::MilanCertified;
-		}
-
-		return isRedundant ? Compatibility::MilanRedundant : Compatibility::Milan;
-	}
-	else if (compatibilityFlags.test(la::avdecc::controller::ControlledEntity::CompatibilityFlag::IEEE17221))
-	{
-		return Compatibility::IEEE;
-	}
-
-	return Compatibility::NotCompliant;
-}
-
-ExclusiveAccessState computeAcquireState(la::avdecc::controller::model::AcquireState const acquireState)
-{
-	switch (acquireState)
-	{
-		case la::avdecc::controller::model::AcquireState::NotSupported:
-			return ExclusiveAccessState::NotSupported;
-		case la::avdecc::controller::model::AcquireState::Acquired:
-			return ExclusiveAccessState::AccessSelf;
-		case la::avdecc::controller::model::AcquireState::AcquiredByOther:
-			return ExclusiveAccessState::AccessOther;
-		default:
-			return ExclusiveAccessState::NoAccess;
-	}
-}
-
-ExclusiveAccessState computeLockState(la::avdecc::controller::model::LockState const lockState)
-{
-	switch (lockState)
-	{
-		case la::avdecc::controller::model::LockState::NotSupported:
-			return ExclusiveAccessState::NotSupported;
-		case la::avdecc::controller::model::LockState::Locked:
-			return ExclusiveAccessState::AccessSelf;
-		case la::avdecc::controller::model::LockState::LockedByOther:
-			return ExclusiveAccessState::AccessOther;
-		default:
-			return ExclusiveAccessState::NoAccess;
-	}
-}
-
-MediaClockInfo computeMediaClockInfo(la::avdecc::UniqueIdentifier const& entityID)
-{
-	MediaClockInfo info;
-
-	try
-	{
-		auto& clockConnectionManager = avdecc::mediaClock::MCDomainManager::getInstance();
-		auto const& [mediaClockMasterID, error] = clockConnectionManager.getMediaClockMaster(entityID);
-
-		if (!!error)
-		{
-			switch (error)
-			{
-				case mediaClock::McDeterminationError::NotSupportedClockSourceType:
-				case mediaClock::McDeterminationError::NotSupportedNoAem:
-				case mediaClock::McDeterminationError::NotSupportedMultipleClockDomains:
-				case mediaClock::McDeterminationError::NotSupportedNoClockDomains:
-					info.masterID = "N/A";
-					break;
-				case mediaClock::McDeterminationError::Recursive:
-					info.masterID = "Recursive";
-					break;
-				case mediaClock::McDeterminationError::StreamNotConnected:
-					info.masterID = "Stream N/C";
-					break;
-				case mediaClock::McDeterminationError::ParentStreamNotConnected:
-					info.masterID = "Parent Stream N/C";
-					break;
-				case mediaClock::McDeterminationError::ExternalClockSource:
-					if (mediaClockMasterID == entityID)
-					{
-						info.masterID = "External";
-					}
-					else
-					{
-						info.masterID = "External on " + hive::modelsLibrary::helper::uniqueIdentifierToString(mediaClockMasterID);
-					}
-					break;
-				case mediaClock::McDeterminationError::AnyEntityInChainOffline:
-					info.masterID = "Talker Offline";
-					break;
-				case mediaClock::McDeterminationError::UnknownEntity:
-					info.masterID = "Unknown Entity";
-					break;
-				default:
-					AVDECC_ASSERT(false, "Unhandled case");
-					break;
-			}
-		}
-		else
-		{
-			if (mediaClockMasterID != entityID)
-			{
-				info.masterID = hive::modelsLibrary::helper::uniqueIdentifierToString(mediaClockMasterID);
-
-				auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
-				if (auto const clockMasterEntity = manager.getControlledEntity(mediaClockMasterID))
-				{
-					info.masterName = hive::modelsLibrary::helper::entityName(*clockMasterEntity);
-				}
-			}
-			else
-			{
-				info.masterID = "Self";
-			}
-		}
-	}
-	catch (...)
-	{
-		return {};
-	}
-
-	return info;
-}
-
-GptpInfoPerAvbInterfaceIndex buildGptpInfoMap(la::avdecc::entity::Entity::InterfacesInformation const& interfacesInformation)
-{
-	GptpInfoPerAvbInterfaceIndex map;
-	for (auto const& [avbInterfaceIndex, interfaceInformation] : interfacesInformation)
-	{
-		map.insert(std::make_pair(avbInterfaceIndex, GptpInfo{ interfaceInformation.gptpGrandmasterID, interfaceInformation.gptpDomainNumber }));
-	}
-	return map;
-}
-
-QString computeGptpTooltip(GptpInfoPerAvbInterfaceIndex const& gptp)
-{
-	QStringList list;
-
-	for (auto const& [avbInterfaceIndex, info] : gptp)
-	{
-		if (info.grandmasterID && info.domainNumber)
-		{
-			if (avbInterfaceIndex == la::avdecc::entity::Entity::GlobalAvbInterfaceIndex)
-			{
-				list << QString{ "Global gPTP: %1 / %2" }.arg(hive::modelsLibrary::helper::uniqueIdentifierToString(*info.grandmasterID)).arg(*info.domainNumber);
-			}
-			else
-			{
-				list << QString{ "gPTP for index %1: %2 / %3" }.arg(avbInterfaceIndex).arg(hive::modelsLibrary::helper::uniqueIdentifierToString(*info.grandmasterID)).arg(*info.domainNumber);
-			}
-		}
-	}
-
-	return list.join('\n');
-}
-
-class ControllerModelPrivate : public QObject, private settings::SettingsManager::Observer
-{
-	Q_OBJECT
-public:
-	ControllerModelPrivate(ControllerModel* model)
-		: q_ptr{ model }
-	{
-		// Connect hive::modelsLibrary::ControllerManager signals
-		auto& controllerManager = hive::modelsLibrary::ControllerManager::getInstance();
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::controllerOffline, this, &ControllerModelPrivate::handleControllerOffline);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::entityOnline, this, &ControllerModelPrivate::handleEntityOnline);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::entityOffline, this, &ControllerModelPrivate::handleEntityOffline);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::entityRedundantInterfaceOnline, this, &ControllerModelPrivate::handleEntityRedundantInterfaceOnline);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::entityRedundantInterfaceOffline, this, &ControllerModelPrivate::handleEntityRedundantInterfaceOffline);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::associationIDChanged, this, &ControllerModelPrivate::handleAssociationIDChanged);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::identificationStarted, this, &ControllerModelPrivate::handleIdentificationStarted);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::identificationStopped, this, &ControllerModelPrivate::handleIdentificationStopped);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::entityNameChanged, this, &ControllerModelPrivate::handleEntityNameChanged);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::entityGroupNameChanged, this, &ControllerModelPrivate::handleEntityGroupNameChanged);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::acquireStateChanged, this, &ControllerModelPrivate::handleAcquireStateChanged);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::lockStateChanged, this, &ControllerModelPrivate::handleLockStateChanged);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::compatibilityFlagsChanged, this, &ControllerModelPrivate::handleCompatibilityFlagsChanged);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::gptpChanged, this, &ControllerModelPrivate::handleGptpChanged);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::streamInputErrorCounterChanged, this, &ControllerModelPrivate::handleStreamInputErrorCounterChanged);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::statisticsErrorCounterChanged, this, &ControllerModelPrivate::handleStatisticsErrorCounterChanged);
-		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::diagnosticsChanged, this, &ControllerModelPrivate::handleDiagnosticsChanged);
-
-		// Connect avdecc::mediaClock::MCDomainManager signals
-		auto& mediaClockConnectionManager = avdecc::mediaClock::MCDomainManager::getInstance();
-		connect(&mediaClockConnectionManager, &avdecc::mediaClock::MCDomainManager::mediaClockConnectionsUpdate, this, &ControllerModelPrivate::handleMediaClockConnectionsUpdated);
-		connect(&mediaClockConnectionManager, &avdecc::mediaClock::MCDomainManager::mcMasterNameChanged, this, &ControllerModelPrivate::handleMcMasterNameChanged);
-
-		// Connect EntityLogoCache signals
-		auto& logoCache = hive::widgetModelsLibrary::EntityLogoCache::getInstance();
-		connect(&logoCache, &hive::widgetModelsLibrary::EntityLogoCache::imageChanged, this, &ControllerModelPrivate::handleImageChanged);
-
-		// Register to settings::SettingsManager
-		auto const* const settings = qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>();
-		settings->registerSettingObserver(settings::General_AutomaticPNGDownloadEnabled.name, this);
-		settings->registerSettingObserver(settings::General_ThemeColorIndex.name, this);
-	}
-
-	virtual ~ControllerModelPrivate()
-	{
-		// Remove settings observers
-		auto const* const settings = qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>();
-		settings->unregisterSettingObserver(settings::General_AutomaticPNGDownloadEnabled.name, this);
-		settings->unregisterSettingObserver(settings::General_ThemeColorIndex.name, this);
-	}
-
-	int rowCount() const
-	{
-		return static_cast<int>(_entities.size());
-	}
-
-	int columnCount() const
-	{
-		return la::avdecc::utils::to_integral(ControllerModel::Column::Count);
-	}
-
-	QVariant data(QModelIndex const& index, int role) const
-	{
-		auto const row = index.row();
-		if (row < 0 || row >= rowCount())
-		{
-			return {};
-		}
-
-		auto const& data = _entities[row];
-		auto const& entityID = data.entityID;
-		auto const column = static_cast<ControllerModel::Column>(index.column());
-
-		if (role == Qt::DisplayRole)
-		{
-			switch (column)
-			{
-				case ControllerModel::Column::EntityID:
-					return hive::modelsLibrary::helper::uniqueIdentifierToString(entityID);
-				case ControllerModel::Column::Name:
-					return data.name;
-				case ControllerModel::Column::Group:
-					return data.groupName;
-				case ControllerModel::Column::GrandmasterID:
-					return data.gptpGrandmasterIDToString();
-				case ControllerModel::Column::GptpDomain:
-					return data.gptpDomainNumberToString();
-				case ControllerModel::Column::InterfaceIndex:
-					return data.avbInterfaceIndexToString();
-				case ControllerModel::Column::AssociationID:
-					return data.associationIDToString();
-				case ControllerModel::Column::MediaClockMasterID:
-					return data.mediaClockInfo.masterID;
-				case ControllerModel::Column::MediaClockMasterName:
-					return data.mediaClockInfo.masterName;
-				default:
-					break;
-			}
-		}
-		else if (column == ControllerModel::Column::EntityID)
-		{
-			if (role == la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ErrorRole) || role == Qt::ForegroundRole)
-			{
-				auto const it = _entitiesWithErrorCounter.find(entityID);
-				if (it != std::end(_entitiesWithErrorCounter))
-				{
-					auto const& entityWithErrorCounter{ it->second };
-					if (entityWithErrorCounter.hasError())
-					{
-						if (role == la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ErrorRole))
-						{
-							return true;
-						}
-						else if (role == Qt::ForegroundRole)
-						{
-							return _errorColorValue;
-						}
-					}
-				}
-			}
-			else if (role == Qt::FontRole)
-			{
-				auto font = QFont{};
-				font.setBold(_identifingEntities.count(entityID) > 0);
-				return font;
-			}
-		}
-		else if (column == ControllerModel::Column::EntityLogo)
-		{
-			if (role == la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::LightImageRole) || role == la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::DarkImageRole))
-			{
-				if (data.aemSupported && data.hasAnyConfiguration)
-				{
-					auto& logoCache = hive::widgetModelsLibrary::EntityLogoCache::getInstance();
-					return logoCache.getImage(entityID, hive::widgetModelsLibrary::EntityLogoCache::Type::Entity, _automaticEntityLogoDownload);
-				}
-			}
-		}
-		else if (column == ControllerModel::Column::Compatibility)
-		{
-			switch (role)
-			{
-				case la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::LightImageRole):
-				{
-					try
-					{
-						return _compatibilityImagesLight.at(data.compatibility);
-					}
-					catch (std::out_of_range const&)
-					{
-						AVDECC_ASSERT(false, "Image missing");
-						return {};
-					}
-				}
-				case la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::DarkImageRole):
-				{
-					try
-					{
-						return _compatibilityImagesDark.at(data.compatibility);
-					}
-					catch (std::out_of_range const&)
-					{
-						AVDECC_ASSERT(false, "Image missing");
-						return {};
-					}
-				}
-				case Qt::ToolTipRole:
-					switch (data.compatibility)
-					{
-						case Compatibility::Misbehaving:
-							return "Entity is sending incoherent values that can cause undefined behavior";
-						case Compatibility::Milan:
-						case Compatibility::MilanRedundant:
-							return "MILAN compatible";
-						case Compatibility::MilanCertified:
-						case Compatibility::MilanCertifiedRedundant:
-							return "MILAN certified";
-						case Compatibility::MilanWarning:
-						case Compatibility::MilanWarningRedundant:
-							return "MILAN with warnings";
-						case Compatibility::IEEE:
-							return "IEEE 1722.1 compatible";
-						default:
-							return "Not fully IEEE 1722.1 compliant";
-					}
-				default:
-					break;
-			}
-		}
-		else if (column == ControllerModel::Column::AcquireState)
-		{
-			switch (role)
-			{
-				case la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::LightImageRole):
-				case la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::DarkImageRole):
-				{
-					try
-					{
-						return _excusiveAccessStateImages.at(data.acquireState);
-					}
-					catch (std::out_of_range const&)
-					{
-						AVDECC_ASSERT(false, "Image missing");
-						return {};
-					}
-				}
-				case Qt::ToolTipRole:
-					return data.acquireStateTooltip;
-				default:
-					break;
-			}
-		}
-		else if (column == ControllerModel::Column::LockState)
-		{
-			switch (role)
-			{
-				case la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::LightImageRole):
-				case la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::DarkImageRole):
-				{
-					try
-					{
-						return _excusiveAccessStateImages.at(data.lockState);
-					}
-					catch (std::out_of_range const&)
-					{
-						AVDECC_ASSERT(false, "Image missing");
-						return {};
-					}
-				}
-				case Qt::ToolTipRole:
-					return data.lockStateTooltip;
-				default:
-					break;
-			}
-		}
-		else if (role == Qt::ToolTipRole)
-		{
-			switch (column)
-			{
-				case ControllerModel::Column::GrandmasterID:
-				case ControllerModel::Column::GptpDomain:
-				case ControllerModel::Column::InterfaceIndex:
-					return data.gptpTooltip;
-				default:
-					break;
-			}
-		}
-
-		return {};
-	}
-
-	QVariant headerData(int section, Qt::Orientation orientation, int role) const
-	{
-		if (orientation == Qt::Horizontal)
-		{
-			if (role == Qt::DisplayRole)
-			{
-				switch (static_cast<ControllerModel::Column>(section))
-				{
-					case ControllerModel::Column::EntityLogo:
-						return "Logo";
-					case ControllerModel::Column::Compatibility:
-						return "Compat";
-					case ControllerModel::Column::EntityID:
-						return "Entity ID";
-					case ControllerModel::Column::Name:
-						return "Name";
-					case ControllerModel::Column::Group:
-						return "Group";
-					case ControllerModel::Column::AcquireState:
-						return "Acquire State";
-					case ControllerModel::Column::LockState:
-						return "Lock State";
-					case ControllerModel::Column::GrandmasterID:
-						return "Grandmaster ID";
-					case ControllerModel::Column::GptpDomain:
-						return "GPTP Domain";
-					case ControllerModel::Column::InterfaceIndex:
-						return "Interface Index";
-					case ControllerModel::Column::AssociationID:
-						return "Association ID";
-					case ControllerModel::Column::MediaClockMasterID:
-						return "Media Clock Master ID";
-					case ControllerModel::Column::MediaClockMasterName:
-						return "Media Clock Master Name";
-					default:
-						break;
-				}
-			}
-		}
-
-		return {};
-	}
-
-	la::avdecc::UniqueIdentifier controlledEntityID(QModelIndex const& index) const
-	{
-		auto const row = index.row();
-		if (row >= 0 && row < rowCount())
-		{
-			return _entities[index.row()].entityID;
-		}
-		return la::avdecc::UniqueIdentifier{};
-	}
-
-private:
-	class EntityData
-	{
-	public:
-		EntityData(la::avdecc::UniqueIdentifier const& entityID, la::avdecc::controller::ControlledEntity const& controlledEntity, la::avdecc::entity::Entity const& entity)
-			: entityID{ entityID }
-			, name{ hive::modelsLibrary::helper::entityName(controlledEntity) }
-			, groupName{ hive::modelsLibrary::helper::groupName(controlledEntity) }
-			, acquireState{ computeAcquireState(controlledEntity.getAcquireState()) }
-			, acquireStateTooltip{ helper::acquireStateToString(controlledEntity.getAcquireState(), controlledEntity.getOwningControllerID()) }
-			, lockState{ computeLockState(controlledEntity.getLockState()) }
-			, lockStateTooltip{ helper::lockStateToString(controlledEntity.getLockState(), controlledEntity.getLockingControllerID()) }
-			, compatibility{ computeCompatibility(controlledEntity.getMilanInfo(), controlledEntity.getCompatibilityFlags()) }
-			, aemSupported{ entity.getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported) }
-			, hasAnyConfiguration{ controlledEntity.hasAnyConfiguration() }
-			, gptpInfoMap{ buildGptpInfoMap(entity.getInterfacesInformation()) }
-			, gptpTooltip{ computeGptpTooltip(gptpInfoMap) }
-			, associationID{ entity.getAssociationID() }
-			, mediaClockInfo{ computeMediaClockInfo(entityID) }
-		{
-		}
-
-	public:
-		la::avdecc::UniqueIdentifier entityID;
-
-		QString name{};
-		QString groupName{};
-
-		ExclusiveAccessState acquireState{};
-		QString acquireStateTooltip{};
-
-		ExclusiveAccessState lockState{};
-		QString lockStateTooltip{};
-
-		Compatibility compatibility{};
-
-		bool aemSupported{ false };
-		bool hasAnyConfiguration{ false };
-
-		GptpInfoPerAvbInterfaceIndex gptpInfoMap{};
-		QString gptpTooltip{};
-
-		std::optional<la::avdecc::UniqueIdentifier> associationID{};
-
-		MediaClockInfo mediaClockInfo{};
-
-		// Helper methods
-
-		QString gptpGrandmasterIDToString() const
-		{
-			try
-			{
-				auto const& [avbInterfaceIndex, info] = *gptpInfoMap.begin();
-				return info.grandmasterID ? hive::modelsLibrary::helper::uniqueIdentifierToString(*info.grandmasterID) : "Not Set";
-			}
-			catch (...)
-			{
-				return "Err";
-			}
-		}
-
-		QString gptpDomainNumberToString() const
-		{
-			try
-			{
-				auto const& [avbInterfaceIndex, info] = *gptpInfoMap.begin();
-				return info.domainNumber ? QString::number(*info.domainNumber) : "Not Set";
-			}
-			catch (...)
-			{
-				return "Err";
-			}
-		}
-
-		QString avbInterfaceIndexToString() const
-		{
-			try
-			{
-				auto const& [avbInterfaceIndex, info] = *gptpInfoMap.begin();
-				return avbInterfaceIndex == la::avdecc::entity::Entity::GlobalAvbInterfaceIndex ? "Not Set" : QString::number(avbInterfaceIndex);
-			}
-			catch (...)
-			{
-				return "Err";
-			}
-		}
-
-		QString associationIDToString() const
-		{
-			return associationID ? hive::modelsLibrary::helper::uniqueIdentifierToString(*associationID) : "Not Set";
-		}
-	};
-
-	using Entities = std::vector<EntityData>;
-	using EntityRowMap = std::unordered_map<la::avdecc::UniqueIdentifier, int, la::avdecc::UniqueIdentifier::hash>;
-
-	QModelIndex createIndex(int const row, ControllerModel::Column const column) const
-	{
-		Q_Q(const ControllerModel);
-		return q->createIndex(row, la::avdecc::utils::to_integral(column));
-	}
-
-	void dataChanged(int const row, ControllerModel::Column const column, QVector<int> const& roles = { Qt::DisplayRole })
-	{
-		auto const index = createIndex(row, column);
-		if (index.isValid())
-		{
-			Q_Q(ControllerModel);
-			emit q->dataChanged(index, index, roles);
-		}
-	}
-
-	// hive::modelsLibrary::ControllerManager
-
-	void handleControllerOffline()
-	{
-		Q_Q(ControllerModel);
-
-		q->beginResetModel();
-		_entities.clear();
-		_entityRowMap.clear();
-		_entitiesWithErrorCounter.clear();
-		_identifingEntities.clear();
-		q->endResetModel();
-	}
-
-	void handleEntityOnline(la::avdecc::UniqueIdentifier const& entityID)
-	{
-		try
-		{
-			auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
-			auto controlledEntity = manager.getControlledEntity(entityID);
-			// Check if the entity is actually online (it might happen that the entity quickly switched from online to offline)
-			if (controlledEntity)
-			{
-				Q_Q(ControllerModel);
-
-				// Insert at the end
-				auto const row = rowCount();
-				emit q->beginInsertRows({}, row, row);
-
-				_entities.emplace_back(entityID, *controlledEntity, controlledEntity->getEntity());
-
-				// Update the cache
-				rebuildEntityRowMap();
-
-				emit q->endInsertRows();
-
-				// Trigger Error Counters, Statistics and Diagnostics (because it's not using DisplayRole, it won't be initially checked)
-				handleStatisticsErrorCounterChanged(entityID, manager.getStatisticsCounters(entityID));
-				handleDiagnosticsChanged(entityID, manager.getDiagnostics(entityID));
-				// Identification status cannot be properly detected, will be fixed when using DiscoveredEntitiesModel
-			}
-		}
-		catch (...)
-		{
-			// Uncaught exception
-			AVDECC_ASSERT(false, "Uncaught exception");
-		}
-	}
-
-	void handleEntityOffline(la::avdecc::UniqueIdentifier const& entityID)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			Q_Q(ControllerModel);
-
-			// Notify slots of the model the entity is going offline, BEFORE removing the row
-			emit q->entityOffline(entityID);
-
-			// Remove the row from the model
-			emit q->beginRemoveRows({}, *row, *row);
-
-			// Remove the entity from the model
-			auto const it = std::next(std::begin(_entities), *row);
-			_entities.erase(it);
-
-			// Wipe Errors
-			_entitiesWithErrorCounter.erase(entityID);
-
-			// Update the cache
-			rebuildEntityRowMap();
-
-			emit q->endRemoveRows();
-		}
-	}
-
-	void handleEntityRedundantInterfaceOnline(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, la::avdecc::entity::Entity::InterfaceInformation const& interfaceInfo)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto& data = _entities[*row];
-
-			auto& info = data.gptpInfoMap[avbInterfaceIndex];
-
-			info.grandmasterID = interfaceInfo.gptpGrandmasterID;
-			info.domainNumber = interfaceInfo.gptpDomainNumber;
-
-			data.gptpTooltip = computeGptpTooltip(data.gptpInfoMap);
-
-			dataChanged(*row, ControllerModel::Column::GrandmasterID);
-			dataChanged(*row, ControllerModel::Column::GptpDomain);
-		}
-	}
-
-	void handleEntityRedundantInterfaceOffline(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto& data = _entities[*row];
-
-			if (data.gptpInfoMap.erase(avbInterfaceIndex) == 1)
-			{
-				data.gptpTooltip = computeGptpTooltip(data.gptpInfoMap);
-
-				dataChanged(*row, ControllerModel::Column::GrandmasterID);
-				dataChanged(*row, ControllerModel::Column::GptpDomain);
-			}
-		}
-	}
-
-	void handleAssociationIDChanged(la::avdecc::UniqueIdentifier const& entityID, std::optional<la::avdecc::UniqueIdentifier> const associationID)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto& data = _entities[*row];
-			data.associationID = associationID;
-
-			dataChanged(*row, ControllerModel::Column::AssociationID);
-		}
-	}
-
-	void handleIdentificationStarted(la::avdecc::UniqueIdentifier const& entityID)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			_identifingEntities.insert(entityID);
-			dataChanged(*row, ControllerModel::Column::EntityID, { Qt::FontRole });
-		}
-	}
-
-	void handleIdentificationStopped(la::avdecc::UniqueIdentifier const& entityID)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			_identifingEntities.erase(entityID);
-			dataChanged(*row, ControllerModel::Column::EntityID, { Qt::FontRole });
-		}
-	}
-
-	void handleEntityNameChanged(la::avdecc::UniqueIdentifier const& entityID, QString const& entityName)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto& data = _entities[*row];
-			data.name = entityName;
-
-			dataChanged(*row, ControllerModel::Column::Name);
-		}
-	}
-
-	void handleEntityGroupNameChanged(la::avdecc::UniqueIdentifier const& entityID, QString const& entityGroupName)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto& data = _entities[*row];
-			data.groupName = entityGroupName;
-
-			dataChanged(*row, ControllerModel::Column::Group);
-		}
-	}
-
-	void handleAcquireStateChanged(la::avdecc::UniqueIdentifier const& entityID, la::avdecc::controller::model::AcquireState const acquireState, la::avdecc::UniqueIdentifier const owningEntity)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto& data = _entities[*row];
-
-			data.acquireState = computeAcquireState(acquireState);
-			data.acquireStateTooltip = helper::acquireStateToString(acquireState, owningEntity);
-
-			dataChanged(*row, ControllerModel::Column::AcquireState, { la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::LightImageRole) });
-		}
-	}
-
-	void handleLockStateChanged(la::avdecc::UniqueIdentifier const& entityID, la::avdecc::controller::model::LockState const lockState, la::avdecc::UniqueIdentifier const lockingEntity)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto& data = _entities[*row];
-
-			data.lockState = computeLockState(lockState);
-			data.lockStateTooltip = helper::lockStateToString(lockState, lockingEntity);
-
-			dataChanged(*row, ControllerModel::Column::LockState, { la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::LightImageRole) });
-		}
-	}
-
-	void handleCompatibilityFlagsChanged(la::avdecc::UniqueIdentifier const& entityID, la::avdecc::controller::ControlledEntity::CompatibilityFlags const compatibilityFlags)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto& data = _entities[*row];
-
-			try
-			{
-				auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
-				if (auto controlledEntity = manager.getControlledEntity(entityID))
-				{
-					data.compatibility = computeCompatibility(controlledEntity->getMilanInfo(), compatibilityFlags);
-					dataChanged(*row, ControllerModel::Column::Compatibility);
-				}
-			}
-			catch (...)
-			{
-				//
-			}
-		}
-	}
-
-	void handleGptpChanged(la::avdecc::UniqueIdentifier const& entityID, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, la::avdecc::UniqueIdentifier const grandMasterID, std::uint8_t const grandMasterDomain)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto& data = _entities[*row];
-
-			auto& info = data.gptpInfoMap[avbInterfaceIndex];
-
-			info.grandmasterID = grandMasterID;
-			info.domainNumber = grandMasterDomain;
-
-			data.gptpTooltip = computeGptpTooltip(data.gptpInfoMap);
-
-			dataChanged(*row, ControllerModel::Column::GrandmasterID);
-			dataChanged(*row, ControllerModel::Column::GptpDomain);
-		}
-	}
-
-	void handleStreamInputErrorCounterChanged(la::avdecc::UniqueIdentifier const& entityID, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, hive::modelsLibrary::ControllerManager::StreamInputErrorCounters const& errorCounters)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			if (!errorCounters.empty())
-			{
-				_entitiesWithErrorCounter[entityID].streamsWithErrorCounter.insert(descriptorIndex);
-			}
-			else
-			{
-				_entitiesWithErrorCounter[entityID].streamsWithErrorCounter.erase(descriptorIndex);
-			}
-
-			dataChanged(*row, ControllerModel::Column::EntityID);
-		}
-	}
-
-	void handleStatisticsErrorCounterChanged(la::avdecc::UniqueIdentifier const entityID, hive::modelsLibrary::ControllerManager::StatisticsErrorCounters const& errorCounters)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			_entitiesWithErrorCounter[entityID].statisticsError = !errorCounters.empty();
-
-			dataChanged(*row, ControllerModel::Column::EntityID);
-		}
-	}
-
-	void handleDiagnosticsChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::controller::ControlledEntity::Diagnostics const& diagnostics)
-	{
-		if (auto const row = entityRow(entityID))
-		{
-			auto const wasRedundancyWarning = _entitiesWithErrorCounter[entityID].redundancyWarning;
-			auto const wasStreamInputLatencyError = !_entitiesWithErrorCounter[entityID].streamsWithLatencyError.empty();
-
-			auto nowRedundancyWarning = false;
-			auto nowStreamInputLatencyError = false;
-
-			// Redundancy Warning
-			{
-				_entitiesWithErrorCounter[entityID].redundancyWarning = diagnostics.redundancyWarning;
-				nowRedundancyWarning = diagnostics.redundancyWarning;
-			}
-
-			// Stream Input Latency Error
-			{
-				_entitiesWithErrorCounter[entityID].streamsWithLatencyError = diagnostics.streamInputOverLatency;
-				nowStreamInputLatencyError = !_entitiesWithErrorCounter[entityID].streamsWithLatencyError.empty();
-			}
-
-			if ((wasRedundancyWarning != nowRedundancyWarning) || (wasStreamInputLatencyError != nowStreamInputLatencyError))
-			{
-				dataChanged(*row, ControllerModel::Column::EntityID);
-			}
-		}
-	}
-
-	// avdecc::mediaClock::MCDomainManager
-
-	void handleMediaClockConnectionsUpdated(std::vector<la::avdecc::UniqueIdentifier> const& changedEntities)
-	{
-		for (auto const& entityID : changedEntities)
-		{
-			if (auto const row = entityRow(entityID))
-			{
-				auto& data = _entities[*row];
-
-				data.mediaClockInfo = computeMediaClockInfo(entityID);
-
-				dataChanged(*row, ControllerModel::Column::MediaClockMasterID);
-				dataChanged(*row, ControllerModel::Column::MediaClockMasterName);
-			}
-		}
-	}
-
-	void handleMcMasterNameChanged(std::vector<la::avdecc::UniqueIdentifier> const& changedEntities)
-	{
-		for (auto const& entityID : changedEntities)
-		{
-			if (auto const row = entityRow(entityID))
-			{
-				auto& data = _entities[*row];
-
-				data.mediaClockInfo = computeMediaClockInfo(entityID);
-
-				dataChanged(*row, ControllerModel::Column::MediaClockMasterName);
-			}
-		}
-	}
-
-	// EntityLogoCache
-
-	void handleImageChanged(la::avdecc::UniqueIdentifier const& entityID, hive::widgetModelsLibrary::EntityLogoCache::Type const type)
-	{
-		if (type == hive::widgetModelsLibrary::EntityLogoCache::Type::Entity)
-		{
-			if (auto const row = entityRow(entityID))
-			{
-				dataChanged(*row, ControllerModel::Column::EntityLogo, { la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::LightImageRole) });
-			}
-		}
-	}
-
-	// settings::SettingsManager overrides
-	virtual void onSettingChanged(settings::SettingsManager::Setting const& name, QVariant const& value) noexcept override
-	{
-		if (name == settings::General_AutomaticPNGDownloadEnabled.name)
-		{
-			_automaticEntityLogoDownload = value.toBool();
-			if (_automaticEntityLogoDownload)
-			{
-				Q_Q(ControllerModel);
-
-				auto constexpr column = la::avdecc::utils::to_integral(ControllerModel::Column::EntityLogo);
-
-				auto const topLeft = q->createIndex(0, column, nullptr);
-				auto const bottomRight = q->createIndex(rowCount(), column, nullptr);
-
-				emit q->dataChanged(topLeft, bottomRight, { la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::LightImageRole) });
-			}
-		}
-		else if (name == settings::General_ThemeColorIndex.name)
-		{
-			//auto const colorName = qtMate::material::color::Palette::name(value.toInt());
-			//_errorColorValue = qtMate::material::color::foregroundErrorColorValue(colorName, qtMate::material::color::Shade::ShadeA700);
-			_errorColorValue = qtMate::material::color::foregroundErrorColorValue(qtMate::material::color::DefaultColor, qtMate::material::color::DefaultShade); // Right now, always use default value, as we draw on white background
-
-			Q_Q(ControllerModel);
-
-			auto constexpr column = la::avdecc::utils::to_integral(ControllerModel::Column::EntityID);
-
-			auto const topLeft = q->createIndex(0, column, nullptr);
-			auto const bottomRight = q->createIndex(rowCount(), column, nullptr);
-
-			emit q->dataChanged(topLeft, bottomRight, { Qt::ForegroundRole });
-		}
-	}
-
-	// Build the entityID to row map
-	void rebuildEntityRowMap()
-	{
-		_entityRowMap.clear();
-
-		for (auto row = 0; row < rowCount(); ++row)
-		{
-			auto const& data = _entities[row];
-			_entityRowMap.emplace(std::make_pair(data.entityID, row));
-		}
-	}
-
-	// Returns the entity row if found in the model
-	std::optional<int> entityRow(la::avdecc::UniqueIdentifier const& entityID) const
-	{
-		// Check if the entity is still online
-		if (auto const it = _entityRowMap.find(entityID); it != std::end(_entityRowMap))
-		{
-			return it->second;
-		}
-		return {};
-	}
-
-private:
-	ControllerModel* const q_ptr{ nullptr };
-	Q_DECLARE_PUBLIC(ControllerModel);
-
-	Entities _entities{};
-	EntityRowMap _entityRowMap{};
-	bool _automaticEntityLogoDownload{ false };
-	QColor _errorColorValue{ Qt::red };
-
-	struct EntityWithErrorCounter
-	{
-		bool statisticsError{ false };
-		bool redundancyWarning{ false };
-		std::set<la::avdecc::entity::model::StreamIndex> streamsWithErrorCounter{};
-		std::set<la::avdecc::entity::model::StreamIndex> streamsWithLatencyError{};
-		constexpr bool hasError() const noexcept
-		{
-			return statisticsError || redundancyWarning || !streamsWithErrorCounter.empty() || !streamsWithLatencyError.empty();
-		}
-	};
-	using EntitiesWithErrorCounter = std::unordered_map<la::avdecc::UniqueIdentifier, EntityWithErrorCounter, la::avdecc::UniqueIdentifier::hash>;
-	EntitiesWithErrorCounter _entitiesWithErrorCounter{};
-	std::unordered_set<la::avdecc::UniqueIdentifier, la::avdecc::UniqueIdentifier::hash> _identifingEntities;
-
-	std::unordered_map<Compatibility, QImage> _compatibilityImagesLight{
-		{ Compatibility::NotCompliant, QImage{ ":/not_compliant.png" } },
-		{ Compatibility::IEEE, QImage{ ":/ieee.png" } },
-		{ Compatibility::Milan, QImage{ ":/Milan_Compatible.png" } },
-		{ Compatibility::MilanCertified, QImage{ ":/Milan_Certified.png" } },
-		{ Compatibility::MilanWarning, QImage{ ":/Milan_Compatible_Warning.png" } },
-		{ Compatibility::MilanRedundant, QImage{ ":/Milan_Redundant_Compatible.png" } },
-		{ Compatibility::MilanCertifiedRedundant, QImage{ ":/Milan_Redundant_Certified.png" } },
-		{ Compatibility::MilanWarningRedundant, QImage{ ":/Milan_Redundant_Compatible_Warning.png" } },
-		{ Compatibility::Misbehaving, QImage{ ":/misbehaving.png" } },
-	};
-	std::unordered_map<Compatibility, QImage> _compatibilityImagesDark{
-		{ Compatibility::NotCompliant, QImage{ ":/not_compliant.png" } },
-		{ Compatibility::IEEE, QImage{ ":/ieee.png" } },
-		{ Compatibility::Milan, QImage{ ":/Milan_Compatible_inv.png" } },
-		{ Compatibility::MilanCertified, QImage{ ":/Milan_Certified_inv.png" } },
-		{ Compatibility::MilanWarning, QImage{ ":/Milan_Compatible_Warning_inv.png" } },
-		{ Compatibility::MilanRedundant, QImage{ ":/Milan_Redundant_Compatible_inv.png" } },
-		{ Compatibility::MilanCertifiedRedundant, QImage{ ":/Milan_Redundant_Certified_inv.png" } },
-		{ Compatibility::MilanWarningRedundant, QImage{ ":/Milan_Redundant_Compatible_Warning_inv.png" } },
-		{ Compatibility::Misbehaving, QImage{ ":/misbehaving.png" } },
-	};
-	std::unordered_map<ExclusiveAccessState, QImage> _excusiveAccessStateImages{
-		{ ExclusiveAccessState::NoAccess, QImage{ ":/unlocked.png" } },
-		{ ExclusiveAccessState::NotSupported, QImage{ ":/lock_not_supported.png" } },
-		{ ExclusiveAccessState::AccessOther, QImage{ ":/locked_by_other.png" } },
-		{ ExclusiveAccessState::AccessSelf, QImage{ ":/locked.png" } },
-	};
-};
-
-ControllerModel::ControllerModel(QObject* parent)
-	: QAbstractTableModel{ parent }
-	, d_ptr{ new ControllerModelPrivate(this) }
-{
-}
-
-ControllerModel::~ControllerModel() = default;
-
-int ControllerModel::rowCount(QModelIndex const& /*parent*/) const
-{
-	Q_D(const ControllerModel);
-	return d->rowCount();
-}
-
-int ControllerModel::columnCount(QModelIndex const& /*parent*/) const
-{
-	Q_D(const ControllerModel);
-	return d->columnCount();
-}
-
-QVariant ControllerModel::data(QModelIndex const& index, int role) const
-{
-	Q_D(const ControllerModel);
-	return d->data(index, role);
-}
-
-QVariant ControllerModel::headerData(int section, Qt::Orientation orientation, int role) const
-{
-	Q_D(const ControllerModel);
-	return d->headerData(section, orientation, role);
-}
-
-la::avdecc::UniqueIdentifier ControllerModel::getControlledEntityID(QModelIndex const& index) const
-{
-	Q_D(const ControllerModel);
-	return d->controlledEntityID(index);
-}
-
-} // namespace avdecc
-
-#include "controllerModel.moc"
diff --git a/src/avdecc/controllerModel.hpp b/src/avdecc/controllerModel.hpp
deleted file mode 100644
index 213a179c..00000000
--- a/src/avdecc/controllerModel.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
-* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
-
-* This file is part of Hive.
-
-* Hive is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-
-* Hive is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-
-* You should have received a copy of the GNU Lesser General Public License
-* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#pragma once
-
-#include <QAbstractListModel>
-#include <la/avdecc/controller/avdeccController.hpp>
-
-namespace avdecc
-{
-class ControllerModelPrivate;
-class ControllerModel : public QAbstractTableModel
-{
-	Q_OBJECT
-public:
-	enum class Column
-	{
-		EntityLogo,
-		Compatibility,
-		EntityID,
-		Name,
-		Group,
-		AcquireState,
-		LockState,
-		GrandmasterID,
-		GptpDomain,
-		InterfaceIndex,
-		AssociationID,
-		MediaClockMasterID,
-		MediaClockMasterName,
-
-		Count
-	};
-
-	ControllerModel(QObject* parent = nullptr);
-	virtual ~ControllerModel();
-
-	virtual int rowCount(QModelIndex const& parent = {}) const override;
-	virtual int columnCount(QModelIndex const& parent = {}) const override;
-	virtual QVariant data(QModelIndex const& index, int role = Qt::DisplayRole) const override;
-	virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
-
-	// Helpers
-	la::avdecc::UniqueIdentifier getControlledEntityID(QModelIndex const& index) const;
-
-	// Signals
-	// Notification for when the entity is going offline, BEFORE any model notifications for removed rows
-	Q_SIGNAL void entityOffline(la::avdecc::UniqueIdentifier const entityID);
-
-private:
-	QScopedPointer<ControllerModelPrivate> const d_ptr;
-	Q_DECLARE_PRIVATE(ControllerModel)
-};
-
-} // namespace avdecc
diff --git a/src/avdecc/helper.cpp b/src/avdecc/helper.cpp
index c2db8223..ea364bf5 100644
--- a/src/avdecc/helper.cpp
+++ b/src/avdecc/helper.cpp
@@ -238,9 +238,9 @@ QString streamFormatToString(la::avdecc::entity::model::StreamFormatInfo const&
 
 QString clockSourceToString(la::avdecc::controller::model::ClockSourceNode const& node) noexcept
 {
-	auto const* const descriptor = node.staticModel;
+	auto const& descriptor = node.staticModel;
 
-	return avdecc::helper::clockSourceTypeToString(descriptor->clockSourceType) + ", " + avdecc::helper::descriptorTypeToString(descriptor->clockSourceLocationType) + ":" + QString::number(descriptor->clockSourceLocationIndex);
+	return avdecc::helper::clockSourceTypeToString(descriptor.clockSourceType) + ", " + avdecc::helper::descriptorTypeToString(descriptor.clockSourceLocationType) + ":" + QString::number(descriptor.clockSourceLocationIndex);
 }
 
 inline void concatenateFlags(QString& flags, QString const& flag) noexcept
@@ -250,6 +250,21 @@ inline void concatenateFlags(QString& flags, QString const& flag) noexcept
 	flags += flag;
 }
 
+QString flagsToString(la::avdecc::entity::JackFlags const flags) noexcept
+{
+	QString str;
+
+	if (flags.empty())
+		return "None";
+
+	if (flags.test(la::avdecc::entity::JackFlag::ClockSyncSource))
+		concatenateFlags(str, "ClockSyncSource");
+	if (flags.test(la::avdecc::entity::JackFlag::Captive))
+		concatenateFlags(str, "Captive");
+
+	return str;
+}
+
 QString flagsToString(la::avdecc::entity::AvbInterfaceFlags const flags) noexcept
 {
 	QString str;
@@ -546,6 +561,94 @@ QString capabilitiesToString(la::avdecc::entity::ControllerCapabilities const ca
 	return str;
 }
 
+QString jackTypeToString(la::avdecc::entity::model::JackType const type) noexcept
+{
+	switch (type)
+	{
+		case la::avdecc::entity::model::JackType::Speaker:
+			return "Speaker";
+		case la::avdecc::entity::model::JackType::Headphone:
+			return "Headphone";
+		case la::avdecc::entity::model::JackType::AnalogMicrophone:
+			return "Analog Microphone";
+		case la::avdecc::entity::model::JackType::Spdif:
+			return "S/PDIF";
+		case la::avdecc::entity::model::JackType::Adat:
+			return "ADAT";
+		case la::avdecc::entity::model::JackType::Tdif:
+			return "TDIF";
+		case la::avdecc::entity::model::JackType::Madi:
+			return "MADI";
+		case la::avdecc::entity::model::JackType::UnbalancedAnalog:
+			return "Generic Unbalanced Analog";
+		case la::avdecc::entity::model::JackType::BalancedAnalog:
+			return "Generic Balanced Analog";
+		case la::avdecc::entity::model::JackType::Digital:
+			return "Generic Digital";
+		case la::avdecc::entity::model::JackType::Midi:
+			return "MIDI";
+		case la::avdecc::entity::model::JackType::AesEbu:
+			return "AES/EBU";
+		case la::avdecc::entity::model::JackType::CompositeVideo:
+			return "Composite Video";
+		case la::avdecc::entity::model::JackType::SVhsVideo:
+			return "S-VHS Video";
+		case la::avdecc::entity::model::JackType::ComponentVideo:
+			return "Component Video";
+		case la::avdecc::entity::model::JackType::Dvi:
+			return "DVI";
+		case la::avdecc::entity::model::JackType::Hdmi:
+			return "HDMI";
+		case la::avdecc::entity::model::JackType::Udi:
+			return "UDI";
+		case la::avdecc::entity::model::JackType::DisplayPort:
+			return "DisplayPort";
+		case la::avdecc::entity::model::JackType::Antenna:
+			return "Antenna";
+		case la::avdecc::entity::model::JackType::AnalogTuner:
+			return "Analog Tuner";
+		case la::avdecc::entity::model::JackType::Ethernet:
+			return "Non-AVB Ethernet";
+		case la::avdecc::entity::model::JackType::Wifi:
+			return "Non-AVB Wi-Fi";
+		case la::avdecc::entity::model::JackType::Usb:
+			return "USB";
+		case la::avdecc::entity::model::JackType::Pci:
+			return "PCI";
+		case la::avdecc::entity::model::JackType::PciE:
+			return "PCI-Express";
+		case la::avdecc::entity::model::JackType::Scsi:
+			return "SCSI";
+		case la::avdecc::entity::model::JackType::Ata:
+			return "ATA";
+		case la::avdecc::entity::model::JackType::Imager:
+			return "Camera Imager";
+		case la::avdecc::entity::model::JackType::Ir:
+			return "Infra-Red";
+		case la::avdecc::entity::model::JackType::Thunderbolt:
+			return "Thunderbolt";
+		case la::avdecc::entity::model::JackType::Sata:
+			return "SATA";
+		case la::avdecc::entity::model::JackType::SmpteLtc:
+			return "SMPTE Linear Time Code";
+		case la::avdecc::entity::model::JackType::DigitalMicrophone:
+			return "Digital Microphone";
+		case la::avdecc::entity::model::JackType::AudioMediaClock:
+			return "Audio Media Clock";
+		case la::avdecc::entity::model::JackType::VideoMediaClock:
+			return "Video Media Clock";
+		case la::avdecc::entity::model::JackType::GnssClock:
+			return "Global Navigation Satellite System Clock";
+		case la::avdecc::entity::model::JackType::Pps:
+			return "Pulse Per Second";
+		case la::avdecc::entity::model::JackType::Expansion:
+			return "Expansion";
+		default:
+			AVDECC_ASSERT(false, "Not handled!");
+	}
+	return "Unknown";
+}
+
 QString clockSourceTypeToString(la::avdecc::entity::model::ClockSourceType const type) noexcept
 {
 	switch (type)
diff --git a/src/avdecc/helper.hpp b/src/avdecc/helper.hpp
index bbe5a965..383a48a5 100644
--- a/src/avdecc/helper.hpp
+++ b/src/avdecc/helper.hpp
@@ -46,6 +46,7 @@ QString samplingRateToString(la::avdecc::entity::model::SamplingRate const& samp
 QString streamFormatToString(la::avdecc::entity::model::StreamFormatInfo const& format) noexcept;
 QString clockSourceToString(la::avdecc::controller::model::ClockSourceNode const& node) noexcept;
 
+QString flagsToString(la::avdecc::entity::JackFlags const flags) noexcept;
 QString flagsToString(la::avdecc::entity::AvbInterfaceFlags const flags) noexcept;
 QString flagsToString(la::avdecc::entity::AvbInfoFlags const flags) noexcept;
 QString flagsToString(la::avdecc::entity::ClockSourceFlags const flags) noexcept;
@@ -62,6 +63,7 @@ QString capabilitiesToString(la::avdecc::entity::TalkerCapabilities const caps)
 QString capabilitiesToString(la::avdecc::entity::ListenerCapabilities const caps) noexcept;
 QString capabilitiesToString(la::avdecc::entity::ControllerCapabilities const caps) noexcept;
 
+QString jackTypeToString(la::avdecc::entity::model::JackType const type) noexcept;
 QString clockSourceTypeToString(la::avdecc::entity::model::ClockSourceType const type) noexcept;
 QString audioClusterFormatToString(la::avdecc::entity::model::AudioClusterFormat const format) noexcept;
 QString controlTypeToString(la::avdecc::entity::model::ControlType const& controlType) noexcept;
diff --git a/src/avdecc/mappingsHelper.cpp b/src/avdecc/mappingsHelper.cpp
index 76226747..ea0fd4eb 100644
--- a/src/avdecc/mappingsHelper.cpp
+++ b/src/avdecc/mappingsHelper.cpp
@@ -24,31 +24,63 @@
 
 #include <QMessageBox>
 
+#include <map>
+#include <utility>
+
 namespace avdecc
 {
 namespace mappingsHelper
 {
-struct NodeMapping
+struct StreamNodeMapping
+{
+	la::avdecc::entity::model::StreamIndex streamIndex{ la::avdecc::entity::model::getInvalidDescriptorIndex() };
+	std::vector<std::uint16_t> channels{};
+
+	// Comparison operator
+	friend bool operator==(StreamNodeMapping const& lhs, StreamNodeMapping const& rhs)
+	{
+		return lhs.streamIndex == rhs.streamIndex && lhs.channels == rhs.channels;
+	}
+};
+
+struct ClusterNodeMapping
 {
-	la::avdecc::entity::model::DescriptorIndex descriptorIndex{ la::avdecc::entity::model::DescriptorIndex{ 0u } };
+	la::avdecc::entity::model::StreamPortIndex streamPortIndex{ la::avdecc::entity::model::getInvalidDescriptorIndex() };
+	la::avdecc::entity::model::ClusterIndex clusterOffset{ la::avdecc::entity::model::getInvalidDescriptorIndex() }; // Offset from baseCluster
 	std::vector<std::uint16_t> channels{};
+
+	// Comparison operator
+	friend bool operator==(ClusterNodeMapping const& lhs, ClusterNodeMapping const& rhs)
+	{
+		return lhs.streamPortIndex == rhs.streamPortIndex && lhs.clusterOffset == rhs.clusterOffset && lhs.channels == rhs.channels;
+	}
+};
+
+struct StreamInputNodeUserData
+{
+	bool isConnected{ false };
+};
+
+struct StreamOutputNodeUserData
+{
+	bool isStreaming{ false };
 };
-using NodeMappings = std::vector<NodeMapping>;
+
+using StreamNodeMappings = std::vector<StreamNodeMapping>;
+using ClusterNodeMappings = std::vector<ClusterNodeMapping>;
 using HashType = std::uint64_t;
 using HashedConnectionsList = std::set<HashType>;
+using StreamPortMappings = std::map<la::avdecc::entity::model::StreamPortIndex, la::avdecc::entity::model::AudioMappings>;
 
 template<class StreamNodeType>
-std::pair<NodeMappings, mappingMatrix::Nodes> buildStreamMappings(la::avdecc::controller::ControlledEntity const* const controlledEntity, std::vector<StreamNodeType const*> const& streamNodes)
+void buildStreamMappings(la::avdecc::controller::ControlledEntity const* const controlledEntity, std::vector<StreamNodeType const*> const& streamNodes, StreamNodeMappings& streamMappings, mappingMatrix::Nodes& streamMatrixNodes)
 {
-	NodeMappings streamMappings;
-	mappingMatrix::Nodes streamMatrixNodes;
-
 	// Build list of stream mappings
 	for (auto const* streamNode : streamNodes)
 	{
 		auto streamName = hive::modelsLibrary::helper::objectName(controlledEntity, *streamNode).toStdString();
-		auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode->dynamicModel->streamFormat);
-		NodeMapping nodeMapping{ streamNode->descriptorIndex };
+		auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode->dynamicModel.streamFormat);
+		StreamNodeMapping nodeMapping{ streamNode->descriptorIndex };
 		mappingMatrix::Node node{ streamName };
 
 		for (auto i = 0u; i < sfi->getChannelsCount(); ++i)
@@ -56,20 +88,43 @@ std::pair<NodeMappings, mappingMatrix::Nodes> buildStreamMappings(la::avdecc::co
 			nodeMapping.channels.push_back(i);
 			node.sockets.push_back("Channel " + std::to_string(i));
 		}
-		streamMappings.push_back(std::move(nodeMapping));
-		streamMatrixNodes.push_back(std::move(node));
+		if constexpr (std::is_same_v<StreamNodeType, la::avdecc::controller::model::StreamInputNode>)
+		{
+			node.userData = StreamInputNodeUserData{ streamNode->dynamicModel.connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected };
+		}
+		else
+		{
+			auto userData = StreamOutputNodeUserData{};
+			if (streamNode->dynamicModel.counters)
+			{
+				try
+				{
+					auto const& counters = *streamNode->dynamicModel.counters;
+					auto const startValue = counters.at(la::avdecc::entity::StreamOutputCounterValidFlag::StreamStart);
+					auto const stopValue = counters.at(la::avdecc::entity::StreamOutputCounterValidFlag::StreamStop);
+					userData.isStreaming = startValue > stopValue;
+				}
+				catch (std::out_of_range const&)
+				{
+					// Ignore
+				}
+			}
+			node.userData = std::move(userData);
+		}
+		// Before adding, search if not already present
+		if (std::find(streamMappings.begin(), streamMappings.end(), nodeMapping) == streamMappings.end())
+		{
+			streamMappings.push_back(std::move(nodeMapping));
+			streamMatrixNodes.push_back(std::move(node));
+		}
 	}
-
-	return std::make_pair(streamMappings, streamMatrixNodes);
 }
 
 template<class StreamNodeType>
-mappingMatrix::Connections buildConnections(la::avdecc::controller::model::StreamPortNode const& streamPortNode, std::vector<StreamNodeType const*> const& streamNodes, NodeMappings const& streamMappings, NodeMappings const& clusterMappings, std::function<mappingMatrix::Connection(mappingMatrix::SlotID const streamSlotID, mappingMatrix::SlotID const clusterSlotID)> const& creationConnectionFunction)
+void buildConnections(la::avdecc::controller::model::StreamPortNode const& streamPortNode, std::vector<StreamNodeType const*> const& streamNodes, StreamNodeMappings const& streamMappings, ClusterNodeMappings const& clusterMappings, std::function<mappingMatrix::Connection(mappingMatrix::SlotID const streamSlotID, mappingMatrix::SlotID const clusterSlotID)> const& creationConnectionFunction, mappingMatrix::Connections& connections)
 {
-	mappingMatrix::Connections connections;
-
 	// Build list of current connections
-	for (auto const& mapping : streamPortNode.dynamicModel->dynamicAudioMap)
+	for (auto const& mapping : streamPortNode.dynamicModel.dynamicAudioMap)
 	{
 		// Find the existing mapping, as mappingMatrix::SlotID
 		mappingMatrix::SlotID streamSlotID{ -1, -1 };
@@ -91,7 +146,7 @@ mappingMatrix::Connections buildConnections(la::avdecc::controller::model::Strea
 				else if (streamNode->isRedundant)
 				{
 					// The stream is a redundant one and not the primary stream, validate the redundant pair index
-					for (auto const redundantIndex : streamNode->staticModel->redundantStreams)
+					for (auto const redundantIndex : streamNode->staticModel.redundantStreams)
 					{
 						if (streamIndex == redundantIndex)
 						{
@@ -120,7 +175,7 @@ mappingMatrix::Connections buildConnections(la::avdecc::controller::model::Strea
 			// Search for descriptorIndex
 			for (auto const& m : streamMappings)
 			{
-				if (streamIndex == m.descriptorIndex)
+				if (streamIndex == m.streamIndex)
 				{
 					// Now search for channel number
 					if (mapping.streamChannel < m.channels.size())
@@ -137,7 +192,7 @@ mappingMatrix::Connections buildConnections(la::avdecc::controller::model::Strea
 			// Search for descriptorIndex
 			for (auto const& m : clusterMappings)
 			{
-				if (mapping.clusterOffset == m.descriptorIndex)
+				if (mapping.clusterOffset == m.clusterOffset)
 				{
 					// Now search for channel number
 					if (mapping.clusterChannel < m.channels.size())
@@ -154,8 +209,6 @@ mappingMatrix::Connections buildConnections(la::avdecc::controller::model::Strea
 			connections.push_back(creationConnectionFunction(streamSlotID, clusterSlotID));
 		}
 	}
-
-	return connections;
 }
 
 HashType makeHash(mappingMatrix::Connection const& connection)
@@ -234,39 +287,40 @@ mappingMatrix::SlotID getClusterSlotIDFromConnection(mappingMatrix::Connection c
 }
 
 template<la::avdecc::entity::model::DescriptorType StreamPortType>
-la::avdecc::entity::model::AudioMapping convertToAudioMapping(NodeMappings const& streamMappings, NodeMappings const& clusterMappings, mappingMatrix::Connection const& connection)
+std::pair<la::avdecc::entity::model::StreamPortIndex, la::avdecc::entity::model::AudioMapping> convertToAudioMapping(StreamNodeMappings const& streamMappings, ClusterNodeMappings const& clusterMappings, mappingMatrix::Connection const& connection)
 {
 	auto const streamSlotID = getStreamSlotIDFromConnection<StreamPortType>(connection);
 	auto const clusterSlotID = getClusterSlotIDFromConnection<StreamPortType>(connection);
 	auto const& streamMapping = streamMappings[streamSlotID.first];
 	auto const& clusterMapping = clusterMappings[clusterSlotID.first];
 
-	return la::avdecc::entity::model::AudioMapping{ streamMapping.descriptorIndex, static_cast<std::uint16_t>(streamSlotID.second), clusterMapping.descriptorIndex, static_cast<std::uint16_t>(clusterSlotID.second) };
+	return std::make_pair(clusterMapping.streamPortIndex, la::avdecc::entity::model::AudioMapping{ streamMapping.streamIndex, static_cast<std::uint16_t>(streamSlotID.second), clusterMapping.clusterOffset, static_cast<std::uint16_t>(clusterSlotID.second) });
 }
 
 template<la::avdecc::entity::model::DescriptorType StreamPortType>
-la::avdecc::entity::model::AudioMappings convertList(NodeMappings const& streamMappings, NodeMappings const& clusterMappings, HashedConnectionsList const& list)
+StreamPortMappings convertList(StreamNodeMappings const& streamMappings, ClusterNodeMappings const& clusterMappings, HashedConnectionsList const& list)
 {
-	la::avdecc::entity::model::AudioMappings mappings;
+	auto mappings = StreamPortMappings{};
 
 	for (auto const& l : list)
 	{
 		auto const c = unmakeHash(l);
-		mappings.push_back(convertToAudioMapping<StreamPortType>(streamMappings, clusterMappings, c));
+		auto [streamPortIndex, mapping] = convertToAudioMapping<StreamPortType>(streamMappings, clusterMappings, c);
+		mappings[streamPortIndex].emplace_back(std::move(mapping));
 	}
 
 	return mappings;
 };
 
 template<la::avdecc::entity::model::DescriptorType StreamPortType>
-void processNewConnections(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, NodeMappings const& streamMappings, NodeMappings const& clusterMappings, mappingMatrix::Connections const& oldConn, mappingMatrix::Connections const& newConn)
+void processNewConnections(la::avdecc::UniqueIdentifier const entityID, StreamNodeMappings const& streamMappings, ClusterNodeMappings const& clusterMappings, mappingMatrix::Connections const& oldConn, mappingMatrix::Connections const& newConn)
 {
 	// Build lists of mappings to add/remove
 	auto const oldConnections = hashConnectionsList(oldConn);
 	auto const newConnections = hashConnectionsList(newConn);
 
-	la::avdecc::entity::model::AudioMappings toRemove{};
-	la::avdecc::entity::model::AudioMappings toAdd{};
+	auto toRemove = StreamPortMappings{};
+	auto toAdd = StreamPortMappings{};
 
 	if constexpr (StreamPortType == la::avdecc::entity::model::DescriptorType::StreamPortInput)
 	{
@@ -283,70 +337,73 @@ void processNewConnections(la::avdecc::UniqueIdentifier const entityID, la::avde
 	auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
 	if (!toRemove.empty())
 	{
-		auto const countMappings = toRemove.size();
-		auto offset = decltype(countMappings){ 0u };
-		while (offset < countMappings)
+		for (auto const& [streamPortIndex, mappings] : toRemove)
 		{
-			auto const mappings = getMaximumAudioMappings(toRemove, offset);
-			auto const count = mappings.size();
-			if (!AVDECC_ASSERT_WITH_RET(count != 0, "Should have at least one mapping to change"))
+			auto const countMappings = mappings.size();
+			auto offset = decltype(countMappings){ 0u };
+			while (offset < countMappings)
 			{
-				break;
-			}
-			offset += count;
+				auto const m = getMaximumAudioMappings(mappings, offset);
+				auto const count = m.size();
+				if (!AVDECC_ASSERT_WITH_RET(count != 0, "Should have at least one mapping to change"))
+				{
+					break;
+				}
+				offset += count;
 
-			if constexpr (StreamPortType == la::avdecc::entity::model::DescriptorType::StreamPortInput)
-			{
-				manager.removeStreamPortInputAudioMappings(entityID, streamPortIndex, mappings);
-			}
-			else if constexpr (StreamPortType == la::avdecc::entity::model::DescriptorType::StreamPortOutput)
-			{
-				manager.removeStreamPortOutputAudioMappings(entityID, streamPortIndex, mappings);
+				if constexpr (StreamPortType == la::avdecc::entity::model::DescriptorType::StreamPortInput)
+				{
+					manager.removeStreamPortInputAudioMappings(entityID, streamPortIndex, m);
+				}
+				else if constexpr (StreamPortType == la::avdecc::entity::model::DescriptorType::StreamPortOutput)
+				{
+					manager.removeStreamPortOutputAudioMappings(entityID, streamPortIndex, m);
+				}
 			}
 		}
 	}
 	if (!toAdd.empty())
 	{
-		auto const countMappings = toAdd.size();
-		auto offset = decltype(countMappings){ 0u };
-		while (offset < countMappings)
+		for (auto const& [streamPortIndex, mappings] : toAdd)
 		{
-			auto const mappings = getMaximumAudioMappings(toAdd, offset);
-			auto const count = mappings.size();
-			if (!AVDECC_ASSERT_WITH_RET(count != 0, "Should have at least one mapping to change"))
+			auto const countMappings = mappings.size();
+			auto offset = decltype(countMappings){ 0u };
+			while (offset < countMappings)
 			{
-				break;
-			}
-			offset += count;
+				auto const m = getMaximumAudioMappings(mappings, offset);
+				auto const count = m.size();
+				if (!AVDECC_ASSERT_WITH_RET(count != 0, "Should have at least one mapping to change"))
+				{
+					break;
+				}
+				offset += count;
 
-			if constexpr (StreamPortType == la::avdecc::entity::model::DescriptorType::StreamPortInput)
-			{
-				manager.addStreamPortInputAudioMappings(entityID, streamPortIndex, mappings);
-			}
-			else if constexpr (StreamPortType == la::avdecc::entity::model::DescriptorType::StreamPortOutput)
-			{
-				manager.addStreamPortOutputAudioMappings(entityID, streamPortIndex, mappings);
+				if constexpr (StreamPortType == la::avdecc::entity::model::DescriptorType::StreamPortInput)
+				{
+					manager.addStreamPortInputAudioMappings(entityID, streamPortIndex, m);
+				}
+				else if constexpr (StreamPortType == la::avdecc::entity::model::DescriptorType::StreamPortOutput)
+				{
+					manager.addStreamPortOutputAudioMappings(entityID, streamPortIndex, m);
+				}
 			}
 		}
 	}
 }
 
-std::pair<NodeMappings, mappingMatrix::Nodes> buildClusterMappings(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::StreamPortNode const& streamPortNode)
+void buildClusterMappings(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::StreamPortNode const& streamPortNode, ClusterNodeMappings& clusterMappings, mappingMatrix::Nodes& clusterMatrixNodes)
 {
-	NodeMappings clusterMappings;
-	mappingMatrix::Nodes clusterMatrixNodes;
-
 	// Build list of cluster mappings
 	for (auto const& clusterKV : streamPortNode.audioClusters)
 	{
-		auto const clusterIndex = static_cast<la::avdecc::entity::model::ClusterIndex>(clusterKV.first - streamPortNode.staticModel->baseCluster); // Mappings use relative index (see IEEE1722.1 Table 7.33)
-		AVDECC_ASSERT(clusterIndex < streamPortNode.staticModel->numberOfClusters, "ClusterIndex invalid");
+		auto const clusterOffset = static_cast<la::avdecc::entity::model::ClusterIndex>(clusterKV.first - streamPortNode.staticModel.baseCluster); // Mappings use relative index (see IEEE1722.1 Table 7.33)
+		AVDECC_ASSERT(clusterOffset < streamPortNode.staticModel.numberOfClusters, "ClusterOffset invalid");
 		auto const& clusterNode = clusterKV.second;
 		auto clusterName = hive::modelsLibrary::helper::objectName(controlledEntity, clusterNode).toStdString();
-		NodeMapping nodeMapping{ clusterIndex };
+		ClusterNodeMapping nodeMapping{ streamPortNode.descriptorIndex, clusterOffset };
 		mappingMatrix::Node node{ clusterName };
 
-		for (auto i = 0u; i < clusterNode.staticModel->channelCount; ++i)
+		for (auto i = 0u; i < clusterNode.staticModel.channelCount; ++i)
 		{
 			nodeMapping.channels.push_back(i);
 			node.sockets.push_back("Channel " + std::to_string(i));
@@ -354,12 +411,73 @@ std::pair<NodeMappings, mappingMatrix::Nodes> buildClusterMappings(la::avdecc::c
 		clusterMappings.push_back(std::move(nodeMapping));
 		clusterMatrixNodes.push_back(std::move(node));
 	}
+}
+
+template<class StreamNodeType, class RedundantStreamNodeType>
+std::vector<StreamNodeType const*> buildStreamsListToDisplay(la::avdecc::entity::model::StreamIndex const streamIndex, std::map<la::avdecc::entity::model::StreamIndex, StreamNodeType> const& streamNodes, std::map<la::avdecc::controller::model::VirtualIndex, RedundantStreamNodeType> const& redundantStreamNodes, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex)
+{
+	auto streamNodesToDisplay = std::vector<StreamNodeType const*>{};
+
+	auto const isValidClockDomain = [](auto const clockDomainIndex, auto const& streamNode)
+	{
+		return clockDomainIndex == streamNode.staticModel.clockDomainIndex;
+	};
+
+	auto const isValidStreamFormat = [](auto const& streamNode)
+	{
+		auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode.dynamicModel.streamFormat);
+
+		return sfi->getChannelsCount() > 0;
+	};
+
+	auto const checkAddStream = [&isValidClockDomain, &isValidStreamFormat, &streamNodesToDisplay](auto const streamIndex, auto const clockDomainIndex, auto const& streamNode, auto const& redundantStreamNodes)
+	{
+		if (isValidStreamFormat(streamNode) && isValidClockDomain(clockDomainIndex, streamNode))
+		{
+			// Add single Stream
+			if (!streamNode.isRedundant)
+			{
+				streamNodesToDisplay.push_back(&streamNode);
+			}
+			else
+			{
+				// Add primary stream of a Redundant Set
+				for (auto const& redundantStreamKV : redundantStreamNodes)
+				{
+					auto const& redundantStreamNode = redundantStreamKV.second;
+					if (redundantStreamNode.primaryStreamIndex == streamIndex)
+					{
+						streamNodesToDisplay.push_back(&streamNode);
+					}
+				}
+			}
+		}
+	};
+
+	if (streamIndex != la::avdecc::entity::model::getInvalidDescriptorIndex())
+	{
+		auto const& streamNode = streamNodes.at(streamIndex);
+
+		if (isValidStreamFormat(streamNode) && isValidClockDomain(clockDomainIndex, streamNode))
+		{
+			checkAddStream(streamIndex, clockDomainIndex, streamNode, redundantStreamNodes);
+		}
+	}
+	else
+	{
+		// Build list of StreamInput (single and primary)
+		for (auto const& [strIndex, strNode] : streamNodes)
+		{
+			checkAddStream(strIndex, clockDomainIndex, strNode, redundantStreamNodes);
+		}
+	}
 
-	return std::make_pair(clusterMappings, clusterMatrixNodes);
+	return streamNodesToDisplay;
 }
 
-void showMappingsEditor(QObject* obj, la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::StreamIndex const streamIndex) noexcept
+void showMappingsEditor(QObject* obj, la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::DescriptorType const streamPortType, std::optional<la::avdecc::entity::model::StreamPortIndex> const streamPortIndex, la::avdecc::entity::model::StreamIndex const streamIndex) noexcept
 {
+	AVDECC_ASSERT(audioUnitIndex != la::avdecc::entity::model::getInvalidDescriptorIndex(), "Invalid AudioUnitIndex");
 	if (AVDECC_ASSERT_WITH_RET(streamPortType == la::avdecc::entity::model::DescriptorType::StreamPortOutput || streamIndex == la::avdecc::entity::model::getInvalidDescriptorIndex(), "StreamPortInput shall not specify a StreamIndex"))
 	{
 		try
@@ -371,152 +489,87 @@ void showMappingsEditor(QObject* obj, la::avdecc::UniqueIdentifier const entityI
 			{
 				auto const* const entity = controlledEntity.get();
 				auto const& entityNode = entity->getEntityNode();
-				auto const& configurationNode = entity->getConfigurationNode(entityNode.dynamicModel->currentConfiguration);
+				auto const currentConfigurationIndex = entityNode.dynamicModel.currentConfiguration;
+				auto const& configurationNode = entity->getConfigurationNode(currentConfigurationIndex);
+				auto const& audioUnitNode = entity->getAudioUnitNode(currentConfigurationIndex, audioUnitIndex);
+				auto const clockDomainIndex = audioUnitNode.staticModel.clockDomainIndex;
 				mappingMatrix::Nodes outputs;
 				mappingMatrix::Nodes inputs;
 				mappingMatrix::Connections connections;
-				NodeMappings streamMappings;
-				NodeMappings clusterMappings;
-
-				auto const isValidClockDomain = [](auto const& streamPortNode, auto const& streamNode)
-				{
-					return streamPortNode.staticModel->clockDomainIndex == streamNode.staticModel->clockDomainIndex;
-				};
-
-				auto const isValidStreamFormat = [](auto const& streamNode)
-				{
-					auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode.dynamicModel->streamFormat);
-
-					return sfi->getChannelsCount() > 0;
-				};
+				StreamNodeMappings streamMappings;
+				ClusterNodeMappings clusterMappings;
 
 				if (streamPortType == la::avdecc::entity::model::DescriptorType::StreamPortInput)
 				{
-					auto const& streamPortNode = entity->getStreamPortInputNode(entityNode.dynamicModel->currentConfiguration, streamPortIndex);
-					std::vector<la::avdecc::controller::model::StreamInputNode const*> streamNodes;
-
-					if (streamIndex != la::avdecc::entity::model::getInvalidDescriptorIndex())
+					auto const handleStreamPort = [entity, clockDomainIndex, streamIndex, &configurationNode, &outputs, &inputs, &connections, &streamMappings, &clusterMappings](auto const& streamPortNode)
 					{
-						// Insert single StreamInput to list
-						auto const& streamNode = configurationNode.streamInputs.at(streamIndex);
-						if (!streamNode.isRedundant && isValidStreamFormat(streamNode) && isValidClockDomain(streamPortNode, streamNode))
+						if (streamPortNode.staticModel.clockDomainIndex != clockDomainIndex)
 						{
-							streamNodes.push_back(&streamNode);
+							return;
 						}
+						auto streamNodes = buildStreamsListToDisplay(streamIndex, configurationNode.streamInputs, configurationNode.redundantStreamInputs, clockDomainIndex);
 
-						// Insert single primary stream of a Redundant Set to list
-						for (auto const& redundantStreamKV : configurationNode.redundantStreamInputs)
-						{
-							auto const& redundantStreamNode = redundantStreamKV.second;
-							auto const* const primRedundantStreamNode = static_cast<decltype(streamNodes)::value_type>(redundantStreamNode.primaryStream);
-
-							// we use the redundantStreams to check if our current streamIndex is either prim or sec of it. For mappings edit, we only use prim though.
-							if (redundantStreamNode.redundantStreams.count(streamIndex) && isValidStreamFormat(*primRedundantStreamNode) && isValidClockDomain(streamPortNode, *primRedundantStreamNode))
+						// Build mappingMatrix vectors
+						buildClusterMappings(entity, streamPortNode, clusterMappings, inputs);
+						buildStreamMappings(entity, streamNodes, streamMappings, outputs);
+						buildConnections(streamPortNode, streamNodes, streamMappings, clusterMappings,
+							[](mappingMatrix::SlotID const streamSlotID, mappingMatrix::SlotID const clusterSlotID)
 							{
-								streamNodes.push_back(primRedundantStreamNode);
-								break;
-							}
-						}
+								return std::make_pair(streamSlotID, clusterSlotID);
+							},
+							connections);
+					};
+					if (streamPortIndex)
+					{
+						auto const& streamPortNode = entity->getStreamPortInputNode(currentConfigurationIndex, *streamPortIndex);
+						handleStreamPort(streamPortNode);
 					}
 					else
 					{
-						// Build list of StreamInput
-						for (auto const& streamKV : configurationNode.streamInputs)
-						{
-							auto const& streamNode = streamKV.second;
-							if (!streamNode.isRedundant && isValidStreamFormat(streamNode) && isValidClockDomain(streamPortNode, streamNode))
-							{
-								streamNodes.push_back(&streamNode);
-							}
-						}
-
-						// Add primary stream of a Redundant Set
-						for (auto const& redundantStreamKV : configurationNode.redundantStreamInputs)
+						for (auto const& [streamPortIndex, streamPortNode] : audioUnitNode.streamPortInputs)
 						{
-							auto const& redundantStreamNode = redundantStreamKV.second;
-							auto const* const streamNode = static_cast<decltype(streamNodes)::value_type>(redundantStreamNode.primaryStream);
-							if (isValidStreamFormat(*streamNode) && isValidClockDomain(streamPortNode, *streamNode))
+							if (streamPortNode.staticModel.clockDomainIndex == clockDomainIndex)
 							{
-								streamNodes.push_back(streamNode);
+								handleStreamPort(streamPortNode);
 							}
 						}
 					}
-
-					// Build mappingMatrix vectors
-					auto clusterResult = buildClusterMappings(entity, streamPortNode);
-					clusterMappings = std::move(clusterResult.first);
-					inputs = std::move(clusterResult.second);
-					auto streamResult = buildStreamMappings(entity, streamNodes);
-					streamMappings = std::move(streamResult.first);
-					outputs = std::move(streamResult.second);
-					connections = buildConnections(streamPortNode, streamNodes, streamMappings, clusterMappings,
-						[](mappingMatrix::SlotID const streamSlotID, mappingMatrix::SlotID const clusterSlotID)
-						{
-							return std::make_pair(streamSlotID, clusterSlotID);
-						});
 				}
 				else if (streamPortType == la::avdecc::entity::model::DescriptorType::StreamPortOutput)
 				{
-					auto const& streamPortNode = entity->getStreamPortOutputNode(entityNode.dynamicModel->currentConfiguration, streamPortIndex);
-					std::vector<la::avdecc::controller::model::StreamOutputNode const*> streamNodes;
-
-					if (streamIndex != la::avdecc::entity::model::getInvalidDescriptorIndex())
+					auto const handleStreamPort = [entity, clockDomainIndex, streamIndex, &configurationNode, &outputs, &inputs, &connections, &streamMappings, &clusterMappings](auto const& streamPortNode)
 					{
-						// Insert single StreamOutput to list
-						auto const& streamNode = configurationNode.streamOutputs.at(streamIndex);
-						if (!streamNode.isRedundant && isValidStreamFormat(streamNode) && isValidClockDomain(streamPortNode, streamNode))
-							streamNodes.push_back(&streamNode);
-
-						// Insert single primary stream of a Redundant Set to list
-						for (auto const& redundantStreamKV : configurationNode.redundantStreamOutputs)
+						if (streamPortNode.staticModel.clockDomainIndex != clockDomainIndex)
 						{
-							auto const& redundantStreamNode = redundantStreamKV.second;
-							auto const* const primRedundantStreamNode = static_cast<decltype(streamNodes)::value_type>(redundantStreamNode.primaryStream);
+							return;
+						}
+						auto streamNodes = buildStreamsListToDisplay(streamIndex, configurationNode.streamOutputs, configurationNode.redundantStreamOutputs, clockDomainIndex);
 
-							// we use the redundantStreams to check if our current streamIndex is either prim or sec of it. For mappings edit, we only use prim though.
-							if (redundantStreamNode.redundantStreams.count(streamIndex) && isValidStreamFormat(*primRedundantStreamNode) && isValidClockDomain(streamPortNode, *primRedundantStreamNode))
+						// Build mappingMatrix vectors
+						buildClusterMappings(entity, streamPortNode, clusterMappings, outputs);
+						buildStreamMappings(entity, streamNodes, streamMappings, inputs);
+						buildConnections(streamPortNode, streamNodes, streamMappings, clusterMappings,
+							[](mappingMatrix::SlotID const streamSlotID, mappingMatrix::SlotID const clusterSlotID)
 							{
-								streamNodes.push_back(primRedundantStreamNode);
-								break;
-							}
-						}
+								return std::make_pair(clusterSlotID, streamSlotID);
+							},
+							connections);
+					};
+					if (streamPortIndex)
+					{
+						auto const& streamPortNode = entity->getStreamPortOutputNode(currentConfigurationIndex, *streamPortIndex);
+						handleStreamPort(streamPortNode);
 					}
 					else
 					{
-						// Build list of StreamOutput
-						for (auto const& streamKV : configurationNode.streamOutputs)
+						for (auto const& [streamPortIndex, streamPortNode] : audioUnitNode.streamPortOutputs)
 						{
-							auto const& streamNode = streamKV.second;
-							if (!streamNode.isRedundant && isValidStreamFormat(streamNode) && isValidClockDomain(streamPortNode, streamNode))
+							if (streamPortNode.staticModel.clockDomainIndex == clockDomainIndex)
 							{
-								streamNodes.push_back(&streamNode);
-							}
-						}
-
-						// Add primary stream of a Redundant Set
-						for (auto const& redundantStreamKV : configurationNode.redundantStreamOutputs)
-						{
-							auto const& redundantStreamNode = redundantStreamKV.second;
-							auto const* const streamNode = static_cast<decltype(streamNodes)::value_type>(redundantStreamNode.primaryStream);
-							if (isValidStreamFormat(*streamNode) && isValidClockDomain(streamPortNode, *streamNode))
-							{
-								streamNodes.push_back(streamNode);
+								handleStreamPort(streamPortNode);
 							}
 						}
 					}
-
-					// Build mappingMatrix vectors
-					auto clusterResult = buildClusterMappings(entity, streamPortNode);
-					clusterMappings = std::move(clusterResult.first);
-					outputs = std::move(clusterResult.second);
-					auto streamResult = buildStreamMappings(entity, streamNodes);
-					streamMappings = std::move(streamResult.first);
-					inputs = std::move(streamResult.second);
-					connections = buildConnections(streamPortNode, streamNodes, streamMappings, clusterMappings,
-						[](mappingMatrix::SlotID const streamSlotID, mappingMatrix::SlotID const clusterSlotID)
-						{
-							return std::make_pair(clusterSlotID, streamSlotID);
-						});
 				}
 				else
 				{
@@ -550,23 +603,27 @@ void showMappingsEditor(QObject* obj, la::avdecc::UniqueIdentifier const entityI
 									}
 
 									// Create the dialog
-									auto title = QString("%1 - %2.%3 Dynamic Mappings").arg(smartName).arg(avdecc::helper::descriptorTypeToString(streamPortType)).arg(streamPortIndex);
+									auto title = QString("%1 - %2 Dynamic Mappings").arg(smartName).arg(streamPortType == la::avdecc::entity::model::DescriptorType::StreamPortOutput ? "Output" : "Input");
 									auto dialog = mappingMatrix::MappingMatrixDialog{ title, outputs, inputs, connections };
 
 									if (dialog.exec() == QDialog::Accepted)
 									{
 										if (streamPortType == la::avdecc::entity::model::DescriptorType::StreamPortInput)
 										{
-											processNewConnections<la::avdecc::entity::model::DescriptorType::StreamPortInput>(entityID, streamPortIndex, streamMappings, clusterMappings, connections, dialog.connections());
+											processNewConnections<la::avdecc::entity::model::DescriptorType::StreamPortInput>(entityID, streamMappings, clusterMappings, connections, dialog.connections());
 										}
 										else if (streamPortType == la::avdecc::entity::model::DescriptorType::StreamPortOutput)
 										{
-											processNewConnections<la::avdecc::entity::model::DescriptorType::StreamPortOutput>(entityID, streamPortIndex, streamMappings, clusterMappings, connections, dialog.connections());
+											processNewConnections<la::avdecc::entity::model::DescriptorType::StreamPortOutput>(entityID, streamMappings, clusterMappings, connections, dialog.connections());
 										}
 									}
 								});
 						});
 				}
+				else
+				{
+					QMessageBox::warning(nullptr, QString(""), QString("No editable channel mappings found for AUDIO_UNIT.%1").arg(audioUnitIndex));
+				}
 			}
 		}
 		catch (...)
diff --git a/src/avdecc/mappingsHelper.hpp b/src/avdecc/mappingsHelper.hpp
index f2e5dab7..bc41da18 100644
--- a/src/avdecc/mappingsHelper.hpp
+++ b/src/avdecc/mappingsHelper.hpp
@@ -32,12 +32,13 @@
 #include <set>
 #include <utility>
 #include <QObject>
+#include <optional>
 
 namespace avdecc
 {
 namespace mappingsHelper
 {
-void showMappingsEditor(QObject* obj, la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::StreamIndex const streamIndex) noexcept;
+void showMappingsEditor(QObject* obj, la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::DescriptorType const streamPortType, std::optional<la::avdecc::entity::model::StreamPortIndex> const streamPortIndex, la::avdecc::entity::model::StreamIndex const streamIndex) noexcept;
 la::avdecc::entity::model::AudioMappings getMaximumAudioMappings(la::avdecc::entity::model::AudioMappings const& mappings, size_t const offset) noexcept;
 /** Adds new input audio mappings. Entity is expected to be under ExclusiveAccess. */
 void batchAddInputAudioMappings(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::AudioMappings const& mappings, hive::modelsLibrary::ControllerManager::AddStreamPortInputAudioMappingsHandler const& handler = {}) noexcept;
diff --git a/src/avdecc/mcDomainManager.cpp b/src/avdecc/mcDomainManager.cpp
index 58729e1f..8050d767 100644
--- a/src/avdecc/mcDomainManager.cpp
+++ b/src/avdecc/mcDomainManager.cpp
@@ -222,85 +222,62 @@ class MCDomainManagerImpl final : public MCDomainManager
 				for (auto const& clockDomainKV : configNode.clockDomains)
 				{
 					auto const& clockDomain = clockDomainKV.second;
-					if (clockDomain.dynamicModel)
-					{
-						auto clockSourceIndex = clockDomain.dynamicModel->clockSourceIndex;
-						auto const& activeClockSourceNode = controlledEntity->getClockSourceNode(activeConfigIndex, clockSourceIndex);
+					auto clockSourceIndex = clockDomain.dynamicModel.clockSourceIndex;
+					auto const& activeClockSourceNode = controlledEntity->getClockSourceNode(activeConfigIndex, clockSourceIndex);
 
-						if (!activeClockSourceNode.staticModel)
-						{
+					switch (activeClockSourceNode.staticModel.clockSourceType)
+					{
+						case la::avdecc::entity::model::ClockSourceType::Internal:
+							if (!(searchForSecondaryMcMaster && entityID == currentEntityId))
+							{
+								return std::make_pair(currentEntityId, McDeterminationError::NoError);
+							}
+							break;
+						case la::avdecc::entity::model::ClockSourceType::External:
+							return std::make_pair(currentEntityId, McDeterminationError::ExternalClockSource);
+						case la::avdecc::entity::model::ClockSourceType::InputStream:
+							break;
+						default:
+							error = McDeterminationError::NotSupportedClockSourceType;
 							keepSearching = false;
 							return std::make_pair(la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), error);
-						}
-
-						switch (activeClockSourceNode.staticModel->clockSourceType)
-						{
-							case la::avdecc::entity::model::ClockSourceType::Internal:
-								if (!(searchForSecondaryMcMaster && entityID == currentEntityId))
-								{
-									return std::make_pair(currentEntityId, McDeterminationError::NoError);
-								}
-								break;
-							case la::avdecc::entity::model::ClockSourceType::External:
-								return std::make_pair(currentEntityId, McDeterminationError::ExternalClockSource);
-							case la::avdecc::entity::model::ClockSourceType::InputStream:
-								break;
-							default:
-								error = McDeterminationError::NotSupportedClockSourceType;
-								keepSearching = false;
-								return std::make_pair(la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), error);
-						}
+					}
 
-						// find the relevant clock stream index
-						std::optional<la::avdecc::entity::model::StreamIndex> clockStreamIndex = std::nullopt;
-						if (activeClockSourceNode.staticModel->clockSourceLocationType == la::avdecc::entity::model::DescriptorType::StreamInput)
+					// find the relevant clock stream index
+					std::optional<la::avdecc::entity::model::StreamIndex> clockStreamIndex = std::nullopt;
+					if (activeClockSourceNode.staticModel.clockSourceLocationType == la::avdecc::entity::model::DescriptorType::StreamInput)
+					{
+						// In the case StreamInput as clockSourceLocationType we can get the relevant index directly from the static model
+						clockStreamIndex = activeClockSourceNode.staticModel.clockSourceLocationIndex;
+					}
+					else if (activeClockSourceNode.staticModel.clockSourceType == la::avdecc::entity::model::ClockSourceType::Internal)
+					{
+						// In the case we are searching for a secondary master, we have to get the index by checking all streams if they are a CRF stream.
+						auto indexes = findInputClockStreamIndexInConfiguration(configNode);
+						if (!indexes.empty())
 						{
-							// In the case StreamInput as clockSourceLocationType we can get the relevant index directly from the static model
-							clockStreamIndex = activeClockSourceNode.staticModel->clockSourceLocationIndex;
-						}
-						else if (activeClockSourceNode.staticModel->clockSourceType == la::avdecc::entity::model::ClockSourceType::Internal)
-						{
-							// In the case we are searching for a secondary master, we have to get the index by checking all streams if they are a CRF stream.
-							auto indexes = findInputClockStreamIndexInConfiguration(configNode);
-							if (!indexes.empty())
-							{
-								clockStreamIndex = indexes.at(0);
-							}
+							clockStreamIndex = indexes.at(0);
 						}
+					}
 
-						if (clockStreamIndex)
-						{
-							auto* clockStreamDynModel = controlledEntity->getStreamInputNode(activeConfigIndex, *clockStreamIndex).dynamicModel;
-							if (clockStreamDynModel)
-							{
-								auto connectedTalker = clockStreamDynModel->connectionInfo.talkerStream.entityID;
-								if (!connectedTalker)
-								{
-									error = searchedEntityIds.size() == 1 ? McDeterminationError::StreamNotConnected : McDeterminationError::ParentStreamNotConnected;
-									keepSearching = false;
-									return std::make_pair(la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), error);
-								}
-								if (searchedEntityIds.count(connectedTalker))
-								{
-									// recusion of entity clock stream connections detected
-									return std::make_pair(la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), McDeterminationError::Recursive);
-								}
-								// set the next entity to traverse
-								currentEntityId = connectedTalker;
-								searchedEntityIds.insert(currentEntityId);
-							}
-							else
-							{
-								error = searchedEntityIds.size() == 1 ? McDeterminationError::StreamNotConnected : McDeterminationError::ParentStreamNotConnected;
-								keepSearching = false;
-								return std::make_pair(la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), error);
-							}
-						}
-						else
+					if (clockStreamIndex)
+					{
+						auto& clockStreamDynModel = controlledEntity->getStreamInputNode(activeConfigIndex, *clockStreamIndex).dynamicModel;
+						auto connectedTalker = clockStreamDynModel.connectionInfo.talkerStream.entityID;
+						if (!connectedTalker)
 						{
+							error = searchedEntityIds.size() == 1 ? McDeterminationError::StreamNotConnected : McDeterminationError::ParentStreamNotConnected;
 							keepSearching = false;
 							return std::make_pair(la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), error);
 						}
+						if (searchedEntityIds.count(connectedTalker))
+						{
+							// recusion of entity clock stream connections detected
+							return std::make_pair(la::avdecc::UniqueIdentifier::getNullUniqueIdentifier(), McDeterminationError::Recursive);
+						}
+						// set the next entity to traverse
+						currentEntityId = connectedTalker;
+						searchedEntityIds.insert(currentEntityId);
 					}
 					else
 					{
@@ -675,7 +652,7 @@ class MCDomainManagerImpl final : public MCDomainManager
 						for (auto const& streamInput : configurationNode.streamInputs)
 						{
 							// get the streamformat's corresponding sampling rate by first deriving the pull and base freq vals from streamformatinfo
-							auto const& streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamInput.second.dynamicModel->streamFormat);
+							auto const& streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamInput.second.dynamicModel.streamFormat);
 							if (la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference == streamFormatInfo->getType())
 								continue;
 
@@ -688,7 +665,7 @@ class MCDomainManagerImpl final : public MCDomainManager
 						for (auto const& streamOutput : configurationNode.streamOutputs)
 						{
 							// get the streamformat's corresponding sampling rate by first deriving the pull and base freq vals from streamformatinfo
-							auto const& streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamOutput.second.dynamicModel->streamFormat);
+							auto const& streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamOutput.second.dynamicModel.streamFormat);
 							if (la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference == streamFormatInfo->getType())
 								continue;
 
@@ -759,11 +736,8 @@ class MCDomainManagerImpl final : public MCDomainManager
 		{
 			try
 			{
-				auto* audioUnitDynModel = controlledEntity->getAudioUnitNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, 0).dynamicModel;
-				if (audioUnitDynModel)
-				{
-					return audioUnitDynModel->currentSamplingRate;
-				}
+				auto& audioUnitDynModel = controlledEntity->getAudioUnitNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, 0).dynamicModel;
+				return audioUnitDynModel.currentSamplingRate;
 			}
 			catch (la::avdecc::controller::ControlledEntity::Exception const&)
 			{
@@ -794,7 +768,7 @@ class MCDomainManagerImpl final : public MCDomainManager
 
 					for (auto const& clockSource : configNode.clockSources)
 					{
-						if (clockSource.second.staticModel && clockSource.second.staticModel->clockSourceType == la::avdecc::entity::model::ClockSourceType::InputStream && clockSource.second.staticModel->clockSourceLocationType == la::avdecc::entity::model::DescriptorType::StreamInput && isStreamInputOfType(entityId, clockSource.second.staticModel->clockSourceLocationIndex, la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference))
+						if (clockSource.second.staticModel.clockSourceType == la::avdecc::entity::model::ClockSourceType::InputStream && clockSource.second.staticModel.clockSourceLocationType == la::avdecc::entity::model::DescriptorType::StreamInput && isStreamInputOfType(entityId, clockSource.second.staticModel.clockSourceLocationIndex, la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference))
 						{
 							auto responseHandler = [parentCommandSet, commandIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)
 							{
@@ -842,7 +816,7 @@ class MCDomainManagerImpl final : public MCDomainManager
 
 					for (const auto& clockSource : configNode.clockSources)
 					{
-						if (clockSource.second.staticModel && clockSource.second.staticModel->clockSourceType == la::avdecc::entity::model::ClockSourceType::External)
+						if (clockSource.second.staticModel.clockSourceType == la::avdecc::entity::model::ClockSourceType::External)
 						{
 							auto responseHandler = [parentCommandSet, commandIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)
 							{
@@ -889,7 +863,7 @@ class MCDomainManagerImpl final : public MCDomainManager
 
 					for (auto const& clockSource : configNode.clockSources)
 					{
-						if (clockSource.second.staticModel && clockSource.second.staticModel->clockSourceType == la::avdecc::entity::model::ClockSourceType::Internal)
+						if (clockSource.second.staticModel.clockSourceType == la::avdecc::entity::model::ClockSourceType::Internal)
 						{
 							auto responseHandler = [parentCommandSet, commandIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)
 							{
@@ -1112,14 +1086,11 @@ class MCDomainManagerImpl final : public MCDomainManager
 			{
 				auto const& streamInput = controlledEntity->getStreamInputNode(config.descriptorIndex, streamIndex);
 
-				if (streamInput.dynamicModel)
+				auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamInput.dynamicModel.streamFormat);
+				auto const streamType = streamFormatInfo->getType();
+				if (expectedStreamType == streamType)
 				{
-					auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamInput.dynamicModel->streamFormat);
-					auto const streamType = streamFormatInfo->getType();
-					if (expectedStreamType == streamType)
-					{
-						return true;
-					}
+					return true;
 				}
 			}
 			catch (la::avdecc::controller::ControlledEntity::Exception const&)
@@ -1144,7 +1115,7 @@ class MCDomainManagerImpl final : public MCDomainManager
 		if (controlledListenerEntity)
 		{
 			auto const& inputNode = controlledListenerEntity->getStreamInputNode(controlledListenerEntity->getCurrentConfigurationNode().descriptorIndex, listenerStreamIndex); // this doesn't work for redundant streams.
-			auto const& connectionState = inputNode.dynamicModel->connectionInfo;
+			auto const& connectionState = inputNode.dynamicModel.connectionInfo;
 			if (connectionState.talkerStream.entityID == talkerEntityId && connectionState.talkerStream.streamIndex == talkerStreamIndex)
 			{
 				return true;
@@ -1172,12 +1143,9 @@ class MCDomainManagerImpl final : public MCDomainManager
 			for (auto const& clockDomainKV : config.clockDomains)
 			{
 				auto const& clockDomain = clockDomainKV.second;
-				if (clockDomain.dynamicModel)
-				{
-					auto const clockSourceIndex = clockDomain.dynamicModel->clockSourceIndex;
-					auto const& activeClockSourceNode = controlledEntity->getClockSourceNode(config.descriptorIndex, clockSourceIndex);
-					return activeClockSourceNode.staticModel->clockSourceLocationIndex;
-				}
+				auto const clockSourceIndex = clockDomain.dynamicModel.clockSourceIndex;
+				auto const& activeClockSourceNode = controlledEntity->getClockSourceNode(config.descriptorIndex, clockSourceIndex);
+				return activeClockSourceNode.staticModel.clockSourceLocationIndex;
 			}
 		}
 		return std::nullopt;
@@ -1192,44 +1160,15 @@ class MCDomainManagerImpl final : public MCDomainManager
 	virtual std::vector<la::avdecc::entity::model::StreamIndex> findOutputClockStreamIndexInConfiguration(la::avdecc::controller::model::ConfigurationNode const& config) const noexcept
 	{
 		std::vector<la::avdecc::entity::model::StreamIndex> streamIndexes;
-		for (auto const& streamOutput : config.redundantStreamOutputs)
-		{
-			if (streamOutput.second.primaryStream && streamOutput.second.primaryStream->staticModel)
-			{
-				for (auto const& streamFormat : streamOutput.second.primaryStream->staticModel->formats)
-				{
-					auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamFormat);
-					auto streamType = streamFormatInfo->getType();
-					if (la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference == streamType)
-					{
-						auto primaryIndex = streamOutput.second.primaryStream->descriptorIndex;
-						streamIndexes.push_back(primaryIndex);
-
-						for (auto const& redundantStream : streamOutput.second.redundantStreams)
-						{
-							// the primary is included in the redundantStreams
-							if (primaryIndex != redundantStream.first)
-							{
-								streamIndexes.push_back(redundantStream.first);
-							}
-						}
-						return streamIndexes;
-					}
-				}
-			}
-		}
 
 		for (auto const& streamOutput : config.streamOutputs)
 		{
-			if (streamOutput.second.dynamicModel)
+			auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamOutput.second.dynamicModel.streamFormat);
+			auto const streamType = streamFormatInfo->getType();
+			if (la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference == streamType)
 			{
-				auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamOutput.second.dynamicModel->streamFormat);
-				auto const streamType = streamFormatInfo->getType();
-				if (la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference == streamType)
-				{
-					streamIndexes.push_back(streamOutput.first);
-					return streamIndexes;
-				}
+				streamIndexes.push_back(streamOutput.first);
+				return streamIndexes;
 			}
 		}
 
@@ -1245,43 +1184,15 @@ class MCDomainManagerImpl final : public MCDomainManager
 	virtual std::vector<la::avdecc::entity::model::StreamIndex> findInputClockStreamIndexInConfiguration(la::avdecc::controller::model::ConfigurationNode const& config) const noexcept
 	{
 		std::vector<la::avdecc::entity::model::StreamIndex> streamIndexes;
-		for (auto const& streamInput : config.redundantStreamInputs)
-		{
-			if (streamInput.second.primaryStream && streamInput.second.primaryStream->staticModel)
-			{
-				for (auto const& streamFormat : streamInput.second.primaryStream->staticModel->formats)
-				{
-					auto const streamFormatInfo2 = la::avdecc::entity::model::StreamFormatInfo::create(streamFormat);
-					auto streamType = streamFormatInfo2->getType();
-					if (la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference == streamType)
-					{
-						auto primaryIndex = streamInput.second.primaryStream->descriptorIndex;
-						streamIndexes.push_back(primaryIndex);
 
-						for (auto const& redundantStream : streamInput.second.redundantStreams)
-						{
-							// the primary is included in the redundantStreams
-							if (primaryIndex != redundantStream.first)
-							{
-								streamIndexes.push_back(redundantStream.first);
-							}
-						}
-						return streamIndexes;
-					}
-				}
-			}
-		}
 		for (auto const& streamInput : config.streamInputs)
 		{
-			if (streamInput.second.dynamicModel)
+			auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamInput.second.dynamicModel.streamFormat);
+			auto const streamType = streamFormatInfo->getType();
+			if (la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference == streamType)
 			{
-				auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamInput.second.dynamicModel->streamFormat);
-				auto const streamType = streamFormatInfo->getType();
-				if (la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference == streamType)
-				{
-					streamIndexes.push_back(streamInput.first);
-					return streamIndexes;
-				}
+				streamIndexes.push_back(streamInput.first);
+				return streamIndexes;
 			}
 		}
 
@@ -1351,13 +1262,10 @@ class MCDomainManagerImpl final : public MCDomainManager
 					auto const& configNode = controlledEntity->getCurrentConfigurationNode();
 					for (auto const& [streamIndex, streamInputNode] : configNode.streamInputs)
 					{
-						auto* streamInputDynamicModel = streamInputNode.dynamicModel;
-						if (streamInputDynamicModel)
+						auto& streamInputDynamicModel = streamInputNode.dynamicModel;
+						if (streamInputDynamicModel.connectionInfo.talkerStream.entityID == talkerEntityId)
 						{
-							if (streamInputDynamicModel->connectionInfo.talkerStream.entityID == talkerEntityId)
-							{
-								disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel->connectionInfo });
-							}
+							disconnectedStreams.push_back({ { potentialListenerEntityId, streamIndex }, streamInputDynamicModel.connectionInfo });
 						}
 					}
 				}
@@ -1390,14 +1298,11 @@ class MCDomainManagerImpl final : public MCDomainManager
 
 				for (auto const& [streamIndex, streamInputNode] : configNode.streamInputs)
 				{
-					auto* streamInputDynModel = streamInputNode.dynamicModel;
-					if (streamInputDynModel)
+					auto& streamInputDynModel = streamInputNode.dynamicModel;
+					auto connectionState = streamInputDynModel.connectionInfo;
+					if (connectionState.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected)
 					{
-						auto connectionState = streamInputDynModel->connectionInfo;
-						if (connectionState.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected)
-						{
-							streamsToDisconnect.push_back({ { targetEntityId, streamIndex }, connectionState });
-						}
+						streamsToDisconnect.push_back({ { targetEntityId, streamIndex }, connectionState });
 					}
 				}
 			}
@@ -1810,31 +1715,24 @@ class MCDomainManagerImpl final : public MCDomainManager
 					for (auto const& clockDomainKV : configNode.clockDomains)
 					{
 						auto const& clockDomain = clockDomainKV.second;
-						if (clockDomain.dynamicModel)
-						{
-							auto const clockSourceIndex = clockDomain.dynamicModel->clockSourceIndex;
-							auto const& activeClockSourceNode = controlledEntity->getClockSourceNode(activeConfigIndex, clockSourceIndex);
+						auto const clockSourceIndex = clockDomain.dynamicModel.clockSourceIndex;
+						auto const& activeClockSourceNode = controlledEntity->getClockSourceNode(activeConfigIndex, clockSourceIndex);
 
-							if (!activeClockSourceNode.staticModel)
-							{
+						switch (activeClockSourceNode.staticModel.clockSourceType)
+						{
+							case la::avdecc::entity::model::ClockSourceType::Internal:
 								break;
-							}
-							switch (activeClockSourceNode.staticModel->clockSourceType)
+							case la::avdecc::entity::model::ClockSourceType::External:
+							case la::avdecc::entity::model::ClockSourceType::InputStream:
 							{
-								case la::avdecc::entity::model::ClockSourceType::Internal:
-									break;
-								case la::avdecc::entity::model::ClockSourceType::External:
-								case la::avdecc::entity::model::ClockSourceType::InputStream:
+								if (stream.streamIndex == activeClockSourceNode.staticModel.clockSourceLocationIndex)
 								{
-									if (stream.streamIndex == activeClockSourceNode.staticModel->clockSourceLocationIndex)
-									{
-										affectsMcMaster = true;
-									}
-									break;
+									affectsMcMaster = true;
 								}
-								default: // Unsupported ClockSourceType, ignore it
-									break;
+								break;
 							}
+							default: // Unsupported ClockSourceType, ignore it
+								break;
 						}
 					}
 				}
diff --git a/src/connectionEditor/connectionEditor.cpp b/src/connectionEditor/connectionEditor.cpp
new file mode 100644
index 00000000..1a5a37f8
--- /dev/null
+++ b/src/connectionEditor/connectionEditor.cpp
@@ -0,0 +1,216 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "connectionEditor.hpp"
+#include "nodeOrganizer.hpp"
+#include "nodeListModel.hpp"
+#include "nodeListView.hpp"
+#include "connectionWorkspace.hpp"
+
+#include <QtMate/flow/flowScene.hpp>
+#include <QtMate/flow/flowSceneDelegate.hpp>
+#include <QtMate/flow/flowNode.hpp>
+#include <QtMate/flow/flowSocket.hpp>
+#include <QtMate/flow/flowView.hpp>
+
+#include <QHBoxLayout>
+#include <QListView>
+
+namespace
+{
+QPixmap render(qtMate::flow::FlowSceneDelegate* delegate, qtMate::flow::FlowNodeUid const& uid, qtMate::flow::FlowNodeDescriptor const& descriptor)
+{
+	auto node = qtMate::flow::FlowNode{ delegate, uid, descriptor };
+
+	auto const boundingRect = node.boundingRect();
+	auto const width = static_cast<int>(boundingRect.width() + 1);
+	auto const height = static_cast<int>(boundingRect.height() + 1);
+	auto pixmap = QPixmap{ width, height };
+	pixmap.fill(Qt::transparent);
+
+	auto painter = QPainter{ &pixmap };
+	node.paint(&painter, nullptr, nullptr);
+
+	auto const options = QStyleOptionGraphicsItem{};
+
+	// we also need to render the children ourself
+	for (auto* child : node.childItems())
+	{
+		auto transform = QTransform{};
+		transform.translate(child->pos().x(), child->pos().y());
+		painter.setTransform(transform);
+		child->paint(&painter, &options, nullptr);
+	}
+
+	return pixmap;
+}
+
+} // namespace
+
+class ConnectionEditorDelegate : public qtMate::flow::FlowSceneDelegate
+{
+public:
+	using FlowSceneDelegate::FlowSceneDelegate;
+
+	virtual QColor socketTypeColor(qtMate::flow::FlowSocketType type) const override
+	{
+		switch (type)
+		{
+			case 0x0:
+				return 0x673AB7;
+			case 0x1:
+				return 0x009688;
+			case 0x2:
+				return 0x7CB342;
+			default:
+				return Qt::darkGray;
+		}
+	}
+};
+
+ConnectionEditor::ConnectionEditor(qtMate::flow::FlowNodeDescriptorMap const& nodes, qtMate::flow::FlowConnectionDescriptors const& connections, QWidget* parent)
+	: QWidget{ parent }
+{
+	auto* delegate = new ConnectionEditorDelegate{ this };
+
+	auto* scene = new qtMate::flow::FlowScene{ delegate, this };
+
+	auto* organizer = new NodeOrganizer{ scene, this };
+
+	auto* model = new NodeListModel{ this };
+
+	connect(scene, &qtMate::flow::FlowScene::nodeCreated, this,
+		[=](qtMate::flow::FlowNodeUid const& uid)
+		{
+			model->setEnabled(uid, false);
+		});
+
+	connect(scene, &qtMate::flow::FlowScene::nodeDestroyed, this,
+		[=](qtMate::flow::FlowNodeUid const& uid)
+		{
+			model->setEnabled(uid, true);
+		});
+
+	connect(scene, &qtMate::flow::FlowScene::connectionCreated, this,
+		[=](qtMate::flow::FlowConnectionDescriptor const& descriptor)
+		{
+			_connections.insert(descriptor);
+		});
+
+	connect(scene, &qtMate::flow::FlowScene::connectionDestroyed, this,
+		[=](qtMate::flow::FlowConnectionDescriptor const& descriptor)
+		{
+			_connections.remove(descriptor);
+		});
+
+	auto* list = new NodeListView{ this };
+	list->setModel(model);
+
+	auto* workspace = new ConnectionWorkspace{ scene, this };
+
+	// selecting a node in the view makes it active in the list and vice-versa
+	connect(scene, &QGraphicsScene::selectionChanged, this,
+		[=]()
+		{
+			for (auto* item : scene->selectedItems())
+			{
+				if (auto* node = qgraphicsitem_cast<qtMate::flow::FlowNode*>(item))
+				{
+					if (auto const index = model->nodeIndex(node->uid()); index.isValid())
+					{
+						list->selectionModel()->select(index, QItemSelectionModel::SelectionFlag::ClearAndSelect);
+					}
+				}
+			}
+		});
+
+	connect(list, &QListView::clicked, this,
+		[=](QModelIndex const& index)
+		{
+			auto const uid = index.data(Qt::UserRole).value<qtMate::flow::FlowNodeUid>();
+			if (auto* node = scene->node(uid))
+			{
+				scene->clearSelection();
+				node->setSelected(true);
+			}
+		});
+
+	// double-clicking a node in the list focuses it in the view
+	connect(list, &NodeListView::doubleClicked, this,
+		[=](QModelIndex const& index)
+		{
+			auto const uid = index.data(Qt::UserRole).value<qtMate::flow::FlowNodeUid>();
+			if (auto* node = scene->node(uid))
+			{
+				workspace->animatedCenterOn(node->sceneBoundingRect().center());
+			}
+		});
+
+	// node dropped means we want to add it to the workspace
+	connect(list, &NodeListView::dropped, this,
+		[=](QModelIndex const& index)
+		{
+			auto const uid = index.data(Qt::UserRole).value<qtMate::flow::FlowNodeUid>();
+			if (auto* descriptor = model->descriptor(uid))
+			{
+				scene->createNode(uid, *descriptor);
+			}
+		});
+
+	// add all nodes to the list
+	auto const uids = nodes.keys();
+	for (auto const& uid : uids)
+	{
+		auto const& descriptor = nodes[uid];
+		auto const pixmap = ::render(delegate, uid, descriptor);
+		model->createItem(uid, descriptor, pixmap);
+	}
+
+	// gather the list of nodes that are connected
+	QSet<qtMate::flow::FlowNodeUid> listOfNodeUidToCreate{};
+	for (auto const& descriptor : connections)
+	{
+		listOfNodeUidToCreate.insert(descriptor.first.first);
+		listOfNodeUidToCreate.insert(descriptor.second.first);
+	}
+
+	// add all these nodes to the scene
+	for (auto const& uid : listOfNodeUidToCreate)
+	{
+		scene->createNode(uid, nodes[uid]);
+	}
+
+	// finally, create all connections
+	for (auto const& descriptor : connections)
+	{
+		scene->createConnection(descriptor);
+	}
+
+	auto* layout = new QHBoxLayout{ this };
+	layout->addWidget(list);
+	layout->addWidget(workspace);
+
+	workspace->animatedCenterOn(scene->itemsBoundingRect().bottomRight());
+}
+
+ConnectionEditor::~ConnectionEditor() = default;
+
+qtMate::flow::FlowConnectionDescriptors const& ConnectionEditor::connections() const
+{
+	return _connections;
+}
diff --git a/src/connectionEditor/connectionEditor.hpp b/src/connectionEditor/connectionEditor.hpp
new file mode 100644
index 00000000..c3e969af
--- /dev/null
+++ b/src/connectionEditor/connectionEditor.hpp
@@ -0,0 +1,36 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QWidget>
+#include <QtMate/flow/flowDefs.hpp>
+
+class ConnectionEditor : public QWidget
+{
+	Q_OBJECT
+public:
+	ConnectionEditor(qtMate::flow::FlowNodeDescriptorMap const& nodes, qtMate::flow::FlowConnectionDescriptors const& connections, QWidget* parent = nullptr);
+	virtual ~ConnectionEditor() override;
+
+	qtMate::flow::FlowConnectionDescriptors const& connections() const;
+
+private:
+	qtMate::flow::FlowConnectionDescriptors _connections{};
+};
diff --git a/src/connectionEditor/connectionWorkspace.cpp b/src/connectionEditor/connectionWorkspace.cpp
new file mode 100644
index 00000000..2da07f91
--- /dev/null
+++ b/src/connectionEditor/connectionWorkspace.cpp
@@ -0,0 +1,93 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "connectionWorkspace.hpp"
+
+#include <QtMate/flow/flowScene.hpp>
+#include <QtMate/flow/flowSocket.hpp>
+#include <QtMate/flow/flowNode.hpp>
+
+#include <QDragEnterEvent>
+#include <QDragLeaveEvent>
+#include <QDragMoveEvent>
+#include <QDropEvent>
+
+#include <QMimeData>
+
+namespace
+{
+bool hasValidMimeData(QMimeData const* mimeData)
+{
+	return mimeData->hasFormat("application/x-node");
+}
+
+} // namespace
+
+ConnectionWorkspace::ConnectionWorkspace(qtMate::flow::FlowScene* scene, QWidget* parent)
+	: FlowView{ scene, parent }
+{
+	setMinimumSize(960, 720);
+	setAcceptDrops(true);
+}
+
+ConnectionWorkspace::~ConnectionWorkspace() = default;
+
+void ConnectionWorkspace::dragEnterEvent(QDragEnterEvent* event)
+{
+	if (hasValidMimeData(event->mimeData()))
+	{
+		_dragEnterAccepted = true;
+		event->acceptProposedAction();
+	}
+	else
+	{
+		_dragEnterAccepted = false;
+		QGraphicsView::dragEnterEvent(event);
+	}
+}
+void ConnectionWorkspace::dragLeaveEvent(QDragLeaveEvent* event)
+{
+	if (!_dragEnterAccepted)
+	{
+		QGraphicsView::dragLeaveEvent(event);
+	}
+}
+
+void ConnectionWorkspace::dragMoveEvent(QDragMoveEvent* event)
+{
+	if (hasValidMimeData(event->mimeData()))
+	{
+		event->acceptProposedAction();
+	}
+	else
+	{
+		QGraphicsView::dragMoveEvent(event);
+	}
+}
+
+void ConnectionWorkspace::dropEvent(QDropEvent* event)
+{
+	if (hasValidMimeData(event->mimeData()))
+	{
+		event->acceptProposedAction();
+	}
+	else
+	{
+		QGraphicsView::dropEvent(event);
+	}
+}
diff --git a/src/connectionEditor/connectionWorkspace.hpp b/src/connectionEditor/connectionWorkspace.hpp
new file mode 100644
index 00000000..cb519812
--- /dev/null
+++ b/src/connectionEditor/connectionWorkspace.hpp
@@ -0,0 +1,38 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QtMate/flow/flowView.hpp>
+
+class ConnectionWorkspace : public qtMate::flow::FlowView
+{
+public:
+	ConnectionWorkspace(qtMate::flow::FlowScene* scene, QWidget* parent = nullptr);
+	virtual ~ConnectionWorkspace() override;
+
+protected:
+	virtual void dragEnterEvent(QDragEnterEvent* event) override;
+	virtual void dragLeaveEvent(QDragLeaveEvent* event) override;
+	virtual void dragMoveEvent(QDragMoveEvent* event) override;
+	virtual void dropEvent(QDropEvent* event) override;
+
+private:
+	bool _dragEnterAccepted{};
+};
diff --git a/src/connectionEditor/nodeListModel.cpp b/src/connectionEditor/nodeListModel.cpp
new file mode 100644
index 00000000..cab46958
--- /dev/null
+++ b/src/connectionEditor/nodeListModel.cpp
@@ -0,0 +1,96 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "nodeListModel.hpp"
+
+#include <QMimeData>
+#include <QByteArray>
+#include <QIODevice>
+#include <QPalette>
+
+void NodeListModel::createItem(qtMate::flow::FlowNodeUid const& uid, qtMate::flow::FlowNodeDescriptor const& descriptor, QPixmap const& pixmap)
+{
+	auto* item = new QStandardItem{};
+	item->setData(descriptor.name, Qt::DisplayRole);
+	item->setData(uid, Qt::UserRole);
+	item->setEditable(false);
+	item->setDragEnabled(true);
+	item->setEnabled(true);
+	_items.insert(uid, item);
+	_descriptors.insert(uid, descriptor);
+	_pixmaps.insert(uid, pixmap);
+	appendRow(item);
+}
+
+void NodeListModel::setEnabled(qtMate::flow::FlowNodeUid const& uid, bool enabled)
+{
+	if (auto* item = _items.value(uid))
+	{
+		item->setDragEnabled(enabled);
+
+		auto const group = enabled ? QPalette::Normal : QPalette::Disabled;
+		auto const color = QPalette().color(group, QPalette::WindowText);
+		item->setData(color, Qt::ForegroundRole);
+	}
+}
+
+QModelIndex NodeListModel::nodeIndex(qtMate::flow::FlowNodeUid const& uid) const
+{
+	if (auto* item = _items.value(uid))
+	{
+		return createIndex(item->row(), 0);
+	}
+	return {};
+}
+
+qtMate::flow::FlowNodeDescriptor const* NodeListModel::descriptor(qtMate::flow::FlowNodeUid const& uid) const
+{
+	auto const it = _descriptors.find(uid);
+	if (it != std::end(_descriptors))
+	{
+		return &(*it);
+	}
+	return nullptr;
+}
+
+QMimeData* NodeListModel::mimeData(QModelIndexList const& indexes) const
+{
+	// only handle 1 valid node
+	if (indexes.empty() || !indexes.first().isValid())
+	{
+		return nullptr;
+	}
+
+	auto encodedData = QByteArray{};
+	auto stream = QDataStream{ &encodedData, QIODevice::WriteOnly };
+
+	auto const index = indexes.first();
+	auto const uid = index.data(Qt::UserRole).value<qtMate::flow::FlowNodeUid>();
+	stream << uid;
+
+	auto* mimeData = new QMimeData{};
+	mimeData->setData("application/x-node", encodedData);
+	mimeData->setImageData(_pixmaps[uid].toImage());
+
+	return mimeData;
+}
+
+QStringList NodeListModel::mimeTypes() const
+{
+	return { "application/x-node" };
+}
diff --git a/src/connectionEditor/nodeListModel.hpp b/src/connectionEditor/nodeListModel.hpp
new file mode 100644
index 00000000..34afd619
--- /dev/null
+++ b/src/connectionEditor/nodeListModel.hpp
@@ -0,0 +1,50 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QStandardItemModel>
+#include <QtMate/flow/flowDefs.hpp>
+
+class NodeListModel : public QStandardItemModel
+{
+public:
+	using QStandardItemModel::QStandardItemModel;
+
+	// add a node to the list
+	void createItem(qtMate::flow::FlowNodeUid const& uid, qtMate::flow::FlowNodeDescriptor const& descriptor, QPixmap const& pixmap);
+
+	// disabled means not draggable and grayed-out
+	void setEnabled(qtMate::flow::FlowNodeUid const& uid, bool enabled);
+
+	// return the index associated with a node
+	QModelIndex nodeIndex(qtMate::flow::FlowNodeUid const& uid) const;
+
+	// return a pointer to the node descriptor associated with a node
+	qtMate::flow::FlowNodeDescriptor const* descriptor(qtMate::flow::FlowNodeUid const& uid) const;
+
+	// QStandardItemModel overrides
+	virtual QMimeData* mimeData(QModelIndexList const& indexes) const override;
+	virtual QStringList mimeTypes() const override;
+
+private:
+	QHash<qtMate::flow::FlowNodeUid, QStandardItem*> _items{};
+	QHash<qtMate::flow::FlowNodeUid, qtMate::flow::FlowNodeDescriptor> _descriptors{};
+	QHash<qtMate::flow::FlowNodeUid, QPixmap> _pixmaps{};
+};
diff --git a/src/connectionEditor/nodeListView.cpp b/src/connectionEditor/nodeListView.cpp
new file mode 100644
index 00000000..7b43e2a7
--- /dev/null
+++ b/src/connectionEditor/nodeListView.cpp
@@ -0,0 +1,55 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "nodeListView.hpp"
+
+#include <QDrag>
+#include <QMimeData>
+
+NodeListView::NodeListView(QWidget* parent)
+	: QListView{ parent }
+{
+	setSelectionMode(QAbstractItemView::SelectionMode::SingleSelection);
+	setDragDropMode(QAbstractItemView::DragDropMode::DragOnly);
+	setDragEnabled(true);
+	setMinimumWidth(250);
+}
+
+NodeListView::~NodeListView() = default;
+
+void NodeListView::startDrag(Qt::DropActions supportedActions)
+{
+	auto* drag = new QDrag{ this };
+
+	auto const indexes = selectedIndexes();
+	Q_ASSERT(indexes.count() == 1);
+
+	auto* mimeData = model()->mimeData(indexes);
+	drag->setMimeData(mimeData);
+
+	if (mimeData->hasImage())
+	{
+		auto const image = qvariant_cast<QImage>(mimeData->imageData());
+		drag->setPixmap(QPixmap::fromImage(image));
+	}
+
+	if (drag->exec(supportedActions) != Qt::DropAction::IgnoreAction)
+	{
+		emit dropped(indexes.first());
+	}
+}
diff --git a/src/connectionEditor/nodeListView.hpp b/src/connectionEditor/nodeListView.hpp
new file mode 100644
index 00000000..2807423f
--- /dev/null
+++ b/src/connectionEditor/nodeListView.hpp
@@ -0,0 +1,36 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QListView>
+
+class NodeListView : public QListView
+{
+	Q_OBJECT
+public:
+	NodeListView(QWidget* parent = nullptr);
+	virtual ~NodeListView() override;
+
+signals:
+	void dropped(QModelIndex const& index);
+
+protected:
+	virtual void startDrag(Qt::DropActions supportedActions) override;
+};
diff --git a/src/connectionEditor/nodeOrganizer.cpp b/src/connectionEditor/nodeOrganizer.cpp
new file mode 100644
index 00000000..ccaf519e
--- /dev/null
+++ b/src/connectionEditor/nodeOrganizer.cpp
@@ -0,0 +1,289 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "nodeOrganizer.hpp"
+
+#include <QtMate/flow/flowScene.hpp>
+#include <QtMate/flow/flowNode.hpp>
+#include <QtMate/flow/flowInput.hpp>
+#include <QtMate/flow/flowOutput.hpp>
+#include <QtMate/flow/flowConnection.hpp>
+
+namespace
+{
+int countConnections(qtMate::flow::FlowInputs const& inputs)
+{
+	int total = 0;
+	for (auto* input : inputs)
+	{
+		total += input->isConnected();
+	}
+	return total;
+}
+
+int countConnections(qtMate::flow::FlowOutputs const& outputs)
+{
+	int total = 0;
+	for (auto* output : outputs)
+	{
+		total += output->connections().size();
+	}
+	return total;
+}
+
+// recursively traverse once, each node that is connected to the node output
+using TraverseFunc = std::function<void(qtMate::flow::FlowNode*, int)>;
+void traverse(qtMate::flow::FlowNode* node, int depth, TraverseFunc func)
+{
+	func(node, depth);
+	QSet<qtMate::flow::FlowNode*> visited{};
+	for (auto* output : node->outputs())
+	{
+		if (output->isConnected())
+		{
+			for (auto* connection : output->connections())
+			{
+				auto* input = connection->input()->node();
+				if (!visited.contains(input))
+				{
+					visited.insert(input);
+					traverse(input, depth + 1, func);
+				}
+			}
+		}
+	}
+}
+
+} // namespace
+
+NodeOrganizer::NodeOrganizer(qtMate::flow::FlowScene* scene, QObject* parent)
+	: QObject{ parent }
+	, _scene{ scene }
+	, _sceneRectAnimation{ new QPropertyAnimation{ _scene, "sceneRect" } }
+{
+	connect(_scene, &qtMate::flow::FlowScene::nodeCreated, this,
+		[this](qtMate::flow::FlowNodeUid const& uid)
+		{
+			updateNodeData(uid);
+		});
+
+	connect(_scene, &qtMate::flow::FlowScene::nodeDestroyed, this,
+		[this](qtMate::flow::FlowNodeUid const& uid)
+		{
+			updateNodeData(uid);
+		});
+
+	connect(_scene, &qtMate::flow::FlowScene::connectionCreated, this,
+		[this](qtMate::flow::FlowConnectionDescriptor const& descriptor)
+		{
+			updateNodeData(descriptor.first.first);
+			updateNodeData(descriptor.second.first);
+		});
+
+	connect(_scene, &qtMate::flow::FlowScene::connectionDestroyed, this,
+		[this](qtMate::flow::FlowConnectionDescriptor const& descriptor)
+		{
+			updateNodeData(descriptor.first.first);
+			updateNodeData(descriptor.second.first);
+		});
+}
+
+NodeOrganizer::~NodeOrganizer() = default;
+
+void NodeOrganizer::updateNodeData(qtMate::flow::FlowNodeUid const& uid)
+{
+	if (auto* node = _scene->node(uid))
+	{
+		auto& nodeData = _nodeData[uid];
+		nodeData.node = node;
+		nodeData.activeInputCount = countConnections(node->inputs());
+		nodeData.activeOutputCount = countConnections(node->outputs());
+	}
+	else
+	{
+		delete _animations.take(uid);
+		_nodeData.remove(uid);
+	}
+
+	doLayout();
+}
+
+void NodeOrganizer::doLayout()
+{
+	using DistanceCandidates = QList<int>;
+	QHash<qtMate::flow::FlowNode*, DistanceCandidates> distanceCandidates{};
+
+	// find each node with no input (root) and compute the distance for each of its children
+	for (auto const& nodeData : _nodeData)
+	{
+		// no inputs means root
+		if (nodeData.activeInputCount == 0)
+		{
+			traverse(nodeData.node, 0,
+				[&distanceCandidates](qtMate::flow::FlowNode* node, int depth)
+				{
+					distanceCandidates[node].push_front(depth);
+				});
+		}
+	}
+
+	// determine the actual distance for each node of the scene
+	// note: distance also represents the column index in the grid
+	QHash<qtMate::flow::FlowNode*, int> distances{};
+	for (auto* node : _scene->nodes())
+	{
+		if (distanceCandidates.contains(node))
+		{
+			auto const& candidates = distanceCandidates[node];
+			distances[node] = *std::max_element(std::begin(candidates), std::end(candidates));
+		}
+		else
+		{
+			distances[node] = 0;
+		}
+	}
+
+	// put each node in some sort of grid
+	using Column = QVector<qtMate::flow::FlowNode*>;
+	using Grid = QHash<int, Column>;
+	Grid grid;
+	for (auto* node : _scene->nodes())
+	{
+		auto const distance = distances.value(node, 0);
+		grid[distance].emplace_back(node);
+	}
+
+	// sort each column in order to keep some consistency
+	for (auto& column : grid)
+	{
+		std::sort(std::begin(column), std::end(column),
+			[this](qtMate::flow::FlowNode* left, qtMate::flow::FlowNode* right)
+			{
+				auto const& leftData = _nodeData[left->uid()];
+				auto const& rightData = _nodeData[right->uid()];
+
+				// sort by number of connected outputs
+				if (leftData.activeOutputCount != rightData.activeOutputCount)
+				{
+					return leftData.activeOutputCount > rightData.activeOutputCount;
+				}
+
+				// sort by number of connected inputs
+				if (leftData.activeInputCount != rightData.activeInputCount)
+				{
+					return leftData.activeInputCount > rightData.activeInputCount;
+				}
+
+				// sort by uid
+				return left->uid() < right->uid();
+			});
+	}
+
+	// holds the list of staged nodes
+	QVector<qtMate::flow::FlowNode*> stagedNodes{};
+
+	// traverse the grid and move nodes
+	auto const horizontalPadding = 120.f;
+	auto const verticalPadding = 100.f;
+
+	// holds the scene size after layout has been performed
+	auto sceneRect = QRectF{};
+
+	auto x = 0.f;
+	for (auto i = 0; i < grid.size(); ++i)
+	{
+		auto const& column = grid[i];
+		auto maxWidth = 0.f;
+
+		auto y = 0.f;
+		for (auto* node : column)
+		{
+			auto const& nodeData = _nodeData[node->uid()];
+			if (nodeData.activeOutputCount == 0 && nodeData.activeInputCount == 0)
+			{
+				stagedNodes.emplace_back(node);
+				continue;
+			}
+
+			auto const r = node->boundingRect();
+			maxWidth = qMax(maxWidth, r.width());
+
+			animateTo(node, x, y);
+
+			y += r.height() + verticalPadding;
+			sceneRect.setHeight(qMax(sceneRect.height(), y));
+		}
+
+		x += maxWidth + horizontalPadding;
+
+		sceneRect.setWidth(qMax(sceneRect.width(), x));
+	}
+
+	// Layout staged nodes above all the others
+	for (auto* node : stagedNodes)
+	{
+		auto const r = node->boundingRect();
+
+		auto y = sceneRect.y() - verticalPadding - r.height();
+		animateTo(node, 0, y);
+
+		sceneRect.setY(y);
+	}
+
+	// update the scene rect according to the new scene layout
+	sceneRect.adjust(-horizontalPadding, -verticalPadding, 0, 0);
+
+	_sceneRectAnimation->stop();
+	_sceneRectAnimation->setDuration(1800);
+	_sceneRectAnimation->setEasingCurve(QEasingCurve::Type::OutQuart);
+	_sceneRectAnimation->setStartValue(_scene->sceneRect());
+	_sceneRectAnimation->setEndValue(sceneRect);
+	_sceneRectAnimation->start(QAbstractAnimation::DeletionPolicy::KeepWhenStopped);
+}
+
+void NodeOrganizer::animateTo(qtMate::flow::FlowNode* node, float x, float y)
+{
+	auto const startValue = node->pos();
+	auto const endValue = QPointF{ x, y };
+
+	auto const uid = node->uid();
+	auto* animation = _animations.value(uid);
+	if (!animation)
+	{
+		animation = new QVariantAnimation{ this };
+		animation->setDuration(1000);
+		animation->setEasingCurve(QEasingCurve::Type::OutQuart);
+		_animations.insert(uid, animation);
+	}
+
+	animation->stop();
+	animation->setStartValue(startValue);
+	animation->setEndValue(endValue);
+
+	// caution, pass the node uid and retrieve it in the lambda cause the node may have been deleted
+	connect(animation, &QVariantAnimation::valueChanged, this,
+		[this, uid](QVariant const& value)
+		{
+			if (auto* node = _scene->node(uid))
+			{
+				node->setPos(value.toPointF());
+			}
+		});
+
+	animation->start(QAbstractAnimation::DeletionPolicy::KeepWhenStopped);
+}
diff --git a/src/connectionEditor/nodeOrganizer.hpp b/src/connectionEditor/nodeOrganizer.hpp
new file mode 100644
index 00000000..c4a08dde
--- /dev/null
+++ b/src/connectionEditor/nodeOrganizer.hpp
@@ -0,0 +1,52 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QObject>
+#include <QVariantAnimation>
+#include <QPropertyAnimation>
+
+#include <QtMate/flow/flowDefs.hpp>
+
+class NodeOrganizer : public QObject
+{
+public:
+	NodeOrganizer(qtMate::flow::FlowScene* scene, QObject* parent = nullptr);
+	virtual ~NodeOrganizer() override;
+
+private:
+	void updateNodeData(qtMate::flow::FlowNodeUid const& uid);
+	void doLayout();
+	void animateTo(qtMate::flow::FlowNode* node, float x, float y);
+
+private:
+	qtMate::flow::FlowScene* _scene{};
+	QPropertyAnimation* _sceneRectAnimation{};
+
+	struct NodeData
+	{
+		qtMate::flow::FlowNode* node{};
+		int activeInputCount{};
+		int activeOutputCount{};
+	};
+
+	QHash<qtMate::flow::FlowNodeUid, NodeData> _nodeData{};
+	QHash<qtMate::flow::FlowNodeUid, QVariantAnimation*> _animations{};
+};
diff --git a/src/connectionMatrix/cornerWidget.cpp b/src/connectionMatrix/cornerWidget.cpp
index c332ecc4..80ce9f19 100644
--- a/src/connectionMatrix/cornerWidget.cpp
+++ b/src/connectionMatrix/cornerWidget.cpp
@@ -66,7 +66,7 @@ CornerWidget::CornerWidget(QWidget* parent)
 	_centerContainerLayout.addStretch();
 	_centerContainerLayout.addWidget(&_legendButton);
 	_centerContainerLayout.addWidget(&_searchLineEdit);
-	_centerContainerLayout.addWidget(&_removeAllConnectionsButton);
+	_centerContainerLayout.addWidget(&_removeAllConnectionsButton, 0, Qt::AlignHCenter);
 	_centerContainerLayout.addStretch();
 
 	_layout.setRowStretch(0, 1);
@@ -79,6 +79,8 @@ CornerWidget::CornerWidget(QWidget* parent)
 	_verticalPlaceholder.setFixedWidth(20);
 	_title.setAlignment(Qt::AlignHCenter);
 	_removeAllConnectionsButton.setToolTip(QCoreApplication::translate("CornerWidget", "Remove all active connections", nullptr));
+	// Prevent the button from expanding
+	_removeAllConnectionsButton.setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
 	// Connect buttons
 	connect(&_legendButton, &qtMate::widgets::FlatIconButton::clicked, this,
@@ -101,17 +103,14 @@ CornerWidget::CornerWidget(QWidget* parent)
 							auto const& configNode = entity.getCurrentConfigurationNode();
 							for (auto const& [streamIndex, streamNode] : configNode.streamInputs)
 							{
-								if (streamNode.dynamicModel != nullptr)
+								auto const& connectionInfo = streamNode.dynamicModel.connectionInfo;
+								if (connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
 								{
-									auto const& connectionInfo = streamNode.dynamicModel->connectionInfo;
-									if (connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
-									{
-										// Ignore result handler
-										manager.disconnectStream(connectionInfo.talkerStream.entityID, connectionInfo.talkerStream.streamIndex, entityID, streamIndex,
-											[](la::avdecc::UniqueIdentifier const talkerEntityID, la::avdecc::entity::model::StreamIndex const talkerStreamIndex, la::avdecc::UniqueIdentifier const listenerEntityID, la::avdecc::entity::model::StreamIndex const listenerStreamIndex, la::avdecc::entity::ControllerEntity::ControlStatus const status)
-											{
-											});
-									}
+									// Ignore result handler
+									manager.disconnectStream(connectionInfo.talkerStream.entityID, connectionInfo.talkerStream.streamIndex, entityID, streamIndex,
+										[](la::avdecc::UniqueIdentifier const talkerEntityID, la::avdecc::entity::model::StreamIndex const talkerStreamIndex, la::avdecc::UniqueIdentifier const listenerEntityID, la::avdecc::entity::model::StreamIndex const listenerStreamIndex, la::avdecc::entity::ControllerEntity::ControlStatus const status)
+										{
+										});
 								}
 							}
 						}
@@ -236,7 +235,8 @@ void CornerWidget::paintEvent(QPaintEvent*)
 
 	// Whole section
 	{
-		painter.fillRect(geometry(), 0xf5f5f5);
+		auto brush = qtMate::material::color::brush(qtMate::material::color::Name::Gray, qtMate::material::color::isDarkColorScheme() ? qtMate::material::color::Shade::Shade900 : qtMate::material::color::Shade::Shade100);
+		painter.fillRect(geometry(), brush);
 	}
 
 	// Horizontal section
diff --git a/src/connectionMatrix/headerView.cpp b/src/connectionMatrix/headerView.cpp
index b86e446d..0589dbe9 100644
--- a/src/connectionMatrix/headerView.cpp
+++ b/src/connectionMatrix/headerView.cpp
@@ -18,6 +18,7 @@
 */
 
 #include "connectionMatrix/headerView.hpp"
+#include "connectionMatrix/view.hpp"
 #include "connectionMatrix/model.hpp"
 #include "connectionMatrix/node.hpp"
 #include "connectionMatrix/paintHelper.hpp"
@@ -160,6 +161,80 @@ void HeaderView::collapseAll()
 	applyFilterPattern();
 }
 
+bool HeaderView::isNodeAndChildrenExpanded(int logicalIndex) const
+{
+	auto* model = static_cast<Model*>(this->model());
+	auto* node = model->node(logicalIndex, orientation());
+
+	if (!AVDECC_ASSERT_WITH_RET(node, "invalid node"))
+	{
+		return false;
+	}
+
+	auto isExpanded = true;
+
+	auto const checkExpanded = [&isExpanded, model, this](Node* node)
+	{
+		auto const section = model->section(node, orientation());
+		isExpanded &= _sectionState[section].expanded;
+	};
+
+	model->accept(node, checkExpanded, false);
+	return isExpanded;
+}
+
+void HeaderView::expandNodeAndChildren(int logicalIndex)
+{
+	auto* model = static_cast<Model*>(this->model());
+	auto* node = model->node(logicalIndex, orientation());
+
+	if (!AVDECC_ASSERT_WITH_RET(node, "invalid node"))
+	{
+		return;
+	}
+
+	// Update hierarchy visibility
+	auto const update = [=](Node* node)
+	{
+		auto const section = model->section(node, orientation());
+		_sectionState[section].expanded = true;
+		_sectionState[section].visible = true;
+		updateSectionVisibility(section);
+	};
+
+	model->accept(node, update, false);
+}
+
+void HeaderView::collapseNodeAndChildren(int logicalIndex)
+{
+	auto* model = static_cast<Model*>(this->model());
+	auto* node = model->node(logicalIndex, orientation());
+
+	if (!AVDECC_ASSERT_WITH_RET(node, "invalid node"))
+	{
+		return;
+	}
+
+	// Update hierarchy visibility
+	auto const update = [=](Node* node)
+	{
+		auto const section = model->section(node, orientation());
+		if (node->type() == Node::Type::Entity)
+		{
+			_sectionState[section].expanded = false;
+			_sectionState[section].visible = true;
+		}
+		else
+		{
+			_sectionState[section].expanded = false;
+			_sectionState[section].visible = false;
+		}
+		updateSectionVisibility(section);
+	};
+
+	model->accept(node, update, false);
+}
+
 void HeaderView::handleSectionClicked(int logicalIndex)
 {
 	auto* model = static_cast<Model*>(this->model());
@@ -396,8 +471,8 @@ void HeaderView::paintSection(QPainter* painter, QRect const& rect, int logicalI
 	switch (nodeType)
 	{
 		case Node::Type::OfflineOutputStream:
-			backgroundColor = Qt::black;
-			foregroundColor = Qt::white;
+			backgroundColor = Qt::black; // Always use black for background offline streams, even in dark mode
+			foregroundColor = Qt::white; // Always use white for foreground offline streams, even in dark mode
 			foregroundErrorColor = Qt::red;
 			break;
 		case Node::Type::Entity:
@@ -591,6 +666,20 @@ void HeaderView::paintSection(QPainter* painter, QRect const& rect, int logicalI
 	painter->restore();
 }
 
+template<class StreamPorts>
+bool atLeastOneDynamicMappings(StreamPorts const& streamPorts)
+{
+	for (auto const& [streamPortIndex, streamPortNode] : streamPorts)
+	{
+		if (streamPortNode.staticModel.hasDynamicAudioMap)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
 void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 {
 	auto const logicalIndex = logicalIndexAt(event->pos());
@@ -629,11 +718,11 @@ void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 		auto const isOutputStream = node->type() == Node::Type::OutputStream || node->type() == Node::Type::RedundantOutputStream;
 		if (isOutputStream)
 		{
-			return static_cast<la::avdecc::controller::model::StreamNode const*>(&controlledEntity.getStreamOutputNode(entityNode.dynamicModel->currentConfiguration, streamIndex));
+			return static_cast<la::avdecc::controller::model::StreamNode const*>(&controlledEntity.getStreamOutputNode(entityNode.dynamicModel.currentConfiguration, streamIndex));
 		}
 		else if (node->type() == Node::Type::InputStream || node->type() == Node::Type::RedundantInputStream)
 		{
-			return static_cast<la::avdecc::controller::model::StreamNode const*>(&controlledEntity.getStreamInputNode(entityNode.dynamicModel->currentConfiguration, streamIndex));
+			return static_cast<la::avdecc::controller::model::StreamNode const*>(&controlledEntity.getStreamInputNode(entityNode.dynamicModel.currentConfiguration, streamIndex));
 		}
 		else
 		{
@@ -644,47 +733,30 @@ void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 	struct MapSupTypeIndex
 	{
 		bool supportsDynamicMappings{ false };
+		la::avdecc::entity::model::AudioUnitIndex audioUnitIndex{ la::avdecc::entity::model::getInvalidDescriptorIndex() };
 		la::avdecc::entity::model::DescriptorType streamPortType{ la::avdecc::entity::model::DescriptorType::Invalid };
-		la::avdecc::entity::model::StreamPortIndex streamPortIndex{ la::avdecc::entity::model::getInvalidDescriptorIndex() };
 		la::avdecc::entity::model::StreamIndex streamIndex{ la::avdecc::entity::model::getInvalidDescriptorIndex() };
 	};
 	auto findMappingsSupportTypeIndexForDescriptor = [](la::avdecc::controller::ControlledEntity const& controlledEntity, la::avdecc::entity::model::DescriptorType const& descriptorType)
 	{
 		// Currently returning the first audio unit - TODO: If we have devices with multiple audio units, we shall probably offer to choose which audio unit to edit
 		auto mti = MapSupTypeIndex{};
+		auto constexpr audioUnitIndex = la::avdecc::entity::model::AudioUnitIndex{ 0u };
+
 		try
 		{
+			auto const& audioUnitNode = controlledEntity.getAudioUnitNode(controlledEntity.getCurrentConfigurationIndex(), audioUnitIndex);
 			if (descriptorType == la::avdecc::entity::model::DescriptorType::StreamInput)
 			{
-				for (auto const& [audioUnitIndex, audioUnitNode] : controlledEntity.getCurrentConfigurationNode().audioUnits)
-				{
-					for (auto const& [spi, streamPortNode] : audioUnitNode.streamPortInputs)
-					{
-						if (streamPortNode.staticModel->hasDynamicAudioMap)
-						{
-							mti.supportsDynamicMappings = true;
-							mti.streamPortType = la::avdecc::entity::model::DescriptorType::StreamPortInput;
-							mti.streamPortIndex = spi;
-							break;
-						}
-					}
-				}
+				mti.supportsDynamicMappings = atLeastOneDynamicMappings(audioUnitNode.streamPortInputs);
+				mti.audioUnitIndex = audioUnitIndex;
+				mti.streamPortType = la::avdecc::entity::model::DescriptorType::StreamPortInput;
 			}
 			else if (descriptorType == la::avdecc::entity::model::DescriptorType::StreamOutput)
 			{
-				for (auto const& [audioUnitIndex, audioUnitNode] : controlledEntity.getCurrentConfigurationNode().audioUnits)
-				{
-					for (auto const& [spi, streamPortNode] : audioUnitNode.streamPortOutputs)
-					{
-						if (streamPortNode.staticModel->hasDynamicAudioMap)
-						{
-							mti.supportsDynamicMappings = true;
-							mti.streamPortType = la::avdecc::entity::model::DescriptorType::StreamPortOutput;
-							mti.streamPortIndex = spi;
-							break;
-						}
-					}
-				}
+				mti.supportsDynamicMappings = atLeastOneDynamicMappings(audioUnitNode.streamPortOutputs);
+				mti.audioUnitIndex = audioUnitIndex;
+				mti.streamPortType = la::avdecc::entity::model::DescriptorType::StreamPortOutput;
 			}
 		}
 		catch (la::avdecc::controller::ControlledEntity::Exception const&)
@@ -696,11 +768,12 @@ void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 	};
 	auto findMappingsSupportTypeIndexForStreamNode = [](la::avdecc::controller::ControlledEntity const& controlledEntity, la::avdecc::controller::model::StreamNode const& streamNode)
 	{
+		// Currently returning the first audio unit - TODO: If we have devices with multiple audio units, we shall probably offer to choose which audio unit to edit
 		auto mti = MapSupTypeIndex{};
 
 		auto const isValidStreamFormat = [](auto const& streamNode)
 		{
-			auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode.dynamicModel->streamFormat);
+			auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamNode.dynamicModel.streamFormat);
 
 			return sfi->getChannelsCount() > 0;
 		};
@@ -711,23 +784,14 @@ void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 			{
 				for (auto const& [audioUnitIndex, audioUnitNode] : controlledEntity.getCurrentConfigurationNode().audioUnits)
 				{
-					// Search which StreamPort has the same ClockDomain than passed StreamNode
-					for (auto const& [spi, streamPortNode] : audioUnitNode.streamPortInputs)
+					// Search which AudioUnit has the same ClockDomain than passed StreamNode
+					if (audioUnitNode.staticModel.clockDomainIndex == streamNode.staticModel.clockDomainIndex)
 					{
-						if (streamPortNode.staticModel->clockDomainIndex == streamNode.staticModel->clockDomainIndex)
-						{
-							if (streamPortNode.staticModel->hasDynamicAudioMap)
-							{
-								auto const& streamInputNode = static_cast<la::avdecc::controller::model::StreamInputNode const&>(streamNode);
-								auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamInputNode.dynamicModel->streamFormat);
-
-								mti.supportsDynamicMappings = isValidStreamFormat(streamInputNode);
-								mti.streamPortType = la::avdecc::entity::model::DescriptorType::StreamPortInput;
-								mti.streamPortIndex = spi;
-								// Don't allow StreamInput to be configured individually to prevent user errors
-							}
-							break;
-						}
+						mti.supportsDynamicMappings = atLeastOneDynamicMappings(audioUnitNode.streamPortInputs);
+						mti.audioUnitIndex = audioUnitIndex;
+						mti.streamPortType = la::avdecc::entity::model::DescriptorType::StreamPortInput;
+						// Don't allow StreamInput to be configured individually to prevent user errors
+						break;
 					}
 				}
 			}
@@ -735,23 +799,15 @@ void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 			{
 				for (auto const& [audioUnitIndex, audioUnitNode] : controlledEntity.getCurrentConfigurationNode().audioUnits)
 				{
-					// Search which StreamPort has the same ClockDomain than passed StreamNode
-					for (auto const& [spi, streamPortNode] : audioUnitNode.streamPortOutputs)
+					// Search which AudioUnit has the same ClockDomain than passed StreamNode
+					if (audioUnitNode.staticModel.clockDomainIndex == streamNode.staticModel.clockDomainIndex)
 					{
-						if (streamPortNode.staticModel->clockDomainIndex == streamNode.staticModel->clockDomainIndex)
-						{
-							if (streamPortNode.staticModel->hasDynamicAudioMap)
-							{
-								auto const& streamOutputNode = static_cast<la::avdecc::controller::model::StreamOutputNode const&>(streamNode);
-								auto const sfi = la::avdecc::entity::model::StreamFormatInfo::create(streamOutputNode.dynamicModel->streamFormat);
-
-								mti.supportsDynamicMappings = isValidStreamFormat(streamOutputNode);
-								mti.streamPortType = la::avdecc::entity::model::DescriptorType::StreamPortOutput;
-								mti.streamPortIndex = spi;
-								mti.streamIndex = streamOutputNode.descriptorIndex;
-							}
-							break;
-						}
+						auto const& streamOutputNode = static_cast<la::avdecc::controller::model::StreamOutputNode const&>(streamNode);
+						mti.supportsDynamicMappings = atLeastOneDynamicMappings(audioUnitNode.streamPortOutputs) && isValidStreamFormat(streamOutputNode);
+						mti.audioUnitIndex = audioUnitIndex;
+						mti.streamPortType = la::avdecc::entity::model::DescriptorType::StreamPortOutput;
+						mti.streamIndex = streamOutputNode.descriptorIndex;
+						break;
 					}
 				}
 			}
@@ -832,7 +888,7 @@ void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 					}
 					else if (action == editMappingsAction)
 					{
-						handleEditMappingsClicked(entityID, mti.streamPortType, mti.streamPortIndex, mti.streamIndex);
+						handleEditMappingsClicked(entityID, mti.audioUnitIndex, mti.streamPortType, mti.streamIndex);
 					}
 				}
 			}
@@ -867,7 +923,7 @@ void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 				{
 					if (action == editMappingsAction)
 					{
-						handleEditMappingsClicked(entityID, mti.streamPortType, mti.streamPortIndex, mti.streamIndex);
+						handleEditMappingsClicked(entityID, mti.audioUnitIndex, mti.streamPortType, mti.streamIndex);
 					}
 				}
 			}
@@ -877,6 +933,12 @@ void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 
 				auto mti = findMappingsSupportTypeIndexForDescriptor(*controlledEntity, isListenersHeader() ? la::avdecc::entity::model::DescriptorType::StreamInput : la::avdecc::entity::model::DescriptorType::StreamOutput);
 
+				auto* highlightAction = static_cast<QAction*>(nullptr);
+
+				if (static_cast<View*>(parent())->isEntitiesListAttached())
+				{
+					highlightAction = addAction(menu, "Select Entity in list", true);
+				}
 				auto* editMappingsAction = addAction(menu, "Edit Dynamic Mappings...", mti.supportsDynamicMappings);
 
 				menu.addSeparator();
@@ -886,9 +948,13 @@ void HeaderView::contextMenuEvent(QContextMenuEvent* event)
 
 				if (auto* action = menu.exec(event->globalPos()))
 				{
-					if (action == editMappingsAction)
+					if (action == highlightAction)
+					{
+						emit static_cast<View*>(parent())->selectEntityRequested(entityID);
+					}
+					else if (action == editMappingsAction)
 					{
-						handleEditMappingsClicked(entityID, mti.streamPortType, mti.streamPortIndex, mti.streamIndex);
+						handleEditMappingsClicked(entityID, mti.audioUnitIndex, mti.streamPortType, mti.streamIndex);
 					}
 				}
 			}
@@ -928,9 +994,9 @@ void HeaderView::leaveEvent(QEvent* event)
 	QHeaderView::leaveEvent(event);
 }
 
-void HeaderView::handleEditMappingsClicked(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::StreamIndex const streamIndex)
+void HeaderView::handleEditMappingsClicked(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamIndex const streamIndex)
 {
-	avdecc::mappingsHelper::showMappingsEditor(this, entityID, streamPortType, streamPortIndex, streamIndex);
+	avdecc::mappingsHelper::showMappingsEditor(this, entityID, audioUnitIndex, streamPortType, std::nullopt, streamIndex);
 }
 
 } // namespace connectionMatrix
diff --git a/src/connectionMatrix/headerView.hpp b/src/connectionMatrix/headerView.hpp
index c2d63e5a..cd125aaa 100644
--- a/src/connectionMatrix/headerView.hpp
+++ b/src/connectionMatrix/headerView.hpp
@@ -64,12 +64,21 @@ class HeaderView final : public QHeaderView
 	// Collapse all child nodes of each entity
 	void collapseAll();
 
+	// Returns true if the node and all children at the specified index are expanded
+	bool isNodeAndChildrenExpanded(int logicalIndex) const;
+
+	// Expand the node and all children at the specified index
+	void expandNodeAndChildren(int logicalIndex);
+
+	// Collapse the node and all children at the specified index
+	void collapseNodeAndChildren(int logicalIndex);
+
 private:
 	void handleSectionClicked(int logicalIndex);
 	void handleSectionInserted(QModelIndex const& parent, int first, int last);
 	void handleSectionRemoved(QModelIndex const& parent, int first, int last);
 	void handleModelReset();
-	void handleEditMappingsClicked(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::StreamIndex const streamIndex);
+	void handleEditMappingsClicked(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamIndex const streamIndex);
 	void updateSectionVisibility(int const logicalIndex);
 	void applyFilterPattern();
 
diff --git a/src/connectionMatrix/model.cpp b/src/connectionMatrix/model.cpp
index c5cf5333..c1e09815 100644
--- a/src/connectionMatrix/model.cpp
+++ b/src/connectionMatrix/model.cpp
@@ -2339,21 +2339,22 @@ class ModelPrivate : public QObject
 
 			auto const isMilan = controlledEntity.getCompatibilityFlags().test(la::avdecc::controller::ControlledEntity::CompatibilityFlag::Milan);
 			auto const isRegisteredUnsol = controlledEntity.isSubscribedToUnsolicitedNotifications();
-			auto* entity = EntityNode::create(entityID, isMilan, isRegisteredUnsol);
+			auto const areUnsolSupported = controlledEntity.areUnsolicitedNotificationsSupported();
+			auto* entity = EntityNode::create(entityID, isMilan, isRegisteredUnsol, areUnsolSupported);
 			entity->setName(hive::modelsLibrary::helper::smartEntityName(controlledEntity));
 
 			auto const fillStreamOutputNode = [&controlledEntity](auto& node, auto const configurationIndex, auto const streamIndex, auto const avbInterfaceIndex, auto const& streamOutputNode, auto const& avbInterfaceNode)
 			{
 				node.setName(hive::modelsLibrary::helper::outputStreamName(controlledEntity, streamIndex));
-				node.setStreamFormat(streamOutputNode.dynamicModel->streamFormat);
-				node.setStreamFormats(streamOutputNode.staticModel->formats);
-				node.setGrandMasterID(avbInterfaceNode.dynamicModel->gptpGrandmasterID);
-				node.setGrandMasterDomain(avbInterfaceNode.dynamicModel->gptpDomainNumber);
+				node.setStreamFormat(streamOutputNode.dynamicModel.streamFormat);
+				node.setStreamFormats(streamOutputNode.staticModel.formats);
+				node.setGrandMasterID(avbInterfaceNode.dynamicModel.gptpGrandmasterID);
+				node.setGrandMasterDomain(avbInterfaceNode.dynamicModel.gptpDomainNumber);
 				node.setInterfaceLinkStatus(controlledEntity.getAvbInterfaceLinkStatus(avbInterfaceIndex));
 				node.setRunning(controlledEntity.isStreamOutputRunning(configurationIndex, streamIndex));
-				if (streamOutputNode.dynamicModel->counters)
+				if (streamOutputNode.dynamicModel.counters)
 				{
-					auto const& counters = *streamOutputNode.dynamicModel->counters;
+					auto const& counters = *streamOutputNode.dynamicModel.counters;
 					{
 						auto const it = counters.find(la::avdecc::entity::StreamOutputCounterValidFlag::StreamStart);
 						if (it != counters.end())
@@ -2384,14 +2385,14 @@ class ModelPrivate : public QObject
 					redundantOutput->setName(hive::modelsLibrary::helper::redundantOutputName(redundantIndex));
 				}
 
-				for (auto const& [streamIndex, streamNode] : redundantNode.redundantStreams)
+				for (auto const streamIndex : redundantNode.redundantStreams)
 				{
-					auto const avbInterfaceIndex{ streamNode->staticModel->avbInterfaceIndex };
+					auto const& streamNode = controlledEntity.getStreamOutputNode(configurationIndex, streamIndex);
+					auto const avbInterfaceIndex{ streamNode.staticModel.avbInterfaceIndex };
 					auto const& avbInterfaceNode = controlledEntity.getAvbInterfaceNode(configurationIndex, avbInterfaceIndex);
 
 					auto* redundantOutputStream = StreamNode::createRedundantOutputNode(*redundantOutput, streamIndex, avbInterfaceIndex);
-					auto const* const streamOutputNode = static_cast<la::avdecc::controller::model::StreamOutputNode const*>(streamNode);
-					fillStreamOutputNode(*redundantOutputStream, configurationIndex, streamIndex, avbInterfaceIndex, *streamOutputNode, avbInterfaceNode);
+					fillStreamOutputNode(*redundantOutputStream, configurationIndex, streamIndex, avbInterfaceIndex, streamNode, avbInterfaceNode);
 				}
 			}
 
@@ -2400,7 +2401,7 @@ class ModelPrivate : public QObject
 			{
 				if (!streamNode.isRedundant)
 				{
-					auto const avbInterfaceIndex{ streamNode.staticModel->avbInterfaceIndex };
+					auto const avbInterfaceIndex{ streamNode.staticModel.avbInterfaceIndex };
 					auto const& avbInterfaceNode = controlledEntity.getAvbInterfaceNode(configurationIndex, avbInterfaceIndex);
 
 					auto* outputStream = StreamNode::createOutputNode(*entity, streamIndex, avbInterfaceIndex);
@@ -2416,19 +2417,19 @@ class ModelPrivate : public QObject
 					for (auto const& [streamPortIndex, streamPortNode] : audioUnitNode.streamPortOutputs)
 					{
 						// Save ChannelOffset for this StreamPort
-						entity->setStreamPortOutputClusterOffset(streamPortIndex, streamPortNode.staticModel->baseCluster);
+						entity->setStreamPortOutputClusterOffset(streamPortIndex, streamPortNode.staticModel.baseCluster);
 
-						if (streamPortNode.staticModel->hasDynamicAudioMap)
+						if (streamPortNode.staticModel.hasDynamicAudioMap)
 						{
 							// Save current mappings (we want all mappings, including redundant)
-							entity->setOutputAudioMappings(streamPortIndex, streamPortNode.dynamicModel->dynamicAudioMap);
+							entity->setOutputAudioMappings(streamPortIndex, streamPortNode.dynamicModel.dynamicAudioMap);
 						}
 						else
 						{
 							la::avdecc::entity::model::AudioMappings staticMappings;
 							for (auto const& mapKV : streamPortNode.audioMaps)
 							{
-								staticMappings.insert(staticMappings.end(), mapKV.second.staticModel->mappings.begin(), mapKV.second.staticModel->mappings.end());
+								staticMappings.insert(staticMappings.end(), mapKV.second.staticModel.mappings.begin(), mapKV.second.staticModel.mappings.end());
 							}
 							entity->setOutputAudioMappings(streamPortIndex, staticMappings);
 						}
@@ -2436,10 +2437,10 @@ class ModelPrivate : public QObject
 						// Process all Clusters
 						for (auto const& [clusterIndex, clusterNode] : streamPortNode.audioClusters)
 						{
-							auto const* const staticModel = clusterNode.staticModel;
-							for (auto channel = (uint16_t)0u; channel < staticModel->channelCount; ++channel)
+							auto const& staticModel = clusterNode.staticModel;
+							for (auto channel = (uint16_t)0u; channel < staticModel.channelCount; ++channel)
 							{
-								auto channelIdentification = avdecc::ChannelIdentification{ configurationNode.descriptorIndex, clusterIndex, channel, avdecc::ChannelConnectionDirection::InputToOutput, audioUnitIndex, streamPortIndex, streamPortNode.staticModel->baseCluster };
+								auto channelIdentification = avdecc::ChannelIdentification{ configurationNode.descriptorIndex, clusterIndex, channel, avdecc::ChannelConnectionDirection::InputToOutput, audioUnitIndex, streamPortIndex, streamPortNode.staticModel.baseCluster };
 
 								auto* outputChannel = ChannelNode::createOutputNode(*entity, channelIdentification);
 								auto const clusterName = hive::modelsLibrary::helper::objectName(&controlledEntity, streamPortNode.audioClusters.at(clusterIndex));
@@ -2476,22 +2477,23 @@ class ModelPrivate : public QObject
 
 			auto const isMilan = controlledEntity.getCompatibilityFlags().test(la::avdecc::controller::ControlledEntity::CompatibilityFlag::Milan);
 			auto const isRegisteredUnsol = controlledEntity.isSubscribedToUnsolicitedNotifications();
-			auto* entity = EntityNode::create(entityID, isMilan, isRegisteredUnsol);
+			auto const areUnsolSupported = controlledEntity.areUnsolicitedNotificationsSupported();
+			auto* entity = EntityNode::create(entityID, isMilan, isRegisteredUnsol, areUnsolSupported);
 			entity->setName(hive::modelsLibrary::helper::smartEntityName(controlledEntity));
 
 			auto const fillStreamInputNode = [&controlledEntity](auto& node, auto const configurationIndex, auto const streamIndex, auto const avbInterfaceIndex, auto const& streamInputNode, auto const& avbInterfaceNode)
 			{
 				node.setName(hive::modelsLibrary::helper::inputStreamName(controlledEntity, streamIndex));
-				node.setStreamFormat(streamInputNode.dynamicModel->streamFormat);
-				node.setStreamFormats(streamInputNode.staticModel->formats);
-				node.setGrandMasterID(avbInterfaceNode.dynamicModel->gptpGrandmasterID);
-				node.setGrandMasterDomain(avbInterfaceNode.dynamicModel->gptpDomainNumber);
+				node.setStreamFormat(streamInputNode.dynamicModel.streamFormat);
+				node.setStreamFormats(streamInputNode.staticModel.formats);
+				node.setGrandMasterID(avbInterfaceNode.dynamicModel.gptpGrandmasterID);
+				node.setGrandMasterDomain(avbInterfaceNode.dynamicModel.gptpDomainNumber);
 				node.setInterfaceLinkStatus(controlledEntity.getAvbInterfaceLinkStatus(avbInterfaceIndex));
 				node.setRunning(controlledEntity.isStreamInputRunning(configurationIndex, streamIndex));
-				node.setStreamInputConnectionInformation(streamInputNode.dynamicModel->connectionInfo);
-				if (streamInputNode.dynamicModel->counters)
+				node.setStreamInputConnectionInformation(streamInputNode.dynamicModel.connectionInfo);
+				if (streamInputNode.dynamicModel.counters)
 				{
-					auto const& counters = *streamInputNode.dynamicModel->counters;
+					auto const& counters = *streamInputNode.dynamicModel.counters;
 					{
 						auto const it = counters.find(la::avdecc::entity::StreamInputCounterValidFlag::MediaLocked);
 						if (it != counters.end())
@@ -2507,9 +2509,9 @@ class ModelPrivate : public QObject
 						}
 					}
 				}
-				if (streamInputNode.dynamicModel->streamDynamicInfo && (*streamInputNode.dynamicModel->streamDynamicInfo).probingStatus)
+				if (streamInputNode.dynamicModel.streamDynamicInfo && (*streamInputNode.dynamicModel.streamDynamicInfo).probingStatus)
 				{
-					node.setProbingStatus(*(*streamInputNode.dynamicModel->streamDynamicInfo).probingStatus);
+					node.setProbingStatus(*(*streamInputNode.dynamicModel.streamDynamicInfo).probingStatus);
 				}
 				// Latency Error
 				{
@@ -2534,16 +2536,15 @@ class ModelPrivate : public QObject
 					redundantInput->setName(hive::modelsLibrary::helper::redundantInputName(redundantIndex));
 				}
 
-				for (auto const& [streamIndex, streamNode] : redundantNode.redundantStreams)
+				for (auto const streamIndex : redundantNode.redundantStreams)
 				{
-					auto const avbInterfaceIndex{ streamNode->staticModel->avbInterfaceIndex };
+					auto const& streamNode = controlledEntity.getStreamInputNode(configurationIndex, streamIndex);
+					auto const avbInterfaceIndex{ streamNode.staticModel.avbInterfaceIndex };
 					auto const& avbInterfaceNode = controlledEntity.getAvbInterfaceNode(configurationIndex, avbInterfaceIndex);
 
 					auto* redundantInputStream = StreamNode::createRedundantInputNode(*redundantInput, streamIndex, avbInterfaceIndex);
 					redundantInputStream->setName(hive::modelsLibrary::helper::inputStreamName(controlledEntity, streamIndex));
-
-					auto const* const streamInputNode = static_cast<la::avdecc::controller::model::StreamInputNode const*>(streamNode);
-					fillStreamInputNode(*redundantInputStream, configurationIndex, streamIndex, avbInterfaceIndex, *streamInputNode, avbInterfaceNode);
+					fillStreamInputNode(*redundantInputStream, configurationIndex, streamIndex, avbInterfaceIndex, streamNode, avbInterfaceNode);
 				}
 			}
 
@@ -2552,7 +2553,7 @@ class ModelPrivate : public QObject
 			{
 				if (!streamNode.isRedundant)
 				{
-					auto const avbInterfaceIndex{ streamNode.staticModel->avbInterfaceIndex };
+					auto const avbInterfaceIndex{ streamNode.staticModel.avbInterfaceIndex };
 					auto const& avbInterfaceNode = controlledEntity.getAvbInterfaceNode(configurationIndex, avbInterfaceIndex);
 
 					auto* inputStream = StreamNode::createInputNode(*entity, streamIndex, avbInterfaceIndex);
@@ -2567,21 +2568,21 @@ class ModelPrivate : public QObject
 				{
 					for (auto const& [streamPortIndex, streamPortNode] : audioUnitNode.streamPortInputs)
 					{
-						if (streamPortNode.staticModel->hasDynamicAudioMap)
+						if (streamPortNode.staticModel.hasDynamicAudioMap)
 						{
 							// Save ChannelOffset for this StreamPort
-							entity->setStreamPortInputClusterOffset(streamPortIndex, streamPortNode.staticModel->baseCluster);
+							entity->setStreamPortInputClusterOffset(streamPortIndex, streamPortNode.staticModel.baseCluster);
 
 							// Save current mappings (we want all mappings, including redundant)
-							entity->setInputAudioMappings(streamPortIndex, streamPortNode.dynamicModel->dynamicAudioMap);
+							entity->setInputAudioMappings(streamPortIndex, streamPortNode.dynamicModel.dynamicAudioMap);
 
 							// Process all Clusters
 							for (auto const& [clusterIndex, clusterNode] : streamPortNode.audioClusters)
 							{
-								auto const* const staticModel = clusterNode.staticModel;
-								for (auto channel = (uint16_t)0u; channel < staticModel->channelCount; ++channel)
+								auto const& staticModel = clusterNode.staticModel;
+								for (auto channel = (uint16_t)0u; channel < staticModel.channelCount; ++channel)
 								{
-									auto channelIdentification = avdecc::ChannelIdentification{ configurationNode.descriptorIndex, clusterIndex, channel, avdecc::ChannelConnectionDirection::InputToOutput, audioUnitIndex, streamPortIndex, streamPortNode.staticModel->baseCluster };
+									auto channelIdentification = avdecc::ChannelIdentification{ configurationNode.descriptorIndex, clusterIndex, channel, avdecc::ChannelConnectionDirection::InputToOutput, audioUnitIndex, streamPortIndex, streamPortNode.staticModel.baseCluster };
 
 									auto* inputChannel = ChannelNode::createInputNode(*entity, channelIdentification);
 									auto const clusterName = hive::modelsLibrary::helper::objectName(&controlledEntity, streamPortNode.audioClusters.at(clusterIndex));
@@ -2858,7 +2859,7 @@ class ModelPrivate : public QObject
 				}
 
 				auto const& entityNode = controlledEntity->getEntityNode();
-				auto const& configurationNode = controlledEntity->getConfigurationNode(entityNode.dynamicModel->currentConfiguration);
+				auto const& configurationNode = controlledEntity->getConfigurationNode(entityNode.dynamicModel.currentConfiguration);
 
 				// Talker
 				if (controlledEntity->getEntity().getTalkerCapabilities().test(la::avdecc::entity::TalkerCapability::Implemented) && !configurationNode.streamOutputs.empty())
@@ -3537,7 +3538,7 @@ class ModelPrivate : public QObject
 			auto const& entityNode = controlledEntity->getEntityNode();
 
 			// We're only interested in the current configuration
-			if (entityNode.dynamicModel->currentConfiguration != configurationIndex)
+			if (entityNode.dynamicModel.currentConfiguration != configurationIndex)
 			{
 				return;
 			}
diff --git a/src/connectionMatrix/node.cpp b/src/connectionMatrix/node.cpp
index aae220f8..802b2c09 100644
--- a/src/connectionMatrix/node.cpp
+++ b/src/connectionMatrix/node.cpp
@@ -225,9 +225,9 @@ OfflineOutputStreamNode::OfflineOutputStreamNode() noexcept
 /* ************************************************************ */
 /* EntityNode                                                   */
 /* ************************************************************ */
-EntityNode* EntityNode::create(la::avdecc::UniqueIdentifier const& entityID, bool const isMilan, bool const isRegisteredUnsol) noexcept
+EntityNode* EntityNode::create(la::avdecc::UniqueIdentifier const& entityID, bool const isMilan, bool const isRegisteredUnsol, bool const areUnsolSupported) noexcept
 {
-	return new EntityNode{ entityID, isMilan, isRegisteredUnsol };
+	return new EntityNode{ entityID, isMilan, isRegisteredUnsol, areUnsolSupported };
 }
 
 void EntityNode::accept(la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, AvbInterfaceIndexVisitor const& visitor) const noexcept
@@ -246,10 +246,11 @@ void EntityNode::accept(la::avdecc::entity::model::AvbInterfaceIndex const avbIn
 		});
 }
 
-EntityNode::EntityNode(la::avdecc::UniqueIdentifier const& entityID, bool const isMilan, bool const isRegisteredUnsol) noexcept
+EntityNode::EntityNode(la::avdecc::UniqueIdentifier const& entityID, bool const isMilan, bool const isRegisteredUnsol, bool const areUnsolSupported) noexcept
 	: Node{ Type::Entity, entityID, nullptr }
 	, _isMilan{ isMilan }
 	, _isRegisteredUnsol{ isRegisteredUnsol }
+	, _areUnsolSupported{ areUnsolSupported }
 {
 }
 
@@ -288,6 +289,11 @@ bool EntityNode::isRegisteredUnsol() const noexcept
 	return _isRegisteredUnsol;
 }
 
+bool EntityNode::areUnsolSupported() const noexcept
+{
+	return _areUnsolSupported;
+}
+
 la::avdecc::entity::model::ClusterIndex EntityNode::getStreamPortInputClusterOffset(la::avdecc::entity::model::StreamPortIndex const streamPortIndex) const
 {
 	if (auto const it = _streamPortInputClusterOffset.find(streamPortIndex); it != _streamPortInputClusterOffset.end())
diff --git a/src/connectionMatrix/node.hpp b/src/connectionMatrix/node.hpp
index 2bac24a7..0323a7df 100644
--- a/src/connectionMatrix/node.hpp
+++ b/src/connectionMatrix/node.hpp
@@ -219,7 +219,7 @@ class EntityNode : public Node
 	friend class ModelPrivate;
 
 public:
-	static EntityNode* create(la::avdecc::UniqueIdentifier const& entityID, bool const isMilan, bool const isRegisteredUnsol) noexcept;
+	static EntityNode* create(la::avdecc::UniqueIdentifier const& entityID, bool const isMilan, bool const isRegisteredUnsol, bool const areUnsolSupported) noexcept;
 
 	// Visitor pattern that is called on every stream node that matches avbInterfaceIndex
 	using AvbInterfaceIndexVisitor = std::function<void(class StreamNode*)>;
@@ -227,6 +227,7 @@ class EntityNode : public Node
 
 	bool isMilan() const noexcept;
 	bool isRegisteredUnsol() const noexcept;
+	bool areUnsolSupported() const noexcept;
 	la::avdecc::entity::model::ClusterIndex getStreamPortInputClusterOffset(la::avdecc::entity::model::StreamPortIndex const streamPortIndex) const;
 	la::avdecc::entity::model::ClusterIndex getStreamPortOutputClusterOffset(la::avdecc::entity::model::StreamPortIndex const streamPortIndex) const;
 	la::avdecc::entity::model::AudioMappings const& getInputAudioMappings(la::avdecc::entity::model::StreamPortIndex const streamPortInputIndex) const;
@@ -235,7 +236,7 @@ class EntityNode : public Node
 	std::unordered_map<la::avdecc::entity::model::StreamPortIndex, la::avdecc::entity::model::AudioMappings> getOutputAudioMappings() const noexcept;
 
 protected:
-	EntityNode(la::avdecc::UniqueIdentifier const& entityID, bool const isMilan, bool const isRegisteredUnsol) noexcept;
+	EntityNode(la::avdecc::UniqueIdentifier const& entityID, bool const isMilan, bool const isRegisteredUnsol, bool const areUnsolSupported) noexcept;
 	void setRegisteredUnsol(bool const isRegisteredUnsol) noexcept;
 	void setStreamPortInputClusterOffset(la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::ClusterIndex const clusterOffset) noexcept;
 	void setStreamPortOutputClusterOffset(la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::ClusterIndex const clusterOffset) noexcept;
@@ -245,6 +246,7 @@ class EntityNode : public Node
 protected:
 	bool _isMilan{ false };
 	bool _isRegisteredUnsol{ false };
+	bool _areUnsolSupported{ false };
 	std::unordered_map<la::avdecc::entity::model::StreamPortIndex, la::avdecc::entity::model::ClusterIndex> _streamPortInputClusterOffset{};
 	std::unordered_map<la::avdecc::entity::model::StreamPortIndex, la::avdecc::entity::model::ClusterIndex> _streamPortOutputClusterOffset{};
 	std::unordered_map<la::avdecc::entity::model::StreamPortIndex, la::avdecc::entity::model::AudioMappings> _inputMappings{};
diff --git a/src/connectionMatrix/paintHelper.cpp b/src/connectionMatrix/paintHelper.cpp
index 2dd66f78..6c1b273b 100644
--- a/src/connectionMatrix/paintHelper.cpp
+++ b/src/connectionMatrix/paintHelper.cpp
@@ -301,7 +301,9 @@ void drawCapabilities(QPainter* painter, QRect const& rect, Model::IntersectionD
 
 	auto const drawInvalidIntersection = [painter, &rect]()
 	{
-		painter->fillRect(rect, QBrush{ 0xE1E1E1, Qt::BDiagPattern });
+		auto brush = qtMate::material::color::brush(qtMate::material::color::Name::Gray, qtMate::material::color::isDarkColorScheme() ? qtMate::material::color::Shade::Shade800 : qtMate::material::color::Shade::Shade300);
+		brush.setStyle(Qt::BrushStyle::BDiagPattern);
+		painter->fillRect(rect, brush);
 	};
 	auto const drawEntitySummaryIntersection = [painter, &rect, state, flags, drawMediaLockedDot](auto const brush, auto const penColor, auto const penWidth)
 	{
diff --git a/src/connectionMatrix/view.cpp b/src/connectionMatrix/view.cpp
index 50f94adc..390d109b 100644
--- a/src/connectionMatrix/view.cpp
+++ b/src/connectionMatrix/view.cpp
@@ -131,6 +131,26 @@ QLineEdit* View::listenerFilterLineEdit() noexcept
 	return _cornerWidget->filterLineEdit();
 }
 
+bool View::isEntitiesListAttached() const noexcept
+{
+	return _countEntitiesListAttached > 0u;
+}
+
+void View::entitiesListAttached(bool const isAttached)
+{
+	if (isAttached)
+	{
+		++_countEntitiesListAttached;
+	}
+	else
+	{
+		if (AVDECC_ASSERT_WITH_RET(_countEntitiesListAttached > 0u, "_countEntitiesListAttached should not be 0 already"))
+		{
+			--_countEntitiesListAttached;
+		}
+	}
+}
+
 void View::onIntersectionClicked(QModelIndex const& index)
 {
 	auto const& intersectionData = _model->intersectionData(index);
@@ -279,9 +299,9 @@ void View::onIntersectionClicked(QModelIndex const& index)
 					{
 						for (auto const& talkerAudioClusterKV : talkerStreamPortOutputKV.second.audioClusters)
 						{
-							for (uint16_t channel = 0; channel < talkerAudioClusterKV.second.staticModel->channelCount; channel++)
+							for (uint16_t channel = 0; channel < talkerAudioClusterKV.second.staticModel.channelCount; channel++)
 							{
-								talkerChannels.emplace_back(avdecc::ChannelIdentification{ talkerConfiguration.descriptorIndex, talkerAudioClusterKV.first, channel, avdecc::ChannelConnectionDirection::OutputToInput, talkerAudioUnitKV.first, talkerStreamPortOutputKV.first, talkerStreamPortOutputKV.second.staticModel->baseCluster });
+								talkerChannels.emplace_back(avdecc::ChannelIdentification{ talkerConfiguration.descriptorIndex, talkerAudioClusterKV.first, channel, avdecc::ChannelConnectionDirection::OutputToInput, talkerAudioUnitKV.first, talkerStreamPortOutputKV.first, talkerStreamPortOutputKV.second.staticModel.baseCluster });
 							}
 						}
 					}
@@ -293,9 +313,9 @@ void View::onIntersectionClicked(QModelIndex const& index)
 					{
 						for (auto const& listenerAudioClusterKV : listenerStreamPortOutputKV.second.audioClusters)
 						{
-							for (uint16_t channel = 0; channel < listenerAudioClusterKV.second.staticModel->channelCount; channel++)
+							for (uint16_t channel = 0; channel < listenerAudioClusterKV.second.staticModel.channelCount; channel++)
 							{
-								listenerChannels.emplace_back(avdecc::ChannelIdentification{ listenerConfiguration.descriptorIndex, listenerAudioClusterKV.first, channel, avdecc::ChannelConnectionDirection::InputToOutput, listenerAudioUnitKV.first, listenerStreamPortOutputKV.first, listenerStreamPortOutputKV.second.staticModel->baseCluster });
+								listenerChannels.emplace_back(avdecc::ChannelIdentification{ listenerConfiguration.descriptorIndex, listenerAudioClusterKV.first, channel, avdecc::ChannelConnectionDirection::InputToOutput, listenerAudioUnitKV.first, listenerStreamPortOutputKV.first, listenerStreamPortOutputKV.second.staticModel.baseCluster });
 							}
 						}
 					}
@@ -321,6 +341,25 @@ void View::onIntersectionClicked(QModelIndex const& index)
 				};
 				handleChannelCreationResult(error, false, true, elevatedRightsCallback);
 			}
+			else
+			{
+				// Expand/collapse the entity (if both talker and listener are expanded, collapse them. Otherwise, expand them)
+				auto const row = index.row();
+				auto const column = index.column();
+				auto const horizontalExpanded = _horizontalHeaderView->isNodeAndChildrenExpanded(column);
+				auto const verticalExpanded = _verticalHeaderView->isNodeAndChildrenExpanded(row);
+
+				if (horizontalExpanded && verticalExpanded)
+				{
+					_horizontalHeaderView->collapseNodeAndChildren(column);
+					_verticalHeaderView->collapseNodeAndChildren(row);
+				}
+				else
+				{
+					_horizontalHeaderView->expandNodeAndChildren(column);
+					_verticalHeaderView->expandNodeAndChildren(row);
+				}
+			}
 			break;
 		}
 
@@ -356,9 +395,9 @@ void View::onIntersectionClicked(QModelIndex const& index)
 					{
 						for (auto const& listenerAudioClusterKV : listenerStreamPortOutputKV.second.audioClusters)
 						{
-							for (uint16_t channel = 0; channel < listenerAudioClusterKV.second.staticModel->channelCount; channel++)
+							for (uint16_t channel = 0; channel < listenerAudioClusterKV.second.staticModel.channelCount; channel++)
 							{
-								listenerChannels.emplace_back(avdecc::ChannelIdentification{ listenerConfiguration.descriptorIndex, listenerAudioClusterKV.first, channel, avdecc::ChannelConnectionDirection::InputToOutput, listenerAudioUnitKV.first, listenerStreamPortOutputKV.first, listenerStreamPortOutputKV.second.staticModel->baseCluster });
+								listenerChannels.emplace_back(avdecc::ChannelIdentification{ listenerConfiguration.descriptorIndex, listenerAudioClusterKV.first, channel, avdecc::ChannelConnectionDirection::InputToOutput, listenerAudioUnitKV.first, listenerStreamPortOutputKV.first, listenerStreamPortOutputKV.second.staticModel.baseCluster });
 							}
 						}
 					}
diff --git a/src/connectionMatrix/view.hpp b/src/connectionMatrix/view.hpp
index a4be622b..3387cbe2 100644
--- a/src/connectionMatrix/view.hpp
+++ b/src/connectionMatrix/view.hpp
@@ -48,6 +48,13 @@ class View final : public QTableView, private settings::SettingsManager::Observe
 	QLineEdit* talkerFilterLineEdit() noexcept;
 	QLineEdit* listenerFilterLineEdit() noexcept;
 
+	// Other methods
+	bool isEntitiesListAttached() const noexcept;
+	void entitiesListAttached(bool const isAttached);
+
+	// Public signals
+	Q_SIGNAL void selectEntityRequested(la::avdecc::UniqueIdentifier const entityID);
+
 private:
 	void onIntersectionClicked(QModelIndex const& index);
 	void onCustomContextMenuRequested(QPoint const& pos);
@@ -70,6 +77,7 @@ class View final : public QTableView, private settings::SettingsManager::Observe
 	std::unique_ptr<HeaderView> _verticalHeaderView;
 	std::unique_ptr<ItemDelegate> _itemDelegate;
 	std::unique_ptr<CornerWidget> _cornerWidget;
+	std::uint32_t _countEntitiesListAttached{ 0u };
 };
 
 } // namespace connectionMatrix
diff --git a/src/controlledEntityTreeWidget.cpp b/src/controlledEntityTreeWidget.cpp
index cb34d631..b525972c 100644
--- a/src/controlledEntityTreeWidget.cpp
+++ b/src/controlledEntityTreeWidget.cpp
@@ -26,23 +26,13 @@
 #include <la/avdecc/controller/internals/avdeccControlledEntity.hpp>
 #include <hive/modelsLibrary/helper.hpp>
 #include <hive/modelsLibrary/controllerManager.hpp>
+#include <hive/widgetModelsLibrary/qtUserRoles.hpp>
 
 #include <QHeaderView>
 #include <QMenu>
 
 #include <unordered_set>
 
-namespace priv
-{
-void useBoldFont(QTreeWidgetItem* item, bool const bold)
-{
-	auto font = item->data(0, Qt::FontRole).value<QFont>();
-	font.setBold(bold);
-	item->setData(0, Qt::FontRole, font);
-}
-
-} // namespace priv
-
 // Base node item
 class NodeItem : public QObject, public QTreeWidgetItem
 {
@@ -57,6 +47,8 @@ class NodeItem : public QObject, public QTreeWidgetItem
 		// StreamInput Level
 		StreamInputCounter = 1u << 2,
 		StreamInputLatency = 1u << 3,
+		// Control Level
+		ControlValueOutOfBounds = 1u << 4,
 	};
 	using ErrorBits = la::avdecc::utils::EnumBitfield<ErrorBit>;
 
@@ -87,8 +79,7 @@ class NodeItem : public QObject, public QTreeWidgetItem
 		}
 
 		auto const inError = hasError();
-		setData(0, la::avdecc::utils::to_integral(EntityInspector::RoleInfo::ErrorRole), inError);
-		setForeground(0, inError ? Qt::red : Qt::black);
+		setData(0, la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ErrorRole), inError);
 
 		// Also update the parent node
 		if (auto* parent = static_cast<NodeItem*>(QTreeWidgetItem::parent()))
@@ -110,8 +101,7 @@ class NodeItem : public QObject, public QTreeWidgetItem
 		_errorBits = errorBits;
 
 		auto const inError = hasError();
-		setData(0, la::avdecc::utils::to_integral(EntityInspector::RoleInfo::ErrorRole), inError);
-		setForeground(0, inError ? Qt::red : Qt::black);
+		setData(0, la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ErrorRole), inError);
 	}
 
 	ErrorBits getErrorBits() const noexcept
@@ -256,6 +246,7 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::statisticsErrorCounterChanged, this, &ControlledEntityTreeWidgetPrivate::statisticsErrorCounterChanged);
 		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::redundancyWarningChanged, this, &ControlledEntityTreeWidgetPrivate::redundancyWarningChanged);
 		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::streamInputLatencyErrorChanged, this, &ControlledEntityTreeWidgetPrivate::handleStreamInputLatencyErrorChanged);
+		connect(&controllerManager, &hive::modelsLibrary::ControllerManager::controlCurrentValueOutOfBoundsChanged, this, &ControlledEntityTreeWidgetPrivate::handleControlCurrentValueOutOfBoundsChanged);
 
 		// Configure settings observers
 		auto const* const settings = qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>();
@@ -349,6 +340,19 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 		}
 	}
 
+	Q_SLOT void handleControlCurrentValueOutOfBoundsChanged(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex, bool const isValueOutOfBounds)
+	{
+		if (entityID != _controlledEntityID)
+		{
+			return;
+		}
+
+		if (auto* item = findItem({ _currentConfigurationIndex, la::avdecc::entity::model::DescriptorType::Control, controlIndex }))
+		{
+			item->setErrorBit(NodeItem::ErrorBit::ControlValueOutOfBounds, isValueOutOfBounds);
+		}
+	}
+
 	void saveUserTreeWidgetState()
 	{
 		// Build expanded state
@@ -508,7 +512,7 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 			{
 				auto const& anyNode = item->data(0, la::avdecc::utils::to_integral(EntityInspector::RoleInfo::NodeType)).value<AnyNode>().getNode();
 				auto const* configurationNode = std::any_cast<la::avdecc::controller::model::ConfigurationNode const*>(anyNode);
-				auto const isEnabled = !configurationNode->dynamicModel->isActiveConfiguration;
+				auto const isEnabled = !configurationNode->dynamicModel.isActiveConfiguration;
 
 				showSetDescriptorAsCurrentMenu(pos, item, "Set As Current Configuration", isEnabled,
 					[this, configurationIndex = nodeIdentifier.index]()
@@ -529,7 +533,7 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 
 						auto const clockDomainIndex = clockDomainNode->descriptorIndex;
 						auto const clockSourceIndex = nodeIdentifier.index;
-						auto const isEnabled = clockDomainNode->dynamicModel->clockSourceIndex != clockSourceIndex;
+						auto const isEnabled = clockDomainNode->dynamicModel.clockSourceIndex != clockSourceIndex;
 
 						showSetDescriptorAsCurrentMenu(pos, item, "Set As Current Clock Source", isEnabled,
 							[this, clockDomainIndex, clockSourceIndex]()
@@ -627,27 +631,58 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 		return item;
 	}
 
+	QString genDescriptorName(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, la::avdecc::entity::model::LocalizedStringReference const& localizedDescription, QString const& name)
+	{
+		auto objName = hive::modelsLibrary::helper::localizedString(*controlledEntity, configurationIndex, localizedDescription);
+
+		// Only use name for current configuration (and all ConfigurationDescriptors)
+		if ((descriptorType == la::avdecc::entity::model::DescriptorType::Configuration || configurationIndex == controlledEntity->getEntityNode().dynamicModel.currentConfiguration) && !name.isEmpty())
+		{
+			objName = name;
+		}
+
+		return QString("%1.%2: %3").arg(avdecc::helper::descriptorTypeToString(descriptorType), QString::number(descriptorIndex), objName);
+	}
+	QString genDescriptorName(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, la::avdecc::entity::model::LocalizedStringReference const& localizedDescription, la::avdecc::entity::model::AvdeccFixedString const& name)
+	{
+		auto qName = QString::fromStdString(name.data());
+		return genDescriptorName(controlledEntity, configurationIndex, descriptorType, descriptorIndex, localizedDescription, qName);
+	}
+	void updateName(NodeItem* item, la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, la::avdecc::entity::model::LocalizedStringReference const& localizedDescription, QString const& name)
+	{
+		auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
+		auto controlledEntity = manager.getControlledEntity(entityID);
+
+		// Filter configuration, we currently expand nodes only for current configuration
+		if (controlledEntity && configurationIndex == controlledEntity->getEntityNode().dynamicModel.currentConfiguration)
+		{
+			auto descName = genDescriptorName(controlledEntity.get(), configurationIndex, descriptorType, descriptorIndex, localizedDescription, name);
+			item->setData(0, Qt::DisplayRole, descName);
+		}
+	}
+
+	// la::avdecc::controller::model::EntityModelVisitor overrides
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::EntityNode const& node) noexcept override
 	{
-		_currentConfigurationIndex = node.dynamicModel->currentConfiguration;
+		_currentConfigurationIndex = node.dynamicModel.currentConfiguration;
 
 		auto genName = [type = node.descriptorType](QString const& name)
 		{
 			return QString("%1: %2").arg(avdecc::helper::descriptorTypeToString(type), name);
 		};
 		// Use Index 0 as ConfigurationIndex for the Entity Descriptor
-		auto* item = addItem<la::avdecc::controller::model::Node const*>(la::avdecc::entity::model::ConfigurationIndex{ 0u }, nullptr, &node, genName(node.dynamicModel->entityName.data()));
+		auto* item = addItem<la::avdecc::controller::model::Node const*>(la::avdecc::entity::model::ConfigurationIndex{ 0u }, nullptr, &node, genName(node.dynamicModel.entityName.data()));
 
 		auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
 
 		// Init ErrorBits
 		{
 			// Statistics
-			auto const errorCounters = manager.getStatisticsCounters(_controlledEntityID); // Why not directly use value from ControlledEntity??
+			auto const errorCounters = manager.getStatisticsCounters(_controlledEntityID);
 			item->setErrorBit(NodeItem::ErrorBit::EntityStatistics, !errorCounters.empty());
 
 			// Redundancy Warning
-			auto const redundancyWarning = manager.getDiagnostics(_controlledEntityID).redundancyWarning; // Why not directly use value from ControlledEntity??
+			auto const redundancyWarning = manager.getDiagnostics(_controlledEntityID).redundancyWarning;
 			item->setErrorBit(NodeItem::ErrorBit::EntityRedundancyWarning, redundancyWarning);
 		}
 
@@ -664,101 +699,74 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::EntityNode const* const parent, la::avdecc::controller::model::ConfigurationNode const& node) noexcept override
 	{
-		auto genName = [type = node.descriptorType, index = node.descriptorIndex](QString const& name)
-		{
-			return QString("%1.%2: %3").arg(avdecc::helper::descriptorTypeToString(type), QString::number(index), name);
-		};
-		auto* item = addItem(node.descriptorIndex, parent, &node, genName(hive::modelsLibrary::helper::configurationName(controlledEntity, node)));
+		auto descName = genDescriptorName(controlledEntity, node.descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
+		auto* item = addItem(node.descriptorIndex, parent, &node, descName);
 
 		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::configurationNameChanged, item,
-			[this, genName, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, QString const& /*configurationName*/)
+			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, QString const& configurationName)
 			{
 				if (entityID == _controlledEntityID && configurationIndex == node.descriptorIndex)
 				{
 					auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
 					auto controlledEntity = manager.getControlledEntity(entityID);
-
 					if (controlledEntity)
 					{
-						auto name = genName(hive::modelsLibrary::helper::configurationName(controlledEntity.get(), node));
-						item->setData(0, Qt::DisplayRole, name);
+						auto descName = genDescriptorName(controlledEntity.get(), configurationIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, configurationName);
+						item->setData(0, Qt::DisplayRole, descName);
 					}
 				}
 			});
 
-		if (node.dynamicModel->isActiveConfiguration)
+		if (node.dynamicModel.isActiveConfiguration)
 		{
-			priv::useBoldFont(item, true);
+			// Set the ActiveRole
+			item->setData(0, la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ActiveRole), true);
 
 			Q_Q(ControlledEntityTreeWidget);
 			item->setExpanded(true);
 		}
 	}
 
-	template<class Node>
-	QString genName(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, Node const& node)
-	{
-		auto objName = hive::modelsLibrary::helper::localizedString(*controlledEntity, node.staticModel->localizedDescription);
-
-		// Only use name for current configuration
-		if (configurationIndex == controlledEntity->getEntityNode().dynamicModel->currentConfiguration && !node.dynamicModel->objectName.empty())
-		{
-			objName = node.dynamicModel->objectName.data();
-		}
-
-		return QString("%1.%2: %3").arg(avdecc::helper::descriptorTypeToString(node.descriptorType), QString::number(node.descriptorIndex), objName);
-	}
-	template<class Node>
-	void updateName(NodeItem* item, Node const& node, la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::DescriptorIndex const descriptorIndex)
-	{
-		if (entityID == _controlledEntityID && descriptorType == node.descriptorType && descriptorIndex == node.descriptorIndex)
-		{
-			auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
-			auto controlledEntity = manager.getControlledEntity(entityID);
-
-			// Filter configuration, we currently expand nodes only for current configuration
-			if (controlledEntity && configurationIndex == controlledEntity->getEntityNode().dynamicModel->currentConfiguration)
-			{
-				auto name = genName(controlledEntity.get(), configurationIndex, node);
-				item->setData(0, Qt::DisplayRole, name);
-			}
-		}
-	}
-
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::AudioUnitNode const& node) noexcept override
 	{
-		auto const name = genName(controlledEntity, parent->descriptorIndex, node);
+		auto const name = genDescriptorName(controlledEntity, parent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
 		auto* item = addItem(parent->descriptorIndex, parent, &node, name);
 
 		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::audioUnitNameChanged, item,
-			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, QString const& /*audioUnitName*/)
+			[this, item, node, confIndex = parent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, QString const& audioUnitName)
 			{
-				updateName(item, node, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::AudioUnit, audioUnitIndex);
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::AudioUnit == node.descriptorType && audioUnitIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::AudioUnit, audioUnitIndex, node.staticModel.localizedDescription, audioUnitName);
+				}
 			});
 	}
 
 	template<typename ParentNodeType>
 	void processStreamInputNode(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, ParentNodeType const* const parent, la::avdecc::controller::model::StreamInputNode const& node) noexcept
 	{
-		auto const name = genName(controlledEntity, configurationIndex, node);
+		auto const name = genDescriptorName(controlledEntity, configurationIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
 		auto* item = addItem(configurationIndex, parent, &node, name);
 
 		auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
 		// Init ErrorBits
 		{
 			// StreamInput Counters
-			auto const errorCounters = manager.getStreamInputErrorCounters(_controlledEntityID, node.descriptorIndex); // Why not directly use value from ControlledEntity??
+			auto const errorCounters = manager.getStreamInputErrorCounters(_controlledEntityID, node.descriptorIndex);
 			item->setErrorBit(NodeItem::ErrorBit::StreamInputCounter, !errorCounters.empty());
 
 			// StreamInput Latency
-			auto const errorLatency = manager.getStreamInputLatencyError(_controlledEntityID, node.descriptorIndex); // Why not directly use value from ControlledEntity??
+			auto const errorLatency = manager.getStreamInputLatencyError(_controlledEntityID, node.descriptorIndex);
 			item->setErrorBit(NodeItem::ErrorBit::StreamInputLatency, errorLatency);
 		}
 
 		connect(&manager, &hive::modelsLibrary::ControllerManager::streamNameChanged, item,
-			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::StreamIndex const streamIndex, QString const& /*streamName*/)
+			[this, item, node, confIndex = configurationIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::StreamIndex const streamIndex, QString const& streamName)
 			{
-				updateName(item, node, entityID, configurationIndex, descriptorType, streamIndex);
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && descriptorType == node.descriptorType && streamIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, descriptorType, streamIndex, node.staticModel.localizedDescription, streamName);
+				}
 			});
 	}
 
@@ -774,13 +782,16 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 	template<typename ParentNodeType>
 	void processStreamOutputNode(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, ParentNodeType const* const parent, la::avdecc::controller::model::StreamOutputNode const& node) noexcept
 	{
-		auto const name = genName(controlledEntity, configurationIndex, node);
+		auto const name = genDescriptorName(controlledEntity, configurationIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
 		auto* item = addItem(configurationIndex, parent, &node, name);
 
 		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::streamNameChanged, item,
-			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::StreamIndex const streamIndex, QString const& /*streamName*/)
+			[this, item, node, confIndex = configurationIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::StreamIndex const streamIndex, QString const& streamName)
 			{
-				updateName(item, node, entityID, configurationIndex, descriptorType, streamIndex);
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && descriptorType == node.descriptorType && streamIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, descriptorType, streamIndex, node.staticModel.localizedDescription, streamName);
+				}
 			});
 	}
 
@@ -793,21 +804,93 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 		}
 	}
 
+	template<typename NodeType>
+	void processJackNode(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const parent, NodeType const& node) noexcept
+	{
+		auto const name = genDescriptorName(controlledEntity, parent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
+		auto* item = addItem(parent->descriptorIndex, parent, &node, name);
+
+		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::jackNameChanged, item,
+			[this, item, node, confIndex = parent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::JackIndex const jackIndex, QString const& jackName)
+			{
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && descriptorType == node.descriptorType && jackIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, descriptorType, jackIndex, node.staticModel.localizedDescription, jackName);
+				}
+			});
+	}
+
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::JackInputNode const& node) noexcept override
+	{
+		processJackNode(controlledEntity, parent, node);
+	}
+
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::JackOutputNode const& node) noexcept override
+	{
+		processJackNode(controlledEntity, parent, node);
+	}
+
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const grandParent, la::avdecc::controller::model::JackNode const* const parent, la::avdecc::controller::model::ControlNode const& node) noexcept override
+	{
+		auto const name = genDescriptorName(controlledEntity, grandParent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
+		auto* item = addItem(grandParent->descriptorIndex, parent, &node, name);
+
+		auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
+		// Init ErrorBits
+		{
+			// ControlValue OutOfBounds
+			auto const valueOutOfBounds = manager.getControlValueOutOfBounds(_controlledEntityID, node.descriptorIndex);
+			item->setErrorBit(NodeItem::ErrorBit::ControlValueOutOfBounds, valueOutOfBounds);
+		}
+
+		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::controlNameChanged, item,
+			[this, item, node, confIndex = grandParent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, QString const& controlName)
+			{
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::Control == node.descriptorType && controlIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::Control, controlIndex, node.staticModel.localizedDescription, controlName);
+				}
+			});
+	}
+
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::AvbInterfaceNode const& node) noexcept override
 	{
-		auto const name = genName(controlledEntity, parent->descriptorIndex, node);
+		auto const name = genDescriptorName(controlledEntity, parent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
 		auto* item = addItem(parent->descriptorIndex, parent, &node, name);
 
 		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::avbInterfaceNameChanged, item,
-			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, QString const& /*avbInterfaceName*/)
+			[this, item, node, confIndex = parent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::AvbInterfaceIndex const avbInterfaceIndex, QString const& avbInterfaceName)
 			{
-				updateName(item, node, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::AvbInterface, avbInterfaceIndex);
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::AvbInterface == node.descriptorType && avbInterfaceIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::AvbInterface, avbInterfaceIndex, node.staticModel.localizedDescription, avbInterfaceName);
+				}
+			});
+	}
+
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const /*parent*/, la::avdecc::controller::model::ClockSourceNode const& /*node*/) noexcept override
+	{
+		// Ignored, we'll show the ClockSourceNode in the ClockDomainNode
+	}
+
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::MemoryObjectNode const& node) noexcept override
+	{
+		auto const name = genDescriptorName(controlledEntity, parent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
+		auto* item = addItem(parent->descriptorIndex, parent, &node, name);
+
+		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::memoryObjectNameChanged, item,
+			[this, item, node, confIndex = parent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, QString const& memoryObjectName)
+			{
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::MemoryObject == node.descriptorType && memoryObjectIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::MemoryObject, memoryObjectIndex, node.staticModel.localizedDescription, memoryObjectName);
+				}
 			});
 	}
 
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::LocaleNode const& node) noexcept override
 	{
-		auto const name = QString("%1.%2: %3").arg(avdecc::helper::descriptorTypeToString(node.descriptorType), QString::number(node.descriptorIndex), node.staticModel->localeID.data());
+		auto const name = QString("%1.%2: %3").arg(avdecc::helper::descriptorTypeToString(node.descriptorType), QString::number(node.descriptorIndex), node.staticModel.localeID.data());
 		addItem(parent->descriptorIndex, parent, &node, name);
 	}
 
@@ -817,7 +900,13 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 		addItem(grandParent->descriptorIndex, parent, &node, name);
 	}
 
-	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const grandParent, la::avdecc::controller::model::AudioUnitNode const* const parent, la::avdecc::controller::model::StreamPortNode const& node) noexcept override
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const grandParent, la::avdecc::controller::model::AudioUnitNode const* const parent, la::avdecc::controller::model::StreamPortInputNode const& node) noexcept override
+	{
+		auto const name = QString("%1.%2").arg(avdecc::helper::descriptorTypeToString(node.descriptorType), QString::number(node.descriptorIndex));
+		addItem(grandParent->descriptorIndex, parent, &node, name);
+	}
+
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const grandParent, la::avdecc::controller::model::AudioUnitNode const* const parent, la::avdecc::controller::model::StreamPortOutputNode const& node) noexcept override
 	{
 		auto const name = QString("%1.%2").arg(avdecc::helper::descriptorTypeToString(node.descriptorType), QString::number(node.descriptorIndex));
 		addItem(grandParent->descriptorIndex, parent, &node, name);
@@ -825,13 +914,16 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const grandGrandParent, la::avdecc::controller::model::AudioUnitNode const* const /*grandParent*/, la::avdecc::controller::model::StreamPortNode const* const parent, la::avdecc::controller::model::AudioClusterNode const& node) noexcept override
 	{
-		auto const name = genName(controlledEntity, grandGrandParent->descriptorIndex, node);
+		auto const name = genDescriptorName(controlledEntity, grandGrandParent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
 		auto* item = addItem(grandGrandParent->descriptorIndex, parent, &node, name);
 
 		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::audioClusterNameChanged, item,
-			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClusterIndex const audioClusterIndex, QString const& /*audioClusterName*/)
+			[this, item, node, confIndex = grandGrandParent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClusterIndex const audioClusterIndex, QString const& audioClusterName)
 			{
-				updateName(item, node, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::AudioCluster, audioClusterIndex);
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::AudioCluster == node.descriptorType && audioClusterIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::AudioCluster, audioClusterIndex, node.staticModel.localizedDescription, audioClusterName);
+				}
 			});
 	}
 
@@ -841,40 +933,103 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 		addItem(grandGrandParent->descriptorIndex, parent, &node, name);
 	}
 
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const grandGrandParent, la::avdecc::controller::model::AudioUnitNode const* const /*grandParent*/, la::avdecc::controller::model::StreamPortNode const* const parent, la::avdecc::controller::model::ControlNode const& node) noexcept override
+	{
+		auto const name = genDescriptorName(controlledEntity, grandGrandParent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
+		auto* item = addItem(grandGrandParent->descriptorIndex, parent, &node, name);
+
+		auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
+		// Init ErrorBits
+		{
+			// ControlValue OutOfBounds
+			auto const valueOutOfBounds = manager.getControlValueOutOfBounds(_controlledEntityID, node.descriptorIndex);
+			item->setErrorBit(NodeItem::ErrorBit::ControlValueOutOfBounds, valueOutOfBounds);
+		}
+
+		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::controlNameChanged, item,
+			[this, item, node, confIndex = grandGrandParent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, QString const& controlName)
+			{
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::Control == node.descriptorType && controlIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::Control, controlIndex, node.staticModel.localizedDescription, controlName);
+				}
+			});
+	}
+
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const grandParent, la::avdecc::controller::model::AudioUnitNode const* const parent, la::avdecc::controller::model::ControlNode const& node) noexcept override
+	{
+		auto const name = genDescriptorName(controlledEntity, grandParent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
+		auto* item = addItem(grandParent->descriptorIndex, parent, &node, name);
+
+		auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
+		// Init ErrorBits
+		{
+			// ControlValue OutOfBounds
+			auto const valueOutOfBounds = manager.getControlValueOutOfBounds(_controlledEntityID, node.descriptorIndex);
+			item->setErrorBit(NodeItem::ErrorBit::ControlValueOutOfBounds, valueOutOfBounds);
+		}
+
+		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::controlNameChanged, item,
+			[this, item, node, confIndex = grandParent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, QString const& controlName)
+			{
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::Control == node.descriptorType && controlIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::Control, controlIndex, node.staticModel.localizedDescription, controlName);
+				}
+			});
+	}
+
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::ControlNode const& node) noexcept override
 	{
-		auto const name = genName(controlledEntity, parent->descriptorIndex, node);
+		auto const name = genDescriptorName(controlledEntity, parent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
 		auto* item = addItem(parent->descriptorIndex, parent, &node, name);
 
+		auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
+		// Init ErrorBits
+		{
+			// ControlValue OutOfBounds
+			auto const valueOutOfBounds = manager.getControlValueOutOfBounds(_controlledEntityID, node.descriptorIndex);
+			item->setErrorBit(NodeItem::ErrorBit::ControlValueOutOfBounds, valueOutOfBounds);
+		}
+
 		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::controlNameChanged, item,
-			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, QString const& /*controlName*/)
+			[this, item, node, confIndex = parent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ControlIndex const controlIndex, QString const& controlName)
 			{
-				updateName(item, node, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::Control, controlIndex);
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::Control == node.descriptorType && controlIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::Control, controlIndex, node.staticModel.localizedDescription, controlName);
+				}
 			});
 	}
 
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::ClockDomainNode const& node) noexcept override
 	{
-		auto const name = genName(controlledEntity, parent->descriptorIndex, node);
+		auto const name = genDescriptorName(controlledEntity, parent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
 		auto* item = addItem(parent->descriptorIndex, parent, &node, name);
 
 		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::clockDomainNameChanged, item,
-			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, QString const& /*clockDomainName*/)
+			[this, item, node, confIndex = parent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockDomainIndex const clockDomainIndex, QString const& clockDomainName)
 			{
-				updateName(item, node, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::ClockDomain, clockDomainIndex);
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::ClockDomain == node.descriptorType && clockDomainIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::ClockDomain, clockDomainIndex, node.staticModel.localizedDescription, clockDomainName);
+				}
 			});
 	}
 
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const grandParent, la::avdecc::controller::model::ClockDomainNode const* const parent, la::avdecc::controller::model::ClockSourceNode const& node) noexcept override
 	{
-		auto const name = genName(controlledEntity, grandParent->descriptorIndex, node);
+		auto const name = genDescriptorName(controlledEntity, grandParent->descriptorIndex, node.descriptorType, node.descriptorIndex, node.staticModel.localizedDescription, node.dynamicModel.objectName);
 		auto* item = addItem(grandParent->descriptorIndex, parent, &node, name);
-		auto const isCurrentConfiguration = grandParent->descriptorIndex == controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const isCurrentConfiguration = grandParent->descriptorIndex == controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 
 		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::clockSourceNameChanged, item,
-			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, QString const& /*clockSourceName*/)
+			[this, item, node, confIndex = grandParent->descriptorIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::ClockSourceIndex const clockSourceIndex, QString const& clockSourceName)
 			{
-				updateName(item, node, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::ClockSource, clockSourceIndex);
+				if (entityID == _controlledEntityID && confIndex == configurationIndex && la::avdecc::entity::model::DescriptorType::ClockSource == node.descriptorType && clockSourceIndex == node.descriptorIndex)
+				{
+					updateName(item, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::ClockSource, clockSourceIndex, node.staticModel.localizedDescription, clockSourceName);
+				}
 			});
 
 		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::clockSourceChanged, item,
@@ -882,32 +1037,29 @@ class ControlledEntityTreeWidgetPrivate : public QObject, public la::avdecc::con
 			{
 				if (isCurrentConfiguration && entityID == _controlledEntityID && clockDomainIndex == parentIndex)
 				{
-					priv::useBoldFont(item, node.descriptorIndex == clockSourceIndex);
+					// Set the ActiveRole
+					auto const isCurrentClockSource = node.descriptorIndex == clockSourceIndex;
+					item->setData(0, la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ActiveRole), isCurrentClockSource);
 				}
 			});
 
 		if (isCurrentConfiguration)
 		{
-			auto const isCurrentClockSource = (node.descriptorIndex == parent->dynamicModel->clockSourceIndex);
-			priv::useBoldFont(item, isCurrentClockSource);
+			// Set the ActiveRole
+			auto const isCurrentClockSource = node.descriptorIndex == parent->dynamicModel.clockSourceIndex;
+			item->setData(0, la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ActiveRole), isCurrentClockSource);
 		}
 	}
 
-	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::MemoryObjectNode const& node) noexcept override
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::RedundantStreamInputNode const& node) noexcept override
 	{
-		auto const name = genName(controlledEntity, parent->descriptorIndex, node);
-		auto* item = addItem(parent->descriptorIndex, parent, &node, name);
-
-		connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::memoryObjectNameChanged, item,
-			[this, item, node](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::MemoryObjectIndex const memoryObjectIndex, QString const& /*memoryObjectName*/)
-			{
-				updateName(item, node, entityID, configurationIndex, la::avdecc::entity::model::DescriptorType::MemoryObject, memoryObjectIndex);
-			});
+		auto const name = QString("REDUNDANT_INPUT.%1: %2").arg(QString::number(node.virtualIndex), QString::fromStdString(node.virtualName));
+		addItem(parent->descriptorIndex, parent, &node, name);
 	}
 
-	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::RedundantStreamNode const& node) noexcept override
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const parent, la::avdecc::controller::model::RedundantStreamOutputNode const& node) noexcept override
 	{
-		auto const name = QString("REDUNDANT_%1.%2: %3").arg(avdecc::helper::descriptorTypeToString(node.descriptorType), QString::number(node.virtualIndex), QString::fromStdString(node.virtualName));
+		auto const name = QString("REDUNDANT_OUTPUT.%1: %2").arg(QString::number(node.virtualIndex), QString::fromStdString(node.virtualName));
 		addItem(parent->descriptorIndex, parent, &node, name);
 	}
 
diff --git a/src/controlledEntityTreeWidgetItemDelegate.cpp b/src/controlledEntityTreeWidgetItemDelegate.cpp
new file mode 100644
index 00000000..e30afee2
--- /dev/null
+++ b/src/controlledEntityTreeWidgetItemDelegate.cpp
@@ -0,0 +1,77 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "controlledEntityTreeWidgetItemDelegate.hpp"
+
+#include <hive/widgetModelsLibrary/qtUserRoles.hpp>
+
+#include <QPainter>
+#include <QAbstractItemView>
+#include <QComboBox>
+
+ControlledEntityTreeWidgetItemDelegate::ControlledEntityTreeWidgetItemDelegate(qtMate::material::color::Name const themeColorName, QObject* parent) noexcept
+	: QStyledItemDelegate(parent)
+{
+	setThemeColorName(themeColorName);
+}
+
+void ControlledEntityTreeWidgetItemDelegate::setThemeColorName(qtMate::material::color::Name const themeColorName)
+{
+	_themeColorName = themeColorName;
+	_isDark = qtMate::material::color::luminance(_themeColorName) == qtMate::material::color::Luminance::Dark;
+	_errorItemDelegate.setThemeColorName(themeColorName);
+}
+
+void ControlledEntityTreeWidgetItemDelegate::paint(QPainter* painter, QStyleOptionViewItem const& option, QModelIndex const& index) const
+{
+	// Override default options according to the model current state
+	auto basePainterOption = option;
+
+
+	// Base painter
+	{
+		painter->save();
+
+		// Check if the item has the active role
+		auto const isActive = index.data(la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ActiveRole)).toBool();
+		// If active, use a bold font
+		if (isActive)
+		{
+			basePainterOption.font.setBold(true);
+		}
+
+		// Check if the item has the error role
+		auto const isError = index.data(la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ErrorRole)).toBool();
+		// If error, change the text color
+		if (isError)
+		{
+			// Change foreground color
+			basePainterOption.palette.setColor(QPalette::Text, qtMate::material::color::foregroundErrorColorValue(qtMate::material::color::backgroundColorName(), qtMate::material::color::colorSchemeShade()));
+		}
+
+		QStyledItemDelegate::paint(painter, basePainterOption, index);
+
+		painter->restore();
+	}
+
+	// Error painter
+	{
+		static_cast<QStyledItemDelegate const&>(_errorItemDelegate).paint(painter, option, index);
+	}
+}
diff --git a/src/controlledEntityTreeWidgetItemDelegate.hpp b/src/controlledEntityTreeWidgetItemDelegate.hpp
new file mode 100644
index 00000000..f9e2464f
--- /dev/null
+++ b/src/controlledEntityTreeWidgetItemDelegate.hpp
@@ -0,0 +1,45 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "settingsManager/settings.hpp"
+
+#include <hive/widgetModelsLibrary/errorItemDelegate.hpp>
+
+#include <QStyledItemDelegate>
+#include <QApplication>
+
+class ControlledEntityTreeWidgetItemDelegate : public QStyledItemDelegate
+{
+	Q_OBJECT
+public:
+	ControlledEntityTreeWidgetItemDelegate(qtMate::material::color::Name const themeColorName = qtMate::material::color::DefaultColor, QObject* parent = nullptr) noexcept;
+
+	Q_SLOT void setThemeColorName(qtMate::material::color::Name const themeColorName);
+
+protected:
+	virtual void paint(QPainter* painter, QStyleOptionViewItem const& option, QModelIndex const& index) const override;
+
+private:
+	// Private members
+	qtMate::material::color::Name _themeColorName{ qtMate::material::color::DefaultColor };
+	bool _isDark{ false };
+	hive::widgetModelsLibrary::ErrorItemDelegate _errorItemDelegate{ false, qtMate::material::color::Palette::name(qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>()->getValue(settings::General_ThemeColorIndex.name).toInt()), this };
+};
diff --git a/src/counters/streamInputCountersTreeWidgetItem.cpp b/src/counters/streamInputCountersTreeWidgetItem.cpp
index 80a1bf5e..263148b3 100644
--- a/src/counters/streamInputCountersTreeWidgetItem.cpp
+++ b/src/counters/streamInputCountersTreeWidgetItem.cpp
@@ -19,6 +19,8 @@
 
 #include "streamInputCountersTreeWidgetItem.hpp"
 
+#include <QtMate/material/color.hpp>
+
 #include <map>
 #include <QMenu>
 
@@ -117,7 +119,7 @@ void StreamInputCountersTreeWidgetItem::updateCounters(la::avdecc::entity::model
 			auto* widget = it->second;
 			AVDECC_ASSERT(widget != nullptr, "If widget is found in the map, it should not be nullptr");
 
-			auto color = QColor{ _isConnected ? Qt::black : Qt::gray };
+			auto color = QColor{ _isConnected ? qtMate::material::color::foregroundColor() : qtMate::material::color::disabledForegroundColor() };
 			auto text = QString::number(value);
 
 			auto const errorCounterIt = _errorCounters.find(flag);
diff --git a/src/defaults.hpp b/src/defaults.hpp
index 5467b087..d662bafe 100644
--- a/src/defaults.hpp
+++ b/src/defaults.hpp
@@ -25,15 +25,17 @@ namespace ui
 {
 struct AdvancedView
 {
-	static constexpr int ColumnWidth_UniqueIdentifier = 160;
+	static constexpr int ColumnWidth_Error = 40;
+	static constexpr int ColumnWidth_UniqueIdentifier = 130;
 	static constexpr int ColumnWidth_Logo = 60;
 	static constexpr int ColumnWidth_Compatibility = 50;
 	static constexpr int ColumnWidth_Name = 180;
-	static constexpr int ColumnWidth_ExclusiveAccessState = 80;
+	static constexpr int ColumnWidth_SquareIcon = 80;
 	static constexpr int ColumnWidth_Group = 80;
 	static constexpr int ColumnWidth_GPTPDomain = 80;
 	static constexpr int ColumnWidth_InterfaceIndex = 90;
-	static constexpr int ColumnWidth_Firmware = 160;
+	static constexpr int ColumnWidth_MacAddress = 110;
+	static constexpr int ColumnWidth_Firmware = 150;
 };
 
 } // namespace ui
diff --git a/src/deviceDetailsChannelTableModel.cpp b/src/deviceDetailsChannelTableModel.cpp
index cd5910f5..15023f77 100644
--- a/src/deviceDetailsChannelTableModel.cpp
+++ b/src/deviceDetailsChannelTableModel.cpp
@@ -42,9 +42,9 @@
 */
 bool isStreamConnected(la::avdecc::UniqueIdentifier const talkerID, la::avdecc::controller::model::StreamOutputNode const* const talkerNode, la::avdecc::controller::model::StreamInputNode const* const listenerNode) noexcept
 {
-	if (listenerNode && listenerNode->dynamicModel && talkerNode)
+	if (listenerNode && talkerNode)
 	{
-		return (listenerNode->dynamicModel->connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected) && (listenerNode->dynamicModel->connectionInfo.talkerStream.entityID == talkerID) && (listenerNode->dynamicModel->connectionInfo.talkerStream.streamIndex == talkerNode->descriptorIndex);
+		return (listenerNode->dynamicModel.connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected) && (listenerNode->dynamicModel.connectionInfo.talkerStream.entityID == talkerID) && (listenerNode->dynamicModel.connectionInfo.talkerStream.streamIndex == talkerNode->descriptorIndex);
 	}
 
 	return false;
@@ -58,9 +58,9 @@ bool isStreamConnected(la::avdecc::UniqueIdentifier const talkerID, la::avdecc::
 */
 bool isStreamFastConnecting(la::avdecc::UniqueIdentifier const talkerID, la::avdecc::controller::model::StreamOutputNode const* const talkerNode, la::avdecc::controller::model::StreamInputNode const* const listenerNode) noexcept
 {
-	if (listenerNode && listenerNode->dynamicModel && talkerNode)
+	if (listenerNode && talkerNode)
 	{
-		return (listenerNode->dynamicModel->connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::FastConnecting) && (listenerNode->dynamicModel->connectionInfo.talkerStream.entityID == talkerID) && (listenerNode->dynamicModel->connectionInfo.talkerStream.streamIndex == talkerNode->descriptorIndex);
+		return (listenerNode->dynamicModel.connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::FastConnecting) && (listenerNode->dynamicModel.connectionInfo.talkerStream.entityID == talkerID) && (listenerNode->dynamicModel.connectionInfo.talkerStream.streamIndex == talkerNode->descriptorIndex);
 	}
 
 	return false;
@@ -85,21 +85,21 @@ DeviceDetailsChannelTableModel::ConnectionStatus calculateConnectionStatus(la::a
 	auto const& talkerEntityNode = talkerEntity->getEntityNode();
 	auto const& listenerEntityNode = listenerEntity->getEntityNode();
 
-	auto const& talkerConfigurationNode = talkerEntity->getConfigurationNode(talkerEntityNode.dynamicModel->currentConfiguration);
-	auto const& listenerConfigurationNode = listenerEntity->getConfigurationNode(listenerEntityNode.dynamicModel->currentConfiguration);
+	auto const& talkerConfigurationNode = talkerEntity->getConfigurationNode(talkerEntityNode.dynamicModel.currentConfiguration);
+	auto const& listenerConfigurationNode = listenerEntity->getConfigurationNode(listenerEntityNode.dynamicModel.currentConfiguration);
 	auto status = DeviceDetailsChannelTableModel::ConnectionStatus{ connectionMatrix::Model::IntersectionData::Type::SingleStream_SingleStream, connectionMatrix::Model::IntersectionData::State::Connected };
 	auto const& talkerOutputStreamNode = talkerEntity->getStreamOutputNode(talkerConfigurationNode.descriptorIndex, talkerStreamIndex);
 	auto const& listenerInputStreamNode = listenerEntity->getStreamInputNode(listenerConfigurationNode.descriptorIndex, listenerStreamIndex);
 
-	auto const talkerAvbInterfaceIndex{ talkerOutputStreamNode.staticModel->avbInterfaceIndex };
+	auto const talkerAvbInterfaceIndex{ talkerOutputStreamNode.staticModel.avbInterfaceIndex };
 	auto const& talkerAvbInterfaceNode = talkerEntity->getAvbInterfaceNode(talkerConfigurationNode.descriptorIndex, talkerAvbInterfaceIndex);
-	auto talkerStreamFormat = talkerOutputStreamNode.dynamicModel->streamFormat;
+	auto talkerStreamFormat = talkerOutputStreamNode.dynamicModel.streamFormat;
 	auto const talkerDynamicInterfaceNode = talkerAvbInterfaceNode.dynamicModel;
 	auto talkerInterfaceLinkStatus = talkerEntity->getAvbInterfaceLinkStatus(talkerAvbInterfaceIndex);
 
-	auto const listenerAvbInterfaceIndex{ listenerInputStreamNode.staticModel->avbInterfaceIndex };
+	auto const listenerAvbInterfaceIndex{ listenerInputStreamNode.staticModel.avbInterfaceIndex };
 	auto const& listenerAvbInterfaceNode = listenerEntity->getAvbInterfaceNode(listenerConfigurationNode.descriptorIndex, listenerAvbInterfaceIndex);
-	auto listenerStreamFormat = listenerInputStreamNode.dynamicModel->streamFormat;
+	auto listenerStreamFormat = listenerInputStreamNode.dynamicModel.streamFormat;
 	auto const listenerDynamicInterfaceNode = listenerAvbInterfaceNode.dynamicModel;
 	auto listenerInterfaceLinkStatus = listenerEntity->getAvbInterfaceLinkStatus(listenerAvbInterfaceIndex);
 
@@ -125,7 +125,7 @@ DeviceDetailsChannelTableModel::ConnectionStatus calculateConnectionStatus(la::a
 		status.flags.reset(connectionMatrix::Model::IntersectionData::Flag::InterfaceDown);
 	}
 
-	if (isSameDomain(*talkerDynamicInterfaceNode, *listenerDynamicInterfaceNode))
+	if (isSameDomain(talkerDynamicInterfaceNode, listenerDynamicInterfaceNode))
 	{
 		status.flags.reset(connectionMatrix::Model::IntersectionData::Flag::WrongDomain);
 	}
@@ -475,59 +475,56 @@ QVariant DeviceDetailsChannelTableModelPrivate::data(QModelIndex const& index, i
 								continue;
 							}
 							auto const& entityNode = controlledEntity->getEntityNode();
-							if (entityNode.dynamicModel)
+							auto const& configurationNode = controlledEntity->getConfigurationNode(entityNode.dynamicModel.currentConfiguration);
+							QString clusterName;
+							if (connectionInfo->sourceClusterChannelInfo->direction == avdecc::ChannelConnectionDirection::OutputToInput)
 							{
-								auto const& configurationNode = controlledEntity->getConfigurationNode(entityNode.dynamicModel->currentConfiguration);
-								QString clusterName;
+								clusterName = hive::modelsLibrary::helper::objectName(controlledEntity.get(), (configurationNode.audioUnits.at(connection->targetAudioUnitIndex).streamPortInputs.at(connection->targetStreamPortIndex).audioClusters.at(clusterKV.first + connection->targetBaseCluster)));
+							}
+							else
+							{
+								clusterName = hive::modelsLibrary::helper::objectName(controlledEntity.get(), (configurationNode.audioUnits.at(connection->targetAudioUnitIndex).streamPortOutputs.at(connection->targetStreamPortIndex).audioClusters.at(clusterKV.first + connection->targetBaseCluster)));
+							}
+
+							if (connection->isSourceRedundant && connection->isTargetRedundant)
+							{
+								connectionLines.append(QString(clusterName).append(": ").append(hive::modelsLibrary::helper::smartEntityName(*controlledEntity.get())).append(" (Prim)"));
+
+								auto const& channelConnectionManager = avdecc::ChannelConnectionManager::getInstance();
+								std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*> redundantOutputs;
+								std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*> redundantInputs;
 								if (connectionInfo->sourceClusterChannelInfo->direction == avdecc::ChannelConnectionDirection::OutputToInput)
 								{
-									clusterName = hive::modelsLibrary::helper::objectName(controlledEntity.get(), (configurationNode.audioUnits.at(connection->targetAudioUnitIndex).streamPortInputs.at(connection->targetStreamPortIndex).audioClusters.at(clusterKV.first + connection->targetBaseCluster)));
+									redundantOutputs = channelConnectionManager.getRedundantStreamOutputsForPrimary(connectionInfo->sourceEntityId, connection->sourceStreamIndex);
+									redundantInputs = channelConnectionManager.getRedundantStreamInputsForPrimary(connection->targetEntityId, connection->targetStreamIndex);
 								}
 								else
 								{
-									clusterName = hive::modelsLibrary::helper::objectName(controlledEntity.get(), (configurationNode.audioUnits.at(connection->targetAudioUnitIndex).streamPortOutputs.at(connection->targetStreamPortIndex).audioClusters.at(clusterKV.first + connection->targetBaseCluster)));
+									redundantOutputs = channelConnectionManager.getRedundantStreamInputsForPrimary(connectionInfo->sourceEntityId, connection->sourceStreamIndex);
+									redundantInputs = channelConnectionManager.getRedundantStreamOutputsForPrimary(connection->targetEntityId, connection->targetStreamIndex);
 								}
+								auto itOutputs = redundantOutputs.begin();
+								auto itInputs = redundantInputs.begin();
 
-								if (connection->isSourceRedundant && connection->isTargetRedundant)
+								if (itOutputs != redundantOutputs.end() && itInputs != redundantInputs.end())
 								{
-									connectionLines.append(QString(clusterName).append(": ").append(hive::modelsLibrary::helper::smartEntityName(*controlledEntity.get())).append(" (Prim)"));
-
-									auto const& channelConnectionManager = avdecc::ChannelConnectionManager::getInstance();
-									std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*> redundantOutputs;
-									std::map<la::avdecc::entity::model::StreamIndex, la::avdecc::controller::model::StreamNode const*> redundantInputs;
-									if (connectionInfo->sourceClusterChannelInfo->direction == avdecc::ChannelConnectionDirection::OutputToInput)
-									{
-										redundantOutputs = channelConnectionManager.getRedundantStreamOutputsForPrimary(connectionInfo->sourceEntityId, connection->sourceStreamIndex);
-										redundantInputs = channelConnectionManager.getRedundantStreamInputsForPrimary(connection->targetEntityId, connection->targetStreamIndex);
-									}
-									else
-									{
-										redundantOutputs = channelConnectionManager.getRedundantStreamInputsForPrimary(connectionInfo->sourceEntityId, connection->sourceStreamIndex);
-										redundantInputs = channelConnectionManager.getRedundantStreamOutputsForPrimary(connection->targetEntityId, connection->targetStreamIndex);
-									}
-									auto itOutputs = redundantOutputs.begin();
-									auto itInputs = redundantInputs.begin();
-
-									if (itOutputs != redundantOutputs.end() && itInputs != redundantInputs.end())
-									{
-										// skip primary
-										itOutputs++;
-										itInputs++;
-									}
-
-									while (itOutputs != redundantOutputs.end() && itInputs != redundantInputs.end())
-									{
-										connectionLines.append(QString(clusterName).append(": ").append(hive::modelsLibrary::helper::smartEntityName(*controlledEntity.get())).append(" (Sec)"));
-
-										itOutputs++;
-										itInputs++;
-									}
+									// skip primary
+									itOutputs++;
+									itInputs++;
 								}
-								else
+
+								while (itOutputs != redundantOutputs.end() && itInputs != redundantInputs.end())
 								{
-									connectionLines.append(QString(clusterName).append(": ").append(hive::modelsLibrary::helper::smartEntityName(*controlledEntity.get())));
+									connectionLines.append(QString(clusterName).append(": ").append(hive::modelsLibrary::helper::smartEntityName(*controlledEntity.get())).append(" (Sec)"));
+
+									itOutputs++;
+									itInputs++;
 								}
 							}
+							else
+							{
+								connectionLines.append(QString(clusterName).append(": ").append(hive::modelsLibrary::helper::smartEntityName(*controlledEntity.get())));
+							}
 						}
 					}
 					return connectionLines;
@@ -581,46 +578,43 @@ QVariant DeviceDetailsChannelTableModelPrivate::data(QModelIndex const& index, i
 						auto const& talkerEntityNode = talkerEntity->getEntityNode();
 						auto const& listenerEntityNode = listenerEntity->getEntityNode();
 
-						if (talkerEntityNode.dynamicModel && listenerEntityNode.dynamicModel)
 						{
-							{
-								auto status = calculateConnectionStatus(talkerEntityId, talkerStreamIndex, listenerEntityId, listenerStreamIndex);
+							auto status = calculateConnectionStatus(talkerEntityId, talkerStreamIndex, listenerEntityId, listenerStreamIndex);
 
-								connectionStatesTmp.append(QVariant::fromValue(status));
-							}
-
-							if (connection->isSourceRedundant && connection->isTargetRedundant)
-							{
-								auto const& channelConnectionManager = avdecc::ChannelConnectionManager::getInstance();
+							connectionStatesTmp.append(QVariant::fromValue(status));
+						}
 
-								auto redundantOutputs = channelConnectionManager.getRedundantStreamOutputsForPrimary(talkerEntityId, talkerStreamIndex);
-								auto redundantInputs = channelConnectionManager.getRedundantStreamInputsForPrimary(listenerEntityId, listenerStreamIndex);
+						if (connection->isSourceRedundant && connection->isTargetRedundant)
+						{
+							auto const& channelConnectionManager = avdecc::ChannelConnectionManager::getInstance();
 
-								auto itOutputs = redundantOutputs.begin();
-								auto itInputs = redundantInputs.begin();
+							auto redundantOutputs = channelConnectionManager.getRedundantStreamOutputsForPrimary(talkerEntityId, talkerStreamIndex);
+							auto redundantInputs = channelConnectionManager.getRedundantStreamInputsForPrimary(listenerEntityId, listenerStreamIndex);
 
-								if (itOutputs != redundantOutputs.end() && itInputs != redundantInputs.end())
-								{
-									// skip primary
-									itOutputs++;
-									itInputs++;
-								}
-								while (itOutputs != redundantOutputs.end() && itInputs != redundantInputs.end())
-								{
-									auto status = calculateConnectionStatus(talkerEntityId, itOutputs->first, listenerEntityId, itInputs->first);
-									connectionStatesTmp.append(QVariant::fromValue(status));
+							auto itOutputs = redundantOutputs.begin();
+							auto itInputs = redundantInputs.begin();
 
-									itOutputs++;
-									itInputs++;
-								}
+							if (itOutputs != redundantOutputs.end() && itInputs != redundantInputs.end())
+							{
+								// skip primary
+								itOutputs++;
+								itInputs++;
 							}
-
-							// add the states for each cluster channel
-							for (uint32_t i = 0; i < connection->targetClusterChannels.size(); i++)
+							while (itOutputs != redundantOutputs.end() && itInputs != redundantInputs.end())
 							{
-								connectionStates << connectionStatesTmp;
+								auto status = calculateConnectionStatus(talkerEntityId, itOutputs->first, listenerEntityId, itInputs->first);
+								connectionStatesTmp.append(QVariant::fromValue(status));
+
+								itOutputs++;
+								itInputs++;
 							}
 						}
+
+						// add the states for each cluster channel
+						for (uint32_t i = 0; i < connection->targetClusterChannels.size(); i++)
+						{
+							connectionStates << connectionStatesTmp;
+						}
 					}
 					return connectionStates;
 				}
diff --git a/src/deviceDetailsDialog.cpp b/src/deviceDetailsDialog.cpp
index 2d75624e..7dd495a2 100644
--- a/src/deviceDetailsDialog.cpp
+++ b/src/deviceDetailsDialog.cpp
@@ -48,7 +48,7 @@
 * Holds the state of the changes until the apply button is pressed, then uses the hive::modelsLibrary::ControllerManager class to
 * write the changes to the device.
 */
-class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QObject, public la::avdecc::controller::model::EntityModelVisitor
+class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QObject, public la::avdecc::controller::model::DefaultedEntityModelVisitor
 {
 private:
 	::DeviceDetailsDialog* _dialog;
@@ -177,7 +177,7 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 		auto controlledEntity = manager.getControlledEntity(entityID);
 		if (controlledEntity)
 		{
-			la::avdecc::controller::model::ConfigurationNode configurationNode;
+			auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 			try
 			{
 				configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -205,20 +205,14 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 
 				auto const& entityNode = controlledEntity->getEntityNode();
 
-				auto const* const staticModel = entityNode.staticModel;
-				auto const* const dynamicModel = entityNode.dynamicModel;
+				auto const& staticModel = entityNode.staticModel;
+				auto const& dynamicModel = entityNode.dynamicModel;
 
 				labelEntityIdValue->setText(hive::modelsLibrary::helper::toHexQString(entityID.getValue(), true, true));
-				if (staticModel)
-				{
-					labelVendorNameValue->setText(hive::modelsLibrary::helper::localizedString(*controlledEntity, staticModel->vendorNameString));
-					labelModelNameValue->setText(hive::modelsLibrary::helper::localizedString(*controlledEntity, staticModel->modelNameString));
-				}
-				if (dynamicModel)
-				{
-					labelFirmwareVersionValue->setText(dynamicModel->firmwareVersion.data());
-					labelSerialNumberValue->setText(dynamicModel->serialNumber.data());
-				}
+				labelVendorNameValue->setText(hive::modelsLibrary::helper::localizedString(*controlledEntity, staticModel.vendorNameString));
+				labelModelNameValue->setText(hive::modelsLibrary::helper::localizedString(*controlledEntity, staticModel.modelNameString));
+				labelFirmwareVersionValue->setText(dynamicModel.firmwareVersion.data());
+				labelSerialNumberValue->setText(dynamicModel.serialNumber.data());
 
 				_previousConfigurationIndex = configurationNode.descriptorIndex;
 			}
@@ -330,14 +324,14 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 						if (la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference == streamFormatInfo->getType())
 							continue;
 
-						auto* audioUnitDynModel = controlledEntity->getAudioUnitNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, 0).dynamicModel;
-						if (streamFormatInfo && audioUnitDynModel)
+						auto& audioUnitDynModel = controlledEntity->getAudioUnitNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, 0).dynamicModel;
+						if (streamFormatInfo)
 						{
 							// get the streamformat's corresponding sampling rate by first deriving the pull and base freq vals from streamformatinfo
 							auto const& streamFormatSampleRate = streamFormatInfo->getSamplingRate();
 
 							// get the 'media clock domain' sampling rate from the 'media clock master's entities audioUnit
-							auto const& mediaClockMasterSampleRate = audioUnitDynModel->currentSamplingRate;
+							auto const& mediaClockMasterSampleRate = audioUnitDynModel.currentSamplingRate;
 
 							// if the 'media clock master' audioUnit SR and the streamFormat SR do not match, we have found a conflict that the user needs to be warned about
 							hasSampleRateConflict = (mediaClockMasterSampleRate != streamFormatSampleRate);
@@ -429,14 +423,14 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 				auto configurationNode = controlledEntity->getCurrentConfigurationNode();
 				for (auto const& streamOutput : configurationNode.streamOutputs)
 				{
-					auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamOutput.second.dynamicModel->streamFormat);
+					auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamOutput.second.dynamicModel.streamFormat);
 					auto const streamType = streamFormatInfo->getType();
 					if (streamType == la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference)
 					{
 						// skip clock stream
 						continue;
 					}
-					auto const streamLatency = streamOutput.second.dynamicModel->streamDynamicInfo ? (*streamOutput.second.dynamicModel->streamDynamicInfo).msrpAccumulatedLatency : decltype(_userSelectedLatency){ std::nullopt };
+					auto const streamLatency = streamOutput.second.dynamicModel.streamDynamicInfo ? (*streamOutput.second.dynamicModel.streamDynamicInfo).msrpAccumulatedLatency : decltype(_userSelectedLatency){ std::nullopt };
 					auto const latencyValuesValid = (streamLatency != std::nullopt && _userSelectedLatency != std::nullopt);
 					if (latencyValuesValid && *streamLatency != *_userSelectedLatency)
 					{
@@ -504,7 +498,7 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 		comboBoxConfiguration->addItem(hive::modelsLibrary::helper::configurationName(controlledEntity, node), node.descriptorIndex);
 
 		// relevant Node:
-		if (node.dynamicModel->isActiveConfiguration && !_activeConfigurationIndex)
+		if (node.dynamicModel.isActiveConfiguration && !_activeConfigurationIndex)
 		{
 			_activeConfigurationIndex = node.descriptorIndex;
 		}
@@ -528,9 +522,9 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 		{
 			for (auto const& inputAudioClusterKV : streamPortInputKV.second.audioClusters)
 			{
-				for (std::uint16_t channelIndex = 0u; channelIndex < inputAudioClusterKV.second.staticModel->channelCount; channelIndex++)
+				for (std::uint16_t channelIndex = 0u; channelIndex < inputAudioClusterKV.second.staticModel.channelCount; channelIndex++)
 				{
-					auto sourceChannelIdentification = avdecc::ChannelIdentification{ *_previousConfigurationIndex, inputAudioClusterKV.first, channelIndex, avdecc::ChannelConnectionDirection::InputToOutput, audioUnitIndex, streamPortInputKV.first, streamPortInputKV.second.staticModel->baseCluster };
+					auto sourceChannelIdentification = avdecc::ChannelIdentification{ *_previousConfigurationIndex, inputAudioClusterKV.first, channelIndex, avdecc::ChannelConnectionDirection::InputToOutput, audioUnitIndex, streamPortInputKV.first, streamPortInputKV.second.staticModel.baseCluster };
 					auto connectionInformation = channelConnectionManager.getChannelConnectionsReverse(_entityID, sourceChannelIdentification);
 
 					_deviceDetailsChannelTableModelReceive.addNode(connectionInformation);
@@ -542,9 +536,9 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 		{
 			for (auto const& outputAudioClusterKV : streamPortOutputKV.second.audioClusters)
 			{
-				for (std::uint16_t channelIndex = 0u; channelIndex < outputAudioClusterKV.second.staticModel->channelCount; channelIndex++)
+				for (std::uint16_t channelIndex = 0u; channelIndex < outputAudioClusterKV.second.staticModel.channelCount; channelIndex++)
 				{
-					auto sourceChannelIdentification = avdecc::ChannelIdentification{ *_previousConfigurationIndex, outputAudioClusterKV.first, channelIndex, avdecc::ChannelConnectionDirection::OutputToInput, audioUnitIndex, streamPortOutputKV.first, streamPortOutputKV.second.staticModel->baseCluster };
+					auto sourceChannelIdentification = avdecc::ChannelIdentification{ *_previousConfigurationIndex, outputAudioClusterKV.first, channelIndex, avdecc::ChannelConnectionDirection::OutputToInput, audioUnitIndex, streamPortOutputKV.first, streamPortOutputKV.second.staticModel.baseCluster };
 					auto connectionInformation = channelConnectionManager.getChannelConnections(_entityID, sourceChannelIdentification);
 
 					_deviceDetailsChannelTableModelTransmit.addNode(connectionInformation);
@@ -563,7 +557,7 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 			return;
 
 		// add the streaminput node to the model
-		_deviceDetailsInputStreamFormatTableModel.addNode(node.descriptorIndex, node.descriptorType, node.dynamicModel->streamFormat);
+		_deviceDetailsInputStreamFormatTableModel.addNode(node.descriptorIndex, node.descriptorType, node.dynamicModel.streamFormat);
 
 		// open the persistent editor for the just added streaminput
 		auto modIdx = _deviceDetailsInputStreamFormatTableModel.index(_deviceDetailsInputStreamFormatTableModel.rowCount() - 1, static_cast<int>(DeviceDetailsStreamFormatTableModelColumn::StreamFormat), QModelIndex());
@@ -580,7 +574,7 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 			return;
 
 		// add the streamoutput node to the model
-		_deviceDetailsOutputStreamFormatTableModel.addNode(node.descriptorIndex, node.descriptorType, node.dynamicModel->streamFormat);
+		_deviceDetailsOutputStreamFormatTableModel.addNode(node.descriptorIndex, node.descriptorType, node.dynamicModel.streamFormat);
 
 		// open the persistent editor for the just added streamoutput
 		auto modIdx = _deviceDetailsOutputStreamFormatTableModel.index(_deviceDetailsOutputStreamFormatTableModel.rowCount() - 1, static_cast<int>(DeviceDetailsStreamFormatTableModelColumn::StreamFormat), QModelIndex());
@@ -610,7 +604,12 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 	/**
 	* Ignored.
 	*/
-	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const /*grandParent*/, la::avdecc::controller::model::AudioUnitNode const* const /*parent*/, la::avdecc::controller::model::StreamPortNode const& /*node*/) noexcept override {}
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const /*grandParent*/, la::avdecc::controller::model::AudioUnitNode const* const /*parent*/, la::avdecc::controller::model::StreamPortInputNode const& /*node*/) noexcept override {}
+
+	/**
+	* Ignored.
+	*/
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const /*grandParent*/, la::avdecc::controller::model::AudioUnitNode const* const /*parent*/, la::avdecc::controller::model::StreamPortOutputNode const& /*node*/) noexcept override {}
 
 	/**
 	* Ignored.
@@ -636,35 +635,29 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 	 * Method to process every incoming redundantstream node.
 	 * This implementation takes the primary stream and adds the format of it to the model (StreamInput or -Output) used for StreamFormat tab and opens the corresponding persistent editor in the new row.
 	*/
-	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*controlledEntity*/, la::avdecc::controller::model::ConfigurationNode const* const /*parent*/, la::avdecc::controller::model::RedundantStreamNode const& node) noexcept override
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*entity*/, la::avdecc::controller::model::ConfigurationNode const* const /*grandParent*/, la::avdecc::controller::model::RedundantStreamNode const* const parent, la::avdecc::controller::model::StreamInputNode const& node) noexcept override
 	{
-		if (node.descriptorType == la::avdecc::entity::model::DescriptorType::StreamInput)
+		if (node.descriptorIndex == parent->primaryStreamIndex)
 		{
-			auto const& streamInputNode = static_cast<const la::avdecc::controller::model::StreamInputNode*>(node.primaryStream);
+			// add the streaminput node to the model
+			_deviceDetailsInputStreamFormatTableModel.addNode(node.descriptorIndex, node.descriptorType, node.dynamicModel.streamFormat);
 
-			if (streamInputNode)
-			{
-				// add the streaminput node to the model
-				_deviceDetailsInputStreamFormatTableModel.addNode(streamInputNode->descriptorIndex, streamInputNode->descriptorType, streamInputNode->dynamicModel->streamFormat);
-
-				// open the persistent editor for the just added streaminput
-				auto modIdx = _deviceDetailsInputStreamFormatTableModel.index(_deviceDetailsInputStreamFormatTableModel.rowCount() - 1, static_cast<int>(DeviceDetailsStreamFormatTableModelColumn::StreamFormat), QModelIndex());
-				tableViewInputStreamFormat->openPersistentEditor(modIdx);
-			}
+			// open the persistent editor for the just added streaminput
+			auto modIdx = _deviceDetailsInputStreamFormatTableModel.index(_deviceDetailsInputStreamFormatTableModel.rowCount() - 1, static_cast<int>(DeviceDetailsStreamFormatTableModelColumn::StreamFormat), QModelIndex());
+			tableViewInputStreamFormat->openPersistentEditor(modIdx);
 		}
-		else if (node.descriptorType == la::avdecc::entity::model::DescriptorType::StreamOutput)
-		{
-			auto const& streamOutputNode = static_cast<const la::avdecc::controller::model::StreamOutputNode*>(node.primaryStream);
+	}
 
-			if (streamOutputNode)
-			{
-				// add the streamoutput node to the model
-				_deviceDetailsOutputStreamFormatTableModel.addNode(streamOutputNode->descriptorIndex, streamOutputNode->descriptorType, streamOutputNode->dynamicModel->streamFormat);
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const /*entity*/, la::avdecc::controller::model::ConfigurationNode const* const /*grandParent*/, la::avdecc::controller::model::RedundantStreamNode const* const parent, la::avdecc::controller::model::StreamOutputNode const& node) noexcept override
+	{
+		if (node.descriptorIndex == parent->primaryStreamIndex)
+		{
+			// add the streamoutput node to the model
+			_deviceDetailsOutputStreamFormatTableModel.addNode(node.descriptorIndex, node.descriptorType, node.dynamicModel.streamFormat);
 
-				// open the persistent editor for the just added streamoutput
-				auto modIdx = _deviceDetailsOutputStreamFormatTableModel.index(_deviceDetailsOutputStreamFormatTableModel.rowCount() - 1, static_cast<int>(DeviceDetailsStreamFormatTableModelColumn::StreamFormat), QModelIndex());
-				tableViewOutputStreamFormat->openPersistentEditor(modIdx);
-			}
+			// open the persistent editor for the just added streamoutput
+			auto modIdx = _deviceDetailsOutputStreamFormatTableModel.index(_deviceDetailsOutputStreamFormatTableModel.rowCount() - 1, static_cast<int>(DeviceDetailsStreamFormatTableModelColumn::StreamFormat), QModelIndex());
+			tableViewOutputStreamFormat->openPersistentEditor(modIdx);
 		}
 	}
 
@@ -987,7 +980,7 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 		auto controlledEntity = manager.getControlledEntity(_entityID);
 		if (controlledEntity)
 		{
-			la::avdecc::controller::model::ConfigurationNode configurationNode;
+			auto configurationNode = la::avdecc::controller::model::ConfigurationNode{ controlledEntity->getCurrentConfigurationNode() };
 			try
 			{
 				configurationNode = controlledEntity->getCurrentConfigurationNode();
@@ -1000,16 +993,16 @@ class DeviceDetailsDialogImpl final : private Ui::DeviceDetailsDialog, public QO
 			auto latency = decltype(la::avdecc::entity::model::StreamDynamicInfo::msrpAccumulatedLatency){ std::nullopt };
 			for (auto const& streamOutput : configurationNode.streamOutputs)
 			{
-				auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamOutput.second.dynamicModel->streamFormat);
+				auto const streamFormatInfo = la::avdecc::entity::model::StreamFormatInfo::create(streamOutput.second.dynamicModel.streamFormat);
 				auto const streamType = streamFormatInfo->getType();
 				if (streamType == la::avdecc::entity::model::StreamFormatInfo::Type::ClockReference)
 				{
 					// skip clock stream
 					continue;
 				}
-				if (streamOutput.second.dynamicModel->streamDynamicInfo)
+				if (streamOutput.second.dynamicModel.streamDynamicInfo)
 				{
-					auto const streamLatency = (*streamOutput.second.dynamicModel->streamDynamicInfo).msrpAccumulatedLatency;
+					auto const streamLatency = (*streamOutput.second.dynamicModel.streamDynamicInfo).msrpAccumulatedLatency;
 					if (latency != streamLatency && latency != std::nullopt)
 					{
 						// unequal values
diff --git a/src/deviceDetailsStreamFormatTableModel.cpp b/src/deviceDetailsStreamFormatTableModel.cpp
index 795d6bb5..23ede022 100644
--- a/src/deviceDetailsStreamFormatTableModel.cpp
+++ b/src/deviceDetailsStreamFormatTableModel.cpp
@@ -214,31 +214,28 @@ QVariant DeviceDetailsStreamFormatTableModelPrivate::data(QModelIndex const& ind
 						if (controlledEntity)
 						{
 							auto const& entityNode = controlledEntity->getEntityNode();
-							if (entityNode.dynamicModel)
-							{
-								auto const configurationIndex = entityNode.dynamicModel->currentConfiguration;
-
-								auto streamName = QString();
+							auto const configurationIndex = entityNode.dynamicModel.currentConfiguration;
 
-								if (streamFormatData.streamType == la::avdecc::entity::model::DescriptorType::StreamOutput)
-								{
-									auto const& streamOutput = controlledEntity->getStreamOutputNode(configurationIndex, streamFormatData.streamIndex);
-									streamName = hive::modelsLibrary::helper::localizedString(*controlledEntity, streamOutput.staticModel->localizedDescription);
+							auto streamName = QString();
 
-									if (configurationIndex == controlledEntity->getEntityNode().dynamicModel->currentConfiguration && !streamOutput.dynamicModel->objectName.empty())
-										streamName = streamOutput.dynamicModel->objectName.data();
-								}
-								else if (streamFormatData.streamType == la::avdecc::entity::model::DescriptorType::StreamInput)
-								{
-									auto const& streamInput = controlledEntity->getStreamInputNode(configurationIndex, streamFormatData.streamIndex);
-									streamName = hive::modelsLibrary::helper::localizedString(*controlledEntity, streamInput.staticModel->localizedDescription);
+							if (streamFormatData.streamType == la::avdecc::entity::model::DescriptorType::StreamOutput)
+							{
+								auto const& streamOutput = controlledEntity->getStreamOutputNode(configurationIndex, streamFormatData.streamIndex);
+								streamName = hive::modelsLibrary::helper::localizedString(*controlledEntity, streamOutput.staticModel.localizedDescription);
 
-									if (configurationIndex == controlledEntity->getEntityNode().dynamicModel->currentConfiguration && !streamInput.dynamicModel->objectName.empty())
-										streamName = streamInput.dynamicModel->objectName.data();
-								}
+								if (configurationIndex == controlledEntity->getEntityNode().dynamicModel.currentConfiguration && !streamOutput.dynamicModel.objectName.empty())
+									streamName = streamOutput.dynamicModel.objectName.data();
+							}
+							else if (streamFormatData.streamType == la::avdecc::entity::model::DescriptorType::StreamInput)
+							{
+								auto const& streamInput = controlledEntity->getStreamInputNode(configurationIndex, streamFormatData.streamIndex);
+								streamName = hive::modelsLibrary::helper::localizedString(*controlledEntity, streamInput.staticModel.localizedDescription);
 
-								return streamName;
+								if (configurationIndex == controlledEntity->getEntityNode().dynamicModel.currentConfiguration && !streamInput.dynamicModel.objectName.empty())
+									streamName = streamInput.dynamicModel.objectName.data();
 							}
+
+							return streamName;
 						}
 					}
 					catch (...)
@@ -550,22 +547,19 @@ QWidget* StreamFormatItemDelegate::createEditor(QWidget* parent, const QStyleOpt
 	if (controlledEntity)
 	{
 		auto const& entityNode = controlledEntity->getEntityNode();
-		if (entityNode.dynamicModel)
-		{
-			auto const configurationIndex = entityNode.dynamicModel->currentConfiguration;
+		auto const configurationIndex = entityNode.dynamicModel.currentConfiguration;
 
-			if (streamFormatData.streamType == la::avdecc::entity::model::DescriptorType::StreamOutput)
-			{
-				auto const& streamOutput = controlledEntity->getStreamOutputNode(configurationIndex, streamFormatData.streamIndex);
-				staticModel = streamOutput.staticModel;
-				dynamicModel = static_cast<decltype(dynamicModel)>(streamOutput.dynamicModel);
-			}
-			else if (streamFormatData.streamType == la::avdecc::entity::model::DescriptorType::StreamInput)
-			{
-				auto const& streamInput = controlledEntity->getStreamInputNode(configurationIndex, streamFormatData.streamIndex);
-				staticModel = streamInput.staticModel;
-				dynamicModel = static_cast<decltype(dynamicModel)>(streamInput.dynamicModel);
-			}
+		if (streamFormatData.streamType == la::avdecc::entity::model::DescriptorType::StreamOutput)
+		{
+			auto const& streamOutput = controlledEntity->getStreamOutputNode(configurationIndex, streamFormatData.streamIndex);
+			staticModel = &streamOutput.staticModel;
+			dynamicModel = static_cast<decltype(dynamicModel)>(&streamOutput.dynamicModel);
+		}
+		else if (streamFormatData.streamType == la::avdecc::entity::model::DescriptorType::StreamInput)
+		{
+			auto const& streamInput = controlledEntity->getStreamInputNode(configurationIndex, streamFormatData.streamIndex);
+			staticModel = &streamInput.staticModel;
+			dynamicModel = static_cast<decltype(dynamicModel)>(&streamInput.dynamicModel);
 		}
 	}
 
diff --git a/src/diagnostics/controlDiagnosticsTreeWidgetItem.cpp b/src/diagnostics/controlDiagnosticsTreeWidgetItem.cpp
new file mode 100644
index 00000000..7bbacc7f
--- /dev/null
+++ b/src/diagnostics/controlDiagnosticsTreeWidgetItem.cpp
@@ -0,0 +1,69 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "controlDiagnosticsTreeWidgetItem.hpp"
+
+#include <QtMate/material/color.hpp>
+
+#include <map>
+#include <QMenu>
+
+ControlDiagnosticsTreeWidgetItem::ControlDiagnosticsTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::controller::ControlledEntity::Diagnostics const& diagnostics, QTreeWidget* parent)
+	: QTreeWidgetItem(parent)
+	, _entityID(entityID)
+	, _controlIndex(controlIndex)
+{
+	// Create fields
+	_controlValueOutOfBounds = new QTreeWidgetItem(this);
+	_controlValueOutOfBounds->setText(0, "Value out of bounds");
+
+	// Update diagnostics right now
+	auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
+	updateDiagnostics(manager.getDiagnostics(entityID));
+
+	// Listen for diagnosticsChanged
+	connect(&manager, &hive::modelsLibrary::ControllerManager::diagnosticsChanged, this,
+		[this](la::avdecc::UniqueIdentifier const entityID, la::avdecc::controller::ControlledEntity::Diagnostics const& diagnostics)
+		{
+			if (entityID == _entityID)
+			{
+				updateDiagnostics(diagnostics);
+			}
+		});
+}
+
+void ControlDiagnosticsTreeWidgetItem::updateDiagnostics(la::avdecc::controller::ControlledEntity::Diagnostics const& diagnostics)
+{
+	// Cache diagnostics
+	_diagnostics = diagnostics;
+
+	// Latency Error
+	{
+		auto color = qtMate::material::color::foregroundColor();
+		auto text = "No";
+		if (_diagnostics.controlCurrentValueOutOfBounds.count(_controlIndex) > 0)
+		{
+			color = qtMate::material::color::foregroundErrorColorValue(qtMate::material::color::backgroundColorName(), qtMate::material::color::colorSchemeShade());
+			text = "Yes";
+		}
+		_controlValueOutOfBounds->setForeground(0, color);
+		_controlValueOutOfBounds->setForeground(1, color);
+		_controlValueOutOfBounds->setText(1, text);
+	}
+}
diff --git a/src/diagnostics/controlDiagnosticsTreeWidgetItem.hpp b/src/diagnostics/controlDiagnosticsTreeWidgetItem.hpp
new file mode 100644
index 00000000..fb317d76
--- /dev/null
+++ b/src/diagnostics/controlDiagnosticsTreeWidgetItem.hpp
@@ -0,0 +1,52 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <la/avdecc/controller/internals/avdeccControlledEntity.hpp>
+
+#include "avdecc/helper.hpp"
+#include "nodeTreeWidget.hpp"
+
+#include <hive/modelsLibrary/controllerManager.hpp>
+
+#include <map>
+
+#include <QObject>
+#include <QTreeWidgetItem>
+#include <QPushButton>
+#include <QLabel>
+#include <QHBoxLayout>
+#include <QListWidget>
+
+class ControlDiagnosticsTreeWidgetItem : public QObject, public QTreeWidgetItem
+{
+public:
+	ControlDiagnosticsTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::controller::ControlledEntity::Diagnostics const& diagnostics, QTreeWidget* parent = nullptr);
+
+private:
+	void updateDiagnostics(la::avdecc::controller::ControlledEntity::Diagnostics const& diagnostics);
+
+	la::avdecc::UniqueIdentifier const _entityID{};
+	la::avdecc::entity::model::ControlIndex const _controlIndex{ 0u };
+
+	// Diagnostics
+	la::avdecc::controller::ControlledEntity::Diagnostics _diagnostics{};
+	QTreeWidgetItem* _controlValueOutOfBounds{ nullptr };
+};
diff --git a/src/diagnostics/entityDiagnosticsTreeWidgetItem.cpp b/src/diagnostics/entityDiagnosticsTreeWidgetItem.cpp
index 5d42f131..a2057949 100644
--- a/src/diagnostics/entityDiagnosticsTreeWidgetItem.cpp
+++ b/src/diagnostics/entityDiagnosticsTreeWidgetItem.cpp
@@ -19,6 +19,8 @@
 
 #include "entityDiagnosticsTreeWidgetItem.hpp"
 
+#include <QtMate/material/color.hpp>
+
 #include <map>
 #include <QMenu>
 
@@ -52,11 +54,11 @@ void EntityDiagnosticsTreeWidgetItem::updateDiagnostics(la::avdecc::controller::
 
 	// Redundancy Warning
 	{
-		auto color = QColor{ Qt::black };
+		auto color = qtMate::material::color::foregroundColor();
 		auto text = "No";
 		if (_diagnostics.redundancyWarning)
 		{
-			color = QColor{ Qt::red };
+			color = qtMate::material::color::foregroundErrorColorValue(qtMate::material::color::backgroundColorName(), qtMate::material::color::colorSchemeShade());
 			text = "Yes";
 		}
 		_redundancyWarning->setForeground(0, color);
diff --git a/src/diagnostics/streamInputDiagnosticsTreeWidgetItem.cpp b/src/diagnostics/streamInputDiagnosticsTreeWidgetItem.cpp
index 131e7b74..98cf88eb 100644
--- a/src/diagnostics/streamInputDiagnosticsTreeWidgetItem.cpp
+++ b/src/diagnostics/streamInputDiagnosticsTreeWidgetItem.cpp
@@ -19,6 +19,8 @@
 
 #include "streamInputDiagnosticsTreeWidgetItem.hpp"
 
+#include <QtMate/material/color.hpp>
+
 #include <map>
 #include <QMenu>
 
@@ -64,7 +66,7 @@ void StreamInputDiagnosticsTreeWidgetItem::updateDiagnostics(la::avdecc::control
 
 	// Latency Error
 	{
-		auto color = QColor{ _isConnected ? Qt::black : Qt::gray };
+		auto color = QColor{ _isConnected ? qtMate::material::color::foregroundColor() : qtMate::material::color::disabledForegroundColor() };
 		auto text = "No";
 		if (_isConnected)
 		{
diff --git a/src/discoveredEntities/view.cpp b/src/discoveredEntities/view.cpp
index 5333f0f4..c01038f1 100644
--- a/src/discoveredEntities/view.cpp
+++ b/src/discoveredEntities/view.cpp
@@ -30,39 +30,42 @@ View::View(QWidget* parent)
 	: qtMate::widgets::TableView{ parent }
 {
 	// Setup model with proxy
-	_proxyModel.setSourceModel(&_model);
+	_proxyModel.setSourceModel(&_controllerModel);
 	setModel(&_proxyModel);
 }
 
 View::~View() {}
 
-void View::setupView(hive::VisibilityDefaults const& defaults) noexcept
+void View::setupView(hive::VisibilityDefaults const& defaults, bool const firstSetup) noexcept
 {
+	_firstSetup = firstSetup;
+
 	// Set selection behavior
 	setSelectionBehavior(QAbstractItemView::SelectRows);
 	setSelectionMode(QAbstractItemView::SingleSelection);
 	setFocusPolicy(Qt::ClickFocus);
 
-	// Set column delegates
-	setItemDelegateForColumn(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::EntityLogo), &_imageItemDelegate);
-	setItemDelegateForColumn(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Compatibility), &_imageItemDelegate);
-	setItemDelegateForColumn(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::AcquireState), &_imageItemDelegate);
-	setItemDelegateForColumn(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::LockState), &_imageItemDelegate);
-	setItemDelegateForColumn(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::EntityID), &_errorItemDelegate);
+	// Set delegate for the entire table
+	setItemDelegate(&_controllerModelItemDelegate);
 
 	// Set dynamic header view
 	_dynamicHeaderView.setSectionsClickable(true);
 	_dynamicHeaderView.setHighlightSections(false);
-	_dynamicHeaderView.setMandatorySection(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::EntityID));
+	_dynamicHeaderView.setMandatorySection(ControllerModelEntityColumn_EntityStatus);
+	_dynamicHeaderView.setMandatorySection(ControllerModelEntityColumn_EntityID);
 
 	// Configure sortable sections
-	_headerSectionSortFilter.enable(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Compatibility));
-	_headerSectionSortFilter.enable(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::EntityID));
-	_headerSectionSortFilter.enable(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Name));
-	_headerSectionSortFilter.enable(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Group));
-	_headerSectionSortFilter.enable(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::GrandmasterID));
-	_headerSectionSortFilter.enable(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::MediaClockMasterID));
-	_headerSectionSortFilter.enable(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::MediaClockMasterName));
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_EntityStatus);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_Compatibility);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_EntityID);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_Name);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_Group);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_GrandmasterID);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_AssociationID);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_EntityModelID);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_FirmwareVersion);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_MediaClockID);
+	_headerSectionSortFilter.enable(ControllerModelEntityColumn_MediaClockName);
 
 	// Set Horizontal header view to our dynamic one
 	setHorizontalHeader(&_dynamicHeaderView);
@@ -78,41 +81,50 @@ void View::setupView(hive::VisibilityDefaults const& defaults) noexcept
 	setContextMenuPolicy(Qt::CustomContextMenu);
 
 	// Initialize UI defaults
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::EntityLogo), !defaults.controllerTableView_EntityLogo_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Compatibility), !defaults.controllerTableView_Compatibility_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Name), !defaults.controllerTableView_Name_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Group), !defaults.controllerTableView_Group_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::AcquireState), !defaults.controllerTableView_AcquireState_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::LockState), !defaults.controllerTableView_LockState_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::GrandmasterID), !defaults.controllerTableView_GrandmasterID_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::GptpDomain), !defaults.controllerTableView_GptpDomain_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::InterfaceIndex), !defaults.controllerTableView_InterfaceIndex_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::AssociationID), !defaults.controllerTableView_AssociationID_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::MediaClockMasterID), !defaults.controllerTableView_MediaClockMasterID_Visible);
-	setColumnHidden(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::MediaClockMasterName), !defaults.controllerTableView_MediaClockMasterName_Visible);
-
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::EntityLogo), defaults::ui::AdvancedView::ColumnWidth_Logo);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Compatibility), defaults::ui::AdvancedView::ColumnWidth_Compatibility);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::EntityID), defaults::ui::AdvancedView::ColumnWidth_UniqueIdentifier);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Name), defaults::ui::AdvancedView::ColumnWidth_Name);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Group), defaults::ui::AdvancedView::ColumnWidth_Group);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::AcquireState), defaults::ui::AdvancedView::ColumnWidth_ExclusiveAccessState);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::LockState), defaults::ui::AdvancedView::ColumnWidth_ExclusiveAccessState);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::GrandmasterID), defaults::ui::AdvancedView::ColumnWidth_UniqueIdentifier);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::GptpDomain), defaults::ui::AdvancedView::ColumnWidth_GPTPDomain);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::InterfaceIndex), defaults::ui::AdvancedView::ColumnWidth_InterfaceIndex);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::AssociationID), defaults::ui::AdvancedView::ColumnWidth_UniqueIdentifier);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::MediaClockMasterID), defaults::ui::AdvancedView::ColumnWidth_UniqueIdentifier);
-	setColumnWidth(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::MediaClockMasterName), defaults::ui::AdvancedView::ColumnWidth_Name);
+	setColumnHidden(ControllerModelEntityColumn_EntityLogo, !defaults.controllerTableView_EntityLogo_Visible);
+	setColumnHidden(ControllerModelEntityColumn_Compatibility, !defaults.controllerTableView_Compatibility_Visible);
+	setColumnHidden(ControllerModelEntityColumn_Name, !defaults.controllerTableView_Name_Visible);
+	setColumnHidden(ControllerModelEntityColumn_Group, !defaults.controllerTableView_Group_Visible);
+	setColumnHidden(ControllerModelEntityColumn_AcquireState, !defaults.controllerTableView_AcquireState_Visible);
+	setColumnHidden(ControllerModelEntityColumn_LockState, !defaults.controllerTableView_LockState_Visible);
+	setColumnHidden(ControllerModelEntityColumn_GrandmasterID, !defaults.controllerTableView_GrandmasterID_Visible);
+	setColumnHidden(ControllerModelEntityColumn_GPTPDomain, !defaults.controllerTableView_GptpDomain_Visible);
+	setColumnHidden(ControllerModelEntityColumn_InterfaceIndex, !defaults.controllerTableView_InterfaceIndex_Visible);
+	setColumnHidden(ControllerModelEntityColumn_MacAddress, !defaults.controllerTableView_MacAddress_Visible);
+	setColumnHidden(ControllerModelEntityColumn_AssociationID, !defaults.controllerTableView_AssociationID_Visible);
+	setColumnHidden(ControllerModelEntityColumn_EntityModelID, !defaults.controllerTableView_EntityModelID_Visible);
+	setColumnHidden(ControllerModelEntityColumn_FirmwareVersion, !defaults.controllerTableView_FirmwareVersion_Visible);
+	setColumnHidden(ControllerModelEntityColumn_MediaClockID, !defaults.controllerTableView_MediaClockMasterID_Visible);
+	setColumnHidden(ControllerModelEntityColumn_MediaClockName, !defaults.controllerTableView_MediaClockMasterName_Visible);
+	setColumnHidden(ControllerModelEntityColumn_ClockDomainLockState, !defaults.controllerTableView_ClockDomainLockState_Visible);
+
+	setColumnWidth(ControllerModelEntityColumn_EntityStatus, defaults::ui::AdvancedView::ColumnWidth_Error);
+	setColumnWidth(ControllerModelEntityColumn_EntityLogo, defaults::ui::AdvancedView::ColumnWidth_Logo);
+	setColumnWidth(ControllerModelEntityColumn_Compatibility, defaults::ui::AdvancedView::ColumnWidth_Compatibility);
+	setColumnWidth(ControllerModelEntityColumn_EntityID, defaults::ui::AdvancedView::ColumnWidth_UniqueIdentifier);
+	setColumnWidth(ControllerModelEntityColumn_Name, defaults::ui::AdvancedView::ColumnWidth_Name);
+	setColumnWidth(ControllerModelEntityColumn_Group, defaults::ui::AdvancedView::ColumnWidth_Group);
+	setColumnWidth(ControllerModelEntityColumn_AcquireState, defaults::ui::AdvancedView::ColumnWidth_SquareIcon);
+	setColumnWidth(ControllerModelEntityColumn_LockState, defaults::ui::AdvancedView::ColumnWidth_SquareIcon);
+	setColumnWidth(ControllerModelEntityColumn_GrandmasterID, defaults::ui::AdvancedView::ColumnWidth_UniqueIdentifier);
+	setColumnWidth(ControllerModelEntityColumn_GPTPDomain, defaults::ui::AdvancedView::ColumnWidth_GPTPDomain);
+	setColumnWidth(ControllerModelEntityColumn_InterfaceIndex, defaults::ui::AdvancedView::ColumnWidth_InterfaceIndex);
+	setColumnWidth(ControllerModelEntityColumn_MacAddress, defaults::ui::AdvancedView::ColumnWidth_MacAddress);
+	setColumnWidth(ControllerModelEntityColumn_AssociationID, defaults::ui::AdvancedView::ColumnWidth_UniqueIdentifier);
+	setColumnWidth(ControllerModelEntityColumn_EntityModelID, defaults::ui::AdvancedView::ColumnWidth_UniqueIdentifier);
+	setColumnWidth(ControllerModelEntityColumn_FirmwareVersion, defaults::ui::AdvancedView::ColumnWidth_Firmware);
+	setColumnWidth(ControllerModelEntityColumn_MediaClockID, defaults::ui::AdvancedView::ColumnWidth_UniqueIdentifier);
+	setColumnWidth(ControllerModelEntityColumn_MediaClockName, defaults::ui::AdvancedView::ColumnWidth_Name);
+	setColumnWidth(ControllerModelEntityColumn_ClockDomainLockState, defaults::ui::AdvancedView::ColumnWidth_SquareIcon);
 
 	// Connect all signals
+	auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
 
 	// Connect the item delegates with theme color changes
-	connect(&_settingsSignaler, &SettingsSignaler::themeColorNameChanged, &_imageItemDelegate, &hive::widgetModelsLibrary::ImageItemDelegate::setThemeColorName);
-	connect(&_settingsSignaler, &SettingsSignaler::themeColorNameChanged, &_errorItemDelegate, &hive::widgetModelsLibrary::ErrorItemDelegate::setThemeColorName);
+	connect(&_settingsSignaler, &SettingsSignaler::themeColorNameChanged, &_controllerModelItemDelegate, &hive::widgetModelsLibrary::DiscoveredEntitiesTableItemDelegate::setThemeColorName);
 
 	// Listen for entity going offline
-	connect(&_model, &avdecc::ControllerModel::entityOffline, this,
+	connect(&manager, &hive::modelsLibrary::ControllerManager::entityOffline, this,
 		[this](la::avdecc::UniqueIdentifier const eid)
 		{
 			// The currently selected entity is going offline
@@ -124,7 +136,7 @@ void View::setupView(hive::VisibilityDefaults const& defaults) noexcept
 		});
 
 	// Listen for model reset
-	connect(&_model, &QAbstractItemModel::modelAboutToBeReset, this,
+	connect(&_controllerModel, &QAbstractItemModel::modelAboutToBeReset, this,
 		[this]()
 		{
 			// Clear selected entity
@@ -132,21 +144,14 @@ void View::setupView(hive::VisibilityDefaults const& defaults) noexcept
 		});
 
 	// Listen for selection change
-	connect(selectionModel(), &QItemSelectionModel::selectionChanged, this,
-		[this](QItemSelection const& selected, QItemSelection const& deselected)
+	connect(selectionModel(), &QItemSelectionModel::currentChanged, this,
+		[this](QModelIndex const& current, QModelIndex const& previous)
 		{
-			auto index = QModelIndex{};
-			auto const& selectedIndexes = selected.indexes();
-			if (!selectedIndexes.empty())
-			{
-				index = *selectedIndexes.begin();
-			}
-
-			auto const entityID = controlledEntityIDAtIndex(index);
+			auto const entityOpt = getEntityAtIndex(current);
 			auto previousEntityID = _selectedControlledEntity;
 
 			// Selection index is invalid (ie. no selection), or the currently selected entity doesn't exist
-			if (!index.isValid() || !entityID.isValid())
+			if (!current.isValid() || !entityOpt)
 			{
 				// Set currently selected ControlledEntity to nothing
 				_selectedControlledEntity = la::avdecc::UniqueIdentifier{};
@@ -154,6 +159,8 @@ void View::setupView(hive::VisibilityDefaults const& defaults) noexcept
 			else
 			{
 				// Set currently selected ControlledEntity to the new entityID
+				auto const& entity = (*entityOpt).get();
+				auto const entityID = entity.entityID;
 				_selectedControlledEntity = entityID;
 			}
 
@@ -170,11 +177,11 @@ void View::setupView(hive::VisibilityDefaults const& defaults) noexcept
 	connect(this, &QTableView::doubleClicked, this,
 		[this](QModelIndex const& index)
 		{
-			auto const entityID = controlledEntityIDAtIndex(index);
+			auto const entityOpt = getEntityAtIndex(index);
 
-			if (entityID.isValid())
+			if (entityOpt)
 			{
-				emit doubleClicked(entityID);
+				emit doubleClicked(entityOpt->get().entityID);
 			}
 		});
 
@@ -182,8 +189,11 @@ void View::setupView(hive::VisibilityDefaults const& defaults) noexcept
 		[this](QPoint const& pos)
 		{
 			auto const index = indexAt(pos);
-			auto const entityID = controlledEntityIDAtIndex(index);
-			emit contextMenuRequested(entityID, pos);
+			auto const entityOpt = getEntityAtIndex(index);
+			if (entityOpt)
+			{
+				emit contextMenuRequested(entityOpt->get(), pos);
+			}
 		});
 
 	// Start the settings signaler service (will trigger all known signals)
@@ -201,6 +211,16 @@ la::avdecc::UniqueIdentifier View::selectedControlledEntity() const noexcept
 	return _selectedControlledEntity;
 }
 
+void View::selectControlledEntity(la::avdecc::UniqueIdentifier const entityID) noexcept
+{
+	auto const index = indexOf(entityID);
+
+	if (index.isValid())
+	{
+		setCurrentIndex(index);
+	}
+}
+
 void View::saveDynamicHeaderState() const noexcept
 {
 	auto* const settings = qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>();
@@ -218,11 +238,27 @@ void View::clearSelection() noexcept
 	emit selectedControlledEntityChanged(_selectedControlledEntity);
 }
 
-la::avdecc::UniqueIdentifier View::controlledEntityIDAtIndex(QModelIndex const& index) const noexcept
+std::optional<std::reference_wrapper<hive::modelsLibrary::DiscoveredEntitiesModel::Entity const>> View::getEntityAtIndex(QModelIndex const& index) const noexcept
 {
-	auto const* m = static_cast<QSortFilterProxyModel const*>(model());
+	auto const* const m = static_cast<QSortFilterProxyModel const*>(model());
 	auto const sourceIndex = m->mapToSource(index);
-	return _model.getControlledEntityID(sourceIndex);
+	return _controllerModel.entity(sourceIndex.row());
+}
+
+QModelIndex View::indexOf(la::avdecc::UniqueIdentifier const entityID) const noexcept
+{
+	// When converting QModelIndex from Source to Proxy, we must convert using our Internal Proxy (_proxyModel) first as we are getting indexes from _controllerModel directly
+	// Then we have to use View's model() to also convert (if model is NOT our proxy), the instantiator might have installed another proxy
+	auto destIndex = _proxyModel.mapFromSource(_controllerModel.indexOf(entityID));
+
+	auto const* const m = static_cast<QSortFilterProxyModel const*>(model());
+	// Another proxy has been installed on top of our internal proxy
+	if (m != &_proxyModel)
+	{
+		destIndex = m->mapFromSource(destIndex);
+	}
+
+	return destIndex;
 }
 
 void View::showEvent(QShowEvent* event)
@@ -234,12 +270,27 @@ void View::showEvent(QShowEvent* event)
 		[this]()
 		{
 			// Set default sort section, if current is unsortable
-			if (!_headerSectionSortFilter.isEnabled(_dynamicHeaderView.sortIndicatorSection()))
+			if (_firstSetup || !_headerSectionSortFilter.isEnabled(_dynamicHeaderView.sortIndicatorSection()))
 			{
-				_dynamicHeaderView.setSortIndicator(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::EntityID), Qt::SortOrder::DescendingOrder);
+				_dynamicHeaderView.setSortIndicator(ControllerModelEntityColumn_EntityID, Qt::SortOrder::DescendingOrder);
 				saveDynamicHeaderState();
 			}
 		});
 }
 
+void View::keyReleaseEvent(QKeyEvent* event)
+{
+	// If the user pressed the delete key, delete the selected entity
+	if (event->key() == Qt::Key::Key_Delete)
+	{
+		auto const index = currentIndex();
+		auto const entityOpt = getEntityAtIndex(index);
+
+		if (entityOpt)
+		{
+			emit deleteEntityRequested(entityOpt->get().entityID);
+		}
+	}
+}
+
 } // namespace discoveredEntities
diff --git a/src/discoveredEntities/view.hpp b/src/discoveredEntities/view.hpp
index 1653f7f3..1e9bdcbb 100644
--- a/src/discoveredEntities/view.hpp
+++ b/src/discoveredEntities/view.hpp
@@ -19,7 +19,6 @@
 
 #pragma once
 
-#include "avdecc/controllerModel.hpp"
 #include "settingsManager/settings.hpp"
 #include "settingsManager/settingsSignaler.hpp"
 #include "visibilitySettings.hpp"
@@ -27,49 +26,75 @@
 #include <QtMate/widgets/tableView.hpp>
 #include <QtMate/widgets/dynamicHeaderView.hpp>
 #include <QtMate/widgets/headerViewSortSectionFilter.hpp>
-#include <hive/widgetModelsLibrary/imageItemDelegate.hpp>
-#include <hive/widgetModelsLibrary/errorItemDelegate.hpp>
+#include <hive/widgetModelsLibrary/discoveredEntitiesTableModel.hpp>
+#include <hive/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.hpp>
 
 #include <QSortFilterProxyModel>
+#include <QKeyEvent>
+#include <QShowEvent>
 
 namespace discoveredEntities
 {
 class View final : public qtMate::widgets::TableView
 {
 	Q_OBJECT
+	static constexpr auto ControllerModelEntityDataFlags = hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlags{ hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::EntityStatus, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::EntityLogo, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::Compatibility, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::EntityID, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::Name, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::Group, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::AcquireState,
+		hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::LockState, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::GrandmasterID, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::GPTPDomain, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::InterfaceIndex, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::MacAddress, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::AssociationID, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::EntityModelID, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::FirmwareVersion, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::MediaClockReferenceID,
+		hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::MediaClockReferenceName, hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::ClockDomainLockState };
+
 public:
+	static constexpr auto ControllerModelEntityColumn_EntityStatus = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::EntityStatus);
+	static constexpr auto ControllerModelEntityColumn_EntityLogo = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::EntityLogo);
+	static constexpr auto ControllerModelEntityColumn_Compatibility = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::Compatibility);
+	static constexpr auto ControllerModelEntityColumn_EntityID = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::EntityID);
+	static constexpr auto ControllerModelEntityColumn_Name = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::Name);
+	static constexpr auto ControllerModelEntityColumn_Group = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::Group);
+	static constexpr auto ControllerModelEntityColumn_AcquireState = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::AcquireState);
+	static constexpr auto ControllerModelEntityColumn_LockState = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::LockState);
+	static constexpr auto ControllerModelEntityColumn_GrandmasterID = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::GrandmasterID);
+	static constexpr auto ControllerModelEntityColumn_GPTPDomain = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::GPTPDomain);
+	static constexpr auto ControllerModelEntityColumn_InterfaceIndex = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::InterfaceIndex);
+	static constexpr auto ControllerModelEntityColumn_MacAddress = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::MacAddress);
+	static constexpr auto ControllerModelEntityColumn_AssociationID = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::AssociationID);
+	static constexpr auto ControllerModelEntityColumn_EntityModelID = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::EntityModelID);
+	static constexpr auto ControllerModelEntityColumn_FirmwareVersion = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::FirmwareVersion);
+	static constexpr auto ControllerModelEntityColumn_MediaClockID = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::MediaClockReferenceID);
+	static constexpr auto ControllerModelEntityColumn_MediaClockName = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::MediaClockReferenceName);
+	static constexpr auto ControllerModelEntityColumn_ClockDomainLockState = ControllerModelEntityDataFlags.getBitSetPosition(hive::widgetModelsLibrary::DiscoveredEntitiesTableModel::EntityDataFlag::ClockDomainLockState);
+
 	View(QWidget* parent = nullptr);
 	virtual ~View();
 
-	void setupView(hive::VisibilityDefaults const& defaults) noexcept;
+	void setupView(hive::VisibilityDefaults const& defaults, bool const firstSetup) noexcept;
 	void restoreState() noexcept;
 	la::avdecc::UniqueIdentifier selectedControlledEntity() const noexcept;
+	void selectControlledEntity(la::avdecc::UniqueIdentifier const entityID) noexcept;
 
 	// Public signals
 	Q_SIGNAL void selectedControlledEntityChanged(la::avdecc::UniqueIdentifier const entityID);
 	Q_SIGNAL void doubleClicked(la::avdecc::UniqueIdentifier const entityID);
-	Q_SIGNAL void contextMenuRequested(la::avdecc::UniqueIdentifier const entityID, QPoint const& pos);
+	Q_SIGNAL void contextMenuRequested(hive::modelsLibrary::DiscoveredEntitiesModel::Entity const& entity, QPoint const& pos);
+	Q_SIGNAL void deleteEntityRequested(la::avdecc::UniqueIdentifier const entityID);
 
 private:
 	void saveDynamicHeaderState() const noexcept;
 	void clearSelection() noexcept;
-	la::avdecc::UniqueIdentifier controlledEntityIDAtIndex(QModelIndex const& index) const noexcept;
+	std::optional<std::reference_wrapper<hive::modelsLibrary::DiscoveredEntitiesModel::Entity const>> getEntityAtIndex(QModelIndex const& index) const noexcept;
+	QModelIndex indexOf(la::avdecc::UniqueIdentifier const entityID) const noexcept;
 
 	// qtMate::widgets::TableView overrides
 	virtual void showEvent(QShowEvent* event) override;
-
-	// Slots
-	//void handleCreateChannelConnectionsFinished(avdecc::CreateConnectionsInfo const& info);
+	virtual void keyReleaseEvent(QKeyEvent* event) override;
 
 private:
-	avdecc::ControllerModel _model{ this };
 	QSortFilterProxyModel _proxyModel{};
 	qtMate::widgets::DynamicHeaderView _dynamicHeaderView{ Qt::Horizontal, this };
 	qtMate::widgets::HeaderViewSortSectionFilter _headerSectionSortFilter{ &_dynamicHeaderView };
-	hive::widgetModelsLibrary::ImageItemDelegate _imageItemDelegate{ true, qtMate::material::color::Palette::name(qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>()->getValue(settings::General_ThemeColorIndex.name).toInt()), this };
-	hive::widgetModelsLibrary::ErrorItemDelegate _errorItemDelegate{ true, qtMate::material::color::Palette::name(qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>()->getValue(settings::General_ThemeColorIndex.name).toInt()), this };
+	hive::widgetModelsLibrary::DiscoveredEntitiesTableModel _controllerModel{ ControllerModelEntityDataFlags };
+	hive::widgetModelsLibrary::DiscoveredEntitiesTableItemDelegate _controllerModelItemDelegate{ qtMate::material::color::Palette::name(qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>()->getValue(settings::General_ThemeColorIndex.name).toInt()), this };
 	SettingsSignaler _settingsSignaler{};
 	la::avdecc::UniqueIdentifier _selectedControlledEntity{};
+	bool _firstSetup{ false };
 };
 
 } // namespace discoveredEntities
diff --git a/src/discoveredEntitiesView.cpp b/src/discoveredEntitiesView.cpp
index f3ff8151..69e5d443 100644
--- a/src/discoveredEntitiesView.cpp
+++ b/src/discoveredEntitiesView.cpp
@@ -78,7 +78,7 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 		{
 			auto const& text = _searchLineEdit.text();
 			auto const pattern = QRegularExpression{ text };
-			_searchFilterProxyModel.setFilterKeyColumn(la::avdecc::utils::to_integral(avdecc::ControllerModel::Column::Name));
+			_searchFilterProxyModel.setFilterKeyColumn(discoveredEntities::View::ControllerModelEntityColumn_Name);
 			_searchFilterProxyModel.setFilterRegularExpression(pattern);
 			_searchFilterProxyModel.setFilterCaseSensitivity(Qt::CaseInsensitive);
 			emit filterChanged(text);
@@ -103,10 +103,10 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 		});
 
 	connect(&_entitiesView, &discoveredEntities::View::contextMenuRequested, this,
-		[this](la::avdecc::UniqueIdentifier const entityID, QPoint const& pos)
+		[this](hive::modelsLibrary::DiscoveredEntitiesModel::Entity const& entity, QPoint const& pos)
 		{
 			auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
-			auto controlledEntity = manager.getControlledEntity(entityID);
+			auto controlledEntity = manager.getControlledEntity(entity.entityID);
 
 			if (controlledEntity)
 			{
@@ -114,7 +114,7 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 
 				// Add header
 				{
-					auto* action = menu.addAction("Entity: " + hive::modelsLibrary::helper::smartEntityName(*controlledEntity));
+					auto* action = menu.addAction("Entity: " + hive::modelsLibrary::helper::smartEntityName(entity));
 					auto font = action->font();
 					font.setBold(true);
 					action->setFont(font);
@@ -122,10 +122,9 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 					menu.addSeparator();
 				}
 
-				auto const& entity = controlledEntity->getEntity();
-				auto const entityModelID = entity.getEntityModelID();
-				auto const isAemSupported = entity.getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported);
-				auto const hasAnyConfiguration = controlledEntity->hasAnyConfiguration();
+				auto const entityModelID = entity.entityModelID;
+				auto const isAemSupported = entity.isAemSupported;
+				auto const hasAnyConfiguration = entity.hasAnyConfigurationTree;
 				auto const isIdentifyControlValid = !!controlledEntity->getIdentifyControlIndex();
 
 				auto* acquireAction{ static_cast<QAction*>(nullptr) };
@@ -137,6 +136,7 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 				auto* getLogo{ static_cast<QAction*>(nullptr) };
 				auto* clearErrorFlags{ static_cast<QAction*>(nullptr) };
 				auto* identify{ static_cast<QAction*>(nullptr) };
+				auto* refreshEntity{ static_cast<QAction*>(nullptr) };
 				auto* dumpFullEntity{ static_cast<QAction*>(nullptr) };
 				auto* dumpEntityModel{ static_cast<QAction*>(nullptr) };
 
@@ -201,7 +201,7 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 					}
 					{
 						getLogo = menu.addAction("Retrieve Entity Logo");
-						getLogo->setEnabled(!hive::widgetModelsLibrary::EntityLogoCache::getInstance().isImageInCache(entityID, hive::widgetModelsLibrary::EntityLogoCache::Type::Entity));
+						getLogo->setEnabled(!hive::widgetModelsLibrary::EntityLogoCache::getInstance().isImageInCache(entity.entityID, hive::widgetModelsLibrary::EntityLogoCache::Type::Entity));
 					}
 					{
 						clearErrorFlags = menu.addAction("Acknowledge Counters Errors");
@@ -210,6 +210,9 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 						identify = menu.addAction("Identify Device (10 sec)");
 						identify->setEnabled(isIdentifyControlValid);
 					}
+					{
+						refreshEntity = menu.addAction("Refresh Entity");
+					}
 				}
 
 				menu.addSeparator();
@@ -233,47 +236,51 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 				{
 					if (action == acquireAction)
 					{
-						manager.acquireEntity(entityID, false);
+						manager.acquireEntity(entity.entityID, false);
 					}
 					else if (action == releaseAction)
 					{
-						manager.releaseEntity(entityID);
+						manager.releaseEntity(entity.entityID);
 					}
 					else if (action == lockAction)
 					{
-						manager.lockEntity(entityID);
+						manager.lockEntity(entity.entityID);
 					}
 					else if (action == unlockAction)
 					{
-						manager.unlockEntity(entityID);
+						manager.unlockEntity(entity.entityID);
 					}
 					else if (action == deviceView)
 					{
 						DeviceDetailsDialog* dialog = new DeviceDetailsDialog(this);
 						dialog->setAttribute(Qt::WA_DeleteOnClose);
-						dialog->setControlledEntityID(entityID);
+						dialog->setControlledEntityID(entity.entityID);
 						dialog->show();
 					}
 					else if (action == inspect)
 					{
 						auto* inspector = new EntityInspector;
 						inspector->setAttribute(Qt::WA_DeleteOnClose);
-						inspector->setControlledEntityID(entityID);
+						inspector->setControlledEntityID(entity.entityID);
 						inspector->restoreGeometry(_inspectorGeometry);
 						inspector->show();
 					}
 					else if (action == getLogo)
 					{
-						hive::widgetModelsLibrary::EntityLogoCache::getInstance().getImage(entityID, hive::widgetModelsLibrary::EntityLogoCache::Type::Entity, true);
+						hive::widgetModelsLibrary::EntityLogoCache::getInstance().getImage(entity.entityID, hive::widgetModelsLibrary::EntityLogoCache::Type::Entity, true);
 					}
 					else if (action == clearErrorFlags)
 					{
-						manager.clearAllStreamInputCounterValidFlags(entityID);
-						manager.clearAllStatisticsCounterValidFlags(entityID);
+						manager.clearAllStreamInputCounterValidFlags(entity.entityID);
+						manager.clearAllStatisticsCounterValidFlags(entity.entityID);
 					}
 					else if (action == identify)
 					{
-						manager.identifyEntity(entityID, std::chrono::seconds{ 10 });
+						manager.identifyEntity(entity.entityID, std::chrono::seconds{ 10 });
+					}
+					else if (action == refreshEntity)
+					{
+						manager.refreshEntity(entity.entityID);
 					}
 					else if (action == dumpFullEntity || action == dumpEntityModel)
 					{
@@ -282,7 +289,7 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 						if (action == dumpFullEntity)
 						{
 							binaryFilterName = "AVDECC Virtual Entity Files (*.ave)";
-							baseFileName = QString("%1/Entity_%2").arg(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation)).arg(hive::modelsLibrary::helper::uniqueIdentifierToString(entityID));
+							baseFileName = QString("%1/Entity_%2").arg(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation)).arg(hive::modelsLibrary::helper::uniqueIdentifierToString(entity.entityID));
 						}
 						else
 						{
@@ -292,7 +299,7 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 								QMessageBox::warning(this, "", "EntityModelID is not valid (invalid Vendor OUI-24), cannot same the Model of this Entity.");
 								return;
 							}
-							if (!avdecc::helper::isEntityModelComplete(entityID))
+							if (!avdecc::helper::isEntityModelComplete(entity.entityID))
 							{
 								QMessageBox::warning(this, "", "'Full AEM Enumeration' option must be Enabled in order to export Model of a multi-configuration Entity.");
 								return;
@@ -300,7 +307,7 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 							binaryFilterName = "AVDECC Entity Model Files (*.aem)";
 							baseFileName = QString("%1/EntityModel_%2").arg(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation)).arg(hive::modelsLibrary::helper::uniqueIdentifierToString(entityModelID));
 						}
-						auto const dumpFile = [this, &entityID, &manager, isFullEntity = (action == dumpFullEntity)](auto const& baseFileName, auto const& binaryFilterName, auto const isBinary)
+						auto const dumpFile = [this, entityID = entity.entityID, &manager, isFullEntity = (action == dumpFullEntity)](auto const& baseFileName, auto const& binaryFilterName, auto const isBinary)
 						{
 							auto const filename = QFileDialog::getSaveFileName(this, "Save As...", baseFileName, binaryFilterName);
 							if (!filename.isEmpty())
@@ -325,21 +332,29 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 								}
 								else
 								{
-									if (error == la::avdecc::jsonSerializer::SerializationError::InvalidDescriptorIndex && isFullEntity)
+									switch (error)
 									{
-										auto const choice = QMessageBox::question(this, "", QString("EntityID %1 model is not fully IEEE1722.1 compliant.\n%2\n\nDo you want to export anyway?").arg(hive::modelsLibrary::helper::uniqueIdentifierToString(entityID)).arg(message.c_str()), QMessageBox::StandardButton::Yes, QMessageBox::StandardButton::No);
-										if (choice == QMessageBox::StandardButton::Yes)
-										{
-											flags.set(la::avdecc::entity::model::jsonSerializer::Flag::IgnoreAEMSanityChecks);
-											auto const result = manager.serializeControlledEntityAsJson(entityID, filename, flags, avdecc::helper::generateDumpSourceString(hive::internals::applicationShortName, hive::internals::versionString));
-											error = std::get<0>(result);
-											message = std::get<1>(result);
-											if (!error)
+										case la::avdecc::jsonSerializer::SerializationError::InvalidDescriptorIndex:
+										case la::avdecc::jsonSerializer::SerializationError::NotSupported:
+											if (isFullEntity)
 											{
-												QMessageBox::information(this, "", "Export completed but with warnings:\n" + filename);
+												auto const choice = QMessageBox::question(this, "", QString("EntityID %1 model is not fully IEEE1722.1 compliant.\n%2\n\nDo you want to export anyway?").arg(hive::modelsLibrary::helper::uniqueIdentifierToString(entityID)).arg(message.c_str()), QMessageBox::StandardButton::Yes, QMessageBox::StandardButton::No);
+												if (choice == QMessageBox::StandardButton::Yes)
+												{
+													flags.set(la::avdecc::entity::model::jsonSerializer::Flag::IgnoreAEMSanityChecks);
+													auto const result = manager.serializeControlledEntityAsJson(entityID, filename, flags, avdecc::helper::generateDumpSourceString(hive::internals::applicationShortName, hive::internals::versionString));
+													error = std::get<0>(result);
+													message = std::get<1>(result);
+													if (!error)
+													{
+														QMessageBox::information(this, "", "Export completed but with warnings:\n" + filename);
+													}
+													// Fallthrough to warning message
+												}
 											}
-											// Fallthrough to warning message
-										}
+											break;
+										default:
+											break;
 									}
 									if (!!error)
 									{
@@ -361,6 +376,30 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 			}
 		});
 
+	connect(&_entitiesView, &discoveredEntities::View::deleteEntityRequested, this,
+		[this](auto const& entityID)
+		{
+			auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
+			auto controlledEntity = manager.getControlledEntity(entityID);
+
+			if (controlledEntity)
+			{
+				if (controlledEntity->isVirtual())
+				{
+					auto const name = hive::modelsLibrary::helper::smartEntityName(*controlledEntity);
+
+					// Release the controlled entity before starting a long operation (messagebox & call to manager)
+					controlledEntity.reset();
+
+					auto const choice = QMessageBox::question(this, "", QString("Do you really want to remove virtual entity %1 (%2)?").arg(hive::modelsLibrary::helper::uniqueIdentifierToString(entityID), name), QMessageBox::StandardButton::Yes, QMessageBox::StandardButton::No);
+					if (choice == QMessageBox::StandardButton::Yes)
+					{
+						manager.unloadVirtualEntity(entityID);
+					}
+				}
+			}
+		});
+
 	auto* searchShortcut = new QShortcut{ QKeySequence::Find, this };
 	connect(searchShortcut, &QShortcut::activated, this,
 		[this]()
@@ -370,9 +409,9 @@ DiscoveredEntitiesView::DiscoveredEntitiesView(QWidget* parent)
 		});
 }
 
-void DiscoveredEntitiesView::setupView(hive::VisibilityDefaults const& defaults) noexcept
+void DiscoveredEntitiesView::setupView(hive::VisibilityDefaults const& defaults, bool const firstSetup) noexcept
 {
-	_entitiesView.setupView(defaults);
+	_entitiesView.setupView(defaults, firstSetup);
 }
 
 discoveredEntities::View* DiscoveredEntitiesView::entitiesTableView() noexcept
diff --git a/src/discoveredEntitiesView.hpp b/src/discoveredEntitiesView.hpp
index ec6f3219..be1caec8 100644
--- a/src/discoveredEntitiesView.hpp
+++ b/src/discoveredEntitiesView.hpp
@@ -34,7 +34,7 @@ class DiscoveredEntitiesView : public QWidget
 public:
 	DiscoveredEntitiesView(QWidget* parent = nullptr);
 
-	void setupView(hive::VisibilityDefaults const& defaults) noexcept;
+	void setupView(hive::VisibilityDefaults const& defaults, bool const firstSetup) noexcept;
 	discoveredEntities::View* entitiesTableView() noexcept;
 	void setInspectorGeometry(QByteArray const& geometry) noexcept;
 	QString filterText() const noexcept;
diff --git a/src/entityInspector.cpp b/src/entityInspector.cpp
index 80fcb671..6be0aeb3 100644
--- a/src/entityInspector.cpp
+++ b/src/entityInspector.cpp
@@ -64,7 +64,7 @@ EntityInspector::EntityInspector(QWidget* parent)
 	connect(&controllerManager, &hive::modelsLibrary::ControllerManager::entityOnline, this, &EntityInspector::entityOnline);
 	connect(&controllerManager, &hive::modelsLibrary::ControllerManager::entityOffline, this, &EntityInspector::entityOffline);
 	connect(&controllerManager, &hive::modelsLibrary::ControllerManager::entityNameChanged, this, &EntityInspector::entityNameChanged);
-	connect(&_settingsSignaler, &SettingsSignaler::themeColorNameChanged, &_itemDelegate, &hive::widgetModelsLibrary::ErrorItemDelegate::setThemeColorName);
+	connect(&_settingsSignaler, &SettingsSignaler::themeColorNameChanged, &_itemDelegate, &ControlledEntityTreeWidgetItemDelegate::setThemeColorName);
 
 	_settingsSignaler.start();
 }
diff --git a/src/entityInspector.hpp b/src/entityInspector.hpp
index d1907b55..8861323a 100644
--- a/src/entityInspector.hpp
+++ b/src/entityInspector.hpp
@@ -20,12 +20,12 @@
 #pragma once
 
 #include "controlledEntityTreeWidget.hpp"
+#include "controlledEntityTreeWidgetItemDelegate.hpp"
 #include "nodeTreeWidget.hpp"
 #include "settingsManager/settings.hpp"
 #include "settingsManager/settingsSignaler.hpp"
 
 #include <QtMate/material/colorPalette.hpp>
-#include <hive/widgetModelsLibrary/errorItemDelegate.hpp>
 #include <hive/widgetModelsLibrary/qtUserRoles.hpp>
 
 #include <QSplitter>
@@ -39,7 +39,6 @@ class EntityInspector : public QWidget
 	enum class RoleInfo
 	{
 		NodeType = Qt::UserRole,
-		ErrorRole = la::avdecc::utils::to_integral(hive::widgetModelsLibrary::QtUserRoles::ErrorRole),
 		IsActiveConfiguration,
 	};
 
@@ -66,6 +65,6 @@ class EntityInspector : public QWidget
 	QSplitter _splitter{ Qt::Vertical, this };
 	ControlledEntityTreeWidget _controlledEntityTreeWiget{ this };
 	NodeTreeWidget _nodeTreeWiget{ this };
-	hive::widgetModelsLibrary::ErrorItemDelegate _itemDelegate{ true, qtMate::material::color::Palette::name(qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>()->getValue(settings::General_ThemeColorIndex.name).toInt()), this };
+	ControlledEntityTreeWidgetItemDelegate _itemDelegate{ qtMate::material::color::Palette::name(qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>()->getValue(settings::General_ThemeColorIndex.name).toInt()), this };
 	SettingsSignaler _settingsSignaler{};
 };
diff --git a/src/internals/config.hpp.in b/src/internals/config.hpp.in
index 0507ec4e..782b0e7b 100644
--- a/src/internals/config.hpp.in
+++ b/src/internals/config.hpp.in
@@ -37,6 +37,8 @@ QString const companyURL{ "@CU_COMPANY_URL@" };
 QString const projectContact{ "@CU_PROJECT_CONTACT@" };
 QString const versionString{ "@CU_PROJECT_FRIENDLY_VERSION@" }; // Friendly version (3 digits for release, 3 digits and beta postfix for beta)
 QString const marketingVersion{ "@CU_PROJECT_MARKETING_VERSION@" }; // Marketing version
+std::uint32_t const majorVersion{ @CU_PROJECT_VERSION_MAJOR@ };
+std::uint32_t const minorVersion{ @CU_PROJECT_VERSION_MINOR@ };
 std::uint32_t const marketingDigits{ @CU_PROJECT_MARKETING_VERSION_DIGITS@ }; // Marketing digits
 QString const cmakeVersionString{ "@CU_PROJECT_CMAKEVERSION_STRING@" }; // CMake version (3 digits for a release, 4 digits for a beta)
 QString const legalCopyright{ "@CU_PROJECT_LEGALCOPYRIGHT@" };
diff --git a/src/listViewSelectionToMatrixModelController.cpp b/src/listViewMatrixViewController.cpp
similarity index 72%
rename from src/listViewSelectionToMatrixModelController.cpp
rename to src/listViewMatrixViewController.cpp
index da6f9aff..2b275e64 100644
--- a/src/listViewSelectionToMatrixModelController.cpp
+++ b/src/listViewMatrixViewController.cpp
@@ -17,11 +17,16 @@
 * along with Hive.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "listViewSelectionToMatrixModelController.hpp"
+#include "listViewMatrixViewController.hpp"
+#include "connectionMatrix/model.hpp"
 
-ListViewSelectionToMatrixModelController::ListViewSelectionToMatrixModelController(discoveredEntities::View* listView, connectionMatrix::Model* matrixModel, QObject* parent)
+ListViewMatrixViewController::ListViewMatrixViewController(discoveredEntities::View* listView, connectionMatrix::View* matrixView, QObject* parent)
 	: QObject{ parent }
 {
+	auto* const matrixModel = static_cast<connectionMatrix::Model*>(matrixView->model());
+	_matrixView = matrixView;
+
+	// Connections from listView to matrixModel
 	connect(listView, &discoveredEntities::View::selectedControlledEntityChanged, matrixModel,
 		[this, matrixModel](la::avdecc::UniqueIdentifier const entityID)
 		{
@@ -52,4 +57,20 @@ ListViewSelectionToMatrixModelController::ListViewSelectionToMatrixModelControll
 			matrixModel->setHeaderData(_selectedIndex.row(), Qt::Vertical, true, connectionMatrix::Model::SelectedEntityRole);
 			matrixModel->setHeaderData(_selectedIndex.column(), Qt::Horizontal, true, connectionMatrix::Model::SelectedEntityRole);
 		});
+
+	// Connections from matrixView to listView
+	connect(matrixView, &connectionMatrix::View::selectEntityRequested, listView,
+		[this, listView](la::avdecc::UniqueIdentifier const entityID)
+		{
+			listView->selectControlledEntity(entityID);
+		});
+
+	// Notify the connectionMatrix View that we have a link to the discoveredEntities View
+	matrixView->entitiesListAttached(true);
+}
+
+ListViewMatrixViewController::~ListViewMatrixViewController() noexcept
+{
+	// Notify the connectionMatrix View that we removed the link with the discoveredEntities View
+	_matrixView->entitiesListAttached(false);
 }
diff --git a/src/listViewSelectionToMatrixModelController.hpp b/src/listViewMatrixViewController.hpp
similarity index 72%
rename from src/listViewSelectionToMatrixModelController.hpp
rename to src/listViewMatrixViewController.hpp
index 90c1c10d..ec512c60 100644
--- a/src/listViewSelectionToMatrixModelController.hpp
+++ b/src/listViewMatrixViewController.hpp
@@ -23,16 +23,20 @@
 #include <QModelIndex>
 
 #include "discoveredEntities/view.hpp"
-#include "connectionMatrix/model.hpp"
+#include "connectionMatrix/view.hpp"
 
-// Mini controller linking discoveredEntities::View selection to connectionMatrix::Model::SelectedEntityRole
-class ListViewSelectionToMatrixModelController final : public QObject
+// Mini controller linking discoveredEntities::View selection to connectionMatrix::View selection (and vice versa)
+class ListViewMatrixViewController final : public QObject
 {
 public:
 	// Constructor
-	ListViewSelectionToMatrixModelController(discoveredEntities::View* listView, connectionMatrix::Model* matrixModel, QObject* parent = nullptr);
+	ListViewMatrixViewController(discoveredEntities::View* listView, connectionMatrix::View* matrixView, QObject* parent = nullptr);
+
+	// Destructor
+	~ListViewMatrixViewController() noexcept;
 
 private:
 	// Private members
 	QModelIndex _selectedIndex{};
+	connectionMatrix::View* _matrixView{ nullptr };
 };
diff --git a/src/main.cpp b/src/main.cpp
index 81b64266..397a3797 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -17,10 +17,12 @@
 * along with Hive.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include "application.hpp"
 #include "mainWindow.hpp"
 #include "internals/config.hpp"
 #include "settingsManager/settings.hpp"
 #include "profiles/profileSelectionDialog.hpp"
+#include "processHelper/processHelper.hpp"
 
 #include <la/avdecc/utils.hpp>
 #ifdef USE_SPARKLE
@@ -28,7 +30,6 @@
 #endif // USE_SPARKLE
 #include <hive/modelsLibrary/controllerManager.hpp>
 
-#include <QApplication>
 #include <QFontDatabase>
 #include <QSharedMemory>
 #include <QMessageBox>
@@ -36,6 +37,7 @@
 #include <QSplashScreen>
 #include <QCommandLineParser>
 #include <QScreen>
+#include <QStringList>
 #include <QtGlobal>
 #if QT_VERSION < 0x050F00
 #	include <QDesktopWidget>
@@ -84,8 +86,23 @@ void setupBugReporter()
 void setupBugReporter() {}
 #endif
 
+struct InstanceInfo
+{
+	QSharedMemory shm{ "d2794ee0-ab5e-48a5-9189-78a9e2c40635" };
+	bool isAlreadyRunning{ false };
+	utils::ProcessHelper::ProcessID pid{ 0u };
+};
+
 int main(int argc, char* argv[])
 {
+#if defined(Q_OS_WIN32)
+	// Enable dark mode on windows
+	qputenv("QT_QPA_PLATFORM", "windows:darkmode=2"); // Not actually needed, since Qt 6.5 dark mode is enabled by default
+#endif // Q_OS_WIN32
+
+	// Set the "fusion" style
+	QApplication::setStyle("fusion"); // We need to set the fusion style as dark mode was removed from windowsvista default style in Qt 6.5
+
 	// Setup Bug Reporter
 	setupBugReporter();
 
@@ -105,7 +122,7 @@ int main(int argc, char* argv[])
 	QCoreApplication::setApplicationVersion(hive::internals::versionString);
 
 	// Create the Qt Application
-	QApplication app(argc, argv);
+	auto app = HiveApplication{ argc, argv };
 
 	// Runtime sanity check on Avdecc Library compilation options
 	{
@@ -125,25 +142,114 @@ int main(int argc, char* argv[])
 		return 0;
 	}
 
-#if 0
-	QSharedMemory lock("d2794ee0-ab5e-48a5-9189-78a9e2c40635");
-	if (!lock.create(512, QSharedMemory::ReadWrite))
+	// Check if we are already running
+	auto instanceInfo = InstanceInfo{};
+	if (!instanceInfo.shm.create(8, QSharedMemory::ReadWrite))
 	{
-#	pragma message("TODO: Read the SM and cast to a processID. Check if that processID is still active and if not, continue.")
-		QMessageBox::critical(nullptr, {}, "An instance of this application is already running.", QMessageBox::Ok);
-		return 1;
+		// If we failed to create the shared memory, check if it's because it already exists
+		if (instanceInfo.shm.error() == QSharedMemory::AlreadyExists)
+		{
+			// Attach to the shared memory
+			if (instanceInfo.shm.attach(QSharedMemory::ReadWrite))
+			{
+				// Make sure the other instance is still running by checking its process ID
+				{
+					// Read the process ID from the shared memory
+					instanceInfo.shm.lock();
+					instanceInfo.pid = *static_cast<utils::ProcessHelper::ProcessID const*>(instanceInfo.shm.constData());
+					instanceInfo.shm.unlock();
+				}
+				// Check if the process is still running
+				instanceInfo.isAlreadyRunning = utils::ProcessHelper::isProcessRunning(instanceInfo.pid);
+			}
+		}
+	}
+	// If not already running, write our process ID to the shared memory
+	if (!instanceInfo.isAlreadyRunning && instanceInfo.shm.isAttached())
+	{
+		instanceInfo.shm.lock();
+		*static_cast<utils::ProcessHelper::ProcessID*>(instanceInfo.shm.data()) = utils::ProcessHelper::getCurrentProcessID();
+		instanceInfo.shm.unlock();
 	}
-#endif
 
 	// Parse command line
 	auto parser = QCommandLineParser{};
+	auto const singleOption = QCommandLineOption{ { "s", "single" }, "Exist if another instance is already running" };
 	auto const settingsFileOption = QCommandLineOption{ "settings", "Use the specified Settings file (.ini)", "Hive Settings" };
+	auto const ansFilesOption = QCommandLineOption{ "ans", "Load the specified ATDECC Network State (.ans)", "Network State" };
+	auto const aveFilesOption = QCommandLineOption{ "ave", "Load the specified ATDECC Virtual Entity (.ave)", "Virtual Entity" };
+	parser.addOption(singleOption);
 	parser.addOption(settingsFileOption);
+	parser.addOption(ansFilesOption);
+	parser.addOption(aveFilesOption);
+	parser.addPositionalArgument("files", "Files to load (.ave, .ans, .json)", "[files...]");
 	parser.addHelpOption();
 	parser.addVersionOption();
 
 	parser.process(app);
 
+	// Get files to load
+	for (auto const& value : parser.values(ansFilesOption))
+	{
+		app.addFileToLoad(value);
+	}
+	for (auto const& value : parser.values(aveFilesOption))
+	{
+		app.addFileToLoad(value);
+	}
+	for (auto const& value : parser.positionalArguments())
+	{
+		app.addFileToLoad(value);
+	}
+
+#if defined(Q_OS_WIN32)
+	// On windows, if the application is already running, we want to forward the files to load to it, then exit
+	if (!app.getFilesToLoad().isEmpty() && instanceInfo.isAlreadyRunning)
+	{
+		// On windows, we send a custom message to the main window of the other instance
+		// First we need to get the main window handle of the other instance (using its process ID)
+		static auto mainWindowHandle = HWND{ 0u };
+		auto const enumWindowsProc = [](HWND hwnd, LPARAM lParam)
+		{
+			auto windowPid = DWORD{ 0u };
+			auto const otherPID = static_cast<decltype(windowPid)>(lParam);
+			GetWindowThreadProcessId(hwnd, &windowPid);
+			if (windowPid == otherPID)
+			{
+				mainWindowHandle = hwnd;
+				return FALSE;
+			}
+			return TRUE;
+		};
+		EnumWindows(enumWindowsProc, static_cast<LPARAM>(instanceInfo.pid));
+
+		if (mainWindowHandle)
+		{
+			// Process each file to load
+			for (auto const& f : app.getFilesToLoad())
+			{
+				auto const data = f.toUtf8();
+				auto const dataLength = data.size();
+
+				// Send a WM_COPYDATA message to the main window of the other instance
+				auto cds = COPYDATASTRUCT{};
+				cds.dwData = static_cast<decltype(cds.dwData)>(MainWindow::MessageType::LoadFileMessage);
+				cds.cbData = dataLength;
+				cds.lpData = const_cast<char*>(data.constData());
+				SendMessageA(mainWindowHandle, WM_COPYDATA, 0, reinterpret_cast<LPARAM>(&cds));
+			}
+			return 0;
+		}
+	}
+#endif // Q_OS_WIN32
+
+	// Check if another instance is already running and the single instance option was specified
+	if (instanceInfo.isAlreadyRunning && parser.isSet(singleOption))
+	{
+		QMessageBox::critical(nullptr, {}, "Another instance of Hive is already running.", QMessageBox::Ok);
+		return 0;
+	}
+
 	// Register settings (creating default value if none was saved before)
 	auto const settingsFileParsed = parser.value(settingsFileOption);
 	auto settingsFile = std::optional<QString>{};
@@ -252,7 +358,7 @@ int main(int argc, char* argv[])
 #endif // USE_SPARKLE
 
 	// Load main window (and all associated resources) while the splashscreen is displayed
-	auto window = MainWindow{ mustResetViewSettings };
+	auto window = MainWindow{ mustResetViewSettings, app.getFilesToLoad() };
 
 #if defined(Q_OS_MACOS)
 	// The native window has to be created before the first processEvents() for the initial position and size to be correctly set.
diff --git a/src/mainWindow.cpp b/src/mainWindow.cpp
index 021eef55..f5b75685 100644
--- a/src/mainWindow.cpp
+++ b/src/mainWindow.cpp
@@ -29,6 +29,7 @@
 #include <QSettings>
 #include <QLabel>
 #include <QStringView>
+#include <QGuiApplication>
 
 #ifdef DEBUG
 #	include <QFileInfo>
@@ -38,7 +39,6 @@
 #include "avdecc/helper.hpp"
 #include "avdecc/hiveLogItems.hpp"
 #include "avdecc/channelConnectionManager.hpp"
-#include "avdecc/controllerModel.hpp"
 #include "avdecc/mcDomainManager.hpp"
 #include "mediaClock/mediaClockManagementDialog.hpp"
 #include "newsFeed/newsFeed.hpp"
@@ -55,7 +55,7 @@
 #include "defaults.hpp"
 #include "windowsNpfHelper.hpp"
 #include "visibilitySettings.hpp"
-#include "listViewSelectionToMatrixModelController.hpp"
+#include "listViewMatrixViewController.hpp"
 
 #include <QtMate/widgets/comboBox.hpp>
 #include <QtMate/widgets/flatIconButton.hpp>
@@ -70,8 +70,7 @@
 #include <hive/modelsLibrary/controllerManager.hpp>
 #include <hive/modelsLibrary/networkInterfacesModel.hpp>
 #include <hive/widgetModelsLibrary/entityLogoCache.hpp>
-#include <hive/widgetModelsLibrary/errorItemDelegate.hpp>
-#include <hive/widgetModelsLibrary/imageItemDelegate.hpp>
+#include <hive/widgetModelsLibrary/networkInterfacesListItemDelegate.hpp>
 
 #include <mutex>
 #include <memory>
@@ -93,13 +92,14 @@ extern "C"
 
 Q_DECLARE_METATYPE(la::avdecc::protocol::ProtocolInterface::Type)
 
-class MainWindowImpl final : public QObject, public Ui::MainWindow, public settings::SettingsManager::Observer
+class MainWindowImpl final : public QObject, public Ui::MainWindow, public settings::SettingsManager::Observer, public QAbstractNativeEventFilter
 {
 	Q_OBJECT
 public:
-	MainWindowImpl(bool const mustResetViewSettings, ::MainWindow* parent)
+	MainWindowImpl(bool const mustResetViewSettings, QStringList const& filesToLoad, ::MainWindow* parent)
 		: _parent(parent)
 		, _mustResetViewSettings{ mustResetViewSettings }
+		, _filesToLoad{ filesToLoad }
 	{
 		// Setup entity model
 		setupEntityModel();
@@ -112,8 +112,21 @@ class MainWindowImpl final : public QObject, public Ui::MainWindow, public setti
 
 		// Setup the current profile
 		setupProfile();
+
+#if defined(Q_OS_WIN32)
+		qApp->installNativeEventFilter(this);
+#endif // Q_OS_WIN32
+#if defined(Q_OS_MACOS)
+		qApp->installEventFilter(this);
+#endif // Q_OS_MACOS
+
+		// Force creation of the MC Domain Manager here, since it was removed from the ControllerModel (it registers to the ControllerManager events so we need to create it before entities are discovered)
+		// (Will be completely removed in the future)
+		avdecc::mediaClock::MCDomainManager::getInstance();
 	}
 
+	void loadFile(QString const& fileName, bool const silent);
+
 	// Deleted compiler auto-generated methods
 	MainWindowImpl(MainWindowImpl const&) = delete;
 	MainWindowImpl(MainWindowImpl&&) = delete;
@@ -139,7 +152,8 @@ class MainWindowImpl final : public QObject, public Ui::MainWindow, public setti
 	void showChangeLog(QString const title, QString const versionString);
 	void showNewsFeed(QString const& news);
 	void updateStyleSheet(qtMate::material::color::Name const colorName, QString const& filename);
-
+	virtual bool nativeEventFilter(QByteArray const& eventType, void* message, qintptr*) override;
+	virtual bool eventFilter(QObject* watched, QEvent* event) override;
 	// settings::SettingsManager::Observer overrides
 	virtual void onSettingChanged(settings::SettingsManager::Setting const& name, QVariant const& value) noexcept override;
 
@@ -148,6 +162,7 @@ class MainWindowImpl final : public QObject, public Ui::MainWindow, public setti
 	qtMate::widgets::ComboBox _interfaceComboBox{ _parent };
 	ActiveNetworkInterfacesModel _activeNetworkInterfacesModel{ _parent };
 	QSortFilterProxyModel _networkInterfacesModelProxy{ _parent };
+	hive::widgetModelsLibrary::NetworkInterfacesListItemDelegate _networkInterfaceModelItemDelegate{ qtMate::material::color::Palette::name(qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>()->getValue(settings::General_ThemeColorIndex.name).toInt()), this };
 	qtMate::widgets::FlatIconButton _refreshControllerButton{ "Material Icons", "refresh", _parent };
 	qtMate::widgets::FlatIconButton _discoverButton{ "Hive", "radar", _parent };
 	qtMate::widgets::FlatIconButton _openMcmdDialogButton{ "Material Icons", "schedule", _parent };
@@ -160,9 +175,10 @@ class MainWindowImpl final : public QObject, public Ui::MainWindow, public setti
 	la::avdecc::entity::model::EntityTree _entityModel{};
 	SettingsSignaler _settingsSignaler{};
 	bool _mustResetViewSettings{ false };
+	QStringList _filesToLoad{};
 	bool _usingBetaAppcast{ false };
 	bool _usingBackupAppcast{ false };
-	std::unique_ptr<ListViewSelectionToMatrixModelController> _listViewSelectionToMatrixModelController{ nullptr }; // Remove smartpointer once in use in the upcoming layout classes
+	std::unique_ptr<ListViewMatrixViewController> _listViewMatrixViewController{ nullptr }; // Remove smartpointer once in use in the upcoming layout classes
 };
 
 void MainWindowImpl::setupAdvancedView(hive::VisibilityDefaults const& defaults)
@@ -174,11 +190,11 @@ void MainWindowImpl::setupAdvancedView(hive::VisibilityDefaults const& defaults)
 	createToolbars();
 
 	// Setup the ControllerView widget
-	discoveredEntitiesView->setupView(defaults);
+	discoveredEntitiesView->setupView(defaults, _mustResetViewSettings);
 
-	// Create ListViewSelectionToMatrixModelController
+	// Create ListViewMatrixViewController
 	// Initialization to be moved to NSDM when layout classes are introduced
-	_listViewSelectionToMatrixModelController = std::make_unique<ListViewSelectionToMatrixModelController>(discoveredEntitiesView->entitiesTableView(), static_cast<connectionMatrix::Model*>(routingTableView->model()), this);
+	_listViewMatrixViewController = std::make_unique<ListViewMatrixViewController>(discoveredEntitiesView->entitiesTableView(), routingTableView, this);
 
 	controllerToolBar->setVisible(defaults.mainWindow_ControllerToolbar_Visible);
 	utilitiesToolBar->setVisible(defaults.mainWindow_UtilitiesToolbar_Visible);
@@ -204,17 +220,17 @@ void MainWindowImpl::setupAdvancedView(hive::VisibilityDefaults const& defaults)
 
 void MainWindowImpl::setupMatrixProfile()
 {
-	setupAdvancedView(hive::VisibilityDefaults{ true, false, false, false, false, true, true, true, true, false, false, false, false, false, false, true, true });
+	setupAdvancedView(hive::VisibilityDefaults{ true, false, false, false, false, true, true, true, true, false, false, false, false, false, false, false, false, false, true, true, true });
 }
 
 void MainWindowImpl::setupStandardProfile()
 {
-	setupAdvancedView(hive::VisibilityDefaults{ true, true, true, false, false, true, true, true, true, false, false, false, false, false, false, true, true });
+	setupAdvancedView(hive::VisibilityDefaults{ true, true, true, false, false, true, true, true, true, false, false, true, false, false, false, false, false, true, false, true, true });
 }
 
 void MainWindowImpl::setupDeveloperProfile()
 {
-	setupAdvancedView(hive::VisibilityDefaults{});
+	setupAdvancedView(hive::VisibilityDefaults{ true, true, true, true, true, true, true, true, true, false });
 }
 
 void MainWindowImpl::setupProfile()
@@ -242,6 +258,175 @@ void MainWindowImpl::setupProfile()
 	}
 }
 
+void MainWindowImpl::loadFile(QString const& fileName, bool const silent)
+{
+	auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
+
+	auto const getErrorString = [](auto const error, auto const& message)
+	{
+		auto msg = QString{};
+		if (!!error)
+		{
+			switch (error)
+			{
+				case la::avdecc::jsonSerializer::DeserializationError::AccessDenied:
+					msg = "Access Denied";
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::FileReadError:
+					msg = "Error Reading File";
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::UnsupportedDumpVersion:
+					msg = "Unsupported Dump Version";
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::ParseError:
+					msg = QString("Parse Error: %1").arg(message.c_str());
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::MissingKey:
+					msg = QString("Missing Key: %1").arg(message.c_str());
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::InvalidKey:
+					msg = QString("Invalid Key: %1").arg(message.c_str());
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::InvalidValue:
+					msg = QString("Invalid Value: %1").arg(message.c_str());
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::OtherError:
+					msg = message.c_str();
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::DuplicateEntityID:
+					msg = QString("An Entity already exists with the same EntityID: %1").arg(message.c_str());
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::NotCompliant:
+					msg = message.c_str();
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::Incomplete:
+					msg = message.c_str();
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::NotSupported:
+					msg = "Virtual Entity Loading not supported by this version of the AVDECC library";
+					break;
+				case la::avdecc::jsonSerializer::DeserializationError::InternalError:
+					msg = QString("Internal Error: %1").arg(message.c_str());
+					break;
+				default:
+					AVDECC_ASSERT(false, "Unknown Error");
+					msg = "Unknown Error";
+					break;
+			}
+		}
+		return msg;
+	};
+
+	auto const loadEntity = [&manager, &getErrorString](auto const& filePath, auto const flags)
+	{
+		auto const [error, message] = manager.loadVirtualEntityFromJson(filePath, flags);
+		return std::make_tuple(error, getErrorString(error, message));
+	};
+
+	auto const loadNetworkState = [&manager, &getErrorString](auto const& filePath, auto const flags)
+	{
+		auto const [error, message] = manager.loadVirtualEntitiesFromJsonNetworkState(filePath, flags);
+		return std::make_tuple(error, getErrorString(error, message));
+	};
+
+	auto const fi = QFileInfo{ fileName };
+	auto const ext = fi.suffix();
+
+	// AVDECC Virtual Entity
+	if (ext == "ave")
+	{
+		auto flags = la::avdecc::entity::model::jsonSerializer::Flags{ la::avdecc::entity::model::jsonSerializer::Flag::ProcessADP, la::avdecc::entity::model::jsonSerializer::Flag::ProcessCompatibility, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDynamicModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessMilan, la::avdecc::entity::model::jsonSerializer::Flag::ProcessState, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStaticModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStatistics, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDiagnostics };
+		flags.set(la::avdecc::entity::model::jsonSerializer::Flag::BinaryFormat);
+		auto [error, message] = loadEntity(fileName, flags);
+		if (!!error)
+		{
+			if (error == la::avdecc::jsonSerializer::DeserializationError::NotCompliant)
+			{
+				auto choice = QMessageBox::StandardButton::Yes;
+				if (silent)
+				{
+					LOG_HIVE_WARN(QString("[%1] Entity model is not fully IEEE1722.1 compliant").arg(fileName));
+				}
+				else
+				{
+					choice = static_cast<QMessageBox::StandardButton>(QMessageBox::question(_parent, "", "Entity model is not fully IEEE1722.1 compliant.\n\nDo you want to import anyway?", QMessageBox::StandardButton::Yes, QMessageBox::StandardButton::No));
+				}
+				if (choice == QMessageBox::StandardButton::Yes)
+				{
+					flags.set(la::avdecc::entity::model::jsonSerializer::Flag::IgnoreAEMSanityChecks);
+					auto const result = loadEntity(fileName, flags);
+					error = std::get<0>(result);
+					message = std::get<1>(result);
+					// Fallthrough to warning message
+				}
+			}
+			if (!!error)
+			{
+				if (silent)
+				{
+					LOG_HIVE_WARN(QString("[%1] Error loading file: %2").arg(fileName).arg(message));
+				}
+				else
+				{
+					QMessageBox::warning(_parent, "Failed to load Entity", QString("Error loading JSON file '%1':\n%2").arg(fileName).arg(message));
+				}
+			}
+		}
+	}
+
+	// AVDECC Network State
+	else if (ext == "ans")
+	{
+		auto flags = la::avdecc::entity::model::jsonSerializer::Flags{ la::avdecc::entity::model::jsonSerializer::Flag::ProcessADP, la::avdecc::entity::model::jsonSerializer::Flag::ProcessCompatibility, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDynamicModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessMilan, la::avdecc::entity::model::jsonSerializer::Flag::ProcessState, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStaticModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStatistics, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDiagnostics };
+		flags.set(la::avdecc::entity::model::jsonSerializer::Flag::BinaryFormat);
+		auto [error, message] = loadNetworkState(fileName, flags);
+		if (!!error)
+		{
+			if (silent)
+			{
+				LOG_HIVE_WARN(QString("[%1] Error loading file: %2").arg(fileName).arg(message));
+			}
+			else
+			{
+				QMessageBox::warning(_parent, "Failed to load Network State", QString("Error loading JSON file '%1':\n%2").arg(fileName).arg(message));
+			}
+		}
+	}
+
+	// Any kind of file, we have to autodetect
+	else if (ext == "json")
+	{
+		auto flags = la::avdecc::entity::model::jsonSerializer::Flags{ la::avdecc::entity::model::jsonSerializer::Flag::ProcessADP, la::avdecc::entity::model::jsonSerializer::Flag::ProcessCompatibility, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDynamicModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessMilan, la::avdecc::entity::model::jsonSerializer::Flag::ProcessState, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStaticModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStatistics, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDiagnostics };
+		// Start with AVE file type
+		auto [error, message] = loadEntity(fileName, flags);
+		if (!!error)
+		{
+			if (error == la::avdecc::jsonSerializer::DeserializationError::NotCompliant)
+			{
+				auto choice = QMessageBox::StandardButton::Yes;
+				if (silent)
+				{
+					LOG_HIVE_WARN(QString("[%1] Entity model is not fully IEEE1722.1 compliant").arg(fileName));
+				}
+				else
+				{
+					choice = static_cast<QMessageBox::StandardButton>(QMessageBox::question(_parent, "", "Entity model is not fully IEEE1722.1 compliant.\n\nDo you want to import anyway?", QMessageBox::StandardButton::Yes, QMessageBox::StandardButton::No));
+				}
+				if (choice == QMessageBox::StandardButton::Yes)
+				{
+					flags.set(la::avdecc::entity::model::jsonSerializer::Flag::IgnoreAEMSanityChecks);
+					loadEntity(fileName, flags);
+				}
+			}
+			else
+			{
+				// Then try ANS file type
+				loadNetworkState(fileName, flags);
+			}
+		}
+	}
+}
+
 void MainWindowImpl::currentControllerChanged()
 {
 	auto* const settings = qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>();
@@ -290,6 +475,14 @@ void MainWindowImpl::currentControllerChanged()
 		{
 			manager.enableEntityAdvertising(*_advertisingDuration);
 		}
+
+		// Load virtual entities
+		for (auto const& f : _filesToLoad)
+		{
+			loadFile(f, true);
+		}
+		// Clear the list
+		_filesToLoad.clear();
 	}
 	catch (la::avdecc::controller::Controller::Exception const& e)
 	{
@@ -355,10 +548,11 @@ void MainWindowImpl::createToolbars()
 		_interfaceComboBox.setMinimumWidth(100);
 		_interfaceComboBox.setModel(&_activeNetworkInterfacesModel);
 
-		// The combobox takes ownership of the item delegate
-		auto* interfaceComboBoxItemDelegate = new hive::widgetModelsLibrary::ErrorItemDelegate{ true, qtMate::material::color::Palette::name(settings->getValue(settings::General_ThemeColorIndex.name).toInt()) };
-		_interfaceComboBox.setItemDelegate(interfaceComboBoxItemDelegate);
-		connect(&_settingsSignaler, &SettingsSignaler::themeColorNameChanged, interfaceComboBoxItemDelegate, &hive::widgetModelsLibrary::ErrorItemDelegate::setThemeColorName);
+		// Set delegate for the entire table
+		_interfaceComboBox.setItemDelegate(&_networkInterfaceModelItemDelegate);
+
+		// Connect the item delegates with theme color changes
+		connect(&_settingsSignaler, &SettingsSignaler::themeColorNameChanged, &_networkInterfaceModelItemDelegate, &hive::widgetModelsLibrary::NetworkInterfacesListItemDelegate::setThemeColorName);
 
 		auto* controllerEntityIDLabel = new QLabel("Controller ID: ");
 		controllerEntityIDLabel->setMinimumWidth(50);
@@ -669,7 +863,14 @@ void MainWindowImpl::connectSignals()
 				}
 				else
 				{
-					QMessageBox::warning(_parent, "", QString("Export failed:\n%1").arg(message.c_str()));
+					if (error == la::avdecc::jsonSerializer::SerializationError::Incomplete)
+					{
+						QMessageBox::warning(_parent, "", QString("Export partially completed (some entities are missing):\n%1").arg(message.c_str()));
+					}
+					else
+					{
+						QMessageBox::warning(_parent, "", QString("Export failed:\n%1").arg(message.c_str()));
+					}
 				}
 			}
 		});
@@ -834,6 +1035,16 @@ void MainWindowImpl::connectSignals()
 				});
 		});
 #endif // USE_SPARKLE
+
+	// Color Scheme changed
+	connect(QGuiApplication::styleHints(), &QStyleHints::colorSchemeChanged, this,
+		[this](Qt::ColorScheme scheme)
+		{
+			auto const* const settings = qApp->property(settings::SettingsManager::PropertyName).value<settings::SettingsManager*>();
+			auto const themeColorIndex = settings->getValue(settings::General_ThemeColorIndex.name).toInt();
+			auto const colorName = qtMate::material::color::Palette::name(themeColorIndex);
+			updateStyleSheet(colorName, ":/style.qss");
+		});
 }
 
 void MainWindowImpl::showChangeLog(QString const title, QString const versionString)
@@ -1059,150 +1270,72 @@ void MainWindow::dragEnterEvent(QDragEnterEvent* event)
 
 void MainWindow::dropEvent(QDropEvent* event)
 {
-	auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
-
-	auto const getErrorString = [](auto const error, auto const& message)
+	for (auto const& u : event->mimeData()->urls())
 	{
-		auto msg = QString{};
-		if (!!error)
-		{
-			switch (error)
-			{
-				case la::avdecc::jsonSerializer::DeserializationError::AccessDenied:
-					msg = "Access Denied";
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::FileReadError:
-					msg = "Error Reading File";
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::UnsupportedDumpVersion:
-					msg = "Unsupported Dump Version";
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::ParseError:
-					msg = QString("Parse Error: %1").arg(message.c_str());
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::MissingKey:
-					msg = QString("Missing Key: %1").arg(message.c_str());
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::InvalidKey:
-					msg = QString("Invalid Key: %1").arg(message.c_str());
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::InvalidValue:
-					msg = QString("Invalid Value: %1").arg(message.c_str());
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::OtherError:
-					msg = message.c_str();
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::DuplicateEntityID:
-					msg = QString("An Entity already exists with the same EntityID: %1").arg(message.c_str());
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::NotCompliant:
-					msg = message.c_str();
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::Incomplete:
-					msg = message.c_str();
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::NotSupported:
-					msg = "Virtual Entity Loading not supported by this version of the AVDECC library";
-					break;
-				case la::avdecc::jsonSerializer::DeserializationError::InternalError:
-					msg = QString("Internal Error: %1").arg(message.c_str());
-					break;
-				default:
-					AVDECC_ASSERT(false, "Unknown Error");
-					msg = "Unknown Error";
-					break;
-			}
-		}
-		return msg;
-	};
+		auto const f = u.toLocalFile();
+		_pImpl->loadFile(f, false);
+	}
+}
 
-	auto const loadEntity = [&manager, &getErrorString](auto const& filePath, auto const flags)
-	{
-		auto const [error, message] = manager.loadVirtualEntityFromJson(filePath, flags);
-		return std::make_tuple(error, getErrorString(error, message));
-	};
+void MainWindowImpl::updateStyleSheet(qtMate::material::color::Name const colorName, QString const& filename)
+{
+	auto const themeBackgroundColor = qtMate::material::color::value(colorName);
+	auto const themeForegroundTextColor = qtMate::material::color::foregroundValue(colorName);
+	auto const connectionMatrixHighlightColor = qtMate::material::color::value(colorName, qtMate::material::color::isDarkColorScheme() ? qtMate::material::color::Shade::Shade900 : qtMate::material::color::Shade::Shade100);
+	auto const flatButtonColor = qtMate::material::color::value(qtMate::material::color::Name::Gray, qtMate::material::color::isDarkColorScheme() ? qtMate::material::color::Shade::Shade300 : qtMate::material::color::Shade::Shade800);
+	auto const complementaryColor = qtMate::material::color::complementaryValue(colorName);
+	// TODO: Add error color, selected-error color, success color, selected-success color (ie. green)
+	// We need those colors for ListenerStreamConnectionWidget
 
-	auto const loadNetworkState = [&manager, &getErrorString](auto const& filePath, auto const flags)
+	// Load and apply the stylesheet
+	auto styleFile = QFile{ filename };
+	if (styleFile.open(QFile::ReadOnly))
 	{
-		auto const [error, message] = manager.loadVirtualEntitiesFromJsonNetworkState(filePath, flags);
-		return std::make_tuple(error, getErrorString(error, message));
-	};
+		auto const styleSheet = QString{ styleFile.readAll() }.arg(themeBackgroundColor.name()).arg(themeForegroundTextColor.name()).arg(connectionMatrixHighlightColor.name()).arg(flatButtonColor.name()).arg(complementaryColor.name());
 
-	for (auto const& u : event->mimeData()->urls())
+		qApp->setStyleSheet(styleSheet);
+	}
+}
+
+bool MainWindowImpl::nativeEventFilter(QByteArray const& eventType, void* message, qintptr*)
+{
+#if defined(Q_OS_WIN32)
+	if (eventType == "windows_generic_MSG")
 	{
-		auto const f = u.toLocalFile();
-		auto const fi = QFileInfo{ f };
-		auto const ext = fi.suffix();
+		auto const* const msg = static_cast<MSG const*>(message);
 
-		// AVDECC Virtual Entity
-		if (ext == "ave")
+		// Check if we received a WM_COPYDATA
+		if (msg->message == WM_COPYDATA)
 		{
-			auto flags = la::avdecc::entity::model::jsonSerializer::Flags{ la::avdecc::entity::model::jsonSerializer::Flag::ProcessADP, la::avdecc::entity::model::jsonSerializer::Flag::ProcessCompatibility, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDynamicModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessMilan, la::avdecc::entity::model::jsonSerializer::Flag::ProcessState, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStaticModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStatistics, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDiagnostics };
-			flags.set(la::avdecc::entity::model::jsonSerializer::Flag::BinaryFormat);
-			auto [error, message] = loadEntity(f, flags);
-			if (!!error)
+			auto const cds = *reinterpret_cast<COPYDATASTRUCT const*>(msg->lParam);
+			switch (static_cast<::MainWindow::MessageType>(cds.dwData))
 			{
-				if (error == la::avdecc::jsonSerializer::DeserializationError::NotCompliant)
-				{
-					auto const choice = QMessageBox::question(this, "", "Entity model is not fully IEEE1722.1 compliant.\n\nDo you want to import anyway?", QMessageBox::StandardButton::Yes, QMessageBox::StandardButton::No);
-					if (choice == QMessageBox::StandardButton::Yes)
-					{
-						flags.set(la::avdecc::entity::model::jsonSerializer::Flag::IgnoreAEMSanityChecks);
-						auto const result = loadEntity(f, flags);
-						error = std::get<0>(result);
-						message = std::get<1>(result);
-						// Fallthrough to warning message
-					}
-				}
-				if (!!error)
+				case ::MainWindow::MessageType::LoadFileMessage:
 				{
-					QMessageBox::warning(this, "Failed to load Entity", QString("Error loading JSON file '%1':\n%2").arg(f).arg(message));
+					auto const filename = QString::fromUtf8(static_cast<char const*>(cds.lpData), static_cast<int>(cds.cbData));
+					loadFile(filename, false);
+					SetForegroundWindow(msg->hwnd);
+					break;
 				}
+				default:
+					break;
 			}
-		}
-
-		// AVDECC Network State
-		else if (ext == "ans")
-		{
-			auto flags = la::avdecc::entity::model::jsonSerializer::Flags{ la::avdecc::entity::model::jsonSerializer::Flag::ProcessADP, la::avdecc::entity::model::jsonSerializer::Flag::ProcessCompatibility, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDynamicModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessMilan, la::avdecc::entity::model::jsonSerializer::Flag::ProcessState, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStaticModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStatistics, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDiagnostics };
-			flags.set(la::avdecc::entity::model::jsonSerializer::Flag::BinaryFormat);
-			auto [error, message] = loadNetworkState(f, flags);
-			if (!!error)
-			{
-				QMessageBox::warning(this, "Failed to load Network State", QString("Error loading JSON file '%1':\n%2").arg(f).arg(message));
-			}
-		}
-
-		// Any kind of file, we have to autodetect
-		else if (ext == "json")
-		{
-			auto flags = la::avdecc::entity::model::jsonSerializer::Flags{ la::avdecc::entity::model::jsonSerializer::Flag::ProcessADP, la::avdecc::entity::model::jsonSerializer::Flag::ProcessCompatibility, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDynamicModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessMilan, la::avdecc::entity::model::jsonSerializer::Flag::ProcessState, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStaticModel, la::avdecc::entity::model::jsonSerializer::Flag::ProcessStatistics, la::avdecc::entity::model::jsonSerializer::Flag::ProcessDiagnostics };
-			flags.set(la::avdecc::entity::model::jsonSerializer::Flag::IgnoreAEMSanityChecks);
-			// Start with AVE file type
-			auto [error, message] = loadEntity(f, flags);
-			if (!!error)
-			{
-				// Then try ANS file type
-				loadNetworkState(f, flags);
-			}
+			return true;
 		}
 	}
+#endif // Q_OS_WIN32
+	return false;
 }
 
-void MainWindowImpl::updateStyleSheet(qtMate::material::color::Name const colorName, QString const& filename)
+bool MainWindowImpl::eventFilter(QObject* watched, QEvent* event)
 {
-	auto const baseBackgroundColor = qtMate::material::color::value(colorName);
-	auto const baseForegroundColor = QColor{ qtMate::material::color::luminance(colorName) == qtMate::material::color::Luminance::Dark ? Qt::white : Qt::black };
-	auto const connectionMatrixBackgroundColor = qtMate::material::color::value(colorName, qtMate::material::color::Shade::Shade100);
-
-	// Load and apply the stylesheet
-	auto styleFile = QFile{ filename };
-	if (styleFile.open(QFile::ReadOnly))
+	if (event->type() == QEvent::FileOpen)
 	{
-		auto const styleSheet = QString{ styleFile.readAll() }.arg(baseBackgroundColor.name()).arg(baseForegroundColor.name()).arg(connectionMatrixBackgroundColor.name());
-
-		qApp->setStyleSheet(styleSheet);
+		auto const* const fileEvent = static_cast<QFileOpenEvent const*>(event);
+		loadFile(fileEvent->file(), false);
+		return true;
 	}
+	return false;
 }
 
 void MainWindowImpl::onSettingChanged(settings::SettingsManager::Setting const& name, QVariant const& value) noexcept
@@ -1290,9 +1423,9 @@ void MainWindowImpl::onSettingChanged(settings::SettingsManager::Setting const&
 #endif // USE_SPARKLE
 }
 
-MainWindow::MainWindow(bool const mustResetViewSettings, QWidget* parent)
+MainWindow::MainWindow(bool const mustResetViewSettings, QStringList const& filesToLoad, QWidget* parent)
 	: QMainWindow(parent)
-	, _pImpl(new MainWindowImpl(mustResetViewSettings, this))
+	, _pImpl(new MainWindowImpl(mustResetViewSettings, filesToLoad, this))
 {
 	// Set title
 	setWindowTitle(hive::internals::applicationLongName + " - Version " + QCoreApplication::applicationVersion());
diff --git a/src/mainWindow.hpp b/src/mainWindow.hpp
index f8eb77fd..f4a6d277 100644
--- a/src/mainWindow.hpp
+++ b/src/mainWindow.hpp
@@ -20,6 +20,7 @@
 #pragma once
 
 #include <QMainWindow>
+#include <QStringList>
 
 class DynamicHeaderView;
 
@@ -28,8 +29,16 @@ class MainWindow : public QMainWindow
 {
 	Q_OBJECT
 public:
+	static constexpr auto FileToLoadNamedMessage = "HiveMessage-FileToLoad";
+
+	enum class MessageType : std::uint8_t
+	{
+		None = 0,
+		LoadFileMessage = 1,
+	};
+
 	// Constructor
-	MainWindow(bool const mustResetViewSettings, QWidget* parent = nullptr);
+	MainWindow(bool const mustResetViewSettings, QStringList const& filesToLoad, QWidget* parent = nullptr);
 	virtual ~MainWindow() noexcept;
 
 	// Public methods
@@ -48,6 +57,8 @@ class MainWindow : public QMainWindow
 	virtual void dragEnterEvent(QDragEnterEvent* event) override;
 	virtual void dropEvent(QDropEvent* event) override;
 
+	void loadFile(QString const& fileName, bool const silent);
+
 	// Private variables
 	MainWindowImpl* _pImpl{ nullptr };
 	bool _isReady{ false };
diff --git a/src/mappingMatrix.cpp b/src/mappingMatrix.cpp
new file mode 100644
index 00000000..306e46ee
--- /dev/null
+++ b/src/mappingMatrix.cpp
@@ -0,0 +1,264 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "mappingMatrix.hpp"
+
+#include <QtMate/flow/flowScene.hpp>
+#include <QtMate/flow/flowSceneDelegate.hpp>
+#include <QtMate/flow/flowView.hpp>
+#include <QtMate/flow/flowNode.hpp>
+#include <QtMate/flow/flowInput.hpp>
+#include <QtMate/flow/flowOutput.hpp>
+
+#include <QPushButton>
+#include <QDialog>
+#include <QGridLayout>
+
+#include <utility>
+#include <vector>
+#include <string>
+
+namespace mappingMatrix
+{
+class MappingMatrix : public QWidget
+{
+public:
+	enum SocketType
+	{
+		Input,
+		Output,
+	};
+
+	class Delegate : public qtMate::flow::FlowSceneDelegate
+	{
+	public:
+		using FlowSceneDelegate::FlowSceneDelegate;
+
+		virtual bool canConnect(qtMate::flow::FlowOutput* output, qtMate::flow::FlowInput* input) const override
+		{
+			return true;
+		}
+
+		virtual QColor socketTypeColor(qtMate::flow::FlowSocketType type) const
+		{
+			return 0x2196F3;
+		}
+	};
+
+
+	MappingMatrix(Outputs const& outputs, Inputs const& inputs, Connections const& connections, QWidget* parent = nullptr)
+		: QWidget{ parent }
+	{
+		auto* delegate = new Delegate{ this };
+		auto* scene = new qtMate::flow::FlowScene{ delegate, this };
+		auto* view = new qtMate::flow::FlowView{ scene, this };
+		view->setDragMode(QGraphicsView::ScrollHandDrag);
+
+		auto* layout = new QHBoxLayout{ this };
+		layout->setContentsMargins(0, 0, 0, 0);
+		layout->addWidget(view);
+
+		// Get notified by the scene when connections are created/destroyed
+		connect(scene, &qtMate::flow::FlowScene::connectionCreated, this,
+			[&](auto const& descriptor)
+			{
+				_connections.insert(descriptor);
+			});
+
+		connect(scene, &qtMate::flow::FlowScene::connectionDestroyed, this,
+			[&](auto const& descriptor)
+			{
+				_connections.remove(descriptor);
+			});
+
+
+		auto const createNodesAndConnections = [&]()
+		{
+			// CAUTION: as the spec tells that outputs and inputs nodes are identified by their index in their own list,
+			// which is not compatible with qtMate::flow API which requires a unique identifier for each node,
+			// we must generate this unique identifier ourselves and also keep the offset to the first input node
+			// in order to be able to translate connections back and forth.
+			auto id = 0;
+			_offset = static_cast<decltype(_offset)>(outputs.size());
+
+			// Create output nodes
+			_outputNodes.reserve(outputs.size());
+			for (auto const& output : outputs)
+			{
+				auto descriptor = qtMate::flow::FlowNodeDescriptor{};
+				descriptor.name = QString::fromStdString(output.name);
+				for (auto const& socket : output.sockets)
+				{
+					descriptor.outputs.push_back({ QString::fromStdString(socket), SocketType::Output });
+				}
+
+				auto* node = scene->createNode(id++, descriptor);
+				node->setFlag(QGraphicsItem::ItemIsMovable, false);
+				_outputNodes.emplaceBack(node);
+			}
+
+			// Create input nodes
+			for (auto const& input : inputs)
+			{
+				auto descriptor = qtMate::flow::FlowNodeDescriptor{};
+				descriptor.name = QString::fromStdString(input.name);
+				for (auto const& socket : input.sockets)
+				{
+					descriptor.inputs.push_back({ QString::fromStdString(socket), SocketType::Input });
+				}
+
+				auto* node = scene->createNode(id++, descriptor);
+				node->setFlag(QGraphicsItem::ItemIsMovable, false);
+				_inputNodes.emplaceBack(node);
+			}
+
+			// Create connections
+			for (auto const& connection : connections)
+			{
+				scene->createConnection(convert(connection));
+			}
+		};
+
+		auto const layoutNodes = [&]()
+		{
+			auto const paddingX{ 150.f };
+			auto const paddingY{ 5.f };
+
+			auto outputNodeX{ 0.f };
+			auto outputNodeY{ 0.f };
+
+			auto inputNodeX{ 0.f };
+			auto inputNodeY{ 0.f };
+
+			auto animateTo = [&](qtMate::flow::FlowNode* node, float x, float y)
+			{
+				if (!_firstLayoutExecuted)
+				{
+					node->setPos(x, y);
+					return;
+				}
+
+				auto animation = new QVariantAnimation{ this };
+				animation->setDuration(400);
+				animation->setEasingCurve(QEasingCurve::Type::OutQuart);
+				animation->setStartValue(node->pos());
+				animation->setEndValue(QPointF{ x, y });
+
+				connect(animation, &QVariantAnimation::valueChanged, this,
+					[node, uid = node](QVariant const& value)
+					{
+						node->setPos(value.toPointF());
+					});
+
+				animation->start(QAbstractAnimation::DeletionPolicy::DeleteWhenStopped);
+			};
+
+
+			for (auto* node : _outputNodes)
+			{
+				animateTo(node, outputNodeX, outputNodeY);
+
+				auto const boundingRect = node->fixedBoundingRect();
+				outputNodeY += boundingRect.height() + paddingY;
+				inputNodeX = std::max(inputNodeX, static_cast<float>(boundingRect.width()) + paddingX);
+			}
+
+			for (auto* node : _inputNodes)
+			{
+				animateTo(node, inputNodeX, inputNodeY);
+
+				auto const boundingRect = node->fixedBoundingRect();
+				inputNodeY += boundingRect.height() + paddingY;
+			}
+		};
+
+		connect(scene, &qtMate::flow::FlowScene::layoutRequested, this, layoutNodes);
+
+		createNodesAndConnections();
+
+		_firstLayoutExecuted = false;
+		layoutNodes();
+		_firstLayoutExecuted = true;
+	}
+
+
+	Connections connections() const
+	{
+		auto result = Connections{};
+		for (auto const& connection : _connections)
+		{
+			result.emplace_back(convert(connection));
+		}
+		return result;
+	}
+
+	// Convert connection from flow to mapping
+	Connection convert(qtMate::flow::FlowConnectionDescriptor const& descriptor) const
+	{
+		auto const source = SlotID{ static_cast<SlotID::first_type>(descriptor.first.first), static_cast<SlotID::second_type>(descriptor.first.second) };
+		auto const sink = SlotID{ static_cast<SlotID::first_type>(descriptor.second.first - _offset), static_cast<SlotID::first_type>(descriptor.second.second) };
+		return Connection{ source, sink };
+	}
+
+	// Convert connection from mapping to flow
+	qtMate::flow::FlowConnectionDescriptor convert(Connection const& connection) const
+	{
+		auto const source = qtMate::flow::FlowSocketSlot{ static_cast<qtMate::flow::FlowSocketSlot::first_type>(connection.first.first), static_cast<qtMate::flow::FlowSocketSlot::second_type>(connection.first.second) };
+		auto const sink = qtMate::flow::FlowSocketSlot{ static_cast<qtMate::flow::FlowSocketSlot::first_type>(connection.second.first + _offset), static_cast<qtMate::flow::FlowSocketSlot::second_type>(connection.second.second) };
+		return qtMate::flow::FlowConnectionDescriptor{ source, sink };
+	}
+
+private:
+	int _offset{}; // we need an offset to identify output nodes
+	qtMate::flow::FlowConnectionDescriptors _connections{};
+
+	QVector<qtMate::flow::FlowNode*> _outputNodes{};
+	QVector<qtMate::flow::FlowNode*> _inputNodes{};
+
+	bool _firstLayoutExecuted{ false };
+};
+
+MappingMatrixDialog::MappingMatrixDialog(QString const& title, Outputs const& outputs, Inputs const& inputs, Connections const& connections, QWidget* parent)
+#ifdef Q_OS_WIN32
+	: QDialog(parent, Qt::Dialog | Qt::WindowSystemMenuHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint) // Because Qt::Tool is ugly on windows and '?' needs to be hidden (currently not supported)
+#else
+	: QDialog(parent, Qt::Tool | Qt::WindowSystemMenuHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint)
+#endif
+	, _matrix{ new MappingMatrix{ outputs, inputs, connections, this } }
+{
+	setWindowTitle(title);
+
+	auto* apply = new QPushButton{ "Apply", this };
+	auto* cancel = new QPushButton{ "Cancel", this };
+
+	auto* layout = new QGridLayout{ this };
+	layout->addWidget(_matrix, 0, 0, 1, 2);
+	layout->addWidget(apply, 1, 0);
+	layout->addWidget(cancel, 1, 1);
+
+	connect(apply, &QPushButton::clicked, this, &QDialog::accept);
+	connect(cancel, &QPushButton::clicked, this, &QDialog::reject);
+}
+
+Connections MappingMatrixDialog::connections() const
+{
+	return _matrix->connections();
+}
+
+} // namespace mappingMatrix
diff --git a/src/mappingMatrix.hpp b/src/mappingMatrix.hpp
index 91fba6a5..7e25756f 100644
--- a/src/mappingMatrix.hpp
+++ b/src/mappingMatrix.hpp
@@ -19,18 +19,13 @@
 
 #pragma once
 
-#include <QtMate/graph/view.hpp>
-#include <QtMate/graph/node.hpp>
-#include <QtMate/graph/inputSocket.hpp>
-#include <QtMate/graph/outputSocket.hpp>
-
+#include <QWidget>
 #include <QPushButton>
 #include <QDialog>
-#include <QGridLayout>
 
-#include <utility>
 #include <vector>
 #include <string>
+#include <any>
 
 namespace mappingMatrix
 {
@@ -38,12 +33,13 @@ struct Node
 {
 	std::string name{};
 	std::vector<std::string> sockets{};
+	std::any userData{};
 };
 
 using Nodes = std::vector<Node>;
 using Outputs = Nodes;
 using Inputs = Nodes;
-using SlotID = std::pair<size_t, size_t>; // Pair of "Node Index", "Socket Index"
+using SlotID = std::pair<quint32, quint32>; // Pair of "Node Index", "Socket Index"
 using Connection = std::pair<SlotID, SlotID>; // Pair of "Output SlotID", "Input SlotID"
 using Connections = std::vector<Connection>;
 
@@ -69,145 +65,26 @@ using Connections = std::vector<Connection>;
 	- <0,0> -> <0,0>
 	- <0,0> -> <0,1>
 	- <1,1> -> <1,0>
+ 
+ 
+ CAUTION: Input and Output nodes can share the same ID as it is the index of the node in the provided list
 
 */
 
-class MappingMatrix : public qtMate::graph::GraphicsView
-{
-public:
-	MappingMatrix(Outputs const& outputs, Inputs const& inputs, Connections const& connections, QWidget* parent = nullptr)
-		: qtMate::graph::GraphicsView(parent)
-		, _connections{ connections }
-	{
-		setScene(&_scene);
-
-		auto const paddingX{ 150.f };
-		auto const paddingY{ 5.f };
-
-		auto outputNodeX{ 0.f };
-		auto outputNodeY{ 0.f };
-
-		auto inputNodeX{ 0.f };
-		auto inputNodeY{ 0.f };
-
-		for (auto const& item : outputs)
-		{
-			auto* node = new qtMate::graph::NodeItem{ static_cast<int>(_outputs.size()), QString::fromStdString(item.name) };
-			for (auto const& socket : item.sockets)
-			{
-				node->addOutput(QString::fromStdString(socket));
-			}
-
-			_outputs.emplace_back(node);
-			_scene.addItem(node);
-
-			node->setPos(outputNodeX, outputNodeY);
-			outputNodeY += node->boundingRect().height() + paddingY;
-
-			inputNodeX = std::max(inputNodeX, static_cast<float>(node->boundingRect().width()) + paddingX);
-		}
-
-		for (auto const& item : inputs)
-		{
-			auto* node = new qtMate::graph::NodeItem{ static_cast<int>(_inputs.size()), QString::fromStdString(item.name) };
-			for (auto const& socket : item.sockets)
-			{
-				node->addInput(QString::fromStdString(socket));
-			}
-
-			_inputs.emplace_back(node);
-			_scene.addItem(node);
-
-			node->setPos(inputNodeX, inputNodeY);
-			inputNodeY += node->boundingRect().height() + paddingY;
-		}
-
-		for (auto const& connection : _connections)
-		{
-			auto* item = new qtMate::graph::ConnectionItem;
-
-			auto const& outputSlot{ connection.first };
-			auto const& inputSlot{ connection.second };
-
-			try
-			{
-				item->connectOutput(_outputs.at(outputSlot.first)->outputAt(static_cast<int>(outputSlot.second)));
-				item->connectInput(_inputs.at(inputSlot.first)->inputAt(static_cast<int>(inputSlot.second)));
-
-				_scene.addItem(item);
-			}
-			catch (...)
-			{
-				// FIXME
-				delete item;
-			}
-		}
-
-		connect(this, &qtMate::graph::GraphicsView::connectionCreated, this,
-			[this](qtMate::graph::ConnectionItem* connection)
-			{
-				_connections.emplace_back(std::make_pair(connection->output()->nodeId(), connection->output()->index()), std::make_pair(connection->input()->nodeId(), connection->input()->index()));
-			});
-
-		connect(this, &qtMate::graph::GraphicsView::connectionDeleted, this,
-			[this](qtMate::graph::ConnectionItem* connection)
-			{
-				_connections.erase(std::remove_if(_connections.begin(), _connections.end(),
-														 [connection](Connection const& item)
-														 {
-															 return (static_cast<int>(item.first.first) == connection->output()->nodeId() && static_cast<int>(item.first.second) == connection->output()->index()) && (static_cast<int>(item.second.first) == connection->input()->nodeId() && static_cast<int>(item.second.second) == connection->input()->index());
-														 }),
-					_connections.end());
-			});
-
-		auto const scenePadding{ 80 };
-		_scene.setSceneRect(_scene.sceneRect().adjusted(-scenePadding, -scenePadding, scenePadding, scenePadding));
-	}
-
-	Connections const& connections() const
-	{
-		return _connections;
-	}
-
-private:
-	QGraphicsScene _scene{ this };
-	std::vector<qtMate::graph::NodeItem*> _outputs;
-	std::vector<qtMate::graph::NodeItem*> _inputs;
-	Connections _connections;
-};
+class MappingMatrix;
 
 class MappingMatrixDialog : public QDialog
 {
 public:
-	MappingMatrixDialog(QString const& title, Outputs const& outputs, Inputs const& inputs, Connections const& connections, QWidget* parent = nullptr)
-#ifdef Q_OS_WIN32
-		: QDialog(parent, Qt::Dialog | Qt::WindowSystemMenuHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint) // Because Qt::Tool is ugly on windows and '?' needs to be hidden (currently not supported)
-#else
-		: QDialog(parent, Qt::Tool | Qt::WindowSystemMenuHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint)
-#endif
-		, _mappingMatrix{ outputs, inputs, connections, this }
-	{
-		setWindowTitle(title);
-
-		auto* layout = new QGridLayout{ this };
-
-		layout->addWidget(&_mappingMatrix, 0, 0, 1, 2);
-		layout->addWidget(&_applyButton, 1, 0);
-		layout->addWidget(&_cancelButton, 1, 1);
-
-		connect(&_applyButton, &QPushButton::clicked, this, &QDialog::accept);
-		connect(&_cancelButton, &QPushButton::clicked, this, &QDialog::reject);
-	}
-
-	Connections const& connections() const
-	{
-		return _mappingMatrix.connections();
-	}
+	// Construct the MappingMatrix editor dialog
+	MappingMatrixDialog(QString const& title, Outputs const& outputs, Inputs const& inputs, Connections const& connections, QWidget* parent = nullptr);
+
+	// Return the list of active connections,
+	// Note: it is ment to be retrived after the dialog has been closed
+	Connections connections() const;
 
 private:
-	MappingMatrix _mappingMatrix;
-	QPushButton _applyButton{ "Apply", this };
-	QPushButton _cancelButton{ "Cancel", this };
+	MappingMatrix* _matrix{};
 };
 
 } // namespace mappingMatrix
diff --git a/src/mediaClock/domainTreeItem.cpp b/src/mediaClock/domainTreeItem.cpp
index b2a6caea..83bc51f9 100644
--- a/src/mediaClock/domainTreeItem.cpp
+++ b/src/mediaClock/domainTreeItem.cpp
@@ -76,13 +76,10 @@ QList<QPair<std::optional<la::avdecc::entity::model::SamplingRate>, QString>> Do
 			auto configurationIndex = controlledEntity->getCurrentConfigurationNode().descriptorIndex;
 			try
 			{
-				auto* audioUnitStaticModel = controlledEntity->getAudioUnitNode(configurationIndex, 0).staticModel;
-				if (audioUnitStaticModel)
+				auto& audioUnitStaticModel = controlledEntity->getAudioUnitNode(configurationIndex, 0).staticModel;
+				for (const auto& sampleRate : audioUnitStaticModel.samplingRates)
 				{
-					for (const auto& sampleRate : audioUnitStaticModel->samplingRates)
-					{
-						domainSampleRates << qMakePair(sampleRate, QString::number(sampleRate / 1000) + " kHz");
-					}
+					domainSampleRates << qMakePair(sampleRate, QString::number(sampleRate / 1000) + " kHz");
 				}
 			}
 			catch (la::avdecc::controller::ControlledEntity::Exception const& ex)
diff --git a/src/mediaClock/entityTreeItem.cpp b/src/mediaClock/entityTreeItem.cpp
index 29c3791b..12bf3d52 100644
--- a/src/mediaClock/entityTreeItem.cpp
+++ b/src/mediaClock/entityTreeItem.cpp
@@ -65,12 +65,9 @@ std::optional<QPair<la::avdecc::entity::model::SamplingRate, QString>> EntityTre
 	{
 		try
 		{
-			auto* audioUnitDynamicModel = controlledEntity->getAudioUnitNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, 0).dynamicModel;
-			if (audioUnitDynamicModel)
-			{
-				auto samplingRate = audioUnitDynamicModel->currentSamplingRate;
-				return qMakePair(samplingRate, QString::number(samplingRate / 1000) + " kHz");
-			}
+			auto& audioUnitDynamicModel = controlledEntity->getAudioUnitNode(controlledEntity->getCurrentConfigurationNode().descriptorIndex, 0).dynamicModel;
+			auto samplingRate = audioUnitDynamicModel.currentSamplingRate;
+			return qMakePair(samplingRate, QString::number(samplingRate / 1000) + " kHz");
 		}
 		catch (la::avdecc::controller::ControlledEntity::Exception const&)
 		{
diff --git a/src/multiFirmwareUpdateDialog.cpp b/src/multiFirmwareUpdateDialog.cpp
index d6efbd1c..90e3f926 100644
--- a/src/multiFirmwareUpdateDialog.cpp
+++ b/src/multiFirmwareUpdateDialog.cpp
@@ -171,29 +171,26 @@ class ModelPrivate : public QObject
 			if (controlledEntity && controlledEntity->getEntity().getEntityCapabilities().test(la::avdecc::entity::EntityCapability::AemSupported) && controlledEntity->hasAnyConfiguration())
 			{
 				auto const& entityNode = controlledEntity->getEntityNode();
-				if (entityNode.dynamicModel)
+				auto const configurationIndex = entityNode.dynamicModel.currentConfiguration;
+				auto const& configurationNode = controlledEntity->getConfigurationNode(configurationIndex);
+				for (auto const& [memoryObjectIndex, memoryObjectNode] : configurationNode.memoryObjects)
 				{
-					auto const configurationIndex = entityNode.dynamicModel->currentConfiguration;
-					auto const& configurationNode = controlledEntity->getConfigurationNode(configurationIndex);
-					for (auto const& [memoryObjectIndex, memoryObjectNode] : configurationNode.memoryObjects)
+					if (memoryObjectNode.staticModel.memoryObjectType == la::avdecc::entity::model::MemoryObjectType::FirmwareImage)
 					{
-						if (memoryObjectNode.staticModel->memoryObjectType == la::avdecc::entity::model::MemoryObjectType::FirmwareImage)
-						{
-							Q_Q(Model);
+						Q_Q(Model);
 
-							// Insert at the end
-							auto const row = rowCount();
-							emit q->beginInsertRows({}, row, row);
+						// Insert at the end
+						auto const row = rowCount();
+						emit q->beginInsertRows({}, row, row);
 
-							_entities.push_back(EntityData{ entityID, hive::modelsLibrary::helper::smartEntityName(*controlledEntity), entityNode.dynamicModel->firmwareVersion.data() });
+						_entities.push_back(EntityData{ entityID, hive::modelsLibrary::helper::smartEntityName(*controlledEntity), entityNode.dynamicModel.firmwareVersion.data() });
 
-							// Update the cache
-							rebuildEntityRowMap();
+						// Update the cache
+						rebuildEntityRowMap();
 
-							emit q->endInsertRows();
+						emit q->endInsertRows();
 
-							return;
-						}
+						return;
 					}
 				}
 			}
@@ -407,19 +404,16 @@ void MultiFirmwareUpdateDialog::onItemSelectionChanged(QItemSelection const&, QI
 		auto const controlledEntity = manager.getControlledEntity(entityID);
 		auto const& entityNode = controlledEntity->getEntityNode();
 
-		if (entityNode.staticModel)
-		{
-			auto const rowModelName = hive::modelsLibrary::helper::localizedString(*controlledEntity, entityNode.staticModel->modelNameString);
+		auto const rowModelName = hive::modelsLibrary::helper::localizedString(*controlledEntity, entityNode.staticModel.modelNameString);
 
-			if (modelName.isEmpty())
-			{
-				modelName = rowModelName;
-			}
-			else if (modelName != rowModelName)
-			{
-				_ui->buttonContinue->setEnabled(false);
-				return;
-			}
+		if (modelName.isEmpty())
+		{
+			modelName = rowModelName;
+		}
+		else if (modelName != rowModelName)
+		{
+			_ui->buttonContinue->setEnabled(false);
+			return;
 		}
 	}
 
@@ -457,24 +451,21 @@ void MultiFirmwareUpdateDialog::startFirmwareUpdate()
 		if (controlledEntity)
 		{
 			auto const& entityNode = controlledEntity->getEntityNode();
-			if (entityNode.dynamicModel)
+			auto const configurationIndex = entityNode.dynamicModel.currentConfiguration;
+			auto const& configurationNode = controlledEntity->getConfigurationNode(configurationIndex);
+			for (auto const& [memoryObjectIndex, memoryObjectNode] : configurationNode.memoryObjects)
 			{
-				auto const configurationIndex = entityNode.dynamicModel->currentConfiguration;
-				auto const& configurationNode = controlledEntity->getConfigurationNode(configurationIndex);
-				for (auto const& [memoryObjectIndex, memoryObjectNode] : configurationNode.memoryObjects)
+				if (memoryObjectNode.staticModel.memoryObjectType == la::avdecc::entity::model::MemoryObjectType::FirmwareImage)
 				{
-					if (memoryObjectNode.staticModel->memoryObjectType == la::avdecc::entity::model::MemoryObjectType::FirmwareImage)
+					if (maximumLength == 0)
 					{
-						if (maximumLength == 0)
-						{
-							// Pick first entity's max length, all following entities should have the same.
-							maximumLength = memoryObjectNode.staticModel->maximumLength;
-						}
-
-						auto const* const model = memoryObjectNode.staticModel;
-						firmwareUpdateEntityInfos.emplace_back(entityID, memoryObjectNode.descriptorIndex, model->startAddress);
-						break;
+						// Pick first entity's max length, all following entities should have the same.
+						maximumLength = memoryObjectNode.staticModel.maximumLength;
 					}
+
+					auto const& model = memoryObjectNode.staticModel;
+					firmwareUpdateEntityInfos.emplace_back(entityID, memoryObjectNode.descriptorIndex, model.startAddress);
+					break;
 				}
 			}
 		}
@@ -494,7 +485,7 @@ void MultiFirmwareUpdateDialog::startFirmwareUpdate()
 	close();
 
 	// Start firmware upload dialog
-	auto dialog = FirmwareUploadDialog{ { firmwareFileData.constData(), static_cast<size_t>(firmwareFileData.count()) }, QFileInfo(fileName).fileName(), firmwareUpdateEntityInfos, this };
+	auto dialog = FirmwareUploadDialog{ { firmwareFileData.constData(), static_cast<size_t>(firmwareFileData.size()) }, QFileInfo(fileName).fileName(), firmwareUpdateEntityInfos, this };
 	dialog.exec();
 }
 
diff --git a/src/nodeTreeDynamicWidgets/controlValuesDynamicTreeWidgetItem.hpp b/src/nodeTreeDynamicWidgets/controlValuesDynamicTreeWidgetItem.hpp
index 5e509a23..7dd83c73 100644
--- a/src/nodeTreeDynamicWidgets/controlValuesDynamicTreeWidgetItem.hpp
+++ b/src/nodeTreeDynamicWidgets/controlValuesDynamicTreeWidgetItem.hpp
@@ -24,6 +24,7 @@
 #include "aecpCommandComboBox.hpp"
 #include "aecpCommandTextEntry.hpp"
 #include "aecpCommandSpinBox.hpp"
+#include "aecpCommandSlider.hpp"
 #include "avdecc/hiveLogItems.hpp"
 
 #include <la/avdecc/controller/internals/avdeccControlledEntity.hpp>
@@ -33,12 +34,11 @@
 #include <QObject>
 #include <QTreeWidgetItem>
 #include <QPushButton>
-#include <QLabel>
 #include <QHBoxLayout>
 #include <QListWidget>
 #include <QSignalBlocker>
 
-#include <vector>
+#include <map>
 #include <cstring> // std::memcpy
 
 class ControlValuesDynamicTreeWidgetItem : public QObject, public QTreeWidgetItem
@@ -54,13 +54,14 @@ class ControlValuesDynamicTreeWidgetItem : public QObject, public QTreeWidgetIte
 	virtual void updateValues(la::avdecc::entity::model::ControlValues const& controlValues) noexcept = 0;
 };
 
-/** Linear Values */
+/** Linear Values - Clause 7.3.5.2.1 */
 template<class StaticValueType, class DynamicValueType>
 class LinearControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeWidgetItem
 {
 	using value_size = typename DynamicValueType::control_value_details_traits::size_type;
 	static constexpr auto UseSpinBox = std::conditional_t < std::is_integral_v<value_size> && sizeof(value_size) <= 4, std::true_type, std::false_type > ();
-	using WidgetType = std::conditional_t<UseSpinBox, AecpCommandSpinBox<value_size>, AecpCommandComboBox<value_size>>;
+	static constexpr auto UseSlider = std::false_type::value;
+	using WidgetType = std::conditional_t<UseSpinBox, AecpCommandSpinBox<value_size>, std::conditional_t<UseSlider, AecpCommandSlider<value_size>, AecpCommandComboBox<value_size>>>;
 
 public:
 	LinearControlValuesDynamicTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::entity::model::ControlNodeStaticModel const& staticModel, la::avdecc::entity::model::ControlNodeDynamicModel const& dynamicModel, QTreeWidget* parent = nullptr)
@@ -92,16 +93,16 @@ class LinearControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTree
 				item->setText(0, "Current Value");
 				if (_isReadOnly)
 				{
-					auto* label = new QLabel(QString::number(val.currentValue));
-					parent->setItemWidget(item, 1, label);
-					_widgets.push_back(label);
+					// Do not use a widget for read only values (especially not a QLabel), the 'selected' state of the item will not be applied
+					item->setText(1, QString::number(val.currentValue));
+					_items[valNumber] = item;
 				}
 				else
 				{
 					auto* widget = new WidgetType{};
 					parent->setItemWidget(item, 1, widget);
 
-					auto const range = static_cast<size_t>(staticVal.maximum - staticVal.minimum);
+					auto const range = static_cast<value_size>(staticVal.maximum - staticVal.minimum);
 					auto stepsCount = size_t{ 1 };
 					if (staticVal.step != value_size{ 0 })
 					{
@@ -120,6 +121,11 @@ class LinearControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTree
 					{
 						widget->setRangeAndStep(staticVal.minimum, staticVal.maximum, staticVal.step);
 					}
+					else if constexpr (UseSlider)
+					{
+						widget->setRangeAndStep(staticVal.minimum, staticVal.maximum, staticVal.step);
+						widget->setTickPosition(QSlider::TicksBothSides);
+					}
 					else
 					{
 						auto data = typename std::remove_pointer_t<decltype(widget)>::Data{};
@@ -142,7 +148,7 @@ class LinearControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTree
 							sendControlValues(widget, previousValue);
 						});
 
-					_widgets.push_back(widget);
+					_widgets[valNumber] = widget;
 				}
 
 				++valNumber;
@@ -165,7 +171,7 @@ class LinearControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTree
 		{
 			auto values = DynamicValueType{};
 
-			for (auto const* item : _widgets)
+			for (auto const [valNumber, item] : _widgets)
 			{
 				auto const* widget = static_cast<WidgetType const*>(item);
 				auto value = typename DynamicValueType::value_type{};
@@ -200,44 +206,216 @@ class LinearControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTree
 	{
 		if (_isValid)
 		{
-			if (controlValues.size() != _widgets.size())
+			if (controlValues.size() != (_items.size() + _widgets.size()))
 			{
 				// This should probably be detected by the AVDECC library
-				LOG_HIVE_WARN("ControlValues update not valid: Static/Dynamic count mismatch");
+				LOG_HIVE_WARN("ControlValues update not valid: Dynamic count mismatch");
 				return;
 			}
 
-			auto const dynamicValues = controlValues.getValues<DynamicValueType>(); // We have to store the copy or it will go out of scope if using it directly in the range-based loop
-			auto valNumber = size_t{ 0u };
-			for (auto const& val : dynamicValues.getValues())
+			try
+			{
+				auto const dynamicValues = controlValues.getValues<DynamicValueType>(); // We have to store the copy or it will go out of scope if using it directly in the range-based loop
+				auto valNumber = size_t{ 0u };
+				for (auto const& val : dynamicValues.getValues())
+				{
+					if (_isReadOnly)
+					{
+						if (auto const itemIt = _items.find(valNumber); itemIt != _items.end())
+						{
+							auto* const item = itemIt->second;
+							item->setText(1, QString::number(val.currentValue));
+						}
+						else
+						{
+							LOG_HIVE_WARN(QString("Failed to update ControlValue n°%1: Item not found").arg(valNumber));
+						}
+					}
+					else
+					{
+						if (auto const widgetIt = _widgets.find(valNumber); widgetIt != _widgets.end())
+						{
+							auto* const widget = static_cast<WidgetType*>(widgetIt->second);
+							widget->setCurrentData(val.currentValue);
+						}
+						else
+						{
+							LOG_HIVE_WARN(QString("Failed to update ControlValue n°%1: Widget not found").arg(valNumber));
+						}
+					}
+
+					++valNumber;
+				}
+			}
+			catch (std::invalid_argument const&)
+			{
+				AVDECC_ASSERT(false, "Identify Control Descriptor values doesn't seem valid");
+			}
+			catch (...)
+			{
+				AVDECC_ASSERT(false, "Identify Control Descriptor was validated, this should not throw");
+			}
+		}
+	}
+
+	bool _isValid{ false };
+	bool _isReadOnly{ false };
+	std::map<size_t, QTreeWidgetItem*> _items{};
+	std::map<size_t, QWidget*> _widgets{};
+};
+
+/** Selector Values - Clause 7.3.5.2.2 */
+template<class StaticValueType, class DynamicValueType>
+class SelectorControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeWidgetItem
+{
+	using value_size = typename DynamicValueType::control_value_details_traits::size_type;
+	using WidgetType = AecpCommandComboBox<value_size>;
+
+public:
+	SelectorControlValuesDynamicTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::entity::model::ControlNodeStaticModel const& staticModel, la::avdecc::entity::model::ControlNodeDynamicModel const& dynamicModel, QTreeWidget* parent = nullptr)
+		: ControlValuesDynamicTreeWidgetItem{ entityID, controlIndex, staticModel, dynamicModel, parent }
+	{
+		_isReadOnly = staticModel.controlValueType.isReadOnly();
+
+		try
+		{
+			auto const staticValue = staticModel.values.getValues<StaticValueType>();
+			auto const dynamicValue = dynamicModel.values.getValues<DynamicValueType>();
+			if (dynamicValue.countValues() != 1)
+			{
+				LOG_HIVE_WARN("ControlValues not valid: Dynamic count is not equal to 1");
+				return;
+			}
+
+			auto* valueItem = new QTreeWidgetItem(this);
+			valueItem->setText(0, "Current Value");
+
+			if (_isReadOnly)
+			{
+				// Do not use a widget for read only values (especially not a QLabel), the 'selected' state of the item will not be applied
+				valueItem->setText(1, QString::number(dynamicValue.currentValue));
+				_item = valueItem;
+			}
+			else
+			{
+				auto* widget = new WidgetType{};
+				parent->setItemWidget(valueItem, 1, widget);
+
+
+				{
+					auto data = typename std::remove_pointer_t<decltype(widget)>::Data{};
+					for (auto const& option : staticValue.options)
+					{
+						data.insert(option);
+					}
+					widget->setAllData(data,
+						[](auto const& value)
+						{
+							return QString::number(value);
+						});
+				}
+
+				// Send changes
+				widget->setDataChangedHandler(
+					[this, widget](auto const& previousValue, auto const& newValue)
+					{
+						sendControlValues(widget, previousValue);
+					});
+
+				_widget = widget;
+			}
+
+
+			_isValid = true;
+
+			// Update now
+			updateValues(dynamicModel.values);
+		}
+		catch (...)
+		{
+		}
+	}
+
+private:
+	void sendControlValues(WidgetType* const changedWidget, value_size const previousValue) noexcept
+	{
+		if (AVDECC_ASSERT_WITH_RET(!_isReadOnly, "Should never call sendControlValues with read only values"))
+		{
+			auto values = DynamicValueType{};
 			{
+				auto const* widget = static_cast<WidgetType const*>(_widget);
+				values.currentValue = static_cast<decltype(DynamicValueType::currentValue)>(widget->getCurrentData());
+			}
+			hive::modelsLibrary::ControllerManager::getInstance().setControlValues(_entityID, _controlIndex, la::avdecc::entity::model::ControlValues{ std::move(values) },
+				[this, changedWidget](la::avdecc::UniqueIdentifier const /*entityID*/)
+				{
+					changedWidget->setEnabled(false);
+				},
+				[this, changedWidget, previousValue](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::ControllerEntity::AemCommandStatus const status)
+				{
+					QMetaObject::invokeMethod(this,
+						[this, changedWidget, previousValue, status]()
+						{
+							if (status != la::avdecc::entity::ControllerEntity::AemCommandStatus::Success)
+							{
+								changedWidget->setCurrentData(previousValue);
+
+								QMessageBox::warning(changedWidget, "", "<i>" + hive::modelsLibrary::ControllerManager::typeToString(hive::modelsLibrary::ControllerManager::AecpCommandType::SetControl) + "<//>/ failed:<br>" + QString::fromStdString(la::avdecc::entity::ControllerEntity::statusToString(status)));
+							}
+							changedWidget->setEnabled(true);
+						});
+				});
+		}
+	}
+
+	virtual void updateValues(la::avdecc::entity::model::ControlValues const& controlValues) noexcept override
+	{
+		if (_isValid)
+		{
+			if (controlValues.size() != 1u)
+			{
+				// This should probably be detected by the AVDECC library
+				LOG_HIVE_WARN("ControlValues update not valid: Dynamic count is not equal to 1");
+				return;
+			}
+
+			try
+			{
+				auto const& dynamicValue = controlValues.getValues<DynamicValueType>();
+
 				if (_isReadOnly)
 				{
-					auto* label = static_cast<QLabel*>(_widgets[valNumber]);
-					label->setText(QString::number(val.currentValue));
+					_item->setText(1, QString::number(dynamicValue.currentValue));
 				}
 				else
 				{
-					auto* widget = static_cast<WidgetType*>(_widgets[valNumber]);
-					widget->setCurrentData(val.currentValue);
+					auto* widget = static_cast<WidgetType*>(_widget);
+					widget->setCurrentData(dynamicValue.currentValue);
 				}
-
-				++valNumber;
+			}
+			catch (std::invalid_argument const&)
+			{
+				AVDECC_ASSERT(false, "Identify Control Descriptor values doesn't seem valid");
+			}
+			catch (...)
+			{
+				AVDECC_ASSERT(false, "Identify Control Descriptor was validated, this should not throw");
 			}
 		}
 	}
 
 	bool _isValid{ false };
 	bool _isReadOnly{ false };
-	std::vector<QWidget*> _widgets{};
+	QTreeWidgetItem* _item{ nullptr };
+	QWidget* _widget{ nullptr };
 };
 
-/** Array Values */
+/** Array Values - Clause 7.3.5.2.3 */
 template<class StaticValueType, class DynamicValueType>
 class ArrayControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeWidgetItem
 {
 	using value_size = typename DynamicValueType::control_value_details_traits::size_type;
-	static constexpr auto UseSpinBox = std::conditional_t < std::is_integral_v<value_size> && sizeof(value_size) <= 4, std::true_type, std::false_type > ();
+	static constexpr auto UseSpinBox = std::conditional_t < std::is_integral_v<value_size> && sizeof(value_size) <= 4, std::true_type, std::false_type > (); // SpinBox only supports integral types up to 32 bits
 	using WidgetType = std::conditional_t<UseSpinBox, AecpCommandSpinBox<value_size>, AecpCommandComboBox<value_size>>;
 
 public:
@@ -262,9 +440,9 @@ class ArrayControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeW
 				item->setText(0, "Current Value");
 				if (_isReadOnly)
 				{
-					auto* label = new QLabel(QString::number(val));
-					parent->setItemWidget(item, 1, label);
-					_widgets.push_back(label);
+					// Do not use a widget for read only values (especially not a QLabel), the 'selected' state of the item will not be applied
+					item->setText(1, QString::number(val));
+					_items[valNumber] = item;
 				}
 				else
 				{
@@ -312,7 +490,7 @@ class ArrayControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeW
 							sendControlValues(widget, previousValue);
 						});
 
-					_widgets.push_back(widget);
+					_widgets[valNumber] = widget;
 				}
 
 				++valNumber;
@@ -335,7 +513,7 @@ class ArrayControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeW
 		{
 			auto values = DynamicValueType{};
 
-			for (auto const* item : _widgets)
+			for (auto const [valNumber, item] : _widgets)
 			{
 				auto const* widget = static_cast<WidgetType const*>(item);
 				values.currentValues.push_back(widget->getCurrentData());
@@ -367,39 +545,65 @@ class ArrayControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeW
 	{
 		if (_isValid)
 		{
-			if (controlValues.size() != _widgets.size())
+			if (controlValues.size() != (_items.size() + _widgets.size()))
 			{
 				// This should probably be detected by the AVDECC library
-				LOG_HIVE_WARN("ControlValues update not valid: Static/Dynamic count mismatch");
+				LOG_HIVE_WARN("ControlValues update not valid: Dynamic count mismatch");
 				return;
 			}
 
-			auto const dynamicValues = controlValues.getValues<DynamicValueType>(); // We have to store the copy or it will go out of scope if using it directly in the range-based loop
-			auto valNumber = size_t{ 0u };
-			for (auto const& val : dynamicValues.currentValues)
+			try
 			{
-				if (_isReadOnly)
+				auto const dynamicValues = controlValues.getValues<DynamicValueType>(); // We have to store the copy or it will go out of scope if using it directly in the range-based loop
+				auto valNumber = size_t{ 0u };
+				for (auto const& val : dynamicValues.currentValues)
 				{
-					auto* label = static_cast<QLabel*>(_widgets[valNumber]);
-					label->setText(QString::number(val));
-				}
-				else
-				{
-					auto* widget = static_cast<WidgetType*>(_widgets[valNumber]);
-					widget->setCurrentData(val);
-				}
+					if (_isReadOnly)
+					{
+						if (auto const itemIt = _items.find(valNumber); itemIt != _items.end())
+						{
+							auto* const item = itemIt->second;
+							item->setText(1, QString::number(val));
+						}
+						else
+						{
+							LOG_HIVE_WARN(QString("Failed to update ControlValue n°%1: Item not found").arg(valNumber));
+						}
+					}
+					else
+					{
+						if (auto const widgetIt = _widgets.find(valNumber); widgetIt != _widgets.end())
+						{
+							auto* const widget = static_cast<WidgetType*>(widgetIt->second);
+							widget->setCurrentData(val);
+						}
+						else
+						{
+							LOG_HIVE_WARN(QString("Failed to update ControlValue n°%1: Widget not found").arg(valNumber));
+						}
+					}
 
-				++valNumber;
+					++valNumber;
+				}
+			}
+			catch (std::invalid_argument const&)
+			{
+				AVDECC_ASSERT(false, "Identify Control Descriptor values doesn't seem valid");
+			}
+			catch (...)
+			{
+				AVDECC_ASSERT(false, "Identify Control Descriptor was validated, this should not throw");
 			}
 		}
 	}
 
 	bool _isValid{ false };
 	bool _isReadOnly{ false };
-	std::vector<QWidget*> _widgets{};
+	std::map<size_t, QTreeWidgetItem*> _items{};
+	std::map<size_t, QWidget*> _widgets{};
 };
 
-/** UTF-8 String Value */
+/** UTF-8 String Value - Clause 7.3.5.2.4 */
 class UTF8ControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeWidgetItem
 {
 	//using value_size = typename DynamicValueType::control_value_details_traits::size_type;
@@ -430,9 +634,9 @@ class UTF8ControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeWi
 			item->setText(0, "Current Value");
 			if (_isReadOnly)
 			{
-				auto label = new QLabel(text);
-				parent->setItemWidget(item, 1, label);
-				_widget = label;
+				// Do not use a widget for read only values (especially not a QLabel), the 'selected' state of the item will not be applied
+				item->setText(1, text);
+				_item = item;
 			}
 			else
 			{
@@ -465,10 +669,11 @@ class UTF8ControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeWi
 		if (AVDECC_ASSERT_WITH_RET(!_isReadOnly, "Should never call sendControlValues with read only values"))
 		{
 			auto values = DynamicValueType{};
-
-			auto const* widget = static_cast<WidgetType const*>(_widget);
-			auto data = widget->getCurrentData().toUtf8();
-			std::memcpy(values.currentValue.data(), data.constData(), std::min(static_cast<size_t>(data.size()), values.currentValue.size()));
+			{
+				auto const* widget = static_cast<WidgetType const*>(_widget);
+				auto data = widget->getCurrentData().toUtf8();
+				std::memcpy(values.currentValue.data(), data.constData(), std::min(static_cast<size_t>(data.size()), values.currentValue.size()));
+			}
 			hive::modelsLibrary::ControllerManager::getInstance().setControlValues(_entityID, _controlIndex, la::avdecc::entity::model::ControlValues{ std::move(values) },
 				[this, changedWidget](la::avdecc::UniqueIdentifier const /*entityID*/)
 				{
@@ -498,27 +703,38 @@ class UTF8ControlValuesDynamicTreeWidgetItem : public ControlValuesDynamicTreeWi
 			if (controlValues.size() != 1u)
 			{
 				// This should probably be detected by the AVDECC library
-				LOG_HIVE_WARN("ControlValues update not valid: Static/Dynamic count mismatch");
+				LOG_HIVE_WARN("ControlValues update not valid: Dynamic count is not equal to 1");
 				return;
 			}
 
-			auto const dynamicValues = controlValues.getValues<DynamicValueType>(); // We have to store the copy or it will go out of scope if using it directly in the range-based loop
-			auto const text = QString::fromUtf8(reinterpret_cast<char const*>(dynamicValues.currentValue.data()));
+			try
+			{
+				auto const& dynamicValue = controlValues.getValues<DynamicValueType>();
+				auto const text = QString::fromUtf8(reinterpret_cast<char const*>(dynamicValue.currentValue.data()));
 
-			if (_isReadOnly)
+				if (_isReadOnly)
+				{
+					_item->setText(1, text);
+				}
+				else
+				{
+					auto* widget = static_cast<WidgetType*>(_widget);
+					widget->setCurrentData(text);
+				}
+			}
+			catch (std::invalid_argument const&)
 			{
-				auto* label = static_cast<QLabel*>(_widget);
-				label->setText(text);
+				AVDECC_ASSERT(false, "Identify Control Descriptor values doesn't seem valid");
 			}
-			else
+			catch (...)
 			{
-				auto* widget = static_cast<WidgetType*>(_widget);
-				widget->setCurrentData(text);
+				AVDECC_ASSERT(false, "Identify Control Descriptor was validated, this should not throw");
 			}
 		}
 	}
 
 	bool _isValid{ false };
 	bool _isReadOnly{ false };
-	QWidget* _widget{};
+	QTreeWidgetItem* _item{ nullptr };
+	QWidget* _widget{ nullptr };
 };
diff --git a/src/nodeTreeDynamicWidgets/listenerStreamConnectionWidget.cpp b/src/nodeTreeDynamicWidgets/listenerStreamConnectionWidget.cpp
index 31ed8e55..6b11ffe8 100644
--- a/src/nodeTreeDynamicWidgets/listenerStreamConnectionWidget.cpp
+++ b/src/nodeTreeDynamicWidgets/listenerStreamConnectionWidget.cpp
@@ -29,13 +29,13 @@ ListenerStreamConnectionWidget::ListenerStreamConnectionWidget(la::avdecc::entit
 	, _stream(stream)
 	, _info(info)
 {
-	auto const margin = style()->pixelMetric(QStyle::PM_FocusFrameHMargin, 0, this) + 1;
-	_layout.setContentsMargins(margin, 0, margin, 0);
+	_layout.setContentsMargins(0, 0, 0, 0);
 
 	_layout.addWidget(&_streamConnectionLabel, 1);
 	_layout.addWidget(&_entityNameLabel, 2);
 	_layout.addWidget(&_disconnectButton);
 
+	_streamConnectionLabel.setObjectName("StreamConnectionLabel");
 	_entityNameLabel.setObjectName("EntityNameLabel");
 	_disconnectButton.setObjectName("DisconnectButton");
 
@@ -83,6 +83,23 @@ ListenerStreamConnectionWidget::ListenerStreamConnectionWidget(la::avdecc::entit
 		});
 }
 
+void ListenerStreamConnectionWidget::selectionChanged(bool const isSelected)
+{
+	if (isSelected != _isSelected)
+	{
+		_isSelected = isSelected;
+		_streamConnectionLabel.setProperty("isSelected", isSelected);
+		style()->unpolish(&_streamConnectionLabel);
+		style()->polish(&_streamConnectionLabel);
+		_entityNameLabel.setProperty("isSelected", isSelected);
+		style()->unpolish(&_entityNameLabel);
+		style()->polish(&_entityNameLabel);
+		_disconnectButton.setProperty("isSelected", isSelected);
+		style()->unpolish(&_disconnectButton);
+		style()->polish(&_disconnectButton);
+	}
+}
+
 void ListenerStreamConnectionWidget::updateData()
 {
 	auto& manager = hive::modelsLibrary::ControllerManager::getInstance();
diff --git a/src/nodeTreeDynamicWidgets/listenerStreamConnectionWidget.hpp b/src/nodeTreeDynamicWidgets/listenerStreamConnectionWidget.hpp
index 20edda6f..a500835e 100644
--- a/src/nodeTreeDynamicWidgets/listenerStreamConnectionWidget.hpp
+++ b/src/nodeTreeDynamicWidgets/listenerStreamConnectionWidget.hpp
@@ -36,12 +36,15 @@ class ListenerStreamConnectionWidget : public QWidget
 public:
 	ListenerStreamConnectionWidget(la::avdecc::entity::model::StreamIdentification const& stream, la::avdecc::entity::model::StreamInputConnectionInfo const& info, QWidget* parent = nullptr);
 
+	void selectionChanged(bool const isSelected);
+
 private:
 	void updateData();
 
 	la::avdecc::entity::model::StreamIdentification _stream{};
 	la::avdecc::entity::model::StreamInputConnectionInfo _info{};
 
+	bool _isSelected{ false };
 	QHBoxLayout _layout{ this };
 	QLabel _streamConnectionLabel{ this };
 	QLabel _entityNameLabel{ this };
diff --git a/src/nodeTreeDynamicWidgets/streamDynamicTreeWidgetItem.cpp b/src/nodeTreeDynamicWidgets/streamDynamicTreeWidgetItem.cpp
index 81701e44..3b520d94 100644
--- a/src/nodeTreeDynamicWidgets/streamDynamicTreeWidgetItem.cpp
+++ b/src/nodeTreeDynamicWidgets/streamDynamicTreeWidgetItem.cpp
@@ -23,6 +23,7 @@
 #include "nodeTreeWidget.hpp"
 
 #include <hive/modelsLibrary/helper.hpp>
+#include <QtMate/material/color.hpp>
 
 #include <QMenu>
 #include <QMessageBox>
@@ -30,8 +31,8 @@
 static inline void setNoValue(QTreeWidgetItem* const widget)
 {
 	widget->setText(1, "No Value");
-	widget->setForeground(0, QColor{ Qt::gray });
-	widget->setForeground(1, QColor{ Qt::gray });
+	widget->setForeground(0, qtMate::material::color::disabledForegroundColor());
+	widget->setForeground(1, qtMate::material::color::disabledForegroundColor());
 }
 
 StreamDynamicTreeWidgetItem::StreamDynamicTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::DescriptorType const streamType, la::avdecc::entity::model::StreamIndex const streamIndex, la::avdecc::entity::model::StreamNodeStaticModel const* const staticModel, la::avdecc::entity::model::StreamInputNodeDynamicModel const* const inputDynamicModel, la::avdecc::entity::model::StreamOutputNodeDynamicModel const* const outputDynamicModel, QTreeWidget* parent)
@@ -97,8 +98,8 @@ StreamDynamicTreeWidgetItem::StreamDynamicTreeWidgetItem(la::avdecc::UniqueIdent
 			auto* const widget = new QTreeWidgetItem(this);
 			widget->setText(0, label);
 			widget->setText(1, "No Value");
-			widget->setForeground(0, QColor{ Qt::gray });
-			widget->setForeground(1, QColor{ Qt::gray });
+			widget->setForeground(0, QColor{ qtMate::material::color::disabledForegroundColor() });
+			widget->setForeground(1, QColor{ qtMate::material::color::disabledForegroundColor() });
 			return widget;
 		};
 
@@ -173,6 +174,12 @@ StreamDynamicTreeWidgetItem::StreamDynamicTreeWidgetItem(la::avdecc::UniqueIdent
 		}
 		_connectionStateWidget = new ListenerStreamConnectionWidget({ _entityID, _streamIndex }, inputDynamicModel->connectionInfo, parent);
 		parent->setItemWidget(_connectionState, 1, _connectionStateWidget);
+		connect(parent, &QTreeWidget::itemSelectionChanged, this,
+			[this, parent]()
+			{
+				// Update the selection state of the widget
+				_connectionStateWidget->selectionChanged(_connectionState->isSelected());
+			});
 	}
 
 	// StreamOutput dynamic info
@@ -202,15 +209,17 @@ StreamDynamicTreeWidgetItem::StreamDynamicTreeWidgetItem(la::avdecc::UniqueIdent
 
 void StreamDynamicTreeWidgetItem::updateStreamFormat(la::avdecc::entity::model::StreamFormat const& streamFormat)
 {
-	_streamFormat->setForeground(0, QColor{ Qt::black });
-	_streamFormat->setForeground(1, QColor{ Qt::black });
+	auto const color = qtMate::material::color::foregroundColor();
+	_streamFormat->setForeground(0, color);
+	_streamFormat->setForeground(1, color);
 	_streamFormat->setText(1, hive::modelsLibrary::helper::toHexQString(streamFormat.getValue(), true, true));
 }
 
 void StreamDynamicTreeWidgetItem::updateStreamIsRunning(bool const isRunning)
 {
-	_streamWait->setForeground(0, QColor{ Qt::black });
-	_streamWait->setForeground(1, QColor{ Qt::black });
+	auto const color = qtMate::material::color::foregroundColor();
+	_streamWait->setForeground(0, color);
+	_streamWait->setForeground(1, color);
 	_streamWait->setText(1, isRunning ? "No" : "Yes");
 }
 
@@ -218,15 +227,17 @@ void StreamDynamicTreeWidgetItem::updateStreamDynamicInfo(la::avdecc::entity::mo
 {
 	auto const setBoolValue = [](auto* const widget, bool const value)
 	{
-		widget->setForeground(0, QColor{ Qt::black });
-		widget->setForeground(1, QColor{ Qt::black });
+		auto const color = qtMate::material::color::foregroundColor();
+		widget->setForeground(0, color);
+		widget->setForeground(1, color);
 		widget->setText(1, value ? "Yes" : "No");
 	};
 
 	auto const setStringValue = [](auto* const widget, QString const value)
 	{
-		widget->setForeground(0, QColor{ Qt::black });
-		widget->setForeground(1, QColor{ Qt::black });
+		auto const color = qtMate::material::color::foregroundColor();
+		widget->setForeground(0, color);
+		widget->setForeground(1, color);
 		widget->setText(1, value);
 	};
 
@@ -235,8 +246,9 @@ void StreamDynamicTreeWidgetItem::updateStreamDynamicInfo(la::avdecc::entity::mo
 	setBoolValue(_doesSupportEncrypted, streamDynamicInfo.doesSupportEncrypted);
 	setBoolValue(_arePdusEncrypted, streamDynamicInfo.arePdusEncrypted);
 	setBoolValue(_hasTalkerFailed, streamDynamicInfo.hasTalkerFailed);
-	_streamFlags->setForeground(0, QColor{ Qt::black });
-	_streamFlags->setForeground(1, QColor{ Qt::black });
+	auto const color = qtMate::material::color::foregroundColor();
+	_streamFlags->setForeground(0, color);
+	_streamFlags->setForeground(1, color);
 	setFlagsItemText(_streamFlags, la::avdecc::utils::forceNumeric(streamDynamicInfo._streamInfoFlags.value()), avdecc::helper::flagsToString(streamDynamicInfo._streamInfoFlags));
 
 	if (streamDynamicInfo.streamID)
@@ -285,8 +297,8 @@ void StreamDynamicTreeWidgetItem::updateStreamDynamicInfo(la::avdecc::entity::mo
 	if (streamDynamicInfo.streamInfoFlagsEx)
 	{
 		auto const flagsEx = *streamDynamicInfo.streamInfoFlagsEx;
-		_streamFlagsEx->setForeground(0, QColor{ Qt::black });
-		_streamFlagsEx->setForeground(1, QColor{ Qt::black });
+		_streamFlagsEx->setForeground(0, qtMate::material::color::foregroundColor());
+		_streamFlagsEx->setForeground(1, qtMate::material::color::foregroundColor());
 		setFlagsItemText(_streamFlagsEx, la::avdecc::utils::forceNumeric(flagsEx.value()), avdecc::helper::flagsToString(flagsEx));
 	}
 	else
diff --git a/src/nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.cpp b/src/nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.cpp
index 98e81138..e8427ca0 100644
--- a/src/nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.cpp
+++ b/src/nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.cpp
@@ -35,12 +35,15 @@
 /* ************************************************************ */
 /* StreamPortDynamicTreeWidgetItem                              */
 /* ************************************************************ */
-StreamPortDynamicTreeWidgetItem::StreamPortDynamicTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::StreamPortNodeStaticModel const* const /*staticModel*/, la::avdecc::entity::model::StreamPortNodeDynamicModel const* const /*dynamicModel*/, QTreeWidget* parent)
+StreamPortDynamicTreeWidgetItem::StreamPortDynamicTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::StreamPortNodeStaticModel const* const /*staticModel*/, la::avdecc::entity::model::StreamPortNodeDynamicModel const* const /*dynamicModel*/, QTreeWidget* parent)
 	: QTreeWidgetItem(parent)
 	, _entityID(entityID)
+	, _audioUnitIndex(audioUnitIndex)
 	, _streamPortType(streamPortType)
 	, _streamPortIndex(streamPortIndex)
 {
+	AVDECC_ASSERT(audioUnitIndex != la::avdecc::entity::model::getInvalidDescriptorIndex(), "Invalid AudioUnitIndex");
+
 	// StreamPortInfo
 	{
 		// Create fields
@@ -82,7 +85,7 @@ StreamPortDynamicTreeWidgetItem::StreamPortDynamicTreeWidgetItem(la::avdecc::Uni
 
 void StreamPortDynamicTreeWidgetItem::editMappingsButtonClicked()
 {
-	avdecc::mappingsHelper::showMappingsEditor(this, _entityID, _streamPortType, _streamPortIndex, la::avdecc::entity::model::getInvalidDescriptorIndex());
+	avdecc::mappingsHelper::showMappingsEditor(this, _entityID, _audioUnitIndex, _streamPortType, _streamPortIndex, la::avdecc::entity::model::getInvalidDescriptorIndex());
 }
 
 void StreamPortDynamicTreeWidgetItem::clearMappingsButtonClicked()
@@ -123,11 +126,27 @@ void StreamPortDynamicTreeWidgetItem::clearMappingsButtonClicked()
 
 						if (streamPortType == la::avdecc::entity::model::DescriptorType::StreamPortInput)
 						{
-							avdecc::mappingsHelper::batchRemoveInputAudioMappings(entityID, streamPortIndex, entity.getStreamPortInputNonRedundantAudioMappings(streamPortIndex));
+							// For virtual devices, also include redundant mappings
+							if (entity.isVirtual())
+							{
+								avdecc::mappingsHelper::batchRemoveInputAudioMappings(entityID, streamPortIndex, entity.getStreamPortInputAudioMappings(streamPortIndex));
+							}
+							// No need for real devices as a Milan device must remove them automatically (we could always remove all mappings, but we want to keep short payloads if we can)
+							{
+								avdecc::mappingsHelper::batchRemoveInputAudioMappings(entityID, streamPortIndex, entity.getStreamPortInputNonRedundantAudioMappings(streamPortIndex));
+							}
 						}
 						else if (streamPortType == la::avdecc::entity::model::DescriptorType::StreamPortOutput)
 						{
-							avdecc::mappingsHelper::batchRemoveOutputAudioMappings(entityID, streamPortIndex, entity.getStreamPortOutputNonRedundantAudioMappings(streamPortIndex));
+							// For virtual devices, also include redundant mappings
+							if (entity.isVirtual())
+							{
+								avdecc::mappingsHelper::batchRemoveOutputAudioMappings(entityID, streamPortIndex, entity.getStreamPortOutputAudioMappings(streamPortIndex));
+							}
+							// No need for real devices as a Milan device must remove them automatically (we could always remove all mappings, but we want to keep short payloads if we can)
+							{
+								avdecc::mappingsHelper::batchRemoveOutputAudioMappings(entityID, streamPortIndex, entity.getStreamPortOutputNonRedundantAudioMappings(streamPortIndex));
+							}
 						}
 					}
 					catch (...)
diff --git a/src/nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.hpp b/src/nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.hpp
index 6f037662..18b5b984 100644
--- a/src/nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.hpp
+++ b/src/nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.hpp
@@ -35,7 +35,7 @@
 class StreamPortDynamicTreeWidgetItem : public QObject, public QTreeWidgetItem
 {
 public:
-	StreamPortDynamicTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::StreamPortNodeStaticModel const* const staticModel, la::avdecc::entity::model::StreamPortNodeDynamicModel const* const dynamicModel, QTreeWidget* parent = nullptr);
+	StreamPortDynamicTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::AudioUnitIndex const audioUnitIndex, la::avdecc::entity::model::DescriptorType const streamPortType, la::avdecc::entity::model::StreamPortIndex const streamPortIndex, la::avdecc::entity::model::StreamPortNodeStaticModel const* const staticModel, la::avdecc::entity::model::StreamPortNodeDynamicModel const* const dynamicModel, QTreeWidget* parent = nullptr);
 
 private:
 	void editMappingsButtonClicked();
@@ -43,6 +43,7 @@ class StreamPortDynamicTreeWidgetItem : public QObject, public QTreeWidgetItem
 	void updateMappings();
 
 	la::avdecc::UniqueIdentifier const _entityID{};
+	la::avdecc::entity::model::AudioUnitIndex const _audioUnitIndex{ 0u };
 	la::avdecc::entity::model::DescriptorType const _streamPortType{ la::avdecc::entity::model::DescriptorType::Entity };
 	la::avdecc::entity::model::StreamPortIndex const _streamPortIndex{ 0u };
 	QListWidget* _mappingsList{ nullptr };
diff --git a/src/nodeTreeDynamicWidgets/talkerStreamConnectionWidget.cpp b/src/nodeTreeDynamicWidgets/talkerStreamConnectionWidget.cpp
index b646d172..9b770904 100644
--- a/src/nodeTreeDynamicWidgets/talkerStreamConnectionWidget.cpp
+++ b/src/nodeTreeDynamicWidgets/talkerStreamConnectionWidget.cpp
@@ -106,12 +106,12 @@ void TalkerStreamConnectionWidget::updateData()
 			auto const& entityNode = controlledEntity->getEntityNode();
 
 			// Check if entity is connected as well (or if we have a ghost connection)
-			auto const& streamNode = controlledEntity->getStreamInputNode(entityNode.dynamicModel->currentConfiguration, _listenerConnection.streamIndex);
-			auto const* const dynamicModel = streamNode.dynamicModel;
+			auto const& streamNode = controlledEntity->getStreamInputNode(entityNode.dynamicModel.currentConfiguration, _listenerConnection.streamIndex);
+			auto const& dynamicModel = streamNode.dynamicModel;
 
-			if (dynamicModel->connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
+			if (dynamicModel.connectionInfo.state != la::avdecc::entity::model::StreamInputConnectionInfo::State::NotConnected)
 			{
-				if (dynamicModel->connectionInfo.talkerStream == _talkerConnection)
+				if (dynamicModel.connectionInfo.talkerStream == _talkerConnection)
 				{
 					isGhost = false;
 				}
diff --git a/src/nodeTreeWidget.cpp b/src/nodeTreeWidget.cpp
index 62c53e43..97f47640 100644
--- a/src/nodeTreeWidget.cpp
+++ b/src/nodeTreeWidget.cpp
@@ -33,6 +33,7 @@
 #include "counters/clockDomainCountersTreeWidgetItem.hpp"
 #include "counters/streamInputCountersTreeWidgetItem.hpp"
 #include "counters/streamOutputCountersTreeWidgetItem.hpp"
+#include "diagnostics/controlDiagnosticsTreeWidgetItem.hpp"
 #include "diagnostics/entityDiagnosticsTreeWidgetItem.hpp"
 #include "diagnostics/streamInputDiagnosticsTreeWidgetItem.hpp"
 #include "statistics/entityStatisticsTreeWidgetItem.hpp"
@@ -59,9 +60,37 @@
 #include <vector>
 #include <utility>
 #include <algorithm>
+#include <stdexcept>
+#include <memory>
 
 Q_DECLARE_METATYPE(la::avdecc::UniqueIdentifier)
 
+class ChangingTextItem final : public QObject
+{
+public:
+	ChangingTextItem(QTreeWidgetItem* const item) noexcept
+		: _item{ item }
+	{
+	}
+	virtual ~ChangingTextItem() noexcept override = default;
+
+	void setText(QString const& text)
+	{
+		_item->setText(1, text);
+	}
+
+	// Deleted compiler auto-generated methods
+	ChangingTextItem(ChangingTextItem const&) = delete;
+	ChangingTextItem(ChangingTextItem&&) = delete;
+	ChangingTextItem& operator=(ChangingTextItem const&) = delete;
+	ChangingTextItem& operator=(ChangingTextItem&&) = delete;
+
+private:
+	QTreeWidgetItem* _item{ nullptr };
+};
+Q_DECLARE_METATYPE(std::shared_ptr<ChangingTextItem>)
+
+
 class Label : public QWidget
 {
 	Q_OBJECT
@@ -222,6 +251,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 		createAccessItem(controlledEntity);
 
 		auto const& entity = *controlledEntity;
+		auto& controllerManager = hive::modelsLibrary::ControllerManager::getInstance();
 
 		Q_Q(NodeTreeWidget);
 
@@ -239,8 +269,8 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const staticModel = node.staticModel;
-			auto const* const dynamicModel = node.dynamicModel;
+			auto const& staticModel = node.staticModel;
+			auto const& dynamicModel = node.dynamicModel;
 
 			// Currently, use the getEntity() information, but maybe in the future the controller will have the information in its static/dynamic model
 			{
@@ -250,6 +280,10 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 				auto const ctrlCaps = e.getControllerCapabilities();
 
 				addTextItem(descriptorItem, "Entity Model ID", hive::modelsLibrary::helper::uniqueIdentifierToString(e.getEntityModelID()));
+				{
+					auto const chksumOpt = controllerManager.computeEntityModelChecksum(entity, std::uint32_t{ 1u });
+					addTextItem(descriptorItem, "AEM Checksum v1", QString::fromStdString(chksumOpt ? (*chksumOpt) : std::string{ "Must enable 'Full AEM Enumeration'" }));
+				}
 				addFlagsItem(descriptorItem, "Talker Capabilities", la::avdecc::utils::forceNumeric(talkerCaps.value()), avdecc::helper::capabilitiesToString(talkerCaps));
 				addTextItem(descriptorItem, "Talker Max Sources", QString::number(e.getTalkerStreamSources()));
 				addFlagsItem(descriptorItem, "Listener Capabilities", la::avdecc::utils::forceNumeric(listenerCaps.value()), avdecc::helper::capabilitiesToString(listenerCaps));
@@ -258,10 +292,11 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 				addTextItem(descriptorItem, "Identify Control Index", e.getIdentifyControlIndex() ? QString::number(*e.getIdentifyControlIndex()) : QString("Not Set"));
 			}
 
-			addTextItem(descriptorItem, "Vendor Name", hive::modelsLibrary::helper::localizedString(entity, staticModel->vendorNameString));
-			addTextItem(descriptorItem, "Model Name", hive::modelsLibrary::helper::localizedString(entity, staticModel->modelNameString));
-			addTextItem(descriptorItem, "Firmware Version", dynamicModel->firmwareVersion.data());
-			addTextItem(descriptorItem, "Serial Number", dynamicModel->serialNumber.data());
+			addTextItem(descriptorItem, "Vendor Name", hive::modelsLibrary::helper::localizedString(entity, staticModel.vendorNameString));
+			addTextItem(descriptorItem, "Model Name", hive::modelsLibrary::helper::localizedString(entity, staticModel.modelNameString));
+			addTextItem(descriptorItem, "Firmware Version", dynamicModel.firmwareVersion.data());
+			addTextItem(descriptorItem, "Serial Number", dynamicModel.serialNumber.data());
+			addTextItem(descriptorItem, "Unsol Supported", entity.areUnsolicitedNotificationsSupported() ? "Yes" : "No");
 
 			addTextItem(descriptorItem, "Configuration Count", node.configurations.size());
 		}
@@ -317,6 +352,23 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 				addTextItem(dynamicItem, "Association ID", e.getAssociationID() ? hive::modelsLibrary::helper::uniqueIdentifierToString(*e.getAssociationID()) : QString("Not Set"));
 			}
 
+			{
+				auto* const subscribedLabel = addChangingTextItem(dynamicItem, "Subcsribed to Unsol");
+				auto const updateSubscribedLabel = [this, subscribedLabel](la::avdecc::UniqueIdentifier const entityID, bool const isSubscribed)
+				{
+					if (entityID == _controlledEntityID)
+					{
+						subscribedLabel->setText(isSubscribed ? "Yes" : "No");
+					}
+				};
+
+				// Update text now
+				updateSubscribedLabel(_controlledEntityID, entity.isSubscribedToUnsolicitedNotifications());
+
+				// Listen for changes
+				connect(&controllerManager, &hive::modelsLibrary::ControllerManager::unsolicitedRegistrationChanged, subscribedLabel, updateSubscribedLabel);
+			}
+
 			auto* currentConfigurationItem = new QTreeWidgetItem(dynamicItem);
 			currentConfigurationItem->setText(0, "Current Configuration");
 
@@ -358,13 +410,13 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 				});
 
 			// Update now
-			configurationComboBox->setCurrentData(node.dynamicModel->currentConfiguration);
+			configurationComboBox->setCurrentData(node.dynamicModel.currentConfiguration);
 		}
 
 		// Counters (if supported by the entity)
-		if (node.dynamicModel->counters && !node.dynamicModel->counters->empty())
+		if (node.dynamicModel.counters && !node.dynamicModel.counters->empty())
 		{
-			auto* countersItem = new EntityCountersTreeWidgetItem(_controlledEntityID, *node.dynamicModel->counters, q);
+			auto* countersItem = new EntityCountersTreeWidgetItem(_controlledEntityID, *node.dynamicModel.counters, q);
 			countersItem->setText(0, "Counters");
 		}
 
@@ -386,12 +438,56 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 		createIdItem(&node);
 		// Always want to display dynamic information for configurations
 		createNameItem(controlledEntity, true, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetConfigurationName, node.descriptorIndex, node.descriptorIndex, node.descriptorIndex);
+
+		Q_Q(NodeTreeWidget);
+
+		// Static model
+		{
+			auto* descriptorItem = new QTreeWidgetItem(q);
+			descriptorItem->setText(0, "Static Info");
+
+			auto descriptorCounts = node.staticModel.descriptorCounts; // Make a copy so we can modify it without impacting the model
+
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::AudioUnit>(descriptorItem, node, node.audioUnits, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::StreamInput>(descriptorItem, node, node.streamInputs, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::StreamOutput>(descriptorItem, node, node.streamOutputs, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::JackInput>(descriptorItem, node, node.jackInputs, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::JackOutput>(descriptorItem, node, node.jackOutputs, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::AvbInterface>(descriptorItem, node, node.avbInterfaces, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::ClockSource>(descriptorItem, node, node.clockSources, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::MemoryObject>(descriptorItem, node, node.memoryObjects, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::Locale>(descriptorItem, node, node.locales, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::Control>(descriptorItem, node, node.controls, descriptorCounts);
+			addEnumeratedDescriptorType<la::avdecc::entity::model::DescriptorType::ClockDomain>(descriptorItem, node, node.clockDomains, descriptorCounts);
+
+			// Display any descriptors that are not supposed to be there
+			if (!descriptorCounts.empty())
+			{
+				auto* unsupportedDescriptorsItem = new QTreeWidgetItem(descriptorItem);
+				unsupportedDescriptorsItem->setText(0, "Invalid/unknown descriptors");
+				unsupportedDescriptorsItem->setToolTip(0, "Descriptor count that is not supposed to be declared as son of Configuration (or is unknown)");
+				for (auto const [descriptorType, count] : descriptorCounts)
+				{
+					auto const descriptorIntegralValue = la::avdecc::utils::to_integral(descriptorType);
+					if (descriptorIntegralValue > la::avdecc::utils::to_integral(la::avdecc::entity::model::DescriptorType::LAST_VALID_DESCRIPTOR))
+					{
+						auto* const item = addTextItem(unsupportedDescriptorsItem, QString{ "%1" }.arg(QString::fromStdString(la::avdecc::utils::toHexString<std::uint32_t, 6>(descriptorIntegralValue, true, true))), QString{ "%1" }.arg(count));
+						item->setToolTip(0, QString{ "Unknown descriptor type" });
+					}
+					else
+					{
+						auto* const item = addTextItem(unsupportedDescriptorsItem, QString{ "%1" }.arg(avdecc::helper::descriptorTypeToString(descriptorType)), QString{ "%1" }.arg(count));
+						item->setToolTip(0, QString{ "Invalid: Not a son of Configuration" });
+					}
+				}
+			}
+		}
 	}
 
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::AudioUnitNode const& node) noexcept override
 	{
 		createIdItem(&node);
-		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetAudioUnitName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorIndex));
 
 		Q_Q(NodeTreeWidget);
@@ -401,23 +497,28 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
+			auto const& model = node.staticModel;
 
-			addTextItem(descriptorItem, "Clock Domain Index", model->clockDomainIndex);
+			addTextItem(descriptorItem, "Clock Domain Index", model.clockDomainIndex);
+			{
+				auto* const item = addTextItem(descriptorItem, QString{ "%1 Count" }.arg(avdecc::helper::descriptorTypeToString(la::avdecc::entity::model::DescriptorType::Control)), QString{ "%1 / %2" }.arg(node.controls.size()).arg(model.numberOfControls));
+				item->setToolTip(1, QString{ "Enumerated / Defined in %1 descriptor" }.arg(avdecc::helper::descriptorTypeToString(node.descriptorType)));
+			}
 		}
 
 		// Dynamic model
 		if (isActiveConfiguration)
 		{
-			auto* dynamicItem = new AudioUnitDynamicTreeWidgetItem(_controlledEntityID, node.descriptorIndex, node.staticModel, node.dynamicModel, q);
+			auto* dynamicItem = new AudioUnitDynamicTreeWidgetItem(_controlledEntityID, node.descriptorIndex, &node.staticModel, &node.dynamicModel, q);
 			dynamicItem->setText(0, "Dynamic Info");
 		}
+		_currentAudioUnitIndex = node.descriptorIndex;
 	}
 
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::StreamInputNode const& node) noexcept override
 	{
 		createIdItem(&node);
-		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetStreamName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorType, node.descriptorIndex));
 
 		Q_Q(NodeTreeWidget);
@@ -427,31 +528,31 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
+			auto const& model = node.staticModel;
 
-			addTextItem(descriptorItem, "AVB Interface Index", model->avbInterfaceIndex);
-			addTextItem(descriptorItem, "Clock Domain Index", model->clockDomainIndex);
+			addTextItem(descriptorItem, "AVB Interface Index", model.avbInterfaceIndex);
+			addTextItem(descriptorItem, "Clock Domain Index", model.clockDomainIndex);
 		}
 
 		// Dynamic model
 		if (isActiveConfiguration)
 		{
-			auto* dynamicItem = new StreamDynamicTreeWidgetItem(_controlledEntityID, node.descriptorType, node.descriptorIndex, node.staticModel, node.dynamicModel, nullptr, q);
+			auto* dynamicItem = new StreamDynamicTreeWidgetItem(_controlledEntityID, node.descriptorType, node.descriptorIndex, &node.staticModel, &node.dynamicModel, nullptr, q);
 			dynamicItem->setText(0, "Dynamic Info");
 		}
 
 		// Counters (if supported by the entity)
 		AVDECC_ASSERT(node.descriptorType == la::avdecc::entity::model::DescriptorType::StreamInput, "Not sure why we test for StreamInput in the following statement, remove it?");
-		if (isActiveConfiguration && node.descriptorType == la::avdecc::entity::model::DescriptorType::StreamInput && node.dynamicModel->counters && !node.dynamicModel->counters->empty())
+		if (isActiveConfiguration && node.descriptorType == la::avdecc::entity::model::DescriptorType::StreamInput && node.dynamicModel.counters && !node.dynamicModel.counters->empty())
 		{
-			auto* countersItem = new StreamInputCountersTreeWidgetItem(_controlledEntityID, node.descriptorIndex, node.dynamicModel->connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected, *node.dynamicModel->counters, q);
+			auto* countersItem = new StreamInputCountersTreeWidgetItem(_controlledEntityID, node.descriptorIndex, node.dynamicModel.connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected, *node.dynamicModel.counters, q);
 			countersItem->setText(0, "Counters");
 		}
 
 		// Diagnostics
 		if (isActiveConfiguration)
 		{
-			auto* diagnosticsItem = new StreamInputDiagnosticsTreeWidgetItem(_controlledEntityID, node.descriptorIndex, node.dynamicModel->connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected, controlledEntity->getDiagnostics(), q);
+			auto* diagnosticsItem = new StreamInputDiagnosticsTreeWidgetItem(_controlledEntityID, node.descriptorIndex, node.dynamicModel.connectionInfo.state == la::avdecc::entity::model::StreamInputConnectionInfo::State::Connected, controlledEntity->getDiagnostics(), q);
 			diagnosticsItem->setText(0, "Diagnostics");
 		}
 	}
@@ -459,7 +560,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::StreamOutputNode const& node) noexcept override
 	{
 		createIdItem(&node);
-		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetStreamName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorType, node.descriptorIndex));
 
 		Q_Q(NodeTreeWidget);
@@ -469,31 +570,60 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
+			auto const& model = node.staticModel;
 
-			addTextItem(descriptorItem, "AVB Interface Index", model->avbInterfaceIndex);
-			addTextItem(descriptorItem, "Clock Domain Index", model->clockDomainIndex);
+			addTextItem(descriptorItem, "AVB Interface Index", model.avbInterfaceIndex);
+			addTextItem(descriptorItem, "Clock Domain Index", model.clockDomainIndex);
 		}
 
 		// Dynamic model
 		if (isActiveConfiguration)
 		{
-			auto* dynamicItem = new StreamDynamicTreeWidgetItem(_controlledEntityID, node.descriptorType, node.descriptorIndex, node.staticModel, nullptr, node.dynamicModel, q);
+			auto* dynamicItem = new StreamDynamicTreeWidgetItem(_controlledEntityID, node.descriptorType, node.descriptorIndex, &node.staticModel, nullptr, &node.dynamicModel, q);
 			dynamicItem->setText(0, "Dynamic Info");
 		}
 
 		// Counters (if supported by the entity)
-		if (isActiveConfiguration && node.descriptorType == la::avdecc::entity::model::DescriptorType::StreamOutput && node.dynamicModel->counters && !node.dynamicModel->counters->empty())
+		if (isActiveConfiguration && node.descriptorType == la::avdecc::entity::model::DescriptorType::StreamOutput && node.dynamicModel.counters && !node.dynamicModel.counters->empty())
 		{
-			auto* countersItem = new StreamOutputCountersTreeWidgetItem(_controlledEntityID, node.descriptorIndex, *node.dynamicModel->counters, q);
+			auto* countersItem = new StreamOutputCountersTreeWidgetItem(_controlledEntityID, node.descriptorIndex, *node.dynamicModel.counters, q);
 			countersItem->setText(0, "Counters");
 		}
 	}
 
+	void processJackNode(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::JackNode const& node) noexcept
+	{
+		createIdItem(&node);
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
+		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetJackName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorType, node.descriptorIndex));
+
+		Q_Q(NodeTreeWidget);
+
+		// Static model
+		{
+			auto* descriptorItem = new QTreeWidgetItem(q);
+			descriptorItem->setText(0, "Static Info");
+
+			auto const& model = node.staticModel;
+
+			addFlagsItem(descriptorItem, "Flags", la::avdecc::utils::forceNumeric(model.jackFlags.value()), avdecc::helper::flagsToString(model.jackFlags));
+			addTextItem(descriptorItem, "Jack Type", avdecc::helper::jackTypeToString(model.jackType));
+			{
+				auto* const item = addTextItem(descriptorItem, QString{ "%1 Count" }.arg(avdecc::helper::descriptorTypeToString(la::avdecc::entity::model::DescriptorType::Control)), QString{ "%1 / %2" }.arg(node.controls.size()).arg(model.numberOfControls));
+				item->setToolTip(1, QString{ "Enumerated / Defined in %1 descriptor" }.arg(avdecc::helper::descriptorTypeToString(node.descriptorType)));
+			}
+		}
+	}
+
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::JackNode const& node) noexcept override
+	{
+		processJackNode(controlledEntity, isActiveConfiguration, node);
+	}
+
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::AvbInterfaceNode const& node) noexcept override
 	{
 		createIdItem(&node);
-		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetAvbInterfaceName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorIndex));
 
 		Q_Q(NodeTreeWidget);
@@ -503,35 +633,35 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
-
-			addTextItem(descriptorItem, "MAC Address", la::networkInterface::NetworkInterfaceHelper::macAddressToString(model->macAddress, true));
-			addFlagsItem(descriptorItem, "Flags", la::avdecc::utils::forceNumeric(model->interfaceFlags.value()), avdecc::helper::flagsToString(model->interfaceFlags));
-			addTextItem(descriptorItem, "Clock Identity", hive::modelsLibrary::helper::uniqueIdentifierToString(model->clockIdentity));
-			addTextItem(descriptorItem, "Priority 1", hive::modelsLibrary::helper::toHexQString(model->priority1, true, true));
-			addTextItem(descriptorItem, "Clock Class", hive::modelsLibrary::helper::toHexQString(model->clockClass, true, true));
-			addTextItem(descriptorItem, "Offset Scaled Log Variance", hive::modelsLibrary::helper::toHexQString(model->offsetScaledLogVariance, true, true));
-			addTextItem(descriptorItem, "Clock Accuracy", hive::modelsLibrary::helper::toHexQString(model->clockAccuracy, true, true));
-			addTextItem(descriptorItem, "Priority 2", hive::modelsLibrary::helper::toHexQString(model->priority2, true, true));
-			addTextItem(descriptorItem, "Domain Number", hive::modelsLibrary::helper::toHexQString(model->domainNumber, true, true));
-			addTextItem(descriptorItem, "Log Sync Interval", hive::modelsLibrary::helper::toHexQString(model->logSyncInterval, true, true));
-			addTextItem(descriptorItem, "Log Announce Interval", hive::modelsLibrary::helper::toHexQString(model->logAnnounceInterval, true, true));
-			addTextItem(descriptorItem, "Log Delay Interval", hive::modelsLibrary::helper::toHexQString(model->logPDelayInterval, true, true));
-			addTextItem(descriptorItem, "Port Number", hive::modelsLibrary::helper::toHexQString(model->portNumber, true, true));
+			auto const& model = node.staticModel;
+
+			addTextItem(descriptorItem, "MAC Address", la::networkInterface::NetworkInterfaceHelper::macAddressToString(model.macAddress, true));
+			addFlagsItem(descriptorItem, "Flags", la::avdecc::utils::forceNumeric(model.interfaceFlags.value()), avdecc::helper::flagsToString(model.interfaceFlags));
+			addTextItem(descriptorItem, "Clock Identity", hive::modelsLibrary::helper::uniqueIdentifierToString(model.clockIdentity));
+			addTextItem(descriptorItem, "Priority 1", hive::modelsLibrary::helper::toHexQString(model.priority1, true, true));
+			addTextItem(descriptorItem, "Clock Class", hive::modelsLibrary::helper::toHexQString(model.clockClass, true, true));
+			addTextItem(descriptorItem, "Offset Scaled Log Variance", hive::modelsLibrary::helper::toHexQString(model.offsetScaledLogVariance, true, true));
+			addTextItem(descriptorItem, "Clock Accuracy", hive::modelsLibrary::helper::toHexQString(model.clockAccuracy, true, true));
+			addTextItem(descriptorItem, "Priority 2", hive::modelsLibrary::helper::toHexQString(model.priority2, true, true));
+			addTextItem(descriptorItem, "Domain Number", hive::modelsLibrary::helper::toHexQString(model.domainNumber, true, true));
+			addTextItem(descriptorItem, "Log Sync Interval", hive::modelsLibrary::helper::toHexQString(model.logSyncInterval, true, true));
+			addTextItem(descriptorItem, "Log Announce Interval", hive::modelsLibrary::helper::toHexQString(model.logAnnounceInterval, true, true));
+			addTextItem(descriptorItem, "Log Delay Interval", hive::modelsLibrary::helper::toHexQString(model.logPDelayInterval, true, true));
+			addTextItem(descriptorItem, "Port Number", hive::modelsLibrary::helper::toHexQString(model.portNumber, true, true));
 		}
 
 		// Dynamic model
 		if (isActiveConfiguration)
 		{
 			auto linkStatus = controlledEntity->getAvbInterfaceLinkStatus(node.descriptorIndex);
-			auto* dynamicItem = new AvbInterfaceDynamicTreeWidgetItem(_controlledEntityID, node.descriptorIndex, node.dynamicModel, linkStatus, q);
+			auto* dynamicItem = new AvbInterfaceDynamicTreeWidgetItem(_controlledEntityID, node.descriptorIndex, &node.dynamicModel, linkStatus, q);
 			dynamicItem->setText(0, "Dynamic Info");
 		}
 
 		// Counters (if supported by the entity)
-		if (isActiveConfiguration && node.dynamicModel->counters && !node.dynamicModel->counters->empty())
+		if (isActiveConfiguration && node.dynamicModel.counters && !node.dynamicModel.counters->empty())
 		{
-			auto* countersItem = new AvbInterfaceCountersTreeWidgetItem(_controlledEntityID, node.descriptorIndex, *node.dynamicModel->counters, q);
+			auto* countersItem = new AvbInterfaceCountersTreeWidgetItem(_controlledEntityID, node.descriptorIndex, *node.dynamicModel.counters, q);
 			countersItem->setText(0, "Counters");
 		}
 	}
@@ -539,7 +669,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::ClockSourceNode const& node) noexcept override
 	{
 		createIdItem(&node);
-		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetClockSourceName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorIndex));
 
 		Q_Q(NodeTreeWidget);
@@ -549,15 +679,15 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
-			auto const* const dynamicModel = node.dynamicModel;
+			auto const& model = node.staticModel;
+			auto const& dynamicModel = node.dynamicModel;
 
-			addTextItem(descriptorItem, "Clock Source Type", avdecc::helper::clockSourceTypeToString(model->clockSourceType));
-			addFlagsItem(descriptorItem, "Flags", la::avdecc::utils::forceNumeric(dynamicModel->clockSourceFlags.value()), avdecc::helper::flagsToString(dynamicModel->clockSourceFlags));
+			addTextItem(descriptorItem, "Clock Source Type", avdecc::helper::clockSourceTypeToString(model.clockSourceType));
+			addFlagsItem(descriptorItem, "Flags", la::avdecc::utils::forceNumeric(dynamicModel.clockSourceFlags.value()), avdecc::helper::flagsToString(dynamicModel.clockSourceFlags));
 
-			addTextItem(descriptorItem, "Clock Source Identifier", hive::modelsLibrary::helper::uniqueIdentifierToString(dynamicModel->clockSourceIdentifier));
-			addTextItem(descriptorItem, "Clock Source Location Type", avdecc::helper::descriptorTypeToString(model->clockSourceLocationType));
-			addTextItem(descriptorItem, "Clock Source Location Index", model->clockSourceLocationIndex);
+			addTextItem(descriptorItem, "Clock Source Identifier", hive::modelsLibrary::helper::uniqueIdentifierToString(dynamicModel.clockSourceIdentifier));
+			addTextItem(descriptorItem, "Clock Source Location Type", avdecc::helper::descriptorTypeToString(model.clockSourceLocationType));
+			addTextItem(descriptorItem, "Clock Source Location Index", model.clockSourceLocationIndex);
 		}
 	}
 
@@ -572,9 +702,9 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
+			auto const& model = node.staticModel;
 
-			addTextItem(descriptorItem, "Number of String Descriptors", model->numberOfStringDescriptors);
+			addTextItem(descriptorItem, "Number of String Descriptors", model.numberOfStringDescriptors);
 		}
 	}
 
@@ -589,20 +719,13 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
+			auto const& model = node.staticModel;
 
-			if (model)
-			{
-				auto idx = 0u;
-				for (auto const& str : model->strings)
-				{
-					addTextItem(descriptorItem, QString("String %1").arg(idx), str.str());
-					++idx;
-				}
-			}
-			else
+			auto idx = 0u;
+			for (auto const& str : model.strings)
 			{
-				addTextItem(descriptorItem, ("Not retrieved from entity"), "");
+				addTextItem(descriptorItem, QString("String %1").arg(idx), str.str());
+				++idx;
 			}
 		}
 	}
@@ -618,18 +741,22 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
+			auto const& model = node.staticModel;
 
-			addTextItem(descriptorItem, "Clock Domain Index", model->clockDomainIndex);
-			addFlagsItem(descriptorItem, "Flags", la::avdecc::utils::forceNumeric(model->portFlags.value()), avdecc::helper::flagsToString(model->portFlags));
-			addTextItem(descriptorItem, "Supports Dynamic Mapping", model->hasDynamicAudioMap ? "Yes" : "No");
+			addTextItem(descriptorItem, "Clock Domain Index", model.clockDomainIndex);
+			addFlagsItem(descriptorItem, "Flags", la::avdecc::utils::forceNumeric(model.portFlags.value()), avdecc::helper::flagsToString(model.portFlags));
+			addTextItem(descriptorItem, "Supports Dynamic Mapping", model.hasDynamicAudioMap ? "Yes" : "No");
+			{
+				auto* const item = addTextItem(descriptorItem, QString{ "%1 Count" }.arg(avdecc::helper::descriptorTypeToString(la::avdecc::entity::model::DescriptorType::Control)), QString{ "%1 / %2" }.arg(node.controls.size()).arg(model.numberOfControls));
+				item->setToolTip(1, QString{ "Enumerated / Defined in %1 descriptor" }.arg(avdecc::helper::descriptorTypeToString(node.descriptorType)));
+			}
 		}
 
 		// Dynamic model
-		auto const hasAtLeastOneDynamicInfo = node.staticModel->hasDynamicAudioMap;
+		auto const hasAtLeastOneDynamicInfo = node.staticModel.hasDynamicAudioMap;
 		if (isActiveConfiguration && hasAtLeastOneDynamicInfo)
 		{
-			auto* dynamicItem = new StreamPortDynamicTreeWidgetItem(_controlledEntityID, node.descriptorType, node.descriptorIndex, node.staticModel, node.dynamicModel, q);
+			auto* dynamicItem = new StreamPortDynamicTreeWidgetItem(_controlledEntityID, _currentAudioUnitIndex, node.descriptorType, node.descriptorIndex, &node.staticModel, &node.dynamicModel, q);
 			dynamicItem->setText(0, "Dynamic Info");
 		}
 	}
@@ -637,7 +764,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::AudioClusterNode const& node) noexcept override
 	{
 		createIdItem(&node);
-		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetAudioClusterName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorIndex));
 
 		Q_Q(NodeTreeWidget);
@@ -647,16 +774,16 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
+			auto const& model = node.staticModel;
 
-			addTextItem(descriptorItem, "Signal Type", avdecc::helper::descriptorTypeToString(model->signalType));
-			addTextItem(descriptorItem, "Signal Index", model->signalIndex);
+			addTextItem(descriptorItem, "Signal Type", avdecc::helper::descriptorTypeToString(model.signalType));
+			addTextItem(descriptorItem, "Signal Index", model.signalIndex);
 
-			addTextItem(descriptorItem, "Signal Output", model->signalOutput);
-			addTextItem(descriptorItem, "Path Latency", model->pathLatency);
-			addTextItem(descriptorItem, "Block Latency", model->blockLatency);
-			addTextItem(descriptorItem, "Channel Count", model->channelCount);
-			addTextItem(descriptorItem, "Format", avdecc::helper::audioClusterFormatToString(model->format));
+			addTextItem(descriptorItem, "Signal Output", model.signalOutput);
+			addTextItem(descriptorItem, "Path Latency", model.pathLatency);
+			addTextItem(descriptorItem, "Block Latency", model.blockLatency);
+			addTextItem(descriptorItem, "Channel Count", model.channelCount);
+			addTextItem(descriptorItem, "Format", avdecc::helper::audioClusterFormatToString(model.format));
 		}
 	}
 
@@ -671,7 +798,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
+			auto const& model = node.staticModel;
 
 			auto* mappingsIndexItem = new QTreeWidgetItem(descriptorItem);
 			mappingsIndexItem->setText(0, "Mappings");
@@ -680,7 +807,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 
 			q->setItemWidget(mappingsIndexItem, 1, listWidget);
 
-			for (auto const& mapping : model->mappings)
+			for (auto const& mapping : model.mappings)
 			{
 				listWidget->addItem(QString("%1.%2 > %3.%4").arg(mapping.streamIndex).arg(mapping.streamChannel).arg(mapping.clusterOffset).arg(mapping.clusterChannel));
 			}
@@ -697,46 +824,38 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 		}
 
 		createIdItem(&node);
-		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetControlName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorIndex));
 
 		Q_Q(NodeTreeWidget);
-		auto const* const staticModel = node.staticModel;
-		auto const* const dynamicModel = node.dynamicModel;
-		auto const valueType = staticModel->controlValueType.getType();
-
-		if (!staticModel->values)
-		{
-			auto* descriptorItem = new QTreeWidgetItem(q);
-			descriptorItem->setText(0, "Error");
-			descriptorItem->setText(1, "Invalid Descriptor");
-			return;
-		}
+		auto const& staticModel = node.staticModel;
+		auto const& dynamicModel = node.dynamicModel;
+		auto const valueType = staticModel.controlValueType.getType();
 
 		// Static model
 		{
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			addTextItem(descriptorItem, "Signal Type", avdecc::helper::descriptorTypeToString(staticModel->signalType));
-			addTextItem(descriptorItem, "Signal Index", staticModel->signalIndex);
-			addTextItem(descriptorItem, "Signal Output", staticModel->signalOutput);
+			addTextItem(descriptorItem, "Signal Type", avdecc::helper::descriptorTypeToString(staticModel.signalType));
+			addTextItem(descriptorItem, "Signal Index", staticModel.signalIndex);
+			addTextItem(descriptorItem, "Signal Output", staticModel.signalOutput);
 
-			addTextItem(descriptorItem, "Block Latency", staticModel->blockLatency);
-			addTextItem(descriptorItem, "Control Latency", staticModel->controlLatency);
-			addTextItem(descriptorItem, "Control Domain", staticModel->controlDomain);
-			addTextItem(descriptorItem, "Auto Reset Time (usec)", staticModel->resetTime);
+			addTextItem(descriptorItem, "Block Latency", staticModel.blockLatency);
+			addTextItem(descriptorItem, "Control Latency", staticModel.controlLatency);
+			addTextItem(descriptorItem, "Control Domain", staticModel.controlDomain);
+			addTextItem(descriptorItem, "Auto Reset Time (usec)", staticModel.resetTime);
 
-			addTextItem(descriptorItem, "Control Type", avdecc::helper::controlTypeToString(staticModel->controlType));
+			addTextItem(descriptorItem, "Control Type", avdecc::helper::controlTypeToString(staticModel.controlType));
 			addTextItem(descriptorItem, "Values Type", avdecc::helper::controlValueTypeToString(valueType));
-			addTextItem(descriptorItem, "Values Writable", staticModel->controlValueType.isReadOnly() ? "False" : "True");
-			addTextItem(descriptorItem, "Values Valid", staticModel->controlValueType.isUnknown() ? "False" : "True");
-			addTextItem(descriptorItem, "Values Count", dynamicModel->values.size());
+			addTextItem(descriptorItem, "Values Writable", staticModel.controlValueType.isReadOnly() ? "False" : "True");
+			addTextItem(descriptorItem, "Values Valid", staticModel.controlValueType.isUnknown() ? "False" : "True");
+			addTextItem(descriptorItem, "Values Count", dynamicModel.values.size());
 
 			// Display static values
 			if (auto const& it = s_Dispatch.find(valueType); it != s_Dispatch.end())
 			{
-				it->second->visitStaticControlValues(this, controlledEntity, descriptorItem, *staticModel, *dynamicModel);
+				it->second->visitStaticControlValues(this, controlledEntity, descriptorItem, staticModel, dynamicModel);
 			}
 			else
 			{
@@ -749,33 +868,40 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			// Display static values
 			if (auto const& it = s_Dispatch.find(valueType); it != s_Dispatch.end())
 			{
-				it->second->visitDynamicControlValues(q, _controlledEntityID, node.descriptorIndex, *staticModel, *dynamicModel);
+				it->second->visitDynamicControlValues(q, _controlledEntityID, node.descriptorIndex, staticModel, dynamicModel);
 			}
 			else
 			{
 				auto* descriptorItem = new QTreeWidgetItem(q);
 				descriptorItem->setText(0, "Dynamic Info");
-				descriptorItem->setText(0, "Value Type Not Supported");
+				descriptorItem->setText(1, "Value Type Not Supported");
 			}
 		}
+
+		// Diagnostics
+		if (isActiveConfiguration)
+		{
+			auto* diagnosticsItem = new ControlDiagnosticsTreeWidgetItem(_controlledEntityID, node.descriptorIndex, controlledEntity->getDiagnostics(), q);
+			diagnosticsItem->setText(0, "Diagnostics");
+		}
 	}
 
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::ClockDomainNode const& node) noexcept override
 	{
 		createIdItem(&node);
-		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetClockDomainName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorIndex));
 
 		Q_Q(NodeTreeWidget);
-		auto const* const model = node.staticModel;
-		auto const* const dynamicModel = node.dynamicModel;
+		auto const& model = node.staticModel;
+		auto const& dynamicModel = node.dynamicModel;
 
 		// Static model
 		{
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			addTextItem(descriptorItem, "Clock Sources count", model->clockSources.size());
+			addTextItem(descriptorItem, "Clock Sources count", model.clockSources.size());
 		}
 
 		// Dynamic model
@@ -789,7 +915,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 
 			auto* sourceComboBox = new AecpCommandComboBox<la::avdecc::entity::model::ClockSourceIndex>();
 			auto clockSources = std::remove_pointer_t<decltype(sourceComboBox)>::Data{};
-			for (auto const sourceIndex : model->clockSources)
+			for (auto const sourceIndex : model.clockSources)
 			{
 				clockSources.insert(sourceIndex);
 				/*try
@@ -844,13 +970,13 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 				});
 
 			// Update now
-			sourceComboBox->setCurrentData(dynamicModel->clockSourceIndex);
+			sourceComboBox->setCurrentData(dynamicModel.clockSourceIndex);
 		}
 
 		// Counters (if supported by the entity)
-		if (isActiveConfiguration && node.dynamicModel->counters && !node.dynamicModel->counters->empty())
+		if (isActiveConfiguration && node.dynamicModel.counters && !node.dynamicModel.counters->empty())
 		{
-			auto* countersItem = new ClockDomainCountersTreeWidgetItem(_controlledEntityID, node.descriptorIndex, *node.dynamicModel->counters, q);
+			auto* countersItem = new ClockDomainCountersTreeWidgetItem(_controlledEntityID, node.descriptorIndex, *node.dynamicModel.counters, q);
 			countersItem->setText(0, "Counters");
 		}
 	}
@@ -875,7 +1001,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const isActiveConfiguration, la::avdecc::controller::model::MemoryObjectNode const& node) noexcept override
 	{
 		createIdItem(&node);
-		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel->currentConfiguration;
+		auto const configurationIndex = controlledEntity->getEntityNode().dynamicModel.currentConfiguration;
 		createNameItem(controlledEntity, isActiveConfiguration, node, hive::modelsLibrary::ControllerManager::AecpCommandType::SetMemoryObjectName, configurationIndex, node.descriptorIndex, std::make_tuple(configurationIndex, node.descriptorIndex));
 
 		Q_Q(NodeTreeWidget);
@@ -885,24 +1011,24 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 			auto* descriptorItem = new QTreeWidgetItem(q);
 			descriptorItem->setText(0, "Static Info");
 
-			auto const* const model = node.staticModel;
-			addTextItem(descriptorItem, "Memory object type", avdecc::helper::memoryObjectTypeToString(model->memoryObjectType));
-			addTextItem(descriptorItem, "Target descriptor type", avdecc::helper::descriptorTypeToString(model->targetDescriptorType));
-			addTextItem(descriptorItem, "Target descriptor index", model->targetDescriptorIndex);
-			addTextItem(descriptorItem, "Start address", hive::modelsLibrary::helper::toHexQString(model->startAddress, false, true));
-			addTextItem(descriptorItem, "Maximum length", hive::modelsLibrary::helper::toHexQString(model->maximumLength, false, true));
+			auto const& model = node.staticModel;
+			addTextItem(descriptorItem, "Memory object type", avdecc::helper::memoryObjectTypeToString(model.memoryObjectType));
+			addTextItem(descriptorItem, "Target descriptor type", avdecc::helper::descriptorTypeToString(model.targetDescriptorType));
+			addTextItem(descriptorItem, "Target descriptor index", model.targetDescriptorIndex);
+			addTextItem(descriptorItem, "Start address", hive::modelsLibrary::helper::toHexQString(model.startAddress, false, true));
+			addTextItem(descriptorItem, "Maximum length", hive::modelsLibrary::helper::toHexQString(model.maximumLength, false, true));
 
 			// Check and add ImageItem, if this MemoryObject is a supported image type
-			checkAddImageItem(descriptorItem, "Preview", model->memoryObjectType);
+			checkAddImageItem(descriptorItem, "Preview", model.memoryObjectType);
 
 			// Check and add FirmwareUpload, if this MemoryObject is a supported firmware type
-			checkAddFirmwareItem(descriptorItem, "Firmware", model->memoryObjectType, node.descriptorIndex, model->startAddress, model->maximumLength);
+			checkAddFirmwareItem(descriptorItem, "Firmware", model.memoryObjectType, node.descriptorIndex, model.startAddress, model.maximumLength);
 		}
 
 		// Dynamic model
 		if (isActiveConfiguration)
 		{
-			auto* dynamicItem = new MemoryObjectDynamicTreeWidgetItem(_controlledEntityID, configurationIndex, node.descriptorIndex, node.dynamicModel, q);
+			auto* dynamicItem = new MemoryObjectDynamicTreeWidgetItem(_controlledEntityID, configurationIndex, node.descriptorIndex, &node.dynamicModel, q);
 			dynamicItem->setText(0, "Dynamic Info");
 		}
 	}
@@ -955,11 +1081,13 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 		// Acquire State
 		if (!controlledEntity->getCompatibilityFlags().test(la::avdecc::controller::ControlledEntity::CompatibilityFlag::Milan))
 		{
-			auto* acquireLabel = addChangingTextItem(accessItem, "Acquire State");
+			auto* const acquireLabel = addChangingTextItem(accessItem, "Acquire State");
 			auto const updateAcquireLabel = [this, acquireLabel](la::avdecc::UniqueIdentifier const entityID, la::avdecc::controller::model::AcquireState const acquireState, la::avdecc::UniqueIdentifier const owningEntity)
 			{
 				if (entityID == _controlledEntityID)
+				{
 					acquireLabel->setText(avdecc::helper::acquireStateToString(acquireState, owningEntity));
+				}
 			};
 
 			// Update text now
@@ -971,11 +1099,13 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 
 		// Lock State
 		{
-			auto* lockLabel = addChangingTextItem(accessItem, "Lock State");
+			auto* const lockLabel = addChangingTextItem(accessItem, "Lock State");
 			auto const updateLockLabel = [this, lockLabel](la::avdecc::UniqueIdentifier const entityID, la::avdecc::controller::model::LockState const lockState, la::avdecc::UniqueIdentifier const lockingEntity)
 			{
 				if (entityID == _controlledEntityID)
+				{
 					lockLabel->setText(avdecc::helper::lockStateToString(lockState, lockingEntity));
+				}
 			};
 
 			// Update text now
@@ -988,6 +1118,24 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 		return accessItem;
 	}
 
+	template<la::avdecc::entity::model::DescriptorType DescriptorType, typename DescriptorCountType>
+	void addEnumeratedDescriptorType(QTreeWidgetItem* const descriptorItem, la::avdecc::controller::model::ConfigurationNode const& node, DescriptorCountType const& counts, la::avdecc::entity::model::DescriptorCounts& descriptorCounts)
+	{
+		auto const& model = node.staticModel;
+		auto descriptorCount = 0u;
+		try
+		{
+			descriptorCount = model.descriptorCounts.at(DescriptorType);
+			// Remove this descriptor type from the list of descriptor counts
+			descriptorCounts.erase(DescriptorType);
+		}
+		catch (std::out_of_range const&)
+		{
+		}
+		auto* const item = addTextItem(descriptorItem, QString{ "%1 Count" }.arg(avdecc::helper::descriptorTypeToString(DescriptorType)), QString{ "%1 / %2" }.arg(counts.size()).arg(descriptorCount));
+		item->setToolTip(1, QString{ "Enumerated / Defined in %1 descriptor" }.arg(avdecc::helper::descriptorTypeToString(node.descriptorType)));
+	}
+
 	template<class NodeType>
 	QTreeWidgetItem* createNameItem(la::avdecc::controller::ControlledEntity const* const controlledEntity, bool const showDynamicInformation, NodeType const& node, hive::modelsLibrary::ControllerManager::AecpCommandType const commandType, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorIndex const descriptorIndex, std::any const& customData)
 	{
@@ -1000,11 +1148,11 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 		{
 			if (commandType != hive::modelsLibrary::ControllerManager::AecpCommandType::None)
 			{
-				addEditableTextItem(nameItem, "Name", node.dynamicModel->objectName.data(), commandType, descriptorIndex, customData);
+				addEditableTextItem(nameItem, "Name", node.dynamicModel.objectName.data(), commandType, descriptorIndex, customData);
 			}
 			else
 			{
-				addTextItem(nameItem, "Name", node.dynamicModel->objectName.data());
+				addTextItem(nameItem, "Name", node.dynamicModel.objectName.data());
 			}
 		}
 		else
@@ -1014,38 +1162,40 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 
 		auto* localizedNameItem = new QTreeWidgetItem(nameItem);
 		localizedNameItem->setText(0, "Localized Name");
-		localizedNameItem->setText(1, hive::modelsLibrary::helper::localizedString(*controlledEntity, configurationIndex, node.staticModel->localizedDescription));
+		localizedNameItem->setText(1, hive::modelsLibrary::helper::localizedString(*controlledEntity, configurationIndex, node.staticModel.localizedDescription));
 
 		return nameItem;
 	}
 
 	/** A label (readonly) item */
-	template<typename ValueType, typename = std::enable_if_t<std::is_move_assignable_v<ValueType>>>
-	void addTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName, ValueType itemValue)
+	template<typename ValueType, typename std::enable_if_t<std::is_arithmetic_v<ValueType> && !std::is_same_v<QString, std::decay_t<ValueType>> && std::is_move_assignable_v<ValueType> && !std::is_reference_v<ValueType> && !std::is_pointer_v<ValueType>, bool> = true>
+	QTreeWidgetItem* addTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName, ValueType const itemValue)
 	{
 		auto* item = new QTreeWidgetItem(treeWidgetItem);
 		item->setText(0, std::move(itemName));
-		item->setData(1, Qt::DisplayRole, std::move(itemValue));
+		item->setText(1, QString::number(itemValue));
+		//item->setData(1, Qt::DisplayRole, QVariant::fromValue<ValueType>(itemValue));
+		return item;
 	}
-	void addTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName, QString itemValue)
+	template<typename ValueType, typename std::enable_if_t<!std::is_arithmetic_v<ValueType> && !std::is_same_v<QString, std::decay_t<ValueType>> && std::is_move_assignable_v<ValueType> && !std::is_reference_v<ValueType> && !std::is_pointer_v<ValueType>, bool> = true>
+	QTreeWidgetItem* addTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName, ValueType const itemValue)
 	{
 		auto* item = new QTreeWidgetItem(treeWidgetItem);
 		item->setText(0, std::move(itemName));
-		item->setText(1, std::move(itemValue));
+		item->setData(1, Qt::DisplayRole, QVariant::fromValue<ValueType>(itemValue));
+		return item;
 	}
-	void addTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName, std::string const& itemValue)
+	template<typename ValueType, typename std::enable_if_t<std::is_same_v<QString, std::decay_t<ValueType>>, bool> = true>
+	QTreeWidgetItem* addTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName, ValueType&& itemValue)
 	{
-		addTextItem(treeWidgetItem, std::move(itemName), QString::fromStdString(itemValue));
-	}
-	// Not sure why we need this overload but without it compilation fails on gcc
-	void addTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName, long const& itemValue)
-	{
-		addTextItem(treeWidgetItem, std::move(itemName), QVariant::fromValue(itemValue));
+		auto* item = new QTreeWidgetItem(treeWidgetItem);
+		item->setText(0, std::move(itemName));
+		item->setText(1, std::forward<ValueType>(itemValue));
+		return item;
 	}
-	// Not sure why we need this overload but without it compilation fails on gcc
-	void addTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName, unsigned long const& itemValue)
+	QTreeWidgetItem* addTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName, std::string const& itemValue)
 	{
-		addTextItem(treeWidgetItem, std::move(itemName), QVariant::fromValue(itemValue));
+		return addTextItem(treeWidgetItem, std::move(itemName), QString::fromStdString(itemValue));
 	}
 
 	/** A flags item */
@@ -1058,17 +1208,13 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 	}
 
 	/** A changing (readonly) text item */
-	QLabel* addChangingTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName)
+	ChangingTextItem* addChangingTextItem(QTreeWidgetItem* const treeWidgetItem, QString itemName)
 	{
-		Q_Q(NodeTreeWidget);
-
 		auto* item = new QTreeWidgetItem(treeWidgetItem);
 		item->setText(0, std::move(itemName));
-
-		auto* label = new QLabel;
-		q->setItemWidget(item, 1, label);
-
-		return label;
+		auto changingTextItem = std::make_shared<ChangingTextItem>(item);
+		item->setData(1, Qt::UserRole, QVariant::fromValue(changingTextItem));
+		return changingTextItem.get();
 	}
 
 	/** An editable text entry item */
@@ -1126,11 +1272,31 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 							auto const streamIndex = std::get<2>(customTuple);
 							if (streamType == la::avdecc::entity::model::DescriptorType::StreamInput)
 							{
-								hive::modelsLibrary::ControllerManager::getInstance().setStreamInputName(_controlledEntityID, configIndex, streamIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetStreamName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetEntityName, oldText));
+								hive::modelsLibrary::ControllerManager::getInstance().setStreamInputName(_controlledEntityID, configIndex, streamIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetStreamName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetStreamName, oldText));
 							}
 							else if (streamType == la::avdecc::entity::model::DescriptorType::StreamOutput)
 							{
-								hive::modelsLibrary::ControllerManager::getInstance().setStreamOutputName(_controlledEntityID, configIndex, streamIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetStreamName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetEntityName, oldText));
+								hive::modelsLibrary::ControllerManager::getInstance().setStreamOutputName(_controlledEntityID, configIndex, streamIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetStreamName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetStreamName, oldText));
+							}
+						}
+						catch (...)
+						{
+						}
+						break;
+					case hive::modelsLibrary::ControllerManager::AecpCommandType::SetJackName:
+						try
+						{
+							auto const customTuple = std::any_cast<std::tuple<la::avdecc::entity::model::ConfigurationIndex, la::avdecc::entity::model::DescriptorType, la::avdecc::entity::model::JackIndex>>(customData);
+							auto const configIndex = std::get<0>(customTuple);
+							auto const jackType = std::get<1>(customTuple);
+							auto const jackIndex = std::get<2>(customTuple);
+							if (jackType == la::avdecc::entity::model::DescriptorType::JackInput)
+							{
+								hive::modelsLibrary::ControllerManager::getInstance().setJackInputName(_controlledEntityID, configIndex, jackIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetJackName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetJackName, oldText));
+							}
+							else if (jackType == la::avdecc::entity::model::DescriptorType::JackOutput)
+							{
+								hive::modelsLibrary::ControllerManager::getInstance().setJackOutputName(_controlledEntityID, configIndex, jackIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetJackName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetJackName, oldText));
 							}
 						}
 						catch (...)
@@ -1143,7 +1309,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 							auto const customTuple = std::any_cast<std::tuple<la::avdecc::entity::model::ConfigurationIndex, la::avdecc::entity::model::AvbInterfaceIndex>>(customData);
 							auto const configIndex = std::get<0>(customTuple);
 							auto const avbInterfaceIndex = std::get<1>(customTuple);
-							hive::modelsLibrary::ControllerManager::getInstance().setAvbInterfaceName(_controlledEntityID, configIndex, avbInterfaceIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetAvbInterfaceName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetEntityName, oldText));
+							hive::modelsLibrary::ControllerManager::getInstance().setAvbInterfaceName(_controlledEntityID, configIndex, avbInterfaceIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetAvbInterfaceName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetAvbInterfaceName, oldText));
 						}
 						catch (...)
 						{
@@ -1155,7 +1321,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 							auto const customTuple = std::any_cast<std::tuple<la::avdecc::entity::model::ConfigurationIndex, la::avdecc::entity::model::ClockSourceIndex>>(customData);
 							auto const configIndex = std::get<0>(customTuple);
 							auto const clockSourceIndex = std::get<1>(customTuple);
-							hive::modelsLibrary::ControllerManager::getInstance().setClockSourceName(_controlledEntityID, configIndex, clockSourceIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetClockSourceName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetEntityName, oldText));
+							hive::modelsLibrary::ControllerManager::getInstance().setClockSourceName(_controlledEntityID, configIndex, clockSourceIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetClockSourceName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetClockSourceName, oldText));
 						}
 						catch (...)
 						{
@@ -1167,7 +1333,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 							auto const customTuple = std::any_cast<std::tuple<la::avdecc::entity::model::ConfigurationIndex, la::avdecc::entity::model::MemoryObjectIndex>>(customData);
 							auto const configIndex = std::get<0>(customTuple);
 							auto const memoryObjectIndex = std::get<1>(customTuple);
-							hive::modelsLibrary::ControllerManager::getInstance().setMemoryObjectName(_controlledEntityID, configIndex, memoryObjectIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetMemoryObjectName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetEntityName, oldText));
+							hive::modelsLibrary::ControllerManager::getInstance().setMemoryObjectName(_controlledEntityID, configIndex, memoryObjectIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetMemoryObjectName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetMemoryObjectName, oldText));
 						}
 						catch (...)
 						{
@@ -1179,7 +1345,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 							auto const customTuple = std::any_cast<std::tuple<la::avdecc::entity::model::ConfigurationIndex, la::avdecc::entity::model::ClusterIndex>>(customData);
 							auto const configIndex = std::get<0>(customTuple);
 							auto const audioClusterIndex = std::get<1>(customTuple);
-							hive::modelsLibrary::ControllerManager::getInstance().setAudioClusterName(_controlledEntityID, configIndex, audioClusterIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetAudioClusterName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetEntityName, oldText));
+							hive::modelsLibrary::ControllerManager::getInstance().setAudioClusterName(_controlledEntityID, configIndex, audioClusterIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetAudioClusterName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetAudioClusterName, oldText));
 						}
 						catch (...)
 						{
@@ -1191,7 +1357,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 							auto const customTuple = std::any_cast<std::tuple<la::avdecc::entity::model::ConfigurationIndex, la::avdecc::entity::model::ControlIndex>>(customData);
 							auto const configIndex = std::get<0>(customTuple);
 							auto const controlIndex = std::get<1>(customTuple);
-							hive::modelsLibrary::ControllerManager::getInstance().setControlName(_controlledEntityID, configIndex, controlIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetControlName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetEntityName, oldText));
+							hive::modelsLibrary::ControllerManager::getInstance().setControlName(_controlledEntityID, configIndex, controlIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetControlName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetControlName, oldText));
 						}
 						catch (...)
 						{
@@ -1203,7 +1369,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 							auto const customTuple = std::any_cast<std::tuple<la::avdecc::entity::model::ConfigurationIndex, la::avdecc::entity::model::ClockDomainIndex>>(customData);
 							auto const configIndex = std::get<0>(customTuple);
 							auto const clockDomainIndex = std::get<1>(customTuple);
-							hive::modelsLibrary::ControllerManager::getInstance().setClockDomainName(_controlledEntityID, configIndex, clockDomainIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetClockDomainName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetEntityName, oldText));
+							hive::modelsLibrary::ControllerManager::getInstance().setClockDomainName(_controlledEntityID, configIndex, clockDomainIndex, newText, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetClockDomainName), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetClockDomainName, oldText));
 						}
 						catch (...)
 						{
@@ -1213,7 +1379,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 						try
 						{
 							auto const associationID = static_cast<la::avdecc::UniqueIdentifier>(la::avdecc::utils::convertFromString<la::avdecc::UniqueIdentifier::value_type>(newText.toStdString().c_str()));
-							hive::modelsLibrary::ControllerManager::getInstance().setAssociationID(_controlledEntityID, associationID, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetAssociationID), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetEntityName, oldText));
+							hive::modelsLibrary::ControllerManager::getInstance().setAssociationID(_controlledEntityID, associationID, textEntry->getBeginCommandHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetAssociationID), textEntry->getResultHandler(hive::modelsLibrary::ControllerManager::AecpCommandType::SetAssociationID, oldText));
 						}
 						catch (std::invalid_argument const& e)
 						{
@@ -1284,6 +1450,20 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 						});
 					break;
 				}
+				case hive::modelsLibrary::ControllerManager::AecpCommandType::SetJackName:
+				{
+					auto const customTuple = std::any_cast<std::tuple<la::avdecc::entity::model::ConfigurationIndex, la::avdecc::entity::model::DescriptorType, la::avdecc::entity::model::JackIndex>>(customData);
+					auto const configIndex = std::get<0>(customTuple);
+					auto const jackType = std::get<1>(customTuple);
+					auto const jackIndex = std::get<2>(customTuple);
+					connect(&hive::modelsLibrary::ControllerManager::getInstance(), &hive::modelsLibrary::ControllerManager::jackNameChanged, textEntry,
+						[this, textEntry, configIndex, jackType, jkIndex = jackIndex](la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ConfigurationIndex const configurationIndex, la::avdecc::entity::model::DescriptorType const descriptorType, la::avdecc::entity::model::JackIndex const jackIndex, QString const& jackName)
+						{
+							if (entityID == _controlledEntityID && configurationIndex == configIndex && descriptorType == jackType && jackIndex == jkIndex)
+								textEntry->setCurrentData(jackName);
+						});
+					break;
+				}
 				case hive::modelsLibrary::ControllerManager::AecpCommandType::SetAvbInterfaceName:
 				{
 					auto const customTuple = std::any_cast<std::tuple<la::avdecc::entity::model::ConfigurationIndex, la::avdecc::entity::model::AvbInterfaceIndex>>(customData);
@@ -1463,7 +1643,7 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 						}
 
 						// Start firmware upload dialog
-						FirmwareUploadDialog dialog{ { data.constData(), static_cast<size_t>(data.count()) }, QFileInfo(fileName).fileName(), { { _controlledEntityID, descriptorIndex, baseAddress } }, q_ptr };
+						FirmwareUploadDialog dialog{ { data.constData(), static_cast<size_t>(data.size()) }, QFileInfo(fileName).fileName(), { { _controlledEntityID, descriptorIndex, baseAddress } }, q_ptr };
 						dialog.exec();
 					}
 				});
@@ -1478,33 +1658,43 @@ class NodeTreeWidgetPrivate : public QObject, public NodeVisitor
 	Q_DECLARE_PUBLIC(NodeTreeWidget);
 
 	la::avdecc::UniqueIdentifier _controlledEntityID{};
+	la::avdecc::entity::model::AudioUnitIndex _currentAudioUnitIndex{ la::avdecc::entity::model::getInvalidDescriptorIndex() };
 };
 
-/** Linear Values */
+/** Linear Values - Clause 7.3.5.2.1 */
 template<class StaticValueType, class DynamicValueType>
 class VisitControlLinearValues final : public NodeTreeWidgetPrivate::VisitControlValues
 {
 	virtual void visitStaticControlValues(NodeTreeWidgetPrivate* self, la::avdecc::controller::ControlledEntity const* const controlledEntity, QTreeWidgetItem* const item, la::avdecc::entity::model::ControlNodeStaticModel const& staticModel, la::avdecc::entity::model::ControlNodeDynamicModel const& /*dynamicModel*/) noexcept override
 	{
-		auto valNumber = decltype(std::declval<decltype(staticModel.values)>().size()){ 0u };
-		auto const linearValues = staticModel.values.getValues<StaticValueType>(); // We have to store the copy or it will go out of scope if using it directly in the range-based loop
+		try
+		{
+			auto valNumber = decltype(std::declval<decltype(staticModel.values)>().size()){ 0u };
+			auto const linearValues = staticModel.values.getValues<StaticValueType>(); // We have to store the copy or it will go out of scope if using it directly in the range-based loop
 
-		for (auto const& val : linearValues.getValues())
+			for (auto const& val : linearValues.getValues())
+			{
+				auto* valueItem = new QTreeWidgetItem(item);
+				valueItem->setText(0, QString("Value %1").arg(valNumber));
+
+				self->addTextItem(valueItem, "Minimum", val.minimum);
+				self->addTextItem(valueItem, "Maximum", val.maximum);
+				self->addTextItem(valueItem, "Step", val.step);
+				self->addTextItem(valueItem, "Default Value", val.defaultValue);
+				self->addTextItem(valueItem, "Unit Type", ::avdecc::helper::controlValueUnitToString(val.unit.getUnit()));
+				self->addTextItem(valueItem, "Unit Multiplier", val.unit.getMultiplier());
+				auto* localizedNameItem = new QTreeWidgetItem(valueItem);
+				localizedNameItem->setText(0, "Localized Name");
+				localizedNameItem->setText(1, hive::modelsLibrary::helper::localizedString(*controlledEntity, val.localizedName));
+
+				++valNumber;
+			}
+		}
+		catch (...)
 		{
 			auto* valueItem = new QTreeWidgetItem(item);
-			valueItem->setText(0, QString("Value %1").arg(valNumber));
-
-			self->addTextItem(valueItem, "Minimum", val.minimum);
-			self->addTextItem(valueItem, "Maximum", val.maximum);
-			self->addTextItem(valueItem, "Step", val.step);
-			self->addTextItem(valueItem, "Default Value", val.defaultValue);
-			self->addTextItem(valueItem, "Unit Type", ::avdecc::helper::controlValueUnitToString(val.unit.getUnit()));
-			self->addTextItem(valueItem, "Unit Multiplier", val.unit.getMultiplier());
-			auto* localizedNameItem = new QTreeWidgetItem(valueItem);
-			localizedNameItem->setText(0, "Localized Name");
-			localizedNameItem->setText(1, hive::modelsLibrary::helper::localizedString(*controlledEntity, val.localizedName));
-
-			++valNumber;
+			valueItem->setText(0, "Values");
+			valueItem->setText(1, "Cannot unpack");
 		}
 	}
 	virtual void visitDynamicControlValues(QTreeWidget* const tree, la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::entity::model::ControlNodeStaticModel const& staticModel, la::avdecc::entity::model::ControlNodeDynamicModel const& dynamicModel) noexcept override
@@ -1514,23 +1704,60 @@ class VisitControlLinearValues final : public NodeTreeWidgetPrivate::VisitContro
 	}
 };
 
-/** Array Values */
+/** Selector Values - Clause 7.3.5.2.2 */
+template<typename SizeType, typename StaticValueType = la::avdecc::entity::model::SelectorValueStatic<SizeType>, typename DynamicValueType = la::avdecc::entity::model::SelectorValueDynamic<SizeType>>
+class VisitControlSelectorValues final : public NodeTreeWidgetPrivate::VisitControlValues
+{
+	virtual void visitStaticControlValues(NodeTreeWidgetPrivate* self, la::avdecc::controller::ControlledEntity const* const controlledEntity, QTreeWidgetItem* const item, la::avdecc::entity::model::ControlNodeStaticModel const& staticModel, la::avdecc::entity::model::ControlNodeDynamicModel const& /*dynamicModel*/) noexcept override
+	{
+		try
+		{
+			auto valNumber = decltype(std::declval<decltype(staticModel.values)>().size()){ 0u };
+			auto const& selectorValue = staticModel.values.getValues<StaticValueType>();
+
+			self->addTextItem(item, "Default Value", selectorValue.defaultValue);
+			self->addTextItem(item, "Unit Type", ::avdecc::helper::controlValueUnitToString(selectorValue.unit.getUnit()));
+		}
+		catch (...)
+		{
+			auto* valueItem = new QTreeWidgetItem(item);
+			valueItem->setText(0, "Values");
+			valueItem->setText(1, "Cannot unpack");
+		}
+	}
+	virtual void visitDynamicControlValues(QTreeWidget* const tree, la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::entity::model::ControlNodeStaticModel const& staticModel, la::avdecc::entity::model::ControlNodeDynamicModel const& dynamicModel) noexcept override
+	{
+		auto* dynamicItem = new SelectorControlValuesDynamicTreeWidgetItem<StaticValueType, DynamicValueType>(entityID, controlIndex, staticModel, dynamicModel, tree);
+		dynamicItem->setText(0, "Dynamic Info");
+	}
+};
+
+/** Array Values - Clause 7.3.5.2.3 */
 template<typename SizeType, typename StaticValueType = la::avdecc::entity::model::ArrayValueStatic<SizeType>, typename DynamicValueType = la::avdecc::entity::model::ArrayValueDynamic<SizeType>>
 class VisitControlArrayValues final : public NodeTreeWidgetPrivate::VisitControlValues
 {
 	virtual void visitStaticControlValues(NodeTreeWidgetPrivate* self, la::avdecc::controller::ControlledEntity const* const controlledEntity, QTreeWidgetItem* const item, la::avdecc::entity::model::ControlNodeStaticModel const& staticModel, la::avdecc::entity::model::ControlNodeDynamicModel const& /*dynamicModel*/) noexcept override
 	{
-		auto const& arrayValue = staticModel.values.getValues<StaticValueType>();
-
-		self->addTextItem(item, "Minimum", arrayValue.minimum);
-		self->addTextItem(item, "Maximum", arrayValue.maximum);
-		self->addTextItem(item, "Step", arrayValue.step);
-		self->addTextItem(item, "Default Value", arrayValue.defaultValue);
-		self->addTextItem(item, "Unit Type", ::avdecc::helper::controlValueUnitToString(arrayValue.unit.getUnit()));
-		self->addTextItem(item, "Unit Multiplier", arrayValue.unit.getMultiplier());
-		auto* localizedNameItem = new QTreeWidgetItem(item);
-		localizedNameItem->setText(0, "Localized Name");
-		localizedNameItem->setText(1, hive::modelsLibrary::helper::localizedString(*controlledEntity, arrayValue.localizedName));
+		try
+		{
+			auto const& arrayValue = staticModel.values.getValues<StaticValueType>();
+
+			self->addTextItem(item, "Minimum", arrayValue.minimum);
+			self->addTextItem(item, "Maximum", arrayValue.maximum);
+			self->addTextItem(item, "Step", arrayValue.step);
+			self->addTextItem(item, "Default Value", arrayValue.defaultValue);
+			self->addTextItem(item, "Unit Type", ::avdecc::helper::controlValueUnitToString(arrayValue.unit.getUnit()));
+			self->addTextItem(item, "Unit Multiplier", arrayValue.unit.getMultiplier());
+			auto* localizedNameItem = new QTreeWidgetItem(item);
+			localizedNameItem->setText(0, "Localized Name");
+			localizedNameItem->setText(1, hive::modelsLibrary::helper::localizedString(*controlledEntity, arrayValue.localizedName));
+		}
+		catch (...)
+		{
+			auto* valueItem = new QTreeWidgetItem(item);
+			valueItem->setText(0, "Values");
+			valueItem->setText(1, "Cannot unpack");
+		}
 	}
 	virtual void visitDynamicControlValues(QTreeWidget* const tree, la::avdecc::UniqueIdentifier const entityID, la::avdecc::entity::model::ControlIndex const controlIndex, la::avdecc::entity::model::ControlNodeStaticModel const& staticModel, la::avdecc::entity::model::ControlNodeDynamicModel const& dynamicModel) noexcept override
 	{
@@ -1539,7 +1766,7 @@ class VisitControlArrayValues final : public NodeTreeWidgetPrivate::VisitControl
 	}
 };
 
-/** UTF-8 String Value */
+/** UTF-8 String Value - Clause 7.3.5.2.4 */
 class VisitControlUtf8Values final : public NodeTreeWidgetPrivate::VisitControlValues
 {
 public:
@@ -1556,6 +1783,7 @@ class VisitControlUtf8Values final : public NodeTreeWidgetPrivate::VisitControlV
 
 void NodeTreeWidgetPrivate::createControlValuesDispatchTable(VisitControlValuesDispatchTable& dispatchTable)
 {
+	/** Linear Values - Clause 7.3.5.2.1 */
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlLinearInt8] = std::make_unique<VisitControlLinearValues<la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueStatic<std::int8_t>>, la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueDynamic<std::int8_t>>>>();
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlLinearUInt8] = std::make_unique<VisitControlLinearValues<la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueStatic<std::uint8_t>>, la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueDynamic<std::uint8_t>>>>();
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlLinearInt16] = std::make_unique<VisitControlLinearValues<la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueStatic<std::int16_t>>, la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueDynamic<std::int16_t>>>>();
@@ -1567,6 +1795,20 @@ void NodeTreeWidgetPrivate::createControlValuesDispatchTable(VisitControlValuesD
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlLinearFloat] = std::make_unique<VisitControlLinearValues<la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueStatic<float>>, la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueDynamic<float>>>>();
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlLinearDouble] = std::make_unique<VisitControlLinearValues<la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueStatic<double>>, la::avdecc::entity::model::LinearValues<la::avdecc::entity::model::LinearValueDynamic<double>>>>();
 
+	/** Selector Value - Clause 7.3.5.2.2 */
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorInt8] = std::make_unique<VisitControlSelectorValues<std::int8_t>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorUInt8] = std::make_unique<VisitControlSelectorValues<std::uint8_t>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorInt16] = std::make_unique<VisitControlSelectorValues<std::int16_t>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorUInt16] = std::make_unique<VisitControlSelectorValues<std::uint16_t>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorInt32] = std::make_unique<VisitControlSelectorValues<std::int32_t>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorUInt32] = std::make_unique<VisitControlSelectorValues<std::uint32_t>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorInt64] = std::make_unique<VisitControlSelectorValues<std::int64_t>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorUInt64] = std::make_unique<VisitControlSelectorValues<std::uint64_t>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorFloat] = std::make_unique<VisitControlSelectorValues<float>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorDouble] = std::make_unique<VisitControlSelectorValues<double>>();
+	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlSelectorString] = std::make_unique<VisitControlSelectorValues<la::avdecc::entity::model::LocalizedStringReference>>();
+
+	/** Array Values - Clause 7.3.5.2.3 */
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlArrayInt8] = std::make_unique<VisitControlArrayValues<std::int8_t>>();
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlArrayUInt8] = std::make_unique<VisitControlArrayValues<std::uint8_t>>();
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlArrayInt16] = std::make_unique<VisitControlArrayValues<std::int16_t>>();
@@ -1578,6 +1820,7 @@ void NodeTreeWidgetPrivate::createControlValuesDispatchTable(VisitControlValuesD
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlArrayFloat] = std::make_unique<VisitControlArrayValues<float>>();
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlArrayDouble] = std::make_unique<VisitControlArrayValues<double>>();
 
+	/** UTF-8 String Value - Clause 7.3.5.2.4 */
 	dispatchTable[la::avdecc::entity::model::ControlValueType::Type::ControlUtf8] = std::make_unique<VisitControlUtf8Values>();
 }
 
diff --git a/src/nodeVisitor.cpp b/src/nodeVisitor.cpp
index 3c966af4..ce5fcd4d 100644
--- a/src/nodeVisitor.cpp
+++ b/src/nodeVisitor.cpp
@@ -57,7 +57,9 @@ void NodeVisitor::accept(NodeVisitor* const visitor, la::avdecc::controller::Con
 		// StreamNodes
 		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::StreamInputNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::StreamInputNode const*>();
 		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::StreamOutputNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::StreamOutputNode const*>();
-		// JackNode
+		// JackNodes
+		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::JackInputNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::JackInputNode const*>();
+		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::JackOutputNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::JackOutputNode const*>();
 		// AvbInterfaceNode
 		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::AvbInterfaceNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::AvbInterfaceNode const*>();
 		// ClockSourceNode
@@ -68,8 +70,9 @@ void NodeVisitor::accept(NodeVisitor* const visitor, la::avdecc::controller::Con
 		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::LocaleNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::LocaleNode const*>();
 		// StringsNode
 		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::StringsNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::StringsNode const*>();
-		// StreamPortNode
-		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::StreamPortNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::StreamPortNode const*>();
+		// StreamPortNodes
+		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::StreamPortInputNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::StreamPortInputNode const*>();
+		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::StreamPortOutputNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::StreamPortOutputNode const*>();
 		// ExternalPortNode
 		// InternalPortNode
 		// AudioClusterNode
@@ -81,7 +84,8 @@ void NodeVisitor::accept(NodeVisitor* const visitor, la::avdecc::controller::Con
 		// ClockDomainNode
 		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::ClockDomainNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::ClockDomainNode const*>();
 		// RedundantStreamNodes
-		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::RedundantStreamNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::RedundantStreamNode const*>();
+		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::RedundantStreamInputNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::RedundantStreamInputNode const*>();
+		s_visitDispatch[std::type_index(typeid(la::avdecc::controller::model::RedundantStreamOutputNode const*))] = createNodeVisitDispatchFunctor<la::avdecc::controller::model::RedundantStreamOutputNode const*>();
 	}
 
 
diff --git a/src/nodeVisitor.hpp b/src/nodeVisitor.hpp
index 47de269f..b78af68e 100644
--- a/src/nodeVisitor.hpp
+++ b/src/nodeVisitor.hpp
@@ -67,6 +67,7 @@ class NodeVisitor
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const entity, bool const isActiveConfiguration, la::avdecc::controller::model::AudioUnitNode const& node) noexcept = 0;
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const entity, bool const isActiveConfiguration, la::avdecc::controller::model::StreamInputNode const& node) noexcept = 0;
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const entity, bool const isActiveConfiguration, la::avdecc::controller::model::StreamOutputNode const& node) noexcept = 0;
+	virtual void visit(la::avdecc::controller::ControlledEntity const* const entity, bool const isActiveConfiguration, la::avdecc::controller::model::JackNode const& node) noexcept = 0;
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const entity, bool const isActiveConfiguration, la::avdecc::controller::model::AvbInterfaceNode const& node) noexcept = 0;
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const entity, bool const isActiveConfiguration, la::avdecc::controller::model::ClockSourceNode const& node) noexcept = 0;
 	virtual void visit(la::avdecc::controller::ControlledEntity const* const entity, bool const isActiveConfiguration, la::avdecc::controller::model::LocaleNode const& node) noexcept = 0;
diff --git a/src/pch.hpp b/src/pch.hpp
index 81fb8696..c8eb112b 100644
--- a/src/pch.hpp
+++ b/src/pch.hpp
@@ -19,94 +19,53 @@
 
 #pragma once
 
-// Private Headers
-#include "aboutDialog.hpp"
-#include "activeNetworkInterfacesModel.hpp"
-#include "aecpCommandComboBox.hpp"
-#include "aecpCommandTextEntry.hpp"
-#include "controlledEntityTreeWidget.hpp"
-#include "defaults.hpp"
-#include "deviceDetailsChannelTableModel.hpp"
-#include "deviceDetailsDialog.hpp"
-#include "entityInspector.hpp"
-#include "firmwareUploadDialog.hpp"
-#include "loggerView.hpp"
-#include "mainWindow.hpp"
-#include "mappingMatrix.hpp"
-#include "multiFirmwareUpdateDialog.hpp"
-#include "networkInterfaceTypeModel.hpp"
-#include "nodeTreeWidget.hpp"
-#include "nodeVisitor.hpp"
-#include "settingsDialog.hpp"
-#include "windowsNpfHelper.hpp"
-#include "avdecc/channelConnectionManager.hpp"
-#include "avdecc/commandChain.hpp"
-#include "avdecc/controllerModel.hpp"
-#include "avdecc/helper.hpp"
-#include "avdecc/hiveLogItems.hpp"
-#include "avdecc/loggerModel.hpp"
-#include "avdecc/mappingsHelper.hpp"
-#include "avdecc/mcDomainManager.hpp"
-#include "avdecc/stringValidator.hpp"
-#include "connectionMatrix/cornerWidget.hpp"
-#include "connectionMatrix/headerView.hpp"
-#include "connectionMatrix/itemDelegate.hpp"
-#include "connectionMatrix/legendDialog.hpp"
-#include "connectionMatrix/model.hpp"
-#include "connectionMatrix/node.hpp"
-#include "connectionMatrix/paintHelper.hpp"
-#include "connectionMatrix/view.hpp"
-#include "counters/avbInterfaceCountersTreeWidgetItem.hpp"
-#include "counters/clockDomainCountersTreeWidgetItem.hpp"
-#include "counters/entityCountersTreeWidgetItem.hpp"
-#include "counters/streamInputCountersTreeWidgetItem.hpp"
-#include "counters/streamOutputCountersTreeWidgetItem.hpp"
-#include "mediaClock/domainTreeDomainNameDelegate.hpp"
-#include "mediaClock/domainTreeEntityNameDelegate.hpp"
-#include "mediaClock/domainTreeModel.hpp"
-#include "mediaClock/mediaClockManagementDialog.hpp"
-#include "mediaClock/unassignedListModel.hpp"
-#include "nodeTreeDynamicWidgets/asPathWidget.hpp"
-#include "nodeTreeDynamicWidgets/audioUnitDynamicTreeWidgetItem.hpp"
-#include "nodeTreeDynamicWidgets/avbInterfaceDynamicTreeWidgetItem.hpp"
-#include "nodeTreeDynamicWidgets/memoryObjectDynamicTreeWidgetItem.hpp"
-#include "nodeTreeDynamicWidgets/streamDynamicTreeWidgetItem.hpp"
-#include "nodeTreeDynamicWidgets/streamPortDynamicTreeWidgetItem.hpp"
-#include "profiles/profileSelectionDialog.hpp"
-#include "profiles/profiles.hpp"
-#include "settingsManager/settings.hpp"
 #ifdef USE_SPARKLE
 #	include "sparkleHelper/sparkleHelper.hpp"
 #endif // USE_SPARKLE
-#include "statistics/entityStatisticsTreeWidgetItem.hpp"
 
 // QtMate Library
-#include <QtMate/graph/inputSocket.hpp>
-#include <QtMate/graph/node.hpp>
-#include <QtMate/graph/outputSocket.hpp>
-#include <QtMate/graph/view.hpp>
+#include <QtMate/flow/flowConnection.hpp>
+#include <QtMate/flow/flowDefs.hpp>
+#include <QtMate/flow/flowInput.hpp>
+#include <QtMate/flow/flowLink.hpp>
+#include <QtMate/flow/flowNode.hpp>
+#include <QtMate/flow/flowOutput.hpp>
+#include <QtMate/flow/flowScene.hpp>
+#include <QtMate/flow/flowSceneDelegate.hpp>
+#include <QtMate/flow/flowSocket.hpp>
+#include <QtMate/flow/flowStyle.hpp>
+#include <QtMate/flow/flowView.hpp>
 #include <QtMate/material/color.hpp>
 #include <QtMate/material/colorPalette.hpp>
 #include <QtMate/material/helper.hpp>
+#include <QtMate/widgets/autoSizeLabel.hpp>
 #include <QtMate/widgets/comboBox.hpp>
 #include <QtMate/widgets/dynamicHeaderView.hpp>
 #include <QtMate/widgets/flatIconButton.hpp>
+#include <QtMate/widgets/headerViewSortSectionFilter.hpp>
+#include <QtMate/widgets/tableView.hpp>
 #include <QtMate/widgets/textEntry.hpp>
 #include <QtMate/widgets/tickableMenu.hpp>
 
 // Models Library
-#include <hive/modelsLibrary/helper.hpp>
+#include <hive/modelsLibrary/commandsExecutor.hpp>
 #include <hive/modelsLibrary/controllerManager.hpp>
-#include <hive/modelsLibrary/networkInterfacesModel.hpp>
 #include <hive/modelsLibrary/discoveredEntitiesModel.hpp>
+#include <hive/modelsLibrary/helper.hpp>
+#include <hive/modelsLibrary/modelsLibrary.hpp>
+#include <hive/modelsLibrary/networkInterfacesModel.hpp>
 
 // Widget Models Library
+#include <hive/widgetModelsLibrary/discoveredEntitiesTableItemDelegate.hpp>
+#include <hive/widgetModelsLibrary/discoveredEntitiesTableModel.hpp>
 #include <hive/widgetModelsLibrary/entityLogoCache.hpp>
 #include <hive/widgetModelsLibrary/errorItemDelegate.hpp>
 #include <hive/widgetModelsLibrary/imageItemDelegate.hpp>
+#include <hive/widgetModelsLibrary/networkInterfacesListItemDelegate.hpp>
 #include <hive/widgetModelsLibrary/networkInterfacesListModel.hpp>
 #include <hive/widgetModelsLibrary/painterHelper.hpp>
-
+#include <hive/widgetModelsLibrary/qtUserRoles.hpp>
+#include <hive/widgetModelsLibrary/widgetModelsLibrary.hpp>
 
 // Other Headers
 #include <la/networkInterfaceHelper/networkInterfaceHelper.hpp>
diff --git a/src/processHelper/processHelper.hpp b/src/processHelper/processHelper.hpp
new file mode 100644
index 00000000..a9613385
--- /dev/null
+++ b/src/processHelper/processHelper.hpp
@@ -0,0 +1,81 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <cstdint>
+
+namespace utils
+{
+template<typename Tag, typename PID>
+struct ProcessHelperBase
+{
+	using ProcessID = PID;
+
+	static ProcessID getCurrentProcessID() noexcept
+	{
+		return {};
+	}
+	static bool isProcessRunning(ProcessID const pid) noexcept
+	{
+		return {};
+	}
+};
+
+#ifdef _WIN32
+
+struct ProcessHelper : public ProcessHelperBase<struct WindowsTag, std::uint32_t>
+{
+	static ProcessID getCurrentProcessID() noexcept;
+	static bool isProcessRunning(ProcessID const pid) noexcept;
+};
+
+#elif __APPLE__
+
+struct ProcessHelper : public ProcessHelperBase<struct macOSTag, std::int32_t>
+{
+	static ProcessID getCurrentProcessID() noexcept;
+	static bool isProcessRunning(ProcessID const pid) noexcept;
+};
+
+#elif __unix__
+
+struct ProcessHelper : public ProcessHelperBase<struct UnixTag, std::uint32_t>
+{
+	static ProcessID getCurrentProcessID() noexcept;
+	static bool isProcessRunning(ProcessID const pid) noexcept;
+};
+
+#else
+
+struct ProcessHelper : public ProcessHelperBase<struct DummyTag, std::uint32_t>
+{
+	static ProcessID getCurrentProcessID() noexcept
+	{
+		return static_cast<ProcessHelper::ProcessID>(0);
+	}
+	static bool isProcessRunning(ProcessID const /*pid*/) noexcept
+	{
+		return false;
+	}
+};
+
+#endif // _WIN32
+
+} // namespace utils
diff --git a/src/processHelper/processHelper_macos.mm b/src/processHelper/processHelper_macos.mm
new file mode 100644
index 00000000..430a0288
--- /dev/null
+++ b/src/processHelper/processHelper_macos.mm
@@ -0,0 +1,84 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "processHelper.hpp"
+
+#import <sys/sysctl.h>
+#import <Foundation/Foundation.h>
+
+#include <memory>
+#include <functional>
+
+namespace utils
+{
+ProcessHelper::ProcessID ProcessHelper::getCurrentProcessID() noexcept
+{
+	return [NSProcessInfo processInfo].processIdentifier;
+}
+
+bool ProcessHelper::isProcessRunning(ProcessID const pid) noexcept
+{
+	static auto maxArgumentSize = int{ 0 };
+	if (maxArgumentSize == 0)
+	{
+		auto size = sizeof(maxArgumentSize);
+		if (sysctl((int[]){ CTL_KERN, KERN_ARGMAX }, 2, &maxArgumentSize, &size, NULL, 0) == -1)
+		{
+			maxArgumentSize = 4096; // Default
+		}
+	}
+
+	int mib[3] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL };
+	struct kinfo_proc* info;
+	size_t length;
+	int count;
+	std::unique_ptr<struct kinfo_proc, std::function<void(struct kinfo_proc*)>> scopedInfo{ nullptr, [](struct kinfo_proc* ptr)
+		{
+			if (ptr != nullptr)
+			{
+				free(ptr);
+			}
+		} };
+
+	if (sysctl(mib, 3, NULL, &length, NULL, 0) < 0)
+	{
+		return false;
+	}
+	if (!(info = (struct kinfo_proc*)malloc(length)))
+	{
+		return false;
+	}
+	scopedInfo.reset(info);
+	if (sysctl(mib, 3, info, &length, NULL, 0) < 0)
+	{
+		return false;
+	}
+	count = static_cast<decltype(count)>(length / sizeof(struct kinfo_proc));
+	for (auto i = 0; i < count; i++)
+	{
+		if (info[i].kp_proc.p_pid == pid)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+} // namespace utils
diff --git a/src/processHelper/processHelper_unix.cpp b/src/processHelper/processHelper_unix.cpp
new file mode 100644
index 00000000..a7122ece
--- /dev/null
+++ b/src/processHelper/processHelper_unix.cpp
@@ -0,0 +1,34 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "processHelper.hpp"
+
+namespace utils
+{
+ProcessHelper::ProcessID ProcessHelper::getCurrentProcessID() noexcept
+{
+	return static_cast<ProcessHelper::ProcessID>(0);
+}
+
+bool ProcessHelper::isProcessRunning(ProcessID const /*pid*/) noexcept
+{
+	return false;
+}
+
+} // namespace utils
diff --git a/src/processHelper/processHelper_win32.cpp b/src/processHelper/processHelper_win32.cpp
new file mode 100644
index 00000000..e7112597
--- /dev/null
+++ b/src/processHelper/processHelper_win32.cpp
@@ -0,0 +1,39 @@
+/*
+* Copyright (C) 2017-2023, Emilien Vallot, Christophe Calmejane and other contributors
+
+* This file is part of Hive.
+
+* Hive is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+
+* Hive is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Lesser General Public License for more details.
+
+* You should have received a copy of the GNU Lesser General Public License
+* along with Hive.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "processHelper.hpp"
+
+#include <Windows.h>
+
+namespace utils
+{
+ProcessHelper::ProcessID ProcessHelper::getCurrentProcessID() noexcept
+{
+	return static_cast<ProcessHelper::ProcessID>(GetCurrentProcessId());
+}
+
+bool ProcessHelper::isProcessRunning(ProcessID const pid) noexcept
+{
+	auto const process = OpenProcess(SYNCHRONIZE, FALSE, pid);
+	auto const ret = WaitForSingleObject(process, 0);
+	CloseHandle(process);
+	return ret == WAIT_TIMEOUT;
+}
+
+} // namespace utils
diff --git a/src/settingsDialog.cpp b/src/settingsDialog.cpp
index 1838740e..d6be7548 100644
--- a/src/settingsDialog.cpp
+++ b/src/settingsDialog.cpp
@@ -86,7 +86,7 @@ class SettingsDialogImpl final : public Ui::SettingsDialog
 		{
 			auto const lock = QSignalBlocker{ themeColorComboBox };
 			themeColorComboBox->setModel(&_themeColorModel);
-			themeColorComboBox->setModelColumn(_themeColorModel.index(qtMate::material::color::DefaultShade));
+			themeColorComboBox->setModelColumn(_themeColorModel.index(qtMate::material::color::DefaultLightShade));
 			themeColorComboBox->setCurrentIndex(settings->getValue(settings::General_ThemeColorIndex.name).toInt());
 		}
 	}
diff --git a/src/settingsDialog.ui b/src/settingsDialog.ui
index 5cceade7..2f17abfb 100644
--- a/src/settingsDialog.ui
+++ b/src/settingsDialog.ui
@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>383</width>
-    <height>768</height>
+    <width>746</width>
+    <height>424</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -25,8 +25,8 @@
   <property name="windowTitle">
    <string>Dialog</string>
   </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
+  <layout class="QGridLayout" name="gridLayout_2">
+   <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>General</string>
@@ -41,7 +41,7 @@
          <bool>false</bool>
         </property>
         <property name="text">
-         <string>Descriptor Index Starts at 0 (Coming Soon)</string>
+         <string>Descriptor Index Starts at 0 (Coming later)</string>
         </property>
        </widget>
       </item>
@@ -61,7 +61,7 @@
          <bool>false</bool>
         </property>
         <property name="text">
-         <string>Primarily Preferred Locale (Coming Soon)</string>
+         <string>Primarily Preferred Locale (Coming loon)</string>
         </property>
        </widget>
       </item>
@@ -78,7 +78,7 @@
          <bool>false</bool>
         </property>
         <property name="text">
-         <string>Secondarily Preferred Locale (Coming Soon)</string>
+         <string>Secondarily Preferred Locale (Coming loon)</string>
         </property>
        </widget>
       </item>
@@ -139,7 +139,7 @@
       <item row="7" column="0">
        <widget class="QLabel" name="themeColorLabel">
         <property name="text">
-         <string>Theme Color</string>
+         <string>Accent Color</string>
         </property>
        </widget>
       </item>
@@ -149,7 +149,7 @@
      </layout>
     </widget>
    </item>
-   <item>
+   <item row="0" column="1">
     <widget class="QGroupBox" name="groupBox_4">
      <property name="title">
       <string>Connection Matrix</string>
@@ -234,7 +234,7 @@
      </layout>
     </widget>
    </item>
-   <item>
+   <item row="1" column="0">
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
       <string>ATDECC Controller</string>
@@ -323,7 +323,7 @@
      </layout>
     </widget>
    </item>
-   <item>
+   <item row="1" column="1">
     <widget class="QGroupBox" name="groupBox_3">
      <property name="title">
       <string>Network</string>
@@ -368,20 +368,7 @@
      </layout>
     </widget>
    </item>
-   <item>
-    <spacer name="verticalSpacer">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>20</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
-   <item>
+   <item row="2" column="1">
     <widget class="QDialogButtonBox" name="buttonBox">
      <property name="standardButtons">
       <set>QDialogButtonBox::Close</set>
diff --git a/src/settingsManager/settings.hpp b/src/settingsManager/settings.hpp
index 8e352dae..a20484fb 100644
--- a/src/settingsManager/settings.hpp
+++ b/src/settingsManager/settings.hpp
@@ -29,7 +29,7 @@
 
 namespace settings
 {
-static constexpr auto ViewSettingsCurrentVersion = 3;
+static constexpr auto ViewSettingsCurrentVersion = 5;
 
 // Settings with a default initial value
 static SettingsManager::SettingDefault LastLaunchedVersion = { "LastLaunchedVersion", "" };
@@ -63,9 +63,9 @@ static SettingsManager::SettingDefault Controller_AemCacheEnabled = { "avdecc/co
 static SettingsManager::SettingDefault Controller_FullStaticModelEnabled = { "avdecc/controller/fullStaticModel", false };
 static SettingsManager::SettingDefault Controller_AdvertisingEnabled = { "avdecc/controller/enableAdvertising", true };
 #ifdef DEBUG
-static SettingsManager::SettingDefault Controller_ControllerSubID = { "avdecc/controller/controllerSubID_Debug", 4 + (hive::internals::marketingDigits > 2u ? 0x8000 : 0) };
+static SettingsManager::SettingDefault Controller_ControllerSubID = { "avdecc/controller/controllerSubID_Debug", (hive::internals::majorVersion * 100) + (hive::internals::minorVersion * 10) + 1 + (hive::internals::marketingDigits > 2u ? 0x8000 : 0) };
 #else // !DEBUG
-static SettingsManager::SettingDefault Controller_ControllerSubID = { "avdecc/controller/controllerSubID", 3 + (hive::internals::marketingDigits > 2u ? 0x8000 : 0) };
+static SettingsManager::SettingDefault Controller_ControllerSubID = { "avdecc/controller/controllerSubID", (hive::internals::majorVersion * 100) + (hive::internals::minorVersion * 10) + (hive::internals::marketingDigits > 2u ? 0x8000 : 0) };
 #endif // DEBUG
 
 // Settings with no default initial value (no need to register with the SettingsManager) - Not allowed to call registerSettingObserver for those
diff --git a/src/settingsManager/settingsManager.cpp b/src/settingsManager/settingsManager.cpp
index 66841bf5..08b7eed3 100644
--- a/src/settingsManager/settingsManager.cpp
+++ b/src/settingsManager/settingsManager.cpp
@@ -50,7 +50,7 @@ class SettingsManagerImpl final : public SettingsManager
 			// But any beta version (key digits > 2) also uses the marketing version number
 			{
 				auto const tokens = la::avdecc::utils::tokenizeString(hive::internals::cmakeVersionString.toStdString(), '.', false);
-				if (AVDECC_ASSERT_WITH_RET(tokens.size() == 4, "cmake version tokens should always be 4"))
+				if (AVDECC_ASSERT_WITH_RET(tokens.size() >= 3, "cmake version tokens should always be 3 or 4"))
 				{
 					if (hive::internals::marketingDigits > 2u || (hive::internals::marketingDigits == 2u && (tokens[0] > "1" || tokens[1] > "2")))
 					{
diff --git a/src/statistics/entityStatisticsTreeWidgetItem.cpp b/src/statistics/entityStatisticsTreeWidgetItem.cpp
index 7fc04bc6..86552409 100644
--- a/src/statistics/entityStatisticsTreeWidgetItem.cpp
+++ b/src/statistics/entityStatisticsTreeWidgetItem.cpp
@@ -19,6 +19,8 @@
 
 #include "entityStatisticsTreeWidgetItem.hpp"
 
+#include <QtMate/material/color.hpp>
+
 #include <QMenu>
 
 EntityStatisticsTreeWidgetItem::EntityStatisticsTreeWidgetItem(la::avdecc::UniqueIdentifier const entityID, std::uint64_t const aecpRetryCounter, std::uint64_t const aecpTimeoutCounter, std::uint64_t const aecpUnexpectedResponseCounter, std::chrono::milliseconds const& aecpResponseAverageTime, std::uint64_t const aemAecpUnsolicitedCounter, std::uint64_t const aemAecpUnsolicitedLossCounter, std::chrono::milliseconds const& enumerationTime, QTreeWidget* parent)
@@ -110,13 +112,13 @@ EntityStatisticsTreeWidgetItem::EntityStatisticsTreeWidgetItem(la::avdecc::Uniqu
 
 void EntityStatisticsTreeWidgetItem::setWidgetTextAndColor(EntityStatisticTreeWidgetItem& widget, std::uint64_t const value, hive::modelsLibrary::ControllerManager::StatisticsErrorCounterFlag const flag) noexcept
 {
-	auto color = QColor{ Qt::black };
+	auto color = qtMate::material::color::foregroundColor();
 	auto text = QString::number(value);
 
 	auto const errorCounterIt = _errorCounters.find(flag);
 	if (errorCounterIt != _errorCounters.end())
 	{
-		color = QColor{ Qt::red };
+		color = qtMate::material::color::foregroundErrorColorValue(qtMate::material::color::backgroundColorName(), qtMate::material::color::colorSchemeShade());
 		text += QString(" (+%1)").arg(errorCounterIt->second);
 	}
 
diff --git a/src/visibilitySettings.hpp b/src/visibilitySettings.hpp
index 42aca70a..6ff30483 100644
--- a/src/visibilitySettings.hpp
+++ b/src/visibilitySettings.hpp
@@ -40,9 +40,13 @@ struct VisibilityDefaults
 	bool controllerTableView_GrandmasterID_Visible{ true };
 	bool controllerTableView_GptpDomain_Visible{ true };
 	bool controllerTableView_InterfaceIndex_Visible{ true };
+	bool controllerTableView_MacAddress_Visible{ true };
 	bool controllerTableView_AssociationID_Visible{ true };
+	bool controllerTableView_EntityModelID_Visible{ true };
+	bool controllerTableView_FirmwareVersion_Visible{ true };
 	bool controllerTableView_MediaClockMasterID_Visible{ true };
 	bool controllerTableView_MediaClockMasterName_Visible{ true };
+	bool controllerTableView_ClockDomainLockState_Visible{ true };
 };
 
 } // namespace hive
diff --git a/src/windowsNpfHelper.hpp b/src/windowsNpfHelper.hpp
index 83c09436..3d046d59 100644
--- a/src/windowsNpfHelper.hpp
+++ b/src/windowsNpfHelper.hpp
@@ -21,7 +21,7 @@
 
 #ifdef _WIN32
 
-#include <string>
+#	include <string>
 
 namespace npf
 {
diff --git a/tools/AEMDumper/main.cpp b/tools/AEMDumper/main.cpp
index ec14341a..3f7d5553 100644
--- a/tools/AEMDumper/main.cpp
+++ b/tools/AEMDumper/main.cpp
@@ -122,16 +122,6 @@ int main(int argc, char* argv[])
 		return 0;
 	}
 
-#if 0
-	QSharedMemory lock("d2794ee0-ab5e-48a5-9189-78a9e2c40635");
-	if (!lock.create(512, QSharedMemory::ReadWrite))
-	{
-#	pragma message("TODO: Read the SM and cast to a processID. Check if that processID is still active and if not, continue.")
-		QMessageBox::critical(nullptr, {}, "An instance of this application is already running.", QMessageBox::Ok);
-		return 1;
-	}
-#endif
-
 	// Load fonts
 	if (QFontDatabase::addApplicationFont(":/MaterialIcons-Regular.ttf") == -1) // From https://material.io/icons/
 	{
diff --git a/tools/AEMDumper/mainWindow.cpp b/tools/AEMDumper/mainWindow.cpp
index 017ae1a3..97808cbb 100644
--- a/tools/AEMDumper/mainWindow.cpp
+++ b/tools/AEMDumper/mainWindow.cpp
@@ -111,7 +111,7 @@ class MainWindowImpl final : public QObject, public Ui::MainWindow
 	QSortFilterProxyModel _networkInterfacesModelProxy{ _parent };
 	qtMate::widgets::DynamicHeaderView _controllerDynamicHeaderView{ Qt::Horizontal, _parent };
 	hive::widgetModelsLibrary::DiscoveredEntitiesTableModel _controllerModel{ ControllerModelEntityDataFlags };
-	hive::widgetModelsLibrary::DiscoveredEntitiesTableItemDelegate _controllerModelItemDelegate{ _parent };
+	hive::widgetModelsLibrary::DiscoveredEntitiesTableItemDelegate _controllerModelItemDelegate{ qtMate::material::color::DefaultColor, _parent };
 	bool _shown{ false };
 	la::avdecc::entity::model::EntityTree _entityModel{};
 };