third_party/WebKit/Source/devtools/front_end/ui/ShortcutRegistry.js

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @constructor
   7  * @param {!WebInspector.ActionRegistry} actionRegistry
   8  * @param {!Document} document
   9  */
  10 WebInspector.ShortcutRegistry = function(actionRegistry, document)
  11 {
  12     this._actionRegistry = actionRegistry;
  13     /** @type {!Multimap.<string, string>} */
  14     this._defaultKeyToActions = new Multimap();
  15     /** @type {!Multimap.<string, !WebInspector.KeyboardShortcut.Descriptor>} */
  16     this._defaultActionToShortcut = new Multimap();
  17     this._registerBindings(document);
  18 }
  19
  20 WebInspector.ShortcutRegistry.prototype = {
  21     /**
  22      * @param {number} key
  23      * @return {!Array.<string>}
  24      */
  25     applicableActions: function(key)
  26     {
  27         return this._actionRegistry.applicableActions(this._defaultActionsForKey(key).valuesArray(), WebInspector.context);
  28     },
  29
  30     /**
  31      * @param {number} key
  32      * @return {!Set.<string>}
  33      */
  34     _defaultActionsForKey: function(key)
  35     {
  36         return this._defaultKeyToActions.get(String(key));
  37     },
  38
  39     /**
  40      * @param {string} actionId
  41      * @return {!Array.<!WebInspector.KeyboardShortcut.Descriptor>}
  42      */
  43     shortcutDescriptorsForAction: function(actionId)
  44     {
  45         return this._defaultActionToShortcut.get(actionId).valuesArray();
  46     },
  47
  48     /**
  49      * @param {!Array.<string>} actionIds
  50      * @return {!Array.<number>}
  51      */
  52     keysForActions: function(actionIds)
  53     {
  54         var result = [];
  55         for (var i = 0; i < actionIds.length; ++i) {
  56             var descriptors = this.shortcutDescriptorsForAction(actionIds[i]);
  57             for (var j = 0; j < descriptors.length; ++j)
  58                 result.push(descriptors[j].key);
  59         }
  60         return result;
  61     },
  62
  63     /**
  64      * @param {string} actionId
  65      * @return {string|undefined}
  66      */
  67     shortcutTitleForAction: function(actionId)
  68     {
  69         var descriptors = this.shortcutDescriptorsForAction(actionId);
  70         if (descriptors.length)
  71             return descriptors[0].name;
  72     },
  73
  74     /**
  75      * @param {!KeyboardEvent} event
  76      */
  77     handleShortcut: function(event)
  78     {
  79         this.handleKey(WebInspector.KeyboardShortcut.makeKeyFromEvent(event), event.keyIdentifier, event);
  80     },
  81
  82     /**
  83      * @param {number} key
  84      * @param {string} keyIdentifier
  85      * @param {!KeyboardEvent=} event
  86      */
  87     handleKey: function(key, keyIdentifier, event)
  88     {
  89         var keyModifiers = key >> 8;
  90         var actionIds = this.applicableActions(key);
  91         if (!actionIds.length)
  92             return;
  93         if (WebInspector.GlassPane.DefaultFocusedViewStack.length > 1) {
  94             if (event && !isPossiblyInputKey())
  95                 event.consume(true);
  96             return;
  97         }
  98
  99         if (!isPossiblyInputKey()) {
 100             if (event)
 101                 event.consume(true);
 102             processNextAction.call(this);
 103         } else {
 104             this._pendingActionTimer = setTimeout(processNextAction.bind(this), 0);
 105         }
 106
 107         /**
 108          * @this {WebInspector.ShortcutRegistry}
 109          */
 110         function processNextAction()
 111         {
 112             delete this._pendingActionTimer;
 113             var actionId = actionIds.shift();
 114             if (!actionId)
 115                 return;
 116
 117             this._actionRegistry.execute(actionId).then(processNextAction.bind(this));
 118         }
 119
 120         /**
 121          * @return {boolean}
 122          */
 123         function isPossiblyInputKey()
 124         {
 125             if (!event || !WebInspector.isEditing() || /^F\d+|Control|Shift|Alt|Meta|Win|U\+001B$/.test(keyIdentifier))
 126                 return false;
 127
 128             if (!keyModifiers)
 129                 return true;
 130
 131             var modifiers = WebInspector.KeyboardShortcut.Modifiers;
 132             if ((keyModifiers & (modifiers.Ctrl | modifiers.Alt)) === (modifiers.Ctrl | modifiers.Alt))
 133                 return WebInspector.isWin();
 134
 135             return !hasModifier(modifiers.Ctrl) && !hasModifier(modifiers.Alt) && !hasModifier(modifiers.Meta);
 136         }
 137
 138         /**
 139          * @param {number} mod
 140          * @return {boolean}
 141          */
 142         function hasModifier(mod)
 143         {
 144             return !!(keyModifiers & mod);
 145         }
 146     },
 147
 148     /**
 149      * @param {string} actionId
 150      * @param {string} shortcut
 151      */
 152     registerShortcut: function(actionId, shortcut)
 153     {
 154         var descriptor = WebInspector.KeyboardShortcut.makeDescriptorFromBindingShortcut(shortcut);
 155         if (!descriptor)
 156             return;
 157         this._defaultActionToShortcut.set(actionId, descriptor);
 158         this._defaultKeyToActions.set(String(descriptor.key), actionId);
 159     },
 160
 161     dismissPendingShortcutAction: function()
 162     {
 163         if (this._pendingActionTimer) {
 164             clearTimeout(this._pendingActionTimer);
 165             delete this._pendingActionTimer;
 166         }
 167     },
 168
 169     /**
 170      * @param {!Document} document
 171      */
 172     _registerBindings: function(document)
 173     {
 174         document.addEventListener("input", this.dismissPendingShortcutAction.bind(this), true);
 175         var extensions = self.runtime.extensions(WebInspector.ActionDelegate);
 176         extensions.forEach(registerExtension, this);
 177
 178         /**
 179          * @param {!Runtime.Extension} extension
 180          * @this {WebInspector.ShortcutRegistry}
 181          */
 182         function registerExtension(extension)
 183         {
 184             var descriptor = extension.descriptor();
 185             var bindings = descriptor["bindings"];
 186             for (var i = 0; bindings && i < bindings.length; ++i) {
 187                 if (!platformMatches(bindings[i].platform))
 188                     continue;
 189                 var shortcuts = bindings[i]["shortcut"].split(/\s+/);
 190                 shortcuts.forEach(this.registerShortcut.bind(this, descriptor["actionId"]));
 191             }
 192         }
 193
 194         /**
 195          * @param {string=} platformsString
 196          * @return {boolean}
 197          */
 198         function platformMatches(platformsString)
 199         {
 200             if (!platformsString)
 201                 return true;
 202             var platforms = platformsString.split(",");
 203             var isMatch = false;
 204             var currentPlatform = WebInspector.platform();
 205             for (var i = 0; !isMatch && i < platforms.length; ++i)
 206                 isMatch = platforms[i] === currentPlatform;
 207             return isMatch;
 208         }
 209     }
 210 }
 211
 212 /**
 213  * @constructor
 214  */
 215 WebInspector.ShortcutRegistry.ForwardedShortcut = function()
 216 {
 217 }
 218
 219 WebInspector.ShortcutRegistry.ForwardedShortcut.instance = new WebInspector.ShortcutRegistry.ForwardedShortcut();
 220
 221 /** @type {!WebInspector.ShortcutRegistry} */
 222 WebInspector.shortcutRegistry;