diff -r 7f019df79cfc src/video/mir/SDL_mirevents.c
--- a/src/video/mir/SDL_mirevents.c	Sat Jul 18 00:04:49 2015 -0400
+++ b/src/video/mir/SDL_mirevents.c	Fri Nov 06 19:42:54 2015 +0100
@@ -34,11 +34,12 @@
 
 #include "SDL_mirevents.h"
 #include "SDL_mirwindow.h"
-
+#include "SDL_log.h"
 #include <xkbcommon/xkbcommon.h>
 
 #include "SDL_mirdyn.h"
 
+
 static void
 HandleKeyText(int32_t key_code)
 {
@@ -70,12 +71,13 @@
 static void
 HandleKeyEvent(MirKeyEvent const ev, SDL_Window* window)
 {
+    const uint32_t unsigned_ev_scan_code = ev.scan_code;
     uint32_t scancode = SDL_SCANCODE_UNKNOWN;
     Uint8 key_state = ev.action == mir_key_action_up ? SDL_RELEASED : SDL_PRESSED;
 
     CheckKeyboardFocus(window);
 
-    if (ev.scan_code < SDL_arraysize(xfree86_scancode_table2))
+    if (unsigned_ev_scan_code < SDL_arraysize(xfree86_scancode_table2))
         scancode = xfree86_scancode_table2[ev.scan_code];
 
     if (scancode != SDL_SCANCODE_UNKNOWN)
@@ -85,8 +87,25 @@
         HandleKeyText(ev.key_code);
 }
 
-static void
-HandleMouseButton(SDL_Window* sdl_window, Uint8 state, MirMotionButton button_state)
+#define AMOTION_EVENT_ACTION_MASK                   0xff
+#define AMOTION_EVENT_ACTION_POINTER_INDEX_MASK     0xff00
+#define AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT    8
+
+static int32_t
+getActionMasked(MirMotionEvent const motion)
+{
+    return motion.action & AMOTION_EVENT_ACTION_MASK; 
+}
+
+static int32_t
+getActionIndex(MirMotionEvent const motion) 
+{
+    return (motion.action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)
+        >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+}
+
+static uint32_t
+mir_2_sdl_button_state(MirMotionButton button_state)
 {
     static uint32_t last_sdl_button;
     uint32_t sdl_button;
@@ -113,138 +132,240 @@
     }
 
     last_sdl_button = sdl_button;
-    SDL_SendMouseButton(sdl_window, 0, state, sdl_button);
+    return sdl_button;
 }
 
+
+// Very Similar to "Android_OnTouch" in the file "SDL_androidtouch.c"
 static void
-HandleMouseMotion(SDL_Window* sdl_window, int x, int y)
+Mir_OnTouch(int touch_device_id_in, int pointer_finger_id_in, int action, float x, float y, float p,
+        SDL_Window *sdl_window, MirMotionButton mmb)
 {
-    SDL_SendMouseMotion(sdl_window, 0, 0, x, y);
-}
+    SDL_TouchID touchDeviceId = 0;
+    SDL_FingerID fingerId = 0;
+    int window_x, window_y;
+    static SDL_FingerID pointerFingerID = 0;
 
-static void
-HandleTouchPress(int device_id, int source_id, SDL_bool down, float x, float y, float pressure)
-{
-    SDL_SendTouch(device_id, source_id, down, x, y, pressure);
-}
+    int mWidth = sdl_window->w;
+    int mHeight = sdl_window->h;
 
-static void
-HandleTouchMotion(int device_id, int source_id, float x, float y, float pressure)
-{
-    SDL_SendTouchMotion(device_id, source_id, x, y, pressure);
-}
+    touchDeviceId = (SDL_TouchID)touch_device_id_in;
+    if (SDL_AddTouch(touchDeviceId, "") < 0) {
+        SDL_Log("error: can't add touch %s, %d", __FILE__, __LINE__);
+    }
 
-static void
-HandleMouseScroll(SDL_Window* sdl_window, int hscroll, int vscroll)
-{
-    SDL_SendMouseWheel(sdl_window, 0, hscroll, vscroll, SDL_MOUSEWHEEL_NORMAL);
-}
+    fingerId = (SDL_FingerID)pointer_finger_id_in;
 
-static void
-AddTouchDevice(int device_id)
-{
-    if (SDL_AddTouch(device_id, "") < 0)
-        SDL_SetError("Error: can't add touch %s, %d", __FILE__, __LINE__);
-}
+    switch (action) {
 
-static void
-HandleTouchEvent(MirMotionEvent const motion, int cord_index, SDL_Window* sdl_window)
-{
-    int device_id = motion.device_id;
-    int id = motion.pointer_coordinates[cord_index].id;
-
-    int width  = sdl_window->w;
-    int height = sdl_window->h;
-    float x   = motion.pointer_coordinates[cord_index].x;
-    float y   = motion.pointer_coordinates[cord_index].y;
-
-    float n_x = x / width;
-    float n_y = y / height;
-    float pressure = motion.pointer_coordinates[cord_index].pressure;
-
-    AddTouchDevice(motion.device_id);
-
-    switch (motion.action) {
         case mir_motion_action_down:
+            /* Primary pointer down */
+            window_x = x * mWidth;
+            window_y = y * mHeight;
+            /* send moved event */
+            SDL_SendMouseMotion(NULL, SDL_TOUCH_MOUSEID, 0, window_x, window_y);
+            /* send mouse down event */
+            SDL_SendMouseButton(NULL, SDL_TOUCH_MOUSEID, SDL_PRESSED, mir_2_sdl_button_state(mmb));
+            pointerFingerID = fingerId;
         case mir_motion_action_pointer_down:
-            HandleTouchPress(device_id, id, SDL_TRUE, n_x, n_y, pressure);
+            /* Non primary pointer down */
+            SDL_SendTouch(touchDeviceId, fingerId, SDL_TRUE, x, y, p);
             break;
+            
+        case mir_motion_action_hover_move: // ? Also this one ?
+        case mir_motion_action_move:
+            if (!pointerFingerID) {
+                window_x = x * mWidth;
+                window_y = y * mHeight;
+                /* send moved event */
+                SDL_SendMouseMotion(NULL, SDL_TOUCH_MOUSEID, 0, window_x, window_y);
+            }
+            SDL_SendTouchMotion(touchDeviceId, fingerId, x, y, p);
+            break;
+            
         case mir_motion_action_up:
+            /* Primary pointer up */
+            /* send mouse up */
+            pointerFingerID = (SDL_FingerID) 0;
+            SDL_SendMouseButton(NULL, SDL_TOUCH_MOUSEID, SDL_RELEASED, mir_2_sdl_button_state(mmb));
         case mir_motion_action_pointer_up:
-            HandleTouchPress(device_id, id, SDL_FALSE, n_x, n_y, pressure);
+            /* Non primary pointer up */
+            SDL_SendTouch(touchDeviceId, fingerId, SDL_FALSE, x, y, p);
             break;
-        case mir_motion_action_hover_move:
-        case mir_motion_action_move:
-            HandleTouchMotion(device_id, id, n_x, n_y, pressure);
-            break;
+            
         default:
+            SDL_Log("Not handled MirEvent action=%08x (Mir_OnTouch)", action);
             break;
     }
 }
 
+
+
+// Very Similar to "public boolean onTouch(View v, MotionEvent event)" in the file "SDLActivity.java"
 static void
-HandleMouseEvent(MirMotionEvent const motion, int cord_index, SDL_Window* sdl_window)
+HandleMotionEvent(MirMotionEvent event, SDL_Window* sdl_window)
 {
-    SDL_SetMouseFocus(sdl_window);
+    /* Ref: http://developer.android.com/training/gestures/multi.html */
+    const int touchDevId = event.device_id;
+    const int pointerCount = event.pointer_count;
+    const int action = getActionMasked(event);
+    int pointerFingerId;
+    int i = -1;
+    float x,y,p;
 
-    switch (motion.action) {
+    const int mWidth = sdl_window->w;
+    const int mHeight = sdl_window->h;
+
+    switch (action) {    
+
+        case mir_motion_action_hover_move: // TODO  Also this one ?
+        case mir_motion_action_move:
+            for (i = 0; i < pointerCount; i++) {
+                pointerFingerId = event.pointer_coordinates[i].id;
+                x = event.pointer_coordinates[i].x / mWidth;
+                y = event.pointer_coordinates[i].y / mHeight;
+                p = event.pointer_coordinates[i].pressure;
+                Mir_OnTouch(touchDevId, pointerFingerId, action, x, y, p, sdl_window, event.button_state);
+            }
+            break;
+
+            /* 
+             * http://developer.android.com/reference/android/view/MotionEvent.html
+             *
+             * The current gesture has been aborted. You will not receive any
+             * more points in it. You should treat this as an up event, but not
+             * perform any action that you normally would.
+             */
+        case mir_motion_action_cancel:
+            for (i = 0; i < pointerCount; i++) {
+                pointerFingerId = event.pointer_coordinates[i].id;
+                x = event.pointer_coordinates[i].x / mWidth;
+                y = event.pointer_coordinates[i].y / mHeight;
+                p = event.pointer_coordinates[i].pressure;
+                Mir_OnTouch(touchDevId, pointerFingerId, mir_motion_action_up, x, y, p, sdl_window, event.button_state);
+            }
+            break;
+
+        case mir_motion_action_up:
         case mir_motion_action_down:
+            // Primary pointer up/down, the index is always zero
+            i = 0;
+            pointerFingerId = event.pointer_coordinates[i].id;
+            x = event.pointer_coordinates[i].x / mWidth;
+            y = event.pointer_coordinates[i].y / mHeight;
+            p = event.pointer_coordinates[i].pressure;
+            Mir_OnTouch(touchDevId, pointerFingerId, action, x, y, p, sdl_window, event.button_state);
+            break;
+
+        case mir_motion_action_pointer_up:
+            // BUG MIR = need to check all FingerId not to miss any FINGER_UP
+            // this brings some duplicate FINGER_UP.
+            for (i = 0; i < pointerCount; i++) {
+                pointerFingerId = event.pointer_coordinates[i].id;
+                x = event.pointer_coordinates[i].x / mWidth;
+                y = event.pointer_coordinates[i].y / mHeight;
+                p = event.pointer_coordinates[i].pressure;
+                Mir_OnTouch(touchDevId, pointerFingerId, action, x, y, p, sdl_window, event.button_state);
+            }
+            break;
+
         case mir_motion_action_pointer_down:
-            HandleMouseButton(sdl_window, SDL_PRESSED, motion.button_state);
+            // Non primary pointer up/down
+            i = getActionIndex(event);
+            pointerFingerId = event.pointer_coordinates[i].id;
+            x = event.pointer_coordinates[i].x / mWidth;
+            y = event.pointer_coordinates[i].y / mHeight;
+            p = event.pointer_coordinates[i].pressure;
+            Mir_OnTouch(touchDevId, pointerFingerId, action, x, y, p, sdl_window, event.button_state);
             break;
-        case mir_motion_action_up:
-        case mir_motion_action_pointer_up:
-            HandleMouseButton(sdl_window, SDL_RELEASED, motion.button_state);
-            break;
-        case mir_motion_action_hover_move:
-        case mir_motion_action_move:
-            HandleMouseMotion(sdl_window,
-                              motion.pointer_coordinates[cord_index].x,
-                              motion.pointer_coordinates[cord_index].y);
-            break;
+
         case mir_motion_action_outside:
             SDL_SetMouseFocus(NULL);
             break;
+
         case mir_motion_action_scroll:
-            HandleMouseScroll(sdl_window,
-                              motion.pointer_coordinates[cord_index].hscroll,
-                              motion.pointer_coordinates[cord_index].vscroll);
+            for (i = 0; i < pointerCount; i++) {
+                SDL_SendMouseWheel(sdl_window, 0,
+                    event.pointer_coordinates[i].hscroll,
+                    event.pointer_coordinates[i].vscroll, 
+                    SDL_MOUSEWHEEL_NORMAL
+                    );
+            } 
+
+        case mir_motion_action_hover_enter:
+            // TODO 
             break;
-        case mir_motion_action_cancel:
-        case mir_motion_action_hover_enter:
+
         case mir_motion_action_hover_exit:
+            // TODO 
+            break;
+
+        default:
+            SDL_Log("Nandled MirMotionEvent action=%08x", action);
+            break;
+    }    
+
+    return;
+}
+
+static void 
+HandleSurfaceEvent(MirSurfaceEvent event, SDL_Window * sdl_window)
+{
+    switch (event.attrib) {
+        case mir_surface_attrib_type:
+            SDL_Log("Not Handled MirSurfaceEvent Type id=%d value=%d", event.id, event.value);
+            break;
+        case mir_surface_attrib_state:
+            SDL_Log("Not Handled MirSurfaceEvent State id=%d value=%d", event.id, event.value);
+            break;
+        case mir_surface_attrib_swapinterval:
+            SDL_Log("Not Handled MirSurfaceEvent SwapInterval id=%d value=%d", event.id, event.value);
+            break;
+        case mir_surface_attrib_focus:
+            if (event.value) {
+                SDL_SetMouseFocus(sdl_window);
+            } else {
+                SDL_SetMouseFocus(NULL);
+            }
+            break;
+        case mir_surface_attribs:
+            SDL_Log("Not Handled MirSurfaceEvent Attribs id=%d value=%d", event.id, event.value);
             break;
         default:
+            SDL_Log("Not Handled MirSurfaceEvent Unkown id=%d value=%d", event.id, event.value);
             break;
     }
+
+    return;
 }
 
 static void
-HandleMotionEvent(MirMotionEvent const motion, SDL_Window* sdl_window)
+HandleResizeEvent(MirResizeEvent event, SDL_Window *sdl_window)
 {
-    int cord_index;
-    for (cord_index = 0; cord_index < motion.pointer_count; cord_index++) {
-        if (motion.pointer_coordinates[cord_index].tool_type == mir_motion_tool_type_finger) {
-            HandleTouchEvent(motion, cord_index, sdl_window);
-        }
-        else {
-            HandleMouseEvent(motion, cord_index, sdl_window);
-        }
-    }
+    SDL_Log("Not Handled MirResizeEvent surface_id=%d width=%d height=%d", event.surface_id, event.width, event.height);
+    return;
 }
+ 
 
 void
 MIR_HandleInput(MirSurface* surface, MirEvent const* ev, void* context)
 {
     SDL_Window* window = (SDL_Window*)context;
     switch (ev->type) {
-        case (mir_event_type_key):
+        case mir_event_type_key:
             HandleKeyEvent(ev->key, window);
             break;
-        case (mir_event_type_motion):
+        case mir_event_type_motion:
             HandleMotionEvent(ev->motion, window);
             break;
+        case mir_event_type_surface:
+            HandleSurfaceEvent(ev->surface, window);
+            break;
+        case mir_event_type_resize:
+            HandleResizeEvent(ev->resize, window);
+            break;
         default:
+            SDL_Log("Not handled MirEvent type=%08x", ev->type);
             break;
     }
 }