예제 #1
0
        public void HandleKeyEvent(Event evt, IContextManager contextManager)
        {
            if (evt == null || !evt.isKey || evt.keyCode == KeyCode.None)
            {
                return;
            }

            if (evt.type == EventType.KeyUp)
            {
                KeyValuePair <ShortcutEntry, object> clutchKeyValuePair;
                if (m_ActiveClutches.TryGetValue(evt.keyCode, out clutchKeyValuePair))
                {
                    var clutchContext = m_ActiveClutches[evt.keyCode].Value;

                    m_ActiveClutches.Remove(evt.keyCode);
                    var args = new ShortcutArguments
                    {
                        context = clutchContext,
                        state   = ShortcutState.End
                    };
                    invokingAction?.Invoke(clutchKeyValuePair.Key, args);
                    clutchKeyValuePair.Key.action(args);
                }
                return;
            }

            // Use the event and return if the key is currently used in an active clutch
            if (m_ActiveClutches.ContainsKey(evt.keyCode))
            {
                evt.Use();
                return;
            }

            var keyCodeCombination = KeyCombination.FromKeyboardInput(evt);

            m_KeyCombinationSequence.Add(keyCodeCombination);

            // Ignore event if sequence is empty
            if (m_KeyCombinationSequence.Count == 0)
            {
                return;
            }

            m_Directory.FindShortcutEntries(m_KeyCombinationSequence, contextManager, m_Entries);
            IEnumerable <ShortcutEntry> entries = m_Entries;

            // Deal ONLY with prioritycontext
            if (entries.Count() > 1 && contextManager.HasAnyPriorityContext())
            {
                m_CurrentContextManager = contextManager;
                entries = m_Entries.FindAll(CurrentContextManagerHasPriorityContextFor);
                if (!entries.Any())
                {
                    entries = m_Entries;
                }
            }

            switch (entries.Count())
            {
            case 0:
                Reset();
                break;

            case 1:
                var shortcutEntry = entries.Single();
                if (ShortcutFullyMatchesKeyCombination(shortcutEntry))
                {
                    if (evt.keyCode != m_KeyCombinationSequence.Last().keyCode)
                    {
                        break;
                    }

                    var args = new ShortcutArguments();
                    args.context = contextManager.GetContextInstanceOfType(shortcutEntry.context);
                    switch (shortcutEntry.type)
                    {
                    case ShortcutType.Action:
                        args.state = ShortcutState.End;
                        invokingAction?.Invoke(shortcutEntry, args);
                        shortcutEntry.action(args);
                        evt.Use();
                        Reset();
                        break;

                    case ShortcutType.Clutch:
                        if (!m_ActiveClutches.ContainsKey(evt.keyCode))
                        {
                            m_ActiveClutches.Add(evt.keyCode, new KeyValuePair <ShortcutEntry, object>(shortcutEntry, args.context));
                            args.state = ShortcutState.Begin;
                            invokingAction?.Invoke(shortcutEntry, args);
                            shortcutEntry.action(args);
                            evt.Use();
                            Reset();
                        }
                        break;

                    case ShortcutType.Menu:
                        args.state = ShortcutState.End;
                        invokingAction?.Invoke(shortcutEntry, args);
                        shortcutEntry.action(args);
                        evt.Use();
                        Reset();
                        break;
                    }
                }
                break;

            default:
                if (HasConflicts(entries, m_KeyCombinationSequence))
                {
                    m_ConflictResolver.ResolveConflict(m_KeyCombinationSequence, entries);
                    evt.Use();
                    Reset();
                }
                break;
            }
        }
예제 #2
0
        public void HandleKeyEvent(Event evt, IContextManager contextManager)
        {
            if (evt == null || !evt.isKey || evt.keyCode == KeyCode.None)
            {
                return;
            }

            if (evt.type == EventType.KeyUp)
            {
                m_KeysDown.Remove(evt.keyCode);
                Tuple <ShortcutEntry, object> clutchTuple;
                if (m_ActiveClutches.TryGetValue(evt.keyCode, out clutchTuple))
                {
                    var clutchContext = m_ActiveClutches[evt.keyCode].Item2;

                    m_ActiveClutches.Remove(evt.keyCode);
                    var args = new ShortcutArguments
                    {
                        context = clutchContext,
                        state   = ShortcutState.End
                    };
                    clutchTuple.Item1.action(args);
                }
                return;
            }

            if (m_KeysDown.Contains(evt.keyCode))
            {
                evt.Use();
                return;
            }
            m_KeysDown.Add(evt.keyCode);

            var keyCodeCombination = new KeyCombination(evt);

            m_KeyCombinationSequence.Add(keyCodeCombination);

            // Ignore event if sequence is empty
            if (m_KeyCombinationSequence.Count == 0)
            {
                return;
            }

            m_Directory.FindShortcutEntries(m_KeyCombinationSequence, contextManager, m_Entries);

            // Deal ONLY with prioritycontext
            if (m_Entries.Count > 1 && contextManager.HasAnyPriorityContext())
            {
                var entry = m_Entries.FindAll(a => contextManager.HasPriorityContextOfType(a.context));
                if (entry.Any())
                {
                    m_Entries.Clear();
                    m_Entries.AddRange(entry);
                }
            }

            switch (m_Entries.Count)
            {
            case 0:
                Reset();
                break;

            case 1:
                var shortcutEntry = m_Entries.Single();
                if (ShortcutFullyMatchesKeyCombination(shortcutEntry))
                {
                    if (evt.keyCode != m_KeyCombinationSequence.Last().keyCode)
                    {
                        break;
                    }

                    var args = new ShortcutArguments();
                    args.context = contextManager.GetContextInstanceOfType(shortcutEntry.context);
                    switch (shortcutEntry.type)
                    {
                    case ShortcutType.Action:
                        args.state = ShortcutState.End;
                        shortcutEntry.action(args);
                        evt.Use();
                        Reset();
                        break;

                    case ShortcutType.Clutch:
                        if (!m_ActiveClutches.ContainsKey(evt.keyCode))
                        {
                            m_ActiveClutches.Add(evt.keyCode, new Tuple <ShortcutEntry, object>(shortcutEntry, args.context));
                            args.state = ShortcutState.Begin;
                            shortcutEntry.action(args);
                            evt.Use();
                            Reset();
                        }
                        break;

                    case ShortcutType.Menu:
                        args.state = ShortcutState.End;
                        EditorApplication.ExecuteMenuItem(shortcutEntry.identifier.path);
                        evt.Use();
                        Reset();
                        break;
                    }
                }
                break;

            default:
                if (HasConflicts(m_Entries, m_KeyCombinationSequence))
                {
                    m_ConflictResolver.ResolveConflict(m_KeyCombinationSequence, m_Entries);
                    Reset();
                }
                break;
            }
        }