DevTools: rename WebInspector into modules.

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

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 12 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.KeyboardShortcut = class {
+UI.KeyboardShortcut = class {
   /**
    * Creates a number encoding keyCode in the lower 8 bits and modifiers mask in the higher 8 bits.
    * It is useful for matching pressed keys.
    *
    * @param {number|string} keyCode The code of the key, or a character "a-z" which is converted to a keyCode value.
    * @param {number=} modifiers Optional list of modifiers passed as additional parameters.
    * @return {number}
    */
   static makeKey(keyCode, modifiers) {
     if (typeof keyCode === 'string')
       keyCode = keyCode.charCodeAt(0) - (/^[a-z]/.test(keyCode) ? 32 : 0);
-    modifiers = modifiers || WebInspector.KeyboardShortcut.Modifiers.None;
-    return WebInspector.KeyboardShortcut._makeKeyFromCodeAndModifiers(keyCode, modifiers);
+    modifiers = modifiers || UI.KeyboardShortcut.Modifiers.None;
+    return UI.KeyboardShortcut._makeKeyFromCodeAndModifiers(keyCode, modifiers);
   }
 
   /**
    * @param {?KeyboardEvent} keyboardEvent
    * @return {number}
    */
   static makeKeyFromEvent(keyboardEvent) {
-    var modifiers = WebInspector.KeyboardShortcut.Modifiers.None;
+    var modifiers = UI.KeyboardShortcut.Modifiers.None;
     if (keyboardEvent.shiftKey)
-      modifiers |= WebInspector.KeyboardShortcut.Modifiers.Shift;
+      modifiers |= UI.KeyboardShortcut.Modifiers.Shift;
     if (keyboardEvent.ctrlKey)
-      modifiers |= WebInspector.KeyboardShortcut.Modifiers.Ctrl;
+      modifiers |= UI.KeyboardShortcut.Modifiers.Ctrl;
     if (keyboardEvent.altKey)
-      modifiers |= WebInspector.KeyboardShortcut.Modifiers.Alt;
+      modifiers |= UI.KeyboardShortcut.Modifiers.Alt;
     if (keyboardEvent.metaKey)
-      modifiers |= WebInspector.KeyboardShortcut.Modifiers.Meta;
+      modifiers |= UI.KeyboardShortcut.Modifiers.Meta;
 
     // Use either a real or a synthetic keyCode (for events originating from extensions).
     var keyCode = keyboardEvent.keyCode || keyboardEvent['__keyCode'];
-    return WebInspector.KeyboardShortcut._makeKeyFromCodeAndModifiers(keyCode, modifiers);
+    return UI.KeyboardShortcut._makeKeyFromCodeAndModifiers(keyCode, modifiers);
   }
 
   /**
    * @param {?KeyboardEvent} keyboardEvent
    * @return {number}
    */
   static makeKeyFromEventIgnoringModifiers(keyboardEvent) {
     var keyCode = keyboardEvent.keyCode || keyboardEvent['__keyCode'];
-    return WebInspector.KeyboardShortcut._makeKeyFromCodeAndModifiers(
-        keyCode, WebInspector.KeyboardShortcut.Modifiers.None);
+    return UI.KeyboardShortcut._makeKeyFromCodeAndModifiers(
+        keyCode, UI.KeyboardShortcut.Modifiers.None);
   }
 
   /**
    * @param {(?KeyboardEvent|?MouseEvent)} event
    * @return {boolean}
    */
   static eventHasCtrlOrMeta(event) {
-    return WebInspector.isMac() ? event.metaKey && !event.ctrlKey : event.ctrlKey && !event.metaKey;
+    return Host.isMac() ? event.metaKey && !event.ctrlKey : event.ctrlKey && !event.metaKey;
   }
 
   /**
    * @param {!Event} event
    * @return {boolean}
    */
   static hasNoModifiers(event) {
     return !event.ctrlKey && !event.shiftKey && !event.altKey && !event.metaKey;
   }
 
   /**
-   * @param {string|!WebInspector.KeyboardShortcut.Key} key
+   * @param {string|!UI.KeyboardShortcut.Key} key
    * @param {number=} modifiers
-   * @return {!WebInspector.KeyboardShortcut.Descriptor}
+   * @return {!UI.KeyboardShortcut.Descriptor}
    */
   static makeDescriptor(key, modifiers) {
     return {
-      key: WebInspector.KeyboardShortcut.makeKey(typeof key === 'string' ? key : key.code, modifiers),
-      name: WebInspector.KeyboardShortcut.shortcutToString(key, modifiers)
+      key: UI.KeyboardShortcut.makeKey(typeof key === 'string' ? key : key.code, modifiers),
+      name: UI.KeyboardShortcut.shortcutToString(key, modifiers)
     };
   }
 
   /**
    * @param {string} shortcut
-   * @return {?WebInspector.KeyboardShortcut.Descriptor}
+   * @return {?UI.KeyboardShortcut.Descriptor}
    */
   static makeDescriptorFromBindingShortcut(shortcut) {
     var parts = shortcut.split(/\+(?!$)/);
     var modifiers = 0;
     var keyString;
     for (var i = 0; i < parts.length; ++i) {
-      if (typeof WebInspector.KeyboardShortcut.Modifiers[parts[i]] !== 'undefined') {
-        modifiers |= WebInspector.KeyboardShortcut.Modifiers[parts[i]];
+      if (typeof UI.KeyboardShortcut.Modifiers[parts[i]] !== 'undefined') {
+        modifiers |= UI.KeyboardShortcut.Modifiers[parts[i]];
         continue;
       }
       console.assert(
           i === parts.length - 1, 'Only one key other than modifier is allowed in shortcut <' + shortcut + '>');
       keyString = parts[i];
       break;
     }
     console.assert(keyString, 'Modifiers-only shortcuts are not allowed (encountered <' + shortcut + '>)');
     if (!keyString)
       return null;
 
-    var key = WebInspector.KeyboardShortcut.Keys[keyString] || WebInspector.KeyboardShortcut.KeyBindings[keyString];
+    var key = UI.KeyboardShortcut.Keys[keyString] || UI.KeyboardShortcut.KeyBindings[keyString];
     if (key && key.shiftKey)
-      modifiers |= WebInspector.KeyboardShortcut.Modifiers.Shift;
-    return WebInspector.KeyboardShortcut.makeDescriptor(key ? key : keyString, modifiers);
+      modifiers |= UI.KeyboardShortcut.Modifiers.Shift;
+    return UI.KeyboardShortcut.makeDescriptor(key ? key : keyString, modifiers);
   }
 
   /**
-   * @param {string|!WebInspector.KeyboardShortcut.Key} key
+   * @param {string|!UI.KeyboardShortcut.Key} key
    * @param {number=} modifiers
    * @return {string}
    */
   static shortcutToString(key, modifiers) {
-    return WebInspector.KeyboardShortcut._modifiersToString(modifiers) + WebInspector.KeyboardShortcut._keyName(key);
+    return UI.KeyboardShortcut._modifiersToString(modifiers) + UI.KeyboardShortcut._keyName(key);
   }
 
   /**
-   * @param {string|!WebInspector.KeyboardShortcut.Key} key
+   * @param {string|!UI.KeyboardShortcut.Key} key
    * @return {string}
    */
   static _keyName(key) {
     if (typeof key === 'string')
       return key.toUpperCase();
     if (typeof key.name === 'string')
       return key.name;
-    return key.name[WebInspector.platform()] || key.name.other || '';
+    return key.name[Host.platform()] || key.name.other || '';
   }
 
   /**
    * @param {number} keyCode
    * @param {?number} modifiers
    * @return {number}
    */
   static _makeKeyFromCodeAndModifiers(keyCode, modifiers) {
     return (keyCode & 255) | (modifiers << 8);
   }
 
   /**
    * @param {number} key
    * @return {!{keyCode: number, modifiers: number}}
    */
   static keyCodeAndModifiersFromKey(key) {
     return {keyCode: key & 255, modifiers: key >> 8};
   }
 
   /**
    * @param {number|undefined} modifiers
    * @return {string}
    */
   static _modifiersToString(modifiers) {
-    var isMac = WebInspector.isMac();
-    var m = WebInspector.KeyboardShortcut.Modifiers;
+    var isMac = Host.isMac();
+    var m = UI.KeyboardShortcut.Modifiers;
     var modifierNames = new Map([
       [m.Ctrl, isMac ? 'Ctrl\u2004' : 'Ctrl\u200A+\u200A'], [m.Alt, isMac ? '\u2325\u2004' : 'Alt\u200A+\u200A'],
       [m.Shift, isMac ? '\u21e7\u2004' : 'Shift\u200A+\u200A'], [m.Meta, isMac ? '\u2318\u2004' : 'Win\u200A+\u200A']
     ]);
     return [m.Meta, m.Ctrl, m.Alt, m.Shift].map(mapModifiers).join('');
 
     /**
      * @param {number} m
      * @return {string}
      */
     function mapModifiers(m) {
       return modifiers & m ? /** @type {string} */ (modifierNames.get(m)) : '';
     }
   }
 };
 
 /**
  * Constants for encoding modifier key set as a bit mask.
  * @see #_makeKeyFromCodeAndModifiers
  */
-WebInspector.KeyboardShortcut.Modifiers = {
+UI.KeyboardShortcut.Modifiers = {
   None: 0,  // Constant for empty modifiers set.
   Shift: 1,
   Ctrl: 2,
   Alt: 4,
   Meta: 8,  // Command key on Mac, Win key on other platforms.
   get CtrlOrMeta() {
     // "default" command/ctrl key for platform, Command on Mac, Ctrl on other platforms
-    return WebInspector.isMac() ? this.Meta : this.Ctrl;
+    return Host.isMac() ? this.Meta : this.Ctrl;
   },
   get ShiftOrOption() {
     // Option on Mac, Shift on other platforms
-    return WebInspector.isMac() ? this.Alt : this.Shift;
+    return Host.isMac() ? this.Alt : this.Shift;
   }
 };
 
 /** @typedef {!{code: number, name: (string|!Object.<string, string>)}} */
-WebInspector.KeyboardShortcut.Key;
+UI.KeyboardShortcut.Key;
 
-/** @type {!Object.<string, !WebInspector.KeyboardShortcut.Key>} */
-WebInspector.KeyboardShortcut.Keys = {
+/** @type {!Object.<string, !UI.KeyboardShortcut.Key>} */
+UI.KeyboardShortcut.Keys = {
   Backspace: {code: 8, name: '\u21a4'},
   Tab: {code: 9, name: {mac: '\u21e5', other: 'Tab'}},
   Enter: {code: 13, name: {mac: '\u21a9', other: 'Enter'}},
   Shift: {code: 16, name: {mac: '\u21e7', other: 'Shift'}},
   Ctrl: {code: 17, name: 'Ctrl'},
   Esc: {code: 27, name: 'Esc'},
   Space: {code: 32, name: 'Space'},
   PageUp: {code: 33, name: {mac: '\u21de', other: 'PageUp'}},      // also NUM_NORTH_EAST
   PageDown: {code: 34, name: {mac: '\u21df', other: 'PageDown'}},  // also NUM_SOUTH_EAST
   End: {code: 35, name: {mac: '\u2197', other: 'End'}},            // also NUM_SOUTH_WEST
@@ skipping 31 matching lines @@
   Slash: {code: 191, name: '/'},
   QuestionMark: {code: 191, name: '?'},
   Apostrophe: {code: 192, name: '`'},
   Tilde: {code: 192, name: 'Tilde'},
   LeftSquareBracket: {code: 219, name: '['},
   RightSquareBracket: {code: 221, name: ']'},
   Backslash: {code: 220, name: '\\'},
   SingleQuote: {code: 222, name: '\''},
   get CtrlOrMeta() {
     // "default" command/ctrl key for platform, Command on Mac, Ctrl on other platforms
-    return WebInspector.isMac() ? this.Meta : this.Ctrl;
+    return Host.isMac() ? this.Meta : this.Ctrl;
   },
 };
 
-WebInspector.KeyboardShortcut.KeyBindings = {};
+UI.KeyboardShortcut.KeyBindings = {};
 
 (function() {
-  for (var key in WebInspector.KeyboardShortcut.Keys) {
-    var descriptor = WebInspector.KeyboardShortcut.Keys[key];
+  for (var key in UI.KeyboardShortcut.Keys) {
+    var descriptor = UI.KeyboardShortcut.Keys[key];
     if (typeof descriptor === 'object' && descriptor['code']) {
       var name = typeof descriptor['name'] === 'string' ? descriptor['name'] : key;
-      WebInspector.KeyboardShortcut.KeyBindings[name] = descriptor;
+      UI.KeyboardShortcut.KeyBindings[name] = descriptor;
     }
   }
 })();
 
 
 /** @typedef {!{key: number, name: string}} */
-WebInspector.KeyboardShortcut.Descriptor;
+UI.KeyboardShortcut.Descriptor;
 
 
-WebInspector.KeyboardShortcut.SelectAll =
-    WebInspector.KeyboardShortcut.makeKey('a', WebInspector.KeyboardShortcut.Modifiers.CtrlOrMeta);
+UI.KeyboardShortcut.SelectAll =
+    UI.KeyboardShortcut.makeKey('a', UI.KeyboardShortcut.Modifiers.CtrlOrMeta);