cesium 0.13.0

data/app/assets/javascripts/Core/Queue.js

@@ -0,0 +1,95 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    /**
+     * A queue that can enqueue items at the end, and dequeue items from the front.
+     *
+     * @alias Queue
+     * @constructor
+     */
+    var Queue = function() {
+        this._array = [];
+        this._offset = 0;
+
+        /**
+         * The length of the queue.
+         */
+        this.length = 0;
+    };
+
+    /**
+     * Enqueues the specified item.
+     *
+     * @param {Object} item The item to enqueue.
+     * @memberof Queue
+     */
+    Queue.prototype.enqueue = function(item) {
+        this._array.push(item);
+        this.length++;
+    };
+
+    /**
+     * Dequeues an item.  Returns undefined if the queue is empty.
+     *
+     * @memberof Queue
+     */
+    Queue.prototype.dequeue = function() {
+        if (this.length === 0) {
+            return undefined;
+        }
+
+        var array = this._array;
+        var offset = this._offset;
+        var item = array[offset];
+        array[offset] = undefined;
+
+        offset++;
+        if (offset > 10 && offset * 2 > array.length) {
+            //compact array
+            this._array = array.slice(offset);
+            offset = 0;
+        }
+
+        this._offset = offset;
+        this.length--;
+
+        return item;
+    };
+
+    /**
+     * Check whether this queue contains the specified item.
+     *
+     * @param {Object} the item to search for.
+     * @memberof Queue
+     */
+    Queue.prototype.contains = function(item) {
+        return this._array.indexOf(item) !== -1;
+    };
+
+    /**
+     * Remove all items from the queue.
+     * @memberof Queue
+     */
+    Queue.prototype.clear = function() {
+        this._array.length = this._offset = this.length = 0;
+    };
+
+    /**
+     * Sort the items in the queue in-place.
+     *
+     * @param {Function} compareFunction a function that defines the sort order.
+     * @memberof Queue
+     */
+    Queue.prototype.sort = function(compareFunction) {
+        if (this._offset > 0) {
+            //compact array
+            this._array = this._array.slice(this._offset);
+            this._offset = 0;
+        }
+
+        this._array.sort(compareFunction);
+    };
+
+    return Queue;
+});

data/app/assets/javascripts/Core/Ray.js

@@ -0,0 +1,64 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './defaultValue',
+        './Cartesian3'
+       ], function(
+         DeveloperError,
+         defaultValue,
+         Cartesian3) {
+    "use strict";
+
+    /**
+     * Represents a ray that extends infinitely from the provided origin in the provided direction.
+     * @alias Ray
+     * @constructor
+     *
+     * @param {Cartesian3} [origin=Cartesian3.ZERO] The origin of the ray.
+     * @param {Cartesian3} [direction=Cartesian3.ZERO] The direction of the ray.
+     */
+    var Ray = function(origin, direction) {
+        direction = Cartesian3.clone(defaultValue(direction, Cartesian3.ZERO));
+        if (!direction.equals(Cartesian3.ZERO)) {
+            Cartesian3.normalize(direction, direction);
+        }
+
+        /**
+         * The origin of the ray.
+         * @type {Cartesian3}
+         */
+        this.origin = Cartesian3.clone(defaultValue(origin, Cartesian3.ZERO));
+
+        /**
+         * The direction of the ray.
+         * @type {Cartesian3}
+         */
+        this.direction = direction;
+    };
+
+    /**
+     * Computes the point along the ray given by r(t) = o + t*d,
+     * where o is the origin of the ray and d is the direction.
+     * @memberof Ray
+     *
+     * @param {Number} t A scalar value.
+     * @param {Cartesian3} [result] The object in which the result will be stored.
+     * @returns The modified result parameter, or a new instance if none was provided.
+     *
+     * @exception {DeveloperError} t is a required number
+     *
+     * @example
+     * //Get the first intersection point of a ray and an ellipsoid.
+     * var intersection = IntersectionTests.rayEllipsoid(ray, ellipsoid);
+     * var point = ray.getPoint(intersection.start);
+     */
+    Ray.prototype.getPoint = function(t, result) {
+        if (typeof t !== 'number') {
+            throw new DeveloperError('t is a required number');
+        }
+        result = Cartesian3.multiplyByScalar(this.direction, t, result);
+        return Cartesian3.add(this.origin, result, result);
+    };
+
+    return Ray;
+});

data/app/assets/javascripts/Core/ReferenceFrame.js

@@ -0,0 +1,25 @@
+/*global define*/
+define([
+        './Enumeration'
+       ], function(
+         Enumeration) {
+    "use strict";
+
+    /**
+     * Constants for identifying well-known reference frames.
+     *
+     * @exports ReferenceFrame
+     */
+    var ReferenceFrame = {
+        /**
+         * The fixed frame.
+         */
+        FIXED : new Enumeration(0, 'FIXED'),
+        /**
+         * The inertial frame.
+         */
+        INERTIAL : new Enumeration(1, 'INERTIAL')
+    };
+
+    return ReferenceFrame;
+});

data/app/assets/javascripts/Core/RequestErrorEvent.js

@@ -0,0 +1,35 @@
+/*global define*/
+define([
+    ], function(
+        ) {
+    "use strict";
+
+    /**
+     * An event that is raised when a request encounters an error.
+     *
+     * @constructor
+     * @alias RequestErrorEvent
+     *
+     * @param {Number} [statusCode] The HTTP error status code, such as 404.
+     * @param {Object} [response] The response included along with the error.
+     */
+    var RequestErrorEvent = function RequestErrorEvent(statusCode, response) {
+        /**
+         * The HTTP error status code, such as 404.  If the error does not have a particular
+         * HTTP code, this property will be undefined.
+         *
+         * @type {Number}
+         */
+        this.statusCode = statusCode;
+
+        /**
+         * The response included along with the error.  If the error does not include a response,
+         * this property will be undefined.
+         *
+         * @type {Object}
+         */
+        this.response = response;
+    };
+
+    return RequestErrorEvent;
+});

data/app/assets/javascripts/Core/RuntimeError.js

@@ -0,0 +1,59 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    /**
+     * Constructs an exception object that is thrown due to an error that can occur at runtime, e.g.,
+     * out of memory, could not compile shader, etc.  If a function may throw this
+     * exception, the calling code should be prepared to catch it.
+     * <br /><br />
+     * On the other hand, a {@link DeveloperError} indicates an exception due
+     * to a developer error, e.g., invalid argument, that usually indicates a bug in the
+     * calling code.
+     *
+     * @alias RuntimeError
+     *
+     * @param {String} [message=undefined] The error message for this exception.
+     *
+     * @see DeveloperError
+     * @constructor
+     */
+    var RuntimeError = function(message) {
+        /**
+         * 'RuntimeError' indicating that this exception was thrown due to a runtime error.
+         * @type String
+         * @constant
+         */
+        this.name = 'RuntimeError';
+
+        /**
+         * The explanation for why this exception was thrown.
+         * @type String
+         * @constant
+         */
+        this.message = message;
+
+        /**
+         * The Error object containing the stack trace.
+         * @type Error
+         * @constant
+         *
+         * @see <a href='https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error'>Error object on Mozilla Developer Network</a>.
+         */
+        this.error = new Error();
+    };
+
+    RuntimeError.prototype.toString = function () {
+        var str = this.name + ': ' + this.message;
+        if (typeof this.error !== 'undefined') {
+            if (typeof this.error.stack !== 'undefined') {
+                str += '\n' + this.error.stack.toString();
+            } else {
+                str += '\n' + this.error.toString();
+            }
+        }
+        return str;
+    };
+
+    return RuntimeError;
+});

data/app/assets/javascripts/Core/ScreenSpaceEventHandler.js

@@ -0,0 +1,658 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './destroyObject',
+        './Cartesian2',
+        './JulianDate',
+        './ScreenSpaceEventType',
+        './KeyboardEventModifier'
+    ], function(
+        DeveloperError,
+        destroyObject,
+        Cartesian2,
+        JulianDate,
+        ScreenSpaceEventType,
+        KeyboardEventModifier) {
+    "use strict";
+
+    /**
+     * Handles user input events. Custom functions can be added to be executed on
+     * when the user enters input.
+     *
+     * @alias ScreenSpaceEventHandler
+     *
+     * @param {DOC_TBA} element The element to add events to. Defaults to document.
+     * @constructor
+     */
+    var ScreenSpaceEventHandler = function(element) {
+        this._mouseEvents = {};
+        for ( var button in ScreenSpaceEventType) {
+            if (ScreenSpaceEventType.hasOwnProperty(button)) {
+                this._mouseEvents[button] = 0;
+            }
+        }
+
+        this._modifiedMouseEvents = {};
+        for ( var modifier in KeyboardEventModifier) {
+            if (KeyboardEventModifier.hasOwnProperty(modifier)) {
+                this._modifiedMouseEvents[modifier] = {};
+                for (button in ScreenSpaceEventType) {
+                    if (ScreenSpaceEventType.hasOwnProperty(button)) {
+                        this._modifiedMouseEvents[modifier][button] = 0;
+                    }
+                }
+            }
+        }
+
+        this._leftMouseButtonDown = false;
+        this._middleMouseButtonDown = false;
+        this._rightMouseButtonDown = false;
+        this._isPinching = false;
+        this._seenAnyTouchEvents = false;
+        this._lastMouseX = 0;
+        this._lastMouseY = 0;
+        this._lastTouch2X = 0;
+        this._lastTouch2Y = 0;
+        this._totalPixels = 0;
+        this._touchID1 = 0;
+        this._touchID2 = 0;
+
+        // TODO: Revisit when doing mobile development. May need to be configurable
+        // or determined based on the platform?
+        this._clickPixelTolerance = 5;
+
+        this._element = element || document;
+
+        this._register();
+    };
+
+    ScreenSpaceEventHandler.prototype._getPosition = function(event) {
+        if (this._element === document) {
+            return {
+                x : event.clientX,
+                y : event.clientY
+            };
+        }
+
+        var rect = this._element.getBoundingClientRect();
+        return {
+            x : event.clientX - rect.left,
+            y : event.clientY - rect.top
+        };
+    };
+
+    /**
+     * Set a function to be executed on an input event.
+     *
+     * @memberof ScreenSpaceEventHandler
+     *
+     * @param {Function} action Function to be executed when the input event occurs.
+     * @param {Enumeration} type The ScreenSpaceEventType of input event.
+     * @param {Enumeration} modifier A KeyboardEventModifier key that is held when a <code>type</code>
+     * event occurs.
+     *
+     * @exception {DeveloperError} action is required.
+     * @exception {DeveloperError} type is required.
+     *
+     * @see ScreenSpaceEventHandler#getInputAction
+     * @see ScreenSpaceEventHandler#removeInputAction
+     */
+    ScreenSpaceEventHandler.prototype.setInputAction = function(action, type, modifier) {
+        if (!action) {
+            throw new DeveloperError('action is required.');
+        }
+
+        if (!type) {
+            throw new DeveloperError('type is required.');
+        }
+
+        var mouseEvents;
+        if (modifier && modifier.name) {
+            mouseEvents = this._modifiedMouseEvents[modifier.name];
+        } else {
+            mouseEvents = this._mouseEvents;
+        }
+
+        if (type && type.name && mouseEvents) {
+            mouseEvents[type.name] = action;
+        }
+    };
+
+    /**
+     * Returns the function to be executed on an input event.
+     *
+     * @memberof ScreenSpaceEventHandler
+     *
+     * @param {Enumeration} type The ScreenSpaceEventType of input event.
+     * @param {Enumeration} modifier A KeyboardEventModifier key that is held when a <code>type</code>
+     * event occurs.
+     *
+     * @exception {DeveloperError} type is required.
+     *
+     * @see ScreenSpaceEventHandler#setInputAction
+     * @see ScreenSpaceEventHandler#removeInputAction
+     */
+    ScreenSpaceEventHandler.prototype.getInputAction = function(type, modifier) {
+        if (!type) {
+            throw new DeveloperError('type is required.');
+        }
+
+        var mouseEvents;
+        if (modifier && modifier.name) {
+            mouseEvents = this._modifiedMouseEvents[modifier.name];
+        } else {
+            mouseEvents = this._mouseEvents;
+        }
+
+        if (type && type.name && mouseEvents) {
+            return mouseEvents[type.name];
+        }
+
+        return undefined;
+    };
+
+    /**
+     * Removes the function to be executed on an input event.
+     *
+     * @memberof ScreenSpaceEventHandler
+     *
+     * @param {Enumeration} type The ScreenSpaceEventType of input event.
+     * @param {Enumeration} modifier A KeyboardEventModifier key that is held when a <code>type</code>
+     * event occurs.
+     *
+     * @exception {DeveloperError} type is required.
+     *
+     * @see ScreenSpaceEventHandler#getInputAction
+     * @see ScreenSpaceEventHandler#setInputAction
+     */
+    ScreenSpaceEventHandler.prototype.removeInputAction = function(type, modifier) {
+        if (!type) {
+            throw new DeveloperError('type is required.');
+        }
+
+        var mouseEvents;
+        if (modifier && modifier.name) {
+            mouseEvents = this._modifiedMouseEvents[modifier.name];
+        } else {
+            mouseEvents = this._mouseEvents;
+        }
+
+        if (type && type.name && mouseEvents && mouseEvents[type.name]) {
+            delete mouseEvents[type.name];
+        }
+    };
+
+    ScreenSpaceEventHandler.prototype._getModifier = function(event) {
+        if (event.shiftKey) {
+            return KeyboardEventModifier.SHIFT;
+        } else if (event.ctrlKey) {
+            return KeyboardEventModifier.CTRL;
+        } else if (event.altKey) {
+            return KeyboardEventModifier.ALT;
+        }
+
+        return undefined;
+    };
+
+    ScreenSpaceEventHandler.prototype._handleMouseDown = function(event) {
+        var pos = this._getPosition(event);
+        this._lastMouseX = pos.x;
+        this._lastMouseY = pos.y;
+        this._totalPixels = 0;
+        if (this._seenAnyTouchEvents) {
+            return;
+        }
+
+        var modifier = this._getModifier(event);
+        var action;
+
+        // IE_TODO:  On some versions of IE, the left-button is 1, and the right-button is 4.
+        // See: http://www.unixpapa.com/js/mouse.html
+        // This is not the case in Chrome Frame, so we are OK for now, but are there
+        // constants somewhere?
+        if (event.button === 0) {
+            this._leftMouseButtonDown = true;
+            action = this.getInputAction(ScreenSpaceEventType.LEFT_DOWN, modifier);
+        } else if (event.button === 1) {
+            this._middleMouseButtonDown = true;
+            action = this.getInputAction(ScreenSpaceEventType.MIDDLE_DOWN, modifier);
+        } else if (event.button === 2) {
+            this._rightMouseButtonDown = true;
+            action = this.getInputAction(ScreenSpaceEventType.RIGHT_DOWN, modifier);
+        }
+
+        if (action) {
+            action({
+                position : new Cartesian2(pos.x, pos.y)
+            });
+        }
+        event.preventDefault();
+    };
+
+    ScreenSpaceEventHandler.prototype._handleMouseUp = function(event) {
+        var modifier = this._getModifier(event);
+        var action, clickAction;
+        if (this._seenAnyTouchEvents) {
+            return;
+        }
+
+        // IE_TODO:  On some versions of IE, the left-button is 1, and the right-button is 4.
+        // See: http://www.unixpapa.com/js/mouse.html
+        // This is not the case in Chrome Frame, so we are OK for now, but are there
+        // constants somewhere?
+        if (event.button === 0) {
+            this._leftMouseButtonDown = false;
+            action = this.getInputAction(ScreenSpaceEventType.LEFT_UP, modifier);
+            clickAction = this.getInputAction(ScreenSpaceEventType.LEFT_CLICK, modifier);
+        } else if (event.button === 1) {
+            this._middleMouseButtonDown = false;
+            action = this.getInputAction(ScreenSpaceEventType.MIDDLE_UP, modifier);
+            clickAction = this.getInputAction(ScreenSpaceEventType.MIDDLE_CLICK, modifier);
+        } else if (event.button === 2) {
+            this._rightMouseButtonDown = false;
+            action = this.getInputAction(ScreenSpaceEventType.RIGHT_UP, modifier);
+            clickAction = this.getInputAction(ScreenSpaceEventType.RIGHT_CLICK, modifier);
+        }
+
+        var pos = this._getPosition(event);
+
+        var xDiff = this._lastMouseX - pos.x;
+        var yDiff = this._lastMouseY - pos.y;
+        this._totalPixels += Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+
+        if (action) {
+            action({
+                position : new Cartesian2(pos.x, pos.y)
+            });
+        }
+
+        if (clickAction && this._totalPixels < this._clickPixelTolerance) {
+            clickAction({
+                position : new Cartesian2(pos.x, pos.y)
+            });
+        }
+    };
+
+    ScreenSpaceEventHandler.prototype._handleMouseMove = function(event) {
+        var pos = this._getPosition(event);
+        if (this._seenAnyTouchEvents) {
+            return;
+        }
+
+        var xDiff = this._lastMouseX - pos.x;
+        var yDiff = this._lastMouseY - pos.y;
+        this._totalPixels += Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+
+        var movement = {
+            startPosition : new Cartesian2(this._lastMouseX, this._lastMouseY),
+            endPosition : new Cartesian2(pos.x, pos.y),
+            motion : new Cartesian2(0.0, 0.0)
+        };
+
+        var modifier = this._getModifier(event);
+        var action = this.getInputAction(ScreenSpaceEventType.MOUSE_MOVE, modifier);
+        if (action) {
+            action(movement);
+        }
+
+        this._lastMouseX = movement.endPosition.x;
+        this._lastMouseY = movement.endPosition.y;
+
+        if (this._leftMouseButtonDown || this._middleMouseButtonDown || this._rightMouseButtonDown) {
+            event.preventDefault();
+        }
+    };
+
+    ScreenSpaceEventHandler.prototype._handleTouchStart = function(event) {
+        var pos, pos2, numberOfTouches = event.touches.length;
+        this._seenAnyTouchEvents = true;
+        var modifier = this._getModifier(event);
+        var action;
+
+        pos = this._getPosition(event.touches[0]);
+
+        if (numberOfTouches === 1) {
+            this._lastMouseX = pos.x;
+            this._lastMouseY = pos.y;
+            this._totalPixels = 0;
+
+            this._leftMouseButtonDown = true;
+            action = this.getInputAction(ScreenSpaceEventType.LEFT_DOWN, modifier);
+
+            if (action) {
+                action({
+                    position : new Cartesian2(pos.x, pos.y)
+                });
+            }
+            event.preventDefault();
+        } else if (this._leftMouseButtonDown) {
+            // Release "mouse" without clicking, because we are adding more touches.
+            this._leftMouseButtonDown = false;
+            action = this.getInputAction(ScreenSpaceEventType.LEFT_UP, modifier);
+            if (action) {
+                action({
+                    position : new Cartesian2(pos.x, pos.y)
+                });
+            }
+        }
+
+        if (numberOfTouches === 2) {
+            this._isPinching = true;
+            pos2 = this._getPosition(event.touches[1]);
+            this._touchID1 = event.touches[0].identifier;
+            this._touchID2 = event.touches[1].identifier;
+            this._lastMouseX = pos.x;
+            this._lastMouseY = pos.y;
+            this._lastTouch2X = pos2.x;
+            this._lastTouch2Y = pos2.y;
+            action = this.getInputAction(ScreenSpaceEventType.PINCH_START, modifier);
+            if (action) {
+                action({
+                    position1 : new Cartesian2(pos.x, pos.y),
+                    position2 : new Cartesian2(pos2.x, pos2.y)
+                });
+            }
+        } else if (this._isPinching) {
+            this._isPinching = false;
+            action = this.getInputAction(ScreenSpaceEventType.PINCH_END, modifier);
+            if (action) {
+                action();
+            }
+        }
+    };
+
+    ScreenSpaceEventHandler.prototype._handleTouchEnd = function(event) {
+        var numberOfTouches = event.touches.length;
+        var numberOfChangedTouches = event.changedTouches.length;
+        var modifier = this._getModifier(event);
+        var action, clickAction;
+
+        if (this._leftMouseButtonDown) {
+            this._leftMouseButtonDown = false;
+            action = this.getInputAction(ScreenSpaceEventType.LEFT_UP, modifier);
+            clickAction = this.getInputAction(ScreenSpaceEventType.LEFT_CLICK, modifier);
+
+            if (numberOfChangedTouches > 0) {
+                var pos = this._getPosition(event.changedTouches[0]);
+
+                var xDiff = this._lastMouseX - pos.x;
+                var yDiff = this._lastMouseY - pos.y;
+                this._totalPixels += Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+
+                if (action) {
+                    action({
+                        position : new Cartesian2(pos.x, pos.y)
+                    });
+                }
+
+                if (clickAction && this._totalPixels < this._clickPixelTolerance) {
+                    clickAction({
+                        position : new Cartesian2(pos.x, pos.y)
+                    });
+                }
+            }
+        }
+
+        if (this._isPinching) {
+            this._isPinching = false;
+            action = this.getInputAction(ScreenSpaceEventType.PINCH_END, modifier);
+            if (action) {
+                action();
+            }
+        }
+
+        if (numberOfTouches === 1 || numberOfTouches === 2) {
+            this._handleTouchStart(event);
+        }
+    };
+
+    ScreenSpaceEventHandler.prototype._handleTouchMove = function(event) {
+        var modifier = this._getModifier(event);
+        var pos, pos2, action, movement;
+
+        if (this._leftMouseButtonDown && (event.touches.length === 1)) {
+            pos = this._getPosition(event.touches[0]);
+
+            var xDiff = this._lastMouseX - pos.x;
+            var yDiff = this._lastMouseY - pos.y;
+            this._totalPixels += Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+
+            movement = {
+                startPosition : new Cartesian2(this._lastMouseX, this._lastMouseY),
+                endPosition : new Cartesian2(pos.x, pos.y),
+                motion : new Cartesian2(0.0, 0.0)
+            };
+
+            action = this.getInputAction(ScreenSpaceEventType.MOUSE_MOVE, modifier);
+            if (action) {
+                action(movement);
+            }
+
+            this._lastMouseX = movement.endPosition.x;
+            this._lastMouseY = movement.endPosition.y;
+
+            if (this._leftMouseButtonDown || this._middleMouseButtonDown || this._rightMouseButtonDown) {
+                event.preventDefault();
+            }
+        }
+
+        if (this._isPinching && (event.touches.length === 2)) {
+            // Check the touch identifier to make sure the order is correct.
+            if (event.touches[0].identifier === this._touchID2) {
+                pos = this._getPosition(event.touches[1]);
+                pos2 = this._getPosition(event.touches[0]);
+            } else {
+                pos = this._getPosition(event.touches[0]);
+                pos2 = this._getPosition(event.touches[1]);
+            }
+
+            action = this.getInputAction(ScreenSpaceEventType.PINCH_MOVE, modifier);
+            if (action) {
+                var dX = pos2.x - pos.x;
+                var dY = pos2.y - pos.y;
+                var dist = Math.sqrt(dX * dX + dY * dY) * 0.25;
+                var prevDX = this._lastTouch2X - this._lastMouseX;
+                var prevDY = this._lastTouch2Y - this._lastMouseY;
+                var prevDist = Math.sqrt(prevDX * prevDX + prevDY * prevDY) * 0.25;
+                var cY = (pos2.y + pos.y) * 0.125;
+                var prevCY = (this._lastTouch2Y + this._lastMouseY) * 0.125;
+                var angle = Math.atan2(dY, dX);
+                var prevAngle = Math.atan2(prevDY, prevDX);
+                movement = {
+                    'distance' : {
+                        startPosition : new Cartesian2(0, prevDist),
+                        endPosition : new Cartesian2(0, dist),
+                        motion : new Cartesian2(0.0, 0.0)
+                    },
+                    'angleAndHeight' : {
+                        startPosition : new Cartesian2(prevAngle, prevCY),
+                        endPosition : new Cartesian2(angle, cY),
+                        motion : new Cartesian2(0.0, 0.0)
+                    }
+                };
+                action(movement);
+            }
+
+            this._lastMouseX = pos.x;
+            this._lastMouseY = pos.y;
+            this._lastTouch2X = pos2.x;
+            this._lastTouch2Y = pos2.y;
+        }
+    };
+
+    ScreenSpaceEventHandler.prototype._handleMouseWheel = function(event) {
+        // Some browsers use event.detail to count the number of clicks. The sign
+        // of the integer is the direction the wheel is scrolled. In that case, convert
+        // to the angle it was rotated in degrees.
+        var delta = event.detail ? event.detail * -120 : event.wheelDelta;
+
+        var modifier = this._getModifier(event);
+        var type = ScreenSpaceEventType.WHEEL;
+        var action = this.getInputAction(type, modifier);
+
+        if (action) {
+            event.preventDefault();
+            action(delta);
+        }
+    };
+
+    ScreenSpaceEventHandler.prototype._handleMouseDblClick = function(event) {
+        var modifier = this._getModifier(event);
+        var action;
+        var pos = this._getPosition(event);
+
+        // IE_TODO:  On some versions of IE, the left-button is 1, and the right-button is 4.
+        // See: http://www.unixpapa.com/js/mouse.html
+        // This is not the case in Chrome Frame, so we are OK for now, but are there
+        // constants somewhere?
+        if (event.button === 0) {
+            action = this.getInputAction(ScreenSpaceEventType.LEFT_DOUBLE_CLICK, modifier);
+        } else if (event.button === 1) {
+            action = this.getInputAction(ScreenSpaceEventType.MIDDLE_DOUBLE_CLICK, modifier);
+        } else if (event.button === 2) {
+            action = this.getInputAction(ScreenSpaceEventType.RIGHT_DOUBLE_CLICK, modifier);
+        }
+
+        if (action) {
+            action({
+                position : new Cartesian2(pos.x, pos.y)
+            });
+        }
+    };
+
+    ScreenSpaceEventHandler.prototype._register = function() {
+        var that = this, useDoc = true;
+
+        this._callbacks = [];
+        if (typeof this._element.disableRootEvents !== 'undefined') {
+            useDoc = false;
+        }
+
+        this._callbacks.push({
+            name : 'mousedown',
+            onDoc : false,
+            action : function(e) {
+                that._handleMouseDown(e);
+            }
+        });
+        this._callbacks.push({
+            name : 'mouseup',
+            onDoc : useDoc,
+            action : function(e) {
+                that._handleMouseUp(e);
+            }
+        });
+        this._callbacks.push({
+            name : 'mousemove',
+            onDoc : useDoc,
+            action : function(e) {
+                that._handleMouseMove(e);
+            }
+        });
+        this._callbacks.push({
+            name : 'dblclick',
+            onDoc : false,
+            action : function(e) {
+                that._handleMouseDblClick(e);
+            }
+        });
+        this._callbacks.push({
+            name : 'touchstart',
+            onDoc : false,
+            action : function(e) {
+                that._handleTouchStart(e);
+            }
+        });
+        this._callbacks.push({
+            name : 'touchend',
+            onDoc : useDoc,
+            action : function(e) {
+                that._handleTouchEnd(e);
+            }
+        });
+        this._callbacks.push({
+            name : 'touchmove',
+            onDoc : useDoc,
+            action : function(e) {
+                that._handleTouchMove(e);
+            }
+        });
+
+        // Firefox calls the mouse wheel event 'DOMMouseScroll', all others use 'mousewheel'
+        this._callbacks.push({
+            name : 'mousewheel',
+            onDoc : false,
+            action : function(e) {
+                that._handleMouseWheel(e);
+            }
+        });
+        this._callbacks.push({
+            name : 'DOMMouseScroll',
+            onDoc : false,
+            action : function(e) {
+                that._handleMouseWheel(e);
+            }
+        });
+
+        for ( var i = 0; i < this._callbacks.length; i++) {
+            var cback = this._callbacks[i];
+            if (cback.onDoc) {
+                document.addEventListener(cback.name, cback.action, false);
+            } else {
+                this._element.addEventListener(cback.name, cback.action, false);
+            }
+        }
+    };
+
+    ScreenSpaceEventHandler.prototype._unregister = function() {
+        for ( var i = 0; i < this._callbacks.length; i++) {
+            var cback = this._callbacks[i];
+            if (cback.onDoc) {
+                document.removeEventListener(cback.name, cback.action, false);
+            } else {
+                this._element.removeEventListener(cback.name, cback.action, false);
+            }
+        }
+    };
+
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     *
+     * @memberof ScreenSpaceEventHandler
+     *
+     * @return {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     *
+     * @see ScreenSpaceEventHandler#destroy
+     */
+    ScreenSpaceEventHandler.prototype.isDestroyed = function() {
+        return false;
+    };
+
+    /**
+     * Removes listeners held by this object.
+     * <br /><br />
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     *
+     * @memberof ScreenSpaceEventHandler
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see ScreenSpaceEventHandler#isDestroyed
+     *
+     * @example
+     * handler = handler && handler.destroy();
+     */
+    ScreenSpaceEventHandler.prototype.destroy = function() {
+        this._unregister();
+        return destroyObject(this);
+    };
+
+    return ScreenSpaceEventHandler;
+});