diff --git a/src/ol/event/Events.js b/src/ol/event/Events.js
index 981c03b119..e8848b23f6 100644
--- a/src/ol/event/Events.js
+++ b/src/ol/event/Events.js
@@ -43,8 +43,10 @@ ol.event.isMultiTouch = function(evt) {
  *     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.<Object>=} opt_sequences Event sequences to register with this
+ *     events instance.
  */
-ol.event.Events = function(object, opt_element, opt_includeXY) {
+ol.event.Events = function(object, opt_element, opt_includeXY, opt_sequences) {
     
     goog.base(this);
 
@@ -68,6 +70,12 @@ ol.event.Events = function(object, opt_element, opt_includeXY) {
      */
     this.includeXY_ = goog.isDef(opt_includeXY) ? opt_includeXY : false;
     
+    /**
+     * @private
+     * @type {Array.<Object>}
+     */
+    this.sequences_ = goog.isDef(opt_sequences) ? opt_sequences : [];
+    
     this.setElement(opt_element);
 };
 goog.inherits(ol.event.Events, goog.events.EventTarget);
@@ -124,37 +132,6 @@ ol.event.Events.prototype.setElement = function(opt_element) {
     }
 };
 
-/**
- * Convenience method for registering listeners with a common scope.
- * Internally, this method calls 'register' as shown in the examples below.
- *
- *     // register a single listener for the "loadstart" event
- *     events.on({"loadstart": loadStartListener});
- *
- *     // this is equivalent to the following
- *     events.register("loadstart", loadStartListener);
- *
- *     // register multiple listeners to be called with the same `this` object
- *     events.on({
- *         "loadstart": loadStartListener,
- *         "loadend": loadEndListener,
- *         scope: object
- *     });
- *
- *     // this is equivalent to the following
- *     events.register("loadstart", loadStartListener, object);
- *     events.register("loadend", loadEndListener, object);
- *
- * @param {Object} object
- */
-ol.event.Events.prototype.on = function(object) {
-    for (var type in object) {
-        if (type != 'scope' && object.hasOwnProperty(type)) {
-            this.register(type, object[type], object['scope']);
-        }
-    }
-};
-
 /**
  * Register a listener for an event.
  *
@@ -183,37 +160,6 @@ ol.event.Events.prototype.register = function(type, listener, opt_scope,
     );
 };
 
-/**
- * Convenience method for unregistering listeners with a common scope.
- * Internally, this method calls 'unregister' as shown in the examples below.
- * 
- *     // unregister a single listener for the "loadstart" event
- *     events.un({"loadstart": loadStartListener});
- *
- *     // this is equivalent to the following
- *     events.unregister("loadstart", loadStartListener);
- *
- *     // unregister multiple listeners with the same `this` object
- *     events.un({
- *         "loadstart": loadStartListener,
- *         "loadend": loadEndListener,
- *         scope: object
- *     });
- *
- *     // this is equivalent to the following
- *     events.unregister("loadstart", loadStartListener, object);
- *     events.unregister("loadend", loadEndListener, object);
- *
- * @param {Object} object
- */
-ol.event.Events.prototype.un = function(object) {
-    for (var type in object) {
-        if (type != 'scope' && object.hasOwnProperty(type)) {
-            this.unregister(type, object[type], object['scope']);
-        }
-    }
-};
-
 /**
  * Unregister a listener for an event
  *
@@ -235,7 +181,7 @@ ol.event.Events.prototype.unregister = function(type, listener, opt_scope) {
  * @param {string} type The type of the event to trigger.
  * @param {Object} evt The event object that will be passed to listeners.
  *
- * @return {Boolean} The last listener return.  If a listener returns false,
+ * @return {boolean} The last listener return.  If a listener returns false,
  *     the chain of listeners will stop getting called.
  */
 ol.event.Events.prototype.triggerEvent = function(type, evt) {
@@ -254,6 +200,28 @@ ol.event.Events.prototype.triggerEvent = function(type, evt) {
     return returnValue;
 };
 
+/**
+ * @param {Event} evt
+ */
+ol.event.Events.prototype.handleSequences = function(evt) {
+    var sequences = this.sequences_,
+        type = evt.type,
+        sequenceEvt,
+        sequence, browserEvent, providedEventType;
+    for (var i=0, ii=sequences.length; i<ii; ++i) {
+        sequence = sequences[i];
+        for (providedEventType in sequence) {
+            // clone the original event
+            sequenceEvt = {}; goog.object.extend(sequenceEvt, evt);
+            browserEvent = sequence[providedEventType];
+            if (browserEvent[type] && browserEvent[type](evt)) {
+                sequenceEvt.type = providedEventType;
+                this.dispatchEvent(sequenceEvt);
+            }
+        }
+    }
+};
+
 /**
  * Basically just a wrapper to the triggerEvent() function, but takes 
  * care to set a property 'xy' on the event with the current mouse position.
@@ -290,6 +258,7 @@ ol.event.Events.prototype.handleBrowserEvent = function(evt) {
         var element = /** @type {!Element} */ this.element_;
         evt.xy = goog.style.getRelativePosition(evt, element);
     }
+    this.handleSequences(evt);
     this.dispatchEvent(evt);
 };
 
diff --git a/src/ol/event/drag.js b/src/ol/event/drag.js
new file mode 100644
index 0000000000..2589a9775b
--- /dev/null
+++ b/src/ol/event/drag.js
@@ -0,0 +1,54 @@
+goog.provide('ol.event.drag');
+
+
+/**
+ * @return {Object} A drag sequence with dragstart, drag and dragend events.
+ */
+ol.event.drag = function() {
+    var previous = null;
+    
+    function dragstart(evt) {
+        if (!previous) {
+            evt.dx = 0;
+            evt.dy = 0;
+            previous = {screenX: evt.screenX, screenY: evt.screenY};
+            if (evt.stopPropagation) {
+                evt.stopPropagation();
+            } else {
+                evt.cancelBubble = true;
+            }
+            return true;
+        }
+    }
+    
+    function drag(evt) {
+        if (previous) {
+            evt.dx = evt.screenX - previous.screenX;
+            evt.dy = evt.screenY - previous.screenY;
+            previous = {screenX: evt.screenX, screenY: evt.screenY};
+            return true;
+        }
+    }
+    
+    function dragend(evt) {
+        if (previous) {
+            previous = null;
+            return true;
+        }
+    }
+
+    return {
+        'dragstart': {
+            'mousedown': dragstart,
+            'touchstart': dragstart 
+        },
+        'drag': {
+            'mousemove': drag,
+            'touchmove': drag
+        },
+        'dragend': {
+            'mouseup': dragend,
+            'touchend': dragend
+        }
+    };
+};
\ No newline at end of file
diff --git a/test/spec/ol/Events.test.js b/test/spec/ol/Events.test.js
index 53a7f86e93..99e394b877 100644
--- a/test/spec/ol/Events.test.js
+++ b/test/spec/ol/Events.test.js
@@ -2,6 +2,7 @@ describe("ol.Events", function() {
     
     var log = [],
         logFn = function(e) {log.push({scope: this, evt: e});};
+        
 
     it("constructs instances", function() {
         var events, element = document.createElement("div");
@@ -122,29 +123,27 @@ describe("ol.Events", function() {
         events.destroy();
     });
     
-    it("has on() and un() convenience methods", function() {
-        var scope = {}, events = new ol.event.Events("foo");
+    it("can map browser events to sequences", function() {
+        var element = document.createElement("div"),
+            events = new ol.event.Events(
+                "foo", element, false, [ol.event.drag()]
+            );
+        
+        // mock dom object
+        goog.object.extend(element, new goog.events.EventTarget());
         
         log = [];
-        events.on({
-            "bar": logFn,
-            "baz": logFn,
-            scope: scope
-        });
-        events.triggerEvent("bar");
-        expect(log[0].evt.type).toBe("bar");
-        events.triggerEvent("baz");
-        expect(log[1].scope).toBe(scope);
-        expect(log[1].evt.type).toBe("baz");
+        events.register('dragstart', logFn);
+        events.register('drag', logFn);
+        events.register('dragend', logFn);
+
+        element.dispatchEvent("mousedown");
+        element.dispatchEvent("mousemove");
+        element.dispatchEvent("mouseup");
         
-        events.un({
-            "bar": logFn,
-            "baz": logFn,
-            scope: scope
-        });
-        events.triggerEvent("bar");
-        events.triggerEvent("baz");
-        expect(log.length).toBe(2);
+        expect(log[0].evt.type).toBe("dragstart");
+        expect(log[1].evt.type).toBe("drag");
+        expect(log[2].evt.type).toBe("dragend");
         
         events.destroy();
     });