src/com/android/launcher2/DragLayer.java - fp2-dev/platform/packages/apps/Launcher2 - Gitiles

 /*
  * 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.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.TimeInterpolator;
 import android.animation.ValueAnimator;
 import android.animation.ValueAnimator.AnimatorUpdateListener;
 import android.content.Context;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Rect;
 import android.util.AttributeSet;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewParent;
 import android.view.animation.DecelerateInterpolator;
 import android.view.animation.Interpolator;
 import android.view.animation.LinearInterpolator;
 import android.widget.FrameLayout;
 import android.widget.ImageView;

 import com.android.launcher.R;

 import java.util.ArrayList;

 /**
  * A ViewGroup that coordinates dragging across its descendants
  */
 public class DragLayer extends FrameLayout {
     private DragController mDragController;
     private int[] mTmpXY = new int[2];

     private int mXDown, mYDown;
     private Launcher mLauncher;

     // Variables relating to resizing widgets
     private final ArrayList<AppWidgetResizeFrame> mResizeFrames =
             new ArrayList<AppWidgetResizeFrame>();
     private AppWidgetResizeFrame mCurrentResizeFrame;

     // Variables relating to animation of views after drop
     private ValueAnimator mDropAnim = null;
     private TimeInterpolator mQuintEaseOutInterpolator = new DecelerateInterpolator(2.5f);
     private View mDropView = null;
     private int[] mDropViewPos = new int[2];
     private float mDropViewScale;
     private float mDropViewAlpha;

     /**
      * Used to create a new DragLayer from XML.
      *
      * @param context The application's context.
      * @param attrs The attributes set containing the Workspace's customization values.
      */
     public DragLayer(Context context, AttributeSet attrs) {
         super(context, attrs);

         // Disable multitouch across the workspace/all apps/customize tray
         setMotionEventSplittingEnabled(false);
     }

     public void setup(Launcher launcher, DragController controller) {
         mLauncher = launcher;
         mDragController = controller;
     }

     @Override
     public boolean dispatchKeyEvent(KeyEvent event) {
         return mDragController.dispatchKeyEvent(event) || super.dispatchKeyEvent(event);
     }

     private boolean handleTouchDown(MotionEvent ev, boolean intercept) {
         Rect hitRect = new Rect();
         int x = (int) ev.getX();
         int y = (int) ev.getY();

         for (AppWidgetResizeFrame child: mResizeFrames) {
             child.getHitRect(hitRect);
             if (hitRect.contains(x, y)) {
                 if (child.beginResizeIfPointInRegion(x - child.getLeft(), y - child.getTop())) {
                     mCurrentResizeFrame = child;
                     mXDown = x;
                     mYDown = y;
                     requestDisallowInterceptTouchEvent(true);
                     return true;
                 }
             }
         }

         Folder currentFolder = mLauncher.getWorkspace().getOpenFolder();
         if (currentFolder != null && intercept) {
             if (currentFolder.isEditingName()) {
                 getDescendantRectRelativeToSelf(currentFolder.getEditTextRegion(), hitRect);
                 if (!hitRect.contains(x, y)) {
                     currentFolder.dismissEditingName();
                     return true;
                 }
             }

             getDescendantRectRelativeToSelf(currentFolder, hitRect);
             if (!hitRect.contains(x, y)) {
                 mLauncher.closeFolder();
                 return true;
             }
         }
         return false;
     }

     @Override
     public boolean onInterceptTouchEvent(MotionEvent ev) {
         if (ev.getAction() == MotionEvent.ACTION_DOWN) {
             if (handleTouchDown(ev, true)) {
                 return true;
             }
         }
         clearAllResizeFrames();
         return mDragController.onInterceptTouchEvent(ev);
     }

     @Override
     public boolean onTouchEvent(MotionEvent ev) {
         boolean handled = false;
         int action = ev.getAction();

         int x = (int) ev.getX();
         int y = (int) ev.getY();

         if (ev.getAction() == MotionEvent.ACTION_DOWN) {
             if (ev.getAction() == MotionEvent.ACTION_DOWN) {
                 if (handleTouchDown(ev, false)) {
                     return true;
                 }
             }
         }

         if (mCurrentResizeFrame != null) {
             handled = true;
             switch (action) {
                 case MotionEvent.ACTION_MOVE:
                     mCurrentResizeFrame.visualizeResizeForDelta(x - mXDown, y - mYDown);
                     break;
                 case MotionEvent.ACTION_CANCEL:
                 case MotionEvent.ACTION_UP:
                     mCurrentResizeFrame.commitResizeForDelta(x - mXDown, y - mYDown);
                     mCurrentResizeFrame = null;
             }
         }
         if (handled) return true;
         return mDragController.onTouchEvent(ev);
     }

     public void getDescendantRectRelativeToSelf(View descendant, Rect r) {
         descendant.getHitRect(r);
         mTmpXY[0] = 0;
         mTmpXY[1] = 0;
         getDescendantCoordRelativeToSelf(descendant, mTmpXY);
         r.offset(mTmpXY[0], mTmpXY[1]);
     }

     public void getDescendantCoordRelativeToSelf(View descendant, int[] coord) {
         ViewParent viewParent = descendant.getParent();
         while (viewParent instanceof View && viewParent != this) {
             final View view = (View)viewParent;
             coord[0] += view.getLeft() + (int) (view.getTranslationX() + 0.5f) - view.getScrollX();
             coord[1] += view.getTop() + (int) (view.getTranslationY() + 0.5f) - view.getScrollY();
             viewParent = view.getParent();
         }
     }

     public void getViewRectRelativeToSelf(View v, Rect r) {
         int[] loc = new int[2];
         getLocationOnScreen(loc);
         int x = loc[0];
         int y = loc[1];

         v.getLocationOnScreen(loc);
         int vX = loc[0];
         int vY = loc[1];

         int left = vX - x;
         int top = vY - y;
         r.set(left, top, left + v.getMeasuredWidth(), top + v.getMeasuredHeight());
     }

     @Override
     public boolean dispatchUnhandledMove(View focused, int direction) {
         return mDragController.dispatchUnhandledMove(focused, direction);
     }

     public View createDragView(Bitmap b, int xPos, int yPos) {
         ImageView imageView = new ImageView(mContext);
         imageView.setImageBitmap(b);
         imageView.setX(xPos);
         imageView.setY(yPos);
         addView(imageView, b.getWidth(), b.getHeight());

         return imageView;
     }

     public View createDragView(View v) {
         v.getLocationOnScreen(mTmpXY);
         return createDragView(mDragController.getViewBitmap(v), mTmpXY[0], mTmpXY[1]);
     }

     public static class LayoutParams extends FrameLayout.LayoutParams {
         public int x, y;
         public boolean customPosition = false;

         /**
          * {@inheritDoc}
          */
         public LayoutParams(int width, int height) {
             super(width, height);
         }

         public void setWidth(int width) {
             this.width = width;
         }

         public int getWidth() {
             return width;
         }

         public void setHeight(int height) {
             this.height = height;
         }

         public int getHeight() {
             return height;
         }

         public void setX(int x) {
             this.x = x;
         }

         public int getX() {
             return x;
         }

         public void setY(int y) {
             this.y = y;
         }

         public int getY() {
             return y;
         }
     }

     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         super.onLayout(changed, l, t, r, b);
         int count = getChildCount();
         for (int i = 0; i < count; i++) {
             View child = getChildAt(i);
             final FrameLayout.LayoutParams flp = (FrameLayout.LayoutParams) child.getLayoutParams();
             if (flp instanceof LayoutParams) {
                 final LayoutParams lp = (LayoutParams) flp;
                 if (lp.customPosition) {
                     child.layout(lp.x, lp.y, lp.x + lp.width, lp.y + lp.height);
                 }
             }
         }
     }

     public void clearAllResizeFrames() {
         if (mResizeFrames.size() > 0) {
             for (AppWidgetResizeFrame frame: mResizeFrames) {
                 removeView(frame);
             }
             mResizeFrames.clear();
         }
     }

     public boolean hasResizeFrames() {
         return mResizeFrames.size() > 0;
     }

     public boolean isWidgetBeingResized() {
         return mCurrentResizeFrame != null;
     }

     public void addResizeFrame(ItemInfo itemInfo, LauncherAppWidgetHostView widget,
             CellLayout cellLayout) {
         AppWidgetResizeFrame resizeFrame = new AppWidgetResizeFrame(getContext(),
                 itemInfo, widget, cellLayout, this);

         LayoutParams lp = new LayoutParams(-1, -1);
         lp.customPosition = true;

         addView(resizeFrame, lp);
         mResizeFrames.add(resizeFrame);

         resizeFrame.snapToWidget(false);
     }

     public void animateViewIntoPosition(DragView dragView, final View child) {
         ((CellLayoutChildren) child.getParent()).measureChild(child);
         CellLayout.LayoutParams lp =  (CellLayout.LayoutParams) child.getLayoutParams();

         Rect r = new Rect();
         getViewRectRelativeToSelf(dragView, r);

         int coord[] = new int[2];
         coord[0] = lp.x;
         coord[1] = lp.y;
         getDescendantCoordRelativeToSelf(child, coord);

         final int fromX = r.left + (dragView.getWidth() - child.getMeasuredWidth())  / 2;
         final int fromY = r.top + (dragView.getHeight() - child.getMeasuredHeight())  / 2;
         child.setVisibility(INVISIBLE);
         animateViewIntoPosition(child, fromX, fromY, coord[0], coord[1]);
     }

     private void animateViewIntoPosition(final View view, final int fromX, final int fromY,
             final int toX, final int toY) {
         Rect from = new Rect(fromX, fromY, fromX + view.getMeasuredWidth(), fromY + view.getMeasuredHeight());
         Rect to = new Rect(toX, toY, toX + view.getMeasuredWidth(), toY + view.getMeasuredHeight());
         animateView(view, from, to, 1f, -1);
     }

     public void animateView(final View view, final Rect from, final Rect to,
             final float finalAlpha, int duration) {
         animateView(view, from, to, finalAlpha, 1.0f, duration, null, null);
     }

     public void animateView(final View view, final Rect from, final Rect to, final float finalAlpha,
             final float finalScale, int duration, final Interpolator motionInterpolator,
             final Interpolator alphaInterpolator) {
         // Calculate the duration of the animation based on the object's distance
         final float dist = (float) Math.sqrt(Math.pow(to.left - from.left, 2) +
                 Math.pow(to.top - from.top, 2));
         final Resources res = getResources();
         final float maxDist = (float) res.getInteger(R.integer.config_dropAnimMaxDist);

         // If duration < 0, this is a cue to compute the duration based on the distance
         if (duration < 0) {
             duration = res.getInteger(R.integer.config_dropAnimMaxDuration);
             if (dist < maxDist) {
                 duration *= mQuintEaseOutInterpolator.getInterpolation(dist / maxDist);
             }
         }

         if (mDropAnim != null) {
             mDropAnim.end();
         }

         mDropView = view;
         final float initialAlpha = view.getAlpha();
         mDropAnim = new ValueAnimator();
         if (alphaInterpolator == null || motionInterpolator == null) {
             mDropAnim.setInterpolator(mQuintEaseOutInterpolator);
         }

         mDropAnim.setDuration(duration);
         mDropAnim.setFloatValues(0.0f, 1.0f);
         mDropAnim.removeAllUpdateListeners();
         mDropAnim.addUpdateListener(new AnimatorUpdateListener() {
             public void onAnimationUpdate(ValueAnimator animation) {
                 final float percent = (Float) animation.getAnimatedValue();
                 // Invalidate the old position
                 int width = view.getMeasuredWidth();
                 int height = view.getMeasuredHeight();
                 invalidate(mDropViewPos[0], mDropViewPos[1],
                         mDropViewPos[0] + width, mDropViewPos[1] + height);

                 float alphaPercent = alphaInterpolator == null ? percent :
                         alphaInterpolator.getInterpolation(percent);
                 float motionPercent = motionInterpolator == null ? percent :
                         motionInterpolator.getInterpolation(percent);

                 mDropViewPos[0] = from.left + (int) ((to.left - from.left) * motionPercent);
                 mDropViewPos[1] = from.top + (int) ((to.top - from.top) * motionPercent);
                 mDropViewScale = percent * finalScale + (1 - percent);
                 mDropViewAlpha = alphaPercent * finalAlpha + (1 - alphaPercent) * initialAlpha;
                 invalidate(mDropViewPos[0], mDropViewPos[1],
                         mDropViewPos[0] + width, mDropViewPos[1] + height);
             }
         });
         mDropAnim.addListener(new AnimatorListenerAdapter() {
             public void onAnimationEnd(Animator animation) {
                 if (mDropView != null) {
                     mDropView.setVisibility(View.VISIBLE);
                     mDropView = null;
                 }
             }
         });
         mDropAnim.start();
     }

     @Override
     protected void dispatchDraw(Canvas canvas) {
         super.dispatchDraw(canvas);
         if (mDropView != null) {
             // We are animating an item that was just dropped on the home screen.
             // Render its View in the current animation position.
             canvas.save(Canvas.MATRIX_SAVE_FLAG);
             final int xPos = mDropViewPos[0] - mDropView.getScrollX();
             final int yPos = mDropViewPos[1] - mDropView.getScrollY();
             int width = mDropView.getMeasuredWidth();
             int height = mDropView.getMeasuredHeight();
             canvas.translate(xPos, yPos);
             canvas.translate((1 - mDropViewScale) * width / 2, (1 - mDropViewScale) * height / 2);
             canvas.scale(mDropViewScale, mDropViewScale);
             mDropView.setAlpha(mDropViewAlpha);
             mDropView.draw(canvas);
             canvas.restore();
         }
     }
 }
	/*
	* 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.animation.Animator;
	import android.animation.AnimatorListenerAdapter;
	import android.animation.TimeInterpolator;
	import android.animation.ValueAnimator;
	import android.animation.ValueAnimator.AnimatorUpdateListener;
	import android.content.Context;
	import android.content.res.Resources;
	import android.graphics.Bitmap;
	import android.graphics.Canvas;
	import android.graphics.Rect;
	import android.util.AttributeSet;
	import android.view.KeyEvent;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.ViewParent;
	import android.view.animation.DecelerateInterpolator;
	import android.view.animation.Interpolator;
	import android.view.animation.LinearInterpolator;
	import android.widget.FrameLayout;
	import android.widget.ImageView;

	import com.android.launcher.R;

	import java.util.ArrayList;

	/**
	* A ViewGroup that coordinates dragging across its descendants
	*/
	public class DragLayer extends FrameLayout {
	private DragController mDragController;
	private int[] mTmpXY = new int[2];

	private int mXDown, mYDown;
	private Launcher mLauncher;

	// Variables relating to resizing widgets
	private final ArrayList<AppWidgetResizeFrame> mResizeFrames =
	new ArrayList<AppWidgetResizeFrame>();
	private AppWidgetResizeFrame mCurrentResizeFrame;

	// Variables relating to animation of views after drop
	private ValueAnimator mDropAnim = null;
	private TimeInterpolator mQuintEaseOutInterpolator = new DecelerateInterpolator(2.5f);
	private View mDropView = null;
	private int[] mDropViewPos = new int[2];
	private float mDropViewScale;
	private float mDropViewAlpha;

	/**
	* Used to create a new DragLayer from XML.
	*
	* @param context The application's context.
	* @param attrs The attributes set containing the Workspace's customization values.
	*/
	public DragLayer(Context context, AttributeSet attrs) {
	super(context, attrs);

	// Disable multitouch across the workspace/all apps/customize tray
	setMotionEventSplittingEnabled(false);
	}

	public void setup(Launcher launcher, DragController controller) {
	mLauncher = launcher;
	mDragController = controller;
	}

	@Override
	public boolean dispatchKeyEvent(KeyEvent event) {
	return mDragController.dispatchKeyEvent(event) \|\| super.dispatchKeyEvent(event);
	}

	private boolean handleTouchDown(MotionEvent ev, boolean intercept) {
	Rect hitRect = new Rect();
	int x = (int) ev.getX();
	int y = (int) ev.getY();

	for (AppWidgetResizeFrame child: mResizeFrames) {
	child.getHitRect(hitRect);
	if (hitRect.contains(x, y)) {
	if (child.beginResizeIfPointInRegion(x - child.getLeft(), y - child.getTop())) {
	mCurrentResizeFrame = child;
	mXDown = x;
	mYDown = y;
	requestDisallowInterceptTouchEvent(true);
	return true;
	}
	}
	}

	Folder currentFolder = mLauncher.getWorkspace().getOpenFolder();
	if (currentFolder != null && intercept) {
	if (currentFolder.isEditingName()) {
	getDescendantRectRelativeToSelf(currentFolder.getEditTextRegion(), hitRect);
	if (!hitRect.contains(x, y)) {
	currentFolder.dismissEditingName();
	return true;
	}
	}

	getDescendantRectRelativeToSelf(currentFolder, hitRect);
	if (!hitRect.contains(x, y)) {
	mLauncher.closeFolder();
	return true;
	}
	}
	return false;
	}

	@Override
	public boolean onInterceptTouchEvent(MotionEvent ev) {
	if (ev.getAction() == MotionEvent.ACTION_DOWN) {
	if (handleTouchDown(ev, true)) {
	return true;
	}
	}
	clearAllResizeFrames();
	return mDragController.onInterceptTouchEvent(ev);
	}

	@Override
	public boolean onTouchEvent(MotionEvent ev) {
	boolean handled = false;
	int action = ev.getAction();

	int x = (int) ev.getX();
	int y = (int) ev.getY();

	if (ev.getAction() == MotionEvent.ACTION_DOWN) {
	if (ev.getAction() == MotionEvent.ACTION_DOWN) {
	if (handleTouchDown(ev, false)) {
	return true;
	}
	}
	}

	if (mCurrentResizeFrame != null) {
	handled = true;
	switch (action) {
	case MotionEvent.ACTION_MOVE:
	mCurrentResizeFrame.visualizeResizeForDelta(x - mXDown, y - mYDown);
	break;
	case MotionEvent.ACTION_CANCEL:
	case MotionEvent.ACTION_UP:
	mCurrentResizeFrame.commitResizeForDelta(x - mXDown, y - mYDown);
	mCurrentResizeFrame = null;
	}
	}
	if (handled) return true;
	return mDragController.onTouchEvent(ev);
	}

	public void getDescendantRectRelativeToSelf(View descendant, Rect r) {
	descendant.getHitRect(r);
	mTmpXY[0] = 0;
	mTmpXY[1] = 0;
	getDescendantCoordRelativeToSelf(descendant, mTmpXY);
	r.offset(mTmpXY[0], mTmpXY[1]);
	}

	public void getDescendantCoordRelativeToSelf(View descendant, int[] coord) {
	ViewParent viewParent = descendant.getParent();
	while (viewParent instanceof View && viewParent != this) {
	final View view = (View)viewParent;
	coord[0] += view.getLeft() + (int) (view.getTranslationX() + 0.5f) - view.getScrollX();
	coord[1] += view.getTop() + (int) (view.getTranslationY() + 0.5f) - view.getScrollY();
	viewParent = view.getParent();
	}
	}

	public void getViewRectRelativeToSelf(View v, Rect r) {
	int[] loc = new int[2];
	getLocationOnScreen(loc);
	int x = loc[0];
	int y = loc[1];

	v.getLocationOnScreen(loc);
	int vX = loc[0];
	int vY = loc[1];

	int left = vX - x;
	int top = vY - y;
	r.set(left, top, left + v.getMeasuredWidth(), top + v.getMeasuredHeight());
	}

	@Override
	public boolean dispatchUnhandledMove(View focused, int direction) {
	return mDragController.dispatchUnhandledMove(focused, direction);
	}

	public View createDragView(Bitmap b, int xPos, int yPos) {
	ImageView imageView = new ImageView(mContext);
	imageView.setImageBitmap(b);
	imageView.setX(xPos);
	imageView.setY(yPos);
	addView(imageView, b.getWidth(), b.getHeight());

	return imageView;
	}

	public View createDragView(View v) {
	v.getLocationOnScreen(mTmpXY);
	return createDragView(mDragController.getViewBitmap(v), mTmpXY[0], mTmpXY[1]);
	}

	public static class LayoutParams extends FrameLayout.LayoutParams {
	public int x, y;
	public boolean customPosition = false;

	/**
	* {@inheritDoc}
	*/
	public LayoutParams(int width, int height) {
	super(width, height);
	}

	public void setWidth(int width) {
	this.width = width;
	}

	public int getWidth() {
	return width;
	}

	public void setHeight(int height) {
	this.height = height;
	}

	public int getHeight() {
	return height;
	}

	public void setX(int x) {
	this.x = x;
	}

	public int getX() {
	return x;
	}

	public void setY(int y) {
	this.y = y;
	}

	public int getY() {
	return y;
	}
	}

	protected void onLayout(boolean changed, int l, int t, int r, int b) {
	super.onLayout(changed, l, t, r, b);
	int count = getChildCount();
	for (int i = 0; i < count; i++) {
	View child = getChildAt(i);
	final FrameLayout.LayoutParams flp = (FrameLayout.LayoutParams) child.getLayoutParams();
	if (flp instanceof LayoutParams) {
	final LayoutParams lp = (LayoutParams) flp;
	if (lp.customPosition) {
	child.layout(lp.x, lp.y, lp.x + lp.width, lp.y + lp.height);
	}
	}
	}
	}

	public void clearAllResizeFrames() {
	if (mResizeFrames.size() > 0) {
	for (AppWidgetResizeFrame frame: mResizeFrames) {
	removeView(frame);
	}
	mResizeFrames.clear();
	}
	}

	public boolean hasResizeFrames() {
	return mResizeFrames.size() > 0;
	}

	public boolean isWidgetBeingResized() {
	return mCurrentResizeFrame != null;
	}

	public void addResizeFrame(ItemInfo itemInfo, LauncherAppWidgetHostView widget,
	CellLayout cellLayout) {
	AppWidgetResizeFrame resizeFrame = new AppWidgetResizeFrame(getContext(),
	itemInfo, widget, cellLayout, this);

	LayoutParams lp = new LayoutParams(-1, -1);
	lp.customPosition = true;

	addView(resizeFrame, lp);
	mResizeFrames.add(resizeFrame);

	resizeFrame.snapToWidget(false);
	}

	public void animateViewIntoPosition(DragView dragView, final View child) {
	((CellLayoutChildren) child.getParent()).measureChild(child);
	CellLayout.LayoutParams lp = (CellLayout.LayoutParams) child.getLayoutParams();

	Rect r = new Rect();
	getViewRectRelativeToSelf(dragView, r);

	int coord[] = new int[2];
	coord[0] = lp.x;
	coord[1] = lp.y;
	getDescendantCoordRelativeToSelf(child, coord);

	final int fromX = r.left + (dragView.getWidth() - child.getMeasuredWidth()) / 2;
	final int fromY = r.top + (dragView.getHeight() - child.getMeasuredHeight()) / 2;
	child.setVisibility(INVISIBLE);
	animateViewIntoPosition(child, fromX, fromY, coord[0], coord[1]);
	}

	private void animateViewIntoPosition(final View view, final int fromX, final int fromY,
	final int toX, final int toY) {
	Rect from = new Rect(fromX, fromY, fromX + view.getMeasuredWidth(), fromY + view.getMeasuredHeight());
	Rect to = new Rect(toX, toY, toX + view.getMeasuredWidth(), toY + view.getMeasuredHeight());
	animateView(view, from, to, 1f, -1);
	}

	public void animateView(final View view, final Rect from, final Rect to,
	final float finalAlpha, int duration) {
	animateView(view, from, to, finalAlpha, 1.0f, duration, null, null);
	}

	public void animateView(final View view, final Rect from, final Rect to, final float finalAlpha,
	final float finalScale, int duration, final Interpolator motionInterpolator,
	final Interpolator alphaInterpolator) {
	// Calculate the duration of the animation based on the object's distance
	final float dist = (float) Math.sqrt(Math.pow(to.left - from.left, 2) +
	Math.pow(to.top - from.top, 2));
	final Resources res = getResources();
	final float maxDist = (float) res.getInteger(R.integer.config_dropAnimMaxDist);

	// If duration < 0, this is a cue to compute the duration based on the distance
	if (duration < 0) {
	duration = res.getInteger(R.integer.config_dropAnimMaxDuration);
	if (dist < maxDist) {
	duration *= mQuintEaseOutInterpolator.getInterpolation(dist / maxDist);
	}
	}

	if (mDropAnim != null) {
	mDropAnim.end();
	}

	mDropView = view;
	final float initialAlpha = view.getAlpha();
	mDropAnim = new ValueAnimator();
	if (alphaInterpolator == null \|\| motionInterpolator == null) {
	mDropAnim.setInterpolator(mQuintEaseOutInterpolator);
	}

	mDropAnim.setDuration(duration);
	mDropAnim.setFloatValues(0.0f, 1.0f);
	mDropAnim.removeAllUpdateListeners();
	mDropAnim.addUpdateListener(new AnimatorUpdateListener() {
	public void onAnimationUpdate(ValueAnimator animation) {
	final float percent = (Float) animation.getAnimatedValue();
	// Invalidate the old position
	int width = view.getMeasuredWidth();
	int height = view.getMeasuredHeight();
	invalidate(mDropViewPos[0], mDropViewPos[1],
	mDropViewPos[0] + width, mDropViewPos[1] + height);

	float alphaPercent = alphaInterpolator == null ? percent :
	alphaInterpolator.getInterpolation(percent);
	float motionPercent = motionInterpolator == null ? percent :
	motionInterpolator.getInterpolation(percent);

	mDropViewPos[0] = from.left + (int) ((to.left - from.left) * motionPercent);
	mDropViewPos[1] = from.top + (int) ((to.top - from.top) * motionPercent);
	mDropViewScale = percent * finalScale + (1 - percent);
	mDropViewAlpha = alphaPercent * finalAlpha + (1 - alphaPercent) * initialAlpha;
	invalidate(mDropViewPos[0], mDropViewPos[1],
	mDropViewPos[0] + width, mDropViewPos[1] + height);
	}
	});
	mDropAnim.addListener(new AnimatorListenerAdapter() {
	public void onAnimationEnd(Animator animation) {
	if (mDropView != null) {
	mDropView.setVisibility(View.VISIBLE);
	mDropView = null;
	}
	}
	});
	mDropAnim.start();
	}

	@Override
	protected void dispatchDraw(Canvas canvas) {
	super.dispatchDraw(canvas);
	if (mDropView != null) {
	// We are animating an item that was just dropped on the home screen.
	// Render its View in the current animation position.
	canvas.save(Canvas.MATRIX_SAVE_FLAG);
	final int xPos = mDropViewPos[0] - mDropView.getScrollX();
	final int yPos = mDropViewPos[1] - mDropView.getScrollY();
	int width = mDropView.getMeasuredWidth();
	int height = mDropView.getMeasuredHeight();
	canvas.translate(xPos, yPos);
	canvas.translate((1 - mDropViewScale) * width / 2, (1 - mDropViewScale) * height / 2);
	canvas.scale(mDropViewScale, mDropViewScale);
	mDropView.setAlpha(mDropViewAlpha);
	mDropView.draw(canvas);
	canvas.restore();
	}
	}
	}