Merge pull request #358 from DarthAffe/bugfix/layout-saving

Fix custom LED data type not being determined correctly

RGB.NET.Core/Positioning/Scale.cs

@@ -50,6 +50,12 @@ public readonly struct Scale : IEquatable<Scale>
 
     #region Methods
 
+    /// <summary>
+    /// Converts the <see cref="Horizontal"/> and <see cref="Vertical"/> value of this <see cref="Scale"/> to a human-readable string.
+    /// </summary>
+    /// <returns>A string that contains the <see cref="Horizontal"/> and <see cref="Vertical"/> value of this <see cref="Scale"/>. For example "[Horizontal: 1, Vertical: 0.5]".</returns>
+    public override string ToString() => $"[Horizontal: {Horizontal}, Vertical: {Vertical}]\"";
+
     /// <summary>
     /// Tests whether the specified <see cref="Scale"/> is equivalent to this <see cref="Scale" />.
     /// </summary>

RGB.NET.Devices.Wooting/Enum/WootingDeviceType.cs

@@ -18,7 +18,12 @@ public enum WootingDeviceType
     Keyboard = 2,
 
     /// <summary>
-    /// Full Size keyboard. E.g. Wooting Two
+    /// 60 percent keyboard, E.g. Wooting 60HE
     /// </summary>
-    KeyboardSixtyPercent = 3
+    KeyboardSixtyPercent = 3,
+    
+    /// <summary>
+    /// Three key keypad. E.g. Wooting Uwu
+    /// </summary>
+    Keypad3Keys = 4,
 }

RGB.NET.Devices.Wooting/Enum/WootingLayoutType.cs

@@ -13,6 +13,7 @@ namespace RGB.NET.Devices.Wooting.Enum;
 /// </remarks>
 public enum WootingLayoutType
 {
+    Unknown = -1,
     ANSI = 0,
     ISO = 1
 }

RGB.NET.Devices.Wooting/Generic/WootingLedMappings.cs

@@ -1,15 +1,15 @@
-// ReSharper disable InconsistentNaming
+// ReSharper disable InconsistentNaming
 
+using System.Collections.Generic;
 using RGB.NET.Core;
 using RGB.NET.Devices.Wooting.Enum;
-using System.Collections.Generic;
 
-namespace RGB.NET.Devices.Wooting.Keyboard;
+namespace RGB.NET.Devices.Wooting.Generic;
 
 /// <summary>
 /// Contains all the hardware-id mappings for Wooting devices.
 /// </summary>
-internal static class WootingKeyboardLedMappings
+internal static class WootingLedMappings
 {
     #region Properties & Fields
 
@@ -305,6 +305,36 @@ internal static class WootingKeyboardLedMappings
         { LedId.Keyboard_Function, (5, 13) }
     };
 
+    private static readonly Dictionary<LedId, (int row, int column)> ThreeKeyKeypad = new()
+    {
+        //left (from top to bottom)
+        [LedId.LedStripe1] = (1, 0),
+        [LedId.LedStripe2] = (2, 0),
+        [LedId.LedStripe3] = (3, 0),
+        
+        //bottom (from left to right)
+        [LedId.LedStripe4] = (4, 1),
+        [LedId.LedStripe5] = (4, 2),
+        [LedId.LedStripe6] = (4, 4),
+        [LedId.LedStripe7] = (4, 5),
+        
+        //right (from bottom to top)
+        [LedId.LedStripe8] = (3, 6),
+        [LedId.LedStripe9] = (2, 6),
+        [LedId.LedStripe10] = (1, 6),
+        
+        //top (from right to left)
+        [LedId.LedStripe11] = (0, 6),
+        [LedId.LedStripe12] = (0, 4),
+        [LedId.LedStripe13] = (0, 2),
+        [LedId.LedStripe14] = (0, 0),
+        
+        //analog keys
+        [LedId.Keypad1] = (2, 1),
+        [LedId.Keypad2] = (2, 3),
+        [LedId.Keypad3] = (2, 5),
+    };
+
     /// <summary>
     /// Contains all the hardware-id mappings for Wooting devices.
     /// </summary>
@@ -312,7 +342,8 @@ internal static class WootingKeyboardLedMappings
     {
         [WootingDeviceType.Keyboard] = Fullsize,
         [WootingDeviceType.KeyboardTKL] = TKL,
-        [WootingDeviceType.KeyboardSixtyPercent] = SixtyPercent
+        [WootingDeviceType.KeyboardSixtyPercent] = SixtyPercent,
+        [WootingDeviceType.Keypad3Keys] = ThreeKeyKeypad
     };
 
     #endregion

RGB.NET.Devices.Wooting/Generic/WootingRGBDevice.cs

@@ -1,4 +1,5 @@
 using RGB.NET.Core;
+using RGB.NET.Devices.Wooting.Native;
 
 namespace RGB.NET.Devices.Wooting.Generic;
 
@@ -23,4 +24,17 @@ public abstract class WootingRGBDevice<TDeviceInfo> : AbstractRGBDevice<TDeviceI
     }
 
     #endregion
+
+
+    #region Methods
+
+    public override void Dispose()
+    {
+        _WootingSDK.SelectDevice(DeviceInfo.WootingDeviceIndex);
+        _WootingSDK.Reset();
+
+        base.Dispose();
+    }
+    
+    #endregion
 }

RGB.NET.Devices.Wooting/Helper/EnumExtension.cs

@@ -1,34 +0,0 @@
-using System;
-using System.ComponentModel;
-using System.Reflection;
-
-namespace RGB.NET.Devices.Wooting.Helper;
-
-/// <summary>
-/// Offers some extensions and helper-methods for enum related things.
-/// </summary>
-internal static class EnumExtension
-{
-    /// <summary>
-    /// Gets the value of the <see cref="DescriptionAttribute"/>.
-    /// </summary>
-    /// <param name="source">The enum value to get the description from.</param>
-    /// <returns>The value of the <see cref="DescriptionAttribute"/> or the <see cref="System.Enum.ToString()" /> result of the source.</returns>
-    internal static string GetDescription(this System.Enum source)
-        => source.GetAttribute<DescriptionAttribute>()?.Description ?? source.ToString();
-        
-    /// <summary>
-    /// Gets the attribute of type T.
-    /// </summary>
-    /// <param name="source">The enum value to get the attribute from</param>
-    /// <typeparam name="T">The generic attribute type</typeparam>
-    /// <returns>The <see cref="Attribute"/>.</returns>
-    private static T? GetAttribute<T>(this System.Enum source)
-        where T : Attribute
-    {
-        FieldInfo? fi = source.GetType().GetField(source.ToString());
-        if (fi == null) return null;
-        T[] attributes = (T[])fi.GetCustomAttributes(typeof(T), false);
-        return attributes.Length > 0 ? attributes[0] : null;
-    }
-}

RGB.NET.Devices.Wooting/Keyboard/WootingKeyboardRGBDevice.cs

@@ -37,22 +37,14 @@ public sealed class WootingKeyboardRGBDevice : WootingRGBDevice<WootingKeyboardR
 
     private void InitializeLayout()
     {
-        Dictionary<LedId, (int row, int column)> mapping = WootingKeyboardLedMappings.Mapping[DeviceInfo.WootingDeviceType];
+        Dictionary<LedId, (int row, int column)> mapping = WootingLedMappings.Mapping[DeviceInfo.WootingDeviceType];
 
         foreach (KeyValuePair<LedId, (int row, int column)> led in mapping)
             AddLed(led.Key, new Point(led.Value.column * 19, led.Value.row * 19), new Size(19, 19));
     }
 
     /// <inheritdoc />
-    protected override object GetLedCustomData(LedId ledId) => WootingKeyboardLedMappings.Mapping[DeviceInfo.WootingDeviceType][ledId];
+    protected override object GetLedCustomData(LedId ledId) => WootingLedMappings.Mapping[DeviceInfo.WootingDeviceType][ledId];
-
-    public override void Dispose()
-    {
-        _WootingSDK.SelectDevice(DeviceInfo.WootingDeviceIndex);
-        _WootingSDK.Reset();
-
-        base.Dispose();
-    }
 
     #endregion
 }

RGB.NET.Devices.Wooting/Keypad/WootingKeypadRGBDevice.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using RGB.NET.Core;
+using RGB.NET.Devices.Wooting.Generic;
+using RGB.NET.Devices.Wooting.Keyboard;
+
+namespace RGB.NET.Devices.Wooting.Keypad;
+
+/// <inheritdoc cref="WootingRGBDevice{TDeviceInfo}" />
+/// <summary>
+/// Represents a Wooting keyboard.
+/// </summary>
+public sealed class WootingKeypadRGBDevice : WootingRGBDevice<WootingKeypadRGBDeviceInfo>, IKeypad
+{
+    #region Constructors
+
+    /// <inheritdoc />
+    /// <summary>
+    /// Initializes a new instance of the <see cref="T:RGB.NET.Devices.Wooting.Keyboard.WootingKeypadRGBDevice" /> class.
+    /// </summary>
+    /// <param name="info">The specific information provided by Wooting for the keyboard</param>
+    /// <param name="updateQueue">The update queue used to update this device.</param>
+    internal WootingKeypadRGBDevice(WootingKeypadRGBDeviceInfo info, IUpdateQueue updateQueue)
+        : base(info, updateQueue)
+    {
+        InitializeLayout();
+    }
+
+    #endregion
+
+    #region Methods
+
+    private void InitializeLayout()
+    {
+        Dictionary<LedId, (int row, int column)> mapping = WootingLedMappings.Mapping[DeviceInfo.WootingDeviceType];
+
+        foreach (KeyValuePair<LedId, (int row, int column)> led in mapping)
+            AddLed(led.Key, new Point(led.Value.column * 19, led.Value.row * 19), new Size(19, 19));
+    }
+
+    /// <inheritdoc />
+    protected override object GetLedCustomData(LedId ledId) => WootingLedMappings.Mapping[DeviceInfo.WootingDeviceType][ledId];
+
+    #endregion
+}

RGB.NET.Devices.Wooting/Keypad/WootingKeypadRGBDeviceInfo.cs

@@ -0,0 +1,17 @@
+using RGB.NET.Core;
+using RGB.NET.Devices.Wooting.Generic;
+using RGB.NET.Devices.Wooting.Native;
+
+namespace RGB.NET.Devices.Wooting.Keypad;
+
+/// <summary>
+/// Represents a generic information for a <see cref="T:RGB.NET.Devices.Wooting.Keypad.WootingKeypadRGBDevice" />.
+/// </summary>
+public sealed class WootingKeypadRGBDeviceInfo : WootingRGBDeviceInfo
+{
+    internal WootingKeypadRGBDeviceInfo(_WootingDeviceInfo deviceInfo, byte deviceIndex)
+        : base(RGBDeviceType.Keypad, deviceInfo, deviceIndex)
+    {
+        
+    }
+}

RGB.NET.Devices.Wooting/Native/_WootingDeviceInfo.cs

@@ -17,11 +17,13 @@ internal struct _WootingDeviceInfo
 
     internal byte MaxColumns { get; private set; }
 
-    internal byte KeycodeLimit { get; private set; }
+    internal byte MaxLedIndex { get; private set; }
 
     internal WootingDeviceType DeviceType { get; private set; }
 
-    internal bool V2Interface { get; set; }
+    internal bool V2Interface { get; private set; }
 
     internal WootingLayoutType LayoutType { get; private set; }
+    
+    internal bool UsesSmallPackets { get; private set; }
 }

RGB.NET.Devices.Wooting/WootingDeviceProvider.cs

@@ -2,8 +2,10 @@
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using RGB.NET.Core;
+using RGB.NET.Devices.Wooting.Enum;
 using RGB.NET.Devices.Wooting.Generic;
 using RGB.NET.Devices.Wooting.Keyboard;
+using RGB.NET.Devices.Wooting.Keypad;
 using RGB.NET.Devices.Wooting.Native;
 
 namespace RGB.NET.Devices.Wooting;
@@ -100,7 +102,15 @@ public sealed class WootingDeviceProvider : AbstractRGBDeviceProvider
                     _WootingSDK.SelectDevice(i);
                     _WootingDeviceInfo nativeDeviceInfo = (_WootingDeviceInfo)Marshal.PtrToStructure(_WootingSDK.GetDeviceInfo(), typeof(_WootingDeviceInfo))!;
                     
-                    yield return new WootingKeyboardRGBDevice(new WootingKeyboardRGBDeviceInfo(nativeDeviceInfo, i), updateQueue);
+                    //Uwu non-rgb returns zero here.
+                    if (nativeDeviceInfo.MaxLedIndex == 0)
+                        continue;
+
+                    yield return nativeDeviceInfo.DeviceType switch
+                    {
+                        WootingDeviceType.Keypad3Keys => new WootingKeypadRGBDevice(new WootingKeypadRGBDeviceInfo(nativeDeviceInfo, i), updateQueue),
+                        _ => new WootingKeyboardRGBDevice(new WootingKeyboardRGBDeviceInfo(nativeDeviceInfo, i), updateQueue),
+                    };
                 }
             }
         }

RGB.NET.Layout/DeviceLayout.cs

@@ -174,7 +174,7 @@ public class DeviceLayout : IDeviceLayout
     /// <returns>The deserialized custom data object.</returns>
     protected virtual object? GetCustomData(object? customData, Type? type)
     {
-        XmlNode? node = (customData as XmlNode) ?? (customData as IEnumerable<XmlNode>)?.FirstOrDefault()?.ParentNode; //HACK DarthAffe 16.01.2021: This gives us the CustomData-Node
+        XmlNode? node = (customData as XmlNode) ?? (customData as IEnumerable<XmlNode>)?.FirstOrDefault(x => x.ParentNode != null)?.ParentNode; //HACK DarthAffe 16.01.2021: This gives us the CustomData-Node
         if ((node == null) || (type == null)) return null;
 
         using MemoryStream ms = new();

RGB.NET.Layout/LayoutExtension.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Xml.Serialization;
 using RGB.NET.Core;
 
 namespace RGB.NET.Layout;
@@ -51,4 +53,48 @@ public static class LayoutExtension
                 device.RemoveLed(led);
         }
     }
+
+    /// <summary>
+    /// Saves the specified layout to the given location.
+    /// </summary>
+    /// <param name="layout">The layout to save.</param>
+    /// <param name="targetFile">The location to save to.</param>
+    public static void Save(this IDeviceLayout layout, string targetFile)
+    {
+        using FileStream fs = new(targetFile, FileMode.Create);
+        layout.Save(fs);
+    }
+
+    /// <summary>
+    /// Saves the specified layout to the given stream.
+    /// </summary>
+    /// <param name="layout">The layout to save.</param>
+    /// <param name="stream">The stream to save to.</param>
+    public static void Save(this IDeviceLayout layout, Stream stream)
+    {
+        Type? customDataType = layout.CustomData?.GetType();
+        Type? customLedDataType = layout.Leds.FirstOrDefault(x => x.CustomData != null)?.CustomData?.GetType();
+
+        Type[] customTypes;
+        if ((customDataType != null) && (customLedDataType != null))
+            customTypes = new[] { customDataType, customLedDataType };
+        else if (customDataType != null)
+            customTypes = new[] { customDataType };
+        else if (customLedDataType != null)
+            customTypes = new[] { customLedDataType };
+        else
+            customTypes = Array.Empty<Type>();
+
+        if (layout is DeviceLayout deviceLayout)
+        {
+            deviceLayout.InternalCustomData = deviceLayout.CustomData;
+
+            foreach (ILedLayout led in deviceLayout.Leds)
+                if (led is LedLayout ledLayout)
+                    ledLayout.InternalCustomData = ledLayout.CustomData;
+        }
+
+        XmlSerializer serializer = new(typeof(DeviceLayout), null, customTypes, null, null);
+        serializer.Serialize(stream, layout);
+    }
 }