/*
 * Copyright 2011 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.touch.client;

import com.google.gwt.core.client.Duration;
import com.google.gwt.core.client.JsArray;
import com.google.gwt.core.client.Scheduler;
import com.google.gwt.core.client.Scheduler.RepeatingCommand;
import com.google.gwt.dom.client.PartialSupport;
import com.google.gwt.dom.client.Touch;
import com.google.gwt.event.dom.client.TouchCancelEvent;
import com.google.gwt.event.dom.client.TouchCancelHandler;
import com.google.gwt.event.dom.client.TouchEndEvent;
import com.google.gwt.event.dom.client.TouchEndHandler;
import com.google.gwt.event.dom.client.TouchEvent;
import com.google.gwt.event.dom.client.TouchMoveEvent;
import com.google.gwt.event.dom.client.TouchMoveHandler;
import com.google.gwt.event.dom.client.TouchStartEvent;
import com.google.gwt.event.dom.client.TouchStartHandler;
import com.google.gwt.event.logical.shared.AttachEvent;
import com.google.gwt.event.logical.shared.ResizeEvent;
import com.google.gwt.event.logical.shared.ResizeHandler;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.touch.client.Momentum.State;
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.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HasScrolling;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * Adds touch based scrolling to a scroll panel.
 * 
 * <p>
 * Touch based scrolling is only supported on devices that support touch events
 * and do not implement native touch based scrolling.
 * </p>
 */
@PartialSupport
public class TouchScroller {

  /**
   * A point associated with a time.
   * 
   * Visible for testing.
   */
  static class TemporalPoint {
    private Point point;
    private double time;

    public TemporalPoint() {
    }

    /**
     * Construct a new {@link TemporalPoint} for the specified point and time.
     */
    public TemporalPoint(Point point, double time) {
      setTemporalPoint(point, time);
    }

    public Point getPoint() {
      return point;
    }

    public double getTime() {
      return time;
    }

    /**
     * Update the point and time.
     * 
     * @param point the new point
     * @param time the new time
     */
    public void setTemporalPoint(Point point, double time) {
      this.point = point;
      this.time = time;
    }
  }

  /**
   * The command used to apply momentum.
   */
  private class MomentumCommand implements RepeatingCommand {

    private final Duration duration = new Duration();
    private final Point initialPosition = getWidgetScrollPosition();
    private int lastElapsedMillis = 0;
    private State state;
    private HandlerRegistration windowResizeHandler;

    /**
     * Construct a {@link MomentumCommand}.
     * 
     * @param endVelocity the final velocity of the user drag
     */
    public MomentumCommand(Point endVelocity) {
      state = momentum.createState(initialPosition, endVelocity);

      /**
       * If the user resizes the window (which happens on orientation change of
       * a mobile device), cancel the momentum. The scrollable widget may be
       * resized, which will cause its content to reflow and invalidates the
       * current scrolling position.
       */
      windowResizeHandler = Window.addResizeHandler(new ResizeHandler() {
        public void onResize(ResizeEvent event) {
          finish();
        }
      });
    }

    @Override
    public boolean execute() {
      /*
       * Stop the command if another touch event starts or if momentum is
       * disabled.
       */
      if (this != momentumCommand) {
        finish();
        return false;
      }

      // Get the current position from the momentum.
      int cumulativeElapsedMillis = duration.elapsedMillis();
      state.setElapsedMillis(cumulativeElapsedMillis - lastElapsedMillis);
      lastElapsedMillis = cumulativeElapsedMillis;
      state.setCumulativeElapsedMillis(cumulativeElapsedMillis);

      // Calculate the new state.
      boolean notDone = momentum.updateState(state);

      // Momentum is finished, so the user is free to click.
      if (!notDone) {
        finish();
      }

      /*
       * Apply the new position. Even if there is no additional momentum, we
       * want to respect the end position that the momentum returns.
       */
      setWidgetScrollPosition(state.getPosition());

      /*
       * If the scroll position reached the min/max of the scrollable area,
       * finish the momentum command.
       */
      int hPos = (int) state.getPosition().getX();
      int hMin = widget.getMinimumHorizontalScrollPosition();
      int hMax = widget.getMaximumHorizontalScrollPosition();
      int vMin = widget.getMinimumVerticalScrollPosition();
      int vMax = widget.getMaximumVerticalScrollPosition();
      int vPos = (int) state.getPosition().getY();
      if ((vMax <= vPos || vMin >= vPos) && (hMax <= hPos || hMin >= hPos)) {
        finish();
        return false;
      }

      return notDone;
    }

    /**
     * Finish and cleanup this momentum command.
     */
    private void finish() {
      if (windowResizeHandler != null) {
        windowResizeHandler.removeHandler();
        windowResizeHandler = null;
      }
      if (this == momentumCommand) {
        momentumCommand = null;
      }
    }
  }

  /**
   * The command used to remove touch points that occurred while the scrolling
   * momentum is active. Only the touch points that occurred before
   * TIME_THRESHOLD get to be removed.
   */
  private class MomentumTouchRemovalCommand implements RepeatingCommand {
    @Override
    public boolean execute() {
      double currentTime = Duration.currentTimeMillis();
      Iterator<TemporalPoint> iter = touchPositionsDuringMomentum.iterator();
      while (iter.hasNext()) {
        TemporalPoint point = iter.next();
        if (currentTime - point.getTime() >= TIME_THRESHOLD) {
          iter.remove();
        }
      }
      return !touchPositionsDuringMomentum.isEmpty();
    }
  }

  /**
   * The number of frames per second the animation should run at.
   */
  private static final double FRAMES_PER_SECOND = 60;

  /**
   * The number of ms to wait during a drag before updating the reported start
   * position of the drag.
   */
  private static final double MAX_TRACKING_TIME = 200;

  /**
   * The number of ms to wait before putting a position on deck.
   */
  private static final double MAX_TRACKING_TIME_ON_DECK = MAX_TRACKING_TIME / 2;

  /**
   * Minimum movement of touch required to be considered a drag.
   */
  private static final double MIN_TRACKING_FOR_DRAG = 5;

  /**
   * The threshold for how close the time of a click event has to be to that of
   * a touch event for us to consider those events to be related; that is,
   * caused by the same user action (tap).
   */
  private static final int TIME_THRESHOLD = 2500;

  /**
   * The threshold for how close the coordinates of a click event has to be to
   * those of a touch event for us to consider those events to be related;
   * that is, caused by the same user action (tap).
   */
  private static final int DISTANCE_THRESHOLD = 25;

  /**
   * The number of milliseconds per animation frame.
   */
  private static final int MS_PER_FRAME = (int) (1000 / FRAMES_PER_SECOND);

  /**
   * A cached boolean indicating whether or not touch scrolling is supported.
   * Set to a non-null value the first time {@link #isSupported()} is called.
   */
  private static Boolean isSupported;

  /**
   * Return a new {@link TouchScroller}.
   * 
   * @return a new {@link TouchScroller} if supported, and null otherwise
   */
  public static TouchScroller createIfSupported() {
    return isSupported() ? new TouchScroller() : null;
  }

  /**
   * Return a new {@link TouchScroller} that augments the specified scrollable
   * widget if supported, and null otherwise.
   * 
   * @param widget the scrollable widget
   * @return a new {@link TouchScroller} if supported, and null otherwise
   */
  public static TouchScroller createIfSupported(HasScrolling widget) {
    TouchScroller scroller = createIfSupported();
    if (scroller != null) {
      scroller.setTargetWidget(widget);
    }
    return scroller;
  }

  /**
   * Runtime check for whether touch scrolling is supported in this browser.
   * Returns true if touch events are supported but touch based scrolling is not
   * natively supported.
   * 
   * @return true if touch scrolling is supported, false if not
   */
  public static boolean isSupported() {
    if (isSupported == null) {
      /*
       * Android 3.0 devices support touch scrolling natively.
       * 
       * TODO(jlabanca): Find a more reliable way to detect if native touch
       * scrolling is supported.
       */
      isSupported = TouchEvent.isSupported() && !isAndroid3();
    }
    return isSupported;
  }

  /**
   * Check if the user agent is android 3.0 or greater.
   * 
   * @return true if android 3.0+
   * 
   */
  private static native boolean isAndroid3() /*-{
    var ua = navigator.userAgent.toLowerCase();
    return /android ([3-9]+)\.([0-9]+)/.exec(ua) != null;
  }-*/;

  /**
   * The registration for the preview handler used to bust click events.
   */
  private HandlerRegistration bustClickHandlerReg;

  /**
   * The registration for the attach event handler.
   */
  private HandlerRegistration attachHandlerReg;

  /**
   * A boolean indicating that we are in a drag sequence. Dragging occurs after
   * the user moves beyond a threshold distance.
   */
  private boolean dragging;

  /**
   * Registrations for the handlers added to the widget.
   */
  private final List<HandlerRegistration> handlerRegs =
      new ArrayList<HandlerRegistration>();

  /**
   * The last (most recent) touch position. We need to keep track of this when
   * we handle touch move events because the Touch is already destroyed before
   * the touch end event fires.
   */
  private final TemporalPoint lastTouchPosition = new TemporalPoint();

  /**
   * The momentum that determines how the widget scrolls after the user
   * completes a gesture. Can be null if momentum is not supported.
   */
  private Momentum momentum;

  /**
   * The repeating command used to continue momentum after the gesture ends. The
   * command is instantiated after the user finishes a drag sequence. A non null
   * value indicates that momentum is occurring.
   */
  private RepeatingCommand momentumCommand;

  /**
   * The coordinate of the most recent relevant touch event. For most drag
   * sequences this will be the same as the startCoordinate. If the touch
   * gesture changes direction significantly or pauses for a while this
   * coordinate will be updated to the coordinate of the on deck touchmove
   * event.
   */
  private final TemporalPoint recentTouchPosition = new TemporalPoint();

  /**
   * If the gesture takes too long, we update the recentTouchPosition to the
   * position on deck, which occurred halfway through the max tracking time. We
   * do this so that we don't base the velocity on two touch events that
   * occurred very close to each other at the end of a long gesture.
   */
  private TemporalPoint recentTouchPositionOnDeck;

  /**
   * The coordinate of the most recent touch event that triggered scrolling.
   */
  private TemporalPoint recentScrollTriggeringTouchPosition =
      new TemporalPoint();

  /**
   * The coordinates of the touch positions while the momentum is active. The
   * points stored in this array will be removed after TIME_THRESHOLD.
   */
  private List<TemporalPoint> touchPositionsDuringMomentum =
      new ArrayList<TemporalPoint>();

  /**
   * The repeating command used to remove the touch points that were added to
   * touchPositionsDuringMomentum after TIME_THRESHOLD.
   */
  private RepeatingCommand momentumTouchRemovalCommand =
      new MomentumTouchRemovalCommand();

  /**
   * The position of the scrollable when the first touch occured.
   */
  private Point startScrollPosition;

  /**
   * The position of the first touch.
   */
  private Point startTouchPosition;

  /**
   * A boolean indicating that we are in a touch sequence.
   */
  private boolean touching;

  /**
   * The widget being augmented.
   */
  private HasScrolling widget;

  /**
   * Construct a new {@link TouchScroller}. This constructor should be called
   * using the static method {@link #createIfSupported()}.
   * 
   * @see #createIfSupported()
   */
  protected TouchScroller() {
    setMomentum(new DefaultMomentum());
  }

  /**
   * Get the {@link Momentum} that controls scrolling after the user completes a
   * gesture.
   * 
   * @return the scrolling {@link Momentum}, or null if disabled
   */
  public Momentum getMomentum() {
    return momentum;
  }

  /**
   * Get the target {@link HasScrolling} widget that this scroller affects.
   * 
   * @return the target widget
   */
  public HasScrolling getTargetWidget() {
    return widget;
  }

  /**
   * Set the {@link Momentum} that controls scrolling after the user completes a
   * gesture.
   * 
   * @param momentum the scrolling {@link Momentum}, or null to disable
   */
  public void setMomentum(Momentum momentum) {
    this.momentum = momentum;
    if (momentum == null) {
      // Cancel the current momentum.
      momentumCommand = null;
    }
  }

  /**
   * Set the target {@link HasScrolling} widget that this scroller affects.
   * 
   * @param widget the target widget, or null to disbale
   */
  public void setTargetWidget(HasScrolling widget) {
    if (this.widget == widget) {
      return;
    }

    // Cancel drag and momentum.
    cancelAll();

    // Release the old widget.
    for (HandlerRegistration reg : handlerRegs) {
      reg.removeHandler();
    }
    handlerRegs.clear();
    removeAttachHandler();
    removeBustClickHandler();

    // Attach to the new widget.
    this.widget = widget;
    if (widget != null) {
      if (widget.asWidget().isAttached()) {
        setupBustClickHandler();
      }

      // Make sure to add/remove the bust click handler if the widget is attached/detached.
      attachHandlerReg = widget.asWidget().addAttachHandler(new AttachEvent.Handler() {
        @Override
        public void onAttachOrDetach(AttachEvent event) {
          if (event.isAttached()) {
            setupBustClickHandler();
          } else {
            removeBustClickHandler();
          }
        }
      });

      // Add touch start handler.
      handlerRegs.add(widget.asWidget().addDomHandler(new TouchStartHandler() {
        @Override
        public void onTouchStart(TouchStartEvent event) {
          TouchScroller.this.onTouchStart(event);
        }
      }, TouchStartEvent.getType()));

      // Add touch move handler.
      handlerRegs.add(widget.asWidget().addDomHandler(new TouchMoveHandler() {
        @Override
        public void onTouchMove(TouchMoveEvent event) {
          TouchScroller.this.onTouchMove(event);
        }
      }, TouchMoveEvent.getType()));

      // Add touch end handler.
      handlerRegs.add(widget.asWidget().addDomHandler(new TouchEndHandler() {
        @Override
        public void onTouchEnd(TouchEndEvent event) {
          TouchScroller.this.onTouchEnd(event);
        }
      }, TouchEndEvent.getType()));

      // Add touch cancel handler.
      handlerRegs.add(widget.asWidget().addDomHandler(new TouchCancelHandler() {
        @Override
        public void onTouchCancel(TouchCancelEvent event) {
          TouchScroller.this.onTouchCancel(event);
        }
      }, TouchCancelEvent.getType()));
    }
  }

  /**
   * Get touch from event.
   * 
   * @param event the event
   * @return the touch object
   */
  protected Touch getTouchFromEvent(TouchEvent<?> event) {
    JsArray<Touch> touches = event.getTouches();
    return (touches.length() > 0) ? touches.get(0) : null;
  }

  /**
   * Called when the object's drag sequence is complete.
   * 
   * @param event the touch event
   */
  protected void onDragEnd(TouchEvent<?> event) {
    // There is no momentum or it isn't supported.
    if (momentum == null) {
      return;
    }

    // Schedule the momentum.
    Point endVelocity = calculateEndVelocity(recentTouchPosition, lastTouchPosition);
    if (endVelocity != null) {
      momentumCommand = new MomentumCommand(endVelocity);
      Scheduler.get().scheduleFixedDelay(momentumCommand, MS_PER_FRAME);
    }
  }

  /**
   * Called when the object has been dragged to a new position.
   * 
   * @param event the touch event
   */
  protected void onDragMove(TouchEvent<?> event) {
    /*
     * Scroll to the new position. Touch scrolling moves in the same direction
     * as the finger dragging, whereas scrolling is inverted with traditional
     * scrollbars.
     */
    Point diff = startTouchPosition.minus(lastTouchPosition.getPoint());
    Point curScrollPosition = startScrollPosition.plus(diff);
    setWidgetScrollPosition(curScrollPosition);
  }

  /**
   * Called when the object has started dragging.
   * 
   * @param event the touch event
   */
  protected void onDragStart(TouchEvent<?> event) {
  }

  /**
   * Called when the user cancels a touch. This can happen if the user touches
   * the screen with too many fingers.
   * 
   * @param event the touch event
   */
  protected void onTouchCancel(TouchEvent<?> event) {
    onTouchEnd(event);
  }

  /**
   * Called when the user releases a touch.
   * 
   * @param event the touch event
   */
  protected void onTouchEnd(TouchEvent<?> event) {
    // Ignore the touch if we didn't catch a touch start event.
    if (!touching) {
      return;
    }
    touching = false;

    // Stop dragging.
    if (dragging) {
      dragging = false;
      onDragEnd(event);
    }
  }

  /**
   * Called when the user moves a touch.
   *
   * @param event the touch event
   */
  protected void onTouchMove(TouchEvent<?> event) {
    // Ignore the touch if we never caught a touch start event.
    if (!touching) {
      return;
    }

    // Check if we should start dragging.
    Touch touch = getTouchFromEvent(event);
    Point touchPoint = new Point(touch.getPageX(), touch.getPageY());
    double touchTime = Duration.currentTimeMillis();
    lastTouchPosition.setTemporalPoint(touchPoint, touchTime);
    if (!dragging) {
      Point diff = touchPoint.minus(startTouchPosition);
      double absDiffX = Math.abs(diff.getX());
      double absDiffY = Math.abs(diff.getY());
      if (absDiffX > MIN_TRACKING_FOR_DRAG || absDiffY > MIN_TRACKING_FOR_DRAG) {
        recentScrollTriggeringTouchPosition.setTemporalPoint(
            recentTouchPosition.getPoint(), recentTouchPosition.getTime());

        /*
         * Check if we should defer to native scrolling. If the scrollable
         * widget is already scrolled as far as it will go, then we don't want
         * to prevent scrolling of the document.
         * 
         * We cannot prevent native scrolling in only one direction (ie. we
         * cannot allow native horizontal scrolling but prevent native vertical
         * scrolling), so we make a best guess based on the direction of the
         * drag.
         */
        if (absDiffX > absDiffY) {
          /*
           * The user scrolled primarily in the horizontal direction, so check
           * if we should defer left/right scrolling to the document.
           */
          int hPosition = widget.getHorizontalScrollPosition();
          int hMin = widget.getMinimumHorizontalScrollPosition();
          int hMax = widget.getMaximumHorizontalScrollPosition();
          if (diff.getX() < 0 && hMax <= hPosition) {
            // Already scrolled to the right.
            cancelAll();
            return;
          } else if (diff.getX() > 0 && hMin >= hPosition) {
            // Already scrolled to the left.
            cancelAll();
            return;
          }
        } else {
          /*
           * The user scrolled primarily in the vertical direction, so check if
           * we should defer up/down scrolling to the document.
           */
          int vPosition = widget.getVerticalScrollPosition();
          int vMin = widget.getMinimumVerticalScrollPosition();
          int vMax = widget.getMaximumVerticalScrollPosition();
          if (diff.getY() < 0 && vMax <= vPosition) {
            // Already scrolled to the bottom.
            cancelAll();
            return;
          } else if (diff.getY() > 0 && vMin >= vPosition) {
            // Already scrolled to the top.
            cancelAll();
            return;
          }
        }

        // Start dragging.
        dragging = true;
        onDragStart(event);
      }
    }

    // Prevent native document level scrolling.
    event.preventDefault();

    if (dragging) {
      // Continue dragging.
      onDragMove(event);

      /*
       * Update the recent position. This happens when they are dragging slowly.
       * If they are dragging slowly then we should reset the start time and
       * position to where they are now. This will be important during the drag
       * end when we report to the draggable delegate what kind of drag just
       * happened.
       */
      double trackingTime = touchTime - recentTouchPosition.getTime();
      if (trackingTime > MAX_TRACKING_TIME && recentTouchPositionOnDeck != null) {
        // See comment below.
        recentTouchPosition.setTemporalPoint(recentTouchPositionOnDeck.getPoint(),
            recentTouchPositionOnDeck.getTime());
        recentTouchPositionOnDeck = null;
      } else if (trackingTime > MAX_TRACKING_TIME_ON_DECK && recentTouchPositionOnDeck == null) {
        /*
         * When we are halfway to the max tracking time, put the current touch
         * on deck. When we switch the recent touch position, we use the on deck
         * position. That prevents us from calculating the velocity from two
         * points that are too close in time (or the same time).
         */
        recentTouchPositionOnDeck = new TemporalPoint(touchPoint, touchTime);
      }
    }
  }

  /**
   * Called when the user starts a touch.
   * 
   * @param event the touch event
   */
  protected void onTouchStart(TouchEvent<?> event) {
    // Touch start event always precedes the click event. So this
    // recentScrollTriggeringTouchPosition gets reset before a click event
    // occurs. That's why we don't need to compare the time of the ghost click
    // and the recentScrollTriggeringTouchPosition.
    recentScrollTriggeringTouchPosition.setTemporalPoint(null, 0);

    // Ignore the touch if there is already a touch happening.
    if (touching) {
      return;
    }

    // Record the starting touch position.
    Touch touch = getTouchFromEvent(event);
    startTouchPosition = new Point(touch.getPageX(), touch.getPageY());
    double startTouchTime = Duration.currentTimeMillis();
    recentTouchPosition.setTemporalPoint(startTouchPosition, startTouchTime);
    lastTouchPosition.setTemporalPoint(startTouchPosition, startTouchTime);
    recentTouchPositionOnDeck = null;

    /**
     * If the user touches the screen while the scrolling momentum is active,
     * add the touch point to an array so that the later click events can be
     * compared to the points in the array and busted if it shouldn't be
     * considered as click.
     */
    if (isMomentumActive()) {
      touchPositionsDuringMomentum.add(
          new TemporalPoint(startTouchPosition, startTouchTime));
      Scheduler.get().scheduleFixedDelay(
          momentumTouchRemovalCommand, TIME_THRESHOLD);
    }

    // Record the starting scroll position.
    startScrollPosition = getWidgetScrollPosition();

    cancelAll();
    touching = true;
  }

  /**
   * Calculate the end velocity. Visible for testing.
   * 
   * @param from the starting point
   * @param to the ending point
   * @return the end velocity, or null if it cannot be calculated
   */
  Point calculateEndVelocity(TemporalPoint from, TemporalPoint to) {
    /*
     * Calculate the time since the recent touch. The time can be zero if the
     * user pauses for too long, which updates the recentTouchPosition, then
     * lets go without moving again.
     */
    double time = to.getTime() - from.getTime();
    if (time <= 0) {
      return null;
    }

    /*
     * Calculate the end velocities. The velocity is inverted from the direction
     * of the gesture.
     */
    Point dist = from.getPoint().minus(to.getPoint());
    return new Point(dist.getX() / time, dist.getY() / time);
  }

  /**
   * Visible for testing.
   */
  TemporalPoint getLastTouchPosition() {
    return lastTouchPosition;
  }

  /**
   * Visible for testing.
   */
  TemporalPoint getRecentTouchPosition() {
    return recentTouchPosition;
  }

  /**
   * Visible for testing.
   */
  boolean isDragging() {
    return dragging;
  }

  /**
   * Check if momentum is currently active. Visible for testing.
   * 
   * @return true if active, false if not
   */
  boolean isMomentumActive() {
    return (momentumCommand != null);
  }

  /**
   * Visible for testing.
   */
  boolean isTouching() {
    return touching;
  }

  /**
   * Removes the attach handler. Visible for testing.
   */
  void removeAttachHandler() {
    if (attachHandlerReg != null) {
      attachHandlerReg.removeHandler();
      attachHandlerReg = null;
    }
  }

  /**
   * Removes the bust click handler. Visible for testing.
   */
  void removeBustClickHandler() {
    if (bustClickHandlerReg != null) {
      bustClickHandlerReg.removeHandler();
      bustClickHandlerReg = null;
    }
  }

  /**
   * Sets up the bust click handler. Visible for testing.
   */
  void setupBustClickHandler() {
    removeBustClickHandler();
    bustClickHandlerReg = Event.addNativePreviewHandler(new NativePreviewHandler() {
      @Override
      public void onPreviewNativeEvent(NativePreviewEvent event) {
        if (Event.ONCLICK == event.getTypeInt()) {
          Point clickPoint = new Point(
              event.getNativeEvent().getClientX(),
              event.getNativeEvent().getClientY());

          /*
           * In mobile browsers, when the user touches on the screen, drag
           * his finger across and take his finger off, the browser fires a
           * click event at the position where the touch start happen. This
           * click event is called "ghost click". This click is not intended by
           * the user and thus needs to be busted.
           * Also, while the panel is scrolling, if the user taps on the screen
           * we want to stop the scrolling and bust the click event that's fired
           * because the user probably didn't mean to click on something.
           */
          if (isClickScrollTriggeringTouch(clickPoint) ||
              isClickTouchPositionDuringMomentum(clickPoint)) {
            event.cancel();
            event.getNativeEvent().stopPropagation();
            event.getNativeEvent().preventDefault();
          }
        }
      }
    });
  }

  /**
   * Cancel all existing touch, drag, and momentum.
   */
  private void cancelAll() {
    touching = false;
    dragging = false;
    momentumCommand = null;
  }

  /**
   * Get the scroll position of the widget.
   */
  private Point getWidgetScrollPosition() {
    return new Point(widget.getHorizontalScrollPosition(), widget.getVerticalScrollPosition());
  }

  /**
   * Tests if the given points fall within the threshold from each other.
   *
   * @param point1 first point
   * @param point2 second point
   * @return true if the points fall within the threshold from each other
   */
  private boolean hitTest(Point point1, Point point2) {
    Point diff = point1.minus(point2);
    double absDiffX = Math.abs(diff.getX());
    double absDiffY = Math.abs(diff.getY());
    return (absDiffX <= DISTANCE_THRESHOLD) && (absDiffY <= DISTANCE_THRESHOLD);
  }

  /**
   * Checks if the click event is related to the touch event that has triggered
   * scrolling. Such click events occur as a result of ghost click (i.e. click
   * event that is fired at the touch start position after the touch end
   * happens) and should be busted.
   *
   * @param clickPoint point of the click event
   * @return true if clickPoint is the same as the recent scroll triggering
   *     touch
   */
  private boolean isClickScrollTriggeringTouch(Point clickPoint) {
    if (recentScrollTriggeringTouchPosition.getPoint() != null) {
      return hitTest(
          clickPoint, recentScrollTriggeringTouchPosition.getPoint());
    }
    return false;
  }

  /**
   * Checks if the click event point is related to the touch positions
   * during the recent momentum scrolling.
   *
   * @param clickPoint point of the click event
   * @return true if clickPoint is the same as one of the touch positions during
   *     the recent momentum scrolling
   */
  private boolean isClickTouchPositionDuringMomentum(Point clickPoint) {
    double currentTime = Duration.currentTimeMillis();
    boolean same = false;
    for (TemporalPoint point : touchPositionsDuringMomentum) {
      if (currentTime - point.getTime() <= TIME_THRESHOLD &&
          hitTest(clickPoint, point.getPoint())) {
        same = true;
        break;
      }
    }
    return same;
  }

  /**
   * Sets the scroll position of the widget.
   * 
   * @param position the new position
   */
  private void setWidgetScrollPosition(Point position) {
    widget.setHorizontalScrollPosition((int) position.getX());
    widget.setVerticalScrollPosition((int) position.getY());
  }
}