记录一下在Unity编辑器中用过的一个简单的快捷键命令功能C#类

/// <summary>
    /// 快捷键配置
    /// eidt by jalang -- 
    /// </summary>
    internal class FunctionShortcutConfigInfo
    {
        /// <summary>
        /// 当前激活的正在编辑快捷键的命令名称
        /// </summary>
        public string currentEditCmdName
        {
            get;
            set;
        }
        /// <summary>
        /// 保存命令所对应的快捷键
        /// </summary>
        private Dictionary<string, List<KeyCode>> mShortcutKeys;
        /// <summary>
        /// 当前被按下的所有按键列表
        /// </summary>
        private List<KeyCode> mCurrentKeyDowns = new List<KeyCode>();
        /// <summary>
        /// 当前激活的正在编辑快捷键的命令名称
        /// </summary>
        //private string mCurrentEditCmdName;

        #region public functions

        public bool InitShortcut(string serializedData)
        {
            mShortcutKeys = JsonConvert.DeserializeObject<Dictionary<string, List<KeyCode>>>(serializedData);
            if (null == mShortcutKeys)
            {
                mShortcutKeys = new Dictionary<string, List<KeyCode>>();
            }
            return true;
        }
        /// <summary>
        /// 获取保存的快捷键的序列化数据 先用json
        /// </summary>
        /// <returns></returns>
        public string GetSerializeData()
        {
            var ret = JsonConvert.SerializeObject(mShortcutKeys);
            return ret;
        }
        /// <summary>
        /// 根据命令名称获取快捷键组合的字符串描述
        /// </summary>
        /// <param name="cmdName"></param>
        /// <returns></returns>
        public string GetShortcutKeysString(string cmdName)
        {
            if (!mShortcutKeys.ContainsKey(cmdName)) return string.Empty;
            var keys = mShortcutKeys[cmdName];
            string ret = "";
            if (null != keys && keys.Count > 0)
            {
                ret = string.Join(" + ", keys.ConvertAll(key => Enum.GetName(typeof(KeyCode), key)));
            }
            return ret;
        }

        /// <summary>
        /// 按键按下
        /// </summary>
        /// <param name="key">按键</param>
        /// <returns>返回符合快捷键组合的命令，没有返回string.Empty</returns>
        public string KeyDown(KeyCode key)
        {
            if (!string.IsNullOrEmpty(currentEditCmdName))   //需要设置快捷键
            {
                if (key == KeyCode.LeftControl || key == KeyCode.RightControl)
                {
                    CustomDebugger.LogWarning("不支持Control组合键...暂时的解决方法是使用Alt键来代替...没办法，本座也很无奈~~~", Color.red);
                    return string.Empty;
                }
            }
            if (key == KeyCode.None) return string.Empty;
            if (!mCurrentKeyDowns.Contains(key))
            {
                mCurrentKeyDowns.Add(key);
            }
            if (string.IsNullOrEmpty(currentEditCmdName))   //当前没有需要设置的快捷键
            {
                return GetCmdName(mCurrentKeyDowns);
            }
            return string.Empty;
        }

        /// <summary>
        /// 按键弹起
        /// 如果是快捷键设置状态 则将当前的快捷键组合设置给命令并清空编辑模式
        /// </summary>
        /// <param name="key">按键</param>
        /// <returns>返回弹起之前的快捷键组合的命令，没有返回string.Empty</returns>
        public string KeyUp(KeyCode key)
        {
            string ret = string.Empty;
            if (!string.IsNullOrEmpty(currentEditCmdName))  //当前是快捷键设置状态
            {
                if (!mShortcutKeys.ContainsKey(currentEditCmdName))
                {
                    mShortcutKeys.Add(currentEditCmdName, new List<KeyCode>(mCurrentKeyDowns));
                }
                else
                {
                    mShortcutKeys[currentEditCmdName].Clear();
                    mShortcutKeys[currentEditCmdName].AddRange(mCurrentKeyDowns);
                }
                // -- 检查所有快捷键列表是否有冲突的快捷键存在 --
                foreach (var item in mShortcutKeys)
                {
                    if (item.Value.All(mCurrentKeyDowns.Contains) && item.Value.Count == mCurrentKeyDowns.Count)
                    {
                        item.Value.Clear();
                    }
                }

                ret = currentEditCmdName;
                currentEditCmdName = string.Empty;
            }
            else
            {
                // 返回之前可能的命令
                ret = GetCmdName(mCurrentKeyDowns);
            }
            mCurrentKeyDowns.Remove(key);   //从当前按键列表中移除弹起的按键
            return ret;
        }

        internal void ResetCurrentKeys()
        {
            mCurrentKeyDowns.Clear();
        }
        #endregion

        #region private functions    
        private string GetCmdName(List<KeyCode> keyCodes)
        {
            foreach (var kvs in mShortcutKeys)
            {
                if (!kvs.Value.Count.Equals(keyCodes.Count))
                {
                    continue;
                }
                var equal = true;
                foreach (var v in keyCodes)
                {
                    if (!kvs.Value.Contains(v))
                    {
                        equal = false;
                        break;
                    }
                }
                if (equal)
                {
                    return kvs.Key;
                }
            }
            return string.Empty;
        }
        #endregion
    }

使用时 先建一个对象 private FunctionShortcutConfigInfo mFunctionShortcutInfo = new FunctionShortcutConfigInfo();

画一个设置快捷键命令的按钮：

private void DrawShortcutCmd(string title, string cmd)
{
      EditorGUILayout.BeginHorizontal();
      var shortcut = mFunctionShortcutInfo.GetShortcutKeysString(cmd);
      EditorGUILayout.LabelField(title, shortcut);
      var currentShortcutCmd = mFunctionShortcutInfo.currentEditCmdName;

      if (string.IsNullOrEmpty(currentShortcutCmd) || !currentShortcutCmd.Equals(cmd))
      {
           if (GUILayout.Button("点击修改快捷键"))
           {
                mFunctionShortcutInfo.currentEditCmdName = cmd;
           }
       }
       EditorGUILayout.EndHorizontal();
}

在OnGUI中画按钮设置快捷键命令：

DrawShortcutCmd("放大笔刷按键快捷键：", "放大笔刷");

// 监听按键消息
if (Event.current.isKey)
{
      switch (Event.current.type)
      {
            case EventType.KeyDown:
                {
                    mFunctionShortcutInfo.KeyDown(Event.current.keyCode);
                    break;
                }
            case EventType.KeyUp:
                {
                    mFunctionShortcutInfo.KeyUp(Event.current.keyCode);
                    Repaint();
                    break;
                }
      }
}

在OnSceneGUI中监听按键消息：

if (Event.current.isKey)
{
      switch (Event.current.type)
      {
            case EventType.KeyDown:
                {
                    var cmd = mFunctionShortcutInfo.KeyDown(Event.current.keyCode);
                    switch (cmd)
                    {
                        case "放大笔刷":
                        break;
                    }
                    break;
                }
            case EventType.KeyUp:
                {
                    var cmd = mFunctionShortcutInfo.KeyUp(Event.current.keyCode);
                    switch (cmd)
                    {
                        case "放大笔刷":
                        // 执行快捷键命令 --
                            ZoomInBrush();
                        break;
                    }
                    Repaint();
                    break;
                }
      }
}