@openglobus/og 0.11.1 → 0.11.6

package/src/og/input/KeyboardHandler.js

@@ -6,124 +6,127 @@
 
 import { input } from './input.js';
 
-const KeyboardHandler = function () {
-    var _currentlyPressedKeys = {};
-    var _pressedKeysCallbacks = {};
-    var _unpressedKeysCallbacks = {};
-    var _charkeysCallbacks = {};
-    var _that = this;
-    var _anykeyCallback = null;
-    var _event = null;
-
-    var _active = true;
-
-    if (KeyboardHandler.prototype._instance) {
-        return KeyboardHandler.prototype._instance;
-    } else {
-        KeyboardHandler.prototype._instance = this;
-
-        document.onkeydown = function (event) { _event = event; _active && _that.handleKeyDown(); };
-        document.onkeyup = function (event) { _event = event; _active && _that.handleKeyUp(); };
-    }
-
-    var _sortByPriority = function (a, b) {
-        return a.priority < b.priority;
-    };
+class KeyboardHandler {
+
+    constructor() {
+        var _currentlyPressedKeys = {};
+        var _pressedKeysCallbacks = {};
+        var _unpressedKeysCallbacks = {};
+        var _charkeysCallbacks = {};
+        var _that = this;
+        var _anykeyCallback = null;
+        var _event = null;
+
+        var _active = true;
+
+        if (KeyboardHandler.prototype._instance) {
+            return KeyboardHandler.prototype._instance;
+        } else {
+            KeyboardHandler.prototype._instance = this;
+
+            document.onkeydown = function (event) { _event = event; _active && _that.handleKeyDown(); };
+            document.onkeyup = function (event) { _event = event; _active && _that.handleKeyUp(); };
+        }
 
-    this.removeEvent = function (events, callback) {
-        //
-        // TODO:...
-        //
-    };
+        var _sortByPriority = function (a, b) {
+            return a.priority < b.priority;
+        };
 
-    this.setActivity = function (activity) {
-        _active = activity;
-    };
+        this.removeEvent = function (events, callback) {
+            //
+            // TODO:...
+            //
+        };
 
-    this.releaseKeys = function () {
-        _currentlyPressedKeys = {};
-    }
+        this.setActivity = function (activity) {
+            _active = activity;
+        };
 
-    this.addEvent = function (event, sender, callback, keyCode, priority) {
-        if (priority === undefined) {
-            priority = 1600;
+        this.releaseKeys = function () {
+            _currentlyPressedKeys = {};
         }
-        switch (event) {
-            case "keyfree":
-                if (!_unpressedKeysCallbacks[keyCode]) {
-                    _unpressedKeysCallbacks[keyCode] = [];
-                }
-                _unpressedKeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
-                _unpressedKeysCallbacks[keyCode].sort(_sortByPriority);
-                break;
-
-            case "keypress":
-                if (keyCode == null) {
-                    _anykeyCallback = { callback: callback, sender: sender || _that };
-                } else {
-                    if (!_pressedKeysCallbacks[keyCode]) {
-                        _pressedKeysCallbacks[keyCode] = [];
+
+        this.addEvent = function (event, sender, callback, keyCode, priority) {
+            if (priority === undefined) {
+                priority = 1600;
+            }
+            switch (event) {
+                case "keyfree":
+                    if (!_unpressedKeysCallbacks[keyCode]) {
+                        _unpressedKeysCallbacks[keyCode] = [];
                     }
-                    _pressedKeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
-                    _pressedKeysCallbacks[keyCode].sort(_sortByPriority);
-                }
-                break;
+                    _unpressedKeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
+                    _unpressedKeysCallbacks[keyCode].sort(_sortByPriority);
+                    break;
+
+                case "keypress":
+                    if (keyCode == null) {
+                        _anykeyCallback = { callback: callback, sender: sender || _that };
+                    } else {
+                        if (!_pressedKeysCallbacks[keyCode]) {
+                            _pressedKeysCallbacks[keyCode] = [];
+                        }
+                        _pressedKeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
+                        _pressedKeysCallbacks[keyCode].sort(_sortByPriority);
+                    }
+                    break;
 
-            case "charkeypress":
-                if (!_charkeysCallbacks[keyCode]) {
-                    _charkeysCallbacks[keyCode] = [];
-                }
-                _charkeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
-                _charkeysCallbacks[keyCode].sort(_sortByPriority);
-                break;
-        }
-    };
-
-    this.isKeyPressed = function (keyCode) {
-        return _currentlyPressedKeys[keyCode];
-    };
-
-    this.handleKeyDown = function () {
-        _anykeyCallback && _anykeyCallback.callback.call(_anykeyCallback.sender, _event);
-        _currentlyPressedKeys[_event.keyCode] = true;
-        for (var ch in _charkeysCallbacks) {
-            if (String.fromCharCode(_event.keyCode) == String.fromCharCode(ch)) {
-                var ccl = _charkeysCallbacks[ch];
-                for (var i = 0; i < ccl.length; i++) {
-                    ccl[i].callback.call(ccl[i].sender, _event);
+                case "charkeypress":
+                    if (!_charkeysCallbacks[keyCode]) {
+                        _charkeysCallbacks[keyCode] = [];
+                    }
+                    _charkeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
+                    _charkeysCallbacks[keyCode].sort(_sortByPriority);
+                    break;
+            }
+        };
+
+        this.isKeyPressed = function (keyCode) {
+            return _currentlyPressedKeys[keyCode];
+        };
+
+        this.handleKeyDown = function () {
+            _anykeyCallback && _anykeyCallback.callback.call(_anykeyCallback.sender, _event);
+            _currentlyPressedKeys[_event.keyCode] = true;
+            for (var ch in _charkeysCallbacks) {
+                if (String.fromCharCode(_event.keyCode) == String.fromCharCode(ch)) {
+                    var ccl = _charkeysCallbacks[ch];
+                    for (var i = 0; i < ccl.length; i++) {
+                        ccl[i].callback.call(ccl[i].sender, _event);
+                    }
                 }
             }
-        }
 
-        if (_event.keyCode == input.KEY_ALT || _event.keyCode == input.KEY_SHIFT) {
-            _event.preventDefault();
-        }
-    };
+            if (_event.keyCode == input.KEY_ALT || _event.keyCode == input.KEY_SHIFT) {
+                _event.preventDefault();
+            }
+        };
+
+        this.handleKeyUp = function () {
+            if (_currentlyPressedKeys[_event.keyCode] || _event.keyCode === input.KEY_PRINTSCREEN) {
+                for (var pk in _unpressedKeysCallbacks) {
+                    if (_currentlyPressedKeys[pk] || _event.keyCode === input.KEY_PRINTSCREEN && pk == input.KEY_PRINTSCREEN) {
+                        var cpk = _unpressedKeysCallbacks[pk];
+                        for (var i = 0; i < cpk.length; i++) {
+                            cpk[i].callback.call(cpk[i].sender, _event);
+                        }
+                    }
+                }
+            }
+            _currentlyPressedKeys[_event.keyCode] = false;
+        };
 
-    this.handleKeyUp = function () {
-        if (_currentlyPressedKeys[_event.keyCode] || _event.keyCode === input.KEY_PRINTSCREEN) {
-            for (var pk in _unpressedKeysCallbacks) {
-                if (_currentlyPressedKeys[pk] || _event.keyCode === input.KEY_PRINTSCREEN && pk == input.KEY_PRINTSCREEN) {
-                    var cpk = _unpressedKeysCallbacks[pk];
+        this.handleEvents = function () {
+            for (var pk in _pressedKeysCallbacks) {
+                if (_currentlyPressedKeys[pk]) {
+                    var cpk = _pressedKeysCallbacks[pk];
                     for (var i = 0; i < cpk.length; i++) {
                         cpk[i].callback.call(cpk[i].sender, _event);
                     }
                 }
             }
-        }
-        _currentlyPressedKeys[_event.keyCode] = false;
-    };
-
-    this.handleEvents = function () {
-        for (var pk in _pressedKeysCallbacks) {
-            if (_currentlyPressedKeys[pk]) {
-                var cpk = _pressedKeysCallbacks[pk];
-                for (var i = 0; i < cpk.length; i++) {
-                    cpk[i].callback.call(cpk[i].sender, _event);
-                }
-            }
-        }
-    };
-};
+        };
+    }
+}
 
-export { KeyboardHandler };
+export { KeyboardHandler };

package/src/og/input/MouseHandler.js

@@ -4,92 +4,95 @@
 
 'use strict';
 
-const MouseHandler = function (htmlObject) {
-    this._htmlObject = htmlObject;
-};
+class MouseHandler {
 
-MouseHandler.prototype.setEvent = function (event, sender, callback) {
-    switch (event) {
-        case "mousewheel":
-            this._htmlObject.addEventListener('mousewheel', function (evt) {
-                var delta = evt.deltaY || evt.detail || evt.wheelDelta;
-                if (evt.wheelDelta == undefined) {
-                    evt.wheelDelta = delta * (-120);
-                }
-                callback.call(sender, evt);
-                evt.preventDefault();
-            }, false);
+    constructor(htmlObject) {
+        this._htmlObject = htmlObject;
+    }
+
+    setEvent(event, sender, callback) {
+        switch (event) {
+            case "mousewheel":
+                this._htmlObject.addEventListener('mousewheel', function (evt) {
+                    var delta = evt.deltaY || evt.detail || evt.wheelDelta;
+                    if (evt.wheelDelta == undefined) {
+                        evt.wheelDelta = delta * (-120);
+                    }
+                    callback.call(sender, evt);
+                    evt.preventDefault();
+                }, false);
 
-            this._htmlObject.addEventListener('wheel', function (evt) {
-                var delta = evt.deltaY || evt.detail || evt.wheelDelta;
-                if (evt.wheelDelta == undefined) {
-                    evt.wheelDelta = delta * (-120);
-                }
-                callback.call(sender, evt);
-                evt.preventDefault();
-            }, false);
-            break;
+                this._htmlObject.addEventListener('wheel', function (evt) {
+                    var delta = evt.deltaY || evt.detail || evt.wheelDelta;
+                    if (evt.wheelDelta == undefined) {
+                        evt.wheelDelta = delta * (-120);
+                    }
+                    callback.call(sender, evt);
+                    evt.preventDefault();
+                }, false);
+                break;
 
-        case "mousedown":
-            this._htmlObject.addEventListener('mousedown', function (event) {
-                var rect = this.getBoundingClientRect();
-                callback.call(sender, {
-                    button: event.button,
-                    clientX: event.clientX - rect.left,
-                    clientY: event.clientY - rect.top
-                }, event);
-            });
-            this._htmlObject.addEventListener('contextmenu', function (event) {
-                event.preventDefault();
-                return false;
-            });
-            break;
+            case "mousedown":
+                this._htmlObject.addEventListener('mousedown', function (event) {
+                    var rect = this.getBoundingClientRect();
+                    callback.call(sender, {
+                        button: event.button,
+                        clientX: event.clientX - rect.left,
+                        clientY: event.clientY - rect.top
+                    }, event);
+                });
+                this._htmlObject.addEventListener('contextmenu', function (event) {
+                    event.preventDefault();
+                    return false;
+                });
+                break;
 
-        case "mouseup":
-            this._htmlObject.addEventListener('mouseup', function (event) {
-                var rect = this.getBoundingClientRect();
-                callback.call(sender, {
-                    button: event.button,
-                    clientX: event.clientX - rect.left,
-                    clientY: event.clientY - rect.top
-                }, event);
-            });
-            break;
+            case "mouseup":
+                this._htmlObject.addEventListener('mouseup', function (event) {
+                    var rect = this.getBoundingClientRect();
+                    callback.call(sender, {
+                        button: event.button,
+                        clientX: event.clientX - rect.left,
+                        clientY: event.clientY - rect.top
+                    }, event);
+                });
+                break;
 
-        case "mousemove":
-            this._htmlObject.addEventListener('mousemove', function (event) {
-                var rect = this.getBoundingClientRect();
-                callback.call(sender, {
-                    clientX: event.clientX - rect.left,
-                    clientY: event.clientY - rect.top
-                }, event);
-            });
-            break;
+            case "mousemove":
+                this._htmlObject.addEventListener('mousemove', function (event) {
+                    var rect = this.getBoundingClientRect();
+                    callback.call(sender, {
+                        clientX: event.clientX - rect.left,
+                        clientY: event.clientY - rect.top
+                    }, event);
+                });
+                break;
 
-        case "mouseleave":
-            this._htmlObject.addEventListener('mouseleave', function (event) {
-                callback.call(sender, event);
-            });
-            break;
+            case "mouseleave":
+                this._htmlObject.addEventListener('mouseleave', function (event) {
+                    callback.call(sender, event);
+                });
+                break;
 
-        case "mouseout":
-            this._htmlObject.addEventListener('mouseout', function (event) {
-                callback.call(sender, event);
-            });
-            break;
+            case "mouseout":
+                this._htmlObject.addEventListener('mouseout', function (event) {
+                    callback.call(sender, event);
+                });
+                break;
 
-        case "mouseover":
-            this._htmlObject.addEventListener('mouseover', function (event) {
-                callback.call(sender, event);
-            });
-            break;
+            case "mouseover":
+                this._htmlObject.addEventListener('mouseover', function (event) {
+                    callback.call(sender, event);
+                });
+                break;
 
-        case "mouseenter":
-            this._htmlObject.addEventListener('mouseenter', function (event) {
-                callback.call(sender, event);
-            });
-            break;
+            case "mouseenter":
+                this._htmlObject.addEventListener('mouseenter', function (event) {
+                    callback.call(sender, event);
+                });
+                break;
+        }
     }
-};
+}
 
-export { MouseHandler };
+export { MouseHandler };

package/src/og/input/TouchHandler.js

@@ -4,56 +4,60 @@
 
 'use strict';
 
-const TouchHandler = function (htmlObject) {
-    this._htmlObject = htmlObject;
-};
-
-TouchHandler.prototype.setEvent = function (event, sender, callback) {
-    switch (event) {
-        case "touchcancel":
-            this._htmlObject.addEventListener('touchcancel', function (event) {
-                event.preventDefault();
-                var rect = this.getBoundingClientRect();
-                event.offsetLeft = rect.left;
-                event.offsetTop = rect.top;
-                callback.call(sender, event);
-                event.preventDefault();
-            });
-            break;
-
-        case "touchstart":
-            this._htmlObject.addEventListener('touchstart', function (event) {
-                event.preventDefault();
-                var rect = this.getBoundingClientRect();
-                event.offsetLeft = rect.left;
-                event.offsetTop = rect.top;
-                callback.call(sender, event);
-                event.preventDefault();
-            });
-            break;
-
-        case "touchend":
-            this._htmlObject.addEventListener('touchend', function (event) {
-                event.preventDefault();
-                var rect = this.getBoundingClientRect();
-                event.offsetLeft = rect.left;
-                event.offsetTop = rect.top;
-                callback.call(sender, event);
-                event.preventDefault();
-            });
-            break;
-
-        case "touchmove":
-            this._htmlObject.addEventListener('touchmove', function (event) {
-                event.preventDefault();
-                var rect = this.getBoundingClientRect();
-                event.offsetLeft = rect.left;
-                event.offsetTop = rect.top;
-                callback.call(sender, event);
-                event.preventDefault();
-            });
-            break;
+class TouchHandler {
+
+    constructor(htmlObject) {
+        this._htmlObject = htmlObject;
     }
-};
 
-export { TouchHandler };
+    setEvent(event, sender, callback) {
+        switch (event) {
+            case "touchcancel":
+                this._htmlObject.addEventListener('touchcancel', function (event) {
+                    event.preventDefault();
+                    var rect = this.getBoundingClientRect();
+                    event.offsetLeft = rect.left;
+                    event.offsetTop = rect.top;
+                    callback.call(sender, event);
+                    event.preventDefault();
+                });
+                break;
+
+            case "touchstart":
+                this._htmlObject.addEventListener('touchstart', function (event) {
+                    event.preventDefault();
+                    var rect = this.getBoundingClientRect();
+                    event.offsetLeft = rect.left;
+                    event.offsetTop = rect.top;
+                    callback.call(sender, event);
+                    event.preventDefault();
+                });
+                break;
+
+            case "touchend":
+                this._htmlObject.addEventListener('touchend', function (event) {
+                    event.preventDefault();
+                    var rect = this.getBoundingClientRect();
+                    event.offsetLeft = rect.left;
+                    event.offsetTop = rect.top;
+                    callback.call(sender, event);
+                    event.preventDefault();
+                });
+                break;
+
+            case "touchmove":
+                this._htmlObject.addEventListener('touchmove', function (event) {
+                    event.preventDefault();
+                    var rect = this.getBoundingClientRect();
+                    event.offsetLeft = rect.left;
+                    event.offsetTop = rect.top;
+                    callback.call(sender, event);
+                    event.preventDefault();
+                });
+                break;
+        }
+    }
+}
+
+export { TouchHandler };
+