@qooxdoo/framework 7.0.0-beta.5 → 7.0.0-beta.9

package/source/class/qx/event/handler/Keyboard.js

@@ -1,4 +1,3 @@
-
 /* ************************************************************************
 
    qooxdoo - the new era of web development
@@ -27,14 +26,9 @@
  *
  * @require(qx.event.handler.UserAction)
  */
-qx.Class.define("qx.event.handler.Keyboard",
-{
-  extend : qx.core.Object,
-  implement : [ qx.event.IEventHandler, qx.core.IDisposable ],
-
-
-
-
+qx.Class.define("qx.event.handler.Keyboard", {
+  extend: qx.core.Object,
+  implement: [qx.event.IEventHandler, qx.core.IDisposable],
 
   /*
   *****************************************************************************
@@ -47,16 +41,15 @@ qx.Class.define("qx.event.handler.Keyboard",
    *
    * @param manager {qx.event.Manager} Event manager for the window to use
    */
-  construct : function(manager)
-  {
-    this.base(arguments);
+  construct(manager) {
+    super();
 
     // Define shorthands
     this.__manager = manager;
     this.__window = manager.getWindow();
 
     // Gecko ignores key events when not explicitly clicked in the document.
-    if ((qx.core.Environment.get("engine.name") == "gecko")) {
+    if (qx.core.Environment.get("engine.name") == "gecko") {
       this.__root = this.__window;
     } else {
       this.__root = this.__window.document.documentElement;
@@ -69,60 +62,46 @@ qx.Class.define("qx.event.handler.Keyboard",
     this._initKeyObserver();
   },
 
-
-
-
-
   /*
   *****************************************************************************
      STATICS
   *****************************************************************************
   */
 
-  statics :
-  {
+  statics: {
     /** @type {Integer} Priority of this handler */
-    PRIORITY : qx.event.Registration.PRIORITY_NORMAL,
-
+    PRIORITY: qx.event.Registration.PRIORITY_NORMAL,
 
     /** @type {Map} Supported event types */
-    SUPPORTED_TYPES :
-    {
-      keyup : 1,
-      keydown : 1,
-      keypress : 1,
-      keyinput : 1
+    SUPPORTED_TYPES: {
+      keyup: 1,
+      keydown: 1,
+      keypress: 1,
+      keyinput: 1
     },
 
-
     /** @type {Integer} Which target check to use */
-    TARGET_CHECK : qx.event.IEventHandler.TARGET_DOMNODE,
-
+    TARGET_CHECK: qx.event.IEventHandler.TARGET_DOMNODE,
 
     /** @type {Integer} Whether the method "canHandleEvent" must be called */
-    IGNORE_CAN_HANDLE : true
+    IGNORE_CAN_HANDLE: true
   },
 
-
-
   /*
   *****************************************************************************
      MEMBERS
   *****************************************************************************
   */
 
-  members :
-  {
-
-    __onKeyUpDownWrapper  : null,
-    __manager : null,
-    __window : null,
-    __root : null,
-    __lastUpDownType : null,
-    __lastKeyCode : null,
-    __inputListeners : null,
-    __onKeyPressWrapper : null,
-
+  members: {
+    __onKeyUpDownWrapper: null,
+    __manager: null,
+    __window: null,
+    __root: null,
+    __lastUpDownType: null,
+    __lastKeyCode: null,
+    __inputListeners: null,
+    __onKeyPressWrapper: null,
 
     /*
     ---------------------------------------------------------------------------
@@ -131,30 +110,24 @@ qx.Class.define("qx.event.handler.Keyboard",
     */
 
     // interface implementation
-    canHandleEvent : function(target, type) {},
-
+    canHandleEvent(target, type) {},
 
     // interface implementation
-    registerEvent : function(target, type, capture) {
+    registerEvent(target, type, capture) {
       // Nothing needs to be done here
     },
 
-
     // interface implementation
-    unregisterEvent : function(target, type, capture) {
+    unregisterEvent(target, type, capture) {
       // Nothing needs to be done here
     },
 
-
-
-
     /*
     ---------------------------------------------------------------------------
       HELPER
     ---------------------------------------------------------------------------
     */
 
-
     /**
      * Fire a key input event with the given parameters
      *
@@ -162,32 +135,41 @@ qx.Class.define("qx.event.handler.Keyboard",
      * @param charCode {Integer} character code
      * @return {qx.Promise?} a promise if the event handlers created one
      */
-    _fireInputEvent : function(domEvent, charCode)
-    {
+    _fireInputEvent(domEvent, charCode) {
       var target = this.__getEventTarget();
       var tracker = {};
       var self = this;
 
       // Only fire when target is defined and visible
-      if (target && target.offsetWidth != 0)
-      {
-        var event = qx.event.Registration.createEvent("keyinput", qx.event.type.KeyInput, [domEvent, target, charCode]);
-        qx.event.Utils.then(tracker, function() { self.__manager.dispatchEvent(target, event); });
+      if (target && target.offsetWidth != 0) {
+        var event = qx.event.Registration.createEvent(
+          "keyinput",
+          qx.event.type.KeyInput,
+          [domEvent, target, charCode]
+        );
+
+        qx.event.Utils.then(tracker, function () {
+          self.__manager.dispatchEvent(target, event);
+        });
       }
 
       // Fire user action event
       // Needs to check if still alive first
       if (this.__window) {
         var self = this;
-        qx.event.Utils.then(tracker, function() {
-          return qx.event.Registration.fireEvent(self.__window, "useraction", qx.event.type.Data, ["keyinput"]);
+        qx.event.Utils.then(tracker, function () {
+          return qx.event.Registration.fireEvent(
+            self.__window,
+            "useraction",
+            qx.event.type.Data,
+            ["keyinput"]
+          );
         });
       }
-      
+
       return tracker.promise;
     },
 
-
     /**
      * Fire a key up/down/press event with the given parameters
      *
@@ -196,16 +178,20 @@ qx.Class.define("qx.event.handler.Keyboard",
      * @param keyIdentifier {String} key identifier
      * @return {qx.Promise?} a promise, if any of the event handlers returned a promise
      */
-    _fireSequenceEvent : function(domEvent, type, keyIdentifier)
-    {
+    _fireSequenceEvent(domEvent, type, keyIdentifier) {
       var target = this.__getEventTarget();
       var keyCode = domEvent.keyCode;
       var tracker = {};
       var self = this;
 
       // Fire key event
-      var event = qx.event.Registration.createEvent(type, qx.event.type.KeySequence, [domEvent, target, keyIdentifier]);
-      qx.event.Utils.then(tracker, function() {
+      var event = qx.event.Registration.createEvent(
+        type,
+        qx.event.type.KeySequence,
+        [domEvent, target, keyIdentifier]
+      );
+
+      qx.event.Utils.then(tracker, function () {
         return self.__manager.dispatchEvent(target, event);
       });
 
@@ -215,38 +201,50 @@ qx.Class.define("qx.event.handler.Keyboard",
       // FireFox suppresses "keypress" when "keydown" default action is prevented.
       // from version 29: https://bugzilla.mozilla.org/show_bug.cgi?id=935876.
       if (event.getDefaultPrevented() && type == "keydown") {
-        if (qx.core.Environment.get("engine.name") == "mshtml" ||
-            qx.core.Environment.get("engine.name") == "webkit" ||
-            (qx.core.Environment.get("engine.name") == "gecko" && qx.core.Environment.get("browser.version") >= 29)) {
-
+        if (
+          qx.core.Environment.get("engine.name") == "mshtml" ||
+          qx.core.Environment.get("engine.name") == "webkit" ||
+          (qx.core.Environment.get("engine.name") == "gecko" &&
+            qx.core.Environment.get("browser.version") >= 29)
+        ) {
           // some key press events are already emulated. Ignore these events.
-          if (!qx.event.util.Keyboard.isNonPrintableKeyCode(keyCode) && !this._emulateKeyPress[keyCode]) {
-            qx.event.Utils.then(tracker, function() {
-              return self._fireSequenceEvent(domEvent, "keypress", keyIdentifier);
+          if (
+            !qx.event.util.Keyboard.isNonPrintableKeyCode(keyCode) &&
+            !this._emulateKeyPress[keyCode]
+          ) {
+            qx.event.Utils.then(tracker, function () {
+              return self._fireSequenceEvent(
+                domEvent,
+                "keypress",
+                keyIdentifier
+              );
             });
           }
         }
       }
-      
+
       // Fire user action event
       // Needs to check if still alive first
       if (this.__window) {
-        qx.event.Utils.then(tracker, function() {
-          return qx.event.Registration.fireEvent(self.__window, "useraction", qx.event.type.Data, [type]);
+        qx.event.Utils.then(tracker, function () {
+          return qx.event.Registration.fireEvent(
+            self.__window,
+            "useraction",
+            qx.event.type.Data,
+            [type]
+          );
         });
       }
-      
+
       return tracker.promise;
     },
 
-
     /**
      * Get the target element for key events
      *
      * @return {Element} the event target element
      */
-    __getEventTarget : function()
-    {
+    __getEventTarget() {
       var focusHandler = this.__manager.getHandler(qx.event.handler.Focus);
       var target = focusHandler.getActive();
 
@@ -263,9 +261,6 @@ qx.Class.define("qx.event.handler.Keyboard",
       return target;
     },
 
-
-
-
     /*
     ---------------------------------------------------------------------------
       OBSERVER INIT/STOP
@@ -277,44 +272,70 @@ qx.Class.define("qx.event.handler.Keyboard",
      *
      * @signature function()
      */
-    _initKeyObserver : function()
-    {
-      this.__onKeyUpDownWrapper = qx.lang.Function.listener(this.__onKeyUpDown, this);
-      this.__onKeyPressWrapper = qx.lang.Function.listener(this.__onKeyPress, this);
+    _initKeyObserver() {
+      this.__onKeyUpDownWrapper = qx.lang.Function.listener(
+        this.__onKeyUpDown,
+        this
+      );
+
+      this.__onKeyPressWrapper = qx.lang.Function.listener(
+        this.__onKeyPress,
+        this
+      );
 
       var Event = qx.bom.Event;
 
       Event.addNativeListener(this.__root, "keyup", this.__onKeyUpDownWrapper);
-      Event.addNativeListener(this.__root, "keydown", this.__onKeyUpDownWrapper);
-      Event.addNativeListener(this.__root, "keypress", this.__onKeyPressWrapper);
+      Event.addNativeListener(
+        this.__root,
+        "keydown",
+        this.__onKeyUpDownWrapper
+      );
+
+      Event.addNativeListener(
+        this.__root,
+        "keypress",
+        this.__onKeyPressWrapper
+      );
     },
 
-
     /**
      * Stops the native key event listeners.
      *
      * @signature function()
      */
-    _stopKeyObserver : function()
-    {
+    _stopKeyObserver() {
       var Event = qx.bom.Event;
 
-      Event.removeNativeListener(this.__root, "keyup", this.__onKeyUpDownWrapper);
-      Event.removeNativeListener(this.__root, "keydown", this.__onKeyUpDownWrapper);
-      Event.removeNativeListener(this.__root, "keypress", this.__onKeyPressWrapper);
-
-      for (var key in (this.__inputListeners || {}))
-      {
+      Event.removeNativeListener(
+        this.__root,
+        "keyup",
+        this.__onKeyUpDownWrapper
+      );
+
+      Event.removeNativeListener(
+        this.__root,
+        "keydown",
+        this.__onKeyUpDownWrapper
+      );
+
+      Event.removeNativeListener(
+        this.__root,
+        "keypress",
+        this.__onKeyPressWrapper
+      );
+
+      for (var key in this.__inputListeners || {}) {
         var listener = this.__inputListeners[key];
-        Event.removeNativeListener(listener.target, "keypress", listener.callback);
+        Event.removeNativeListener(
+          listener.target,
+          "keypress",
+          listener.callback
+        );
       }
-      delete(this.__inputListeners);
+      delete this.__inputListeners;
     },
 
-
-
-
-
     /*
     ---------------------------------------------------------------------------
       NATIVE EVENT OBSERVERS
@@ -328,53 +349,68 @@ qx.Class.define("qx.event.handler.Keyboard",
      * @signature function(domEvent)
      * @param domEvent {Event} DOM event object
      */
-    __onKeyUpDown : qx.event.GlobalError.observeMethod(qx.core.Environment.select("engine.name",
-    {
-      "gecko|webkit|mshtml" : function(domEvent)
-      {
-        var keyCode = 0;
-        var charCode = 0;
-        var type = domEvent.type;
-
-        keyCode = domEvent.keyCode;
-        
-        var tracker = {};
-        var self = this;
+    __onKeyUpDown: qx.event.GlobalError.observeMethod(
+      qx.core.Environment.select("engine.name", {
+        "gecko|webkit|mshtml"(domEvent) {
+          var keyCode = 0;
+          var charCode = 0;
+          var type = domEvent.type;
 
-        qx.event.Utils.track(tracker, this._idealKeyHandler(keyCode, charCode, type, domEvent));
-
-        // On non print-able character be sure to add a keypress event
-        if (type == "keydown")
-        {
-          /*
-           * We need an artificial keypress event for every keydown event.
-           * Newer browsers do not fire keypress for a regular charachter key (e.g when typing 'a')
-           * if it was typed with the CTRL, ALT or META Key pressed during typing, like
-           * doing it when typing the combination CTRL+A
-           */
-          var isModifierDown = domEvent.ctrlKey || domEvent.altKey || domEvent.metaKey;
-
-          // non-printable, backspace, tab or the modfier keys are down
-          if (qx.event.util.Keyboard.isNonPrintableKeyCode(keyCode) || this._emulateKeyPress[keyCode] || isModifierDown) {
-            qx.event.Utils.then(tracker, function() {
-              return self._idealKeyHandler(keyCode, charCode, "keypress", domEvent);
-            });
+          keyCode = domEvent.keyCode;
+
+          var tracker = {};
+          var self = this;
+
+          qx.event.Utils.track(
+            tracker,
+            this._idealKeyHandler(keyCode, charCode, type, domEvent)
+          );
+
+          // On non print-able character be sure to add a keypress event
+          if (type == "keydown") {
+            /*
+             * We need an artificial keypress event for every keydown event.
+             * Newer browsers do not fire keypress for a regular charachter key (e.g when typing 'a')
+             * if it was typed with the CTRL, ALT or META Key pressed during typing, like
+             * doing it when typing the combination CTRL+A
+             */
+            var isModifierDown =
+              domEvent.ctrlKey || domEvent.altKey || domEvent.metaKey;
+
+            // non-printable, backspace, tab or the modfier keys are down
+            if (
+              qx.event.util.Keyboard.isNonPrintableKeyCode(keyCode) ||
+              this._emulateKeyPress[keyCode] ||
+              isModifierDown
+            ) {
+              qx.event.Utils.then(tracker, function () {
+                return self._idealKeyHandler(
+                  keyCode,
+                  charCode,
+                  "keypress",
+                  domEvent
+                );
+              });
+            }
           }
-        }
 
-        // Store last type
-        this.__lastUpDownType[keyCode] = type;
-        
-        return tracker.promise;
-      },
+          // Store last type
+          this.__lastUpDownType[keyCode] = type;
 
-      "opera" : function(domEvent)
-      {
-        this.__lastKeyCode = domEvent.keyCode;
-        return this._idealKeyHandler(domEvent.keyCode, 0, domEvent.type, domEvent);
-      }
-    })),
+          return tracker.promise;
+        },
 
+        opera(domEvent) {
+          this.__lastKeyCode = domEvent.keyCode;
+          return this._idealKeyHandler(
+            domEvent.keyCode,
+            0,
+            domEvent.type,
+            domEvent
+          );
+        }
+      })
+    ),
 
     /**
      * some keys like "up", "down", "pageup", "pagedown" do not bubble a
@@ -388,18 +424,15 @@ qx.Class.define("qx.event.handler.Keyboard",
      * @param type {String} The event type
      * @param keyCode {Integer} the key code
      */
-    __firefoxInputFix : qx.core.Environment.select("engine.name",
-    {
-      "gecko" : function(target, type, keyCode)
-      {
+    __firefoxInputFix: qx.core.Environment.select("engine.name", {
+      gecko(target, type, keyCode) {
         if (
           type === "keydown" &&
           (keyCode == 33 || keyCode == 34 || keyCode == 38 || keyCode == 40) &&
           target.type == "text" &&
           target.tagName.toLowerCase() === "input" &&
           target.getAttribute("autoComplete") !== "off"
-        )
-        {
+        ) {
           if (!this.__inputListeners) {
             this.__inputListeners = {};
           }
@@ -410,94 +443,132 @@ qx.Class.define("qx.event.handler.Keyboard",
           var self = this;
           this.__inputListeners[hash] = {
             target: target,
-            callback : function(domEvent)
-            {
+            callback(domEvent) {
               qx.bom.Event.stopPropagation(domEvent);
               self.__onKeyPress(domEvent);
             }
           };
-          var listener = qx.event.GlobalError.observeMethod(this.__inputListeners[hash].callback);
+
+          var listener = qx.event.GlobalError.observeMethod(
+            this.__inputListeners[hash].callback
+          );
+
           qx.bom.Event.addNativeListener(target, "keypress", listener);
         }
       },
 
-      "default" : null
+      default: null
     }),
 
-
     /**
      * Low level key press handler
      *
      * @signature function(domEvent)
      * @param domEvent {Event} DOM event object
      */
-    __onKeyPress : qx.event.GlobalError.observeMethod(qx.core.Environment.select("engine.name",
-    {
-      "mshtml" : function(domEvent)
-      {
-        domEvent = window.event || domEvent;
-
-        if (this._charCode2KeyCode[domEvent.keyCode]) {
-          return this._idealKeyHandler(this._charCode2KeyCode[domEvent.keyCode], 0, domEvent.type, domEvent);
-        } else {
-          return this._idealKeyHandler(0, domEvent.keyCode, domEvent.type, domEvent);
-        }
-      },
+    __onKeyPress: qx.event.GlobalError.observeMethod(
+      qx.core.Environment.select("engine.name", {
+        mshtml(domEvent) {
+          domEvent = window.event || domEvent;
 
-      "gecko" : function(domEvent)
-      {
-        if(qx.core.Environment.get("engine.version") < 66) {
-          var charCode = domEvent.charCode;
-          var type = domEvent.type;
+          if (this._charCode2KeyCode[domEvent.keyCode]) {
+            return this._idealKeyHandler(
+              this._charCode2KeyCode[domEvent.keyCode],
+              0,
+              domEvent.type,
+              domEvent
+            );
+          } else {
+            return this._idealKeyHandler(
+              0,
+              domEvent.keyCode,
+              domEvent.type,
+              domEvent
+            );
+          }
+        },
+
+        gecko(domEvent) {
+          if (qx.core.Environment.get("engine.version") < 66) {
+            var charCode = domEvent.charCode;
+            var type = domEvent.type;
+
+            return this._idealKeyHandler(
+              domEvent.keyCode,
+              charCode,
+              type,
+              domEvent
+            );
+          } else {
+            if (this._charCode2KeyCode[domEvent.keyCode]) {
+              return this._idealKeyHandler(
+                this._charCode2KeyCode[domEvent.keyCode],
+                0,
+                domEvent.type,
+                domEvent
+              );
+            } else {
+              return this._idealKeyHandler(
+                0,
+                domEvent.keyCode,
+                domEvent.type,
+                domEvent
+              );
+            }
+          }
+        },
 
-           return this._idealKeyHandler(domEvent.keyCode, charCode, type, domEvent);
-        } else {
+        webkit(domEvent) {
           if (this._charCode2KeyCode[domEvent.keyCode]) {
-            return this._idealKeyHandler(this._charCode2KeyCode[domEvent.keyCode], 0, domEvent.type, domEvent);
+            return this._idealKeyHandler(
+              this._charCode2KeyCode[domEvent.keyCode],
+              0,
+              domEvent.type,
+              domEvent
+            );
           } else {
-            return this._idealKeyHandler(0, domEvent.keyCode, domEvent.type, domEvent);
+            return this._idealKeyHandler(
+              0,
+              domEvent.keyCode,
+              domEvent.type,
+              domEvent
+            );
           }
-        }
-      },
+        },
 
-      "webkit" : function(domEvent)
-      {
-        if (this._charCode2KeyCode[domEvent.keyCode]) {
-          return this._idealKeyHandler(this._charCode2KeyCode[domEvent.keyCode], 0, domEvent.type, domEvent);
-        } else {
-          return this._idealKeyHandler(0, domEvent.keyCode, domEvent.type, domEvent);
-        }
-      },
+        opera(domEvent) {
+          var keyCode = domEvent.keyCode;
+          var type = domEvent.type;
 
-      "opera" : function(domEvent)
-      {
-        var keyCode = domEvent.keyCode;
-        var type = domEvent.type;
-
-        // Some keys are identified differently for key up/down and keypress
-        // (e.g. "v" gets identified as "F7").
-        // So we store the last key up/down keycode and compare it to the
-        // current keycode.
-        // See http://bugzilla.qooxdoo.org/show_bug.cgi?id=603
-        if(keyCode != this.__lastKeyCode)
-        {
-          return this._idealKeyHandler(0, this.__lastKeyCode, type, domEvent);
-        }
-        else
-        {
-          if (qx.event.util.Keyboard.keyCodeToIdentifierMap[domEvent.keyCode]) {
-            return this._idealKeyHandler(domEvent.keyCode, 0, domEvent.type, domEvent);
+          // Some keys are identified differently for key up/down and keypress
+          // (e.g. "v" gets identified as "F7").
+          // So we store the last key up/down keycode and compare it to the
+          // current keycode.
+          // See http://bugzilla.qooxdoo.org/show_bug.cgi?id=603
+          if (keyCode != this.__lastKeyCode) {
+            return this._idealKeyHandler(0, this.__lastKeyCode, type, domEvent);
           } else {
-            return this._idealKeyHandler(0, domEvent.keyCode, domEvent.type, domEvent);
+            if (
+              qx.event.util.Keyboard.keyCodeToIdentifierMap[domEvent.keyCode]
+            ) {
+              return this._idealKeyHandler(
+                domEvent.keyCode,
+                0,
+                domEvent.type,
+                domEvent
+              );
+            } else {
+              return this._idealKeyHandler(
+                0,
+                domEvent.keyCode,
+                domEvent.type,
+                domEvent
+              );
+            }
           }
         }
-
-      }
-    })),
-
-
-
-
+      })
+    ),
 
     /*
     ---------------------------------------------------------------------------
@@ -515,134 +586,118 @@ qx.Class.define("qx.event.handler.Keyboard",
      * @param domEvent {Element} DomEvent
      * @return {qx.Promise?} a promise, if an event handler created one
      */
-    _idealKeyHandler : function(keyCode, charCode, eventType, domEvent)
-    {
+    _idealKeyHandler(keyCode, charCode, eventType, domEvent) {
       var keyIdentifier;
 
       // Use: keyCode
-      if (keyCode || (!keyCode && !charCode))
-      {
+      if (keyCode || (!keyCode && !charCode)) {
         keyIdentifier = qx.event.util.Keyboard.keyCodeToIdentifier(keyCode);
 
         return this._fireSequenceEvent(domEvent, eventType, keyIdentifier);
       }
 
       // Use: charCode
-      else
-      {
+      else {
         keyIdentifier = qx.event.util.Keyboard.charCodeToIdentifier(charCode);
 
         var tracker = {};
         var self = this;
-        qx.event.Utils.track(tracker, this._fireSequenceEvent(domEvent, "keypress", keyIdentifier));
-        return qx.event.Utils.then(tracker, function() {
+        qx.event.Utils.track(
+          tracker,
+          this._fireSequenceEvent(domEvent, "keypress", keyIdentifier)
+        );
+
+        return qx.event.Utils.then(tracker, function () {
           return self._fireInputEvent(domEvent, charCode);
         });
       }
     },
 
-
-
-
-
-
     /*
     ---------------------------------------------------------------------------
       KEY MAPS
     ---------------------------------------------------------------------------
     */
 
-
     /**
      * @type {Map} maps the charcodes of special keys for key press emulation
      *
      * @lint ignoreReferenceField(_emulateKeyPress)
      */
-    _emulateKeyPress : qx.core.Environment.select("engine.name",
-    {
-      "mshtml" : {
+    _emulateKeyPress: qx.core.Environment.select("engine.name", {
+      mshtml: {
         8: true,
         9: true
       },
 
-      "webkit" : {
+      webkit: {
         8: true,
         9: true,
         27: true
       },
 
-      "gecko" : (qx.core.Environment.get("browser.version") >= 65) ?
-      {
-        8: true,
-        9: true,
-        27: true
-      }
-      :
-      {
-      },
+      gecko:
+        qx.core.Environment.get("browser.version") >= 65
+          ? {
+              8: true,
+              9: true,
+              27: true
+            }
+          : {},
 
-      "default" : {}
+      default: {}
     }),
 
-
-
-
     /*
     ---------------------------------------------------------------------------
       HELPER METHODS
     ---------------------------------------------------------------------------
     */
 
-
     /**
      * converts a key identifier back to a keycode
      *
      * @param keyIdentifier {String} The key identifier to convert
      * @return {Integer} keyboard code
      */
-    _identifierToKeyCode : function(keyIdentifier) {
-      return qx.event.util.Keyboard.identifierToKeyCodeMap[keyIdentifier] || keyIdentifier.charCodeAt(0);
+    _identifierToKeyCode(keyIdentifier) {
+      return (
+        qx.event.util.Keyboard.identifierToKeyCodeMap[keyIdentifier] ||
+        keyIdentifier.charCodeAt(0)
+      );
     }
   },
 
-
-
-
-
-
   /*
   *****************************************************************************
      DESTRUCTOR
   *****************************************************************************
   */
 
-  destruct : function()
-  {
+  destruct() {
     this._stopKeyObserver();
-    this.__lastKeyCode = this.__manager = this.__window = this.__root = this.__lastUpDownType = null;
+    this.__lastKeyCode =
+      this.__manager =
+      this.__window =
+      this.__root =
+      this.__lastUpDownType =
+        null;
   },
 
-
-
-
-
   /*
   *****************************************************************************
      DEFER
   *****************************************************************************
   */
 
-  defer : function(statics, members)
-  {
+  defer(statics, members) {
     // register at the event handler
     qx.event.Registration.addHandler(statics);
 
-    if ((qx.core.Environment.get("engine.name") !== "opera"))
-    {
-      members._charCode2KeyCode =
-      {
-        13 : 13,
-        27 : 27
+    if (qx.core.Environment.get("engine.name") !== "opera") {
+      members._charCode2KeyCode = {
+        13: 13,
+        27: 27
       };
     }
   }