src/com/android/launcher2/DragController.java - platform/packages/apps/Launcher2 - Git at Google

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * 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.android.launcher2;

 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Matrix;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.os.IBinder;
 import android.os.Handler;
 import android.os.Vibrator;
 import android.os.SystemClock;
 import android.util.AttributeSet;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.WindowManager;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.FrameLayout;
 import android.widget.ImageView;

 import java.util.ArrayList;

 /**
  * Class for initiating a drag within a view or across multiple views.
  */
 public class DragController {
     private static final String TAG = "Launcher.DragController";

     /** Indicates the drag is a move.  */
     public static int DRAG_ACTION_MOVE = 0;

     /** Indicates the drag is a copy.  */
     public static int DRAG_ACTION_COPY = 1;

     private static final int SCROLL_DELAY = 600;
     private static final int SCROLL_ZONE = 20;
     private static final int VIBRATE_DURATION = 35;

     private static final boolean PROFILE_DRAWING_DURING_DRAG = false;

     private static final int SCROLL_OUTSIDE_ZONE = 0;
     private static final int SCROLL_WAITING_IN_ZONE = 1;

     private static final int SCROLL_LEFT = 0;
     private static final int SCROLL_RIGHT = 1;

     private Context mContext;
     private Handler mHandler;
     private final Vibrator mVibrator = new Vibrator();

     // temporaries to avoid gc thrash
     private Rect mRectTemp = new Rect();
     private final int[] mCoordinatesTemp = new int[2];

     /** Whether or not we're dragging. */
     private boolean mDragging;

     /** X coordinate of the down event. */
     private float mMotionDownX;

     /** Y coordinate of the down event. */
     private float mMotionDownY;

     /** Info about the screen for clamping. */
     private DisplayMetrics mDisplayMetrics = new DisplayMetrics();

     /** Original view that is being dragged.  */
     private View mOriginator;

     /** X offset from the upper-left corner of the cell to where we touched.  */
     private float mTouchOffsetX;

     /** Y offset from the upper-left corner of the cell to where we touched.  */
     private float mTouchOffsetY;

     /** Where the drag originated */
     private DragSource mDragSource;

     /** The data associated with the object being dragged */
     private Object mDragInfo;

     /** The view that moves around while you drag.  */
     private DragView mDragView;

     /** Who can receive drop events */
     private ArrayList<DropTarget> mDropTargets = new ArrayList<DropTarget>();

     private DragListener mListener;

     /** The window token used as the parent for the DragView. */
     private IBinder mWindowToken;

     /** The view that will be scrolled when dragging to the left and right edges of the screen. */
     private View mScrollView;

     private DragScroller mDragScroller;
     private int mScrollState = SCROLL_OUTSIDE_ZONE;
     private ScrollRunnable mScrollRunnable = new ScrollRunnable();

     private RectF mDeleteRegion;
     private DropTarget mLastDropTarget;

     private InputMethodManager mInputMethodManager;

     /**
      * Interface to receive notifications when a drag starts or stops
      */
     interface DragListener {

         /**
          * A drag has begun
          *
          * @param source An object representing where the drag originated
          * @param info The data associated with the object that is being dragged
          * @param dragAction The drag action: either {@link DragController#DRAG_ACTION_MOVE}
          *        or {@link DragController#DRAG_ACTION_COPY}
          */
         void onDragStart(DragSource source, Object info, int dragAction);

         /**
          * The drag has eneded
          */
         void onDragEnd();
     }

     /**
      * Used to create a new DragLayer from XML.
      *
      * @param context The application's context.
      * @param attrs The attribtues set containing the Workspace's customization values.
      */
     public DragController(Context context) {
         mContext = context;
         mHandler = new Handler();
     }

     /**
      * Starts a drag.
      *
      * @param v The view that is being dragged
      * @param source An object representing where the drag originated
      * @param info The data associated with the object that is being dragged
      * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
      *        {@link #DRAG_ACTION_COPY}
      */
     public void startDrag(View v, DragSource source, Object dragInfo, int dragAction) {
         mOriginator = v;

         Bitmap b = getViewBitmap(v);

         int[] loc = mCoordinatesTemp;
         v.getLocationOnScreen(loc);
         int screenX = loc[0];
         int screenY = loc[1];

         startDrag(b, screenX, screenY, 0, 0, b.getWidth(), b.getHeight(),
                 source, dragInfo, dragAction);

         b.recycle();

         if (dragAction == DRAG_ACTION_MOVE) {
             v.setVisibility(View.GONE);
         }
     }

     /**
      * Starts a drag.
      *
      * @param b The bitmap to display as the drag image.  It will be re-scaled to the
      *          enlarged size.
      * @param screenX The x position on screen of the left-top of the bitmap.
      * @param screenY The y position on screen of the left-top of the bitmap.
      * @param textureLeft The left edge of the region inside b to use.
      * @param textureTop The top edge of the region inside b to use.
      * @param textureWidth The width of the region inside b to use.
      * @param textureHeight The height of the region inside b to use.
      * @param source An object representing where the drag originated
      * @param info The data associated with the object that is being dragged
      * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
      *        {@link #DRAG_ACTION_COPY}
      */
     public void startDrag(Bitmap b, int screenX, int screenY,
             int textureLeft, int textureTop, int textureWidth, int textureHeight,
             DragSource source, Object dragInfo, int dragAction) {
         if (PROFILE_DRAWING_DURING_DRAG) {
             android.os.Debug.startMethodTracing("Launcher");
         }

         // Hide soft keyboard, if visible
         if (mInputMethodManager == null) {
             mInputMethodManager = (InputMethodManager)
                     mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
         }
         mInputMethodManager.hideSoftInputFromWindow(mWindowToken, 0);

         if (mListener != null) {
             mListener.onDragStart(source, dragInfo, dragAction);
         }

         int registrationX = ((int)mMotionDownX) - screenX;
         int registrationY = ((int)mMotionDownY) - screenY;

         mTouchOffsetX = mMotionDownX - screenX;
         mTouchOffsetY = mMotionDownY - screenY;

         mDragging = true;
         mDragSource = source;
         mDragInfo = dragInfo;

         mVibrator.vibrate(VIBRATE_DURATION);

         DragView dragView = mDragView = new DragView(mContext, b, registrationX, registrationY,
                 textureLeft, textureTop, textureWidth, textureHeight);
         dragView.show(mWindowToken, (int)mMotionDownX, (int)mMotionDownY);
     }

     /**
      * Draw the view into a bitmap.
      */
     private Bitmap getViewBitmap(View v) {
         v.clearFocus();
         v.setPressed(false);

         boolean willNotCache = v.willNotCacheDrawing();
         v.setWillNotCacheDrawing(false);

         // Reset the drawing cache background color to fully transparent
         // for the duration of this operation
         int color = v.getDrawingCacheBackgroundColor();
         v.setDrawingCacheBackgroundColor(0);

         if (color != 0) {
             v.destroyDrawingCache();
         }
         v.buildDrawingCache();
         Bitmap cacheBitmap = v.getDrawingCache();

         Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);

         // Restore the view
         v.destroyDrawingCache();
         v.setWillNotCacheDrawing(willNotCache);
         v.setDrawingCacheBackgroundColor(color);

         return bitmap;
     }

     /**
      * Call this from a drag source view like this:
      *
      * <pre>
      *  @Override
      *  public boolean dispatchKeyEvent(KeyEvent event) {
      *      return mDragController.dispatchKeyEvent(this, event)
      *              || super.dispatchKeyEvent(event);
      * </pre>
      */
     public boolean dispatchKeyEvent(KeyEvent event) {
         return mDragging;
     }

     /**
      * Stop dragging without dropping.
      */
     public void cancelDrag() {
         endDrag();
     }

     private void endDrag() {
         if (mDragging) {
             mDragging = false;
             if (mOriginator != null) {
                 mOriginator.setVisibility(View.VISIBLE);
             }
             if (mListener != null) {
                 mListener.onDragEnd();
             }
             if (mDragView != null) {
                 mDragView.remove();
                 mDragView = null;
             }
         }
     }

     /**
      * Call this from a drag source view.
      */
     public boolean onInterceptTouchEvent(MotionEvent ev) {
         if (false) {
             Log.d(Launcher.TAG, "DragController.onInterceptTouchEvent " + ev + " mDragging="
                     + mDragging);
         }
         final int action = ev.getAction();

         if (action == MotionEvent.ACTION_DOWN) {
             recordScreenSize();
         }

         final int screenX = clamp((int)ev.getRawX(), 0, mDisplayMetrics.widthPixels);
         final int screenY = clamp((int)ev.getRawY(), 0, mDisplayMetrics.heightPixels);

         switch (action) {
             case MotionEvent.ACTION_MOVE:
                 break;

             case MotionEvent.ACTION_DOWN:
                 // Remember location of down touch
                 mMotionDownX = screenX;
                 mMotionDownY = screenY;
                 mLastDropTarget = null;
                 break;

             case MotionEvent.ACTION_CANCEL:
             case MotionEvent.ACTION_UP:
                 if (mDragging) {
                     drop(screenX, screenY);
                 }
                 endDrag();
                 break;
         }

         return mDragging;
     }

     /**
      * Call this from a drag source view.
      */
     public boolean onTouchEvent(MotionEvent ev) {
         View scrollView = mScrollView;

         if (!mDragging) {
             return false;
         }

         final int action = ev.getAction();
         final int screenX = clamp((int)ev.getRawX(), 0, mDisplayMetrics.widthPixels);
         final int screenY = clamp((int)ev.getRawY(), 0, mDisplayMetrics.heightPixels);

         switch (action) {
         case MotionEvent.ACTION_DOWN:
             // Remember where the motion event started
             mMotionDownX = screenX;
             mMotionDownY = screenY;

             if ((screenX < SCROLL_ZONE) || (screenX > scrollView.getWidth() - SCROLL_ZONE)) {
                 mScrollState = SCROLL_WAITING_IN_ZONE;
                 mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
             } else {
                 mScrollState = SCROLL_OUTSIDE_ZONE;
             }

             break;
         case MotionEvent.ACTION_MOVE:
             // Update the drag view.  Don't use the clamped pos here so the dragging looks
             // like it goes off screen a little, intead of bumping up against the edge.
             mDragView.move((int)ev.getRawX(), (int)ev.getRawY());

             // Drop on someone?
             final int[] coordinates = mCoordinatesTemp;
             DropTarget dropTarget = findDropTarget((int) screenX, (int) screenY, coordinates);
             if (dropTarget != null) {
                 if (mLastDropTarget == dropTarget) {
                     dropTarget.onDragOver(mDragSource, coordinates[0], coordinates[1],
                         (int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
                 } else {
                     if (mLastDropTarget != null) {
                         mLastDropTarget.onDragExit(mDragSource, coordinates[0], coordinates[1],
                             (int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
                     }
                     dropTarget.onDragEnter(mDragSource, coordinates[0], coordinates[1],
                         (int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
                 }
             } else {
                 if (mLastDropTarget != null) {
                     mLastDropTarget.onDragExit(mDragSource, coordinates[0], coordinates[1],
                         (int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
                 }
             }
             mLastDropTarget = dropTarget;

             // Scroll, maybe, but not if we're in the delete region.
             boolean inDeleteRegion = false;
             if (mDeleteRegion != null) {
                 inDeleteRegion = mDeleteRegion.contains(screenX, screenY);
             }
             if (!inDeleteRegion && screenX < SCROLL_ZONE) {
                 if (mScrollState == SCROLL_OUTSIDE_ZONE) {
                     mScrollState = SCROLL_WAITING_IN_ZONE;
                     mScrollRunnable.setDirection(SCROLL_LEFT);
                     mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
                 }
             } else if (!inDeleteRegion && screenX > scrollView.getWidth() - SCROLL_ZONE) {
                 if (mScrollState == SCROLL_OUTSIDE_ZONE) {
                     mScrollState = SCROLL_WAITING_IN_ZONE;
                     mScrollRunnable.setDirection(SCROLL_RIGHT);
                     mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
                 }
             } else {
                 if (mScrollState == SCROLL_WAITING_IN_ZONE) {
                     mScrollState = SCROLL_OUTSIDE_ZONE;
                     mScrollRunnable.setDirection(SCROLL_RIGHT);
                     mHandler.removeCallbacks(mScrollRunnable);
                 }
             }

             break;
         case MotionEvent.ACTION_UP:
             mHandler.removeCallbacks(mScrollRunnable);
             if (mDragging) {
                 drop(screenX, screenY);
             }
             endDrag();

             break;
         case MotionEvent.ACTION_CANCEL:
             cancelDrag();
         }

         return true;
     }

     private boolean drop(float x, float y) {
         final int[] coordinates = mCoordinatesTemp;
         DropTarget dropTarget = findDropTarget((int) x, (int) y, coordinates);

         if (dropTarget != null) {
             dropTarget.onDragExit(mDragSource, coordinates[0], coordinates[1],
                     (int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
             if (dropTarget.acceptDrop(mDragSource, coordinates[0], coordinates[1],
                     (int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo)) {
                 dropTarget.onDrop(mDragSource, coordinates[0], coordinates[1],
                         (int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
                 mDragSource.onDropCompleted((View) dropTarget, true);
                 return true;
             } else {
                 mDragSource.onDropCompleted((View) dropTarget, false);
                 return true;
             }
         }
         return false;
     }

     private DropTarget findDropTarget(int x, int y, int[] dropCoordinates) {
         final Rect r = mRectTemp;

         final ArrayList<DropTarget> dropTargets = mDropTargets;
         final int count = dropTargets.size();
         for (int i=count-1; i>=0; i--) {
             final DropTarget target = dropTargets.get(i);
             target.getHitRect(r);
             target.getLocationOnScreen(dropCoordinates);
             r.offset(dropCoordinates[0] - target.getLeft(), dropCoordinates[1] - target.getTop());
             if (r.contains(x, y)) {
                 dropCoordinates[0] = x - dropCoordinates[0];
                 dropCoordinates[1] = y - dropCoordinates[1];
                 return target;
             }
         }
         return null;
     }

     /**
      * Get the screen size so we can clamp events to the screen size so even if
      * you drag off the edge of the screen, we find something.
      */
     private void recordScreenSize() {
         ((WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE))
                 .getDefaultDisplay().getMetrics(mDisplayMetrics);
     }

     /**
      * Clamp val to be &gt;= min and &lt; max.
      */
     private static int clamp(int val, int min, int max) {
         if (val < min) {
             return min;
         } else if (val >= max) {
             return max - 1;
         } else {
             return val;
         }
     }

     public void setDragScoller(DragScroller scroller) {
         mDragScroller = scroller;
     }

     public void setWindowToken(IBinder token) {
         mWindowToken = token;
     }

     /**
      * Sets the drag listner which will be notified when a drag starts or ends.
      */
     public void setDragListener(DragListener l) {
         mListener = l;
     }

     /**
      * Remove a previously installed drag listener.
      */
     public void removeDragListener(DragListener l) {
         mListener = null;
     }

     /**
      * Add a DropTarget to the list of potential places to receive drop events.
      */
     public void addDropTarget(DropTarget target) {
         mDropTargets.add(target);
     }

     /**
      * Don't send drop events to <em>target</em> any more.
      */
     public void removeDropTarget(DropTarget target) {
         mDropTargets.remove(target);
     }

     /**
      * Set which view scrolls for touch events near the edge of the screen.
      */
     public void setScrollView(View v) {
         mScrollView = v;
     }

     /**
      * Specifies the delete region.  We won't scroll on touch events over the delete region.
      *
      * @param region The rectangle in screen coordinates of the delete region.
      */
     void setDeleteRegion(RectF region) {
         mDeleteRegion = region;
     }

     private class ScrollRunnable implements Runnable {
         private int mDirection;

         ScrollRunnable() {
         }

         public void run() {
             if (mDragScroller != null) {
                 if (mDirection == SCROLL_LEFT) {
                     mDragScroller.scrollLeft();
                 } else {
                     mDragScroller.scrollRight();
                 }
                 mScrollState = SCROLL_OUTSIDE_ZONE;
             }
         }

         void setDirection(int direction) {
             mDirection = direction;
         }
     }
 }
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* 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.android.launcher2;

	import android.content.Context;
	import android.graphics.Bitmap;
	import android.graphics.Canvas;
	import android.graphics.Matrix;
	import android.graphics.Rect;
	import android.graphics.RectF;
	import android.os.IBinder;
	import android.os.Handler;
	import android.os.Vibrator;
	import android.os.SystemClock;
	import android.util.AttributeSet;
	import android.util.DisplayMetrics;
	import android.util.Log;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.KeyEvent;
	import android.view.MotionEvent;
	import android.view.WindowManager;
	import android.view.inputmethod.InputMethodManager;
	import android.widget.FrameLayout;
	import android.widget.ImageView;

	import java.util.ArrayList;

	/**
	* Class for initiating a drag within a view or across multiple views.
	*/
	public class DragController {
	private static final String TAG = "Launcher.DragController";

	/** Indicates the drag is a move. */
	public static int DRAG_ACTION_MOVE = 0;

	/** Indicates the drag is a copy. */
	public static int DRAG_ACTION_COPY = 1;

	private static final int SCROLL_DELAY = 600;
	private static final int SCROLL_ZONE = 20;
	private static final int VIBRATE_DURATION = 35;

	private static final boolean PROFILE_DRAWING_DURING_DRAG = false;

	private static final int SCROLL_OUTSIDE_ZONE = 0;
	private static final int SCROLL_WAITING_IN_ZONE = 1;

	private static final int SCROLL_LEFT = 0;
	private static final int SCROLL_RIGHT = 1;

	private Context mContext;
	private Handler mHandler;
	private final Vibrator mVibrator = new Vibrator();

	// temporaries to avoid gc thrash
	private Rect mRectTemp = new Rect();
	private final int[] mCoordinatesTemp = new int[2];

	/** Whether or not we're dragging. */
	private boolean mDragging;

	/** X coordinate of the down event. */
	private float mMotionDownX;

	/** Y coordinate of the down event. */
	private float mMotionDownY;

	/** Info about the screen for clamping. */
	private DisplayMetrics mDisplayMetrics = new DisplayMetrics();

	/** Original view that is being dragged. */
	private View mOriginator;

	/** X offset from the upper-left corner of the cell to where we touched. */
	private float mTouchOffsetX;

	/** Y offset from the upper-left corner of the cell to where we touched. */
	private float mTouchOffsetY;

	/** Where the drag originated */
	private DragSource mDragSource;

	/** The data associated with the object being dragged */
	private Object mDragInfo;

	/** The view that moves around while you drag. */
	private DragView mDragView;

	/** Who can receive drop events */
	private ArrayList<DropTarget> mDropTargets = new ArrayList<DropTarget>();

	private DragListener mListener;

	/** The window token used as the parent for the DragView. */
	private IBinder mWindowToken;

	/** The view that will be scrolled when dragging to the left and right edges of the screen. */
	private View mScrollView;

	private DragScroller mDragScroller;
	private int mScrollState = SCROLL_OUTSIDE_ZONE;
	private ScrollRunnable mScrollRunnable = new ScrollRunnable();

	private RectF mDeleteRegion;
	private DropTarget mLastDropTarget;

	private InputMethodManager mInputMethodManager;

	/**
	* Interface to receive notifications when a drag starts or stops
	*/
	interface DragListener {

	/**
	* A drag has begun
	*
	* @param source An object representing where the drag originated
	* @param info The data associated with the object that is being dragged
	* @param dragAction The drag action: either {@link DragController#DRAG_ACTION_MOVE}
	* or {@link DragController#DRAG_ACTION_COPY}
	*/
	void onDragStart(DragSource source, Object info, int dragAction);

	/**
	* The drag has eneded
	*/
	void onDragEnd();
	}

	/**
	* Used to create a new DragLayer from XML.
	*
	* @param context The application's context.
	* @param attrs The attribtues set containing the Workspace's customization values.
	*/
	public DragController(Context context) {
	mContext = context;
	mHandler = new Handler();
	}

	/**
	* Starts a drag.
	*
	* @param v The view that is being dragged
	* @param source An object representing where the drag originated
	* @param info The data associated with the object that is being dragged
	* @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
	* {@link #DRAG_ACTION_COPY}
	*/
	public void startDrag(View v, DragSource source, Object dragInfo, int dragAction) {
	mOriginator = v;

	Bitmap b = getViewBitmap(v);

	int[] loc = mCoordinatesTemp;
	v.getLocationOnScreen(loc);
	int screenX = loc[0];
	int screenY = loc[1];

	startDrag(b, screenX, screenY, 0, 0, b.getWidth(), b.getHeight(),
	source, dragInfo, dragAction);

	b.recycle();

	if (dragAction == DRAG_ACTION_MOVE) {
	v.setVisibility(View.GONE);
	}
	}

	/**
	* Starts a drag.
	*
	* @param b The bitmap to display as the drag image. It will be re-scaled to the
	* enlarged size.
	* @param screenX The x position on screen of the left-top of the bitmap.
	* @param screenY The y position on screen of the left-top of the bitmap.
	* @param textureLeft The left edge of the region inside b to use.
	* @param textureTop The top edge of the region inside b to use.
	* @param textureWidth The width of the region inside b to use.
	* @param textureHeight The height of the region inside b to use.
	* @param source An object representing where the drag originated
	* @param info The data associated with the object that is being dragged
	* @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
	* {@link #DRAG_ACTION_COPY}
	*/
	public void startDrag(Bitmap b, int screenX, int screenY,
	int textureLeft, int textureTop, int textureWidth, int textureHeight,
	DragSource source, Object dragInfo, int dragAction) {
	if (PROFILE_DRAWING_DURING_DRAG) {
	android.os.Debug.startMethodTracing("Launcher");
	}

	// Hide soft keyboard, if visible
	if (mInputMethodManager == null) {
	mInputMethodManager = (InputMethodManager)
	mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
	}
	mInputMethodManager.hideSoftInputFromWindow(mWindowToken, 0);

	if (mListener != null) {
	mListener.onDragStart(source, dragInfo, dragAction);
	}

	int registrationX = ((int)mMotionDownX) - screenX;
	int registrationY = ((int)mMotionDownY) - screenY;

	mTouchOffsetX = mMotionDownX - screenX;
	mTouchOffsetY = mMotionDownY - screenY;

	mDragging = true;
	mDragSource = source;
	mDragInfo = dragInfo;

	mVibrator.vibrate(VIBRATE_DURATION);

	DragView dragView = mDragView = new DragView(mContext, b, registrationX, registrationY,
	textureLeft, textureTop, textureWidth, textureHeight);
	dragView.show(mWindowToken, (int)mMotionDownX, (int)mMotionDownY);
	}

	/**
	* Draw the view into a bitmap.
	*/
	private Bitmap getViewBitmap(View v) {
	v.clearFocus();
	v.setPressed(false);

	boolean willNotCache = v.willNotCacheDrawing();
	v.setWillNotCacheDrawing(false);

	// Reset the drawing cache background color to fully transparent
	// for the duration of this operation
	int color = v.getDrawingCacheBackgroundColor();
	v.setDrawingCacheBackgroundColor(0);

	if (color != 0) {
	v.destroyDrawingCache();
	}
	v.buildDrawingCache();
	Bitmap cacheBitmap = v.getDrawingCache();

	Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);

	// Restore the view
	v.destroyDrawingCache();
	v.setWillNotCacheDrawing(willNotCache);
	v.setDrawingCacheBackgroundColor(color);

	return bitmap;
	}

	/**
	* Call this from a drag source view like this:
	*
	* <pre>
	* @Override
	* public boolean dispatchKeyEvent(KeyEvent event) {
	* return mDragController.dispatchKeyEvent(this, event)
	* \|\| super.dispatchKeyEvent(event);
	* </pre>
	*/
	public boolean dispatchKeyEvent(KeyEvent event) {
	return mDragging;
	}

	/**
	* Stop dragging without dropping.
	*/
	public void cancelDrag() {
	endDrag();
	}

	private void endDrag() {
	if (mDragging) {
	mDragging = false;
	if (mOriginator != null) {
	mOriginator.setVisibility(View.VISIBLE);
	}
	if (mListener != null) {
	mListener.onDragEnd();
	}
	if (mDragView != null) {
	mDragView.remove();
	mDragView = null;
	}
	}
	}

	/**
	* Call this from a drag source view.
	*/
	public boolean onInterceptTouchEvent(MotionEvent ev) {
	if (false) {
	Log.d(Launcher.TAG, "DragController.onInterceptTouchEvent " + ev + " mDragging="
	+ mDragging);
	}
	final int action = ev.getAction();

	if (action == MotionEvent.ACTION_DOWN) {
	recordScreenSize();
	}

	final int screenX = clamp((int)ev.getRawX(), 0, mDisplayMetrics.widthPixels);
	final int screenY = clamp((int)ev.getRawY(), 0, mDisplayMetrics.heightPixels);

	switch (action) {
	case MotionEvent.ACTION_MOVE:
	break;

	case MotionEvent.ACTION_DOWN:
	// Remember location of down touch
	mMotionDownX = screenX;
	mMotionDownY = screenY;
	mLastDropTarget = null;
	break;

	case MotionEvent.ACTION_CANCEL:
	case MotionEvent.ACTION_UP:
	if (mDragging) {
	drop(screenX, screenY);
	}
	endDrag();
	break;
	}

	return mDragging;
	}

	/**
	* Call this from a drag source view.
	*/
	public boolean onTouchEvent(MotionEvent ev) {
	View scrollView = mScrollView;

	if (!mDragging) {
	return false;
	}

	final int action = ev.getAction();
	final int screenX = clamp((int)ev.getRawX(), 0, mDisplayMetrics.widthPixels);
	final int screenY = clamp((int)ev.getRawY(), 0, mDisplayMetrics.heightPixels);

	switch (action) {
	case MotionEvent.ACTION_DOWN:
	// Remember where the motion event started
	mMotionDownX = screenX;
	mMotionDownY = screenY;

	if ((screenX < SCROLL_ZONE) \|\| (screenX > scrollView.getWidth() - SCROLL_ZONE)) {
	mScrollState = SCROLL_WAITING_IN_ZONE;
	mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
	} else {
	mScrollState = SCROLL_OUTSIDE_ZONE;
	}

	break;
	case MotionEvent.ACTION_MOVE:
	// Update the drag view. Don't use the clamped pos here so the dragging looks
	// like it goes off screen a little, intead of bumping up against the edge.
	mDragView.move((int)ev.getRawX(), (int)ev.getRawY());

	// Drop on someone?
	final int[] coordinates = mCoordinatesTemp;
	DropTarget dropTarget = findDropTarget((int) screenX, (int) screenY, coordinates);
	if (dropTarget != null) {
	if (mLastDropTarget == dropTarget) {
	dropTarget.onDragOver(mDragSource, coordinates[0], coordinates[1],
	(int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
	} else {
	if (mLastDropTarget != null) {
	mLastDropTarget.onDragExit(mDragSource, coordinates[0], coordinates[1],
	(int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
	}
	dropTarget.onDragEnter(mDragSource, coordinates[0], coordinates[1],
	(int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
	}
	} else {
	if (mLastDropTarget != null) {
	mLastDropTarget.onDragExit(mDragSource, coordinates[0], coordinates[1],
	(int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
	}
	}
	mLastDropTarget = dropTarget;

	// Scroll, maybe, but not if we're in the delete region.
	boolean inDeleteRegion = false;
	if (mDeleteRegion != null) {
	inDeleteRegion = mDeleteRegion.contains(screenX, screenY);
	}
	if (!inDeleteRegion && screenX < SCROLL_ZONE) {
	if (mScrollState == SCROLL_OUTSIDE_ZONE) {
	mScrollState = SCROLL_WAITING_IN_ZONE;
	mScrollRunnable.setDirection(SCROLL_LEFT);
	mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
	}
	} else if (!inDeleteRegion && screenX > scrollView.getWidth() - SCROLL_ZONE) {
	if (mScrollState == SCROLL_OUTSIDE_ZONE) {
	mScrollState = SCROLL_WAITING_IN_ZONE;
	mScrollRunnable.setDirection(SCROLL_RIGHT);
	mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
	}
	} else {
	if (mScrollState == SCROLL_WAITING_IN_ZONE) {
	mScrollState = SCROLL_OUTSIDE_ZONE;
	mScrollRunnable.setDirection(SCROLL_RIGHT);
	mHandler.removeCallbacks(mScrollRunnable);
	}
	}

	break;
	case MotionEvent.ACTION_UP:
	mHandler.removeCallbacks(mScrollRunnable);
	if (mDragging) {
	drop(screenX, screenY);
	}
	endDrag();

	break;
	case MotionEvent.ACTION_CANCEL:
	cancelDrag();
	}

	return true;
	}

	private boolean drop(float x, float y) {
	final int[] coordinates = mCoordinatesTemp;
	DropTarget dropTarget = findDropTarget((int) x, (int) y, coordinates);

	if (dropTarget != null) {
	dropTarget.onDragExit(mDragSource, coordinates[0], coordinates[1],
	(int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
	if (dropTarget.acceptDrop(mDragSource, coordinates[0], coordinates[1],
	(int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo)) {
	dropTarget.onDrop(mDragSource, coordinates[0], coordinates[1],
	(int) mTouchOffsetX, (int) mTouchOffsetY, mDragView, mDragInfo);
	mDragSource.onDropCompleted((View) dropTarget, true);
	return true;
	} else {
	mDragSource.onDropCompleted((View) dropTarget, false);
	return true;
	}
	}
	return false;
	}

	private DropTarget findDropTarget(int x, int y, int[] dropCoordinates) {
	final Rect r = mRectTemp;

	final ArrayList<DropTarget> dropTargets = mDropTargets;
	final int count = dropTargets.size();
	for (int i=count-1; i>=0; i--) {
	final DropTarget target = dropTargets.get(i);
	target.getHitRect(r);
	target.getLocationOnScreen(dropCoordinates);
	r.offset(dropCoordinates[0] - target.getLeft(), dropCoordinates[1] - target.getTop());
	if (r.contains(x, y)) {
	dropCoordinates[0] = x - dropCoordinates[0];
	dropCoordinates[1] = y - dropCoordinates[1];
	return target;
	}
	}
	return null;
	}

	/**
	* Get the screen size so we can clamp events to the screen size so even if
	* you drag off the edge of the screen, we find something.
	*/
	private void recordScreenSize() {
	((WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE))
	.getDefaultDisplay().getMetrics(mDisplayMetrics);
	}

	/**
	* Clamp val to be >= min and < max.
	*/
	private static int clamp(int val, int min, int max) {
	if (val < min) {
	return min;
	} else if (val >= max) {
	return max - 1;
	} else {
	return val;
	}
	}

	public void setDragScoller(DragScroller scroller) {
	mDragScroller = scroller;
	}

	public void setWindowToken(IBinder token) {
	mWindowToken = token;
	}

	/**
	* Sets the drag listner which will be notified when a drag starts or ends.
	*/
	public void setDragListener(DragListener l) {
	mListener = l;
	}

	/**
	* Remove a previously installed drag listener.
	*/
	public void removeDragListener(DragListener l) {
	mListener = null;
	}

	/**
	* Add a DropTarget to the list of potential places to receive drop events.
	*/
	public void addDropTarget(DropTarget target) {
	mDropTargets.add(target);
	}

	/**
	* Don't send drop events to <em>target</em> any more.
	*/
	public void removeDropTarget(DropTarget target) {
	mDropTargets.remove(target);
	}

	/**
	* Set which view scrolls for touch events near the edge of the screen.
	*/
	public void setScrollView(View v) {
	mScrollView = v;
	}

	/**
	* Specifies the delete region. We won't scroll on touch events over the delete region.
	*
	* @param region The rectangle in screen coordinates of the delete region.
	*/
	void setDeleteRegion(RectF region) {
	mDeleteRegion = region;
	}

	private class ScrollRunnable implements Runnable {
	private int mDirection;

	ScrollRunnable() {
	}

	public void run() {
	if (mDragScroller != null) {
	if (mDirection == SCROLL_LEFT) {
	mDragScroller.scrollLeft();
	} else {
	mDragScroller.scrollRight();
	}
	mScrollState = SCROLL_OUTSIDE_ZONE;
	}
	}

	void setDirection(int direction) {
	mDirection = direction;
	}
	}
	}