add shortcuts.cs

add shortcuts.cs and part of keyboard.cs,and little fix in raw_keyboard.cs

com.unity.uiwidgets/Runtime/service/raw_keyboard.cs

 using System.Collections.Generic;
 using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.services;
 using UnityEngine;
 
 namespace Unity.UIWidgets.service {
+        
+        public static readonly Dictionary<PhysicalKeyboardKey, LogicalKeyboardKey> _keysPressed = new Dictionary<PhysicalKeyboardKey, LogicalKeyboardKey>();
+        
+        public HashSet<LogicalKeyboardKey> keysPressed 
+        {
+            get {
+                HashSet<LogicalKeyboardKey> keyboardKeys = new HashSet<LogicalKeyboardKey>();
+                foreach (var value in _keysPressed.Values) {
+                    keyboardKeys.Add(value);
+                }
+                return keyboardKeys;
+            }
+        }
 
         RawKeyboard() {
             

com.unity.uiwidgets/Runtime/services/keyboard_key.cs

+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Unity.UIWidgets.foundation;
+
+namespace Unity.UIWidgets.services 
+{
+    public abstract class KeyboardKey : Diagnosticable
+    {
+        protected KeyboardKey() { }
+    }
+    
+    public class LogicalKeyboardKey : KeyboardKey, IEquatable<LogicalKeyboardKey> 
+    {
+        public bool Equals(LogicalKeyboardKey other)
+        {
+            if (ReferenceEquals(null, other)) {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other)) {
+                return true;
+            }
+
+            return keyId == other.keyId;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj)) {
+                return true;
+            }
+
+            if (obj.GetType() != GetType()) {
+                return false;
+            }
+
+            return Equals((LogicalKeyboardKey) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hashCode = (int)keyId;
+                hashCode = (hashCode * 397) ^ (debugName != null ? debugName.GetHashCode() : 0);
+                hashCode = (hashCode * 397) ^ (keyLabel != null ? keyLabel.GetHashCode() : 0);
+                return hashCode;
+            }
+        }
+
+        protected LogicalKeyboardKey(long keyId, string debugName = null, string keyLabel = null) : base()
+        {
+            D.assert(keyId != null);
+            this.keyId = keyId;
+            this.debugName = debugName;
+            this.keyLabel = keyLabel;
+        }
+        
+        public readonly long keyId;
+          
+        public readonly string debugName;
+
+        public readonly string keyLabel;
+
+        public static LogicalKeyboardKey findKeyByKeyId(int keyId) => _knownLogicalKeys[keyId];
+
+        public static bool isControlCharacter(string label) 
+        {
+            if (label.Length > 1) 
+            {
+              return false;
+            }
+            int codeUnit = label[0];
+            return (codeUnit <= 0x1f && codeUnit >= 0x00) || (codeUnit >= 0x7f && codeUnit <= 0x9f);
+        }
+          
+        public bool  isAutogenerated 
+        {
+            get 
+            {
+                return (keyId & autogeneratedMask) != 0;
+            }
+        }
+
+        public HashSet<LogicalKeyboardKey> synonyms 
+        {
+            get {
+                HashSet<LogicalKeyboardKey> result = new HashSet<LogicalKeyboardKey>();
+                LogicalKeyboardKey item = _synonyms[this];
+                if (item == null) {
+                    return result;
+                }
+                result.Add(item: item);
+                return result;
+            }
+        }
+        
+        public static HashSet<LogicalKeyboardKey> collapseSynonyms(HashSet<LogicalKeyboardKey> input) 
+        { 
+            HashSet<LogicalKeyboardKey> result = new HashSet<LogicalKeyboardKey>();
+            foreach (LogicalKeyboardKey key in input) 
+            {
+                LogicalKeyboardKey synonym = _synonyms[key];
+                result.Add(synonym ?? key);
+            }
+            return result;
+        }
+
+      
+      public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+        base.debugFillProperties(properties);
+        properties.add(new StringProperty("keyId", keyId.ToString().PadLeft(8,'\0'), showName: true));
+        properties.add(new StringProperty("keyLabel", keyLabel, showName: true));
+        properties.add(new StringProperty("debugName", debugName, showName: true, defaultValue: null));
+      }
+      
+      /// Mask for the 32-bit value portion of the key code.
+      ///
+      /// This is used by platform-specific code to generate Flutter key codes.
+      public static readonly long valueMask = 0x000FFFFFFFF;
+      
+      /// Mask for the platform prefix portion of the key code.
+      ///
+      /// This is used by platform-specific code to generate Flutter key codes.
+      public static readonly long platformMask = 0x0FF00000000;
+
+      /// Mask for the auto-generated bit portion of the key code.
+      ///
+      /// This is used by platform-specific code to generate new Flutter key codes
+      /// for keys which are not recognized.
+      public static readonly long autogeneratedMask = 0x10000000000;
+      
+      /// Mask for the synonym pseudo-keys generated for keys which appear in more
+      /// than one place on the keyboard.
+      ///
+      /// IDs in this range are used to represent keys which appear in multiple
+      /// places on the keyboard, such as the SHIFT, ALT, CTRL, and numeric keypad
+      /// keys. These key codes will never be generated by the key event system, but
+      /// may be used in key maps to represent the union of all the keys of each
+      /// type in order to match them.
+      ///
+      /// To look up the synonyms that are defined, look in the [synonyms] map.
+      public static readonly long synonymMask = 0x20000000000;
+
+      /// The code prefix for keys which have a Unicode representation.
+      ///
+      /// This is used by platform-specific code to generate Flutter key codes.
+      public static readonly long unicodePlane = 0x00000000000;
+
+      /// The code prefix for keys which do not have a Unicode representation.
+      ///
+      /// This is used by platform-specific code to generate Flutter key codes using
+      /// HID Usage codes.
+      public static readonly long hidPlane = 0x00100000000;
+
+      /// Represents the logical "None" key on the keyboard.
+      ///
+      /// See the function [RawKeyEvent.logicalKey] for more information.
+      public static readonly LogicalKeyboardKey none = new LogicalKeyboardKey(0x00100000000, debugName: foundation_.kReleaseMode ? null : "None");
+
+        /// Represents the logical "Control Left" key on the keyboard.
+      ///
+      /// See the function [RawKeyEvent.logicalKey] for more information.
+      public static readonly LogicalKeyboardKey controlLeft = new LogicalKeyboardKey(0x001000700e0, debugName: foundation_.kReleaseMode ? null : "Control Left");
+
+      /// Represents the logical "Shift Left" key on the keyboard.
+      ///
+      /// See the function [RawKeyEvent.logicalKey] for more information.
+      public static readonly LogicalKeyboardKey shiftLeft = new LogicalKeyboardKey(0x001000700e1, debugName: foundation_.kReleaseMode ? null : "Shift Left");
+
+      /// Represents the logical "Alt Left" key on the keyboard.
+      ///
+      /// See the function [RawKeyEvent.logicalKey] for more information.
+      public static readonly LogicalKeyboardKey altLeft = new LogicalKeyboardKey(0x001000700e2, debugName: foundation_.kReleaseMode ? null : "Alt Left");
+
+      /// Represents the logical "Meta Left" key on the keyboard.
+      ///
+      /// See the function [RawKeyEvent.logicalKey] for more information.
+      public static readonly LogicalKeyboardKey metaLeft = new LogicalKeyboardKey(0x001000700e3, debugName: foundation_.kReleaseMode ? null : "Meta Left");
+
+      /// Represents the logical "Control Right" key on the keyboard.
+      ///
+      /// See the function [RawKeyEvent.logicalKey] for more information.
+      public static readonly LogicalKeyboardKey controlRight = new LogicalKeyboardKey(0x001000700e4, debugName: foundation_.kReleaseMode ? null : "Control Right");
+
+      /// Represents the logical "Shift Right" key on the keyboard.
+      ///
+      /// See the function [RawKeyEvent.logicalKey] for more information.
+      public static readonly LogicalKeyboardKey shiftRight = new LogicalKeyboardKey(0x001000700e5, debugName: foundation_.kReleaseMode ? null : "Shift Right");
+
+      /// Represents the logical "Alt Right" key on the keyboard.
+      ///
+      /// See the function [RawKeyEvent.logicalKey] for more information.
+      public static readonly LogicalKeyboardKey altRight = new LogicalKeyboardKey(0x001000700e6, debugName: foundation_.kReleaseMode ? null : "Alt Right");
+
+      /// Represents the logical "Meta Right" key on the keyboard.
+      ///
+      /// See the function [RawKeyEvent.logicalKey] for more information.
+      public static readonly LogicalKeyboardKey metaRight = new LogicalKeyboardKey(0x001000700e7, debugName: foundation_.kReleaseMode ? null : "Meta Right");
+
+      /// Represents the logical "Shift" key on the keyboard.
+      ///
+      /// This key represents the union of the keys {shiftLeft, shiftRight} when
+      /// comparing keys. This key will never be generated directly, its main use is
+      /// in defining key maps.
+      public static readonly LogicalKeyboardKey shift = new LogicalKeyboardKey(0x201000700e1, debugName: foundation_.kReleaseMode ? null : "Shift");
+
+      /// Represents the logical "Meta" key on the keyboard.
+      ///
+      /// This key represents the union of the keys {metaLeft, metaRight} when
+      /// comparing keys. This key will never be generated directly, its main use is
+      /// in defining key maps.
+      public static readonly LogicalKeyboardKey meta = new LogicalKeyboardKey(0x201000700e3, debugName: foundation_.kReleaseMode ? null : "Meta");
+
+      /// Represents the logical "Alt" key on the keyboard.
+      ///
+      /// This key represents the union of the keys {altLeft, altRight} when
+      /// comparing keys. This key will never be generated directly, its main use is
+      /// in defining key maps.
+      public static readonly LogicalKeyboardKey alt = new LogicalKeyboardKey(0x201000700e2, debugName: foundation_.kReleaseMode ? null : "Alt");
+
+      /// Represents the logical "Control" key on the keyboard.
+      ///
+      /// This key represents the union of the keys {controlLeft, controlRight} when
+      /// comparing keys. This key will never be generated directly, its main use is
+      /// in defining key maps.
+      public static readonly LogicalKeyboardKey control = new LogicalKeyboardKey(0x201000700e0, debugName: foundation_.kReleaseMode ? null : "Control");
+
+      // A list of all predefined constant LogicalKeyboardKeys so they can be
+      // searched.
+      public static readonly Dictionary<long, LogicalKeyboardKey> _knownLogicalKeys = new Dictionary<long, LogicalKeyboardKey>{
+          {0x0100000000, none},
+          {0x201000700e1, shift},
+          {0x201000700e3, meta},
+          {0x201000700e2, alt},
+          {0x201000700e0, control},
+      };
+
+      // A map of keys to the pseudo-key synonym for that key. Used by getSynonyms.
+      public static readonly Dictionary<LogicalKeyboardKey, LogicalKeyboardKey> _synonyms = new Dictionary<LogicalKeyboardKey, LogicalKeyboardKey>{
+          {shiftLeft, shift},
+          {shiftRight, shift},
+          {metaLeft, meta},
+          {metaRight, meta},
+          {altLeft, alt},
+          {altRight, alt},
+          {controlLeft, control},
+          {controlRight, control},
+      };
+    }
+    
+    public class PhysicalKeyboardKey : KeyboardKey, IEquatable<PhysicalKeyboardKey>  
+    {
+
+        protected PhysicalKeyboardKey(int usbHidUsage, string debugName = null) 
+        {
+            D.assert(usbHidUsage != null);
+            this.usbHidUsage = usbHidUsage;
+            this.debugName = debugName;
+        }
+        
+
+        /// The unique USB HID usage ID of this physical key on the keyboard.
+        ///
+        /// Due to the variations in platform APIs, this may not be the actual HID
+        /// usage code from the hardware, but a value derived from available
+        /// information on the platform.
+        ///
+        /// See <https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf>
+        /// for the HID usage values and their meanings.
+        public readonly int usbHidUsage;
+
+        /// The debug string to print for this keyboard key, which will be null in
+        /// release mode.
+        public readonly string debugName;
+
+        /// Finds a known [PhysicalKeyboardKey] that matches the given USB HID usage
+        /// code.
+        public static PhysicalKeyboardKey findKeyByCode(int usageCode) => _knownPhysicalKeys[usageCode];
+        
+        public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+            base.debugFillProperties(properties);
+            properties.add(new StringProperty("usbHidUsage", usbHidUsage.ToString().PadLeft(8,'0'), showName: true));
+            properties.add(new StringProperty("debugName", debugName, showName: true, defaultValue: null));
+        }
+
+        public bool Equals(PhysicalKeyboardKey other)
+        {
+            if (ReferenceEquals(null, other)) {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other)) {
+                return true;
+            }
+
+            return usbHidUsage == other.usbHidUsage;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj)) {
+                return true;
+            }
+
+            if (obj.GetType() != GetType()) {
+                return false;
+            }
+
+            return Equals((PhysicalKeyboardKey) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (usbHidUsage * 397) ^ (debugName != null ? debugName.GetHashCode() : 0);
+            }
+        }
+        // Key constants for all keyboard keys in the USB HID specification at the
+        // time Flutter was built.
+
+        /// Represents the location of the "None" key on a generalized keyboard.
+        ///
+        /// See the function [RawKeyEvent.physicalKey] for more information.
+        public static readonly PhysicalKeyboardKey none = new PhysicalKeyboardKey(0x00000000, debugName: foundation_.kReleaseMode ? null : "None");
+
+        /// Represents the location of the "Control Left" key on a generalized
+        /// keyboard.
+        ///
+        /// See the function [RawKeyEvent.physicalKey] for more information.
+        public static readonly PhysicalKeyboardKey controlLeft = new PhysicalKeyboardKey(0x000700e0, debugName: foundation_.kReleaseMode ? null : "Control Left");
+
+        /// Represents the location of the "Shift Left" key on a generalized keyboard.
+        ///
+        /// See the function [RawKeyEvent.physicalKey] for more information.
+        public static readonly PhysicalKeyboardKey shiftLeft = new PhysicalKeyboardKey(0x000700e1, debugName: foundation_.kReleaseMode ? null : "Shift Left");
+
+        /// Represents the location of the "Alt Left" key on a generalized keyboard.
+        ///
+        /// See the function [RawKeyEvent.physicalKey] for more information.
+        public static readonly PhysicalKeyboardKey altLeft = new PhysicalKeyboardKey(0x000700e2, debugName: foundation_.kReleaseMode ? null : "Alt Left");
+
+        /// Represents the location of the "Meta Left" key on a generalized keyboard.
+        ///
+        /// See the function [RawKeyEvent.physicalKey] for more information.
+        public static readonly PhysicalKeyboardKey metaLeft = new PhysicalKeyboardKey(0x000700e3, debugName: foundation_.kReleaseMode ? null : "Meta Left");
+
+        /// Represents the location of the "Control Right" key on a generalized
+        /// keyboard.
+        ///
+        /// See the function [RawKeyEvent.physicalKey] for more information.
+        public static readonly PhysicalKeyboardKey controlRight = new PhysicalKeyboardKey(0x000700e4, debugName: foundation_.kReleaseMode ? null : "Control Right");
+
+        /// Represents the location of the "Shift Right" key on a generalized
+        /// keyboard.
+        ///
+        /// See the function [RawKeyEvent.physicalKey] for more information.
+        public static readonly PhysicalKeyboardKey shiftRight = new PhysicalKeyboardKey(0x000700e5, debugName: foundation_.kReleaseMode ? null : "Shift Right");
+
+        /// Represents the location of the "Alt Right" key on a generalized keyboard.
+        ///
+        /// See the function [RawKeyEvent.physicalKey] for more information.
+        public static readonly PhysicalKeyboardKey altRight = new PhysicalKeyboardKey(0x000700e6, debugName: foundation_.kReleaseMode ? null : "Alt Right");
+
+        /// Represents the location of the "Meta Right" key on a generalized keyboard.
+        ///
+        /// See the function [RawKeyEvent.physicalKey] for more information.
+        public static readonly PhysicalKeyboardKey metaRight = new PhysicalKeyboardKey(0x000700e7, debugName: foundation_.kReleaseMode ? null : "Meta Right");
+
+        
+        public static readonly Dictionary<int, PhysicalKeyboardKey> _knownPhysicalKeys =
+            new Dictionary<int, PhysicalKeyboardKey>() {
+                {0x00000000, none},
+                {0x000700e0, controlLeft},
+                {0x000700e1, shiftLeft},
+                {0x000700e2, altLeft},
+                {0x000700e3, metaLeft},
+                {0x000700e4, controlRight},
+                {0x000700e5, shiftRight},
+                {0x000700e6, altRight},
+                {0x000700e7, metaRight},
+            };
+    }
+
+
+}

com.unity.uiwidgets/Runtime/widgets/shortcuts.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.service;
+using Unity.UIWidgets.services;
+
+namespace Unity.UIWidgets.widgets {
+
+    public class KeySet<T> : KeyboardKey, IEquatable<KeySet<T>> 
+    {  
+        public KeySet(
+            T key1,
+            T key2 = default(T),
+            T key3 = default(T),
+            T key4 = default(T)
+        ) {
+            D.assert(key1 != null);
+            _keys = new HashSet<T>();
+            _keys.Add(key1);
+            int count = 1;
+            if (key2 != null) {
+                _keys.Add(key2);
+                D.assert(() => {
+                    count++;
+                    return true;
+                });
+            }
+
+            if (key3 != null) {
+                _keys.Add(key3);
+                D.assert(() => {
+                    count++;
+                    return true;
+                });
+            }
+
+            if (key4 != null) {
+                _keys.Add(key4);
+                D.assert(() => {
+                    count++;
+                    return true;
+                });
+            }
+
+            D.assert(_keys.Count == count,
+                () => "Two or more provided keys are identical. Each key must appear only once.");
+        }
+
+        public KeySet(HashSet<T> keys) 
+        {
+            D.assert(keys != null);
+            D.assert(keys.isNotEmpty);
+            D.assert(!keys.Contains(default(T)));
+            foreach (var key in keys) {
+                _keys.Add(key);
+            }
+        }
+
+        public HashSet<T> keys 
+        {
+            get { return new HashSet<T>(_keys); }
+        }
+
+        public readonly HashSet<T> _keys;
+        
+        
+        public static readonly List<int> _tempHashStore3 = new List<int>() {0, 0, 0}; // used to sort exactly 3 keys
+        public static readonly List<int> _tempHashStore4 = new List<int>() {0, 0, 0, 0}; // used to sort exactly 4 keys
+        
+        public int _hashCode;
+
+        public bool Equals(KeySet<T> other)
+        {
+            if (ReferenceEquals(null, other)) {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other)) {
+                return true;
+            }
+
+            return Equals(_keys, other._keys) && _hashCode == other._hashCode;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj)) {
+                return true;
+            }
+
+            if (obj.GetType() != GetType()) {
+                return false;
+            }
+
+            return Equals((KeySet<T>) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                if (_hashCode != 0) {
+                    return _hashCode;
+                }
+
+                int length = _keys.Count;
+                IEnumerator<T> iterator = _keys.GetEnumerator();
+
+                // There's always at least one key. Just extract it.
+                iterator.MoveNext();
+                int h1 = iterator.GetHashCode();
+
+                if (length == 1) {
+                    // Don't do anything fancy if there's exactly one key.
+                    return _hashCode = h1;
+                }
+
+                iterator.MoveNext();
+                int h2 = iterator.GetHashCode();
+                if (length == 2) {
+                    // No need to sort if there's two keys, just compare them.
+                    return _hashCode = h1 < h2
+                        ? ((h1 != null ? h1.GetHashCode() : 0) * 397) ^ h2.GetHashCode()
+                        : ((h2 != null ? h2.GetHashCode() : 0) * 397) ^ h1.GetHashCode();
+                }
+
+                // Sort key hash codes and feed to hashList to ensure the aggregate
+                // hash code does not depend on the key order.
+                List<int> sortedHashes = length == 3
+                    ? _tempHashStore3
+                    : _tempHashStore4;
+                sortedHashes[0] = h1;
+                sortedHashes[1] = h2;
+                iterator.MoveNext();
+                sortedHashes[2] = iterator.GetHashCode();
+                if (length == 4) {
+                    iterator.MoveNext();
+                    sortedHashes[3] = iterator.GetHashCode();
+                }
+                sortedHashes.Sort();
+                return _hashCode  = (_hashCode * 397) ^ (sortedHashes != null ? sortedHashes.GetHashCode() : 0);;
+            }
+        }
+    }
+    
+    public class LogicalKeySet : KeySet<LogicalKeyboardKey> {
+
+        public LogicalKeySet(
+            LogicalKeyboardKey key1,
+            LogicalKeyboardKey key2 = default(LogicalKeyboardKey),
+            LogicalKeyboardKey key3 = default(LogicalKeyboardKey),
+            LogicalKeyboardKey key4 = default(LogicalKeyboardKey)
+        ) : base(key1: key1, key2: key2, key3: key3, key4: key4){ }
+        
+        public LogicalKeySet(HashSet<LogicalKeyboardKey> keys) : base(keys) { }
+
+        public static readonly HashSet<LogicalKeyboardKey> _modifiers = new HashSet<LogicalKeyboardKey>(){
+            LogicalKeyboardKey.alt,
+            LogicalKeyboardKey.control,
+            LogicalKeyboardKey.meta,
+            LogicalKeyboardKey.shift,
+        };
+
+      /// Returns a description of the key set that is short and readable.
+      ///
+      /// Intended to be used in debug mode for logging purposes.
+      public string debugDescribeKeys() {
+          List<LogicalKeyboardKey> sortedKeys = keys.ToList();
+             sortedKeys.Sort(
+             (LogicalKeyboardKey a, LogicalKeyboardKey b) => { 
+                 bool aIsModifier = a.synonyms.isNotEmpty() || _modifiers.Contains(a);
+                 bool bIsModifier = b.synonyms.isNotEmpty() || _modifiers.Contains(b);
+                 if (aIsModifier && !bIsModifier) {
+                     return -1;
+                 } else if (bIsModifier && !aIsModifier) {
+                     return 1;
+                 }
+                 return a.debugName.CompareTo(b.debugName);
+             }
+        ); 
+          List<string> result = new List<string>();
+          foreach (var key in sortedKeys) {
+              result.Add(key.debugName);
+          }
+          return string.Join(" + ", result.ToArray());
+      }
+
+      
+      public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+        base.debugFillProperties(properties);
+        properties.add(new DiagnosticsProperty<HashSet<LogicalKeyboardKey>>("keys", _keys, description: debugDescribeKeys()));
+      }
+    }
+    
+    public class ShortcutMapProperty : DiagnosticsProperty<Dictionary<LogicalKeySet, Intent>> {
+
+        public ShortcutMapProperty(
+            string name,
+            Dictionary<LogicalKeySet, Intent> value,
+            bool showName = true,
+            Object defaultValue =  null,//foundation_.kNoDefaultValue
+            DiagnosticLevel level = DiagnosticLevel.info,
+            string description = null
+        ) : base(
+                name: name,
+                value: value,
+                showName: showName,
+                defaultValue: defaultValue,
+                level: level,
+                description: description
+            ) 
+            {
+                D.assert(showName != null);
+                D.assert(level != null);
+            }
+
+    
+        protected override string valueToString( TextTreeConfiguration parentConfiguration = null) {
+            List<string> res = new List<string>();
+            foreach (var key in value.Keys) {
+                string temp = "{" + key.debugDescribeKeys() + "}:" + value[key];
+                res.Add(temp);
+            }
+            return string.Join(", ", res);
+        }
+    }
+    
+    public class ShortcutManager : ChangeNotifier {
+
+      public ShortcutManager(
+        Dictionary<LogicalKeySet, Intent> shortcuts = null,
+        bool modal = false
+      ) {
+          shortcuts = shortcuts ?? new Dictionary<LogicalKeySet, Intent>();
+          D.assert(shortcuts != null);
+          this.modal = modal;
+          this.shortcuts = shortcuts;
+        } 
+
+      /// True if the [ShortcutManager] should not pass on keys that it doesn't
+      /// handle to any key-handling widgets that are ancestors to this one.
+      ///
+      /// Setting [modal] to true is the equivalent of always handling any key given
+      /// to it, even if that key doesn't appear in the [shortcuts] map. Keys that
+      /// don't appear in the map will be dropped.
+      public readonly bool modal;
+
+
+      Dictionary<LogicalKeySet, Intent> _shortcuts;
+    
+      public Dictionary<LogicalKeySet, Intent>  shortcuts {
+          get { return _shortcuts; }
+          set {
+              _shortcuts = value;
+              notifyListeners();
+          }
+      }
+
+      /// Handles a key pressed `event` in the given `context`.
+      ///
+      /// The optional `keysPressed` argument provides an override to keys that the
+      /// [RawKeyboard] reports. If not specified, uses [RawKeyboard.keysPressed]
+      /// instead.
+      public bool handleKeypress(
+        BuildContext context,
+        RawKeyEvent rawKeyEvent,
+        LogicalKeySet keysPressed = null
+      ) {
+        if (!(rawKeyEvent is RawKeyDownEvent)) {
+          return false;
+        }
+        D.assert(context != null);
+        LogicalKeySet keySet = keysPressed ?? new LogicalKeySet(RawKeyboard.instance.keysPressed);
+        Intent matchedIntent = _shortcuts[keySet];
+        if (matchedIntent == null) {
+          // If there's not a more specific match, We also look for any keys that
+          // have synonyms in the map.  This is for things like left and right shift
+          // keys mapping to just the "shift" pseudo-key.
+          HashSet<LogicalKeyboardKey> pseudoKeys = new HashSet<LogicalKeyboardKey>{};
+          foreach (LogicalKeyboardKey setKey in keySet.keys) {
+            HashSet<LogicalKeyboardKey> synonyms = setKey.synonyms;
+            if (synonyms.isNotEmpty()) {
+              // There currently aren't any synonyms that match more than one key.
+              pseudoKeys.Add(synonyms.First());
+            } else {
+              pseudoKeys.Add(setKey);
+            }
+          }
+          matchedIntent = _shortcuts[new LogicalKeySet(pseudoKeys)];
+        }
+        if (matchedIntent != null) {
+          BuildContext primaryContext = FocusManagerUtils.primaryFocus?.context;
+          if (primaryContext == null) {
+            return false;
+          }
+          return Actions.invoke(primaryContext, matchedIntent, nullOk: true);
+        }
+        return false;
+      }
+
+      public  void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+          properties.add(new DiagnosticsProperty<Dictionary<LogicalKeySet, Intent>>("shortcuts", _shortcuts));
+        properties.add(new FlagProperty("modal", value: modal, ifTrue: "modal", defaultValue: false));
+      }
+    }
+      
+    public class Shortcuts : StatefulWidget {
+      /// Creates a ActionManager object.
+      ///
+      /// The [child] argument must not be null.
+      public Shortcuts(
+        Key key = null,
+        ShortcutManager manager = null,
+        Dictionary<LogicalKeySet, Intent> shortcuts = null,
+        Widget child = null,
+        string debugLabel = null
+      ) : base(key: key) {
+          this.manager = manager;
+          this.shortcuts = shortcuts;
+          this.child = child;
+          this.debugLabel = debugLabel;
+      }
+      
+      public readonly ShortcutManager manager;
+      
+      public readonly Dictionary<LogicalKeySet, Intent> shortcuts;
+      
+      public readonly Widget child;
+      
+      public readonly string debugLabel;
+
+      public static ShortcutManager of(BuildContext context, bool nullOk = false) {
+        D.assert(context != null);
+        _ShortcutsMarker inherited = context.dependOnInheritedWidgetOfExactType<_ShortcutsMarker>();
+        D.assert(() => {
+          if (nullOk) {
+            return true;
+          }
+          if (inherited == null) {
+            throw new UIWidgetsError($"Unable to find a {typeof(Shortcuts)} widget in the context.\n" +
+                $"{typeof(Shortcuts)}.of()was called with a context that does not contain a " +
+                $"{typeof(Shortcuts)} widget.\n" +
+                $"No {typeof(Shortcuts)} ancestor could be found starting from the context that was " +
+                $"passed to {typeof(Shortcuts)}.of().\n" +
+                "The context used was:\n" +
+                $"  {context}");
+          }
+          return true;
+        });
+        return inherited?.notifier;
+      }
+
+      
+      public override State createState() {
+          return new _ShortcutsState();
+      }
+
+
+      public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+        base.debugFillProperties(properties);
+        properties.add(new DiagnosticsProperty<ShortcutManager>("manager", manager, defaultValue: null));
+        properties.add(new ShortcutMapProperty("shortcuts", shortcuts, description: debugLabel?.isNotEmpty() ?? false ? debugLabel : null));
+      }
+    }
+
+    public class _ShortcutsState : State<Shortcuts> {
+        
+      private ShortcutManager _internalManager;
+      public ShortcutManager manager {
+          get { return widget.manager ?? _internalManager; }
+      }
+
+      
+      public override void dispose() {
+        _internalManager?.dispose();
+        base.dispose();
+      }
+
+      
+      public override void initState() {
+        base.initState();
+        if (widget.manager == null) {
+          _internalManager = new ShortcutManager();
+        }
+        manager.shortcuts = widget.shortcuts;
+      }
+
+      
+      public override void didUpdateWidget(StatefulWidget oldWidget) {
+        base.didUpdateWidget((Shortcuts)oldWidget);
+        if (widget.manager != ((Shortcuts)oldWidget).manager) {
+          if (widget.manager != null) {
+            _internalManager?.dispose();
+            _internalManager = null;
+          } else {
+            _internalManager = _internalManager?? new ShortcutManager();
+          }
+        }
+        manager.shortcuts = widget.shortcuts;
+      }
+
+      public bool _handleOnKey(FocusNode node, RawKeyEvent _event)
+      {
+        if (node.context == null) {
+          return false;
+        }
+        return manager.handleKeypress(node.context, _event) || manager.modal;
+      }
+      
+      public override Widget build(BuildContext context) {
+        return new Focus(
+          debugLabel: typeof(Shortcuts).ToString(),
+          canRequestFocus: false,
+          onKey: _handleOnKey,
+          child: new _ShortcutsMarker(
+            manager: manager,
+            child: widget.child
+          )
+        );
+      }
+    }
+
+    public class _ShortcutsMarker : InheritedNotifier<ShortcutManager> {
+        public _ShortcutsMarker(
+            ShortcutManager manager = null,
+            Widget child = null
+        ) : base(notifier: manager, child: child) {
+            D.assert(manager != null);
+            D.assert(child != null);
+        }
+    }
+    
+}