ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/core/platform/CCInputManager.js

@@ -0,0 +1,616 @@
+/****************************************************************************
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+/**
+ * ignore
+ */
+
+/**
+ * @constant
+ * @type {number}
+ */
+cc.UIInterfaceOrientationLandscapeLeft = -90;
+/**
+ * @constant
+ * @type {number}
+ */
+cc.UIInterfaceOrientationLandscapeRight = 90;
+/**
+ * @constant
+ * @type {number}
+ */
+cc.UIInterfaceOrientationPortraitUpsideDown = 180;
+/**
+ * @constant
+ * @type {number}
+ */
+cc.UIInterfaceOrientationPortrait = 0;
+
+/**
+ * <p>
+ *  This class manages all events of input. include: touch, mouse, accelerometer, keyboard                                       <br/>
+ * </p>
+ * @class
+ * @name cc.inputManager
+ */
+cc.inputManager = /** @lends cc.inputManager# */{
+    _mousePressed: false,
+
+    _isRegisterEvent: false,
+
+    _preTouchPoint: cc.p(0,0),
+    _prevMousePoint: cc.p(0,0),
+
+    _preTouchPool: [],
+    _preTouchPoolPointer: 0,
+
+    _touches: [],
+    _touchesIntegerDict:{},
+
+    _indexBitsUsed: 0,
+    _maxTouches: 5,
+
+    _accelEnabled: false,
+    _accelInterval: 1/30,
+    _accelMinus: 1,
+    _accelCurTime: 0,
+    _acceleration: null,
+    _accelDeviceEvent: null,
+
+    _getUnUsedIndex: function () {
+        var temp = this._indexBitsUsed;
+
+        for (var i = 0; i < this._maxTouches; i++) {
+            if (!(temp & 0x00000001)) {
+                this._indexBitsUsed |= (1 << i);
+                return i;
+            }
+            temp >>= 1;
+        }
+
+        // all bits are used
+        return -1;
+    },
+
+    _removeUsedIndexBit: function (index) {
+        if (index < 0 || index >= this._maxTouches)
+            return;
+
+        var temp = 1 << index;
+        temp = ~temp;
+        this._indexBitsUsed &= temp;
+    },
+
+    _glView: null,
+
+    /**
+     * @function
+     * @param {Array} touches
+     */
+    handleTouchesBegin: function (touches) {
+        var selTouch, index, curTouch, touchID, handleTouches = [], locTouchIntDict = this._touchesIntegerDict;
+        for(var i = 0, len = touches.length; i< len; i ++){
+            selTouch = touches[i];
+            touchID = selTouch.getID();
+            index = locTouchIntDict[touchID];
+
+            if(index == null){
+                var unusedIndex = this._getUnUsedIndex();
+                if (unusedIndex == -1) {
+                    cc.log(cc._LogInfos.inputManager_handleTouchesBegin, unusedIndex);
+                    continue;
+                }
+                //curTouch = this._touches[unusedIndex] = selTouch;
+                curTouch = this._touches[unusedIndex] = new cc.Touch(selTouch._point.x, selTouch._point.y, selTouch.getID());
+                curTouch._setPrevPoint(selTouch._prevPoint);
+                locTouchIntDict[touchID] = unusedIndex;
+                handleTouches.push(curTouch);
+            }
+        }
+        if(handleTouches.length > 0){
+            this._glView._convertTouchesWithScale(handleTouches);
+            var touchEvent = new cc.EventTouch(handleTouches);
+            touchEvent._eventCode = cc.EventTouch.EventCode.BEGAN;
+            cc.eventManager.dispatchEvent(touchEvent);
+        }
+    },
+
+    /**
+     * @function
+     * @param {Array} touches
+     */
+    handleTouchesMove: function(touches){
+        var selTouch, index, touchID, handleTouches = [], locTouches = this._touches;
+        for(var i = 0, len = touches.length; i< len; i ++){
+            selTouch = touches[i];
+            touchID = selTouch.getID();
+            index = this._touchesIntegerDict[touchID];
+
+            if(index == null){
+                //cc.log("if the index doesn't exist, it is an error");
+                continue;
+            }
+            if(locTouches[index]){
+                locTouches[index]._setPoint(selTouch._point);
+                locTouches[index]._setPrevPoint(selTouch._prevPoint);
+                handleTouches.push(locTouches[index]);
+            }
+        }
+        if(handleTouches.length > 0){
+            this._glView._convertTouchesWithScale(handleTouches);
+            var touchEvent = new cc.EventTouch(handleTouches);
+            touchEvent._eventCode = cc.EventTouch.EventCode.MOVED;
+            cc.eventManager.dispatchEvent(touchEvent);
+        }
+    },
+
+    /**
+     * @function
+     * @param {Array} touches
+     */
+    handleTouchesEnd: function(touches){
+        var handleTouches = this.getSetOfTouchesEndOrCancel(touches);
+        if(handleTouches.length > 0) {
+            this._glView._convertTouchesWithScale(handleTouches);
+            var touchEvent = new cc.EventTouch(handleTouches);
+            touchEvent._eventCode = cc.EventTouch.EventCode.ENDED;
+            cc.eventManager.dispatchEvent(touchEvent);
+        }
+    },
+
+    /**
+     * @function
+     * @param {Array} touches
+     */
+    handleTouchesCancel: function(touches){
+        var handleTouches = this.getSetOfTouchesEndOrCancel(touches);
+        if(handleTouches.length > 0) {
+            this._glView._convertTouchesWithScale(handleTouches);
+            var touchEvent = new cc.EventTouch(handleTouches);
+            touchEvent._eventCode = cc.EventTouch.EventCode.CANCELLED;
+            cc.eventManager.dispatchEvent(touchEvent);
+        }
+    },
+
+    /**
+     * @function
+     * @param {Array} touches
+     * @returns {Array}
+     */
+    getSetOfTouchesEndOrCancel: function(touches) {
+        var selTouch, index, touchID, handleTouches = [], locTouches = this._touches, locTouchesIntDict = this._touchesIntegerDict;
+        for(var i = 0, len = touches.length; i< len; i ++){
+            selTouch = touches[i];
+            touchID = selTouch.getID();
+            index = locTouchesIntDict[touchID];
+
+            if(index == null){
+                continue;  //cc.log("if the index doesn't exist, it is an error");
+            }
+            if(locTouches[index]){
+                locTouches[index]._setPoint(selTouch._point);
+                locTouches[index]._setPrevPoint(selTouch._prevPoint);
+                handleTouches.push(locTouches[index]);
+                this._removeUsedIndexBit(index);
+                delete locTouchesIntDict[touchID];
+            }
+        }
+        return handleTouches;
+    },
+
+    /**
+     * @function
+     * @param {HTMLElement} element
+     * @return {Object}
+     */
+    getHTMLElementPosition: function (element) {
+        var docElem = document.documentElement;
+        var win = window;
+        var box = null;
+        if (cc.isFunction(element.getBoundingClientRect)) {
+            box = element.getBoundingClientRect();
+        } else {
+            if (element instanceof HTMLCanvasElement) {
+                box = {
+                    left: 0,
+                    top: 0,
+                    width: element.width,
+                    height: element.height
+                };
+            } else {
+                box = {
+                    left: 0,
+                    top: 0,
+                    width: parseInt(element.style.width),
+                    height: parseInt(element.style.height)
+                };
+            }
+        }
+        return {
+            left: box.left + win.pageXOffset - docElem.clientLeft,
+            top: box.top + win.pageYOffset - docElem.clientTop,
+            width: box.width,
+            height: box.height
+        };
+    },
+
+    /**
+     * @function
+     * @param {cc.Touch} touch
+     * @return {cc.Touch}
+     */
+    getPreTouch: function(touch){
+        var preTouch = null;
+        var locPreTouchPool = this._preTouchPool;
+        var id = touch.getID();
+        for (var i = locPreTouchPool.length - 1; i >= 0; i--) {
+            if (locPreTouchPool[i].getID() == id) {
+                preTouch = locPreTouchPool[i];
+                break;
+            }
+        }
+        if (!preTouch)
+            preTouch = touch;
+        return preTouch;
+    },
+
+    /**
+     * @function
+     * @param {cc.Touch} touch
+     */
+    setPreTouch: function(touch){
+        var find = false;
+        var locPreTouchPool = this._preTouchPool;
+        var id = touch.getID();
+        for (var i = locPreTouchPool.length - 1; i >= 0; i--) {
+            if (locPreTouchPool[i].getID() == id) {
+                locPreTouchPool[i] = touch;
+                find = true;
+                break;
+            }
+        }
+        if (!find) {
+            if (locPreTouchPool.length <= 50) {
+                locPreTouchPool.push(touch);
+            } else {
+                locPreTouchPool[this._preTouchPoolPointer] = touch;
+                this._preTouchPoolPointer = (this._preTouchPoolPointer + 1) % 50;
+            }
+        }
+    },
+
+    /**
+     * @function
+     * @param {Number} tx
+     * @param {Number} ty
+     * @param {cc.Point} pos
+     * @return {cc.Touch}
+     */
+    getTouchByXY: function(tx, ty, pos){
+        var locPreTouch = this._preTouchPoint;
+        var location = this._glView.convertToLocationInView(tx, ty, pos);
+        var touch = new cc.Touch(location.x,  location.y);
+        touch._setPrevPoint(locPreTouch.x, locPreTouch.y);
+        locPreTouch.x = location.x;
+        locPreTouch.y = location.y;
+        return touch;
+    },
+
+    /**
+     * @function
+     * @param {cc.Point} location
+     * @param {cc.Point} pos
+     * @param {Number} eventType
+     * @returns {cc.EventMouse}
+     */
+    getMouseEvent: function(location, pos, eventType){
+        var locPreMouse = this._prevMousePoint;
+        this._glView._convertMouseToLocationInView(location, pos);
+        var mouseEvent = new cc.EventMouse(eventType);
+        mouseEvent.setLocation(location.x, location.y);
+        mouseEvent._setPrevCursor(locPreMouse.x, locPreMouse.y);
+        locPreMouse.x = location.x;
+        locPreMouse.y = location.y;
+        return mouseEvent;
+    },
+
+    /**
+     * @function
+     * @param {Touch} event
+     * @param {cc.Point} pos
+     * @return {cc.Point}
+     */
+    getPointByEvent: function(event, pos){
+        if (event.pageX != null)  //not avalable in <= IE8
+            return {x: event.pageX, y: event.pageY};
+
+        pos.left -= document.body.scrollLeft;
+        pos.top -= document.body.scrollTop;
+        return {x: event.clientX, y: event.clientY};
+    },
+
+    /**
+     * @function
+     * @param {Touch} event
+     * @param {cc.Point} pos
+     * @returns {Array}
+     */
+    getTouchesByEvent: function(event, pos){
+        var touchArr = [], locView = this._glView;
+        var touch_event, touch, preLocation;
+        var locPreTouch = this._preTouchPoint;
+
+        var length = event.changedTouches.length;
+        for (var i = 0; i < length; i++) {
+            touch_event = event.changedTouches[i];
+            if (touch_event) {
+                var location;
+                if (cc.sys.BROWSER_TYPE_FIREFOX === cc.sys.browserType)
+                    location = locView.convertToLocationInView(touch_event.pageX, touch_event.pageY, pos);
+                else
+                    location = locView.convertToLocationInView(touch_event.clientX, touch_event.clientY, pos);
+                if (touch_event.identifier != null) {
+                    touch = new cc.Touch(location.x, location.y, touch_event.identifier);
+                    //use Touch Pool
+                    preLocation = this.getPreTouch(touch).getLocation();
+                    touch._setPrevPoint(preLocation.x, preLocation.y);
+                    this.setPreTouch(touch);
+                } else {
+                    touch = new cc.Touch(location.x, location.y);
+                    touch._setPrevPoint(locPreTouch.x, locPreTouch.y);
+                }
+                locPreTouch.x = location.x;
+                locPreTouch.y = location.y;
+                touchArr.push(touch);
+            }
+        }
+        return touchArr;
+    },
+
+    /**
+     * @function
+     * @param {HTMLElement} element
+     */
+    registerSystemEvent: function(element){
+        if(this._isRegisterEvent) return;
+
+        var locView = this._glView = cc.view;
+        var selfPointer = this;
+        var supportMouse = ('mouse' in cc.sys.capabilities), supportTouches = ('touches' in cc.sys.capabilities);
+
+        //HACK
+        //  - At the same time to trigger the ontouch event and onmouse event
+        //  - The function will execute 2 times
+        //The known browser:
+        //  liebiao
+        //  miui
+        //  WECHAT
+        var prohibition = false;
+        if( cc.sys.isMobile)
+            prohibition = true;
+
+        //register touch event
+        if (supportMouse) {
+            cc._addEventListener(window, 'mousedown', function () {
+                selfPointer._mousePressed = true;
+            }, false);
+
+            cc._addEventListener(window, 'mouseup', function (event) {
+                if(prohibition) return;
+                var savePressed = selfPointer._mousePressed;
+                selfPointer._mousePressed = false;
+
+                if(!savePressed)
+                    return;
+
+                var pos = selfPointer.getHTMLElementPosition(element);
+                var location = selfPointer.getPointByEvent(event, pos);
+                if (!cc.rectContainsPoint(new cc.Rect(pos.left, pos.top, pos.width, pos.height), location)){
+                    selfPointer.handleTouchesEnd([selfPointer.getTouchByXY(location.x, location.y, pos)]);
+
+                    var mouseEvent = selfPointer.getMouseEvent(location,pos,cc.EventMouse.UP);
+                    mouseEvent.setButton(event.button);
+                    cc.eventManager.dispatchEvent(mouseEvent);
+                }
+            }, false);
+
+            //register canvas mouse event
+            cc._addEventListener(element,"mousedown", function (event) {
+                if(prohibition) return;
+                selfPointer._mousePressed = true;
+
+                var pos = selfPointer.getHTMLElementPosition(element);
+                var location = selfPointer.getPointByEvent(event, pos);
+
+                selfPointer.handleTouchesBegin([selfPointer.getTouchByXY(location.x, location.y, pos)]);
+
+                var mouseEvent = selfPointer.getMouseEvent(location,pos,cc.EventMouse.DOWN);
+                mouseEvent.setButton(event.button);
+                cc.eventManager.dispatchEvent(mouseEvent);
+
+                event.stopPropagation();
+                event.preventDefault();
+                element.focus();
+            }, false);
+
+            cc._addEventListener(element, "mouseup", function (event) {
+                if(prohibition) return;
+                selfPointer._mousePressed = false;
+
+                var pos = selfPointer.getHTMLElementPosition(element);
+                var location = selfPointer.getPointByEvent(event, pos);
+
+                selfPointer.handleTouchesEnd([selfPointer.getTouchByXY(location.x, location.y, pos)]);
+
+                var mouseEvent = selfPointer.getMouseEvent(location,pos,cc.EventMouse.UP);
+                mouseEvent.setButton(event.button);
+                cc.eventManager.dispatchEvent(mouseEvent);
+
+                event.stopPropagation();
+                event.preventDefault();
+            }, false);
+
+            cc._addEventListener(element, "mousemove", function (event) {
+                if(prohibition) return;
+
+                var pos = selfPointer.getHTMLElementPosition(element);
+                var location = selfPointer.getPointByEvent(event, pos);
+
+                selfPointer.handleTouchesMove([selfPointer.getTouchByXY(location.x, location.y, pos)]);
+
+                var mouseEvent = selfPointer.getMouseEvent(location,pos,cc.EventMouse.MOVE);
+                if(selfPointer._mousePressed)
+                    mouseEvent.setButton(event.button);
+                else
+                    mouseEvent.setButton(null);
+                cc.eventManager.dispatchEvent(mouseEvent);
+
+                event.stopPropagation();
+                event.preventDefault();
+            }, false);
+
+            cc._addEventListener(element, "mousewheel", function (event) {
+                var pos = selfPointer.getHTMLElementPosition(element);
+                var location = selfPointer.getPointByEvent(event, pos);
+
+                var mouseEvent = selfPointer.getMouseEvent(location,pos,cc.EventMouse.SCROLL);
+                mouseEvent.setButton(event.button);
+                mouseEvent.setScrollData(0, event.wheelDelta);
+                cc.eventManager.dispatchEvent(mouseEvent);
+
+                event.stopPropagation();
+                event.preventDefault();
+            }, false);
+
+            /* firefox fix */
+            cc._addEventListener(element, "DOMMouseScroll", function(event) {
+                var pos = selfPointer.getHTMLElementPosition(element);
+                var location = selfPointer.getPointByEvent(event, pos);
+
+                var mouseEvent = selfPointer.getMouseEvent(location,pos,cc.EventMouse.SCROLL);
+                mouseEvent.setButton(event.button);
+                mouseEvent.setScrollData(0, event.detail * -120);
+                cc.eventManager.dispatchEvent(mouseEvent);
+
+                event.stopPropagation();
+                event.preventDefault();
+            }, false);
+        }
+
+        if(window.navigator.msPointerEnabled){
+            var _pointerEventsMap = {
+                "MSPointerDown"     : selfPointer.handleTouchesBegin,
+                "MSPointerMove"     : selfPointer.handleTouchesMove,
+                "MSPointerUp"       : selfPointer.handleTouchesEnd,
+                "MSPointerCancel"   : selfPointer.handleTouchesCancel
+            };
+
+            for(var eventName in _pointerEventsMap){
+                (function(_pointerEvent, _touchEvent){
+                    cc._addEventListener(element, _pointerEvent, function (event){
+                        var pos = selfPointer.getHTMLElementPosition(element);
+                        pos.left -= document.documentElement.scrollLeft;
+                        pos.top -= document.documentElement.scrollTop;
+
+                        _touchEvent.call(selfPointer, [selfPointer.getTouchByXY(event.clientX, event.clientY, pos)]);
+                        event.stopPropagation();
+                    }, false);
+                })(eventName, _pointerEventsMap[eventName]);
+            }
+        }
+
+        if(supportTouches) {
+            //register canvas touch event
+            cc._addEventListener(element,"touchstart", function (event) {
+                if (!event.changedTouches) return;
+
+                var pos = selfPointer.getHTMLElementPosition(element);
+                pos.left -= document.body.scrollLeft;
+                pos.top -= document.body.scrollTop;
+                selfPointer.handleTouchesBegin(selfPointer.getTouchesByEvent(event, pos));
+                event.stopPropagation();
+                event.preventDefault();
+                element.focus();
+            }, false);
+
+            cc._addEventListener(element, "touchmove", function (event) {
+                if (!event.changedTouches) return;
+
+                var pos = selfPointer.getHTMLElementPosition(element);
+                pos.left -= document.body.scrollLeft;
+                pos.top -= document.body.scrollTop;
+                selfPointer.handleTouchesMove(selfPointer.getTouchesByEvent(event, pos));
+                event.stopPropagation();
+                event.preventDefault();
+            }, false);
+
+            cc._addEventListener(element, "touchend", function (event) {
+                if (!event.changedTouches) return;
+
+                var pos = selfPointer.getHTMLElementPosition(element);
+                pos.left -= document.body.scrollLeft;
+                pos.top -= document.body.scrollTop;
+                selfPointer.handleTouchesEnd(selfPointer.getTouchesByEvent(event, pos));
+                event.stopPropagation();
+                event.preventDefault();
+            }, false);
+
+            cc._addEventListener(element, "touchcancel", function (event) {
+                if (!event.changedTouches) return;
+
+                var pos = selfPointer.getHTMLElementPosition(element);
+                pos.left -= document.body.scrollLeft;
+                pos.top -= document.body.scrollTop;
+                selfPointer.handleTouchesCancel(selfPointer.getTouchesByEvent(event, pos));
+                event.stopPropagation();
+                event.preventDefault();
+            }, false);
+        }
+
+        //register keyboard event
+        this._registerKeyboardEvent();
+
+        //register Accelerometer event
+        this._registerAccelerometerEvent();
+
+        this._isRegisterEvent = true;
+    },
+
+    _registerKeyboardEvent: function(){},
+
+    _registerAccelerometerEvent: function(){},
+
+    /**
+     * @function
+     * @param {Number} dt
+     */
+    update:function(dt){
+        if(this._accelCurTime > this._accelInterval){
+            this._accelCurTime -= this._accelInterval;
+            cc.eventManager.dispatchEvent(new cc.EventAcceleration(this._acceleration));
+        }
+        this._accelCurTime += dt;
+    }
+};