Merge commit '61638'

Conflicts:
	src/com/vaadin/terminal/gwt/client/ui/ClickEventHandler.java
	tests/testbench/com/vaadin/tests/components/orderedlayout/LayoutClickListenerTest.html
	tests/testbench/com/vaadin/tests/layouts/TestLayoutClickListeners.html

3 files changed, 102 insertions, 15 deletions

diff --git a/src/com/vaadin/terminal/gwt/client/Util.java b/src/com/vaadin/terminal/gwt/client/Util.java
index 87bf27fc27..010d30e49c 100644
--- a/src/com/vaadin/terminal/gwt/client/Util.java
+++ b/src/com/vaadin/terminal/gwt/client/Util.java
@@ -911,6 +911,22 @@ public class Util {
     }
 
     /**
+     * Find the element corresponding to the coordinates in the passed mouse
+     * event. Please note that this is not always the same as the target of the
+     * element e.g. if event capture is used.
+     * 
+     * @param event
+     *            the mouse event to get coordinates from
+     * @return the element at the coordinates of the event
+     */
+    public static Element getElementUnderMouse(NativeEvent event) {
+        int pageX = getTouchOrMouseClientX(event);
+        int pageY = getTouchOrMouseClientY(event);
+
+        return getElementFromPoint(pageX, pageY);
+    }
+
+    /**
      * A helper method to return the client position from an event. Returns
      * position from either first changed touch (if touch event) or from the
      * event itself.
diff --git a/src/com/vaadin/terminal/gwt/client/ui/AbstractClickEventHandler.java b/src/com/vaadin/terminal/gwt/client/ui/AbstractClickEventHandler.java
index 31204aa0c6..2802277281 100644
--- a/src/com/vaadin/terminal/gwt/client/ui/AbstractClickEventHandler.java
+++ b/src/com/vaadin/terminal/gwt/client/ui/AbstractClickEventHandler.java
@@ -3,29 +3,76 @@
  */
 package com.vaadin.terminal.gwt.client.ui;
 
+import com.google.gwt.core.client.JavaScriptObject;
 import com.google.gwt.dom.client.NativeEvent;
 import com.google.gwt.event.dom.client.ContextMenuEvent;
 import com.google.gwt.event.dom.client.ContextMenuHandler;
 import com.google.gwt.event.dom.client.DomEvent;
 import com.google.gwt.event.dom.client.DoubleClickEvent;
 import com.google.gwt.event.dom.client.DoubleClickHandler;
+import com.google.gwt.event.dom.client.MouseDownEvent;
+import com.google.gwt.event.dom.client.MouseDownHandler;
 import com.google.gwt.event.dom.client.MouseUpEvent;
 import com.google.gwt.event.dom.client.MouseUpHandler;
 import com.google.gwt.event.shared.EventHandler;
 import com.google.gwt.event.shared.HandlerRegistration;
 import com.google.gwt.user.client.Element;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.Event.NativePreviewEvent;
+import com.google.gwt.user.client.Event.NativePreviewHandler;
 import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.Util;
 
-public abstract class AbstractClickEventHandler implements DoubleClickHandler,
-        ContextMenuHandler, MouseUpHandler {
+public abstract class AbstractClickEventHandler implements MouseDownHandler,
+        MouseUpHandler, DoubleClickHandler, ContextMenuHandler {
 
-    private HandlerRegistration doubleClickHandlerRegistration;
+    private HandlerRegistration mouseDownHandlerRegistration;
     private HandlerRegistration mouseUpHandlerRegistration;
+    private HandlerRegistration doubleClickHandlerRegistration;
     private HandlerRegistration contextMenuHandlerRegistration;
 
     protected ComponentConnector connector;
     private String clickEventIdentifier;
 
+    /**
+     * The element where the last mouse down event was registered.
+     */
+    private JavaScriptObject lastMouseDownTarget;
+
+    /**
+     * Set to true by {@link #mouseUpPreviewHandler} if it gets a mouseup at the
+     * same element as {@link #lastMouseDownTarget}.
+     */
+    private boolean mouseUpPreviewMatched = false;
+
+    private HandlerRegistration mouseUpEventPreviewRegistration;
+
+    /**
+     * Previews events after a mousedown to detect where the following mouseup
+     * hits.
+     */
+    private final NativePreviewHandler mouseUpPreviewHandler = new NativePreviewHandler() {
+        @Override
+        public void onPreviewNativeEvent(NativePreviewEvent event) {
+            if (event.getTypeInt() == Event.ONMOUSEUP) {
+                mouseUpEventPreviewRegistration.removeHandler();
+
+                // Event's reported target not always correct if event
+                // capture is in use
+                Element elementUnderMouse = Util.getElementUnderMouse(event
+                        .getNativeEvent());
+                if (lastMouseDownTarget != null
+                        && elementUnderMouse.cast() == lastMouseDownTarget) {
+                    mouseUpPreviewMatched = true;
+                } else {
+                    System.out.println("Ignoring mouseup from "
+                            + elementUnderMouse + " when mousedown was on "
+                            + lastMouseDownTarget);
+                }
+            }
+        }
+    };
+
     public AbstractClickEventHandler(ComponentConnector connector,
             String clickEventIdentifier) {
         this.connector = connector;
@@ -36,7 +83,9 @@ public abstract class AbstractClickEventHandler implements DoubleClickHandler,
         // Handle registering/unregistering of click handler depending on if
         // server side listeners have been added or removed.
         if (hasEventListener()) {
-            if (mouseUpHandlerRegistration == null) {
+            if (mouseDownHandlerRegistration == null) {
+                mouseDownHandlerRegistration = registerHandler(this,
+                        MouseUpEvent.getType());
                 mouseUpHandlerRegistration = registerHandler(this,
                         MouseUpEvent.getType());
                 contextMenuHandlerRegistration = registerHandler(this,
@@ -45,14 +94,16 @@ public abstract class AbstractClickEventHandler implements DoubleClickHandler,
                         DoubleClickEvent.getType());
             }
         } else {
-            if (mouseUpHandlerRegistration != null) {
+            if (mouseDownHandlerRegistration != null) {
                 // Remove existing handlers
-                doubleClickHandlerRegistration.removeHandler();
+                mouseDownHandlerRegistration.removeHandler();
                 mouseUpHandlerRegistration.removeHandler();
+                doubleClickHandlerRegistration.removeHandler();
                 contextMenuHandlerRegistration.removeHandler();
 
-                contextMenuHandlerRegistration = null;
+                mouseDownHandlerRegistration = null;
                 mouseUpHandlerRegistration = null;
+                contextMenuHandlerRegistration = null;
                 doubleClickHandlerRegistration = null;
 
             }
@@ -93,6 +144,7 @@ public abstract class AbstractClickEventHandler implements DoubleClickHandler,
      * Event handler for context menu. Prevents the browser context menu from
      * popping up if there is a listener for right clicks.
      */
+    @Override
     public void onContextMenu(ContextMenuEvent event) {
         if (hasEventListener() && shouldFireEvent(event)) {
             // Prevent showing the browser's context menu when there is a right
@@ -101,18 +153,35 @@ public abstract class AbstractClickEventHandler implements DoubleClickHandler,
         }
     }
 
-    /**
-     * Event handler for mouse up. This is used to detect all single click
-     * events.
-     */
+    @Override
+    public void onMouseDown(MouseDownEvent event) {
+        /*
+         * When getting a mousedown event, we must detect where the
+         * corresponding mouseup event if it's on a different part of the page.
+         */
+        lastMouseDownTarget = event.getNativeEvent().getEventTarget();
+        mouseUpPreviewMatched = false;
+        mouseUpEventPreviewRegistration = Event
+                .addNativePreviewHandler(mouseUpPreviewHandler);
+    }
+
+    @Override
     public void onMouseUp(MouseUpEvent event) {
-        // TODO For perfect accuracy we should check that a mousedown has
-        // occured on this element before this mouseup and that no mouseup
-        // has occured anywhere after that.
-        if (hasEventListener() && shouldFireEvent(event)) {
+        /*
+         * Only fire a click if the mouseup hits the same element as the
+         * corresponding mousedown. This is first checked in the event preview
+         * but we can't fire the even there as the event might get canceled
+         * before it gets here.
+         */
+        if (hasEventListener()
+                && mouseUpPreviewMatched
+                && lastMouseDownTarget != null
+                && Util.getElementUnderMouse(event.getNativeEvent()) == lastMouseDownTarget) {
             // "Click" with left, right or middle button
             fireClick(event.getNativeEvent());
         }
+        mouseUpPreviewMatched = false;
+        lastMouseDownTarget = null;
     }
 
     /**
@@ -140,6 +209,7 @@ public abstract class AbstractClickEventHandler implements DoubleClickHandler,
      * that browsers typically fail to prevent the second click event so a
      * double click will result in two click events and one double click event.
      */
+    @Override
     public void onDoubleClick(DoubleClickEvent event) {
         if (hasEventListener() && shouldFireEvent(event)) {
             fireClick(event.getNativeEvent());
diff --git a/src/com/vaadin/terminal/gwt/client/ui/ClickEventHandler.java b/src/com/vaadin/terminal/gwt/client/ui/ClickEventHandler.java
index cffdb1e68a..758f798ef2 100644
--- a/src/com/vaadin/terminal/gwt/client/ui/ClickEventHandler.java
+++ b/src/com/vaadin/terminal/gwt/client/ui/ClickEventHandler.java
@@ -28,6 +28,7 @@ public abstract class ClickEventHandler extends AbstractClickEventHandler {
      * @param event
      *            The native event that caused this click event
      */
+    @Override
     protected void fireClick(NativeEvent event) {
         MouseEventDetails mouseDetails = MouseEventDetailsBuilder
                 .buildMouseEventDetails(event, getRelativeToElement());