diff --git a/src/ol.js b/src/ol.js
index d22946802e..6223dc2f02 100644
--- a/src/ol.js
+++ b/src/ol.js
@@ -5,8 +5,6 @@ goog.require('ol.bounds');
 goog.require('ol.control.Attribution');
 goog.require('ol.control.Navigation');
 goog.require('ol.control.Zoom');
-goog.require('ol.event.Events');
-goog.require('ol.event.Scroll');
 goog.require('ol.handler.Drag');
 goog.require('ol.handler.MouseWheel');
 goog.require("ol.map");
diff --git a/src/ol/event/Drag.js b/src/ol/event/Drag.js
deleted file mode 100644
index af1eee8fe3..0000000000
--- a/src/ol/event/Drag.js
+++ /dev/null
@@ -1,95 +0,0 @@
-goog.provide('ol.event.Drag');
-
-goog.require('ol.event');
-goog.require('ol.event.ISequence');
-
-goog.require('goog.functions');
-goog.require('goog.fx.Dragger');
-goog.require('goog.fx.DragEvent');
-goog.require('goog.fx.Dragger.EventType');
-
-
-/**
- * Event sequence that provides a 'dragstart', 'drag' and 'dragend' events.
- * Event objects of the 'drag' events have 'deltaX' and 'deltaY' values with
- * the relative pixel movement since the previous 'drag' or 'dragstart' event.
- *
- * @constructor
- * @param {ol.event.Events} target The Events instance that handles events.
- * @implements {ol.event.ISequence}
- * @export
- */
-ol.event.Drag = function(target) {    
-    var previousX = 0, previousY = 0,
-        element = target.getElement(),
-        dragger = new goog.fx.Dragger(element);
-
-    /**
-     * @private
-     * @type {goog.fx.Dragger}
-     */
-    this.dragger_ = dragger;
-    
-    /**
-     * @private
-     * @type {ol.event.Events}
-     */
-    this.target_ = target;
-    
-    // We want to swallow the click event that gets fired after dragging.
-    var newSequence;
-    function unregisterClickStopper() {
-        target.unregister('click', goog.functions.FALSE, undefined, true);
-    }
-
-    // no default for mousemove and touchmove events to avoid page scrolling.
-    target.register('mousemove', ol.event.preventDefault);
-    target.register('touchmove', ol.event.preventDefault);
-    
-    dragger.defaultAction = function(x, y) {};                
-    dragger.addEventListener(goog.fx.Dragger.EventType.START, function(evt) {
-        evt.target = element;
-        evt.type = 'dragstart';
-        previousX = evt.clientX;
-        previousY = evt.clientY;
-        newSequence = true;
-        target.triggerEvent(evt.type, evt);
-    });
-    dragger.addEventListener(goog.fx.Dragger.EventType.DRAG, function(evt) {
-        evt.target = element;
-        evt.deltaX = evt.clientX - previousX;
-        evt.deltaY = evt.clientY - previousY;
-        previousX = evt.clientX;
-        previousY = evt.clientY;
-        if (newSequence) {
-            // Once we are in the drag sequence, we know that we need to
-            // get rid of the click event that gets fired when we are done
-            // dragging.
-            target.register('click', goog.functions.FALSE, undefined, true);
-            newSequence = false;
-        }
-        target.triggerEvent(evt.type, evt);
-    });
-    dragger.addEventListener(goog.fx.Dragger.EventType.END, function(evt) {
-        evt.target = element;
-        evt.type = 'dragend';
-        target.triggerEvent(evt.type, evt);
-        // Unregister the click stopper in the next cycle
-        window.setTimeout(unregisterClickStopper, 0);
-    });
-    // Don't swallow the click event if our sequence cancels early.
-    dragger.addEventListener(
-        goog.fx.Dragger.EventType.EARLY_CANCEL, unregisterClickStopper
-    );  
-};
-
-/** @inheritDoc */
-ol.event.Drag.prototype.destroy = function() {
-    this.target_.unregister('mousemove', ol.event.preventDefault);
-    this.target_.unregister('touchmove', ol.event.preventDefault);
-    this.dragger_.dispose();
-    goog.object.clear(this);
-};
-
-
-ol.event.addSequenceProvider('drag', ol.event.Drag);
\ No newline at end of file
diff --git a/src/ol/event/Events.js b/src/ol/event/Events.js
deleted file mode 100644
index 3ad7969228..0000000000
--- a/src/ol/event/Events.js
+++ /dev/null
@@ -1,327 +0,0 @@
-goog.provide('ol.event');
-goog.provide('ol.event.Events');
-
-goog.require('goog.object');
-goog.require('goog.events');
-goog.require('goog.events.EventType');
-goog.require('goog.events.EventTarget');
-goog.require('goog.events.KeyCodes');
-goog.require('goog.style');
-
-/**
- * @enum {Object}
- */
-ol.event.SEQUENCE_PROVIDER_MAP = {};
-
-/**
- * @param {string} name
- * @param {Function} Sequence
- */
-ol.event.addSequenceProvider = function(name, Sequence) {
-    ol.event.SEQUENCE_PROVIDER_MAP[name] = Sequence;
-};
-
-/**
- * Determine whether event was caused by a single touch
- *
- * @param {!Event} evt
- * @return {boolean}
- */
-ol.event.isSingleTouch = function(evt) {
-    return !!(evt.touches && evt.touches.length == 1);
-};
-
-/**
- * Determine whether event was caused by a multi touch
- *
- * @param {!Event} evt
- * @return {boolean}
- */
-ol.event.isMultiTouch = function(evt) {
-    return !!(evt.touches && evt.touches.length > 1);
-};
-
-/**
- * Call preventDefault on the provided event.
- *
- * @param {!Event} evt
- */
-ol.event.preventDefault = function(evt) {
-    evt.preventDefault();
-};
-
-/**
- * Call stopPropagation on the provided event.
- *
- * @param {!Event} evt
- */
-ol.event.stopPropagation = function(evt) {
-    evt.stopPropagation();
-};
-
-
-/**
- * Construct an ol.event.Events instance.
- *
- * @constructor
- * @extends {goog.events.EventTarget}
- * @param {Object} object The object we are creating this instance for.
- * @param {!Element=} opt_element An optional element that we want to
- *     listen to browser events on.
- * @param {boolean=} opt_includeXY Should the 'xy' property automatically be
- *     created for browser pointer events? In general, this should be false. If
- *     it is true, then pointer events will automatically generate an 'xy'
- *     property on the event object that is passed, which represents the
- *     relative position of the pointer to the {@code element}. Default is
- *     false.
- * @param {Array.<String>=} opt_sequences Event sequences to register with
- *     this Events instance.
- */
-ol.event.Events = function(object, opt_element, opt_includeXY, opt_sequences) {
-    
-    goog.base(this);
-
-    /**
-     * @private
-     * @type {Object}
-     * The object that this instance is bound to.
-     */
-    this.object_ = object;
-
-    /**
-     * @private
-     * @type {Element}
-     * The element that this instance listens to mouse events on.
-     */
-    this.element_ = null;
-
-    /**
-     * @private
-     * @type {boolean}
-     */
-    this.includeXY_ = goog.isDef(opt_includeXY) ? opt_includeXY : false;
-    
-    /**
-     * @private
-     * @type {Array.<String>}
-     */
-    this.sequenceProviders_ = goog.isDef(opt_sequences) ? opt_sequences : [];
-    
-    /**
-     * @private
-     * @type {Array.<ol.event.ISequence>}
-     */
-    this.sequences_ = [];
-    
-    /**
-     * @private
-     * @type {Object}
-     */
-    this.listenerCount_ = {};
-    
-    if (goog.isDef(opt_element)) {
-        this.setElement(opt_element);
-    }
-};
-goog.inherits(ol.event.Events, goog.events.EventTarget);
-
-/**
- * @return {Object} The object that this instance is bound to.
- */
-ol.event.Events.prototype.getObject = function() {
-    return this.object_;
-};
-
-/**
- * @param {boolean} includeXY
- */
-ol.event.Events.prototype.setIncludeXY = function(includeXY) {
-    this.includeXY_ = includeXY;
-};
-
-/**
- * @return {Element} The element that this instance currently
- *     listens to browser events on.
- */
-ol.event.Events.prototype.getElement = function() {
-    return this.element_;
-};
-
-/**
- * Attach this instance to a DOM element. When called, all browser events fired
- * on the provided element will be relayed by this instance.
- *
- * @param {Element|Node} element A DOM element to attach
- *     browser events to. If called without this argument, all browser events
- *     will be detached from the element they are currently attached to.
- */
-ol.event.Events.prototype.setElement = function(element) {
-    var types = goog.events.EventType, t;    
-    if (this.element_) {
-        for (t in types) {
-            goog.events.unlisten(
-                this.element_, types[t], this.handleBrowserEvent, false, this
-            );
-        }
-        this.destroySequences();
-        delete this.element_;
-    }
-    this.element_ = /** @type {Element} */ (element) || null;
-    if (goog.isDefAndNotNull(element)) {
-        this.createSequences();
-        for (t in types) {
-            goog.events.listen(
-                element, types[t], this.handleBrowserEvent, false, this
-            );
-        }
-    }
-};
-
-ol.event.Events.prototype.createSequences = function() {
-    for (var i=0, ii=this.sequenceProviders_.length; i<ii; ++i) {
-        this.sequences_.push(
-            new ol.event.SEQUENCE_PROVIDER_MAP[this.sequenceProviders_[i]](
-                this
-            )
-        );
-    }
-};
-
-ol.event.Events.prototype.destroySequences = function() {
-    for (var i=this.sequences_.length-1; i>=0; --i) {
-        this.sequences_[i].destroy();
-    }
-    this.sequences_ = [];
-};
-
-/**
- * Register a listener for an event.
- *
- * When the event is triggered, the 'listener' function will be called, in the
- * context of 'scope'. Imagine we were to register an event, specifying an 
- * ol.Bounds instance as 'scope'.  When the event is triggered, the context in
- * the listener function will be our Bounds instance.  This means that within
- * our listener function, we can access the properties and methods of the
- * Bounds instance through the 'this' keyword. So our listener could execute
- * something like:
- *
- *     var leftStr = "Left: " + this.minX();
- *
- * @param {string} type Name of the event to register.
- * @param {Function} listener The callback function.
- * @param {Object=} opt_scope The object to bind the context to for the
- *     listener. If no scope is specified, default is this intance's 'object'
- *     property.
- * @param {boolean=} opt_priority Register the listener as priority listener,
- *     so it gets executed before other listeners? Default is false.
- */
-ol.event.Events.prototype.register = function(type, listener, opt_scope,
-                                              opt_priority) {
-    goog.events.listen(
-        this, type, listener, opt_priority, opt_scope || this.object_
-    );
-    this.listenerCount_[type] = (this.listenerCount_[type] || 0) + 1;
-};
-
-/**
- * Unregister a listener for an event
- *
- * @param {string} type Name of the event to unregister
- * @param {Function} listener The callback function.
- * @param {Object=} opt_scope The object to bind the context to for the
- *     listener. If no scope is specified, default is the event's default
- *     scope.
- * @param {boolean=} opt_priority Listener was registered as priority listener,
- *     so it gets executed before other listeners. Default is false.
- */
-ol.event.Events.prototype.unregister = function(type, listener, opt_scope,
-                                                opt_priority) {
-    var removed = goog.events.unlisten(
-        this, type, listener, opt_priority, opt_scope || this.object_
-    );
-    if (removed) {
-        this.listenerCount_[type] = (this.listenerCount_[type] || 1) - 1;
-    }
-};
-
-/**
- * Trigger a specified registered event.  
- *
- * @param {string} type The type of the event to trigger.
- * @param {Object=} opt_evt The event object that will be passed to listeners.
- *      This object will always have a 'type' property with the event type and
- *      an 'object' property referencing this Events instance.
- *
- * @return {boolean} The last listener return.  If a listener returns false,
- *     the chain of listeners will stop getting called. Returns undefined if
- *     called for an event type that has no listeners.
- */
-ol.event.Events.prototype.triggerEvent = function(type, opt_evt) {
-    var returnValue;
-    if (this.listenerCount_[type] > 0) {
-        var listeners = goog.events.getListeners(this, type, true)
-            .concat(goog.events.getListeners(this, type, false));
-        if (arguments.length === 1) {
-            opt_evt = {'type': type};
-        }
-        opt_evt['object'] = this.object_;
-        for (var i=0, ii=listeners.length; i<ii; ++i) {
-            returnValue = listeners[i].handleEvent(opt_evt);
-            if (returnValue === false) {
-                break;
-            }
-        }
-    }
-    return returnValue;
-};
-
-/**
- * Prepares browser events before they are dispatched. This takes care to set a
- * property 'xy' on the event with the current pointer position (if 
- * {@code includeXY} is set to true), and normalizes clientX and clientY for
- * multi-touch events.
- * 
- * @param {Event} evt Event object.
- */
-ol.event.Events.prototype.handleBrowserEvent = function(evt) {
-    var type = evt.type;
-    if (this.listenerCount_[type] > 0) {
-        // add clientX & clientY to all events - corresponds to average x, y
-        var touches = evt.touches;
-        if (touches && touches[0]) {
-            var x = 0;
-            var y = 0;
-            var num = touches.length;
-            var touch;
-            for (var i=0; i<num; ++i) {
-                touch = touches[i];
-                x += touch.clientX;
-                y += touch.clientY;
-            }
-            evt.clientX = x / num;
-            evt.clientY = y / num;
-        }
-        if (this.includeXY_) {
-            evt.xy = this.getPointerPosition(evt);
-        }
-        this.triggerEvent(evt.type, evt);
-    }
-};
-
-/**
- * Get the mouse position relative to this Event instance's target element for
- * the provided event.
- *
- * @param {Event} evt Event object
- */
-ol.event.Events.prototype.getPointerPosition = function(evt) {
-    return goog.style.getRelativePosition(evt, this.element_);
-};
-
-/**
- * Destroy this Events instance.
- */
-ol.event.Events.prototype.destroy = function() {
-    this.setElement(null);
-    goog.object.clear(this);
-};
\ No newline at end of file
diff --git a/src/ol/event/ISequence.js b/src/ol/event/ISequence.js
deleted file mode 100644
index 0b4cb60c83..0000000000
--- a/src/ol/event/ISequence.js
+++ /dev/null
@@ -1,22 +0,0 @@
-goog.provide('ol.event.ISequence');
-
-/**
- * Interface for event sequences. Event sequences map sequences of native
- * browser events to high level events that the sequence provides.
- *
- * Implementations are expected to call {@code triggerEvent} on the
- * {@code target} to to fire their high level events.
- *
- * Implementations can expect the {@code target}'s {@code getElement} method
- * to return an {Element} at construction time.
- *
- * @interface
- * @param {ol.event.Events} target The Events instance that receives the
- *     sequence's events.
- */
-ol.event.ISequence = function(target) {};
-
-/**
- * Destroys the sequence
- */
-ol.event.ISequence.prototype.destroy = function() {};
diff --git a/src/ol/event/Scroll.js b/src/ol/event/Scroll.js
deleted file mode 100644
index dc204fcdd1..0000000000
--- a/src/ol/event/Scroll.js
+++ /dev/null
@@ -1,45 +0,0 @@
-goog.provide('ol.event.Scroll');
-
-goog.require('ol.event.ISequence');
-goog.require('ol.event');
-
-goog.require('goog.events.MouseWheelHandler');
-
-
-/**
- * Event sequence that provides a 'scroll' event. Event objects have 'deltaX'
- * and 'deltaY' values with the scroll delta since the previous 'scroll' event.
- *
- * @constructor
- * @param {ol.event.Events} target The Events instance that handles events.
- * @implements {ol.event.ISequence}
- * @export
- */
-ol.event.Scroll = function(target) {    
-    var element = target.getElement(),
-        handler = new goog.events.MouseWheelHandler(element);
-
-    /**
-     * @private
-     * @type {goog.events.MouseWheelHandler}
-     */
-    this.handler_ = handler;
-    
-    handler.addEventListener(
-        goog.events.MouseWheelHandler.EventType.MOUSEWHEEL,
-        function(evt) {
-            evt.type = 'scroll';
-            evt.target = element;
-            target.triggerEvent(evt.type, evt);
-        }
-    );
-};
-
-/** @inheritDoc */
-ol.event.Scroll.prototype.destroy = function() {
-    this.handler_.dispose();
-    delete this.handler_;
-};
-
-
-ol.event.addSequenceProvider('scroll', ol.event.Scroll);
\ No newline at end of file
diff --git a/test/ol.html b/test/ol.html
index 956b331983..776efaf0e0 100644
--- a/test/ol.html
+++ b/test/ol.html
@@ -74,7 +74,6 @@
   <script type="text/javascript" src="jasmine-extensions.js"></script>
 
   <!-- include spec files here... -->
-  <script type="text/javascript" src="spec/ol/Events.test.js"></script>
   <script type="text/javascript" src="spec/ol/UnreferencedBounds.test.js"></script>
   <script type="text/javascript" src="spec/ol/Projection.test.js"></script>
   <script type="text/javascript" src="spec/ol/Bounds.test.js"></script>
diff --git a/test/spec/ol/Events.test.js b/test/spec/ol/Events.test.js
deleted file mode 100644
index 604e131708..0000000000
--- a/test/spec/ol/Events.test.js
+++ /dev/null
@@ -1,175 +0,0 @@
-describe("ol.event.Events", function() {
-    
-    var log = [],
-        logFn = function(e) {log.push({scope: this, evt: e});};
-        
-
-    it("constructs instances", function() {
-        var events, element = document.createElement("div");
-        
-        events = new ol.event.Events("foo");        
-        expect(events.getObject()).toBe("foo");
-        expect(events.getElement()).toBe(null);        
-        events.destroy();
-        
-        events = new ol.event.Events("foo", element, true);        
-        expect(events.getElement()).toBe(element);
-        expect(events.includeXY_).toBe(true);        
-        events.destroy();
-    });
-    
-    it("destroys properly", function() {
-        var events = new ol.event.Events("foo");
-        events.destroy();        
-        expect(events.getObject()).toBe(undefined);
-    });
-    
-    it("relays browser events and knows about pointer position", function() {
-        var element = document.createElement("div"),
-            events = new ol.event.Events("foo", element);
-        
-        //TODO Figure out a good way to deal with fixtures
-        element.style.position = "absolute";
-        element.style.left = "5px";
-        element.style.top = "10px";
-        document.body.appendChild(element);
-        // mock dom element so we can trigger events on it
-        goog.object.extend(element, new goog.events.EventTarget());
-        
-        log = [];
-        events.register("click", logFn);
-        element.dispatchEvent("click");
-        expect(log.length).toBe(1);
-        
-        // detach from the element
-        events.setElement(null);
-        element.dispatchEvent("click");
-        expect(log.length).toBe(1);
-        
-        // attach to the element again
-        events.setElement(element);
-        events.setIncludeXY(true);
-        element.dispatchEvent({
-            type: "click",
-            touches: [{clientX: 9, clientY: 22}, {clientX: 11, clientY: 18}]
-        });
-        expect(log.length).toBe(2);
-        expect(log[1].evt.xy.x).toBe(5);
-        expect(log[1].evt.xy.y).toBe(10);
-        expect(log[1].evt.clientX).toBe(10);
-        expect(log[1].evt.clientY).toBe(20);
-        
-        events.destroy();
-        document.body.removeChild(element);
-    });
-    
-    it("calls listeners with a scope and an event object", function() {
-        var scope = {}, evt = {}, events = new ol.event.Events("foo");
-        
-        log = [];
-        events.register("bar", logFn, scope);
-        events.triggerEvent("bar", evt);
-        expect(log[0].scope).toBe(scope);
-        expect(log[0].evt).toBe(evt);
-        expect(log[0].evt.object).toBe("foo");
-    });
-    
-    it("respects event priority", function() {
-        var log = [], events = new ol.event.Events("foo");
-        
-        // register a normal listener
-        events.register("bar", function() {log.push("normal");});
-        // register a priority listener
-        events.register(
-            "bar", function() {log.push("priority");}, undefined, true);        
-        events.triggerEvent("bar");        
-        expect(log[0]).toBe("priority");
-        expect(log[1]).toBe("normal");
-        
-        events.destroy();
-    });
-    
-    it("allows to abort the event chain", function() {
-        var events = new ol.event.Events("foo");
-        
-        log = [];
-        // register a listener that aborts the event chain
-        events.register("bar", function(e) {logFn(e); return false;});        
-        // register a listener that just does something
-        events.register("bar", logFn);        
-        events.triggerEvent("bar");
-        expect(log.length).toBe(1);
-        
-        log = [];
-        // register a priority listener that just does something
-        events.register("bar", logFn, undefined, true);
-        events.triggerEvent("bar");
-        expect(log.length).toBe(2);
-        
-        events.destroy();
-    });
-    
-    it("allows to unregister events", function() {
-        var events = new ol.event.Events("foo");
-        
-        log = [];
-        events.register("bar", logFn);
-        expect(events.listenerCount_["bar"]).toBe(1);
-
-        events.triggerEvent("bar");
-        expect(log.length).toBe(1);
-        
-        events.unregister("bar", logFn);
-        events.triggerEvent("bar");
-        expect(log.length).toBe(1);
-        
-        events.unregister("bar", logFn);
-        expect(events.listenerCount_["bar"]).toBe(0);
-        
-        events.destroy();
-    });
-    
-    it("can be extended with sequences implementing ol.event.ISequence", function() {
-        var sequence;
-        var Sequence = function(target) {
-            sequence = this;
-            this.target = target;
-        };
-        Sequence.prototype.fire = function() {
-            this.target.triggerEvent("myevent");
-        };
-        Sequence.prototype.destroy = function() {
-            this.destroyed = true;
-        };
-        ol.event.addSequenceProvider("myseq", Sequence);
-
-        var element = document.createElement("div");
-            events = new ol.event.Events("foo", undefined, false, ["myseq"]);
-        
-        expect(sequence).toBeUndefined();
-        
-        log = [];
-        events.setElement(element);
-        events.register('myevent', logFn);
-        sequence.fire();
-
-        expect(log.length).toBe(1);
-        expect(log[0].evt.type).toBe("myevent");
-        
-        events.destroy();
-        expect(sequence.destroyed).toBe(true);
-    });
-    
-    it("provides an isSingleTouch() function", function() {
-        expect(ol.event.isSingleTouch({touches: [{}, {}]})).toBe(false);
-        expect(ol.event.isSingleTouch({touches: [{}]})).toBe(true);
-        expect(ol.event.isSingleTouch({})).toBe(false);        
-    });
-    
-    it("provides an isMultiTouch() function", function() {
-        expect(ol.event.isMultiTouch({touches: [{}, {}]})).toBe(true);
-        expect(ol.event.isMultiTouch({touches: [{}]})).toBe(false);
-        expect(ol.event.isMultiTouch({})).toBe(false);        
-    });
-    
-});