Added the original class back and changed updated class slightly; Minor changes to factory

Remove release creation for alpha & beta builds

PepperDashEssentials/UI/EssentialsTouchpanelController.cs

@@ -211,7 +211,7 @@ namespace PepperDash.Essentials
             var comm = CommFactory.GetControlPropertiesConfig(dc);
             var props = Newtonsoft.Json.JsonConvert.DeserializeObject<CrestronTouchpanelPropertiesConfig>(dc.Properties.ToString());
 
-            Debug.Console(1, "Factory Attempting to create new Generic Comm Device");
+            Debug.Console(1, "Factory Attempting to create new EssentialsTouchpanelController");
 
             var panelController = new EssentialsTouchpanelController(dc.Key, dc.Name, dc.Type, props, comm.IpIdInt);
 

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/HdMdNxM4kEControllerJoinMap.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Core.Bridges
+{
+    public class HdMdNxM4kEControllerJoinMap : JoinMapBaseAdvanced
+    {
+        [JoinName("Name")]
+        public JoinDataComplete Name = new JoinDataComplete(new JoinData() { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata() { Label = "Device Name", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+        [JoinName("EnableAutoRoute")]
+        public JoinDataComplete EnableAutoRoute = new JoinDataComplete(new JoinData() { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata() { Label = "Enable Automatic Routing on 4x1 Switchers", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("DisableAutoRoute")]
+        public JoinDataComplete DisableAutoRoute = new JoinDataComplete(new JoinData() { JoinNumber = 1, JoinSpan = 1 },
+            new JoinMetadata() { Label = "Disable Automatic Routing on 4x1 Switchers", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("InputName")]
+        public JoinDataComplete InputName = new JoinDataComplete(new JoinData() { JoinNumber = 2, JoinSpan = 8 },
+            new JoinMetadata() { Label = "Device Input Name", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+        [JoinName("InputSync")]
+        public JoinDataComplete InputSync = new JoinDataComplete(new JoinData() { JoinNumber = 2, JoinSpan = 8 },
+            new JoinMetadata() { Label = "Device Input Sync", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("OutputName")]
+        public JoinDataComplete OutputName = new JoinDataComplete(new JoinData() { JoinNumber = 11, JoinSpan = 2 },
+            new JoinMetadata() { Label = "Device Output Name", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+        [JoinName("OutputRoute")]
+        public JoinDataComplete OutputRoute = new JoinDataComplete(new JoinData() { JoinNumber = 11, JoinSpan = 2 },
+            new JoinMetadata() { Label = "Device Output Route Set/Get", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Analog });
+
+        [JoinName("OutputRoutedName")]
+        public JoinDataComplete OutputRoutedName = new JoinDataComplete(new JoinData() { JoinNumber = 16, JoinSpan = 2 },
+            new JoinMetadata() { Label = "Device Output Route Name", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Serial });
+
+        [JoinName("EnableInputHdcp")]
+        public JoinDataComplete EnableInputHdcp = new JoinDataComplete(new JoinData() { JoinNumber = 11, JoinSpan = 8 },
+            new JoinMetadata() { Label = "Device Enable Input Hdcp", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("DisableInputHdcp")]
+        public JoinDataComplete DisableInputHdcp = new JoinDataComplete(new JoinData() { JoinNumber = 21, JoinSpan = 8 },
+            new JoinMetadata() { Label = "Device Disnable Input Hdcp", JoinCapabilities = eJoinCapabilities.ToFromSIMPL, JoinType = eJoinType.Digital });
+
+        [JoinName("IsOnline")]
+        public JoinDataComplete IsOnline = new JoinDataComplete(new JoinData() { JoinNumber = 30, JoinSpan = 1 },
+            new JoinMetadata() { Label = "Device Onlne", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+
+        public HdMdNxM4kEControllerJoinMap(uint joinStart)
+            : base(joinStart, typeof(HdMdNxM4kEControllerJoinMap))
+        {
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/EssentialsDevice.cs

@@ -53,7 +53,7 @@ namespace PepperDash.Essentials.Core
 
         public ConfigSnippetAttribute(string configSnippet)
         {
-            Debug.Console(2, "Setting Description {0}", configSnippet);
+            Debug.Console(2, "Setting Config Snippet {0}", configSnippet);
             _ConfigSnippet = configSnippet;
         }
 
@@ -83,8 +83,9 @@ namespace PepperDash.Essentials.Core
             foreach (var typeName in TypeNames)
             {
                 Debug.Console(2, "Getting Description Attribute from class: '{0}'", typeof(T).FullName);
-                var attributes = typeof(T).GetCustomAttributes(typeof(DescriptionAttribute), true) as DescriptionAttribute[];
-                string description = attributes[0].Description;
+                var descriptionAttribute = typeof(T).GetCustomAttributes(typeof(DescriptionAttribute), true) as DescriptionAttribute[];
+                string description = descriptionAttribute[0].Description;
+                var snippetAttribute = typeof(T).GetCustomAttributes(typeof(ConfigSnippetAttribute), true) as ConfigSnippetAttribute[];
                 DeviceFactory.AddFactoryForType(typeName.ToLower(), description, typeof(T), BuildDevice);
             }
         }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/IProjectorInterfaces.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Core
+{
+    public interface IBasicVideoMute
+    {
+        void VideoMuteToggle();
+    }
+
+    public interface IBasicVideoMuteWithFeedback : IBasicVideoMute
+    {
+        BoolFeedback VideoMuteIsOn { get; }
+
+        void VideoMuteOn();
+        void VideoMuteOff();
+ 
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj

@@ -129,6 +129,7 @@
     <Compile Include="Bridges\JoinMaps\GenericLightingJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\GenericRelayControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\GlsOccupancySensorBaseJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\HdMdNxM4kEControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\HdMdxxxCEControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\IBasicCommunicationJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\IDigitalInputJoinMap.cs" />
@@ -158,6 +159,7 @@
     <Compile Include="Devices\DeviceFeedbackExtensions.cs" />
     <Compile Include="Devices\EssentialsBridgeableDevice.cs" />
     <Compile Include="Devices\EssentialsDevice.cs" />
+    <Compile Include="Devices\IProjectorInterfaces.cs" />
     <Compile Include="Devices\PC\InRoomPc.cs" />
     <Compile Include="Devices\PC\Laptop.cs" />
     <Compile Include="Devices\ReconfigurableDevice.cs" />

essentials-framework/Essentials DM/Essentials_DM/Chassis/HdMdNxM4kEBridgeableController.cs

@@ -0,0 +1,394 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Newtonsoft.Json;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+using PepperDash.Essentials.Core.Bridges;
+using PepperDash.Essentials.Core.Config;
+
+namespace PepperDash.Essentials.DM.Chassis
+{
+    [Description("Wrapper class for all HdMdNxM4E switchers")]
+    public class HdMdNxM4kEBridgeableController : CrestronGenericBridgeableBaseDevice, IRoutingInputsOutputs, IRouting, IHasFeedback
+    {
+        private HdMdNxM _Chassis;
+        private HdMd4x14kE _Chassis4x1;
+
+        public Dictionary<uint, string> InputNames { get; set; }
+        public Dictionary<uint, string> OutputNames { get; set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+        public FeedbackCollection<BoolFeedback> VideoInputSyncFeedbacks { get; private set; }
+        public FeedbackCollection<IntFeedback> VideoOutputRouteFeedbacks { get; private set; }
+        public FeedbackCollection<StringFeedback> InputNameFeedbacks { get; private set; }
+        public FeedbackCollection<StringFeedback> OutputNameFeedbacks { get; private set; }
+        public FeedbackCollection<StringFeedback> OutputRouteNameFeedbacks { get; private set; }
+        public FeedbackCollection<BoolFeedback> InputHdcpEnableFeedback { get; private set; }
+        public FeedbackCollection<StringFeedback> DeviceNameFeedback { get; private set; }
+        public FeedbackCollection<BoolFeedback> AutoRouteFeedback { get; private set; }
+
+        #region Constructor
+
+        public HdMdNxM4kEBridgeableController(string key, string name, HdMdNxM chassis,
+            HdMdNxM4kEBridgeablePropertiesConfig props)
+            : base(key, name, chassis)
+        {
+            _Chassis = chassis;
+            var _props = props;
+
+            InputNames = props.Inputs;
+            OutputNames = props.Outputs;
+
+            VideoInputSyncFeedbacks = new FeedbackCollection<BoolFeedback>();
+            VideoOutputRouteFeedbacks = new FeedbackCollection<IntFeedback>();
+            InputNameFeedbacks = new FeedbackCollection<StringFeedback>();
+            OutputNameFeedbacks = new FeedbackCollection<StringFeedback>();
+            OutputRouteNameFeedbacks = new FeedbackCollection<StringFeedback>();
+            InputHdcpEnableFeedback = new FeedbackCollection<BoolFeedback>();
+            DeviceNameFeedback = new FeedbackCollection<StringFeedback>();
+            AutoRouteFeedback = new FeedbackCollection<BoolFeedback>();
+
+            InputPorts = new RoutingPortCollection<RoutingInputPort>();
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+
+            DeviceNameFeedback.Add(new StringFeedback(this.Name, () => this.Name));
+
+            if (_Chassis.NumberOfInputs == 1)
+            {
+                _Chassis4x1 = _Chassis as HdMd4x14kE;
+                AutoRouteFeedback.Add(new BoolFeedback(this.Name + "-" + InputNames[1], () => _Chassis4x1.AutoModeOnFeedback.BoolValue));
+            }
+
+            for (uint i = 1; i <= _Chassis.NumberOfInputs; i++)
+            {
+                var inputName = InputNames[i];
+                _Chassis.Inputs[i].Name.StringValue = inputName;
+
+                InputPorts.Add(new RoutingInputPort(inputName, eRoutingSignalType.AudioVideo,
+                    eRoutingPortConnectionType.Hdmi, i, this));
+                VideoInputSyncFeedbacks.Add(new BoolFeedback(inputName, () => _Chassis.Inputs[i].VideoDetectedFeedback.BoolValue));
+                InputNameFeedbacks.Add(new StringFeedback(inputName, () => _Chassis.Inputs[i].Name.StringValue));
+                InputHdcpEnableFeedback.Add(new BoolFeedback(inputName, () => _Chassis.HdmiInputs[i].HdmiInputPort.HdcpSupportOnFeedback.BoolValue));
+            }
+
+            for (uint i = 1; i <= _Chassis.NumberOfOutputs; i++)
+            {
+                var outputName = OutputNames[i];
+                _Chassis.Outputs[i].Name.StringValue = outputName;
+
+                OutputPorts.Add(new RoutingOutputPort(outputName, eRoutingSignalType.AudioVideo,
+                    eRoutingPortConnectionType.Hdmi, i, this));
+                VideoOutputRouteFeedbacks.Add(new IntFeedback(outputName, () => (int)_Chassis.Outputs[i].VideoOutFeedback.Number));
+                OutputNameFeedbacks.Add(new StringFeedback(outputName, () => _Chassis.Outputs[i].Name.StringValue));
+                OutputRouteNameFeedbacks.Add(new StringFeedback(outputName, () => _Chassis.Outputs[i].VideoOutFeedback.NameFeedback.StringValue));
+            }
+
+            _Chassis.DMInputChange += new DMInputEventHandler(Chassis_DMInputChange);
+            _Chassis.DMOutputChange += new DMOutputEventHandler(Chassis_DMOutputChange);
+
+            AddPostActivationAction(AddFeedbackCollections);
+        }
+
+        #endregion
+
+        #region Methods
+
+        public void EnableHdcp(uint port)
+        {
+            if (port > _Chassis.NumberOfInputs) return;
+            if (port <= 0) return;
+
+            _Chassis.HdmiInputs[port].HdmiInputPort.HdcpSupportOn();
+            InputHdcpEnableFeedback[InputNames[port]].FireUpdate();
+        }
+
+        public void DisableHdcp(uint port)
+        {
+            if (port > _Chassis.NumberOfInputs) return;
+            if (port <= 0) return;
+
+            _Chassis.HdmiInputs[port].HdmiInputPort.HdcpSupportOff();
+            InputHdcpEnableFeedback[InputNames[port]].FireUpdate();
+        }
+
+        public void EnableAutoRoute()
+        {
+            if (_Chassis.NumberOfInputs != 1) return;
+
+            if (_Chassis4x1 == null) return;
+
+            _Chassis4x1.AutoModeOn();
+        }
+
+        public void DisableAutoRoute()
+        {
+            if (_Chassis.NumberOfInputs != 1) return;
+
+            if (_Chassis4x1 == null) return;
+
+            _Chassis4x1.AutoModeOff();
+        }
+
+        #region PostActivate
+
+        public void AddFeedbackCollections()
+        {
+            AddCollectionsToList(VideoInputSyncFeedbacks, InputHdcpEnableFeedback);
+            AddCollectionsToList(VideoOutputRouteFeedbacks);
+            AddCollectionsToList(InputNameFeedbacks, OutputNameFeedbacks, OutputRouteNameFeedbacks, DeviceNameFeedback);
+        }
+
+        #endregion
+
+        #region FeedbackCollection Methods
+
+        //Add arrays of collections
+        public void AddCollectionsToList(params FeedbackCollection<BoolFeedback>[] newFbs)
+        {
+            foreach (FeedbackCollection<BoolFeedback> fbCollection in newFbs)
+            {
+                foreach (var item in newFbs)
+                {
+                    AddCollectionToList(item);
+                }
+            }
+        }
+        public void AddCollectionsToList(params FeedbackCollection<IntFeedback>[] newFbs)
+        {
+            foreach (FeedbackCollection<IntFeedback> fbCollection in newFbs)
+            {
+                foreach (var item in newFbs)
+                {
+                    AddCollectionToList(item);
+                }
+            }
+        }
+
+        public void AddCollectionsToList(params FeedbackCollection<StringFeedback>[] newFbs)
+        {
+            foreach (FeedbackCollection<StringFeedback> fbCollection in newFbs)
+            {
+                foreach (var item in newFbs)
+                {
+                    AddCollectionToList(item);
+                }
+            }
+        }
+
+        //Add Collections
+        public void AddCollectionToList(FeedbackCollection<BoolFeedback> newFbs)
+        {
+            foreach (var f in newFbs)
+            {
+                if (f == null) continue;
+
+                AddFeedbackToList(f);
+            }
+        }
+
+        public void AddCollectionToList(FeedbackCollection<IntFeedback> newFbs)
+        {
+            foreach (var f in newFbs)
+            {
+                if (f == null) continue;
+
+                AddFeedbackToList(f);
+            }
+        }
+
+        public void AddCollectionToList(FeedbackCollection<StringFeedback> newFbs)
+        {
+            foreach (var f in newFbs)
+            {
+                if (f == null) continue;
+
+                AddFeedbackToList(f);
+            }
+        }
+
+        //Add Individual Feedbacks
+        public void AddFeedbackToList(PepperDash.Essentials.Core.Feedback newFb)
+        {
+            if (newFb == null) return;
+
+            if (!Feedbacks.Contains(newFb))
+            {
+                Feedbacks.Add(newFb);
+            }
+        }
+
+        #endregion
+
+        #region IRouting Members
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            // Try to make switch only when necessary.  The unit appears to toggle when already selected.
+            var current = _Chassis.HdmiOutputs[(uint)outputSelector].VideoOut;
+            if (current != _Chassis.HdmiInputs[(uint)inputSelector])
+                _Chassis.HdmiOutputs[(uint)outputSelector].VideoOut = _Chassis.HdmiInputs[(uint)inputSelector];
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Bridge Linking
+
+        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+        {
+            var joinMap = new HdMdNxM4kEControllerJoinMap(joinStart);
+
+            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<HdMdNxM4kEControllerJoinMap>(joinMapSerialized);
+
+            bridge.AddJoinMap(Key, joinMap);
+
+            IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+            DeviceNameFeedback[this.Name].LinkInputSig(trilist.StringInput[joinMap.Name.JoinNumber]);
+
+            if (_Chassis4x1 != null)
+            {
+                AutoRouteFeedback[this.Name + "-" + InputNames[1]].LinkInputSig(trilist.BooleanInput[joinMap.EnableAutoRoute.JoinNumber]);
+                AutoRouteFeedback[this.Name + "-" + InputNames[1]].LinkComplementInputSig(trilist.BooleanInput[joinMap.DisableAutoRoute.JoinNumber]);
+            }
+
+            for (uint i = 1; i <= _Chassis.NumberOfInputs; i++)
+            {
+                var joinIndex = i - 1;
+                //Digital
+                VideoInputSyncFeedbacks[InputNames[i]].LinkInputSig(trilist.BooleanInput[joinMap.InputSync.JoinNumber + joinIndex]);
+                InputHdcpEnableFeedback[InputNames[i]].LinkInputSig(trilist.BooleanInput[joinMap.EnableInputHdcp.JoinNumber + joinIndex]);
+                InputHdcpEnableFeedback[InputNames[i]].LinkComplementInputSig(trilist.BooleanInput[joinMap.DisableInputHdcp.JoinNumber + joinIndex]);
+                trilist.SetSigTrueAction(joinMap.EnableInputHdcp.JoinNumber + joinIndex, () => EnableHdcp(i));
+                trilist.SetSigTrueAction(joinMap.DisableInputHdcp.JoinNumber + joinIndex, () => DisableHdcp(i));
+
+                //Serial
+                InputNameFeedbacks[InputNames[i]].LinkInputSig(trilist.StringInput[joinMap.InputName.JoinNumber + joinIndex]);
+            }
+
+            for (uint i = 1; i <= _Chassis.NumberOfOutputs; i++)
+            {
+                var joinIndex = i - 1;
+                //Analog
+                VideoOutputRouteFeedbacks[OutputNames[i]].LinkInputSig(trilist.UShortInput[joinMap.OutputRoute.JoinNumber + joinIndex]);
+                trilist.SetUShortSigAction(joinMap.OutputRoute.JoinNumber + joinIndex, (a) => ExecuteSwitch(a, i, eRoutingSignalType.AudioVideo));
+
+                //Serial
+                OutputNameFeedbacks[OutputNames[i]].LinkInputSig(trilist.StringInput[joinMap.OutputName.JoinNumber + joinIndex]);
+                OutputRouteNameFeedbacks[OutputNames[i]].LinkInputSig(trilist.StringInput[joinMap.OutputRoutedName.JoinNumber + joinIndex]);
+            }
+
+            _Chassis.OnlineStatusChange += new Crestron.SimplSharpPro.OnlineStatusChangeEventHandler(Chassis_OnlineStatusChange);
+
+            trilist.OnlineStatusChange += new Crestron.SimplSharpPro.OnlineStatusChangeEventHandler((d, args) =>
+            {
+                if (args.DeviceOnLine)
+                {
+                    foreach (var feedback in Feedbacks)
+                    {
+                        feedback.FireUpdate();
+                    }
+                }
+            });
+        }
+
+
+        #endregion
+
+        #region Events
+
+        void Chassis_OnlineStatusChange(Crestron.SimplSharpPro.GenericBase currentDevice, Crestron.SimplSharpPro.OnlineOfflineEventArgs args)
+        {
+            if (args.DeviceOnLine)
+            {
+                for (uint i = 1; i <= _Chassis.NumberOfInputs; i++)
+                {
+                    _Chassis.Inputs[i].Name.StringValue = InputNames[i];
+                }
+                for (uint i = 1; i <= _Chassis.NumberOfOutputs; i++)
+                {
+                    _Chassis.Outputs[i].Name.StringValue = OutputNames[i];
+                }
+
+                foreach (var feedback in Feedbacks)
+                {
+                    feedback.FireUpdate();
+                }
+            }
+            
+        }
+
+        void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
+        {
+            if (args.EventId == DMOutputEventIds.VideoOutEventId)
+            {
+                foreach (var item in VideoOutputRouteFeedbacks)
+                {
+                    item.FireUpdate();
+                }
+            }
+        }
+
+        void Chassis_DMInputChange(Switch device, DMInputEventArgs args)
+        {
+            if (args.EventId == DMInputEventIds.VideoDetectedEventId)
+            {
+                foreach (var item in VideoInputSyncFeedbacks)
+                {
+                    item.FireUpdate();
+                }
+            }
+        }
+
+        #endregion
+
+        #region Factory
+
+        public class HdMdNxM4kEControllerFactory : EssentialsDeviceFactory<HdMdNxM4kEBridgeableController>
+        {
+            public HdMdNxM4kEControllerFactory()
+            {
+                TypeNames = new List<string>() { "hdmd4x14ke-bridgeable", "hdmd4x24ke", "hdmd6x24ke" };
+            }
+
+            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            {
+                Debug.Console(1, "Factory Attempting to create new HD-MD-NxM-4K-E Device");
+
+                var props = JsonConvert.DeserializeObject<HdMdNxM4kEBridgeablePropertiesConfig>(dc.Properties.ToString());
+
+                var type = dc.Type.ToLower();
+                var control = props.Control;
+                var ipid = control.IpIdInt;
+                var address = control.TcpSshProperties.Address;
+
+                switch (type)
+                {
+                    case ("hdmd4x14ke-bridgeable"):
+                        return new HdMdNxM4kEBridgeableController(dc.Key, dc.Name, new HdMd4x14kE(ipid, address, Global.ControlSystem), props);
+                    case ("hdmd4x24ke"):
+                        return new HdMdNxM4kEBridgeableController(dc.Key, dc.Name, new HdMd4x24kE(ipid, address, Global.ControlSystem), props);
+                    case ("hdmd6x24ke"):
+                        return new HdMdNxM4kEBridgeableController(dc.Key, dc.Name, new HdMd6x24kE(ipid, address, Global.ControlSystem), props);
+                    default:
+                        return null;
+                }
+            }
+        }
+
+        #endregion
+ 
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/Chassis/HdMdNxM4kEController.cs

@@ -1,125 +1,128 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-using Crestron.SimplSharpPro.DM;
-
-using PepperDash.Core;
-using PepperDash.Essentials.Core;
-using PepperDash.Essentials.DM.Config;
-
-namespace PepperDash.Essentials.DM.Chassis
-{
-	public class HdMdNxM4kEController : Device, IRoutingInputsOutputs, IRouting
-	{
-		public HdMdNxM Chassis { get; private set; }
-
-		public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
-		public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
-
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="name"></param>
-		/// <param name="chassis"></param>
-		public HdMdNxM4kEController(string key, string name, HdMdNxM chassis, 
-			HdMdNxM4kEPropertiesConfig props)
-			: base(key, name)
-		{
-			Chassis = chassis;
-
-			// logical ports
-			InputPorts = new RoutingPortCollection<RoutingInputPort>();
-			for (uint i = 1; i <= 4; i++)
-			{
-				InputPorts.Add(new RoutingInputPort("hdmiIn" + i, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-					eRoutingPortConnectionType.Hdmi, i, this));
-			}
-			OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
-			OutputPorts.Add(new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
-				eRoutingPortConnectionType.Hdmi, null, this));
-
-			// physical settings
-			if (props != null && props.Inputs != null)
-			{
-				foreach (var kvp in props.Inputs)
-				{
-					// strip "hdmiIn"
-					var inputNum =  Convert.ToUInt32(kvp.Key.Substring(6));
-
-					var port = chassis.HdmiInputs[inputNum].HdmiInputPort;
-					// set hdcp disables
-					if (kvp.Value.DisableHdcp)
-					{
-						Debug.Console(0, this, "Configuration disables HDCP support on {0}", kvp.Key);
-						port.HdcpSupportOff();
-					}
-					else
-						port.HdcpSupportOn();
-				}
-			}
-		}
-
-		public override bool CustomActivate()
-		{
-			var result = Chassis.Register();
-			if (result != Crestron.SimplSharpPro.eDeviceRegistrationUnRegistrationResponse.Success)
-			{
-				Debug.Console(0, this, "Device registration failed: {0}", result);
-				return false;
-			}
-
-			return base.CustomActivate();
-		}
-
-
-
-		#region IRouting Members
-
-		public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
-		{
-			// Try to make switch only when necessary.  The unit appears to toggle when already selected.
-			var current = Chassis.HdmiOutputs[1].VideoOut;
-			if(current != Chassis.HdmiInputs[(uint)inputSelector])
-				Chassis.HdmiOutputs[1].VideoOut = Chassis.HdmiInputs[(uint)inputSelector];
-		}
-
-		#endregion
-
-		/////////////////////////////////////////////////////
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="name"></param>
-		/// <param name="type"></param>
-		/// <param name="properties"></param>
-		/// <returns></returns>
-		public static HdMdNxM4kEController GetController(string key, string name,
-			string type, HdMdNxM4kEPropertiesConfig properties)
-		{
-			try
-			{
-				var ipid = properties.Control.IpIdInt;
-				var address = properties.Control.TcpSshProperties.Address;
-
-				type = type.ToLower();
-				if (type == "hdmd4x14ke")
-				{
-					var chassis = new HdMd4x14kE(ipid, address, Global.ControlSystem);
-					return new HdMdNxM4kEController(key, name, chassis, properties);
-				}
-				return null;
-			}
-			catch (Exception e)
-			{
-				Debug.Console(0, "ERROR Creating device key {0}: \r{1}", key, e);
-				return null;
-			}
-		}
-	}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DM;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.DM.Config;
+
+namespace PepperDash.Essentials.DM.Chassis
+{
+    public class HdMdNxM4kEController : Device, IRoutingInputsOutputs, IRouting
+    {
+        public HdMdNxM Chassis { get; private set; }
+
+        public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
+        public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="chassis"></param>
+        public HdMdNxM4kEController(string key, string name, HdMdNxM chassis,
+            HdMdNxM4kEPropertiesConfig props)
+            : base(key, name)
+        {
+            Chassis = chassis;
+
+            // logical ports
+            InputPorts = new RoutingPortCollection<RoutingInputPort>();
+            for (uint i = 1; i <= 4; i++)
+            {
+                InputPorts.Add(new RoutingInputPort("hdmiIn" + i, eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.Hdmi, i, this));
+            }
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+            OutputPorts.Add(new RoutingOutputPort(DmPortName.HdmiOut, eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Hdmi, null, this));
+
+            // physical settings
+            if (props != null && props.Inputs != null)
+            {
+                foreach (var kvp in props.Inputs)
+                {
+                    // strip "hdmiIn"
+                    var inputNum = Convert.ToUInt32(kvp.Key.Substring(6));
+
+                    var port = chassis.HdmiInputs[inputNum].HdmiInputPort;
+                    // set hdcp disables
+                    if (kvp.Value.DisableHdcp)
+                    {
+                        Debug.Console(0, this, "Configuration disables HDCP support on {0}", kvp.Key);
+                        port.HdcpSupportOff();
+                    }
+                    else
+                        port.HdcpSupportOn();
+                }
+            }
+        }
+
+        public override bool CustomActivate()
+        {
+            var result = Chassis.Register();
+            if (result != Crestron.SimplSharpPro.eDeviceRegistrationUnRegistrationResponse.Success)
+            {
+                Debug.Console(0, this, "Device registration failed: {0}", result);
+                return false;
+            }
+
+            return base.CustomActivate();
+        }
+
+
+
+        #region IRouting Members
+
+        public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType signalType)
+        {
+            // Try to make switch only when necessary.  The unit appears to toggle when already selected.
+            var current = Chassis.HdmiOutputs[1].VideoOut;
+            if (current != Chassis.HdmiInputs[(uint)inputSelector])
+                Chassis.HdmiOutputs[1].VideoOut = Chassis.HdmiInputs[(uint)inputSelector];
+        }
+
+        #endregion
+
+        /////////////////////////////////////////////////////
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="name"></param>
+        /// <param name="type"></param>
+        /// <param name="properties"></param>
+        /// <returns></returns>
+        public static HdMdNxM4kEController GetController(string key, string name,
+            string type, HdMdNxM4kEPropertiesConfig properties)
+        {
+            try
+            {
+                var ipid = properties.Control.IpIdInt;
+                var address = properties.Control.TcpSshProperties.Address;
+
+                type = type.ToLower();
+                if (type == "hdmd4x14ke")
+                {
+                    Debug.Console(0, @"The 'hdmd4x14ke' device is not an Essentials Bridgeable device.  
+                        If an essentials Bridgeable Device is required, use the 'hdmd4x14ke-bridgeable' type");
+  
+                    var chassis = new HdMd4x14kE(ipid, address, Global.ControlSystem);
+                    return new HdMdNxM4kEController(key, name, chassis, properties);
+                }
+                return null;
+            }
+            catch (Exception e)
+            {
+                Debug.Console(0, "ERROR Creating device key {0}: \r{1}", key, e);
+                return null;
+            }
+        }
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/Config/HdMdNxM4kEPropertiesConfig.cs

@@ -8,16 +8,28 @@ using Newtonsoft.Json;
 using PepperDash.Core;
 
 namespace PepperDash.Essentials.DM.Config
-{
-	/// <summary>
-	/// Defines the properties section of HdMdNxM boxes
-	/// </summary>
-	public class HdMdNxM4kEPropertiesConfig
-	{
-		[JsonProperty("control")]
-		public ControlPropertiesConfig Control { get; set; }
-
-		[JsonProperty("inputs")]
-		public Dictionary<string, InputPropertiesConfig> Inputs { get; set; }
-	}
+{
+    /// <summary>
+    /// Defines the properties section of HdMdNxM boxes
+    /// </summary>
+    public class HdMdNxM4kEPropertiesConfig
+    {
+        [JsonProperty("control")]
+        public ControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("inputs")]
+        public Dictionary<string, InputPropertiesConfig> Inputs { get; set; }
+    }
+
+    public class HdMdNxM4kEBridgeablePropertiesConfig
+    {
+        [JsonProperty("control")]
+        public ControlPropertiesConfig Control { get; set; }
+
+        [JsonProperty("inputs")]
+        public Dictionary<uint, string> Inputs { get; set; }
+
+        [JsonProperty("outputs")]
+        public Dictionary<uint, string> Outputs { get; set; }
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/Config/InputPropertiesConfig.cs

@@ -1,15 +1,16 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
-
-namespace PepperDash.Essentials.DM.Config
-{
-	public class InputPropertiesConfig
-	{
-		public string Name { get; set; }
-
-		public bool DisableHdcp { get; set; }
-	}
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.DM.Config
+{
+    public class InputPropertiesConfig
+    {
+        public string Name { get; set; }
+
+        public bool DisableHdcp { get; set; }
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/PepperDash_Essentials_DM.csproj

@@ -99,7 +99,9 @@
     <Compile Include="Chassis\DmpsAudioOutputController.cs" />
     <Compile Include="Chassis\DmpsInternalVirtualDmTxController.cs" />
     <Compile Include="Chassis\DmpsRoutingController.cs" />
+    <Compile Include="Chassis\HdMdNxM4kEBridgeableController.cs" />
     <Compile Include="Chassis\HdMdNxM4kEController.cs" />
+    <Compile Include="Config\InputPropertiesConfig.cs" />
     <Compile Include="Endpoints\DGEs\DmDge200CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZ100CController.cs" />
     <Compile Include="Endpoints\Receivers\DmRmc4kZScalerCController.cs" />
@@ -112,7 +114,6 @@
     <Compile Include="Config\DmTxConfig.cs" />
     <Compile Include="Config\DMChassisConfig.cs" />
     <Compile Include="Config\HdMdNxM4kEPropertiesConfig.cs" />
-    <Compile Include="Config\InputPropertiesConfig.cs" />
     <Compile Include="DmPortName.cs" />
     <Compile Include="Endpoints\DGEs\Dge100Controller.cs" />
     <Compile Include="Endpoints\DGEs\DgePropertiesConfig.cs" />

essentials-framework/Essentials Devices Common/Essentials Devices Common/Display/InputInterfaces.cs

@@ -12,6 +12,6 @@ namespace PepperDash.Essentials.Devices.Displays
     public interface IInputHdmi4 { void InputHdmi4(); }
     public interface IInputDisplayPort1 { void InputDisplayPort1(); }
     public interface IInputDisplayPort2 { void InputDisplayPort2(); }
-    public interface IInputVga1 { void InputVga1(); }
-
+    public interface IInputVga1 { void InputVga1(); }
+
 }